"cmd/compile/internal/ssa.Location %v": "",
"cmd/compile/internal/ssa.Op %s": "",
"cmd/compile/internal/ssa.Op %v": "",
- "cmd/compile/internal/ssa.SizeAndAlign %s": "",
"cmd/compile/internal/ssa.Type %s": "",
"cmd/compile/internal/ssa.Type %v": "",
"cmd/compile/internal/ssa.ValAndOff %s": "",
return s.curBlock.NewValue3I(s.peekPos(), op, t, aux, arg0, arg1, arg2)
}
+// newValue3A adds a new value with three arguments and an aux value to the current block.
+func (s *state) newValue3A(op ssa.Op, t ssa.Type, aux interface{}, arg0, arg1, arg2 *ssa.Value) *ssa.Value {
+ return s.curBlock.NewValue3A(s.peekPos(), op, t, aux, arg0, arg1, arg2)
+}
+
// newValue4 adds a new value with four arguments to the current block.
func (s *state) newValue4(op ssa.Op, t ssa.Type, arg0, arg1, arg2, arg3 *ssa.Value) *ssa.Value {
return s.curBlock.NewValue4(s.peekPos(), op, t, arg0, arg1, arg2, arg3)
addr := s.decladdrs[n]
val := s.variable(n, n.Type)
s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, n, s.mem())
- store := s.newValue3I(ssa.OpStore, ssa.TypeMem, n.Type.Size(), addr, val, s.mem())
- store.Aux = n.Type
- s.vars[&memVar] = store
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, n.Type, addr, val, s.mem())
// TODO: if val is ever spilled, we'd like to use the
// PPARAMOUT slot for spilling it. That won't happen
// currently.
s.vars[&memVar] = s.newValue1A(ssa.OpVarDef, ssa.TypeMem, sn, s.mem())
}
capaddr := s.newValue1I(ssa.OpOffPtr, ptrto(Types[TINT]), int64(array_cap), addr)
- store := s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.IntSize, capaddr, r[2], s.mem())
- store.Aux = Types[TINT]
- s.vars[&memVar] = store
- store = s.newValue3I(ssa.OpStore, ssa.TypeMem, pt.Size(), addr, r[0], s.mem())
- store.Aux = pt
- s.vars[&memVar] = store
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, Types[TINT], capaddr, r[2], s.mem())
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, pt, addr, r[0], s.mem())
// load the value we just stored to avoid having to spill it
s.vars[&ptrVar] = s.newValue2(ssa.OpLoad, pt, addr, s.mem())
s.vars[&lenVar] = r[1] // avoid a spill in the fast path
l = s.variable(&lenVar, Types[TINT]) // generates phi for len
nl = s.newValue2(s.ssaOp(OADD, Types[TINT]), Types[TINT], l, s.constInt(Types[TINT], nargs))
lenaddr := s.newValue1I(ssa.OpOffPtr, ptrto(Types[TINT]), int64(array_nel), addr)
- store := s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.IntSize, lenaddr, nl, s.mem())
- store.Aux = Types[TINT]
- s.vars[&memVar] = store
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, Types[TINT], lenaddr, nl, s.mem())
}
// Evaluate args
if arg.store {
s.storeType(et, addr, arg.v, 0)
} else {
- store := s.newValue3I(ssa.OpMove, ssa.TypeMem, sizeAlignAuxInt(et), addr, arg.v, s.mem())
+ store := s.newValue3I(ssa.OpMove, ssa.TypeMem, et.Size(), addr, arg.v, s.mem())
store.Aux = et
s.vars[&memVar] = store
}
// Treat as a mem->mem move.
var store *ssa.Value
if right == nil {
- store = s.newValue2I(ssa.OpZero, ssa.TypeMem, sizeAlignAuxInt(t), addr, s.mem())
+ store = s.newValue2I(ssa.OpZero, ssa.TypeMem, t.Size(), addr, s.mem())
} else {
- store = s.newValue3I(ssa.OpMove, ssa.TypeMem, sizeAlignAuxInt(t), addr, right, s.mem())
+ store = s.newValue3I(ssa.OpMove, ssa.TypeMem, t.Size(), addr, right, s.mem())
}
store.Aux = t
s.vars[&memVar] = store
argStart += int64(2 * Widthptr)
}
addr := s.constOffPtrSP(ptrto(Types[TUINTPTR]), argStart)
- store := s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), addr, rcvr, s.mem())
- store.Aux = Types[TUINTPTR]
- s.vars[&memVar] = store
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, Types[TUINTPTR], addr, rcvr, s.mem())
}
// Defer/go args
argStart := Ctxt.FixedFrameSize()
argsize := s.constInt32(Types[TUINT32], int32(stksize))
addr := s.constOffPtrSP(ptrto(Types[TUINT32]), argStart)
- store := s.newValue3I(ssa.OpStore, ssa.TypeMem, 4, addr, argsize, s.mem())
- store.Aux = Types[TUINT32]
- s.vars[&memVar] = store
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, Types[TUINT32], addr, argsize, s.mem())
addr = s.constOffPtrSP(ptrto(Types[TUINTPTR]), argStart+int64(Widthptr))
- store = s.newValue3I(ssa.OpStore, ssa.TypeMem, int64(Widthptr), addr, closure, s.mem())
- store.Aux = Types[TUINTPTR]
- s.vars[&memVar] = store
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, Types[TUINTPTR], addr, closure, s.mem())
stksize += 2 * int64(Widthptr)
}
off = Rnd(off, t.Alignment())
ptr := s.constOffPtrSP(t.PtrTo(), off)
size := t.Size()
- store := s.newValue3I(ssa.OpStore, ssa.TypeMem, size, ptr, arg, s.mem())
- store.Aux = t
- s.vars[&memVar] = store
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, t, ptr, arg, s.mem())
off += size
}
off = Rnd(off, int64(Widthptr))
func (s *state) storeTypeScalars(t *Type, left, right *ssa.Value, skip skipMask) {
switch {
case t.IsBoolean() || t.IsInteger() || t.IsFloat() || t.IsComplex():
- store := s.newValue3I(ssa.OpStore, ssa.TypeMem, t.Size(), left, right, s.mem())
- store.Aux = t
- s.vars[&memVar] = store
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, t, left, right, s.mem())
case t.IsPtrShaped():
// no scalar fields.
case t.IsString():
}
len := s.newValue1(ssa.OpStringLen, Types[TINT], right)
lenAddr := s.newValue1I(ssa.OpOffPtr, ptrto(Types[TINT]), s.config.IntSize, left)
- store := s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.IntSize, lenAddr, len, s.mem())
- store.Aux = Types[TINT]
- s.vars[&memVar] = store
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, Types[TINT], lenAddr, len, s.mem())
case t.IsSlice():
if skip&skipLen == 0 {
len := s.newValue1(ssa.OpSliceLen, Types[TINT], right)
lenAddr := s.newValue1I(ssa.OpOffPtr, ptrto(Types[TINT]), s.config.IntSize, left)
- store := s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.IntSize, lenAddr, len, s.mem())
- store.Aux = Types[TINT]
- s.vars[&memVar] = store
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, Types[TINT], lenAddr, len, s.mem())
}
if skip&skipCap == 0 {
cap := s.newValue1(ssa.OpSliceCap, Types[TINT], right)
capAddr := s.newValue1I(ssa.OpOffPtr, ptrto(Types[TINT]), 2*s.config.IntSize, left)
- store := s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.IntSize, capAddr, cap, s.mem())
- store.Aux = Types[TINT]
- s.vars[&memVar] = store
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, Types[TINT], capAddr, cap, s.mem())
}
case t.IsInterface():
// itab field doesn't need a write barrier (even though it is a pointer).
itab := s.newValue1(ssa.OpITab, ptrto(Types[TUINT8]), right)
- store := s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.IntSize, left, itab, s.mem())
- store.Aux = Types[TUINTPTR]
- s.vars[&memVar] = store
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, Types[TUINTPTR], left, itab, s.mem())
case t.IsStruct():
n := t.NumFields()
for i := 0; i < n; i++ {
func (s *state) storeTypePtrs(t *Type, left, right *ssa.Value) {
switch {
case t.IsPtrShaped():
- store := s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.PtrSize, left, right, s.mem())
- store.Aux = t
- s.vars[&memVar] = store
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, t, left, right, s.mem())
case t.IsString():
ptr := s.newValue1(ssa.OpStringPtr, ptrto(Types[TUINT8]), right)
- store := s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.PtrSize, left, ptr, s.mem())
- store.Aux = ptrto(Types[TUINT8])
- s.vars[&memVar] = store
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, ptrto(Types[TUINT8]), left, ptr, s.mem())
case t.IsSlice():
ptr := s.newValue1(ssa.OpSlicePtr, ptrto(Types[TUINT8]), right)
- store := s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.PtrSize, left, ptr, s.mem())
- store.Aux = ptrto(Types[TUINT8])
- s.vars[&memVar] = store
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, ptrto(Types[TUINT8]), left, ptr, s.mem())
case t.IsInterface():
// itab field is treated as a scalar.
idata := s.newValue1(ssa.OpIData, ptrto(Types[TUINT8]), right)
idataAddr := s.newValue1I(ssa.OpOffPtr, ptrto(ptrto(Types[TUINT8])), s.config.PtrSize, left)
- store := s.newValue3I(ssa.OpStore, ssa.TypeMem, s.config.PtrSize, idataAddr, idata, s.mem())
- store.Aux = ptrto(Types[TUINT8])
- s.vars[&memVar] = store
+ s.vars[&memVar] = s.newValue3A(ssa.OpStore, ssa.TypeMem, ptrto(Types[TUINT8]), idataAddr, idata, s.mem())
case t.IsStruct():
n := t.NumFields()
for i := 0; i < n; i++ {
}
} else {
p := s.newValue1(ssa.OpIData, ptrto(n.Type), iface)
- store := s.newValue3I(ssa.OpMove, ssa.TypeMem, sizeAlignAuxInt(n.Type), addr, p, s.mem())
+ store := s.newValue3I(ssa.OpMove, ssa.TypeMem, n.Type.Size(), addr, p, s.mem())
store.Aux = n.Type
s.vars[&memVar] = store
}
if tmp == nil {
s.vars[valVar] = s.zeroVal(n.Type)
} else {
- store := s.newValue2I(ssa.OpZero, ssa.TypeMem, sizeAlignAuxInt(n.Type), addr, s.mem())
+ store := s.newValue2I(ssa.OpZero, ssa.TypeMem, n.Type.Size(), addr, s.mem())
store.Aux = n.Type
s.vars[&memVar] = store
}
}
}
-// sizeAlignAuxInt returns an AuxInt encoding the size and alignment of type t.
-func sizeAlignAuxInt(t *Type) int64 {
- return ssa.MakeSizeAndAlign(t.Size(), t.Alignment()).Int64()
-}
-
// extendIndex extends v to a full int width.
// panic using the given function if v does not fit in an int (only on 32-bit archs).
func (s *state) extendIndex(v *ssa.Value, panicfn *obj.LSym) *ssa.Value {
if !isExactFloat32(v) {
f.Fatalf("value %v has an AuxInt value that is not an exact float32", v)
}
- case auxSizeAndAlign:
- canHaveAuxInt = true
- case auxString, auxSym:
+ case auxString, auxSym, auxTyp:
canHaveAux = true
- case auxSymOff, auxSymValAndOff, auxSymSizeAndAlign:
+ case auxSymOff, auxSymValAndOff, auxTypSize:
canHaveAuxInt = true
canHaveAux = true
case auxSymInt32:
Valu("r3", OpAdd64, TypeInt64, 0, nil, "arg1", "arg2"),
Valu("r5", OpAdd64, TypeInt64, 0, nil, "r2", "r3"),
Valu("r10", OpAdd64, TypeInt64, 0, nil, "r6", "r9"),
- Valu("rstore", OpStore, TypeMem, 8, nil, "raddr", "r10", "raddrdef"),
+ Valu("rstore", OpStore, TypeMem, 0, TypeInt64, "raddr", "r10", "raddrdef"),
Goto("exit")),
Bloc("exit",
Exit("rstore")))
Valu("r3", OpAdd64, TypeInt64, 0, nil, "r1", "r2"),
Valu("raddr", OpAddr, TypeInt64Ptr, 0, nil, "sp"),
Valu("raddrdef", OpVarDef, TypeMem, 0, nil, "start"),
- Valu("rstore", OpStore, TypeMem, 8, nil, "raddr", "r3", "raddrdef"),
+ Valu("rstore", OpStore, TypeMem, 0, TypeInt64, "raddr", "r3", "raddrdef"),
Goto("exit")),
Bloc("exit",
Exit("rstore")))
if v.Op == OpStore || v.Op == OpZero {
var sz int64
if v.Op == OpStore {
- sz = v.AuxInt
+ sz = v.Aux.(Type).Size()
} else { // OpZero
- sz = SizeAndAlign(v.AuxInt).Size()
+ sz = v.AuxInt
}
if shadowedSize := int64(shadowed.get(v.Args[0].ID)); shadowedSize != -1 && shadowedSize >= sz {
// Modify store into a copy
Valu("addr1", OpAddr, ptrType, 0, nil, "sb"),
Valu("addr2", OpAddr, ptrType, 0, nil, "sb"),
Valu("addr3", OpAddr, ptrType, 0, nil, "sb"),
- Valu("zero1", OpZero, TypeMem, 1, nil, "addr3", "start"),
- Valu("store1", OpStore, TypeMem, 1, nil, "addr1", "v", "zero1"),
- Valu("store2", OpStore, TypeMem, 1, nil, "addr2", "v", "store1"),
- Valu("store3", OpStore, TypeMem, 1, nil, "addr1", "v", "store2"),
- Valu("store4", OpStore, TypeMem, 1, nil, "addr3", "v", "store3"),
+ Valu("zero1", OpZero, TypeMem, 1, TypeBool, "addr3", "start"),
+ Valu("store1", OpStore, TypeMem, 0, TypeBool, "addr1", "v", "zero1"),
+ Valu("store2", OpStore, TypeMem, 0, TypeBool, "addr2", "v", "store1"),
+ Valu("store3", OpStore, TypeMem, 0, TypeBool, "addr1", "v", "store2"),
+ Valu("store4", OpStore, TypeMem, 0, TypeBool, "addr3", "v", "store3"),
Goto("exit")),
Bloc("exit",
Exit("store3")))
Goto("loop")),
Bloc("loop",
Valu("phi", OpPhi, TypeMem, 0, nil, "start", "store"),
- Valu("store", OpStore, TypeMem, 1, nil, "addr", "v", "phi"),
+ Valu("store", OpStore, TypeMem, 0, TypeBool, "addr", "v", "phi"),
If("v", "loop", "exit")),
Bloc("exit",
Exit("store")))
Valu("v", OpConstBool, TypeBool, 1, nil),
Valu("addr1", OpAddr, t1, 0, nil, "sb"),
Valu("addr2", OpAddr, t2, 0, nil, "sb"),
- Valu("store1", OpStore, TypeMem, 1, nil, "addr1", "v", "start"),
- Valu("store2", OpStore, TypeMem, 1, nil, "addr2", "v", "store1"),
+ Valu("store1", OpStore, TypeMem, 0, TypeBool, "addr1", "v", "start"),
+ Valu("store2", OpStore, TypeMem, 0, TypeBool, "addr2", "v", "store1"),
Goto("exit")),
Bloc("exit",
Exit("store2")))
Valu("sb", OpSB, TypeInvalid, 0, nil),
Valu("v", OpConstBool, TypeBool, 1, nil),
Valu("addr1", OpAddr, ptrType, 0, nil, "sb"),
- Valu("store1", OpStore, TypeMem, 8, nil, "addr1", "v", "start"), // store 8 bytes
- Valu("store2", OpStore, TypeMem, 1, nil, "addr1", "v", "store1"), // store 1 byte
+ Valu("store1", OpStore, TypeMem, 0, TypeInt64, "addr1", "v", "start"), // store 8 bytes
+ Valu("store2", OpStore, TypeMem, 0, TypeBool, "addr1", "v", "store1"), // store 1 byte
Goto("exit")),
Bloc("exit",
Exit("store2")))
return v
}
+// 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 Type, aux interface{}, arg0, arg1, arg2 *Value) *Value {
+ v := b.Func.newValue(op, t, b, pos)
+ v.AuxInt = 0
+ v.Aux = aux
+ v.Args = v.argstorage[:3]
+ v.argstorage[0] = arg0
+ v.argstorage[1] = arg1
+ v.argstorage[2] = arg2
+ arg0.Uses++
+ arg1.Uses++
+ arg2.Uses++
+ return v
+}
+
// 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 Type, arg0, arg1, arg2, arg3 *Value) *Value {
v := b.Func.newValue(op, t, b, pos)
// Lowering stores
// These more-specific FP versions of Store pattern should come first.
-(Store [8] ptr val mem) && is64BitFloat(val.Type) -> (MOVSDstore ptr val mem)
-(Store [4] ptr val mem) && is32BitFloat(val.Type) -> (MOVSSstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 8 && is64BitFloat(val.Type) -> (MOVSDstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 4 && is32BitFloat(val.Type) -> (MOVSSstore ptr val mem)
-(Store [4] ptr val mem) -> (MOVLstore ptr val mem)
-(Store [2] ptr val mem) -> (MOVWstore ptr val mem)
-(Store [1] ptr val mem) -> (MOVBstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 4 -> (MOVLstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 2 -> (MOVWstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 1 -> (MOVBstore ptr val mem)
// Lowering moves
-(Move [s] _ _ mem) && SizeAndAlign(s).Size() == 0 -> mem
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstore dst (MOVBload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 2 -> (MOVWstore dst (MOVWload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 -> (MOVLstore dst (MOVLload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 3 ->
+(Move [0] _ _ mem) -> mem
+(Move [1] dst src mem) -> (MOVBstore dst (MOVBload src mem) mem)
+(Move [2] dst src mem) -> (MOVWstore dst (MOVWload src mem) mem)
+(Move [4] dst src mem) -> (MOVLstore dst (MOVLload src mem) mem)
+(Move [3] dst src mem) ->
(MOVBstore [2] dst (MOVBload [2] src mem)
(MOVWstore dst (MOVWload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 5 ->
+(Move [5] dst src mem) ->
(MOVBstore [4] dst (MOVBload [4] src mem)
(MOVLstore dst (MOVLload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 6 ->
+(Move [6] dst src mem) ->
(MOVWstore [4] dst (MOVWload [4] src mem)
(MOVLstore dst (MOVLload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 7 ->
+(Move [7] dst src mem) ->
(MOVLstore [3] dst (MOVLload [3] src mem)
(MOVLstore dst (MOVLload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 8 ->
+(Move [8] dst src mem) ->
(MOVLstore [4] dst (MOVLload [4] src mem)
(MOVLstore dst (MOVLload src mem) mem))
// Adjust moves to be a multiple of 4 bytes.
(Move [s] dst src mem)
- && SizeAndAlign(s).Size() > 8 && SizeAndAlign(s).Size()%4 != 0 ->
- (Move [SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%4]
- (ADDLconst <dst.Type> dst [SizeAndAlign(s).Size()%4])
- (ADDLconst <src.Type> src [SizeAndAlign(s).Size()%4])
+ && s > 8 && s%4 != 0 ->
+ (Move [s-s%4]
+ (ADDLconst <dst.Type> dst [s%4])
+ (ADDLconst <src.Type> src [s%4])
(MOVLstore dst (MOVLload src mem) mem))
// Medium copying uses a duff device.
(Move [s] dst src mem)
- && SizeAndAlign(s).Size() > 8 && SizeAndAlign(s).Size() <= 4*128 && SizeAndAlign(s).Size()%4 == 0
+ && s > 8 && s <= 4*128 && s%4 == 0
&& !config.noDuffDevice ->
- (DUFFCOPY [10*(128-SizeAndAlign(s).Size()/4)] dst src mem)
+ (DUFFCOPY [10*(128-s/4)] dst src mem)
// 10 and 128 are magic constants. 10 is the number of bytes to encode:
// MOVL (SI), CX
// ADDL $4, SI
// and 128 is the number of such blocks. See src/runtime/duff_386.s:duffcopy.
// Large copying uses REP MOVSL.
-(Move [s] dst src mem) && (SizeAndAlign(s).Size() > 4*128 || config.noDuffDevice) && SizeAndAlign(s).Size()%4 == 0 ->
- (REPMOVSL dst src (MOVLconst [SizeAndAlign(s).Size()/4]) mem)
+(Move [s] dst src mem) && (s > 4*128 || config.noDuffDevice) && s%4 == 0 ->
+ (REPMOVSL dst src (MOVLconst [s/4]) mem)
// Lowering Zero instructions
-(Zero [s] _ mem) && SizeAndAlign(s).Size() == 0 -> mem
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstoreconst [0] destptr mem)
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 2 -> (MOVWstoreconst [0] destptr mem)
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 4 -> (MOVLstoreconst [0] destptr mem)
+(Zero [0] _ mem) -> mem
+(Zero [1] destptr mem) -> (MOVBstoreconst [0] destptr mem)
+(Zero [2] destptr mem) -> (MOVWstoreconst [0] destptr mem)
+(Zero [4] destptr mem) -> (MOVLstoreconst [0] destptr mem)
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 3 ->
+(Zero [3] destptr mem) ->
(MOVBstoreconst [makeValAndOff(0,2)] destptr
(MOVWstoreconst [0] destptr mem))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 5 ->
+(Zero [5] destptr mem) ->
(MOVBstoreconst [makeValAndOff(0,4)] destptr
(MOVLstoreconst [0] destptr mem))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 6 ->
+(Zero [6] destptr mem) ->
(MOVWstoreconst [makeValAndOff(0,4)] destptr
(MOVLstoreconst [0] destptr mem))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 7 ->
+(Zero [7] destptr mem) ->
(MOVLstoreconst [makeValAndOff(0,3)] destptr
(MOVLstoreconst [0] destptr mem))
// Strip off any fractional word zeroing.
-(Zero [s] destptr mem) && SizeAndAlign(s).Size()%4 != 0 && SizeAndAlign(s).Size() > 4 ->
- (Zero [SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%4] (ADDLconst destptr [SizeAndAlign(s).Size()%4])
+(Zero [s] destptr mem) && s%4 != 0 && s > 4 ->
+ (Zero [s-s%4] (ADDLconst destptr [s%4])
(MOVLstoreconst [0] destptr mem))
// Zero small numbers of words directly.
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 8 ->
+(Zero [8] destptr mem) ->
(MOVLstoreconst [makeValAndOff(0,4)] destptr
(MOVLstoreconst [0] destptr mem))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 12 ->
+(Zero [12] destptr mem) ->
(MOVLstoreconst [makeValAndOff(0,8)] destptr
(MOVLstoreconst [makeValAndOff(0,4)] destptr
(MOVLstoreconst [0] destptr mem)))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 16 ->
+(Zero [16] destptr mem) ->
(MOVLstoreconst [makeValAndOff(0,12)] destptr
(MOVLstoreconst [makeValAndOff(0,8)] destptr
(MOVLstoreconst [makeValAndOff(0,4)] destptr
// Medium zeroing uses a duff device.
(Zero [s] destptr mem)
- && SizeAndAlign(s).Size() > 16
- && SizeAndAlign(s).Size() <= 4*128
- && SizeAndAlign(s).Size()%4 == 0
+ && s > 16 && s <= 4*128 && s%4 == 0
&& !config.noDuffDevice ->
- (DUFFZERO [1*(128-SizeAndAlign(s).Size()/4)] destptr (MOVLconst [0]) mem)
+ (DUFFZERO [1*(128-s/4)] destptr (MOVLconst [0]) mem)
// 1 and 128 are magic constants. 1 is the number of bytes to encode STOSL.
// 128 is the number of STOSL instructions in duffzero.
// See src/runtime/duff_386.s:duffzero.
// Large zeroing uses REP STOSQ.
(Zero [s] destptr mem)
- && (SizeAndAlign(s).Size() > 4*128 || (config.noDuffDevice && SizeAndAlign(s).Size() > 16))
- && SizeAndAlign(s).Size()%4 == 0 ->
- (REPSTOSL destptr (MOVLconst [SizeAndAlign(s).Size()/4]) (MOVLconst [0]) mem)
+ && (s > 4*128 || (config.noDuffDevice && s > 16))
+ && s%4 == 0 ->
+ (REPSTOSL destptr (MOVLconst [s/4]) (MOVLconst [0]) mem)
// Lowering constants
(Const8 [val]) -> (MOVLconst [val])
// Lowering stores
// These more-specific FP versions of Store pattern should come first.
-(Store [8] ptr val mem) && is64BitFloat(val.Type) -> (MOVSDstore ptr val mem)
-(Store [4] ptr val mem) && is32BitFloat(val.Type) -> (MOVSSstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 8 && is64BitFloat(val.Type) -> (MOVSDstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 4 && is32BitFloat(val.Type) -> (MOVSSstore ptr val mem)
-(Store [8] ptr val mem) -> (MOVQstore ptr val mem)
-(Store [4] ptr val mem) -> (MOVLstore ptr val mem)
-(Store [2] ptr val mem) -> (MOVWstore ptr val mem)
-(Store [1] ptr val mem) -> (MOVBstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 8 -> (MOVQstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 4 -> (MOVLstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 2 -> (MOVWstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 1 -> (MOVBstore ptr val mem)
// Lowering moves
-(Move [s] _ _ mem) && SizeAndAlign(s).Size() == 0 -> mem
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstore dst (MOVBload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 2 -> (MOVWstore dst (MOVWload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 -> (MOVLstore dst (MOVLload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 8 -> (MOVQstore dst (MOVQload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 16 -> (MOVOstore dst (MOVOload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 3 ->
+(Move [0] _ _ mem) -> mem
+(Move [1] dst src mem) -> (MOVBstore dst (MOVBload src mem) mem)
+(Move [2] dst src mem) -> (MOVWstore dst (MOVWload src mem) mem)
+(Move [4] dst src mem) -> (MOVLstore dst (MOVLload src mem) mem)
+(Move [8] dst src mem) -> (MOVQstore dst (MOVQload src mem) mem)
+(Move [16] dst src mem) -> (MOVOstore dst (MOVOload src mem) mem)
+(Move [3] dst src mem) ->
(MOVBstore [2] dst (MOVBload [2] src mem)
(MOVWstore dst (MOVWload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 5 ->
+(Move [5] dst src mem) ->
(MOVBstore [4] dst (MOVBload [4] src mem)
(MOVLstore dst (MOVLload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 6 ->
+(Move [6] dst src mem) ->
(MOVWstore [4] dst (MOVWload [4] src mem)
(MOVLstore dst (MOVLload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 7 ->
+(Move [7] dst src mem) ->
(MOVLstore [3] dst (MOVLload [3] src mem)
(MOVLstore dst (MOVLload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() > 8 && SizeAndAlign(s).Size() < 16 ->
- (MOVQstore [SizeAndAlign(s).Size()-8] dst (MOVQload [SizeAndAlign(s).Size()-8] src mem)
+(Move [s] dst src mem) && s > 8 && s < 16 ->
+ (MOVQstore [s-8] dst (MOVQload [s-8] src mem)
(MOVQstore dst (MOVQload src mem) mem))
// Adjust moves to be a multiple of 16 bytes.
(Move [s] dst src mem)
- && SizeAndAlign(s).Size() > 16 && SizeAndAlign(s).Size()%16 != 0 && SizeAndAlign(s).Size()%16 <= 8 ->
- (Move [SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%16]
- (OffPtr <dst.Type> dst [SizeAndAlign(s).Size()%16])
- (OffPtr <src.Type> src [SizeAndAlign(s).Size()%16])
+ && s > 16 && s%16 != 0 && s%16 <= 8 ->
+ (Move [s-s%16]
+ (OffPtr <dst.Type> dst [s%16])
+ (OffPtr <src.Type> src [s%16])
(MOVQstore dst (MOVQload src mem) mem))
(Move [s] dst src mem)
- && SizeAndAlign(s).Size() > 16 && SizeAndAlign(s).Size()%16 != 0 && SizeAndAlign(s).Size()%16 > 8 ->
- (Move [SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%16]
- (OffPtr <dst.Type> dst [SizeAndAlign(s).Size()%16])
- (OffPtr <src.Type> src [SizeAndAlign(s).Size()%16])
+ && s > 16 && s%16 != 0 && s%16 > 8 ->
+ (Move [s-s%16]
+ (OffPtr <dst.Type> dst [s%16])
+ (OffPtr <src.Type> src [s%16])
(MOVOstore dst (MOVOload src mem) mem))
// Medium copying uses a duff device.
(Move [s] dst src mem)
- && SizeAndAlign(s).Size() >= 32 && SizeAndAlign(s).Size() <= 16*64 && SizeAndAlign(s).Size()%16 == 0
+ && s >= 32 && s <= 16*64 && s%16 == 0
&& !config.noDuffDevice ->
- (DUFFCOPY [14*(64-SizeAndAlign(s).Size()/16)] dst src mem)
+ (DUFFCOPY [14*(64-s/16)] dst src mem)
// 14 and 64 are magic constants. 14 is the number of bytes to encode:
// MOVUPS (SI), X0
// ADDQ $16, SI
// and 64 is the number of such blocks. See src/runtime/duff_amd64.s:duffcopy.
// Large copying uses REP MOVSQ.
-(Move [s] dst src mem) && (SizeAndAlign(s).Size() > 16*64 || config.noDuffDevice) && SizeAndAlign(s).Size()%8 == 0 ->
- (REPMOVSQ dst src (MOVQconst [SizeAndAlign(s).Size()/8]) mem)
+(Move [s] dst src mem) && (s > 16*64 || config.noDuffDevice) && s%8 == 0 ->
+ (REPMOVSQ dst src (MOVQconst [s/8]) mem)
// Lowering Zero instructions
-(Zero [s] _ mem) && SizeAndAlign(s).Size() == 0 -> mem
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstoreconst [0] destptr mem)
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 2 -> (MOVWstoreconst [0] destptr mem)
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 4 -> (MOVLstoreconst [0] destptr mem)
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 8 -> (MOVQstoreconst [0] destptr mem)
+(Zero [0] _ mem) -> mem
+(Zero [1] destptr mem) -> (MOVBstoreconst [0] destptr mem)
+(Zero [2] destptr mem) -> (MOVWstoreconst [0] destptr mem)
+(Zero [4] destptr mem) -> (MOVLstoreconst [0] destptr mem)
+(Zero [8] destptr mem) -> (MOVQstoreconst [0] destptr mem)
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 3 ->
+(Zero [3] destptr mem) ->
(MOVBstoreconst [makeValAndOff(0,2)] destptr
(MOVWstoreconst [0] destptr mem))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 5 ->
+(Zero [5] destptr mem) ->
(MOVBstoreconst [makeValAndOff(0,4)] destptr
(MOVLstoreconst [0] destptr mem))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 6 ->
+(Zero [6] destptr mem) ->
(MOVWstoreconst [makeValAndOff(0,4)] destptr
(MOVLstoreconst [0] destptr mem))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 7 ->
+(Zero [7] destptr mem) ->
(MOVLstoreconst [makeValAndOff(0,3)] destptr
(MOVLstoreconst [0] destptr mem))
// Strip off any fractional word zeroing.
-(Zero [s] destptr mem) && SizeAndAlign(s).Size()%8 != 0 && SizeAndAlign(s).Size() > 8 ->
- (Zero [SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%8] (OffPtr <destptr.Type> destptr [SizeAndAlign(s).Size()%8])
+(Zero [s] destptr mem) && s%8 != 0 && s > 8 ->
+ (Zero [s-s%8] (OffPtr <destptr.Type> destptr [s%8])
(MOVQstoreconst [0] destptr mem))
// Zero small numbers of words directly.
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 16 ->
+(Zero [16] destptr mem) ->
(MOVQstoreconst [makeValAndOff(0,8)] destptr
(MOVQstoreconst [0] destptr mem))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 24 ->
+(Zero [24] destptr mem) ->
(MOVQstoreconst [makeValAndOff(0,16)] destptr
(MOVQstoreconst [makeValAndOff(0,8)] destptr
(MOVQstoreconst [0] destptr mem)))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 32 ->
+(Zero [32] destptr mem) ->
(MOVQstoreconst [makeValAndOff(0,24)] destptr
(MOVQstoreconst [makeValAndOff(0,16)] destptr
(MOVQstoreconst [makeValAndOff(0,8)] destptr
// Medium zeroing uses a duff device.
(Zero [s] destptr mem)
- && SizeAndAlign(s).Size() <= 1024 && SizeAndAlign(s).Size()%8 == 0 && SizeAndAlign(s).Size()%16 != 0
+ && s <= 1024 && s%8 == 0 && s%16 != 0
&& !config.noDuffDevice ->
- (Zero [SizeAndAlign(s).Size()-8] (OffPtr <destptr.Type> [8] destptr) (MOVQstore destptr (MOVQconst [0]) mem))
+ (Zero [s-8] (OffPtr <destptr.Type> [8] destptr) (MOVQstore destptr (MOVQconst [0]) mem))
(Zero [s] destptr mem)
- && SizeAndAlign(s).Size() <= 1024 && SizeAndAlign(s).Size()%16 == 0 && !config.noDuffDevice ->
- (DUFFZERO [SizeAndAlign(s).Size()] destptr (MOVOconst [0]) mem)
+ && s <= 1024 && s%16 == 0 && !config.noDuffDevice ->
+ (DUFFZERO [s] destptr (MOVOconst [0]) mem)
// Large zeroing uses REP STOSQ.
(Zero [s] destptr mem)
- && (SizeAndAlign(s).Size() > 1024 || (config.noDuffDevice && SizeAndAlign(s).Size() > 32))
- && SizeAndAlign(s).Size()%8 == 0 ->
- (REPSTOSQ destptr (MOVQconst [SizeAndAlign(s).Size()/8]) (MOVQconst [0]) mem)
+ && (s > 1024 || (config.noDuffDevice && s > 32))
+ && s%8 == 0 ->
+ (REPSTOSQ destptr (MOVQconst [s/8]) (MOVQconst [0]) mem)
// Lowering constants
(Const8 [val]) -> (MOVLconst [val])
(Load <t> ptr mem) && is64BitFloat(t) -> (MOVDload ptr mem)
// stores
-(Store [1] ptr val mem) -> (MOVBstore ptr val mem)
-(Store [2] ptr val mem) -> (MOVHstore ptr val mem)
-(Store [4] ptr val mem) && !is32BitFloat(val.Type) -> (MOVWstore ptr val mem)
-(Store [4] ptr val mem) && is32BitFloat(val.Type) -> (MOVFstore ptr val mem)
-(Store [8] ptr val mem) && is64BitFloat(val.Type) -> (MOVDstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 1 -> (MOVBstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 2 -> (MOVHstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 4 && !is32BitFloat(val.Type) -> (MOVWstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 4 && is32BitFloat(val.Type) -> (MOVFstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 8 && is64BitFloat(val.Type) -> (MOVDstore ptr val mem)
// zero instructions
-(Zero [s] _ mem) && SizeAndAlign(s).Size() == 0 -> mem
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstore ptr (MOVWconst [0]) mem)
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0 ->
+(Zero [0] _ mem) -> mem
+(Zero [1] ptr mem) -> (MOVBstore ptr (MOVWconst [0]) mem)
+(Zero [2] {t} ptr mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore ptr (MOVWconst [0]) mem)
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 2 ->
+(Zero [2] ptr mem) ->
(MOVBstore [1] ptr (MOVWconst [0])
(MOVBstore [0] ptr (MOVWconst [0]) mem))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0 ->
+(Zero [4] {t} ptr mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore ptr (MOVWconst [0]) mem)
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0 ->
+(Zero [4] {t} ptr mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore [2] ptr (MOVWconst [0])
(MOVHstore [0] ptr (MOVWconst [0]) mem))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 4 ->
+(Zero [4] ptr mem) ->
(MOVBstore [3] ptr (MOVWconst [0])
(MOVBstore [2] ptr (MOVWconst [0])
(MOVBstore [1] ptr (MOVWconst [0])
(MOVBstore [0] ptr (MOVWconst [0]) mem))))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 3 ->
+(Zero [3] ptr mem) ->
(MOVBstore [2] ptr (MOVWconst [0])
(MOVBstore [1] ptr (MOVWconst [0])
(MOVBstore [0] ptr (MOVWconst [0]) mem)))
// Medium zeroing uses a duff device
// 4 and 128 are magic constants, see runtime/mkduff.go
-(Zero [s] ptr mem)
- && SizeAndAlign(s).Size()%4 == 0 && SizeAndAlign(s).Size() > 4 && SizeAndAlign(s).Size() <= 512
- && SizeAndAlign(s).Align()%4 == 0 && !config.noDuffDevice ->
- (DUFFZERO [4 * (128 - int64(SizeAndAlign(s).Size()/4))] ptr (MOVWconst [0]) mem)
+(Zero [s] {t} ptr mem)
+ && s%4 == 0 && s > 4 && s <= 512
+ && t.(Type).Alignment()%4 == 0 && !config.noDuffDevice ->
+ (DUFFZERO [4 * (128 - int64(s/4))] ptr (MOVWconst [0]) mem)
// Large zeroing uses a loop
-(Zero [s] ptr mem)
- && (SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%4 != 0 ->
- (LoweredZero [SizeAndAlign(s).Align()]
+(Zero [s] {t} ptr mem)
+ && (s > 512 || config.noDuffDevice) || t.(Type).Alignment()%4 != 0 ->
+ (LoweredZero [t.(Type).Alignment()]
ptr
- (ADDconst <ptr.Type> ptr [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)])
+ (ADDconst <ptr.Type> ptr [s-moveSize(t.(Type).Alignment(), config)])
(MOVWconst [0])
mem)
// moves
-(Move [s] _ _ mem) && SizeAndAlign(s).Size() == 0 -> mem
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstore dst (MOVBUload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0 ->
+(Move [0] _ _ mem) -> mem
+(Move [1] dst src mem) -> (MOVBstore dst (MOVBUload src mem) mem)
+(Move [2] {t} dst src mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore dst (MOVHUload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 2 ->
+(Move [2] dst src mem) ->
(MOVBstore [1] dst (MOVBUload [1] src mem)
(MOVBstore dst (MOVBUload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0 ->
+(Move [4] {t} dst src mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore dst (MOVWload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0 ->
+(Move [4] {t} dst src mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore [2] dst (MOVHUload [2] src mem)
(MOVHstore dst (MOVHUload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 ->
+(Move [4] dst src mem) ->
(MOVBstore [3] dst (MOVBUload [3] src mem)
(MOVBstore [2] dst (MOVBUload [2] src mem)
(MOVBstore [1] dst (MOVBUload [1] src mem)
(MOVBstore dst (MOVBUload src mem) mem))))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 3 ->
+(Move [3] dst src mem) ->
(MOVBstore [2] dst (MOVBUload [2] src mem)
(MOVBstore [1] dst (MOVBUload [1] src mem)
(MOVBstore dst (MOVBUload src mem) mem)))
// Medium move uses a duff device
// 8 and 128 are magic constants, see runtime/mkduff.go
-(Move [s] dst src mem)
- && SizeAndAlign(s).Size()%4 == 0 && SizeAndAlign(s).Size() > 4 && SizeAndAlign(s).Size() <= 512
- && SizeAndAlign(s).Align()%4 == 0 && !config.noDuffDevice ->
- (DUFFCOPY [8 * (128 - int64(SizeAndAlign(s).Size()/4))] dst src mem)
+(Move [s] {t} dst src mem)
+ && s%4 == 0 && s > 4 && s <= 512
+ && t.(Type).Alignment()%4 == 0 && !config.noDuffDevice ->
+ (DUFFCOPY [8 * (128 - int64(s/4))] dst src mem)
// Large move uses a loop
-(Move [s] dst src mem)
- && (SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%4 != 0 ->
- (LoweredMove [SizeAndAlign(s).Align()]
+(Move [s] {t} dst src mem)
+ && (s > 512 || config.noDuffDevice) || t.(Type).Alignment()%4 != 0 ->
+ (LoweredMove [t.(Type).Alignment()]
dst
src
- (ADDconst <src.Type> src [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)])
+ (ADDconst <src.Type> src [s-moveSize(t.(Type).Alignment(), config)])
mem)
// calls
(Load <t> ptr mem) && is64BitFloat(t) -> (FMOVDload ptr mem)
// stores
-(Store [1] ptr val mem) -> (MOVBstore ptr val mem)
-(Store [2] ptr val mem) -> (MOVHstore ptr val mem)
-(Store [4] ptr val mem) && !is32BitFloat(val.Type) -> (MOVWstore ptr val mem)
-(Store [8] ptr val mem) && !is64BitFloat(val.Type) -> (MOVDstore ptr val mem)
-(Store [4] ptr val mem) && is32BitFloat(val.Type) -> (FMOVSstore ptr val mem)
-(Store [8] ptr val mem) && is64BitFloat(val.Type) -> (FMOVDstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 1 -> (MOVBstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 2 -> (MOVHstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 4 && !is32BitFloat(val.Type) -> (MOVWstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 8 && !is64BitFloat(val.Type) -> (MOVDstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 4 && is32BitFloat(val.Type) -> (FMOVSstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 8 && is64BitFloat(val.Type) -> (FMOVDstore ptr val mem)
// zeroing
-(Zero [s] _ mem) && SizeAndAlign(s).Size() == 0 -> mem
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstore ptr (MOVDconst [0]) mem)
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 2 -> (MOVHstore ptr (MOVDconst [0]) mem)
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 4 -> (MOVWstore ptr (MOVDconst [0]) mem)
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 8 -> (MOVDstore ptr (MOVDconst [0]) mem)
+(Zero [0] _ mem) -> mem
+(Zero [1] ptr mem) -> (MOVBstore ptr (MOVDconst [0]) mem)
+(Zero [2] ptr mem) -> (MOVHstore ptr (MOVDconst [0]) mem)
+(Zero [4] ptr mem) -> (MOVWstore ptr (MOVDconst [0]) mem)
+(Zero [8] ptr mem) -> (MOVDstore ptr (MOVDconst [0]) mem)
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 3 ->
+(Zero [3] ptr mem) ->
(MOVBstore [2] ptr (MOVDconst [0])
(MOVHstore ptr (MOVDconst [0]) mem))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 5 ->
+(Zero [5] ptr mem) ->
(MOVBstore [4] ptr (MOVDconst [0])
(MOVWstore ptr (MOVDconst [0]) mem))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 6 ->
+(Zero [6] ptr mem) ->
(MOVHstore [4] ptr (MOVDconst [0])
(MOVWstore ptr (MOVDconst [0]) mem))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 7 ->
+(Zero [7] ptr mem) ->
(MOVBstore [6] ptr (MOVDconst [0])
(MOVHstore [4] ptr (MOVDconst [0])
(MOVWstore ptr (MOVDconst [0]) mem)))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 12 ->
+(Zero [12] ptr mem) ->
(MOVWstore [8] ptr (MOVDconst [0])
(MOVDstore ptr (MOVDconst [0]) mem))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 16 ->
+(Zero [16] ptr mem) ->
(MOVDstore [8] ptr (MOVDconst [0])
(MOVDstore ptr (MOVDconst [0]) mem))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 24 ->
+(Zero [24] ptr mem) ->
(MOVDstore [16] ptr (MOVDconst [0])
(MOVDstore [8] ptr (MOVDconst [0])
(MOVDstore ptr (MOVDconst [0]) mem)))
// strip off fractional word zeroing
-(Zero [s] ptr mem) && SizeAndAlign(s).Size()%8 != 0 && SizeAndAlign(s).Size() > 8 ->
- (Zero [MakeSizeAndAlign(SizeAndAlign(s).Size()%8, 1).Int64()]
- (OffPtr <ptr.Type> ptr [SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%8])
- (Zero [MakeSizeAndAlign(SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%8, 1).Int64()] ptr mem))
+(Zero [s] ptr mem) && s%8 != 0 && s > 8 ->
+ (Zero [s%8]
+ (OffPtr <ptr.Type> ptr [s-s%8])
+ (Zero [s-s%8] ptr mem))
// medium zeroing uses a duff device
// 4, 8, and 128 are magic constants, see runtime/mkduff.go
(Zero [s] ptr mem)
- && SizeAndAlign(s).Size()%8 == 0 && SizeAndAlign(s).Size() > 24 && SizeAndAlign(s).Size() <= 8*128
+ && s%8 == 0 && s > 24 && s <= 8*128
&& !config.noDuffDevice ->
- (DUFFZERO [4 * (128 - int64(SizeAndAlign(s).Size()/8))] ptr mem)
+ (DUFFZERO [4 * (128 - int64(s/8))] ptr mem)
// large zeroing uses a loop
(Zero [s] ptr mem)
- && SizeAndAlign(s).Size()%8 == 0 && (SizeAndAlign(s).Size() > 8*128 || config.noDuffDevice) ->
+ && s%8 == 0 && (s > 8*128 || config.noDuffDevice) ->
(LoweredZero
ptr
- (ADDconst <ptr.Type> [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)] ptr)
+ (ADDconst <ptr.Type> [s-8] ptr)
mem)
// moves
-(Move [s] _ _ mem) && SizeAndAlign(s).Size() == 0 -> mem
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstore dst (MOVBUload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 2 -> (MOVHstore dst (MOVHUload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 -> (MOVWstore dst (MOVWUload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 8 -> (MOVDstore dst (MOVDload src mem) mem)
+(Move [0] _ _ mem) -> mem
+(Move [1] dst src mem) -> (MOVBstore dst (MOVBUload src mem) mem)
+(Move [2] dst src mem) -> (MOVHstore dst (MOVHUload src mem) mem)
+(Move [4] dst src mem) -> (MOVWstore dst (MOVWUload src mem) mem)
+(Move [8] dst src mem) -> (MOVDstore dst (MOVDload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 3 ->
+(Move [3] dst src mem) ->
(MOVBstore [2] dst (MOVBUload [2] src mem)
(MOVHstore dst (MOVHUload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 5 ->
+(Move [5] dst src mem) ->
(MOVBstore [4] dst (MOVBUload [4] src mem)
(MOVWstore dst (MOVWUload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 6 ->
+(Move [6] dst src mem) ->
(MOVHstore [4] dst (MOVHUload [4] src mem)
(MOVWstore dst (MOVWUload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 7 ->
+(Move [7] dst src mem) ->
(MOVBstore [6] dst (MOVBUload [6] src mem)
(MOVHstore [4] dst (MOVHUload [4] src mem)
(MOVWstore dst (MOVWUload src mem) mem)))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 12 ->
+(Move [12] dst src mem) ->
(MOVWstore [8] dst (MOVWUload [8] src mem)
(MOVDstore dst (MOVDload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 16 ->
+(Move [16] dst src mem) ->
(MOVDstore [8] dst (MOVDload [8] src mem)
(MOVDstore dst (MOVDload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 24 ->
+(Move [24] dst src mem) ->
(MOVDstore [16] dst (MOVDload [16] src mem)
(MOVDstore [8] dst (MOVDload [8] src mem)
(MOVDstore dst (MOVDload src mem) mem)))
// strip off fractional word move
-(Move [s] dst src mem) && SizeAndAlign(s).Size()%8 != 0 && SizeAndAlign(s).Size() > 8 ->
- (Move [MakeSizeAndAlign(SizeAndAlign(s).Size()%8, 1).Int64()]
- (OffPtr <dst.Type> dst [SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%8])
- (OffPtr <src.Type> src [SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%8])
- (Move [MakeSizeAndAlign(SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%8, 1).Int64()] dst src mem))
+(Move [s] dst src mem) && s%8 != 0 && s > 8 ->
+ (Move [s%8]
+ (OffPtr <dst.Type> dst [s-s%8])
+ (OffPtr <src.Type> src [s-s%8])
+ (Move [s-s%8] dst src mem))
// medium move uses a duff device
// 8 and 128 are magic constants, see runtime/mkduff.go
(Move [s] dst src mem)
- && SizeAndAlign(s).Size()%8 == 0 && SizeAndAlign(s).Size() > 24 && SizeAndAlign(s).Size() <= 8*128
+ && s%8 == 0 && s > 24 && s <= 8*128
&& !config.noDuffDevice ->
- (DUFFCOPY [8 * (128 - int64(SizeAndAlign(s).Size()/8))] dst src mem)
+ (DUFFCOPY [8 * (128 - int64(s/8))] dst src mem)
// large move uses a loop
(Move [s] dst src mem)
- && SizeAndAlign(s).Size() > 24 && SizeAndAlign(s).Size()%8 == 0 ->
+ && s > 24 && s%8 == 0 ->
(LoweredMove
dst
src
- (ADDconst <src.Type> src [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)])
+ (ADDconst <src.Type> src [s-8])
mem)
// calls
(Load <t> ptr mem) && is64BitFloat(t) -> (MOVDload ptr mem)
// stores
-(Store [1] ptr val mem) -> (MOVBstore ptr val mem)
-(Store [2] ptr val mem) -> (MOVHstore ptr val mem)
-(Store [4] ptr val mem) && !is32BitFloat(val.Type) -> (MOVWstore ptr val mem)
-(Store [8] ptr val mem) && !is64BitFloat(val.Type) -> (MOVWstore ptr val mem)
-(Store [4] ptr val mem) && is32BitFloat(val.Type) -> (MOVFstore ptr val mem)
-(Store [8] ptr val mem) && is64BitFloat(val.Type) -> (MOVDstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 1 -> (MOVBstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 2 -> (MOVHstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 4 && !is32BitFloat(val.Type) -> (MOVWstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 4 && is32BitFloat(val.Type) -> (MOVFstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 8 && is64BitFloat(val.Type) -> (MOVDstore ptr val mem)
// zero instructions
-(Zero [s] _ mem) && SizeAndAlign(s).Size() == 0 -> mem
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstore ptr (MOVWconst [0]) mem)
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0 ->
+(Zero [0] _ mem) -> mem
+(Zero [1] ptr mem) -> (MOVBstore ptr (MOVWconst [0]) mem)
+(Zero [2] {t} ptr mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore ptr (MOVWconst [0]) mem)
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 2 ->
+(Zero [2] ptr mem) ->
(MOVBstore [1] ptr (MOVWconst [0])
(MOVBstore [0] ptr (MOVWconst [0]) mem))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0 ->
+(Zero [4] {t} ptr mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore ptr (MOVWconst [0]) mem)
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0 ->
+(Zero [4] {t} ptr mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore [2] ptr (MOVWconst [0])
(MOVHstore [0] ptr (MOVWconst [0]) mem))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 4 ->
+(Zero [4] ptr mem) ->
(MOVBstore [3] ptr (MOVWconst [0])
(MOVBstore [2] ptr (MOVWconst [0])
(MOVBstore [1] ptr (MOVWconst [0])
(MOVBstore [0] ptr (MOVWconst [0]) mem))))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 3 ->
+(Zero [3] ptr mem) ->
(MOVBstore [2] ptr (MOVWconst [0])
(MOVBstore [1] ptr (MOVWconst [0])
(MOVBstore [0] ptr (MOVWconst [0]) mem)))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 6 && SizeAndAlign(s).Align()%2 == 0 ->
+(Zero [6] {t} ptr mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore [4] ptr (MOVWconst [0])
(MOVHstore [2] ptr (MOVWconst [0])
(MOVHstore [0] ptr (MOVWconst [0]) mem)))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0 ->
+(Zero [8] {t} ptr mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore [4] ptr (MOVWconst [0])
(MOVWstore [0] ptr (MOVWconst [0]) mem))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 12 && SizeAndAlign(s).Align()%4 == 0 ->
+(Zero [12] {t} ptr mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore [8] ptr (MOVWconst [0])
(MOVWstore [4] ptr (MOVWconst [0])
(MOVWstore [0] ptr (MOVWconst [0]) mem)))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%4 == 0 ->
+(Zero [16] {t} ptr mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore [12] ptr (MOVWconst [0])
(MOVWstore [8] ptr (MOVWconst [0])
(MOVWstore [4] ptr (MOVWconst [0])
(MOVWstore [0] ptr (MOVWconst [0]) mem))))
// large or unaligned zeroing uses a loop
-(Zero [s] ptr mem)
- && (SizeAndAlign(s).Size() > 16 || SizeAndAlign(s).Align()%4 != 0) ->
- (LoweredZero [SizeAndAlign(s).Align()]
+(Zero [s] {t} ptr mem)
+ && (s > 16 || s%4 != 0) ->
+ (LoweredZero [t.(Type).Alignment()]
ptr
- (ADDconst <ptr.Type> ptr [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)])
+ (ADDconst <ptr.Type> ptr [s-moveSize(t.(Type).Alignment(), config)])
mem)
// moves
-(Move [s] _ _ mem) && SizeAndAlign(s).Size() == 0 -> mem
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstore dst (MOVBUload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0 ->
+(Move [0] _ _ mem) -> mem
+(Move [1] dst src mem) -> (MOVBstore dst (MOVBUload src mem) mem)
+(Move [2] {t} dst src mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore dst (MOVHUload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 2 ->
+(Move [2] dst src mem) ->
(MOVBstore [1] dst (MOVBUload [1] src mem)
(MOVBstore dst (MOVBUload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0 ->
+(Move [4] {t} dst src mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore dst (MOVWload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0 ->
+(Move [4] {t} dst src mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore [2] dst (MOVHUload [2] src mem)
(MOVHstore dst (MOVHUload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 ->
+(Move [4] dst src mem) ->
(MOVBstore [3] dst (MOVBUload [3] src mem)
(MOVBstore [2] dst (MOVBUload [2] src mem)
(MOVBstore [1] dst (MOVBUload [1] src mem)
(MOVBstore dst (MOVBUload src mem) mem))))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 3 ->
+(Move [3] dst src mem) ->
(MOVBstore [2] dst (MOVBUload [2] src mem)
(MOVBstore [1] dst (MOVBUload [1] src mem)
(MOVBstore dst (MOVBUload src mem) mem)))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0 ->
+(Move [8] {t} dst src mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore [4] dst (MOVWload [4] src mem)
(MOVWstore dst (MOVWload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0 ->
+(Move [8] {t} dst src mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore [6] dst (MOVHload [6] src mem)
(MOVHstore [4] dst (MOVHload [4] src mem)
(MOVHstore [2] dst (MOVHload [2] src mem)
(MOVHstore dst (MOVHload src mem) mem))))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 6 && SizeAndAlign(s).Align()%2 == 0 ->
+(Move [6] {t} dst src mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore [4] dst (MOVHload [4] src mem)
(MOVHstore [2] dst (MOVHload [2] src mem)
(MOVHstore dst (MOVHload src mem) mem)))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 12 && SizeAndAlign(s).Align()%4 == 0 ->
+(Move [12] {t} dst src mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore [8] dst (MOVWload [8] src mem)
(MOVWstore [4] dst (MOVWload [4] src mem)
(MOVWstore dst (MOVWload src mem) mem)))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%4 == 0 ->
+(Move [16] {t} dst src mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore [12] dst (MOVWload [12] src mem)
(MOVWstore [8] dst (MOVWload [8] src mem)
(MOVWstore [4] dst (MOVWload [4] src mem)
// large or unaligned move uses a loop
-(Move [s] dst src mem)
- && (SizeAndAlign(s).Size() > 16 || SizeAndAlign(s).Align()%4 != 0) ->
- (LoweredMove [SizeAndAlign(s).Align()]
+(Move [s] {t} dst src mem)
+ && (s > 16 || t.(Type).Alignment()%4 != 0) ->
+ (LoweredMove [t.(Type).Alignment()]
dst
src
- (ADDconst <src.Type> src [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)])
+ (ADDconst <src.Type> src [s-moveSize(t.(Type).Alignment(), config)])
mem)
// calls
(Load <t> ptr mem) && is64BitFloat(t) -> (MOVDload ptr mem)
// stores
-(Store [1] ptr val mem) -> (MOVBstore ptr val mem)
-(Store [2] ptr val mem) -> (MOVHstore ptr val mem)
-(Store [4] ptr val mem) && !is32BitFloat(val.Type) -> (MOVWstore ptr val mem)
-(Store [8] ptr val mem) && !is64BitFloat(val.Type) -> (MOVVstore ptr val mem)
-(Store [4] ptr val mem) && is32BitFloat(val.Type) -> (MOVFstore ptr val mem)
-(Store [8] ptr val mem) && is64BitFloat(val.Type) -> (MOVDstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 1 -> (MOVBstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 2 -> (MOVHstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 4 && !is32BitFloat(val.Type) -> (MOVWstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 8 && !is64BitFloat(val.Type) -> (MOVVstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 4 && is32BitFloat(val.Type) -> (MOVFstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 8 && is64BitFloat(val.Type) -> (MOVDstore ptr val mem)
// zeroing
-(Zero [s] _ mem) && SizeAndAlign(s).Size() == 0 -> mem
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstore ptr (MOVVconst [0]) mem)
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0 ->
+(Zero [0] _ mem) -> mem
+(Zero [1] ptr mem) -> (MOVBstore ptr (MOVVconst [0]) mem)
+(Zero [2] {t} ptr mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore ptr (MOVVconst [0]) mem)
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 2 ->
+(Zero [2] ptr mem) ->
(MOVBstore [1] ptr (MOVVconst [0])
(MOVBstore [0] ptr (MOVVconst [0]) mem))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0 ->
+(Zero [4] {t} ptr mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore ptr (MOVVconst [0]) mem)
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0 ->
+(Zero [4] {t} ptr mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore [2] ptr (MOVVconst [0])
(MOVHstore [0] ptr (MOVVconst [0]) mem))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 4 ->
+(Zero [4] ptr mem) ->
(MOVBstore [3] ptr (MOVVconst [0])
(MOVBstore [2] ptr (MOVVconst [0])
(MOVBstore [1] ptr (MOVVconst [0])
(MOVBstore [0] ptr (MOVVconst [0]) mem))))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0 ->
+(Zero [8] {t} ptr mem) && t.(Type).Alignment()%8 == 0 ->
(MOVVstore ptr (MOVVconst [0]) mem)
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0 ->
+(Zero [8] {t} ptr mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore [4] ptr (MOVVconst [0])
(MOVWstore [0] ptr (MOVVconst [0]) mem))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 4 ->
+(Zero [8] {t} ptr mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore [6] ptr (MOVVconst [0])
(MOVHstore [4] ptr (MOVVconst [0])
(MOVHstore [2] ptr (MOVVconst [0])
(MOVHstore [0] ptr (MOVVconst [0]) mem))))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 3 ->
+(Zero [3] ptr mem) ->
(MOVBstore [2] ptr (MOVVconst [0])
(MOVBstore [1] ptr (MOVVconst [0])
(MOVBstore [0] ptr (MOVVconst [0]) mem)))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 6 && SizeAndAlign(s).Align()%2 == 0 ->
+(Zero [6] {t} ptr mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore [4] ptr (MOVVconst [0])
(MOVHstore [2] ptr (MOVVconst [0])
(MOVHstore [0] ptr (MOVVconst [0]) mem)))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 12 && SizeAndAlign(s).Align()%4 == 0 ->
+(Zero [12] {t} ptr mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore [8] ptr (MOVVconst [0])
(MOVWstore [4] ptr (MOVVconst [0])
(MOVWstore [0] ptr (MOVVconst [0]) mem)))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%8 == 0 ->
+(Zero [16] {t} ptr mem) && t.(Type).Alignment()%8 == 0 ->
(MOVVstore [8] ptr (MOVVconst [0])
(MOVVstore [0] ptr (MOVVconst [0]) mem))
-(Zero [s] ptr mem) && SizeAndAlign(s).Size() == 24 && SizeAndAlign(s).Align()%8 == 0 ->
+(Zero [24] {t} ptr mem) && t.(Type).Alignment()%8 == 0 ->
(MOVVstore [16] ptr (MOVVconst [0])
(MOVVstore [8] ptr (MOVVconst [0])
(MOVVstore [0] ptr (MOVVconst [0]) mem)))
// medium zeroing uses a duff device
// 8, and 128 are magic constants, see runtime/mkduff.go
-(Zero [s] ptr mem)
- && SizeAndAlign(s).Size()%8 == 0 && SizeAndAlign(s).Size() > 24 && SizeAndAlign(s).Size() <= 8*128
- && SizeAndAlign(s).Align()%8 == 0 && !config.noDuffDevice ->
- (DUFFZERO [8 * (128 - int64(SizeAndAlign(s).Size()/8))] ptr mem)
+(Zero [s] {t} ptr mem)
+ && s%8 == 0 && s > 24 && s <= 8*128
+ && t.(Type).Alignment()%8 == 0 && !config.noDuffDevice ->
+ (DUFFZERO [8 * (128 - int64(s/8))] ptr mem)
// large or unaligned zeroing uses a loop
-(Zero [s] ptr mem)
- && (SizeAndAlign(s).Size() > 8*128 || config.noDuffDevice) || SizeAndAlign(s).Align()%8 != 0 ->
- (LoweredZero [SizeAndAlign(s).Align()]
+(Zero [s] {t} ptr mem)
+ && (s > 8*128 || config.noDuffDevice) || t.(Type).Alignment()%8 != 0 ->
+ (LoweredZero [t.(Type).Alignment()]
ptr
- (ADDVconst <ptr.Type> ptr [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)])
+ (ADDVconst <ptr.Type> ptr [s-moveSize(t.(Type).Alignment(), config)])
mem)
// moves
-(Move [s] _ _ mem) && SizeAndAlign(s).Size() == 0 -> mem
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstore dst (MOVBload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0 ->
+(Move [0] _ _ mem) -> mem
+(Move [1] dst src mem) -> (MOVBstore dst (MOVBload src mem) mem)
+(Move [2] {t} dst src mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore dst (MOVHload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 2 ->
+(Move [2] dst src mem) ->
(MOVBstore [1] dst (MOVBload [1] src mem)
(MOVBstore dst (MOVBload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0 ->
+(Move [4] {t} dst src mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore dst (MOVWload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0 ->
+(Move [4] {t} dst src mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore [2] dst (MOVHload [2] src mem)
(MOVHstore dst (MOVHload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 ->
+(Move [4] dst src mem) ->
(MOVBstore [3] dst (MOVBload [3] src mem)
(MOVBstore [2] dst (MOVBload [2] src mem)
(MOVBstore [1] dst (MOVBload [1] src mem)
(MOVBstore dst (MOVBload src mem) mem))))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0 ->
+(Move [8] {t} dst src mem) && t.(Type).Alignment()%8 == 0 ->
(MOVVstore dst (MOVVload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0 ->
+(Move [8] {t} dst src mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore [4] dst (MOVWload [4] src mem)
(MOVWstore dst (MOVWload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0 ->
+(Move [8] {t} dst src mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore [6] dst (MOVHload [6] src mem)
(MOVHstore [4] dst (MOVHload [4] src mem)
(MOVHstore [2] dst (MOVHload [2] src mem)
(MOVHstore dst (MOVHload src mem) mem))))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 3 ->
+(Move [3] dst src mem) ->
(MOVBstore [2] dst (MOVBload [2] src mem)
(MOVBstore [1] dst (MOVBload [1] src mem)
(MOVBstore dst (MOVBload src mem) mem)))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 6 && SizeAndAlign(s).Align()%2 == 0 ->
+(Move [6] {t} dst src mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore [4] dst (MOVHload [4] src mem)
(MOVHstore [2] dst (MOVHload [2] src mem)
(MOVHstore dst (MOVHload src mem) mem)))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 12 && SizeAndAlign(s).Align()%4 == 0 ->
+(Move [12] {t} dst src mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore [8] dst (MOVWload [8] src mem)
(MOVWstore [4] dst (MOVWload [4] src mem)
(MOVWstore dst (MOVWload src mem) mem)))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%8 == 0 ->
+(Move [16] {t} dst src mem) && t.(Type).Alignment()%8 == 0 ->
(MOVVstore [8] dst (MOVVload [8] src mem)
(MOVVstore dst (MOVVload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 24 && SizeAndAlign(s).Align()%8 == 0 ->
+(Move [24] {t} dst src mem) && t.(Type).Alignment()%8 == 0 ->
(MOVVstore [16] dst (MOVVload [16] src mem)
(MOVVstore [8] dst (MOVVload [8] src mem)
(MOVVstore dst (MOVVload src mem) mem)))
// large or unaligned move uses a loop
-(Move [s] dst src mem)
- && SizeAndAlign(s).Size() > 24 || SizeAndAlign(s).Align()%8 != 0 ->
- (LoweredMove [SizeAndAlign(s).Align()]
+(Move [s] {t} dst src mem)
+ && s > 24 || t.(Type).Alignment()%8 != 0 ->
+ (LoweredMove [t.(Type).Alignment()]
dst
src
- (ADDVconst <src.Type> src [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)])
+ (ADDVconst <src.Type> src [s-moveSize(t.(Type).Alignment(), config)])
mem)
// calls
(Load <t> ptr mem) && is32BitFloat(t) -> (FMOVSload ptr mem)
(Load <t> ptr mem) && is64BitFloat(t) -> (FMOVDload ptr mem)
-(Store [8] ptr val mem) && is64BitFloat(val.Type) -> (FMOVDstore ptr val mem)
-(Store [8] ptr val mem) && is32BitFloat(val.Type) -> (FMOVDstore ptr val mem) // glitch from (Cvt32Fto64F x) -> x -- type is wrong
-(Store [4] ptr val mem) && is32BitFloat(val.Type) -> (FMOVSstore ptr val mem)
-(Store [8] ptr val mem) && (is64BitInt(val.Type) || isPtr(val.Type)) -> (MOVDstore ptr val mem)
-(Store [4] ptr val mem) && is32BitInt(val.Type) -> (MOVWstore ptr val mem)
-(Store [2] ptr val mem) -> (MOVHstore ptr val mem)
-(Store [1] ptr val mem) -> (MOVBstore ptr val mem)
-
-(Zero [s] _ mem) && SizeAndAlign(s).Size() == 0 -> mem
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstorezero destptr mem)
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0 ->
+(Store {t} ptr val mem) && t.(Type).Size() == 8 && is64BitFloat(val.Type) -> (FMOVDstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 8 && is32BitFloat(val.Type) -> (FMOVDstore ptr val mem) // glitch from (Cvt32Fto64F x) -> x -- type is wrong
+(Store {t} ptr val mem) && t.(Type).Size() == 4 && is32BitFloat(val.Type) -> (FMOVSstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 8 && (is64BitInt(val.Type) || isPtr(val.Type)) -> (MOVDstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 4 && is32BitInt(val.Type) -> (MOVWstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 2 -> (MOVHstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 1 -> (MOVBstore ptr val mem)
+
+(Zero [0] _ mem) -> mem
+(Zero [1] destptr mem) -> (MOVBstorezero destptr mem)
+(Zero [2] {t} destptr mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstorezero destptr mem)
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 2 ->
+(Zero [2] destptr mem) ->
(MOVBstorezero [1] destptr
(MOVBstorezero [0] destptr mem))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0 ->
+(Zero [4] {t} destptr mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstorezero destptr mem)
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0 ->
+(Zero [4] {t} destptr mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstorezero [2] destptr
(MOVHstorezero [0] destptr mem))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 4 ->
+(Zero [4] destptr mem) ->
(MOVBstorezero [3] destptr
(MOVBstorezero [2] destptr
(MOVBstorezero [1] destptr
(MOVBstorezero [0] destptr mem))))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0 ->
+(Zero [8] {t} destptr mem) && t.(Type).Alignment()%8 == 0 ->
(MOVDstorezero [0] destptr mem)
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0 ->
+(Zero [8] {t} destptr mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstorezero [4] destptr
(MOVWstorezero [0] destptr mem))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0 ->
+(Zero [8] {t} destptr mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstorezero [6] destptr
(MOVHstorezero [4] destptr
(MOVHstorezero [2] destptr
(MOVHstorezero [0] destptr mem))))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 3 ->
+(Zero [3] destptr mem) ->
(MOVBstorezero [2] destptr
(MOVBstorezero [1] destptr
(MOVBstorezero [0] destptr mem)))
// Zero small numbers of words directly.
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%8 == 0 ->
+(Zero [16] {t} destptr mem) && t.(Type).Alignment()%8 == 0 ->
(MOVDstorezero [8] destptr
(MOVDstorezero [0] destptr mem))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 24 && SizeAndAlign(s).Align()%8 == 0 ->
+(Zero [24] {t} destptr mem) && t.(Type).Alignment()%8 == 0 ->
(MOVDstorezero [16] destptr
(MOVDstorezero [8] destptr
(MOVDstorezero [0] destptr mem)))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 32 && SizeAndAlign(s).Align()%8 == 0 ->
+(Zero [32] {t} destptr mem) && t.(Type).Alignment()%8 == 0 ->
(MOVDstorezero [24] destptr
(MOVDstorezero [16] destptr
(MOVDstorezero [8] destptr
(MOVDstorezero [0] destptr mem))))
// Large zeroing uses a loop
-(Zero [s] ptr mem)
- && (SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%8 != 0 ->
- (LoweredZero [SizeAndAlign(s).Align()]
+(Zero [s] {t} ptr mem)
+ && (s > 512 || config.noDuffDevice) || t.(Type).Alignment()%8 != 0 ->
+ (LoweredZero [t.(Type).Alignment()]
ptr
- (ADDconst <ptr.Type> ptr [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)])
+ (ADDconst <ptr.Type> ptr [s-moveSize(t.(Type).Alignment(), config)])
mem)
// moves
-(Move [s] _ _ mem) && SizeAndAlign(s).Size() == 0 -> mem
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstore dst (MOVBZload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0 ->
+(Move [0] _ _ mem) -> mem
+(Move [1] dst src mem) -> (MOVBstore dst (MOVBZload src mem) mem)
+(Move [2] {t} dst src mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore dst (MOVHZload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 2 ->
+(Move [2] dst src mem) ->
(MOVBstore [1] dst (MOVBZload [1] src mem)
(MOVBstore dst (MOVBZload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0 ->
+(Move [4] {t} dst src mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore dst (MOVWload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0 ->
+(Move [4] {t} dst src mem) && t.(Type).Alignment()%2 == 0 ->
(MOVHstore [2] dst (MOVHZload [2] src mem)
(MOVHstore dst (MOVHZload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 ->
+(Move [4] dst src mem) ->
(MOVBstore [3] dst (MOVBZload [3] src mem)
(MOVBstore [2] dst (MOVBZload [2] src mem)
(MOVBstore [1] dst (MOVBZload [1] src mem)
(MOVBstore dst (MOVBZload src mem) mem))))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0 ->
+(Move [8] {t} dst src mem) && t.(Type).Alignment()%8 == 0 ->
(MOVDstore dst (MOVDload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0 ->
+(Move [8] {t} dst src mem) && t.(Type).Alignment()%4 == 0 ->
(MOVWstore [4] dst (MOVWZload [4] src mem)
(MOVWstore dst (MOVWZload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0->
+(Move [8] {t} dst src mem) && t.(Type).Alignment()%2 == 0->
(MOVHstore [6] dst (MOVHZload [6] src mem)
(MOVHstore [4] dst (MOVHZload [4] src mem)
(MOVHstore [2] dst (MOVHZload [2] src mem)
(MOVHstore dst (MOVHZload src mem) mem))))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 3 ->
+(Move [3] dst src mem) ->
(MOVBstore [2] dst (MOVBZload [2] src mem)
(MOVBstore [1] dst (MOVBZload [1] src mem)
(MOVBstore dst (MOVBZload src mem) mem)))
// Large move uses a loop
-(Move [s] dst src mem)
- && (SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%8 != 0 ->
- (LoweredMove [SizeAndAlign(s).Align()]
+(Move [s] {t} dst src mem)
+ && (s > 512 || config.noDuffDevice) || t.(Type).Alignment()%8 != 0 ->
+ (LoweredMove [t.(Type).Alignment()]
dst
src
- (ADDconst <src.Type> src [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)])
+ (ADDconst <src.Type> src [s-moveSize(t.(Type).Alignment(), config)])
mem)
// Calls
// Lowering stores
// These more-specific FP versions of Store pattern should come first.
-(Store [8] ptr val mem) && is64BitFloat(val.Type) -> (FMOVDstore ptr val mem)
-(Store [4] ptr val mem) && is32BitFloat(val.Type) -> (FMOVSstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 8 && is64BitFloat(val.Type) -> (FMOVDstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 4 && is32BitFloat(val.Type) -> (FMOVSstore ptr val mem)
-(Store [8] ptr val mem) -> (MOVDstore ptr val mem)
-(Store [4] ptr val mem) -> (MOVWstore ptr val mem)
-(Store [2] ptr val mem) -> (MOVHstore ptr val mem)
-(Store [1] ptr val mem) -> (MOVBstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 8 -> (MOVDstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 4 -> (MOVWstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 2 -> (MOVHstore ptr val mem)
+(Store {t} ptr val mem) && t.(Type).Size() == 1 -> (MOVBstore ptr val mem)
// Lowering moves
// Load and store for small copies.
-(Move [s] _ _ mem) && SizeAndAlign(s).Size() == 0 -> mem
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstore dst (MOVBZload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 2 -> (MOVHstore dst (MOVHZload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 4 -> (MOVWstore dst (MOVWZload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 8 -> (MOVDstore dst (MOVDload src mem) mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 16 ->
+(Move [0] _ _ mem) -> mem
+(Move [1] dst src mem) -> (MOVBstore dst (MOVBZload src mem) mem)
+(Move [2] dst src mem) -> (MOVHstore dst (MOVHZload src mem) mem)
+(Move [4] dst src mem) -> (MOVWstore dst (MOVWZload src mem) mem)
+(Move [8] dst src mem) -> (MOVDstore dst (MOVDload src mem) mem)
+(Move [16] dst src mem) ->
(MOVDstore [8] dst (MOVDload [8] src mem)
(MOVDstore dst (MOVDload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 24 ->
+(Move [24] dst src mem) ->
(MOVDstore [16] dst (MOVDload [16] src mem)
(MOVDstore [8] dst (MOVDload [8] src mem)
(MOVDstore dst (MOVDload src mem) mem)))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 3 ->
+(Move [3] dst src mem) ->
(MOVBstore [2] dst (MOVBZload [2] src mem)
(MOVHstore dst (MOVHZload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 5 ->
+(Move [5] dst src mem) ->
(MOVBstore [4] dst (MOVBZload [4] src mem)
(MOVWstore dst (MOVWZload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 6 ->
+(Move [6] dst src mem) ->
(MOVHstore [4] dst (MOVHZload [4] src mem)
(MOVWstore dst (MOVWZload src mem) mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() == 7 ->
+(Move [7] dst src mem) ->
(MOVBstore [6] dst (MOVBZload [6] src mem)
(MOVHstore [4] dst (MOVHZload [4] src mem)
(MOVWstore dst (MOVWZload src mem) mem)))
// MVC for other moves. Use up to 4 instructions (sizes up to 1024 bytes).
-(Move [s] dst src mem) && SizeAndAlign(s).Size() > 0 && SizeAndAlign(s).Size() <= 256 ->
- (MVC [makeValAndOff(SizeAndAlign(s).Size(), 0)] dst src mem)
-(Move [s] dst src mem) && SizeAndAlign(s).Size() > 256 && SizeAndAlign(s).Size() <= 512 ->
- (MVC [makeValAndOff(SizeAndAlign(s).Size()-256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() > 512 && SizeAndAlign(s).Size() <= 768 ->
- (MVC [makeValAndOff(SizeAndAlign(s).Size()-512, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem)))
-(Move [s] dst src mem) && SizeAndAlign(s).Size() > 768 && SizeAndAlign(s).Size() <= 1024 ->
- (MVC [makeValAndOff(SizeAndAlign(s).Size()-768, 768)] dst src (MVC [makeValAndOff(256, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))))
+(Move [s] dst src mem) && s > 0 && s <= 256 ->
+ (MVC [makeValAndOff(s, 0)] dst src mem)
+(Move [s] dst src mem) && s > 256 && s <= 512 ->
+ (MVC [makeValAndOff(s-256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))
+(Move [s] dst src mem) && s > 512 && s <= 768 ->
+ (MVC [makeValAndOff(s-512, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem)))
+(Move [s] dst src mem) && s > 768 && s <= 1024 ->
+ (MVC [makeValAndOff(s-768, 768)] dst src (MVC [makeValAndOff(256, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))))
// Move more than 1024 bytes using a loop.
-(Move [s] dst src mem) && SizeAndAlign(s).Size() > 1024 ->
- (LoweredMove [SizeAndAlign(s).Size()%256] dst src (ADDconst <src.Type> src [(SizeAndAlign(s).Size()/256)*256]) mem)
+(Move [s] dst src mem) && s > 1024 ->
+ (LoweredMove [s%256] dst src (ADDconst <src.Type> src [(s/256)*256]) mem)
// Lowering Zero instructions
-(Zero [s] _ mem) && SizeAndAlign(s).Size() == 0 -> mem
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 1 -> (MOVBstoreconst [0] destptr mem)
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 2 -> (MOVHstoreconst [0] destptr mem)
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 4 -> (MOVWstoreconst [0] destptr mem)
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 8 -> (MOVDstoreconst [0] destptr mem)
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 3 ->
+(Zero [0] _ mem) -> mem
+(Zero [1] destptr mem) -> (MOVBstoreconst [0] destptr mem)
+(Zero [2] destptr mem) -> (MOVHstoreconst [0] destptr mem)
+(Zero [4] destptr mem) -> (MOVWstoreconst [0] destptr mem)
+(Zero [8] destptr mem) -> (MOVDstoreconst [0] destptr mem)
+(Zero [3] destptr mem) ->
(MOVBstoreconst [makeValAndOff(0,2)] destptr
(MOVHstoreconst [0] destptr mem))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 5 ->
+(Zero [5] destptr mem) ->
(MOVBstoreconst [makeValAndOff(0,4)] destptr
(MOVWstoreconst [0] destptr mem))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 6 ->
+(Zero [6] destptr mem) ->
(MOVHstoreconst [makeValAndOff(0,4)] destptr
(MOVWstoreconst [0] destptr mem))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() == 7 ->
+(Zero [7] destptr mem) ->
(MOVWstoreconst [makeValAndOff(0,3)] destptr
(MOVWstoreconst [0] destptr mem))
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() > 0 && SizeAndAlign(s).Size() <= 1024 ->
- (CLEAR [makeValAndOff(SizeAndAlign(s).Size(), 0)] destptr mem)
+(Zero [s] destptr mem) && s > 0 && s <= 1024 ->
+ (CLEAR [makeValAndOff(s, 0)] destptr mem)
// Move more than 1024 bytes using a loop.
-(Zero [s] destptr mem) && SizeAndAlign(s).Size() > 1024 ->
- (LoweredZero [SizeAndAlign(s).Size()%256] destptr (ADDconst <destptr.Type> destptr [(SizeAndAlign(s).Size()/256)*256]) mem)
+(Zero [s] destptr mem) && s > 1024 ->
+ (LoweredZero [s%256] destptr (ADDconst <destptr.Type> destptr [(s/256)*256]) mem)
// Lowering constants
(Const8 [val]) -> (MOVDconst [val])
(OffPtr <config.fe.TypeFloat32().PtrTo()> [4] ptr)
mem)
)
-(Store [8] dst (ComplexMake real imag) mem) ->
- (Store [4] {config.fe.TypeFloat32()}
+(Store {t} dst (ComplexMake real imag) mem) && t.(Type).Size() == 8 ->
+ (Store {config.fe.TypeFloat32()}
(OffPtr <config.fe.TypeFloat32().PtrTo()> [4] dst)
imag
- (Store [4] {config.fe.TypeFloat32()} dst real mem))
+ (Store {config.fe.TypeFloat32()} dst real mem))
(Load <t> ptr mem) && t.IsComplex() && t.Size() == 16 ->
(ComplexMake
(Load <config.fe.TypeFloat64()> ptr mem)
(OffPtr <config.fe.TypeFloat64().PtrTo()> [8] ptr)
mem)
)
-(Store [16] dst (ComplexMake real imag) mem) ->
- (Store [8] {config.fe.TypeFloat64()}
+(Store {t} dst (ComplexMake real imag) mem) && t.(Type).Size() == 16 ->
+ (Store {config.fe.TypeFloat64()}
(OffPtr <config.fe.TypeFloat64().PtrTo()> [8] dst)
imag
- (Store [8] {config.fe.TypeFloat64()} dst real mem))
+ (Store {config.fe.TypeFloat64()} dst real mem))
// string ops
(StringPtr (StringMake ptr _)) -> ptr
(Load <config.fe.TypeInt()>
(OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] ptr)
mem))
-(Store [2*config.PtrSize] dst (StringMake ptr len) mem) ->
- (Store [config.PtrSize] {config.fe.TypeInt()}
+(Store dst (StringMake ptr len) mem) ->
+ (Store {config.fe.TypeInt()}
(OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] dst)
len
- (Store [config.PtrSize] {config.fe.TypeBytePtr()} dst ptr mem))
+ (Store {config.fe.TypeBytePtr()} dst ptr mem))
// slice ops
(SlicePtr (SliceMake ptr _ _ )) -> ptr
(Load <config.fe.TypeInt()>
(OffPtr <config.fe.TypeInt().PtrTo()> [2*config.PtrSize] ptr)
mem))
-(Store [3*config.PtrSize] dst (SliceMake ptr len cap) mem) ->
- (Store [config.PtrSize] {config.fe.TypeInt()}
+(Store dst (SliceMake ptr len cap) mem) ->
+ (Store {config.fe.TypeInt()}
(OffPtr <config.fe.TypeInt().PtrTo()> [2*config.PtrSize] dst)
cap
- (Store [config.PtrSize] {config.fe.TypeInt()}
+ (Store {config.fe.TypeInt()}
(OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] dst)
len
- (Store [config.PtrSize] {config.fe.TypeBytePtr()} dst ptr mem)))
+ (Store {config.fe.TypeBytePtr()} dst ptr mem)))
// interface ops
(ITab (IMake itab _)) -> itab
(Load <config.fe.TypeBytePtr()>
(OffPtr <config.fe.TypeBytePtr().PtrTo()> [config.PtrSize] ptr)
mem))
-(Store [2*config.PtrSize] dst (IMake itab data) mem) ->
- (Store [config.PtrSize] {config.fe.TypeBytePtr()}
+(Store dst (IMake itab data) mem) ->
+ (Store {config.fe.TypeBytePtr()}
(OffPtr <config.fe.TypeBytePtr().PtrTo()> [config.PtrSize] dst)
data
- (Store [config.PtrSize] {config.fe.TypeUintptr()} dst itab mem))
+ (Store {config.fe.TypeUintptr()} dst itab mem))
(Load <config.fe.TypeUInt32()> ptr mem)
(Load <config.fe.TypeUInt32()> (OffPtr <config.fe.TypeUInt32().PtrTo()> [4] ptr) mem))
-(Store [8] dst (Int64Make hi lo) mem) && !config.BigEndian ->
- (Store [4] {hi.Type}
+(Store {t} dst (Int64Make hi lo) mem) && t.(Type).Size() == 8 && !config.BigEndian ->
+ (Store {hi.Type}
(OffPtr <hi.Type.PtrTo()> [4] dst)
hi
- (Store [4] {lo.Type} dst lo mem))
+ (Store {lo.Type} dst lo mem))
-(Store [8] dst (Int64Make hi lo) mem) && config.BigEndian ->
- (Store [4] {lo.Type}
+(Store {t} dst (Int64Make hi lo) mem) && t.(Type).Size() == 8 && config.BigEndian ->
+ (Store {lo.Type}
(OffPtr <lo.Type.PtrTo()> [4] dst)
lo
- (Store [4] {hi.Type} dst hi mem))
+ (Store {hi.Type} dst hi mem))
(Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() ->
(Int64Make
(NeqSlice x y) -> (NeqPtr (SlicePtr x) (SlicePtr y))
// Load of store of same address, with compatibly typed value and same size
-(Load <t1> p1 (Store [w] p2 x _)) && isSamePtr(p1,p2) && t1.Compare(x.Type)==CMPeq && w == t1.Size() -> x
+(Load <t1> p1 (Store {t2} p2 x _)) && isSamePtr(p1,p2) && t1.Compare(x.Type)==CMPeq && t1.Size() == t2.(Type).Size() -> x
// Collapse OffPtr
(OffPtr (OffPtr p [b]) [a]) -> (OffPtr p [a+b])
(Store _ (StructMake0) mem) -> mem
(Store dst (StructMake1 <t> f0) mem) ->
- (Store [t.FieldType(0).Size()] {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem)
+ (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem)
(Store dst (StructMake2 <t> f0 f1) mem) ->
- (Store [t.FieldType(1).Size()] {t.FieldType(1)}
+ (Store {t.FieldType(1)}
(OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst)
f1
- (Store [t.FieldType(0).Size()] {t.FieldType(0)}
+ (Store {t.FieldType(0)}
(OffPtr <t.FieldType(0).PtrTo()> [0] dst)
f0 mem))
(Store dst (StructMake3 <t> f0 f1 f2) mem) ->
- (Store [t.FieldType(2).Size()] {t.FieldType(2)}
+ (Store {t.FieldType(2)}
(OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst)
f2
- (Store [t.FieldType(1).Size()] {t.FieldType(1)}
+ (Store {t.FieldType(1)}
(OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst)
f1
- (Store [t.FieldType(0).Size()] {t.FieldType(0)}
+ (Store {t.FieldType(0)}
(OffPtr <t.FieldType(0).PtrTo()> [0] dst)
f0 mem)))
(Store dst (StructMake4 <t> f0 f1 f2 f3) mem) ->
- (Store [t.FieldType(3).Size()] {t.FieldType(3)}
+ (Store {t.FieldType(3)}
(OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] dst)
f3
- (Store [t.FieldType(2).Size()] {t.FieldType(2)}
+ (Store {t.FieldType(2)}
(OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst)
f2
- (Store [t.FieldType(1).Size()] {t.FieldType(1)}
+ (Store {t.FieldType(1)}
(OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst)
f1
- (Store [t.FieldType(0).Size()] {t.FieldType(0)}
+ (Store {t.FieldType(0)}
(OffPtr <t.FieldType(0).PtrTo()> [0] dst)
f0 mem))))
(StructSelect [0] x:(IData _)) -> x
// un-SSAable values use mem->mem copies
-(Store [size] dst (Load <t> src mem) mem) && !config.fe.CanSSA(t) ->
- (Move [MakeSizeAndAlign(size, t.Alignment()).Int64()] {t} dst src mem)
-(Store [size] dst (Load <t> src mem) (VarDef {x} mem)) && !config.fe.CanSSA(t) ->
- (Move [MakeSizeAndAlign(size, t.Alignment()).Int64()] {t} dst src (VarDef {x} mem))
+(Store {t} dst (Load src mem) mem) && !config.fe.CanSSA(t.(Type)) ->
+ (Move {t} [t.(Type).Size()] dst src mem)
+(Store {t} dst (Load src mem) (VarDef {x} mem)) && !config.fe.CanSSA(t.(Type)) ->
+ (Move {t} [t.(Type).Size()] dst src (VarDef {x} mem))
// array ops
(ArraySelect (ArrayMake1 x)) -> x
(ArrayMake1 (Load <t.ElemType()> ptr mem))
(Store _ (ArrayMake0) mem) -> mem
-(Store [size] dst (ArrayMake1 e) mem) -> (Store [size] {e.Type} dst e mem)
+(Store dst (ArrayMake1 e) mem) -> (Store {e.Type} dst e mem)
(ArraySelect [0] (Load ptr mem)) -> (Load ptr mem)
{name: "Invalid"}, // unused value
// Memory operations
- {name: "Load", argLength: 2}, // Load from arg0. arg1=memory
- {name: "Store", argLength: 3, typ: "Mem", aux: "SymOff", symEffect: "None"}, // Store arg1 to arg0. arg2=memory, auxint=size, aux=type. Returns memory.
- {name: "Move", argLength: 3, typ: "Mem", aux: "SymSizeAndAlign", symEffect: "None"}, // arg0=destptr, arg1=srcptr, arg2=mem, auxint=size+alignment, aux=type. Returns memory.
- {name: "Zero", argLength: 2, typ: "Mem", aux: "SymSizeAndAlign", symEffect: "None"}, // arg0=destptr, arg1=mem, auxint=size+alignment, aux=type. Returns memory.
+ {name: "Load", argLength: 2}, // Load from arg0. arg1=memory
+ {name: "Store", argLength: 3, typ: "Mem", aux: "Typ"}, // Store arg1 to arg0. arg2=memory, aux=type. Returns memory.
+ {name: "Move", argLength: 3, typ: "Mem", aux: "TypSize"}, // arg0=destptr, arg1=srcptr, arg2=mem, auxint=size, aux=type. Returns memory.
+ {name: "Zero", argLength: 2, typ: "Mem", aux: "TypSize"}, // arg0=destptr, arg1=mem, auxint=size, aux=type. Returns memory.
// Memory operations with write barriers.
// Expand to runtime calls. Write barrier will be removed if write on stack.
- {name: "StoreWB", argLength: 3, typ: "Mem", aux: "SymOff", symEffect: "None"}, // Store arg1 to arg0. arg2=memory, auxint=size, aux=type. Returns memory.
- {name: "MoveWB", argLength: 3, typ: "Mem", aux: "SymSizeAndAlign", symEffect: "None"}, // arg0=destptr, arg1=srcptr, arg2=mem, auxint=size+alignment, aux=type. Returns memory.
- {name: "ZeroWB", argLength: 2, typ: "Mem", aux: "SymSizeAndAlign", symEffect: "None"}, // arg0=destptr, arg1=mem, auxint=size+alignment, aux=type. Returns memory.
+ {name: "StoreWB", argLength: 3, typ: "Mem", aux: "Typ"}, // Store arg1 to arg0. arg2=memory, aux=type. Returns memory.
+ {name: "MoveWB", argLength: 3, typ: "Mem", aux: "TypSize"}, // arg0=destptr, arg1=srcptr, arg2=mem, auxint=size, aux=type. Returns memory.
+ {name: "ZeroWB", argLength: 2, typ: "Mem", aux: "TypSize"}, // arg0=destptr, arg1=mem, auxint=size, aux=type. Returns memory.
// Function calls. Arguments to the call have already been written to the stack.
// Return values appear on the stack. The method receiver, if any, is treated
// Sanity check aux, auxint.
if auxint != "" {
switch op.aux {
- case "Bool", "Int8", "Int16", "Int32", "Int64", "Int128", "Float32", "Float64", "SymOff", "SymValAndOff", "SymInt32", "SizeAndAlign", "SymSizeAndAlign":
+ case "Bool", "Int8", "Int16", "Int32", "Int64", "Int128", "Float32", "Float64", "SymOff", "SymValAndOff", "SymInt32", "TypSize":
default:
log.Fatalf("%s: op %s %s can't have auxint", loc, op.name, op.aux)
}
}
if aux != "" {
switch op.aux {
- case "String", "Sym", "SymOff", "SymValAndOff", "SymInt32", "SymSizeAndAlign":
+ case "String", "Sym", "SymOff", "SymValAndOff", "SymInt32", "Typ", "TypSize":
default:
log.Fatalf("%s: op %s %s can't have aux", loc, op.name, op.aux)
}
Goto("b1")),
Bloc("b3",
Valu("retdef", OpVarDef, TypeMem, 0, nil, "mem"),
- Valu("store", OpStore, TypeMem, 8, TypeInt64, "ret", "phisum", "retdef"),
+ Valu("store", OpStore, TypeMem, 0, TypeInt64, "ret", "phisum", "retdef"),
Exit("store")))
CheckFunc(fun.f)
Compile(fun.f)
If("bool2", "extra", "exit")),
Bloc("extra",
// prevent fuse from eliminating this block
- Valu("store", OpStore, TypeMem, 8, nil, "ptr1", "nilptr", "mem"),
+ Valu("store", OpStore, TypeMem, 0, ptrType, "ptr1", "nilptr", "mem"),
Goto("exit")),
Bloc("exit",
Valu("phi", OpPhi, TypeMem, 0, nil, "mem", "store"),
type auxType int8
const (
- auxNone auxType = iota
- auxBool // auxInt is 0/1 for false/true
- auxInt8 // auxInt is an 8-bit integer
- auxInt16 // auxInt is a 16-bit integer
- auxInt32 // auxInt is a 32-bit integer
- auxInt64 // auxInt is a 64-bit integer
- auxInt128 // auxInt represents a 128-bit integer. Always 0.
- auxFloat32 // auxInt is a float32 (encoded with math.Float64bits)
- auxFloat64 // auxInt is a float64 (encoded with math.Float64bits)
- auxSizeAndAlign // auxInt is a SizeAndAlign
- auxString // aux is a string
- auxSym // aux is a symbol
- auxSymOff // aux is a symbol, auxInt is an offset
- auxSymValAndOff // aux is a symbol, auxInt is a ValAndOff
- auxSymSizeAndAlign // aux is a symbol, auxInt is a SizeAndAlign
+ auxNone auxType = iota
+ auxBool // auxInt is 0/1 for false/true
+ auxInt8 // auxInt is an 8-bit integer
+ auxInt16 // auxInt is a 16-bit integer
+ auxInt32 // auxInt is a 32-bit integer
+ auxInt64 // auxInt is a 64-bit integer
+ auxInt128 // auxInt represents a 128-bit integer. Always 0.
+ auxFloat32 // auxInt is a float32 (encoded with math.Float64bits)
+ auxFloat64 // auxInt is a float64 (encoded with math.Float64bits)
+ auxString // aux is a string
+ auxSym // aux is a symbol
+ auxSymOff // aux is a symbol, auxInt is an offset
+ auxSymValAndOff // aux is a symbol, auxInt is a ValAndOff
+ auxTyp // aux is a type
+ auxTypSize // aux is a type, auxInt is a size, must have Aux.(Type).Size() == AuxInt
auxSymInt32 // aux is a symbol, auxInt is a 32-bit integer
)
}
return makeValAndOff(x.Val(), x.Off()+off)
}
-
-// SizeAndAlign holds both the size and the alignment of a type,
-// used in Zero and Move ops.
-// The high 8 bits hold the alignment.
-// The low 56 bits hold the size.
-type SizeAndAlign int64
-
-func (x SizeAndAlign) Size() int64 {
- return int64(x) & (1<<56 - 1)
-}
-func (x SizeAndAlign) Align() int64 {
- return int64(uint64(x) >> 56)
-}
-func (x SizeAndAlign) Int64() int64 {
- return int64(x)
-}
-func (x SizeAndAlign) String() string {
- return fmt.Sprintf("size=%d,align=%d", x.Size(), x.Align())
-}
-func MakeSizeAndAlign(size, align int64) SizeAndAlign {
- if size&^(1<<56-1) != 0 {
- panic("size too big in SizeAndAlign")
- }
- if align >= 1<<8 {
- panic("alignment too big in SizeAndAlign")
- }
- return SizeAndAlign(size | align<<56)
-}
generic: true,
},
{
- name: "Store",
- auxType: auxSymOff,
- argLen: 3,
- symEffect: SymNone,
- generic: true,
+ name: "Store",
+ auxType: auxTyp,
+ argLen: 3,
+ generic: true,
},
{
- name: "Move",
- auxType: auxSymSizeAndAlign,
- argLen: 3,
- symEffect: SymNone,
- generic: true,
+ name: "Move",
+ auxType: auxTypSize,
+ argLen: 3,
+ generic: true,
},
{
- name: "Zero",
- auxType: auxSymSizeAndAlign,
- argLen: 2,
- symEffect: SymNone,
- generic: true,
+ name: "Zero",
+ auxType: auxTypSize,
+ argLen: 2,
+ generic: true,
},
{
- name: "StoreWB",
- auxType: auxSymOff,
- argLen: 3,
- symEffect: SymNone,
- generic: true,
+ name: "StoreWB",
+ auxType: auxTyp,
+ argLen: 3,
+ generic: true,
},
{
- name: "MoveWB",
- auxType: auxSymSizeAndAlign,
- argLen: 3,
- symEffect: SymNone,
- generic: true,
+ name: "MoveWB",
+ auxType: auxTypSize,
+ argLen: 3,
+ generic: true,
},
{
- name: "ZeroWB",
- auxType: auxSymSizeAndAlign,
- argLen: 2,
- symEffect: SymNone,
- generic: true,
+ name: "ZeroWB",
+ auxType: auxTypSize,
+ argLen: 2,
+ generic: true,
},
{
name: "ClosureCall",
Valu(valn("addr", i, 1), OpAddr, ptrType, 0, nil, "sb"),
Valu(valn("addr", i, 2), OpAddr, ptrType, 0, nil, "sb"),
Valu(valn("addr", i, 3), OpAddr, ptrType, 0, nil, "sb"),
- Valu(valn("zero", i, 1), OpZero, TypeMem, 8, nil, valn("addr", i, 3),
+ Valu(valn("zero", i, 1), OpZero, TypeMem, 8, elemType, valn("addr", i, 3),
valn("store", i-1, 4)),
- Valu(valn("store", i, 1), OpStore, TypeMem, 0, nil, valn("addr", i, 1),
+ Valu(valn("store", i, 1), OpStore, TypeMem, 0, elemType, valn("addr", i, 1),
valn("v", i, 0), valn("zero", i, 1)),
- Valu(valn("store", i, 2), OpStore, TypeMem, 0, nil, valn("addr", i, 2),
+ Valu(valn("store", i, 2), OpStore, TypeMem, 0, elemType, valn("addr", i, 2),
valn("v", i, 0), valn("store", i, 1)),
- Valu(valn("store", i, 3), OpStore, TypeMem, 0, nil, valn("addr", i, 1),
+ Valu(valn("store", i, 3), OpStore, TypeMem, 0, elemType, valn("addr", i, 1),
valn("v", i, 0), valn("store", i, 2)),
- Valu(valn("store", i, 4), OpStore, TypeMem, 0, nil, valn("addr", i, 3),
+ Valu(valn("store", i, 4), OpStore, TypeMem, 0, elemType, valn("addr", i, 3),
valn("v", i, 0), valn("store", i, 3)),
Goto(blockn(i+1))))
}
func rewriteValue386_OpMove(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Move [s] _ _ mem)
- // cond: SizeAndAlign(s).Size() == 0
+ // match: (Move [0] _ _ mem)
+ // cond:
// result: mem
for {
- s := v.AuxInt
- mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 0) {
+ if v.AuxInt != 0 {
break
}
+ mem := v.Args[2]
v.reset(OpCopy)
v.Type = mem.Type
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 1
+ // match: (Move [1] dst src mem)
+ // cond:
// result: (MOVBstore dst (MOVBload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 1 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 1) {
- break
- }
v.reset(Op386MOVBstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, Op386MOVBload, config.fe.TypeUInt8())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 2
+ // match: (Move [2] dst src mem)
+ // cond:
// result: (MOVWstore dst (MOVWload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 2 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 2) {
- break
- }
v.reset(Op386MOVWstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, Op386MOVWload, config.fe.TypeUInt16())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Move [4] dst src mem)
+ // cond:
// result: (MOVLstore dst (MOVLload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 4) {
- break
- }
v.reset(Op386MOVLstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, Op386MOVLload, config.fe.TypeUInt32())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 3
+ // match: (Move [3] dst src mem)
+ // cond:
// result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVWstore dst (MOVWload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 3 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 3) {
- break
- }
v.reset(Op386MOVBstore)
v.AuxInt = 2
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 5
+ // match: (Move [5] dst src mem)
+ // cond:
// result: (MOVBstore [4] dst (MOVBload [4] src mem) (MOVLstore dst (MOVLload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 5 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 5) {
- break
- }
v.reset(Op386MOVBstore)
v.AuxInt = 4
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 6
+ // match: (Move [6] dst src mem)
+ // cond:
// result: (MOVWstore [4] dst (MOVWload [4] src mem) (MOVLstore dst (MOVLload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 6 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 6) {
- break
- }
v.reset(Op386MOVWstore)
v.AuxInt = 4
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 7
+ // match: (Move [7] dst src mem)
+ // cond:
// result: (MOVLstore [3] dst (MOVLload [3] src mem) (MOVLstore dst (MOVLload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 7 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 7) {
- break
- }
v.reset(Op386MOVLstore)
v.AuxInt = 3
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 8
+ // match: (Move [8] dst src mem)
+ // cond:
// result: (MOVLstore [4] dst (MOVLload [4] src mem) (MOVLstore dst (MOVLload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 8) {
- break
- }
v.reset(Op386MOVLstore)
v.AuxInt = 4
v.AddArg(dst)
return true
}
// match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() > 8 && SizeAndAlign(s).Size()%4 != 0
- // result: (Move [SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%4] (ADDLconst <dst.Type> dst [SizeAndAlign(s).Size()%4]) (ADDLconst <src.Type> src [SizeAndAlign(s).Size()%4]) (MOVLstore dst (MOVLload src mem) mem))
+ // cond: s > 8 && s%4 != 0
+ // result: (Move [s-s%4] (ADDLconst <dst.Type> dst [s%4]) (ADDLconst <src.Type> src [s%4]) (MOVLstore dst (MOVLload src mem) mem))
for {
s := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() > 8 && SizeAndAlign(s).Size()%4 != 0) {
+ if !(s > 8 && s%4 != 0) {
break
}
v.reset(OpMove)
- v.AuxInt = SizeAndAlign(s).Size() - SizeAndAlign(s).Size()%4
+ v.AuxInt = s - s%4
v0 := b.NewValue0(v.Pos, Op386ADDLconst, dst.Type)
- v0.AuxInt = SizeAndAlign(s).Size() % 4
+ v0.AuxInt = s % 4
v0.AddArg(dst)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, Op386ADDLconst, src.Type)
- v1.AuxInt = SizeAndAlign(s).Size() % 4
+ v1.AuxInt = s % 4
v1.AddArg(src)
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem)
return true
}
// match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() > 8 && SizeAndAlign(s).Size() <= 4*128 && SizeAndAlign(s).Size()%4 == 0 && !config.noDuffDevice
- // result: (DUFFCOPY [10*(128-SizeAndAlign(s).Size()/4)] dst src mem)
+ // cond: s > 8 && s <= 4*128 && s%4 == 0 && !config.noDuffDevice
+ // result: (DUFFCOPY [10*(128-s/4)] dst src mem)
for {
s := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() > 8 && SizeAndAlign(s).Size() <= 4*128 && SizeAndAlign(s).Size()%4 == 0 && !config.noDuffDevice) {
+ if !(s > 8 && s <= 4*128 && s%4 == 0 && !config.noDuffDevice) {
break
}
v.reset(Op386DUFFCOPY)
- v.AuxInt = 10 * (128 - SizeAndAlign(s).Size()/4)
+ v.AuxInt = 10 * (128 - s/4)
v.AddArg(dst)
v.AddArg(src)
v.AddArg(mem)
return true
}
// match: (Move [s] dst src mem)
- // cond: (SizeAndAlign(s).Size() > 4*128 || config.noDuffDevice) && SizeAndAlign(s).Size()%4 == 0
- // result: (REPMOVSL dst src (MOVLconst [SizeAndAlign(s).Size()/4]) mem)
+ // cond: (s > 4*128 || config.noDuffDevice) && s%4 == 0
+ // result: (REPMOVSL dst src (MOVLconst [s/4]) mem)
for {
s := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !((SizeAndAlign(s).Size() > 4*128 || config.noDuffDevice) && SizeAndAlign(s).Size()%4 == 0) {
+ if !((s > 4*128 || config.noDuffDevice) && s%4 == 0) {
break
}
v.reset(Op386REPMOVSL)
v.AddArg(dst)
v.AddArg(src)
v0 := b.NewValue0(v.Pos, Op386MOVLconst, config.fe.TypeUInt32())
- v0.AuxInt = SizeAndAlign(s).Size() / 4
+ v0.AuxInt = s / 4
v.AddArg(v0)
v.AddArg(mem)
return true
func rewriteValue386_OpStore(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Store [8] ptr val mem)
- // cond: is64BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
// result: (MOVSDstore ptr val mem)
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is64BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 8 && is64BitFloat(val.Type)) {
break
}
v.reset(Op386MOVSDstore)
v.AddArg(mem)
return true
}
- // match: (Store [4] ptr val mem)
- // cond: is32BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 4 && is32BitFloat(val.Type)
// result: (MOVSSstore ptr val mem)
for {
- if v.AuxInt != 4 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is32BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 4 && is32BitFloat(val.Type)) {
break
}
v.reset(Op386MOVSSstore)
v.AddArg(mem)
return true
}
- // match: (Store [4] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 4
// result: (MOVLstore ptr val mem)
for {
- if v.AuxInt != 4 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 4) {
+ break
+ }
v.reset(Op386MOVLstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [2] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 2
// result: (MOVWstore ptr val mem)
for {
- if v.AuxInt != 2 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 2) {
+ break
+ }
v.reset(Op386MOVWstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [1] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 1
// result: (MOVBstore ptr val mem)
for {
- if v.AuxInt != 1 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 1) {
+ break
+ }
v.reset(Op386MOVBstore)
v.AddArg(ptr)
v.AddArg(val)
func rewriteValue386_OpZero(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Zero [s] _ mem)
- // cond: SizeAndAlign(s).Size() == 0
+ // match: (Zero [0] _ mem)
+ // cond:
// result: mem
for {
- s := v.AuxInt
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 0) {
+ if v.AuxInt != 0 {
break
}
+ mem := v.Args[1]
v.reset(OpCopy)
v.Type = mem.Type
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 1
+ // match: (Zero [1] destptr mem)
+ // cond:
// result: (MOVBstoreconst [0] destptr mem)
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 1) {
+ if v.AuxInt != 1 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(Op386MOVBstoreconst)
v.AuxInt = 0
v.AddArg(destptr)
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 2
+ // match: (Zero [2] destptr mem)
+ // cond:
// result: (MOVWstoreconst [0] destptr mem)
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 2) {
+ if v.AuxInt != 2 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(Op386MOVWstoreconst)
v.AuxInt = 0
v.AddArg(destptr)
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Zero [4] destptr mem)
+ // cond:
// result: (MOVLstoreconst [0] destptr mem)
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4) {
+ if v.AuxInt != 4 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(Op386MOVLstoreconst)
v.AuxInt = 0
v.AddArg(destptr)
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 3
+ // match: (Zero [3] destptr mem)
+ // cond:
// result: (MOVBstoreconst [makeValAndOff(0,2)] destptr (MOVWstoreconst [0] destptr mem))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 3) {
+ if v.AuxInt != 3 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(Op386MOVBstoreconst)
v.AuxInt = makeValAndOff(0, 2)
v.AddArg(destptr)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 5
+ // match: (Zero [5] destptr mem)
+ // cond:
// result: (MOVBstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 5) {
+ if v.AuxInt != 5 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(Op386MOVBstoreconst)
v.AuxInt = makeValAndOff(0, 4)
v.AddArg(destptr)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 6
+ // match: (Zero [6] destptr mem)
+ // cond:
// result: (MOVWstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 6) {
+ if v.AuxInt != 6 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(Op386MOVWstoreconst)
v.AuxInt = makeValAndOff(0, 4)
v.AddArg(destptr)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 7
+ // match: (Zero [7] destptr mem)
+ // cond:
// result: (MOVLstoreconst [makeValAndOff(0,3)] destptr (MOVLstoreconst [0] destptr mem))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 7) {
+ if v.AuxInt != 7 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(Op386MOVLstoreconst)
v.AuxInt = makeValAndOff(0, 3)
v.AddArg(destptr)
return true
}
// match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size()%4 != 0 && SizeAndAlign(s).Size() > 4
- // result: (Zero [SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%4] (ADDLconst destptr [SizeAndAlign(s).Size()%4]) (MOVLstoreconst [0] destptr mem))
+ // cond: s%4 != 0 && s > 4
+ // result: (Zero [s-s%4] (ADDLconst destptr [s%4]) (MOVLstoreconst [0] destptr mem))
for {
s := v.AuxInt
destptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size()%4 != 0 && SizeAndAlign(s).Size() > 4) {
+ if !(s%4 != 0 && s > 4) {
break
}
v.reset(OpZero)
- v.AuxInt = SizeAndAlign(s).Size() - SizeAndAlign(s).Size()%4
+ v.AuxInt = s - s%4
v0 := b.NewValue0(v.Pos, Op386ADDLconst, config.fe.TypeUInt32())
- v0.AuxInt = SizeAndAlign(s).Size() % 4
+ v0.AuxInt = s % 4
v0.AddArg(destptr)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, Op386MOVLstoreconst, TypeMem)
v.AddArg(v1)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 8
+ // match: (Zero [8] destptr mem)
+ // cond:
// result: (MOVLstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 8) {
+ if v.AuxInt != 8 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(Op386MOVLstoreconst)
v.AuxInt = makeValAndOff(0, 4)
v.AddArg(destptr)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 12
+ // match: (Zero [12] destptr mem)
+ // cond:
// result: (MOVLstoreconst [makeValAndOff(0,8)] destptr (MOVLstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem)))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 12) {
+ if v.AuxInt != 12 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(Op386MOVLstoreconst)
v.AuxInt = makeValAndOff(0, 8)
v.AddArg(destptr)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 16
+ // match: (Zero [16] destptr mem)
+ // cond:
// result: (MOVLstoreconst [makeValAndOff(0,12)] destptr (MOVLstoreconst [makeValAndOff(0,8)] destptr (MOVLstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem))))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 16) {
+ if v.AuxInt != 16 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(Op386MOVLstoreconst)
v.AuxInt = makeValAndOff(0, 12)
v.AddArg(destptr)
return true
}
// match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() > 16 && SizeAndAlign(s).Size() <= 4*128 && SizeAndAlign(s).Size()%4 == 0 && !config.noDuffDevice
- // result: (DUFFZERO [1*(128-SizeAndAlign(s).Size()/4)] destptr (MOVLconst [0]) mem)
+ // cond: s > 16 && s <= 4*128 && s%4 == 0 && !config.noDuffDevice
+ // result: (DUFFZERO [1*(128-s/4)] destptr (MOVLconst [0]) mem)
for {
s := v.AuxInt
destptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() > 16 && SizeAndAlign(s).Size() <= 4*128 && SizeAndAlign(s).Size()%4 == 0 && !config.noDuffDevice) {
+ if !(s > 16 && s <= 4*128 && s%4 == 0 && !config.noDuffDevice) {
break
}
v.reset(Op386DUFFZERO)
- v.AuxInt = 1 * (128 - SizeAndAlign(s).Size()/4)
+ v.AuxInt = 1 * (128 - s/4)
v.AddArg(destptr)
v0 := b.NewValue0(v.Pos, Op386MOVLconst, config.fe.TypeUInt32())
v0.AuxInt = 0
return true
}
// match: (Zero [s] destptr mem)
- // cond: (SizeAndAlign(s).Size() > 4*128 || (config.noDuffDevice && SizeAndAlign(s).Size() > 16)) && SizeAndAlign(s).Size()%4 == 0
- // result: (REPSTOSL destptr (MOVLconst [SizeAndAlign(s).Size()/4]) (MOVLconst [0]) mem)
+ // cond: (s > 4*128 || (config.noDuffDevice && s > 16)) && s%4 == 0
+ // result: (REPSTOSL destptr (MOVLconst [s/4]) (MOVLconst [0]) mem)
for {
s := v.AuxInt
destptr := v.Args[0]
mem := v.Args[1]
- if !((SizeAndAlign(s).Size() > 4*128 || (config.noDuffDevice && SizeAndAlign(s).Size() > 16)) && SizeAndAlign(s).Size()%4 == 0) {
+ if !((s > 4*128 || (config.noDuffDevice && s > 16)) && s%4 == 0) {
break
}
v.reset(Op386REPSTOSL)
v.AddArg(destptr)
v0 := b.NewValue0(v.Pos, Op386MOVLconst, config.fe.TypeUInt32())
- v0.AuxInt = SizeAndAlign(s).Size() / 4
+ v0.AuxInt = s / 4
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, Op386MOVLconst, config.fe.TypeUInt32())
v1.AuxInt = 0
func rewriteValueAMD64_OpMove(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Move [s] _ _ mem)
- // cond: SizeAndAlign(s).Size() == 0
+ // match: (Move [0] _ _ mem)
+ // cond:
// result: mem
for {
- s := v.AuxInt
- mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 0) {
+ if v.AuxInt != 0 {
break
}
+ mem := v.Args[2]
v.reset(OpCopy)
v.Type = mem.Type
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 1
+ // match: (Move [1] dst src mem)
+ // cond:
// result: (MOVBstore dst (MOVBload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 1 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 1) {
- break
- }
v.reset(OpAMD64MOVBstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, config.fe.TypeUInt8())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 2
+ // match: (Move [2] dst src mem)
+ // cond:
// result: (MOVWstore dst (MOVWload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 2 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 2) {
- break
- }
v.reset(OpAMD64MOVWstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, config.fe.TypeUInt16())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Move [4] dst src mem)
+ // cond:
// result: (MOVLstore dst (MOVLload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 4) {
- break
- }
v.reset(OpAMD64MOVLstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, config.fe.TypeUInt32())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 8
+ // match: (Move [8] dst src mem)
+ // cond:
// result: (MOVQstore dst (MOVQload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 8) {
- break
- }
v.reset(OpAMD64MOVQstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, config.fe.TypeUInt64())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 16
+ // match: (Move [16] dst src mem)
+ // cond:
// result: (MOVOstore dst (MOVOload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 16 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 16) {
- break
- }
v.reset(OpAMD64MOVOstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpAMD64MOVOload, TypeInt128)
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 3
+ // match: (Move [3] dst src mem)
+ // cond:
// result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVWstore dst (MOVWload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 3 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 3) {
- break
- }
v.reset(OpAMD64MOVBstore)
v.AuxInt = 2
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 5
+ // match: (Move [5] dst src mem)
+ // cond:
// result: (MOVBstore [4] dst (MOVBload [4] src mem) (MOVLstore dst (MOVLload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 5 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 5) {
- break
- }
v.reset(OpAMD64MOVBstore)
v.AuxInt = 4
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 6
+ // match: (Move [6] dst src mem)
+ // cond:
// result: (MOVWstore [4] dst (MOVWload [4] src mem) (MOVLstore dst (MOVLload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 6 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 6) {
- break
- }
v.reset(OpAMD64MOVWstore)
v.AuxInt = 4
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 7
+ // match: (Move [7] dst src mem)
+ // cond:
// result: (MOVLstore [3] dst (MOVLload [3] src mem) (MOVLstore dst (MOVLload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 7 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 7) {
- break
- }
v.reset(OpAMD64MOVLstore)
v.AuxInt = 3
v.AddArg(dst)
return true
}
// match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() > 8 && SizeAndAlign(s).Size() < 16
- // result: (MOVQstore [SizeAndAlign(s).Size()-8] dst (MOVQload [SizeAndAlign(s).Size()-8] src mem) (MOVQstore dst (MOVQload src mem) mem))
+ // cond: s > 8 && s < 16
+ // result: (MOVQstore [s-8] dst (MOVQload [s-8] src mem) (MOVQstore dst (MOVQload src mem) mem))
for {
s := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() > 8 && SizeAndAlign(s).Size() < 16) {
+ if !(s > 8 && s < 16) {
break
}
v.reset(OpAMD64MOVQstore)
- v.AuxInt = SizeAndAlign(s).Size() - 8
+ v.AuxInt = s - 8
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, config.fe.TypeUInt64())
- v0.AuxInt = SizeAndAlign(s).Size() - 8
+ v0.AuxInt = s - 8
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
return true
}
// match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() > 16 && SizeAndAlign(s).Size()%16 != 0 && SizeAndAlign(s).Size()%16 <= 8
- // result: (Move [SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%16] (OffPtr <dst.Type> dst [SizeAndAlign(s).Size()%16]) (OffPtr <src.Type> src [SizeAndAlign(s).Size()%16]) (MOVQstore dst (MOVQload src mem) mem))
+ // cond: s > 16 && s%16 != 0 && s%16 <= 8
+ // result: (Move [s-s%16] (OffPtr <dst.Type> dst [s%16]) (OffPtr <src.Type> src [s%16]) (MOVQstore dst (MOVQload src mem) mem))
for {
s := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() > 16 && SizeAndAlign(s).Size()%16 != 0 && SizeAndAlign(s).Size()%16 <= 8) {
+ if !(s > 16 && s%16 != 0 && s%16 <= 8) {
break
}
v.reset(OpMove)
- v.AuxInt = SizeAndAlign(s).Size() - SizeAndAlign(s).Size()%16
+ v.AuxInt = s - s%16
v0 := b.NewValue0(v.Pos, OpOffPtr, dst.Type)
- v0.AuxInt = SizeAndAlign(s).Size() % 16
+ v0.AuxInt = s % 16
v0.AddArg(dst)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpOffPtr, src.Type)
- v1.AuxInt = SizeAndAlign(s).Size() % 16
+ v1.AuxInt = s % 16
v1.AddArg(src)
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpAMD64MOVQstore, TypeMem)
return true
}
// match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() > 16 && SizeAndAlign(s).Size()%16 != 0 && SizeAndAlign(s).Size()%16 > 8
- // result: (Move [SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%16] (OffPtr <dst.Type> dst [SizeAndAlign(s).Size()%16]) (OffPtr <src.Type> src [SizeAndAlign(s).Size()%16]) (MOVOstore dst (MOVOload src mem) mem))
+ // cond: s > 16 && s%16 != 0 && s%16 > 8
+ // result: (Move [s-s%16] (OffPtr <dst.Type> dst [s%16]) (OffPtr <src.Type> src [s%16]) (MOVOstore dst (MOVOload src mem) mem))
for {
s := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() > 16 && SizeAndAlign(s).Size()%16 != 0 && SizeAndAlign(s).Size()%16 > 8) {
+ if !(s > 16 && s%16 != 0 && s%16 > 8) {
break
}
v.reset(OpMove)
- v.AuxInt = SizeAndAlign(s).Size() - SizeAndAlign(s).Size()%16
+ v.AuxInt = s - s%16
v0 := b.NewValue0(v.Pos, OpOffPtr, dst.Type)
- v0.AuxInt = SizeAndAlign(s).Size() % 16
+ v0.AuxInt = s % 16
v0.AddArg(dst)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpOffPtr, src.Type)
- v1.AuxInt = SizeAndAlign(s).Size() % 16
+ v1.AuxInt = s % 16
v1.AddArg(src)
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpAMD64MOVOstore, TypeMem)
return true
}
// match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() >= 32 && SizeAndAlign(s).Size() <= 16*64 && SizeAndAlign(s).Size()%16 == 0 && !config.noDuffDevice
- // result: (DUFFCOPY [14*(64-SizeAndAlign(s).Size()/16)] dst src mem)
+ // cond: s >= 32 && s <= 16*64 && s%16 == 0 && !config.noDuffDevice
+ // result: (DUFFCOPY [14*(64-s/16)] dst src mem)
for {
s := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() >= 32 && SizeAndAlign(s).Size() <= 16*64 && SizeAndAlign(s).Size()%16 == 0 && !config.noDuffDevice) {
+ if !(s >= 32 && s <= 16*64 && s%16 == 0 && !config.noDuffDevice) {
break
}
v.reset(OpAMD64DUFFCOPY)
- v.AuxInt = 14 * (64 - SizeAndAlign(s).Size()/16)
+ v.AuxInt = 14 * (64 - s/16)
v.AddArg(dst)
v.AddArg(src)
v.AddArg(mem)
return true
}
// match: (Move [s] dst src mem)
- // cond: (SizeAndAlign(s).Size() > 16*64 || config.noDuffDevice) && SizeAndAlign(s).Size()%8 == 0
- // result: (REPMOVSQ dst src (MOVQconst [SizeAndAlign(s).Size()/8]) mem)
+ // cond: (s > 16*64 || config.noDuffDevice) && s%8 == 0
+ // result: (REPMOVSQ dst src (MOVQconst [s/8]) mem)
for {
s := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !((SizeAndAlign(s).Size() > 16*64 || config.noDuffDevice) && SizeAndAlign(s).Size()%8 == 0) {
+ if !((s > 16*64 || config.noDuffDevice) && s%8 == 0) {
break
}
v.reset(OpAMD64REPMOVSQ)
v.AddArg(dst)
v.AddArg(src)
v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, config.fe.TypeUInt64())
- v0.AuxInt = SizeAndAlign(s).Size() / 8
+ v0.AuxInt = s / 8
v.AddArg(v0)
v.AddArg(mem)
return true
func rewriteValueAMD64_OpStore(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Store [8] ptr val mem)
- // cond: is64BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
// result: (MOVSDstore ptr val mem)
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is64BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 8 && is64BitFloat(val.Type)) {
break
}
v.reset(OpAMD64MOVSDstore)
v.AddArg(mem)
return true
}
- // match: (Store [4] ptr val mem)
- // cond: is32BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 4 && is32BitFloat(val.Type)
// result: (MOVSSstore ptr val mem)
for {
- if v.AuxInt != 4 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is32BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 4 && is32BitFloat(val.Type)) {
break
}
v.reset(OpAMD64MOVSSstore)
v.AddArg(mem)
return true
}
- // match: (Store [8] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 8
// result: (MOVQstore ptr val mem)
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 8) {
+ break
+ }
v.reset(OpAMD64MOVQstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [4] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 4
// result: (MOVLstore ptr val mem)
for {
- if v.AuxInt != 4 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 4) {
+ break
+ }
v.reset(OpAMD64MOVLstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [2] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 2
// result: (MOVWstore ptr val mem)
for {
- if v.AuxInt != 2 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 2) {
+ break
+ }
v.reset(OpAMD64MOVWstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [1] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 1
// result: (MOVBstore ptr val mem)
for {
- if v.AuxInt != 1 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 1) {
+ break
+ }
v.reset(OpAMD64MOVBstore)
v.AddArg(ptr)
v.AddArg(val)
func rewriteValueAMD64_OpZero(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Zero [s] _ mem)
- // cond: SizeAndAlign(s).Size() == 0
+ // match: (Zero [0] _ mem)
+ // cond:
// result: mem
for {
- s := v.AuxInt
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 0) {
+ if v.AuxInt != 0 {
break
}
+ mem := v.Args[1]
v.reset(OpCopy)
v.Type = mem.Type
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 1
+ // match: (Zero [1] destptr mem)
+ // cond:
// result: (MOVBstoreconst [0] destptr mem)
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 1) {
+ if v.AuxInt != 1 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpAMD64MOVBstoreconst)
v.AuxInt = 0
v.AddArg(destptr)
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 2
+ // match: (Zero [2] destptr mem)
+ // cond:
// result: (MOVWstoreconst [0] destptr mem)
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 2) {
+ if v.AuxInt != 2 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpAMD64MOVWstoreconst)
v.AuxInt = 0
v.AddArg(destptr)
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Zero [4] destptr mem)
+ // cond:
// result: (MOVLstoreconst [0] destptr mem)
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4) {
+ if v.AuxInt != 4 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpAMD64MOVLstoreconst)
v.AuxInt = 0
v.AddArg(destptr)
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 8
+ // match: (Zero [8] destptr mem)
+ // cond:
// result: (MOVQstoreconst [0] destptr mem)
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 8) {
+ if v.AuxInt != 8 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpAMD64MOVQstoreconst)
v.AuxInt = 0
v.AddArg(destptr)
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 3
+ // match: (Zero [3] destptr mem)
+ // cond:
// result: (MOVBstoreconst [makeValAndOff(0,2)] destptr (MOVWstoreconst [0] destptr mem))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 3) {
+ if v.AuxInt != 3 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpAMD64MOVBstoreconst)
v.AuxInt = makeValAndOff(0, 2)
v.AddArg(destptr)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 5
+ // match: (Zero [5] destptr mem)
+ // cond:
// result: (MOVBstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 5) {
+ if v.AuxInt != 5 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpAMD64MOVBstoreconst)
v.AuxInt = makeValAndOff(0, 4)
v.AddArg(destptr)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 6
+ // match: (Zero [6] destptr mem)
+ // cond:
// result: (MOVWstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 6) {
+ if v.AuxInt != 6 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpAMD64MOVWstoreconst)
v.AuxInt = makeValAndOff(0, 4)
v.AddArg(destptr)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 7
+ // match: (Zero [7] destptr mem)
+ // cond:
// result: (MOVLstoreconst [makeValAndOff(0,3)] destptr (MOVLstoreconst [0] destptr mem))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 7) {
+ if v.AuxInt != 7 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpAMD64MOVLstoreconst)
v.AuxInt = makeValAndOff(0, 3)
v.AddArg(destptr)
return true
}
// match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size()%8 != 0 && SizeAndAlign(s).Size() > 8
- // result: (Zero [SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%8] (OffPtr <destptr.Type> destptr [SizeAndAlign(s).Size()%8]) (MOVQstoreconst [0] destptr mem))
+ // cond: s%8 != 0 && s > 8
+ // result: (Zero [s-s%8] (OffPtr <destptr.Type> destptr [s%8]) (MOVQstoreconst [0] destptr mem))
for {
s := v.AuxInt
destptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size()%8 != 0 && SizeAndAlign(s).Size() > 8) {
+ if !(s%8 != 0 && s > 8) {
break
}
v.reset(OpZero)
- v.AuxInt = SizeAndAlign(s).Size() - SizeAndAlign(s).Size()%8
+ v.AuxInt = s - s%8
v0 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
- v0.AuxInt = SizeAndAlign(s).Size() % 8
+ v0.AuxInt = s % 8
v0.AddArg(destptr)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVQstoreconst, TypeMem)
v.AddArg(v1)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 16
+ // match: (Zero [16] destptr mem)
+ // cond:
// result: (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 16) {
+ if v.AuxInt != 16 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpAMD64MOVQstoreconst)
v.AuxInt = makeValAndOff(0, 8)
v.AddArg(destptr)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 24
+ // match: (Zero [24] destptr mem)
+ // cond:
// result: (MOVQstoreconst [makeValAndOff(0,16)] destptr (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem)))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 24) {
+ if v.AuxInt != 24 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpAMD64MOVQstoreconst)
v.AuxInt = makeValAndOff(0, 16)
v.AddArg(destptr)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 32
+ // match: (Zero [32] destptr mem)
+ // cond:
// result: (MOVQstoreconst [makeValAndOff(0,24)] destptr (MOVQstoreconst [makeValAndOff(0,16)] destptr (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem))))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 32) {
+ if v.AuxInt != 32 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpAMD64MOVQstoreconst)
v.AuxInt = makeValAndOff(0, 24)
v.AddArg(destptr)
return true
}
// match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() <= 1024 && SizeAndAlign(s).Size()%8 == 0 && SizeAndAlign(s).Size()%16 != 0 && !config.noDuffDevice
- // result: (Zero [SizeAndAlign(s).Size()-8] (OffPtr <destptr.Type> [8] destptr) (MOVQstore destptr (MOVQconst [0]) mem))
+ // cond: s <= 1024 && s%8 == 0 && s%16 != 0 && !config.noDuffDevice
+ // result: (Zero [s-8] (OffPtr <destptr.Type> [8] destptr) (MOVQstore destptr (MOVQconst [0]) mem))
for {
s := v.AuxInt
destptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() <= 1024 && SizeAndAlign(s).Size()%8 == 0 && SizeAndAlign(s).Size()%16 != 0 && !config.noDuffDevice) {
+ if !(s <= 1024 && s%8 == 0 && s%16 != 0 && !config.noDuffDevice) {
break
}
v.reset(OpZero)
- v.AuxInt = SizeAndAlign(s).Size() - 8
+ v.AuxInt = s - 8
v0 := b.NewValue0(v.Pos, OpOffPtr, destptr.Type)
v0.AuxInt = 8
v0.AddArg(destptr)
return true
}
// match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() <= 1024 && SizeAndAlign(s).Size()%16 == 0 && !config.noDuffDevice
- // result: (DUFFZERO [SizeAndAlign(s).Size()] destptr (MOVOconst [0]) mem)
+ // cond: s <= 1024 && s%16 == 0 && !config.noDuffDevice
+ // result: (DUFFZERO [s] destptr (MOVOconst [0]) mem)
for {
s := v.AuxInt
destptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() <= 1024 && SizeAndAlign(s).Size()%16 == 0 && !config.noDuffDevice) {
+ if !(s <= 1024 && s%16 == 0 && !config.noDuffDevice) {
break
}
v.reset(OpAMD64DUFFZERO)
- v.AuxInt = SizeAndAlign(s).Size()
+ v.AuxInt = s
v.AddArg(destptr)
v0 := b.NewValue0(v.Pos, OpAMD64MOVOconst, TypeInt128)
v0.AuxInt = 0
return true
}
// match: (Zero [s] destptr mem)
- // cond: (SizeAndAlign(s).Size() > 1024 || (config.noDuffDevice && SizeAndAlign(s).Size() > 32)) && SizeAndAlign(s).Size()%8 == 0
- // result: (REPSTOSQ destptr (MOVQconst [SizeAndAlign(s).Size()/8]) (MOVQconst [0]) mem)
+ // cond: (s > 1024 || (config.noDuffDevice && s > 32)) && s%8 == 0
+ // result: (REPSTOSQ destptr (MOVQconst [s/8]) (MOVQconst [0]) mem)
for {
s := v.AuxInt
destptr := v.Args[0]
mem := v.Args[1]
- if !((SizeAndAlign(s).Size() > 1024 || (config.noDuffDevice && SizeAndAlign(s).Size() > 32)) && SizeAndAlign(s).Size()%8 == 0) {
+ if !((s > 1024 || (config.noDuffDevice && s > 32)) && s%8 == 0) {
break
}
v.reset(OpAMD64REPSTOSQ)
v.AddArg(destptr)
v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, config.fe.TypeUInt64())
- v0.AuxInt = SizeAndAlign(s).Size() / 8
+ v0.AuxInt = s / 8
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVQconst, config.fe.TypeUInt64())
v1.AuxInt = 0
func rewriteValueARM_OpMove(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Move [s] _ _ mem)
- // cond: SizeAndAlign(s).Size() == 0
+ // match: (Move [0] _ _ mem)
+ // cond:
// result: mem
for {
- s := v.AuxInt
- mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 0) {
+ if v.AuxInt != 0 {
break
}
+ mem := v.Args[2]
v.reset(OpCopy)
v.Type = mem.Type
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 1
+ // match: (Move [1] dst src mem)
+ // cond:
// result: (MOVBstore dst (MOVBUload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 1 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 1) {
- break
- }
v.reset(OpARMMOVBstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpARMMOVBUload, config.fe.TypeUInt8())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Move [2] {t} dst src mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore dst (MOVHUload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 2 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpARMMOVHstore)
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 2
+ // match: (Move [2] dst src mem)
+ // cond:
// result: (MOVBstore [1] dst (MOVBUload [1] src mem) (MOVBstore dst (MOVBUload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 2 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 2) {
- break
- }
v.reset(OpARMMOVBstore)
v.AuxInt = 1
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Move [4] {t} dst src mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore dst (MOVWload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpARMMOVWstore)
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Move [4] {t} dst src mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [2] dst (MOVHUload [2] src mem) (MOVHstore dst (MOVHUload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpARMMOVHstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Move [4] dst src mem)
+ // cond:
// result: (MOVBstore [3] dst (MOVBUload [3] src mem) (MOVBstore [2] dst (MOVBUload [2] src mem) (MOVBstore [1] dst (MOVBUload [1] src mem) (MOVBstore dst (MOVBUload src mem) mem))))
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 4) {
- break
- }
v.reset(OpARMMOVBstore)
v.AuxInt = 3
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 3
+ // match: (Move [3] dst src mem)
+ // cond:
// result: (MOVBstore [2] dst (MOVBUload [2] src mem) (MOVBstore [1] dst (MOVBUload [1] src mem) (MOVBstore dst (MOVBUload src mem) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 3 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 3) {
- break
- }
v.reset(OpARMMOVBstore)
v.AuxInt = 2
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size()%4 == 0 && SizeAndAlign(s).Size() > 4 && SizeAndAlign(s).Size() <= 512 && SizeAndAlign(s).Align()%4 == 0 && !config.noDuffDevice
- // result: (DUFFCOPY [8 * (128 - int64(SizeAndAlign(s).Size()/4))] dst src mem)
+ // match: (Move [s] {t} dst src mem)
+ // cond: s%4 == 0 && s > 4 && s <= 512 && t.(Type).Alignment()%4 == 0 && !config.noDuffDevice
+ // result: (DUFFCOPY [8 * (128 - int64(s/4))] dst src mem)
for {
s := v.AuxInt
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size()%4 == 0 && SizeAndAlign(s).Size() > 4 && SizeAndAlign(s).Size() <= 512 && SizeAndAlign(s).Align()%4 == 0 && !config.noDuffDevice) {
+ if !(s%4 == 0 && s > 4 && s <= 512 && t.(Type).Alignment()%4 == 0 && !config.noDuffDevice) {
break
}
v.reset(OpARMDUFFCOPY)
- v.AuxInt = 8 * (128 - int64(SizeAndAlign(s).Size()/4))
+ v.AuxInt = 8 * (128 - int64(s/4))
v.AddArg(dst)
v.AddArg(src)
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: (SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%4 != 0
- // result: (LoweredMove [SizeAndAlign(s).Align()] dst src (ADDconst <src.Type> src [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)]) mem)
+ // match: (Move [s] {t} dst src mem)
+ // cond: (s > 512 || config.noDuffDevice) || t.(Type).Alignment()%4 != 0
+ // result: (LoweredMove [t.(Type).Alignment()] dst src (ADDconst <src.Type> src [s-moveSize(t.(Type).Alignment(), config)]) mem)
for {
s := v.AuxInt
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !((SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%4 != 0) {
+ if !((s > 512 || config.noDuffDevice) || t.(Type).Alignment()%4 != 0) {
break
}
v.reset(OpARMLoweredMove)
- v.AuxInt = SizeAndAlign(s).Align()
+ v.AuxInt = t.(Type).Alignment()
v.AddArg(dst)
v.AddArg(src)
v0 := b.NewValue0(v.Pos, OpARMADDconst, src.Type)
- v0.AuxInt = SizeAndAlign(s).Size() - moveSize(SizeAndAlign(s).Align(), config)
+ v0.AuxInt = s - moveSize(t.(Type).Alignment(), config)
v0.AddArg(src)
v.AddArg(v0)
v.AddArg(mem)
func rewriteValueARM_OpStore(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Store [1] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 1
// result: (MOVBstore ptr val mem)
for {
- if v.AuxInt != 1 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 1) {
+ break
+ }
v.reset(OpARMMOVBstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [2] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 2
// result: (MOVHstore ptr val mem)
for {
- if v.AuxInt != 2 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 2) {
+ break
+ }
v.reset(OpARMMOVHstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [4] ptr val mem)
- // cond: !is32BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 4 && !is32BitFloat(val.Type)
// result: (MOVWstore ptr val mem)
for {
- if v.AuxInt != 4 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(!is32BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 4 && !is32BitFloat(val.Type)) {
break
}
v.reset(OpARMMOVWstore)
v.AddArg(mem)
return true
}
- // match: (Store [4] ptr val mem)
- // cond: is32BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 4 && is32BitFloat(val.Type)
// result: (MOVFstore ptr val mem)
for {
- if v.AuxInt != 4 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is32BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 4 && is32BitFloat(val.Type)) {
break
}
v.reset(OpARMMOVFstore)
v.AddArg(mem)
return true
}
- // match: (Store [8] ptr val mem)
- // cond: is64BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
// result: (MOVDstore ptr val mem)
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is64BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 8 && is64BitFloat(val.Type)) {
break
}
v.reset(OpARMMOVDstore)
func rewriteValueARM_OpZero(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Zero [s] _ mem)
- // cond: SizeAndAlign(s).Size() == 0
+ // match: (Zero [0] _ mem)
+ // cond:
// result: mem
for {
- s := v.AuxInt
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 0) {
+ if v.AuxInt != 0 {
break
}
+ mem := v.Args[1]
v.reset(OpCopy)
v.Type = mem.Type
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 1
+ // match: (Zero [1] ptr mem)
+ // cond:
// result: (MOVBstore ptr (MOVWconst [0]) mem)
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 1) {
+ if v.AuxInt != 1 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpARMMOVBstore)
v.AddArg(ptr)
v0 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32())
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Zero [2] {t} ptr mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore ptr (MOVWconst [0]) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 2 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpARMMOVHstore)
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 2
+ // match: (Zero [2] ptr mem)
+ // cond:
// result: (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem))
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 2) {
+ if v.AuxInt != 2 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpARMMOVBstore)
v.AuxInt = 1
v.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Zero [4] {t} ptr mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore ptr (MOVWconst [0]) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpARMMOVWstore)
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Zero [4] {t} ptr mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [2] ptr (MOVWconst [0]) (MOVHstore [0] ptr (MOVWconst [0]) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpARMMOVHstore)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Zero [4] ptr mem)
+ // cond:
// result: (MOVBstore [3] ptr (MOVWconst [0]) (MOVBstore [2] ptr (MOVWconst [0]) (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem))))
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4) {
+ if v.AuxInt != 4 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpARMMOVBstore)
v.AuxInt = 3
v.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 3
+ // match: (Zero [3] ptr mem)
+ // cond:
// result: (MOVBstore [2] ptr (MOVWconst [0]) (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem)))
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 3) {
+ if v.AuxInt != 3 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpARMMOVBstore)
v.AuxInt = 2
v.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size()%4 == 0 && SizeAndAlign(s).Size() > 4 && SizeAndAlign(s).Size() <= 512 && SizeAndAlign(s).Align()%4 == 0 && !config.noDuffDevice
- // result: (DUFFZERO [4 * (128 - int64(SizeAndAlign(s).Size()/4))] ptr (MOVWconst [0]) mem)
+ // match: (Zero [s] {t} ptr mem)
+ // cond: s%4 == 0 && s > 4 && s <= 512 && t.(Type).Alignment()%4 == 0 && !config.noDuffDevice
+ // result: (DUFFZERO [4 * (128 - int64(s/4))] ptr (MOVWconst [0]) mem)
for {
s := v.AuxInt
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size()%4 == 0 && SizeAndAlign(s).Size() > 4 && SizeAndAlign(s).Size() <= 512 && SizeAndAlign(s).Align()%4 == 0 && !config.noDuffDevice) {
+ if !(s%4 == 0 && s > 4 && s <= 512 && t.(Type).Alignment()%4 == 0 && !config.noDuffDevice) {
break
}
v.reset(OpARMDUFFZERO)
- v.AuxInt = 4 * (128 - int64(SizeAndAlign(s).Size()/4))
+ v.AuxInt = 4 * (128 - int64(s/4))
v.AddArg(ptr)
v0 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32())
v0.AuxInt = 0
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: (SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%4 != 0
- // result: (LoweredZero [SizeAndAlign(s).Align()] ptr (ADDconst <ptr.Type> ptr [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)]) (MOVWconst [0]) mem)
+ // match: (Zero [s] {t} ptr mem)
+ // cond: (s > 512 || config.noDuffDevice) || t.(Type).Alignment()%4 != 0
+ // result: (LoweredZero [t.(Type).Alignment()] ptr (ADDconst <ptr.Type> ptr [s-moveSize(t.(Type).Alignment(), config)]) (MOVWconst [0]) mem)
for {
s := v.AuxInt
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !((SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%4 != 0) {
+ if !((s > 512 || config.noDuffDevice) || t.(Type).Alignment()%4 != 0) {
break
}
v.reset(OpARMLoweredZero)
- v.AuxInt = SizeAndAlign(s).Align()
+ v.AuxInt = t.(Type).Alignment()
v.AddArg(ptr)
v0 := b.NewValue0(v.Pos, OpARMADDconst, ptr.Type)
- v0.AuxInt = SizeAndAlign(s).Size() - moveSize(SizeAndAlign(s).Align(), config)
+ v0.AuxInt = s - moveSize(t.(Type).Alignment(), config)
v0.AddArg(ptr)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARMMOVWconst, config.fe.TypeUInt32())
func rewriteValueARM64_OpMove(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Move [s] _ _ mem)
- // cond: SizeAndAlign(s).Size() == 0
+ // match: (Move [0] _ _ mem)
+ // cond:
// result: mem
for {
- s := v.AuxInt
- mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 0) {
+ if v.AuxInt != 0 {
break
}
+ mem := v.Args[2]
v.reset(OpCopy)
v.Type = mem.Type
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 1
+ // match: (Move [1] dst src mem)
+ // cond:
// result: (MOVBstore dst (MOVBUload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 1 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 1) {
- break
- }
v.reset(OpARM64MOVBstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, config.fe.TypeUInt8())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 2
+ // match: (Move [2] dst src mem)
+ // cond:
// result: (MOVHstore dst (MOVHUload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 2 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 2) {
- break
- }
v.reset(OpARM64MOVHstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpARM64MOVHUload, config.fe.TypeUInt16())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Move [4] dst src mem)
+ // cond:
// result: (MOVWstore dst (MOVWUload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 4) {
- break
- }
v.reset(OpARM64MOVWstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpARM64MOVWUload, config.fe.TypeUInt32())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 8
+ // match: (Move [8] dst src mem)
+ // cond:
// result: (MOVDstore dst (MOVDload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 8) {
- break
- }
v.reset(OpARM64MOVDstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpARM64MOVDload, config.fe.TypeUInt64())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 3
+ // match: (Move [3] dst src mem)
+ // cond:
// result: (MOVBstore [2] dst (MOVBUload [2] src mem) (MOVHstore dst (MOVHUload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 3 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 3) {
- break
- }
v.reset(OpARM64MOVBstore)
v.AuxInt = 2
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 5
+ // match: (Move [5] dst src mem)
+ // cond:
// result: (MOVBstore [4] dst (MOVBUload [4] src mem) (MOVWstore dst (MOVWUload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 5 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 5) {
- break
- }
v.reset(OpARM64MOVBstore)
v.AuxInt = 4
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 6
+ // match: (Move [6] dst src mem)
+ // cond:
// result: (MOVHstore [4] dst (MOVHUload [4] src mem) (MOVWstore dst (MOVWUload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 6 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 6) {
- break
- }
v.reset(OpARM64MOVHstore)
v.AuxInt = 4
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 7
+ // match: (Move [7] dst src mem)
+ // cond:
// result: (MOVBstore [6] dst (MOVBUload [6] src mem) (MOVHstore [4] dst (MOVHUload [4] src mem) (MOVWstore dst (MOVWUload src mem) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 7 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 7) {
- break
- }
v.reset(OpARM64MOVBstore)
v.AuxInt = 6
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 12
+ // match: (Move [12] dst src mem)
+ // cond:
// result: (MOVWstore [8] dst (MOVWUload [8] src mem) (MOVDstore dst (MOVDload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 12 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 12) {
- break
- }
v.reset(OpARM64MOVWstore)
v.AuxInt = 8
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 16
+ // match: (Move [16] dst src mem)
+ // cond:
// result: (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 16 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 16) {
- break
- }
v.reset(OpARM64MOVDstore)
v.AuxInt = 8
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 24
+ // match: (Move [24] dst src mem)
+ // cond:
// result: (MOVDstore [16] dst (MOVDload [16] src mem) (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 24 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 24) {
- break
- }
v.reset(OpARM64MOVDstore)
v.AuxInt = 16
v.AddArg(dst)
return true
}
// match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size()%8 != 0 && SizeAndAlign(s).Size() > 8
- // result: (Move [MakeSizeAndAlign(SizeAndAlign(s).Size()%8, 1).Int64()] (OffPtr <dst.Type> dst [SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%8]) (OffPtr <src.Type> src [SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%8]) (Move [MakeSizeAndAlign(SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%8, 1).Int64()] dst src mem))
+ // cond: s%8 != 0 && s > 8
+ // result: (Move [s%8] (OffPtr <dst.Type> dst [s-s%8]) (OffPtr <src.Type> src [s-s%8]) (Move [s-s%8] dst src mem))
for {
s := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size()%8 != 0 && SizeAndAlign(s).Size() > 8) {
+ if !(s%8 != 0 && s > 8) {
break
}
v.reset(OpMove)
- v.AuxInt = MakeSizeAndAlign(SizeAndAlign(s).Size()%8, 1).Int64()
+ v.AuxInt = s % 8
v0 := b.NewValue0(v.Pos, OpOffPtr, dst.Type)
- v0.AuxInt = SizeAndAlign(s).Size() - SizeAndAlign(s).Size()%8
+ v0.AuxInt = s - s%8
v0.AddArg(dst)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpOffPtr, src.Type)
- v1.AuxInt = SizeAndAlign(s).Size() - SizeAndAlign(s).Size()%8
+ v1.AuxInt = s - s%8
v1.AddArg(src)
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpMove, TypeMem)
- v2.AuxInt = MakeSizeAndAlign(SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%8, 1).Int64()
+ v2.AuxInt = s - s%8
v2.AddArg(dst)
v2.AddArg(src)
v2.AddArg(mem)
return true
}
// match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size()%8 == 0 && SizeAndAlign(s).Size() > 24 && SizeAndAlign(s).Size() <= 8*128 && !config.noDuffDevice
- // result: (DUFFCOPY [8 * (128 - int64(SizeAndAlign(s).Size()/8))] dst src mem)
+ // cond: s%8 == 0 && s > 24 && s <= 8*128 && !config.noDuffDevice
+ // result: (DUFFCOPY [8 * (128 - int64(s/8))] dst src mem)
for {
s := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size()%8 == 0 && SizeAndAlign(s).Size() > 24 && SizeAndAlign(s).Size() <= 8*128 && !config.noDuffDevice) {
+ if !(s%8 == 0 && s > 24 && s <= 8*128 && !config.noDuffDevice) {
break
}
v.reset(OpARM64DUFFCOPY)
- v.AuxInt = 8 * (128 - int64(SizeAndAlign(s).Size()/8))
+ v.AuxInt = 8 * (128 - int64(s/8))
v.AddArg(dst)
v.AddArg(src)
v.AddArg(mem)
return true
}
// match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() > 24 && SizeAndAlign(s).Size()%8 == 0
- // result: (LoweredMove dst src (ADDconst <src.Type> src [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)]) mem)
+ // cond: s > 24 && s%8 == 0
+ // result: (LoweredMove dst src (ADDconst <src.Type> src [s-8]) mem)
for {
s := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() > 24 && SizeAndAlign(s).Size()%8 == 0) {
+ if !(s > 24 && s%8 == 0) {
break
}
v.reset(OpARM64LoweredMove)
v.AddArg(dst)
v.AddArg(src)
v0 := b.NewValue0(v.Pos, OpARM64ADDconst, src.Type)
- v0.AuxInt = SizeAndAlign(s).Size() - moveSize(SizeAndAlign(s).Align(), config)
+ v0.AuxInt = s - 8
v0.AddArg(src)
v.AddArg(v0)
v.AddArg(mem)
func rewriteValueARM64_OpStore(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Store [1] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 1
// result: (MOVBstore ptr val mem)
for {
- if v.AuxInt != 1 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 1) {
+ break
+ }
v.reset(OpARM64MOVBstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [2] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 2
// result: (MOVHstore ptr val mem)
for {
- if v.AuxInt != 2 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 2) {
+ break
+ }
v.reset(OpARM64MOVHstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [4] ptr val mem)
- // cond: !is32BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 4 && !is32BitFloat(val.Type)
// result: (MOVWstore ptr val mem)
for {
- if v.AuxInt != 4 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(!is32BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 4 && !is32BitFloat(val.Type)) {
break
}
v.reset(OpARM64MOVWstore)
v.AddArg(mem)
return true
}
- // match: (Store [8] ptr val mem)
- // cond: !is64BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 8 && !is64BitFloat(val.Type)
// result: (MOVDstore ptr val mem)
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(!is64BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 8 && !is64BitFloat(val.Type)) {
break
}
v.reset(OpARM64MOVDstore)
v.AddArg(mem)
return true
}
- // match: (Store [4] ptr val mem)
- // cond: is32BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 4 && is32BitFloat(val.Type)
// result: (FMOVSstore ptr val mem)
for {
- if v.AuxInt != 4 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is32BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 4 && is32BitFloat(val.Type)) {
break
}
v.reset(OpARM64FMOVSstore)
v.AddArg(mem)
return true
}
- // match: (Store [8] ptr val mem)
- // cond: is64BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
// result: (FMOVDstore ptr val mem)
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is64BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 8 && is64BitFloat(val.Type)) {
break
}
v.reset(OpARM64FMOVDstore)
func rewriteValueARM64_OpZero(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Zero [s] _ mem)
- // cond: SizeAndAlign(s).Size() == 0
+ // match: (Zero [0] _ mem)
+ // cond:
// result: mem
for {
- s := v.AuxInt
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 0) {
+ if v.AuxInt != 0 {
break
}
+ mem := v.Args[1]
v.reset(OpCopy)
v.Type = mem.Type
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 1
+ // match: (Zero [1] ptr mem)
+ // cond:
// result: (MOVBstore ptr (MOVDconst [0]) mem)
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 1) {
+ if v.AuxInt != 1 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpARM64MOVBstore)
v.AddArg(ptr)
v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64())
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 2
+ // match: (Zero [2] ptr mem)
+ // cond:
// result: (MOVHstore ptr (MOVDconst [0]) mem)
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 2) {
+ if v.AuxInt != 2 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpARM64MOVHstore)
v.AddArg(ptr)
v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64())
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Zero [4] ptr mem)
+ // cond:
// result: (MOVWstore ptr (MOVDconst [0]) mem)
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4) {
+ if v.AuxInt != 4 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpARM64MOVWstore)
v.AddArg(ptr)
v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64())
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 8
+ // match: (Zero [8] ptr mem)
+ // cond:
// result: (MOVDstore ptr (MOVDconst [0]) mem)
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 8) {
+ if v.AuxInt != 8 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpARM64MOVDstore)
v.AddArg(ptr)
v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, config.fe.TypeUInt64())
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 3
+ // match: (Zero [3] ptr mem)
+ // cond:
// result: (MOVBstore [2] ptr (MOVDconst [0]) (MOVHstore ptr (MOVDconst [0]) mem))
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 3) {
+ if v.AuxInt != 3 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpARM64MOVBstore)
v.AuxInt = 2
v.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 5
+ // match: (Zero [5] ptr mem)
+ // cond:
// result: (MOVBstore [4] ptr (MOVDconst [0]) (MOVWstore ptr (MOVDconst [0]) mem))
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 5) {
+ if v.AuxInt != 5 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpARM64MOVBstore)
v.AuxInt = 4
v.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 6
+ // match: (Zero [6] ptr mem)
+ // cond:
// result: (MOVHstore [4] ptr (MOVDconst [0]) (MOVWstore ptr (MOVDconst [0]) mem))
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 6) {
+ if v.AuxInt != 6 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpARM64MOVHstore)
v.AuxInt = 4
v.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 7
+ // match: (Zero [7] ptr mem)
+ // cond:
// result: (MOVBstore [6] ptr (MOVDconst [0]) (MOVHstore [4] ptr (MOVDconst [0]) (MOVWstore ptr (MOVDconst [0]) mem)))
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 7) {
+ if v.AuxInt != 7 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpARM64MOVBstore)
v.AuxInt = 6
v.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 12
+ // match: (Zero [12] ptr mem)
+ // cond:
// result: (MOVWstore [8] ptr (MOVDconst [0]) (MOVDstore ptr (MOVDconst [0]) mem))
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 12) {
+ if v.AuxInt != 12 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpARM64MOVWstore)
v.AuxInt = 8
v.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 16
+ // match: (Zero [16] ptr mem)
+ // cond:
// result: (MOVDstore [8] ptr (MOVDconst [0]) (MOVDstore ptr (MOVDconst [0]) mem))
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 16) {
+ if v.AuxInt != 16 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpARM64MOVDstore)
v.AuxInt = 8
v.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 24
+ // match: (Zero [24] ptr mem)
+ // cond:
// result: (MOVDstore [16] ptr (MOVDconst [0]) (MOVDstore [8] ptr (MOVDconst [0]) (MOVDstore ptr (MOVDconst [0]) mem)))
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 24) {
+ if v.AuxInt != 24 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpARM64MOVDstore)
v.AuxInt = 16
v.AddArg(ptr)
return true
}
// match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size()%8 != 0 && SizeAndAlign(s).Size() > 8
- // result: (Zero [MakeSizeAndAlign(SizeAndAlign(s).Size()%8, 1).Int64()] (OffPtr <ptr.Type> ptr [SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%8]) (Zero [MakeSizeAndAlign(SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%8, 1).Int64()] ptr mem))
+ // cond: s%8 != 0 && s > 8
+ // result: (Zero [s%8] (OffPtr <ptr.Type> ptr [s-s%8]) (Zero [s-s%8] ptr mem))
for {
s := v.AuxInt
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size()%8 != 0 && SizeAndAlign(s).Size() > 8) {
+ if !(s%8 != 0 && s > 8) {
break
}
v.reset(OpZero)
- v.AuxInt = MakeSizeAndAlign(SizeAndAlign(s).Size()%8, 1).Int64()
+ v.AuxInt = s % 8
v0 := b.NewValue0(v.Pos, OpOffPtr, ptr.Type)
- v0.AuxInt = SizeAndAlign(s).Size() - SizeAndAlign(s).Size()%8
+ v0.AuxInt = s - s%8
v0.AddArg(ptr)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpZero, TypeMem)
- v1.AuxInt = MakeSizeAndAlign(SizeAndAlign(s).Size()-SizeAndAlign(s).Size()%8, 1).Int64()
+ v1.AuxInt = s - s%8
v1.AddArg(ptr)
v1.AddArg(mem)
v.AddArg(v1)
return true
}
// match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size()%8 == 0 && SizeAndAlign(s).Size() > 24 && SizeAndAlign(s).Size() <= 8*128 && !config.noDuffDevice
- // result: (DUFFZERO [4 * (128 - int64(SizeAndAlign(s).Size()/8))] ptr mem)
+ // cond: s%8 == 0 && s > 24 && s <= 8*128 && !config.noDuffDevice
+ // result: (DUFFZERO [4 * (128 - int64(s/8))] ptr mem)
for {
s := v.AuxInt
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size()%8 == 0 && SizeAndAlign(s).Size() > 24 && SizeAndAlign(s).Size() <= 8*128 && !config.noDuffDevice) {
+ if !(s%8 == 0 && s > 24 && s <= 8*128 && !config.noDuffDevice) {
break
}
v.reset(OpARM64DUFFZERO)
- v.AuxInt = 4 * (128 - int64(SizeAndAlign(s).Size()/8))
+ v.AuxInt = 4 * (128 - int64(s/8))
v.AddArg(ptr)
v.AddArg(mem)
return true
}
// match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size()%8 == 0 && (SizeAndAlign(s).Size() > 8*128 || config.noDuffDevice)
- // result: (LoweredZero ptr (ADDconst <ptr.Type> [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)] ptr) mem)
+ // cond: s%8 == 0 && (s > 8*128 || config.noDuffDevice)
+ // result: (LoweredZero ptr (ADDconst <ptr.Type> [s-8] ptr) mem)
for {
s := v.AuxInt
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size()%8 == 0 && (SizeAndAlign(s).Size() > 8*128 || config.noDuffDevice)) {
+ if !(s%8 == 0 && (s > 8*128 || config.noDuffDevice)) {
break
}
v.reset(OpARM64LoweredZero)
v.AddArg(ptr)
v0 := b.NewValue0(v.Pos, OpARM64ADDconst, ptr.Type)
- v0.AuxInt = SizeAndAlign(s).Size() - moveSize(SizeAndAlign(s).Align(), config)
+ v0.AuxInt = s - 8
v0.AddArg(ptr)
v.AddArg(v0)
v.AddArg(mem)
func rewriteValueMIPS_OpMove(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Move [s] _ _ mem)
- // cond: SizeAndAlign(s).Size() == 0
+ // match: (Move [0] _ _ mem)
+ // cond:
// result: mem
for {
- s := v.AuxInt
- mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 0) {
+ if v.AuxInt != 0 {
break
}
+ mem := v.Args[2]
v.reset(OpCopy)
v.Type = mem.Type
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 1
+ // match: (Move [1] dst src mem)
+ // cond:
// result: (MOVBstore dst (MOVBUload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 1 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 1) {
- break
- }
v.reset(OpMIPSMOVBstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, config.fe.TypeUInt8())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Move [2] {t} dst src mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore dst (MOVHUload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 2 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpMIPSMOVHstore)
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 2
+ // match: (Move [2] dst src mem)
+ // cond:
// result: (MOVBstore [1] dst (MOVBUload [1] src mem) (MOVBstore dst (MOVBUload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 2 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 2) {
- break
- }
v.reset(OpMIPSMOVBstore)
v.AuxInt = 1
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Move [4] {t} dst src mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore dst (MOVWload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpMIPSMOVWstore)
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Move [4] {t} dst src mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [2] dst (MOVHUload [2] src mem) (MOVHstore dst (MOVHUload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpMIPSMOVHstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Move [4] dst src mem)
+ // cond:
// result: (MOVBstore [3] dst (MOVBUload [3] src mem) (MOVBstore [2] dst (MOVBUload [2] src mem) (MOVBstore [1] dst (MOVBUload [1] src mem) (MOVBstore dst (MOVBUload src mem) mem))))
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 4) {
- break
- }
v.reset(OpMIPSMOVBstore)
v.AuxInt = 3
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 3
+ // match: (Move [3] dst src mem)
+ // cond:
// result: (MOVBstore [2] dst (MOVBUload [2] src mem) (MOVBstore [1] dst (MOVBUload [1] src mem) (MOVBstore dst (MOVBUload src mem) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 3 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 3) {
- break
- }
v.reset(OpMIPSMOVBstore)
v.AuxInt = 2
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Move [8] {t} dst src mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore [4] dst (MOVWload [4] src mem) (MOVWstore dst (MOVWload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpMIPSMOVWstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Move [8] {t} dst src mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [6] dst (MOVHload [6] src mem) (MOVHstore [4] dst (MOVHload [4] src mem) (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem))))
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpMIPSMOVHstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 6 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Move [6] {t} dst src mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [4] dst (MOVHload [4] src mem) (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 6 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 6 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpMIPSMOVHstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 12 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Move [12] {t} dst src mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore [8] dst (MOVWload [8] src mem) (MOVWstore [4] dst (MOVWload [4] src mem) (MOVWstore dst (MOVWload src mem) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 12 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 12 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpMIPSMOVWstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Move [16] {t} dst src mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore [12] dst (MOVWload [12] src mem) (MOVWstore [8] dst (MOVWload [8] src mem) (MOVWstore [4] dst (MOVWload [4] src mem) (MOVWstore dst (MOVWload src mem) mem))))
for {
- s := v.AuxInt
+ if v.AuxInt != 16 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpMIPSMOVWstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: (SizeAndAlign(s).Size() > 16 || SizeAndAlign(s).Align()%4 != 0)
- // result: (LoweredMove [SizeAndAlign(s).Align()] dst src (ADDconst <src.Type> src [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)]) mem)
+ // match: (Move [s] {t} dst src mem)
+ // cond: (s > 16 || t.(Type).Alignment()%4 != 0)
+ // result: (LoweredMove [t.(Type).Alignment()] dst src (ADDconst <src.Type> src [s-moveSize(t.(Type).Alignment(), config)]) mem)
for {
s := v.AuxInt
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() > 16 || SizeAndAlign(s).Align()%4 != 0) {
+ if !(s > 16 || t.(Type).Alignment()%4 != 0) {
break
}
v.reset(OpMIPSLoweredMove)
- v.AuxInt = SizeAndAlign(s).Align()
+ v.AuxInt = t.(Type).Alignment()
v.AddArg(dst)
v.AddArg(src)
v0 := b.NewValue0(v.Pos, OpMIPSADDconst, src.Type)
- v0.AuxInt = SizeAndAlign(s).Size() - moveSize(SizeAndAlign(s).Align(), config)
+ v0.AuxInt = s - moveSize(t.(Type).Alignment(), config)
v0.AddArg(src)
v.AddArg(v0)
v.AddArg(mem)
func rewriteValueMIPS_OpStore(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Store [1] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 1
// result: (MOVBstore ptr val mem)
for {
- if v.AuxInt != 1 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- v.reset(OpMIPSMOVBstore)
- v.AddArg(ptr)
- v.AddArg(val)
- v.AddArg(mem)
- return true
- }
- // match: (Store [2] ptr val mem)
- // cond:
- // result: (MOVHstore ptr val mem)
- for {
- if v.AuxInt != 2 {
+ if !(t.(Type).Size() == 1) {
break
}
- ptr := v.Args[0]
- val := v.Args[1]
- mem := v.Args[2]
- v.reset(OpMIPSMOVHstore)
+ v.reset(OpMIPSMOVBstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [4] ptr val mem)
- // cond: !is32BitFloat(val.Type)
- // result: (MOVWstore ptr val mem)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 2
+ // result: (MOVHstore ptr val mem)
for {
- if v.AuxInt != 4 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(!is32BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 2) {
break
}
- v.reset(OpMIPSMOVWstore)
+ v.reset(OpMIPSMOVHstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [8] ptr val mem)
- // cond: !is64BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 4 && !is32BitFloat(val.Type)
// result: (MOVWstore ptr val mem)
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(!is64BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 4 && !is32BitFloat(val.Type)) {
break
}
v.reset(OpMIPSMOVWstore)
v.AddArg(mem)
return true
}
- // match: (Store [4] ptr val mem)
- // cond: is32BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 4 && is32BitFloat(val.Type)
// result: (MOVFstore ptr val mem)
for {
- if v.AuxInt != 4 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is32BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 4 && is32BitFloat(val.Type)) {
break
}
v.reset(OpMIPSMOVFstore)
v.AddArg(mem)
return true
}
- // match: (Store [8] ptr val mem)
- // cond: is64BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
// result: (MOVDstore ptr val mem)
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is64BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 8 && is64BitFloat(val.Type)) {
break
}
v.reset(OpMIPSMOVDstore)
func rewriteValueMIPS_OpZero(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Zero [s] _ mem)
- // cond: SizeAndAlign(s).Size() == 0
+ // match: (Zero [0] _ mem)
+ // cond:
// result: mem
for {
- s := v.AuxInt
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 0) {
+ if v.AuxInt != 0 {
break
}
+ mem := v.Args[1]
v.reset(OpCopy)
v.Type = mem.Type
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 1
+ // match: (Zero [1] ptr mem)
+ // cond:
// result: (MOVBstore ptr (MOVWconst [0]) mem)
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 1) {
+ if v.AuxInt != 1 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpMIPSMOVBstore)
v.AddArg(ptr)
v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, config.fe.TypeUInt32())
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Zero [2] {t} ptr mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore ptr (MOVWconst [0]) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 2 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpMIPSMOVHstore)
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 2
+ // match: (Zero [2] ptr mem)
+ // cond:
// result: (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem))
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 2) {
+ if v.AuxInt != 2 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpMIPSMOVBstore)
v.AuxInt = 1
v.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Zero [4] {t} ptr mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore ptr (MOVWconst [0]) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpMIPSMOVWstore)
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Zero [4] {t} ptr mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [2] ptr (MOVWconst [0]) (MOVHstore [0] ptr (MOVWconst [0]) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpMIPSMOVHstore)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Zero [4] ptr mem)
+ // cond:
// result: (MOVBstore [3] ptr (MOVWconst [0]) (MOVBstore [2] ptr (MOVWconst [0]) (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem))))
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4) {
+ if v.AuxInt != 4 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpMIPSMOVBstore)
v.AuxInt = 3
v.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 3
+ // match: (Zero [3] ptr mem)
+ // cond:
// result: (MOVBstore [2] ptr (MOVWconst [0]) (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem)))
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 3) {
+ if v.AuxInt != 3 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpMIPSMOVBstore)
v.AuxInt = 2
v.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 6 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Zero [6] {t} ptr mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [4] ptr (MOVWconst [0]) (MOVHstore [2] ptr (MOVWconst [0]) (MOVHstore [0] ptr (MOVWconst [0]) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 6 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 6 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpMIPSMOVHstore)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Zero [8] {t} ptr mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore [4] ptr (MOVWconst [0]) (MOVWstore [0] ptr (MOVWconst [0]) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpMIPSMOVWstore)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 12 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Zero [12] {t} ptr mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore [8] ptr (MOVWconst [0]) (MOVWstore [4] ptr (MOVWconst [0]) (MOVWstore [0] ptr (MOVWconst [0]) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 12 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 12 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpMIPSMOVWstore)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Zero [16] {t} ptr mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore [12] ptr (MOVWconst [0]) (MOVWstore [8] ptr (MOVWconst [0]) (MOVWstore [4] ptr (MOVWconst [0]) (MOVWstore [0] ptr (MOVWconst [0]) mem))))
for {
- s := v.AuxInt
+ if v.AuxInt != 16 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpMIPSMOVWstore)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: (SizeAndAlign(s).Size() > 16 || SizeAndAlign(s).Align()%4 != 0)
- // result: (LoweredZero [SizeAndAlign(s).Align()] ptr (ADDconst <ptr.Type> ptr [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)]) mem)
+ // match: (Zero [s] {t} ptr mem)
+ // cond: (s > 16 || s%4 != 0)
+ // result: (LoweredZero [t.(Type).Alignment()] ptr (ADDconst <ptr.Type> ptr [s-moveSize(t.(Type).Alignment(), config)]) mem)
for {
s := v.AuxInt
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() > 16 || SizeAndAlign(s).Align()%4 != 0) {
+ if !(s > 16 || s%4 != 0) {
break
}
v.reset(OpMIPSLoweredZero)
- v.AuxInt = SizeAndAlign(s).Align()
+ v.AuxInt = t.(Type).Alignment()
v.AddArg(ptr)
v0 := b.NewValue0(v.Pos, OpMIPSADDconst, ptr.Type)
- v0.AuxInt = SizeAndAlign(s).Size() - moveSize(SizeAndAlign(s).Align(), config)
+ v0.AuxInt = s - moveSize(t.(Type).Alignment(), config)
v0.AddArg(ptr)
v.AddArg(v0)
v.AddArg(mem)
func rewriteValueMIPS64_OpMove(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Move [s] _ _ mem)
- // cond: SizeAndAlign(s).Size() == 0
+ // match: (Move [0] _ _ mem)
+ // cond:
// result: mem
for {
- s := v.AuxInt
- mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 0) {
+ if v.AuxInt != 0 {
break
}
+ mem := v.Args[2]
v.reset(OpCopy)
v.Type = mem.Type
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 1
+ // match: (Move [1] dst src mem)
+ // cond:
// result: (MOVBstore dst (MOVBload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 1 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 1) {
- break
- }
v.reset(OpMIPS64MOVBstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, config.fe.TypeInt8())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Move [2] {t} dst src mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore dst (MOVHload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 2 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpMIPS64MOVHstore)
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 2
+ // match: (Move [2] dst src mem)
+ // cond:
// result: (MOVBstore [1] dst (MOVBload [1] src mem) (MOVBstore dst (MOVBload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 2 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 2) {
- break
- }
v.reset(OpMIPS64MOVBstore)
v.AuxInt = 1
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Move [4] {t} dst src mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore dst (MOVWload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpMIPS64MOVWstore)
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Move [4] {t} dst src mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpMIPS64MOVHstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Move [4] dst src mem)
+ // cond:
// result: (MOVBstore [3] dst (MOVBload [3] src mem) (MOVBstore [2] dst (MOVBload [2] src mem) (MOVBstore [1] dst (MOVBload [1] src mem) (MOVBstore dst (MOVBload src mem) mem))))
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 4) {
- break
- }
v.reset(OpMIPS64MOVBstore)
v.AuxInt = 3
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0
+ // match: (Move [8] {t} dst src mem)
+ // cond: t.(Type).Alignment()%8 == 0
// result: (MOVVstore dst (MOVVload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0) {
+ if !(t.(Type).Alignment()%8 == 0) {
break
}
v.reset(OpMIPS64MOVVstore)
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Move [8] {t} dst src mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore [4] dst (MOVWload [4] src mem) (MOVWstore dst (MOVWload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpMIPS64MOVWstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Move [8] {t} dst src mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [6] dst (MOVHload [6] src mem) (MOVHstore [4] dst (MOVHload [4] src mem) (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem))))
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpMIPS64MOVHstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 3
+ // match: (Move [3] dst src mem)
+ // cond:
// result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVBstore [1] dst (MOVBload [1] src mem) (MOVBstore dst (MOVBload src mem) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 3 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 3) {
- break
- }
v.reset(OpMIPS64MOVBstore)
v.AuxInt = 2
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 6 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Move [6] {t} dst src mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [4] dst (MOVHload [4] src mem) (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 6 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 6 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpMIPS64MOVHstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 12 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Move [12] {t} dst src mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore [8] dst (MOVWload [8] src mem) (MOVWstore [4] dst (MOVWload [4] src mem) (MOVWstore dst (MOVWload src mem) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 12 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 12 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpMIPS64MOVWstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%8 == 0
+ // match: (Move [16] {t} dst src mem)
+ // cond: t.(Type).Alignment()%8 == 0
// result: (MOVVstore [8] dst (MOVVload [8] src mem) (MOVVstore dst (MOVVload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 16 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%8 == 0) {
+ if !(t.(Type).Alignment()%8 == 0) {
break
}
v.reset(OpMIPS64MOVVstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 24 && SizeAndAlign(s).Align()%8 == 0
+ // match: (Move [24] {t} dst src mem)
+ // cond: t.(Type).Alignment()%8 == 0
// result: (MOVVstore [16] dst (MOVVload [16] src mem) (MOVVstore [8] dst (MOVVload [8] src mem) (MOVVstore dst (MOVVload src mem) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 24 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 24 && SizeAndAlign(s).Align()%8 == 0) {
+ if !(t.(Type).Alignment()%8 == 0) {
break
}
v.reset(OpMIPS64MOVVstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() > 24 || SizeAndAlign(s).Align()%8 != 0
- // result: (LoweredMove [SizeAndAlign(s).Align()] dst src (ADDVconst <src.Type> src [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)]) mem)
+ // match: (Move [s] {t} dst src mem)
+ // cond: s > 24 || t.(Type).Alignment()%8 != 0
+ // result: (LoweredMove [t.(Type).Alignment()] dst src (ADDVconst <src.Type> src [s-moveSize(t.(Type).Alignment(), config)]) mem)
for {
s := v.AuxInt
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() > 24 || SizeAndAlign(s).Align()%8 != 0) {
+ if !(s > 24 || t.(Type).Alignment()%8 != 0) {
break
}
v.reset(OpMIPS64LoweredMove)
- v.AuxInt = SizeAndAlign(s).Align()
+ v.AuxInt = t.(Type).Alignment()
v.AddArg(dst)
v.AddArg(src)
v0 := b.NewValue0(v.Pos, OpMIPS64ADDVconst, src.Type)
- v0.AuxInt = SizeAndAlign(s).Size() - moveSize(SizeAndAlign(s).Align(), config)
+ v0.AuxInt = s - moveSize(t.(Type).Alignment(), config)
v0.AddArg(src)
v.AddArg(v0)
v.AddArg(mem)
func rewriteValueMIPS64_OpStore(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Store [1] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 1
// result: (MOVBstore ptr val mem)
for {
- if v.AuxInt != 1 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 1) {
+ break
+ }
v.reset(OpMIPS64MOVBstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [2] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 2
// result: (MOVHstore ptr val mem)
for {
- if v.AuxInt != 2 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 2) {
+ break
+ }
v.reset(OpMIPS64MOVHstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [4] ptr val mem)
- // cond: !is32BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 4 && !is32BitFloat(val.Type)
// result: (MOVWstore ptr val mem)
for {
- if v.AuxInt != 4 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(!is32BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 4 && !is32BitFloat(val.Type)) {
break
}
v.reset(OpMIPS64MOVWstore)
v.AddArg(mem)
return true
}
- // match: (Store [8] ptr val mem)
- // cond: !is64BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 8 && !is64BitFloat(val.Type)
// result: (MOVVstore ptr val mem)
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(!is64BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 8 && !is64BitFloat(val.Type)) {
break
}
v.reset(OpMIPS64MOVVstore)
v.AddArg(mem)
return true
}
- // match: (Store [4] ptr val mem)
- // cond: is32BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 4 && is32BitFloat(val.Type)
// result: (MOVFstore ptr val mem)
for {
- if v.AuxInt != 4 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is32BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 4 && is32BitFloat(val.Type)) {
break
}
v.reset(OpMIPS64MOVFstore)
v.AddArg(mem)
return true
}
- // match: (Store [8] ptr val mem)
- // cond: is64BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
// result: (MOVDstore ptr val mem)
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is64BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 8 && is64BitFloat(val.Type)) {
break
}
v.reset(OpMIPS64MOVDstore)
func rewriteValueMIPS64_OpZero(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Zero [s] _ mem)
- // cond: SizeAndAlign(s).Size() == 0
+ // match: (Zero [0] _ mem)
+ // cond:
// result: mem
for {
- s := v.AuxInt
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 0) {
+ if v.AuxInt != 0 {
break
}
+ mem := v.Args[1]
v.reset(OpCopy)
v.Type = mem.Type
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 1
+ // match: (Zero [1] ptr mem)
+ // cond:
// result: (MOVBstore ptr (MOVVconst [0]) mem)
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 1) {
+ if v.AuxInt != 1 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpMIPS64MOVBstore)
v.AddArg(ptr)
v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, config.fe.TypeUInt64())
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Zero [2] {t} ptr mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore ptr (MOVVconst [0]) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 2 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpMIPS64MOVHstore)
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 2
+ // match: (Zero [2] ptr mem)
+ // cond:
// result: (MOVBstore [1] ptr (MOVVconst [0]) (MOVBstore [0] ptr (MOVVconst [0]) mem))
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 2) {
+ if v.AuxInt != 2 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpMIPS64MOVBstore)
v.AuxInt = 1
v.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Zero [4] {t} ptr mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore ptr (MOVVconst [0]) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpMIPS64MOVWstore)
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Zero [4] {t} ptr mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [2] ptr (MOVVconst [0]) (MOVHstore [0] ptr (MOVVconst [0]) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpMIPS64MOVHstore)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Zero [4] ptr mem)
+ // cond:
// result: (MOVBstore [3] ptr (MOVVconst [0]) (MOVBstore [2] ptr (MOVVconst [0]) (MOVBstore [1] ptr (MOVVconst [0]) (MOVBstore [0] ptr (MOVVconst [0]) mem))))
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4) {
+ if v.AuxInt != 4 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpMIPS64MOVBstore)
v.AuxInt = 3
v.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0
+ // match: (Zero [8] {t} ptr mem)
+ // cond: t.(Type).Alignment()%8 == 0
// result: (MOVVstore ptr (MOVVconst [0]) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0) {
+ if !(t.(Type).Alignment()%8 == 0) {
break
}
v.reset(OpMIPS64MOVVstore)
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Zero [8] {t} ptr mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore [4] ptr (MOVVconst [0]) (MOVWstore [0] ptr (MOVVconst [0]) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpMIPS64MOVWstore)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Zero [8] {t} ptr mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [6] ptr (MOVVconst [0]) (MOVHstore [4] ptr (MOVVconst [0]) (MOVHstore [2] ptr (MOVVconst [0]) (MOVHstore [0] ptr (MOVVconst [0]) mem))))
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpMIPS64MOVHstore)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 3
+ // match: (Zero [3] ptr mem)
+ // cond:
// result: (MOVBstore [2] ptr (MOVVconst [0]) (MOVBstore [1] ptr (MOVVconst [0]) (MOVBstore [0] ptr (MOVVconst [0]) mem)))
for {
- s := v.AuxInt
- ptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 3) {
+ if v.AuxInt != 3 {
break
}
+ ptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpMIPS64MOVBstore)
v.AuxInt = 2
v.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 6 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Zero [6] {t} ptr mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [4] ptr (MOVVconst [0]) (MOVHstore [2] ptr (MOVVconst [0]) (MOVHstore [0] ptr (MOVVconst [0]) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 6 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 6 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpMIPS64MOVHstore)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 12 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Zero [12] {t} ptr mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore [8] ptr (MOVVconst [0]) (MOVWstore [4] ptr (MOVVconst [0]) (MOVWstore [0] ptr (MOVVconst [0]) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 12 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 12 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpMIPS64MOVWstore)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%8 == 0
+ // match: (Zero [16] {t} ptr mem)
+ // cond: t.(Type).Alignment()%8 == 0
// result: (MOVVstore [8] ptr (MOVVconst [0]) (MOVVstore [0] ptr (MOVVconst [0]) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 16 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%8 == 0) {
+ if !(t.(Type).Alignment()%8 == 0) {
break
}
v.reset(OpMIPS64MOVVstore)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size() == 24 && SizeAndAlign(s).Align()%8 == 0
+ // match: (Zero [24] {t} ptr mem)
+ // cond: t.(Type).Alignment()%8 == 0
// result: (MOVVstore [16] ptr (MOVVconst [0]) (MOVVstore [8] ptr (MOVVconst [0]) (MOVVstore [0] ptr (MOVVconst [0]) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 24 {
+ break
+ }
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 24 && SizeAndAlign(s).Align()%8 == 0) {
+ if !(t.(Type).Alignment()%8 == 0) {
break
}
v.reset(OpMIPS64MOVVstore)
v.AddArg(v1)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: SizeAndAlign(s).Size()%8 == 0 && SizeAndAlign(s).Size() > 24 && SizeAndAlign(s).Size() <= 8*128 && SizeAndAlign(s).Align()%8 == 0 && !config.noDuffDevice
- // result: (DUFFZERO [8 * (128 - int64(SizeAndAlign(s).Size()/8))] ptr mem)
+ // match: (Zero [s] {t} ptr mem)
+ // cond: s%8 == 0 && s > 24 && s <= 8*128 && t.(Type).Alignment()%8 == 0 && !config.noDuffDevice
+ // result: (DUFFZERO [8 * (128 - int64(s/8))] ptr mem)
for {
s := v.AuxInt
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size()%8 == 0 && SizeAndAlign(s).Size() > 24 && SizeAndAlign(s).Size() <= 8*128 && SizeAndAlign(s).Align()%8 == 0 && !config.noDuffDevice) {
+ if !(s%8 == 0 && s > 24 && s <= 8*128 && t.(Type).Alignment()%8 == 0 && !config.noDuffDevice) {
break
}
v.reset(OpMIPS64DUFFZERO)
- v.AuxInt = 8 * (128 - int64(SizeAndAlign(s).Size()/8))
+ v.AuxInt = 8 * (128 - int64(s/8))
v.AddArg(ptr)
v.AddArg(mem)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: (SizeAndAlign(s).Size() > 8*128 || config.noDuffDevice) || SizeAndAlign(s).Align()%8 != 0
- // result: (LoweredZero [SizeAndAlign(s).Align()] ptr (ADDVconst <ptr.Type> ptr [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)]) mem)
+ // match: (Zero [s] {t} ptr mem)
+ // cond: (s > 8*128 || config.noDuffDevice) || t.(Type).Alignment()%8 != 0
+ // result: (LoweredZero [t.(Type).Alignment()] ptr (ADDVconst <ptr.Type> ptr [s-moveSize(t.(Type).Alignment(), config)]) mem)
for {
s := v.AuxInt
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !((SizeAndAlign(s).Size() > 8*128 || config.noDuffDevice) || SizeAndAlign(s).Align()%8 != 0) {
+ if !((s > 8*128 || config.noDuffDevice) || t.(Type).Alignment()%8 != 0) {
break
}
v.reset(OpMIPS64LoweredZero)
- v.AuxInt = SizeAndAlign(s).Align()
+ v.AuxInt = t.(Type).Alignment()
v.AddArg(ptr)
v0 := b.NewValue0(v.Pos, OpMIPS64ADDVconst, ptr.Type)
- v0.AuxInt = SizeAndAlign(s).Size() - moveSize(SizeAndAlign(s).Align(), config)
+ v0.AuxInt = s - moveSize(t.(Type).Alignment(), config)
v0.AddArg(ptr)
v.AddArg(v0)
v.AddArg(mem)
func rewriteValuePPC64_OpMove(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Move [s] _ _ mem)
- // cond: SizeAndAlign(s).Size() == 0
+ // match: (Move [0] _ _ mem)
+ // cond:
// result: mem
for {
- s := v.AuxInt
- mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 0) {
+ if v.AuxInt != 0 {
break
}
+ mem := v.Args[2]
v.reset(OpCopy)
v.Type = mem.Type
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 1
+ // match: (Move [1] dst src mem)
+ // cond:
// result: (MOVBstore dst (MOVBZload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 1 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 1) {
- break
- }
v.reset(OpPPC64MOVBstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Move [2] {t} dst src mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore dst (MOVHZload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 2 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpPPC64MOVHstore)
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 2
+ // match: (Move [2] dst src mem)
+ // cond:
// result: (MOVBstore [1] dst (MOVBZload [1] src mem) (MOVBstore dst (MOVBZload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 2 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 2) {
- break
- }
v.reset(OpPPC64MOVBstore)
v.AuxInt = 1
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Move [4] {t} dst src mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore dst (MOVWload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpPPC64MOVWstore)
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Move [4] {t} dst src mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [2] dst (MOVHZload [2] src mem) (MOVHstore dst (MOVHZload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpPPC64MOVHstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Move [4] dst src mem)
+ // cond:
// result: (MOVBstore [3] dst (MOVBZload [3] src mem) (MOVBstore [2] dst (MOVBZload [2] src mem) (MOVBstore [1] dst (MOVBZload [1] src mem) (MOVBstore dst (MOVBZload src mem) mem))))
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 4) {
- break
- }
v.reset(OpPPC64MOVBstore)
v.AuxInt = 3
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0
+ // match: (Move [8] {t} dst src mem)
+ // cond: t.(Type).Alignment()%8 == 0
// result: (MOVDstore dst (MOVDload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0) {
+ if !(t.(Type).Alignment()%8 == 0) {
break
}
v.reset(OpPPC64MOVDstore)
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Move [8] {t} dst src mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore [4] dst (MOVWZload [4] src mem) (MOVWstore dst (MOVWZload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpPPC64MOVWstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Move [8] {t} dst src mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [6] dst (MOVHZload [6] src mem) (MOVHstore [4] dst (MOVHZload [4] src mem) (MOVHstore [2] dst (MOVHZload [2] src mem) (MOVHstore dst (MOVHZload src mem) mem))))
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpPPC64MOVHstore)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 3
+ // match: (Move [3] dst src mem)
+ // cond:
// result: (MOVBstore [2] dst (MOVBZload [2] src mem) (MOVBstore [1] dst (MOVBZload [1] src mem) (MOVBstore dst (MOVBZload src mem) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 3 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 3) {
- break
- }
v.reset(OpPPC64MOVBstore)
v.AuxInt = 2
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: (SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%8 != 0
- // result: (LoweredMove [SizeAndAlign(s).Align()] dst src (ADDconst <src.Type> src [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)]) mem)
+ // match: (Move [s] {t} dst src mem)
+ // cond: (s > 512 || config.noDuffDevice) || t.(Type).Alignment()%8 != 0
+ // result: (LoweredMove [t.(Type).Alignment()] dst src (ADDconst <src.Type> src [s-moveSize(t.(Type).Alignment(), config)]) mem)
for {
s := v.AuxInt
+ t := v.Aux
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !((SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%8 != 0) {
+ if !((s > 512 || config.noDuffDevice) || t.(Type).Alignment()%8 != 0) {
break
}
v.reset(OpPPC64LoweredMove)
- v.AuxInt = SizeAndAlign(s).Align()
+ v.AuxInt = t.(Type).Alignment()
v.AddArg(dst)
v.AddArg(src)
v0 := b.NewValue0(v.Pos, OpPPC64ADDconst, src.Type)
- v0.AuxInt = SizeAndAlign(s).Size() - moveSize(SizeAndAlign(s).Align(), config)
+ v0.AuxInt = s - moveSize(t.(Type).Alignment(), config)
v0.AddArg(src)
v.AddArg(v0)
v.AddArg(mem)
func rewriteValuePPC64_OpStore(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Store [8] ptr val mem)
- // cond: is64BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
// result: (FMOVDstore ptr val mem)
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is64BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 8 && is64BitFloat(val.Type)) {
break
}
v.reset(OpPPC64FMOVDstore)
v.AddArg(mem)
return true
}
- // match: (Store [8] ptr val mem)
- // cond: is32BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 8 && is32BitFloat(val.Type)
// result: (FMOVDstore ptr val mem)
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is32BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 8 && is32BitFloat(val.Type)) {
break
}
v.reset(OpPPC64FMOVDstore)
v.AddArg(mem)
return true
}
- // match: (Store [4] ptr val mem)
- // cond: is32BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 4 && is32BitFloat(val.Type)
// result: (FMOVSstore ptr val mem)
for {
- if v.AuxInt != 4 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is32BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 4 && is32BitFloat(val.Type)) {
break
}
v.reset(OpPPC64FMOVSstore)
v.AddArg(mem)
return true
}
- // match: (Store [8] ptr val mem)
- // cond: (is64BitInt(val.Type) || isPtr(val.Type))
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 8 && (is64BitInt(val.Type) || isPtr(val.Type))
// result: (MOVDstore ptr val mem)
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is64BitInt(val.Type) || isPtr(val.Type)) {
+ if !(t.(Type).Size() == 8 && (is64BitInt(val.Type) || isPtr(val.Type))) {
break
}
v.reset(OpPPC64MOVDstore)
v.AddArg(mem)
return true
}
- // match: (Store [4] ptr val mem)
- // cond: is32BitInt(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 4 && is32BitInt(val.Type)
// result: (MOVWstore ptr val mem)
for {
- if v.AuxInt != 4 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is32BitInt(val.Type)) {
+ if !(t.(Type).Size() == 4 && is32BitInt(val.Type)) {
break
}
v.reset(OpPPC64MOVWstore)
v.AddArg(mem)
return true
}
- // match: (Store [2] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 2
// result: (MOVHstore ptr val mem)
for {
- if v.AuxInt != 2 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 2) {
+ break
+ }
v.reset(OpPPC64MOVHstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [1] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 1
// result: (MOVBstore ptr val mem)
for {
- if v.AuxInt != 1 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 1) {
+ break
+ }
v.reset(OpPPC64MOVBstore)
v.AddArg(ptr)
v.AddArg(val)
func rewriteValuePPC64_OpZero(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Zero [s] _ mem)
- // cond: SizeAndAlign(s).Size() == 0
+ // match: (Zero [0] _ mem)
+ // cond:
// result: mem
for {
- s := v.AuxInt
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 0) {
+ if v.AuxInt != 0 {
break
}
+ mem := v.Args[1]
v.reset(OpCopy)
v.Type = mem.Type
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 1
+ // match: (Zero [1] destptr mem)
+ // cond:
// result: (MOVBstorezero destptr mem)
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 1) {
+ if v.AuxInt != 1 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpPPC64MOVBstorezero)
v.AddArg(destptr)
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Zero [2] {t} destptr mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstorezero destptr mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 2 {
+ break
+ }
+ t := v.Aux
destptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpPPC64MOVHstorezero)
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 2
+ // match: (Zero [2] destptr mem)
+ // cond:
// result: (MOVBstorezero [1] destptr (MOVBstorezero [0] destptr mem))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 2) {
+ if v.AuxInt != 2 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpPPC64MOVBstorezero)
v.AuxInt = 1
v.AddArg(destptr)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Zero [4] {t} destptr mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstorezero destptr mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
+ t := v.Aux
destptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpPPC64MOVWstorezero)
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Zero [4] {t} destptr mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstorezero [2] destptr (MOVHstorezero [0] destptr mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
+ t := v.Aux
destptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpPPC64MOVHstorezero)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Zero [4] destptr mem)
+ // cond:
// result: (MOVBstorezero [3] destptr (MOVBstorezero [2] destptr (MOVBstorezero [1] destptr (MOVBstorezero [0] destptr mem))))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4) {
+ if v.AuxInt != 4 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpPPC64MOVBstorezero)
v.AuxInt = 3
v.AddArg(destptr)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0
+ // match: (Zero [8] {t} destptr mem)
+ // cond: t.(Type).Alignment()%8 == 0
// result: (MOVDstorezero [0] destptr mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
+ t := v.Aux
destptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0) {
+ if !(t.(Type).Alignment()%8 == 0) {
break
}
v.reset(OpPPC64MOVDstorezero)
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0
+ // match: (Zero [8] {t} destptr mem)
+ // cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstorezero [4] destptr (MOVWstorezero [0] destptr mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
+ t := v.Aux
destptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0) {
+ if !(t.(Type).Alignment()%4 == 0) {
break
}
v.reset(OpPPC64MOVWstorezero)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0
+ // match: (Zero [8] {t} destptr mem)
+ // cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstorezero [6] destptr (MOVHstorezero [4] destptr (MOVHstorezero [2] destptr (MOVHstorezero [0] destptr mem))))
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
+ t := v.Aux
destptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0) {
+ if !(t.(Type).Alignment()%2 == 0) {
break
}
v.reset(OpPPC64MOVHstorezero)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 3
+ // match: (Zero [3] destptr mem)
+ // cond:
// result: (MOVBstorezero [2] destptr (MOVBstorezero [1] destptr (MOVBstorezero [0] destptr mem)))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 3) {
+ if v.AuxInt != 3 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpPPC64MOVBstorezero)
v.AuxInt = 2
v.AddArg(destptr)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%8 == 0
+ // match: (Zero [16] {t} destptr mem)
+ // cond: t.(Type).Alignment()%8 == 0
// result: (MOVDstorezero [8] destptr (MOVDstorezero [0] destptr mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 16 {
+ break
+ }
+ t := v.Aux
destptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%8 == 0) {
+ if !(t.(Type).Alignment()%8 == 0) {
break
}
v.reset(OpPPC64MOVDstorezero)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 24 && SizeAndAlign(s).Align()%8 == 0
+ // match: (Zero [24] {t} destptr mem)
+ // cond: t.(Type).Alignment()%8 == 0
// result: (MOVDstorezero [16] destptr (MOVDstorezero [8] destptr (MOVDstorezero [0] destptr mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 24 {
+ break
+ }
+ t := v.Aux
destptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 24 && SizeAndAlign(s).Align()%8 == 0) {
+ if !(t.(Type).Alignment()%8 == 0) {
break
}
v.reset(OpPPC64MOVDstorezero)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 32 && SizeAndAlign(s).Align()%8 == 0
+ // match: (Zero [32] {t} destptr mem)
+ // cond: t.(Type).Alignment()%8 == 0
// result: (MOVDstorezero [24] destptr (MOVDstorezero [16] destptr (MOVDstorezero [8] destptr (MOVDstorezero [0] destptr mem))))
for {
- s := v.AuxInt
+ if v.AuxInt != 32 {
+ break
+ }
+ t := v.Aux
destptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 32 && SizeAndAlign(s).Align()%8 == 0) {
+ if !(t.(Type).Alignment()%8 == 0) {
break
}
v.reset(OpPPC64MOVDstorezero)
v.AddArg(v0)
return true
}
- // match: (Zero [s] ptr mem)
- // cond: (SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%8 != 0
- // result: (LoweredZero [SizeAndAlign(s).Align()] ptr (ADDconst <ptr.Type> ptr [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)]) mem)
+ // match: (Zero [s] {t} ptr mem)
+ // cond: (s > 512 || config.noDuffDevice) || t.(Type).Alignment()%8 != 0
+ // result: (LoweredZero [t.(Type).Alignment()] ptr (ADDconst <ptr.Type> ptr [s-moveSize(t.(Type).Alignment(), config)]) mem)
for {
s := v.AuxInt
+ t := v.Aux
ptr := v.Args[0]
mem := v.Args[1]
- if !((SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%8 != 0) {
+ if !((s > 512 || config.noDuffDevice) || t.(Type).Alignment()%8 != 0) {
break
}
v.reset(OpPPC64LoweredZero)
- v.AuxInt = SizeAndAlign(s).Align()
+ v.AuxInt = t.(Type).Alignment()
v.AddArg(ptr)
v0 := b.NewValue0(v.Pos, OpPPC64ADDconst, ptr.Type)
- v0.AuxInt = SizeAndAlign(s).Size() - moveSize(SizeAndAlign(s).Align(), config)
+ v0.AuxInt = s - moveSize(t.(Type).Alignment(), config)
v0.AddArg(ptr)
v.AddArg(v0)
v.AddArg(mem)
func rewriteValueS390X_OpMove(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Move [s] _ _ mem)
- // cond: SizeAndAlign(s).Size() == 0
+ // match: (Move [0] _ _ mem)
+ // cond:
// result: mem
for {
- s := v.AuxInt
- mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 0) {
+ if v.AuxInt != 0 {
break
}
+ mem := v.Args[2]
v.reset(OpCopy)
v.Type = mem.Type
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 1
+ // match: (Move [1] dst src mem)
+ // cond:
// result: (MOVBstore dst (MOVBZload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 1 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 1) {
- break
- }
v.reset(OpS390XMOVBstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, config.fe.TypeUInt8())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 2
+ // match: (Move [2] dst src mem)
+ // cond:
// result: (MOVHstore dst (MOVHZload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 2 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 2) {
- break
- }
v.reset(OpS390XMOVHstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, config.fe.TypeUInt16())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Move [4] dst src mem)
+ // cond:
// result: (MOVWstore dst (MOVWZload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 4 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 4) {
- break
- }
v.reset(OpS390XMOVWstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, config.fe.TypeUInt32())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 8
+ // match: (Move [8] dst src mem)
+ // cond:
// result: (MOVDstore dst (MOVDload src mem) mem)
for {
- s := v.AuxInt
+ if v.AuxInt != 8 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 8) {
- break
- }
v.reset(OpS390XMOVDstore)
v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpS390XMOVDload, config.fe.TypeUInt64())
v.AddArg(mem)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 16
+ // match: (Move [16] dst src mem)
+ // cond:
// result: (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 16 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 16) {
- break
- }
v.reset(OpS390XMOVDstore)
v.AuxInt = 8
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 24
+ // match: (Move [24] dst src mem)
+ // cond:
// result: (MOVDstore [16] dst (MOVDload [16] src mem) (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 24 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 24) {
- break
- }
v.reset(OpS390XMOVDstore)
v.AuxInt = 16
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 3
+ // match: (Move [3] dst src mem)
+ // cond:
// result: (MOVBstore [2] dst (MOVBZload [2] src mem) (MOVHstore dst (MOVHZload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 3 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 3) {
- break
- }
v.reset(OpS390XMOVBstore)
v.AuxInt = 2
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 5
+ // match: (Move [5] dst src mem)
+ // cond:
// result: (MOVBstore [4] dst (MOVBZload [4] src mem) (MOVWstore dst (MOVWZload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 5 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 5) {
- break
- }
v.reset(OpS390XMOVBstore)
v.AuxInt = 4
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 6
+ // match: (Move [6] dst src mem)
+ // cond:
// result: (MOVHstore [4] dst (MOVHZload [4] src mem) (MOVWstore dst (MOVWZload src mem) mem))
for {
- s := v.AuxInt
+ if v.AuxInt != 6 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 6) {
- break
- }
v.reset(OpS390XMOVHstore)
v.AuxInt = 4
v.AddArg(dst)
v.AddArg(v1)
return true
}
- // match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() == 7
+ // match: (Move [7] dst src mem)
+ // cond:
// result: (MOVBstore [6] dst (MOVBZload [6] src mem) (MOVHstore [4] dst (MOVHZload [4] src mem) (MOVWstore dst (MOVWZload src mem) mem)))
for {
- s := v.AuxInt
+ if v.AuxInt != 7 {
+ break
+ }
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() == 7) {
- break
- }
v.reset(OpS390XMOVBstore)
v.AuxInt = 6
v.AddArg(dst)
return true
}
// match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() > 0 && SizeAndAlign(s).Size() <= 256
- // result: (MVC [makeValAndOff(SizeAndAlign(s).Size(), 0)] dst src mem)
+ // cond: s > 0 && s <= 256
+ // result: (MVC [makeValAndOff(s, 0)] dst src mem)
for {
s := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() > 0 && SizeAndAlign(s).Size() <= 256) {
+ if !(s > 0 && s <= 256) {
break
}
v.reset(OpS390XMVC)
- v.AuxInt = makeValAndOff(SizeAndAlign(s).Size(), 0)
+ v.AuxInt = makeValAndOff(s, 0)
v.AddArg(dst)
v.AddArg(src)
v.AddArg(mem)
return true
}
// match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() > 256 && SizeAndAlign(s).Size() <= 512
- // result: (MVC [makeValAndOff(SizeAndAlign(s).Size()-256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))
+ // cond: s > 256 && s <= 512
+ // result: (MVC [makeValAndOff(s-256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))
for {
s := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() > 256 && SizeAndAlign(s).Size() <= 512) {
+ if !(s > 256 && s <= 512) {
break
}
v.reset(OpS390XMVC)
- v.AuxInt = makeValAndOff(SizeAndAlign(s).Size()-256, 256)
+ v.AuxInt = makeValAndOff(s-256, 256)
v.AddArg(dst)
v.AddArg(src)
v0 := b.NewValue0(v.Pos, OpS390XMVC, TypeMem)
return true
}
// match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() > 512 && SizeAndAlign(s).Size() <= 768
- // result: (MVC [makeValAndOff(SizeAndAlign(s).Size()-512, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem)))
+ // cond: s > 512 && s <= 768
+ // result: (MVC [makeValAndOff(s-512, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem)))
for {
s := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() > 512 && SizeAndAlign(s).Size() <= 768) {
+ if !(s > 512 && s <= 768) {
break
}
v.reset(OpS390XMVC)
- v.AuxInt = makeValAndOff(SizeAndAlign(s).Size()-512, 512)
+ v.AuxInt = makeValAndOff(s-512, 512)
v.AddArg(dst)
v.AddArg(src)
v0 := b.NewValue0(v.Pos, OpS390XMVC, TypeMem)
return true
}
// match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() > 768 && SizeAndAlign(s).Size() <= 1024
- // result: (MVC [makeValAndOff(SizeAndAlign(s).Size()-768, 768)] dst src (MVC [makeValAndOff(256, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))))
+ // cond: s > 768 && s <= 1024
+ // result: (MVC [makeValAndOff(s-768, 768)] dst src (MVC [makeValAndOff(256, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))))
for {
s := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() > 768 && SizeAndAlign(s).Size() <= 1024) {
+ if !(s > 768 && s <= 1024) {
break
}
v.reset(OpS390XMVC)
- v.AuxInt = makeValAndOff(SizeAndAlign(s).Size()-768, 768)
+ v.AuxInt = makeValAndOff(s-768, 768)
v.AddArg(dst)
v.AddArg(src)
v0 := b.NewValue0(v.Pos, OpS390XMVC, TypeMem)
return true
}
// match: (Move [s] dst src mem)
- // cond: SizeAndAlign(s).Size() > 1024
- // result: (LoweredMove [SizeAndAlign(s).Size()%256] dst src (ADDconst <src.Type> src [(SizeAndAlign(s).Size()/256)*256]) mem)
+ // cond: s > 1024
+ // result: (LoweredMove [s%256] dst src (ADDconst <src.Type> src [(s/256)*256]) mem)
for {
s := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
- if !(SizeAndAlign(s).Size() > 1024) {
+ if !(s > 1024) {
break
}
v.reset(OpS390XLoweredMove)
- v.AuxInt = SizeAndAlign(s).Size() % 256
+ v.AuxInt = s % 256
v.AddArg(dst)
v.AddArg(src)
v0 := b.NewValue0(v.Pos, OpS390XADDconst, src.Type)
- v0.AuxInt = (SizeAndAlign(s).Size() / 256) * 256
+ v0.AuxInt = (s / 256) * 256
v0.AddArg(src)
v.AddArg(v0)
v.AddArg(mem)
func rewriteValueS390X_OpStore(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Store [8] ptr val mem)
- // cond: is64BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
// result: (FMOVDstore ptr val mem)
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is64BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 8 && is64BitFloat(val.Type)) {
break
}
v.reset(OpS390XFMOVDstore)
v.AddArg(mem)
return true
}
- // match: (Store [4] ptr val mem)
- // cond: is32BitFloat(val.Type)
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 4 && is32BitFloat(val.Type)
// result: (FMOVSstore ptr val mem)
for {
- if v.AuxInt != 4 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
- if !(is32BitFloat(val.Type)) {
+ if !(t.(Type).Size() == 4 && is32BitFloat(val.Type)) {
break
}
v.reset(OpS390XFMOVSstore)
v.AddArg(mem)
return true
}
- // match: (Store [8] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 8
// result: (MOVDstore ptr val mem)
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 8) {
+ break
+ }
v.reset(OpS390XMOVDstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [4] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 4
// result: (MOVWstore ptr val mem)
for {
- if v.AuxInt != 4 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 4) {
+ break
+ }
v.reset(OpS390XMOVWstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [2] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 2
// result: (MOVHstore ptr val mem)
for {
- if v.AuxInt != 2 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 2) {
+ break
+ }
v.reset(OpS390XMOVHstore)
v.AddArg(ptr)
v.AddArg(val)
v.AddArg(mem)
return true
}
- // match: (Store [1] ptr val mem)
- // cond:
+ // match: (Store {t} ptr val mem)
+ // cond: t.(Type).Size() == 1
// result: (MOVBstore ptr val mem)
for {
- if v.AuxInt != 1 {
- break
- }
+ t := v.Aux
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 1) {
+ break
+ }
v.reset(OpS390XMOVBstore)
v.AddArg(ptr)
v.AddArg(val)
func rewriteValueS390X_OpZero(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Zero [s] _ mem)
- // cond: SizeAndAlign(s).Size() == 0
+ // match: (Zero [0] _ mem)
+ // cond:
// result: mem
for {
- s := v.AuxInt
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 0) {
+ if v.AuxInt != 0 {
break
}
+ mem := v.Args[1]
v.reset(OpCopy)
v.Type = mem.Type
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 1
+ // match: (Zero [1] destptr mem)
+ // cond:
// result: (MOVBstoreconst [0] destptr mem)
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 1) {
+ if v.AuxInt != 1 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpS390XMOVBstoreconst)
v.AuxInt = 0
v.AddArg(destptr)
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 2
+ // match: (Zero [2] destptr mem)
+ // cond:
// result: (MOVHstoreconst [0] destptr mem)
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 2) {
+ if v.AuxInt != 2 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpS390XMOVHstoreconst)
v.AuxInt = 0
v.AddArg(destptr)
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 4
+ // match: (Zero [4] destptr mem)
+ // cond:
// result: (MOVWstoreconst [0] destptr mem)
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 4) {
+ if v.AuxInt != 4 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpS390XMOVWstoreconst)
v.AuxInt = 0
v.AddArg(destptr)
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 8
+ // match: (Zero [8] destptr mem)
+ // cond:
// result: (MOVDstoreconst [0] destptr mem)
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 8) {
+ if v.AuxInt != 8 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpS390XMOVDstoreconst)
v.AuxInt = 0
v.AddArg(destptr)
v.AddArg(mem)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 3
+ // match: (Zero [3] destptr mem)
+ // cond:
// result: (MOVBstoreconst [makeValAndOff(0,2)] destptr (MOVHstoreconst [0] destptr mem))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 3) {
+ if v.AuxInt != 3 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpS390XMOVBstoreconst)
v.AuxInt = makeValAndOff(0, 2)
v.AddArg(destptr)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 5
+ // match: (Zero [5] destptr mem)
+ // cond:
// result: (MOVBstoreconst [makeValAndOff(0,4)] destptr (MOVWstoreconst [0] destptr mem))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 5) {
+ if v.AuxInt != 5 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpS390XMOVBstoreconst)
v.AuxInt = makeValAndOff(0, 4)
v.AddArg(destptr)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 6
+ // match: (Zero [6] destptr mem)
+ // cond:
// result: (MOVHstoreconst [makeValAndOff(0,4)] destptr (MOVWstoreconst [0] destptr mem))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 6) {
+ if v.AuxInt != 6 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpS390XMOVHstoreconst)
v.AuxInt = makeValAndOff(0, 4)
v.AddArg(destptr)
v.AddArg(v0)
return true
}
- // match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() == 7
+ // match: (Zero [7] destptr mem)
+ // cond:
// result: (MOVWstoreconst [makeValAndOff(0,3)] destptr (MOVWstoreconst [0] destptr mem))
for {
- s := v.AuxInt
- destptr := v.Args[0]
- mem := v.Args[1]
- if !(SizeAndAlign(s).Size() == 7) {
+ if v.AuxInt != 7 {
break
}
+ destptr := v.Args[0]
+ mem := v.Args[1]
v.reset(OpS390XMOVWstoreconst)
v.AuxInt = makeValAndOff(0, 3)
v.AddArg(destptr)
return true
}
// match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() > 0 && SizeAndAlign(s).Size() <= 1024
- // result: (CLEAR [makeValAndOff(SizeAndAlign(s).Size(), 0)] destptr mem)
+ // cond: s > 0 && s <= 1024
+ // result: (CLEAR [makeValAndOff(s, 0)] destptr mem)
for {
s := v.AuxInt
destptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() > 0 && SizeAndAlign(s).Size() <= 1024) {
+ if !(s > 0 && s <= 1024) {
break
}
v.reset(OpS390XCLEAR)
- v.AuxInt = makeValAndOff(SizeAndAlign(s).Size(), 0)
+ v.AuxInt = makeValAndOff(s, 0)
v.AddArg(destptr)
v.AddArg(mem)
return true
}
// match: (Zero [s] destptr mem)
- // cond: SizeAndAlign(s).Size() > 1024
- // result: (LoweredZero [SizeAndAlign(s).Size()%256] destptr (ADDconst <destptr.Type> destptr [(SizeAndAlign(s).Size()/256)*256]) mem)
+ // cond: s > 1024
+ // result: (LoweredZero [s%256] destptr (ADDconst <destptr.Type> destptr [(s/256)*256]) mem)
for {
s := v.AuxInt
destptr := v.Args[0]
mem := v.Args[1]
- if !(SizeAndAlign(s).Size() > 1024) {
+ if !(s > 1024) {
break
}
v.reset(OpS390XLoweredZero)
- v.AuxInt = SizeAndAlign(s).Size() % 256
+ v.AuxInt = s % 256
v.AddArg(destptr)
v0 := b.NewValue0(v.Pos, OpS390XADDconst, destptr.Type)
- v0.AuxInt = (SizeAndAlign(s).Size() / 256) * 256
+ v0.AuxInt = (s / 256) * 256
v0.AddArg(destptr)
v.AddArg(v0)
v.AddArg(mem)
func rewriteValuedec_OpStore(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Store [8] dst (ComplexMake real imag) mem)
- // cond:
- // result: (Store [4] {config.fe.TypeFloat32()} (OffPtr <config.fe.TypeFloat32().PtrTo()> [4] dst) imag (Store [4] {config.fe.TypeFloat32()} dst real mem))
+ // match: (Store {t} dst (ComplexMake real imag) mem)
+ // cond: t.(Type).Size() == 8
+ // result: (Store {config.fe.TypeFloat32()} (OffPtr <config.fe.TypeFloat32().PtrTo()> [4] dst) imag (Store {config.fe.TypeFloat32()} dst real mem))
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
dst := v.Args[0]
v_1 := v.Args[1]
if v_1.Op != OpComplexMake {
real := v_1.Args[0]
imag := v_1.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 8) {
+ break
+ }
v.reset(OpStore)
- v.AuxInt = 4
v.Aux = config.fe.TypeFloat32()
v0 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeFloat32().PtrTo())
v0.AuxInt = 4
v.AddArg(v0)
v.AddArg(imag)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v1.AuxInt = 4
v1.Aux = config.fe.TypeFloat32()
v1.AddArg(dst)
v1.AddArg(real)
v.AddArg(v1)
return true
}
- // match: (Store [16] dst (ComplexMake real imag) mem)
- // cond:
- // result: (Store [8] {config.fe.TypeFloat64()} (OffPtr <config.fe.TypeFloat64().PtrTo()> [8] dst) imag (Store [8] {config.fe.TypeFloat64()} dst real mem))
+ // match: (Store {t} dst (ComplexMake real imag) mem)
+ // cond: t.(Type).Size() == 16
+ // result: (Store {config.fe.TypeFloat64()} (OffPtr <config.fe.TypeFloat64().PtrTo()> [8] dst) imag (Store {config.fe.TypeFloat64()} dst real mem))
for {
- if v.AuxInt != 16 {
- break
- }
+ t := v.Aux
dst := v.Args[0]
v_1 := v.Args[1]
if v_1.Op != OpComplexMake {
real := v_1.Args[0]
imag := v_1.Args[1]
mem := v.Args[2]
+ if !(t.(Type).Size() == 16) {
+ break
+ }
v.reset(OpStore)
- v.AuxInt = 8
v.Aux = config.fe.TypeFloat64()
v0 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeFloat64().PtrTo())
v0.AuxInt = 8
v.AddArg(v0)
v.AddArg(imag)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v1.AuxInt = 8
v1.Aux = config.fe.TypeFloat64()
v1.AddArg(dst)
v1.AddArg(real)
v.AddArg(v1)
return true
}
- // match: (Store [2*config.PtrSize] dst (StringMake ptr len) mem)
+ // match: (Store dst (StringMake ptr len) mem)
// cond:
- // result: (Store [config.PtrSize] {config.fe.TypeInt()} (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] dst) len (Store [config.PtrSize] {config.fe.TypeBytePtr()} dst ptr mem))
+ // result: (Store {config.fe.TypeInt()} (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] dst) len (Store {config.fe.TypeBytePtr()} dst ptr mem))
for {
- if v.AuxInt != 2*config.PtrSize {
- break
- }
dst := v.Args[0]
v_1 := v.Args[1]
if v_1.Op != OpStringMake {
len := v_1.Args[1]
mem := v.Args[2]
v.reset(OpStore)
- v.AuxInt = config.PtrSize
v.Aux = config.fe.TypeInt()
v0 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeInt().PtrTo())
v0.AuxInt = config.PtrSize
v.AddArg(v0)
v.AddArg(len)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v1.AuxInt = config.PtrSize
v1.Aux = config.fe.TypeBytePtr()
v1.AddArg(dst)
v1.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Store [3*config.PtrSize] dst (SliceMake ptr len cap) mem)
+ // match: (Store dst (SliceMake ptr len cap) mem)
// cond:
- // result: (Store [config.PtrSize] {config.fe.TypeInt()} (OffPtr <config.fe.TypeInt().PtrTo()> [2*config.PtrSize] dst) cap (Store [config.PtrSize] {config.fe.TypeInt()} (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] dst) len (Store [config.PtrSize] {config.fe.TypeBytePtr()} dst ptr mem)))
+ // result: (Store {config.fe.TypeInt()} (OffPtr <config.fe.TypeInt().PtrTo()> [2*config.PtrSize] dst) cap (Store {config.fe.TypeInt()} (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] dst) len (Store {config.fe.TypeBytePtr()} dst ptr mem)))
for {
- if v.AuxInt != 3*config.PtrSize {
- break
- }
dst := v.Args[0]
v_1 := v.Args[1]
if v_1.Op != OpSliceMake {
cap := v_1.Args[2]
mem := v.Args[2]
v.reset(OpStore)
- v.AuxInt = config.PtrSize
v.Aux = config.fe.TypeInt()
v0 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeInt().PtrTo())
v0.AuxInt = 2 * config.PtrSize
v.AddArg(v0)
v.AddArg(cap)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v1.AuxInt = config.PtrSize
v1.Aux = config.fe.TypeInt()
v2 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeInt().PtrTo())
v2.AuxInt = config.PtrSize
v1.AddArg(v2)
v1.AddArg(len)
v3 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v3.AuxInt = config.PtrSize
v3.Aux = config.fe.TypeBytePtr()
v3.AddArg(dst)
v3.AddArg(ptr)
v.AddArg(v1)
return true
}
- // match: (Store [2*config.PtrSize] dst (IMake itab data) mem)
+ // match: (Store dst (IMake itab data) mem)
// cond:
- // result: (Store [config.PtrSize] {config.fe.TypeBytePtr()} (OffPtr <config.fe.TypeBytePtr().PtrTo()> [config.PtrSize] dst) data (Store [config.PtrSize] {config.fe.TypeUintptr()} dst itab mem))
+ // result: (Store {config.fe.TypeBytePtr()} (OffPtr <config.fe.TypeBytePtr().PtrTo()> [config.PtrSize] dst) data (Store {config.fe.TypeUintptr()} dst itab mem))
for {
- if v.AuxInt != 2*config.PtrSize {
- break
- }
dst := v.Args[0]
v_1 := v.Args[1]
if v_1.Op != OpIMake {
data := v_1.Args[1]
mem := v.Args[2]
v.reset(OpStore)
- v.AuxInt = config.PtrSize
v.Aux = config.fe.TypeBytePtr()
v0 := b.NewValue0(v.Pos, OpOffPtr, config.fe.TypeBytePtr().PtrTo())
v0.AuxInt = config.PtrSize
v.AddArg(v0)
v.AddArg(data)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v1.AuxInt = config.PtrSize
v1.Aux = config.fe.TypeUintptr()
v1.AddArg(dst)
v1.AddArg(itab)
func rewriteValuedec64_OpStore(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Store [8] dst (Int64Make hi lo) mem)
- // cond: !config.BigEndian
- // result: (Store [4] {hi.Type} (OffPtr <hi.Type.PtrTo()> [4] dst) hi (Store [4] {lo.Type} dst lo mem))
+ // match: (Store {t} dst (Int64Make hi lo) mem)
+ // cond: t.(Type).Size() == 8 && !config.BigEndian
+ // result: (Store {hi.Type} (OffPtr <hi.Type.PtrTo()> [4] dst) hi (Store {lo.Type} dst lo mem))
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
dst := v.Args[0]
v_1 := v.Args[1]
if v_1.Op != OpInt64Make {
hi := v_1.Args[0]
lo := v_1.Args[1]
mem := v.Args[2]
- if !(!config.BigEndian) {
+ if !(t.(Type).Size() == 8 && !config.BigEndian) {
break
}
v.reset(OpStore)
- v.AuxInt = 4
v.Aux = hi.Type
v0 := b.NewValue0(v.Pos, OpOffPtr, hi.Type.PtrTo())
v0.AuxInt = 4
v.AddArg(v0)
v.AddArg(hi)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v1.AuxInt = 4
v1.Aux = lo.Type
v1.AddArg(dst)
v1.AddArg(lo)
v.AddArg(v1)
return true
}
- // match: (Store [8] dst (Int64Make hi lo) mem)
- // cond: config.BigEndian
- // result: (Store [4] {lo.Type} (OffPtr <lo.Type.PtrTo()> [4] dst) lo (Store [4] {hi.Type} dst hi mem))
+ // match: (Store {t} dst (Int64Make hi lo) mem)
+ // cond: t.(Type).Size() == 8 && config.BigEndian
+ // result: (Store {lo.Type} (OffPtr <lo.Type.PtrTo()> [4] dst) lo (Store {hi.Type} dst hi mem))
for {
- if v.AuxInt != 8 {
- break
- }
+ t := v.Aux
dst := v.Args[0]
v_1 := v.Args[1]
if v_1.Op != OpInt64Make {
hi := v_1.Args[0]
lo := v_1.Args[1]
mem := v.Args[2]
- if !(config.BigEndian) {
+ if !(t.(Type).Size() == 8 && config.BigEndian) {
break
}
v.reset(OpStore)
- v.AuxInt = 4
v.Aux = lo.Type
v0 := b.NewValue0(v.Pos, OpOffPtr, lo.Type.PtrTo())
v0.AuxInt = 4
v.AddArg(v0)
v.AddArg(lo)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v1.AuxInt = 4
v1.Aux = hi.Type
v1.AddArg(dst)
v1.AddArg(hi)
func rewriteValuegeneric_OpLoad(v *Value, config *Config) bool {
b := v.Block
_ = b
- // match: (Load <t1> p1 (Store [w] p2 x _))
- // cond: isSamePtr(p1,p2) && t1.Compare(x.Type)==CMPeq && w == t1.Size()
+ // match: (Load <t1> p1 (Store {t2} p2 x _))
+ // cond: isSamePtr(p1,p2) && t1.Compare(x.Type)==CMPeq && t1.Size() == t2.(Type).Size()
// result: x
for {
t1 := v.Type
if v_1.Op != OpStore {
break
}
- w := v_1.AuxInt
+ t2 := v_1.Aux
p2 := v_1.Args[0]
x := v_1.Args[1]
- if !(isSamePtr(p1, p2) && t1.Compare(x.Type) == CMPeq && w == t1.Size()) {
+ if !(isSamePtr(p1, p2) && t1.Compare(x.Type) == CMPeq && t1.Size() == t2.(Type).Size()) {
break
}
v.reset(OpCopy)
}
// match: (Store dst (StructMake1 <t> f0) mem)
// cond:
- // result: (Store [t.FieldType(0).Size()] {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem)
+ // result: (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem)
for {
dst := v.Args[0]
v_1 := v.Args[1]
f0 := v_1.Args[0]
mem := v.Args[2]
v.reset(OpStore)
- v.AuxInt = t.FieldType(0).Size()
v.Aux = t.FieldType(0)
v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
v0.AuxInt = 0
}
// match: (Store dst (StructMake2 <t> f0 f1) mem)
// cond:
- // result: (Store [t.FieldType(1).Size()] {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store [t.FieldType(0).Size()] {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem))
+ // result: (Store {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem))
for {
dst := v.Args[0]
v_1 := v.Args[1]
f1 := v_1.Args[1]
mem := v.Args[2]
v.reset(OpStore)
- v.AuxInt = t.FieldType(1).Size()
v.Aux = t.FieldType(1)
v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
v0.AuxInt = t.FieldOff(1)
v.AddArg(v0)
v.AddArg(f1)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v1.AuxInt = t.FieldType(0).Size()
v1.Aux = t.FieldType(0)
v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
v2.AuxInt = 0
}
// match: (Store dst (StructMake3 <t> f0 f1 f2) mem)
// cond:
- // result: (Store [t.FieldType(2).Size()] {t.FieldType(2)} (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst) f2 (Store [t.FieldType(1).Size()] {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store [t.FieldType(0).Size()] {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem)))
+ // result: (Store {t.FieldType(2)} (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst) f2 (Store {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem)))
for {
dst := v.Args[0]
v_1 := v.Args[1]
f2 := v_1.Args[2]
mem := v.Args[2]
v.reset(OpStore)
- v.AuxInt = t.FieldType(2).Size()
v.Aux = t.FieldType(2)
v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo())
v0.AuxInt = t.FieldOff(2)
v.AddArg(v0)
v.AddArg(f2)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v1.AuxInt = t.FieldType(1).Size()
v1.Aux = t.FieldType(1)
v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
v2.AuxInt = t.FieldOff(1)
v1.AddArg(v2)
v1.AddArg(f1)
v3 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v3.AuxInt = t.FieldType(0).Size()
v3.Aux = t.FieldType(0)
v4 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
v4.AuxInt = 0
}
// match: (Store dst (StructMake4 <t> f0 f1 f2 f3) mem)
// cond:
- // result: (Store [t.FieldType(3).Size()] {t.FieldType(3)} (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] dst) f3 (Store [t.FieldType(2).Size()] {t.FieldType(2)} (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst) f2 (Store [t.FieldType(1).Size()] {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store [t.FieldType(0).Size()] {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem))))
+ // result: (Store {t.FieldType(3)} (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] dst) f3 (Store {t.FieldType(2)} (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst) f2 (Store {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem))))
for {
dst := v.Args[0]
v_1 := v.Args[1]
f3 := v_1.Args[3]
mem := v.Args[2]
v.reset(OpStore)
- v.AuxInt = t.FieldType(3).Size()
v.Aux = t.FieldType(3)
v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(3).PtrTo())
v0.AuxInt = t.FieldOff(3)
v.AddArg(v0)
v.AddArg(f3)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v1.AuxInt = t.FieldType(2).Size()
v1.Aux = t.FieldType(2)
v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo())
v2.AuxInt = t.FieldOff(2)
v1.AddArg(v2)
v1.AddArg(f2)
v3 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v3.AuxInt = t.FieldType(1).Size()
v3.Aux = t.FieldType(1)
v4 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
v4.AuxInt = t.FieldOff(1)
v3.AddArg(v4)
v3.AddArg(f1)
v5 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v5.AuxInt = t.FieldType(0).Size()
v5.Aux = t.FieldType(0)
v6 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
v6.AuxInt = 0
v.AddArg(v1)
return true
}
- // match: (Store [size] dst (Load <t> src mem) mem)
- // cond: !config.fe.CanSSA(t)
- // result: (Move [MakeSizeAndAlign(size, t.Alignment()).Int64()] {t} dst src mem)
+ // match: (Store {t} dst (Load src mem) mem)
+ // cond: !config.fe.CanSSA(t.(Type))
+ // result: (Move {t} [t.(Type).Size()] dst src mem)
for {
- size := v.AuxInt
+ t := v.Aux
dst := v.Args[0]
v_1 := v.Args[1]
if v_1.Op != OpLoad {
break
}
- t := v_1.Type
src := v_1.Args[0]
mem := v_1.Args[1]
if mem != v.Args[2] {
break
}
- if !(!config.fe.CanSSA(t)) {
+ if !(!config.fe.CanSSA(t.(Type))) {
break
}
v.reset(OpMove)
- v.AuxInt = MakeSizeAndAlign(size, t.Alignment()).Int64()
+ v.AuxInt = t.(Type).Size()
v.Aux = t
v.AddArg(dst)
v.AddArg(src)
v.AddArg(mem)
return true
}
- // match: (Store [size] dst (Load <t> src mem) (VarDef {x} mem))
- // cond: !config.fe.CanSSA(t)
- // result: (Move [MakeSizeAndAlign(size, t.Alignment()).Int64()] {t} dst src (VarDef {x} mem))
+ // match: (Store {t} dst (Load src mem) (VarDef {x} mem))
+ // cond: !config.fe.CanSSA(t.(Type))
+ // result: (Move {t} [t.(Type).Size()] dst src (VarDef {x} mem))
for {
- size := v.AuxInt
+ t := v.Aux
dst := v.Args[0]
v_1 := v.Args[1]
if v_1.Op != OpLoad {
break
}
- t := v_1.Type
src := v_1.Args[0]
mem := v_1.Args[1]
v_2 := v.Args[2]
if mem != v_2.Args[0] {
break
}
- if !(!config.fe.CanSSA(t)) {
+ if !(!config.fe.CanSSA(t.(Type))) {
break
}
v.reset(OpMove)
- v.AuxInt = MakeSizeAndAlign(size, t.Alignment()).Int64()
+ v.AuxInt = t.(Type).Size()
v.Aux = t
v.AddArg(dst)
v.AddArg(src)
v.AddArg(mem)
return true
}
- // match: (Store [size] dst (ArrayMake1 e) mem)
+ // match: (Store dst (ArrayMake1 e) mem)
// cond:
- // result: (Store [size] {e.Type} dst e mem)
+ // result: (Store {e.Type} dst e mem)
for {
- size := v.AuxInt
dst := v.Args[0]
v_1 := v.Args[1]
if v_1.Op != OpArrayMake1 {
e := v_1.Args[0]
mem := v.Args[2]
v.reset(OpStore)
- v.AuxInt = size
v.Aux = e.Type
v.AddArg(dst)
v.AddArg(e)
Valu("mem0", OpInitMem, TypeMem, 0, nil),
Valu("ptr", OpConst64, TypeInt64, 0xABCD, nil),
Valu("v", OpConst64, TypeInt64, 12, nil),
- Valu("mem1", OpStore, TypeMem, 8, nil, "ptr", "v", "mem0"),
- Valu("mem2", OpStore, TypeMem, 8, nil, "ptr", "v", "mem1"),
- Valu("mem3", OpStore, TypeInt64, 8, nil, "ptr", "sum", "mem2"),
+ Valu("mem1", OpStore, TypeMem, 0, TypeInt64, "ptr", "v", "mem0"),
+ Valu("mem2", OpStore, TypeMem, 0, TypeInt64, "ptr", "v", "mem1"),
+ Valu("mem3", OpStore, TypeMem, 0, TypeInt64, "ptr", "sum", "mem2"),
Valu("l1", OpLoad, TypeInt64, 0, nil, "ptr", "mem1"),
Valu("l2", OpLoad, TypeInt64, 0, nil, "ptr", "mem2"),
Valu("sum", OpAdd64, TypeInt64, 0, nil, "l1", "l2"),
fun := Fun(c, "entry",
Bloc("entry",
Valu("mem0", OpInitMem, TypeMem, 0, nil),
- Valu("a", OpAdd64, TypeInt64, 0, nil, "b", "c"), // v2
- Valu("b", OpLoad, TypeInt64, 0, nil, "ptr", "mem1"), // v3
- Valu("c", OpNeg64, TypeInt64, 0, nil, "b"), // v4
- Valu("mem1", OpStore, TypeMem, 8, nil, "ptr", "v", "mem0"), // v5
- Valu("mem2", OpStore, TypeMem, 0, nil, "ptr", "a", "mem1"),
+ Valu("a", OpAdd64, TypeInt64, 0, nil, "b", "c"), // v2
+ Valu("b", OpLoad, TypeInt64, 0, nil, "ptr", "mem1"), // v3
+ Valu("c", OpNeg64, TypeInt64, 0, nil, "b"), // v4
+ Valu("mem1", OpStore, TypeMem, 0, TypeInt64, "ptr", "v", "mem0"), // v5
+ Valu("mem2", OpStore, TypeMem, 0, TypeInt64, "ptr", "a", "mem1"),
Valu("ptr", OpConst64, TypeInt64, 0xABCD, nil),
Valu("v", OpConst64, TypeInt64, 12, nil),
Goto("exit")),
Valu("load", OpLoad, typ, 0, nil, "argptr", "mem"),
Valu("c", OpConst64, TypeUInt64, amount, nil),
Valu("shift", op, typ, 0, nil, "load", "c"),
- Valu("store", OpStore, TypeMem, 8, TypeUInt64, "resptr", "shift", "mem"),
+ Valu("store", OpStore, TypeMem, 0, TypeUInt64, "resptr", "shift", "mem"),
Exit("store")))
Compile(fun.f)
return fun
Valu("c", OpConst64, TypeUInt64, amount, nil),
Valu("lshift", lshift, typ, 0, nil, "load", "c"),
Valu("rshift", rshift, typ, 0, nil, "lshift", "c"),
- Valu("store", OpStore, TypeMem, 8, TypeUInt64, "resptr", "rshift", "mem"),
+ Valu("store", OpStore, TypeMem, 0, TypeUInt64, "resptr", "rshift", "mem"),
Exit("store")))
Compile(fun.f)
return fun
return fmt.Sprintf(" [%d]", v.AuxInt32())
case auxInt64, auxInt128:
return fmt.Sprintf(" [%d]", v.AuxInt)
- case auxSizeAndAlign:
- return fmt.Sprintf(" [%s]", SizeAndAlign(v.AuxInt))
case auxFloat32, auxFloat64:
return fmt.Sprintf(" [%g]", v.AuxFloat())
case auxString:
return fmt.Sprintf(" {%q}", v.Aux)
- case auxSym:
+ case auxSym, auxTyp:
if v.Aux != nil {
return fmt.Sprintf(" {%v}", v.Aux)
}
- case auxSymOff, auxSymInt32:
+ case auxSymOff, auxSymInt32, auxTypSize:
s := ""
if v.Aux != nil {
s = fmt.Sprintf(" {%v}", v.Aux)
s = fmt.Sprintf(" {%v}", v.Aux)
}
return s + fmt.Sprintf(" [%s]", v.AuxValAndOff())
- case auxSymSizeAndAlign:
- s := ""
- if v.Aux != nil {
- s = fmt.Sprintf(" {%v}", v.Aux)
- }
- return s + fmt.Sprintf(" [%s]", SizeAndAlign(v.AuxInt))
}
return ""
}
for _, w := range stores {
var val *Value
ptr := w.Args[0]
- siz := w.AuxInt
var typ interface{}
if w.Op != OpStoreWB {
typ = &ExternSymbol{Typ: f.Config.fe.TypeUintptr(), Sym: w.Aux.(Type).Symbol()}
}
pos = w.Pos
- var op Op
var fn *obj.LSym
switch w.Op {
case OpStoreWB:
- op = OpStore
fn = writebarrierptr
val = w.Args[1]
case OpMoveWB:
- op = OpMove
fn = typedmemmove
val = w.Args[1]
case OpZeroWB:
- op = OpZero
fn = typedmemclr
}
memThen = wbcall(pos, bThen, fn, typ, ptr, val, memThen, sp, sb, volatile)
// else block: normal store
- if op == OpZero {
- memElse = bElse.NewValue2I(pos, op, TypeMem, siz, ptr, memElse)
- } else {
- memElse = bElse.NewValue3I(pos, op, TypeMem, siz, ptr, val, memElse)
+ switch w.Op {
+ case OpStoreWB:
+ memElse = bElse.NewValue3A(pos, OpStore, TypeMem, w.Aux, ptr, val, memElse)
+ case OpMoveWB:
+ memElse = bElse.NewValue3I(pos, OpMove, TypeMem, w.AuxInt, ptr, val, memElse)
+ memElse.Aux = w.Aux
+ case OpZeroWB:
+ memElse = bElse.NewValue2I(pos, OpZero, TypeMem, w.AuxInt, ptr, memElse)
+ memElse.Aux = w.Aux
}
if f.NoWB {
aux := &AutoSymbol{Typ: t, Node: tmp}
mem = b.NewValue1A(pos, OpVarDef, TypeMem, tmp, mem)
tmpaddr := b.NewValue1A(pos, OpAddr, t.PtrTo(), aux, sp)
- siz := MakeSizeAndAlign(t.Size(), t.Alignment()).Int64()
+ siz := t.Size()
mem = b.NewValue3I(pos, OpMove, TypeMem, siz, tmpaddr, val, mem)
+ mem.Aux = t
val = tmpaddr
}
taddr := b.NewValue1A(pos, OpAddr, config.fe.TypeUintptr(), typ, sb)
off = round(off, taddr.Type.Alignment())
arg := b.NewValue1I(pos, OpOffPtr, taddr.Type.PtrTo(), off, sp)
- mem = b.NewValue3I(pos, OpStore, TypeMem, ptr.Type.Size(), arg, taddr, mem)
+ mem = b.NewValue3A(pos, OpStore, TypeMem, ptr.Type, arg, taddr, mem)
off += taddr.Type.Size()
}
off = round(off, ptr.Type.Alignment())
arg := b.NewValue1I(pos, OpOffPtr, ptr.Type.PtrTo(), off, sp)
- mem = b.NewValue3I(pos, OpStore, TypeMem, ptr.Type.Size(), arg, ptr, mem)
+ mem = b.NewValue3A(pos, OpStore, TypeMem, ptr.Type, arg, ptr, mem)
off += ptr.Type.Size()
if val != nil {
off = round(off, val.Type.Alignment())
arg = b.NewValue1I(pos, OpOffPtr, val.Type.PtrTo(), off, sp)
- mem = b.NewValue3I(pos, OpStore, TypeMem, val.Type.Size(), arg, val, mem)
+ mem = b.NewValue3A(pos, OpStore, TypeMem, val.Type, arg, val, mem)
off += val.Type.Size()
}
off = round(off, config.PtrSize)
Valu("sp", OpSP, TypeInvalid, 0, nil),
Valu("v", OpConstNil, ptrType, 0, nil),
Valu("addr1", OpAddr, ptrType, 0, nil, "sb"),
- Valu("wb2", OpStore, TypeMem, 8, ptrType, "addr1", "v", "wb1"),
- Valu("wb1", OpStore, TypeMem, 8, ptrType, "addr1", "v", "start"), // wb1 and wb2 are out of order
+ Valu("wb2", OpStore, TypeMem, 0, ptrType, "addr1", "v", "wb1"),
+ Valu("wb1", OpStore, TypeMem, 0, ptrType, "addr1", "v", "start"), // wb1 and wb2 are out of order
Goto("exit")),
Bloc("exit",
Exit("wb2")))
Valu("phi", OpPhi, TypeMem, 0, nil, "start", "wb"),
Valu("v", OpConstNil, ptrType, 0, nil),
Valu("addr", OpAddr, ptrType, 0, nil, "sb"),
- Valu("wb", OpStore, TypeMem, 8, ptrType, "addr", "v", "phi"), // has write barrier
+ Valu("wb", OpStore, TypeMem, 0, ptrType, "addr", "v", "phi"), // has write barrier
Goto("loop")))
CheckFunc(fun.f)