| // Code generated from _gen/dec64.rules using 'go generate'; DO NOT EDIT. | |
| package dec64 | |
| import "cmd/compile/internal/types" | |
| import "cmd/compile/internal/ssa/ssaop" | |
| import "cmd/compile/internal/ssa" | |
| func RewriteValue(v *ssa.Value) bool { | |
| switch v.Op { | |
| case ssaop.OpAdd64: | |
| return rewriteValue_OpAdd64(v) | |
| case ssaop.OpAnd64: | |
| return rewriteValue_OpAnd64(v) | |
| case ssaop.OpArg: | |
| return rewriteValue_OpArg(v) | |
| case ssaop.OpAvg64u: | |
| return rewriteValue_OpAvg64u(v) | |
| case ssaop.OpBitLen64: | |
| return rewriteValue_OpBitLen64(v) | |
| case ssaop.OpBswap64: | |
| return rewriteValue_OpBswap64(v) | |
| case ssaop.OpCom64: | |
| return rewriteValue_OpCom64(v) | |
| case ssaop.OpConst64: | |
| return rewriteValue_OpConst64(v) | |
| case ssaop.OpCtz64: | |
| return rewriteValue_OpCtz64(v) | |
| case ssaop.OpCtz64NonZero: | |
| v.Op = ssaop.OpCtz64 | |
| return true | |
| case ssaop.OpEq64: | |
| return rewriteValue_OpEq64(v) | |
| case ssaop.OpHmul64: | |
| return rewriteValue_OpHmul64(v) | |
| case ssaop.OpHmul64u: | |
| return rewriteValue_OpHmul64u(v) | |
| case ssaop.OpInt64Hi: | |
| return rewriteValue_OpInt64Hi(v) | |
| case ssaop.OpInt64Lo: | |
| return rewriteValue_OpInt64Lo(v) | |
| case ssaop.OpLast: | |
| return rewriteValue_OpLast(v) | |
| case ssaop.OpLeq64: | |
| return rewriteValue_OpLeq64(v) | |
| case ssaop.OpLeq64U: | |
| return rewriteValue_OpLeq64U(v) | |
| case ssaop.OpLess64: | |
| return rewriteValue_OpLess64(v) | |
| case ssaop.OpLess64U: | |
| return rewriteValue_OpLess64U(v) | |
| case ssaop.OpLoad: | |
| return rewriteValue_OpLoad(v) | |
| case ssaop.OpLsh16x64: | |
| return rewriteValue_OpLsh16x64(v) | |
| case ssaop.OpLsh32x64: | |
| return rewriteValue_OpLsh32x64(v) | |
| case ssaop.OpLsh64x16: | |
| return rewriteValue_OpLsh64x16(v) | |
| case ssaop.OpLsh64x32: | |
| return rewriteValue_OpLsh64x32(v) | |
| case ssaop.OpLsh64x64: | |
| return rewriteValue_OpLsh64x64(v) | |
| case ssaop.OpLsh64x8: | |
| return rewriteValue_OpLsh64x8(v) | |
| case ssaop.OpLsh8x64: | |
| return rewriteValue_OpLsh8x64(v) | |
| case ssaop.OpMul64: | |
| return rewriteValue_OpMul64(v) | |
| case ssaop.OpMul64uhilo: | |
| return rewriteValue_OpMul64uhilo(v) | |
| case ssaop.OpNeg64: | |
| return rewriteValue_OpNeg64(v) | |
| case ssaop.OpNeq64: | |
| return rewriteValue_OpNeq64(v) | |
| case ssaop.OpOr32: | |
| return rewriteValue_OpOr32(v) | |
| case ssaop.OpOr64: | |
| return rewriteValue_OpOr64(v) | |
| case ssaop.OpRotateLeft16: | |
| return rewriteValue_OpRotateLeft16(v) | |
| case ssaop.OpRotateLeft32: | |
| return rewriteValue_OpRotateLeft32(v) | |
| case ssaop.OpRotateLeft64: | |
| return rewriteValue_OpRotateLeft64(v) | |
| case ssaop.OpRotateLeft8: | |
| return rewriteValue_OpRotateLeft8(v) | |
| case ssaop.OpRsh16Ux64: | |
| return rewriteValue_OpRsh16Ux64(v) | |
| case ssaop.OpRsh16x64: | |
| return rewriteValue_OpRsh16x64(v) | |
| case ssaop.OpRsh32Ux64: | |
| return rewriteValue_OpRsh32Ux64(v) | |
| case ssaop.OpRsh32x64: | |
| return rewriteValue_OpRsh32x64(v) | |
| case ssaop.OpRsh64Ux16: | |
| return rewriteValue_OpRsh64Ux16(v) | |
| case ssaop.OpRsh64Ux32: | |
| return rewriteValue_OpRsh64Ux32(v) | |
| case ssaop.OpRsh64Ux64: | |
| return rewriteValue_OpRsh64Ux64(v) | |
| case ssaop.OpRsh64Ux8: | |
| return rewriteValue_OpRsh64Ux8(v) | |
| case ssaop.OpRsh64x16: | |
| return rewriteValue_OpRsh64x16(v) | |
| case ssaop.OpRsh64x32: | |
| return rewriteValue_OpRsh64x32(v) | |
| case ssaop.OpRsh64x64: | |
| return rewriteValue_OpRsh64x64(v) | |
| case ssaop.OpRsh64x8: | |
| return rewriteValue_OpRsh64x8(v) | |
| case ssaop.OpRsh8Ux64: | |
| return rewriteValue_OpRsh8Ux64(v) | |
| case ssaop.OpRsh8x64: | |
| return rewriteValue_OpRsh8x64(v) | |
| case ssaop.OpSelect0: | |
| return rewriteValue_OpSelect0(v) | |
| case ssaop.OpSelect1: | |
| return rewriteValue_OpSelect1(v) | |
| case ssaop.OpSignExt16to64: | |
| return rewriteValue_OpSignExt16to64(v) | |
| case ssaop.OpSignExt32to64: | |
| return rewriteValue_OpSignExt32to64(v) | |
| case ssaop.OpSignExt8to64: | |
| return rewriteValue_OpSignExt8to64(v) | |
| case ssaop.OpStore: | |
| return rewriteValue_OpStore(v) | |
| case ssaop.OpSub64: | |
| return rewriteValue_OpSub64(v) | |
| case ssaop.OpTrunc64to16: | |
| return rewriteValue_OpTrunc64to16(v) | |
| case ssaop.OpTrunc64to32: | |
| return rewriteValue_OpTrunc64to32(v) | |
| case ssaop.OpTrunc64to8: | |
| return rewriteValue_OpTrunc64to8(v) | |
| case ssaop.OpXor64: | |
| return rewriteValue_OpXor64(v) | |
| case ssaop.OpZeroExt16to64: | |
| return rewriteValue_OpZeroExt16to64(v) | |
| case ssaop.OpZeroExt32to64: | |
| return rewriteValue_OpZeroExt32to64(v) | |
| case ssaop.OpZeroExt8to64: | |
| return rewriteValue_OpZeroExt8to64(v) | |
| } | |
| return false | |
| } | |
| func rewriteValue_OpAdd64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Add64 <t> x y) | |
| // result: (Last <t> x0: (Int64Lo x) x1: (Int64Hi x) y0: (Int64Lo y) y1: (Int64Hi y) add: (Add32carry x0 y0) (Int64Make (Add32withcarry <typ.UInt32> x1 y1 (Select1 <types.TypeFlags> add)) (Select0 <typ.UInt32> add))) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpLast) | |
| v.Type = t | |
| x0 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| x0.AddArg(x) | |
| x1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| x1.AddArg(x) | |
| y0 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| y0.AddArg(y) | |
| y1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| y1.AddArg(y) | |
| add := b.NewValue0(v.Pos, ssaop.OpAdd32carry, types.NewTuple(typ.UInt32, types.TypeFlags)) | |
| add.AddArg2(x0, y0) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Make, typ.UInt64) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpAdd32withcarry, typ.UInt32) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpSelect1, types.TypeFlags) | |
| v7.AddArg(add) | |
| v6.AddArg3(x1, y1, v7) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpSelect0, typ.UInt32) | |
| v8.AddArg(add) | |
| v5.AddArg2(v6, v8) | |
| v.AddArg6(x0, x1, y0, y1, add, v5) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpAnd64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (And64 x y) | |
| // result: (Int64Make (And32 <typ.UInt32> (Int64Hi x) (Int64Hi y)) (And32 <typ.UInt32> (Int64Lo x) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v0.AddArg2(v1, v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpAnd32, typ.UInt32) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v4.AddArg(x) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(y) | |
| v3.AddArg2(v4, v5) | |
| v.AddArg2(v0, v3) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpArg(v *ssa.Value) bool { | |
| b := v.Block | |
| config := b.Func.Config | |
| typ := &b.Func.Config.Types | |
| // match: (Arg {n} [off]) | |
| // cond: ssa.Is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.Pass.Name == "decompose builtin") | |
| // result: (Int64Make (Arg <typ.Int32> {n} [off+4]) (Arg <typ.UInt32> {n} [off])) | |
| for { | |
| off := ssa.AuxIntToInt32(v.AuxInt) | |
| n := ssa.AuxToSym(v.Aux) | |
| if !(ssa.Is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.Pass.Name == "decompose builtin")) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpArg, typ.Int32) | |
| v0.AuxInt = ssa.Int32ToAuxInt(off + 4) | |
| v0.Aux = ssa.SymToAux(n) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpArg, typ.UInt32) | |
| v1.AuxInt = ssa.Int32ToAuxInt(off) | |
| v1.Aux = ssa.SymToAux(n) | |
| v.AddArg2(v0, v1) | |
| return true | |
| } | |
| // match: (Arg {n} [off]) | |
| // cond: ssa.Is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(b.Func.Pass.Name == "decompose builtin") | |
| // result: (Int64Make (Arg <typ.UInt32> {n} [off+4]) (Arg <typ.UInt32> {n} [off])) | |
| for { | |
| off := ssa.AuxIntToInt32(v.AuxInt) | |
| n := ssa.AuxToSym(v.Aux) | |
| if !(ssa.Is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(b.Func.Pass.Name == "decompose builtin")) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpArg, typ.UInt32) | |
| v0.AuxInt = ssa.Int32ToAuxInt(off + 4) | |
| v0.Aux = ssa.SymToAux(n) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpArg, typ.UInt32) | |
| v1.AuxInt = ssa.Int32ToAuxInt(off) | |
| v1.Aux = ssa.SymToAux(n) | |
| v.AddArg2(v0, v1) | |
| return true | |
| } | |
| // match: (Arg {n} [off]) | |
| // cond: ssa.Is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(b.Func.Pass.Name == "decompose builtin") | |
| // result: (Int64Make (Arg <typ.Int32> {n} [off]) (Arg <typ.UInt32> {n} [off+4])) | |
| for { | |
| off := ssa.AuxIntToInt32(v.AuxInt) | |
| n := ssa.AuxToSym(v.Aux) | |
| if !(ssa.Is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(b.Func.Pass.Name == "decompose builtin")) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpArg, typ.Int32) | |
| v0.AuxInt = ssa.Int32ToAuxInt(off) | |
| v0.Aux = ssa.SymToAux(n) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpArg, typ.UInt32) | |
| v1.AuxInt = ssa.Int32ToAuxInt(off + 4) | |
| v1.Aux = ssa.SymToAux(n) | |
| v.AddArg2(v0, v1) | |
| return true | |
| } | |
| // match: (Arg {n} [off]) | |
| // cond: ssa.Is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(b.Func.Pass.Name == "decompose builtin") | |
| // result: (Int64Make (Arg <typ.UInt32> {n} [off]) (Arg <typ.UInt32> {n} [off+4])) | |
| for { | |
| off := ssa.AuxIntToInt32(v.AuxInt) | |
| n := ssa.AuxToSym(v.Aux) | |
| if !(ssa.Is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(b.Func.Pass.Name == "decompose builtin")) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpArg, typ.UInt32) | |
| v0.AuxInt = ssa.Int32ToAuxInt(off) | |
| v0.Aux = ssa.SymToAux(n) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpArg, typ.UInt32) | |
| v1.AuxInt = ssa.Int32ToAuxInt(off + 4) | |
| v1.Aux = ssa.SymToAux(n) | |
| v.AddArg2(v0, v1) | |
| return true | |
| } | |
| return false | |
| } | |
| func rewriteValue_OpAvg64u(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Avg64u <t> x y) | |
| // result: (Add64 (Rsh64Ux32 <t> (Sub64 <t> x y) (Const32 <typ.UInt32> [1])) y) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpAdd64) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh64Ux32, t) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub64, t) | |
| v1.AddArg2(x, y) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v2.AuxInt = ssa.Int32ToAuxInt(1) | |
| v0.AddArg2(v1, v2) | |
| v.AddArg2(v0, y) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpBitLen64(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (BitLen64 x) | |
| // result: (Add32 <typ.Int> (BitLen32 <typ.Int> (Int64Hi x)) (BitLen32 <typ.Int> (Or32 <typ.UInt32> (Int64Lo x) (Zeromask (Int64Hi x))))) | |
| for { | |
| x := v_0 | |
| v.Reset(ssaop.OpAdd32) | |
| v.Type = typ.Int | |
| v0 := b.NewValue0(v.Pos, ssaop.OpBitLen32, typ.Int) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v0.AddArg(v1) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpBitLen32, typ.Int) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v4.AddArg(x) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v5.AddArg(v1) | |
| v3.AddArg2(v4, v5) | |
| v2.AddArg(v3) | |
| v.AddArg2(v0, v2) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpBswap64(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Bswap64 x) | |
| // result: (Int64Make (Bswap32 <typ.UInt32> (Int64Lo x)) (Bswap32 <typ.UInt32> (Int64Hi x))) | |
| for { | |
| x := v_0 | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpBswap32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v1.AddArg(x) | |
| v0.AddArg(v1) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpBswap32, typ.UInt32) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v3.AddArg(x) | |
| v2.AddArg(v3) | |
| v.AddArg2(v0, v2) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpCom64(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Com64 x) | |
| // result: (Int64Make (Com32 <typ.UInt32> (Int64Hi x)) (Com32 <typ.UInt32> (Int64Lo x))) | |
| for { | |
| x := v_0 | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpCom32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v0.AddArg(v1) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpCom32, typ.UInt32) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v3.AddArg(x) | |
| v2.AddArg(v3) | |
| v.AddArg2(v0, v2) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpConst64(v *ssa.Value) bool { | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Const64 <t> [c]) | |
| // cond: t.IsSigned() | |
| // result: (Int64Make (Const32 <typ.Int32> [int32(c>>32)]) (Const32 <typ.UInt32> [int32(c)])) | |
| for { | |
| t := v.Type | |
| c := ssa.AuxIntToInt64(v.AuxInt) | |
| if !(t.IsSigned()) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32) | |
| v0.AuxInt = ssa.Int32ToAuxInt(int32(c >> 32)) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v1.AuxInt = ssa.Int32ToAuxInt(int32(c)) | |
| v.AddArg2(v0, v1) | |
| return true | |
| } | |
| // match: (Const64 <t> [c]) | |
| // cond: !t.IsSigned() | |
| // result: (Int64Make (Const32 <typ.UInt32> [int32(c>>32)]) (Const32 <typ.UInt32> [int32(c)])) | |
| for { | |
| t := v.Type | |
| c := ssa.AuxIntToInt64(v.AuxInt) | |
| if !(!t.IsSigned()) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v0.AuxInt = ssa.Int32ToAuxInt(int32(c >> 32)) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v1.AuxInt = ssa.Int32ToAuxInt(int32(c)) | |
| v.AddArg2(v0, v1) | |
| return true | |
| } | |
| return false | |
| } | |
| func rewriteValue_OpCtz64(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Ctz64 x) | |
| // result: (Add32 <typ.UInt32> (Ctz32 <typ.UInt32> (Int64Lo x)) (And32 <typ.UInt32> (Com32 <typ.UInt32> (Zeromask (Int64Lo x))) (Ctz32 <typ.UInt32> (Int64Hi x)))) | |
| for { | |
| x := v_0 | |
| v.Reset(ssaop.OpAdd32) | |
| v.Type = typ.UInt32 | |
| v0 := b.NewValue0(v.Pos, ssaop.OpCtz32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v1.AddArg(x) | |
| v0.AddArg(v1) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpAnd32, typ.UInt32) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpCom32, typ.UInt32) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v4.AddArg(v1) | |
| v3.AddArg(v4) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpCtz32, typ.UInt32) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v6.AddArg(x) | |
| v5.AddArg(v6) | |
| v2.AddArg2(v3, v5) | |
| v.AddArg2(v0, v2) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpEq64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Eq64 x y) | |
| // result: (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Eq32 (Int64Lo x) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpAndB) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq32, typ.Bool) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v0.AddArg2(v1, v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpEq32, typ.Bool) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v4.AddArg(x) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(y) | |
| v3.AddArg2(v4, v5) | |
| v.AddArg2(v0, v3) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpHmul64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Hmul64 x y) | |
| // result: (Last p: (Hmul64u <typ.UInt64> x y) xSign: (Int64Make xs:(Rsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [31])) xs) ySign: (Int64Make ys:(Rsh32x32 <typ.UInt32> (Int64Hi y) (Const32 <typ.UInt32> [31])) ys) (Sub64 <typ.Int64> (Sub64 <typ.Int64> p (And64 <typ.Int64> xSign y)) (And64 <typ.Int64> ySign x))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpLast) | |
| p := b.NewValue0(v.Pos, ssaop.OpHmul64u, typ.UInt64) | |
| p.AddArg2(x, y) | |
| xSign := b.NewValue0(v.Pos, ssaop.OpInt64Make, typ.UInt64) | |
| xs := b.NewValue0(v.Pos, ssaop.OpRsh32x32, typ.UInt32) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v3.AddArg(x) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v4.AuxInt = ssa.Int32ToAuxInt(31) | |
| xs.AddArg2(v3, v4) | |
| xSign.AddArg2(xs, xs) | |
| ySign := b.NewValue0(v.Pos, ssaop.OpInt64Make, typ.UInt64) | |
| ys := b.NewValue0(v.Pos, ssaop.OpRsh32x32, typ.UInt32) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v7.AddArg(y) | |
| ys.AddArg2(v7, v4) | |
| ySign.AddArg2(ys, ys) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpSub64, typ.Int64) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpSub64, typ.Int64) | |
| v10 := b.NewValue0(v.Pos, ssaop.OpAnd64, typ.Int64) | |
| v10.AddArg2(xSign, y) | |
| v9.AddArg2(p, v10) | |
| v11 := b.NewValue0(v.Pos, ssaop.OpAnd64, typ.Int64) | |
| v11.AddArg2(ySign, x) | |
| v8.AddArg2(v9, v11) | |
| v.AddArg4(p, xSign, ySign, v8) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpHmul64u(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Hmul64u x y) | |
| // result: (Select0 (Mul64uhilo x y)) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpSelect0) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul64uhilo, types.NewTuple(typ.UInt64, typ.UInt64)) | |
| v0.AddArg2(x, y) | |
| v.AddArg(v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpInt64Hi(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| // match: (Int64Hi (Int64Make hi _)) | |
| // result: hi | |
| for { | |
| if v_0.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| hi := v_0.Args[0] | |
| v.CopyOf(hi) | |
| return true | |
| } | |
| return false | |
| } | |
| func rewriteValue_OpInt64Lo(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| // match: (Int64Lo (Int64Make _ lo)) | |
| // result: lo | |
| for { | |
| if v_0.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_0.Args[1] | |
| v.CopyOf(lo) | |
| return true | |
| } | |
| return false | |
| } | |
| func rewriteValue_OpLast(v *ssa.Value) bool { | |
| // match: (Last ___) | |
| // result: v.Args[len(v.Args)-1] | |
| for { | |
| v.CopyOf(v.Args[len(v.Args)-1]) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpLeq64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Leq64 x y) | |
| // result: (OrB (Less32 (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Leq32U (Int64Lo x) (Int64Lo y)))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpOrB) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpLess32, typ.Bool) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v0.AddArg2(v1, v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpAndB, typ.Bool) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpEq32, typ.Bool) | |
| v4.AddArg2(v1, v2) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpLeq32U, typ.Bool) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v6.AddArg(x) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v7.AddArg(y) | |
| v5.AddArg2(v6, v7) | |
| v3.AddArg2(v4, v5) | |
| v.AddArg2(v0, v3) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpLeq64U(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Leq64U x y) | |
| // result: (OrB (Less32U (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Leq32U (Int64Lo x) (Int64Lo y)))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpOrB) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpLess32U, typ.Bool) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v0.AddArg2(v1, v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpAndB, typ.Bool) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpEq32, typ.Bool) | |
| v4.AddArg2(v1, v2) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpLeq32U, typ.Bool) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v6.AddArg(x) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v7.AddArg(y) | |
| v5.AddArg2(v6, v7) | |
| v3.AddArg2(v4, v5) | |
| v.AddArg2(v0, v3) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpLess64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Less64 x y) | |
| // result: (OrB (Less32 (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Less32U (Int64Lo x) (Int64Lo y)))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpOrB) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpLess32, typ.Bool) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v0.AddArg2(v1, v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpAndB, typ.Bool) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpEq32, typ.Bool) | |
| v4.AddArg2(v1, v2) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpLess32U, typ.Bool) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v6.AddArg(x) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v7.AddArg(y) | |
| v5.AddArg2(v6, v7) | |
| v3.AddArg2(v4, v5) | |
| v.AddArg2(v0, v3) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpLess64U(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Less64U x y) | |
| // result: (OrB (Less32U (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Less32U (Int64Lo x) (Int64Lo y)))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpOrB) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpLess32U, typ.Bool) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v0.AddArg2(v1, v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpAndB, typ.Bool) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpEq32, typ.Bool) | |
| v4.AddArg2(v1, v2) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpLess32U, typ.Bool) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v6.AddArg(x) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v7.AddArg(y) | |
| v5.AddArg2(v6, v7) | |
| v3.AddArg2(v4, v5) | |
| v.AddArg2(v0, v3) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpLoad(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| config := b.Func.Config | |
| typ := &b.Func.Config.Types | |
| // match: (Load <t> ptr mem) | |
| // cond: ssa.Is64BitInt(t) && !config.BigEndian && t.IsSigned() | |
| // result: (Int64Make (Load <typ.Int32> (OffPtr <typ.Int32Ptr> [4] ptr) mem) (Load <typ.UInt32> ptr mem)) | |
| for { | |
| t := v.Type | |
| ptr := v_0 | |
| mem := v_1 | |
| if !(ssa.Is64BitInt(t) && !config.BigEndian && t.IsSigned()) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.Int32Ptr) | |
| v1.AuxInt = ssa.Int64ToAuxInt(4) | |
| v1.AddArg(ptr) | |
| v0.AddArg2(v1, mem) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.UInt32) | |
| v2.AddArg2(ptr, mem) | |
| v.AddArg2(v0, v2) | |
| return true | |
| } | |
| // match: (Load <t> ptr mem) | |
| // cond: ssa.Is64BitInt(t) && !config.BigEndian && !t.IsSigned() | |
| // result: (Int64Make (Load <typ.UInt32> (OffPtr <typ.UInt32Ptr> [4] ptr) mem) (Load <typ.UInt32> ptr mem)) | |
| for { | |
| t := v.Type | |
| ptr := v_0 | |
| mem := v_1 | |
| if !(ssa.Is64BitInt(t) && !config.BigEndian && !t.IsSigned()) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.UInt32Ptr) | |
| v1.AuxInt = ssa.Int64ToAuxInt(4) | |
| v1.AddArg(ptr) | |
| v0.AddArg2(v1, mem) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.UInt32) | |
| v2.AddArg2(ptr, mem) | |
| v.AddArg2(v0, v2) | |
| return true | |
| } | |
| // match: (Load <t> ptr mem) | |
| // cond: ssa.Is64BitInt(t) && config.BigEndian && t.IsSigned() | |
| // result: (Int64Make (Load <typ.Int32> ptr mem) (Load <typ.UInt32> (OffPtr <typ.UInt32Ptr> [4] ptr) mem)) | |
| for { | |
| t := v.Type | |
| ptr := v_0 | |
| mem := v_1 | |
| if !(ssa.Is64BitInt(t) && config.BigEndian && t.IsSigned()) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32) | |
| v0.AddArg2(ptr, mem) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.UInt32Ptr) | |
| v2.AuxInt = ssa.Int64ToAuxInt(4) | |
| v2.AddArg(ptr) | |
| v1.AddArg2(v2, mem) | |
| v.AddArg2(v0, v1) | |
| return true | |
| } | |
| // match: (Load <t> ptr mem) | |
| // cond: ssa.Is64BitInt(t) && config.BigEndian && !t.IsSigned() | |
| // result: (Int64Make (Load <typ.UInt32> ptr mem) (Load <typ.UInt32> (OffPtr <typ.UInt32Ptr> [4] ptr) mem)) | |
| for { | |
| t := v.Type | |
| ptr := v_0 | |
| mem := v_1 | |
| if !(ssa.Is64BitInt(t) && config.BigEndian && !t.IsSigned()) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.UInt32) | |
| v0.AddArg2(ptr, mem) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.UInt32Ptr) | |
| v2.AuxInt = ssa.Int64ToAuxInt(4) | |
| v2.AddArg(ptr) | |
| v1.AddArg2(v2, mem) | |
| v.AddArg2(v0, v1) | |
| return true | |
| } | |
| return false | |
| } | |
| func rewriteValue_OpLsh16x64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Lsh16x64 _ (Int64Make (Const32 [c]) _)) | |
| // cond: c != 0 | |
| // result: (Const32 [0]) | |
| for { | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt32(v_1_0.AuxInt) | |
| if !(c != 0) { | |
| break | |
| } | |
| v.Reset(ssaop.OpConst32) | |
| v.AuxInt = ssa.Int32ToAuxInt(0) | |
| return true | |
| } | |
| // match: (Lsh16x64 [c] x (Int64Make (Const32 [0]) lo)) | |
| // result: (Lsh16x32 [c] x lo) | |
| for { | |
| c := ssa.AuxIntToBool(v.AuxInt) | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1_0.AuxInt) != 0 { | |
| break | |
| } | |
| v.Reset(ssaop.OpLsh16x32) | |
| v.AuxInt = ssa.BoolToAuxInt(c) | |
| v.AddArg2(x, lo) | |
| return true | |
| } | |
| // match: (Lsh16x64 x (Int64Make hi lo)) | |
| // cond: hi.Op != ssaop.OpConst32 | |
| // result: (Lsh16x32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| hi := v_1.Args[0] | |
| if !(hi.Op != ssaop.OpConst32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpLsh16x32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v1.AddArg(hi) | |
| v0.AddArg2(v1, lo) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| // match: (Lsh16x64 x y) | |
| // result: (Lsh16x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpLsh16x32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v1.AddArg(v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v3.AddArg(y) | |
| v0.AddArg2(v1, v3) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpLsh32x64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Lsh32x64 _ (Int64Make (Const32 [c]) _)) | |
| // cond: c != 0 | |
| // result: (Const32 [0]) | |
| for { | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt32(v_1_0.AuxInt) | |
| if !(c != 0) { | |
| break | |
| } | |
| v.Reset(ssaop.OpConst32) | |
| v.AuxInt = ssa.Int32ToAuxInt(0) | |
| return true | |
| } | |
| // match: (Lsh32x64 [c] x (Int64Make (Const32 [0]) lo)) | |
| // result: (Lsh32x32 [c] x lo) | |
| for { | |
| c := ssa.AuxIntToBool(v.AuxInt) | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1_0.AuxInt) != 0 { | |
| break | |
| } | |
| v.Reset(ssaop.OpLsh32x32) | |
| v.AuxInt = ssa.BoolToAuxInt(c) | |
| v.AddArg2(x, lo) | |
| return true | |
| } | |
| // match: (Lsh32x64 x (Int64Make hi lo)) | |
| // cond: hi.Op != ssaop.OpConst32 | |
| // result: (Lsh32x32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| hi := v_1.Args[0] | |
| if !(hi.Op != ssaop.OpConst32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpLsh32x32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v1.AddArg(hi) | |
| v0.AddArg2(v1, lo) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| // match: (Lsh32x64 x y) | |
| // result: (Lsh32x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpLsh32x32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v1.AddArg(v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v3.AddArg(y) | |
| v0.AddArg2(v1, v3) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpLsh64x16(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Lsh64x16 x s) | |
| // result: (Int64Make (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Lsh32x16 <typ.UInt32> (Int64Hi x) s) (Rsh32Ux16 <typ.UInt32> (Int64Lo x) (Sub16 <typ.UInt16> (Const16 <typ.UInt16> [32]) s))) (Lsh32x16 <typ.UInt32> (Int64Lo x) (Sub16 <typ.UInt16> s (Const16 <typ.UInt16> [32])))) (Lsh32x16 <typ.UInt32> (Int64Lo x) s)) | |
| for { | |
| x := v_0 | |
| s := v_1 | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpLsh32x16, typ.UInt32) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v3.AddArg(x) | |
| v2.AddArg2(v3, s) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux16, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(x) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpSub16, typ.UInt16) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpConst16, typ.UInt16) | |
| v7.AuxInt = ssa.Int16ToAuxInt(32) | |
| v6.AddArg2(v7, s) | |
| v4.AddArg2(v5, v6) | |
| v1.AddArg2(v2, v4) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpLsh32x16, typ.UInt32) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpSub16, typ.UInt16) | |
| v9.AddArg2(s, v7) | |
| v8.AddArg2(v5, v9) | |
| v0.AddArg2(v1, v8) | |
| v10 := b.NewValue0(v.Pos, ssaop.OpLsh32x16, typ.UInt32) | |
| v10.AddArg2(v5, s) | |
| v.AddArg2(v0, v10) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpLsh64x32(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Lsh64x32 x s) | |
| // result: (Int64Make (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) s) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Sub32 <typ.UInt32> (Const32 <typ.UInt32> [32]) s))) (Lsh32x32 <typ.UInt32> (Int64Lo x) (Sub32 <typ.UInt32> s (Const32 <typ.UInt32> [32])))) (Lsh32x32 <typ.UInt32> (Int64Lo x) s)) | |
| for { | |
| x := v_0 | |
| s := v_1 | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v3.AddArg(x) | |
| v2.AddArg2(v3, s) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(x) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpSub32, typ.UInt32) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v7.AuxInt = ssa.Int32ToAuxInt(32) | |
| v6.AddArg2(v7, s) | |
| v4.AddArg2(v5, v6) | |
| v1.AddArg2(v2, v4) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpSub32, typ.UInt32) | |
| v9.AddArg2(s, v7) | |
| v8.AddArg2(v5, v9) | |
| v0.AddArg2(v1, v8) | |
| v10 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v10.AddArg2(v5, s) | |
| v.AddArg2(v0, v10) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpLsh64x64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Lsh64x64 _ (Int64Make (Const32 [c]) _)) | |
| // cond: c != 0 | |
| // result: (Const64 [0]) | |
| for { | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt32(v_1_0.AuxInt) | |
| if !(c != 0) { | |
| break | |
| } | |
| v.Reset(ssaop.OpConst64) | |
| v.AuxInt = ssa.Int64ToAuxInt(0) | |
| return true | |
| } | |
| // match: (Lsh64x64 [c] x (Int64Make (Const32 [0]) lo)) | |
| // result: (Lsh64x32 [c] x lo) | |
| for { | |
| c := ssa.AuxIntToBool(v.AuxInt) | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1_0.AuxInt) != 0 { | |
| break | |
| } | |
| v.Reset(ssaop.OpLsh64x32) | |
| v.AuxInt = ssa.BoolToAuxInt(c) | |
| v.AddArg2(x, lo) | |
| return true | |
| } | |
| // match: (Lsh64x64 x (Int64Make hi lo)) | |
| // cond: hi.Op != ssaop.OpConst32 | |
| // result: (Lsh64x32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| hi := v_1.Args[0] | |
| if !(hi.Op != ssaop.OpConst32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpLsh64x32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v1.AddArg(hi) | |
| v0.AddArg2(v1, lo) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| // match: (Lsh64x64 x y) | |
| // result: (Lsh64x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpLsh64x32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v1.AddArg(v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v3.AddArg(y) | |
| v0.AddArg2(v1, v3) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpLsh64x8(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Lsh64x8 x s) | |
| // result: (Int64Make (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Lsh32x8 <typ.UInt32> (Int64Hi x) s) (Rsh32Ux8 <typ.UInt32> (Int64Lo x) (Sub8 <typ.UInt8> (Const8 <typ.UInt8> [32]) s))) (Lsh32x8 <typ.UInt32> (Int64Lo x) (Sub8 <typ.UInt8> s (Const8 <typ.UInt8> [32])))) (Lsh32x8 <typ.UInt32> (Int64Lo x) s)) | |
| for { | |
| x := v_0 | |
| s := v_1 | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpLsh32x8, typ.UInt32) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v3.AddArg(x) | |
| v2.AddArg2(v3, s) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux8, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(x) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpSub8, typ.UInt8) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpConst8, typ.UInt8) | |
| v7.AuxInt = ssa.Int8ToAuxInt(32) | |
| v6.AddArg2(v7, s) | |
| v4.AddArg2(v5, v6) | |
| v1.AddArg2(v2, v4) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpLsh32x8, typ.UInt32) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpSub8, typ.UInt8) | |
| v9.AddArg2(s, v7) | |
| v8.AddArg2(v5, v9) | |
| v0.AddArg2(v1, v8) | |
| v10 := b.NewValue0(v.Pos, ssaop.OpLsh32x8, typ.UInt32) | |
| v10.AddArg2(v5, s) | |
| v.AddArg2(v0, v10) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpLsh8x64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Lsh8x64 _ (Int64Make (Const32 [c]) _)) | |
| // cond: c != 0 | |
| // result: (Const32 [0]) | |
| for { | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt32(v_1_0.AuxInt) | |
| if !(c != 0) { | |
| break | |
| } | |
| v.Reset(ssaop.OpConst32) | |
| v.AuxInt = ssa.Int32ToAuxInt(0) | |
| return true | |
| } | |
| // match: (Lsh8x64 [c] x (Int64Make (Const32 [0]) lo)) | |
| // result: (Lsh8x32 [c] x lo) | |
| for { | |
| c := ssa.AuxIntToBool(v.AuxInt) | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1_0.AuxInt) != 0 { | |
| break | |
| } | |
| v.Reset(ssaop.OpLsh8x32) | |
| v.AuxInt = ssa.BoolToAuxInt(c) | |
| v.AddArg2(x, lo) | |
| return true | |
| } | |
| // match: (Lsh8x64 x (Int64Make hi lo)) | |
| // cond: hi.Op != ssaop.OpConst32 | |
| // result: (Lsh8x32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| hi := v_1.Args[0] | |
| if !(hi.Op != ssaop.OpConst32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpLsh8x32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v1.AddArg(hi) | |
| v0.AddArg2(v1, lo) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| // match: (Lsh8x64 x y) | |
| // result: (Lsh8x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpLsh8x32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v1.AddArg(v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v3.AddArg(y) | |
| v0.AddArg2(v1, v3) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpMul64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Mul64 <t> x y) | |
| // result: (Last <t> x0: (Int64Lo x) x1: (Int64Hi x) y0: (Int64Lo y) y1: (Int64Hi y) x0y0: (Mul32uhilo x0 y0) x0y0Hi: (Select0 <typ.UInt32> x0y0) x0y0Lo: (Select1 <typ.UInt32> x0y0) (Int64Make (Add32 <typ.UInt32> x0y0Hi (Add32 <typ.UInt32> (Mul32 <typ.UInt32> x0 y1) (Mul32 <typ.UInt32> x1 y0))) x0y0Lo)) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpLast) | |
| v.Type = t | |
| x0 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| x0.AddArg(x) | |
| x1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| x1.AddArg(x) | |
| y0 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| y0.AddArg(y) | |
| y1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| y1.AddArg(y) | |
| x0y0 := b.NewValue0(v.Pos, ssaop.OpMul32uhilo, types.NewTuple(typ.UInt32, typ.UInt32)) | |
| x0y0.AddArg2(x0, y0) | |
| x0y0Hi := b.NewValue0(v.Pos, ssaop.OpSelect0, typ.UInt32) | |
| x0y0Hi.AddArg(x0y0) | |
| x0y0Lo := b.NewValue0(v.Pos, ssaop.OpSelect1, typ.UInt32) | |
| x0y0Lo.AddArg(x0y0) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpInt64Make, typ.UInt64) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpAdd32, typ.UInt32) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpAdd32, typ.UInt32) | |
| v10 := b.NewValue0(v.Pos, ssaop.OpMul32, typ.UInt32) | |
| v10.AddArg2(x0, y1) | |
| v11 := b.NewValue0(v.Pos, ssaop.OpMul32, typ.UInt32) | |
| v11.AddArg2(x1, y0) | |
| v9.AddArg2(v10, v11) | |
| v8.AddArg2(x0y0Hi, v9) | |
| v7.AddArg2(v8, x0y0Lo) | |
| v.AddArgs(x0, x1, y0, y1, x0y0, x0y0Hi, x0y0Lo, v7) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpMul64uhilo(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Mul64uhilo <t> x y) | |
| // result: (Last <t> x0: (Int64Lo x) x1: (Int64Hi x) y0: (Int64Lo y) y1: (Int64Hi y) x0y0: (Mul32uhilo x0 y0) x0y1: (Mul32uhilo x0 y1) x1y0: (Mul32uhilo x1 y0) x1y1: (Mul32uhilo x1 y1) x0y0Hi: (Select0 <typ.UInt32> x0y0) x0y0Lo: (Select1 <typ.UInt32> x0y0) x0y1Hi: (Select0 <typ.UInt32> x0y1) x0y1Lo: (Select1 <typ.UInt32> x0y1) x1y0Hi: (Select0 <typ.UInt32> x1y0) x1y0Lo: (Select1 <typ.UInt32> x1y0) x1y1Hi: (Select0 <typ.UInt32> x1y1) x1y1Lo: (Select1 <typ.UInt32> x1y1) w1a: (Add32carry x0y0Hi x0y1Lo) w2a: (Add32carrywithcarry x0y1Hi x1y0Hi (Select1 <types.TypeFlags> w1a)) w3a: (Add32withcarry <typ.UInt32> x1y1Hi (Const32 <typ.UInt32> [0]) (Select1 <types.TypeFlags> w2a)) w1b: (Add32carry x1y0Lo (Select0 <typ.UInt32> w1a)) w2b: (Add32carrywithcarry x1y1Lo (Select0 <typ.UInt32> w2a) (Select1 <types.TypeFlags> w1b)) w3b: (Add32withcarry <typ.UInt32> w3a (Const32 <typ.UInt32> [0]) (Select1 <types.TypeFlags> w2b)) (MakeTuple <types.NewTuple(typ.UInt64,typ.UInt64)> (Int64Make w3b (Select0 <typ.UInt32> w2b)) (Int64Make (Select0 <typ.UInt32> w1b) x0y0Lo))) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpLast) | |
| v.Type = t | |
| x0 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| x0.AddArg(x) | |
| x1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| x1.AddArg(x) | |
| y0 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| y0.AddArg(y) | |
| y1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| y1.AddArg(y) | |
| x0y0 := b.NewValue0(v.Pos, ssaop.OpMul32uhilo, types.NewTuple(typ.UInt32, typ.UInt32)) | |
| x0y0.AddArg2(x0, y0) | |
| x0y1 := b.NewValue0(v.Pos, ssaop.OpMul32uhilo, types.NewTuple(typ.UInt32, typ.UInt32)) | |
| x0y1.AddArg2(x0, y1) | |
| x1y0 := b.NewValue0(v.Pos, ssaop.OpMul32uhilo, types.NewTuple(typ.UInt32, typ.UInt32)) | |
| x1y0.AddArg2(x1, y0) | |
| x1y1 := b.NewValue0(v.Pos, ssaop.OpMul32uhilo, types.NewTuple(typ.UInt32, typ.UInt32)) | |
| x1y1.AddArg2(x1, y1) | |
| x0y0Hi := b.NewValue0(v.Pos, ssaop.OpSelect0, typ.UInt32) | |
| x0y0Hi.AddArg(x0y0) | |
| x0y0Lo := b.NewValue0(v.Pos, ssaop.OpSelect1, typ.UInt32) | |
| x0y0Lo.AddArg(x0y0) | |
| x0y1Hi := b.NewValue0(v.Pos, ssaop.OpSelect0, typ.UInt32) | |
| x0y1Hi.AddArg(x0y1) | |
| x0y1Lo := b.NewValue0(v.Pos, ssaop.OpSelect1, typ.UInt32) | |
| x0y1Lo.AddArg(x0y1) | |
| x1y0Hi := b.NewValue0(v.Pos, ssaop.OpSelect0, typ.UInt32) | |
| x1y0Hi.AddArg(x1y0) | |
| x1y0Lo := b.NewValue0(v.Pos, ssaop.OpSelect1, typ.UInt32) | |
| x1y0Lo.AddArg(x1y0) | |
| x1y1Hi := b.NewValue0(v.Pos, ssaop.OpSelect0, typ.UInt32) | |
| x1y1Hi.AddArg(x1y1) | |
| x1y1Lo := b.NewValue0(v.Pos, ssaop.OpSelect1, typ.UInt32) | |
| x1y1Lo.AddArg(x1y1) | |
| w1a := b.NewValue0(v.Pos, ssaop.OpAdd32carry, types.NewTuple(typ.UInt32, types.TypeFlags)) | |
| w1a.AddArg2(x0y0Hi, x0y1Lo) | |
| w2a := b.NewValue0(v.Pos, ssaop.OpAdd32carrywithcarry, types.NewTuple(typ.UInt32, types.TypeFlags)) | |
| v18 := b.NewValue0(v.Pos, ssaop.OpSelect1, types.TypeFlags) | |
| v18.AddArg(w1a) | |
| w2a.AddArg3(x0y1Hi, x1y0Hi, v18) | |
| w3a := b.NewValue0(v.Pos, ssaop.OpAdd32withcarry, typ.UInt32) | |
| v20 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v20.AuxInt = ssa.Int32ToAuxInt(0) | |
| v21 := b.NewValue0(v.Pos, ssaop.OpSelect1, types.TypeFlags) | |
| v21.AddArg(w2a) | |
| w3a.AddArg3(x1y1Hi, v20, v21) | |
| w1b := b.NewValue0(v.Pos, ssaop.OpAdd32carry, types.NewTuple(typ.UInt32, types.TypeFlags)) | |
| v23 := b.NewValue0(v.Pos, ssaop.OpSelect0, typ.UInt32) | |
| v23.AddArg(w1a) | |
| w1b.AddArg2(x1y0Lo, v23) | |
| w2b := b.NewValue0(v.Pos, ssaop.OpAdd32carrywithcarry, types.NewTuple(typ.UInt32, types.TypeFlags)) | |
| v25 := b.NewValue0(v.Pos, ssaop.OpSelect0, typ.UInt32) | |
| v25.AddArg(w2a) | |
| v26 := b.NewValue0(v.Pos, ssaop.OpSelect1, types.TypeFlags) | |
| v26.AddArg(w1b) | |
| w2b.AddArg3(x1y1Lo, v25, v26) | |
| w3b := b.NewValue0(v.Pos, ssaop.OpAdd32withcarry, typ.UInt32) | |
| v28 := b.NewValue0(v.Pos, ssaop.OpSelect1, types.TypeFlags) | |
| v28.AddArg(w2b) | |
| w3b.AddArg3(w3a, v20, v28) | |
| v29 := b.NewValue0(v.Pos, ssaop.OpMakeTuple, types.NewTuple(typ.UInt64, typ.UInt64)) | |
| v30 := b.NewValue0(v.Pos, ssaop.OpInt64Make, typ.UInt64) | |
| v31 := b.NewValue0(v.Pos, ssaop.OpSelect0, typ.UInt32) | |
| v31.AddArg(w2b) | |
| v30.AddArg2(w3b, v31) | |
| v32 := b.NewValue0(v.Pos, ssaop.OpInt64Make, typ.UInt64) | |
| v33 := b.NewValue0(v.Pos, ssaop.OpSelect0, typ.UInt32) | |
| v33.AddArg(w1b) | |
| v32.AddArg2(v33, x0y0Lo) | |
| v29.AddArg2(v30, v32) | |
| v.AddArgs(x0, x1, y0, y1, x0y0, x0y1, x1y0, x1y1, x0y0Hi, x0y0Lo, x0y1Hi, x0y1Lo, x1y0Hi, x1y0Lo, x1y1Hi, x1y1Lo, w1a, w2a, w3a, w1b, w2b, w3b, v29) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpNeg64(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| // match: (Neg64 <t> x) | |
| // result: (Sub64 (Const64 <t> [0]) x) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| v.Reset(ssaop.OpSub64) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) | |
| v0.AuxInt = ssa.Int64ToAuxInt(0) | |
| v.AddArg2(v0, x) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpNeq64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Neq64 x y) | |
| // result: (OrB (Neq32 (Int64Hi x) (Int64Hi y)) (Neq32 (Int64Lo x) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpOrB) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeq32, typ.Bool) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v0.AddArg2(v1, v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpNeq32, typ.Bool) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v4.AddArg(x) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(y) | |
| v3.AddArg2(v4, v5) | |
| v.AddArg2(v0, v3) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpOr32(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Or32 <typ.UInt32> (Zeromask (Const32 [c])) y) | |
| // cond: c == 0 | |
| // result: y | |
| for { | |
| if v.Type != typ.UInt32 { | |
| break | |
| } | |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { | |
| if v_0.Op != ssaop.OpZeromask { | |
| continue | |
| } | |
| v_0_0 := v_0.Args[0] | |
| if v_0_0.Op != ssaop.OpConst32 { | |
| continue | |
| } | |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) | |
| y := v_1 | |
| if !(c == 0) { | |
| continue | |
| } | |
| v.CopyOf(y) | |
| return true | |
| } | |
| break | |
| } | |
| // match: (Or32 <typ.UInt32> (Zeromask (Const32 [c])) y) | |
| // cond: c != 0 | |
| // result: (Const32 <typ.UInt32> [-1]) | |
| for { | |
| if v.Type != typ.UInt32 { | |
| break | |
| } | |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { | |
| if v_0.Op != ssaop.OpZeromask { | |
| continue | |
| } | |
| v_0_0 := v_0.Args[0] | |
| if v_0_0.Op != ssaop.OpConst32 { | |
| continue | |
| } | |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) | |
| if !(c != 0) { | |
| continue | |
| } | |
| v.Reset(ssaop.OpConst32) | |
| v.Type = typ.UInt32 | |
| v.AuxInt = ssa.Int32ToAuxInt(-1) | |
| return true | |
| } | |
| break | |
| } | |
| return false | |
| } | |
| func rewriteValue_OpOr64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Or64 x y) | |
| // result: (Int64Make (Or32 <typ.UInt32> (Int64Hi x) (Int64Hi y)) (Or32 <typ.UInt32> (Int64Lo x) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v0.AddArg2(v1, v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v4.AddArg(x) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(y) | |
| v3.AddArg2(v4, v5) | |
| v.AddArg2(v0, v3) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpRotateLeft16(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| // match: (RotateLeft16 x (Int64Make hi lo)) | |
| // result: (RotateLeft16 x lo) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| v.Reset(ssaop.OpRotateLeft16) | |
| v.AddArg2(x, lo) | |
| return true | |
| } | |
| return false | |
| } | |
| func rewriteValue_OpRotateLeft32(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| // match: (RotateLeft32 x (Int64Make hi lo)) | |
| // result: (RotateLeft32 x lo) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| v.Reset(ssaop.OpRotateLeft32) | |
| v.AddArg2(x, lo) | |
| return true | |
| } | |
| return false | |
| } | |
| func rewriteValue_OpRotateLeft64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (RotateLeft64 x (Int64Make hi lo)) | |
| // result: (RotateLeft64 x lo) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| v.Reset(ssaop.OpRotateLeft64) | |
| v.AddArg2(x, lo) | |
| return true | |
| } | |
| // match: (RotateLeft64 <t> x (Const64 [c])) | |
| // cond: c&63 == 0 | |
| // result: x | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpConst64 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt64(v_1.AuxInt) | |
| if !(c&63 == 0) { | |
| break | |
| } | |
| v.CopyOf(x) | |
| return true | |
| } | |
| // match: (RotateLeft64 <t> x (Const32 [c])) | |
| // cond: c&63 == 0 | |
| // result: x | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpConst32 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt32(v_1.AuxInt) | |
| if !(c&63 == 0) { | |
| break | |
| } | |
| v.CopyOf(x) | |
| return true | |
| } | |
| // match: (RotateLeft64 <t> x (Const16 [c])) | |
| // cond: c&63 == 0 | |
| // result: x | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpConst16 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt16(v_1.AuxInt) | |
| if !(c&63 == 0) { | |
| break | |
| } | |
| v.CopyOf(x) | |
| return true | |
| } | |
| // match: (RotateLeft64 <t> x (Const8 [c])) | |
| // cond: c&63 == 0 | |
| // result: x | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpConst8 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt8(v_1.AuxInt) | |
| if !(c&63 == 0) { | |
| break | |
| } | |
| v.CopyOf(x) | |
| return true | |
| } | |
| // match: (RotateLeft64 <t> x (Const64 [c])) | |
| // cond: c&63 == 32 | |
| // result: (Int64Make <t> (Int64Lo x) (Int64Hi x)) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| if v_1.Op != ssaop.OpConst64 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt64(v_1.AuxInt) | |
| if !(c&63 == 32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v.Type = t | |
| v0 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v0.AddArg(x) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v.AddArg2(v0, v1) | |
| return true | |
| } | |
| // match: (RotateLeft64 <t> x (Const32 [c])) | |
| // cond: c&63 == 32 | |
| // result: (Int64Make <t> (Int64Lo x) (Int64Hi x)) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| if v_1.Op != ssaop.OpConst32 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt32(v_1.AuxInt) | |
| if !(c&63 == 32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v.Type = t | |
| v0 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v0.AddArg(x) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v.AddArg2(v0, v1) | |
| return true | |
| } | |
| // match: (RotateLeft64 <t> x (Const16 [c])) | |
| // cond: c&63 == 32 | |
| // result: (Int64Make <t> (Int64Lo x) (Int64Hi x)) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| if v_1.Op != ssaop.OpConst16 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt16(v_1.AuxInt) | |
| if !(c&63 == 32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v.Type = t | |
| v0 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v0.AddArg(x) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v.AddArg2(v0, v1) | |
| return true | |
| } | |
| // match: (RotateLeft64 <t> x (Const8 [c])) | |
| // cond: c&63 == 32 | |
| // result: (Int64Make <t> (Int64Lo x) (Int64Hi x)) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| if v_1.Op != ssaop.OpConst8 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt8(v_1.AuxInt) | |
| if !(c&63 == 32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v.Type = t | |
| v0 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v0.AddArg(x) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v.AddArg2(v0, v1) | |
| return true | |
| } | |
| // match: (RotateLeft64 <t> x (Const64 [c])) | |
| // cond: 0 < c&63 && c&63 < 32 | |
| // result: (Int64Make <t> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)]))) (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)])))) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| if v_1.Op != ssaop.OpConst64 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt64(v_1.AuxInt) | |
| if !(0 < c&63 && c&63 < 32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v.Type = t | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(x) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v3.AuxInt = ssa.Int32ToAuxInt(int32(c & 31)) | |
| v1.AddArg2(v2, v3) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(x) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v6.AuxInt = ssa.Int32ToAuxInt(int32(32 - c&31)) | |
| v4.AddArg2(v5, v6) | |
| v0.AddArg2(v1, v4) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v8.AddArg2(v5, v3) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v9.AddArg2(v2, v6) | |
| v7.AddArg2(v8, v9) | |
| v.AddArg2(v0, v7) | |
| return true | |
| } | |
| // match: (RotateLeft64 <t> x (Const32 [c])) | |
| // cond: 0 < c&63 && c&63 < 32 | |
| // result: (Int64Make <t> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)]))) (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)])))) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| if v_1.Op != ssaop.OpConst32 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt32(v_1.AuxInt) | |
| if !(0 < c&63 && c&63 < 32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v.Type = t | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(x) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v3.AuxInt = ssa.Int32ToAuxInt(int32(c & 31)) | |
| v1.AddArg2(v2, v3) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(x) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v6.AuxInt = ssa.Int32ToAuxInt(int32(32 - c&31)) | |
| v4.AddArg2(v5, v6) | |
| v0.AddArg2(v1, v4) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v8.AddArg2(v5, v3) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v9.AddArg2(v2, v6) | |
| v7.AddArg2(v8, v9) | |
| v.AddArg2(v0, v7) | |
| return true | |
| } | |
| // match: (RotateLeft64 <t> x (Const16 [c])) | |
| // cond: 0 < c&63 && c&63 < 32 | |
| // result: (Int64Make <t> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)]))) (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)])))) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| if v_1.Op != ssaop.OpConst16 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt16(v_1.AuxInt) | |
| if !(0 < c&63 && c&63 < 32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v.Type = t | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(x) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v3.AuxInt = ssa.Int32ToAuxInt(int32(c & 31)) | |
| v1.AddArg2(v2, v3) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(x) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v6.AuxInt = ssa.Int32ToAuxInt(int32(32 - c&31)) | |
| v4.AddArg2(v5, v6) | |
| v0.AddArg2(v1, v4) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v8.AddArg2(v5, v3) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v9.AddArg2(v2, v6) | |
| v7.AddArg2(v8, v9) | |
| v.AddArg2(v0, v7) | |
| return true | |
| } | |
| // match: (RotateLeft64 <t> x (Const8 [c])) | |
| // cond: 0 < c&63 && c&63 < 32 | |
| // result: (Int64Make <t> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)]))) (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)])))) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| if v_1.Op != ssaop.OpConst8 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt8(v_1.AuxInt) | |
| if !(0 < c&63 && c&63 < 32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v.Type = t | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(x) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v3.AuxInt = ssa.Int32ToAuxInt(int32(c & 31)) | |
| v1.AddArg2(v2, v3) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(x) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v6.AuxInt = ssa.Int32ToAuxInt(int32(32 - c&31)) | |
| v4.AddArg2(v5, v6) | |
| v0.AddArg2(v1, v4) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v8.AddArg2(v5, v3) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v9.AddArg2(v2, v6) | |
| v7.AddArg2(v8, v9) | |
| v.AddArg2(v0, v7) | |
| return true | |
| } | |
| // match: (RotateLeft64 <t> x (Const64 [c])) | |
| // cond: 32 < c&63 && c&63 < 64 | |
| // result: (Int64Make <t> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)]))) (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)])))) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| if v_1.Op != ssaop.OpConst64 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt64(v_1.AuxInt) | |
| if !(32 < c&63 && c&63 < 64) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v.Type = t | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v2.AddArg(x) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v3.AuxInt = ssa.Int32ToAuxInt(int32(c & 31)) | |
| v1.AddArg2(v2, v3) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v5.AddArg(x) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v6.AuxInt = ssa.Int32ToAuxInt(int32(32 - c&31)) | |
| v4.AddArg2(v5, v6) | |
| v0.AddArg2(v1, v4) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v8.AddArg2(v5, v3) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v9.AddArg2(v2, v6) | |
| v7.AddArg2(v8, v9) | |
| v.AddArg2(v0, v7) | |
| return true | |
| } | |
| // match: (RotateLeft64 <t> x (Const32 [c])) | |
| // cond: 32 < c&63 && c&63 < 64 | |
| // result: (Int64Make <t> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)]))) (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)])))) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| if v_1.Op != ssaop.OpConst32 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt32(v_1.AuxInt) | |
| if !(32 < c&63 && c&63 < 64) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v.Type = t | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v2.AddArg(x) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v3.AuxInt = ssa.Int32ToAuxInt(int32(c & 31)) | |
| v1.AddArg2(v2, v3) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v5.AddArg(x) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v6.AuxInt = ssa.Int32ToAuxInt(int32(32 - c&31)) | |
| v4.AddArg2(v5, v6) | |
| v0.AddArg2(v1, v4) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v8.AddArg2(v5, v3) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v9.AddArg2(v2, v6) | |
| v7.AddArg2(v8, v9) | |
| v.AddArg2(v0, v7) | |
| return true | |
| } | |
| // match: (RotateLeft64 <t> x (Const16 [c])) | |
| // cond: 32 < c&63 && c&63 < 64 | |
| // result: (Int64Make <t> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)]))) (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)])))) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| if v_1.Op != ssaop.OpConst16 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt16(v_1.AuxInt) | |
| if !(32 < c&63 && c&63 < 64) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v.Type = t | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v2.AddArg(x) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v3.AuxInt = ssa.Int32ToAuxInt(int32(c & 31)) | |
| v1.AddArg2(v2, v3) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v5.AddArg(x) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v6.AuxInt = ssa.Int32ToAuxInt(int32(32 - c&31)) | |
| v4.AddArg2(v5, v6) | |
| v0.AddArg2(v1, v4) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v8.AddArg2(v5, v3) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v9.AddArg2(v2, v6) | |
| v7.AddArg2(v8, v9) | |
| v.AddArg2(v0, v7) | |
| return true | |
| } | |
| // match: (RotateLeft64 <t> x (Const8 [c])) | |
| // cond: 32 < c&63 && c&63 < 64 | |
| // result: (Int64Make <t> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)]))) (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)])) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)])))) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| if v_1.Op != ssaop.OpConst8 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt8(v_1.AuxInt) | |
| if !(32 < c&63 && c&63 < 64) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v.Type = t | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v2.AddArg(x) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v3.AuxInt = ssa.Int32ToAuxInt(int32(c & 31)) | |
| v1.AddArg2(v2, v3) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v5.AddArg(x) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v6.AuxInt = ssa.Int32ToAuxInt(int32(32 - c&31)) | |
| v4.AddArg2(v5, v6) | |
| v0.AddArg2(v1, v4) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v8.AddArg2(v5, v3) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v9.AddArg2(v2, v6) | |
| v7.AddArg2(v8, v9) | |
| v.AddArg2(v0, v7) | |
| return true | |
| } | |
| return false | |
| } | |
| func rewriteValue_OpRotateLeft8(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| // match: (RotateLeft8 x (Int64Make hi lo)) | |
| // result: (RotateLeft8 x lo) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| v.Reset(ssaop.OpRotateLeft8) | |
| v.AddArg2(x, lo) | |
| return true | |
| } | |
| return false | |
| } | |
| func rewriteValue_OpRsh16Ux64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Rsh16Ux64 _ (Int64Make (Const32 [c]) _)) | |
| // cond: c != 0 | |
| // result: (Const32 [0]) | |
| for { | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt32(v_1_0.AuxInt) | |
| if !(c != 0) { | |
| break | |
| } | |
| v.Reset(ssaop.OpConst32) | |
| v.AuxInt = ssa.Int32ToAuxInt(0) | |
| return true | |
| } | |
| // match: (Rsh16Ux64 [c] x (Int64Make (Const32 [0]) lo)) | |
| // result: (Rsh16Ux32 [c] x lo) | |
| for { | |
| c := ssa.AuxIntToBool(v.AuxInt) | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1_0.AuxInt) != 0 { | |
| break | |
| } | |
| v.Reset(ssaop.OpRsh16Ux32) | |
| v.AuxInt = ssa.BoolToAuxInt(c) | |
| v.AddArg2(x, lo) | |
| return true | |
| } | |
| // match: (Rsh16Ux64 x (Int64Make hi lo)) | |
| // cond: hi.Op != ssaop.OpConst32 | |
| // result: (Rsh16Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| hi := v_1.Args[0] | |
| if !(hi.Op != ssaop.OpConst32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpRsh16Ux32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v1.AddArg(hi) | |
| v0.AddArg2(v1, lo) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| // match: (Rsh16Ux64 x y) | |
| // result: (Rsh16Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpRsh16Ux32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v1.AddArg(v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v3.AddArg(y) | |
| v0.AddArg2(v1, v3) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpRsh16x64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Rsh16x64 x (Int64Make (Const32 [c]) _)) | |
| // cond: c != 0 | |
| // result: (Signmask (SignExt16to32 x)) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt32(v_1_0.AuxInt) | |
| if !(c != 0) { | |
| break | |
| } | |
| v.Reset(ssaop.OpSignmask) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpSignExt16to32, typ.Int32) | |
| v0.AddArg(x) | |
| v.AddArg(v0) | |
| return true | |
| } | |
| // match: (Rsh16x64 [c] x (Int64Make (Const32 [0]) lo)) | |
| // result: (Rsh16x32 [c] x lo) | |
| for { | |
| c := ssa.AuxIntToBool(v.AuxInt) | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1_0.AuxInt) != 0 { | |
| break | |
| } | |
| v.Reset(ssaop.OpRsh16x32) | |
| v.AuxInt = ssa.BoolToAuxInt(c) | |
| v.AddArg2(x, lo) | |
| return true | |
| } | |
| // match: (Rsh16x64 x (Int64Make hi lo)) | |
| // cond: hi.Op != ssaop.OpConst32 | |
| // result: (Rsh16x32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| hi := v_1.Args[0] | |
| if !(hi.Op != ssaop.OpConst32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpRsh16x32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v1.AddArg(hi) | |
| v0.AddArg2(v1, lo) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| // match: (Rsh16x64 x y) | |
| // result: (Rsh16x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpRsh16x32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v1.AddArg(v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v3.AddArg(y) | |
| v0.AddArg2(v1, v3) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpRsh32Ux64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Rsh32Ux64 _ (Int64Make (Const32 [c]) _)) | |
| // cond: c != 0 | |
| // result: (Const32 [0]) | |
| for { | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt32(v_1_0.AuxInt) | |
| if !(c != 0) { | |
| break | |
| } | |
| v.Reset(ssaop.OpConst32) | |
| v.AuxInt = ssa.Int32ToAuxInt(0) | |
| return true | |
| } | |
| // match: (Rsh32Ux64 [c] x (Int64Make (Const32 [0]) lo)) | |
| // result: (Rsh32Ux32 [c] x lo) | |
| for { | |
| c := ssa.AuxIntToBool(v.AuxInt) | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1_0.AuxInt) != 0 { | |
| break | |
| } | |
| v.Reset(ssaop.OpRsh32Ux32) | |
| v.AuxInt = ssa.BoolToAuxInt(c) | |
| v.AddArg2(x, lo) | |
| return true | |
| } | |
| // match: (Rsh32Ux64 x (Int64Make hi lo)) | |
| // cond: hi.Op != ssaop.OpConst32 | |
| // result: (Rsh32Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| hi := v_1.Args[0] | |
| if !(hi.Op != ssaop.OpConst32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpRsh32Ux32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v1.AddArg(hi) | |
| v0.AddArg2(v1, lo) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| // match: (Rsh32Ux64 x y) | |
| // result: (Rsh32Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpRsh32Ux32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v1.AddArg(v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v3.AddArg(y) | |
| v0.AddArg2(v1, v3) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpRsh32x64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Rsh32x64 x (Int64Make (Const32 [c]) _)) | |
| // cond: c != 0 | |
| // result: (Signmask x) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt32(v_1_0.AuxInt) | |
| if !(c != 0) { | |
| break | |
| } | |
| v.Reset(ssaop.OpSignmask) | |
| v.AddArg(x) | |
| return true | |
| } | |
| // match: (Rsh32x64 [c] x (Int64Make (Const32 [0]) lo)) | |
| // result: (Rsh32x32 [c] x lo) | |
| for { | |
| c := ssa.AuxIntToBool(v.AuxInt) | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1_0.AuxInt) != 0 { | |
| break | |
| } | |
| v.Reset(ssaop.OpRsh32x32) | |
| v.AuxInt = ssa.BoolToAuxInt(c) | |
| v.AddArg2(x, lo) | |
| return true | |
| } | |
| // match: (Rsh32x64 x (Int64Make hi lo)) | |
| // cond: hi.Op != ssaop.OpConst32 | |
| // result: (Rsh32x32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| hi := v_1.Args[0] | |
| if !(hi.Op != ssaop.OpConst32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpRsh32x32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v1.AddArg(hi) | |
| v0.AddArg2(v1, lo) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| // match: (Rsh32x64 x y) | |
| // result: (Rsh32x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpRsh32x32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v1.AddArg(v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v3.AddArg(y) | |
| v0.AddArg2(v1, v3) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpRsh64Ux16(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Rsh64Ux16 x s) | |
| // result: (Int64Make (Rsh32Ux16 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux16 <typ.UInt32> (Int64Lo x) s) (Lsh32x16 <typ.UInt32> (Int64Hi x) (Sub16 <typ.UInt16> (Const16 <typ.UInt16> [32]) s))) (Rsh32Ux16 <typ.UInt32> (Int64Hi x) (Sub16 <typ.UInt16> s (Const16 <typ.UInt16> [32]))))) | |
| for { | |
| x := v_0 | |
| s := v_1 | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux16, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v0.AddArg2(v1, s) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux16, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(x) | |
| v4.AddArg2(v5, s) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpLsh32x16, typ.UInt32) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpSub16, typ.UInt16) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpConst16, typ.UInt16) | |
| v8.AuxInt = ssa.Int16ToAuxInt(32) | |
| v7.AddArg2(v8, s) | |
| v6.AddArg2(v1, v7) | |
| v3.AddArg2(v4, v6) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux16, typ.UInt32) | |
| v10 := b.NewValue0(v.Pos, ssaop.OpSub16, typ.UInt16) | |
| v10.AddArg2(s, v8) | |
| v9.AddArg2(v1, v10) | |
| v2.AddArg2(v3, v9) | |
| v.AddArg2(v0, v2) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpRsh64Ux32(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Rsh64Ux32 x s) | |
| // result: (Int64Make (Rsh32Ux32 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux32 <typ.UInt32> (Int64Lo x) s) (Lsh32x32 <typ.UInt32> (Int64Hi x) (Sub32 <typ.UInt32> (Const32 <typ.UInt32> [32]) s))) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Sub32 <typ.UInt32> s (Const32 <typ.UInt32> [32]))))) | |
| for { | |
| x := v_0 | |
| s := v_1 | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v0.AddArg2(v1, s) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(x) | |
| v4.AddArg2(v5, s) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpSub32, typ.UInt32) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v8.AuxInt = ssa.Int32ToAuxInt(32) | |
| v7.AddArg2(v8, s) | |
| v6.AddArg2(v1, v7) | |
| v3.AddArg2(v4, v6) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v10 := b.NewValue0(v.Pos, ssaop.OpSub32, typ.UInt32) | |
| v10.AddArg2(s, v8) | |
| v9.AddArg2(v1, v10) | |
| v2.AddArg2(v3, v9) | |
| v.AddArg2(v0, v2) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpRsh64Ux64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Rsh64Ux64 _ (Int64Make (Const32 [c]) _)) | |
| // cond: c != 0 | |
| // result: (Const64 [0]) | |
| for { | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt32(v_1_0.AuxInt) | |
| if !(c != 0) { | |
| break | |
| } | |
| v.Reset(ssaop.OpConst64) | |
| v.AuxInt = ssa.Int64ToAuxInt(0) | |
| return true | |
| } | |
| // match: (Rsh64Ux64 [c] x (Int64Make (Const32 [0]) lo)) | |
| // result: (Rsh64Ux32 [c] x lo) | |
| for { | |
| c := ssa.AuxIntToBool(v.AuxInt) | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1_0.AuxInt) != 0 { | |
| break | |
| } | |
| v.Reset(ssaop.OpRsh64Ux32) | |
| v.AuxInt = ssa.BoolToAuxInt(c) | |
| v.AddArg2(x, lo) | |
| return true | |
| } | |
| // match: (Rsh64Ux64 x (Int64Make hi lo)) | |
| // cond: hi.Op != ssaop.OpConst32 | |
| // result: (Rsh64Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| hi := v_1.Args[0] | |
| if !(hi.Op != ssaop.OpConst32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpRsh64Ux32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v1.AddArg(hi) | |
| v0.AddArg2(v1, lo) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| // match: (Rsh64Ux64 x y) | |
| // result: (Rsh64Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpRsh64Ux32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v1.AddArg(v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v3.AddArg(y) | |
| v0.AddArg2(v1, v3) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpRsh64Ux8(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Rsh64Ux8 x s) | |
| // result: (Int64Make (Rsh32Ux8 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux8 <typ.UInt32> (Int64Lo x) s) (Lsh32x8 <typ.UInt32> (Int64Hi x) (Sub8 <typ.UInt8> (Const8 <typ.UInt8> [32]) s))) (Rsh32Ux8 <typ.UInt32> (Int64Hi x) (Sub8 <typ.UInt8> s (Const8 <typ.UInt8> [32]))))) | |
| for { | |
| x := v_0 | |
| s := v_1 | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux8, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v0.AddArg2(v1, s) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux8, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(x) | |
| v4.AddArg2(v5, s) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpLsh32x8, typ.UInt32) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpSub8, typ.UInt8) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpConst8, typ.UInt8) | |
| v8.AuxInt = ssa.Int8ToAuxInt(32) | |
| v7.AddArg2(v8, s) | |
| v6.AddArg2(v1, v7) | |
| v3.AddArg2(v4, v6) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux8, typ.UInt32) | |
| v10 := b.NewValue0(v.Pos, ssaop.OpSub8, typ.UInt8) | |
| v10.AddArg2(s, v8) | |
| v9.AddArg2(v1, v10) | |
| v2.AddArg2(v3, v9) | |
| v.AddArg2(v0, v2) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpRsh64x16(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Rsh64x16 x s) | |
| // result: (Int64Make (Rsh32x16 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux16 <typ.UInt32> (Int64Lo x) s) (Lsh32x16 <typ.UInt32> (Int64Hi x) (Sub16 <typ.UInt16> (Const16 <typ.UInt16> [32]) s))) (And32 <typ.UInt32> (Rsh32x16 <typ.UInt32> (Int64Hi x) (Sub16 <typ.UInt16> s (Const16 <typ.UInt16> [32]))) (Zeromask (ZeroExt16to32 (Rsh16Ux32 <typ.UInt16> s (Const32 <typ.UInt32> [5]))))))) | |
| for { | |
| x := v_0 | |
| s := v_1 | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh32x16, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v0.AddArg2(v1, s) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux16, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(x) | |
| v4.AddArg2(v5, s) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpLsh32x16, typ.UInt32) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpSub16, typ.UInt16) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpConst16, typ.UInt16) | |
| v8.AuxInt = ssa.Int16ToAuxInt(32) | |
| v7.AddArg2(v8, s) | |
| v6.AddArg2(v1, v7) | |
| v3.AddArg2(v4, v6) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpAnd32, typ.UInt32) | |
| v10 := b.NewValue0(v.Pos, ssaop.OpRsh32x16, typ.UInt32) | |
| v11 := b.NewValue0(v.Pos, ssaop.OpSub16, typ.UInt16) | |
| v11.AddArg2(s, v8) | |
| v10.AddArg2(v1, v11) | |
| v12 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v13 := b.NewValue0(v.Pos, ssaop.OpZeroExt16to32, typ.UInt32) | |
| v14 := b.NewValue0(v.Pos, ssaop.OpRsh16Ux32, typ.UInt16) | |
| v15 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v15.AuxInt = ssa.Int32ToAuxInt(5) | |
| v14.AddArg2(s, v15) | |
| v13.AddArg(v14) | |
| v12.AddArg(v13) | |
| v9.AddArg2(v10, v12) | |
| v2.AddArg2(v3, v9) | |
| v.AddArg2(v0, v2) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpRsh64x32(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Rsh64x32 x s) | |
| // result: (Int64Make (Rsh32x32 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux32 <typ.UInt32> (Int64Lo x) s) (Lsh32x32 <typ.UInt32> (Int64Hi x) (Sub32 <typ.UInt32> (Const32 <typ.UInt32> [32]) s))) (And32 <typ.UInt32> (Rsh32x32 <typ.UInt32> (Int64Hi x) (Sub32 <typ.UInt32> s (Const32 <typ.UInt32> [32]))) (Zeromask (Rsh32Ux32 <typ.UInt32> s (Const32 <typ.UInt32> [5])))))) | |
| for { | |
| x := v_0 | |
| s := v_1 | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh32x32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v0.AddArg2(v1, s) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(x) | |
| v4.AddArg2(v5, s) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.UInt32) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpSub32, typ.UInt32) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v8.AuxInt = ssa.Int32ToAuxInt(32) | |
| v7.AddArg2(v8, s) | |
| v6.AddArg2(v1, v7) | |
| v3.AddArg2(v4, v6) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpAnd32, typ.UInt32) | |
| v10 := b.NewValue0(v.Pos, ssaop.OpRsh32x32, typ.UInt32) | |
| v11 := b.NewValue0(v.Pos, ssaop.OpSub32, typ.UInt32) | |
| v11.AddArg2(s, v8) | |
| v10.AddArg2(v1, v11) | |
| v12 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v13 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux32, typ.UInt32) | |
| v14 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v14.AuxInt = ssa.Int32ToAuxInt(5) | |
| v13.AddArg2(s, v14) | |
| v12.AddArg(v13) | |
| v9.AddArg2(v10, v12) | |
| v2.AddArg2(v3, v9) | |
| v.AddArg2(v0, v2) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpRsh64x64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Rsh64x64 x (Int64Make (Const32 [c]) _)) | |
| // cond: c != 0 | |
| // result: (Int64Make (Signmask (Int64Hi x)) (Signmask (Int64Hi x))) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt32(v_1_0.AuxInt) | |
| if !(c != 0) { | |
| break | |
| } | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpSignmask, typ.Int32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v0.AddArg(v1) | |
| v.AddArg2(v0, v0) | |
| return true | |
| } | |
| // match: (Rsh64x64 [c] x (Int64Make (Const32 [0]) lo)) | |
| // result: (Rsh64x32 [c] x lo) | |
| for { | |
| c := ssa.AuxIntToBool(v.AuxInt) | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1_0.AuxInt) != 0 { | |
| break | |
| } | |
| v.Reset(ssaop.OpRsh64x32) | |
| v.AuxInt = ssa.BoolToAuxInt(c) | |
| v.AddArg2(x, lo) | |
| return true | |
| } | |
| // match: (Rsh64x64 x (Int64Make hi lo)) | |
| // cond: hi.Op != ssaop.OpConst32 | |
| // result: (Rsh64x32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| hi := v_1.Args[0] | |
| if !(hi.Op != ssaop.OpConst32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpRsh64x32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v1.AddArg(hi) | |
| v0.AddArg2(v1, lo) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| // match: (Rsh64x64 x y) | |
| // result: (Rsh64x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpRsh64x32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v1.AddArg(v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v3.AddArg(y) | |
| v0.AddArg2(v1, v3) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpRsh64x8(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Rsh64x8 x s) | |
| // result: (Int64Make (Rsh32x8 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux8 <typ.UInt32> (Int64Lo x) s) (Lsh32x8 <typ.UInt32> (Int64Hi x) (Sub8 <typ.UInt8> (Const8 <typ.UInt8> [32]) s))) (And32 <typ.UInt32> (Rsh32x8 <typ.UInt32> (Int64Hi x) (Sub8 <typ.UInt8> s (Const8 <typ.UInt8> [32]))) (Zeromask (ZeroExt8to32 (Rsh8Ux32 <typ.UInt8> s (Const32 <typ.UInt32> [5]))))))) | |
| for { | |
| x := v_0 | |
| s := v_1 | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh32x8, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v0.AddArg2(v1, s) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux8, typ.UInt32) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(x) | |
| v4.AddArg2(v5, s) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpLsh32x8, typ.UInt32) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpSub8, typ.UInt8) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpConst8, typ.UInt8) | |
| v8.AuxInt = ssa.Int8ToAuxInt(32) | |
| v7.AddArg2(v8, s) | |
| v6.AddArg2(v1, v7) | |
| v3.AddArg2(v4, v6) | |
| v9 := b.NewValue0(v.Pos, ssaop.OpAnd32, typ.UInt32) | |
| v10 := b.NewValue0(v.Pos, ssaop.OpRsh32x8, typ.UInt32) | |
| v11 := b.NewValue0(v.Pos, ssaop.OpSub8, typ.UInt8) | |
| v11.AddArg2(s, v8) | |
| v10.AddArg2(v1, v11) | |
| v12 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v13 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, typ.UInt32) | |
| v14 := b.NewValue0(v.Pos, ssaop.OpRsh8Ux32, typ.UInt8) | |
| v15 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v15.AuxInt = ssa.Int32ToAuxInt(5) | |
| v14.AddArg2(s, v15) | |
| v13.AddArg(v14) | |
| v12.AddArg(v13) | |
| v9.AddArg2(v10, v12) | |
| v2.AddArg2(v3, v9) | |
| v.AddArg2(v0, v2) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpRsh8Ux64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Rsh8Ux64 _ (Int64Make (Const32 [c]) _)) | |
| // cond: c != 0 | |
| // result: (Const32 [0]) | |
| for { | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt32(v_1_0.AuxInt) | |
| if !(c != 0) { | |
| break | |
| } | |
| v.Reset(ssaop.OpConst32) | |
| v.AuxInt = ssa.Int32ToAuxInt(0) | |
| return true | |
| } | |
| // match: (Rsh8Ux64 [c] x (Int64Make (Const32 [0]) lo)) | |
| // result: (Rsh8Ux32 [c] x lo) | |
| for { | |
| c := ssa.AuxIntToBool(v.AuxInt) | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1_0.AuxInt) != 0 { | |
| break | |
| } | |
| v.Reset(ssaop.OpRsh8Ux32) | |
| v.AuxInt = ssa.BoolToAuxInt(c) | |
| v.AddArg2(x, lo) | |
| return true | |
| } | |
| // match: (Rsh8Ux64 x (Int64Make hi lo)) | |
| // cond: hi.Op != ssaop.OpConst32 | |
| // result: (Rsh8Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| hi := v_1.Args[0] | |
| if !(hi.Op != ssaop.OpConst32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpRsh8Ux32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v1.AddArg(hi) | |
| v0.AddArg2(v1, lo) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| // match: (Rsh8Ux64 x y) | |
| // result: (Rsh8Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpRsh8Ux32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v1.AddArg(v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v3.AddArg(y) | |
| v0.AddArg2(v1, v3) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpRsh8x64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Rsh8x64 x (Int64Make (Const32 [c]) _)) | |
| // cond: c != 0 | |
| // result: (Signmask (SignExt8to32 x)) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 { | |
| break | |
| } | |
| c := ssa.AuxIntToInt32(v_1_0.AuxInt) | |
| if !(c != 0) { | |
| break | |
| } | |
| v.Reset(ssaop.OpSignmask) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpSignExt8to32, typ.Int32) | |
| v0.AddArg(x) | |
| v.AddArg(v0) | |
| return true | |
| } | |
| // match: (Rsh8x64 [c] x (Int64Make (Const32 [0]) lo)) | |
| // result: (Rsh8x32 [c] x lo) | |
| for { | |
| c := ssa.AuxIntToBool(v.AuxInt) | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| v_1_0 := v_1.Args[0] | |
| if v_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1_0.AuxInt) != 0 { | |
| break | |
| } | |
| v.Reset(ssaop.OpRsh8x32) | |
| v.AuxInt = ssa.BoolToAuxInt(c) | |
| v.AddArg2(x, lo) | |
| return true | |
| } | |
| // match: (Rsh8x64 x (Int64Make hi lo)) | |
| // cond: hi.Op != ssaop.OpConst32 | |
| // result: (Rsh8x32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) | |
| for { | |
| x := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| hi := v_1.Args[0] | |
| if !(hi.Op != ssaop.OpConst32) { | |
| break | |
| } | |
| v.Reset(ssaop.OpRsh8x32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v1.AddArg(hi) | |
| v0.AddArg2(v1, lo) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| // match: (Rsh8x64 x y) | |
| // result: (Rsh8x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpRsh8x32) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeromask, typ.UInt32) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v1.AddArg(v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v3.AddArg(y) | |
| v0.AddArg2(v1, v3) | |
| v.AddArg2(x, v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpSelect0(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| // match: (Select0 (MakeTuple x y)) | |
| // result: x | |
| for { | |
| if v_0.Op != ssaop.OpMakeTuple { | |
| break | |
| } | |
| x := v_0.Args[0] | |
| v.CopyOf(x) | |
| return true | |
| } | |
| return false | |
| } | |
| func rewriteValue_OpSelect1(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| // match: (Select1 (MakeTuple x y)) | |
| // result: y | |
| for { | |
| if v_0.Op != ssaop.OpMakeTuple { | |
| break | |
| } | |
| y := v_0.Args[1] | |
| v.CopyOf(y) | |
| return true | |
| } | |
| return false | |
| } | |
| func rewriteValue_OpSignExt16to64(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (SignExt16to64 x) | |
| // result: (SignExt32to64 (SignExt16to32 x)) | |
| for { | |
| x := v_0 | |
| v.Reset(ssaop.OpSignExt32to64) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpSignExt16to32, typ.Int32) | |
| v0.AddArg(x) | |
| v.AddArg(v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpSignExt32to64(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (SignExt32to64 x) | |
| // result: (Int64Make (Signmask x) x) | |
| for { | |
| x := v_0 | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpSignmask, typ.Int32) | |
| v0.AddArg(x) | |
| v.AddArg2(v0, x) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpSignExt8to64(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (SignExt8to64 x) | |
| // result: (SignExt32to64 (SignExt8to32 x)) | |
| for { | |
| x := v_0 | |
| v.Reset(ssaop.OpSignExt32to64) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpSignExt8to32, typ.Int32) | |
| v0.AddArg(x) | |
| v.AddArg(v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpStore(v *ssa.Value) bool { | |
| v_2 := v.Args[2] | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| config := b.Func.Config | |
| // match: (Store {t} dst (Int64Make hi lo) mem) | |
| // cond: t.Size() == 8 && !config.BigEndian | |
| // result: (Store {hi.Type} (OffPtr <hi.Type.PtrTo()> [4] dst) hi (Store {lo.Type} dst lo mem)) | |
| for { | |
| t := ssa.AuxToType(v.Aux) | |
| dst := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| hi := v_1.Args[0] | |
| mem := v_2 | |
| if !(t.Size() == 8 && !config.BigEndian) { | |
| break | |
| } | |
| v.Reset(ssaop.OpStore) | |
| v.Aux = ssa.TypeToAux(hi.Type) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, hi.Type.PtrTo()) | |
| v0.AuxInt = ssa.Int64ToAuxInt(4) | |
| v0.AddArg(dst) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) | |
| v1.Aux = ssa.TypeToAux(lo.Type) | |
| v1.AddArg3(dst, lo, mem) | |
| v.AddArg3(v0, hi, v1) | |
| return true | |
| } | |
| // match: (Store {t} dst (Int64Make hi lo) mem) | |
| // cond: t.Size() == 8 && config.BigEndian | |
| // result: (Store {lo.Type} (OffPtr <lo.Type.PtrTo()> [4] dst) lo (Store {hi.Type} dst hi mem)) | |
| for { | |
| t := ssa.AuxToType(v.Aux) | |
| dst := v_0 | |
| if v_1.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_1.Args[1] | |
| hi := v_1.Args[0] | |
| mem := v_2 | |
| if !(t.Size() == 8 && config.BigEndian) { | |
| break | |
| } | |
| v.Reset(ssaop.OpStore) | |
| v.Aux = ssa.TypeToAux(lo.Type) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, lo.Type.PtrTo()) | |
| v0.AuxInt = ssa.Int64ToAuxInt(4) | |
| v0.AddArg(dst) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) | |
| v1.Aux = ssa.TypeToAux(hi.Type) | |
| v1.AddArg3(dst, hi, mem) | |
| v.AddArg3(v0, lo, v1) | |
| return true | |
| } | |
| return false | |
| } | |
| func rewriteValue_OpSub64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Sub64 <t> x y) | |
| // result: (Last <t> x0: (Int64Lo x) x1: (Int64Hi x) y0: (Int64Lo y) y1: (Int64Hi y) sub: (Sub32carry x0 y0) (Int64Make (Sub32withcarry <typ.UInt32> x1 y1 (Select1 <types.TypeFlags> sub)) (Select0 <typ.UInt32> sub))) | |
| for { | |
| t := v.Type | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpLast) | |
| v.Type = t | |
| x0 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| x0.AddArg(x) | |
| x1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| x1.AddArg(x) | |
| y0 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| y0.AddArg(y) | |
| y1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| y1.AddArg(y) | |
| sub := b.NewValue0(v.Pos, ssaop.OpSub32carry, types.NewTuple(typ.UInt32, types.TypeFlags)) | |
| sub.AddArg2(x0, y0) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Make, typ.UInt64) | |
| v6 := b.NewValue0(v.Pos, ssaop.OpSub32withcarry, typ.UInt32) | |
| v7 := b.NewValue0(v.Pos, ssaop.OpSelect1, types.TypeFlags) | |
| v7.AddArg(sub) | |
| v6.AddArg3(x1, y1, v7) | |
| v8 := b.NewValue0(v.Pos, ssaop.OpSelect0, typ.UInt32) | |
| v8.AddArg(sub) | |
| v5.AddArg2(v6, v8) | |
| v.AddArg6(x0, x1, y0, y1, sub, v5) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpTrunc64to16(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Trunc64to16 (Int64Make _ lo)) | |
| // result: (Trunc32to16 lo) | |
| for { | |
| if v_0.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_0.Args[1] | |
| v.Reset(ssaop.OpTrunc32to16) | |
| v.AddArg(lo) | |
| return true | |
| } | |
| // match: (Trunc64to16 x) | |
| // result: (Trunc32to16 (Int64Lo x)) | |
| for { | |
| x := v_0 | |
| v.Reset(ssaop.OpTrunc32to16) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v0.AddArg(x) | |
| v.AddArg(v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpTrunc64to32(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| // match: (Trunc64to32 (Int64Make _ lo)) | |
| // result: lo | |
| for { | |
| if v_0.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_0.Args[1] | |
| v.CopyOf(lo) | |
| return true | |
| } | |
| // match: (Trunc64to32 x) | |
| // result: (Int64Lo x) | |
| for { | |
| x := v_0 | |
| v.Reset(ssaop.OpInt64Lo) | |
| v.AddArg(x) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpTrunc64to8(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Trunc64to8 (Int64Make _ lo)) | |
| // result: (Trunc32to8 lo) | |
| for { | |
| if v_0.Op != ssaop.OpInt64Make { | |
| break | |
| } | |
| lo := v_0.Args[1] | |
| v.Reset(ssaop.OpTrunc32to8) | |
| v.AddArg(lo) | |
| return true | |
| } | |
| // match: (Trunc64to8 x) | |
| // result: (Trunc32to8 (Int64Lo x)) | |
| for { | |
| x := v_0 | |
| v.Reset(ssaop.OpTrunc32to8) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v0.AddArg(x) | |
| v.AddArg(v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpXor64(v *ssa.Value) bool { | |
| v_1 := v.Args[1] | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (Xor64 x y) | |
| // result: (Int64Make (Xor32 <typ.UInt32> (Int64Hi x) (Int64Hi y)) (Xor32 <typ.UInt32> (Int64Lo x) (Int64Lo y))) | |
| for { | |
| x := v_0 | |
| y := v_1 | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpXor32, typ.UInt32) | |
| v1 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v1.AddArg(x) | |
| v2 := b.NewValue0(v.Pos, ssaop.OpInt64Hi, typ.UInt32) | |
| v2.AddArg(y) | |
| v0.AddArg2(v1, v2) | |
| v3 := b.NewValue0(v.Pos, ssaop.OpXor32, typ.UInt32) | |
| v4 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v4.AddArg(x) | |
| v5 := b.NewValue0(v.Pos, ssaop.OpInt64Lo, typ.UInt32) | |
| v5.AddArg(y) | |
| v3.AddArg2(v4, v5) | |
| v.AddArg2(v0, v3) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpZeroExt16to64(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (ZeroExt16to64 x) | |
| // result: (ZeroExt32to64 (ZeroExt16to32 x)) | |
| for { | |
| x := v_0 | |
| v.Reset(ssaop.OpZeroExt32to64) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpZeroExt16to32, typ.UInt32) | |
| v0.AddArg(x) | |
| v.AddArg(v0) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpZeroExt32to64(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (ZeroExt32to64 x) | |
| // result: (Int64Make (Const32 <typ.UInt32> [0]) x) | |
| for { | |
| x := v_0 | |
| v.Reset(ssaop.OpInt64Make) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) | |
| v0.AuxInt = ssa.Int32ToAuxInt(0) | |
| v.AddArg2(v0, x) | |
| return true | |
| } | |
| } | |
| func rewriteValue_OpZeroExt8to64(v *ssa.Value) bool { | |
| v_0 := v.Args[0] | |
| b := v.Block | |
| typ := &b.Func.Config.Types | |
| // match: (ZeroExt8to64 x) | |
| // result: (ZeroExt32to64 (ZeroExt8to32 x)) | |
| for { | |
| x := v_0 | |
| v.Reset(ssaop.OpZeroExt32to64) | |
| v0 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, typ.UInt32) | |
| v0.AddArg(x) | |
| v.AddArg(v0) | |
| return true | |
| } | |
| } | |
| func RewriteBlock(b *ssa.Block) bool { | |
| return false | |
| } |