var ssaCache *ssa.Cache
func initssaconfig() {
- ssaConfig = ssa.NewConfig(thearch.LinkArch.Name, Ctxt, Debug['N'] == 0)
+ types := ssa.Types{
+ Bool: Types[TBOOL],
+ Int8: Types[TINT8],
+ Int16: Types[TINT16],
+ Int32: Types[TINT32],
+ Int64: Types[TINT64],
+ UInt8: Types[TUINT8],
+ UInt16: Types[TUINT16],
+ UInt32: Types[TUINT32],
+ UInt64: Types[TUINT64],
+ Float32: Types[TFLOAT32],
+ Float64: Types[TFLOAT64],
+ Int: Types[TINT],
+ Uintptr: Types[TUINTPTR],
+ String: Types[TSTRING],
+ BytePtr: ptrto(Types[TUINT8]),
+ }
+ ssaConfig = ssa.NewConfig(thearch.LinkArch.Name, types, Ctxt, Debug['N'] == 0)
if thearch.LinkArch.Name == "386" {
ssaConfig.Set387(thearch.Use387)
}
log bool
}
-func (s *ssafn) TypeBool() ssa.Type { return Types[TBOOL] }
-func (s *ssafn) TypeInt8() ssa.Type { return Types[TINT8] }
-func (s *ssafn) TypeInt16() ssa.Type { return Types[TINT16] }
-func (s *ssafn) TypeInt32() ssa.Type { return Types[TINT32] }
-func (s *ssafn) TypeInt64() ssa.Type { return Types[TINT64] }
-func (s *ssafn) TypeUInt8() ssa.Type { return Types[TUINT8] }
-func (s *ssafn) TypeUInt16() ssa.Type { return Types[TUINT16] }
-func (s *ssafn) TypeUInt32() ssa.Type { return Types[TUINT32] }
-func (s *ssafn) TypeUInt64() ssa.Type { return Types[TUINT64] }
-func (s *ssafn) TypeFloat32() ssa.Type { return Types[TFLOAT32] }
-func (s *ssafn) TypeFloat64() ssa.Type { return Types[TFLOAT64] }
-func (s *ssafn) TypeInt() ssa.Type { return Types[TINT] }
-func (s *ssafn) TypeUintptr() ssa.Type { return Types[TUINTPTR] }
-func (s *ssafn) TypeString() ssa.Type { return Types[TSTRING] }
-func (s *ssafn) TypeBytePtr() ssa.Type { return ptrto(Types[TUINT8]) }
-
// StringData returns a symbol (a *Sym wrapped in an interface) which
// is the data component of a global string constant containing s.
func (*ssafn) StringData(s string) interface{} {
// It is created once, early during compilation,
// and shared across all compilations.
type Config struct {
- arch string // "amd64", etc.
- IntSize int64 // 4 or 8
- PtrSize int64 // 4 or 8
- RegSize int64 // 4 or 8
+ arch string // "amd64", etc.
+ IntSize int64 // 4 or 8
+ PtrSize int64 // 4 or 8
+ RegSize int64 // 4 or 8
+ Types Types
lowerBlock blockRewriter // lowering function
lowerValue valueRewriter // lowering function
registers []Register // machine registers
valueRewriter func(*Value) bool
)
-type TypeSource interface {
- TypeBool() Type
- TypeInt8() Type
- TypeInt16() Type
- TypeInt32() Type
- TypeInt64() Type
- TypeUInt8() Type
- TypeUInt16() Type
- TypeUInt32() Type
- TypeUInt64() Type
- TypeInt() Type
- TypeFloat32() Type
- TypeFloat64() Type
- TypeUintptr() Type
- TypeString() Type
- TypeBytePtr() Type // TODO: use unsafe.Pointer instead?
-
- CanSSA(t Type) bool
+type Types struct {
+ Bool Type
+ Int8 Type
+ Int16 Type
+ Int32 Type
+ Int64 Type
+ UInt8 Type
+ UInt16 Type
+ UInt32 Type
+ UInt64 Type
+ Int Type
+ Float32 Type
+ Float64 Type
+ Uintptr Type
+ String Type
+ BytePtr Type // TODO: use unsafe.Pointer instead?
}
type Logger interface {
}
type Frontend interface {
- TypeSource
+ CanSSA(t Type) bool
+
Logger
// StringData returns a symbol pointing to the given string's contents.
}
// NewConfig returns a new configuration object for the given architecture.
-func NewConfig(arch string, ctxt *obj.Link, optimize bool) *Config {
- c := &Config{arch: arch}
+func NewConfig(arch string, types Types, ctxt *obj.Link, optimize bool) *Config {
+ c := &Config{arch: arch, Types: types}
switch arch {
case "amd64":
c.IntSize = 8
case t.IsInteger() && t.Size() == 8 && f.Config.IntSize == 4:
var elemType Type
if t.IsSigned() {
- elemType = f.fe.TypeInt32()
+ elemType = f.Config.Types.Int32
} else {
- elemType = f.fe.TypeUInt32()
+ elemType = f.Config.Types.UInt32
}
hiName, loName := f.fe.SplitInt64(name)
newNames = append(newNames, hiName, loName)
for _, v := range f.NamedValues[name] {
hi := v.Block.NewValue1(v.Pos, OpInt64Hi, elemType, v)
- lo := v.Block.NewValue1(v.Pos, OpInt64Lo, f.fe.TypeUInt32(), v)
+ lo := v.Block.NewValue1(v.Pos, OpInt64Lo, f.Config.Types.UInt32, v)
f.NamedValues[hiName] = append(f.NamedValues[hiName], hi)
f.NamedValues[loName] = append(f.NamedValues[loName], lo)
}
case t.IsComplex():
var elemType Type
if t.Size() == 16 {
- elemType = f.fe.TypeFloat64()
+ elemType = f.Config.Types.Float64
} else {
- elemType = f.fe.TypeFloat32()
+ elemType = f.Config.Types.Float32
}
rName, iName := f.fe.SplitComplex(name)
newNames = append(newNames, rName, iName)
}
delete(f.NamedValues, name)
case t.IsString():
- ptrType := f.fe.TypeBytePtr()
- lenType := f.fe.TypeInt()
+ ptrType := f.Config.Types.BytePtr
+ lenType := f.Config.Types.Int
ptrName, lenName := f.fe.SplitString(name)
newNames = append(newNames, ptrName, lenName)
for _, v := range f.NamedValues[name] {
}
delete(f.NamedValues, name)
case t.IsSlice():
- ptrType := f.fe.TypeBytePtr()
- lenType := f.fe.TypeInt()
+ ptrType := f.Config.Types.BytePtr
+ lenType := f.Config.Types.Int
ptrName, lenName, capName := f.fe.SplitSlice(name)
newNames = append(newNames, ptrName, lenName, capName)
for _, v := range f.NamedValues[name] {
}
delete(f.NamedValues, name)
case t.IsInterface():
- ptrType := f.fe.TypeBytePtr()
+ ptrType := f.Config.Types.BytePtr
typeName, dataName := f.fe.SplitInterface(name)
newNames = append(newNames, typeName, dataName)
for _, v := range f.NamedValues[name] {
}
func decomposeStringPhi(v *Value) {
- fe := v.Block.Func.fe
- ptrType := fe.TypeBytePtr()
- lenType := fe.TypeInt()
+ types := &v.Block.Func.Config.Types
+ ptrType := types.BytePtr
+ lenType := types.Int
ptr := v.Block.NewValue0(v.Pos, OpPhi, ptrType)
len := v.Block.NewValue0(v.Pos, OpPhi, lenType)
}
func decomposeSlicePhi(v *Value) {
- fe := v.Block.Func.fe
- ptrType := fe.TypeBytePtr()
- lenType := fe.TypeInt()
+ types := &v.Block.Func.Config.Types
+ ptrType := types.BytePtr
+ lenType := types.Int
ptr := v.Block.NewValue0(v.Pos, OpPhi, ptrType)
len := v.Block.NewValue0(v.Pos, OpPhi, lenType)
}
func decomposeInt64Phi(v *Value) {
- fe := v.Block.Func.fe
+ types := &v.Block.Func.Config.Types
var partType Type
if v.Type.IsSigned() {
- partType = fe.TypeInt32()
+ partType = types.Int32
} else {
- partType = fe.TypeUInt32()
+ partType = types.UInt32
}
hi := v.Block.NewValue0(v.Pos, OpPhi, partType)
- lo := v.Block.NewValue0(v.Pos, OpPhi, fe.TypeUInt32())
+ lo := v.Block.NewValue0(v.Pos, OpPhi, types.UInt32)
for _, a := range v.Args {
hi.AddArg(a.Block.NewValue1(v.Pos, OpInt64Hi, partType, a))
- lo.AddArg(a.Block.NewValue1(v.Pos, OpInt64Lo, fe.TypeUInt32(), a))
+ lo.AddArg(a.Block.NewValue1(v.Pos, OpInt64Lo, types.UInt32, a))
}
v.reset(OpInt64Make)
v.AddArg(hi)
}
func decomposeComplexPhi(v *Value) {
- fe := v.Block.Func.fe
+ types := &v.Block.Func.Config.Types
var partType Type
switch z := v.Type.Size(); z {
case 8:
- partType = fe.TypeFloat32()
+ partType = types.Float32
case 16:
- partType = fe.TypeFloat64()
+ partType = types.Float64
default:
v.Fatalf("decomposeComplexPhi: bad complex size %d", z)
}
}
func decomposeInterfacePhi(v *Value) {
- ptrType := v.Block.Func.fe.TypeBytePtr()
+ ptrType := v.Block.Func.Config.Types.BytePtr
itab := v.Block.NewValue0(v.Pos, OpPhi, ptrType)
data := v.Block.NewValue0(v.Pos, OpPhi, ptrType)
var TestCtxt = obj.Linknew(&x86.Linkamd64)
func testConfig(t testing.TB) *Config {
- return NewConfig("amd64", TestCtxt, true)
+ return NewConfig("amd64", dummyTypes, TestCtxt, true)
}
func testConfigS390X(t testing.TB) *Config {
- return NewConfig("s390x", obj.Linknew(&s390x.Links390x), true)
+ return NewConfig("s390x", dummyTypes, obj.Linknew(&s390x.Links390x), true)
}
// DummyFrontend is a test-only frontend.
return &DummyAuto{t: t, s: "aDummyAuto"}
}
func (d DummyFrontend) SplitString(s LocalSlot) (LocalSlot, LocalSlot) {
- return LocalSlot{s.N, d.TypeBytePtr(), s.Off}, LocalSlot{s.N, d.TypeInt(), s.Off + 8}
+ return LocalSlot{s.N, dummyTypes.BytePtr, s.Off}, LocalSlot{s.N, dummyTypes.Int, s.Off + 8}
}
func (d DummyFrontend) SplitInterface(s LocalSlot) (LocalSlot, LocalSlot) {
- return LocalSlot{s.N, d.TypeBytePtr(), s.Off}, LocalSlot{s.N, d.TypeBytePtr(), s.Off + 8}
+ return LocalSlot{s.N, dummyTypes.BytePtr, s.Off}, LocalSlot{s.N, dummyTypes.BytePtr, s.Off + 8}
}
func (d DummyFrontend) SplitSlice(s LocalSlot) (LocalSlot, LocalSlot, LocalSlot) {
return LocalSlot{s.N, s.Type.ElemType().PtrTo(), s.Off},
- LocalSlot{s.N, d.TypeInt(), s.Off + 8},
- LocalSlot{s.N, d.TypeInt(), s.Off + 16}
+ LocalSlot{s.N, dummyTypes.Int, s.Off + 8},
+ LocalSlot{s.N, dummyTypes.Int, s.Off + 16}
}
func (d DummyFrontend) SplitComplex(s LocalSlot) (LocalSlot, LocalSlot) {
if s.Type.Size() == 16 {
- return LocalSlot{s.N, d.TypeFloat64(), s.Off}, LocalSlot{s.N, d.TypeFloat64(), s.Off + 8}
+ return LocalSlot{s.N, dummyTypes.Float64, s.Off}, LocalSlot{s.N, dummyTypes.Float64, s.Off + 8}
}
- return LocalSlot{s.N, d.TypeFloat32(), s.Off}, LocalSlot{s.N, d.TypeFloat32(), s.Off + 4}
+ return LocalSlot{s.N, dummyTypes.Float32, s.Off}, LocalSlot{s.N, dummyTypes.Float32, s.Off + 4}
}
func (d DummyFrontend) SplitInt64(s LocalSlot) (LocalSlot, LocalSlot) {
if s.Type.IsSigned() {
- return LocalSlot{s.N, d.TypeInt32(), s.Off + 4}, LocalSlot{s.N, d.TypeUInt32(), s.Off}
+ return LocalSlot{s.N, dummyTypes.Int32, s.Off + 4}, LocalSlot{s.N, dummyTypes.UInt32, s.Off}
}
- return LocalSlot{s.N, d.TypeUInt32(), s.Off + 4}, LocalSlot{s.N, d.TypeUInt32(), s.Off}
+ return LocalSlot{s.N, dummyTypes.UInt32, s.Off + 4}, LocalSlot{s.N, dummyTypes.UInt32, s.Off}
}
func (d DummyFrontend) SplitStruct(s LocalSlot, i int) LocalSlot {
return LocalSlot{s.N, s.Type.FieldType(i), s.Off + s.Type.FieldOff(i)}
func (d DummyFrontend) Debug_checknil() bool { return false }
func (d DummyFrontend) Debug_wb() bool { return false }
-func (d DummyFrontend) TypeBool() Type { return TypeBool }
-func (d DummyFrontend) TypeInt8() Type { return TypeInt8 }
-func (d DummyFrontend) TypeInt16() Type { return TypeInt16 }
-func (d DummyFrontend) TypeInt32() Type { return TypeInt32 }
-func (d DummyFrontend) TypeInt64() Type { return TypeInt64 }
-func (d DummyFrontend) TypeUInt8() Type { return TypeUInt8 }
-func (d DummyFrontend) TypeUInt16() Type { return TypeUInt16 }
-func (d DummyFrontend) TypeUInt32() Type { return TypeUInt32 }
-func (d DummyFrontend) TypeUInt64() Type { return TypeUInt64 }
-func (d DummyFrontend) TypeFloat32() Type { return TypeFloat32 }
-func (d DummyFrontend) TypeFloat64() Type { return TypeFloat64 }
-func (d DummyFrontend) TypeInt() Type { return TypeInt64 }
-func (d DummyFrontend) TypeUintptr() Type { return TypeUInt64 }
-func (d DummyFrontend) TypeString() Type { panic("unimplemented") }
-func (d DummyFrontend) TypeBytePtr() Type { return TypeBytePtr }
+var dummyTypes = Types{
+ Bool: TypeBool,
+ Int8: TypeInt8,
+ Int16: TypeInt16,
+ Int32: TypeInt32,
+ Int64: TypeInt64,
+ UInt8: TypeUInt8,
+ UInt16: TypeUInt16,
+ UInt32: TypeUInt32,
+ UInt64: TypeUInt64,
+ Float32: TypeFloat32,
+ Float64: TypeFloat64,
+ Int: TypeInt64,
+ Uintptr: TypeUInt64,
+ String: nil,
+ BytePtr: TypeBytePtr,
+}
+
func (d DummyFrontend) DerefItab(sym *obj.LSym, off int64) *obj.LSym { return nil }
func (d DummyFrontend) CanSSA(t Type) bool {
(Neg32 x) -> (NEGL x)
(Neg16 x) -> (NEGL x)
(Neg8 x) -> (NEGL x)
-(Neg32F x) && !config.use387 -> (PXOR x (MOVSSconst <fe.TypeFloat32()> [f2i(math.Copysign(0, -1))]))
-(Neg64F x) && !config.use387 -> (PXOR x (MOVSDconst <fe.TypeFloat64()> [f2i(math.Copysign(0, -1))]))
+(Neg32F x) && !config.use387 -> (PXOR x (MOVSSconst <types.Float32> [f2i(math.Copysign(0, -1))]))
+(Neg64F x) && !config.use387 -> (PXOR x (MOVSDconst <types.Float64> [f2i(math.Copysign(0, -1))]))
(Neg32F x) && config.use387 -> (FCHS x)
(Neg64F x) && config.use387 -> (FCHS x)
(Neg32 x) -> (NEGL x)
(Neg16 x) -> (NEGL x)
(Neg8 x) -> (NEGL x)
-(Neg32F x) -> (PXOR x (MOVSSconst <fe.TypeFloat32()> [f2i(math.Copysign(0, -1))]))
-(Neg64F x) -> (PXOR x (MOVSDconst <fe.TypeFloat64()> [f2i(math.Copysign(0, -1))]))
+(Neg32F x) -> (PXOR x (MOVSSconst <types.Float32> [f2i(math.Copysign(0, -1))]))
+(Neg64F x) -> (PXOR x (MOVSDconst <types.Float64> [f2i(math.Copysign(0, -1))]))
(Com64 x) -> (NOTQ x)
(Com32 x) -> (NOTL x)
// Lowering other arithmetic
(Ctz64 <t> x) -> (CMOVQEQ (Select0 <t> (BSFQ x)) (MOVQconst <t> [64]) (Select1 <TypeFlags> (BSFQ x)))
-(Ctz32 x) -> (Select0 (BSFQ (ORQ <fe.TypeUInt64()> (MOVQconst [1<<32]) x)))
+(Ctz32 x) -> (Select0 (BSFQ (ORQ <types.UInt64> (MOVQconst [1<<32]) x)))
(BitLen64 <t> x) -> (ADDQconst [1] (CMOVQEQ <t> (Select0 <t> (BSRQ x)) (MOVQconst <t> [-1]) (Select1 <TypeFlags> (BSRQ x))))
-(BitLen32 x) -> (BitLen64 (MOVLQZX <fe.TypeUInt64()> x))
+(BitLen32 x) -> (BitLen64 (MOVLQZX <types.UInt64> x))
(Bswap64 x) -> (BSWAPQ x)
(Bswap32 x) -> (BSWAPL x)
// Atomic stores. We use XCHG to prevent the hardware reordering a subsequent load.
// TODO: most runtime uses of atomic stores don't need that property. Use normal stores for those?
-(AtomicStore32 ptr val mem) -> (Select1 (XCHGL <MakeTuple(fe.TypeUInt32(),TypeMem)> val ptr mem))
-(AtomicStore64 ptr val mem) -> (Select1 (XCHGQ <MakeTuple(fe.TypeUInt64(),TypeMem)> val ptr mem))
-(AtomicStorePtrNoWB ptr val mem) && config.PtrSize == 8 -> (Select1 (XCHGQ <MakeTuple(fe.TypeBytePtr(),TypeMem)> val ptr mem))
-(AtomicStorePtrNoWB ptr val mem) && config.PtrSize == 4 -> (Select1 (XCHGL <MakeTuple(fe.TypeBytePtr(),TypeMem)> val ptr mem))
+(AtomicStore32 ptr val mem) -> (Select1 (XCHGL <MakeTuple(types.UInt32,TypeMem)> val ptr mem))
+(AtomicStore64 ptr val mem) -> (Select1 (XCHGQ <MakeTuple(types.UInt64,TypeMem)> val ptr mem))
+(AtomicStorePtrNoWB ptr val mem) && config.PtrSize == 8 -> (Select1 (XCHGQ <MakeTuple(types.BytePtr,TypeMem)> val ptr mem))
+(AtomicStorePtrNoWB ptr val mem) && config.PtrSize == 4 -> (Select1 (XCHGL <MakeTuple(types.BytePtr,TypeMem)> val ptr mem))
// Atomic exchanges.
(AtomicExchange32 ptr val mem) -> (XCHGL val ptr mem)
(NE (TESTB (SETNEF cmp) (SETNEF cmp)) yes no) -> (NEF cmp yes no)
// Disabled because it interferes with the pattern match above and makes worse code.
-// (SETNEF x) -> (ORQ (SETNE <fe.TypeInt8()> x) (SETNAN <fe.TypeInt8()> x))
-// (SETEQF x) -> (ANDQ (SETEQ <fe.TypeInt8()> x) (SETORD <fe.TypeInt8()> x))
+// (SETNEF x) -> (ORQ (SETNE <types.Int8> x) (SETNAN <types.Int8> x))
+// (SETEQF x) -> (ANDQ (SETEQ <types.Int8> x) (SETORD <types.Int8> x))
// fold constants into instructions
(ADDQ x (MOVQconst [c])) && is32Bit(c) -> (ADDQconst [c] x)
(Mul32uhilo x y) -> (MULLU x y)
(Div32 x y) ->
- (SUB (XOR <fe.TypeUInt32()> // negate the result if one operand is negative
- (Select0 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)}
- (SUB <fe.TypeUInt32()> (XOR x <fe.TypeUInt32()> (Signmask x)) (Signmask x)) // negate x if negative
- (SUB <fe.TypeUInt32()> (XOR y <fe.TypeUInt32()> (Signmask y)) (Signmask y)))) // negate y if negative
- (Signmask (XOR <fe.TypeUInt32()> x y))) (Signmask (XOR <fe.TypeUInt32()> x y)))
-(Div32u x y) -> (Select0 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y))
+ (SUB (XOR <types.UInt32> // negate the result if one operand is negative
+ (Select0 <types.UInt32> (CALLudiv {config.ctxt.Lookup("udiv", 0)}
+ (SUB <types.UInt32> (XOR x <types.UInt32> (Signmask x)) (Signmask x)) // negate x if negative
+ (SUB <types.UInt32> (XOR y <types.UInt32> (Signmask y)) (Signmask y)))) // negate y if negative
+ (Signmask (XOR <types.UInt32> x y))) (Signmask (XOR <types.UInt32> x y)))
+(Div32u x y) -> (Select0 <types.UInt32> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y))
(Div16 x y) -> (Div32 (SignExt16to32 x) (SignExt16to32 y))
(Div16u x y) -> (Div32u (ZeroExt16to32 x) (ZeroExt16to32 y))
(Div8 x y) -> (Div32 (SignExt8to32 x) (SignExt8to32 y))
(Div64F x y) -> (DIVD x y)
(Mod32 x y) ->
- (SUB (XOR <fe.TypeUInt32()> // negate the result if x is negative
- (Select1 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)}
- (SUB <fe.TypeUInt32()> (XOR <fe.TypeUInt32()> x (Signmask x)) (Signmask x)) // negate x if negative
- (SUB <fe.TypeUInt32()> (XOR <fe.TypeUInt32()> y (Signmask y)) (Signmask y)))) // negate y if negative
+ (SUB (XOR <types.UInt32> // negate the result if x is negative
+ (Select1 <types.UInt32> (CALLudiv {config.ctxt.Lookup("udiv", 0)}
+ (SUB <types.UInt32> (XOR <types.UInt32> x (Signmask x)) (Signmask x)) // negate x if negative
+ (SUB <types.UInt32> (XOR <types.UInt32> y (Signmask y)) (Signmask y)))) // negate y if negative
(Signmask x)) (Signmask x))
-(Mod32u x y) -> (Select1 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y))
+(Mod32u x y) -> (Select1 <types.UInt32> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y))
(Mod16 x y) -> (Mod32 (SignExt16to32 x) (SignExt16to32 y))
(Mod16u x y) -> (Mod32u (ZeroExt16to32 x) (ZeroExt16to32 y))
(Mod8 x y) -> (Mod32 (SignExt8to32 x) (SignExt8to32 y))
// boolean ops -- booleans are represented with 0=false, 1=true
(AndB x y) -> (AND x y)
(OrB x y) -> (OR x y)
-(EqB x y) -> (XORconst [1] (XOR <fe.TypeBool()> x y))
+(EqB x y) -> (XORconst [1] (XOR <types.Bool> x y))
(NeqB x y) -> (XOR x y)
(Not x) -> (XORconst [1] x)
(Rsh32x64 x (Const64 [c])) && uint64(c) < 32 -> (SRAconst x [c])
(Rsh32Ux64 x (Const64 [c])) && uint64(c) < 32 -> (SRLconst x [c])
(Lsh16x64 x (Const64 [c])) && uint64(c) < 16 -> (SLLconst x [c])
-(Rsh16x64 x (Const64 [c])) && uint64(c) < 16 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16])
-(Rsh16Ux64 x (Const64 [c])) && uint64(c) < 16 -> (SRLconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16])
+(Rsh16x64 x (Const64 [c])) && uint64(c) < 16 -> (SRAconst (SLLconst <types.UInt32> x [16]) [c+16])
+(Rsh16Ux64 x (Const64 [c])) && uint64(c) < 16 -> (SRLconst (SLLconst <types.UInt32> x [16]) [c+16])
(Lsh8x64 x (Const64 [c])) && uint64(c) < 8 -> (SLLconst x [c])
-(Rsh8x64 x (Const64 [c])) && uint64(c) < 8 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24])
-(Rsh8Ux64 x (Const64 [c])) && uint64(c) < 8 -> (SRLconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24])
+(Rsh8x64 x (Const64 [c])) && uint64(c) < 8 -> (SRAconst (SLLconst <types.UInt32> x [24]) [c+24])
+(Rsh8Ux64 x (Const64 [c])) && uint64(c) < 8 -> (SRLconst (SLLconst <types.UInt32> x [24]) [c+24])
// large constant shifts
(Lsh32x64 _ (Const64 [c])) && uint64(c) >= 32 -> (Const32 [0])
// large constant signed right shift, we leave the sign bit
(Rsh32x64 x (Const64 [c])) && uint64(c) >= 32 -> (SRAconst x [31])
-(Rsh16x64 x (Const64 [c])) && uint64(c) >= 16 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [31])
-(Rsh8x64 x (Const64 [c])) && uint64(c) >= 8 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [31])
+(Rsh16x64 x (Const64 [c])) && uint64(c) >= 16 -> (SRAconst (SLLconst <types.UInt32> x [16]) [31])
+(Rsh8x64 x (Const64 [c])) && uint64(c) >= 8 -> (SRAconst (SLLconst <types.UInt32> x [24]) [31])
// constants
(Const8 [val]) -> (MOVWconst [val])
(SignExt16to32 x) -> (MOVHreg x)
(Signmask x) -> (SRAconst x [31])
-(Zeromask x) -> (SRAconst (RSBshiftRL <fe.TypeInt32()> x x [1]) [31]) // sign bit of uint32(x)>>1 - x
+(Zeromask x) -> (SRAconst (RSBshiftRL <types.Int32> x x [1]) [31]) // sign bit of uint32(x)>>1 - x
(Slicemask <t> x) -> (SRAconst (RSBconst <t> [0] x) [31])
// float <-> int conversion
(Hmul64 x y) -> (MULH x y)
(Hmul64u x y) -> (UMULH x y)
-(Hmul32 x y) -> (SRAconst (MULL <fe.TypeInt64()> x y) [32])
-(Hmul32u x y) -> (SRAconst (UMULL <fe.TypeUInt64()> x y) [32])
+(Hmul32 x y) -> (SRAconst (MULL <types.Int64> x y) [32])
+(Hmul32u x y) -> (SRAconst (UMULL <types.UInt64> x y) [32])
(Div64 x y) -> (DIV x y)
(Div64u x y) -> (UDIV x y)
(Ctz64 <t> x) -> (CLZ (RBIT <t> x))
(Ctz32 <t> x) -> (CLZW (RBITW <t> x))
-(BitLen64 x) -> (SUB (MOVDconst [64]) (CLZ <fe.TypeInt()> x))
+(BitLen64 x) -> (SUB (MOVDconst [64]) (CLZ <types.Int> x))
(Bswap64 x) -> (REV x)
(Bswap32 x) -> (REVW x)
(BitRev64 x) -> (RBIT x)
(BitRev32 x) -> (RBITW x)
-(BitRev16 x) -> (SRLconst [48] (RBIT <fe.TypeUInt64()> x))
-(BitRev8 x) -> (SRLconst [56] (RBIT <fe.TypeUInt64()> x))
+(BitRev16 x) -> (SRLconst [48] (RBIT <types.UInt64> x))
+(BitRev8 x) -> (SRLconst [56] (RBIT <types.UInt64> x))
// boolean ops -- booleans are represented with 0=false, 1=true
(AndB x y) -> (AND x y)
(OrB x y) -> (OR x y)
-(EqB x y) -> (XOR (MOVDconst [1]) (XOR <fe.TypeBool()> x y))
+(EqB x y) -> (XOR (MOVDconst [1]) (XOR <types.Bool> x y))
(NeqB x y) -> (XOR x y)
(Not x) -> (XOR (MOVDconst [1]) x)
(Add64F x y) -> (ADDD x y)
(Select0 (Add32carry <t> x y)) -> (ADD <t.FieldType(0)> x y)
-(Select1 (Add32carry <t> x y)) -> (SGTU <fe.TypeBool()> x (ADD <t.FieldType(0)> x y))
+(Select1 (Add32carry <t> x y)) -> (SGTU <types.Bool> x (ADD <t.FieldType(0)> x y))
(Add32withcarry <t> x y c) -> (ADD c (ADD <t> x y))
(SubPtr x y) -> (SUB x y)
(Sub64F x y) -> (SUBD x y)
(Select0 (Sub32carry <t> x y)) -> (SUB <t.FieldType(0)> x y)
-(Select1 (Sub32carry <t> x y)) -> (SGTU <fe.TypeBool()> (SUB <t.FieldType(0)> x y) x)
+(Select1 (Sub32carry <t> x y)) -> (SGTU <types.Bool> (SUB <t.FieldType(0)> x y) x)
(Sub32withcarry <t> x y c) -> (SUB (SUB <t> x y) c)
(Mul32 x y) -> (MUL x y)
(Rsh32x64 x (Const64 [c])) && uint32(c) < 32 -> (SRAconst x [c])
(Rsh32Ux64 x (Const64 [c])) && uint32(c) < 32 -> (SRLconst x [c])
(Lsh16x64 x (Const64 [c])) && uint32(c) < 16 -> (SLLconst x [c])
-(Rsh16x64 x (Const64 [c])) && uint32(c) < 16 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16])
-(Rsh16Ux64 x (Const64 [c])) && uint32(c) < 16 -> (SRLconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16])
+(Rsh16x64 x (Const64 [c])) && uint32(c) < 16 -> (SRAconst (SLLconst <types.UInt32> x [16]) [c+16])
+(Rsh16Ux64 x (Const64 [c])) && uint32(c) < 16 -> (SRLconst (SLLconst <types.UInt32> x [16]) [c+16])
(Lsh8x64 x (Const64 [c])) && uint32(c) < 8 -> (SLLconst x [c])
-(Rsh8x64 x (Const64 [c])) && uint32(c) < 8 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24])
-(Rsh8Ux64 x (Const64 [c])) && uint32(c) < 8 -> (SRLconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24])
+(Rsh8x64 x (Const64 [c])) && uint32(c) < 8 -> (SRAconst (SLLconst <types.UInt32> x [24]) [c+24])
+(Rsh8Ux64 x (Const64 [c])) && uint32(c) < 8 -> (SRLconst (SLLconst <types.UInt32> x [24]) [c+24])
// large constant shifts
(Lsh32x64 _ (Const64 [c])) && uint32(c) >= 32 -> (MOVWconst [0])
// large constant signed right shift, we leave the sign bit
(Rsh32x64 x (Const64 [c])) && uint32(c) >= 32 -> (SRAconst x [31])
-(Rsh16x64 x (Const64 [c])) && uint32(c) >= 16 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [31])
-(Rsh8x64 x (Const64 [c])) && uint32(c) >= 8 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [31])
+(Rsh16x64 x (Const64 [c])) && uint32(c) >= 16 -> (SRAconst (SLLconst <types.UInt32> x [16]) [31])
+(Rsh8x64 x (Const64 [c])) && uint32(c) >= 8 -> (SRAconst (SLLconst <types.UInt32> x [24]) [31])
// shifts
// hardware instruction uses only the low 5 bits of the shift
(Rsh8Ux16 <t> x y) -> (CMOVZ (SRL <t> (ZeroExt8to32 x) (ZeroExt16to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt16to32 y)))
(Rsh8Ux8 <t> x y) -> (CMOVZ (SRL <t> (ZeroExt8to32 x) (ZeroExt8to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt8to32 y)))
-(Rsh32x32 x y) -> (SRA x ( CMOVZ <fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y)))
-(Rsh32x16 x y) -> (SRA x ( CMOVZ <fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y))))
-(Rsh32x8 x y) -> (SRA x ( CMOVZ <fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y))))
+(Rsh32x32 x y) -> (SRA x ( CMOVZ <types.UInt32> y (MOVWconst [-1]) (SGTUconst [32] y)))
+(Rsh32x16 x y) -> (SRA x ( CMOVZ <types.UInt32> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y))))
+(Rsh32x8 x y) -> (SRA x ( CMOVZ <types.UInt32> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y))))
-(Rsh16x32 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y)))
-(Rsh16x16 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y))))
-(Rsh16x8 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y))))
+(Rsh16x32 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> y (MOVWconst [-1]) (SGTUconst [32] y)))
+(Rsh16x16 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y))))
+(Rsh16x8 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y))))
-(Rsh8x32 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y)))
-(Rsh8x16 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y))))
-(Rsh8x8 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y))))
+(Rsh8x32 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> y (MOVWconst [-1]) (SGTUconst [32] y)))
+(Rsh8x16 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y))))
+(Rsh8x8 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y))))
// unary ops
(Neg32 x) -> (NEG x)
// boolean ops -- booleans are represented with 0=false, 1=true
(AndB x y) -> (AND x y)
(OrB x y) -> (OR x y)
-(EqB x y) -> (XORconst [1] (XOR <fe.TypeBool()> x y))
+(EqB x y) -> (XORconst [1] (XOR <types.Bool> x y))
(NeqB x y) -> (XOR x y)
(Not x) -> (XORconst [1] x)
// AtomicOr8(ptr,val) -> LoweredAtomicOr(ptr&^3,uint32(val) << ((ptr & 3) * 8))
(AtomicOr8 ptr val mem) && !config.BigEndian ->
- (LoweredAtomicOr (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr)
- (SLL <fe.TypeUInt32()> (ZeroExt8to32 val)
- (SLLconst <fe.TypeUInt32()> [3]
- (ANDconst <fe.TypeUInt32()> [3] ptr))) mem)
+ (LoweredAtomicOr (AND <types.UInt32.PtrTo()> (MOVWconst [^3]) ptr)
+ (SLL <types.UInt32> (ZeroExt8to32 val)
+ (SLLconst <types.UInt32> [3]
+ (ANDconst <types.UInt32> [3] ptr))) mem)
// AtomicAnd8(ptr,val) -> LoweredAtomicAnd(ptr&^3,(uint32(val) << ((ptr & 3) * 8)) | ^(uint32(0xFF) << ((ptr & 3) * 8))))
(AtomicAnd8 ptr val mem) && !config.BigEndian ->
- (LoweredAtomicAnd (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr)
- (OR <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> (ZeroExt8to32 val)
- (SLLconst <fe.TypeUInt32()> [3]
- (ANDconst <fe.TypeUInt32()> [3] ptr)))
- (NORconst [0] <fe.TypeUInt32()> (SLL <fe.TypeUInt32()>
- (MOVWconst [0xff]) (SLLconst <fe.TypeUInt32()> [3]
- (ANDconst <fe.TypeUInt32()> [3]
- (XORconst <fe.TypeUInt32()> [3] ptr)))))) mem)
+ (LoweredAtomicAnd (AND <types.UInt32.PtrTo()> (MOVWconst [^3]) ptr)
+ (OR <types.UInt32> (SLL <types.UInt32> (ZeroExt8to32 val)
+ (SLLconst <types.UInt32> [3]
+ (ANDconst <types.UInt32> [3] ptr)))
+ (NORconst [0] <types.UInt32> (SLL <types.UInt32>
+ (MOVWconst [0xff]) (SLLconst <types.UInt32> [3]
+ (ANDconst <types.UInt32> [3]
+ (XORconst <types.UInt32> [3] ptr)))))) mem)
// AtomicOr8(ptr,val) -> LoweredAtomicOr(ptr&^3,uint32(val) << (((ptr^3) & 3) * 8))
(AtomicOr8 ptr val mem) && config.BigEndian ->
- (LoweredAtomicOr (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr)
- (SLL <fe.TypeUInt32()> (ZeroExt8to32 val)
- (SLLconst <fe.TypeUInt32()> [3]
- (ANDconst <fe.TypeUInt32()> [3]
- (XORconst <fe.TypeUInt32()> [3] ptr)))) mem)
+ (LoweredAtomicOr (AND <types.UInt32.PtrTo()> (MOVWconst [^3]) ptr)
+ (SLL <types.UInt32> (ZeroExt8to32 val)
+ (SLLconst <types.UInt32> [3]
+ (ANDconst <types.UInt32> [3]
+ (XORconst <types.UInt32> [3] ptr)))) mem)
// AtomicAnd8(ptr,val) -> LoweredAtomicAnd(ptr&^3,(uint32(val) << (((ptr^3) & 3) * 8)) | ^(uint32(0xFF) << (((ptr^3) & 3) * 8))))
(AtomicAnd8 ptr val mem) && config.BigEndian ->
- (LoweredAtomicAnd (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr)
- (OR <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> (ZeroExt8to32 val)
- (SLLconst <fe.TypeUInt32()> [3]
- (ANDconst <fe.TypeUInt32()> [3]
- (XORconst <fe.TypeUInt32()> [3] ptr))))
- (NORconst [0] <fe.TypeUInt32()> (SLL <fe.TypeUInt32()>
- (MOVWconst [0xff]) (SLLconst <fe.TypeUInt32()> [3]
- (ANDconst <fe.TypeUInt32()> [3]
- (XORconst <fe.TypeUInt32()> [3] ptr)))))) mem)
+ (LoweredAtomicAnd (AND <types.UInt32.PtrTo()> (MOVWconst [^3]) ptr)
+ (OR <types.UInt32> (SLL <types.UInt32> (ZeroExt8to32 val)
+ (SLLconst <types.UInt32> [3]
+ (ANDconst <types.UInt32> [3]
+ (XORconst <types.UInt32> [3] ptr))))
+ (NORconst [0] <types.UInt32> (SLL <types.UInt32>
+ (MOVWconst [0xff]) (SLLconst <types.UInt32> [3]
+ (ANDconst <types.UInt32> [3]
+ (XORconst <types.UInt32> [3] ptr)))))) mem)
// checks
(Hmul64 x y) -> (Select0 (MULV x y))
(Hmul64u x y) -> (Select0 (MULVU x y))
-(Hmul32 x y) -> (SRAVconst (Select1 <fe.TypeInt64()> (MULV (SignExt32to64 x) (SignExt32to64 y))) [32])
-(Hmul32u x y) -> (SRLVconst (Select1 <fe.TypeUInt64()> (MULVU (ZeroExt32to64 x) (ZeroExt32to64 y))) [32])
+(Hmul32 x y) -> (SRAVconst (Select1 <types.Int64> (MULV (SignExt32to64 x) (SignExt32to64 y))) [32])
+(Hmul32u x y) -> (SRLVconst (Select1 <types.UInt64> (MULVU (ZeroExt32to64 x) (ZeroExt32to64 y))) [32])
(Div64 x y) -> (Select1 (DIVV x y))
(Div64u x y) -> (Select1 (DIVVU x y))
// shifts
// hardware instruction uses only the low 6 bits of the shift
// we compare to 64 to ensure Go semantics for large shifts
-(Lsh64x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y))
-(Lsh64x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
-(Lsh64x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
-(Lsh64x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
-
-(Lsh32x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y))
-(Lsh32x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
-(Lsh32x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
-(Lsh32x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
-
-(Lsh16x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y))
-(Lsh16x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
-(Lsh16x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
-(Lsh16x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
-
-(Lsh8x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y))
-(Lsh8x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
-(Lsh8x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
-(Lsh8x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
-
-(Rsh64Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> x y))
-(Rsh64Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> x (ZeroExt32to64 y)))
-(Rsh64Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> x (ZeroExt16to64 y)))
-(Rsh64Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> x (ZeroExt8to64 y)))
-
-(Rsh32Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt32to64 x) y))
-(Rsh32Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt32to64 y)))
-(Rsh32Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt16to64 y)))
-(Rsh32Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt8to64 y)))
-
-(Rsh16Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt16to64 x) y))
-(Rsh16Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt32to64 y)))
-(Rsh16Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt16to64 y)))
-(Rsh16Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt8to64 y)))
-
-(Rsh8Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt8to64 x) y))
-(Rsh8Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt32to64 y)))
-(Rsh8Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt16to64 y)))
-(Rsh8Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt8to64 y)))
-
-(Rsh64x64 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y))
-(Rsh64x32 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y)))
-(Rsh64x16 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y)))
-(Rsh64x8 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y)))
-
-(Rsh32x64 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y))
-(Rsh32x32 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y)))
-(Rsh32x16 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y)))
-(Rsh32x8 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y)))
-
-(Rsh16x64 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y))
-(Rsh16x32 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y)))
-(Rsh16x16 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y)))
-(Rsh16x8 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y)))
-
-(Rsh8x64 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y))
-(Rsh8x32 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y)))
-(Rsh8x16 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y)))
-(Rsh8x8 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y)))
+(Lsh64x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SLLV <t> x y))
+(Lsh64x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
+(Lsh64x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
+(Lsh64x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
+
+(Lsh32x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SLLV <t> x y))
+(Lsh32x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
+(Lsh32x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
+(Lsh32x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
+
+(Lsh16x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SLLV <t> x y))
+(Lsh16x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
+(Lsh16x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
+(Lsh16x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
+
+(Lsh8x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SLLV <t> x y))
+(Lsh8x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
+(Lsh8x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
+(Lsh8x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
+
+(Rsh64Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SRLV <t> x y))
+(Rsh64Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SRLV <t> x (ZeroExt32to64 y)))
+(Rsh64Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SRLV <t> x (ZeroExt16to64 y)))
+(Rsh64Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SRLV <t> x (ZeroExt8to64 y)))
+
+(Rsh32Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SRLV <t> (ZeroExt32to64 x) y))
+(Rsh32Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt32to64 y)))
+(Rsh32Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt16to64 y)))
+(Rsh32Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt8to64 y)))
+
+(Rsh16Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SRLV <t> (ZeroExt16to64 x) y))
+(Rsh16Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt32to64 y)))
+(Rsh16Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt16to64 y)))
+(Rsh16Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt8to64 y)))
+
+(Rsh8Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SRLV <t> (ZeroExt8to64 x) y))
+(Rsh8Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt32to64 y)))
+(Rsh8Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt16to64 y)))
+(Rsh8Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt8to64 y)))
+
+(Rsh64x64 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU y (Const64 <types.UInt64> [63]))) y))
+(Rsh64x32 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt32to64 y)))
+(Rsh64x16 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt16to64 y)))
+(Rsh64x8 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt8to64 y)))
+
+(Rsh32x64 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <types.UInt64> [63]))) y))
+(Rsh32x32 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt32to64 y)))
+(Rsh32x16 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt16to64 y)))
+(Rsh32x8 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt8to64 y)))
+
+(Rsh16x64 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <types.UInt64> [63]))) y))
+(Rsh16x32 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt32to64 y)))
+(Rsh16x16 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt16to64 y)))
+(Rsh16x8 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt8to64 y)))
+
+(Rsh8x64 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <types.UInt64> [63]))) y))
+(Rsh8x32 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt32to64 y)))
+(Rsh8x16 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt16to64 y)))
+(Rsh8x8 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt8to64 y)))
// unary ops
(Neg64 x) -> (NEGV x)
// boolean ops -- booleans are represented with 0=false, 1=true
(AndB x y) -> (AND x y)
(OrB x y) -> (OR x y)
-(EqB x y) -> (XOR (MOVVconst [1]) (XOR <fe.TypeBool()> x y))
+(EqB x y) -> (XOR (MOVVconst [1]) (XOR <types.Bool> x y))
(NeqB x y) -> (XOR x y)
(Not x) -> (XORconst [1] x)
(Rsh8x32 x (MOVDconst [c])) && uint32(c) < 8 -> (SRAWconst (SignExt8to32 x) [c])
(Rsh8Ux32 x (MOVDconst [c])) && uint32(c) < 8 -> (SRWconst (ZeroExt8to32 x) [c])
-(Rsh64x64 x y) -> (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
-(Rsh64Ux64 x y) -> (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
-(Lsh64x64 x y) -> (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
+(Rsh64x64 x y) -> (SRAD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
+(Rsh64Ux64 x y) -> (SRD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
+(Lsh64x64 x y) -> (SLD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
-(Rsh32x64 x y) -> (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
-(Rsh32Ux64 x y) -> (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
-(Lsh32x64 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
+(Rsh32x64 x y) -> (SRAW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
+(Rsh32Ux64 x y) -> (SRW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
+(Lsh32x64 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
-(Rsh16x64 x y) -> (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
-(Rsh16Ux64 x y) -> (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
-(Lsh16x64 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
+(Rsh16x64 x y) -> (SRAW (SignExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
+(Rsh16Ux64 x y) -> (SRW (ZeroExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
+(Lsh16x64 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
-(Rsh8x64 x y) -> (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
-(Rsh8Ux64 x y) -> (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
-(Lsh8x64 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
+(Rsh8x64 x y) -> (SRAW (SignExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
+(Rsh8Ux64 x y) -> (SRW (ZeroExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
+(Lsh8x64 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
-(Rsh64x32 x y) -> (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
-(Rsh64Ux32 x y) -> (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
-(Lsh64x32 x y) -> (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
+(Rsh64x32 x y) -> (SRAD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
+(Rsh64Ux32 x y) -> (SRD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
+(Lsh64x32 x y) -> (SLD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
-(Rsh32x32 x y) -> (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
-(Rsh32Ux32 x y) -> (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
-(Lsh32x32 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
+(Rsh32x32 x y) -> (SRAW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
+(Rsh32Ux32 x y) -> (SRW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
+(Lsh32x32 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
-(Rsh16x32 x y) -> (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
-(Rsh16Ux32 x y) -> (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
-(Lsh16x32 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
+(Rsh16x32 x y) -> (SRAW (SignExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
+(Rsh16Ux32 x y) -> (SRW (ZeroExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
+(Lsh16x32 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
-(Rsh8x32 x y) -> (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
-(Rsh8Ux32 x y) -> (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
-(Lsh8x32 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
+(Rsh8x32 x y) -> (SRAW (SignExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
+(Rsh8Ux32 x y) -> (SRW (ZeroExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
+(Lsh8x32 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
-(Rsh64x16 x y) -> (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
-(Rsh64Ux16 x y) -> (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
-(Lsh64x16 x y) -> (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
+(Rsh64x16 x y) -> (SRAD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
+(Rsh64Ux16 x y) -> (SRD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
+(Lsh64x16 x y) -> (SLD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
-(Rsh32x16 x y) -> (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
-(Rsh32Ux16 x y) -> (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
-(Lsh32x16 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
+(Rsh32x16 x y) -> (SRAW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
+(Rsh32Ux16 x y) -> (SRW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
+(Lsh32x16 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
-(Rsh16x16 x y) -> (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
-(Rsh16Ux16 x y) -> (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
-(Lsh16x16 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
+(Rsh16x16 x y) -> (SRAW (SignExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
+(Rsh16Ux16 x y) -> (SRW (ZeroExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
+(Lsh16x16 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
-(Rsh8x16 x y) -> (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
-(Rsh8Ux16 x y) -> (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
-(Lsh8x16 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
+(Rsh8x16 x y) -> (SRAW (SignExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
+(Rsh8Ux16 x y) -> (SRW (ZeroExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
+(Lsh8x16 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
-(Rsh64x8 x y) -> (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
-(Rsh64Ux8 x y) -> (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
-(Lsh64x8 x y) -> (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
+(Rsh64x8 x y) -> (SRAD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
+(Rsh64Ux8 x y) -> (SRD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
+(Lsh64x8 x y) -> (SLD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
-(Rsh32x8 x y) -> (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
-(Rsh32Ux8 x y) -> (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
-(Lsh32x8 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
+(Rsh32x8 x y) -> (SRAW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
+(Rsh32Ux8 x y) -> (SRW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
+(Lsh32x8 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
-(Rsh16x8 x y) -> (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
-(Rsh16Ux8 x y) -> (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
-(Lsh16x8 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
+(Rsh16x8 x y) -> (SRAW (SignExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
+(Rsh16Ux8 x y) -> (SRW (ZeroExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
+(Lsh16x8 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
-(Rsh8x8 x y) -> (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
-(Rsh8Ux8 x y) -> (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
-(Lsh8x8 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
+(Rsh8x8 x y) -> (SRAW (SignExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
+(Rsh8Ux8 x y) -> (SRW (ZeroExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
+(Lsh8x8 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
// Cleaning up shift ops when input is masked
(MaskIfNotCarry (ADDconstForCarry [c] (ANDconst [d] _))) && c < 0 && d > 0 && c + d < 0 -> (MOVDconst [-1])
(Addr {sym} base) -> (MOVDaddr {sym} base)
// (Addr {sym} base) -> (ADDconst {sym} base)
-(OffPtr [off] ptr) -> (ADD (MOVDconst <fe.TypeInt64()> [off]) ptr)
+(OffPtr [off] ptr) -> (ADD (MOVDconst <types.Int64> [off]) ptr)
(And64 x y) -> (AND x y)
(And32 x y) -> (AND x y)
(If (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) cmp) yes no) -> (GTF cmp yes no)
(If (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) cmp) yes no) -> (GEF cmp yes no)
-(If cond yes no) -> (NE (CMPWconst [0] (MOVBZreg <fe.TypeBool()> cond)) yes no)
+(If cond yes no) -> (NE (CMPWconst [0] (MOVBZreg <types.Bool> cond)) yes no)
// ***************************
// Above: lowering rules
(Load <t> ptr mem) && t.IsComplex() && t.Size() == 8 ->
(ComplexMake
- (Load <fe.TypeFloat32()> ptr mem)
- (Load <fe.TypeFloat32()>
- (OffPtr <fe.TypeFloat32().PtrTo()> [4] ptr)
+ (Load <types.Float32> ptr mem)
+ (Load <types.Float32>
+ (OffPtr <types.Float32.PtrTo()> [4] ptr)
mem)
)
(Store {t} dst (ComplexMake real imag) mem) && t.(Type).Size() == 8 ->
- (Store {fe.TypeFloat32()}
- (OffPtr <fe.TypeFloat32().PtrTo()> [4] dst)
+ (Store {types.Float32}
+ (OffPtr <types.Float32.PtrTo()> [4] dst)
imag
- (Store {fe.TypeFloat32()} dst real mem))
+ (Store {types.Float32} dst real mem))
(Load <t> ptr mem) && t.IsComplex() && t.Size() == 16 ->
(ComplexMake
- (Load <fe.TypeFloat64()> ptr mem)
- (Load <fe.TypeFloat64()>
- (OffPtr <fe.TypeFloat64().PtrTo()> [8] ptr)
+ (Load <types.Float64> ptr mem)
+ (Load <types.Float64>
+ (OffPtr <types.Float64.PtrTo()> [8] ptr)
mem)
)
(Store {t} dst (ComplexMake real imag) mem) && t.(Type).Size() == 16 ->
- (Store {fe.TypeFloat64()}
- (OffPtr <fe.TypeFloat64().PtrTo()> [8] dst)
+ (Store {types.Float64}
+ (OffPtr <types.Float64.PtrTo()> [8] dst)
imag
- (Store {fe.TypeFloat64()} dst real mem))
+ (Store {types.Float64} dst real mem))
// string ops
(StringPtr (StringMake ptr _)) -> ptr
(Load <t> ptr mem) && t.IsString() ->
(StringMake
- (Load <fe.TypeBytePtr()> ptr mem)
- (Load <fe.TypeInt()>
- (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] ptr)
+ (Load <types.BytePtr> ptr mem)
+ (Load <types.Int>
+ (OffPtr <types.Int.PtrTo()> [config.PtrSize] ptr)
mem))
(Store dst (StringMake ptr len) mem) ->
- (Store {fe.TypeInt()}
- (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] dst)
+ (Store {types.Int}
+ (OffPtr <types.Int.PtrTo()> [config.PtrSize] dst)
len
- (Store {fe.TypeBytePtr()} dst ptr mem))
+ (Store {types.BytePtr} dst ptr mem))
// slice ops
(SlicePtr (SliceMake ptr _ _ )) -> ptr
(Load <t> ptr mem) && t.IsSlice() ->
(SliceMake
(Load <t.ElemType().PtrTo()> ptr mem)
- (Load <fe.TypeInt()>
- (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] ptr)
+ (Load <types.Int>
+ (OffPtr <types.Int.PtrTo()> [config.PtrSize] ptr)
mem)
- (Load <fe.TypeInt()>
- (OffPtr <fe.TypeInt().PtrTo()> [2*config.PtrSize] ptr)
+ (Load <types.Int>
+ (OffPtr <types.Int.PtrTo()> [2*config.PtrSize] ptr)
mem))
(Store dst (SliceMake ptr len cap) mem) ->
- (Store {fe.TypeInt()}
- (OffPtr <fe.TypeInt().PtrTo()> [2*config.PtrSize] dst)
+ (Store {types.Int}
+ (OffPtr <types.Int.PtrTo()> [2*config.PtrSize] dst)
cap
- (Store {fe.TypeInt()}
- (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] dst)
+ (Store {types.Int}
+ (OffPtr <types.Int.PtrTo()> [config.PtrSize] dst)
len
- (Store {fe.TypeBytePtr()} dst ptr mem)))
+ (Store {types.BytePtr} dst ptr mem)))
// interface ops
(ITab (IMake itab _)) -> itab
(Load <t> ptr mem) && t.IsInterface() ->
(IMake
- (Load <fe.TypeBytePtr()> ptr mem)
- (Load <fe.TypeBytePtr()>
- (OffPtr <fe.TypeBytePtr().PtrTo()> [config.PtrSize] ptr)
+ (Load <types.BytePtr> ptr mem)
+ (Load <types.BytePtr>
+ (OffPtr <types.BytePtr.PtrTo()> [config.PtrSize] ptr)
mem))
(Store dst (IMake itab data) mem) ->
- (Store {fe.TypeBytePtr()}
- (OffPtr <fe.TypeBytePtr().PtrTo()> [config.PtrSize] dst)
+ (Store {types.BytePtr}
+ (OffPtr <types.BytePtr.PtrTo()> [config.PtrSize] dst)
data
- (Store {fe.TypeUintptr()} dst itab mem))
+ (Store {types.Uintptr} dst itab mem))
(Load <t> ptr mem) && is64BitInt(t) && !config.BigEndian && t.IsSigned() ->
(Int64Make
- (Load <fe.TypeInt32()> (OffPtr <fe.TypeInt32().PtrTo()> [4] ptr) mem)
- (Load <fe.TypeUInt32()> ptr mem))
+ (Load <types.Int32> (OffPtr <types.Int32.PtrTo()> [4] ptr) mem)
+ (Load <types.UInt32> ptr mem))
(Load <t> ptr mem) && is64BitInt(t) && !config.BigEndian && !t.IsSigned() ->
(Int64Make
- (Load <fe.TypeUInt32()> (OffPtr <fe.TypeUInt32().PtrTo()> [4] ptr) mem)
- (Load <fe.TypeUInt32()> ptr mem))
+ (Load <types.UInt32> (OffPtr <types.UInt32.PtrTo()> [4] ptr) mem)
+ (Load <types.UInt32> ptr mem))
(Load <t> ptr mem) && is64BitInt(t) && config.BigEndian && t.IsSigned() ->
(Int64Make
- (Load <fe.TypeInt32()> ptr mem)
- (Load <fe.TypeUInt32()> (OffPtr <fe.TypeUInt32().PtrTo()> [4] ptr) mem))
+ (Load <types.Int32> ptr mem)
+ (Load <types.UInt32> (OffPtr <types.UInt32.PtrTo()> [4] ptr) mem))
(Load <t> ptr mem) && is64BitInt(t) && config.BigEndian && !t.IsSigned() ->
(Int64Make
- (Load <fe.TypeUInt32()> ptr mem)
- (Load <fe.TypeUInt32()> (OffPtr <fe.TypeUInt32().PtrTo()> [4] ptr) mem))
+ (Load <types.UInt32> ptr mem)
+ (Load <types.UInt32> (OffPtr <types.UInt32.PtrTo()> [4] ptr) mem))
(Store {t} dst (Int64Make hi lo) mem) && t.(Type).Size() == 8 && !config.BigEndian ->
(Store {hi.Type}
(Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() ->
(Int64Make
- (Arg <fe.TypeInt32()> {n} [off+4])
- (Arg <fe.TypeUInt32()> {n} [off]))
+ (Arg <types.Int32> {n} [off+4])
+ (Arg <types.UInt32> {n} [off]))
(Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() ->
(Int64Make
- (Arg <fe.TypeUInt32()> {n} [off+4])
- (Arg <fe.TypeUInt32()> {n} [off]))
+ (Arg <types.UInt32> {n} [off+4])
+ (Arg <types.UInt32> {n} [off]))
(Arg {n} [off]) && is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() ->
(Int64Make
- (Arg <fe.TypeInt32()> {n} [off])
- (Arg <fe.TypeUInt32()> {n} [off+4]))
+ (Arg <types.Int32> {n} [off])
+ (Arg <types.UInt32> {n} [off+4]))
(Arg {n} [off]) && is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() ->
(Int64Make
- (Arg <fe.TypeUInt32()> {n} [off])
- (Arg <fe.TypeUInt32()> {n} [off+4]))
+ (Arg <types.UInt32> {n} [off])
+ (Arg <types.UInt32> {n} [off+4]))
(Add64 x y) ->
(Int64Make
- (Add32withcarry <fe.TypeInt32()>
+ (Add32withcarry <types.Int32>
(Int64Hi x)
(Int64Hi y)
(Select1 <TypeFlags> (Add32carry (Int64Lo x) (Int64Lo y))))
- (Select0 <fe.TypeUInt32()> (Add32carry (Int64Lo x) (Int64Lo y))))
+ (Select0 <types.UInt32> (Add32carry (Int64Lo x) (Int64Lo y))))
(Sub64 x y) ->
(Int64Make
- (Sub32withcarry <fe.TypeInt32()>
+ (Sub32withcarry <types.Int32>
(Int64Hi x)
(Int64Hi y)
(Select1 <TypeFlags> (Sub32carry (Int64Lo x) (Int64Lo y))))
- (Select0 <fe.TypeUInt32()> (Sub32carry (Int64Lo x) (Int64Lo y))))
+ (Select0 <types.UInt32> (Sub32carry (Int64Lo x) (Int64Lo y))))
(Mul64 x y) ->
(Int64Make
- (Add32 <fe.TypeUInt32()>
- (Mul32 <fe.TypeUInt32()> (Int64Lo x) (Int64Hi y))
- (Add32 <fe.TypeUInt32()>
- (Mul32 <fe.TypeUInt32()> (Int64Hi x) (Int64Lo y))
- (Select0 <fe.TypeUInt32()> (Mul32uhilo (Int64Lo x) (Int64Lo y)))))
- (Select1 <fe.TypeUInt32()> (Mul32uhilo (Int64Lo x) (Int64Lo y))))
+ (Add32 <types.UInt32>
+ (Mul32 <types.UInt32> (Int64Lo x) (Int64Hi y))
+ (Add32 <types.UInt32>
+ (Mul32 <types.UInt32> (Int64Hi x) (Int64Lo y))
+ (Select0 <types.UInt32> (Mul32uhilo (Int64Lo x) (Int64Lo y)))))
+ (Select1 <types.UInt32> (Mul32uhilo (Int64Lo x) (Int64Lo y))))
(And64 x y) ->
(Int64Make
- (And32 <fe.TypeUInt32()> (Int64Hi x) (Int64Hi y))
- (And32 <fe.TypeUInt32()> (Int64Lo x) (Int64Lo y)))
+ (And32 <types.UInt32> (Int64Hi x) (Int64Hi y))
+ (And32 <types.UInt32> (Int64Lo x) (Int64Lo y)))
(Or64 x y) ->
(Int64Make
- (Or32 <fe.TypeUInt32()> (Int64Hi x) (Int64Hi y))
- (Or32 <fe.TypeUInt32()> (Int64Lo x) (Int64Lo y)))
+ (Or32 <types.UInt32> (Int64Hi x) (Int64Hi y))
+ (Or32 <types.UInt32> (Int64Lo x) (Int64Lo y)))
(Xor64 x y) ->
(Int64Make
- (Xor32 <fe.TypeUInt32()> (Int64Hi x) (Int64Hi y))
- (Xor32 <fe.TypeUInt32()> (Int64Lo x) (Int64Lo y)))
+ (Xor32 <types.UInt32> (Int64Hi x) (Int64Hi y))
+ (Xor32 <types.UInt32> (Int64Lo x) (Int64Lo y)))
(Neg64 <t> x) -> (Sub64 (Const64 <t> [0]) x)
(Com64 x) ->
(Int64Make
- (Com32 <fe.TypeUInt32()> (Int64Hi x))
- (Com32 <fe.TypeUInt32()> (Int64Lo x)))
+ (Com32 <types.UInt32> (Int64Hi x))
+ (Com32 <types.UInt32> (Int64Lo x)))
(Ctz64 x) ->
- (Add32 <fe.TypeUInt32()>
- (Ctz32 <fe.TypeUInt32()> (Int64Lo x))
- (And32 <fe.TypeUInt32()>
- (Com32 <fe.TypeUInt32()> (Zeromask (Int64Lo x)))
- (Ctz32 <fe.TypeUInt32()> (Int64Hi x))))
+ (Add32 <types.UInt32>
+ (Ctz32 <types.UInt32> (Int64Lo x))
+ (And32 <types.UInt32>
+ (Com32 <types.UInt32> (Zeromask (Int64Lo x)))
+ (Ctz32 <types.UInt32> (Int64Hi x))))
(BitLen64 x) ->
- (Add32 <fe.TypeInt()>
- (BitLen32 <fe.TypeInt()> (Int64Hi x))
- (BitLen32 <fe.TypeInt()>
- (Or32 <fe.TypeUInt32()>
+ (Add32 <types.Int>
+ (BitLen32 <types.Int> (Int64Hi x))
+ (BitLen32 <types.Int>
+ (Or32 <types.UInt32>
(Int64Lo x)
(Zeromask (Int64Hi x)))))
(Bswap64 x) ->
(Int64Make
- (Bswap32 <fe.TypeUInt32()> (Int64Lo x))
- (Bswap32 <fe.TypeUInt32()> (Int64Hi x)))
+ (Bswap32 <types.UInt32> (Int64Lo x))
+ (Bswap32 <types.UInt32> (Int64Hi x)))
(SignExt32to64 x) -> (Int64Make (Signmask x) x)
(SignExt16to64 x) -> (SignExt32to64 (SignExt16to32 x))
(SignExt8to64 x) -> (SignExt32to64 (SignExt8to32 x))
-(ZeroExt32to64 x) -> (Int64Make (Const32 <fe.TypeUInt32()> [0]) x)
+(ZeroExt32to64 x) -> (Int64Make (Const32 <types.UInt32> [0]) x)
(ZeroExt16to64 x) -> (ZeroExt32to64 (ZeroExt16to32 x))
(ZeroExt8to64 x) -> (ZeroExt32to64 (ZeroExt8to32 x))
// turn x64 non-constant shifts to x32 shifts
// if high 32-bit of the shift is nonzero, make a huge shift
(Lsh64x64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
- (Lsh64x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ (Lsh64x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Rsh64x64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
- (Rsh64x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ (Rsh64x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Rsh64Ux64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
- (Rsh64Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ (Rsh64Ux32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Lsh32x64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
- (Lsh32x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ (Lsh32x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Rsh32x64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
- (Rsh32x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ (Rsh32x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Rsh32Ux64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
- (Rsh32Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ (Rsh32Ux32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Lsh16x64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
- (Lsh16x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ (Lsh16x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Rsh16x64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
- (Rsh16x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ (Rsh16x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Rsh16Ux64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
- (Rsh16Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ (Rsh16Ux32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Lsh8x64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
- (Lsh8x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ (Lsh8x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Rsh8x64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
- (Rsh8x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ (Rsh8x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Rsh8Ux64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
- (Rsh8Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ (Rsh8Ux32 x (Or32 <types.UInt32> (Zeromask hi) lo))
// 64x left shift
// result.hi = hi<<s | lo>>(32-s) | lo<<(s-32) // >> is unsigned, large shifts result 0
// result.lo = lo<<s
(Lsh64x32 (Int64Make hi lo) s) ->
(Int64Make
- (Or32 <fe.TypeUInt32()>
- (Or32 <fe.TypeUInt32()>
- (Lsh32x32 <fe.TypeUInt32()> hi s)
- (Rsh32Ux32 <fe.TypeUInt32()>
+ (Or32 <types.UInt32>
+ (Or32 <types.UInt32>
+ (Lsh32x32 <types.UInt32> hi s)
+ (Rsh32Ux32 <types.UInt32>
lo
- (Sub32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [32]) s)))
- (Lsh32x32 <fe.TypeUInt32()>
+ (Sub32 <types.UInt32> (Const32 <types.UInt32> [32]) s)))
+ (Lsh32x32 <types.UInt32>
lo
- (Sub32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [32]))))
- (Lsh32x32 <fe.TypeUInt32()> lo s))
+ (Sub32 <types.UInt32> s (Const32 <types.UInt32> [32]))))
+ (Lsh32x32 <types.UInt32> lo s))
(Lsh64x16 (Int64Make hi lo) s) ->
(Int64Make
- (Or32 <fe.TypeUInt32()>
- (Or32 <fe.TypeUInt32()>
- (Lsh32x16 <fe.TypeUInt32()> hi s)
- (Rsh32Ux16 <fe.TypeUInt32()>
+ (Or32 <types.UInt32>
+ (Or32 <types.UInt32>
+ (Lsh32x16 <types.UInt32> hi s)
+ (Rsh32Ux16 <types.UInt32>
lo
- (Sub16 <fe.TypeUInt16()> (Const16 <fe.TypeUInt16()> [32]) s)))
- (Lsh32x16 <fe.TypeUInt32()>
+ (Sub16 <types.UInt16> (Const16 <types.UInt16> [32]) s)))
+ (Lsh32x16 <types.UInt32>
lo
- (Sub16 <fe.TypeUInt16()> s (Const16 <fe.TypeUInt16()> [32]))))
- (Lsh32x16 <fe.TypeUInt32()> lo s))
+ (Sub16 <types.UInt16> s (Const16 <types.UInt16> [32]))))
+ (Lsh32x16 <types.UInt32> lo s))
(Lsh64x8 (Int64Make hi lo) s) ->
(Int64Make
- (Or32 <fe.TypeUInt32()>
- (Or32 <fe.TypeUInt32()>
- (Lsh32x8 <fe.TypeUInt32()> hi s)
- (Rsh32Ux8 <fe.TypeUInt32()>
+ (Or32 <types.UInt32>
+ (Or32 <types.UInt32>
+ (Lsh32x8 <types.UInt32> hi s)
+ (Rsh32Ux8 <types.UInt32>
lo
- (Sub8 <fe.TypeUInt8()> (Const8 <fe.TypeUInt8()> [32]) s)))
- (Lsh32x8 <fe.TypeUInt32()>
+ (Sub8 <types.UInt8> (Const8 <types.UInt8> [32]) s)))
+ (Lsh32x8 <types.UInt32>
lo
- (Sub8 <fe.TypeUInt8()> s (Const8 <fe.TypeUInt8()> [32]))))
- (Lsh32x8 <fe.TypeUInt32()> lo s))
+ (Sub8 <types.UInt8> s (Const8 <types.UInt8> [32]))))
+ (Lsh32x8 <types.UInt32> lo s))
// 64x unsigned right shift
// result.hi = hi>>s
// result.lo = lo>>s | hi<<(32-s) | hi>>(s-32) // >> is unsigned, large shifts result 0
(Rsh64Ux32 (Int64Make hi lo) s) ->
(Int64Make
- (Rsh32Ux32 <fe.TypeUInt32()> hi s)
- (Or32 <fe.TypeUInt32()>
- (Or32 <fe.TypeUInt32()>
- (Rsh32Ux32 <fe.TypeUInt32()> lo s)
- (Lsh32x32 <fe.TypeUInt32()>
+ (Rsh32Ux32 <types.UInt32> hi s)
+ (Or32 <types.UInt32>
+ (Or32 <types.UInt32>
+ (Rsh32Ux32 <types.UInt32> lo s)
+ (Lsh32x32 <types.UInt32>
hi
- (Sub32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [32]) s)))
- (Rsh32Ux32 <fe.TypeUInt32()>
+ (Sub32 <types.UInt32> (Const32 <types.UInt32> [32]) s)))
+ (Rsh32Ux32 <types.UInt32>
hi
- (Sub32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [32])))))
+ (Sub32 <types.UInt32> s (Const32 <types.UInt32> [32])))))
(Rsh64Ux16 (Int64Make hi lo) s) ->
(Int64Make
- (Rsh32Ux16 <fe.TypeUInt32()> hi s)
- (Or32 <fe.TypeUInt32()>
- (Or32 <fe.TypeUInt32()>
- (Rsh32Ux16 <fe.TypeUInt32()> lo s)
- (Lsh32x16 <fe.TypeUInt32()>
+ (Rsh32Ux16 <types.UInt32> hi s)
+ (Or32 <types.UInt32>
+ (Or32 <types.UInt32>
+ (Rsh32Ux16 <types.UInt32> lo s)
+ (Lsh32x16 <types.UInt32>
hi
- (Sub16 <fe.TypeUInt16()> (Const16 <fe.TypeUInt16()> [32]) s)))
- (Rsh32Ux16 <fe.TypeUInt32()>
+ (Sub16 <types.UInt16> (Const16 <types.UInt16> [32]) s)))
+ (Rsh32Ux16 <types.UInt32>
hi
- (Sub16 <fe.TypeUInt16()> s (Const16 <fe.TypeUInt16()> [32])))))
+ (Sub16 <types.UInt16> s (Const16 <types.UInt16> [32])))))
(Rsh64Ux8 (Int64Make hi lo) s) ->
(Int64Make
- (Rsh32Ux8 <fe.TypeUInt32()> hi s)
- (Or32 <fe.TypeUInt32()>
- (Or32 <fe.TypeUInt32()>
- (Rsh32Ux8 <fe.TypeUInt32()> lo s)
- (Lsh32x8 <fe.TypeUInt32()>
+ (Rsh32Ux8 <types.UInt32> hi s)
+ (Or32 <types.UInt32>
+ (Or32 <types.UInt32>
+ (Rsh32Ux8 <types.UInt32> lo s)
+ (Lsh32x8 <types.UInt32>
hi
- (Sub8 <fe.TypeUInt8()> (Const8 <fe.TypeUInt8()> [32]) s)))
- (Rsh32Ux8 <fe.TypeUInt32()>
+ (Sub8 <types.UInt8> (Const8 <types.UInt8> [32]) s)))
+ (Rsh32Ux8 <types.UInt32>
hi
- (Sub8 <fe.TypeUInt8()> s (Const8 <fe.TypeUInt8()> [32])))))
+ (Sub8 <types.UInt8> s (Const8 <types.UInt8> [32])))))
// 64x signed right shift
// result.hi = hi>>s
// result.lo = lo>>s | hi<<(32-s) | (hi>>(s-32))&zeromask(s>>5) // hi>>(s-32) is signed, large shifts result 0/-1
(Rsh64x32 (Int64Make hi lo) s) ->
(Int64Make
- (Rsh32x32 <fe.TypeUInt32()> hi s)
- (Or32 <fe.TypeUInt32()>
- (Or32 <fe.TypeUInt32()>
- (Rsh32Ux32 <fe.TypeUInt32()> lo s)
- (Lsh32x32 <fe.TypeUInt32()>
+ (Rsh32x32 <types.UInt32> hi s)
+ (Or32 <types.UInt32>
+ (Or32 <types.UInt32>
+ (Rsh32Ux32 <types.UInt32> lo s)
+ (Lsh32x32 <types.UInt32>
hi
- (Sub32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [32]) s)))
- (And32 <fe.TypeUInt32()>
- (Rsh32x32 <fe.TypeUInt32()>
+ (Sub32 <types.UInt32> (Const32 <types.UInt32> [32]) s)))
+ (And32 <types.UInt32>
+ (Rsh32x32 <types.UInt32>
hi
- (Sub32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [32])))
+ (Sub32 <types.UInt32> s (Const32 <types.UInt32> [32])))
(Zeromask
- (Rsh32Ux32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [5]))))))
+ (Rsh32Ux32 <types.UInt32> s (Const32 <types.UInt32> [5]))))))
(Rsh64x16 (Int64Make hi lo) s) ->
(Int64Make
- (Rsh32x16 <fe.TypeUInt32()> hi s)
- (Or32 <fe.TypeUInt32()>
- (Or32 <fe.TypeUInt32()>
- (Rsh32Ux16 <fe.TypeUInt32()> lo s)
- (Lsh32x16 <fe.TypeUInt32()>
+ (Rsh32x16 <types.UInt32> hi s)
+ (Or32 <types.UInt32>
+ (Or32 <types.UInt32>
+ (Rsh32Ux16 <types.UInt32> lo s)
+ (Lsh32x16 <types.UInt32>
hi
- (Sub16 <fe.TypeUInt16()> (Const16 <fe.TypeUInt16()> [32]) s)))
- (And32 <fe.TypeUInt32()>
- (Rsh32x16 <fe.TypeUInt32()>
+ (Sub16 <types.UInt16> (Const16 <types.UInt16> [32]) s)))
+ (And32 <types.UInt32>
+ (Rsh32x16 <types.UInt32>
hi
- (Sub16 <fe.TypeUInt16()> s (Const16 <fe.TypeUInt16()> [32])))
+ (Sub16 <types.UInt16> s (Const16 <types.UInt16> [32])))
(Zeromask
(ZeroExt16to32
- (Rsh16Ux32 <fe.TypeUInt16()> s (Const32 <fe.TypeUInt32()> [5])))))))
+ (Rsh16Ux32 <types.UInt16> s (Const32 <types.UInt32> [5])))))))
(Rsh64x8 (Int64Make hi lo) s) ->
(Int64Make
- (Rsh32x8 <fe.TypeUInt32()> hi s)
- (Or32 <fe.TypeUInt32()>
- (Or32 <fe.TypeUInt32()>
- (Rsh32Ux8 <fe.TypeUInt32()> lo s)
- (Lsh32x8 <fe.TypeUInt32()>
+ (Rsh32x8 <types.UInt32> hi s)
+ (Or32 <types.UInt32>
+ (Or32 <types.UInt32>
+ (Rsh32Ux8 <types.UInt32> lo s)
+ (Lsh32x8 <types.UInt32>
hi
- (Sub8 <fe.TypeUInt8()> (Const8 <fe.TypeUInt8()> [32]) s)))
- (And32 <fe.TypeUInt32()>
- (Rsh32x8 <fe.TypeUInt32()>
+ (Sub8 <types.UInt8> (Const8 <types.UInt8> [32]) s)))
+ (And32 <types.UInt32>
+ (Rsh32x8 <types.UInt32>
hi
- (Sub8 <fe.TypeUInt8()> s (Const8 <fe.TypeUInt8()> [32])))
+ (Sub8 <types.UInt8> s (Const8 <types.UInt8> [32])))
(Zeromask
(ZeroExt8to32
- (Rsh8Ux32 <fe.TypeUInt8()> s (Const32 <fe.TypeUInt32()> [5])))))))
+ (Rsh8Ux32 <types.UInt8> s (Const32 <types.UInt32> [5])))))))
// 64xConst32 shifts
// we probably do not need them -- lateopt may take care of them just fine
//
//(Lsh64x32 x (Const32 [c])) && c < 64 && c > 32 ->
// (Int64Make
-// (Lsh32x32 <fe.TypeUInt32()> (Int64Lo x) (Const32 <fe.TypeUInt32()> [c-32]))
-// (Const32 <fe.TypeUInt32()> [0]))
+// (Lsh32x32 <types.UInt32> (Int64Lo x) (Const32 <types.UInt32> [c-32]))
+// (Const32 <types.UInt32> [0]))
//(Rsh64x32 x (Const32 [c])) && c < 64 && c > 32 ->
// (Int64Make
// (Signmask (Int64Hi x))
-// (Rsh32x32 <fe.TypeInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [c-32])))
+// (Rsh32x32 <types.Int32> (Int64Hi x) (Const32 <types.UInt32> [c-32])))
//(Rsh64Ux32 x (Const32 [c])) && c < 64 && c > 32 ->
// (Int64Make
-// (Const32 <fe.TypeUInt32()> [0])
-// (Rsh32Ux32 <fe.TypeUInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [c-32])))
+// (Const32 <types.UInt32> [0])
+// (Rsh32Ux32 <types.UInt32> (Int64Hi x) (Const32 <types.UInt32> [c-32])))
//
-//(Lsh64x32 x (Const32 [32])) -> (Int64Make (Int64Lo x) (Const32 <fe.TypeUInt32()> [0]))
+//(Lsh64x32 x (Const32 [32])) -> (Int64Make (Int64Lo x) (Const32 <types.UInt32> [0]))
//(Rsh64x32 x (Const32 [32])) -> (Int64Make (Signmask (Int64Hi x)) (Int64Hi x))
-//(Rsh64Ux32 x (Const32 [32])) -> (Int64Make (Const32 <fe.TypeUInt32()> [0]) (Int64Hi x))
+//(Rsh64Ux32 x (Const32 [32])) -> (Int64Make (Const32 <types.UInt32> [0]) (Int64Hi x))
//
//(Lsh64x32 x (Const32 [c])) && c < 32 && c > 0 ->
// (Int64Make
-// (Or32 <fe.TypeUInt32()>
-// (Lsh32x32 <fe.TypeUInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [c]))
-// (Rsh32Ux32 <fe.TypeUInt32()> (Int64Lo x) (Const32 <fe.TypeUInt32()> [32-c])))
-// (Lsh32x32 <fe.TypeUInt32()> (Int64Lo x) (Const32 <fe.TypeUInt32()> [c])))
+// (Or32 <types.UInt32>
+// (Lsh32x32 <types.UInt32> (Int64Hi x) (Const32 <types.UInt32> [c]))
+// (Rsh32Ux32 <types.UInt32> (Int64Lo x) (Const32 <types.UInt32> [32-c])))
+// (Lsh32x32 <types.UInt32> (Int64Lo x) (Const32 <types.UInt32> [c])))
//(Rsh64x32 x (Const32 [c])) && c < 32 && c > 0 ->
// (Int64Make
-// (Rsh32x32 <fe.TypeInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [c]))
-// (Or32 <fe.TypeUInt32()>
-// (Rsh32Ux32 <fe.TypeUInt32()> (Int64Lo x) (Const32 <fe.TypeUInt32()> [c]))
-// (Lsh32x32 <fe.TypeUInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [32-c]))))
+// (Rsh32x32 <types.Int32> (Int64Hi x) (Const32 <types.UInt32> [c]))
+// (Or32 <types.UInt32>
+// (Rsh32Ux32 <types.UInt32> (Int64Lo x) (Const32 <types.UInt32> [c]))
+// (Lsh32x32 <types.UInt32> (Int64Hi x) (Const32 <types.UInt32> [32-c]))))
//(Rsh64Ux32 x (Const32 [c])) && c < 32 && c > 0 ->
// (Int64Make
-// (Rsh32Ux32 <fe.TypeUInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [c]))
-// (Or32 <fe.TypeUInt32()>
-// (Rsh32Ux32 <fe.TypeUInt32()> (Int64Lo x) (Const32 <fe.TypeUInt32()> [c]))
-// (Lsh32x32 <fe.TypeUInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [32-c]))))
+// (Rsh32Ux32 <types.UInt32> (Int64Hi x) (Const32 <types.UInt32> [c]))
+// (Or32 <types.UInt32>
+// (Rsh32Ux32 <types.UInt32> (Int64Lo x) (Const32 <types.UInt32> [c]))
+// (Lsh32x32 <types.UInt32> (Int64Hi x) (Const32 <types.UInt32> [32-c]))))
//
//(Lsh64x32 x (Const32 [0])) -> x
//(Rsh64x32 x (Const32 [0])) -> x
//(Rsh64Ux32 x (Const32 [0])) -> x
(Const64 <t> [c]) && t.IsSigned() ->
- (Int64Make (Const32 <fe.TypeInt32()> [c>>32]) (Const32 <fe.TypeUInt32()> [int64(int32(c))]))
+ (Int64Make (Const32 <types.Int32> [c>>32]) (Const32 <types.UInt32> [int64(int32(c))]))
(Const64 <t> [c]) && !t.IsSigned() ->
- (Int64Make (Const32 <fe.TypeUInt32()> [c>>32]) (Const32 <fe.TypeUInt32()> [int64(int32(c))]))
+ (Int64Make (Const32 <types.UInt32> [c>>32]) (Const32 <types.UInt32> [int64(int32(c))]))
(Eq64 x y) ->
(AndB
(Mul64 (Const64 [-1]) x) -> (Neg64 x)
// Convert multiplication by a power of two to a shift.
-(Mul8 <t> n (Const8 [c])) && isPowerOfTwo(c) -> (Lsh8x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)]))
-(Mul16 <t> n (Const16 [c])) && isPowerOfTwo(c) -> (Lsh16x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)]))
-(Mul32 <t> n (Const32 [c])) && isPowerOfTwo(c) -> (Lsh32x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)]))
-(Mul64 <t> n (Const64 [c])) && isPowerOfTwo(c) -> (Lsh64x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)]))
-(Mul8 <t> n (Const8 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg8 (Lsh8x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)])))
-(Mul16 <t> n (Const16 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg16 (Lsh16x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)])))
-(Mul32 <t> n (Const32 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg32 (Lsh32x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)])))
-(Mul64 <t> n (Const64 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg64 (Lsh64x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)])))
+(Mul8 <t> n (Const8 [c])) && isPowerOfTwo(c) -> (Lsh8x64 <t> n (Const64 <types.UInt64> [log2(c)]))
+(Mul16 <t> n (Const16 [c])) && isPowerOfTwo(c) -> (Lsh16x64 <t> n (Const64 <types.UInt64> [log2(c)]))
+(Mul32 <t> n (Const32 [c])) && isPowerOfTwo(c) -> (Lsh32x64 <t> n (Const64 <types.UInt64> [log2(c)]))
+(Mul64 <t> n (Const64 [c])) && isPowerOfTwo(c) -> (Lsh64x64 <t> n (Const64 <types.UInt64> [log2(c)]))
+(Mul8 <t> n (Const8 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg8 (Lsh8x64 <t> n (Const64 <types.UInt64> [log2(-c)])))
+(Mul16 <t> n (Const16 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg16 (Lsh16x64 <t> n (Const64 <types.UInt64> [log2(-c)])))
+(Mul32 <t> n (Const32 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg32 (Lsh32x64 <t> n (Const64 <types.UInt64> [log2(-c)])))
+(Mul64 <t> n (Const64 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg64 (Lsh64x64 <t> n (Const64 <types.UInt64> [log2(-c)])))
(Mod8 (Const8 [c]) (Const8 [d])) && d != 0 -> (Const8 [int64(int8(c % d))])
(Mod16 (Const16 [c]) (Const16 [d])) && d != 0 -> (Const16 [int64(int16(c % d))])
// ((x >> c1) << c2) >> c3
(Rsh64Ux64 (Lsh64x64 (Rsh64Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
&& uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
- -> (Rsh64Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3]))
+ -> (Rsh64Ux64 x (Const64 <types.UInt64> [c1-c2+c3]))
(Rsh32Ux64 (Lsh32x64 (Rsh32Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
&& uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
- -> (Rsh32Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3]))
+ -> (Rsh32Ux64 x (Const64 <types.UInt64> [c1-c2+c3]))
(Rsh16Ux64 (Lsh16x64 (Rsh16Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
&& uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
- -> (Rsh16Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3]))
+ -> (Rsh16Ux64 x (Const64 <types.UInt64> [c1-c2+c3]))
(Rsh8Ux64 (Lsh8x64 (Rsh8Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
&& uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
- -> (Rsh8Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3]))
+ -> (Rsh8Ux64 x (Const64 <types.UInt64> [c1-c2+c3]))
// ((x << c1) >> c2) << c3
(Lsh64x64 (Rsh64Ux64 (Lsh64x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
&& uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
- -> (Lsh64x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3]))
+ -> (Lsh64x64 x (Const64 <types.UInt64> [c1-c2+c3]))
(Lsh32x64 (Rsh32Ux64 (Lsh32x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
&& uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
- -> (Lsh32x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3]))
+ -> (Lsh32x64 x (Const64 <types.UInt64> [c1-c2+c3]))
(Lsh16x64 (Rsh16Ux64 (Lsh16x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
&& uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
- -> (Lsh16x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3]))
+ -> (Lsh16x64 x (Const64 <types.UInt64> [c1-c2+c3]))
(Lsh8x64 (Rsh8Ux64 (Lsh8x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
&& uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
- -> (Lsh8x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3]))
+ -> (Lsh8x64 x (Const64 <types.UInt64> [c1-c2+c3]))
// replace shifts with zero extensions
-(Rsh16Ux64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) -> (ZeroExt8to16 (Trunc16to8 <fe.TypeUInt8()> x))
-(Rsh32Ux64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) -> (ZeroExt8to32 (Trunc32to8 <fe.TypeUInt8()> x))
-(Rsh64Ux64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) -> (ZeroExt8to64 (Trunc64to8 <fe.TypeUInt8()> x))
-(Rsh32Ux64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) -> (ZeroExt16to32 (Trunc32to16 <fe.TypeUInt16()> x))
-(Rsh64Ux64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) -> (ZeroExt16to64 (Trunc64to16 <fe.TypeUInt16()> x))
-(Rsh64Ux64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) -> (ZeroExt32to64 (Trunc64to32 <fe.TypeUInt32()> x))
+(Rsh16Ux64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) -> (ZeroExt8to16 (Trunc16to8 <types.UInt8> x))
+(Rsh32Ux64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) -> (ZeroExt8to32 (Trunc32to8 <types.UInt8> x))
+(Rsh64Ux64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) -> (ZeroExt8to64 (Trunc64to8 <types.UInt8> x))
+(Rsh32Ux64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) -> (ZeroExt16to32 (Trunc32to16 <types.UInt16> x))
+(Rsh64Ux64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) -> (ZeroExt16to64 (Trunc64to16 <types.UInt16> x))
+(Rsh64Ux64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) -> (ZeroExt32to64 (Trunc64to32 <types.UInt32> x))
// replace shifts with sign extensions
-(Rsh16x64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) -> (SignExt8to16 (Trunc16to8 <fe.TypeInt8()> x))
-(Rsh32x64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) -> (SignExt8to32 (Trunc32to8 <fe.TypeInt8()> x))
-(Rsh64x64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) -> (SignExt8to64 (Trunc64to8 <fe.TypeInt8()> x))
-(Rsh32x64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) -> (SignExt16to32 (Trunc32to16 <fe.TypeInt16()> x))
-(Rsh64x64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) -> (SignExt16to64 (Trunc64to16 <fe.TypeInt16()> x))
-(Rsh64x64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) -> (SignExt32to64 (Trunc64to32 <fe.TypeInt32()> x))
+(Rsh16x64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) -> (SignExt8to16 (Trunc16to8 <types.Int8> x))
+(Rsh32x64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) -> (SignExt8to32 (Trunc32to8 <types.Int8> x))
+(Rsh64x64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) -> (SignExt8to64 (Trunc64to8 <types.Int8> x))
+(Rsh32x64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) -> (SignExt16to32 (Trunc32to16 <types.Int16> x))
+(Rsh64x64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) -> (SignExt16to64 (Trunc64to16 <types.Int16> x))
+(Rsh64x64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) -> (SignExt32to64 (Trunc64to32 <types.Int32> x))
// constant comparisons
(Eq64 (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(c == d)])
// indexing operations
// Note: bounds check has already been done
-(PtrIndex <t> ptr idx) && config.PtrSize == 4 -> (AddPtr ptr (Mul32 <fe.TypeInt()> idx (Const32 <fe.TypeInt()> [t.ElemType().Size()])))
-(PtrIndex <t> ptr idx) && config.PtrSize == 8 -> (AddPtr ptr (Mul64 <fe.TypeInt()> idx (Const64 <fe.TypeInt()> [t.ElemType().Size()])))
+(PtrIndex <t> ptr idx) && config.PtrSize == 4 -> (AddPtr ptr (Mul32 <types.Int> idx (Const32 <types.Int> [t.ElemType().Size()])))
+(PtrIndex <t> ptr idx) && config.PtrSize == 8 -> (AddPtr ptr (Mul64 <types.Int> idx (Const64 <types.Int> [t.ElemType().Size()])))
// struct operations
(StructSelect (StructMake1 x)) -> x
(StringPtr (StringMake (Const64 <t> [c]) _)) -> (Const64 <t> [c])
(StringLen (StringMake _ (Const64 <t> [c]))) -> (Const64 <t> [c])
(ConstString {s}) && config.PtrSize == 4 && s.(string) == "" ->
- (StringMake (ConstNil) (Const32 <fe.TypeInt()> [0]))
+ (StringMake (ConstNil) (Const32 <types.Int> [0]))
(ConstString {s}) && config.PtrSize == 8 && s.(string) == "" ->
- (StringMake (ConstNil) (Const64 <fe.TypeInt()> [0]))
+ (StringMake (ConstNil) (Const64 <types.Int> [0]))
(ConstString {s}) && config.PtrSize == 4 && s.(string) != "" ->
(StringMake
- (Addr <fe.TypeBytePtr()> {fe.StringData(s.(string))}
+ (Addr <types.BytePtr> {fe.StringData(s.(string))}
(SB))
- (Const32 <fe.TypeInt()> [int64(len(s.(string)))]))
+ (Const32 <types.Int> [int64(len(s.(string)))]))
(ConstString {s}) && config.PtrSize == 8 && s.(string) != "" ->
(StringMake
- (Addr <fe.TypeBytePtr()> {fe.StringData(s.(string))}
+ (Addr <types.BytePtr> {fe.StringData(s.(string))}
(SB))
- (Const64 <fe.TypeInt()> [int64(len(s.(string)))]))
+ (Const64 <types.Int> [int64(len(s.(string)))]))
// slice ops
// Only a few slice rules are provided here. See dec.rules for
(ConstSlice) && config.PtrSize == 4 ->
(SliceMake
(ConstNil <v.Type.ElemType().PtrTo()>)
- (Const32 <fe.TypeInt()> [0])
- (Const32 <fe.TypeInt()> [0]))
+ (Const32 <types.Int> [0])
+ (Const32 <types.Int> [0]))
(ConstSlice) && config.PtrSize == 8 ->
(SliceMake
(ConstNil <v.Type.ElemType().PtrTo()>)
- (Const64 <fe.TypeInt()> [0])
- (Const64 <fe.TypeInt()> [0]))
+ (Const64 <types.Int> [0])
+ (Const64 <types.Int> [0]))
// interface ops
(ConstInterface) ->
(IMake
- (ConstNil <fe.TypeBytePtr()>)
- (ConstNil <fe.TypeBytePtr()>))
+ (ConstNil <types.BytePtr>)
+ (ConstNil <types.BytePtr>))
(NilCheck (GetG mem) mem) -> mem
// Decompose compound argument values
(Arg {n} [off]) && v.Type.IsString() ->
(StringMake
- (Arg <fe.TypeBytePtr()> {n} [off])
- (Arg <fe.TypeInt()> {n} [off+config.PtrSize]))
+ (Arg <types.BytePtr> {n} [off])
+ (Arg <types.Int> {n} [off+config.PtrSize]))
(Arg {n} [off]) && v.Type.IsSlice() ->
(SliceMake
(Arg <v.Type.ElemType().PtrTo()> {n} [off])
- (Arg <fe.TypeInt()> {n} [off+config.PtrSize])
- (Arg <fe.TypeInt()> {n} [off+2*config.PtrSize]))
+ (Arg <types.Int> {n} [off+config.PtrSize])
+ (Arg <types.Int> {n} [off+2*config.PtrSize]))
(Arg {n} [off]) && v.Type.IsInterface() ->
(IMake
- (Arg <fe.TypeBytePtr()> {n} [off])
- (Arg <fe.TypeBytePtr()> {n} [off+config.PtrSize]))
+ (Arg <types.BytePtr> {n} [off])
+ (Arg <types.BytePtr> {n} [off+config.PtrSize]))
(Arg {n} [off]) && v.Type.IsComplex() && v.Type.Size() == 16 ->
(ComplexMake
- (Arg <fe.TypeFloat64()> {n} [off])
- (Arg <fe.TypeFloat64()> {n} [off+8]))
+ (Arg <types.Float64> {n} [off])
+ (Arg <types.Float64> {n} [off+8]))
(Arg {n} [off]) && v.Type.IsComplex() && v.Type.Size() == 8 ->
(ComplexMake
- (Arg <fe.TypeFloat32()> {n} [off])
- (Arg <fe.TypeFloat32()> {n} [off+4]))
+ (Arg <types.Float32> {n} [off])
+ (Arg <types.Float32> {n} [off+4]))
(Arg <t>) && t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t) ->
(StructMake0)
// See ../magic.go for a detailed description of these algorithms.
// Unsigned divide by power of 2. Strength reduce to a shift.
-(Div8u n (Const8 [c])) && isPowerOfTwo(c&0xff) -> (Rsh8Ux64 n (Const64 <fe.TypeUInt64()> [log2(c&0xff)]))
-(Div16u n (Const16 [c])) && isPowerOfTwo(c&0xffff) -> (Rsh16Ux64 n (Const64 <fe.TypeUInt64()> [log2(c&0xffff)]))
-(Div32u n (Const32 [c])) && isPowerOfTwo(c&0xffffffff) -> (Rsh32Ux64 n (Const64 <fe.TypeUInt64()> [log2(c&0xffffffff)]))
-(Div64u n (Const64 [c])) && isPowerOfTwo(c) -> (Rsh64Ux64 n (Const64 <fe.TypeUInt64()> [log2(c)]))
+(Div8u n (Const8 [c])) && isPowerOfTwo(c&0xff) -> (Rsh8Ux64 n (Const64 <types.UInt64> [log2(c&0xff)]))
+(Div16u n (Const16 [c])) && isPowerOfTwo(c&0xffff) -> (Rsh16Ux64 n (Const64 <types.UInt64> [log2(c&0xffff)]))
+(Div32u n (Const32 [c])) && isPowerOfTwo(c&0xffffffff) -> (Rsh32Ux64 n (Const64 <types.UInt64> [log2(c&0xffffffff)]))
+(Div64u n (Const64 [c])) && isPowerOfTwo(c) -> (Rsh64Ux64 n (Const64 <types.UInt64> [log2(c)]))
// Unsigned divide, not a power of 2. Strength reduce to a multiply.
// For 8-bit divides, we just do a direct 9-bit by 8-bit multiply.
(Div8u x (Const8 [c])) && umagicOK(8, c) ->
(Trunc32to8
- (Rsh32Ux64 <fe.TypeUInt32()>
- (Mul32 <fe.TypeUInt32()>
- (Const32 <fe.TypeUInt32()> [int64(1<<8+umagic(8,c).m)])
+ (Rsh32Ux64 <types.UInt32>
+ (Mul32 <types.UInt32>
+ (Const32 <types.UInt32> [int64(1<<8+umagic(8,c).m)])
(ZeroExt8to32 x))
- (Const64 <fe.TypeUInt64()> [8+umagic(8,c).s])))
+ (Const64 <types.UInt64> [8+umagic(8,c).s])))
// For 16-bit divides on 64-bit machines, we do a direct 17-bit by 16-bit multiply.
(Div16u x (Const16 [c])) && umagicOK(16, c) && config.RegSize == 8 ->
(Trunc64to16
- (Rsh64Ux64 <fe.TypeUInt64()>
- (Mul64 <fe.TypeUInt64()>
- (Const64 <fe.TypeUInt64()> [int64(1<<16+umagic(16,c).m)])
+ (Rsh64Ux64 <types.UInt64>
+ (Mul64 <types.UInt64>
+ (Const64 <types.UInt64> [int64(1<<16+umagic(16,c).m)])
(ZeroExt16to64 x))
- (Const64 <fe.TypeUInt64()> [16+umagic(16,c).s])))
+ (Const64 <types.UInt64> [16+umagic(16,c).s])))
// For 16-bit divides on 32-bit machines
(Div16u x (Const16 [c])) && umagicOK(16, c) && config.RegSize == 4 && umagic(16,c).m&1 == 0 ->
(Trunc32to16
- (Rsh32Ux64 <fe.TypeUInt32()>
- (Mul32 <fe.TypeUInt32()>
- (Const32 <fe.TypeUInt32()> [int64(1<<15+umagic(16,c).m/2)])
+ (Rsh32Ux64 <types.UInt32>
+ (Mul32 <types.UInt32>
+ (Const32 <types.UInt32> [int64(1<<15+umagic(16,c).m/2)])
(ZeroExt16to32 x))
- (Const64 <fe.TypeUInt64()> [16+umagic(16,c).s-1])))
+ (Const64 <types.UInt64> [16+umagic(16,c).s-1])))
(Div16u x (Const16 [c])) && umagicOK(16, c) && config.RegSize == 4 && c&1 == 0 ->
(Trunc32to16
- (Rsh32Ux64 <fe.TypeUInt32()>
- (Mul32 <fe.TypeUInt32()>
- (Const32 <fe.TypeUInt32()> [int64(1<<15+(umagic(16,c).m+1)/2)])
- (Rsh32Ux64 <fe.TypeUInt32()> (ZeroExt16to32 x) (Const64 <fe.TypeUInt64()> [1])))
- (Const64 <fe.TypeUInt64()> [16+umagic(16,c).s-2])))
+ (Rsh32Ux64 <types.UInt32>
+ (Mul32 <types.UInt32>
+ (Const32 <types.UInt32> [int64(1<<15+(umagic(16,c).m+1)/2)])
+ (Rsh32Ux64 <types.UInt32> (ZeroExt16to32 x) (Const64 <types.UInt64> [1])))
+ (Const64 <types.UInt64> [16+umagic(16,c).s-2])))
(Div16u x (Const16 [c])) && umagicOK(16, c) && config.RegSize == 4 ->
(Trunc32to16
- (Rsh32Ux64 <fe.TypeUInt32()>
+ (Rsh32Ux64 <types.UInt32>
(Avg32u
- (Lsh32x64 <fe.TypeUInt32()> (ZeroExt16to32 x) (Const64 <fe.TypeUInt64()> [16]))
- (Mul32 <fe.TypeUInt32()>
- (Const32 <fe.TypeUInt32()> [int64(umagic(16,c).m)])
+ (Lsh32x64 <types.UInt32> (ZeroExt16to32 x) (Const64 <types.UInt64> [16]))
+ (Mul32 <types.UInt32>
+ (Const32 <types.UInt32> [int64(umagic(16,c).m)])
(ZeroExt16to32 x)))
- (Const64 <fe.TypeUInt64()> [16+umagic(16,c).s-1])))
+ (Const64 <types.UInt64> [16+umagic(16,c).s-1])))
// For 32-bit divides on 32-bit machines
(Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 4 && umagic(32,c).m&1 == 0 ->
- (Rsh32Ux64 <fe.TypeUInt32()>
- (Hmul32u <fe.TypeUInt32()>
- (Const32 <fe.TypeUInt32()> [int64(int32(1<<31+umagic(32,c).m/2))])
+ (Rsh32Ux64 <types.UInt32>
+ (Hmul32u <types.UInt32>
+ (Const32 <types.UInt32> [int64(int32(1<<31+umagic(32,c).m/2))])
x)
- (Const64 <fe.TypeUInt64()> [umagic(32,c).s-1]))
+ (Const64 <types.UInt64> [umagic(32,c).s-1]))
(Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 4 && c&1 == 0 ->
- (Rsh32Ux64 <fe.TypeUInt32()>
- (Hmul32u <fe.TypeUInt32()>
- (Const32 <fe.TypeUInt32()> [int64(int32(1<<31+(umagic(32,c).m+1)/2))])
- (Rsh32Ux64 <fe.TypeUInt32()> x (Const64 <fe.TypeUInt64()> [1])))
- (Const64 <fe.TypeUInt64()> [umagic(32,c).s-2]))
+ (Rsh32Ux64 <types.UInt32>
+ (Hmul32u <types.UInt32>
+ (Const32 <types.UInt32> [int64(int32(1<<31+(umagic(32,c).m+1)/2))])
+ (Rsh32Ux64 <types.UInt32> x (Const64 <types.UInt64> [1])))
+ (Const64 <types.UInt64> [umagic(32,c).s-2]))
(Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 4 ->
- (Rsh32Ux64 <fe.TypeUInt32()>
+ (Rsh32Ux64 <types.UInt32>
(Avg32u
x
- (Hmul32u <fe.TypeUInt32()>
- (Const32 <fe.TypeUInt32()> [int64(int32(umagic(32,c).m))])
+ (Hmul32u <types.UInt32>
+ (Const32 <types.UInt32> [int64(int32(umagic(32,c).m))])
x))
- (Const64 <fe.TypeUInt64()> [umagic(32,c).s-1]))
+ (Const64 <types.UInt64> [umagic(32,c).s-1]))
// For 32-bit divides on 64-bit machines
// We'll use a regular (non-hi) multiply for this case.
(Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 8 && umagic(32,c).m&1 == 0 ->
(Trunc64to32
- (Rsh64Ux64 <fe.TypeUInt64()>
- (Mul64 <fe.TypeUInt64()>
- (Const64 <fe.TypeUInt64()> [int64(1<<31+umagic(32,c).m/2)])
+ (Rsh64Ux64 <types.UInt64>
+ (Mul64 <types.UInt64>
+ (Const64 <types.UInt64> [int64(1<<31+umagic(32,c).m/2)])
(ZeroExt32to64 x))
- (Const64 <fe.TypeUInt64()> [32+umagic(32,c).s-1])))
+ (Const64 <types.UInt64> [32+umagic(32,c).s-1])))
(Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 8 && c&1 == 0 ->
(Trunc64to32
- (Rsh64Ux64 <fe.TypeUInt64()>
- (Mul64 <fe.TypeUInt64()>
- (Const64 <fe.TypeUInt64()> [int64(1<<31+(umagic(32,c).m+1)/2)])
- (Rsh64Ux64 <fe.TypeUInt64()> (ZeroExt32to64 x) (Const64 <fe.TypeUInt64()> [1])))
- (Const64 <fe.TypeUInt64()> [32+umagic(32,c).s-2])))
+ (Rsh64Ux64 <types.UInt64>
+ (Mul64 <types.UInt64>
+ (Const64 <types.UInt64> [int64(1<<31+(umagic(32,c).m+1)/2)])
+ (Rsh64Ux64 <types.UInt64> (ZeroExt32to64 x) (Const64 <types.UInt64> [1])))
+ (Const64 <types.UInt64> [32+umagic(32,c).s-2])))
(Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 8 ->
(Trunc64to32
- (Rsh64Ux64 <fe.TypeUInt64()>
+ (Rsh64Ux64 <types.UInt64>
(Avg64u
- (Lsh64x64 <fe.TypeUInt64()> (ZeroExt32to64 x) (Const64 <fe.TypeUInt64()> [32]))
- (Mul64 <fe.TypeUInt64()>
- (Const64 <fe.TypeUInt32()> [int64(umagic(32,c).m)])
+ (Lsh64x64 <types.UInt64> (ZeroExt32to64 x) (Const64 <types.UInt64> [32]))
+ (Mul64 <types.UInt64>
+ (Const64 <types.UInt32> [int64(umagic(32,c).m)])
(ZeroExt32to64 x)))
- (Const64 <fe.TypeUInt64()> [32+umagic(32,c).s-1])))
+ (Const64 <types.UInt64> [32+umagic(32,c).s-1])))
// For 64-bit divides on 64-bit machines
// (64-bit divides on 32-bit machines are lowered to a runtime call by the walk pass.)
(Div64u x (Const64 [c])) && umagicOK(64, c) && config.RegSize == 8 && umagic(64,c).m&1 == 0 ->
- (Rsh64Ux64 <fe.TypeUInt64()>
- (Hmul64u <fe.TypeUInt64()>
- (Const64 <fe.TypeUInt64()> [int64(1<<63+umagic(64,c).m/2)])
+ (Rsh64Ux64 <types.UInt64>
+ (Hmul64u <types.UInt64>
+ (Const64 <types.UInt64> [int64(1<<63+umagic(64,c).m/2)])
x)
- (Const64 <fe.TypeUInt64()> [umagic(64,c).s-1]))
+ (Const64 <types.UInt64> [umagic(64,c).s-1]))
(Div64u x (Const64 [c])) && umagicOK(64, c) && config.RegSize == 8 && c&1 == 0 ->
- (Rsh64Ux64 <fe.TypeUInt64()>
- (Hmul64u <fe.TypeUInt64()>
- (Const64 <fe.TypeUInt64()> [int64(1<<63+(umagic(64,c).m+1)/2)])
- (Rsh64Ux64 <fe.TypeUInt64()> x (Const64 <fe.TypeUInt64()> [1])))
- (Const64 <fe.TypeUInt64()> [umagic(64,c).s-2]))
+ (Rsh64Ux64 <types.UInt64>
+ (Hmul64u <types.UInt64>
+ (Const64 <types.UInt64> [int64(1<<63+(umagic(64,c).m+1)/2)])
+ (Rsh64Ux64 <types.UInt64> x (Const64 <types.UInt64> [1])))
+ (Const64 <types.UInt64> [umagic(64,c).s-2]))
(Div64u x (Const64 [c])) && umagicOK(64, c) && config.RegSize == 8 ->
- (Rsh64Ux64 <fe.TypeUInt64()>
+ (Rsh64Ux64 <types.UInt64>
(Avg64u
x
- (Hmul64u <fe.TypeUInt64()>
- (Const64 <fe.TypeUInt64()> [int64(umagic(64,c).m)])
+ (Hmul64u <types.UInt64>
+ (Const64 <types.UInt64> [int64(umagic(64,c).m)])
x))
- (Const64 <fe.TypeUInt64()> [umagic(64,c).s-1]))
+ (Const64 <types.UInt64> [umagic(64,c).s-1]))
// Signed divide by a negative constant. Rewrite to divide by a positive constant.
(Div8 <t> n (Const8 [c])) && c < 0 && c != -1<<7 -> (Neg8 (Div8 <t> n (Const8 <t> [-c])))
// Dividing by the most-negative number. Result is always 0 except
// if the input is also the most-negative number.
// We can detect that using the sign bit of x & -x.
-(Div8 <t> x (Const8 [-1<<7 ])) -> (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <fe.TypeUInt64()> [7 ]))
-(Div16 <t> x (Const16 [-1<<15])) -> (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <fe.TypeUInt64()> [15]))
-(Div32 <t> x (Const32 [-1<<31])) -> (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <fe.TypeUInt64()> [31]))
-(Div64 <t> x (Const64 [-1<<63])) -> (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <fe.TypeUInt64()> [63]))
+(Div8 <t> x (Const8 [-1<<7 ])) -> (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <types.UInt64> [7 ]))
+(Div16 <t> x (Const16 [-1<<15])) -> (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <types.UInt64> [15]))
+(Div32 <t> x (Const32 [-1<<31])) -> (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <types.UInt64> [31]))
+(Div64 <t> x (Const64 [-1<<63])) -> (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <types.UInt64> [63]))
// Signed divide by power of 2.
// n / c = n >> log(c) if n >= 0
// We conditionally add c-1 by adding n>>63>>(64-log(c)) (first shift signed, second shift unsigned).
(Div8 <t> n (Const8 [c])) && isPowerOfTwo(c) ->
(Rsh8x64
- (Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <fe.TypeUInt64()> [ 7])) (Const64 <fe.TypeUInt64()> [ 8-log2(c)])))
- (Const64 <fe.TypeUInt64()> [log2(c)]))
+ (Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <types.UInt64> [ 7])) (Const64 <types.UInt64> [ 8-log2(c)])))
+ (Const64 <types.UInt64> [log2(c)]))
(Div16 <t> n (Const16 [c])) && isPowerOfTwo(c) ->
(Rsh16x64
- (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <fe.TypeUInt64()> [15])) (Const64 <fe.TypeUInt64()> [16-log2(c)])))
- (Const64 <fe.TypeUInt64()> [log2(c)]))
+ (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <types.UInt64> [15])) (Const64 <types.UInt64> [16-log2(c)])))
+ (Const64 <types.UInt64> [log2(c)]))
(Div32 <t> n (Const32 [c])) && isPowerOfTwo(c) ->
(Rsh32x64
- (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <fe.TypeUInt64()> [31])) (Const64 <fe.TypeUInt64()> [32-log2(c)])))
- (Const64 <fe.TypeUInt64()> [log2(c)]))
+ (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <types.UInt64> [31])) (Const64 <types.UInt64> [32-log2(c)])))
+ (Const64 <types.UInt64> [log2(c)]))
(Div64 <t> n (Const64 [c])) && isPowerOfTwo(c) ->
(Rsh64x64
- (Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <fe.TypeUInt64()> [63])) (Const64 <fe.TypeUInt64()> [64-log2(c)])))
- (Const64 <fe.TypeUInt64()> [log2(c)]))
+ (Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <types.UInt64> [63])) (Const64 <types.UInt64> [64-log2(c)])))
+ (Const64 <types.UInt64> [log2(c)]))
// Signed divide, not a power of 2. Strength reduce to a multiply.
(Div8 <t> x (Const8 [c])) && smagicOK(8,c) ->
(Sub8 <t>
(Rsh32x64 <t>
- (Mul32 <fe.TypeUInt32()>
- (Const32 <fe.TypeUInt32()> [int64(smagic(8,c).m)])
+ (Mul32 <types.UInt32>
+ (Const32 <types.UInt32> [int64(smagic(8,c).m)])
(SignExt8to32 x))
- (Const64 <fe.TypeUInt64()> [8+smagic(8,c).s]))
+ (Const64 <types.UInt64> [8+smagic(8,c).s]))
(Rsh32x64 <t>
(SignExt8to32 x)
- (Const64 <fe.TypeUInt64()> [31])))
+ (Const64 <types.UInt64> [31])))
(Div16 <t> x (Const16 [c])) && smagicOK(16,c) ->
(Sub16 <t>
(Rsh32x64 <t>
- (Mul32 <fe.TypeUInt32()>
- (Const32 <fe.TypeUInt32()> [int64(smagic(16,c).m)])
+ (Mul32 <types.UInt32>
+ (Const32 <types.UInt32> [int64(smagic(16,c).m)])
(SignExt16to32 x))
- (Const64 <fe.TypeUInt64()> [16+smagic(16,c).s]))
+ (Const64 <types.UInt64> [16+smagic(16,c).s]))
(Rsh32x64 <t>
(SignExt16to32 x)
- (Const64 <fe.TypeUInt64()> [31])))
+ (Const64 <types.UInt64> [31])))
(Div32 <t> x (Const32 [c])) && smagicOK(32,c) && config.RegSize == 8 ->
(Sub32 <t>
(Rsh64x64 <t>
- (Mul64 <fe.TypeUInt64()>
- (Const64 <fe.TypeUInt64()> [int64(smagic(32,c).m)])
+ (Mul64 <types.UInt64>
+ (Const64 <types.UInt64> [int64(smagic(32,c).m)])
(SignExt32to64 x))
- (Const64 <fe.TypeUInt64()> [32+smagic(32,c).s]))
+ (Const64 <types.UInt64> [32+smagic(32,c).s]))
(Rsh64x64 <t>
(SignExt32to64 x)
- (Const64 <fe.TypeUInt64()> [63])))
+ (Const64 <types.UInt64> [63])))
(Div32 <t> x (Const32 [c])) && smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 == 0 ->
(Sub32 <t>
(Rsh32x64 <t>
(Hmul32 <t>
- (Const32 <fe.TypeUInt32()> [int64(int32(smagic(32,c).m/2))])
+ (Const32 <types.UInt32> [int64(int32(smagic(32,c).m/2))])
x)
- (Const64 <fe.TypeUInt64()> [smagic(32,c).s-1]))
+ (Const64 <types.UInt64> [smagic(32,c).s-1]))
(Rsh32x64 <t>
x
- (Const64 <fe.TypeUInt64()> [31])))
+ (Const64 <types.UInt64> [31])))
(Div32 <t> x (Const32 [c])) && smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 != 0 ->
(Sub32 <t>
(Rsh32x64 <t>
(Add32 <t>
(Hmul32 <t>
- (Const32 <fe.TypeUInt32()> [int64(int32(smagic(32,c).m))])
+ (Const32 <types.UInt32> [int64(int32(smagic(32,c).m))])
x)
x)
- (Const64 <fe.TypeUInt64()> [smagic(32,c).s]))
+ (Const64 <types.UInt64> [smagic(32,c).s]))
(Rsh32x64 <t>
x
- (Const64 <fe.TypeUInt64()> [31])))
+ (Const64 <types.UInt64> [31])))
(Div64 <t> x (Const64 [c])) && smagicOK(64,c) && smagic(64,c).m&1 == 0 ->
(Sub64 <t>
(Rsh64x64 <t>
(Hmul64 <t>
- (Const64 <fe.TypeUInt64()> [int64(smagic(64,c).m/2)])
+ (Const64 <types.UInt64> [int64(smagic(64,c).m/2)])
x)
- (Const64 <fe.TypeUInt64()> [smagic(64,c).s-1]))
+ (Const64 <types.UInt64> [smagic(64,c).s-1]))
(Rsh64x64 <t>
x
- (Const64 <fe.TypeUInt64()> [63])))
+ (Const64 <types.UInt64> [63])))
(Div64 <t> x (Const64 [c])) && smagicOK(64,c) && smagic(64,c).m&1 != 0 ->
(Sub64 <t>
(Rsh64x64 <t>
(Add64 <t>
(Hmul64 <t>
- (Const64 <fe.TypeUInt64()> [int64(smagic(64,c).m)])
+ (Const64 <types.UInt64> [int64(smagic(64,c).m)])
x)
x)
- (Const64 <fe.TypeUInt64()> [smagic(64,c).s]))
+ (Const64 <types.UInt64> [smagic(64,c).s]))
(Rsh64x64 <t>
x
- (Const64 <fe.TypeUInt64()> [63])))
+ (Const64 <types.UInt64> [63])))
// Unsigned mod by power of 2 constant.
(Mod8u <t> n (Const8 [c])) && isPowerOfTwo(c&0xff) -> (And8 n (Const8 <t> [(c&0xff)-1]))
}
body := buf.String()
- // Do a rough match to predict whether we need b, config, and/or fe.
+ // Do a rough match to predict whether we need b, config, fe, and/or types.
// It's not precise--thus the blank assignments--but it's good enough
// to avoid generating needless code and doing pointless nil checks.
hasb := strings.Contains(body, "b.")
hasconfig := strings.Contains(body, "config.") || strings.Contains(body, "config)")
hasfe := strings.Contains(body, "fe.")
+ hasts := strings.Contains(body, "types.")
fmt.Fprintf(w, "func rewriteValue%s_%s(v *Value) bool {\n", arch.name, op)
if hasb || hasconfig || hasfe {
fmt.Fprintln(w, "b := v.Block")
fmt.Fprintln(w, "fe := b.Func.fe")
fmt.Fprintln(w, "_ = fe")
}
+ if hasts {
+ fmt.Fprintln(w, "types := &b.Func.Config.Types")
+ fmt.Fprintln(w, "_ = types")
+ }
fmt.Fprint(w, body)
fmt.Fprintf(w, "}\n")
}
fmt.Fprintln(w, "_ = config")
fmt.Fprintln(w, "fe := b.Func.fe")
fmt.Fprintln(w, "_ = fe")
+ fmt.Fprintln(w, "types := &config.Types")
+ fmt.Fprintln(w, "_ = types")
fmt.Fprintf(w, "switch b.Kind {\n")
ops = nil
for op := range blockrules {
case "Flags", "Mem", "Void", "Int128":
return "Type" + typ
default:
- return "fe.Type" + typ + "()"
+ return "types." + typ
}
}
// if sp < g.limit { goto sched }
// goto header
- pt := f.fe.TypeUintptr()
+ types := &f.Config.Types
+ pt := types.Uintptr
g := test.NewValue1(bb.Pos, OpGetG, pt, mem0)
sp := test.NewValue0(bb.Pos, OpSP, pt)
cmpOp := OpLess64U
}
limaddr := test.NewValue1I(bb.Pos, OpOffPtr, pt, 2*pt.Size(), g)
lim := test.NewValue2(bb.Pos, OpLoad, pt, limaddr, mem0)
- cmp := test.NewValue2(bb.Pos, cmpOp, f.fe.TypeBool(), sp, lim)
+ cmp := test.NewValue2(bb.Pos, cmpOp, types.Bool, sp, lim)
test.SetControl(cmp)
// if true, goto sched
func (e *edgeState) findRegFor(typ Type) Location {
// Which registers are possibilities.
var m regMask
+ types := &e.s.f.Config.Types
if typ.IsFloat() {
- m = e.s.compatRegs(e.s.f.fe.TypeFloat64())
+ m = e.s.compatRegs(types.Float64)
} else {
- m = e.s.compatRegs(e.s.f.fe.TypeInt64())
+ m = e.s.compatRegs(types.Int64)
}
// Pick a register. In priority order:
// No register is available. Allocate a temp location to spill a register to.
// The type of the slot is immaterial - it will not be live across
// any safepoint. Just use a type big enough to hold any register.
- typ = e.s.f.fe.TypeInt64()
+ typ = types.Int64
t := LocalSlot{e.s.f.fe.Auto(typ), typ, 0}
// TODO: reuse these slots.
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (MOVSDconst [c])
// cond: config.ctxt.Flag_shared
// result: (MOVSDconst2 (MOVSDconst1 [c]))
break
}
v.reset(Op386MOVSDconst2)
- v0 := b.NewValue0(v.Pos, Op386MOVSDconst1, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, Op386MOVSDconst1, types.UInt32)
v0.AuxInt = c
v.AddArg(v0)
return true
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (MOVSSconst [c])
// cond: config.ctxt.Flag_shared
// result: (MOVSSconst2 (MOVSSconst1 [c]))
break
}
v.reset(Op386MOVSSconst2)
- v0 := b.NewValue0(v.Pos, Op386MOVSSconst1, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, Op386MOVSSconst1, types.UInt32)
v0.AuxInt = c
v.AddArg(v0)
return true
func rewriteValue386_Op386ORL(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL x (MOVLconst [c]))
// cond:
// result: (ORLconst [c] x)
break
}
b = mergePoint(b, x0, x1)
- v0 := b.NewValue0(v.Pos, Op386MOVWload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, Op386MOVWload, types.UInt16)
v.reset(OpCopy)
v.AddArg(v0)
v0.AuxInt = i
break
}
b = mergePoint(b, x0, x1, x2)
- v0 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v.reset(OpCopy)
v.AddArg(v0)
v0.AuxInt = i
func rewriteValue386_OpDiv8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8 x y)
// cond:
// result: (DIVW (SignExt8to16 x) (SignExt8to16 y))
x := v.Args[0]
y := v.Args[1]
v.reset(Op386DIVW)
- v0 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to16, types.Int16)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to16, types.Int16)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValue386_OpDiv8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8u x y)
// cond:
// result: (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y))
x := v.Args[0]
y := v.Args[1]
v.reset(Op386DIVWU)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to16, types.UInt16)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to16, types.UInt16)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValue386_OpMod8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod8 x y)
// cond:
// result: (MODW (SignExt8to16 x) (SignExt8to16 y))
x := v.Args[0]
y := v.Args[1]
v.reset(Op386MODW)
- v0 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to16, types.Int16)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to16, types.Int16)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValue386_OpMod8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod8u x y)
// cond:
// result: (MODWU (ZeroExt8to16 x) (ZeroExt8to16 y))
x := v.Args[0]
y := v.Args[1]
v.reset(Op386MODWU)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to16, types.UInt16)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to16, types.UInt16)
v1.AddArg(y)
v.AddArg(v1)
return true
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [0] _ _ mem)
// cond:
// result: mem
mem := v.Args[2]
v.reset(Op386MOVBstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, Op386MOVBload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, Op386MOVBload, types.UInt8)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
mem := v.Args[2]
v.reset(Op386MOVWstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, Op386MOVWload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, Op386MOVWload, types.UInt16)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
mem := v.Args[2]
v.reset(Op386MOVLstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v.reset(Op386MOVBstore)
v.AuxInt = 2
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, Op386MOVBload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, Op386MOVBload, types.UInt8)
v0.AuxInt = 2
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, Op386MOVWstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, Op386MOVWload, fe.TypeUInt16())
+ v2 := b.NewValue0(v.Pos, Op386MOVWload, types.UInt16)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(Op386MOVBstore)
v.AuxInt = 4
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, Op386MOVBload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, Op386MOVBload, types.UInt8)
v0.AuxInt = 4
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(Op386MOVWstore)
v.AuxInt = 4
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, Op386MOVWload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, Op386MOVWload, types.UInt16)
v0.AuxInt = 4
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(Op386MOVLstore)
v.AuxInt = 3
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v0.AuxInt = 3
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(Op386MOVLstore)
v.AuxInt = 4
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v0.AuxInt = 4
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem)
v2.AddArg(dst)
- v3 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v3.AddArg(src)
v3.AddArg(mem)
v2.AddArg(v3)
v.reset(Op386REPMOVSL)
v.AddArg(dst)
v.AddArg(src)
- v0 := b.NewValue0(v.Pos, Op386MOVLconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, Op386MOVLconst, types.UInt32)
v0.AuxInt = s / 4
v.AddArg(v0)
v.AddArg(mem)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neg32F x)
// cond: !config.use387
- // result: (PXOR x (MOVSSconst <fe.TypeFloat32()> [f2i(math.Copysign(0, -1))]))
+ // result: (PXOR x (MOVSSconst <types.Float32> [f2i(math.Copysign(0, -1))]))
for {
x := v.Args[0]
if !(!config.use387) {
}
v.reset(Op386PXOR)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, Op386MOVSSconst, fe.TypeFloat32())
+ v0 := b.NewValue0(v.Pos, Op386MOVSSconst, types.Float32)
v0.AuxInt = f2i(math.Copysign(0, -1))
v.AddArg(v0)
return true
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neg64F x)
// cond: !config.use387
- // result: (PXOR x (MOVSDconst <fe.TypeFloat64()> [f2i(math.Copysign(0, -1))]))
+ // result: (PXOR x (MOVSDconst <types.Float64> [f2i(math.Copysign(0, -1))]))
for {
x := v.Args[0]
if !(!config.use387) {
}
v.reset(Op386PXOR)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, Op386MOVSDconst, fe.TypeFloat64())
+ v0 := b.NewValue0(v.Pos, Op386MOVSDconst, types.Float64)
v0.AuxInt = f2i(math.Copysign(0, -1))
v.AddArg(v0)
return true
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zero [0] _ mem)
// cond:
// result: mem
}
v.reset(OpZero)
v.AuxInt = s - s%4
- v0 := b.NewValue0(v.Pos, Op386ADDLconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, Op386ADDLconst, types.UInt32)
v0.AuxInt = s % 4
v0.AddArg(destptr)
v.AddArg(v0)
v.reset(Op386DUFFZERO)
v.AuxInt = 1 * (128 - s/4)
v.AddArg(destptr)
- v0 := b.NewValue0(v.Pos, Op386MOVLconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, Op386MOVLconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(mem)
}
v.reset(Op386REPSTOSL)
v.AddArg(destptr)
- v0 := b.NewValue0(v.Pos, Op386MOVLconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, Op386MOVLconst, types.UInt32)
v0.AuxInt = s / 4
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, Op386MOVLconst, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, Op386MOVLconst, types.UInt32)
v1.AuxInt = 0
v.AddArg(v1)
v.AddArg(mem)
_ = config
fe := b.Func.fe
_ = fe
+ types := &config.Types
+ _ = types
switch b.Kind {
case Block386EQ:
// match: (EQ (InvertFlags cmp) yes no)
func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (MOVLstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVLstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
v.AuxInt = ValAndOff(a).Off()
v.Aux = s
v.AddArg(p)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v0.AuxInt = ValAndOff(a).Val()&0xffffffff | ValAndOff(c).Val()<<32
v.AddArg(v0)
v.AddArg(mem)
func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (MOVLstoreconstidx1 [c] {sym} ptr (SHLQconst [2] idx) mem)
// cond:
// result: (MOVLstoreconstidx4 [c] {sym} ptr idx mem)
v.Aux = s
v.AddArg(p)
v.AddArg(i)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v0.AuxInt = ValAndOff(a).Val()&0xffffffff | ValAndOff(c).Val()<<32
v.AddArg(v0)
v.AddArg(mem)
func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (MOVLstoreconstidx4 [x] {sym} (ADDQconst [c] ptr) idx mem)
// cond:
// result: (MOVLstoreconstidx4 [ValAndOff(x).add(c)] {sym} ptr idx mem)
v0.AuxInt = 2
v0.AddArg(i)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v1.AuxInt = ValAndOff(a).Val()&0xffffffff | ValAndOff(c).Val()<<32
v.AddArg(v1)
v.AddArg(mem)
func rewriteValueAMD64_OpAMD64ORL(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL x (MOVLconst [c]))
// cond:
// result: (ORLconst [c] x)
break
}
b = mergePoint(b, x0, x1)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, types.UInt16)
v.reset(OpCopy)
v.AddArg(v0)
v0.AuxInt = i
break
}
b = mergePoint(b, x0, x1, x2)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, types.UInt32)
v.reset(OpCopy)
v.AddArg(v0)
v0.AuxInt = i
v.reset(OpCopy)
v.AddArg(v0)
v0.AuxInt = 8
- v1 := b.NewValue0(v.Pos, OpAMD64MOVWload, fe.TypeUInt16())
+ v1 := b.NewValue0(v.Pos, OpAMD64MOVWload, types.UInt16)
v1.AuxInt = i - 1
v1.Aux = s
v1.AddArg(p)
v0 := b.NewValue0(v.Pos, OpAMD64BSWAPL, v.Type)
v.reset(OpCopy)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpAMD64MOVLload, types.UInt32)
v1.AuxInt = i1 - 2
v1.Aux = s
v1.AddArg(p)
func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (ORQconst [c] x)
break
}
b = mergePoint(b, x0, x1, x2, x3, x4, x5, x6, x7)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, types.UInt64)
v.reset(OpCopy)
v.AddArg(v0)
v0.AuxInt = i
v0 := b.NewValue0(v.Pos, OpAMD64BSWAPQ, v.Type)
v.reset(OpCopy)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpAMD64MOVQload, types.UInt64)
v1.AuxInt = i - 7
v1.Aux = s
v1.AddArg(p)
func rewriteValueAMD64_OpAtomicAdd32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (AtomicAdd32 ptr val mem)
// cond:
// result: (AddTupleFirst32 (XADDLlock val ptr mem) val)
val := v.Args[1]
mem := v.Args[2]
v.reset(OpAMD64AddTupleFirst32)
- v0 := b.NewValue0(v.Pos, OpAMD64XADDLlock, MakeTuple(fe.TypeUInt32(), TypeMem))
+ v0 := b.NewValue0(v.Pos, OpAMD64XADDLlock, MakeTuple(types.UInt32, TypeMem))
v0.AddArg(val)
v0.AddArg(ptr)
v0.AddArg(mem)
func rewriteValueAMD64_OpAtomicAdd64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (AtomicAdd64 ptr val mem)
// cond:
// result: (AddTupleFirst64 (XADDQlock val ptr mem) val)
val := v.Args[1]
mem := v.Args[2]
v.reset(OpAMD64AddTupleFirst64)
- v0 := b.NewValue0(v.Pos, OpAMD64XADDQlock, MakeTuple(fe.TypeUInt64(), TypeMem))
+ v0 := b.NewValue0(v.Pos, OpAMD64XADDQlock, MakeTuple(types.UInt64, TypeMem))
v0.AddArg(val)
v0.AddArg(ptr)
v0.AddArg(mem)
func rewriteValueAMD64_OpAtomicStore32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (AtomicStore32 ptr val mem)
// cond:
- // result: (Select1 (XCHGL <MakeTuple(fe.TypeUInt32(),TypeMem)> val ptr mem))
+ // result: (Select1 (XCHGL <MakeTuple(types.UInt32,TypeMem)> val ptr mem))
for {
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpAMD64XCHGL, MakeTuple(fe.TypeUInt32(), TypeMem))
+ v0 := b.NewValue0(v.Pos, OpAMD64XCHGL, MakeTuple(types.UInt32, TypeMem))
v0.AddArg(val)
v0.AddArg(ptr)
v0.AddArg(mem)
func rewriteValueAMD64_OpAtomicStore64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (AtomicStore64 ptr val mem)
// cond:
- // result: (Select1 (XCHGQ <MakeTuple(fe.TypeUInt64(),TypeMem)> val ptr mem))
+ // result: (Select1 (XCHGQ <MakeTuple(types.UInt64,TypeMem)> val ptr mem))
for {
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpAMD64XCHGQ, MakeTuple(fe.TypeUInt64(), TypeMem))
+ v0 := b.NewValue0(v.Pos, OpAMD64XCHGQ, MakeTuple(types.UInt64, TypeMem))
v0.AddArg(val)
v0.AddArg(ptr)
v0.AddArg(mem)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (AtomicStorePtrNoWB ptr val mem)
// cond: config.PtrSize == 8
- // result: (Select1 (XCHGQ <MakeTuple(fe.TypeBytePtr(),TypeMem)> val ptr mem))
+ // result: (Select1 (XCHGQ <MakeTuple(types.BytePtr,TypeMem)> val ptr mem))
for {
ptr := v.Args[0]
val := v.Args[1]
break
}
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpAMD64XCHGQ, MakeTuple(fe.TypeBytePtr(), TypeMem))
+ v0 := b.NewValue0(v.Pos, OpAMD64XCHGQ, MakeTuple(types.BytePtr, TypeMem))
v0.AddArg(val)
v0.AddArg(ptr)
v0.AddArg(mem)
}
// match: (AtomicStorePtrNoWB ptr val mem)
// cond: config.PtrSize == 4
- // result: (Select1 (XCHGL <MakeTuple(fe.TypeBytePtr(),TypeMem)> val ptr mem))
+ // result: (Select1 (XCHGL <MakeTuple(types.BytePtr,TypeMem)> val ptr mem))
for {
ptr := v.Args[0]
val := v.Args[1]
break
}
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpAMD64XCHGL, MakeTuple(fe.TypeBytePtr(), TypeMem))
+ v0 := b.NewValue0(v.Pos, OpAMD64XCHGL, MakeTuple(types.BytePtr, TypeMem))
v0.AddArg(val)
v0.AddArg(ptr)
v0.AddArg(mem)
func rewriteValueAMD64_OpBitLen32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (BitLen32 x)
// cond:
- // result: (BitLen64 (MOVLQZX <fe.TypeUInt64()> x))
+ // result: (BitLen64 (MOVLQZX <types.UInt64> x))
for {
x := v.Args[0]
v.reset(OpBitLen64)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVLQZX, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVLQZX, types.UInt64)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValueAMD64_OpBitLen64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (BitLen64 <t> x)
// cond:
// result: (ADDQconst [1] (CMOVQEQ <t> (Select0 <t> (BSRQ x)) (MOVQconst <t> [-1]) (Select1 <TypeFlags> (BSRQ x))))
v.AuxInt = 1
v0 := b.NewValue0(v.Pos, OpAMD64CMOVQEQ, t)
v1 := b.NewValue0(v.Pos, OpSelect0, t)
- v2 := b.NewValue0(v.Pos, OpAMD64BSRQ, MakeTuple(fe.TypeUInt64(), TypeFlags))
+ v2 := b.NewValue0(v.Pos, OpAMD64BSRQ, MakeTuple(types.UInt64, TypeFlags))
v2.AddArg(x)
v1.AddArg(v2)
v0.AddArg(v1)
v3.AuxInt = -1
v0.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpSelect1, TypeFlags)
- v5 := b.NewValue0(v.Pos, OpAMD64BSRQ, MakeTuple(fe.TypeUInt64(), TypeFlags))
+ v5 := b.NewValue0(v.Pos, OpAMD64BSRQ, MakeTuple(types.UInt64, TypeFlags))
v5.AddArg(x)
v4.AddArg(v5)
v0.AddArg(v4)
func rewriteValueAMD64_OpCtz32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Ctz32 x)
// cond:
- // result: (Select0 (BSFQ (ORQ <fe.TypeUInt64()> (MOVQconst [1<<32]) x)))
+ // result: (Select0 (BSFQ (ORQ <types.UInt64> (MOVQconst [1<<32]) x)))
for {
x := v.Args[0]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(fe.TypeUInt64(), TypeFlags))
- v1 := b.NewValue0(v.Pos, OpAMD64ORQ, fe.TypeUInt64())
- v2 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(types.UInt64, TypeFlags))
+ v1 := b.NewValue0(v.Pos, OpAMD64ORQ, types.UInt64)
+ v2 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v2.AuxInt = 1 << 32
v1.AddArg(v2)
v1.AddArg(x)
func rewriteValueAMD64_OpCtz64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Ctz64 <t> x)
// cond:
// result: (CMOVQEQ (Select0 <t> (BSFQ x)) (MOVQconst <t> [64]) (Select1 <TypeFlags> (BSFQ x)))
x := v.Args[0]
v.reset(OpAMD64CMOVQEQ)
v0 := b.NewValue0(v.Pos, OpSelect0, t)
- v1 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(fe.TypeUInt64(), TypeFlags))
+ v1 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(types.UInt64, TypeFlags))
v1.AddArg(x)
v0.AddArg(v1)
v.AddArg(v0)
v2.AuxInt = 64
v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpSelect1, TypeFlags)
- v4 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(fe.TypeUInt64(), TypeFlags))
+ v4 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(types.UInt64, TypeFlags))
v4.AddArg(x)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueAMD64_OpDiv16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div16 x y)
// cond:
// result: (Select0 (DIVW x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(fe.TypeInt16(), fe.TypeInt16()))
+ v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(types.Int16, types.Int16))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueAMD64_OpDiv16u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div16u x y)
// cond:
// result: (Select0 (DIVWU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(fe.TypeUInt16(), fe.TypeUInt16()))
+ v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(types.UInt16, types.UInt16))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueAMD64_OpDiv32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div32 x y)
// cond:
// result: (Select0 (DIVL x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpAMD64DIVL, MakeTuple(fe.TypeInt32(), fe.TypeInt32()))
+ v0 := b.NewValue0(v.Pos, OpAMD64DIVL, MakeTuple(types.Int32, types.Int32))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueAMD64_OpDiv32u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div32u x y)
// cond:
// result: (Select0 (DIVLU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpAMD64DIVLU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
+ v0 := b.NewValue0(v.Pos, OpAMD64DIVLU, MakeTuple(types.UInt32, types.UInt32))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueAMD64_OpDiv64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div64 x y)
// cond:
// result: (Select0 (DIVQ x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpAMD64DIVQ, MakeTuple(fe.TypeInt64(), fe.TypeInt64()))
+ v0 := b.NewValue0(v.Pos, OpAMD64DIVQ, MakeTuple(types.Int64, types.Int64))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueAMD64_OpDiv64u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div64u x y)
// cond:
// result: (Select0 (DIVQU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpAMD64DIVQU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64()))
+ v0 := b.NewValue0(v.Pos, OpAMD64DIVQU, MakeTuple(types.UInt64, types.UInt64))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueAMD64_OpDiv8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8 x y)
// cond:
// result: (Select0 (DIVW (SignExt8to16 x) (SignExt8to16 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(fe.TypeInt16(), fe.TypeInt16()))
- v1 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16())
+ v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(types.Int16, types.Int16))
+ v1 := b.NewValue0(v.Pos, OpSignExt8to16, types.Int16)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to16, types.Int16)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueAMD64_OpDiv8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8u x y)
// cond:
// result: (Select0 (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(fe.TypeUInt16(), fe.TypeUInt16()))
- v1 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(types.UInt16, types.UInt16))
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to16, types.UInt16)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to16, types.UInt16)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueAMD64_OpMod16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod16 x y)
// cond:
// result: (Select1 (DIVW x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(fe.TypeInt16(), fe.TypeInt16()))
+ v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(types.Int16, types.Int16))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueAMD64_OpMod16u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod16u x y)
// cond:
// result: (Select1 (DIVWU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(fe.TypeUInt16(), fe.TypeUInt16()))
+ v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(types.UInt16, types.UInt16))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueAMD64_OpMod32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod32 x y)
// cond:
// result: (Select1 (DIVL x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpAMD64DIVL, MakeTuple(fe.TypeInt32(), fe.TypeInt32()))
+ v0 := b.NewValue0(v.Pos, OpAMD64DIVL, MakeTuple(types.Int32, types.Int32))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueAMD64_OpMod32u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod32u x y)
// cond:
// result: (Select1 (DIVLU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpAMD64DIVLU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
+ v0 := b.NewValue0(v.Pos, OpAMD64DIVLU, MakeTuple(types.UInt32, types.UInt32))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueAMD64_OpMod64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod64 x y)
// cond:
// result: (Select1 (DIVQ x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpAMD64DIVQ, MakeTuple(fe.TypeInt64(), fe.TypeInt64()))
+ v0 := b.NewValue0(v.Pos, OpAMD64DIVQ, MakeTuple(types.Int64, types.Int64))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueAMD64_OpMod64u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod64u x y)
// cond:
// result: (Select1 (DIVQU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpAMD64DIVQU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64()))
+ v0 := b.NewValue0(v.Pos, OpAMD64DIVQU, MakeTuple(types.UInt64, types.UInt64))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueAMD64_OpMod8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod8 x y)
// cond:
// result: (Select1 (DIVW (SignExt8to16 x) (SignExt8to16 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(fe.TypeInt16(), fe.TypeInt16()))
- v1 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16())
+ v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(types.Int16, types.Int16))
+ v1 := b.NewValue0(v.Pos, OpSignExt8to16, types.Int16)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to16, types.Int16)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueAMD64_OpMod8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod8u x y)
// cond:
// result: (Select1 (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(fe.TypeUInt16(), fe.TypeUInt16()))
- v1 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(types.UInt16, types.UInt16))
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to16, types.UInt16)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to16, types.UInt16)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [0] _ _ mem)
// cond:
// result: mem
mem := v.Args[2]
v.reset(OpAMD64MOVBstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, types.UInt8)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
mem := v.Args[2]
v.reset(OpAMD64MOVWstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, types.UInt16)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
mem := v.Args[2]
v.reset(OpAMD64MOVLstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, types.UInt32)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
mem := v.Args[2]
v.reset(OpAMD64MOVQstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, types.UInt64)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v.reset(OpAMD64MOVBstore)
v.AuxInt = 2
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, types.UInt8)
v0.AuxInt = 2
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVWstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpAMD64MOVWload, fe.TypeUInt16())
+ v2 := b.NewValue0(v.Pos, OpAMD64MOVWload, types.UInt16)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpAMD64MOVBstore)
v.AuxInt = 4
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, types.UInt8)
v0.AuxInt = 4
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVLstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, types.UInt32)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpAMD64MOVWstore)
v.AuxInt = 4
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, types.UInt16)
v0.AuxInt = 4
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVLstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, types.UInt32)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpAMD64MOVLstore)
v.AuxInt = 3
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, types.UInt32)
v0.AuxInt = 3
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVLstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, types.UInt32)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpAMD64MOVQstore)
v.AuxInt = s - 8
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, types.UInt64)
v0.AuxInt = s - 8
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVQstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpAMD64MOVQload, types.UInt64)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpAMD64MOVQstore, TypeMem)
v2.AddArg(dst)
- v3 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpAMD64MOVQload, types.UInt64)
v3.AddArg(src)
v3.AddArg(mem)
v2.AddArg(v3)
v.reset(OpAMD64REPMOVSQ)
v.AddArg(dst)
v.AddArg(src)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v0.AuxInt = s / 8
v.AddArg(v0)
v.AddArg(mem)
func rewriteValueAMD64_OpNeg32F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neg32F x)
// cond:
- // result: (PXOR x (MOVSSconst <fe.TypeFloat32()> [f2i(math.Copysign(0, -1))]))
+ // result: (PXOR x (MOVSSconst <types.Float32> [f2i(math.Copysign(0, -1))]))
for {
x := v.Args[0]
v.reset(OpAMD64PXOR)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVSSconst, fe.TypeFloat32())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVSSconst, types.Float32)
v0.AuxInt = f2i(math.Copysign(0, -1))
v.AddArg(v0)
return true
func rewriteValueAMD64_OpNeg64F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neg64F x)
// cond:
- // result: (PXOR x (MOVSDconst <fe.TypeFloat64()> [f2i(math.Copysign(0, -1))]))
+ // result: (PXOR x (MOVSDconst <types.Float64> [f2i(math.Copysign(0, -1))]))
for {
x := v.Args[0]
v.reset(OpAMD64PXOR)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVSDconst, fe.TypeFloat64())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVSDconst, types.Float64)
v0.AuxInt = f2i(math.Copysign(0, -1))
v.AddArg(v0)
return true
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (OffPtr [off] ptr)
// cond: config.PtrSize == 8 && is32Bit(off)
// result: (ADDQconst [off] ptr)
break
}
v.reset(OpAMD64ADDQ)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v0.AuxInt = off
v.AddArg(v0)
v.AddArg(ptr)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zero [0] _ mem)
// cond:
// result: mem
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVQstore, TypeMem)
v1.AddArg(destptr)
- v2 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v1.AddArg(mem)
}
v.reset(OpAMD64REPSTOSQ)
v.AddArg(destptr)
- v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v0.AuxInt = s / 8
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v1.AuxInt = 0
v.AddArg(v1)
v.AddArg(mem)
_ = config
fe := b.Func.fe
_ = fe
+ types := &config.Types
+ _ = types
switch b.Kind {
case BlockAMD64EQ:
// match: (EQ (TESTL (SHLL (MOVLconst [1]) x) y))
func rewriteValueARM_OpDiv16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div16 x y)
// cond:
// result: (Div32 (SignExt16to32 x) (SignExt16to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpDiv32)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueARM_OpDiv16u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div16u x y)
// cond:
// result: (Div32u (ZeroExt16to32 x) (ZeroExt16to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpDiv32u)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div32 x y)
// cond:
- // result: (SUB (XOR <fe.TypeUInt32()> (Select0 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} (SUB <fe.TypeUInt32()> (XOR x <fe.TypeUInt32()> (Signmask x)) (Signmask x)) (SUB <fe.TypeUInt32()> (XOR y <fe.TypeUInt32()> (Signmask y)) (Signmask y)))) (Signmask (XOR <fe.TypeUInt32()> x y))) (Signmask (XOR <fe.TypeUInt32()> x y)))
+ // result: (SUB (XOR <types.UInt32> (Select0 <types.UInt32> (CALLudiv {config.ctxt.Lookup("udiv", 0)} (SUB <types.UInt32> (XOR x <types.UInt32> (Signmask x)) (Signmask x)) (SUB <types.UInt32> (XOR y <types.UInt32> (Signmask y)) (Signmask y)))) (Signmask (XOR <types.UInt32> x y))) (Signmask (XOR <types.UInt32> x y)))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpARMSUB)
- v0 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpSelect0, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpARMCALLudiv, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
+ v0 := b.NewValue0(v.Pos, OpARMXOR, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpSelect0, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpARMCALLudiv, MakeTuple(types.UInt32, types.UInt32))
v2.Aux = config.ctxt.Lookup("udiv", 0)
- v3 := b.NewValue0(v.Pos, OpARMSUB, fe.TypeUInt32())
- v4 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpARMSUB, types.UInt32)
+ v4 := b.NewValue0(v.Pos, OpARMXOR, types.UInt32)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32())
+ v5 := b.NewValue0(v.Pos, OpSignmask, types.Int32)
v5.AddArg(x)
v4.AddArg(v5)
v3.AddArg(v4)
- v6 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32())
+ v6 := b.NewValue0(v.Pos, OpSignmask, types.Int32)
v6.AddArg(x)
v3.AddArg(v6)
v2.AddArg(v3)
- v7 := b.NewValue0(v.Pos, OpARMSUB, fe.TypeUInt32())
- v8 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpARMSUB, types.UInt32)
+ v8 := b.NewValue0(v.Pos, OpARMXOR, types.UInt32)
v8.AddArg(y)
- v9 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32())
+ v9 := b.NewValue0(v.Pos, OpSignmask, types.Int32)
v9.AddArg(y)
v8.AddArg(v9)
v7.AddArg(v8)
- v10 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32())
+ v10 := b.NewValue0(v.Pos, OpSignmask, types.Int32)
v10.AddArg(y)
v7.AddArg(v10)
v2.AddArg(v7)
v1.AddArg(v2)
v0.AddArg(v1)
- v11 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32())
- v12 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeUInt32())
+ v11 := b.NewValue0(v.Pos, OpSignmask, types.Int32)
+ v12 := b.NewValue0(v.Pos, OpARMXOR, types.UInt32)
v12.AddArg(x)
v12.AddArg(y)
v11.AddArg(v12)
v0.AddArg(v11)
v.AddArg(v0)
- v13 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32())
- v14 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeUInt32())
+ v13 := b.NewValue0(v.Pos, OpSignmask, types.Int32)
+ v14 := b.NewValue0(v.Pos, OpARMXOR, types.UInt32)
v14.AddArg(x)
v14.AddArg(y)
v13.AddArg(v14)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div32u x y)
// cond:
- // result: (Select0 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y))
+ // result: (Select0 <types.UInt32> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v.Type = fe.TypeUInt32()
- v0 := b.NewValue0(v.Pos, OpARMCALLudiv, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
+ v.Type = types.UInt32
+ v0 := b.NewValue0(v.Pos, OpARMCALLudiv, MakeTuple(types.UInt32, types.UInt32))
v0.Aux = config.ctxt.Lookup("udiv", 0)
v0.AddArg(x)
v0.AddArg(y)
func rewriteValueARM_OpDiv8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8 x y)
// cond:
// result: (Div32 (SignExt8to32 x) (SignExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpDiv32)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueARM_OpDiv8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8u x y)
// cond:
// result: (Div32u (ZeroExt8to32 x) (ZeroExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpDiv32u)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueARM_OpEq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq16 x y)
// cond:
// result: (Equal (CMP (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpARMEqual)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpEq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq8 x y)
// cond:
// result: (Equal (CMP (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpARMEqual)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpEqB(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (EqB x y)
// cond:
- // result: (XORconst [1] (XOR <fe.TypeBool()> x y))
+ // result: (XORconst [1] (XOR <types.Bool> x y))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpARMXORconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeBool())
+ v0 := b.NewValue0(v.Pos, OpARMXOR, types.Bool)
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueARM_OpGeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq16 x y)
// cond:
// result: (GreaterEqual (CMP (SignExt16to32 x) (SignExt16to32 y)))
y := v.Args[1]
v.reset(OpARMGreaterEqual)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpGeq16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq16U x y)
// cond:
// result: (GreaterEqualU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpARMGreaterEqualU)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpGeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq8 x y)
// cond:
// result: (GreaterEqual (CMP (SignExt8to32 x) (SignExt8to32 y)))
y := v.Args[1]
v.reset(OpARMGreaterEqual)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpGeq8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq8U x y)
// cond:
// result: (GreaterEqualU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpARMGreaterEqualU)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpGreater16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater16 x y)
// cond:
// result: (GreaterThan (CMP (SignExt16to32 x) (SignExt16to32 y)))
y := v.Args[1]
v.reset(OpARMGreaterThan)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpGreater16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater16U x y)
// cond:
// result: (GreaterThanU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpARMGreaterThanU)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpGreater8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater8 x y)
// cond:
// result: (GreaterThan (CMP (SignExt8to32 x) (SignExt8to32 y)))
y := v.Args[1]
v.reset(OpARMGreaterThan)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpGreater8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater8U x y)
// cond:
// result: (GreaterThanU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpARMGreaterThanU)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpLeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq16 x y)
// cond:
// result: (LessEqual (CMP (SignExt16to32 x) (SignExt16to32 y)))
y := v.Args[1]
v.reset(OpARMLessEqual)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpLeq16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq16U x y)
// cond:
// result: (LessEqualU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpARMLessEqualU)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpLeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq8 x y)
// cond:
// result: (LessEqual (CMP (SignExt8to32 x) (SignExt8to32 y)))
y := v.Args[1]
v.reset(OpARMLessEqual)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpLeq8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq8U x y)
// cond:
// result: (LessEqualU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpARMLessEqualU)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpLess16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less16 x y)
// cond:
// result: (LessThan (CMP (SignExt16to32 x) (SignExt16to32 y)))
y := v.Args[1]
v.reset(OpARMLessThan)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpLess16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less16U x y)
// cond:
// result: (LessThanU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpARMLessThanU)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpLess8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less8 x y)
// cond:
// result: (LessThan (CMP (SignExt8to32 x) (SignExt8to32 y)))
y := v.Args[1]
v.reset(OpARMLessThan)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpLess8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less8U x y)
// cond:
// result: (LessThanU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpARMLessThanU)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpLsh16x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x16 x y)
// cond:
// result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0])
v.AuxInt = 0
v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v2 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags)
v2.AuxInt = 256
- v3 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v3.AddArg(y)
v2.AddArg(v3)
v.AddArg(v2)
func rewriteValueARM_OpLsh16x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x8 x y)
// cond:
// result: (SLL x (ZeroExt8to32 y))
y := v.Args[1]
v.reset(OpARMSLL)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(y)
v.AddArg(v0)
return true
func rewriteValueARM_OpLsh32x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x16 x y)
// cond:
// result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0])
v.AuxInt = 0
v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v2 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags)
v2.AuxInt = 256
- v3 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v3.AddArg(y)
v2.AddArg(v3)
v.AddArg(v2)
func rewriteValueARM_OpLsh32x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x8 x y)
// cond:
// result: (SLL x (ZeroExt8to32 y))
y := v.Args[1]
v.reset(OpARMSLL)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(y)
v.AddArg(v0)
return true
func rewriteValueARM_OpLsh8x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x16 x y)
// cond:
// result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0])
v.AuxInt = 0
v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v2 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags)
v2.AuxInt = 256
- v3 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v3.AddArg(y)
v2.AddArg(v3)
v.AddArg(v2)
func rewriteValueARM_OpLsh8x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x8 x y)
// cond:
// result: (SLL x (ZeroExt8to32 y))
y := v.Args[1]
v.reset(OpARMSLL)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(y)
v.AddArg(v0)
return true
func rewriteValueARM_OpMod16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod16 x y)
// cond:
// result: (Mod32 (SignExt16to32 x) (SignExt16to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMod32)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueARM_OpMod16u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod16u x y)
// cond:
// result: (Mod32u (ZeroExt16to32 x) (ZeroExt16to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMod32u)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod32 x y)
// cond:
- // result: (SUB (XOR <fe.TypeUInt32()> (Select1 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} (SUB <fe.TypeUInt32()> (XOR <fe.TypeUInt32()> x (Signmask x)) (Signmask x)) (SUB <fe.TypeUInt32()> (XOR <fe.TypeUInt32()> y (Signmask y)) (Signmask y)))) (Signmask x)) (Signmask x))
+ // result: (SUB (XOR <types.UInt32> (Select1 <types.UInt32> (CALLudiv {config.ctxt.Lookup("udiv", 0)} (SUB <types.UInt32> (XOR <types.UInt32> x (Signmask x)) (Signmask x)) (SUB <types.UInt32> (XOR <types.UInt32> y (Signmask y)) (Signmask y)))) (Signmask x)) (Signmask x))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpARMSUB)
- v0 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpSelect1, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpARMCALLudiv, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
+ v0 := b.NewValue0(v.Pos, OpARMXOR, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpSelect1, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpARMCALLudiv, MakeTuple(types.UInt32, types.UInt32))
v2.Aux = config.ctxt.Lookup("udiv", 0)
- v3 := b.NewValue0(v.Pos, OpARMSUB, fe.TypeUInt32())
- v4 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpARMSUB, types.UInt32)
+ v4 := b.NewValue0(v.Pos, OpARMXOR, types.UInt32)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32())
+ v5 := b.NewValue0(v.Pos, OpSignmask, types.Int32)
v5.AddArg(x)
v4.AddArg(v5)
v3.AddArg(v4)
- v6 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32())
+ v6 := b.NewValue0(v.Pos, OpSignmask, types.Int32)
v6.AddArg(x)
v3.AddArg(v6)
v2.AddArg(v3)
- v7 := b.NewValue0(v.Pos, OpARMSUB, fe.TypeUInt32())
- v8 := b.NewValue0(v.Pos, OpARMXOR, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpARMSUB, types.UInt32)
+ v8 := b.NewValue0(v.Pos, OpARMXOR, types.UInt32)
v8.AddArg(y)
- v9 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32())
+ v9 := b.NewValue0(v.Pos, OpSignmask, types.Int32)
v9.AddArg(y)
v8.AddArg(v9)
v7.AddArg(v8)
- v10 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32())
+ v10 := b.NewValue0(v.Pos, OpSignmask, types.Int32)
v10.AddArg(y)
v7.AddArg(v10)
v2.AddArg(v7)
v1.AddArg(v2)
v0.AddArg(v1)
- v11 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32())
+ v11 := b.NewValue0(v.Pos, OpSignmask, types.Int32)
v11.AddArg(x)
v0.AddArg(v11)
v.AddArg(v0)
- v12 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32())
+ v12 := b.NewValue0(v.Pos, OpSignmask, types.Int32)
v12.AddArg(x)
v.AddArg(v12)
return true
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod32u x y)
// cond:
- // result: (Select1 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y))
+ // result: (Select1 <types.UInt32> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v.Type = fe.TypeUInt32()
- v0 := b.NewValue0(v.Pos, OpARMCALLudiv, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
+ v.Type = types.UInt32
+ v0 := b.NewValue0(v.Pos, OpARMCALLudiv, MakeTuple(types.UInt32, types.UInt32))
v0.Aux = config.ctxt.Lookup("udiv", 0)
v0.AddArg(x)
v0.AddArg(y)
func rewriteValueARM_OpMod8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod8 x y)
// cond:
// result: (Mod32 (SignExt8to32 x) (SignExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMod32)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueARM_OpMod8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod8u x y)
// cond:
// result: (Mod32u (ZeroExt8to32 x) (ZeroExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMod32u)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [0] _ _ mem)
// cond:
// result: mem
mem := v.Args[2]
v.reset(OpARMMOVBstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpARMMOVBUload, types.UInt8)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
}
v.reset(OpARMMOVHstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARMMOVHUload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpARMMOVHUload, types.UInt16)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v.reset(OpARMMOVBstore)
v.AuxInt = 1
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpARMMOVBUload, types.UInt8)
v0.AuxInt = 1
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8())
+ v2 := b.NewValue0(v.Pos, OpARMMOVBUload, types.UInt8)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
}
v.reset(OpARMMOVWstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARMMOVWload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARMMOVWload, types.UInt32)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v.reset(OpARMMOVHstore)
v.AuxInt = 2
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARMMOVHUload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpARMMOVHUload, types.UInt16)
v0.AuxInt = 2
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARMMOVHstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpARMMOVHUload, fe.TypeUInt16())
+ v2 := b.NewValue0(v.Pos, OpARMMOVHUload, types.UInt16)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpARMMOVBstore)
v.AuxInt = 3
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpARMMOVBUload, types.UInt8)
v0.AuxInt = 3
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem)
v1.AuxInt = 2
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8())
+ v2 := b.NewValue0(v.Pos, OpARMMOVBUload, types.UInt8)
v2.AuxInt = 2
v2.AddArg(src)
v2.AddArg(mem)
v3 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem)
v3.AuxInt = 1
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8())
+ v4 := b.NewValue0(v.Pos, OpARMMOVBUload, types.UInt8)
v4.AuxInt = 1
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
v5 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem)
v5.AddArg(dst)
- v6 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8())
+ v6 := b.NewValue0(v.Pos, OpARMMOVBUload, types.UInt8)
v6.AddArg(src)
v6.AddArg(mem)
v5.AddArg(v6)
v.reset(OpARMMOVBstore)
v.AuxInt = 2
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpARMMOVBUload, types.UInt8)
v0.AuxInt = 2
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem)
v1.AuxInt = 1
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8())
+ v2 := b.NewValue0(v.Pos, OpARMMOVBUload, types.UInt8)
v2.AuxInt = 1
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem)
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpARMMOVBUload, fe.TypeUInt8())
+ v4 := b.NewValue0(v.Pos, OpARMMOVBUload, types.UInt8)
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
func rewriteValueARM_OpNeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq16 x y)
// cond:
// result: (NotEqual (CMP (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpARMNotEqual)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpNeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq8 x y)
// cond:
// result: (NotEqual (CMP (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpARMNotEqual)
v0 := b.NewValue0(v.Pos, OpARMCMP, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM_OpRsh16Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux16 x y)
// cond:
// result: (CMOVWHSconst (SRL <x.Type> (ZeroExt16to32 x) (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0])
v.reset(OpARMCMOVWHSconst)
v.AuxInt = 0
v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
v3 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags)
v3.AuxInt = 256
- v4 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM_OpRsh16Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux32 x y)
// cond:
// result: (CMOVWHSconst (SRL <x.Type> (ZeroExt16to32 x) y) (CMPconst [256] y) [0])
v.reset(OpARMCMOVWHSconst)
v.AuxInt = 0
v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
v0.AddArg(y)
func rewriteValueARM_OpRsh16Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux64 x (Const64 [c]))
// cond: uint64(c) < 16
- // result: (SRLconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16])
+ // result: (SRLconst (SLLconst <types.UInt32> x [16]) [c+16])
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpARMSRLconst)
v.AuxInt = c + 16
- v0 := b.NewValue0(v.Pos, OpARMSLLconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARMSLLconst, types.UInt32)
v0.AuxInt = 16
v0.AddArg(x)
v.AddArg(v0)
func rewriteValueARM_OpRsh16Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux8 x y)
// cond:
// result: (SRL (ZeroExt16to32 x) (ZeroExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARMSRL)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueARM_OpRsh16x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x16 x y)
// cond:
// result: (SRAcond (SignExt16to32 x) (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARMSRAcond)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags)
v2.AuxInt = 256
- v3 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v3.AddArg(y)
v2.AddArg(v3)
v.AddArg(v2)
func rewriteValueARM_OpRsh16x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x32 x y)
// cond:
// result: (SRAcond (SignExt16to32 x) y (CMPconst [256] y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARMSRAcond)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
v.AddArg(y)
func rewriteValueARM_OpRsh16x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x64 x (Const64 [c]))
// cond: uint64(c) < 16
- // result: (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16])
+ // result: (SRAconst (SLLconst <types.UInt32> x [16]) [c+16])
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpARMSRAconst)
v.AuxInt = c + 16
- v0 := b.NewValue0(v.Pos, OpARMSLLconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARMSLLconst, types.UInt32)
v0.AuxInt = 16
v0.AddArg(x)
v.AddArg(v0)
}
// match: (Rsh16x64 x (Const64 [c]))
// cond: uint64(c) >= 16
- // result: (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [31])
+ // result: (SRAconst (SLLconst <types.UInt32> x [16]) [31])
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpARMSRAconst)
v.AuxInt = 31
- v0 := b.NewValue0(v.Pos, OpARMSLLconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARMSLLconst, types.UInt32)
v0.AuxInt = 16
v0.AddArg(x)
v.AddArg(v0)
func rewriteValueARM_OpRsh16x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x8 x y)
// cond:
// result: (SRA (SignExt16to32 x) (ZeroExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARMSRA)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueARM_OpRsh32Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux16 x y)
// cond:
// result: (CMOVWHSconst (SRL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0])
v.AuxInt = 0
v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v2 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags)
v2.AuxInt = 256
- v3 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v3.AddArg(y)
v2.AddArg(v3)
v.AddArg(v2)
func rewriteValueARM_OpRsh32Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux8 x y)
// cond:
// result: (SRL x (ZeroExt8to32 y))
y := v.Args[1]
v.reset(OpARMSRL)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(y)
v.AddArg(v0)
return true
func rewriteValueARM_OpRsh32x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x16 x y)
// cond:
// result: (SRAcond x (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpARMSRAcond)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(y)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags)
v1.AuxInt = 256
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v1.AddArg(v2)
v.AddArg(v1)
func rewriteValueARM_OpRsh32x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x8 x y)
// cond:
// result: (SRA x (ZeroExt8to32 y))
y := v.Args[1]
v.reset(OpARMSRA)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(y)
v.AddArg(v0)
return true
func rewriteValueARM_OpRsh8Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux16 x y)
// cond:
// result: (CMOVWHSconst (SRL <x.Type> (ZeroExt8to32 x) (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0])
v.reset(OpARMCMOVWHSconst)
v.AuxInt = 0
v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
v3 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags)
v3.AuxInt = 256
- v4 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM_OpRsh8Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux32 x y)
// cond:
// result: (CMOVWHSconst (SRL <x.Type> (ZeroExt8to32 x) y) (CMPconst [256] y) [0])
v.reset(OpARMCMOVWHSconst)
v.AuxInt = 0
v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
v0.AddArg(y)
func rewriteValueARM_OpRsh8Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux64 x (Const64 [c]))
// cond: uint64(c) < 8
- // result: (SRLconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24])
+ // result: (SRLconst (SLLconst <types.UInt32> x [24]) [c+24])
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpARMSRLconst)
v.AuxInt = c + 24
- v0 := b.NewValue0(v.Pos, OpARMSLLconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARMSLLconst, types.UInt32)
v0.AuxInt = 24
v0.AddArg(x)
v.AddArg(v0)
func rewriteValueARM_OpRsh8Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux8 x y)
// cond:
// result: (SRL (ZeroExt8to32 x) (ZeroExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARMSRL)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueARM_OpRsh8x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x16 x y)
// cond:
// result: (SRAcond (SignExt8to32 x) (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARMSRAcond)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpARMCMPconst, TypeFlags)
v2.AuxInt = 256
- v3 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v3.AddArg(y)
v2.AddArg(v3)
v.AddArg(v2)
func rewriteValueARM_OpRsh8x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x32 x y)
// cond:
// result: (SRAcond (SignExt8to32 x) y (CMPconst [256] y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARMSRAcond)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
v.AddArg(y)
func rewriteValueARM_OpRsh8x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x64 x (Const64 [c]))
// cond: uint64(c) < 8
- // result: (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24])
+ // result: (SRAconst (SLLconst <types.UInt32> x [24]) [c+24])
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpARMSRAconst)
v.AuxInt = c + 24
- v0 := b.NewValue0(v.Pos, OpARMSLLconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARMSLLconst, types.UInt32)
v0.AuxInt = 24
v0.AddArg(x)
v.AddArg(v0)
}
// match: (Rsh8x64 x (Const64 [c]))
// cond: uint64(c) >= 8
- // result: (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [31])
+ // result: (SRAconst (SLLconst <types.UInt32> x [24]) [31])
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpARMSRAconst)
v.AuxInt = 31
- v0 := b.NewValue0(v.Pos, OpARMSLLconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARMSLLconst, types.UInt32)
v0.AuxInt = 24
v0.AddArg(x)
v.AddArg(v0)
func rewriteValueARM_OpRsh8x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x8 x y)
// cond:
// result: (SRA (SignExt8to32 x) (ZeroExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARMSRA)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zero [0] _ mem)
// cond:
// result: mem
mem := v.Args[1]
v.reset(OpARMMOVBstore)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARMMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(mem)
}
v.reset(OpARMMOVHstore)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARMMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(mem)
v.reset(OpARMMOVBstore)
v.AuxInt = 1
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARMMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem)
v1.AuxInt = 0
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpARMMOVWconst, types.UInt32)
v2.AuxInt = 0
v1.AddArg(v2)
v1.AddArg(mem)
}
v.reset(OpARMMOVWstore)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARMMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(mem)
v.reset(OpARMMOVHstore)
v.AuxInt = 2
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARMMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARMMOVHstore, TypeMem)
v1.AuxInt = 0
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpARMMOVWconst, types.UInt32)
v2.AuxInt = 0
v1.AddArg(v2)
v1.AddArg(mem)
v.reset(OpARMMOVBstore)
v.AuxInt = 3
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARMMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem)
v1.AuxInt = 2
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpARMMOVWconst, types.UInt32)
v2.AuxInt = 0
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem)
v3.AuxInt = 1
v3.AddArg(ptr)
- v4 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpARMMOVWconst, types.UInt32)
v4.AuxInt = 0
v3.AddArg(v4)
v5 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem)
v5.AuxInt = 0
v5.AddArg(ptr)
- v6 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpARMMOVWconst, types.UInt32)
v6.AuxInt = 0
v5.AddArg(v6)
v5.AddArg(mem)
v.reset(OpARMMOVBstore)
v.AuxInt = 2
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARMMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem)
v1.AuxInt = 1
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpARMMOVWconst, types.UInt32)
v2.AuxInt = 0
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARMMOVBstore, TypeMem)
v3.AuxInt = 0
v3.AddArg(ptr)
- v4 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpARMMOVWconst, types.UInt32)
v4.AuxInt = 0
v3.AddArg(v4)
v3.AddArg(mem)
v.reset(OpARMDUFFZERO)
v.AuxInt = 4 * (128 - int64(s/4))
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARMMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(mem)
v0.AuxInt = s - moveSize(t.(Type).Alignment(), config)
v0.AddArg(ptr)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpARMMOVWconst, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpARMMOVWconst, types.UInt32)
v1.AuxInt = 0
v.AddArg(v1)
v.AddArg(mem)
func rewriteValueARM_OpZeromask(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zeromask x)
// cond:
- // result: (SRAconst (RSBshiftRL <fe.TypeInt32()> x x [1]) [31])
+ // result: (SRAconst (RSBshiftRL <types.Int32> x x [1]) [31])
for {
x := v.Args[0]
v.reset(OpARMSRAconst)
v.AuxInt = 31
- v0 := b.NewValue0(v.Pos, OpARMRSBshiftRL, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpARMRSBshiftRL, types.Int32)
v0.AuxInt = 1
v0.AddArg(x)
v0.AddArg(x)
_ = config
fe := b.Func.fe
_ = fe
+ types := &config.Types
+ _ = types
switch b.Kind {
case BlockARMEQ:
// match: (EQ (FlagEQ) yes no)
func rewriteValueARM64_OpBitLen64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (BitLen64 x)
// cond:
- // result: (SUB (MOVDconst [64]) (CLZ <fe.TypeInt()> x))
+ // result: (SUB (MOVDconst [64]) (CLZ <types.Int> x))
for {
x := v.Args[0]
v.reset(OpARM64SUB)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v0.AuxInt = 64
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpARM64CLZ, fe.TypeInt())
+ v1 := b.NewValue0(v.Pos, OpARM64CLZ, types.Int)
v1.AddArg(x)
v.AddArg(v1)
return true
func rewriteValueARM64_OpBitRev16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (BitRev16 x)
// cond:
- // result: (SRLconst [48] (RBIT <fe.TypeUInt64()> x))
+ // result: (SRLconst [48] (RBIT <types.UInt64> x))
for {
x := v.Args[0]
v.reset(OpARM64SRLconst)
v.AuxInt = 48
- v0 := b.NewValue0(v.Pos, OpARM64RBIT, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64RBIT, types.UInt64)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValueARM64_OpBitRev8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (BitRev8 x)
// cond:
- // result: (SRLconst [56] (RBIT <fe.TypeUInt64()> x))
+ // result: (SRLconst [56] (RBIT <types.UInt64> x))
for {
x := v.Args[0]
v.reset(OpARM64SRLconst)
v.AuxInt = 56
- v0 := b.NewValue0(v.Pos, OpARM64RBIT, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64RBIT, types.UInt64)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValueARM64_OpDiv16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div16 x y)
// cond:
// result: (DIVW (SignExt16to32 x) (SignExt16to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64DIVW)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueARM64_OpDiv16u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div16u x y)
// cond:
// result: (UDIVW (ZeroExt16to32 x) (ZeroExt16to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64UDIVW)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueARM64_OpDiv8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8 x y)
// cond:
// result: (DIVW (SignExt8to32 x) (SignExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64DIVW)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueARM64_OpDiv8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8u x y)
// cond:
// result: (UDIVW (ZeroExt8to32 x) (ZeroExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64UDIVW)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueARM64_OpEq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq16 x y)
// cond:
// result: (Equal (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpARM64Equal)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpEq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq8 x y)
// cond:
// result: (Equal (CMPW (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpARM64Equal)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpEqB(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (EqB x y)
// cond:
- // result: (XOR (MOVDconst [1]) (XOR <fe.TypeBool()> x y))
+ // result: (XOR (MOVDconst [1]) (XOR <types.Bool> x y))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64XOR)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpARM64XOR, fe.TypeBool())
+ v1 := b.NewValue0(v.Pos, OpARM64XOR, types.Bool)
v1.AddArg(x)
v1.AddArg(y)
v.AddArg(v1)
func rewriteValueARM64_OpGeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq16 x y)
// cond:
// result: (GreaterEqual (CMPW (SignExt16to32 x) (SignExt16to32 y)))
y := v.Args[1]
v.reset(OpARM64GreaterEqual)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpGeq16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq16U x y)
// cond:
// result: (GreaterEqualU (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpARM64GreaterEqualU)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpGeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq8 x y)
// cond:
// result: (GreaterEqual (CMPW (SignExt8to32 x) (SignExt8to32 y)))
y := v.Args[1]
v.reset(OpARM64GreaterEqual)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpGeq8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq8U x y)
// cond:
// result: (GreaterEqualU (CMPW (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpARM64GreaterEqualU)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpGreater16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater16 x y)
// cond:
// result: (GreaterThan (CMPW (SignExt16to32 x) (SignExt16to32 y)))
y := v.Args[1]
v.reset(OpARM64GreaterThan)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpGreater16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater16U x y)
// cond:
// result: (GreaterThanU (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpARM64GreaterThanU)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpGreater8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater8 x y)
// cond:
// result: (GreaterThan (CMPW (SignExt8to32 x) (SignExt8to32 y)))
y := v.Args[1]
v.reset(OpARM64GreaterThan)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpGreater8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater8U x y)
// cond:
// result: (GreaterThanU (CMPW (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpARM64GreaterThanU)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpHmul32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Hmul32 x y)
// cond:
- // result: (SRAconst (MULL <fe.TypeInt64()> x y) [32])
+ // result: (SRAconst (MULL <types.Int64> x y) [32])
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64SRAconst)
v.AuxInt = 32
- v0 := b.NewValue0(v.Pos, OpARM64MULL, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MULL, types.Int64)
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueARM64_OpHmul32u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Hmul32u x y)
// cond:
- // result: (SRAconst (UMULL <fe.TypeUInt64()> x y) [32])
+ // result: (SRAconst (UMULL <types.UInt64> x y) [32])
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64SRAconst)
v.AuxInt = 32
- v0 := b.NewValue0(v.Pos, OpARM64UMULL, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64UMULL, types.UInt64)
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueARM64_OpLeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq16 x y)
// cond:
// result: (LessEqual (CMPW (SignExt16to32 x) (SignExt16to32 y)))
y := v.Args[1]
v.reset(OpARM64LessEqual)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpLeq16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq16U x y)
// cond:
// result: (LessEqualU (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpARM64LessEqualU)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpLeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq8 x y)
// cond:
// result: (LessEqual (CMPW (SignExt8to32 x) (SignExt8to32 y)))
y := v.Args[1]
v.reset(OpARM64LessEqual)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpLeq8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq8U x y)
// cond:
// result: (LessEqualU (CMPW (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpARM64LessEqualU)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpLess16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less16 x y)
// cond:
// result: (LessThan (CMPW (SignExt16to32 x) (SignExt16to32 y)))
y := v.Args[1]
v.reset(OpARM64LessThan)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpLess16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less16U x y)
// cond:
// result: (LessThanU (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpARM64LessThanU)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpLess8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less8 x y)
// cond:
// result: (LessThan (CMPW (SignExt8to32 x) (SignExt8to32 y)))
y := v.Args[1]
v.reset(OpARM64LessThan)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpLess8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less8U x y)
// cond:
// result: (LessThanU (CMPW (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpARM64LessThanU)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpLsh16x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x16 <t> x y)
// cond:
// result: (CSELULT (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM64_OpLsh16x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x32 <t> x y)
// cond:
// result: (CSELULT (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM64_OpLsh16x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x8 <t> x y)
// cond:
// result: (CSELULT (SLL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM64_OpLsh32x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x16 <t> x y)
// cond:
// result: (CSELULT (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM64_OpLsh32x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x32 <t> x y)
// cond:
// result: (CSELULT (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM64_OpLsh32x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x8 <t> x y)
// cond:
// result: (CSELULT (SLL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM64_OpLsh64x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x16 <t> x y)
// cond:
// result: (CSELULT (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM64_OpLsh64x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x32 <t> x y)
// cond:
// result: (CSELULT (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM64_OpLsh64x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x8 <t> x y)
// cond:
// result: (CSELULT (SLL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM64_OpLsh8x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x16 <t> x y)
// cond:
// result: (CSELULT (SLL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM64_OpLsh8x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x32 <t> x y)
// cond:
// result: (CSELULT (SLL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM64_OpLsh8x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x8 <t> x y)
// cond:
// result: (CSELULT (SLL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM64_OpMod16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod16 x y)
// cond:
// result: (MODW (SignExt16to32 x) (SignExt16to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64MODW)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueARM64_OpMod16u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod16u x y)
// cond:
// result: (UMODW (ZeroExt16to32 x) (ZeroExt16to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64UMODW)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueARM64_OpMod8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod8 x y)
// cond:
// result: (MODW (SignExt8to32 x) (SignExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64MODW)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueARM64_OpMod8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod8u x y)
// cond:
// result: (UMODW (ZeroExt8to32 x) (ZeroExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64UMODW)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [0] _ _ mem)
// cond:
// result: mem
mem := v.Args[2]
v.reset(OpARM64MOVBstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, types.UInt8)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
mem := v.Args[2]
v.reset(OpARM64MOVHstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARM64MOVHUload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVHUload, types.UInt16)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
mem := v.Args[2]
v.reset(OpARM64MOVWstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARM64MOVWUload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVWUload, types.UInt32)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
mem := v.Args[2]
v.reset(OpARM64MOVDstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDload, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDload, types.UInt64)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v.reset(OpARM64MOVBstore)
v.AuxInt = 2
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, types.UInt8)
v0.AuxInt = 2
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVHstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpARM64MOVHUload, fe.TypeUInt16())
+ v2 := b.NewValue0(v.Pos, OpARM64MOVHUload, types.UInt16)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpARM64MOVBstore)
v.AuxInt = 4
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, types.UInt8)
v0.AuxInt = 4
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpARM64MOVWUload, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpARM64MOVWUload, types.UInt32)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpARM64MOVHstore)
v.AuxInt = 4
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARM64MOVHUload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVHUload, types.UInt16)
v0.AuxInt = 4
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpARM64MOVWUload, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpARM64MOVWUload, types.UInt32)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpARM64MOVBstore)
v.AuxInt = 6
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, types.UInt8)
v0.AuxInt = 6
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpARM64MOVHstore, TypeMem)
v1.AuxInt = 4
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpARM64MOVHUload, fe.TypeUInt16())
+ v2 := b.NewValue0(v.Pos, OpARM64MOVHUload, types.UInt16)
v2.AuxInt = 4
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64MOVWstore, TypeMem)
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpARM64MOVWUload, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpARM64MOVWUload, types.UInt32)
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
v.reset(OpARM64MOVWstore)
v.AuxInt = 8
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARM64MOVWUload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVWUload, types.UInt32)
v0.AuxInt = 8
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpARM64MOVDload, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpARM64MOVDload, types.UInt64)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpARM64MOVDstore)
v.AuxInt = 8
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDload, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDload, types.UInt64)
v0.AuxInt = 8
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpARM64MOVDload, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpARM64MOVDload, types.UInt64)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpARM64MOVDstore)
v.AuxInt = 16
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDload, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDload, types.UInt64)
v0.AuxInt = 16
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, TypeMem)
v1.AuxInt = 8
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpARM64MOVDload, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpARM64MOVDload, types.UInt64)
v2.AuxInt = 8
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64MOVDstore, TypeMem)
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpARM64MOVDload, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpARM64MOVDload, types.UInt64)
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
func rewriteValueARM64_OpNeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq16 x y)
// cond:
// result: (NotEqual (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpARM64NotEqual)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpNeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq8 x y)
// cond:
// result: (NotEqual (CMPW (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpARM64NotEqual)
v0 := b.NewValue0(v.Pos, OpARM64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueARM64_OpNot(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Not x)
// cond:
// result: (XOR (MOVDconst [1]) x)
for {
x := v.Args[0]
v.reset(OpARM64XOR)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
v.AddArg(x)
func rewriteValueARM64_OpRsh16Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux16 <t> x y)
// cond:
// result: (CSELULT (SRL <t> (ZeroExt16to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
y := v.Args[1]
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
v.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueARM64_OpRsh16Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux32 <t> x y)
// cond:
// result: (CSELULT (SRL <t> (ZeroExt16to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
y := v.Args[1]
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
v.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueARM64_OpRsh16Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux64 x (MOVDconst [c]))
// cond: uint64(c) < 16
// result: (SRLconst (ZeroExt16to64 x) [c])
}
v.reset(OpARM64SRLconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v0.AddArg(x)
v.AddArg(v0)
return true
y := v.Args[1]
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
v0.AddArg(y)
func rewriteValueARM64_OpRsh16Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux8 <t> x y)
// cond:
// result: (CSELULT (SRL <t> (ZeroExt16to64 x) (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
y := v.Args[1]
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
v.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueARM64_OpRsh16x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x16 x y)
// cond:
// result: (SRA (SignExt16to64 x) (CSELULT <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64SRA)
- v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v2.AddArg(y)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
v1.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v1.AddArg(v4)
func rewriteValueARM64_OpRsh16x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x32 x y)
// cond:
// result: (SRA (SignExt16to64 x) (CSELULT <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64SRA)
- v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type)
- v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v2.AddArg(y)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
v1.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v1.AddArg(v4)
func rewriteValueARM64_OpRsh16x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x64 x (MOVDconst [c]))
// cond: uint64(c) < 16
// result: (SRAconst (SignExt16to64 x) [c])
}
v.reset(OpARM64SRAconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
return true
}
v.reset(OpARM64SRAconst)
v.AuxInt = 63
- v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
return true
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64SRA)
- v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type)
func rewriteValueARM64_OpRsh16x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x8 x y)
// cond:
// result: (SRA (SignExt16to64 x) (CSELULT <y.Type> (ZeroExt8to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64 y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64SRA)
- v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v2.AddArg(y)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
v1.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v1.AddArg(v4)
func rewriteValueARM64_OpRsh32Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux16 <t> x y)
// cond:
// result: (CSELULT (SRL <t> (ZeroExt32to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
y := v.Args[1]
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
v.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueARM64_OpRsh32Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux32 <t> x y)
// cond:
// result: (CSELULT (SRL <t> (ZeroExt32to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
y := v.Args[1]
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
v.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueARM64_OpRsh32Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux64 x (MOVDconst [c]))
// cond: uint64(c) < 32
// result: (SRLconst (ZeroExt32to64 x) [c])
}
v.reset(OpARM64SRLconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v0.AddArg(x)
v.AddArg(v0)
return true
y := v.Args[1]
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
v0.AddArg(y)
func rewriteValueARM64_OpRsh32Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux8 <t> x y)
// cond:
// result: (CSELULT (SRL <t> (ZeroExt32to64 x) (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
y := v.Args[1]
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
v.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueARM64_OpRsh32x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x16 x y)
// cond:
// result: (SRA (SignExt32to64 x) (CSELULT <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64SRA)
- v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v2.AddArg(y)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
v1.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v1.AddArg(v4)
func rewriteValueARM64_OpRsh32x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x32 x y)
// cond:
// result: (SRA (SignExt32to64 x) (CSELULT <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64SRA)
- v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type)
- v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v2.AddArg(y)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
v1.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v1.AddArg(v4)
func rewriteValueARM64_OpRsh32x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x64 x (MOVDconst [c]))
// cond: uint64(c) < 32
// result: (SRAconst (SignExt32to64 x) [c])
}
v.reset(OpARM64SRAconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
return true
}
v.reset(OpARM64SRAconst)
v.AuxInt = 63
- v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
return true
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64SRA)
- v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type)
func rewriteValueARM64_OpRsh32x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x8 x y)
// cond:
// result: (SRA (SignExt32to64 x) (CSELULT <y.Type> (ZeroExt8to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64 y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64SRA)
- v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v2.AddArg(y)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
v1.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v1.AddArg(v4)
func rewriteValueARM64_OpRsh64Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux16 <t> x y)
// cond:
// result: (CSELULT (SRL <t> x (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM64_OpRsh64Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux32 <t> x y)
// cond:
// result: (CSELULT (SRL <t> x (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM64_OpRsh64Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux8 <t> x y)
// cond:
// result: (CSELULT (SRL <t> x (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueARM64_OpRsh64x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x16 x y)
// cond:
// result: (SRA x (CSELULT <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
v.reset(OpARM64SRA)
v.AddArg(x)
v0 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpConst64, y.Type)
v0.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v0.AddArg(v3)
func rewriteValueARM64_OpRsh64x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x32 x y)
// cond:
// result: (SRA x (CSELULT <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
v.reset(OpARM64SRA)
v.AddArg(x)
v0 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type)
- v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpConst64, y.Type)
v0.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v0.AddArg(v3)
func rewriteValueARM64_OpRsh64x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x8 x y)
// cond:
// result: (SRA x (CSELULT <y.Type> (ZeroExt8to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64 y))))
v.reset(OpARM64SRA)
v.AddArg(x)
v0 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v1.AddArg(y)
v0.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpConst64, y.Type)
v0.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v3.AuxInt = 64
- v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v0.AddArg(v3)
func rewriteValueARM64_OpRsh8Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux16 <t> x y)
// cond:
// result: (CSELULT (SRL <t> (ZeroExt8to64 x) (ZeroExt16to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt16to64 y)))
y := v.Args[1]
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
v.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueARM64_OpRsh8Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux32 <t> x y)
// cond:
// result: (CSELULT (SRL <t> (ZeroExt8to64 x) (ZeroExt32to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt32to64 y)))
y := v.Args[1]
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
v.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueARM64_OpRsh8Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux64 x (MOVDconst [c]))
// cond: uint64(c) < 8
// result: (SRLconst (ZeroExt8to64 x) [c])
}
v.reset(OpARM64SRLconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v0.AddArg(x)
v.AddArg(v0)
return true
y := v.Args[1]
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
v0.AddArg(y)
func rewriteValueARM64_OpRsh8Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux8 <t> x y)
// cond:
// result: (CSELULT (SRL <t> (ZeroExt8to64 x) (ZeroExt8to64 y)) (Const64 <t> [0]) (CMPconst [64] (ZeroExt8to64 y)))
y := v.Args[1]
v.reset(OpARM64CSELULT)
v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
v.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueARM64_OpRsh8x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x16 x y)
// cond:
// result: (SRA (SignExt8to64 x) (CSELULT <y.Type> (ZeroExt16to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt16to64 y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64SRA)
- v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v2.AddArg(y)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
v1.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v1.AddArg(v4)
func rewriteValueARM64_OpRsh8x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x32 x y)
// cond:
// result: (SRA (SignExt8to64 x) (CSELULT <y.Type> (ZeroExt32to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt32to64 y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64SRA)
- v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type)
- v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v2.AddArg(y)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
v1.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v1.AddArg(v4)
func rewriteValueARM64_OpRsh8x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x64 x (MOVDconst [c]))
// cond: uint64(c) < 8
// result: (SRAconst (SignExt8to64 x) [c])
}
v.reset(OpARM64SRAconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
return true
}
v.reset(OpARM64SRAconst)
v.AuxInt = 63
- v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
return true
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64SRA)
- v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type)
func rewriteValueARM64_OpRsh8x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x8 x y)
// cond:
// result: (SRA (SignExt8to64 x) (CSELULT <y.Type> (ZeroExt8to64 y) (Const64 <y.Type> [63]) (CMPconst [64] (ZeroExt8to64 y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpARM64SRA)
- v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64CSELULT, y.Type)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v2.AddArg(y)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpConst64, y.Type)
v1.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpARM64CMPconst, TypeFlags)
v4.AuxInt = 64
- v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v1.AddArg(v4)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zero [0] _ mem)
// cond:
// result: mem
mem := v.Args[1]
v.reset(OpARM64MOVBstore)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(mem)
mem := v.Args[1]
v.reset(OpARM64MOVHstore)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(mem)
mem := v.Args[1]
v.reset(OpARM64MOVWstore)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(mem)
mem := v.Args[1]
v.reset(OpARM64MOVDstore)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(mem)
v.reset(OpARM64MOVBstore)
v.AuxInt = 2
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVHstore, TypeMem)
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v1.AddArg(mem)
v.reset(OpARM64MOVBstore)
v.AuxInt = 4
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, TypeMem)
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v1.AddArg(mem)
v.reset(OpARM64MOVHstore)
v.AuxInt = 4
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, TypeMem)
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v1.AddArg(mem)
v.reset(OpARM64MOVBstore)
v.AuxInt = 6
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVHstore, TypeMem)
v1.AuxInt = 4
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64MOVWstore, TypeMem)
v3.AddArg(ptr)
- v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v4.AuxInt = 0
v3.AddArg(v4)
v3.AddArg(mem)
v.reset(OpARM64MOVWstore)
v.AuxInt = 8
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, TypeMem)
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v1.AddArg(mem)
v.reset(OpARM64MOVDstore)
v.AuxInt = 8
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, TypeMem)
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v1.AddArg(mem)
v.reset(OpARM64MOVDstore)
v.AuxInt = 16
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, TypeMem)
v1.AuxInt = 8
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpARM64MOVDstore, TypeMem)
v3.AddArg(ptr)
- v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, types.UInt64)
v4.AuxInt = 0
v3.AddArg(v4)
v3.AddArg(mem)
_ = config
fe := b.Func.fe
_ = fe
+ types := &config.Types
+ _ = types
switch b.Kind {
case BlockARM64EQ:
// match: (EQ (CMPconst [0] x) yes no)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (AtomicAnd8 ptr val mem)
// cond: !config.BigEndian
- // result: (LoweredAtomicAnd (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) (OR <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> (ZeroExt8to32 val) (SLLconst <fe.TypeUInt32()> [3] (ANDconst <fe.TypeUInt32()> [3] ptr))) (NORconst [0] <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> (MOVWconst [0xff]) (SLLconst <fe.TypeUInt32()> [3] (ANDconst <fe.TypeUInt32()> [3] (XORconst <fe.TypeUInt32()> [3] ptr)))))) mem)
+ // result: (LoweredAtomicAnd (AND <types.UInt32.PtrTo()> (MOVWconst [^3]) ptr) (OR <types.UInt32> (SLL <types.UInt32> (ZeroExt8to32 val) (SLLconst <types.UInt32> [3] (ANDconst <types.UInt32> [3] ptr))) (NORconst [0] <types.UInt32> (SLL <types.UInt32> (MOVWconst [0xff]) (SLLconst <types.UInt32> [3] (ANDconst <types.UInt32> [3] (XORconst <types.UInt32> [3] ptr)))))) mem)
for {
ptr := v.Args[0]
val := v.Args[1]
break
}
v.reset(OpMIPSLoweredAtomicAnd)
- v0 := b.NewValue0(v.Pos, OpMIPSAND, fe.TypeUInt32().PtrTo())
- v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSAND, types.UInt32.PtrTo())
+ v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v1.AuxInt = ^3
v0.AddArg(v1)
v0.AddArg(ptr)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpMIPSOR, fe.TypeUInt32())
- v3 := b.NewValue0(v.Pos, OpMIPSSLL, fe.TypeUInt32())
- v4 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSOR, types.UInt32)
+ v3 := b.NewValue0(v.Pos, OpMIPSSLL, types.UInt32)
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v4.AddArg(val)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpMIPSSLLconst, types.UInt32)
v5.AuxInt = 3
- v6 := b.NewValue0(v.Pos, OpMIPSANDconst, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpMIPSANDconst, types.UInt32)
v6.AuxInt = 3
v6.AddArg(ptr)
v5.AddArg(v6)
v3.AddArg(v5)
v2.AddArg(v3)
- v7 := b.NewValue0(v.Pos, OpMIPSNORconst, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpMIPSNORconst, types.UInt32)
v7.AuxInt = 0
- v8 := b.NewValue0(v.Pos, OpMIPSSLL, fe.TypeUInt32())
- v9 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v8 := b.NewValue0(v.Pos, OpMIPSSLL, types.UInt32)
+ v9 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v9.AuxInt = 0xff
v8.AddArg(v9)
- v10 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32())
+ v10 := b.NewValue0(v.Pos, OpMIPSSLLconst, types.UInt32)
v10.AuxInt = 3
- v11 := b.NewValue0(v.Pos, OpMIPSANDconst, fe.TypeUInt32())
+ v11 := b.NewValue0(v.Pos, OpMIPSANDconst, types.UInt32)
v11.AuxInt = 3
- v12 := b.NewValue0(v.Pos, OpMIPSXORconst, fe.TypeUInt32())
+ v12 := b.NewValue0(v.Pos, OpMIPSXORconst, types.UInt32)
v12.AuxInt = 3
v12.AddArg(ptr)
v11.AddArg(v12)
}
// match: (AtomicAnd8 ptr val mem)
// cond: config.BigEndian
- // result: (LoweredAtomicAnd (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) (OR <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> (ZeroExt8to32 val) (SLLconst <fe.TypeUInt32()> [3] (ANDconst <fe.TypeUInt32()> [3] (XORconst <fe.TypeUInt32()> [3] ptr)))) (NORconst [0] <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> (MOVWconst [0xff]) (SLLconst <fe.TypeUInt32()> [3] (ANDconst <fe.TypeUInt32()> [3] (XORconst <fe.TypeUInt32()> [3] ptr)))))) mem)
+ // result: (LoweredAtomicAnd (AND <types.UInt32.PtrTo()> (MOVWconst [^3]) ptr) (OR <types.UInt32> (SLL <types.UInt32> (ZeroExt8to32 val) (SLLconst <types.UInt32> [3] (ANDconst <types.UInt32> [3] (XORconst <types.UInt32> [3] ptr)))) (NORconst [0] <types.UInt32> (SLL <types.UInt32> (MOVWconst [0xff]) (SLLconst <types.UInt32> [3] (ANDconst <types.UInt32> [3] (XORconst <types.UInt32> [3] ptr)))))) mem)
for {
ptr := v.Args[0]
val := v.Args[1]
break
}
v.reset(OpMIPSLoweredAtomicAnd)
- v0 := b.NewValue0(v.Pos, OpMIPSAND, fe.TypeUInt32().PtrTo())
- v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSAND, types.UInt32.PtrTo())
+ v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v1.AuxInt = ^3
v0.AddArg(v1)
v0.AddArg(ptr)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpMIPSOR, fe.TypeUInt32())
- v3 := b.NewValue0(v.Pos, OpMIPSSLL, fe.TypeUInt32())
- v4 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSOR, types.UInt32)
+ v3 := b.NewValue0(v.Pos, OpMIPSSLL, types.UInt32)
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v4.AddArg(val)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpMIPSSLLconst, types.UInt32)
v5.AuxInt = 3
- v6 := b.NewValue0(v.Pos, OpMIPSANDconst, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpMIPSANDconst, types.UInt32)
v6.AuxInt = 3
- v7 := b.NewValue0(v.Pos, OpMIPSXORconst, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpMIPSXORconst, types.UInt32)
v7.AuxInt = 3
v7.AddArg(ptr)
v6.AddArg(v7)
v5.AddArg(v6)
v3.AddArg(v5)
v2.AddArg(v3)
- v8 := b.NewValue0(v.Pos, OpMIPSNORconst, fe.TypeUInt32())
+ v8 := b.NewValue0(v.Pos, OpMIPSNORconst, types.UInt32)
v8.AuxInt = 0
- v9 := b.NewValue0(v.Pos, OpMIPSSLL, fe.TypeUInt32())
- v10 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v9 := b.NewValue0(v.Pos, OpMIPSSLL, types.UInt32)
+ v10 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v10.AuxInt = 0xff
v9.AddArg(v10)
- v11 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32())
+ v11 := b.NewValue0(v.Pos, OpMIPSSLLconst, types.UInt32)
v11.AuxInt = 3
- v12 := b.NewValue0(v.Pos, OpMIPSANDconst, fe.TypeUInt32())
+ v12 := b.NewValue0(v.Pos, OpMIPSANDconst, types.UInt32)
v12.AuxInt = 3
- v13 := b.NewValue0(v.Pos, OpMIPSXORconst, fe.TypeUInt32())
+ v13 := b.NewValue0(v.Pos, OpMIPSXORconst, types.UInt32)
v13.AuxInt = 3
v13.AddArg(ptr)
v12.AddArg(v13)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (AtomicOr8 ptr val mem)
// cond: !config.BigEndian
- // result: (LoweredAtomicOr (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) (SLL <fe.TypeUInt32()> (ZeroExt8to32 val) (SLLconst <fe.TypeUInt32()> [3] (ANDconst <fe.TypeUInt32()> [3] ptr))) mem)
+ // result: (LoweredAtomicOr (AND <types.UInt32.PtrTo()> (MOVWconst [^3]) ptr) (SLL <types.UInt32> (ZeroExt8to32 val) (SLLconst <types.UInt32> [3] (ANDconst <types.UInt32> [3] ptr))) mem)
for {
ptr := v.Args[0]
val := v.Args[1]
break
}
v.reset(OpMIPSLoweredAtomicOr)
- v0 := b.NewValue0(v.Pos, OpMIPSAND, fe.TypeUInt32().PtrTo())
- v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSAND, types.UInt32.PtrTo())
+ v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v1.AuxInt = ^3
v0.AddArg(v1)
v0.AddArg(ptr)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpMIPSSLL, fe.TypeUInt32())
- v3 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSSLL, types.UInt32)
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v3.AddArg(val)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpMIPSSLLconst, types.UInt32)
v4.AuxInt = 3
- v5 := b.NewValue0(v.Pos, OpMIPSANDconst, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpMIPSANDconst, types.UInt32)
v5.AuxInt = 3
v5.AddArg(ptr)
v4.AddArg(v5)
}
// match: (AtomicOr8 ptr val mem)
// cond: config.BigEndian
- // result: (LoweredAtomicOr (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) (SLL <fe.TypeUInt32()> (ZeroExt8to32 val) (SLLconst <fe.TypeUInt32()> [3] (ANDconst <fe.TypeUInt32()> [3] (XORconst <fe.TypeUInt32()> [3] ptr)))) mem)
+ // result: (LoweredAtomicOr (AND <types.UInt32.PtrTo()> (MOVWconst [^3]) ptr) (SLL <types.UInt32> (ZeroExt8to32 val) (SLLconst <types.UInt32> [3] (ANDconst <types.UInt32> [3] (XORconst <types.UInt32> [3] ptr)))) mem)
for {
ptr := v.Args[0]
val := v.Args[1]
break
}
v.reset(OpMIPSLoweredAtomicOr)
- v0 := b.NewValue0(v.Pos, OpMIPSAND, fe.TypeUInt32().PtrTo())
- v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSAND, types.UInt32.PtrTo())
+ v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v1.AuxInt = ^3
v0.AddArg(v1)
v0.AddArg(ptr)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpMIPSSLL, fe.TypeUInt32())
- v3 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSSLL, types.UInt32)
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v3.AddArg(val)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpMIPSSLLconst, types.UInt32)
v4.AuxInt = 3
- v5 := b.NewValue0(v.Pos, OpMIPSANDconst, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpMIPSANDconst, types.UInt32)
v5.AuxInt = 3
- v6 := b.NewValue0(v.Pos, OpMIPSXORconst, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpMIPSXORconst, types.UInt32)
v6.AuxInt = 3
v6.AddArg(ptr)
v5.AddArg(v6)
func rewriteValueMIPS_OpBitLen32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (BitLen32 <t> x)
// cond:
// result: (SUB (MOVWconst [32]) (CLZ <t> x))
t := v.Type
x := v.Args[0]
v.reset(OpMIPSSUB)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v0.AuxInt = 32
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPSCLZ, t)
func rewriteValueMIPS_OpCtz32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Ctz32 <t> x)
// cond:
// result: (SUB (MOVWconst [32]) (CLZ <t> (SUBconst <t> [1] (AND <t> x (NEG <t> x)))))
t := v.Type
x := v.Args[0]
v.reset(OpMIPSSUB)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v0.AuxInt = 32
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPSCLZ, t)
func rewriteValueMIPS_OpDiv16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div16 x y)
// cond:
// result: (Select1 (DIV (SignExt16to32 x) (SignExt16to32 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(fe.TypeInt32(), fe.TypeInt32()))
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(types.Int32, types.Int32))
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpDiv16u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div16u x y)
// cond:
// result: (Select1 (DIVU (ZeroExt16to32 x) (ZeroExt16to32 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(types.UInt32, types.UInt32))
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpDiv32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div32 x y)
// cond:
// result: (Select1 (DIV x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(fe.TypeInt32(), fe.TypeInt32()))
+ v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(types.Int32, types.Int32))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS_OpDiv32u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div32u x y)
// cond:
// result: (Select1 (DIVU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
+ v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(types.UInt32, types.UInt32))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS_OpDiv8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8 x y)
// cond:
// result: (Select1 (DIV (SignExt8to32 x) (SignExt8to32 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(fe.TypeInt32(), fe.TypeInt32()))
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(types.Int32, types.Int32))
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpDiv8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8u x y)
// cond:
// result: (Select1 (DIVU (ZeroExt8to32 x) (ZeroExt8to32 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(types.UInt32, types.UInt32))
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpEq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq16 x y)
// cond:
// result: (SGTUconst [1] (XOR (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpMIPSSGTUconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSXOR, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpEq32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq32 x y)
// cond:
// result: (SGTUconst [1] (XOR x y))
y := v.Args[1]
v.reset(OpMIPSSGTUconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSXOR, types.UInt32)
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS_OpEq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq8 x y)
// cond:
// result: (SGTUconst [1] (XOR (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpMIPSSGTUconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSXOR, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpEqB(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (EqB x y)
// cond:
- // result: (XORconst [1] (XOR <fe.TypeBool()> x y))
+ // result: (XORconst [1] (XOR <types.Bool> x y))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSXORconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeBool())
+ v0 := b.NewValue0(v.Pos, OpMIPSXOR, types.Bool)
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS_OpEqPtr(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (EqPtr x y)
// cond:
// result: (SGTUconst [1] (XOR x y))
y := v.Args[1]
v.reset(OpMIPSSGTUconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSXOR, types.UInt32)
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS_OpGeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq16 x y)
// cond:
// result: (XORconst [1] (SGT (SignExt16to32 y) (SignExt16to32 x)))
y := v.Args[1]
v.reset(OpMIPSXORconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSSGT, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSSGT, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(y)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(x)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpGeq16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq16U x y)
// cond:
// result: (XORconst [1] (SGTU (ZeroExt16to32 y) (ZeroExt16to32 x)))
y := v.Args[1]
v.reset(OpMIPSXORconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSSGTU, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSSGTU, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(x)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpGeq32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq32 x y)
// cond:
// result: (XORconst [1] (SGT y x))
y := v.Args[1]
v.reset(OpMIPSXORconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSSGT, fe.TypeBool())
+ v0 := b.NewValue0(v.Pos, OpMIPSSGT, types.Bool)
v0.AddArg(y)
v0.AddArg(x)
v.AddArg(v0)
func rewriteValueMIPS_OpGeq32U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq32U x y)
// cond:
// result: (XORconst [1] (SGTU y x))
y := v.Args[1]
v.reset(OpMIPSXORconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSSGTU, fe.TypeBool())
+ v0 := b.NewValue0(v.Pos, OpMIPSSGTU, types.Bool)
v0.AddArg(y)
v0.AddArg(x)
v.AddArg(v0)
func rewriteValueMIPS_OpGeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq8 x y)
// cond:
// result: (XORconst [1] (SGT (SignExt8to32 y) (SignExt8to32 x)))
y := v.Args[1]
v.reset(OpMIPSXORconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSSGT, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSSGT, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(y)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(x)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpGeq8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq8U x y)
// cond:
// result: (XORconst [1] (SGTU (ZeroExt8to32 y) (ZeroExt8to32 x)))
y := v.Args[1]
v.reset(OpMIPSXORconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSSGTU, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSSGTU, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(x)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpGreater16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater16 x y)
// cond:
// result: (SGT (SignExt16to32 x) (SignExt16to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSGT)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueMIPS_OpGreater16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater16U x y)
// cond:
// result: (SGTU (ZeroExt16to32 x) (ZeroExt16to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSGTU)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueMIPS_OpGreater8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater8 x y)
// cond:
// result: (SGT (SignExt8to32 x) (SignExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSGT)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueMIPS_OpGreater8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater8U x y)
// cond:
// result: (SGTU (ZeroExt8to32 x) (ZeroExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSGTU)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueMIPS_OpHmul32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Hmul32 x y)
// cond:
// result: (Select0 (MULT x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPSMULT, MakeTuple(fe.TypeInt32(), fe.TypeInt32()))
+ v0 := b.NewValue0(v.Pos, OpMIPSMULT, MakeTuple(types.Int32, types.Int32))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS_OpHmul32u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Hmul32u x y)
// cond:
// result: (Select0 (MULTU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPSMULTU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
+ v0 := b.NewValue0(v.Pos, OpMIPSMULTU, MakeTuple(types.UInt32, types.UInt32))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS_OpIsNonNil(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (IsNonNil ptr)
// cond:
// result: (SGTU ptr (MOVWconst [0]))
ptr := v.Args[0]
v.reset(OpMIPSSGTU)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
return true
func rewriteValueMIPS_OpIsSliceInBounds(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (IsSliceInBounds idx len)
// cond:
// result: (XORconst [1] (SGTU idx len))
len := v.Args[1]
v.reset(OpMIPSXORconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSSGTU, fe.TypeBool())
+ v0 := b.NewValue0(v.Pos, OpMIPSSGTU, types.Bool)
v0.AddArg(idx)
v0.AddArg(len)
v.AddArg(v0)
func rewriteValueMIPS_OpLeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq16 x y)
// cond:
// result: (XORconst [1] (SGT (SignExt16to32 x) (SignExt16to32 y)))
y := v.Args[1]
v.reset(OpMIPSXORconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSSGT, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSSGT, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpLeq16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq16U x y)
// cond:
// result: (XORconst [1] (SGTU (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpMIPSXORconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSSGTU, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSSGTU, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpLeq32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq32 x y)
// cond:
// result: (XORconst [1] (SGT x y))
y := v.Args[1]
v.reset(OpMIPSXORconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSSGT, fe.TypeBool())
+ v0 := b.NewValue0(v.Pos, OpMIPSSGT, types.Bool)
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS_OpLeq32U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq32U x y)
// cond:
// result: (XORconst [1] (SGTU x y))
y := v.Args[1]
v.reset(OpMIPSXORconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSSGTU, fe.TypeBool())
+ v0 := b.NewValue0(v.Pos, OpMIPSSGTU, types.Bool)
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS_OpLeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq8 x y)
// cond:
// result: (XORconst [1] (SGT (SignExt8to32 x) (SignExt8to32 y)))
y := v.Args[1]
v.reset(OpMIPSXORconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSSGT, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSSGT, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpLeq8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq8U x y)
// cond:
// result: (XORconst [1] (SGTU (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpMIPSXORconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpMIPSSGTU, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSSGTU, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpLess16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less16 x y)
// cond:
// result: (SGT (SignExt16to32 y) (SignExt16to32 x))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSGT)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v.AddArg(v1)
return true
func rewriteValueMIPS_OpLess16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less16U x y)
// cond:
// result: (SGTU (ZeroExt16to32 y) (ZeroExt16to32 x))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSGTU)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v.AddArg(v1)
return true
func rewriteValueMIPS_OpLess8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less8 x y)
// cond:
// result: (SGT (SignExt8to32 y) (SignExt8to32 x))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSGT)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v.AddArg(v1)
return true
func rewriteValueMIPS_OpLess8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less8U x y)
// cond:
// result: (SGTU (ZeroExt8to32 y) (ZeroExt8to32 x))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSGTU)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v.AddArg(v1)
return true
func rewriteValueMIPS_OpLsh16x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x16 <t> x y)
// cond:
// result: (CMOVZ (SLL <t> x (ZeroExt16to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt16to32 y)))
v.reset(OpMIPSCMOVZ)
v0 := b.NewValue0(v.Pos, OpMIPSSLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v3.AuxInt = 32
- v4 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueMIPS_OpLsh16x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x32 <t> x y)
// cond:
// result: (CMOVZ (SLL <t> x y) (MOVWconst [0]) (SGTUconst [32] y))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v1.AuxInt = 0
v.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v2.AuxInt = 32
v2.AddArg(y)
v.AddArg(v2)
func rewriteValueMIPS_OpLsh16x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x8 <t> x y)
// cond:
// result: (CMOVZ (SLL <t> x (ZeroExt8to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt8to32 y)))
v.reset(OpMIPSCMOVZ)
v0 := b.NewValue0(v.Pos, OpMIPSSLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v3.AuxInt = 32
- v4 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueMIPS_OpLsh32x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x16 <t> x y)
// cond:
// result: (CMOVZ (SLL <t> x (ZeroExt16to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt16to32 y)))
v.reset(OpMIPSCMOVZ)
v0 := b.NewValue0(v.Pos, OpMIPSSLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v3.AuxInt = 32
- v4 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueMIPS_OpLsh32x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x32 <t> x y)
// cond:
// result: (CMOVZ (SLL <t> x y) (MOVWconst [0]) (SGTUconst [32] y))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v1.AuxInt = 0
v.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v2.AuxInt = 32
v2.AddArg(y)
v.AddArg(v2)
func rewriteValueMIPS_OpLsh32x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x8 <t> x y)
// cond:
// result: (CMOVZ (SLL <t> x (ZeroExt8to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt8to32 y)))
v.reset(OpMIPSCMOVZ)
v0 := b.NewValue0(v.Pos, OpMIPSSLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v3.AuxInt = 32
- v4 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueMIPS_OpLsh8x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x16 <t> x y)
// cond:
// result: (CMOVZ (SLL <t> x (ZeroExt16to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt16to32 y)))
v.reset(OpMIPSCMOVZ)
v0 := b.NewValue0(v.Pos, OpMIPSSLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v3.AuxInt = 32
- v4 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueMIPS_OpLsh8x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x32 <t> x y)
// cond:
// result: (CMOVZ (SLL <t> x y) (MOVWconst [0]) (SGTUconst [32] y))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v1.AuxInt = 0
v.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v2.AuxInt = 32
v2.AddArg(y)
v.AddArg(v2)
func rewriteValueMIPS_OpLsh8x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x8 <t> x y)
// cond:
// result: (CMOVZ (SLL <t> x (ZeroExt8to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt8to32 y)))
v.reset(OpMIPSCMOVZ)
v0 := b.NewValue0(v.Pos, OpMIPSSLL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v3.AuxInt = 32
- v4 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueMIPS_OpMod16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod16 x y)
// cond:
// result: (Select0 (DIV (SignExt16to32 x) (SignExt16to32 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(fe.TypeInt32(), fe.TypeInt32()))
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(types.Int32, types.Int32))
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpMod16u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod16u x y)
// cond:
// result: (Select0 (DIVU (ZeroExt16to32 x) (ZeroExt16to32 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(types.UInt32, types.UInt32))
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpMod32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod32 x y)
// cond:
// result: (Select0 (DIV x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(fe.TypeInt32(), fe.TypeInt32()))
+ v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(types.Int32, types.Int32))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS_OpMod32u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod32u x y)
// cond:
// result: (Select0 (DIVU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
+ v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(types.UInt32, types.UInt32))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS_OpMod8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod8 x y)
// cond:
// result: (Select0 (DIV (SignExt8to32 x) (SignExt8to32 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(fe.TypeInt32(), fe.TypeInt32()))
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSDIV, MakeTuple(types.Int32, types.Int32))
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS_OpMod8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod8u x y)
// cond:
// result: (Select0 (DIVU (ZeroExt8to32 x) (ZeroExt8to32 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSDIVU, MakeTuple(types.UInt32, types.UInt32))
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [0] _ _ mem)
// cond:
// result: mem
mem := v.Args[2]
v.reset(OpMIPSMOVBstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, types.UInt8)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
}
v.reset(OpMIPSMOVHstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVHUload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVHUload, types.UInt16)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v.reset(OpMIPSMOVBstore)
v.AuxInt = 1
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, types.UInt8)
v0.AuxInt = 1
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVBUload, types.UInt8)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
}
v.reset(OpMIPSMOVWstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWload, types.UInt32)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v.reset(OpMIPSMOVHstore)
v.AuxInt = 2
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVHUload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVHUload, types.UInt16)
v0.AuxInt = 2
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVHUload, fe.TypeUInt16())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVHUload, types.UInt16)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpMIPSMOVBstore)
v.AuxInt = 3
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, types.UInt8)
v0.AuxInt = 3
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem)
v1.AuxInt = 2
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVBUload, types.UInt8)
v2.AuxInt = 2
v2.AddArg(src)
v2.AddArg(mem)
v3 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem)
v3.AuxInt = 1
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8())
+ v4 := b.NewValue0(v.Pos, OpMIPSMOVBUload, types.UInt8)
v4.AuxInt = 1
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
v5 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem)
v5.AddArg(dst)
- v6 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8())
+ v6 := b.NewValue0(v.Pos, OpMIPSMOVBUload, types.UInt8)
v6.AddArg(src)
v6.AddArg(mem)
v5.AddArg(v6)
v.reset(OpMIPSMOVBstore)
v.AuxInt = 2
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVBUload, types.UInt8)
v0.AuxInt = 2
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem)
v1.AuxInt = 1
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVBUload, types.UInt8)
v2.AuxInt = 1
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem)
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpMIPSMOVBUload, fe.TypeUInt8())
+ v4 := b.NewValue0(v.Pos, OpMIPSMOVBUload, types.UInt8)
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
v.reset(OpMIPSMOVWstore)
v.AuxInt = 4
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWload, types.UInt32)
v0.AuxInt = 4
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWload, types.UInt32)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpMIPSMOVHstore)
v.AuxInt = 6
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVHload, fe.TypeInt16())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVHload, types.Int16)
v0.AuxInt = 6
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem)
v1.AuxInt = 4
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVHload, fe.TypeInt16())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVHload, types.Int16)
v2.AuxInt = 4
v2.AddArg(src)
v2.AddArg(mem)
v3 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem)
v3.AuxInt = 2
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpMIPSMOVHload, fe.TypeInt16())
+ v4 := b.NewValue0(v.Pos, OpMIPSMOVHload, types.Int16)
v4.AuxInt = 2
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
v5 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem)
v5.AddArg(dst)
- v6 := b.NewValue0(v.Pos, OpMIPSMOVHload, fe.TypeInt16())
+ v6 := b.NewValue0(v.Pos, OpMIPSMOVHload, types.Int16)
v6.AddArg(src)
v6.AddArg(mem)
v5.AddArg(v6)
v.reset(OpMIPSMOVHstore)
v.AuxInt = 4
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVHload, fe.TypeInt16())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVHload, types.Int16)
v0.AuxInt = 4
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem)
v1.AuxInt = 2
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVHload, fe.TypeInt16())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVHload, types.Int16)
v2.AuxInt = 2
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem)
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpMIPSMOVHload, fe.TypeInt16())
+ v4 := b.NewValue0(v.Pos, OpMIPSMOVHload, types.Int16)
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
v.reset(OpMIPSMOVWstore)
v.AuxInt = 8
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWload, types.UInt32)
v0.AuxInt = 8
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem)
v1.AuxInt = 4
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWload, types.UInt32)
v2.AuxInt = 4
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem)
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpMIPSMOVWload, types.UInt32)
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
v.reset(OpMIPSMOVWstore)
v.AuxInt = 12
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWload, types.UInt32)
v0.AuxInt = 12
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem)
v1.AuxInt = 8
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWload, types.UInt32)
v2.AuxInt = 8
v2.AddArg(src)
v2.AddArg(mem)
v3 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem)
v3.AuxInt = 4
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpMIPSMOVWload, types.UInt32)
v4.AuxInt = 4
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
v5 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem)
v5.AddArg(dst)
- v6 := b.NewValue0(v.Pos, OpMIPSMOVWload, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpMIPSMOVWload, types.UInt32)
v6.AddArg(src)
v6.AddArg(mem)
v5.AddArg(v6)
func rewriteValueMIPS_OpNeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq16 x y)
// cond:
// result: (SGTU (XOR (ZeroExt16to32 x) (ZeroExt16to32 y)) (MOVWconst [0]))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSGTU)
- v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSXOR, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v3.AuxInt = 0
v.AddArg(v3)
return true
func rewriteValueMIPS_OpNeq32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq32 x y)
// cond:
// result: (SGTU (XOR x y) (MOVWconst [0]))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSGTU)
- v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSXOR, types.UInt32)
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v1.AuxInt = 0
v.AddArg(v1)
return true
func rewriteValueMIPS_OpNeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq8 x y)
// cond:
// result: (SGTU (XOR (ZeroExt8to32 x) (ZeroExt8to32 y)) (MOVWconst [0]))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSGTU)
- v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSXOR, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v3.AuxInt = 0
v.AddArg(v3)
return true
func rewriteValueMIPS_OpNeqPtr(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (NeqPtr x y)
// cond:
// result: (SGTU (XOR x y) (MOVWconst [0]))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSGTU)
- v0 := b.NewValue0(v.Pos, OpMIPSXOR, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSXOR, types.UInt32)
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v1.AuxInt = 0
v.AddArg(v1)
return true
func rewriteValueMIPS_OpRsh16Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux16 <t> x y)
// cond:
// result: (CMOVZ (SRL <t> (ZeroExt16to32 x) (ZeroExt16to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpMIPSCMOVZ)
v0 := b.NewValue0(v.Pos, OpMIPSSRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v3.AuxInt = 0
v.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v4.AuxInt = 32
- v5 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS_OpRsh16Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux32 <t> x y)
// cond:
// result: (CMOVZ (SRL <t> (ZeroExt16to32 x) y) (MOVWconst [0]) (SGTUconst [32] y))
y := v.Args[1]
v.reset(OpMIPSCMOVZ)
v0 := b.NewValue0(v.Pos, OpMIPSSRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
v0.AddArg(y)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v3.AuxInt = 32
v3.AddArg(y)
v.AddArg(v3)
func rewriteValueMIPS_OpRsh16Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux64 x (Const64 [c]))
// cond: uint32(c) < 16
- // result: (SRLconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16])
+ // result: (SRLconst (SLLconst <types.UInt32> x [16]) [c+16])
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpMIPSSRLconst)
v.AuxInt = c + 16
- v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, types.UInt32)
v0.AuxInt = 16
v0.AddArg(x)
v.AddArg(v0)
func rewriteValueMIPS_OpRsh16Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux8 <t> x y)
// cond:
// result: (CMOVZ (SRL <t> (ZeroExt16to32 x) (ZeroExt8to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpMIPSCMOVZ)
v0 := b.NewValue0(v.Pos, OpMIPSSRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v3.AuxInt = 0
v.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v4.AuxInt = 32
- v5 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS_OpRsh16x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x16 x y)
// cond:
- // result: (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y))))
+ // result: (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSRA)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v3.AuxInt = -1
v1.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v4.AuxInt = 32
- v5 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v5.AddArg(y)
v4.AddArg(v5)
v1.AddArg(v4)
func rewriteValueMIPS_OpRsh16x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x32 x y)
// cond:
- // result: (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y)))
+ // result: (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> y (MOVWconst [-1]) (SGTUconst [32] y)))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSRA)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, types.UInt32)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = -1
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v3.AuxInt = 32
v3.AddArg(y)
v1.AddArg(v3)
func rewriteValueMIPS_OpRsh16x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x64 x (Const64 [c]))
// cond: uint32(c) < 16
- // result: (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16])
+ // result: (SRAconst (SLLconst <types.UInt32> x [16]) [c+16])
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpMIPSSRAconst)
v.AuxInt = c + 16
- v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, types.UInt32)
v0.AuxInt = 16
v0.AddArg(x)
v.AddArg(v0)
}
// match: (Rsh16x64 x (Const64 [c]))
// cond: uint32(c) >= 16
- // result: (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [31])
+ // result: (SRAconst (SLLconst <types.UInt32> x [16]) [31])
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpMIPSSRAconst)
v.AuxInt = 31
- v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, types.UInt32)
v0.AuxInt = 16
v0.AddArg(x)
v.AddArg(v0)
func rewriteValueMIPS_OpRsh16x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x8 x y)
// cond:
- // result: (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y))))
+ // result: (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSRA)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v3.AuxInt = -1
v1.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v4.AuxInt = 32
- v5 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v5.AddArg(y)
v4.AddArg(v5)
v1.AddArg(v4)
func rewriteValueMIPS_OpRsh32Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux16 <t> x y)
// cond:
// result: (CMOVZ (SRL <t> x (ZeroExt16to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt16to32 y)))
v.reset(OpMIPSCMOVZ)
v0 := b.NewValue0(v.Pos, OpMIPSSRL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v3.AuxInt = 32
- v4 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueMIPS_OpRsh32Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux32 <t> x y)
// cond:
// result: (CMOVZ (SRL <t> x y) (MOVWconst [0]) (SGTUconst [32] y))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v1.AuxInt = 0
v.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v2.AuxInt = 32
v2.AddArg(y)
v.AddArg(v2)
func rewriteValueMIPS_OpRsh32Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux8 <t> x y)
// cond:
// result: (CMOVZ (SRL <t> x (ZeroExt8to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt8to32 y)))
v.reset(OpMIPSCMOVZ)
v0 := b.NewValue0(v.Pos, OpMIPSSRL, t)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v3.AuxInt = 32
- v4 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v4.AddArg(y)
v3.AddArg(v4)
v.AddArg(v3)
func rewriteValueMIPS_OpRsh32x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x16 x y)
// cond:
- // result: (SRA x ( CMOVZ <fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y))))
+ // result: (SRA x ( CMOVZ <types.UInt32> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSRA)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSCMOVZ, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = -1
v0.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v3.AuxInt = 32
- v4 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v4.AddArg(y)
v3.AddArg(v4)
v0.AddArg(v3)
func rewriteValueMIPS_OpRsh32x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x32 x y)
// cond:
- // result: (SRA x ( CMOVZ <fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y)))
+ // result: (SRA x ( CMOVZ <types.UInt32> y (MOVWconst [-1]) (SGTUconst [32] y)))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSRA)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSCMOVZ, types.UInt32)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v1.AuxInt = -1
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v2 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v2.AuxInt = 32
v2.AddArg(y)
v0.AddArg(v2)
func rewriteValueMIPS_OpRsh32x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x8 x y)
// cond:
- // result: (SRA x ( CMOVZ <fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y))))
+ // result: (SRA x ( CMOVZ <types.UInt32> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSRA)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSCMOVZ, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = -1
v0.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v3.AuxInt = 32
- v4 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v4.AddArg(y)
v3.AddArg(v4)
v0.AddArg(v3)
func rewriteValueMIPS_OpRsh8Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux16 <t> x y)
// cond:
// result: (CMOVZ (SRL <t> (ZeroExt8to32 x) (ZeroExt16to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpMIPSCMOVZ)
v0 := b.NewValue0(v.Pos, OpMIPSSRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v3.AuxInt = 0
v.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v4.AuxInt = 32
- v5 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS_OpRsh8Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux32 <t> x y)
// cond:
// result: (CMOVZ (SRL <t> (ZeroExt8to32 x) y) (MOVWconst [0]) (SGTUconst [32] y))
y := v.Args[1]
v.reset(OpMIPSCMOVZ)
v0 := b.NewValue0(v.Pos, OpMIPSSRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
v0.AddArg(y)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v3.AuxInt = 32
v3.AddArg(y)
v.AddArg(v3)
func rewriteValueMIPS_OpRsh8Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux64 x (Const64 [c]))
// cond: uint32(c) < 8
- // result: (SRLconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24])
+ // result: (SRLconst (SLLconst <types.UInt32> x [24]) [c+24])
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpMIPSSRLconst)
v.AuxInt = c + 24
- v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, types.UInt32)
v0.AuxInt = 24
v0.AddArg(x)
v.AddArg(v0)
func rewriteValueMIPS_OpRsh8Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux8 <t> x y)
// cond:
// result: (CMOVZ (SRL <t> (ZeroExt8to32 x) (ZeroExt8to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpMIPSCMOVZ)
v0 := b.NewValue0(v.Pos, OpMIPSSRL, t)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v3.AuxInt = 0
v.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v4.AuxInt = 32
- v5 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS_OpRsh8x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x16 x y)
// cond:
- // result: (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y))))
+ // result: (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSRA)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v3.AuxInt = -1
v1.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v4.AuxInt = 32
- v5 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v5.AddArg(y)
v4.AddArg(v5)
v1.AddArg(v4)
func rewriteValueMIPS_OpRsh8x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x32 x y)
// cond:
- // result: (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y)))
+ // result: (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> y (MOVWconst [-1]) (SGTUconst [32] y)))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSRA)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, types.UInt32)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = -1
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v3.AuxInt = 32
v3.AddArg(y)
v1.AddArg(v3)
func rewriteValueMIPS_OpRsh8x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x64 x (Const64 [c]))
// cond: uint32(c) < 8
- // result: (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24])
+ // result: (SRAconst (SLLconst <types.UInt32> x [24]) [c+24])
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpMIPSSRAconst)
v.AuxInt = c + 24
- v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, types.UInt32)
v0.AuxInt = 24
v0.AddArg(x)
v.AddArg(v0)
}
// match: (Rsh8x64 x (Const64 [c]))
// cond: uint32(c) >= 8
- // result: (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [31])
+ // result: (SRAconst (SLLconst <types.UInt32> x [24]) [31])
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpMIPSSRAconst)
v.AuxInt = 31
- v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSSLLconst, types.UInt32)
v0.AuxInt = 24
v0.AddArg(x)
v.AddArg(v0)
func rewriteValueMIPS_OpRsh8x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x8 x y)
// cond:
- // result: (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y))))
+ // result: (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPSSRA)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMIPSCMOVZ, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v3.AuxInt = -1
v1.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, fe.TypeBool())
+ v4 := b.NewValue0(v.Pos, OpMIPSSGTUconst, types.Bool)
v4.AuxInt = 32
- v5 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v5.AddArg(y)
v4.AddArg(v5)
v1.AddArg(v4)
func rewriteValueMIPS_OpSelect0(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Select0 (Add32carry <t> x y))
// cond:
// result: (ADD <t.FieldType(0)> x y)
break
}
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPSMULTU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
- v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMULTU, MakeTuple(types.UInt32, types.UInt32))
+ v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v1.AuxInt = c
v0.AddArg(v1)
v0.AddArg(x)
v0.AuxInt = -1
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v1.AuxInt = 0
v.AddArg(v1)
v.AddArg(x)
func rewriteValueMIPS_OpSelect1(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Select1 (Add32carry <t> x y))
// cond:
- // result: (SGTU <fe.TypeBool()> x (ADD <t.FieldType(0)> x y))
+ // result: (SGTU <types.Bool> x (ADD <t.FieldType(0)> x y))
for {
v_0 := v.Args[0]
if v_0.Op != OpAdd32carry {
x := v_0.Args[0]
y := v_0.Args[1]
v.reset(OpMIPSSGTU)
- v.Type = fe.TypeBool()
+ v.Type = types.Bool
v.AddArg(x)
v0 := b.NewValue0(v.Pos, OpMIPSADD, t.FieldType(0))
v0.AddArg(x)
}
// match: (Select1 (Sub32carry <t> x y))
// cond:
- // result: (SGTU <fe.TypeBool()> (SUB <t.FieldType(0)> x y) x)
+ // result: (SGTU <types.Bool> (SUB <t.FieldType(0)> x y) x)
for {
v_0 := v.Args[0]
if v_0.Op != OpSub32carry {
x := v_0.Args[0]
y := v_0.Args[1]
v.reset(OpMIPSSGTU)
- v.Type = fe.TypeBool()
+ v.Type = types.Bool
v0 := b.NewValue0(v.Pos, OpMIPSSUB, t.FieldType(0))
v0.AddArg(x)
v0.AddArg(y)
break
}
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPSMULTU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
- v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMULTU, MakeTuple(types.UInt32, types.UInt32))
+ v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v1.AuxInt = c
v0.AddArg(v1)
v0.AddArg(x)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zero [0] _ mem)
// cond:
// result: mem
mem := v.Args[1]
v.reset(OpMIPSMOVBstore)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(mem)
}
v.reset(OpMIPSMOVHstore)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(mem)
v.reset(OpMIPSMOVBstore)
v.AuxInt = 1
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem)
v1.AuxInt = 0
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v1.AddArg(v2)
v1.AddArg(mem)
}
v.reset(OpMIPSMOVWstore)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(mem)
v.reset(OpMIPSMOVHstore)
v.AuxInt = 2
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem)
v1.AuxInt = 0
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v1.AddArg(v2)
v1.AddArg(mem)
v.reset(OpMIPSMOVBstore)
v.AuxInt = 3
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem)
v1.AuxInt = 2
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem)
v3.AuxInt = 1
v3.AddArg(ptr)
- v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v4.AuxInt = 0
v3.AddArg(v4)
v5 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem)
v5.AuxInt = 0
v5.AddArg(ptr)
- v6 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v6.AuxInt = 0
v5.AddArg(v6)
v5.AddArg(mem)
v.reset(OpMIPSMOVBstore)
v.AuxInt = 2
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem)
v1.AuxInt = 1
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPSMOVBstore, TypeMem)
v3.AuxInt = 0
v3.AddArg(ptr)
- v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v4.AuxInt = 0
v3.AddArg(v4)
v3.AddArg(mem)
v.reset(OpMIPSMOVHstore)
v.AuxInt = 4
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem)
v1.AuxInt = 2
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPSMOVHstore, TypeMem)
v3.AuxInt = 0
v3.AddArg(ptr)
- v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v4.AuxInt = 0
v3.AddArg(v4)
v3.AddArg(mem)
v.reset(OpMIPSMOVWstore)
v.AuxInt = 4
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem)
v1.AuxInt = 0
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v1.AddArg(v2)
v1.AddArg(mem)
v.reset(OpMIPSMOVWstore)
v.AuxInt = 8
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem)
v1.AuxInt = 4
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem)
v3.AuxInt = 0
v3.AddArg(ptr)
- v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v4.AuxInt = 0
v3.AddArg(v4)
v3.AddArg(mem)
v.reset(OpMIPSMOVWstore)
v.AuxInt = 12
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem)
v1.AuxInt = 8
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v2.AuxInt = 0
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem)
v3.AuxInt = 4
v3.AddArg(ptr)
- v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v4.AuxInt = 0
v3.AddArg(v4)
v5 := b.NewValue0(v.Pos, OpMIPSMOVWstore, TypeMem)
v5.AuxInt = 0
v5.AddArg(ptr)
- v6 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v6.AuxInt = 0
v5.AddArg(v6)
v5.AddArg(mem)
func rewriteValueMIPS_OpZeromask(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zeromask x)
// cond:
// result: (NEG (SGTU x (MOVWconst [0])))
for {
x := v.Args[0]
v.reset(OpMIPSNEG)
- v0 := b.NewValue0(v.Pos, OpMIPSSGTU, fe.TypeBool())
+ v0 := b.NewValue0(v.Pos, OpMIPSSGTU, types.Bool)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMIPSMOVWconst, types.UInt32)
v1.AuxInt = 0
v0.AddArg(v1)
v.AddArg(v0)
_ = config
fe := b.Func.fe
_ = fe
+ types := &config.Types
+ _ = types
switch b.Kind {
case BlockMIPSEQ:
// match: (EQ (FPFlagTrue cmp) yes no)
func rewriteValueMIPS64_OpCom16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Com16 x)
// cond:
// result: (NOR (MOVVconst [0]) x)
for {
x := v.Args[0]
v.reset(OpMIPS64NOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(x)
func rewriteValueMIPS64_OpCom32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Com32 x)
// cond:
// result: (NOR (MOVVconst [0]) x)
for {
x := v.Args[0]
v.reset(OpMIPS64NOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(x)
func rewriteValueMIPS64_OpCom64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Com64 x)
// cond:
// result: (NOR (MOVVconst [0]) x)
for {
x := v.Args[0]
v.reset(OpMIPS64NOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(x)
func rewriteValueMIPS64_OpCom8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Com8 x)
// cond:
// result: (NOR (MOVVconst [0]) x)
for {
x := v.Args[0]
v.reset(OpMIPS64NOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(x)
func rewriteValueMIPS64_OpDiv16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div16 x y)
// cond:
// result: (Select1 (DIVV (SignExt16to64 x) (SignExt16to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(fe.TypeInt64(), fe.TypeInt64()))
- v1 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(types.Int64, types.Int64))
+ v1 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS64_OpDiv16u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div16u x y)
// cond:
// result: (Select1 (DIVVU (ZeroExt16to64 x) (ZeroExt16to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64()))
- v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(types.UInt64, types.UInt64))
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS64_OpDiv32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div32 x y)
// cond:
// result: (Select1 (DIVV (SignExt32to64 x) (SignExt32to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(fe.TypeInt64(), fe.TypeInt64()))
- v1 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(types.Int64, types.Int64))
+ v1 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS64_OpDiv32u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div32u x y)
// cond:
// result: (Select1 (DIVVU (ZeroExt32to64 x) (ZeroExt32to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64()))
- v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(types.UInt64, types.UInt64))
+ v1 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS64_OpDiv64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div64 x y)
// cond:
// result: (Select1 (DIVV x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(fe.TypeInt64(), fe.TypeInt64()))
+ v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(types.Int64, types.Int64))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS64_OpDiv64u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div64u x y)
// cond:
// result: (Select1 (DIVVU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64()))
+ v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(types.UInt64, types.UInt64))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS64_OpDiv8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8 x y)
// cond:
// result: (Select1 (DIVV (SignExt8to64 x) (SignExt8to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(fe.TypeInt64(), fe.TypeInt64()))
- v1 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(types.Int64, types.Int64))
+ v1 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS64_OpDiv8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8u x y)
// cond:
// result: (Select1 (DIVVU (ZeroExt8to64 x) (ZeroExt8to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64()))
- v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(types.UInt64, types.UInt64))
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS64_OpEq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq16 x y)
// cond:
// result: (SGTU (MOVVconst [1]) (XOR (ZeroExt16to64 x) (ZeroExt16to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGTU)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64())
- v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64XOR, types.UInt64)
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v2.AddArg(x)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v.AddArg(v1)
func rewriteValueMIPS64_OpEq32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq32 x y)
// cond:
// result: (SGTU (MOVVconst [1]) (XOR (ZeroExt32to64 x) (ZeroExt32to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGTU)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64())
- v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64XOR, types.UInt64)
+ v2 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v2.AddArg(x)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v.AddArg(v1)
func rewriteValueMIPS64_OpEq64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq64 x y)
// cond:
// result: (SGTU (MOVVconst [1]) (XOR x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGTU)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64XOR, types.UInt64)
v1.AddArg(x)
v1.AddArg(y)
v.AddArg(v1)
func rewriteValueMIPS64_OpEq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq8 x y)
// cond:
// result: (SGTU (MOVVconst [1]) (XOR (ZeroExt8to64 x) (ZeroExt8to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGTU)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64())
- v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64XOR, types.UInt64)
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v2.AddArg(x)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v.AddArg(v1)
func rewriteValueMIPS64_OpEqB(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (EqB x y)
// cond:
- // result: (XOR (MOVVconst [1]) (XOR <fe.TypeBool()> x y))
+ // result: (XOR (MOVVconst [1]) (XOR <types.Bool> x y))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeBool())
+ v1 := b.NewValue0(v.Pos, OpMIPS64XOR, types.Bool)
v1.AddArg(x)
v1.AddArg(y)
v.AddArg(v1)
func rewriteValueMIPS64_OpEqPtr(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (EqPtr x y)
// cond:
// result: (SGTU (MOVVconst [1]) (XOR x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGTU)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64XOR, types.UInt64)
v1.AddArg(x)
v1.AddArg(y)
v.AddArg(v1)
func rewriteValueMIPS64_OpGeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq16 x y)
// cond:
// result: (XOR (MOVVconst [1]) (SGT (SignExt16to64 y) (SignExt16to64 x)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGT, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGT, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v2.AddArg(y)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v3.AddArg(x)
v1.AddArg(v3)
v.AddArg(v1)
func rewriteValueMIPS64_OpGeq16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq16U x y)
// cond:
// result: (XOR (MOVVconst [1]) (SGTU (ZeroExt16to64 y) (ZeroExt16to64 x)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v2.AddArg(y)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(x)
v1.AddArg(v3)
v.AddArg(v1)
func rewriteValueMIPS64_OpGeq32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq32 x y)
// cond:
// result: (XOR (MOVVconst [1]) (SGT (SignExt32to64 y) (SignExt32to64 x)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGT, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGT, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v2.AddArg(y)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v3.AddArg(x)
v1.AddArg(v3)
v.AddArg(v1)
func rewriteValueMIPS64_OpGeq32U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq32U x y)
// cond:
// result: (XOR (MOVVconst [1]) (SGTU (ZeroExt32to64 y) (ZeroExt32to64 x)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v2.AddArg(y)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(x)
v1.AddArg(v3)
v.AddArg(v1)
func rewriteValueMIPS64_OpGeq64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq64 x y)
// cond:
// result: (XOR (MOVVconst [1]) (SGT y x))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGT, fe.TypeBool())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGT, types.Bool)
v1.AddArg(y)
v1.AddArg(x)
v.AddArg(v1)
func rewriteValueMIPS64_OpGeq64U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq64U x y)
// cond:
// result: (XOR (MOVVconst [1]) (SGTU y x))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
v1.AddArg(y)
v1.AddArg(x)
v.AddArg(v1)
func rewriteValueMIPS64_OpGeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq8 x y)
// cond:
// result: (XOR (MOVVconst [1]) (SGT (SignExt8to64 y) (SignExt8to64 x)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGT, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGT, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v2.AddArg(y)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v3.AddArg(x)
v1.AddArg(v3)
v.AddArg(v1)
func rewriteValueMIPS64_OpGeq8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq8U x y)
// cond:
// result: (XOR (MOVVconst [1]) (SGTU (ZeroExt8to64 y) (ZeroExt8to64 x)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v2.AddArg(y)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(x)
v1.AddArg(v3)
v.AddArg(v1)
func rewriteValueMIPS64_OpGreater16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater16 x y)
// cond:
// result: (SGT (SignExt16to64 x) (SignExt16to64 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGT)
- v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueMIPS64_OpGreater16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater16U x y)
// cond:
// result: (SGTU (ZeroExt16to64 x) (ZeroExt16to64 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGTU)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueMIPS64_OpGreater32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater32 x y)
// cond:
// result: (SGT (SignExt32to64 x) (SignExt32to64 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGT)
- v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueMIPS64_OpGreater32U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater32U x y)
// cond:
// result: (SGTU (ZeroExt32to64 x) (ZeroExt32to64 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGTU)
- v0 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueMIPS64_OpGreater8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater8 x y)
// cond:
// result: (SGT (SignExt8to64 x) (SignExt8to64 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGT)
- v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueMIPS64_OpGreater8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater8U x y)
// cond:
// result: (SGTU (ZeroExt8to64 x) (ZeroExt8to64 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGTU)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueMIPS64_OpHmul32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Hmul32 x y)
// cond:
- // result: (SRAVconst (Select1 <fe.TypeInt64()> (MULV (SignExt32to64 x) (SignExt32to64 y))) [32])
+ // result: (SRAVconst (Select1 <types.Int64> (MULV (SignExt32to64 x) (SignExt32to64 y))) [32])
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SRAVconst)
v.AuxInt = 32
- v0 := b.NewValue0(v.Pos, OpSelect1, fe.TypeInt64())
- v1 := b.NewValue0(v.Pos, OpMIPS64MULV, MakeTuple(fe.TypeInt64(), fe.TypeInt64()))
- v2 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSelect1, types.Int64)
+ v1 := b.NewValue0(v.Pos, OpMIPS64MULV, MakeTuple(types.Int64, types.Int64))
+ v2 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v2.AddArg(x)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
func rewriteValueMIPS64_OpHmul32u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Hmul32u x y)
// cond:
- // result: (SRLVconst (Select1 <fe.TypeUInt64()> (MULVU (ZeroExt32to64 x) (ZeroExt32to64 y))) [32])
+ // result: (SRLVconst (Select1 <types.UInt64> (MULVU (ZeroExt32to64 x) (ZeroExt32to64 y))) [32])
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SRLVconst)
v.AuxInt = 32
- v0 := b.NewValue0(v.Pos, OpSelect1, fe.TypeUInt64())
- v1 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64()))
- v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpSelect1, types.UInt64)
+ v1 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(types.UInt64, types.UInt64))
+ v2 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v2.AddArg(x)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
func rewriteValueMIPS64_OpHmul64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Hmul64 x y)
// cond:
// result: (Select0 (MULV x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPS64MULV, MakeTuple(fe.TypeInt64(), fe.TypeInt64()))
+ v0 := b.NewValue0(v.Pos, OpMIPS64MULV, MakeTuple(types.Int64, types.Int64))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS64_OpHmul64u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Hmul64u x y)
// cond:
// result: (Select0 (MULVU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64()))
+ v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(types.UInt64, types.UInt64))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS64_OpIsNonNil(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (IsNonNil ptr)
// cond:
// result: (SGTU ptr (MOVVconst [0]))
ptr := v.Args[0]
v.reset(OpMIPS64SGTU)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
return true
func rewriteValueMIPS64_OpIsSliceInBounds(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (IsSliceInBounds idx len)
// cond:
// result: (XOR (MOVVconst [1]) (SGTU idx len))
idx := v.Args[0]
len := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
v1.AddArg(idx)
v1.AddArg(len)
v.AddArg(v1)
func rewriteValueMIPS64_OpLeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq16 x y)
// cond:
// result: (XOR (MOVVconst [1]) (SGT (SignExt16to64 x) (SignExt16to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGT, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGT, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v2.AddArg(x)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v3.AddArg(y)
v1.AddArg(v3)
v.AddArg(v1)
func rewriteValueMIPS64_OpLeq16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq16U x y)
// cond:
// result: (XOR (MOVVconst [1]) (SGTU (ZeroExt16to64 x) (ZeroExt16to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v2.AddArg(x)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v.AddArg(v1)
func rewriteValueMIPS64_OpLeq32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq32 x y)
// cond:
// result: (XOR (MOVVconst [1]) (SGT (SignExt32to64 x) (SignExt32to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGT, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGT, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v2.AddArg(x)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v3.AddArg(y)
v1.AddArg(v3)
v.AddArg(v1)
func rewriteValueMIPS64_OpLeq32U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq32U x y)
// cond:
// result: (XOR (MOVVconst [1]) (SGTU (ZeroExt32to64 x) (ZeroExt32to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v2.AddArg(x)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v.AddArg(v1)
func rewriteValueMIPS64_OpLeq64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq64 x y)
// cond:
// result: (XOR (MOVVconst [1]) (SGT x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGT, fe.TypeBool())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGT, types.Bool)
v1.AddArg(x)
v1.AddArg(y)
v.AddArg(v1)
func rewriteValueMIPS64_OpLeq64U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq64U x y)
// cond:
// result: (XOR (MOVVconst [1]) (SGTU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
v1.AddArg(x)
v1.AddArg(y)
v.AddArg(v1)
func rewriteValueMIPS64_OpLeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq8 x y)
// cond:
// result: (XOR (MOVVconst [1]) (SGT (SignExt8to64 x) (SignExt8to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGT, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGT, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v2.AddArg(x)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v3.AddArg(y)
v1.AddArg(v3)
v.AddArg(v1)
func rewriteValueMIPS64_OpLeq8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq8U x y)
// cond:
// result: (XOR (MOVVconst [1]) (SGTU (ZeroExt8to64 x) (ZeroExt8to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64XOR)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 1
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v2.AddArg(x)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v.AddArg(v1)
func rewriteValueMIPS64_OpLess16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less16 x y)
// cond:
// result: (SGT (SignExt16to64 y) (SignExt16to64 x))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGT)
- v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v1.AddArg(x)
v.AddArg(v1)
return true
func rewriteValueMIPS64_OpLess16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less16U x y)
// cond:
// result: (SGTU (ZeroExt16to64 y) (ZeroExt16to64 x))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGTU)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v1.AddArg(x)
v.AddArg(v1)
return true
func rewriteValueMIPS64_OpLess32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less32 x y)
// cond:
// result: (SGT (SignExt32to64 y) (SignExt32to64 x))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGT)
- v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v1.AddArg(x)
v.AddArg(v1)
return true
func rewriteValueMIPS64_OpLess32U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less32U x y)
// cond:
// result: (SGTU (ZeroExt32to64 y) (ZeroExt32to64 x))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGTU)
- v0 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v1.AddArg(x)
v.AddArg(v1)
return true
func rewriteValueMIPS64_OpLess8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less8 x y)
// cond:
// result: (SGT (SignExt8to64 y) (SignExt8to64 x))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGT)
- v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v1.AddArg(x)
v.AddArg(v1)
return true
func rewriteValueMIPS64_OpLess8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less8U x y)
// cond:
// result: (SGTU (ZeroExt8to64 y) (ZeroExt8to64 x))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGTU)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v1.AddArg(x)
v.AddArg(v1)
return true
func rewriteValueMIPS64_OpLsh16x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x16 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS64_OpLsh16x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x32 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS64_OpLsh16x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x64 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SLLV <t> x y))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
v1.AddArg(y)
func rewriteValueMIPS64_OpLsh16x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x8 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS64_OpLsh32x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x16 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS64_OpLsh32x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x32 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS64_OpLsh32x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x64 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SLLV <t> x y))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
v1.AddArg(y)
func rewriteValueMIPS64_OpLsh32x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x8 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS64_OpLsh64x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x16 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS64_OpLsh64x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x32 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS64_OpLsh64x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x64 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SLLV <t> x y))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
v1.AddArg(y)
func rewriteValueMIPS64_OpLsh64x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x8 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS64_OpLsh8x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x16 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS64_OpLsh8x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x32 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS64_OpLsh8x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x64 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SLLV <t> x y))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
v1.AddArg(y)
func rewriteValueMIPS64_OpLsh8x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x8 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SLLV, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS64_OpMod16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod16 x y)
// cond:
// result: (Select0 (DIVV (SignExt16to64 x) (SignExt16to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(fe.TypeInt64(), fe.TypeInt64()))
- v1 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(types.Int64, types.Int64))
+ v1 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS64_OpMod16u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod16u x y)
// cond:
// result: (Select0 (DIVVU (ZeroExt16to64 x) (ZeroExt16to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64()))
- v1 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(types.UInt64, types.UInt64))
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS64_OpMod32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod32 x y)
// cond:
// result: (Select0 (DIVV (SignExt32to64 x) (SignExt32to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(fe.TypeInt64(), fe.TypeInt64()))
- v1 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(types.Int64, types.Int64))
+ v1 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS64_OpMod32u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod32u x y)
// cond:
// result: (Select0 (DIVVU (ZeroExt32to64 x) (ZeroExt32to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64()))
- v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(types.UInt64, types.UInt64))
+ v1 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS64_OpMod64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod64 x y)
// cond:
// result: (Select0 (DIVV x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(fe.TypeInt64(), fe.TypeInt64()))
+ v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(types.Int64, types.Int64))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS64_OpMod64u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod64u x y)
// cond:
// result: (Select0 (DIVVU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64()))
+ v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(types.UInt64, types.UInt64))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS64_OpMod8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod8 x y)
// cond:
// result: (Select0 (DIVV (SignExt8to64 x) (SignExt8to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(fe.TypeInt64(), fe.TypeInt64()))
- v1 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64DIVV, MakeTuple(types.Int64, types.Int64))
+ v1 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueMIPS64_OpMod8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod8u x y)
// cond:
// result: (Select0 (DIVVU (ZeroExt8to64 x) (ZeroExt8to64 y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect0)
- v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64()))
- v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64DIVVU, MakeTuple(types.UInt64, types.UInt64))
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [0] _ _ mem)
// cond:
// result: mem
mem := v.Args[2]
v.reset(OpMIPS64MOVBstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, types.Int8)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
}
v.reset(OpMIPS64MOVHstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVHload, types.Int16)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v.reset(OpMIPS64MOVBstore)
v.AuxInt = 1
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, types.Int8)
v0.AuxInt = 1
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVBload, types.Int8)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
}
v.reset(OpMIPS64MOVWstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVWload, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVWload, types.Int32)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v.reset(OpMIPS64MOVHstore)
v.AuxInt = 2
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVHload, types.Int16)
v0.AuxInt = 2
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVHload, types.Int16)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpMIPS64MOVBstore)
v.AuxInt = 3
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, types.Int8)
v0.AuxInt = 3
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem)
v1.AuxInt = 2
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVBload, types.Int8)
v2.AuxInt = 2
v2.AddArg(src)
v2.AddArg(mem)
v3 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem)
v3.AuxInt = 1
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8())
+ v4 := b.NewValue0(v.Pos, OpMIPS64MOVBload, types.Int8)
v4.AuxInt = 1
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
v5 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem)
v5.AddArg(dst)
- v6 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8())
+ v6 := b.NewValue0(v.Pos, OpMIPS64MOVBload, types.Int8)
v6.AddArg(src)
v6.AddArg(mem)
v5.AddArg(v6)
}
v.reset(OpMIPS64MOVVstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVload, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVload, types.UInt64)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v.reset(OpMIPS64MOVWstore)
v.AuxInt = 4
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVWload, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVWload, types.Int32)
v0.AuxInt = 4
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVWstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVWload, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVWload, types.Int32)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpMIPS64MOVHstore)
v.AuxInt = 6
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVHload, types.Int16)
v0.AuxInt = 6
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem)
v1.AuxInt = 4
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVHload, types.Int16)
v2.AuxInt = 4
v2.AddArg(src)
v2.AddArg(mem)
v3 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem)
v3.AuxInt = 2
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16())
+ v4 := b.NewValue0(v.Pos, OpMIPS64MOVHload, types.Int16)
v4.AuxInt = 2
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
v5 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem)
v5.AddArg(dst)
- v6 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16())
+ v6 := b.NewValue0(v.Pos, OpMIPS64MOVHload, types.Int16)
v6.AddArg(src)
v6.AddArg(mem)
v5.AddArg(v6)
v.reset(OpMIPS64MOVBstore)
v.AuxInt = 2
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVBload, types.Int8)
v0.AuxInt = 2
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem)
v1.AuxInt = 1
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVBload, types.Int8)
v2.AuxInt = 1
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem)
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpMIPS64MOVBload, fe.TypeInt8())
+ v4 := b.NewValue0(v.Pos, OpMIPS64MOVBload, types.Int8)
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
v.reset(OpMIPS64MOVHstore)
v.AuxInt = 4
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVHload, types.Int16)
v0.AuxInt = 4
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem)
v1.AuxInt = 2
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVHload, types.Int16)
v2.AuxInt = 2
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem)
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpMIPS64MOVHload, fe.TypeInt16())
+ v4 := b.NewValue0(v.Pos, OpMIPS64MOVHload, types.Int16)
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
v.reset(OpMIPS64MOVWstore)
v.AuxInt = 8
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVWload, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVWload, types.Int32)
v0.AuxInt = 8
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVWstore, TypeMem)
v1.AuxInt = 4
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVWload, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVWload, types.Int32)
v2.AuxInt = 4
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPS64MOVWstore, TypeMem)
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpMIPS64MOVWload, fe.TypeInt32())
+ v4 := b.NewValue0(v.Pos, OpMIPS64MOVWload, types.Int32)
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
v.reset(OpMIPS64MOVVstore)
v.AuxInt = 8
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVload, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVload, types.UInt64)
v0.AuxInt = 8
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVVstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVVload, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVVload, types.UInt64)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpMIPS64MOVVstore)
v.AuxInt = 16
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVload, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVload, types.UInt64)
v0.AuxInt = 16
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVVstore, TypeMem)
v1.AuxInt = 8
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVVload, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVVload, types.UInt64)
v2.AuxInt = 8
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPS64MOVVstore, TypeMem)
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpMIPS64MOVVload, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpMIPS64MOVVload, types.UInt64)
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
func rewriteValueMIPS64_OpMul16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mul16 x y)
// cond:
// result: (Select1 (MULVU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64()))
+ v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(types.UInt64, types.UInt64))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS64_OpMul32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mul32 x y)
// cond:
// result: (Select1 (MULVU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64()))
+ v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(types.UInt64, types.UInt64))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS64_OpMul64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mul64 x y)
// cond:
// result: (Select1 (MULVU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64()))
+ v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(types.UInt64, types.UInt64))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS64_OpMul8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mul8 x y)
// cond:
// result: (Select1 (MULVU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpSelect1)
- v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64()))
+ v0 := b.NewValue0(v.Pos, OpMIPS64MULVU, MakeTuple(types.UInt64, types.UInt64))
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValueMIPS64_OpNeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq16 x y)
// cond:
// result: (SGTU (XOR (ZeroExt16to32 x) (ZeroExt16to64 y)) (MOVVconst [0]))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGTU)
- v0 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64())
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpMIPS64XOR, types.UInt64)
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v3.AuxInt = 0
v.AddArg(v3)
return true
func rewriteValueMIPS64_OpNeq32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq32 x y)
// cond:
// result: (SGTU (XOR (ZeroExt32to64 x) (ZeroExt32to64 y)) (MOVVconst [0]))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGTU)
- v0 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64())
- v1 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64XOR, types.UInt64)
+ v1 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v3.AuxInt = 0
v.AddArg(v3)
return true
func rewriteValueMIPS64_OpNeq64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq64 x y)
// cond:
// result: (SGTU (XOR x y) (MOVVconst [0]))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGTU)
- v0 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64XOR, types.UInt64)
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v1.AuxInt = 0
v.AddArg(v1)
return true
func rewriteValueMIPS64_OpNeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq8 x y)
// cond:
// result: (SGTU (XOR (ZeroExt8to64 x) (ZeroExt8to64 y)) (MOVVconst [0]))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGTU)
- v0 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64())
- v1 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64XOR, types.UInt64)
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v3.AuxInt = 0
v.AddArg(v3)
return true
func rewriteValueMIPS64_OpNeqPtr(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (NeqPtr x y)
// cond:
// result: (SGTU (XOR x y) (MOVVconst [0]))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SGTU)
- v0 := b.NewValue0(v.Pos, OpMIPS64XOR, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64XOR, types.UInt64)
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v1.AuxInt = 0
v.AddArg(v1)
return true
func rewriteValueMIPS64_OpRsh16Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux16 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt16to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt16to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t)
- v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v6.AddArg(y)
v4.AddArg(v6)
v.AddArg(v4)
func rewriteValueMIPS64_OpRsh16Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux32 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt32to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt32to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t)
- v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v6.AddArg(y)
v4.AddArg(v6)
v.AddArg(v4)
func rewriteValueMIPS64_OpRsh16Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux64 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt16to64 x) y))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SRLV <t> (ZeroExt16to64 x) y))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v3 := b.NewValue0(v.Pos, OpMIPS64SRLV, t)
- v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v4.AddArg(x)
v3.AddArg(v4)
v3.AddArg(y)
func rewriteValueMIPS64_OpRsh16Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux8 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt8to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt8to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t)
- v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v6.AddArg(y)
v4.AddArg(v6)
v.AddArg(v4)
func rewriteValueMIPS64_OpRsh16x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x16 <t> x y)
// cond:
- // result: (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y)))
+ // result: (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt16to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SRAV)
- v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64OR, t)
v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = 63
v3.AddArg(v5)
v2.AddArg(v3)
v1.AddArg(v2)
- v6 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v6.AddArg(y)
v1.AddArg(v6)
v.AddArg(v1)
func rewriteValueMIPS64_OpRsh16x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x32 <t> x y)
// cond:
- // result: (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y)))
+ // result: (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt32to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SRAV)
- v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64OR, t)
v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = 63
v3.AddArg(v5)
v2.AddArg(v3)
v1.AddArg(v2)
- v6 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v6.AddArg(y)
v1.AddArg(v6)
v.AddArg(v1)
func rewriteValueMIPS64_OpRsh16x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x64 <t> x y)
// cond:
- // result: (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y))
+ // result: (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <types.UInt64> [63]))) y))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SRAV)
- v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64OR, t)
v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
v3.AddArg(y)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 63
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValueMIPS64_OpRsh16x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x8 <t> x y)
// cond:
- // result: (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y)))
+ // result: (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt8to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SRAV)
- v0 := b.NewValue0(v.Pos, OpSignExt16to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64OR, t)
v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = 63
v3.AddArg(v5)
v2.AddArg(v3)
v1.AddArg(v2)
- v6 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v6.AddArg(y)
v1.AddArg(v6)
v.AddArg(v1)
func rewriteValueMIPS64_OpRsh32Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux16 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt16to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt16to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t)
- v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v6.AddArg(y)
v4.AddArg(v6)
v.AddArg(v4)
func rewriteValueMIPS64_OpRsh32Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux32 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt32to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt32to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t)
- v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v6.AddArg(y)
v4.AddArg(v6)
v.AddArg(v4)
func rewriteValueMIPS64_OpRsh32Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux64 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt32to64 x) y))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SRLV <t> (ZeroExt32to64 x) y))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v3 := b.NewValue0(v.Pos, OpMIPS64SRLV, t)
- v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v4.AddArg(x)
v3.AddArg(v4)
v3.AddArg(y)
func rewriteValueMIPS64_OpRsh32Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux8 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt8to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt8to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t)
- v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v6.AddArg(y)
v4.AddArg(v6)
v.AddArg(v4)
func rewriteValueMIPS64_OpRsh32x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x16 <t> x y)
// cond:
- // result: (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y)))
+ // result: (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt16to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SRAV)
- v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64OR, t)
v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = 63
v3.AddArg(v5)
v2.AddArg(v3)
v1.AddArg(v2)
- v6 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v6.AddArg(y)
v1.AddArg(v6)
v.AddArg(v1)
func rewriteValueMIPS64_OpRsh32x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x32 <t> x y)
// cond:
- // result: (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y)))
+ // result: (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt32to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SRAV)
- v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64OR, t)
v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = 63
v3.AddArg(v5)
v2.AddArg(v3)
v1.AddArg(v2)
- v6 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v6.AddArg(y)
v1.AddArg(v6)
v.AddArg(v1)
func rewriteValueMIPS64_OpRsh32x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x64 <t> x y)
// cond:
- // result: (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y))
+ // result: (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <types.UInt64> [63]))) y))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SRAV)
- v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64OR, t)
v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
v3.AddArg(y)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 63
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValueMIPS64_OpRsh32x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x8 <t> x y)
// cond:
- // result: (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y)))
+ // result: (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt8to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SRAV)
- v0 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64OR, t)
v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = 63
v3.AddArg(v5)
v2.AddArg(v3)
v1.AddArg(v2)
- v6 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v6.AddArg(y)
v1.AddArg(v6)
v.AddArg(v1)
func rewriteValueMIPS64_OpRsh64Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux16 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> x (ZeroExt16to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SRLV <t> x (ZeroExt16to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS64_OpRsh64Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux32 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> x (ZeroExt32to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SRLV <t> x (ZeroExt32to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS64_OpRsh64Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux64 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> x y))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SRLV <t> x y))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
v1.AddArg(y)
func rewriteValueMIPS64_OpRsh64Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux8 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> x (ZeroExt8to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SRLV <t> x (ZeroExt8to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v.AddArg(v4)
func rewriteValueMIPS64_OpRsh64x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x16 <t> x y)
// cond:
- // result: (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y)))
+ // result: (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt16to64 y)))
for {
t := v.Type
x := v.Args[0]
v.AddArg(x)
v0 := b.NewValue0(v.Pos, OpMIPS64OR, t)
v1 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v2 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 63
v2.AddArg(v4)
v1.AddArg(v2)
v0.AddArg(v1)
- v5 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v5.AddArg(y)
v0.AddArg(v5)
v.AddArg(v0)
func rewriteValueMIPS64_OpRsh64x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x32 <t> x y)
// cond:
- // result: (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y)))
+ // result: (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt32to64 y)))
for {
t := v.Type
x := v.Args[0]
v.AddArg(x)
v0 := b.NewValue0(v.Pos, OpMIPS64OR, t)
v1 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v2 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 63
v2.AddArg(v4)
v1.AddArg(v2)
v0.AddArg(v1)
- v5 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v5.AddArg(y)
v0.AddArg(v5)
v.AddArg(v0)
func rewriteValueMIPS64_OpRsh64x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x64 <t> x y)
// cond:
- // result: (SRAV x (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y))
+ // result: (SRAV x (OR <t> (NEGV <t> (SGTU y (Const64 <types.UInt64> [63]))) y))
for {
t := v.Type
x := v.Args[0]
v.AddArg(x)
v0 := b.NewValue0(v.Pos, OpMIPS64OR, t)
v1 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v2 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
+ v2 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
v2.AddArg(y)
- v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v3.AuxInt = 63
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValueMIPS64_OpRsh64x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x8 <t> x y)
// cond:
- // result: (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y)))
+ // result: (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt8to64 y)))
for {
t := v.Type
x := v.Args[0]
v.AddArg(x)
v0 := b.NewValue0(v.Pos, OpMIPS64OR, t)
v1 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v2 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 63
v2.AddArg(v4)
v1.AddArg(v2)
v0.AddArg(v1)
- v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v5.AddArg(y)
v0.AddArg(v5)
v.AddArg(v0)
func rewriteValueMIPS64_OpRsh8Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux16 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt16to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt16to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t)
- v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v6.AddArg(y)
v4.AddArg(v6)
v.AddArg(v4)
func rewriteValueMIPS64_OpRsh8Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux32 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt32to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt32to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t)
- v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v6.AddArg(y)
v4.AddArg(v6)
v.AddArg(v4)
func rewriteValueMIPS64_OpRsh8Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux64 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt8to64 x) y))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SRLV <t> (ZeroExt8to64 x) y))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
v1.AddArg(y)
v0.AddArg(v1)
v.AddArg(v0)
v3 := b.NewValue0(v.Pos, OpMIPS64SRLV, t)
- v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v4.AddArg(x)
v3.AddArg(v4)
v3.AddArg(y)
func rewriteValueMIPS64_OpRsh8Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux8 <t> x y)
// cond:
- // result: (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt8to64 y)))
+ // result: (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt8to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64AND)
v0 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 64
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpMIPS64SRLV, t)
- v5 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v6.AddArg(y)
v4.AddArg(v6)
v.AddArg(v4)
func rewriteValueMIPS64_OpRsh8x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x16 <t> x y)
// cond:
- // result: (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y)))
+ // result: (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt16to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SRAV)
- v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64OR, t)
v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = 63
v3.AddArg(v5)
v2.AddArg(v3)
v1.AddArg(v2)
- v6 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v6.AddArg(y)
v1.AddArg(v6)
v.AddArg(v1)
func rewriteValueMIPS64_OpRsh8x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x32 <t> x y)
// cond:
- // result: (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y)))
+ // result: (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt32to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SRAV)
- v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64OR, t)
v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = 63
v3.AddArg(v5)
v2.AddArg(v3)
v1.AddArg(v2)
- v6 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v6.AddArg(y)
v1.AddArg(v6)
v.AddArg(v1)
func rewriteValueMIPS64_OpRsh8x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x64 <t> x y)
// cond:
- // result: (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y))
+ // result: (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <types.UInt64> [63]))) y))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SRAV)
- v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64OR, t)
v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
+ v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
v3.AddArg(y)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 63
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValueMIPS64_OpRsh8x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x8 <t> x y)
// cond:
- // result: (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y)))
+ // result: (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt8to64 y)))
for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.reset(OpMIPS64SRAV)
- v0 := b.NewValue0(v.Pos, OpSignExt8to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to64, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64OR, t)
v2 := b.NewValue0(v.Pos, OpMIPS64NEGV, t)
- v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpMIPS64SGTU, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = 63
v3.AddArg(v5)
v2.AddArg(v3)
v1.AddArg(v2)
- v6 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v6.AddArg(y)
v1.AddArg(v6)
v.AddArg(v1)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zero [0] _ mem)
// cond:
// result: mem
mem := v.Args[1]
v.reset(OpMIPS64MOVBstore)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(mem)
}
v.reset(OpMIPS64MOVHstore)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(mem)
v.reset(OpMIPS64MOVBstore)
v.AuxInt = 1
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem)
v1.AuxInt = 0
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v1.AddArg(mem)
}
v.reset(OpMIPS64MOVWstore)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(mem)
v.reset(OpMIPS64MOVHstore)
v.AuxInt = 2
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem)
v1.AuxInt = 0
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v1.AddArg(mem)
v.reset(OpMIPS64MOVBstore)
v.AuxInt = 3
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem)
v1.AuxInt = 2
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem)
v3.AuxInt = 1
v3.AddArg(ptr)
- v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v4.AuxInt = 0
v3.AddArg(v4)
v5 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem)
v5.AuxInt = 0
v5.AddArg(ptr)
- v6 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v6.AuxInt = 0
v5.AddArg(v6)
v5.AddArg(mem)
}
v.reset(OpMIPS64MOVVstore)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(mem)
v.reset(OpMIPS64MOVWstore)
v.AuxInt = 4
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVWstore, TypeMem)
v1.AuxInt = 0
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v1.AddArg(mem)
v.reset(OpMIPS64MOVHstore)
v.AuxInt = 6
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem)
v1.AuxInt = 4
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem)
v3.AuxInt = 2
v3.AddArg(ptr)
- v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v4.AuxInt = 0
v3.AddArg(v4)
v5 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem)
v5.AuxInt = 0
v5.AddArg(ptr)
- v6 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v6.AuxInt = 0
v5.AddArg(v6)
v5.AddArg(mem)
v.reset(OpMIPS64MOVBstore)
v.AuxInt = 2
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem)
v1.AuxInt = 1
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPS64MOVBstore, TypeMem)
v3.AuxInt = 0
v3.AddArg(ptr)
- v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v4.AuxInt = 0
v3.AddArg(v4)
v3.AddArg(mem)
v.reset(OpMIPS64MOVHstore)
v.AuxInt = 4
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem)
v1.AuxInt = 2
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPS64MOVHstore, TypeMem)
v3.AuxInt = 0
v3.AddArg(ptr)
- v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v4.AuxInt = 0
v3.AddArg(v4)
v3.AddArg(mem)
v.reset(OpMIPS64MOVWstore)
v.AuxInt = 8
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVWstore, TypeMem)
v1.AuxInt = 4
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPS64MOVWstore, TypeMem)
v3.AuxInt = 0
v3.AddArg(ptr)
- v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v4.AuxInt = 0
v3.AddArg(v4)
v3.AddArg(mem)
v.reset(OpMIPS64MOVVstore)
v.AuxInt = 8
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVVstore, TypeMem)
v1.AuxInt = 0
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v1.AddArg(mem)
v.reset(OpMIPS64MOVVstore)
v.AuxInt = 16
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpMIPS64MOVVstore, TypeMem)
v1.AuxInt = 8
v1.AddArg(ptr)
- v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v2.AuxInt = 0
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpMIPS64MOVVstore, TypeMem)
v3.AuxInt = 0
v3.AddArg(ptr)
- v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpMIPS64MOVVconst, types.UInt64)
v4.AuxInt = 0
v3.AddArg(v4)
v3.AddArg(mem)
_ = config
fe := b.Func.fe
_ = fe
+ types := &config.Types
+ _ = types
switch b.Kind {
case BlockMIPS64EQ:
// match: (EQ (FPFlagTrue cmp) yes no)
func rewriteValuePPC64_OpCvt32Fto32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Cvt32Fto32 x)
// cond:
// result: (Xf2i64 (FCTIWZ x))
for {
x := v.Args[0]
v.reset(OpPPC64Xf2i64)
- v0 := b.NewValue0(v.Pos, OpPPC64FCTIWZ, fe.TypeFloat64())
+ v0 := b.NewValue0(v.Pos, OpPPC64FCTIWZ, types.Float64)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValuePPC64_OpCvt32Fto64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Cvt32Fto64 x)
// cond:
// result: (Xf2i64 (FCTIDZ x))
for {
x := v.Args[0]
v.reset(OpPPC64Xf2i64)
- v0 := b.NewValue0(v.Pos, OpPPC64FCTIDZ, fe.TypeFloat64())
+ v0 := b.NewValue0(v.Pos, OpPPC64FCTIDZ, types.Float64)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValuePPC64_OpCvt32to32F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Cvt32to32F x)
// cond:
// result: (FRSP (FCFID (Xi2f64 (SignExt32to64 x))))
for {
x := v.Args[0]
v.reset(OpPPC64FRSP)
- v0 := b.NewValue0(v.Pos, OpPPC64FCFID, fe.TypeFloat64())
- v1 := b.NewValue0(v.Pos, OpPPC64Xi2f64, fe.TypeFloat64())
- v2 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64FCFID, types.Float64)
+ v1 := b.NewValue0(v.Pos, OpPPC64Xi2f64, types.Float64)
+ v2 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v2.AddArg(x)
v1.AddArg(v2)
v0.AddArg(v1)
func rewriteValuePPC64_OpCvt32to64F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Cvt32to64F x)
// cond:
// result: (FCFID (Xi2f64 (SignExt32to64 x)))
for {
x := v.Args[0]
v.reset(OpPPC64FCFID)
- v0 := b.NewValue0(v.Pos, OpPPC64Xi2f64, fe.TypeFloat64())
- v1 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64Xi2f64, types.Float64)
+ v1 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v1.AddArg(x)
v0.AddArg(v1)
v.AddArg(v0)
func rewriteValuePPC64_OpCvt64Fto32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Cvt64Fto32 x)
// cond:
// result: (Xf2i64 (FCTIWZ x))
for {
x := v.Args[0]
v.reset(OpPPC64Xf2i64)
- v0 := b.NewValue0(v.Pos, OpPPC64FCTIWZ, fe.TypeFloat64())
+ v0 := b.NewValue0(v.Pos, OpPPC64FCTIWZ, types.Float64)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValuePPC64_OpCvt64Fto64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Cvt64Fto64 x)
// cond:
// result: (Xf2i64 (FCTIDZ x))
for {
x := v.Args[0]
v.reset(OpPPC64Xf2i64)
- v0 := b.NewValue0(v.Pos, OpPPC64FCTIDZ, fe.TypeFloat64())
+ v0 := b.NewValue0(v.Pos, OpPPC64FCTIDZ, types.Float64)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValuePPC64_OpCvt64to32F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Cvt64to32F x)
// cond:
// result: (FRSP (FCFID (Xi2f64 x)))
for {
x := v.Args[0]
v.reset(OpPPC64FRSP)
- v0 := b.NewValue0(v.Pos, OpPPC64FCFID, fe.TypeFloat64())
- v1 := b.NewValue0(v.Pos, OpPPC64Xi2f64, fe.TypeFloat64())
+ v0 := b.NewValue0(v.Pos, OpPPC64FCFID, types.Float64)
+ v1 := b.NewValue0(v.Pos, OpPPC64Xi2f64, types.Float64)
v1.AddArg(x)
v0.AddArg(v1)
v.AddArg(v0)
func rewriteValuePPC64_OpCvt64to64F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Cvt64to64F x)
// cond:
// result: (FCFID (Xi2f64 x))
for {
x := v.Args[0]
v.reset(OpPPC64FCFID)
- v0 := b.NewValue0(v.Pos, OpPPC64Xi2f64, fe.TypeFloat64())
+ v0 := b.NewValue0(v.Pos, OpPPC64Xi2f64, types.Float64)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValuePPC64_OpDiv16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div16 x y)
// cond:
// result: (DIVW (SignExt16to32 x) (SignExt16to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64DIVW)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValuePPC64_OpDiv16u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div16u x y)
// cond:
// result: (DIVWU (ZeroExt16to32 x) (ZeroExt16to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64DIVWU)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValuePPC64_OpDiv8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8 x y)
// cond:
// result: (DIVW (SignExt8to32 x) (SignExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64DIVW)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValuePPC64_OpDiv8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8u x y)
// cond:
// result: (DIVWU (ZeroExt8to32 x) (ZeroExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64DIVWU)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValuePPC64_OpEq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq16 x y)
// cond: isSigned(x.Type) && isSigned(y.Type)
// result: (Equal (CMPW (SignExt16to32 x) (SignExt16to32 y)))
}
v.reset(OpPPC64Equal)
v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
y := v.Args[1]
v.reset(OpPPC64Equal)
v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpEq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq8 x y)
// cond: isSigned(x.Type) && isSigned(y.Type)
// result: (Equal (CMPW (SignExt8to32 x) (SignExt8to32 y)))
}
v.reset(OpPPC64Equal)
v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
y := v.Args[1]
v.reset(OpPPC64Equal)
v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpEqB(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (EqB x y)
// cond:
// result: (ANDconst [1] (EQV x y))
y := v.Args[1]
v.reset(OpPPC64ANDconst)
v.AuxInt = 1
- v0 := b.NewValue0(v.Pos, OpPPC64EQV, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64EQV, types.Int64)
v0.AddArg(x)
v0.AddArg(y)
v.AddArg(v0)
func rewriteValuePPC64_OpGeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq16 x y)
// cond:
// result: (GreaterEqual (CMPW (SignExt16to32 x) (SignExt16to32 y)))
y := v.Args[1]
v.reset(OpPPC64GreaterEqual)
v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpGeq16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq16U x y)
// cond:
// result: (GreaterEqual (CMPWU (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpPPC64GreaterEqual)
v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpGeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq8 x y)
// cond:
// result: (GreaterEqual (CMPW (SignExt8to32 x) (SignExt8to32 y)))
y := v.Args[1]
v.reset(OpPPC64GreaterEqual)
v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpGeq8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq8U x y)
// cond:
// result: (GreaterEqual (CMPWU (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpPPC64GreaterEqual)
v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpGreater16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater16 x y)
// cond:
// result: (GreaterThan (CMPW (SignExt16to32 x) (SignExt16to32 y)))
y := v.Args[1]
v.reset(OpPPC64GreaterThan)
v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpGreater16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater16U x y)
// cond:
// result: (GreaterThan (CMPWU (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpPPC64GreaterThan)
v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpGreater8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater8 x y)
// cond:
// result: (GreaterThan (CMPW (SignExt8to32 x) (SignExt8to32 y)))
y := v.Args[1]
v.reset(OpPPC64GreaterThan)
v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpGreater8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater8U x y)
// cond:
// result: (GreaterThan (CMPWU (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpPPC64GreaterThan)
v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpLeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq16 x y)
// cond:
// result: (LessEqual (CMPW (SignExt16to32 x) (SignExt16to32 y)))
y := v.Args[1]
v.reset(OpPPC64LessEqual)
v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpLeq16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq16U x y)
// cond:
// result: (LessEqual (CMPWU (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpPPC64LessEqual)
v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpLeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq8 x y)
// cond:
// result: (LessEqual (CMPW (SignExt8to32 x) (SignExt8to32 y)))
y := v.Args[1]
v.reset(OpPPC64LessEqual)
v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpLeq8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq8U x y)
// cond:
// result: (LessEqual (CMPWU (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpPPC64LessEqual)
v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpLess16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less16 x y)
// cond:
// result: (LessThan (CMPW (SignExt16to32 x) (SignExt16to32 y)))
y := v.Args[1]
v.reset(OpPPC64LessThan)
v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpLess16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less16U x y)
// cond:
// result: (LessThan (CMPWU (ZeroExt16to32 x) (ZeroExt16to32 y)))
y := v.Args[1]
v.reset(OpPPC64LessThan)
v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpLess8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less8 x y)
// cond:
// result: (LessThan (CMPW (SignExt8to32 x) (SignExt8to32 y)))
y := v.Args[1]
v.reset(OpPPC64LessThan)
v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpLess8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less8U x y)
// cond:
// result: (LessThan (CMPWU (ZeroExt8to32 x) (ZeroExt8to32 y)))
y := v.Args[1]
v.reset(OpPPC64LessThan)
v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpLoad(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Load <t> ptr mem)
// cond: (is64BitInt(t) || isPtr(t))
// result: (MOVDload ptr mem)
break
}
v.reset(OpPPC64MOVBreg)
- v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, types.UInt8)
v0.AddArg(ptr)
v0.AddArg(mem)
v.AddArg(v0)
func rewriteValuePPC64_OpLsh16x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x16 x y)
// cond:
- // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
+ // result: (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SLW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -16
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpLsh16x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x32 x (Const64 [c]))
// cond: uint32(c) < 16
// result: (SLWconst x [c])
}
// match: (Lsh16x32 x y)
// cond:
- // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
+ // result: (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SLW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -16
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpLsh16x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x64 x (Const64 [c]))
// cond: uint64(c) < 16
// result: (SLWconst x [c])
}
// match: (Lsh16x64 x y)
// cond:
- // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
+ // result: (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SLW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -16
v2.AddArg(y)
func rewriteValuePPC64_OpLsh16x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x8 x y)
// cond:
- // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
+ // result: (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SLW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -16
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpLsh32x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x16 x y)
// cond:
- // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
+ // result: (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SLW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -32
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpLsh32x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x32 x (Const64 [c]))
// cond: uint32(c) < 32
// result: (SLWconst x [c])
}
// match: (Lsh32x32 x y)
// cond:
- // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
+ // result: (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SLW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -32
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpLsh32x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x64 x (Const64 [c]))
// cond: uint64(c) < 32
// result: (SLWconst x [c])
}
// match: (Lsh32x64 x y)
// cond:
- // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
+ // result: (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SLW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -32
v2.AddArg(y)
func rewriteValuePPC64_OpLsh32x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x8 x y)
// cond:
- // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
+ // result: (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SLW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -32
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpLsh64x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x16 x y)
// cond:
- // result: (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
+ // result: (SLD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SLD)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -64
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpLsh64x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x32 x (Const64 [c]))
// cond: uint32(c) < 64
// result: (SLDconst x [c])
}
// match: (Lsh64x32 x y)
// cond:
- // result: (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
+ // result: (SLD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SLD)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -64
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpLsh64x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x64 x (Const64 [c]))
// cond: uint64(c) < 64
// result: (SLDconst x [c])
}
// match: (Lsh64x64 x y)
// cond:
- // result: (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
+ // result: (SLD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SLD)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -64
v2.AddArg(y)
func rewriteValuePPC64_OpLsh64x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x8 x y)
// cond:
- // result: (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
+ // result: (SLD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SLD)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -64
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpLsh8x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x16 x y)
// cond:
- // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
+ // result: (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SLW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -8
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpLsh8x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x32 x (Const64 [c]))
// cond: uint32(c) < 8
// result: (SLWconst x [c])
}
// match: (Lsh8x32 x y)
// cond:
- // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
+ // result: (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SLW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -8
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpLsh8x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x64 x (Const64 [c]))
// cond: uint64(c) < 8
// result: (SLWconst x [c])
}
// match: (Lsh8x64 x y)
// cond:
- // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
+ // result: (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SLW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -8
v2.AddArg(y)
func rewriteValuePPC64_OpLsh8x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x8 x y)
// cond:
- // result: (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
+ // result: (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SLW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -8
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpMod16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod16 x y)
// cond:
// result: (Mod32 (SignExt16to32 x) (SignExt16to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMod32)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValuePPC64_OpMod16u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod16u x y)
// cond:
// result: (Mod32u (ZeroExt16to32 x) (ZeroExt16to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMod32u)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValuePPC64_OpMod32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod32 x y)
// cond:
// result: (SUB x (MULLW y (DIVW x y)))
y := v.Args[1]
v.reset(OpPPC64SUB)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64MULLW, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpPPC64MULLW, types.Int32)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64DIVW, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpPPC64DIVW, types.Int32)
v1.AddArg(x)
v1.AddArg(y)
v0.AddArg(v1)
func rewriteValuePPC64_OpMod32u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod32u x y)
// cond:
// result: (SUB x (MULLW y (DIVWU x y)))
y := v.Args[1]
v.reset(OpPPC64SUB)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64MULLW, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpPPC64MULLW, types.Int32)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64DIVWU, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpPPC64DIVWU, types.Int32)
v1.AddArg(x)
v1.AddArg(y)
v0.AddArg(v1)
func rewriteValuePPC64_OpMod64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod64 x y)
// cond:
// result: (SUB x (MULLD y (DIVD x y)))
y := v.Args[1]
v.reset(OpPPC64SUB)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64MULLD, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64MULLD, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64DIVD, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64DIVD, types.Int64)
v1.AddArg(x)
v1.AddArg(y)
v0.AddArg(v1)
func rewriteValuePPC64_OpMod64u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod64u x y)
// cond:
// result: (SUB x (MULLD y (DIVDU x y)))
y := v.Args[1]
v.reset(OpPPC64SUB)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64MULLD, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64MULLD, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64DIVDU, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64DIVDU, types.Int64)
v1.AddArg(x)
v1.AddArg(y)
v0.AddArg(v1)
func rewriteValuePPC64_OpMod8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod8 x y)
// cond:
// result: (Mod32 (SignExt8to32 x) (SignExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMod32)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValuePPC64_OpMod8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod8u x y)
// cond:
// result: (Mod32u (ZeroExt8to32 x) (ZeroExt8to32 y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpMod32u)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(y)
v.AddArg(v1)
return true
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [0] _ _ mem)
// cond:
// result: mem
mem := v.Args[2]
v.reset(OpPPC64MOVBstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, types.UInt8)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
}
v.reset(OpPPC64MOVHstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpPPC64MOVHZload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpPPC64MOVHZload, types.UInt16)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v.reset(OpPPC64MOVBstore)
v.AuxInt = 1
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, types.UInt8)
v0.AuxInt = 1
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8())
+ v2 := b.NewValue0(v.Pos, OpPPC64MOVBZload, types.UInt8)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
}
v.reset(OpPPC64MOVWstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpPPC64MOVWload, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpPPC64MOVWload, types.Int32)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v.reset(OpPPC64MOVHstore)
v.AuxInt = 2
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpPPC64MOVHZload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpPPC64MOVHZload, types.UInt16)
v0.AuxInt = 2
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpPPC64MOVHstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpPPC64MOVHZload, fe.TypeUInt16())
+ v2 := b.NewValue0(v.Pos, OpPPC64MOVHZload, types.UInt16)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpPPC64MOVBstore)
v.AuxInt = 3
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, types.UInt8)
v0.AuxInt = 3
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem)
v1.AuxInt = 2
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8())
+ v2 := b.NewValue0(v.Pos, OpPPC64MOVBZload, types.UInt8)
v2.AuxInt = 2
v2.AddArg(src)
v2.AddArg(mem)
v3 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem)
v3.AuxInt = 1
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8())
+ v4 := b.NewValue0(v.Pos, OpPPC64MOVBZload, types.UInt8)
v4.AuxInt = 1
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
v5 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem)
v5.AddArg(dst)
- v6 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8())
+ v6 := b.NewValue0(v.Pos, OpPPC64MOVBZload, types.UInt8)
v6.AddArg(src)
v6.AddArg(mem)
v5.AddArg(v6)
}
v.reset(OpPPC64MOVDstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpPPC64MOVDload, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64MOVDload, types.Int64)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v.reset(OpPPC64MOVWstore)
v.AuxInt = 4
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpPPC64MOVWZload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpPPC64MOVWZload, types.UInt32)
v0.AuxInt = 4
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpPPC64MOVWstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpPPC64MOVWZload, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpPPC64MOVWZload, types.UInt32)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpPPC64MOVHstore)
v.AuxInt = 6
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpPPC64MOVHZload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpPPC64MOVHZload, types.UInt16)
v0.AuxInt = 6
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpPPC64MOVHstore, TypeMem)
v1.AuxInt = 4
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpPPC64MOVHZload, fe.TypeUInt16())
+ v2 := b.NewValue0(v.Pos, OpPPC64MOVHZload, types.UInt16)
v2.AuxInt = 4
v2.AddArg(src)
v2.AddArg(mem)
v3 := b.NewValue0(v.Pos, OpPPC64MOVHstore, TypeMem)
v3.AuxInt = 2
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpPPC64MOVHZload, fe.TypeUInt16())
+ v4 := b.NewValue0(v.Pos, OpPPC64MOVHZload, types.UInt16)
v4.AuxInt = 2
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
v5 := b.NewValue0(v.Pos, OpPPC64MOVHstore, TypeMem)
v5.AddArg(dst)
- v6 := b.NewValue0(v.Pos, OpPPC64MOVHZload, fe.TypeUInt16())
+ v6 := b.NewValue0(v.Pos, OpPPC64MOVHZload, types.UInt16)
v6.AddArg(src)
v6.AddArg(mem)
v5.AddArg(v6)
v.reset(OpPPC64MOVBstore)
v.AuxInt = 2
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, types.UInt8)
v0.AuxInt = 2
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem)
v1.AuxInt = 1
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8())
+ v2 := b.NewValue0(v.Pos, OpPPC64MOVBZload, types.UInt8)
v2.AuxInt = 1
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem)
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpPPC64MOVBZload, fe.TypeUInt8())
+ v4 := b.NewValue0(v.Pos, OpPPC64MOVBZload, types.UInt8)
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
func rewriteValuePPC64_OpNeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq16 x y)
// cond: isSigned(x.Type) && isSigned(y.Type)
// result: (NotEqual (CMPW (SignExt16to32 x) (SignExt16to32 y)))
}
v.reset(OpPPC64NotEqual)
v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
y := v.Args[1]
v.reset(OpPPC64NotEqual)
v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpNeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq8 x y)
// cond: isSigned(x.Type) && isSigned(y.Type)
// result: (NotEqual (CMPW (SignExt8to32 x) (SignExt8to32 y)))
}
v.reset(OpPPC64NotEqual)
v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v1 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v2 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
y := v.Args[1]
v.reset(OpPPC64NotEqual)
v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
- v1 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValuePPC64_OpOffPtr(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (OffPtr [off] ptr)
// cond:
- // result: (ADD (MOVDconst <fe.TypeInt64()> [off]) ptr)
+ // result: (ADD (MOVDconst <types.Int64> [off]) ptr)
for {
off := v.AuxInt
ptr := v.Args[0]
v.reset(OpPPC64ADD)
- v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, types.Int64)
v0.AuxInt = off
v.AddArg(v0)
v.AddArg(ptr)
func rewriteValuePPC64_OpRsh16Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux16 x y)
// cond:
- // result: (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
+ // result: (SRW (ZeroExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRW)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v3.AuxInt = -16
- v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValuePPC64_OpRsh16Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux32 x (Const64 [c]))
// cond: uint32(c) < 16
// result: (SRWconst (ZeroExt16to32 x) [c])
}
v.reset(OpPPC64SRWconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
v.reset(OpPPC64SRWconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
// match: (Rsh16Ux32 x y)
// cond:
- // result: (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
+ // result: (SRW (ZeroExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRW)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v3.AuxInt = -16
- v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValuePPC64_OpRsh16Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux64 x (Const64 [c]))
// cond: uint64(c) < 16
// result: (SRWconst (ZeroExt16to32 x) [c])
}
v.reset(OpPPC64SRWconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
v.reset(OpPPC64SRWconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
// match: (Rsh16Ux64 x y)
// cond:
- // result: (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
+ // result: (SRW (ZeroExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRW)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v3.AuxInt = -16
v3.AddArg(y)
func rewriteValuePPC64_OpRsh16Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux8 x y)
// cond:
- // result: (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
+ // result: (SRW (ZeroExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRW)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v3.AuxInt = -16
- v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValuePPC64_OpRsh16x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x16 x y)
// cond:
- // result: (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
+ // result: (SRAW (SignExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRAW)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v3.AuxInt = -16
- v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValuePPC64_OpRsh16x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x32 x (Const64 [c]))
// cond: uint32(c) < 16
// result: (SRAWconst (SignExt16to32 x) [c])
}
v.reset(OpPPC64SRAWconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
v.reset(OpPPC64SRAWconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
// match: (Rsh16x32 x y)
// cond:
- // result: (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
+ // result: (SRAW (SignExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRAW)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v3.AuxInt = -16
- v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValuePPC64_OpRsh16x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x64 x (Const64 [c]))
// cond: uint64(c) < 16
// result: (SRAWconst (SignExt16to32 x) [c])
}
v.reset(OpPPC64SRAWconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
v.reset(OpPPC64SRAWconst)
v.AuxInt = 63
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
v.reset(OpPPC64SRAWconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
// match: (Rsh16x64 x y)
// cond:
- // result: (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
+ // result: (SRAW (SignExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRAW)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v3.AuxInt = -16
v3.AddArg(y)
func rewriteValuePPC64_OpRsh16x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x8 x y)
// cond:
- // result: (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
+ // result: (SRAW (SignExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRAW)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v3.AuxInt = -16
- v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValuePPC64_OpRsh32Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux16 x y)
// cond:
- // result: (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
+ // result: (SRW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -32
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpRsh32Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux32 x (Const64 [c]))
// cond: uint32(c) < 32
// result: (SRWconst x [c])
}
// match: (Rsh32Ux32 x y)
// cond:
- // result: (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
+ // result: (SRW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -32
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpRsh32Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux64 x (Const64 [c]))
// cond: uint64(c) < 32
// result: (SRWconst x [c])
}
// match: (Rsh32Ux64 x y)
// cond:
- // result: (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
+ // result: (SRW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -32
v2.AddArg(y)
func rewriteValuePPC64_OpRsh32Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux8 x y)
// cond:
- // result: (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
+ // result: (SRW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -32
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpRsh32x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x16 x y)
// cond:
- // result: (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
+ // result: (SRAW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRAW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -32
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpRsh32x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x32 x (Const64 [c]))
// cond: uint32(c) < 32
// result: (SRAWconst x [c])
}
// match: (Rsh32x32 x y)
// cond:
- // result: (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
+ // result: (SRAW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRAW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -32
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpRsh32x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x64 x (Const64 [c]))
// cond: uint64(c) < 32
// result: (SRAWconst x [c])
}
// match: (Rsh32x64 x y)
// cond:
- // result: (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
+ // result: (SRAW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRAW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -32
v2.AddArg(y)
func rewriteValuePPC64_OpRsh32x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x8 x y)
// cond:
- // result: (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
+ // result: (SRAW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRAW)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -32
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpRsh64Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux16 x y)
// cond:
- // result: (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
+ // result: (SRD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRD)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -64
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpRsh64Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux32 x (Const64 [c]))
// cond: uint32(c) < 64
// result: (SRDconst x [c])
}
// match: (Rsh64Ux32 x y)
// cond:
- // result: (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
+ // result: (SRD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRD)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -64
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpRsh64Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux64 x (Const64 [c]))
// cond: uint64(c) < 64
// result: (SRDconst x [c])
}
// match: (Rsh64Ux64 x y)
// cond:
- // result: (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
+ // result: (SRD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRD)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -64
v2.AddArg(y)
func rewriteValuePPC64_OpRsh64Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux8 x y)
// cond:
- // result: (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
+ // result: (SRD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRD)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -64
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpRsh64x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x16 x y)
// cond:
- // result: (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
+ // result: (SRAD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRAD)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -64
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpRsh64x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x32 x (Const64 [c]))
// cond: uint32(c) < 64
// result: (SRADconst x [c])
}
// match: (Rsh64x32 x y)
// cond:
- // result: (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
+ // result: (SRAD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRAD)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -64
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpRsh64x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x64 x (Const64 [c]))
// cond: uint64(c) < 64
// result: (SRADconst x [c])
}
// match: (Rsh64x64 x y)
// cond:
- // result: (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
+ // result: (SRAD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRAD)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -64
v2.AddArg(y)
func rewriteValuePPC64_OpRsh64x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x8 x y)
// cond:
- // result: (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
+ // result: (SRAD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRAD)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v0.AddArg(y)
- v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v2.AuxInt = -64
- v3 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValuePPC64_OpRsh8Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux16 x y)
// cond:
- // result: (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
+ // result: (SRW (ZeroExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRW)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v3.AuxInt = -8
- v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValuePPC64_OpRsh8Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux32 x (Const64 [c]))
// cond: uint32(c) < 8
// result: (SRWconst (ZeroExt8to32 x) [c])
}
v.reset(OpPPC64SRWconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
v.reset(OpPPC64SRWconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
// match: (Rsh8Ux32 x y)
// cond:
- // result: (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
+ // result: (SRW (ZeroExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRW)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v3.AuxInt = -8
- v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValuePPC64_OpRsh8Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux64 x (Const64 [c]))
// cond: uint64(c) < 8
// result: (SRWconst (ZeroExt8to32 x) [c])
}
v.reset(OpPPC64SRWconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
v.reset(OpPPC64SRWconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
// match: (Rsh8Ux64 x y)
// cond:
- // result: (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
+ // result: (SRW (ZeroExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRW)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v3.AuxInt = -8
v3.AddArg(y)
func rewriteValuePPC64_OpRsh8Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux8 x y)
// cond:
- // result: (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
+ // result: (SRW (ZeroExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRW)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v3.AuxInt = -8
- v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValuePPC64_OpRsh8x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x16 x y)
// cond:
- // result: (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
+ // result: (SRAW (SignExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRAW)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v3.AuxInt = -8
- v4 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValuePPC64_OpRsh8x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x32 x (Const64 [c]))
// cond: uint32(c) < 8
// result: (SRAWconst (SignExt8to32 x) [c])
}
v.reset(OpPPC64SRAWconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
v.reset(OpPPC64SRAWconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
// match: (Rsh8x32 x y)
// cond:
- // result: (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
+ // result: (SRAW (SignExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRAW)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v3.AuxInt = -8
- v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValuePPC64_OpRsh8x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x64 x (Const64 [c]))
// cond: uint64(c) < 8
// result: (SRAWconst (SignExt8to32 x) [c])
}
v.reset(OpPPC64SRAWconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
v.reset(OpPPC64SRAWconst)
v.AuxInt = 63
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
v.reset(OpPPC64SRAWconst)
v.AuxInt = c
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
// match: (Rsh8x64 x y)
// cond:
- // result: (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
+ // result: (SRAW (SignExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRAW)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v3.AuxInt = -8
v3.AddArg(y)
func rewriteValuePPC64_OpRsh8x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x8 x y)
// cond:
- // result: (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
+ // result: (SRAW (SignExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpPPC64SRAW)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpPPC64ORN, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpPPC64ORN, types.Int64)
v1.AddArg(y)
- v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, types.Int64)
v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
v3.AuxInt = -8
- v4 := b.NewValue0(v.Pos, OpZeroExt8to64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpZeroExt8to64, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
_ = config
fe := b.Func.fe
_ = fe
+ types := &config.Types
+ _ = types
switch b.Kind {
case BlockPPC64EQ:
// match: (EQ (CMPconst [0] (ANDconst [c] x)) yes no)
func rewriteValueS390X_OpAtomicAdd32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (AtomicAdd32 ptr val mem)
// cond:
// result: (AddTupleFirst32 (LAA ptr val mem) val)
val := v.Args[1]
mem := v.Args[2]
v.reset(OpS390XAddTupleFirst32)
- v0 := b.NewValue0(v.Pos, OpS390XLAA, MakeTuple(fe.TypeUInt32(), TypeMem))
+ v0 := b.NewValue0(v.Pos, OpS390XLAA, MakeTuple(types.UInt32, TypeMem))
v0.AddArg(ptr)
v0.AddArg(val)
v0.AddArg(mem)
func rewriteValueS390X_OpAtomicAdd64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (AtomicAdd64 ptr val mem)
// cond:
// result: (AddTupleFirst64 (LAAG ptr val mem) val)
val := v.Args[1]
mem := v.Args[2]
v.reset(OpS390XAddTupleFirst64)
- v0 := b.NewValue0(v.Pos, OpS390XLAAG, MakeTuple(fe.TypeUInt64(), TypeMem))
+ v0 := b.NewValue0(v.Pos, OpS390XLAAG, MakeTuple(types.UInt64, TypeMem))
v0.AddArg(ptr)
v0.AddArg(val)
v0.AddArg(mem)
func rewriteValueS390X_OpBitLen64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (BitLen64 x)
// cond:
// result: (SUB (MOVDconst [64]) (FLOGR x))
for {
x := v.Args[0]
v.reset(OpS390XSUB)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 64
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XFLOGR, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XFLOGR, types.UInt64)
v1.AddArg(x)
v.AddArg(v1)
return true
func rewriteValueS390X_OpCtz32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Ctz32 <t> x)
// cond:
// result: (SUB (MOVDconst [64]) (FLOGR (MOVWZreg (ANDW <t> (SUBWconst <t> [1] x) (NOTW <t> x)))))
t := v.Type
x := v.Args[0]
v.reset(OpS390XSUB)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 64
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XFLOGR, fe.TypeUInt64())
- v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XFLOGR, types.UInt64)
+ v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, types.UInt64)
v3 := b.NewValue0(v.Pos, OpS390XANDW, t)
v4 := b.NewValue0(v.Pos, OpS390XSUBWconst, t)
v4.AuxInt = 1
func rewriteValueS390X_OpCtz64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Ctz64 <t> x)
// cond:
// result: (SUB (MOVDconst [64]) (FLOGR (AND <t> (SUBconst <t> [1] x) (NOT <t> x))))
t := v.Type
x := v.Args[0]
v.reset(OpS390XSUB)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 64
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XFLOGR, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XFLOGR, types.UInt64)
v2 := b.NewValue0(v.Pos, OpS390XAND, t)
v3 := b.NewValue0(v.Pos, OpS390XSUBconst, t)
v3.AuxInt = 1
func rewriteValueS390X_OpDiv16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div16 x y)
// cond:
// result: (DIVW (MOVHreg x) (MOVHreg y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XDIVW)
- v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueS390X_OpDiv16u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div16u x y)
// cond:
// result: (DIVWU (MOVHZreg x) (MOVHZreg y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XDIVWU)
- v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueS390X_OpDiv32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div32 x y)
// cond:
// result: (DIVW (MOVWreg x) y)
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XDIVW)
- v0 := b.NewValue0(v.Pos, OpS390XMOVWreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVWreg, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v.AddArg(y)
func rewriteValueS390X_OpDiv32u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div32u x y)
// cond:
// result: (DIVWU (MOVWZreg x) y)
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XDIVWU)
- v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, types.UInt64)
v0.AddArg(x)
v.AddArg(v0)
v.AddArg(y)
func rewriteValueS390X_OpDiv8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8 x y)
// cond:
// result: (DIVW (MOVBreg x) (MOVBreg y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XDIVW)
- v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueS390X_OpDiv8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8u x y)
// cond:
// result: (DIVWU (MOVBZreg x) (MOVBZreg y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XDIVWU)
- v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueS390X_OpEq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq16 x y)
// cond:
// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDEQ)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpEq32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq32 x y)
// cond:
// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDEQ)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPW, TypeFlags)
func rewriteValueS390X_OpEq32F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq32F x y)
// cond:
// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDEQ)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XFCMPS, TypeFlags)
func rewriteValueS390X_OpEq64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq64 x y)
// cond:
// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDEQ)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
func rewriteValueS390X_OpEq64F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq64F x y)
// cond:
// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDEQ)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XFCMP, TypeFlags)
func rewriteValueS390X_OpEq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq8 x y)
// cond:
// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDEQ)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpEqB(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (EqB x y)
// cond:
// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDEQ)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpEqPtr(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (EqPtr x y)
// cond:
// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDEQ)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
func rewriteValueS390X_OpGeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq16 x y)
// cond:
// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpGeq16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq16U x y)
// cond:
// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVHZreg x) (MOVHZreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpGeq32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq32 x y)
// cond:
// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPW, TypeFlags)
func rewriteValueS390X_OpGeq32F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq32F x y)
// cond:
// result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGEnoinv)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XFCMPS, TypeFlags)
func rewriteValueS390X_OpGeq32U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq32U x y)
// cond:
// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPWU, TypeFlags)
func rewriteValueS390X_OpGeq64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq64 x y)
// cond:
// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
func rewriteValueS390X_OpGeq64F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq64F x y)
// cond:
// result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGEnoinv)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XFCMP, TypeFlags)
func rewriteValueS390X_OpGeq64U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq64U x y)
// cond:
// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags)
func rewriteValueS390X_OpGeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq8 x y)
// cond:
// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpGeq8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq8U x y)
// cond:
// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVBZreg x) (MOVBZreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpGreater16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater16 x y)
// cond:
// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpGreater16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater16U x y)
// cond:
// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVHZreg x) (MOVHZreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpGreater32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater32 x y)
// cond:
// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPW, TypeFlags)
func rewriteValueS390X_OpGreater32F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater32F x y)
// cond:
// result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGTnoinv)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XFCMPS, TypeFlags)
func rewriteValueS390X_OpGreater32U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater32U x y)
// cond:
// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPWU, TypeFlags)
func rewriteValueS390X_OpGreater64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater64 x y)
// cond:
// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
func rewriteValueS390X_OpGreater64F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater64F x y)
// cond:
// result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGTnoinv)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XFCMP, TypeFlags)
func rewriteValueS390X_OpGreater64U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater64U x y)
// cond:
// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags)
func rewriteValueS390X_OpGreater8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater8 x y)
// cond:
// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpGreater8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater8U x y)
// cond:
// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVBZreg x) (MOVBZreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpHmul32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Hmul32 x y)
// cond:
// result: (SRDconst [32] (MULLD (MOVWreg x) (MOVWreg y)))
y := v.Args[1]
v.reset(OpS390XSRDconst)
v.AuxInt = 32
- v0 := b.NewValue0(v.Pos, OpS390XMULLD, fe.TypeInt64())
- v1 := b.NewValue0(v.Pos, OpS390XMOVWreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMULLD, types.Int64)
+ v1 := b.NewValue0(v.Pos, OpS390XMOVWreg, types.Int64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpS390XMOVWreg, fe.TypeInt64())
+ v2 := b.NewValue0(v.Pos, OpS390XMOVWreg, types.Int64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueS390X_OpHmul32u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Hmul32u x y)
// cond:
// result: (SRDconst [32] (MULLD (MOVWZreg x) (MOVWZreg y)))
y := v.Args[1]
v.reset(OpS390XSRDconst)
v.AuxInt = 32
- v0 := b.NewValue0(v.Pos, OpS390XMULLD, fe.TypeInt64())
- v1 := b.NewValue0(v.Pos, OpS390XMOVWZreg, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMULLD, types.Int64)
+ v1 := b.NewValue0(v.Pos, OpS390XMOVWZreg, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, types.UInt64)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
func rewriteValueS390X_OpIsInBounds(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (IsInBounds idx len)
// cond:
// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPU idx len))
idx := v.Args[0]
len := v.Args[1]
v.reset(OpS390XMOVDLT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags)
func rewriteValueS390X_OpIsNonNil(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (IsNonNil p)
// cond:
// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMPconst p [0]))
for {
p := v.Args[0]
v.reset(OpS390XMOVDNE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPconst, TypeFlags)
func rewriteValueS390X_OpIsSliceInBounds(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (IsSliceInBounds idx len)
// cond:
// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPU idx len))
idx := v.Args[0]
len := v.Args[1]
v.reset(OpS390XMOVDLE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags)
func rewriteValueS390X_OpLeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq16 x y)
// cond:
// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDLE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpLeq16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq16U x y)
// cond:
// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVHZreg x) (MOVHZreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDLE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpLeq32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq32 x y)
// cond:
// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDLE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPW, TypeFlags)
func rewriteValueS390X_OpLeq32F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq32F x y)
// cond:
// result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS y x))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGEnoinv)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XFCMPS, TypeFlags)
func rewriteValueS390X_OpLeq32U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq32U x y)
// cond:
// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDLE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPWU, TypeFlags)
func rewriteValueS390X_OpLeq64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq64 x y)
// cond:
// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDLE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
func rewriteValueS390X_OpLeq64F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq64F x y)
// cond:
// result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP y x))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGEnoinv)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XFCMP, TypeFlags)
func rewriteValueS390X_OpLeq64U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq64U x y)
// cond:
// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDLE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags)
func rewriteValueS390X_OpLeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq8 x y)
// cond:
// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDLE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpLeq8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq8U x y)
// cond:
// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVBZreg x) (MOVBZreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDLE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpLess16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less16 x y)
// cond:
// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDLT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpLess16U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less16U x y)
// cond:
// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVHZreg x) (MOVHZreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDLT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpLess32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less32 x y)
// cond:
// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDLT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPW, TypeFlags)
func rewriteValueS390X_OpLess32F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less32F x y)
// cond:
// result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS y x))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGTnoinv)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XFCMPS, TypeFlags)
func rewriteValueS390X_OpLess32U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less32U x y)
// cond:
// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDLT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPWU, TypeFlags)
func rewriteValueS390X_OpLess64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less64 x y)
// cond:
// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDLT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
func rewriteValueS390X_OpLess64F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less64F x y)
// cond:
// result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP y x))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDGTnoinv)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XFCMP, TypeFlags)
func rewriteValueS390X_OpLess64U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less64U x y)
// cond:
// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPU x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDLT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags)
func rewriteValueS390X_OpLess8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less8 x y)
// cond:
// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDLT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpLess8U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less8U x y)
// cond:
// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVBZreg x) (MOVBZreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDLT)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPU, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpLsh16x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x16 <t> x y)
// cond:
// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [31])))
v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v2.AuxInt = 31
- v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValueS390X_OpLsh16x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x8 <t> x y)
// cond:
// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [31])))
v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v2.AuxInt = 31
- v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValueS390X_OpLsh32x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x16 <t> x y)
// cond:
// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [31])))
v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v2.AuxInt = 31
- v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValueS390X_OpLsh32x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x8 <t> x y)
// cond:
// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [31])))
v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v2.AuxInt = 31
- v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValueS390X_OpLsh64x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x16 <t> x y)
// cond:
// result: (AND (SLD <t> x y) (SUBEcarrymask <t> (CMPWUconst (MOVHZreg y) [63])))
v1 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, t)
v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v2.AuxInt = 63
- v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValueS390X_OpLsh64x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x8 <t> x y)
// cond:
// result: (AND (SLD <t> x y) (SUBEcarrymask <t> (CMPWUconst (MOVBZreg y) [63])))
v1 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, t)
v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v2.AuxInt = 63
- v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValueS390X_OpLsh8x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x16 <t> x y)
// cond:
// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [31])))
v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v2.AuxInt = 31
- v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValueS390X_OpLsh8x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x8 <t> x y)
// cond:
// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [31])))
v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v2.AuxInt = 31
- v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValueS390X_OpMod16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod16 x y)
// cond:
// result: (MODW (MOVHreg x) (MOVHreg y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMODW)
- v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueS390X_OpMod16u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod16u x y)
// cond:
// result: (MODWU (MOVHZreg x) (MOVHZreg y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMODWU)
- v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueS390X_OpMod32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod32 x y)
// cond:
// result: (MODW (MOVWreg x) y)
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMODW)
- v0 := b.NewValue0(v.Pos, OpS390XMOVWreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVWreg, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v.AddArg(y)
func rewriteValueS390X_OpMod32u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod32u x y)
// cond:
// result: (MODWU (MOVWZreg x) y)
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMODWU)
- v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, types.UInt64)
v0.AddArg(x)
v.AddArg(v0)
v.AddArg(y)
func rewriteValueS390X_OpMod8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod8 x y)
// cond:
// result: (MODW (MOVBreg x) (MOVBreg y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMODW)
- v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueS390X_OpMod8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mod8u x y)
// cond:
// result: (MODWU (MOVBZreg x) (MOVBZreg y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMODWU)
- v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValueS390X_OpMove(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [0] _ _ mem)
// cond:
// result: mem
mem := v.Args[2]
v.reset(OpS390XMOVBstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, types.UInt8)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
mem := v.Args[2]
v.reset(OpS390XMOVHstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, types.UInt16)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
mem := v.Args[2]
v.reset(OpS390XMOVWstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, types.UInt32)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
mem := v.Args[2]
v.reset(OpS390XMOVDstore)
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDload, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDload, types.UInt64)
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v.reset(OpS390XMOVDstore)
v.AuxInt = 8
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDload, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDload, types.UInt64)
v0.AuxInt = 8
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpS390XMOVDstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpS390XMOVDload, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpS390XMOVDload, types.UInt64)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpS390XMOVDstore)
v.AuxInt = 16
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDload, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDload, types.UInt64)
v0.AuxInt = 16
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpS390XMOVDstore, TypeMem)
v1.AuxInt = 8
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpS390XMOVDload, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpS390XMOVDload, types.UInt64)
v2.AuxInt = 8
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpS390XMOVDstore, TypeMem)
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpS390XMOVDload, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVDload, types.UInt64)
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
v.reset(OpS390XMOVBstore)
v.AuxInt = 2
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, types.UInt8)
v0.AuxInt = 2
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpS390XMOVHstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, fe.TypeUInt16())
+ v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, types.UInt16)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpS390XMOVBstore)
v.AuxInt = 4
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, types.UInt8)
v0.AuxInt = 4
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpS390XMOVWstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, types.UInt32)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpS390XMOVHstore)
v.AuxInt = 4
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, types.UInt16)
v0.AuxInt = 4
v0.AddArg(src)
v0.AddArg(mem)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpS390XMOVWstore, TypeMem)
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, types.UInt32)
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v.reset(OpS390XMOVBstore)
v.AuxInt = 6
v.AddArg(dst)
- v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, types.UInt8)
v0.AuxInt = 6
v0.AddArg(src)
v0.AddArg(mem)
v1 := b.NewValue0(v.Pos, OpS390XMOVHstore, TypeMem)
v1.AuxInt = 4
v1.AddArg(dst)
- v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, fe.TypeUInt16())
+ v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, types.UInt16)
v2.AuxInt = 4
v2.AddArg(src)
v2.AddArg(mem)
v1.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpS390XMOVWstore, TypeMem)
v3.AddArg(dst)
- v4 := b.NewValue0(v.Pos, OpS390XMOVWZload, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVWZload, types.UInt32)
v4.AddArg(src)
v4.AddArg(mem)
v3.AddArg(v4)
func rewriteValueS390X_OpNeg16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neg16 x)
// cond:
// result: (NEGW (MOVHreg x))
for {
x := v.Args[0]
v.reset(OpS390XNEGW)
- v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValueS390X_OpNeg8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neg8 x)
// cond:
// result: (NEGW (MOVBreg x))
for {
x := v.Args[0]
v.reset(OpS390XNEGW)
- v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValueS390X_OpNeq16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq16 x y)
// cond:
// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDNE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpNeq32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq32 x y)
// cond:
// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDNE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMPW, TypeFlags)
func rewriteValueS390X_OpNeq32F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq32F x y)
// cond:
// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDNE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XFCMPS, TypeFlags)
func rewriteValueS390X_OpNeq64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq64 x y)
// cond:
// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDNE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
func rewriteValueS390X_OpNeq64F(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq64F x y)
// cond:
// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDNE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XFCMP, TypeFlags)
func rewriteValueS390X_OpNeq8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq8 x y)
// cond:
// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDNE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpNeqB(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (NeqB x y)
// cond:
// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDNE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
- v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v4.AddArg(y)
v2.AddArg(v4)
v.AddArg(v2)
func rewriteValueS390X_OpNeqPtr(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (NeqPtr x y)
// cond:
// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpS390XMOVDNE)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = 0
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v1.AuxInt = 1
v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpS390XCMP, TypeFlags)
func rewriteValueS390X_OpOffPtr(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (OffPtr [off] ptr:(SP))
// cond:
// result: (MOVDaddr [off] ptr)
off := v.AuxInt
ptr := v.Args[0]
v.reset(OpS390XADD)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = off
v.AddArg(v0)
v.AddArg(ptr)
func rewriteValueS390X_OpRsh16Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux16 <t> x y)
// cond:
// result: (ANDW (SRW <t> (MOVHZreg x) y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [15])))
y := v.Args[1]
v.reset(OpS390XANDW)
v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
- v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
v0.AddArg(y)
v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v3.AuxInt = 15
- v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValueS390X_OpRsh16Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux32 <t> x y)
// cond:
// result: (ANDW (SRW <t> (MOVHZreg x) y) (SUBEWcarrymask <t> (CMPWUconst y [15])))
y := v.Args[1]
v.reset(OpS390XANDW)
v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
- v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
v0.AddArg(y)
func rewriteValueS390X_OpRsh16Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux64 <t> x y)
// cond:
// result: (ANDW (SRW <t> (MOVHZreg x) y) (SUBEWcarrymask <t> (CMPUconst y [15])))
y := v.Args[1]
v.reset(OpS390XANDW)
v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
- v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
v0.AddArg(y)
func rewriteValueS390X_OpRsh16Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux8 <t> x y)
// cond:
// result: (ANDW (SRW <t> (MOVHZreg x) y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [15])))
y := v.Args[1]
v.reset(OpS390XANDW)
v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
- v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
v0.AddArg(y)
v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v3.AuxInt = 15
- v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValueS390X_OpRsh16x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x16 <t> x y)
// cond:
// result: (SRAW <t> (MOVHreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVHZreg y) [15])))))
y := v.Args[1]
v.reset(OpS390XSRAW)
v.Type = t
- v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
v3 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
v4 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v4.AuxInt = 15
- v5 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v3.AddArg(v4)
func rewriteValueS390X_OpRsh16x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x32 <t> x y)
// cond:
// result: (SRAW <t> (MOVHreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst y [15])))))
y := v.Args[1]
v.reset(OpS390XSRAW)
v.Type = t
- v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
func rewriteValueS390X_OpRsh16x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x64 <t> x y)
// cond:
// result: (SRAW <t> (MOVHreg x) (OR <y.Type> y (NOT <y.Type> (SUBEcarrymask <y.Type> (CMPUconst y [15])))))
y := v.Args[1]
v.reset(OpS390XSRAW)
v.Type = t
- v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpS390XOR, y.Type)
func rewriteValueS390X_OpRsh16x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x8 <t> x y)
// cond:
// result: (SRAW <t> (MOVHreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVBZreg y) [15])))))
y := v.Args[1]
v.reset(OpS390XSRAW)
v.Type = t
- v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
v3 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
v4 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v4.AuxInt = 15
- v5 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v3.AddArg(v4)
func rewriteValueS390X_OpRsh32Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux16 <t> x y)
// cond:
// result: (ANDW (SRW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [31])))
v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v2.AuxInt = 31
- v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValueS390X_OpRsh32Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux8 <t> x y)
// cond:
// result: (ANDW (SRW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [31])))
v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v2.AuxInt = 31
- v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValueS390X_OpRsh32x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x16 <t> x y)
// cond:
// result: (SRAW <t> x (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVHZreg y) [31])))))
v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v3.AuxInt = 31
- v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValueS390X_OpRsh32x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x8 <t> x y)
// cond:
// result: (SRAW <t> x (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVBZreg y) [31])))))
v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v3.AuxInt = 31
- v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValueS390X_OpRsh64Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux16 <t> x y)
// cond:
// result: (AND (SRD <t> x y) (SUBEcarrymask <t> (CMPWUconst (MOVHZreg y) [63])))
v1 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, t)
v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v2.AuxInt = 63
- v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValueS390X_OpRsh64Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux8 <t> x y)
// cond:
// result: (AND (SRD <t> x y) (SUBEcarrymask <t> (CMPWUconst (MOVBZreg y) [63])))
v1 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, t)
v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v2.AuxInt = 63
- v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v3.AddArg(y)
v2.AddArg(v3)
v1.AddArg(v2)
func rewriteValueS390X_OpRsh64x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x16 <t> x y)
// cond:
// result: (SRAD <t> x (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVHZreg y) [63])))))
v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v3.AuxInt = 63
- v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValueS390X_OpRsh64x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x8 <t> x y)
// cond:
// result: (SRAD <t> x (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVBZreg y) [63])))))
v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v3.AuxInt = 63
- v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValueS390X_OpRsh8Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux16 <t> x y)
// cond:
// result: (ANDW (SRW <t> (MOVBZreg x) y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [7])))
y := v.Args[1]
v.reset(OpS390XANDW)
v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
- v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
v0.AddArg(y)
v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v3.AuxInt = 7
- v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValueS390X_OpRsh8Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux32 <t> x y)
// cond:
// result: (ANDW (SRW <t> (MOVBZreg x) y) (SUBEWcarrymask <t> (CMPWUconst y [7])))
y := v.Args[1]
v.reset(OpS390XANDW)
v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
- v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
v0.AddArg(y)
func rewriteValueS390X_OpRsh8Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux64 <t> x y)
// cond:
// result: (ANDW (SRW <t> (MOVBZreg x) y) (SUBEWcarrymask <t> (CMPUconst y [7])))
y := v.Args[1]
v.reset(OpS390XANDW)
v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
- v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
v0.AddArg(y)
func rewriteValueS390X_OpRsh8Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux8 <t> x y)
// cond:
// result: (ANDW (SRW <t> (MOVBZreg x) y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [7])))
y := v.Args[1]
v.reset(OpS390XANDW)
v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
- v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v1.AddArg(x)
v0.AddArg(v1)
v0.AddArg(y)
v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v3.AuxInt = 7
- v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v4.AddArg(y)
v3.AddArg(v4)
v2.AddArg(v3)
func rewriteValueS390X_OpRsh8x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x16 <t> x y)
// cond:
// result: (SRAW <t> (MOVBreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVHZreg y) [7])))))
y := v.Args[1]
v.reset(OpS390XSRAW)
v.Type = t
- v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
v3 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
v4 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v4.AuxInt = 7
- v5 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v3.AddArg(v4)
func rewriteValueS390X_OpRsh8x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x32 <t> x y)
// cond:
// result: (SRAW <t> (MOVBreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst y [7])))))
y := v.Args[1]
v.reset(OpS390XSRAW)
v.Type = t
- v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
func rewriteValueS390X_OpRsh8x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x64 <t> x y)
// cond:
// result: (SRAW <t> (MOVBreg x) (OR <y.Type> y (NOT <y.Type> (SUBEcarrymask <y.Type> (CMPUconst y [7])))))
y := v.Args[1]
v.reset(OpS390XSRAW)
v.Type = t
- v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpS390XOR, y.Type)
func rewriteValueS390X_OpRsh8x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x8 <t> x y)
// cond:
// result: (SRAW <t> (MOVBreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVBZreg y) [7])))))
y := v.Args[1]
v.reset(OpS390XSRAW)
v.Type = t
- v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, fe.TypeInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, types.Int64)
v0.AddArg(x)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
v3 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
v4 := b.NewValue0(v.Pos, OpS390XCMPWUconst, TypeFlags)
v4.AuxInt = 7
- v5 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.UInt64)
v5.AddArg(y)
v4.AddArg(v5)
v3.AddArg(v4)
func rewriteValueS390X_OpS390XMOVWstoreconst(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (MOVWstoreconst [sc] {s} (ADDconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVWstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
v.AuxInt = ValAndOff(a).Off()
v.Aux = s
v.AddArg(p)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = ValAndOff(c).Val()&0xffffffff | ValAndOff(a).Val()<<32
v.AddArg(v0)
v.AddArg(mem)
func rewriteValueS390X_OpS390XNOT(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (NOT x)
// cond: true
// result: (XOR (MOVDconst [-1]) x)
break
}
v.reset(OpS390XXOR)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, types.UInt64)
v0.AuxInt = -1
v.AddArg(v0)
v.AddArg(x)
func rewriteValueS390X_OpS390XOR(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR x (MOVDconst [c]))
// cond: isU32Bit(c)
// result: (ORconst [c] x)
break
}
b = mergePoint(b, x0, x1, x2, x3, x4, x5, x6, x7)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDBRload, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDBRload, types.UInt64)
v.reset(OpCopy)
v.AddArg(v0)
v0.AuxInt = i
break
}
b = mergePoint(b, x0, x1, x2, x3, x4, x5, x6, x7)
- v0 := b.NewValue0(v.Pos, OpS390XMOVDload, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVDload, types.UInt64)
v.reset(OpCopy)
v.AddArg(v0)
v0.AuxInt = i - 7
func rewriteValueS390X_OpS390XORW(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW x (MOVDconst [c]))
// cond:
// result: (ORWconst [c] x)
break
}
b = mergePoint(b, x0, x1)
- v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v.reset(OpCopy)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpS390XMOVHBRload, fe.TypeUInt16())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVHBRload, types.UInt16)
v1.AuxInt = i
v1.Aux = s
v1.AddArg(p)
break
}
b = mergePoint(b, x0, x1, x2)
- v0 := b.NewValue0(v.Pos, OpS390XMOVWBRload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVWBRload, types.UInt32)
v.reset(OpCopy)
v.AddArg(v0)
v0.AuxInt = i
break
}
b = mergePoint(b, x0, x1)
- v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, types.UInt64)
v.reset(OpCopy)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, v.Type)
break
}
b = mergePoint(b, x0, x1, x2)
- v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, types.UInt64)
v.reset(OpCopy)
v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, v.Type)
break
}
b = mergePoint(b, x0, x1)
- v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, types.UInt16)
v.reset(OpCopy)
v.AddArg(v0)
v0.AuxInt = i - 1
break
}
b = mergePoint(b, x0, x1, x2)
- v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, types.UInt32)
v.reset(OpCopy)
v.AddArg(v0)
v0.AuxInt = i - 2
_ = config
fe := b.Func.fe
_ = fe
+ types := &config.Types
+ _ = types
switch b.Kind {
case BlockS390XEQ:
// match: (EQ (InvertFlags cmp) yes no)
}
// match: (If cond yes no)
// cond:
- // result: (NE (CMPWconst [0] (MOVBZreg <fe.TypeBool()> cond)) yes no)
+ // result: (NE (CMPWconst [0] (MOVBZreg <types.Bool> cond)) yes no)
for {
v := b.Control
_ = v
b.Kind = BlockS390XNE
v0 := b.NewValue0(v.Pos, OpS390XCMPWconst, TypeFlags)
v0.AuxInt = 0
- v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, fe.TypeBool())
+ v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, types.Bool)
v1.AddArg(cond)
v0.AddArg(v1)
b.SetControl(v0)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Load <t> ptr mem)
// cond: t.IsComplex() && t.Size() == 8
- // result: (ComplexMake (Load <fe.TypeFloat32()> ptr mem) (Load <fe.TypeFloat32()> (OffPtr <fe.TypeFloat32().PtrTo()> [4] ptr) mem) )
+ // result: (ComplexMake (Load <types.Float32> ptr mem) (Load <types.Float32> (OffPtr <types.Float32.PtrTo()> [4] ptr) mem) )
for {
t := v.Type
ptr := v.Args[0]
break
}
v.reset(OpComplexMake)
- v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeFloat32())
+ v0 := b.NewValue0(v.Pos, OpLoad, types.Float32)
v0.AddArg(ptr)
v0.AddArg(mem)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeFloat32())
- v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeFloat32().PtrTo())
+ v1 := b.NewValue0(v.Pos, OpLoad, types.Float32)
+ v2 := b.NewValue0(v.Pos, OpOffPtr, types.Float32.PtrTo())
v2.AuxInt = 4
v2.AddArg(ptr)
v1.AddArg(v2)
}
// match: (Load <t> ptr mem)
// cond: t.IsComplex() && t.Size() == 16
- // result: (ComplexMake (Load <fe.TypeFloat64()> ptr mem) (Load <fe.TypeFloat64()> (OffPtr <fe.TypeFloat64().PtrTo()> [8] ptr) mem) )
+ // result: (ComplexMake (Load <types.Float64> ptr mem) (Load <types.Float64> (OffPtr <types.Float64.PtrTo()> [8] ptr) mem) )
for {
t := v.Type
ptr := v.Args[0]
break
}
v.reset(OpComplexMake)
- v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeFloat64())
+ v0 := b.NewValue0(v.Pos, OpLoad, types.Float64)
v0.AddArg(ptr)
v0.AddArg(mem)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeFloat64())
- v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeFloat64().PtrTo())
+ v1 := b.NewValue0(v.Pos, OpLoad, types.Float64)
+ v2 := b.NewValue0(v.Pos, OpOffPtr, types.Float64.PtrTo())
v2.AuxInt = 8
v2.AddArg(ptr)
v1.AddArg(v2)
}
// match: (Load <t> ptr mem)
// cond: t.IsString()
- // result: (StringMake (Load <fe.TypeBytePtr()> ptr mem) (Load <fe.TypeInt()> (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] ptr) mem))
+ // result: (StringMake (Load <types.BytePtr> ptr mem) (Load <types.Int> (OffPtr <types.Int.PtrTo()> [config.PtrSize] ptr) mem))
for {
t := v.Type
ptr := v.Args[0]
break
}
v.reset(OpStringMake)
- v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeBytePtr())
+ v0 := b.NewValue0(v.Pos, OpLoad, types.BytePtr)
v0.AddArg(ptr)
v0.AddArg(mem)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeInt())
- v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo())
+ v1 := b.NewValue0(v.Pos, OpLoad, types.Int)
+ v2 := b.NewValue0(v.Pos, OpOffPtr, types.Int.PtrTo())
v2.AuxInt = config.PtrSize
v2.AddArg(ptr)
v1.AddArg(v2)
}
// match: (Load <t> ptr mem)
// cond: t.IsSlice()
- // result: (SliceMake (Load <t.ElemType().PtrTo()> ptr mem) (Load <fe.TypeInt()> (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] ptr) mem) (Load <fe.TypeInt()> (OffPtr <fe.TypeInt().PtrTo()> [2*config.PtrSize] ptr) mem))
+ // result: (SliceMake (Load <t.ElemType().PtrTo()> ptr mem) (Load <types.Int> (OffPtr <types.Int.PtrTo()> [config.PtrSize] ptr) mem) (Load <types.Int> (OffPtr <types.Int.PtrTo()> [2*config.PtrSize] ptr) mem))
for {
t := v.Type
ptr := v.Args[0]
v0.AddArg(ptr)
v0.AddArg(mem)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeInt())
- v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo())
+ v1 := b.NewValue0(v.Pos, OpLoad, types.Int)
+ v2 := b.NewValue0(v.Pos, OpOffPtr, types.Int.PtrTo())
v2.AuxInt = config.PtrSize
v2.AddArg(ptr)
v1.AddArg(v2)
v1.AddArg(mem)
v.AddArg(v1)
- v3 := b.NewValue0(v.Pos, OpLoad, fe.TypeInt())
- v4 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo())
+ v3 := b.NewValue0(v.Pos, OpLoad, types.Int)
+ v4 := b.NewValue0(v.Pos, OpOffPtr, types.Int.PtrTo())
v4.AuxInt = 2 * config.PtrSize
v4.AddArg(ptr)
v3.AddArg(v4)
}
// match: (Load <t> ptr mem)
// cond: t.IsInterface()
- // result: (IMake (Load <fe.TypeBytePtr()> ptr mem) (Load <fe.TypeBytePtr()> (OffPtr <fe.TypeBytePtr().PtrTo()> [config.PtrSize] ptr) mem))
+ // result: (IMake (Load <types.BytePtr> ptr mem) (Load <types.BytePtr> (OffPtr <types.BytePtr.PtrTo()> [config.PtrSize] ptr) mem))
for {
t := v.Type
ptr := v.Args[0]
break
}
v.reset(OpIMake)
- v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeBytePtr())
+ v0 := b.NewValue0(v.Pos, OpLoad, types.BytePtr)
v0.AddArg(ptr)
v0.AddArg(mem)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeBytePtr())
- v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeBytePtr().PtrTo())
+ v1 := b.NewValue0(v.Pos, OpLoad, types.BytePtr)
+ v2 := b.NewValue0(v.Pos, OpOffPtr, types.BytePtr.PtrTo())
v2.AuxInt = config.PtrSize
v2.AddArg(ptr)
v1.AddArg(v2)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Store {t} dst (ComplexMake real imag) mem)
// cond: t.(Type).Size() == 8
- // result: (Store {fe.TypeFloat32()} (OffPtr <fe.TypeFloat32().PtrTo()> [4] dst) imag (Store {fe.TypeFloat32()} dst real mem))
+ // result: (Store {types.Float32} (OffPtr <types.Float32.PtrTo()> [4] dst) imag (Store {types.Float32} dst real mem))
for {
t := v.Aux
dst := v.Args[0]
break
}
v.reset(OpStore)
- v.Aux = fe.TypeFloat32()
- v0 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeFloat32().PtrTo())
+ v.Aux = types.Float32
+ v0 := b.NewValue0(v.Pos, OpOffPtr, types.Float32.PtrTo())
v0.AuxInt = 4
v0.AddArg(dst)
v.AddArg(v0)
v.AddArg(imag)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v1.Aux = fe.TypeFloat32()
+ v1.Aux = types.Float32
v1.AddArg(dst)
v1.AddArg(real)
v1.AddArg(mem)
}
// match: (Store {t} dst (ComplexMake real imag) mem)
// cond: t.(Type).Size() == 16
- // result: (Store {fe.TypeFloat64()} (OffPtr <fe.TypeFloat64().PtrTo()> [8] dst) imag (Store {fe.TypeFloat64()} dst real mem))
+ // result: (Store {types.Float64} (OffPtr <types.Float64.PtrTo()> [8] dst) imag (Store {types.Float64} dst real mem))
for {
t := v.Aux
dst := v.Args[0]
break
}
v.reset(OpStore)
- v.Aux = fe.TypeFloat64()
- v0 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeFloat64().PtrTo())
+ v.Aux = types.Float64
+ v0 := b.NewValue0(v.Pos, OpOffPtr, types.Float64.PtrTo())
v0.AuxInt = 8
v0.AddArg(dst)
v.AddArg(v0)
v.AddArg(imag)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v1.Aux = fe.TypeFloat64()
+ v1.Aux = types.Float64
v1.AddArg(dst)
v1.AddArg(real)
v1.AddArg(mem)
}
// match: (Store dst (StringMake ptr len) mem)
// cond:
- // result: (Store {fe.TypeInt()} (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] dst) len (Store {fe.TypeBytePtr()} dst ptr mem))
+ // result: (Store {types.Int} (OffPtr <types.Int.PtrTo()> [config.PtrSize] dst) len (Store {types.BytePtr} dst ptr mem))
for {
dst := v.Args[0]
v_1 := v.Args[1]
len := v_1.Args[1]
mem := v.Args[2]
v.reset(OpStore)
- v.Aux = fe.TypeInt()
- v0 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo())
+ v.Aux = types.Int
+ v0 := b.NewValue0(v.Pos, OpOffPtr, types.Int.PtrTo())
v0.AuxInt = config.PtrSize
v0.AddArg(dst)
v.AddArg(v0)
v.AddArg(len)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v1.Aux = fe.TypeBytePtr()
+ v1.Aux = types.BytePtr
v1.AddArg(dst)
v1.AddArg(ptr)
v1.AddArg(mem)
}
// match: (Store dst (SliceMake ptr len cap) mem)
// cond:
- // result: (Store {fe.TypeInt()} (OffPtr <fe.TypeInt().PtrTo()> [2*config.PtrSize] dst) cap (Store {fe.TypeInt()} (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] dst) len (Store {fe.TypeBytePtr()} dst ptr mem)))
+ // result: (Store {types.Int} (OffPtr <types.Int.PtrTo()> [2*config.PtrSize] dst) cap (Store {types.Int} (OffPtr <types.Int.PtrTo()> [config.PtrSize] dst) len (Store {types.BytePtr} dst ptr mem)))
for {
dst := v.Args[0]
v_1 := v.Args[1]
cap := v_1.Args[2]
mem := v.Args[2]
v.reset(OpStore)
- v.Aux = fe.TypeInt()
- v0 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo())
+ v.Aux = types.Int
+ v0 := b.NewValue0(v.Pos, OpOffPtr, types.Int.PtrTo())
v0.AuxInt = 2 * config.PtrSize
v0.AddArg(dst)
v.AddArg(v0)
v.AddArg(cap)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v1.Aux = fe.TypeInt()
- v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo())
+ v1.Aux = types.Int
+ v2 := b.NewValue0(v.Pos, OpOffPtr, types.Int.PtrTo())
v2.AuxInt = config.PtrSize
v2.AddArg(dst)
v1.AddArg(v2)
v1.AddArg(len)
v3 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v3.Aux = fe.TypeBytePtr()
+ v3.Aux = types.BytePtr
v3.AddArg(dst)
v3.AddArg(ptr)
v3.AddArg(mem)
}
// match: (Store dst (IMake itab data) mem)
// cond:
- // result: (Store {fe.TypeBytePtr()} (OffPtr <fe.TypeBytePtr().PtrTo()> [config.PtrSize] dst) data (Store {fe.TypeUintptr()} dst itab mem))
+ // result: (Store {types.BytePtr} (OffPtr <types.BytePtr.PtrTo()> [config.PtrSize] dst) data (Store {types.Uintptr} dst itab mem))
for {
dst := v.Args[0]
v_1 := v.Args[1]
data := v_1.Args[1]
mem := v.Args[2]
v.reset(OpStore)
- v.Aux = fe.TypeBytePtr()
- v0 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeBytePtr().PtrTo())
+ v.Aux = types.BytePtr
+ v0 := b.NewValue0(v.Pos, OpOffPtr, types.BytePtr.PtrTo())
v0.AuxInt = config.PtrSize
v0.AddArg(dst)
v.AddArg(v0)
v.AddArg(data)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
- v1.Aux = fe.TypeUintptr()
+ v1.Aux = types.Uintptr
v1.AddArg(dst)
v1.AddArg(itab)
v1.AddArg(mem)
_ = config
fe := b.Func.fe
_ = fe
+ types := &config.Types
+ _ = types
switch b.Kind {
}
return false
func rewriteValuedec64_OpAdd64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Add64 x y)
// cond:
- // result: (Int64Make (Add32withcarry <fe.TypeInt32()> (Int64Hi x) (Int64Hi y) (Select1 <TypeFlags> (Add32carry (Int64Lo x) (Int64Lo y)))) (Select0 <fe.TypeUInt32()> (Add32carry (Int64Lo x) (Int64Lo y))))
+ // result: (Int64Make (Add32withcarry <types.Int32> (Int64Hi x) (Int64Hi y) (Select1 <TypeFlags> (Add32carry (Int64Lo x) (Int64Lo y)))) (Select0 <types.UInt32> (Add32carry (Int64Lo x) (Int64Lo y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpAdd32withcarry, fe.TypeInt32())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpAdd32withcarry, types.Int32)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpSelect1, TypeFlags)
- v4 := b.NewValue0(v.Pos, OpAdd32carry, MakeTuple(fe.TypeUInt32(), TypeFlags))
- v5 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpAdd32carry, MakeTuple(types.UInt32, TypeFlags))
+ v5 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v6.AddArg(y)
v4.AddArg(v6)
v3.AddArg(v4)
v0.AddArg(v3)
v.AddArg(v0)
- v7 := b.NewValue0(v.Pos, OpSelect0, fe.TypeUInt32())
- v8 := b.NewValue0(v.Pos, OpAdd32carry, MakeTuple(fe.TypeUInt32(), TypeFlags))
- v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpSelect0, types.UInt32)
+ v8 := b.NewValue0(v.Pos, OpAdd32carry, MakeTuple(types.UInt32, TypeFlags))
+ v9 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v9.AddArg(x)
v8.AddArg(v9)
- v10 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v10 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v10.AddArg(y)
v8.AddArg(v10)
v7.AddArg(v8)
func rewriteValuedec64_OpAnd64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (And64 x y)
// cond:
- // result: (Int64Make (And32 <fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) (And32 <fe.TypeUInt32()> (Int64Lo x) (Int64Lo y)))
+ // result: (Int64Make (And32 <types.UInt32> (Int64Hi x) (Int64Hi y)) (And32 <types.UInt32> (Int64Lo x) (Int64Lo y)))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpAnd32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpAnd32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpAnd32, fe.TypeUInt32())
- v4 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpAnd32, types.UInt32)
+ v4 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v4.AddArg(x)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v5.AddArg(y)
v3.AddArg(v5)
v.AddArg(v3)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Arg {n} [off])
// cond: is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned()
- // result: (Int64Make (Arg <fe.TypeInt32()> {n} [off+4]) (Arg <fe.TypeUInt32()> {n} [off]))
+ // result: (Int64Make (Arg <types.Int32> {n} [off+4]) (Arg <types.UInt32> {n} [off]))
for {
off := v.AuxInt
n := v.Aux
break
}
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpArg, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpArg, types.Int32)
v0.AuxInt = off + 4
v0.Aux = n
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpArg, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpArg, types.UInt32)
v1.AuxInt = off
v1.Aux = n
v.AddArg(v1)
}
// match: (Arg {n} [off])
// cond: is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned()
- // result: (Int64Make (Arg <fe.TypeUInt32()> {n} [off+4]) (Arg <fe.TypeUInt32()> {n} [off]))
+ // result: (Int64Make (Arg <types.UInt32> {n} [off+4]) (Arg <types.UInt32> {n} [off]))
for {
off := v.AuxInt
n := v.Aux
break
}
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpArg, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpArg, types.UInt32)
v0.AuxInt = off + 4
v0.Aux = n
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpArg, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpArg, types.UInt32)
v1.AuxInt = off
v1.Aux = n
v.AddArg(v1)
}
// match: (Arg {n} [off])
// cond: is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned()
- // result: (Int64Make (Arg <fe.TypeInt32()> {n} [off]) (Arg <fe.TypeUInt32()> {n} [off+4]))
+ // result: (Int64Make (Arg <types.Int32> {n} [off]) (Arg <types.UInt32> {n} [off+4]))
for {
off := v.AuxInt
n := v.Aux
break
}
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpArg, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpArg, types.Int32)
v0.AuxInt = off
v0.Aux = n
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpArg, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpArg, types.UInt32)
v1.AuxInt = off + 4
v1.Aux = n
v.AddArg(v1)
}
// match: (Arg {n} [off])
// cond: is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned()
- // result: (Int64Make (Arg <fe.TypeUInt32()> {n} [off]) (Arg <fe.TypeUInt32()> {n} [off+4]))
+ // result: (Int64Make (Arg <types.UInt32> {n} [off]) (Arg <types.UInt32> {n} [off+4]))
for {
off := v.AuxInt
n := v.Aux
break
}
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpArg, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpArg, types.UInt32)
v0.AuxInt = off
v0.Aux = n
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpArg, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpArg, types.UInt32)
v1.AuxInt = off + 4
v1.Aux = n
v.AddArg(v1)
func rewriteValuedec64_OpBitLen64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (BitLen64 x)
// cond:
- // result: (Add32 <fe.TypeInt()> (BitLen32 <fe.TypeInt()> (Int64Hi x)) (BitLen32 <fe.TypeInt()> (Or32 <fe.TypeUInt32()> (Int64Lo x) (Zeromask (Int64Hi x)))))
+ // result: (Add32 <types.Int> (BitLen32 <types.Int> (Int64Hi x)) (BitLen32 <types.Int> (Or32 <types.UInt32> (Int64Lo x) (Zeromask (Int64Hi x)))))
for {
x := v.Args[0]
v.reset(OpAdd32)
- v.Type = fe.TypeInt()
- v0 := b.NewValue0(v.Pos, OpBitLen32, fe.TypeInt())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v.Type = types.Int
+ v0 := b.NewValue0(v.Pos, OpBitLen32, types.Int)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpBitLen32, fe.TypeInt())
- v3 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v4 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpBitLen32, types.Int)
+ v3 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v4 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v4.AddArg(x)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
- v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
+ v6 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v6.AddArg(x)
v5.AddArg(v6)
v3.AddArg(v5)
func rewriteValuedec64_OpBswap64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Bswap64 x)
// cond:
- // result: (Int64Make (Bswap32 <fe.TypeUInt32()> (Int64Lo x)) (Bswap32 <fe.TypeUInt32()> (Int64Hi x)))
+ // result: (Int64Make (Bswap32 <types.UInt32> (Int64Lo x)) (Bswap32 <types.UInt32> (Int64Hi x)))
for {
x := v.Args[0]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpBswap32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpBswap32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpBswap32, fe.TypeUInt32())
- v3 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpBswap32, types.UInt32)
+ v3 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v3.AddArg(x)
v2.AddArg(v3)
v.AddArg(v2)
func rewriteValuedec64_OpCom64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Com64 x)
// cond:
- // result: (Int64Make (Com32 <fe.TypeUInt32()> (Int64Hi x)) (Com32 <fe.TypeUInt32()> (Int64Lo x)))
+ // result: (Int64Make (Com32 <types.UInt32> (Int64Hi x)) (Com32 <types.UInt32> (Int64Lo x)))
for {
x := v.Args[0]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpCom32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpCom32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpCom32, fe.TypeUInt32())
- v3 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpCom32, types.UInt32)
+ v3 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v3.AddArg(x)
v2.AddArg(v3)
v.AddArg(v2)
func rewriteValuedec64_OpConst64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Const64 <t> [c])
// cond: t.IsSigned()
- // result: (Int64Make (Const32 <fe.TypeInt32()> [c>>32]) (Const32 <fe.TypeUInt32()> [int64(int32(c))]))
+ // result: (Int64Make (Const32 <types.Int32> [c>>32]) (Const32 <types.UInt32> [int64(int32(c))]))
for {
t := v.Type
c := v.AuxInt
break
}
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpConst32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpConst32, types.Int32)
v0.AuxInt = c >> 32
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v1.AuxInt = int64(int32(c))
v.AddArg(v1)
return true
}
// match: (Const64 <t> [c])
// cond: !t.IsSigned()
- // result: (Int64Make (Const32 <fe.TypeUInt32()> [c>>32]) (Const32 <fe.TypeUInt32()> [int64(int32(c))]))
+ // result: (Int64Make (Const32 <types.UInt32> [c>>32]) (Const32 <types.UInt32> [int64(int32(c))]))
for {
t := v.Type
c := v.AuxInt
break
}
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v0.AuxInt = c >> 32
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v1.AuxInt = int64(int32(c))
v.AddArg(v1)
return true
func rewriteValuedec64_OpCtz64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Ctz64 x)
// cond:
- // result: (Add32 <fe.TypeUInt32()> (Ctz32 <fe.TypeUInt32()> (Int64Lo x)) (And32 <fe.TypeUInt32()> (Com32 <fe.TypeUInt32()> (Zeromask (Int64Lo x))) (Ctz32 <fe.TypeUInt32()> (Int64Hi x))))
+ // result: (Add32 <types.UInt32> (Ctz32 <types.UInt32> (Int64Lo x)) (And32 <types.UInt32> (Com32 <types.UInt32> (Zeromask (Int64Lo x))) (Ctz32 <types.UInt32> (Int64Hi x))))
for {
x := v.Args[0]
v.reset(OpAdd32)
- v.Type = fe.TypeUInt32()
- v0 := b.NewValue0(v.Pos, OpCtz32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v.Type = types.UInt32
+ v0 := b.NewValue0(v.Pos, OpCtz32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpAnd32, fe.TypeUInt32())
- v3 := b.NewValue0(v.Pos, OpCom32, fe.TypeUInt32())
- v4 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
- v5 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpAnd32, types.UInt32)
+ v3 := b.NewValue0(v.Pos, OpCom32, types.UInt32)
+ v4 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
+ v5 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v5.AddArg(x)
v4.AddArg(v5)
v3.AddArg(v4)
v2.AddArg(v3)
- v6 := b.NewValue0(v.Pos, OpCtz32, fe.TypeUInt32())
- v7 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpCtz32, types.UInt32)
+ v7 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v7.AddArg(x)
v6.AddArg(v7)
v2.AddArg(v6)
func rewriteValuedec64_OpEq64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Eq64 x y)
// cond:
// result: (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Eq32 (Int64Lo x) (Int64Lo y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpAndB)
- v0 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpEq32, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpEq32, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v4.AddArg(x)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v5.AddArg(y)
v3.AddArg(v5)
v.AddArg(v3)
func rewriteValuedec64_OpGeq64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq64 x y)
// cond:
// result: (OrB (Greater32 (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Geq32U (Int64Lo x) (Int64Lo y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpOrB)
- v0 := b.NewValue0(v.Pos, OpGreater32, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpGreater32, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpAndB, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool())
- v5 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpAndB, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpEq32, types.Bool)
+ v5 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v6.AddArg(y)
v4.AddArg(v6)
v3.AddArg(v4)
- v7 := b.NewValue0(v.Pos, OpGeq32U, fe.TypeBool())
- v8 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpGeq32U, types.Bool)
+ v8 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v8.AddArg(x)
v7.AddArg(v8)
- v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v9 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v9.AddArg(y)
v7.AddArg(v9)
v3.AddArg(v7)
func rewriteValuedec64_OpGeq64U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Geq64U x y)
// cond:
// result: (OrB (Greater32U (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Geq32U (Int64Lo x) (Int64Lo y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpOrB)
- v0 := b.NewValue0(v.Pos, OpGreater32U, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpGreater32U, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpAndB, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool())
- v5 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpAndB, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpEq32, types.Bool)
+ v5 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v6.AddArg(y)
v4.AddArg(v6)
v3.AddArg(v4)
- v7 := b.NewValue0(v.Pos, OpGeq32U, fe.TypeBool())
- v8 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpGeq32U, types.Bool)
+ v8 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v8.AddArg(x)
v7.AddArg(v8)
- v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v9 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v9.AddArg(y)
v7.AddArg(v9)
v3.AddArg(v7)
func rewriteValuedec64_OpGreater64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater64 x y)
// cond:
// result: (OrB (Greater32 (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Greater32U (Int64Lo x) (Int64Lo y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpOrB)
- v0 := b.NewValue0(v.Pos, OpGreater32, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpGreater32, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpAndB, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool())
- v5 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpAndB, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpEq32, types.Bool)
+ v5 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v6.AddArg(y)
v4.AddArg(v6)
v3.AddArg(v4)
- v7 := b.NewValue0(v.Pos, OpGreater32U, fe.TypeBool())
- v8 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpGreater32U, types.Bool)
+ v8 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v8.AddArg(x)
v7.AddArg(v8)
- v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v9 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v9.AddArg(y)
v7.AddArg(v9)
v3.AddArg(v7)
func rewriteValuedec64_OpGreater64U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Greater64U x y)
// cond:
// result: (OrB (Greater32U (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Greater32U (Int64Lo x) (Int64Lo y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpOrB)
- v0 := b.NewValue0(v.Pos, OpGreater32U, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpGreater32U, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpAndB, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool())
- v5 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpAndB, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpEq32, types.Bool)
+ v5 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v6.AddArg(y)
v4.AddArg(v6)
v3.AddArg(v4)
- v7 := b.NewValue0(v.Pos, OpGreater32U, fe.TypeBool())
- v8 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpGreater32U, types.Bool)
+ v8 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v8.AddArg(x)
v7.AddArg(v8)
- v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v9 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v9.AddArg(y)
v7.AddArg(v9)
v3.AddArg(v7)
func rewriteValuedec64_OpLeq64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq64 x y)
// cond:
// result: (OrB (Less32 (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Leq32U (Int64Lo x) (Int64Lo y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpOrB)
- v0 := b.NewValue0(v.Pos, OpLess32, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpLess32, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpAndB, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool())
- v5 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpAndB, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpEq32, types.Bool)
+ v5 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v6.AddArg(y)
v4.AddArg(v6)
v3.AddArg(v4)
- v7 := b.NewValue0(v.Pos, OpLeq32U, fe.TypeBool())
- v8 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpLeq32U, types.Bool)
+ v8 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v8.AddArg(x)
v7.AddArg(v8)
- v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v9 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v9.AddArg(y)
v7.AddArg(v9)
v3.AddArg(v7)
func rewriteValuedec64_OpLeq64U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Leq64U x y)
// cond:
// result: (OrB (Less32U (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Leq32U (Int64Lo x) (Int64Lo y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpOrB)
- v0 := b.NewValue0(v.Pos, OpLess32U, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpLess32U, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpAndB, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool())
- v5 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpAndB, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpEq32, types.Bool)
+ v5 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v6.AddArg(y)
v4.AddArg(v6)
v3.AddArg(v4)
- v7 := b.NewValue0(v.Pos, OpLeq32U, fe.TypeBool())
- v8 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpLeq32U, types.Bool)
+ v8 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v8.AddArg(x)
v7.AddArg(v8)
- v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v9 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v9.AddArg(y)
v7.AddArg(v9)
v3.AddArg(v7)
func rewriteValuedec64_OpLess64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less64 x y)
// cond:
// result: (OrB (Less32 (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Less32U (Int64Lo x) (Int64Lo y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpOrB)
- v0 := b.NewValue0(v.Pos, OpLess32, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpLess32, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpAndB, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool())
- v5 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpAndB, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpEq32, types.Bool)
+ v5 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v6.AddArg(y)
v4.AddArg(v6)
v3.AddArg(v4)
- v7 := b.NewValue0(v.Pos, OpLess32U, fe.TypeBool())
- v8 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpLess32U, types.Bool)
+ v8 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v8.AddArg(x)
v7.AddArg(v8)
- v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v9 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v9.AddArg(y)
v7.AddArg(v9)
v3.AddArg(v7)
func rewriteValuedec64_OpLess64U(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Less64U x y)
// cond:
// result: (OrB (Less32U (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Less32U (Int64Lo x) (Int64Lo y))))
x := v.Args[0]
y := v.Args[1]
v.reset(OpOrB)
- v0 := b.NewValue0(v.Pos, OpLess32U, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpLess32U, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpAndB, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpEq32, fe.TypeBool())
- v5 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpAndB, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpEq32, types.Bool)
+ v5 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v6.AddArg(y)
v4.AddArg(v6)
v3.AddArg(v4)
- v7 := b.NewValue0(v.Pos, OpLess32U, fe.TypeBool())
- v8 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpLess32U, types.Bool)
+ v8 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v8.AddArg(x)
v7.AddArg(v8)
- v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v9 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v9.AddArg(y)
v7.AddArg(v9)
v3.AddArg(v7)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Load <t> ptr mem)
// cond: is64BitInt(t) && !config.BigEndian && t.IsSigned()
- // result: (Int64Make (Load <fe.TypeInt32()> (OffPtr <fe.TypeInt32().PtrTo()> [4] ptr) mem) (Load <fe.TypeUInt32()> ptr mem))
+ // result: (Int64Make (Load <types.Int32> (OffPtr <types.Int32.PtrTo()> [4] ptr) mem) (Load <types.UInt32> ptr mem))
for {
t := v.Type
ptr := v.Args[0]
break
}
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeInt32())
- v1 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt32().PtrTo())
+ v0 := b.NewValue0(v.Pos, OpLoad, types.Int32)
+ v1 := b.NewValue0(v.Pos, OpOffPtr, types.Int32.PtrTo())
v1.AuxInt = 4
v1.AddArg(ptr)
v0.AddArg(v1)
v0.AddArg(mem)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpLoad, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpLoad, types.UInt32)
v2.AddArg(ptr)
v2.AddArg(mem)
v.AddArg(v2)
}
// match: (Load <t> ptr mem)
// cond: is64BitInt(t) && !config.BigEndian && !t.IsSigned()
- // result: (Int64Make (Load <fe.TypeUInt32()> (OffPtr <fe.TypeUInt32().PtrTo()> [4] ptr) mem) (Load <fe.TypeUInt32()> ptr mem))
+ // result: (Int64Make (Load <types.UInt32> (OffPtr <types.UInt32.PtrTo()> [4] ptr) mem) (Load <types.UInt32> ptr mem))
for {
t := v.Type
ptr := v.Args[0]
break
}
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeUInt32().PtrTo())
+ v0 := b.NewValue0(v.Pos, OpLoad, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpOffPtr, types.UInt32.PtrTo())
v1.AuxInt = 4
v1.AddArg(ptr)
v0.AddArg(v1)
v0.AddArg(mem)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpLoad, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpLoad, types.UInt32)
v2.AddArg(ptr)
v2.AddArg(mem)
v.AddArg(v2)
}
// match: (Load <t> ptr mem)
// cond: is64BitInt(t) && config.BigEndian && t.IsSigned()
- // result: (Int64Make (Load <fe.TypeInt32()> ptr mem) (Load <fe.TypeUInt32()> (OffPtr <fe.TypeUInt32().PtrTo()> [4] ptr) mem))
+ // result: (Int64Make (Load <types.Int32> ptr mem) (Load <types.UInt32> (OffPtr <types.UInt32.PtrTo()> [4] ptr) mem))
for {
t := v.Type
ptr := v.Args[0]
break
}
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpLoad, types.Int32)
v0.AddArg(ptr)
v0.AddArg(mem)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeUInt32().PtrTo())
+ v1 := b.NewValue0(v.Pos, OpLoad, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpOffPtr, types.UInt32.PtrTo())
v2.AuxInt = 4
v2.AddArg(ptr)
v1.AddArg(v2)
}
// match: (Load <t> ptr mem)
// cond: is64BitInt(t) && config.BigEndian && !t.IsSigned()
- // result: (Int64Make (Load <fe.TypeUInt32()> ptr mem) (Load <fe.TypeUInt32()> (OffPtr <fe.TypeUInt32().PtrTo()> [4] ptr) mem))
+ // result: (Int64Make (Load <types.UInt32> ptr mem) (Load <types.UInt32> (OffPtr <types.UInt32.PtrTo()> [4] ptr) mem))
for {
t := v.Type
ptr := v.Args[0]
break
}
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpLoad, types.UInt32)
v0.AddArg(ptr)
v0.AddArg(mem)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeUInt32().PtrTo())
+ v1 := b.NewValue0(v.Pos, OpLoad, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpOffPtr, types.UInt32.PtrTo())
v2.AuxInt = 4
v2.AddArg(ptr)
v1.AddArg(v2)
func rewriteValuedec64_OpLsh16x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x64 _ (Int64Make (Const32 [c]) _))
// cond: c != 0
// result: (Const32 [0])
}
// match: (Lsh16x64 x (Int64Make hi lo))
// cond: hi.Op != OpConst32
- // result: (Lsh16x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ // result: (Lsh16x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpLsh16x32)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
v1.AddArg(hi)
v0.AddArg(v1)
v0.AddArg(lo)
func rewriteValuedec64_OpLsh32x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x64 _ (Int64Make (Const32 [c]) _))
// cond: c != 0
// result: (Const32 [0])
}
// match: (Lsh32x64 x (Int64Make hi lo))
// cond: hi.Op != OpConst32
- // result: (Lsh32x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ // result: (Lsh32x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpLsh32x32)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
v1.AddArg(hi)
v0.AddArg(v1)
v0.AddArg(lo)
func rewriteValuedec64_OpLsh64x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x16 (Int64Make hi lo) s)
// cond:
- // result: (Int64Make (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Lsh32x16 <fe.TypeUInt32()> hi s) (Rsh32Ux16 <fe.TypeUInt32()> lo (Sub16 <fe.TypeUInt16()> (Const16 <fe.TypeUInt16()> [32]) s))) (Lsh32x16 <fe.TypeUInt32()> lo (Sub16 <fe.TypeUInt16()> s (Const16 <fe.TypeUInt16()> [32])))) (Lsh32x16 <fe.TypeUInt32()> lo s))
+ // result: (Int64Make (Or32 <types.UInt32> (Or32 <types.UInt32> (Lsh32x16 <types.UInt32> hi s) (Rsh32Ux16 <types.UInt32> lo (Sub16 <types.UInt16> (Const16 <types.UInt16> [32]) s))) (Lsh32x16 <types.UInt32> lo (Sub16 <types.UInt16> s (Const16 <types.UInt16> [32])))) (Lsh32x16 <types.UInt32> lo s))
for {
v_0 := v.Args[0]
if v_0.Op != OpInt64Make {
lo := v_0.Args[1]
s := v.Args[1]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpLsh32x16, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpLsh32x16, types.UInt32)
v2.AddArg(hi)
v2.AddArg(s)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpRsh32Ux16, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpRsh32Ux16, types.UInt32)
v3.AddArg(lo)
- v4 := b.NewValue0(v.Pos, OpSub16, fe.TypeUInt16())
- v5 := b.NewValue0(v.Pos, OpConst16, fe.TypeUInt16())
+ v4 := b.NewValue0(v.Pos, OpSub16, types.UInt16)
+ v5 := b.NewValue0(v.Pos, OpConst16, types.UInt16)
v5.AuxInt = 32
v4.AddArg(v5)
v4.AddArg(s)
v3.AddArg(v4)
v1.AddArg(v3)
v0.AddArg(v1)
- v6 := b.NewValue0(v.Pos, OpLsh32x16, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpLsh32x16, types.UInt32)
v6.AddArg(lo)
- v7 := b.NewValue0(v.Pos, OpSub16, fe.TypeUInt16())
+ v7 := b.NewValue0(v.Pos, OpSub16, types.UInt16)
v7.AddArg(s)
- v8 := b.NewValue0(v.Pos, OpConst16, fe.TypeUInt16())
+ v8 := b.NewValue0(v.Pos, OpConst16, types.UInt16)
v8.AuxInt = 32
v7.AddArg(v8)
v6.AddArg(v7)
v0.AddArg(v6)
v.AddArg(v0)
- v9 := b.NewValue0(v.Pos, OpLsh32x16, fe.TypeUInt32())
+ v9 := b.NewValue0(v.Pos, OpLsh32x16, types.UInt32)
v9.AddArg(lo)
v9.AddArg(s)
v.AddArg(v9)
func rewriteValuedec64_OpLsh64x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x32 (Int64Make hi lo) s)
// cond:
- // result: (Int64Make (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Lsh32x32 <fe.TypeUInt32()> hi s) (Rsh32Ux32 <fe.TypeUInt32()> lo (Sub32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [32]) s))) (Lsh32x32 <fe.TypeUInt32()> lo (Sub32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [32])))) (Lsh32x32 <fe.TypeUInt32()> lo s))
+ // result: (Int64Make (Or32 <types.UInt32> (Or32 <types.UInt32> (Lsh32x32 <types.UInt32> hi s) (Rsh32Ux32 <types.UInt32> lo (Sub32 <types.UInt32> (Const32 <types.UInt32> [32]) s))) (Lsh32x32 <types.UInt32> lo (Sub32 <types.UInt32> s (Const32 <types.UInt32> [32])))) (Lsh32x32 <types.UInt32> lo s))
for {
v_0 := v.Args[0]
if v_0.Op != OpInt64Make {
lo := v_0.Args[1]
s := v.Args[1]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpLsh32x32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpLsh32x32, types.UInt32)
v2.AddArg(hi)
v2.AddArg(s)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpRsh32Ux32, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpRsh32Ux32, types.UInt32)
v3.AddArg(lo)
- v4 := b.NewValue0(v.Pos, OpSub32, fe.TypeUInt32())
- v5 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpSub32, types.UInt32)
+ v5 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v5.AuxInt = 32
v4.AddArg(v5)
v4.AddArg(s)
v3.AddArg(v4)
v1.AddArg(v3)
v0.AddArg(v1)
- v6 := b.NewValue0(v.Pos, OpLsh32x32, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpLsh32x32, types.UInt32)
v6.AddArg(lo)
- v7 := b.NewValue0(v.Pos, OpSub32, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpSub32, types.UInt32)
v7.AddArg(s)
- v8 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v8 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v8.AuxInt = 32
v7.AddArg(v8)
v6.AddArg(v7)
v0.AddArg(v6)
v.AddArg(v0)
- v9 := b.NewValue0(v.Pos, OpLsh32x32, fe.TypeUInt32())
+ v9 := b.NewValue0(v.Pos, OpLsh32x32, types.UInt32)
v9.AddArg(lo)
v9.AddArg(s)
v.AddArg(v9)
func rewriteValuedec64_OpLsh64x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x64 _ (Int64Make (Const32 [c]) _))
// cond: c != 0
// result: (Const64 [0])
}
// match: (Lsh64x64 x (Int64Make hi lo))
// cond: hi.Op != OpConst32
- // result: (Lsh64x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ // result: (Lsh64x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpLsh64x32)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
v1.AddArg(hi)
v0.AddArg(v1)
v0.AddArg(lo)
func rewriteValuedec64_OpLsh64x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x8 (Int64Make hi lo) s)
// cond:
- // result: (Int64Make (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Lsh32x8 <fe.TypeUInt32()> hi s) (Rsh32Ux8 <fe.TypeUInt32()> lo (Sub8 <fe.TypeUInt8()> (Const8 <fe.TypeUInt8()> [32]) s))) (Lsh32x8 <fe.TypeUInt32()> lo (Sub8 <fe.TypeUInt8()> s (Const8 <fe.TypeUInt8()> [32])))) (Lsh32x8 <fe.TypeUInt32()> lo s))
+ // result: (Int64Make (Or32 <types.UInt32> (Or32 <types.UInt32> (Lsh32x8 <types.UInt32> hi s) (Rsh32Ux8 <types.UInt32> lo (Sub8 <types.UInt8> (Const8 <types.UInt8> [32]) s))) (Lsh32x8 <types.UInt32> lo (Sub8 <types.UInt8> s (Const8 <types.UInt8> [32])))) (Lsh32x8 <types.UInt32> lo s))
for {
v_0 := v.Args[0]
if v_0.Op != OpInt64Make {
lo := v_0.Args[1]
s := v.Args[1]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpLsh32x8, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpLsh32x8, types.UInt32)
v2.AddArg(hi)
v2.AddArg(s)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpRsh32Ux8, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpRsh32Ux8, types.UInt32)
v3.AddArg(lo)
- v4 := b.NewValue0(v.Pos, OpSub8, fe.TypeUInt8())
- v5 := b.NewValue0(v.Pos, OpConst8, fe.TypeUInt8())
+ v4 := b.NewValue0(v.Pos, OpSub8, types.UInt8)
+ v5 := b.NewValue0(v.Pos, OpConst8, types.UInt8)
v5.AuxInt = 32
v4.AddArg(v5)
v4.AddArg(s)
v3.AddArg(v4)
v1.AddArg(v3)
v0.AddArg(v1)
- v6 := b.NewValue0(v.Pos, OpLsh32x8, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpLsh32x8, types.UInt32)
v6.AddArg(lo)
- v7 := b.NewValue0(v.Pos, OpSub8, fe.TypeUInt8())
+ v7 := b.NewValue0(v.Pos, OpSub8, types.UInt8)
v7.AddArg(s)
- v8 := b.NewValue0(v.Pos, OpConst8, fe.TypeUInt8())
+ v8 := b.NewValue0(v.Pos, OpConst8, types.UInt8)
v8.AuxInt = 32
v7.AddArg(v8)
v6.AddArg(v7)
v0.AddArg(v6)
v.AddArg(v0)
- v9 := b.NewValue0(v.Pos, OpLsh32x8, fe.TypeUInt32())
+ v9 := b.NewValue0(v.Pos, OpLsh32x8, types.UInt32)
v9.AddArg(lo)
v9.AddArg(s)
v.AddArg(v9)
func rewriteValuedec64_OpLsh8x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x64 _ (Int64Make (Const32 [c]) _))
// cond: c != 0
// result: (Const32 [0])
}
// match: (Lsh8x64 x (Int64Make hi lo))
// cond: hi.Op != OpConst32
- // result: (Lsh8x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ // result: (Lsh8x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpLsh8x32)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
v1.AddArg(hi)
v0.AddArg(v1)
v0.AddArg(lo)
func rewriteValuedec64_OpMul64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mul64 x y)
// cond:
- // result: (Int64Make (Add32 <fe.TypeUInt32()> (Mul32 <fe.TypeUInt32()> (Int64Lo x) (Int64Hi y)) (Add32 <fe.TypeUInt32()> (Mul32 <fe.TypeUInt32()> (Int64Hi x) (Int64Lo y)) (Select0 <fe.TypeUInt32()> (Mul32uhilo (Int64Lo x) (Int64Lo y))))) (Select1 <fe.TypeUInt32()> (Mul32uhilo (Int64Lo x) (Int64Lo y))))
+ // result: (Int64Make (Add32 <types.UInt32> (Mul32 <types.UInt32> (Int64Lo x) (Int64Hi y)) (Add32 <types.UInt32> (Mul32 <types.UInt32> (Int64Hi x) (Int64Lo y)) (Select0 <types.UInt32> (Mul32uhilo (Int64Lo x) (Int64Lo y))))) (Select1 <types.UInt32> (Mul32uhilo (Int64Lo x) (Int64Lo y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpAdd32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpMul32, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpAdd32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpMul32, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v2.AddArg(x)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v3.AddArg(y)
v1.AddArg(v3)
v0.AddArg(v1)
- v4 := b.NewValue0(v.Pos, OpAdd32, fe.TypeUInt32())
- v5 := b.NewValue0(v.Pos, OpMul32, fe.TypeUInt32())
- v6 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpAdd32, types.UInt32)
+ v5 := b.NewValue0(v.Pos, OpMul32, types.UInt32)
+ v6 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v6.AddArg(x)
v5.AddArg(v6)
- v7 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v7.AddArg(y)
v5.AddArg(v7)
v4.AddArg(v5)
- v8 := b.NewValue0(v.Pos, OpSelect0, fe.TypeUInt32())
- v9 := b.NewValue0(v.Pos, OpMul32uhilo, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
- v10 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v8 := b.NewValue0(v.Pos, OpSelect0, types.UInt32)
+ v9 := b.NewValue0(v.Pos, OpMul32uhilo, MakeTuple(types.UInt32, types.UInt32))
+ v10 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v10.AddArg(x)
v9.AddArg(v10)
- v11 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v11 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v11.AddArg(y)
v9.AddArg(v11)
v8.AddArg(v9)
v4.AddArg(v8)
v0.AddArg(v4)
v.AddArg(v0)
- v12 := b.NewValue0(v.Pos, OpSelect1, fe.TypeUInt32())
- v13 := b.NewValue0(v.Pos, OpMul32uhilo, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32()))
- v14 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v12 := b.NewValue0(v.Pos, OpSelect1, types.UInt32)
+ v13 := b.NewValue0(v.Pos, OpMul32uhilo, MakeTuple(types.UInt32, types.UInt32))
+ v14 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v14.AddArg(x)
v13.AddArg(v14)
- v15 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v15 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v15.AddArg(y)
v13.AddArg(v15)
v12.AddArg(v13)
func rewriteValuedec64_OpNeq64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Neq64 x y)
// cond:
// result: (OrB (Neq32 (Int64Hi x) (Int64Hi y)) (Neq32 (Int64Lo x) (Int64Lo y)))
x := v.Args[0]
y := v.Args[1]
v.reset(OpOrB)
- v0 := b.NewValue0(v.Pos, OpNeq32, fe.TypeBool())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpNeq32, types.Bool)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpNeq32, fe.TypeBool())
- v4 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpNeq32, types.Bool)
+ v4 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v4.AddArg(x)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v5.AddArg(y)
v3.AddArg(v5)
v.AddArg(v3)
func rewriteValuedec64_OpOr64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Or64 x y)
// cond:
- // result: (Int64Make (Or32 <fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) (Or32 <fe.TypeUInt32()> (Int64Lo x) (Int64Lo y)))
+ // result: (Int64Make (Or32 <types.UInt32> (Int64Hi x) (Int64Hi y)) (Or32 <types.UInt32> (Int64Lo x) (Int64Lo y)))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v4 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v4 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v4.AddArg(x)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v5.AddArg(y)
v3.AddArg(v5)
v.AddArg(v3)
func rewriteValuedec64_OpRsh16Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux64 _ (Int64Make (Const32 [c]) _))
// cond: c != 0
// result: (Const32 [0])
}
// match: (Rsh16Ux64 x (Int64Make hi lo))
// cond: hi.Op != OpConst32
- // result: (Rsh16Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ // result: (Rsh16Ux32 x (Or32 <types.UInt32> (Zeromask hi) lo))
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpRsh16Ux32)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
v1.AddArg(hi)
v0.AddArg(v1)
v0.AddArg(lo)
func rewriteValuedec64_OpRsh16x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x64 x (Int64Make (Const32 [c]) _))
// cond: c != 0
// result: (Signmask (SignExt16to32 x))
break
}
v.reset(OpSignmask)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
// match: (Rsh16x64 x (Int64Make hi lo))
// cond: hi.Op != OpConst32
- // result: (Rsh16x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ // result: (Rsh16x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpRsh16x32)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
v1.AddArg(hi)
v0.AddArg(v1)
v0.AddArg(lo)
func rewriteValuedec64_OpRsh32Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux64 _ (Int64Make (Const32 [c]) _))
// cond: c != 0
// result: (Const32 [0])
}
// match: (Rsh32Ux64 x (Int64Make hi lo))
// cond: hi.Op != OpConst32
- // result: (Rsh32Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ // result: (Rsh32Ux32 x (Or32 <types.UInt32> (Zeromask hi) lo))
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpRsh32Ux32)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
v1.AddArg(hi)
v0.AddArg(v1)
v0.AddArg(lo)
func rewriteValuedec64_OpRsh32x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x64 x (Int64Make (Const32 [c]) _))
// cond: c != 0
// result: (Signmask x)
}
// match: (Rsh32x64 x (Int64Make hi lo))
// cond: hi.Op != OpConst32
- // result: (Rsh32x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ // result: (Rsh32x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpRsh32x32)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
v1.AddArg(hi)
v0.AddArg(v1)
v0.AddArg(lo)
func rewriteValuedec64_OpRsh64Ux16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux16 (Int64Make hi lo) s)
// cond:
- // result: (Int64Make (Rsh32Ux16 <fe.TypeUInt32()> hi s) (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Rsh32Ux16 <fe.TypeUInt32()> lo s) (Lsh32x16 <fe.TypeUInt32()> hi (Sub16 <fe.TypeUInt16()> (Const16 <fe.TypeUInt16()> [32]) s))) (Rsh32Ux16 <fe.TypeUInt32()> hi (Sub16 <fe.TypeUInt16()> s (Const16 <fe.TypeUInt16()> [32])))))
+ // result: (Int64Make (Rsh32Ux16 <types.UInt32> hi s) (Or32 <types.UInt32> (Or32 <types.UInt32> (Rsh32Ux16 <types.UInt32> lo s) (Lsh32x16 <types.UInt32> hi (Sub16 <types.UInt16> (Const16 <types.UInt16> [32]) s))) (Rsh32Ux16 <types.UInt32> hi (Sub16 <types.UInt16> s (Const16 <types.UInt16> [32])))))
for {
v_0 := v.Args[0]
if v_0.Op != OpInt64Make {
lo := v_0.Args[1]
s := v.Args[1]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpRsh32Ux16, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpRsh32Ux16, types.UInt32)
v0.AddArg(hi)
v0.AddArg(s)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v3 := b.NewValue0(v.Pos, OpRsh32Ux16, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v3 := b.NewValue0(v.Pos, OpRsh32Ux16, types.UInt32)
v3.AddArg(lo)
v3.AddArg(s)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpLsh32x16, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpLsh32x16, types.UInt32)
v4.AddArg(hi)
- v5 := b.NewValue0(v.Pos, OpSub16, fe.TypeUInt16())
- v6 := b.NewValue0(v.Pos, OpConst16, fe.TypeUInt16())
+ v5 := b.NewValue0(v.Pos, OpSub16, types.UInt16)
+ v6 := b.NewValue0(v.Pos, OpConst16, types.UInt16)
v6.AuxInt = 32
v5.AddArg(v6)
v5.AddArg(s)
v4.AddArg(v5)
v2.AddArg(v4)
v1.AddArg(v2)
- v7 := b.NewValue0(v.Pos, OpRsh32Ux16, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpRsh32Ux16, types.UInt32)
v7.AddArg(hi)
- v8 := b.NewValue0(v.Pos, OpSub16, fe.TypeUInt16())
+ v8 := b.NewValue0(v.Pos, OpSub16, types.UInt16)
v8.AddArg(s)
- v9 := b.NewValue0(v.Pos, OpConst16, fe.TypeUInt16())
+ v9 := b.NewValue0(v.Pos, OpConst16, types.UInt16)
v9.AuxInt = 32
v8.AddArg(v9)
v7.AddArg(v8)
func rewriteValuedec64_OpRsh64Ux32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux32 (Int64Make hi lo) s)
// cond:
- // result: (Int64Make (Rsh32Ux32 <fe.TypeUInt32()> hi s) (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Rsh32Ux32 <fe.TypeUInt32()> lo s) (Lsh32x32 <fe.TypeUInt32()> hi (Sub32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [32]) s))) (Rsh32Ux32 <fe.TypeUInt32()> hi (Sub32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [32])))))
+ // result: (Int64Make (Rsh32Ux32 <types.UInt32> hi s) (Or32 <types.UInt32> (Or32 <types.UInt32> (Rsh32Ux32 <types.UInt32> lo s) (Lsh32x32 <types.UInt32> hi (Sub32 <types.UInt32> (Const32 <types.UInt32> [32]) s))) (Rsh32Ux32 <types.UInt32> hi (Sub32 <types.UInt32> s (Const32 <types.UInt32> [32])))))
for {
v_0 := v.Args[0]
if v_0.Op != OpInt64Make {
lo := v_0.Args[1]
s := v.Args[1]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpRsh32Ux32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpRsh32Ux32, types.UInt32)
v0.AddArg(hi)
v0.AddArg(s)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v3 := b.NewValue0(v.Pos, OpRsh32Ux32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v3 := b.NewValue0(v.Pos, OpRsh32Ux32, types.UInt32)
v3.AddArg(lo)
v3.AddArg(s)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpLsh32x32, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpLsh32x32, types.UInt32)
v4.AddArg(hi)
- v5 := b.NewValue0(v.Pos, OpSub32, fe.TypeUInt32())
- v6 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpSub32, types.UInt32)
+ v6 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v6.AuxInt = 32
v5.AddArg(v6)
v5.AddArg(s)
v4.AddArg(v5)
v2.AddArg(v4)
v1.AddArg(v2)
- v7 := b.NewValue0(v.Pos, OpRsh32Ux32, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpRsh32Ux32, types.UInt32)
v7.AddArg(hi)
- v8 := b.NewValue0(v.Pos, OpSub32, fe.TypeUInt32())
+ v8 := b.NewValue0(v.Pos, OpSub32, types.UInt32)
v8.AddArg(s)
- v9 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v9 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v9.AuxInt = 32
v8.AddArg(v9)
v7.AddArg(v8)
func rewriteValuedec64_OpRsh64Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux64 _ (Int64Make (Const32 [c]) _))
// cond: c != 0
// result: (Const64 [0])
}
// match: (Rsh64Ux64 x (Int64Make hi lo))
// cond: hi.Op != OpConst32
- // result: (Rsh64Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ // result: (Rsh64Ux32 x (Or32 <types.UInt32> (Zeromask hi) lo))
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpRsh64Ux32)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
v1.AddArg(hi)
v0.AddArg(v1)
v0.AddArg(lo)
func rewriteValuedec64_OpRsh64Ux8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux8 (Int64Make hi lo) s)
// cond:
- // result: (Int64Make (Rsh32Ux8 <fe.TypeUInt32()> hi s) (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Rsh32Ux8 <fe.TypeUInt32()> lo s) (Lsh32x8 <fe.TypeUInt32()> hi (Sub8 <fe.TypeUInt8()> (Const8 <fe.TypeUInt8()> [32]) s))) (Rsh32Ux8 <fe.TypeUInt32()> hi (Sub8 <fe.TypeUInt8()> s (Const8 <fe.TypeUInt8()> [32])))))
+ // result: (Int64Make (Rsh32Ux8 <types.UInt32> hi s) (Or32 <types.UInt32> (Or32 <types.UInt32> (Rsh32Ux8 <types.UInt32> lo s) (Lsh32x8 <types.UInt32> hi (Sub8 <types.UInt8> (Const8 <types.UInt8> [32]) s))) (Rsh32Ux8 <types.UInt32> hi (Sub8 <types.UInt8> s (Const8 <types.UInt8> [32])))))
for {
v_0 := v.Args[0]
if v_0.Op != OpInt64Make {
lo := v_0.Args[1]
s := v.Args[1]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpRsh32Ux8, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpRsh32Ux8, types.UInt32)
v0.AddArg(hi)
v0.AddArg(s)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v3 := b.NewValue0(v.Pos, OpRsh32Ux8, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v3 := b.NewValue0(v.Pos, OpRsh32Ux8, types.UInt32)
v3.AddArg(lo)
v3.AddArg(s)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpLsh32x8, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpLsh32x8, types.UInt32)
v4.AddArg(hi)
- v5 := b.NewValue0(v.Pos, OpSub8, fe.TypeUInt8())
- v6 := b.NewValue0(v.Pos, OpConst8, fe.TypeUInt8())
+ v5 := b.NewValue0(v.Pos, OpSub8, types.UInt8)
+ v6 := b.NewValue0(v.Pos, OpConst8, types.UInt8)
v6.AuxInt = 32
v5.AddArg(v6)
v5.AddArg(s)
v4.AddArg(v5)
v2.AddArg(v4)
v1.AddArg(v2)
- v7 := b.NewValue0(v.Pos, OpRsh32Ux8, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpRsh32Ux8, types.UInt32)
v7.AddArg(hi)
- v8 := b.NewValue0(v.Pos, OpSub8, fe.TypeUInt8())
+ v8 := b.NewValue0(v.Pos, OpSub8, types.UInt8)
v8.AddArg(s)
- v9 := b.NewValue0(v.Pos, OpConst8, fe.TypeUInt8())
+ v9 := b.NewValue0(v.Pos, OpConst8, types.UInt8)
v9.AuxInt = 32
v8.AddArg(v9)
v7.AddArg(v8)
func rewriteValuedec64_OpRsh64x16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x16 (Int64Make hi lo) s)
// cond:
- // result: (Int64Make (Rsh32x16 <fe.TypeUInt32()> hi s) (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Rsh32Ux16 <fe.TypeUInt32()> lo s) (Lsh32x16 <fe.TypeUInt32()> hi (Sub16 <fe.TypeUInt16()> (Const16 <fe.TypeUInt16()> [32]) s))) (And32 <fe.TypeUInt32()> (Rsh32x16 <fe.TypeUInt32()> hi (Sub16 <fe.TypeUInt16()> s (Const16 <fe.TypeUInt16()> [32]))) (Zeromask (ZeroExt16to32 (Rsh16Ux32 <fe.TypeUInt16()> s (Const32 <fe.TypeUInt32()> [5])))))))
+ // result: (Int64Make (Rsh32x16 <types.UInt32> hi s) (Or32 <types.UInt32> (Or32 <types.UInt32> (Rsh32Ux16 <types.UInt32> lo s) (Lsh32x16 <types.UInt32> hi (Sub16 <types.UInt16> (Const16 <types.UInt16> [32]) s))) (And32 <types.UInt32> (Rsh32x16 <types.UInt32> hi (Sub16 <types.UInt16> s (Const16 <types.UInt16> [32]))) (Zeromask (ZeroExt16to32 (Rsh16Ux32 <types.UInt16> s (Const32 <types.UInt32> [5])))))))
for {
v_0 := v.Args[0]
if v_0.Op != OpInt64Make {
lo := v_0.Args[1]
s := v.Args[1]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpRsh32x16, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpRsh32x16, types.UInt32)
v0.AddArg(hi)
v0.AddArg(s)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v3 := b.NewValue0(v.Pos, OpRsh32Ux16, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v3 := b.NewValue0(v.Pos, OpRsh32Ux16, types.UInt32)
v3.AddArg(lo)
v3.AddArg(s)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpLsh32x16, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpLsh32x16, types.UInt32)
v4.AddArg(hi)
- v5 := b.NewValue0(v.Pos, OpSub16, fe.TypeUInt16())
- v6 := b.NewValue0(v.Pos, OpConst16, fe.TypeUInt16())
+ v5 := b.NewValue0(v.Pos, OpSub16, types.UInt16)
+ v6 := b.NewValue0(v.Pos, OpConst16, types.UInt16)
v6.AuxInt = 32
v5.AddArg(v6)
v5.AddArg(s)
v4.AddArg(v5)
v2.AddArg(v4)
v1.AddArg(v2)
- v7 := b.NewValue0(v.Pos, OpAnd32, fe.TypeUInt32())
- v8 := b.NewValue0(v.Pos, OpRsh32x16, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpAnd32, types.UInt32)
+ v8 := b.NewValue0(v.Pos, OpRsh32x16, types.UInt32)
v8.AddArg(hi)
- v9 := b.NewValue0(v.Pos, OpSub16, fe.TypeUInt16())
+ v9 := b.NewValue0(v.Pos, OpSub16, types.UInt16)
v9.AddArg(s)
- v10 := b.NewValue0(v.Pos, OpConst16, fe.TypeUInt16())
+ v10 := b.NewValue0(v.Pos, OpConst16, types.UInt16)
v10.AuxInt = 32
v9.AddArg(v10)
v8.AddArg(v9)
v7.AddArg(v8)
- v11 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
- v12 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
- v13 := b.NewValue0(v.Pos, OpRsh16Ux32, fe.TypeUInt16())
+ v11 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
+ v12 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
+ v13 := b.NewValue0(v.Pos, OpRsh16Ux32, types.UInt16)
v13.AddArg(s)
- v14 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v14 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v14.AuxInt = 5
v13.AddArg(v14)
v12.AddArg(v13)
func rewriteValuedec64_OpRsh64x32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x32 (Int64Make hi lo) s)
// cond:
- // result: (Int64Make (Rsh32x32 <fe.TypeUInt32()> hi s) (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Rsh32Ux32 <fe.TypeUInt32()> lo s) (Lsh32x32 <fe.TypeUInt32()> hi (Sub32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [32]) s))) (And32 <fe.TypeUInt32()> (Rsh32x32 <fe.TypeUInt32()> hi (Sub32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [32]))) (Zeromask (Rsh32Ux32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [5]))))))
+ // result: (Int64Make (Rsh32x32 <types.UInt32> hi s) (Or32 <types.UInt32> (Or32 <types.UInt32> (Rsh32Ux32 <types.UInt32> lo s) (Lsh32x32 <types.UInt32> hi (Sub32 <types.UInt32> (Const32 <types.UInt32> [32]) s))) (And32 <types.UInt32> (Rsh32x32 <types.UInt32> hi (Sub32 <types.UInt32> s (Const32 <types.UInt32> [32]))) (Zeromask (Rsh32Ux32 <types.UInt32> s (Const32 <types.UInt32> [5]))))))
for {
v_0 := v.Args[0]
if v_0.Op != OpInt64Make {
lo := v_0.Args[1]
s := v.Args[1]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpRsh32x32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpRsh32x32, types.UInt32)
v0.AddArg(hi)
v0.AddArg(s)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v3 := b.NewValue0(v.Pos, OpRsh32Ux32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v3 := b.NewValue0(v.Pos, OpRsh32Ux32, types.UInt32)
v3.AddArg(lo)
v3.AddArg(s)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpLsh32x32, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpLsh32x32, types.UInt32)
v4.AddArg(hi)
- v5 := b.NewValue0(v.Pos, OpSub32, fe.TypeUInt32())
- v6 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpSub32, types.UInt32)
+ v6 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v6.AuxInt = 32
v5.AddArg(v6)
v5.AddArg(s)
v4.AddArg(v5)
v2.AddArg(v4)
v1.AddArg(v2)
- v7 := b.NewValue0(v.Pos, OpAnd32, fe.TypeUInt32())
- v8 := b.NewValue0(v.Pos, OpRsh32x32, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpAnd32, types.UInt32)
+ v8 := b.NewValue0(v.Pos, OpRsh32x32, types.UInt32)
v8.AddArg(hi)
- v9 := b.NewValue0(v.Pos, OpSub32, fe.TypeUInt32())
+ v9 := b.NewValue0(v.Pos, OpSub32, types.UInt32)
v9.AddArg(s)
- v10 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v10 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v10.AuxInt = 32
v9.AddArg(v10)
v8.AddArg(v9)
v7.AddArg(v8)
- v11 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
- v12 := b.NewValue0(v.Pos, OpRsh32Ux32, fe.TypeUInt32())
+ v11 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
+ v12 := b.NewValue0(v.Pos, OpRsh32Ux32, types.UInt32)
v12.AddArg(s)
- v13 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v13 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v13.AuxInt = 5
v12.AddArg(v13)
v11.AddArg(v12)
func rewriteValuedec64_OpRsh64x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x64 x (Int64Make (Const32 [c]) _))
// cond: c != 0
// result: (Int64Make (Signmask (Int64Hi x)) (Signmask (Int64Hi x)))
break
}
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpSignmask, types.Int32)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32())
- v3 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpSignmask, types.Int32)
+ v3 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v3.AddArg(x)
v2.AddArg(v3)
v.AddArg(v2)
}
// match: (Rsh64x64 x (Int64Make hi lo))
// cond: hi.Op != OpConst32
- // result: (Rsh64x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ // result: (Rsh64x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpRsh64x32)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
v1.AddArg(hi)
v0.AddArg(v1)
v0.AddArg(lo)
func rewriteValuedec64_OpRsh64x8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x8 (Int64Make hi lo) s)
// cond:
- // result: (Int64Make (Rsh32x8 <fe.TypeUInt32()> hi s) (Or32 <fe.TypeUInt32()> (Or32 <fe.TypeUInt32()> (Rsh32Ux8 <fe.TypeUInt32()> lo s) (Lsh32x8 <fe.TypeUInt32()> hi (Sub8 <fe.TypeUInt8()> (Const8 <fe.TypeUInt8()> [32]) s))) (And32 <fe.TypeUInt32()> (Rsh32x8 <fe.TypeUInt32()> hi (Sub8 <fe.TypeUInt8()> s (Const8 <fe.TypeUInt8()> [32]))) (Zeromask (ZeroExt8to32 (Rsh8Ux32 <fe.TypeUInt8()> s (Const32 <fe.TypeUInt32()> [5])))))))
+ // result: (Int64Make (Rsh32x8 <types.UInt32> hi s) (Or32 <types.UInt32> (Or32 <types.UInt32> (Rsh32Ux8 <types.UInt32> lo s) (Lsh32x8 <types.UInt32> hi (Sub8 <types.UInt8> (Const8 <types.UInt8> [32]) s))) (And32 <types.UInt32> (Rsh32x8 <types.UInt32> hi (Sub8 <types.UInt8> s (Const8 <types.UInt8> [32]))) (Zeromask (ZeroExt8to32 (Rsh8Ux32 <types.UInt8> s (Const32 <types.UInt32> [5])))))))
for {
v_0 := v.Args[0]
if v_0.Op != OpInt64Make {
lo := v_0.Args[1]
s := v.Args[1]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpRsh32x8, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpRsh32x8, types.UInt32)
v0.AddArg(hi)
v0.AddArg(s)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v3 := b.NewValue0(v.Pos, OpRsh32Ux8, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v3 := b.NewValue0(v.Pos, OpRsh32Ux8, types.UInt32)
v3.AddArg(lo)
v3.AddArg(s)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpLsh32x8, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpLsh32x8, types.UInt32)
v4.AddArg(hi)
- v5 := b.NewValue0(v.Pos, OpSub8, fe.TypeUInt8())
- v6 := b.NewValue0(v.Pos, OpConst8, fe.TypeUInt8())
+ v5 := b.NewValue0(v.Pos, OpSub8, types.UInt8)
+ v6 := b.NewValue0(v.Pos, OpConst8, types.UInt8)
v6.AuxInt = 32
v5.AddArg(v6)
v5.AddArg(s)
v4.AddArg(v5)
v2.AddArg(v4)
v1.AddArg(v2)
- v7 := b.NewValue0(v.Pos, OpAnd32, fe.TypeUInt32())
- v8 := b.NewValue0(v.Pos, OpRsh32x8, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpAnd32, types.UInt32)
+ v8 := b.NewValue0(v.Pos, OpRsh32x8, types.UInt32)
v8.AddArg(hi)
- v9 := b.NewValue0(v.Pos, OpSub8, fe.TypeUInt8())
+ v9 := b.NewValue0(v.Pos, OpSub8, types.UInt8)
v9.AddArg(s)
- v10 := b.NewValue0(v.Pos, OpConst8, fe.TypeUInt8())
+ v10 := b.NewValue0(v.Pos, OpConst8, types.UInt8)
v10.AuxInt = 32
v9.AddArg(v10)
v8.AddArg(v9)
v7.AddArg(v8)
- v11 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
- v12 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
- v13 := b.NewValue0(v.Pos, OpRsh8Ux32, fe.TypeUInt8())
+ v11 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
+ v12 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
+ v13 := b.NewValue0(v.Pos, OpRsh8Ux32, types.UInt8)
v13.AddArg(s)
- v14 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v14 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v14.AuxInt = 5
v13.AddArg(v14)
v12.AddArg(v13)
func rewriteValuedec64_OpRsh8Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux64 _ (Int64Make (Const32 [c]) _))
// cond: c != 0
// result: (Const32 [0])
}
// match: (Rsh8Ux64 x (Int64Make hi lo))
// cond: hi.Op != OpConst32
- // result: (Rsh8Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ // result: (Rsh8Ux32 x (Or32 <types.UInt32> (Zeromask hi) lo))
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpRsh8Ux32)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
v1.AddArg(hi)
v0.AddArg(v1)
v0.AddArg(lo)
func rewriteValuedec64_OpRsh8x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8x64 x (Int64Make (Const32 [c]) _))
// cond: c != 0
// result: (Signmask (SignExt8to32 x))
break
}
v.reset(OpSignmask)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
return true
}
// match: (Rsh8x64 x (Int64Make hi lo))
// cond: hi.Op != OpConst32
- // result: (Rsh8x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo))
+ // result: (Rsh8x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
for {
x := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpRsh8x32)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpOr32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpZeromask, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpOr32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpZeromask, types.UInt32)
v1.AddArg(hi)
v0.AddArg(v1)
v0.AddArg(lo)
func rewriteValuedec64_OpSignExt16to64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (SignExt16to64 x)
// cond:
// result: (SignExt32to64 (SignExt16to32 x))
for {
x := v.Args[0]
v.reset(OpSignExt32to64)
- v0 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValuedec64_OpSignExt32to64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (SignExt32to64 x)
// cond:
// result: (Int64Make (Signmask x) x)
for {
x := v.Args[0]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpSignmask, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignmask, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
v.AddArg(x)
func rewriteValuedec64_OpSignExt8to64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (SignExt8to64 x)
// cond:
// result: (SignExt32to64 (SignExt8to32 x))
for {
x := v.Args[0]
v.reset(OpSignExt32to64)
- v0 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValuedec64_OpSub64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Sub64 x y)
// cond:
- // result: (Int64Make (Sub32withcarry <fe.TypeInt32()> (Int64Hi x) (Int64Hi y) (Select1 <TypeFlags> (Sub32carry (Int64Lo x) (Int64Lo y)))) (Select0 <fe.TypeUInt32()> (Sub32carry (Int64Lo x) (Int64Lo y))))
+ // result: (Int64Make (Sub32withcarry <types.Int32> (Int64Hi x) (Int64Hi y) (Select1 <TypeFlags> (Sub32carry (Int64Lo x) (Int64Lo y)))) (Select0 <types.UInt32> (Sub32carry (Int64Lo x) (Int64Lo y))))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpSub32withcarry, fe.TypeInt32())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpSub32withcarry, types.Int32)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpSelect1, TypeFlags)
- v4 := b.NewValue0(v.Pos, OpSub32carry, MakeTuple(fe.TypeUInt32(), TypeFlags))
- v5 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v4 := b.NewValue0(v.Pos, OpSub32carry, MakeTuple(types.UInt32, TypeFlags))
+ v5 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v5.AddArg(x)
v4.AddArg(v5)
- v6 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v6 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v6.AddArg(y)
v4.AddArg(v6)
v3.AddArg(v4)
v0.AddArg(v3)
v.AddArg(v0)
- v7 := b.NewValue0(v.Pos, OpSelect0, fe.TypeUInt32())
- v8 := b.NewValue0(v.Pos, OpSub32carry, MakeTuple(fe.TypeUInt32(), TypeFlags))
- v9 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpSelect0, types.UInt32)
+ v8 := b.NewValue0(v.Pos, OpSub32carry, MakeTuple(types.UInt32, TypeFlags))
+ v9 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v9.AddArg(x)
v8.AddArg(v9)
- v10 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v10 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v10.AddArg(y)
v8.AddArg(v10)
v7.AddArg(v8)
func rewriteValuedec64_OpXor64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Xor64 x y)
// cond:
- // result: (Int64Make (Xor32 <fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) (Xor32 <fe.TypeUInt32()> (Int64Lo x) (Int64Lo y)))
+ // result: (Int64Make (Xor32 <types.UInt32> (Int64Hi x) (Int64Hi y)) (Xor32 <types.UInt32> (Int64Lo x) (Int64Lo y)))
for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpXor32, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpXor32, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v1.AddArg(x)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpInt64Hi, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpInt64Hi, types.UInt32)
v2.AddArg(y)
v0.AddArg(v2)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpXor32, fe.TypeUInt32())
- v4 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpXor32, types.UInt32)
+ v4 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v4.AddArg(x)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpInt64Lo, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpInt64Lo, types.UInt32)
v5.AddArg(y)
v3.AddArg(v5)
v.AddArg(v3)
func rewriteValuedec64_OpZeroExt16to64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (ZeroExt16to64 x)
// cond:
// result: (ZeroExt32to64 (ZeroExt16to32 x))
for {
x := v.Args[0]
v.reset(OpZeroExt32to64)
- v0 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValuedec64_OpZeroExt32to64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (ZeroExt32to64 x)
// cond:
- // result: (Int64Make (Const32 <fe.TypeUInt32()> [0]) x)
+ // result: (Int64Make (Const32 <types.UInt32> [0]) x)
for {
x := v.Args[0]
v.reset(OpInt64Make)
- v0 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v0.AuxInt = 0
v.AddArg(v0)
v.AddArg(x)
func rewriteValuedec64_OpZeroExt8to64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (ZeroExt8to64 x)
// cond:
// result: (ZeroExt32to64 (ZeroExt8to32 x))
for {
x := v.Args[0]
v.reset(OpZeroExt32to64)
- v0 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
return true
_ = config
fe := b.Func.fe
_ = fe
+ types := &config.Types
+ _ = types
switch b.Kind {
}
return false
_ = config
fe := b.Func.fe
_ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Arg {n} [off])
// cond: v.Type.IsString()
- // result: (StringMake (Arg <fe.TypeBytePtr()> {n} [off]) (Arg <fe.TypeInt()> {n} [off+config.PtrSize]))
+ // result: (StringMake (Arg <types.BytePtr> {n} [off]) (Arg <types.Int> {n} [off+config.PtrSize]))
for {
off := v.AuxInt
n := v.Aux
break
}
v.reset(OpStringMake)
- v0 := b.NewValue0(v.Pos, OpArg, fe.TypeBytePtr())
+ v0 := b.NewValue0(v.Pos, OpArg, types.BytePtr)
v0.AuxInt = off
v0.Aux = n
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpArg, fe.TypeInt())
+ v1 := b.NewValue0(v.Pos, OpArg, types.Int)
v1.AuxInt = off + config.PtrSize
v1.Aux = n
v.AddArg(v1)
}
// match: (Arg {n} [off])
// cond: v.Type.IsSlice()
- // result: (SliceMake (Arg <v.Type.ElemType().PtrTo()> {n} [off]) (Arg <fe.TypeInt()> {n} [off+config.PtrSize]) (Arg <fe.TypeInt()> {n} [off+2*config.PtrSize]))
+ // result: (SliceMake (Arg <v.Type.ElemType().PtrTo()> {n} [off]) (Arg <types.Int> {n} [off+config.PtrSize]) (Arg <types.Int> {n} [off+2*config.PtrSize]))
for {
off := v.AuxInt
n := v.Aux
v0.AuxInt = off
v0.Aux = n
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpArg, fe.TypeInt())
+ v1 := b.NewValue0(v.Pos, OpArg, types.Int)
v1.AuxInt = off + config.PtrSize
v1.Aux = n
v.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpArg, fe.TypeInt())
+ v2 := b.NewValue0(v.Pos, OpArg, types.Int)
v2.AuxInt = off + 2*config.PtrSize
v2.Aux = n
v.AddArg(v2)
}
// match: (Arg {n} [off])
// cond: v.Type.IsInterface()
- // result: (IMake (Arg <fe.TypeBytePtr()> {n} [off]) (Arg <fe.TypeBytePtr()> {n} [off+config.PtrSize]))
+ // result: (IMake (Arg <types.BytePtr> {n} [off]) (Arg <types.BytePtr> {n} [off+config.PtrSize]))
for {
off := v.AuxInt
n := v.Aux
break
}
v.reset(OpIMake)
- v0 := b.NewValue0(v.Pos, OpArg, fe.TypeBytePtr())
+ v0 := b.NewValue0(v.Pos, OpArg, types.BytePtr)
v0.AuxInt = off
v0.Aux = n
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpArg, fe.TypeBytePtr())
+ v1 := b.NewValue0(v.Pos, OpArg, types.BytePtr)
v1.AuxInt = off + config.PtrSize
v1.Aux = n
v.AddArg(v1)
}
// match: (Arg {n} [off])
// cond: v.Type.IsComplex() && v.Type.Size() == 16
- // result: (ComplexMake (Arg <fe.TypeFloat64()> {n} [off]) (Arg <fe.TypeFloat64()> {n} [off+8]))
+ // result: (ComplexMake (Arg <types.Float64> {n} [off]) (Arg <types.Float64> {n} [off+8]))
for {
off := v.AuxInt
n := v.Aux
break
}
v.reset(OpComplexMake)
- v0 := b.NewValue0(v.Pos, OpArg, fe.TypeFloat64())
+ v0 := b.NewValue0(v.Pos, OpArg, types.Float64)
v0.AuxInt = off
v0.Aux = n
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpArg, fe.TypeFloat64())
+ v1 := b.NewValue0(v.Pos, OpArg, types.Float64)
v1.AuxInt = off + 8
v1.Aux = n
v.AddArg(v1)
}
// match: (Arg {n} [off])
// cond: v.Type.IsComplex() && v.Type.Size() == 8
- // result: (ComplexMake (Arg <fe.TypeFloat32()> {n} [off]) (Arg <fe.TypeFloat32()> {n} [off+4]))
+ // result: (ComplexMake (Arg <types.Float32> {n} [off]) (Arg <types.Float32> {n} [off+4]))
for {
off := v.AuxInt
n := v.Aux
break
}
v.reset(OpComplexMake)
- v0 := b.NewValue0(v.Pos, OpArg, fe.TypeFloat32())
+ v0 := b.NewValue0(v.Pos, OpArg, types.Float32)
v0.AuxInt = off
v0.Aux = n
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpArg, fe.TypeFloat32())
+ v1 := b.NewValue0(v.Pos, OpArg, types.Float32)
v1.AuxInt = off + 4
v1.Aux = n
v.AddArg(v1)
func rewriteValuegeneric_OpConstInterface(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (ConstInterface)
// cond:
- // result: (IMake (ConstNil <fe.TypeBytePtr()>) (ConstNil <fe.TypeBytePtr()>))
+ // result: (IMake (ConstNil <types.BytePtr>) (ConstNil <types.BytePtr>))
for {
v.reset(OpIMake)
- v0 := b.NewValue0(v.Pos, OpConstNil, fe.TypeBytePtr())
+ v0 := b.NewValue0(v.Pos, OpConstNil, types.BytePtr)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpConstNil, fe.TypeBytePtr())
+ v1 := b.NewValue0(v.Pos, OpConstNil, types.BytePtr)
v.AddArg(v1)
return true
}
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (ConstSlice)
// cond: config.PtrSize == 4
- // result: (SliceMake (ConstNil <v.Type.ElemType().PtrTo()>) (Const32 <fe.TypeInt()> [0]) (Const32 <fe.TypeInt()> [0]))
+ // result: (SliceMake (ConstNil <v.Type.ElemType().PtrTo()>) (Const32 <types.Int> [0]) (Const32 <types.Int> [0]))
for {
if !(config.PtrSize == 4) {
break
v.reset(OpSliceMake)
v0 := b.NewValue0(v.Pos, OpConstNil, v.Type.ElemType().PtrTo())
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpConst32, fe.TypeInt())
+ v1 := b.NewValue0(v.Pos, OpConst32, types.Int)
v1.AuxInt = 0
v.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeInt())
+ v2 := b.NewValue0(v.Pos, OpConst32, types.Int)
v2.AuxInt = 0
v.AddArg(v2)
return true
}
// match: (ConstSlice)
// cond: config.PtrSize == 8
- // result: (SliceMake (ConstNil <v.Type.ElemType().PtrTo()>) (Const64 <fe.TypeInt()> [0]) (Const64 <fe.TypeInt()> [0]))
+ // result: (SliceMake (ConstNil <v.Type.ElemType().PtrTo()>) (Const64 <types.Int> [0]) (Const64 <types.Int> [0]))
for {
if !(config.PtrSize == 8) {
break
v.reset(OpSliceMake)
v0 := b.NewValue0(v.Pos, OpConstNil, v.Type.ElemType().PtrTo())
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeInt())
+ v1 := b.NewValue0(v.Pos, OpConst64, types.Int)
v1.AuxInt = 0
v.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeInt())
+ v2 := b.NewValue0(v.Pos, OpConst64, types.Int)
v2.AuxInt = 0
v.AddArg(v2)
return true
_ = config
fe := b.Func.fe
_ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (ConstString {s})
// cond: config.PtrSize == 4 && s.(string) == ""
- // result: (StringMake (ConstNil) (Const32 <fe.TypeInt()> [0]))
+ // result: (StringMake (ConstNil) (Const32 <types.Int> [0]))
for {
s := v.Aux
if !(config.PtrSize == 4 && s.(string) == "") {
break
}
v.reset(OpStringMake)
- v0 := b.NewValue0(v.Pos, OpConstNil, fe.TypeBytePtr())
+ v0 := b.NewValue0(v.Pos, OpConstNil, types.BytePtr)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpConst32, fe.TypeInt())
+ v1 := b.NewValue0(v.Pos, OpConst32, types.Int)
v1.AuxInt = 0
v.AddArg(v1)
return true
}
// match: (ConstString {s})
// cond: config.PtrSize == 8 && s.(string) == ""
- // result: (StringMake (ConstNil) (Const64 <fe.TypeInt()> [0]))
+ // result: (StringMake (ConstNil) (Const64 <types.Int> [0]))
for {
s := v.Aux
if !(config.PtrSize == 8 && s.(string) == "") {
break
}
v.reset(OpStringMake)
- v0 := b.NewValue0(v.Pos, OpConstNil, fe.TypeBytePtr())
+ v0 := b.NewValue0(v.Pos, OpConstNil, types.BytePtr)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeInt())
+ v1 := b.NewValue0(v.Pos, OpConst64, types.Int)
v1.AuxInt = 0
v.AddArg(v1)
return true
}
// match: (ConstString {s})
// cond: config.PtrSize == 4 && s.(string) != ""
- // result: (StringMake (Addr <fe.TypeBytePtr()> {fe.StringData(s.(string))} (SB)) (Const32 <fe.TypeInt()> [int64(len(s.(string)))]))
+ // result: (StringMake (Addr <types.BytePtr> {fe.StringData(s.(string))} (SB)) (Const32 <types.Int> [int64(len(s.(string)))]))
for {
s := v.Aux
if !(config.PtrSize == 4 && s.(string) != "") {
break
}
v.reset(OpStringMake)
- v0 := b.NewValue0(v.Pos, OpAddr, fe.TypeBytePtr())
+ v0 := b.NewValue0(v.Pos, OpAddr, types.BytePtr)
v0.Aux = fe.StringData(s.(string))
- v1 := b.NewValue0(v.Pos, OpSB, fe.TypeUintptr())
+ v1 := b.NewValue0(v.Pos, OpSB, types.Uintptr)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeInt())
+ v2 := b.NewValue0(v.Pos, OpConst32, types.Int)
v2.AuxInt = int64(len(s.(string)))
v.AddArg(v2)
return true
}
// match: (ConstString {s})
// cond: config.PtrSize == 8 && s.(string) != ""
- // result: (StringMake (Addr <fe.TypeBytePtr()> {fe.StringData(s.(string))} (SB)) (Const64 <fe.TypeInt()> [int64(len(s.(string)))]))
+ // result: (StringMake (Addr <types.BytePtr> {fe.StringData(s.(string))} (SB)) (Const64 <types.Int> [int64(len(s.(string)))]))
for {
s := v.Aux
if !(config.PtrSize == 8 && s.(string) != "") {
break
}
v.reset(OpStringMake)
- v0 := b.NewValue0(v.Pos, OpAddr, fe.TypeBytePtr())
+ v0 := b.NewValue0(v.Pos, OpAddr, types.BytePtr)
v0.Aux = fe.StringData(s.(string))
- v1 := b.NewValue0(v.Pos, OpSB, fe.TypeUintptr())
+ v1 := b.NewValue0(v.Pos, OpSB, types.Uintptr)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeInt())
+ v2 := b.NewValue0(v.Pos, OpConst64, types.Int)
v2.AuxInt = int64(len(s.(string)))
v.AddArg(v2)
return true
func rewriteValuegeneric_OpDiv16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div16 (Const16 [c]) (Const16 [d]))
// cond: d != 0
// result: (Const16 [int64(int16(c)/int16(d))])
}
// match: (Div16 <t> x (Const16 [-1<<15]))
// cond:
- // result: (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <fe.TypeUInt64()> [15]))
+ // result: (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <types.UInt64> [15]))
for {
t := v.Type
x := v.Args[0]
v1.AddArg(x)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 15
v.AddArg(v2)
return true
}
// match: (Div16 <t> n (Const16 [c]))
// cond: isPowerOfTwo(c)
- // result: (Rsh16x64 (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <fe.TypeUInt64()> [15])) (Const64 <fe.TypeUInt64()> [16-log2(c)]))) (Const64 <fe.TypeUInt64()> [log2(c)]))
+ // result: (Rsh16x64 (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <types.UInt64> [15])) (Const64 <types.UInt64> [16-log2(c)]))) (Const64 <types.UInt64> [log2(c)]))
for {
t := v.Type
n := v.Args[0]
v1 := b.NewValue0(v.Pos, OpRsh16Ux64, t)
v2 := b.NewValue0(v.Pos, OpRsh16x64, t)
v2.AddArg(n)
- v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v3.AuxInt = 15
v2.AddArg(v3)
v1.AddArg(v2)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 16 - log2(c)
v1.AddArg(v4)
v0.AddArg(v1)
v.AddArg(v0)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = log2(c)
v.AddArg(v5)
return true
}
// match: (Div16 <t> x (Const16 [c]))
// cond: smagicOK(16,c)
- // result: (Sub16 <t> (Rsh32x64 <t> (Mul32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(smagic(16,c).m)]) (SignExt16to32 x)) (Const64 <fe.TypeUInt64()> [16+smagic(16,c).s])) (Rsh32x64 <t> (SignExt16to32 x) (Const64 <fe.TypeUInt64()> [31])))
+ // result: (Sub16 <t> (Rsh32x64 <t> (Mul32 <types.UInt32> (Const32 <types.UInt32> [int64(smagic(16,c).m)]) (SignExt16to32 x)) (Const64 <types.UInt64> [16+smagic(16,c).s])) (Rsh32x64 <t> (SignExt16to32 x) (Const64 <types.UInt64> [31])))
for {
t := v.Type
x := v.Args[0]
v.reset(OpSub16)
v.Type = t
v0 := b.NewValue0(v.Pos, OpRsh32x64, t)
- v1 := b.NewValue0(v.Pos, OpMul32, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMul32, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v2.AuxInt = int64(smagic(16, c).m)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v3 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v3.AddArg(x)
v1.AddArg(v3)
v0.AddArg(v1)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 16 + smagic(16, c).s
v0.AddArg(v4)
v.AddArg(v0)
v5 := b.NewValue0(v.Pos, OpRsh32x64, t)
- v6 := b.NewValue0(v.Pos, OpSignExt16to32, fe.TypeInt32())
+ v6 := b.NewValue0(v.Pos, OpSignExt16to32, types.Int32)
v6.AddArg(x)
v5.AddArg(v6)
- v7 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v7 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v7.AuxInt = 31
v5.AddArg(v7)
v.AddArg(v5)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div16u (Const16 [c]) (Const16 [d]))
// cond: d != 0
// result: (Const16 [int64(int16(uint16(c)/uint16(d)))])
}
// match: (Div16u n (Const16 [c]))
// cond: isPowerOfTwo(c&0xffff)
- // result: (Rsh16Ux64 n (Const64 <fe.TypeUInt64()> [log2(c&0xffff)]))
+ // result: (Rsh16Ux64 n (Const64 <types.UInt64> [log2(c&0xffff)]))
for {
n := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpRsh16Ux64)
v.AddArg(n)
- v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v0.AuxInt = log2(c & 0xffff)
v.AddArg(v0)
return true
}
// match: (Div16u x (Const16 [c]))
// cond: umagicOK(16, c) && config.RegSize == 8
- // result: (Trunc64to16 (Rsh64Ux64 <fe.TypeUInt64()> (Mul64 <fe.TypeUInt64()> (Const64 <fe.TypeUInt64()> [int64(1<<16+umagic(16,c).m)]) (ZeroExt16to64 x)) (Const64 <fe.TypeUInt64()> [16+umagic(16,c).s])))
+ // result: (Trunc64to16 (Rsh64Ux64 <types.UInt64> (Mul64 <types.UInt64> (Const64 <types.UInt64> [int64(1<<16+umagic(16,c).m)]) (ZeroExt16to64 x)) (Const64 <types.UInt64> [16+umagic(16,c).s])))
for {
x := v.Args[0]
v_1 := v.Args[1]
break
}
v.reset(OpTrunc64to16)
- v0 := b.NewValue0(v.Pos, OpRsh64Ux64, fe.TypeUInt64())
- v1 := b.NewValue0(v.Pos, OpMul64, fe.TypeUInt64())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpRsh64Ux64, types.UInt64)
+ v1 := b.NewValue0(v.Pos, OpMul64, types.UInt64)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = int64(1<<16 + umagic(16, c).m)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt16to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to64, types.UInt64)
v3.AddArg(x)
v1.AddArg(v3)
v0.AddArg(v1)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 16 + umagic(16, c).s
v0.AddArg(v4)
v.AddArg(v0)
}
// match: (Div16u x (Const16 [c]))
// cond: umagicOK(16, c) && config.RegSize == 4 && umagic(16,c).m&1 == 0
- // result: (Trunc32to16 (Rsh32Ux64 <fe.TypeUInt32()> (Mul32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(1<<15+umagic(16,c).m/2)]) (ZeroExt16to32 x)) (Const64 <fe.TypeUInt64()> [16+umagic(16,c).s-1])))
+ // result: (Trunc32to16 (Rsh32Ux64 <types.UInt32> (Mul32 <types.UInt32> (Const32 <types.UInt32> [int64(1<<15+umagic(16,c).m/2)]) (ZeroExt16to32 x)) (Const64 <types.UInt64> [16+umagic(16,c).s-1])))
for {
x := v.Args[0]
v_1 := v.Args[1]
break
}
v.reset(OpTrunc32to16)
- v0 := b.NewValue0(v.Pos, OpRsh32Ux64, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpMul32, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpRsh32Ux64, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpMul32, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v2.AuxInt = int64(1<<15 + umagic(16, c).m/2)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v3.AddArg(x)
v1.AddArg(v3)
v0.AddArg(v1)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 16 + umagic(16, c).s - 1
v0.AddArg(v4)
v.AddArg(v0)
}
// match: (Div16u x (Const16 [c]))
// cond: umagicOK(16, c) && config.RegSize == 4 && c&1 == 0
- // result: (Trunc32to16 (Rsh32Ux64 <fe.TypeUInt32()> (Mul32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(1<<15+(umagic(16,c).m+1)/2)]) (Rsh32Ux64 <fe.TypeUInt32()> (ZeroExt16to32 x) (Const64 <fe.TypeUInt64()> [1]))) (Const64 <fe.TypeUInt64()> [16+umagic(16,c).s-2])))
+ // result: (Trunc32to16 (Rsh32Ux64 <types.UInt32> (Mul32 <types.UInt32> (Const32 <types.UInt32> [int64(1<<15+(umagic(16,c).m+1)/2)]) (Rsh32Ux64 <types.UInt32> (ZeroExt16to32 x) (Const64 <types.UInt64> [1]))) (Const64 <types.UInt64> [16+umagic(16,c).s-2])))
for {
x := v.Args[0]
v_1 := v.Args[1]
break
}
v.reset(OpTrunc32to16)
- v0 := b.NewValue0(v.Pos, OpRsh32Ux64, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpMul32, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpRsh32Ux64, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpMul32, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v2.AuxInt = int64(1<<15 + (umagic(16, c).m+1)/2)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpRsh32Ux64, fe.TypeUInt32())
- v4 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpRsh32Ux64, types.UInt32)
+ v4 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v4.AddArg(x)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = 1
v3.AddArg(v5)
v1.AddArg(v3)
v0.AddArg(v1)
- v6 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v6.AuxInt = 16 + umagic(16, c).s - 2
v0.AddArg(v6)
v.AddArg(v0)
}
// match: (Div16u x (Const16 [c]))
// cond: umagicOK(16, c) && config.RegSize == 4
- // result: (Trunc32to16 (Rsh32Ux64 <fe.TypeUInt32()> (Avg32u (Lsh32x64 <fe.TypeUInt32()> (ZeroExt16to32 x) (Const64 <fe.TypeUInt64()> [16])) (Mul32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(umagic(16,c).m)]) (ZeroExt16to32 x))) (Const64 <fe.TypeUInt64()> [16+umagic(16,c).s-1])))
+ // result: (Trunc32to16 (Rsh32Ux64 <types.UInt32> (Avg32u (Lsh32x64 <types.UInt32> (ZeroExt16to32 x) (Const64 <types.UInt64> [16])) (Mul32 <types.UInt32> (Const32 <types.UInt32> [int64(umagic(16,c).m)]) (ZeroExt16to32 x))) (Const64 <types.UInt64> [16+umagic(16,c).s-1])))
for {
x := v.Args[0]
v_1 := v.Args[1]
break
}
v.reset(OpTrunc32to16)
- v0 := b.NewValue0(v.Pos, OpRsh32Ux64, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpAvg32u, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpLsh32x64, fe.TypeUInt32())
- v3 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpRsh32Ux64, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpAvg32u, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpLsh32x64, types.UInt32)
+ v3 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 16
v2.AddArg(v4)
v1.AddArg(v2)
- v5 := b.NewValue0(v.Pos, OpMul32, fe.TypeUInt32())
- v6 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpMul32, types.UInt32)
+ v6 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v6.AuxInt = int64(umagic(16, c).m)
v5.AddArg(v6)
- v7 := b.NewValue0(v.Pos, OpZeroExt16to32, fe.TypeUInt32())
+ v7 := b.NewValue0(v.Pos, OpZeroExt16to32, types.UInt32)
v7.AddArg(x)
v5.AddArg(v7)
v1.AddArg(v5)
v0.AddArg(v1)
- v8 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v8 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v8.AuxInt = 16 + umagic(16, c).s - 1
v0.AddArg(v8)
v.AddArg(v0)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div32 (Const32 [c]) (Const32 [d]))
// cond: d != 0
// result: (Const32 [int64(int32(c)/int32(d))])
}
// match: (Div32 <t> x (Const32 [-1<<31]))
// cond:
- // result: (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <fe.TypeUInt64()> [31]))
+ // result: (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <types.UInt64> [31]))
for {
t := v.Type
x := v.Args[0]
v1.AddArg(x)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 31
v.AddArg(v2)
return true
}
// match: (Div32 <t> n (Const32 [c]))
// cond: isPowerOfTwo(c)
- // result: (Rsh32x64 (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <fe.TypeUInt64()> [31])) (Const64 <fe.TypeUInt64()> [32-log2(c)]))) (Const64 <fe.TypeUInt64()> [log2(c)]))
+ // result: (Rsh32x64 (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <types.UInt64> [31])) (Const64 <types.UInt64> [32-log2(c)]))) (Const64 <types.UInt64> [log2(c)]))
for {
t := v.Type
n := v.Args[0]
v1 := b.NewValue0(v.Pos, OpRsh32Ux64, t)
v2 := b.NewValue0(v.Pos, OpRsh32x64, t)
v2.AddArg(n)
- v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v3.AuxInt = 31
v2.AddArg(v3)
v1.AddArg(v2)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 32 - log2(c)
v1.AddArg(v4)
v0.AddArg(v1)
v.AddArg(v0)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = log2(c)
v.AddArg(v5)
return true
}
// match: (Div32 <t> x (Const32 [c]))
// cond: smagicOK(32,c) && config.RegSize == 8
- // result: (Sub32 <t> (Rsh64x64 <t> (Mul64 <fe.TypeUInt64()> (Const64 <fe.TypeUInt64()> [int64(smagic(32,c).m)]) (SignExt32to64 x)) (Const64 <fe.TypeUInt64()> [32+smagic(32,c).s])) (Rsh64x64 <t> (SignExt32to64 x) (Const64 <fe.TypeUInt64()> [63])))
+ // result: (Sub32 <t> (Rsh64x64 <t> (Mul64 <types.UInt64> (Const64 <types.UInt64> [int64(smagic(32,c).m)]) (SignExt32to64 x)) (Const64 <types.UInt64> [32+smagic(32,c).s])) (Rsh64x64 <t> (SignExt32to64 x) (Const64 <types.UInt64> [63])))
for {
t := v.Type
x := v.Args[0]
v.reset(OpSub32)
v.Type = t
v0 := b.NewValue0(v.Pos, OpRsh64x64, t)
- v1 := b.NewValue0(v.Pos, OpMul64, fe.TypeUInt64())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpMul64, types.UInt64)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = int64(smagic(32, c).m)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v3 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v3.AddArg(x)
v1.AddArg(v3)
v0.AddArg(v1)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 32 + smagic(32, c).s
v0.AddArg(v4)
v.AddArg(v0)
v5 := b.NewValue0(v.Pos, OpRsh64x64, t)
- v6 := b.NewValue0(v.Pos, OpSignExt32to64, fe.TypeInt64())
+ v6 := b.NewValue0(v.Pos, OpSignExt32to64, types.Int64)
v6.AddArg(x)
v5.AddArg(v6)
- v7 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v7 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v7.AuxInt = 63
v5.AddArg(v7)
v.AddArg(v5)
}
// match: (Div32 <t> x (Const32 [c]))
// cond: smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 == 0
- // result: (Sub32 <t> (Rsh32x64 <t> (Hmul32 <t> (Const32 <fe.TypeUInt32()> [int64(int32(smagic(32,c).m/2))]) x) (Const64 <fe.TypeUInt64()> [smagic(32,c).s-1])) (Rsh32x64 <t> x (Const64 <fe.TypeUInt64()> [31])))
+ // result: (Sub32 <t> (Rsh32x64 <t> (Hmul32 <t> (Const32 <types.UInt32> [int64(int32(smagic(32,c).m/2))]) x) (Const64 <types.UInt64> [smagic(32,c).s-1])) (Rsh32x64 <t> x (Const64 <types.UInt64> [31])))
for {
t := v.Type
x := v.Args[0]
v.Type = t
v0 := b.NewValue0(v.Pos, OpRsh32x64, t)
v1 := b.NewValue0(v.Pos, OpHmul32, t)
- v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v2.AuxInt = int64(int32(smagic(32, c).m / 2))
v1.AddArg(v2)
v1.AddArg(x)
v0.AddArg(v1)
- v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v3.AuxInt = smagic(32, c).s - 1
v0.AddArg(v3)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpRsh32x64, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = 31
v4.AddArg(v5)
v.AddArg(v4)
}
// match: (Div32 <t> x (Const32 [c]))
// cond: smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 != 0
- // result: (Sub32 <t> (Rsh32x64 <t> (Add32 <t> (Hmul32 <t> (Const32 <fe.TypeUInt32()> [int64(int32(smagic(32,c).m))]) x) x) (Const64 <fe.TypeUInt64()> [smagic(32,c).s])) (Rsh32x64 <t> x (Const64 <fe.TypeUInt64()> [31])))
+ // result: (Sub32 <t> (Rsh32x64 <t> (Add32 <t> (Hmul32 <t> (Const32 <types.UInt32> [int64(int32(smagic(32,c).m))]) x) x) (Const64 <types.UInt64> [smagic(32,c).s])) (Rsh32x64 <t> x (Const64 <types.UInt64> [31])))
for {
t := v.Type
x := v.Args[0]
v0 := b.NewValue0(v.Pos, OpRsh32x64, t)
v1 := b.NewValue0(v.Pos, OpAdd32, t)
v2 := b.NewValue0(v.Pos, OpHmul32, t)
- v3 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v3.AuxInt = int64(int32(smagic(32, c).m))
v2.AddArg(v3)
v2.AddArg(x)
v1.AddArg(v2)
v1.AddArg(x)
v0.AddArg(v1)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = smagic(32, c).s
v0.AddArg(v4)
v.AddArg(v0)
v5 := b.NewValue0(v.Pos, OpRsh32x64, t)
v5.AddArg(x)
- v6 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v6.AuxInt = 31
v5.AddArg(v6)
v.AddArg(v5)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div32u (Const32 [c]) (Const32 [d]))
// cond: d != 0
// result: (Const32 [int64(int32(uint32(c)/uint32(d)))])
}
// match: (Div32u n (Const32 [c]))
// cond: isPowerOfTwo(c&0xffffffff)
- // result: (Rsh32Ux64 n (Const64 <fe.TypeUInt64()> [log2(c&0xffffffff)]))
+ // result: (Rsh32Ux64 n (Const64 <types.UInt64> [log2(c&0xffffffff)]))
for {
n := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpRsh32Ux64)
v.AddArg(n)
- v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v0.AuxInt = log2(c & 0xffffffff)
v.AddArg(v0)
return true
}
// match: (Div32u x (Const32 [c]))
// cond: umagicOK(32, c) && config.RegSize == 4 && umagic(32,c).m&1 == 0
- // result: (Rsh32Ux64 <fe.TypeUInt32()> (Hmul32u <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(int32(1<<31+umagic(32,c).m/2))]) x) (Const64 <fe.TypeUInt64()> [umagic(32,c).s-1]))
+ // result: (Rsh32Ux64 <types.UInt32> (Hmul32u <types.UInt32> (Const32 <types.UInt32> [int64(int32(1<<31+umagic(32,c).m/2))]) x) (Const64 <types.UInt64> [umagic(32,c).s-1]))
for {
x := v.Args[0]
v_1 := v.Args[1]
break
}
v.reset(OpRsh32Ux64)
- v.Type = fe.TypeUInt32()
- v0 := b.NewValue0(v.Pos, OpHmul32u, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v.Type = types.UInt32
+ v0 := b.NewValue0(v.Pos, OpHmul32u, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v1.AuxInt = int64(int32(1<<31 + umagic(32, c).m/2))
v0.AddArg(v1)
v0.AddArg(x)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = umagic(32, c).s - 1
v.AddArg(v2)
return true
}
// match: (Div32u x (Const32 [c]))
// cond: umagicOK(32, c) && config.RegSize == 4 && c&1 == 0
- // result: (Rsh32Ux64 <fe.TypeUInt32()> (Hmul32u <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(int32(1<<31+(umagic(32,c).m+1)/2))]) (Rsh32Ux64 <fe.TypeUInt32()> x (Const64 <fe.TypeUInt64()> [1]))) (Const64 <fe.TypeUInt64()> [umagic(32,c).s-2]))
+ // result: (Rsh32Ux64 <types.UInt32> (Hmul32u <types.UInt32> (Const32 <types.UInt32> [int64(int32(1<<31+(umagic(32,c).m+1)/2))]) (Rsh32Ux64 <types.UInt32> x (Const64 <types.UInt64> [1]))) (Const64 <types.UInt64> [umagic(32,c).s-2]))
for {
x := v.Args[0]
v_1 := v.Args[1]
break
}
v.reset(OpRsh32Ux64)
- v.Type = fe.TypeUInt32()
- v0 := b.NewValue0(v.Pos, OpHmul32u, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v.Type = types.UInt32
+ v0 := b.NewValue0(v.Pos, OpHmul32u, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v1.AuxInt = int64(int32(1<<31 + (umagic(32, c).m+1)/2))
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpRsh32Ux64, fe.TypeUInt32())
+ v2 := b.NewValue0(v.Pos, OpRsh32Ux64, types.UInt32)
v2.AddArg(x)
- v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v3.AuxInt = 1
v2.AddArg(v3)
v0.AddArg(v2)
v.AddArg(v0)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = umagic(32, c).s - 2
v.AddArg(v4)
return true
}
// match: (Div32u x (Const32 [c]))
// cond: umagicOK(32, c) && config.RegSize == 4
- // result: (Rsh32Ux64 <fe.TypeUInt32()> (Avg32u x (Hmul32u <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(int32(umagic(32,c).m))]) x)) (Const64 <fe.TypeUInt64()> [umagic(32,c).s-1]))
+ // result: (Rsh32Ux64 <types.UInt32> (Avg32u x (Hmul32u <types.UInt32> (Const32 <types.UInt32> [int64(int32(umagic(32,c).m))]) x)) (Const64 <types.UInt64> [umagic(32,c).s-1]))
for {
x := v.Args[0]
v_1 := v.Args[1]
break
}
v.reset(OpRsh32Ux64)
- v.Type = fe.TypeUInt32()
- v0 := b.NewValue0(v.Pos, OpAvg32u, fe.TypeUInt32())
+ v.Type = types.UInt32
+ v0 := b.NewValue0(v.Pos, OpAvg32u, types.UInt32)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpHmul32u, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpHmul32u, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v2.AuxInt = int64(int32(umagic(32, c).m))
v1.AddArg(v2)
v1.AddArg(x)
v0.AddArg(v1)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v3.AuxInt = umagic(32, c).s - 1
v.AddArg(v3)
return true
}
// match: (Div32u x (Const32 [c]))
// cond: umagicOK(32, c) && config.RegSize == 8 && umagic(32,c).m&1 == 0
- // result: (Trunc64to32 (Rsh64Ux64 <fe.TypeUInt64()> (Mul64 <fe.TypeUInt64()> (Const64 <fe.TypeUInt64()> [int64(1<<31+umagic(32,c).m/2)]) (ZeroExt32to64 x)) (Const64 <fe.TypeUInt64()> [32+umagic(32,c).s-1])))
+ // result: (Trunc64to32 (Rsh64Ux64 <types.UInt64> (Mul64 <types.UInt64> (Const64 <types.UInt64> [int64(1<<31+umagic(32,c).m/2)]) (ZeroExt32to64 x)) (Const64 <types.UInt64> [32+umagic(32,c).s-1])))
for {
x := v.Args[0]
v_1 := v.Args[1]
break
}
v.reset(OpTrunc64to32)
- v0 := b.NewValue0(v.Pos, OpRsh64Ux64, fe.TypeUInt64())
- v1 := b.NewValue0(v.Pos, OpMul64, fe.TypeUInt64())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpRsh64Ux64, types.UInt64)
+ v1 := b.NewValue0(v.Pos, OpMul64, types.UInt64)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = int64(1<<31 + umagic(32, c).m/2)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(x)
v1.AddArg(v3)
v0.AddArg(v1)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 32 + umagic(32, c).s - 1
v0.AddArg(v4)
v.AddArg(v0)
}
// match: (Div32u x (Const32 [c]))
// cond: umagicOK(32, c) && config.RegSize == 8 && c&1 == 0
- // result: (Trunc64to32 (Rsh64Ux64 <fe.TypeUInt64()> (Mul64 <fe.TypeUInt64()> (Const64 <fe.TypeUInt64()> [int64(1<<31+(umagic(32,c).m+1)/2)]) (Rsh64Ux64 <fe.TypeUInt64()> (ZeroExt32to64 x) (Const64 <fe.TypeUInt64()> [1]))) (Const64 <fe.TypeUInt64()> [32+umagic(32,c).s-2])))
+ // result: (Trunc64to32 (Rsh64Ux64 <types.UInt64> (Mul64 <types.UInt64> (Const64 <types.UInt64> [int64(1<<31+(umagic(32,c).m+1)/2)]) (Rsh64Ux64 <types.UInt64> (ZeroExt32to64 x) (Const64 <types.UInt64> [1]))) (Const64 <types.UInt64> [32+umagic(32,c).s-2])))
for {
x := v.Args[0]
v_1 := v.Args[1]
break
}
v.reset(OpTrunc64to32)
- v0 := b.NewValue0(v.Pos, OpRsh64Ux64, fe.TypeUInt64())
- v1 := b.NewValue0(v.Pos, OpMul64, fe.TypeUInt64())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpRsh64Ux64, types.UInt64)
+ v1 := b.NewValue0(v.Pos, OpMul64, types.UInt64)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = int64(1<<31 + (umagic(32, c).m+1)/2)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpRsh64Ux64, fe.TypeUInt64())
- v4 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpRsh64Ux64, types.UInt64)
+ v4 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v4.AddArg(x)
v3.AddArg(v4)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = 1
v3.AddArg(v5)
v1.AddArg(v3)
v0.AddArg(v1)
- v6 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v6.AuxInt = 32 + umagic(32, c).s - 2
v0.AddArg(v6)
v.AddArg(v0)
}
// match: (Div32u x (Const32 [c]))
// cond: umagicOK(32, c) && config.RegSize == 8
- // result: (Trunc64to32 (Rsh64Ux64 <fe.TypeUInt64()> (Avg64u (Lsh64x64 <fe.TypeUInt64()> (ZeroExt32to64 x) (Const64 <fe.TypeUInt64()> [32])) (Mul64 <fe.TypeUInt64()> (Const64 <fe.TypeUInt32()> [int64(umagic(32,c).m)]) (ZeroExt32to64 x))) (Const64 <fe.TypeUInt64()> [32+umagic(32,c).s-1])))
+ // result: (Trunc64to32 (Rsh64Ux64 <types.UInt64> (Avg64u (Lsh64x64 <types.UInt64> (ZeroExt32to64 x) (Const64 <types.UInt64> [32])) (Mul64 <types.UInt64> (Const64 <types.UInt32> [int64(umagic(32,c).m)]) (ZeroExt32to64 x))) (Const64 <types.UInt64> [32+umagic(32,c).s-1])))
for {
x := v.Args[0]
v_1 := v.Args[1]
break
}
v.reset(OpTrunc64to32)
- v0 := b.NewValue0(v.Pos, OpRsh64Ux64, fe.TypeUInt64())
- v1 := b.NewValue0(v.Pos, OpAvg64u, fe.TypeUInt64())
- v2 := b.NewValue0(v.Pos, OpLsh64x64, fe.TypeUInt64())
- v3 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpRsh64Ux64, types.UInt64)
+ v1 := b.NewValue0(v.Pos, OpAvg64u, types.UInt64)
+ v2 := b.NewValue0(v.Pos, OpLsh64x64, types.UInt64)
+ v3 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v3.AddArg(x)
v2.AddArg(v3)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 32
v2.AddArg(v4)
v1.AddArg(v2)
- v5 := b.NewValue0(v.Pos, OpMul64, fe.TypeUInt64())
- v6 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt32())
+ v5 := b.NewValue0(v.Pos, OpMul64, types.UInt64)
+ v6 := b.NewValue0(v.Pos, OpConst64, types.UInt32)
v6.AuxInt = int64(umagic(32, c).m)
v5.AddArg(v6)
- v7 := b.NewValue0(v.Pos, OpZeroExt32to64, fe.TypeUInt64())
+ v7 := b.NewValue0(v.Pos, OpZeroExt32to64, types.UInt64)
v7.AddArg(x)
v5.AddArg(v7)
v1.AddArg(v5)
v0.AddArg(v1)
- v8 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v8 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v8.AuxInt = 32 + umagic(32, c).s - 1
v0.AddArg(v8)
v.AddArg(v0)
func rewriteValuegeneric_OpDiv64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div64 (Const64 [c]) (Const64 [d]))
// cond: d != 0
// result: (Const64 [c/d])
}
// match: (Div64 <t> x (Const64 [-1<<63]))
// cond:
- // result: (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <fe.TypeUInt64()> [63]))
+ // result: (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <types.UInt64> [63]))
for {
t := v.Type
x := v.Args[0]
v1.AddArg(x)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 63
v.AddArg(v2)
return true
}
// match: (Div64 <t> n (Const64 [c]))
// cond: isPowerOfTwo(c)
- // result: (Rsh64x64 (Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <fe.TypeUInt64()> [63])) (Const64 <fe.TypeUInt64()> [64-log2(c)]))) (Const64 <fe.TypeUInt64()> [log2(c)]))
+ // result: (Rsh64x64 (Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <types.UInt64> [63])) (Const64 <types.UInt64> [64-log2(c)]))) (Const64 <types.UInt64> [log2(c)]))
for {
t := v.Type
n := v.Args[0]
v1 := b.NewValue0(v.Pos, OpRsh64Ux64, t)
v2 := b.NewValue0(v.Pos, OpRsh64x64, t)
v2.AddArg(n)
- v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v3.AuxInt = 63
v2.AddArg(v3)
v1.AddArg(v2)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 64 - log2(c)
v1.AddArg(v4)
v0.AddArg(v1)
v.AddArg(v0)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = log2(c)
v.AddArg(v5)
return true
}
// match: (Div64 <t> x (Const64 [c]))
// cond: smagicOK(64,c) && smagic(64,c).m&1 == 0
- // result: (Sub64 <t> (Rsh64x64 <t> (Hmul64 <t> (Const64 <fe.TypeUInt64()> [int64(smagic(64,c).m/2)]) x) (Const64 <fe.TypeUInt64()> [smagic(64,c).s-1])) (Rsh64x64 <t> x (Const64 <fe.TypeUInt64()> [63])))
+ // result: (Sub64 <t> (Rsh64x64 <t> (Hmul64 <t> (Const64 <types.UInt64> [int64(smagic(64,c).m/2)]) x) (Const64 <types.UInt64> [smagic(64,c).s-1])) (Rsh64x64 <t> x (Const64 <types.UInt64> [63])))
for {
t := v.Type
x := v.Args[0]
v.Type = t
v0 := b.NewValue0(v.Pos, OpRsh64x64, t)
v1 := b.NewValue0(v.Pos, OpHmul64, t)
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = int64(smagic(64, c).m / 2)
v1.AddArg(v2)
v1.AddArg(x)
v0.AddArg(v1)
- v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v3.AuxInt = smagic(64, c).s - 1
v0.AddArg(v3)
v.AddArg(v0)
v4 := b.NewValue0(v.Pos, OpRsh64x64, t)
v4.AddArg(x)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = 63
v4.AddArg(v5)
v.AddArg(v4)
}
// match: (Div64 <t> x (Const64 [c]))
// cond: smagicOK(64,c) && smagic(64,c).m&1 != 0
- // result: (Sub64 <t> (Rsh64x64 <t> (Add64 <t> (Hmul64 <t> (Const64 <fe.TypeUInt64()> [int64(smagic(64,c).m)]) x) x) (Const64 <fe.TypeUInt64()> [smagic(64,c).s])) (Rsh64x64 <t> x (Const64 <fe.TypeUInt64()> [63])))
+ // result: (Sub64 <t> (Rsh64x64 <t> (Add64 <t> (Hmul64 <t> (Const64 <types.UInt64> [int64(smagic(64,c).m)]) x) x) (Const64 <types.UInt64> [smagic(64,c).s])) (Rsh64x64 <t> x (Const64 <types.UInt64> [63])))
for {
t := v.Type
x := v.Args[0]
v0 := b.NewValue0(v.Pos, OpRsh64x64, t)
v1 := b.NewValue0(v.Pos, OpAdd64, t)
v2 := b.NewValue0(v.Pos, OpHmul64, t)
- v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v3.AuxInt = int64(smagic(64, c).m)
v2.AddArg(v3)
v2.AddArg(x)
v1.AddArg(v2)
v1.AddArg(x)
v0.AddArg(v1)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = smagic(64, c).s
v0.AddArg(v4)
v.AddArg(v0)
v5 := b.NewValue0(v.Pos, OpRsh64x64, t)
v5.AddArg(x)
- v6 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v6 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v6.AuxInt = 63
v5.AddArg(v6)
v.AddArg(v5)
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div64u (Const64 [c]) (Const64 [d]))
// cond: d != 0
// result: (Const64 [int64(uint64(c)/uint64(d))])
}
// match: (Div64u n (Const64 [c]))
// cond: isPowerOfTwo(c)
- // result: (Rsh64Ux64 n (Const64 <fe.TypeUInt64()> [log2(c)]))
+ // result: (Rsh64Ux64 n (Const64 <types.UInt64> [log2(c)]))
for {
n := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpRsh64Ux64)
v.AddArg(n)
- v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v0.AuxInt = log2(c)
v.AddArg(v0)
return true
}
// match: (Div64u x (Const64 [c]))
// cond: umagicOK(64, c) && config.RegSize == 8 && umagic(64,c).m&1 == 0
- // result: (Rsh64Ux64 <fe.TypeUInt64()> (Hmul64u <fe.TypeUInt64()> (Const64 <fe.TypeUInt64()> [int64(1<<63+umagic(64,c).m/2)]) x) (Const64 <fe.TypeUInt64()> [umagic(64,c).s-1]))
+ // result: (Rsh64Ux64 <types.UInt64> (Hmul64u <types.UInt64> (Const64 <types.UInt64> [int64(1<<63+umagic(64,c).m/2)]) x) (Const64 <types.UInt64> [umagic(64,c).s-1]))
for {
x := v.Args[0]
v_1 := v.Args[1]
break
}
v.reset(OpRsh64Ux64)
- v.Type = fe.TypeUInt64()
- v0 := b.NewValue0(v.Pos, OpHmul64u, fe.TypeUInt64())
- v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v.Type = types.UInt64
+ v0 := b.NewValue0(v.Pos, OpHmul64u, types.UInt64)
+ v1 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v1.AuxInt = int64(1<<63 + umagic(64, c).m/2)
v0.AddArg(v1)
v0.AddArg(x)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = umagic(64, c).s - 1
v.AddArg(v2)
return true
}
// match: (Div64u x (Const64 [c]))
// cond: umagicOK(64, c) && config.RegSize == 8 && c&1 == 0
- // result: (Rsh64Ux64 <fe.TypeUInt64()> (Hmul64u <fe.TypeUInt64()> (Const64 <fe.TypeUInt64()> [int64(1<<63+(umagic(64,c).m+1)/2)]) (Rsh64Ux64 <fe.TypeUInt64()> x (Const64 <fe.TypeUInt64()> [1]))) (Const64 <fe.TypeUInt64()> [umagic(64,c).s-2]))
+ // result: (Rsh64Ux64 <types.UInt64> (Hmul64u <types.UInt64> (Const64 <types.UInt64> [int64(1<<63+(umagic(64,c).m+1)/2)]) (Rsh64Ux64 <types.UInt64> x (Const64 <types.UInt64> [1]))) (Const64 <types.UInt64> [umagic(64,c).s-2]))
for {
x := v.Args[0]
v_1 := v.Args[1]
break
}
v.reset(OpRsh64Ux64)
- v.Type = fe.TypeUInt64()
- v0 := b.NewValue0(v.Pos, OpHmul64u, fe.TypeUInt64())
- v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v.Type = types.UInt64
+ v0 := b.NewValue0(v.Pos, OpHmul64u, types.UInt64)
+ v1 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v1.AuxInt = int64(1<<63 + (umagic(64, c).m+1)/2)
v0.AddArg(v1)
- v2 := b.NewValue0(v.Pos, OpRsh64Ux64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpRsh64Ux64, types.UInt64)
v2.AddArg(x)
- v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v3.AuxInt = 1
v2.AddArg(v3)
v0.AddArg(v2)
v.AddArg(v0)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = umagic(64, c).s - 2
v.AddArg(v4)
return true
}
// match: (Div64u x (Const64 [c]))
// cond: umagicOK(64, c) && config.RegSize == 8
- // result: (Rsh64Ux64 <fe.TypeUInt64()> (Avg64u x (Hmul64u <fe.TypeUInt64()> (Const64 <fe.TypeUInt64()> [int64(umagic(64,c).m)]) x)) (Const64 <fe.TypeUInt64()> [umagic(64,c).s-1]))
+ // result: (Rsh64Ux64 <types.UInt64> (Avg64u x (Hmul64u <types.UInt64> (Const64 <types.UInt64> [int64(umagic(64,c).m)]) x)) (Const64 <types.UInt64> [umagic(64,c).s-1]))
for {
x := v.Args[0]
v_1 := v.Args[1]
break
}
v.reset(OpRsh64Ux64)
- v.Type = fe.TypeUInt64()
- v0 := b.NewValue0(v.Pos, OpAvg64u, fe.TypeUInt64())
+ v.Type = types.UInt64
+ v0 := b.NewValue0(v.Pos, OpAvg64u, types.UInt64)
v0.AddArg(x)
- v1 := b.NewValue0(v.Pos, OpHmul64u, fe.TypeUInt64())
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpHmul64u, types.UInt64)
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = int64(umagic(64, c).m)
v1.AddArg(v2)
v1.AddArg(x)
v0.AddArg(v1)
v.AddArg(v0)
- v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v3.AuxInt = umagic(64, c).s - 1
v.AddArg(v3)
return true
func rewriteValuegeneric_OpDiv8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8 (Const8 [c]) (Const8 [d]))
// cond: d != 0
// result: (Const8 [int64(int8(c)/int8(d))])
}
// match: (Div8 <t> x (Const8 [-1<<7 ]))
// cond:
- // result: (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <fe.TypeUInt64()> [7 ]))
+ // result: (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <types.UInt64> [7 ]))
for {
t := v.Type
x := v.Args[0]
v1.AddArg(x)
v0.AddArg(v1)
v.AddArg(v0)
- v2 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v2 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v2.AuxInt = 7
v.AddArg(v2)
return true
}
// match: (Div8 <t> n (Const8 [c]))
// cond: isPowerOfTwo(c)
- // result: (Rsh8x64 (Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <fe.TypeUInt64()> [ 7])) (Const64 <fe.TypeUInt64()> [ 8-log2(c)]))) (Const64 <fe.TypeUInt64()> [log2(c)]))
+ // result: (Rsh8x64 (Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <types.UInt64> [ 7])) (Const64 <types.UInt64> [ 8-log2(c)]))) (Const64 <types.UInt64> [log2(c)]))
for {
t := v.Type
n := v.Args[0]
v1 := b.NewValue0(v.Pos, OpRsh8Ux64, t)
v2 := b.NewValue0(v.Pos, OpRsh8x64, t)
v2.AddArg(n)
- v3 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v3 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v3.AuxInt = 7
v2.AddArg(v3)
v1.AddArg(v2)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 8 - log2(c)
v1.AddArg(v4)
v0.AddArg(v1)
v.AddArg(v0)
- v5 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v5 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v5.AuxInt = log2(c)
v.AddArg(v5)
return true
}
// match: (Div8 <t> x (Const8 [c]))
// cond: smagicOK(8,c)
- // result: (Sub8 <t> (Rsh32x64 <t> (Mul32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(smagic(8,c).m)]) (SignExt8to32 x)) (Const64 <fe.TypeUInt64()> [8+smagic(8,c).s])) (Rsh32x64 <t> (SignExt8to32 x) (Const64 <fe.TypeUInt64()> [31])))
+ // result: (Sub8 <t> (Rsh32x64 <t> (Mul32 <types.UInt32> (Const32 <types.UInt32> [int64(smagic(8,c).m)]) (SignExt8to32 x)) (Const64 <types.UInt64> [8+smagic(8,c).s])) (Rsh32x64 <t> (SignExt8to32 x) (Const64 <types.UInt64> [31])))
for {
t := v.Type
x := v.Args[0]
v.reset(OpSub8)
v.Type = t
v0 := b.NewValue0(v.Pos, OpRsh32x64, t)
- v1 := b.NewValue0(v.Pos, OpMul32, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v1 := b.NewValue0(v.Pos, OpMul32, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v2.AuxInt = int64(smagic(8, c).m)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v3 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v3.AddArg(x)
v1.AddArg(v3)
v0.AddArg(v1)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 8 + smagic(8, c).s
v0.AddArg(v4)
v.AddArg(v0)
v5 := b.NewValue0(v.Pos, OpRsh32x64, t)
- v6 := b.NewValue0(v.Pos, OpSignExt8to32, fe.TypeInt32())
+ v6 := b.NewValue0(v.Pos, OpSignExt8to32, types.Int32)
v6.AddArg(x)
v5.AddArg(v6)
- v7 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v7 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v7.AuxInt = 31
v5.AddArg(v7)
v.AddArg(v5)
func rewriteValuegeneric_OpDiv8u(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Div8u (Const8 [c]) (Const8 [d]))
// cond: d != 0
// result: (Const8 [int64(int8(uint8(c)/uint8(d)))])
}
// match: (Div8u n (Const8 [c]))
// cond: isPowerOfTwo(c&0xff)
- // result: (Rsh8Ux64 n (Const64 <fe.TypeUInt64()> [log2(c&0xff)]))
+ // result: (Rsh8Ux64 n (Const64 <types.UInt64> [log2(c&0xff)]))
for {
n := v.Args[0]
v_1 := v.Args[1]
}
v.reset(OpRsh8Ux64)
v.AddArg(n)
- v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v0.AuxInt = log2(c & 0xff)
v.AddArg(v0)
return true
}
// match: (Div8u x (Const8 [c]))
// cond: umagicOK(8, c)
- // result: (Trunc32to8 (Rsh32Ux64 <fe.TypeUInt32()> (Mul32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [int64(1<<8+umagic(8,c).m)]) (ZeroExt8to32 x)) (Const64 <fe.TypeUInt64()> [8+umagic(8,c).s])))
+ // result: (Trunc32to8 (Rsh32Ux64 <types.UInt32> (Mul32 <types.UInt32> (Const32 <types.UInt32> [int64(1<<8+umagic(8,c).m)]) (ZeroExt8to32 x)) (Const64 <types.UInt64> [8+umagic(8,c).s])))
for {
x := v.Args[0]
v_1 := v.Args[1]
break
}
v.reset(OpTrunc32to8)
- v0 := b.NewValue0(v.Pos, OpRsh32Ux64, fe.TypeUInt32())
- v1 := b.NewValue0(v.Pos, OpMul32, fe.TypeUInt32())
- v2 := b.NewValue0(v.Pos, OpConst32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpRsh32Ux64, types.UInt32)
+ v1 := b.NewValue0(v.Pos, OpMul32, types.UInt32)
+ v2 := b.NewValue0(v.Pos, OpConst32, types.UInt32)
v2.AuxInt = int64(1<<8 + umagic(8, c).m)
v1.AddArg(v2)
- v3 := b.NewValue0(v.Pos, OpZeroExt8to32, fe.TypeUInt32())
+ v3 := b.NewValue0(v.Pos, OpZeroExt8to32, types.UInt32)
v3.AddArg(x)
v1.AddArg(v3)
v0.AddArg(v1)
- v4 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v4 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v4.AuxInt = 8 + umagic(8, c).s
v0.AddArg(v4)
v.AddArg(v0)
func rewriteValuegeneric_OpEqInter(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (EqInter x y)
// cond:
// result: (EqPtr (ITab x) (ITab y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpEqPtr)
- v0 := b.NewValue0(v.Pos, OpITab, fe.TypeBytePtr())
+ v0 := b.NewValue0(v.Pos, OpITab, types.BytePtr)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpITab, fe.TypeBytePtr())
+ v1 := b.NewValue0(v.Pos, OpITab, types.BytePtr)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValuegeneric_OpEqPtr(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (EqPtr p (ConstNil))
// cond:
// result: (Not (IsNonNil p))
break
}
v.reset(OpNot)
- v0 := b.NewValue0(v.Pos, OpIsNonNil, fe.TypeBool())
+ v0 := b.NewValue0(v.Pos, OpIsNonNil, types.Bool)
v0.AddArg(p)
v.AddArg(v0)
return true
}
p := v.Args[1]
v.reset(OpNot)
- v0 := b.NewValue0(v.Pos, OpIsNonNil, fe.TypeBool())
+ v0 := b.NewValue0(v.Pos, OpIsNonNil, types.Bool)
v0.AddArg(p)
v.AddArg(v0)
return true
func rewriteValuegeneric_OpEqSlice(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (EqSlice x y)
// cond:
// result: (EqPtr (SlicePtr x) (SlicePtr y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpEqPtr)
- v0 := b.NewValue0(v.Pos, OpSlicePtr, fe.TypeBytePtr())
+ v0 := b.NewValue0(v.Pos, OpSlicePtr, types.BytePtr)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSlicePtr, fe.TypeBytePtr())
+ v1 := b.NewValue0(v.Pos, OpSlicePtr, types.BytePtr)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValuegeneric_OpLsh16x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh16x64 (Const16 [c]) (Const64 [d]))
// cond:
// result: (Const16 [int64(int16(c) << uint64(d))])
}
// match: (Lsh16x64 (Rsh16Ux64 (Lsh16x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
- // result: (Lsh16x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3]))
+ // result: (Lsh16x64 x (Const64 <types.UInt64> [c1-c2+c3]))
for {
v_0 := v.Args[0]
if v_0.Op != OpRsh16Ux64 {
}
v.reset(OpLsh16x64)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v0.AuxInt = c1 - c2 + c3
v.AddArg(v0)
return true
func rewriteValuegeneric_OpLsh32x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh32x64 (Const32 [c]) (Const64 [d]))
// cond:
// result: (Const32 [int64(int32(c) << uint64(d))])
}
// match: (Lsh32x64 (Rsh32Ux64 (Lsh32x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
- // result: (Lsh32x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3]))
+ // result: (Lsh32x64 x (Const64 <types.UInt64> [c1-c2+c3]))
for {
v_0 := v.Args[0]
if v_0.Op != OpRsh32Ux64 {
}
v.reset(OpLsh32x64)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v0.AuxInt = c1 - c2 + c3
v.AddArg(v0)
return true
func rewriteValuegeneric_OpLsh64x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh64x64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (Const64 [c << uint64(d)])
}
// match: (Lsh64x64 (Rsh64Ux64 (Lsh64x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
- // result: (Lsh64x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3]))
+ // result: (Lsh64x64 x (Const64 <types.UInt64> [c1-c2+c3]))
for {
v_0 := v.Args[0]
if v_0.Op != OpRsh64Ux64 {
}
v.reset(OpLsh64x64)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v0.AuxInt = c1 - c2 + c3
v.AddArg(v0)
return true
func rewriteValuegeneric_OpLsh8x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Lsh8x64 (Const8 [c]) (Const64 [d]))
// cond:
// result: (Const8 [int64(int8(c) << uint64(d))])
}
// match: (Lsh8x64 (Rsh8Ux64 (Lsh8x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
- // result: (Lsh8x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3]))
+ // result: (Lsh8x64 x (Const64 <types.UInt64> [c1-c2+c3]))
for {
v_0 := v.Args[0]
if v_0.Op != OpRsh8Ux64 {
}
v.reset(OpLsh8x64)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v0.AuxInt = c1 - c2 + c3
v.AddArg(v0)
return true
func rewriteValuegeneric_OpMul16(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mul16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (Const16 [int64(int16(c*d))])
}
// match: (Mul16 <t> n (Const16 [c]))
// cond: isPowerOfTwo(c)
- // result: (Lsh16x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)]))
+ // result: (Lsh16x64 <t> n (Const64 <types.UInt64> [log2(c)]))
for {
t := v.Type
n := v.Args[0]
v.reset(OpLsh16x64)
v.Type = t
v.AddArg(n)
- v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v0.AuxInt = log2(c)
v.AddArg(v0)
return true
}
// match: (Mul16 <t> n (Const16 [c]))
// cond: t.IsSigned() && isPowerOfTwo(-c)
- // result: (Neg16 (Lsh16x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)])))
+ // result: (Neg16 (Lsh16x64 <t> n (Const64 <types.UInt64> [log2(-c)])))
for {
t := v.Type
n := v.Args[0]
v.reset(OpNeg16)
v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
v0.AddArg(n)
- v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v1.AuxInt = log2(-c)
v0.AddArg(v1)
v.AddArg(v0)
func rewriteValuegeneric_OpMul32(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mul32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (Const32 [int64(int32(c*d))])
}
// match: (Mul32 <t> n (Const32 [c]))
// cond: isPowerOfTwo(c)
- // result: (Lsh32x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)]))
+ // result: (Lsh32x64 <t> n (Const64 <types.UInt64> [log2(c)]))
for {
t := v.Type
n := v.Args[0]
v.reset(OpLsh32x64)
v.Type = t
v.AddArg(n)
- v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v0.AuxInt = log2(c)
v.AddArg(v0)
return true
}
// match: (Mul32 <t> n (Const32 [c]))
// cond: t.IsSigned() && isPowerOfTwo(-c)
- // result: (Neg32 (Lsh32x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)])))
+ // result: (Neg32 (Lsh32x64 <t> n (Const64 <types.UInt64> [log2(-c)])))
for {
t := v.Type
n := v.Args[0]
v.reset(OpNeg32)
v0 := b.NewValue0(v.Pos, OpLsh32x64, t)
v0.AddArg(n)
- v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v1.AuxInt = log2(-c)
v0.AddArg(v1)
v.AddArg(v0)
func rewriteValuegeneric_OpMul64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mul64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (Const64 [c*d])
}
// match: (Mul64 <t> n (Const64 [c]))
// cond: isPowerOfTwo(c)
- // result: (Lsh64x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)]))
+ // result: (Lsh64x64 <t> n (Const64 <types.UInt64> [log2(c)]))
for {
t := v.Type
n := v.Args[0]
v.reset(OpLsh64x64)
v.Type = t
v.AddArg(n)
- v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v0.AuxInt = log2(c)
v.AddArg(v0)
return true
}
// match: (Mul64 <t> n (Const64 [c]))
// cond: t.IsSigned() && isPowerOfTwo(-c)
- // result: (Neg64 (Lsh64x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)])))
+ // result: (Neg64 (Lsh64x64 <t> n (Const64 <types.UInt64> [log2(-c)])))
for {
t := v.Type
n := v.Args[0]
v.reset(OpNeg64)
v0 := b.NewValue0(v.Pos, OpLsh64x64, t)
v0.AddArg(n)
- v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v1.AuxInt = log2(-c)
v0.AddArg(v1)
v.AddArg(v0)
func rewriteValuegeneric_OpMul8(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Mul8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (Const8 [int64(int8(c*d))])
}
// match: (Mul8 <t> n (Const8 [c]))
// cond: isPowerOfTwo(c)
- // result: (Lsh8x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)]))
+ // result: (Lsh8x64 <t> n (Const64 <types.UInt64> [log2(c)]))
for {
t := v.Type
n := v.Args[0]
v.reset(OpLsh8x64)
v.Type = t
v.AddArg(n)
- v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v0.AuxInt = log2(c)
v.AddArg(v0)
return true
}
// match: (Mul8 <t> n (Const8 [c]))
// cond: t.IsSigned() && isPowerOfTwo(-c)
- // result: (Neg8 (Lsh8x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)])))
+ // result: (Neg8 (Lsh8x64 <t> n (Const64 <types.UInt64> [log2(-c)])))
for {
t := v.Type
n := v.Args[0]
v.reset(OpNeg8)
v0 := b.NewValue0(v.Pos, OpLsh8x64, t)
v0.AddArg(n)
- v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v1 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v1.AuxInt = log2(-c)
v0.AddArg(v1)
v.AddArg(v0)
func rewriteValuegeneric_OpNeqInter(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (NeqInter x y)
// cond:
// result: (NeqPtr (ITab x) (ITab y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpNeqPtr)
- v0 := b.NewValue0(v.Pos, OpITab, fe.TypeBytePtr())
+ v0 := b.NewValue0(v.Pos, OpITab, types.BytePtr)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpITab, fe.TypeBytePtr())
+ v1 := b.NewValue0(v.Pos, OpITab, types.BytePtr)
v1.AddArg(y)
v.AddArg(v1)
return true
func rewriteValuegeneric_OpNeqSlice(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (NeqSlice x y)
// cond:
// result: (NeqPtr (SlicePtr x) (SlicePtr y))
x := v.Args[0]
y := v.Args[1]
v.reset(OpNeqPtr)
- v0 := b.NewValue0(v.Pos, OpSlicePtr, fe.TypeBytePtr())
+ v0 := b.NewValue0(v.Pos, OpSlicePtr, types.BytePtr)
v0.AddArg(x)
v.AddArg(v0)
- v1 := b.NewValue0(v.Pos, OpSlicePtr, fe.TypeBytePtr())
+ v1 := b.NewValue0(v.Pos, OpSlicePtr, types.BytePtr)
v1.AddArg(y)
v.AddArg(v1)
return true
_ = b
config := b.Func.Config
_ = config
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (PtrIndex <t> ptr idx)
// cond: config.PtrSize == 4
- // result: (AddPtr ptr (Mul32 <fe.TypeInt()> idx (Const32 <fe.TypeInt()> [t.ElemType().Size()])))
+ // result: (AddPtr ptr (Mul32 <types.Int> idx (Const32 <types.Int> [t.ElemType().Size()])))
for {
t := v.Type
ptr := v.Args[0]
}
v.reset(OpAddPtr)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMul32, fe.TypeInt())
+ v0 := b.NewValue0(v.Pos, OpMul32, types.Int)
v0.AddArg(idx)
- v1 := b.NewValue0(v.Pos, OpConst32, fe.TypeInt())
+ v1 := b.NewValue0(v.Pos, OpConst32, types.Int)
v1.AuxInt = t.ElemType().Size()
v0.AddArg(v1)
v.AddArg(v0)
}
// match: (PtrIndex <t> ptr idx)
// cond: config.PtrSize == 8
- // result: (AddPtr ptr (Mul64 <fe.TypeInt()> idx (Const64 <fe.TypeInt()> [t.ElemType().Size()])))
+ // result: (AddPtr ptr (Mul64 <types.Int> idx (Const64 <types.Int> [t.ElemType().Size()])))
for {
t := v.Type
ptr := v.Args[0]
}
v.reset(OpAddPtr)
v.AddArg(ptr)
- v0 := b.NewValue0(v.Pos, OpMul64, fe.TypeInt())
+ v0 := b.NewValue0(v.Pos, OpMul64, types.Int)
v0.AddArg(idx)
- v1 := b.NewValue0(v.Pos, OpConst64, fe.TypeInt())
+ v1 := b.NewValue0(v.Pos, OpConst64, types.Int)
v1.AuxInt = t.ElemType().Size()
v0.AddArg(v1)
v.AddArg(v0)
func rewriteValuegeneric_OpRsh16Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16Ux64 (Const16 [c]) (Const64 [d]))
// cond:
// result: (Const16 [int64(int16(uint16(c) >> uint64(d)))])
}
// match: (Rsh16Ux64 (Lsh16x64 (Rsh16Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
- // result: (Rsh16Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3]))
+ // result: (Rsh16Ux64 x (Const64 <types.UInt64> [c1-c2+c3]))
for {
v_0 := v.Args[0]
if v_0.Op != OpLsh16x64 {
}
v.reset(OpRsh16Ux64)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v0.AuxInt = c1 - c2 + c3
v.AddArg(v0)
return true
}
// match: (Rsh16Ux64 (Lsh16x64 x (Const64 [8])) (Const64 [8]))
// cond:
- // result: (ZeroExt8to16 (Trunc16to8 <fe.TypeUInt8()> x))
+ // result: (ZeroExt8to16 (Trunc16to8 <types.UInt8> x))
for {
v_0 := v.Args[0]
if v_0.Op != OpLsh16x64 {
break
}
v.reset(OpZeroExt8to16)
- v0 := b.NewValue0(v.Pos, OpTrunc16to8, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpTrunc16to8, types.UInt8)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValuegeneric_OpRsh16x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh16x64 (Const16 [c]) (Const64 [d]))
// cond:
// result: (Const16 [int64(int16(c) >> uint64(d))])
}
// match: (Rsh16x64 (Lsh16x64 x (Const64 [8])) (Const64 [8]))
// cond:
- // result: (SignExt8to16 (Trunc16to8 <fe.TypeInt8()> x))
+ // result: (SignExt8to16 (Trunc16to8 <types.Int8> x))
for {
v_0 := v.Args[0]
if v_0.Op != OpLsh16x64 {
break
}
v.reset(OpSignExt8to16)
- v0 := b.NewValue0(v.Pos, OpTrunc16to8, fe.TypeInt8())
+ v0 := b.NewValue0(v.Pos, OpTrunc16to8, types.Int8)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValuegeneric_OpRsh32Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32Ux64 (Const32 [c]) (Const64 [d]))
// cond:
// result: (Const32 [int64(int32(uint32(c) >> uint64(d)))])
}
// match: (Rsh32Ux64 (Lsh32x64 (Rsh32Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
- // result: (Rsh32Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3]))
+ // result: (Rsh32Ux64 x (Const64 <types.UInt64> [c1-c2+c3]))
for {
v_0 := v.Args[0]
if v_0.Op != OpLsh32x64 {
}
v.reset(OpRsh32Ux64)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v0.AuxInt = c1 - c2 + c3
v.AddArg(v0)
return true
}
// match: (Rsh32Ux64 (Lsh32x64 x (Const64 [24])) (Const64 [24]))
// cond:
- // result: (ZeroExt8to32 (Trunc32to8 <fe.TypeUInt8()> x))
+ // result: (ZeroExt8to32 (Trunc32to8 <types.UInt8> x))
for {
v_0 := v.Args[0]
if v_0.Op != OpLsh32x64 {
break
}
v.reset(OpZeroExt8to32)
- v0 := b.NewValue0(v.Pos, OpTrunc32to8, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpTrunc32to8, types.UInt8)
v0.AddArg(x)
v.AddArg(v0)
return true
}
// match: (Rsh32Ux64 (Lsh32x64 x (Const64 [16])) (Const64 [16]))
// cond:
- // result: (ZeroExt16to32 (Trunc32to16 <fe.TypeUInt16()> x))
+ // result: (ZeroExt16to32 (Trunc32to16 <types.UInt16> x))
for {
v_0 := v.Args[0]
if v_0.Op != OpLsh32x64 {
break
}
v.reset(OpZeroExt16to32)
- v0 := b.NewValue0(v.Pos, OpTrunc32to16, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpTrunc32to16, types.UInt16)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValuegeneric_OpRsh32x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh32x64 (Const32 [c]) (Const64 [d]))
// cond:
// result: (Const32 [int64(int32(c) >> uint64(d))])
}
// match: (Rsh32x64 (Lsh32x64 x (Const64 [24])) (Const64 [24]))
// cond:
- // result: (SignExt8to32 (Trunc32to8 <fe.TypeInt8()> x))
+ // result: (SignExt8to32 (Trunc32to8 <types.Int8> x))
for {
v_0 := v.Args[0]
if v_0.Op != OpLsh32x64 {
break
}
v.reset(OpSignExt8to32)
- v0 := b.NewValue0(v.Pos, OpTrunc32to8, fe.TypeInt8())
+ v0 := b.NewValue0(v.Pos, OpTrunc32to8, types.Int8)
v0.AddArg(x)
v.AddArg(v0)
return true
}
// match: (Rsh32x64 (Lsh32x64 x (Const64 [16])) (Const64 [16]))
// cond:
- // result: (SignExt16to32 (Trunc32to16 <fe.TypeInt16()> x))
+ // result: (SignExt16to32 (Trunc32to16 <types.Int16> x))
for {
v_0 := v.Args[0]
if v_0.Op != OpLsh32x64 {
break
}
v.reset(OpSignExt16to32)
- v0 := b.NewValue0(v.Pos, OpTrunc32to16, fe.TypeInt16())
+ v0 := b.NewValue0(v.Pos, OpTrunc32to16, types.Int16)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValuegeneric_OpRsh64Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64Ux64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (Const64 [int64(uint64(c) >> uint64(d))])
}
// match: (Rsh64Ux64 (Lsh64x64 (Rsh64Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
- // result: (Rsh64Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3]))
+ // result: (Rsh64Ux64 x (Const64 <types.UInt64> [c1-c2+c3]))
for {
v_0 := v.Args[0]
if v_0.Op != OpLsh64x64 {
}
v.reset(OpRsh64Ux64)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v0.AuxInt = c1 - c2 + c3
v.AddArg(v0)
return true
}
// match: (Rsh64Ux64 (Lsh64x64 x (Const64 [56])) (Const64 [56]))
// cond:
- // result: (ZeroExt8to64 (Trunc64to8 <fe.TypeUInt8()> x))
+ // result: (ZeroExt8to64 (Trunc64to8 <types.UInt8> x))
for {
v_0 := v.Args[0]
if v_0.Op != OpLsh64x64 {
break
}
v.reset(OpZeroExt8to64)
- v0 := b.NewValue0(v.Pos, OpTrunc64to8, fe.TypeUInt8())
+ v0 := b.NewValue0(v.Pos, OpTrunc64to8, types.UInt8)
v0.AddArg(x)
v.AddArg(v0)
return true
}
// match: (Rsh64Ux64 (Lsh64x64 x (Const64 [48])) (Const64 [48]))
// cond:
- // result: (ZeroExt16to64 (Trunc64to16 <fe.TypeUInt16()> x))
+ // result: (ZeroExt16to64 (Trunc64to16 <types.UInt16> x))
for {
v_0 := v.Args[0]
if v_0.Op != OpLsh64x64 {
break
}
v.reset(OpZeroExt16to64)
- v0 := b.NewValue0(v.Pos, OpTrunc64to16, fe.TypeUInt16())
+ v0 := b.NewValue0(v.Pos, OpTrunc64to16, types.UInt16)
v0.AddArg(x)
v.AddArg(v0)
return true
}
// match: (Rsh64Ux64 (Lsh64x64 x (Const64 [32])) (Const64 [32]))
// cond:
- // result: (ZeroExt32to64 (Trunc64to32 <fe.TypeUInt32()> x))
+ // result: (ZeroExt32to64 (Trunc64to32 <types.UInt32> x))
for {
v_0 := v.Args[0]
if v_0.Op != OpLsh64x64 {
break
}
v.reset(OpZeroExt32to64)
- v0 := b.NewValue0(v.Pos, OpTrunc64to32, fe.TypeUInt32())
+ v0 := b.NewValue0(v.Pos, OpTrunc64to32, types.UInt32)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValuegeneric_OpRsh64x64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh64x64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (Const64 [c >> uint64(d)])
}
// match: (Rsh64x64 (Lsh64x64 x (Const64 [56])) (Const64 [56]))
// cond:
- // result: (SignExt8to64 (Trunc64to8 <fe.TypeInt8()> x))
+ // result: (SignExt8to64 (Trunc64to8 <types.Int8> x))
for {
v_0 := v.Args[0]
if v_0.Op != OpLsh64x64 {
break
}
v.reset(OpSignExt8to64)
- v0 := b.NewValue0(v.Pos, OpTrunc64to8, fe.TypeInt8())
+ v0 := b.NewValue0(v.Pos, OpTrunc64to8, types.Int8)
v0.AddArg(x)
v.AddArg(v0)
return true
}
// match: (Rsh64x64 (Lsh64x64 x (Const64 [48])) (Const64 [48]))
// cond:
- // result: (SignExt16to64 (Trunc64to16 <fe.TypeInt16()> x))
+ // result: (SignExt16to64 (Trunc64to16 <types.Int16> x))
for {
v_0 := v.Args[0]
if v_0.Op != OpLsh64x64 {
break
}
v.reset(OpSignExt16to64)
- v0 := b.NewValue0(v.Pos, OpTrunc64to16, fe.TypeInt16())
+ v0 := b.NewValue0(v.Pos, OpTrunc64to16, types.Int16)
v0.AddArg(x)
v.AddArg(v0)
return true
}
// match: (Rsh64x64 (Lsh64x64 x (Const64 [32])) (Const64 [32]))
// cond:
- // result: (SignExt32to64 (Trunc64to32 <fe.TypeInt32()> x))
+ // result: (SignExt32to64 (Trunc64to32 <types.Int32> x))
for {
v_0 := v.Args[0]
if v_0.Op != OpLsh64x64 {
break
}
v.reset(OpSignExt32to64)
- v0 := b.NewValue0(v.Pos, OpTrunc64to32, fe.TypeInt32())
+ v0 := b.NewValue0(v.Pos, OpTrunc64to32, types.Int32)
v0.AddArg(x)
v.AddArg(v0)
return true
func rewriteValuegeneric_OpRsh8Ux64(v *Value) bool {
b := v.Block
_ = b
- fe := b.Func.fe
- _ = fe
+ types := &b.Func.Config.Types
+ _ = types
// match: (Rsh8Ux64 (Const8 [c]) (Const64 [d]))
// cond:
// result: (Const8 [int64(int8(uint8(c) >> uint64(d)))])
}
// match: (Rsh8Ux64 (Lsh8x64 (Rsh8Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
- // result: (Rsh8Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3]))
+ // result: (Rsh8Ux64 x (Const64 <types.UInt64> [c1-c2+c3]))
for {
v_0 := v.Args[0]
if v_0.Op != OpLsh8x64 {
}
v.reset(OpRsh8Ux64)
v.AddArg(x)
- v0 := b.NewValue0(v.Pos, OpConst64, fe.TypeUInt64())
+ v0 := b.NewValue0(v.Pos, OpConst64, types.UInt64)
v0.AuxInt = c1 - c2 + c3
v.AddArg(v0)
return true
_ = config
fe := b.Func.fe
_ = fe
+ types := &config.Types
+ _ = types
switch b.Kind {
case BlockIf:
// match: (If (Not cond) yes no)
// x = phi(a, ...)
//
// We can replace the "a" in the phi with the constant true.
- ct := f.ConstBool(f.Entry.Pos, f.fe.TypeBool(), true)
- cf := f.ConstBool(f.Entry.Pos, f.fe.TypeBool(), false)
+ ct := f.ConstBool(f.Entry.Pos, f.Config.Types.Bool, true)
+ cf := f.ConstBool(f.Entry.Pos, f.Config.Types.Bool, false)
for _, b := range f.Blocks {
for _, v := range b.Values {
if v.Op != OpPhi {
}
}
if sb == nil {
- sb = f.Entry.NewValue0(initpos, OpSB, f.fe.TypeUintptr())
+ sb = f.Entry.NewValue0(initpos, OpSB, f.Config.Types.Uintptr)
}
if sp == nil {
- sp = f.Entry.NewValue0(initpos, OpSP, f.fe.TypeUintptr())
+ sp = f.Entry.NewValue0(initpos, OpSP, f.Config.Types.Uintptr)
}
- wbsym := &ExternSymbol{Typ: f.fe.TypeBool(), Sym: f.fe.Syslook("writeBarrier")}
- wbaddr = f.Entry.NewValue1A(initpos, OpAddr, f.fe.TypeUInt32().PtrTo(), wbsym, sb)
+ wbsym := &ExternSymbol{Typ: f.Config.Types.Bool, Sym: f.fe.Syslook("writeBarrier")}
+ wbaddr = f.Entry.NewValue1A(initpos, OpAddr, f.Config.Types.UInt32.PtrTo(), wbsym, sb)
writebarrierptr = f.fe.Syslook("writebarrierptr")
typedmemmove = f.fe.Syslook("typedmemmove")
typedmemclr = f.fe.Syslook("typedmemclr")
- const0 = f.ConstInt32(initpos, f.fe.TypeUInt32(), 0)
+ const0 = f.ConstInt32(initpos, f.Config.Types.UInt32, 0)
// allocate auxiliary data structures for computing store order
sset = f.newSparseSet(f.NumValues())
// set up control flow for write barrier test
// load word, test word, avoiding partial register write from load byte.
- flag := b.NewValue2(pos, OpLoad, f.fe.TypeUInt32(), wbaddr, mem)
- flag = b.NewValue2(pos, OpNeq32, f.fe.TypeBool(), flag, const0)
+ types := &f.Config.Types
+ flag := b.NewValue2(pos, OpLoad, types.UInt32, wbaddr, mem)
+ flag = b.NewValue2(pos, OpNeq32, types.Bool, flag, const0)
b.Kind = BlockIf
b.SetControl(flag)
b.Likely = BranchUnlikely
ptr := w.Args[0]
var typ interface{}
if w.Op != OpStoreWB {
- typ = &ExternSymbol{Typ: f.fe.TypeUintptr(), Sym: w.Aux.(Type).Symbol()}
+ typ = &ExternSymbol{Typ: types.Uintptr, Sym: w.Aux.(Type).Symbol()}
}
pos = w.Pos
off := config.ctxt.FixedFrameSize()
if typ != nil { // for typedmemmove
- taddr := b.NewValue1A(pos, OpAddr, b.Func.fe.TypeUintptr(), typ, sb)
+ taddr := b.NewValue1A(pos, OpAddr, b.Func.Config.Types.Uintptr, typ, sb)
off = round(off, taddr.Type.Alignment())
arg := b.NewValue1I(pos, OpOffPtr, taddr.Type.PtrTo(), off, sp)
mem = b.NewValue3A(pos, OpStore, TypeMem, ptr.Type, arg, taddr, mem)