| // Code generated from gen/generic.rules; DO NOT EDIT. |
| // generated with: cd gen; go run *.go |
| |
| package ssa |
| |
| import "fmt" |
| import "math" |
| import "cmd/internal/obj" |
| import "cmd/internal/objabi" |
| import "cmd/compile/internal/types" |
| |
| var _ = fmt.Println // in case not otherwise used |
| var _ = math.MinInt8 // in case not otherwise used |
| var _ = obj.ANOP // in case not otherwise used |
| var _ = objabi.GOROOT // in case not otherwise used |
| var _ = types.TypeMem // in case not otherwise used |
| |
| func rewriteValuegeneric(v *Value) bool { |
| switch v.Op { |
| case OpAdd16: |
| return rewriteValuegeneric_OpAdd16_0(v) || rewriteValuegeneric_OpAdd16_10(v) || rewriteValuegeneric_OpAdd16_20(v) || rewriteValuegeneric_OpAdd16_30(v) |
| case OpAdd32: |
| return rewriteValuegeneric_OpAdd32_0(v) || rewriteValuegeneric_OpAdd32_10(v) || rewriteValuegeneric_OpAdd32_20(v) || rewriteValuegeneric_OpAdd32_30(v) |
| case OpAdd32F: |
| return rewriteValuegeneric_OpAdd32F_0(v) |
| case OpAdd64: |
| return rewriteValuegeneric_OpAdd64_0(v) || rewriteValuegeneric_OpAdd64_10(v) || rewriteValuegeneric_OpAdd64_20(v) || rewriteValuegeneric_OpAdd64_30(v) |
| case OpAdd64F: |
| return rewriteValuegeneric_OpAdd64F_0(v) |
| case OpAdd8: |
| return rewriteValuegeneric_OpAdd8_0(v) || rewriteValuegeneric_OpAdd8_10(v) || rewriteValuegeneric_OpAdd8_20(v) || rewriteValuegeneric_OpAdd8_30(v) |
| case OpAddPtr: |
| return rewriteValuegeneric_OpAddPtr_0(v) |
| case OpAnd16: |
| return rewriteValuegeneric_OpAnd16_0(v) || rewriteValuegeneric_OpAnd16_10(v) || rewriteValuegeneric_OpAnd16_20(v) |
| case OpAnd32: |
| return rewriteValuegeneric_OpAnd32_0(v) || rewriteValuegeneric_OpAnd32_10(v) || rewriteValuegeneric_OpAnd32_20(v) |
| case OpAnd64: |
| return rewriteValuegeneric_OpAnd64_0(v) || rewriteValuegeneric_OpAnd64_10(v) || rewriteValuegeneric_OpAnd64_20(v) |
| case OpAnd8: |
| return rewriteValuegeneric_OpAnd8_0(v) || rewriteValuegeneric_OpAnd8_10(v) || rewriteValuegeneric_OpAnd8_20(v) |
| case OpArraySelect: |
| return rewriteValuegeneric_OpArraySelect_0(v) |
| case OpCom16: |
| return rewriteValuegeneric_OpCom16_0(v) |
| case OpCom32: |
| return rewriteValuegeneric_OpCom32_0(v) |
| case OpCom64: |
| return rewriteValuegeneric_OpCom64_0(v) |
| case OpCom8: |
| return rewriteValuegeneric_OpCom8_0(v) |
| case OpConstInterface: |
| return rewriteValuegeneric_OpConstInterface_0(v) |
| case OpConstSlice: |
| return rewriteValuegeneric_OpConstSlice_0(v) |
| case OpConstString: |
| return rewriteValuegeneric_OpConstString_0(v) |
| case OpConvert: |
| return rewriteValuegeneric_OpConvert_0(v) |
| case OpCvt32Fto32: |
| return rewriteValuegeneric_OpCvt32Fto32_0(v) |
| case OpCvt32Fto64: |
| return rewriteValuegeneric_OpCvt32Fto64_0(v) |
| case OpCvt32Fto64F: |
| return rewriteValuegeneric_OpCvt32Fto64F_0(v) |
| case OpCvt32to32F: |
| return rewriteValuegeneric_OpCvt32to32F_0(v) |
| case OpCvt32to64F: |
| return rewriteValuegeneric_OpCvt32to64F_0(v) |
| case OpCvt64Fto32: |
| return rewriteValuegeneric_OpCvt64Fto32_0(v) |
| case OpCvt64Fto32F: |
| return rewriteValuegeneric_OpCvt64Fto32F_0(v) |
| case OpCvt64Fto64: |
| return rewriteValuegeneric_OpCvt64Fto64_0(v) |
| case OpCvt64to32F: |
| return rewriteValuegeneric_OpCvt64to32F_0(v) |
| case OpCvt64to64F: |
| return rewriteValuegeneric_OpCvt64to64F_0(v) |
| case OpDiv16: |
| return rewriteValuegeneric_OpDiv16_0(v) |
| case OpDiv16u: |
| return rewriteValuegeneric_OpDiv16u_0(v) |
| case OpDiv32: |
| return rewriteValuegeneric_OpDiv32_0(v) |
| case OpDiv32F: |
| return rewriteValuegeneric_OpDiv32F_0(v) |
| case OpDiv32u: |
| return rewriteValuegeneric_OpDiv32u_0(v) |
| case OpDiv64: |
| return rewriteValuegeneric_OpDiv64_0(v) |
| case OpDiv64F: |
| return rewriteValuegeneric_OpDiv64F_0(v) |
| case OpDiv64u: |
| return rewriteValuegeneric_OpDiv64u_0(v) |
| case OpDiv8: |
| return rewriteValuegeneric_OpDiv8_0(v) |
| case OpDiv8u: |
| return rewriteValuegeneric_OpDiv8u_0(v) |
| case OpEq16: |
| return rewriteValuegeneric_OpEq16_0(v) || rewriteValuegeneric_OpEq16_10(v) || rewriteValuegeneric_OpEq16_20(v) || rewriteValuegeneric_OpEq16_30(v) || rewriteValuegeneric_OpEq16_40(v) || rewriteValuegeneric_OpEq16_50(v) |
| case OpEq32: |
| return rewriteValuegeneric_OpEq32_0(v) || rewriteValuegeneric_OpEq32_10(v) || rewriteValuegeneric_OpEq32_20(v) || rewriteValuegeneric_OpEq32_30(v) || rewriteValuegeneric_OpEq32_40(v) || rewriteValuegeneric_OpEq32_50(v) || rewriteValuegeneric_OpEq32_60(v) || rewriteValuegeneric_OpEq32_70(v) || rewriteValuegeneric_OpEq32_80(v) || rewriteValuegeneric_OpEq32_90(v) |
| case OpEq32F: |
| return rewriteValuegeneric_OpEq32F_0(v) |
| case OpEq64: |
| return rewriteValuegeneric_OpEq64_0(v) || rewriteValuegeneric_OpEq64_10(v) || rewriteValuegeneric_OpEq64_20(v) || rewriteValuegeneric_OpEq64_30(v) || rewriteValuegeneric_OpEq64_40(v) || rewriteValuegeneric_OpEq64_50(v) || rewriteValuegeneric_OpEq64_60(v) |
| case OpEq64F: |
| return rewriteValuegeneric_OpEq64F_0(v) |
| case OpEq8: |
| return rewriteValuegeneric_OpEq8_0(v) || rewriteValuegeneric_OpEq8_10(v) || rewriteValuegeneric_OpEq8_20(v) || rewriteValuegeneric_OpEq8_30(v) |
| case OpEqB: |
| return rewriteValuegeneric_OpEqB_0(v) |
| case OpEqInter: |
| return rewriteValuegeneric_OpEqInter_0(v) |
| case OpEqPtr: |
| return rewriteValuegeneric_OpEqPtr_0(v) || rewriteValuegeneric_OpEqPtr_10(v) || rewriteValuegeneric_OpEqPtr_20(v) |
| case OpEqSlice: |
| return rewriteValuegeneric_OpEqSlice_0(v) |
| case OpGeq16: |
| return rewriteValuegeneric_OpGeq16_0(v) |
| case OpGeq16U: |
| return rewriteValuegeneric_OpGeq16U_0(v) |
| case OpGeq32: |
| return rewriteValuegeneric_OpGeq32_0(v) |
| case OpGeq32F: |
| return rewriteValuegeneric_OpGeq32F_0(v) |
| case OpGeq32U: |
| return rewriteValuegeneric_OpGeq32U_0(v) |
| case OpGeq64: |
| return rewriteValuegeneric_OpGeq64_0(v) |
| case OpGeq64F: |
| return rewriteValuegeneric_OpGeq64F_0(v) |
| case OpGeq64U: |
| return rewriteValuegeneric_OpGeq64U_0(v) |
| case OpGeq8: |
| return rewriteValuegeneric_OpGeq8_0(v) |
| case OpGeq8U: |
| return rewriteValuegeneric_OpGeq8U_0(v) |
| case OpGreater16: |
| return rewriteValuegeneric_OpGreater16_0(v) |
| case OpGreater16U: |
| return rewriteValuegeneric_OpGreater16U_0(v) |
| case OpGreater32: |
| return rewriteValuegeneric_OpGreater32_0(v) |
| case OpGreater32F: |
| return rewriteValuegeneric_OpGreater32F_0(v) |
| case OpGreater32U: |
| return rewriteValuegeneric_OpGreater32U_0(v) |
| case OpGreater64: |
| return rewriteValuegeneric_OpGreater64_0(v) |
| case OpGreater64F: |
| return rewriteValuegeneric_OpGreater64F_0(v) |
| case OpGreater64U: |
| return rewriteValuegeneric_OpGreater64U_0(v) |
| case OpGreater8: |
| return rewriteValuegeneric_OpGreater8_0(v) |
| case OpGreater8U: |
| return rewriteValuegeneric_OpGreater8U_0(v) |
| case OpIMake: |
| return rewriteValuegeneric_OpIMake_0(v) |
| case OpInterCall: |
| return rewriteValuegeneric_OpInterCall_0(v) |
| case OpIsInBounds: |
| return rewriteValuegeneric_OpIsInBounds_0(v) || rewriteValuegeneric_OpIsInBounds_10(v) || rewriteValuegeneric_OpIsInBounds_20(v) || rewriteValuegeneric_OpIsInBounds_30(v) |
| case OpIsNonNil: |
| return rewriteValuegeneric_OpIsNonNil_0(v) |
| case OpIsSliceInBounds: |
| return rewriteValuegeneric_OpIsSliceInBounds_0(v) |
| case OpLeq16: |
| return rewriteValuegeneric_OpLeq16_0(v) |
| case OpLeq16U: |
| return rewriteValuegeneric_OpLeq16U_0(v) |
| case OpLeq32: |
| return rewriteValuegeneric_OpLeq32_0(v) |
| case OpLeq32F: |
| return rewriteValuegeneric_OpLeq32F_0(v) |
| case OpLeq32U: |
| return rewriteValuegeneric_OpLeq32U_0(v) |
| case OpLeq64: |
| return rewriteValuegeneric_OpLeq64_0(v) |
| case OpLeq64F: |
| return rewriteValuegeneric_OpLeq64F_0(v) |
| case OpLeq64U: |
| return rewriteValuegeneric_OpLeq64U_0(v) |
| case OpLeq8: |
| return rewriteValuegeneric_OpLeq8_0(v) |
| case OpLeq8U: |
| return rewriteValuegeneric_OpLeq8U_0(v) |
| case OpLess16: |
| return rewriteValuegeneric_OpLess16_0(v) |
| case OpLess16U: |
| return rewriteValuegeneric_OpLess16U_0(v) |
| case OpLess32: |
| return rewriteValuegeneric_OpLess32_0(v) |
| case OpLess32F: |
| return rewriteValuegeneric_OpLess32F_0(v) |
| case OpLess32U: |
| return rewriteValuegeneric_OpLess32U_0(v) |
| case OpLess64: |
| return rewriteValuegeneric_OpLess64_0(v) |
| case OpLess64F: |
| return rewriteValuegeneric_OpLess64F_0(v) |
| case OpLess64U: |
| return rewriteValuegeneric_OpLess64U_0(v) |
| case OpLess8: |
| return rewriteValuegeneric_OpLess8_0(v) |
| case OpLess8U: |
| return rewriteValuegeneric_OpLess8U_0(v) |
| case OpLoad: |
| return rewriteValuegeneric_OpLoad_0(v) || rewriteValuegeneric_OpLoad_10(v) || rewriteValuegeneric_OpLoad_20(v) |
| case OpLsh16x16: |
| return rewriteValuegeneric_OpLsh16x16_0(v) |
| case OpLsh16x32: |
| return rewriteValuegeneric_OpLsh16x32_0(v) |
| case OpLsh16x64: |
| return rewriteValuegeneric_OpLsh16x64_0(v) |
| case OpLsh16x8: |
| return rewriteValuegeneric_OpLsh16x8_0(v) |
| case OpLsh32x16: |
| return rewriteValuegeneric_OpLsh32x16_0(v) |
| case OpLsh32x32: |
| return rewriteValuegeneric_OpLsh32x32_0(v) |
| case OpLsh32x64: |
| return rewriteValuegeneric_OpLsh32x64_0(v) |
| case OpLsh32x8: |
| return rewriteValuegeneric_OpLsh32x8_0(v) |
| case OpLsh64x16: |
| return rewriteValuegeneric_OpLsh64x16_0(v) |
| case OpLsh64x32: |
| return rewriteValuegeneric_OpLsh64x32_0(v) |
| case OpLsh64x64: |
| return rewriteValuegeneric_OpLsh64x64_0(v) |
| case OpLsh64x8: |
| return rewriteValuegeneric_OpLsh64x8_0(v) |
| case OpLsh8x16: |
| return rewriteValuegeneric_OpLsh8x16_0(v) |
| case OpLsh8x32: |
| return rewriteValuegeneric_OpLsh8x32_0(v) |
| case OpLsh8x64: |
| return rewriteValuegeneric_OpLsh8x64_0(v) |
| case OpLsh8x8: |
| return rewriteValuegeneric_OpLsh8x8_0(v) |
| case OpMod16: |
| return rewriteValuegeneric_OpMod16_0(v) |
| case OpMod16u: |
| return rewriteValuegeneric_OpMod16u_0(v) |
| case OpMod32: |
| return rewriteValuegeneric_OpMod32_0(v) |
| case OpMod32u: |
| return rewriteValuegeneric_OpMod32u_0(v) |
| case OpMod64: |
| return rewriteValuegeneric_OpMod64_0(v) |
| case OpMod64u: |
| return rewriteValuegeneric_OpMod64u_0(v) |
| case OpMod8: |
| return rewriteValuegeneric_OpMod8_0(v) |
| case OpMod8u: |
| return rewriteValuegeneric_OpMod8u_0(v) |
| case OpMove: |
| return rewriteValuegeneric_OpMove_0(v) || rewriteValuegeneric_OpMove_10(v) || rewriteValuegeneric_OpMove_20(v) |
| case OpMul16: |
| return rewriteValuegeneric_OpMul16_0(v) || rewriteValuegeneric_OpMul16_10(v) |
| case OpMul32: |
| return rewriteValuegeneric_OpMul32_0(v) || rewriteValuegeneric_OpMul32_10(v) |
| case OpMul32F: |
| return rewriteValuegeneric_OpMul32F_0(v) |
| case OpMul64: |
| return rewriteValuegeneric_OpMul64_0(v) || rewriteValuegeneric_OpMul64_10(v) |
| case OpMul64F: |
| return rewriteValuegeneric_OpMul64F_0(v) |
| case OpMul8: |
| return rewriteValuegeneric_OpMul8_0(v) || rewriteValuegeneric_OpMul8_10(v) |
| case OpNeg16: |
| return rewriteValuegeneric_OpNeg16_0(v) |
| case OpNeg32: |
| return rewriteValuegeneric_OpNeg32_0(v) |
| case OpNeg32F: |
| return rewriteValuegeneric_OpNeg32F_0(v) |
| case OpNeg64: |
| return rewriteValuegeneric_OpNeg64_0(v) |
| case OpNeg64F: |
| return rewriteValuegeneric_OpNeg64F_0(v) |
| case OpNeg8: |
| return rewriteValuegeneric_OpNeg8_0(v) |
| case OpNeq16: |
| return rewriteValuegeneric_OpNeq16_0(v) |
| case OpNeq32: |
| return rewriteValuegeneric_OpNeq32_0(v) |
| case OpNeq32F: |
| return rewriteValuegeneric_OpNeq32F_0(v) |
| case OpNeq64: |
| return rewriteValuegeneric_OpNeq64_0(v) |
| case OpNeq64F: |
| return rewriteValuegeneric_OpNeq64F_0(v) |
| case OpNeq8: |
| return rewriteValuegeneric_OpNeq8_0(v) |
| case OpNeqB: |
| return rewriteValuegeneric_OpNeqB_0(v) |
| case OpNeqInter: |
| return rewriteValuegeneric_OpNeqInter_0(v) |
| case OpNeqPtr: |
| return rewriteValuegeneric_OpNeqPtr_0(v) || rewriteValuegeneric_OpNeqPtr_10(v) || rewriteValuegeneric_OpNeqPtr_20(v) |
| case OpNeqSlice: |
| return rewriteValuegeneric_OpNeqSlice_0(v) |
| case OpNilCheck: |
| return rewriteValuegeneric_OpNilCheck_0(v) |
| case OpNot: |
| return rewriteValuegeneric_OpNot_0(v) || rewriteValuegeneric_OpNot_10(v) || rewriteValuegeneric_OpNot_20(v) || rewriteValuegeneric_OpNot_30(v) || rewriteValuegeneric_OpNot_40(v) |
| case OpOffPtr: |
| return rewriteValuegeneric_OpOffPtr_0(v) |
| case OpOr16: |
| return rewriteValuegeneric_OpOr16_0(v) || rewriteValuegeneric_OpOr16_10(v) || rewriteValuegeneric_OpOr16_20(v) |
| case OpOr32: |
| return rewriteValuegeneric_OpOr32_0(v) || rewriteValuegeneric_OpOr32_10(v) || rewriteValuegeneric_OpOr32_20(v) |
| case OpOr64: |
| return rewriteValuegeneric_OpOr64_0(v) || rewriteValuegeneric_OpOr64_10(v) || rewriteValuegeneric_OpOr64_20(v) |
| case OpOr8: |
| return rewriteValuegeneric_OpOr8_0(v) || rewriteValuegeneric_OpOr8_10(v) || rewriteValuegeneric_OpOr8_20(v) |
| case OpPhi: |
| return rewriteValuegeneric_OpPhi_0(v) |
| case OpPtrIndex: |
| return rewriteValuegeneric_OpPtrIndex_0(v) |
| case OpRotateLeft16: |
| return rewriteValuegeneric_OpRotateLeft16_0(v) |
| case OpRotateLeft32: |
| return rewriteValuegeneric_OpRotateLeft32_0(v) |
| case OpRotateLeft64: |
| return rewriteValuegeneric_OpRotateLeft64_0(v) |
| case OpRotateLeft8: |
| return rewriteValuegeneric_OpRotateLeft8_0(v) |
| case OpRound32F: |
| return rewriteValuegeneric_OpRound32F_0(v) |
| case OpRound64F: |
| return rewriteValuegeneric_OpRound64F_0(v) |
| case OpRsh16Ux16: |
| return rewriteValuegeneric_OpRsh16Ux16_0(v) |
| case OpRsh16Ux32: |
| return rewriteValuegeneric_OpRsh16Ux32_0(v) |
| case OpRsh16Ux64: |
| return rewriteValuegeneric_OpRsh16Ux64_0(v) |
| case OpRsh16Ux8: |
| return rewriteValuegeneric_OpRsh16Ux8_0(v) |
| case OpRsh16x16: |
| return rewriteValuegeneric_OpRsh16x16_0(v) |
| case OpRsh16x32: |
| return rewriteValuegeneric_OpRsh16x32_0(v) |
| case OpRsh16x64: |
| return rewriteValuegeneric_OpRsh16x64_0(v) |
| case OpRsh16x8: |
| return rewriteValuegeneric_OpRsh16x8_0(v) |
| case OpRsh32Ux16: |
| return rewriteValuegeneric_OpRsh32Ux16_0(v) |
| case OpRsh32Ux32: |
| return rewriteValuegeneric_OpRsh32Ux32_0(v) |
| case OpRsh32Ux64: |
| return rewriteValuegeneric_OpRsh32Ux64_0(v) |
| case OpRsh32Ux8: |
| return rewriteValuegeneric_OpRsh32Ux8_0(v) |
| case OpRsh32x16: |
| return rewriteValuegeneric_OpRsh32x16_0(v) |
| case OpRsh32x32: |
| return rewriteValuegeneric_OpRsh32x32_0(v) |
| case OpRsh32x64: |
| return rewriteValuegeneric_OpRsh32x64_0(v) |
| case OpRsh32x8: |
| return rewriteValuegeneric_OpRsh32x8_0(v) |
| case OpRsh64Ux16: |
| return rewriteValuegeneric_OpRsh64Ux16_0(v) |
| case OpRsh64Ux32: |
| return rewriteValuegeneric_OpRsh64Ux32_0(v) |
| case OpRsh64Ux64: |
| return rewriteValuegeneric_OpRsh64Ux64_0(v) |
| case OpRsh64Ux8: |
| return rewriteValuegeneric_OpRsh64Ux8_0(v) |
| case OpRsh64x16: |
| return rewriteValuegeneric_OpRsh64x16_0(v) |
| case OpRsh64x32: |
| return rewriteValuegeneric_OpRsh64x32_0(v) |
| case OpRsh64x64: |
| return rewriteValuegeneric_OpRsh64x64_0(v) |
| case OpRsh64x8: |
| return rewriteValuegeneric_OpRsh64x8_0(v) |
| case OpRsh8Ux16: |
| return rewriteValuegeneric_OpRsh8Ux16_0(v) |
| case OpRsh8Ux32: |
| return rewriteValuegeneric_OpRsh8Ux32_0(v) |
| case OpRsh8Ux64: |
| return rewriteValuegeneric_OpRsh8Ux64_0(v) |
| case OpRsh8Ux8: |
| return rewriteValuegeneric_OpRsh8Ux8_0(v) |
| case OpRsh8x16: |
| return rewriteValuegeneric_OpRsh8x16_0(v) |
| case OpRsh8x32: |
| return rewriteValuegeneric_OpRsh8x32_0(v) |
| case OpRsh8x64: |
| return rewriteValuegeneric_OpRsh8x64_0(v) |
| case OpRsh8x8: |
| return rewriteValuegeneric_OpRsh8x8_0(v) |
| case OpSelect0: |
| return rewriteValuegeneric_OpSelect0_0(v) |
| case OpSelect1: |
| return rewriteValuegeneric_OpSelect1_0(v) |
| case OpSignExt16to32: |
| return rewriteValuegeneric_OpSignExt16to32_0(v) |
| case OpSignExt16to64: |
| return rewriteValuegeneric_OpSignExt16to64_0(v) |
| case OpSignExt32to64: |
| return rewriteValuegeneric_OpSignExt32to64_0(v) |
| case OpSignExt8to16: |
| return rewriteValuegeneric_OpSignExt8to16_0(v) |
| case OpSignExt8to32: |
| return rewriteValuegeneric_OpSignExt8to32_0(v) |
| case OpSignExt8to64: |
| return rewriteValuegeneric_OpSignExt8to64_0(v) |
| case OpSliceCap: |
| return rewriteValuegeneric_OpSliceCap_0(v) |
| case OpSliceLen: |
| return rewriteValuegeneric_OpSliceLen_0(v) |
| case OpSlicePtr: |
| return rewriteValuegeneric_OpSlicePtr_0(v) |
| case OpSlicemask: |
| return rewriteValuegeneric_OpSlicemask_0(v) |
| case OpSqrt: |
| return rewriteValuegeneric_OpSqrt_0(v) |
| case OpStaticCall: |
| return rewriteValuegeneric_OpStaticCall_0(v) |
| case OpStore: |
| return rewriteValuegeneric_OpStore_0(v) || rewriteValuegeneric_OpStore_10(v) || rewriteValuegeneric_OpStore_20(v) |
| case OpStringLen: |
| return rewriteValuegeneric_OpStringLen_0(v) |
| case OpStringPtr: |
| return rewriteValuegeneric_OpStringPtr_0(v) |
| case OpStructSelect: |
| return rewriteValuegeneric_OpStructSelect_0(v) || rewriteValuegeneric_OpStructSelect_10(v) |
| case OpSub16: |
| return rewriteValuegeneric_OpSub16_0(v) || rewriteValuegeneric_OpSub16_10(v) |
| case OpSub32: |
| return rewriteValuegeneric_OpSub32_0(v) || rewriteValuegeneric_OpSub32_10(v) |
| case OpSub32F: |
| return rewriteValuegeneric_OpSub32F_0(v) |
| case OpSub64: |
| return rewriteValuegeneric_OpSub64_0(v) || rewriteValuegeneric_OpSub64_10(v) |
| case OpSub64F: |
| return rewriteValuegeneric_OpSub64F_0(v) |
| case OpSub8: |
| return rewriteValuegeneric_OpSub8_0(v) || rewriteValuegeneric_OpSub8_10(v) |
| case OpTrunc16to8: |
| return rewriteValuegeneric_OpTrunc16to8_0(v) |
| case OpTrunc32to16: |
| return rewriteValuegeneric_OpTrunc32to16_0(v) |
| case OpTrunc32to8: |
| return rewriteValuegeneric_OpTrunc32to8_0(v) |
| case OpTrunc64to16: |
| return rewriteValuegeneric_OpTrunc64to16_0(v) |
| case OpTrunc64to32: |
| return rewriteValuegeneric_OpTrunc64to32_0(v) |
| case OpTrunc64to8: |
| return rewriteValuegeneric_OpTrunc64to8_0(v) |
| case OpXor16: |
| return rewriteValuegeneric_OpXor16_0(v) || rewriteValuegeneric_OpXor16_10(v) |
| case OpXor32: |
| return rewriteValuegeneric_OpXor32_0(v) || rewriteValuegeneric_OpXor32_10(v) |
| case OpXor64: |
| return rewriteValuegeneric_OpXor64_0(v) || rewriteValuegeneric_OpXor64_10(v) |
| case OpXor8: |
| return rewriteValuegeneric_OpXor8_0(v) || rewriteValuegeneric_OpXor8_10(v) |
| case OpZero: |
| return rewriteValuegeneric_OpZero_0(v) |
| case OpZeroExt16to32: |
| return rewriteValuegeneric_OpZeroExt16to32_0(v) |
| case OpZeroExt16to64: |
| return rewriteValuegeneric_OpZeroExt16to64_0(v) |
| case OpZeroExt32to64: |
| return rewriteValuegeneric_OpZeroExt32to64_0(v) |
| case OpZeroExt8to16: |
| return rewriteValuegeneric_OpZeroExt8to16_0(v) |
| case OpZeroExt8to32: |
| return rewriteValuegeneric_OpZeroExt8to32_0(v) |
| case OpZeroExt8to64: |
| return rewriteValuegeneric_OpZeroExt8to64_0(v) |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd16_0(v *Value) bool { |
| b := v.Block |
| // match: (Add16 (Const16 [c]) (Const16 [d])) |
| // cond: |
| // result: (Const16 [int64(int16(c+d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| d := v_1.AuxInt |
| v.reset(OpConst16) |
| v.AuxInt = int64(int16(c + d)) |
| return true |
| } |
| // match: (Add16 (Const16 [d]) (Const16 [c])) |
| // cond: |
| // result: (Const16 [int64(int16(c+d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| d := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpConst16) |
| v.AuxInt = int64(int16(c + d)) |
| return true |
| } |
| // match: (Add16 <t> (Mul16 x y) (Mul16 x z)) |
| // cond: |
| // result: (Mul16 x (Add16 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| z := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpMul16) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add16 <t> (Mul16 y x) (Mul16 x z)) |
| // cond: |
| // result: (Mul16 x (Add16 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| x := v_0.Args[1] |
| y := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| z := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpMul16) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add16 <t> (Mul16 x y) (Mul16 z x)) |
| // cond: |
| // result: (Mul16 x (Add16 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpMul16) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add16 <t> (Mul16 y x) (Mul16 z x)) |
| // cond: |
| // result: (Mul16 x (Add16 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| x := v_0.Args[1] |
| y := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpMul16) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add16 <t> (Mul16 x z) (Mul16 x y)) |
| // cond: |
| // result: (Mul16 x (Add16 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| z := v_0.Args[1] |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| y := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpMul16) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add16 <t> (Mul16 z x) (Mul16 x y)) |
| // cond: |
| // result: (Mul16 x (Add16 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| x := v_0.Args[1] |
| z := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| y := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpMul16) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add16 <t> (Mul16 x z) (Mul16 y x)) |
| // cond: |
| // result: (Mul16 x (Add16 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| z := v_0.Args[1] |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpMul16) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add16 <t> (Mul16 z x) (Mul16 y x)) |
| // cond: |
| // result: (Mul16 x (Add16 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| x := v_0.Args[1] |
| z := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpMul16) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd16_10(v *Value) bool { |
| b := v.Block |
| // match: (Add16 (Const16 [0]) x) |
| // cond: |
| // result: x |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| if v_0.AuxInt != 0 { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add16 x (Const16 [0])) |
| // cond: |
| // result: x |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| if v_1.AuxInt != 0 { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add16 (Const16 [1]) (Com16 x)) |
| // cond: |
| // result: (Neg16 x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| if v_0.AuxInt != 1 { |
| break |
| } |
| v_1 := v.Args[1] |
| if v_1.Op != OpCom16 { |
| break |
| } |
| x := v_1.Args[0] |
| v.reset(OpNeg16) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add16 (Com16 x) (Const16 [1])) |
| // cond: |
| // result: (Neg16 x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpCom16 { |
| break |
| } |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| if v_1.AuxInt != 1 { |
| break |
| } |
| v.reset(OpNeg16) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add16 (Add16 i:(Const16 <t>) z) x) |
| // cond: (z.Op != OpConst16 && x.Op != OpConst16) |
| // result: (Add16 i (Add16 <t> z x)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd16 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst16 && x.Op != OpConst16) { |
| break |
| } |
| v.reset(OpAdd16) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add16 (Add16 z i:(Const16 <t>)) x) |
| // cond: (z.Op != OpConst16 && x.Op != OpConst16) |
| // result: (Add16 i (Add16 <t> z x)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd16 { |
| break |
| } |
| _ = v_0.Args[1] |
| z := v_0.Args[0] |
| i := v_0.Args[1] |
| if i.Op != OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst16 && x.Op != OpConst16) { |
| break |
| } |
| v.reset(OpAdd16) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add16 x (Add16 i:(Const16 <t>) z)) |
| // cond: (z.Op != OpConst16 && x.Op != OpConst16) |
| // result: (Add16 i (Add16 <t> z x)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd16 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst16 && x.Op != OpConst16) { |
| break |
| } |
| v.reset(OpAdd16) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add16 x (Add16 z i:(Const16 <t>))) |
| // cond: (z.Op != OpConst16 && x.Op != OpConst16) |
| // result: (Add16 i (Add16 <t> z x)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| i := v_1.Args[1] |
| if i.Op != OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst16 && x.Op != OpConst16) { |
| break |
| } |
| v.reset(OpAdd16) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add16 (Sub16 i:(Const16 <t>) z) x) |
| // cond: (z.Op != OpConst16 && x.Op != OpConst16) |
| // result: (Add16 i (Sub16 <t> x z)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub16 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst16 && x.Op != OpConst16) { |
| break |
| } |
| v.reset(OpAdd16) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpSub16, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add16 x (Sub16 i:(Const16 <t>) z)) |
| // cond: (z.Op != OpConst16 && x.Op != OpConst16) |
| // result: (Add16 i (Sub16 <t> x z)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub16 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst16 && x.Op != OpConst16) { |
| break |
| } |
| v.reset(OpAdd16) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpSub16, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd16_20(v *Value) bool { |
| b := v.Block |
| // match: (Add16 x (Sub16 i:(Const16 <t>) z)) |
| // cond: (z.Op != OpConst16 && x.Op != OpConst16) |
| // result: (Add16 i (Sub16 <t> x z)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub16 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst16 && x.Op != OpConst16) { |
| break |
| } |
| v.reset(OpAdd16) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpSub16, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add16 (Sub16 i:(Const16 <t>) z) x) |
| // cond: (z.Op != OpConst16 && x.Op != OpConst16) |
| // result: (Add16 i (Sub16 <t> x z)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub16 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst16 && x.Op != OpConst16) { |
| break |
| } |
| v.reset(OpAdd16) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpSub16, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add16 (Sub16 z i:(Const16 <t>)) x) |
| // cond: (z.Op != OpConst16 && x.Op != OpConst16) |
| // result: (Sub16 (Add16 <t> x z) i) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub16 { |
| break |
| } |
| _ = v_0.Args[1] |
| z := v_0.Args[0] |
| i := v_0.Args[1] |
| if i.Op != OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst16 && x.Op != OpConst16) { |
| break |
| } |
| v.reset(OpSub16) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| v.AddArg(i) |
| return true |
| } |
| // match: (Add16 x (Sub16 z i:(Const16 <t>))) |
| // cond: (z.Op != OpConst16 && x.Op != OpConst16) |
| // result: (Sub16 (Add16 <t> x z) i) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub16 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| i := v_1.Args[1] |
| if i.Op != OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst16 && x.Op != OpConst16) { |
| break |
| } |
| v.reset(OpSub16) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| v.AddArg(i) |
| return true |
| } |
| // match: (Add16 x (Sub16 z i:(Const16 <t>))) |
| // cond: (z.Op != OpConst16 && x.Op != OpConst16) |
| // result: (Sub16 (Add16 <t> x z) i) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub16 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| i := v_1.Args[1] |
| if i.Op != OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst16 && x.Op != OpConst16) { |
| break |
| } |
| v.reset(OpSub16) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| v.AddArg(i) |
| return true |
| } |
| // match: (Add16 (Sub16 z i:(Const16 <t>)) x) |
| // cond: (z.Op != OpConst16 && x.Op != OpConst16) |
| // result: (Sub16 (Add16 <t> x z) i) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub16 { |
| break |
| } |
| _ = v_0.Args[1] |
| z := v_0.Args[0] |
| i := v_0.Args[1] |
| if i.Op != OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst16 && x.Op != OpConst16) { |
| break |
| } |
| v.reset(OpSub16) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| v.AddArg(i) |
| return true |
| } |
| // match: (Add16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x)) |
| // cond: |
| // result: (Add16 (Const16 <t> [int64(int16(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd16 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst16 { |
| break |
| } |
| if v_1_0.Type != t { |
| break |
| } |
| d := v_1_0.AuxInt |
| v.reset(OpAdd16) |
| v0 := b.NewValue0(v.Pos, OpConst16, t) |
| v0.AuxInt = int64(int16(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add16 (Const16 <t> [c]) (Add16 x (Const16 <t> [d]))) |
| // cond: |
| // result: (Add16 (Const16 <t> [int64(int16(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst16 { |
| break |
| } |
| if v_1_1.Type != t { |
| break |
| } |
| d := v_1_1.AuxInt |
| v.reset(OpAdd16) |
| v0 := b.NewValue0(v.Pos, OpConst16, t) |
| v0.AuxInt = int64(int16(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c])) |
| // cond: |
| // result: (Add16 (Const16 <t> [int64(int16(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd16 { |
| break |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst16 { |
| break |
| } |
| t := v_0_0.Type |
| d := v_0_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAdd16) |
| v0 := b.NewValue0(v.Pos, OpConst16, t) |
| v0.AuxInt = int64(int16(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add16 (Add16 x (Const16 <t> [d])) (Const16 <t> [c])) |
| // cond: |
| // result: (Add16 (Const16 <t> [int64(int16(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd16 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst16 { |
| break |
| } |
| t := v_0_1.Type |
| d := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAdd16) |
| v0 := b.NewValue0(v.Pos, OpConst16, t) |
| v0.AuxInt = int64(int16(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd16_30(v *Value) bool { |
| b := v.Block |
| // match: (Add16 (Const16 <t> [c]) (Sub16 (Const16 <t> [d]) x)) |
| // cond: |
| // result: (Sub16 (Const16 <t> [int64(int16(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub16 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst16 { |
| break |
| } |
| if v_1_0.Type != t { |
| break |
| } |
| d := v_1_0.AuxInt |
| v.reset(OpSub16) |
| v0 := b.NewValue0(v.Pos, OpConst16, t) |
| v0.AuxInt = int64(int16(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add16 (Sub16 (Const16 <t> [d]) x) (Const16 <t> [c])) |
| // cond: |
| // result: (Sub16 (Const16 <t> [int64(int16(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub16 { |
| break |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst16 { |
| break |
| } |
| t := v_0_0.Type |
| d := v_0_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpSub16) |
| v0 := b.NewValue0(v.Pos, OpConst16, t) |
| v0.AuxInt = int64(int16(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add16 (Const16 <t> [c]) (Sub16 x (Const16 <t> [d]))) |
| // cond: |
| // result: (Add16 (Const16 <t> [int64(int16(c-d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub16 { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst16 { |
| break |
| } |
| if v_1_1.Type != t { |
| break |
| } |
| d := v_1_1.AuxInt |
| v.reset(OpAdd16) |
| v0 := b.NewValue0(v.Pos, OpConst16, t) |
| v0.AuxInt = int64(int16(c - d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add16 (Sub16 x (Const16 <t> [d])) (Const16 <t> [c])) |
| // cond: |
| // result: (Add16 (Const16 <t> [int64(int16(c-d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub16 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst16 { |
| break |
| } |
| t := v_0_1.Type |
| d := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAdd16) |
| v0 := b.NewValue0(v.Pos, OpConst16, t) |
| v0.AuxInt = int64(int16(c - d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd32_0(v *Value) bool { |
| b := v.Block |
| // match: (Add32 (Const32 [c]) (Const32 [d])) |
| // cond: |
| // result: (Const32 [int64(int32(c+d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| d := v_1.AuxInt |
| v.reset(OpConst32) |
| v.AuxInt = int64(int32(c + d)) |
| return true |
| } |
| // match: (Add32 (Const32 [d]) (Const32 [c])) |
| // cond: |
| // result: (Const32 [int64(int32(c+d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| d := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpConst32) |
| v.AuxInt = int64(int32(c + d)) |
| return true |
| } |
| // match: (Add32 <t> (Mul32 x y) (Mul32 x z)) |
| // cond: |
| // result: (Mul32 x (Add32 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| z := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpMul32) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add32 <t> (Mul32 y x) (Mul32 x z)) |
| // cond: |
| // result: (Mul32 x (Add32 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| x := v_0.Args[1] |
| y := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| z := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpMul32) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add32 <t> (Mul32 x y) (Mul32 z x)) |
| // cond: |
| // result: (Mul32 x (Add32 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpMul32) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add32 <t> (Mul32 y x) (Mul32 z x)) |
| // cond: |
| // result: (Mul32 x (Add32 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| x := v_0.Args[1] |
| y := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpMul32) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add32 <t> (Mul32 x z) (Mul32 x y)) |
| // cond: |
| // result: (Mul32 x (Add32 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| z := v_0.Args[1] |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| y := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpMul32) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add32 <t> (Mul32 z x) (Mul32 x y)) |
| // cond: |
| // result: (Mul32 x (Add32 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| x := v_0.Args[1] |
| z := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| y := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpMul32) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add32 <t> (Mul32 x z) (Mul32 y x)) |
| // cond: |
| // result: (Mul32 x (Add32 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| z := v_0.Args[1] |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpMul32) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add32 <t> (Mul32 z x) (Mul32 y x)) |
| // cond: |
| // result: (Mul32 x (Add32 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| x := v_0.Args[1] |
| z := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpMul32) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd32_10(v *Value) bool { |
| b := v.Block |
| // match: (Add32 (Const32 [0]) x) |
| // cond: |
| // result: x |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| if v_0.AuxInt != 0 { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add32 x (Const32 [0])) |
| // cond: |
| // result: x |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| if v_1.AuxInt != 0 { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add32 (Const32 [1]) (Com32 x)) |
| // cond: |
| // result: (Neg32 x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| if v_0.AuxInt != 1 { |
| break |
| } |
| v_1 := v.Args[1] |
| if v_1.Op != OpCom32 { |
| break |
| } |
| x := v_1.Args[0] |
| v.reset(OpNeg32) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add32 (Com32 x) (Const32 [1])) |
| // cond: |
| // result: (Neg32 x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpCom32 { |
| break |
| } |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| if v_1.AuxInt != 1 { |
| break |
| } |
| v.reset(OpNeg32) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add32 (Add32 i:(Const32 <t>) z) x) |
| // cond: (z.Op != OpConst32 && x.Op != OpConst32) |
| // result: (Add32 i (Add32 <t> z x)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd32 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst32 && x.Op != OpConst32) { |
| break |
| } |
| v.reset(OpAdd32) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add32 (Add32 z i:(Const32 <t>)) x) |
| // cond: (z.Op != OpConst32 && x.Op != OpConst32) |
| // result: (Add32 i (Add32 <t> z x)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| z := v_0.Args[0] |
| i := v_0.Args[1] |
| if i.Op != OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst32 && x.Op != OpConst32) { |
| break |
| } |
| v.reset(OpAdd32) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add32 x (Add32 i:(Const32 <t>) z)) |
| // cond: (z.Op != OpConst32 && x.Op != OpConst32) |
| // result: (Add32 i (Add32 <t> z x)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd32 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst32 && x.Op != OpConst32) { |
| break |
| } |
| v.reset(OpAdd32) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add32 x (Add32 z i:(Const32 <t>))) |
| // cond: (z.Op != OpConst32 && x.Op != OpConst32) |
| // result: (Add32 i (Add32 <t> z x)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| i := v_1.Args[1] |
| if i.Op != OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst32 && x.Op != OpConst32) { |
| break |
| } |
| v.reset(OpAdd32) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add32 (Sub32 i:(Const32 <t>) z) x) |
| // cond: (z.Op != OpConst32 && x.Op != OpConst32) |
| // result: (Add32 i (Sub32 <t> x z)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub32 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst32 && x.Op != OpConst32) { |
| break |
| } |
| v.reset(OpAdd32) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpSub32, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add32 x (Sub32 i:(Const32 <t>) z)) |
| // cond: (z.Op != OpConst32 && x.Op != OpConst32) |
| // result: (Add32 i (Sub32 <t> x z)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub32 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst32 && x.Op != OpConst32) { |
| break |
| } |
| v.reset(OpAdd32) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpSub32, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd32_20(v *Value) bool { |
| b := v.Block |
| // match: (Add32 x (Sub32 i:(Const32 <t>) z)) |
| // cond: (z.Op != OpConst32 && x.Op != OpConst32) |
| // result: (Add32 i (Sub32 <t> x z)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub32 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst32 && x.Op != OpConst32) { |
| break |
| } |
| v.reset(OpAdd32) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpSub32, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add32 (Sub32 i:(Const32 <t>) z) x) |
| // cond: (z.Op != OpConst32 && x.Op != OpConst32) |
| // result: (Add32 i (Sub32 <t> x z)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub32 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst32 && x.Op != OpConst32) { |
| break |
| } |
| v.reset(OpAdd32) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpSub32, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add32 (Sub32 z i:(Const32 <t>)) x) |
| // cond: (z.Op != OpConst32 && x.Op != OpConst32) |
| // result: (Sub32 (Add32 <t> x z) i) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub32 { |
| break |
| } |
| _ = v_0.Args[1] |
| z := v_0.Args[0] |
| i := v_0.Args[1] |
| if i.Op != OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst32 && x.Op != OpConst32) { |
| break |
| } |
| v.reset(OpSub32) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| v.AddArg(i) |
| return true |
| } |
| // match: (Add32 x (Sub32 z i:(Const32 <t>))) |
| // cond: (z.Op != OpConst32 && x.Op != OpConst32) |
| // result: (Sub32 (Add32 <t> x z) i) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub32 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| i := v_1.Args[1] |
| if i.Op != OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst32 && x.Op != OpConst32) { |
| break |
| } |
| v.reset(OpSub32) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| v.AddArg(i) |
| return true |
| } |
| // match: (Add32 x (Sub32 z i:(Const32 <t>))) |
| // cond: (z.Op != OpConst32 && x.Op != OpConst32) |
| // result: (Sub32 (Add32 <t> x z) i) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub32 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| i := v_1.Args[1] |
| if i.Op != OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst32 && x.Op != OpConst32) { |
| break |
| } |
| v.reset(OpSub32) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| v.AddArg(i) |
| return true |
| } |
| // match: (Add32 (Sub32 z i:(Const32 <t>)) x) |
| // cond: (z.Op != OpConst32 && x.Op != OpConst32) |
| // result: (Sub32 (Add32 <t> x z) i) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub32 { |
| break |
| } |
| _ = v_0.Args[1] |
| z := v_0.Args[0] |
| i := v_0.Args[1] |
| if i.Op != OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst32 && x.Op != OpConst32) { |
| break |
| } |
| v.reset(OpSub32) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| v.AddArg(i) |
| return true |
| } |
| // match: (Add32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x)) |
| // cond: |
| // result: (Add32 (Const32 <t> [int64(int32(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd32 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| if v_1_0.Type != t { |
| break |
| } |
| d := v_1_0.AuxInt |
| v.reset(OpAdd32) |
| v0 := b.NewValue0(v.Pos, OpConst32, t) |
| v0.AuxInt = int64(int32(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add32 (Const32 <t> [c]) (Add32 x (Const32 <t> [d]))) |
| // cond: |
| // result: (Add32 (Const32 <t> [int64(int32(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| if v_1_1.Type != t { |
| break |
| } |
| d := v_1_1.AuxInt |
| v.reset(OpAdd32) |
| v0 := b.NewValue0(v.Pos, OpConst32, t) |
| v0.AuxInt = int64(int32(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c])) |
| // cond: |
| // result: (Add32 (Const32 <t> [int64(int32(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd32 { |
| break |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| t := v_0_0.Type |
| d := v_0_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAdd32) |
| v0 := b.NewValue0(v.Pos, OpConst32, t) |
| v0.AuxInt = int64(int32(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add32 (Add32 x (Const32 <t> [d])) (Const32 <t> [c])) |
| // cond: |
| // result: (Add32 (Const32 <t> [int64(int32(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| t := v_0_1.Type |
| d := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAdd32) |
| v0 := b.NewValue0(v.Pos, OpConst32, t) |
| v0.AuxInt = int64(int32(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd32_30(v *Value) bool { |
| b := v.Block |
| // match: (Add32 (Const32 <t> [c]) (Sub32 (Const32 <t> [d]) x)) |
| // cond: |
| // result: (Sub32 (Const32 <t> [int64(int32(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub32 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| if v_1_0.Type != t { |
| break |
| } |
| d := v_1_0.AuxInt |
| v.reset(OpSub32) |
| v0 := b.NewValue0(v.Pos, OpConst32, t) |
| v0.AuxInt = int64(int32(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add32 (Sub32 (Const32 <t> [d]) x) (Const32 <t> [c])) |
| // cond: |
| // result: (Sub32 (Const32 <t> [int64(int32(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub32 { |
| break |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| t := v_0_0.Type |
| d := v_0_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpSub32) |
| v0 := b.NewValue0(v.Pos, OpConst32, t) |
| v0.AuxInt = int64(int32(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add32 (Const32 <t> [c]) (Sub32 x (Const32 <t> [d]))) |
| // cond: |
| // result: (Add32 (Const32 <t> [int64(int32(c-d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub32 { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| if v_1_1.Type != t { |
| break |
| } |
| d := v_1_1.AuxInt |
| v.reset(OpAdd32) |
| v0 := b.NewValue0(v.Pos, OpConst32, t) |
| v0.AuxInt = int64(int32(c - d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add32 (Sub32 x (Const32 <t> [d])) (Const32 <t> [c])) |
| // cond: |
| // result: (Add32 (Const32 <t> [int64(int32(c-d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub32 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| t := v_0_1.Type |
| d := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAdd32) |
| v0 := b.NewValue0(v.Pos, OpConst32, t) |
| v0.AuxInt = int64(int32(c - d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd32F_0(v *Value) bool { |
| // match: (Add32F (Const32F [c]) (Const32F [d])) |
| // cond: |
| // result: (Const32F [auxFrom32F(auxTo32F(c) + auxTo32F(d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32F { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32F { |
| break |
| } |
| d := v_1.AuxInt |
| v.reset(OpConst32F) |
| v.AuxInt = auxFrom32F(auxTo32F(c) + auxTo32F(d)) |
| return true |
| } |
| // match: (Add32F (Const32F [d]) (Const32F [c])) |
| // cond: |
| // result: (Const32F [auxFrom32F(auxTo32F(c) + auxTo32F(d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32F { |
| break |
| } |
| d := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32F { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpConst32F) |
| v.AuxInt = auxFrom32F(auxTo32F(c) + auxTo32F(d)) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd64_0(v *Value) bool { |
| b := v.Block |
| // match: (Add64 (Const64 [c]) (Const64 [d])) |
| // cond: |
| // result: (Const64 [c+d]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| d := v_1.AuxInt |
| v.reset(OpConst64) |
| v.AuxInt = c + d |
| return true |
| } |
| // match: (Add64 (Const64 [d]) (Const64 [c])) |
| // cond: |
| // result: (Const64 [c+d]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| d := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpConst64) |
| v.AuxInt = c + d |
| return true |
| } |
| // match: (Add64 <t> (Mul64 x y) (Mul64 x z)) |
| // cond: |
| // result: (Mul64 x (Add64 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| z := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpMul64) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add64 <t> (Mul64 y x) (Mul64 x z)) |
| // cond: |
| // result: (Mul64 x (Add64 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| x := v_0.Args[1] |
| y := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| z := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpMul64) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add64 <t> (Mul64 x y) (Mul64 z x)) |
| // cond: |
| // result: (Mul64 x (Add64 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpMul64) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add64 <t> (Mul64 y x) (Mul64 z x)) |
| // cond: |
| // result: (Mul64 x (Add64 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| x := v_0.Args[1] |
| y := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpMul64) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add64 <t> (Mul64 x z) (Mul64 x y)) |
| // cond: |
| // result: (Mul64 x (Add64 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| z := v_0.Args[1] |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| y := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpMul64) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add64 <t> (Mul64 z x) (Mul64 x y)) |
| // cond: |
| // result: (Mul64 x (Add64 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| x := v_0.Args[1] |
| z := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| y := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpMul64) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add64 <t> (Mul64 x z) (Mul64 y x)) |
| // cond: |
| // result: (Mul64 x (Add64 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| z := v_0.Args[1] |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpMul64) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add64 <t> (Mul64 z x) (Mul64 y x)) |
| // cond: |
| // result: (Mul64 x (Add64 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| x := v_0.Args[1] |
| z := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpMul64) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd64_10(v *Value) bool { |
| b := v.Block |
| // match: (Add64 (Const64 [0]) x) |
| // cond: |
| // result: x |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| if v_0.AuxInt != 0 { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add64 x (Const64 [0])) |
| // cond: |
| // result: x |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| if v_1.AuxInt != 0 { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add64 (Const64 [1]) (Com64 x)) |
| // cond: |
| // result: (Neg64 x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| if v_0.AuxInt != 1 { |
| break |
| } |
| v_1 := v.Args[1] |
| if v_1.Op != OpCom64 { |
| break |
| } |
| x := v_1.Args[0] |
| v.reset(OpNeg64) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add64 (Com64 x) (Const64 [1])) |
| // cond: |
| // result: (Neg64 x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpCom64 { |
| break |
| } |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| if v_1.AuxInt != 1 { |
| break |
| } |
| v.reset(OpNeg64) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add64 (Add64 i:(Const64 <t>) z) x) |
| // cond: (z.Op != OpConst64 && x.Op != OpConst64) |
| // result: (Add64 i (Add64 <t> z x)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd64 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst64 && x.Op != OpConst64) { |
| break |
| } |
| v.reset(OpAdd64) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add64 (Add64 z i:(Const64 <t>)) x) |
| // cond: (z.Op != OpConst64 && x.Op != OpConst64) |
| // result: (Add64 i (Add64 <t> z x)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| z := v_0.Args[0] |
| i := v_0.Args[1] |
| if i.Op != OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst64 && x.Op != OpConst64) { |
| break |
| } |
| v.reset(OpAdd64) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add64 x (Add64 i:(Const64 <t>) z)) |
| // cond: (z.Op != OpConst64 && x.Op != OpConst64) |
| // result: (Add64 i (Add64 <t> z x)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd64 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst64 && x.Op != OpConst64) { |
| break |
| } |
| v.reset(OpAdd64) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add64 x (Add64 z i:(Const64 <t>))) |
| // cond: (z.Op != OpConst64 && x.Op != OpConst64) |
| // result: (Add64 i (Add64 <t> z x)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| i := v_1.Args[1] |
| if i.Op != OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst64 && x.Op != OpConst64) { |
| break |
| } |
| v.reset(OpAdd64) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add64 (Sub64 i:(Const64 <t>) z) x) |
| // cond: (z.Op != OpConst64 && x.Op != OpConst64) |
| // result: (Add64 i (Sub64 <t> x z)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub64 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst64 && x.Op != OpConst64) { |
| break |
| } |
| v.reset(OpAdd64) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpSub64, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add64 x (Sub64 i:(Const64 <t>) z)) |
| // cond: (z.Op != OpConst64 && x.Op != OpConst64) |
| // result: (Add64 i (Sub64 <t> x z)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub64 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst64 && x.Op != OpConst64) { |
| break |
| } |
| v.reset(OpAdd64) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpSub64, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd64_20(v *Value) bool { |
| b := v.Block |
| // match: (Add64 x (Sub64 i:(Const64 <t>) z)) |
| // cond: (z.Op != OpConst64 && x.Op != OpConst64) |
| // result: (Add64 i (Sub64 <t> x z)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub64 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst64 && x.Op != OpConst64) { |
| break |
| } |
| v.reset(OpAdd64) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpSub64, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add64 (Sub64 i:(Const64 <t>) z) x) |
| // cond: (z.Op != OpConst64 && x.Op != OpConst64) |
| // result: (Add64 i (Sub64 <t> x z)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub64 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst64 && x.Op != OpConst64) { |
| break |
| } |
| v.reset(OpAdd64) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpSub64, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add64 (Sub64 z i:(Const64 <t>)) x) |
| // cond: (z.Op != OpConst64 && x.Op != OpConst64) |
| // result: (Sub64 (Add64 <t> x z) i) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub64 { |
| break |
| } |
| _ = v_0.Args[1] |
| z := v_0.Args[0] |
| i := v_0.Args[1] |
| if i.Op != OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst64 && x.Op != OpConst64) { |
| break |
| } |
| v.reset(OpSub64) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| v.AddArg(i) |
| return true |
| } |
| // match: (Add64 x (Sub64 z i:(Const64 <t>))) |
| // cond: (z.Op != OpConst64 && x.Op != OpConst64) |
| // result: (Sub64 (Add64 <t> x z) i) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub64 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| i := v_1.Args[1] |
| if i.Op != OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst64 && x.Op != OpConst64) { |
| break |
| } |
| v.reset(OpSub64) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| v.AddArg(i) |
| return true |
| } |
| // match: (Add64 x (Sub64 z i:(Const64 <t>))) |
| // cond: (z.Op != OpConst64 && x.Op != OpConst64) |
| // result: (Sub64 (Add64 <t> x z) i) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub64 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| i := v_1.Args[1] |
| if i.Op != OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst64 && x.Op != OpConst64) { |
| break |
| } |
| v.reset(OpSub64) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| v.AddArg(i) |
| return true |
| } |
| // match: (Add64 (Sub64 z i:(Const64 <t>)) x) |
| // cond: (z.Op != OpConst64 && x.Op != OpConst64) |
| // result: (Sub64 (Add64 <t> x z) i) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub64 { |
| break |
| } |
| _ = v_0.Args[1] |
| z := v_0.Args[0] |
| i := v_0.Args[1] |
| if i.Op != OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst64 && x.Op != OpConst64) { |
| break |
| } |
| v.reset(OpSub64) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| v.AddArg(i) |
| return true |
| } |
| // match: (Add64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x)) |
| // cond: |
| // result: (Add64 (Const64 <t> [c+d]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd64 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst64 { |
| break |
| } |
| if v_1_0.Type != t { |
| break |
| } |
| d := v_1_0.AuxInt |
| v.reset(OpAdd64) |
| v0 := b.NewValue0(v.Pos, OpConst64, t) |
| v0.AuxInt = c + d |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add64 (Const64 <t> [c]) (Add64 x (Const64 <t> [d]))) |
| // cond: |
| // result: (Add64 (Const64 <t> [c+d]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1.Type != t { |
| break |
| } |
| d := v_1_1.AuxInt |
| v.reset(OpAdd64) |
| v0 := b.NewValue0(v.Pos, OpConst64, t) |
| v0.AuxInt = c + d |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c])) |
| // cond: |
| // result: (Add64 (Const64 <t> [c+d]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd64 { |
| break |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst64 { |
| break |
| } |
| t := v_0_0.Type |
| d := v_0_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAdd64) |
| v0 := b.NewValue0(v.Pos, OpConst64, t) |
| v0.AuxInt = c + d |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add64 (Add64 x (Const64 <t> [d])) (Const64 <t> [c])) |
| // cond: |
| // result: (Add64 (Const64 <t> [c+d]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| t := v_0_1.Type |
| d := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAdd64) |
| v0 := b.NewValue0(v.Pos, OpConst64, t) |
| v0.AuxInt = c + d |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd64_30(v *Value) bool { |
| b := v.Block |
| // match: (Add64 (Const64 <t> [c]) (Sub64 (Const64 <t> [d]) x)) |
| // cond: |
| // result: (Sub64 (Const64 <t> [c+d]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub64 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst64 { |
| break |
| } |
| if v_1_0.Type != t { |
| break |
| } |
| d := v_1_0.AuxInt |
| v.reset(OpSub64) |
| v0 := b.NewValue0(v.Pos, OpConst64, t) |
| v0.AuxInt = c + d |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add64 (Sub64 (Const64 <t> [d]) x) (Const64 <t> [c])) |
| // cond: |
| // result: (Sub64 (Const64 <t> [c+d]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub64 { |
| break |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst64 { |
| break |
| } |
| t := v_0_0.Type |
| d := v_0_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpSub64) |
| v0 := b.NewValue0(v.Pos, OpConst64, t) |
| v0.AuxInt = c + d |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add64 (Const64 <t> [c]) (Sub64 x (Const64 <t> [d]))) |
| // cond: |
| // result: (Add64 (Const64 <t> [c-d]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub64 { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1.Type != t { |
| break |
| } |
| d := v_1_1.AuxInt |
| v.reset(OpAdd64) |
| v0 := b.NewValue0(v.Pos, OpConst64, t) |
| v0.AuxInt = c - d |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add64 (Sub64 x (Const64 <t> [d])) (Const64 <t> [c])) |
| // cond: |
| // result: (Add64 (Const64 <t> [c-d]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| t := v_0_1.Type |
| d := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAdd64) |
| v0 := b.NewValue0(v.Pos, OpConst64, t) |
| v0.AuxInt = c - d |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd64F_0(v *Value) bool { |
| // match: (Add64F (Const64F [c]) (Const64F [d])) |
| // cond: |
| // result: (Const64F [auxFrom64F(auxTo64F(c) + auxTo64F(d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64F { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64F { |
| break |
| } |
| d := v_1.AuxInt |
| v.reset(OpConst64F) |
| v.AuxInt = auxFrom64F(auxTo64F(c) + auxTo64F(d)) |
| return true |
| } |
| // match: (Add64F (Const64F [d]) (Const64F [c])) |
| // cond: |
| // result: (Const64F [auxFrom64F(auxTo64F(c) + auxTo64F(d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64F { |
| break |
| } |
| d := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64F { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpConst64F) |
| v.AuxInt = auxFrom64F(auxTo64F(c) + auxTo64F(d)) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd8_0(v *Value) bool { |
| b := v.Block |
| // match: (Add8 (Const8 [c]) (Const8 [d])) |
| // cond: |
| // result: (Const8 [int64(int8(c+d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| d := v_1.AuxInt |
| v.reset(OpConst8) |
| v.AuxInt = int64(int8(c + d)) |
| return true |
| } |
| // match: (Add8 (Const8 [d]) (Const8 [c])) |
| // cond: |
| // result: (Const8 [int64(int8(c+d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| d := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpConst8) |
| v.AuxInt = int64(int8(c + d)) |
| return true |
| } |
| // match: (Add8 <t> (Mul8 x y) (Mul8 x z)) |
| // cond: |
| // result: (Mul8 x (Add8 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul8 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul8 { |
| break |
| } |
| z := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpMul8) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add8 <t> (Mul8 y x) (Mul8 x z)) |
| // cond: |
| // result: (Mul8 x (Add8 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul8 { |
| break |
| } |
| x := v_0.Args[1] |
| y := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul8 { |
| break |
| } |
| z := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpMul8) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add8 <t> (Mul8 x y) (Mul8 z x)) |
| // cond: |
| // result: (Mul8 x (Add8 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul8 { |
| break |
| } |
| y := v_0.Args[1] |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul8 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpMul8) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add8 <t> (Mul8 y x) (Mul8 z x)) |
| // cond: |
| // result: (Mul8 x (Add8 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul8 { |
| break |
| } |
| x := v_0.Args[1] |
| y := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul8 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpMul8) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add8 <t> (Mul8 x z) (Mul8 x y)) |
| // cond: |
| // result: (Mul8 x (Add8 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul8 { |
| break |
| } |
| z := v_0.Args[1] |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul8 { |
| break |
| } |
| y := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpMul8) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add8 <t> (Mul8 z x) (Mul8 x y)) |
| // cond: |
| // result: (Mul8 x (Add8 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul8 { |
| break |
| } |
| x := v_0.Args[1] |
| z := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul8 { |
| break |
| } |
| y := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpMul8) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add8 <t> (Mul8 x z) (Mul8 y x)) |
| // cond: |
| // result: (Mul8 x (Add8 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul8 { |
| break |
| } |
| z := v_0.Args[1] |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul8 { |
| break |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpMul8) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add8 <t> (Mul8 z x) (Mul8 y x)) |
| // cond: |
| // result: (Mul8 x (Add8 <t> y z)) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul8 { |
| break |
| } |
| x := v_0.Args[1] |
| z := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul8 { |
| break |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpMul8) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(y) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd8_10(v *Value) bool { |
| b := v.Block |
| // match: (Add8 (Const8 [0]) x) |
| // cond: |
| // result: x |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| if v_0.AuxInt != 0 { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add8 x (Const8 [0])) |
| // cond: |
| // result: x |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| if v_1.AuxInt != 0 { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add8 (Const8 [1]) (Com8 x)) |
| // cond: |
| // result: (Neg8 x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| if v_0.AuxInt != 1 { |
| break |
| } |
| v_1 := v.Args[1] |
| if v_1.Op != OpCom8 { |
| break |
| } |
| x := v_1.Args[0] |
| v.reset(OpNeg8) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add8 (Com8 x) (Const8 [1])) |
| // cond: |
| // result: (Neg8 x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpCom8 { |
| break |
| } |
| x := v_0.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| if v_1.AuxInt != 1 { |
| break |
| } |
| v.reset(OpNeg8) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add8 (Add8 i:(Const8 <t>) z) x) |
| // cond: (z.Op != OpConst8 && x.Op != OpConst8) |
| // result: (Add8 i (Add8 <t> z x)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd8 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst8 && x.Op != OpConst8) { |
| break |
| } |
| v.reset(OpAdd8) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add8 (Add8 z i:(Const8 <t>)) x) |
| // cond: (z.Op != OpConst8 && x.Op != OpConst8) |
| // result: (Add8 i (Add8 <t> z x)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd8 { |
| break |
| } |
| _ = v_0.Args[1] |
| z := v_0.Args[0] |
| i := v_0.Args[1] |
| if i.Op != OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst8 && x.Op != OpConst8) { |
| break |
| } |
| v.reset(OpAdd8) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add8 x (Add8 i:(Const8 <t>) z)) |
| // cond: (z.Op != OpConst8 && x.Op != OpConst8) |
| // result: (Add8 i (Add8 <t> z x)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd8 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst8 && x.Op != OpConst8) { |
| break |
| } |
| v.reset(OpAdd8) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add8 x (Add8 z i:(Const8 <t>))) |
| // cond: (z.Op != OpConst8 && x.Op != OpConst8) |
| // result: (Add8 i (Add8 <t> z x)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| i := v_1.Args[1] |
| if i.Op != OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst8 && x.Op != OpConst8) { |
| break |
| } |
| v.reset(OpAdd8) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add8 (Sub8 i:(Const8 <t>) z) x) |
| // cond: (z.Op != OpConst8 && x.Op != OpConst8) |
| // result: (Add8 i (Sub8 <t> x z)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub8 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst8 && x.Op != OpConst8) { |
| break |
| } |
| v.reset(OpAdd8) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpSub8, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add8 x (Sub8 i:(Const8 <t>) z)) |
| // cond: (z.Op != OpConst8 && x.Op != OpConst8) |
| // result: (Add8 i (Sub8 <t> x z)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub8 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst8 && x.Op != OpConst8) { |
| break |
| } |
| v.reset(OpAdd8) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpSub8, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd8_20(v *Value) bool { |
| b := v.Block |
| // match: (Add8 x (Sub8 i:(Const8 <t>) z)) |
| // cond: (z.Op != OpConst8 && x.Op != OpConst8) |
| // result: (Add8 i (Sub8 <t> x z)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub8 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst8 && x.Op != OpConst8) { |
| break |
| } |
| v.reset(OpAdd8) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpSub8, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add8 (Sub8 i:(Const8 <t>) z) x) |
| // cond: (z.Op != OpConst8 && x.Op != OpConst8) |
| // result: (Add8 i (Sub8 <t> x z)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub8 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst8 && x.Op != OpConst8) { |
| break |
| } |
| v.reset(OpAdd8) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpSub8, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Add8 (Sub8 z i:(Const8 <t>)) x) |
| // cond: (z.Op != OpConst8 && x.Op != OpConst8) |
| // result: (Sub8 (Add8 <t> x z) i) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub8 { |
| break |
| } |
| _ = v_0.Args[1] |
| z := v_0.Args[0] |
| i := v_0.Args[1] |
| if i.Op != OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst8 && x.Op != OpConst8) { |
| break |
| } |
| v.reset(OpSub8) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| v.AddArg(i) |
| return true |
| } |
| // match: (Add8 x (Sub8 z i:(Const8 <t>))) |
| // cond: (z.Op != OpConst8 && x.Op != OpConst8) |
| // result: (Sub8 (Add8 <t> x z) i) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub8 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| i := v_1.Args[1] |
| if i.Op != OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst8 && x.Op != OpConst8) { |
| break |
| } |
| v.reset(OpSub8) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| v.AddArg(i) |
| return true |
| } |
| // match: (Add8 x (Sub8 z i:(Const8 <t>))) |
| // cond: (z.Op != OpConst8 && x.Op != OpConst8) |
| // result: (Sub8 (Add8 <t> x z) i) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub8 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| i := v_1.Args[1] |
| if i.Op != OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst8 && x.Op != OpConst8) { |
| break |
| } |
| v.reset(OpSub8) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| v.AddArg(i) |
| return true |
| } |
| // match: (Add8 (Sub8 z i:(Const8 <t>)) x) |
| // cond: (z.Op != OpConst8 && x.Op != OpConst8) |
| // result: (Sub8 (Add8 <t> x z) i) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub8 { |
| break |
| } |
| _ = v_0.Args[1] |
| z := v_0.Args[0] |
| i := v_0.Args[1] |
| if i.Op != OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst8 && x.Op != OpConst8) { |
| break |
| } |
| v.reset(OpSub8) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(x) |
| v0.AddArg(z) |
| v.AddArg(v0) |
| v.AddArg(i) |
| return true |
| } |
| // match: (Add8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x)) |
| // cond: |
| // result: (Add8 (Const8 <t> [int64(int8(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd8 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst8 { |
| break |
| } |
| if v_1_0.Type != t { |
| break |
| } |
| d := v_1_0.AuxInt |
| v.reset(OpAdd8) |
| v0 := b.NewValue0(v.Pos, OpConst8, t) |
| v0.AuxInt = int64(int8(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add8 (Const8 <t> [c]) (Add8 x (Const8 <t> [d]))) |
| // cond: |
| // result: (Add8 (Const8 <t> [int64(int8(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst8 { |
| break |
| } |
| if v_1_1.Type != t { |
| break |
| } |
| d := v_1_1.AuxInt |
| v.reset(OpAdd8) |
| v0 := b.NewValue0(v.Pos, OpConst8, t) |
| v0.AuxInt = int64(int8(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add8 (Add8 (Const8 <t> [d]) x) (Const8 <t> [c])) |
| // cond: |
| // result: (Add8 (Const8 <t> [int64(int8(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd8 { |
| break |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst8 { |
| break |
| } |
| t := v_0_0.Type |
| d := v_0_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAdd8) |
| v0 := b.NewValue0(v.Pos, OpConst8, t) |
| v0.AuxInt = int64(int8(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add8 (Add8 x (Const8 <t> [d])) (Const8 <t> [c])) |
| // cond: |
| // result: (Add8 (Const8 <t> [int64(int8(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd8 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst8 { |
| break |
| } |
| t := v_0_1.Type |
| d := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAdd8) |
| v0 := b.NewValue0(v.Pos, OpConst8, t) |
| v0.AuxInt = int64(int8(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAdd8_30(v *Value) bool { |
| b := v.Block |
| // match: (Add8 (Const8 <t> [c]) (Sub8 (Const8 <t> [d]) x)) |
| // cond: |
| // result: (Sub8 (Const8 <t> [int64(int8(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub8 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst8 { |
| break |
| } |
| if v_1_0.Type != t { |
| break |
| } |
| d := v_1_0.AuxInt |
| v.reset(OpSub8) |
| v0 := b.NewValue0(v.Pos, OpConst8, t) |
| v0.AuxInt = int64(int8(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add8 (Sub8 (Const8 <t> [d]) x) (Const8 <t> [c])) |
| // cond: |
| // result: (Sub8 (Const8 <t> [int64(int8(c+d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub8 { |
| break |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst8 { |
| break |
| } |
| t := v_0_0.Type |
| d := v_0_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpSub8) |
| v0 := b.NewValue0(v.Pos, OpConst8, t) |
| v0.AuxInt = int64(int8(c + d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add8 (Const8 <t> [c]) (Sub8 x (Const8 <t> [d]))) |
| // cond: |
| // result: (Add8 (Const8 <t> [int64(int8(c-d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpSub8 { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst8 { |
| break |
| } |
| if v_1_1.Type != t { |
| break |
| } |
| d := v_1_1.AuxInt |
| v.reset(OpAdd8) |
| v0 := b.NewValue0(v.Pos, OpConst8, t) |
| v0.AuxInt = int64(int8(c - d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Add8 (Sub8 x (Const8 <t> [d])) (Const8 <t> [c])) |
| // cond: |
| // result: (Add8 (Const8 <t> [int64(int8(c-d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpSub8 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst8 { |
| break |
| } |
| t := v_0_1.Type |
| d := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAdd8) |
| v0 := b.NewValue0(v.Pos, OpConst8, t) |
| v0.AuxInt = int64(int8(c - d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAddPtr_0(v *Value) bool { |
| // match: (AddPtr <t> x (Const64 [c])) |
| // cond: |
| // result: (OffPtr <t> x [c]) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpOffPtr) |
| v.Type = t |
| v.AuxInt = c |
| v.AddArg(x) |
| return true |
| } |
| // match: (AddPtr <t> x (Const32 [c])) |
| // cond: |
| // result: (OffPtr <t> x [c]) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpOffPtr) |
| v.Type = t |
| v.AuxInt = c |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAnd16_0(v *Value) bool { |
| // match: (And16 (Const16 [c]) (Const16 [d])) |
| // cond: |
| // result: (Const16 [int64(int16(c&d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| d := v_1.AuxInt |
| v.reset(OpConst16) |
| v.AuxInt = int64(int16(c & d)) |
| return true |
| } |
| // match: (And16 (Const16 [d]) (Const16 [c])) |
| // cond: |
| // result: (Const16 [int64(int16(c&d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| d := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpConst16) |
| v.AuxInt = int64(int16(c & d)) |
| return true |
| } |
| // match: (And16 (Const16 [m]) (Rsh16Ux64 _ (Const64 [c]))) |
| // cond: c >= 64-ntz(m) |
| // result: (Const16 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| m := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpRsh16Ux64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(c >= 64-ntz(m)) { |
| break |
| } |
| v.reset(OpConst16) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And16 (Rsh16Ux64 _ (Const64 [c])) (Const16 [m])) |
| // cond: c >= 64-ntz(m) |
| // result: (Const16 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpRsh16Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| c := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| m := v_1.AuxInt |
| if !(c >= 64-ntz(m)) { |
| break |
| } |
| v.reset(OpConst16) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And16 (Const16 [m]) (Lsh16x64 _ (Const64 [c]))) |
| // cond: c >= 64-nlz(m) |
| // result: (Const16 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| m := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpLsh16x64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(c >= 64-nlz(m)) { |
| break |
| } |
| v.reset(OpConst16) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And16 (Lsh16x64 _ (Const64 [c])) (Const16 [m])) |
| // cond: c >= 64-nlz(m) |
| // result: (Const16 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpLsh16x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| c := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| m := v_1.AuxInt |
| if !(c >= 64-nlz(m)) { |
| break |
| } |
| v.reset(OpConst16) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And16 x x) |
| // cond: |
| // result: x |
| for { |
| x := v.Args[1] |
| if x != v.Args[0] { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (And16 (Const16 [-1]) x) |
| // cond: |
| // result: x |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| if v_0.AuxInt != -1 { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (And16 x (Const16 [-1])) |
| // cond: |
| // result: x |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| if v_1.AuxInt != -1 { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (And16 (Const16 [0]) _) |
| // cond: |
| // result: (Const16 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| if v_0.AuxInt != 0 { |
| break |
| } |
| v.reset(OpConst16) |
| v.AuxInt = 0 |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAnd16_10(v *Value) bool { |
| b := v.Block |
| // match: (And16 _ (Const16 [0])) |
| // cond: |
| // result: (Const16 [0]) |
| for { |
| _ = v.Args[1] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| if v_1.AuxInt != 0 { |
| break |
| } |
| v.reset(OpConst16) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And16 x (And16 x y)) |
| // cond: |
| // result: (And16 x y) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd16 { |
| break |
| } |
| y := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpAnd16) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (And16 x (And16 y x)) |
| // cond: |
| // result: (And16 x y) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpAnd16) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (And16 (And16 x y) x) |
| // cond: |
| // result: (And16 x y) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd16 { |
| break |
| } |
| y := v_0.Args[1] |
| if x != v_0.Args[0] { |
| break |
| } |
| v.reset(OpAnd16) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (And16 (And16 y x) x) |
| // cond: |
| // result: (And16 x y) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd16 { |
| break |
| } |
| _ = v_0.Args[1] |
| y := v_0.Args[0] |
| if x != v_0.Args[1] { |
| break |
| } |
| v.reset(OpAnd16) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (And16 (And16 i:(Const16 <t>) z) x) |
| // cond: (z.Op != OpConst16 && x.Op != OpConst16) |
| // result: (And16 i (And16 <t> z x)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd16 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst16 && x.Op != OpConst16) { |
| break |
| } |
| v.reset(OpAnd16) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAnd16, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (And16 (And16 z i:(Const16 <t>)) x) |
| // cond: (z.Op != OpConst16 && x.Op != OpConst16) |
| // result: (And16 i (And16 <t> z x)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd16 { |
| break |
| } |
| _ = v_0.Args[1] |
| z := v_0.Args[0] |
| i := v_0.Args[1] |
| if i.Op != OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst16 && x.Op != OpConst16) { |
| break |
| } |
| v.reset(OpAnd16) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAnd16, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (And16 x (And16 i:(Const16 <t>) z)) |
| // cond: (z.Op != OpConst16 && x.Op != OpConst16) |
| // result: (And16 i (And16 <t> z x)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd16 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst16 && x.Op != OpConst16) { |
| break |
| } |
| v.reset(OpAnd16) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAnd16, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (And16 x (And16 z i:(Const16 <t>))) |
| // cond: (z.Op != OpConst16 && x.Op != OpConst16) |
| // result: (And16 i (And16 <t> z x)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| i := v_1.Args[1] |
| if i.Op != OpConst16 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst16 && x.Op != OpConst16) { |
| break |
| } |
| v.reset(OpAnd16) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAnd16, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (And16 (Const16 <t> [c]) (And16 (Const16 <t> [d]) x)) |
| // cond: |
| // result: (And16 (Const16 <t> [int64(int16(c&d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd16 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst16 { |
| break |
| } |
| if v_1_0.Type != t { |
| break |
| } |
| d := v_1_0.AuxInt |
| v.reset(OpAnd16) |
| v0 := b.NewValue0(v.Pos, OpConst16, t) |
| v0.AuxInt = int64(int16(c & d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAnd16_20(v *Value) bool { |
| b := v.Block |
| // match: (And16 (Const16 <t> [c]) (And16 x (Const16 <t> [d]))) |
| // cond: |
| // result: (And16 (Const16 <t> [int64(int16(c&d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst16 { |
| break |
| } |
| if v_1_1.Type != t { |
| break |
| } |
| d := v_1_1.AuxInt |
| v.reset(OpAnd16) |
| v0 := b.NewValue0(v.Pos, OpConst16, t) |
| v0.AuxInt = int64(int16(c & d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (And16 (And16 (Const16 <t> [d]) x) (Const16 <t> [c])) |
| // cond: |
| // result: (And16 (Const16 <t> [int64(int16(c&d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd16 { |
| break |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst16 { |
| break |
| } |
| t := v_0_0.Type |
| d := v_0_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAnd16) |
| v0 := b.NewValue0(v.Pos, OpConst16, t) |
| v0.AuxInt = int64(int16(c & d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (And16 (And16 x (Const16 <t> [d])) (Const16 <t> [c])) |
| // cond: |
| // result: (And16 (Const16 <t> [int64(int16(c&d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd16 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst16 { |
| break |
| } |
| t := v_0_1.Type |
| d := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAnd16) |
| v0 := b.NewValue0(v.Pos, OpConst16, t) |
| v0.AuxInt = int64(int16(c & d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAnd32_0(v *Value) bool { |
| // match: (And32 (Const32 [c]) (Const32 [d])) |
| // cond: |
| // result: (Const32 [int64(int32(c&d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| d := v_1.AuxInt |
| v.reset(OpConst32) |
| v.AuxInt = int64(int32(c & d)) |
| return true |
| } |
| // match: (And32 (Const32 [d]) (Const32 [c])) |
| // cond: |
| // result: (Const32 [int64(int32(c&d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| d := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpConst32) |
| v.AuxInt = int64(int32(c & d)) |
| return true |
| } |
| // match: (And32 (Const32 [m]) (Rsh32Ux64 _ (Const64 [c]))) |
| // cond: c >= 64-ntz(m) |
| // result: (Const32 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| m := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(c >= 64-ntz(m)) { |
| break |
| } |
| v.reset(OpConst32) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And32 (Rsh32Ux64 _ (Const64 [c])) (Const32 [m])) |
| // cond: c >= 64-ntz(m) |
| // result: (Const32 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| c := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| m := v_1.AuxInt |
| if !(c >= 64-ntz(m)) { |
| break |
| } |
| v.reset(OpConst32) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And32 (Const32 [m]) (Lsh32x64 _ (Const64 [c]))) |
| // cond: c >= 64-nlz(m) |
| // result: (Const32 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| m := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpLsh32x64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(c >= 64-nlz(m)) { |
| break |
| } |
| v.reset(OpConst32) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And32 (Lsh32x64 _ (Const64 [c])) (Const32 [m])) |
| // cond: c >= 64-nlz(m) |
| // result: (Const32 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpLsh32x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| c := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| m := v_1.AuxInt |
| if !(c >= 64-nlz(m)) { |
| break |
| } |
| v.reset(OpConst32) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And32 x x) |
| // cond: |
| // result: x |
| for { |
| x := v.Args[1] |
| if x != v.Args[0] { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (And32 (Const32 [-1]) x) |
| // cond: |
| // result: x |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| if v_0.AuxInt != -1 { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (And32 x (Const32 [-1])) |
| // cond: |
| // result: x |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| if v_1.AuxInt != -1 { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (And32 (Const32 [0]) _) |
| // cond: |
| // result: (Const32 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| if v_0.AuxInt != 0 { |
| break |
| } |
| v.reset(OpConst32) |
| v.AuxInt = 0 |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAnd32_10(v *Value) bool { |
| b := v.Block |
| // match: (And32 _ (Const32 [0])) |
| // cond: |
| // result: (Const32 [0]) |
| for { |
| _ = v.Args[1] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| if v_1.AuxInt != 0 { |
| break |
| } |
| v.reset(OpConst32) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And32 x (And32 x y)) |
| // cond: |
| // result: (And32 x y) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd32 { |
| break |
| } |
| y := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpAnd32) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (And32 x (And32 y x)) |
| // cond: |
| // result: (And32 x y) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpAnd32) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (And32 (And32 x y) x) |
| // cond: |
| // result: (And32 x y) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd32 { |
| break |
| } |
| y := v_0.Args[1] |
| if x != v_0.Args[0] { |
| break |
| } |
| v.reset(OpAnd32) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (And32 (And32 y x) x) |
| // cond: |
| // result: (And32 x y) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| y := v_0.Args[0] |
| if x != v_0.Args[1] { |
| break |
| } |
| v.reset(OpAnd32) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (And32 (And32 i:(Const32 <t>) z) x) |
| // cond: (z.Op != OpConst32 && x.Op != OpConst32) |
| // result: (And32 i (And32 <t> z x)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd32 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst32 && x.Op != OpConst32) { |
| break |
| } |
| v.reset(OpAnd32) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAnd32, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (And32 (And32 z i:(Const32 <t>)) x) |
| // cond: (z.Op != OpConst32 && x.Op != OpConst32) |
| // result: (And32 i (And32 <t> z x)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| z := v_0.Args[0] |
| i := v_0.Args[1] |
| if i.Op != OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst32 && x.Op != OpConst32) { |
| break |
| } |
| v.reset(OpAnd32) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAnd32, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (And32 x (And32 i:(Const32 <t>) z)) |
| // cond: (z.Op != OpConst32 && x.Op != OpConst32) |
| // result: (And32 i (And32 <t> z x)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd32 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst32 && x.Op != OpConst32) { |
| break |
| } |
| v.reset(OpAnd32) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAnd32, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (And32 x (And32 z i:(Const32 <t>))) |
| // cond: (z.Op != OpConst32 && x.Op != OpConst32) |
| // result: (And32 i (And32 <t> z x)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| i := v_1.Args[1] |
| if i.Op != OpConst32 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst32 && x.Op != OpConst32) { |
| break |
| } |
| v.reset(OpAnd32) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAnd32, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (And32 (Const32 <t> [c]) (And32 (Const32 <t> [d]) x)) |
| // cond: |
| // result: (And32 (Const32 <t> [int64(int32(c&d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd32 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| if v_1_0.Type != t { |
| break |
| } |
| d := v_1_0.AuxInt |
| v.reset(OpAnd32) |
| v0 := b.NewValue0(v.Pos, OpConst32, t) |
| v0.AuxInt = int64(int32(c & d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAnd32_20(v *Value) bool { |
| b := v.Block |
| // match: (And32 (Const32 <t> [c]) (And32 x (Const32 <t> [d]))) |
| // cond: |
| // result: (And32 (Const32 <t> [int64(int32(c&d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| if v_1_1.Type != t { |
| break |
| } |
| d := v_1_1.AuxInt |
| v.reset(OpAnd32) |
| v0 := b.NewValue0(v.Pos, OpConst32, t) |
| v0.AuxInt = int64(int32(c & d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (And32 (And32 (Const32 <t> [d]) x) (Const32 <t> [c])) |
| // cond: |
| // result: (And32 (Const32 <t> [int64(int32(c&d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd32 { |
| break |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| t := v_0_0.Type |
| d := v_0_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAnd32) |
| v0 := b.NewValue0(v.Pos, OpConst32, t) |
| v0.AuxInt = int64(int32(c & d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (And32 (And32 x (Const32 <t> [d])) (Const32 <t> [c])) |
| // cond: |
| // result: (And32 (Const32 <t> [int64(int32(c&d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| t := v_0_1.Type |
| d := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAnd32) |
| v0 := b.NewValue0(v.Pos, OpConst32, t) |
| v0.AuxInt = int64(int32(c & d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAnd64_0(v *Value) bool { |
| // match: (And64 (Const64 [c]) (Const64 [d])) |
| // cond: |
| // result: (Const64 [c&d]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| d := v_1.AuxInt |
| v.reset(OpConst64) |
| v.AuxInt = c & d |
| return true |
| } |
| // match: (And64 (Const64 [d]) (Const64 [c])) |
| // cond: |
| // result: (Const64 [c&d]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| d := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpConst64) |
| v.AuxInt = c & d |
| return true |
| } |
| // match: (And64 (Const64 [m]) (Rsh64Ux64 _ (Const64 [c]))) |
| // cond: c >= 64-ntz(m) |
| // result: (Const64 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| m := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(c >= 64-ntz(m)) { |
| break |
| } |
| v.reset(OpConst64) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And64 (Rsh64Ux64 _ (Const64 [c])) (Const64 [m])) |
| // cond: c >= 64-ntz(m) |
| // result: (Const64 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| c := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| m := v_1.AuxInt |
| if !(c >= 64-ntz(m)) { |
| break |
| } |
| v.reset(OpConst64) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And64 (Const64 [m]) (Lsh64x64 _ (Const64 [c]))) |
| // cond: c >= 64-nlz(m) |
| // result: (Const64 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| m := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpLsh64x64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(c >= 64-nlz(m)) { |
| break |
| } |
| v.reset(OpConst64) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And64 (Lsh64x64 _ (Const64 [c])) (Const64 [m])) |
| // cond: c >= 64-nlz(m) |
| // result: (Const64 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpLsh64x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| c := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| m := v_1.AuxInt |
| if !(c >= 64-nlz(m)) { |
| break |
| } |
| v.reset(OpConst64) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And64 x x) |
| // cond: |
| // result: x |
| for { |
| x := v.Args[1] |
| if x != v.Args[0] { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (And64 (Const64 [-1]) x) |
| // cond: |
| // result: x |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| if v_0.AuxInt != -1 { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (And64 x (Const64 [-1])) |
| // cond: |
| // result: x |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| if v_1.AuxInt != -1 { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (And64 (Const64 [0]) _) |
| // cond: |
| // result: (Const64 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| if v_0.AuxInt != 0 { |
| break |
| } |
| v.reset(OpConst64) |
| v.AuxInt = 0 |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAnd64_10(v *Value) bool { |
| b := v.Block |
| // match: (And64 _ (Const64 [0])) |
| // cond: |
| // result: (Const64 [0]) |
| for { |
| _ = v.Args[1] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| if v_1.AuxInt != 0 { |
| break |
| } |
| v.reset(OpConst64) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And64 x (And64 x y)) |
| // cond: |
| // result: (And64 x y) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd64 { |
| break |
| } |
| y := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpAnd64) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (And64 x (And64 y x)) |
| // cond: |
| // result: (And64 x y) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpAnd64) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (And64 (And64 x y) x) |
| // cond: |
| // result: (And64 x y) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd64 { |
| break |
| } |
| y := v_0.Args[1] |
| if x != v_0.Args[0] { |
| break |
| } |
| v.reset(OpAnd64) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (And64 (And64 y x) x) |
| // cond: |
| // result: (And64 x y) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| y := v_0.Args[0] |
| if x != v_0.Args[1] { |
| break |
| } |
| v.reset(OpAnd64) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (And64 <t> (Const64 [y]) x) |
| // cond: nlz(y) + nto(y) == 64 && nto(y) >= 32 |
| // result: (Rsh64Ux64 (Lsh64x64 <t> x (Const64 <t> [nlz(y)])) (Const64 <t> [nlz(y)])) |
| for { |
| t := v.Type |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| y := v_0.AuxInt |
| if !(nlz(y)+nto(y) == 64 && nto(y) >= 32) { |
| break |
| } |
| v.reset(OpRsh64Ux64) |
| v0 := b.NewValue0(v.Pos, OpLsh64x64, t) |
| v0.AddArg(x) |
| v1 := b.NewValue0(v.Pos, OpConst64, t) |
| v1.AuxInt = nlz(y) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst64, t) |
| v2.AuxInt = nlz(y) |
| v.AddArg(v2) |
| return true |
| } |
| // match: (And64 <t> x (Const64 [y])) |
| // cond: nlz(y) + nto(y) == 64 && nto(y) >= 32 |
| // result: (Rsh64Ux64 (Lsh64x64 <t> x (Const64 <t> [nlz(y)])) (Const64 <t> [nlz(y)])) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| y := v_1.AuxInt |
| if !(nlz(y)+nto(y) == 64 && nto(y) >= 32) { |
| break |
| } |
| v.reset(OpRsh64Ux64) |
| v0 := b.NewValue0(v.Pos, OpLsh64x64, t) |
| v0.AddArg(x) |
| v1 := b.NewValue0(v.Pos, OpConst64, t) |
| v1.AuxInt = nlz(y) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst64, t) |
| v2.AuxInt = nlz(y) |
| v.AddArg(v2) |
| return true |
| } |
| // match: (And64 <t> (Const64 [y]) x) |
| // cond: nlo(y) + ntz(y) == 64 && ntz(y) >= 32 |
| // result: (Lsh64x64 (Rsh64Ux64 <t> x (Const64 <t> [ntz(y)])) (Const64 <t> [ntz(y)])) |
| for { |
| t := v.Type |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| y := v_0.AuxInt |
| if !(nlo(y)+ntz(y) == 64 && ntz(y) >= 32) { |
| break |
| } |
| v.reset(OpLsh64x64) |
| v0 := b.NewValue0(v.Pos, OpRsh64Ux64, t) |
| v0.AddArg(x) |
| v1 := b.NewValue0(v.Pos, OpConst64, t) |
| v1.AuxInt = ntz(y) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst64, t) |
| v2.AuxInt = ntz(y) |
| v.AddArg(v2) |
| return true |
| } |
| // match: (And64 <t> x (Const64 [y])) |
| // cond: nlo(y) + ntz(y) == 64 && ntz(y) >= 32 |
| // result: (Lsh64x64 (Rsh64Ux64 <t> x (Const64 <t> [ntz(y)])) (Const64 <t> [ntz(y)])) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| y := v_1.AuxInt |
| if !(nlo(y)+ntz(y) == 64 && ntz(y) >= 32) { |
| break |
| } |
| v.reset(OpLsh64x64) |
| v0 := b.NewValue0(v.Pos, OpRsh64Ux64, t) |
| v0.AddArg(x) |
| v1 := b.NewValue0(v.Pos, OpConst64, t) |
| v1.AuxInt = ntz(y) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst64, t) |
| v2.AuxInt = ntz(y) |
| v.AddArg(v2) |
| return true |
| } |
| // match: (And64 (And64 i:(Const64 <t>) z) x) |
| // cond: (z.Op != OpConst64 && x.Op != OpConst64) |
| // result: (And64 i (And64 <t> z x)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd64 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst64 && x.Op != OpConst64) { |
| break |
| } |
| v.reset(OpAnd64) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAnd64, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAnd64_20(v *Value) bool { |
| b := v.Block |
| // match: (And64 (And64 z i:(Const64 <t>)) x) |
| // cond: (z.Op != OpConst64 && x.Op != OpConst64) |
| // result: (And64 i (And64 <t> z x)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| z := v_0.Args[0] |
| i := v_0.Args[1] |
| if i.Op != OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst64 && x.Op != OpConst64) { |
| break |
| } |
| v.reset(OpAnd64) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAnd64, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (And64 x (And64 i:(Const64 <t>) z)) |
| // cond: (z.Op != OpConst64 && x.Op != OpConst64) |
| // result: (And64 i (And64 <t> z x)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd64 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst64 && x.Op != OpConst64) { |
| break |
| } |
| v.reset(OpAnd64) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAnd64, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (And64 x (And64 z i:(Const64 <t>))) |
| // cond: (z.Op != OpConst64 && x.Op != OpConst64) |
| // result: (And64 i (And64 <t> z x)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| i := v_1.Args[1] |
| if i.Op != OpConst64 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst64 && x.Op != OpConst64) { |
| break |
| } |
| v.reset(OpAnd64) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAnd64, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (And64 (Const64 <t> [c]) (And64 (Const64 <t> [d]) x)) |
| // cond: |
| // result: (And64 (Const64 <t> [c&d]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd64 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst64 { |
| break |
| } |
| if v_1_0.Type != t { |
| break |
| } |
| d := v_1_0.AuxInt |
| v.reset(OpAnd64) |
| v0 := b.NewValue0(v.Pos, OpConst64, t) |
| v0.AuxInt = c & d |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (And64 (Const64 <t> [c]) (And64 x (Const64 <t> [d]))) |
| // cond: |
| // result: (And64 (Const64 <t> [c&d]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1.Type != t { |
| break |
| } |
| d := v_1_1.AuxInt |
| v.reset(OpAnd64) |
| v0 := b.NewValue0(v.Pos, OpConst64, t) |
| v0.AuxInt = c & d |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (And64 (And64 (Const64 <t> [d]) x) (Const64 <t> [c])) |
| // cond: |
| // result: (And64 (Const64 <t> [c&d]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd64 { |
| break |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst64 { |
| break |
| } |
| t := v_0_0.Type |
| d := v_0_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAnd64) |
| v0 := b.NewValue0(v.Pos, OpConst64, t) |
| v0.AuxInt = c & d |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (And64 (And64 x (Const64 <t> [d])) (Const64 <t> [c])) |
| // cond: |
| // result: (And64 (Const64 <t> [c&d]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| t := v_0_1.Type |
| d := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAnd64) |
| v0 := b.NewValue0(v.Pos, OpConst64, t) |
| v0.AuxInt = c & d |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAnd8_0(v *Value) bool { |
| // match: (And8 (Const8 [c]) (Const8 [d])) |
| // cond: |
| // result: (Const8 [int64(int8(c&d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| d := v_1.AuxInt |
| v.reset(OpConst8) |
| v.AuxInt = int64(int8(c & d)) |
| return true |
| } |
| // match: (And8 (Const8 [d]) (Const8 [c])) |
| // cond: |
| // result: (Const8 [int64(int8(c&d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| d := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpConst8) |
| v.AuxInt = int64(int8(c & d)) |
| return true |
| } |
| // match: (And8 (Const8 [m]) (Rsh8Ux64 _ (Const64 [c]))) |
| // cond: c >= 64-ntz(m) |
| // result: (Const8 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| m := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpRsh8Ux64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(c >= 64-ntz(m)) { |
| break |
| } |
| v.reset(OpConst8) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And8 (Rsh8Ux64 _ (Const64 [c])) (Const8 [m])) |
| // cond: c >= 64-ntz(m) |
| // result: (Const8 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpRsh8Ux64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| c := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| m := v_1.AuxInt |
| if !(c >= 64-ntz(m)) { |
| break |
| } |
| v.reset(OpConst8) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And8 (Const8 [m]) (Lsh8x64 _ (Const64 [c]))) |
| // cond: c >= 64-nlz(m) |
| // result: (Const8 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| m := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpLsh8x64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(c >= 64-nlz(m)) { |
| break |
| } |
| v.reset(OpConst8) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And8 (Lsh8x64 _ (Const64 [c])) (Const8 [m])) |
| // cond: c >= 64-nlz(m) |
| // result: (Const8 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpLsh8x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| c := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| m := v_1.AuxInt |
| if !(c >= 64-nlz(m)) { |
| break |
| } |
| v.reset(OpConst8) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And8 x x) |
| // cond: |
| // result: x |
| for { |
| x := v.Args[1] |
| if x != v.Args[0] { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (And8 (Const8 [-1]) x) |
| // cond: |
| // result: x |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| if v_0.AuxInt != -1 { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (And8 x (Const8 [-1])) |
| // cond: |
| // result: x |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| if v_1.AuxInt != -1 { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (And8 (Const8 [0]) _) |
| // cond: |
| // result: (Const8 [0]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| if v_0.AuxInt != 0 { |
| break |
| } |
| v.reset(OpConst8) |
| v.AuxInt = 0 |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAnd8_10(v *Value) bool { |
| b := v.Block |
| // match: (And8 _ (Const8 [0])) |
| // cond: |
| // result: (Const8 [0]) |
| for { |
| _ = v.Args[1] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| if v_1.AuxInt != 0 { |
| break |
| } |
| v.reset(OpConst8) |
| v.AuxInt = 0 |
| return true |
| } |
| // match: (And8 x (And8 x y)) |
| // cond: |
| // result: (And8 x y) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd8 { |
| break |
| } |
| y := v_1.Args[1] |
| if x != v_1.Args[0] { |
| break |
| } |
| v.reset(OpAnd8) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (And8 x (And8 y x)) |
| // cond: |
| // result: (And8 x y) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| y := v_1.Args[0] |
| if x != v_1.Args[1] { |
| break |
| } |
| v.reset(OpAnd8) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (And8 (And8 x y) x) |
| // cond: |
| // result: (And8 x y) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd8 { |
| break |
| } |
| y := v_0.Args[1] |
| if x != v_0.Args[0] { |
| break |
| } |
| v.reset(OpAnd8) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (And8 (And8 y x) x) |
| // cond: |
| // result: (And8 x y) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd8 { |
| break |
| } |
| _ = v_0.Args[1] |
| y := v_0.Args[0] |
| if x != v_0.Args[1] { |
| break |
| } |
| v.reset(OpAnd8) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (And8 (And8 i:(Const8 <t>) z) x) |
| // cond: (z.Op != OpConst8 && x.Op != OpConst8) |
| // result: (And8 i (And8 <t> z x)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd8 { |
| break |
| } |
| z := v_0.Args[1] |
| i := v_0.Args[0] |
| if i.Op != OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst8 && x.Op != OpConst8) { |
| break |
| } |
| v.reset(OpAnd8) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAnd8, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (And8 (And8 z i:(Const8 <t>)) x) |
| // cond: (z.Op != OpConst8 && x.Op != OpConst8) |
| // result: (And8 i (And8 <t> z x)) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd8 { |
| break |
| } |
| _ = v_0.Args[1] |
| z := v_0.Args[0] |
| i := v_0.Args[1] |
| if i.Op != OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst8 && x.Op != OpConst8) { |
| break |
| } |
| v.reset(OpAnd8) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAnd8, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (And8 x (And8 i:(Const8 <t>) z)) |
| // cond: (z.Op != OpConst8 && x.Op != OpConst8) |
| // result: (And8 i (And8 <t> z x)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd8 { |
| break |
| } |
| z := v_1.Args[1] |
| i := v_1.Args[0] |
| if i.Op != OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst8 && x.Op != OpConst8) { |
| break |
| } |
| v.reset(OpAnd8) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAnd8, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (And8 x (And8 z i:(Const8 <t>))) |
| // cond: (z.Op != OpConst8 && x.Op != OpConst8) |
| // result: (And8 i (And8 <t> z x)) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| z := v_1.Args[0] |
| i := v_1.Args[1] |
| if i.Op != OpConst8 { |
| break |
| } |
| t := i.Type |
| if !(z.Op != OpConst8 && x.Op != OpConst8) { |
| break |
| } |
| v.reset(OpAnd8) |
| v.AddArg(i) |
| v0 := b.NewValue0(v.Pos, OpAnd8, t) |
| v0.AddArg(z) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (And8 (Const8 <t> [c]) (And8 (Const8 <t> [d]) x)) |
| // cond: |
| // result: (And8 (Const8 <t> [int64(int8(c&d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd8 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst8 { |
| break |
| } |
| if v_1_0.Type != t { |
| break |
| } |
| d := v_1_0.AuxInt |
| v.reset(OpAnd8) |
| v0 := b.NewValue0(v.Pos, OpConst8, t) |
| v0.AuxInt = int64(int8(c & d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpAnd8_20(v *Value) bool { |
| b := v.Block |
| // match: (And8 (Const8 <t> [c]) (And8 x (Const8 <t> [d]))) |
| // cond: |
| // result: (And8 (Const8 <t> [int64(int8(c&d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAnd8 { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst8 { |
| break |
| } |
| if v_1_1.Type != t { |
| break |
| } |
| d := v_1_1.AuxInt |
| v.reset(OpAnd8) |
| v0 := b.NewValue0(v.Pos, OpConst8, t) |
| v0.AuxInt = int64(int8(c & d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (And8 (And8 (Const8 <t> [d]) x) (Const8 <t> [c])) |
| // cond: |
| // result: (And8 (Const8 <t> [int64(int8(c&d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd8 { |
| break |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst8 { |
| break |
| } |
| t := v_0_0.Type |
| d := v_0_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAnd8) |
| v0 := b.NewValue0(v.Pos, OpConst8, t) |
| v0.AuxInt = int64(int8(c & d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (And8 (And8 x (Const8 <t> [d])) (Const8 <t> [c])) |
| // cond: |
| // result: (And8 (Const8 <t> [int64(int8(c&d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAnd8 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst8 { |
| break |
| } |
| t := v_0_1.Type |
| d := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpAnd8) |
| v0 := b.NewValue0(v.Pos, OpConst8, t) |
| v0.AuxInt = int64(int8(c & d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpArraySelect_0(v *Value) bool { |
| // match: (ArraySelect (ArrayMake1 x)) |
| // cond: |
| // result: x |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpArrayMake1 { |
| break |
| } |
| x := v_0.Args[0] |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (ArraySelect [0] x:(IData _)) |
| // cond: |
| // result: x |
| for { |
| if v.AuxInt != 0 { |
| break |
| } |
| x := v.Args[0] |
| if x.Op != OpIData { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpCom16_0(v *Value) bool { |
| // match: (Com16 (Com16 x)) |
| // cond: |
| // result: x |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpCom16 { |
| break |
| } |
| x := v_0.Args[0] |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (Com16 (Const16 [c])) |
| // cond: |
| // result: (Const16 [^c]) |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| c := v_0.AuxInt |
| v.reset(OpConst16) |
| v.AuxInt = ^c |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpCom32_0(v *Value) bool { |
| // match: (Com32 (Com32 x)) |
| // cond: |
| // result: x |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpCom32 { |
| break |
| } |
| x := v_0.Args[0] |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (Com32 (Const32 [c])) |
| // cond: |
| // result: (Const32 [^c]) |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| c := v_0.AuxInt |
| v.reset(OpConst32) |
| v.AuxInt = ^c |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpCom64_0(v *Value) bool { |
| // match: (Com64 (Com64 x)) |
| // cond: |
| // result: x |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpCom64 { |
| break |
| } |
| x := v_0.Args[0] |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (Com64 (Const64 [c])) |
| // cond: |
| // result: (Const64 [^c]) |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| c := v_0.AuxInt |
| v.reset(OpConst64) |
| v.AuxInt = ^c |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpCom8_0(v *Value) bool { |
| // match: (Com8 (Com8 x)) |
| // cond: |
| // result: x |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpCom8 { |
| break |
| } |
| x := v_0.Args[0] |
| v.reset(OpCopy) |
| v.Type = x.Type |
| v.AddArg(x) |
| return true |
| } |
| // match: (Com8 (Const8 [c])) |
| // cond: |
| // result: (Const8 [^c]) |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| c := v_0.AuxInt |
| v.reset(OpConst8) |
| v.AuxInt = ^c |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpConstInterface_0(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (ConstInterface) |
| // cond: |
| // result: (IMake (ConstNil <typ.Uintptr>) (ConstNil <typ.BytePtr>)) |
| for { |
| v.reset(OpIMake) |
| v0 := b.NewValue0(v.Pos, OpConstNil, typ.Uintptr) |
| v.AddArg(v0) |
| v1 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr) |
| v.AddArg(v1) |
| return true |
| } |
| } |
| func rewriteValuegeneric_OpConstSlice_0(v *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(OpSliceMake) |
| v0 := b.NewValue0(v.Pos, OpConstNil, v.Type.Elem().PtrTo()) |
| v.AddArg(v0) |
| v1 := b.NewValue0(v.Pos, OpConst32, typ.Int) |
| v1.AuxInt = 0 |
| v.AddArg(v1) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.Int) |
| v2.AuxInt = 0 |
| v.AddArg(v2) |
| 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(OpSliceMake) |
| v0 := b.NewValue0(v.Pos, OpConstNil, v.Type.Elem().PtrTo()) |
| v.AddArg(v0) |
| v1 := b.NewValue0(v.Pos, OpConst64, typ.Int) |
| v1.AuxInt = 0 |
| v.AddArg(v1) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.Int) |
| v2.AuxInt = 0 |
| v.AddArg(v2) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpConstString_0(v *Value) bool { |
| b := v.Block |
| config := b.Func.Config |
| fe := b.Func.fe |
| typ := &b.Func.Config.Types |
| // match: (ConstString {s}) |
| // cond: config.PtrSize == 4 && s.(string) == "" |
| // result: (StringMake (ConstNil) (Const32 <typ.Int> [0])) |
| for { |
| s := v.Aux |
| if !(config.PtrSize == 4 && s.(string) == "") { |
| break |
| } |
| v.reset(OpStringMake) |
| v0 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr) |
| v.AddArg(v0) |
| v1 := b.NewValue0(v.Pos, OpConst32, typ.Int) |
| v1.AuxInt = 0 |
| v.AddArg(v1) |
| return true |
| } |
| // match: (ConstString {s}) |
| // cond: config.PtrSize == 8 && s.(string) == "" |
| // result: (StringMake (ConstNil) (Const64 <typ.Int> [0])) |
| for { |
| s := v.Aux |
| if !(config.PtrSize == 8 && s.(string) == "") { |
| break |
| } |
| v.reset(OpStringMake) |
| v0 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr) |
| v.AddArg(v0) |
| v1 := b.NewValue0(v.Pos, OpConst64, typ.Int) |
| v1.AuxInt = 0 |
| v.AddArg(v1) |
| return true |
| } |
| // match: (ConstString {s}) |
| // cond: config.PtrSize == 4 && s.(string) != "" |
| // result: (StringMake (Addr <typ.BytePtr> {fe.StringData(s.(string))} (SB)) (Const32 <typ.Int> [int64(len(s.(string)))])) |
| for { |
| s := v.Aux |
| if !(config.PtrSize == 4 && s.(string) != "") { |
| break |
| } |
| v.reset(OpStringMake) |
| v0 := b.NewValue0(v.Pos, OpAddr, typ.BytePtr) |
| v0.Aux = fe.StringData(s.(string)) |
| v1 := b.NewValue0(v.Pos, OpSB, typ.Uintptr) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.Int) |
| v2.AuxInt = int64(len(s.(string))) |
| v.AddArg(v2) |
| return true |
| } |
| // match: (ConstString {s}) |
| // cond: config.PtrSize == 8 && s.(string) != "" |
| // result: (StringMake (Addr <typ.BytePtr> {fe.StringData(s.(string))} (SB)) (Const64 <typ.Int> [int64(len(s.(string)))])) |
| for { |
| s := v.Aux |
| if !(config.PtrSize == 8 && s.(string) != "") { |
| break |
| } |
| v.reset(OpStringMake) |
| v0 := b.NewValue0(v.Pos, OpAddr, typ.BytePtr) |
| v0.Aux = fe.StringData(s.(string)) |
| v1 := b.NewValue0(v.Pos, OpSB, typ.Uintptr) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.Int) |
| v2.AuxInt = int64(len(s.(string))) |
| v.AddArg(v2) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpConvert_0(v *Value) bool { |
| // match: (Convert (Add64 (Convert ptr mem) off) mem) |
| // cond: |
| // result: (Add64 ptr off) |
| for { |
| mem := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd64 { |
| break |
| } |
| off := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConvert { |
| break |
| } |
| _ = v_0_0.Args[1] |
| ptr := v_0_0.Args[0] |
| if mem != v_0_0.Args[1] { |
| break |
| } |
| v.reset(OpAdd64) |
| v.AddArg(ptr) |
| v.AddArg(off) |
| return true |
| } |
| // match: (Convert (Add64 off (Convert ptr mem)) mem) |
| // cond: |
| // result: (Add64 ptr off) |
| for { |
| mem := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| off := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConvert { |
| break |
| } |
| _ = v_0_1.Args[1] |
| ptr := v_0_1.Args[0] |
| if mem != v_0_1.Args[1] { |
| break |
| } |
| v.reset(OpAdd64) |
| v.AddArg(ptr) |
| v.AddArg(off) |
| return true |
| } |
| // match: (Convert (Add32 (Convert ptr mem) off) mem) |
| // cond: |
| // result: (Add32 ptr off) |
| for { |
| mem := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd32 { |
| break |
| } |
| off := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConvert { |
| break |
| } |
| _ = v_0_0.Args[1] |
| ptr := v_0_0.Args[0] |
| if mem != v_0_0.Args[1] { |
| break |
| } |
| v.reset(OpAdd32) |
| v.AddArg(ptr) |
| v.AddArg(off) |
| return true |
| } |
| // match: (Convert (Add32 off (Convert ptr mem)) mem) |
| // cond: |
| // result: (Add32 ptr off) |
| for { |
| mem := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| off := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConvert { |
| break |
| } |
| _ = v_0_1.Args[1] |
| ptr := v_0_1.Args[0] |
| if mem != v_0_1.Args[1] { |
| break |
| } |
| v.reset(OpAdd32) |
| v.AddArg(ptr) |
| v.AddArg(off) |
| return true |
| } |
| // match: (Convert (Convert ptr mem) mem) |
| // cond: |
| // result: ptr |
| for { |
| mem := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConvert { |
| break |
| } |
| _ = v_0.Args[1] |
| ptr := v_0.Args[0] |
| if mem != v_0.Args[1] { |
| break |
| } |
| v.reset(OpCopy) |
| v.Type = ptr.Type |
| v.AddArg(ptr) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpCvt32Fto32_0(v *Value) bool { |
| // match: (Cvt32Fto32 (Const32F [c])) |
| // cond: |
| // result: (Const32 [int64(int32(auxTo32F(c)))]) |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32F { |
| break |
| } |
| c := v_0.AuxInt |
| v.reset(OpConst32) |
| v.AuxInt = int64(int32(auxTo32F(c))) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpCvt32Fto64_0(v *Value) bool { |
| // match: (Cvt32Fto64 (Const32F [c])) |
| // cond: |
| // result: (Const64 [int64(auxTo32F(c))]) |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32F { |
| break |
| } |
| c := v_0.AuxInt |
| v.reset(OpConst64) |
| v.AuxInt = int64(auxTo32F(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpCvt32Fto64F_0(v *Value) bool { |
| // match: (Cvt32Fto64F (Const32F [c])) |
| // cond: |
| // result: (Const64F [c]) |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32F { |
| break |
| } |
| c := v_0.AuxInt |
| v.reset(OpConst64F) |
| v.AuxInt = c |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpCvt32to32F_0(v *Value) bool { |
| // match: (Cvt32to32F (Const32 [c])) |
| // cond: |
| // result: (Const32F [auxFrom32F(float32(int32(c)))]) |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| c := v_0.AuxInt |
| v.reset(OpConst32F) |
| v.AuxInt = auxFrom32F(float32(int32(c))) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpCvt32to64F_0(v *Value) bool { |
| // match: (Cvt32to64F (Const32 [c])) |
| // cond: |
| // result: (Const64F [auxFrom64F(float64(int32(c)))]) |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| c := v_0.AuxInt |
| v.reset(OpConst64F) |
| v.AuxInt = auxFrom64F(float64(int32(c))) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpCvt64Fto32_0(v *Value) bool { |
| // match: (Cvt64Fto32 (Const64F [c])) |
| // cond: |
| // result: (Const32 [int64(int32(auxTo64F(c)))]) |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64F { |
| break |
| } |
| c := v_0.AuxInt |
| v.reset(OpConst32) |
| v.AuxInt = int64(int32(auxTo64F(c))) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpCvt64Fto32F_0(v *Value) bool { |
| // match: (Cvt64Fto32F (Const64F [c])) |
| // cond: |
| // result: (Const32F [auxFrom32F(float32(auxTo64F(c)))]) |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64F { |
| break |
| } |
| c := v_0.AuxInt |
| v.reset(OpConst32F) |
| v.AuxInt = auxFrom32F(float32(auxTo64F(c))) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpCvt64Fto64_0(v *Value) bool { |
| // match: (Cvt64Fto64 (Const64F [c])) |
| // cond: |
| // result: (Const64 [int64(auxTo64F(c))]) |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64F { |
| break |
| } |
| c := v_0.AuxInt |
| v.reset(OpConst64) |
| v.AuxInt = int64(auxTo64F(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpCvt64to32F_0(v *Value) bool { |
| // match: (Cvt64to32F (Const64 [c])) |
| // cond: |
| // result: (Const32F [auxFrom32F(float32(c))]) |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| c := v_0.AuxInt |
| v.reset(OpConst32F) |
| v.AuxInt = auxFrom32F(float32(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpCvt64to64F_0(v *Value) bool { |
| // match: (Cvt64to64F (Const64 [c])) |
| // cond: |
| // result: (Const64F [auxFrom64F(float64(c))]) |
| for { |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| c := v_0.AuxInt |
| v.reset(OpConst64F) |
| v.AuxInt = auxFrom64F(float64(c)) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpDiv16_0(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Div16 (Const16 [c]) (Const16 [d])) |
| // cond: d != 0 |
| // result: (Const16 [int64(int16(c)/int16(d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| d := v_1.AuxInt |
| if !(d != 0) { |
| break |
| } |
| v.reset(OpConst16) |
| v.AuxInt = int64(int16(c) / int16(d)) |
| return true |
| } |
| // match: (Div16 n (Const16 [c])) |
| // cond: isNonNegative(n) && isPowerOfTwo(c&0xffff) |
| // result: (Rsh16Ux64 n (Const64 <typ.UInt64> [log2(c&0xffff)])) |
| for { |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(isNonNegative(n) && isPowerOfTwo(c&0xffff)) { |
| break |
| } |
| v.reset(OpRsh16Ux64) |
| v.AddArg(n) |
| v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v0.AuxInt = log2(c & 0xffff) |
| v.AddArg(v0) |
| 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 |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(c < 0 && c != -1<<15) { |
| break |
| } |
| v.reset(OpNeg16) |
| v0 := b.NewValue0(v.Pos, OpDiv16, t) |
| v0.AddArg(n) |
| v1 := b.NewValue0(v.Pos, OpConst16, t) |
| v1.AuxInt = -c |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div16 <t> x (Const16 [-1<<15])) |
| // cond: |
| // result: (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <typ.UInt64> [15])) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| if v_1.AuxInt != -1<<15 { |
| break |
| } |
| v.reset(OpRsh16Ux64) |
| v0 := b.NewValue0(v.Pos, OpAnd16, t) |
| v0.AddArg(x) |
| v1 := b.NewValue0(v.Pos, OpNeg16, t) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = 15 |
| v.AddArg(v2) |
| return true |
| } |
| // match: (Div16 <t> n (Const16 [c])) |
| // cond: isPowerOfTwo(c) |
| // result: (Rsh16x64 (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <typ.UInt64> [15])) (Const64 <typ.UInt64> [16-log2(c)]))) (Const64 <typ.UInt64> [log2(c)])) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(isPowerOfTwo(c)) { |
| break |
| } |
| v.reset(OpRsh16x64) |
| v0 := b.NewValue0(v.Pos, OpAdd16, t) |
| v0.AddArg(n) |
| v1 := b.NewValue0(v.Pos, OpRsh16Ux64, t) |
| v2 := b.NewValue0(v.Pos, OpRsh16x64, t) |
| v2.AddArg(n) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = 15 |
| v2.AddArg(v3) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = 16 - log2(c) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v5.AuxInt = log2(c) |
| v.AddArg(v5) |
| return true |
| } |
| // match: (Div16 <t> x (Const16 [c])) |
| // cond: smagicOK(16,c) |
| // result: (Sub16 <t> (Rsh32x64 <t> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(smagic(16,c).m)]) (SignExt16to32 x)) (Const64 <typ.UInt64> [16+smagic(16,c).s])) (Rsh32x64 <t> (SignExt16to32 x) (Const64 <typ.UInt64> [31]))) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(smagicOK(16, c)) { |
| break |
| } |
| v.reset(OpSub16) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, OpRsh32x64, t) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(smagic(16, c).m) |
| v1.AddArg(v2) |
| v3 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) |
| v3.AddArg(x) |
| v1.AddArg(v3) |
| v0.AddArg(v1) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = 16 + smagic(16, c).s |
| v0.AddArg(v4) |
| v.AddArg(v0) |
| v5 := b.NewValue0(v.Pos, OpRsh32x64, t) |
| v6 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) |
| v6.AddArg(x) |
| v5.AddArg(v6) |
| v7 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v7.AuxInt = 31 |
| v5.AddArg(v7) |
| v.AddArg(v5) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpDiv16u_0(v *Value) bool { |
| b := v.Block |
| config := b.Func.Config |
| typ := &b.Func.Config.Types |
| // match: (Div16u (Const16 [c]) (Const16 [d])) |
| // cond: d != 0 |
| // result: (Const16 [int64(int16(uint16(c)/uint16(d)))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| d := v_1.AuxInt |
| if !(d != 0) { |
| break |
| } |
| v.reset(OpConst16) |
| v.AuxInt = int64(int16(uint16(c) / uint16(d))) |
| return true |
| } |
| // match: (Div16u n (Const16 [c])) |
| // cond: isPowerOfTwo(c&0xffff) |
| // result: (Rsh16Ux64 n (Const64 <typ.UInt64> [log2(c&0xffff)])) |
| for { |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(isPowerOfTwo(c & 0xffff)) { |
| break |
| } |
| v.reset(OpRsh16Ux64) |
| v.AddArg(n) |
| v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v0.AuxInt = log2(c & 0xffff) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div16u x (Const16 [c])) |
| // cond: umagicOK(16, c) && config.RegSize == 8 |
| // result: (Trunc64to16 (Rsh64Ux64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<16+umagic(16,c).m)]) (ZeroExt16to64 x)) (Const64 <typ.UInt64> [16+umagic(16,c).s]))) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(umagicOK(16, c) && config.RegSize == 8) { |
| break |
| } |
| v.reset(OpTrunc64to16) |
| v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(1<<16 + umagic(16, c).m) |
| v1.AddArg(v2) |
| v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64) |
| v3.AddArg(x) |
| v1.AddArg(v3) |
| v0.AddArg(v1) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = 16 + umagic(16, c).s |
| v0.AddArg(v4) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div16u x (Const16 [c])) |
| // cond: umagicOK(16, c) && config.RegSize == 4 && umagic(16,c).m&1 == 0 |
| // result: (Trunc32to16 (Rsh32Ux64 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(1<<15+umagic(16,c).m/2)]) (ZeroExt16to32 x)) (Const64 <typ.UInt64> [16+umagic(16,c).s-1]))) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(umagicOK(16, c) && config.RegSize == 4 && umagic(16, c).m&1 == 0) { |
| break |
| } |
| v.reset(OpTrunc32to16) |
| v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(1<<15 + umagic(16, c).m/2) |
| v1.AddArg(v2) |
| v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) |
| v3.AddArg(x) |
| v1.AddArg(v3) |
| v0.AddArg(v1) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = 16 + umagic(16, c).s - 1 |
| v0.AddArg(v4) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div16u x (Const16 [c])) |
| // cond: umagicOK(16, c) && config.RegSize == 4 && c&1 == 0 |
| // result: (Trunc32to16 (Rsh32Ux64 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(1<<15+(umagic(16,c).m+1)/2)]) (Rsh32Ux64 <typ.UInt32> (ZeroExt16to32 x) (Const64 <typ.UInt64> [1]))) (Const64 <typ.UInt64> [16+umagic(16,c).s-2]))) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(umagicOK(16, c) && config.RegSize == 4 && c&1 == 0) { |
| break |
| } |
| v.reset(OpTrunc32to16) |
| v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(1<<15 + (umagic(16, c).m+1)/2) |
| v1.AddArg(v2) |
| v3 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) |
| v4 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) |
| v4.AddArg(x) |
| v3.AddArg(v4) |
| v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v5.AuxInt = 1 |
| v3.AddArg(v5) |
| v1.AddArg(v3) |
| v0.AddArg(v1) |
| v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v6.AuxInt = 16 + umagic(16, c).s - 2 |
| v0.AddArg(v6) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div16u x (Const16 [c])) |
| // cond: umagicOK(16, c) && config.RegSize == 4 && config.useAvg |
| // result: (Trunc32to16 (Rsh32Ux64 <typ.UInt32> (Avg32u (Lsh32x64 <typ.UInt32> (ZeroExt16to32 x) (Const64 <typ.UInt64> [16])) (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(umagic(16,c).m)]) (ZeroExt16to32 x))) (Const64 <typ.UInt64> [16+umagic(16,c).s-1]))) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(umagicOK(16, c) && config.RegSize == 4 && config.useAvg) { |
| break |
| } |
| v.reset(OpTrunc32to16) |
| v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAvg32u, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpLsh32x64, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) |
| v3.AddArg(x) |
| v2.AddArg(v3) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = 16 |
| v2.AddArg(v4) |
| v1.AddArg(v2) |
| v5 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(umagic(16, c).m) |
| v5.AddArg(v6) |
| v7 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) |
| v7.AddArg(x) |
| v5.AddArg(v7) |
| v1.AddArg(v5) |
| v0.AddArg(v1) |
| v8 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v8.AuxInt = 16 + umagic(16, c).s - 1 |
| v0.AddArg(v8) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpDiv32_0(v *Value) bool { |
| b := v.Block |
| config := b.Func.Config |
| typ := &b.Func.Config.Types |
| // match: (Div32 (Const32 [c]) (Const32 [d])) |
| // cond: d != 0 |
| // result: (Const32 [int64(int32(c)/int32(d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| d := v_1.AuxInt |
| if !(d != 0) { |
| break |
| } |
| v.reset(OpConst32) |
| v.AuxInt = int64(int32(c) / int32(d)) |
| return true |
| } |
| // match: (Div32 n (Const32 [c])) |
| // cond: isNonNegative(n) && isPowerOfTwo(c&0xffffffff) |
| // result: (Rsh32Ux64 n (Const64 <typ.UInt64> [log2(c&0xffffffff)])) |
| for { |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(isNonNegative(n) && isPowerOfTwo(c&0xffffffff)) { |
| break |
| } |
| v.reset(OpRsh32Ux64) |
| v.AddArg(n) |
| v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v0.AuxInt = log2(c & 0xffffffff) |
| v.AddArg(v0) |
| 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 |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(c < 0 && c != -1<<31) { |
| break |
| } |
| v.reset(OpNeg32) |
| v0 := b.NewValue0(v.Pos, OpDiv32, t) |
| v0.AddArg(n) |
| v1 := b.NewValue0(v.Pos, OpConst32, t) |
| v1.AuxInt = -c |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div32 <t> x (Const32 [-1<<31])) |
| // cond: |
| // result: (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <typ.UInt64> [31])) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| if v_1.AuxInt != -1<<31 { |
| break |
| } |
| v.reset(OpRsh32Ux64) |
| v0 := b.NewValue0(v.Pos, OpAnd32, t) |
| v0.AddArg(x) |
| v1 := b.NewValue0(v.Pos, OpNeg32, t) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = 31 |
| v.AddArg(v2) |
| return true |
| } |
| // match: (Div32 <t> n (Const32 [c])) |
| // cond: isPowerOfTwo(c) |
| // result: (Rsh32x64 (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <typ.UInt64> [31])) (Const64 <typ.UInt64> [32-log2(c)]))) (Const64 <typ.UInt64> [log2(c)])) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(isPowerOfTwo(c)) { |
| break |
| } |
| v.reset(OpRsh32x64) |
| v0 := b.NewValue0(v.Pos, OpAdd32, t) |
| v0.AddArg(n) |
| v1 := b.NewValue0(v.Pos, OpRsh32Ux64, t) |
| v2 := b.NewValue0(v.Pos, OpRsh32x64, t) |
| v2.AddArg(n) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = 31 |
| v2.AddArg(v3) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = 32 - log2(c) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v5.AuxInt = log2(c) |
| v.AddArg(v5) |
| return true |
| } |
| // match: (Div32 <t> x (Const32 [c])) |
| // cond: smagicOK(32,c) && config.RegSize == 8 |
| // result: (Sub32 <t> (Rsh64x64 <t> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(smagic(32,c).m)]) (SignExt32to64 x)) (Const64 <typ.UInt64> [32+smagic(32,c).s])) (Rsh64x64 <t> (SignExt32to64 x) (Const64 <typ.UInt64> [63]))) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(smagicOK(32, c) && config.RegSize == 8) { |
| break |
| } |
| v.reset(OpSub32) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, OpRsh64x64, t) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(smagic(32, c).m) |
| v1.AddArg(v2) |
| v3 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64) |
| v3.AddArg(x) |
| v1.AddArg(v3) |
| v0.AddArg(v1) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = 32 + smagic(32, c).s |
| v0.AddArg(v4) |
| v.AddArg(v0) |
| v5 := b.NewValue0(v.Pos, OpRsh64x64, t) |
| v6 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64) |
| v6.AddArg(x) |
| v5.AddArg(v6) |
| v7 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v7.AuxInt = 63 |
| v5.AddArg(v7) |
| v.AddArg(v5) |
| return true |
| } |
| // match: (Div32 <t> x (Const32 [c])) |
| // cond: smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 == 0 && config.useHmul |
| // result: (Sub32 <t> (Rsh32x64 <t> (Hmul32 <t> (Const32 <typ.UInt32> [int64(int32(smagic(32,c).m/2))]) x) (Const64 <typ.UInt64> [smagic(32,c).s-1])) (Rsh32x64 <t> x (Const64 <typ.UInt64> [31]))) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(smagicOK(32, c) && config.RegSize == 4 && smagic(32, c).m&1 == 0 && config.useHmul) { |
| break |
| } |
| v.reset(OpSub32) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, OpRsh32x64, t) |
| v1 := b.NewValue0(v.Pos, OpHmul32, t) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(smagic(32, c).m / 2)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = smagic(32, c).s - 1 |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpRsh32x64, t) |
| v4.AddArg(x) |
| v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v5.AuxInt = 31 |
| v4.AddArg(v5) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Div32 <t> x (Const32 [c])) |
| // cond: smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 != 0 && config.useHmul |
| // result: (Sub32 <t> (Rsh32x64 <t> (Add32 <t> (Hmul32 <t> (Const32 <typ.UInt32> [int64(int32(smagic(32,c).m))]) x) x) (Const64 <typ.UInt64> [smagic(32,c).s])) (Rsh32x64 <t> x (Const64 <typ.UInt64> [31]))) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(smagicOK(32, c) && config.RegSize == 4 && smagic(32, c).m&1 != 0 && config.useHmul) { |
| break |
| } |
| v.reset(OpSub32) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, OpRsh32x64, t) |
| v1 := b.NewValue0(v.Pos, OpAdd32, t) |
| v2 := b.NewValue0(v.Pos, OpHmul32, t) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(smagic(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = smagic(32, c).s |
| v0.AddArg(v4) |
| v.AddArg(v0) |
| v5 := b.NewValue0(v.Pos, OpRsh32x64, t) |
| v5.AddArg(x) |
| v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v6.AuxInt = 31 |
| v5.AddArg(v6) |
| v.AddArg(v5) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpDiv32F_0(v *Value) bool { |
| b := v.Block |
| // match: (Div32F (Const32F [c]) (Const32F [d])) |
| // cond: |
| // result: (Const32F [auxFrom32F(auxTo32F(c) / auxTo32F(d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32F { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32F { |
| break |
| } |
| d := v_1.AuxInt |
| v.reset(OpConst32F) |
| v.AuxInt = auxFrom32F(auxTo32F(c) / auxTo32F(d)) |
| return true |
| } |
| // match: (Div32F x (Const32F <t> [c])) |
| // cond: reciprocalExact32(auxTo32F(c)) |
| // result: (Mul32F x (Const32F <t> [auxFrom32F(1/auxTo32F(c))])) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32F { |
| break |
| } |
| t := v_1.Type |
| c := v_1.AuxInt |
| if !(reciprocalExact32(auxTo32F(c))) { |
| break |
| } |
| v.reset(OpMul32F) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpConst32F, t) |
| v0.AuxInt = auxFrom32F(1 / auxTo32F(c)) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpDiv32u_0(v *Value) bool { |
| b := v.Block |
| config := b.Func.Config |
| typ := &b.Func.Config.Types |
| // match: (Div32u (Const32 [c]) (Const32 [d])) |
| // cond: d != 0 |
| // result: (Const32 [int64(int32(uint32(c)/uint32(d)))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| d := v_1.AuxInt |
| if !(d != 0) { |
| break |
| } |
| v.reset(OpConst32) |
| v.AuxInt = int64(int32(uint32(c) / uint32(d))) |
| return true |
| } |
| // match: (Div32u n (Const32 [c])) |
| // cond: isPowerOfTwo(c&0xffffffff) |
| // result: (Rsh32Ux64 n (Const64 <typ.UInt64> [log2(c&0xffffffff)])) |
| for { |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(isPowerOfTwo(c & 0xffffffff)) { |
| break |
| } |
| v.reset(OpRsh32Ux64) |
| v.AddArg(n) |
| v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v0.AuxInt = log2(c & 0xffffffff) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div32u x (Const32 [c])) |
| // cond: umagicOK(32, c) && config.RegSize == 4 && umagic(32,c).m&1 == 0 && config.useHmul |
| // result: (Rsh32Ux64 <typ.UInt32> (Hmul32u <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(1<<31+umagic(32,c).m/2))]) x) (Const64 <typ.UInt64> [umagic(32,c).s-1])) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(umagicOK(32, c) && config.RegSize == 4 && umagic(32, c).m&1 == 0 && config.useHmul) { |
| break |
| } |
| v.reset(OpRsh32Ux64) |
| v.Type = typ.UInt32 |
| v0 := b.NewValue0(v.Pos, OpHmul32u, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v1.AuxInt = int64(int32(1<<31 + umagic(32, c).m/2)) |
| v0.AddArg(v1) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = umagic(32, c).s - 1 |
| v.AddArg(v2) |
| return true |
| } |
| // match: (Div32u x (Const32 [c])) |
| // cond: umagicOK(32, c) && config.RegSize == 4 && c&1 == 0 && config.useHmul |
| // result: (Rsh32Ux64 <typ.UInt32> (Hmul32u <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(1<<31+(umagic(32,c).m+1)/2))]) (Rsh32Ux64 <typ.UInt32> x (Const64 <typ.UInt64> [1]))) (Const64 <typ.UInt64> [umagic(32,c).s-2])) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(umagicOK(32, c) && config.RegSize == 4 && c&1 == 0 && config.useHmul) { |
| break |
| } |
| v.reset(OpRsh32Ux64) |
| v.Type = typ.UInt32 |
| v0 := b.NewValue0(v.Pos, OpHmul32u, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v1.AuxInt = int64(int32(1<<31 + (umagic(32, c).m+1)/2)) |
| v0.AddArg(v1) |
| v2 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) |
| v2.AddArg(x) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = 1 |
| v2.AddArg(v3) |
| v0.AddArg(v2) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = umagic(32, c).s - 2 |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Div32u x (Const32 [c])) |
| // cond: umagicOK(32, c) && config.RegSize == 4 && config.useAvg && config.useHmul |
| // result: (Rsh32Ux64 <typ.UInt32> (Avg32u x (Hmul32u <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(umagic(32,c).m))]) x)) (Const64 <typ.UInt64> [umagic(32,c).s-1])) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(umagicOK(32, c) && config.RegSize == 4 && config.useAvg && config.useHmul) { |
| break |
| } |
| v.reset(OpRsh32Ux64) |
| v.Type = typ.UInt32 |
| v0 := b.NewValue0(v.Pos, OpAvg32u, typ.UInt32) |
| v0.AddArg(x) |
| v1 := b.NewValue0(v.Pos, OpHmul32u, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(umagic(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = umagic(32, c).s - 1 |
| v.AddArg(v3) |
| return true |
| } |
| // match: (Div32u x (Const32 [c])) |
| // cond: umagicOK(32, c) && config.RegSize == 8 && umagic(32,c).m&1 == 0 |
| // result: (Trunc64to32 (Rsh64Ux64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<31+umagic(32,c).m/2)]) (ZeroExt32to64 x)) (Const64 <typ.UInt64> [32+umagic(32,c).s-1]))) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(umagicOK(32, c) && config.RegSize == 8 && umagic(32, c).m&1 == 0) { |
| break |
| } |
| v.reset(OpTrunc64to32) |
| v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(1<<31 + umagic(32, c).m/2) |
| v1.AddArg(v2) |
| v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64) |
| v3.AddArg(x) |
| v1.AddArg(v3) |
| v0.AddArg(v1) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = 32 + umagic(32, c).s - 1 |
| v0.AddArg(v4) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div32u x (Const32 [c])) |
| // cond: umagicOK(32, c) && config.RegSize == 8 && c&1 == 0 |
| // result: (Trunc64to32 (Rsh64Ux64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<31+(umagic(32,c).m+1)/2)]) (Rsh64Ux64 <typ.UInt64> (ZeroExt32to64 x) (Const64 <typ.UInt64> [1]))) (Const64 <typ.UInt64> [32+umagic(32,c).s-2]))) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(umagicOK(32, c) && config.RegSize == 8 && c&1 == 0) { |
| break |
| } |
| v.reset(OpTrunc64to32) |
| v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(1<<31 + (umagic(32, c).m+1)/2) |
| v1.AddArg(v2) |
| v3 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) |
| v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64) |
| v4.AddArg(x) |
| v3.AddArg(v4) |
| v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v5.AuxInt = 1 |
| v3.AddArg(v5) |
| v1.AddArg(v3) |
| v0.AddArg(v1) |
| v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v6.AuxInt = 32 + umagic(32, c).s - 2 |
| v0.AddArg(v6) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div32u x (Const32 [c])) |
| // cond: umagicOK(32, c) && config.RegSize == 8 && config.useAvg |
| // result: (Trunc64to32 (Rsh64Ux64 <typ.UInt64> (Avg64u (Lsh64x64 <typ.UInt64> (ZeroExt32to64 x) (Const64 <typ.UInt64> [32])) (Mul64 <typ.UInt64> (Const64 <typ.UInt32> [int64(umagic(32,c).m)]) (ZeroExt32to64 x))) (Const64 <typ.UInt64> [32+umagic(32,c).s-1]))) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(umagicOK(32, c) && config.RegSize == 8 && config.useAvg) { |
| break |
| } |
| v.reset(OpTrunc64to32) |
| v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpAvg64u, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpLsh64x64, typ.UInt64) |
| v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64) |
| v3.AddArg(x) |
| v2.AddArg(v3) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = 32 |
| v2.AddArg(v4) |
| v1.AddArg(v2) |
| v5 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt32) |
| v6.AuxInt = int64(umagic(32, c).m) |
| v5.AddArg(v6) |
| v7 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64) |
| v7.AddArg(x) |
| v5.AddArg(v7) |
| v1.AddArg(v5) |
| v0.AddArg(v1) |
| v8 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v8.AuxInt = 32 + umagic(32, c).s - 1 |
| v0.AddArg(v8) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpDiv64_0(v *Value) bool { |
| b := v.Block |
| config := b.Func.Config |
| typ := &b.Func.Config.Types |
| // match: (Div64 (Const64 [c]) (Const64 [d])) |
| // cond: d != 0 |
| // result: (Const64 [c/d]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| d := v_1.AuxInt |
| if !(d != 0) { |
| break |
| } |
| v.reset(OpConst64) |
| v.AuxInt = c / d |
| return true |
| } |
| // match: (Div64 n (Const64 [c])) |
| // cond: isNonNegative(n) && isPowerOfTwo(c) |
| // result: (Rsh64Ux64 n (Const64 <typ.UInt64> [log2(c)])) |
| for { |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(isNonNegative(n) && isPowerOfTwo(c)) { |
| break |
| } |
| v.reset(OpRsh64Ux64) |
| v.AddArg(n) |
| v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v0.AuxInt = log2(c) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div64 n (Const64 [-1<<63])) |
| // cond: isNonNegative(n) |
| // result: (Const64 [0]) |
| for { |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| if v_1.AuxInt != -1<<63 { |
| break |
| } |
| if !(isNonNegative(n)) { |
| break |
| } |
| v.reset(OpConst64) |
| v.AuxInt = 0 |
| 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 |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(c < 0 && c != -1<<63) { |
| break |
| } |
| v.reset(OpNeg64) |
| v0 := b.NewValue0(v.Pos, OpDiv64, t) |
| v0.AddArg(n) |
| v1 := b.NewValue0(v.Pos, OpConst64, t) |
| v1.AuxInt = -c |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div64 <t> x (Const64 [-1<<63])) |
| // cond: |
| // result: (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <typ.UInt64> [63])) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| if v_1.AuxInt != -1<<63 { |
| break |
| } |
| v.reset(OpRsh64Ux64) |
| v0 := b.NewValue0(v.Pos, OpAnd64, t) |
| v0.AddArg(x) |
| v1 := b.NewValue0(v.Pos, OpNeg64, t) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = 63 |
| v.AddArg(v2) |
| return true |
| } |
| // match: (Div64 <t> n (Const64 [c])) |
| // cond: isPowerOfTwo(c) |
| // result: (Rsh64x64 (Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <typ.UInt64> [63])) (Const64 <typ.UInt64> [64-log2(c)]))) (Const64 <typ.UInt64> [log2(c)])) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(isPowerOfTwo(c)) { |
| break |
| } |
| v.reset(OpRsh64x64) |
| v0 := b.NewValue0(v.Pos, OpAdd64, t) |
| v0.AddArg(n) |
| v1 := b.NewValue0(v.Pos, OpRsh64Ux64, t) |
| v2 := b.NewValue0(v.Pos, OpRsh64x64, t) |
| v2.AddArg(n) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = 63 |
| v2.AddArg(v3) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = 64 - log2(c) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v5.AuxInt = log2(c) |
| v.AddArg(v5) |
| return true |
| } |
| // match: (Div64 <t> x (Const64 [c])) |
| // cond: smagicOK(64,c) && smagic(64,c).m&1 == 0 && config.useHmul |
| // result: (Sub64 <t> (Rsh64x64 <t> (Hmul64 <t> (Const64 <typ.UInt64> [int64(smagic(64,c).m/2)]) x) (Const64 <typ.UInt64> [smagic(64,c).s-1])) (Rsh64x64 <t> x (Const64 <typ.UInt64> [63]))) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(smagicOK(64, c) && smagic(64, c).m&1 == 0 && config.useHmul) { |
| break |
| } |
| v.reset(OpSub64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, OpRsh64x64, t) |
| v1 := b.NewValue0(v.Pos, OpHmul64, t) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(smagic(64, c).m / 2) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = smagic(64, c).s - 1 |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpRsh64x64, t) |
| v4.AddArg(x) |
| v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v5.AuxInt = 63 |
| v4.AddArg(v5) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Div64 <t> x (Const64 [c])) |
| // cond: smagicOK(64,c) && smagic(64,c).m&1 != 0 && config.useHmul |
| // result: (Sub64 <t> (Rsh64x64 <t> (Add64 <t> (Hmul64 <t> (Const64 <typ.UInt64> [int64(smagic(64,c).m)]) x) x) (Const64 <typ.UInt64> [smagic(64,c).s])) (Rsh64x64 <t> x (Const64 <typ.UInt64> [63]))) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(smagicOK(64, c) && smagic(64, c).m&1 != 0 && config.useHmul) { |
| break |
| } |
| v.reset(OpSub64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, OpRsh64x64, t) |
| v1 := b.NewValue0(v.Pos, OpAdd64, t) |
| v2 := b.NewValue0(v.Pos, OpHmul64, t) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(smagic(64, c).m) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = smagic(64, c).s |
| v0.AddArg(v4) |
| v.AddArg(v0) |
| v5 := b.NewValue0(v.Pos, OpRsh64x64, t) |
| v5.AddArg(x) |
| v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v6.AuxInt = 63 |
| v5.AddArg(v6) |
| v.AddArg(v5) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpDiv64F_0(v *Value) bool { |
| b := v.Block |
| // match: (Div64F (Const64F [c]) (Const64F [d])) |
| // cond: |
| // result: (Const64F [auxFrom64F(auxTo64F(c) / auxTo64F(d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64F { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64F { |
| break |
| } |
| d := v_1.AuxInt |
| v.reset(OpConst64F) |
| v.AuxInt = auxFrom64F(auxTo64F(c) / auxTo64F(d)) |
| return true |
| } |
| // match: (Div64F x (Const64F <t> [c])) |
| // cond: reciprocalExact64(auxTo64F(c)) |
| // result: (Mul64F x (Const64F <t> [auxFrom64F(1/auxTo64F(c))])) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64F { |
| break |
| } |
| t := v_1.Type |
| c := v_1.AuxInt |
| if !(reciprocalExact64(auxTo64F(c))) { |
| break |
| } |
| v.reset(OpMul64F) |
| v.AddArg(x) |
| v0 := b.NewValue0(v.Pos, OpConst64F, t) |
| v0.AuxInt = auxFrom64F(1 / auxTo64F(c)) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpDiv64u_0(v *Value) bool { |
| b := v.Block |
| config := b.Func.Config |
| typ := &b.Func.Config.Types |
| // match: (Div64u (Const64 [c]) (Const64 [d])) |
| // cond: d != 0 |
| // result: (Const64 [int64(uint64(c)/uint64(d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| d := v_1.AuxInt |
| if !(d != 0) { |
| break |
| } |
| v.reset(OpConst64) |
| v.AuxInt = int64(uint64(c) / uint64(d)) |
| return true |
| } |
| // match: (Div64u n (Const64 [c])) |
| // cond: isPowerOfTwo(c) |
| // result: (Rsh64Ux64 n (Const64 <typ.UInt64> [log2(c)])) |
| for { |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(isPowerOfTwo(c)) { |
| break |
| } |
| v.reset(OpRsh64Ux64) |
| v.AddArg(n) |
| v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v0.AuxInt = log2(c) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div64u n (Const64 [-1<<63])) |
| // cond: |
| // result: (Rsh64Ux64 n (Const64 <typ.UInt64> [63])) |
| for { |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| if v_1.AuxInt != -1<<63 { |
| break |
| } |
| v.reset(OpRsh64Ux64) |
| v.AddArg(n) |
| v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v0.AuxInt = 63 |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div64u x (Const64 [c])) |
| // cond: umagicOK(64, c) && config.RegSize == 8 && umagic(64,c).m&1 == 0 && config.useHmul |
| // result: (Rsh64Ux64 <typ.UInt64> (Hmul64u <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<63+umagic(64,c).m/2)]) x) (Const64 <typ.UInt64> [umagic(64,c).s-1])) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(umagicOK(64, c) && config.RegSize == 8 && umagic(64, c).m&1 == 0 && config.useHmul) { |
| break |
| } |
| v.reset(OpRsh64Ux64) |
| v.Type = typ.UInt64 |
| v0 := b.NewValue0(v.Pos, OpHmul64u, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v1.AuxInt = int64(1<<63 + umagic(64, c).m/2) |
| v0.AddArg(v1) |
| v0.AddArg(x) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = umagic(64, c).s - 1 |
| v.AddArg(v2) |
| return true |
| } |
| // match: (Div64u x (Const64 [c])) |
| // cond: umagicOK(64, c) && config.RegSize == 8 && c&1 == 0 && config.useHmul |
| // result: (Rsh64Ux64 <typ.UInt64> (Hmul64u <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<63+(umagic(64,c).m+1)/2)]) (Rsh64Ux64 <typ.UInt64> x (Const64 <typ.UInt64> [1]))) (Const64 <typ.UInt64> [umagic(64,c).s-2])) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(umagicOK(64, c) && config.RegSize == 8 && c&1 == 0 && config.useHmul) { |
| break |
| } |
| v.reset(OpRsh64Ux64) |
| v.Type = typ.UInt64 |
| v0 := b.NewValue0(v.Pos, OpHmul64u, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v1.AuxInt = int64(1<<63 + (umagic(64, c).m+1)/2) |
| v0.AddArg(v1) |
| v2 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) |
| v2.AddArg(x) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = 1 |
| v2.AddArg(v3) |
| v0.AddArg(v2) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = umagic(64, c).s - 2 |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Div64u x (Const64 [c])) |
| // cond: umagicOK(64, c) && config.RegSize == 8 && config.useAvg && config.useHmul |
| // result: (Rsh64Ux64 <typ.UInt64> (Avg64u x (Hmul64u <typ.UInt64> (Const64 <typ.UInt64> [int64(umagic(64,c).m)]) x)) (Const64 <typ.UInt64> [umagic(64,c).s-1])) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(umagicOK(64, c) && config.RegSize == 8 && config.useAvg && config.useHmul) { |
| break |
| } |
| v.reset(OpRsh64Ux64) |
| v.Type = typ.UInt64 |
| v0 := b.NewValue0(v.Pos, OpAvg64u, typ.UInt64) |
| v0.AddArg(x) |
| v1 := b.NewValue0(v.Pos, OpHmul64u, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(umagic(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = umagic(64, c).s - 1 |
| v.AddArg(v3) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpDiv8_0(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Div8 (Const8 [c]) (Const8 [d])) |
| // cond: d != 0 |
| // result: (Const8 [int64(int8(c)/int8(d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| d := v_1.AuxInt |
| if !(d != 0) { |
| break |
| } |
| v.reset(OpConst8) |
| v.AuxInt = int64(int8(c) / int8(d)) |
| return true |
| } |
| // match: (Div8 n (Const8 [c])) |
| // cond: isNonNegative(n) && isPowerOfTwo(c&0xff) |
| // result: (Rsh8Ux64 n (Const64 <typ.UInt64> [log2(c&0xff)])) |
| for { |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(isNonNegative(n) && isPowerOfTwo(c&0xff)) { |
| break |
| } |
| v.reset(OpRsh8Ux64) |
| v.AddArg(n) |
| v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v0.AuxInt = log2(c & 0xff) |
| v.AddArg(v0) |
| 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 |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(c < 0 && c != -1<<7) { |
| break |
| } |
| v.reset(OpNeg8) |
| v0 := b.NewValue0(v.Pos, OpDiv8, t) |
| v0.AddArg(n) |
| v1 := b.NewValue0(v.Pos, OpConst8, t) |
| v1.AuxInt = -c |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div8 <t> x (Const8 [-1<<7 ])) |
| // cond: |
| // result: (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <typ.UInt64> [7 ])) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| if v_1.AuxInt != -1<<7 { |
| break |
| } |
| v.reset(OpRsh8Ux64) |
| v0 := b.NewValue0(v.Pos, OpAnd8, t) |
| v0.AddArg(x) |
| v1 := b.NewValue0(v.Pos, OpNeg8, t) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = 7 |
| v.AddArg(v2) |
| return true |
| } |
| // match: (Div8 <t> n (Const8 [c])) |
| // cond: isPowerOfTwo(c) |
| // result: (Rsh8x64 (Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <typ.UInt64> [ 7])) (Const64 <typ.UInt64> [ 8-log2(c)]))) (Const64 <typ.UInt64> [log2(c)])) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(isPowerOfTwo(c)) { |
| break |
| } |
| v.reset(OpRsh8x64) |
| v0 := b.NewValue0(v.Pos, OpAdd8, t) |
| v0.AddArg(n) |
| v1 := b.NewValue0(v.Pos, OpRsh8Ux64, t) |
| v2 := b.NewValue0(v.Pos, OpRsh8x64, t) |
| v2.AddArg(n) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = 7 |
| v2.AddArg(v3) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = 8 - log2(c) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v5.AuxInt = log2(c) |
| v.AddArg(v5) |
| return true |
| } |
| // match: (Div8 <t> x (Const8 [c])) |
| // cond: smagicOK(8,c) |
| // result: (Sub8 <t> (Rsh32x64 <t> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(smagic(8,c).m)]) (SignExt8to32 x)) (Const64 <typ.UInt64> [8+smagic(8,c).s])) (Rsh32x64 <t> (SignExt8to32 x) (Const64 <typ.UInt64> [31]))) |
| for { |
| t := v.Type |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(smagicOK(8, c)) { |
| break |
| } |
| v.reset(OpSub8) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, OpRsh32x64, t) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(smagic(8, c).m) |
| v1.AddArg(v2) |
| v3 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) |
| v3.AddArg(x) |
| v1.AddArg(v3) |
| v0.AddArg(v1) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = 8 + smagic(8, c).s |
| v0.AddArg(v4) |
| v.AddArg(v0) |
| v5 := b.NewValue0(v.Pos, OpRsh32x64, t) |
| v6 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) |
| v6.AddArg(x) |
| v5.AddArg(v6) |
| v7 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v7.AuxInt = 31 |
| v5.AddArg(v7) |
| v.AddArg(v5) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpDiv8u_0(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Div8u (Const8 [c]) (Const8 [d])) |
| // cond: d != 0 |
| // result: (Const8 [int64(int8(uint8(c)/uint8(d)))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst8 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| d := v_1.AuxInt |
| if !(d != 0) { |
| break |
| } |
| v.reset(OpConst8) |
| v.AuxInt = int64(int8(uint8(c) / uint8(d))) |
| return true |
| } |
| // match: (Div8u n (Const8 [c])) |
| // cond: isPowerOfTwo(c&0xff) |
| // result: (Rsh8Ux64 n (Const64 <typ.UInt64> [log2(c&0xff)])) |
| for { |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(isPowerOfTwo(c & 0xff)) { |
| break |
| } |
| v.reset(OpRsh8Ux64) |
| v.AddArg(n) |
| v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v0.AuxInt = log2(c & 0xff) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div8u x (Const8 [c])) |
| // cond: umagicOK(8, c) |
| // result: (Trunc32to8 (Rsh32Ux64 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(1<<8+umagic(8,c).m)]) (ZeroExt8to32 x)) (Const64 <typ.UInt64> [8+umagic(8,c).s]))) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst8 { |
| break |
| } |
| c := v_1.AuxInt |
| if !(umagicOK(8, c)) { |
| break |
| } |
| v.reset(OpTrunc32to8) |
| v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(1<<8 + umagic(8, c).m) |
| v1.AddArg(v2) |
| v3 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) |
| v3.AddArg(x) |
| v1.AddArg(v3) |
| v0.AddArg(v1) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = 8 + umagic(8, c).s |
| v0.AddArg(v4) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq16_0(v *Value) bool { |
| b := v.Block |
| config := b.Func.Config |
| typ := &b.Func.Config.Types |
| // match: (Eq16 x x) |
| // cond: |
| // result: (ConstBool [1]) |
| for { |
| x := v.Args[1] |
| if x != v.Args[0] { |
| break |
| } |
| v.reset(OpConstBool) |
| v.AuxInt = 1 |
| return true |
| } |
| // match: (Eq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x)) |
| // cond: |
| // result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd16 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst16 { |
| break |
| } |
| if v_1_0.Type != t { |
| break |
| } |
| d := v_1_0.AuxInt |
| v.reset(OpEq16) |
| v0 := b.NewValue0(v.Pos, OpConst16, t) |
| v0.AuxInt = int64(int16(c - d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Eq16 (Const16 <t> [c]) (Add16 x (Const16 <t> [d]))) |
| // cond: |
| // result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd16 { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst16 { |
| break |
| } |
| if v_1_1.Type != t { |
| break |
| } |
| d := v_1_1.AuxInt |
| v.reset(OpEq16) |
| v0 := b.NewValue0(v.Pos, OpConst16, t) |
| v0.AuxInt = int64(int16(c - d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Eq16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c])) |
| // cond: |
| // result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd16 { |
| break |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst16 { |
| break |
| } |
| t := v_0_0.Type |
| d := v_0_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpEq16) |
| v0 := b.NewValue0(v.Pos, OpConst16, t) |
| v0.AuxInt = int64(int16(c - d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Eq16 (Add16 x (Const16 <t> [d])) (Const16 <t> [c])) |
| // cond: |
| // result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd16 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst16 { |
| break |
| } |
| t := v_0_1.Type |
| d := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpEq16) |
| v0 := b.NewValue0(v.Pos, OpConst16, t) |
| v0.AuxInt = int64(int16(c - d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Eq16 (Const16 [c]) (Const16 [d])) |
| // cond: |
| // result: (ConstBool [b2i(c == d)]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| d := v_1.AuxInt |
| v.reset(OpConstBool) |
| v.AuxInt = b2i(c == d) |
| return true |
| } |
| // match: (Eq16 (Const16 [d]) (Const16 [c])) |
| // cond: |
| // result: (ConstBool [b2i(c == d)]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| d := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpConstBool) |
| v.AuxInt = b2i(c == d) |
| return true |
| } |
| // match: (Eq16 (Mod16u x (Const16 [c])) (Const16 [0])) |
| // cond: x.Op != OpConst16 && udivisibleOK(16,c) && !hasSmallRotate(config) |
| // result: (Eq32 (Mod32u <typ.UInt32> (ZeroExt16to32 <typ.UInt32> x) (Const32 <typ.UInt32> [c&0xffff])) (Const32 <typ.UInt32> [0])) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMod16u { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst16 { |
| break |
| } |
| c := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| if v_1.AuxInt != 0 { |
| break |
| } |
| if !(x.Op != OpConst16 && udivisibleOK(16, c) && !hasSmallRotate(config)) { |
| break |
| } |
| v.reset(OpEq32) |
| v0 := b.NewValue0(v.Pos, OpMod32u, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = c & 0xffff |
| v0.AddArg(v2) |
| v.AddArg(v0) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = 0 |
| v.AddArg(v3) |
| return true |
| } |
| // match: (Eq16 (Const16 [0]) (Mod16u x (Const16 [c]))) |
| // cond: x.Op != OpConst16 && udivisibleOK(16,c) && !hasSmallRotate(config) |
| // result: (Eq32 (Mod32u <typ.UInt32> (ZeroExt16to32 <typ.UInt32> x) (Const32 <typ.UInt32> [c&0xffff])) (Const32 <typ.UInt32> [0])) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| if v_0.AuxInt != 0 { |
| break |
| } |
| v_1 := v.Args[1] |
| if v_1.Op != OpMod16u { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst16 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(x.Op != OpConst16 && udivisibleOK(16, c) && !hasSmallRotate(config)) { |
| break |
| } |
| v.reset(OpEq32) |
| v0 := b.NewValue0(v.Pos, OpMod32u, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = c & 0xffff |
| v0.AddArg(v2) |
| v.AddArg(v0) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = 0 |
| v.AddArg(v3) |
| return true |
| } |
| // match: (Eq16 (Mod16 x (Const16 [c])) (Const16 [0])) |
| // cond: x.Op != OpConst16 && sdivisibleOK(16,c) && !hasSmallRotate(config) |
| // result: (Eq32 (Mod32 <typ.Int32> (SignExt16to32 <typ.Int32> x) (Const32 <typ.Int32> [c])) (Const32 <typ.Int32> [0])) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMod16 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst16 { |
| break |
| } |
| c := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| if v_1.AuxInt != 0 { |
| break |
| } |
| if !(x.Op != OpConst16 && sdivisibleOK(16, c) && !hasSmallRotate(config)) { |
| break |
| } |
| v.reset(OpEq32) |
| v0 := b.NewValue0(v.Pos, OpMod32, typ.Int32) |
| v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.Int32) |
| v2.AuxInt = c |
| v0.AddArg(v2) |
| v.AddArg(v0) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.Int32) |
| v3.AuxInt = 0 |
| v.AddArg(v3) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq16_10(v *Value) bool { |
| b := v.Block |
| config := b.Func.Config |
| typ := &b.Func.Config.Types |
| // match: (Eq16 (Const16 [0]) (Mod16 x (Const16 [c]))) |
| // cond: x.Op != OpConst16 && sdivisibleOK(16,c) && !hasSmallRotate(config) |
| // result: (Eq32 (Mod32 <typ.Int32> (SignExt16to32 <typ.Int32> x) (Const32 <typ.Int32> [c])) (Const32 <typ.Int32> [0])) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| if v_0.AuxInt != 0 { |
| break |
| } |
| v_1 := v.Args[1] |
| if v_1.Op != OpMod16 { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst16 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(x.Op != OpConst16 && sdivisibleOK(16, c) && !hasSmallRotate(config)) { |
| break |
| } |
| v.reset(OpEq32) |
| v0 := b.NewValue0(v.Pos, OpMod32, typ.Int32) |
| v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.Int32) |
| v2.AuxInt = c |
| v0.AddArg(v2) |
| v.AddArg(v0) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.Int32) |
| v3.AuxInt = 0 |
| v.AddArg(v3) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Const16 [c]) (Trunc64to16 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (ZeroExt16to64 x)) (Const64 [s]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16,c).m) && s == 16+umagic(16,c).s && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst16 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpTrunc64to16 { |
| break |
| } |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt16to64 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16, c).m) && s == 16+umagic(16, c).s && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Const16 [c]) (Trunc64to16 (Rsh64Ux64 mul:(Mul64 (ZeroExt16to64 x) (Const64 [m])) (Const64 [s]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16,c).m) && s == 16+umagic(16,c).s && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst16 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpTrunc64to16 { |
| break |
| } |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt16to64 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16, c).m) && s == 16+umagic(16, c).s && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Trunc64to16 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (ZeroExt16to64 x)) (Const64 [s]))) (Const16 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16,c).m) && s == 16+umagic(16,c).s && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpTrunc64to16 { |
| break |
| } |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt16to64 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst16 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16, c).m) && s == 16+umagic(16, c).s && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Trunc64to16 (Rsh64Ux64 mul:(Mul64 (ZeroExt16to64 x) (Const64 [m])) (Const64 [s]))) (Const16 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16,c).m) && s == 16+umagic(16,c).s && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpTrunc64to16 { |
| break |
| } |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt16to64 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst16 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16, c).m) && s == 16+umagic(16, c).s && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Const16 [c]) (Trunc64to16 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (ZeroExt16to64 x)) (Const64 [s])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16,c).m) && s == 16+umagic(16,c).s && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst16 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpTrunc64to16 { |
| break |
| } |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| mul := v_0_1_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt16to64 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16, c).m) && s == 16+umagic(16, c).s && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Const16 [c]) (Trunc64to16 (Rsh64Ux64 mul:(Mul64 (ZeroExt16to64 x) (Const64 [m])) (Const64 [s])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16,c).m) && s == 16+umagic(16,c).s && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst16 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpTrunc64to16 { |
| break |
| } |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| mul := v_0_1_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt16to64 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16, c).m) && s == 16+umagic(16, c).s && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Trunc64to16 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (ZeroExt16to64 x)) (Const64 [s]))) (Const16 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16,c).m) && s == 16+umagic(16,c).s && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpTrunc64to16 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| mul := v_0_0_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt16to64 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst16 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16, c).m) && s == 16+umagic(16, c).s && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Trunc64to16 (Rsh64Ux64 mul:(Mul64 (ZeroExt16to64 x) (Const64 [m])) (Const64 [s]))) (Const16 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16,c).m) && s == 16+umagic(16,c).s && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpTrunc64to16 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| mul := v_0_0_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt16to64 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst16 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<16+umagic(16, c).m) && s == 16+umagic(16, c).s && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (ZeroExt16to32 x)) (Const64 [s]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16,c).m/2) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst16 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpTrunc32to16 { |
| break |
| } |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16, c).m/2) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq16_20(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq16 x (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (ZeroExt16to32 x) (Const32 [m])) (Const64 [s]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16,c).m/2) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst16 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpTrunc32to16 { |
| break |
| } |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16, c).m/2) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (ZeroExt16to32 x)) (Const64 [s]))) (Const16 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16,c).m/2) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpTrunc32to16 { |
| break |
| } |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst16 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16, c).m/2) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (ZeroExt16to32 x) (Const32 [m])) (Const64 [s]))) (Const16 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16,c).m/2) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpTrunc32to16 { |
| break |
| } |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst16 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16, c).m/2) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (ZeroExt16to32 x)) (Const64 [s])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16,c).m/2) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst16 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpTrunc32to16 { |
| break |
| } |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| mul := v_0_1_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16, c).m/2) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (ZeroExt16to32 x) (Const32 [m])) (Const64 [s])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16,c).m/2) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst16 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpTrunc32to16 { |
| break |
| } |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| mul := v_0_1_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16, c).m/2) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (ZeroExt16to32 x)) (Const64 [s]))) (Const16 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16,c).m/2) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpTrunc32to16 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| mul := v_0_0_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst16 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16, c).m/2) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (ZeroExt16to32 x) (Const32 [m])) (Const64 [s]))) (Const16 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16,c).m/2) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpTrunc32to16 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| mul := v_0_0_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst16 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+umagic(16, c).m/2) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (Rsh32Ux64 (ZeroExt16to32 x) (Const64 [1]))) (Const64 [s]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16,c).m+1)/2) && s == 16+umagic(16,c).s-2 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst16 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpTrunc32to16 { |
| break |
| } |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = mul_1.Args[1] |
| mul_1_0 := mul_1.Args[0] |
| if mul_1_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_1_0.Args[0] { |
| break |
| } |
| mul_1_1 := mul_1.Args[1] |
| if mul_1_1.Op != OpConst64 { |
| break |
| } |
| if mul_1_1.AuxInt != 1 { |
| break |
| } |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16, c).m+1)/2) && s == 16+umagic(16, c).s-2 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Rsh32Ux64 (ZeroExt16to32 x) (Const64 [1])) (Const32 [m])) (Const64 [s]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16,c).m+1)/2) && s == 16+umagic(16,c).s-2 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst16 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpTrunc32to16 { |
| break |
| } |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = mul_0.Args[1] |
| mul_0_0 := mul_0.Args[0] |
| if mul_0_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_0_0.Args[0] { |
| break |
| } |
| mul_0_1 := mul_0.Args[1] |
| if mul_0_1.Op != OpConst64 { |
| break |
| } |
| if mul_0_1.AuxInt != 1 { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16, c).m+1)/2) && s == 16+umagic(16, c).s-2 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (Rsh32Ux64 (ZeroExt16to32 x) (Const64 [1]))) (Const64 [s]))) (Const16 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16,c).m+1)/2) && s == 16+umagic(16,c).s-2 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpTrunc32to16 { |
| break |
| } |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = mul_1.Args[1] |
| mul_1_0 := mul_1.Args[0] |
| if mul_1_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_1_0.Args[0] { |
| break |
| } |
| mul_1_1 := mul_1.Args[1] |
| if mul_1_1.Op != OpConst64 { |
| break |
| } |
| if mul_1_1.AuxInt != 1 { |
| break |
| } |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst16 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16, c).m+1)/2) && s == 16+umagic(16, c).s-2 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq16_30(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq16 x (Mul16 (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Rsh32Ux64 (ZeroExt16to32 x) (Const64 [1])) (Const32 [m])) (Const64 [s]))) (Const16 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16,c).m+1)/2) && s == 16+umagic(16,c).s-2 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpTrunc32to16 { |
| break |
| } |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = mul_0.Args[1] |
| mul_0_0 := mul_0.Args[0] |
| if mul_0_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_0_0.Args[0] { |
| break |
| } |
| mul_0_1 := mul_0.Args[1] |
| if mul_0_1.Op != OpConst64 { |
| break |
| } |
| if mul_0_1.AuxInt != 1 { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst16 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16, c).m+1)/2) && s == 16+umagic(16, c).s-2 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (Rsh32Ux64 (ZeroExt16to32 x) (Const64 [1]))) (Const64 [s])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16,c).m+1)/2) && s == 16+umagic(16,c).s-2 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst16 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpTrunc32to16 { |
| break |
| } |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| mul := v_0_1_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = mul_1.Args[1] |
| mul_1_0 := mul_1.Args[0] |
| if mul_1_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_1_0.Args[0] { |
| break |
| } |
| mul_1_1 := mul_1.Args[1] |
| if mul_1_1.Op != OpConst64 { |
| break |
| } |
| if mul_1_1.AuxInt != 1 { |
| break |
| } |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16, c).m+1)/2) && s == 16+umagic(16, c).s-2 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Rsh32Ux64 (ZeroExt16to32 x) (Const64 [1])) (Const32 [m])) (Const64 [s])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16,c).m+1)/2) && s == 16+umagic(16,c).s-2 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst16 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpTrunc32to16 { |
| break |
| } |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| mul := v_0_1_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = mul_0.Args[1] |
| mul_0_0 := mul_0.Args[0] |
| if mul_0_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_0_0.Args[0] { |
| break |
| } |
| mul_0_1 := mul_0.Args[1] |
| if mul_0_1.Op != OpConst64 { |
| break |
| } |
| if mul_0_1.AuxInt != 1 { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16, c).m+1)/2) && s == 16+umagic(16, c).s-2 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Const32 [m]) (Rsh32Ux64 (ZeroExt16to32 x) (Const64 [1]))) (Const64 [s]))) (Const16 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16,c).m+1)/2) && s == 16+umagic(16,c).s-2 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpTrunc32to16 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| mul := v_0_0_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = mul_1.Args[1] |
| mul_1_0 := mul_1.Args[0] |
| if mul_1_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_1_0.Args[0] { |
| break |
| } |
| mul_1_1 := mul_1.Args[1] |
| if mul_1_1.Op != OpConst64 { |
| break |
| } |
| if mul_1_1.AuxInt != 1 { |
| break |
| } |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst16 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16, c).m+1)/2) && s == 16+umagic(16, c).s-2 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Trunc32to16 (Rsh32Ux64 mul:(Mul32 (Rsh32Ux64 (ZeroExt16to32 x) (Const64 [1])) (Const32 [m])) (Const64 [s]))) (Const16 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16,c).m+1)/2) && s == 16+umagic(16,c).s-2 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpTrunc32to16 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| mul := v_0_0_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = mul_0.Args[1] |
| mul_0_0 := mul_0.Args[0] |
| if mul_0_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_0_0.Args[0] { |
| break |
| } |
| mul_0_1 := mul_0.Args[1] |
| if mul_0_1.Op != OpConst64 { |
| break |
| } |
| if mul_0_1.AuxInt != 1 { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst16 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<15+(umagic(16, c).m+1)/2) && s == 16+umagic(16, c).s-2 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 (Avg32u (Lsh32x64 (ZeroExt16to32 x) (Const64 [16])) mul:(Mul32 (Const32 [m]) (ZeroExt16to32 x))) (Const64 [s]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16,c).m) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst16 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpTrunc32to16 { |
| break |
| } |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| v_1_1_0_0 := v_1_1_0.Args[0] |
| if v_1_1_0_0.Op != OpAvg32u { |
| break |
| } |
| _ = v_1_1_0_0.Args[1] |
| v_1_1_0_0_0 := v_1_1_0_0.Args[0] |
| if v_1_1_0_0_0.Op != OpLsh32x64 { |
| break |
| } |
| _ = v_1_1_0_0_0.Args[1] |
| v_1_1_0_0_0_0 := v_1_1_0_0_0.Args[0] |
| if v_1_1_0_0_0_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != v_1_1_0_0_0_0.Args[0] { |
| break |
| } |
| v_1_1_0_0_0_1 := v_1_1_0_0_0.Args[1] |
| if v_1_1_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1_0_0_0_1.AuxInt != 16 { |
| break |
| } |
| mul := v_1_1_0_0.Args[1] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16, c).m) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 (Avg32u (Lsh32x64 (ZeroExt16to32 x) (Const64 [16])) mul:(Mul32 (ZeroExt16to32 x) (Const32 [m]))) (Const64 [s]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16,c).m) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst16 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpTrunc32to16 { |
| break |
| } |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| v_1_1_0_0 := v_1_1_0.Args[0] |
| if v_1_1_0_0.Op != OpAvg32u { |
| break |
| } |
| _ = v_1_1_0_0.Args[1] |
| v_1_1_0_0_0 := v_1_1_0_0.Args[0] |
| if v_1_1_0_0_0.Op != OpLsh32x64 { |
| break |
| } |
| _ = v_1_1_0_0_0.Args[1] |
| v_1_1_0_0_0_0 := v_1_1_0_0_0.Args[0] |
| if v_1_1_0_0_0_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != v_1_1_0_0_0_0.Args[0] { |
| break |
| } |
| v_1_1_0_0_0_1 := v_1_1_0_0_0.Args[1] |
| if v_1_1_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1_0_0_0_1.AuxInt != 16 { |
| break |
| } |
| mul := v_1_1_0_0.Args[1] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16, c).m) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Trunc32to16 (Rsh32Ux64 (Avg32u (Lsh32x64 (ZeroExt16to32 x) (Const64 [16])) mul:(Mul32 (Const32 [m]) (ZeroExt16to32 x))) (Const64 [s]))) (Const16 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16,c).m) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpTrunc32to16 { |
| break |
| } |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| v_1_0_0_0 := v_1_0_0.Args[0] |
| if v_1_0_0_0.Op != OpAvg32u { |
| break |
| } |
| _ = v_1_0_0_0.Args[1] |
| v_1_0_0_0_0 := v_1_0_0_0.Args[0] |
| if v_1_0_0_0_0.Op != OpLsh32x64 { |
| break |
| } |
| _ = v_1_0_0_0_0.Args[1] |
| v_1_0_0_0_0_0 := v_1_0_0_0_0.Args[0] |
| if v_1_0_0_0_0_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != v_1_0_0_0_0_0.Args[0] { |
| break |
| } |
| v_1_0_0_0_0_1 := v_1_0_0_0_0.Args[1] |
| if v_1_0_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_0_0_0_1.AuxInt != 16 { |
| break |
| } |
| mul := v_1_0_0_0.Args[1] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst16 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16, c).m) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Trunc32to16 (Rsh32Ux64 (Avg32u (Lsh32x64 (ZeroExt16to32 x) (Const64 [16])) mul:(Mul32 (ZeroExt16to32 x) (Const32 [m]))) (Const64 [s]))) (Const16 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16,c).m) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpTrunc32to16 { |
| break |
| } |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| v_1_0_0_0 := v_1_0_0.Args[0] |
| if v_1_0_0_0.Op != OpAvg32u { |
| break |
| } |
| _ = v_1_0_0_0.Args[1] |
| v_1_0_0_0_0 := v_1_0_0_0.Args[0] |
| if v_1_0_0_0_0.Op != OpLsh32x64 { |
| break |
| } |
| _ = v_1_0_0_0_0.Args[1] |
| v_1_0_0_0_0_0 := v_1_0_0_0_0.Args[0] |
| if v_1_0_0_0_0_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != v_1_0_0_0_0_0.Args[0] { |
| break |
| } |
| v_1_0_0_0_0_1 := v_1_0_0_0_0.Args[1] |
| if v_1_0_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_0_0_0_1.AuxInt != 16 { |
| break |
| } |
| mul := v_1_0_0_0.Args[1] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst16 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16, c).m) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 (Avg32u (Lsh32x64 (ZeroExt16to32 x) (Const64 [16])) mul:(Mul32 (Const32 [m]) (ZeroExt16to32 x))) (Const64 [s])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16,c).m) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst16 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpTrunc32to16 { |
| break |
| } |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| v_0_1_0_0 := v_0_1_0.Args[0] |
| if v_0_1_0_0.Op != OpAvg32u { |
| break |
| } |
| _ = v_0_1_0_0.Args[1] |
| v_0_1_0_0_0 := v_0_1_0_0.Args[0] |
| if v_0_1_0_0_0.Op != OpLsh32x64 { |
| break |
| } |
| _ = v_0_1_0_0_0.Args[1] |
| v_0_1_0_0_0_0 := v_0_1_0_0_0.Args[0] |
| if v_0_1_0_0_0_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != v_0_1_0_0_0_0.Args[0] { |
| break |
| } |
| v_0_1_0_0_0_1 := v_0_1_0_0_0.Args[1] |
| if v_0_1_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1_0_0_0_1.AuxInt != 16 { |
| break |
| } |
| mul := v_0_1_0_0.Args[1] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16, c).m) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq16_40(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq16 (Mul16 (Const16 [c]) (Trunc32to16 (Rsh32Ux64 (Avg32u (Lsh32x64 (ZeroExt16to32 x) (Const64 [16])) mul:(Mul32 (ZeroExt16to32 x) (Const32 [m]))) (Const64 [s])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16,c).m) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst16 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpTrunc32to16 { |
| break |
| } |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| v_0_1_0_0 := v_0_1_0.Args[0] |
| if v_0_1_0_0.Op != OpAvg32u { |
| break |
| } |
| _ = v_0_1_0_0.Args[1] |
| v_0_1_0_0_0 := v_0_1_0_0.Args[0] |
| if v_0_1_0_0_0.Op != OpLsh32x64 { |
| break |
| } |
| _ = v_0_1_0_0_0.Args[1] |
| v_0_1_0_0_0_0 := v_0_1_0_0_0.Args[0] |
| if v_0_1_0_0_0_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != v_0_1_0_0_0_0.Args[0] { |
| break |
| } |
| v_0_1_0_0_0_1 := v_0_1_0_0_0.Args[1] |
| if v_0_1_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1_0_0_0_1.AuxInt != 16 { |
| break |
| } |
| mul := v_0_1_0_0.Args[1] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16, c).m) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Trunc32to16 (Rsh32Ux64 (Avg32u (Lsh32x64 (ZeroExt16to32 x) (Const64 [16])) mul:(Mul32 (Const32 [m]) (ZeroExt16to32 x))) (Const64 [s]))) (Const16 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16,c).m) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpTrunc32to16 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| v_0_0_0_0 := v_0_0_0.Args[0] |
| if v_0_0_0_0.Op != OpAvg32u { |
| break |
| } |
| _ = v_0_0_0_0.Args[1] |
| v_0_0_0_0_0 := v_0_0_0_0.Args[0] |
| if v_0_0_0_0_0.Op != OpLsh32x64 { |
| break |
| } |
| _ = v_0_0_0_0_0.Args[1] |
| v_0_0_0_0_0_0 := v_0_0_0_0_0.Args[0] |
| if v_0_0_0_0_0_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != v_0_0_0_0_0_0.Args[0] { |
| break |
| } |
| v_0_0_0_0_0_1 := v_0_0_0_0_0.Args[1] |
| if v_0_0_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_0_0_0_1.AuxInt != 16 { |
| break |
| } |
| mul := v_0_0_0_0.Args[1] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst16 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16, c).m) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Trunc32to16 (Rsh32Ux64 (Avg32u (Lsh32x64 (ZeroExt16to32 x) (Const64 [16])) mul:(Mul32 (ZeroExt16to32 x) (Const32 [m]))) (Const64 [s]))) (Const16 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16,c).m) && s == 16+umagic(16,c).s-1 && x.Op != OpConst16 && udivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(16-udivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(udivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpTrunc32to16 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| v_0_0_0_0 := v_0_0_0.Args[0] |
| if v_0_0_0_0.Op != OpAvg32u { |
| break |
| } |
| _ = v_0_0_0_0.Args[1] |
| v_0_0_0_0_0 := v_0_0_0_0.Args[0] |
| if v_0_0_0_0_0.Op != OpLsh32x64 { |
| break |
| } |
| _ = v_0_0_0_0_0.Args[1] |
| v_0_0_0_0_0_0 := v_0_0_0_0_0.Args[0] |
| if v_0_0_0_0_0_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != v_0_0_0_0_0_0.Args[0] { |
| break |
| } |
| v_0_0_0_0_0_1 := v_0_0_0_0_0.Args[1] |
| if v_0_0_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_0_0_0_1.AuxInt != 16 { |
| break |
| } |
| mul := v_0_0_0_0.Args[1] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt16to32 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst16 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(16, c).m) && s == 16+umagic(16, c).s-1 && x.Op != OpConst16 && udivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v2.AuxInt = int64(int16(udivisible(16, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(16 - udivisible(16, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(udivisible(16, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Const16 [c]) (Sub16 (Rsh32x64 mul:(Mul32 (Const32 [m]) (SignExt16to32 x)) (Const64 [s])) (Rsh32x64 (SignExt16to32 x) (Const64 [31]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16,c).m) && s == 16+smagic(16,c).s && x.Op != OpConst16 && sdivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Add16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).a))]) ) (Const16 <typ.UInt16> [int64(16-sdivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst16 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpSub16 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpSignExt16to32 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_1_1.Args[1] |
| v_1_1_1_0 := v_1_1_1.Args[0] |
| if v_1_1_1_0.Op != OpSignExt16to32 { |
| break |
| } |
| if x != v_1_1_1_0.Args[0] { |
| break |
| } |
| v_1_1_1_1 := v_1_1_1.Args[1] |
| if v_1_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1_1_1.AuxInt != 31 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16, c).m) && s == 16+smagic(16, c).s && x.Op != OpConst16 && sdivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpAdd16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(int16(sdivisible(16, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(sdivisible(16, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v5.AuxInt = int64(16 - sdivisible(16, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v6.AuxInt = int64(int16(sdivisible(16, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Const16 [c]) (Sub16 (Rsh32x64 mul:(Mul32 (SignExt16to32 x) (Const32 [m])) (Const64 [s])) (Rsh32x64 (SignExt16to32 x) (Const64 [31]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16,c).m) && s == 16+smagic(16,c).s && x.Op != OpConst16 && sdivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Add16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).a))]) ) (Const16 <typ.UInt16> [int64(16-sdivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst16 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpSub16 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpSignExt16to32 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_1_1.Args[1] |
| v_1_1_1_0 := v_1_1_1.Args[0] |
| if v_1_1_1_0.Op != OpSignExt16to32 { |
| break |
| } |
| if x != v_1_1_1_0.Args[0] { |
| break |
| } |
| v_1_1_1_1 := v_1_1_1.Args[1] |
| if v_1_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1_1_1.AuxInt != 31 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16, c).m) && s == 16+smagic(16, c).s && x.Op != OpConst16 && sdivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpAdd16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(int16(sdivisible(16, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(sdivisible(16, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v5.AuxInt = int64(16 - sdivisible(16, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v6.AuxInt = int64(int16(sdivisible(16, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Sub16 (Rsh32x64 mul:(Mul32 (Const32 [m]) (SignExt16to32 x)) (Const64 [s])) (Rsh32x64 (SignExt16to32 x) (Const64 [31]))) (Const16 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16,c).m) && s == 16+smagic(16,c).s && x.Op != OpConst16 && sdivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Add16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).a))]) ) (Const16 <typ.UInt16> [int64(16-sdivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpSub16 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpSignExt16to32 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0_1.Args[1] |
| v_1_0_1_0 := v_1_0_1.Args[0] |
| if v_1_0_1_0.Op != OpSignExt16to32 { |
| break |
| } |
| if x != v_1_0_1_0.Args[0] { |
| break |
| } |
| v_1_0_1_1 := v_1_0_1.Args[1] |
| if v_1_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_1_1.AuxInt != 31 { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst16 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16, c).m) && s == 16+smagic(16, c).s && x.Op != OpConst16 && sdivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpAdd16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(int16(sdivisible(16, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(sdivisible(16, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v5.AuxInt = int64(16 - sdivisible(16, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v6.AuxInt = int64(int16(sdivisible(16, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq16 x (Mul16 (Sub16 (Rsh32x64 mul:(Mul32 (SignExt16to32 x) (Const32 [m])) (Const64 [s])) (Rsh32x64 (SignExt16to32 x) (Const64 [31]))) (Const16 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16,c).m) && s == 16+smagic(16,c).s && x.Op != OpConst16 && sdivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Add16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).a))]) ) (Const16 <typ.UInt16> [int64(16-sdivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul16 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpSub16 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpSignExt16to32 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0_1.Args[1] |
| v_1_0_1_0 := v_1_0_1.Args[0] |
| if v_1_0_1_0.Op != OpSignExt16to32 { |
| break |
| } |
| if x != v_1_0_1_0.Args[0] { |
| break |
| } |
| v_1_0_1_1 := v_1_0_1.Args[1] |
| if v_1_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_1_1.AuxInt != 31 { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst16 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16, c).m) && s == 16+smagic(16, c).s && x.Op != OpConst16 && sdivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpAdd16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(int16(sdivisible(16, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(sdivisible(16, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v5.AuxInt = int64(16 - sdivisible(16, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v6.AuxInt = int64(int16(sdivisible(16, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Const16 [c]) (Sub16 (Rsh32x64 mul:(Mul32 (Const32 [m]) (SignExt16to32 x)) (Const64 [s])) (Rsh32x64 (SignExt16to32 x) (Const64 [31])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16,c).m) && s == 16+smagic(16,c).s && x.Op != OpConst16 && sdivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Add16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).a))]) ) (Const16 <typ.UInt16> [int64(16-sdivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst16 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpSub16 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| mul := v_0_1_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpSignExt16to32 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_1_1.Args[1] |
| v_0_1_1_0 := v_0_1_1.Args[0] |
| if v_0_1_1_0.Op != OpSignExt16to32 { |
| break |
| } |
| if x != v_0_1_1_0.Args[0] { |
| break |
| } |
| v_0_1_1_1 := v_0_1_1.Args[1] |
| if v_0_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1_1_1.AuxInt != 31 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16, c).m) && s == 16+smagic(16, c).s && x.Op != OpConst16 && sdivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpAdd16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(int16(sdivisible(16, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(sdivisible(16, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v5.AuxInt = int64(16 - sdivisible(16, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v6.AuxInt = int64(int16(sdivisible(16, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Const16 [c]) (Sub16 (Rsh32x64 mul:(Mul32 (SignExt16to32 x) (Const32 [m])) (Const64 [s])) (Rsh32x64 (SignExt16to32 x) (Const64 [31])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16,c).m) && s == 16+smagic(16,c).s && x.Op != OpConst16 && sdivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Add16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).a))]) ) (Const16 <typ.UInt16> [int64(16-sdivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst16 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpSub16 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| mul := v_0_1_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpSignExt16to32 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_1_1.Args[1] |
| v_0_1_1_0 := v_0_1_1.Args[0] |
| if v_0_1_1_0.Op != OpSignExt16to32 { |
| break |
| } |
| if x != v_0_1_1_0.Args[0] { |
| break |
| } |
| v_0_1_1_1 := v_0_1_1.Args[1] |
| if v_0_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1_1_1.AuxInt != 31 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16, c).m) && s == 16+smagic(16, c).s && x.Op != OpConst16 && sdivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpAdd16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(int16(sdivisible(16, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(sdivisible(16, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v5.AuxInt = int64(16 - sdivisible(16, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v6.AuxInt = int64(int16(sdivisible(16, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq16 (Mul16 (Sub16 (Rsh32x64 mul:(Mul32 (Const32 [m]) (SignExt16to32 x)) (Const64 [s])) (Rsh32x64 (SignExt16to32 x) (Const64 [31]))) (Const16 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16,c).m) && s == 16+smagic(16,c).s && x.Op != OpConst16 && sdivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Add16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).a))]) ) (Const16 <typ.UInt16> [int64(16-sdivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpSub16 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| mul := v_0_0_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpSignExt16to32 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0_1.Args[1] |
| v_0_0_1_0 := v_0_0_1.Args[0] |
| if v_0_0_1_0.Op != OpSignExt16to32 { |
| break |
| } |
| if x != v_0_0_1_0.Args[0] { |
| break |
| } |
| v_0_0_1_1 := v_0_0_1.Args[1] |
| if v_0_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_1_1.AuxInt != 31 { |
| break |
| } |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst16 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16, c).m) && s == 16+smagic(16, c).s && x.Op != OpConst16 && sdivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpAdd16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(int16(sdivisible(16, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(sdivisible(16, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v5.AuxInt = int64(16 - sdivisible(16, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v6.AuxInt = int64(int16(sdivisible(16, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq16_50(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq16 (Mul16 (Sub16 (Rsh32x64 mul:(Mul32 (SignExt16to32 x) (Const32 [m])) (Const64 [s])) (Rsh32x64 (SignExt16to32 x) (Const64 [31]))) (Const16 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16,c).m) && s == 16+smagic(16,c).s && x.Op != OpConst16 && sdivisibleOK(16,c) |
| // result: (Leq16U (RotateLeft16 <typ.UInt16> (Add16 <typ.UInt16> (Mul16 <typ.UInt16> (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).m))]) x) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).a))]) ) (Const16 <typ.UInt16> [int64(16-sdivisible(16,c).k)]) ) (Const16 <typ.UInt16> [int64(int16(sdivisible(16,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul16 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpSub16 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| mul := v_0_0_0.Args[0] |
| if mul.Op != OpMul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpSignExt16to32 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0_1.Args[1] |
| v_0_0_1_0 := v_0_0_1.Args[0] |
| if v_0_0_1_0.Op != OpSignExt16to32 { |
| break |
| } |
| if x != v_0_0_1_0.Args[0] { |
| break |
| } |
| v_0_0_1_1 := v_0_0_1.Args[1] |
| if v_0_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_1_1.AuxInt != 31 { |
| break |
| } |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst16 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(16, c).m) && s == 16+smagic(16, c).s && x.Op != OpConst16 && sdivisibleOK(16, c)) { |
| break |
| } |
| v.reset(OpLeq16U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft16, typ.UInt16) |
| v1 := b.NewValue0(v.Pos, OpAdd16, typ.UInt16) |
| v2 := b.NewValue0(v.Pos, OpMul16, typ.UInt16) |
| v3 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v3.AuxInt = int64(int16(sdivisible(16, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v4.AuxInt = int64(int16(sdivisible(16, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v5.AuxInt = int64(16 - sdivisible(16, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) |
| v6.AuxInt = int64(int16(sdivisible(16, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq16 n (Lsh16x64 (Rsh16x64 (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <typ.UInt64> [15])) (Const64 <typ.UInt64> [kbar]))) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k]))) |
| // cond: k > 0 && k < 15 && kbar == 16 - k |
| // result: (Eq16 (And16 <t> n (Const16 <t> [int64(1<<uint(k)-1)])) (Const16 <t> [0])) |
| for { |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpLsh16x64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpRsh16x64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpAdd16 { |
| break |
| } |
| t := v_1_0_0.Type |
| _ = v_1_0_0.Args[1] |
| if n != v_1_0_0.Args[0] { |
| break |
| } |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpRsh16Ux64 { |
| break |
| } |
| if v_1_0_0_1.Type != t { |
| break |
| } |
| _ = v_1_0_0_1.Args[1] |
| v_1_0_0_1_0 := v_1_0_0_1.Args[0] |
| if v_1_0_0_1_0.Op != OpRsh16x64 { |
| break |
| } |
| if v_1_0_0_1_0.Type != t { |
| break |
| } |
| _ = v_1_0_0_1_0.Args[1] |
| if n != v_1_0_0_1_0.Args[0] { |
| break |
| } |
| v_1_0_0_1_0_1 := v_1_0_0_1_0.Args[1] |
| if v_1_0_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_0_1_0_1.Type != typ.UInt64 { |
| break |
| } |
| if v_1_0_0_1_0_1.AuxInt != 15 { |
| break |
| } |
| v_1_0_0_1_1 := v_1_0_0_1.Args[1] |
| if v_1_0_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_0_1_1.Type != typ.UInt64 { |
| break |
| } |
| kbar := v_1_0_0_1_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_1.Type != typ.UInt64 { |
| break |
| } |
| k := v_1_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1.Type != typ.UInt64 { |
| break |
| } |
| if v_1_1.AuxInt != k { |
| break |
| } |
| if !(k > 0 && k < 15 && kbar == 16-k) { |
| break |
| } |
| v.reset(OpEq16) |
| v0 := b.NewValue0(v.Pos, OpAnd16, t) |
| v0.AddArg(n) |
| v1 := b.NewValue0(v.Pos, OpConst16, t) |
| v1.AuxInt = int64(1<<uint(k) - 1) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst16, t) |
| v2.AuxInt = 0 |
| v.AddArg(v2) |
| return true |
| } |
| // match: (Eq16 n (Lsh16x64 (Rsh16x64 (Add16 <t> (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <typ.UInt64> [15])) (Const64 <typ.UInt64> [kbar])) n) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k]))) |
| // cond: k > 0 && k < 15 && kbar == 16 - k |
| // result: (Eq16 (And16 <t> n (Const16 <t> [int64(1<<uint(k)-1)])) (Const16 <t> [0])) |
| for { |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpLsh16x64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpRsh16x64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpAdd16 { |
| break |
| } |
| t := v_1_0_0.Type |
| _ = v_1_0_0.Args[1] |
| v_1_0_0_0 := v_1_0_0.Args[0] |
| if v_1_0_0_0.Op != OpRsh16Ux64 { |
| break |
| } |
| if v_1_0_0_0.Type != t { |
| break |
| } |
| _ = v_1_0_0_0.Args[1] |
| v_1_0_0_0_0 := v_1_0_0_0.Args[0] |
| if v_1_0_0_0_0.Op != OpRsh16x64 { |
| break |
| } |
| if v_1_0_0_0_0.Type != t { |
| break |
| } |
| _ = v_1_0_0_0_0.Args[1] |
| if n != v_1_0_0_0_0.Args[0] { |
| break |
| } |
| v_1_0_0_0_0_1 := v_1_0_0_0_0.Args[1] |
| if v_1_0_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_0_0_0_1.Type != typ.UInt64 { |
| break |
| } |
| if v_1_0_0_0_0_1.AuxInt != 15 { |
| break |
| } |
| v_1_0_0_0_1 := v_1_0_0_0.Args[1] |
| if v_1_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_0_0_1.Type != typ.UInt64 { |
| break |
| } |
| kbar := v_1_0_0_0_1.AuxInt |
| if n != v_1_0_0.Args[1] { |
| break |
| } |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_1.Type != typ.UInt64 { |
| break |
| } |
| k := v_1_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1.Type != typ.UInt64 { |
| break |
| } |
| if v_1_1.AuxInt != k { |
| break |
| } |
| if !(k > 0 && k < 15 && kbar == 16-k) { |
| break |
| } |
| v.reset(OpEq16) |
| v0 := b.NewValue0(v.Pos, OpAnd16, t) |
| v0.AddArg(n) |
| v1 := b.NewValue0(v.Pos, OpConst16, t) |
| v1.AuxInt = int64(1<<uint(k) - 1) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst16, t) |
| v2.AuxInt = 0 |
| v.AddArg(v2) |
| return true |
| } |
| // match: (Eq16 (Lsh16x64 (Rsh16x64 (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <typ.UInt64> [15])) (Const64 <typ.UInt64> [kbar]))) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])) n) |
| // cond: k > 0 && k < 15 && kbar == 16 - k |
| // result: (Eq16 (And16 <t> n (Const16 <t> [int64(1<<uint(k)-1)])) (Const16 <t> [0])) |
| for { |
| n := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpLsh16x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpRsh16x64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpAdd16 { |
| break |
| } |
| t := v_0_0_0.Type |
| _ = v_0_0_0.Args[1] |
| if n != v_0_0_0.Args[0] { |
| break |
| } |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpRsh16Ux64 { |
| break |
| } |
| if v_0_0_0_1.Type != t { |
| break |
| } |
| _ = v_0_0_0_1.Args[1] |
| v_0_0_0_1_0 := v_0_0_0_1.Args[0] |
| if v_0_0_0_1_0.Op != OpRsh16x64 { |
| break |
| } |
| if v_0_0_0_1_0.Type != t { |
| break |
| } |
| _ = v_0_0_0_1_0.Args[1] |
| if n != v_0_0_0_1_0.Args[0] { |
| break |
| } |
| v_0_0_0_1_0_1 := v_0_0_0_1_0.Args[1] |
| if v_0_0_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_0_1_0_1.Type != typ.UInt64 { |
| break |
| } |
| if v_0_0_0_1_0_1.AuxInt != 15 { |
| break |
| } |
| v_0_0_0_1_1 := v_0_0_0_1.Args[1] |
| if v_0_0_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_0_1_1.Type != typ.UInt64 { |
| break |
| } |
| kbar := v_0_0_0_1_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_1.Type != typ.UInt64 { |
| break |
| } |
| k := v_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1.Type != typ.UInt64 { |
| break |
| } |
| if v_0_1.AuxInt != k { |
| break |
| } |
| if !(k > 0 && k < 15 && kbar == 16-k) { |
| break |
| } |
| v.reset(OpEq16) |
| v0 := b.NewValue0(v.Pos, OpAnd16, t) |
| v0.AddArg(n) |
| v1 := b.NewValue0(v.Pos, OpConst16, t) |
| v1.AuxInt = int64(1<<uint(k) - 1) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst16, t) |
| v2.AuxInt = 0 |
| v.AddArg(v2) |
| return true |
| } |
| // match: (Eq16 (Lsh16x64 (Rsh16x64 (Add16 <t> (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <typ.UInt64> [15])) (Const64 <typ.UInt64> [kbar])) n) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])) n) |
| // cond: k > 0 && k < 15 && kbar == 16 - k |
| // result: (Eq16 (And16 <t> n (Const16 <t> [int64(1<<uint(k)-1)])) (Const16 <t> [0])) |
| for { |
| n := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpLsh16x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpRsh16x64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpAdd16 { |
| break |
| } |
| t := v_0_0_0.Type |
| _ = v_0_0_0.Args[1] |
| v_0_0_0_0 := v_0_0_0.Args[0] |
| if v_0_0_0_0.Op != OpRsh16Ux64 { |
| break |
| } |
| if v_0_0_0_0.Type != t { |
| break |
| } |
| _ = v_0_0_0_0.Args[1] |
| v_0_0_0_0_0 := v_0_0_0_0.Args[0] |
| if v_0_0_0_0_0.Op != OpRsh16x64 { |
| break |
| } |
| if v_0_0_0_0_0.Type != t { |
| break |
| } |
| _ = v_0_0_0_0_0.Args[1] |
| if n != v_0_0_0_0_0.Args[0] { |
| break |
| } |
| v_0_0_0_0_0_1 := v_0_0_0_0_0.Args[1] |
| if v_0_0_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_0_0_0_1.Type != typ.UInt64 { |
| break |
| } |
| if v_0_0_0_0_0_1.AuxInt != 15 { |
| break |
| } |
| v_0_0_0_0_1 := v_0_0_0_0.Args[1] |
| if v_0_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_0_0_1.Type != typ.UInt64 { |
| break |
| } |
| kbar := v_0_0_0_0_1.AuxInt |
| if n != v_0_0_0.Args[1] { |
| break |
| } |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_1.Type != typ.UInt64 { |
| break |
| } |
| k := v_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1.Type != typ.UInt64 { |
| break |
| } |
| if v_0_1.AuxInt != k { |
| break |
| } |
| if !(k > 0 && k < 15 && kbar == 16-k) { |
| break |
| } |
| v.reset(OpEq16) |
| v0 := b.NewValue0(v.Pos, OpAnd16, t) |
| v0.AddArg(n) |
| v1 := b.NewValue0(v.Pos, OpConst16, t) |
| v1.AuxInt = int64(1<<uint(k) - 1) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst16, t) |
| v2.AuxInt = 0 |
| v.AddArg(v2) |
| return true |
| } |
| // match: (Eq16 s:(Sub16 x y) (Const16 [0])) |
| // cond: s.Uses == 1 |
| // result: (Eq16 x y) |
| for { |
| _ = v.Args[1] |
| s := v.Args[0] |
| if s.Op != OpSub16 { |
| break |
| } |
| y := s.Args[1] |
| x := s.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst16 { |
| break |
| } |
| if v_1.AuxInt != 0 { |
| break |
| } |
| if !(s.Uses == 1) { |
| break |
| } |
| v.reset(OpEq16) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (Eq16 (Const16 [0]) s:(Sub16 x y)) |
| // cond: s.Uses == 1 |
| // result: (Eq16 x y) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst16 { |
| break |
| } |
| if v_0.AuxInt != 0 { |
| break |
| } |
| s := v.Args[1] |
| if s.Op != OpSub16 { |
| break |
| } |
| y := s.Args[1] |
| x := s.Args[0] |
| if !(s.Uses == 1) { |
| break |
| } |
| v.reset(OpEq16) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq32_0(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq32 x x) |
| // cond: |
| // result: (ConstBool [1]) |
| for { |
| x := v.Args[1] |
| if x != v.Args[0] { |
| break |
| } |
| v.reset(OpConstBool) |
| v.AuxInt = 1 |
| return true |
| } |
| // match: (Eq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x)) |
| // cond: |
| // result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd32 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| if v_1_0.Type != t { |
| break |
| } |
| d := v_1_0.AuxInt |
| v.reset(OpEq32) |
| v0 := b.NewValue0(v.Pos, OpConst32, t) |
| v0.AuxInt = int64(int32(c - d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Eq32 (Const32 <t> [c]) (Add32 x (Const32 <t> [d]))) |
| // cond: |
| // result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd32 { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| if v_1_1.Type != t { |
| break |
| } |
| d := v_1_1.AuxInt |
| v.reset(OpEq32) |
| v0 := b.NewValue0(v.Pos, OpConst32, t) |
| v0.AuxInt = int64(int32(c - d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Eq32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c])) |
| // cond: |
| // result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd32 { |
| break |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| t := v_0_0.Type |
| d := v_0_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpEq32) |
| v0 := b.NewValue0(v.Pos, OpConst32, t) |
| v0.AuxInt = int64(int32(c - d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Eq32 (Add32 x (Const32 <t> [d])) (Const32 <t> [c])) |
| // cond: |
| // result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| t := v_0_1.Type |
| d := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpEq32) |
| v0 := b.NewValue0(v.Pos, OpConst32, t) |
| v0.AuxInt = int64(int32(c - d)) |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Eq32 (Const32 [c]) (Const32 [d])) |
| // cond: |
| // result: (ConstBool [b2i(c == d)]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| d := v_1.AuxInt |
| v.reset(OpConstBool) |
| v.AuxInt = b2i(c == d) |
| return true |
| } |
| // match: (Eq32 (Const32 [d]) (Const32 [c])) |
| // cond: |
| // result: (ConstBool [b2i(c == d)]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| d := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpConstBool) |
| v.AuxInt = b2i(c == d) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Rsh32Ux64 mul:(Hmul32u (Const32 [m]) x) (Const64 [s])))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32,c).m/2)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| mul := v_1_1.Args[0] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32, c).m/2)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Rsh32Ux64 mul:(Hmul32u x (Const32 [m])) (Const64 [s])))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32,c).m/2)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| mul := v_1_1.Args[0] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32, c).m/2)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Rsh32Ux64 mul:(Hmul32u (Const32 [m]) x) (Const64 [s])) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32,c).m/2)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| mul := v_1_0.Args[0] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32, c).m/2)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq32_10(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq32 x (Mul32 (Rsh32Ux64 mul:(Hmul32u x (Const32 [m])) (Const64 [s])) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32,c).m/2)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| mul := v_1_0.Args[0] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32, c).m/2)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Rsh32Ux64 mul:(Hmul32u (Const32 [m]) x) (Const64 [s]))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32,c).m/2)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| mul := v_0_1.Args[0] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32, c).m/2)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Rsh32Ux64 mul:(Hmul32u x (Const32 [m])) (Const64 [s]))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32,c).m/2)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| mul := v_0_1.Args[0] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32, c).m/2)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Rsh32Ux64 mul:(Hmul32u (Const32 [m]) x) (Const64 [s])) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32,c).m/2)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| mul := v_0_0.Args[0] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32, c).m/2)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Rsh32Ux64 mul:(Hmul32u x (Const32 [m])) (Const64 [s])) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32,c).m/2)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| mul := v_0_0.Args[0] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+umagic(32, c).m/2)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Rsh32Ux64 mul:(Hmul32u (Const32 <typ.UInt32> [m]) (Rsh32Ux64 x (Const64 [1]))) (Const64 [s])))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32,c).m+1)/2)) && s == umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| mul := v_1_1.Args[0] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| if mul_0.Type != typ.UInt32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = mul_1.Args[1] |
| if x != mul_1.Args[0] { |
| break |
| } |
| mul_1_1 := mul_1.Args[1] |
| if mul_1_1.Op != OpConst64 { |
| break |
| } |
| if mul_1_1.AuxInt != 1 { |
| break |
| } |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32, c).m+1)/2)) && s == umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Rsh32Ux64 mul:(Hmul32u (Rsh32Ux64 x (Const64 [1])) (Const32 <typ.UInt32> [m])) (Const64 [s])))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32,c).m+1)/2)) && s == umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| mul := v_1_1.Args[0] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = mul_0.Args[1] |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_0_1 := mul_0.Args[1] |
| if mul_0_1.Op != OpConst64 { |
| break |
| } |
| if mul_0_1.AuxInt != 1 { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| if mul_1.Type != typ.UInt32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32, c).m+1)/2)) && s == umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Rsh32Ux64 mul:(Hmul32u (Const32 <typ.UInt32> [m]) (Rsh32Ux64 x (Const64 [1]))) (Const64 [s])) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32,c).m+1)/2)) && s == umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| mul := v_1_0.Args[0] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| if mul_0.Type != typ.UInt32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = mul_1.Args[1] |
| if x != mul_1.Args[0] { |
| break |
| } |
| mul_1_1 := mul_1.Args[1] |
| if mul_1_1.Op != OpConst64 { |
| break |
| } |
| if mul_1_1.AuxInt != 1 { |
| break |
| } |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32, c).m+1)/2)) && s == umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Rsh32Ux64 mul:(Hmul32u (Rsh32Ux64 x (Const64 [1])) (Const32 <typ.UInt32> [m])) (Const64 [s])) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32,c).m+1)/2)) && s == umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| mul := v_1_0.Args[0] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = mul_0.Args[1] |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_0_1 := mul_0.Args[1] |
| if mul_0_1.Op != OpConst64 { |
| break |
| } |
| if mul_0_1.AuxInt != 1 { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| if mul_1.Type != typ.UInt32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32, c).m+1)/2)) && s == umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Rsh32Ux64 mul:(Hmul32u (Const32 <typ.UInt32> [m]) (Rsh32Ux64 x (Const64 [1]))) (Const64 [s]))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32,c).m+1)/2)) && s == umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| mul := v_0_1.Args[0] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| if mul_0.Type != typ.UInt32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = mul_1.Args[1] |
| if x != mul_1.Args[0] { |
| break |
| } |
| mul_1_1 := mul_1.Args[1] |
| if mul_1_1.Op != OpConst64 { |
| break |
| } |
| if mul_1_1.AuxInt != 1 { |
| break |
| } |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32, c).m+1)/2)) && s == umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq32_20(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq32 (Mul32 (Const32 [c]) (Rsh32Ux64 mul:(Hmul32u (Rsh32Ux64 x (Const64 [1])) (Const32 <typ.UInt32> [m])) (Const64 [s]))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32,c).m+1)/2)) && s == umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| mul := v_0_1.Args[0] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = mul_0.Args[1] |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_0_1 := mul_0.Args[1] |
| if mul_0_1.Op != OpConst64 { |
| break |
| } |
| if mul_0_1.AuxInt != 1 { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| if mul_1.Type != typ.UInt32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32, c).m+1)/2)) && s == umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Rsh32Ux64 mul:(Hmul32u (Const32 <typ.UInt32> [m]) (Rsh32Ux64 x (Const64 [1]))) (Const64 [s])) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32,c).m+1)/2)) && s == umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| mul := v_0_0.Args[0] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| if mul_0.Type != typ.UInt32 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = mul_1.Args[1] |
| if x != mul_1.Args[0] { |
| break |
| } |
| mul_1_1 := mul_1.Args[1] |
| if mul_1_1.Op != OpConst64 { |
| break |
| } |
| if mul_1_1.AuxInt != 1 { |
| break |
| } |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32, c).m+1)/2)) && s == umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Rsh32Ux64 mul:(Hmul32u (Rsh32Ux64 x (Const64 [1])) (Const32 <typ.UInt32> [m])) (Const64 [s])) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32,c).m+1)/2)) && s == umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| mul := v_0_0.Args[0] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = mul_0.Args[1] |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_0_1 := mul_0.Args[1] |
| if mul_0_1.Op != OpConst64 { |
| break |
| } |
| if mul_0_1.AuxInt != 1 { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| if mul_1.Type != typ.UInt32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(1<<31+(umagic(32, c).m+1)/2)) && s == umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Rsh32Ux64 (Avg32u x mul:(Hmul32u (Const32 [m]) x)) (Const64 [s])))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32,c).m)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpAvg32u { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| if x != v_1_1_0.Args[0] { |
| break |
| } |
| mul := v_1_1_0.Args[1] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32, c).m)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Rsh32Ux64 (Avg32u x mul:(Hmul32u x (Const32 [m]))) (Const64 [s])))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32,c).m)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpAvg32u { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| if x != v_1_1_0.Args[0] { |
| break |
| } |
| mul := v_1_1_0.Args[1] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32, c).m)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Rsh32Ux64 (Avg32u x mul:(Hmul32u (Const32 [m]) x)) (Const64 [s])) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32,c).m)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpAvg32u { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| if x != v_1_0_0.Args[0] { |
| break |
| } |
| mul := v_1_0_0.Args[1] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32, c).m)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Rsh32Ux64 (Avg32u x mul:(Hmul32u x (Const32 [m]))) (Const64 [s])) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32,c).m)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpAvg32u { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| if x != v_1_0_0.Args[0] { |
| break |
| } |
| mul := v_1_0_0.Args[1] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32, c).m)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Rsh32Ux64 (Avg32u x mul:(Hmul32u (Const32 [m]) x)) (Const64 [s]))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32,c).m)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpAvg32u { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| if x != v_0_1_0.Args[0] { |
| break |
| } |
| mul := v_0_1_0.Args[1] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32, c).m)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Rsh32Ux64 (Avg32u x mul:(Hmul32u x (Const32 [m]))) (Const64 [s]))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32,c).m)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpAvg32u { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| if x != v_0_1_0.Args[0] { |
| break |
| } |
| mul := v_0_1_0.Args[1] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32, c).m)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Rsh32Ux64 (Avg32u x mul:(Hmul32u (Const32 [m]) x)) (Const64 [s])) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32,c).m)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpAvg32u { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| if x != v_0_0_0.Args[0] { |
| break |
| } |
| mul := v_0_0_0.Args[1] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32, c).m)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq32_30(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq32 (Mul32 (Rsh32Ux64 (Avg32u x mul:(Hmul32u x (Const32 [m]))) (Const64 [s])) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32,c).m)) && s == umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpAvg32u { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| if x != v_0_0_0.Args[0] { |
| break |
| } |
| mul := v_0_0_0.Args[1] |
| if mul.Op != OpHmul32u { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(umagic(32, c).m)) && s == umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (ZeroExt32to64 x)) (Const64 [s]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32,c).m/2) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpTrunc64to32 { |
| break |
| } |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32, c).m/2) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (ZeroExt32to64 x) (Const64 [m])) (Const64 [s]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32,c).m/2) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpTrunc64to32 { |
| break |
| } |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32, c).m/2) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (ZeroExt32to64 x)) (Const64 [s]))) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32,c).m/2) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpTrunc64to32 { |
| break |
| } |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32, c).m/2) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (ZeroExt32to64 x) (Const64 [m])) (Const64 [s]))) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32,c).m/2) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpTrunc64to32 { |
| break |
| } |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32, c).m/2) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (ZeroExt32to64 x)) (Const64 [s])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32,c).m/2) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpTrunc64to32 { |
| break |
| } |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| mul := v_0_1_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32, c).m/2) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (ZeroExt32to64 x) (Const64 [m])) (Const64 [s])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32,c).m/2) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpTrunc64to32 { |
| break |
| } |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| mul := v_0_1_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32, c).m/2) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (ZeroExt32to64 x)) (Const64 [s]))) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32,c).m/2) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpTrunc64to32 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| mul := v_0_0_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32, c).m/2) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (ZeroExt32to64 x) (Const64 [m])) (Const64 [s]))) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32,c).m/2) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpTrunc64to32 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| mul := v_0_0_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+umagic(32, c).m/2) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (Rsh64Ux64 (ZeroExt32to64 x) (Const64 [1]))) (Const64 [s]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32,c).m+1)/2) && s == 32+umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpTrunc64to32 { |
| break |
| } |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = mul_1.Args[1] |
| mul_1_0 := mul_1.Args[0] |
| if mul_1_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_1_0.Args[0] { |
| break |
| } |
| mul_1_1 := mul_1.Args[1] |
| if mul_1_1.Op != OpConst64 { |
| break |
| } |
| if mul_1_1.AuxInt != 1 { |
| break |
| } |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32, c).m+1)/2) && s == 32+umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq32_40(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Rsh64Ux64 (ZeroExt32to64 x) (Const64 [1])) (Const64 [m])) (Const64 [s]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32,c).m+1)/2) && s == 32+umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpTrunc64to32 { |
| break |
| } |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = mul_0.Args[1] |
| mul_0_0 := mul_0.Args[0] |
| if mul_0_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_0_0.Args[0] { |
| break |
| } |
| mul_0_1 := mul_0.Args[1] |
| if mul_0_1.Op != OpConst64 { |
| break |
| } |
| if mul_0_1.AuxInt != 1 { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32, c).m+1)/2) && s == 32+umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (Rsh64Ux64 (ZeroExt32to64 x) (Const64 [1]))) (Const64 [s]))) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32,c).m+1)/2) && s == 32+umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpTrunc64to32 { |
| break |
| } |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = mul_1.Args[1] |
| mul_1_0 := mul_1.Args[0] |
| if mul_1_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_1_0.Args[0] { |
| break |
| } |
| mul_1_1 := mul_1.Args[1] |
| if mul_1_1.Op != OpConst64 { |
| break |
| } |
| if mul_1_1.AuxInt != 1 { |
| break |
| } |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32, c).m+1)/2) && s == 32+umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Rsh64Ux64 (ZeroExt32to64 x) (Const64 [1])) (Const64 [m])) (Const64 [s]))) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32,c).m+1)/2) && s == 32+umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpTrunc64to32 { |
| break |
| } |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = mul_0.Args[1] |
| mul_0_0 := mul_0.Args[0] |
| if mul_0_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_0_0.Args[0] { |
| break |
| } |
| mul_0_1 := mul_0.Args[1] |
| if mul_0_1.Op != OpConst64 { |
| break |
| } |
| if mul_0_1.AuxInt != 1 { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32, c).m+1)/2) && s == 32+umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (Rsh64Ux64 (ZeroExt32to64 x) (Const64 [1]))) (Const64 [s])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32,c).m+1)/2) && s == 32+umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpTrunc64to32 { |
| break |
| } |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| mul := v_0_1_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = mul_1.Args[1] |
| mul_1_0 := mul_1.Args[0] |
| if mul_1_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_1_0.Args[0] { |
| break |
| } |
| mul_1_1 := mul_1.Args[1] |
| if mul_1_1.Op != OpConst64 { |
| break |
| } |
| if mul_1_1.AuxInt != 1 { |
| break |
| } |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32, c).m+1)/2) && s == 32+umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Rsh64Ux64 (ZeroExt32to64 x) (Const64 [1])) (Const64 [m])) (Const64 [s])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32,c).m+1)/2) && s == 32+umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpTrunc64to32 { |
| break |
| } |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| mul := v_0_1_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = mul_0.Args[1] |
| mul_0_0 := mul_0.Args[0] |
| if mul_0_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_0_0.Args[0] { |
| break |
| } |
| mul_0_1 := mul_0.Args[1] |
| if mul_0_1.Op != OpConst64 { |
| break |
| } |
| if mul_0_1.AuxInt != 1 { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32, c).m+1)/2) && s == 32+umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Const64 [m]) (Rsh64Ux64 (ZeroExt32to64 x) (Const64 [1]))) (Const64 [s]))) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32,c).m+1)/2) && s == 32+umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpTrunc64to32 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| mul := v_0_0_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = mul_1.Args[1] |
| mul_1_0 := mul_1.Args[0] |
| if mul_1_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_1_0.Args[0] { |
| break |
| } |
| mul_1_1 := mul_1.Args[1] |
| if mul_1_1.Op != OpConst64 { |
| break |
| } |
| if mul_1_1.AuxInt != 1 { |
| break |
| } |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32, c).m+1)/2) && s == 32+umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Trunc64to32 (Rsh64Ux64 mul:(Mul64 (Rsh64Ux64 (ZeroExt32to64 x) (Const64 [1])) (Const64 [m])) (Const64 [s]))) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32,c).m+1)/2) && s == 32+umagic(32,c).s-2 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpTrunc64to32 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| mul := v_0_0_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = mul_0.Args[1] |
| mul_0_0 := mul_0.Args[0] |
| if mul_0_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_0_0.Args[0] { |
| break |
| } |
| mul_0_1 := mul_0.Args[1] |
| if mul_0_1.Op != OpConst64 { |
| break |
| } |
| if mul_0_1.AuxInt != 1 { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<31+(umagic(32, c).m+1)/2) && s == 32+umagic(32, c).s-2 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 (Avg64u (Lsh64x64 (ZeroExt32to64 x) (Const64 [32])) mul:(Mul64 (Const64 [m]) (ZeroExt32to64 x))) (Const64 [s]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32,c).m) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpTrunc64to32 { |
| break |
| } |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| v_1_1_0_0 := v_1_1_0.Args[0] |
| if v_1_1_0_0.Op != OpAvg64u { |
| break |
| } |
| _ = v_1_1_0_0.Args[1] |
| v_1_1_0_0_0 := v_1_1_0_0.Args[0] |
| if v_1_1_0_0_0.Op != OpLsh64x64 { |
| break |
| } |
| _ = v_1_1_0_0_0.Args[1] |
| v_1_1_0_0_0_0 := v_1_1_0_0_0.Args[0] |
| if v_1_1_0_0_0_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != v_1_1_0_0_0_0.Args[0] { |
| break |
| } |
| v_1_1_0_0_0_1 := v_1_1_0_0_0.Args[1] |
| if v_1_1_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1_0_0_0_1.AuxInt != 32 { |
| break |
| } |
| mul := v_1_1_0_0.Args[1] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32, c).m) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 (Avg64u (Lsh64x64 (ZeroExt32to64 x) (Const64 [32])) mul:(Mul64 (ZeroExt32to64 x) (Const64 [m]))) (Const64 [s]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32,c).m) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpTrunc64to32 { |
| break |
| } |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| v_1_1_0_0 := v_1_1_0.Args[0] |
| if v_1_1_0_0.Op != OpAvg64u { |
| break |
| } |
| _ = v_1_1_0_0.Args[1] |
| v_1_1_0_0_0 := v_1_1_0_0.Args[0] |
| if v_1_1_0_0_0.Op != OpLsh64x64 { |
| break |
| } |
| _ = v_1_1_0_0_0.Args[1] |
| v_1_1_0_0_0_0 := v_1_1_0_0_0.Args[0] |
| if v_1_1_0_0_0_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != v_1_1_0_0_0_0.Args[0] { |
| break |
| } |
| v_1_1_0_0_0_1 := v_1_1_0_0_0.Args[1] |
| if v_1_1_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1_0_0_0_1.AuxInt != 32 { |
| break |
| } |
| mul := v_1_1_0_0.Args[1] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32, c).m) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Trunc64to32 (Rsh64Ux64 (Avg64u (Lsh64x64 (ZeroExt32to64 x) (Const64 [32])) mul:(Mul64 (Const64 [m]) (ZeroExt32to64 x))) (Const64 [s]))) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32,c).m) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpTrunc64to32 { |
| break |
| } |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| v_1_0_0_0 := v_1_0_0.Args[0] |
| if v_1_0_0_0.Op != OpAvg64u { |
| break |
| } |
| _ = v_1_0_0_0.Args[1] |
| v_1_0_0_0_0 := v_1_0_0_0.Args[0] |
| if v_1_0_0_0_0.Op != OpLsh64x64 { |
| break |
| } |
| _ = v_1_0_0_0_0.Args[1] |
| v_1_0_0_0_0_0 := v_1_0_0_0_0.Args[0] |
| if v_1_0_0_0_0_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != v_1_0_0_0_0_0.Args[0] { |
| break |
| } |
| v_1_0_0_0_0_1 := v_1_0_0_0_0.Args[1] |
| if v_1_0_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_0_0_0_1.AuxInt != 32 { |
| break |
| } |
| mul := v_1_0_0_0.Args[1] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32, c).m) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq32_50(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq32 x (Mul32 (Trunc64to32 (Rsh64Ux64 (Avg64u (Lsh64x64 (ZeroExt32to64 x) (Const64 [32])) mul:(Mul64 (ZeroExt32to64 x) (Const64 [m]))) (Const64 [s]))) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32,c).m) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpTrunc64to32 { |
| break |
| } |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| v_1_0_0_0 := v_1_0_0.Args[0] |
| if v_1_0_0_0.Op != OpAvg64u { |
| break |
| } |
| _ = v_1_0_0_0.Args[1] |
| v_1_0_0_0_0 := v_1_0_0_0.Args[0] |
| if v_1_0_0_0_0.Op != OpLsh64x64 { |
| break |
| } |
| _ = v_1_0_0_0_0.Args[1] |
| v_1_0_0_0_0_0 := v_1_0_0_0_0.Args[0] |
| if v_1_0_0_0_0_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != v_1_0_0_0_0_0.Args[0] { |
| break |
| } |
| v_1_0_0_0_0_1 := v_1_0_0_0_0.Args[1] |
| if v_1_0_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_0_0_0_1.AuxInt != 32 { |
| break |
| } |
| mul := v_1_0_0_0.Args[1] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32, c).m) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 (Avg64u (Lsh64x64 (ZeroExt32to64 x) (Const64 [32])) mul:(Mul64 (Const64 [m]) (ZeroExt32to64 x))) (Const64 [s])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32,c).m) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpTrunc64to32 { |
| break |
| } |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| v_0_1_0_0 := v_0_1_0.Args[0] |
| if v_0_1_0_0.Op != OpAvg64u { |
| break |
| } |
| _ = v_0_1_0_0.Args[1] |
| v_0_1_0_0_0 := v_0_1_0_0.Args[0] |
| if v_0_1_0_0_0.Op != OpLsh64x64 { |
| break |
| } |
| _ = v_0_1_0_0_0.Args[1] |
| v_0_1_0_0_0_0 := v_0_1_0_0_0.Args[0] |
| if v_0_1_0_0_0_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != v_0_1_0_0_0_0.Args[0] { |
| break |
| } |
| v_0_1_0_0_0_1 := v_0_1_0_0_0.Args[1] |
| if v_0_1_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1_0_0_0_1.AuxInt != 32 { |
| break |
| } |
| mul := v_0_1_0_0.Args[1] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32, c).m) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Trunc64to32 (Rsh64Ux64 (Avg64u (Lsh64x64 (ZeroExt32to64 x) (Const64 [32])) mul:(Mul64 (ZeroExt32to64 x) (Const64 [m]))) (Const64 [s])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32,c).m) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpTrunc64to32 { |
| break |
| } |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| v_0_1_0_0 := v_0_1_0.Args[0] |
| if v_0_1_0_0.Op != OpAvg64u { |
| break |
| } |
| _ = v_0_1_0_0.Args[1] |
| v_0_1_0_0_0 := v_0_1_0_0.Args[0] |
| if v_0_1_0_0_0.Op != OpLsh64x64 { |
| break |
| } |
| _ = v_0_1_0_0_0.Args[1] |
| v_0_1_0_0_0_0 := v_0_1_0_0_0.Args[0] |
| if v_0_1_0_0_0_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != v_0_1_0_0_0_0.Args[0] { |
| break |
| } |
| v_0_1_0_0_0_1 := v_0_1_0_0_0.Args[1] |
| if v_0_1_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1_0_0_0_1.AuxInt != 32 { |
| break |
| } |
| mul := v_0_1_0_0.Args[1] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32, c).m) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Trunc64to32 (Rsh64Ux64 (Avg64u (Lsh64x64 (ZeroExt32to64 x) (Const64 [32])) mul:(Mul64 (Const64 [m]) (ZeroExt32to64 x))) (Const64 [s]))) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32,c).m) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpTrunc64to32 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| v_0_0_0_0 := v_0_0_0.Args[0] |
| if v_0_0_0_0.Op != OpAvg64u { |
| break |
| } |
| _ = v_0_0_0_0.Args[1] |
| v_0_0_0_0_0 := v_0_0_0_0.Args[0] |
| if v_0_0_0_0_0.Op != OpLsh64x64 { |
| break |
| } |
| _ = v_0_0_0_0_0.Args[1] |
| v_0_0_0_0_0_0 := v_0_0_0_0_0.Args[0] |
| if v_0_0_0_0_0_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != v_0_0_0_0_0_0.Args[0] { |
| break |
| } |
| v_0_0_0_0_0_1 := v_0_0_0_0_0.Args[1] |
| if v_0_0_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_0_0_0_1.AuxInt != 32 { |
| break |
| } |
| mul := v_0_0_0_0.Args[1] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32, c).m) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Trunc64to32 (Rsh64Ux64 (Avg64u (Lsh64x64 (ZeroExt32to64 x) (Const64 [32])) mul:(Mul64 (ZeroExt32to64 x) (Const64 [m]))) (Const64 [s]))) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32,c).m) && s == 32+umagic(32,c).s-1 && x.Op != OpConst32 && udivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(32-udivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(udivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpTrunc64to32 { |
| break |
| } |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| v_0_0_0_0 := v_0_0_0.Args[0] |
| if v_0_0_0_0.Op != OpAvg64u { |
| break |
| } |
| _ = v_0_0_0_0.Args[1] |
| v_0_0_0_0_0 := v_0_0_0_0.Args[0] |
| if v_0_0_0_0_0.Op != OpLsh64x64 { |
| break |
| } |
| _ = v_0_0_0_0_0.Args[1] |
| v_0_0_0_0_0_0 := v_0_0_0_0_0.Args[0] |
| if v_0_0_0_0_0_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != v_0_0_0_0_0_0.Args[0] { |
| break |
| } |
| v_0_0_0_0_0_1 := v_0_0_0_0_0.Args[1] |
| if v_0_0_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_0_0_0_1.AuxInt != 32 { |
| break |
| } |
| mul := v_0_0_0_0.Args[1] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpZeroExt32to64 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(32, c).m) && s == 32+umagic(32, c).s-1 && x.Op != OpConst32 && udivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v2.AuxInt = int64(int32(udivisible(32, c).m)) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(32 - udivisible(32, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(udivisible(32, c).max)) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh64x64 mul:(Mul64 (Const64 [m]) (SignExt32to64 x)) (Const64 [s])) (Rsh64x64 (SignExt32to64 x) (Const64 [63]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32,c).m) && s == 32+smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpSub32 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpSignExt32to64 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_1_1_1.Args[1] |
| v_1_1_1_0 := v_1_1_1.Args[0] |
| if v_1_1_1_0.Op != OpSignExt32to64 { |
| break |
| } |
| if x != v_1_1_1_0.Args[0] { |
| break |
| } |
| v_1_1_1_1 := v_1_1_1.Args[1] |
| if v_1_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1_1_1.AuxInt != 63 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32, c).m) && s == 32+smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh64x64 mul:(Mul64 (SignExt32to64 x) (Const64 [m])) (Const64 [s])) (Rsh64x64 (SignExt32to64 x) (Const64 [63]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32,c).m) && s == 32+smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpSub32 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpSignExt32to64 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_1_1_1.Args[1] |
| v_1_1_1_0 := v_1_1_1.Args[0] |
| if v_1_1_1_0.Op != OpSignExt32to64 { |
| break |
| } |
| if x != v_1_1_1_0.Args[0] { |
| break |
| } |
| v_1_1_1_1 := v_1_1_1.Args[1] |
| if v_1_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1_1_1.AuxInt != 63 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32, c).m) && s == 32+smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Sub32 (Rsh64x64 mul:(Mul64 (Const64 [m]) (SignExt32to64 x)) (Const64 [s])) (Rsh64x64 (SignExt32to64 x) (Const64 [63]))) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32,c).m) && s == 32+smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpSub32 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpSignExt32to64 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_1_0_1.Args[1] |
| v_1_0_1_0 := v_1_0_1.Args[0] |
| if v_1_0_1_0.Op != OpSignExt32to64 { |
| break |
| } |
| if x != v_1_0_1_0.Args[0] { |
| break |
| } |
| v_1_0_1_1 := v_1_0_1.Args[1] |
| if v_1_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_1_1.AuxInt != 63 { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32, c).m) && s == 32+smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Sub32 (Rsh64x64 mul:(Mul64 (SignExt32to64 x) (Const64 [m])) (Const64 [s])) (Rsh64x64 (SignExt32to64 x) (Const64 [63]))) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32,c).m) && s == 32+smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpSub32 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpSignExt32to64 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_1_0_1.Args[1] |
| v_1_0_1_0 := v_1_0_1.Args[0] |
| if v_1_0_1_0.Op != OpSignExt32to64 { |
| break |
| } |
| if x != v_1_0_1_0.Args[0] { |
| break |
| } |
| v_1_0_1_1 := v_1_0_1.Args[1] |
| if v_1_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_1_1.AuxInt != 63 { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32, c).m) && s == 32+smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Sub32 (Rsh64x64 mul:(Mul64 (Const64 [m]) (SignExt32to64 x)) (Const64 [s])) (Rsh64x64 (SignExt32to64 x) (Const64 [63])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32,c).m) && s == 32+smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpSub32 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| mul := v_0_1_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpSignExt32to64 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_0_1_1.Args[1] |
| v_0_1_1_0 := v_0_1_1.Args[0] |
| if v_0_1_1_0.Op != OpSignExt32to64 { |
| break |
| } |
| if x != v_0_1_1_0.Args[0] { |
| break |
| } |
| v_0_1_1_1 := v_0_1_1.Args[1] |
| if v_0_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1_1_1.AuxInt != 63 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32, c).m) && s == 32+smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq32_60(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq32 (Mul32 (Const32 [c]) (Sub32 (Rsh64x64 mul:(Mul64 (SignExt32to64 x) (Const64 [m])) (Const64 [s])) (Rsh64x64 (SignExt32to64 x) (Const64 [63])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32,c).m) && s == 32+smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpSub32 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| mul := v_0_1_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpSignExt32to64 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_0_1_1.Args[1] |
| v_0_1_1_0 := v_0_1_1.Args[0] |
| if v_0_1_1_0.Op != OpSignExt32to64 { |
| break |
| } |
| if x != v_0_1_1_0.Args[0] { |
| break |
| } |
| v_0_1_1_1 := v_0_1_1.Args[1] |
| if v_0_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1_1_1.AuxInt != 63 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32, c).m) && s == 32+smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Sub32 (Rsh64x64 mul:(Mul64 (Const64 [m]) (SignExt32to64 x)) (Const64 [s])) (Rsh64x64 (SignExt32to64 x) (Const64 [63]))) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32,c).m) && s == 32+smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpSub32 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| mul := v_0_0_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpSignExt32to64 { |
| break |
| } |
| if x != mul_1.Args[0] { |
| break |
| } |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_0_0_1.Args[1] |
| v_0_0_1_0 := v_0_0_1.Args[0] |
| if v_0_0_1_0.Op != OpSignExt32to64 { |
| break |
| } |
| if x != v_0_0_1_0.Args[0] { |
| break |
| } |
| v_0_0_1_1 := v_0_0_1.Args[1] |
| if v_0_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_1_1.AuxInt != 63 { |
| break |
| } |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32, c).m) && s == 32+smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Sub32 (Rsh64x64 mul:(Mul64 (SignExt32to64 x) (Const64 [m])) (Const64 [s])) (Rsh64x64 (SignExt32to64 x) (Const64 [63]))) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32,c).m) && s == 32+smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpSub32 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| mul := v_0_0_0.Args[0] |
| if mul.Op != OpMul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpSignExt32to64 { |
| break |
| } |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_0_0_1.Args[1] |
| v_0_0_1_0 := v_0_0_1.Args[0] |
| if v_0_0_1_0.Op != OpSignExt32to64 { |
| break |
| } |
| if x != v_0_0_1_0.Args[0] { |
| break |
| } |
| v_0_0_1_1 := v_0_0_1.Args[1] |
| if v_0_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_1_1.AuxInt != 63 { |
| break |
| } |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(32, c).m) && s == 32+smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 mul:(Hmul32 (Const32 [m]) x) (Const64 [s])) (Rsh32x64 x (Const64 [31]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpSub32 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_1_1.Args[1] |
| if x != v_1_1_1.Args[0] { |
| break |
| } |
| v_1_1_1_1 := v_1_1_1.Args[1] |
| if v_1_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1_1_1.AuxInt != 31 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m/2)) && s == smagic(32, c).s-1 && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 mul:(Hmul32 x (Const32 [m])) (Const64 [s])) (Rsh32x64 x (Const64 [31]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpSub32 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_1_1.Args[1] |
| if x != v_1_1_1.Args[0] { |
| break |
| } |
| v_1_1_1_1 := v_1_1_1.Args[1] |
| if v_1_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1_1_1.AuxInt != 31 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m/2)) && s == smagic(32, c).s-1 && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Sub32 (Rsh32x64 mul:(Hmul32 (Const32 [m]) x) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpSub32 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0_1.Args[1] |
| if x != v_1_0_1.Args[0] { |
| break |
| } |
| v_1_0_1_1 := v_1_0_1.Args[1] |
| if v_1_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_1_1.AuxInt != 31 { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m/2)) && s == smagic(32, c).s-1 && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Sub32 (Rsh32x64 mul:(Hmul32 x (Const32 [m])) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpSub32 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0_1.Args[1] |
| if x != v_1_0_1.Args[0] { |
| break |
| } |
| v_1_0_1_1 := v_1_0_1.Args[1] |
| if v_1_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_1_1.AuxInt != 31 { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m/2)) && s == smagic(32, c).s-1 && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 mul:(Hmul32 (Const32 [m]) x) (Const64 [s])) (Rsh32x64 x (Const64 [31])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpSub32 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| mul := v_0_1_0.Args[0] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_1_1.Args[1] |
| if x != v_0_1_1.Args[0] { |
| break |
| } |
| v_0_1_1_1 := v_0_1_1.Args[1] |
| if v_0_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1_1_1.AuxInt != 31 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m/2)) && s == smagic(32, c).s-1 && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 mul:(Hmul32 x (Const32 [m])) (Const64 [s])) (Rsh32x64 x (Const64 [31])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpSub32 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| mul := v_0_1_0.Args[0] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_1_1.Args[1] |
| if x != v_0_1_1.Args[0] { |
| break |
| } |
| v_0_1_1_1 := v_0_1_1.Args[1] |
| if v_0_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1_1_1.AuxInt != 31 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m/2)) && s == smagic(32, c).s-1 && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Sub32 (Rsh32x64 mul:(Hmul32 (Const32 [m]) x) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpSub32 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| mul := v_0_0_0.Args[0] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0_1.Args[1] |
| if x != v_0_0_1.Args[0] { |
| break |
| } |
| v_0_0_1_1 := v_0_0_1.Args[1] |
| if v_0_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_1_1.AuxInt != 31 { |
| break |
| } |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m/2)) && s == smagic(32, c).s-1 && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq32_70(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq32 (Mul32 (Sub32 (Rsh32x64 mul:(Hmul32 x (Const32 [m])) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpSub32 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| mul := v_0_0_0.Args[0] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0_1.Args[1] |
| if x != v_0_0_1.Args[0] { |
| break |
| } |
| v_0_0_1_1 := v_0_0_1.Args[1] |
| if v_0_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_1_1.AuxInt != 31 { |
| break |
| } |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m/2)) && s == smagic(32, c).s-1 && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 (Add32 mul:(Hmul32 (Const32 [m]) x) x) (Const64 [s])) (Rsh32x64 x (Const64 [31]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpSub32 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| v_1_1_0_0 := v_1_1_0.Args[0] |
| if v_1_1_0_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_1_1_0_0.Args[1] |
| mul := v_1_1_0_0.Args[0] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| if x != v_1_1_0_0.Args[1] { |
| break |
| } |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_1_1.Args[1] |
| if x != v_1_1_1.Args[0] { |
| break |
| } |
| v_1_1_1_1 := v_1_1_1.Args[1] |
| if v_1_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1_1_1.AuxInt != 31 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 (Add32 mul:(Hmul32 x (Const32 [m])) x) (Const64 [s])) (Rsh32x64 x (Const64 [31]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpSub32 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| v_1_1_0_0 := v_1_1_0.Args[0] |
| if v_1_1_0_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_1_1_0_0.Args[1] |
| mul := v_1_1_0_0.Args[0] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| if x != v_1_1_0_0.Args[1] { |
| break |
| } |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_1_1.Args[1] |
| if x != v_1_1_1.Args[0] { |
| break |
| } |
| v_1_1_1_1 := v_1_1_1.Args[1] |
| if v_1_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1_1_1.AuxInt != 31 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 (Add32 x mul:(Hmul32 (Const32 [m]) x)) (Const64 [s])) (Rsh32x64 x (Const64 [31]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpSub32 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| v_1_1_0_0 := v_1_1_0.Args[0] |
| if v_1_1_0_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_1_1_0_0.Args[1] |
| if x != v_1_1_0_0.Args[0] { |
| break |
| } |
| mul := v_1_1_0_0.Args[1] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_1_1.Args[1] |
| if x != v_1_1_1.Args[0] { |
| break |
| } |
| v_1_1_1_1 := v_1_1_1.Args[1] |
| if v_1_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1_1_1.AuxInt != 31 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 (Add32 x mul:(Hmul32 x (Const32 [m]))) (Const64 [s])) (Rsh32x64 x (Const64 [31]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst32 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpSub32 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| v_1_1_0_0 := v_1_1_0.Args[0] |
| if v_1_1_0_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_1_1_0_0.Args[1] |
| if x != v_1_1_0_0.Args[0] { |
| break |
| } |
| mul := v_1_1_0_0.Args[1] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_1_1.Args[1] |
| if x != v_1_1_1.Args[0] { |
| break |
| } |
| v_1_1_1_1 := v_1_1_1.Args[1] |
| if v_1_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1_1_1.AuxInt != 31 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Sub32 (Rsh32x64 (Add32 mul:(Hmul32 (Const32 [m]) x) x) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpSub32 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| v_1_0_0_0 := v_1_0_0.Args[0] |
| if v_1_0_0_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_1_0_0_0.Args[1] |
| mul := v_1_0_0_0.Args[0] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| if x != v_1_0_0_0.Args[1] { |
| break |
| } |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0_1.Args[1] |
| if x != v_1_0_1.Args[0] { |
| break |
| } |
| v_1_0_1_1 := v_1_0_1.Args[1] |
| if v_1_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_1_1.AuxInt != 31 { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Sub32 (Rsh32x64 (Add32 mul:(Hmul32 x (Const32 [m])) x) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpSub32 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| v_1_0_0_0 := v_1_0_0.Args[0] |
| if v_1_0_0_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_1_0_0_0.Args[1] |
| mul := v_1_0_0_0.Args[0] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| if x != v_1_0_0_0.Args[1] { |
| break |
| } |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0_1.Args[1] |
| if x != v_1_0_1.Args[0] { |
| break |
| } |
| v_1_0_1_1 := v_1_0_1.Args[1] |
| if v_1_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_1_1.AuxInt != 31 { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Sub32 (Rsh32x64 (Add32 x mul:(Hmul32 (Const32 [m]) x)) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpSub32 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| v_1_0_0_0 := v_1_0_0.Args[0] |
| if v_1_0_0_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_1_0_0_0.Args[1] |
| if x != v_1_0_0_0.Args[0] { |
| break |
| } |
| mul := v_1_0_0_0.Args[1] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0_1.Args[1] |
| if x != v_1_0_1.Args[0] { |
| break |
| } |
| v_1_0_1_1 := v_1_0_1.Args[1] |
| if v_1_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_1_1.AuxInt != 31 { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 x (Mul32 (Sub32 (Rsh32x64 (Add32 x mul:(Hmul32 x (Const32 [m]))) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul32 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpSub32 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| v_1_0_0_0 := v_1_0_0.Args[0] |
| if v_1_0_0_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_1_0_0_0.Args[1] |
| if x != v_1_0_0_0.Args[0] { |
| break |
| } |
| mul := v_1_0_0_0.Args[1] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0_1.Args[1] |
| if x != v_1_0_1.Args[0] { |
| break |
| } |
| v_1_0_1_1 := v_1_0_1.Args[1] |
| if v_1_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_1_1.AuxInt != 31 { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst32 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 (Add32 mul:(Hmul32 (Const32 [m]) x) x) (Const64 [s])) (Rsh32x64 x (Const64 [31])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpSub32 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| v_0_1_0_0 := v_0_1_0.Args[0] |
| if v_0_1_0_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_0_1_0_0.Args[1] |
| mul := v_0_1_0_0.Args[0] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| if x != v_0_1_0_0.Args[1] { |
| break |
| } |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_1_1.Args[1] |
| if x != v_0_1_1.Args[0] { |
| break |
| } |
| v_0_1_1_1 := v_0_1_1.Args[1] |
| if v_0_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1_1_1.AuxInt != 31 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq32_80(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq32 (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 (Add32 mul:(Hmul32 x (Const32 [m])) x) (Const64 [s])) (Rsh32x64 x (Const64 [31])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpSub32 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| v_0_1_0_0 := v_0_1_0.Args[0] |
| if v_0_1_0_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_0_1_0_0.Args[1] |
| mul := v_0_1_0_0.Args[0] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| if x != v_0_1_0_0.Args[1] { |
| break |
| } |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_1_1.Args[1] |
| if x != v_0_1_1.Args[0] { |
| break |
| } |
| v_0_1_1_1 := v_0_1_1.Args[1] |
| if v_0_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1_1_1.AuxInt != 31 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 (Add32 x mul:(Hmul32 (Const32 [m]) x)) (Const64 [s])) (Rsh32x64 x (Const64 [31])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpSub32 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| v_0_1_0_0 := v_0_1_0.Args[0] |
| if v_0_1_0_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_0_1_0_0.Args[1] |
| if x != v_0_1_0_0.Args[0] { |
| break |
| } |
| mul := v_0_1_0_0.Args[1] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_1_1.Args[1] |
| if x != v_0_1_1.Args[0] { |
| break |
| } |
| v_0_1_1_1 := v_0_1_1.Args[1] |
| if v_0_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1_1_1.AuxInt != 31 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 (Add32 x mul:(Hmul32 x (Const32 [m]))) (Const64 [s])) (Rsh32x64 x (Const64 [31])))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst32 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpSub32 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| v_0_1_0_0 := v_0_1_0.Args[0] |
| if v_0_1_0_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_0_1_0_0.Args[1] |
| if x != v_0_1_0_0.Args[0] { |
| break |
| } |
| mul := v_0_1_0_0.Args[1] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_0_1 := v_0_1_0.Args[1] |
| if v_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_0_1.AuxInt |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_1_1.Args[1] |
| if x != v_0_1_1.Args[0] { |
| break |
| } |
| v_0_1_1_1 := v_0_1_1.Args[1] |
| if v_0_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1_1_1.AuxInt != 31 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Sub32 (Rsh32x64 (Add32 mul:(Hmul32 (Const32 [m]) x) x) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpSub32 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| v_0_0_0_0 := v_0_0_0.Args[0] |
| if v_0_0_0_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_0_0_0_0.Args[1] |
| mul := v_0_0_0_0.Args[0] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| if x != v_0_0_0_0.Args[1] { |
| break |
| } |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0_1.Args[1] |
| if x != v_0_0_1.Args[0] { |
| break |
| } |
| v_0_0_1_1 := v_0_0_1.Args[1] |
| if v_0_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_1_1.AuxInt != 31 { |
| break |
| } |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Sub32 (Rsh32x64 (Add32 mul:(Hmul32 x (Const32 [m])) x) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpSub32 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| v_0_0_0_0 := v_0_0_0.Args[0] |
| if v_0_0_0_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_0_0_0_0.Args[1] |
| mul := v_0_0_0_0.Args[0] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| if x != v_0_0_0_0.Args[1] { |
| break |
| } |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0_1.Args[1] |
| if x != v_0_0_1.Args[0] { |
| break |
| } |
| v_0_0_1_1 := v_0_0_1.Args[1] |
| if v_0_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_1_1.AuxInt != 31 { |
| break |
| } |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Sub32 (Rsh32x64 (Add32 x mul:(Hmul32 (Const32 [m]) x)) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpSub32 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| v_0_0_0_0 := v_0_0_0.Args[0] |
| if v_0_0_0_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_0_0_0_0.Args[1] |
| if x != v_0_0_0_0.Args[0] { |
| break |
| } |
| mul := v_0_0_0_0.Args[1] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst32 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0_1.Args[1] |
| if x != v_0_0_1.Args[0] { |
| break |
| } |
| v_0_0_1_1 := v_0_0_1.Args[1] |
| if v_0_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_1_1.AuxInt != 31 { |
| break |
| } |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 (Mul32 (Sub32 (Rsh32x64 (Add32 x mul:(Hmul32 x (Const32 [m]))) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) (Const32 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m)) && s == smagic(32,c).s && x.Op != OpConst32 && sdivisibleOK(32,c) |
| // result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul32 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpSub32 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| v_0_0_0_0 := v_0_0_0.Args[0] |
| if v_0_0_0_0.Op != OpAdd32 { |
| break |
| } |
| _ = v_0_0_0_0.Args[1] |
| if x != v_0_0_0_0.Args[0] { |
| break |
| } |
| mul := v_0_0_0_0.Args[1] |
| if mul.Op != OpHmul32 { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst32 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_0_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0_1.Args[1] |
| if x != v_0_0_1.Args[0] { |
| break |
| } |
| v_0_0_1_1 := v_0_0_1.Args[1] |
| if v_0_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_1_1.AuxInt != 31 { |
| break |
| } |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst32 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32, c).m)) && s == smagic(32, c).s && x.Op != OpConst32 && sdivisibleOK(32, c)) { |
| break |
| } |
| v.reset(OpLeq32U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v3.AuxInt = int64(int32(sdivisible(32, c).m)) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v4.AuxInt = int64(int32(sdivisible(32, c).a)) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v5.AuxInt = int64(32 - sdivisible(32, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) |
| v6.AuxInt = int64(int32(sdivisible(32, c).max)) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq32 n (Lsh32x64 (Rsh32x64 (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <typ.UInt64> [31])) (Const64 <typ.UInt64> [kbar]))) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k]))) |
| // cond: k > 0 && k < 31 && kbar == 32 - k |
| // result: (Eq32 (And32 <t> n (Const32 <t> [int64(1<<uint(k)-1)])) (Const32 <t> [0])) |
| for { |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpLsh32x64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpAdd32 { |
| break |
| } |
| t := v_1_0_0.Type |
| _ = v_1_0_0.Args[1] |
| if n != v_1_0_0.Args[0] { |
| break |
| } |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpRsh32Ux64 { |
| break |
| } |
| if v_1_0_0_1.Type != t { |
| break |
| } |
| _ = v_1_0_0_1.Args[1] |
| v_1_0_0_1_0 := v_1_0_0_1.Args[0] |
| if v_1_0_0_1_0.Op != OpRsh32x64 { |
| break |
| } |
| if v_1_0_0_1_0.Type != t { |
| break |
| } |
| _ = v_1_0_0_1_0.Args[1] |
| if n != v_1_0_0_1_0.Args[0] { |
| break |
| } |
| v_1_0_0_1_0_1 := v_1_0_0_1_0.Args[1] |
| if v_1_0_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_0_1_0_1.Type != typ.UInt64 { |
| break |
| } |
| if v_1_0_0_1_0_1.AuxInt != 31 { |
| break |
| } |
| v_1_0_0_1_1 := v_1_0_0_1.Args[1] |
| if v_1_0_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_0_1_1.Type != typ.UInt64 { |
| break |
| } |
| kbar := v_1_0_0_1_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_1.Type != typ.UInt64 { |
| break |
| } |
| k := v_1_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1.Type != typ.UInt64 { |
| break |
| } |
| if v_1_1.AuxInt != k { |
| break |
| } |
| if !(k > 0 && k < 31 && kbar == 32-k) { |
| break |
| } |
| v.reset(OpEq32) |
| v0 := b.NewValue0(v.Pos, OpAnd32, t) |
| v0.AddArg(n) |
| v1 := b.NewValue0(v.Pos, OpConst32, t) |
| v1.AuxInt = int64(1<<uint(k) - 1) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst32, t) |
| v2.AuxInt = 0 |
| v.AddArg(v2) |
| return true |
| } |
| // match: (Eq32 n (Lsh32x64 (Rsh32x64 (Add32 <t> (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <typ.UInt64> [31])) (Const64 <typ.UInt64> [kbar])) n) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k]))) |
| // cond: k > 0 && k < 31 && kbar == 32 - k |
| // result: (Eq32 (And32 <t> n (Const32 <t> [int64(1<<uint(k)-1)])) (Const32 <t> [0])) |
| for { |
| _ = v.Args[1] |
| n := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpLsh32x64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpAdd32 { |
| break |
| } |
| t := v_1_0_0.Type |
| _ = v_1_0_0.Args[1] |
| v_1_0_0_0 := v_1_0_0.Args[0] |
| if v_1_0_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| if v_1_0_0_0.Type != t { |
| break |
| } |
| _ = v_1_0_0_0.Args[1] |
| v_1_0_0_0_0 := v_1_0_0_0.Args[0] |
| if v_1_0_0_0_0.Op != OpRsh32x64 { |
| break |
| } |
| if v_1_0_0_0_0.Type != t { |
| break |
| } |
| _ = v_1_0_0_0_0.Args[1] |
| if n != v_1_0_0_0_0.Args[0] { |
| break |
| } |
| v_1_0_0_0_0_1 := v_1_0_0_0_0.Args[1] |
| if v_1_0_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_0_0_0_1.Type != typ.UInt64 { |
| break |
| } |
| if v_1_0_0_0_0_1.AuxInt != 31 { |
| break |
| } |
| v_1_0_0_0_1 := v_1_0_0_0.Args[1] |
| if v_1_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_0_0_1.Type != typ.UInt64 { |
| break |
| } |
| kbar := v_1_0_0_0_1.AuxInt |
| if n != v_1_0_0.Args[1] { |
| break |
| } |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_1.Type != typ.UInt64 { |
| break |
| } |
| k := v_1_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1.Type != typ.UInt64 { |
| break |
| } |
| if v_1_1.AuxInt != k { |
| break |
| } |
| if !(k > 0 && k < 31 && kbar == 32-k) { |
| break |
| } |
| v.reset(OpEq32) |
| v0 := b.NewValue0(v.Pos, OpAnd32, t) |
| v0.AddArg(n) |
| v1 := b.NewValue0(v.Pos, OpConst32, t) |
| v1.AuxInt = int64(1<<uint(k) - 1) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst32, t) |
| v2.AuxInt = 0 |
| v.AddArg(v2) |
| return true |
| } |
| // match: (Eq32 (Lsh32x64 (Rsh32x64 (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <typ.UInt64> [31])) (Const64 <typ.UInt64> [kbar]))) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])) n) |
| // cond: k > 0 && k < 31 && kbar == 32 - k |
| // result: (Eq32 (And32 <t> n (Const32 <t> [int64(1<<uint(k)-1)])) (Const32 <t> [0])) |
| for { |
| n := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpLsh32x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpAdd32 { |
| break |
| } |
| t := v_0_0_0.Type |
| _ = v_0_0_0.Args[1] |
| if n != v_0_0_0.Args[0] { |
| break |
| } |
| v_0_0_0_1 := v_0_0_0.Args[1] |
| if v_0_0_0_1.Op != OpRsh32Ux64 { |
| break |
| } |
| if v_0_0_0_1.Type != t { |
| break |
| } |
| _ = v_0_0_0_1.Args[1] |
| v_0_0_0_1_0 := v_0_0_0_1.Args[0] |
| if v_0_0_0_1_0.Op != OpRsh32x64 { |
| break |
| } |
| if v_0_0_0_1_0.Type != t { |
| break |
| } |
| _ = v_0_0_0_1_0.Args[1] |
| if n != v_0_0_0_1_0.Args[0] { |
| break |
| } |
| v_0_0_0_1_0_1 := v_0_0_0_1_0.Args[1] |
| if v_0_0_0_1_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_0_1_0_1.Type != typ.UInt64 { |
| break |
| } |
| if v_0_0_0_1_0_1.AuxInt != 31 { |
| break |
| } |
| v_0_0_0_1_1 := v_0_0_0_1.Args[1] |
| if v_0_0_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_0_1_1.Type != typ.UInt64 { |
| break |
| } |
| kbar := v_0_0_0_1_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_1.Type != typ.UInt64 { |
| break |
| } |
| k := v_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1.Type != typ.UInt64 { |
| break |
| } |
| if v_0_1.AuxInt != k { |
| break |
| } |
| if !(k > 0 && k < 31 && kbar == 32-k) { |
| break |
| } |
| v.reset(OpEq32) |
| v0 := b.NewValue0(v.Pos, OpAnd32, t) |
| v0.AddArg(n) |
| v1 := b.NewValue0(v.Pos, OpConst32, t) |
| v1.AuxInt = int64(1<<uint(k) - 1) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst32, t) |
| v2.AuxInt = 0 |
| v.AddArg(v2) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq32_90(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq32 (Lsh32x64 (Rsh32x64 (Add32 <t> (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <typ.UInt64> [31])) (Const64 <typ.UInt64> [kbar])) n) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])) n) |
| // cond: k > 0 && k < 31 && kbar == 32 - k |
| // result: (Eq32 (And32 <t> n (Const32 <t> [int64(1<<uint(k)-1)])) (Const32 <t> [0])) |
| for { |
| n := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpLsh32x64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpRsh32x64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpAdd32 { |
| break |
| } |
| t := v_0_0_0.Type |
| _ = v_0_0_0.Args[1] |
| v_0_0_0_0 := v_0_0_0.Args[0] |
| if v_0_0_0_0.Op != OpRsh32Ux64 { |
| break |
| } |
| if v_0_0_0_0.Type != t { |
| break |
| } |
| _ = v_0_0_0_0.Args[1] |
| v_0_0_0_0_0 := v_0_0_0_0.Args[0] |
| if v_0_0_0_0_0.Op != OpRsh32x64 { |
| break |
| } |
| if v_0_0_0_0_0.Type != t { |
| break |
| } |
| _ = v_0_0_0_0_0.Args[1] |
| if n != v_0_0_0_0_0.Args[0] { |
| break |
| } |
| v_0_0_0_0_0_1 := v_0_0_0_0_0.Args[1] |
| if v_0_0_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_0_0_0_1.Type != typ.UInt64 { |
| break |
| } |
| if v_0_0_0_0_0_1.AuxInt != 31 { |
| break |
| } |
| v_0_0_0_0_1 := v_0_0_0_0.Args[1] |
| if v_0_0_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_0_0_1.Type != typ.UInt64 { |
| break |
| } |
| kbar := v_0_0_0_0_1.AuxInt |
| if n != v_0_0_0.Args[1] { |
| break |
| } |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_0_1.Type != typ.UInt64 { |
| break |
| } |
| k := v_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| if v_0_1.Type != typ.UInt64 { |
| break |
| } |
| if v_0_1.AuxInt != k { |
| break |
| } |
| if !(k > 0 && k < 31 && kbar == 32-k) { |
| break |
| } |
| v.reset(OpEq32) |
| v0 := b.NewValue0(v.Pos, OpAnd32, t) |
| v0.AddArg(n) |
| v1 := b.NewValue0(v.Pos, OpConst32, t) |
| v1.AuxInt = int64(1<<uint(k) - 1) |
| v0.AddArg(v1) |
| v.AddArg(v0) |
| v2 := b.NewValue0(v.Pos, OpConst32, t) |
| v2.AuxInt = 0 |
| v.AddArg(v2) |
| return true |
| } |
| // match: (Eq32 s:(Sub32 x y) (Const32 [0])) |
| // cond: s.Uses == 1 |
| // result: (Eq32 x y) |
| for { |
| _ = v.Args[1] |
| s := v.Args[0] |
| if s.Op != OpSub32 { |
| break |
| } |
| y := s.Args[1] |
| x := s.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32 { |
| break |
| } |
| if v_1.AuxInt != 0 { |
| break |
| } |
| if !(s.Uses == 1) { |
| break |
| } |
| v.reset(OpEq32) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| // match: (Eq32 (Const32 [0]) s:(Sub32 x y)) |
| // cond: s.Uses == 1 |
| // result: (Eq32 x y) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32 { |
| break |
| } |
| if v_0.AuxInt != 0 { |
| break |
| } |
| s := v.Args[1] |
| if s.Op != OpSub32 { |
| break |
| } |
| y := s.Args[1] |
| x := s.Args[0] |
| if !(s.Uses == 1) { |
| break |
| } |
| v.reset(OpEq32) |
| v.AddArg(x) |
| v.AddArg(y) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq32F_0(v *Value) bool { |
| // match: (Eq32F (Const32F [c]) (Const32F [d])) |
| // cond: |
| // result: (ConstBool [b2i(auxTo32F(c) == auxTo32F(d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32F { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32F { |
| break |
| } |
| d := v_1.AuxInt |
| v.reset(OpConstBool) |
| v.AuxInt = b2i(auxTo32F(c) == auxTo32F(d)) |
| return true |
| } |
| // match: (Eq32F (Const32F [d]) (Const32F [c])) |
| // cond: |
| // result: (ConstBool [b2i(auxTo32F(c) == auxTo32F(d))]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst32F { |
| break |
| } |
| d := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst32F { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpConstBool) |
| v.AuxInt = b2i(auxTo32F(c) == auxTo32F(d)) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq64_0(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq64 x x) |
| // cond: |
| // result: (ConstBool [1]) |
| for { |
| x := v.Args[1] |
| if x != v.Args[0] { |
| break |
| } |
| v.reset(OpConstBool) |
| v.AuxInt = 1 |
| return true |
| } |
| // match: (Eq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x)) |
| // cond: |
| // result: (Eq64 (Const64 <t> [c-d]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd64 { |
| break |
| } |
| x := v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst64 { |
| break |
| } |
| if v_1_0.Type != t { |
| break |
| } |
| d := v_1_0.AuxInt |
| v.reset(OpEq64) |
| v0 := b.NewValue0(v.Pos, OpConst64, t) |
| v0.AuxInt = c - d |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Eq64 (Const64 <t> [c]) (Add64 x (Const64 <t> [d]))) |
| // cond: |
| // result: (Eq64 (Const64 <t> [c-d]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| t := v_0.Type |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpAdd64 { |
| break |
| } |
| _ = v_1.Args[1] |
| x := v_1.Args[0] |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1.Type != t { |
| break |
| } |
| d := v_1_1.AuxInt |
| v.reset(OpEq64) |
| v0 := b.NewValue0(v.Pos, OpConst64, t) |
| v0.AuxInt = c - d |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Eq64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c])) |
| // cond: |
| // result: (Eq64 (Const64 <t> [c-d]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd64 { |
| break |
| } |
| x := v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst64 { |
| break |
| } |
| t := v_0_0.Type |
| d := v_0_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpEq64) |
| v0 := b.NewValue0(v.Pos, OpConst64, t) |
| v0.AuxInt = c - d |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Eq64 (Add64 x (Const64 <t> [d])) (Const64 <t> [c])) |
| // cond: |
| // result: (Eq64 (Const64 <t> [c-d]) x) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpAdd64 { |
| break |
| } |
| _ = v_0.Args[1] |
| x := v_0.Args[0] |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| t := v_0_1.Type |
| d := v_0_1.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| if v_1.Type != t { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpEq64) |
| v0 := b.NewValue0(v.Pos, OpConst64, t) |
| v0.AuxInt = c - d |
| v.AddArg(v0) |
| v.AddArg(x) |
| return true |
| } |
| // match: (Eq64 (Const64 [c]) (Const64 [d])) |
| // cond: |
| // result: (ConstBool [b2i(c == d)]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| c := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| d := v_1.AuxInt |
| v.reset(OpConstBool) |
| v.AuxInt = b2i(c == d) |
| return true |
| } |
| // match: (Eq64 (Const64 [d]) (Const64 [c])) |
| // cond: |
| // result: (ConstBool [b2i(c == d)]) |
| for { |
| _ = v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpConst64 { |
| break |
| } |
| d := v_0.AuxInt |
| v_1 := v.Args[1] |
| if v_1.Op != OpConst64 { |
| break |
| } |
| c := v_1.AuxInt |
| v.reset(OpConstBool) |
| v.AuxInt = b2i(c == d) |
| return true |
| } |
| // match: (Eq64 x (Mul64 (Const64 [c]) (Rsh64Ux64 mul:(Hmul64u (Const64 [m]) x) (Const64 [s])))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64,c).m/2) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst64 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| mul := v_1_1.Args[0] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64, c).m/2) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 x (Mul64 (Const64 [c]) (Rsh64Ux64 mul:(Hmul64u x (Const64 [m])) (Const64 [s])))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64,c).m/2) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst64 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| mul := v_1_1.Args[0] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64, c).m/2) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 x (Mul64 (Rsh64Ux64 mul:(Hmul64u (Const64 [m]) x) (Const64 [s])) (Const64 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64,c).m/2) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| mul := v_1_0.Args[0] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64, c).m/2) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq64_10(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq64 x (Mul64 (Rsh64Ux64 mul:(Hmul64u x (Const64 [m])) (Const64 [s])) (Const64 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64,c).m/2) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| mul := v_1_0.Args[0] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64, c).m/2) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 (Mul64 (Const64 [c]) (Rsh64Ux64 mul:(Hmul64u (Const64 [m]) x) (Const64 [s]))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64,c).m/2) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst64 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| mul := v_0_1.Args[0] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64, c).m/2) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 (Mul64 (Const64 [c]) (Rsh64Ux64 mul:(Hmul64u x (Const64 [m])) (Const64 [s]))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64,c).m/2) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst64 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| mul := v_0_1.Args[0] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64, c).m/2) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 (Mul64 (Rsh64Ux64 mul:(Hmul64u (Const64 [m]) x) (Const64 [s])) (Const64 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64,c).m/2) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| mul := v_0_0.Args[0] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64, c).m/2) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 (Mul64 (Rsh64Ux64 mul:(Hmul64u x (Const64 [m])) (Const64 [s])) (Const64 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64,c).m/2) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| mul := v_0_0.Args[0] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+umagic(64, c).m/2) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 x (Mul64 (Const64 [c]) (Rsh64Ux64 mul:(Hmul64u (Const64 [m]) (Rsh64Ux64 x (Const64 [1]))) (Const64 [s])))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64,c).m+1)/2) && s == umagic(64,c).s-2 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst64 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| mul := v_1_1.Args[0] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = mul_1.Args[1] |
| if x != mul_1.Args[0] { |
| break |
| } |
| mul_1_1 := mul_1.Args[1] |
| if mul_1_1.Op != OpConst64 { |
| break |
| } |
| if mul_1_1.AuxInt != 1 { |
| break |
| } |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64, c).m+1)/2) && s == umagic(64, c).s-2 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 x (Mul64 (Const64 [c]) (Rsh64Ux64 mul:(Hmul64u (Rsh64Ux64 x (Const64 [1])) (Const64 [m])) (Const64 [s])))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64,c).m+1)/2) && s == umagic(64,c).s-2 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst64 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| mul := v_1_1.Args[0] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = mul_0.Args[1] |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_0_1 := mul_0.Args[1] |
| if mul_0_1.Op != OpConst64 { |
| break |
| } |
| if mul_0_1.AuxInt != 1 { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64, c).m+1)/2) && s == umagic(64, c).s-2 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 x (Mul64 (Rsh64Ux64 mul:(Hmul64u (Const64 [m]) (Rsh64Ux64 x (Const64 [1]))) (Const64 [s])) (Const64 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64,c).m+1)/2) && s == umagic(64,c).s-2 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| mul := v_1_0.Args[0] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = mul_1.Args[1] |
| if x != mul_1.Args[0] { |
| break |
| } |
| mul_1_1 := mul_1.Args[1] |
| if mul_1_1.Op != OpConst64 { |
| break |
| } |
| if mul_1_1.AuxInt != 1 { |
| break |
| } |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64, c).m+1)/2) && s == umagic(64, c).s-2 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 x (Mul64 (Rsh64Ux64 mul:(Hmul64u (Rsh64Ux64 x (Const64 [1])) (Const64 [m])) (Const64 [s])) (Const64 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64,c).m+1)/2) && s == umagic(64,c).s-2 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| mul := v_1_0.Args[0] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = mul_0.Args[1] |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_0_1 := mul_0.Args[1] |
| if mul_0_1.Op != OpConst64 { |
| break |
| } |
| if mul_0_1.AuxInt != 1 { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64, c).m+1)/2) && s == umagic(64, c).s-2 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 (Mul64 (Const64 [c]) (Rsh64Ux64 mul:(Hmul64u (Const64 [m]) (Rsh64Ux64 x (Const64 [1]))) (Const64 [s]))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64,c).m+1)/2) && s == umagic(64,c).s-2 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst64 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| mul := v_0_1.Args[0] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = mul_1.Args[1] |
| if x != mul_1.Args[0] { |
| break |
| } |
| mul_1_1 := mul_1.Args[1] |
| if mul_1_1.Op != OpConst64 { |
| break |
| } |
| if mul_1_1.AuxInt != 1 { |
| break |
| } |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64, c).m+1)/2) && s == umagic(64, c).s-2 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq64_20(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq64 (Mul64 (Const64 [c]) (Rsh64Ux64 mul:(Hmul64u (Rsh64Ux64 x (Const64 [1])) (Const64 [m])) (Const64 [s]))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64,c).m+1)/2) && s == umagic(64,c).s-2 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst64 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| mul := v_0_1.Args[0] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = mul_0.Args[1] |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_0_1 := mul_0.Args[1] |
| if mul_0_1.Op != OpConst64 { |
| break |
| } |
| if mul_0_1.AuxInt != 1 { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64, c).m+1)/2) && s == umagic(64, c).s-2 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 (Mul64 (Rsh64Ux64 mul:(Hmul64u (Const64 [m]) (Rsh64Ux64 x (Const64 [1]))) (Const64 [s])) (Const64 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64,c).m+1)/2) && s == umagic(64,c).s-2 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| mul := v_0_0.Args[0] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = mul_1.Args[1] |
| if x != mul_1.Args[0] { |
| break |
| } |
| mul_1_1 := mul_1.Args[1] |
| if mul_1_1.Op != OpConst64 { |
| break |
| } |
| if mul_1_1.AuxInt != 1 { |
| break |
| } |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64, c).m+1)/2) && s == umagic(64, c).s-2 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 (Mul64 (Rsh64Ux64 mul:(Hmul64u (Rsh64Ux64 x (Const64 [1])) (Const64 [m])) (Const64 [s])) (Const64 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64,c).m+1)/2) && s == umagic(64,c).s-2 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| mul := v_0_0.Args[0] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = mul_0.Args[1] |
| if x != mul_0.Args[0] { |
| break |
| } |
| mul_0_1 := mul_0.Args[1] |
| if mul_0_1.Op != OpConst64 { |
| break |
| } |
| if mul_0_1.AuxInt != 1 { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(1<<63+(umagic(64, c).m+1)/2) && s == umagic(64, c).s-2 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 x (Mul64 (Const64 [c]) (Rsh64Ux64 (Avg64u x mul:(Hmul64u (Const64 [m]) x)) (Const64 [s])))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64,c).m) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst64 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpAvg64u { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| if x != v_1_1_0.Args[0] { |
| break |
| } |
| mul := v_1_1_0.Args[1] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64, c).m) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 x (Mul64 (Const64 [c]) (Rsh64Ux64 (Avg64u x mul:(Hmul64u x (Const64 [m]))) (Const64 [s])))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64,c).m) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst64 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpAvg64u { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| if x != v_1_1_0.Args[0] { |
| break |
| } |
| mul := v_1_1_0.Args[1] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64, c).m) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 x (Mul64 (Rsh64Ux64 (Avg64u x mul:(Hmul64u (Const64 [m]) x)) (Const64 [s])) (Const64 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64,c).m) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpAvg64u { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| if x != v_1_0_0.Args[0] { |
| break |
| } |
| mul := v_1_0_0.Args[1] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64, c).m) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 x (Mul64 (Rsh64Ux64 (Avg64u x mul:(Hmul64u x (Const64 [m]))) (Const64 [s])) (Const64 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64,c).m) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpAvg64u { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| if x != v_1_0_0.Args[0] { |
| break |
| } |
| mul := v_1_0_0.Args[1] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_1.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64, c).m) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 (Mul64 (Const64 [c]) (Rsh64Ux64 (Avg64u x mul:(Hmul64u (Const64 [m]) x)) (Const64 [s]))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64,c).m) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst64 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpAvg64u { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| if x != v_0_1_0.Args[0] { |
| break |
| } |
| mul := v_0_1_0.Args[1] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64, c).m) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 (Mul64 (Const64 [c]) (Rsh64Ux64 (Avg64u x mul:(Hmul64u x (Const64 [m]))) (Const64 [s]))) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64,c).m) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpConst64 { |
| break |
| } |
| c := v_0_0.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_1.Args[1] |
| v_0_1_0 := v_0_1.Args[0] |
| if v_0_1_0.Op != OpAvg64u { |
| break |
| } |
| _ = v_0_1_0.Args[1] |
| if x != v_0_1_0.Args[0] { |
| break |
| } |
| mul := v_0_1_0.Args[1] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_1_1 := v_0_1.Args[1] |
| if v_0_1_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64, c).m) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 (Mul64 (Rsh64Ux64 (Avg64u x mul:(Hmul64u (Const64 [m]) x)) (Const64 [s])) (Const64 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64,c).m) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpAvg64u { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| if x != v_0_0_0.Args[0] { |
| break |
| } |
| mul := v_0_0_0.Args[1] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64, c).m) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| return false |
| } |
| func rewriteValuegeneric_OpEq64_30(v *Value) bool { |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Eq64 (Mul64 (Rsh64Ux64 (Avg64u x mul:(Hmul64u x (Const64 [m]))) (Const64 [s])) (Const64 [c])) x) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64,c).m) && s == umagic(64,c).s-1 && x.Op != OpConst64 && udivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(udivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(64-udivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(udivisible(64,c).max)]) ) |
| for { |
| x := v.Args[1] |
| v_0 := v.Args[0] |
| if v_0.Op != OpMul64 { |
| break |
| } |
| _ = v_0.Args[1] |
| v_0_0 := v_0.Args[0] |
| if v_0_0.Op != OpRsh64Ux64 { |
| break |
| } |
| _ = v_0_0.Args[1] |
| v_0_0_0 := v_0_0.Args[0] |
| if v_0_0_0.Op != OpAvg64u { |
| break |
| } |
| _ = v_0_0_0.Args[1] |
| if x != v_0_0_0.Args[0] { |
| break |
| } |
| mul := v_0_0_0.Args[1] |
| if mul.Op != OpHmul64u { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_0_0_1 := v_0_0.Args[1] |
| if v_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_0_0_1.AuxInt |
| v_0_1 := v_0.Args[1] |
| if v_0_1.Op != OpConst64 { |
| break |
| } |
| c := v_0_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(umagic(64, c).m) && s == umagic(64, c).s-1 && x.Op != OpConst64 && udivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v2.AuxInt = int64(udivisible(64, c).m) |
| v1.AddArg(v2) |
| v1.AddArg(x) |
| v0.AddArg(v1) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(64 - udivisible(64, c).k) |
| v0.AddArg(v3) |
| v.AddArg(v0) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(udivisible(64, c).max) |
| v.AddArg(v4) |
| return true |
| } |
| // match: (Eq64 x (Mul64 (Const64 [c]) (Sub64 (Rsh64x64 mul:(Hmul64 (Const64 [m]) x) (Const64 [s])) (Rsh64x64 x (Const64 [63]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m/2) && s == smagic(64,c).s-1 && x.Op != OpConst64 && sdivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst64 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpSub64 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpHmul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_1_1_1.Args[1] |
| if x != v_1_1_1.Args[0] { |
| break |
| } |
| v_1_1_1_1 := v_1_1_1.Args[1] |
| if v_1_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1_1_1.AuxInt != 63 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m/2) && s == smagic(64, c).s-1 && x.Op != OpConst64 && sdivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(sdivisible(64, c).m) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(sdivisible(64, c).a) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v5.AuxInt = int64(64 - sdivisible(64, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v6.AuxInt = int64(sdivisible(64, c).max) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq64 x (Mul64 (Const64 [c]) (Sub64 (Rsh64x64 mul:(Hmul64 x (Const64 [m])) (Const64 [s])) (Rsh64x64 x (Const64 [63]))))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m/2) && s == smagic(64,c).s-1 && x.Op != OpConst64 && sdivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpConst64 { |
| break |
| } |
| c := v_1_0.AuxInt |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpSub64 { |
| break |
| } |
| _ = v_1_1.Args[1] |
| v_1_1_0 := v_1_1.Args[0] |
| if v_1_1_0.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_1_1_0.Args[1] |
| mul := v_1_1_0.Args[0] |
| if mul.Op != OpHmul64 { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_1_0_1 := v_1_1_0.Args[1] |
| if v_1_1_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_1_0_1.AuxInt |
| v_1_1_1 := v_1_1.Args[1] |
| if v_1_1_1.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_1_1_1.Args[1] |
| if x != v_1_1_1.Args[0] { |
| break |
| } |
| v_1_1_1_1 := v_1_1_1.Args[1] |
| if v_1_1_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_1_1_1.AuxInt != 63 { |
| break |
| } |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m/2) && s == smagic(64, c).s-1 && x.Op != OpConst64 && sdivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(sdivisible(64, c).m) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(sdivisible(64, c).a) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v5.AuxInt = int64(64 - sdivisible(64, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v6.AuxInt = int64(sdivisible(64, c).max) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq64 x (Mul64 (Sub64 (Rsh64x64 mul:(Hmul64 (Const64 [m]) x) (Const64 [s])) (Rsh64x64 x (Const64 [63]))) (Const64 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m/2) && s == smagic(64,c).s-1 && x.Op != OpConst64 && sdivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpSub64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpHmul64 { |
| break |
| } |
| _ = mul.Args[1] |
| mul_0 := mul.Args[0] |
| if mul_0.Op != OpConst64 { |
| break |
| } |
| m := mul_0.AuxInt |
| if x != mul.Args[1] { |
| break |
| } |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_1_0_1.Args[1] |
| if x != v_1_0_1.Args[0] { |
| break |
| } |
| v_1_0_1_1 := v_1_0_1.Args[1] |
| if v_1_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_1_1.AuxInt != 63 { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| c := v_1_1.AuxInt |
| if !(v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64, c).m/2) && s == smagic(64, c).s-1 && x.Op != OpConst64 && sdivisibleOK(64, c)) { |
| break |
| } |
| v.reset(OpLeq64U) |
| v0 := b.NewValue0(v.Pos, OpRotateLeft64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, OpAdd64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) |
| v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v3.AuxInt = int64(sdivisible(64, c).m) |
| v2.AddArg(v3) |
| v2.AddArg(x) |
| v1.AddArg(v2) |
| v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v4.AuxInt = int64(sdivisible(64, c).a) |
| v1.AddArg(v4) |
| v0.AddArg(v1) |
| v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v5.AuxInt = int64(64 - sdivisible(64, c).k) |
| v0.AddArg(v5) |
| v.AddArg(v0) |
| v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) |
| v6.AuxInt = int64(sdivisible(64, c).max) |
| v.AddArg(v6) |
| return true |
| } |
| // match: (Eq64 x (Mul64 (Sub64 (Rsh64x64 mul:(Hmul64 x (Const64 [m])) (Const64 [s])) (Rsh64x64 x (Const64 [63]))) (Const64 [c]))) |
| // cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(smagic(64,c).m/2) && s == smagic(64,c).s-1 && x.Op != OpConst64 && sdivisibleOK(64,c) |
| // result: (Leq64U (RotateLeft64 <typ.UInt64> (Add64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(sdivisible(64,c).m)]) x) (Const64 <typ.UInt64> [int64(sdivisible(64,c).a)]) ) (Const64 <typ.UInt64> [int64(64-sdivisible(64,c).k)]) ) (Const64 <typ.UInt64> [int64(sdivisible(64,c).max)]) ) |
| for { |
| _ = v.Args[1] |
| x := v.Args[0] |
| v_1 := v.Args[1] |
| if v_1.Op != OpMul64 { |
| break |
| } |
| _ = v_1.Args[1] |
| v_1_0 := v_1.Args[0] |
| if v_1_0.Op != OpSub64 { |
| break |
| } |
| _ = v_1_0.Args[1] |
| v_1_0_0 := v_1_0.Args[0] |
| if v_1_0_0.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_1_0_0.Args[1] |
| mul := v_1_0_0.Args[0] |
| if mul.Op != OpHmul64 { |
| break |
| } |
| _ = mul.Args[1] |
| if x != mul.Args[0] { |
| break |
| } |
| mul_1 := mul.Args[1] |
| if mul_1.Op != OpConst64 { |
| break |
| } |
| m := mul_1.AuxInt |
| v_1_0_0_1 := v_1_0_0.Args[1] |
| if v_1_0_0_1.Op != OpConst64 { |
| break |
| } |
| s := v_1_0_0_1.AuxInt |
| v_1_0_1 := v_1_0.Args[1] |
| if v_1_0_1.Op != OpRsh64x64 { |
| break |
| } |
| _ = v_1_0_1.Args[1] |
| if x != v_1_0_1.Args[0] { |
| break |
| } |
| v_1_0_1_1 := v_1_0_1.Args[1] |
| if v_1_0_1_1.Op != OpConst64 { |
| break |
| } |
| if v_1_0_1_1.AuxInt != 63 { |
| break |
| } |
| v_1_1 := v_1.Args[1] |
| if v_1_1.Op != OpConst64 { |
| break |
| } |
| c := v_1_1.AuxInt |
|
|
