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

     1	// Code generated from gen/386splitload.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 rewriteValue386splitload(v *Value) bool {
    19		switch v.Op {
    20		case Op386CMPBconstload:
    21			return rewriteValue386splitload_Op386CMPBconstload_0(v)
    22		case Op386CMPBload:
    23			return rewriteValue386splitload_Op386CMPBload_0(v)
    24		case Op386CMPLconstload:
    25			return rewriteValue386splitload_Op386CMPLconstload_0(v)
    26		case Op386CMPLload:
    27			return rewriteValue386splitload_Op386CMPLload_0(v)
    28		case Op386CMPWconstload:
    29			return rewriteValue386splitload_Op386CMPWconstload_0(v)
    30		case Op386CMPWload:
    31			return rewriteValue386splitload_Op386CMPWload_0(v)
    32		}
    33		return false
    34	}
    35	func rewriteValue386splitload_Op386CMPBconstload_0(v *Value) bool {
    36		b := v.Block
    37		typ := &b.Func.Config.Types
    38		// match: (CMPBconstload {sym} [vo] ptr mem)
    39		// cond:
    40		// result: (CMPBconst (MOVBload {sym} [offOnly(vo)] ptr mem) [valOnly(vo)])
    41		for {
    42			vo := v.AuxInt
    43			sym := v.Aux
    44			mem := v.Args[1]
    45			ptr := v.Args[0]
    46			v.reset(Op386CMPBconst)
    47			v.AuxInt = valOnly(vo)
    48			v0 := b.NewValue0(v.Pos, Op386MOVBload, typ.UInt8)
    49			v0.AuxInt = offOnly(vo)
    50			v0.Aux = sym
    51			v0.AddArg(ptr)
    52			v0.AddArg(mem)
    53			v.AddArg(v0)
    54			return true
    55		}
    56	}
    57	func rewriteValue386splitload_Op386CMPBload_0(v *Value) bool {
    58		b := v.Block
    59		typ := &b.Func.Config.Types
    60		// match: (CMPBload {sym} [off] ptr x mem)
    61		// cond:
    62		// result: (CMPB (MOVBload {sym} [off] ptr mem) x)
    63		for {
    64			off := v.AuxInt
    65			sym := v.Aux
    66			mem := v.Args[2]
    67			ptr := v.Args[0]
    68			x := v.Args[1]
    69			v.reset(Op386CMPB)
    70			v0 := b.NewValue0(v.Pos, Op386MOVBload, typ.UInt8)
    71			v0.AuxInt = off
    72			v0.Aux = sym
    73			v0.AddArg(ptr)
    74			v0.AddArg(mem)
    75			v.AddArg(v0)
    76			v.AddArg(x)
    77			return true
    78		}
    79	}
    80	func rewriteValue386splitload_Op386CMPLconstload_0(v *Value) bool {
    81		b := v.Block
    82		typ := &b.Func.Config.Types
    83		// match: (CMPLconstload {sym} [vo] ptr mem)
    84		// cond:
    85		// result: (CMPLconst (MOVLload {sym} [offOnly(vo)] ptr mem) [valOnly(vo)])
    86		for {
    87			vo := v.AuxInt
    88			sym := v.Aux
    89			mem := v.Args[1]
    90			ptr := v.Args[0]
    91			v.reset(Op386CMPLconst)
    92			v.AuxInt = valOnly(vo)
    93			v0 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
    94			v0.AuxInt = offOnly(vo)
    95			v0.Aux = sym
    96			v0.AddArg(ptr)
    97			v0.AddArg(mem)
    98			v.AddArg(v0)
    99			return true
   100		}
   101	}
   102	func rewriteValue386splitload_Op386CMPLload_0(v *Value) bool {
   103		b := v.Block
   104		typ := &b.Func.Config.Types
   105		// match: (CMPLload {sym} [off] ptr x mem)
   106		// cond:
   107		// result: (CMPL (MOVLload {sym} [off] ptr mem) x)
   108		for {
   109			off := v.AuxInt
   110			sym := v.Aux
   111			mem := v.Args[2]
   112			ptr := v.Args[0]
   113			x := v.Args[1]
   114			v.reset(Op386CMPL)
   115			v0 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
   116			v0.AuxInt = off
   117			v0.Aux = sym
   118			v0.AddArg(ptr)
   119			v0.AddArg(mem)
   120			v.AddArg(v0)
   121			v.AddArg(x)
   122			return true
   123		}
   124	}
   125	func rewriteValue386splitload_Op386CMPWconstload_0(v *Value) bool {
   126		b := v.Block
   127		typ := &b.Func.Config.Types
   128		// match: (CMPWconstload {sym} [vo] ptr mem)
   129		// cond:
   130		// result: (CMPWconst (MOVWload {sym} [offOnly(vo)] ptr mem) [valOnly(vo)])
   131		for {
   132			vo := v.AuxInt
   133			sym := v.Aux
   134			mem := v.Args[1]
   135			ptr := v.Args[0]
   136			v.reset(Op386CMPWconst)
   137			v.AuxInt = valOnly(vo)
   138			v0 := b.NewValue0(v.Pos, Op386MOVWload, typ.UInt16)
   139			v0.AuxInt = offOnly(vo)
   140			v0.Aux = sym
   141			v0.AddArg(ptr)
   142			v0.AddArg(mem)
   143			v.AddArg(v0)
   144			return true
   145		}
   146	}
   147	func rewriteValue386splitload_Op386CMPWload_0(v *Value) bool {
   148		b := v.Block
   149		typ := &b.Func.Config.Types
   150		// match: (CMPWload {sym} [off] ptr x mem)
   151		// cond:
   152		// result: (CMPW (MOVWload {sym} [off] ptr mem) x)
   153		for {
   154			off := v.AuxInt
   155			sym := v.Aux
   156			mem := v.Args[2]
   157			ptr := v.Args[0]
   158			x := v.Args[1]
   159			v.reset(Op386CMPW)
   160			v0 := b.NewValue0(v.Pos, Op386MOVWload, typ.UInt16)
   161			v0.AuxInt = off
   162			v0.Aux = sym
   163			v0.AddArg(ptr)
   164			v0.AddArg(mem)
   165			v.AddArg(v0)
   166			v.AddArg(x)
   167			return true
   168		}
   169	}
   170	func rewriteBlock386splitload(b *Block) bool {
   171		config := b.Func.Config
   172		typ := &config.Types
   173		_ = typ
   174		v := b.Control
   175		_ = v
   176		switch b.Kind {
   177		}
   178		return false
   179	}
   180	

View as plain text