Source file src/cmd/compile/internal/ssarewrite/rewriteamd64splitload/rewriteAMD64splitload.go

     1  // Code generated from _gen/AMD64splitload.rules using 'go generate'; DO NOT EDIT.
     2  
     3  package rewriteamd64splitload
     4  
     5  import "cmd/compile/internal/ssa/ssaop"
     6  import "cmd/compile/internal/ssa"
     7  
     8  func RewriteValue(v *ssa.Value) bool {
     9  	switch v.Op {
    10  	case ssaop.OpAMD64CMPBconstload:
    11  		return rewriteValue_OpAMD64CMPBconstload(v)
    12  	case ssaop.OpAMD64CMPBconstloadidx1:
    13  		return rewriteValue_OpAMD64CMPBconstloadidx1(v)
    14  	case ssaop.OpAMD64CMPBload:
    15  		return rewriteValue_OpAMD64CMPBload(v)
    16  	case ssaop.OpAMD64CMPBloadidx1:
    17  		return rewriteValue_OpAMD64CMPBloadidx1(v)
    18  	case ssaop.OpAMD64CMPLconstload:
    19  		return rewriteValue_OpAMD64CMPLconstload(v)
    20  	case ssaop.OpAMD64CMPLconstloadidx1:
    21  		return rewriteValue_OpAMD64CMPLconstloadidx1(v)
    22  	case ssaop.OpAMD64CMPLconstloadidx4:
    23  		return rewriteValue_OpAMD64CMPLconstloadidx4(v)
    24  	case ssaop.OpAMD64CMPLload:
    25  		return rewriteValue_OpAMD64CMPLload(v)
    26  	case ssaop.OpAMD64CMPLloadidx1:
    27  		return rewriteValue_OpAMD64CMPLloadidx1(v)
    28  	case ssaop.OpAMD64CMPLloadidx4:
    29  		return rewriteValue_OpAMD64CMPLloadidx4(v)
    30  	case ssaop.OpAMD64CMPQconstload:
    31  		return rewriteValue_OpAMD64CMPQconstload(v)
    32  	case ssaop.OpAMD64CMPQconstloadidx1:
    33  		return rewriteValue_OpAMD64CMPQconstloadidx1(v)
    34  	case ssaop.OpAMD64CMPQconstloadidx8:
    35  		return rewriteValue_OpAMD64CMPQconstloadidx8(v)
    36  	case ssaop.OpAMD64CMPQload:
    37  		return rewriteValue_OpAMD64CMPQload(v)
    38  	case ssaop.OpAMD64CMPQloadidx1:
    39  		return rewriteValue_OpAMD64CMPQloadidx1(v)
    40  	case ssaop.OpAMD64CMPQloadidx8:
    41  		return rewriteValue_OpAMD64CMPQloadidx8(v)
    42  	case ssaop.OpAMD64CMPWconstload:
    43  		return rewriteValue_OpAMD64CMPWconstload(v)
    44  	case ssaop.OpAMD64CMPWconstloadidx1:
    45  		return rewriteValue_OpAMD64CMPWconstloadidx1(v)
    46  	case ssaop.OpAMD64CMPWconstloadidx2:
    47  		return rewriteValue_OpAMD64CMPWconstloadidx2(v)
    48  	case ssaop.OpAMD64CMPWload:
    49  		return rewriteValue_OpAMD64CMPWload(v)
    50  	case ssaop.OpAMD64CMPWloadidx1:
    51  		return rewriteValue_OpAMD64CMPWloadidx1(v)
    52  	case ssaop.OpAMD64CMPWloadidx2:
    53  		return rewriteValue_OpAMD64CMPWloadidx2(v)
    54  	}
    55  	return false
    56  }
    57  func rewriteValue_OpAMD64CMPBconstload(v *ssa.Value) bool {
    58  	v_1 := v.Args[1]
    59  	v_0 := v.Args[0]
    60  	b := v.Block
    61  	typ := &b.Func.Config.Types
    62  	// match: (CMPBconstload {sym} [vo] ptr mem)
    63  	// cond: vo.Val() == 0
    64  	// result: (TESTB x:(MOVBload {sym} [vo.Off()] ptr mem) x)
    65  	for {
    66  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
    67  		sym := ssa.AuxToSym(v.Aux)
    68  		ptr := v_0
    69  		mem := v_1
    70  		if !(vo.Val() == 0) {
    71  			break
    72  		}
    73  		v.Reset(ssaop.OpAMD64TESTB)
    74  		x := b.NewValue0(v.Pos, ssaop.OpAMD64MOVBload, typ.UInt8)
    75  		x.AuxInt = ssa.Int32ToAuxInt(vo.Off())
    76  		x.Aux = ssa.SymToAux(sym)
    77  		x.AddArg2(ptr, mem)
    78  		v.AddArg2(x, x)
    79  		return true
    80  	}
    81  	// match: (CMPBconstload {sym} [vo] ptr mem)
    82  	// cond: vo.Val() != 0
    83  	// result: (CMPBconst (MOVBload {sym} [vo.Off()] ptr mem) [vo.Val8()])
    84  	for {
    85  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
    86  		sym := ssa.AuxToSym(v.Aux)
    87  		ptr := v_0
    88  		mem := v_1
    89  		if !(vo.Val() != 0) {
    90  			break
    91  		}
    92  		v.Reset(ssaop.OpAMD64CMPBconst)
    93  		v.AuxInt = ssa.Int8ToAuxInt(vo.Val8())
    94  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVBload, typ.UInt8)
    95  		v0.AuxInt = ssa.Int32ToAuxInt(vo.Off())
    96  		v0.Aux = ssa.SymToAux(sym)
    97  		v0.AddArg2(ptr, mem)
    98  		v.AddArg(v0)
    99  		return true
   100  	}
   101  	return false
   102  }
   103  func rewriteValue_OpAMD64CMPBconstloadidx1(v *ssa.Value) bool {
   104  	v_2 := v.Args[2]
   105  	v_1 := v.Args[1]
   106  	v_0 := v.Args[0]
   107  	b := v.Block
   108  	typ := &b.Func.Config.Types
   109  	// match: (CMPBconstloadidx1 {sym} [vo] ptr idx mem)
   110  	// cond: vo.Val() == 0
   111  	// result: (TESTB x:(MOVBloadidx1 {sym} [vo.Off()] ptr idx mem) x)
   112  	for {
   113  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   114  		sym := ssa.AuxToSym(v.Aux)
   115  		ptr := v_0
   116  		idx := v_1
   117  		mem := v_2
   118  		if !(vo.Val() == 0) {
   119  			break
   120  		}
   121  		v.Reset(ssaop.OpAMD64TESTB)
   122  		x := b.NewValue0(v.Pos, ssaop.OpAMD64MOVBloadidx1, typ.UInt8)
   123  		x.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   124  		x.Aux = ssa.SymToAux(sym)
   125  		x.AddArg3(ptr, idx, mem)
   126  		v.AddArg2(x, x)
   127  		return true
   128  	}
   129  	// match: (CMPBconstloadidx1 {sym} [vo] ptr idx mem)
   130  	// cond: vo.Val() != 0
   131  	// result: (CMPBconst (MOVBloadidx1 {sym} [vo.Off()] ptr idx mem) [vo.Val8()])
   132  	for {
   133  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   134  		sym := ssa.AuxToSym(v.Aux)
   135  		ptr := v_0
   136  		idx := v_1
   137  		mem := v_2
   138  		if !(vo.Val() != 0) {
   139  			break
   140  		}
   141  		v.Reset(ssaop.OpAMD64CMPBconst)
   142  		v.AuxInt = ssa.Int8ToAuxInt(vo.Val8())
   143  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVBloadidx1, typ.UInt8)
   144  		v0.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   145  		v0.Aux = ssa.SymToAux(sym)
   146  		v0.AddArg3(ptr, idx, mem)
   147  		v.AddArg(v0)
   148  		return true
   149  	}
   150  	return false
   151  }
   152  func rewriteValue_OpAMD64CMPBload(v *ssa.Value) bool {
   153  	v_2 := v.Args[2]
   154  	v_1 := v.Args[1]
   155  	v_0 := v.Args[0]
   156  	b := v.Block
   157  	// match: (CMPBload {sym} [off] ptr x mem)
   158  	// result: (CMPB (MOVBload <x.Type> {sym} [off] ptr mem) x)
   159  	for {
   160  		off := ssa.AuxIntToInt32(v.AuxInt)
   161  		sym := ssa.AuxToSym(v.Aux)
   162  		ptr := v_0
   163  		x := v_1
   164  		mem := v_2
   165  		v.Reset(ssaop.OpAMD64CMPB)
   166  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVBload, x.Type)
   167  		v0.AuxInt = ssa.Int32ToAuxInt(off)
   168  		v0.Aux = ssa.SymToAux(sym)
   169  		v0.AddArg2(ptr, mem)
   170  		v.AddArg2(v0, x)
   171  		return true
   172  	}
   173  }
   174  func rewriteValue_OpAMD64CMPBloadidx1(v *ssa.Value) bool {
   175  	v_3 := v.Args[3]
   176  	v_2 := v.Args[2]
   177  	v_1 := v.Args[1]
   178  	v_0 := v.Args[0]
   179  	b := v.Block
   180  	// match: (CMPBloadidx1 {sym} [off] ptr idx x mem)
   181  	// result: (CMPB (MOVBloadidx1 <x.Type> {sym} [off] ptr idx mem) x)
   182  	for {
   183  		off := ssa.AuxIntToInt32(v.AuxInt)
   184  		sym := ssa.AuxToSym(v.Aux)
   185  		ptr := v_0
   186  		idx := v_1
   187  		x := v_2
   188  		mem := v_3
   189  		v.Reset(ssaop.OpAMD64CMPB)
   190  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVBloadidx1, x.Type)
   191  		v0.AuxInt = ssa.Int32ToAuxInt(off)
   192  		v0.Aux = ssa.SymToAux(sym)
   193  		v0.AddArg3(ptr, idx, mem)
   194  		v.AddArg2(v0, x)
   195  		return true
   196  	}
   197  }
   198  func rewriteValue_OpAMD64CMPLconstload(v *ssa.Value) bool {
   199  	v_1 := v.Args[1]
   200  	v_0 := v.Args[0]
   201  	b := v.Block
   202  	typ := &b.Func.Config.Types
   203  	// match: (CMPLconstload {sym} [vo] ptr mem)
   204  	// cond: vo.Val() == 0
   205  	// result: (TESTL x:(MOVLload {sym} [vo.Off()] ptr mem) x)
   206  	for {
   207  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   208  		sym := ssa.AuxToSym(v.Aux)
   209  		ptr := v_0
   210  		mem := v_1
   211  		if !(vo.Val() == 0) {
   212  			break
   213  		}
   214  		v.Reset(ssaop.OpAMD64TESTL)
   215  		x := b.NewValue0(v.Pos, ssaop.OpAMD64MOVLload, typ.UInt32)
   216  		x.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   217  		x.Aux = ssa.SymToAux(sym)
   218  		x.AddArg2(ptr, mem)
   219  		v.AddArg2(x, x)
   220  		return true
   221  	}
   222  	// match: (CMPLconstload {sym} [vo] ptr mem)
   223  	// cond: vo.Val() != 0
   224  	// result: (CMPLconst (MOVLload {sym} [vo.Off()] ptr mem) [vo.Val()])
   225  	for {
   226  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   227  		sym := ssa.AuxToSym(v.Aux)
   228  		ptr := v_0
   229  		mem := v_1
   230  		if !(vo.Val() != 0) {
   231  			break
   232  		}
   233  		v.Reset(ssaop.OpAMD64CMPLconst)
   234  		v.AuxInt = ssa.Int32ToAuxInt(vo.Val())
   235  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVLload, typ.UInt32)
   236  		v0.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   237  		v0.Aux = ssa.SymToAux(sym)
   238  		v0.AddArg2(ptr, mem)
   239  		v.AddArg(v0)
   240  		return true
   241  	}
   242  	return false
   243  }
   244  func rewriteValue_OpAMD64CMPLconstloadidx1(v *ssa.Value) bool {
   245  	v_2 := v.Args[2]
   246  	v_1 := v.Args[1]
   247  	v_0 := v.Args[0]
   248  	b := v.Block
   249  	typ := &b.Func.Config.Types
   250  	// match: (CMPLconstloadidx1 {sym} [vo] ptr idx mem)
   251  	// cond: vo.Val() == 0
   252  	// result: (TESTL x:(MOVLloadidx1 {sym} [vo.Off()] ptr idx mem) x)
   253  	for {
   254  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   255  		sym := ssa.AuxToSym(v.Aux)
   256  		ptr := v_0
   257  		idx := v_1
   258  		mem := v_2
   259  		if !(vo.Val() == 0) {
   260  			break
   261  		}
   262  		v.Reset(ssaop.OpAMD64TESTL)
   263  		x := b.NewValue0(v.Pos, ssaop.OpAMD64MOVLloadidx1, typ.UInt32)
   264  		x.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   265  		x.Aux = ssa.SymToAux(sym)
   266  		x.AddArg3(ptr, idx, mem)
   267  		v.AddArg2(x, x)
   268  		return true
   269  	}
   270  	// match: (CMPLconstloadidx1 {sym} [vo] ptr idx mem)
   271  	// cond: vo.Val() != 0
   272  	// result: (CMPLconst (MOVLloadidx1 {sym} [vo.Off()] ptr idx mem) [vo.Val()])
   273  	for {
   274  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   275  		sym := ssa.AuxToSym(v.Aux)
   276  		ptr := v_0
   277  		idx := v_1
   278  		mem := v_2
   279  		if !(vo.Val() != 0) {
   280  			break
   281  		}
   282  		v.Reset(ssaop.OpAMD64CMPLconst)
   283  		v.AuxInt = ssa.Int32ToAuxInt(vo.Val())
   284  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVLloadidx1, typ.UInt32)
   285  		v0.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   286  		v0.Aux = ssa.SymToAux(sym)
   287  		v0.AddArg3(ptr, idx, mem)
   288  		v.AddArg(v0)
   289  		return true
   290  	}
   291  	return false
   292  }
   293  func rewriteValue_OpAMD64CMPLconstloadidx4(v *ssa.Value) bool {
   294  	v_2 := v.Args[2]
   295  	v_1 := v.Args[1]
   296  	v_0 := v.Args[0]
   297  	b := v.Block
   298  	typ := &b.Func.Config.Types
   299  	// match: (CMPLconstloadidx4 {sym} [vo] ptr idx mem)
   300  	// cond: vo.Val() == 0
   301  	// result: (TESTL x:(MOVLloadidx4 {sym} [vo.Off()] ptr idx mem) x)
   302  	for {
   303  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   304  		sym := ssa.AuxToSym(v.Aux)
   305  		ptr := v_0
   306  		idx := v_1
   307  		mem := v_2
   308  		if !(vo.Val() == 0) {
   309  			break
   310  		}
   311  		v.Reset(ssaop.OpAMD64TESTL)
   312  		x := b.NewValue0(v.Pos, ssaop.OpAMD64MOVLloadidx4, typ.UInt32)
   313  		x.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   314  		x.Aux = ssa.SymToAux(sym)
   315  		x.AddArg3(ptr, idx, mem)
   316  		v.AddArg2(x, x)
   317  		return true
   318  	}
   319  	// match: (CMPLconstloadidx4 {sym} [vo] ptr idx mem)
   320  	// cond: vo.Val() != 0
   321  	// result: (CMPLconst (MOVLloadidx4 {sym} [vo.Off()] ptr idx mem) [vo.Val()])
   322  	for {
   323  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   324  		sym := ssa.AuxToSym(v.Aux)
   325  		ptr := v_0
   326  		idx := v_1
   327  		mem := v_2
   328  		if !(vo.Val() != 0) {
   329  			break
   330  		}
   331  		v.Reset(ssaop.OpAMD64CMPLconst)
   332  		v.AuxInt = ssa.Int32ToAuxInt(vo.Val())
   333  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVLloadidx4, typ.UInt32)
   334  		v0.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   335  		v0.Aux = ssa.SymToAux(sym)
   336  		v0.AddArg3(ptr, idx, mem)
   337  		v.AddArg(v0)
   338  		return true
   339  	}
   340  	return false
   341  }
   342  func rewriteValue_OpAMD64CMPLload(v *ssa.Value) bool {
   343  	v_2 := v.Args[2]
   344  	v_1 := v.Args[1]
   345  	v_0 := v.Args[0]
   346  	b := v.Block
   347  	// match: (CMPLload {sym} [off] ptr x mem)
   348  	// result: (CMPL (MOVLload <x.Type> {sym} [off] ptr mem) x)
   349  	for {
   350  		off := ssa.AuxIntToInt32(v.AuxInt)
   351  		sym := ssa.AuxToSym(v.Aux)
   352  		ptr := v_0
   353  		x := v_1
   354  		mem := v_2
   355  		v.Reset(ssaop.OpAMD64CMPL)
   356  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVLload, x.Type)
   357  		v0.AuxInt = ssa.Int32ToAuxInt(off)
   358  		v0.Aux = ssa.SymToAux(sym)
   359  		v0.AddArg2(ptr, mem)
   360  		v.AddArg2(v0, x)
   361  		return true
   362  	}
   363  }
   364  func rewriteValue_OpAMD64CMPLloadidx1(v *ssa.Value) bool {
   365  	v_3 := v.Args[3]
   366  	v_2 := v.Args[2]
   367  	v_1 := v.Args[1]
   368  	v_0 := v.Args[0]
   369  	b := v.Block
   370  	// match: (CMPLloadidx1 {sym} [off] ptr idx x mem)
   371  	// result: (CMPL (MOVLloadidx1 <x.Type> {sym} [off] ptr idx mem) x)
   372  	for {
   373  		off := ssa.AuxIntToInt32(v.AuxInt)
   374  		sym := ssa.AuxToSym(v.Aux)
   375  		ptr := v_0
   376  		idx := v_1
   377  		x := v_2
   378  		mem := v_3
   379  		v.Reset(ssaop.OpAMD64CMPL)
   380  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVLloadidx1, x.Type)
   381  		v0.AuxInt = ssa.Int32ToAuxInt(off)
   382  		v0.Aux = ssa.SymToAux(sym)
   383  		v0.AddArg3(ptr, idx, mem)
   384  		v.AddArg2(v0, x)
   385  		return true
   386  	}
   387  }
   388  func rewriteValue_OpAMD64CMPLloadidx4(v *ssa.Value) bool {
   389  	v_3 := v.Args[3]
   390  	v_2 := v.Args[2]
   391  	v_1 := v.Args[1]
   392  	v_0 := v.Args[0]
   393  	b := v.Block
   394  	// match: (CMPLloadidx4 {sym} [off] ptr idx x mem)
   395  	// result: (CMPL (MOVLloadidx4 <x.Type> {sym} [off] ptr idx mem) x)
   396  	for {
   397  		off := ssa.AuxIntToInt32(v.AuxInt)
   398  		sym := ssa.AuxToSym(v.Aux)
   399  		ptr := v_0
   400  		idx := v_1
   401  		x := v_2
   402  		mem := v_3
   403  		v.Reset(ssaop.OpAMD64CMPL)
   404  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVLloadidx4, x.Type)
   405  		v0.AuxInt = ssa.Int32ToAuxInt(off)
   406  		v0.Aux = ssa.SymToAux(sym)
   407  		v0.AddArg3(ptr, idx, mem)
   408  		v.AddArg2(v0, x)
   409  		return true
   410  	}
   411  }
   412  func rewriteValue_OpAMD64CMPQconstload(v *ssa.Value) bool {
   413  	v_1 := v.Args[1]
   414  	v_0 := v.Args[0]
   415  	b := v.Block
   416  	typ := &b.Func.Config.Types
   417  	// match: (CMPQconstload {sym} [vo] ptr mem)
   418  	// cond: vo.Val() == 0
   419  	// result: (TESTQ x:(MOVQload {sym} [vo.Off()] ptr mem) x)
   420  	for {
   421  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   422  		sym := ssa.AuxToSym(v.Aux)
   423  		ptr := v_0
   424  		mem := v_1
   425  		if !(vo.Val() == 0) {
   426  			break
   427  		}
   428  		v.Reset(ssaop.OpAMD64TESTQ)
   429  		x := b.NewValue0(v.Pos, ssaop.OpAMD64MOVQload, typ.UInt64)
   430  		x.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   431  		x.Aux = ssa.SymToAux(sym)
   432  		x.AddArg2(ptr, mem)
   433  		v.AddArg2(x, x)
   434  		return true
   435  	}
   436  	// match: (CMPQconstload {sym} [vo] ptr mem)
   437  	// cond: vo.Val() != 0
   438  	// result: (CMPQconst (MOVQload {sym} [vo.Off()] ptr mem) [vo.Val()])
   439  	for {
   440  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   441  		sym := ssa.AuxToSym(v.Aux)
   442  		ptr := v_0
   443  		mem := v_1
   444  		if !(vo.Val() != 0) {
   445  			break
   446  		}
   447  		v.Reset(ssaop.OpAMD64CMPQconst)
   448  		v.AuxInt = ssa.Int32ToAuxInt(vo.Val())
   449  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVQload, typ.UInt64)
   450  		v0.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   451  		v0.Aux = ssa.SymToAux(sym)
   452  		v0.AddArg2(ptr, mem)
   453  		v.AddArg(v0)
   454  		return true
   455  	}
   456  	return false
   457  }
   458  func rewriteValue_OpAMD64CMPQconstloadidx1(v *ssa.Value) bool {
   459  	v_2 := v.Args[2]
   460  	v_1 := v.Args[1]
   461  	v_0 := v.Args[0]
   462  	b := v.Block
   463  	typ := &b.Func.Config.Types
   464  	// match: (CMPQconstloadidx1 {sym} [vo] ptr idx mem)
   465  	// cond: vo.Val() == 0
   466  	// result: (TESTQ x:(MOVQloadidx1 {sym} [vo.Off()] ptr idx mem) x)
   467  	for {
   468  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   469  		sym := ssa.AuxToSym(v.Aux)
   470  		ptr := v_0
   471  		idx := v_1
   472  		mem := v_2
   473  		if !(vo.Val() == 0) {
   474  			break
   475  		}
   476  		v.Reset(ssaop.OpAMD64TESTQ)
   477  		x := b.NewValue0(v.Pos, ssaop.OpAMD64MOVQloadidx1, typ.UInt64)
   478  		x.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   479  		x.Aux = ssa.SymToAux(sym)
   480  		x.AddArg3(ptr, idx, mem)
   481  		v.AddArg2(x, x)
   482  		return true
   483  	}
   484  	// match: (CMPQconstloadidx1 {sym} [vo] ptr idx mem)
   485  	// cond: vo.Val() != 0
   486  	// result: (CMPQconst (MOVQloadidx1 {sym} [vo.Off()] ptr idx mem) [vo.Val()])
   487  	for {
   488  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   489  		sym := ssa.AuxToSym(v.Aux)
   490  		ptr := v_0
   491  		idx := v_1
   492  		mem := v_2
   493  		if !(vo.Val() != 0) {
   494  			break
   495  		}
   496  		v.Reset(ssaop.OpAMD64CMPQconst)
   497  		v.AuxInt = ssa.Int32ToAuxInt(vo.Val())
   498  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVQloadidx1, typ.UInt64)
   499  		v0.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   500  		v0.Aux = ssa.SymToAux(sym)
   501  		v0.AddArg3(ptr, idx, mem)
   502  		v.AddArg(v0)
   503  		return true
   504  	}
   505  	return false
   506  }
   507  func rewriteValue_OpAMD64CMPQconstloadidx8(v *ssa.Value) bool {
   508  	v_2 := v.Args[2]
   509  	v_1 := v.Args[1]
   510  	v_0 := v.Args[0]
   511  	b := v.Block
   512  	typ := &b.Func.Config.Types
   513  	// match: (CMPQconstloadidx8 {sym} [vo] ptr idx mem)
   514  	// cond: vo.Val() == 0
   515  	// result: (TESTQ x:(MOVQloadidx8 {sym} [vo.Off()] ptr idx mem) x)
   516  	for {
   517  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   518  		sym := ssa.AuxToSym(v.Aux)
   519  		ptr := v_0
   520  		idx := v_1
   521  		mem := v_2
   522  		if !(vo.Val() == 0) {
   523  			break
   524  		}
   525  		v.Reset(ssaop.OpAMD64TESTQ)
   526  		x := b.NewValue0(v.Pos, ssaop.OpAMD64MOVQloadidx8, typ.UInt64)
   527  		x.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   528  		x.Aux = ssa.SymToAux(sym)
   529  		x.AddArg3(ptr, idx, mem)
   530  		v.AddArg2(x, x)
   531  		return true
   532  	}
   533  	// match: (CMPQconstloadidx8 {sym} [vo] ptr idx mem)
   534  	// cond: vo.Val() != 0
   535  	// result: (CMPQconst (MOVQloadidx8 {sym} [vo.Off()] ptr idx mem) [vo.Val()])
   536  	for {
   537  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   538  		sym := ssa.AuxToSym(v.Aux)
   539  		ptr := v_0
   540  		idx := v_1
   541  		mem := v_2
   542  		if !(vo.Val() != 0) {
   543  			break
   544  		}
   545  		v.Reset(ssaop.OpAMD64CMPQconst)
   546  		v.AuxInt = ssa.Int32ToAuxInt(vo.Val())
   547  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVQloadidx8, typ.UInt64)
   548  		v0.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   549  		v0.Aux = ssa.SymToAux(sym)
   550  		v0.AddArg3(ptr, idx, mem)
   551  		v.AddArg(v0)
   552  		return true
   553  	}
   554  	return false
   555  }
   556  func rewriteValue_OpAMD64CMPQload(v *ssa.Value) bool {
   557  	v_2 := v.Args[2]
   558  	v_1 := v.Args[1]
   559  	v_0 := v.Args[0]
   560  	b := v.Block
   561  	// match: (CMPQload {sym} [off] ptr x mem)
   562  	// result: (CMPQ (MOVQload <x.Type> {sym} [off] ptr mem) x)
   563  	for {
   564  		off := ssa.AuxIntToInt32(v.AuxInt)
   565  		sym := ssa.AuxToSym(v.Aux)
   566  		ptr := v_0
   567  		x := v_1
   568  		mem := v_2
   569  		v.Reset(ssaop.OpAMD64CMPQ)
   570  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVQload, x.Type)
   571  		v0.AuxInt = ssa.Int32ToAuxInt(off)
   572  		v0.Aux = ssa.SymToAux(sym)
   573  		v0.AddArg2(ptr, mem)
   574  		v.AddArg2(v0, x)
   575  		return true
   576  	}
   577  }
   578  func rewriteValue_OpAMD64CMPQloadidx1(v *ssa.Value) bool {
   579  	v_3 := v.Args[3]
   580  	v_2 := v.Args[2]
   581  	v_1 := v.Args[1]
   582  	v_0 := v.Args[0]
   583  	b := v.Block
   584  	// match: (CMPQloadidx1 {sym} [off] ptr idx x mem)
   585  	// result: (CMPQ (MOVQloadidx1 <x.Type> {sym} [off] ptr idx mem) x)
   586  	for {
   587  		off := ssa.AuxIntToInt32(v.AuxInt)
   588  		sym := ssa.AuxToSym(v.Aux)
   589  		ptr := v_0
   590  		idx := v_1
   591  		x := v_2
   592  		mem := v_3
   593  		v.Reset(ssaop.OpAMD64CMPQ)
   594  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVQloadidx1, x.Type)
   595  		v0.AuxInt = ssa.Int32ToAuxInt(off)
   596  		v0.Aux = ssa.SymToAux(sym)
   597  		v0.AddArg3(ptr, idx, mem)
   598  		v.AddArg2(v0, x)
   599  		return true
   600  	}
   601  }
   602  func rewriteValue_OpAMD64CMPQloadidx8(v *ssa.Value) bool {
   603  	v_3 := v.Args[3]
   604  	v_2 := v.Args[2]
   605  	v_1 := v.Args[1]
   606  	v_0 := v.Args[0]
   607  	b := v.Block
   608  	// match: (CMPQloadidx8 {sym} [off] ptr idx x mem)
   609  	// result: (CMPQ (MOVQloadidx8 <x.Type> {sym} [off] ptr idx mem) x)
   610  	for {
   611  		off := ssa.AuxIntToInt32(v.AuxInt)
   612  		sym := ssa.AuxToSym(v.Aux)
   613  		ptr := v_0
   614  		idx := v_1
   615  		x := v_2
   616  		mem := v_3
   617  		v.Reset(ssaop.OpAMD64CMPQ)
   618  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVQloadidx8, x.Type)
   619  		v0.AuxInt = ssa.Int32ToAuxInt(off)
   620  		v0.Aux = ssa.SymToAux(sym)
   621  		v0.AddArg3(ptr, idx, mem)
   622  		v.AddArg2(v0, x)
   623  		return true
   624  	}
   625  }
   626  func rewriteValue_OpAMD64CMPWconstload(v *ssa.Value) bool {
   627  	v_1 := v.Args[1]
   628  	v_0 := v.Args[0]
   629  	b := v.Block
   630  	typ := &b.Func.Config.Types
   631  	// match: (CMPWconstload {sym} [vo] ptr mem)
   632  	// cond: vo.Val() == 0
   633  	// result: (TESTW x:(MOVWload {sym} [vo.Off()] ptr mem) x)
   634  	for {
   635  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   636  		sym := ssa.AuxToSym(v.Aux)
   637  		ptr := v_0
   638  		mem := v_1
   639  		if !(vo.Val() == 0) {
   640  			break
   641  		}
   642  		v.Reset(ssaop.OpAMD64TESTW)
   643  		x := b.NewValue0(v.Pos, ssaop.OpAMD64MOVWload, typ.UInt16)
   644  		x.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   645  		x.Aux = ssa.SymToAux(sym)
   646  		x.AddArg2(ptr, mem)
   647  		v.AddArg2(x, x)
   648  		return true
   649  	}
   650  	// match: (CMPWconstload {sym} [vo] ptr mem)
   651  	// cond: vo.Val() != 0
   652  	// result: (CMPWconst (MOVWload {sym} [vo.Off()] ptr mem) [vo.Val16()])
   653  	for {
   654  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   655  		sym := ssa.AuxToSym(v.Aux)
   656  		ptr := v_0
   657  		mem := v_1
   658  		if !(vo.Val() != 0) {
   659  			break
   660  		}
   661  		v.Reset(ssaop.OpAMD64CMPWconst)
   662  		v.AuxInt = ssa.Int16ToAuxInt(vo.Val16())
   663  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVWload, typ.UInt16)
   664  		v0.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   665  		v0.Aux = ssa.SymToAux(sym)
   666  		v0.AddArg2(ptr, mem)
   667  		v.AddArg(v0)
   668  		return true
   669  	}
   670  	return false
   671  }
   672  func rewriteValue_OpAMD64CMPWconstloadidx1(v *ssa.Value) bool {
   673  	v_2 := v.Args[2]
   674  	v_1 := v.Args[1]
   675  	v_0 := v.Args[0]
   676  	b := v.Block
   677  	typ := &b.Func.Config.Types
   678  	// match: (CMPWconstloadidx1 {sym} [vo] ptr idx mem)
   679  	// cond: vo.Val() == 0
   680  	// result: (TESTW x:(MOVWloadidx1 {sym} [vo.Off()] ptr idx mem) x)
   681  	for {
   682  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   683  		sym := ssa.AuxToSym(v.Aux)
   684  		ptr := v_0
   685  		idx := v_1
   686  		mem := v_2
   687  		if !(vo.Val() == 0) {
   688  			break
   689  		}
   690  		v.Reset(ssaop.OpAMD64TESTW)
   691  		x := b.NewValue0(v.Pos, ssaop.OpAMD64MOVWloadidx1, typ.UInt16)
   692  		x.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   693  		x.Aux = ssa.SymToAux(sym)
   694  		x.AddArg3(ptr, idx, mem)
   695  		v.AddArg2(x, x)
   696  		return true
   697  	}
   698  	// match: (CMPWconstloadidx1 {sym} [vo] ptr idx mem)
   699  	// cond: vo.Val() != 0
   700  	// result: (CMPWconst (MOVWloadidx1 {sym} [vo.Off()] ptr idx mem) [vo.Val16()])
   701  	for {
   702  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   703  		sym := ssa.AuxToSym(v.Aux)
   704  		ptr := v_0
   705  		idx := v_1
   706  		mem := v_2
   707  		if !(vo.Val() != 0) {
   708  			break
   709  		}
   710  		v.Reset(ssaop.OpAMD64CMPWconst)
   711  		v.AuxInt = ssa.Int16ToAuxInt(vo.Val16())
   712  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVWloadidx1, typ.UInt16)
   713  		v0.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   714  		v0.Aux = ssa.SymToAux(sym)
   715  		v0.AddArg3(ptr, idx, mem)
   716  		v.AddArg(v0)
   717  		return true
   718  	}
   719  	return false
   720  }
   721  func rewriteValue_OpAMD64CMPWconstloadidx2(v *ssa.Value) bool {
   722  	v_2 := v.Args[2]
   723  	v_1 := v.Args[1]
   724  	v_0 := v.Args[0]
   725  	b := v.Block
   726  	typ := &b.Func.Config.Types
   727  	// match: (CMPWconstloadidx2 {sym} [vo] ptr idx mem)
   728  	// cond: vo.Val() == 0
   729  	// result: (TESTW x:(MOVWloadidx2 {sym} [vo.Off()] ptr idx mem) x)
   730  	for {
   731  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   732  		sym := ssa.AuxToSym(v.Aux)
   733  		ptr := v_0
   734  		idx := v_1
   735  		mem := v_2
   736  		if !(vo.Val() == 0) {
   737  			break
   738  		}
   739  		v.Reset(ssaop.OpAMD64TESTW)
   740  		x := b.NewValue0(v.Pos, ssaop.OpAMD64MOVWloadidx2, typ.UInt16)
   741  		x.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   742  		x.Aux = ssa.SymToAux(sym)
   743  		x.AddArg3(ptr, idx, mem)
   744  		v.AddArg2(x, x)
   745  		return true
   746  	}
   747  	// match: (CMPWconstloadidx2 {sym} [vo] ptr idx mem)
   748  	// cond: vo.Val() != 0
   749  	// result: (CMPWconst (MOVWloadidx2 {sym} [vo.Off()] ptr idx mem) [vo.Val16()])
   750  	for {
   751  		vo := ssa.AuxIntToValAndOff(v.AuxInt)
   752  		sym := ssa.AuxToSym(v.Aux)
   753  		ptr := v_0
   754  		idx := v_1
   755  		mem := v_2
   756  		if !(vo.Val() != 0) {
   757  			break
   758  		}
   759  		v.Reset(ssaop.OpAMD64CMPWconst)
   760  		v.AuxInt = ssa.Int16ToAuxInt(vo.Val16())
   761  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVWloadidx2, typ.UInt16)
   762  		v0.AuxInt = ssa.Int32ToAuxInt(vo.Off())
   763  		v0.Aux = ssa.SymToAux(sym)
   764  		v0.AddArg3(ptr, idx, mem)
   765  		v.AddArg(v0)
   766  		return true
   767  	}
   768  	return false
   769  }
   770  func rewriteValue_OpAMD64CMPWload(v *ssa.Value) bool {
   771  	v_2 := v.Args[2]
   772  	v_1 := v.Args[1]
   773  	v_0 := v.Args[0]
   774  	b := v.Block
   775  	// match: (CMPWload {sym} [off] ptr x mem)
   776  	// result: (CMPW (MOVWload <x.Type> {sym} [off] ptr mem) x)
   777  	for {
   778  		off := ssa.AuxIntToInt32(v.AuxInt)
   779  		sym := ssa.AuxToSym(v.Aux)
   780  		ptr := v_0
   781  		x := v_1
   782  		mem := v_2
   783  		v.Reset(ssaop.OpAMD64CMPW)
   784  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVWload, x.Type)
   785  		v0.AuxInt = ssa.Int32ToAuxInt(off)
   786  		v0.Aux = ssa.SymToAux(sym)
   787  		v0.AddArg2(ptr, mem)
   788  		v.AddArg2(v0, x)
   789  		return true
   790  	}
   791  }
   792  func rewriteValue_OpAMD64CMPWloadidx1(v *ssa.Value) bool {
   793  	v_3 := v.Args[3]
   794  	v_2 := v.Args[2]
   795  	v_1 := v.Args[1]
   796  	v_0 := v.Args[0]
   797  	b := v.Block
   798  	// match: (CMPWloadidx1 {sym} [off] ptr idx x mem)
   799  	// result: (CMPW (MOVWloadidx1 <x.Type> {sym} [off] ptr idx mem) x)
   800  	for {
   801  		off := ssa.AuxIntToInt32(v.AuxInt)
   802  		sym := ssa.AuxToSym(v.Aux)
   803  		ptr := v_0
   804  		idx := v_1
   805  		x := v_2
   806  		mem := v_3
   807  		v.Reset(ssaop.OpAMD64CMPW)
   808  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVWloadidx1, x.Type)
   809  		v0.AuxInt = ssa.Int32ToAuxInt(off)
   810  		v0.Aux = ssa.SymToAux(sym)
   811  		v0.AddArg3(ptr, idx, mem)
   812  		v.AddArg2(v0, x)
   813  		return true
   814  	}
   815  }
   816  func rewriteValue_OpAMD64CMPWloadidx2(v *ssa.Value) bool {
   817  	v_3 := v.Args[3]
   818  	v_2 := v.Args[2]
   819  	v_1 := v.Args[1]
   820  	v_0 := v.Args[0]
   821  	b := v.Block
   822  	// match: (CMPWloadidx2 {sym} [off] ptr idx x mem)
   823  	// result: (CMPW (MOVWloadidx2 <x.Type> {sym} [off] ptr idx mem) x)
   824  	for {
   825  		off := ssa.AuxIntToInt32(v.AuxInt)
   826  		sym := ssa.AuxToSym(v.Aux)
   827  		ptr := v_0
   828  		idx := v_1
   829  		x := v_2
   830  		mem := v_3
   831  		v.Reset(ssaop.OpAMD64CMPW)
   832  		v0 := b.NewValue0(v.Pos, ssaop.OpAMD64MOVWloadidx2, x.Type)
   833  		v0.AuxInt = ssa.Int32ToAuxInt(off)
   834  		v0.Aux = ssa.SymToAux(sym)
   835  		v0.AddArg3(ptr, idx, mem)
   836  		v.AddArg2(v0, x)
   837  		return true
   838  	}
   839  }
   840  func RewriteBlock(b *ssa.Block) bool {
   841  	return false
   842  }
   843  

View as plain text