Source file src/pkg/cmd/compile/internal/ssa/rewriteAMD64splitload.go

     1	// Code generated from gen/AMD64splitload.rules; DO NOT EDIT.
     2	// generated with: cd gen; go run *.go
     3	
     4	package ssa
     5	
     6	import "fmt"
     7	import "math"
     8	import "cmd/internal/obj"
     9	import "cmd/internal/objabi"
    10	import "cmd/compile/internal/types"
    11	
    12	var _ = fmt.Println   // in case not otherwise used
    13	var _ = math.MinInt8  // in case not otherwise used
    14	var _ = obj.ANOP      // in case not otherwise used
    15	var _ = objabi.GOROOT // in case not otherwise used
    16	var _ = types.TypeMem // in case not otherwise used
    17	
    18	func rewriteValueAMD64splitload(v *Value) bool {
    19		switch v.Op {
    20		case OpAMD64CMPBconstload:
    21			return rewriteValueAMD64splitload_OpAMD64CMPBconstload_0(v)
    22		case OpAMD64CMPBload:
    23			return rewriteValueAMD64splitload_OpAMD64CMPBload_0(v)
    24		case OpAMD64CMPLconstload:
    25			return rewriteValueAMD64splitload_OpAMD64CMPLconstload_0(v)
    26		case OpAMD64CMPLload:
    27			return rewriteValueAMD64splitload_OpAMD64CMPLload_0(v)
    28		case OpAMD64CMPQconstload:
    29			return rewriteValueAMD64splitload_OpAMD64CMPQconstload_0(v)
    30		case OpAMD64CMPQload:
    31			return rewriteValueAMD64splitload_OpAMD64CMPQload_0(v)
    32		case OpAMD64CMPWconstload:
    33			return rewriteValueAMD64splitload_OpAMD64CMPWconstload_0(v)
    34		case OpAMD64CMPWload:
    35			return rewriteValueAMD64splitload_OpAMD64CMPWload_0(v)
    36		}
    37		return false
    38	}
    39	func rewriteValueAMD64splitload_OpAMD64CMPBconstload_0(v *Value) bool {
    40		b := v.Block
    41		typ := &b.Func.Config.Types
    42		// match: (CMPBconstload {sym} [vo] ptr mem)
    43		// cond:
    44		// result: (CMPBconst (MOVBload {sym} [offOnly(vo)] ptr mem) [valOnly(vo)])
    45		for {
    46			vo := v.AuxInt
    47			sym := v.Aux
    48			mem := v.Args[1]
    49			ptr := v.Args[0]
    50			v.reset(OpAMD64CMPBconst)
    51			v.AuxInt = valOnly(vo)
    52			v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, typ.UInt8)
    53			v0.AuxInt = offOnly(vo)
    54			v0.Aux = sym
    55			v0.AddArg(ptr)
    56			v0.AddArg(mem)
    57			v.AddArg(v0)
    58			return true
    59		}
    60	}
    61	func rewriteValueAMD64splitload_OpAMD64CMPBload_0(v *Value) bool {
    62		b := v.Block
    63		typ := &b.Func.Config.Types
    64		// match: (CMPBload {sym} [off] ptr x mem)
    65		// cond:
    66		// result: (CMPB (MOVBload {sym} [off] ptr mem) x)
    67		for {
    68			off := v.AuxInt
    69			sym := v.Aux
    70			mem := v.Args[2]
    71			ptr := v.Args[0]
    72			x := v.Args[1]
    73			v.reset(OpAMD64CMPB)
    74			v0 := b.NewValue0(v.Pos, OpAMD64MOVBload, typ.UInt8)
    75			v0.AuxInt = off
    76			v0.Aux = sym
    77			v0.AddArg(ptr)
    78			v0.AddArg(mem)
    79			v.AddArg(v0)
    80			v.AddArg(x)
    81			return true
    82		}
    83	}
    84	func rewriteValueAMD64splitload_OpAMD64CMPLconstload_0(v *Value) bool {
    85		b := v.Block
    86		typ := &b.Func.Config.Types
    87		// match: (CMPLconstload {sym} [vo] ptr mem)
    88		// cond:
    89		// result: (CMPLconst (MOVLload {sym} [offOnly(vo)] ptr mem) [valOnly(vo)])
    90		for {
    91			vo := v.AuxInt
    92			sym := v.Aux
    93			mem := v.Args[1]
    94			ptr := v.Args[0]
    95			v.reset(OpAMD64CMPLconst)
    96			v.AuxInt = valOnly(vo)
    97			v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, typ.UInt32)
    98			v0.AuxInt = offOnly(vo)
    99			v0.Aux = sym
   100			v0.AddArg(ptr)
   101			v0.AddArg(mem)
   102			v.AddArg(v0)
   103			return true
   104		}
   105	}
   106	func rewriteValueAMD64splitload_OpAMD64CMPLload_0(v *Value) bool {
   107		b := v.Block
   108		typ := &b.Func.Config.Types
   109		// match: (CMPLload {sym} [off] ptr x mem)
   110		// cond:
   111		// result: (CMPL (MOVLload {sym} [off] ptr mem) x)
   112		for {
   113			off := v.AuxInt
   114			sym := v.Aux
   115			mem := v.Args[2]
   116			ptr := v.Args[0]
   117			x := v.Args[1]
   118			v.reset(OpAMD64CMPL)
   119			v0 := b.NewValue0(v.Pos, OpAMD64MOVLload, typ.UInt32)
   120			v0.AuxInt = off
   121			v0.Aux = sym
   122			v0.AddArg(ptr)
   123			v0.AddArg(mem)
   124			v.AddArg(v0)
   125			v.AddArg(x)
   126			return true
   127		}
   128	}
   129	func rewriteValueAMD64splitload_OpAMD64CMPQconstload_0(v *Value) bool {
   130		b := v.Block
   131		typ := &b.Func.Config.Types
   132		// match: (CMPQconstload {sym} [vo] ptr mem)
   133		// cond:
   134		// result: (CMPQconst (MOVQload {sym} [offOnly(vo)] ptr mem) [valOnly(vo)])
   135		for {
   136			vo := v.AuxInt
   137			sym := v.Aux
   138			mem := v.Args[1]
   139			ptr := v.Args[0]
   140			v.reset(OpAMD64CMPQconst)
   141			v.AuxInt = valOnly(vo)
   142			v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, typ.UInt64)
   143			v0.AuxInt = offOnly(vo)
   144			v0.Aux = sym
   145			v0.AddArg(ptr)
   146			v0.AddArg(mem)
   147			v.AddArg(v0)
   148			return true
   149		}
   150	}
   151	func rewriteValueAMD64splitload_OpAMD64CMPQload_0(v *Value) bool {
   152		b := v.Block
   153		typ := &b.Func.Config.Types
   154		// match: (CMPQload {sym} [off] ptr x mem)
   155		// cond:
   156		// result: (CMPQ (MOVQload {sym} [off] ptr mem) x)
   157		for {
   158			off := v.AuxInt
   159			sym := v.Aux
   160			mem := v.Args[2]
   161			ptr := v.Args[0]
   162			x := v.Args[1]
   163			v.reset(OpAMD64CMPQ)
   164			v0 := b.NewValue0(v.Pos, OpAMD64MOVQload, typ.UInt64)
   165			v0.AuxInt = off
   166			v0.Aux = sym
   167			v0.AddArg(ptr)
   168			v0.AddArg(mem)
   169			v.AddArg(v0)
   170			v.AddArg(x)
   171			return true
   172		}
   173	}
   174	func rewriteValueAMD64splitload_OpAMD64CMPWconstload_0(v *Value) bool {
   175		b := v.Block
   176		typ := &b.Func.Config.Types
   177		// match: (CMPWconstload {sym} [vo] ptr mem)
   178		// cond:
   179		// result: (CMPWconst (MOVWload {sym} [offOnly(vo)] ptr mem) [valOnly(vo)])
   180		for {
   181			vo := v.AuxInt
   182			sym := v.Aux
   183			mem := v.Args[1]
   184			ptr := v.Args[0]
   185			v.reset(OpAMD64CMPWconst)
   186			v.AuxInt = valOnly(vo)
   187			v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, typ.UInt16)
   188			v0.AuxInt = offOnly(vo)
   189			v0.Aux = sym
   190			v0.AddArg(ptr)
   191			v0.AddArg(mem)
   192			v.AddArg(v0)
   193			return true
   194		}
   195	}
   196	func rewriteValueAMD64splitload_OpAMD64CMPWload_0(v *Value) bool {
   197		b := v.Block
   198		typ := &b.Func.Config.Types
   199		// match: (CMPWload {sym} [off] ptr x mem)
   200		// cond:
   201		// result: (CMPW (MOVWload {sym} [off] ptr mem) x)
   202		for {
   203			off := v.AuxInt
   204			sym := v.Aux
   205			mem := v.Args[2]
   206			ptr := v.Args[0]
   207			x := v.Args[1]
   208			v.reset(OpAMD64CMPW)
   209			v0 := b.NewValue0(v.Pos, OpAMD64MOVWload, typ.UInt16)
   210			v0.AuxInt = off
   211			v0.Aux = sym
   212			v0.AddArg(ptr)
   213			v0.AddArg(mem)
   214			v.AddArg(v0)
   215			v.AddArg(x)
   216			return true
   217		}
   218	}
   219	func rewriteBlockAMD64splitload(b *Block) bool {
   220		config := b.Func.Config
   221		typ := &config.Types
   222		_ = typ
   223		v := b.Control
   224		_ = v
   225		switch b.Kind {
   226		}
   227		return false
   228	}
   229	

View as plain text