Stowage/go
2
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-12-08 06:10:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

cmd/compile: separate ssa.Frontend and ssa.TypeSource

Browse source 
Prior to this CL, the ssa.Frontend field was responsible
for providing types to the backend during compilation.
However, the types needed by the backend are few and static.
It makes more sense to use a struct for them
and to hang that struct off the ssa.Config,
which is the correct home for readonly data.
Now that Types is a struct, we can clean up the names a bit as well.

This has the added benefit of allowing early construction
of all types needed by the backend.
This will be useful for concurrent backend compilation.

Passes toolstash-check -all. No compiler performance change.

Updates #15756

Change-Id: I021658c8cf2836d6a22bbc20cc828ac38c7da08a
Reviewed-on: https://go-review.googlesource.com/38336
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
This commit is contained in:
Josh Bleecher Snyder 2017-03-17 16:04:46 -07:00
parent 2c397c7a75
commit aea3aff669
31 changed files with 4663 additions and 4623 deletions
Download patch file Download diff file Expand all files Collapse all files

35
src/cmd/compile/internal/gc/ssa.go
View file

@ -22,7 +22,24 @@ var ssaConfig *ssa.Config
var ssaCache *ssa.Cache var ssaCache *ssa.Cache
func initssaconfig() { func initssaconfig() {
ssaConfig = ssa.NewConfig(thearch.LinkArch.Name, Ctxt, Debug['N'] == 0) types := ssa.Types{
Bool: Types[TBOOL],
Int8: Types[TINT8],
Int16: Types[TINT16],
Int32: Types[TINT32],
Int64: Types[TINT64],
UInt8: Types[TUINT8],
UInt16: Types[TUINT16],
UInt32: Types[TUINT32],
UInt64: Types[TUINT64],
Float32: Types[TFLOAT32],
Float64: Types[TFLOAT64],
Int: Types[TINT],
Uintptr: Types[TUINTPTR],
String: Types[TSTRING],
BytePtr: ptrto(Types[TUINT8]),
}
ssaConfig = ssa.NewConfig(thearch.LinkArch.Name, types, Ctxt, Debug['N'] == 0)
if thearch.LinkArch.Name == "386" { if thearch.LinkArch.Name == "386" {
ssaConfig.Set387(thearch.Use387) ssaConfig.Set387(thearch.Use387)
} }
@ -4673,22 +4690,6 @@ type ssafn struct {
log bool log bool
} }
func (s *ssafn) TypeBool() ssa.Type { return Types[TBOOL] }
func (s *ssafn) TypeInt8() ssa.Type { return Types[TINT8] }
func (s *ssafn) TypeInt16() ssa.Type { return Types[TINT16] }
func (s *ssafn) TypeInt32() ssa.Type { return Types[TINT32] }
func (s *ssafn) TypeInt64() ssa.Type { return Types[TINT64] }
func (s *ssafn) TypeUInt8() ssa.Type { return Types[TUINT8] }
func (s *ssafn) TypeUInt16() ssa.Type { return Types[TUINT16] }
func (s *ssafn) TypeUInt32() ssa.Type { return Types[TUINT32] }
func (s *ssafn) TypeUInt64() ssa.Type { return Types[TUINT64] }
func (s *ssafn) TypeFloat32() ssa.Type { return Types[TFLOAT32] }
func (s *ssafn) TypeFloat64() ssa.Type { return Types[TFLOAT64] }
func (s *ssafn) TypeInt() ssa.Type { return Types[TINT] }
func (s *ssafn) TypeUintptr() ssa.Type { return Types[TUINTPTR] }
func (s *ssafn) TypeString() ssa.Type { return Types[TSTRING] }
func (s *ssafn) TypeBytePtr() ssa.Type { return ptrto(Types[TUINT8]) }
// StringData returns a symbol (a *Sym wrapped in an interface) which // StringData returns a symbol (a *Sym wrapped in an interface) which
// is the data component of a global string constant containing s. // is the data component of a global string constant containing s.
func (*ssafn) StringData(s string) interface{} { func (*ssafn) StringData(s string) interface{} {

50
src/cmd/compile/internal/ssa/config.go
View file

@ -15,10 +15,11 @@ import (
// It is created once, early during compilation, // It is created once, early during compilation,
// and shared across all compilations. // and shared across all compilations.
type Config struct { type Config struct {
arch string // "amd64", etc. arch string // "amd64", etc.
IntSize int64 // 4 or 8 IntSize int64 // 4 or 8
PtrSize int64 // 4 or 8 PtrSize int64 // 4 or 8
RegSize int64 // 4 or 8 RegSize int64 // 4 or 8
Types Types
lowerBlock blockRewriter // lowering function lowerBlock blockRewriter // lowering function
lowerValue valueRewriter // lowering function lowerValue valueRewriter // lowering function
registers []Register // machine registers registers []Register // machine registers
@ -44,24 +45,22 @@ type (
valueRewriter func(*Value) bool valueRewriter func(*Value) bool
) )
type TypeSource interface { type Types struct {
TypeBool() Type Bool Type
TypeInt8() Type Int8 Type
TypeInt16() Type Int16 Type
TypeInt32() Type Int32 Type
TypeInt64() Type Int64 Type
TypeUInt8() Type UInt8 Type
TypeUInt16() Type UInt16 Type
TypeUInt32() Type UInt32 Type
TypeUInt64() Type UInt64 Type
TypeInt() Type Int Type
TypeFloat32() Type Float32 Type
TypeFloat64() Type Float64 Type
TypeUintptr() Type Uintptr Type
TypeString() Type String Type
TypeBytePtr() Type // TODO: use unsafe.Pointer instead? BytePtr Type // TODO: use unsafe.Pointer instead?
CanSSA(t Type) bool
} }
type Logger interface { type Logger interface {
@ -87,7 +86,8 @@ type Logger interface {
} }
type Frontend interface { type Frontend interface {
TypeSource CanSSA(t Type) bool
Logger Logger
// StringData returns a symbol pointing to the given string's contents. // StringData returns a symbol pointing to the given string's contents.
@ -135,8 +135,8 @@ type GCNode interface {
} }
// NewConfig returns a new configuration object for the given architecture. // NewConfig returns a new configuration object for the given architecture.
func NewConfig(arch string, ctxt *obj.Link, optimize bool) *Config { func NewConfig(arch string, types Types, ctxt *obj.Link, optimize bool) *Config {
c := &Config{arch: arch} c := &Config{arch: arch, Types: types}
switch arch { switch arch {
case "amd64": case "amd64":
c.IntSize = 8 c.IntSize = 8

50
src/cmd/compile/internal/ssa/decompose.go
View file

@ -28,15 +28,15 @@ func decomposeBuiltIn(f *Func) {
case t.IsInteger() && t.Size() == 8 && f.Config.IntSize == 4: case t.IsInteger() && t.Size() == 8 && f.Config.IntSize == 4:
var elemType Type var elemType Type
if t.IsSigned() { if t.IsSigned() {
elemType = f.fe.TypeInt32() elemType = f.Config.Types.Int32
} else { } else {
elemType = f.fe.TypeUInt32() elemType = f.Config.Types.UInt32
} }
hiName, loName := f.fe.SplitInt64(name) hiName, loName := f.fe.SplitInt64(name)
newNames = append(newNames, hiName, loName) newNames = append(newNames, hiName, loName)
for _, v := range f.NamedValues[name] { for _, v := range f.NamedValues[name] {
hi := v.Block.NewValue1(v.Pos, OpInt64Hi, elemType, v) hi := v.Block.NewValue1(v.Pos, OpInt64Hi, elemType, v)
lo := v.Block.NewValue1(v.Pos, OpInt64Lo, f.fe.TypeUInt32(), v) lo := v.Block.NewValue1(v.Pos, OpInt64Lo, f.Config.Types.UInt32, v)
f.NamedValues[hiName] = append(f.NamedValues[hiName], hi) f.NamedValues[hiName] = append(f.NamedValues[hiName], hi)
f.NamedValues[loName] = append(f.NamedValues[loName], lo) f.NamedValues[loName] = append(f.NamedValues[loName], lo)
} }
@ -44,9 +44,9 @@ func decomposeBuiltIn(f *Func) {
case t.IsComplex(): case t.IsComplex():
var elemType Type var elemType Type
if t.Size() == 16 { if t.Size() == 16 {
elemType = f.fe.TypeFloat64() elemType = f.Config.Types.Float64
} else { } else {
elemType = f.fe.TypeFloat32() elemType = f.Config.Types.Float32
} }
rName, iName := f.fe.SplitComplex(name) rName, iName := f.fe.SplitComplex(name)
newNames = append(newNames, rName, iName) newNames = append(newNames, rName, iName)
@ -58,8 +58,8 @@ func decomposeBuiltIn(f *Func) {
} }
delete(f.NamedValues, name) delete(f.NamedValues, name)
case t.IsString(): case t.IsString():
ptrType := f.fe.TypeBytePtr() ptrType := f.Config.Types.BytePtr
lenType := f.fe.TypeInt() lenType := f.Config.Types.Int
ptrName, lenName := f.fe.SplitString(name) ptrName, lenName := f.fe.SplitString(name)
newNames = append(newNames, ptrName, lenName) newNames = append(newNames, ptrName, lenName)
for _, v := range f.NamedValues[name] { for _, v := range f.NamedValues[name] {
@ -70,8 +70,8 @@ func decomposeBuiltIn(f *Func) {
} }
delete(f.NamedValues, name) delete(f.NamedValues, name)
case t.IsSlice(): case t.IsSlice():
ptrType := f.fe.TypeBytePtr() ptrType := f.Config.Types.BytePtr
lenType := f.fe.TypeInt() lenType := f.Config.Types.Int
ptrName, lenName, capName := f.fe.SplitSlice(name) ptrName, lenName, capName := f.fe.SplitSlice(name)
newNames = append(newNames, ptrName, lenName, capName) newNames = append(newNames, ptrName, lenName, capName)
for _, v := range f.NamedValues[name] { for _, v := range f.NamedValues[name] {
@ -84,7 +84,7 @@ func decomposeBuiltIn(f *Func) {
} }
delete(f.NamedValues, name) delete(f.NamedValues, name)
case t.IsInterface(): case t.IsInterface():
ptrType := f.fe.TypeBytePtr() ptrType := f.Config.Types.BytePtr
typeName, dataName := f.fe.SplitInterface(name) typeName, dataName := f.fe.SplitInterface(name)
newNames = append(newNames, typeName, dataName) newNames = append(newNames, typeName, dataName)
for _, v := range f.NamedValues[name] { for _, v := range f.NamedValues[name] {
@ -129,9 +129,9 @@ func decomposeBuiltInPhi(v *Value) {
} }
func decomposeStringPhi(v *Value) { func decomposeStringPhi(v *Value) {
fe := v.Block.Func.fe types := &v.Block.Func.Config.Types
ptrType := fe.TypeBytePtr() ptrType := types.BytePtr
lenType := fe.TypeInt() lenType := types.Int
ptr := v.Block.NewValue0(v.Pos, OpPhi, ptrType) ptr := v.Block.NewValue0(v.Pos, OpPhi, ptrType)
len := v.Block.NewValue0(v.Pos, OpPhi, lenType) len := v.Block.NewValue0(v.Pos, OpPhi, lenType)
@ -145,9 +145,9 @@ func decomposeStringPhi(v *Value) {
} }
func decomposeSlicePhi(v *Value) { func decomposeSlicePhi(v *Value) {
fe := v.Block.Func.fe types := &v.Block.Func.Config.Types
ptrType := fe.TypeBytePtr() ptrType := types.BytePtr
lenType := fe.TypeInt() lenType := types.Int
ptr := v.Block.NewValue0(v.Pos, OpPhi, ptrType) ptr := v.Block.NewValue0(v.Pos, OpPhi, ptrType)
len := v.Block.NewValue0(v.Pos, OpPhi, lenType) len := v.Block.NewValue0(v.Pos, OpPhi, lenType)
@ -164,19 +164,19 @@ func decomposeSlicePhi(v *Value) {
} }
func decomposeInt64Phi(v *Value) { func decomposeInt64Phi(v *Value) {
fe := v.Block.Func.fe types := &v.Block.Func.Config.Types
var partType Type var partType Type
if v.Type.IsSigned() { if v.Type.IsSigned() {
partType = fe.TypeInt32() partType = types.Int32
} else { } else {
partType = fe.TypeUInt32() partType = types.UInt32
} }
hi := v.Block.NewValue0(v.Pos, OpPhi, partType) hi := v.Block.NewValue0(v.Pos, OpPhi, partType)
lo := v.Block.NewValue0(v.Pos, OpPhi, fe.TypeUInt32()) lo := v.Block.NewValue0(v.Pos, OpPhi, types.UInt32)
for _, a := range v.Args { for _, a := range v.Args {
hi.AddArg(a.Block.NewValue1(v.Pos, OpInt64Hi, partType, a)) hi.AddArg(a.Block.NewValue1(v.Pos, OpInt64Hi, partType, a))
lo.AddArg(a.Block.NewValue1(v.Pos, OpInt64Lo, fe.TypeUInt32(), a)) lo.AddArg(a.Block.NewValue1(v.Pos, OpInt64Lo, types.UInt32, a))
} }
v.reset(OpInt64Make) v.reset(OpInt64Make)
v.AddArg(hi) v.AddArg(hi)
@ -184,13 +184,13 @@ func decomposeInt64Phi(v *Value) {
} }
func decomposeComplexPhi(v *Value) { func decomposeComplexPhi(v *Value) {
fe := v.Block.Func.fe types := &v.Block.Func.Config.Types
var partType Type var partType Type
switch z := v.Type.Size(); z { switch z := v.Type.Size(); z {
case 8: case 8:
partType = fe.TypeFloat32() partType = types.Float32
case 16: case 16:
partType = fe.TypeFloat64() partType = types.Float64
default: default:
v.Fatalf("decomposeComplexPhi: bad complex size %d", z) v.Fatalf("decomposeComplexPhi: bad complex size %d", z)
} }
@ -207,7 +207,7 @@ func decomposeComplexPhi(v *Value) {
} }
func decomposeInterfacePhi(v *Value) { func decomposeInterfacePhi(v *Value) {
ptrType := v.Block.Func.fe.TypeBytePtr() ptrType := v.Block.Func.Config.Types.BytePtr
itab := v.Block.NewValue0(v.Pos, OpPhi, ptrType) itab := v.Block.NewValue0(v.Pos, OpPhi, ptrType)
data := v.Block.NewValue0(v.Pos, OpPhi, ptrType) data := v.Block.NewValue0(v.Pos, OpPhi, ptrType)

53
src/cmd/compile/internal/ssa/export_test.go
View file

@ -19,11 +19,11 @@ var Copyelim = copyelim
var TestCtxt = obj.Linknew(&x86.Linkamd64) var TestCtxt = obj.Linknew(&x86.Linkamd64)
func testConfig(t testing.TB) *Config { func testConfig(t testing.TB) *Config {
return NewConfig("amd64", TestCtxt, true) return NewConfig("amd64", dummyTypes, TestCtxt, true)
} }
func testConfigS390X(t testing.TB) *Config { func testConfigS390X(t testing.TB) *Config {
return NewConfig("s390x", obj.Linknew(&s390x.Links390x), true) return NewConfig("s390x", dummyTypes, obj.Linknew(&s390x.Links390x), true)
} }
// DummyFrontend is a test-only frontend. // DummyFrontend is a test-only frontend.
@ -52,27 +52,27 @@ func (DummyFrontend) Auto(t Type) GCNode {
return &DummyAuto{t: t, s: "aDummyAuto"} return &DummyAuto{t: t, s: "aDummyAuto"}
} }
func (d DummyFrontend) SplitString(s LocalSlot) (LocalSlot, LocalSlot) { func (d DummyFrontend) SplitString(s LocalSlot) (LocalSlot, LocalSlot) {
return LocalSlot{s.N, d.TypeBytePtr(), s.Off}, LocalSlot{s.N, d.TypeInt(), s.Off + 8} return LocalSlot{s.N, dummyTypes.BytePtr, s.Off}, LocalSlot{s.N, dummyTypes.Int, s.Off + 8}
} }
func (d DummyFrontend) SplitInterface(s LocalSlot) (LocalSlot, LocalSlot) { func (d DummyFrontend) SplitInterface(s LocalSlot) (LocalSlot, LocalSlot) {
return LocalSlot{s.N, d.TypeBytePtr(), s.Off}, LocalSlot{s.N, d.TypeBytePtr(), s.Off + 8} return LocalSlot{s.N, dummyTypes.BytePtr, s.Off}, LocalSlot{s.N, dummyTypes.BytePtr, s.Off + 8}
} }
func (d DummyFrontend) SplitSlice(s LocalSlot) (LocalSlot, LocalSlot, LocalSlot) { func (d DummyFrontend) SplitSlice(s LocalSlot) (LocalSlot, LocalSlot, LocalSlot) {
return LocalSlot{s.N, s.Type.ElemType().PtrTo(), s.Off}, return LocalSlot{s.N, s.Type.ElemType().PtrTo(), s.Off},
LocalSlot{s.N, d.TypeInt(), s.Off + 8}, LocalSlot{s.N, dummyTypes.Int, s.Off + 8},
LocalSlot{s.N, d.TypeInt(), s.Off + 16} LocalSlot{s.N, dummyTypes.Int, s.Off + 16}
} }
func (d DummyFrontend) SplitComplex(s LocalSlot) (LocalSlot, LocalSlot) { func (d DummyFrontend) SplitComplex(s LocalSlot) (LocalSlot, LocalSlot) {
if s.Type.Size() == 16 { if s.Type.Size() == 16 {
return LocalSlot{s.N, d.TypeFloat64(), s.Off}, LocalSlot{s.N, d.TypeFloat64(), s.Off + 8} return LocalSlot{s.N, dummyTypes.Float64, s.Off}, LocalSlot{s.N, dummyTypes.Float64, s.Off + 8}
} }
return LocalSlot{s.N, d.TypeFloat32(), s.Off}, LocalSlot{s.N, d.TypeFloat32(), s.Off + 4} return LocalSlot{s.N, dummyTypes.Float32, s.Off}, LocalSlot{s.N, dummyTypes.Float32, s.Off + 4}
} }
func (d DummyFrontend) SplitInt64(s LocalSlot) (LocalSlot, LocalSlot) { func (d DummyFrontend) SplitInt64(s LocalSlot) (LocalSlot, LocalSlot) {
if s.Type.IsSigned() { if s.Type.IsSigned() {
return LocalSlot{s.N, d.TypeInt32(), s.Off + 4}, LocalSlot{s.N, d.TypeUInt32(), s.Off} return LocalSlot{s.N, dummyTypes.Int32, s.Off + 4}, LocalSlot{s.N, dummyTypes.UInt32, s.Off}
} }
return LocalSlot{s.N, d.TypeUInt32(), s.Off + 4}, LocalSlot{s.N, d.TypeUInt32(), s.Off} return LocalSlot{s.N, dummyTypes.UInt32, s.Off + 4}, LocalSlot{s.N, dummyTypes.UInt32, s.Off}
} }
func (d DummyFrontend) SplitStruct(s LocalSlot, i int) LocalSlot { func (d DummyFrontend) SplitStruct(s LocalSlot, i int) LocalSlot {
return LocalSlot{s.N, s.Type.FieldType(i), s.Off + s.Type.FieldOff(i)} return LocalSlot{s.N, s.Type.FieldType(i), s.Off + s.Type.FieldOff(i)}
@ -101,21 +101,24 @@ func (d DummyFrontend) Warnl(_ src.XPos, msg string, args ...interface{}) { d.t
func (d DummyFrontend) Debug_checknil() bool { return false } func (d DummyFrontend) Debug_checknil() bool { return false }
func (d DummyFrontend) Debug_wb() bool { return false } func (d DummyFrontend) Debug_wb() bool { return false }
func (d DummyFrontend) TypeBool() Type { return TypeBool } var dummyTypes = Types{
func (d DummyFrontend) TypeInt8() Type { return TypeInt8 } Bool: TypeBool,
func (d DummyFrontend) TypeInt16() Type { return TypeInt16 } Int8: TypeInt8,
func (d DummyFrontend) TypeInt32() Type { return TypeInt32 } Int16: TypeInt16,
func (d DummyFrontend) TypeInt64() Type { return TypeInt64 } Int32: TypeInt32,
func (d DummyFrontend) TypeUInt8() Type { return TypeUInt8 } Int64: TypeInt64,
func (d DummyFrontend) TypeUInt16() Type { return TypeUInt16 } UInt8: TypeUInt8,
func (d DummyFrontend) TypeUInt32() Type { return TypeUInt32 } UInt16: TypeUInt16,
func (d DummyFrontend) TypeUInt64() Type { return TypeUInt64 } UInt32: TypeUInt32,
func (d DummyFrontend) TypeFloat32() Type { return TypeFloat32 } UInt64: TypeUInt64,
func (d DummyFrontend) TypeFloat64() Type { return TypeFloat64 } Float32: TypeFloat32,
func (d DummyFrontend) TypeInt() Type { return TypeInt64 } Float64: TypeFloat64,
func (d DummyFrontend) TypeUintptr() Type { return TypeUInt64 } Int: TypeInt64,
func (d DummyFrontend) TypeString() Type { panic("unimplemented") } Uintptr: TypeUInt64,
func (d DummyFrontend) TypeBytePtr() Type { return TypeBytePtr } String: nil,
BytePtr: TypeBytePtr,
}
func (d DummyFrontend) DerefItab(sym *obj.LSym, off int64) *obj.LSym { return nil } func (d DummyFrontend) DerefItab(sym *obj.LSym, off int64) *obj.LSym { return nil }
func (d DummyFrontend) CanSSA(t Type) bool { func (d DummyFrontend) CanSSA(t Type) bool {

4
src/cmd/compile/internal/ssa/gen/386.rules
View file

@ -68,8 +68,8 @@
(Neg32 x) -> (NEGL x) (Neg32 x) -> (NEGL x)
(Neg16 x) -> (NEGL x) (Neg16 x) -> (NEGL x)
(Neg8 x) -> (NEGL x) (Neg8 x) -> (NEGL x)
(Neg32F x) && !config.use387 -> (PXOR x (MOVSSconst <fe.TypeFloat32()> [f2i(math.Copysign(0, -1))])) (Neg32F x) && !config.use387 -> (PXOR x (MOVSSconst <types.Float32> [f2i(math.Copysign(0, -1))]))
(Neg64F x) && !config.use387 -> (PXOR x (MOVSDconst <fe.TypeFloat64()> [f2i(math.Copysign(0, -1))])) (Neg64F x) && !config.use387 -> (PXOR x (MOVSDconst <types.Float64> [f2i(math.Copysign(0, -1))]))
(Neg32F x) && config.use387 -> (FCHS x) (Neg32F x) && config.use387 -> (FCHS x)
(Neg64F x) && config.use387 -> (FCHS x) (Neg64F x) && config.use387 -> (FCHS x)

20
src/cmd/compile/internal/ssa/gen/AMD64.rules
View file

@ -78,8 +78,8 @@
(Neg32 x) -> (NEGL x) (Neg32 x) -> (NEGL x)
(Neg16 x) -> (NEGL x) (Neg16 x) -> (NEGL x)
(Neg8 x) -> (NEGL x) (Neg8 x) -> (NEGL x)
(Neg32F x) -> (PXOR x (MOVSSconst <fe.TypeFloat32()> [f2i(math.Copysign(0, -1))])) (Neg32F x) -> (PXOR x (MOVSSconst <types.Float32> [f2i(math.Copysign(0, -1))]))
(Neg64F x) -> (PXOR x (MOVSDconst <fe.TypeFloat64()> [f2i(math.Copysign(0, -1))])) (Neg64F x) -> (PXOR x (MOVSDconst <types.Float64> [f2i(math.Copysign(0, -1))]))
(Com64 x) -> (NOTQ x) (Com64 x) -> (NOTQ x)
(Com32 x) -> (NOTL x) (Com32 x) -> (NOTL x)
@ -98,10 +98,10 @@
// Lowering other arithmetic // Lowering other arithmetic
(Ctz64 <t> x) -> (CMOVQEQ (Select0 <t> (BSFQ x)) (MOVQconst <t> [64]) (Select1 <TypeFlags> (BSFQ x))) (Ctz64 <t> x) -> (CMOVQEQ (Select0 <t> (BSFQ x)) (MOVQconst <t> [64]) (Select1 <TypeFlags> (BSFQ x)))
(Ctz32 x) -> (Select0 (BSFQ (ORQ <fe.TypeUInt64()> (MOVQconst [1<<32]) x))) (Ctz32 x) -> (Select0 (BSFQ (ORQ <types.UInt64> (MOVQconst [1<<32]) x)))
(BitLen64 <t> x) -> (ADDQconst [1] (CMOVQEQ <t> (Select0 <t> (BSRQ x)) (MOVQconst <t> [-1]) (Select1 <TypeFlags> (BSRQ x)))) (BitLen64 <t> x) -> (ADDQconst [1] (CMOVQEQ <t> (Select0 <t> (BSRQ x)) (MOVQconst <t> [-1]) (Select1 <TypeFlags> (BSRQ x))))
(BitLen32 x) -> (BitLen64 (MOVLQZX <fe.TypeUInt64()> x)) (BitLen32 x) -> (BitLen64 (MOVLQZX <types.UInt64> x))
(Bswap64 x) -> (BSWAPQ x) (Bswap64 x) -> (BSWAPQ x)
(Bswap32 x) -> (BSWAPL x) (Bswap32 x) -> (BSWAPL x)
@ -472,10 +472,10 @@
// Atomic stores. We use XCHG to prevent the hardware reordering a subsequent load. // Atomic stores. We use XCHG to prevent the hardware reordering a subsequent load.
// TODO: most runtime uses of atomic stores don't need that property. Use normal stores for those? // TODO: most runtime uses of atomic stores don't need that property. Use normal stores for those?
(AtomicStore32 ptr val mem) -> (Select1 (XCHGL <MakeTuple(fe.TypeUInt32(),TypeMem)> val ptr mem)) (AtomicStore32 ptr val mem) -> (Select1 (XCHGL <MakeTuple(types.UInt32,TypeMem)> val ptr mem))
(AtomicStore64 ptr val mem) -> (Select1 (XCHGQ <MakeTuple(fe.TypeUInt64(),TypeMem)> val ptr mem)) (AtomicStore64 ptr val mem) -> (Select1 (XCHGQ <MakeTuple(types.UInt64,TypeMem)> val ptr mem))
(AtomicStorePtrNoWB ptr val mem) && config.PtrSize == 8 -> (Select1 (XCHGQ <MakeTuple(fe.TypeBytePtr(),TypeMem)> val ptr mem)) (AtomicStorePtrNoWB ptr val mem) && config.PtrSize == 8 -> (Select1 (XCHGQ <MakeTuple(types.BytePtr,TypeMem)> val ptr mem))
(AtomicStorePtrNoWB ptr val mem) && config.PtrSize == 4 -> (Select1 (XCHGL <MakeTuple(fe.TypeBytePtr(),TypeMem)> val ptr mem)) (AtomicStorePtrNoWB ptr val mem) && config.PtrSize == 4 -> (Select1 (XCHGL <MakeTuple(types.BytePtr,TypeMem)> val ptr mem))
// Atomic exchanges. // Atomic exchanges.
(AtomicExchange32 ptr val mem) -> (XCHGL val ptr mem) (AtomicExchange32 ptr val mem) -> (XCHGL val ptr mem)
@ -553,8 +553,8 @@
(NE (TESTB (SETNEF cmp) (SETNEF cmp)) yes no) -> (NEF cmp yes no) (NE (TESTB (SETNEF cmp) (SETNEF cmp)) yes no) -> (NEF cmp yes no)
// Disabled because it interferes with the pattern match above and makes worse code. // Disabled because it interferes with the pattern match above and makes worse code.
// (SETNEF x) -> (ORQ (SETNE <fe.TypeInt8()> x) (SETNAN <fe.TypeInt8()> x)) // (SETNEF x) -> (ORQ (SETNE <types.Int8> x) (SETNAN <types.Int8> x))
// (SETEQF x) -> (ANDQ (SETEQ <fe.TypeInt8()> x) (SETORD <fe.TypeInt8()> x)) // (SETEQF x) -> (ANDQ (SETEQ <types.Int8> x) (SETORD <types.Int8> x))
// fold constants into instructions // fold constants into instructions
(ADDQ x (MOVQconst [c])) && is32Bit(c) -> (ADDQconst [c] x) (ADDQ x (MOVQconst [c])) && is32Bit(c) -> (ADDQconst [c] x)

38
src/cmd/compile/internal/ssa/gen/ARM.rules
View file

@ -34,12 +34,12 @@
(Mul32uhilo x y) -> (MULLU x y) (Mul32uhilo x y) -> (MULLU x y)
(Div32 x y) -> (Div32 x y) ->
(SUB (XOR <fe.TypeUInt32()> // negate the result if one operand is negative (SUB (XOR <types.UInt32> // negate the result if one operand is negative
(Select0 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} (Select0 <types.UInt32> (CALLudiv {config.ctxt.Lookup("udiv", 0)}
(SUB <fe.TypeUInt32()> (XOR x <fe.TypeUInt32()> (Signmask x)) (Signmask x)) // negate x if negative (SUB <types.UInt32> (XOR x <types.UInt32> (Signmask x)) (Signmask x)) // negate x if negative
(SUB <fe.TypeUInt32()> (XOR y <fe.TypeUInt32()> (Signmask y)) (Signmask y)))) // negate y if negative (SUB <types.UInt32> (XOR y <types.UInt32> (Signmask y)) (Signmask y)))) // negate y if negative
(Signmask (XOR <fe.TypeUInt32()> x y))) (Signmask (XOR <fe.TypeUInt32()> x y))) (Signmask (XOR <types.UInt32> x y))) (Signmask (XOR <types.UInt32> x y)))
(Div32u x y) -> (Select0 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y)) (Div32u x y) -> (Select0 <types.UInt32> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y))
(Div16 x y) -> (Div32 (SignExt16to32 x) (SignExt16to32 y)) (Div16 x y) -> (Div32 (SignExt16to32 x) (SignExt16to32 y))
(Div16u x y) -> (Div32u (ZeroExt16to32 x) (ZeroExt16to32 y)) (Div16u x y) -> (Div32u (ZeroExt16to32 x) (ZeroExt16to32 y))
(Div8 x y) -> (Div32 (SignExt8to32 x) (SignExt8to32 y)) (Div8 x y) -> (Div32 (SignExt8to32 x) (SignExt8to32 y))
@ -48,12 +48,12 @@
(Div64F x y) -> (DIVD x y) (Div64F x y) -> (DIVD x y)
(Mod32 x y) -> (Mod32 x y) ->
(SUB (XOR <fe.TypeUInt32()> // negate the result if x is negative (SUB (XOR <types.UInt32> // negate the result if x is negative
(Select1 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} (Select1 <types.UInt32> (CALLudiv {config.ctxt.Lookup("udiv", 0)}
(SUB <fe.TypeUInt32()> (XOR <fe.TypeUInt32()> x (Signmask x)) (Signmask x)) // negate x if negative (SUB <types.UInt32> (XOR <types.UInt32> x (Signmask x)) (Signmask x)) // negate x if negative
(SUB <fe.TypeUInt32()> (XOR <fe.TypeUInt32()> y (Signmask y)) (Signmask y)))) // negate y if negative (SUB <types.UInt32> (XOR <types.UInt32> y (Signmask y)) (Signmask y)))) // negate y if negative
(Signmask x)) (Signmask x)) (Signmask x)) (Signmask x))
(Mod32u x y) -> (Select1 <fe.TypeUInt32()> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y)) (Mod32u x y) -> (Select1 <types.UInt32> (CALLudiv {config.ctxt.Lookup("udiv", 0)} x y))
(Mod16 x y) -> (Mod32 (SignExt16to32 x) (SignExt16to32 y)) (Mod16 x y) -> (Mod32 (SignExt16to32 x) (SignExt16to32 y))
(Mod16u x y) -> (Mod32u (ZeroExt16to32 x) (ZeroExt16to32 y)) (Mod16u x y) -> (Mod32u (ZeroExt16to32 x) (ZeroExt16to32 y))
(Mod8 x y) -> (Mod32 (SignExt8to32 x) (SignExt8to32 y)) (Mod8 x y) -> (Mod32 (SignExt8to32 x) (SignExt8to32 y))
@ -111,7 +111,7 @@
// boolean ops -- booleans are represented with 0=false, 1=true // boolean ops -- booleans are represented with 0=false, 1=true
(AndB x y) -> (AND x y) (AndB x y) -> (AND x y)
(OrB x y) -> (OR x y) (OrB x y) -> (OR x y)
(EqB x y) -> (XORconst [1] (XOR <fe.TypeBool()> x y)) (EqB x y) -> (XORconst [1] (XOR <types.Bool> x y))
(NeqB x y) -> (XOR x y) (NeqB x y) -> (XOR x y)
(Not x) -> (XORconst [1] x) (Not x) -> (XORconst [1] x)
@ -160,11 +160,11 @@
(Rsh32x64 x (Const64 [c])) && uint64(c) < 32 -> (SRAconst x [c]) (Rsh32x64 x (Const64 [c])) && uint64(c) < 32 -> (SRAconst x [c])
(Rsh32Ux64 x (Const64 [c])) && uint64(c) < 32 -> (SRLconst x [c]) (Rsh32Ux64 x (Const64 [c])) && uint64(c) < 32 -> (SRLconst x [c])
(Lsh16x64 x (Const64 [c])) && uint64(c) < 16 -> (SLLconst x [c]) (Lsh16x64 x (Const64 [c])) && uint64(c) < 16 -> (SLLconst x [c])
(Rsh16x64 x (Const64 [c])) && uint64(c) < 16 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16]) (Rsh16x64 x (Const64 [c])) && uint64(c) < 16 -> (SRAconst (SLLconst <types.UInt32> x [16]) [c+16])
(Rsh16Ux64 x (Const64 [c])) && uint64(c) < 16 -> (SRLconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16]) (Rsh16Ux64 x (Const64 [c])) && uint64(c) < 16 -> (SRLconst (SLLconst <types.UInt32> x [16]) [c+16])
(Lsh8x64 x (Const64 [c])) && uint64(c) < 8 -> (SLLconst x [c]) (Lsh8x64 x (Const64 [c])) && uint64(c) < 8 -> (SLLconst x [c])
(Rsh8x64 x (Const64 [c])) && uint64(c) < 8 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24]) (Rsh8x64 x (Const64 [c])) && uint64(c) < 8 -> (SRAconst (SLLconst <types.UInt32> x [24]) [c+24])
(Rsh8Ux64 x (Const64 [c])) && uint64(c) < 8 -> (SRLconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24]) (Rsh8Ux64 x (Const64 [c])) && uint64(c) < 8 -> (SRLconst (SLLconst <types.UInt32> x [24]) [c+24])
// large constant shifts // large constant shifts
(Lsh32x64 _ (Const64 [c])) && uint64(c) >= 32 -> (Const32 [0]) (Lsh32x64 _ (Const64 [c])) && uint64(c) >= 32 -> (Const32 [0])
@ -176,8 +176,8 @@
// large constant signed right shift, we leave the sign bit // large constant signed right shift, we leave the sign bit
(Rsh32x64 x (Const64 [c])) && uint64(c) >= 32 -> (SRAconst x [31]) (Rsh32x64 x (Const64 [c])) && uint64(c) >= 32 -> (SRAconst x [31])
(Rsh16x64 x (Const64 [c])) && uint64(c) >= 16 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [31]) (Rsh16x64 x (Const64 [c])) && uint64(c) >= 16 -> (SRAconst (SLLconst <types.UInt32> x [16]) [31])
(Rsh8x64 x (Const64 [c])) && uint64(c) >= 8 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [31]) (Rsh8x64 x (Const64 [c])) && uint64(c) >= 8 -> (SRAconst (SLLconst <types.UInt32> x [24]) [31])
// constants // constants
(Const8 [val]) -> (MOVWconst [val]) (Const8 [val]) -> (MOVWconst [val])
@ -204,7 +204,7 @@
(SignExt16to32 x) -> (MOVHreg x) (SignExt16to32 x) -> (MOVHreg x)
(Signmask x) -> (SRAconst x [31]) (Signmask x) -> (SRAconst x [31])
(Zeromask x) -> (SRAconst (RSBshiftRL <fe.TypeInt32()> x x [1]) [31]) // sign bit of uint32(x)>>1 - x (Zeromask x) -> (SRAconst (RSBshiftRL <types.Int32> x x [1]) [31]) // sign bit of uint32(x)>>1 - x
(Slicemask <t> x) -> (SRAconst (RSBconst <t> [0] x) [31]) (Slicemask <t> x) -> (SRAconst (RSBconst <t> [0] x) [31])
// float <-> int conversion // float <-> int conversion

12
src/cmd/compile/internal/ssa/gen/ARM64.rules
View file

@ -27,8 +27,8 @@
(Hmul64 x y) -> (MULH x y) (Hmul64 x y) -> (MULH x y)
(Hmul64u x y) -> (UMULH x y) (Hmul64u x y) -> (UMULH x y)
(Hmul32 x y) -> (SRAconst (MULL <fe.TypeInt64()> x y) [32]) (Hmul32 x y) -> (SRAconst (MULL <types.Int64> x y) [32])
(Hmul32u x y) -> (SRAconst (UMULL <fe.TypeUInt64()> x y) [32]) (Hmul32u x y) -> (SRAconst (UMULL <types.UInt64> x y) [32])
(Div64 x y) -> (DIV x y) (Div64 x y) -> (DIV x y)
(Div64u x y) -> (UDIV x y) (Div64u x y) -> (UDIV x y)
@ -86,20 +86,20 @@
(Ctz64 <t> x) -> (CLZ (RBIT <t> x)) (Ctz64 <t> x) -> (CLZ (RBIT <t> x))
(Ctz32 <t> x) -> (CLZW (RBITW <t> x)) (Ctz32 <t> x) -> (CLZW (RBITW <t> x))
(BitLen64 x) -> (SUB (MOVDconst [64]) (CLZ <fe.TypeInt()> x)) (BitLen64 x) -> (SUB (MOVDconst [64]) (CLZ <types.Int> x))
(Bswap64 x) -> (REV x) (Bswap64 x) -> (REV x)
(Bswap32 x) -> (REVW x) (Bswap32 x) -> (REVW x)
(BitRev64 x) -> (RBIT x) (BitRev64 x) -> (RBIT x)
(BitRev32 x) -> (RBITW x) (BitRev32 x) -> (RBITW x)
(BitRev16 x) -> (SRLconst [48] (RBIT <fe.TypeUInt64()> x)) (BitRev16 x) -> (SRLconst [48] (RBIT <types.UInt64> x))
(BitRev8 x) -> (SRLconst [56] (RBIT <fe.TypeUInt64()> x)) (BitRev8 x) -> (SRLconst [56] (RBIT <types.UInt64> x))
// boolean ops -- booleans are represented with 0=false, 1=true // boolean ops -- booleans are represented with 0=false, 1=true
(AndB x y) -> (AND x y) (AndB x y) -> (AND x y)
(OrB x y) -> (OR x y) (OrB x y) -> (OR x y)
(EqB x y) -> (XOR (MOVDconst [1]) (XOR <fe.TypeBool()> x y)) (EqB x y) -> (XOR (MOVDconst [1]) (XOR <types.Bool> x y))
(NeqB x y) -> (XOR x y) (NeqB x y) -> (XOR x y)
(Not x) -> (XOR (MOVDconst [1]) x) (Not x) -> (XOR (MOVDconst [1]) x)

88
src/cmd/compile/internal/ssa/gen/MIPS.rules
View file

@ -10,7 +10,7 @@
(Add64F x y) -> (ADDD x y) (Add64F x y) -> (ADDD x y)
(Select0 (Add32carry <t> x y)) -> (ADD <t.FieldType(0)> x y) (Select0 (Add32carry <t> x y)) -> (ADD <t.FieldType(0)> x y)
(Select1 (Add32carry <t> x y)) -> (SGTU <fe.TypeBool()> x (ADD <t.FieldType(0)> x y)) (Select1 (Add32carry <t> x y)) -> (SGTU <types.Bool> x (ADD <t.FieldType(0)> x y))
(Add32withcarry <t> x y c) -> (ADD c (ADD <t> x y)) (Add32withcarry <t> x y c) -> (ADD c (ADD <t> x y))
(SubPtr x y) -> (SUB x y) (SubPtr x y) -> (SUB x y)
@ -21,7 +21,7 @@
(Sub64F x y) -> (SUBD x y) (Sub64F x y) -> (SUBD x y)
(Select0 (Sub32carry <t> x y)) -> (SUB <t.FieldType(0)> x y) (Select0 (Sub32carry <t> x y)) -> (SUB <t.FieldType(0)> x y)
(Select1 (Sub32carry <t> x y)) -> (SGTU <fe.TypeBool()> (SUB <t.FieldType(0)> x y) x) (Select1 (Sub32carry <t> x y)) -> (SGTU <types.Bool> (SUB <t.FieldType(0)> x y) x)
(Sub32withcarry <t> x y c) -> (SUB (SUB <t> x y) c) (Sub32withcarry <t> x y c) -> (SUB (SUB <t> x y) c)
(Mul32 x y) -> (MUL x y) (Mul32 x y) -> (MUL x y)
@ -72,11 +72,11 @@
(Rsh32x64 x (Const64 [c])) && uint32(c) < 32 -> (SRAconst x [c]) (Rsh32x64 x (Const64 [c])) && uint32(c) < 32 -> (SRAconst x [c])
(Rsh32Ux64 x (Const64 [c])) && uint32(c) < 32 -> (SRLconst x [c]) (Rsh32Ux64 x (Const64 [c])) && uint32(c) < 32 -> (SRLconst x [c])
(Lsh16x64 x (Const64 [c])) && uint32(c) < 16 -> (SLLconst x [c]) (Lsh16x64 x (Const64 [c])) && uint32(c) < 16 -> (SLLconst x [c])
(Rsh16x64 x (Const64 [c])) && uint32(c) < 16 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16]) (Rsh16x64 x (Const64 [c])) && uint32(c) < 16 -> (SRAconst (SLLconst <types.UInt32> x [16]) [c+16])
(Rsh16Ux64 x (Const64 [c])) && uint32(c) < 16 -> (SRLconst (SLLconst <fe.TypeUInt32()> x [16]) [c+16]) (Rsh16Ux64 x (Const64 [c])) && uint32(c) < 16 -> (SRLconst (SLLconst <types.UInt32> x [16]) [c+16])
(Lsh8x64 x (Const64 [c])) && uint32(c) < 8 -> (SLLconst x [c]) (Lsh8x64 x (Const64 [c])) && uint32(c) < 8 -> (SLLconst x [c])
(Rsh8x64 x (Const64 [c])) && uint32(c) < 8 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24]) (Rsh8x64 x (Const64 [c])) && uint32(c) < 8 -> (SRAconst (SLLconst <types.UInt32> x [24]) [c+24])
(Rsh8Ux64 x (Const64 [c])) && uint32(c) < 8 -> (SRLconst (SLLconst <fe.TypeUInt32()> x [24]) [c+24]) (Rsh8Ux64 x (Const64 [c])) && uint32(c) < 8 -> (SRLconst (SLLconst <types.UInt32> x [24]) [c+24])
// large constant shifts // large constant shifts
(Lsh32x64 _ (Const64 [c])) && uint32(c) >= 32 -> (MOVWconst [0]) (Lsh32x64 _ (Const64 [c])) && uint32(c) >= 32 -> (MOVWconst [0])
@ -88,8 +88,8 @@
// large constant signed right shift, we leave the sign bit // large constant signed right shift, we leave the sign bit
(Rsh32x64 x (Const64 [c])) && uint32(c) >= 32 -> (SRAconst x [31]) (Rsh32x64 x (Const64 [c])) && uint32(c) >= 32 -> (SRAconst x [31])
(Rsh16x64 x (Const64 [c])) && uint32(c) >= 16 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [16]) [31]) (Rsh16x64 x (Const64 [c])) && uint32(c) >= 16 -> (SRAconst (SLLconst <types.UInt32> x [16]) [31])
(Rsh8x64 x (Const64 [c])) && uint32(c) >= 8 -> (SRAconst (SLLconst <fe.TypeUInt32()> x [24]) [31]) (Rsh8x64 x (Const64 [c])) && uint32(c) >= 8 -> (SRAconst (SLLconst <types.UInt32> x [24]) [31])
// shifts // shifts
// hardware instruction uses only the low 5 bits of the shift // hardware instruction uses only the low 5 bits of the shift
@ -118,17 +118,17 @@
(Rsh8Ux16 <t> x y) -> (CMOVZ (SRL <t> (ZeroExt8to32 x) (ZeroExt16to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt16to32 y))) (Rsh8Ux16 <t> x y) -> (CMOVZ (SRL <t> (ZeroExt8to32 x) (ZeroExt16to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt16to32 y)))
(Rsh8Ux8 <t> x y) -> (CMOVZ (SRL <t> (ZeroExt8to32 x) (ZeroExt8to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt8to32 y))) (Rsh8Ux8 <t> x y) -> (CMOVZ (SRL <t> (ZeroExt8to32 x) (ZeroExt8to32 y) ) (MOVWconst [0]) (SGTUconst [32] (ZeroExt8to32 y)))
(Rsh32x32 x y) -> (SRA x ( CMOVZ <fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y))) (Rsh32x32 x y) -> (SRA x ( CMOVZ <types.UInt32> y (MOVWconst [-1]) (SGTUconst [32] y)))
(Rsh32x16 x y) -> (SRA x ( CMOVZ <fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y)))) (Rsh32x16 x y) -> (SRA x ( CMOVZ <types.UInt32> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y))))
(Rsh32x8 x y) -> (SRA x ( CMOVZ <fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y)))) (Rsh32x8 x y) -> (SRA x ( CMOVZ <types.UInt32> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y))))
(Rsh16x32 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y))) (Rsh16x32 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> y (MOVWconst [-1]) (SGTUconst [32] y)))
(Rsh16x16 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y)))) (Rsh16x16 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y))))
(Rsh16x8 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y)))) (Rsh16x8 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y))))
(Rsh8x32 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> y (MOVWconst [-1]) (SGTUconst [32] y))) (Rsh8x32 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> y (MOVWconst [-1]) (SGTUconst [32] y)))
(Rsh8x16 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y)))) (Rsh8x16 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> (ZeroExt16to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt16to32 y))))
(Rsh8x8 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <fe.TypeUInt32()> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y)))) (Rsh8x8 x y) -> (SRA (SignExt16to32 x) ( CMOVZ <types.UInt32> (ZeroExt8to32 y) (MOVWconst [-1]) (SGTUconst [32] (ZeroExt8to32 y))))
// unary ops // unary ops
(Neg32 x) -> (NEG x) (Neg32 x) -> (NEG x)
@ -153,7 +153,7 @@
// boolean ops -- booleans are represented with 0=false, 1=true // boolean ops -- booleans are represented with 0=false, 1=true
(AndB x y) -> (AND x y) (AndB x y) -> (AND x y)
(OrB x y) -> (OR x y) (OrB x y) -> (OR x y)
(EqB x y) -> (XORconst [1] (XOR <fe.TypeBool()> x y)) (EqB x y) -> (XORconst [1] (XOR <types.Bool> x y))
(NeqB x y) -> (XOR x y) (NeqB x y) -> (XOR x y)
(Not x) -> (XORconst [1] x) (Not x) -> (XORconst [1] x)
@ -393,41 +393,41 @@
// AtomicOr8(ptr,val) -> LoweredAtomicOr(ptr&^3,uint32(val) << ((ptr & 3) * 8)) // AtomicOr8(ptr,val) -> LoweredAtomicOr(ptr&^3,uint32(val) << ((ptr & 3) * 8))
(AtomicOr8 ptr val mem) && !config.BigEndian -> (AtomicOr8 ptr val mem) && !config.BigEndian ->
(LoweredAtomicOr (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) (LoweredAtomicOr (AND <types.UInt32.PtrTo()> (MOVWconst [^3]) ptr)
(SLL <fe.TypeUInt32()> (ZeroExt8to32 val) (SLL <types.UInt32> (ZeroExt8to32 val)
(SLLconst <fe.TypeUInt32()> [3] (SLLconst <types.UInt32> [3]
(ANDconst <fe.TypeUInt32()> [3] ptr))) mem) (ANDconst <types.UInt32> [3] ptr))) mem)
// AtomicAnd8(ptr,val) -> LoweredAtomicAnd(ptr&^3,(uint32(val) << ((ptr & 3) * 8)) | ^(uint32(0xFF) << ((ptr & 3) * 8)))) // AtomicAnd8(ptr,val) -> LoweredAtomicAnd(ptr&^3,(uint32(val) << ((ptr & 3) * 8)) | ^(uint32(0xFF) << ((ptr & 3) * 8))))
(AtomicAnd8 ptr val mem) && !config.BigEndian -> (AtomicAnd8 ptr val mem) && !config.BigEndian ->
(LoweredAtomicAnd (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) (LoweredAtomicAnd (AND <types.UInt32.PtrTo()> (MOVWconst [^3]) ptr)
(OR <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> (ZeroExt8to32 val) (OR <types.UInt32> (SLL <types.UInt32> (ZeroExt8to32 val)
(SLLconst <fe.TypeUInt32()> [3] (SLLconst <types.UInt32> [3]
(ANDconst <fe.TypeUInt32()> [3] ptr))) (ANDconst <types.UInt32> [3] ptr)))
(NORconst [0] <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> (NORconst [0] <types.UInt32> (SLL <types.UInt32>
(MOVWconst [0xff]) (SLLconst <fe.TypeUInt32()> [3] (MOVWconst [0xff]) (SLLconst <types.UInt32> [3]
(ANDconst <fe.TypeUInt32()> [3] (ANDconst <types.UInt32> [3]
(XORconst <fe.TypeUInt32()> [3] ptr)))))) mem) (XORconst <types.UInt32> [3] ptr)))))) mem)
// AtomicOr8(ptr,val) -> LoweredAtomicOr(ptr&^3,uint32(val) << (((ptr^3) & 3) * 8)) // AtomicOr8(ptr,val) -> LoweredAtomicOr(ptr&^3,uint32(val) << (((ptr^3) & 3) * 8))
(AtomicOr8 ptr val mem) && config.BigEndian -> (AtomicOr8 ptr val mem) && config.BigEndian ->
(LoweredAtomicOr (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) (LoweredAtomicOr (AND <types.UInt32.PtrTo()> (MOVWconst [^3]) ptr)
(SLL <fe.TypeUInt32()> (ZeroExt8to32 val) (SLL <types.UInt32> (ZeroExt8to32 val)
(SLLconst <fe.TypeUInt32()> [3] (SLLconst <types.UInt32> [3]
(ANDconst <fe.TypeUInt32()> [3] (ANDconst <types.UInt32> [3]
(XORconst <fe.TypeUInt32()> [3] ptr)))) mem) (XORconst <types.UInt32> [3] ptr)))) mem)
// AtomicAnd8(ptr,val) -> LoweredAtomicAnd(ptr&^3,(uint32(val) << (((ptr^3) & 3) * 8)) | ^(uint32(0xFF) << (((ptr^3) & 3) * 8)))) // AtomicAnd8(ptr,val) -> LoweredAtomicAnd(ptr&^3,(uint32(val) << (((ptr^3) & 3) * 8)) | ^(uint32(0xFF) << (((ptr^3) & 3) * 8))))
(AtomicAnd8 ptr val mem) && config.BigEndian -> (AtomicAnd8 ptr val mem) && config.BigEndian ->
(LoweredAtomicAnd (AND <fe.TypeUInt32().PtrTo()> (MOVWconst [^3]) ptr) (LoweredAtomicAnd (AND <types.UInt32.PtrTo()> (MOVWconst [^3]) ptr)
(OR <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> (ZeroExt8to32 val) (OR <types.UInt32> (SLL <types.UInt32> (ZeroExt8to32 val)
(SLLconst <fe.TypeUInt32()> [3] (SLLconst <types.UInt32> [3]
(ANDconst <fe.TypeUInt32()> [3] (ANDconst <types.UInt32> [3]
(XORconst <fe.TypeUInt32()> [3] ptr)))) (XORconst <types.UInt32> [3] ptr))))
(NORconst [0] <fe.TypeUInt32()> (SLL <fe.TypeUInt32()> (NORconst [0] <types.UInt32> (SLL <types.UInt32>
(MOVWconst [0xff]) (SLLconst <fe.TypeUInt32()> [3] (MOVWconst [0xff]) (SLLconst <types.UInt32> [3]
(ANDconst <fe.TypeUInt32()> [3] (ANDconst <types.UInt32> [3]
(XORconst <fe.TypeUInt32()> [3] ptr)))))) mem) (XORconst <types.UInt32> [3] ptr)))))) mem)
// checks // checks

