| // Code generated from _gen/divmod.rules using 'go generate'; DO NOT EDIT. |
| |
| package rewritedivmod |
| |
| import "cmd/compile/internal/ssa/ssaop" |
| import "cmd/compile/internal/ssa" |
| |
| func RewriteValue(v *ssa.Value) bool { |
| switch v.Op { |
| case ssaop.OpDiv16: |
| return rewriteValue_OpDiv16(v) |
| case ssaop.OpDiv16u: |
| return rewriteValue_OpDiv16u(v) |
| case ssaop.OpDiv32: |
| return rewriteValue_OpDiv32(v) |
| case ssaop.OpDiv32u: |
| return rewriteValue_OpDiv32u(v) |
| case ssaop.OpDiv64: |
| return rewriteValue_OpDiv64(v) |
| case ssaop.OpDiv64u: |
| return rewriteValue_OpDiv64u(v) |
| case ssaop.OpDiv8: |
| return rewriteValue_OpDiv8(v) |
| case ssaop.OpDiv8u: |
| return rewriteValue_OpDiv8u(v) |
| } |
| return false |
| } |
| func rewriteValue_OpDiv16(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Div16 <t> n (Const16 [c])) |
| // cond: ssa.IsPowerOfTwo(c) |
| // result: (Rsh16x64 (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <typ.UInt64> [15])) (Const64 <typ.UInt64> [int64(16-ssa.Log16(c))]))) (Const64 <typ.UInt64> [int64(ssa.Log16(c))])) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(c)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh16x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd16, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpRsh16Ux64, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpRsh16x64, t) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v3.AuxInt = ssa.Int64ToAuxInt(15) |
| v2.AddArg2(n, v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(int64(16 - ssa.Log16(c))) |
| v1.AddArg2(v2, v4) |
| v0.AddArg2(n, v1) |
| v5 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v5.AuxInt = ssa.Int64ToAuxInt(int64(ssa.Log16(c))) |
| v.AddArg2(v0, v5) |
| return true |
| } |
| // match: (Div16 <t> x (Const16 [c])) |
| // cond: smagicOK16(c) |
| // result: (Sub16 <t> (Rsh32x64 <t> (Mul32 <typ.UInt32> (SignExt16to32 x) (Const32 <typ.UInt32> [int32(smagic16(c).M)])) (Const64 <typ.UInt64> [16 + smagic16(c).S])) (Rsh32x64 <t> (SignExt16to32 x) (Const64 <typ.UInt64> [31]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(smagicOK16(c)) { |
| break |
| } |
| v.Reset(ssaop.OpSub16) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh32x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, ssaop.OpSignExt16to32, typ.Int32) |
| v2.AddArg(x) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v3.AuxInt = ssa.Int32ToAuxInt(int32(smagic16(c).M)) |
| v1.AddArg2(v2, v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(16 + smagic16(c).S) |
| v0.AddArg2(v1, v4) |
| v5 := b.NewValue0(v.Pos, ssaop.OpRsh32x64, t) |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v6.AuxInt = ssa.Int64ToAuxInt(31) |
| v5.AddArg2(v2, v6) |
| v.AddArg2(v0, v5) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv16u(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| typ := &b.Func.Config.Types |
| // match: (Div16u <t> x (Const16 [c])) |
| // cond: t.IsSigned() && smagicOK16(c) |
| // result: (Rsh32Ux64 <t> (Mul32 <typ.UInt32> (SignExt16to32 x) (Const32 <typ.UInt32> [int32(smagic16(c).M)])) (Const64 <typ.UInt64> [16 + smagic16(c).S])) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(t.IsSigned() && smagicOK16(c)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32Ux64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul32, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSignExt16to32, typ.Int32) |
| v1.AddArg(x) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v2.AuxInt = ssa.Int32ToAuxInt(int32(smagic16(c).M)) |
| v0.AddArg2(v1, v2) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v3.AuxInt = ssa.Int64ToAuxInt(16 + smagic16(c).S) |
| v.AddArg2(v0, v3) |
| return true |
| } |
| // match: (Div16u <t> x (Const16 [c])) |
| // cond: umagicOK16(c) && config.RegSize == 8 |
| // result: (Trunc64to16 <t> (Rsh64Ux64 <typ.UInt64> (Mul64 <typ.UInt64> (ZeroExt16to64 x) (Const64 <typ.UInt64> [int64(1<<16 + umagic16(c).M)])) (Const64 <typ.UInt64> [16 + umagic16(c).S]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(umagicOK16(c) && config.RegSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpTrunc64to16) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh64Ux64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, ssaop.OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt16to64, typ.UInt64) |
| v2.AddArg(x) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v3.AuxInt = ssa.Int64ToAuxInt(int64(1<<16 + umagic16(c).M)) |
| v1.AddArg2(v2, v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(16 + umagic16(c).S) |
| v0.AddArg2(v1, v4) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div16u <t> x (Const16 [c])) |
| // cond: umagicOK16(c) && umagic16(c).M&1 == 0 |
| // result: (Trunc32to16 <t> (Rsh32Ux64 <typ.UInt32> (Mul32 <typ.UInt32> (ZeroExt16to32 x) (Const32 <typ.UInt32> [int32(1<<15 + umagic16(c).M/2)])) (Const64 <typ.UInt64> [16 + umagic16(c).S - 1]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(umagicOK16(c) && umagic16(c).M&1 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpTrunc32to16) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux64, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, ssaop.OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt16to32, typ.UInt32) |
| v2.AddArg(x) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v3.AuxInt = ssa.Int32ToAuxInt(int32(1<<15 + umagic16(c).M/2)) |
| v1.AddArg2(v2, v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(16 + umagic16(c).S - 1) |
| v0.AddArg2(v1, v4) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div16u <t> x (Const16 [c])) |
| // cond: umagicOK16(c) && config.RegSize == 4 && c&1 == 0 |
| // result: (Trunc32to16 <t> (Rsh32Ux64 <typ.UInt32> (Mul32 <typ.UInt32> (Rsh32Ux64 <typ.UInt32> (ZeroExt16to32 x) (Const64 <typ.UInt64> [1])) (Const32 <typ.UInt32> [int32(1<<15 + (umagic16(c).M+1)/2)])) (Const64 <typ.UInt64> [16 + umagic16(c).S - 2]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(umagicOK16(c) && config.RegSize == 4 && c&1 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpTrunc32to16) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux64, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, ssaop.OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux64, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, ssaop.OpZeroExt16to32, typ.UInt32) |
| v3.AddArg(x) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(1) |
| v2.AddArg2(v3, v4) |
| v5 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v5.AuxInt = ssa.Int32ToAuxInt(int32(1<<15 + (umagic16(c).M+1)/2)) |
| v1.AddArg2(v2, v5) |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v6.AuxInt = ssa.Int64ToAuxInt(16 + umagic16(c).S - 2) |
| v0.AddArg2(v1, v6) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div16u <t> x (Const16 [c])) |
| // cond: umagicOK16(c) && config.RegSize == 4 |
| // result: (Trunc32to16 <t> (Rsh32Ux64 <typ.UInt32> (Avg32u (Lsh32x64 <typ.UInt32> (ZeroExt16to32 x) (Const64 <typ.UInt64> [16])) (Mul32 <typ.UInt32> (ZeroExt16to32 x) (Const32 <typ.UInt32> [int32(umagic16(c).M)]))) (Const64 <typ.UInt64> [16 + umagic16(c).S - 1]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst16 { |
| break |
| } |
| c := ssa.AuxIntToInt16(v_1.AuxInt) |
| if !(umagicOK16(c) && config.RegSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpTrunc32to16) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux64, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, ssaop.OpAvg32u, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, ssaop.OpLsh32x64, typ.UInt32) |
| v3 := b.NewValue0(v.Pos, ssaop.OpZeroExt16to32, typ.UInt32) |
| v3.AddArg(x) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(16) |
| v2.AddArg2(v3, v4) |
| v5 := b.NewValue0(v.Pos, ssaop.OpMul32, typ.UInt32) |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v6.AuxInt = ssa.Int32ToAuxInt(int32(umagic16(c).M)) |
| v5.AddArg2(v3, v6) |
| v1.AddArg2(v2, v5) |
| v7 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v7.AuxInt = ssa.Int64ToAuxInt(16 + umagic16(c).S - 1) |
| v0.AddArg2(v1, v7) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv32(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| typ := &b.Func.Config.Types |
| // match: (Div32 <t> n (Const32 [c])) |
| // cond: ssa.IsPowerOfTwo(c) |
| // result: (Rsh32x64 (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <typ.UInt64> [31])) (Const64 <typ.UInt64> [int64(32-ssa.Log32(c))]))) (Const64 <typ.UInt64> [int64(ssa.Log32(c))])) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(c)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd32, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux64, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpRsh32x64, t) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v3.AuxInt = ssa.Int64ToAuxInt(31) |
| v2.AddArg2(n, v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(int64(32 - ssa.Log32(c))) |
| v1.AddArg2(v2, v4) |
| v0.AddArg2(n, v1) |
| v5 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v5.AuxInt = ssa.Int64ToAuxInt(int64(ssa.Log32(c))) |
| v.AddArg2(v0, v5) |
| return true |
| } |
| // match: (Div32 <t> x (Const32 [c])) |
| // cond: smagicOK32(c) && config.RegSize == 8 |
| // result: (Sub32 <t> (Rsh64x64 <t> (Mul64 <typ.UInt64> (SignExt32to64 x) (Const64 <typ.UInt64> [int64(smagic32(c).M)])) (Const64 <typ.UInt64> [32 + smagic32(c).S])) (Rsh64x64 <t> (SignExt32to64 x) (Const64 <typ.UInt64> [63]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(smagicOK32(c) && config.RegSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpSub32) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh64x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, ssaop.OpSignExt32to64, typ.Int64) |
| v2.AddArg(x) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v3.AuxInt = ssa.Int64ToAuxInt(int64(smagic32(c).M)) |
| v1.AddArg2(v2, v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(32 + smagic32(c).S) |
| v0.AddArg2(v1, v4) |
| v5 := b.NewValue0(v.Pos, ssaop.OpRsh64x64, t) |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v6.AuxInt = ssa.Int64ToAuxInt(63) |
| v5.AddArg2(v2, v6) |
| v.AddArg2(v0, v5) |
| return true |
| } |
| // match: (Div32 <t> x (Const32 [c])) |
| // cond: smagicOK32(c) && config.RegSize == 4 && smagic32(c).M&1 == 0 |
| // result: (Sub32 <t> (Rsh32x64 <t> (Hmul32 <t> x (Const32 <typ.UInt32> [int32(smagic32(c).M/2)])) (Const64 <typ.UInt64> [smagic32(c).S - 1])) (Rsh32x64 <t> x (Const64 <typ.UInt64> [31]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(smagicOK32(c) && config.RegSize == 4 && smagic32(c).M&1 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpSub32) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh32x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpHmul32, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v2.AuxInt = ssa.Int32ToAuxInt(int32(smagic32(c).M / 2)) |
| v1.AddArg2(x, v2) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v3.AuxInt = ssa.Int64ToAuxInt(smagic32(c).S - 1) |
| v0.AddArg2(v1, v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh32x64, t) |
| v5 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v5.AuxInt = ssa.Int64ToAuxInt(31) |
| v4.AddArg2(x, v5) |
| v.AddArg2(v0, v4) |
| return true |
| } |
| // match: (Div32 <t> x (Const32 [c])) |
| // cond: smagicOK32(c) && config.RegSize == 4 && smagic32(c).M&1 != 0 |
| // result: (Sub32 <t> (Rsh32x64 <t> (Add32 <t> x (Hmul32 <t> x (Const32 <typ.UInt32> [int32(smagic32(c).M)]))) (Const64 <typ.UInt64> [smagic32(c).S])) (Rsh32x64 <t> x (Const64 <typ.UInt64> [31]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(smagicOK32(c) && config.RegSize == 4 && smagic32(c).M&1 != 0) { |
| break |
| } |
| v.Reset(ssaop.OpSub32) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh32x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpAdd32, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpHmul32, t) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v3.AuxInt = ssa.Int32ToAuxInt(int32(smagic32(c).M)) |
| v2.AddArg2(x, v3) |
| v1.AddArg2(x, v2) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(smagic32(c).S) |
| v0.AddArg2(v1, v4) |
| v5 := b.NewValue0(v.Pos, ssaop.OpRsh32x64, t) |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v6.AuxInt = ssa.Int64ToAuxInt(31) |
| v5.AddArg2(x, v6) |
| v.AddArg2(v0, v5) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv32u(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| config := b.Func.Config |
| typ := &b.Func.Config.Types |
| // match: (Div32u <t> x (Const32 [c])) |
| // cond: t.IsSigned() && smagicOK32(c) && config.RegSize == 8 |
| // result: (Rsh64Ux64 <t> (Mul64 <typ.UInt64> (SignExt32to64 x) (Const64 <typ.UInt64> [int64(smagic32(c).M)])) (Const64 <typ.UInt64> [32 + smagic32(c).S])) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(t.IsSigned() && smagicOK32(c) && config.RegSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64Ux64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpMul64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, ssaop.OpSignExt32to64, typ.Int64) |
| v1.AddArg(x) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v2.AuxInt = ssa.Int64ToAuxInt(int64(smagic32(c).M)) |
| v0.AddArg2(v1, v2) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v3.AuxInt = ssa.Int64ToAuxInt(32 + smagic32(c).S) |
| v.AddArg2(v0, v3) |
| return true |
| } |
| // match: (Div32u <t> x (Const32 [c])) |
| // cond: t.IsSigned() && smagicOK32(c) && config.RegSize == 4 |
| // result: (Rsh32Ux64 <t> (Hmul32u <typ.UInt32> x (Const32 <typ.UInt32> [int32(smagic32(c).M)])) (Const64 <typ.UInt64> [smagic32(c).S])) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(t.IsSigned() && smagicOK32(c) && config.RegSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32Ux64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpHmul32u, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v1.AuxInt = ssa.Int32ToAuxInt(int32(smagic32(c).M)) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v2.AuxInt = ssa.Int64ToAuxInt(smagic32(c).S) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| // match: (Div32u <t> x (Const32 [c])) |
| // cond: umagicOK32(c) && umagic32(c).M&1 == 0 && config.RegSize == 8 |
| // result: (Trunc64to32 <t> (Rsh64Ux64 <typ.UInt64> (Mul64 <typ.UInt64> (ZeroExt32to64 x) (Const64 <typ.UInt64> [int64(1<<31 + umagic32(c).M/2)])) (Const64 <typ.UInt64> [32 + umagic32(c).S - 1]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(umagicOK32(c) && umagic32(c).M&1 == 0 && config.RegSize == 8) { |
| break |
| } |
| v.Reset(ssaop.OpTrunc64to32) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh64Ux64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, ssaop.OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.UInt64) |
| v2.AddArg(x) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v3.AuxInt = ssa.Int64ToAuxInt(int64(1<<31 + umagic32(c).M/2)) |
| v1.AddArg2(v2, v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(32 + umagic32(c).S - 1) |
| v0.AddArg2(v1, v4) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div32u <t> x (Const32 [c])) |
| // cond: umagicOK32(c) && umagic32(c).M&1 == 0 && config.RegSize == 4 |
| // result: (Rsh32Ux64 <t> (Hmul32u <typ.UInt32> x (Const32 <typ.UInt32> [int32(1<<31 + umagic32(c).M/2)])) (Const64 <typ.UInt64> [umagic32(c).S - 1])) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(umagicOK32(c) && umagic32(c).M&1 == 0 && config.RegSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32Ux64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpHmul32u, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v1.AuxInt = ssa.Int32ToAuxInt(int32(1<<31 + umagic32(c).M/2)) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v2.AuxInt = ssa.Int64ToAuxInt(umagic32(c).S - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| // match: (Div32u <t> x (Const32 [c])) |
| // cond: umagicOK32(c) && config.RegSize == 8 && config.Ctxt.Arch.Name != "wasm" && umagic32(c).M&1 != 0 |
| // result: (Trunc64to32 <t> (Hmul64u <typ.UInt64> (ZeroExt32to64 x) (Const64 <typ.UInt64> [int64(umagic32PreShifted(c))]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(umagicOK32(c) && config.RegSize == 8 && config.Ctxt.Arch.Name != "wasm" && umagic32(c).M&1 != 0) { |
| break |
| } |
| v.Reset(ssaop.OpTrunc64to32) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpHmul64u, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.UInt64) |
| v1.AddArg(x) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v2.AuxInt = ssa.Int64ToAuxInt(int64(umagic32PreShifted(c))) |
| v0.AddArg2(v1, v2) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div32u <t> x (Const32 [c])) |
| // cond: umagicOK32(c) && config.RegSize == 8 && c&1 == 0 |
| // result: (Trunc64to32 <t> (Rsh64Ux64 <typ.UInt64> (Mul64 <typ.UInt64> (Rsh64Ux64 <typ.UInt64> (ZeroExt32to64 x) (Const64 <typ.UInt64> [1])) (Const64 <typ.UInt64> [int64(1<<31 + (umagic32(c).M+1)/2)])) (Const64 <typ.UInt64> [32 + umagic32(c).S - 2]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(umagicOK32(c) && config.RegSize == 8 && c&1 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpTrunc64to32) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh64Ux64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, ssaop.OpMul64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, ssaop.OpRsh64Ux64, typ.UInt64) |
| v3 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.UInt64) |
| v3.AddArg(x) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(1) |
| v2.AddArg2(v3, v4) |
| v5 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v5.AuxInt = ssa.Int64ToAuxInt(int64(1<<31 + (umagic32(c).M+1)/2)) |
| v1.AddArg2(v2, v5) |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v6.AuxInt = ssa.Int64ToAuxInt(32 + umagic32(c).S - 2) |
| v0.AddArg2(v1, v6) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div32u <t> x (Const32 [c])) |
| // cond: umagicOK32(c) && config.RegSize == 4 && c&1 == 0 |
| // result: (Rsh32Ux64 <t> (Hmul32u <typ.UInt32> (Rsh32Ux64 <typ.UInt32> x (Const64 <typ.UInt64> [1])) (Const32 <typ.UInt32> [int32(1<<31 + (umagic32(c).M+1)/2)])) (Const64 <typ.UInt64> [umagic32(c).S - 2])) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(umagicOK32(c) && config.RegSize == 4 && c&1 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32Ux64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpHmul32u, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux64, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v2.AuxInt = ssa.Int64ToAuxInt(1) |
| v1.AddArg2(x, v2) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v3.AuxInt = ssa.Int32ToAuxInt(int32(1<<31 + (umagic32(c).M+1)/2)) |
| v0.AddArg2(v1, v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(umagic32(c).S - 2) |
| v.AddArg2(v0, v4) |
| return true |
| } |
| // match: (Div32u <t> x (Const32 [c])) |
| // cond: umagicOK32(c) && config.RegSize == 8 && config.Ctxt.Arch.Name == "wasm" |
| // result: (Trunc64to32 <t> (Rsh64Ux64 <typ.UInt64> (Avg64u (Lsh64x64 <typ.UInt64> (ZeroExt32to64 x) (Const64 <typ.UInt64> [32])) (Mul64 <typ.UInt64> (ZeroExt32to64 x) (Const64 <typ.UInt64> [int64(umagic32(c).M)]))) (Const64 <typ.UInt64> [32 + umagic32(c).S - 1]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(umagicOK32(c) && config.RegSize == 8 && config.Ctxt.Arch.Name == "wasm") { |
| break |
| } |
| v.Reset(ssaop.OpTrunc64to32) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh64Ux64, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, ssaop.OpAvg64u, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, ssaop.OpLsh64x64, typ.UInt64) |
| v3 := b.NewValue0(v.Pos, ssaop.OpZeroExt32to64, typ.UInt64) |
| v3.AddArg(x) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(32) |
| v2.AddArg2(v3, v4) |
| v5 := b.NewValue0(v.Pos, ssaop.OpMul64, typ.UInt64) |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v6.AuxInt = ssa.Int64ToAuxInt(int64(umagic32(c).M)) |
| v5.AddArg2(v3, v6) |
| v1.AddArg2(v2, v5) |
| v7 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v7.AuxInt = ssa.Int64ToAuxInt(32 + umagic32(c).S - 1) |
| v0.AddArg2(v1, v7) |
| v.AddArg(v0) |
| return true |
| } |
| // match: (Div32u <t> x (Const32 [c])) |
| // cond: umagicOK32(c) && config.RegSize == 4 |
| // result: (Rsh32Ux64 <t> (Avg32u x (Hmul32u <typ.UInt32> x (Const32 <typ.UInt32> [int32(umagic32(c).M)]))) (Const64 <typ.UInt64> [umagic32(c).S - 1])) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst32 { |
| break |
| } |
| c := ssa.AuxIntToInt32(v_1.AuxInt) |
| if !(umagicOK32(c) && config.RegSize == 4) { |
| break |
| } |
| v.Reset(ssaop.OpRsh32Ux64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpAvg32u, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, ssaop.OpHmul32u, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v2.AuxInt = ssa.Int32ToAuxInt(int32(umagic32(c).M)) |
| v1.AddArg2(x, v2) |
| v0.AddArg2(x, v1) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v3.AuxInt = ssa.Int64ToAuxInt(umagic32(c).S - 1) |
| v.AddArg2(v0, v3) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv64(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Div64 <t> n (Const64 [c])) |
| // cond: ssa.IsPowerOfTwo(c) |
| // result: (Rsh64x64 (Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <typ.UInt64> [63])) (Const64 <typ.UInt64> [int64(64-ssa.Log64(c))]))) (Const64 <typ.UInt64> [int64(ssa.Log64(c))])) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(c)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpRsh64Ux64, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpRsh64x64, t) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v3.AuxInt = ssa.Int64ToAuxInt(63) |
| v2.AddArg2(n, v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(int64(64 - ssa.Log64(c))) |
| v1.AddArg2(v2, v4) |
| v0.AddArg2(n, v1) |
| v5 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v5.AuxInt = ssa.Int64ToAuxInt(int64(ssa.Log64(c))) |
| v.AddArg2(v0, v5) |
| return true |
| } |
| // match: (Div64 <t> x (Const64 [c])) |
| // cond: smagicOK64(c) && smagic64(c).M&1 == 0 |
| // result: (Sub64 <t> (Rsh64x64 <t> (Hmul64 <t> x (Const64 <typ.UInt64> [int64(smagic64(c).M/2)])) (Const64 <typ.UInt64> [smagic64(c).S - 1])) (Rsh64x64 <t> x (Const64 <typ.UInt64> [63]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(smagicOK64(c) && smagic64(c).M&1 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpSub64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh64x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpHmul64, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v2.AuxInt = ssa.Int64ToAuxInt(int64(smagic64(c).M / 2)) |
| v1.AddArg2(x, v2) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v3.AuxInt = ssa.Int64ToAuxInt(smagic64(c).S - 1) |
| v0.AddArg2(v1, v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpRsh64x64, t) |
| v5 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v5.AuxInt = ssa.Int64ToAuxInt(63) |
| v4.AddArg2(x, v5) |
| v.AddArg2(v0, v4) |
| return true |
| } |
| // match: (Div64 <t> x (Const64 [c])) |
| // cond: smagicOK64(c) && smagic64(c).M&1 != 0 |
| // result: (Sub64 <t> (Rsh64x64 <t> (Add64 <t> x (Hmul64 <t> x (Const64 <typ.UInt64> [int64(smagic64(c).M)]))) (Const64 <typ.UInt64> [smagic64(c).S])) (Rsh64x64 <t> x (Const64 <typ.UInt64> [63]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(smagicOK64(c) && smagic64(c).M&1 != 0) { |
| break |
| } |
| v.Reset(ssaop.OpSub64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh64x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpAdd64, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpHmul64, t) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v3.AuxInt = ssa.Int64ToAuxInt(int64(smagic64(c).M)) |
| v2.AddArg2(x, v3) |
| v1.AddArg2(x, v2) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(smagic64(c).S) |
| v0.AddArg2(v1, v4) |
| v5 := b.NewValue0(v.Pos, ssaop.OpRsh64x64, t) |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v6.AuxInt = ssa.Int64ToAuxInt(63) |
| v5.AddArg2(x, v6) |
| v.AddArg2(v0, v5) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv64u(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Div64u <t> x (Const64 [c])) |
| // cond: t.IsSigned() && smagicOK64(c) |
| // result: (Rsh64Ux64 <t> (Hmul64u <typ.UInt64> x (Const64 <typ.UInt64> [int64(smagic64(c).M)])) (Const64 <typ.UInt64> [smagic64(c).S])) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(t.IsSigned() && smagicOK64(c)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64Ux64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpHmul64u, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v1.AuxInt = ssa.Int64ToAuxInt(int64(smagic64(c).M)) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v2.AuxInt = ssa.Int64ToAuxInt(smagic64(c).S) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| // match: (Div64u <t> x (Const64 [c])) |
| // cond: umagicOK64(c) && umagic64(c).M&1 == 0 |
| // result: (Rsh64Ux64 <t> (Hmul64u <typ.UInt64> x (Const64 <typ.UInt64> [int64(1<<63 + umagic64(c).M/2)])) (Const64 <typ.UInt64> [umagic64(c).S - 1])) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(umagicOK64(c) && umagic64(c).M&1 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64Ux64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpHmul64u, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v1.AuxInt = ssa.Int64ToAuxInt(int64(1<<63 + umagic64(c).M/2)) |
| v0.AddArg2(x, v1) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v2.AuxInt = ssa.Int64ToAuxInt(umagic64(c).S - 1) |
| v.AddArg2(v0, v2) |
| return true |
| } |
| // match: (Div64u <t> x (Const64 [c])) |
| // cond: umagicOK64(c) && c&1 == 0 |
| // result: (Rsh64Ux64 <t> (Hmul64u <typ.UInt64> (Rsh64Ux64 <typ.UInt64> x (Const64 <typ.UInt64> [1])) (Const64 <typ.UInt64> [int64(1<<63 + (umagic64(c).M+1)/2)])) (Const64 <typ.UInt64> [umagic64(c).S - 2])) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(umagicOK64(c) && c&1 == 0) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64Ux64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpHmul64u, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, ssaop.OpRsh64Ux64, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v2.AuxInt = ssa.Int64ToAuxInt(1) |
| v1.AddArg2(x, v2) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v3.AuxInt = ssa.Int64ToAuxInt(int64(1<<63 + (umagic64(c).M+1)/2)) |
| v0.AddArg2(v1, v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(umagic64(c).S - 2) |
| v.AddArg2(v0, v4) |
| return true |
| } |
| // match: (Div64u <t> x (Const64 [c])) |
| // cond: umagicOK64(c) |
| // result: (Rsh64Ux64 <t> (Avg64u x (Hmul64u <typ.UInt64> x (Const64 <typ.UInt64> [int64(umagic64(c).M)]))) (Const64 <typ.UInt64> [umagic64(c).S - 1])) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst64 { |
| break |
| } |
| c := ssa.AuxIntToInt64(v_1.AuxInt) |
| if !(umagicOK64(c)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh64Ux64) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpAvg64u, typ.UInt64) |
| v1 := b.NewValue0(v.Pos, ssaop.OpHmul64u, typ.UInt64) |
| v2 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v2.AuxInt = ssa.Int64ToAuxInt(int64(umagic64(c).M)) |
| v1.AddArg2(x, v2) |
| v0.AddArg2(x, v1) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v3.AuxInt = ssa.Int64ToAuxInt(umagic64(c).S - 1) |
| v.AddArg2(v0, v3) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv8(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Div8 <t> n (Const8 [c])) |
| // cond: ssa.IsPowerOfTwo(c) |
| // result: (Rsh8x64 (Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <typ.UInt64> [ 7])) (Const64 <typ.UInt64> [int64( 8-log8(c))]))) (Const64 <typ.UInt64> [int64(log8(c))])) |
| for { |
| t := v.Type |
| n := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(ssa.IsPowerOfTwo(c)) { |
| break |
| } |
| v.Reset(ssaop.OpRsh8x64) |
| v0 := b.NewValue0(v.Pos, ssaop.OpAdd8, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpRsh8Ux64, t) |
| v2 := b.NewValue0(v.Pos, ssaop.OpRsh8x64, t) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v3.AuxInt = ssa.Int64ToAuxInt(7) |
| v2.AddArg2(n, v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(int64(8 - log8(c))) |
| v1.AddArg2(v2, v4) |
| v0.AddArg2(n, v1) |
| v5 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v5.AuxInt = ssa.Int64ToAuxInt(int64(log8(c))) |
| v.AddArg2(v0, v5) |
| return true |
| } |
| // match: (Div8 <t> x (Const8 [c])) |
| // cond: smagicOK8(c) |
| // result: (Sub8 <t> (Rsh32x64 <t> (Mul32 <typ.UInt32> (SignExt8to32 x) (Const32 <typ.UInt32> [int32(smagic8(c).M)])) (Const64 <typ.UInt64> [8 + smagic8(c).S])) (Rsh32x64 <t> (SignExt8to32 x) (Const64 <typ.UInt64> [31]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(smagicOK8(c)) { |
| break |
| } |
| v.Reset(ssaop.OpSub8) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh32x64, t) |
| v1 := b.NewValue0(v.Pos, ssaop.OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, ssaop.OpSignExt8to32, typ.Int32) |
| v2.AddArg(x) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v3.AuxInt = ssa.Int32ToAuxInt(int32(smagic8(c).M)) |
| v1.AddArg2(v2, v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(8 + smagic8(c).S) |
| v0.AddArg2(v1, v4) |
| v5 := b.NewValue0(v.Pos, ssaop.OpRsh32x64, t) |
| v6 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v6.AuxInt = ssa.Int64ToAuxInt(31) |
| v5.AddArg2(v2, v6) |
| v.AddArg2(v0, v5) |
| return true |
| } |
| return false |
| } |
| func rewriteValue_OpDiv8u(v *ssa.Value) bool { |
| v_1 := v.Args[1] |
| v_0 := v.Args[0] |
| b := v.Block |
| typ := &b.Func.Config.Types |
| // match: (Div8u <t> x (Const8 [c])) |
| // cond: umagicOK8(c) |
| // result: (Trunc32to8 <t> (Rsh32Ux64 <typ.UInt32> (Mul32 <typ.UInt32> (ZeroExt8to32 x) (Const32 <typ.UInt32> [int32(1<<8 + umagic8(c).M)])) (Const64 <typ.UInt64> [8 + umagic8(c).S]))) |
| for { |
| t := v.Type |
| x := v_0 |
| if v_1.Op != ssaop.OpConst8 { |
| break |
| } |
| c := ssa.AuxIntToInt8(v_1.AuxInt) |
| if !(umagicOK8(c)) { |
| break |
| } |
| v.Reset(ssaop.OpTrunc32to8) |
| v.Type = t |
| v0 := b.NewValue0(v.Pos, ssaop.OpRsh32Ux64, typ.UInt32) |
| v1 := b.NewValue0(v.Pos, ssaop.OpMul32, typ.UInt32) |
| v2 := b.NewValue0(v.Pos, ssaop.OpZeroExt8to32, typ.UInt32) |
| v2.AddArg(x) |
| v3 := b.NewValue0(v.Pos, ssaop.OpConst32, typ.UInt32) |
| v3.AuxInt = ssa.Int32ToAuxInt(int32(1<<8 + umagic8(c).M)) |
| v1.AddArg2(v2, v3) |
| v4 := b.NewValue0(v.Pos, ssaop.OpConst64, typ.UInt64) |
| v4.AuxInt = ssa.Int64ToAuxInt(8 + umagic8(c).S) |
| v0.AddArg2(v1, v4) |
| v.AddArg(v0) |
| return true |
| } |
| return false |
| } |
| func RewriteBlock(b *ssa.Block) bool { |
| return false |
| } |
