Source file src/cmd/compile/internal/ssarewrite/rewriteloong64latelower/rewriteLOONG64latelower.go

     1  // Code generated from _gen/LOONG64latelower.rules using 'go generate'; DO NOT EDIT.
     2  
     3  package rewriteloong64latelower
     4  
     5  import "cmd/compile/internal/ssa/block"
     6  import "cmd/compile/internal/ssa/ssaop"
     7  import "cmd/compile/internal/ssa"
     8  
     9  func RewriteValue(v *ssa.Value) bool {
    10  	switch v.Op {
    11  	case ssaop.OpLOONG64MOVBUreg:
    12  		return rewriteValue_OpLOONG64MOVBUreg(v)
    13  	case ssaop.OpLOONG64MOVBreg:
    14  		return rewriteValue_OpLOONG64MOVBreg(v)
    15  	case ssaop.OpLOONG64MOVHUreg:
    16  		return rewriteValue_OpLOONG64MOVHUreg(v)
    17  	case ssaop.OpLOONG64MOVHreg:
    18  		return rewriteValue_OpLOONG64MOVHreg(v)
    19  	case ssaop.OpLOONG64MOVVconst:
    20  		return rewriteValue_OpLOONG64MOVVconst(v)
    21  	case ssaop.OpLOONG64MOVVnop:
    22  		return rewriteValue_OpLOONG64MOVVnop(v)
    23  	case ssaop.OpLOONG64MOVVreg:
    24  		return rewriteValue_OpLOONG64MOVVreg(v)
    25  	case ssaop.OpLOONG64MOVWUreg:
    26  		return rewriteValue_OpLOONG64MOVWUreg(v)
    27  	case ssaop.OpLOONG64MOVWreg:
    28  		return rewriteValue_OpLOONG64MOVWreg(v)
    29  	case ssaop.OpLOONG64SLLVconst:
    30  		return rewriteValue_OpLOONG64SLLVconst(v)
    31  	}
    32  	return false
    33  }
    34  func rewriteValue_OpLOONG64MOVBUreg(v *ssa.Value) bool {
    35  	v_0 := v.Args[0]
    36  	// match: (MOVBUreg x)
    37  	// cond: ssa.ZeroUpper56Bits(x)
    38  	// result: x
    39  	for {
    40  		x := v_0
    41  		if !(ssa.ZeroUpper56Bits(x)) {
    42  			break
    43  		}
    44  		v.CopyOf(x)
    45  		return true
    46  	}
    47  	// match: (MOVBUreg x:(MOVBUload _ _))
    48  	// result: (MOVVreg x)
    49  	for {
    50  		x := v_0
    51  		if x.Op != ssaop.OpLOONG64MOVBUload {
    52  			break
    53  		}
    54  		v.Reset(ssaop.OpLOONG64MOVVreg)
    55  		v.AddArg(x)
    56  		return true
    57  	}
    58  	// match: (MOVBUreg x:(MOVBUloadidx _ _ _))
    59  	// result: (MOVVreg x)
    60  	for {
    61  		x := v_0
    62  		if x.Op != ssaop.OpLOONG64MOVBUloadidx {
    63  			break
    64  		}
    65  		v.Reset(ssaop.OpLOONG64MOVVreg)
    66  		v.AddArg(x)
    67  		return true
    68  	}
    69  	// match: (MOVBUreg x:(MOVBUreg _))
    70  	// result: (MOVVreg x)
    71  	for {
    72  		x := v_0
    73  		if x.Op != ssaop.OpLOONG64MOVBUreg {
    74  			break
    75  		}
    76  		v.Reset(ssaop.OpLOONG64MOVVreg)
    77  		v.AddArg(x)
    78  		return true
    79  	}
    80  	return false
    81  }
    82  func rewriteValue_OpLOONG64MOVBreg(v *ssa.Value) bool {
    83  	v_0 := v.Args[0]
    84  	// match: (MOVBreg x:(MOVBload _ _))
    85  	// result: (MOVVreg x)
    86  	for {
    87  		x := v_0
    88  		if x.Op != ssaop.OpLOONG64MOVBload {
    89  			break
    90  		}
    91  		v.Reset(ssaop.OpLOONG64MOVVreg)
    92  		v.AddArg(x)
    93  		return true
    94  	}
    95  	// match: (MOVBreg x:(MOVBloadidx _ _ _))
    96  	// result: (MOVVreg x)
    97  	for {
    98  		x := v_0
    99  		if x.Op != ssaop.OpLOONG64MOVBloadidx {
   100  			break
   101  		}
   102  		v.Reset(ssaop.OpLOONG64MOVVreg)
   103  		v.AddArg(x)
   104  		return true
   105  	}
   106  	// match: (MOVBreg x:(MOVBreg _))
   107  	// result: (MOVVreg x)
   108  	for {
   109  		x := v_0
   110  		if x.Op != ssaop.OpLOONG64MOVBreg {
   111  			break
   112  		}
   113  		v.Reset(ssaop.OpLOONG64MOVVreg)
   114  		v.AddArg(x)
   115  		return true
   116  	}
   117  	return false
   118  }
   119  func rewriteValue_OpLOONG64MOVHUreg(v *ssa.Value) bool {
   120  	v_0 := v.Args[0]
   121  	// match: (MOVHUreg x)
   122  	// cond: ssa.ZeroUpper48Bits(x)
   123  	// result: x
   124  	for {
   125  		x := v_0
   126  		if !(ssa.ZeroUpper48Bits(x)) {
   127  			break
   128  		}
   129  		v.CopyOf(x)
   130  		return true
   131  	}
   132  	// match: (MOVHUreg x:(MOVBUload _ _))
   133  	// result: (MOVVreg x)
   134  	for {
   135  		x := v_0
   136  		if x.Op != ssaop.OpLOONG64MOVBUload {
   137  			break
   138  		}
   139  		v.Reset(ssaop.OpLOONG64MOVVreg)
   140  		v.AddArg(x)
   141  		return true
   142  	}
   143  	// match: (MOVHUreg x:(MOVHUload _ _))
   144  	// result: (MOVVreg x)
   145  	for {
   146  		x := v_0
   147  		if x.Op != ssaop.OpLOONG64MOVHUload {
   148  			break
   149  		}
   150  		v.Reset(ssaop.OpLOONG64MOVVreg)
   151  		v.AddArg(x)
   152  		return true
   153  	}
   154  	// match: (MOVHUreg x:(MOVBUloadidx _ _ _))
   155  	// result: (MOVVreg x)
   156  	for {
   157  		x := v_0
   158  		if x.Op != ssaop.OpLOONG64MOVBUloadidx {
   159  			break
   160  		}
   161  		v.Reset(ssaop.OpLOONG64MOVVreg)
   162  		v.AddArg(x)
   163  		return true
   164  	}
   165  	// match: (MOVHUreg x:(MOVHUloadidx _ _ _))
   166  	// result: (MOVVreg x)
   167  	for {
   168  		x := v_0
   169  		if x.Op != ssaop.OpLOONG64MOVHUloadidx {
   170  			break
   171  		}
   172  		v.Reset(ssaop.OpLOONG64MOVVreg)
   173  		v.AddArg(x)
   174  		return true
   175  	}
   176  	// match: (MOVHUreg x:(MOVBUreg _))
   177  	// result: (MOVVreg x)
   178  	for {
   179  		x := v_0
   180  		if x.Op != ssaop.OpLOONG64MOVBUreg {
   181  			break
   182  		}
   183  		v.Reset(ssaop.OpLOONG64MOVVreg)
   184  		v.AddArg(x)
   185  		return true
   186  	}
   187  	// match: (MOVHUreg x:(MOVHUreg _))
   188  	// result: (MOVVreg x)
   189  	for {
   190  		x := v_0
   191  		if x.Op != ssaop.OpLOONG64MOVHUreg {
   192  			break
   193  		}
   194  		v.Reset(ssaop.OpLOONG64MOVVreg)
   195  		v.AddArg(x)
   196  		return true
   197  	}
   198  	return false
   199  }
   200  func rewriteValue_OpLOONG64MOVHreg(v *ssa.Value) bool {
   201  	v_0 := v.Args[0]
   202  	// match: (MOVHreg x:(MOVBload _ _))
   203  	// result: (MOVVreg x)
   204  	for {
   205  		x := v_0
   206  		if x.Op != ssaop.OpLOONG64MOVBload {
   207  			break
   208  		}
   209  		v.Reset(ssaop.OpLOONG64MOVVreg)
   210  		v.AddArg(x)
   211  		return true
   212  	}
   213  	// match: (MOVHreg x:(MOVBUload _ _))
   214  	// result: (MOVVreg x)
   215  	for {
   216  		x := v_0
   217  		if x.Op != ssaop.OpLOONG64MOVBUload {
   218  			break
   219  		}
   220  		v.Reset(ssaop.OpLOONG64MOVVreg)
   221  		v.AddArg(x)
   222  		return true
   223  	}
   224  	// match: (MOVHreg x:(MOVHload _ _))
   225  	// result: (MOVVreg x)
   226  	for {
   227  		x := v_0
   228  		if x.Op != ssaop.OpLOONG64MOVHload {
   229  			break
   230  		}
   231  		v.Reset(ssaop.OpLOONG64MOVVreg)
   232  		v.AddArg(x)
   233  		return true
   234  	}
   235  	// match: (MOVHreg x:(MOVBloadidx _ _ _))
   236  	// result: (MOVVreg x)
   237  	for {
   238  		x := v_0
   239  		if x.Op != ssaop.OpLOONG64MOVBloadidx {
   240  			break
   241  		}
   242  		v.Reset(ssaop.OpLOONG64MOVVreg)
   243  		v.AddArg(x)
   244  		return true
   245  	}
   246  	// match: (MOVHreg x:(MOVBUloadidx _ _ _))
   247  	// result: (MOVVreg x)
   248  	for {
   249  		x := v_0
   250  		if x.Op != ssaop.OpLOONG64MOVBUloadidx {
   251  			break
   252  		}
   253  		v.Reset(ssaop.OpLOONG64MOVVreg)
   254  		v.AddArg(x)
   255  		return true
   256  	}
   257  	// match: (MOVHreg x:(MOVHloadidx _ _ _))
   258  	// result: (MOVVreg x)
   259  	for {
   260  		x := v_0
   261  		if x.Op != ssaop.OpLOONG64MOVHloadidx {
   262  			break
   263  		}
   264  		v.Reset(ssaop.OpLOONG64MOVVreg)
   265  		v.AddArg(x)
   266  		return true
   267  	}
   268  	// match: (MOVHreg x:(MOVBreg _))
   269  	// result: (MOVVreg x)
   270  	for {
   271  		x := v_0
   272  		if x.Op != ssaop.OpLOONG64MOVBreg {
   273  			break
   274  		}
   275  		v.Reset(ssaop.OpLOONG64MOVVreg)
   276  		v.AddArg(x)
   277  		return true
   278  	}
   279  	// match: (MOVHreg x:(MOVBUreg _))
   280  	// result: (MOVVreg x)
   281  	for {
   282  		x := v_0
   283  		if x.Op != ssaop.OpLOONG64MOVBUreg {
   284  			break
   285  		}
   286  		v.Reset(ssaop.OpLOONG64MOVVreg)
   287  		v.AddArg(x)
   288  		return true
   289  	}
   290  	// match: (MOVHreg x:(MOVHreg _))
   291  	// result: (MOVVreg x)
   292  	for {
   293  		x := v_0
   294  		if x.Op != ssaop.OpLOONG64MOVHreg {
   295  			break
   296  		}
   297  		v.Reset(ssaop.OpLOONG64MOVVreg)
   298  		v.AddArg(x)
   299  		return true
   300  	}
   301  	return false
   302  }
   303  func rewriteValue_OpLOONG64MOVVconst(v *ssa.Value) bool {
   304  	// match: (MOVVconst [0])
   305  	// result: (ZERO)
   306  	for {
   307  		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
   308  			break
   309  		}
   310  		v.Reset(ssaop.OpLOONG64ZERO)
   311  		return true
   312  	}
   313  	return false
   314  }
   315  func rewriteValue_OpLOONG64MOVVnop(v *ssa.Value) bool {
   316  	v_0 := v.Args[0]
   317  	// match: (MOVVnop (MOVVconst [c]))
   318  	// result: (MOVVconst [c])
   319  	for {
   320  		if v_0.Op != ssaop.OpLOONG64MOVVconst {
   321  			break
   322  		}
   323  		c := ssa.AuxIntToInt64(v_0.AuxInt)
   324  		v.Reset(ssaop.OpLOONG64MOVVconst)
   325  		v.AuxInt = ssa.Int64ToAuxInt(c)
   326  		return true
   327  	}
   328  	return false
   329  }
   330  func rewriteValue_OpLOONG64MOVVreg(v *ssa.Value) bool {
   331  	v_0 := v.Args[0]
   332  	// match: (MOVVreg x)
   333  	// cond: x.Uses == 1
   334  	// result: (MOVVnop x)
   335  	for {
   336  		x := v_0
   337  		if !(x.Uses == 1) {
   338  			break
   339  		}
   340  		v.Reset(ssaop.OpLOONG64MOVVnop)
   341  		v.AddArg(x)
   342  		return true
   343  	}
   344  	return false
   345  }
   346  func rewriteValue_OpLOONG64MOVWUreg(v *ssa.Value) bool {
   347  	v_0 := v.Args[0]
   348  	// match: (MOVWUreg x)
   349  	// cond: ssa.ZeroUpper32Bits(x)
   350  	// result: x
   351  	for {
   352  		x := v_0
   353  		if !(ssa.ZeroUpper32Bits(x)) {
   354  			break
   355  		}
   356  		v.CopyOf(x)
   357  		return true
   358  	}
   359  	// match: (MOVWUreg x:(MOVBUload _ _))
   360  	// result: (MOVVreg x)
   361  	for {
   362  		x := v_0
   363  		if x.Op != ssaop.OpLOONG64MOVBUload {
   364  			break
   365  		}
   366  		v.Reset(ssaop.OpLOONG64MOVVreg)
   367  		v.AddArg(x)
   368  		return true
   369  	}
   370  	// match: (MOVWUreg x:(MOVHUload _ _))
   371  	// result: (MOVVreg x)
   372  	for {
   373  		x := v_0
   374  		if x.Op != ssaop.OpLOONG64MOVHUload {
   375  			break
   376  		}
   377  		v.Reset(ssaop.OpLOONG64MOVVreg)
   378  		v.AddArg(x)
   379  		return true
   380  	}
   381  	// match: (MOVWUreg x:(MOVWUload _ _))
   382  	// result: (MOVVreg x)
   383  	for {
   384  		x := v_0
   385  		if x.Op != ssaop.OpLOONG64MOVWUload {
   386  			break
   387  		}
   388  		v.Reset(ssaop.OpLOONG64MOVVreg)
   389  		v.AddArg(x)
   390  		return true
   391  	}
   392  	// match: (MOVWUreg x:(MOVBUloadidx _ _ _))
   393  	// result: (MOVVreg x)
   394  	for {
   395  		x := v_0
   396  		if x.Op != ssaop.OpLOONG64MOVBUloadidx {
   397  			break
   398  		}
   399  		v.Reset(ssaop.OpLOONG64MOVVreg)
   400  		v.AddArg(x)
   401  		return true
   402  	}
   403  	// match: (MOVWUreg x:(MOVHUloadidx _ _ _))
   404  	// result: (MOVVreg x)
   405  	for {
   406  		x := v_0
   407  		if x.Op != ssaop.OpLOONG64MOVHUloadidx {
   408  			break
   409  		}
   410  		v.Reset(ssaop.OpLOONG64MOVVreg)
   411  		v.AddArg(x)
   412  		return true
   413  	}
   414  	// match: (MOVWUreg x:(MOVWUloadidx _ _ _))
   415  	// result: (MOVVreg x)
   416  	for {
   417  		x := v_0
   418  		if x.Op != ssaop.OpLOONG64MOVWUloadidx {
   419  			break
   420  		}
   421  		v.Reset(ssaop.OpLOONG64MOVVreg)
   422  		v.AddArg(x)
   423  		return true
   424  	}
   425  	// match: (MOVWUreg x:(MOVBUreg _))
   426  	// result: (MOVVreg x)
   427  	for {
   428  		x := v_0
   429  		if x.Op != ssaop.OpLOONG64MOVBUreg {
   430  			break
   431  		}
   432  		v.Reset(ssaop.OpLOONG64MOVVreg)
   433  		v.AddArg(x)
   434  		return true
   435  	}
   436  	// match: (MOVWUreg x:(MOVHUreg _))
   437  	// result: (MOVVreg x)
   438  	for {
   439  		x := v_0
   440  		if x.Op != ssaop.OpLOONG64MOVHUreg {
   441  			break
   442  		}
   443  		v.Reset(ssaop.OpLOONG64MOVVreg)
   444  		v.AddArg(x)
   445  		return true
   446  	}
   447  	// match: (MOVWUreg x:(MOVWUreg _))
   448  	// result: (MOVVreg x)
   449  	for {
   450  		x := v_0
   451  		if x.Op != ssaop.OpLOONG64MOVWUreg {
   452  			break
   453  		}
   454  		v.Reset(ssaop.OpLOONG64MOVVreg)
   455  		v.AddArg(x)
   456  		return true
   457  	}
   458  	return false
   459  }
   460  func rewriteValue_OpLOONG64MOVWreg(v *ssa.Value) bool {
   461  	v_0 := v.Args[0]
   462  	// match: (MOVWreg x:(MOVBload _ _))
   463  	// result: (MOVVreg x)
   464  	for {
   465  		x := v_0
   466  		if x.Op != ssaop.OpLOONG64MOVBload {
   467  			break
   468  		}
   469  		v.Reset(ssaop.OpLOONG64MOVVreg)
   470  		v.AddArg(x)
   471  		return true
   472  	}
   473  	// match: (MOVWreg x:(MOVBUload _ _))
   474  	// result: (MOVVreg x)
   475  	for {
   476  		x := v_0
   477  		if x.Op != ssaop.OpLOONG64MOVBUload {
   478  			break
   479  		}
   480  		v.Reset(ssaop.OpLOONG64MOVVreg)
   481  		v.AddArg(x)
   482  		return true
   483  	}
   484  	// match: (MOVWreg x:(MOVHload _ _))
   485  	// result: (MOVVreg x)
   486  	for {
   487  		x := v_0
   488  		if x.Op != ssaop.OpLOONG64MOVHload {
   489  			break
   490  		}
   491  		v.Reset(ssaop.OpLOONG64MOVVreg)
   492  		v.AddArg(x)
   493  		return true
   494  	}
   495  	// match: (MOVWreg x:(MOVHUload _ _))
   496  	// result: (MOVVreg x)
   497  	for {
   498  		x := v_0
   499  		if x.Op != ssaop.OpLOONG64MOVHUload {
   500  			break
   501  		}
   502  		v.Reset(ssaop.OpLOONG64MOVVreg)
   503  		v.AddArg(x)
   504  		return true
   505  	}
   506  	// match: (MOVWreg x:(MOVWload _ _))
   507  	// result: (MOVVreg x)
   508  	for {
   509  		x := v_0
   510  		if x.Op != ssaop.OpLOONG64MOVWload {
   511  			break
   512  		}
   513  		v.Reset(ssaop.OpLOONG64MOVVreg)
   514  		v.AddArg(x)
   515  		return true
   516  	}
   517  	// match: (MOVWreg x:(MOVBloadidx _ _ _))
   518  	// result: (MOVVreg x)
   519  	for {
   520  		x := v_0
   521  		if x.Op != ssaop.OpLOONG64MOVBloadidx {
   522  			break
   523  		}
   524  		v.Reset(ssaop.OpLOONG64MOVVreg)
   525  		v.AddArg(x)
   526  		return true
   527  	}
   528  	// match: (MOVWreg x:(MOVBUloadidx _ _ _))
   529  	// result: (MOVVreg x)
   530  	for {
   531  		x := v_0
   532  		if x.Op != ssaop.OpLOONG64MOVBUloadidx {
   533  			break
   534  		}
   535  		v.Reset(ssaop.OpLOONG64MOVVreg)
   536  		v.AddArg(x)
   537  		return true
   538  	}
   539  	// match: (MOVWreg x:(MOVHloadidx _ _ _))
   540  	// result: (MOVVreg x)
   541  	for {
   542  		x := v_0
   543  		if x.Op != ssaop.OpLOONG64MOVHloadidx {
   544  			break
   545  		}
   546  		v.Reset(ssaop.OpLOONG64MOVVreg)
   547  		v.AddArg(x)
   548  		return true
   549  	}
   550  	// match: (MOVWreg x:(MOVHUloadidx _ _ _))
   551  	// result: (MOVVreg x)
   552  	for {
   553  		x := v_0
   554  		if x.Op != ssaop.OpLOONG64MOVHUloadidx {
   555  			break
   556  		}
   557  		v.Reset(ssaop.OpLOONG64MOVVreg)
   558  		v.AddArg(x)
   559  		return true
   560  	}
   561  	// match: (MOVWreg x:(MOVWloadidx _ _ _))
   562  	// result: (MOVVreg x)
   563  	for {
   564  		x := v_0
   565  		if x.Op != ssaop.OpLOONG64MOVWloadidx {
   566  			break
   567  		}
   568  		v.Reset(ssaop.OpLOONG64MOVVreg)
   569  		v.AddArg(x)
   570  		return true
   571  	}
   572  	// match: (MOVWreg x:(MOVBreg _))
   573  	// result: (MOVVreg x)
   574  	for {
   575  		x := v_0
   576  		if x.Op != ssaop.OpLOONG64MOVBreg {
   577  			break
   578  		}
   579  		v.Reset(ssaop.OpLOONG64MOVVreg)
   580  		v.AddArg(x)
   581  		return true
   582  	}
   583  	// match: (MOVWreg x:(MOVBUreg _))
   584  	// result: (MOVVreg x)
   585  	for {
   586  		x := v_0
   587  		if x.Op != ssaop.OpLOONG64MOVBUreg {
   588  			break
   589  		}
   590  		v.Reset(ssaop.OpLOONG64MOVVreg)
   591  		v.AddArg(x)
   592  		return true
   593  	}
   594  	// match: (MOVWreg x:(MOVHreg _))
   595  	// result: (MOVVreg x)
   596  	for {
   597  		x := v_0
   598  		if x.Op != ssaop.OpLOONG64MOVHreg {
   599  			break
   600  		}
   601  		v.Reset(ssaop.OpLOONG64MOVVreg)
   602  		v.AddArg(x)
   603  		return true
   604  	}
   605  	// match: (MOVWreg x:(MOVWreg _))
   606  	// result: (MOVVreg x)
   607  	for {
   608  		x := v_0
   609  		if x.Op != ssaop.OpLOONG64MOVWreg {
   610  			break
   611  		}
   612  		v.Reset(ssaop.OpLOONG64MOVVreg)
   613  		v.AddArg(x)
   614  		return true
   615  	}
   616  	return false
   617  }
   618  func rewriteValue_OpLOONG64SLLVconst(v *ssa.Value) bool {
   619  	v_0 := v.Args[0]
   620  	// match: (SLLVconst [1] x)
   621  	// result: (ADDV x x)
   622  	for {
   623  		if ssa.AuxIntToInt64(v.AuxInt) != 1 {
   624  			break
   625  		}
   626  		x := v_0
   627  		v.Reset(ssaop.OpLOONG64ADDV)
   628  		v.AddArg2(x, x)
   629  		return true
   630  	}
   631  	return false
   632  }
   633  func RewriteBlock(b *ssa.Block) bool {
   634  	switch b.Kind {
   635  	case block.BlockLOONG64EQZ:
   636  		// match: (EQZ (XOR x y) yes no)
   637  		// result: (BEQ x y yes no)
   638  		for b.Controls[0].Op == ssaop.OpLOONG64XOR {
   639  			v_0 := b.Controls[0]
   640  			_ = v_0.Args[1]
   641  			v_0_0 := v_0.Args[0]
   642  			v_0_1 := v_0.Args[1]
   643  			for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
   644  				x := v_0_0
   645  				y := v_0_1
   646  				b.ResetWithControl2(block.BlockLOONG64BEQ, x, y)
   647  				return true
   648  			}
   649  		}
   650  	case block.BlockLOONG64NEZ:
   651  		// match: (NEZ (XOR x y) yes no)
   652  		// result: (BNE x y yes no)
   653  		for b.Controls[0].Op == ssaop.OpLOONG64XOR {
   654  			v_0 := b.Controls[0]
   655  			_ = v_0.Args[1]
   656  			v_0_0 := v_0.Args[0]
   657  			v_0_1 := v_0.Args[1]
   658  			for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
   659  				x := v_0_0
   660  				y := v_0_1
   661  				b.ResetWithControl2(block.BlockLOONG64BNE, x, y)
   662  				return true
   663  			}
   664  		}
   665  	}
   666  	return false
   667  }
   668  

View as plain text