102
src/cmd/compile/internal/ssa/gen/MIPS64.rules
View file

@ -27,8 +27,8 @@
(Hmul64 x y) -> (Select0 (MULV x y)) (Hmul64 x y) -> (Select0 (MULV x y))
(Hmul64u x y) -> (Select0 (MULVU x y)) (Hmul64u x y) -> (Select0 (MULVU x y))
(Hmul32 x y) -> (SRAVconst (Select1 <fe.TypeInt64()> (MULV (SignExt32to64 x) (SignExt32to64 y))) [32]) (Hmul32 x y) -> (SRAVconst (Select1 <types.Int64> (MULV (SignExt32to64 x) (SignExt32to64 y))) [32])
(Hmul32u x y) -> (SRLVconst (Select1 <fe.TypeUInt64()> (MULVU (ZeroExt32to64 x) (ZeroExt32to64 y))) [32]) (Hmul32u x y) -> (SRLVconst (Select1 <types.UInt64> (MULVU (ZeroExt32to64 x) (ZeroExt32to64 y))) [32])
(Div64 x y) -> (Select1 (DIVV x y)) (Div64 x y) -> (Select1 (DIVV x y))
(Div64u x y) -> (Select1 (DIVVU x y)) (Div64u x y) -> (Select1 (DIVVU x y))
@ -71,65 +71,65 @@
// shifts // shifts
// hardware instruction uses only the low 6 bits of the shift // hardware instruction uses only the low 6 bits of the shift
// we compare to 64 to ensure Go semantics for large shifts // we compare to 64 to ensure Go semantics for large shifts
(Lsh64x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) (Lsh64x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SLLV <t> x y))
(Lsh64x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) (Lsh64x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
(Lsh64x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) (Lsh64x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
(Lsh64x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) (Lsh64x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
(Lsh32x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) (Lsh32x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SLLV <t> x y))
(Lsh32x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) (Lsh32x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
(Lsh32x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) (Lsh32x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
(Lsh32x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) (Lsh32x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
(Lsh16x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) (Lsh16x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SLLV <t> x y))
(Lsh16x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) (Lsh16x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
(Lsh16x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) (Lsh16x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
(Lsh16x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) (Lsh16x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
(Lsh8x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SLLV <t> x y)) (Lsh8x64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SLLV <t> x y))
(Lsh8x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y))) (Lsh8x32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SLLV <t> x (ZeroExt32to64 y)))
(Lsh8x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y))) (Lsh8x16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SLLV <t> x (ZeroExt16to64 y)))
(Lsh8x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y))) (Lsh8x8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SLLV <t> x (ZeroExt8to64 y)))
(Rsh64Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> x y)) (Rsh64Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SRLV <t> x y))
(Rsh64Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> x (ZeroExt32to64 y))) (Rsh64Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SRLV <t> x (ZeroExt32to64 y)))
(Rsh64Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> x (ZeroExt16to64 y))) (Rsh64Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SRLV <t> x (ZeroExt16to64 y)))
(Rsh64Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> x (ZeroExt8to64 y))) (Rsh64Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SRLV <t> x (ZeroExt8to64 y)))
(Rsh32Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt32to64 x) y)) (Rsh32Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SRLV <t> (ZeroExt32to64 x) y))
(Rsh32Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt32to64 y))) (Rsh32Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt32to64 y)))
(Rsh32Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt16to64 y))) (Rsh32Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt16to64 y)))
(Rsh32Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt8to64 y))) (Rsh32Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt32to64 x) (ZeroExt8to64 y)))
(Rsh16Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt16to64 x) y)) (Rsh16Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SRLV <t> (ZeroExt16to64 x) y))
(Rsh16Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt32to64 y))) (Rsh16Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt32to64 y)))
(Rsh16Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt16to64 y))) (Rsh16Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt16to64 y)))
(Rsh16Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt8to64 y))) (Rsh16Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt16to64 x) (ZeroExt8to64 y)))
(Rsh8Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) y)) (SRLV <t> (ZeroExt8to64 x) y)) (Rsh8Ux64 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) y)) (SRLV <t> (ZeroExt8to64 x) y))
(Rsh8Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt32to64 y))) (Rsh8Ux32 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt32to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt32to64 y)))
(Rsh8Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt16to64 y))) (Rsh8Ux16 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt16to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt16to64 y)))
(Rsh8Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <fe.TypeUInt64()> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt8to64 y))) (Rsh8Ux8 <t> x y) -> (AND (NEGV <t> (SGTU (Const64 <types.UInt64> [64]) (ZeroExt8to64 y))) (SRLV <t> (ZeroExt8to64 x) (ZeroExt8to64 y)))
(Rsh64x64 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y)) (Rsh64x64 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU y (Const64 <types.UInt64> [63]))) y))
(Rsh64x32 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) (Rsh64x32 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt32to64 y)))
(Rsh64x16 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) (Rsh64x16 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt16to64 y)))
(Rsh64x8 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) (Rsh64x8 <t> x y) -> (SRAV x (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt8to64 y)))
(Rsh32x64 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y)) (Rsh32x64 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <types.UInt64> [63]))) y))
(Rsh32x32 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) (Rsh32x32 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt32to64 y)))
(Rsh32x16 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) (Rsh32x16 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt16to64 y)))
(Rsh32x8 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) (Rsh32x8 <t> x y) -> (SRAV (SignExt32to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt8to64 y)))
(Rsh16x64 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y)) (Rsh16x64 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <types.UInt64> [63]))) y))
(Rsh16x32 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) (Rsh16x32 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt32to64 y)))
(Rsh16x16 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) (Rsh16x16 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt16to64 y)))
(Rsh16x8 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) (Rsh16x8 <t> x y) -> (SRAV (SignExt16to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt8to64 y)))
(Rsh8x64 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <fe.TypeUInt64()> [63]))) y)) (Rsh8x64 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU y (Const64 <types.UInt64> [63]))) y))
(Rsh8x32 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt32to64 y))) (Rsh8x32 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt32to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt32to64 y)))
(Rsh8x16 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt16to64 y))) (Rsh8x16 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt16to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt16to64 y)))
(Rsh8x8 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <fe.TypeUInt64()> [63]))) (ZeroExt8to64 y))) (Rsh8x8 <t> x y) -> (SRAV (SignExt8to64 x) (OR <t> (NEGV <t> (SGTU (ZeroExt8to64 y) (Const64 <types.UInt64> [63]))) (ZeroExt8to64 y)))
// unary ops // unary ops
(Neg64 x) -> (NEGV x) (Neg64 x) -> (NEGV x)
@ -147,7 +147,7 @@
// boolean ops -- booleans are represented with 0=false, 1=true // boolean ops -- booleans are represented with 0=false, 1=true
(AndB x y) -> (AND x y) (AndB x y) -> (AND x y)
(OrB x y) -> (OR x y) (OrB x y) -> (OR x y)
(EqB x y) -> (XOR (MOVVconst [1]) (XOR <fe.TypeBool()> x y)) (EqB x y) -> (XOR (MOVVconst [1]) (XOR <types.Bool> x y))
(NeqB x y) -> (XOR x y) (NeqB x y) -> (XOR x y)
(Not x) -> (XORconst [1] x) (Not x) -> (XORconst [1] x)

