| // Code generated from _gen/generic.rules using 'go generate'; DO NOT EDIT. |
| |
| package rewritegeneric |
| |
| import "math" |
| import "math/bits" |
| import "cmd/internal/obj" |
| import "cmd/compile/internal/types" |
| import "cmd/compile/internal/ir" |
| import "cmd/compile/internal/ssa/block" |
| import "cmd/compile/internal/ssa/ssaop" |
| import "cmd/compile/internal/ssa" |
| |
| func RewriteValue(v *ssa.Value) bool { |
| switch v.Op { |
| case ssaop.OpAdd16: |
| return rewriteValue_OpAdd16(v) |
| case ssaop.OpAdd32: |
| return rewriteValue_OpAdd32(v) |
| case ssaop.OpAdd32F: |
| return rewriteValue_OpAdd32F(v) |
| case ssaop.OpAdd64: |
| return rewriteValue_OpAdd64(v) |
| case ssaop.OpAdd64F: |
| return rewriteValue_OpAdd64F(v) |
| case ssaop.OpAdd64carry: |
| return rewriteValue_OpAdd64carry(v) |
| case ssaop.OpAdd8: |
| return rewriteValue_OpAdd8(v) |
| case ssaop.OpAddPtr: |
| return rewriteValue_OpAddPtr(v) |
| case ssaop.OpAnd16: |
| return rewriteValue_OpAnd16(v) |
| case ssaop.OpAnd32: |
| return rewriteValue_OpAnd32(v) |
| case ssaop.OpAnd64: |
| return rewriteValue_OpAnd64(v) |
| case ssaop.OpAnd8: |
| return rewriteValue_OpAnd8(v) |
| case ssaop.OpAndB: |
| return rewriteValue_OpAndB(v) |
| case ssaop.OpArraySelect: |
| return rewriteValue_OpArraySelect(v) |
| case ssaop.OpBitLen16: |
| return rewriteValue_OpBitLen16(v) |
| case ssaop.OpBitLen32: |
| return rewriteValue_OpBitLen32(v) |
| case ssaop.OpBitLen64: |
| return rewriteValue_OpBitLen64(v) |
| case ssaop.OpBitLen8: |
| return rewriteValue_OpBitLen8(v) |
| case ssaop.OpBitRev16: |
| return rewriteValue_OpBitRev16(v) |
| case ssaop.OpBitRev32: |
| return rewriteValue_OpBitRev32(v) |
| case ssaop.OpBitRev64: |
| return rewriteValue_OpBitRev64(v) |
| case ssaop.OpBitRev8: |
| return rewriteValue_OpBitRev8(v) |
| case ssaop.OpBswap16: |
| return rewriteValue_OpBswap16(v) |
| case ssaop.OpBswap32: |
| return rewriteValue_OpBswap32(v) |
| case ssaop.OpBswap64: |
| return rewriteValue_OpBswap64(v) |
| case ssaop.OpCeil: |
| return rewriteValue_OpCeil(v) |
| case ssaop.OpCom16: |
| return rewriteValue_OpCom16(v) |
| case ssaop.OpCom32: |
| return rewriteValue_OpCom32(v) |
| case ssaop.OpCom64: |
| return rewriteValue_OpCom64(v) |
| case ssaop.OpCom8: |
| return rewriteValue_OpCom8(v) |
| case ssaop.OpCondSelect: |
| return rewriteValue_OpCondSelect(v) |
| case ssaop.OpConstInterface: |
| return rewriteValue_OpConstInterface(v) |
| case ssaop.OpConstSlice: |
| return rewriteValue_OpConstSlice(v) |
| case ssaop.OpConstString: |
| return rewriteValue_OpConstString(v) |
| case ssaop.OpConvert: |
| return rewriteValue_OpConvert(v) |
| case ssaop.OpCtz16: |
| return rewriteValue_OpCtz16(v) |
| case ssaop.OpCtz32: |
| return rewriteValue_OpCtz32(v) |
| case ssaop.OpCtz64: |
| return rewriteValue_OpCtz64(v) |
| case ssaop.OpCtz8: |
| return rewriteValue_OpCtz8(v) |
| case ssaop.OpCvt32Fto32: |
| return rewriteValue_OpCvt32Fto32(v) |
| case ssaop.OpCvt32Fto64: |
| return rewriteValue_OpCvt32Fto64(v) |
| case ssaop.OpCvt32Fto64F: |
| return rewriteValue_OpCvt32Fto64F(v) |
| case ssaop.OpCvt32to32F: |
| return rewriteValue_OpCvt32to32F(v) |
| case ssaop.OpCvt32to64F: |
| return rewriteValue_OpCvt32to64F(v) |
| case ssaop.OpCvt64Fto32: |
| return rewriteValue_OpCvt64Fto32(v) |
| case ssaop.OpCvt64Fto32F: |
| return rewriteValue_OpCvt64Fto32F(v) |
| case ssaop.OpCvt64Fto64: |
| return rewriteValue_OpCvt64Fto64(v) |
| case ssaop.OpCvt64to32F: |
| return rewriteValue_OpCvt64to32F(v) |
| case ssaop.OpCvt64to64F: |
| return rewriteValue_OpCvt64to64F(v) |
| case ssaop.OpCvtBoolToUint8: |
| return rewriteValue_OpCvtBoolToUint8(v) |
| case ssaop.OpDiv128u: |
| return rewriteValue_OpDiv128u(v) |
| case ssaop.OpDiv16: |
| return rewriteValue_OpDiv16(v) |
| case ssaop.OpDiv16u: |
| return rewriteValue_OpDiv16u(v) |
| case ssaop.OpDiv32: |
| return rewriteValue_OpDiv32(v) |
| case ssaop.OpDiv32F: |
| return rewriteValue_OpDiv32F(v) |
| case ssaop.OpDiv32u: |
| return rewriteValue_OpDiv32u(v) |
| case ssaop.OpDiv64: |
| return rewriteValue_OpDiv64(v) |
| case ssaop.OpDiv64F: |
| return rewriteValue_OpDiv64F(v) |
| case ssaop.OpDiv64u: |
| return rewriteValue_OpDiv64u(v) |
| case ssaop.OpDiv8: |
| return rewriteValue_OpDiv8(v) |
| case ssaop.OpDiv8u: |
| return rewriteValue_OpDiv8u(v) |
| case ssaop.OpEq16: |
| return rewriteValue_OpEq16(v) |
| case ssaop.OpEq32: |
| return rewriteValue_OpEq32(v) |
| case ssaop.OpEq32F: |
| return rewriteValue_OpEq32F(v) |
| case ssaop.OpEq64: |
| return rewriteValue_OpEq64(v) |
| case ssaop.OpEq64F: |
| return rewriteValue_OpEq64F(v) |
| case ssaop.OpEq8: |
| return rewriteValue_OpEq8(v) |
| case ssaop.OpEqB: |
| return rewriteValue_OpEqB(v) |
| case ssaop.OpEqInter: |
| return rewriteValue_OpEqInter(v) |
| case ssaop.OpEqPtr: |
| return rewriteValue_OpEqPtr(v) |
| case ssaop.OpEqSlice: |
| return rewriteValue_OpEqSlice(v) |
| case ssaop.OpFloor: |
| return rewriteValue_OpFloor(v) |
| case ssaop.OpIMake: |
| return rewriteValue_OpIMake(v) |
| case ssaop.OpInterLECall: |
| return rewriteValue_OpInterLECall(v) |
| case ssaop.OpIsInBounds: |
| return rewriteValue_OpIsInBounds(v) |
| case ssaop.OpIsNonNil: |
| return rewriteValue_OpIsNonNil(v) |
| case ssaop.OpIsSliceInBounds: |
| return rewriteValue_OpIsSliceInBounds(v) |
| case ssaop.OpLeq16: |
| return rewriteValue_OpLeq16(v) |
| case ssaop.OpLeq16U: |
| return rewriteValue_OpLeq16U(v) |
| case ssaop.OpLeq32: |
| return rewriteValue_OpLeq32(v) |
| case ssaop.OpLeq32F: |
| return rewriteValue_OpLeq32F(v) |
| case ssaop.OpLeq32U: |
| return rewriteValue_OpLeq32U(v) |
| case ssaop.OpLeq64: |
| return rewriteValue_OpLeq64(v) |
| case ssaop.OpLeq64F: |
| return rewriteValue_OpLeq64F(v) |
| case ssaop.OpLeq64U: |
| return rewriteValue_OpLeq64U(v) |
| case ssaop.OpLeq8: |
| return rewriteValue_OpLeq8(v) |
| case ssaop.OpLeq8U: |
| return rewriteValue_OpLeq8U(v) |
| case ssaop.OpLess16: |
| return rewriteValue_OpLess16(v) |
| case ssaop.OpLess16U: |
| return rewriteValue_OpLess16U(v) |
| case ssaop.OpLess32: |
| return rewriteValue_OpLess32(v) |
| case ssaop.OpLess32F: |
| return rewriteValue_OpLess32F(v) |
| case ssaop.OpLess32U: |
| return rewriteValue_OpLess32U(v) |
| case ssaop.OpLess64: |
| return rewriteValue_OpLess64(v) |
| case ssaop.OpLess64F: |
| return rewriteValue_OpLess64F(v) |
| case ssaop.OpLess64U: |
| return rewriteValue_OpLess64U(v) |
| case ssaop.OpLess8: |
| return rewriteValue_OpLess8(v) |
| case ssaop.OpLess8U: |
| return rewriteValue_OpLess8U(v) |
| case ssaop.OpLoad: |
| return rewriteValue_OpLoad(v) |
| case ssaop.OpLsh16x16: |
| return rewriteValue_OpLsh16x16(v) |
| case ssaop.OpLsh16x32: |
| return rewriteValue_OpLsh16x32(v) |
| case ssaop.OpLsh16x64: |
| return rewriteValue_OpLsh16x64(v) |
| case ssaop.OpLsh16x8: |
| return rewriteValue_OpLsh16x8(v) |
| case ssaop.OpLsh32x16: |
| return rewriteValue_OpLsh32x16(v) |
| case ssaop.OpLsh32x32: |
| return rewriteValue_OpLsh32x32(v) |
| case ssaop.OpLsh32x64: |
| return rewriteValue_OpLsh32x64(v) |
| case ssaop.OpLsh32x8: |
| return rewriteValue_OpLsh32x8(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.OpLsh8x16: |
| return rewriteValue_OpLsh8x16(v) |
| case ssaop.OpLsh8x32: |
| return rewriteValue_OpLsh8x32(v) |
| case ssaop.OpLsh8x64: |
| return rewriteValue_OpLsh8x64(v) |
| case ssaop.OpLsh8x8: |
| return rewriteValue_OpLsh8x8(v) |
| case ssaop.OpMemEq: |
| return rewriteValue_OpMemEq(v) |
| case ssaop.OpMod16: |
| return rewriteValue_OpMod16(v) |
| case ssaop.OpMod16u: |
| return rewriteValue_OpMod16u(v) |
| case ssaop.OpMod32: |
| return rewriteValue_OpMod32(v) |
| case ssaop.OpMod32u: |
| return rewriteValue_OpMod32u(v) |
| case ssaop.OpMod64: |
| return rewriteValue_OpMod64(v) |
| case ssaop.OpMod64u: |
| return rewriteValue_OpMod64u(v) |
| case ssaop.OpMod8: |
| return rewriteValue_OpMod8(v) |
| case ssaop.OpMod8u: |
| return rewriteValue_OpMod8u(v) |
| case ssaop.OpMove: |
| return rewriteValue_OpMove(v) |
| case ssaop.OpMul16: |
| return rewriteValue_OpMul16(v) |
| case ssaop.OpMul32: |
| return rewriteValue_OpMul32(v) |
| case ssaop.OpMul32F: |
| return rewriteValue_OpMul32F(v) |
| case ssaop.OpMul32uhilo: |
| return rewriteValue_OpMul32uhilo(v) |
| case ssaop.OpMul32uover: |
| return rewriteValue_OpMul32uover(v) |
| case ssaop.OpMul64: |
| return rewriteValue_OpMul64(v) |
| case ssaop.OpMul64F: |
| return rewriteValue_OpMul64F(v) |
| case ssaop.OpMul64uhilo: |
| return rewriteValue_OpMul64uhilo(v) |
| case ssaop.OpMul64uover: |
| return rewriteValue_OpMul64uover(v) |
| case ssaop.OpMul8: |
| return rewriteValue_OpMul8(v) |
| case ssaop.OpNeg16: |
| return rewriteValue_OpNeg16(v) |
| case ssaop.OpNeg32: |
| return rewriteValue_OpNeg32(v) |
| case ssaop.OpNeg32F: |
| return rewriteValue_OpNeg32F(v) |
| case ssaop.OpNeg64: |
| return rewriteValue_OpNeg64(v) |
| case ssaop.OpNeg64F: |
| return rewriteValue_OpNeg64F(v) |
| case ssaop.OpNeg8: |
| return rewriteValue_OpNeg8(v) |
| case ssaop.OpNeq16: |
| return rewriteValue_OpNeq16(v) |
| case ssaop.OpNeq32: |
| return rewriteValue_OpNeq32(v) |
| case ssaop.OpNeq32F: |
| return rewriteValue_OpNeq32F(v) |
| case ssaop.OpNeq64: |
| return rewriteValue_OpNeq64(v) |
| case ssaop.OpNeq64F: |
| return rewriteValue_OpNeq64F(v) |
| case ssaop.OpNeq8: |
| return rewriteValue_OpNeq8(v) |
| case ssaop.OpNeqB: |
| return rewriteValue_OpNeqB(v) |
| case ssaop.OpNeqInter: |
| return rewriteValue_OpNeqInter(v) |
| case ssaop.OpNeqPtr: |
| return rewriteValue_OpNeqPtr(v) |
| case ssaop.OpNeqSlice: |
| return rewriteValue_OpNeqSlice(v) |
| case ssaop.OpNilCheck: |
| return rewriteValue_OpNilCheck(v) |
| case ssaop.OpNot: |
| return rewriteValue_OpNot(v) |
| case ssaop.OpOffPtr: |
| return rewriteValue_OpOffPtr(v) |
| case ssaop.OpOr16: |
| return rewriteValue_OpOr16(v) |
| case ssaop.OpOr32: |
| return rewriteValue_OpOr32(v) |
| case ssaop.OpOr64: |
| return rewriteValue_OpOr64(v) |
| case ssaop.OpOr8: |
| return rewriteValue_OpOr8(v) |
| case ssaop.OpOrB: |
| return rewriteValue_OpOrB(v) |
| case ssaop.OpPhi: |
| return rewriteValue_OpPhi(v) |
| case ssaop.OpPopCount16: |
| return rewriteValue_OpPopCount16(v) |
| case ssaop.OpPopCount32: |
| return rewriteValue_OpPopCount32(v) |
| case ssaop.OpPopCount64: |
| return rewriteValue_OpPopCount64(v) |
| case ssaop.OpPopCount8: |
| return rewriteValue_OpPopCount8(v) |
| case ssaop.OpPtrIndex: |
| return rewriteValue_OpPtrIndex(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.OpRound32F: |
| return rewriteValue_OpRound32F(v) |
| case ssaop.OpRound64F: |
| return rewriteValue_OpRound64F(v) |
| case ssaop.OpRoundToEven: |
| return rewriteValue_OpRoundToEven(v) |
| case ssaop.OpRsh16Ux16: |
| return rewriteValue_OpRsh16Ux16(v) |
| case ssaop.OpRsh16Ux32: |
| return rewriteValue_OpRsh16Ux32(v) |
| case ssaop.OpRsh16Ux64: |
| return rewriteValue_OpRsh16Ux64(v) |
| case ssaop.OpRsh16Ux8: |
| return rewriteValue_OpRsh16Ux8(v) |
| case ssaop.OpRsh16x16: |
| return rewriteValue_OpRsh16x16(v) |
| case ssaop.OpRsh16x32: |
| return rewriteValue_OpRsh16x32(v) |
| case ssaop.OpRsh16x64: |
| return rewriteValue_OpRsh16x64(v) |
| case ssaop.OpRsh16x8: |
| return rewriteValue_OpRsh16x8(v) |
| case ssaop.OpRsh32Ux16: |
| return rewriteValue_OpRsh32Ux16(v) |
| case ssaop.OpRsh32Ux32: |
| return rewriteValue_OpRsh32Ux32(v) |
| case ssaop.OpRsh32Ux64: |
| return rewriteValue_OpRsh32Ux64(v) |
| case ssaop.OpRsh32Ux8: |
| return rewriteValue_OpRsh32Ux8(v) |
| case ssaop.OpRsh32x16: |
| return rewriteValue_OpRsh32x16(v) |
| case ssaop.OpRsh32x32: |
| return rewriteValue_OpRsh32x32(v) |
| case ssaop.OpRsh32x64: |
| return rewriteValue_OpRsh32x64(v) |
| case ssaop.OpRsh32x8: |
| return rewriteValue_OpRsh32x8(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.OpRsh8Ux16: |
| return rewriteValue_OpRsh8Ux16(v) |
| case ssaop.OpRsh8Ux32: |
| return rewriteValue_OpRsh8Ux32(v) |
| case ssaop.OpRsh8Ux64: |
| return rewriteValue_OpRsh8Ux64(v) |
| case ssaop.OpRsh8Ux8: |
| return rewriteValue_OpRsh8Ux8(v) |
| case ssaop.OpRsh8x16: |
| return rewriteValue_OpRsh8x16(v) |
| case ssaop.OpRsh8x32: |
| return rewriteValue_OpRsh8x32(v) |
| case ssaop.OpRsh8x64: |
| return rewriteValue_OpRsh8x64(v) |
| case ssaop.OpRsh8x8: |
| return rewriteValue_OpRsh8x8(v) |
| case ssaop.OpSelect0: |
| return rewriteValue_OpSelect0(v) |
| case ssaop.OpSelect1: |
| return rewriteValue_OpSelect1(v) |
| case ssaop.OpSelectN: |
| return rewriteValue_OpSelectN(v) |
| case ssaop.OpSignExt16to32: |
| return rewriteValue_OpSignExt16to32(v) |
| case ssaop.OpSignExt16to64: |
| return rewriteValue_OpSignExt16to64(v) |
| case ssaop.OpSignExt32to64: |
| return rewriteValue_OpSignExt32to64(v) |
| case ssaop.OpSignExt8to16: |
| return rewriteValue_OpSignExt8to16(v) |
| case ssaop.OpSignExt8to32: |
| return rewriteValue_OpSignExt8to32(v) |
| case ssaop.OpSignExt8to64: |
| return rewriteValue_OpSignExt8to64(v) |
| case ssaop.OpSliceCap: |
| return rewriteValue_OpSliceCap(v) |
| case ssaop.OpSliceLen: |
| return rewriteValue_OpSliceLen(v) |
| case ssaop.OpSliceMake: |
| return rewriteValue_OpSliceMake(v) |
| case ssaop.OpSlicePtr: |
| return rewriteValue_OpSlicePtr(v) |
| case ssaop.OpSlicemask: |
| return rewriteValue_OpSlicemask(v) |
| case ssaop.OpSqrt: |
| return rewriteValue_OpSqrt(v) |
| case ssaop.OpStaticCall: |
| return rewriteValue_OpStaticCall(v) |
| case ssaop.OpStaticLECall: |
| return rewriteValue_OpStaticLECall(v) |
| case ssaop.OpStore: |
| return rewriteValue_OpStore(v) |
| case ssaop.OpStringLen: |
| return rewriteValue_OpStringLen(v) |
| case ssaop.OpStringPtr: |
| return rewriteValue_OpStringPtr(v) |
| case ssaop.OpStructSelect: |
| return rewriteValue_OpStructSelect(v) |
| case ssaop.OpSub16: |
| return rewriteValue_OpSub16(v) |
| case ssaop.OpSub32: |
| return rewriteValue_OpSub32(v) |
| case ssaop.OpSub32F: |
| return rewriteValue_OpSub32F(v) |
| case ssaop.OpSub64: |
| return rewriteValue_OpSub64(v) |
| case ssaop.OpSub64F: |
| return rewriteValue_OpSub64F(v) |
| case ssaop.OpSub64borrow: |
| return rewriteValue_OpSub64borrow(v) |
| case ssaop.OpSub8: |
| return rewriteValue_OpSub8(v) |
| case ssaop.OpTrunc: |
| return rewriteValue_OpTrunc(v) |
| case ssaop.OpTrunc16to8: |
| return rewriteValue_OpTrunc16to8(v) |
| case ssaop.OpTrunc32to16: |
| return rewriteValue_OpTrunc32to16(v) |
| case ssaop.OpTrunc32to8: |
| return rewriteValue_OpTrunc32to8(v) |
| case ssaop.OpTrunc64to16: |
| return rewriteValue_OpTrunc64to16(v) |
| case ssaop.OpTrunc64to32: |
| return rewriteValue_OpTrunc64to32(v) |
| case ssaop.OpTrunc64to8: |
| return rewriteValue_OpTrunc64to8(v) |
| case ssaop.OpXor16: |
| return rewriteValue_OpXor16(v) |
| case ssaop.OpXor32: |
| return rewriteValue_OpXor32(v) |
| case ssaop.OpXor64: |
| return rewriteValue_OpXor64(v) |
| case ssaop.OpXor8: |
| return rewriteValue_OpXor8(v) |
| case ssaop.OpZero: |
| return rewriteValue_OpZero(v) |
| case ssaop.OpZeroExt16to32: |
| return rewriteValue_OpZeroExt16to32(v) |
| case ssaop.OpZeroExt16to64: |
| return rewriteValue_OpZeroExt16to64(v) |
| case ssaop.OpZeroExt32to64: |
| return rewriteValue_OpZeroExt32to64(v) |
| case ssaop.OpZeroExt8to16: |
| return rewriteValue_OpZeroExt8to16(v) |
| case ssaop.OpZeroExt8to32: |
| return rewriteValue_OpZeroExt8to32(v) |
| case ssaop.OpZeroExt8to64: |
| return rewriteValue_OpZeroExt8to64(v) |
| } |
| return false |
| } |
| func rewriteValue_OpAdd16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (Add16 (Const16 [c]) (Const16 [d])) |
| // result: (Const16 [c+d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(c + d) |
| return true |
| } |
| break |
| } |
| // match: (Add16 <t> (Mul16 x y) (Mul16 x z)) |
| // result: (Mul16 x (Add16 <t> y z)) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpMul16 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| y := v_0_1 |
| if v_1.Op != ssaop.OpMul16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| z := v_1_1 |
| v.Reset(ssaop.OpMul16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, t) |
| v0.AddArg2(y, z) |
| v.AddArg2(x, v0) |
| return true |
| } |
| } |
| } |
| break |
| } |
| // match: (Add16 x x) |
| // result: (Lsh16x64 x (Const64 <types.Types[types.TUINT64]> [1])) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpLsh16x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Add16 (Const16 [0]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Add16 x (Neg16 y)) |
| // result: (Sub16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg16 { |
| continue |
| } |
| y := v_1.Args[0] |
| v.Reset(ssaop.OpSub16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add16 (Com16 x) x) |
| // result: (Const16 [-1]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom16 { |
| continue |
| } |
| x := v_0.Args[0] |
| if x != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(-1) |
| return true |
| } |
| break |
| } |
| // match: (Add16 (Sub16 x t) (Add16 t y)) |
| // result: (Add16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpSub16 { |
| continue |
| } |
| t := v_0.Args[1] |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpAdd16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if t != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpAdd16) |
| v.AddArg2(x, y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Add16 (Const16 [1]) (Com16 x)) |
| // result: (Neg16 x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 1 || v_1.Op != ssaop.OpCom16 { |
| continue |
| } |
| x := v_1.Args[0] |
| v.Reset(ssaop.OpNeg16) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| // match: (Add16 x (Sub16 y x)) |
| // result: y |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if x != v_1.Args[1] { |
| continue |
| } |
| v.CopyOf(y) |
| return true |
| } |
| break |
| } |
| // match: (Add16 x (Add16 y (Sub16 z x))) |
| // result: (Add16 y z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = v_1_1.Args[1] |
| z := v_1_1.Args[0] |
| if x != v_1_1.Args[1] { |
| continue |
| } |
| v.Reset(ssaop.OpAdd16) |
| v.AddArg2(y, z) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Add16 x (Sub16 y (Sub16 x z))) |
| // result: (Add16 y z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| z := v_1_1.Args[1] |
| if x != v_1_1.Args[0] { |
| continue |
| } |
| v.Reset(ssaop.OpAdd16) |
| v.AddArg2(y, z) |
| return true |
| } |
| break |
| } |
| // match: (Add16 (Add16 i:(Const16 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) |
| // result: (Add16 i (Add16 <t> z x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAdd16 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Add16 (Sub16 i:(Const16 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) |
| // result: (Add16 i (Sub16 <t> x z)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpSub16 { |
| continue |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := i.Type |
| x := v_1 |
| if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub16, t) |
| v0.AddArg2(x, z) |
| v.AddArg2(i, v0) |
| return true |
| } |
| break |
| } |
| // match: (Add16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x)) |
| // result: (Add16 (Const16 <t> [c+d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpAdd16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst16 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpAdd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(c + d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Add16 (Const16 <t> [c]) (Sub16 (Const16 <t> [d]) x)) |
| // result: (Sub16 (Const16 <t> [c+d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst16 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_0.AuxInt) |
| v.Reset(ssaop.OpSub16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(c + d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Add16 (Lsh16x64 x z:(Const64 <t> [c])) (Rsh16Ux64 x (Const64 [d]))) |
| // cond: c < 16 && d == 16-c && canRotate(config, 16) |
| // result: (RotateLeft16 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLsh16x64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| z := v_0.Args[1] |
| if z.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(z.AuxInt) |
| if v_1.Op != ssaop.OpRsh16Ux64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c < 16 && d == 16-c && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Add16 left:(Lsh16x64 x y) right:(Rsh16Ux64 x (Sub64 (Const64 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh16x64 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh16Ux64 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add16 left:(Lsh16x32 x y) right:(Rsh16Ux32 x (Sub32 (Const32 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh16x32 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh16Ux32 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add16 left:(Lsh16x16 x y) right:(Rsh16Ux16 x (Sub16 (Const16 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh16x16 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh16Ux16 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add16 left:(Lsh16x8 x y) right:(Rsh16Ux8 x (Sub8 (Const8 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh16x8 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh16Ux8 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add16 right:(Rsh16Ux64 x y) left:(Lsh16x64 x z:(Sub64 (Const64 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh16Ux64 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh16x64 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Add16 right:(Rsh16Ux32 x y) left:(Lsh16x32 x z:(Sub32 (Const32 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh16Ux32 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh16x32 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Add16 right:(Rsh16Ux16 x y) left:(Lsh16x16 x z:(Sub16 (Const16 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh16Ux16 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh16x16 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Add16 right:(Rsh16Ux8 x y) left:(Lsh16x8 x z:(Sub8 (Const8 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh16Ux8 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh16x8 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpAdd32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (Add32 (Const32 [c]) (Const32 [d])) |
| // result: (Const32 [c+d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(c + d) |
| return true |
| } |
| break |
| } |
| // match: (Add32 <t> (Mul32 x y) (Mul32 x z)) |
| // result: (Mul32 x (Add32 <t> y z)) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpMul32 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| y := v_0_1 |
| if v_1.Op != ssaop.OpMul32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| z := v_1_1 |
| v.Reset(ssaop.OpMul32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, t) |
| v0.AddArg2(y, z) |
| v.AddArg2(x, v0) |
| return true |
| } |
| } |
| } |
| break |
| } |
| // match: (Add32 x x) |
| // result: (Lsh32x64 x (Const64 <types.Types[types.TUINT64]> [1])) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpLsh32x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Add32 (Const32 [0]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Add32 x (Neg32 y)) |
| // result: (Sub32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg32 { |
| continue |
| } |
| y := v_1.Args[0] |
| v.Reset(ssaop.OpSub32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add32 (Com32 x) x) |
| // result: (Const32 [-1]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom32 { |
| continue |
| } |
| x := v_0.Args[0] |
| if x != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(-1) |
| return true |
| } |
| break |
| } |
| // match: (Add32 (Sub32 x t) (Add32 t y)) |
| // result: (Add32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpSub32 { |
| continue |
| } |
| t := v_0.Args[1] |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpAdd32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if t != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpAdd32) |
| v.AddArg2(x, y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Add32 (Const32 [1]) (Com32 x)) |
| // result: (Neg32 x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 1 || v_1.Op != ssaop.OpCom32 { |
| continue |
| } |
| x := v_1.Args[0] |
| v.Reset(ssaop.OpNeg32) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| // match: (Add32 x (Sub32 y x)) |
| // result: y |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if x != v_1.Args[1] { |
| continue |
| } |
| v.CopyOf(y) |
| return true |
| } |
| break |
| } |
| // match: (Add32 x (Add32 y (Sub32 z x))) |
| // result: (Add32 y z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = v_1_1.Args[1] |
| z := v_1_1.Args[0] |
| if x != v_1_1.Args[1] { |
| continue |
| } |
| v.Reset(ssaop.OpAdd32) |
| v.AddArg2(y, z) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Add32 x (Sub32 y (Sub32 x z))) |
| // result: (Add32 y z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| z := v_1_1.Args[1] |
| if x != v_1_1.Args[0] { |
| continue |
| } |
| v.Reset(ssaop.OpAdd32) |
| v.AddArg2(y, z) |
| return true |
| } |
| break |
| } |
| // match: (Add32 (Add32 i:(Const32 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) |
| // result: (Add32 i (Add32 <t> z x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAdd32 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Add32 (Sub32 i:(Const32 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) |
| // result: (Add32 i (Sub32 <t> x z)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpSub32 { |
| continue |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := i.Type |
| x := v_1 |
| if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub32, t) |
| v0.AddArg2(x, z) |
| v.AddArg2(i, v0) |
| return true |
| } |
| break |
| } |
| // match: (Add32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x)) |
| // result: (Add32 (Const32 <t> [c+d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpAdd32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst32 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpAdd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(c + d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Add32 (Const32 <t> [c]) (Sub32 (Const32 <t> [d]) x)) |
| // result: (Sub32 (Const32 <t> [c+d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst32 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_0.AuxInt) |
| v.Reset(ssaop.OpSub32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(c + d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Add32 (Lsh32x64 x z:(Const64 <t> [c])) (Rsh32Ux64 x (Const64 [d]))) |
| // cond: c < 32 && d == 32-c && canRotate(config, 32) |
| // result: (RotateLeft32 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLsh32x64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| z := v_0.Args[1] |
| if z.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(z.AuxInt) |
| if v_1.Op != ssaop.OpRsh32Ux64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c < 32 && d == 32-c && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Add32 left:(Lsh32x64 x y) right:(Rsh32Ux64 x (Sub64 (Const64 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh32x64 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh32Ux64 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add32 left:(Lsh32x32 x y) right:(Rsh32Ux32 x (Sub32 (Const32 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh32x32 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh32Ux32 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add32 left:(Lsh32x16 x y) right:(Rsh32Ux16 x (Sub16 (Const16 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh32x16 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh32Ux16 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add32 left:(Lsh32x8 x y) right:(Rsh32Ux8 x (Sub8 (Const8 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh32x8 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh32Ux8 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add32 right:(Rsh32Ux64 x y) left:(Lsh32x64 x z:(Sub64 (Const64 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh32Ux64 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh32x64 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Add32 right:(Rsh32Ux32 x y) left:(Lsh32x32 x z:(Sub32 (Const32 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh32Ux32 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh32x32 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Add32 right:(Rsh32Ux16 x y) left:(Lsh32x16 x z:(Sub16 (Const16 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh32Ux16 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh32x16 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Add32 right:(Rsh32Ux8 x y) left:(Lsh32x8 x z:(Sub8 (Const8 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh32Ux8 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh32x8 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpAdd32F(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (Add32F (Const32F [c]) (Const32F [d])) |
| // cond: c+d == c+d |
| // result: (Const32F [c+d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32F { |
| continue |
| } |
| c := ssa.AuxIntToFloat32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32F { |
| continue |
| } |
| d := ssa.AuxIntToFloat32(v_1.AuxInt) |
| if !(c+d == c+d) { |
| continue |
| } |
| v.Reset(ssaop.OpConst32F) |
| v.AuxInt = ssa.Float32ToAuxInt(c + d) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpAdd64(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (Add64 (Const64 [c]) (Const64 [d])) |
| // result: (Const64 [c+d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(c + d) |
| return true |
| } |
| break |
| } |
| // match: (Add64 <t> (Mul64 x y) (Mul64 x z)) |
| // result: (Mul64 x (Add64 <t> y z)) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpMul64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| y := v_0_1 |
| if v_1.Op != ssaop.OpMul64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| z := v_1_1 |
| v.Reset(ssaop.OpMul64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, t) |
| v0.AddArg2(y, z) |
| v.AddArg2(x, v0) |
| return true |
| } |
| } |
| } |
| break |
| } |
| // match: (Add64 x x) |
| // result: (Lsh64x64 x (Const64 <types.Types[types.TUINT64]> [1])) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpLsh64x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Add64 (Const64 [0]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Add64 x (Neg64 y)) |
| // result: (Sub64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg64 { |
| continue |
| } |
| y := v_1.Args[0] |
| v.Reset(ssaop.OpSub64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add64 (Com64 x) x) |
| // result: (Const64 [-1]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom64 { |
| continue |
| } |
| x := v_0.Args[0] |
| if x != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(-1) |
| return true |
| } |
| break |
| } |
| // match: (Add64 (Sub64 x t) (Add64 t y)) |
| // result: (Add64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpSub64 { |
| continue |
| } |
| t := v_0.Args[1] |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpAdd64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if t != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpAdd64) |
| v.AddArg2(x, y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Add64 (Const64 [1]) (Com64 x)) |
| // result: (Neg64 x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 1 || v_1.Op != ssaop.OpCom64 { |
| continue |
| } |
| x := v_1.Args[0] |
| v.Reset(ssaop.OpNeg64) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| // match: (Add64 x (Sub64 y x)) |
| // result: y |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if x != v_1.Args[1] { |
| continue |
| } |
| v.CopyOf(y) |
| return true |
| } |
| break |
| } |
| // match: (Add64 x (Add64 y (Sub64 z x))) |
| // result: (Add64 y z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = v_1_1.Args[1] |
| z := v_1_1.Args[0] |
| if x != v_1_1.Args[1] { |
| continue |
| } |
| v.Reset(ssaop.OpAdd64) |
| v.AddArg2(y, z) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Add64 x (Sub64 y (Sub64 x z))) |
| // result: (Add64 y z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| z := v_1_1.Args[1] |
| if x != v_1_1.Args[0] { |
| continue |
| } |
| v.Reset(ssaop.OpAdd64) |
| v.AddArg2(y, z) |
| return true |
| } |
| break |
| } |
| // match: (Add64 (Add64 i:(Const64 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) |
| // result: (Add64 i (Add64 <t> z x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAdd64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Add64 (Sub64 i:(Const64 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) |
| // result: (Add64 i (Sub64 <t> x z)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpSub64 { |
| continue |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := i.Type |
| x := v_1 |
| if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub64, t) |
| v0.AddArg2(x, z) |
| v.AddArg2(i, v0) |
| return true |
| } |
| break |
| } |
| // match: (Add64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x)) |
| // result: (Add64 (Const64 <t> [c+d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpAdd64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst64 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpAdd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c + d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Add64 (Const64 <t> [c]) (Sub64 (Const64 <t> [d]) x)) |
| // result: (Sub64 (Const64 <t> [c+d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst64 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_0.AuxInt) |
| v.Reset(ssaop.OpSub64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c + d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Add64 (Lsh64x64 x z:(Const64 <t> [c])) (Rsh64Ux64 x (Const64 [d]))) |
| // cond: c < 64 && d == 64-c && canRotate(config, 64) |
| // result: (RotateLeft64 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLsh64x64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| z := v_0.Args[1] |
| if z.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(z.AuxInt) |
| if v_1.Op != ssaop.OpRsh64Ux64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c < 64 && d == 64-c && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Add64 left:(Lsh64x64 x y) right:(Rsh64Ux64 x (Sub64 (Const64 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh64x64 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh64Ux64 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add64 left:(Lsh64x32 x y) right:(Rsh64Ux32 x (Sub32 (Const32 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh64x32 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh64Ux32 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add64 left:(Lsh64x16 x y) right:(Rsh64Ux16 x (Sub16 (Const16 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh64x16 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh64Ux16 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add64 left:(Lsh64x8 x y) right:(Rsh64Ux8 x (Sub8 (Const8 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh64x8 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh64Ux8 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add64 right:(Rsh64Ux64 x y) left:(Lsh64x64 x z:(Sub64 (Const64 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh64Ux64 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh64x64 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Add64 right:(Rsh64Ux32 x y) left:(Lsh64x32 x z:(Sub32 (Const32 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh64Ux32 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh64x32 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Add64 right:(Rsh64Ux16 x y) left:(Lsh64x16 x z:(Sub16 (Const16 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh64Ux16 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh64x16 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Add64 right:(Rsh64Ux8 x y) left:(Lsh64x8 x z:(Sub8 (Const8 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh64Ux8 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh64x8 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpAdd64F(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (Add64F (Const64F [c]) (Const64F [d])) |
| // cond: c+d == c+d |
| // result: (Const64F [c+d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64F { |
| continue |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64F { |
| continue |
| } |
| d := ssa.AuxIntToFloat64(v_1.AuxInt) |
| if !(c+d == c+d) { |
| continue |
| } |
| v.Reset(ssaop.OpConst64F) |
| v.AuxInt = ssa.Float64ToAuxInt(c + d) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpAdd64carry(v *ssa.Value) bool { |
| v_2 := v.Args[2] |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Add64carry (Const64 <t> [x]) (Const64 [y]) (Const64 [c])) |
| // cond: c >= 0 && c <= 1 |
| // result: (MakeTuple (Const64 <t> [bitsAdd64(x, y, c).sum]) (Const64 <t> [bitsAdd64(x, y, c).carry])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| x := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| y := ssa.AuxIntToInt64(v_1.AuxInt) |
| if v_2.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_2.AuxInt) |
| if !(c >= 0 && c <= 1) { |
| continue |
| } |
| v.Reset(ssaop.OpMakeTuple) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(bitsAdd64(x, y, c).sum) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v1.AuxInt = ssa.Int64ToAuxInt(bitsAdd64(x, y, c).carry) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpAdd8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (Add8 (Const8 [c]) (Const8 [d])) |
| // result: (Const8 [c+d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(c + d) |
| return true |
| } |
| break |
| } |
| // match: (Add8 <t> (Mul8 x y) (Mul8 x z)) |
| // result: (Mul8 x (Add8 <t> y z)) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpMul8 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| y := v_0_1 |
| if v_1.Op != ssaop.OpMul8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| z := v_1_1 |
| v.Reset(ssaop.OpMul8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, t) |
| v0.AddArg2(y, z) |
| v.AddArg2(x, v0) |
| return true |
| } |
| } |
| } |
| break |
| } |
| // match: (Add8 x x) |
| // result: (Lsh8x64 x (Const64 <types.Types[types.TUINT64]> [1])) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpLsh8x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Add8 (Const8 [0]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Add8 x (Neg8 y)) |
| // result: (Sub8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg8 { |
| continue |
| } |
| y := v_1.Args[0] |
| v.Reset(ssaop.OpSub8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add8 (Com8 x) x) |
| // result: (Const8 [-1]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom8 { |
| continue |
| } |
| x := v_0.Args[0] |
| if x != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(-1) |
| return true |
| } |
| break |
| } |
| // match: (Add8 (Sub8 x t) (Add8 t y)) |
| // result: (Add8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpSub8 { |
| continue |
| } |
| t := v_0.Args[1] |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpAdd8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if t != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpAdd8) |
| v.AddArg2(x, y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Add8 (Const8 [1]) (Com8 x)) |
| // result: (Neg8 x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 1 || v_1.Op != ssaop.OpCom8 { |
| continue |
| } |
| x := v_1.Args[0] |
| v.Reset(ssaop.OpNeg8) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| // match: (Add8 x (Sub8 y x)) |
| // result: y |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if x != v_1.Args[1] { |
| continue |
| } |
| v.CopyOf(y) |
| return true |
| } |
| break |
| } |
| // match: (Add8 x (Add8 y (Sub8 z x))) |
| // result: (Add8 y z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = v_1_1.Args[1] |
| z := v_1_1.Args[0] |
| if x != v_1_1.Args[1] { |
| continue |
| } |
| v.Reset(ssaop.OpAdd8) |
| v.AddArg2(y, z) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Add8 x (Sub8 y (Sub8 x z))) |
| // result: (Add8 y z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| z := v_1_1.Args[1] |
| if x != v_1_1.Args[0] { |
| continue |
| } |
| v.Reset(ssaop.OpAdd8) |
| v.AddArg2(y, z) |
| return true |
| } |
| break |
| } |
| // match: (Add8 (Add8 i:(Const8 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) |
| // result: (Add8 i (Add8 <t> z x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAdd8 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Add8 (Sub8 i:(Const8 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) |
| // result: (Add8 i (Sub8 <t> x z)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpSub8 { |
| continue |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := i.Type |
| x := v_1 |
| if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub8, t) |
| v0.AddArg2(x, z) |
| v.AddArg2(i, v0) |
| return true |
| } |
| break |
| } |
| // match: (Add8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x)) |
| // result: (Add8 (Const8 <t> [c+d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpAdd8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst8 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpAdd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(c + d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Add8 (Const8 <t> [c]) (Sub8 (Const8 <t> [d]) x)) |
| // result: (Sub8 (Const8 <t> [c+d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst8 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_0.AuxInt) |
| v.Reset(ssaop.OpSub8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(c + d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Add8 (Lsh8x64 x z:(Const64 <t> [c])) (Rsh8Ux64 x (Const64 [d]))) |
| // cond: c < 8 && d == 8-c && canRotate(config, 8) |
| // result: (RotateLeft8 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLsh8x64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| z := v_0.Args[1] |
| if z.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(z.AuxInt) |
| if v_1.Op != ssaop.OpRsh8Ux64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c < 8 && d == 8-c && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Add8 left:(Lsh8x64 x y) right:(Rsh8Ux64 x (Sub64 (Const64 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh8x64 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh8Ux64 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add8 left:(Lsh8x32 x y) right:(Rsh8Ux32 x (Sub32 (Const32 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh8x32 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh8Ux32 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add8 left:(Lsh8x16 x y) right:(Rsh8Ux16 x (Sub16 (Const16 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh8x16 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh8Ux16 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add8 left:(Lsh8x8 x y) right:(Rsh8Ux8 x (Sub8 (Const8 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh8x8 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh8Ux8 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Add8 right:(Rsh8Ux64 x y) left:(Lsh8x64 x z:(Sub64 (Const64 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh8Ux64 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh8x64 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Add8 right:(Rsh8Ux32 x y) left:(Lsh8x32 x z:(Sub32 (Const32 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh8Ux32 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh8x32 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Add8 right:(Rsh8Ux16 x y) left:(Lsh8x16 x z:(Sub16 (Const16 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh8Ux16 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh8x16 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Add8 right:(Rsh8Ux8 x y) left:(Lsh8x8 x z:(Sub8 (Const8 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh8Ux8 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh8x8 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpAddPtr(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (AddPtr <t> x (Const64 [c])) |
| // result: (OffPtr <t> x [c]) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpOffPtr) |
| v.Type = t |
| v.AuxInt = ssa.Int64ToAuxInt(c) |
| v.AddArg(x) |
| return true |
| } |
| // match: (AddPtr <t> x (Const32 [c])) |
| // result: (OffPtr <t> x [int64(c)]) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpOffPtr) |
| v.Type = t |
| v.AuxInt = ssa.Int64ToAuxInt(int64(c)) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpAnd16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (And16 (Const16 [c]) (Const16 [d])) |
| // result: (Const16 [c&d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(c & d) |
| return true |
| } |
| break |
| } |
| // match: (And16 <t> (Com16 x) (Com16 y)) |
| // result: (Com16 (Or16 <t> x y)) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom16 { |
| continue |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpCom16 { |
| continue |
| } |
| y := v_1.Args[0] |
| v.Reset(ssaop.OpCom16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr16, t) |
| v0.AddArg2(x, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (And16 x (Or16 x y)) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpOr16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (And16 (Const16 [m]) (Rsh16Ux64 _ (Const64 [c]))) |
| // cond: c >= int64(16-ntz16(m)) |
| // result: (Const16 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| m := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpRsh16Ux64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c >= int64(16-ntz16(m))) { |
| continue |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (And16 (Const16 [m]) (Lsh16x64 _ (Const64 [c]))) |
| // cond: c >= int64(16-nlz16(m)) |
| // result: (Const16 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| m := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpLsh16x64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c >= int64(16-nlz16(m))) { |
| continue |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (And16 x x) |
| // result: x |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (And16 (Const16 [-1]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != -1 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (And16 (Const16 [0]) _) |
| // result: (Const16 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| continue |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (And16 (Com16 x) x) |
| // result: (Const16 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom16 { |
| continue |
| } |
| x := v_0.Args[0] |
| if x != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (And16 x (And16 x y)) |
| // result: (And16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpAnd16) |
| v.AddArg2(x, y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (And16 (And16 i:(Const16 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) |
| // result: (And16 i (And16 <t> z x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAnd16 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd16, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (And16 (Const16 <t> [c]) (And16 (Const16 <t> [d]) x)) |
| // result: (And16 (Const16 <t> [c&d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpAnd16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst16 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpAnd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(c & d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpAnd32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (And32 (Const32 [c]) (Const32 [d])) |
| // result: (Const32 [c&d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(c & d) |
| return true |
| } |
| break |
| } |
| // match: (And32 <t> (Com32 x) (Com32 y)) |
| // result: (Com32 (Or32 <t> x y)) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom32 { |
| continue |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpCom32 { |
| continue |
| } |
| y := v_1.Args[0] |
| v.Reset(ssaop.OpCom32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, t) |
| v0.AddArg2(x, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (And32 x (Or32 x y)) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpOr32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (And32 (Const32 [m]) (Rsh32Ux64 _ (Const64 [c]))) |
| // cond: c >= int64(32-ntz32(m)) |
| // result: (Const32 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| m := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpRsh32Ux64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c >= int64(32-ntz32(m))) { |
| continue |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (And32 (Const32 [m]) (Lsh32x64 _ (Const64 [c]))) |
| // cond: c >= int64(32-nlz32(m)) |
| // result: (Const32 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| m := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpLsh32x64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c >= int64(32-nlz32(m))) { |
| continue |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (And32 x x) |
| // result: x |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (And32 (Const32 [-1]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != -1 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (And32 (Const32 [0]) _) |
| // result: (Const32 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| continue |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (And32 (Com32 x) x) |
| // result: (Const32 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom32 { |
| continue |
| } |
| x := v_0.Args[0] |
| if x != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (And32 x (And32 x y)) |
| // result: (And32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpAnd32) |
| v.AddArg2(x, y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (And32 (And32 i:(Const32 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) |
| // result: (And32 i (And32 <t> z x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAnd32 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd32, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (And32 (Const32 <t> [c]) (And32 (Const32 <t> [d]) x)) |
| // result: (And32 (Const32 <t> [c&d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpAnd32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst32 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpAnd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(c & d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpAnd64(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (And64 (Const64 [c]) (Const64 [d])) |
| // result: (Const64 [c&d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(c & d) |
| return true |
| } |
| break |
| } |
| // match: (And64 <t> (Com64 x) (Com64 y)) |
| // result: (Com64 (Or64 <t> x y)) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom64 { |
| continue |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpCom64 { |
| continue |
| } |
| y := v_1.Args[0] |
| v.Reset(ssaop.OpCom64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr64, t) |
| v0.AddArg2(x, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (And64 x (Or64 x y)) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpOr64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (And64 (Const64 [m]) (Rsh64Ux64 _ (Const64 [c]))) |
| // cond: c >= int64(64-ssa.Ntz64(m)) |
| // result: (Const64 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| m := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpRsh64Ux64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c >= int64(64-ssa.Ntz64(m))) { |
| continue |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (And64 (Const64 [m]) (Lsh64x64 _ (Const64 [c]))) |
| // cond: c >= int64(64-nlz64(m)) |
| // result: (Const64 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| m := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpLsh64x64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c >= int64(64-nlz64(m))) { |
| continue |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (And64 x x) |
| // result: x |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (And64 (Const64 [-1]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != -1 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (And64 (Const64 [0]) _) |
| // result: (Const64 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| continue |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (And64 (Com64 x) x) |
| // result: (Const64 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom64 { |
| continue |
| } |
| x := v_0.Args[0] |
| if x != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (And64 x (And64 x y)) |
| // result: (And64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpAnd64) |
| v.AddArg2(x, y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (And64 (And64 i:(Const64 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) |
| // result: (And64 i (And64 <t> z x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAnd64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd64, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (And64 (Const64 <t> [c]) (And64 (Const64 <t> [d]) x)) |
| // result: (And64 (Const64 <t> [c&d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpAnd64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst64 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpAnd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c & d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpAnd8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (And8 (Const8 [c]) (Const8 [d])) |
| // result: (Const8 [c&d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(c & d) |
| return true |
| } |
| break |
| } |
| // match: (And8 <t> (Com8 x) (Com8 y)) |
| // result: (Com8 (Or8 <t> x y)) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom8 { |
| continue |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpCom8 { |
| continue |
| } |
| y := v_1.Args[0] |
| v.Reset(ssaop.OpCom8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr8, t) |
| v0.AddArg2(x, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (And8 x (Or8 x y)) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpOr8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (And8 (Const8 [m]) (Rsh8Ux64 _ (Const64 [c]))) |
| // cond: c >= int64(8-ntz8(m)) |
| // result: (Const8 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| m := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpRsh8Ux64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c >= int64(8-ntz8(m))) { |
| continue |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (And8 (Const8 [m]) (Lsh8x64 _ (Const64 [c]))) |
| // cond: c >= int64(8-nlz8(m)) |
| // result: (Const8 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| m := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpLsh8x64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c >= int64(8-nlz8(m))) { |
| continue |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (And8 x x) |
| // result: x |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (And8 (Const8 [-1]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != -1 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (And8 (Const8 [0]) _) |
| // result: (Const8 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| continue |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (And8 (Com8 x) x) |
| // result: (Const8 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom8 { |
| continue |
| } |
| x := v_0.Args[0] |
| if x != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (And8 x (And8 x y)) |
| // result: (And8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpAnd8) |
| v.AddArg2(x, y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (And8 (And8 i:(Const8 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) |
| // result: (And8 i (And8 <t> z x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAnd8 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd8, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (And8 (Const8 <t> [c]) (And8 (Const8 <t> [d]) x)) |
| // result: (And8 (Const8 <t> [c&d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpAnd8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst8 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpAnd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(c & d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpAndB(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (AndB (ConstBool [c]) (ConstBool [d])) |
| // result: (ConstBool [c&&d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConstBool { |
| continue |
| } |
| c := ssa.AuxIntToBool(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConstBool { |
| continue |
| } |
| d := ssa.AuxIntToBool(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c && d) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Leq64 (Const64 [c]) x) (Less64 x (Const64 [d]))) |
| // cond: d >= c |
| // result: (Less64U (Sub64 <x.Type> x (Const64 <x.Type> [c])) (Const64 <x.Type> [d-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq64 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(d >= c) { |
| continue |
| } |
| v.Reset(ssaop.OpLess64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d - c) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Leq64 (Const64 [c]) x) (Leq64 x (Const64 [d]))) |
| // cond: d >= c |
| // result: (Leq64U (Sub64 <x.Type> x (Const64 <x.Type> [c])) (Const64 <x.Type> [d-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq64 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(d >= c) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d - c) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Leq32 (Const32 [c]) x) (Less32 x (Const32 [d]))) |
| // cond: d >= c |
| // result: (Less32U (Sub32 <x.Type> x (Const32 <x.Type> [c])) (Const32 <x.Type> [d-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq32 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(d >= c) { |
| continue |
| } |
| v.Reset(ssaop.OpLess32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v1.AuxInt = ssa.Int32ToAuxInt(c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d - c) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Leq32 (Const32 [c]) x) (Leq32 x (Const32 [d]))) |
| // cond: d >= c |
| // result: (Leq32U (Sub32 <x.Type> x (Const32 <x.Type> [c])) (Const32 <x.Type> [d-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq32 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(d >= c) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v1.AuxInt = ssa.Int32ToAuxInt(c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d - c) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Leq16 (Const16 [c]) x) (Less16 x (Const16 [d]))) |
| // cond: d >= c |
| // result: (Less16U (Sub16 <x.Type> x (Const16 <x.Type> [c])) (Const16 <x.Type> [d-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq16 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(d >= c) { |
| continue |
| } |
| v.Reset(ssaop.OpLess16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v1.AuxInt = ssa.Int16ToAuxInt(c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d - c) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Leq16 (Const16 [c]) x) (Leq16 x (Const16 [d]))) |
| // cond: d >= c |
| // result: (Leq16U (Sub16 <x.Type> x (Const16 <x.Type> [c])) (Const16 <x.Type> [d-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq16 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(d >= c) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v1.AuxInt = ssa.Int16ToAuxInt(c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d - c) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Leq8 (Const8 [c]) x) (Less8 x (Const8 [d]))) |
| // cond: d >= c |
| // result: (Less8U (Sub8 <x.Type> x (Const8 <x.Type> [c])) (Const8 <x.Type> [d-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq8 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(d >= c) { |
| continue |
| } |
| v.Reset(ssaop.OpLess8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v1.AuxInt = ssa.Int8ToAuxInt(c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d - c) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Leq8 (Const8 [c]) x) (Leq8 x (Const8 [d]))) |
| // cond: d >= c |
| // result: (Leq8U (Sub8 <x.Type> x (Const8 <x.Type> [c])) (Const8 <x.Type> [d-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq8 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(d >= c) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v1.AuxInt = ssa.Int8ToAuxInt(c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d - c) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Less64 (Const64 [c]) x) (Less64 x (Const64 [d]))) |
| // cond: d >= c+1 && c+1 > c |
| // result: (Less64U (Sub64 <x.Type> x (Const64 <x.Type> [c+1])) (Const64 <x.Type> [d-c-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess64 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(d >= c+1 && c+1 > c) { |
| continue |
| } |
| v.Reset(ssaop.OpLess64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(c + 1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d - c - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Less64 (Const64 [c]) x) (Leq64 x (Const64 [d]))) |
| // cond: d >= c+1 && c+1 > c |
| // result: (Leq64U (Sub64 <x.Type> x (Const64 <x.Type> [c+1])) (Const64 <x.Type> [d-c-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess64 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(d >= c+1 && c+1 > c) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(c + 1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d - c - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Less32 (Const32 [c]) x) (Less32 x (Const32 [d]))) |
| // cond: d >= c+1 && c+1 > c |
| // result: (Less32U (Sub32 <x.Type> x (Const32 <x.Type> [c+1])) (Const32 <x.Type> [d-c-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess32 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(d >= c+1 && c+1 > c) { |
| continue |
| } |
| v.Reset(ssaop.OpLess32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v1.AuxInt = ssa.Int32ToAuxInt(c + 1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d - c - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Less32 (Const32 [c]) x) (Leq32 x (Const32 [d]))) |
| // cond: d >= c+1 && c+1 > c |
| // result: (Leq32U (Sub32 <x.Type> x (Const32 <x.Type> [c+1])) (Const32 <x.Type> [d-c-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess32 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(d >= c+1 && c+1 > c) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v1.AuxInt = ssa.Int32ToAuxInt(c + 1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d - c - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Less16 (Const16 [c]) x) (Less16 x (Const16 [d]))) |
| // cond: d >= c+1 && c+1 > c |
| // result: (Less16U (Sub16 <x.Type> x (Const16 <x.Type> [c+1])) (Const16 <x.Type> [d-c-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess16 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(d >= c+1 && c+1 > c) { |
| continue |
| } |
| v.Reset(ssaop.OpLess16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v1.AuxInt = ssa.Int16ToAuxInt(c + 1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d - c - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Less16 (Const16 [c]) x) (Leq16 x (Const16 [d]))) |
| // cond: d >= c+1 && c+1 > c |
| // result: (Leq16U (Sub16 <x.Type> x (Const16 <x.Type> [c+1])) (Const16 <x.Type> [d-c-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess16 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(d >= c+1 && c+1 > c) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v1.AuxInt = ssa.Int16ToAuxInt(c + 1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d - c - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Less8 (Const8 [c]) x) (Less8 x (Const8 [d]))) |
| // cond: d >= c+1 && c+1 > c |
| // result: (Less8U (Sub8 <x.Type> x (Const8 <x.Type> [c+1])) (Const8 <x.Type> [d-c-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess8 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(d >= c+1 && c+1 > c) { |
| continue |
| } |
| v.Reset(ssaop.OpLess8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v1.AuxInt = ssa.Int8ToAuxInt(c + 1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d - c - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Less8 (Const8 [c]) x) (Leq8 x (Const8 [d]))) |
| // cond: d >= c+1 && c+1 > c |
| // result: (Leq8U (Sub8 <x.Type> x (Const8 <x.Type> [c+1])) (Const8 <x.Type> [d-c-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess8 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(d >= c+1 && c+1 > c) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v1.AuxInt = ssa.Int8ToAuxInt(c + 1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d - c - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Leq64U (Const64 [c]) x) (Less64U x (Const64 [d]))) |
| // cond: uint64(d) >= uint64(c) |
| // result: (Less64U (Sub64 <x.Type> x (Const64 <x.Type> [c])) (Const64 <x.Type> [d-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq64U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess64U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(uint64(d) >= uint64(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpLess64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d - c) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Leq64U (Const64 [c]) x) (Leq64U x (Const64 [d]))) |
| // cond: uint64(d) >= uint64(c) |
| // result: (Leq64U (Sub64 <x.Type> x (Const64 <x.Type> [c])) (Const64 <x.Type> [d-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq64U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq64U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(uint64(d) >= uint64(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d - c) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Leq32U (Const32 [c]) x) (Less32U x (Const32 [d]))) |
| // cond: uint32(d) >= uint32(c) |
| // result: (Less32U (Sub32 <x.Type> x (Const32 <x.Type> [c])) (Const32 <x.Type> [d-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq32U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess32U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(uint32(d) >= uint32(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpLess32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v1.AuxInt = ssa.Int32ToAuxInt(c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d - c) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Leq32U (Const32 [c]) x) (Leq32U x (Const32 [d]))) |
| // cond: uint32(d) >= uint32(c) |
| // result: (Leq32U (Sub32 <x.Type> x (Const32 <x.Type> [c])) (Const32 <x.Type> [d-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq32U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq32U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(uint32(d) >= uint32(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v1.AuxInt = ssa.Int32ToAuxInt(c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d - c) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Leq16U (Const16 [c]) x) (Less16U x (Const16 [d]))) |
| // cond: uint16(d) >= uint16(c) |
| // result: (Less16U (Sub16 <x.Type> x (Const16 <x.Type> [c])) (Const16 <x.Type> [d-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq16U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess16U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(uint16(d) >= uint16(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpLess16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v1.AuxInt = ssa.Int16ToAuxInt(c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d - c) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Leq16U (Const16 [c]) x) (Leq16U x (Const16 [d]))) |
| // cond: uint16(d) >= uint16(c) |
| // result: (Leq16U (Sub16 <x.Type> x (Const16 <x.Type> [c])) (Const16 <x.Type> [d-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq16U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq16U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(uint16(d) >= uint16(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v1.AuxInt = ssa.Int16ToAuxInt(c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d - c) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Leq8U (Const8 [c]) x) (Less8U x (Const8 [d]))) |
| // cond: uint8(d) >= uint8(c) |
| // result: (Less8U (Sub8 <x.Type> x (Const8 <x.Type> [c])) (Const8 <x.Type> [d-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq8U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess8U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(uint8(d) >= uint8(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpLess8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v1.AuxInt = ssa.Int8ToAuxInt(c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d - c) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Leq8U (Const8 [c]) x) (Leq8U x (Const8 [d]))) |
| // cond: uint8(d) >= uint8(c) |
| // result: (Leq8U (Sub8 <x.Type> x (Const8 <x.Type> [c])) (Const8 <x.Type> [d-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq8U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq8U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(uint8(d) >= uint8(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v1.AuxInt = ssa.Int8ToAuxInt(c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d - c) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Less64U (Const64 [c]) x) (Less64U x (Const64 [d]))) |
| // cond: uint64(d) >= uint64(c+1) && uint64(c+1) > uint64(c) |
| // result: (Less64U (Sub64 <x.Type> x (Const64 <x.Type> [c+1])) (Const64 <x.Type> [d-c-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess64U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess64U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(uint64(d) >= uint64(c+1) && uint64(c+1) > uint64(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpLess64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(c + 1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d - c - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Less64U (Const64 [c]) x) (Leq64U x (Const64 [d]))) |
| // cond: uint64(d) >= uint64(c+1) && uint64(c+1) > uint64(c) |
| // result: (Leq64U (Sub64 <x.Type> x (Const64 <x.Type> [c+1])) (Const64 <x.Type> [d-c-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess64U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq64U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(uint64(d) >= uint64(c+1) && uint64(c+1) > uint64(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(c + 1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d - c - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Less32U (Const32 [c]) x) (Less32U x (Const32 [d]))) |
| // cond: uint32(d) >= uint32(c+1) && uint32(c+1) > uint32(c) |
| // result: (Less32U (Sub32 <x.Type> x (Const32 <x.Type> [c+1])) (Const32 <x.Type> [d-c-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess32U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess32U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(uint32(d) >= uint32(c+1) && uint32(c+1) > uint32(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpLess32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v1.AuxInt = ssa.Int32ToAuxInt(c + 1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d - c - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Less32U (Const32 [c]) x) (Leq32U x (Const32 [d]))) |
| // cond: uint32(d) >= uint32(c+1) && uint32(c+1) > uint32(c) |
| // result: (Leq32U (Sub32 <x.Type> x (Const32 <x.Type> [c+1])) (Const32 <x.Type> [d-c-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess32U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq32U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(uint32(d) >= uint32(c+1) && uint32(c+1) > uint32(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v1.AuxInt = ssa.Int32ToAuxInt(c + 1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d - c - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Less16U (Const16 [c]) x) (Less16U x (Const16 [d]))) |
| // cond: uint16(d) >= uint16(c+1) && uint16(c+1) > uint16(c) |
| // result: (Less16U (Sub16 <x.Type> x (Const16 <x.Type> [c+1])) (Const16 <x.Type> [d-c-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess16U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess16U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(uint16(d) >= uint16(c+1) && uint16(c+1) > uint16(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpLess16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v1.AuxInt = ssa.Int16ToAuxInt(c + 1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d - c - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Less16U (Const16 [c]) x) (Leq16U x (Const16 [d]))) |
| // cond: uint16(d) >= uint16(c+1) && uint16(c+1) > uint16(c) |
| // result: (Leq16U (Sub16 <x.Type> x (Const16 <x.Type> [c+1])) (Const16 <x.Type> [d-c-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess16U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq16U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(uint16(d) >= uint16(c+1) && uint16(c+1) > uint16(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v1.AuxInt = ssa.Int16ToAuxInt(c + 1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d - c - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Less8U (Const8 [c]) x) (Less8U x (Const8 [d]))) |
| // cond: uint8(d) >= uint8(c+1) && uint8(c+1) > uint8(c) |
| // result: (Less8U (Sub8 <x.Type> x (Const8 <x.Type> [c+1])) (Const8 <x.Type> [d-c-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess8U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess8U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(uint8(d) >= uint8(c+1) && uint8(c+1) > uint8(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpLess8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v1.AuxInt = ssa.Int8ToAuxInt(c + 1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d - c - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Less8U (Const8 [c]) x) (Leq8U x (Const8 [d]))) |
| // cond: uint8(d) >= uint8(c+1) && uint8(c+1) > uint8(c) |
| // result: (Leq8U (Sub8 <x.Type> x (Const8 <x.Type> [c+1])) (Const8 <x.Type> [d-c-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess8U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq8U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(uint8(d) >= uint8(c+1) && uint8(c+1) > uint8(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v1.AuxInt = ssa.Int8ToAuxInt(c + 1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d - c - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (AndB (Neq64 x (Const64 [0])) (Less64U x (Const64 [d]))) |
| // cond: uint64(d) >= 1 |
| // result: (Less64U (Sub64 <x.Type> x (Const64 <x.Type> [1])) (Const64 <x.Type> [d-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 0 || v_1.Op != ssaop.OpLess64U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(uint64(d) >= 1) { |
| continue |
| } |
| v.Reset(ssaop.OpLess64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| } |
| break |
| } |
| // match: (AndB (Neq64 x (Const64 [0])) (Leq64U x (Const64 [d]))) |
| // cond: uint64(d) >= 1 |
| // result: (Leq64U (Sub64 <x.Type> x (Const64 <x.Type> [1])) (Const64 <x.Type> [d-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 0 || v_1.Op != ssaop.OpLeq64U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(uint64(d) >= 1) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| } |
| break |
| } |
| // match: (AndB (Neq32 x (Const32 [0])) (Less32U x (Const32 [d]))) |
| // cond: uint32(d) >= 1 |
| // result: (Less32U (Sub32 <x.Type> x (Const32 <x.Type> [1])) (Const32 <x.Type> [d-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq32 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0_1.AuxInt) != 0 || v_1.Op != ssaop.OpLess32U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(uint32(d) >= 1) { |
| continue |
| } |
| v.Reset(ssaop.OpLess32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v1.AuxInt = ssa.Int32ToAuxInt(1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| } |
| break |
| } |
| // match: (AndB (Neq32 x (Const32 [0])) (Leq32U x (Const32 [d]))) |
| // cond: uint32(d) >= 1 |
| // result: (Leq32U (Sub32 <x.Type> x (Const32 <x.Type> [1])) (Const32 <x.Type> [d-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq32 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0_1.AuxInt) != 0 || v_1.Op != ssaop.OpLeq32U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(uint32(d) >= 1) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v1.AuxInt = ssa.Int32ToAuxInt(1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| } |
| break |
| } |
| // match: (AndB (Neq16 x (Const16 [0])) (Less16U x (Const16 [d]))) |
| // cond: uint16(d) >= 1 |
| // result: (Less16U (Sub16 <x.Type> x (Const16 <x.Type> [1])) (Const16 <x.Type> [d-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq16 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0_1.AuxInt) != 0 || v_1.Op != ssaop.OpLess16U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(uint16(d) >= 1) { |
| continue |
| } |
| v.Reset(ssaop.OpLess16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v1.AuxInt = ssa.Int16ToAuxInt(1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| } |
| break |
| } |
| // match: (AndB (Neq16 x (Const16 [0])) (Leq16U x (Const16 [d]))) |
| // cond: uint16(d) >= 1 |
| // result: (Leq16U (Sub16 <x.Type> x (Const16 <x.Type> [1])) (Const16 <x.Type> [d-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq16 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0_1.AuxInt) != 0 || v_1.Op != ssaop.OpLeq16U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(uint16(d) >= 1) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v1.AuxInt = ssa.Int16ToAuxInt(1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| } |
| break |
| } |
| // match: (AndB (Neq8 x (Const8 [0])) (Less8U x (Const8 [d]))) |
| // cond: uint8(d) >= 1 |
| // result: (Less8U (Sub8 <x.Type> x (Const8 <x.Type> [1])) (Const8 <x.Type> [d-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq8 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0_1.AuxInt) != 0 || v_1.Op != ssaop.OpLess8U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(uint8(d) >= 1) { |
| continue |
| } |
| v.Reset(ssaop.OpLess8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v1.AuxInt = ssa.Int8ToAuxInt(1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| } |
| break |
| } |
| // match: (AndB (Neq8 x (Const8 [0])) (Leq8U x (Const8 [d]))) |
| // cond: uint8(d) >= 1 |
| // result: (Leq8U (Sub8 <x.Type> x (Const8 <x.Type> [1])) (Const8 <x.Type> [d-1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq8 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0_1.AuxInt) != 0 || v_1.Op != ssaop.OpLeq8U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(uint8(d) >= 1) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v1.AuxInt = ssa.Int8ToAuxInt(1) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| } |
| break |
| } |
| // match: (AndB (Neq64 x cv:(Const64 [c])) (Neq64 x (Const64 [d]))) |
| // cond: c|d == c && ssa.OneBit(c^d) |
| // result: (Neq64 (Or64 <x.Type> x (Const64 <x.Type> [c^d])) cv) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| cv := v_0_1 |
| if cv.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(cv.AuxInt) |
| if v_1.Op != ssaop.OpNeq64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 { |
| if x != v_1_0 || v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c|d == c && ssa.OneBit(c^d)) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr64, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(c ^ d) |
| v0.AddArg2(x, v1) |
| v.AddArg2(v0, cv) |
| return true |
| } |
| } |
| } |
| break |
| } |
| // match: (AndB (Neq32 x cv:(Const32 [c])) (Neq32 x (Const32 [d]))) |
| // cond: c|d == c && ssa.OneBit(c^d) |
| // result: (Neq32 (Or32 <x.Type> x (Const32 <x.Type> [c^d])) cv) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq32 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| cv := v_0_1 |
| if cv.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(cv.AuxInt) |
| if v_1.Op != ssaop.OpNeq32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 { |
| if x != v_1_0 || v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(c|d == c && ssa.OneBit(c^d)) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v1.AuxInt = ssa.Int32ToAuxInt(c ^ d) |
| v0.AddArg2(x, v1) |
| v.AddArg2(v0, cv) |
| return true |
| } |
| } |
| } |
| break |
| } |
| // match: (AndB (Neq16 x cv:(Const16 [c])) (Neq16 x (Const16 [d]))) |
| // cond: c|d == c && ssa.OneBit(c^d) |
| // result: (Neq16 (Or16 <x.Type> x (Const16 <x.Type> [c^d])) cv) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq16 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| cv := v_0_1 |
| if cv.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(cv.AuxInt) |
| if v_1.Op != ssaop.OpNeq16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 { |
| if x != v_1_0 || v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(c|d == c && ssa.OneBit(c^d)) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr16, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v1.AuxInt = ssa.Int16ToAuxInt(c ^ d) |
| v0.AddArg2(x, v1) |
| v.AddArg2(v0, cv) |
| return true |
| } |
| } |
| } |
| break |
| } |
| // match: (AndB (Neq8 x cv:(Const8 [c])) (Neq8 x (Const8 [d]))) |
| // cond: c|d == c && ssa.OneBit(c^d) |
| // result: (Neq8 (Or8 <x.Type> x (Const8 <x.Type> [c^d])) cv) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq8 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| cv := v_0_1 |
| if cv.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(cv.AuxInt) |
| if v_1.Op != ssaop.OpNeq8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 { |
| if x != v_1_0 || v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(c|d == c && ssa.OneBit(c^d)) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr8, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v1.AuxInt = ssa.Int8ToAuxInt(c ^ d) |
| v0.AddArg2(x, v1) |
| v.AddArg2(v0, cv) |
| return true |
| } |
| } |
| } |
| break |
| } |
| // match: (AndB x x) |
| // result: x |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (AndB (ConstBool [true]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != true { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (AndB (ConstBool [false]) _) |
| // result: (ConstBool [false]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != false { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpArraySelect(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (ArraySelect (ArrayMake1 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpArrayMake1 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (ArraySelect [0] (IData x)) |
| // result: (IData x) |
| for { |
| if ssa.AuxIntToInt64(v.AuxInt) != 0 || v_0.Op != ssaop.OpIData { |
| break |
| } |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpIData) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpBitLen16(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (BitLen16 (Const16 [c])) |
| // cond: config.PtrSize == 8 |
| // result: (Const64 [int64(bits.Len16(uint16(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if !(config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(bits.Len16(uint16(c)))) |
| return true |
| } |
| // match: (BitLen16 (Const16 [c])) |
| // cond: config.PtrSize == 4 |
| // result: (Const32 [int32(bits.Len16(uint16(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(bits.Len16(uint16(c)))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpBitLen32(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (BitLen32 (Const32 [c])) |
| // cond: config.PtrSize == 8 |
| // result: (Const64 [int64(bits.Len32(uint32(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if !(config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(bits.Len32(uint32(c)))) |
| return true |
| } |
| // match: (BitLen32 (Const32 [c])) |
| // cond: config.PtrSize == 4 |
| // result: (Const32 [int32(bits.Len32(uint32(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(bits.Len32(uint32(c)))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpBitLen64(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (BitLen64 (Const64 [c])) |
| // cond: config.PtrSize == 8 |
| // result: (Const64 [int64(bits.Len64(uint64(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if !(config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(bits.Len64(uint64(c)))) |
| return true |
| } |
| // match: (BitLen64 (Const64 [c])) |
| // cond: config.PtrSize == 4 |
| // result: (Const32 [int32(bits.Len64(uint64(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(bits.Len64(uint64(c)))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpBitLen8(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (BitLen8 (Const8 [c])) |
| // cond: config.PtrSize == 8 |
| // result: (Const64 [int64(bits.Len8(uint8(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if !(config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(bits.Len8(uint8(c)))) |
| return true |
| } |
| // match: (BitLen8 (Const8 [c])) |
| // cond: config.PtrSize == 4 |
| // result: (Const32 [int32(bits.Len8(uint8(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(bits.Len8(uint8(c)))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpBitRev16(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (BitRev16 (Const16 [c])) |
| // result: (Const16 [int16(bits.Reverse16(uint16(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(int16(bits.Reverse16(uint16(c)))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpBitRev32(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (BitRev32 (Const32 [c])) |
| // result: (Const32 [int32(bits.Reverse32(uint32(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(bits.Reverse32(uint32(c)))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpBitRev64(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (BitRev64 (Const64 [c])) |
| // result: (Const64 [int64(bits.Reverse64(uint64(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(bits.Reverse64(uint64(c)))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpBitRev8(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (BitRev8 (Const8 [c])) |
| // result: (Const8 [int8(bits.Reverse8(uint8(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(int8(bits.Reverse8(uint8(c)))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpBswap16(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Bswap16 (Const16 [c])) |
| // result: (Const16 [int16(bits.ReverseBytes16(uint16(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(int16(bits.ReverseBytes16(uint16(c)))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpBswap32(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Bswap32 (Const32 [c])) |
| // result: (Const32 [int32(bits.ReverseBytes32(uint32(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(bits.ReverseBytes32(uint32(c)))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpBswap64(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Bswap64 (Const64 [c])) |
| // result: (Const64 [int64(bits.ReverseBytes64(uint64(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(bits.ReverseBytes64(uint64(c)))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpCeil(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Ceil (Const64F [c])) |
| // result: (Const64F [math.Ceil(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst64F { |
| break |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64F) |
| v.AuxInt = ssa.Float64ToAuxInt(math.Ceil(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpCom16(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Com16 (Com16 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpCom16 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Com16 (Const16 [c])) |
| // result: (Const16 [^c]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(^c) |
| return true |
| } |
| // match: (Com16 (Add16 (Const16 [-1]) x)) |
| // result: (Neg16 x) |
| for { |
| if v_0.Op != ssaop.OpAdd16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0_0.AuxInt) != -1 { |
| continue |
| } |
| x := v_0_1 |
| v.Reset(ssaop.OpNeg16) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpCom32(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Com32 (Com32 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpCom32 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Com32 (Const32 [c])) |
| // result: (Const32 [^c]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(^c) |
| return true |
| } |
| // match: (Com32 (Add32 (Const32 [-1]) x)) |
| // result: (Neg32 x) |
| for { |
| if v_0.Op != ssaop.OpAdd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0_0.AuxInt) != -1 { |
| continue |
| } |
| x := v_0_1 |
| v.Reset(ssaop.OpNeg32) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpCom64(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Com64 (Com64 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpCom64 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Com64 (Const64 [c])) |
| // result: (Const64 [^c]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(^c) |
| return true |
| } |
| // match: (Com64 (Add64 (Const64 [-1]) x)) |
| // result: (Neg64 x) |
| for { |
| if v_0.Op != ssaop.OpAdd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_0.AuxInt) != -1 { |
| continue |
| } |
| x := v_0_1 |
| v.Reset(ssaop.OpNeg64) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpCom8(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Com8 (Com8 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpCom8 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Com8 (Const8 [c])) |
| // result: (Const8 [^c]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(^c) |
| return true |
| } |
| // match: (Com8 (Add8 (Const8 [-1]) x)) |
| // result: (Neg8 x) |
| for { |
| if v_0.Op != ssaop.OpAdd8 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0_0.AuxInt) != -1 { |
| continue |
| } |
| x := v_0_1 |
| v.Reset(ssaop.OpNeg8) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpCondSelect(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: (CondSelect x _ (ConstBool [true ])) |
| // result: x |
| for { |
| x := v_0 |
| if v_2.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_2.AuxInt) != true { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (CondSelect _ y (ConstBool [false])) |
| // result: y |
| for { |
| y := v_1 |
| if v_2.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_2.AuxInt) != false { |
| break |
| } |
| v.CopyOf(y) |
| return true |
| } |
| // match: (CondSelect x x _) |
| // result: x |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (CondSelect op1:(Add8 <t> x c:(Const8)) x bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Add8 x (Mul8 <t> c (CvtBoolToUint8 <t> bool))) |
| for { |
| op1 := v_0 |
| if op1.Op != ssaop.OpAdd8 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| x := op1_0 |
| c := op1_1 |
| if c.Op != ssaop.OpConst8 || x != v_1 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, t) |
| v1.AddArg(bool) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect op1:(Add64 <t> x c:(Const64)) x bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Add64 x (Mul64 <t> c (ZeroExt8to64 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)))) |
| for { |
| op1 := v_0 |
| if op1.Op != ssaop.OpAdd64 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| x := op1_0 |
| c := op1_1 |
| if c.Op != ssaop.OpConst64 || x != v_1 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v2.AddArg(bool) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect op1:(Add32 <t> x c:(Const32)) x bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Add32 x (Mul32 <t> c (ZeroExt8to32 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)))) |
| for { |
| op1 := v_0 |
| if op1.Op != ssaop.OpAdd32 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| x := op1_0 |
| c := op1_1 |
| if c.Op != ssaop.OpConst32 || x != v_1 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v2.AddArg(bool) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect op1:(Add16 <t> x c:(Const16)) x bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Add16 x (Mul16 <t> c (ZeroExt8to16 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)))) |
| for { |
| op1 := v_0 |
| if op1.Op != ssaop.OpAdd16 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| x := op1_0 |
| c := op1_1 |
| if c.Op != ssaop.OpConst16 || x != v_1 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v2.AddArg(bool) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect x op1:(Add8 <t> x c:(Const8)) bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Add8 x (Mul8 <t> c (CvtBoolToUint8 <t> (Not <bool.Type> bool)))) |
| for { |
| x := v_0 |
| op1 := v_1 |
| if op1.Op != ssaop.OpAdd8 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| if x != op1_0 { |
| continue |
| } |
| c := op1_1 |
| if c.Op != ssaop.OpConst8 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v2.AddArg(bool) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect x op1:(Add64 <t> x c:(Const64)) bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Add64 x (Mul64 <t> c (ZeroExt8to64 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))))) |
| for { |
| x := v_0 |
| op1 := v_1 |
| if op1.Op != ssaop.OpAdd64 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| if x != op1_0 { |
| continue |
| } |
| c := op1_1 |
| if c.Op != ssaop.OpConst64 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v3.AddArg(bool) |
| v2.AddArg(v3) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect x op1:(Add32 <t> x c:(Const32)) bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Add32 x (Mul32 <t> c (ZeroExt8to32 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))))) |
| for { |
| x := v_0 |
| op1 := v_1 |
| if op1.Op != ssaop.OpAdd32 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| if x != op1_0 { |
| continue |
| } |
| c := op1_1 |
| if c.Op != ssaop.OpConst32 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v3.AddArg(bool) |
| v2.AddArg(v3) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect x op1:(Add16 <t> x c:(Const16)) bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Add16 x (Mul16 <t> c (ZeroExt8to16 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))))) |
| for { |
| x := v_0 |
| op1 := v_1 |
| if op1.Op != ssaop.OpAdd16 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| if x != op1_0 { |
| continue |
| } |
| c := op1_1 |
| if c.Op != ssaop.OpConst16 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v3.AddArg(bool) |
| v2.AddArg(v3) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect op1:(Add8 <t> x c:(Const8 [consT])) x bool) |
| // cond: !rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt) |
| // result: (Sub8 x (Mul8 <t> (Const8 <t> [-consT]) (CvtBoolToUint8 <t> bool))) |
| for { |
| op1 := v_0 |
| if op1.Op != ssaop.OpAdd8 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| x := op1_0 |
| c := op1_1 |
| if c.Op != ssaop.OpConst8 { |
| continue |
| } |
| consT := ssa.AuxIntToInt8(c.AuxInt) |
| if x != v_1 { |
| continue |
| } |
| bool := v_2 |
| if !(!rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpSub8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v1.AuxInt = ssa.Int8ToAuxInt(-consT) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, t) |
| v2.AddArg(bool) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect op1:(Add64 <t> x c:(Const64 [consT])) x bool) |
| // cond: !rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt) |
| // result: (Sub64 x (Mul64 <t> (Const64 <t> [-consT]) (ZeroExt8to64 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)))) |
| for { |
| op1 := v_0 |
| if op1.Op != ssaop.OpAdd64 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| x := op1_0 |
| c := op1_1 |
| if c.Op != ssaop.OpConst64 { |
| continue |
| } |
| consT := ssa.AuxIntToInt64(c.AuxInt) |
| if x != v_1 { |
| continue |
| } |
| bool := v_2 |
| if !(!rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpSub64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v1.AuxInt = ssa.Int64ToAuxInt(-consT) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, t) |
| v3 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v3.AddArg(bool) |
| v2.AddArg(v3) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect op1:(Add32 <t> x c:(Const32 [consT])) x bool) |
| // cond: !rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt) |
| // result: (Sub32 x (Mul32 <t> (Const32 <t> [-consT]) (ZeroExt8to32 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)))) |
| for { |
| op1 := v_0 |
| if op1.Op != ssaop.OpAdd32 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| x := op1_0 |
| c := op1_1 |
| if c.Op != ssaop.OpConst32 { |
| continue |
| } |
| consT := ssa.AuxIntToInt32(c.AuxInt) |
| if x != v_1 { |
| continue |
| } |
| bool := v_2 |
| if !(!rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpSub32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v1.AuxInt = ssa.Int32ToAuxInt(-consT) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, t) |
| v3 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v3.AddArg(bool) |
| v2.AddArg(v3) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect op1:(Add16 <t> x c:(Const16 [consT])) x bool) |
| // cond: !rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt) |
| // result: (Sub16 x (Mul16 <t> (Const16 <t> [-consT]) (ZeroExt8to16 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)))) |
| for { |
| op1 := v_0 |
| if op1.Op != ssaop.OpAdd16 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| x := op1_0 |
| c := op1_1 |
| if c.Op != ssaop.OpConst16 { |
| continue |
| } |
| consT := ssa.AuxIntToInt16(c.AuxInt) |
| if x != v_1 { |
| continue |
| } |
| bool := v_2 |
| if !(!rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpSub16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v1.AuxInt = ssa.Int16ToAuxInt(-consT) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, t) |
| v3 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v3.AddArg(bool) |
| v2.AddArg(v3) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect x op1:(Add8 <t> x c:(Const8 [consT])) bool) |
| // cond: !rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt) |
| // result: (Sub8 x (Mul8 <t> (Const8 <t> [-consT]) (CvtBoolToUint8 <t> (Not <bool.Type> bool)))) |
| for { |
| x := v_0 |
| op1 := v_1 |
| if op1.Op != ssaop.OpAdd8 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| if x != op1_0 { |
| continue |
| } |
| c := op1_1 |
| if c.Op != ssaop.OpConst8 { |
| continue |
| } |
| consT := ssa.AuxIntToInt8(c.AuxInt) |
| bool := v_2 |
| if !(!rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpSub8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v1.AuxInt = ssa.Int8ToAuxInt(-consT) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, t) |
| v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v3.AddArg(bool) |
| v2.AddArg(v3) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect x op1:(Add64 <t> x c:(Const64 [consT])) bool) |
| // cond: !rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt) |
| // result: (Sub64 x (Mul64 <t> (Const64 <t> [-consT]) (ZeroExt8to64 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))))) |
| for { |
| x := v_0 |
| op1 := v_1 |
| if op1.Op != ssaop.OpAdd64 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| if x != op1_0 { |
| continue |
| } |
| c := op1_1 |
| if c.Op != ssaop.OpConst64 { |
| continue |
| } |
| consT := ssa.AuxIntToInt64(c.AuxInt) |
| bool := v_2 |
| if !(!rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpSub64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v1.AuxInt = ssa.Int64ToAuxInt(-consT) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, t) |
| v3 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v4 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v4.AddArg(bool) |
| v3.AddArg(v4) |
| v2.AddArg(v3) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect x op1:(Add32 <t> x c:(Const32 [consT])) bool) |
| // cond: !rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt) |
| // result: (Sub32 x (Mul32 <t> (Const32 <t> [-consT]) (ZeroExt8to32 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))))) |
| for { |
| x := v_0 |
| op1 := v_1 |
| if op1.Op != ssaop.OpAdd32 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| if x != op1_0 { |
| continue |
| } |
| c := op1_1 |
| if c.Op != ssaop.OpConst32 { |
| continue |
| } |
| consT := ssa.AuxIntToInt32(c.AuxInt) |
| bool := v_2 |
| if !(!rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpSub32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v1.AuxInt = ssa.Int32ToAuxInt(-consT) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, t) |
| v3 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v4 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v4.AddArg(bool) |
| v3.AddArg(v4) |
| v2.AddArg(v3) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect x op1:(Add16 <t> x c:(Const16 [consT])) bool) |
| // cond: !rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt) |
| // result: (Sub16 x (Mul16 <t> (Const16 <t> [-consT]) (ZeroExt8to16 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))))) |
| for { |
| x := v_0 |
| op1 := v_1 |
| if op1.Op != ssaop.OpAdd16 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| if x != op1_0 { |
| continue |
| } |
| c := op1_1 |
| if c.Op != ssaop.OpConst16 { |
| continue |
| } |
| consT := ssa.AuxIntToInt16(c.AuxInt) |
| bool := v_2 |
| if !(!rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) && rewriteCondSelectIntoMath(config, addToSub(op1.Op), -c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpSub16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v1.AuxInt = ssa.Int16ToAuxInt(-consT) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, t) |
| v3 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v4 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v4.AddArg(bool) |
| v3.AddArg(v4) |
| v2.AddArg(v3) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect (Lsh64x64 x (Const64 [1])) x bool) |
| // result: (Lsh64x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)) |
| for { |
| if v_0.Op != ssaop.OpLsh64x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpLsh64x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v0.AddArg(bool) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect (Lsh32x64 x (Const64 [1])) x bool) |
| // result: (Lsh32x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)) |
| for { |
| if v_0.Op != ssaop.OpLsh32x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpLsh32x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v0.AddArg(bool) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect (Lsh16x64 x (Const64 [1])) x bool) |
| // result: (Lsh16x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)) |
| for { |
| if v_0.Op != ssaop.OpLsh16x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpLsh16x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v0.AddArg(bool) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect (Lsh8x64 x (Const64 [1])) x bool) |
| // result: (Lsh8x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)) |
| for { |
| if v_0.Op != ssaop.OpLsh8x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpLsh8x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v0.AddArg(bool) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect x (Lsh64x64 x (Const64 [1])) bool) |
| // result: (Lsh64x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpLsh64x64 { |
| break |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpLsh64x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect x (Lsh32x64 x (Const64 [1])) bool) |
| // result: (Lsh32x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpLsh32x64 { |
| break |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpLsh32x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect x (Lsh16x64 x (Const64 [1])) bool) |
| // result: (Lsh16x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpLsh16x64 { |
| break |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpLsh16x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect x (Lsh8x64 x (Const64 [1])) bool) |
| // result: (Lsh8x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpLsh8x64 { |
| break |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpLsh8x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect (Rsh64x64 x (Const64 [1])) x bool) |
| // result: (Rsh64x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)) |
| for { |
| if v_0.Op != ssaop.OpRsh64x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpRsh64x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v0.AddArg(bool) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect (Rsh32x64 x (Const64 [1])) x bool) |
| // result: (Rsh32x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)) |
| for { |
| if v_0.Op != ssaop.OpRsh32x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpRsh32x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v0.AddArg(bool) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect (Rsh16x64 x (Const64 [1])) x bool) |
| // result: (Rsh16x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)) |
| for { |
| if v_0.Op != ssaop.OpRsh16x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpRsh16x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v0.AddArg(bool) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect (Rsh8x64 x (Const64 [1])) x bool) |
| // result: (Rsh8x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)) |
| for { |
| if v_0.Op != ssaop.OpRsh8x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpRsh8x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v0.AddArg(bool) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect (Rsh64Ux64 x (Const64 [1])) x bool) |
| // result: (Rsh64Ux8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)) |
| for { |
| if v_0.Op != ssaop.OpRsh64Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpRsh64Ux8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v0.AddArg(bool) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect (Rsh32Ux64 x (Const64 [1])) x bool) |
| // result: (Rsh32Ux8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)) |
| for { |
| if v_0.Op != ssaop.OpRsh32Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpRsh32Ux8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v0.AddArg(bool) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect (Rsh16Ux64 x (Const64 [1])) x bool) |
| // result: (Rsh16Ux8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)) |
| for { |
| if v_0.Op != ssaop.OpRsh16Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpRsh16Ux8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v0.AddArg(bool) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect (Rsh8Ux64 x (Const64 [1])) x bool) |
| // result: (Rsh8Ux8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)) |
| for { |
| if v_0.Op != ssaop.OpRsh8Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 1 || x != v_1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpRsh8Ux8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v0.AddArg(bool) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect x (Rsh64x64 x (Const64 [1])) bool) |
| // result: (Rsh64x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpRsh64x64 { |
| break |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpRsh64x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect x (Rsh32x64 x (Const64 [1])) bool) |
| // result: (Rsh32x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpRsh32x64 { |
| break |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpRsh32x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect x (Rsh16x64 x (Const64 [1])) bool) |
| // result: (Rsh16x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpRsh16x64 { |
| break |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpRsh16x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect x (Rsh8x64 x (Const64 [1])) bool) |
| // result: (Rsh8x8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpRsh8x64 { |
| break |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpRsh8x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect x (Rsh64Ux64 x (Const64 [1])) bool) |
| // result: (Rsh64Ux8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpRsh64Ux64 { |
| break |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpRsh64Ux8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect x (Rsh32Ux64 x (Const64 [1])) bool) |
| // result: (Rsh32Ux8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpRsh32Ux64 { |
| break |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpRsh32Ux8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect x (Rsh16Ux64 x (Const64 [1])) bool) |
| // result: (Rsh16Ux8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpRsh16Ux64 { |
| break |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpRsh16Ux8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect x (Rsh8Ux64 x (Const64 [1])) bool) |
| // result: (Rsh8Ux8 [true] x (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpRsh8Ux64 { |
| break |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1_1.AuxInt) != 1 { |
| break |
| } |
| bool := v_2 |
| v.Reset(ssaop.OpRsh8Ux8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (CondSelect op1:(Or8 <t> x c:(Const8)) x bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Or8 x (Mul8 <t> c (CvtBoolToUint8 <t> bool))) |
| for { |
| op1 := v_0 |
| if op1.Op != ssaop.OpOr8 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| x := op1_0 |
| c := op1_1 |
| if c.Op != ssaop.OpConst8 || x != v_1 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpOr8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, t) |
| v1.AddArg(bool) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect op1:(Or64 <t> x c:(Const64)) x bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Or64 x (Mul64 <t> c (ZeroExt8to64 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)))) |
| for { |
| op1 := v_0 |
| if op1.Op != ssaop.OpOr64 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| x := op1_0 |
| c := op1_1 |
| if c.Op != ssaop.OpConst64 || x != v_1 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpOr64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v2.AddArg(bool) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect op1:(Or32 <t> x c:(Const32)) x bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Or32 x (Mul32 <t> c (ZeroExt8to32 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)))) |
| for { |
| op1 := v_0 |
| if op1.Op != ssaop.OpOr32 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| x := op1_0 |
| c := op1_1 |
| if c.Op != ssaop.OpConst32 || x != v_1 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpOr32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v2.AddArg(bool) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect op1:(Or16 <t> x c:(Const16)) x bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Or16 x (Mul16 <t> c (ZeroExt8to16 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)))) |
| for { |
| op1 := v_0 |
| if op1.Op != ssaop.OpOr16 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| x := op1_0 |
| c := op1_1 |
| if c.Op != ssaop.OpConst16 || x != v_1 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpOr16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v2.AddArg(bool) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect x op1:(Or8 <t> x c:(Const8)) bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Or8 x (Mul8 <t> c (CvtBoolToUint8 <t> (Not <bool.Type> bool)))) |
| for { |
| x := v_0 |
| op1 := v_1 |
| if op1.Op != ssaop.OpOr8 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| if x != op1_0 { |
| continue |
| } |
| c := op1_1 |
| if c.Op != ssaop.OpConst8 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpOr8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v2.AddArg(bool) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect x op1:(Or64 <t> x c:(Const64)) bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Or64 x (Mul64 <t> c (ZeroExt8to64 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))))) |
| for { |
| x := v_0 |
| op1 := v_1 |
| if op1.Op != ssaop.OpOr64 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| if x != op1_0 { |
| continue |
| } |
| c := op1_1 |
| if c.Op != ssaop.OpConst64 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpOr64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v3.AddArg(bool) |
| v2.AddArg(v3) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect x op1:(Or32 <t> x c:(Const32)) bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Or32 x (Mul32 <t> c (ZeroExt8to32 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))))) |
| for { |
| x := v_0 |
| op1 := v_1 |
| if op1.Op != ssaop.OpOr32 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| if x != op1_0 { |
| continue |
| } |
| c := op1_1 |
| if c.Op != ssaop.OpConst32 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpOr32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v3.AddArg(bool) |
| v2.AddArg(v3) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect x op1:(Or16 <t> x c:(Const16)) bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Or16 x (Mul16 <t> c (ZeroExt8to16 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))))) |
| for { |
| x := v_0 |
| op1 := v_1 |
| if op1.Op != ssaop.OpOr16 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| if x != op1_0 { |
| continue |
| } |
| c := op1_1 |
| if c.Op != ssaop.OpConst16 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpOr16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v3.AddArg(bool) |
| v2.AddArg(v3) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect op1:(Xor8 <t> x c:(Const8)) x bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Xor8 x (Mul8 <t> c (CvtBoolToUint8 <t> bool))) |
| for { |
| op1 := v_0 |
| if op1.Op != ssaop.OpXor8 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| x := op1_0 |
| c := op1_1 |
| if c.Op != ssaop.OpConst8 || x != v_1 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpXor8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, t) |
| v1.AddArg(bool) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect op1:(Xor64 <t> x c:(Const64)) x bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Xor64 x (Mul64 <t> c (ZeroExt8to64 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)))) |
| for { |
| op1 := v_0 |
| if op1.Op != ssaop.OpXor64 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| x := op1_0 |
| c := op1_1 |
| if c.Op != ssaop.OpConst64 || x != v_1 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpXor64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v2.AddArg(bool) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect op1:(Xor32 <t> x c:(Const32)) x bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Xor32 x (Mul32 <t> c (ZeroExt8to32 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)))) |
| for { |
| op1 := v_0 |
| if op1.Op != ssaop.OpXor32 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| x := op1_0 |
| c := op1_1 |
| if c.Op != ssaop.OpConst32 || x != v_1 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpXor32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v2.AddArg(bool) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect op1:(Xor16 <t> x c:(Const16)) x bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Xor16 x (Mul16 <t> c (ZeroExt8to16 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> bool)))) |
| for { |
| op1 := v_0 |
| if op1.Op != ssaop.OpXor16 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| x := op1_0 |
| c := op1_1 |
| if c.Op != ssaop.OpConst16 || x != v_1 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpXor16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v2.AddArg(bool) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect x op1:(Xor8 <t> x c:(Const8)) bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Xor8 x (Mul8 <t> c (CvtBoolToUint8 <t> (Not <bool.Type> bool)))) |
| for { |
| x := v_0 |
| op1 := v_1 |
| if op1.Op != ssaop.OpXor8 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| if x != op1_0 { |
| continue |
| } |
| c := op1_1 |
| if c.Op != ssaop.OpConst8 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpXor8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v2.AddArg(bool) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect x op1:(Xor64 <t> x c:(Const64)) bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Xor64 x (Mul64 <t> c (ZeroExt8to64 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))))) |
| for { |
| x := v_0 |
| op1 := v_1 |
| if op1.Op != ssaop.OpXor64 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| if x != op1_0 { |
| continue |
| } |
| c := op1_1 |
| if c.Op != ssaop.OpConst64 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpXor64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v3.AddArg(bool) |
| v2.AddArg(v3) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect x op1:(Xor32 <t> x c:(Const32)) bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Xor32 x (Mul32 <t> c (ZeroExt8to32 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))))) |
| for { |
| x := v_0 |
| op1 := v_1 |
| if op1.Op != ssaop.OpXor32 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| if x != op1_0 { |
| continue |
| } |
| c := op1_1 |
| if c.Op != ssaop.OpConst32 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpXor32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v3.AddArg(bool) |
| v2.AddArg(v3) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (CondSelect x op1:(Xor16 <t> x c:(Const16)) bool) |
| // cond: rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt) |
| // result: (Xor16 x (Mul16 <t> c (ZeroExt8to16 <t> (CvtBoolToUint8 <types.Types[types.TUINT8]> (Not <bool.Type> bool))))) |
| for { |
| x := v_0 |
| op1 := v_1 |
| if op1.Op != ssaop.OpXor16 { |
| break |
| } |
| t := op1.Type |
| _ = op1.Args[1] |
| op1_0 := op1.Args[0] |
| op1_1 := op1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, op1_0, op1_1 = _i0+1, op1_1, op1_0 { |
| if x != op1_0 { |
| continue |
| } |
| c := op1_1 |
| if c.Op != ssaop.OpConst16 { |
| continue |
| } |
| bool := v_2 |
| if !(rewriteCondSelectIntoMath(config, op1.Op, c.AuxInt)) { |
| continue |
| } |
| v.Reset(ssaop.OpXor16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, types.Types[types.TUINT8]) |
| v3 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v3.AddArg(bool) |
| v2.AddArg(v3) |
| v1.AddArg(v2) |
| v0.AddArg2(c, v1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpConstInterface(v *ssa.Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (ConstInterface) |
| // result: (IMake (ConstNil <typ.Uintptr>) (ConstNil <typ.BytePtr>)) |
| for { |
| v.Reset(ssaop.OpIMake) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConstNil, typ.Uintptr) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConstNil, typ.BytePtr) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| } |
| func rewriteValue_OpConstSlice(v *ssa.Value) bool { |
| b := v.Block |
| config := b.Func.Config |
| typ := &b.Func.Config.Types |
| // match: (ConstSlice) |
| // cond: config.PtrSize == 4 |
| // result: (SliceMake (ConstNil <v.Type.Elem().PtrTo()>) (Const32 <typ.Int> [0]) (Const32 <typ.Int> [0])) |
| for { |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpSliceMake) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConstNil, v.Type.Elem().PtrTo()) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int) |
| v1.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg3(v0, v1, v1) |
| return true |
| } |
| // match: (ConstSlice) |
| // cond: config.PtrSize == 8 |
| // result: (SliceMake (ConstNil <v.Type.Elem().PtrTo()>) (Const64 <typ.Int> [0]) (Const64 <typ.Int> [0])) |
| for { |
| if !(config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpSliceMake) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConstNil, v.Type.Elem().PtrTo()) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int) |
| v1.AuxInt = ssa.Int64ToAuxInt(0) |
| v.AddArg3(v0, v1, v1) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpConstString(v *ssa.Value) bool { |
| b := v.Block |
| config := b.Func.Config |
| fe := b.Func.Fe |
| typ := &b.Func.Config.Types |
| // match: (ConstString {str}) |
| // cond: config.PtrSize == 4 && str == "" |
| // result: (StringMake (ConstNil) (Const32 <typ.Int> [0])) |
| for { |
| str := ssa.AuxToString(v.Aux) |
| if !(config.PtrSize == 4 && str == "") { |
| break |
| } |
| v.Reset(ssaop.OpStringMake) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConstNil, typ.BytePtr) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int) |
| v1.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| // match: (ConstString {str}) |
| // cond: config.PtrSize == 8 && str == "" |
| // result: (StringMake (ConstNil) (Const64 <typ.Int> [0])) |
| for { |
| str := ssa.AuxToString(v.Aux) |
| if !(config.PtrSize == 8 && str == "") { |
| break |
| } |
| v.Reset(ssaop.OpStringMake) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConstNil, typ.BytePtr) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int) |
| v1.AuxInt = ssa.Int64ToAuxInt(0) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| // match: (ConstString {str}) |
| // cond: config.PtrSize == 4 && str != "" |
| // result: (StringMake (Addr <typ.BytePtr> {fe.StringData(str)} (SB)) (Const32 <typ.Int> [int32(len(str))])) |
| for { |
| str := ssa.AuxToString(v.Aux) |
| if !(config.PtrSize == 4 && str != "") { |
| break |
| } |
| v.Reset(ssaop.OpStringMake) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAddr, typ.BytePtr) |
| v0.Aux = ssa.SymToAux(fe.StringData(str)) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSB, typ.Uintptr) |
| v0.AddArg(v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int) |
| v2.AuxInt = ssa.Int32ToAuxInt(int32(len(str))) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| // match: (ConstString {str}) |
| // cond: config.PtrSize == 8 && str != "" |
| // result: (StringMake (Addr <typ.BytePtr> {fe.StringData(str)} (SB)) (Const64 <typ.Int> [int64(len(str))])) |
| for { |
| str := ssa.AuxToString(v.Aux) |
| if !(config.PtrSize == 8 && str != "") { |
| break |
| } |
| v.Reset(ssaop.OpStringMake) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAddr, typ.BytePtr) |
| v0.Aux = ssa.SymToAux(fe.StringData(str)) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSB, typ.Uintptr) |
| v0.AddArg(v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int) |
| v2.AuxInt = ssa.Int64ToAuxInt(int64(len(str))) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpConvert(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Convert (Add64 (Convert ptr mem) off) mem) |
| // result: (AddPtr ptr off) |
| for { |
| if v_0.Op != ssaop.OpAdd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConvert { |
| continue |
| } |
| mem := v_0_0.Args[1] |
| ptr := v_0_0.Args[0] |
| off := v_0_1 |
| if mem != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpAddPtr) |
| v.AddArg2(ptr, off) |
| return true |
| } |
| break |
| } |
| // match: (Convert (Add32 (Convert ptr mem) off) mem) |
| // result: (AddPtr ptr off) |
| for { |
| if v_0.Op != ssaop.OpAdd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConvert { |
| continue |
| } |
| mem := v_0_0.Args[1] |
| ptr := v_0_0.Args[0] |
| off := v_0_1 |
| if mem != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpAddPtr) |
| v.AddArg2(ptr, off) |
| return true |
| } |
| break |
| } |
| // match: (Convert (Convert ptr mem) mem) |
| // result: ptr |
| for { |
| if v_0.Op != ssaop.OpConvert { |
| break |
| } |
| mem := v_0.Args[1] |
| ptr := v_0.Args[0] |
| if mem != v_1 { |
| break |
| } |
| v.CopyOf(ptr) |
| return true |
| } |
| // match: (Convert a:(Add64 (Add64 (Convert ptr mem) off1) off2) mem) |
| // result: (AddPtr ptr (Add64 <a.Type> off1 off2)) |
| for { |
| a := v_0 |
| if a.Op != ssaop.OpAdd64 { |
| break |
| } |
| _ = a.Args[1] |
| a_0 := a.Args[0] |
| a_1 := a.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, a_0, a_1 = _i0+1, a_1, a_0 { |
| if a_0.Op != ssaop.OpAdd64 { |
| continue |
| } |
| _ = a_0.Args[1] |
| a_0_0 := a_0.Args[0] |
| a_0_1 := a_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, a_0_0, a_0_1 = _i1+1, a_0_1, a_0_0 { |
| if a_0_0.Op != ssaop.OpConvert { |
| continue |
| } |
| mem := a_0_0.Args[1] |
| ptr := a_0_0.Args[0] |
| off1 := a_0_1 |
| off2 := a_1 |
| if mem != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpAddPtr) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, a.Type) |
| v0.AddArg2(off1, off2) |
| v.AddArg2(ptr, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Convert a:(Add32 (Add32 (Convert ptr mem) off1) off2) mem) |
| // result: (AddPtr ptr (Add32 <a.Type> off1 off2)) |
| for { |
| a := v_0 |
| if a.Op != ssaop.OpAdd32 { |
| break |
| } |
| _ = a.Args[1] |
| a_0 := a.Args[0] |
| a_1 := a.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, a_0, a_1 = _i0+1, a_1, a_0 { |
| if a_0.Op != ssaop.OpAdd32 { |
| continue |
| } |
| _ = a_0.Args[1] |
| a_0_0 := a_0.Args[0] |
| a_0_1 := a_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, a_0_0, a_0_1 = _i1+1, a_0_1, a_0_0 { |
| if a_0_0.Op != ssaop.OpConvert { |
| continue |
| } |
| mem := a_0_0.Args[1] |
| ptr := a_0_0.Args[0] |
| off1 := a_0_1 |
| off2 := a_1 |
| if mem != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpAddPtr) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, a.Type) |
| v0.AddArg2(off1, off2) |
| v.AddArg2(ptr, v0) |
| return true |
| } |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpCtz16(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (Ctz16 (Const16 [c])) |
| // cond: config.PtrSize == 4 |
| // result: (Const32 [int32(ntz16(c))]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(ntz16(c))) |
| return true |
| } |
| // match: (Ctz16 (Const16 [c])) |
| // cond: config.PtrSize == 8 |
| // result: (Const64 [int64(ntz16(c))]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if !(config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(ntz16(c))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpCtz32(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (Ctz32 (Const32 [c])) |
| // cond: config.PtrSize == 4 |
| // result: (Const32 [int32(ntz32(c))]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(ntz32(c))) |
| return true |
| } |
| // match: (Ctz32 (Const32 [c])) |
| // cond: config.PtrSize == 8 |
| // result: (Const64 [int64(ntz32(c))]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if !(config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(ntz32(c))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpCtz64(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (Ctz64 (Const64 [c])) |
| // cond: config.PtrSize == 4 |
| // result: (Const32 [int32(ssa.Ntz64(c))]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(ssa.Ntz64(c))) |
| return true |
| } |
| // match: (Ctz64 (Const64 [c])) |
| // cond: config.PtrSize == 8 |
| // result: (Const64 [int64(ssa.Ntz64(c))]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if !(config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(ssa.Ntz64(c))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpCtz8(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (Ctz8 (Const8 [c])) |
| // cond: config.PtrSize == 4 |
| // result: (Const32 [int32(ntz8(c))]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(ntz8(c))) |
| return true |
| } |
| // match: (Ctz8 (Const8 [c])) |
| // cond: config.PtrSize == 8 |
| // result: (Const64 [int64(ntz8(c))]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if !(config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(ntz8(c))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpCvt32Fto32(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Cvt32Fto32 (Const32F [c])) |
| // cond: c >= -1<<31 && c < 1<<31 |
| // result: (Const32 [int32(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst32F { |
| break |
| } |
| c := ssa.AuxIntToFloat32(v_0.AuxInt) |
| if !(c >= -1<<31 && c < 1<<31) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpCvt32Fto64(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Cvt32Fto64 (Const32F [c])) |
| // cond: c >= -1<<63 && c < 1<<63 |
| // result: (Const64 [int64(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst32F { |
| break |
| } |
| c := ssa.AuxIntToFloat32(v_0.AuxInt) |
| if !(c >= -1<<63 && c < 1<<63) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpCvt32Fto64F(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Cvt32Fto64F (Const32F [c])) |
| // result: (Const64F [float64(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst32F { |
| break |
| } |
| c := ssa.AuxIntToFloat32(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64F) |
| v.AuxInt = ssa.Float64ToAuxInt(float64(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpCvt32to32F(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Cvt32to32F (Const32 [c])) |
| // result: (Const32F [float32(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| v.Reset(ssaop.OpConst32F) |
| v.AuxInt = ssa.Float32ToAuxInt(float32(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpCvt32to64F(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Cvt32to64F (Const32 [c])) |
| // result: (Const64F [float64(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64F) |
| v.AuxInt = ssa.Float64ToAuxInt(float64(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpCvt64Fto32(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Cvt64Fto32 (Const64F [c])) |
| // cond: c >= -1<<31 && c < 1<<31 |
| // result: (Const32 [int32(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst64F { |
| break |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| if !(c >= -1<<31 && c < 1<<31) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpCvt64Fto32F(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Cvt64Fto32F (Const64F [c])) |
| // result: (Const32F [float32(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst64F { |
| break |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| v.Reset(ssaop.OpConst32F) |
| v.AuxInt = ssa.Float32ToAuxInt(float32(c)) |
| return true |
| } |
| // match: (Cvt64Fto32F sqrt0:(Sqrt (Cvt32Fto64F x))) |
| // cond: sqrt0.Uses==1 |
| // result: (Sqrt32 x) |
| for { |
| sqrt0 := v_0 |
| if sqrt0.Op != ssaop.OpSqrt { |
| break |
| } |
| sqrt0_0 := sqrt0.Args[0] |
| if sqrt0_0.Op != ssaop.OpCvt32Fto64F { |
| break |
| } |
| x := sqrt0_0.Args[0] |
| if !(sqrt0.Uses == 1) { |
| break |
| } |
| v.Reset(ssaop.OpSqrt32) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpCvt64Fto64(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Cvt64Fto64 (Const64F [c])) |
| // cond: c >= -1<<63 && c < 1<<63 |
| // result: (Const64 [int64(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst64F { |
| break |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| if !(c >= -1<<63 && c < 1<<63) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpCvt64to32F(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Cvt64to32F (Const64 [c])) |
| // result: (Const32F [float32(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| v.Reset(ssaop.OpConst32F) |
| v.AuxInt = ssa.Float32ToAuxInt(float32(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpCvt64to64F(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Cvt64to64F (Const64 [c])) |
| // result: (Const64F [float64(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64F) |
| v.AuxInt = ssa.Float64ToAuxInt(float64(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpCvtBoolToUint8(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (CvtBoolToUint8 (ConstBool [false])) |
| // result: (Const8 [0]) |
| for { |
| if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != false { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (CvtBoolToUint8 (ConstBool [true])) |
| // result: (Const8 [1]) |
| for { |
| if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != true { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(1) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv128u(v *ssa.Value) bool { |
| v_2 := v.Args[2] |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Div128u <t> (Const64 [hi]) (Const64 [lo]) (Const64 [y])) |
| // cond: y != 0 && uint64(hi) < uint64(y) |
| // result: (MakeTuple (Const64 <t.FieldType(0)> [bitsDiv128u(hi, lo, y).quo]) (Const64 <t.FieldType(1)> [bitsDiv128u(hi, lo, y).rem])) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| hi := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| lo := ssa.AuxIntToInt64(v_1.AuxInt) |
| if v_2.Op != ssaop.OpConst64 { |
| break |
| } |
| y := ssa.AuxIntToInt64(v_2.AuxInt) |
| if !(y != 0 && uint64(hi) < uint64(y)) { |
| break |
| } |
| v.Reset(ssaop.OpMakeTuple) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t.FieldType(0)) |
| v0.AuxInt = ssa.Int64ToAuxInt(bitsDiv128u(hi, lo, y).quo) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t.FieldType(1)) |
| v1.AuxInt = ssa.Int64ToAuxInt(bitsDiv128u(hi, lo, y).rem) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| // match: (Div128u <t> (Const64 [0]) lo y) |
| // result: (MakeTuple (Div64u <t.FieldType(0)> lo y) (Mod64u <t.FieldType(1)> lo y)) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| lo := v_1 |
| y := v_2 |
| v.Reset(ssaop.OpMakeTuple) |
| v0 := b.NewValue0(v.Pos, ssaop.OpDiv64u, t.FieldType(0)) |
| v0.AddArg2(lo, y) |
| v1 := b.NewValue0(v.Pos, ssaop.OpMod64u, t.FieldType(1)) |
| v1.AddArg2(lo, y) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Div16 (Const16 [c]) (Const16 [d])) |
| // cond: d != 0 |
| // result: (Const16 [c/d]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(d != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(c / d) |
| return true |
| } |
| // match: (Div16 <t> n (Const16 [c])) |
| // cond: c < 0 && c != -1<<15 |
| // result: (Neg16 (Div16 <t> n (Const16 <t> [-c]))) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(c < 0 && c != -1<<15) { |
| break |
| } |
| v.Reset(ssaop.OpNeg16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpDiv16, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v1.AuxInt = ssa.Int16ToAuxInt(-c) |
| v0.AddArg2(n, v1) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div16 <t> x (Const16 [-1<<15])) |
| // result: (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <typ.UInt64> [15])) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != -1<<15 { |
| break |
| } |
| v.Reset(ssaop.OpRsh16Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd16, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNeg16, t) |
| v1.AddArg(x) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v2.AuxInt = ssa.Int64ToAuxInt(15) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv16u(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Div16u (Const16 [c]) (Const16 [d])) |
| // cond: d != 0 |
| // result: (Const16 [int16(uint16(c)/uint16(d))]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(d != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(int16(uint16(c) / uint16(d))) |
| return true |
| } |
| // match: (Div16u n (Const16 [c])) |
| // cond: ssa.IsPowerOfTwo(uint16(c)) |
| // result: (Rsh16Ux64 n (Const64 <typ.UInt64> [ssa.Log16u(uint16(c))])) |
| for { |
| n := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(uint16(c))) { |
| break |
| } |
| v.Reset(ssaop.OpRsh16Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(ssa.Log16u(uint16(c))) |
| v.AddArg2(n, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Div32 (Const32 [c]) (Const32 [d])) |
| // cond: d != 0 |
| // result: (Const32 [c/d]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(d != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(c / d) |
| return true |
| } |
| // match: (Div32 <t> n (Const32 [c])) |
| // cond: c < 0 && c != -1<<31 |
| // result: (Neg32 (Div32 <t> n (Const32 <t> [-c]))) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(c < 0 && c != -1<<31) { |
| break |
| } |
| v.Reset(ssaop.OpNeg32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpDiv32, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v1.AuxInt = ssa.Int32ToAuxInt(-c) |
| v0.AddArg2(n, v1) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div32 <t> x (Const32 [-1<<31])) |
| // result: (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <typ.UInt64> [31])) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != -1<<31 { |
| break |
| } |
| v.Reset(ssaop.OpRsh32Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd32, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNeg32, t) |
| v1.AddArg(x) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v2.AuxInt = ssa.Int64ToAuxInt(31) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv32F(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Div32F (Const32F [c]) (Const32F [d])) |
| // cond: c/d == c/d |
| // result: (Const32F [c/d]) |
| for { |
| if v_0.Op != ssaop.OpConst32F { |
| break |
| } |
| c := ssa.AuxIntToFloat32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32F { |
| break |
| } |
| d := ssa.AuxIntToFloat32(v_1.AuxInt) |
| if !(c/d == c/d) { |
| break |
| } |
| v.Reset(ssaop.OpConst32F) |
| v.AuxInt = ssa.Float32ToAuxInt(c / d) |
| return true |
| } |
| // match: (Div32F x (Const32F <t> [c])) |
| // cond: reciprocalExact32(c) |
| // result: (Mul32F x (Const32F <t> [1/c])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32F { |
| break |
| } |
| t := v_1.Type |
| c := ssa.AuxIntToFloat32(v_1.AuxInt) |
| if !(reciprocalExact32(c)) { |
| break |
| } |
| v.Reset(ssaop.OpMul32F) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32F, t) |
| v0.AuxInt = ssa.Float32ToAuxInt(1 / c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv32u(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Div32u (Const32 [c]) (Const32 [d])) |
| // cond: d != 0 |
| // result: (Const32 [int32(uint32(c)/uint32(d))]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(d != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(uint32(c) / uint32(d))) |
| return true |
| } |
| // match: (Div32u n (Const32 [c])) |
| // cond: ssa.IsPowerOfTwo(uint32(c)) |
| // result: (Rsh32Ux64 n (Const64 <typ.UInt64> [ssa.Log32u(uint32(c))])) |
| for { |
| n := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(uint32(c))) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(ssa.Log32u(uint32(c))) |
| v.AddArg2(n, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv64(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Div64 (Const64 [c]) (Const64 [d])) |
| // cond: d != 0 |
| // result: (Const64 [c/d]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(d != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(c / d) |
| return true |
| } |
| // match: (Div64 <t> n (Const64 [c])) |
| // cond: c < 0 && c != -1<<63 |
| // result: (Neg64 (Div64 <t> n (Const64 <t> [-c]))) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c < 0 && c != -1<<63) { |
| break |
| } |
| v.Reset(ssaop.OpNeg64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpDiv64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v1.AuxInt = ssa.Int64ToAuxInt(-c) |
| v0.AddArg2(n, v1) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div64 x (Const64 [-1<<63])) |
| // cond: isNonNegative(x) |
| // result: (Const64 [0]) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != -1<<63 || !(isNonNegative(x)) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Div64 <t> x (Const64 [-1<<63])) |
| // result: (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <typ.UInt64> [63])) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != -1<<63 { |
| break |
| } |
| v.Reset(ssaop.OpRsh64Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNeg64, t) |
| v1.AddArg(x) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v2.AuxInt = ssa.Int64ToAuxInt(63) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv64F(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Div64F (Const64F [c]) (Const64F [d])) |
| // cond: c/d == c/d |
| // result: (Const64F [c/d]) |
| for { |
| if v_0.Op != ssaop.OpConst64F { |
| break |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64F { |
| break |
| } |
| d := ssa.AuxIntToFloat64(v_1.AuxInt) |
| if !(c/d == c/d) { |
| break |
| } |
| v.Reset(ssaop.OpConst64F) |
| v.AuxInt = ssa.Float64ToAuxInt(c / d) |
| return true |
| } |
| // match: (Div64F x (Const64F <t> [c])) |
| // cond: reciprocalExact64(c) |
| // result: (Mul64F x (Const64F <t> [1/c])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64F { |
| break |
| } |
| t := v_1.Type |
| c := ssa.AuxIntToFloat64(v_1.AuxInt) |
| if !(reciprocalExact64(c)) { |
| break |
| } |
| v.Reset(ssaop.OpMul64F) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64F, t) |
| v0.AuxInt = ssa.Float64ToAuxInt(1 / c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv64u(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Div64u (Const64 [c]) (Const64 [d])) |
| // cond: d != 0 |
| // result: (Const64 [int64(uint64(c)/uint64(d))]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(d != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(uint64(c) / uint64(d))) |
| return true |
| } |
| // match: (Div64u n (Const64 [c])) |
| // cond: ssa.IsPowerOfTwo(uint64(c)) |
| // result: (Rsh64Ux64 n (Const64 <typ.UInt64> [ssa.Log64u(uint64(c))])) |
| for { |
| n := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(uint64(c))) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(ssa.Log64u(uint64(c))) |
| v.AddArg2(n, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Div8 (Const8 [c]) (Const8 [d])) |
| // cond: d != 0 |
| // result: (Const8 [c/d]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(d != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(c / d) |
| return true |
| } |
| // match: (Div8 <t> n (Const8 [c])) |
| // cond: c < 0 && c != -1<<7 |
| // result: (Neg8 (Div8 <t> n (Const8 <t> [-c]))) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(c < 0 && c != -1<<7) { |
| break |
| } |
| v.Reset(ssaop.OpNeg8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpDiv8, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v1.AuxInt = ssa.Int8ToAuxInt(-c) |
| v0.AddArg2(n, v1) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div8 <t> x (Const8 [-1<<7 ])) |
| // result: (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <typ.UInt64> [7 ])) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != -1<<7 { |
| break |
| } |
| v.Reset(ssaop.OpRsh8Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd8, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNeg8, t) |
| v1.AddArg(x) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v2.AuxInt = ssa.Int64ToAuxInt(7) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv8u(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Div8u (Const8 [c]) (Const8 [d])) |
| // cond: d != 0 |
| // result: (Const8 [int8(uint8(c)/uint8(d))]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(d != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(int8(uint8(c) / uint8(d))) |
| return true |
| } |
| // match: (Div8u n (Const8 [c])) |
| // cond: ssa.IsPowerOfTwo(uint8(c)) |
| // result: (Rsh8Ux64 n (Const64 <typ.UInt64> [ssa.Log8u(uint8(c))])) |
| for { |
| n := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(uint8(c))) { |
| break |
| } |
| v.Reset(ssaop.OpRsh8Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(ssa.Log8u(uint8(c))) |
| v.AddArg2(n, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpEq16(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: (Eq16 x x) |
| // result: (ConstBool [true]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Eq16 (Const16 <t> [c]) o:(Add16 (Const16 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Eq16 (Const16 <t> [c-d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpAdd16 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(o_0.AuxInt) |
| x := o_1 |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(c - d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Eq16 (Const16 <t> [c]) o:(Sub16 x (Const16 [d]))) |
| // cond: o.Uses == 1 |
| // result: (Eq16 (Const16 <t> [c+d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = o.Args[1] |
| x := o.Args[0] |
| o_1 := o.Args[1] |
| if o_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(o_1.AuxInt) |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(c + d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Eq16 (Const16 <t> [c]) o:(Sub16 (Const16 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Eq16 (Const16 <t> [d-c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpSub16 { |
| continue |
| } |
| x := o.Args[1] |
| o_0 := o.Args[0] |
| if o_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(o_0.AuxInt) |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(d - c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Eq16 (Const16 <t> [c]) o:(Xor16 (Const16 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Eq16 (Const16 <t> [d^c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpXor16 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(o_0.AuxInt) |
| x := o_1 |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(d ^ c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Eq16 (Const16 <t> [c]) o:(Com16 x)) |
| // cond: o.Uses == 1 |
| // result: (Eq16 (Const16 <t> [^c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpCom16 { |
| continue |
| } |
| x := o.Args[0] |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(^c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Eq16 (Const16 <t> [c]) o:(Neg16 x)) |
| // cond: o.Uses == 1 |
| // result: (Eq16 (Const16 <t> [-c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpNeg16 { |
| continue |
| } |
| x := o.Args[0] |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(-c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Eq16 (Const16 <t> [c]) o:(Mul16 (Const16 [d]) x)) |
| // cond: uint16(d)%2 == 1 && o.Uses == 1 |
| // result: (Eq16 (Const16 <t> [int16(uint16(c) * uint16(modularMultiplicativeInverse(uint64(d))))]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpMul16 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(o_0.AuxInt) |
| x := o_1 |
| if !(uint16(d)%2 == 1 && o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(int16(uint16(c) * uint16(modularMultiplicativeInverse(uint64(d))))) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Eq16 (Const16 [c]) (Const16 [d])) |
| // result: (ConstBool [c == d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c == d) |
| return true |
| } |
| break |
| } |
| // match: (Eq16 (Mod16u x (Const16 [c])) (Const16 [0])) |
| // cond: x.Op != ssaop.OpConst16 && ssa.UdivisibleOK16(c) && !hasSmallRotate(config) |
| // result: (Eq32 (Mod32u <typ.UInt32> (ZeroExt16to32 <typ.UInt32> x) (Const32 <typ.UInt32> [int32(uint16(c))])) (Const32 <typ.UInt32> [0])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpMod16u { |
| continue |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 0 || !(x.Op != ssaop.OpConst16 && ssa.UdivisibleOK16(c) && !hasSmallRotate(config)) { |
| continue |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMod32u, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt16to32, typ.UInt32) |
| v1.AddArg(x) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v2.AuxInt = ssa.Int32ToAuxInt(int32(uint16(c))) |
| v0.AddArg2(v1, v2) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v3.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(v0, v3) |
| return true |
| } |
| break |
| } |
| // match: (Eq16 (Mod16 x (Const16 [c])) (Const16 [0])) |
| // cond: x.Op != ssaop.OpConst16 && ssa.SdivisibleOK16(c) && !hasSmallRotate(config) |
| // result: (Eq32 (Mod32 <typ.Int32> (SignExt16to32 <typ.Int32> x) (Const32 <typ.Int32> [int32(c)])) (Const32 <typ.Int32> [0])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpMod16 { |
| continue |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 0 || !(x.Op != ssaop.OpConst16 && ssa.SdivisibleOK16(c) && !hasSmallRotate(config)) { |
| continue |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMod32, typ.Int32) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSignExt16to32, typ.Int32) |
| v1.AddArg(x) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32) |
| v2.AuxInt = ssa.Int32ToAuxInt(int32(c)) |
| v0.AddArg2(v1, v2) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32) |
| v3.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(v0, v3) |
| return true |
| } |
| break |
| } |
| // match: (Eq16 s:(Sub16 x y) (Const16 [0])) |
| // cond: s.Uses == 1 |
| // result: (Eq16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| s := v_0 |
| if s.Op != ssaop.OpSub16 { |
| continue |
| } |
| y := s.Args[1] |
| x := s.Args[0] |
| if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 0 || !(s.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Eq16 (And16 <t> x (Const16 <t> [y])) (Const16 <t> [y])) |
| // cond: ssa.OneBit(y) |
| // result: (Neq16 (And16 <t> x (Const16 <t> [y])) (Const16 <t> [0])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAnd16 { |
| continue |
| } |
| t := v_0.Type |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst16 || v_0_1.Type != t { |
| continue |
| } |
| y := ssa.AuxIntToInt16(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst16 || v_1.Type != t || ssa.AuxIntToInt16(v_1.AuxInt) != y || !(ssa.OneBit(y)) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd16, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v1.AuxInt = ssa.Int16ToAuxInt(y) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v2.AuxInt = ssa.Int16ToAuxInt(0) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Eq16 (ZeroExt8to16 (CvtBoolToUint8 x)) (Const16 [1])) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to16 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| x := v_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 1 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Eq16 (ZeroExt8to16 (CvtBoolToUint8 x)) (Const16 [0])) |
| // result: (Not x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to16 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| x := v_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 0 { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpEq32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Eq32 x x) |
| // result: (ConstBool [true]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Eq32 (Const32 <t> [c]) o:(Add32 (Const32 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Eq32 (Const32 <t> [c-d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpAdd32 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(o_0.AuxInt) |
| x := o_1 |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(c - d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Eq32 (Const32 <t> [c]) o:(Sub32 x (Const32 [d]))) |
| // cond: o.Uses == 1 |
| // result: (Eq32 (Const32 <t> [c+d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = o.Args[1] |
| x := o.Args[0] |
| o_1 := o.Args[1] |
| if o_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(o_1.AuxInt) |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(c + d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Eq32 (Const32 <t> [c]) o:(Sub32 (Const32 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Eq32 (Const32 <t> [d-c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpSub32 { |
| continue |
| } |
| x := o.Args[1] |
| o_0 := o.Args[0] |
| if o_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(o_0.AuxInt) |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(d - c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Eq32 (Const32 <t> [c]) o:(Xor32 (Const32 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Eq32 (Const32 <t> [d^c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpXor32 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(o_0.AuxInt) |
| x := o_1 |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(d ^ c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Eq32 (Const32 <t> [c]) o:(Com32 x)) |
| // cond: o.Uses == 1 |
| // result: (Eq32 (Const32 <t> [^c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpCom32 { |
| continue |
| } |
| x := o.Args[0] |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(^c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Eq32 (Const32 <t> [c]) o:(Neg32 x)) |
| // cond: o.Uses == 1 |
| // result: (Eq32 (Const32 <t> [-c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpNeg32 { |
| continue |
| } |
| x := o.Args[0] |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(-c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Eq32 (Const32 <t> [c]) o:(Mul32 (Const32 [d]) x)) |
| // cond: uint32(d)%2 == 1 && o.Uses == 1 |
| // result: (Eq32 (Const32 <t> [int32(uint32(c) * uint32(modularMultiplicativeInverse(uint64(d))))]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpMul32 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(o_0.AuxInt) |
| x := o_1 |
| if !(uint32(d)%2 == 1 && o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(int32(uint32(c) * uint32(modularMultiplicativeInverse(uint64(d))))) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Eq32 (Const32 [c]) (Const32 [d])) |
| // result: (ConstBool [c == d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c == d) |
| return true |
| } |
| break |
| } |
| // match: (Eq32 s:(Sub32 x y) (Const32 [0])) |
| // cond: s.Uses == 1 |
| // result: (Eq32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| s := v_0 |
| if s.Op != ssaop.OpSub32 { |
| continue |
| } |
| y := s.Args[1] |
| x := s.Args[0] |
| if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 0 || !(s.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Eq32 (And32 <t> x (Const32 <t> [y])) (Const32 <t> [y])) |
| // cond: ssa.OneBit(y) |
| // result: (Neq32 (And32 <t> x (Const32 <t> [y])) (Const32 <t> [0])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAnd32 { |
| continue |
| } |
| t := v_0.Type |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst32 || v_0_1.Type != t { |
| continue |
| } |
| y := ssa.AuxIntToInt32(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst32 || v_1.Type != t || ssa.AuxIntToInt32(v_1.AuxInt) != y || !(ssa.OneBit(y)) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd32, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v1.AuxInt = ssa.Int32ToAuxInt(y) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v2.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Eq32 (ZeroExt8to32 (CvtBoolToUint8 x)) (Const32 [1])) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to32 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| x := v_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 1 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Eq32 (ZeroExt8to32 (CvtBoolToUint8 x)) (Const32 [0])) |
| // result: (Not x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to32 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| x := v_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 0 { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpEq32F(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (Eq32F (Const32F [c]) (Const32F [d])) |
| // result: (ConstBool [c == d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32F { |
| continue |
| } |
| c := ssa.AuxIntToFloat32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32F { |
| continue |
| } |
| d := ssa.AuxIntToFloat32(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c == d) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpEq64(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Eq64 x x) |
| // result: (ConstBool [true]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Eq64 (Const64 <t> [c]) o:(Add64 (Const64 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Eq64 (Const64 <t> [c-d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpAdd64 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(o_0.AuxInt) |
| x := o_1 |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c - d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Eq64 (Const64 <t> [c]) o:(Sub64 x (Const64 [d]))) |
| // cond: o.Uses == 1 |
| // result: (Eq64 (Const64 <t> [c+d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = o.Args[1] |
| x := o.Args[0] |
| o_1 := o.Args[1] |
| if o_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(o_1.AuxInt) |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c + d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Eq64 (Const64 <t> [c]) o:(Sub64 (Const64 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Eq64 (Const64 <t> [d-c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpSub64 { |
| continue |
| } |
| x := o.Args[1] |
| o_0 := o.Args[0] |
| if o_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(o_0.AuxInt) |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(d - c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Eq64 (Const64 <t> [c]) o:(Xor64 (Const64 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Eq64 (Const64 <t> [d^c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpXor64 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(o_0.AuxInt) |
| x := o_1 |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(d ^ c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Eq64 (Const64 <t> [c]) o:(Com64 x)) |
| // cond: o.Uses == 1 |
| // result: (Eq64 (Const64 <t> [^c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpCom64 { |
| continue |
| } |
| x := o.Args[0] |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(^c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Eq64 (Const64 <t> [c]) o:(Neg64 x)) |
| // cond: o.Uses == 1 |
| // result: (Eq64 (Const64 <t> [-c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpNeg64 { |
| continue |
| } |
| x := o.Args[0] |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(-c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Eq64 (Const64 <t> [c]) o:(Mul64 (Const64 [d]) x)) |
| // cond: uint64(d)%2 == 1 && o.Uses == 1 |
| // result: (Eq64 (Const64 <t> [int64(uint64(c) * modularMultiplicativeInverse(uint64(d))) ]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpMul64 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(o_0.AuxInt) |
| x := o_1 |
| if !(uint64(d)%2 == 1 && o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint64(c) * modularMultiplicativeInverse(uint64(d)))) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Eq64 (Const64 [c]) (Const64 [d])) |
| // result: (ConstBool [c == d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c == d) |
| return true |
| } |
| break |
| } |
| // match: (Eq64 s:(Sub64 x y) (Const64 [0])) |
| // cond: s.Uses == 1 |
| // result: (Eq64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| s := v_0 |
| if s.Op != ssaop.OpSub64 { |
| continue |
| } |
| y := s.Args[1] |
| x := s.Args[0] |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 || !(s.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Eq64 (And64 <t> x (Const64 <t> [y])) (Const64 <t> [y])) |
| // cond: ssa.OneBit(y) |
| // result: (Neq64 (And64 <t> x (Const64 <t> [y])) (Const64 <t> [0])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAnd64 { |
| continue |
| } |
| t := v_0.Type |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst64 || v_0_1.Type != t { |
| continue |
| } |
| y := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 || v_1.Type != t || ssa.AuxIntToInt64(v_1.AuxInt) != y || !(ssa.OneBit(y)) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v1.AuxInt = ssa.Int64ToAuxInt(y) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v2.AuxInt = ssa.Int64ToAuxInt(0) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Eq64 (ZeroExt8to64 (CvtBoolToUint8 x)) (Const64 [1])) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to64 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| x := v_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 1 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Eq64 (ZeroExt8to64 (CvtBoolToUint8 x)) (Const64 [0])) |
| // result: (Not x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to64 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| x := v_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpEq64F(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (Eq64F (Const64F [c]) (Const64F [d])) |
| // result: (ConstBool [c == d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64F { |
| continue |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64F { |
| continue |
| } |
| d := ssa.AuxIntToFloat64(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c == d) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpEq8(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: (Eq8 x x) |
| // result: (ConstBool [true]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Eq8 (Const8 <t> [c]) o:(Add8 (Const8 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Eq8 (Const8 <t> [c-d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpAdd8 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(o_0.AuxInt) |
| x := o_1 |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(c - d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Eq8 (Const8 <t> [c]) o:(Sub8 x (Const8 [d]))) |
| // cond: o.Uses == 1 |
| // result: (Eq8 (Const8 <t> [c+d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = o.Args[1] |
| x := o.Args[0] |
| o_1 := o.Args[1] |
| if o_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(o_1.AuxInt) |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(c + d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Eq8 (Const8 <t> [c]) o:(Sub8 (Const8 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Eq8 (Const8 <t> [d-c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpSub8 { |
| continue |
| } |
| x := o.Args[1] |
| o_0 := o.Args[0] |
| if o_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(o_0.AuxInt) |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(d - c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Eq8 (Const8 <t> [c]) o:(Xor8 (Const8 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Eq8 (Const8 <t> [d^c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpXor8 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(o_0.AuxInt) |
| x := o_1 |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(d ^ c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Eq8 (Const8 <t> [c]) o:(Com8 x)) |
| // cond: o.Uses == 1 |
| // result: (Eq8 (Const8 <t> [^c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpCom8 { |
| continue |
| } |
| x := o.Args[0] |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(^c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Eq8 (Const8 <t> [c]) o:(Neg8 x)) |
| // cond: o.Uses == 1 |
| // result: (Eq8 (Const8 <t> [-c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpNeg8 { |
| continue |
| } |
| x := o.Args[0] |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(-c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Eq8 (Const8 <t> [c]) o:(Mul8 (Const8 [d]) x)) |
| // cond: uint8( d)%2 == 1 && o.Uses == 1 |
| // result: (Eq8 (Const8 <t> [int8( uint8( c) * uint8( modularMultiplicativeInverse(uint64(d))))]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpMul8 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(o_0.AuxInt) |
| x := o_1 |
| if !(uint8(d)%2 == 1 && o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(int8(uint8(c) * uint8(modularMultiplicativeInverse(uint64(d))))) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Eq8 (Const8 [c]) (Const8 [d])) |
| // result: (ConstBool [c == d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c == d) |
| return true |
| } |
| break |
| } |
| // match: (Eq8 (Mod8u x (Const8 [c])) (Const8 [0])) |
| // cond: x.Op != ssaop.OpConst8 && ssa.UdivisibleOK8(c) && !hasSmallRotate(config) |
| // result: (Eq32 (Mod32u <typ.UInt32> (ZeroExt8to32 <typ.UInt32> x) (Const32 <typ.UInt32> [int32(uint8(c))])) (Const32 <typ.UInt32> [0])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpMod8u { |
| continue |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 0 || !(x.Op != ssaop.OpConst8 && ssa.UdivisibleOK8(c) && !hasSmallRotate(config)) { |
| continue |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMod32u, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, typ.UInt32) |
| v1.AddArg(x) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v2.AuxInt = ssa.Int32ToAuxInt(int32(uint8(c))) |
| v0.AddArg2(v1, v2) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v3.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(v0, v3) |
| return true |
| } |
| break |
| } |
| // match: (Eq8 (Mod8 x (Const8 [c])) (Const8 [0])) |
| // cond: x.Op != ssaop.OpConst8 && ssa.SdivisibleOK8(c) && !hasSmallRotate(config) |
| // result: (Eq32 (Mod32 <typ.Int32> (SignExt8to32 <typ.Int32> x) (Const32 <typ.Int32> [int32(c)])) (Const32 <typ.Int32> [0])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpMod8 { |
| continue |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 0 || !(x.Op != ssaop.OpConst8 && ssa.SdivisibleOK8(c) && !hasSmallRotate(config)) { |
| continue |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMod32, typ.Int32) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSignExt8to32, typ.Int32) |
| v1.AddArg(x) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32) |
| v2.AuxInt = ssa.Int32ToAuxInt(int32(c)) |
| v0.AddArg2(v1, v2) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32) |
| v3.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(v0, v3) |
| return true |
| } |
| break |
| } |
| // match: (Eq8 s:(Sub8 x y) (Const8 [0])) |
| // cond: s.Uses == 1 |
| // result: (Eq8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| s := v_0 |
| if s.Op != ssaop.OpSub8 { |
| continue |
| } |
| y := s.Args[1] |
| x := s.Args[0] |
| if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 0 || !(s.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpEq8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Eq8 (And8 <t> x (Const8 <t> [y])) (Const8 <t> [y])) |
| // cond: ssa.OneBit(y) |
| // result: (Neq8 (And8 <t> x (Const8 <t> [y])) (Const8 <t> [0])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAnd8 { |
| continue |
| } |
| t := v_0.Type |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst8 || v_0_1.Type != t { |
| continue |
| } |
| y := ssa.AuxIntToInt8(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst8 || v_1.Type != t || ssa.AuxIntToInt8(v_1.AuxInt) != y || !(ssa.OneBit(y)) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd8, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v1.AuxInt = ssa.Int8ToAuxInt(y) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v2.AuxInt = ssa.Int8ToAuxInt(0) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Eq8 (CvtBoolToUint8 x) (Const8 [1])) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 1 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Eq8 (CvtBoolToUint8 x) (Const8 [0])) |
| // result: (Not x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 0 { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpEqB(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (EqB x x) |
| // result: (ConstBool [true]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (EqB (ConstBool [c]) (ConstBool [d])) |
| // result: (ConstBool [c == d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConstBool { |
| continue |
| } |
| c := ssa.AuxIntToBool(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConstBool { |
| continue |
| } |
| d := ssa.AuxIntToBool(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c == d) |
| return true |
| } |
| break |
| } |
| // match: (EqB (ConstBool [false]) x) |
| // result: (Not x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != false { |
| continue |
| } |
| x := v_1 |
| v.Reset(ssaop.OpNot) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| // match: (EqB (ConstBool [true]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != true { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (EqB (Not x) y) |
| // result: (NeqB x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNot { |
| continue |
| } |
| x := v_0.Args[0] |
| y := v_1 |
| v.Reset(ssaop.OpNeqB) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpEqInter(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (EqInter x y) |
| // result: (EqPtr (ITab x) (ITab y)) |
| for { |
| x := v_0 |
| y := v_1 |
| v.Reset(ssaop.OpEqPtr) |
| v0 := b.NewValue0(v.Pos, ssaop.OpITab, typ.Uintptr) |
| v0.AddArg(x) |
| v1 := b.NewValue0(v.Pos, ssaop.OpITab, typ.Uintptr) |
| v1.AddArg(y) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| } |
| func rewriteValue_OpEqPtr(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (EqPtr x x) |
| // result: (ConstBool [true]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (EqPtr (Addr {x} _) (Addr {y} _)) |
| // result: (ConstBool [x == y]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAddr { |
| continue |
| } |
| x := ssa.AuxToSym(v_0.Aux) |
| if v_1.Op != ssaop.OpAddr { |
| continue |
| } |
| y := ssa.AuxToSym(v_1.Aux) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(x == y) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (Addr {x} _) (OffPtr [o] (Addr {y} _))) |
| // result: (ConstBool [x == y && o == 0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAddr { |
| continue |
| } |
| x := ssa.AuxToSym(v_0.Aux) |
| if v_1.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o := ssa.AuxIntToInt64(v_1.AuxInt) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAddr { |
| continue |
| } |
| y := ssa.AuxToSym(v_1_0.Aux) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(x == y && o == 0) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (OffPtr [o1] (Addr {x} _)) (OffPtr [o2] (Addr {y} _))) |
| // result: (ConstBool [x == y && o1 == o2]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o1 := ssa.AuxIntToInt64(v_0.AuxInt) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpAddr { |
| continue |
| } |
| x := ssa.AuxToSym(v_0_0.Aux) |
| if v_1.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o2 := ssa.AuxIntToInt64(v_1.AuxInt) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAddr { |
| continue |
| } |
| y := ssa.AuxToSym(v_1_0.Aux) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(x == y && o1 == o2) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (LocalAddr {x} _ _) (LocalAddr {y} _ _)) |
| // result: (ConstBool [x == y]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLocalAddr { |
| continue |
| } |
| x := ssa.AuxToSym(v_0.Aux) |
| if v_1.Op != ssaop.OpLocalAddr { |
| continue |
| } |
| y := ssa.AuxToSym(v_1.Aux) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(x == y) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (LocalAddr {x} _ _) (OffPtr [o] (LocalAddr {y} _ _))) |
| // result: (ConstBool [x == y && o == 0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLocalAddr { |
| continue |
| } |
| x := ssa.AuxToSym(v_0.Aux) |
| if v_1.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o := ssa.AuxIntToInt64(v_1.AuxInt) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpLocalAddr { |
| continue |
| } |
| y := ssa.AuxToSym(v_1_0.Aux) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(x == y && o == 0) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (OffPtr [o1] (LocalAddr {x} _ _)) (OffPtr [o2] (LocalAddr {y} _ _))) |
| // result: (ConstBool [x == y && o1 == o2]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o1 := ssa.AuxIntToInt64(v_0.AuxInt) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpLocalAddr { |
| continue |
| } |
| x := ssa.AuxToSym(v_0_0.Aux) |
| if v_1.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o2 := ssa.AuxIntToInt64(v_1.AuxInt) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpLocalAddr { |
| continue |
| } |
| y := ssa.AuxToSym(v_1_0.Aux) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(x == y && o1 == o2) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (OffPtr [o1] p1) p2) |
| // cond: ssa.IsSamePtr(p1, p2) |
| // result: (ConstBool [o1 == 0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o1 := ssa.AuxIntToInt64(v_0.AuxInt) |
| p1 := v_0.Args[0] |
| p2 := v_1 |
| if !(ssa.IsSamePtr(p1, p2)) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(o1 == 0) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (OffPtr [o1] p1) (OffPtr [o2] p2)) |
| // cond: ssa.IsSamePtr(p1, p2) |
| // result: (ConstBool [o1 == o2]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o1 := ssa.AuxIntToInt64(v_0.AuxInt) |
| p1 := v_0.Args[0] |
| if v_1.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o2 := ssa.AuxIntToInt64(v_1.AuxInt) |
| p2 := v_1.Args[0] |
| if !(ssa.IsSamePtr(p1, p2)) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(o1 == o2) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (Const32 [c]) (Const32 [d])) |
| // result: (ConstBool [c == d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c == d) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (Const64 [c]) (Const64 [d])) |
| // result: (ConstBool [c == d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c == d) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (Convert (Addr {x} _) _) (Addr {y} _)) |
| // result: (ConstBool [x==y]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConvert { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpAddr { |
| continue |
| } |
| x := ssa.AuxToSym(v_0_0.Aux) |
| if v_1.Op != ssaop.OpAddr { |
| continue |
| } |
| y := ssa.AuxToSym(v_1.Aux) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(x == y) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (LocalAddr _ _) (Addr _)) |
| // result: (ConstBool [false]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLocalAddr || v_1.Op != ssaop.OpAddr { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (OffPtr (LocalAddr _ _)) (Addr _)) |
| // result: (ConstBool [false]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpOffPtr { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpLocalAddr || v_1.Op != ssaop.OpAddr { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (LocalAddr _ _) (OffPtr (Addr _))) |
| // result: (ConstBool [false]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLocalAddr || v_1.Op != ssaop.OpOffPtr { |
| continue |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAddr { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (OffPtr (LocalAddr _ _)) (OffPtr (Addr _))) |
| // result: (ConstBool [false]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpOffPtr { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpLocalAddr || v_1.Op != ssaop.OpOffPtr { |
| continue |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAddr { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (AddPtr p1 o1) p2) |
| // cond: ssa.IsSamePtr(p1, p2) |
| // result: (Not (IsNonNil o1)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAddPtr { |
| continue |
| } |
| o1 := v_0.Args[1] |
| p1 := v_0.Args[0] |
| p2 := v_1 |
| if !(ssa.IsSamePtr(p1, p2)) { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpIsNonNil, typ.Bool) |
| v0.AddArg(o1) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (Const32 [0]) p) |
| // result: (Not (IsNonNil p)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| continue |
| } |
| p := v_1 |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpIsNonNil, typ.Bool) |
| v0.AddArg(p) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (Const64 [0]) p) |
| // result: (Not (IsNonNil p)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| continue |
| } |
| p := v_1 |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpIsNonNil, typ.Bool) |
| v0.AddArg(p) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (EqPtr (ConstNil) p) |
| // result: (Not (IsNonNil p)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConstNil { |
| continue |
| } |
| p := v_1 |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpIsNonNil, typ.Bool) |
| v0.AddArg(p) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpEqSlice(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (EqSlice x y) |
| // result: (EqPtr (SlicePtr x) (SlicePtr y)) |
| for { |
| x := v_0 |
| y := v_1 |
| v.Reset(ssaop.OpEqPtr) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSlicePtr, typ.BytePtr) |
| v0.AddArg(x) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSlicePtr, typ.BytePtr) |
| v1.AddArg(y) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| } |
| func rewriteValue_OpFloor(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Floor (Const64F [c])) |
| // result: (Const64F [math.Floor(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst64F { |
| break |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64F) |
| v.AuxInt = ssa.Float64ToAuxInt(math.Floor(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpIMake(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (IMake _typ (StructMake ___)) |
| // result: ssa.ImakeOfStructMake(v) |
| for { |
| if v_1.Op != ssaop.OpStructMake { |
| break |
| } |
| v.CopyOf(ssa.ImakeOfStructMake(v)) |
| return true |
| } |
| // match: (IMake _typ (ArrayMake1 val)) |
| // result: (IMake _typ val) |
| for { |
| _typ := v_0 |
| if v_1.Op != ssaop.OpArrayMake1 { |
| break |
| } |
| val := v_1.Args[0] |
| v.Reset(ssaop.OpIMake) |
| v.AddArg2(_typ, val) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpInterLECall(v *ssa.Value) bool { |
| // match: (InterLECall [argsize] {auxCall} (Addr {fn} (SB)) ___) |
| // result: devirtLECall(v, fn.(*obj.LSym)) |
| for { |
| if len(v.Args) < 1 { |
| break |
| } |
| v_0 := v.Args[0] |
| if v_0.Op != ssaop.OpAddr { |
| break |
| } |
| fn := ssa.AuxToSym(v_0.Aux) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpSB { |
| break |
| } |
| v.CopyOf(devirtLECall(v, fn.(*obj.LSym))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpIsInBounds(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (IsInBounds (ZeroExt8to32 _) (Const32 [c])) |
| // cond: (1 << 8) <= c |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpZeroExt8to32 || v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !((1 << 8) <= c) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsInBounds (ZeroExt8to64 _) (Const64 [c])) |
| // cond: (1 << 8) <= c |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpZeroExt8to64 || v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !((1 << 8) <= c) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsInBounds (ZeroExt16to32 _) (Const32 [c])) |
| // cond: (1 << 16) <= c |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpZeroExt16to32 || v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !((1 << 16) <= c) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsInBounds (ZeroExt16to64 _) (Const64 [c])) |
| // cond: (1 << 16) <= c |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpZeroExt16to64 || v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !((1 << 16) <= c) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsInBounds x x) |
| // result: (ConstBool [false]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (IsInBounds (And8 (Const8 [c]) _) (Const8 [d])) |
| // cond: 0 <= c && c < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpAnd8 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(0 <= c && c < d) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (IsInBounds (ZeroExt8to16 (And8 (Const8 [c]) _)) (Const16 [d])) |
| // cond: 0 <= c && int16(c) < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpZeroExt8to16 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpAnd8 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0_0, v_0_0_1 = _i0+1, v_0_0_1, v_0_0_0 { |
| if v_0_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(0 <= c && int16(c) < d) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (IsInBounds (ZeroExt8to32 (And8 (Const8 [c]) _)) (Const32 [d])) |
| // cond: 0 <= c && int32(c) < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpZeroExt8to32 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpAnd8 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0_0, v_0_0_1 = _i0+1, v_0_0_1, v_0_0_0 { |
| if v_0_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(0 <= c && int32(c) < d) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (IsInBounds (ZeroExt8to64 (And8 (Const8 [c]) _)) (Const64 [d])) |
| // cond: 0 <= c && int64(c) < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpZeroExt8to64 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpAnd8 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0_0, v_0_0_1 = _i0+1, v_0_0_1, v_0_0_0 { |
| if v_0_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(0 <= c && int64(c) < d) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (IsInBounds (And16 (Const16 [c]) _) (Const16 [d])) |
| // cond: 0 <= c && c < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpAnd16 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(0 <= c && c < d) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (IsInBounds (ZeroExt16to32 (And16 (Const16 [c]) _)) (Const32 [d])) |
| // cond: 0 <= c && int32(c) < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpZeroExt16to32 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpAnd16 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0_0, v_0_0_1 = _i0+1, v_0_0_1, v_0_0_0 { |
| if v_0_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(0 <= c && int32(c) < d) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (IsInBounds (ZeroExt16to64 (And16 (Const16 [c]) _)) (Const64 [d])) |
| // cond: 0 <= c && int64(c) < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpZeroExt16to64 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpAnd16 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0_0, v_0_0_1 = _i0+1, v_0_0_1, v_0_0_0 { |
| if v_0_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(0 <= c && int64(c) < d) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (IsInBounds (And32 (Const32 [c]) _) (Const32 [d])) |
| // cond: 0 <= c && c < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpAnd32 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(0 <= c && c < d) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (IsInBounds (ZeroExt32to64 (And32 (Const32 [c]) _)) (Const64 [d])) |
| // cond: 0 <= c && int64(c) < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpZeroExt32to64 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpAnd32 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0_0, v_0_0_1 = _i0+1, v_0_0_1, v_0_0_0 { |
| if v_0_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(0 <= c && int64(c) < d) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (IsInBounds (And64 (Const64 [c]) _) (Const64 [d])) |
| // cond: 0 <= c && c < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpAnd64 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(0 <= c && c < d) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (IsInBounds (Const32 [c]) (Const32 [d])) |
| // result: (ConstBool [0 <= c && c < d]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(0 <= c && c < d) |
| return true |
| } |
| // match: (IsInBounds (Const64 [c]) (Const64 [d])) |
| // result: (ConstBool [0 <= c && c < d]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(0 <= c && c < d) |
| return true |
| } |
| // match: (IsInBounds (Mod32u _ y) y) |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpMod32u { |
| break |
| } |
| y := v_0.Args[1] |
| if y != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsInBounds (Mod64u _ y) y) |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpMod64u { |
| break |
| } |
| y := v_0.Args[1] |
| if y != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsInBounds (ZeroExt8to64 (Rsh8Ux64 _ (Const64 [c]))) (Const64 [d])) |
| // cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpZeroExt8to64 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpRsh8Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsInBounds (ZeroExt8to32 (Rsh8Ux64 _ (Const64 [c]))) (Const32 [d])) |
| // cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpZeroExt8to32 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpRsh8Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsInBounds (ZeroExt8to16 (Rsh8Ux64 _ (Const64 [c]))) (Const16 [d])) |
| // cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpZeroExt8to16 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpRsh8Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsInBounds (Rsh8Ux64 _ (Const64 [c])) (Const8 [d])) |
| // cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpRsh8Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsInBounds (ZeroExt16to64 (Rsh16Ux64 _ (Const64 [c]))) (Const64 [d])) |
| // cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpZeroExt16to64 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpRsh16Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsInBounds (ZeroExt16to32 (Rsh16Ux64 _ (Const64 [c]))) (Const32 [d])) |
| // cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpZeroExt16to32 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpRsh16Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsInBounds (Rsh16Ux64 _ (Const64 [c])) (Const16 [d])) |
| // cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpRsh16Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsInBounds (ZeroExt32to64 (Rsh32Ux64 _ (Const64 [c]))) (Const64 [d])) |
| // cond: 0 < c && c < 32 && 1<<uint(32-c)-1 < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpZeroExt32to64 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(0 < c && c < 32 && 1<<uint(32-c)-1 < d) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsInBounds (Rsh32Ux64 _ (Const64 [c])) (Const32 [d])) |
| // cond: 0 < c && c < 32 && 1<<uint(32-c)-1 < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpRsh32Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(0 < c && c < 32 && 1<<uint(32-c)-1 < d) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsInBounds (Rsh64Ux64 _ (Const64 [c])) (Const64 [d])) |
| // cond: 0 < c && c < 64 && 1<<uint(64-c)-1 < d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpRsh64Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(0 < c && c < 64 && 1<<uint(64-c)-1 < d) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpIsNonNil(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (IsNonNil (ConstNil)) |
| // result: (ConstBool [false]) |
| for { |
| if v_0.Op != ssaop.OpConstNil { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (IsNonNil (Const32 [c])) |
| // result: (ConstBool [c != 0]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c != 0) |
| return true |
| } |
| // match: (IsNonNil (Const64 [c])) |
| // result: (ConstBool [c != 0]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c != 0) |
| return true |
| } |
| // match: (IsNonNil (Addr _) ) |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpAddr { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsNonNil (Convert (Addr _) _)) |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConvert { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpAddr { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsNonNil (LocalAddr _ _)) |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpLocalAddr { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpIsSliceInBounds(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (IsSliceInBounds x x) |
| // result: (ConstBool [true]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsSliceInBounds (And32 (Const32 [c]) _) (Const32 [d])) |
| // cond: 0 <= c && c <= d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpAnd32 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(0 <= c && c <= d) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (IsSliceInBounds (And64 (Const64 [c]) _) (Const64 [d])) |
| // cond: 0 <= c && c <= d |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpAnd64 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(0 <= c && c <= d) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (IsSliceInBounds (Const32 [0]) _) |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsSliceInBounds (Const64 [0]) _) |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (IsSliceInBounds (Const32 [c]) (Const32 [d])) |
| // result: (ConstBool [0 <= c && c <= d]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(0 <= c && c <= d) |
| return true |
| } |
| // match: (IsSliceInBounds (Const64 [c]) (Const64 [d])) |
| // result: (ConstBool [0 <= c && c <= d]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(0 <= c && c <= d) |
| return true |
| } |
| // match: (IsSliceInBounds (SliceLen x) (SliceCap x)) |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpSliceLen { |
| break |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpSliceCap || x != v_1.Args[0] { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLeq16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Leq16 (Const16 [c]) (Const16 [d])) |
| // result: (ConstBool [c <= d]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c <= d) |
| return true |
| } |
| // match: (Leq16 (Const16 [0]) (And16 _ (Const16 [c]))) |
| // cond: c >= 0 |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 || v_1.Op != ssaop.OpAnd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(c >= 0) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (Leq16 (Const16 [0]) (Rsh16Ux64 _ (Const64 [c]))) |
| // cond: c > 0 |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 || v_1.Op != ssaop.OpRsh16Ux64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c > 0) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq16 x (Const16 <t> [0])) |
| // cond: isNonNegative(x) |
| // result: (Eq16 (Const16 <t> [0]) x) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt16(v_1.AuxInt) != 0 || !(isNonNegative(x)) { |
| break |
| } |
| v.Reset(ssaop.OpEq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Leq16 x (Const16 <t> [-1])) |
| // result: (Less16 x (Const16 <t> [0])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt16(v_1.AuxInt) != -1 { |
| break |
| } |
| v.Reset(ssaop.OpLess16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(0) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Leq16 (Const16 <t> [1]) x) |
| // result: (Less16 (Const16 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt16(v_0.AuxInt) != 1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpLess16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Leq16 (Const16 [math.MinInt16]) _) |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != math.MinInt16 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq16 _ (Const16 [math.MaxInt16])) |
| // result: (ConstBool [true]) |
| for { |
| if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != math.MaxInt16 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq16 x c:(Const16 [math.MinInt16])) |
| // result: (Eq16 x c) |
| for { |
| x := v_0 |
| c := v_1 |
| if c.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(c.AuxInt) != math.MinInt16 { |
| break |
| } |
| v.Reset(ssaop.OpEq16) |
| v.AddArg2(x, c) |
| return true |
| } |
| // match: (Leq16 c:(Const16 [math.MaxInt16]) x) |
| // result: (Eq16 x c) |
| for { |
| c := v_0 |
| if c.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(c.AuxInt) != math.MaxInt16 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpEq16) |
| v.AddArg2(x, c) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLeq16U(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Leq16U (Const16 [c]) (Const16 [d])) |
| // result: (ConstBool [uint16(c) <= uint16(d)]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(uint16(c) <= uint16(d)) |
| return true |
| } |
| // match: (Leq16U (Const16 <t> [1]) x) |
| // result: (Neq16 (Const16 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt16(v_0.AuxInt) != 1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpNeq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Leq16U (Const16 [0]) _) |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq16U _ (Const16 [-1])) |
| // result: (ConstBool [true]) |
| for { |
| if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != -1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq16U x c:(Const16 [0])) |
| // result: (Eq16 x c) |
| for { |
| x := v_0 |
| c := v_1 |
| if c.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(c.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpEq16) |
| v.AddArg2(x, c) |
| return true |
| } |
| // match: (Leq16U c:(Const16 [-1]) x) |
| // result: (Eq16 x c) |
| for { |
| c := v_0 |
| if c.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(c.AuxInt) != -1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpEq16) |
| v.AddArg2(x, c) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLeq32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Leq32 (Const32 [c]) (Const32 [d])) |
| // result: (ConstBool [c <= d]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c <= d) |
| return true |
| } |
| // match: (Leq32 (Const32 [0]) (And32 _ (Const32 [c]))) |
| // cond: c >= 0 |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 || v_1.Op != ssaop.OpAnd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(c >= 0) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (Leq32 (Const32 [0]) (Rsh32Ux64 _ (Const64 [c]))) |
| // cond: c > 0 |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 || v_1.Op != ssaop.OpRsh32Ux64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c > 0) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq32 x (Const32 <t> [0])) |
| // cond: isNonNegative(x) |
| // result: (Eq32 (Const32 <t> [0]) x) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt32(v_1.AuxInt) != 0 || !(isNonNegative(x)) { |
| break |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Leq32 x (Const32 <t> [-1])) |
| // result: (Less32 x (Const32 <t> [0])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt32(v_1.AuxInt) != -1 { |
| break |
| } |
| v.Reset(ssaop.OpLess32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Leq32 (Const32 <t> [1]) x) |
| // result: (Less32 (Const32 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt32(v_0.AuxInt) != 1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpLess32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Leq32 (Const32 [math.MinInt32]) _) |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != math.MinInt32 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq32 _ (Const32 [math.MaxInt32])) |
| // result: (ConstBool [true]) |
| for { |
| if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != math.MaxInt32 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq32 x c:(Const32 [math.MinInt32])) |
| // result: (Eq32 x c) |
| for { |
| x := v_0 |
| c := v_1 |
| if c.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(c.AuxInt) != math.MinInt32 { |
| break |
| } |
| v.Reset(ssaop.OpEq32) |
| v.AddArg2(x, c) |
| return true |
| } |
| // match: (Leq32 c:(Const32 [math.MaxInt32]) x) |
| // result: (Eq32 x c) |
| for { |
| c := v_0 |
| if c.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(c.AuxInt) != math.MaxInt32 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpEq32) |
| v.AddArg2(x, c) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLeq32F(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (Leq32F (Const32F [c]) (Const32F [d])) |
| // result: (ConstBool [c <= d]) |
| for { |
| if v_0.Op != ssaop.OpConst32F { |
| break |
| } |
| c := ssa.AuxIntToFloat32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32F { |
| break |
| } |
| d := ssa.AuxIntToFloat32(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c <= d) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLeq32U(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Leq32U (Const32 [c]) (Const32 [d])) |
| // result: (ConstBool [uint32(c) <= uint32(d)]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(uint32(c) <= uint32(d)) |
| return true |
| } |
| // match: (Leq32U (Const32 <t> [1]) x) |
| // result: (Neq32 (Const32 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt32(v_0.AuxInt) != 1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpNeq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Leq32U (Const32 [0]) _) |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq32U _ (Const32 [-1])) |
| // result: (ConstBool [true]) |
| for { |
| if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != -1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq32U x c:(Const32 [0])) |
| // result: (Eq32 x c) |
| for { |
| x := v_0 |
| c := v_1 |
| if c.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(c.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpEq32) |
| v.AddArg2(x, c) |
| return true |
| } |
| // match: (Leq32U c:(Const32 [-1]) x) |
| // result: (Eq32 x c) |
| for { |
| c := v_0 |
| if c.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(c.AuxInt) != -1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpEq32) |
| v.AddArg2(x, c) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLeq64(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Leq64 (Const64 [c]) (Const64 [d])) |
| // result: (ConstBool [c <= d]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c <= d) |
| return true |
| } |
| // match: (Leq64 (Const64 [0]) (And64 _ (Const64 [c]))) |
| // cond: c >= 0 |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 || v_1.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c >= 0) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (Leq64 (Const64 [0]) (Rsh64Ux64 _ (Const64 [c]))) |
| // cond: c > 0 |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 || v_1.Op != ssaop.OpRsh64Ux64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c > 0) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq64 x (Const64 <t> [0])) |
| // cond: isNonNegative(x) |
| // result: (Eq64 (Const64 <t> [0]) x) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt64(v_1.AuxInt) != 0 || !(isNonNegative(x)) { |
| break |
| } |
| v.Reset(ssaop.OpEq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Leq64 x (Const64 <t> [-1])) |
| // result: (Less64 x (Const64 <t> [0])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt64(v_1.AuxInt) != -1 { |
| break |
| } |
| v.Reset(ssaop.OpLess64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(0) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Leq64 (Const64 <t> [1]) x) |
| // result: (Less64 (Const64 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt64(v_0.AuxInt) != 1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpLess64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Leq64 (Const64 [math.MinInt64]) _) |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != math.MinInt64 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq64 _ (Const64 [math.MaxInt64])) |
| // result: (ConstBool [true]) |
| for { |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != math.MaxInt64 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq64 x c:(Const64 [math.MinInt64])) |
| // result: (Eq64 x c) |
| for { |
| x := v_0 |
| c := v_1 |
| if c.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(c.AuxInt) != math.MinInt64 { |
| break |
| } |
| v.Reset(ssaop.OpEq64) |
| v.AddArg2(x, c) |
| return true |
| } |
| // match: (Leq64 c:(Const64 [math.MaxInt64]) x) |
| // result: (Eq64 x c) |
| for { |
| c := v_0 |
| if c.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(c.AuxInt) != math.MaxInt64 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpEq64) |
| v.AddArg2(x, c) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLeq64F(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (Leq64F (Const64F [c]) (Const64F [d])) |
| // result: (ConstBool [c <= d]) |
| for { |
| if v_0.Op != ssaop.OpConst64F { |
| break |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64F { |
| break |
| } |
| d := ssa.AuxIntToFloat64(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c <= d) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLeq64U(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Leq64U (Const64 [c]) (Const64 [d])) |
| // result: (ConstBool [uint64(c) <= uint64(d)]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(uint64(c) <= uint64(d)) |
| return true |
| } |
| // match: (Leq64U (Const64 <t> [1]) x) |
| // result: (Neq64 (Const64 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt64(v_0.AuxInt) != 1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpNeq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Leq64U (Const64 [0]) _) |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq64U _ (Const64 [-1])) |
| // result: (ConstBool [true]) |
| for { |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != -1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq64U x c:(Const64 [0])) |
| // result: (Eq64 x c) |
| for { |
| x := v_0 |
| c := v_1 |
| if c.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(c.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpEq64) |
| v.AddArg2(x, c) |
| return true |
| } |
| // match: (Leq64U c:(Const64 [-1]) x) |
| // result: (Eq64 x c) |
| for { |
| c := v_0 |
| if c.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(c.AuxInt) != -1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpEq64) |
| v.AddArg2(x, c) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLeq8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Leq8 (Const8 [c]) (Const8 [d])) |
| // result: (ConstBool [c <= d]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c <= d) |
| return true |
| } |
| // match: (Leq8 (Const8 [0]) (And8 _ (Const8 [c]))) |
| // cond: c >= 0 |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 || v_1.Op != ssaop.OpAnd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(c >= 0) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (Leq8 (Const8 [0]) (Rsh8Ux64 _ (Const64 [c]))) |
| // cond: c > 0 |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 || v_1.Op != ssaop.OpRsh8Ux64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c > 0) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq8 x (Const8 <t> [0])) |
| // cond: isNonNegative(x) |
| // result: (Eq8 (Const8 <t> [0]) x) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt8(v_1.AuxInt) != 0 || !(isNonNegative(x)) { |
| break |
| } |
| v.Reset(ssaop.OpEq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Leq8 x (Const8 <t> [-1])) |
| // result: (Less8 x (Const8 <t> [0])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt8(v_1.AuxInt) != -1 { |
| break |
| } |
| v.Reset(ssaop.OpLess8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(0) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Leq8 (Const8 <t> [1]) x) |
| // result: (Less8 (Const8 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt8(v_0.AuxInt) != 1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpLess8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Leq8 (Const8 [math.MinInt8 ]) _) |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != math.MinInt8 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq8 _ (Const8 [math.MaxInt8 ])) |
| // result: (ConstBool [true]) |
| for { |
| if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != math.MaxInt8 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq8 x c:(Const8 [math.MinInt8 ])) |
| // result: (Eq8 x c) |
| for { |
| x := v_0 |
| c := v_1 |
| if c.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(c.AuxInt) != math.MinInt8 { |
| break |
| } |
| v.Reset(ssaop.OpEq8) |
| v.AddArg2(x, c) |
| return true |
| } |
| // match: (Leq8 c:(Const8 [math.MaxInt8 ]) x) |
| // result: (Eq8 x c) |
| for { |
| c := v_0 |
| if c.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(c.AuxInt) != math.MaxInt8 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpEq8) |
| v.AddArg2(x, c) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLeq8U(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Leq8U (Const8 [c]) (Const8 [d])) |
| // result: (ConstBool [ uint8(c) <= uint8(d)]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(uint8(c) <= uint8(d)) |
| return true |
| } |
| // match: (Leq8U (Const8 <t> [1]) x) |
| // result: (Neq8 (Const8 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt8(v_0.AuxInt) != 1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpNeq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Leq8U (Const8 [0]) _) |
| // result: (ConstBool [true]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq8U _ (Const8 [-1])) |
| // result: (ConstBool [true]) |
| for { |
| if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != -1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (Leq8U x c:(Const8 [0])) |
| // result: (Eq8 x c) |
| for { |
| x := v_0 |
| c := v_1 |
| if c.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(c.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpEq8) |
| v.AddArg2(x, c) |
| return true |
| } |
| // match: (Leq8U c:(Const8 [-1]) x) |
| // result: (Eq8 x c) |
| for { |
| c := v_0 |
| if c.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(c.AuxInt) != -1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpEq8) |
| v.AddArg2(x, c) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLess16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Less16 (Const16 [c]) (Const16 [d])) |
| // result: (ConstBool [c < d]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c < d) |
| return true |
| } |
| // match: (Less16 (Const16 <t> [0]) x) |
| // cond: isNonNegative(x) |
| // result: (Neq16 (Const16 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| break |
| } |
| x := v_1 |
| if !(isNonNegative(x)) { |
| break |
| } |
| v.Reset(ssaop.OpNeq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Less16 x (Const16 <t> [1])) |
| // result: (Leq16 x (Const16 <t> [0])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt16(v_1.AuxInt) != 1 { |
| break |
| } |
| v.Reset(ssaop.OpLeq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(0) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Less16 (Const16 <t> [-1]) x) |
| // result: (Leq16 (Const16 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt16(v_0.AuxInt) != -1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpLeq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Less16 _ (Const16 [math.MinInt16])) |
| // result: (ConstBool [false]) |
| for { |
| if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != math.MinInt16 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Less16 (Const16 [math.MaxInt16]) _) |
| // result: (ConstBool [false]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != math.MaxInt16 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Less16 x (Const16 <t> [math.MinInt16+1])) |
| // result: (Eq16 x (Const16 <t> [math.MinInt16])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt16(v_1.AuxInt) != math.MinInt16+1 { |
| break |
| } |
| v.Reset(ssaop.OpEq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(math.MinInt16) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Less16 (Const16 <t> [math.MaxInt16-1]) x) |
| // result: (Eq16 x (Const16 <t> [math.MaxInt16])) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt16(v_0.AuxInt) != math.MaxInt16-1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpEq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(math.MaxInt16) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLess16U(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Less16U (Const16 [c]) (Const16 [d])) |
| // result: (ConstBool [uint16(c) < uint16(d)]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(uint16(c) < uint16(d)) |
| return true |
| } |
| // match: (Less16U (Const16 <t> [0]) x) |
| // result: (Neq16 (Const16 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpNeq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Less16U x (Const16 <t> [1])) |
| // result: (Eq16 (Const16 <t> [0]) x) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt16(v_1.AuxInt) != 1 { |
| break |
| } |
| v.Reset(ssaop.OpEq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Less16U _ (Const16 [0])) |
| // result: (ConstBool [false]) |
| for { |
| if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Less16U (Const16 [-1]) _) |
| // result: (ConstBool [false]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != -1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Less16U x (Const16 <t> [1])) |
| // result: (Eq16 x (Const16 <t> [0])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt16(v_1.AuxInt) != 1 { |
| break |
| } |
| v.Reset(ssaop.OpEq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(0) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Less16U (Const16 <t> [-2]) x) |
| // result: (Eq16 x (Const16 <t> [-1])) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt16(v_0.AuxInt) != -2 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpEq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(-1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLess32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Less32 (Const32 [c]) (Const32 [d])) |
| // result: (ConstBool [c < d]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c < d) |
| return true |
| } |
| // match: (Less32 (Const32 <t> [0]) x) |
| // cond: isNonNegative(x) |
| // result: (Neq32 (Const32 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| x := v_1 |
| if !(isNonNegative(x)) { |
| break |
| } |
| v.Reset(ssaop.OpNeq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Less32 x (Const32 <t> [1])) |
| // result: (Leq32 x (Const32 <t> [0])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt32(v_1.AuxInt) != 1 { |
| break |
| } |
| v.Reset(ssaop.OpLeq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Less32 (Const32 <t> [-1]) x) |
| // result: (Leq32 (Const32 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt32(v_0.AuxInt) != -1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpLeq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Less32 _ (Const32 [math.MinInt32])) |
| // result: (ConstBool [false]) |
| for { |
| if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != math.MinInt32 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Less32 (Const32 [math.MaxInt32]) _) |
| // result: (ConstBool [false]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != math.MaxInt32 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Less32 x (Const32 <t> [math.MinInt32+1])) |
| // result: (Eq32 x (Const32 <t> [math.MinInt32])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt32(v_1.AuxInt) != math.MinInt32+1 { |
| break |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(math.MinInt32) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Less32 (Const32 <t> [math.MaxInt32-1]) x) |
| // result: (Eq32 x (Const32 <t> [math.MaxInt32])) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt32(v_0.AuxInt) != math.MaxInt32-1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(math.MaxInt32) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLess32F(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (Less32F (Const32F [c]) (Const32F [d])) |
| // result: (ConstBool [c < d]) |
| for { |
| if v_0.Op != ssaop.OpConst32F { |
| break |
| } |
| c := ssa.AuxIntToFloat32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32F { |
| break |
| } |
| d := ssa.AuxIntToFloat32(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c < d) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLess32U(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Less32U (Const32 [c]) (Const32 [d])) |
| // result: (ConstBool [uint32(c) < uint32(d)]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(uint32(c) < uint32(d)) |
| return true |
| } |
| // match: (Less32U (Const32 <t> [0]) x) |
| // result: (Neq32 (Const32 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpNeq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Less32U x (Const32 <t> [1])) |
| // result: (Eq32 (Const32 <t> [0]) x) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt32(v_1.AuxInt) != 1 { |
| break |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Less32U _ (Const32 [0])) |
| // result: (ConstBool [false]) |
| for { |
| if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Less32U (Const32 [-1]) _) |
| // result: (ConstBool [false]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != -1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Less32U x (Const32 <t> [1])) |
| // result: (Eq32 x (Const32 <t> [0])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt32(v_1.AuxInt) != 1 { |
| break |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Less32U (Const32 <t> [-2]) x) |
| // result: (Eq32 x (Const32 <t> [-1])) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt32(v_0.AuxInt) != -2 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(-1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLess64(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Less64 (Const64 [c]) (Const64 [d])) |
| // result: (ConstBool [c < d]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c < d) |
| return true |
| } |
| // match: (Less64 (Const64 <t> [0]) x) |
| // cond: isNonNegative(x) |
| // result: (Neq64 (Const64 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| x := v_1 |
| if !(isNonNegative(x)) { |
| break |
| } |
| v.Reset(ssaop.OpNeq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Less64 x (Const64 <t> [1])) |
| // result: (Leq64 x (Const64 <t> [0])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt64(v_1.AuxInt) != 1 { |
| break |
| } |
| v.Reset(ssaop.OpLeq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(0) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Less64 (Const64 <t> [-1]) x) |
| // result: (Leq64 (Const64 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt64(v_0.AuxInt) != -1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpLeq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Less64 _ (Const64 [math.MinInt64])) |
| // result: (ConstBool [false]) |
| for { |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != math.MinInt64 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Less64 (Const64 [math.MaxInt64]) _) |
| // result: (ConstBool [false]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != math.MaxInt64 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Less64 x (Const64 <t> [math.MinInt64+1])) |
| // result: (Eq64 x (Const64 <t> [math.MinInt64])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt64(v_1.AuxInt) != math.MinInt64+1 { |
| break |
| } |
| v.Reset(ssaop.OpEq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(math.MinInt64) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Less64 (Const64 <t> [math.MaxInt64-1]) x) |
| // result: (Eq64 x (Const64 <t> [math.MaxInt64])) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt64(v_0.AuxInt) != math.MaxInt64-1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpEq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(math.MaxInt64) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLess64F(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (Less64F (Const64F [c]) (Const64F [d])) |
| // result: (ConstBool [c < d]) |
| for { |
| if v_0.Op != ssaop.OpConst64F { |
| break |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64F { |
| break |
| } |
| d := ssa.AuxIntToFloat64(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c < d) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLess64U(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Less64U (Const64 [c]) (Const64 [d])) |
| // result: (ConstBool [uint64(c) < uint64(d)]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(uint64(c) < uint64(d)) |
| return true |
| } |
| // match: (Less64U (Const64 <t> [0]) x) |
| // result: (Neq64 (Const64 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpNeq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Less64U x (Const64 <t> [1])) |
| // result: (Eq64 (Const64 <t> [0]) x) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt64(v_1.AuxInt) != 1 { |
| break |
| } |
| v.Reset(ssaop.OpEq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Less64U _ (Const64 [0])) |
| // result: (ConstBool [false]) |
| for { |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Less64U (Const64 [-1]) _) |
| // result: (ConstBool [false]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != -1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Less64U x (Const64 <t> [1])) |
| // result: (Eq64 x (Const64 <t> [0])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt64(v_1.AuxInt) != 1 { |
| break |
| } |
| v.Reset(ssaop.OpEq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(0) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Less64U (Const64 <t> [-2]) x) |
| // result: (Eq64 x (Const64 <t> [-1])) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt64(v_0.AuxInt) != -2 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpEq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(-1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLess8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Less8 (Const8 [c]) (Const8 [d])) |
| // result: (ConstBool [c < d]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c < d) |
| return true |
| } |
| // match: (Less8 (Const8 <t> [0]) x) |
| // cond: isNonNegative(x) |
| // result: (Neq8 (Const8 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| break |
| } |
| x := v_1 |
| if !(isNonNegative(x)) { |
| break |
| } |
| v.Reset(ssaop.OpNeq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Less8 x (Const8 <t> [1])) |
| // result: (Leq8 x (Const8 <t> [0])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt8(v_1.AuxInt) != 1 { |
| break |
| } |
| v.Reset(ssaop.OpLeq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(0) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Less8 (Const8 <t> [-1]) x) |
| // result: (Leq8 (Const8 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt8(v_0.AuxInt) != -1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpLeq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Less8 _ (Const8 [math.MinInt8 ])) |
| // result: (ConstBool [false]) |
| for { |
| if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != math.MinInt8 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Less8 (Const8 [math.MaxInt8 ]) _) |
| // result: (ConstBool [false]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != math.MaxInt8 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Less8 x (Const8 <t> [math.MinInt8 +1])) |
| // result: (Eq8 x (Const8 <t> [math.MinInt8 ])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt8(v_1.AuxInt) != math.MinInt8+1 { |
| break |
| } |
| v.Reset(ssaop.OpEq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(math.MinInt8) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Less8 (Const8 <t> [math.MaxInt8 -1]) x) |
| // result: (Eq8 x (Const8 <t> [math.MaxInt8 ])) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt8(v_0.AuxInt) != math.MaxInt8-1 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpEq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(math.MaxInt8) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLess8U(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Less8U (Const8 [c]) (Const8 [d])) |
| // result: (ConstBool [ uint8(c) < uint8(d)]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(uint8(c) < uint8(d)) |
| return true |
| } |
| // match: (Less8U (Const8 <t> [0]) x) |
| // result: (Neq8 (Const8 <t> [0]) x) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpNeq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Less8U x (Const8 <t> [1])) |
| // result: (Eq8 (Const8 <t> [0]) x) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt8(v_1.AuxInt) != 1 { |
| break |
| } |
| v.Reset(ssaop.OpEq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(0) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Less8U _ (Const8 [0])) |
| // result: (ConstBool [false]) |
| for { |
| if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Less8U (Const8 [-1]) _) |
| // result: (ConstBool [false]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != -1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Less8U x (Const8 <t> [1])) |
| // result: (Eq8 x (Const8 <t> [0])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt8(v_1.AuxInt) != 1 { |
| break |
| } |
| v.Reset(ssaop.OpEq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(0) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Less8U (Const8 <t> [-2]) x) |
| // result: (Eq8 x (Const8 <t> [-1])) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| t := v_0.Type |
| if ssa.AuxIntToInt8(v_0.AuxInt) != -2 { |
| break |
| } |
| x := v_1 |
| v.Reset(ssaop.OpEq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(-1) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| 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 <t1> p1 (Store {t2} p2 x _)) |
| // cond: ssa.IsSamePtr(p1, p2) && copyCompatibleType(t1, x.Type) && t1.Size() == t2.Size() |
| // result: x |
| for { |
| t1 := v.Type |
| p1 := v_0 |
| if v_1.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(v_1.Aux) |
| x := v_1.Args[1] |
| p2 := v_1.Args[0] |
| if !(ssa.IsSamePtr(p1, p2) && copyCompatibleType(t1, x.Type) && t1.Size() == t2.Size()) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 x _))) |
| // cond: ssa.IsSamePtr(p1, p3) && copyCompatibleType(t1, x.Type) && t1.Size() == t3.Size() && ssa.Disjoint(p3, t3, p2, t2) |
| // result: x |
| for { |
| t1 := v.Type |
| p1 := v_0 |
| if v_1.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(v_1.Aux) |
| _ = v_1.Args[2] |
| p2 := v_1.Args[0] |
| v_1_2 := v_1.Args[2] |
| if v_1_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(v_1_2.Aux) |
| x := v_1_2.Args[1] |
| p3 := v_1_2.Args[0] |
| if !(ssa.IsSamePtr(p1, p3) && copyCompatibleType(t1, x.Type) && t1.Size() == t3.Size() && ssa.Disjoint(p3, t3, p2, t2)) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 x _)))) |
| // cond: ssa.IsSamePtr(p1, p4) && copyCompatibleType(t1, x.Type) && t1.Size() == t4.Size() && ssa.Disjoint(p4, t4, p2, t2) && ssa.Disjoint(p4, t4, p3, t3) |
| // result: x |
| for { |
| t1 := v.Type |
| p1 := v_0 |
| if v_1.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(v_1.Aux) |
| _ = v_1.Args[2] |
| p2 := v_1.Args[0] |
| v_1_2 := v_1.Args[2] |
| if v_1_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(v_1_2.Aux) |
| _ = v_1_2.Args[2] |
| p3 := v_1_2.Args[0] |
| v_1_2_2 := v_1_2.Args[2] |
| if v_1_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(v_1_2_2.Aux) |
| x := v_1_2_2.Args[1] |
| p4 := v_1_2_2.Args[0] |
| if !(ssa.IsSamePtr(p1, p4) && copyCompatibleType(t1, x.Type) && t1.Size() == t4.Size() && ssa.Disjoint(p4, t4, p2, t2) && ssa.Disjoint(p4, t4, p3, t3)) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 x _))))) |
| // cond: ssa.IsSamePtr(p1, p5) && copyCompatibleType(t1, x.Type) && t1.Size() == t5.Size() && ssa.Disjoint(p5, t5, p2, t2) && ssa.Disjoint(p5, t5, p3, t3) && ssa.Disjoint(p5, t5, p4, t4) |
| // result: x |
| for { |
| t1 := v.Type |
| p1 := v_0 |
| if v_1.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(v_1.Aux) |
| _ = v_1.Args[2] |
| p2 := v_1.Args[0] |
| v_1_2 := v_1.Args[2] |
| if v_1_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(v_1_2.Aux) |
| _ = v_1_2.Args[2] |
| p3 := v_1_2.Args[0] |
| v_1_2_2 := v_1_2.Args[2] |
| if v_1_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(v_1_2_2.Aux) |
| _ = v_1_2_2.Args[2] |
| p4 := v_1_2_2.Args[0] |
| v_1_2_2_2 := v_1_2_2.Args[2] |
| if v_1_2_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t5 := ssa.AuxToType(v_1_2_2_2.Aux) |
| x := v_1_2_2_2.Args[1] |
| p5 := v_1_2_2_2.Args[0] |
| if !(ssa.IsSamePtr(p1, p5) && copyCompatibleType(t1, x.Type) && t1.Size() == t5.Size() && ssa.Disjoint(p5, t5, p2, t2) && ssa.Disjoint(p5, t5, p3, t3) && ssa.Disjoint(p5, t5, p4, t4)) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Load <t1> op1:(OffPtr [o1] p1) move:(Move [n] p2 src mem)) |
| // cond: o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p2) && !ssa.IsVolatile(src) |
| // result: @move.Block (Load <t1> (OffPtr <op1.Type> [o1] src) mem) |
| for { |
| t1 := v.Type |
| op1 := v_0 |
| if op1.Op != ssaop.OpOffPtr { |
| break |
| } |
| o1 := ssa.AuxIntToInt64(op1.AuxInt) |
| p1 := op1.Args[0] |
| move := v_1 |
| if move.Op != ssaop.OpMove { |
| break |
| } |
| n := ssa.AuxIntToInt64(move.AuxInt) |
| mem := move.Args[2] |
| p2 := move.Args[0] |
| src := move.Args[1] |
| if !(o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p2) && !ssa.IsVolatile(src)) { |
| break |
| } |
| b = move.Block |
| v0 := b.NewValue0(v.Pos, ssaop.OpLoad, t1) |
| v.CopyOf(v0) |
| v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, op1.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(o1) |
| v1.AddArg(src) |
| v0.AddArg2(v1, mem) |
| return true |
| } |
| // match: (Load <t1> p1 (Store {t2} p2 (Const64 [x]) _)) |
| // cond: ssa.IsSamePtr(p1,p2) && t2.Size() == 8 && ssa.Is64BitFloat(t1) && !math.IsNaN(math.Float64frombits(uint64(x))) |
| // result: (Const64F [math.Float64frombits(uint64(x))]) |
| for { |
| t1 := v.Type |
| p1 := v_0 |
| if v_1.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(v_1.Aux) |
| _ = v_1.Args[1] |
| p2 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| break |
| } |
| x := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(ssa.IsSamePtr(p1, p2) && t2.Size() == 8 && ssa.Is64BitFloat(t1) && !math.IsNaN(math.Float64frombits(uint64(x)))) { |
| break |
| } |
| v.Reset(ssaop.OpConst64F) |
| v.AuxInt = ssa.Float64ToAuxInt(math.Float64frombits(uint64(x))) |
| return true |
| } |
| // match: (Load <t1> p1 (Store {t2} p2 (Const32 [x]) _)) |
| // cond: ssa.IsSamePtr(p1,p2) && t2.Size() == 4 && ssa.Is32BitFloat(t1) && !math.IsNaN(float64(math.Float32frombits(uint32(x)))) |
| // result: (Const32F [math.Float32frombits(uint32(x))]) |
| for { |
| t1 := v.Type |
| p1 := v_0 |
| if v_1.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(v_1.Aux) |
| _ = v_1.Args[1] |
| p2 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| break |
| } |
| x := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(ssa.IsSamePtr(p1, p2) && t2.Size() == 4 && ssa.Is32BitFloat(t1) && !math.IsNaN(float64(math.Float32frombits(uint32(x))))) { |
| break |
| } |
| v.Reset(ssaop.OpConst32F) |
| v.AuxInt = ssa.Float32ToAuxInt(math.Float32frombits(uint32(x))) |
| return true |
| } |
| // match: (Load <t1> p1 (Store {t2} p2 (Const64F [x]) _)) |
| // cond: ssa.IsSamePtr(p1,p2) && t2.Size() == 8 && ssa.Is64BitInt(t1) |
| // result: (Const64 [int64(math.Float64bits(x))]) |
| for { |
| t1 := v.Type |
| p1 := v_0 |
| if v_1.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(v_1.Aux) |
| _ = v_1.Args[1] |
| p2 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64F { |
| break |
| } |
| x := ssa.AuxIntToFloat64(v_1_1.AuxInt) |
| if !(ssa.IsSamePtr(p1, p2) && t2.Size() == 8 && ssa.Is64BitInt(t1)) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(math.Float64bits(x))) |
| return true |
| } |
| // match: (Load <t1> p1 (Store {t2} p2 (Const32F [x]) _)) |
| // cond: ssa.IsSamePtr(p1,p2) && t2.Size() == 4 && ssa.Is32BitInt(t1) |
| // result: (Const32 [int32(math.Float32bits(x))]) |
| for { |
| t1 := v.Type |
| p1 := v_0 |
| if v_1.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(v_1.Aux) |
| _ = v_1.Args[1] |
| p2 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32F { |
| break |
| } |
| x := ssa.AuxIntToFloat32(v_1_1.AuxInt) |
| if !(ssa.IsSamePtr(p1, p2) && t2.Size() == 4 && ssa.Is32BitInt(t1)) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(math.Float32bits(x))) |
| return true |
| } |
| // match: (Load <t1> op1:(OffPtr [o1] p1) (Store {t2} p2 _ mem:(Zero [n] p3 _))) |
| // cond: o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p3) && ssa.CanSSA(t1) && ssa.Disjoint(op1, t1, p2, t2) |
| // result: @mem.Block (Load <t1> (OffPtr <op1.Type> [o1] p3) mem) |
| for { |
| t1 := v.Type |
| op1 := v_0 |
| if op1.Op != ssaop.OpOffPtr { |
| break |
| } |
| o1 := ssa.AuxIntToInt64(op1.AuxInt) |
| p1 := op1.Args[0] |
| if v_1.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(v_1.Aux) |
| _ = v_1.Args[2] |
| p2 := v_1.Args[0] |
| mem := v_1.Args[2] |
| if mem.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(mem.AuxInt) |
| p3 := mem.Args[0] |
| if !(o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p3) && ssa.CanSSA(t1) && ssa.Disjoint(op1, t1, p2, t2)) { |
| break |
| } |
| b = mem.Block |
| v0 := b.NewValue0(v.Pos, ssaop.OpLoad, t1) |
| v.CopyOf(v0) |
| v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, op1.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(o1) |
| v1.AddArg(p3) |
| v0.AddArg2(v1, mem) |
| return true |
| } |
| // match: (Load <t1> op1:(OffPtr [o1] p1) (Store {t2} p2 _ (Store {t3} p3 _ mem:(Zero [n] p4 _)))) |
| // cond: o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p4) && ssa.CanSSA(t1) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) |
| // result: @mem.Block (Load <t1> (OffPtr <op1.Type> [o1] p4) mem) |
| for { |
| t1 := v.Type |
| op1 := v_0 |
| if op1.Op != ssaop.OpOffPtr { |
| break |
| } |
| o1 := ssa.AuxIntToInt64(op1.AuxInt) |
| p1 := op1.Args[0] |
| if v_1.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(v_1.Aux) |
| _ = v_1.Args[2] |
| p2 := v_1.Args[0] |
| v_1_2 := v_1.Args[2] |
| if v_1_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(v_1_2.Aux) |
| _ = v_1_2.Args[2] |
| p3 := v_1_2.Args[0] |
| mem := v_1_2.Args[2] |
| if mem.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(mem.AuxInt) |
| p4 := mem.Args[0] |
| if !(o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p4) && ssa.CanSSA(t1) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3)) { |
| break |
| } |
| b = mem.Block |
| v0 := b.NewValue0(v.Pos, ssaop.OpLoad, t1) |
| v.CopyOf(v0) |
| v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, op1.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(o1) |
| v1.AddArg(p4) |
| v0.AddArg2(v1, mem) |
| return true |
| } |
| // match: (Load <t1> op1:(OffPtr [o1] p1) (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ mem:(Zero [n] p5 _))))) |
| // cond: o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p5) && ssa.CanSSA(t1) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) && ssa.Disjoint(op1, t1, p4, t4) |
| // result: @mem.Block (Load <t1> (OffPtr <op1.Type> [o1] p5) mem) |
| for { |
| t1 := v.Type |
| op1 := v_0 |
| if op1.Op != ssaop.OpOffPtr { |
| break |
| } |
| o1 := ssa.AuxIntToInt64(op1.AuxInt) |
| p1 := op1.Args[0] |
| if v_1.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(v_1.Aux) |
| _ = v_1.Args[2] |
| p2 := v_1.Args[0] |
| v_1_2 := v_1.Args[2] |
| if v_1_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(v_1_2.Aux) |
| _ = v_1_2.Args[2] |
| p3 := v_1_2.Args[0] |
| v_1_2_2 := v_1_2.Args[2] |
| if v_1_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(v_1_2_2.Aux) |
| _ = v_1_2_2.Args[2] |
| p4 := v_1_2_2.Args[0] |
| mem := v_1_2_2.Args[2] |
| if mem.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(mem.AuxInt) |
| p5 := mem.Args[0] |
| if !(o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p5) && ssa.CanSSA(t1) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) && ssa.Disjoint(op1, t1, p4, t4)) { |
| break |
| } |
| b = mem.Block |
| v0 := b.NewValue0(v.Pos, ssaop.OpLoad, t1) |
| v.CopyOf(v0) |
| v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, op1.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(o1) |
| v1.AddArg(p5) |
| v0.AddArg2(v1, mem) |
| return true |
| } |
| // match: (Load <t1> op1:(OffPtr [o1] p1) (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 _ mem:(Zero [n] p6 _)))))) |
| // cond: o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p6) && ssa.CanSSA(t1) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) && ssa.Disjoint(op1, t1, p4, t4) && ssa.Disjoint(op1, t1, p5, t5) |
| // result: @mem.Block (Load <t1> (OffPtr <op1.Type> [o1] p6) mem) |
| for { |
| t1 := v.Type |
| op1 := v_0 |
| if op1.Op != ssaop.OpOffPtr { |
| break |
| } |
| o1 := ssa.AuxIntToInt64(op1.AuxInt) |
| p1 := op1.Args[0] |
| if v_1.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(v_1.Aux) |
| _ = v_1.Args[2] |
| p2 := v_1.Args[0] |
| v_1_2 := v_1.Args[2] |
| if v_1_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(v_1_2.Aux) |
| _ = v_1_2.Args[2] |
| p3 := v_1_2.Args[0] |
| v_1_2_2 := v_1_2.Args[2] |
| if v_1_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(v_1_2_2.Aux) |
| _ = v_1_2_2.Args[2] |
| p4 := v_1_2_2.Args[0] |
| v_1_2_2_2 := v_1_2_2.Args[2] |
| if v_1_2_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t5 := ssa.AuxToType(v_1_2_2_2.Aux) |
| _ = v_1_2_2_2.Args[2] |
| p5 := v_1_2_2_2.Args[0] |
| mem := v_1_2_2_2.Args[2] |
| if mem.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(mem.AuxInt) |
| p6 := mem.Args[0] |
| if !(o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p6) && ssa.CanSSA(t1) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) && ssa.Disjoint(op1, t1, p4, t4) && ssa.Disjoint(op1, t1, p5, t5)) { |
| break |
| } |
| b = mem.Block |
| v0 := b.NewValue0(v.Pos, ssaop.OpLoad, t1) |
| v.CopyOf(v0) |
| v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, op1.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(o1) |
| v1.AddArg(p6) |
| v0.AddArg2(v1, mem) |
| return true |
| } |
| // match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _)) |
| // cond: t1.IsBoolean() && ssa.IsSamePtr(p1, p2) && n >= o + 1 |
| // result: (ConstBool [false]) |
| for { |
| t1 := v.Type |
| if v_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| o := ssa.AuxIntToInt64(v_0.AuxInt) |
| p1 := v_0.Args[0] |
| if v_1.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(v_1.AuxInt) |
| p2 := v_1.Args[0] |
| if !(t1.IsBoolean() && ssa.IsSamePtr(p1, p2) && n >= o+1) { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _)) |
| // cond: ssa.Is8BitInt(t1) && ssa.IsSamePtr(p1, p2) && n >= o + 1 |
| // result: (Const8 [0]) |
| for { |
| t1 := v.Type |
| if v_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| o := ssa.AuxIntToInt64(v_0.AuxInt) |
| p1 := v_0.Args[0] |
| if v_1.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(v_1.AuxInt) |
| p2 := v_1.Args[0] |
| if !(ssa.Is8BitInt(t1) && ssa.IsSamePtr(p1, p2) && n >= o+1) { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _)) |
| // cond: ssa.Is16BitInt(t1) && ssa.IsSamePtr(p1, p2) && n >= o + 2 |
| // result: (Const16 [0]) |
| for { |
| t1 := v.Type |
| if v_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| o := ssa.AuxIntToInt64(v_0.AuxInt) |
| p1 := v_0.Args[0] |
| if v_1.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(v_1.AuxInt) |
| p2 := v_1.Args[0] |
| if !(ssa.Is16BitInt(t1) && ssa.IsSamePtr(p1, p2) && n >= o+2) { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _)) |
| // cond: ssa.Is32BitInt(t1) && ssa.IsSamePtr(p1, p2) && n >= o + 4 |
| // result: (Const32 [0]) |
| for { |
| t1 := v.Type |
| if v_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| o := ssa.AuxIntToInt64(v_0.AuxInt) |
| p1 := v_0.Args[0] |
| if v_1.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(v_1.AuxInt) |
| p2 := v_1.Args[0] |
| if !(ssa.Is32BitInt(t1) && ssa.IsSamePtr(p1, p2) && n >= o+4) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _)) |
| // cond: ssa.Is64BitInt(t1) && ssa.IsSamePtr(p1, p2) && n >= o + 8 |
| // result: (Const64 [0]) |
| for { |
| t1 := v.Type |
| if v_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| o := ssa.AuxIntToInt64(v_0.AuxInt) |
| p1 := v_0.Args[0] |
| if v_1.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(v_1.AuxInt) |
| p2 := v_1.Args[0] |
| if !(ssa.Is64BitInt(t1) && ssa.IsSamePtr(p1, p2) && n >= o+8) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _)) |
| // cond: ssa.Is32BitFloat(t1) && ssa.IsSamePtr(p1, p2) && n >= o + 4 |
| // result: (Const32F [0]) |
| for { |
| t1 := v.Type |
| if v_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| o := ssa.AuxIntToInt64(v_0.AuxInt) |
| p1 := v_0.Args[0] |
| if v_1.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(v_1.AuxInt) |
| p2 := v_1.Args[0] |
| if !(ssa.Is32BitFloat(t1) && ssa.IsSamePtr(p1, p2) && n >= o+4) { |
| break |
| } |
| v.Reset(ssaop.OpConst32F) |
| v.AuxInt = ssa.Float32ToAuxInt(0) |
| return true |
| } |
| // match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _)) |
| // cond: ssa.Is64BitFloat(t1) && ssa.IsSamePtr(p1, p2) && n >= o + 8 |
| // result: (Const64F [0]) |
| for { |
| t1 := v.Type |
| if v_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| o := ssa.AuxIntToInt64(v_0.AuxInt) |
| p1 := v_0.Args[0] |
| if v_1.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(v_1.AuxInt) |
| p2 := v_1.Args[0] |
| if !(ssa.Is64BitFloat(t1) && ssa.IsSamePtr(p1, p2) && n >= o+8) { |
| break |
| } |
| v.Reset(ssaop.OpConst64F) |
| v.AuxInt = ssa.Float64ToAuxInt(0) |
| return true |
| } |
| // match: (Load <t> _ _) |
| // cond: t.IsStruct() && t.Size() > 0 && ssa.CanSSA(t) && !t.IsSIMD() |
| // result: rewriteStructLoad(v) |
| for { |
| t := v.Type |
| if !(t.IsStruct() && t.Size() > 0 && ssa.CanSSA(t) && !t.IsSIMD()) { |
| break |
| } |
| v.CopyOf(rewriteStructLoad(v)) |
| return true |
| } |
| // match: (Load <t> ptr mem) |
| // cond: t.IsArray() && t.NumElem() == 1 && t.Size() > 0 && ssa.CanSSA(t) |
| // result: (ArrayMake1 (Load <t.Elem()> ptr mem)) |
| for { |
| t := v.Type |
| ptr := v_0 |
| mem := v_1 |
| if !(t.IsArray() && t.NumElem() == 1 && t.Size() > 0 && ssa.CanSSA(t)) { |
| break |
| } |
| v.Reset(ssaop.OpArrayMake1) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLoad, t.Elem()) |
| v0.AddArg2(ptr, mem) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Load <t> _ _) |
| // cond: t.Size() == 0 |
| // result: (Empty) |
| for { |
| t := v.Type |
| if !(t.Size() == 0) { |
| break |
| } |
| v.Reset(ssaop.OpEmpty) |
| return true |
| } |
| // match: (Load <typ.Int8> sptr:(Addr {scon} (SB)) mem) |
| // cond: ssa.SymIsRO(scon) |
| // result: (Const8 <typ.Int8> [int8(ssa.Read8(scon,0))]) |
| for { |
| if v.Type != typ.Int8 { |
| break |
| } |
| sptr := v_0 |
| if sptr.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(sptr.Aux) |
| sptr_0 := sptr.Args[0] |
| if sptr_0.Op != ssaop.OpSB { |
| break |
| } |
| if !(ssa.SymIsRO(scon)) { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.Type = typ.Int8 |
| v.AuxInt = ssa.Int8ToAuxInt(int8(ssa.Read8(scon, 0))) |
| return true |
| } |
| // match: (Load <typ.Int16> sptr:(Addr {scon} (SB)) mem) |
| // cond: ssa.SymIsRO(scon) |
| // result: (Const16 <typ.Int16> [int16(ssa.Read16(scon,0,config.Ctxt.Arch.ByteOrder))]) |
| for { |
| if v.Type != typ.Int16 { |
| break |
| } |
| sptr := v_0 |
| if sptr.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(sptr.Aux) |
| sptr_0 := sptr.Args[0] |
| if sptr_0.Op != ssaop.OpSB { |
| break |
| } |
| if !(ssa.SymIsRO(scon)) { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.Type = typ.Int16 |
| v.AuxInt = ssa.Int16ToAuxInt(int16(ssa.Read16(scon, 0, config.Ctxt.Arch.ByteOrder))) |
| return true |
| } |
| // match: (Load <typ.Int32> sptr:(Addr {scon} (SB)) mem) |
| // cond: ssa.SymIsRO(scon) |
| // result: (Const32 <typ.Int32> [int32(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))]) |
| for { |
| if v.Type != typ.Int32 { |
| break |
| } |
| sptr := v_0 |
| if sptr.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(sptr.Aux) |
| sptr_0 := sptr.Args[0] |
| if sptr_0.Op != ssaop.OpSB { |
| break |
| } |
| if !(ssa.SymIsRO(scon)) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.Type = typ.Int32 |
| v.AuxInt = ssa.Int32ToAuxInt(int32(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder))) |
| return true |
| } |
| // match: (Load <typ.Int64> sptr:(Addr {scon} (SB)) mem) |
| // cond: ssa.SymIsRO(scon) |
| // result: (Const64 <typ.Int64> [int64(ssa.Read64(scon,0,config.Ctxt.Arch.ByteOrder))]) |
| for { |
| if v.Type != typ.Int64 { |
| break |
| } |
| sptr := v_0 |
| if sptr.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(sptr.Aux) |
| sptr_0 := sptr.Args[0] |
| if sptr_0.Op != ssaop.OpSB { |
| break |
| } |
| if !(ssa.SymIsRO(scon)) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.Type = typ.Int64 |
| v.AuxInt = ssa.Int64ToAuxInt(int64(ssa.Read64(scon, 0, config.Ctxt.Arch.ByteOrder))) |
| return true |
| } |
| // match: (Load (Addr {s} sb) _) |
| // cond: isFixedLoad(v, s, 0) |
| // result: rewriteFixedLoad(v, s, sb, 0) |
| for { |
| if v_0.Op != ssaop.OpAddr { |
| break |
| } |
| s := ssa.AuxToSym(v_0.Aux) |
| sb := v_0.Args[0] |
| if !(isFixedLoad(v, s, 0)) { |
| break |
| } |
| v.CopyOf(rewriteFixedLoad(v, s, sb, 0)) |
| return true |
| } |
| // match: (Load (Convert (Addr {s} sb) _) _) |
| // cond: isFixedLoad(v, s, 0) |
| // result: rewriteFixedLoad(v, s, sb, 0) |
| for { |
| if v_0.Op != ssaop.OpConvert { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpAddr { |
| break |
| } |
| s := ssa.AuxToSym(v_0_0.Aux) |
| sb := v_0_0.Args[0] |
| if !(isFixedLoad(v, s, 0)) { |
| break |
| } |
| v.CopyOf(rewriteFixedLoad(v, s, sb, 0)) |
| return true |
| } |
| // match: (Load (ITab (IMake (Addr {s} sb) _)) _) |
| // cond: isFixedLoad(v, s, 0) |
| // result: rewriteFixedLoad(v, s, sb, 0) |
| for { |
| if v_0.Op != ssaop.OpITab { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpIMake { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != ssaop.OpAddr { |
| break |
| } |
| s := ssa.AuxToSym(v_0_0_0.Aux) |
| sb := v_0_0_0.Args[0] |
| if !(isFixedLoad(v, s, 0)) { |
| break |
| } |
| v.CopyOf(rewriteFixedLoad(v, s, sb, 0)) |
| return true |
| } |
| // match: (Load (ITab (IMake (Convert (Addr {s} sb) _) _)) _) |
| // cond: isFixedLoad(v, s, 0) |
| // result: rewriteFixedLoad(v, s, sb, 0) |
| for { |
| if v_0.Op != ssaop.OpITab { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpIMake { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != ssaop.OpConvert { |
| break |
| } |
| v_0_0_0_0 := v_0_0_0.Args[0] |
| if v_0_0_0_0.Op != ssaop.OpAddr { |
| break |
| } |
| s := ssa.AuxToSym(v_0_0_0_0.Aux) |
| sb := v_0_0_0_0.Args[0] |
| if !(isFixedLoad(v, s, 0)) { |
| break |
| } |
| v.CopyOf(rewriteFixedLoad(v, s, sb, 0)) |
| return true |
| } |
| // match: (Load (OffPtr [off] (Addr {s} sb) ) _) |
| // cond: isFixedLoad(v, s, off) |
| // result: rewriteFixedLoad(v, s, sb, off) |
| for { |
| if v_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| off := ssa.AuxIntToInt64(v_0.AuxInt) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpAddr { |
| break |
| } |
| s := ssa.AuxToSym(v_0_0.Aux) |
| sb := v_0_0.Args[0] |
| if !(isFixedLoad(v, s, off)) { |
| break |
| } |
| v.CopyOf(rewriteFixedLoad(v, s, sb, off)) |
| return true |
| } |
| // match: (Load (OffPtr [off] (Convert (Addr {s} sb) _) ) _) |
| // cond: isFixedLoad(v, s, off) |
| // result: rewriteFixedLoad(v, s, sb, off) |
| for { |
| if v_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| off := ssa.AuxIntToInt64(v_0.AuxInt) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConvert { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != ssaop.OpAddr { |
| break |
| } |
| s := ssa.AuxToSym(v_0_0_0.Aux) |
| sb := v_0_0_0.Args[0] |
| if !(isFixedLoad(v, s, off)) { |
| break |
| } |
| v.CopyOf(rewriteFixedLoad(v, s, sb, off)) |
| return true |
| } |
| // match: (Load (OffPtr [off] (ITab (IMake (Addr {s} sb) _))) _) |
| // cond: isFixedLoad(v, s, off) |
| // result: rewriteFixedLoad(v, s, sb, off) |
| for { |
| if v_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| off := ssa.AuxIntToInt64(v_0.AuxInt) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpITab { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != ssaop.OpIMake { |
| break |
| } |
| v_0_0_0_0 := v_0_0_0.Args[0] |
| if v_0_0_0_0.Op != ssaop.OpAddr { |
| break |
| } |
| s := ssa.AuxToSym(v_0_0_0_0.Aux) |
| sb := v_0_0_0_0.Args[0] |
| if !(isFixedLoad(v, s, off)) { |
| break |
| } |
| v.CopyOf(rewriteFixedLoad(v, s, sb, off)) |
| return true |
| } |
| // match: (Load (OffPtr [off] (ITab (IMake (Convert (Addr {s} sb) _) _))) _) |
| // cond: isFixedLoad(v, s, off) |
| // result: rewriteFixedLoad(v, s, sb, off) |
| for { |
| if v_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| off := ssa.AuxIntToInt64(v_0.AuxInt) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpITab { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != ssaop.OpIMake { |
| break |
| } |
| v_0_0_0_0 := v_0_0_0.Args[0] |
| if v_0_0_0_0.Op != ssaop.OpConvert { |
| break |
| } |
| v_0_0_0_0_0 := v_0_0_0_0.Args[0] |
| if v_0_0_0_0_0.Op != ssaop.OpAddr { |
| break |
| } |
| s := ssa.AuxToSym(v_0_0_0_0_0.Aux) |
| sb := v_0_0_0_0_0.Args[0] |
| if !(isFixedLoad(v, s, off)) { |
| break |
| } |
| v.CopyOf(rewriteFixedLoad(v, s, sb, off)) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLsh16x16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Lsh16x16 x (Const16 [c])) |
| // result: (Lsh16x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpLsh16x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh16x16 (Const16 [0]) _) |
| // result: (Const16 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh16x16 [false] x con:(Const16 [c])) |
| // cond: 0 < c && c < 16 |
| // result: (Lsh16x16 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(con.AuxInt) |
| if !(0 < c && c < 16) { |
| break |
| } |
| v.Reset(ssaop.OpLsh16x16) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLsh16x32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Lsh16x32 x (Const32 [c])) |
| // result: (Lsh16x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpLsh16x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh16x32 (Const16 [0]) _) |
| // result: (Const16 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh16x32 [false] x con:(Const32 [c])) |
| // cond: 0 < c && c < 16 |
| // result: (Lsh16x32 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(con.AuxInt) |
| if !(0 < c && c < 16) { |
| break |
| } |
| v.Reset(ssaop.OpLsh16x32) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| 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 (Const16 [c]) (Const64 [d])) |
| // result: (Const16 [c << uint64(d)]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(c << uint64(d)) |
| return true |
| } |
| // match: (Lsh16x64 x (Const64 [0])) |
| // result: x |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Lsh16x64 (Const16 [0]) _) |
| // result: (Const16 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh16x64 _ (Const64 [c])) |
| // cond: uint64(c) >= 16 |
| // result: (Const16 [0]) |
| for { |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(uint64(c) >= 16) { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh16x64 <t> (Lsh16x64 x (Const64 [c])) (Const64 [d])) |
| // cond: !uaddOvf(c,d) |
| // result: (Lsh16x64 x (Const64 <t> [c+d])) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpLsh16x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(!uaddOvf(c, d)) { |
| break |
| } |
| v.Reset(ssaop.OpLsh16x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c + d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh16x64 i:(Rsh16x64 x (Const64 [c])) (Const64 [c])) |
| // cond: c >= 0 && c < 16 && i.Uses == 1 |
| // result: (And16 x (Const16 <v.Type> [int16(-1) << c])) |
| for { |
| i := v_0 |
| if i.Op != ssaop.OpRsh16x64 { |
| break |
| } |
| _ = i.Args[1] |
| x := i.Args[0] |
| i_1 := i.Args[1] |
| if i_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(i_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 16 && i.Uses == 1) { |
| break |
| } |
| v.Reset(ssaop.OpAnd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, v.Type) |
| v0.AuxInt = ssa.Int16ToAuxInt(int16(-1) << c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh16x64 i:(Rsh16Ux64 x (Const64 [c])) (Const64 [c])) |
| // cond: c >= 0 && c < 16 && i.Uses == 1 |
| // result: (And16 x (Const16 <v.Type> [int16(-1) << c])) |
| for { |
| i := v_0 |
| if i.Op != ssaop.OpRsh16Ux64 { |
| break |
| } |
| _ = i.Args[1] |
| x := i.Args[0] |
| i_1 := i.Args[1] |
| if i_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(i_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 16 && i.Uses == 1) { |
| break |
| } |
| v.Reset(ssaop.OpAnd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, v.Type) |
| v0.AuxInt = ssa.Int16ToAuxInt(int16(-1) << c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh16x64 (Rsh16Ux64 (Lsh16x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) |
| // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) |
| // result: (Lsh16x64 x (Const64 <typ.UInt64> [c1-c2+c3])) |
| for { |
| if v_0.Op != ssaop.OpRsh16Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpLsh16x64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c1 := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c2 := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c3 := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { |
| break |
| } |
| v.Reset(ssaop.OpLsh16x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(c1 - c2 + c3) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh16x64 (And16 (Rsh16x64 <t> x (Const64 <t2> [c])) (Const16 [d])) (Const64 [e])) |
| // cond: c >= e |
| // result: (And16 (Rsh16x64 <t> x (Const64 <t2> [c-e])) (Const16 <t> [d<<e])) |
| for { |
| if v_0.Op != ssaop.OpAnd16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpRsh16x64 { |
| continue |
| } |
| t := v_0_0.Type |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t2 := v_0_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_0_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| e := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c >= e) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh16x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2) |
| v1.AuxInt = ssa.Int64ToAuxInt(c - e) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v2.AuxInt = ssa.Int16ToAuxInt(d << e) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (Lsh16x64 (And16 (Rsh16Ux64 <t> x (Const64 <t2> [c])) (Const16 [d])) (Const64 [e])) |
| // cond: c >= e |
| // result: (And16 (Rsh16Ux64 <t> x (Const64 <t2> [c-e])) (Const16 <t> [d<<e])) |
| for { |
| if v_0.Op != ssaop.OpAnd16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpRsh16Ux64 { |
| continue |
| } |
| t := v_0_0.Type |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t2 := v_0_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_0_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| e := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c >= e) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh16Ux64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2) |
| v1.AuxInt = ssa.Int64ToAuxInt(c - e) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v2.AuxInt = ssa.Int16ToAuxInt(d << e) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (Lsh16x64 (And16 (Rsh16x64 <t> x (Const64 <t2> [c])) (Const16 [d])) (Const64 [e])) |
| // cond: c < e |
| // result: (And16 (Lsh16x64 <t> x (Const64 <t2> [e-c])) (Const16 <t> [d<<e])) |
| for { |
| if v_0.Op != ssaop.OpAnd16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpRsh16x64 { |
| continue |
| } |
| t := v_0_0.Type |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t2 := v_0_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_0_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| e := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c < e) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLsh16x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2) |
| v1.AuxInt = ssa.Int64ToAuxInt(e - c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v2.AuxInt = ssa.Int16ToAuxInt(d << e) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (Lsh16x64 (And16 (Rsh16Ux64 <t> x (Const64 <t2> [c])) (Const16 [d])) (Const64 [e])) |
| // cond: c < e |
| // result: (And16 (Lsh16x64 <t> x (Const64 <t2> [e-c])) (Const16 <t> [d<<e])) |
| for { |
| if v_0.Op != ssaop.OpAnd16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpRsh16Ux64 { |
| continue |
| } |
| t := v_0_0.Type |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t2 := v_0_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_0_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| e := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c < e) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLsh16x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2) |
| v1.AuxInt = ssa.Int64ToAuxInt(e - c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v2.AuxInt = ssa.Int16ToAuxInt(d << e) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (Lsh16x64 [false] x con:(Const64 [c])) |
| // cond: 0 < c && c < 16 |
| // result: (Lsh16x64 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(con.AuxInt) |
| if !(0 < c && c < 16) { |
| break |
| } |
| v.Reset(ssaop.OpLsh16x64) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLsh16x8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Lsh16x8 x (Const8 [c])) |
| // result: (Lsh16x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpLsh16x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh16x8 (Const16 [0]) _) |
| // result: (Const16 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh16x8 [false] x con:(Const8 [c])) |
| // cond: 0 < c && c < 16 |
| // result: (Lsh16x8 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(con.AuxInt) |
| if !(0 < c && c < 16) { |
| break |
| } |
| v.Reset(ssaop.OpLsh16x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLsh32x16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Lsh32x16 x (Const16 [c])) |
| // result: (Lsh32x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpLsh32x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh32x16 (Const32 [0]) _) |
| // result: (Const32 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh32x16 [false] x con:(Const16 [c])) |
| // cond: 0 < c && c < 32 |
| // result: (Lsh32x16 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(con.AuxInt) |
| if !(0 < c && c < 32) { |
| break |
| } |
| v.Reset(ssaop.OpLsh32x16) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLsh32x32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Lsh32x32 x (Const32 [c])) |
| // result: (Lsh32x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpLsh32x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh32x32 (Const32 [0]) _) |
| // result: (Const32 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh32x32 [false] x con:(Const32 [c])) |
| // cond: 0 < c && c < 32 |
| // result: (Lsh32x32 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(con.AuxInt) |
| if !(0 < c && c < 32) { |
| break |
| } |
| v.Reset(ssaop.OpLsh32x32) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| 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 (Const32 [c]) (Const64 [d])) |
| // result: (Const32 [c << uint64(d)]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(c << uint64(d)) |
| return true |
| } |
| // match: (Lsh32x64 x (Const64 [0])) |
| // result: x |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Lsh32x64 (Const32 [0]) _) |
| // result: (Const32 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh32x64 _ (Const64 [c])) |
| // cond: uint64(c) >= 32 |
| // result: (Const32 [0]) |
| for { |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(uint64(c) >= 32) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh32x64 <t> (Lsh32x64 x (Const64 [c])) (Const64 [d])) |
| // cond: !uaddOvf(c,d) |
| // result: (Lsh32x64 x (Const64 <t> [c+d])) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpLsh32x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(!uaddOvf(c, d)) { |
| break |
| } |
| v.Reset(ssaop.OpLsh32x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c + d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh32x64 i:(Rsh32x64 x (Const64 [c])) (Const64 [c])) |
| // cond: c >= 0 && c < 32 && i.Uses == 1 |
| // result: (And32 x (Const32 <v.Type> [int32(-1) << c])) |
| for { |
| i := v_0 |
| if i.Op != ssaop.OpRsh32x64 { |
| break |
| } |
| _ = i.Args[1] |
| x := i.Args[0] |
| i_1 := i.Args[1] |
| if i_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(i_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 32 && i.Uses == 1) { |
| break |
| } |
| v.Reset(ssaop.OpAnd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, v.Type) |
| v0.AuxInt = ssa.Int32ToAuxInt(int32(-1) << c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh32x64 i:(Rsh32Ux64 x (Const64 [c])) (Const64 [c])) |
| // cond: c >= 0 && c < 32 && i.Uses == 1 |
| // result: (And32 x (Const32 <v.Type> [int32(-1) << c])) |
| for { |
| i := v_0 |
| if i.Op != ssaop.OpRsh32Ux64 { |
| break |
| } |
| _ = i.Args[1] |
| x := i.Args[0] |
| i_1 := i.Args[1] |
| if i_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(i_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 32 && i.Uses == 1) { |
| break |
| } |
| v.Reset(ssaop.OpAnd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, v.Type) |
| v0.AuxInt = ssa.Int32ToAuxInt(int32(-1) << c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh32x64 (Rsh32Ux64 (Lsh32x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) |
| // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) |
| // result: (Lsh32x64 x (Const64 <typ.UInt64> [c1-c2+c3])) |
| for { |
| if v_0.Op != ssaop.OpRsh32Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpLsh32x64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c1 := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c2 := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c3 := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { |
| break |
| } |
| v.Reset(ssaop.OpLsh32x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(c1 - c2 + c3) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh32x64 (And32 (Rsh32x64 <t> x (Const64 <t2> [c])) (Const32 [d])) (Const64 [e])) |
| // cond: c >= e |
| // result: (And32 (Rsh32x64 <t> x (Const64 <t2> [c-e])) (Const32 <t> [d<<e])) |
| for { |
| if v_0.Op != ssaop.OpAnd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpRsh32x64 { |
| continue |
| } |
| t := v_0_0.Type |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t2 := v_0_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_0_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| e := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c >= e) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh32x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2) |
| v1.AuxInt = ssa.Int64ToAuxInt(c - e) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v2.AuxInt = ssa.Int32ToAuxInt(d << e) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (Lsh32x64 (And32 (Rsh32Ux64 <t> x (Const64 <t2> [c])) (Const32 [d])) (Const64 [e])) |
| // cond: c >= e |
| // result: (And32 (Rsh32Ux64 <t> x (Const64 <t2> [c-e])) (Const32 <t> [d<<e])) |
| for { |
| if v_0.Op != ssaop.OpAnd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpRsh32Ux64 { |
| continue |
| } |
| t := v_0_0.Type |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t2 := v_0_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_0_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| e := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c >= e) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2) |
| v1.AuxInt = ssa.Int64ToAuxInt(c - e) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v2.AuxInt = ssa.Int32ToAuxInt(d << e) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (Lsh32x64 (And32 (Rsh32x64 <t> x (Const64 <t2> [c])) (Const32 [d])) (Const64 [e])) |
| // cond: c < e |
| // result: (And32 (Lsh32x64 <t> x (Const64 <t2> [e-c])) (Const32 <t> [d<<e])) |
| for { |
| if v_0.Op != ssaop.OpAnd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpRsh32x64 { |
| continue |
| } |
| t := v_0_0.Type |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t2 := v_0_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_0_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| e := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c < e) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLsh32x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2) |
| v1.AuxInt = ssa.Int64ToAuxInt(e - c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v2.AuxInt = ssa.Int32ToAuxInt(d << e) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (Lsh32x64 (And32 (Rsh32Ux64 <t> x (Const64 <t2> [c])) (Const32 [d])) (Const64 [e])) |
| // cond: c < e |
| // result: (And32 (Lsh32x64 <t> x (Const64 <t2> [e-c])) (Const32 <t> [d<<e])) |
| for { |
| if v_0.Op != ssaop.OpAnd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpRsh32Ux64 { |
| continue |
| } |
| t := v_0_0.Type |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t2 := v_0_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_0_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| e := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c < e) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLsh32x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2) |
| v1.AuxInt = ssa.Int64ToAuxInt(e - c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v2.AuxInt = ssa.Int32ToAuxInt(d << e) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (Lsh32x64 [false] x con:(Const64 [c])) |
| // cond: 0 < c && c < 32 |
| // result: (Lsh32x64 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(con.AuxInt) |
| if !(0 < c && c < 32) { |
| break |
| } |
| v.Reset(ssaop.OpLsh32x64) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLsh32x8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Lsh32x8 x (Const8 [c])) |
| // result: (Lsh32x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpLsh32x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh32x8 (Const32 [0]) _) |
| // result: (Const32 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh32x8 [false] x con:(Const8 [c])) |
| // cond: 0 < c && c < 32 |
| // result: (Lsh32x8 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(con.AuxInt) |
| if !(0 < c && c < 32) { |
| break |
| } |
| v.Reset(ssaop.OpLsh32x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLsh64x16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Lsh64x16 x (Const16 [c])) |
| // result: (Lsh64x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpLsh64x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh64x16 (Const64 [0]) _) |
| // result: (Const64 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh64x16 [false] x con:(Const16 [c])) |
| // cond: 0 < c && c < 64 |
| // result: (Lsh64x16 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(con.AuxInt) |
| if !(0 < c && c < 64) { |
| break |
| } |
| v.Reset(ssaop.OpLsh64x16) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLsh64x32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Lsh64x32 x (Const32 [c])) |
| // result: (Lsh64x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpLsh64x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh64x32 (Const64 [0]) _) |
| // result: (Const64 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh64x32 [false] x con:(Const32 [c])) |
| // cond: 0 < c && c < 64 |
| // result: (Lsh64x32 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(con.AuxInt) |
| if !(0 < c && c < 64) { |
| break |
| } |
| v.Reset(ssaop.OpLsh64x32) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| 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 (Const64 [c]) (Const64 [d])) |
| // result: (Const64 [c << uint64(d)]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(c << uint64(d)) |
| return true |
| } |
| // match: (Lsh64x64 x (Const64 [0])) |
| // result: x |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Lsh64x64 (Const64 [0]) _) |
| // result: (Const64 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh64x64 _ (Const64 [c])) |
| // cond: uint64(c) >= 64 |
| // result: (Const64 [0]) |
| for { |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(uint64(c) >= 64) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh64x64 <t> (Lsh64x64 x (Const64 [c])) (Const64 [d])) |
| // cond: !uaddOvf(c,d) |
| // result: (Lsh64x64 x (Const64 <t> [c+d])) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpLsh64x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(!uaddOvf(c, d)) { |
| break |
| } |
| v.Reset(ssaop.OpLsh64x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c + d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh64x64 i:(Rsh64x64 x (Const64 [c])) (Const64 [c])) |
| // cond: c >= 0 && c < 64 && i.Uses == 1 |
| // result: (And64 x (Const64 <v.Type> [int64(-1) << c])) |
| for { |
| i := v_0 |
| if i.Op != ssaop.OpRsh64x64 { |
| break |
| } |
| _ = i.Args[1] |
| x := i.Args[0] |
| i_1 := i.Args[1] |
| if i_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(i_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 64 && i.Uses == 1) { |
| break |
| } |
| v.Reset(ssaop.OpAnd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, v.Type) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(-1) << c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh64x64 i:(Rsh64Ux64 x (Const64 [c])) (Const64 [c])) |
| // cond: c >= 0 && c < 64 && i.Uses == 1 |
| // result: (And64 x (Const64 <v.Type> [int64(-1) << c])) |
| for { |
| i := v_0 |
| if i.Op != ssaop.OpRsh64Ux64 { |
| break |
| } |
| _ = i.Args[1] |
| x := i.Args[0] |
| i_1 := i.Args[1] |
| if i_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(i_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 64 && i.Uses == 1) { |
| break |
| } |
| v.Reset(ssaop.OpAnd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, v.Type) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(-1) << c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh64x64 (Rsh64Ux64 (Lsh64x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) |
| // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) |
| // result: (Lsh64x64 x (Const64 <typ.UInt64> [c1-c2+c3])) |
| for { |
| if v_0.Op != ssaop.OpRsh64Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpLsh64x64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c1 := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c2 := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c3 := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { |
| break |
| } |
| v.Reset(ssaop.OpLsh64x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(c1 - c2 + c3) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh64x64 (And64 (Rsh64x64 <t> x (Const64 <t2> [c])) (Const64 [d])) (Const64 [e])) |
| // cond: c >= e |
| // result: (And64 (Rsh64x64 <t> x (Const64 <t2> [c-e])) (Const64 <t> [d<<e])) |
| for { |
| if v_0.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpRsh64x64 { |
| continue |
| } |
| t := v_0_0.Type |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t2 := v_0_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| e := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c >= e) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh64x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2) |
| v1.AuxInt = ssa.Int64ToAuxInt(c - e) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v2.AuxInt = ssa.Int64ToAuxInt(d << e) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (Lsh64x64 (And64 (Rsh64Ux64 <t> x (Const64 <t2> [c])) (Const64 [d])) (Const64 [e])) |
| // cond: c >= e |
| // result: (And64 (Rsh64Ux64 <t> x (Const64 <t2> [c-e])) (Const64 <t> [d<<e])) |
| for { |
| if v_0.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpRsh64Ux64 { |
| continue |
| } |
| t := v_0_0.Type |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t2 := v_0_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| e := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c >= e) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh64Ux64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2) |
| v1.AuxInt = ssa.Int64ToAuxInt(c - e) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v2.AuxInt = ssa.Int64ToAuxInt(d << e) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (Lsh64x64 (And64 (Rsh64x64 <t> x (Const64 <t2> [c])) (Const64 [d])) (Const64 [e])) |
| // cond: c < e |
| // result: (And64 (Lsh64x64 <t> x (Const64 <t2> [e-c])) (Const64 <t> [d<<e])) |
| for { |
| if v_0.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpRsh64x64 { |
| continue |
| } |
| t := v_0_0.Type |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t2 := v_0_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| e := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c < e) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2) |
| v1.AuxInt = ssa.Int64ToAuxInt(e - c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v2.AuxInt = ssa.Int64ToAuxInt(d << e) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (Lsh64x64 (And64 (Rsh64Ux64 <t> x (Const64 <t2> [c])) (Const64 [d])) (Const64 [e])) |
| // cond: c < e |
| // result: (And64 (Lsh64x64 <t> x (Const64 <t2> [e-c])) (Const64 <t> [d<<e])) |
| for { |
| if v_0.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpRsh64Ux64 { |
| continue |
| } |
| t := v_0_0.Type |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t2 := v_0_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| e := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c < e) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2) |
| v1.AuxInt = ssa.Int64ToAuxInt(e - c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v2.AuxInt = ssa.Int64ToAuxInt(d << e) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (Lsh64x64 [false] x con:(Const64 [c])) |
| // cond: 0 < c && c < 64 |
| // result: (Lsh64x64 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(con.AuxInt) |
| if !(0 < c && c < 64) { |
| break |
| } |
| v.Reset(ssaop.OpLsh64x64) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLsh64x8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Lsh64x8 x (Const8 [c])) |
| // result: (Lsh64x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpLsh64x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh64x8 (Const64 [0]) _) |
| // result: (Const64 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh64x8 [false] x con:(Const8 [c])) |
| // cond: 0 < c && c < 64 |
| // result: (Lsh64x8 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(con.AuxInt) |
| if !(0 < c && c < 64) { |
| break |
| } |
| v.Reset(ssaop.OpLsh64x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLsh8x16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Lsh8x16 x (Const16 [c])) |
| // result: (Lsh8x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpLsh8x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh8x16 (Const8 [0]) _) |
| // result: (Const8 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh8x16 [false] x con:(Const16 [c])) |
| // cond: 0 < c && c < 8 |
| // result: (Lsh8x16 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(con.AuxInt) |
| if !(0 < c && c < 8) { |
| break |
| } |
| v.Reset(ssaop.OpLsh8x16) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLsh8x32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Lsh8x32 x (Const32 [c])) |
| // result: (Lsh8x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpLsh8x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh8x32 (Const8 [0]) _) |
| // result: (Const8 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh8x32 [false] x con:(Const32 [c])) |
| // cond: 0 < c && c < 8 |
| // result: (Lsh8x32 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(con.AuxInt) |
| if !(0 < c && c < 8) { |
| break |
| } |
| v.Reset(ssaop.OpLsh8x32) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| 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 (Const8 [c]) (Const64 [d])) |
| // result: (Const8 [c << uint64(d)]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(c << uint64(d)) |
| return true |
| } |
| // match: (Lsh8x64 x (Const64 [0])) |
| // result: x |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Lsh8x64 (Const8 [0]) _) |
| // result: (Const8 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh8x64 _ (Const64 [c])) |
| // cond: uint64(c) >= 8 |
| // result: (Const8 [0]) |
| for { |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(uint64(c) >= 8) { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh8x64 <t> (Lsh8x64 x (Const64 [c])) (Const64 [d])) |
| // cond: !uaddOvf(c,d) |
| // result: (Lsh8x64 x (Const64 <t> [c+d])) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpLsh8x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(!uaddOvf(c, d)) { |
| break |
| } |
| v.Reset(ssaop.OpLsh8x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c + d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh8x64 i:(Rsh8x64 x (Const64 [c])) (Const64 [c])) |
| // cond: c >= 0 && c < 8 && i.Uses == 1 |
| // result: (And8 x (Const8 <v.Type> [int8(-1) << c])) |
| for { |
| i := v_0 |
| if i.Op != ssaop.OpRsh8x64 { |
| break |
| } |
| _ = i.Args[1] |
| x := i.Args[0] |
| i_1 := i.Args[1] |
| if i_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(i_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 8 && i.Uses == 1) { |
| break |
| } |
| v.Reset(ssaop.OpAnd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, v.Type) |
| v0.AuxInt = ssa.Int8ToAuxInt(int8(-1) << c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh8x64 i:(Rsh8Ux64 x (Const64 [c])) (Const64 [c])) |
| // cond: c >= 0 && c < 8 && i.Uses == 1 |
| // result: (And8 x (Const8 <v.Type> [int8(-1) << c])) |
| for { |
| i := v_0 |
| if i.Op != ssaop.OpRsh8Ux64 { |
| break |
| } |
| _ = i.Args[1] |
| x := i.Args[0] |
| i_1 := i.Args[1] |
| if i_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(i_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 8 && i.Uses == 1) { |
| break |
| } |
| v.Reset(ssaop.OpAnd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, v.Type) |
| v0.AuxInt = ssa.Int8ToAuxInt(int8(-1) << c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh8x64 (Rsh8Ux64 (Lsh8x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) |
| // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) |
| // result: (Lsh8x64 x (Const64 <typ.UInt64> [c1-c2+c3])) |
| for { |
| if v_0.Op != ssaop.OpRsh8Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpLsh8x64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c1 := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c2 := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c3 := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { |
| break |
| } |
| v.Reset(ssaop.OpLsh8x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(c1 - c2 + c3) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh8x64 (And8 (Rsh8x64 <t> x (Const64 <t2> [c])) (Const8 [d])) (Const64 [e])) |
| // cond: c >= e |
| // result: (And8 (Rsh8x64 <t> x (Const64 <t2> [c-e])) (Const8 <t> [d<<e])) |
| for { |
| if v_0.Op != ssaop.OpAnd8 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpRsh8x64 { |
| continue |
| } |
| t := v_0_0.Type |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t2 := v_0_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_0_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| e := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c >= e) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh8x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2) |
| v1.AuxInt = ssa.Int64ToAuxInt(c - e) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v2.AuxInt = ssa.Int8ToAuxInt(d << e) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (Lsh8x64 (And8 (Rsh8Ux64 <t> x (Const64 <t2> [c])) (Const8 [d])) (Const64 [e])) |
| // cond: c >= e |
| // result: (And8 (Rsh8Ux64 <t> x (Const64 <t2> [c-e])) (Const8 <t> [d<<e])) |
| for { |
| if v_0.Op != ssaop.OpAnd8 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpRsh8Ux64 { |
| continue |
| } |
| t := v_0_0.Type |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t2 := v_0_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_0_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| e := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c >= e) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh8Ux64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2) |
| v1.AuxInt = ssa.Int64ToAuxInt(c - e) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v2.AuxInt = ssa.Int8ToAuxInt(d << e) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (Lsh8x64 (And8 (Rsh8x64 <t> x (Const64 <t2> [c])) (Const8 [d])) (Const64 [e])) |
| // cond: c < e |
| // result: (And8 (Lsh8x64 <t> x (Const64 <t2> [e-c])) (Const8 <t> [d<<e])) |
| for { |
| if v_0.Op != ssaop.OpAnd8 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpRsh8x64 { |
| continue |
| } |
| t := v_0_0.Type |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t2 := v_0_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_0_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| e := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c < e) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLsh8x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2) |
| v1.AuxInt = ssa.Int64ToAuxInt(e - c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v2.AuxInt = ssa.Int8ToAuxInt(d << e) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (Lsh8x64 (And8 (Rsh8Ux64 <t> x (Const64 <t2> [c])) (Const8 [d])) (Const64 [e])) |
| // cond: c < e |
| // result: (And8 (Lsh8x64 <t> x (Const64 <t2> [e-c])) (Const8 <t> [d<<e])) |
| for { |
| if v_0.Op != ssaop.OpAnd8 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpRsh8Ux64 { |
| continue |
| } |
| t := v_0_0.Type |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t2 := v_0_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| if v_0_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| e := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c < e) { |
| continue |
| } |
| v.Reset(ssaop.OpAnd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLsh8x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t2) |
| v1.AuxInt = ssa.Int64ToAuxInt(e - c) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v2.AuxInt = ssa.Int8ToAuxInt(d << e) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| // match: (Lsh8x64 [false] x con:(Const64 [c])) |
| // cond: 0 < c && c < 8 |
| // result: (Lsh8x64 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(con.AuxInt) |
| if !(0 < c && c < 8) { |
| break |
| } |
| v.Reset(ssaop.OpLsh8x64) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpLsh8x8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Lsh8x8 x (Const8 [c])) |
| // result: (Lsh8x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpLsh8x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Lsh8x8 (Const8 [0]) _) |
| // result: (Const8 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Lsh8x8 [false] x con:(Const8 [c])) |
| // cond: 0 < c && c < 8 |
| // result: (Lsh8x8 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(con.AuxInt) |
| if !(0 < c && c < 8) { |
| break |
| } |
| v.Reset(ssaop.OpLsh8x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpMemEq(v *ssa.Value) bool { |
| v_3 := v.Args[3] |
| v_2 := v.Args[2] |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| typ := &b.Func.Config.Types |
| // match: (MemEq sptr tptr (Const64 [1]) mem) |
| // result: (Eq8 (Load <typ.Int8> sptr mem) (Load <typ.Int8> tptr mem)) |
| for { |
| sptr := v_0 |
| tptr := v_1 |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 1 { |
| break |
| } |
| mem := v_3 |
| v.Reset(ssaop.OpEq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8) |
| v0.AddArg2(sptr, mem) |
| v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8) |
| v1.AddArg2(tptr, mem) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| // match: (MemEq sptr tptr (Const64 [2]) mem) |
| // cond: canLoadUnaligned(config) |
| // result: (Eq16 (Load <typ.Int16> sptr mem) (Load <typ.Int16> tptr mem)) |
| for { |
| sptr := v_0 |
| tptr := v_1 |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 2 { |
| break |
| } |
| mem := v_3 |
| if !(canLoadUnaligned(config)) { |
| break |
| } |
| v.Reset(ssaop.OpEq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16) |
| v0.AddArg2(sptr, mem) |
| v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16) |
| v1.AddArg2(tptr, mem) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| // match: (MemEq sptr tptr (Const64 [4]) mem) |
| // cond: canLoadUnaligned(config) |
| // result: (Eq32 (Load <typ.Int32> sptr mem) (Load <typ.Int32> tptr mem)) |
| for { |
| sptr := v_0 |
| tptr := v_1 |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 4 { |
| break |
| } |
| mem := v_3 |
| if !(canLoadUnaligned(config)) { |
| break |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32) |
| v0.AddArg2(sptr, mem) |
| v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32) |
| v1.AddArg2(tptr, mem) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| // match: (MemEq sptr tptr (Const64 [8]) mem) |
| // cond: canLoadUnaligned(config) && config.PtrSize == 8 |
| // result: (Eq64 (Load <typ.Int64> sptr mem) (Load <typ.Int64> tptr mem)) |
| for { |
| sptr := v_0 |
| tptr := v_1 |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 8 { |
| break |
| } |
| mem := v_3 |
| if !(canLoadUnaligned(config) && config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpEq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int64) |
| v0.AddArg2(sptr, mem) |
| v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int64) |
| v1.AddArg2(tptr, mem) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| // match: (MemEq _ _ (Const64 [0]) _) |
| // result: (ConstBool <typ.Bool> [true]) |
| for { |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.Type = typ.Bool |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| // match: (MemEq p q _ _) |
| // cond: ssa.IsSamePtr(p, q) |
| // result: (ConstBool <typ.Bool> [true]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| p := v_0 |
| q := v_1 |
| if !(ssa.IsSamePtr(p, q)) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.Type = typ.Bool |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (MemEq p q (Const64 [c]) mem) |
| // cond: (c == 3 || c == 5 || c == 9 || c == 17) && canLoadUnaligned(config) && config.RegSize == 8 |
| // result: (AndB (MemEq p q (Const64 <typ.Int64> [c-1]) mem) (Eq8 (Load <typ.Int8> (OffPtr <p.Type> p [c-1]) mem) (Load <typ.Int8> (OffPtr <q.Type> q [c-1]) mem))) |
| for { |
| p := v_0 |
| q := v_1 |
| if v_2.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_2.AuxInt) |
| mem := v_3 |
| if !((c == 3 || c == 5 || c == 9 || c == 17) && canLoadUnaligned(config) && config.RegSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpAndB) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMemEq, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v1.AuxInt = ssa.Int64ToAuxInt(c - 1) |
| v0.AddArg4(p, q, v1, mem) |
| v2 := b.NewValue0(v.Pos, ssaop.OpEq8, typ.Bool) |
| v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8) |
| v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, p.Type) |
| v4.AuxInt = ssa.Int64ToAuxInt(c - 1) |
| v4.AddArg(p) |
| v3.AddArg2(v4, mem) |
| v5 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8) |
| v6 := b.NewValue0(v.Pos, ssaop.OpOffPtr, q.Type) |
| v6.AuxInt = ssa.Int64ToAuxInt(c - 1) |
| v6.AddArg(q) |
| v5.AddArg2(v6, mem) |
| v2.AddArg2(v3, v5) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| // match: (MemEq p q (Const64 [c]) mem) |
| // cond: (c == 6 || c == 10 || c == 18) && canLoadUnaligned(config) && config.RegSize == 8 |
| // result: (AndB (MemEq p q (Const64 <typ.Int64> [c-2]) mem) (Eq16 (Load <typ.Int16> (OffPtr <p.Type> p [c-2]) mem) (Load <typ.Int16> (OffPtr <q.Type> q [c-2]) mem))) |
| for { |
| p := v_0 |
| q := v_1 |
| if v_2.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_2.AuxInt) |
| mem := v_3 |
| if !((c == 6 || c == 10 || c == 18) && canLoadUnaligned(config) && config.RegSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpAndB) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMemEq, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v1.AuxInt = ssa.Int64ToAuxInt(c - 2) |
| v0.AddArg4(p, q, v1, mem) |
| v2 := b.NewValue0(v.Pos, ssaop.OpEq16, typ.Bool) |
| v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16) |
| v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, p.Type) |
| v4.AuxInt = ssa.Int64ToAuxInt(c - 2) |
| v4.AddArg(p) |
| v3.AddArg2(v4, mem) |
| v5 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16) |
| v6 := b.NewValue0(v.Pos, ssaop.OpOffPtr, q.Type) |
| v6.AuxInt = ssa.Int64ToAuxInt(c - 2) |
| v6.AddArg(q) |
| v5.AddArg2(v6, mem) |
| v2.AddArg2(v3, v5) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| // match: (MemEq p q (Const64 [c]) mem) |
| // cond: (c == 7 || c == 11 || c == 19 || c == 20) && canLoadUnaligned(config) && config.RegSize == 8 |
| // result: (AndB (MemEq p q (Const64 <typ.Int64> [min(c-3,16)]) mem) (Eq32 (Load <typ.Int32> (OffPtr <p.Type> p [c-4]) mem) (Load <typ.Int32> (OffPtr <q.Type> q [c-4]) mem))) |
| for { |
| p := v_0 |
| q := v_1 |
| if v_2.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_2.AuxInt) |
| mem := v_3 |
| if !((c == 7 || c == 11 || c == 19 || c == 20) && canLoadUnaligned(config) && config.RegSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpAndB) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMemEq, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v1.AuxInt = ssa.Int64ToAuxInt(min(c-3, 16)) |
| v0.AddArg4(p, q, v1, mem) |
| v2 := b.NewValue0(v.Pos, ssaop.OpEq32, typ.Bool) |
| v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32) |
| v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, p.Type) |
| v4.AuxInt = ssa.Int64ToAuxInt(c - 4) |
| v4.AddArg(p) |
| v3.AddArg2(v4, mem) |
| v5 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32) |
| v6 := b.NewValue0(v.Pos, ssaop.OpOffPtr, q.Type) |
| v6.AuxInt = ssa.Int64ToAuxInt(c - 4) |
| v6.AddArg(q) |
| v5.AddArg2(v6, mem) |
| v2.AddArg2(v3, v5) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| // match: (MemEq p q (Const64 [c]) mem) |
| // cond: ((c >= 12 && c <= 16) || (c >= 21 && c <= 24)) && canLoadUnaligned(config) && config.RegSize == 8 |
| // result: (AndB (MemEq p q (Const64 <typ.Int64> [8 + int64(bool2int(c>16))*8]) mem) (Eq64 (Load <typ.Int64> (OffPtr <p.Type> p [c-8]) mem) (Load <typ.Int64> (OffPtr <q.Type> q [c-8]) mem))) |
| for { |
| p := v_0 |
| q := v_1 |
| if v_2.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_2.AuxInt) |
| mem := v_3 |
| if !(((c >= 12 && c <= 16) || (c >= 21 && c <= 24)) && canLoadUnaligned(config) && config.RegSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpAndB) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMemEq, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v1.AuxInt = ssa.Int64ToAuxInt(8 + int64(bool2int(c > 16))*8) |
| v0.AddArg4(p, q, v1, mem) |
| v2 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool) |
| v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int64) |
| v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, p.Type) |
| v4.AuxInt = ssa.Int64ToAuxInt(c - 8) |
| v4.AddArg(p) |
| v3.AddArg2(v4, mem) |
| v5 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int64) |
| v6 := b.NewValue0(v.Pos, ssaop.OpOffPtr, q.Type) |
| v6.AuxInt = ssa.Int64ToAuxInt(c - 8) |
| v6.AddArg(q) |
| v5.AddArg2(v6, mem) |
| v2.AddArg2(v3, v5) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| // match: (MemEq p q (Const64 [c]) mem) |
| // cond: c >= 25 && c <= 32 && canLoadUnaligned(config) && config.RegSize == 8 |
| // result: (AndB (MemEq p q (Const64 <typ.Int64> [16]) mem) (MemEq (OffPtr <p.Type> p [16]) (OffPtr <q.Type> q [16]) (Const64 <typ.Int64> [c-16]) mem)) |
| for { |
| p := v_0 |
| q := v_1 |
| if v_2.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_2.AuxInt) |
| mem := v_3 |
| if !(c >= 25 && c <= 32 && canLoadUnaligned(config) && config.RegSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpAndB) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMemEq, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v1.AuxInt = ssa.Int64ToAuxInt(16) |
| v0.AddArg4(p, q, v1, mem) |
| v2 := b.NewValue0(v.Pos, ssaop.OpMemEq, typ.Bool) |
| v3 := b.NewValue0(v.Pos, ssaop.OpOffPtr, p.Type) |
| v3.AuxInt = ssa.Int64ToAuxInt(16) |
| v3.AddArg(p) |
| v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, q.Type) |
| v4.AuxInt = ssa.Int64ToAuxInt(16) |
| v4.AddArg(q) |
| v5 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v5.AuxInt = ssa.Int64ToAuxInt(c - 16) |
| v2.AddArg4(v3, v4, v5, mem) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpMod16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Mod16 (Const16 [c]) (Const16 [d])) |
| // cond: d != 0 |
| // result: (Const16 [c % d]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(d != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(c % d) |
| return true |
| } |
| // match: (Mod16 <t> n (Const16 [c])) |
| // cond: isNonNegative(n) && ssa.IsPowerOfTwo(c) |
| // result: (And16 n (Const16 <t> [c-1])) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(isNonNegative(n) && ssa.IsPowerOfTwo(c)) { |
| break |
| } |
| v.Reset(ssaop.OpAnd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(c - 1) |
| v.AddArg2(n, v0) |
| return true |
| } |
| // match: (Mod16 <t> n (Const16 [c])) |
| // cond: c < 0 && c != -1<<15 |
| // result: (Mod16 <t> n (Const16 <t> [-c])) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(c < 0 && c != -1<<15) { |
| break |
| } |
| v.Reset(ssaop.OpMod16) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(-c) |
| v.AddArg2(n, v0) |
| return true |
| } |
| // match: (Mod16 <t> x (Const16 [c])) |
| // cond: x.Op != ssaop.OpConst16 && (c > 0 || c == -1<<15) |
| // result: (Sub16 x (Mul16 <t> (Div16 <t> x (Const16 <t> [c])) (Const16 <t> [c]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(x.Op != ssaop.OpConst16 && (c > 0 || c == -1<<15)) { |
| break |
| } |
| v.Reset(ssaop.OpSub16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpDiv16, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v2.AuxInt = ssa.Int16ToAuxInt(c) |
| v1.AddArg2(x, v2) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpMod16u(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Mod16u (Const16 [c]) (Const16 [d])) |
| // cond: d != 0 |
| // result: (Const16 [int16(uint16(c) % uint16(d))]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(d != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(int16(uint16(c) % uint16(d))) |
| return true |
| } |
| // match: (Mod16u <t> n (Const16 [c])) |
| // cond: ssa.IsPowerOfTwo(uint16(c)) |
| // result: (And16 n (Const16 <t> [c-1])) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(uint16(c))) { |
| break |
| } |
| v.Reset(ssaop.OpAnd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(c - 1) |
| v.AddArg2(n, v0) |
| return true |
| } |
| // match: (Mod16u <t> x (Const16 [c])) |
| // cond: x.Op != ssaop.OpConst16 && c != 0 |
| // result: (Sub16 x (Mul16 <t> (Div16u <t> x (Const16 <t> [c])) (Const16 <t> [c]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(x.Op != ssaop.OpConst16 && c != 0) { |
| break |
| } |
| v.Reset(ssaop.OpSub16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpDiv16u, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v2.AuxInt = ssa.Int16ToAuxInt(c) |
| v1.AddArg2(x, v2) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpMod32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Mod32 (Const32 [c]) (Const32 [d])) |
| // cond: d != 0 |
| // result: (Const32 [c % d]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(d != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(c % d) |
| return true |
| } |
| // match: (Mod32 <t> n (Const32 [c])) |
| // cond: isNonNegative(n) && ssa.IsPowerOfTwo(c) |
| // result: (And32 n (Const32 <t> [c-1])) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(isNonNegative(n) && ssa.IsPowerOfTwo(c)) { |
| break |
| } |
| v.Reset(ssaop.OpAnd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(c - 1) |
| v.AddArg2(n, v0) |
| return true |
| } |
| // match: (Mod32 <t> n (Const32 [c])) |
| // cond: c < 0 && c != -1<<31 |
| // result: (Mod32 <t> n (Const32 <t> [-c])) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(c < 0 && c != -1<<31) { |
| break |
| } |
| v.Reset(ssaop.OpMod32) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(-c) |
| v.AddArg2(n, v0) |
| return true |
| } |
| // match: (Mod32 <t> x (Const32 [c])) |
| // cond: x.Op != ssaop.OpConst32 && (c > 0 || c == -1<<31) |
| // result: (Sub32 x (Mul32 <t> (Div32 <t> x (Const32 <t> [c])) (Const32 <t> [c]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(x.Op != ssaop.OpConst32 && (c > 0 || c == -1<<31)) { |
| break |
| } |
| v.Reset(ssaop.OpSub32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpDiv32, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v2.AuxInt = ssa.Int32ToAuxInt(c) |
| v1.AddArg2(x, v2) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpMod32u(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Mod32u (Const32 [c]) (Const32 [d])) |
| // cond: d != 0 |
| // result: (Const32 [int32(uint32(c) % uint32(d))]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(d != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(uint32(c) % uint32(d))) |
| return true |
| } |
| // match: (Mod32u <t> n (Const32 [c])) |
| // cond: ssa.IsPowerOfTwo(uint32(c)) |
| // result: (And32 n (Const32 <t> [c-1])) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(uint32(c))) { |
| break |
| } |
| v.Reset(ssaop.OpAnd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(c - 1) |
| v.AddArg2(n, v0) |
| return true |
| } |
| // match: (Mod32u <t> x (Const32 [c])) |
| // cond: x.Op != ssaop.OpConst32 && c != 0 |
| // result: (Sub32 x (Mul32 <t> (Div32u <t> x (Const32 <t> [c])) (Const32 <t> [c]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(x.Op != ssaop.OpConst32 && c != 0) { |
| break |
| } |
| v.Reset(ssaop.OpSub32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpDiv32u, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v2.AuxInt = ssa.Int32ToAuxInt(c) |
| v1.AddArg2(x, v2) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpMod64(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Mod64 (Const64 [c]) (Const64 [d])) |
| // cond: d != 0 |
| // result: (Const64 [c % d]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(d != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(c % d) |
| return true |
| } |
| // match: (Mod64 <t> n (Const64 [c])) |
| // cond: isNonNegative(n) && ssa.IsPowerOfTwo(c) |
| // result: (And64 n (Const64 <t> [c-1])) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(isNonNegative(n) && ssa.IsPowerOfTwo(c)) { |
| break |
| } |
| v.Reset(ssaop.OpAnd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c - 1) |
| v.AddArg2(n, v0) |
| return true |
| } |
| // match: (Mod64 n (Const64 [-1<<63])) |
| // cond: isNonNegative(n) |
| // result: n |
| for { |
| n := v_0 |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != -1<<63 || !(isNonNegative(n)) { |
| break |
| } |
| v.CopyOf(n) |
| return true |
| } |
| // match: (Mod64 <t> n (Const64 [c])) |
| // cond: c < 0 && c != -1<<63 |
| // result: (Mod64 <t> n (Const64 <t> [-c])) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c < 0 && c != -1<<63) { |
| break |
| } |
| v.Reset(ssaop.OpMod64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(-c) |
| v.AddArg2(n, v0) |
| return true |
| } |
| // match: (Mod64 <t> x (Const64 [c])) |
| // cond: x.Op != ssaop.OpConst64 && (c > 0 || c == -1<<63) |
| // result: (Sub64 x (Mul64 <t> (Div64 <t> x (Const64 <t> [c])) (Const64 <t> [c]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(x.Op != ssaop.OpConst64 && (c > 0 || c == -1<<63)) { |
| break |
| } |
| v.Reset(ssaop.OpSub64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpDiv64, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v2.AuxInt = ssa.Int64ToAuxInt(c) |
| v1.AddArg2(x, v2) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpMod64u(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Mod64u (Const64 [c]) (Const64 [d])) |
| // cond: d != 0 |
| // result: (Const64 [int64(uint64(c) % uint64(d))]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(d != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(uint64(c) % uint64(d))) |
| return true |
| } |
| // match: (Mod64u <t> n (Const64 [c])) |
| // cond: ssa.IsPowerOfTwo(uint64(c)) |
| // result: (And64 n (Const64 <t> [c-1])) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(uint64(c))) { |
| break |
| } |
| v.Reset(ssaop.OpAnd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c - 1) |
| v.AddArg2(n, v0) |
| return true |
| } |
| // match: (Mod64u <t> x (Const64 [c])) |
| // cond: x.Op != ssaop.OpConst64 && c != 0 |
| // result: (Sub64 x (Mul64 <t> (Div64u <t> x (Const64 <t> [c])) (Const64 <t> [c]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(x.Op != ssaop.OpConst64 && c != 0) { |
| break |
| } |
| v.Reset(ssaop.OpSub64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpDiv64u, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v2.AuxInt = ssa.Int64ToAuxInt(c) |
| v1.AddArg2(x, v2) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpMod8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Mod8 (Const8 [c]) (Const8 [d])) |
| // cond: d != 0 |
| // result: (Const8 [c % d]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(d != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(c % d) |
| return true |
| } |
| // match: (Mod8 <t> n (Const8 [c])) |
| // cond: isNonNegative(n) && ssa.IsPowerOfTwo(c) |
| // result: (And8 n (Const8 <t> [c-1])) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(isNonNegative(n) && ssa.IsPowerOfTwo(c)) { |
| break |
| } |
| v.Reset(ssaop.OpAnd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(c - 1) |
| v.AddArg2(n, v0) |
| return true |
| } |
| // match: (Mod8 <t> n (Const8 [c])) |
| // cond: c < 0 && c != -1<<7 |
| // result: (Mod8 <t> n (Const8 <t> [-c])) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(c < 0 && c != -1<<7) { |
| break |
| } |
| v.Reset(ssaop.OpMod8) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(-c) |
| v.AddArg2(n, v0) |
| return true |
| } |
| // match: (Mod8 <t> x (Const8 [c])) |
| // cond: x.Op != ssaop.OpConst8 && (c > 0 || c == -1<<7) |
| // result: (Sub8 x (Mul8 <t> (Div8 <t> x (Const8 <t> [c])) (Const8 <t> [c]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(x.Op != ssaop.OpConst8 && (c > 0 || c == -1<<7)) { |
| break |
| } |
| v.Reset(ssaop.OpSub8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpDiv8, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v2.AuxInt = ssa.Int8ToAuxInt(c) |
| v1.AddArg2(x, v2) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpMod8u(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Mod8u (Const8 [c]) (Const8 [d])) |
| // cond: d != 0 |
| // result: (Const8 [int8(uint8(c) % uint8(d))]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(d != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(int8(uint8(c) % uint8(d))) |
| return true |
| } |
| // match: (Mod8u <t> n (Const8 [c])) |
| // cond: ssa.IsPowerOfTwo(uint8(c)) |
| // result: (And8 n (Const8 <t> [c-1])) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(uint8(c))) { |
| break |
| } |
| v.Reset(ssaop.OpAnd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(c - 1) |
| v.AddArg2(n, v0) |
| return true |
| } |
| // match: (Mod8u <t> x (Const8 [c])) |
| // cond: x.Op != ssaop.OpConst8 && c != 0 |
| // result: (Sub8 x (Mul8 <t> (Div8u <t> x (Const8 <t> [c])) (Const8 <t> [c]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(x.Op != ssaop.OpConst8 && c != 0) { |
| break |
| } |
| v.Reset(ssaop.OpSub8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpDiv8u, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v2.AuxInt = ssa.Int8ToAuxInt(c) |
| v1.AddArg2(x, v2) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpMove(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: (Move {t} [n] dst1 src mem:(Zero {t} [n] dst2 _)) |
| // cond: ssa.IsSamePtr(src, dst2) |
| // result: (Zero {t} [n] dst1 mem) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t := ssa.AuxToType(v.Aux) |
| dst1 := v_0 |
| src := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem.AuxInt) != n || ssa.AuxToType(mem.Aux) != t { |
| break |
| } |
| dst2 := mem.Args[0] |
| if !(ssa.IsSamePtr(src, dst2)) { |
| break |
| } |
| v.Reset(ssaop.OpZero) |
| v.AuxInt = ssa.Int64ToAuxInt(n) |
| v.Aux = ssa.TypeToAux(t) |
| v.AddArg2(dst1, mem) |
| return true |
| } |
| // match: (Move {t} [n] dst1 src mem:(VarDef (Zero {t} [n] dst0 _))) |
| // cond: ssa.IsSamePtr(src, dst0) |
| // result: (Zero {t} [n] dst1 mem) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t := ssa.AuxToType(v.Aux) |
| dst1 := v_0 |
| src := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpVarDef { |
| break |
| } |
| mem_0 := mem.Args[0] |
| if mem_0.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_0.AuxInt) != n || ssa.AuxToType(mem_0.Aux) != t { |
| break |
| } |
| dst0 := mem_0.Args[0] |
| if !(ssa.IsSamePtr(src, dst0)) { |
| break |
| } |
| v.Reset(ssaop.OpZero) |
| v.AuxInt = ssa.Int64ToAuxInt(n) |
| v.Aux = ssa.TypeToAux(t) |
| v.AddArg2(dst1, mem) |
| return true |
| } |
| // match: (Move {t} [n] dst (Addr {sym} (SB)) mem) |
| // cond: symIsROZero(sym) |
| // result: (Zero {t} [n] dst mem) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| if v_1.Op != ssaop.OpAddr { |
| break |
| } |
| sym := ssa.AuxToSym(v_1.Aux) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpSB { |
| break |
| } |
| mem := v_2 |
| if !(symIsROZero(sym)) { |
| break |
| } |
| v.Reset(ssaop.OpZero) |
| v.AuxInt = ssa.Int64ToAuxInt(n) |
| v.Aux = ssa.TypeToAux(t) |
| v.AddArg2(dst, mem) |
| return true |
| } |
| // match: (Move {t1} [n] dst1 src1 store:(Store {t2} op1:(OffPtr [o2] dst2) _ mem)) |
| // cond: ssa.IsSamePtr(dst1, dst2) && store.Uses == 1 && n >= o2 + t2.Size() && ssa.Disjoint1(src1, n, op1, t2.Size()) && ssa.Clobber(store) |
| // result: (Move {t1} [n] dst1 src1 mem) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst1 := v_0 |
| src1 := v_1 |
| store := v_2 |
| if store.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(store.Aux) |
| mem := store.Args[2] |
| op1 := store.Args[0] |
| if op1.Op != ssaop.OpOffPtr { |
| break |
| } |
| o2 := ssa.AuxIntToInt64(op1.AuxInt) |
| dst2 := op1.Args[0] |
| if !(ssa.IsSamePtr(dst1, dst2) && store.Uses == 1 && n >= o2+t2.Size() && ssa.Disjoint1(src1, n, op1, t2.Size()) && ssa.Clobber(store)) { |
| break |
| } |
| v.Reset(ssaop.OpMove) |
| v.AuxInt = ssa.Int64ToAuxInt(n) |
| v.Aux = ssa.TypeToAux(t1) |
| v.AddArg3(dst1, src1, mem) |
| return true |
| } |
| // match: (Move {t} [n] dst1 src1 move:(Move {t} [n] dst2 _ mem)) |
| // cond: move.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Disjoint1(src1, n, dst2, n) && ssa.Clobber(move) |
| // result: (Move {t} [n] dst1 src1 mem) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t := ssa.AuxToType(v.Aux) |
| dst1 := v_0 |
| src1 := v_1 |
| move := v_2 |
| if move.Op != ssaop.OpMove || ssa.AuxIntToInt64(move.AuxInt) != n || ssa.AuxToType(move.Aux) != t { |
| break |
| } |
| mem := move.Args[2] |
| dst2 := move.Args[0] |
| if !(move.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Disjoint1(src1, n, dst2, n) && ssa.Clobber(move)) { |
| break |
| } |
| v.Reset(ssaop.OpMove) |
| v.AuxInt = ssa.Int64ToAuxInt(n) |
| v.Aux = ssa.TypeToAux(t) |
| v.AddArg3(dst1, src1, mem) |
| return true |
| } |
| // match: (Move {t} [n] dst1 src1 vardef:(VarDef {x} move:(Move {t} [n] dst2 _ mem))) |
| // cond: move.Uses == 1 && vardef.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Disjoint1(src1, n, dst2, n) && ssa.Clobber(move, vardef) |
| // result: (Move {t} [n] dst1 src1 (VarDef {x} mem)) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t := ssa.AuxToType(v.Aux) |
| dst1 := v_0 |
| src1 := v_1 |
| vardef := v_2 |
| if vardef.Op != ssaop.OpVarDef { |
| break |
| } |
| x := ssa.AuxToSym(vardef.Aux) |
| move := vardef.Args[0] |
| if move.Op != ssaop.OpMove || ssa.AuxIntToInt64(move.AuxInt) != n || ssa.AuxToType(move.Aux) != t { |
| break |
| } |
| mem := move.Args[2] |
| dst2 := move.Args[0] |
| if !(move.Uses == 1 && vardef.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Disjoint1(src1, n, dst2, n) && ssa.Clobber(move, vardef)) { |
| break |
| } |
| v.Reset(ssaop.OpMove) |
| v.AuxInt = ssa.Int64ToAuxInt(n) |
| v.Aux = ssa.TypeToAux(t) |
| v0 := b.NewValue0(v.Pos, ssaop.OpVarDef, types.TypeMem) |
| v0.Aux = ssa.SymToAux(x) |
| v0.AddArg(mem) |
| v.AddArg3(dst1, src1, v0) |
| return true |
| } |
| // match: (Move {t} [n] dst1 src1 zero:(Zero {t} [n] dst2 mem)) |
| // cond: zero.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Disjoint1(src1, n, dst2, n) && ssa.Clobber(zero) |
| // result: (Move {t} [n] dst1 src1 mem) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t := ssa.AuxToType(v.Aux) |
| dst1 := v_0 |
| src1 := v_1 |
| zero := v_2 |
| if zero.Op != ssaop.OpZero || ssa.AuxIntToInt64(zero.AuxInt) != n || ssa.AuxToType(zero.Aux) != t { |
| break |
| } |
| mem := zero.Args[1] |
| dst2 := zero.Args[0] |
| if !(zero.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Disjoint1(src1, n, dst2, n) && ssa.Clobber(zero)) { |
| break |
| } |
| v.Reset(ssaop.OpMove) |
| v.AuxInt = ssa.Int64ToAuxInt(n) |
| v.Aux = ssa.TypeToAux(t) |
| v.AddArg3(dst1, src1, mem) |
| return true |
| } |
| // match: (Move {t} [n] dst1 src1 vardef:(VarDef {x} zero:(Zero {t} [n] dst2 mem))) |
| // cond: zero.Uses == 1 && vardef.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Disjoint1(src1, n, dst2, n) && ssa.Clobber(zero, vardef) |
| // result: (Move {t} [n] dst1 src1 (VarDef {x} mem)) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t := ssa.AuxToType(v.Aux) |
| dst1 := v_0 |
| src1 := v_1 |
| vardef := v_2 |
| if vardef.Op != ssaop.OpVarDef { |
| break |
| } |
| x := ssa.AuxToSym(vardef.Aux) |
| zero := vardef.Args[0] |
| if zero.Op != ssaop.OpZero || ssa.AuxIntToInt64(zero.AuxInt) != n || ssa.AuxToType(zero.Aux) != t { |
| break |
| } |
| mem := zero.Args[1] |
| dst2 := zero.Args[0] |
| if !(zero.Uses == 1 && vardef.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Disjoint1(src1, n, dst2, n) && ssa.Clobber(zero, vardef)) { |
| break |
| } |
| v.Reset(ssaop.OpMove) |
| v.AuxInt = ssa.Int64ToAuxInt(n) |
| v.Aux = ssa.TypeToAux(t) |
| v0 := b.NewValue0(v.Pos, ssaop.OpVarDef, types.TypeMem) |
| v0.Aux = ssa.SymToAux(x) |
| v0.AddArg(mem) |
| v.AddArg3(dst1, src1, v0) |
| return true |
| } |
| // match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [0] p3) d2 _))) |
| // cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && o2 == t3.Size() && n == t2.Size() + t3.Size() |
| // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [0] dst) d2 mem)) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| p1 := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem.Aux) |
| _ = mem.Args[2] |
| op2 := mem.Args[0] |
| if op2.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt2 := op2.Type |
| o2 := ssa.AuxIntToInt64(op2.AuxInt) |
| p2 := op2.Args[0] |
| d1 := mem.Args[1] |
| mem_2 := mem.Args[2] |
| if mem_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem_2.Aux) |
| d2 := mem_2.Args[1] |
| op3 := mem_2.Args[0] |
| if op3.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt3 := op3.Type |
| if ssa.AuxIntToInt64(op3.AuxInt) != 0 { |
| break |
| } |
| p3 := op3.Args[0] |
| if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && o2 == t3.Size() && n == t2.Size()+t3.Size()) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t2) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2) |
| v0.AuxInt = ssa.Int64ToAuxInt(o2) |
| v0.AddArg(dst) |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v1.Aux = ssa.TypeToAux(t3) |
| v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3) |
| v2.AuxInt = ssa.Int64ToAuxInt(0) |
| v2.AddArg(dst) |
| v1.AddArg3(v2, d2, mem) |
| v.AddArg3(v0, d1, v1) |
| return true |
| } |
| // match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [0] p4) d3 _)))) |
| // cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == t4.Size() && o2-o3 == t3.Size() && n == t2.Size() + t3.Size() + t4.Size() |
| // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [0] dst) d3 mem))) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| p1 := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem.Aux) |
| _ = mem.Args[2] |
| op2 := mem.Args[0] |
| if op2.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt2 := op2.Type |
| o2 := ssa.AuxIntToInt64(op2.AuxInt) |
| p2 := op2.Args[0] |
| d1 := mem.Args[1] |
| mem_2 := mem.Args[2] |
| if mem_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem_2.Aux) |
| _ = mem_2.Args[2] |
| op3 := mem_2.Args[0] |
| if op3.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt3 := op3.Type |
| o3 := ssa.AuxIntToInt64(op3.AuxInt) |
| p3 := op3.Args[0] |
| d2 := mem_2.Args[1] |
| mem_2_2 := mem_2.Args[2] |
| if mem_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(mem_2_2.Aux) |
| d3 := mem_2_2.Args[1] |
| op4 := mem_2_2.Args[0] |
| if op4.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt4 := op4.Type |
| if ssa.AuxIntToInt64(op4.AuxInt) != 0 { |
| break |
| } |
| p4 := op4.Args[0] |
| if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == t4.Size() && o2-o3 == t3.Size() && n == t2.Size()+t3.Size()+t4.Size()) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t2) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2) |
| v0.AuxInt = ssa.Int64ToAuxInt(o2) |
| v0.AddArg(dst) |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v1.Aux = ssa.TypeToAux(t3) |
| v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3) |
| v2.AuxInt = ssa.Int64ToAuxInt(o3) |
| v2.AddArg(dst) |
| v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v3.Aux = ssa.TypeToAux(t4) |
| v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt4) |
| v4.AuxInt = ssa.Int64ToAuxInt(0) |
| v4.AddArg(dst) |
| v3.AddArg3(v4, d3, mem) |
| v1.AddArg3(v2, d2, v3) |
| v.AddArg3(v0, d1, v1) |
| return true |
| } |
| // match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [o4] p4) d3 (Store {t5} op5:(OffPtr <tt5> [0] p5) d4 _))))) |
| // cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == t5.Size() && o3-o4 == t4.Size() && o2-o3 == t3.Size() && n == t2.Size() + t3.Size() + t4.Size() + t5.Size() |
| // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [0] dst) d4 mem)))) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| p1 := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem.Aux) |
| _ = mem.Args[2] |
| op2 := mem.Args[0] |
| if op2.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt2 := op2.Type |
| o2 := ssa.AuxIntToInt64(op2.AuxInt) |
| p2 := op2.Args[0] |
| d1 := mem.Args[1] |
| mem_2 := mem.Args[2] |
| if mem_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem_2.Aux) |
| _ = mem_2.Args[2] |
| op3 := mem_2.Args[0] |
| if op3.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt3 := op3.Type |
| o3 := ssa.AuxIntToInt64(op3.AuxInt) |
| p3 := op3.Args[0] |
| d2 := mem_2.Args[1] |
| mem_2_2 := mem_2.Args[2] |
| if mem_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(mem_2_2.Aux) |
| _ = mem_2_2.Args[2] |
| op4 := mem_2_2.Args[0] |
| if op4.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt4 := op4.Type |
| o4 := ssa.AuxIntToInt64(op4.AuxInt) |
| p4 := op4.Args[0] |
| d3 := mem_2_2.Args[1] |
| mem_2_2_2 := mem_2_2.Args[2] |
| if mem_2_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t5 := ssa.AuxToType(mem_2_2_2.Aux) |
| d4 := mem_2_2_2.Args[1] |
| op5 := mem_2_2_2.Args[0] |
| if op5.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt5 := op5.Type |
| if ssa.AuxIntToInt64(op5.AuxInt) != 0 { |
| break |
| } |
| p5 := op5.Args[0] |
| if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == t5.Size() && o3-o4 == t4.Size() && o2-o3 == t3.Size() && n == t2.Size()+t3.Size()+t4.Size()+t5.Size()) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t2) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2) |
| v0.AuxInt = ssa.Int64ToAuxInt(o2) |
| v0.AddArg(dst) |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v1.Aux = ssa.TypeToAux(t3) |
| v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3) |
| v2.AuxInt = ssa.Int64ToAuxInt(o3) |
| v2.AddArg(dst) |
| v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v3.Aux = ssa.TypeToAux(t4) |
| v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt4) |
| v4.AuxInt = ssa.Int64ToAuxInt(o4) |
| v4.AddArg(dst) |
| v5 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v5.Aux = ssa.TypeToAux(t5) |
| v6 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt5) |
| v6.AuxInt = ssa.Int64ToAuxInt(0) |
| v6.AddArg(dst) |
| v5.AddArg3(v6, d4, mem) |
| v3.AddArg3(v4, d3, v5) |
| v1.AddArg3(v2, d2, v3) |
| v.AddArg3(v0, d1, v1) |
| return true |
| } |
| // match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [0] p3) d2 _)))) |
| // cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && o2 == t3.Size() && n == t2.Size() + t3.Size() |
| // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [0] dst) d2 mem)) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| p1 := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpVarDef { |
| break |
| } |
| mem_0 := mem.Args[0] |
| if mem_0.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem_0.Aux) |
| _ = mem_0.Args[2] |
| op2 := mem_0.Args[0] |
| if op2.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt2 := op2.Type |
| o2 := ssa.AuxIntToInt64(op2.AuxInt) |
| p2 := op2.Args[0] |
| d1 := mem_0.Args[1] |
| mem_0_2 := mem_0.Args[2] |
| if mem_0_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem_0_2.Aux) |
| d2 := mem_0_2.Args[1] |
| op3 := mem_0_2.Args[0] |
| if op3.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt3 := op3.Type |
| if ssa.AuxIntToInt64(op3.AuxInt) != 0 { |
| break |
| } |
| p3 := op3.Args[0] |
| if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && o2 == t3.Size() && n == t2.Size()+t3.Size()) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t2) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2) |
| v0.AuxInt = ssa.Int64ToAuxInt(o2) |
| v0.AddArg(dst) |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v1.Aux = ssa.TypeToAux(t3) |
| v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3) |
| v2.AuxInt = ssa.Int64ToAuxInt(0) |
| v2.AddArg(dst) |
| v1.AddArg3(v2, d2, mem) |
| v.AddArg3(v0, d1, v1) |
| return true |
| } |
| // match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [0] p4) d3 _))))) |
| // cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == t4.Size() && o2-o3 == t3.Size() && n == t2.Size() + t3.Size() + t4.Size() |
| // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [0] dst) d3 mem))) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| p1 := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpVarDef { |
| break |
| } |
| mem_0 := mem.Args[0] |
| if mem_0.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem_0.Aux) |
| _ = mem_0.Args[2] |
| op2 := mem_0.Args[0] |
| if op2.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt2 := op2.Type |
| o2 := ssa.AuxIntToInt64(op2.AuxInt) |
| p2 := op2.Args[0] |
| d1 := mem_0.Args[1] |
| mem_0_2 := mem_0.Args[2] |
| if mem_0_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem_0_2.Aux) |
| _ = mem_0_2.Args[2] |
| op3 := mem_0_2.Args[0] |
| if op3.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt3 := op3.Type |
| o3 := ssa.AuxIntToInt64(op3.AuxInt) |
| p3 := op3.Args[0] |
| d2 := mem_0_2.Args[1] |
| mem_0_2_2 := mem_0_2.Args[2] |
| if mem_0_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(mem_0_2_2.Aux) |
| d3 := mem_0_2_2.Args[1] |
| op4 := mem_0_2_2.Args[0] |
| if op4.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt4 := op4.Type |
| if ssa.AuxIntToInt64(op4.AuxInt) != 0 { |
| break |
| } |
| p4 := op4.Args[0] |
| if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == t4.Size() && o2-o3 == t3.Size() && n == t2.Size()+t3.Size()+t4.Size()) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t2) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2) |
| v0.AuxInt = ssa.Int64ToAuxInt(o2) |
| v0.AddArg(dst) |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v1.Aux = ssa.TypeToAux(t3) |
| v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3) |
| v2.AuxInt = ssa.Int64ToAuxInt(o3) |
| v2.AddArg(dst) |
| v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v3.Aux = ssa.TypeToAux(t4) |
| v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt4) |
| v4.AuxInt = ssa.Int64ToAuxInt(0) |
| v4.AddArg(dst) |
| v3.AddArg3(v4, d3, mem) |
| v1.AddArg3(v2, d2, v3) |
| v.AddArg3(v0, d1, v1) |
| return true |
| } |
| // match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [o4] p4) d3 (Store {t5} op5:(OffPtr <tt5> [0] p5) d4 _)))))) |
| // cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == t5.Size() && o3-o4 == t4.Size() && o2-o3 == t3.Size() && n == t2.Size() + t3.Size() + t4.Size() + t5.Size() |
| // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [0] dst) d4 mem)))) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| p1 := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpVarDef { |
| break |
| } |
| mem_0 := mem.Args[0] |
| if mem_0.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem_0.Aux) |
| _ = mem_0.Args[2] |
| op2 := mem_0.Args[0] |
| if op2.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt2 := op2.Type |
| o2 := ssa.AuxIntToInt64(op2.AuxInt) |
| p2 := op2.Args[0] |
| d1 := mem_0.Args[1] |
| mem_0_2 := mem_0.Args[2] |
| if mem_0_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem_0_2.Aux) |
| _ = mem_0_2.Args[2] |
| op3 := mem_0_2.Args[0] |
| if op3.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt3 := op3.Type |
| o3 := ssa.AuxIntToInt64(op3.AuxInt) |
| p3 := op3.Args[0] |
| d2 := mem_0_2.Args[1] |
| mem_0_2_2 := mem_0_2.Args[2] |
| if mem_0_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(mem_0_2_2.Aux) |
| _ = mem_0_2_2.Args[2] |
| op4 := mem_0_2_2.Args[0] |
| if op4.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt4 := op4.Type |
| o4 := ssa.AuxIntToInt64(op4.AuxInt) |
| p4 := op4.Args[0] |
| d3 := mem_0_2_2.Args[1] |
| mem_0_2_2_2 := mem_0_2_2.Args[2] |
| if mem_0_2_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t5 := ssa.AuxToType(mem_0_2_2_2.Aux) |
| d4 := mem_0_2_2_2.Args[1] |
| op5 := mem_0_2_2_2.Args[0] |
| if op5.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt5 := op5.Type |
| if ssa.AuxIntToInt64(op5.AuxInt) != 0 { |
| break |
| } |
| p5 := op5.Args[0] |
| if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == t5.Size() && o3-o4 == t4.Size() && o2-o3 == t3.Size() && n == t2.Size()+t3.Size()+t4.Size()+t5.Size()) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t2) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2) |
| v0.AuxInt = ssa.Int64ToAuxInt(o2) |
| v0.AddArg(dst) |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v1.Aux = ssa.TypeToAux(t3) |
| v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3) |
| v2.AuxInt = ssa.Int64ToAuxInt(o3) |
| v2.AddArg(dst) |
| v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v3.Aux = ssa.TypeToAux(t4) |
| v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt4) |
| v4.AuxInt = ssa.Int64ToAuxInt(o4) |
| v4.AddArg(dst) |
| v5 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v5.Aux = ssa.TypeToAux(t5) |
| v6 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt5) |
| v6.AuxInt = ssa.Int64ToAuxInt(0) |
| v6.AddArg(dst) |
| v5.AddArg3(v6, d4, mem) |
| v3.AddArg3(v4, d3, v5) |
| v1.AddArg3(v2, d2, v3) |
| v.AddArg3(v0, d1, v1) |
| return true |
| } |
| // match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Zero {t3} [n] p3 _))) |
| // cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && registerizable(b, t2) && n >= o2 + t2.Size() |
| // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Zero {t1} [n] dst mem)) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| p1 := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem.Aux) |
| _ = mem.Args[2] |
| op2 := mem.Args[0] |
| if op2.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt2 := op2.Type |
| o2 := ssa.AuxIntToInt64(op2.AuxInt) |
| p2 := op2.Args[0] |
| d1 := mem.Args[1] |
| mem_2 := mem.Args[2] |
| if mem_2.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_2.AuxInt) != n { |
| break |
| } |
| t3 := ssa.AuxToType(mem_2.Aux) |
| p3 := mem_2.Args[0] |
| if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && registerizable(b, t2) && n >= o2+t2.Size()) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t2) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2) |
| v0.AuxInt = ssa.Int64ToAuxInt(o2) |
| v0.AddArg(dst) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZero, types.TypeMem) |
| v1.AuxInt = ssa.Int64ToAuxInt(n) |
| v1.Aux = ssa.TypeToAux(t1) |
| v1.AddArg2(dst, mem) |
| v.AddArg3(v0, d1, v1) |
| return true |
| } |
| // match: (Move {t1} [n] dst p1 mem:(Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Zero {t4} [n] p4 _)))) |
| // cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && n >= o2 + t2.Size() && n >= o3 + t3.Size() |
| // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Zero {t1} [n] dst mem))) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| p1 := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem.Aux) |
| _ = mem.Args[2] |
| mem_0 := mem.Args[0] |
| if mem_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt2 := mem_0.Type |
| o2 := ssa.AuxIntToInt64(mem_0.AuxInt) |
| p2 := mem_0.Args[0] |
| d1 := mem.Args[1] |
| mem_2 := mem.Args[2] |
| if mem_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem_2.Aux) |
| _ = mem_2.Args[2] |
| mem_2_0 := mem_2.Args[0] |
| if mem_2_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt3 := mem_2_0.Type |
| o3 := ssa.AuxIntToInt64(mem_2_0.AuxInt) |
| p3 := mem_2_0.Args[0] |
| d2 := mem_2.Args[1] |
| mem_2_2 := mem_2.Args[2] |
| if mem_2_2.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_2_2.AuxInt) != n { |
| break |
| } |
| t4 := ssa.AuxToType(mem_2_2.Aux) |
| p4 := mem_2_2.Args[0] |
| if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && n >= o2+t2.Size() && n >= o3+t3.Size()) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t2) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2) |
| v0.AuxInt = ssa.Int64ToAuxInt(o2) |
| v0.AddArg(dst) |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v1.Aux = ssa.TypeToAux(t3) |
| v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3) |
| v2.AuxInt = ssa.Int64ToAuxInt(o3) |
| v2.AddArg(dst) |
| v3 := b.NewValue0(v.Pos, ssaop.OpZero, types.TypeMem) |
| v3.AuxInt = ssa.Int64ToAuxInt(n) |
| v3.Aux = ssa.TypeToAux(t1) |
| v3.AddArg2(dst, mem) |
| v1.AddArg3(v2, d2, v3) |
| v.AddArg3(v0, d1, v1) |
| return true |
| } |
| // match: (Move {t1} [n] dst p1 mem:(Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Zero {t5} [n] p5 _))))) |
| // cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2 + t2.Size() && n >= o3 + t3.Size() && n >= o4 + t4.Size() |
| // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Zero {t1} [n] dst mem)))) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| p1 := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem.Aux) |
| _ = mem.Args[2] |
| mem_0 := mem.Args[0] |
| if mem_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt2 := mem_0.Type |
| o2 := ssa.AuxIntToInt64(mem_0.AuxInt) |
| p2 := mem_0.Args[0] |
| d1 := mem.Args[1] |
| mem_2 := mem.Args[2] |
| if mem_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem_2.Aux) |
| _ = mem_2.Args[2] |
| mem_2_0 := mem_2.Args[0] |
| if mem_2_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt3 := mem_2_0.Type |
| o3 := ssa.AuxIntToInt64(mem_2_0.AuxInt) |
| p3 := mem_2_0.Args[0] |
| d2 := mem_2.Args[1] |
| mem_2_2 := mem_2.Args[2] |
| if mem_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(mem_2_2.Aux) |
| _ = mem_2_2.Args[2] |
| mem_2_2_0 := mem_2_2.Args[0] |
| if mem_2_2_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt4 := mem_2_2_0.Type |
| o4 := ssa.AuxIntToInt64(mem_2_2_0.AuxInt) |
| p4 := mem_2_2_0.Args[0] |
| d3 := mem_2_2.Args[1] |
| mem_2_2_2 := mem_2_2.Args[2] |
| if mem_2_2_2.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_2_2_2.AuxInt) != n { |
| break |
| } |
| t5 := ssa.AuxToType(mem_2_2_2.Aux) |
| p5 := mem_2_2_2.Args[0] |
| if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2+t2.Size() && n >= o3+t3.Size() && n >= o4+t4.Size()) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t2) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2) |
| v0.AuxInt = ssa.Int64ToAuxInt(o2) |
| v0.AddArg(dst) |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v1.Aux = ssa.TypeToAux(t3) |
| v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3) |
| v2.AuxInt = ssa.Int64ToAuxInt(o3) |
| v2.AddArg(dst) |
| v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v3.Aux = ssa.TypeToAux(t4) |
| v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt4) |
| v4.AuxInt = ssa.Int64ToAuxInt(o4) |
| v4.AddArg(dst) |
| v5 := b.NewValue0(v.Pos, ssaop.OpZero, types.TypeMem) |
| v5.AuxInt = ssa.Int64ToAuxInt(n) |
| v5.Aux = ssa.TypeToAux(t1) |
| v5.AddArg2(dst, mem) |
| v3.AddArg3(v4, d3, v5) |
| v1.AddArg3(v2, d2, v3) |
| v.AddArg3(v0, d1, v1) |
| return true |
| } |
| // match: (Move {t1} [n] dst p1 mem:(Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Store {t5} (OffPtr <tt5> [o5] p5) d4 (Zero {t6} [n] p6 _)))))) |
| // cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && ssa.IsSamePtr(p5, p6) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && t6.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2 + t2.Size() && n >= o3 + t3.Size() && n >= o4 + t4.Size() && n >= o5 + t5.Size() |
| // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [o5] dst) d4 (Zero {t1} [n] dst mem))))) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| p1 := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem.Aux) |
| _ = mem.Args[2] |
| mem_0 := mem.Args[0] |
| if mem_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt2 := mem_0.Type |
| o2 := ssa.AuxIntToInt64(mem_0.AuxInt) |
| p2 := mem_0.Args[0] |
| d1 := mem.Args[1] |
| mem_2 := mem.Args[2] |
| if mem_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem_2.Aux) |
| _ = mem_2.Args[2] |
| mem_2_0 := mem_2.Args[0] |
| if mem_2_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt3 := mem_2_0.Type |
| o3 := ssa.AuxIntToInt64(mem_2_0.AuxInt) |
| p3 := mem_2_0.Args[0] |
| d2 := mem_2.Args[1] |
| mem_2_2 := mem_2.Args[2] |
| if mem_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(mem_2_2.Aux) |
| _ = mem_2_2.Args[2] |
| mem_2_2_0 := mem_2_2.Args[0] |
| if mem_2_2_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt4 := mem_2_2_0.Type |
| o4 := ssa.AuxIntToInt64(mem_2_2_0.AuxInt) |
| p4 := mem_2_2_0.Args[0] |
| d3 := mem_2_2.Args[1] |
| mem_2_2_2 := mem_2_2.Args[2] |
| if mem_2_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t5 := ssa.AuxToType(mem_2_2_2.Aux) |
| _ = mem_2_2_2.Args[2] |
| mem_2_2_2_0 := mem_2_2_2.Args[0] |
| if mem_2_2_2_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt5 := mem_2_2_2_0.Type |
| o5 := ssa.AuxIntToInt64(mem_2_2_2_0.AuxInt) |
| p5 := mem_2_2_2_0.Args[0] |
| d4 := mem_2_2_2.Args[1] |
| mem_2_2_2_2 := mem_2_2_2.Args[2] |
| if mem_2_2_2_2.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_2_2_2_2.AuxInt) != n { |
| break |
| } |
| t6 := ssa.AuxToType(mem_2_2_2_2.Aux) |
| p6 := mem_2_2_2_2.Args[0] |
| if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && ssa.IsSamePtr(p5, p6) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && t6.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2+t2.Size() && n >= o3+t3.Size() && n >= o4+t4.Size() && n >= o5+t5.Size()) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t2) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2) |
| v0.AuxInt = ssa.Int64ToAuxInt(o2) |
| v0.AddArg(dst) |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v1.Aux = ssa.TypeToAux(t3) |
| v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3) |
| v2.AuxInt = ssa.Int64ToAuxInt(o3) |
| v2.AddArg(dst) |
| v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v3.Aux = ssa.TypeToAux(t4) |
| v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt4) |
| v4.AuxInt = ssa.Int64ToAuxInt(o4) |
| v4.AddArg(dst) |
| v5 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v5.Aux = ssa.TypeToAux(t5) |
| v6 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt5) |
| v6.AuxInt = ssa.Int64ToAuxInt(o5) |
| v6.AddArg(dst) |
| v7 := b.NewValue0(v.Pos, ssaop.OpZero, types.TypeMem) |
| v7.AuxInt = ssa.Int64ToAuxInt(n) |
| v7.Aux = ssa.TypeToAux(t1) |
| v7.AddArg2(dst, mem) |
| v5.AddArg3(v6, d4, v7) |
| v3.AddArg3(v4, d3, v5) |
| v1.AddArg3(v2, d2, v3) |
| v.AddArg3(v0, d1, v1) |
| return true |
| } |
| // match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Zero {t3} [n] p3 _)))) |
| // cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && registerizable(b, t2) && n >= o2 + t2.Size() |
| // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Zero {t1} [n] dst mem)) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| p1 := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpVarDef { |
| break |
| } |
| mem_0 := mem.Args[0] |
| if mem_0.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem_0.Aux) |
| _ = mem_0.Args[2] |
| op2 := mem_0.Args[0] |
| if op2.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt2 := op2.Type |
| o2 := ssa.AuxIntToInt64(op2.AuxInt) |
| p2 := op2.Args[0] |
| d1 := mem_0.Args[1] |
| mem_0_2 := mem_0.Args[2] |
| if mem_0_2.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_0_2.AuxInt) != n { |
| break |
| } |
| t3 := ssa.AuxToType(mem_0_2.Aux) |
| p3 := mem_0_2.Args[0] |
| if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && registerizable(b, t2) && n >= o2+t2.Size()) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t2) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2) |
| v0.AuxInt = ssa.Int64ToAuxInt(o2) |
| v0.AddArg(dst) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZero, types.TypeMem) |
| v1.AuxInt = ssa.Int64ToAuxInt(n) |
| v1.Aux = ssa.TypeToAux(t1) |
| v1.AddArg2(dst, mem) |
| v.AddArg3(v0, d1, v1) |
| return true |
| } |
| // match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Zero {t4} [n] p4 _))))) |
| // cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && n >= o2 + t2.Size() && n >= o3 + t3.Size() |
| // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Zero {t1} [n] dst mem))) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| p1 := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpVarDef { |
| break |
| } |
| mem_0 := mem.Args[0] |
| if mem_0.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem_0.Aux) |
| _ = mem_0.Args[2] |
| mem_0_0 := mem_0.Args[0] |
| if mem_0_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt2 := mem_0_0.Type |
| o2 := ssa.AuxIntToInt64(mem_0_0.AuxInt) |
| p2 := mem_0_0.Args[0] |
| d1 := mem_0.Args[1] |
| mem_0_2 := mem_0.Args[2] |
| if mem_0_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem_0_2.Aux) |
| _ = mem_0_2.Args[2] |
| mem_0_2_0 := mem_0_2.Args[0] |
| if mem_0_2_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt3 := mem_0_2_0.Type |
| o3 := ssa.AuxIntToInt64(mem_0_2_0.AuxInt) |
| p3 := mem_0_2_0.Args[0] |
| d2 := mem_0_2.Args[1] |
| mem_0_2_2 := mem_0_2.Args[2] |
| if mem_0_2_2.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_0_2_2.AuxInt) != n { |
| break |
| } |
| t4 := ssa.AuxToType(mem_0_2_2.Aux) |
| p4 := mem_0_2_2.Args[0] |
| if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && n >= o2+t2.Size() && n >= o3+t3.Size()) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t2) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2) |
| v0.AuxInt = ssa.Int64ToAuxInt(o2) |
| v0.AddArg(dst) |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v1.Aux = ssa.TypeToAux(t3) |
| v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3) |
| v2.AuxInt = ssa.Int64ToAuxInt(o3) |
| v2.AddArg(dst) |
| v3 := b.NewValue0(v.Pos, ssaop.OpZero, types.TypeMem) |
| v3.AuxInt = ssa.Int64ToAuxInt(n) |
| v3.Aux = ssa.TypeToAux(t1) |
| v3.AddArg2(dst, mem) |
| v1.AddArg3(v2, d2, v3) |
| v.AddArg3(v0, d1, v1) |
| return true |
| } |
| // match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Zero {t5} [n] p5 _)))))) |
| // cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2 + t2.Size() && n >= o3 + t3.Size() && n >= o4 + t4.Size() |
| // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Zero {t1} [n] dst mem)))) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| p1 := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpVarDef { |
| break |
| } |
| mem_0 := mem.Args[0] |
| if mem_0.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem_0.Aux) |
| _ = mem_0.Args[2] |
| mem_0_0 := mem_0.Args[0] |
| if mem_0_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt2 := mem_0_0.Type |
| o2 := ssa.AuxIntToInt64(mem_0_0.AuxInt) |
| p2 := mem_0_0.Args[0] |
| d1 := mem_0.Args[1] |
| mem_0_2 := mem_0.Args[2] |
| if mem_0_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem_0_2.Aux) |
| _ = mem_0_2.Args[2] |
| mem_0_2_0 := mem_0_2.Args[0] |
| if mem_0_2_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt3 := mem_0_2_0.Type |
| o3 := ssa.AuxIntToInt64(mem_0_2_0.AuxInt) |
| p3 := mem_0_2_0.Args[0] |
| d2 := mem_0_2.Args[1] |
| mem_0_2_2 := mem_0_2.Args[2] |
| if mem_0_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(mem_0_2_2.Aux) |
| _ = mem_0_2_2.Args[2] |
| mem_0_2_2_0 := mem_0_2_2.Args[0] |
| if mem_0_2_2_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt4 := mem_0_2_2_0.Type |
| o4 := ssa.AuxIntToInt64(mem_0_2_2_0.AuxInt) |
| p4 := mem_0_2_2_0.Args[0] |
| d3 := mem_0_2_2.Args[1] |
| mem_0_2_2_2 := mem_0_2_2.Args[2] |
| if mem_0_2_2_2.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_0_2_2_2.AuxInt) != n { |
| break |
| } |
| t5 := ssa.AuxToType(mem_0_2_2_2.Aux) |
| p5 := mem_0_2_2_2.Args[0] |
| if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2+t2.Size() && n >= o3+t3.Size() && n >= o4+t4.Size()) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t2) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2) |
| v0.AuxInt = ssa.Int64ToAuxInt(o2) |
| v0.AddArg(dst) |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v1.Aux = ssa.TypeToAux(t3) |
| v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3) |
| v2.AuxInt = ssa.Int64ToAuxInt(o3) |
| v2.AddArg(dst) |
| v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v3.Aux = ssa.TypeToAux(t4) |
| v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt4) |
| v4.AuxInt = ssa.Int64ToAuxInt(o4) |
| v4.AddArg(dst) |
| v5 := b.NewValue0(v.Pos, ssaop.OpZero, types.TypeMem) |
| v5.AuxInt = ssa.Int64ToAuxInt(n) |
| v5.Aux = ssa.TypeToAux(t1) |
| v5.AddArg2(dst, mem) |
| v3.AddArg3(v4, d3, v5) |
| v1.AddArg3(v2, d2, v3) |
| v.AddArg3(v0, d1, v1) |
| return true |
| } |
| // match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Store {t5} (OffPtr <tt5> [o5] p5) d4 (Zero {t6} [n] p6 _))))))) |
| // cond: ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && ssa.IsSamePtr(p5, p6) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && t6.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2 + t2.Size() && n >= o3 + t3.Size() && n >= o4 + t4.Size() && n >= o5 + t5.Size() |
| // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [o5] dst) d4 (Zero {t1} [n] dst mem))))) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| p1 := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpVarDef { |
| break |
| } |
| mem_0 := mem.Args[0] |
| if mem_0.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem_0.Aux) |
| _ = mem_0.Args[2] |
| mem_0_0 := mem_0.Args[0] |
| if mem_0_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt2 := mem_0_0.Type |
| o2 := ssa.AuxIntToInt64(mem_0_0.AuxInt) |
| p2 := mem_0_0.Args[0] |
| d1 := mem_0.Args[1] |
| mem_0_2 := mem_0.Args[2] |
| if mem_0_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem_0_2.Aux) |
| _ = mem_0_2.Args[2] |
| mem_0_2_0 := mem_0_2.Args[0] |
| if mem_0_2_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt3 := mem_0_2_0.Type |
| o3 := ssa.AuxIntToInt64(mem_0_2_0.AuxInt) |
| p3 := mem_0_2_0.Args[0] |
| d2 := mem_0_2.Args[1] |
| mem_0_2_2 := mem_0_2.Args[2] |
| if mem_0_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(mem_0_2_2.Aux) |
| _ = mem_0_2_2.Args[2] |
| mem_0_2_2_0 := mem_0_2_2.Args[0] |
| if mem_0_2_2_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt4 := mem_0_2_2_0.Type |
| o4 := ssa.AuxIntToInt64(mem_0_2_2_0.AuxInt) |
| p4 := mem_0_2_2_0.Args[0] |
| d3 := mem_0_2_2.Args[1] |
| mem_0_2_2_2 := mem_0_2_2.Args[2] |
| if mem_0_2_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t5 := ssa.AuxToType(mem_0_2_2_2.Aux) |
| _ = mem_0_2_2_2.Args[2] |
| mem_0_2_2_2_0 := mem_0_2_2_2.Args[0] |
| if mem_0_2_2_2_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| tt5 := mem_0_2_2_2_0.Type |
| o5 := ssa.AuxIntToInt64(mem_0_2_2_2_0.AuxInt) |
| p5 := mem_0_2_2_2_0.Args[0] |
| d4 := mem_0_2_2_2.Args[1] |
| mem_0_2_2_2_2 := mem_0_2_2_2.Args[2] |
| if mem_0_2_2_2_2.Op != ssaop.OpZero || ssa.AuxIntToInt64(mem_0_2_2_2_2.AuxInt) != n { |
| break |
| } |
| t6 := ssa.AuxToType(mem_0_2_2_2_2.Aux) |
| p6 := mem_0_2_2_2_2.Args[0] |
| if !(ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && ssa.IsSamePtr(p5, p6) && t2.Alignment() <= t1.Alignment() && t3.Alignment() <= t1.Alignment() && t4.Alignment() <= t1.Alignment() && t5.Alignment() <= t1.Alignment() && t6.Alignment() <= t1.Alignment() && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2+t2.Size() && n >= o3+t3.Size() && n >= o4+t4.Size() && n >= o5+t5.Size()) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t2) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt2) |
| v0.AuxInt = ssa.Int64ToAuxInt(o2) |
| v0.AddArg(dst) |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v1.Aux = ssa.TypeToAux(t3) |
| v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt3) |
| v2.AuxInt = ssa.Int64ToAuxInt(o3) |
| v2.AddArg(dst) |
| v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v3.Aux = ssa.TypeToAux(t4) |
| v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt4) |
| v4.AuxInt = ssa.Int64ToAuxInt(o4) |
| v4.AddArg(dst) |
| v5 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v5.Aux = ssa.TypeToAux(t5) |
| v6 := b.NewValue0(v.Pos, ssaop.OpOffPtr, tt5) |
| v6.AuxInt = ssa.Int64ToAuxInt(o5) |
| v6.AddArg(dst) |
| v7 := b.NewValue0(v.Pos, ssaop.OpZero, types.TypeMem) |
| v7.AuxInt = ssa.Int64ToAuxInt(n) |
| v7.Aux = ssa.TypeToAux(t1) |
| v7.AddArg2(dst, mem) |
| v5.AddArg3(v6, d4, v7) |
| v3.AddArg3(v4, d3, v5) |
| v1.AddArg3(v2, d2, v3) |
| v.AddArg3(v0, d1, v1) |
| return true |
| } |
| // match: (Move {t1} [s] dst tmp1 midmem:(Move {t2} [s] tmp2 src _)) |
| // cond: t1.Compare(t2) == types.CMPeq && ssa.IsSamePtr(tmp1, tmp2) && isStackPtr(src) && !ssa.IsVolatile(src) && ssa.Disjoint1(src, s, tmp2, s) && (ssa.Disjoint1(src, s, dst, s) || ssa.IsInlinableMemmove(dst, src, s, config)) |
| // result: (Move {t1} [s] dst src midmem) |
| for { |
| s := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| tmp1 := v_1 |
| midmem := v_2 |
| if midmem.Op != ssaop.OpMove || ssa.AuxIntToInt64(midmem.AuxInt) != s { |
| break |
| } |
| t2 := ssa.AuxToType(midmem.Aux) |
| src := midmem.Args[1] |
| tmp2 := midmem.Args[0] |
| if !(t1.Compare(t2) == types.CMPeq && ssa.IsSamePtr(tmp1, tmp2) && isStackPtr(src) && !ssa.IsVolatile(src) && ssa.Disjoint1(src, s, tmp2, s) && (ssa.Disjoint1(src, s, dst, s) || ssa.IsInlinableMemmove(dst, src, s, config))) { |
| break |
| } |
| v.Reset(ssaop.OpMove) |
| v.AuxInt = ssa.Int64ToAuxInt(s) |
| v.Aux = ssa.TypeToAux(t1) |
| v.AddArg3(dst, src, midmem) |
| return true |
| } |
| // match: (Move {t1} [s] dst tmp1 midmem:(VarDef (Move {t2} [s] tmp2 src _))) |
| // cond: t1.Compare(t2) == types.CMPeq && ssa.IsSamePtr(tmp1, tmp2) && isStackPtr(src) && !ssa.IsVolatile(src) && ssa.Disjoint1(src, s, tmp2, s) && (ssa.Disjoint1(src, s, dst, s) || ssa.IsInlinableMemmove(dst, src, s, config)) |
| // result: (Move {t1} [s] dst src midmem) |
| for { |
| s := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| tmp1 := v_1 |
| midmem := v_2 |
| if midmem.Op != ssaop.OpVarDef { |
| break |
| } |
| midmem_0 := midmem.Args[0] |
| if midmem_0.Op != ssaop.OpMove || ssa.AuxIntToInt64(midmem_0.AuxInt) != s { |
| break |
| } |
| t2 := ssa.AuxToType(midmem_0.Aux) |
| src := midmem_0.Args[1] |
| tmp2 := midmem_0.Args[0] |
| if !(t1.Compare(t2) == types.CMPeq && ssa.IsSamePtr(tmp1, tmp2) && isStackPtr(src) && !ssa.IsVolatile(src) && ssa.Disjoint1(src, s, tmp2, s) && (ssa.Disjoint1(src, s, dst, s) || ssa.IsInlinableMemmove(dst, src, s, config))) { |
| break |
| } |
| v.Reset(ssaop.OpMove) |
| v.AuxInt = ssa.Int64ToAuxInt(s) |
| v.Aux = ssa.TypeToAux(t1) |
| v.AddArg3(dst, src, midmem) |
| return true |
| } |
| // match: (Move dst src mem) |
| // cond: ssa.IsSamePtr(dst, src) |
| // result: mem |
| for { |
| dst := v_0 |
| src := v_1 |
| mem := v_2 |
| if !(ssa.IsSamePtr(dst, src)) { |
| break |
| } |
| v.CopyOf(mem) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpMul16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Mul16 (Const16 [c]) (Const16 [d])) |
| // result: (Const16 [c*d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(c * d) |
| return true |
| } |
| break |
| } |
| // match: (Mul16 (Const16 [1]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 1 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Mul16 (Const16 [-1]) x) |
| // result: (Neg16 x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != -1 { |
| continue |
| } |
| x := v_1 |
| v.Reset(ssaop.OpNeg16) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| // match: (Mul16 (Const16 <t> [c]) (Neg16 x)) |
| // result: (Mul16 x (Const16 <t> [-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpNeg16 { |
| continue |
| } |
| x := v_1.Args[0] |
| v.Reset(ssaop.OpMul16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(-c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Mul16 (Neg16 x) (Neg16 y)) |
| // result: (Mul16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeg16 { |
| continue |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpNeg16 { |
| continue |
| } |
| y := v_1.Args[0] |
| v.Reset(ssaop.OpMul16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Mul16 (Const16 <t> [c]) (Add16 <t> (Const16 <t> [d]) x)) |
| // cond: !ssa.IsPowerOfTwo(c) |
| // result: (Add16 (Const16 <t> [c*d]) (Mul16 <t> (Const16 <t> [c]) x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpAdd16 || v_1.Type != t { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst16 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_0.AuxInt) |
| x := v_1_1 |
| if !(!ssa.IsPowerOfTwo(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(c * d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpMul16, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v2.AuxInt = ssa.Int16ToAuxInt(c) |
| v1.AddArg2(v2, x) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Mul16 (Const16 [0]) _) |
| // result: (Const16 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| continue |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (Mul16 <t> x (Const16 [c])) |
| // cond: ssa.IsPowerOfTwo(uint16(c)) && v.Block.Func.Pass.Name != "opt" |
| // result: (Lsh16x64 <t> x (Const64 <typ.UInt64> [ssa.Log16u(uint16(c))])) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(uint16(c)) && v.Block.Func.Pass.Name != "opt") { |
| continue |
| } |
| v.Reset(ssaop.OpLsh16x64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(ssa.Log16u(uint16(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Mul16 <t> x (Const16 [c])) |
| // cond: ssa.IsPowerOfTwo(uint16(-c)) && v.Block.Func.Pass.Name != "opt" |
| // result: (Neg16 (Lsh16x64 <t> x (Const64 <typ.UInt64> [ssa.Log16u(uint16(-c))]))) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(uint16(-c)) && v.Block.Func.Pass.Name != "opt") { |
| continue |
| } |
| v.Reset(ssaop.OpNeg16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLsh16x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v1.AuxInt = ssa.Int64ToAuxInt(ssa.Log16u(uint16(-c))) |
| v0.AddArg2(x, v1) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (Mul16 (Mul16 i:(Const16 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) |
| // result: (Mul16 i (Mul16 <t> x z)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpMul16 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) { |
| continue |
| } |
| v.Reset(ssaop.OpMul16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul16, t) |
| v0.AddArg2(x, z) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Mul16 (Const16 <t> [c]) m:(Mul16 (Const16 <t> [d]) x)) |
| // cond: (!ssa.IsPowerOfTwo(c) || m.Uses == 1) |
| // result: (Mul16 (Const16 <t> [c*d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| m := v_1 |
| if m.Op != ssaop.OpMul16 { |
| continue |
| } |
| _ = m.Args[1] |
| m_0 := m.Args[0] |
| m_1 := m.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, m_0, m_1 = _i1+1, m_1, m_0 { |
| if m_0.Op != ssaop.OpConst16 || m_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt16(m_0.AuxInt) |
| x := m_1 |
| if !(!ssa.IsPowerOfTwo(c) || m.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpMul16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(c * d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpMul32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Mul32 (Const32 [c]) (Const32 [d])) |
| // result: (Const32 [c*d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(c * d) |
| return true |
| } |
| break |
| } |
| // match: (Mul32 (Const32 [1]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 1 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Mul32 (Const32 [-1]) x) |
| // result: (Neg32 x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != -1 { |
| continue |
| } |
| x := v_1 |
| v.Reset(ssaop.OpNeg32) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| // match: (Mul32 (Const32 <t> [c]) (Neg32 x)) |
| // result: (Mul32 x (Const32 <t> [-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpNeg32 { |
| continue |
| } |
| x := v_1.Args[0] |
| v.Reset(ssaop.OpMul32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(-c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Mul32 (Neg32 x) (Neg32 y)) |
| // result: (Mul32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeg32 { |
| continue |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpNeg32 { |
| continue |
| } |
| y := v_1.Args[0] |
| v.Reset(ssaop.OpMul32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Mul32 (Const32 <t> [c]) (Add32 <t> (Const32 <t> [d]) x)) |
| // cond: !ssa.IsPowerOfTwo(c) |
| // result: (Add32 (Const32 <t> [c*d]) (Mul32 <t> (Const32 <t> [c]) x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpAdd32 || v_1.Type != t { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst32 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_0.AuxInt) |
| x := v_1_1 |
| if !(!ssa.IsPowerOfTwo(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(c * d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpMul32, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v2.AuxInt = ssa.Int32ToAuxInt(c) |
| v1.AddArg2(v2, x) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Mul32 (Const32 [0]) _) |
| // result: (Const32 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| continue |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (Mul32 <t> x (Const32 [c])) |
| // cond: ssa.IsPowerOfTwo(uint32(c)) && v.Block.Func.Pass.Name != "opt" |
| // result: (Lsh32x64 <t> x (Const64 <typ.UInt64> [ssa.Log32u(uint32(c))])) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(uint32(c)) && v.Block.Func.Pass.Name != "opt") { |
| continue |
| } |
| v.Reset(ssaop.OpLsh32x64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(ssa.Log32u(uint32(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Mul32 <t> x (Const32 [c])) |
| // cond: ssa.IsPowerOfTwo(uint32(-c)) && v.Block.Func.Pass.Name != "opt" |
| // result: (Neg32 (Lsh32x64 <t> x (Const64 <typ.UInt64> [ssa.Log32u(uint32(-c))]))) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(uint32(-c)) && v.Block.Func.Pass.Name != "opt") { |
| continue |
| } |
| v.Reset(ssaop.OpNeg32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLsh32x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v1.AuxInt = ssa.Int64ToAuxInt(ssa.Log32u(uint32(-c))) |
| v0.AddArg2(x, v1) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (Mul32 (Mul32 i:(Const32 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) |
| // result: (Mul32 i (Mul32 <t> x z)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpMul32 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) { |
| continue |
| } |
| v.Reset(ssaop.OpMul32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul32, t) |
| v0.AddArg2(x, z) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Mul32 (Const32 <t> [c]) m:(Mul32 (Const32 <t> [d]) x)) |
| // cond: (!ssa.IsPowerOfTwo(c) || m.Uses == 1) |
| // result: (Mul32 (Const32 <t> [c*d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| m := v_1 |
| if m.Op != ssaop.OpMul32 { |
| continue |
| } |
| _ = m.Args[1] |
| m_0 := m.Args[0] |
| m_1 := m.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, m_0, m_1 = _i1+1, m_1, m_0 { |
| if m_0.Op != ssaop.OpConst32 || m_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt32(m_0.AuxInt) |
| x := m_1 |
| if !(!ssa.IsPowerOfTwo(c) || m.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpMul32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(c * d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpMul32F(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (Mul32F (Const32F [c]) (Const32F [d])) |
| // cond: c*d == c*d |
| // result: (Const32F [c*d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32F { |
| continue |
| } |
| c := ssa.AuxIntToFloat32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32F { |
| continue |
| } |
| d := ssa.AuxIntToFloat32(v_1.AuxInt) |
| if !(c*d == c*d) { |
| continue |
| } |
| v.Reset(ssaop.OpConst32F) |
| v.AuxInt = ssa.Float32ToAuxInt(c * d) |
| return true |
| } |
| break |
| } |
| // match: (Mul32F x (Const32F [1])) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32F || ssa.AuxIntToFloat32(v_1.AuxInt) != 1 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Mul32F x (Const32F [-1])) |
| // result: (Neg32F x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32F || ssa.AuxIntToFloat32(v_1.AuxInt) != -1 { |
| continue |
| } |
| v.Reset(ssaop.OpNeg32F) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| // match: (Mul32F x (Const32F [2])) |
| // result: (Add32F x x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32F || ssa.AuxIntToFloat32(v_1.AuxInt) != 2 { |
| continue |
| } |
| v.Reset(ssaop.OpAdd32F) |
| v.AddArg2(x, x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpMul32uhilo(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Mul32uhilo (Const32 [c]) (Const32 [d])) |
| // result: (MakeTuple (Const32 <typ.UInt32> [bitsMulU32(c, d).hi]) (Const32 <typ.UInt32> [bitsMulU32(c,d).lo])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpMakeTuple) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v0.AuxInt = ssa.Int32ToAuxInt(bitsMulU32(c, d).hi) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v1.AuxInt = ssa.Int32ToAuxInt(bitsMulU32(c, d).lo) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpMul32uover(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Mul32uover (Const32 [c]) (Const32 [d])) |
| // result: (MakeTuple (Const32 <typ.UInt32> [bitsMulU32(c, d).lo]) (ConstBool <typ.Bool> [bitsMulU32(c,d).hi != 0])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpMakeTuple) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v0.AuxInt = ssa.Int32ToAuxInt(bitsMulU32(c, d).lo) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConstBool, typ.Bool) |
| v1.AuxInt = ssa.BoolToAuxInt(bitsMulU32(c, d).hi != 0) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (Mul32uover <t> (Const32 [1]) x) |
| // result: (MakeTuple x (ConstBool <t.FieldType(1)> [false])) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 1 { |
| continue |
| } |
| x := v_1 |
| v.Reset(ssaop.OpMakeTuple) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConstBool, t.FieldType(1)) |
| v0.AuxInt = ssa.BoolToAuxInt(false) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Mul32uover <t> (Const32 [0]) x) |
| // result: (MakeTuple (Const32 <t.FieldType(0)> [0]) (ConstBool <t.FieldType(1)> [false])) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| continue |
| } |
| v.Reset(ssaop.OpMakeTuple) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t.FieldType(0)) |
| v0.AuxInt = ssa.Int32ToAuxInt(0) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConstBool, t.FieldType(1)) |
| v1.AuxInt = ssa.BoolToAuxInt(false) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| 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 (Const64 [c]) (Const64 [d])) |
| // result: (Const64 [c*d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(c * d) |
| return true |
| } |
| break |
| } |
| // match: (Mul64 (Const64 [1]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 1 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Mul64 (Const64 [-1]) x) |
| // result: (Neg64 x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != -1 { |
| continue |
| } |
| x := v_1 |
| v.Reset(ssaop.OpNeg64) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| // match: (Mul64 (Const64 <t> [c]) (Neg64 x)) |
| // result: (Mul64 x (Const64 <t> [-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpNeg64 { |
| continue |
| } |
| x := v_1.Args[0] |
| v.Reset(ssaop.OpMul64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(-c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Mul64 (Neg64 x) (Neg64 y)) |
| // result: (Mul64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeg64 { |
| continue |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpNeg64 { |
| continue |
| } |
| y := v_1.Args[0] |
| v.Reset(ssaop.OpMul64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Mul64 (Const64 <t> [c]) (Add64 <t> (Const64 <t> [d]) x)) |
| // cond: !ssa.IsPowerOfTwo(c) |
| // result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpAdd64 || v_1.Type != t { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst64 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_0.AuxInt) |
| x := v_1_1 |
| if !(!ssa.IsPowerOfTwo(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c * d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpMul64, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v2.AuxInt = ssa.Int64ToAuxInt(c) |
| v1.AddArg2(v2, x) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Mul64 (Const64 [0]) _) |
| // result: (Const64 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| continue |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (Mul64 <t> x (Const64 [c])) |
| // cond: ssa.IsPowerOfTwo(uint64(c)) && v.Block.Func.Pass.Name != "opt" |
| // result: (Lsh64x64 <t> x (Const64 <typ.UInt64> [ssa.Log64u(uint64(c))])) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(uint64(c)) && v.Block.Func.Pass.Name != "opt") { |
| continue |
| } |
| v.Reset(ssaop.OpLsh64x64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(ssa.Log64u(uint64(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Mul64 <t> x (Const64 [c])) |
| // cond: ssa.IsPowerOfTwo(uint64(-c)) && v.Block.Func.Pass.Name != "opt" |
| // result: (Neg64 (Lsh64x64 <t> x (Const64 <typ.UInt64> [ssa.Log64u(uint64(-c))]))) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(uint64(-c)) && v.Block.Func.Pass.Name != "opt") { |
| continue |
| } |
| v.Reset(ssaop.OpNeg64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v1.AuxInt = ssa.Int64ToAuxInt(ssa.Log64u(uint64(-c))) |
| v0.AddArg2(x, v1) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (Mul64 (Mul64 i:(Const64 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) |
| // result: (Mul64 i (Mul64 <t> x z)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpMul64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) { |
| continue |
| } |
| v.Reset(ssaop.OpMul64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul64, t) |
| v0.AddArg2(x, z) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Mul64 (Const64 <t> [c]) m:(Mul64 (Const64 <t> [d]) x)) |
| // cond: (!ssa.IsPowerOfTwo(c) || m.Uses == 1) |
| // result: (Mul64 (Const64 <t> [c*d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| m := v_1 |
| if m.Op != ssaop.OpMul64 { |
| continue |
| } |
| _ = m.Args[1] |
| m_0 := m.Args[0] |
| m_1 := m.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, m_0, m_1 = _i1+1, m_1, m_0 { |
| if m_0.Op != ssaop.OpConst64 || m_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt64(m_0.AuxInt) |
| x := m_1 |
| if !(!ssa.IsPowerOfTwo(c) || m.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpMul64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c * d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpMul64F(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (Mul64F (Const64F [c]) (Const64F [d])) |
| // cond: c*d == c*d |
| // result: (Const64F [c*d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64F { |
| continue |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64F { |
| continue |
| } |
| d := ssa.AuxIntToFloat64(v_1.AuxInt) |
| if !(c*d == c*d) { |
| continue |
| } |
| v.Reset(ssaop.OpConst64F) |
| v.AuxInt = ssa.Float64ToAuxInt(c * d) |
| return true |
| } |
| break |
| } |
| // match: (Mul64F x (Const64F [1])) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64F || ssa.AuxIntToFloat64(v_1.AuxInt) != 1 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Mul64F x (Const64F [-1])) |
| // result: (Neg64F x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64F || ssa.AuxIntToFloat64(v_1.AuxInt) != -1 { |
| continue |
| } |
| v.Reset(ssaop.OpNeg64F) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| // match: (Mul64F x (Const64F [2])) |
| // result: (Add64F x x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64F || ssa.AuxIntToFloat64(v_1.AuxInt) != 2 { |
| continue |
| } |
| v.Reset(ssaop.OpAdd64F) |
| v.AddArg2(x, x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| 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 (Const64 [c]) (Const64 [d])) |
| // result: (MakeTuple (Const64 <typ.UInt64> [bitsMulU64(c, d).hi]) (Const64 <typ.UInt64> [bitsMulU64(c,d).lo])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpMakeTuple) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(bitsMulU64(c, d).hi) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v1.AuxInt = ssa.Int64ToAuxInt(bitsMulU64(c, d).lo) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (Mul64uhilo x (Const64 [c])) |
| // cond: c > 0 && ssa.IsPowerOfTwo(uint64(c)) |
| // result: (MakeTuple (Rsh64Ux64 <typ.UInt64> x (Const64 <typ.UInt64> [64 - ssa.Log64u(uint64(c))])) (Lsh64x64 <typ.UInt64> x (Const64 <typ.UInt64> [ssa.Log64u(uint64(c))]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c > 0 && ssa.IsPowerOfTwo(uint64(c))) { |
| continue |
| } |
| v.Reset(ssaop.OpMakeTuple) |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh64Ux64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v1.AuxInt = ssa.Int64ToAuxInt(64 - ssa.Log64u(uint64(c))) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, typ.UInt64) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v3.AuxInt = ssa.Int64ToAuxInt(ssa.Log64u(uint64(c))) |
| v2.AddArg2(x, v3) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpMul64uover(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Mul64uover (Const64 [c]) (Const64 [d])) |
| // result: (MakeTuple (Const64 <typ.UInt64> [bitsMulU64(c, d).lo]) (ConstBool <typ.Bool> [bitsMulU64(c,d).hi != 0])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpMakeTuple) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(bitsMulU64(c, d).lo) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConstBool, typ.Bool) |
| v1.AuxInt = ssa.BoolToAuxInt(bitsMulU64(c, d).hi != 0) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (Mul64uover <t> (Const64 [1]) x) |
| // result: (MakeTuple x (ConstBool <t.FieldType(1)> [false])) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 1 { |
| continue |
| } |
| x := v_1 |
| v.Reset(ssaop.OpMakeTuple) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConstBool, t.FieldType(1)) |
| v0.AuxInt = ssa.BoolToAuxInt(false) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Mul64uover <t> (Const64 [0]) x) |
| // result: (MakeTuple (Const64 <t.FieldType(0)> [0]) (ConstBool <t.FieldType(1)> [false])) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| continue |
| } |
| v.Reset(ssaop.OpMakeTuple) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t.FieldType(0)) |
| v0.AuxInt = ssa.Int64ToAuxInt(0) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConstBool, t.FieldType(1)) |
| v1.AuxInt = ssa.BoolToAuxInt(false) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpMul8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Mul8 (Const8 [c]) (Const8 [d])) |
| // result: (Const8 [c*d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(c * d) |
| return true |
| } |
| break |
| } |
| // match: (Mul8 (Const8 [1]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 1 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Mul8 (Const8 [-1]) x) |
| // result: (Neg8 x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != -1 { |
| continue |
| } |
| x := v_1 |
| v.Reset(ssaop.OpNeg8) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| // match: (Mul8 (Const8 <t> [c]) (Neg8 x)) |
| // result: (Mul8 x (Const8 <t> [-c])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpNeg8 { |
| continue |
| } |
| x := v_1.Args[0] |
| v.Reset(ssaop.OpMul8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(-c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Mul8 (Neg8 x) (Neg8 y)) |
| // result: (Mul8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeg8 { |
| continue |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpNeg8 { |
| continue |
| } |
| y := v_1.Args[0] |
| v.Reset(ssaop.OpMul8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Mul8 (Const8 <t> [c]) (Add8 <t> (Const8 <t> [d]) x)) |
| // cond: !ssa.IsPowerOfTwo(c) |
| // result: (Add8 (Const8 <t> [c*d]) (Mul8 <t> (Const8 <t> [c]) x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpAdd8 || v_1.Type != t { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst8 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_0.AuxInt) |
| x := v_1_1 |
| if !(!ssa.IsPowerOfTwo(c)) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(c * d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpMul8, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v2.AuxInt = ssa.Int8ToAuxInt(c) |
| v1.AddArg2(v2, x) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Mul8 (Const8 [0]) _) |
| // result: (Const8 [0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| continue |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| break |
| } |
| // match: (Mul8 <t> x (Const8 [c])) |
| // cond: ssa.IsPowerOfTwo(uint8(c)) && v.Block.Func.Pass.Name != "opt" |
| // result: (Lsh8x64 <t> x (Const64 <typ.UInt64> [ssa.Log8u(uint8(c))])) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(uint8(c)) && v.Block.Func.Pass.Name != "opt") { |
| continue |
| } |
| v.Reset(ssaop.OpLsh8x64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(ssa.Log8u(uint8(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Mul8 <t> x (Const8 [c])) |
| // cond: ssa.IsPowerOfTwo(uint8(-c)) && v.Block.Func.Pass.Name != "opt" |
| // result: (Neg8 (Lsh8x64 <t> x (Const64 <typ.UInt64> [ssa.Log8u(uint8(-c))]))) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(uint8(-c)) && v.Block.Func.Pass.Name != "opt") { |
| continue |
| } |
| v.Reset(ssaop.OpNeg8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLsh8x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v1.AuxInt = ssa.Int64ToAuxInt(ssa.Log8u(uint8(-c))) |
| v0.AddArg2(x, v1) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (Mul8 (Mul8 i:(Const8 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) |
| // result: (Mul8 i (Mul8 <t> x z)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpMul8 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) { |
| continue |
| } |
| v.Reset(ssaop.OpMul8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul8, t) |
| v0.AddArg2(x, z) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Mul8 (Const8 <t> [c]) m:(Mul8 (Const8 <t> [d]) x)) |
| // cond: (!ssa.IsPowerOfTwo(c) || m.Uses == 1) |
| // result: (Mul8 (Const8 <t> [c*d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| m := v_1 |
| if m.Op != ssaop.OpMul8 { |
| continue |
| } |
| _ = m.Args[1] |
| m_0 := m.Args[0] |
| m_1 := m.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, m_0, m_1 = _i1+1, m_1, m_0 { |
| if m_0.Op != ssaop.OpConst8 || m_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt8(m_0.AuxInt) |
| x := m_1 |
| if !(!ssa.IsPowerOfTwo(c) || m.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpMul8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(c * d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpNeg16(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Neg16 (Const16 [c])) |
| // result: (Const16 [-c]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(-c) |
| return true |
| } |
| // match: (Neg16 (Mul16 x (Const16 <t> [c]))) |
| // result: (Mul16 x (Const16 <t> [-c])) |
| for { |
| if v_0.Op != ssaop.OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0_1.Type |
| c := ssa.AuxIntToInt16(v_0_1.AuxInt) |
| v.Reset(ssaop.OpMul16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(-c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Neg16 (Mul16 x (Neg16 y))) |
| // result: (Mul16 x y) |
| for { |
| if v_0.Op != ssaop.OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpNeg16 { |
| continue |
| } |
| y := v_0_1.Args[0] |
| v.Reset(ssaop.OpMul16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Neg16 (Sub16 x y)) |
| // result: (Sub16 y x) |
| for { |
| if v_0.Op != ssaop.OpSub16 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpSub16) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Neg16 (Neg16 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpNeg16 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Neg16 <t> (Com16 x)) |
| // result: (Add16 (Const16 <t> [1]) x) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpCom16 { |
| break |
| } |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpAdd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(1) |
| v.AddArg2(v0, x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpNeg32(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Neg32 (Const32 [c])) |
| // result: (Const32 [-c]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(-c) |
| return true |
| } |
| // match: (Neg32 (Mul32 x (Const32 <t> [c]))) |
| // result: (Mul32 x (Const32 <t> [-c])) |
| for { |
| if v_0.Op != ssaop.OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0_1.Type |
| c := ssa.AuxIntToInt32(v_0_1.AuxInt) |
| v.Reset(ssaop.OpMul32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(-c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Neg32 (Mul32 x (Neg32 y))) |
| // result: (Mul32 x y) |
| for { |
| if v_0.Op != ssaop.OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpNeg32 { |
| continue |
| } |
| y := v_0_1.Args[0] |
| v.Reset(ssaop.OpMul32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Neg32 (Sub32 x y)) |
| // result: (Sub32 y x) |
| for { |
| if v_0.Op != ssaop.OpSub32 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpSub32) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Neg32 (Neg32 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpNeg32 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Neg32 <t> (Com32 x)) |
| // result: (Add32 (Const32 <t> [1]) x) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpCom32 { |
| break |
| } |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpAdd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(1) |
| v.AddArg2(v0, x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpNeg32F(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Neg32F (Const32F [c])) |
| // cond: c != 0 |
| // result: (Const32F [-c]) |
| for { |
| if v_0.Op != ssaop.OpConst32F { |
| break |
| } |
| c := ssa.AuxIntToFloat32(v_0.AuxInt) |
| if !(c != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst32F) |
| v.AuxInt = ssa.Float32ToAuxInt(-c) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpNeg64(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Neg64 (Const64 [c])) |
| // result: (Const64 [-c]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(-c) |
| return true |
| } |
| // match: (Neg64 (Mul64 x (Const64 <t> [c]))) |
| // result: (Mul64 x (Const64 <t> [-c])) |
| for { |
| if v_0.Op != ssaop.OpMul64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| v.Reset(ssaop.OpMul64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(-c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Neg64 (Mul64 x (Neg64 y))) |
| // result: (Mul64 x y) |
| for { |
| if v_0.Op != ssaop.OpMul64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpNeg64 { |
| continue |
| } |
| y := v_0_1.Args[0] |
| v.Reset(ssaop.OpMul64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Neg64 (Sub64 x y)) |
| // result: (Sub64 y x) |
| for { |
| if v_0.Op != ssaop.OpSub64 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpSub64) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Neg64 (Neg64 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpNeg64 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Neg64 <t> (Com64 x)) |
| // result: (Add64 (Const64 <t> [1]) x) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpCom64 { |
| break |
| } |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpAdd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(1) |
| v.AddArg2(v0, x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpNeg64F(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Neg64F (Const64F [c])) |
| // cond: c != 0 |
| // result: (Const64F [-c]) |
| for { |
| if v_0.Op != ssaop.OpConst64F { |
| break |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| if !(c != 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst64F) |
| v.AuxInt = ssa.Float64ToAuxInt(-c) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpNeg8(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Neg8 (Const8 [c])) |
| // result: (Const8 [-c]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(-c) |
| return true |
| } |
| // match: (Neg8 (Mul8 x (Const8 <t> [c]))) |
| // result: (Mul8 x (Const8 <t> [-c])) |
| for { |
| if v_0.Op != ssaop.OpMul8 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0_1.Type |
| c := ssa.AuxIntToInt8(v_0_1.AuxInt) |
| v.Reset(ssaop.OpMul8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(-c) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Neg8 (Mul8 x (Neg8 y))) |
| // result: (Mul8 x y) |
| for { |
| if v_0.Op != ssaop.OpMul8 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpNeg8 { |
| continue |
| } |
| y := v_0_1.Args[0] |
| v.Reset(ssaop.OpMul8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Neg8 (Sub8 x y)) |
| // result: (Sub8 y x) |
| for { |
| if v_0.Op != ssaop.OpSub8 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpSub8) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Neg8 (Neg8 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpNeg8 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Neg8 <t> (Com8 x)) |
| // result: (Add8 (Const8 <t> [1]) x) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpCom8 { |
| break |
| } |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpAdd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(1) |
| v.AddArg2(v0, x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpNeq16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Neq16 x x) |
| // result: (ConstBool [false]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Neq16 (Const16 <t> [c]) o:(Add16 (Const16 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Neq16 (Const16 <t> [c-d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpAdd16 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(o_0.AuxInt) |
| x := o_1 |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(c - d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Neq16 (Const16 <t> [c]) o:(Sub16 x (Const16 [d]))) |
| // cond: o.Uses == 1 |
| // result: (Neq16 (Const16 <t> [c+d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = o.Args[1] |
| x := o.Args[0] |
| o_1 := o.Args[1] |
| if o_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(o_1.AuxInt) |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(c + d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Neq16 (Const16 <t> [c]) o:(Sub16 (Const16 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Neq16 (Const16 <t> [d-c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpSub16 { |
| continue |
| } |
| x := o.Args[1] |
| o_0 := o.Args[0] |
| if o_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(o_0.AuxInt) |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(d - c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Neq16 (Const16 <t> [c]) o:(Xor16 (Const16 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Neq16 (Const16 <t> [d^c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpXor16 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(o_0.AuxInt) |
| x := o_1 |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(d ^ c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Neq16 (Const16 <t> [c]) o:(Com16 x)) |
| // cond: o.Uses == 1 |
| // result: (Neq16 (Const16 <t> [^c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpCom16 { |
| continue |
| } |
| x := o.Args[0] |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(^c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Neq16 (Const16 <t> [c]) o:(Neg16 x)) |
| // cond: o.Uses == 1 |
| // result: (Neq16 (Const16 <t> [-c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpNeg16 { |
| continue |
| } |
| x := o.Args[0] |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(-c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Neq16 (Const16 <t> [c]) o:(Mul16 (Const16 [d]) x)) |
| // cond: uint16(d)%2 == 1 && o.Uses == 1 |
| // result: (Neq16 (Const16 <t> [int16(uint16(c) * uint16(modularMultiplicativeInverse(uint64(d))))]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpMul16 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(o_0.AuxInt) |
| x := o_1 |
| if !(uint16(d)%2 == 1 && o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(int16(uint16(c) * uint16(modularMultiplicativeInverse(uint64(d))))) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Neq16 (Const16 [c]) (Const16 [d])) |
| // result: (ConstBool [c != d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c != d) |
| return true |
| } |
| break |
| } |
| // match: (Neq16 s:(Sub16 x y) (Const16 [0])) |
| // cond: s.Uses == 1 |
| // result: (Neq16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| s := v_0 |
| if s.Op != ssaop.OpSub16 { |
| continue |
| } |
| y := s.Args[1] |
| x := s.Args[0] |
| if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 0 || !(s.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Neq16 (And16 <t> x (Const16 <t> [y])) (Const16 <t> [y])) |
| // cond: ssa.OneBit(y) |
| // result: (Eq16 (And16 <t> x (Const16 <t> [y])) (Const16 <t> [0])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAnd16 { |
| continue |
| } |
| t := v_0.Type |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst16 || v_0_1.Type != t { |
| continue |
| } |
| y := ssa.AuxIntToInt16(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst16 || v_1.Type != t || ssa.AuxIntToInt16(v_1.AuxInt) != y || !(ssa.OneBit(y)) { |
| continue |
| } |
| v.Reset(ssaop.OpEq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd16, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v1.AuxInt = ssa.Int16ToAuxInt(y) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v2.AuxInt = ssa.Int16ToAuxInt(0) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Neq16 (ZeroExt8to16 (CvtBoolToUint8 x)) (Const16 [0])) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to16 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| x := v_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 0 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Neq16 (ZeroExt8to16 (CvtBoolToUint8 x)) (Const16 [1])) |
| // result: (Not x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to16 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| x := v_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 1 { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpNeq32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Neq32 x x) |
| // result: (ConstBool [false]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Neq32 (Const32 <t> [c]) o:(Add32 (Const32 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Neq32 (Const32 <t> [c-d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpAdd32 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(o_0.AuxInt) |
| x := o_1 |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(c - d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Neq32 (Const32 <t> [c]) o:(Sub32 x (Const32 [d]))) |
| // cond: o.Uses == 1 |
| // result: (Neq32 (Const32 <t> [c+d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = o.Args[1] |
| x := o.Args[0] |
| o_1 := o.Args[1] |
| if o_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(o_1.AuxInt) |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(c + d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Neq32 (Const32 <t> [c]) o:(Sub32 (Const32 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Neq32 (Const32 <t> [d-c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpSub32 { |
| continue |
| } |
| x := o.Args[1] |
| o_0 := o.Args[0] |
| if o_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(o_0.AuxInt) |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(d - c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Neq32 (Const32 <t> [c]) o:(Xor32 (Const32 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Neq32 (Const32 <t> [d^c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpXor32 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(o_0.AuxInt) |
| x := o_1 |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(d ^ c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Neq32 (Const32 <t> [c]) o:(Com32 x)) |
| // cond: o.Uses == 1 |
| // result: (Neq32 (Const32 <t> [^c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpCom32 { |
| continue |
| } |
| x := o.Args[0] |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(^c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Neq32 (Const32 <t> [c]) o:(Neg32 x)) |
| // cond: o.Uses == 1 |
| // result: (Neq32 (Const32 <t> [-c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpNeg32 { |
| continue |
| } |
| x := o.Args[0] |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(-c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Neq32 (Const32 <t> [c]) o:(Mul32 (Const32 [d]) x)) |
| // cond: uint32(d)%2 == 1 && o.Uses == 1 |
| // result: (Neq32 (Const32 <t> [int32(uint32(c) * uint32(modularMultiplicativeInverse(uint64(d))))]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpMul32 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(o_0.AuxInt) |
| x := o_1 |
| if !(uint32(d)%2 == 1 && o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(int32(uint32(c) * uint32(modularMultiplicativeInverse(uint64(d))))) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Neq32 (Const32 [c]) (Const32 [d])) |
| // result: (ConstBool [c != d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c != d) |
| return true |
| } |
| break |
| } |
| // match: (Neq32 s:(Sub32 x y) (Const32 [0])) |
| // cond: s.Uses == 1 |
| // result: (Neq32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| s := v_0 |
| if s.Op != ssaop.OpSub32 { |
| continue |
| } |
| y := s.Args[1] |
| x := s.Args[0] |
| if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 0 || !(s.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Neq32 (And32 <t> x (Const32 <t> [y])) (Const32 <t> [y])) |
| // cond: ssa.OneBit(y) |
| // result: (Eq32 (And32 <t> x (Const32 <t> [y])) (Const32 <t> [0])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAnd32 { |
| continue |
| } |
| t := v_0.Type |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst32 || v_0_1.Type != t { |
| continue |
| } |
| y := ssa.AuxIntToInt32(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst32 || v_1.Type != t || ssa.AuxIntToInt32(v_1.AuxInt) != y || !(ssa.OneBit(y)) { |
| continue |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd32, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v1.AuxInt = ssa.Int32ToAuxInt(y) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v2.AuxInt = ssa.Int32ToAuxInt(0) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Neq32 (ZeroExt8to32 (CvtBoolToUint8 x)) (Const32 [0])) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to32 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| x := v_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 0 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Neq32 (ZeroExt8to32 (CvtBoolToUint8 x)) (Const32 [1])) |
| // result: (Not x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to32 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| x := v_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 1 { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpNeq32F(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (Neq32F (Const32F [c]) (Const32F [d])) |
| // result: (ConstBool [c != d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32F { |
| continue |
| } |
| c := ssa.AuxIntToFloat32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32F { |
| continue |
| } |
| d := ssa.AuxIntToFloat32(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c != d) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpNeq64(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Neq64 x x) |
| // result: (ConstBool [false]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Neq64 (Const64 <t> [c]) o:(Add64 (Const64 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Neq64 (Const64 <t> [c-d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpAdd64 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(o_0.AuxInt) |
| x := o_1 |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c - d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Neq64 (Const64 <t> [c]) o:(Sub64 x (Const64 [d]))) |
| // cond: o.Uses == 1 |
| // result: (Neq64 (Const64 <t> [c+d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = o.Args[1] |
| x := o.Args[0] |
| o_1 := o.Args[1] |
| if o_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(o_1.AuxInt) |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c + d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Neq64 (Const64 <t> [c]) o:(Sub64 (Const64 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Neq64 (Const64 <t> [d-c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpSub64 { |
| continue |
| } |
| x := o.Args[1] |
| o_0 := o.Args[0] |
| if o_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(o_0.AuxInt) |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(d - c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Neq64 (Const64 <t> [c]) o:(Xor64 (Const64 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Neq64 (Const64 <t> [d^c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpXor64 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(o_0.AuxInt) |
| x := o_1 |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(d ^ c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Neq64 (Const64 <t> [c]) o:(Com64 x)) |
| // cond: o.Uses == 1 |
| // result: (Neq64 (Const64 <t> [^c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpCom64 { |
| continue |
| } |
| x := o.Args[0] |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(^c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Neq64 (Const64 <t> [c]) o:(Neg64 x)) |
| // cond: o.Uses == 1 |
| // result: (Neq64 (Const64 <t> [-c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpNeg64 { |
| continue |
| } |
| x := o.Args[0] |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(-c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Neq64 (Const64 <t> [c]) o:(Mul64 (Const64 [d]) x)) |
| // cond: uint64(d)%2 == 1 && o.Uses == 1 |
| // result: (Neq64 (Const64 <t> [int64(uint64(c) * modularMultiplicativeInverse(uint64(d))) ]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpMul64 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(o_0.AuxInt) |
| x := o_1 |
| if !(uint64(d)%2 == 1 && o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint64(c) * modularMultiplicativeInverse(uint64(d)))) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Neq64 (Const64 [c]) (Const64 [d])) |
| // result: (ConstBool [c != d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c != d) |
| return true |
| } |
| break |
| } |
| // match: (Neq64 s:(Sub64 x y) (Const64 [0])) |
| // cond: s.Uses == 1 |
| // result: (Neq64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| s := v_0 |
| if s.Op != ssaop.OpSub64 { |
| continue |
| } |
| y := s.Args[1] |
| x := s.Args[0] |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 || !(s.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Neq64 (And64 <t> x (Const64 <t> [y])) (Const64 <t> [y])) |
| // cond: ssa.OneBit(y) |
| // result: (Eq64 (And64 <t> x (Const64 <t> [y])) (Const64 <t> [0])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAnd64 { |
| continue |
| } |
| t := v_0.Type |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst64 || v_0_1.Type != t { |
| continue |
| } |
| y := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 || v_1.Type != t || ssa.AuxIntToInt64(v_1.AuxInt) != y || !(ssa.OneBit(y)) { |
| continue |
| } |
| v.Reset(ssaop.OpEq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v1.AuxInt = ssa.Int64ToAuxInt(y) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v2.AuxInt = ssa.Int64ToAuxInt(0) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Neq64 (ZeroExt8to64 (CvtBoolToUint8 x)) (Const64 [0])) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to64 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| x := v_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Neq64 (ZeroExt8to64 (CvtBoolToUint8 x)) (Const64 [1])) |
| // result: (Not x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to64 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| x := v_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 1 { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpNeq64F(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (Neq64F (Const64F [c]) (Const64F [d])) |
| // result: (ConstBool [c != d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64F { |
| continue |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64F { |
| continue |
| } |
| d := ssa.AuxIntToFloat64(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c != d) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpNeq8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Neq8 x x) |
| // result: (ConstBool [false]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (Neq8 (Const8 <t> [c]) o:(Add8 (Const8 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Neq8 (Const8 <t> [c-d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpAdd8 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(o_0.AuxInt) |
| x := o_1 |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(c - d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Neq8 (Const8 <t> [c]) o:(Sub8 x (Const8 [d]))) |
| // cond: o.Uses == 1 |
| // result: (Neq8 (Const8 <t> [c+d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = o.Args[1] |
| x := o.Args[0] |
| o_1 := o.Args[1] |
| if o_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(o_1.AuxInt) |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(c + d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Neq8 (Const8 <t> [c]) o:(Sub8 (Const8 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Neq8 (Const8 <t> [d-c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpSub8 { |
| continue |
| } |
| x := o.Args[1] |
| o_0 := o.Args[0] |
| if o_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(o_0.AuxInt) |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(d - c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Neq8 (Const8 <t> [c]) o:(Xor8 (Const8 [d]) x)) |
| // cond: o.Uses == 1 |
| // result: (Neq8 (Const8 <t> [d^c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpXor8 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(o_0.AuxInt) |
| x := o_1 |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(d ^ c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Neq8 (Const8 <t> [c]) o:(Com8 x)) |
| // cond: o.Uses == 1 |
| // result: (Neq8 (Const8 <t> [^c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpCom8 { |
| continue |
| } |
| x := o.Args[0] |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(^c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Neq8 (Const8 <t> [c]) o:(Neg8 x)) |
| // cond: o.Uses == 1 |
| // result: (Neq8 (Const8 <t> [-c]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpNeg8 { |
| continue |
| } |
| x := o.Args[0] |
| if !(o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(-c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| // match: (Neq8 (Const8 <t> [c]) o:(Mul8 (Const8 [d]) x)) |
| // cond: uint8( d)%2 == 1 && o.Uses == 1 |
| // result: (Neq8 (Const8 <t> [int8( uint8( c) * uint8( modularMultiplicativeInverse(uint64(d))))]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| o := v_1 |
| if o.Op != ssaop.OpMul8 { |
| continue |
| } |
| _ = o.Args[1] |
| o_0 := o.Args[0] |
| o_1 := o.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, o_0, o_1 = _i1+1, o_1, o_0 { |
| if o_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(o_0.AuxInt) |
| x := o_1 |
| if !(uint8(d)%2 == 1 && o.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(int8(uint8(c) * uint8(modularMultiplicativeInverse(uint64(d))))) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Neq8 (Const8 [c]) (Const8 [d])) |
| // result: (ConstBool [c != d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c != d) |
| return true |
| } |
| break |
| } |
| // match: (Neq8 s:(Sub8 x y) (Const8 [0])) |
| // cond: s.Uses == 1 |
| // result: (Neq8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| s := v_0 |
| if s.Op != ssaop.OpSub8 { |
| continue |
| } |
| y := s.Args[1] |
| x := s.Args[0] |
| if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 0 || !(s.Uses == 1) { |
| continue |
| } |
| v.Reset(ssaop.OpNeq8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Neq8 (And8 <t> x (Const8 <t> [y])) (Const8 <t> [y])) |
| // cond: ssa.OneBit(y) |
| // result: (Eq8 (And8 <t> x (Const8 <t> [y])) (Const8 <t> [0])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAnd8 { |
| continue |
| } |
| t := v_0.Type |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst8 || v_0_1.Type != t { |
| continue |
| } |
| y := ssa.AuxIntToInt8(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst8 || v_1.Type != t || ssa.AuxIntToInt8(v_1.AuxInt) != y || !(ssa.OneBit(y)) { |
| continue |
| } |
| v.Reset(ssaop.OpEq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd8, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v1.AuxInt = ssa.Int8ToAuxInt(y) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v2.AuxInt = ssa.Int8ToAuxInt(0) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Neq8 (CvtBoolToUint8 x) (Const8 [0])) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 0 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Neq8 (CvtBoolToUint8 x) (Const8 [1])) |
| // result: (Not x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 1 { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpNeqB(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (NeqB x x) |
| // result: (ConstBool [false]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (NeqB (ConstBool [c]) (ConstBool [d])) |
| // result: (ConstBool [c != d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConstBool { |
| continue |
| } |
| c := ssa.AuxIntToBool(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConstBool { |
| continue |
| } |
| d := ssa.AuxIntToBool(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c != d) |
| return true |
| } |
| break |
| } |
| // match: (NeqB (ConstBool [false]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != false { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (NeqB (ConstBool [true]) x) |
| // result: (Not x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != true { |
| continue |
| } |
| x := v_1 |
| v.Reset(ssaop.OpNot) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| // match: (NeqB (Not x) y) |
| // result: (EqB x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNot { |
| continue |
| } |
| x := v_0.Args[0] |
| y := v_1 |
| v.Reset(ssaop.OpEqB) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpNeqInter(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (NeqInter x y) |
| // result: (NeqPtr (ITab x) (ITab y)) |
| for { |
| x := v_0 |
| y := v_1 |
| v.Reset(ssaop.OpNeqPtr) |
| v0 := b.NewValue0(v.Pos, ssaop.OpITab, typ.Uintptr) |
| v0.AddArg(x) |
| v1 := b.NewValue0(v.Pos, ssaop.OpITab, typ.Uintptr) |
| v1.AddArg(y) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| } |
| func rewriteValue_OpNeqPtr(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (NeqPtr x x) |
| // result: (ConstBool [false]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(false) |
| return true |
| } |
| // match: (NeqPtr (Addr {x} _) (Addr {y} _)) |
| // result: (ConstBool [x != y]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAddr { |
| continue |
| } |
| x := ssa.AuxToSym(v_0.Aux) |
| if v_1.Op != ssaop.OpAddr { |
| continue |
| } |
| y := ssa.AuxToSym(v_1.Aux) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(x != y) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (Addr {x} _) (OffPtr [o] (Addr {y} _))) |
| // result: (ConstBool [x != y || o != 0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAddr { |
| continue |
| } |
| x := ssa.AuxToSym(v_0.Aux) |
| if v_1.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o := ssa.AuxIntToInt64(v_1.AuxInt) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAddr { |
| continue |
| } |
| y := ssa.AuxToSym(v_1_0.Aux) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(x != y || o != 0) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (OffPtr [o1] (Addr {x} _)) (OffPtr [o2] (Addr {y} _))) |
| // result: (ConstBool [x != y || o1 != o2]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o1 := ssa.AuxIntToInt64(v_0.AuxInt) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpAddr { |
| continue |
| } |
| x := ssa.AuxToSym(v_0_0.Aux) |
| if v_1.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o2 := ssa.AuxIntToInt64(v_1.AuxInt) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAddr { |
| continue |
| } |
| y := ssa.AuxToSym(v_1_0.Aux) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(x != y || o1 != o2) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (LocalAddr {x} _ _) (LocalAddr {y} _ _)) |
| // result: (ConstBool [x != y]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLocalAddr { |
| continue |
| } |
| x := ssa.AuxToSym(v_0.Aux) |
| if v_1.Op != ssaop.OpLocalAddr { |
| continue |
| } |
| y := ssa.AuxToSym(v_1.Aux) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(x != y) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (LocalAddr {x} _ _) (OffPtr [o] (LocalAddr {y} _ _))) |
| // result: (ConstBool [x != y || o != 0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLocalAddr { |
| continue |
| } |
| x := ssa.AuxToSym(v_0.Aux) |
| if v_1.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o := ssa.AuxIntToInt64(v_1.AuxInt) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpLocalAddr { |
| continue |
| } |
| y := ssa.AuxToSym(v_1_0.Aux) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(x != y || o != 0) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (OffPtr [o1] (LocalAddr {x} _ _)) (OffPtr [o2] (LocalAddr {y} _ _))) |
| // result: (ConstBool [x != y || o1 != o2]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o1 := ssa.AuxIntToInt64(v_0.AuxInt) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpLocalAddr { |
| continue |
| } |
| x := ssa.AuxToSym(v_0_0.Aux) |
| if v_1.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o2 := ssa.AuxIntToInt64(v_1.AuxInt) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpLocalAddr { |
| continue |
| } |
| y := ssa.AuxToSym(v_1_0.Aux) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(x != y || o1 != o2) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (OffPtr [o1] p1) p2) |
| // cond: ssa.IsSamePtr(p1, p2) |
| // result: (ConstBool [o1 != 0]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o1 := ssa.AuxIntToInt64(v_0.AuxInt) |
| p1 := v_0.Args[0] |
| p2 := v_1 |
| if !(ssa.IsSamePtr(p1, p2)) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(o1 != 0) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (OffPtr [o1] p1) (OffPtr [o2] p2)) |
| // cond: ssa.IsSamePtr(p1, p2) |
| // result: (ConstBool [o1 != o2]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o1 := ssa.AuxIntToInt64(v_0.AuxInt) |
| p1 := v_0.Args[0] |
| if v_1.Op != ssaop.OpOffPtr { |
| continue |
| } |
| o2 := ssa.AuxIntToInt64(v_1.AuxInt) |
| p2 := v_1.Args[0] |
| if !(ssa.IsSamePtr(p1, p2)) { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(o1 != o2) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (Const32 [c]) (Const32 [d])) |
| // result: (ConstBool [c != d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c != d) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (Const64 [c]) (Const64 [d])) |
| // result: (ConstBool [c != d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c != d) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (Convert (Addr {x} _) _) (Addr {y} _)) |
| // result: (ConstBool [x!=y]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConvert { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpAddr { |
| continue |
| } |
| x := ssa.AuxToSym(v_0_0.Aux) |
| if v_1.Op != ssaop.OpAddr { |
| continue |
| } |
| y := ssa.AuxToSym(v_1.Aux) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(x != y) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (LocalAddr _ _) (Addr _)) |
| // result: (ConstBool [true]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLocalAddr || v_1.Op != ssaop.OpAddr { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (OffPtr (LocalAddr _ _)) (Addr _)) |
| // result: (ConstBool [true]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpOffPtr { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpLocalAddr || v_1.Op != ssaop.OpAddr { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (LocalAddr _ _) (OffPtr (Addr _))) |
| // result: (ConstBool [true]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLocalAddr || v_1.Op != ssaop.OpOffPtr { |
| continue |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAddr { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (OffPtr (LocalAddr _ _)) (OffPtr (Addr _))) |
| // result: (ConstBool [true]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpOffPtr { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpLocalAddr || v_1.Op != ssaop.OpOffPtr { |
| continue |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAddr { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (AddPtr p1 o1) p2) |
| // cond: ssa.IsSamePtr(p1, p2) |
| // result: (IsNonNil o1) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAddPtr { |
| continue |
| } |
| o1 := v_0.Args[1] |
| p1 := v_0.Args[0] |
| p2 := v_1 |
| if !(ssa.IsSamePtr(p1, p2)) { |
| continue |
| } |
| v.Reset(ssaop.OpIsNonNil) |
| v.AddArg(o1) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (Const32 [0]) p) |
| // result: (IsNonNil p) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| continue |
| } |
| p := v_1 |
| v.Reset(ssaop.OpIsNonNil) |
| v.AddArg(p) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (Const64 [0]) p) |
| // result: (IsNonNil p) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| continue |
| } |
| p := v_1 |
| v.Reset(ssaop.OpIsNonNil) |
| v.AddArg(p) |
| return true |
| } |
| break |
| } |
| // match: (NeqPtr (ConstNil) p) |
| // result: (IsNonNil p) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConstNil { |
| continue |
| } |
| p := v_1 |
| v.Reset(ssaop.OpIsNonNil) |
| v.AddArg(p) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpNeqSlice(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (NeqSlice x y) |
| // result: (NeqPtr (SlicePtr x) (SlicePtr y)) |
| for { |
| x := v_0 |
| y := v_1 |
| v.Reset(ssaop.OpNeqPtr) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSlicePtr, typ.BytePtr) |
| v0.AddArg(x) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSlicePtr, typ.BytePtr) |
| v1.AddArg(y) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| } |
| func rewriteValue_OpNilCheck(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| fe := b.Func.Fe |
| // match: (NilCheck ptr:(GetG mem) mem) |
| // result: ptr |
| for { |
| ptr := v_0 |
| if ptr.Op != ssaop.OpGetG { |
| break |
| } |
| mem := ptr.Args[0] |
| if mem != v_1 { |
| break |
| } |
| v.CopyOf(ptr) |
| return true |
| } |
| // match: (NilCheck ptr:(SelectN [0] call:(StaticLECall ___)) _) |
| // cond: isMalloc(call.Aux) && warnRule(fe.Debug_checknil(), v, "removed nil check") |
| // result: ptr |
| for { |
| ptr := v_0 |
| if ptr.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(ptr.AuxInt) != 0 { |
| break |
| } |
| call := ptr.Args[0] |
| if call.Op != ssaop.OpStaticLECall { |
| break |
| } |
| if !(isMalloc(call.Aux) && warnRule(fe.Debug_checknil(), v, "removed nil check")) { |
| break |
| } |
| v.CopyOf(ptr) |
| return true |
| } |
| // match: (NilCheck ptr:(OffPtr (SelectN [0] call:(StaticLECall ___))) _) |
| // cond: isMalloc(call.Aux) && warnRule(fe.Debug_checknil(), v, "removed nil check") |
| // result: ptr |
| for { |
| ptr := v_0 |
| if ptr.Op != ssaop.OpOffPtr { |
| break |
| } |
| ptr_0 := ptr.Args[0] |
| if ptr_0.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(ptr_0.AuxInt) != 0 { |
| break |
| } |
| call := ptr_0.Args[0] |
| if call.Op != ssaop.OpStaticLECall { |
| break |
| } |
| if !(isMalloc(call.Aux) && warnRule(fe.Debug_checknil(), v, "removed nil check")) { |
| break |
| } |
| v.CopyOf(ptr) |
| return true |
| } |
| // match: (NilCheck ptr:(Addr {_} (SB)) _) |
| // result: ptr |
| for { |
| ptr := v_0 |
| if ptr.Op != ssaop.OpAddr { |
| break |
| } |
| ptr_0 := ptr.Args[0] |
| if ptr_0.Op != ssaop.OpSB { |
| break |
| } |
| v.CopyOf(ptr) |
| return true |
| } |
| // match: (NilCheck ptr:(Convert (Addr {_} (SB)) _) _) |
| // result: ptr |
| for { |
| ptr := v_0 |
| if ptr.Op != ssaop.OpConvert { |
| break |
| } |
| ptr_0 := ptr.Args[0] |
| if ptr_0.Op != ssaop.OpAddr { |
| break |
| } |
| ptr_0_0 := ptr_0.Args[0] |
| if ptr_0_0.Op != ssaop.OpSB { |
| break |
| } |
| v.CopyOf(ptr) |
| return true |
| } |
| // match: (NilCheck ptr:(LocalAddr _ _) _) |
| // cond: warnRule(fe.Debug_checknil(), v, "removed nil check") |
| // result: ptr |
| for { |
| ptr := v_0 |
| if ptr.Op != ssaop.OpLocalAddr || !(warnRule(fe.Debug_checknil(), v, "removed nil check")) { |
| break |
| } |
| v.CopyOf(ptr) |
| return true |
| } |
| // match: (NilCheck ptr:(Arg {sym}) _) |
| // cond: isDictArgSym(sym) |
| // result: ptr |
| for { |
| ptr := v_0 |
| if ptr.Op != ssaop.OpArg { |
| break |
| } |
| sym := ssa.AuxToSym(ptr.Aux) |
| if !(isDictArgSym(sym)) { |
| break |
| } |
| v.CopyOf(ptr) |
| return true |
| } |
| // match: (NilCheck ptr:(NilCheck _ _) _ ) |
| // result: ptr |
| for { |
| ptr := v_0 |
| if ptr.Op != ssaop.OpNilCheck { |
| break |
| } |
| v.CopyOf(ptr) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpNot(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Not (ConstBool [c])) |
| // result: (ConstBool [!c]) |
| for { |
| if v_0.Op != ssaop.OpConstBool { |
| break |
| } |
| c := ssa.AuxIntToBool(v_0.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(!c) |
| return true |
| } |
| // match: (Not (Eq64 x y)) |
| // result: (Neq64 x y) |
| for { |
| if v_0.Op != ssaop.OpEq64 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpNeq64) |
| v.AddArg2(x, y) |
| return true |
| } |
| // match: (Not (Eq32 x y)) |
| // result: (Neq32 x y) |
| for { |
| if v_0.Op != ssaop.OpEq32 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpNeq32) |
| v.AddArg2(x, y) |
| return true |
| } |
| // match: (Not (Eq16 x y)) |
| // result: (Neq16 x y) |
| for { |
| if v_0.Op != ssaop.OpEq16 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpNeq16) |
| v.AddArg2(x, y) |
| return true |
| } |
| // match: (Not (Eq8 x y)) |
| // result: (Neq8 x y) |
| for { |
| if v_0.Op != ssaop.OpEq8 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpNeq8) |
| v.AddArg2(x, y) |
| return true |
| } |
| // match: (Not (EqB x y)) |
| // result: (NeqB x y) |
| for { |
| if v_0.Op != ssaop.OpEqB { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpNeqB) |
| v.AddArg2(x, y) |
| return true |
| } |
| // match: (Not (EqPtr x y)) |
| // result: (NeqPtr x y) |
| for { |
| if v_0.Op != ssaop.OpEqPtr { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpNeqPtr) |
| v.AddArg2(x, y) |
| return true |
| } |
| // match: (Not (Eq64F x y)) |
| // result: (Neq64F x y) |
| for { |
| if v_0.Op != ssaop.OpEq64F { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpNeq64F) |
| v.AddArg2(x, y) |
| return true |
| } |
| // match: (Not (Eq32F x y)) |
| // result: (Neq32F x y) |
| for { |
| if v_0.Op != ssaop.OpEq32F { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpNeq32F) |
| v.AddArg2(x, y) |
| return true |
| } |
| // match: (Not (Neq64 x y)) |
| // result: (Eq64 x y) |
| for { |
| if v_0.Op != ssaop.OpNeq64 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpEq64) |
| v.AddArg2(x, y) |
| return true |
| } |
| // match: (Not (Neq32 x y)) |
| // result: (Eq32 x y) |
| for { |
| if v_0.Op != ssaop.OpNeq32 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpEq32) |
| v.AddArg2(x, y) |
| return true |
| } |
| // match: (Not (Neq16 x y)) |
| // result: (Eq16 x y) |
| for { |
| if v_0.Op != ssaop.OpNeq16 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpEq16) |
| v.AddArg2(x, y) |
| return true |
| } |
| // match: (Not (Neq8 x y)) |
| // result: (Eq8 x y) |
| for { |
| if v_0.Op != ssaop.OpNeq8 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpEq8) |
| v.AddArg2(x, y) |
| return true |
| } |
| // match: (Not (NeqB x y)) |
| // result: (EqB x y) |
| for { |
| if v_0.Op != ssaop.OpNeqB { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpEqB) |
| v.AddArg2(x, y) |
| return true |
| } |
| // match: (Not (NeqPtr x y)) |
| // result: (EqPtr x y) |
| for { |
| if v_0.Op != ssaop.OpNeqPtr { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpEqPtr) |
| v.AddArg2(x, y) |
| return true |
| } |
| // match: (Not (Neq64F x y)) |
| // result: (Eq64F x y) |
| for { |
| if v_0.Op != ssaop.OpNeq64F { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpEq64F) |
| v.AddArg2(x, y) |
| return true |
| } |
| // match: (Not (Neq32F x y)) |
| // result: (Eq32F x y) |
| for { |
| if v_0.Op != ssaop.OpNeq32F { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpEq32F) |
| v.AddArg2(x, y) |
| return true |
| } |
| // match: (Not (Less64 x y)) |
| // result: (Leq64 y x) |
| for { |
| if v_0.Op != ssaop.OpLess64 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpLeq64) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Not (Less32 x y)) |
| // result: (Leq32 y x) |
| for { |
| if v_0.Op != ssaop.OpLess32 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpLeq32) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Not (Less16 x y)) |
| // result: (Leq16 y x) |
| for { |
| if v_0.Op != ssaop.OpLess16 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpLeq16) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Not (Less8 x y)) |
| // result: (Leq8 y x) |
| for { |
| if v_0.Op != ssaop.OpLess8 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpLeq8) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Not (Less64U x y)) |
| // result: (Leq64U y x) |
| for { |
| if v_0.Op != ssaop.OpLess64U { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpLeq64U) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Not (Less32U x y)) |
| // result: (Leq32U y x) |
| for { |
| if v_0.Op != ssaop.OpLess32U { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpLeq32U) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Not (Less16U x y)) |
| // result: (Leq16U y x) |
| for { |
| if v_0.Op != ssaop.OpLess16U { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpLeq16U) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Not (Less8U x y)) |
| // result: (Leq8U y x) |
| for { |
| if v_0.Op != ssaop.OpLess8U { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpLeq8U) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Not (Leq64 x y)) |
| // result: (Less64 y x) |
| for { |
| if v_0.Op != ssaop.OpLeq64 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpLess64) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Not (Leq32 x y)) |
| // result: (Less32 y x) |
| for { |
| if v_0.Op != ssaop.OpLeq32 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpLess32) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Not (Leq16 x y)) |
| // result: (Less16 y x) |
| for { |
| if v_0.Op != ssaop.OpLeq16 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpLess16) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Not (Leq8 x y)) |
| // result: (Less8 y x) |
| for { |
| if v_0.Op != ssaop.OpLeq8 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpLess8) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Not (Leq64U x y)) |
| // result: (Less64U y x) |
| for { |
| if v_0.Op != ssaop.OpLeq64U { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpLess64U) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Not (Leq32U x y)) |
| // result: (Less32U y x) |
| for { |
| if v_0.Op != ssaop.OpLeq32U { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpLess32U) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Not (Leq16U x y)) |
| // result: (Less16U y x) |
| for { |
| if v_0.Op != ssaop.OpLeq16U { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpLess16U) |
| v.AddArg2(y, x) |
| return true |
| } |
| // match: (Not (Leq8U x y)) |
| // result: (Less8U y x) |
| for { |
| if v_0.Op != ssaop.OpLeq8U { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpLess8U) |
| v.AddArg2(y, x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpOffPtr(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (OffPtr (OffPtr p [y]) [x]) |
| // result: (OffPtr p [x+y]) |
| for { |
| x := ssa.AuxIntToInt64(v.AuxInt) |
| if v_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| y := ssa.AuxIntToInt64(v_0.AuxInt) |
| p := v_0.Args[0] |
| v.Reset(ssaop.OpOffPtr) |
| v.AuxInt = ssa.Int64ToAuxInt(x + y) |
| v.AddArg(p) |
| return true |
| } |
| // match: (OffPtr p [0]) |
| // cond: v.Type.Compare(p.Type) == types.CMPeq |
| // result: p |
| for { |
| if ssa.AuxIntToInt64(v.AuxInt) != 0 { |
| break |
| } |
| p := v_0 |
| if !(v.Type.Compare(p.Type) == types.CMPeq) { |
| break |
| } |
| v.CopyOf(p) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpOr16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (Or16 (Const16 [c]) (Const16 [d])) |
| // result: (Const16 [c|d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(c | d) |
| return true |
| } |
| break |
| } |
| // match: (Or16 <t> (Com16 x) (Com16 y)) |
| // result: (Com16 (And16 <t> x y)) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom16 { |
| continue |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpCom16 { |
| continue |
| } |
| y := v_1.Args[0] |
| v.Reset(ssaop.OpCom16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd16, t) |
| v0.AddArg2(x, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (Or16 x (And16 x y)) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or16 x x) |
| // result: x |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Or16 (Const16 [0]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Or16 (Const16 [-1]) _) |
| // result: (Const16 [-1]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != -1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(-1) |
| return true |
| } |
| break |
| } |
| // match: (Or16 (Com16 x) x) |
| // result: (Const16 [-1]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom16 { |
| continue |
| } |
| x := v_0.Args[0] |
| if x != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(-1) |
| return true |
| } |
| break |
| } |
| // match: (Or16 x (Or16 x y)) |
| // result: (Or16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpOr16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpOr16) |
| v.AddArg2(x, y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or16 (And16 x (Const16 [c2])) (Const16 <t> [c1])) |
| // cond: ^(c1 | c2) == 0 |
| // result: (Or16 (Const16 <t> [c1]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAnd16 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c2 := ssa.AuxIntToInt16(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_1.Type |
| c1 := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(^(c1 | c2) == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpOr16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(c1) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or16 (Or16 i:(Const16 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) |
| // result: (Or16 i (Or16 <t> z x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpOr16 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) { |
| continue |
| } |
| v.Reset(ssaop.OpOr16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr16, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or16 (Const16 <t> [c]) (Or16 (Const16 <t> [d]) x)) |
| // result: (Or16 (Const16 <t> [c|d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpOr16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst16 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpOr16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(c | d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or16 (Lsh16x64 x z:(Const64 <t> [c])) (Rsh16Ux64 x (Const64 [d]))) |
| // cond: c < 16 && d == 16-c && canRotate(config, 16) |
| // result: (RotateLeft16 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLsh16x64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| z := v_0.Args[1] |
| if z.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(z.AuxInt) |
| if v_1.Op != ssaop.OpRsh16Ux64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c < 16 && d == 16-c && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Or16 left:(Lsh16x64 x y) right:(Rsh16Ux64 x (Sub64 (Const64 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh16x64 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh16Ux64 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Or16 left:(Lsh16x32 x y) right:(Rsh16Ux32 x (Sub32 (Const32 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh16x32 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh16Ux32 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Or16 left:(Lsh16x16 x y) right:(Rsh16Ux16 x (Sub16 (Const16 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh16x16 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh16Ux16 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Or16 left:(Lsh16x8 x y) right:(Rsh16Ux8 x (Sub8 (Const8 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh16x8 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh16Ux8 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Or16 right:(Rsh16Ux64 x y) left:(Lsh16x64 x z:(Sub64 (Const64 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh16Ux64 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh16x64 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Or16 right:(Rsh16Ux32 x y) left:(Lsh16x32 x z:(Sub32 (Const32 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh16Ux32 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh16x32 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Or16 right:(Rsh16Ux16 x y) left:(Lsh16x16 x z:(Sub16 (Const16 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh16Ux16 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh16x16 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Or16 right:(Rsh16Ux8 x y) left:(Lsh16x8 x z:(Sub8 (Const8 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh16Ux8 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh16x8 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpOr32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (Or32 (Const32 [c]) (Const32 [d])) |
| // result: (Const32 [c|d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(c | d) |
| return true |
| } |
| break |
| } |
| // match: (Or32 <t> (Com32 x) (Com32 y)) |
| // result: (Com32 (And32 <t> x y)) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom32 { |
| continue |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpCom32 { |
| continue |
| } |
| y := v_1.Args[0] |
| v.Reset(ssaop.OpCom32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd32, t) |
| v0.AddArg2(x, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (Or32 x (And32 x y)) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or32 x x) |
| // result: x |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Or32 (Const32 [0]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Or32 (Const32 [-1]) _) |
| // result: (Const32 [-1]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != -1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(-1) |
| return true |
| } |
| break |
| } |
| // match: (Or32 (Com32 x) x) |
| // result: (Const32 [-1]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom32 { |
| continue |
| } |
| x := v_0.Args[0] |
| if x != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(-1) |
| return true |
| } |
| break |
| } |
| // match: (Or32 x (Or32 x y)) |
| // result: (Or32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpOr32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpOr32) |
| v.AddArg2(x, y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or32 (And32 x (Const32 [c2])) (Const32 <t> [c1])) |
| // cond: ^(c1 | c2) == 0 |
| // result: (Or32 (Const32 <t> [c1]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAnd32 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| c2 := ssa.AuxIntToInt32(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_1.Type |
| c1 := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(^(c1 | c2) == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpOr32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(c1) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or32 (Or32 i:(Const32 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) |
| // result: (Or32 i (Or32 <t> z x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpOr32 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) { |
| continue |
| } |
| v.Reset(ssaop.OpOr32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or32 (Const32 <t> [c]) (Or32 (Const32 <t> [d]) x)) |
| // result: (Or32 (Const32 <t> [c|d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpOr32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst32 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpOr32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(c | d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or32 (Lsh32x64 x z:(Const64 <t> [c])) (Rsh32Ux64 x (Const64 [d]))) |
| // cond: c < 32 && d == 32-c && canRotate(config, 32) |
| // result: (RotateLeft32 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLsh32x64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| z := v_0.Args[1] |
| if z.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(z.AuxInt) |
| if v_1.Op != ssaop.OpRsh32Ux64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c < 32 && d == 32-c && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Or32 left:(Lsh32x64 x y) right:(Rsh32Ux64 x (Sub64 (Const64 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh32x64 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh32Ux64 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Or32 left:(Lsh32x32 x y) right:(Rsh32Ux32 x (Sub32 (Const32 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh32x32 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh32Ux32 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Or32 left:(Lsh32x16 x y) right:(Rsh32Ux16 x (Sub16 (Const16 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh32x16 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh32Ux16 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Or32 left:(Lsh32x8 x y) right:(Rsh32Ux8 x (Sub8 (Const8 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh32x8 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh32Ux8 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Or32 right:(Rsh32Ux64 x y) left:(Lsh32x64 x z:(Sub64 (Const64 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh32Ux64 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh32x64 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Or32 right:(Rsh32Ux32 x y) left:(Lsh32x32 x z:(Sub32 (Const32 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh32Ux32 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh32x32 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Or32 right:(Rsh32Ux16 x y) left:(Lsh32x16 x z:(Sub16 (Const16 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh32Ux16 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh32x16 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Or32 right:(Rsh32Ux8 x y) left:(Lsh32x8 x z:(Sub8 (Const8 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh32Ux8 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh32x8 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, z) |
| 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 |
| config := b.Func.Config |
| // match: (Or64 (Const64 [c]) (Const64 [d])) |
| // result: (Const64 [c|d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(c | d) |
| return true |
| } |
| break |
| } |
| // match: (Or64 <t> (Com64 x) (Com64 y)) |
| // result: (Com64 (And64 <t> x y)) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom64 { |
| continue |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpCom64 { |
| continue |
| } |
| y := v_1.Args[0] |
| v.Reset(ssaop.OpCom64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd64, t) |
| v0.AddArg2(x, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (Or64 x (And64 x y)) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or64 x x) |
| // result: x |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Or64 (Const64 [0]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Or64 (Const64 [-1]) _) |
| // result: (Const64 [-1]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != -1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(-1) |
| return true |
| } |
| break |
| } |
| // match: (Or64 (Com64 x) x) |
| // result: (Const64 [-1]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom64 { |
| continue |
| } |
| x := v_0.Args[0] |
| if x != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(-1) |
| return true |
| } |
| break |
| } |
| // match: (Or64 x (Or64 x y)) |
| // result: (Or64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpOr64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpOr64) |
| v.AddArg2(x, y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or64 (And64 x (Const64 [c2])) (Const64 <t> [c1])) |
| // cond: ^(c1 | c2) == 0 |
| // result: (Or64 (Const64 <t> [c1]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAnd64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c2 := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_1.Type |
| c1 := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(^(c1 | c2) == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpOr64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c1) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or64 (Or64 i:(Const64 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) |
| // result: (Or64 i (Or64 <t> z x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpOr64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) { |
| continue |
| } |
| v.Reset(ssaop.OpOr64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr64, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or64 (Const64 <t> [c]) (Or64 (Const64 <t> [d]) x)) |
| // result: (Or64 (Const64 <t> [c|d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpOr64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst64 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpOr64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c | d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or64 (Lsh64x64 x z:(Const64 <t> [c])) (Rsh64Ux64 x (Const64 [d]))) |
| // cond: c < 64 && d == 64-c && canRotate(config, 64) |
| // result: (RotateLeft64 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLsh64x64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| z := v_0.Args[1] |
| if z.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(z.AuxInt) |
| if v_1.Op != ssaop.OpRsh64Ux64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c < 64 && d == 64-c && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Or64 left:(Lsh64x64 x y) right:(Rsh64Ux64 x (Sub64 (Const64 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh64x64 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh64Ux64 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Or64 left:(Lsh64x32 x y) right:(Rsh64Ux32 x (Sub32 (Const32 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh64x32 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh64Ux32 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Or64 left:(Lsh64x16 x y) right:(Rsh64Ux16 x (Sub16 (Const16 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh64x16 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh64Ux16 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Or64 left:(Lsh64x8 x y) right:(Rsh64Ux8 x (Sub8 (Const8 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh64x8 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh64Ux8 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Or64 right:(Rsh64Ux64 x y) left:(Lsh64x64 x z:(Sub64 (Const64 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh64Ux64 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh64x64 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Or64 right:(Rsh64Ux32 x y) left:(Lsh64x32 x z:(Sub32 (Const32 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh64Ux32 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh64x32 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Or64 right:(Rsh64Ux16 x y) left:(Lsh64x16 x z:(Sub16 (Const16 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh64Ux16 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh64x16 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Or64 right:(Rsh64Ux8 x y) left:(Lsh64x8 x z:(Sub8 (Const8 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh64Ux8 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh64x8 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpOr8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (Or8 (Const8 [c]) (Const8 [d])) |
| // result: (Const8 [c|d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(c | d) |
| return true |
| } |
| break |
| } |
| // match: (Or8 <t> (Com8 x) (Com8 y)) |
| // result: (Com8 (And8 <t> x y)) |
| for { |
| t := v.Type |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom8 { |
| continue |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpCom8 { |
| continue |
| } |
| y := v_1.Args[0] |
| v.Reset(ssaop.OpCom8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAnd8, t) |
| v0.AddArg2(x, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (Or8 x (And8 x y)) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or8 x x) |
| // result: x |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Or8 (Const8 [0]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Or8 (Const8 [-1]) _) |
| // result: (Const8 [-1]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != -1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(-1) |
| return true |
| } |
| break |
| } |
| // match: (Or8 (Com8 x) x) |
| // result: (Const8 [-1]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom8 { |
| continue |
| } |
| x := v_0.Args[0] |
| if x != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(-1) |
| return true |
| } |
| break |
| } |
| // match: (Or8 x (Or8 x y)) |
| // result: (Or8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpOr8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpOr8) |
| v.AddArg2(x, y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or8 (And8 x (Const8 [c2])) (Const8 <t> [c1])) |
| // cond: ^(c1 | c2) == 0 |
| // result: (Or8 (Const8 <t> [c1]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpAnd8 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| if v_0_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c2 := ssa.AuxIntToInt8(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_1.Type |
| c1 := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(^(c1 | c2) == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpOr8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(c1) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or8 (Or8 i:(Const8 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) |
| // result: (Or8 i (Or8 <t> z x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpOr8 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) { |
| continue |
| } |
| v.Reset(ssaop.OpOr8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr8, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or8 (Const8 <t> [c]) (Or8 (Const8 <t> [d]) x)) |
| // result: (Or8 (Const8 <t> [c|d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpOr8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst8 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpOr8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(c | d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Or8 (Lsh8x64 x z:(Const64 <t> [c])) (Rsh8Ux64 x (Const64 [d]))) |
| // cond: c < 8 && d == 8-c && canRotate(config, 8) |
| // result: (RotateLeft8 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLsh8x64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| z := v_0.Args[1] |
| if z.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(z.AuxInt) |
| if v_1.Op != ssaop.OpRsh8Ux64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c < 8 && d == 8-c && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Or8 left:(Lsh8x64 x y) right:(Rsh8Ux64 x (Sub64 (Const64 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh8x64 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh8Ux64 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Or8 left:(Lsh8x32 x y) right:(Rsh8Ux32 x (Sub32 (Const32 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh8x32 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh8Ux32 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Or8 left:(Lsh8x16 x y) right:(Rsh8Ux16 x (Sub16 (Const16 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh8x16 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh8Ux16 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Or8 left:(Lsh8x8 x y) right:(Rsh8Ux8 x (Sub8 (Const8 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh8x8 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh8Ux8 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Or8 right:(Rsh8Ux64 x y) left:(Lsh8x64 x z:(Sub64 (Const64 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh8Ux64 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh8x64 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Or8 right:(Rsh8Ux32 x y) left:(Lsh8x32 x z:(Sub32 (Const32 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh8Ux32 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh8x32 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Or8 right:(Rsh8Ux16 x y) left:(Lsh8x16 x z:(Sub16 (Const16 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh8Ux16 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh8x16 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Or8 right:(Rsh8Ux8 x y) left:(Lsh8x8 x z:(Sub8 (Const8 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh8Ux8 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh8x8 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpOrB(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (OrB (ConstBool [c]) (ConstBool [d])) |
| // result: (ConstBool [c||d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConstBool { |
| continue |
| } |
| c := ssa.AuxIntToBool(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConstBool { |
| continue |
| } |
| d := ssa.AuxIntToBool(v_1.AuxInt) |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(c || d) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Less64 (Const64 [c]) x) (Less64 x (Const64 [d]))) |
| // cond: c >= d |
| // result: (Less64U (Const64 <x.Type> [c-d]) (Sub64 <x.Type> x (Const64 <x.Type> [d]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess64 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c >= d) { |
| continue |
| } |
| v.Reset(ssaop.OpLess64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v0.AuxInt = ssa.Int64ToAuxInt(c - d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Leq64 (Const64 [c]) x) (Less64 x (Const64 [d]))) |
| // cond: c >= d |
| // result: (Leq64U (Const64 <x.Type> [c-d]) (Sub64 <x.Type> x (Const64 <x.Type> [d]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq64 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c >= d) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v0.AuxInt = ssa.Int64ToAuxInt(c - d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Less32 (Const32 [c]) x) (Less32 x (Const32 [d]))) |
| // cond: c >= d |
| // result: (Less32U (Const32 <x.Type> [c-d]) (Sub32 <x.Type> x (Const32 <x.Type> [d]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess32 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(c >= d) { |
| continue |
| } |
| v.Reset(ssaop.OpLess32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v0.AuxInt = ssa.Int32ToAuxInt(c - d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Leq32 (Const32 [c]) x) (Less32 x (Const32 [d]))) |
| // cond: c >= d |
| // result: (Leq32U (Const32 <x.Type> [c-d]) (Sub32 <x.Type> x (Const32 <x.Type> [d]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq32 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(c >= d) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v0.AuxInt = ssa.Int32ToAuxInt(c - d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Less16 (Const16 [c]) x) (Less16 x (Const16 [d]))) |
| // cond: c >= d |
| // result: (Less16U (Const16 <x.Type> [c-d]) (Sub16 <x.Type> x (Const16 <x.Type> [d]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess16 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(c >= d) { |
| continue |
| } |
| v.Reset(ssaop.OpLess16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v0.AuxInt = ssa.Int16ToAuxInt(c - d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Leq16 (Const16 [c]) x) (Less16 x (Const16 [d]))) |
| // cond: c >= d |
| // result: (Leq16U (Const16 <x.Type> [c-d]) (Sub16 <x.Type> x (Const16 <x.Type> [d]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq16 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(c >= d) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v0.AuxInt = ssa.Int16ToAuxInt(c - d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Less8 (Const8 [c]) x) (Less8 x (Const8 [d]))) |
| // cond: c >= d |
| // result: (Less8U (Const8 <x.Type> [c-d]) (Sub8 <x.Type> x (Const8 <x.Type> [d]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess8 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(c >= d) { |
| continue |
| } |
| v.Reset(ssaop.OpLess8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v0.AuxInt = ssa.Int8ToAuxInt(c - d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Leq8 (Const8 [c]) x) (Less8 x (Const8 [d]))) |
| // cond: c >= d |
| // result: (Leq8U (Const8 <x.Type> [c-d]) (Sub8 <x.Type> x (Const8 <x.Type> [d]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq8 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(c >= d) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v0.AuxInt = ssa.Int8ToAuxInt(c - d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Less64 (Const64 [c]) x) (Leq64 x (Const64 [d]))) |
| // cond: c >= d+1 && d+1 > d |
| // result: (Less64U (Const64 <x.Type> [c-d-1]) (Sub64 <x.Type> x (Const64 <x.Type> [d+1]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess64 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c >= d+1 && d+1 > d) { |
| continue |
| } |
| v.Reset(ssaop.OpLess64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v0.AuxInt = ssa.Int64ToAuxInt(c - d - 1) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d + 1) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Leq64 (Const64 [c]) x) (Leq64 x (Const64 [d]))) |
| // cond: c >= d+1 && d+1 > d |
| // result: (Leq64U (Const64 <x.Type> [c-d-1]) (Sub64 <x.Type> x (Const64 <x.Type> [d+1]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq64 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c >= d+1 && d+1 > d) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v0.AuxInt = ssa.Int64ToAuxInt(c - d - 1) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d + 1) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Less32 (Const32 [c]) x) (Leq32 x (Const32 [d]))) |
| // cond: c >= d+1 && d+1 > d |
| // result: (Less32U (Const32 <x.Type> [c-d-1]) (Sub32 <x.Type> x (Const32 <x.Type> [d+1]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess32 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(c >= d+1 && d+1 > d) { |
| continue |
| } |
| v.Reset(ssaop.OpLess32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v0.AuxInt = ssa.Int32ToAuxInt(c - d - 1) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d + 1) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Leq32 (Const32 [c]) x) (Leq32 x (Const32 [d]))) |
| // cond: c >= d+1 && d+1 > d |
| // result: (Leq32U (Const32 <x.Type> [c-d-1]) (Sub32 <x.Type> x (Const32 <x.Type> [d+1]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq32 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(c >= d+1 && d+1 > d) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v0.AuxInt = ssa.Int32ToAuxInt(c - d - 1) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d + 1) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Less16 (Const16 [c]) x) (Leq16 x (Const16 [d]))) |
| // cond: c >= d+1 && d+1 > d |
| // result: (Less16U (Const16 <x.Type> [c-d-1]) (Sub16 <x.Type> x (Const16 <x.Type> [d+1]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess16 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(c >= d+1 && d+1 > d) { |
| continue |
| } |
| v.Reset(ssaop.OpLess16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v0.AuxInt = ssa.Int16ToAuxInt(c - d - 1) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d + 1) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Leq16 (Const16 [c]) x) (Leq16 x (Const16 [d]))) |
| // cond: c >= d+1 && d+1 > d |
| // result: (Leq16U (Const16 <x.Type> [c-d-1]) (Sub16 <x.Type> x (Const16 <x.Type> [d+1]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq16 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(c >= d+1 && d+1 > d) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v0.AuxInt = ssa.Int16ToAuxInt(c - d - 1) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d + 1) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Less8 (Const8 [c]) x) (Leq8 x (Const8 [d]))) |
| // cond: c >= d+1 && d+1 > d |
| // result: (Less8U (Const8 <x.Type> [c-d-1]) (Sub8 <x.Type> x (Const8 <x.Type> [d+1]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess8 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(c >= d+1 && d+1 > d) { |
| continue |
| } |
| v.Reset(ssaop.OpLess8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v0.AuxInt = ssa.Int8ToAuxInt(c - d - 1) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d + 1) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Leq8 (Const8 [c]) x) (Leq8 x (Const8 [d]))) |
| // cond: c >= d+1 && d+1 > d |
| // result: (Leq8U (Const8 <x.Type> [c-d-1]) (Sub8 <x.Type> x (Const8 <x.Type> [d+1]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq8 { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(c >= d+1 && d+1 > d) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v0.AuxInt = ssa.Int8ToAuxInt(c - d - 1) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d + 1) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Less64U (Const64 [c]) x) (Less64U x (Const64 [d]))) |
| // cond: uint64(c) >= uint64(d) |
| // result: (Less64U (Const64 <x.Type> [c-d]) (Sub64 <x.Type> x (Const64 <x.Type> [d]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess64U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess64U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(uint64(c) >= uint64(d)) { |
| continue |
| } |
| v.Reset(ssaop.OpLess64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v0.AuxInt = ssa.Int64ToAuxInt(c - d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Leq64U (Const64 [c]) x) (Less64U x (Const64 [d]))) |
| // cond: uint64(c) >= uint64(d) |
| // result: (Leq64U (Const64 <x.Type> [c-d]) (Sub64 <x.Type> x (Const64 <x.Type> [d]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq64U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess64U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(uint64(c) >= uint64(d)) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v0.AuxInt = ssa.Int64ToAuxInt(c - d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Less32U (Const32 [c]) x) (Less32U x (Const32 [d]))) |
| // cond: uint32(c) >= uint32(d) |
| // result: (Less32U (Const32 <x.Type> [c-d]) (Sub32 <x.Type> x (Const32 <x.Type> [d]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess32U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess32U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(uint32(c) >= uint32(d)) { |
| continue |
| } |
| v.Reset(ssaop.OpLess32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v0.AuxInt = ssa.Int32ToAuxInt(c - d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Leq32U (Const32 [c]) x) (Less32U x (Const32 [d]))) |
| // cond: uint32(c) >= uint32(d) |
| // result: (Leq32U (Const32 <x.Type> [c-d]) (Sub32 <x.Type> x (Const32 <x.Type> [d]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq32U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess32U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(uint32(c) >= uint32(d)) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v0.AuxInt = ssa.Int32ToAuxInt(c - d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Less16U (Const16 [c]) x) (Less16U x (Const16 [d]))) |
| // cond: uint16(c) >= uint16(d) |
| // result: (Less16U (Const16 <x.Type> [c-d]) (Sub16 <x.Type> x (Const16 <x.Type> [d]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess16U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess16U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(uint16(c) >= uint16(d)) { |
| continue |
| } |
| v.Reset(ssaop.OpLess16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v0.AuxInt = ssa.Int16ToAuxInt(c - d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Leq16U (Const16 [c]) x) (Less16U x (Const16 [d]))) |
| // cond: uint16(c) >= uint16(d) |
| // result: (Leq16U (Const16 <x.Type> [c-d]) (Sub16 <x.Type> x (Const16 <x.Type> [d]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq16U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess16U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(uint16(c) >= uint16(d)) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v0.AuxInt = ssa.Int16ToAuxInt(c - d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Less8U (Const8 [c]) x) (Less8U x (Const8 [d]))) |
| // cond: uint8(c) >= uint8(d) |
| // result: (Less8U (Const8 <x.Type> [c-d]) (Sub8 <x.Type> x (Const8 <x.Type> [d]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess8U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess8U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(uint8(c) >= uint8(d)) { |
| continue |
| } |
| v.Reset(ssaop.OpLess8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v0.AuxInt = ssa.Int8ToAuxInt(c - d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Leq8U (Const8 [c]) x) (Less8U x (Const8 [d]))) |
| // cond: uint8(c) >= uint8(d) |
| // result: (Leq8U (Const8 <x.Type> [c-d]) (Sub8 <x.Type> x (Const8 <x.Type> [d]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq8U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLess8U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(uint8(c) >= uint8(d)) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v0.AuxInt = ssa.Int8ToAuxInt(c - d) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Less64U (Const64 [c]) x) (Leq64U x (Const64 [d]))) |
| // cond: uint64(c) >= uint64(d+1) && uint64(d+1) > uint64(d) |
| // result: (Less64U (Const64 <x.Type> [c-d-1]) (Sub64 <x.Type> x (Const64 <x.Type> [d+1]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess64U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq64U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(uint64(c) >= uint64(d+1) && uint64(d+1) > uint64(d)) { |
| continue |
| } |
| v.Reset(ssaop.OpLess64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v0.AuxInt = ssa.Int64ToAuxInt(c - d - 1) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d + 1) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Leq64U (Const64 [c]) x) (Leq64U x (Const64 [d]))) |
| // cond: uint64(c) >= uint64(d+1) && uint64(d+1) > uint64(d) |
| // result: (Leq64U (Const64 <x.Type> [c-d-1]) (Sub64 <x.Type> x (Const64 <x.Type> [d+1]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq64U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq64U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(uint64(c) >= uint64(d+1) && uint64(d+1) > uint64(d)) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq64U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v0.AuxInt = ssa.Int64ToAuxInt(c - d - 1) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub64, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v2.AuxInt = ssa.Int64ToAuxInt(d + 1) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Less32U (Const32 [c]) x) (Leq32U x (Const32 [d]))) |
| // cond: uint32(c) >= uint32(d+1) && uint32(d+1) > uint32(d) |
| // result: (Less32U (Const32 <x.Type> [c-d-1]) (Sub32 <x.Type> x (Const32 <x.Type> [d+1]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess32U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq32U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(uint32(c) >= uint32(d+1) && uint32(d+1) > uint32(d)) { |
| continue |
| } |
| v.Reset(ssaop.OpLess32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v0.AuxInt = ssa.Int32ToAuxInt(c - d - 1) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d + 1) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Leq32U (Const32 [c]) x) (Leq32U x (Const32 [d]))) |
| // cond: uint32(c) >= uint32(d+1) && uint32(d+1) > uint32(d) |
| // result: (Leq32U (Const32 <x.Type> [c-d-1]) (Sub32 <x.Type> x (Const32 <x.Type> [d+1]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq32U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq32U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(uint32(c) >= uint32(d+1) && uint32(d+1) > uint32(d)) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq32U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v0.AuxInt = ssa.Int32ToAuxInt(c - d - 1) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub32, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v2.AuxInt = ssa.Int32ToAuxInt(d + 1) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Less16U (Const16 [c]) x) (Leq16U x (Const16 [d]))) |
| // cond: uint16(c) >= uint16(d+1) && uint16(d+1) > uint16(d) |
| // result: (Less16U (Const16 <x.Type> [c-d-1]) (Sub16 <x.Type> x (Const16 <x.Type> [d+1]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess16U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq16U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(uint16(c) >= uint16(d+1) && uint16(d+1) > uint16(d)) { |
| continue |
| } |
| v.Reset(ssaop.OpLess16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v0.AuxInt = ssa.Int16ToAuxInt(c - d - 1) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d + 1) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Leq16U (Const16 [c]) x) (Leq16U x (Const16 [d]))) |
| // cond: uint16(c) >= uint16(d+1) && uint16(d+1) > uint16(d) |
| // result: (Leq16U (Const16 <x.Type> [c-d-1]) (Sub16 <x.Type> x (Const16 <x.Type> [d+1]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq16U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq16U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(uint16(c) >= uint16(d+1) && uint16(d+1) > uint16(d)) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq16U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v0.AuxInt = ssa.Int16ToAuxInt(c - d - 1) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub16, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v2.AuxInt = ssa.Int16ToAuxInt(d + 1) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Less8U (Const8 [c]) x) (Leq8U x (Const8 [d]))) |
| // cond: uint8(c) >= uint8(d+1) && uint8(d+1) > uint8(d) |
| // result: (Less8U (Const8 <x.Type> [c-d-1]) (Sub8 <x.Type> x (Const8 <x.Type> [d+1]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLess8U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq8U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(uint8(c) >= uint8(d+1) && uint8(d+1) > uint8(d)) { |
| continue |
| } |
| v.Reset(ssaop.OpLess8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v0.AuxInt = ssa.Int8ToAuxInt(c - d - 1) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d + 1) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Leq8U (Const8 [c]) x) (Leq8U x (Const8 [d]))) |
| // cond: uint8(c) >= uint8(d+1) && uint8(d+1) > uint8(d) |
| // result: (Leq8U (Const8 <x.Type> [c-d-1]) (Sub8 <x.Type> x (Const8 <x.Type> [d+1]))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLeq8U { |
| continue |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0_0.AuxInt) |
| if v_1.Op != ssaop.OpLeq8U { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(uint8(c) >= uint8(d+1) && uint8(d+1) > uint8(d)) { |
| continue |
| } |
| v.Reset(ssaop.OpLeq8U) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v0.AuxInt = ssa.Int8ToAuxInt(c - d - 1) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSub8, x.Type) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v2.AuxInt = ssa.Int8ToAuxInt(d + 1) |
| v1.AddArg2(x, v2) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Eq64 x cv:(Const64 [c])) (Eq64 x (Const64 [d]))) |
| // cond: c|d == c && ssa.OneBit(c^d) |
| // result: (Eq64 (Or64 <x.Type> x (Const64 <x.Type> [c^d])) cv) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpEq64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| cv := v_0_1 |
| if cv.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(cv.AuxInt) |
| if v_1.Op != ssaop.OpEq64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 { |
| if x != v_1_0 || v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c|d == c && ssa.OneBit(c^d)) { |
| continue |
| } |
| v.Reset(ssaop.OpEq64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr64, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, x.Type) |
| v1.AuxInt = ssa.Int64ToAuxInt(c ^ d) |
| v0.AddArg2(x, v1) |
| v.AddArg2(v0, cv) |
| return true |
| } |
| } |
| } |
| break |
| } |
| // match: (OrB (Eq32 x cv:(Const32 [c])) (Eq32 x (Const32 [d]))) |
| // cond: c|d == c && ssa.OneBit(c^d) |
| // result: (Eq32 (Or32 <x.Type> x (Const32 <x.Type> [c^d])) cv) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpEq32 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| cv := v_0_1 |
| if cv.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(cv.AuxInt) |
| if v_1.Op != ssaop.OpEq32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 { |
| if x != v_1_0 || v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(c|d == c && ssa.OneBit(c^d)) { |
| continue |
| } |
| v.Reset(ssaop.OpEq32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr32, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, x.Type) |
| v1.AuxInt = ssa.Int32ToAuxInt(c ^ d) |
| v0.AddArg2(x, v1) |
| v.AddArg2(v0, cv) |
| return true |
| } |
| } |
| } |
| break |
| } |
| // match: (OrB (Eq16 x cv:(Const16 [c])) (Eq16 x (Const16 [d]))) |
| // cond: c|d == c && ssa.OneBit(c^d) |
| // result: (Eq16 (Or16 <x.Type> x (Const16 <x.Type> [c^d])) cv) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpEq16 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| cv := v_0_1 |
| if cv.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(cv.AuxInt) |
| if v_1.Op != ssaop.OpEq16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 { |
| if x != v_1_0 || v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(c|d == c && ssa.OneBit(c^d)) { |
| continue |
| } |
| v.Reset(ssaop.OpEq16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr16, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst16, x.Type) |
| v1.AuxInt = ssa.Int16ToAuxInt(c ^ d) |
| v0.AddArg2(x, v1) |
| v.AddArg2(v0, cv) |
| return true |
| } |
| } |
| } |
| break |
| } |
| // match: (OrB (Eq8 x cv:(Const8 [c])) (Eq8 x (Const8 [d]))) |
| // cond: c|d == c && ssa.OneBit(c^d) |
| // result: (Eq8 (Or8 <x.Type> x (Const8 <x.Type> [c^d])) cv) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpEq8 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| cv := v_0_1 |
| if cv.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(cv.AuxInt) |
| if v_1.Op != ssaop.OpEq8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i2 := 0; _i2 <= 1; _i2, v_1_0, v_1_1 = _i2+1, v_1_1, v_1_0 { |
| if x != v_1_0 || v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(c|d == c && ssa.OneBit(c^d)) { |
| continue |
| } |
| v.Reset(ssaop.OpEq8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpOr8, x.Type) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, x.Type) |
| v1.AuxInt = ssa.Int8ToAuxInt(c ^ d) |
| v0.AddArg2(x, v1) |
| v.AddArg2(v0, cv) |
| return true |
| } |
| } |
| } |
| break |
| } |
| // match: (OrB (Neq64F x x) (Less64F x y:(Const64F [c]))) |
| // result: (Not (Leq64F y x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq64F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLess64F { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| y := v_1.Args[1] |
| if y.Op != ssaop.OpConst64F { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLeq64F, typ.Bool) |
| v0.AddArg2(y, x) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq64F x x) (Leq64F x y:(Const64F [c]))) |
| // result: (Not (Less64F y x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq64F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq64F { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| y := v_1.Args[1] |
| if y.Op != ssaop.OpConst64F { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLess64F, typ.Bool) |
| v0.AddArg2(y, x) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq64F x x) (Less64F y:(Const64F [c]) x)) |
| // result: (Not (Leq64F x y)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq64F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLess64F { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if y.Op != ssaop.OpConst64F { |
| continue |
| } |
| if x != v_1.Args[1] { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLeq64F, typ.Bool) |
| v0.AddArg2(x, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq64F x x) (Leq64F y:(Const64F [c]) x)) |
| // result: (Not (Less64F x y)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq64F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq64F { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if y.Op != ssaop.OpConst64F { |
| continue |
| } |
| if x != v_1.Args[1] { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLess64F, typ.Bool) |
| v0.AddArg2(x, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq32F x x) (Less32F x y:(Const32F [c]))) |
| // result: (Not (Leq32F y x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq32F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLess32F { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| y := v_1.Args[1] |
| if y.Op != ssaop.OpConst32F { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLeq32F, typ.Bool) |
| v0.AddArg2(y, x) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq32F x x) (Leq32F x y:(Const32F [c]))) |
| // result: (Not (Less32F y x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq32F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq32F { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| y := v_1.Args[1] |
| if y.Op != ssaop.OpConst32F { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLess32F, typ.Bool) |
| v0.AddArg2(y, x) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq32F x x) (Less32F y:(Const32F [c]) x)) |
| // result: (Not (Leq32F x y)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq32F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLess32F { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if y.Op != ssaop.OpConst32F { |
| continue |
| } |
| if x != v_1.Args[1] { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLeq32F, typ.Bool) |
| v0.AddArg2(x, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq32F x x) (Leq32F y:(Const32F [c]) x)) |
| // result: (Not (Less32F x y)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq32F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq32F { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if y.Op != ssaop.OpConst32F { |
| continue |
| } |
| if x != v_1.Args[1] { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLess32F, typ.Bool) |
| v0.AddArg2(x, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq64F x x) (Less64F abs:(Abs x) y:(Const64F [c]))) |
| // result: (Not (Leq64F y abs)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq64F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLess64F { |
| continue |
| } |
| _ = v_1.Args[1] |
| abs := v_1.Args[0] |
| if abs.Op != ssaop.OpAbs || x != abs.Args[0] { |
| continue |
| } |
| y := v_1.Args[1] |
| if y.Op != ssaop.OpConst64F { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLeq64F, typ.Bool) |
| v0.AddArg2(y, abs) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq64F x x) (Leq64F abs:(Abs x) y:(Const64F [c]))) |
| // result: (Not (Less64F y abs)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq64F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq64F { |
| continue |
| } |
| _ = v_1.Args[1] |
| abs := v_1.Args[0] |
| if abs.Op != ssaop.OpAbs || x != abs.Args[0] { |
| continue |
| } |
| y := v_1.Args[1] |
| if y.Op != ssaop.OpConst64F { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLess64F, typ.Bool) |
| v0.AddArg2(y, abs) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq64F x x) (Less64F y:(Const64F [c]) abs:(Abs x))) |
| // result: (Not (Leq64F abs y)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq64F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLess64F { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if y.Op != ssaop.OpConst64F { |
| continue |
| } |
| abs := v_1.Args[1] |
| if abs.Op != ssaop.OpAbs || x != abs.Args[0] { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLeq64F, typ.Bool) |
| v0.AddArg2(abs, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq64F x x) (Leq64F y:(Const64F [c]) abs:(Abs x))) |
| // result: (Not (Less64F abs y)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq64F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq64F { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if y.Op != ssaop.OpConst64F { |
| continue |
| } |
| abs := v_1.Args[1] |
| if abs.Op != ssaop.OpAbs || x != abs.Args[0] { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLess64F, typ.Bool) |
| v0.AddArg2(abs, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq64F x x) (Less64F neg:(Neg64F x) y:(Const64F [c]))) |
| // result: (Not (Leq64F y neg)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq64F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLess64F { |
| continue |
| } |
| _ = v_1.Args[1] |
| neg := v_1.Args[0] |
| if neg.Op != ssaop.OpNeg64F || x != neg.Args[0] { |
| continue |
| } |
| y := v_1.Args[1] |
| if y.Op != ssaop.OpConst64F { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLeq64F, typ.Bool) |
| v0.AddArg2(y, neg) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq64F x x) (Leq64F neg:(Neg64F x) y:(Const64F [c]))) |
| // result: (Not (Less64F y neg)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq64F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq64F { |
| continue |
| } |
| _ = v_1.Args[1] |
| neg := v_1.Args[0] |
| if neg.Op != ssaop.OpNeg64F || x != neg.Args[0] { |
| continue |
| } |
| y := v_1.Args[1] |
| if y.Op != ssaop.OpConst64F { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLess64F, typ.Bool) |
| v0.AddArg2(y, neg) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq64F x x) (Less64F y:(Const64F [c]) neg:(Neg64F x))) |
| // result: (Not (Leq64F neg y)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq64F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLess64F { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if y.Op != ssaop.OpConst64F { |
| continue |
| } |
| neg := v_1.Args[1] |
| if neg.Op != ssaop.OpNeg64F || x != neg.Args[0] { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLeq64F, typ.Bool) |
| v0.AddArg2(neg, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq64F x x) (Leq64F y:(Const64F [c]) neg:(Neg64F x))) |
| // result: (Not (Less64F neg y)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq64F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq64F { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if y.Op != ssaop.OpConst64F { |
| continue |
| } |
| neg := v_1.Args[1] |
| if neg.Op != ssaop.OpNeg64F || x != neg.Args[0] { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLess64F, typ.Bool) |
| v0.AddArg2(neg, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq32F x x) (Less32F neg:(Neg32F x) y:(Const32F [c]))) |
| // result: (Not (Leq32F y neg)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq32F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLess32F { |
| continue |
| } |
| _ = v_1.Args[1] |
| neg := v_1.Args[0] |
| if neg.Op != ssaop.OpNeg32F || x != neg.Args[0] { |
| continue |
| } |
| y := v_1.Args[1] |
| if y.Op != ssaop.OpConst32F { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLeq32F, typ.Bool) |
| v0.AddArg2(y, neg) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq32F x x) (Leq32F neg:(Neg32F x) y:(Const32F [c]))) |
| // result: (Not (Less32F y neg)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq32F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq32F { |
| continue |
| } |
| _ = v_1.Args[1] |
| neg := v_1.Args[0] |
| if neg.Op != ssaop.OpNeg32F || x != neg.Args[0] { |
| continue |
| } |
| y := v_1.Args[1] |
| if y.Op != ssaop.OpConst32F { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLess32F, typ.Bool) |
| v0.AddArg2(y, neg) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq32F x x) (Less32F y:(Const32F [c]) neg:(Neg32F x))) |
| // result: (Not (Leq32F neg y)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq32F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLess32F { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if y.Op != ssaop.OpConst32F { |
| continue |
| } |
| neg := v_1.Args[1] |
| if neg.Op != ssaop.OpNeg32F || x != neg.Args[0] { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLeq32F, typ.Bool) |
| v0.AddArg2(neg, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB (Neq32F x x) (Leq32F y:(Const32F [c]) neg:(Neg32F x))) |
| // result: (Not (Less32F neg y)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpNeq32F { |
| continue |
| } |
| x := v_0.Args[1] |
| if x != v_0.Args[0] || v_1.Op != ssaop.OpLeq32F { |
| continue |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if y.Op != ssaop.OpConst32F { |
| continue |
| } |
| neg := v_1.Args[1] |
| if neg.Op != ssaop.OpNeg32F || x != neg.Args[0] { |
| continue |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpLess32F, typ.Bool) |
| v0.AddArg2(neg, y) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (OrB x x) |
| // result: x |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (OrB (ConstBool [false]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != false { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (OrB (ConstBool [true]) _) |
| // result: (ConstBool [true]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConstBool || ssa.AuxIntToBool(v_0.AuxInt) != true { |
| continue |
| } |
| v.Reset(ssaop.OpConstBool) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpPhi(v *ssa.Value) bool { |
| b := v.Block |
| // match: (Phi (Const8 [c]) (Const8 [c])) |
| // result: (Const8 [c]) |
| for { |
| if len(v.Args) != 2 { |
| break |
| } |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| v_1 := v.Args[1] |
| if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != c { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(c) |
| return true |
| } |
| // match: (Phi (Const16 [c]) (Const16 [c])) |
| // result: (Const16 [c]) |
| for { |
| if len(v.Args) != 2 { |
| break |
| } |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| v_1 := v.Args[1] |
| if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != c { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(c) |
| return true |
| } |
| // match: (Phi (Const32 [c]) (Const32 [c])) |
| // result: (Const32 [c]) |
| for { |
| if len(v.Args) != 2 { |
| break |
| } |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| v_1 := v.Args[1] |
| if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != c { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(c) |
| return true |
| } |
| // match: (Phi (Const64 [c]) (Const64 [c])) |
| // result: (Const64 [c]) |
| for { |
| if len(v.Args) != 2 { |
| break |
| } |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| v_1 := v.Args[1] |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(c) |
| return true |
| } |
| // match: (Phi <t> nx:(Not x) ny:(Not y)) |
| // cond: nx.Uses == 1 && ny.Uses == 1 |
| // result: (Not (Phi <t> x y)) |
| for { |
| if len(v.Args) != 2 { |
| break |
| } |
| t := v.Type |
| _ = v.Args[1] |
| nx := v.Args[0] |
| if nx.Op != ssaop.OpNot { |
| break |
| } |
| x := nx.Args[0] |
| ny := v.Args[1] |
| if ny.Op != ssaop.OpNot { |
| break |
| } |
| y := ny.Args[0] |
| if !(nx.Uses == 1 && ny.Uses == 1) { |
| break |
| } |
| v.Reset(ssaop.OpNot) |
| v0 := b.NewValue0(v.Pos, ssaop.OpPhi, t) |
| v0.AddArg2(x, y) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpPopCount16(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (PopCount16 (Const16 [c])) |
| // cond: config.PtrSize == 8 |
| // result: (Const64 [int64(bits.OnesCount16(uint16(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if !(config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(bits.OnesCount16(uint16(c)))) |
| return true |
| } |
| // match: (PopCount16 (Const16 [c])) |
| // cond: config.PtrSize == 4 |
| // result: (Const32 [int32(bits.OnesCount16(uint16(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(bits.OnesCount16(uint16(c)))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpPopCount32(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (PopCount32 (Const32 [c])) |
| // cond: config.PtrSize == 8 |
| // result: (Const64 [int64(bits.OnesCount32(uint32(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if !(config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(bits.OnesCount32(uint32(c)))) |
| return true |
| } |
| // match: (PopCount32 (Const32 [c])) |
| // cond: config.PtrSize == 4 |
| // result: (Const32 [int32(bits.OnesCount32(uint32(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(bits.OnesCount32(uint32(c)))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpPopCount64(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (PopCount64 (Const64 [c])) |
| // cond: config.PtrSize == 8 |
| // result: (Const64 [int64(bits.OnesCount64(uint64(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if !(config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(bits.OnesCount64(uint64(c)))) |
| return true |
| } |
| // match: (PopCount64 (Const64 [c])) |
| // cond: config.PtrSize == 4 |
| // result: (Const32 [int32(bits.OnesCount64(uint64(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(bits.OnesCount64(uint64(c)))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpPopCount8(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (PopCount8 (Const8 [c])) |
| // cond: config.PtrSize == 8 |
| // result: (Const64 [int64(bits.OnesCount8(uint8(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if !(config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(bits.OnesCount8(uint8(c)))) |
| return true |
| } |
| // match: (PopCount8 (Const8 [c])) |
| // cond: config.PtrSize == 4 |
| // result: (Const32 [int32(bits.OnesCount8(uint8(c)))]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(bits.OnesCount8(uint8(c)))) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpPtrIndex(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: (PtrIndex <t> ptr idx) |
| // cond: config.PtrSize == 4 && ssa.Is32Bit(t.Elem().Size()) |
| // result: (AddPtr ptr (Mul32 <typ.Int> idx (Const32 <typ.Int> [int32(t.Elem().Size())]))) |
| for { |
| t := v.Type |
| ptr := v_0 |
| idx := v_1 |
| if !(config.PtrSize == 4 && ssa.Is32Bit(t.Elem().Size())) { |
| break |
| } |
| v.Reset(ssaop.OpAddPtr) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul32, typ.Int) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int) |
| v1.AuxInt = ssa.Int32ToAuxInt(int32(t.Elem().Size())) |
| v0.AddArg2(idx, v1) |
| v.AddArg2(ptr, v0) |
| return true |
| } |
| // match: (PtrIndex <t> ptr idx) |
| // cond: config.PtrSize == 8 |
| // result: (AddPtr ptr (Mul64 <typ.Int> idx (Const64 <typ.Int> [t.Elem().Size()]))) |
| for { |
| t := v.Type |
| ptr := v_0 |
| idx := v_1 |
| if !(config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpAddPtr) |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul64, typ.Int) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int) |
| v1.AuxInt = ssa.Int64ToAuxInt(t.Elem().Size()) |
| v0.AddArg2(idx, v1) |
| v.AddArg2(ptr, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRotateLeft16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (RotateLeft16 (Const16 [x]) (Const64 [y])) |
| // result: (Const16 [int16(bits.RotateLeft16(uint16(x), int(y)))]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| x := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| y := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(int16(bits.RotateLeft16(uint16(x), int(y)))) |
| return true |
| } |
| // match: (RotateLeft16 (Const16 [x]) (Const32 [y])) |
| // result: (Const16 [int16(bits.RotateLeft16(uint16(x), int(y)))]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| x := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| y := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(int16(bits.RotateLeft16(uint16(x), int(y)))) |
| return true |
| } |
| // match: (RotateLeft16 x (Const16 [c])) |
| // cond: c%16 == 0 |
| // result: x |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(c%16 == 0) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (RotateLeft16 x (And64 y (Const64 [c]))) |
| // cond: c&15 == 15 |
| // result: (RotateLeft16 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c&15 == 15) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft16 x (And32 y (Const32 [c]))) |
| // cond: c&15 == 15 |
| // result: (RotateLeft16 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(c&15 == 15) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft16 x (And16 y (Const16 [c]))) |
| // cond: c&15 == 15 |
| // result: (RotateLeft16 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(c&15 == 15) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft16 x (And8 y (Const8 [c]))) |
| // cond: c&15 == 15 |
| // result: (RotateLeft16 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(c&15 == 15) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft16 x (Neg64 (And64 y (Const64 [c])))) |
| // cond: c&15 == 15 |
| // result: (RotateLeft16 x (Neg64 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg64 { |
| break |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| v_1_0_1 := v_1_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 { |
| y := v_1_0_0 |
| if v_1_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_0_1.AuxInt) |
| if !(c&15 == 15) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg64, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft16 x (Neg32 (And32 y (Const32 [c])))) |
| // cond: c&15 == 15 |
| // result: (RotateLeft16 x (Neg32 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg32 { |
| break |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAnd32 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| v_1_0_1 := v_1_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 { |
| y := v_1_0_0 |
| if v_1_0_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_1_0_1.AuxInt) |
| if !(c&15 == 15) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg32, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft16 x (Neg16 (And16 y (Const16 [c])))) |
| // cond: c&15 == 15 |
| // result: (RotateLeft16 x (Neg16 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg16 { |
| break |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAnd16 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| v_1_0_1 := v_1_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 { |
| y := v_1_0_0 |
| if v_1_0_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_1_0_1.AuxInt) |
| if !(c&15 == 15) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg16, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft16 x (Neg8 (And8 y (Const8 [c])))) |
| // cond: c&15 == 15 |
| // result: (RotateLeft16 x (Neg8 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg8 { |
| break |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAnd8 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| v_1_0_1 := v_1_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 { |
| y := v_1_0_0 |
| if v_1_0_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_1_0_1.AuxInt) |
| if !(c&15 == 15) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg8, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft16 x (Add64 y (Const64 [c]))) |
| // cond: c&15 == 0 |
| // result: (RotateLeft16 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c&15 == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft16 x (Add32 y (Const32 [c]))) |
| // cond: c&15 == 0 |
| // result: (RotateLeft16 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(c&15 == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft16 x (Add16 y (Const16 [c]))) |
| // cond: c&15 == 0 |
| // result: (RotateLeft16 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(c&15 == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft16 x (Add8 y (Const8 [c]))) |
| // cond: c&15 == 0 |
| // result: (RotateLeft16 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(c&15 == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft16 x (Sub64 (Const64 [c]) y)) |
| // cond: c&15 == 0 |
| // result: (RotateLeft16 x (Neg64 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub64 { |
| break |
| } |
| y := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1_0.AuxInt) |
| if !(c&15 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg64, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft16 x (Sub32 (Const32 [c]) y)) |
| // cond: c&15 == 0 |
| // result: (RotateLeft16 x (Neg32 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub32 { |
| break |
| } |
| y := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1_0.AuxInt) |
| if !(c&15 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg32, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft16 x (Sub16 (Const16 [c]) y)) |
| // cond: c&15 == 0 |
| // result: (RotateLeft16 x (Neg16 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub16 { |
| break |
| } |
| y := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1_0.AuxInt) |
| if !(c&15 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg16, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft16 x (Sub8 (Const8 [c]) y)) |
| // cond: c&15 == 0 |
| // result: (RotateLeft16 x (Neg8 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub8 { |
| break |
| } |
| y := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1_0.AuxInt) |
| if !(c&15 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg8, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft16 x (Const64 <t> [c])) |
| // cond: config.PtrSize == 4 |
| // result: (RotateLeft16 x (Const32 <t> [int32(c)])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_1.Type |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(int32(c)) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft16 (RotateLeft16 x c) d) |
| // cond: c.Type.Size() == 8 && d.Type.Size() == 8 |
| // result: (RotateLeft16 x (Add64 <c.Type> c d)) |
| for { |
| if v_0.Op != ssaop.OpRotateLeft16 { |
| break |
| } |
| c := v_0.Args[1] |
| x := v_0.Args[0] |
| d := v_1 |
| if !(c.Type.Size() == 8 && d.Type.Size() == 8) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, c.Type) |
| v0.AddArg2(c, d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft16 (RotateLeft16 x c) d) |
| // cond: c.Type.Size() == 4 && d.Type.Size() == 4 |
| // result: (RotateLeft16 x (Add32 <c.Type> c d)) |
| for { |
| if v_0.Op != ssaop.OpRotateLeft16 { |
| break |
| } |
| c := v_0.Args[1] |
| x := v_0.Args[0] |
| d := v_1 |
| if !(c.Type.Size() == 4 && d.Type.Size() == 4) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, c.Type) |
| v0.AddArg2(c, d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft16 (RotateLeft16 x c) d) |
| // cond: c.Type.Size() == 2 && d.Type.Size() == 2 |
| // result: (RotateLeft16 x (Add16 <c.Type> c d)) |
| for { |
| if v_0.Op != ssaop.OpRotateLeft16 { |
| break |
| } |
| c := v_0.Args[1] |
| x := v_0.Args[0] |
| d := v_1 |
| if !(c.Type.Size() == 2 && d.Type.Size() == 2) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, c.Type) |
| v0.AddArg2(c, d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft16 (RotateLeft16 x c) d) |
| // cond: c.Type.Size() == 1 && d.Type.Size() == 1 |
| // result: (RotateLeft16 x (Add8 <c.Type> c d)) |
| for { |
| if v_0.Op != ssaop.OpRotateLeft16 { |
| break |
| } |
| c := v_0.Args[1] |
| x := v_0.Args[0] |
| d := v_1 |
| if !(c.Type.Size() == 1 && d.Type.Size() == 1) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, c.Type) |
| v0.AddArg2(c, d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRotateLeft32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (RotateLeft32 (Const32 [x]) (Const64 [y])) |
| // result: (Const32 [int32(bits.RotateLeft32(uint32(x), int(y)))]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| x := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| y := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(bits.RotateLeft32(uint32(x), int(y)))) |
| return true |
| } |
| // match: (RotateLeft32 (Const32 [x]) (Const32 [y])) |
| // result: (Const32 [int32(bits.RotateLeft32(uint32(x), int(y)))]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| x := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| y := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(bits.RotateLeft32(uint32(x), int(y)))) |
| return true |
| } |
| // match: (RotateLeft32 x (Const32 [c])) |
| // cond: c%32 == 0 |
| // result: x |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(c%32 == 0) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (RotateLeft32 x (And64 y (Const64 [c]))) |
| // cond: c&31 == 31 |
| // result: (RotateLeft32 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c&31 == 31) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft32 x (And32 y (Const32 [c]))) |
| // cond: c&31 == 31 |
| // result: (RotateLeft32 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(c&31 == 31) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft32 x (And16 y (Const16 [c]))) |
| // cond: c&31 == 31 |
| // result: (RotateLeft32 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(c&31 == 31) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft32 x (And8 y (Const8 [c]))) |
| // cond: c&31 == 31 |
| // result: (RotateLeft32 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(c&31 == 31) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft32 x (Neg64 (And64 y (Const64 [c])))) |
| // cond: c&31 == 31 |
| // result: (RotateLeft32 x (Neg64 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg64 { |
| break |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| v_1_0_1 := v_1_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 { |
| y := v_1_0_0 |
| if v_1_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_0_1.AuxInt) |
| if !(c&31 == 31) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg64, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft32 x (Neg32 (And32 y (Const32 [c])))) |
| // cond: c&31 == 31 |
| // result: (RotateLeft32 x (Neg32 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg32 { |
| break |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAnd32 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| v_1_0_1 := v_1_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 { |
| y := v_1_0_0 |
| if v_1_0_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_1_0_1.AuxInt) |
| if !(c&31 == 31) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg32, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft32 x (Neg16 (And16 y (Const16 [c])))) |
| // cond: c&31 == 31 |
| // result: (RotateLeft32 x (Neg16 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg16 { |
| break |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAnd16 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| v_1_0_1 := v_1_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 { |
| y := v_1_0_0 |
| if v_1_0_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_1_0_1.AuxInt) |
| if !(c&31 == 31) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg16, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft32 x (Neg8 (And8 y (Const8 [c])))) |
| // cond: c&31 == 31 |
| // result: (RotateLeft32 x (Neg8 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg8 { |
| break |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAnd8 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| v_1_0_1 := v_1_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 { |
| y := v_1_0_0 |
| if v_1_0_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_1_0_1.AuxInt) |
| if !(c&31 == 31) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg8, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft32 x (Add64 y (Const64 [c]))) |
| // cond: c&31 == 0 |
| // result: (RotateLeft32 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c&31 == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft32 x (Add32 y (Const32 [c]))) |
| // cond: c&31 == 0 |
| // result: (RotateLeft32 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(c&31 == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft32 x (Add16 y (Const16 [c]))) |
| // cond: c&31 == 0 |
| // result: (RotateLeft32 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(c&31 == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft32 x (Add8 y (Const8 [c]))) |
| // cond: c&31 == 0 |
| // result: (RotateLeft32 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(c&31 == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft32 x (Sub64 (Const64 [c]) y)) |
| // cond: c&31 == 0 |
| // result: (RotateLeft32 x (Neg64 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub64 { |
| break |
| } |
| y := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1_0.AuxInt) |
| if !(c&31 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg64, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft32 x (Sub32 (Const32 [c]) y)) |
| // cond: c&31 == 0 |
| // result: (RotateLeft32 x (Neg32 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub32 { |
| break |
| } |
| y := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1_0.AuxInt) |
| if !(c&31 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg32, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft32 x (Sub16 (Const16 [c]) y)) |
| // cond: c&31 == 0 |
| // result: (RotateLeft32 x (Neg16 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub16 { |
| break |
| } |
| y := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1_0.AuxInt) |
| if !(c&31 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg16, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft32 x (Sub8 (Const8 [c]) y)) |
| // cond: c&31 == 0 |
| // result: (RotateLeft32 x (Neg8 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub8 { |
| break |
| } |
| y := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1_0.AuxInt) |
| if !(c&31 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg8, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft32 x (Const64 <t> [c])) |
| // cond: config.PtrSize == 4 |
| // result: (RotateLeft32 x (Const32 <t> [int32(c)])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_1.Type |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(int32(c)) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft32 (RotateLeft32 x c) d) |
| // cond: c.Type.Size() == 8 && d.Type.Size() == 8 |
| // result: (RotateLeft32 x (Add64 <c.Type> c d)) |
| for { |
| if v_0.Op != ssaop.OpRotateLeft32 { |
| break |
| } |
| c := v_0.Args[1] |
| x := v_0.Args[0] |
| d := v_1 |
| if !(c.Type.Size() == 8 && d.Type.Size() == 8) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, c.Type) |
| v0.AddArg2(c, d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft32 (RotateLeft32 x c) d) |
| // cond: c.Type.Size() == 4 && d.Type.Size() == 4 |
| // result: (RotateLeft32 x (Add32 <c.Type> c d)) |
| for { |
| if v_0.Op != ssaop.OpRotateLeft32 { |
| break |
| } |
| c := v_0.Args[1] |
| x := v_0.Args[0] |
| d := v_1 |
| if !(c.Type.Size() == 4 && d.Type.Size() == 4) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, c.Type) |
| v0.AddArg2(c, d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft32 (RotateLeft32 x c) d) |
| // cond: c.Type.Size() == 2 && d.Type.Size() == 2 |
| // result: (RotateLeft32 x (Add16 <c.Type> c d)) |
| for { |
| if v_0.Op != ssaop.OpRotateLeft32 { |
| break |
| } |
| c := v_0.Args[1] |
| x := v_0.Args[0] |
| d := v_1 |
| if !(c.Type.Size() == 2 && d.Type.Size() == 2) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, c.Type) |
| v0.AddArg2(c, d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft32 (RotateLeft32 x c) d) |
| // cond: c.Type.Size() == 1 && d.Type.Size() == 1 |
| // result: (RotateLeft32 x (Add8 <c.Type> c d)) |
| for { |
| if v_0.Op != ssaop.OpRotateLeft32 { |
| break |
| } |
| c := v_0.Args[1] |
| x := v_0.Args[0] |
| d := v_1 |
| if !(c.Type.Size() == 1 && d.Type.Size() == 1) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, c.Type) |
| v0.AddArg2(c, d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRotateLeft64(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (RotateLeft64 (Const64 [x]) (Const64 [y])) |
| // result: (Const64 [int64(bits.RotateLeft64(uint64(x), int(y)))]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| x := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| y := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(bits.RotateLeft64(uint64(x), int(y)))) |
| return true |
| } |
| // match: (RotateLeft64 (Const64 [x]) (Const32 [y])) |
| // result: (Const64 [int64(bits.RotateLeft64(uint64(x), int(y)))]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| x := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| y := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(bits.RotateLeft64(uint64(x), int(y)))) |
| return true |
| } |
| // match: (RotateLeft64 x (Const64 [c])) |
| // cond: c%64 == 0 |
| // result: x |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c%64 == 0) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (RotateLeft64 x (And64 y (Const64 [c]))) |
| // cond: c&63 == 63 |
| // result: (RotateLeft64 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c&63 == 63) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft64 x (And32 y (Const32 [c]))) |
| // cond: c&63 == 63 |
| // result: (RotateLeft64 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(c&63 == 63) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft64 x (And16 y (Const16 [c]))) |
| // cond: c&63 == 63 |
| // result: (RotateLeft64 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(c&63 == 63) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft64 x (And8 y (Const8 [c]))) |
| // cond: c&63 == 63 |
| // result: (RotateLeft64 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(c&63 == 63) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft64 x (Neg64 (And64 y (Const64 [c])))) |
| // cond: c&63 == 63 |
| // result: (RotateLeft64 x (Neg64 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg64 { |
| break |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| v_1_0_1 := v_1_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 { |
| y := v_1_0_0 |
| if v_1_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_0_1.AuxInt) |
| if !(c&63 == 63) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg64, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft64 x (Neg32 (And32 y (Const32 [c])))) |
| // cond: c&63 == 63 |
| // result: (RotateLeft64 x (Neg32 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg32 { |
| break |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAnd32 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| v_1_0_1 := v_1_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 { |
| y := v_1_0_0 |
| if v_1_0_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_1_0_1.AuxInt) |
| if !(c&63 == 63) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg32, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft64 x (Neg16 (And16 y (Const16 [c])))) |
| // cond: c&63 == 63 |
| // result: (RotateLeft64 x (Neg16 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg16 { |
| break |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAnd16 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| v_1_0_1 := v_1_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 { |
| y := v_1_0_0 |
| if v_1_0_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_1_0_1.AuxInt) |
| if !(c&63 == 63) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg16, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft64 x (Neg8 (And8 y (Const8 [c])))) |
| // cond: c&63 == 63 |
| // result: (RotateLeft64 x (Neg8 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg8 { |
| break |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAnd8 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| v_1_0_1 := v_1_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 { |
| y := v_1_0_0 |
| if v_1_0_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_1_0_1.AuxInt) |
| if !(c&63 == 63) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg8, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft64 x (Add64 y (Const64 [c]))) |
| // cond: c&63 == 0 |
| // result: (RotateLeft64 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c&63 == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft64 x (Add32 y (Const32 [c]))) |
| // cond: c&63 == 0 |
| // result: (RotateLeft64 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(c&63 == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft64 x (Add16 y (Const16 [c]))) |
| // cond: c&63 == 0 |
| // result: (RotateLeft64 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(c&63 == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft64 x (Add8 y (Const8 [c]))) |
| // cond: c&63 == 0 |
| // result: (RotateLeft64 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(c&63 == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft64 x (Sub64 (Const64 [c]) y)) |
| // cond: c&63 == 0 |
| // result: (RotateLeft64 x (Neg64 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub64 { |
| break |
| } |
| y := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1_0.AuxInt) |
| if !(c&63 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg64, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft64 x (Sub32 (Const32 [c]) y)) |
| // cond: c&63 == 0 |
| // result: (RotateLeft64 x (Neg32 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub32 { |
| break |
| } |
| y := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1_0.AuxInt) |
| if !(c&63 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg32, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft64 x (Sub16 (Const16 [c]) y)) |
| // cond: c&63 == 0 |
| // result: (RotateLeft64 x (Neg16 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub16 { |
| break |
| } |
| y := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1_0.AuxInt) |
| if !(c&63 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg16, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft64 x (Sub8 (Const8 [c]) y)) |
| // cond: c&63 == 0 |
| // result: (RotateLeft64 x (Neg8 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub8 { |
| break |
| } |
| y := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1_0.AuxInt) |
| if !(c&63 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg8, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft64 x (Const64 <t> [c])) |
| // cond: config.PtrSize == 4 |
| // result: (RotateLeft64 x (Const32 <t> [int32(c)])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_1.Type |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(int32(c)) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft64 (RotateLeft64 x c) d) |
| // cond: c.Type.Size() == 8 && d.Type.Size() == 8 |
| // result: (RotateLeft64 x (Add64 <c.Type> c d)) |
| for { |
| if v_0.Op != ssaop.OpRotateLeft64 { |
| break |
| } |
| c := v_0.Args[1] |
| x := v_0.Args[0] |
| d := v_1 |
| if !(c.Type.Size() == 8 && d.Type.Size() == 8) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, c.Type) |
| v0.AddArg2(c, d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft64 (RotateLeft64 x c) d) |
| // cond: c.Type.Size() == 4 && d.Type.Size() == 4 |
| // result: (RotateLeft64 x (Add32 <c.Type> c d)) |
| for { |
| if v_0.Op != ssaop.OpRotateLeft64 { |
| break |
| } |
| c := v_0.Args[1] |
| x := v_0.Args[0] |
| d := v_1 |
| if !(c.Type.Size() == 4 && d.Type.Size() == 4) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, c.Type) |
| v0.AddArg2(c, d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft64 (RotateLeft64 x c) d) |
| // cond: c.Type.Size() == 2 && d.Type.Size() == 2 |
| // result: (RotateLeft64 x (Add16 <c.Type> c d)) |
| for { |
| if v_0.Op != ssaop.OpRotateLeft64 { |
| break |
| } |
| c := v_0.Args[1] |
| x := v_0.Args[0] |
| d := v_1 |
| if !(c.Type.Size() == 2 && d.Type.Size() == 2) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, c.Type) |
| v0.AddArg2(c, d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft64 (RotateLeft64 x c) d) |
| // cond: c.Type.Size() == 1 && d.Type.Size() == 1 |
| // result: (RotateLeft64 x (Add8 <c.Type> c d)) |
| for { |
| if v_0.Op != ssaop.OpRotateLeft64 { |
| break |
| } |
| c := v_0.Args[1] |
| x := v_0.Args[0] |
| d := v_1 |
| if !(c.Type.Size() == 1 && d.Type.Size() == 1) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, c.Type) |
| v0.AddArg2(c, d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRotateLeft8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (RotateLeft8 (Const8 [x]) (Const64 [y])) |
| // result: (Const8 [int8(bits.RotateLeft8(uint8(x), int(y)))]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| x := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| y := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(int8(bits.RotateLeft8(uint8(x), int(y)))) |
| return true |
| } |
| // match: (RotateLeft8 (Const8 [x]) (Const32 [y])) |
| // result: (Const8 [int8(bits.RotateLeft8(uint8(x), int(y)))]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| x := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| y := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(int8(bits.RotateLeft8(uint8(x), int(y)))) |
| return true |
| } |
| // match: (RotateLeft8 x (Const8 [c])) |
| // cond: c%8 == 0 |
| // result: x |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(c%8 == 0) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (RotateLeft8 x (And64 y (Const64 [c]))) |
| // cond: c&7 == 7 |
| // result: (RotateLeft8 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c&7 == 7) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft8 x (And32 y (Const32 [c]))) |
| // cond: c&7 == 7 |
| // result: (RotateLeft8 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(c&7 == 7) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft8 x (And16 y (Const16 [c]))) |
| // cond: c&7 == 7 |
| // result: (RotateLeft8 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(c&7 == 7) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft8 x (And8 y (Const8 [c]))) |
| // cond: c&7 == 7 |
| // result: (RotateLeft8 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(c&7 == 7) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft8 x (Neg64 (And64 y (Const64 [c])))) |
| // cond: c&7 == 7 |
| // result: (RotateLeft8 x (Neg64 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg64 { |
| break |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| v_1_0_1 := v_1_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 { |
| y := v_1_0_0 |
| if v_1_0_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_0_1.AuxInt) |
| if !(c&7 == 7) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg64, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft8 x (Neg32 (And32 y (Const32 [c])))) |
| // cond: c&7 == 7 |
| // result: (RotateLeft8 x (Neg32 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg32 { |
| break |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAnd32 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| v_1_0_1 := v_1_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 { |
| y := v_1_0_0 |
| if v_1_0_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_1_0_1.AuxInt) |
| if !(c&7 == 7) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg32, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft8 x (Neg16 (And16 y (Const16 [c])))) |
| // cond: c&7 == 7 |
| // result: (RotateLeft8 x (Neg16 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg16 { |
| break |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAnd16 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| v_1_0_1 := v_1_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 { |
| y := v_1_0_0 |
| if v_1_0_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_1_0_1.AuxInt) |
| if !(c&7 == 7) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg16, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft8 x (Neg8 (And8 y (Const8 [c])))) |
| // cond: c&7 == 7 |
| // result: (RotateLeft8 x (Neg8 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpNeg8 { |
| break |
| } |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpAnd8 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| v_1_0_1 := v_1_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0_0, v_1_0_1 = _i0+1, v_1_0_1, v_1_0_0 { |
| y := v_1_0_0 |
| if v_1_0_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_1_0_1.AuxInt) |
| if !(c&7 == 7) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg8, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft8 x (Add64 y (Const64 [c]))) |
| // cond: c&7 == 0 |
| // result: (RotateLeft8 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c&7 == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft8 x (Add32 y (Const32 [c]))) |
| // cond: c&7 == 0 |
| // result: (RotateLeft8 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_1_1.AuxInt) |
| if !(c&7 == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft8 x (Add16 y (Const16 [c]))) |
| // cond: c&7 == 0 |
| // result: (RotateLeft8 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_1_1.AuxInt) |
| if !(c&7 == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft8 x (Add8 y (Const8 [c]))) |
| // cond: c&7 == 0 |
| // result: (RotateLeft8 x y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| y := v_1_0 |
| if v_1_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_1_1.AuxInt) |
| if !(c&7 == 0) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (RotateLeft8 x (Sub64 (Const64 [c]) y)) |
| // cond: c&7 == 0 |
| // result: (RotateLeft8 x (Neg64 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub64 { |
| break |
| } |
| y := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1_0.AuxInt) |
| if !(c&7 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg64, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft8 x (Sub32 (Const32 [c]) y)) |
| // cond: c&7 == 0 |
| // result: (RotateLeft8 x (Neg32 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub32 { |
| break |
| } |
| y := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1_0.AuxInt) |
| if !(c&7 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg32, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft8 x (Sub16 (Const16 [c]) y)) |
| // cond: c&7 == 0 |
| // result: (RotateLeft8 x (Neg16 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub16 { |
| break |
| } |
| y := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1_0.AuxInt) |
| if !(c&7 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg16, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft8 x (Sub8 (Const8 [c]) y)) |
| // cond: c&7 == 0 |
| // result: (RotateLeft8 x (Neg8 <y.Type> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub8 { |
| break |
| } |
| y := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1_0.AuxInt) |
| if !(c&7 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNeg8, y.Type) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft8 x (Const64 <t> [c])) |
| // cond: config.PtrSize == 4 |
| // result: (RotateLeft8 x (Const32 <t> [int32(c)])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_1.Type |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(config.PtrSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(int32(c)) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft8 (RotateLeft8 x c) d) |
| // cond: c.Type.Size() == 8 && d.Type.Size() == 8 |
| // result: (RotateLeft8 x (Add64 <c.Type> c d)) |
| for { |
| if v_0.Op != ssaop.OpRotateLeft8 { |
| break |
| } |
| c := v_0.Args[1] |
| x := v_0.Args[0] |
| d := v_1 |
| if !(c.Type.Size() == 8 && d.Type.Size() == 8) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, c.Type) |
| v0.AddArg2(c, d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft8 (RotateLeft8 x c) d) |
| // cond: c.Type.Size() == 4 && d.Type.Size() == 4 |
| // result: (RotateLeft8 x (Add32 <c.Type> c d)) |
| for { |
| if v_0.Op != ssaop.OpRotateLeft8 { |
| break |
| } |
| c := v_0.Args[1] |
| x := v_0.Args[0] |
| d := v_1 |
| if !(c.Type.Size() == 4 && d.Type.Size() == 4) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, c.Type) |
| v0.AddArg2(c, d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft8 (RotateLeft8 x c) d) |
| // cond: c.Type.Size() == 2 && d.Type.Size() == 2 |
| // result: (RotateLeft8 x (Add16 <c.Type> c d)) |
| for { |
| if v_0.Op != ssaop.OpRotateLeft8 { |
| break |
| } |
| c := v_0.Args[1] |
| x := v_0.Args[0] |
| d := v_1 |
| if !(c.Type.Size() == 2 && d.Type.Size() == 2) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, c.Type) |
| v0.AddArg2(c, d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (RotateLeft8 (RotateLeft8 x c) d) |
| // cond: c.Type.Size() == 1 && d.Type.Size() == 1 |
| // result: (RotateLeft8 x (Add8 <c.Type> c d)) |
| for { |
| if v_0.Op != ssaop.OpRotateLeft8 { |
| break |
| } |
| c := v_0.Args[1] |
| x := v_0.Args[0] |
| d := v_1 |
| if !(c.Type.Size() == 1 && d.Type.Size() == 1) { |
| break |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, c.Type) |
| v0.AddArg2(c, d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRound32F(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Round32F x:(Const32F)) |
| // result: x |
| for { |
| x := v_0 |
| if x.Op != ssaop.OpConst32F { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRound64F(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Round64F x:(Const64F)) |
| // result: x |
| for { |
| x := v_0 |
| if x.Op != ssaop.OpConst64F { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRoundToEven(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (RoundToEven (Const64F [c])) |
| // result: (Const64F [math.RoundToEven(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst64F { |
| break |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64F) |
| v.AuxInt = ssa.Float64ToAuxInt(math.RoundToEven(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh16Ux16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh16Ux16 x (Const16 [c])) |
| // result: (Rsh16Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh16Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh16Ux16 (Const16 [0]) _) |
| // result: (Const16 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh16Ux16 [false] x con:(Const16 [c])) |
| // cond: 0 < c && c < 16 |
| // result: (Rsh16Ux16 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(con.AuxInt) |
| if !(0 < c && c < 16) { |
| break |
| } |
| v.Reset(ssaop.OpRsh16Ux16) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh16Ux32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh16Ux32 x (Const32 [c])) |
| // result: (Rsh16Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh16Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh16Ux32 (Const16 [0]) _) |
| // result: (Const16 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh16Ux32 [false] x con:(Const32 [c])) |
| // cond: 0 < c && c < 16 |
| // result: (Rsh16Ux32 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(con.AuxInt) |
| if !(0 < c && c < 16) { |
| break |
| } |
| v.Reset(ssaop.OpRsh16Ux32) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| 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 (Const16 [c]) (Const64 [d])) |
| // result: (Const16 [int16(uint16(c) >> uint64(d))]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(int16(uint16(c) >> uint64(d))) |
| return true |
| } |
| // match: (Rsh16Ux64 x (Const64 [0])) |
| // result: x |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Rsh16Ux64 (Const16 [0]) _) |
| // result: (Const16 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh16Ux64 _ (Const64 [c])) |
| // cond: uint64(c) >= 16 |
| // result: (Const16 [0]) |
| for { |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(uint64(c) >= 16) { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh16Ux64 <t> (Rsh16Ux64 x (Const64 [c])) (Const64 [d])) |
| // cond: !uaddOvf(c,d) |
| // result: (Rsh16Ux64 x (Const64 <t> [c+d])) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpRsh16Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(!uaddOvf(c, d)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh16Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c + d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh16Ux64 (Rsh16x64 x _) (Const64 <t> [15])) |
| // result: (Rsh16Ux64 x (Const64 <t> [15])) |
| for { |
| if v_0.Op != ssaop.OpRsh16x64 { |
| break |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt64(v_1.AuxInt) != 15 { |
| break |
| } |
| v.Reset(ssaop.OpRsh16Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(15) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh16Ux64 i:(Lsh16x64 x (Const64 [c])) (Const64 [c])) |
| // cond: c >= 0 && c < 16 && i.Uses == 1 |
| // result: (And16 x (Const16 <v.Type> [int16(^uint16(0)>>c)])) |
| for { |
| i := v_0 |
| if i.Op != ssaop.OpLsh16x64 { |
| break |
| } |
| _ = i.Args[1] |
| x := i.Args[0] |
| i_1 := i.Args[1] |
| if i_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(i_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 16 && i.Uses == 1) { |
| break |
| } |
| v.Reset(ssaop.OpAnd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, v.Type) |
| v0.AuxInt = ssa.Int16ToAuxInt(int16(^uint16(0) >> c)) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh16Ux64 (Lsh16x64 (Rsh16Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) |
| // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) |
| // result: (Rsh16Ux64 x (Const64 <typ.UInt64> [c1-c2+c3])) |
| for { |
| if v_0.Op != ssaop.OpLsh16x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpRsh16Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c1 := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c2 := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c3 := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh16Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(c1 - c2 + c3) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh16Ux64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) |
| // result: (ZeroExt8to16 (Trunc16to8 <typ.UInt8> x)) |
| for { |
| if v_0.Op != ssaop.OpLsh16x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 8 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 8 { |
| break |
| } |
| v.Reset(ssaop.OpZeroExt8to16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpTrunc16to8, typ.UInt8) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Rsh16Ux64 [false] x con:(Const64 [c])) |
| // cond: 0 < c && c < 16 |
| // result: (Rsh16Ux64 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(con.AuxInt) |
| if !(0 < c && c < 16) { |
| break |
| } |
| v.Reset(ssaop.OpRsh16Ux64) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh16Ux8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh16Ux8 x (Const8 [c])) |
| // result: (Rsh16Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh16Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh16Ux8 (Const16 [0]) _) |
| // result: (Const16 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh16Ux8 [false] x con:(Const8 [c])) |
| // cond: 0 < c && c < 16 |
| // result: (Rsh16Ux8 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(con.AuxInt) |
| if !(0 < c && c < 16) { |
| break |
| } |
| v.Reset(ssaop.OpRsh16Ux8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh16x16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh16x16 x (Const16 [c])) |
| // result: (Rsh16x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh16x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh16x16 (Const16 [0]) _) |
| // result: (Const16 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh16x16 [false] x con:(Const16 [c])) |
| // cond: 0 < c && c < 16 |
| // result: (Rsh16x16 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(con.AuxInt) |
| if !(0 < c && c < 16) { |
| break |
| } |
| v.Reset(ssaop.OpRsh16x16) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh16x32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh16x32 x (Const32 [c])) |
| // result: (Rsh16x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh16x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh16x32 (Const16 [0]) _) |
| // result: (Const16 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh16x32 [false] x con:(Const32 [c])) |
| // cond: 0 < c && c < 16 |
| // result: (Rsh16x32 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(con.AuxInt) |
| if !(0 < c && c < 16) { |
| break |
| } |
| v.Reset(ssaop.OpRsh16x32) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| 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 (Const16 [c]) (Const64 [d])) |
| // result: (Const16 [c >> uint64(d)]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(c >> uint64(d)) |
| return true |
| } |
| // match: (Rsh16x64 x (Const64 [0])) |
| // result: x |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Rsh16x64 (Const16 [0]) _) |
| // result: (Const16 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh16x64 <t> (Rsh16x64 x (Const64 [c])) (Const64 [d])) |
| // cond: !uaddOvf(c,d) |
| // result: (Rsh16x64 x (Const64 <t> [c+d])) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpRsh16x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(!uaddOvf(c, d)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh16x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c + d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh16x64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) |
| // result: (SignExt8to16 (Trunc16to8 <typ.Int8> x)) |
| for { |
| if v_0.Op != ssaop.OpLsh16x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 8 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 8 { |
| break |
| } |
| v.Reset(ssaop.OpSignExt8to16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpTrunc16to8, typ.Int8) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Rsh16x64 [false] x con:(Const64 [c])) |
| // cond: 0 < c && c < 16 |
| // result: (Rsh16x64 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(con.AuxInt) |
| if !(0 < c && c < 16) { |
| break |
| } |
| v.Reset(ssaop.OpRsh16x64) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh16x8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh16x8 x (Const8 [c])) |
| // result: (Rsh16x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh16x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh16x8 (Const16 [0]) _) |
| // result: (Const16 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh16x8 [false] x con:(Const8 [c])) |
| // cond: 0 < c && c < 16 |
| // result: (Rsh16x8 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(con.AuxInt) |
| if !(0 < c && c < 16) { |
| break |
| } |
| v.Reset(ssaop.OpRsh16x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh32Ux16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh32Ux16 x (Const16 [c])) |
| // result: (Rsh32Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh32Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh32Ux16 (Const32 [0]) _) |
| // result: (Const32 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh32Ux16 [false] x con:(Const16 [c])) |
| // cond: 0 < c && c < 32 |
| // result: (Rsh32Ux16 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(con.AuxInt) |
| if !(0 < c && c < 32) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32Ux16) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh32Ux32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh32Ux32 x (Const32 [c])) |
| // result: (Rsh32Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh32Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh32Ux32 (Const32 [0]) _) |
| // result: (Const32 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh32Ux32 [false] x con:(Const32 [c])) |
| // cond: 0 < c && c < 32 |
| // result: (Rsh32Ux32 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(con.AuxInt) |
| if !(0 < c && c < 32) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32Ux32) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| 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 (Const32 [c]) (Const64 [d])) |
| // result: (Const32 [int32(uint32(c) >> uint64(d))]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(uint32(c) >> uint64(d))) |
| return true |
| } |
| // match: (Rsh32Ux64 x (Const64 [0])) |
| // result: x |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Rsh32Ux64 (Const32 [0]) _) |
| // result: (Const32 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh32Ux64 _ (Const64 [c])) |
| // cond: uint64(c) >= 32 |
| // result: (Const32 [0]) |
| for { |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(uint64(c) >= 32) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh32Ux64 <t> (Rsh32Ux64 x (Const64 [c])) (Const64 [d])) |
| // cond: !uaddOvf(c,d) |
| // result: (Rsh32Ux64 x (Const64 <t> [c+d])) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpRsh32Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(!uaddOvf(c, d)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c + d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh32Ux64 (Rsh32x64 x _) (Const64 <t> [31])) |
| // result: (Rsh32Ux64 x (Const64 <t> [31])) |
| for { |
| if v_0.Op != ssaop.OpRsh32x64 { |
| break |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt64(v_1.AuxInt) != 31 { |
| break |
| } |
| v.Reset(ssaop.OpRsh32Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(31) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh32Ux64 i:(Lsh32x64 x (Const64 [c])) (Const64 [c])) |
| // cond: c >= 0 && c < 32 && i.Uses == 1 |
| // result: (And32 x (Const32 <v.Type> [int32(^uint32(0)>>c)])) |
| for { |
| i := v_0 |
| if i.Op != ssaop.OpLsh32x64 { |
| break |
| } |
| _ = i.Args[1] |
| x := i.Args[0] |
| i_1 := i.Args[1] |
| if i_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(i_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 32 && i.Uses == 1) { |
| break |
| } |
| v.Reset(ssaop.OpAnd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, v.Type) |
| v0.AuxInt = ssa.Int32ToAuxInt(int32(^uint32(0) >> c)) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh32Ux64 (Lsh32x64 (Rsh32Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) |
| // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) |
| // result: (Rsh32Ux64 x (Const64 <typ.UInt64> [c1-c2+c3])) |
| for { |
| if v_0.Op != ssaop.OpLsh32x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c1 := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c2 := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c3 := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(c1 - c2 + c3) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh32Ux64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) |
| // result: (ZeroExt8to32 (Trunc32to8 <typ.UInt8> x)) |
| for { |
| if v_0.Op != ssaop.OpLsh32x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 24 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 24 { |
| break |
| } |
| v.Reset(ssaop.OpZeroExt8to32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpTrunc32to8, typ.UInt8) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Rsh32Ux64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) |
| // result: (ZeroExt16to32 (Trunc32to16 <typ.UInt16> x)) |
| for { |
| if v_0.Op != ssaop.OpLsh32x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 16 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 16 { |
| break |
| } |
| v.Reset(ssaop.OpZeroExt16to32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpTrunc32to16, typ.UInt16) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Rsh32Ux64 [false] x con:(Const64 [c])) |
| // cond: 0 < c && c < 32 |
| // result: (Rsh32Ux64 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(con.AuxInt) |
| if !(0 < c && c < 32) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32Ux64) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh32Ux8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh32Ux8 x (Const8 [c])) |
| // result: (Rsh32Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh32Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh32Ux8 (Const32 [0]) _) |
| // result: (Const32 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh32Ux8 [false] x con:(Const8 [c])) |
| // cond: 0 < c && c < 32 |
| // result: (Rsh32Ux8 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(con.AuxInt) |
| if !(0 < c && c < 32) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32Ux8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh32x16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh32x16 x (Const16 [c])) |
| // result: (Rsh32x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh32x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh32x16 (Const32 [0]) _) |
| // result: (Const32 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh32x16 [false] x con:(Const16 [c])) |
| // cond: 0 < c && c < 32 |
| // result: (Rsh32x16 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(con.AuxInt) |
| if !(0 < c && c < 32) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32x16) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh32x32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh32x32 x (Const32 [c])) |
| // result: (Rsh32x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh32x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh32x32 (Const32 [0]) _) |
| // result: (Const32 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh32x32 [false] x con:(Const32 [c])) |
| // cond: 0 < c && c < 32 |
| // result: (Rsh32x32 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(con.AuxInt) |
| if !(0 < c && c < 32) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32x32) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| 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 (Const32 [c]) (Const64 [d])) |
| // result: (Const32 [c >> uint64(d)]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(c >> uint64(d)) |
| return true |
| } |
| // match: (Rsh32x64 x (Const64 [0])) |
| // result: x |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Rsh32x64 (Const32 [0]) _) |
| // result: (Const32 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh32x64 <t> (Rsh32x64 x (Const64 [c])) (Const64 [d])) |
| // cond: !uaddOvf(c,d) |
| // result: (Rsh32x64 x (Const64 <t> [c+d])) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpRsh32x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(!uaddOvf(c, d)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c + d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh32x64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) |
| // result: (SignExt8to32 (Trunc32to8 <typ.Int8> x)) |
| for { |
| if v_0.Op != ssaop.OpLsh32x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 24 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 24 { |
| break |
| } |
| v.Reset(ssaop.OpSignExt8to32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpTrunc32to8, typ.Int8) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Rsh32x64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) |
| // result: (SignExt16to32 (Trunc32to16 <typ.Int16> x)) |
| for { |
| if v_0.Op != ssaop.OpLsh32x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 16 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 16 { |
| break |
| } |
| v.Reset(ssaop.OpSignExt16to32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpTrunc32to16, typ.Int16) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Rsh32x64 [false] x con:(Const64 [c])) |
| // cond: 0 < c && c < 32 |
| // result: (Rsh32x64 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(con.AuxInt) |
| if !(0 < c && c < 32) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32x64) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh32x8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh32x8 x (Const8 [c])) |
| // result: (Rsh32x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh32x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh32x8 (Const32 [0]) _) |
| // result: (Const32 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh32x8 [false] x con:(Const8 [c])) |
| // cond: 0 < c && c < 32 |
| // result: (Rsh32x8 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(con.AuxInt) |
| if !(0 < c && c < 32) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh64Ux16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh64Ux16 x (Const16 [c])) |
| // result: (Rsh64Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh64Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh64Ux16 (Const64 [0]) _) |
| // result: (Const64 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh64Ux16 [false] x con:(Const16 [c])) |
| // cond: 0 < c && c < 64 |
| // result: (Rsh64Ux16 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(con.AuxInt) |
| if !(0 < c && c < 64) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64Ux16) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh64Ux32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh64Ux32 x (Const32 [c])) |
| // result: (Rsh64Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh64Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh64Ux32 (Const64 [0]) _) |
| // result: (Const64 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh64Ux32 [false] x con:(Const32 [c])) |
| // cond: 0 < c && c < 64 |
| // result: (Rsh64Ux32 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(con.AuxInt) |
| if !(0 < c && c < 64) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64Ux32) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| 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 (Const64 [c]) (Const64 [d])) |
| // result: (Const64 [int64(uint64(c) >> uint64(d))]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(uint64(c) >> uint64(d))) |
| return true |
| } |
| // match: (Rsh64Ux64 x (Const64 [0])) |
| // result: x |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Rsh64Ux64 (Const64 [0]) _) |
| // result: (Const64 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh64Ux64 _ (Const64 [c])) |
| // cond: uint64(c) >= 64 |
| // result: (Const64 [0]) |
| for { |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(uint64(c) >= 64) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh64Ux64 <t> (Rsh64Ux64 x (Const64 [c])) (Const64 [d])) |
| // cond: !uaddOvf(c,d) |
| // result: (Rsh64Ux64 x (Const64 <t> [c+d])) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpRsh64Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(!uaddOvf(c, d)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c + d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh64Ux64 (Rsh64x64 x _) (Const64 <t> [63])) |
| // result: (Rsh64Ux64 x (Const64 <t> [63])) |
| for { |
| if v_0.Op != ssaop.OpRsh64x64 { |
| break |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt64(v_1.AuxInt) != 63 { |
| break |
| } |
| v.Reset(ssaop.OpRsh64Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(63) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh64Ux64 i:(Lsh64x64 x (Const64 [c])) (Const64 [c])) |
| // cond: c >= 0 && c < 64 && i.Uses == 1 |
| // result: (And64 x (Const64 <v.Type> [int64(^uint64(0)>>c)])) |
| for { |
| i := v_0 |
| if i.Op != ssaop.OpLsh64x64 { |
| break |
| } |
| _ = i.Args[1] |
| x := i.Args[0] |
| i_1 := i.Args[1] |
| if i_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(i_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 64 && i.Uses == 1) { |
| break |
| } |
| v.Reset(ssaop.OpAnd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, v.Type) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(^uint64(0) >> c)) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh64Ux64 (Lsh64x64 (Rsh64Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) |
| // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) |
| // result: (Rsh64Ux64 x (Const64 <typ.UInt64> [c1-c2+c3])) |
| for { |
| if v_0.Op != ssaop.OpLsh64x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c1 := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c2 := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c3 := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(c1 - c2 + c3) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh64Ux64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) |
| // result: (ZeroExt8to64 (Trunc64to8 <typ.UInt8> x)) |
| for { |
| if v_0.Op != ssaop.OpLsh64x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 56 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 56 { |
| break |
| } |
| v.Reset(ssaop.OpZeroExt8to64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpTrunc64to8, typ.UInt8) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Rsh64Ux64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) |
| // result: (ZeroExt16to64 (Trunc64to16 <typ.UInt16> x)) |
| for { |
| if v_0.Op != ssaop.OpLsh64x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 48 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 48 { |
| break |
| } |
| v.Reset(ssaop.OpZeroExt16to64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpTrunc64to16, typ.UInt16) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Rsh64Ux64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) |
| // result: (ZeroExt32to64 (Trunc64to32 <typ.UInt32> x)) |
| for { |
| if v_0.Op != ssaop.OpLsh64x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 32 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 32 { |
| break |
| } |
| v.Reset(ssaop.OpZeroExt32to64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpTrunc64to32, typ.UInt32) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Rsh64Ux64 [false] x con:(Const64 [c])) |
| // cond: 0 < c && c < 64 |
| // result: (Rsh64Ux64 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(con.AuxInt) |
| if !(0 < c && c < 64) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64Ux64) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh64Ux8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh64Ux8 x (Const8 [c])) |
| // result: (Rsh64Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh64Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh64Ux8 (Const64 [0]) _) |
| // result: (Const64 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh64Ux8 [false] x con:(Const8 [c])) |
| // cond: 0 < c && c < 64 |
| // result: (Rsh64Ux8 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(con.AuxInt) |
| if !(0 < c && c < 64) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64Ux8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh64x16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh64x16 x (Const16 [c])) |
| // result: (Rsh64x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh64x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh64x16 (Const64 [0]) _) |
| // result: (Const64 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh64x16 [false] x con:(Const16 [c])) |
| // cond: 0 < c && c < 64 |
| // result: (Rsh64x16 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(con.AuxInt) |
| if !(0 < c && c < 64) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64x16) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh64x32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh64x32 x (Const32 [c])) |
| // result: (Rsh64x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh64x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh64x32 (Const64 [0]) _) |
| // result: (Const64 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh64x32 [false] x con:(Const32 [c])) |
| // cond: 0 < c && c < 64 |
| // result: (Rsh64x32 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(con.AuxInt) |
| if !(0 < c && c < 64) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64x32) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| 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 (Const64 [c]) (Const64 [d])) |
| // result: (Const64 [c >> uint64(d)]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(c >> uint64(d)) |
| return true |
| } |
| // match: (Rsh64x64 x (Const64 [0])) |
| // result: x |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Rsh64x64 (Const64 [0]) _) |
| // result: (Const64 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh64x64 <t> (Rsh64x64 x (Const64 [c])) (Const64 [d])) |
| // cond: !uaddOvf(c,d) |
| // result: (Rsh64x64 x (Const64 <t> [c+d])) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpRsh64x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(!uaddOvf(c, d)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c + d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh64x64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) |
| // result: (SignExt8to64 (Trunc64to8 <typ.Int8> x)) |
| for { |
| if v_0.Op != ssaop.OpLsh64x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 56 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 56 { |
| break |
| } |
| v.Reset(ssaop.OpSignExt8to64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpTrunc64to8, typ.Int8) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Rsh64x64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) |
| // result: (SignExt16to64 (Trunc64to16 <typ.Int16> x)) |
| for { |
| if v_0.Op != ssaop.OpLsh64x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 48 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 48 { |
| break |
| } |
| v.Reset(ssaop.OpSignExt16to64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpTrunc64to16, typ.Int16) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Rsh64x64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) |
| // result: (SignExt32to64 (Trunc64to32 <typ.Int32> x)) |
| for { |
| if v_0.Op != ssaop.OpLsh64x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0_1.AuxInt) != 32 || v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 32 { |
| break |
| } |
| v.Reset(ssaop.OpSignExt32to64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpTrunc64to32, typ.Int32) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Rsh64x64 [false] x con:(Const64 [c])) |
| // cond: 0 < c && c < 64 |
| // result: (Rsh64x64 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(con.AuxInt) |
| if !(0 < c && c < 64) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64x64) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh64x8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh64x8 x (Const8 [c])) |
| // result: (Rsh64x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh64x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh64x8 (Const64 [0]) _) |
| // result: (Const64 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh64x8 [false] x con:(Const8 [c])) |
| // cond: 0 < c && c < 64 |
| // result: (Rsh64x8 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(con.AuxInt) |
| if !(0 < c && c < 64) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh8Ux16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh8Ux16 x (Const16 [c])) |
| // result: (Rsh8Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh8Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh8Ux16 (Const8 [0]) _) |
| // result: (Const8 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh8Ux16 [false] x con:(Const16 [c])) |
| // cond: 0 < c && c < 8 |
| // result: (Rsh8Ux16 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(con.AuxInt) |
| if !(0 < c && c < 8) { |
| break |
| } |
| v.Reset(ssaop.OpRsh8Ux16) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh8Ux32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh8Ux32 x (Const32 [c])) |
| // result: (Rsh8Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh8Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh8Ux32 (Const8 [0]) _) |
| // result: (Const8 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh8Ux32 [false] x con:(Const32 [c])) |
| // cond: 0 < c && c < 8 |
| // result: (Rsh8Ux32 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(con.AuxInt) |
| if !(0 < c && c < 8) { |
| break |
| } |
| v.Reset(ssaop.OpRsh8Ux32) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| 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 (Const8 [c]) (Const64 [d])) |
| // result: (Const8 [int8(uint8(c) >> uint64(d))]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(int8(uint8(c) >> uint64(d))) |
| return true |
| } |
| // match: (Rsh8Ux64 x (Const64 [0])) |
| // result: x |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Rsh8Ux64 (Const8 [0]) _) |
| // result: (Const8 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh8Ux64 _ (Const64 [c])) |
| // cond: uint64(c) >= 8 |
| // result: (Const8 [0]) |
| for { |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(uint64(c) >= 8) { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh8Ux64 <t> (Rsh8Ux64 x (Const64 [c])) (Const64 [d])) |
| // cond: !uaddOvf(c,d) |
| // result: (Rsh8Ux64 x (Const64 <t> [c+d])) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpRsh8Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(!uaddOvf(c, d)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh8Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c + d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh8Ux64 (Rsh8x64 x _) (Const64 <t> [7] )) |
| // result: (Rsh8Ux64 x (Const64 <t> [7] )) |
| for { |
| if v_0.Op != ssaop.OpRsh8x64 { |
| break |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_1.Type |
| if ssa.AuxIntToInt64(v_1.AuxInt) != 7 { |
| break |
| } |
| v.Reset(ssaop.OpRsh8Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(7) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh8Ux64 i:(Lsh8x64 x (Const64 [c])) (Const64 [c])) |
| // cond: c >= 0 && c < 8 && i.Uses == 1 |
| // result: (And8 x (Const8 <v.Type> [int8 (^uint8 (0)>>c)])) |
| for { |
| i := v_0 |
| if i.Op != ssaop.OpLsh8x64 { |
| break |
| } |
| _ = i.Args[1] |
| x := i.Args[0] |
| i_1 := i.Args[1] |
| if i_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(i_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != c || !(c >= 0 && c < 8 && i.Uses == 1) { |
| break |
| } |
| v.Reset(ssaop.OpAnd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, v.Type) |
| v0.AuxInt = ssa.Int8ToAuxInt(int8(^uint8(0) >> c)) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh8Ux64 (Lsh8x64 (Rsh8Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) |
| // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) |
| // result: (Rsh8Ux64 x (Const64 <typ.UInt64> [c1-c2+c3])) |
| for { |
| if v_0.Op != ssaop.OpLsh8x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpRsh8Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| x := v_0_0.Args[0] |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c1 := ssa.AuxIntToInt64(v_0_0_1.AuxInt) |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c2 := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c3 := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh8Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v0.AuxInt = ssa.Int64ToAuxInt(c1 - c2 + c3) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh8Ux64 [false] x con:(Const64 [c])) |
| // cond: 0 < c && c < 8 |
| // result: (Rsh8Ux64 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(con.AuxInt) |
| if !(0 < c && c < 8) { |
| break |
| } |
| v.Reset(ssaop.OpRsh8Ux64) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh8Ux8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh8Ux8 x (Const8 [c])) |
| // result: (Rsh8Ux64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh8Ux64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh8Ux8 (Const8 [0]) _) |
| // result: (Const8 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh8Ux8 [false] x con:(Const8 [c])) |
| // cond: 0 < c && c < 8 |
| // result: (Rsh8Ux8 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(con.AuxInt) |
| if !(0 < c && c < 8) { |
| break |
| } |
| v.Reset(ssaop.OpRsh8Ux8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh8x16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh8x16 x (Const16 [c])) |
| // result: (Rsh8x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint16(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh8x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh8x16 (Const8 [0]) _) |
| // result: (Const8 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh8x16 [false] x con:(Const16 [c])) |
| // cond: 0 < c && c < 8 |
| // result: (Rsh8x16 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(con.AuxInt) |
| if !(0 < c && c < 8) { |
| break |
| } |
| v.Reset(ssaop.OpRsh8x16) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh8x32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh8x32 x (Const32 [c])) |
| // result: (Rsh8x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint32(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh8x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh8x32 (Const8 [0]) _) |
| // result: (Const8 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh8x32 [false] x con:(Const32 [c])) |
| // cond: 0 < c && c < 8 |
| // result: (Rsh8x32 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(con.AuxInt) |
| if !(0 < c && c < 8) { |
| break |
| } |
| v.Reset(ssaop.OpRsh8x32) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh8x64(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh8x64 (Const8 [c]) (Const64 [d])) |
| // result: (Const8 [c >> uint64(d)]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(c >> uint64(d)) |
| return true |
| } |
| // match: (Rsh8x64 x (Const64 [0])) |
| // result: x |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Rsh8x64 (Const8 [0]) _) |
| // result: (Const8 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh8x64 <t> (Rsh8x64 x (Const64 [c])) (Const64 [d])) |
| // cond: !uaddOvf(c,d) |
| // result: (Rsh8x64 x (Const64 <t> [c+d])) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpRsh8x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(!uaddOvf(c, d)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh8x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c + d) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh8x64 [false] x con:(Const64 [c])) |
| // cond: 0 < c && c < 8 |
| // result: (Rsh8x64 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(con.AuxInt) |
| if !(0 < c && c < 8) { |
| break |
| } |
| v.Reset(ssaop.OpRsh8x64) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpRsh8x8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Rsh8x8 x (Const8 [c])) |
| // result: (Rsh8x64 x (Const64 <types.Types[types.TUINT64]> [int64(uint8(c))])) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpRsh8x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, types.Types[types.TUINT64]) |
| v0.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c))) |
| v.AddArg2(x, v0) |
| return true |
| } |
| // match: (Rsh8x8 (Const8 [0]) _) |
| // result: (Const8 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Rsh8x8 [false] x con:(Const8 [c])) |
| // cond: 0 < c && c < 8 |
| // result: (Rsh8x8 [true] x con) |
| for { |
| if ssa.AuxIntToBool(v.AuxInt) != false { |
| break |
| } |
| x := v_0 |
| con := v_1 |
| if con.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(con.AuxInt) |
| if !(0 < c && c < 8) { |
| break |
| } |
| v.Reset(ssaop.OpRsh8x8) |
| v.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(x, con) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpSelect0(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Select0 a:(Add64carry x y (Const64 [0]))) |
| // cond: a.Uses == 1 |
| // result: (Add64 x y) |
| for { |
| a := v_0 |
| if a.Op != ssaop.OpAdd64carry { |
| break |
| } |
| _ = a.Args[2] |
| x := a.Args[0] |
| y := a.Args[1] |
| a_2 := a.Args[2] |
| if a_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(a_2.AuxInt) != 0 || !(a.Uses == 1) { |
| break |
| } |
| v.Reset(ssaop.OpAdd64) |
| v.AddArg2(x, y) |
| return true |
| } |
| // 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_OpSelectN(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| typ := &b.Func.Config.Types |
| // match: (SelectN [n] m:(MakeResult ___)) |
| // result: m.Args[n] |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| m := v_0 |
| if m.Op != ssaop.OpMakeResult { |
| break |
| } |
| v.CopyOf(m.Args[n]) |
| return true |
| } |
| // match: (SelectN [0] call:(StaticCall {sym} sptr (Const64 [c]) mem)) |
| // cond: isInlinableMemclr(config, int64(c)) && ssa.IsSameCall(sym, "runtime.memclrNoHeapPointers") && call.Uses == 1 && ssa.Clobber(call) |
| // result: (Zero {types.Types[types.TUINT8]} [int64(c)] sptr mem) |
| for { |
| if ssa.AuxIntToInt64(v.AuxInt) != 0 { |
| break |
| } |
| call := v_0 |
| if call.Op != ssaop.OpStaticCall || len(call.Args) != 3 { |
| break |
| } |
| sym := ssa.AuxToCall(call.Aux) |
| mem := call.Args[2] |
| sptr := call.Args[0] |
| call_1 := call.Args[1] |
| if call_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(call_1.AuxInt) |
| if !(isInlinableMemclr(config, int64(c)) && ssa.IsSameCall(sym, "runtime.memclrNoHeapPointers") && call.Uses == 1 && ssa.Clobber(call)) { |
| break |
| } |
| v.Reset(ssaop.OpZero) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(c)) |
| v.Aux = ssa.TypeToAux(types.Types[types.TUINT8]) |
| v.AddArg2(sptr, mem) |
| return true |
| } |
| // match: (SelectN [0] call:(StaticCall {sym} sptr (Const32 [c]) mem)) |
| // cond: isInlinableMemclr(config, int64(c)) && ssa.IsSameCall(sym, "runtime.memclrNoHeapPointers") && call.Uses == 1 && ssa.Clobber(call) |
| // result: (Zero {types.Types[types.TUINT8]} [int64(c)] sptr mem) |
| for { |
| if ssa.AuxIntToInt64(v.AuxInt) != 0 { |
| break |
| } |
| call := v_0 |
| if call.Op != ssaop.OpStaticCall || len(call.Args) != 3 { |
| break |
| } |
| sym := ssa.AuxToCall(call.Aux) |
| mem := call.Args[2] |
| sptr := call.Args[0] |
| call_1 := call.Args[1] |
| if call_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(call_1.AuxInt) |
| if !(isInlinableMemclr(config, int64(c)) && ssa.IsSameCall(sym, "runtime.memclrNoHeapPointers") && call.Uses == 1 && ssa.Clobber(call)) { |
| break |
| } |
| v.Reset(ssaop.OpZero) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(c)) |
| v.Aux = ssa.TypeToAux(types.Types[types.TUINT8]) |
| v.AddArg2(sptr, mem) |
| return true |
| } |
| // match: (SelectN [0] call:(StaticCall {sym} s1:(Store _ (Const64 [sz]) s2:(Store _ src s3:(Store {t} _ dst mem))))) |
| // cond: sz >= 0 && ssa.IsSameCall(sym, "runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(s1, s2, s3, call) |
| // result: (Move {types.Types[types.TUINT8]} [int64(sz)] dst src mem) |
| for { |
| if ssa.AuxIntToInt64(v.AuxInt) != 0 { |
| break |
| } |
| call := v_0 |
| if call.Op != ssaop.OpStaticCall || len(call.Args) != 1 { |
| break |
| } |
| sym := ssa.AuxToCall(call.Aux) |
| s1 := call.Args[0] |
| if s1.Op != ssaop.OpStore { |
| break |
| } |
| _ = s1.Args[2] |
| s1_1 := s1.Args[1] |
| if s1_1.Op != ssaop.OpConst64 { |
| break |
| } |
| sz := ssa.AuxIntToInt64(s1_1.AuxInt) |
| s2 := s1.Args[2] |
| if s2.Op != ssaop.OpStore { |
| break |
| } |
| _ = s2.Args[2] |
| src := s2.Args[1] |
| s3 := s2.Args[2] |
| if s3.Op != ssaop.OpStore { |
| break |
| } |
| mem := s3.Args[2] |
| dst := s3.Args[1] |
| if !(sz >= 0 && ssa.IsSameCall(sym, "runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(s1, s2, s3, call)) { |
| break |
| } |
| v.Reset(ssaop.OpMove) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(sz)) |
| v.Aux = ssa.TypeToAux(types.Types[types.TUINT8]) |
| v.AddArg3(dst, src, mem) |
| return true |
| } |
| // match: (SelectN [0] call:(StaticCall {sym} s1:(Store _ (Const32 [sz]) s2:(Store _ src s3:(Store {t} _ dst mem))))) |
| // cond: sz >= 0 && ssa.IsSameCall(sym, "runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(s1, s2, s3, call) |
| // result: (Move {types.Types[types.TUINT8]} [int64(sz)] dst src mem) |
| for { |
| if ssa.AuxIntToInt64(v.AuxInt) != 0 { |
| break |
| } |
| call := v_0 |
| if call.Op != ssaop.OpStaticCall || len(call.Args) != 1 { |
| break |
| } |
| sym := ssa.AuxToCall(call.Aux) |
| s1 := call.Args[0] |
| if s1.Op != ssaop.OpStore { |
| break |
| } |
| _ = s1.Args[2] |
| s1_1 := s1.Args[1] |
| if s1_1.Op != ssaop.OpConst32 { |
| break |
| } |
| sz := ssa.AuxIntToInt32(s1_1.AuxInt) |
| s2 := s1.Args[2] |
| if s2.Op != ssaop.OpStore { |
| break |
| } |
| _ = s2.Args[2] |
| src := s2.Args[1] |
| s3 := s2.Args[2] |
| if s3.Op != ssaop.OpStore { |
| break |
| } |
| mem := s3.Args[2] |
| dst := s3.Args[1] |
| if !(sz >= 0 && ssa.IsSameCall(sym, "runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(s1, s2, s3, call)) { |
| break |
| } |
| v.Reset(ssaop.OpMove) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(sz)) |
| v.Aux = ssa.TypeToAux(types.Types[types.TUINT8]) |
| v.AddArg3(dst, src, mem) |
| return true |
| } |
| // match: (SelectN [0] call:(StaticCall {sym} dst src (Const64 [sz]) mem)) |
| // cond: sz >= 0 && call.Uses == 1 && ssa.IsSameCall(sym, "runtime.memmove") && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(call) |
| // result: (Move {types.Types[types.TUINT8]} [int64(sz)] dst src mem) |
| for { |
| if ssa.AuxIntToInt64(v.AuxInt) != 0 { |
| break |
| } |
| call := v_0 |
| if call.Op != ssaop.OpStaticCall || len(call.Args) != 4 { |
| break |
| } |
| sym := ssa.AuxToCall(call.Aux) |
| mem := call.Args[3] |
| dst := call.Args[0] |
| src := call.Args[1] |
| call_2 := call.Args[2] |
| if call_2.Op != ssaop.OpConst64 { |
| break |
| } |
| sz := ssa.AuxIntToInt64(call_2.AuxInt) |
| if !(sz >= 0 && call.Uses == 1 && ssa.IsSameCall(sym, "runtime.memmove") && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(call)) { |
| break |
| } |
| v.Reset(ssaop.OpMove) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(sz)) |
| v.Aux = ssa.TypeToAux(types.Types[types.TUINT8]) |
| v.AddArg3(dst, src, mem) |
| return true |
| } |
| // match: (SelectN [0] call:(StaticCall {sym} dst src (Const32 [sz]) mem)) |
| // cond: sz >= 0 && call.Uses == 1 && ssa.IsSameCall(sym, "runtime.memmove") && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(call) |
| // result: (Move {types.Types[types.TUINT8]} [int64(sz)] dst src mem) |
| for { |
| if ssa.AuxIntToInt64(v.AuxInt) != 0 { |
| break |
| } |
| call := v_0 |
| if call.Op != ssaop.OpStaticCall || len(call.Args) != 4 { |
| break |
| } |
| sym := ssa.AuxToCall(call.Aux) |
| mem := call.Args[3] |
| dst := call.Args[0] |
| src := call.Args[1] |
| call_2 := call.Args[2] |
| if call_2.Op != ssaop.OpConst32 { |
| break |
| } |
| sz := ssa.AuxIntToInt32(call_2.AuxInt) |
| if !(sz >= 0 && call.Uses == 1 && ssa.IsSameCall(sym, "runtime.memmove") && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(call)) { |
| break |
| } |
| v.Reset(ssaop.OpMove) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(sz)) |
| v.Aux = ssa.TypeToAux(types.Types[types.TUINT8]) |
| v.AddArg3(dst, src, mem) |
| return true |
| } |
| // match: (SelectN [0] call:(StaticLECall {sym} dst src (Const64 [sz]) mem)) |
| // cond: sz >= 0 && call.Uses == 1 && ssa.IsSameCall(sym, "runtime.memmove") && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(call) |
| // result: (Move {types.Types[types.TUINT8]} [int64(sz)] dst src mem) |
| for { |
| if ssa.AuxIntToInt64(v.AuxInt) != 0 { |
| break |
| } |
| call := v_0 |
| if call.Op != ssaop.OpStaticLECall || len(call.Args) != 4 { |
| break |
| } |
| sym := ssa.AuxToCall(call.Aux) |
| mem := call.Args[3] |
| dst := call.Args[0] |
| src := call.Args[1] |
| call_2 := call.Args[2] |
| if call_2.Op != ssaop.OpConst64 { |
| break |
| } |
| sz := ssa.AuxIntToInt64(call_2.AuxInt) |
| if !(sz >= 0 && call.Uses == 1 && ssa.IsSameCall(sym, "runtime.memmove") && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(call)) { |
| break |
| } |
| v.Reset(ssaop.OpMove) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(sz)) |
| v.Aux = ssa.TypeToAux(types.Types[types.TUINT8]) |
| v.AddArg3(dst, src, mem) |
| return true |
| } |
| // match: (SelectN [0] call:(StaticLECall {sym} dst src (Const32 [sz]) mem)) |
| // cond: sz >= 0 && call.Uses == 1 && ssa.IsSameCall(sym, "runtime.memmove") && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(call) |
| // result: (Move {types.Types[types.TUINT8]} [int64(sz)] dst src mem) |
| for { |
| if ssa.AuxIntToInt64(v.AuxInt) != 0 { |
| break |
| } |
| call := v_0 |
| if call.Op != ssaop.OpStaticLECall || len(call.Args) != 4 { |
| break |
| } |
| sym := ssa.AuxToCall(call.Aux) |
| mem := call.Args[3] |
| dst := call.Args[0] |
| src := call.Args[1] |
| call_2 := call.Args[2] |
| if call_2.Op != ssaop.OpConst32 { |
| break |
| } |
| sz := ssa.AuxIntToInt32(call_2.AuxInt) |
| if !(sz >= 0 && call.Uses == 1 && ssa.IsSameCall(sym, "runtime.memmove") && ssa.IsInlinableMemmove(dst, src, int64(sz), config) && ssa.Clobber(call)) { |
| break |
| } |
| v.Reset(ssaop.OpMove) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(sz)) |
| v.Aux = ssa.TypeToAux(types.Types[types.TUINT8]) |
| v.AddArg3(dst, src, mem) |
| return true |
| } |
| // match: (SelectN [0] call:(StaticLECall {sym} a x)) |
| // cond: needRaceCleanup(sym, call) && ssa.Clobber(call) |
| // result: x |
| for { |
| if ssa.AuxIntToInt64(v.AuxInt) != 0 { |
| break |
| } |
| call := v_0 |
| if call.Op != ssaop.OpStaticLECall || len(call.Args) != 2 { |
| break |
| } |
| sym := ssa.AuxToCall(call.Aux) |
| x := call.Args[1] |
| if !(needRaceCleanup(sym, call) && ssa.Clobber(call)) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (SelectN [0] call:(StaticLECall {sym} x)) |
| // cond: needRaceCleanup(sym, call) && ssa.Clobber(call) |
| // result: x |
| for { |
| if ssa.AuxIntToInt64(v.AuxInt) != 0 { |
| break |
| } |
| call := v_0 |
| if call.Op != ssaop.OpStaticLECall || len(call.Args) != 1 { |
| break |
| } |
| sym := ssa.AuxToCall(call.Aux) |
| x := call.Args[0] |
| if !(needRaceCleanup(sym, call) && ssa.Clobber(call)) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (SelectN [1] (StaticCall {sym} _ newLen:(Const64) _ _ _ _)) |
| // cond: v.Type.IsInteger() && (ssa.IsSameCall(sym, "runtime.growslice") || ssa.IsSameCall(sym, "runtime.growsliceNoAlias")) |
| // result: newLen |
| for { |
| if ssa.AuxIntToInt64(v.AuxInt) != 1 || v_0.Op != ssaop.OpStaticCall || len(v_0.Args) != 6 { |
| break |
| } |
| sym := ssa.AuxToCall(v_0.Aux) |
| _ = v_0.Args[1] |
| newLen := v_0.Args[1] |
| if newLen.Op != ssaop.OpConst64 || !(v.Type.IsInteger() && (ssa.IsSameCall(sym, "runtime.growslice") || ssa.IsSameCall(sym, "runtime.growsliceNoAlias"))) { |
| break |
| } |
| v.CopyOf(newLen) |
| return true |
| } |
| // match: (SelectN [1] (StaticCall {sym} _ newLen:(Const32) _ _ _ _)) |
| // cond: v.Type.IsInteger() && (ssa.IsSameCall(sym, "runtime.growslice") || ssa.IsSameCall(sym, "runtime.growsliceNoAlias")) |
| // result: newLen |
| for { |
| if ssa.AuxIntToInt64(v.AuxInt) != 1 || v_0.Op != ssaop.OpStaticCall || len(v_0.Args) != 6 { |
| break |
| } |
| sym := ssa.AuxToCall(v_0.Aux) |
| _ = v_0.Args[1] |
| newLen := v_0.Args[1] |
| if newLen.Op != ssaop.OpConst32 || !(v.Type.IsInteger() && (ssa.IsSameCall(sym, "runtime.growslice") || ssa.IsSameCall(sym, "runtime.growsliceNoAlias"))) { |
| break |
| } |
| v.CopyOf(newLen) |
| return true |
| } |
| // match: (SelectN [0] (StaticLECall {f} x y (SelectN [1] c:(StaticLECall {g} x y mem)))) |
| // cond: ssa.IsSameCall(f, "runtime.cmpstring") && ssa.IsSameCall(g, "runtime.cmpstring") |
| // result: @c.Block (SelectN [0] <typ.Int> c) |
| for { |
| if ssa.AuxIntToInt64(v.AuxInt) != 0 || v_0.Op != ssaop.OpStaticLECall || len(v_0.Args) != 3 { |
| break |
| } |
| f := ssa.AuxToCall(v_0.Aux) |
| _ = v_0.Args[2] |
| x := v_0.Args[0] |
| y := v_0.Args[1] |
| v_0_2 := v_0.Args[2] |
| if v_0_2.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(v_0_2.AuxInt) != 1 { |
| break |
| } |
| c := v_0_2.Args[0] |
| if c.Op != ssaop.OpStaticLECall || len(c.Args) != 3 { |
| break |
| } |
| g := ssa.AuxToCall(c.Aux) |
| if x != c.Args[0] || y != c.Args[1] || !(ssa.IsSameCall(f, "runtime.cmpstring") && ssa.IsSameCall(g, "runtime.cmpstring")) { |
| break |
| } |
| b = c.Block |
| v0 := b.NewValue0(v.Pos, ssaop.OpSelectN, typ.Int) |
| v.CopyOf(v0) |
| v0.AuxInt = ssa.Int64ToAuxInt(0) |
| v0.AddArg(c) |
| return true |
| } |
| // match: (SelectN [1] c:(StaticLECall {f} _ _ mem)) |
| // cond: c.Uses == 1 && ssa.IsSameCall(f, "runtime.cmpstring") && ssa.Clobber(c) |
| // result: mem |
| for { |
| if ssa.AuxIntToInt64(v.AuxInt) != 1 { |
| break |
| } |
| c := v_0 |
| if c.Op != ssaop.OpStaticLECall || len(c.Args) != 3 { |
| break |
| } |
| f := ssa.AuxToCall(c.Aux) |
| mem := c.Args[2] |
| if !(c.Uses == 1 && ssa.IsSameCall(f, "runtime.cmpstring") && ssa.Clobber(c)) { |
| break |
| } |
| v.CopyOf(mem) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpSignExt16to32(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (SignExt16to32 (Const16 [c])) |
| // result: (Const32 [int32(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(c)) |
| return true |
| } |
| // match: (SignExt16to32 (Trunc32to16 x:(Rsh32x64 _ (Const64 [s])))) |
| // cond: s >= 16 |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpTrunc32to16 { |
| break |
| } |
| x := v_0.Args[0] |
| if x.Op != ssaop.OpRsh32x64 { |
| break |
| } |
| _ = x.Args[1] |
| x_1 := x.Args[1] |
| if x_1.Op != ssaop.OpConst64 { |
| break |
| } |
| s := ssa.AuxIntToInt64(x_1.AuxInt) |
| if !(s >= 16) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpSignExt16to64(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (SignExt16to64 (Const16 [c])) |
| // result: (Const64 [int64(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(c)) |
| return true |
| } |
| // match: (SignExt16to64 (Trunc64to16 x:(Rsh64x64 _ (Const64 [s])))) |
| // cond: s >= 48 |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpTrunc64to16 { |
| break |
| } |
| x := v_0.Args[0] |
| if x.Op != ssaop.OpRsh64x64 { |
| break |
| } |
| _ = x.Args[1] |
| x_1 := x.Args[1] |
| if x_1.Op != ssaop.OpConst64 { |
| break |
| } |
| s := ssa.AuxIntToInt64(x_1.AuxInt) |
| if !(s >= 48) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpSignExt32to64(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (SignExt32to64 (Const32 [c])) |
| // result: (Const64 [int64(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(c)) |
| return true |
| } |
| // match: (SignExt32to64 (Trunc64to32 x:(Rsh64x64 _ (Const64 [s])))) |
| // cond: s >= 32 |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpTrunc64to32 { |
| break |
| } |
| x := v_0.Args[0] |
| if x.Op != ssaop.OpRsh64x64 { |
| break |
| } |
| _ = x.Args[1] |
| x_1 := x.Args[1] |
| if x_1.Op != ssaop.OpConst64 { |
| break |
| } |
| s := ssa.AuxIntToInt64(x_1.AuxInt) |
| if !(s >= 32) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpSignExt8to16(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (SignExt8to16 (Const8 [c])) |
| // result: (Const16 [int16(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(int16(c)) |
| return true |
| } |
| // match: (SignExt8to16 (Trunc16to8 x:(Rsh16x64 _ (Const64 [s])))) |
| // cond: s >= 8 |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpTrunc16to8 { |
| break |
| } |
| x := v_0.Args[0] |
| if x.Op != ssaop.OpRsh16x64 { |
| break |
| } |
| _ = x.Args[1] |
| x_1 := x.Args[1] |
| if x_1.Op != ssaop.OpConst64 { |
| break |
| } |
| s := ssa.AuxIntToInt64(x_1.AuxInt) |
| if !(s >= 8) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (SignExt8to16 cvt:(CvtBoolToUint8 bool)) |
| // result: (ZeroExt8to16 cvt) |
| for { |
| cvt := v_0 |
| if cvt.Op != ssaop.OpCvtBoolToUint8 { |
| break |
| } |
| v.Reset(ssaop.OpZeroExt8to16) |
| v.AddArg(cvt) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpSignExt8to32(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (SignExt8to32 (Const8 [c])) |
| // result: (Const32 [int32(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(c)) |
| return true |
| } |
| // match: (SignExt8to32 (Trunc32to8 x:(Rsh32x64 _ (Const64 [s])))) |
| // cond: s >= 24 |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpTrunc32to8 { |
| break |
| } |
| x := v_0.Args[0] |
| if x.Op != ssaop.OpRsh32x64 { |
| break |
| } |
| _ = x.Args[1] |
| x_1 := x.Args[1] |
| if x_1.Op != ssaop.OpConst64 { |
| break |
| } |
| s := ssa.AuxIntToInt64(x_1.AuxInt) |
| if !(s >= 24) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (SignExt8to32 cvt:(CvtBoolToUint8 bool)) |
| // result: (ZeroExt8to32 cvt) |
| for { |
| cvt := v_0 |
| if cvt.Op != ssaop.OpCvtBoolToUint8 { |
| break |
| } |
| v.Reset(ssaop.OpZeroExt8to32) |
| v.AddArg(cvt) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpSignExt8to64(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (SignExt8to64 (Const8 [c])) |
| // result: (Const64 [int64(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(c)) |
| return true |
| } |
| // match: (SignExt8to64 (Trunc64to8 x:(Rsh64x64 _ (Const64 [s])))) |
| // cond: s >= 56 |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpTrunc64to8 { |
| break |
| } |
| x := v_0.Args[0] |
| if x.Op != ssaop.OpRsh64x64 { |
| break |
| } |
| _ = x.Args[1] |
| x_1 := x.Args[1] |
| if x_1.Op != ssaop.OpConst64 { |
| break |
| } |
| s := ssa.AuxIntToInt64(x_1.AuxInt) |
| if !(s >= 56) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (SignExt8to64 cvt:(CvtBoolToUint8 bool)) |
| // result: (ZeroExt8to64 cvt) |
| for { |
| cvt := v_0 |
| if cvt.Op != ssaop.OpCvtBoolToUint8 { |
| break |
| } |
| v.Reset(ssaop.OpZeroExt8to64) |
| v.AddArg(cvt) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpSliceCap(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (SliceCap (SliceMake _ _ (Const64 <t> [c]))) |
| // result: (Const64 <t> [c]) |
| for { |
| if v_0.Op != ssaop.OpSliceMake { |
| break |
| } |
| _ = v_0.Args[2] |
| v_0_2 := v_0.Args[2] |
| if v_0_2.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_0_2.Type |
| c := ssa.AuxIntToInt64(v_0_2.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.Type = t |
| v.AuxInt = ssa.Int64ToAuxInt(c) |
| return true |
| } |
| // match: (SliceCap (SliceMake _ _ (Const32 <t> [c]))) |
| // result: (Const32 <t> [c]) |
| for { |
| if v_0.Op != ssaop.OpSliceMake { |
| break |
| } |
| _ = v_0.Args[2] |
| v_0_2 := v_0.Args[2] |
| if v_0_2.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_0_2.Type |
| c := ssa.AuxIntToInt32(v_0_2.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.Type = t |
| v.AuxInt = ssa.Int32ToAuxInt(c) |
| return true |
| } |
| // match: (SliceCap (SliceMake _ _ (SliceCap x))) |
| // result: (SliceCap x) |
| for { |
| if v_0.Op != ssaop.OpSliceMake { |
| break |
| } |
| _ = v_0.Args[2] |
| v_0_2 := v_0.Args[2] |
| if v_0_2.Op != ssaop.OpSliceCap { |
| break |
| } |
| x := v_0_2.Args[0] |
| v.Reset(ssaop.OpSliceCap) |
| v.AddArg(x) |
| return true |
| } |
| // match: (SliceCap (SliceMake _ _ (SliceLen x))) |
| // result: (SliceLen x) |
| for { |
| if v_0.Op != ssaop.OpSliceMake { |
| break |
| } |
| _ = v_0.Args[2] |
| v_0_2 := v_0.Args[2] |
| if v_0_2.Op != ssaop.OpSliceLen { |
| break |
| } |
| x := v_0_2.Args[0] |
| v.Reset(ssaop.OpSliceLen) |
| v.AddArg(x) |
| return true |
| } |
| // match: (SliceCap (Phi (SliceMake _ _ x) (SliceMake _ _ x))) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpPhi || len(v_0.Args) != 2 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpSliceMake { |
| break |
| } |
| x := v_0_0.Args[2] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpSliceMake { |
| break |
| } |
| _ = v_0_1.Args[2] |
| if x != v_0_1.Args[2] { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpSliceLen(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (SliceLen (SliceMake _ (Const64 <t> [c]) _)) |
| // result: (Const64 <t> [c]) |
| for { |
| if v_0.Op != ssaop.OpSliceMake { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.Type = t |
| v.AuxInt = ssa.Int64ToAuxInt(c) |
| return true |
| } |
| // match: (SliceLen (SliceMake _ (Const32 <t> [c]) _)) |
| // result: (Const32 <t> [c]) |
| for { |
| if v_0.Op != ssaop.OpSliceMake { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_0_1.Type |
| c := ssa.AuxIntToInt32(v_0_1.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.Type = t |
| v.AuxInt = ssa.Int32ToAuxInt(c) |
| return true |
| } |
| // match: (SliceLen (SliceMake _ (SliceLen x) _)) |
| // result: (SliceLen x) |
| for { |
| if v_0.Op != ssaop.OpSliceMake { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpSliceLen { |
| break |
| } |
| x := v_0_1.Args[0] |
| v.Reset(ssaop.OpSliceLen) |
| v.AddArg(x) |
| return true |
| } |
| // match: (SliceLen (Phi (SliceMake _ x _) (SliceMake _ x _))) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpPhi || len(v_0.Args) != 2 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpSliceMake { |
| break |
| } |
| x := v_0_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpSliceMake { |
| break |
| } |
| _ = v_0_1.Args[1] |
| if x != v_0_1.Args[1] { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| // match: (SliceLen (SelectN [0] (StaticLECall {sym} _ newLen:(Const64) _ _ _ _))) |
| // cond: (ssa.IsSameCall(sym, "runtime.growslice") || ssa.IsSameCall(sym, "runtime.growsliceNoAlias")) |
| // result: newLen |
| for { |
| if v_0.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpStaticLECall || len(v_0_0.Args) != 6 { |
| break |
| } |
| sym := ssa.AuxToCall(v_0_0.Aux) |
| _ = v_0_0.Args[1] |
| newLen := v_0_0.Args[1] |
| if newLen.Op != ssaop.OpConst64 || !(ssa.IsSameCall(sym, "runtime.growslice") || ssa.IsSameCall(sym, "runtime.growsliceNoAlias")) { |
| break |
| } |
| v.CopyOf(newLen) |
| return true |
| } |
| // match: (SliceLen (SelectN [0] (StaticLECall {sym} _ newLen:(Const32) _ _ _ _))) |
| // cond: (ssa.IsSameCall(sym, "runtime.growslice") || ssa.IsSameCall(sym, "runtime.growsliceNoAlias")) |
| // result: newLen |
| for { |
| if v_0.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpStaticLECall || len(v_0_0.Args) != 6 { |
| break |
| } |
| sym := ssa.AuxToCall(v_0_0.Aux) |
| _ = v_0_0.Args[1] |
| newLen := v_0_0.Args[1] |
| if newLen.Op != ssaop.OpConst32 || !(ssa.IsSameCall(sym, "runtime.growslice") || ssa.IsSameCall(sym, "runtime.growsliceNoAlias")) { |
| break |
| } |
| v.CopyOf(newLen) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpSliceMake(v *ssa.Value) bool { |
| v_2 := v.Args[2] |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (SliceMake (AddPtr <t> x (And64 y (Slicemask _))) w:(Const64 [c]) z) |
| // cond: c > 0 |
| // result: (SliceMake (AddPtr <t> x y) w z) |
| for { |
| if v_0.Op != ssaop.OpAddPtr { |
| break |
| } |
| t := v_0.Type |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| v_0_1_0 := v_0_1.Args[0] |
| v_0_1_1 := v_0_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_1_0, v_0_1_1 = _i0+1, v_0_1_1, v_0_1_0 { |
| y := v_0_1_0 |
| if v_0_1_1.Op != ssaop.OpSlicemask { |
| continue |
| } |
| w := v_1 |
| if w.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(w.AuxInt) |
| z := v_2 |
| if !(c > 0) { |
| continue |
| } |
| v.Reset(ssaop.OpSliceMake) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAddPtr, t) |
| v0.AddArg2(x, y) |
| v.AddArg3(v0, w, z) |
| return true |
| } |
| break |
| } |
| // match: (SliceMake (AddPtr <t> x (And32 y (Slicemask _))) w:(Const32 [c]) z) |
| // cond: c > 0 |
| // result: (SliceMake (AddPtr <t> x y) w z) |
| for { |
| if v_0.Op != ssaop.OpAddPtr { |
| break |
| } |
| t := v_0.Type |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpAnd32 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| v_0_1_0 := v_0_1.Args[0] |
| v_0_1_1 := v_0_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_1_0, v_0_1_1 = _i0+1, v_0_1_1, v_0_1_0 { |
| y := v_0_1_0 |
| if v_0_1_1.Op != ssaop.OpSlicemask { |
| continue |
| } |
| w := v_1 |
| if w.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(w.AuxInt) |
| z := v_2 |
| if !(c > 0) { |
| continue |
| } |
| v.Reset(ssaop.OpSliceMake) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAddPtr, t) |
| v0.AddArg2(x, y) |
| v.AddArg3(v0, w, z) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpSlicePtr(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (SlicePtr (SliceMake (SlicePtr x) _ _)) |
| // result: (SlicePtr x) |
| for { |
| if v_0.Op != ssaop.OpSliceMake { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpSlicePtr { |
| break |
| } |
| x := v_0_0.Args[0] |
| v.Reset(ssaop.OpSlicePtr) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpSlicemask(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Slicemask (Const32 [x])) |
| // cond: x > 0 |
| // result: (Const32 [-1]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| x := ssa.AuxIntToInt32(v_0.AuxInt) |
| if !(x > 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(-1) |
| return true |
| } |
| // match: (Slicemask (Const32 [0])) |
| // result: (Const32 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Slicemask (Const64 [x])) |
| // cond: x > 0 |
| // result: (Const64 [-1]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| x := ssa.AuxIntToInt64(v_0.AuxInt) |
| if !(x > 0) { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(-1) |
| return true |
| } |
| // match: (Slicemask (Const64 [0])) |
| // result: (Const64 [0]) |
| for { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpSqrt(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Sqrt (Const64F [c])) |
| // cond: !math.IsNaN(math.Sqrt(c)) |
| // result: (Const64F [math.Sqrt(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst64F { |
| break |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| if !(!math.IsNaN(math.Sqrt(c))) { |
| break |
| } |
| v.Reset(ssaop.OpConst64F) |
| v.AuxInt = ssa.Float64ToAuxInt(math.Sqrt(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpStaticCall(v *ssa.Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (StaticCall {callAux} p q _ mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.IsSamePtr(p, q) |
| // result: (MakeResult (ConstBool <typ.Bool> [true]) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| p := v.Args[0] |
| q := v.Args[1] |
| if !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.IsSamePtr(p, q)) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConstBool, typ.Bool) |
| v0.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpStaticLECall(v *ssa.Value) bool { |
| b := v.Block |
| config := b.Func.Config |
| typ := &b.Func.Config.Types |
| // match: (StaticLECall {callAux} sptr (Addr {scon} (SB)) (Const64 [1]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) |
| // result: (MakeResult (Eq8 (Load <typ.Int8> sptr mem) (Const8 <typ.Int8> [int8(ssa.Read8(scon,0))])) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| sptr := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(v_1.Aux) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpSB { |
| break |
| } |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 1 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon)) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq8, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8) |
| v1.AddArg2(sptr, mem) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, typ.Int8) |
| v2.AuxInt = ssa.Int8ToAuxInt(int8(ssa.Read8(scon, 0))) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [1]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) |
| // result: (MakeResult (Eq8 (Load <typ.Int8> sptr mem) (Const8 <typ.Int8> [int8(ssa.Read8(scon,0))])) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| v_0 := v.Args[0] |
| if v_0.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(v_0.Aux) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpSB { |
| break |
| } |
| sptr := v.Args[1] |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 1 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon)) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq8, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8) |
| v1.AddArg2(sptr, mem) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst8, typ.Int8) |
| v2.AuxInt = ssa.Int8ToAuxInt(int8(ssa.Read8(scon, 0))) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} sptr (Addr {scon} (SB)) (Const64 [2]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) |
| // result: (MakeResult (Eq16 (Load <typ.Int16> sptr mem) (Const16 <typ.Int16> [int16(ssa.Read16(scon,0,config.Ctxt.Arch.ByteOrder))])) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| sptr := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(v_1.Aux) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpSB { |
| break |
| } |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 2 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq16, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16) |
| v1.AddArg2(sptr, mem) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, typ.Int16) |
| v2.AuxInt = ssa.Int16ToAuxInt(int16(ssa.Read16(scon, 0, config.Ctxt.Arch.ByteOrder))) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [2]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) |
| // result: (MakeResult (Eq16 (Load <typ.Int16> sptr mem) (Const16 <typ.Int16> [int16(ssa.Read16(scon,0,config.Ctxt.Arch.ByteOrder))])) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| v_0 := v.Args[0] |
| if v_0.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(v_0.Aux) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpSB { |
| break |
| } |
| sptr := v.Args[1] |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 2 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq16, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16) |
| v1.AddArg2(sptr, mem) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, typ.Int16) |
| v2.AuxInt = ssa.Int16ToAuxInt(int16(ssa.Read16(scon, 0, config.Ctxt.Arch.ByteOrder))) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} sptr (Addr {scon} (SB)) (Const64 [4]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) |
| // result: (MakeResult (Eq32 (Load <typ.Int32> sptr mem) (Const32 <typ.Int32> [int32(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))])) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| sptr := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(v_1.Aux) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpSB { |
| break |
| } |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 4 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq32, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32) |
| v1.AddArg2(sptr, mem) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32) |
| v2.AuxInt = ssa.Int32ToAuxInt(int32(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder))) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [4]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) |
| // result: (MakeResult (Eq32 (Load <typ.Int32> sptr mem) (Const32 <typ.Int32> [int32(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))])) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| v_0 := v.Args[0] |
| if v_0.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(v_0.Aux) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpSB { |
| break |
| } |
| sptr := v.Args[1] |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 4 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq32, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32) |
| v1.AddArg2(sptr, mem) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32) |
| v2.AuxInt = ssa.Int32ToAuxInt(int32(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder))) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} sptr (Addr {scon} (SB)) (Const64 [8]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8 |
| // result: (MakeResult (Eq64 (Load <typ.Int64> sptr mem) (Const64 <typ.Int64> [int64(ssa.Read64(scon,0,config.Ctxt.Arch.ByteOrder))])) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| sptr := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(v_1.Aux) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpSB { |
| break |
| } |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 8 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int64) |
| v1.AddArg2(sptr, mem) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v2.AuxInt = ssa.Int64ToAuxInt(int64(ssa.Read64(scon, 0, config.Ctxt.Arch.ByteOrder))) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [8]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8 |
| // result: (MakeResult (Eq64 (Load <typ.Int64> sptr mem) (Const64 <typ.Int64> [int64(ssa.Read64(scon,0,config.Ctxt.Arch.ByteOrder))])) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| v_0 := v.Args[0] |
| if v_0.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(v_0.Aux) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpSB { |
| break |
| } |
| sptr := v.Args[1] |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 8 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int64) |
| v1.AddArg2(sptr, mem) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v2.AuxInt = ssa.Int64ToAuxInt(int64(ssa.Read64(scon, 0, config.Ctxt.Arch.ByteOrder))) |
| v0.AddArg2(v1, v2) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} sptr (Addr {scon} (SB)) (Const64 [3]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) |
| // result: (MakeResult (Eq32 (Or32 <typ.Int32> (ZeroExt16to32 <typ.Int32> (Load <typ.Int16> sptr mem)) (Lsh32x32 <typ.Int32> (ZeroExt8to32 <typ.Int32> (Load <typ.Int8> (OffPtr <typ.BytePtr> [2] sptr) mem)) (Const32 <typ.Int32> [16]))) (Const32 <typ.Int32> [int32(uint32(ssa.Read16(scon,0,config.Ctxt.Arch.ByteOrder))|(uint32(ssa.Read8(scon,2))<<16))])) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| sptr := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(v_1.Aux) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpSB { |
| break |
| } |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 3 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq32, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.Int32) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt16to32, typ.Int32) |
| v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16) |
| v3.AddArg2(sptr, mem) |
| v2.AddArg(v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.Int32) |
| v5 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, typ.Int32) |
| v6 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8) |
| v7 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtr) |
| v7.AuxInt = ssa.Int64ToAuxInt(2) |
| v7.AddArg(sptr) |
| v6.AddArg2(v7, mem) |
| v5.AddArg(v6) |
| v8 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32) |
| v8.AuxInt = ssa.Int32ToAuxInt(16) |
| v4.AddArg2(v5, v8) |
| v1.AddArg2(v2, v4) |
| v9 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32) |
| v9.AuxInt = ssa.Int32ToAuxInt(int32(uint32(ssa.Read16(scon, 0, config.Ctxt.Arch.ByteOrder)) | (uint32(ssa.Read8(scon, 2)) << 16))) |
| v0.AddArg2(v1, v9) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [3]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) |
| // result: (MakeResult (Eq32 (Or32 <typ.Int32> (ZeroExt16to32 <typ.Int32> (Load <typ.Int16> sptr mem)) (Lsh32x32 <typ.Int32> (ZeroExt8to32 <typ.Int32> (Load <typ.Int8> (OffPtr <typ.BytePtr> [2] sptr) mem)) (Const32 <typ.Int32> [16]))) (Const32 <typ.Int32> [int32(uint32(ssa.Read16(scon,0,config.Ctxt.Arch.ByteOrder))|(uint32(ssa.Read8(scon,2))<<16))])) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| v_0 := v.Args[0] |
| if v_0.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(v_0.Aux) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpSB { |
| break |
| } |
| sptr := v.Args[1] |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 3 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config)) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq32, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpOr32, typ.Int32) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt16to32, typ.Int32) |
| v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16) |
| v3.AddArg2(sptr, mem) |
| v2.AddArg(v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpLsh32x32, typ.Int32) |
| v5 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, typ.Int32) |
| v6 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8) |
| v7 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtr) |
| v7.AuxInt = ssa.Int64ToAuxInt(2) |
| v7.AddArg(sptr) |
| v6.AddArg2(v7, mem) |
| v5.AddArg(v6) |
| v8 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32) |
| v8.AuxInt = ssa.Int32ToAuxInt(16) |
| v4.AddArg2(v5, v8) |
| v1.AddArg2(v2, v4) |
| v9 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.Int32) |
| v9.AuxInt = ssa.Int32ToAuxInt(int32(uint32(ssa.Read16(scon, 0, config.Ctxt.Arch.ByteOrder)) | (uint32(ssa.Read8(scon, 2)) << 16))) |
| v0.AddArg2(v1, v9) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} sptr (Addr {scon} (SB)) (Const64 [5]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8 |
| // result: (MakeResult (Eq64 (Or64 <typ.Int64> (ZeroExt32to64 <typ.Int64> (Load <typ.Int32> sptr mem)) (Lsh64x64 <typ.Int64> (ZeroExt8to64 <typ.Int64> (Load <typ.Int8> (OffPtr <typ.BytePtr> [4] sptr) mem)) (Const64 <typ.Int64> [32]))) (Const64 <typ.Int64> [int64(uint64(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))|(uint64(ssa.Read8(scon,4))<<32))])) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| sptr := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(v_1.Aux) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpSB { |
| break |
| } |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 5 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpOr64, typ.Int64) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.Int64) |
| v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32) |
| v3.AddArg2(sptr, mem) |
| v2.AddArg(v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, typ.Int64) |
| v5 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, typ.Int64) |
| v6 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8) |
| v7 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtr) |
| v7.AuxInt = ssa.Int64ToAuxInt(4) |
| v7.AddArg(sptr) |
| v6.AddArg2(v7, mem) |
| v5.AddArg(v6) |
| v8 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v8.AuxInt = ssa.Int64ToAuxInt(32) |
| v4.AddArg2(v5, v8) |
| v1.AddArg2(v2, v4) |
| v9 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v9.AuxInt = ssa.Int64ToAuxInt(int64(uint64(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder)) | (uint64(ssa.Read8(scon, 4)) << 32))) |
| v0.AddArg2(v1, v9) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [5]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8 |
| // result: (MakeResult (Eq64 (Or64 <typ.Int64> (ZeroExt32to64 <typ.Int64> (Load <typ.Int32> sptr mem)) (Lsh64x64 <typ.Int64> (ZeroExt8to64 <typ.Int64> (Load <typ.Int8> (OffPtr <typ.BytePtr> [4] sptr) mem)) (Const64 <typ.Int64> [32]))) (Const64 <typ.Int64> [int64(uint64(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))|(uint64(ssa.Read8(scon,4))<<32))])) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| v_0 := v.Args[0] |
| if v_0.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(v_0.Aux) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpSB { |
| break |
| } |
| sptr := v.Args[1] |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 5 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpOr64, typ.Int64) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.Int64) |
| v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32) |
| v3.AddArg2(sptr, mem) |
| v2.AddArg(v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, typ.Int64) |
| v5 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, typ.Int64) |
| v6 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int8) |
| v7 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtr) |
| v7.AuxInt = ssa.Int64ToAuxInt(4) |
| v7.AddArg(sptr) |
| v6.AddArg2(v7, mem) |
| v5.AddArg(v6) |
| v8 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v8.AuxInt = ssa.Int64ToAuxInt(32) |
| v4.AddArg2(v5, v8) |
| v1.AddArg2(v2, v4) |
| v9 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v9.AuxInt = ssa.Int64ToAuxInt(int64(uint64(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder)) | (uint64(ssa.Read8(scon, 4)) << 32))) |
| v0.AddArg2(v1, v9) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} sptr (Addr {scon} (SB)) (Const64 [6]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8 |
| // result: (MakeResult (Eq64 (Or64 <typ.Int64> (ZeroExt32to64 <typ.Int64> (Load <typ.Int32> sptr mem)) (Lsh64x64 <typ.Int64> (ZeroExt16to64 <typ.Int64> (Load <typ.Int16> (OffPtr <typ.BytePtr> [4] sptr) mem)) (Const64 <typ.Int64> [32]))) (Const64 <typ.Int64> [int64(uint64(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))|(uint64(ssa.Read16(scon,4,config.Ctxt.Arch.ByteOrder))<<32))])) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| sptr := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(v_1.Aux) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpSB { |
| break |
| } |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 6 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpOr64, typ.Int64) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.Int64) |
| v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32) |
| v3.AddArg2(sptr, mem) |
| v2.AddArg(v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, typ.Int64) |
| v5 := b.NewValue0(v.Pos, ssaop.OpZeroExt16to64, typ.Int64) |
| v6 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16) |
| v7 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtr) |
| v7.AuxInt = ssa.Int64ToAuxInt(4) |
| v7.AddArg(sptr) |
| v6.AddArg2(v7, mem) |
| v5.AddArg(v6) |
| v8 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v8.AuxInt = ssa.Int64ToAuxInt(32) |
| v4.AddArg2(v5, v8) |
| v1.AddArg2(v2, v4) |
| v9 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v9.AuxInt = ssa.Int64ToAuxInt(int64(uint64(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder)) | (uint64(ssa.Read16(scon, 4, config.Ctxt.Arch.ByteOrder)) << 32))) |
| v0.AddArg2(v1, v9) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [6]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8 |
| // result: (MakeResult (Eq64 (Or64 <typ.Int64> (ZeroExt32to64 <typ.Int64> (Load <typ.Int32> sptr mem)) (Lsh64x64 <typ.Int64> (ZeroExt16to64 <typ.Int64> (Load <typ.Int16> (OffPtr <typ.BytePtr> [4] sptr) mem)) (Const64 <typ.Int64> [32]))) (Const64 <typ.Int64> [int64(uint64(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))|(uint64(ssa.Read16(scon,4,config.Ctxt.Arch.ByteOrder))<<32))])) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| v_0 := v.Args[0] |
| if v_0.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(v_0.Aux) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpSB { |
| break |
| } |
| sptr := v.Args[1] |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 6 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpOr64, typ.Int64) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.Int64) |
| v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32) |
| v3.AddArg2(sptr, mem) |
| v2.AddArg(v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, typ.Int64) |
| v5 := b.NewValue0(v.Pos, ssaop.OpZeroExt16to64, typ.Int64) |
| v6 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int16) |
| v7 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtr) |
| v7.AuxInt = ssa.Int64ToAuxInt(4) |
| v7.AddArg(sptr) |
| v6.AddArg2(v7, mem) |
| v5.AddArg(v6) |
| v8 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v8.AuxInt = ssa.Int64ToAuxInt(32) |
| v4.AddArg2(v5, v8) |
| v1.AddArg2(v2, v4) |
| v9 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v9.AuxInt = ssa.Int64ToAuxInt(int64(uint64(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder)) | (uint64(ssa.Read16(scon, 4, config.Ctxt.Arch.ByteOrder)) << 32))) |
| v0.AddArg2(v1, v9) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} sptr (Addr {scon} (SB)) (Const64 [7]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8 |
| // result: (MakeResult (Eq64 (Or64 <typ.Int64> (ZeroExt32to64 <typ.Int64> (Load <typ.Int32> sptr mem)) (Lsh64x64 <typ.Int64> (ZeroExt32to64 <typ.Int64> (Load <typ.Int32> (OffPtr <typ.BytePtr> [3] sptr) mem)) (Const64 <typ.Int64> [32]))) (Const64 <typ.Int64> [int64(uint64(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))|(uint64(ssa.Read32(scon,3,config.Ctxt.Arch.ByteOrder))<<32))])) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| sptr := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(v_1.Aux) |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpSB { |
| break |
| } |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 7 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpOr64, typ.Int64) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.Int64) |
| v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32) |
| v3.AddArg2(sptr, mem) |
| v2.AddArg(v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, typ.Int64) |
| v5 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.Int64) |
| v6 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32) |
| v7 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtr) |
| v7.AuxInt = ssa.Int64ToAuxInt(3) |
| v7.AddArg(sptr) |
| v6.AddArg2(v7, mem) |
| v5.AddArg(v6) |
| v8 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v8.AuxInt = ssa.Int64ToAuxInt(32) |
| v4.AddArg2(v5, v8) |
| v1.AddArg2(v2, v4) |
| v9 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v9.AuxInt = ssa.Int64ToAuxInt(int64(uint64(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder)) | (uint64(ssa.Read32(scon, 3, config.Ctxt.Arch.ByteOrder)) << 32))) |
| v0.AddArg2(v1, v9) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [7]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8 |
| // result: (MakeResult (Eq64 (Or64 <typ.Int64> (ZeroExt32to64 <typ.Int64> (Load <typ.Int32> sptr mem)) (Lsh64x64 <typ.Int64> (ZeroExt32to64 <typ.Int64> (Load <typ.Int32> (OffPtr <typ.BytePtr> [3] sptr) mem)) (Const64 <typ.Int64> [32]))) (Const64 <typ.Int64> [int64(uint64(ssa.Read32(scon,0,config.Ctxt.Arch.ByteOrder))|(uint64(ssa.Read32(scon,3,config.Ctxt.Arch.ByteOrder))<<32))])) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| v_0 := v.Args[0] |
| if v_0.Op != ssaop.OpAddr { |
| break |
| } |
| scon := ssa.AuxToSym(v_0.Aux) |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpSB { |
| break |
| } |
| sptr := v.Args[1] |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 7 || !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.SymIsRO(scon) && canLoadUnaligned(config) && config.PtrSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEq64, typ.Bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpOr64, typ.Int64) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.Int64) |
| v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32) |
| v3.AddArg2(sptr, mem) |
| v2.AddArg(v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, typ.Int64) |
| v5 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.Int64) |
| v6 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int32) |
| v7 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtr) |
| v7.AuxInt = ssa.Int64ToAuxInt(3) |
| v7.AddArg(sptr) |
| v6.AddArg2(v7, mem) |
| v5.AddArg(v6) |
| v8 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v8.AuxInt = ssa.Int64ToAuxInt(32) |
| v4.AddArg2(v5, v8) |
| v1.AddArg2(v2, v4) |
| v9 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.Int64) |
| v9.AuxInt = ssa.Int64ToAuxInt(int64(uint64(ssa.Read32(scon, 0, config.Ctxt.Arch.ByteOrder)) | (uint64(ssa.Read32(scon, 3, config.Ctxt.Arch.ByteOrder)) << 32))) |
| v0.AddArg2(v1, v9) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} _ _ (Const64 [0]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") |
| // result: (MakeResult (ConstBool <typ.Bool> [true]) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 0 || !(ssa.IsSameCall(callAux, "runtime.memequal")) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConstBool, typ.Bool) |
| v0.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} p q _ mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.memequal") && ssa.IsSamePtr(p, q) |
| // result: (MakeResult (ConstBool <typ.Bool> [true]) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| p := v.Args[0] |
| q := v.Args[1] |
| if !(ssa.IsSameCall(callAux, "runtime.memequal") && ssa.IsSamePtr(p, q)) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConstBool, typ.Bool) |
| v0.AuxInt = ssa.BoolToAuxInt(true) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} _ (Const64 [0]) (Const64 [0]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.makeslice") |
| // result: (MakeResult (Addr <v.Type.FieldType(0)> {ir.Syms.Zerobase} (SB)) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| v_1 := v.Args[1] |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 0 { |
| break |
| } |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_2.AuxInt) != 0 || !(ssa.IsSameCall(callAux, "runtime.makeslice")) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAddr, v.Type.FieldType(0)) |
| v0.Aux = ssa.SymToAux(ir.Syms.Zerobase) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSB, typ.Uintptr) |
| v0.AddArg(v1) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {callAux} _ (Const32 [0]) (Const32 [0]) mem) |
| // cond: ssa.IsSameCall(callAux, "runtime.makeslice") |
| // result: (MakeResult (Addr <v.Type.FieldType(0)> {ir.Syms.Zerobase} (SB)) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| callAux := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| v_1 := v.Args[1] |
| if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 0 { |
| break |
| } |
| v_2 := v.Args[2] |
| if v_2.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_2.AuxInt) != 0 || !(ssa.IsSameCall(callAux, "runtime.makeslice")) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAddr, v.Type.FieldType(0)) |
| v0.Aux = ssa.SymToAux(ir.Syms.Zerobase) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSB, typ.Uintptr) |
| v0.AddArg(v1) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {f} typ_ x y mem) |
| // cond: ssa.IsSameCall(f, "runtime.efaceeq") && isDirectAndComparableType(typ_) && ssa.Clobber(v) |
| // result: (MakeResult (EqPtr x y) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| f := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| typ_ := v.Args[0] |
| x := v.Args[1] |
| y := v.Args[2] |
| if !(ssa.IsSameCall(f, "runtime.efaceeq") && isDirectAndComparableType(typ_) && ssa.Clobber(v)) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEqPtr, typ.Bool) |
| v0.AddArg2(x, y) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {f} itab x y mem) |
| // cond: ssa.IsSameCall(f, "runtime.ifaceeq") && isDirectAndComparableIface(itab) && ssa.Clobber(v) |
| // result: (MakeResult (EqPtr x y) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| f := ssa.AuxToCall(v.Aux) |
| mem := v.Args[3] |
| itab := v.Args[0] |
| x := v.Args[1] |
| y := v.Args[2] |
| if !(ssa.IsSameCall(f, "runtime.ifaceeq") && isDirectAndComparableIface(itab) && ssa.Clobber(v)) { |
| break |
| } |
| v.Reset(ssaop.OpMakeResult) |
| v0 := b.NewValue0(v.Pos, ssaop.OpEqPtr, typ.Bool) |
| v0.AddArg2(x, y) |
| v.AddArg2(v0, mem) |
| return true |
| } |
| // match: (StaticLECall {f} [argsize] typ_ map_ key:(SelectN [0] sbts:(StaticLECall {g} _ ptr len mem)) m:(SelectN [1] sbts)) |
| // cond: (ssa.IsSameCall(f, "runtime.mapaccess1_faststr") || ssa.IsSameCall(f, "runtime.mapaccess2_faststr") || ssa.IsSameCall(f, "runtime.mapdelete_faststr")) && ssa.IsSameCall(g, "runtime.slicebytetostring") && key.Uses == 1 && sbts.Uses == 2 && resetCopy(m, mem) && ssa.Clobber(sbts) && ssa.Clobber(key) |
| // result: (StaticLECall {f} [argsize] typ_ map_ (StringMake <typ.String> ptr len) mem) |
| for { |
| if len(v.Args) != 4 { |
| break |
| } |
| argsize := ssa.AuxIntToInt32(v.AuxInt) |
| f := ssa.AuxToCall(v.Aux) |
| _ = v.Args[3] |
| typ_ := v.Args[0] |
| map_ := v.Args[1] |
| key := v.Args[2] |
| if key.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(key.AuxInt) != 0 { |
| break |
| } |
| sbts := key.Args[0] |
| if sbts.Op != ssaop.OpStaticLECall || len(sbts.Args) != 4 { |
| break |
| } |
| g := ssa.AuxToCall(sbts.Aux) |
| mem := sbts.Args[3] |
| ptr := sbts.Args[1] |
| len := sbts.Args[2] |
| m := v.Args[3] |
| if m.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(m.AuxInt) != 1 || sbts != m.Args[0] || !((ssa.IsSameCall(f, "runtime.mapaccess1_faststr") || ssa.IsSameCall(f, "runtime.mapaccess2_faststr") || ssa.IsSameCall(f, "runtime.mapdelete_faststr")) && ssa.IsSameCall(g, "runtime.slicebytetostring") && key.Uses == 1 && sbts.Uses == 2 && resetCopy(m, mem) && ssa.Clobber(sbts) && ssa.Clobber(key)) { |
| break |
| } |
| v.Reset(ssaop.OpStaticLECall) |
| v.AuxInt = ssa.Int32ToAuxInt(argsize) |
| v.Aux = ssa.CallToAux(f) |
| v0 := b.NewValue0(v.Pos, ssaop.OpStringMake, typ.String) |
| v0.AddArg2(ptr, len) |
| v.AddArg4(typ_, map_, v0, mem) |
| return true |
| } |
| // match: (StaticLECall {f} [argsize] dict_ key:(SelectN [0] sbts:(StaticLECall {g} _ ptr len mem)) m:(SelectN [1] sbts)) |
| // cond: ssa.IsSameCall(f, "unique.Make[go.shape.string]") && ssa.IsSameCall(g, "runtime.slicebytetostring") && key.Uses == 1 && sbts.Uses == 2 && resetCopy(m, mem) && ssa.Clobber(sbts) && ssa.Clobber(key) |
| // result: (StaticLECall {f} [argsize] dict_ (StringMake <typ.String> ptr len) mem) |
| for { |
| if len(v.Args) != 3 { |
| break |
| } |
| argsize := ssa.AuxIntToInt32(v.AuxInt) |
| f := ssa.AuxToCall(v.Aux) |
| _ = v.Args[2] |
| dict_ := v.Args[0] |
| key := v.Args[1] |
| if key.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(key.AuxInt) != 0 { |
| break |
| } |
| sbts := key.Args[0] |
| if sbts.Op != ssaop.OpStaticLECall || len(sbts.Args) != 4 { |
| break |
| } |
| g := ssa.AuxToCall(sbts.Aux) |
| mem := sbts.Args[3] |
| ptr := sbts.Args[1] |
| len := sbts.Args[2] |
| m := v.Args[2] |
| if m.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(m.AuxInt) != 1 || sbts != m.Args[0] || !(ssa.IsSameCall(f, "unique.Make[go.shape.string]") && ssa.IsSameCall(g, "runtime.slicebytetostring") && key.Uses == 1 && sbts.Uses == 2 && resetCopy(m, mem) && ssa.Clobber(sbts) && ssa.Clobber(key)) { |
| break |
| } |
| v.Reset(ssaop.OpStaticLECall) |
| v.AuxInt = ssa.Int32ToAuxInt(argsize) |
| v.Aux = ssa.CallToAux(f) |
| v0 := b.NewValue0(v.Pos, ssaop.OpStringMake, typ.String) |
| v0.AddArg2(ptr, len) |
| v.AddArg3(dict_, v0, mem) |
| return true |
| } |
| return false |
| } |
| 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 |
| // match: (Store {t1} p1 (Load <t2> p2 mem) mem) |
| // cond: ssa.IsSamePtr(p1, p2) && t2.Size() == t1.Size() |
| // result: mem |
| for { |
| t1 := ssa.AuxToType(v.Aux) |
| p1 := v_0 |
| if v_1.Op != ssaop.OpLoad { |
| break |
| } |
| t2 := v_1.Type |
| mem := v_1.Args[1] |
| p2 := v_1.Args[0] |
| if mem != v_2 || !(ssa.IsSamePtr(p1, p2) && t2.Size() == t1.Size()) { |
| break |
| } |
| v.CopyOf(mem) |
| return true |
| } |
| // match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ oldmem)) |
| // cond: ssa.IsSamePtr(p1, p2) && t2.Size() == t1.Size() && ssa.Disjoint(p1, t1, p3, t3) |
| // result: mem |
| for { |
| t1 := ssa.AuxToType(v.Aux) |
| p1 := v_0 |
| if v_1.Op != ssaop.OpLoad { |
| break |
| } |
| t2 := v_1.Type |
| oldmem := v_1.Args[1] |
| p2 := v_1.Args[0] |
| mem := v_2 |
| if mem.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem.Aux) |
| _ = mem.Args[2] |
| p3 := mem.Args[0] |
| if oldmem != mem.Args[2] || !(ssa.IsSamePtr(p1, p2) && t2.Size() == t1.Size() && ssa.Disjoint(p1, t1, p3, t3)) { |
| break |
| } |
| v.CopyOf(mem) |
| return true |
| } |
| // match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ (Store {t4} p4 _ oldmem))) |
| // cond: ssa.IsSamePtr(p1, p2) && t2.Size() == t1.Size() && ssa.Disjoint(p1, t1, p3, t3) && ssa.Disjoint(p1, t1, p4, t4) |
| // result: mem |
| for { |
| t1 := ssa.AuxToType(v.Aux) |
| p1 := v_0 |
| if v_1.Op != ssaop.OpLoad { |
| break |
| } |
| t2 := v_1.Type |
| oldmem := v_1.Args[1] |
| p2 := v_1.Args[0] |
| mem := v_2 |
| if mem.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem.Aux) |
| _ = mem.Args[2] |
| p3 := mem.Args[0] |
| mem_2 := mem.Args[2] |
| if mem_2.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(mem_2.Aux) |
| _ = mem_2.Args[2] |
| p4 := mem_2.Args[0] |
| if oldmem != mem_2.Args[2] || !(ssa.IsSamePtr(p1, p2) && t2.Size() == t1.Size() && ssa.Disjoint(p1, t1, p3, t3) && ssa.Disjoint(p1, t1, p4, t4)) { |
| break |
| } |
| v.CopyOf(mem) |
| return true |
| } |
| // match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 _ oldmem)))) |
| // cond: ssa.IsSamePtr(p1, p2) && t2.Size() == t1.Size() && ssa.Disjoint(p1, t1, p3, t3) && ssa.Disjoint(p1, t1, p4, t4) && ssa.Disjoint(p1, t1, p5, t5) |
| // result: mem |
| for { |
| t1 := ssa.AuxToType(v.Aux) |
| p1 := v_0 |
| if v_1.Op != ssaop.OpLoad { |
| break |
| } |
| t2 := v_1.Type |
| oldmem := v_1.Args[1] |
| p2 := v_1.Args[0] |
| mem := v_2 |
| if mem.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem.Aux) |
| _ = mem.Args[2] |
| p3 := mem.Args[0] |
| mem_2 := mem.Args[2] |
| if mem_2.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(mem_2.Aux) |
| _ = mem_2.Args[2] |
| p4 := mem_2.Args[0] |
| mem_2_2 := mem_2.Args[2] |
| if mem_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t5 := ssa.AuxToType(mem_2_2.Aux) |
| _ = mem_2_2.Args[2] |
| p5 := mem_2_2.Args[0] |
| if oldmem != mem_2_2.Args[2] || !(ssa.IsSamePtr(p1, p2) && t2.Size() == t1.Size() && ssa.Disjoint(p1, t1, p3, t3) && ssa.Disjoint(p1, t1, p4, t4) && ssa.Disjoint(p1, t1, p5, t5)) { |
| break |
| } |
| v.CopyOf(mem) |
| return true |
| } |
| // match: (Store {t} (OffPtr [o] p1) x mem:(Zero [n] p2 _)) |
| // cond: ssa.IsConstZero(x) && o >= 0 && t.Size() + o <= n && ssa.IsSamePtr(p1, p2) |
| // result: mem |
| for { |
| t := ssa.AuxToType(v.Aux) |
| if v_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| o := ssa.AuxIntToInt64(v_0.AuxInt) |
| p1 := v_0.Args[0] |
| x := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(mem.AuxInt) |
| p2 := mem.Args[0] |
| if !(ssa.IsConstZero(x) && o >= 0 && t.Size()+o <= n && ssa.IsSamePtr(p1, p2)) { |
| break |
| } |
| v.CopyOf(mem) |
| return true |
| } |
| // match: (Store {t1} op1:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Zero [n] p3 _))) |
| // cond: ssa.IsConstZero(x) && o1 >= 0 && t1.Size() + o1 <= n && ssa.IsSamePtr(p1, p3) && ssa.Disjoint(op1, t1, p2, t2) |
| // result: mem |
| for { |
| t1 := ssa.AuxToType(v.Aux) |
| op1 := v_0 |
| if op1.Op != ssaop.OpOffPtr { |
| break |
| } |
| o1 := ssa.AuxIntToInt64(op1.AuxInt) |
| p1 := op1.Args[0] |
| x := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem.Aux) |
| _ = mem.Args[2] |
| p2 := mem.Args[0] |
| mem_2 := mem.Args[2] |
| if mem_2.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(mem_2.AuxInt) |
| p3 := mem_2.Args[0] |
| if !(ssa.IsConstZero(x) && o1 >= 0 && t1.Size()+o1 <= n && ssa.IsSamePtr(p1, p3) && ssa.Disjoint(op1, t1, p2, t2)) { |
| break |
| } |
| v.CopyOf(mem) |
| return true |
| } |
| // match: (Store {t1} op1:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Store {t3} p3 _ (Zero [n] p4 _)))) |
| // cond: ssa.IsConstZero(x) && o1 >= 0 && t1.Size() + o1 <= n && ssa.IsSamePtr(p1, p4) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) |
| // result: mem |
| for { |
| t1 := ssa.AuxToType(v.Aux) |
| op1 := v_0 |
| if op1.Op != ssaop.OpOffPtr { |
| break |
| } |
| o1 := ssa.AuxIntToInt64(op1.AuxInt) |
| p1 := op1.Args[0] |
| x := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem.Aux) |
| _ = mem.Args[2] |
| p2 := mem.Args[0] |
| mem_2 := mem.Args[2] |
| if mem_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem_2.Aux) |
| _ = mem_2.Args[2] |
| p3 := mem_2.Args[0] |
| mem_2_2 := mem_2.Args[2] |
| if mem_2_2.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(mem_2_2.AuxInt) |
| p4 := mem_2_2.Args[0] |
| if !(ssa.IsConstZero(x) && o1 >= 0 && t1.Size()+o1 <= n && ssa.IsSamePtr(p1, p4) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3)) { |
| break |
| } |
| v.CopyOf(mem) |
| return true |
| } |
| // match: (Store {t1} op1:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Zero [n] p5 _))))) |
| // cond: ssa.IsConstZero(x) && o1 >= 0 && t1.Size() + o1 <= n && ssa.IsSamePtr(p1, p5) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) && ssa.Disjoint(op1, t1, p4, t4) |
| // result: mem |
| for { |
| t1 := ssa.AuxToType(v.Aux) |
| op1 := v_0 |
| if op1.Op != ssaop.OpOffPtr { |
| break |
| } |
| o1 := ssa.AuxIntToInt64(op1.AuxInt) |
| p1 := op1.Args[0] |
| x := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(mem.Aux) |
| _ = mem.Args[2] |
| p2 := mem.Args[0] |
| mem_2 := mem.Args[2] |
| if mem_2.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(mem_2.Aux) |
| _ = mem_2.Args[2] |
| p3 := mem_2.Args[0] |
| mem_2_2 := mem_2.Args[2] |
| if mem_2_2.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(mem_2_2.Aux) |
| _ = mem_2_2.Args[2] |
| p4 := mem_2_2.Args[0] |
| mem_2_2_2 := mem_2_2.Args[2] |
| if mem_2_2_2.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(mem_2_2_2.AuxInt) |
| p5 := mem_2_2_2.Args[0] |
| if !(ssa.IsConstZero(x) && o1 >= 0 && t1.Size()+o1 <= n && ssa.IsSamePtr(p1, p5) && ssa.Disjoint(op1, t1, p2, t2) && ssa.Disjoint(op1, t1, p3, t3) && ssa.Disjoint(op1, t1, p4, t4)) { |
| break |
| } |
| v.CopyOf(mem) |
| return true |
| } |
| // match: (Store _ (StructMake ___) _) |
| // result: ssa.RewriteStructStore(v) |
| for { |
| if v_1.Op != ssaop.OpStructMake { |
| break |
| } |
| v.CopyOf(ssa.RewriteStructStore(v)) |
| return true |
| } |
| // match: (Store {t} dst (Load src mem) mem) |
| // cond: !ssa.CanSSA(t) |
| // result: (Move {t} [t.Size()] dst src mem) |
| for { |
| t := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| if v_1.Op != ssaop.OpLoad { |
| break |
| } |
| mem := v_1.Args[1] |
| src := v_1.Args[0] |
| if mem != v_2 || !(!ssa.CanSSA(t)) { |
| break |
| } |
| v.Reset(ssaop.OpMove) |
| v.AuxInt = ssa.Int64ToAuxInt(t.Size()) |
| v.Aux = ssa.TypeToAux(t) |
| v.AddArg3(dst, src, mem) |
| return true |
| } |
| // match: (Store {t} dst (Load src mem) (VarDef {x} mem)) |
| // cond: !ssa.CanSSA(t) |
| // result: (Move {t} [t.Size()] dst src (VarDef {x} mem)) |
| for { |
| t := ssa.AuxToType(v.Aux) |
| dst := v_0 |
| if v_1.Op != ssaop.OpLoad { |
| break |
| } |
| mem := v_1.Args[1] |
| src := v_1.Args[0] |
| if v_2.Op != ssaop.OpVarDef { |
| break |
| } |
| x := ssa.AuxToSym(v_2.Aux) |
| if mem != v_2.Args[0] || !(!ssa.CanSSA(t)) { |
| break |
| } |
| v.Reset(ssaop.OpMove) |
| v.AuxInt = ssa.Int64ToAuxInt(t.Size()) |
| v.Aux = ssa.TypeToAux(t) |
| v0 := b.NewValue0(v.Pos, ssaop.OpVarDef, types.TypeMem) |
| v0.Aux = ssa.SymToAux(x) |
| v0.AddArg(mem) |
| v.AddArg3(dst, src, v0) |
| return true |
| } |
| // match: (Store dst (ArrayMake1 e) mem) |
| // result: (Store {e.Type} dst e mem) |
| for { |
| dst := v_0 |
| if v_1.Op != ssaop.OpArrayMake1 { |
| break |
| } |
| e := v_1.Args[0] |
| mem := v_2 |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(e.Type) |
| v.AddArg3(dst, e, mem) |
| return true |
| } |
| // match: (Store _ (Empty) mem) |
| // result: mem |
| for { |
| if v_1.Op != ssaop.OpEmpty { |
| break |
| } |
| mem := v_2 |
| v.CopyOf(mem) |
| return true |
| } |
| // match: (Store (SelectN [0] call:(StaticLECall ___)) x mem:(SelectN [1] call)) |
| // cond: ssa.IsConstZero(x) && isMalloc(call.Aux) |
| // result: mem |
| for { |
| if v_0.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| call := v_0.Args[0] |
| if call.Op != ssaop.OpStaticLECall { |
| break |
| } |
| x := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(mem.AuxInt) != 1 || call != mem.Args[0] || !(ssa.IsConstZero(x) && isMalloc(call.Aux)) { |
| break |
| } |
| v.CopyOf(mem) |
| return true |
| } |
| // match: (Store (OffPtr (SelectN [0] call:(StaticLECall ___))) x mem:(SelectN [1] call)) |
| // cond: ssa.IsConstZero(x) && isMalloc(call.Aux) |
| // result: mem |
| for { |
| if v_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(v_0_0.AuxInt) != 0 { |
| break |
| } |
| call := v_0_0.Args[0] |
| if call.Op != ssaop.OpStaticLECall { |
| break |
| } |
| x := v_1 |
| mem := v_2 |
| if mem.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(mem.AuxInt) != 1 || call != mem.Args[0] || !(ssa.IsConstZero(x) && isMalloc(call.Aux)) { |
| break |
| } |
| v.CopyOf(mem) |
| return true |
| } |
| // match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [0] p2) d2 m3:(Move [n] p3 _ mem))) |
| // cond: m2.Uses == 1 && m3.Uses == 1 && o1 == t2.Size() && n == t2.Size() + t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.Clobber(m2, m3) |
| // result: (Store {t1} op1 d1 (Store {t2} op2 d2 mem)) |
| for { |
| t1 := ssa.AuxToType(v.Aux) |
| op1 := v_0 |
| if op1.Op != ssaop.OpOffPtr { |
| break |
| } |
| o1 := ssa.AuxIntToInt64(op1.AuxInt) |
| p1 := op1.Args[0] |
| d1 := v_1 |
| m2 := v_2 |
| if m2.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(m2.Aux) |
| _ = m2.Args[2] |
| op2 := m2.Args[0] |
| if op2.Op != ssaop.OpOffPtr || ssa.AuxIntToInt64(op2.AuxInt) != 0 { |
| break |
| } |
| p2 := op2.Args[0] |
| d2 := m2.Args[1] |
| m3 := m2.Args[2] |
| if m3.Op != ssaop.OpMove { |
| break |
| } |
| n := ssa.AuxIntToInt64(m3.AuxInt) |
| mem := m3.Args[2] |
| p3 := m3.Args[0] |
| if !(m2.Uses == 1 && m3.Uses == 1 && o1 == t2.Size() && n == t2.Size()+t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.Clobber(m2, m3)) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t1) |
| v0 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v0.Aux = ssa.TypeToAux(t2) |
| v0.AddArg3(op2, d2, mem) |
| v.AddArg3(op1, d1, v0) |
| return true |
| } |
| // match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [0] p3) d3 m4:(Move [n] p4 _ mem)))) |
| // cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == t3.Size() && o1-o2 == t2.Size() && n == t3.Size() + t2.Size() + t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.Clobber(m2, m3, m4) |
| // result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 mem))) |
| for { |
| t1 := ssa.AuxToType(v.Aux) |
| op1 := v_0 |
| if op1.Op != ssaop.OpOffPtr { |
| break |
| } |
| o1 := ssa.AuxIntToInt64(op1.AuxInt) |
| p1 := op1.Args[0] |
| d1 := v_1 |
| m2 := v_2 |
| if m2.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(m2.Aux) |
| _ = m2.Args[2] |
| op2 := m2.Args[0] |
| if op2.Op != ssaop.OpOffPtr { |
| break |
| } |
| o2 := ssa.AuxIntToInt64(op2.AuxInt) |
| p2 := op2.Args[0] |
| d2 := m2.Args[1] |
| m3 := m2.Args[2] |
| if m3.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(m3.Aux) |
| _ = m3.Args[2] |
| op3 := m3.Args[0] |
| if op3.Op != ssaop.OpOffPtr || ssa.AuxIntToInt64(op3.AuxInt) != 0 { |
| break |
| } |
| p3 := op3.Args[0] |
| d3 := m3.Args[1] |
| m4 := m3.Args[2] |
| if m4.Op != ssaop.OpMove { |
| break |
| } |
| n := ssa.AuxIntToInt64(m4.AuxInt) |
| mem := m4.Args[2] |
| p4 := m4.Args[0] |
| if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == t3.Size() && o1-o2 == t2.Size() && n == t3.Size()+t2.Size()+t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.Clobber(m2, m3, m4)) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t1) |
| v0 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v0.Aux = ssa.TypeToAux(t2) |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v1.Aux = ssa.TypeToAux(t3) |
| v1.AddArg3(op3, d3, mem) |
| v0.AddArg3(op2, d2, v1) |
| v.AddArg3(op1, d1, v0) |
| return true |
| } |
| // match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [o3] p3) d3 m4:(Store {t4} op4:(OffPtr [0] p4) d4 m5:(Move [n] p5 _ mem))))) |
| // cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == t4.Size() && o2-o3 == t3.Size() && o1-o2 == t2.Size() && n == t4.Size() + t3.Size() + t2.Size() + t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && ssa.Clobber(m2, m3, m4, m5) |
| // result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 (Store {t4} op4 d4 mem)))) |
| for { |
| t1 := ssa.AuxToType(v.Aux) |
| op1 := v_0 |
| if op1.Op != ssaop.OpOffPtr { |
| break |
| } |
| o1 := ssa.AuxIntToInt64(op1.AuxInt) |
| p1 := op1.Args[0] |
| d1 := v_1 |
| m2 := v_2 |
| if m2.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(m2.Aux) |
| _ = m2.Args[2] |
| op2 := m2.Args[0] |
| if op2.Op != ssaop.OpOffPtr { |
| break |
| } |
| o2 := ssa.AuxIntToInt64(op2.AuxInt) |
| p2 := op2.Args[0] |
| d2 := m2.Args[1] |
| m3 := m2.Args[2] |
| if m3.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(m3.Aux) |
| _ = m3.Args[2] |
| op3 := m3.Args[0] |
| if op3.Op != ssaop.OpOffPtr { |
| break |
| } |
| o3 := ssa.AuxIntToInt64(op3.AuxInt) |
| p3 := op3.Args[0] |
| d3 := m3.Args[1] |
| m4 := m3.Args[2] |
| if m4.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(m4.Aux) |
| _ = m4.Args[2] |
| op4 := m4.Args[0] |
| if op4.Op != ssaop.OpOffPtr || ssa.AuxIntToInt64(op4.AuxInt) != 0 { |
| break |
| } |
| p4 := op4.Args[0] |
| d4 := m4.Args[1] |
| m5 := m4.Args[2] |
| if m5.Op != ssaop.OpMove { |
| break |
| } |
| n := ssa.AuxIntToInt64(m5.AuxInt) |
| mem := m5.Args[2] |
| p5 := m5.Args[0] |
| if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == t4.Size() && o2-o3 == t3.Size() && o1-o2 == t2.Size() && n == t4.Size()+t3.Size()+t2.Size()+t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && ssa.Clobber(m2, m3, m4, m5)) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t1) |
| v0 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v0.Aux = ssa.TypeToAux(t2) |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v1.Aux = ssa.TypeToAux(t3) |
| v2 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v2.Aux = ssa.TypeToAux(t4) |
| v2.AddArg3(op4, d4, mem) |
| v1.AddArg3(op3, d3, v2) |
| v0.AddArg3(op2, d2, v1) |
| v.AddArg3(op1, d1, v0) |
| return true |
| } |
| // match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [0] p2) d2 m3:(Zero [n] p3 mem))) |
| // cond: m2.Uses == 1 && m3.Uses == 1 && o1 == t2.Size() && n == t2.Size() + t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.Clobber(m2, m3) |
| // result: (Store {t1} op1 d1 (Store {t2} op2 d2 mem)) |
| for { |
| t1 := ssa.AuxToType(v.Aux) |
| op1 := v_0 |
| if op1.Op != ssaop.OpOffPtr { |
| break |
| } |
| o1 := ssa.AuxIntToInt64(op1.AuxInt) |
| p1 := op1.Args[0] |
| d1 := v_1 |
| m2 := v_2 |
| if m2.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(m2.Aux) |
| _ = m2.Args[2] |
| op2 := m2.Args[0] |
| if op2.Op != ssaop.OpOffPtr || ssa.AuxIntToInt64(op2.AuxInt) != 0 { |
| break |
| } |
| p2 := op2.Args[0] |
| d2 := m2.Args[1] |
| m3 := m2.Args[2] |
| if m3.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(m3.AuxInt) |
| mem := m3.Args[1] |
| p3 := m3.Args[0] |
| if !(m2.Uses == 1 && m3.Uses == 1 && o1 == t2.Size() && n == t2.Size()+t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.Clobber(m2, m3)) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t1) |
| v0 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v0.Aux = ssa.TypeToAux(t2) |
| v0.AddArg3(op2, d2, mem) |
| v.AddArg3(op1, d1, v0) |
| return true |
| } |
| // match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [0] p3) d3 m4:(Zero [n] p4 mem)))) |
| // cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == t3.Size() && o1-o2 == t2.Size() && n == t3.Size() + t2.Size() + t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.Clobber(m2, m3, m4) |
| // result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 mem))) |
| for { |
| t1 := ssa.AuxToType(v.Aux) |
| op1 := v_0 |
| if op1.Op != ssaop.OpOffPtr { |
| break |
| } |
| o1 := ssa.AuxIntToInt64(op1.AuxInt) |
| p1 := op1.Args[0] |
| d1 := v_1 |
| m2 := v_2 |
| if m2.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(m2.Aux) |
| _ = m2.Args[2] |
| op2 := m2.Args[0] |
| if op2.Op != ssaop.OpOffPtr { |
| break |
| } |
| o2 := ssa.AuxIntToInt64(op2.AuxInt) |
| p2 := op2.Args[0] |
| d2 := m2.Args[1] |
| m3 := m2.Args[2] |
| if m3.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(m3.Aux) |
| _ = m3.Args[2] |
| op3 := m3.Args[0] |
| if op3.Op != ssaop.OpOffPtr || ssa.AuxIntToInt64(op3.AuxInt) != 0 { |
| break |
| } |
| p3 := op3.Args[0] |
| d3 := m3.Args[1] |
| m4 := m3.Args[2] |
| if m4.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(m4.AuxInt) |
| mem := m4.Args[1] |
| p4 := m4.Args[0] |
| if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == t3.Size() && o1-o2 == t2.Size() && n == t3.Size()+t2.Size()+t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.Clobber(m2, m3, m4)) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t1) |
| v0 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v0.Aux = ssa.TypeToAux(t2) |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v1.Aux = ssa.TypeToAux(t3) |
| v1.AddArg3(op3, d3, mem) |
| v0.AddArg3(op2, d2, v1) |
| v.AddArg3(op1, d1, v0) |
| return true |
| } |
| // match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [o3] p3) d3 m4:(Store {t4} op4:(OffPtr [0] p4) d4 m5:(Zero [n] p5 mem))))) |
| // cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == t4.Size() && o2-o3 == t3.Size() && o1-o2 == t2.Size() && n == t4.Size() + t3.Size() + t2.Size() + t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && ssa.Clobber(m2, m3, m4, m5) |
| // result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 (Store {t4} op4 d4 mem)))) |
| for { |
| t1 := ssa.AuxToType(v.Aux) |
| op1 := v_0 |
| if op1.Op != ssaop.OpOffPtr { |
| break |
| } |
| o1 := ssa.AuxIntToInt64(op1.AuxInt) |
| p1 := op1.Args[0] |
| d1 := v_1 |
| m2 := v_2 |
| if m2.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(m2.Aux) |
| _ = m2.Args[2] |
| op2 := m2.Args[0] |
| if op2.Op != ssaop.OpOffPtr { |
| break |
| } |
| o2 := ssa.AuxIntToInt64(op2.AuxInt) |
| p2 := op2.Args[0] |
| d2 := m2.Args[1] |
| m3 := m2.Args[2] |
| if m3.Op != ssaop.OpStore { |
| break |
| } |
| t3 := ssa.AuxToType(m3.Aux) |
| _ = m3.Args[2] |
| op3 := m3.Args[0] |
| if op3.Op != ssaop.OpOffPtr { |
| break |
| } |
| o3 := ssa.AuxIntToInt64(op3.AuxInt) |
| p3 := op3.Args[0] |
| d3 := m3.Args[1] |
| m4 := m3.Args[2] |
| if m4.Op != ssaop.OpStore { |
| break |
| } |
| t4 := ssa.AuxToType(m4.Aux) |
| _ = m4.Args[2] |
| op4 := m4.Args[0] |
| if op4.Op != ssaop.OpOffPtr || ssa.AuxIntToInt64(op4.AuxInt) != 0 { |
| break |
| } |
| p4 := op4.Args[0] |
| d4 := m4.Args[1] |
| m5 := m4.Args[2] |
| if m5.Op != ssaop.OpZero { |
| break |
| } |
| n := ssa.AuxIntToInt64(m5.AuxInt) |
| mem := m5.Args[1] |
| p5 := m5.Args[0] |
| if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == t4.Size() && o2-o3 == t3.Size() && o1-o2 == t2.Size() && n == t4.Size()+t3.Size()+t2.Size()+t1.Size() && ssa.IsSamePtr(p1, p2) && ssa.IsSamePtr(p2, p3) && ssa.IsSamePtr(p3, p4) && ssa.IsSamePtr(p4, p5) && ssa.Clobber(m2, m3, m4, m5)) { |
| break |
| } |
| v.Reset(ssaop.OpStore) |
| v.Aux = ssa.TypeToAux(t1) |
| v0 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v0.Aux = ssa.TypeToAux(t2) |
| v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v1.Aux = ssa.TypeToAux(t3) |
| v2 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem) |
| v2.Aux = ssa.TypeToAux(t4) |
| v2.AddArg3(op4, d4, mem) |
| v1.AddArg3(op3, d3, v2) |
| v0.AddArg3(op2, d2, v1) |
| v.AddArg3(op1, d1, v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpStringLen(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (StringLen (StringMake _ (Const64 <t> [c]))) |
| // result: (Const64 <t> [c]) |
| for { |
| if v_0.Op != ssaop.OpStringMake { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_0_1.Type |
| c := ssa.AuxIntToInt64(v_0_1.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.Type = t |
| v.AuxInt = ssa.Int64ToAuxInt(c) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpStringPtr(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (StringPtr (StringMake (Addr <t> {s} base) _)) |
| // result: (Addr <t> {s} base) |
| for { |
| if v_0.Op != ssaop.OpStringMake { |
| break |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpAddr { |
| break |
| } |
| t := v_0_0.Type |
| s := ssa.AuxToSym(v_0_0.Aux) |
| base := v_0_0.Args[0] |
| v.Reset(ssaop.OpAddr) |
| v.Type = t |
| v.Aux = ssa.SymToAux(s) |
| v.AddArg(base) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpStructSelect(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (StructSelect [i] x:(StructMake ___)) |
| // result: x.Args[i] |
| for { |
| i := ssa.AuxIntToInt64(v.AuxInt) |
| x := v_0 |
| if x.Op != ssaop.OpStructMake { |
| break |
| } |
| v.CopyOf(x.Args[i]) |
| return true |
| } |
| // match: (StructSelect [i] x:(Load <t> ptr mem)) |
| // cond: !ssa.CanSSA(t) |
| // result: @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(int(i))] ptr) mem) |
| for { |
| i := ssa.AuxIntToInt64(v.AuxInt) |
| x := v_0 |
| if x.Op != ssaop.OpLoad { |
| break |
| } |
| t := x.Type |
| mem := x.Args[1] |
| ptr := x.Args[0] |
| if !(!ssa.CanSSA(t)) { |
| break |
| } |
| b = x.Block |
| v0 := b.NewValue0(v.Pos, ssaop.OpLoad, v.Type) |
| v.CopyOf(v0) |
| v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, v.Type.PtrTo()) |
| v1.AuxInt = ssa.Int64ToAuxInt(t.FieldOff(int(i))) |
| v1.AddArg(ptr) |
| v0.AddArg2(v1, mem) |
| return true |
| } |
| // match: (StructSelect (IData x)) |
| // cond: v.Type.Size() > 0 |
| // result: (IData x) |
| for { |
| if v_0.Op != ssaop.OpIData { |
| break |
| } |
| x := v_0.Args[0] |
| if !(v.Type.Size() > 0) { |
| break |
| } |
| v.Reset(ssaop.OpIData) |
| v.AddArg(x) |
| return true |
| } |
| // match: (StructSelect (IData x)) |
| // cond: v.Type.Size() == 0 |
| // result: (Empty) |
| for { |
| if v_0.Op != ssaop.OpIData { |
| break |
| } |
| if !(v.Type.Size() == 0) { |
| break |
| } |
| v.Reset(ssaop.OpEmpty) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpSub16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Sub16 (Const16 [c]) (Const16 [d])) |
| // result: (Const16 [c-d]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(c - d) |
| return true |
| } |
| // match: (Sub16 x (Const16 <t> [c])) |
| // cond: x.Op != ssaop.OpConst16 |
| // result: (Add16 (Const16 <t> [-c]) x) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| t := v_1.Type |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(x.Op != ssaop.OpConst16) { |
| break |
| } |
| v.Reset(ssaop.OpAdd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(-c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Sub16 <t> (Mul16 x y) (Mul16 x z)) |
| // result: (Mul16 x (Sub16 <t> y z)) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| y := v_0_1 |
| if v_1.Op != ssaop.OpMul16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| z := v_1_1 |
| v.Reset(ssaop.OpMul16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub16, t) |
| v0.AddArg2(y, z) |
| v.AddArg2(x, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Sub16 x x) |
| // result: (Const16 [0]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Sub16 (Neg16 x) (Com16 x)) |
| // result: (Const16 [1]) |
| for { |
| if v_0.Op != ssaop.OpNeg16 { |
| break |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpCom16 || x != v_1.Args[0] { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(1) |
| return true |
| } |
| // match: (Sub16 (Com16 x) (Neg16 x)) |
| // result: (Const16 [-1]) |
| for { |
| if v_0.Op != ssaop.OpCom16 { |
| break |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpNeg16 || x != v_1.Args[0] { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(-1) |
| return true |
| } |
| // match: (Sub16 (Add16 t x) (Add16 t y)) |
| // result: (Sub16 x y) |
| for { |
| if v_0.Op != ssaop.OpAdd16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| t := v_0_0 |
| x := v_0_1 |
| if v_1.Op != ssaop.OpAdd16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if t != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpSub16) |
| v.AddArg2(x, y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Sub16 x (And16 <t> x y)) |
| // result: (And16 x (Com16 <t> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd16 { |
| break |
| } |
| t := v_1.Type |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpAnd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCom16, t) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Sub16 (Add16 x y) x) |
| // result: y |
| for { |
| if v_0.Op != ssaop.OpAdd16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| y := v_0_1 |
| if x != v_1 { |
| continue |
| } |
| v.CopyOf(y) |
| return true |
| } |
| break |
| } |
| // match: (Sub16 (Add16 x y) y) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpAdd16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| y := v_0_1 |
| if y != v_1 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Sub16 (Sub16 x y) x) |
| // result: (Neg16 y) |
| for { |
| if v_0.Op != ssaop.OpSub16 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpNeg16) |
| v.AddArg(y) |
| return true |
| } |
| // match: (Sub16 x (Add16 x y)) |
| // result: (Neg16 y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpNeg16) |
| v.AddArg(y) |
| return true |
| } |
| break |
| } |
| // match: (Sub16 x (Sub16 i:(Const16 <t>) z)) |
| // cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) |
| // result: (Sub16 (Add16 <t> x z) i) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub16 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != ssaop.OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) { |
| break |
| } |
| v.Reset(ssaop.OpSub16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, t) |
| v0.AddArg2(x, z) |
| v.AddArg2(v0, i) |
| return true |
| } |
| // match: (Sub16 x (Add16 z i:(Const16 <t>))) |
| // cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) |
| // result: (Sub16 (Sub16 <t> x z) i) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| z := v_1_0 |
| i := v_1_1 |
| if i.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := i.Type |
| if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) { |
| continue |
| } |
| v.Reset(ssaop.OpSub16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub16, t) |
| v0.AddArg2(x, z) |
| v.AddArg2(v0, i) |
| return true |
| } |
| break |
| } |
| // match: (Sub16 (Sub16 i:(Const16 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) |
| // result: (Sub16 i (Add16 <t> z x)) |
| for { |
| if v_0.Op != ssaop.OpSub16 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != ssaop.OpConst16 { |
| break |
| } |
| t := i.Type |
| x := v_1 |
| if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) { |
| break |
| } |
| v.Reset(ssaop.OpSub16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| // match: (Sub16 (Add16 z i:(Const16 <t>)) x) |
| // cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) |
| // result: (Add16 i (Sub16 <t> z x)) |
| for { |
| if v_0.Op != ssaop.OpAdd16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| z := v_0_0 |
| i := v_0_1 |
| if i.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := i.Type |
| x := v_1 |
| if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub16, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| break |
| } |
| // match: (Sub16 (Const16 <t> [c]) (Sub16 (Const16 <t> [d]) x)) |
| // result: (Add16 (Const16 <t> [c-d]) x) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpSub16 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst16 || v_1_0.Type != t { |
| break |
| } |
| d := ssa.AuxIntToInt16(v_1_0.AuxInt) |
| v.Reset(ssaop.OpAdd16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(c - d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Sub16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x)) |
| // result: (Sub16 (Const16 <t> [c-d]) x) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpAdd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst16 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpSub16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(c - d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpSub32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Sub32 (Const32 [c]) (Const32 [d])) |
| // result: (Const32 [c-d]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(c - d) |
| return true |
| } |
| // match: (Sub32 x (Const32 <t> [c])) |
| // cond: x.Op != ssaop.OpConst32 |
| // result: (Add32 (Const32 <t> [-c]) x) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_1.Type |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(x.Op != ssaop.OpConst32) { |
| break |
| } |
| v.Reset(ssaop.OpAdd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(-c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Sub32 <t> (Mul32 x y) (Mul32 x z)) |
| // result: (Mul32 x (Sub32 <t> y z)) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| y := v_0_1 |
| if v_1.Op != ssaop.OpMul32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| z := v_1_1 |
| v.Reset(ssaop.OpMul32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub32, t) |
| v0.AddArg2(y, z) |
| v.AddArg2(x, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Sub32 x x) |
| // result: (Const32 [0]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Sub32 (Neg32 x) (Com32 x)) |
| // result: (Const32 [1]) |
| for { |
| if v_0.Op != ssaop.OpNeg32 { |
| break |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpCom32 || x != v_1.Args[0] { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(1) |
| return true |
| } |
| // match: (Sub32 (Com32 x) (Neg32 x)) |
| // result: (Const32 [-1]) |
| for { |
| if v_0.Op != ssaop.OpCom32 { |
| break |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpNeg32 || x != v_1.Args[0] { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(-1) |
| return true |
| } |
| // match: (Sub32 (Add32 t x) (Add32 t y)) |
| // result: (Sub32 x y) |
| for { |
| if v_0.Op != ssaop.OpAdd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| t := v_0_0 |
| x := v_0_1 |
| if v_1.Op != ssaop.OpAdd32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if t != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpSub32) |
| v.AddArg2(x, y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Sub32 x (And32 <t> x y)) |
| // result: (And32 x (Com32 <t> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd32 { |
| break |
| } |
| t := v_1.Type |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpAnd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCom32, t) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Sub32 (Add32 x y) x) |
| // result: y |
| for { |
| if v_0.Op != ssaop.OpAdd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| y := v_0_1 |
| if x != v_1 { |
| continue |
| } |
| v.CopyOf(y) |
| return true |
| } |
| break |
| } |
| // match: (Sub32 (Add32 x y) y) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpAdd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| y := v_0_1 |
| if y != v_1 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Sub32 (Sub32 x y) x) |
| // result: (Neg32 y) |
| for { |
| if v_0.Op != ssaop.OpSub32 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpNeg32) |
| v.AddArg(y) |
| return true |
| } |
| // match: (Sub32 x (Add32 x y)) |
| // result: (Neg32 y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpNeg32) |
| v.AddArg(y) |
| return true |
| } |
| break |
| } |
| // match: (Sub32 x (Sub32 i:(Const32 <t>) z)) |
| // cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) |
| // result: (Sub32 (Add32 <t> x z) i) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub32 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != ssaop.OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) { |
| break |
| } |
| v.Reset(ssaop.OpSub32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, t) |
| v0.AddArg2(x, z) |
| v.AddArg2(v0, i) |
| return true |
| } |
| // match: (Sub32 x (Add32 z i:(Const32 <t>))) |
| // cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) |
| // result: (Sub32 (Sub32 <t> x z) i) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| z := v_1_0 |
| i := v_1_1 |
| if i.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := i.Type |
| if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) { |
| continue |
| } |
| v.Reset(ssaop.OpSub32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub32, t) |
| v0.AddArg2(x, z) |
| v.AddArg2(v0, i) |
| return true |
| } |
| break |
| } |
| // match: (Sub32 (Sub32 i:(Const32 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) |
| // result: (Sub32 i (Add32 <t> z x)) |
| for { |
| if v_0.Op != ssaop.OpSub32 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != ssaop.OpConst32 { |
| break |
| } |
| t := i.Type |
| x := v_1 |
| if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) { |
| break |
| } |
| v.Reset(ssaop.OpSub32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| // match: (Sub32 (Add32 z i:(Const32 <t>)) x) |
| // cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) |
| // result: (Add32 i (Sub32 <t> z x)) |
| for { |
| if v_0.Op != ssaop.OpAdd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| z := v_0_0 |
| i := v_0_1 |
| if i.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := i.Type |
| x := v_1 |
| if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub32, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| break |
| } |
| // match: (Sub32 (Const32 <t> [c]) (Sub32 (Const32 <t> [d]) x)) |
| // result: (Add32 (Const32 <t> [c-d]) x) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpSub32 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst32 || v_1_0.Type != t { |
| break |
| } |
| d := ssa.AuxIntToInt32(v_1_0.AuxInt) |
| v.Reset(ssaop.OpAdd32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(c - d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Sub32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x)) |
| // result: (Sub32 (Const32 <t> [c-d]) x) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpAdd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst32 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpSub32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(c - d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpSub32F(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (Sub32F (Const32F [c]) (Const32F [d])) |
| // cond: c-d == c-d |
| // result: (Const32F [c-d]) |
| for { |
| if v_0.Op != ssaop.OpConst32F { |
| break |
| } |
| c := ssa.AuxIntToFloat32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32F { |
| break |
| } |
| d := ssa.AuxIntToFloat32(v_1.AuxInt) |
| if !(c-d == c-d) { |
| break |
| } |
| v.Reset(ssaop.OpConst32F) |
| v.AuxInt = ssa.Float32ToAuxInt(c - d) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpSub64(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Sub64 (Const64 [c]) (Const64 [d])) |
| // result: (Const64 [c-d]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(c - d) |
| return true |
| } |
| // match: (Sub64 x (Const64 <t> [c])) |
| // cond: x.Op != ssaop.OpConst64 |
| // result: (Add64 (Const64 <t> [-c]) x) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_1.Type |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(x.Op != ssaop.OpConst64) { |
| break |
| } |
| v.Reset(ssaop.OpAdd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(-c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Sub64 <t> (Mul64 x y) (Mul64 x z)) |
| // result: (Mul64 x (Sub64 <t> y z)) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpMul64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| y := v_0_1 |
| if v_1.Op != ssaop.OpMul64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| z := v_1_1 |
| v.Reset(ssaop.OpMul64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub64, t) |
| v0.AddArg2(y, z) |
| v.AddArg2(x, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Sub64 x x) |
| // result: (Const64 [0]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Sub64 (Neg64 x) (Com64 x)) |
| // result: (Const64 [1]) |
| for { |
| if v_0.Op != ssaop.OpNeg64 { |
| break |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpCom64 || x != v_1.Args[0] { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(1) |
| return true |
| } |
| // match: (Sub64 (Com64 x) (Neg64 x)) |
| // result: (Const64 [-1]) |
| for { |
| if v_0.Op != ssaop.OpCom64 { |
| break |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpNeg64 || x != v_1.Args[0] { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(-1) |
| return true |
| } |
| // match: (Sub64 (Add64 t x) (Add64 t y)) |
| // result: (Sub64 x y) |
| for { |
| if v_0.Op != ssaop.OpAdd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| t := v_0_0 |
| x := v_0_1 |
| if v_1.Op != ssaop.OpAdd64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if t != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpSub64) |
| v.AddArg2(x, y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Sub64 x (And64 <t> x y)) |
| // result: (And64 x (Com64 <t> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd64 { |
| break |
| } |
| t := v_1.Type |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpAnd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCom64, t) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Sub64 (Add64 x y) x) |
| // result: y |
| for { |
| if v_0.Op != ssaop.OpAdd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| y := v_0_1 |
| if x != v_1 { |
| continue |
| } |
| v.CopyOf(y) |
| return true |
| } |
| break |
| } |
| // match: (Sub64 (Add64 x y) y) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpAdd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| y := v_0_1 |
| if y != v_1 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Sub64 (Sub64 x y) x) |
| // result: (Neg64 y) |
| for { |
| if v_0.Op != ssaop.OpSub64 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpNeg64) |
| v.AddArg(y) |
| return true |
| } |
| // match: (Sub64 x (Add64 x y)) |
| // result: (Neg64 y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpNeg64) |
| v.AddArg(y) |
| return true |
| } |
| break |
| } |
| // match: (Sub64 x (Sub64 i:(Const64 <t>) z)) |
| // cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) |
| // result: (Sub64 (Add64 <t> x z) i) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub64 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != ssaop.OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) { |
| break |
| } |
| v.Reset(ssaop.OpSub64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, t) |
| v0.AddArg2(x, z) |
| v.AddArg2(v0, i) |
| return true |
| } |
| // match: (Sub64 x (Add64 z i:(Const64 <t>))) |
| // cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) |
| // result: (Sub64 (Sub64 <t> x z) i) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| z := v_1_0 |
| i := v_1_1 |
| if i.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := i.Type |
| if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) { |
| continue |
| } |
| v.Reset(ssaop.OpSub64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub64, t) |
| v0.AddArg2(x, z) |
| v.AddArg2(v0, i) |
| return true |
| } |
| break |
| } |
| // match: (Sub64 (Sub64 i:(Const64 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) |
| // result: (Sub64 i (Add64 <t> z x)) |
| for { |
| if v_0.Op != ssaop.OpSub64 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != ssaop.OpConst64 { |
| break |
| } |
| t := i.Type |
| x := v_1 |
| if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) { |
| break |
| } |
| v.Reset(ssaop.OpSub64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| // match: (Sub64 (Add64 z i:(Const64 <t>)) x) |
| // cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) |
| // result: (Add64 i (Sub64 <t> z x)) |
| for { |
| if v_0.Op != ssaop.OpAdd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| z := v_0_0 |
| i := v_0_1 |
| if i.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := i.Type |
| x := v_1 |
| if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub64, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| break |
| } |
| // match: (Sub64 (Const64 <t> [c]) (Sub64 (Const64 <t> [d]) x)) |
| // result: (Add64 (Const64 <t> [c-d]) x) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpSub64 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst64 || v_1_0.Type != t { |
| break |
| } |
| d := ssa.AuxIntToInt64(v_1_0.AuxInt) |
| v.Reset(ssaop.OpAdd64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c - d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Sub64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x)) |
| // result: (Sub64 (Const64 <t> [c-d]) x) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpAdd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst64 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpSub64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c - d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpSub64F(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| // match: (Sub64F (Const64F [c]) (Const64F [d])) |
| // cond: c-d == c-d |
| // result: (Const64F [c-d]) |
| for { |
| if v_0.Op != ssaop.OpConst64F { |
| break |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64F { |
| break |
| } |
| d := ssa.AuxIntToFloat64(v_1.AuxInt) |
| if !(c-d == c-d) { |
| break |
| } |
| v.Reset(ssaop.OpConst64F) |
| v.AuxInt = ssa.Float64ToAuxInt(c - d) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpSub64borrow(v *ssa.Value) bool { |
| v_2 := v.Args[2] |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Sub64borrow (Const64 <t> [x]) (Const64 [y]) (Const64 [borrowVal])) |
| // cond: borrowVal >= 0 && borrowVal <= 1 |
| // result: (MakeTuple (Const64 <t> [bitsSub64(x, y, borrowVal).diff]) (Const64 <t> [bitsSub64(x, y, borrowVal).borrow])) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| t := v_0.Type |
| x := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| y := ssa.AuxIntToInt64(v_1.AuxInt) |
| if v_2.Op != ssaop.OpConst64 { |
| break |
| } |
| borrowVal := ssa.AuxIntToInt64(v_2.AuxInt) |
| if !(borrowVal >= 0 && borrowVal <= 1) { |
| break |
| } |
| v.Reset(ssaop.OpMakeTuple) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(bitsSub64(x, y, borrowVal).diff) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v1.AuxInt = ssa.Int64ToAuxInt(bitsSub64(x, y, borrowVal).borrow) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpSub8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Sub8 (Const8 [c]) (Const8 [d])) |
| // result: (Const8 [c-d]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(c - d) |
| return true |
| } |
| // match: (Sub8 x (Const8 <t> [c])) |
| // cond: x.Op != ssaop.OpConst8 |
| // result: (Add8 (Const8 <t> [-c]) x) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| t := v_1.Type |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(x.Op != ssaop.OpConst8) { |
| break |
| } |
| v.Reset(ssaop.OpAdd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(-c) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Sub8 <t> (Mul8 x y) (Mul8 x z)) |
| // result: (Mul8 x (Sub8 <t> y z)) |
| for { |
| t := v.Type |
| if v_0.Op != ssaop.OpMul8 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| y := v_0_1 |
| if v_1.Op != ssaop.OpMul8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| z := v_1_1 |
| v.Reset(ssaop.OpMul8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub8, t) |
| v0.AddArg2(y, z) |
| v.AddArg2(x, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Sub8 x x) |
| // result: (Const8 [0]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Sub8 (Neg8 x) (Com8 x)) |
| // result: (Const8 [1]) |
| for { |
| if v_0.Op != ssaop.OpNeg8 { |
| break |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpCom8 || x != v_1.Args[0] { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(1) |
| return true |
| } |
| // match: (Sub8 (Com8 x) (Neg8 x)) |
| // result: (Const8 [-1]) |
| for { |
| if v_0.Op != ssaop.OpCom8 { |
| break |
| } |
| x := v_0.Args[0] |
| if v_1.Op != ssaop.OpNeg8 || x != v_1.Args[0] { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(-1) |
| return true |
| } |
| // match: (Sub8 (Add8 t x) (Add8 t y)) |
| // result: (Sub8 x y) |
| for { |
| if v_0.Op != ssaop.OpAdd8 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| t := v_0_0 |
| x := v_0_1 |
| if v_1.Op != ssaop.OpAdd8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if t != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpSub8) |
| v.AddArg2(x, y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Sub8 x (And8 <t> x y)) |
| // result: (And8 x (Com8 <t> y)) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAnd8 { |
| break |
| } |
| t := v_1.Type |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpAnd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCom8, t) |
| v0.AddArg(y) |
| v.AddArg2(x, v0) |
| return true |
| } |
| break |
| } |
| // match: (Sub8 (Add8 x y) x) |
| // result: y |
| for { |
| if v_0.Op != ssaop.OpAdd8 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| y := v_0_1 |
| if x != v_1 { |
| continue |
| } |
| v.CopyOf(y) |
| return true |
| } |
| break |
| } |
| // match: (Sub8 (Add8 x y) y) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpAdd8 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| x := v_0_0 |
| y := v_0_1 |
| if y != v_1 { |
| continue |
| } |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Sub8 (Sub8 x y) x) |
| // result: (Neg8 y) |
| for { |
| if v_0.Op != ssaop.OpSub8 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpNeg8) |
| v.AddArg(y) |
| return true |
| } |
| // match: (Sub8 x (Add8 x y)) |
| // result: (Neg8 y) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.Reset(ssaop.OpNeg8) |
| v.AddArg(y) |
| return true |
| } |
| break |
| } |
| // match: (Sub8 x (Sub8 i:(Const8 <t>) z)) |
| // cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) |
| // result: (Sub8 (Add8 <t> x z) i) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpSub8 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != ssaop.OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) { |
| break |
| } |
| v.Reset(ssaop.OpSub8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, t) |
| v0.AddArg2(x, z) |
| v.AddArg2(v0, i) |
| return true |
| } |
| // match: (Sub8 x (Add8 z i:(Const8 <t>))) |
| // cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) |
| // result: (Sub8 (Sub8 <t> x z) i) |
| for { |
| x := v_0 |
| if v_1.Op != ssaop.OpAdd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| z := v_1_0 |
| i := v_1_1 |
| if i.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := i.Type |
| if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) { |
| continue |
| } |
| v.Reset(ssaop.OpSub8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub8, t) |
| v0.AddArg2(x, z) |
| v.AddArg2(v0, i) |
| return true |
| } |
| break |
| } |
| // match: (Sub8 (Sub8 i:(Const8 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) |
| // result: (Sub8 i (Add8 <t> z x)) |
| for { |
| if v_0.Op != ssaop.OpSub8 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != ssaop.OpConst8 { |
| break |
| } |
| t := i.Type |
| x := v_1 |
| if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) { |
| break |
| } |
| v.Reset(ssaop.OpSub8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| // match: (Sub8 (Add8 z i:(Const8 <t>)) x) |
| // cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) |
| // result: (Add8 i (Sub8 <t> z x)) |
| for { |
| if v_0.Op != ssaop.OpAdd8 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| z := v_0_0 |
| i := v_0_1 |
| if i.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := i.Type |
| x := v_1 |
| if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) { |
| continue |
| } |
| v.Reset(ssaop.OpAdd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpSub8, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| break |
| } |
| // match: (Sub8 (Const8 <t> [c]) (Sub8 (Const8 <t> [d]) x)) |
| // result: (Add8 (Const8 <t> [c-d]) x) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpSub8 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != ssaop.OpConst8 || v_1_0.Type != t { |
| break |
| } |
| d := ssa.AuxIntToInt8(v_1_0.AuxInt) |
| v.Reset(ssaop.OpAdd8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(c - d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| // match: (Sub8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x)) |
| // result: (Sub8 (Const8 <t> [c-d]) x) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpAdd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_1_0, v_1_1 = _i0+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst8 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpSub8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(c - d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpTrunc(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Trunc (Const64F [c])) |
| // result: (Const64F [math.Trunc(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst64F { |
| break |
| } |
| c := ssa.AuxIntToFloat64(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64F) |
| v.AuxInt = ssa.Float64ToAuxInt(math.Trunc(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpTrunc16to8(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Trunc16to8 (Const16 [c])) |
| // result: (Const8 [int8(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(int8(c)) |
| return true |
| } |
| // match: (Trunc16to8 (ZeroExt8to16 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpZeroExt8to16 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Trunc16to8 (SignExt8to16 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpSignExt8to16 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Trunc16to8 (And16 (Const16 [y]) x)) |
| // cond: y&0xFF == 0xFF |
| // result: (Trunc16to8 x) |
| for { |
| if v_0.Op != ssaop.OpAnd16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| y := ssa.AuxIntToInt16(v_0_0.AuxInt) |
| x := v_0_1 |
| if !(y&0xFF == 0xFF) { |
| continue |
| } |
| v.Reset(ssaop.OpTrunc16to8) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpTrunc32to16(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Trunc32to16 (Const32 [c])) |
| // result: (Const16 [int16(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(int16(c)) |
| return true |
| } |
| // match: (Trunc32to16 (ZeroExt8to32 x)) |
| // result: (ZeroExt8to16 x) |
| for { |
| if v_0.Op != ssaop.OpZeroExt8to32 { |
| break |
| } |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpZeroExt8to16) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Trunc32to16 (ZeroExt16to32 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpZeroExt16to32 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Trunc32to16 (SignExt8to32 x)) |
| // result: (SignExt8to16 x) |
| for { |
| if v_0.Op != ssaop.OpSignExt8to32 { |
| break |
| } |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpSignExt8to16) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Trunc32to16 (SignExt16to32 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpSignExt16to32 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Trunc32to16 (And32 (Const32 [y]) x)) |
| // cond: y&0xFFFF == 0xFFFF |
| // result: (Trunc32to16 x) |
| for { |
| if v_0.Op != ssaop.OpAnd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| y := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| x := v_0_1 |
| if !(y&0xFFFF == 0xFFFF) { |
| continue |
| } |
| v.Reset(ssaop.OpTrunc32to16) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpTrunc32to8(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Trunc32to8 (Const32 [c])) |
| // result: (Const8 [int8(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(int8(c)) |
| return true |
| } |
| // match: (Trunc32to8 (ZeroExt8to32 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpZeroExt8to32 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Trunc32to8 (SignExt8to32 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpSignExt8to32 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Trunc32to8 (And32 (Const32 [y]) x)) |
| // cond: y&0xFF == 0xFF |
| // result: (Trunc32to8 x) |
| for { |
| if v_0.Op != ssaop.OpAnd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| y := ssa.AuxIntToInt32(v_0_0.AuxInt) |
| x := v_0_1 |
| if !(y&0xFF == 0xFF) { |
| continue |
| } |
| v.Reset(ssaop.OpTrunc32to8) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpTrunc64to16(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Trunc64to16 (Const64 [c])) |
| // result: (Const16 [int16(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(int16(c)) |
| return true |
| } |
| // match: (Trunc64to16 (ZeroExt8to64 x)) |
| // result: (ZeroExt8to16 x) |
| for { |
| if v_0.Op != ssaop.OpZeroExt8to64 { |
| break |
| } |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpZeroExt8to16) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Trunc64to16 (ZeroExt16to64 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpZeroExt16to64 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Trunc64to16 (SignExt8to64 x)) |
| // result: (SignExt8to16 x) |
| for { |
| if v_0.Op != ssaop.OpSignExt8to64 { |
| break |
| } |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpSignExt8to16) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Trunc64to16 (SignExt16to64 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpSignExt16to64 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Trunc64to16 (And64 (Const64 [y]) x)) |
| // cond: y&0xFFFF == 0xFFFF |
| // result: (Trunc64to16 x) |
| for { |
| if v_0.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| y := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| x := v_0_1 |
| if !(y&0xFFFF == 0xFFFF) { |
| continue |
| } |
| v.Reset(ssaop.OpTrunc64to16) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpTrunc64to32(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Trunc64to32 (Const64 [c])) |
| // result: (Const32 [int32(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(c)) |
| return true |
| } |
| // match: (Trunc64to32 (ZeroExt8to64 x)) |
| // result: (ZeroExt8to32 x) |
| for { |
| if v_0.Op != ssaop.OpZeroExt8to64 { |
| break |
| } |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpZeroExt8to32) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Trunc64to32 (ZeroExt16to64 x)) |
| // result: (ZeroExt16to32 x) |
| for { |
| if v_0.Op != ssaop.OpZeroExt16to64 { |
| break |
| } |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpZeroExt16to32) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Trunc64to32 (ZeroExt32to64 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpZeroExt32to64 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Trunc64to32 (SignExt8to64 x)) |
| // result: (SignExt8to32 x) |
| for { |
| if v_0.Op != ssaop.OpSignExt8to64 { |
| break |
| } |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpSignExt8to32) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Trunc64to32 (SignExt16to64 x)) |
| // result: (SignExt16to32 x) |
| for { |
| if v_0.Op != ssaop.OpSignExt16to64 { |
| break |
| } |
| x := v_0.Args[0] |
| v.Reset(ssaop.OpSignExt16to32) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Trunc64to32 (SignExt32to64 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpSignExt32to64 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Trunc64to32 (And64 (Const64 [y]) x)) |
| // cond: y&0xFFFFFFFF == 0xFFFFFFFF |
| // result: (Trunc64to32 x) |
| for { |
| if v_0.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| y := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| x := v_0_1 |
| if !(y&0xFFFFFFFF == 0xFFFFFFFF) { |
| continue |
| } |
| v.Reset(ssaop.OpTrunc64to32) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpTrunc64to8(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (Trunc64to8 (Const64 [c])) |
| // result: (Const8 [int8(c)]) |
| for { |
| if v_0.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(int8(c)) |
| return true |
| } |
| // match: (Trunc64to8 (ZeroExt8to64 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpZeroExt8to64 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Trunc64to8 (SignExt8to64 x)) |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpSignExt8to64 { |
| break |
| } |
| x := v_0.Args[0] |
| v.CopyOf(x) |
| return true |
| } |
| // match: (Trunc64to8 (And64 (Const64 [y]) x)) |
| // cond: y&0xFF == 0xFF |
| // result: (Trunc64to8 x) |
| for { |
| if v_0.Op != ssaop.OpAnd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { |
| if v_0_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| y := ssa.AuxIntToInt64(v_0_0.AuxInt) |
| x := v_0_1 |
| if !(y&0xFF == 0xFF) { |
| continue |
| } |
| v.Reset(ssaop.OpTrunc64to8) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpXor16(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: (Xor16 (Const16 [c]) (Const16 [d])) |
| // result: (Const16 [c^d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(c ^ d) |
| return true |
| } |
| break |
| } |
| // match: (Xor16 x x) |
| // result: (Const16 [0]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(0) |
| return true |
| } |
| // match: (Xor16 (Const16 [0]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != 0 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Xor16 (Com16 x) x) |
| // result: (Const16 [-1]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom16 { |
| continue |
| } |
| x := v_0.Args[0] |
| if x != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(-1) |
| return true |
| } |
| break |
| } |
| // match: (Xor16 (Const16 [-1]) x) |
| // result: (Com16 x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_0.AuxInt) != -1 { |
| continue |
| } |
| x := v_1 |
| v.Reset(ssaop.OpCom16) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| // match: (Xor16 x (Xor16 x y)) |
| // result: y |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpXor16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.CopyOf(y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Xor16 (Xor16 i:(Const16 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) |
| // result: (Xor16 i (Xor16 <t> z x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpXor16 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst16 && x.Op != ssaop.OpConst16) { |
| continue |
| } |
| v.Reset(ssaop.OpXor16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpXor16, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Xor16 (Const16 <t> [c]) (Xor16 (Const16 <t> [d]) x)) |
| // result: (Xor16 (Const16 <t> [c^d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst16 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| if v_1.Op != ssaop.OpXor16 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst16 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt16(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpXor16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst16, t) |
| v0.AuxInt = ssa.Int16ToAuxInt(c ^ d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Xor16 (Lsh16x64 x z:(Const64 <t> [c])) (Rsh16Ux64 x (Const64 [d]))) |
| // cond: c < 16 && d == 16-c && canRotate(config, 16) |
| // result: (RotateLeft16 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLsh16x64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| z := v_0.Args[1] |
| if z.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(z.AuxInt) |
| if v_1.Op != ssaop.OpRsh16Ux64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c < 16 && d == 16-c && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor16 left:(Lsh16x64 x y) right:(Rsh16Ux64 x (Sub64 (Const64 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh16x64 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh16Ux64 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Xor16 left:(Lsh16x32 x y) right:(Rsh16Ux32 x (Sub32 (Const32 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh16x32 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh16Ux32 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Xor16 left:(Lsh16x16 x y) right:(Rsh16Ux16 x (Sub16 (Const16 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh16x16 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh16Ux16 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Xor16 left:(Lsh16x8 x y) right:(Rsh16Ux8 x (Sub8 (Const8 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh16x8 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh16Ux8 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 16 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Xor16 right:(Rsh16Ux64 x y) left:(Lsh16x64 x z:(Sub64 (Const64 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh16Ux64 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh16x64 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor16 right:(Rsh16Ux32 x y) left:(Lsh16x32 x z:(Sub32 (Const32 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh16Ux32 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh16x32 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor16 right:(Rsh16Ux16 x y) left:(Lsh16x16 x z:(Sub16 (Const16 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh16Ux16 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh16x16 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor16 right:(Rsh16Ux8 x y) left:(Lsh16x8 x z:(Sub8 (Const8 [16]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16) |
| // result: (RotateLeft16 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh16Ux8 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh16x8 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 16 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 16)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft16) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor16 (ZeroExt8to16 (CvtBoolToUint8 <cvtT> bool)) (Const16 [1])) |
| // cond: invertibleBool(bool.Op) |
| // result: (ZeroExt8to16 (CvtBoolToUint8 <cvtT> (Not <bool.Type> bool))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to16 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| cvtT := v_0_0.Type |
| bool := v_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(v_1.AuxInt) != 1 || !(invertibleBool(bool.Op)) { |
| continue |
| } |
| v.Reset(ssaop.OpZeroExt8to16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, cvtT) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (Xor16 (ZeroExt8to16 (CvtBoolToUint8 <cvtT> (Not bool))) (Const16 <constT> [c])) |
| // cond: c != 1 |
| // result: (Xor16 (ZeroExt8to16 (CvtBoolToUint8 <cvtT> bool)) (Const16 <constT> [c^1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to16 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| cvtT := v_0_0.Type |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != ssaop.OpNot { |
| continue |
| } |
| bool := v_0_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst16 { |
| continue |
| } |
| constT := v_1.Type |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(c != 1) { |
| continue |
| } |
| v.Reset(ssaop.OpXor16) |
| v0 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, cvtT) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst16, constT) |
| v2.AuxInt = ssa.Int16ToAuxInt(c ^ 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpXor32(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: (Xor32 (Const32 [c]) (Const32 [d])) |
| // result: (Const32 [c^d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(c ^ d) |
| return true |
| } |
| break |
| } |
| // match: (Xor32 x x) |
| // result: (Const32 [0]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(0) |
| return true |
| } |
| // match: (Xor32 (Const32 [0]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != 0 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Xor32 (Com32 x) x) |
| // result: (Const32 [-1]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom32 { |
| continue |
| } |
| x := v_0.Args[0] |
| if x != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(-1) |
| return true |
| } |
| break |
| } |
| // match: (Xor32 (Const32 [-1]) x) |
| // result: (Com32 x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_0.AuxInt) != -1 { |
| continue |
| } |
| x := v_1 |
| v.Reset(ssaop.OpCom32) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| // match: (Xor32 x (Xor32 x y)) |
| // result: y |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpXor32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.CopyOf(y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Xor32 (Xor32 i:(Const32 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) |
| // result: (Xor32 i (Xor32 <t> z x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpXor32 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst32 && x.Op != ssaop.OpConst32) { |
| continue |
| } |
| v.Reset(ssaop.OpXor32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpXor32, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Xor32 (Const32 <t> [c]) (Xor32 (Const32 <t> [d]) x)) |
| // result: (Xor32 (Const32 <t> [c^d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst32 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| if v_1.Op != ssaop.OpXor32 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst32 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt32(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpXor32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst32, t) |
| v0.AuxInt = ssa.Int32ToAuxInt(c ^ d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Xor32 (Lsh32x64 x z:(Const64 <t> [c])) (Rsh32Ux64 x (Const64 [d]))) |
| // cond: c < 32 && d == 32-c && canRotate(config, 32) |
| // result: (RotateLeft32 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLsh32x64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| z := v_0.Args[1] |
| if z.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(z.AuxInt) |
| if v_1.Op != ssaop.OpRsh32Ux64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c < 32 && d == 32-c && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor32 left:(Lsh32x64 x y) right:(Rsh32Ux64 x (Sub64 (Const64 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh32x64 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh32Ux64 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Xor32 left:(Lsh32x32 x y) right:(Rsh32Ux32 x (Sub32 (Const32 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh32x32 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh32Ux32 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Xor32 left:(Lsh32x16 x y) right:(Rsh32Ux16 x (Sub16 (Const16 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh32x16 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh32Ux16 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Xor32 left:(Lsh32x8 x y) right:(Rsh32Ux8 x (Sub8 (Const8 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh32x8 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh32Ux8 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 32 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Xor32 right:(Rsh32Ux64 x y) left:(Lsh32x64 x z:(Sub64 (Const64 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh32Ux64 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh32x64 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor32 right:(Rsh32Ux32 x y) left:(Lsh32x32 x z:(Sub32 (Const32 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh32Ux32 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh32x32 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor32 right:(Rsh32Ux16 x y) left:(Lsh32x16 x z:(Sub16 (Const16 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh32Ux16 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh32x16 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor32 right:(Rsh32Ux8 x y) left:(Lsh32x8 x z:(Sub8 (Const8 [32]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32) |
| // result: (RotateLeft32 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh32Ux8 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh32x8 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 32 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 32)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft32) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor32 (ZeroExt8to32 (CvtBoolToUint8 <cvtT> bool)) (Const32 [1])) |
| // cond: invertibleBool(bool.Op) |
| // result: (ZeroExt8to32 (CvtBoolToUint8 <cvtT> (Not <bool.Type> bool))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to32 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| cvtT := v_0_0.Type |
| bool := v_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(v_1.AuxInt) != 1 || !(invertibleBool(bool.Op)) { |
| continue |
| } |
| v.Reset(ssaop.OpZeroExt8to32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, cvtT) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (Xor32 (ZeroExt8to32 (CvtBoolToUint8 <cvtT> (Not bool))) (Const32 <constT> [c])) |
| // cond: c != 1 |
| // result: (Xor32 (ZeroExt8to32 (CvtBoolToUint8 <cvtT> bool)) (Const32 <constT> [c^1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to32 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| cvtT := v_0_0.Type |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != ssaop.OpNot { |
| continue |
| } |
| bool := v_0_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst32 { |
| continue |
| } |
| constT := v_1.Type |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(c != 1) { |
| continue |
| } |
| v.Reset(ssaop.OpXor32) |
| v0 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, cvtT) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, constT) |
| v2.AuxInt = ssa.Int32ToAuxInt(c ^ 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpXor64(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: (Xor64 (Const64 [c]) (Const64 [d])) |
| // result: (Const64 [c^d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(c ^ d) |
| return true |
| } |
| break |
| } |
| // match: (Xor64 x x) |
| // result: (Const64 [0]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(0) |
| return true |
| } |
| // match: (Xor64 (Const64 [0]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Xor64 (Com64 x) x) |
| // result: (Const64 [-1]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom64 { |
| continue |
| } |
| x := v_0.Args[0] |
| if x != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(-1) |
| return true |
| } |
| break |
| } |
| // match: (Xor64 (Const64 [-1]) x) |
| // result: (Com64 x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_0.AuxInt) != -1 { |
| continue |
| } |
| x := v_1 |
| v.Reset(ssaop.OpCom64) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| // match: (Xor64 x (Xor64 x y)) |
| // result: y |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpXor64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.CopyOf(y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Xor64 (Xor64 i:(Const64 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) |
| // result: (Xor64 i (Xor64 <t> z x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpXor64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst64 && x.Op != ssaop.OpConst64) { |
| continue |
| } |
| v.Reset(ssaop.OpXor64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpXor64, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Xor64 (Const64 <t> [c]) (Xor64 (Const64 <t> [d]) x)) |
| // result: (Xor64 (Const64 <t> [c^d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst64 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt64(v_0.AuxInt) |
| if v_1.Op != ssaop.OpXor64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst64 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpXor64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst64, t) |
| v0.AuxInt = ssa.Int64ToAuxInt(c ^ d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Xor64 (Lsh64x64 x z:(Const64 <t> [c])) (Rsh64Ux64 x (Const64 [d]))) |
| // cond: c < 64 && d == 64-c && canRotate(config, 64) |
| // result: (RotateLeft64 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLsh64x64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| z := v_0.Args[1] |
| if z.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(z.AuxInt) |
| if v_1.Op != ssaop.OpRsh64Ux64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c < 64 && d == 64-c && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor64 left:(Lsh64x64 x y) right:(Rsh64Ux64 x (Sub64 (Const64 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh64x64 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh64Ux64 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Xor64 left:(Lsh64x32 x y) right:(Rsh64Ux32 x (Sub32 (Const32 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh64x32 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh64Ux32 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Xor64 left:(Lsh64x16 x y) right:(Rsh64Ux16 x (Sub16 (Const16 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh64x16 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh64Ux16 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Xor64 left:(Lsh64x8 x y) right:(Rsh64Ux8 x (Sub8 (Const8 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh64x8 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh64Ux8 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 64 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Xor64 right:(Rsh64Ux64 x y) left:(Lsh64x64 x z:(Sub64 (Const64 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh64Ux64 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh64x64 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor64 right:(Rsh64Ux32 x y) left:(Lsh64x32 x z:(Sub32 (Const32 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh64Ux32 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh64x32 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor64 right:(Rsh64Ux16 x y) left:(Lsh64x16 x z:(Sub16 (Const16 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh64Ux16 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh64x16 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor64 right:(Rsh64Ux8 x y) left:(Lsh64x8 x z:(Sub8 (Const8 [64]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64) |
| // result: (RotateLeft64 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh64Ux8 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh64x8 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 64 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 64)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft64) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor64 (ZeroExt8to64 (CvtBoolToUint8 <cvtT> bool)) (Const64 [1])) |
| // cond: invertibleBool(bool.Op) |
| // result: (ZeroExt8to64 (CvtBoolToUint8 <cvtT> (Not <bool.Type> bool))) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to64 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| cvtT := v_0_0.Type |
| bool := v_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(v_1.AuxInt) != 1 || !(invertibleBool(bool.Op)) { |
| continue |
| } |
| v.Reset(ssaop.OpZeroExt8to64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, cvtT) |
| v1 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (Xor64 (ZeroExt8to64 (CvtBoolToUint8 <cvtT> (Not bool))) (Const64 <constT> [c])) |
| // cond: c != 1 |
| // result: (Xor64 (ZeroExt8to64 (CvtBoolToUint8 <cvtT> bool)) (Const64 <constT> [c^1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpZeroExt8to64 { |
| continue |
| } |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| cvtT := v_0_0.Type |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != ssaop.OpNot { |
| continue |
| } |
| bool := v_0_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| constT := v_1.Type |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(c != 1) { |
| continue |
| } |
| v.Reset(ssaop.OpXor64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, cvtT) |
| v1.AddArg(bool) |
| v0.AddArg(v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, constT) |
| v2.AuxInt = ssa.Int64ToAuxInt(c ^ 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpXor8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| // match: (Xor8 (Const8 [c]) (Const8 [d])) |
| // result: (Const8 [c^d]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1.AuxInt) |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(c ^ d) |
| return true |
| } |
| break |
| } |
| // match: (Xor8 x x) |
| // result: (Const8 [0]) |
| for { |
| x := v_0 |
| if x != v_1 { |
| break |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(0) |
| return true |
| } |
| // match: (Xor8 (Const8 [0]) x) |
| // result: x |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != 0 { |
| continue |
| } |
| x := v_1 |
| v.CopyOf(x) |
| return true |
| } |
| break |
| } |
| // match: (Xor8 (Com8 x) x) |
| // result: (Const8 [-1]) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCom8 { |
| continue |
| } |
| x := v_0.Args[0] |
| if x != v_1 { |
| continue |
| } |
| v.Reset(ssaop.OpConst8) |
| v.AuxInt = ssa.Int8ToAuxInt(-1) |
| return true |
| } |
| break |
| } |
| // match: (Xor8 (Const8 [-1]) x) |
| // result: (Com8 x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_0.AuxInt) != -1 { |
| continue |
| } |
| x := v_1 |
| v.Reset(ssaop.OpCom8) |
| v.AddArg(x) |
| return true |
| } |
| break |
| } |
| // match: (Xor8 x (Xor8 x y)) |
| // result: y |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| x := v_0 |
| if v_1.Op != ssaop.OpXor8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if x != v_1_0 { |
| continue |
| } |
| y := v_1_1 |
| v.CopyOf(y) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Xor8 (Xor8 i:(Const8 <t>) z) x) |
| // cond: (z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) |
| // result: (Xor8 i (Xor8 <t> z x)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpXor8 { |
| continue |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_0_0, v_0_1 = _i1+1, v_0_1, v_0_0 { |
| i := v_0_0 |
| if i.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := i.Type |
| z := v_0_1 |
| x := v_1 |
| if !(z.Op != ssaop.OpConst8 && x.Op != ssaop.OpConst8) { |
| continue |
| } |
| v.Reset(ssaop.OpXor8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpXor8, t) |
| v0.AddArg2(z, x) |
| v.AddArg2(i, v0) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Xor8 (Const8 <t> [c]) (Xor8 (Const8 <t> [d]) x)) |
| // result: (Xor8 (Const8 <t> [c^d]) x) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpConst8 { |
| continue |
| } |
| t := v_0.Type |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| if v_1.Op != ssaop.OpXor8 { |
| continue |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 { |
| if v_1_0.Op != ssaop.OpConst8 || v_1_0.Type != t { |
| continue |
| } |
| d := ssa.AuxIntToInt8(v_1_0.AuxInt) |
| x := v_1_1 |
| v.Reset(ssaop.OpXor8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpConst8, t) |
| v0.AuxInt = ssa.Int8ToAuxInt(c ^ d) |
| v.AddArg2(v0, x) |
| return true |
| } |
| } |
| break |
| } |
| // match: (Xor8 (Lsh8x64 x z:(Const64 <t> [c])) (Rsh8Ux64 x (Const64 [d]))) |
| // cond: c < 8 && d == 8-c && canRotate(config, 8) |
| // result: (RotateLeft8 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpLsh8x64 { |
| continue |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| z := v_0.Args[1] |
| if z.Op != ssaop.OpConst64 { |
| continue |
| } |
| c := ssa.AuxIntToInt64(z.AuxInt) |
| if v_1.Op != ssaop.OpRsh8Ux64 { |
| continue |
| } |
| _ = v_1.Args[1] |
| if x != v_1.Args[0] { |
| continue |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != ssaop.OpConst64 { |
| continue |
| } |
| d := ssa.AuxIntToInt64(v_1_1.AuxInt) |
| if !(c < 8 && d == 8-c && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor8 left:(Lsh8x64 x y) right:(Rsh8Ux64 x (Sub64 (Const64 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh8x64 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh8Ux64 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Xor8 left:(Lsh8x32 x y) right:(Rsh8Ux32 x (Sub32 (Const32 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh8x32 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh8Ux32 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Xor8 left:(Lsh8x16 x y) right:(Rsh8Ux16 x (Sub16 (Const16 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh8x16 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh8Ux16 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Xor8 left:(Lsh8x8 x y) right:(Rsh8Ux8 x (Sub8 (Const8 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x y) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| left := v_0 |
| if left.Op != ssaop.OpLsh8x8 { |
| continue |
| } |
| y := left.Args[1] |
| x := left.Args[0] |
| right := v_1 |
| if right.Op != ssaop.OpRsh8Ux8 { |
| continue |
| } |
| _ = right.Args[1] |
| if x != right.Args[0] { |
| continue |
| } |
| right_1 := right.Args[1] |
| if right_1.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = right_1.Args[1] |
| right_1_0 := right_1.Args[0] |
| if right_1_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(right_1_0.AuxInt) != 8 || y != right_1.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, y) |
| return true |
| } |
| break |
| } |
| // match: (Xor8 right:(Rsh8Ux64 x y) left:(Lsh8x64 x z:(Sub64 (Const64 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh8Ux64 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh8x64 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub64 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst64 || ssa.AuxIntToInt64(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor8 right:(Rsh8Ux32 x y) left:(Lsh8x32 x z:(Sub32 (Const32 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh8Ux32 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh8x32 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub32 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst32 || ssa.AuxIntToInt32(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor8 right:(Rsh8Ux16 x y) left:(Lsh8x16 x z:(Sub16 (Const16 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh8Ux16 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh8x16 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub16 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst16 || ssa.AuxIntToInt16(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor8 right:(Rsh8Ux8 x y) left:(Lsh8x8 x z:(Sub8 (Const8 [8]) y))) |
| // cond: (ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8) |
| // result: (RotateLeft8 x z) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| right := v_0 |
| if right.Op != ssaop.OpRsh8Ux8 { |
| continue |
| } |
| y := right.Args[1] |
| x := right.Args[0] |
| left := v_1 |
| if left.Op != ssaop.OpLsh8x8 { |
| continue |
| } |
| _ = left.Args[1] |
| if x != left.Args[0] { |
| continue |
| } |
| z := left.Args[1] |
| if z.Op != ssaop.OpSub8 { |
| continue |
| } |
| _ = z.Args[1] |
| z_0 := z.Args[0] |
| if z_0.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(z_0.AuxInt) != 8 || y != z.Args[1] || !((ssa.ShiftIsBounded(left) || ssa.ShiftIsBounded(right)) && canRotate(config, 8)) { |
| continue |
| } |
| v.Reset(ssaop.OpRotateLeft8) |
| v.AddArg2(x, z) |
| return true |
| } |
| break |
| } |
| // match: (Xor8 (CvtBoolToUint8 bool) (Const8 [1])) |
| // cond: invertibleBool(bool.Op) |
| // result: (CvtBoolToUint8 (Not <bool.Type> bool)) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| bool := v_0.Args[0] |
| if v_1.Op != ssaop.OpConst8 || ssa.AuxIntToInt8(v_1.AuxInt) != 1 || !(invertibleBool(bool.Op)) { |
| continue |
| } |
| v.Reset(ssaop.OpCvtBoolToUint8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpNot, bool.Type) |
| v0.AddArg(bool) |
| v.AddArg(v0) |
| return true |
| } |
| break |
| } |
| // match: (Xor8 (CvtBoolToUint8 <cvtT> (Not bool)) (Const8 <constT> [c])) |
| // cond: c != 1 |
| // result: (Xor8 (CvtBoolToUint8 <cvtT> bool) (Const8 <constT> [c^1])) |
| for { |
| for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { |
| if v_0.Op != ssaop.OpCvtBoolToUint8 { |
| continue |
| } |
| cvtT := v_0.Type |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != ssaop.OpNot { |
| continue |
| } |
| bool := v_0_0.Args[0] |
| if v_1.Op != ssaop.OpConst8 { |
| continue |
| } |
| constT := v_1.Type |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(c != 1) { |
| continue |
| } |
| v.Reset(ssaop.OpXor8) |
| v0 := b.NewValue0(v.Pos, ssaop.OpCvtBoolToUint8, cvtT) |
| v0.AddArg(bool) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst8, constT) |
| v1.AuxInt = ssa.Int8ToAuxInt(c ^ 1) |
| v.AddArg2(v0, v1) |
| return true |
| } |
| break |
| } |
| return false |
| } |
| func rewriteValue_OpZero(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| // match: (Zero (SelectN [0] call:(StaticLECall ___)) mem:(SelectN [1] call)) |
| // cond: isMalloc(call.Aux) |
| // result: mem |
| for { |
| if v_0.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(v_0.AuxInt) != 0 { |
| break |
| } |
| call := v_0.Args[0] |
| if call.Op != ssaop.OpStaticLECall { |
| break |
| } |
| mem := v_1 |
| if mem.Op != ssaop.OpSelectN || ssa.AuxIntToInt64(mem.AuxInt) != 1 || call != mem.Args[0] || !(isMalloc(call.Aux)) { |
| break |
| } |
| v.CopyOf(mem) |
| return true |
| } |
| // match: (Zero {t1} [n] p1 store:(Store {t2} (OffPtr [o2] p2) _ mem)) |
| // cond: ssa.IsSamePtr(p1, p2) && store.Uses == 1 && n >= o2 + t2.Size() && ssa.Clobber(store) |
| // result: (Zero {t1} [n] p1 mem) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t1 := ssa.AuxToType(v.Aux) |
| p1 := v_0 |
| store := v_1 |
| if store.Op != ssaop.OpStore { |
| break |
| } |
| t2 := ssa.AuxToType(store.Aux) |
| mem := store.Args[2] |
| store_0 := store.Args[0] |
| if store_0.Op != ssaop.OpOffPtr { |
| break |
| } |
| o2 := ssa.AuxIntToInt64(store_0.AuxInt) |
| p2 := store_0.Args[0] |
| if !(ssa.IsSamePtr(p1, p2) && store.Uses == 1 && n >= o2+t2.Size() && ssa.Clobber(store)) { |
| break |
| } |
| v.Reset(ssaop.OpZero) |
| v.AuxInt = ssa.Int64ToAuxInt(n) |
| v.Aux = ssa.TypeToAux(t1) |
| v.AddArg2(p1, mem) |
| return true |
| } |
| // match: (Zero {t} [n] dst1 move:(Move {t} [n] dst2 _ mem)) |
| // cond: move.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Clobber(move) |
| // result: (Zero {t} [n] dst1 mem) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t := ssa.AuxToType(v.Aux) |
| dst1 := v_0 |
| move := v_1 |
| if move.Op != ssaop.OpMove || ssa.AuxIntToInt64(move.AuxInt) != n || ssa.AuxToType(move.Aux) != t { |
| break |
| } |
| mem := move.Args[2] |
| dst2 := move.Args[0] |
| if !(move.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Clobber(move)) { |
| break |
| } |
| v.Reset(ssaop.OpZero) |
| v.AuxInt = ssa.Int64ToAuxInt(n) |
| v.Aux = ssa.TypeToAux(t) |
| v.AddArg2(dst1, mem) |
| return true |
| } |
| // match: (Zero {t} [n] dst1 vardef:(VarDef {x} move:(Move {t} [n] dst2 _ mem))) |
| // cond: move.Uses == 1 && vardef.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Clobber(move, vardef) |
| // result: (Zero {t} [n] dst1 (VarDef {x} mem)) |
| for { |
| n := ssa.AuxIntToInt64(v.AuxInt) |
| t := ssa.AuxToType(v.Aux) |
| dst1 := v_0 |
| vardef := v_1 |
| if vardef.Op != ssaop.OpVarDef { |
| break |
| } |
| x := ssa.AuxToSym(vardef.Aux) |
| move := vardef.Args[0] |
| if move.Op != ssaop.OpMove || ssa.AuxIntToInt64(move.AuxInt) != n || ssa.AuxToType(move.Aux) != t { |
| break |
| } |
| mem := move.Args[2] |
| dst2 := move.Args[0] |
| if !(move.Uses == 1 && vardef.Uses == 1 && ssa.IsSamePtr(dst1, dst2) && ssa.Clobber(move, vardef)) { |
| break |
| } |
| v.Reset(ssaop.OpZero) |
| v.AuxInt = ssa.Int64ToAuxInt(n) |
| v.Aux = ssa.TypeToAux(t) |
| v0 := b.NewValue0(v.Pos, ssaop.OpVarDef, types.TypeMem) |
| v0.Aux = ssa.SymToAux(x) |
| v0.AddArg(mem) |
| v.AddArg2(dst1, v0) |
| return true |
| } |
| // match: (Zero {t} [s] dst1 zero:(Zero {t} [s] dst2 _)) |
| // cond: ssa.IsSamePtr(dst1, dst2) |
| // result: zero |
| for { |
| s := ssa.AuxIntToInt64(v.AuxInt) |
| t := ssa.AuxToType(v.Aux) |
| dst1 := v_0 |
| zero := v_1 |
| if zero.Op != ssaop.OpZero || ssa.AuxIntToInt64(zero.AuxInt) != s || ssa.AuxToType(zero.Aux) != t { |
| break |
| } |
| dst2 := zero.Args[0] |
| if !(ssa.IsSamePtr(dst1, dst2)) { |
| break |
| } |
| v.CopyOf(zero) |
| return true |
| } |
| // match: (Zero {t} [s] dst1 vardef:(VarDef (Zero {t} [s] dst2 _))) |
| // cond: ssa.IsSamePtr(dst1, dst2) |
| // result: vardef |
| for { |
| s := ssa.AuxIntToInt64(v.AuxInt) |
| t := ssa.AuxToType(v.Aux) |
| dst1 := v_0 |
| vardef := v_1 |
| if vardef.Op != ssaop.OpVarDef { |
| break |
| } |
| vardef_0 := vardef.Args[0] |
| if vardef_0.Op != ssaop.OpZero || ssa.AuxIntToInt64(vardef_0.AuxInt) != s || ssa.AuxToType(vardef_0.Aux) != t { |
| break |
| } |
| dst2 := vardef_0.Args[0] |
| if !(ssa.IsSamePtr(dst1, dst2)) { |
| break |
| } |
| v.CopyOf(vardef) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpZeroExt16to32(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (ZeroExt16to32 (Const16 [c])) |
| // result: (Const32 [int32(uint16(c))]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(uint16(c))) |
| return true |
| } |
| // match: (ZeroExt16to32 (Trunc32to16 x:(Rsh32Ux64 _ (Const64 [s])))) |
| // cond: s >= 16 |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpTrunc32to16 { |
| break |
| } |
| x := v_0.Args[0] |
| if x.Op != ssaop.OpRsh32Ux64 { |
| break |
| } |
| _ = x.Args[1] |
| x_1 := x.Args[1] |
| if x_1.Op != ssaop.OpConst64 { |
| break |
| } |
| s := ssa.AuxIntToInt64(x_1.AuxInt) |
| if !(s >= 16) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpZeroExt16to64(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (ZeroExt16to64 (Const16 [c])) |
| // result: (Const64 [int64(uint16(c))]) |
| for { |
| if v_0.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(uint16(c))) |
| return true |
| } |
| // match: (ZeroExt16to64 (Trunc64to16 x:(Rsh64Ux64 _ (Const64 [s])))) |
| // cond: s >= 48 |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpTrunc64to16 { |
| break |
| } |
| x := v_0.Args[0] |
| if x.Op != ssaop.OpRsh64Ux64 { |
| break |
| } |
| _ = x.Args[1] |
| x_1 := x.Args[1] |
| if x_1.Op != ssaop.OpConst64 { |
| break |
| } |
| s := ssa.AuxIntToInt64(x_1.AuxInt) |
| if !(s >= 48) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpZeroExt32to64(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (ZeroExt32to64 (Const32 [c])) |
| // result: (Const64 [int64(uint32(c))]) |
| for { |
| if v_0.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(uint32(c))) |
| return true |
| } |
| // match: (ZeroExt32to64 (Trunc64to32 x:(Rsh64Ux64 _ (Const64 [s])))) |
| // cond: s >= 32 |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpTrunc64to32 { |
| break |
| } |
| x := v_0.Args[0] |
| if x.Op != ssaop.OpRsh64Ux64 { |
| break |
| } |
| _ = x.Args[1] |
| x_1 := x.Args[1] |
| if x_1.Op != ssaop.OpConst64 { |
| break |
| } |
| s := ssa.AuxIntToInt64(x_1.AuxInt) |
| if !(s >= 32) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpZeroExt8to16(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (ZeroExt8to16 (Const8 [c])) |
| // result: (Const16 [int16( uint8(c))]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| v.Reset(ssaop.OpConst16) |
| v.AuxInt = ssa.Int16ToAuxInt(int16(uint8(c))) |
| return true |
| } |
| // match: (ZeroExt8to16 (Trunc16to8 x:(Rsh16Ux64 _ (Const64 [s])))) |
| // cond: s >= 8 |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpTrunc16to8 { |
| break |
| } |
| x := v_0.Args[0] |
| if x.Op != ssaop.OpRsh16Ux64 { |
| break |
| } |
| _ = x.Args[1] |
| x_1 := x.Args[1] |
| if x_1.Op != ssaop.OpConst64 { |
| break |
| } |
| s := ssa.AuxIntToInt64(x_1.AuxInt) |
| if !(s >= 8) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpZeroExt8to32(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (ZeroExt8to32 (Const8 [c])) |
| // result: (Const32 [int32( uint8(c))]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| v.Reset(ssaop.OpConst32) |
| v.AuxInt = ssa.Int32ToAuxInt(int32(uint8(c))) |
| return true |
| } |
| // match: (ZeroExt8to32 (Trunc32to8 x:(Rsh32Ux64 _ (Const64 [s])))) |
| // cond: s >= 24 |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpTrunc32to8 { |
| break |
| } |
| x := v_0.Args[0] |
| if x.Op != ssaop.OpRsh32Ux64 { |
| break |
| } |
| _ = x.Args[1] |
| x_1 := x.Args[1] |
| if x_1.Op != ssaop.OpConst64 { |
| break |
| } |
| s := ssa.AuxIntToInt64(x_1.AuxInt) |
| if !(s >= 24) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpZeroExt8to64(v *ssa.Value) bool { |
| v_0 := v.Args[0] |
| // match: (ZeroExt8to64 (Const8 [c])) |
| // result: (Const64 [int64( uint8(c))]) |
| for { |
| if v_0.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_0.AuxInt) |
| v.Reset(ssaop.OpConst64) |
| v.AuxInt = ssa.Int64ToAuxInt(int64(uint8(c))) |
| return true |
| } |
| // match: (ZeroExt8to64 (Trunc64to8 x:(Rsh64Ux64 _ (Const64 [s])))) |
| // cond: s >= 56 |
| // result: x |
| for { |
| if v_0.Op != ssaop.OpTrunc64to8 { |
| break |
| } |
| x := v_0.Args[0] |
| if x.Op != ssaop.OpRsh64Ux64 { |
| break |
| } |
| _ = x.Args[1] |
| x_1 := x.Args[1] |
| if x_1.Op != ssaop.OpConst64 { |
| break |
| } |
| s := ssa.AuxIntToInt64(x_1.AuxInt) |
| if !(s >= 56) { |
| break |
| } |
| v.CopyOf(x) |
| return true |
| } |
| return false |
| } |
| func RewriteBlock(b *ssa.Block) bool { |
| switch b.Kind { |
| case block.BlockIf: |
| // match: (If (Not cond) yes no) |
| // result: (If cond no yes) |
| for b.Controls[0].Op == ssaop.OpNot { |
| v_0 := b.Controls[0] |
| cond := v_0.Args[0] |
| b.ResetWithControl(block.BlockIf, cond) |
| b.SwapSuccessors() |
| return true |
| } |
| // match: (If (ConstBool [c]) yes no) |
| // cond: c |
| // result: (First yes no) |
| for b.Controls[0].Op == ssaop.OpConstBool { |
| v_0 := b.Controls[0] |
| c := ssa.AuxIntToBool(v_0.AuxInt) |
| if !(c) { |
| break |
| } |
| b.Reset(block.BlockFirst) |
| return true |
| } |
| // match: (If (ConstBool [c]) yes no) |
| // cond: !c |
| // result: (First no yes) |
| for b.Controls[0].Op == ssaop.OpConstBool { |
| v_0 := b.Controls[0] |
| c := ssa.AuxIntToBool(v_0.AuxInt) |
| if !(!c) { |
| break |
| } |
| b.Reset(block.BlockFirst) |
| b.SwapSuccessors() |
| return true |
| } |
| } |
| return false |
| } |