98
src/cmd/compile/internal/ssa/gen/PPC64.rules
View file

@ -154,72 +154,72 @@
(Rsh8x32 x (MOVDconst [c])) && uint32(c) < 8 -> (SRAWconst (SignExt8to32 x) [c]) (Rsh8x32 x (MOVDconst [c])) && uint32(c) < 8 -> (SRAWconst (SignExt8to32 x) [c])
(Rsh8Ux32 x (MOVDconst [c])) && uint32(c) < 8 -> (SRWconst (ZeroExt8to32 x) [c]) (Rsh8Ux32 x (MOVDconst [c])) && uint32(c) < 8 -> (SRWconst (ZeroExt8to32 x) [c])
(Rsh64x64 x y) -> (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) (Rsh64x64 x y) -> (SRAD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
(Rsh64Ux64 x y) -> (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) (Rsh64Ux64 x y) -> (SRD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
(Lsh64x64 x y) -> (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y)))) (Lsh64x64 x y) -> (SLD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
(Rsh32x64 x y) -> (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) (Rsh32x64 x y) -> (SRAW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
(Rsh32Ux64 x y) -> (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) (Rsh32Ux64 x y) -> (SRW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
(Lsh32x64 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y)))) (Lsh32x64 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
(Rsh16x64 x y) -> (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) (Rsh16x64 x y) -> (SRAW (SignExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
(Rsh16Ux64 x y) -> (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) (Rsh16Ux64 x y) -> (SRW (ZeroExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
(Lsh16x64 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y)))) (Lsh16x64 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
(Rsh8x64 x y) -> (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) (Rsh8x64 x y) -> (SRAW (SignExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
(Rsh8Ux64 x y) -> (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) (Rsh8Ux64 x y) -> (SRW (ZeroExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
(Lsh8x64 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y)))) (Lsh8x64 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
(Rsh64x32 x y) -> (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) (Rsh64x32 x y) -> (SRAD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
(Rsh64Ux32 x y) -> (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) (Rsh64Ux32 x y) -> (SRD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
(Lsh64x32 x y) -> (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y))))) (Lsh64x32 x y) -> (SLD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
(Rsh32x32 x y) -> (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) (Rsh32x32 x y) -> (SRAW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
(Rsh32Ux32 x y) -> (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) (Rsh32Ux32 x y) -> (SRW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
(Lsh32x32 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y))))) (Lsh32x32 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
(Rsh16x32 x y) -> (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) (Rsh16x32 x y) -> (SRAW (SignExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
(Rsh16Ux32 x y) -> (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) (Rsh16Ux32 x y) -> (SRW (ZeroExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
(Lsh16x32 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y))))) (Lsh16x32 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
(Rsh8x32 x y) -> (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) (Rsh8x32 x y) -> (SRAW (SignExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
(Rsh8Ux32 x y) -> (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) (Rsh8Ux32 x y) -> (SRW (ZeroExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
(Lsh8x32 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y))))) (Lsh8x32 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
(Rsh64x16 x y) -> (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) (Rsh64x16 x y) -> (SRAD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
(Rsh64Ux16 x y) -> (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) (Rsh64Ux16 x y) -> (SRD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
(Lsh64x16 x y) -> (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y))))) (Lsh64x16 x y) -> (SLD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
(Rsh32x16 x y) -> (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) (Rsh32x16 x y) -> (SRAW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
(Rsh32Ux16 x y) -> (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) (Rsh32Ux16 x y) -> (SRW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
(Lsh32x16 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y))))) (Lsh32x16 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
(Rsh16x16 x y) -> (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) (Rsh16x16 x y) -> (SRAW (SignExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
(Rsh16Ux16 x y) -> (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) (Rsh16Ux16 x y) -> (SRW (ZeroExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
(Lsh16x16 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y))))) (Lsh16x16 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
(Rsh8x16 x y) -> (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) (Rsh8x16 x y) -> (SRAW (SignExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
(Rsh8Ux16 x y) -> (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) (Rsh8Ux16 x y) -> (SRW (ZeroExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
(Lsh8x16 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y))))) (Lsh8x16 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
(Rsh64x8 x y) -> (SRAD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) (Rsh64x8 x y) -> (SRAD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
(Rsh64Ux8 x y) -> (SRD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) (Rsh64Ux8 x y) -> (SRD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
(Lsh64x8 x y) -> (SLD x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y))))) (Lsh64x8 x y) -> (SLD x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
(Rsh32x8 x y) -> (SRAW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) (Rsh32x8 x y) -> (SRAW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
(Rsh32Ux8 x y) -> (SRW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) (Rsh32Ux8 x y) -> (SRW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
(Lsh32x8 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y))))) (Lsh32x8 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
(Rsh16x8 x y) -> (SRAW (SignExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) (Rsh16x8 x y) -> (SRAW (SignExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
(Rsh16Ux8 x y) -> (SRW (ZeroExt16to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) (Rsh16Ux8 x y) -> (SRW (ZeroExt16to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
(Lsh16x8 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y))))) (Lsh16x8 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
(Rsh8x8 x y) -> (SRAW (SignExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) (Rsh8x8 x y) -> (SRAW (SignExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
(Rsh8Ux8 x y) -> (SRW (ZeroExt8to32 x) (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) (Rsh8Ux8 x y) -> (SRW (ZeroExt8to32 x) (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
(Lsh8x8 x y) -> (SLW x (ORN y <fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y))))) (Lsh8x8 x y) -> (SLW x (ORN y <types.Int64> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
// Cleaning up shift ops when input is masked // Cleaning up shift ops when input is masked
(MaskIfNotCarry (ADDconstForCarry [c] (ANDconst [d] _))) && c < 0 && d > 0 && c + d < 0 -> (MOVDconst [-1]) (MaskIfNotCarry (ADDconstForCarry [c] (ANDconst [d] _))) && c < 0 && d > 0 && c + d < 0 -> (MOVDconst [-1])
@ -233,7 +233,7 @@
(Addr {sym} base) -> (MOVDaddr {sym} base) (Addr {sym} base) -> (MOVDaddr {sym} base)
// (Addr {sym} base) -> (ADDconst {sym} base) // (Addr {sym} base) -> (ADDconst {sym} base)
(OffPtr [off] ptr) -> (ADD (MOVDconst <fe.TypeInt64()> [off]) ptr) (OffPtr [off] ptr) -> (ADD (MOVDconst <types.Int64> [off]) ptr)
(And64 x y) -> (AND x y) (And64 x y) -> (AND x y)
(And32 x y) -> (AND x y) (And32 x y) -> (AND x y)

2
src/cmd/compile/internal/ssa/gen/S390X.rules
View file

@ -437,7 +437,7 @@
(If (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) cmp) yes no) -> (GTF cmp yes no) (If (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) cmp) yes no) -> (GTF cmp yes no)
(If (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) cmp) yes no) -> (GEF cmp yes no) (If (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) cmp) yes no) -> (GEF cmp yes no)
(If cond yes no) -> (NE (CMPWconst [0] (MOVBZreg <fe.TypeBool()> cond)) yes no) (If cond yes no) -> (NE (CMPWconst [0] (MOVBZreg <types.Bool> cond)) yes no)
// *************************** // ***************************
// Above: lowering rules // Above: lowering rules

66
src/cmd/compile/internal/ssa/gen/dec.rules
View file

@ -13,28 +13,28 @@
(Load <t> ptr mem) && t.IsComplex() && t.Size() == 8 -> (Load <t> ptr mem) && t.IsComplex() && t.Size() == 8 ->
(ComplexMake (ComplexMake
(Load <fe.TypeFloat32()> ptr mem) (Load <types.Float32> ptr mem)
(Load <fe.TypeFloat32()> (Load <types.Float32>
(OffPtr <fe.TypeFloat32().PtrTo()> [4] ptr) (OffPtr <types.Float32.PtrTo()> [4] ptr)
mem) mem)
) )
(Store {t} dst (ComplexMake real imag) mem) && t.(Type).Size() == 8 -> (Store {t} dst (ComplexMake real imag) mem) && t.(Type).Size() == 8 ->
(Store {fe.TypeFloat32()} (Store {types.Float32}
(OffPtr <fe.TypeFloat32().PtrTo()> [4] dst) (OffPtr <types.Float32.PtrTo()> [4] dst)
imag imag
(Store {fe.TypeFloat32()} dst real mem)) (Store {types.Float32} dst real mem))
(Load <t> ptr mem) && t.IsComplex() && t.Size() == 16 -> (Load <t> ptr mem) && t.IsComplex() && t.Size() == 16 ->
(ComplexMake (ComplexMake
(Load <fe.TypeFloat64()> ptr mem) (Load <types.Float64> ptr mem)
(Load <fe.TypeFloat64()> (Load <types.Float64>
(OffPtr <fe.TypeFloat64().PtrTo()> [8] ptr) (OffPtr <types.Float64.PtrTo()> [8] ptr)
mem) mem)
) )
(Store {t} dst (ComplexMake real imag) mem) && t.(Type).Size() == 16 -> (Store {t} dst (ComplexMake real imag) mem) && t.(Type).Size() == 16 ->
(Store {fe.TypeFloat64()} (Store {types.Float64}
(OffPtr <fe.TypeFloat64().PtrTo()> [8] dst) (OffPtr <types.Float64.PtrTo()> [8] dst)
imag imag
(Store {fe.TypeFloat64()} dst real mem)) (Store {types.Float64} dst real mem))
// string ops // string ops
(StringPtr (StringMake ptr _)) -> ptr (StringPtr (StringMake ptr _)) -> ptr
@ -42,15 +42,15 @@
(Load <t> ptr mem) && t.IsString() -> (Load <t> ptr mem) && t.IsString() ->
(StringMake (StringMake
(Load <fe.TypeBytePtr()> ptr mem) (Load <types.BytePtr> ptr mem)
(Load <fe.TypeInt()> (Load <types.Int>
(OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] ptr) (OffPtr <types.Int.PtrTo()> [config.PtrSize] ptr)
mem)) mem))
(Store dst (StringMake ptr len) mem) -> (Store dst (StringMake ptr len) mem) ->
(Store {fe.TypeInt()} (Store {types.Int}
(OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] dst) (OffPtr <types.Int.PtrTo()> [config.PtrSize] dst)
len len
(Store {fe.TypeBytePtr()} dst ptr mem)) (Store {types.BytePtr} dst ptr mem))
// slice ops // slice ops
(SlicePtr (SliceMake ptr _ _ )) -> ptr (SlicePtr (SliceMake ptr _ _ )) -> ptr
@ -60,20 +60,20 @@
(Load <t> ptr mem) && t.IsSlice() -> (Load <t> ptr mem) && t.IsSlice() ->
(SliceMake (SliceMake
(Load <t.ElemType().PtrTo()> ptr mem) (Load <t.ElemType().PtrTo()> ptr mem)
(Load <fe.TypeInt()> (Load <types.Int>
(OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] ptr) (OffPtr <types.Int.PtrTo()> [config.PtrSize] ptr)
mem) mem)
(Load <fe.TypeInt()> (Load <types.Int>
(OffPtr <fe.TypeInt().PtrTo()> [2*config.PtrSize] ptr) (OffPtr <types.Int.PtrTo()> [2*config.PtrSize] ptr)
mem)) mem))
(Store dst (SliceMake ptr len cap) mem) -> (Store dst (SliceMake ptr len cap) mem) ->
(Store {fe.TypeInt()} (Store {types.Int}
(OffPtr <fe.TypeInt().PtrTo()> [2*config.PtrSize] dst) (OffPtr <types.Int.PtrTo()> [2*config.PtrSize] dst)
cap cap
(Store {fe.TypeInt()} (Store {types.Int}
(OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] dst) (OffPtr <types.Int.PtrTo()> [config.PtrSize] dst)
len len
(Store {fe.TypeBytePtr()} dst ptr mem))) (Store {types.BytePtr} dst ptr mem)))
// interface ops // interface ops
(ITab (IMake itab _)) -> itab (ITab (IMake itab _)) -> itab
@ -81,12 +81,12 @@
(Load <t> ptr mem) && t.IsInterface() -> (Load <t> ptr mem) && t.IsInterface() ->
(IMake (IMake
(Load <fe.TypeBytePtr()> ptr mem) (Load <types.BytePtr> ptr mem)
(Load <fe.TypeBytePtr()> (Load <types.BytePtr>
(OffPtr <fe.TypeBytePtr().PtrTo()> [config.PtrSize] ptr) (OffPtr <types.BytePtr.PtrTo()> [config.PtrSize] ptr)
mem)) mem))
(Store dst (IMake itab data) mem) -> (Store dst (IMake itab data) mem) ->
(Store {fe.TypeBytePtr()} (Store {types.BytePtr}
(OffPtr <fe.TypeBytePtr().PtrTo()> [config.PtrSize] dst) (OffPtr <types.BytePtr.PtrTo()> [config.PtrSize] dst)
data data
(Store {fe.TypeUintptr()} dst itab mem)) (Store {types.Uintptr} dst itab mem))

314
src/cmd/compile/internal/ssa/gen/dec64.rules
View file

@ -12,23 +12,23 @@
(Load <t> ptr mem) && is64BitInt(t) && !config.BigEndian && t.IsSigned() -> (Load <t> ptr mem) && is64BitInt(t) && !config.BigEndian && t.IsSigned() ->
(Int64Make (Int64Make
(Load <fe.TypeInt32()> (OffPtr <fe.TypeInt32().PtrTo()> [4] ptr) mem) (Load <types.Int32> (OffPtr <types.Int32.PtrTo()> [4] ptr) mem)
(Load <fe.TypeUInt32()> ptr mem)) (Load <types.UInt32> ptr mem))
(Load <t> ptr mem) && is64BitInt(t) && !config.BigEndian && !t.IsSigned() -> (Load <t> ptr mem) && is64BitInt(t) && !config.BigEndian && !t.IsSigned() ->
(Int64Make (Int64Make
(Load <fe.TypeUInt32()> (OffPtr <fe.TypeUInt32().PtrTo()> [4] ptr) mem) (Load <types.UInt32> (OffPtr <types.UInt32.PtrTo()> [4] ptr) mem)
(Load <fe.TypeUInt32()> ptr mem)) (Load <types.UInt32> ptr mem))
(Load <t> ptr mem) && is64BitInt(t) && config.BigEndian && t.IsSigned() -> (Load <t> ptr mem) && is64BitInt(t) && config.BigEndian && t.IsSigned() ->
(Int64Make (Int64Make
(Load <fe.TypeInt32()> ptr mem) (Load <types.Int32> ptr mem)
(Load <fe.TypeUInt32()> (OffPtr <fe.TypeUInt32().PtrTo()> [4] ptr) mem)) (Load <types.UInt32> (OffPtr <types.UInt32.PtrTo()> [4] ptr) mem))
(Load <t> ptr mem) && is64BitInt(t) && config.BigEndian && !t.IsSigned() -> (Load <t> ptr mem) && is64BitInt(t) && config.BigEndian && !t.IsSigned() ->
(Int64Make (Int64Make
(Load <fe.TypeUInt32()> ptr mem) (Load <types.UInt32> ptr mem)
(Load <fe.TypeUInt32()> (OffPtr <fe.TypeUInt32().PtrTo()> [4] ptr) mem)) (Load <types.UInt32> (OffPtr <types.UInt32.PtrTo()> [4] ptr) mem))
(Store {t} dst (Int64Make hi lo) mem) && t.(Type).Size() == 8 && !config.BigEndian -> (Store {t} dst (Int64Make hi lo) mem) && t.(Type).Size() == 8 && !config.BigEndian ->
(Store {hi.Type} (Store {hi.Type}
@ -44,94 +44,94 @@
(Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() -> (Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() ->
(Int64Make (Int64Make
(Arg <fe.TypeInt32()> {n} [off+4]) (Arg <types.Int32> {n} [off+4])
(Arg <fe.TypeUInt32()> {n} [off])) (Arg <types.UInt32> {n} [off]))
(Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() -> (Arg {n} [off]) && is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() ->
(Int64Make (Int64Make
(Arg <fe.TypeUInt32()> {n} [off+4]) (Arg <types.UInt32> {n} [off+4])
(Arg <fe.TypeUInt32()> {n} [off])) (Arg <types.UInt32> {n} [off]))
(Arg {n} [off]) && is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() -> (Arg {n} [off]) && is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() ->
(Int64Make (Int64Make
(Arg <fe.TypeInt32()> {n} [off]) (Arg <types.Int32> {n} [off])
(Arg <fe.TypeUInt32()> {n} [off+4])) (Arg <types.UInt32> {n} [off+4]))
(Arg {n} [off]) && is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() -> (Arg {n} [off]) && is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() ->
(Int64Make (Int64Make
(Arg <fe.TypeUInt32()> {n} [off]) (Arg <types.UInt32> {n} [off])
(Arg <fe.TypeUInt32()> {n} [off+4])) (Arg <types.UInt32> {n} [off+4]))
(Add64 x y) -> (Add64 x y) ->
(Int64Make (Int64Make
(Add32withcarry <fe.TypeInt32()> (Add32withcarry <types.Int32>
(Int64Hi x) (Int64Hi x)
(Int64Hi y) (Int64Hi y)
(Select1 <TypeFlags> (Add32carry (Int64Lo x) (Int64Lo y)))) (Select1 <TypeFlags> (Add32carry (Int64Lo x) (Int64Lo y))))
(Select0 <fe.TypeUInt32()> (Add32carry (Int64Lo x) (Int64Lo y)))) (Select0 <types.UInt32> (Add32carry (Int64Lo x) (Int64Lo y))))
(Sub64 x y) -> (Sub64 x y) ->
(Int64Make (Int64Make
(Sub32withcarry <fe.TypeInt32()> (Sub32withcarry <types.Int32>
(Int64Hi x) (Int64Hi x)
(Int64Hi y) (Int64Hi y)
(Select1 <TypeFlags> (Sub32carry (Int64Lo x) (Int64Lo y)))) (Select1 <TypeFlags> (Sub32carry (Int64Lo x) (Int64Lo y))))
(Select0 <fe.TypeUInt32()> (Sub32carry (Int64Lo x) (Int64Lo y)))) (Select0 <types.UInt32> (Sub32carry (Int64Lo x) (Int64Lo y))))
(Mul64 x y) -> (Mul64 x y) ->
(Int64Make (Int64Make
(Add32 <fe.TypeUInt32()> (Add32 <types.UInt32>
(Mul32 <fe.TypeUInt32()> (Int64Lo x) (Int64Hi y)) (Mul32 <types.UInt32> (Int64Lo x) (Int64Hi y))
(Add32 <fe.TypeUInt32()> (Add32 <types.UInt32>
(Mul32 <fe.TypeUInt32()> (Int64Hi x) (Int64Lo y)) (Mul32 <types.UInt32> (Int64Hi x) (Int64Lo y))
(Select0 <fe.TypeUInt32()> (Mul32uhilo (Int64Lo x) (Int64Lo y))))) (Select0 <types.UInt32> (Mul32uhilo (Int64Lo x) (Int64Lo y)))))
(Select1 <fe.TypeUInt32()> (Mul32uhilo (Int64Lo x) (Int64Lo y)))) (Select1 <types.UInt32> (Mul32uhilo (Int64Lo x) (Int64Lo y))))
(And64 x y) -> (And64 x y) ->
(Int64Make (Int64Make
(And32 <fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) (And32 <types.UInt32> (Int64Hi x) (Int64Hi y))
(And32 <fe.TypeUInt32()> (Int64Lo x) (Int64Lo y))) (And32 <types.UInt32> (Int64Lo x) (Int64Lo y)))
(Or64 x y) -> (Or64 x y) ->
(Int64Make (Int64Make
(Or32 <fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) (Or32 <types.UInt32> (Int64Hi x) (Int64Hi y))
(Or32 <fe.TypeUInt32()> (Int64Lo x) (Int64Lo y))) (Or32 <types.UInt32> (Int64Lo x) (Int64Lo y)))
(Xor64 x y) -> (Xor64 x y) ->
(Int64Make (Int64Make
(Xor32 <fe.TypeUInt32()> (Int64Hi x) (Int64Hi y)) (Xor32 <types.UInt32> (Int64Hi x) (Int64Hi y))
(Xor32 <fe.TypeUInt32()> (Int64Lo x) (Int64Lo y))) (Xor32 <types.UInt32> (Int64Lo x) (Int64Lo y)))
(Neg64 <t> x) -> (Sub64 (Const64 <t> [0]) x) (Neg64 <t> x) -> (Sub64 (Const64 <t> [0]) x)
(Com64 x) -> (Com64 x) ->
(Int64Make (Int64Make
(Com32 <fe.TypeUInt32()> (Int64Hi x)) (Com32 <types.UInt32> (Int64Hi x))
(Com32 <fe.TypeUInt32()> (Int64Lo x))) (Com32 <types.UInt32> (Int64Lo x)))
(Ctz64 x) -> (Ctz64 x) ->
(Add32 <fe.TypeUInt32()> (Add32 <types.UInt32>
(Ctz32 <fe.TypeUInt32()> (Int64Lo x)) (Ctz32 <types.UInt32> (Int64Lo x))
(And32 <fe.TypeUInt32()> (And32 <types.UInt32>
(Com32 <fe.TypeUInt32()> (Zeromask (Int64Lo x))) (Com32 <types.UInt32> (Zeromask (Int64Lo x)))
(Ctz32 <fe.TypeUInt32()> (Int64Hi x)))) (Ctz32 <types.UInt32> (Int64Hi x))))
(BitLen64 x) -> (BitLen64 x) ->
(Add32 <fe.TypeInt()> (Add32 <types.Int>
(BitLen32 <fe.TypeInt()> (Int64Hi x)) (BitLen32 <types.Int> (Int64Hi x))
(BitLen32 <fe.TypeInt()> (BitLen32 <types.Int>
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Int64Lo x) (Int64Lo x)
(Zeromask (Int64Hi x))))) (Zeromask (Int64Hi x)))))
(Bswap64 x) -> (Bswap64 x) ->
(Int64Make (Int64Make
(Bswap32 <fe.TypeUInt32()> (Int64Lo x)) (Bswap32 <types.UInt32> (Int64Lo x))
(Bswap32 <fe.TypeUInt32()> (Int64Hi x))) (Bswap32 <types.UInt32> (Int64Hi x)))
(SignExt32to64 x) -> (Int64Make (Signmask x) x) (SignExt32to64 x) -> (Int64Make (Signmask x) x)
(SignExt16to64 x) -> (SignExt32to64 (SignExt16to32 x)) (SignExt16to64 x) -> (SignExt32to64 (SignExt16to32 x))
(SignExt8to64 x) -> (SignExt32to64 (SignExt8to32 x)) (SignExt8to64 x) -> (SignExt32to64 (SignExt8to32 x))
(ZeroExt32to64 x) -> (Int64Make (Const32 <fe.TypeUInt32()> [0]) x) (ZeroExt32to64 x) -> (Int64Make (Const32 <types.UInt32> [0]) x)
(ZeroExt16to64 x) -> (ZeroExt32to64 (ZeroExt16to32 x)) (ZeroExt16to64 x) -> (ZeroExt32to64 (ZeroExt16to32 x))
(ZeroExt8to64 x) -> (ZeroExt32to64 (ZeroExt8to32 x)) (ZeroExt8to64 x) -> (ZeroExt32to64 (ZeroExt8to32 x))
@ -170,160 +170,160 @@
// turn x64 non-constant shifts to x32 shifts // turn x64 non-constant shifts to x32 shifts
// if high 32-bit of the shift is nonzero, make a huge shift // if high 32-bit of the shift is nonzero, make a huge shift
(Lsh64x64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> (Lsh64x64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
(Lsh64x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Lsh64x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Rsh64x64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> (Rsh64x64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
(Rsh64x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Rsh64x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Rsh64Ux64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> (Rsh64Ux64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
(Rsh64Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Rsh64Ux32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Lsh32x64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> (Lsh32x64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
(Lsh32x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Lsh32x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Rsh32x64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> (Rsh32x64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
(Rsh32x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Rsh32x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Rsh32Ux64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> (Rsh32Ux64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
(Rsh32Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Rsh32Ux32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Lsh16x64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> (Lsh16x64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
(Lsh16x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Lsh16x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Rsh16x64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> (Rsh16x64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
(Rsh16x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Rsh16x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Rsh16Ux64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> (Rsh16Ux64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
(Rsh16Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Rsh16Ux32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Lsh8x64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> (Lsh8x64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
(Lsh8x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Lsh8x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Rsh8x64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> (Rsh8x64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
(Rsh8x32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Rsh8x32 x (Or32 <types.UInt32> (Zeromask hi) lo))
(Rsh8Ux64 x (Int64Make hi lo)) && hi.Op != OpConst32 -> (Rsh8Ux64 x (Int64Make hi lo)) && hi.Op != OpConst32 ->
(Rsh8Ux32 x (Or32 <fe.TypeUInt32()> (Zeromask hi) lo)) (Rsh8Ux32 x (Or32 <types.UInt32> (Zeromask hi) lo))
// 64x left shift // 64x left shift
// result.hi = hi<<s | lo>>(32-s) | lo<<(s-32) // >> is unsigned, large shifts result 0 // result.hi = hi<<s | lo>>(32-s) | lo<<(s-32) // >> is unsigned, large shifts result 0
// result.lo = lo<<s // result.lo = lo<<s
(Lsh64x32 (Int64Make hi lo) s) -> (Lsh64x32 (Int64Make hi lo) s) ->
(Int64Make (Int64Make
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Lsh32x32 <fe.TypeUInt32()> hi s) (Lsh32x32 <types.UInt32> hi s)
(Rsh32Ux32 <fe.TypeUInt32()> (Rsh32Ux32 <types.UInt32>
lo lo
(Sub32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [32]) s))) (Sub32 <types.UInt32> (Const32 <types.UInt32> [32]) s)))
(Lsh32x32 <fe.TypeUInt32()> (Lsh32x32 <types.UInt32>
lo lo
(Sub32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [32])))) (Sub32 <types.UInt32> s (Const32 <types.UInt32> [32]))))
(Lsh32x32 <fe.TypeUInt32()> lo s)) (Lsh32x32 <types.UInt32> lo s))
(Lsh64x16 (Int64Make hi lo) s) -> (Lsh64x16 (Int64Make hi lo) s) ->
(Int64Make (Int64Make
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Lsh32x16 <fe.TypeUInt32()> hi s) (Lsh32x16 <types.UInt32> hi s)
(Rsh32Ux16 <fe.TypeUInt32()> (Rsh32Ux16 <types.UInt32>
lo lo
(Sub16 <fe.TypeUInt16()> (Const16 <fe.TypeUInt16()> [32]) s))) (Sub16 <types.UInt16> (Const16 <types.UInt16> [32]) s)))
(Lsh32x16 <fe.TypeUInt32()> (Lsh32x16 <types.UInt32>
lo lo
(Sub16 <fe.TypeUInt16()> s (Const16 <fe.TypeUInt16()> [32])))) (Sub16 <types.UInt16> s (Const16 <types.UInt16> [32]))))
(Lsh32x16 <fe.TypeUInt32()> lo s)) (Lsh32x16 <types.UInt32> lo s))
(Lsh64x8 (Int64Make hi lo) s) -> (Lsh64x8 (Int64Make hi lo) s) ->
(Int64Make (Int64Make
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Lsh32x8 <fe.TypeUInt32()> hi s) (Lsh32x8 <types.UInt32> hi s)
(Rsh32Ux8 <fe.TypeUInt32()> (Rsh32Ux8 <types.UInt32>
lo lo
(Sub8 <fe.TypeUInt8()> (Const8 <fe.TypeUInt8()> [32]) s))) (Sub8 <types.UInt8> (Const8 <types.UInt8> [32]) s)))
(Lsh32x8 <fe.TypeUInt32()> (Lsh32x8 <types.UInt32>
lo lo
(Sub8 <fe.TypeUInt8()> s (Const8 <fe.TypeUInt8()> [32])))) (Sub8 <types.UInt8> s (Const8 <types.UInt8> [32]))))
(Lsh32x8 <fe.TypeUInt32()> lo s)) (Lsh32x8 <types.UInt32> lo s))
// 64x unsigned right shift // 64x unsigned right shift
// result.hi = hi>>s // result.hi = hi>>s
// result.lo = lo>>s | hi<<(32-s) | hi>>(s-32) // >> is unsigned, large shifts result 0 // result.lo = lo>>s | hi<<(32-s) | hi>>(s-32) // >> is unsigned, large shifts result 0
(Rsh64Ux32 (Int64Make hi lo) s) -> (Rsh64Ux32 (Int64Make hi lo) s) ->
(Int64Make (Int64Make
(Rsh32Ux32 <fe.TypeUInt32()> hi s) (Rsh32Ux32 <types.UInt32> hi s)
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Rsh32Ux32 <fe.TypeUInt32()> lo s) (Rsh32Ux32 <types.UInt32> lo s)
(Lsh32x32 <fe.TypeUInt32()> (Lsh32x32 <types.UInt32>
hi hi
(Sub32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [32]) s))) (Sub32 <types.UInt32> (Const32 <types.UInt32> [32]) s)))
(Rsh32Ux32 <fe.TypeUInt32()> (Rsh32Ux32 <types.UInt32>
hi hi
(Sub32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [32]))))) (Sub32 <types.UInt32> s (Const32 <types.UInt32> [32])))))
(Rsh64Ux16 (Int64Make hi lo) s) -> (Rsh64Ux16 (Int64Make hi lo) s) ->
(Int64Make (Int64Make
(Rsh32Ux16 <fe.TypeUInt32()> hi s) (Rsh32Ux16 <types.UInt32> hi s)
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Rsh32Ux16 <fe.TypeUInt32()> lo s) (Rsh32Ux16 <types.UInt32> lo s)
(Lsh32x16 <fe.TypeUInt32()> (Lsh32x16 <types.UInt32>
hi hi
(Sub16 <fe.TypeUInt16()> (Const16 <fe.TypeUInt16()> [32]) s))) (Sub16 <types.UInt16> (Const16 <types.UInt16> [32]) s)))
(Rsh32Ux16 <fe.TypeUInt32()> (Rsh32Ux16 <types.UInt32>
hi hi
(Sub16 <fe.TypeUInt16()> s (Const16 <fe.TypeUInt16()> [32]))))) (Sub16 <types.UInt16> s (Const16 <types.UInt16> [32])))))
(Rsh64Ux8 (Int64Make hi lo) s) -> (Rsh64Ux8 (Int64Make hi lo) s) ->
(Int64Make (Int64Make
(Rsh32Ux8 <fe.TypeUInt32()> hi s) (Rsh32Ux8 <types.UInt32> hi s)
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Rsh32Ux8 <fe.TypeUInt32()> lo s) (Rsh32Ux8 <types.UInt32> lo s)
(Lsh32x8 <fe.TypeUInt32()> (Lsh32x8 <types.UInt32>
hi hi
(Sub8 <fe.TypeUInt8()> (Const8 <fe.TypeUInt8()> [32]) s))) (Sub8 <types.UInt8> (Const8 <types.UInt8> [32]) s)))
(Rsh32Ux8 <fe.TypeUInt32()> (Rsh32Ux8 <types.UInt32>
hi hi
(Sub8 <fe.TypeUInt8()> s (Const8 <fe.TypeUInt8()> [32]))))) (Sub8 <types.UInt8> s (Const8 <types.UInt8> [32])))))
// 64x signed right shift // 64x signed right shift
// result.hi = hi>>s // result.hi = hi>>s
// result.lo = lo>>s | hi<<(32-s) | (hi>>(s-32))&zeromask(s>>5) // hi>>(s-32) is signed, large shifts result 0/-1 // result.lo = lo>>s | hi<<(32-s) | (hi>>(s-32))&zeromask(s>>5) // hi>>(s-32) is signed, large shifts result 0/-1
(Rsh64x32 (Int64Make hi lo) s) -> (Rsh64x32 (Int64Make hi lo) s) ->
(Int64Make (Int64Make
(Rsh32x32 <fe.TypeUInt32()> hi s) (Rsh32x32 <types.UInt32> hi s)
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Rsh32Ux32 <fe.TypeUInt32()> lo s) (Rsh32Ux32 <types.UInt32> lo s)
(Lsh32x32 <fe.TypeUInt32()> (Lsh32x32 <types.UInt32>
hi hi
(Sub32 <fe.TypeUInt32()> (Const32 <fe.TypeUInt32()> [32]) s))) (Sub32 <types.UInt32> (Const32 <types.UInt32> [32]) s)))
(And32 <fe.TypeUInt32()> (And32 <types.UInt32>
(Rsh32x32 <fe.TypeUInt32()> (Rsh32x32 <types.UInt32>
hi hi
(Sub32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [32]))) (Sub32 <types.UInt32> s (Const32 <types.UInt32> [32])))
(Zeromask (Zeromask
(Rsh32Ux32 <fe.TypeUInt32()> s (Const32 <fe.TypeUInt32()> [5])))))) (Rsh32Ux32 <types.UInt32> s (Const32 <types.UInt32> [5]))))))
(Rsh64x16 (Int64Make hi lo) s) -> (Rsh64x16 (Int64Make hi lo) s) ->
(Int64Make (Int64Make
(Rsh32x16 <fe.TypeUInt32()> hi s) (Rsh32x16 <types.UInt32> hi s)
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Rsh32Ux16 <fe.TypeUInt32()> lo s) (Rsh32Ux16 <types.UInt32> lo s)
(Lsh32x16 <fe.TypeUInt32()> (Lsh32x16 <types.UInt32>
hi hi
(Sub16 <fe.TypeUInt16()> (Const16 <fe.TypeUInt16()> [32]) s))) (Sub16 <types.UInt16> (Const16 <types.UInt16> [32]) s)))
(And32 <fe.TypeUInt32()> (And32 <types.UInt32>
(Rsh32x16 <fe.TypeUInt32()> (Rsh32x16 <types.UInt32>
hi hi
(Sub16 <fe.TypeUInt16()> s (Const16 <fe.TypeUInt16()> [32]))) (Sub16 <types.UInt16> s (Const16 <types.UInt16> [32])))
(Zeromask (Zeromask
(ZeroExt16to32 (ZeroExt16to32
(Rsh16Ux32 <fe.TypeUInt16()> s (Const32 <fe.TypeUInt32()> [5]))))))) (Rsh16Ux32 <types.UInt16> s (Const32 <types.UInt32> [5])))))))
(Rsh64x8 (Int64Make hi lo) s) -> (Rsh64x8 (Int64Make hi lo) s) ->
(Int64Make (Int64Make
(Rsh32x8 <fe.TypeUInt32()> hi s) (Rsh32x8 <types.UInt32> hi s)
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Or32 <fe.TypeUInt32()> (Or32 <types.UInt32>
(Rsh32Ux8 <fe.TypeUInt32()> lo s) (Rsh32Ux8 <types.UInt32> lo s)
(Lsh32x8 <fe.TypeUInt32()> (Lsh32x8 <types.UInt32>
hi hi
(Sub8 <fe.TypeUInt8()> (Const8 <fe.TypeUInt8()> [32]) s))) (Sub8 <types.UInt8> (Const8 <types.UInt8> [32]) s)))
(And32 <fe.TypeUInt32()> (And32 <types.UInt32>
(Rsh32x8 <fe.TypeUInt32()> (Rsh32x8 <types.UInt32>
hi hi
(Sub8 <fe.TypeUInt8()> s (Const8 <fe.TypeUInt8()> [32]))) (Sub8 <types.UInt8> s (Const8 <types.UInt8> [32])))
(Zeromask (Zeromask
(ZeroExt8to32 (ZeroExt8to32
(Rsh8Ux32 <fe.TypeUInt8()> s (Const32 <fe.TypeUInt32()> [5]))))))) (Rsh8Ux32 <types.UInt8> s (Const32 <types.UInt32> [5])))))))
// 64xConst32 shifts // 64xConst32 shifts
// we probably do not need them -- lateopt may take care of them just fine // we probably do not need them -- lateopt may take care of them just fine
@ -333,48 +333,48 @@
// //
//(Lsh64x32 x (Const32 [c])) && c < 64 && c > 32 -> //(Lsh64x32 x (Const32 [c])) && c < 64 && c > 32 ->
// (Int64Make // (Int64Make
// (Lsh32x32 <fe.TypeUInt32()> (Int64Lo x) (Const32 <fe.TypeUInt32()> [c-32])) // (Lsh32x32 <types.UInt32> (Int64Lo x) (Const32 <types.UInt32> [c-32]))
// (Const32 <fe.TypeUInt32()> [0])) // (Const32 <types.UInt32> [0]))
//(Rsh64x32 x (Const32 [c])) && c < 64 && c > 32 -> //(Rsh64x32 x (Const32 [c])) && c < 64 && c > 32 ->
// (Int64Make // (Int64Make
// (Signmask (Int64Hi x)) // (Signmask (Int64Hi x))
// (Rsh32x32 <fe.TypeInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [c-32]))) // (Rsh32x32 <types.Int32> (Int64Hi x) (Const32 <types.UInt32> [c-32])))
//(Rsh64Ux32 x (Const32 [c])) && c < 64 && c > 32 -> //(Rsh64Ux32 x (Const32 [c])) && c < 64 && c > 32 ->
// (Int64Make // (Int64Make
// (Const32 <fe.TypeUInt32()> [0]) // (Const32 <types.UInt32> [0])
// (Rsh32Ux32 <fe.TypeUInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [c-32]))) // (Rsh32Ux32 <types.UInt32> (Int64Hi x) (Const32 <types.UInt32> [c-32])))
// //
//(Lsh64x32 x (Const32 [32])) -> (Int64Make (Int64Lo x) (Const32 <fe.TypeUInt32()> [0])) //(Lsh64x32 x (Const32 [32])) -> (Int64Make (Int64Lo x) (Const32 <types.UInt32> [0]))
//(Rsh64x32 x (Const32 [32])) -> (Int64Make (Signmask (Int64Hi x)) (Int64Hi x)) //(Rsh64x32 x (Const32 [32])) -> (Int64Make (Signmask (Int64Hi x)) (Int64Hi x))
//(Rsh64Ux32 x (Const32 [32])) -> (Int64Make (Const32 <fe.TypeUInt32()> [0]) (Int64Hi x)) //(Rsh64Ux32 x (Const32 [32])) -> (Int64Make (Const32 <types.UInt32> [0]) (Int64Hi x))
// //
//(Lsh64x32 x (Const32 [c])) && c < 32 && c > 0 -> //(Lsh64x32 x (Const32 [c])) && c < 32 && c > 0 ->
// (Int64Make // (Int64Make
// (Or32 <fe.TypeUInt32()> // (Or32 <types.UInt32>
// (Lsh32x32 <fe.TypeUInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [c])) // (Lsh32x32 <types.UInt32> (Int64Hi x) (Const32 <types.UInt32> [c]))
// (Rsh32Ux32 <fe.TypeUInt32()> (Int64Lo x) (Const32 <fe.TypeUInt32()> [32-c]))) // (Rsh32Ux32 <types.UInt32> (Int64Lo x) (Const32 <types.UInt32> [32-c])))
// (Lsh32x32 <fe.TypeUInt32()> (Int64Lo x) (Const32 <fe.TypeUInt32()> [c]))) // (Lsh32x32 <types.UInt32> (Int64Lo x) (Const32 <types.UInt32> [c])))
//(Rsh64x32 x (Const32 [c])) && c < 32 && c > 0 -> //(Rsh64x32 x (Const32 [c])) && c < 32 && c > 0 ->
// (Int64Make // (Int64Make
// (Rsh32x32 <fe.TypeInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [c])) // (Rsh32x32 <types.Int32> (Int64Hi x) (Const32 <types.UInt32> [c]))
// (Or32 <fe.TypeUInt32()> // (Or32 <types.UInt32>
// (Rsh32Ux32 <fe.TypeUInt32()> (Int64Lo x) (Const32 <fe.TypeUInt32()> [c])) // (Rsh32Ux32 <types.UInt32> (Int64Lo x) (Const32 <types.UInt32> [c]))
// (Lsh32x32 <fe.TypeUInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [32-c])))) // (Lsh32x32 <types.UInt32> (Int64Hi x) (Const32 <types.UInt32> [32-c]))))
//(Rsh64Ux32 x (Const32 [c])) && c < 32 && c > 0 -> //(Rsh64Ux32 x (Const32 [c])) && c < 32 && c > 0 ->
// (Int64Make // (Int64Make
// (Rsh32Ux32 <fe.TypeUInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [c])) // (Rsh32Ux32 <types.UInt32> (Int64Hi x) (Const32 <types.UInt32> [c]))
// (Or32 <fe.TypeUInt32()> // (Or32 <types.UInt32>
// (Rsh32Ux32 <fe.TypeUInt32()> (Int64Lo x) (Const32 <fe.TypeUInt32()> [c])) // (Rsh32Ux32 <types.UInt32> (Int64Lo x) (Const32 <types.UInt32> [c]))
// (Lsh32x32 <fe.TypeUInt32()> (Int64Hi x) (Const32 <fe.TypeUInt32()> [32-c])))) // (Lsh32x32 <types.UInt32> (Int64Hi x) (Const32 <types.UInt32> [32-c]))))
// //
//(Lsh64x32 x (Const32 [0])) -> x //(Lsh64x32 x (Const32 [0])) -> x
//(Rsh64x32 x (Const32 [0])) -> x //(Rsh64x32 x (Const32 [0])) -> x
//(Rsh64Ux32 x (Const32 [0])) -> x //(Rsh64Ux32 x (Const32 [0])) -> x
(Const64 <t> [c]) && t.IsSigned() -> (Const64 <t> [c]) && t.IsSigned() ->
(Int64Make (Const32 <fe.TypeInt32()> [c>>32]) (Const32 <fe.TypeUInt32()> [int64(int32(c))])) (Int64Make (Const32 <types.Int32> [c>>32]) (Const32 <types.UInt32> [int64(int32(c))]))
(Const64 <t> [c]) && !t.IsSigned() -> (Const64 <t> [c]) && !t.IsSigned() ->
(Int64Make (Const32 <fe.TypeUInt32()> [c>>32]) (Const32 <fe.TypeUInt32()> [int64(int32(c))])) (Int64Make (Const32 <types.UInt32> [c>>32]) (Const32 <types.UInt32> [int64(int32(c))]))
(Eq64 x y) -> (Eq64 x y) ->
(AndB (AndB

308
src/cmd/compile/internal/ssa/gen/generic.rules
View file

@ -155,14 +155,14 @@
(Mul64 (Const64 [-1]) x) -> (Neg64 x) (Mul64 (Const64 [-1]) x) -> (Neg64 x)
// Convert multiplication by a power of two to a shift. // Convert multiplication by a power of two to a shift.
(Mul8 <t> n (Const8 [c])) && isPowerOfTwo(c) -> (Lsh8x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)])) (Mul8 <t> n (Const8 [c])) && isPowerOfTwo(c) -> (Lsh8x64 <t> n (Const64 <types.UInt64> [log2(c)]))
(Mul16 <t> n (Const16 [c])) && isPowerOfTwo(c) -> (Lsh16x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)])) (Mul16 <t> n (Const16 [c])) && isPowerOfTwo(c) -> (Lsh16x64 <t> n (Const64 <types.UInt64> [log2(c)]))
(Mul32 <t> n (Const32 [c])) && isPowerOfTwo(c) -> (Lsh32x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)])) (Mul32 <t> n (Const32 [c])) && isPowerOfTwo(c) -> (Lsh32x64 <t> n (Const64 <types.UInt64> [log2(c)]))
(Mul64 <t> n (Const64 [c])) && isPowerOfTwo(c) -> (Lsh64x64 <t> n (Const64 <fe.TypeUInt64()> [log2(c)])) (Mul64 <t> n (Const64 [c])) && isPowerOfTwo(c) -> (Lsh64x64 <t> n (Const64 <types.UInt64> [log2(c)]))
(Mul8 <t> n (Const8 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg8 (Lsh8x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)]))) (Mul8 <t> n (Const8 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg8 (Lsh8x64 <t> n (Const64 <types.UInt64> [log2(-c)])))
(Mul16 <t> n (Const16 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg16 (Lsh16x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)]))) (Mul16 <t> n (Const16 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg16 (Lsh16x64 <t> n (Const64 <types.UInt64> [log2(-c)])))
(Mul32 <t> n (Const32 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg32 (Lsh32x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)]))) (Mul32 <t> n (Const32 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg32 (Lsh32x64 <t> n (Const64 <types.UInt64> [log2(-c)])))
(Mul64 <t> n (Const64 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg64 (Lsh64x64 <t> n (Const64 <fe.TypeUInt64()> [log2(-c)]))) (Mul64 <t> n (Const64 [c])) && t.IsSigned() && isPowerOfTwo(-c) -> (Neg64 (Lsh64x64 <t> n (Const64 <types.UInt64> [log2(-c)])))
(Mod8 (Const8 [c]) (Const8 [d])) && d != 0 -> (Const8 [int64(int8(c % d))]) (Mod8 (Const8 [c]) (Const8 [d])) && d != 0 -> (Const8 [int64(int8(c % d))])
(Mod16 (Const16 [c]) (Const16 [d])) && d != 0 -> (Const16 [int64(int16(c % d))]) (Mod16 (Const16 [c]) (Const16 [d])) && d != 0 -> (Const16 [int64(int16(c % d))])
@ -481,46 +481,46 @@
// ((x >> c1) << c2) >> c3 // ((x >> c1) << c2) >> c3
(Rsh64Ux64 (Lsh64x64 (Rsh64Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) (Rsh64Ux64 (Lsh64x64 (Rsh64Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
&& uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) && uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
-> (Rsh64Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) -> (Rsh64Ux64 x (Const64 <types.UInt64> [c1-c2+c3]))
(Rsh32Ux64 (Lsh32x64 (Rsh32Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) (Rsh32Ux64 (Lsh32x64 (Rsh32Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
&& uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) && uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
-> (Rsh32Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) -> (Rsh32Ux64 x (Const64 <types.UInt64> [c1-c2+c3]))
(Rsh16Ux64 (Lsh16x64 (Rsh16Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) (Rsh16Ux64 (Lsh16x64 (Rsh16Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
&& uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) && uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
-> (Rsh16Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) -> (Rsh16Ux64 x (Const64 <types.UInt64> [c1-c2+c3]))
(Rsh8Ux64 (Lsh8x64 (Rsh8Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) (Rsh8Ux64 (Lsh8x64 (Rsh8Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
&& uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) && uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
-> (Rsh8Ux64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) -> (Rsh8Ux64 x (Const64 <types.UInt64> [c1-c2+c3]))
// ((x << c1) >> c2) << c3 // ((x << c1) >> c2) << c3
(Lsh64x64 (Rsh64Ux64 (Lsh64x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) (Lsh64x64 (Rsh64Ux64 (Lsh64x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
&& uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) && uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
-> (Lsh64x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) -> (Lsh64x64 x (Const64 <types.UInt64> [c1-c2+c3]))
(Lsh32x64 (Rsh32Ux64 (Lsh32x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) (Lsh32x64 (Rsh32Ux64 (Lsh32x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
&& uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) && uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
-> (Lsh32x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) -> (Lsh32x64 x (Const64 <types.UInt64> [c1-c2+c3]))
(Lsh16x64 (Rsh16Ux64 (Lsh16x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) (Lsh16x64 (Rsh16Ux64 (Lsh16x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
&& uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) && uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
-> (Lsh16x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) -> (Lsh16x64 x (Const64 <types.UInt64> [c1-c2+c3]))
(Lsh8x64 (Rsh8Ux64 (Lsh8x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) (Lsh8x64 (Rsh8Ux64 (Lsh8x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
&& uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) && uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
-> (Lsh8x64 x (Const64 <fe.TypeUInt64()> [c1-c2+c3])) -> (Lsh8x64 x (Const64 <types.UInt64> [c1-c2+c3]))
// replace shifts with zero extensions // replace shifts with zero extensions
(Rsh16Ux64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) -> (ZeroExt8to16 (Trunc16to8 <fe.TypeUInt8()> x)) (Rsh16Ux64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) -> (ZeroExt8to16 (Trunc16to8 <types.UInt8> x))
(Rsh32Ux64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) -> (ZeroExt8to32 (Trunc32to8 <fe.TypeUInt8()> x)) (Rsh32Ux64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) -> (ZeroExt8to32 (Trunc32to8 <types.UInt8> x))
(Rsh64Ux64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) -> (ZeroExt8to64 (Trunc64to8 <fe.TypeUInt8()> x)) (Rsh64Ux64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) -> (ZeroExt8to64 (Trunc64to8 <types.UInt8> x))
(Rsh32Ux64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) -> (ZeroExt16to32 (Trunc32to16 <fe.TypeUInt16()> x)) (Rsh32Ux64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) -> (ZeroExt16to32 (Trunc32to16 <types.UInt16> x))
(Rsh64Ux64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) -> (ZeroExt16to64 (Trunc64to16 <fe.TypeUInt16()> x)) (Rsh64Ux64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) -> (ZeroExt16to64 (Trunc64to16 <types.UInt16> x))
(Rsh64Ux64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) -> (ZeroExt32to64 (Trunc64to32 <fe.TypeUInt32()> x)) (Rsh64Ux64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) -> (ZeroExt32to64 (Trunc64to32 <types.UInt32> x))
// replace shifts with sign extensions // replace shifts with sign extensions
(Rsh16x64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) -> (SignExt8to16 (Trunc16to8 <fe.TypeInt8()> x)) (Rsh16x64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) -> (SignExt8to16 (Trunc16to8 <types.Int8> x))
(Rsh32x64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) -> (SignExt8to32 (Trunc32to8 <fe.TypeInt8()> x)) (Rsh32x64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) -> (SignExt8to32 (Trunc32to8 <types.Int8> x))
(Rsh64x64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) -> (SignExt8to64 (Trunc64to8 <fe.TypeInt8()> x)) (Rsh64x64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) -> (SignExt8to64 (Trunc64to8 <types.Int8> x))
(Rsh32x64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) -> (SignExt16to32 (Trunc32to16 <fe.TypeInt16()> x)) (Rsh32x64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) -> (SignExt16to32 (Trunc32to16 <types.Int16> x))
(Rsh64x64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) -> (SignExt16to64 (Trunc64to16 <fe.TypeInt16()> x)) (Rsh64x64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) -> (SignExt16to64 (Trunc64to16 <types.Int16> x))
(Rsh64x64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) -> (SignExt32to64 (Trunc64to32 <fe.TypeInt32()> x)) (Rsh64x64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) -> (SignExt32to64 (Trunc64to32 <types.Int32> x))
// constant comparisons // constant comparisons
(Eq64 (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(c == d)]) (Eq64 (Const64 [c]) (Const64 [d])) -> (ConstBool [b2i(c == d)])
@ -754,8 +754,8 @@
// indexing operations // indexing operations
// Note: bounds check has already been done // Note: bounds check has already been done
(PtrIndex <t> ptr idx) && config.PtrSize == 4 -> (AddPtr ptr (Mul32 <fe.TypeInt()> idx (Const32 <fe.TypeInt()> [t.ElemType().Size()]))) (PtrIndex <t> ptr idx) && config.PtrSize == 4 -> (AddPtr ptr (Mul32 <types.Int> idx (Const32 <types.Int> [t.ElemType().Size()])))
(PtrIndex <t> ptr idx) && config.PtrSize == 8 -> (AddPtr ptr (Mul64 <fe.TypeInt()> idx (Const64 <fe.TypeInt()> [t.ElemType().Size()]))) (PtrIndex <t> ptr idx) && config.PtrSize == 8 -> (AddPtr ptr (Mul64 <types.Int> idx (Const64 <types.Int> [t.ElemType().Size()])))
// struct operations // struct operations
(StructSelect (StructMake1 x)) -> x (StructSelect (StructMake1 x)) -> x
@ -862,19 +862,19 @@
(StringPtr (StringMake (Const64 <t> [c]) _)) -> (Const64 <t> [c]) (StringPtr (StringMake (Const64 <t> [c]) _)) -> (Const64 <t> [c])
(StringLen (StringMake _ (Const64 <t> [c]))) -> (Const64 <t> [c]) (StringLen (StringMake _ (Const64 <t> [c]))) -> (Const64 <t> [c])
(ConstString {s}) && config.PtrSize == 4 && s.(string) == "" -> (ConstString {s}) && config.PtrSize == 4 && s.(string) == "" ->
(StringMake (ConstNil) (Const32 <fe.TypeInt()> [0])) (StringMake (ConstNil) (Const32 <types.Int> [0]))
(ConstString {s}) && config.PtrSize == 8 && s.(string) == "" -> (ConstString {s}) && config.PtrSize == 8 && s.(string) == "" ->
(StringMake (ConstNil) (Const64 <fe.TypeInt()> [0])) (StringMake (ConstNil) (Const64 <types.Int> [0]))
(ConstString {s}) && config.PtrSize == 4 && s.(string) != "" -> (ConstString {s}) && config.PtrSize == 4 && s.(string) != "" ->
(StringMake (StringMake
(Addr <fe.TypeBytePtr()> {fe.StringData(s.(string))} (Addr <types.BytePtr> {fe.StringData(s.(string))}
(SB)) (SB))
(Const32 <fe.TypeInt()> [int64(len(s.(string)))])) (Const32 <types.Int> [int64(len(s.(string)))]))
(ConstString {s}) && config.PtrSize == 8 && s.(string) != "" -> (ConstString {s}) && config.PtrSize == 8 && s.(string) != "" ->
(StringMake (StringMake
(Addr <fe.TypeBytePtr()> {fe.StringData(s.(string))} (Addr <types.BytePtr> {fe.StringData(s.(string))}
(SB)) (SB))
(Const64 <fe.TypeInt()> [int64(len(s.(string)))])) (Const64 <types.Int> [int64(len(s.(string)))]))
// slice ops // slice ops
// Only a few slice rules are provided here. See dec.rules for // Only a few slice rules are provided here. See dec.rules for
@ -890,19 +890,19 @@
(ConstSlice) && config.PtrSize == 4 -> (ConstSlice) && config.PtrSize == 4 ->
(SliceMake (SliceMake
(ConstNil <v.Type.ElemType().PtrTo()>) (ConstNil <v.Type.ElemType().PtrTo()>)
(Const32 <fe.TypeInt()> [0]) (Const32 <types.Int> [0])
(Const32 <fe.TypeInt()> [0])) (Const32 <types.Int> [0]))
(ConstSlice) && config.PtrSize == 8 -> (ConstSlice) && config.PtrSize == 8 ->
(SliceMake (SliceMake
(ConstNil <v.Type.ElemType().PtrTo()>) (ConstNil <v.Type.ElemType().PtrTo()>)
(Const64 <fe.TypeInt()> [0]) (Const64 <types.Int> [0])
(Const64 <fe.TypeInt()> [0])) (Const64 <types.Int> [0]))
// interface ops // interface ops
(ConstInterface) -> (ConstInterface) ->
(IMake (IMake
(ConstNil <fe.TypeBytePtr()>) (ConstNil <types.BytePtr>)
(ConstNil <fe.TypeBytePtr()>)) (ConstNil <types.BytePtr>))
(NilCheck (GetG mem) mem) -> mem (NilCheck (GetG mem) mem) -> mem
@ -918,29 +918,29 @@
// Decompose compound argument values // Decompose compound argument values
(Arg {n} [off]) && v.Type.IsString() -> (Arg {n} [off]) && v.Type.IsString() ->
(StringMake (StringMake
(Arg <fe.TypeBytePtr()> {n} [off]) (Arg <types.BytePtr> {n} [off])
(Arg <fe.TypeInt()> {n} [off+config.PtrSize])) (Arg <types.Int> {n} [off+config.PtrSize]))
(Arg {n} [off]) && v.Type.IsSlice() -> (Arg {n} [off]) && v.Type.IsSlice() ->
(SliceMake (SliceMake
(Arg <v.Type.ElemType().PtrTo()> {n} [off]) (Arg <v.Type.ElemType().PtrTo()> {n} [off])
(Arg <fe.TypeInt()> {n} [off+config.PtrSize]) (Arg <types.Int> {n} [off+config.PtrSize])
(Arg <fe.TypeInt()> {n} [off+2*config.PtrSize])) (Arg <types.Int> {n} [off+2*config.PtrSize]))
(Arg {n} [off]) && v.Type.IsInterface() -> (Arg {n} [off]) && v.Type.IsInterface() ->
(IMake (IMake
(Arg <fe.TypeBytePtr()> {n} [off]) (Arg <types.BytePtr> {n} [off])
(Arg <fe.TypeBytePtr()> {n} [off+config.PtrSize])) (Arg <types.BytePtr> {n} [off+config.PtrSize]))
(Arg {n} [off]) && v.Type.IsComplex() && v.Type.Size() == 16 -> (Arg {n} [off]) && v.Type.IsComplex() && v.Type.Size() == 16 ->
(ComplexMake (ComplexMake
(Arg <fe.TypeFloat64()> {n} [off]) (Arg <types.Float64> {n} [off])
(Arg <fe.TypeFloat64()> {n} [off+8])) (Arg <types.Float64> {n} [off+8]))
(Arg {n} [off]) && v.Type.IsComplex() && v.Type.Size() == 8 -> (Arg {n} [off]) && v.Type.IsComplex() && v.Type.Size() == 8 ->
(ComplexMake (ComplexMake
(Arg <fe.TypeFloat32()> {n} [off]) (Arg <types.Float32> {n} [off])
(Arg <fe.TypeFloat32()> {n} [off+4])) (Arg <types.Float32> {n} [off+4]))
(Arg <t>) && t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t) -> (Arg <t>) && t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t) ->
(StructMake0) (StructMake0)
@ -972,125 +972,125 @@
// See ../magic.go for a detailed description of these algorithms. // See ../magic.go for a detailed description of these algorithms.
// Unsigned divide by power of 2. Strength reduce to a shift. // Unsigned divide by power of 2. Strength reduce to a shift.
(Div8u n (Const8 [c])) && isPowerOfTwo(c&0xff) -> (Rsh8Ux64 n (Const64 <fe.TypeUInt64()> [log2(c&0xff)])) (Div8u n (Const8 [c])) && isPowerOfTwo(c&0xff) -> (Rsh8Ux64 n (Const64 <types.UInt64> [log2(c&0xff)]))
(Div16u n (Const16 [c])) && isPowerOfTwo(c&0xffff) -> (Rsh16Ux64 n (Const64 <fe.TypeUInt64()> [log2(c&0xffff)])) (Div16u n (Const16 [c])) && isPowerOfTwo(c&0xffff) -> (Rsh16Ux64 n (Const64 <types.UInt64> [log2(c&0xffff)]))
(Div32u n (Const32 [c])) && isPowerOfTwo(c&0xffffffff) -> (Rsh32Ux64 n (Const64 <fe.TypeUInt64()> [log2(c&0xffffffff)])) (Div32u n (Const32 [c])) && isPowerOfTwo(c&0xffffffff) -> (Rsh32Ux64 n (Const64 <types.UInt64> [log2(c&0xffffffff)]))
(Div64u n (Const64 [c])) && isPowerOfTwo(c) -> (Rsh64Ux64 n (Const64 <fe.TypeUInt64()> [log2(c)])) (Div64u n (Const64 [c])) && isPowerOfTwo(c) -> (Rsh64Ux64 n (Const64 <types.UInt64> [log2(c)]))
// Unsigned divide, not a power of 2. Strength reduce to a multiply. // Unsigned divide, not a power of 2. Strength reduce to a multiply.
// For 8-bit divides, we just do a direct 9-bit by 8-bit multiply. // For 8-bit divides, we just do a direct 9-bit by 8-bit multiply.
(Div8u x (Const8 [c])) && umagicOK(8, c) -> (Div8u x (Const8 [c])) && umagicOK(8, c) ->
(Trunc32to8 (Trunc32to8
(Rsh32Ux64 <fe.TypeUInt32()> (Rsh32Ux64 <types.UInt32>
(Mul32 <fe.TypeUInt32()> (Mul32 <types.UInt32>
(Const32 <fe.TypeUInt32()> [int64(1<<8+umagic(8,c).m)]) (Const32 <types.UInt32> [int64(1<<8+umagic(8,c).m)])
(ZeroExt8to32 x)) (ZeroExt8to32 x))
(Const64 <fe.TypeUInt64()> [8+umagic(8,c).s]))) (Const64 <types.UInt64> [8+umagic(8,c).s])))
// For 16-bit divides on 64-bit machines, we do a direct 17-bit by 16-bit multiply. // For 16-bit divides on 64-bit machines, we do a direct 17-bit by 16-bit multiply.
(Div16u x (Const16 [c])) && umagicOK(16, c) && config.RegSize == 8 -> (Div16u x (Const16 [c])) && umagicOK(16, c) && config.RegSize == 8 ->
(Trunc64to16 (Trunc64to16
(Rsh64Ux64 <fe.TypeUInt64()> (Rsh64Ux64 <types.UInt64>
(Mul64 <fe.TypeUInt64()> (Mul64 <types.UInt64>
(Const64 <fe.TypeUInt64()> [int64(1<<16+umagic(16,c).m)]) (Const64 <types.UInt64> [int64(1<<16+umagic(16,c).m)])
(ZeroExt16to64 x)) (ZeroExt16to64 x))
(Const64 <fe.TypeUInt64()> [16+umagic(16,c).s]))) (Const64 <types.UInt64> [16+umagic(16,c).s])))
// For 16-bit divides on 32-bit machines // For 16-bit divides on 32-bit machines
(Div16u x (Const16 [c])) && umagicOK(16, c) && config.RegSize == 4 && umagic(16,c).m&1 == 0 -> (Div16u x (Const16 [c])) && umagicOK(16, c) && config.RegSize == 4 && umagic(16,c).m&1 == 0 ->
(Trunc32to16 (Trunc32to16
(Rsh32Ux64 <fe.TypeUInt32()> (Rsh32Ux64 <types.UInt32>
(Mul32 <fe.TypeUInt32()> (Mul32 <types.UInt32>
(Const32 <fe.TypeUInt32()> [int64(1<<15+umagic(16,c).m/2)]) (Const32 <types.UInt32> [int64(1<<15+umagic(16,c).m/2)])
(ZeroExt16to32 x)) (ZeroExt16to32 x))
(Const64 <fe.TypeUInt64()> [16+umagic(16,c).s-1]))) (Const64 <types.UInt64> [16+umagic(16,c).s-1])))
(Div16u x (Const16 [c])) && umagicOK(16, c) && config.RegSize == 4 && c&1 == 0 -> (Div16u x (Const16 [c])) && umagicOK(16, c) && config.RegSize == 4 && c&1 == 0 ->
(Trunc32to16 (Trunc32to16
(Rsh32Ux64 <fe.TypeUInt32()> (Rsh32Ux64 <types.UInt32>
(Mul32 <fe.TypeUInt32()> (Mul32 <types.UInt32>
(Const32 <fe.TypeUInt32()> [int64(1<<15+(umagic(16,c).m+1)/2)]) (Const32 <types.UInt32> [int64(1<<15+(umagic(16,c).m+1)/2)])
(Rsh32Ux64 <fe.TypeUInt32()> (ZeroExt16to32 x) (Const64 <fe.TypeUInt64()> [1]))) (Rsh32Ux64 <types.UInt32> (ZeroExt16to32 x) (Const64 <types.UInt64> [1])))
(Const64 <fe.TypeUInt64()> [16+umagic(16,c).s-2]))) (Const64 <types.UInt64> [16+umagic(16,c).s-2])))
(Div16u x (Const16 [c])) && umagicOK(16, c) && config.RegSize == 4 -> (Div16u x (Const16 [c])) && umagicOK(16, c) && config.RegSize == 4 ->
(Trunc32to16 (Trunc32to16
(Rsh32Ux64 <fe.TypeUInt32()> (Rsh32Ux64 <types.UInt32>
(Avg32u (Avg32u
(Lsh32x64 <fe.TypeUInt32()> (ZeroExt16to32 x) (Const64 <fe.TypeUInt64()> [16])) (Lsh32x64 <types.UInt32> (ZeroExt16to32 x) (Const64 <types.UInt64> [16]))
(Mul32 <fe.TypeUInt32()> (Mul32 <types.UInt32>
(Const32 <fe.TypeUInt32()> [int64(umagic(16,c).m)]) (Const32 <types.UInt32> [int64(umagic(16,c).m)])
(ZeroExt16to32 x))) (ZeroExt16to32 x)))
(Const64 <fe.TypeUInt64()> [16+umagic(16,c).s-1]))) (Const64 <types.UInt64> [16+umagic(16,c).s-1])))
// For 32-bit divides on 32-bit machines // For 32-bit divides on 32-bit machines
(Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 4 && umagic(32,c).m&1 == 0 -> (Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 4 && umagic(32,c).m&1 == 0 ->
(Rsh32Ux64 <fe.TypeUInt32()> (Rsh32Ux64 <types.UInt32>
(Hmul32u <fe.TypeUInt32()> (Hmul32u <types.UInt32>
(Const32 <fe.TypeUInt32()> [int64(int32(1<<31+umagic(32,c).m/2))]) (Const32 <types.UInt32> [int64(int32(1<<31+umagic(32,c).m/2))])
x) x)
(Const64 <fe.TypeUInt64()> [umagic(32,c).s-1])) (Const64 <types.UInt64> [umagic(32,c).s-1]))
(Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 4 && c&1 == 0 -> (Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 4 && c&1 == 0 ->
(Rsh32Ux64 <fe.TypeUInt32()> (Rsh32Ux64 <types.UInt32>
(Hmul32u <fe.TypeUInt32()> (Hmul32u <types.UInt32>
(Const32 <fe.TypeUInt32()> [int64(int32(1<<31+(umagic(32,c).m+1)/2))]) (Const32 <types.UInt32> [int64(int32(1<<31+(umagic(32,c).m+1)/2))])
(Rsh32Ux64 <fe.TypeUInt32()> x (Const64 <fe.TypeUInt64()> [1]))) (Rsh32Ux64 <types.UInt32> x (Const64 <types.UInt64> [1])))
(Const64 <fe.TypeUInt64()> [umagic(32,c).s-2])) (Const64 <types.UInt64> [umagic(32,c).s-2]))
(Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 4 -> (Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 4 ->
(Rsh32Ux64 <fe.TypeUInt32()> (Rsh32Ux64 <types.UInt32>
(Avg32u (Avg32u
x x
(Hmul32u <fe.TypeUInt32()> (Hmul32u <types.UInt32>
(Const32 <fe.TypeUInt32()> [int64(int32(umagic(32,c).m))]) (Const32 <types.UInt32> [int64(int32(umagic(32,c).m))])
x)) x))
(Const64 <fe.TypeUInt64()> [umagic(32,c).s-1])) (Const64 <types.UInt64> [umagic(32,c).s-1]))
// For 32-bit divides on 64-bit machines // For 32-bit divides on 64-bit machines
// We'll use a regular (non-hi) multiply for this case. // We'll use a regular (non-hi) multiply for this case.
(Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 8 && umagic(32,c).m&1 == 0 -> (Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 8 && umagic(32,c).m&1 == 0 ->
(Trunc64to32 (Trunc64to32
(Rsh64Ux64 <fe.TypeUInt64()> (Rsh64Ux64 <types.UInt64>
(Mul64 <fe.TypeUInt64()> (Mul64 <types.UInt64>
(Const64 <fe.TypeUInt64()> [int64(1<<31+umagic(32,c).m/2)]) (Const64 <types.UInt64> [int64(1<<31+umagic(32,c).m/2)])
(ZeroExt32to64 x)) (ZeroExt32to64 x))
(Const64 <fe.TypeUInt64()> [32+umagic(32,c).s-1]))) (Const64 <types.UInt64> [32+umagic(32,c).s-1])))
(Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 8 && c&1 == 0 -> (Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 8 && c&1 == 0 ->
(Trunc64to32 (Trunc64to32
(Rsh64Ux64 <fe.TypeUInt64()> (Rsh64Ux64 <types.UInt64>
(Mul64 <fe.TypeUInt64()> (Mul64 <types.UInt64>
(Const64 <fe.TypeUInt64()> [int64(1<<31+(umagic(32,c).m+1)/2)]) (Const64 <types.UInt64> [int64(1<<31+(umagic(32,c).m+1)/2)])
(Rsh64Ux64 <fe.TypeUInt64()> (ZeroExt32to64 x) (Const64 <fe.TypeUInt64()> [1]))) (Rsh64Ux64 <types.UInt64> (ZeroExt32to64 x) (Const64 <types.UInt64> [1])))
(Const64 <fe.TypeUInt64()> [32+umagic(32,c).s-2]))) (Const64 <types.UInt64> [32+umagic(32,c).s-2])))
(Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 8 -> (Div32u x (Const32 [c])) && umagicOK(32, c) && config.RegSize == 8 ->
(Trunc64to32 (Trunc64to32
(Rsh64Ux64 <fe.TypeUInt64()> (Rsh64Ux64 <types.UInt64>
(Avg64u (Avg64u
(Lsh64x64 <fe.TypeUInt64()> (ZeroExt32to64 x) (Const64 <fe.TypeUInt64()> [32])) (Lsh64x64 <types.UInt64> (ZeroExt32to64 x) (Const64 <types.UInt64> [32]))
(Mul64 <fe.TypeUInt64()> (Mul64 <types.UInt64>
(Const64 <fe.TypeUInt32()> [int64(umagic(32,c).m)]) (Const64 <types.UInt32> [int64(umagic(32,c).m)])
(ZeroExt32to64 x))) (ZeroExt32to64 x)))
(Const64 <fe.TypeUInt64()> [32+umagic(32,c).s-1]))) (Const64 <types.UInt64> [32+umagic(32,c).s-1])))
// For 64-bit divides on 64-bit machines // For 64-bit divides on 64-bit machines
// (64-bit divides on 32-bit machines are lowered to a runtime call by the walk pass.) // (64-bit divides on 32-bit machines are lowered to a runtime call by the walk pass.)
(Div64u x (Const64 [c])) && umagicOK(64, c) && config.RegSize == 8 && umagic(64,c).m&1 == 0 -> (Div64u x (Const64 [c])) && umagicOK(64, c) && config.RegSize == 8 && umagic(64,c).m&1 == 0 ->
(Rsh64Ux64 <fe.TypeUInt64()> (Rsh64Ux64 <types.UInt64>
(Hmul64u <fe.TypeUInt64()> (Hmul64u <types.UInt64>
(Const64 <fe.TypeUInt64()> [int64(1<<63+umagic(64,c).m/2)]) (Const64 <types.UInt64> [int64(1<<63+umagic(64,c).m/2)])
x) x)
(Const64 <fe.TypeUInt64()> [umagic(64,c).s-1])) (Const64 <types.UInt64> [umagic(64,c).s-1]))
(Div64u x (Const64 [c])) && umagicOK(64, c) && config.RegSize == 8 && c&1 == 0 -> (Div64u x (Const64 [c])) && umagicOK(64, c) && config.RegSize == 8 && c&1 == 0 ->
(Rsh64Ux64 <fe.TypeUInt64()> (Rsh64Ux64 <types.UInt64>
(Hmul64u <fe.TypeUInt64()> (Hmul64u <types.UInt64>
(Const64 <fe.TypeUInt64()> [int64(1<<63+(umagic(64,c).m+1)/2)]) (Const64 <types.UInt64> [int64(1<<63+(umagic(64,c).m+1)/2)])
(Rsh64Ux64 <fe.TypeUInt64()> x (Const64 <fe.TypeUInt64()> [1]))) (Rsh64Ux64 <types.UInt64> x (Const64 <types.UInt64> [1])))
(Const64 <fe.TypeUInt64()> [umagic(64,c).s-2])) (Const64 <types.UInt64> [umagic(64,c).s-2]))
(Div64u x (Const64 [c])) && umagicOK(64, c) && config.RegSize == 8 -> (Div64u x (Const64 [c])) && umagicOK(64, c) && config.RegSize == 8 ->
(Rsh64Ux64 <fe.TypeUInt64()> (Rsh64Ux64 <types.UInt64>
(Avg64u (Avg64u
x x
(Hmul64u <fe.TypeUInt64()> (Hmul64u <types.UInt64>
(Const64 <fe.TypeUInt64()> [int64(umagic(64,c).m)]) (Const64 <types.UInt64> [int64(umagic(64,c).m)])
x)) x))
(Const64 <fe.TypeUInt64()> [umagic(64,c).s-1])) (Const64 <types.UInt64> [umagic(64,c).s-1]))
// Signed divide by a negative constant. Rewrite to divide by a positive constant. // Signed divide by a negative constant. Rewrite to divide by a positive constant.
(Div8 <t> n (Const8 [c])) && c < 0 && c != -1<<7 -> (Neg8 (Div8 <t> n (Const8 <t> [-c]))) (Div8 <t> n (Const8 [c])) && c < 0 && c != -1<<7 -> (Neg8 (Div8 <t> n (Const8 <t> [-c])))
@ -1101,10 +1101,10 @@
// Dividing by the most-negative number. Result is always 0 except // Dividing by the most-negative number. Result is always 0 except
// if the input is also the most-negative number. // if the input is also the most-negative number.
// We can detect that using the sign bit of x & -x. // We can detect that using the sign bit of x & -x.
(Div8 <t> x (Const8 [-1<<7 ])) -> (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <fe.TypeUInt64()> [7 ])) (Div8 <t> x (Const8 [-1<<7 ])) -> (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <types.UInt64> [7 ]))
(Div16 <t> x (Const16 [-1<<15])) -> (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <fe.TypeUInt64()> [15])) (Div16 <t> x (Const16 [-1<<15])) -> (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <types.UInt64> [15]))
(Div32 <t> x (Const32 [-1<<31])) -> (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <fe.TypeUInt64()> [31])) (Div32 <t> x (Const32 [-1<<31])) -> (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <types.UInt64> [31]))
(Div64 <t> x (Const64 [-1<<63])) -> (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <fe.TypeUInt64()> [63])) (Div64 <t> x (Const64 [-1<<63])) -> (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <types.UInt64> [63]))
// Signed divide by power of 2. // Signed divide by power of 2.
// n / c = n >> log(c) if n >= 0 // n / c = n >> log(c) if n >= 0
@ -1112,96 +1112,96 @@
// We conditionally add c-1 by adding n>>63>>(64-log(c)) (first shift signed, second shift unsigned). // We conditionally add c-1 by adding n>>63>>(64-log(c)) (first shift signed, second shift unsigned).
(Div8 <t> n (Const8 [c])) && isPowerOfTwo(c) -> (Div8 <t> n (Const8 [c])) && isPowerOfTwo(c) ->
(Rsh8x64 (Rsh8x64
(Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <fe.TypeUInt64()> [ 7])) (Const64 <fe.TypeUInt64()> [ 8-log2(c)]))) (Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <types.UInt64> [ 7])) (Const64 <types.UInt64> [ 8-log2(c)])))
(Const64 <fe.TypeUInt64()> [log2(c)])) (Const64 <types.UInt64> [log2(c)]))
(Div16 <t> n (Const16 [c])) && isPowerOfTwo(c) -> (Div16 <t> n (Const16 [c])) && isPowerOfTwo(c) ->
(Rsh16x64 (Rsh16x64
(Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <fe.TypeUInt64()> [15])) (Const64 <fe.TypeUInt64()> [16-log2(c)]))) (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <types.UInt64> [15])) (Const64 <types.UInt64> [16-log2(c)])))
(Const64 <fe.TypeUInt64()> [log2(c)])) (Const64 <types.UInt64> [log2(c)]))
(Div32 <t> n (Const32 [c])) && isPowerOfTwo(c) -> (Div32 <t> n (Const32 [c])) && isPowerOfTwo(c) ->
(Rsh32x64 (Rsh32x64
(Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <fe.TypeUInt64()> [31])) (Const64 <fe.TypeUInt64()> [32-log2(c)]))) (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <types.UInt64> [31])) (Const64 <types.UInt64> [32-log2(c)])))
(Const64 <fe.TypeUInt64()> [log2(c)])) (Const64 <types.UInt64> [log2(c)]))
(Div64 <t> n (Const64 [c])) && isPowerOfTwo(c) -> (Div64 <t> n (Const64 [c])) && isPowerOfTwo(c) ->
(Rsh64x64 (Rsh64x64
(Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <fe.TypeUInt64()> [63])) (Const64 <fe.TypeUInt64()> [64-log2(c)]))) (Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <types.UInt64> [63])) (Const64 <types.UInt64> [64-log2(c)])))
(Const64 <fe.TypeUInt64()> [log2(c)])) (Const64 <types.UInt64> [log2(c)]))
// Signed divide, not a power of 2. Strength reduce to a multiply. // Signed divide, not a power of 2. Strength reduce to a multiply.
(Div8 <t> x (Const8 [c])) && smagicOK(8,c) -> (Div8 <t> x (Const8 [c])) && smagicOK(8,c) ->
(Sub8 <t> (Sub8 <t>
(Rsh32x64 <t> (Rsh32x64 <t>
(Mul32 <fe.TypeUInt32()> (Mul32 <types.UInt32>
(Const32 <fe.TypeUInt32()> [int64(smagic(8,c).m)]) (Const32 <types.UInt32> [int64(smagic(8,c).m)])
(SignExt8to32 x)) (SignExt8to32 x))
(Const64 <fe.TypeUInt64()> [8+smagic(8,c).s])) (Const64 <types.UInt64> [8+smagic(8,c).s]))
(Rsh32x64 <t> (Rsh32x64 <t>
(SignExt8to32 x) (SignExt8to32 x)
(Const64 <fe.TypeUInt64()> [31]))) (Const64 <types.UInt64> [31])))
(Div16 <t> x (Const16 [c])) && smagicOK(16,c) -> (Div16 <t> x (Const16 [c])) && smagicOK(16,c) ->
(Sub16 <t> (Sub16 <t>
(Rsh32x64 <t> (Rsh32x64 <t>
(Mul32 <fe.TypeUInt32()> (Mul32 <types.UInt32>
(Const32 <fe.TypeUInt32()> [int64(smagic(16,c).m)]) (Const32 <types.UInt32> [int64(smagic(16,c).m)])
(SignExt16to32 x)) (SignExt16to32 x))
(Const64 <fe.TypeUInt64()> [16+smagic(16,c).s])) (Const64 <types.UInt64> [16+smagic(16,c).s]))
(Rsh32x64 <t> (Rsh32x64 <t>
(SignExt16to32 x) (SignExt16to32 x)
(Const64 <fe.TypeUInt64()> [31]))) (Const64 <types.UInt64> [31])))
(Div32 <t> x (Const32 [c])) && smagicOK(32,c) && config.RegSize == 8 -> (Div32 <t> x (Const32 [c])) && smagicOK(32,c) && config.RegSize == 8 ->
(Sub32 <t> (Sub32 <t>
(Rsh64x64 <t> (Rsh64x64 <t>
(Mul64 <fe.TypeUInt64()> (Mul64 <types.UInt64>
(Const64 <fe.TypeUInt64()> [int64(smagic(32,c).m)]) (Const64 <types.UInt64> [int64(smagic(32,c).m)])
(SignExt32to64 x)) (SignExt32to64 x))
(Const64 <fe.TypeUInt64()> [32+smagic(32,c).s])) (Const64 <types.UInt64> [32+smagic(32,c).s]))
(Rsh64x64 <t> (Rsh64x64 <t>
(SignExt32to64 x) (SignExt32to64 x)
(Const64 <fe.TypeUInt64()> [63]))) (Const64 <types.UInt64> [63])))
(Div32 <t> x (Const32 [c])) && smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 == 0 -> (Div32 <t> x (Const32 [c])) && smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 == 0 ->
(Sub32 <t> (Sub32 <t>
(Rsh32x64 <t> (Rsh32x64 <t>
(Hmul32 <t> (Hmul32 <t>
(Const32 <fe.TypeUInt32()> [int64(int32(smagic(32,c).m/2))]) (Const32 <types.UInt32> [int64(int32(smagic(32,c).m/2))])
x) x)
(Const64 <fe.TypeUInt64()> [smagic(32,c).s-1])) (Const64 <types.UInt64> [smagic(32,c).s-1]))
(Rsh32x64 <t> (Rsh32x64 <t>
x x
(Const64 <fe.TypeUInt64()> [31]))) (Const64 <types.UInt64> [31])))
(Div32 <t> x (Const32 [c])) && smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 != 0 -> (Div32 <t> x (Const32 [c])) && smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 != 0 ->
(Sub32 <t> (Sub32 <t>
(Rsh32x64 <t> (Rsh32x64 <t>
(Add32 <t> (Add32 <t>
(Hmul32 <t> (Hmul32 <t>
(Const32 <fe.TypeUInt32()> [int64(int32(smagic(32,c).m))]) (Const32 <types.UInt32> [int64(int32(smagic(32,c).m))])
x) x)
x) x)
(Const64 <fe.TypeUInt64()> [smagic(32,c).s])) (Const64 <types.UInt64> [smagic(32,c).s]))
(Rsh32x64 <t> (Rsh32x64 <t>
x x
(Const64 <fe.TypeUInt64()> [31]))) (Const64 <types.UInt64> [31])))
(Div64 <t> x (Const64 [c])) && smagicOK(64,c) && smagic(64,c).m&1 == 0 -> (Div64 <t> x (Const64 [c])) && smagicOK(64,c) && smagic(64,c).m&1 == 0 ->
(Sub64 <t> (Sub64 <t>
(Rsh64x64 <t> (Rsh64x64 <t>
(Hmul64 <t> (Hmul64 <t>
(Const64 <fe.TypeUInt64()> [int64(smagic(64,c).m/2)]) (Const64 <types.UInt64> [int64(smagic(64,c).m/2)])
x) x)
(Const64 <fe.TypeUInt64()> [smagic(64,c).s-1])) (Const64 <types.UInt64> [smagic(64,c).s-1]))
(Rsh64x64 <t> (Rsh64x64 <t>
x x
(Const64 <fe.TypeUInt64()> [63]))) (Const64 <types.UInt64> [63])))
(Div64 <t> x (Const64 [c])) && smagicOK(64,c) && smagic(64,c).m&1 != 0 -> (Div64 <t> x (Const64 [c])) && smagicOK(64,c) && smagic(64,c).m&1 != 0 ->
(Sub64 <t> (Sub64 <t>
(Rsh64x64 <t> (Rsh64x64 <t>
(Add64 <t> (Add64 <t>
(Hmul64 <t> (Hmul64 <t>
(Const64 <fe.TypeUInt64()> [int64(smagic(64,c).m)]) (Const64 <types.UInt64> [int64(smagic(64,c).m)])
x) x)
x) x)
(Const64 <fe.TypeUInt64()> [smagic(64,c).s])) (Const64 <types.UInt64> [smagic(64,c).s]))
(Rsh64x64 <t> (Rsh64x64 <t>
x x
(Const64 <fe.TypeUInt64()> [63]))) (Const64 <types.UInt64> [63])))
// Unsigned mod by power of 2 constant. // Unsigned mod by power of 2 constant.
(Mod8u <t> n (Const8 [c])) && isPowerOfTwo(c&0xff) -> (And8 n (Const8 <t> [(c&0xff)-1])) (Mod8u <t> n (Const8 [c])) && isPowerOfTwo(c&0xff) -> (And8 n (Const8 <t> [(c&0xff)-1]))

11
src/cmd/compile/internal/ssa/gen/rulegen.go
View file

@ -204,12 +204,13 @@ func genRules(arch arch) {
} }
body := buf.String() body := buf.String()
// Do a rough match to predict whether we need b, config, and/or fe. // Do a rough match to predict whether we need b, config, fe, and/or types.
// It's not precise--thus the blank assignments--but it's good enough // It's not precise--thus the blank assignments--but it's good enough
// to avoid generating needless code and doing pointless nil checks. // to avoid generating needless code and doing pointless nil checks.
hasb := strings.Contains(body, "b.") hasb := strings.Contains(body, "b.")
hasconfig := strings.Contains(body, "config.") || strings.Contains(body, "config)") hasconfig := strings.Contains(body, "config.") || strings.Contains(body, "config)")
hasfe := strings.Contains(body, "fe.") hasfe := strings.Contains(body, "fe.")
hasts := strings.Contains(body, "types.")
fmt.Fprintf(w, "func rewriteValue%s_%s(v *Value) bool {\n", arch.name, op) fmt.Fprintf(w, "func rewriteValue%s_%s(v *Value) bool {\n", arch.name, op)
if hasb || hasconfig || hasfe { if hasb || hasconfig || hasfe {
fmt.Fprintln(w, "b := v.Block") fmt.Fprintln(w, "b := v.Block")
@ -223,6 +224,10 @@ func genRules(arch arch) {
fmt.Fprintln(w, "fe := b.Func.fe") fmt.Fprintln(w, "fe := b.Func.fe")
fmt.Fprintln(w, "_ = fe") fmt.Fprintln(w, "_ = fe")
} }
if hasts {
fmt.Fprintln(w, "types := &b.Func.Config.Types")
fmt.Fprintln(w, "_ = types")
}
fmt.Fprint(w, body) fmt.Fprint(w, body)
fmt.Fprintf(w, "}\n") fmt.Fprintf(w, "}\n")
} }
@ -234,6 +239,8 @@ func genRules(arch arch) {
fmt.Fprintln(w, "_ = config") fmt.Fprintln(w, "_ = config")
fmt.Fprintln(w, "fe := b.Func.fe") fmt.Fprintln(w, "fe := b.Func.fe")
fmt.Fprintln(w, "_ = fe") fmt.Fprintln(w, "_ = fe")
fmt.Fprintln(w, "types := &config.Types")
fmt.Fprintln(w, "_ = types")
fmt.Fprintf(w, "switch b.Kind {\n") fmt.Fprintf(w, "switch b.Kind {\n")
ops = nil ops = nil
for op := range blockrules { for op := range blockrules {
@ -719,7 +726,7 @@ func typeName(typ string) string {
case "Flags", "Mem", "Void", "Int128": case "Flags", "Mem", "Void", "Int128":
return "Type" + typ return "Type" + typ
default: default:
return "fe.Type" + typ + "()" return "types." + typ
} }
} }

5
src/cmd/compile/internal/ssa/loopreschedchecks.go
View file

@ -197,7 +197,8 @@ func insertLoopReschedChecks(f *Func) {
// if sp < g.limit { goto sched } // if sp < g.limit { goto sched }
// goto header // goto header
pt := f.fe.TypeUintptr() types := &f.Config.Types
pt := types.Uintptr
g := test.NewValue1(bb.Pos, OpGetG, pt, mem0) g := test.NewValue1(bb.Pos, OpGetG, pt, mem0)
sp := test.NewValue0(bb.Pos, OpSP, pt) sp := test.NewValue0(bb.Pos, OpSP, pt)
cmpOp := OpLess64U cmpOp := OpLess64U
@ -206,7 +207,7 @@ func insertLoopReschedChecks(f *Func) {
} }
limaddr := test.NewValue1I(bb.Pos, OpOffPtr, pt, 2*pt.Size(), g) limaddr := test.NewValue1I(bb.Pos, OpOffPtr, pt, 2*pt.Size(), g)
lim := test.NewValue2(bb.Pos, OpLoad, pt, limaddr, mem0) lim := test.NewValue2(bb.Pos, OpLoad, pt, limaddr, mem0)
cmp := test.NewValue2(bb.Pos, cmpOp, f.fe.TypeBool(), sp, lim) cmp := test.NewValue2(bb.Pos, cmpOp, types.Bool, sp, lim)
test.SetControl(cmp) test.SetControl(cmp)
// if true, goto sched // if true, goto sched

7
src/cmd/compile/internal/ssa/regalloc.go
View file

@ -2055,10 +2055,11 @@ func (e *edgeState) erase(loc Location) {
func (e *edgeState) findRegFor(typ Type) Location { func (e *edgeState) findRegFor(typ Type) Location {
// Which registers are possibilities. // Which registers are possibilities.
var m regMask var m regMask
types := &e.s.f.Config.Types
if typ.IsFloat() { if typ.IsFloat() {
m = e.s.compatRegs(e.s.f.fe.TypeFloat64()) m = e.s.compatRegs(types.Float64)
} else { } else {
m = e.s.compatRegs(e.s.f.fe.TypeInt64()) m = e.s.compatRegs(types.Int64)
} }
// Pick a register. In priority order: // Pick a register. In priority order:
@ -2082,7 +2083,7 @@ func (e *edgeState) findRegFor(typ Type) Location {
// No register is available. Allocate a temp location to spill a register to. // No register is available. Allocate a temp location to spill a register to.
// The type of the slot is immaterial - it will not be live across // The type of the slot is immaterial - it will not be live across
// any safepoint. Just use a type big enough to hold any register. // any safepoint. Just use a type big enough to hold any register.
typ = e.s.f.fe.TypeInt64() typ = types.Int64
t := LocalSlot{e.s.f.fe.Auto(typ), typ, 0} t := LocalSlot{e.s.f.fe.Auto(typ), typ, 0}
// TODO: reuse these slots. // TODO: reuse these slots.

116
src/cmd/compile/internal/ssa/rewrite386.go
View file

@ -4354,8 +4354,8 @@ func rewriteValue386_Op386MOVSDconst(v *Value) bool {
_ = b _ = b
config := b.Func.Config config := b.Func.Config
_ = config _ = config
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (MOVSDconst [c]) // match: (MOVSDconst [c])
// cond: config.ctxt.Flag_shared // cond: config.ctxt.Flag_shared
// result: (MOVSDconst2 (MOVSDconst1 [c])) // result: (MOVSDconst2 (MOVSDconst1 [c]))
@ -4365,7 +4365,7 @@ func rewriteValue386_Op386MOVSDconst(v *Value) bool {
break break
} }
v.reset(Op386MOVSDconst2) v.reset(Op386MOVSDconst2)
v0 := b.NewValue0(v.Pos, Op386MOVSDconst1, fe.TypeUInt32()) v0 := b.NewValue0(v.Pos, Op386MOVSDconst1, types.UInt32)
v0.AuxInt = c v0.AuxInt = c
v.AddArg(v0) v.AddArg(v0)
return true return true
@ -4843,8 +4843,8 @@ func rewriteValue386_Op386MOVSSconst(v *Value) bool {
_ = b _ = b
config := b.Func.Config config := b.Func.Config
_ = config _ = config
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (MOVSSconst [c]) // match: (MOVSSconst [c])
// cond: config.ctxt.Flag_shared // cond: config.ctxt.Flag_shared
// result: (MOVSSconst2 (MOVSSconst1 [c])) // result: (MOVSSconst2 (MOVSSconst1 [c]))
@ -4854,7 +4854,7 @@ func rewriteValue386_Op386MOVSSconst(v *Value) bool {
break break
} }
v.reset(Op386MOVSSconst2) v.reset(Op386MOVSSconst2)
v0 := b.NewValue0(v.Pos, Op386MOVSSconst1, fe.TypeUInt32()) v0 := b.NewValue0(v.Pos, Op386MOVSSconst1, types.UInt32)
v0.AuxInt = c v0.AuxInt = c
v.AddArg(v0) v.AddArg(v0)
return true return true
@ -7212,8 +7212,8 @@ func rewriteValue386_Op386NOTL(v *Value) bool {
func rewriteValue386_Op386ORL(v *Value) bool { func rewriteValue386_Op386ORL(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (ORL x (MOVLconst [c])) // match: (ORL x (MOVLconst [c]))
// cond: // cond:
// result: (ORLconst [c] x) // result: (ORLconst [c] x)
@ -7479,7 +7479,7 @@ func rewriteValue386_Op386ORL(v *Value) bool {
break break
} }
b = mergePoint(b, x0, x1) b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, Op386MOVWload, fe.TypeUInt16()) v0 := b.NewValue0(v.Pos, Op386MOVWload, types.UInt16)
v.reset(OpCopy) v.reset(OpCopy)
v.AddArg(v0) v.AddArg(v0)
v0.AuxInt = i v0.AuxInt = i
@ -7554,7 +7554,7 @@ func rewriteValue386_Op386ORL(v *Value) bool {
break break
} }
b = mergePoint(b, x0, x1, x2) b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v0 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v.reset(OpCopy) v.reset(OpCopy)
v.AddArg(v0) v.AddArg(v0)
v0.AuxInt = i v0.AuxInt = i
@ -9890,8 +9890,8 @@ func rewriteValue386_OpDiv64F(v *Value) bool {
func rewriteValue386_OpDiv8(v *Value) bool { func rewriteValue386_OpDiv8(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Div8 x y) // match: (Div8 x y)
// cond: // cond:
// result: (DIVW (SignExt8to16 x) (SignExt8to16 y)) // result: (DIVW (SignExt8to16 x) (SignExt8to16 y))
@ -9899,10 +9899,10 @@ func rewriteValue386_OpDiv8(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(Op386DIVW) v.reset(Op386DIVW)
v0 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16()) v0 := b.NewValue0(v.Pos, OpSignExt8to16, types.Int16)
v0.AddArg(x) v0.AddArg(x)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16()) v1 := b.NewValue0(v.Pos, OpSignExt8to16, types.Int16)
v1.AddArg(y) v1.AddArg(y)
v.AddArg(v1) v.AddArg(v1)
return true return true
@ -9911,8 +9911,8 @@ func rewriteValue386_OpDiv8(v *Value) bool {
func rewriteValue386_OpDiv8u(v *Value) bool { func rewriteValue386_OpDiv8u(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Div8u x y) // match: (Div8u x y)
// cond: // cond:
// result: (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)) // result: (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y))
@ -9920,10 +9920,10 @@ func rewriteValue386_OpDiv8u(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(Op386DIVWU) v.reset(Op386DIVWU)
v0 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16()) v0 := b.NewValue0(v.Pos, OpZeroExt8to16, types.UInt16)
v0.AddArg(x) v0.AddArg(x)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16()) v1 := b.NewValue0(v.Pos, OpZeroExt8to16, types.UInt16)
v1.AddArg(y) v1.AddArg(y)
v.AddArg(v1) v.AddArg(v1)
return true return true
@ -11163,8 +11163,8 @@ func rewriteValue386_OpMod32u(v *Value) bool {
func rewriteValue386_OpMod8(v *Value) bool { func rewriteValue386_OpMod8(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Mod8 x y) // match: (Mod8 x y)
// cond: // cond:
// result: (MODW (SignExt8to16 x) (SignExt8to16 y)) // result: (MODW (SignExt8to16 x) (SignExt8to16 y))
@ -11172,10 +11172,10 @@ func rewriteValue386_OpMod8(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(Op386MODW) v.reset(Op386MODW)
v0 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16()) v0 := b.NewValue0(v.Pos, OpSignExt8to16, types.Int16)
v0.AddArg(x) v0.AddArg(x)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16()) v1 := b.NewValue0(v.Pos, OpSignExt8to16, types.Int16)
v1.AddArg(y) v1.AddArg(y)
v.AddArg(v1) v.AddArg(v1)
return true return true
@ -11184,8 +11184,8 @@ func rewriteValue386_OpMod8(v *Value) bool {
func rewriteValue386_OpMod8u(v *Value) bool { func rewriteValue386_OpMod8u(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Mod8u x y) // match: (Mod8u x y)
// cond: // cond:
// result: (MODWU (ZeroExt8to16 x) (ZeroExt8to16 y)) // result: (MODWU (ZeroExt8to16 x) (ZeroExt8to16 y))
@ -11193,10 +11193,10 @@ func rewriteValue386_OpMod8u(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(Op386MODWU) v.reset(Op386MODWU)
v0 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16()) v0 := b.NewValue0(v.Pos, OpZeroExt8to16, types.UInt16)
v0.AddArg(x) v0.AddArg(x)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16()) v1 := b.NewValue0(v.Pos, OpZeroExt8to16, types.UInt16)
v1.AddArg(y) v1.AddArg(y)
v.AddArg(v1) v.AddArg(v1)
return true return true
@ -11207,8 +11207,8 @@ func rewriteValue386_OpMove(v *Value) bool {
_ = b _ = b
config := b.Func.Config config := b.Func.Config
_ = config _ = config
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Move [0] _ _ mem) // match: (Move [0] _ _ mem)
// cond: // cond:
// result: mem // result: mem
@ -11234,7 +11234,7 @@ func rewriteValue386_OpMove(v *Value) bool {
mem := v.Args[2] mem := v.Args[2]
v.reset(Op386MOVBstore) v.reset(Op386MOVBstore)
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, Op386MOVBload, fe.TypeUInt8()) v0 := b.NewValue0(v.Pos, Op386MOVBload, types.UInt8)
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
@ -11253,7 +11253,7 @@ func rewriteValue386_OpMove(v *Value) bool {
mem := v.Args[2] mem := v.Args[2]
v.reset(Op386MOVWstore) v.reset(Op386MOVWstore)
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, Op386MOVWload, fe.TypeUInt16()) v0 := b.NewValue0(v.Pos, Op386MOVWload, types.UInt16)
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
@ -11272,7 +11272,7 @@ func rewriteValue386_OpMove(v *Value) bool {
mem := v.Args[2] mem := v.Args[2]
v.reset(Op386MOVLstore) v.reset(Op386MOVLstore)
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v0 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
@ -11292,14 +11292,14 @@ func rewriteValue386_OpMove(v *Value) bool {
v.reset(Op386MOVBstore) v.reset(Op386MOVBstore)
v.AuxInt = 2 v.AuxInt = 2
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, Op386MOVBload, fe.TypeUInt8()) v0 := b.NewValue0(v.Pos, Op386MOVBload, types.UInt8)
v0.AuxInt = 2 v0.AuxInt = 2
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, Op386MOVWstore, TypeMem) v1 := b.NewValue0(v.Pos, Op386MOVWstore, TypeMem)
v1.AddArg(dst) v1.AddArg(dst)
v2 := b.NewValue0(v.Pos, Op386MOVWload, fe.TypeUInt16()) v2 := b.NewValue0(v.Pos, Op386MOVWload, types.UInt16)
v2.AddArg(src) v2.AddArg(src)
v2.AddArg(mem) v2.AddArg(mem)
v1.AddArg(v2) v1.AddArg(v2)
@ -11320,14 +11320,14 @@ func rewriteValue386_OpMove(v *Value) bool {
v.reset(Op386MOVBstore) v.reset(Op386MOVBstore)
v.AuxInt = 4 v.AuxInt = 4
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, Op386MOVBload, fe.TypeUInt8()) v0 := b.NewValue0(v.Pos, Op386MOVBload, types.UInt8)
v0.AuxInt = 4 v0.AuxInt = 4
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem) v1 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem)
v1.AddArg(dst) v1.AddArg(dst)
v2 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v2 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v2.AddArg(src) v2.AddArg(src)
v2.AddArg(mem) v2.AddArg(mem)
v1.AddArg(v2) v1.AddArg(v2)
@ -11348,14 +11348,14 @@ func rewriteValue386_OpMove(v *Value) bool {
v.reset(Op386MOVWstore) v.reset(Op386MOVWstore)
v.AuxInt = 4 v.AuxInt = 4
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, Op386MOVWload, fe.TypeUInt16()) v0 := b.NewValue0(v.Pos, Op386MOVWload, types.UInt16)
v0.AuxInt = 4 v0.AuxInt = 4
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem) v1 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem)
v1.AddArg(dst) v1.AddArg(dst)
v2 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v2 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v2.AddArg(src) v2.AddArg(src)
v2.AddArg(mem) v2.AddArg(mem)
v1.AddArg(v2) v1.AddArg(v2)
@ -11376,14 +11376,14 @@ func rewriteValue386_OpMove(v *Value) bool {
v.reset(Op386MOVLstore) v.reset(Op386MOVLstore)
v.AuxInt = 3 v.AuxInt = 3
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v0 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v0.AuxInt = 3 v0.AuxInt = 3
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem) v1 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem)
v1.AddArg(dst) v1.AddArg(dst)
v2 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v2 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v2.AddArg(src) v2.AddArg(src)
v2.AddArg(mem) v2.AddArg(mem)
v1.AddArg(v2) v1.AddArg(v2)
@ -11404,14 +11404,14 @@ func rewriteValue386_OpMove(v *Value) bool {
v.reset(Op386MOVLstore) v.reset(Op386MOVLstore)
v.AuxInt = 4 v.AuxInt = 4
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v0 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v0.AuxInt = 4 v0.AuxInt = 4
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem) v1 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem)
v1.AddArg(dst) v1.AddArg(dst)
v2 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v2 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v2.AddArg(src) v2.AddArg(src)
v2.AddArg(mem) v2.AddArg(mem)
v1.AddArg(v2) v1.AddArg(v2)
@ -11442,7 +11442,7 @@ func rewriteValue386_OpMove(v *Value) bool {
v.AddArg(v1) v.AddArg(v1)
v2 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem) v2 := b.NewValue0(v.Pos, Op386MOVLstore, TypeMem)
v2.AddArg(dst) v2.AddArg(dst)
v3 := b.NewValue0(v.Pos, Op386MOVLload, fe.TypeUInt32()) v3 := b.NewValue0(v.Pos, Op386MOVLload, types.UInt32)
v3.AddArg(src) v3.AddArg(src)
v3.AddArg(mem) v3.AddArg(mem)
v2.AddArg(v3) v2.AddArg(v3)
@ -11482,7 +11482,7 @@ func rewriteValue386_OpMove(v *Value) bool {
v.reset(Op386REPMOVSL) v.reset(Op386REPMOVSL)
v.AddArg(dst) v.AddArg(dst)
v.AddArg(src) v.AddArg(src)
v0 := b.NewValue0(v.Pos, Op386MOVLconst, fe.TypeUInt32()) v0 := b.NewValue0(v.Pos, Op386MOVLconst, types.UInt32)
v0.AuxInt = s / 4 v0.AuxInt = s / 4
v.AddArg(v0) v.AddArg(v0)
v.AddArg(mem) v.AddArg(mem)
@ -11595,11 +11595,11 @@ func rewriteValue386_OpNeg32F(v *Value) bool {
_ = b _ = b
config := b.Func.Config config := b.Func.Config
_ = config _ = config
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Neg32F x) // match: (Neg32F x)
// cond: !config.use387 // cond: !config.use387
// result: (PXOR x (MOVSSconst <fe.TypeFloat32()> [f2i(math.Copysign(0, -1))])) // result: (PXOR x (MOVSSconst <types.Float32> [f2i(math.Copysign(0, -1))]))
for { for {
x := v.Args[0] x := v.Args[0]
if !(!config.use387) { if !(!config.use387) {
@ -11607,7 +11607,7 @@ func rewriteValue386_OpNeg32F(v *Value) bool {
} }
v.reset(Op386PXOR) v.reset(Op386PXOR)
v.AddArg(x) v.AddArg(x)
v0 := b.NewValue0(v.Pos, Op386MOVSSconst, fe.TypeFloat32()) v0 := b.NewValue0(v.Pos, Op386MOVSSconst, types.Float32)
v0.AuxInt = f2i(math.Copysign(0, -1)) v0.AuxInt = f2i(math.Copysign(0, -1))
v.AddArg(v0) v.AddArg(v0)
return true return true
@ -11631,11 +11631,11 @@ func rewriteValue386_OpNeg64F(v *Value) bool {
_ = b _ = b
config := b.Func.Config config := b.Func.Config
_ = config _ = config
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Neg64F x) // match: (Neg64F x)
// cond: !config.use387 // cond: !config.use387
// result: (PXOR x (MOVSDconst <fe.TypeFloat64()> [f2i(math.Copysign(0, -1))])) // result: (PXOR x (MOVSDconst <types.Float64> [f2i(math.Copysign(0, -1))]))
for { for {
x := v.Args[0] x := v.Args[0]
if !(!config.use387) { if !(!config.use387) {
@ -11643,7 +11643,7 @@ func rewriteValue386_OpNeg64F(v *Value) bool {
} }
v.reset(Op386PXOR) v.reset(Op386PXOR)
v.AddArg(x) v.AddArg(x)
v0 := b.NewValue0(v.Pos, Op386MOVSDconst, fe.TypeFloat64()) v0 := b.NewValue0(v.Pos, Op386MOVSDconst, types.Float64)
v0.AuxInt = f2i(math.Copysign(0, -1)) v0.AuxInt = f2i(math.Copysign(0, -1))
v.AddArg(v0) v.AddArg(v0)
return true return true
@ -12955,8 +12955,8 @@ func rewriteValue386_OpZero(v *Value) bool {
_ = b _ = b
config := b.Func.Config config := b.Func.Config
_ = config _ = config
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Zero [0] _ mem) // match: (Zero [0] _ mem)
// cond: // cond:
// result: mem // result: mem
@ -13103,7 +13103,7 @@ func rewriteValue386_OpZero(v *Value) bool {
} }
v.reset(OpZero) v.reset(OpZero)
v.AuxInt = s - s%4 v.AuxInt = s - s%4
v0 := b.NewValue0(v.Pos, Op386ADDLconst, fe.TypeUInt32()) v0 := b.NewValue0(v.Pos, Op386ADDLconst, types.UInt32)
v0.AuxInt = s % 4 v0.AuxInt = s % 4
v0.AddArg(destptr) v0.AddArg(destptr)
v.AddArg(v0) v.AddArg(v0)
@ -13196,7 +13196,7 @@ func rewriteValue386_OpZero(v *Value) bool {
v.reset(Op386DUFFZERO) v.reset(Op386DUFFZERO)
v.AuxInt = 1 * (128 - s/4) v.AuxInt = 1 * (128 - s/4)
v.AddArg(destptr) v.AddArg(destptr)
v0 := b.NewValue0(v.Pos, Op386MOVLconst, fe.TypeUInt32()) v0 := b.NewValue0(v.Pos, Op386MOVLconst, types.UInt32)
v0.AuxInt = 0 v0.AuxInt = 0
v.AddArg(v0) v.AddArg(v0)
v.AddArg(mem) v.AddArg(mem)
@ -13214,10 +13214,10 @@ func rewriteValue386_OpZero(v *Value) bool {
} }
v.reset(Op386REPSTOSL) v.reset(Op386REPSTOSL)
v.AddArg(destptr) v.AddArg(destptr)
v0 := b.NewValue0(v.Pos, Op386MOVLconst, fe.TypeUInt32()) v0 := b.NewValue0(v.Pos, Op386MOVLconst, types.UInt32)
v0.AuxInt = s / 4 v0.AuxInt = s / 4
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, Op386MOVLconst, fe.TypeUInt32()) v1 := b.NewValue0(v.Pos, Op386MOVLconst, types.UInt32)
v1.AuxInt = 0 v1.AuxInt = 0
v.AddArg(v1) v.AddArg(v1)
v.AddArg(mem) v.AddArg(mem)
@ -13283,6 +13283,8 @@ func rewriteBlock386(b *Block) bool {
_ = config _ = config
fe := b.Func.fe fe := b.Func.fe
_ = fe _ = fe
types := &config.Types
_ = types
switch b.Kind { switch b.Kind {
case Block386EQ: case Block386EQ:
// match: (EQ (InvertFlags cmp) yes no) // match: (EQ (InvertFlags cmp) yes no)

296
src/cmd/compile/internal/ssa/rewriteAMD64.go
View file

@ -6786,8 +6786,8 @@ func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value) bool { func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (MOVLstoreconst [sc] {s} (ADDQconst [off] ptr) mem) // match: (MOVLstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off) // cond: ValAndOff(sc).canAdd(off)
// result: (MOVLstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) // result: (MOVLstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
@ -6934,7 +6934,7 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value) bool {
v.AuxInt = ValAndOff(a).Off() v.AuxInt = ValAndOff(a).Off()
v.Aux = s v.Aux = s
v.AddArg(p) v.AddArg(p)
v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v0.AuxInt = ValAndOff(a).Val()&0xffffffff | ValAndOff(c).Val()<<32 v0.AuxInt = ValAndOff(a).Val()&0xffffffff | ValAndOff(c).Val()<<32
v.AddArg(v0) v.AddArg(v0)
v.AddArg(mem) v.AddArg(mem)
@ -6992,8 +6992,8 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value) bool {
func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v *Value) bool { func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (MOVLstoreconstidx1 [c] {sym} ptr (SHLQconst [2] idx) mem) // match: (MOVLstoreconstidx1 [c] {sym} ptr (SHLQconst [2] idx) mem)
// cond: // cond:
// result: (MOVLstoreconstidx4 [c] {sym} ptr idx mem) // result: (MOVLstoreconstidx4 [c] {sym} ptr idx mem)
@ -7093,7 +7093,7 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v *Value) bool {
v.Aux = s v.Aux = s
v.AddArg(p) v.AddArg(p)
v.AddArg(i) v.AddArg(i)
v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v0.AuxInt = ValAndOff(a).Val()&0xffffffff | ValAndOff(c).Val()<<32 v0.AuxInt = ValAndOff(a).Val()&0xffffffff | ValAndOff(c).Val()<<32
v.AddArg(v0) v.AddArg(v0)
v.AddArg(mem) v.AddArg(mem)
@ -7104,8 +7104,8 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v *Value) bool {
func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v *Value) bool { func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (MOVLstoreconstidx4 [x] {sym} (ADDQconst [c] ptr) idx mem) // match: (MOVLstoreconstidx4 [x] {sym} (ADDQconst [c] ptr) idx mem)
// cond: // cond:
// result: (MOVLstoreconstidx4 [ValAndOff(x).add(c)] {sym} ptr idx mem) // result: (MOVLstoreconstidx4 [ValAndOff(x).add(c)] {sym} ptr idx mem)
@ -7184,7 +7184,7 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v *Value) bool {
v0.AuxInt = 2 v0.AuxInt = 2
v0.AddArg(i) v0.AddArg(i)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v1 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v1.AuxInt = ValAndOff(a).Val()&0xffffffff | ValAndOff(c).Val()<<32 v1.AuxInt = ValAndOff(a).Val()&0xffffffff | ValAndOff(c).Val()<<32
v.AddArg(v1) v.AddArg(v1)
v.AddArg(mem) v.AddArg(mem)
@ -12037,8 +12037,8 @@ func rewriteValueAMD64_OpAMD64NOTQ(v *Value) bool {
func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { func rewriteValueAMD64_OpAMD64ORL(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (ORL x (MOVLconst [c])) // match: (ORL x (MOVLconst [c]))
// cond: // cond:
// result: (ORLconst [c] x) // result: (ORLconst [c] x)
@ -12304,7 +12304,7 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool {
break break
} }
b = mergePoint(b, x0, x1) b = mergePoint(b, x0, x1)
v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, fe.TypeUInt16()) v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, types.UInt16)
v.reset(OpCopy) v.reset(OpCopy)
v.AddArg(v0) v.AddArg(v0)
v0.AuxInt = i v0.AuxInt = i
@ -12379,7 +12379,7 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool {
break break
} }
b = mergePoint(b, x0, x1, x2) b = mergePoint(b, x0, x1, x2)
v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32()) v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, types.UInt32)
v.reset(OpCopy) v.reset(OpCopy)
v.AddArg(v0) v.AddArg(v0)
v0.AuxInt = i v0.AuxInt = i
@ -12567,7 +12567,7 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool {
v.reset(OpCopy) v.reset(OpCopy)
v.AddArg(v0) v.AddArg(v0)
v0.AuxInt = 8 v0.AuxInt = 8
v1 := b.NewValue0(v.Pos, OpAMD64MOVWload, fe.TypeUInt16()) v1 := b.NewValue0(v.Pos, OpAMD64MOVWload, types.UInt16)
v1.AuxInt = i - 1 v1.AuxInt = i - 1
v1.Aux = s v1.Aux = s
v1.AddArg(p) v1.AddArg(p)
@ -12707,7 +12707,7 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool {
v0 := b.NewValue0(v.Pos, OpAMD64BSWAPL, v.Type) v0 := b.NewValue0(v.Pos, OpAMD64BSWAPL, v.Type)
v.reset(OpCopy) v.reset(OpCopy)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32()) v1 := b.NewValue0(v.Pos, OpAMD64MOVLload, types.UInt32)
v1.AuxInt = i1 - 2 v1.AuxInt = i1 - 2
v1.Aux = s v1.Aux = s
v1.AddArg(p) v1.AddArg(p)
@ -12903,8 +12903,8 @@ func rewriteValueAMD64_OpAMD64ORLconst(v *Value) bool {
func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (ORQ x (MOVQconst [c])) // match: (ORQ x (MOVQconst [c]))
// cond: is32Bit(c) // cond: is32Bit(c)
// result: (ORQconst [c] x) // result: (ORQconst [c] x)
@ -13222,7 +13222,7 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool {
break break
} }
b = mergePoint(b, x0, x1, x2, x3, x4, x5, x6, x7) b = mergePoint(b, x0, x1, x2, x3, x4, x5, x6, x7)
v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64()) v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, types.UInt64)
v.reset(OpCopy) v.reset(OpCopy)
v.AddArg(v0) v.AddArg(v0)
v0.AuxInt = i v0.AuxInt = i
@ -13668,7 +13668,7 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool {
v0 := b.NewValue0(v.Pos, OpAMD64BSWAPQ, v.Type) v0 := b.NewValue0(v.Pos, OpAMD64BSWAPQ, v.Type)
v.reset(OpCopy) v.reset(OpCopy)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64()) v1 := b.NewValue0(v.Pos, OpAMD64MOVQload, types.UInt64)
v1.AuxInt = i - 7 v1.AuxInt = i - 7
v1.Aux = s v1.Aux = s
v1.AddArg(p) v1.AddArg(p)
@ -17355,8 +17355,8 @@ func rewriteValueAMD64_OpAndB(v *Value) bool {
func rewriteValueAMD64_OpAtomicAdd32(v *Value) bool { func rewriteValueAMD64_OpAtomicAdd32(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (AtomicAdd32 ptr val mem) // match: (AtomicAdd32 ptr val mem)
// cond: // cond:
// result: (AddTupleFirst32 (XADDLlock val ptr mem) val) // result: (AddTupleFirst32 (XADDLlock val ptr mem) val)
@ -17365,7 +17365,7 @@ func rewriteValueAMD64_OpAtomicAdd32(v *Value) bool {
val := v.Args[1] val := v.Args[1]
mem := v.Args[2] mem := v.Args[2]
v.reset(OpAMD64AddTupleFirst32) v.reset(OpAMD64AddTupleFirst32)
v0 := b.NewValue0(v.Pos, OpAMD64XADDLlock, MakeTuple(fe.TypeUInt32(), TypeMem)) v0 := b.NewValue0(v.Pos, OpAMD64XADDLlock, MakeTuple(types.UInt32, TypeMem))
v0.AddArg(val) v0.AddArg(val)
v0.AddArg(ptr) v0.AddArg(ptr)
v0.AddArg(mem) v0.AddArg(mem)
@ -17377,8 +17377,8 @@ func rewriteValueAMD64_OpAtomicAdd32(v *Value) bool {
func rewriteValueAMD64_OpAtomicAdd64(v *Value) bool { func rewriteValueAMD64_OpAtomicAdd64(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (AtomicAdd64 ptr val mem) // match: (AtomicAdd64 ptr val mem)
// cond: // cond:
// result: (AddTupleFirst64 (XADDQlock val ptr mem) val) // result: (AddTupleFirst64 (XADDQlock val ptr mem) val)
@ -17387,7 +17387,7 @@ func rewriteValueAMD64_OpAtomicAdd64(v *Value) bool {
val := v.Args[1] val := v.Args[1]
mem := v.Args[2] mem := v.Args[2]
v.reset(OpAMD64AddTupleFirst64) v.reset(OpAMD64AddTupleFirst64)
v0 := b.NewValue0(v.Pos, OpAMD64XADDQlock, MakeTuple(fe.TypeUInt64(), TypeMem)) v0 := b.NewValue0(v.Pos, OpAMD64XADDQlock, MakeTuple(types.UInt64, TypeMem))
v0.AddArg(val) v0.AddArg(val)
v0.AddArg(ptr) v0.AddArg(ptr)
v0.AddArg(mem) v0.AddArg(mem)
@ -17554,17 +17554,17 @@ func rewriteValueAMD64_OpAtomicOr8(v *Value) bool {
func rewriteValueAMD64_OpAtomicStore32(v *Value) bool { func rewriteValueAMD64_OpAtomicStore32(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (AtomicStore32 ptr val mem) // match: (AtomicStore32 ptr val mem)
// cond: // cond:
// result: (Select1 (XCHGL <MakeTuple(fe.TypeUInt32(),TypeMem)> val ptr mem)) // result: (Select1 (XCHGL <MakeTuple(types.UInt32,TypeMem)> val ptr mem))
for { for {
ptr := v.Args[0] ptr := v.Args[0]
val := v.Args[1] val := v.Args[1]
mem := v.Args[2] mem := v.Args[2]
v.reset(OpSelect1) v.reset(OpSelect1)
v0 := b.NewValue0(v.Pos, OpAMD64XCHGL, MakeTuple(fe.TypeUInt32(), TypeMem)) v0 := b.NewValue0(v.Pos, OpAMD64XCHGL, MakeTuple(types.UInt32, TypeMem))
v0.AddArg(val) v0.AddArg(val)
v0.AddArg(ptr) v0.AddArg(ptr)
v0.AddArg(mem) v0.AddArg(mem)
@ -17575,17 +17575,17 @@ func rewriteValueAMD64_OpAtomicStore32(v *Value) bool {
func rewriteValueAMD64_OpAtomicStore64(v *Value) bool { func rewriteValueAMD64_OpAtomicStore64(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (AtomicStore64 ptr val mem) // match: (AtomicStore64 ptr val mem)
// cond: // cond:
// result: (Select1 (XCHGQ <MakeTuple(fe.TypeUInt64(),TypeMem)> val ptr mem)) // result: (Select1 (XCHGQ <MakeTuple(types.UInt64,TypeMem)> val ptr mem))
for { for {
ptr := v.Args[0] ptr := v.Args[0]
val := v.Args[1] val := v.Args[1]
mem := v.Args[2] mem := v.Args[2]
v.reset(OpSelect1) v.reset(OpSelect1)
v0 := b.NewValue0(v.Pos, OpAMD64XCHGQ, MakeTuple(fe.TypeUInt64(), TypeMem)) v0 := b.NewValue0(v.Pos, OpAMD64XCHGQ, MakeTuple(types.UInt64, TypeMem))
v0.AddArg(val) v0.AddArg(val)
v0.AddArg(ptr) v0.AddArg(ptr)
v0.AddArg(mem) v0.AddArg(mem)
@ -17598,11 +17598,11 @@ func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value) bool {
_ = b _ = b
config := b.Func.Config config := b.Func.Config
_ = config _ = config
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (AtomicStorePtrNoWB ptr val mem) // match: (AtomicStorePtrNoWB ptr val mem)
// cond: config.PtrSize == 8 // cond: config.PtrSize == 8
// result: (Select1 (XCHGQ <MakeTuple(fe.TypeBytePtr(),TypeMem)> val ptr mem)) // result: (Select1 (XCHGQ <MakeTuple(types.BytePtr,TypeMem)> val ptr mem))
for { for {
ptr := v.Args[0] ptr := v.Args[0]
val := v.Args[1] val := v.Args[1]
@ -17611,7 +17611,7 @@ func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value) bool {
break break
} }
v.reset(OpSelect1) v.reset(OpSelect1)
v0 := b.NewValue0(v.Pos, OpAMD64XCHGQ, MakeTuple(fe.TypeBytePtr(), TypeMem)) v0 := b.NewValue0(v.Pos, OpAMD64XCHGQ, MakeTuple(types.BytePtr, TypeMem))
v0.AddArg(val) v0.AddArg(val)
v0.AddArg(ptr) v0.AddArg(ptr)
v0.AddArg(mem) v0.AddArg(mem)
@ -17620,7 +17620,7 @@ func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value) bool {
} }
// match: (AtomicStorePtrNoWB ptr val mem) // match: (AtomicStorePtrNoWB ptr val mem)
// cond: config.PtrSize == 4 // cond: config.PtrSize == 4
// result: (Select1 (XCHGL <MakeTuple(fe.TypeBytePtr(),TypeMem)> val ptr mem)) // result: (Select1 (XCHGL <MakeTuple(types.BytePtr,TypeMem)> val ptr mem))
for { for {
ptr := v.Args[0] ptr := v.Args[0]
val := v.Args[1] val := v.Args[1]
@ -17629,7 +17629,7 @@ func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value) bool {
break break
} }
v.reset(OpSelect1) v.reset(OpSelect1)
v0 := b.NewValue0(v.Pos, OpAMD64XCHGL, MakeTuple(fe.TypeBytePtr(), TypeMem)) v0 := b.NewValue0(v.Pos, OpAMD64XCHGL, MakeTuple(types.BytePtr, TypeMem))
v0.AddArg(val) v0.AddArg(val)
v0.AddArg(ptr) v0.AddArg(ptr)
v0.AddArg(mem) v0.AddArg(mem)
@ -17654,15 +17654,15 @@ func rewriteValueAMD64_OpAvg64u(v *Value) bool {
func rewriteValueAMD64_OpBitLen32(v *Value) bool { func rewriteValueAMD64_OpBitLen32(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (BitLen32 x) // match: (BitLen32 x)
// cond: // cond:
// result: (BitLen64 (MOVLQZX <fe.TypeUInt64()> x)) // result: (BitLen64 (MOVLQZX <types.UInt64> x))
for { for {
x := v.Args[0] x := v.Args[0]
v.reset(OpBitLen64) v.reset(OpBitLen64)
v0 := b.NewValue0(v.Pos, OpAMD64MOVLQZX, fe.TypeUInt64()) v0 := b.NewValue0(v.Pos, OpAMD64MOVLQZX, types.UInt64)
v0.AddArg(x) v0.AddArg(x)
v.AddArg(v0) v.AddArg(v0)
return true return true
@ -17671,8 +17671,8 @@ func rewriteValueAMD64_OpBitLen32(v *Value) bool {
func rewriteValueAMD64_OpBitLen64(v *Value) bool { func rewriteValueAMD64_OpBitLen64(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (BitLen64 <t> x) // match: (BitLen64 <t> x)
// cond: // cond:
// result: (ADDQconst [1] (CMOVQEQ <t> (Select0 <t> (BSRQ x)) (MOVQconst <t> [-1]) (Select1 <TypeFlags> (BSRQ x)))) // result: (ADDQconst [1] (CMOVQEQ <t> (Select0 <t> (BSRQ x)) (MOVQconst <t> [-1]) (Select1 <TypeFlags> (BSRQ x))))
@ -17683,7 +17683,7 @@ func rewriteValueAMD64_OpBitLen64(v *Value) bool {
v.AuxInt = 1 v.AuxInt = 1
v0 := b.NewValue0(v.Pos, OpAMD64CMOVQEQ, t) v0 := b.NewValue0(v.Pos, OpAMD64CMOVQEQ, t)
v1 := b.NewValue0(v.Pos, OpSelect0, t) v1 := b.NewValue0(v.Pos, OpSelect0, t)
v2 := b.NewValue0(v.Pos, OpAMD64BSRQ, MakeTuple(fe.TypeUInt64(), TypeFlags)) v2 := b.NewValue0(v.Pos, OpAMD64BSRQ, MakeTuple(types.UInt64, TypeFlags))
v2.AddArg(x) v2.AddArg(x)
v1.AddArg(v2) v1.AddArg(v2)
v0.AddArg(v1) v0.AddArg(v1)
@ -17691,7 +17691,7 @@ func rewriteValueAMD64_OpBitLen64(v *Value) bool {
v3.AuxInt = -1 v3.AuxInt = -1
v0.AddArg(v3) v0.AddArg(v3)
v4 := b.NewValue0(v.Pos, OpSelect1, TypeFlags) v4 := b.NewValue0(v.Pos, OpSelect1, TypeFlags)
v5 := b.NewValue0(v.Pos, OpAMD64BSRQ, MakeTuple(fe.TypeUInt64(), TypeFlags)) v5 := b.NewValue0(v.Pos, OpAMD64BSRQ, MakeTuple(types.UInt64, TypeFlags))
v5.AddArg(x) v5.AddArg(x)
v4.AddArg(v5) v4.AddArg(v5)
v0.AddArg(v4) v0.AddArg(v4)
@ -17930,17 +17930,17 @@ func rewriteValueAMD64_OpConvert(v *Value) bool {
func rewriteValueAMD64_OpCtz32(v *Value) bool { func rewriteValueAMD64_OpCtz32(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Ctz32 x) // match: (Ctz32 x)
// cond: // cond:
// result: (Select0 (BSFQ (ORQ <fe.TypeUInt64()> (MOVQconst [1<<32]) x))) // result: (Select0 (BSFQ (ORQ <types.UInt64> (MOVQconst [1<<32]) x)))
for { for {
x := v.Args[0] x := v.Args[0]
v.reset(OpSelect0) v.reset(OpSelect0)
v0 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(fe.TypeUInt64(), TypeFlags)) v0 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(types.UInt64, TypeFlags))
v1 := b.NewValue0(v.Pos, OpAMD64ORQ, fe.TypeUInt64()) v1 := b.NewValue0(v.Pos, OpAMD64ORQ, types.UInt64)
v2 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v2 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v2.AuxInt = 1 << 32 v2.AuxInt = 1 << 32
v1.AddArg(v2) v1.AddArg(v2)
v1.AddArg(x) v1.AddArg(x)
@ -17952,8 +17952,8 @@ func rewriteValueAMD64_OpCtz32(v *Value) bool {
func rewriteValueAMD64_OpCtz64(v *Value) bool { func rewriteValueAMD64_OpCtz64(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Ctz64 <t> x) // match: (Ctz64 <t> x)
// cond: // cond:
// result: (CMOVQEQ (Select0 <t> (BSFQ x)) (MOVQconst <t> [64]) (Select1 <TypeFlags> (BSFQ x))) // result: (CMOVQEQ (Select0 <t> (BSFQ x)) (MOVQconst <t> [64]) (Select1 <TypeFlags> (BSFQ x)))
@ -17962,7 +17962,7 @@ func rewriteValueAMD64_OpCtz64(v *Value) bool {
x := v.Args[0] x := v.Args[0]
v.reset(OpAMD64CMOVQEQ) v.reset(OpAMD64CMOVQEQ)
v0 := b.NewValue0(v.Pos, OpSelect0, t) v0 := b.NewValue0(v.Pos, OpSelect0, t)
v1 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(fe.TypeUInt64(), TypeFlags)) v1 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(types.UInt64, TypeFlags))
v1.AddArg(x) v1.AddArg(x)
v0.AddArg(v1) v0.AddArg(v1)
v.AddArg(v0) v.AddArg(v0)
@ -17970,7 +17970,7 @@ func rewriteValueAMD64_OpCtz64(v *Value) bool {
v2.AuxInt = 64 v2.AuxInt = 64
v.AddArg(v2) v.AddArg(v2)
v3 := b.NewValue0(v.Pos, OpSelect1, TypeFlags) v3 := b.NewValue0(v.Pos, OpSelect1, TypeFlags)
v4 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(fe.TypeUInt64(), TypeFlags)) v4 := b.NewValue0(v.Pos, OpAMD64BSFQ, MakeTuple(types.UInt64, TypeFlags))
v4.AddArg(x) v4.AddArg(x)
v3.AddArg(v4) v3.AddArg(v4)
v.AddArg(v3) v.AddArg(v3)
@ -18105,8 +18105,8 @@ func rewriteValueAMD64_OpDiv128u(v *Value) bool {
func rewriteValueAMD64_OpDiv16(v *Value) bool { func rewriteValueAMD64_OpDiv16(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Div16 x y) // match: (Div16 x y)
// cond: // cond:
// result: (Select0 (DIVW x y)) // result: (Select0 (DIVW x y))
@ -18114,7 +18114,7 @@ func rewriteValueAMD64_OpDiv16(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(OpSelect0) v.reset(OpSelect0)
v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(fe.TypeInt16(), fe.TypeInt16())) v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(types.Int16, types.Int16))
v0.AddArg(x) v0.AddArg(x)
v0.AddArg(y) v0.AddArg(y)
v.AddArg(v0) v.AddArg(v0)
@ -18124,8 +18124,8 @@ func rewriteValueAMD64_OpDiv16(v *Value) bool {
func rewriteValueAMD64_OpDiv16u(v *Value) bool { func rewriteValueAMD64_OpDiv16u(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Div16u x y) // match: (Div16u x y)
// cond: // cond:
// result: (Select0 (DIVWU x y)) // result: (Select0 (DIVWU x y))
@ -18133,7 +18133,7 @@ func rewriteValueAMD64_OpDiv16u(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(OpSelect0) v.reset(OpSelect0)
v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(fe.TypeUInt16(), fe.TypeUInt16())) v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(types.UInt16, types.UInt16))
v0.AddArg(x) v0.AddArg(x)
v0.AddArg(y) v0.AddArg(y)
v.AddArg(v0) v.AddArg(v0)
@ -18143,8 +18143,8 @@ func rewriteValueAMD64_OpDiv16u(v *Value) bool {
func rewriteValueAMD64_OpDiv32(v *Value) bool { func rewriteValueAMD64_OpDiv32(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Div32 x y) // match: (Div32 x y)
// cond: // cond:
// result: (Select0 (DIVL x y)) // result: (Select0 (DIVL x y))
@ -18152,7 +18152,7 @@ func rewriteValueAMD64_OpDiv32(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(OpSelect0) v.reset(OpSelect0)
v0 := b.NewValue0(v.Pos, OpAMD64DIVL, MakeTuple(fe.TypeInt32(), fe.TypeInt32())) v0 := b.NewValue0(v.Pos, OpAMD64DIVL, MakeTuple(types.Int32, types.Int32))
v0.AddArg(x) v0.AddArg(x)
v0.AddArg(y) v0.AddArg(y)
v.AddArg(v0) v.AddArg(v0)
@ -18175,8 +18175,8 @@ func rewriteValueAMD64_OpDiv32F(v *Value) bool {
func rewriteValueAMD64_OpDiv32u(v *Value) bool { func rewriteValueAMD64_OpDiv32u(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Div32u x y) // match: (Div32u x y)
// cond: // cond:
// result: (Select0 (DIVLU x y)) // result: (Select0 (DIVLU x y))
@ -18184,7 +18184,7 @@ func rewriteValueAMD64_OpDiv32u(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(OpSelect0) v.reset(OpSelect0)
v0 := b.NewValue0(v.Pos, OpAMD64DIVLU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) v0 := b.NewValue0(v.Pos, OpAMD64DIVLU, MakeTuple(types.UInt32, types.UInt32))
v0.AddArg(x) v0.AddArg(x)
v0.AddArg(y) v0.AddArg(y)
v.AddArg(v0) v.AddArg(v0)
@ -18194,8 +18194,8 @@ func rewriteValueAMD64_OpDiv32u(v *Value) bool {
func rewriteValueAMD64_OpDiv64(v *Value) bool { func rewriteValueAMD64_OpDiv64(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Div64 x y) // match: (Div64 x y)
// cond: // cond:
// result: (Select0 (DIVQ x y)) // result: (Select0 (DIVQ x y))
@ -18203,7 +18203,7 @@ func rewriteValueAMD64_OpDiv64(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(OpSelect0) v.reset(OpSelect0)
v0 := b.NewValue0(v.Pos, OpAMD64DIVQ, MakeTuple(fe.TypeInt64(), fe.TypeInt64())) v0 := b.NewValue0(v.Pos, OpAMD64DIVQ, MakeTuple(types.Int64, types.Int64))
v0.AddArg(x) v0.AddArg(x)
v0.AddArg(y) v0.AddArg(y)
v.AddArg(v0) v.AddArg(v0)
@ -18226,8 +18226,8 @@ func rewriteValueAMD64_OpDiv64F(v *Value) bool {
func rewriteValueAMD64_OpDiv64u(v *Value) bool { func rewriteValueAMD64_OpDiv64u(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Div64u x y) // match: (Div64u x y)
// cond: // cond:
// result: (Select0 (DIVQU x y)) // result: (Select0 (DIVQU x y))
@ -18235,7 +18235,7 @@ func rewriteValueAMD64_OpDiv64u(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(OpSelect0) v.reset(OpSelect0)
v0 := b.NewValue0(v.Pos, OpAMD64DIVQU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) v0 := b.NewValue0(v.Pos, OpAMD64DIVQU, MakeTuple(types.UInt64, types.UInt64))
v0.AddArg(x) v0.AddArg(x)
v0.AddArg(y) v0.AddArg(y)
v.AddArg(v0) v.AddArg(v0)
@ -18245,8 +18245,8 @@ func rewriteValueAMD64_OpDiv64u(v *Value) bool {
func rewriteValueAMD64_OpDiv8(v *Value) bool { func rewriteValueAMD64_OpDiv8(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Div8 x y) // match: (Div8 x y)
// cond: // cond:
// result: (Select0 (DIVW (SignExt8to16 x) (SignExt8to16 y))) // result: (Select0 (DIVW (SignExt8to16 x) (SignExt8to16 y)))
@ -18254,11 +18254,11 @@ func rewriteValueAMD64_OpDiv8(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(OpSelect0) v.reset(OpSelect0)
v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(fe.TypeInt16(), fe.TypeInt16())) v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(types.Int16, types.Int16))
v1 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16()) v1 := b.NewValue0(v.Pos, OpSignExt8to16, types.Int16)
v1.AddArg(x) v1.AddArg(x)
v0.AddArg(v1) v0.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16()) v2 := b.NewValue0(v.Pos, OpSignExt8to16, types.Int16)
v2.AddArg(y) v2.AddArg(y)
v0.AddArg(v2) v0.AddArg(v2)
v.AddArg(v0) v.AddArg(v0)
@ -18268,8 +18268,8 @@ func rewriteValueAMD64_OpDiv8(v *Value) bool {
func rewriteValueAMD64_OpDiv8u(v *Value) bool { func rewriteValueAMD64_OpDiv8u(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Div8u x y) // match: (Div8u x y)
// cond: // cond:
// result: (Select0 (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y))) // result: (Select0 (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)))
@ -18277,11 +18277,11 @@ func rewriteValueAMD64_OpDiv8u(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(OpSelect0) v.reset(OpSelect0)
v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(fe.TypeUInt16(), fe.TypeUInt16())) v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(types.UInt16, types.UInt16))
v1 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16()) v1 := b.NewValue0(v.Pos, OpZeroExt8to16, types.UInt16)
v1.AddArg(x) v1.AddArg(x)
v0.AddArg(v1) v0.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16()) v2 := b.NewValue0(v.Pos, OpZeroExt8to16, types.UInt16)
v2.AddArg(y) v2.AddArg(y)
v0.AddArg(v2) v0.AddArg(v2)
v.AddArg(v0) v.AddArg(v0)
@ -19780,8 +19780,8 @@ func rewriteValueAMD64_OpLsh8x8(v *Value) bool {
func rewriteValueAMD64_OpMod16(v *Value) bool { func rewriteValueAMD64_OpMod16(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Mod16 x y) // match: (Mod16 x y)
// cond: // cond:
// result: (Select1 (DIVW x y)) // result: (Select1 (DIVW x y))
@ -19789,7 +19789,7 @@ func rewriteValueAMD64_OpMod16(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(OpSelect1) v.reset(OpSelect1)
v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(fe.TypeInt16(), fe.TypeInt16())) v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(types.Int16, types.Int16))
v0.AddArg(x) v0.AddArg(x)
v0.AddArg(y) v0.AddArg(y)
v.AddArg(v0) v.AddArg(v0)
@ -19799,8 +19799,8 @@ func rewriteValueAMD64_OpMod16(v *Value) bool {
func rewriteValueAMD64_OpMod16u(v *Value) bool { func rewriteValueAMD64_OpMod16u(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Mod16u x y) // match: (Mod16u x y)
// cond: // cond:
// result: (Select1 (DIVWU x y)) // result: (Select1 (DIVWU x y))
@ -19808,7 +19808,7 @@ func rewriteValueAMD64_OpMod16u(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(OpSelect1) v.reset(OpSelect1)
v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(fe.TypeUInt16(), fe.TypeUInt16())) v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(types.UInt16, types.UInt16))
v0.AddArg(x) v0.AddArg(x)
v0.AddArg(y) v0.AddArg(y)
v.AddArg(v0) v.AddArg(v0)
@ -19818,8 +19818,8 @@ func rewriteValueAMD64_OpMod16u(v *Value) bool {
func rewriteValueAMD64_OpMod32(v *Value) bool { func rewriteValueAMD64_OpMod32(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Mod32 x y) // match: (Mod32 x y)
// cond: // cond:
// result: (Select1 (DIVL x y)) // result: (Select1 (DIVL x y))
@ -19827,7 +19827,7 @@ func rewriteValueAMD64_OpMod32(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(OpSelect1) v.reset(OpSelect1)
v0 := b.NewValue0(v.Pos, OpAMD64DIVL, MakeTuple(fe.TypeInt32(), fe.TypeInt32())) v0 := b.NewValue0(v.Pos, OpAMD64DIVL, MakeTuple(types.Int32, types.Int32))
v0.AddArg(x) v0.AddArg(x)
v0.AddArg(y) v0.AddArg(y)
v.AddArg(v0) v.AddArg(v0)
@ -19837,8 +19837,8 @@ func rewriteValueAMD64_OpMod32(v *Value) bool {
func rewriteValueAMD64_OpMod32u(v *Value) bool { func rewriteValueAMD64_OpMod32u(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Mod32u x y) // match: (Mod32u x y)
// cond: // cond:
// result: (Select1 (DIVLU x y)) // result: (Select1 (DIVLU x y))
@ -19846,7 +19846,7 @@ func rewriteValueAMD64_OpMod32u(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(OpSelect1) v.reset(OpSelect1)
v0 := b.NewValue0(v.Pos, OpAMD64DIVLU, MakeTuple(fe.TypeUInt32(), fe.TypeUInt32())) v0 := b.NewValue0(v.Pos, OpAMD64DIVLU, MakeTuple(types.UInt32, types.UInt32))
v0.AddArg(x) v0.AddArg(x)
v0.AddArg(y) v0.AddArg(y)
v.AddArg(v0) v.AddArg(v0)
@ -19856,8 +19856,8 @@ func rewriteValueAMD64_OpMod32u(v *Value) bool {
func rewriteValueAMD64_OpMod64(v *Value) bool { func rewriteValueAMD64_OpMod64(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Mod64 x y) // match: (Mod64 x y)
// cond: // cond:
// result: (Select1 (DIVQ x y)) // result: (Select1 (DIVQ x y))
@ -19865,7 +19865,7 @@ func rewriteValueAMD64_OpMod64(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(OpSelect1) v.reset(OpSelect1)
v0 := b.NewValue0(v.Pos, OpAMD64DIVQ, MakeTuple(fe.TypeInt64(), fe.TypeInt64())) v0 := b.NewValue0(v.Pos, OpAMD64DIVQ, MakeTuple(types.Int64, types.Int64))
v0.AddArg(x) v0.AddArg(x)
v0.AddArg(y) v0.AddArg(y)
v.AddArg(v0) v.AddArg(v0)
@ -19875,8 +19875,8 @@ func rewriteValueAMD64_OpMod64(v *Value) bool {
func rewriteValueAMD64_OpMod64u(v *Value) bool { func rewriteValueAMD64_OpMod64u(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Mod64u x y) // match: (Mod64u x y)
// cond: // cond:
// result: (Select1 (DIVQU x y)) // result: (Select1 (DIVQU x y))
@ -19884,7 +19884,7 @@ func rewriteValueAMD64_OpMod64u(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(OpSelect1) v.reset(OpSelect1)
v0 := b.NewValue0(v.Pos, OpAMD64DIVQU, MakeTuple(fe.TypeUInt64(), fe.TypeUInt64())) v0 := b.NewValue0(v.Pos, OpAMD64DIVQU, MakeTuple(types.UInt64, types.UInt64))
v0.AddArg(x) v0.AddArg(x)
v0.AddArg(y) v0.AddArg(y)
v.AddArg(v0) v.AddArg(v0)
@ -19894,8 +19894,8 @@ func rewriteValueAMD64_OpMod64u(v *Value) bool {
func rewriteValueAMD64_OpMod8(v *Value) bool { func rewriteValueAMD64_OpMod8(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Mod8 x y) // match: (Mod8 x y)
// cond: // cond:
// result: (Select1 (DIVW (SignExt8to16 x) (SignExt8to16 y))) // result: (Select1 (DIVW (SignExt8to16 x) (SignExt8to16 y)))
@ -19903,11 +19903,11 @@ func rewriteValueAMD64_OpMod8(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(OpSelect1) v.reset(OpSelect1)
v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(fe.TypeInt16(), fe.TypeInt16())) v0 := b.NewValue0(v.Pos, OpAMD64DIVW, MakeTuple(types.Int16, types.Int16))
v1 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16()) v1 := b.NewValue0(v.Pos, OpSignExt8to16, types.Int16)
v1.AddArg(x) v1.AddArg(x)
v0.AddArg(v1) v0.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpSignExt8to16, fe.TypeInt16()) v2 := b.NewValue0(v.Pos, OpSignExt8to16, types.Int16)
v2.AddArg(y) v2.AddArg(y)
v0.AddArg(v2) v0.AddArg(v2)
v.AddArg(v0) v.AddArg(v0)
@ -19917,8 +19917,8 @@ func rewriteValueAMD64_OpMod8(v *Value) bool {
func rewriteValueAMD64_OpMod8u(v *Value) bool { func rewriteValueAMD64_OpMod8u(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Mod8u x y) // match: (Mod8u x y)
// cond: // cond:
// result: (Select1 (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y))) // result: (Select1 (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)))
@ -19926,11 +19926,11 @@ func rewriteValueAMD64_OpMod8u(v *Value) bool {
x := v.Args[0] x := v.Args[0]
y := v.Args[1] y := v.Args[1]
v.reset(OpSelect1) v.reset(OpSelect1)
v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(fe.TypeUInt16(), fe.TypeUInt16())) v0 := b.NewValue0(v.Pos, OpAMD64DIVWU, MakeTuple(types.UInt16, types.UInt16))
v1 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16()) v1 := b.NewValue0(v.Pos, OpZeroExt8to16, types.UInt16)
v1.AddArg(x) v1.AddArg(x)
v0.AddArg(v1) v0.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpZeroExt8to16, fe.TypeUInt16()) v2 := b.NewValue0(v.Pos, OpZeroExt8to16, types.UInt16)
v2.AddArg(y) v2.AddArg(y)
v0.AddArg(v2) v0.AddArg(v2)
v.AddArg(v0) v.AddArg(v0)
@ -19942,8 +19942,8 @@ func rewriteValueAMD64_OpMove(v *Value) bool {
_ = b _ = b
config := b.Func.Config config := b.Func.Config
_ = config _ = config
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Move [0] _ _ mem) // match: (Move [0] _ _ mem)
// cond: // cond:
// result: mem // result: mem
@ -19969,7 +19969,7 @@ func rewriteValueAMD64_OpMove(v *Value) bool {
mem := v.Args[2] mem := v.Args[2]
v.reset(OpAMD64MOVBstore) v.reset(OpAMD64MOVBstore)
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, fe.TypeUInt8()) v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, types.UInt8)
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
@ -19988,7 +19988,7 @@ func rewriteValueAMD64_OpMove(v *Value) bool {
mem := v.Args[2] mem := v.Args[2]
v.reset(OpAMD64MOVWstore) v.reset(OpAMD64MOVWstore)
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, fe.TypeUInt16()) v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, types.UInt16)
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
@ -20007,7 +20007,7 @@ func rewriteValueAMD64_OpMove(v *Value) bool {
mem := v.Args[2] mem := v.Args[2]
v.reset(OpAMD64MOVLstore) v.reset(OpAMD64MOVLstore)
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32()) v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, types.UInt32)
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
@ -20026,7 +20026,7 @@ func rewriteValueAMD64_OpMove(v *Value) bool {
mem := v.Args[2] mem := v.Args[2]
v.reset(OpAMD64MOVQstore) v.reset(OpAMD64MOVQstore)
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64()) v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, types.UInt64)
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
@ -20065,14 +20065,14 @@ func rewriteValueAMD64_OpMove(v *Value) bool {
v.reset(OpAMD64MOVBstore) v.reset(OpAMD64MOVBstore)
v.AuxInt = 2 v.AuxInt = 2
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, fe.TypeUInt8()) v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, types.UInt8)
v0.AuxInt = 2 v0.AuxInt = 2
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVWstore, TypeMem) v1 := b.NewValue0(v.Pos, OpAMD64MOVWstore, TypeMem)
v1.AddArg(dst) v1.AddArg(dst)
v2 := b.NewValue0(v.Pos, OpAMD64MOVWload, fe.TypeUInt16()) v2 := b.NewValue0(v.Pos, OpAMD64MOVWload, types.UInt16)
v2.AddArg(src) v2.AddArg(src)
v2.AddArg(mem) v2.AddArg(mem)
v1.AddArg(v2) v1.AddArg(v2)
@ -20093,14 +20093,14 @@ func rewriteValueAMD64_OpMove(v *Value) bool {
v.reset(OpAMD64MOVBstore) v.reset(OpAMD64MOVBstore)
v.AuxInt = 4 v.AuxInt = 4
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, fe.TypeUInt8()) v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, types.UInt8)
v0.AuxInt = 4 v0.AuxInt = 4
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVLstore, TypeMem) v1 := b.NewValue0(v.Pos, OpAMD64MOVLstore, TypeMem)
v1.AddArg(dst) v1.AddArg(dst)
v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32()) v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, types.UInt32)
v2.AddArg(src) v2.AddArg(src)
v2.AddArg(mem) v2.AddArg(mem)
v1.AddArg(v2) v1.AddArg(v2)
@ -20121,14 +20121,14 @@ func rewriteValueAMD64_OpMove(v *Value) bool {
v.reset(OpAMD64MOVWstore) v.reset(OpAMD64MOVWstore)
v.AuxInt = 4 v.AuxInt = 4
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, fe.TypeUInt16()) v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, types.UInt16)
v0.AuxInt = 4 v0.AuxInt = 4
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVLstore, TypeMem) v1 := b.NewValue0(v.Pos, OpAMD64MOVLstore, TypeMem)
v1.AddArg(dst) v1.AddArg(dst)
v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32()) v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, types.UInt32)
v2.AddArg(src) v2.AddArg(src)
v2.AddArg(mem) v2.AddArg(mem)
v1.AddArg(v2) v1.AddArg(v2)
@ -20149,14 +20149,14 @@ func rewriteValueAMD64_OpMove(v *Value) bool {
v.reset(OpAMD64MOVLstore) v.reset(OpAMD64MOVLstore)
v.AuxInt = 3 v.AuxInt = 3
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32()) v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, types.UInt32)
v0.AuxInt = 3 v0.AuxInt = 3
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVLstore, TypeMem) v1 := b.NewValue0(v.Pos, OpAMD64MOVLstore, TypeMem)
v1.AddArg(dst) v1.AddArg(dst)
v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, fe.TypeUInt32()) v2 := b.NewValue0(v.Pos, OpAMD64MOVLload, types.UInt32)
v2.AddArg(src) v2.AddArg(src)
v2.AddArg(mem) v2.AddArg(mem)
v1.AddArg(v2) v1.AddArg(v2)
@ -20178,14 +20178,14 @@ func rewriteValueAMD64_OpMove(v *Value) bool {
v.reset(OpAMD64MOVQstore) v.reset(OpAMD64MOVQstore)
v.AuxInt = s - 8 v.AuxInt = s - 8
v.AddArg(dst) v.AddArg(dst)
v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64()) v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, types.UInt64)
v0.AuxInt = s - 8 v0.AuxInt = s - 8
v0.AddArg(src) v0.AddArg(src)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVQstore, TypeMem) v1 := b.NewValue0(v.Pos, OpAMD64MOVQstore, TypeMem)
v1.AddArg(dst) v1.AddArg(dst)
v2 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64()) v2 := b.NewValue0(v.Pos, OpAMD64MOVQload, types.UInt64)
v2.AddArg(src) v2.AddArg(src)
v2.AddArg(mem) v2.AddArg(mem)
v1.AddArg(v2) v1.AddArg(v2)
@ -20216,7 +20216,7 @@ func rewriteValueAMD64_OpMove(v *Value) bool {
v.AddArg(v1) v.AddArg(v1)
v2 := b.NewValue0(v.Pos, OpAMD64MOVQstore, TypeMem) v2 := b.NewValue0(v.Pos, OpAMD64MOVQstore, TypeMem)
v2.AddArg(dst) v2.AddArg(dst)
v3 := b.NewValue0(v.Pos, OpAMD64MOVQload, fe.TypeUInt64()) v3 := b.NewValue0(v.Pos, OpAMD64MOVQload, types.UInt64)
v3.AddArg(src) v3.AddArg(src)
v3.AddArg(mem) v3.AddArg(mem)
v2.AddArg(v3) v2.AddArg(v3)
@ -20287,7 +20287,7 @@ func rewriteValueAMD64_OpMove(v *Value) bool {
v.reset(OpAMD64REPMOVSQ) v.reset(OpAMD64REPMOVSQ)
v.AddArg(dst) v.AddArg(dst)
v.AddArg(src) v.AddArg(src)
v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v0.AuxInt = s / 8 v0.AuxInt = s / 8
v.AddArg(v0) v.AddArg(v0)
v.AddArg(mem) v.AddArg(mem)
@ -20411,16 +20411,16 @@ func rewriteValueAMD64_OpNeg32(v *Value) bool {
func rewriteValueAMD64_OpNeg32F(v *Value) bool { func rewriteValueAMD64_OpNeg32F(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Neg32F x) // match: (Neg32F x)
// cond: // cond:
// result: (PXOR x (MOVSSconst <fe.TypeFloat32()> [f2i(math.Copysign(0, -1))])) // result: (PXOR x (MOVSSconst <types.Float32> [f2i(math.Copysign(0, -1))]))
for { for {
x := v.Args[0] x := v.Args[0]
v.reset(OpAMD64PXOR) v.reset(OpAMD64PXOR)
v.AddArg(x) v.AddArg(x)
v0 := b.NewValue0(v.Pos, OpAMD64MOVSSconst, fe.TypeFloat32()) v0 := b.NewValue0(v.Pos, OpAMD64MOVSSconst, types.Float32)
v0.AuxInt = f2i(math.Copysign(0, -1)) v0.AuxInt = f2i(math.Copysign(0, -1))
v.AddArg(v0) v.AddArg(v0)
return true return true
@ -20440,16 +20440,16 @@ func rewriteValueAMD64_OpNeg64(v *Value) bool {
func rewriteValueAMD64_OpNeg64F(v *Value) bool { func rewriteValueAMD64_OpNeg64F(v *Value) bool {
b := v.Block b := v.Block
_ = b _ = b
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Neg64F x) // match: (Neg64F x)
// cond: // cond:
// result: (PXOR x (MOVSDconst <fe.TypeFloat64()> [f2i(math.Copysign(0, -1))])) // result: (PXOR x (MOVSDconst <types.Float64> [f2i(math.Copysign(0, -1))]))
for { for {
x := v.Args[0] x := v.Args[0]
v.reset(OpAMD64PXOR) v.reset(OpAMD64PXOR)
v.AddArg(x) v.AddArg(x)
v0 := b.NewValue0(v.Pos, OpAMD64MOVSDconst, fe.TypeFloat64()) v0 := b.NewValue0(v.Pos, OpAMD64MOVSDconst, types.Float64)
v0.AuxInt = f2i(math.Copysign(0, -1)) v0.AuxInt = f2i(math.Copysign(0, -1))
v.AddArg(v0) v.AddArg(v0)
return true return true
@ -20654,8 +20654,8 @@ func rewriteValueAMD64_OpOffPtr(v *Value) bool {
_ = b _ = b
config := b.Func.Config config := b.Func.Config
_ = config _ = config
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (OffPtr [off] ptr) // match: (OffPtr [off] ptr)
// cond: config.PtrSize == 8 && is32Bit(off) // cond: config.PtrSize == 8 && is32Bit(off)
// result: (ADDQconst [off] ptr) // result: (ADDQconst [off] ptr)
@ -20680,7 +20680,7 @@ func rewriteValueAMD64_OpOffPtr(v *Value) bool {
break break
} }
v.reset(OpAMD64ADDQ) v.reset(OpAMD64ADDQ)
v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v0.AuxInt = off v0.AuxInt = off
v.AddArg(v0) v.AddArg(v0)
v.AddArg(ptr) v.AddArg(ptr)
@ -22133,8 +22133,8 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
_ = b _ = b
config := b.Func.Config config := b.Func.Config
_ = config _ = config
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Zero [0] _ mem) // match: (Zero [0] _ mem)
// cond: // cond:
// result: mem // result: mem
@ -22394,7 +22394,7 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVQstore, TypeMem) v1 := b.NewValue0(v.Pos, OpAMD64MOVQstore, TypeMem)
v1.AddArg(destptr) v1.AddArg(destptr)
v2 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v2 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v2.AuxInt = 0 v2.AuxInt = 0
v1.AddArg(v2) v1.AddArg(v2)
v1.AddArg(mem) v1.AddArg(mem)
@ -22432,10 +22432,10 @@ func rewriteValueAMD64_OpZero(v *Value) bool {
} }
v.reset(OpAMD64REPSTOSQ) v.reset(OpAMD64REPSTOSQ)
v.AddArg(destptr) v.AddArg(destptr)
v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v0 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v0.AuxInt = s / 8 v0.AuxInt = s / 8
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpAMD64MOVQconst, fe.TypeUInt64()) v1 := b.NewValue0(v.Pos, OpAMD64MOVQconst, types.UInt64)
v1.AuxInt = 0 v1.AuxInt = 0
v.AddArg(v1) v.AddArg(v1)
v.AddArg(mem) v.AddArg(mem)
@ -22514,6 +22514,8 @@ func rewriteBlockAMD64(b *Block) bool {
_ = config _ = config
fe := b.Func.fe fe := b.Func.fe
_ = fe _ = fe
types := &config.Types
_ = types
switch b.Kind { switch b.Kind {
case BlockAMD64EQ: case BlockAMD64EQ:
// match: (EQ (TESTL (SHLL (MOVLconst [1]) x) y)) // match: (EQ (TESTL (SHLL (MOVLconst [1]) x) y))

604
src/cmd/compile/internal/ssa/rewriteARM.go
View file

File diff suppressed because it is too large Load diff

750
src/cmd/compile/internal/ssa/rewriteARM64.go
View file

File diff suppressed because it is too large Load diff

1028
src/cmd/compile/internal/ssa/rewriteMIPS.go
View file

File diff suppressed because it is too large Load diff

1442
src/cmd/compile/internal/ssa/rewriteMIPS64.go
View file

File diff suppressed because it is too large Load diff

1016
src/cmd/compile/internal/ssa/rewritePPC64.go
View file

File diff suppressed because it is too large Load diff

1016
src/cmd/compile/internal/ssa/rewriteS390X.go
View file

File diff suppressed because it is too large Load diff

96
src/cmd/compile/internal/ssa/rewritedec.go
View file

@ -108,11 +108,11 @@ func rewriteValuedec_OpLoad(v *Value) bool {
_ = b _ = b
config := b.Func.Config config := b.Func.Config
_ = config _ = config
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Load <t> ptr mem) // match: (Load <t> ptr mem)
// cond: t.IsComplex() && t.Size() == 8 // cond: t.IsComplex() && t.Size() == 8
// result: (ComplexMake (Load <fe.TypeFloat32()> ptr mem) (Load <fe.TypeFloat32()> (OffPtr <fe.TypeFloat32().PtrTo()> [4] ptr) mem) ) // result: (ComplexMake (Load <types.Float32> ptr mem) (Load <types.Float32> (OffPtr <types.Float32.PtrTo()> [4] ptr) mem) )
for { for {
t := v.Type t := v.Type
ptr := v.Args[0] ptr := v.Args[0]
@ -121,12 +121,12 @@ func rewriteValuedec_OpLoad(v *Value) bool {
break break
} }
v.reset(OpComplexMake) v.reset(OpComplexMake)
v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeFloat32()) v0 := b.NewValue0(v.Pos, OpLoad, types.Float32)
v0.AddArg(ptr) v0.AddArg(ptr)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeFloat32()) v1 := b.NewValue0(v.Pos, OpLoad, types.Float32)
v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeFloat32().PtrTo()) v2 := b.NewValue0(v.Pos, OpOffPtr, types.Float32.PtrTo())
v2.AuxInt = 4 v2.AuxInt = 4
v2.AddArg(ptr) v2.AddArg(ptr)
v1.AddArg(v2) v1.AddArg(v2)
@ -136,7 +136,7 @@ func rewriteValuedec_OpLoad(v *Value) bool {
} }
// match: (Load <t> ptr mem) // match: (Load <t> ptr mem)
// cond: t.IsComplex() && t.Size() == 16 // cond: t.IsComplex() && t.Size() == 16
// result: (ComplexMake (Load <fe.TypeFloat64()> ptr mem) (Load <fe.TypeFloat64()> (OffPtr <fe.TypeFloat64().PtrTo()> [8] ptr) mem) ) // result: (ComplexMake (Load <types.Float64> ptr mem) (Load <types.Float64> (OffPtr <types.Float64.PtrTo()> [8] ptr) mem) )
for { for {
t := v.Type t := v.Type
ptr := v.Args[0] ptr := v.Args[0]
@ -145,12 +145,12 @@ func rewriteValuedec_OpLoad(v *Value) bool {
break break
} }
v.reset(OpComplexMake) v.reset(OpComplexMake)
v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeFloat64()) v0 := b.NewValue0(v.Pos, OpLoad, types.Float64)
v0.AddArg(ptr) v0.AddArg(ptr)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeFloat64()) v1 := b.NewValue0(v.Pos, OpLoad, types.Float64)
v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeFloat64().PtrTo()) v2 := b.NewValue0(v.Pos, OpOffPtr, types.Float64.PtrTo())
v2.AuxInt = 8 v2.AuxInt = 8
v2.AddArg(ptr) v2.AddArg(ptr)
v1.AddArg(v2) v1.AddArg(v2)
@ -160,7 +160,7 @@ func rewriteValuedec_OpLoad(v *Value) bool {
} }
// match: (Load <t> ptr mem) // match: (Load <t> ptr mem)
// cond: t.IsString() // cond: t.IsString()
// result: (StringMake (Load <fe.TypeBytePtr()> ptr mem) (Load <fe.TypeInt()> (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] ptr) mem)) // result: (StringMake (Load <types.BytePtr> ptr mem) (Load <types.Int> (OffPtr <types.Int.PtrTo()> [config.PtrSize] ptr) mem))
for { for {
t := v.Type t := v.Type
ptr := v.Args[0] ptr := v.Args[0]
@ -169,12 +169,12 @@ func rewriteValuedec_OpLoad(v *Value) bool {
break break
} }
v.reset(OpStringMake) v.reset(OpStringMake)
v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeBytePtr()) v0 := b.NewValue0(v.Pos, OpLoad, types.BytePtr)
v0.AddArg(ptr) v0.AddArg(ptr)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeInt()) v1 := b.NewValue0(v.Pos, OpLoad, types.Int)
v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo()) v2 := b.NewValue0(v.Pos, OpOffPtr, types.Int.PtrTo())
v2.AuxInt = config.PtrSize v2.AuxInt = config.PtrSize
v2.AddArg(ptr) v2.AddArg(ptr)
v1.AddArg(v2) v1.AddArg(v2)
@ -184,7 +184,7 @@ func rewriteValuedec_OpLoad(v *Value) bool {
} }
// match: (Load <t> ptr mem) // match: (Load <t> ptr mem)
// cond: t.IsSlice() // cond: t.IsSlice()
// result: (SliceMake (Load <t.ElemType().PtrTo()> ptr mem) (Load <fe.TypeInt()> (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] ptr) mem) (Load <fe.TypeInt()> (OffPtr <fe.TypeInt().PtrTo()> [2*config.PtrSize] ptr) mem)) // result: (SliceMake (Load <t.ElemType().PtrTo()> ptr mem) (Load <types.Int> (OffPtr <types.Int.PtrTo()> [config.PtrSize] ptr) mem) (Load <types.Int> (OffPtr <types.Int.PtrTo()> [2*config.PtrSize] ptr) mem))
for { for {
t := v.Type t := v.Type
ptr := v.Args[0] ptr := v.Args[0]
@ -197,15 +197,15 @@ func rewriteValuedec_OpLoad(v *Value) bool {
v0.AddArg(ptr) v0.AddArg(ptr)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeInt()) v1 := b.NewValue0(v.Pos, OpLoad, types.Int)
v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo()) v2 := b.NewValue0(v.Pos, OpOffPtr, types.Int.PtrTo())
v2.AuxInt = config.PtrSize v2.AuxInt = config.PtrSize
v2.AddArg(ptr) v2.AddArg(ptr)
v1.AddArg(v2) v1.AddArg(v2)
v1.AddArg(mem) v1.AddArg(mem)
v.AddArg(v1) v.AddArg(v1)
v3 := b.NewValue0(v.Pos, OpLoad, fe.TypeInt()) v3 := b.NewValue0(v.Pos, OpLoad, types.Int)
v4 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo()) v4 := b.NewValue0(v.Pos, OpOffPtr, types.Int.PtrTo())
v4.AuxInt = 2 * config.PtrSize v4.AuxInt = 2 * config.PtrSize
v4.AddArg(ptr) v4.AddArg(ptr)
v3.AddArg(v4) v3.AddArg(v4)
@ -215,7 +215,7 @@ func rewriteValuedec_OpLoad(v *Value) bool {
} }
// match: (Load <t> ptr mem) // match: (Load <t> ptr mem)
// cond: t.IsInterface() // cond: t.IsInterface()
// result: (IMake (Load <fe.TypeBytePtr()> ptr mem) (Load <fe.TypeBytePtr()> (OffPtr <fe.TypeBytePtr().PtrTo()> [config.PtrSize] ptr) mem)) // result: (IMake (Load <types.BytePtr> ptr mem) (Load <types.BytePtr> (OffPtr <types.BytePtr.PtrTo()> [config.PtrSize] ptr) mem))
for { for {
t := v.Type t := v.Type
ptr := v.Args[0] ptr := v.Args[0]
@ -224,12 +224,12 @@ func rewriteValuedec_OpLoad(v *Value) bool {
break break
} }
v.reset(OpIMake) v.reset(OpIMake)
v0 := b.NewValue0(v.Pos, OpLoad, fe.TypeBytePtr()) v0 := b.NewValue0(v.Pos, OpLoad, types.BytePtr)
v0.AddArg(ptr) v0.AddArg(ptr)
v0.AddArg(mem) v0.AddArg(mem)
v.AddArg(v0) v.AddArg(v0)
v1 := b.NewValue0(v.Pos, OpLoad, fe.TypeBytePtr()) v1 := b.NewValue0(v.Pos, OpLoad, types.BytePtr)
v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeBytePtr().PtrTo()) v2 := b.NewValue0(v.Pos, OpOffPtr, types.BytePtr.PtrTo())
v2.AuxInt = config.PtrSize v2.AuxInt = config.PtrSize
v2.AddArg(ptr) v2.AddArg(ptr)
v1.AddArg(v2) v1.AddArg(v2)
@ -295,11 +295,11 @@ func rewriteValuedec_OpStore(v *Value) bool {
_ = b _ = b
config := b.Func.Config config := b.Func.Config
_ = config _ = config
fe := b.Func.fe types := &b.Func.Config.Types
_ = fe _ = types
// match: (Store {t} dst (ComplexMake real imag) mem) // match: (Store {t} dst (ComplexMake real imag) mem)
// cond: t.(Type).Size() == 8 // cond: t.(Type).Size() == 8
// result: (Store {fe.TypeFloat32()} (OffPtr <fe.TypeFloat32().PtrTo()> [4] dst) imag (Store {fe.TypeFloat32()} dst real mem)) // result: (Store {types.Float32} (OffPtr <types.Float32.PtrTo()> [4] dst) imag (Store {types.Float32} dst real mem))
for { for {
t := v.Aux t := v.Aux
dst := v.Args[0] dst := v.Args[0]
@ -314,14 +314,14 @@ func rewriteValuedec_OpStore(v *Value) bool {
break break
} }
v.reset(OpStore) v.reset(OpStore)
v.Aux = fe.TypeFloat32() v.Aux = types.Float32
v0 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeFloat32().PtrTo()) v0 := b.NewValue0(v.Pos, OpOffPtr, types.Float32.PtrTo())
v0.AuxInt = 4 v0.AuxInt = 4
v0.AddArg(dst) v0.AddArg(dst)
v.AddArg(v0) v.AddArg(v0)
v.AddArg(imag) v.AddArg(imag)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem) v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
v1.Aux = fe.TypeFloat32() v1.Aux = types.Float32
v1.AddArg(dst) v1.AddArg(dst)
v1.AddArg(real) v1.AddArg(real)
v1.AddArg(mem) v1.AddArg(mem)
@ -330,7 +330,7 @@ func rewriteValuedec_OpStore(v *Value) bool {
} }
// match: (Store {t} dst (ComplexMake real imag) mem) // match: (Store {t} dst (ComplexMake real imag) mem)
// cond: t.(Type).Size() == 16 // cond: t.(Type).Size() == 16
// result: (Store {fe.TypeFloat64()} (OffPtr <fe.TypeFloat64().PtrTo()> [8] dst) imag (Store {fe.TypeFloat64()} dst real mem)) // result: (Store {types.Float64} (OffPtr <types.Float64.PtrTo()> [8] dst) imag (Store {types.Float64} dst real mem))
for { for {
t := v.Aux t := v.Aux
dst := v.Args[0] dst := v.Args[0]
@ -345,14 +345,14 @@ func rewriteValuedec_OpStore(v *Value) bool {
break break
} }
v.reset(OpStore) v.reset(OpStore)
v.Aux = fe.TypeFloat64() v.Aux = types.Float64
v0 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeFloat64().PtrTo()) v0 := b.NewValue0(v.Pos, OpOffPtr, types.Float64.PtrTo())
v0.AuxInt = 8 v0.AuxInt = 8
v0.AddArg(dst) v0.AddArg(dst)
v.AddArg(v0) v.AddArg(v0)
v.AddArg(imag) v.AddArg(imag)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem) v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
v1.Aux = fe.TypeFloat64() v1.Aux = types.Float64
v1.AddArg(dst) v1.AddArg(dst)
v1.AddArg(real) v1.AddArg(real)
v1.AddArg(mem) v1.AddArg(mem)
@ -361,7 +361,7 @@ func rewriteValuedec_OpStore(v *Value) bool {
} }
// match: (Store dst (StringMake ptr len) mem) // match: (Store dst (StringMake ptr len) mem)
// cond: // cond:
// result: (Store {fe.TypeInt()} (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] dst) len (Store {fe.TypeBytePtr()} dst ptr mem)) // result: (Store {types.Int} (OffPtr <types.Int.PtrTo()> [config.PtrSize] dst) len (Store {types.BytePtr} dst ptr mem))
for { for {
dst := v.Args[0] dst := v.Args[0]
v_1 := v.Args[1] v_1 := v.Args[1]
@ -372,14 +372,14 @@ func rewriteValuedec_OpStore(v *Value) bool {
len := v_1.Args[1] len := v_1.Args[1]
mem := v.Args[2] mem := v.Args[2]
v.reset(OpStore) v.reset(OpStore)
v.Aux = fe.TypeInt() v.Aux = types.Int
v0 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo()) v0 := b.NewValue0(v.Pos, OpOffPtr, types.Int.PtrTo())
v0.AuxInt = config.PtrSize v0.AuxInt = config.PtrSize
v0.AddArg(dst) v0.AddArg(dst)
v.AddArg(v0) v.AddArg(v0)
v.AddArg(len) v.AddArg(len)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem) v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
v1.Aux = fe.TypeBytePtr() v1.Aux = types.BytePtr
v1.AddArg(dst) v1.AddArg(dst)
v1.AddArg(ptr) v1.AddArg(ptr)
v1.AddArg(mem) v1.AddArg(mem)
@ -388,7 +388,7 @@ func rewriteValuedec_OpStore(v *Value) bool {
} }
// match: (Store dst (SliceMake ptr len cap) mem) // match: (Store dst (SliceMake ptr len cap) mem)
// cond: // cond:
// result: (Store {fe.TypeInt()} (OffPtr <fe.TypeInt().PtrTo()> [2*config.PtrSize] dst) cap (Store {fe.TypeInt()} (OffPtr <fe.TypeInt().PtrTo()> [config.PtrSize] dst) len (Store {fe.TypeBytePtr()} dst ptr mem))) // result: (Store {types.Int} (OffPtr <types.Int.PtrTo()> [2*config.PtrSize] dst) cap (Store {types.Int} (OffPtr <types.Int.PtrTo()> [config.PtrSize] dst) len (Store {types.BytePtr} dst ptr mem)))
for { for {
dst := v.Args[0] dst := v.Args[0]
v_1 := v.Args[1] v_1 := v.Args[1]
@ -400,21 +400,21 @@ func rewriteValuedec_OpStore(v *Value) bool {
cap := v_1.Args[2] cap := v_1.Args[2]
mem := v.Args[2] mem := v.Args[2]
v.reset(OpStore) v.reset(OpStore)
v.Aux = fe.TypeInt() v.Aux = types.Int
v0 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo()) v0 := b.NewValue0(v.Pos, OpOffPtr, types.Int.PtrTo())
v0.AuxInt = 2 * config.PtrSize v0.AuxInt = 2 * config.PtrSize
v0.AddArg(dst) v0.AddArg(dst)
v.AddArg(v0) v.AddArg(v0)
v.AddArg(cap) v.AddArg(cap)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem) v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
v1.Aux = fe.TypeInt() v1.Aux = types.Int
v2 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeInt().PtrTo()) v2 := b.NewValue0(v.Pos, OpOffPtr, types.Int.PtrTo())
v2.AuxInt = config.PtrSize v2.AuxInt = config.PtrSize
v2.AddArg(dst) v2.AddArg(dst)
v1.AddArg(v2) v1.AddArg(v2)
v1.AddArg(len) v1.AddArg(len)
v3 := b.NewValue0(v.Pos, OpStore, TypeMem) v3 := b.NewValue0(v.Pos, OpStore, TypeMem)
v3.Aux = fe.TypeBytePtr() v3.Aux = types.BytePtr
v3.AddArg(dst) v3.AddArg(dst)
v3.AddArg(ptr) v3.AddArg(ptr)
v3.AddArg(mem) v3.AddArg(mem)
@ -424,7 +424,7 @@ func rewriteValuedec_OpStore(v *Value) bool {
} }
// match: (Store dst (IMake itab data) mem) // match: (Store dst (IMake itab data) mem)
// cond: // cond:
// result: (Store {fe.TypeBytePtr()} (OffPtr <fe.TypeBytePtr().PtrTo()> [config.PtrSize] dst) data (Store {fe.TypeUintptr()} dst itab mem)) // result: (Store {types.BytePtr} (OffPtr <types.BytePtr.PtrTo()> [config.PtrSize] dst) data (Store {types.Uintptr} dst itab mem))
for { for {
dst := v.Args[0] dst := v.Args[0]
v_1 := v.Args[1] v_1 := v.Args[1]
@ -435,14 +435,14 @@ func rewriteValuedec_OpStore(v *Value) bool {
data := v_1.Args[1] data := v_1.Args[1]
mem := v.Args[2] mem := v.Args[2]
v.reset(OpStore) v.reset(OpStore)
v.Aux = fe.TypeBytePtr() v.Aux = types.BytePtr
v0 := b.NewValue0(v.Pos, OpOffPtr, fe.TypeBytePtr().PtrTo()) v0 := b.NewValue0(v.Pos, OpOffPtr, types.BytePtr.PtrTo())
v0.AuxInt = config.PtrSize v0.AuxInt = config.PtrSize
v0.AddArg(dst) v0.AddArg(dst)
v.AddArg(v0) v.AddArg(v0)
v.AddArg(data) v.AddArg(data)
v1 := b.NewValue0(v.Pos, OpStore, TypeMem) v1 := b.NewValue0(v.Pos, OpStore, TypeMem)
v1.Aux = fe.TypeUintptr() v1.Aux = types.Uintptr
v1.AddArg(dst) v1.AddArg(dst)
v1.AddArg(itab) v1.AddArg(itab)
v1.AddArg(mem) v1.AddArg(mem)
@ -490,6 +490,8 @@ func rewriteBlockdec(b *Block) bool {
_ = config _ = config
fe := b.Func.fe fe := b.Func.fe
_ = fe _ = fe
types := &config.Types
_ = types
switch b.Kind { switch b.Kind {
} }
return false return false

956
src/cmd/compile/internal/ssa/rewritedec64.go
View file

File diff suppressed because it is too large Load diff

680
src/cmd/compile/internal/ssa/rewritegeneric.go
View file

File diff suppressed because it is too large Load diff

4
src/cmd/compile/internal/ssa/shortcircuit.go
View file

@ -17,8 +17,8 @@ func shortcircuit(f *Func) {
// x = phi(a, ...) // x = phi(a, ...)
// //
// We can replace the "a" in the phi with the constant true. // We can replace the "a" in the phi with the constant true.
ct := f.ConstBool(f.Entry.Pos, f.fe.TypeBool(), true) ct := f.ConstBool(f.Entry.Pos, f.Config.Types.Bool, true)
cf := f.ConstBool(f.Entry.Pos, f.fe.TypeBool(), false) cf := f.ConstBool(f.Entry.Pos, f.Config.Types.Bool, false)
for _, b := range f.Blocks { for _, b := range f.Blocks {
for _, v := range b.Values { for _, v := range b.Values {
if v.Op != OpPhi { if v.Op != OpPhi {

19
src/cmd/compile/internal/ssa/writebarrier.go
View file

@ -88,17 +88,17 @@ func writebarrier(f *Func) {
} }
} }
if sb == nil { if sb == nil {
sb = f.Entry.NewValue0(initpos, OpSB, f.fe.TypeUintptr()) sb = f.Entry.NewValue0(initpos, OpSB, f.Config.Types.Uintptr)
} }
if sp == nil { if sp == nil {
sp = f.Entry.NewValue0(initpos, OpSP, f.fe.TypeUintptr()) sp = f.Entry.NewValue0(initpos, OpSP, f.Config.Types.Uintptr)
} }
wbsym := &ExternSymbol{Typ: f.fe.TypeBool(), Sym: f.fe.Syslook("writeBarrier")} wbsym := &ExternSymbol{Typ: f.Config.Types.Bool, Sym: f.fe.Syslook("writeBarrier")}
wbaddr = f.Entry.NewValue1A(initpos, OpAddr, f.fe.TypeUInt32().PtrTo(), wbsym, sb) wbaddr = f.Entry.NewValue1A(initpos, OpAddr, f.Config.Types.UInt32.PtrTo(), wbsym, sb)
writebarrierptr = f.fe.Syslook("writebarrierptr") writebarrierptr = f.fe.Syslook("writebarrierptr")
typedmemmove = f.fe.Syslook("typedmemmove") typedmemmove = f.fe.Syslook("typedmemmove")
typedmemclr = f.fe.Syslook("typedmemclr") typedmemclr = f.fe.Syslook("typedmemclr")
const0 = f.ConstInt32(initpos, f.fe.TypeUInt32(), 0) const0 = f.ConstInt32(initpos, f.Config.Types.UInt32, 0)
// allocate auxiliary data structures for computing store order // allocate auxiliary data structures for computing store order
sset = f.newSparseSet(f.NumValues()) sset = f.newSparseSet(f.NumValues())
@ -155,8 +155,9 @@ func writebarrier(f *Func) {
// set up control flow for write barrier test // set up control flow for write barrier test
// load word, test word, avoiding partial register write from load byte. // load word, test word, avoiding partial register write from load byte.
flag := b.NewValue2(pos, OpLoad, f.fe.TypeUInt32(), wbaddr, mem) types := &f.Config.Types
flag = b.NewValue2(pos, OpNeq32, f.fe.TypeBool(), flag, const0) flag := b.NewValue2(pos, OpLoad, types.UInt32, wbaddr, mem)
flag = b.NewValue2(pos, OpNeq32, types.Bool, flag, const0)
b.Kind = BlockIf b.Kind = BlockIf
b.SetControl(flag) b.SetControl(flag)
b.Likely = BranchUnlikely b.Likely = BranchUnlikely
@ -175,7 +176,7 @@ func writebarrier(f *Func) {
ptr := w.Args[0] ptr := w.Args[0]
var typ interface{} var typ interface{}
if w.Op != OpStoreWB { if w.Op != OpStoreWB {
typ = &ExternSymbol{Typ: f.fe.TypeUintptr(), Sym: w.Aux.(Type).Symbol()} typ = &ExternSymbol{Typ: types.Uintptr, Sym: w.Aux.(Type).Symbol()}
} }
pos = w.Pos pos = w.Pos
@ -280,7 +281,7 @@ func wbcall(pos src.XPos, b *Block, fn *obj.LSym, typ interface{}, ptr, val, mem
off := config.ctxt.FixedFrameSize() off := config.ctxt.FixedFrameSize()
if typ != nil { // for typedmemmove if typ != nil { // for typedmemmove
taddr := b.NewValue1A(pos, OpAddr, b.Func.fe.TypeUintptr(), typ, sb) taddr := b.NewValue1A(pos, OpAddr, b.Func.Config.Types.Uintptr, typ, sb)
off = round(off, taddr.Type.Alignment()) off = round(off, taddr.Type.Alignment())
arg := b.NewValue1I(pos, OpOffPtr, taddr.Type.PtrTo(), off, sp) arg := b.NewValue1I(pos, OpOffPtr, taddr.Type.PtrTo(), off, sp)
mem = b.NewValue3A(pos, OpStore, TypeMem, ptr.Type, arg, taddr, mem) mem = b.NewValue3A(pos, OpStore, TypeMem, ptr.Type, arg, taddr, mem)