github.com/bir3/gocompiler@v0.3.205/src/cmd/compile/internal/ssa/rewriteRISCV64.go (about)

     1  // Code generated from _gen/RISCV64.rules; DO NOT EDIT.
     2  // generated with: cd _gen; go run .
     3  
     4  package ssa
     5  
     6  import "math"
     7  import "github.com/bir3/gocompiler/src/cmd/compile/internal/types"
     8  
     9  func rewriteValueRISCV64(v *Value) bool {
    10  	switch v.Op {
    11  	case OpAbs:
    12  		v.Op = OpRISCV64FABSD
    13  		return true
    14  	case OpAdd16:
    15  		v.Op = OpRISCV64ADD
    16  		return true
    17  	case OpAdd32:
    18  		v.Op = OpRISCV64ADD
    19  		return true
    20  	case OpAdd32F:
    21  		v.Op = OpRISCV64FADDS
    22  		return true
    23  	case OpAdd64:
    24  		v.Op = OpRISCV64ADD
    25  		return true
    26  	case OpAdd64F:
    27  		v.Op = OpRISCV64FADDD
    28  		return true
    29  	case OpAdd8:
    30  		v.Op = OpRISCV64ADD
    31  		return true
    32  	case OpAddPtr:
    33  		v.Op = OpRISCV64ADD
    34  		return true
    35  	case OpAddr:
    36  		return rewriteValueRISCV64_OpAddr(v)
    37  	case OpAnd16:
    38  		v.Op = OpRISCV64AND
    39  		return true
    40  	case OpAnd32:
    41  		v.Op = OpRISCV64AND
    42  		return true
    43  	case OpAnd64:
    44  		v.Op = OpRISCV64AND
    45  		return true
    46  	case OpAnd8:
    47  		v.Op = OpRISCV64AND
    48  		return true
    49  	case OpAndB:
    50  		v.Op = OpRISCV64AND
    51  		return true
    52  	case OpAtomicAdd32:
    53  		v.Op = OpRISCV64LoweredAtomicAdd32
    54  		return true
    55  	case OpAtomicAdd64:
    56  		v.Op = OpRISCV64LoweredAtomicAdd64
    57  		return true
    58  	case OpAtomicAnd32:
    59  		v.Op = OpRISCV64LoweredAtomicAnd32
    60  		return true
    61  	case OpAtomicAnd8:
    62  		return rewriteValueRISCV64_OpAtomicAnd8(v)
    63  	case OpAtomicCompareAndSwap32:
    64  		return rewriteValueRISCV64_OpAtomicCompareAndSwap32(v)
    65  	case OpAtomicCompareAndSwap64:
    66  		v.Op = OpRISCV64LoweredAtomicCas64
    67  		return true
    68  	case OpAtomicExchange32:
    69  		v.Op = OpRISCV64LoweredAtomicExchange32
    70  		return true
    71  	case OpAtomicExchange64:
    72  		v.Op = OpRISCV64LoweredAtomicExchange64
    73  		return true
    74  	case OpAtomicLoad32:
    75  		v.Op = OpRISCV64LoweredAtomicLoad32
    76  		return true
    77  	case OpAtomicLoad64:
    78  		v.Op = OpRISCV64LoweredAtomicLoad64
    79  		return true
    80  	case OpAtomicLoad8:
    81  		v.Op = OpRISCV64LoweredAtomicLoad8
    82  		return true
    83  	case OpAtomicLoadPtr:
    84  		v.Op = OpRISCV64LoweredAtomicLoad64
    85  		return true
    86  	case OpAtomicOr32:
    87  		v.Op = OpRISCV64LoweredAtomicOr32
    88  		return true
    89  	case OpAtomicOr8:
    90  		return rewriteValueRISCV64_OpAtomicOr8(v)
    91  	case OpAtomicStore32:
    92  		v.Op = OpRISCV64LoweredAtomicStore32
    93  		return true
    94  	case OpAtomicStore64:
    95  		v.Op = OpRISCV64LoweredAtomicStore64
    96  		return true
    97  	case OpAtomicStore8:
    98  		v.Op = OpRISCV64LoweredAtomicStore8
    99  		return true
   100  	case OpAtomicStorePtrNoWB:
   101  		v.Op = OpRISCV64LoweredAtomicStore64
   102  		return true
   103  	case OpAvg64u:
   104  		return rewriteValueRISCV64_OpAvg64u(v)
   105  	case OpClosureCall:
   106  		v.Op = OpRISCV64CALLclosure
   107  		return true
   108  	case OpCom16:
   109  		v.Op = OpRISCV64NOT
   110  		return true
   111  	case OpCom32:
   112  		v.Op = OpRISCV64NOT
   113  		return true
   114  	case OpCom64:
   115  		v.Op = OpRISCV64NOT
   116  		return true
   117  	case OpCom8:
   118  		v.Op = OpRISCV64NOT
   119  		return true
   120  	case OpConst16:
   121  		return rewriteValueRISCV64_OpConst16(v)
   122  	case OpConst32:
   123  		return rewriteValueRISCV64_OpConst32(v)
   124  	case OpConst32F:
   125  		return rewriteValueRISCV64_OpConst32F(v)
   126  	case OpConst64:
   127  		return rewriteValueRISCV64_OpConst64(v)
   128  	case OpConst64F:
   129  		return rewriteValueRISCV64_OpConst64F(v)
   130  	case OpConst8:
   131  		return rewriteValueRISCV64_OpConst8(v)
   132  	case OpConstBool:
   133  		return rewriteValueRISCV64_OpConstBool(v)
   134  	case OpConstNil:
   135  		return rewriteValueRISCV64_OpConstNil(v)
   136  	case OpConvert:
   137  		v.Op = OpRISCV64MOVconvert
   138  		return true
   139  	case OpCopysign:
   140  		v.Op = OpRISCV64FSGNJD
   141  		return true
   142  	case OpCvt32Fto32:
   143  		v.Op = OpRISCV64FCVTWS
   144  		return true
   145  	case OpCvt32Fto64:
   146  		v.Op = OpRISCV64FCVTLS
   147  		return true
   148  	case OpCvt32Fto64F:
   149  		v.Op = OpRISCV64FCVTDS
   150  		return true
   151  	case OpCvt32to32F:
   152  		v.Op = OpRISCV64FCVTSW
   153  		return true
   154  	case OpCvt32to64F:
   155  		v.Op = OpRISCV64FCVTDW
   156  		return true
   157  	case OpCvt64Fto32:
   158  		v.Op = OpRISCV64FCVTWD
   159  		return true
   160  	case OpCvt64Fto32F:
   161  		v.Op = OpRISCV64FCVTSD
   162  		return true
   163  	case OpCvt64Fto64:
   164  		v.Op = OpRISCV64FCVTLD
   165  		return true
   166  	case OpCvt64to32F:
   167  		v.Op = OpRISCV64FCVTSL
   168  		return true
   169  	case OpCvt64to64F:
   170  		v.Op = OpRISCV64FCVTDL
   171  		return true
   172  	case OpCvtBoolToUint8:
   173  		v.Op = OpCopy
   174  		return true
   175  	case OpDiv16:
   176  		return rewriteValueRISCV64_OpDiv16(v)
   177  	case OpDiv16u:
   178  		return rewriteValueRISCV64_OpDiv16u(v)
   179  	case OpDiv32:
   180  		return rewriteValueRISCV64_OpDiv32(v)
   181  	case OpDiv32F:
   182  		v.Op = OpRISCV64FDIVS
   183  		return true
   184  	case OpDiv32u:
   185  		v.Op = OpRISCV64DIVUW
   186  		return true
   187  	case OpDiv64:
   188  		return rewriteValueRISCV64_OpDiv64(v)
   189  	case OpDiv64F:
   190  		v.Op = OpRISCV64FDIVD
   191  		return true
   192  	case OpDiv64u:
   193  		v.Op = OpRISCV64DIVU
   194  		return true
   195  	case OpDiv8:
   196  		return rewriteValueRISCV64_OpDiv8(v)
   197  	case OpDiv8u:
   198  		return rewriteValueRISCV64_OpDiv8u(v)
   199  	case OpEq16:
   200  		return rewriteValueRISCV64_OpEq16(v)
   201  	case OpEq32:
   202  		return rewriteValueRISCV64_OpEq32(v)
   203  	case OpEq32F:
   204  		v.Op = OpRISCV64FEQS
   205  		return true
   206  	case OpEq64:
   207  		return rewriteValueRISCV64_OpEq64(v)
   208  	case OpEq64F:
   209  		v.Op = OpRISCV64FEQD
   210  		return true
   211  	case OpEq8:
   212  		return rewriteValueRISCV64_OpEq8(v)
   213  	case OpEqB:
   214  		return rewriteValueRISCV64_OpEqB(v)
   215  	case OpEqPtr:
   216  		return rewriteValueRISCV64_OpEqPtr(v)
   217  	case OpFMA:
   218  		v.Op = OpRISCV64FMADDD
   219  		return true
   220  	case OpGetCallerPC:
   221  		v.Op = OpRISCV64LoweredGetCallerPC
   222  		return true
   223  	case OpGetCallerSP:
   224  		v.Op = OpRISCV64LoweredGetCallerSP
   225  		return true
   226  	case OpGetClosurePtr:
   227  		v.Op = OpRISCV64LoweredGetClosurePtr
   228  		return true
   229  	case OpHmul32:
   230  		return rewriteValueRISCV64_OpHmul32(v)
   231  	case OpHmul32u:
   232  		return rewriteValueRISCV64_OpHmul32u(v)
   233  	case OpHmul64:
   234  		v.Op = OpRISCV64MULH
   235  		return true
   236  	case OpHmul64u:
   237  		v.Op = OpRISCV64MULHU
   238  		return true
   239  	case OpInterCall:
   240  		v.Op = OpRISCV64CALLinter
   241  		return true
   242  	case OpIsInBounds:
   243  		v.Op = OpLess64U
   244  		return true
   245  	case OpIsNonNil:
   246  		v.Op = OpRISCV64SNEZ
   247  		return true
   248  	case OpIsSliceInBounds:
   249  		v.Op = OpLeq64U
   250  		return true
   251  	case OpLeq16:
   252  		return rewriteValueRISCV64_OpLeq16(v)
   253  	case OpLeq16U:
   254  		return rewriteValueRISCV64_OpLeq16U(v)
   255  	case OpLeq32:
   256  		return rewriteValueRISCV64_OpLeq32(v)
   257  	case OpLeq32F:
   258  		v.Op = OpRISCV64FLES
   259  		return true
   260  	case OpLeq32U:
   261  		return rewriteValueRISCV64_OpLeq32U(v)
   262  	case OpLeq64:
   263  		return rewriteValueRISCV64_OpLeq64(v)
   264  	case OpLeq64F:
   265  		v.Op = OpRISCV64FLED
   266  		return true
   267  	case OpLeq64U:
   268  		return rewriteValueRISCV64_OpLeq64U(v)
   269  	case OpLeq8:
   270  		return rewriteValueRISCV64_OpLeq8(v)
   271  	case OpLeq8U:
   272  		return rewriteValueRISCV64_OpLeq8U(v)
   273  	case OpLess16:
   274  		return rewriteValueRISCV64_OpLess16(v)
   275  	case OpLess16U:
   276  		return rewriteValueRISCV64_OpLess16U(v)
   277  	case OpLess32:
   278  		return rewriteValueRISCV64_OpLess32(v)
   279  	case OpLess32F:
   280  		v.Op = OpRISCV64FLTS
   281  		return true
   282  	case OpLess32U:
   283  		return rewriteValueRISCV64_OpLess32U(v)
   284  	case OpLess64:
   285  		v.Op = OpRISCV64SLT
   286  		return true
   287  	case OpLess64F:
   288  		v.Op = OpRISCV64FLTD
   289  		return true
   290  	case OpLess64U:
   291  		v.Op = OpRISCV64SLTU
   292  		return true
   293  	case OpLess8:
   294  		return rewriteValueRISCV64_OpLess8(v)
   295  	case OpLess8U:
   296  		return rewriteValueRISCV64_OpLess8U(v)
   297  	case OpLoad:
   298  		return rewriteValueRISCV64_OpLoad(v)
   299  	case OpLocalAddr:
   300  		return rewriteValueRISCV64_OpLocalAddr(v)
   301  	case OpLsh16x16:
   302  		return rewriteValueRISCV64_OpLsh16x16(v)
   303  	case OpLsh16x32:
   304  		return rewriteValueRISCV64_OpLsh16x32(v)
   305  	case OpLsh16x64:
   306  		return rewriteValueRISCV64_OpLsh16x64(v)
   307  	case OpLsh16x8:
   308  		return rewriteValueRISCV64_OpLsh16x8(v)
   309  	case OpLsh32x16:
   310  		return rewriteValueRISCV64_OpLsh32x16(v)
   311  	case OpLsh32x32:
   312  		return rewriteValueRISCV64_OpLsh32x32(v)
   313  	case OpLsh32x64:
   314  		return rewriteValueRISCV64_OpLsh32x64(v)
   315  	case OpLsh32x8:
   316  		return rewriteValueRISCV64_OpLsh32x8(v)
   317  	case OpLsh64x16:
   318  		return rewriteValueRISCV64_OpLsh64x16(v)
   319  	case OpLsh64x32:
   320  		return rewriteValueRISCV64_OpLsh64x32(v)
   321  	case OpLsh64x64:
   322  		return rewriteValueRISCV64_OpLsh64x64(v)
   323  	case OpLsh64x8:
   324  		return rewriteValueRISCV64_OpLsh64x8(v)
   325  	case OpLsh8x16:
   326  		return rewriteValueRISCV64_OpLsh8x16(v)
   327  	case OpLsh8x32:
   328  		return rewriteValueRISCV64_OpLsh8x32(v)
   329  	case OpLsh8x64:
   330  		return rewriteValueRISCV64_OpLsh8x64(v)
   331  	case OpLsh8x8:
   332  		return rewriteValueRISCV64_OpLsh8x8(v)
   333  	case OpMod16:
   334  		return rewriteValueRISCV64_OpMod16(v)
   335  	case OpMod16u:
   336  		return rewriteValueRISCV64_OpMod16u(v)
   337  	case OpMod32:
   338  		return rewriteValueRISCV64_OpMod32(v)
   339  	case OpMod32u:
   340  		v.Op = OpRISCV64REMUW
   341  		return true
   342  	case OpMod64:
   343  		return rewriteValueRISCV64_OpMod64(v)
   344  	case OpMod64u:
   345  		v.Op = OpRISCV64REMU
   346  		return true
   347  	case OpMod8:
   348  		return rewriteValueRISCV64_OpMod8(v)
   349  	case OpMod8u:
   350  		return rewriteValueRISCV64_OpMod8u(v)
   351  	case OpMove:
   352  		return rewriteValueRISCV64_OpMove(v)
   353  	case OpMul16:
   354  		return rewriteValueRISCV64_OpMul16(v)
   355  	case OpMul32:
   356  		v.Op = OpRISCV64MULW
   357  		return true
   358  	case OpMul32F:
   359  		v.Op = OpRISCV64FMULS
   360  		return true
   361  	case OpMul64:
   362  		v.Op = OpRISCV64MUL
   363  		return true
   364  	case OpMul64F:
   365  		v.Op = OpRISCV64FMULD
   366  		return true
   367  	case OpMul64uhilo:
   368  		v.Op = OpRISCV64LoweredMuluhilo
   369  		return true
   370  	case OpMul64uover:
   371  		v.Op = OpRISCV64LoweredMuluover
   372  		return true
   373  	case OpMul8:
   374  		return rewriteValueRISCV64_OpMul8(v)
   375  	case OpNeg16:
   376  		v.Op = OpRISCV64NEG
   377  		return true
   378  	case OpNeg32:
   379  		v.Op = OpRISCV64NEG
   380  		return true
   381  	case OpNeg32F:
   382  		v.Op = OpRISCV64FNEGS
   383  		return true
   384  	case OpNeg64:
   385  		v.Op = OpRISCV64NEG
   386  		return true
   387  	case OpNeg64F:
   388  		v.Op = OpRISCV64FNEGD
   389  		return true
   390  	case OpNeg8:
   391  		v.Op = OpRISCV64NEG
   392  		return true
   393  	case OpNeq16:
   394  		return rewriteValueRISCV64_OpNeq16(v)
   395  	case OpNeq32:
   396  		return rewriteValueRISCV64_OpNeq32(v)
   397  	case OpNeq32F:
   398  		v.Op = OpRISCV64FNES
   399  		return true
   400  	case OpNeq64:
   401  		return rewriteValueRISCV64_OpNeq64(v)
   402  	case OpNeq64F:
   403  		v.Op = OpRISCV64FNED
   404  		return true
   405  	case OpNeq8:
   406  		return rewriteValueRISCV64_OpNeq8(v)
   407  	case OpNeqB:
   408  		return rewriteValueRISCV64_OpNeqB(v)
   409  	case OpNeqPtr:
   410  		return rewriteValueRISCV64_OpNeqPtr(v)
   411  	case OpNilCheck:
   412  		v.Op = OpRISCV64LoweredNilCheck
   413  		return true
   414  	case OpNot:
   415  		v.Op = OpRISCV64SEQZ
   416  		return true
   417  	case OpOffPtr:
   418  		return rewriteValueRISCV64_OpOffPtr(v)
   419  	case OpOr16:
   420  		v.Op = OpRISCV64OR
   421  		return true
   422  	case OpOr32:
   423  		v.Op = OpRISCV64OR
   424  		return true
   425  	case OpOr64:
   426  		v.Op = OpRISCV64OR
   427  		return true
   428  	case OpOr8:
   429  		v.Op = OpRISCV64OR
   430  		return true
   431  	case OpOrB:
   432  		v.Op = OpRISCV64OR
   433  		return true
   434  	case OpPanicBounds:
   435  		return rewriteValueRISCV64_OpPanicBounds(v)
   436  	case OpRISCV64ADD:
   437  		return rewriteValueRISCV64_OpRISCV64ADD(v)
   438  	case OpRISCV64ADDI:
   439  		return rewriteValueRISCV64_OpRISCV64ADDI(v)
   440  	case OpRISCV64AND:
   441  		return rewriteValueRISCV64_OpRISCV64AND(v)
   442  	case OpRISCV64ANDI:
   443  		return rewriteValueRISCV64_OpRISCV64ANDI(v)
   444  	case OpRISCV64FMADDD:
   445  		return rewriteValueRISCV64_OpRISCV64FMADDD(v)
   446  	case OpRISCV64FMSUBD:
   447  		return rewriteValueRISCV64_OpRISCV64FMSUBD(v)
   448  	case OpRISCV64FNMADDD:
   449  		return rewriteValueRISCV64_OpRISCV64FNMADDD(v)
   450  	case OpRISCV64FNMSUBD:
   451  		return rewriteValueRISCV64_OpRISCV64FNMSUBD(v)
   452  	case OpRISCV64MOVBUload:
   453  		return rewriteValueRISCV64_OpRISCV64MOVBUload(v)
   454  	case OpRISCV64MOVBUreg:
   455  		return rewriteValueRISCV64_OpRISCV64MOVBUreg(v)
   456  	case OpRISCV64MOVBload:
   457  		return rewriteValueRISCV64_OpRISCV64MOVBload(v)
   458  	case OpRISCV64MOVBreg:
   459  		return rewriteValueRISCV64_OpRISCV64MOVBreg(v)
   460  	case OpRISCV64MOVBstore:
   461  		return rewriteValueRISCV64_OpRISCV64MOVBstore(v)
   462  	case OpRISCV64MOVBstorezero:
   463  		return rewriteValueRISCV64_OpRISCV64MOVBstorezero(v)
   464  	case OpRISCV64MOVDload:
   465  		return rewriteValueRISCV64_OpRISCV64MOVDload(v)
   466  	case OpRISCV64MOVDnop:
   467  		return rewriteValueRISCV64_OpRISCV64MOVDnop(v)
   468  	case OpRISCV64MOVDreg:
   469  		return rewriteValueRISCV64_OpRISCV64MOVDreg(v)
   470  	case OpRISCV64MOVDstore:
   471  		return rewriteValueRISCV64_OpRISCV64MOVDstore(v)
   472  	case OpRISCV64MOVDstorezero:
   473  		return rewriteValueRISCV64_OpRISCV64MOVDstorezero(v)
   474  	case OpRISCV64MOVHUload:
   475  		return rewriteValueRISCV64_OpRISCV64MOVHUload(v)
   476  	case OpRISCV64MOVHUreg:
   477  		return rewriteValueRISCV64_OpRISCV64MOVHUreg(v)
   478  	case OpRISCV64MOVHload:
   479  		return rewriteValueRISCV64_OpRISCV64MOVHload(v)
   480  	case OpRISCV64MOVHreg:
   481  		return rewriteValueRISCV64_OpRISCV64MOVHreg(v)
   482  	case OpRISCV64MOVHstore:
   483  		return rewriteValueRISCV64_OpRISCV64MOVHstore(v)
   484  	case OpRISCV64MOVHstorezero:
   485  		return rewriteValueRISCV64_OpRISCV64MOVHstorezero(v)
   486  	case OpRISCV64MOVWUload:
   487  		return rewriteValueRISCV64_OpRISCV64MOVWUload(v)
   488  	case OpRISCV64MOVWUreg:
   489  		return rewriteValueRISCV64_OpRISCV64MOVWUreg(v)
   490  	case OpRISCV64MOVWload:
   491  		return rewriteValueRISCV64_OpRISCV64MOVWload(v)
   492  	case OpRISCV64MOVWreg:
   493  		return rewriteValueRISCV64_OpRISCV64MOVWreg(v)
   494  	case OpRISCV64MOVWstore:
   495  		return rewriteValueRISCV64_OpRISCV64MOVWstore(v)
   496  	case OpRISCV64MOVWstorezero:
   497  		return rewriteValueRISCV64_OpRISCV64MOVWstorezero(v)
   498  	case OpRISCV64NEG:
   499  		return rewriteValueRISCV64_OpRISCV64NEG(v)
   500  	case OpRISCV64NEGW:
   501  		return rewriteValueRISCV64_OpRISCV64NEGW(v)
   502  	case OpRISCV64OR:
   503  		return rewriteValueRISCV64_OpRISCV64OR(v)
   504  	case OpRISCV64ORI:
   505  		return rewriteValueRISCV64_OpRISCV64ORI(v)
   506  	case OpRISCV64SEQZ:
   507  		return rewriteValueRISCV64_OpRISCV64SEQZ(v)
   508  	case OpRISCV64SLL:
   509  		return rewriteValueRISCV64_OpRISCV64SLL(v)
   510  	case OpRISCV64SLLI:
   511  		return rewriteValueRISCV64_OpRISCV64SLLI(v)
   512  	case OpRISCV64SLT:
   513  		return rewriteValueRISCV64_OpRISCV64SLT(v)
   514  	case OpRISCV64SLTI:
   515  		return rewriteValueRISCV64_OpRISCV64SLTI(v)
   516  	case OpRISCV64SLTIU:
   517  		return rewriteValueRISCV64_OpRISCV64SLTIU(v)
   518  	case OpRISCV64SLTU:
   519  		return rewriteValueRISCV64_OpRISCV64SLTU(v)
   520  	case OpRISCV64SNEZ:
   521  		return rewriteValueRISCV64_OpRISCV64SNEZ(v)
   522  	case OpRISCV64SRA:
   523  		return rewriteValueRISCV64_OpRISCV64SRA(v)
   524  	case OpRISCV64SRAI:
   525  		return rewriteValueRISCV64_OpRISCV64SRAI(v)
   526  	case OpRISCV64SRL:
   527  		return rewriteValueRISCV64_OpRISCV64SRL(v)
   528  	case OpRISCV64SRLI:
   529  		return rewriteValueRISCV64_OpRISCV64SRLI(v)
   530  	case OpRISCV64SUB:
   531  		return rewriteValueRISCV64_OpRISCV64SUB(v)
   532  	case OpRISCV64SUBW:
   533  		return rewriteValueRISCV64_OpRISCV64SUBW(v)
   534  	case OpRISCV64XOR:
   535  		return rewriteValueRISCV64_OpRISCV64XOR(v)
   536  	case OpRotateLeft16:
   537  		return rewriteValueRISCV64_OpRotateLeft16(v)
   538  	case OpRotateLeft32:
   539  		return rewriteValueRISCV64_OpRotateLeft32(v)
   540  	case OpRotateLeft64:
   541  		return rewriteValueRISCV64_OpRotateLeft64(v)
   542  	case OpRotateLeft8:
   543  		return rewriteValueRISCV64_OpRotateLeft8(v)
   544  	case OpRound32F:
   545  		v.Op = OpCopy
   546  		return true
   547  	case OpRound64F:
   548  		v.Op = OpCopy
   549  		return true
   550  	case OpRsh16Ux16:
   551  		return rewriteValueRISCV64_OpRsh16Ux16(v)
   552  	case OpRsh16Ux32:
   553  		return rewriteValueRISCV64_OpRsh16Ux32(v)
   554  	case OpRsh16Ux64:
   555  		return rewriteValueRISCV64_OpRsh16Ux64(v)
   556  	case OpRsh16Ux8:
   557  		return rewriteValueRISCV64_OpRsh16Ux8(v)
   558  	case OpRsh16x16:
   559  		return rewriteValueRISCV64_OpRsh16x16(v)
   560  	case OpRsh16x32:
   561  		return rewriteValueRISCV64_OpRsh16x32(v)
   562  	case OpRsh16x64:
   563  		return rewriteValueRISCV64_OpRsh16x64(v)
   564  	case OpRsh16x8:
   565  		return rewriteValueRISCV64_OpRsh16x8(v)
   566  	case OpRsh32Ux16:
   567  		return rewriteValueRISCV64_OpRsh32Ux16(v)
   568  	case OpRsh32Ux32:
   569  		return rewriteValueRISCV64_OpRsh32Ux32(v)
   570  	case OpRsh32Ux64:
   571  		return rewriteValueRISCV64_OpRsh32Ux64(v)
   572  	case OpRsh32Ux8:
   573  		return rewriteValueRISCV64_OpRsh32Ux8(v)
   574  	case OpRsh32x16:
   575  		return rewriteValueRISCV64_OpRsh32x16(v)
   576  	case OpRsh32x32:
   577  		return rewriteValueRISCV64_OpRsh32x32(v)
   578  	case OpRsh32x64:
   579  		return rewriteValueRISCV64_OpRsh32x64(v)
   580  	case OpRsh32x8:
   581  		return rewriteValueRISCV64_OpRsh32x8(v)
   582  	case OpRsh64Ux16:
   583  		return rewriteValueRISCV64_OpRsh64Ux16(v)
   584  	case OpRsh64Ux32:
   585  		return rewriteValueRISCV64_OpRsh64Ux32(v)
   586  	case OpRsh64Ux64:
   587  		return rewriteValueRISCV64_OpRsh64Ux64(v)
   588  	case OpRsh64Ux8:
   589  		return rewriteValueRISCV64_OpRsh64Ux8(v)
   590  	case OpRsh64x16:
   591  		return rewriteValueRISCV64_OpRsh64x16(v)
   592  	case OpRsh64x32:
   593  		return rewriteValueRISCV64_OpRsh64x32(v)
   594  	case OpRsh64x64:
   595  		return rewriteValueRISCV64_OpRsh64x64(v)
   596  	case OpRsh64x8:
   597  		return rewriteValueRISCV64_OpRsh64x8(v)
   598  	case OpRsh8Ux16:
   599  		return rewriteValueRISCV64_OpRsh8Ux16(v)
   600  	case OpRsh8Ux32:
   601  		return rewriteValueRISCV64_OpRsh8Ux32(v)
   602  	case OpRsh8Ux64:
   603  		return rewriteValueRISCV64_OpRsh8Ux64(v)
   604  	case OpRsh8Ux8:
   605  		return rewriteValueRISCV64_OpRsh8Ux8(v)
   606  	case OpRsh8x16:
   607  		return rewriteValueRISCV64_OpRsh8x16(v)
   608  	case OpRsh8x32:
   609  		return rewriteValueRISCV64_OpRsh8x32(v)
   610  	case OpRsh8x64:
   611  		return rewriteValueRISCV64_OpRsh8x64(v)
   612  	case OpRsh8x8:
   613  		return rewriteValueRISCV64_OpRsh8x8(v)
   614  	case OpSelect0:
   615  		return rewriteValueRISCV64_OpSelect0(v)
   616  	case OpSelect1:
   617  		return rewriteValueRISCV64_OpSelect1(v)
   618  	case OpSignExt16to32:
   619  		v.Op = OpRISCV64MOVHreg
   620  		return true
   621  	case OpSignExt16to64:
   622  		v.Op = OpRISCV64MOVHreg
   623  		return true
   624  	case OpSignExt32to64:
   625  		v.Op = OpRISCV64MOVWreg
   626  		return true
   627  	case OpSignExt8to16:
   628  		v.Op = OpRISCV64MOVBreg
   629  		return true
   630  	case OpSignExt8to32:
   631  		v.Op = OpRISCV64MOVBreg
   632  		return true
   633  	case OpSignExt8to64:
   634  		v.Op = OpRISCV64MOVBreg
   635  		return true
   636  	case OpSlicemask:
   637  		return rewriteValueRISCV64_OpSlicemask(v)
   638  	case OpSqrt:
   639  		v.Op = OpRISCV64FSQRTD
   640  		return true
   641  	case OpSqrt32:
   642  		v.Op = OpRISCV64FSQRTS
   643  		return true
   644  	case OpStaticCall:
   645  		v.Op = OpRISCV64CALLstatic
   646  		return true
   647  	case OpStore:
   648  		return rewriteValueRISCV64_OpStore(v)
   649  	case OpSub16:
   650  		v.Op = OpRISCV64SUB
   651  		return true
   652  	case OpSub32:
   653  		v.Op = OpRISCV64SUB
   654  		return true
   655  	case OpSub32F:
   656  		v.Op = OpRISCV64FSUBS
   657  		return true
   658  	case OpSub64:
   659  		v.Op = OpRISCV64SUB
   660  		return true
   661  	case OpSub64F:
   662  		v.Op = OpRISCV64FSUBD
   663  		return true
   664  	case OpSub8:
   665  		v.Op = OpRISCV64SUB
   666  		return true
   667  	case OpSubPtr:
   668  		v.Op = OpRISCV64SUB
   669  		return true
   670  	case OpTailCall:
   671  		v.Op = OpRISCV64CALLtail
   672  		return true
   673  	case OpTrunc16to8:
   674  		v.Op = OpCopy
   675  		return true
   676  	case OpTrunc32to16:
   677  		v.Op = OpCopy
   678  		return true
   679  	case OpTrunc32to8:
   680  		v.Op = OpCopy
   681  		return true
   682  	case OpTrunc64to16:
   683  		v.Op = OpCopy
   684  		return true
   685  	case OpTrunc64to32:
   686  		v.Op = OpCopy
   687  		return true
   688  	case OpTrunc64to8:
   689  		v.Op = OpCopy
   690  		return true
   691  	case OpWB:
   692  		v.Op = OpRISCV64LoweredWB
   693  		return true
   694  	case OpXor16:
   695  		v.Op = OpRISCV64XOR
   696  		return true
   697  	case OpXor32:
   698  		v.Op = OpRISCV64XOR
   699  		return true
   700  	case OpXor64:
   701  		v.Op = OpRISCV64XOR
   702  		return true
   703  	case OpXor8:
   704  		v.Op = OpRISCV64XOR
   705  		return true
   706  	case OpZero:
   707  		return rewriteValueRISCV64_OpZero(v)
   708  	case OpZeroExt16to32:
   709  		v.Op = OpRISCV64MOVHUreg
   710  		return true
   711  	case OpZeroExt16to64:
   712  		v.Op = OpRISCV64MOVHUreg
   713  		return true
   714  	case OpZeroExt32to64:
   715  		v.Op = OpRISCV64MOVWUreg
   716  		return true
   717  	case OpZeroExt8to16:
   718  		v.Op = OpRISCV64MOVBUreg
   719  		return true
   720  	case OpZeroExt8to32:
   721  		v.Op = OpRISCV64MOVBUreg
   722  		return true
   723  	case OpZeroExt8to64:
   724  		v.Op = OpRISCV64MOVBUreg
   725  		return true
   726  	}
   727  	return false
   728  }
   729  func rewriteValueRISCV64_OpAddr(v *Value) bool {
   730  	v_0 := v.Args[0]
   731  	// match: (Addr {sym} base)
   732  	// result: (MOVaddr {sym} [0] base)
   733  	for {
   734  		sym := auxToSym(v.Aux)
   735  		base := v_0
   736  		v.reset(OpRISCV64MOVaddr)
   737  		v.AuxInt = int32ToAuxInt(0)
   738  		v.Aux = symToAux(sym)
   739  		v.AddArg(base)
   740  		return true
   741  	}
   742  }
   743  func rewriteValueRISCV64_OpAtomicAnd8(v *Value) bool {
   744  	v_2 := v.Args[2]
   745  	v_1 := v.Args[1]
   746  	v_0 := v.Args[0]
   747  	b := v.Block
   748  	typ := &b.Func.Config.Types
   749  	// match: (AtomicAnd8 ptr val mem)
   750  	// result: (LoweredAtomicAnd32 (ANDI <typ.Uintptr> [^3] ptr) (NOT <typ.UInt32> (SLL <typ.UInt32> (XORI <typ.UInt32> [0xff] (ZeroExt8to32 val)) (SLLI <typ.UInt64> [3] (ANDI <typ.UInt64> [3] ptr)))) mem)
   751  	for {
   752  		ptr := v_0
   753  		val := v_1
   754  		mem := v_2
   755  		v.reset(OpRISCV64LoweredAtomicAnd32)
   756  		v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Uintptr)
   757  		v0.AuxInt = int64ToAuxInt(^3)
   758  		v0.AddArg(ptr)
   759  		v1 := b.NewValue0(v.Pos, OpRISCV64NOT, typ.UInt32)
   760  		v2 := b.NewValue0(v.Pos, OpRISCV64SLL, typ.UInt32)
   761  		v3 := b.NewValue0(v.Pos, OpRISCV64XORI, typ.UInt32)
   762  		v3.AuxInt = int64ToAuxInt(0xff)
   763  		v4 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
   764  		v4.AddArg(val)
   765  		v3.AddArg(v4)
   766  		v5 := b.NewValue0(v.Pos, OpRISCV64SLLI, typ.UInt64)
   767  		v5.AuxInt = int64ToAuxInt(3)
   768  		v6 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.UInt64)
   769  		v6.AuxInt = int64ToAuxInt(3)
   770  		v6.AddArg(ptr)
   771  		v5.AddArg(v6)
   772  		v2.AddArg2(v3, v5)
   773  		v1.AddArg(v2)
   774  		v.AddArg3(v0, v1, mem)
   775  		return true
   776  	}
   777  }
   778  func rewriteValueRISCV64_OpAtomicCompareAndSwap32(v *Value) bool {
   779  	v_3 := v.Args[3]
   780  	v_2 := v.Args[2]
   781  	v_1 := v.Args[1]
   782  	v_0 := v.Args[0]
   783  	b := v.Block
   784  	typ := &b.Func.Config.Types
   785  	// match: (AtomicCompareAndSwap32 ptr old new mem)
   786  	// result: (LoweredAtomicCas32 ptr (SignExt32to64 old) new mem)
   787  	for {
   788  		ptr := v_0
   789  		old := v_1
   790  		new := v_2
   791  		mem := v_3
   792  		v.reset(OpRISCV64LoweredAtomicCas32)
   793  		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
   794  		v0.AddArg(old)
   795  		v.AddArg4(ptr, v0, new, mem)
   796  		return true
   797  	}
   798  }
   799  func rewriteValueRISCV64_OpAtomicOr8(v *Value) bool {
   800  	v_2 := v.Args[2]
   801  	v_1 := v.Args[1]
   802  	v_0 := v.Args[0]
   803  	b := v.Block
   804  	typ := &b.Func.Config.Types
   805  	// match: (AtomicOr8 ptr val mem)
   806  	// result: (LoweredAtomicOr32 (ANDI <typ.Uintptr> [^3] ptr) (SLL <typ.UInt32> (ZeroExt8to32 val) (SLLI <typ.UInt64> [3] (ANDI <typ.UInt64> [3] ptr))) mem)
   807  	for {
   808  		ptr := v_0
   809  		val := v_1
   810  		mem := v_2
   811  		v.reset(OpRISCV64LoweredAtomicOr32)
   812  		v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Uintptr)
   813  		v0.AuxInt = int64ToAuxInt(^3)
   814  		v0.AddArg(ptr)
   815  		v1 := b.NewValue0(v.Pos, OpRISCV64SLL, typ.UInt32)
   816  		v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
   817  		v2.AddArg(val)
   818  		v3 := b.NewValue0(v.Pos, OpRISCV64SLLI, typ.UInt64)
   819  		v3.AuxInt = int64ToAuxInt(3)
   820  		v4 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.UInt64)
   821  		v4.AuxInt = int64ToAuxInt(3)
   822  		v4.AddArg(ptr)
   823  		v3.AddArg(v4)
   824  		v1.AddArg2(v2, v3)
   825  		v.AddArg3(v0, v1, mem)
   826  		return true
   827  	}
   828  }
   829  func rewriteValueRISCV64_OpAvg64u(v *Value) bool {
   830  	v_1 := v.Args[1]
   831  	v_0 := v.Args[0]
   832  	b := v.Block
   833  	// match: (Avg64u <t> x y)
   834  	// result: (ADD (ADD <t> (SRLI <t> [1] x) (SRLI <t> [1] y)) (ANDI <t> [1] (AND <t> x y)))
   835  	for {
   836  		t := v.Type
   837  		x := v_0
   838  		y := v_1
   839  		v.reset(OpRISCV64ADD)
   840  		v0 := b.NewValue0(v.Pos, OpRISCV64ADD, t)
   841  		v1 := b.NewValue0(v.Pos, OpRISCV64SRLI, t)
   842  		v1.AuxInt = int64ToAuxInt(1)
   843  		v1.AddArg(x)
   844  		v2 := b.NewValue0(v.Pos, OpRISCV64SRLI, t)
   845  		v2.AuxInt = int64ToAuxInt(1)
   846  		v2.AddArg(y)
   847  		v0.AddArg2(v1, v2)
   848  		v3 := b.NewValue0(v.Pos, OpRISCV64ANDI, t)
   849  		v3.AuxInt = int64ToAuxInt(1)
   850  		v4 := b.NewValue0(v.Pos, OpRISCV64AND, t)
   851  		v4.AddArg2(x, y)
   852  		v3.AddArg(v4)
   853  		v.AddArg2(v0, v3)
   854  		return true
   855  	}
   856  }
   857  func rewriteValueRISCV64_OpConst16(v *Value) bool {
   858  	// match: (Const16 [val])
   859  	// result: (MOVDconst [int64(val)])
   860  	for {
   861  		val := auxIntToInt16(v.AuxInt)
   862  		v.reset(OpRISCV64MOVDconst)
   863  		v.AuxInt = int64ToAuxInt(int64(val))
   864  		return true
   865  	}
   866  }
   867  func rewriteValueRISCV64_OpConst32(v *Value) bool {
   868  	// match: (Const32 [val])
   869  	// result: (MOVDconst [int64(val)])
   870  	for {
   871  		val := auxIntToInt32(v.AuxInt)
   872  		v.reset(OpRISCV64MOVDconst)
   873  		v.AuxInt = int64ToAuxInt(int64(val))
   874  		return true
   875  	}
   876  }
   877  func rewriteValueRISCV64_OpConst32F(v *Value) bool {
   878  	b := v.Block
   879  	typ := &b.Func.Config.Types
   880  	// match: (Const32F [val])
   881  	// result: (FMVSX (MOVDconst [int64(math.Float32bits(val))]))
   882  	for {
   883  		val := auxIntToFloat32(v.AuxInt)
   884  		v.reset(OpRISCV64FMVSX)
   885  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
   886  		v0.AuxInt = int64ToAuxInt(int64(math.Float32bits(val)))
   887  		v.AddArg(v0)
   888  		return true
   889  	}
   890  }
   891  func rewriteValueRISCV64_OpConst64(v *Value) bool {
   892  	// match: (Const64 [val])
   893  	// result: (MOVDconst [int64(val)])
   894  	for {
   895  		val := auxIntToInt64(v.AuxInt)
   896  		v.reset(OpRISCV64MOVDconst)
   897  		v.AuxInt = int64ToAuxInt(int64(val))
   898  		return true
   899  	}
   900  }
   901  func rewriteValueRISCV64_OpConst64F(v *Value) bool {
   902  	b := v.Block
   903  	typ := &b.Func.Config.Types
   904  	// match: (Const64F [val])
   905  	// result: (FMVDX (MOVDconst [int64(math.Float64bits(val))]))
   906  	for {
   907  		val := auxIntToFloat64(v.AuxInt)
   908  		v.reset(OpRISCV64FMVDX)
   909  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
   910  		v0.AuxInt = int64ToAuxInt(int64(math.Float64bits(val)))
   911  		v.AddArg(v0)
   912  		return true
   913  	}
   914  }
   915  func rewriteValueRISCV64_OpConst8(v *Value) bool {
   916  	// match: (Const8 [val])
   917  	// result: (MOVDconst [int64(val)])
   918  	for {
   919  		val := auxIntToInt8(v.AuxInt)
   920  		v.reset(OpRISCV64MOVDconst)
   921  		v.AuxInt = int64ToAuxInt(int64(val))
   922  		return true
   923  	}
   924  }
   925  func rewriteValueRISCV64_OpConstBool(v *Value) bool {
   926  	// match: (ConstBool [val])
   927  	// result: (MOVDconst [int64(b2i(val))])
   928  	for {
   929  		val := auxIntToBool(v.AuxInt)
   930  		v.reset(OpRISCV64MOVDconst)
   931  		v.AuxInt = int64ToAuxInt(int64(b2i(val)))
   932  		return true
   933  	}
   934  }
   935  func rewriteValueRISCV64_OpConstNil(v *Value) bool {
   936  	// match: (ConstNil)
   937  	// result: (MOVDconst [0])
   938  	for {
   939  		v.reset(OpRISCV64MOVDconst)
   940  		v.AuxInt = int64ToAuxInt(0)
   941  		return true
   942  	}
   943  }
   944  func rewriteValueRISCV64_OpDiv16(v *Value) bool {
   945  	v_1 := v.Args[1]
   946  	v_0 := v.Args[0]
   947  	b := v.Block
   948  	typ := &b.Func.Config.Types
   949  	// match: (Div16 x y [false])
   950  	// result: (DIVW (SignExt16to32 x) (SignExt16to32 y))
   951  	for {
   952  		if auxIntToBool(v.AuxInt) != false {
   953  			break
   954  		}
   955  		x := v_0
   956  		y := v_1
   957  		v.reset(OpRISCV64DIVW)
   958  		v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
   959  		v0.AddArg(x)
   960  		v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
   961  		v1.AddArg(y)
   962  		v.AddArg2(v0, v1)
   963  		return true
   964  	}
   965  	return false
   966  }
   967  func rewriteValueRISCV64_OpDiv16u(v *Value) bool {
   968  	v_1 := v.Args[1]
   969  	v_0 := v.Args[0]
   970  	b := v.Block
   971  	typ := &b.Func.Config.Types
   972  	// match: (Div16u x y)
   973  	// result: (DIVUW (ZeroExt16to32 x) (ZeroExt16to32 y))
   974  	for {
   975  		x := v_0
   976  		y := v_1
   977  		v.reset(OpRISCV64DIVUW)
   978  		v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
   979  		v0.AddArg(x)
   980  		v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
   981  		v1.AddArg(y)
   982  		v.AddArg2(v0, v1)
   983  		return true
   984  	}
   985  }
   986  func rewriteValueRISCV64_OpDiv32(v *Value) bool {
   987  	v_1 := v.Args[1]
   988  	v_0 := v.Args[0]
   989  	// match: (Div32 x y [false])
   990  	// result: (DIVW x y)
   991  	for {
   992  		if auxIntToBool(v.AuxInt) != false {
   993  			break
   994  		}
   995  		x := v_0
   996  		y := v_1
   997  		v.reset(OpRISCV64DIVW)
   998  		v.AddArg2(x, y)
   999  		return true
  1000  	}
  1001  	return false
  1002  }
  1003  func rewriteValueRISCV64_OpDiv64(v *Value) bool {
  1004  	v_1 := v.Args[1]
  1005  	v_0 := v.Args[0]
  1006  	// match: (Div64 x y [false])
  1007  	// result: (DIV x y)
  1008  	for {
  1009  		if auxIntToBool(v.AuxInt) != false {
  1010  			break
  1011  		}
  1012  		x := v_0
  1013  		y := v_1
  1014  		v.reset(OpRISCV64DIV)
  1015  		v.AddArg2(x, y)
  1016  		return true
  1017  	}
  1018  	return false
  1019  }
  1020  func rewriteValueRISCV64_OpDiv8(v *Value) bool {
  1021  	v_1 := v.Args[1]
  1022  	v_0 := v.Args[0]
  1023  	b := v.Block
  1024  	typ := &b.Func.Config.Types
  1025  	// match: (Div8 x y)
  1026  	// result: (DIVW (SignExt8to32 x) (SignExt8to32 y))
  1027  	for {
  1028  		x := v_0
  1029  		y := v_1
  1030  		v.reset(OpRISCV64DIVW)
  1031  		v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
  1032  		v0.AddArg(x)
  1033  		v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
  1034  		v1.AddArg(y)
  1035  		v.AddArg2(v0, v1)
  1036  		return true
  1037  	}
  1038  }
  1039  func rewriteValueRISCV64_OpDiv8u(v *Value) bool {
  1040  	v_1 := v.Args[1]
  1041  	v_0 := v.Args[0]
  1042  	b := v.Block
  1043  	typ := &b.Func.Config.Types
  1044  	// match: (Div8u x y)
  1045  	// result: (DIVUW (ZeroExt8to32 x) (ZeroExt8to32 y))
  1046  	for {
  1047  		x := v_0
  1048  		y := v_1
  1049  		v.reset(OpRISCV64DIVUW)
  1050  		v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
  1051  		v0.AddArg(x)
  1052  		v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
  1053  		v1.AddArg(y)
  1054  		v.AddArg2(v0, v1)
  1055  		return true
  1056  	}
  1057  }
  1058  func rewriteValueRISCV64_OpEq16(v *Value) bool {
  1059  	v_1 := v.Args[1]
  1060  	v_0 := v.Args[0]
  1061  	b := v.Block
  1062  	typ := &b.Func.Config.Types
  1063  	// match: (Eq16 x y)
  1064  	// result: (SEQZ (SUB <x.Type> (ZeroExt16to64 x) (ZeroExt16to64 y)))
  1065  	for {
  1066  		x := v_0
  1067  		y := v_1
  1068  		v.reset(OpRISCV64SEQZ)
  1069  		v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
  1070  		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  1071  		v1.AddArg(x)
  1072  		v2 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  1073  		v2.AddArg(y)
  1074  		v0.AddArg2(v1, v2)
  1075  		v.AddArg(v0)
  1076  		return true
  1077  	}
  1078  }
  1079  func rewriteValueRISCV64_OpEq32(v *Value) bool {
  1080  	v_1 := v.Args[1]
  1081  	v_0 := v.Args[0]
  1082  	b := v.Block
  1083  	typ := &b.Func.Config.Types
  1084  	// match: (Eq32 x y)
  1085  	// result: (SEQZ (SUB <x.Type> (ZeroExt32to64 x) (ZeroExt32to64 y)))
  1086  	for {
  1087  		x := v_0
  1088  		y := v_1
  1089  		v.reset(OpRISCV64SEQZ)
  1090  		v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
  1091  		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1092  		v1.AddArg(x)
  1093  		v2 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1094  		v2.AddArg(y)
  1095  		v0.AddArg2(v1, v2)
  1096  		v.AddArg(v0)
  1097  		return true
  1098  	}
  1099  }
  1100  func rewriteValueRISCV64_OpEq64(v *Value) bool {
  1101  	v_1 := v.Args[1]
  1102  	v_0 := v.Args[0]
  1103  	b := v.Block
  1104  	// match: (Eq64 x y)
  1105  	// result: (SEQZ (SUB <x.Type> x y))
  1106  	for {
  1107  		x := v_0
  1108  		y := v_1
  1109  		v.reset(OpRISCV64SEQZ)
  1110  		v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
  1111  		v0.AddArg2(x, y)
  1112  		v.AddArg(v0)
  1113  		return true
  1114  	}
  1115  }
  1116  func rewriteValueRISCV64_OpEq8(v *Value) bool {
  1117  	v_1 := v.Args[1]
  1118  	v_0 := v.Args[0]
  1119  	b := v.Block
  1120  	typ := &b.Func.Config.Types
  1121  	// match: (Eq8 x y)
  1122  	// result: (SEQZ (SUB <x.Type> (ZeroExt8to64 x) (ZeroExt8to64 y)))
  1123  	for {
  1124  		x := v_0
  1125  		y := v_1
  1126  		v.reset(OpRISCV64SEQZ)
  1127  		v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
  1128  		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  1129  		v1.AddArg(x)
  1130  		v2 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  1131  		v2.AddArg(y)
  1132  		v0.AddArg2(v1, v2)
  1133  		v.AddArg(v0)
  1134  		return true
  1135  	}
  1136  }
  1137  func rewriteValueRISCV64_OpEqB(v *Value) bool {
  1138  	v_1 := v.Args[1]
  1139  	v_0 := v.Args[0]
  1140  	b := v.Block
  1141  	typ := &b.Func.Config.Types
  1142  	// match: (EqB x y)
  1143  	// result: (SEQZ (SUB <typ.Bool> x y))
  1144  	for {
  1145  		x := v_0
  1146  		y := v_1
  1147  		v.reset(OpRISCV64SEQZ)
  1148  		v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.Bool)
  1149  		v0.AddArg2(x, y)
  1150  		v.AddArg(v0)
  1151  		return true
  1152  	}
  1153  }
  1154  func rewriteValueRISCV64_OpEqPtr(v *Value) bool {
  1155  	v_1 := v.Args[1]
  1156  	v_0 := v.Args[0]
  1157  	b := v.Block
  1158  	typ := &b.Func.Config.Types
  1159  	// match: (EqPtr x y)
  1160  	// result: (SEQZ (SUB <typ.Uintptr> x y))
  1161  	for {
  1162  		x := v_0
  1163  		y := v_1
  1164  		v.reset(OpRISCV64SEQZ)
  1165  		v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.Uintptr)
  1166  		v0.AddArg2(x, y)
  1167  		v.AddArg(v0)
  1168  		return true
  1169  	}
  1170  }
  1171  func rewriteValueRISCV64_OpHmul32(v *Value) bool {
  1172  	v_1 := v.Args[1]
  1173  	v_0 := v.Args[0]
  1174  	b := v.Block
  1175  	typ := &b.Func.Config.Types
  1176  	// match: (Hmul32 x y)
  1177  	// result: (SRAI [32] (MUL (SignExt32to64 x) (SignExt32to64 y)))
  1178  	for {
  1179  		x := v_0
  1180  		y := v_1
  1181  		v.reset(OpRISCV64SRAI)
  1182  		v.AuxInt = int64ToAuxInt(32)
  1183  		v0 := b.NewValue0(v.Pos, OpRISCV64MUL, typ.Int64)
  1184  		v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  1185  		v1.AddArg(x)
  1186  		v2 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  1187  		v2.AddArg(y)
  1188  		v0.AddArg2(v1, v2)
  1189  		v.AddArg(v0)
  1190  		return true
  1191  	}
  1192  }
  1193  func rewriteValueRISCV64_OpHmul32u(v *Value) bool {
  1194  	v_1 := v.Args[1]
  1195  	v_0 := v.Args[0]
  1196  	b := v.Block
  1197  	typ := &b.Func.Config.Types
  1198  	// match: (Hmul32u x y)
  1199  	// result: (SRLI [32] (MUL (ZeroExt32to64 x) (ZeroExt32to64 y)))
  1200  	for {
  1201  		x := v_0
  1202  		y := v_1
  1203  		v.reset(OpRISCV64SRLI)
  1204  		v.AuxInt = int64ToAuxInt(32)
  1205  		v0 := b.NewValue0(v.Pos, OpRISCV64MUL, typ.Int64)
  1206  		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1207  		v1.AddArg(x)
  1208  		v2 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1209  		v2.AddArg(y)
  1210  		v0.AddArg2(v1, v2)
  1211  		v.AddArg(v0)
  1212  		return true
  1213  	}
  1214  }
  1215  func rewriteValueRISCV64_OpLeq16(v *Value) bool {
  1216  	v_1 := v.Args[1]
  1217  	v_0 := v.Args[0]
  1218  	b := v.Block
  1219  	typ := &b.Func.Config.Types
  1220  	// match: (Leq16 x y)
  1221  	// result: (Not (Less16 y x))
  1222  	for {
  1223  		x := v_0
  1224  		y := v_1
  1225  		v.reset(OpNot)
  1226  		v0 := b.NewValue0(v.Pos, OpLess16, typ.Bool)
  1227  		v0.AddArg2(y, x)
  1228  		v.AddArg(v0)
  1229  		return true
  1230  	}
  1231  }
  1232  func rewriteValueRISCV64_OpLeq16U(v *Value) bool {
  1233  	v_1 := v.Args[1]
  1234  	v_0 := v.Args[0]
  1235  	b := v.Block
  1236  	typ := &b.Func.Config.Types
  1237  	// match: (Leq16U x y)
  1238  	// result: (Not (Less16U y x))
  1239  	for {
  1240  		x := v_0
  1241  		y := v_1
  1242  		v.reset(OpNot)
  1243  		v0 := b.NewValue0(v.Pos, OpLess16U, typ.Bool)
  1244  		v0.AddArg2(y, x)
  1245  		v.AddArg(v0)
  1246  		return true
  1247  	}
  1248  }
  1249  func rewriteValueRISCV64_OpLeq32(v *Value) bool {
  1250  	v_1 := v.Args[1]
  1251  	v_0 := v.Args[0]
  1252  	b := v.Block
  1253  	typ := &b.Func.Config.Types
  1254  	// match: (Leq32 x y)
  1255  	// result: (Not (Less32 y x))
  1256  	for {
  1257  		x := v_0
  1258  		y := v_1
  1259  		v.reset(OpNot)
  1260  		v0 := b.NewValue0(v.Pos, OpLess32, typ.Bool)
  1261  		v0.AddArg2(y, x)
  1262  		v.AddArg(v0)
  1263  		return true
  1264  	}
  1265  }
  1266  func rewriteValueRISCV64_OpLeq32U(v *Value) bool {
  1267  	v_1 := v.Args[1]
  1268  	v_0 := v.Args[0]
  1269  	b := v.Block
  1270  	typ := &b.Func.Config.Types
  1271  	// match: (Leq32U x y)
  1272  	// result: (Not (Less32U y x))
  1273  	for {
  1274  		x := v_0
  1275  		y := v_1
  1276  		v.reset(OpNot)
  1277  		v0 := b.NewValue0(v.Pos, OpLess32U, typ.Bool)
  1278  		v0.AddArg2(y, x)
  1279  		v.AddArg(v0)
  1280  		return true
  1281  	}
  1282  }
  1283  func rewriteValueRISCV64_OpLeq64(v *Value) bool {
  1284  	v_1 := v.Args[1]
  1285  	v_0 := v.Args[0]
  1286  	b := v.Block
  1287  	typ := &b.Func.Config.Types
  1288  	// match: (Leq64 x y)
  1289  	// result: (Not (Less64 y x))
  1290  	for {
  1291  		x := v_0
  1292  		y := v_1
  1293  		v.reset(OpNot)
  1294  		v0 := b.NewValue0(v.Pos, OpLess64, typ.Bool)
  1295  		v0.AddArg2(y, x)
  1296  		v.AddArg(v0)
  1297  		return true
  1298  	}
  1299  }
  1300  func rewriteValueRISCV64_OpLeq64U(v *Value) bool {
  1301  	v_1 := v.Args[1]
  1302  	v_0 := v.Args[0]
  1303  	b := v.Block
  1304  	typ := &b.Func.Config.Types
  1305  	// match: (Leq64U x y)
  1306  	// result: (Not (Less64U y x))
  1307  	for {
  1308  		x := v_0
  1309  		y := v_1
  1310  		v.reset(OpNot)
  1311  		v0 := b.NewValue0(v.Pos, OpLess64U, typ.Bool)
  1312  		v0.AddArg2(y, x)
  1313  		v.AddArg(v0)
  1314  		return true
  1315  	}
  1316  }
  1317  func rewriteValueRISCV64_OpLeq8(v *Value) bool {
  1318  	v_1 := v.Args[1]
  1319  	v_0 := v.Args[0]
  1320  	b := v.Block
  1321  	typ := &b.Func.Config.Types
  1322  	// match: (Leq8 x y)
  1323  	// result: (Not (Less8 y x))
  1324  	for {
  1325  		x := v_0
  1326  		y := v_1
  1327  		v.reset(OpNot)
  1328  		v0 := b.NewValue0(v.Pos, OpLess8, typ.Bool)
  1329  		v0.AddArg2(y, x)
  1330  		v.AddArg(v0)
  1331  		return true
  1332  	}
  1333  }
  1334  func rewriteValueRISCV64_OpLeq8U(v *Value) bool {
  1335  	v_1 := v.Args[1]
  1336  	v_0 := v.Args[0]
  1337  	b := v.Block
  1338  	typ := &b.Func.Config.Types
  1339  	// match: (Leq8U x y)
  1340  	// result: (Not (Less8U y x))
  1341  	for {
  1342  		x := v_0
  1343  		y := v_1
  1344  		v.reset(OpNot)
  1345  		v0 := b.NewValue0(v.Pos, OpLess8U, typ.Bool)
  1346  		v0.AddArg2(y, x)
  1347  		v.AddArg(v0)
  1348  		return true
  1349  	}
  1350  }
  1351  func rewriteValueRISCV64_OpLess16(v *Value) bool {
  1352  	v_1 := v.Args[1]
  1353  	v_0 := v.Args[0]
  1354  	b := v.Block
  1355  	typ := &b.Func.Config.Types
  1356  	// match: (Less16 x y)
  1357  	// result: (SLT (SignExt16to64 x) (SignExt16to64 y))
  1358  	for {
  1359  		x := v_0
  1360  		y := v_1
  1361  		v.reset(OpRISCV64SLT)
  1362  		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  1363  		v0.AddArg(x)
  1364  		v1 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  1365  		v1.AddArg(y)
  1366  		v.AddArg2(v0, v1)
  1367  		return true
  1368  	}
  1369  }
  1370  func rewriteValueRISCV64_OpLess16U(v *Value) bool {
  1371  	v_1 := v.Args[1]
  1372  	v_0 := v.Args[0]
  1373  	b := v.Block
  1374  	typ := &b.Func.Config.Types
  1375  	// match: (Less16U x y)
  1376  	// result: (SLTU (ZeroExt16to64 x) (ZeroExt16to64 y))
  1377  	for {
  1378  		x := v_0
  1379  		y := v_1
  1380  		v.reset(OpRISCV64SLTU)
  1381  		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  1382  		v0.AddArg(x)
  1383  		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  1384  		v1.AddArg(y)
  1385  		v.AddArg2(v0, v1)
  1386  		return true
  1387  	}
  1388  }
  1389  func rewriteValueRISCV64_OpLess32(v *Value) bool {
  1390  	v_1 := v.Args[1]
  1391  	v_0 := v.Args[0]
  1392  	b := v.Block
  1393  	typ := &b.Func.Config.Types
  1394  	// match: (Less32 x y)
  1395  	// result: (SLT (SignExt32to64 x) (SignExt32to64 y))
  1396  	for {
  1397  		x := v_0
  1398  		y := v_1
  1399  		v.reset(OpRISCV64SLT)
  1400  		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  1401  		v0.AddArg(x)
  1402  		v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  1403  		v1.AddArg(y)
  1404  		v.AddArg2(v0, v1)
  1405  		return true
  1406  	}
  1407  }
  1408  func rewriteValueRISCV64_OpLess32U(v *Value) bool {
  1409  	v_1 := v.Args[1]
  1410  	v_0 := v.Args[0]
  1411  	b := v.Block
  1412  	typ := &b.Func.Config.Types
  1413  	// match: (Less32U x y)
  1414  	// result: (SLTU (ZeroExt32to64 x) (ZeroExt32to64 y))
  1415  	for {
  1416  		x := v_0
  1417  		y := v_1
  1418  		v.reset(OpRISCV64SLTU)
  1419  		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1420  		v0.AddArg(x)
  1421  		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1422  		v1.AddArg(y)
  1423  		v.AddArg2(v0, v1)
  1424  		return true
  1425  	}
  1426  }
  1427  func rewriteValueRISCV64_OpLess8(v *Value) bool {
  1428  	v_1 := v.Args[1]
  1429  	v_0 := v.Args[0]
  1430  	b := v.Block
  1431  	typ := &b.Func.Config.Types
  1432  	// match: (Less8 x y)
  1433  	// result: (SLT (SignExt8to64 x) (SignExt8to64 y))
  1434  	for {
  1435  		x := v_0
  1436  		y := v_1
  1437  		v.reset(OpRISCV64SLT)
  1438  		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  1439  		v0.AddArg(x)
  1440  		v1 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  1441  		v1.AddArg(y)
  1442  		v.AddArg2(v0, v1)
  1443  		return true
  1444  	}
  1445  }
  1446  func rewriteValueRISCV64_OpLess8U(v *Value) bool {
  1447  	v_1 := v.Args[1]
  1448  	v_0 := v.Args[0]
  1449  	b := v.Block
  1450  	typ := &b.Func.Config.Types
  1451  	// match: (Less8U x y)
  1452  	// result: (SLTU (ZeroExt8to64 x) (ZeroExt8to64 y))
  1453  	for {
  1454  		x := v_0
  1455  		y := v_1
  1456  		v.reset(OpRISCV64SLTU)
  1457  		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  1458  		v0.AddArg(x)
  1459  		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  1460  		v1.AddArg(y)
  1461  		v.AddArg2(v0, v1)
  1462  		return true
  1463  	}
  1464  }
  1465  func rewriteValueRISCV64_OpLoad(v *Value) bool {
  1466  	v_1 := v.Args[1]
  1467  	v_0 := v.Args[0]
  1468  	// match: (Load <t> ptr mem)
  1469  	// cond: t.IsBoolean()
  1470  	// result: (MOVBUload ptr mem)
  1471  	for {
  1472  		t := v.Type
  1473  		ptr := v_0
  1474  		mem := v_1
  1475  		if !(t.IsBoolean()) {
  1476  			break
  1477  		}
  1478  		v.reset(OpRISCV64MOVBUload)
  1479  		v.AddArg2(ptr, mem)
  1480  		return true
  1481  	}
  1482  	// match: (Load <t> ptr mem)
  1483  	// cond: ( is8BitInt(t) && isSigned(t))
  1484  	// result: (MOVBload ptr mem)
  1485  	for {
  1486  		t := v.Type
  1487  		ptr := v_0
  1488  		mem := v_1
  1489  		if !(is8BitInt(t) && isSigned(t)) {
  1490  			break
  1491  		}
  1492  		v.reset(OpRISCV64MOVBload)
  1493  		v.AddArg2(ptr, mem)
  1494  		return true
  1495  	}
  1496  	// match: (Load <t> ptr mem)
  1497  	// cond: ( is8BitInt(t) && !isSigned(t))
  1498  	// result: (MOVBUload ptr mem)
  1499  	for {
  1500  		t := v.Type
  1501  		ptr := v_0
  1502  		mem := v_1
  1503  		if !(is8BitInt(t) && !isSigned(t)) {
  1504  			break
  1505  		}
  1506  		v.reset(OpRISCV64MOVBUload)
  1507  		v.AddArg2(ptr, mem)
  1508  		return true
  1509  	}
  1510  	// match: (Load <t> ptr mem)
  1511  	// cond: (is16BitInt(t) && isSigned(t))
  1512  	// result: (MOVHload ptr mem)
  1513  	for {
  1514  		t := v.Type
  1515  		ptr := v_0
  1516  		mem := v_1
  1517  		if !(is16BitInt(t) && isSigned(t)) {
  1518  			break
  1519  		}
  1520  		v.reset(OpRISCV64MOVHload)
  1521  		v.AddArg2(ptr, mem)
  1522  		return true
  1523  	}
  1524  	// match: (Load <t> ptr mem)
  1525  	// cond: (is16BitInt(t) && !isSigned(t))
  1526  	// result: (MOVHUload ptr mem)
  1527  	for {
  1528  		t := v.Type
  1529  		ptr := v_0
  1530  		mem := v_1
  1531  		if !(is16BitInt(t) && !isSigned(t)) {
  1532  			break
  1533  		}
  1534  		v.reset(OpRISCV64MOVHUload)
  1535  		v.AddArg2(ptr, mem)
  1536  		return true
  1537  	}
  1538  	// match: (Load <t> ptr mem)
  1539  	// cond: (is32BitInt(t) && isSigned(t))
  1540  	// result: (MOVWload ptr mem)
  1541  	for {
  1542  		t := v.Type
  1543  		ptr := v_0
  1544  		mem := v_1
  1545  		if !(is32BitInt(t) && isSigned(t)) {
  1546  			break
  1547  		}
  1548  		v.reset(OpRISCV64MOVWload)
  1549  		v.AddArg2(ptr, mem)
  1550  		return true
  1551  	}
  1552  	// match: (Load <t> ptr mem)
  1553  	// cond: (is32BitInt(t) && !isSigned(t))
  1554  	// result: (MOVWUload ptr mem)
  1555  	for {
  1556  		t := v.Type
  1557  		ptr := v_0
  1558  		mem := v_1
  1559  		if !(is32BitInt(t) && !isSigned(t)) {
  1560  			break
  1561  		}
  1562  		v.reset(OpRISCV64MOVWUload)
  1563  		v.AddArg2(ptr, mem)
  1564  		return true
  1565  	}
  1566  	// match: (Load <t> ptr mem)
  1567  	// cond: (is64BitInt(t) || isPtr(t))
  1568  	// result: (MOVDload ptr mem)
  1569  	for {
  1570  		t := v.Type
  1571  		ptr := v_0
  1572  		mem := v_1
  1573  		if !(is64BitInt(t) || isPtr(t)) {
  1574  			break
  1575  		}
  1576  		v.reset(OpRISCV64MOVDload)
  1577  		v.AddArg2(ptr, mem)
  1578  		return true
  1579  	}
  1580  	// match: (Load <t> ptr mem)
  1581  	// cond: is32BitFloat(t)
  1582  	// result: (FMOVWload ptr mem)
  1583  	for {
  1584  		t := v.Type
  1585  		ptr := v_0
  1586  		mem := v_1
  1587  		if !(is32BitFloat(t)) {
  1588  			break
  1589  		}
  1590  		v.reset(OpRISCV64FMOVWload)
  1591  		v.AddArg2(ptr, mem)
  1592  		return true
  1593  	}
  1594  	// match: (Load <t> ptr mem)
  1595  	// cond: is64BitFloat(t)
  1596  	// result: (FMOVDload ptr mem)
  1597  	for {
  1598  		t := v.Type
  1599  		ptr := v_0
  1600  		mem := v_1
  1601  		if !(is64BitFloat(t)) {
  1602  			break
  1603  		}
  1604  		v.reset(OpRISCV64FMOVDload)
  1605  		v.AddArg2(ptr, mem)
  1606  		return true
  1607  	}
  1608  	return false
  1609  }
  1610  func rewriteValueRISCV64_OpLocalAddr(v *Value) bool {
  1611  	v_0 := v.Args[0]
  1612  	// match: (LocalAddr {sym} base _)
  1613  	// result: (MOVaddr {sym} base)
  1614  	for {
  1615  		sym := auxToSym(v.Aux)
  1616  		base := v_0
  1617  		v.reset(OpRISCV64MOVaddr)
  1618  		v.Aux = symToAux(sym)
  1619  		v.AddArg(base)
  1620  		return true
  1621  	}
  1622  }
  1623  func rewriteValueRISCV64_OpLsh16x16(v *Value) bool {
  1624  	v_1 := v.Args[1]
  1625  	v_0 := v.Args[0]
  1626  	b := v.Block
  1627  	typ := &b.Func.Config.Types
  1628  	// match: (Lsh16x16 <t> x y)
  1629  	// cond: !shiftIsBounded(v)
  1630  	// result: (AND (SLL <t> x y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
  1631  	for {
  1632  		t := v.Type
  1633  		x := v_0
  1634  		y := v_1
  1635  		if !(!shiftIsBounded(v)) {
  1636  			break
  1637  		}
  1638  		v.reset(OpRISCV64AND)
  1639  		v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
  1640  		v0.AddArg2(x, y)
  1641  		v1 := b.NewValue0(v.Pos, OpNeg16, t)
  1642  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  1643  		v2.AuxInt = int64ToAuxInt(64)
  1644  		v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  1645  		v3.AddArg(y)
  1646  		v2.AddArg(v3)
  1647  		v1.AddArg(v2)
  1648  		v.AddArg2(v0, v1)
  1649  		return true
  1650  	}
  1651  	// match: (Lsh16x16 x y)
  1652  	// cond: shiftIsBounded(v)
  1653  	// result: (SLL x y)
  1654  	for {
  1655  		x := v_0
  1656  		y := v_1
  1657  		if !(shiftIsBounded(v)) {
  1658  			break
  1659  		}
  1660  		v.reset(OpRISCV64SLL)
  1661  		v.AddArg2(x, y)
  1662  		return true
  1663  	}
  1664  	return false
  1665  }
  1666  func rewriteValueRISCV64_OpLsh16x32(v *Value) bool {
  1667  	v_1 := v.Args[1]
  1668  	v_0 := v.Args[0]
  1669  	b := v.Block
  1670  	typ := &b.Func.Config.Types
  1671  	// match: (Lsh16x32 <t> x y)
  1672  	// cond: !shiftIsBounded(v)
  1673  	// result: (AND (SLL <t> x y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
  1674  	for {
  1675  		t := v.Type
  1676  		x := v_0
  1677  		y := v_1
  1678  		if !(!shiftIsBounded(v)) {
  1679  			break
  1680  		}
  1681  		v.reset(OpRISCV64AND)
  1682  		v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
  1683  		v0.AddArg2(x, y)
  1684  		v1 := b.NewValue0(v.Pos, OpNeg16, t)
  1685  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  1686  		v2.AuxInt = int64ToAuxInt(64)
  1687  		v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1688  		v3.AddArg(y)
  1689  		v2.AddArg(v3)
  1690  		v1.AddArg(v2)
  1691  		v.AddArg2(v0, v1)
  1692  		return true
  1693  	}
  1694  	// match: (Lsh16x32 x y)
  1695  	// cond: shiftIsBounded(v)
  1696  	// result: (SLL x y)
  1697  	for {
  1698  		x := v_0
  1699  		y := v_1
  1700  		if !(shiftIsBounded(v)) {
  1701  			break
  1702  		}
  1703  		v.reset(OpRISCV64SLL)
  1704  		v.AddArg2(x, y)
  1705  		return true
  1706  	}
  1707  	return false
  1708  }
  1709  func rewriteValueRISCV64_OpLsh16x64(v *Value) bool {
  1710  	v_1 := v.Args[1]
  1711  	v_0 := v.Args[0]
  1712  	b := v.Block
  1713  	// match: (Lsh16x64 <t> x y)
  1714  	// cond: !shiftIsBounded(v)
  1715  	// result: (AND (SLL <t> x y) (Neg16 <t> (SLTIU <t> [64] y)))
  1716  	for {
  1717  		t := v.Type
  1718  		x := v_0
  1719  		y := v_1
  1720  		if !(!shiftIsBounded(v)) {
  1721  			break
  1722  		}
  1723  		v.reset(OpRISCV64AND)
  1724  		v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
  1725  		v0.AddArg2(x, y)
  1726  		v1 := b.NewValue0(v.Pos, OpNeg16, t)
  1727  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  1728  		v2.AuxInt = int64ToAuxInt(64)
  1729  		v2.AddArg(y)
  1730  		v1.AddArg(v2)
  1731  		v.AddArg2(v0, v1)
  1732  		return true
  1733  	}
  1734  	// match: (Lsh16x64 x y)
  1735  	// cond: shiftIsBounded(v)
  1736  	// result: (SLL x y)
  1737  	for {
  1738  		x := v_0
  1739  		y := v_1
  1740  		if !(shiftIsBounded(v)) {
  1741  			break
  1742  		}
  1743  		v.reset(OpRISCV64SLL)
  1744  		v.AddArg2(x, y)
  1745  		return true
  1746  	}
  1747  	return false
  1748  }
  1749  func rewriteValueRISCV64_OpLsh16x8(v *Value) bool {
  1750  	v_1 := v.Args[1]
  1751  	v_0 := v.Args[0]
  1752  	b := v.Block
  1753  	typ := &b.Func.Config.Types
  1754  	// match: (Lsh16x8 <t> x y)
  1755  	// cond: !shiftIsBounded(v)
  1756  	// result: (AND (SLL <t> x y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
  1757  	for {
  1758  		t := v.Type
  1759  		x := v_0
  1760  		y := v_1
  1761  		if !(!shiftIsBounded(v)) {
  1762  			break
  1763  		}
  1764  		v.reset(OpRISCV64AND)
  1765  		v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
  1766  		v0.AddArg2(x, y)
  1767  		v1 := b.NewValue0(v.Pos, OpNeg16, t)
  1768  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  1769  		v2.AuxInt = int64ToAuxInt(64)
  1770  		v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  1771  		v3.AddArg(y)
  1772  		v2.AddArg(v3)
  1773  		v1.AddArg(v2)
  1774  		v.AddArg2(v0, v1)
  1775  		return true
  1776  	}
  1777  	// match: (Lsh16x8 x y)
  1778  	// cond: shiftIsBounded(v)
  1779  	// result: (SLL x y)
  1780  	for {
  1781  		x := v_0
  1782  		y := v_1
  1783  		if !(shiftIsBounded(v)) {
  1784  			break
  1785  		}
  1786  		v.reset(OpRISCV64SLL)
  1787  		v.AddArg2(x, y)
  1788  		return true
  1789  	}
  1790  	return false
  1791  }
  1792  func rewriteValueRISCV64_OpLsh32x16(v *Value) bool {
  1793  	v_1 := v.Args[1]
  1794  	v_0 := v.Args[0]
  1795  	b := v.Block
  1796  	typ := &b.Func.Config.Types
  1797  	// match: (Lsh32x16 <t> x y)
  1798  	// cond: !shiftIsBounded(v)
  1799  	// result: (AND (SLL <t> x y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
  1800  	for {
  1801  		t := v.Type
  1802  		x := v_0
  1803  		y := v_1
  1804  		if !(!shiftIsBounded(v)) {
  1805  			break
  1806  		}
  1807  		v.reset(OpRISCV64AND)
  1808  		v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
  1809  		v0.AddArg2(x, y)
  1810  		v1 := b.NewValue0(v.Pos, OpNeg32, t)
  1811  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  1812  		v2.AuxInt = int64ToAuxInt(64)
  1813  		v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  1814  		v3.AddArg(y)
  1815  		v2.AddArg(v3)
  1816  		v1.AddArg(v2)
  1817  		v.AddArg2(v0, v1)
  1818  		return true
  1819  	}
  1820  	// match: (Lsh32x16 x y)
  1821  	// cond: shiftIsBounded(v)
  1822  	// result: (SLL x y)
  1823  	for {
  1824  		x := v_0
  1825  		y := v_1
  1826  		if !(shiftIsBounded(v)) {
  1827  			break
  1828  		}
  1829  		v.reset(OpRISCV64SLL)
  1830  		v.AddArg2(x, y)
  1831  		return true
  1832  	}
  1833  	return false
  1834  }
  1835  func rewriteValueRISCV64_OpLsh32x32(v *Value) bool {
  1836  	v_1 := v.Args[1]
  1837  	v_0 := v.Args[0]
  1838  	b := v.Block
  1839  	typ := &b.Func.Config.Types
  1840  	// match: (Lsh32x32 <t> x y)
  1841  	// cond: !shiftIsBounded(v)
  1842  	// result: (AND (SLL <t> x y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
  1843  	for {
  1844  		t := v.Type
  1845  		x := v_0
  1846  		y := v_1
  1847  		if !(!shiftIsBounded(v)) {
  1848  			break
  1849  		}
  1850  		v.reset(OpRISCV64AND)
  1851  		v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
  1852  		v0.AddArg2(x, y)
  1853  		v1 := b.NewValue0(v.Pos, OpNeg32, t)
  1854  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  1855  		v2.AuxInt = int64ToAuxInt(64)
  1856  		v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  1857  		v3.AddArg(y)
  1858  		v2.AddArg(v3)
  1859  		v1.AddArg(v2)
  1860  		v.AddArg2(v0, v1)
  1861  		return true
  1862  	}
  1863  	// match: (Lsh32x32 x y)
  1864  	// cond: shiftIsBounded(v)
  1865  	// result: (SLL x y)
  1866  	for {
  1867  		x := v_0
  1868  		y := v_1
  1869  		if !(shiftIsBounded(v)) {
  1870  			break
  1871  		}
  1872  		v.reset(OpRISCV64SLL)
  1873  		v.AddArg2(x, y)
  1874  		return true
  1875  	}
  1876  	return false
  1877  }
  1878  func rewriteValueRISCV64_OpLsh32x64(v *Value) bool {
  1879  	v_1 := v.Args[1]
  1880  	v_0 := v.Args[0]
  1881  	b := v.Block
  1882  	// match: (Lsh32x64 <t> x y)
  1883  	// cond: !shiftIsBounded(v)
  1884  	// result: (AND (SLL <t> x y) (Neg32 <t> (SLTIU <t> [64] y)))
  1885  	for {
  1886  		t := v.Type
  1887  		x := v_0
  1888  		y := v_1
  1889  		if !(!shiftIsBounded(v)) {
  1890  			break
  1891  		}
  1892  		v.reset(OpRISCV64AND)
  1893  		v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
  1894  		v0.AddArg2(x, y)
  1895  		v1 := b.NewValue0(v.Pos, OpNeg32, t)
  1896  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  1897  		v2.AuxInt = int64ToAuxInt(64)
  1898  		v2.AddArg(y)
  1899  		v1.AddArg(v2)
  1900  		v.AddArg2(v0, v1)
  1901  		return true
  1902  	}
  1903  	// match: (Lsh32x64 x y)
  1904  	// cond: shiftIsBounded(v)
  1905  	// result: (SLL x y)
  1906  	for {
  1907  		x := v_0
  1908  		y := v_1
  1909  		if !(shiftIsBounded(v)) {
  1910  			break
  1911  		}
  1912  		v.reset(OpRISCV64SLL)
  1913  		v.AddArg2(x, y)
  1914  		return true
  1915  	}
  1916  	return false
  1917  }
  1918  func rewriteValueRISCV64_OpLsh32x8(v *Value) bool {
  1919  	v_1 := v.Args[1]
  1920  	v_0 := v.Args[0]
  1921  	b := v.Block
  1922  	typ := &b.Func.Config.Types
  1923  	// match: (Lsh32x8 <t> x y)
  1924  	// cond: !shiftIsBounded(v)
  1925  	// result: (AND (SLL <t> x y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
  1926  	for {
  1927  		t := v.Type
  1928  		x := v_0
  1929  		y := v_1
  1930  		if !(!shiftIsBounded(v)) {
  1931  			break
  1932  		}
  1933  		v.reset(OpRISCV64AND)
  1934  		v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
  1935  		v0.AddArg2(x, y)
  1936  		v1 := b.NewValue0(v.Pos, OpNeg32, t)
  1937  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  1938  		v2.AuxInt = int64ToAuxInt(64)
  1939  		v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  1940  		v3.AddArg(y)
  1941  		v2.AddArg(v3)
  1942  		v1.AddArg(v2)
  1943  		v.AddArg2(v0, v1)
  1944  		return true
  1945  	}
  1946  	// match: (Lsh32x8 x y)
  1947  	// cond: shiftIsBounded(v)
  1948  	// result: (SLL x y)
  1949  	for {
  1950  		x := v_0
  1951  		y := v_1
  1952  		if !(shiftIsBounded(v)) {
  1953  			break
  1954  		}
  1955  		v.reset(OpRISCV64SLL)
  1956  		v.AddArg2(x, y)
  1957  		return true
  1958  	}
  1959  	return false
  1960  }
  1961  func rewriteValueRISCV64_OpLsh64x16(v *Value) bool {
  1962  	v_1 := v.Args[1]
  1963  	v_0 := v.Args[0]
  1964  	b := v.Block
  1965  	typ := &b.Func.Config.Types
  1966  	// match: (Lsh64x16 <t> x y)
  1967  	// cond: !shiftIsBounded(v)
  1968  	// result: (AND (SLL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
  1969  	for {
  1970  		t := v.Type
  1971  		x := v_0
  1972  		y := v_1
  1973  		if !(!shiftIsBounded(v)) {
  1974  			break
  1975  		}
  1976  		v.reset(OpRISCV64AND)
  1977  		v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
  1978  		v0.AddArg2(x, y)
  1979  		v1 := b.NewValue0(v.Pos, OpNeg64, t)
  1980  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  1981  		v2.AuxInt = int64ToAuxInt(64)
  1982  		v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  1983  		v3.AddArg(y)
  1984  		v2.AddArg(v3)
  1985  		v1.AddArg(v2)
  1986  		v.AddArg2(v0, v1)
  1987  		return true
  1988  	}
  1989  	// match: (Lsh64x16 x y)
  1990  	// cond: shiftIsBounded(v)
  1991  	// result: (SLL x y)
  1992  	for {
  1993  		x := v_0
  1994  		y := v_1
  1995  		if !(shiftIsBounded(v)) {
  1996  			break
  1997  		}
  1998  		v.reset(OpRISCV64SLL)
  1999  		v.AddArg2(x, y)
  2000  		return true
  2001  	}
  2002  	return false
  2003  }
  2004  func rewriteValueRISCV64_OpLsh64x32(v *Value) bool {
  2005  	v_1 := v.Args[1]
  2006  	v_0 := v.Args[0]
  2007  	b := v.Block
  2008  	typ := &b.Func.Config.Types
  2009  	// match: (Lsh64x32 <t> x y)
  2010  	// cond: !shiftIsBounded(v)
  2011  	// result: (AND (SLL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
  2012  	for {
  2013  		t := v.Type
  2014  		x := v_0
  2015  		y := v_1
  2016  		if !(!shiftIsBounded(v)) {
  2017  			break
  2018  		}
  2019  		v.reset(OpRISCV64AND)
  2020  		v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
  2021  		v0.AddArg2(x, y)
  2022  		v1 := b.NewValue0(v.Pos, OpNeg64, t)
  2023  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  2024  		v2.AuxInt = int64ToAuxInt(64)
  2025  		v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  2026  		v3.AddArg(y)
  2027  		v2.AddArg(v3)
  2028  		v1.AddArg(v2)
  2029  		v.AddArg2(v0, v1)
  2030  		return true
  2031  	}
  2032  	// match: (Lsh64x32 x y)
  2033  	// cond: shiftIsBounded(v)
  2034  	// result: (SLL x y)
  2035  	for {
  2036  		x := v_0
  2037  		y := v_1
  2038  		if !(shiftIsBounded(v)) {
  2039  			break
  2040  		}
  2041  		v.reset(OpRISCV64SLL)
  2042  		v.AddArg2(x, y)
  2043  		return true
  2044  	}
  2045  	return false
  2046  }
  2047  func rewriteValueRISCV64_OpLsh64x64(v *Value) bool {
  2048  	v_1 := v.Args[1]
  2049  	v_0 := v.Args[0]
  2050  	b := v.Block
  2051  	// match: (Lsh64x64 <t> x y)
  2052  	// cond: !shiftIsBounded(v)
  2053  	// result: (AND (SLL <t> x y) (Neg64 <t> (SLTIU <t> [64] y)))
  2054  	for {
  2055  		t := v.Type
  2056  		x := v_0
  2057  		y := v_1
  2058  		if !(!shiftIsBounded(v)) {
  2059  			break
  2060  		}
  2061  		v.reset(OpRISCV64AND)
  2062  		v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
  2063  		v0.AddArg2(x, y)
  2064  		v1 := b.NewValue0(v.Pos, OpNeg64, t)
  2065  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  2066  		v2.AuxInt = int64ToAuxInt(64)
  2067  		v2.AddArg(y)
  2068  		v1.AddArg(v2)
  2069  		v.AddArg2(v0, v1)
  2070  		return true
  2071  	}
  2072  	// match: (Lsh64x64 x y)
  2073  	// cond: shiftIsBounded(v)
  2074  	// result: (SLL x y)
  2075  	for {
  2076  		x := v_0
  2077  		y := v_1
  2078  		if !(shiftIsBounded(v)) {
  2079  			break
  2080  		}
  2081  		v.reset(OpRISCV64SLL)
  2082  		v.AddArg2(x, y)
  2083  		return true
  2084  	}
  2085  	return false
  2086  }
  2087  func rewriteValueRISCV64_OpLsh64x8(v *Value) bool {
  2088  	v_1 := v.Args[1]
  2089  	v_0 := v.Args[0]
  2090  	b := v.Block
  2091  	typ := &b.Func.Config.Types
  2092  	// match: (Lsh64x8 <t> x y)
  2093  	// cond: !shiftIsBounded(v)
  2094  	// result: (AND (SLL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
  2095  	for {
  2096  		t := v.Type
  2097  		x := v_0
  2098  		y := v_1
  2099  		if !(!shiftIsBounded(v)) {
  2100  			break
  2101  		}
  2102  		v.reset(OpRISCV64AND)
  2103  		v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
  2104  		v0.AddArg2(x, y)
  2105  		v1 := b.NewValue0(v.Pos, OpNeg64, t)
  2106  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  2107  		v2.AuxInt = int64ToAuxInt(64)
  2108  		v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  2109  		v3.AddArg(y)
  2110  		v2.AddArg(v3)
  2111  		v1.AddArg(v2)
  2112  		v.AddArg2(v0, v1)
  2113  		return true
  2114  	}
  2115  	// match: (Lsh64x8 x y)
  2116  	// cond: shiftIsBounded(v)
  2117  	// result: (SLL x y)
  2118  	for {
  2119  		x := v_0
  2120  		y := v_1
  2121  		if !(shiftIsBounded(v)) {
  2122  			break
  2123  		}
  2124  		v.reset(OpRISCV64SLL)
  2125  		v.AddArg2(x, y)
  2126  		return true
  2127  	}
  2128  	return false
  2129  }
  2130  func rewriteValueRISCV64_OpLsh8x16(v *Value) bool {
  2131  	v_1 := v.Args[1]
  2132  	v_0 := v.Args[0]
  2133  	b := v.Block
  2134  	typ := &b.Func.Config.Types
  2135  	// match: (Lsh8x16 <t> x y)
  2136  	// cond: !shiftIsBounded(v)
  2137  	// result: (AND (SLL <t> x y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
  2138  	for {
  2139  		t := v.Type
  2140  		x := v_0
  2141  		y := v_1
  2142  		if !(!shiftIsBounded(v)) {
  2143  			break
  2144  		}
  2145  		v.reset(OpRISCV64AND)
  2146  		v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
  2147  		v0.AddArg2(x, y)
  2148  		v1 := b.NewValue0(v.Pos, OpNeg8, t)
  2149  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  2150  		v2.AuxInt = int64ToAuxInt(64)
  2151  		v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  2152  		v3.AddArg(y)
  2153  		v2.AddArg(v3)
  2154  		v1.AddArg(v2)
  2155  		v.AddArg2(v0, v1)
  2156  		return true
  2157  	}
  2158  	// match: (Lsh8x16 x y)
  2159  	// cond: shiftIsBounded(v)
  2160  	// result: (SLL x y)
  2161  	for {
  2162  		x := v_0
  2163  		y := v_1
  2164  		if !(shiftIsBounded(v)) {
  2165  			break
  2166  		}
  2167  		v.reset(OpRISCV64SLL)
  2168  		v.AddArg2(x, y)
  2169  		return true
  2170  	}
  2171  	return false
  2172  }
  2173  func rewriteValueRISCV64_OpLsh8x32(v *Value) bool {
  2174  	v_1 := v.Args[1]
  2175  	v_0 := v.Args[0]
  2176  	b := v.Block
  2177  	typ := &b.Func.Config.Types
  2178  	// match: (Lsh8x32 <t> x y)
  2179  	// cond: !shiftIsBounded(v)
  2180  	// result: (AND (SLL <t> x y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
  2181  	for {
  2182  		t := v.Type
  2183  		x := v_0
  2184  		y := v_1
  2185  		if !(!shiftIsBounded(v)) {
  2186  			break
  2187  		}
  2188  		v.reset(OpRISCV64AND)
  2189  		v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
  2190  		v0.AddArg2(x, y)
  2191  		v1 := b.NewValue0(v.Pos, OpNeg8, t)
  2192  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  2193  		v2.AuxInt = int64ToAuxInt(64)
  2194  		v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  2195  		v3.AddArg(y)
  2196  		v2.AddArg(v3)
  2197  		v1.AddArg(v2)
  2198  		v.AddArg2(v0, v1)
  2199  		return true
  2200  	}
  2201  	// match: (Lsh8x32 x y)
  2202  	// cond: shiftIsBounded(v)
  2203  	// result: (SLL x y)
  2204  	for {
  2205  		x := v_0
  2206  		y := v_1
  2207  		if !(shiftIsBounded(v)) {
  2208  			break
  2209  		}
  2210  		v.reset(OpRISCV64SLL)
  2211  		v.AddArg2(x, y)
  2212  		return true
  2213  	}
  2214  	return false
  2215  }
  2216  func rewriteValueRISCV64_OpLsh8x64(v *Value) bool {
  2217  	v_1 := v.Args[1]
  2218  	v_0 := v.Args[0]
  2219  	b := v.Block
  2220  	// match: (Lsh8x64 <t> x y)
  2221  	// cond: !shiftIsBounded(v)
  2222  	// result: (AND (SLL <t> x y) (Neg8 <t> (SLTIU <t> [64] y)))
  2223  	for {
  2224  		t := v.Type
  2225  		x := v_0
  2226  		y := v_1
  2227  		if !(!shiftIsBounded(v)) {
  2228  			break
  2229  		}
  2230  		v.reset(OpRISCV64AND)
  2231  		v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
  2232  		v0.AddArg2(x, y)
  2233  		v1 := b.NewValue0(v.Pos, OpNeg8, t)
  2234  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  2235  		v2.AuxInt = int64ToAuxInt(64)
  2236  		v2.AddArg(y)
  2237  		v1.AddArg(v2)
  2238  		v.AddArg2(v0, v1)
  2239  		return true
  2240  	}
  2241  	// match: (Lsh8x64 x y)
  2242  	// cond: shiftIsBounded(v)
  2243  	// result: (SLL x y)
  2244  	for {
  2245  		x := v_0
  2246  		y := v_1
  2247  		if !(shiftIsBounded(v)) {
  2248  			break
  2249  		}
  2250  		v.reset(OpRISCV64SLL)
  2251  		v.AddArg2(x, y)
  2252  		return true
  2253  	}
  2254  	return false
  2255  }
  2256  func rewriteValueRISCV64_OpLsh8x8(v *Value) bool {
  2257  	v_1 := v.Args[1]
  2258  	v_0 := v.Args[0]
  2259  	b := v.Block
  2260  	typ := &b.Func.Config.Types
  2261  	// match: (Lsh8x8 <t> x y)
  2262  	// cond: !shiftIsBounded(v)
  2263  	// result: (AND (SLL <t> x y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
  2264  	for {
  2265  		t := v.Type
  2266  		x := v_0
  2267  		y := v_1
  2268  		if !(!shiftIsBounded(v)) {
  2269  			break
  2270  		}
  2271  		v.reset(OpRISCV64AND)
  2272  		v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
  2273  		v0.AddArg2(x, y)
  2274  		v1 := b.NewValue0(v.Pos, OpNeg8, t)
  2275  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  2276  		v2.AuxInt = int64ToAuxInt(64)
  2277  		v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  2278  		v3.AddArg(y)
  2279  		v2.AddArg(v3)
  2280  		v1.AddArg(v2)
  2281  		v.AddArg2(v0, v1)
  2282  		return true
  2283  	}
  2284  	// match: (Lsh8x8 x y)
  2285  	// cond: shiftIsBounded(v)
  2286  	// result: (SLL x y)
  2287  	for {
  2288  		x := v_0
  2289  		y := v_1
  2290  		if !(shiftIsBounded(v)) {
  2291  			break
  2292  		}
  2293  		v.reset(OpRISCV64SLL)
  2294  		v.AddArg2(x, y)
  2295  		return true
  2296  	}
  2297  	return false
  2298  }
  2299  func rewriteValueRISCV64_OpMod16(v *Value) bool {
  2300  	v_1 := v.Args[1]
  2301  	v_0 := v.Args[0]
  2302  	b := v.Block
  2303  	typ := &b.Func.Config.Types
  2304  	// match: (Mod16 x y [false])
  2305  	// result: (REMW (SignExt16to32 x) (SignExt16to32 y))
  2306  	for {
  2307  		if auxIntToBool(v.AuxInt) != false {
  2308  			break
  2309  		}
  2310  		x := v_0
  2311  		y := v_1
  2312  		v.reset(OpRISCV64REMW)
  2313  		v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
  2314  		v0.AddArg(x)
  2315  		v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
  2316  		v1.AddArg(y)
  2317  		v.AddArg2(v0, v1)
  2318  		return true
  2319  	}
  2320  	return false
  2321  }
  2322  func rewriteValueRISCV64_OpMod16u(v *Value) bool {
  2323  	v_1 := v.Args[1]
  2324  	v_0 := v.Args[0]
  2325  	b := v.Block
  2326  	typ := &b.Func.Config.Types
  2327  	// match: (Mod16u x y)
  2328  	// result: (REMUW (ZeroExt16to32 x) (ZeroExt16to32 y))
  2329  	for {
  2330  		x := v_0
  2331  		y := v_1
  2332  		v.reset(OpRISCV64REMUW)
  2333  		v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
  2334  		v0.AddArg(x)
  2335  		v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
  2336  		v1.AddArg(y)
  2337  		v.AddArg2(v0, v1)
  2338  		return true
  2339  	}
  2340  }
  2341  func rewriteValueRISCV64_OpMod32(v *Value) bool {
  2342  	v_1 := v.Args[1]
  2343  	v_0 := v.Args[0]
  2344  	// match: (Mod32 x y [false])
  2345  	// result: (REMW x y)
  2346  	for {
  2347  		if auxIntToBool(v.AuxInt) != false {
  2348  			break
  2349  		}
  2350  		x := v_0
  2351  		y := v_1
  2352  		v.reset(OpRISCV64REMW)
  2353  		v.AddArg2(x, y)
  2354  		return true
  2355  	}
  2356  	return false
  2357  }
  2358  func rewriteValueRISCV64_OpMod64(v *Value) bool {
  2359  	v_1 := v.Args[1]
  2360  	v_0 := v.Args[0]
  2361  	// match: (Mod64 x y [false])
  2362  	// result: (REM x y)
  2363  	for {
  2364  		if auxIntToBool(v.AuxInt) != false {
  2365  			break
  2366  		}
  2367  		x := v_0
  2368  		y := v_1
  2369  		v.reset(OpRISCV64REM)
  2370  		v.AddArg2(x, y)
  2371  		return true
  2372  	}
  2373  	return false
  2374  }
  2375  func rewriteValueRISCV64_OpMod8(v *Value) bool {
  2376  	v_1 := v.Args[1]
  2377  	v_0 := v.Args[0]
  2378  	b := v.Block
  2379  	typ := &b.Func.Config.Types
  2380  	// match: (Mod8 x y)
  2381  	// result: (REMW (SignExt8to32 x) (SignExt8to32 y))
  2382  	for {
  2383  		x := v_0
  2384  		y := v_1
  2385  		v.reset(OpRISCV64REMW)
  2386  		v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
  2387  		v0.AddArg(x)
  2388  		v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
  2389  		v1.AddArg(y)
  2390  		v.AddArg2(v0, v1)
  2391  		return true
  2392  	}
  2393  }
  2394  func rewriteValueRISCV64_OpMod8u(v *Value) bool {
  2395  	v_1 := v.Args[1]
  2396  	v_0 := v.Args[0]
  2397  	b := v.Block
  2398  	typ := &b.Func.Config.Types
  2399  	// match: (Mod8u x y)
  2400  	// result: (REMUW (ZeroExt8to32 x) (ZeroExt8to32 y))
  2401  	for {
  2402  		x := v_0
  2403  		y := v_1
  2404  		v.reset(OpRISCV64REMUW)
  2405  		v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
  2406  		v0.AddArg(x)
  2407  		v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
  2408  		v1.AddArg(y)
  2409  		v.AddArg2(v0, v1)
  2410  		return true
  2411  	}
  2412  }
  2413  func rewriteValueRISCV64_OpMove(v *Value) bool {
  2414  	v_2 := v.Args[2]
  2415  	v_1 := v.Args[1]
  2416  	v_0 := v.Args[0]
  2417  	b := v.Block
  2418  	config := b.Func.Config
  2419  	typ := &b.Func.Config.Types
  2420  	// match: (Move [0] _ _ mem)
  2421  	// result: mem
  2422  	for {
  2423  		if auxIntToInt64(v.AuxInt) != 0 {
  2424  			break
  2425  		}
  2426  		mem := v_2
  2427  		v.copyOf(mem)
  2428  		return true
  2429  	}
  2430  	// match: (Move [1] dst src mem)
  2431  	// result: (MOVBstore dst (MOVBload src mem) mem)
  2432  	for {
  2433  		if auxIntToInt64(v.AuxInt) != 1 {
  2434  			break
  2435  		}
  2436  		dst := v_0
  2437  		src := v_1
  2438  		mem := v_2
  2439  		v.reset(OpRISCV64MOVBstore)
  2440  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
  2441  		v0.AddArg2(src, mem)
  2442  		v.AddArg3(dst, v0, mem)
  2443  		return true
  2444  	}
  2445  	// match: (Move [2] {t} dst src mem)
  2446  	// cond: t.Alignment()%2 == 0
  2447  	// result: (MOVHstore dst (MOVHload src mem) mem)
  2448  	for {
  2449  		if auxIntToInt64(v.AuxInt) != 2 {
  2450  			break
  2451  		}
  2452  		t := auxToType(v.Aux)
  2453  		dst := v_0
  2454  		src := v_1
  2455  		mem := v_2
  2456  		if !(t.Alignment()%2 == 0) {
  2457  			break
  2458  		}
  2459  		v.reset(OpRISCV64MOVHstore)
  2460  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
  2461  		v0.AddArg2(src, mem)
  2462  		v.AddArg3(dst, v0, mem)
  2463  		return true
  2464  	}
  2465  	// match: (Move [2] dst src mem)
  2466  	// result: (MOVBstore [1] dst (MOVBload [1] src mem) (MOVBstore dst (MOVBload src mem) mem))
  2467  	for {
  2468  		if auxIntToInt64(v.AuxInt) != 2 {
  2469  			break
  2470  		}
  2471  		dst := v_0
  2472  		src := v_1
  2473  		mem := v_2
  2474  		v.reset(OpRISCV64MOVBstore)
  2475  		v.AuxInt = int32ToAuxInt(1)
  2476  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
  2477  		v0.AuxInt = int32ToAuxInt(1)
  2478  		v0.AddArg2(src, mem)
  2479  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
  2480  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
  2481  		v2.AddArg2(src, mem)
  2482  		v1.AddArg3(dst, v2, mem)
  2483  		v.AddArg3(dst, v0, v1)
  2484  		return true
  2485  	}
  2486  	// match: (Move [4] {t} dst src mem)
  2487  	// cond: t.Alignment()%4 == 0
  2488  	// result: (MOVWstore dst (MOVWload src mem) mem)
  2489  	for {
  2490  		if auxIntToInt64(v.AuxInt) != 4 {
  2491  			break
  2492  		}
  2493  		t := auxToType(v.Aux)
  2494  		dst := v_0
  2495  		src := v_1
  2496  		mem := v_2
  2497  		if !(t.Alignment()%4 == 0) {
  2498  			break
  2499  		}
  2500  		v.reset(OpRISCV64MOVWstore)
  2501  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
  2502  		v0.AddArg2(src, mem)
  2503  		v.AddArg3(dst, v0, mem)
  2504  		return true
  2505  	}
  2506  	// match: (Move [4] {t} dst src mem)
  2507  	// cond: t.Alignment()%2 == 0
  2508  	// result: (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem))
  2509  	for {
  2510  		if auxIntToInt64(v.AuxInt) != 4 {
  2511  			break
  2512  		}
  2513  		t := auxToType(v.Aux)
  2514  		dst := v_0
  2515  		src := v_1
  2516  		mem := v_2
  2517  		if !(t.Alignment()%2 == 0) {
  2518  			break
  2519  		}
  2520  		v.reset(OpRISCV64MOVHstore)
  2521  		v.AuxInt = int32ToAuxInt(2)
  2522  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
  2523  		v0.AuxInt = int32ToAuxInt(2)
  2524  		v0.AddArg2(src, mem)
  2525  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
  2526  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
  2527  		v2.AddArg2(src, mem)
  2528  		v1.AddArg3(dst, v2, mem)
  2529  		v.AddArg3(dst, v0, v1)
  2530  		return true
  2531  	}
  2532  	// match: (Move [4] dst src mem)
  2533  	// result: (MOVBstore [3] dst (MOVBload [3] src mem) (MOVBstore [2] dst (MOVBload [2] src mem) (MOVBstore [1] dst (MOVBload [1] src mem) (MOVBstore dst (MOVBload src mem) mem))))
  2534  	for {
  2535  		if auxIntToInt64(v.AuxInt) != 4 {
  2536  			break
  2537  		}
  2538  		dst := v_0
  2539  		src := v_1
  2540  		mem := v_2
  2541  		v.reset(OpRISCV64MOVBstore)
  2542  		v.AuxInt = int32ToAuxInt(3)
  2543  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
  2544  		v0.AuxInt = int32ToAuxInt(3)
  2545  		v0.AddArg2(src, mem)
  2546  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
  2547  		v1.AuxInt = int32ToAuxInt(2)
  2548  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
  2549  		v2.AuxInt = int32ToAuxInt(2)
  2550  		v2.AddArg2(src, mem)
  2551  		v3 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
  2552  		v3.AuxInt = int32ToAuxInt(1)
  2553  		v4 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
  2554  		v4.AuxInt = int32ToAuxInt(1)
  2555  		v4.AddArg2(src, mem)
  2556  		v5 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
  2557  		v6 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
  2558  		v6.AddArg2(src, mem)
  2559  		v5.AddArg3(dst, v6, mem)
  2560  		v3.AddArg3(dst, v4, v5)
  2561  		v1.AddArg3(dst, v2, v3)
  2562  		v.AddArg3(dst, v0, v1)
  2563  		return true
  2564  	}
  2565  	// match: (Move [8] {t} dst src mem)
  2566  	// cond: t.Alignment()%8 == 0
  2567  	// result: (MOVDstore dst (MOVDload src mem) mem)
  2568  	for {
  2569  		if auxIntToInt64(v.AuxInt) != 8 {
  2570  			break
  2571  		}
  2572  		t := auxToType(v.Aux)
  2573  		dst := v_0
  2574  		src := v_1
  2575  		mem := v_2
  2576  		if !(t.Alignment()%8 == 0) {
  2577  			break
  2578  		}
  2579  		v.reset(OpRISCV64MOVDstore)
  2580  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
  2581  		v0.AddArg2(src, mem)
  2582  		v.AddArg3(dst, v0, mem)
  2583  		return true
  2584  	}
  2585  	// match: (Move [8] {t} dst src mem)
  2586  	// cond: t.Alignment()%4 == 0
  2587  	// result: (MOVWstore [4] dst (MOVWload [4] src mem) (MOVWstore dst (MOVWload src mem) mem))
  2588  	for {
  2589  		if auxIntToInt64(v.AuxInt) != 8 {
  2590  			break
  2591  		}
  2592  		t := auxToType(v.Aux)
  2593  		dst := v_0
  2594  		src := v_1
  2595  		mem := v_2
  2596  		if !(t.Alignment()%4 == 0) {
  2597  			break
  2598  		}
  2599  		v.reset(OpRISCV64MOVWstore)
  2600  		v.AuxInt = int32ToAuxInt(4)
  2601  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
  2602  		v0.AuxInt = int32ToAuxInt(4)
  2603  		v0.AddArg2(src, mem)
  2604  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
  2605  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
  2606  		v2.AddArg2(src, mem)
  2607  		v1.AddArg3(dst, v2, mem)
  2608  		v.AddArg3(dst, v0, v1)
  2609  		return true
  2610  	}
  2611  	// match: (Move [8] {t} dst src mem)
  2612  	// cond: t.Alignment()%2 == 0
  2613  	// result: (MOVHstore [6] dst (MOVHload [6] src mem) (MOVHstore [4] dst (MOVHload [4] src mem) (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem))))
  2614  	for {
  2615  		if auxIntToInt64(v.AuxInt) != 8 {
  2616  			break
  2617  		}
  2618  		t := auxToType(v.Aux)
  2619  		dst := v_0
  2620  		src := v_1
  2621  		mem := v_2
  2622  		if !(t.Alignment()%2 == 0) {
  2623  			break
  2624  		}
  2625  		v.reset(OpRISCV64MOVHstore)
  2626  		v.AuxInt = int32ToAuxInt(6)
  2627  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
  2628  		v0.AuxInt = int32ToAuxInt(6)
  2629  		v0.AddArg2(src, mem)
  2630  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
  2631  		v1.AuxInt = int32ToAuxInt(4)
  2632  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
  2633  		v2.AuxInt = int32ToAuxInt(4)
  2634  		v2.AddArg2(src, mem)
  2635  		v3 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
  2636  		v3.AuxInt = int32ToAuxInt(2)
  2637  		v4 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
  2638  		v4.AuxInt = int32ToAuxInt(2)
  2639  		v4.AddArg2(src, mem)
  2640  		v5 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
  2641  		v6 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
  2642  		v6.AddArg2(src, mem)
  2643  		v5.AddArg3(dst, v6, mem)
  2644  		v3.AddArg3(dst, v4, v5)
  2645  		v1.AddArg3(dst, v2, v3)
  2646  		v.AddArg3(dst, v0, v1)
  2647  		return true
  2648  	}
  2649  	// match: (Move [3] dst src mem)
  2650  	// result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVBstore [1] dst (MOVBload [1] src mem) (MOVBstore dst (MOVBload src mem) mem)))
  2651  	for {
  2652  		if auxIntToInt64(v.AuxInt) != 3 {
  2653  			break
  2654  		}
  2655  		dst := v_0
  2656  		src := v_1
  2657  		mem := v_2
  2658  		v.reset(OpRISCV64MOVBstore)
  2659  		v.AuxInt = int32ToAuxInt(2)
  2660  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
  2661  		v0.AuxInt = int32ToAuxInt(2)
  2662  		v0.AddArg2(src, mem)
  2663  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
  2664  		v1.AuxInt = int32ToAuxInt(1)
  2665  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
  2666  		v2.AuxInt = int32ToAuxInt(1)
  2667  		v2.AddArg2(src, mem)
  2668  		v3 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
  2669  		v4 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
  2670  		v4.AddArg2(src, mem)
  2671  		v3.AddArg3(dst, v4, mem)
  2672  		v1.AddArg3(dst, v2, v3)
  2673  		v.AddArg3(dst, v0, v1)
  2674  		return true
  2675  	}
  2676  	// match: (Move [6] {t} dst src mem)
  2677  	// cond: t.Alignment()%2 == 0
  2678  	// result: (MOVHstore [4] dst (MOVHload [4] src mem) (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem)))
  2679  	for {
  2680  		if auxIntToInt64(v.AuxInt) != 6 {
  2681  			break
  2682  		}
  2683  		t := auxToType(v.Aux)
  2684  		dst := v_0
  2685  		src := v_1
  2686  		mem := v_2
  2687  		if !(t.Alignment()%2 == 0) {
  2688  			break
  2689  		}
  2690  		v.reset(OpRISCV64MOVHstore)
  2691  		v.AuxInt = int32ToAuxInt(4)
  2692  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
  2693  		v0.AuxInt = int32ToAuxInt(4)
  2694  		v0.AddArg2(src, mem)
  2695  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
  2696  		v1.AuxInt = int32ToAuxInt(2)
  2697  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
  2698  		v2.AuxInt = int32ToAuxInt(2)
  2699  		v2.AddArg2(src, mem)
  2700  		v3 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
  2701  		v4 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
  2702  		v4.AddArg2(src, mem)
  2703  		v3.AddArg3(dst, v4, mem)
  2704  		v1.AddArg3(dst, v2, v3)
  2705  		v.AddArg3(dst, v0, v1)
  2706  		return true
  2707  	}
  2708  	// match: (Move [12] {t} dst src mem)
  2709  	// cond: t.Alignment()%4 == 0
  2710  	// result: (MOVWstore [8] dst (MOVWload [8] src mem) (MOVWstore [4] dst (MOVWload [4] src mem) (MOVWstore dst (MOVWload src mem) mem)))
  2711  	for {
  2712  		if auxIntToInt64(v.AuxInt) != 12 {
  2713  			break
  2714  		}
  2715  		t := auxToType(v.Aux)
  2716  		dst := v_0
  2717  		src := v_1
  2718  		mem := v_2
  2719  		if !(t.Alignment()%4 == 0) {
  2720  			break
  2721  		}
  2722  		v.reset(OpRISCV64MOVWstore)
  2723  		v.AuxInt = int32ToAuxInt(8)
  2724  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
  2725  		v0.AuxInt = int32ToAuxInt(8)
  2726  		v0.AddArg2(src, mem)
  2727  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
  2728  		v1.AuxInt = int32ToAuxInt(4)
  2729  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
  2730  		v2.AuxInt = int32ToAuxInt(4)
  2731  		v2.AddArg2(src, mem)
  2732  		v3 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
  2733  		v4 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
  2734  		v4.AddArg2(src, mem)
  2735  		v3.AddArg3(dst, v4, mem)
  2736  		v1.AddArg3(dst, v2, v3)
  2737  		v.AddArg3(dst, v0, v1)
  2738  		return true
  2739  	}
  2740  	// match: (Move [16] {t} dst src mem)
  2741  	// cond: t.Alignment()%8 == 0
  2742  	// result: (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem))
  2743  	for {
  2744  		if auxIntToInt64(v.AuxInt) != 16 {
  2745  			break
  2746  		}
  2747  		t := auxToType(v.Aux)
  2748  		dst := v_0
  2749  		src := v_1
  2750  		mem := v_2
  2751  		if !(t.Alignment()%8 == 0) {
  2752  			break
  2753  		}
  2754  		v.reset(OpRISCV64MOVDstore)
  2755  		v.AuxInt = int32ToAuxInt(8)
  2756  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
  2757  		v0.AuxInt = int32ToAuxInt(8)
  2758  		v0.AddArg2(src, mem)
  2759  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
  2760  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
  2761  		v2.AddArg2(src, mem)
  2762  		v1.AddArg3(dst, v2, mem)
  2763  		v.AddArg3(dst, v0, v1)
  2764  		return true
  2765  	}
  2766  	// match: (Move [24] {t} dst src mem)
  2767  	// cond: t.Alignment()%8 == 0
  2768  	// result: (MOVDstore [16] dst (MOVDload [16] src mem) (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem)))
  2769  	for {
  2770  		if auxIntToInt64(v.AuxInt) != 24 {
  2771  			break
  2772  		}
  2773  		t := auxToType(v.Aux)
  2774  		dst := v_0
  2775  		src := v_1
  2776  		mem := v_2
  2777  		if !(t.Alignment()%8 == 0) {
  2778  			break
  2779  		}
  2780  		v.reset(OpRISCV64MOVDstore)
  2781  		v.AuxInt = int32ToAuxInt(16)
  2782  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
  2783  		v0.AuxInt = int32ToAuxInt(16)
  2784  		v0.AddArg2(src, mem)
  2785  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
  2786  		v1.AuxInt = int32ToAuxInt(8)
  2787  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
  2788  		v2.AuxInt = int32ToAuxInt(8)
  2789  		v2.AddArg2(src, mem)
  2790  		v3 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
  2791  		v4 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
  2792  		v4.AddArg2(src, mem)
  2793  		v3.AddArg3(dst, v4, mem)
  2794  		v1.AddArg3(dst, v2, v3)
  2795  		v.AddArg3(dst, v0, v1)
  2796  		return true
  2797  	}
  2798  	// match: (Move [32] {t} dst src mem)
  2799  	// cond: t.Alignment()%8 == 0
  2800  	// result: (MOVDstore [24] dst (MOVDload [24] src mem) (MOVDstore [16] dst (MOVDload [16] src mem) (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem))))
  2801  	for {
  2802  		if auxIntToInt64(v.AuxInt) != 32 {
  2803  			break
  2804  		}
  2805  		t := auxToType(v.Aux)
  2806  		dst := v_0
  2807  		src := v_1
  2808  		mem := v_2
  2809  		if !(t.Alignment()%8 == 0) {
  2810  			break
  2811  		}
  2812  		v.reset(OpRISCV64MOVDstore)
  2813  		v.AuxInt = int32ToAuxInt(24)
  2814  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
  2815  		v0.AuxInt = int32ToAuxInt(24)
  2816  		v0.AddArg2(src, mem)
  2817  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
  2818  		v1.AuxInt = int32ToAuxInt(16)
  2819  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
  2820  		v2.AuxInt = int32ToAuxInt(16)
  2821  		v2.AddArg2(src, mem)
  2822  		v3 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
  2823  		v3.AuxInt = int32ToAuxInt(8)
  2824  		v4 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
  2825  		v4.AuxInt = int32ToAuxInt(8)
  2826  		v4.AddArg2(src, mem)
  2827  		v5 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
  2828  		v6 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
  2829  		v6.AddArg2(src, mem)
  2830  		v5.AddArg3(dst, v6, mem)
  2831  		v3.AddArg3(dst, v4, v5)
  2832  		v1.AddArg3(dst, v2, v3)
  2833  		v.AddArg3(dst, v0, v1)
  2834  		return true
  2835  	}
  2836  	// match: (Move [s] {t} dst src mem)
  2837  	// cond: s%8 == 0 && s <= 8*128 && t.Alignment()%8 == 0 && !config.noDuffDevice && logLargeCopy(v, s)
  2838  	// result: (DUFFCOPY [16 * (128 - s/8)] dst src mem)
  2839  	for {
  2840  		s := auxIntToInt64(v.AuxInt)
  2841  		t := auxToType(v.Aux)
  2842  		dst := v_0
  2843  		src := v_1
  2844  		mem := v_2
  2845  		if !(s%8 == 0 && s <= 8*128 && t.Alignment()%8 == 0 && !config.noDuffDevice && logLargeCopy(v, s)) {
  2846  			break
  2847  		}
  2848  		v.reset(OpRISCV64DUFFCOPY)
  2849  		v.AuxInt = int64ToAuxInt(16 * (128 - s/8))
  2850  		v.AddArg3(dst, src, mem)
  2851  		return true
  2852  	}
  2853  	// match: (Move [s] {t} dst src mem)
  2854  	// cond: (s <= 16 || logLargeCopy(v, s))
  2855  	// result: (LoweredMove [t.Alignment()] dst src (ADDI <src.Type> [s-moveSize(t.Alignment(), config)] src) mem)
  2856  	for {
  2857  		s := auxIntToInt64(v.AuxInt)
  2858  		t := auxToType(v.Aux)
  2859  		dst := v_0
  2860  		src := v_1
  2861  		mem := v_2
  2862  		if !(s <= 16 || logLargeCopy(v, s)) {
  2863  			break
  2864  		}
  2865  		v.reset(OpRISCV64LoweredMove)
  2866  		v.AuxInt = int64ToAuxInt(t.Alignment())
  2867  		v0 := b.NewValue0(v.Pos, OpRISCV64ADDI, src.Type)
  2868  		v0.AuxInt = int64ToAuxInt(s - moveSize(t.Alignment(), config))
  2869  		v0.AddArg(src)
  2870  		v.AddArg4(dst, src, v0, mem)
  2871  		return true
  2872  	}
  2873  	return false
  2874  }
  2875  func rewriteValueRISCV64_OpMul16(v *Value) bool {
  2876  	v_1 := v.Args[1]
  2877  	v_0 := v.Args[0]
  2878  	b := v.Block
  2879  	typ := &b.Func.Config.Types
  2880  	// match: (Mul16 x y)
  2881  	// result: (MULW (SignExt16to32 x) (SignExt16to32 y))
  2882  	for {
  2883  		x := v_0
  2884  		y := v_1
  2885  		v.reset(OpRISCV64MULW)
  2886  		v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
  2887  		v0.AddArg(x)
  2888  		v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
  2889  		v1.AddArg(y)
  2890  		v.AddArg2(v0, v1)
  2891  		return true
  2892  	}
  2893  }
  2894  func rewriteValueRISCV64_OpMul8(v *Value) bool {
  2895  	v_1 := v.Args[1]
  2896  	v_0 := v.Args[0]
  2897  	b := v.Block
  2898  	typ := &b.Func.Config.Types
  2899  	// match: (Mul8 x y)
  2900  	// result: (MULW (SignExt8to32 x) (SignExt8to32 y))
  2901  	for {
  2902  		x := v_0
  2903  		y := v_1
  2904  		v.reset(OpRISCV64MULW)
  2905  		v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
  2906  		v0.AddArg(x)
  2907  		v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
  2908  		v1.AddArg(y)
  2909  		v.AddArg2(v0, v1)
  2910  		return true
  2911  	}
  2912  }
  2913  func rewriteValueRISCV64_OpNeq16(v *Value) bool {
  2914  	v_1 := v.Args[1]
  2915  	v_0 := v.Args[0]
  2916  	b := v.Block
  2917  	typ := &b.Func.Config.Types
  2918  	// match: (Neq16 x y)
  2919  	// result: (SNEZ (SUB <x.Type> (ZeroExt16to64 x) (ZeroExt16to64 y)))
  2920  	for {
  2921  		x := v_0
  2922  		y := v_1
  2923  		v.reset(OpRISCV64SNEZ)
  2924  		v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
  2925  		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  2926  		v1.AddArg(x)
  2927  		v2 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  2928  		v2.AddArg(y)
  2929  		v0.AddArg2(v1, v2)
  2930  		v.AddArg(v0)
  2931  		return true
  2932  	}
  2933  }
  2934  func rewriteValueRISCV64_OpNeq32(v *Value) bool {
  2935  	v_1 := v.Args[1]
  2936  	v_0 := v.Args[0]
  2937  	b := v.Block
  2938  	typ := &b.Func.Config.Types
  2939  	// match: (Neq32 x y)
  2940  	// result: (SNEZ (SUB <x.Type> (ZeroExt32to64 x) (ZeroExt32to64 y)))
  2941  	for {
  2942  		x := v_0
  2943  		y := v_1
  2944  		v.reset(OpRISCV64SNEZ)
  2945  		v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
  2946  		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  2947  		v1.AddArg(x)
  2948  		v2 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  2949  		v2.AddArg(y)
  2950  		v0.AddArg2(v1, v2)
  2951  		v.AddArg(v0)
  2952  		return true
  2953  	}
  2954  }
  2955  func rewriteValueRISCV64_OpNeq64(v *Value) bool {
  2956  	v_1 := v.Args[1]
  2957  	v_0 := v.Args[0]
  2958  	b := v.Block
  2959  	// match: (Neq64 x y)
  2960  	// result: (SNEZ (SUB <x.Type> x y))
  2961  	for {
  2962  		x := v_0
  2963  		y := v_1
  2964  		v.reset(OpRISCV64SNEZ)
  2965  		v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
  2966  		v0.AddArg2(x, y)
  2967  		v.AddArg(v0)
  2968  		return true
  2969  	}
  2970  }
  2971  func rewriteValueRISCV64_OpNeq8(v *Value) bool {
  2972  	v_1 := v.Args[1]
  2973  	v_0 := v.Args[0]
  2974  	b := v.Block
  2975  	typ := &b.Func.Config.Types
  2976  	// match: (Neq8 x y)
  2977  	// result: (SNEZ (SUB <x.Type> (ZeroExt8to64 x) (ZeroExt8to64 y)))
  2978  	for {
  2979  		x := v_0
  2980  		y := v_1
  2981  		v.reset(OpRISCV64SNEZ)
  2982  		v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
  2983  		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  2984  		v1.AddArg(x)
  2985  		v2 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  2986  		v2.AddArg(y)
  2987  		v0.AddArg2(v1, v2)
  2988  		v.AddArg(v0)
  2989  		return true
  2990  	}
  2991  }
  2992  func rewriteValueRISCV64_OpNeqB(v *Value) bool {
  2993  	v_1 := v.Args[1]
  2994  	v_0 := v.Args[0]
  2995  	b := v.Block
  2996  	typ := &b.Func.Config.Types
  2997  	// match: (NeqB x y)
  2998  	// result: (SNEZ (SUB <typ.Bool> x y))
  2999  	for {
  3000  		x := v_0
  3001  		y := v_1
  3002  		v.reset(OpRISCV64SNEZ)
  3003  		v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.Bool)
  3004  		v0.AddArg2(x, y)
  3005  		v.AddArg(v0)
  3006  		return true
  3007  	}
  3008  }
  3009  func rewriteValueRISCV64_OpNeqPtr(v *Value) bool {
  3010  	v_1 := v.Args[1]
  3011  	v_0 := v.Args[0]
  3012  	b := v.Block
  3013  	typ := &b.Func.Config.Types
  3014  	// match: (NeqPtr x y)
  3015  	// result: (SNEZ (SUB <typ.Uintptr> x y))
  3016  	for {
  3017  		x := v_0
  3018  		y := v_1
  3019  		v.reset(OpRISCV64SNEZ)
  3020  		v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.Uintptr)
  3021  		v0.AddArg2(x, y)
  3022  		v.AddArg(v0)
  3023  		return true
  3024  	}
  3025  }
  3026  func rewriteValueRISCV64_OpOffPtr(v *Value) bool {
  3027  	v_0 := v.Args[0]
  3028  	b := v.Block
  3029  	typ := &b.Func.Config.Types
  3030  	// match: (OffPtr [off] ptr:(SP))
  3031  	// cond: is32Bit(off)
  3032  	// result: (MOVaddr [int32(off)] ptr)
  3033  	for {
  3034  		off := auxIntToInt64(v.AuxInt)
  3035  		ptr := v_0
  3036  		if ptr.Op != OpSP || !(is32Bit(off)) {
  3037  			break
  3038  		}
  3039  		v.reset(OpRISCV64MOVaddr)
  3040  		v.AuxInt = int32ToAuxInt(int32(off))
  3041  		v.AddArg(ptr)
  3042  		return true
  3043  	}
  3044  	// match: (OffPtr [off] ptr)
  3045  	// cond: is32Bit(off)
  3046  	// result: (ADDI [off] ptr)
  3047  	for {
  3048  		off := auxIntToInt64(v.AuxInt)
  3049  		ptr := v_0
  3050  		if !(is32Bit(off)) {
  3051  			break
  3052  		}
  3053  		v.reset(OpRISCV64ADDI)
  3054  		v.AuxInt = int64ToAuxInt(off)
  3055  		v.AddArg(ptr)
  3056  		return true
  3057  	}
  3058  	// match: (OffPtr [off] ptr)
  3059  	// result: (ADD (MOVDconst [off]) ptr)
  3060  	for {
  3061  		off := auxIntToInt64(v.AuxInt)
  3062  		ptr := v_0
  3063  		v.reset(OpRISCV64ADD)
  3064  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  3065  		v0.AuxInt = int64ToAuxInt(off)
  3066  		v.AddArg2(v0, ptr)
  3067  		return true
  3068  	}
  3069  }
  3070  func rewriteValueRISCV64_OpPanicBounds(v *Value) bool {
  3071  	v_2 := v.Args[2]
  3072  	v_1 := v.Args[1]
  3073  	v_0 := v.Args[0]
  3074  	// match: (PanicBounds [kind] x y mem)
  3075  	// cond: boundsABI(kind) == 0
  3076  	// result: (LoweredPanicBoundsA [kind] x y mem)
  3077  	for {
  3078  		kind := auxIntToInt64(v.AuxInt)
  3079  		x := v_0
  3080  		y := v_1
  3081  		mem := v_2
  3082  		if !(boundsABI(kind) == 0) {
  3083  			break
  3084  		}
  3085  		v.reset(OpRISCV64LoweredPanicBoundsA)
  3086  		v.AuxInt = int64ToAuxInt(kind)
  3087  		v.AddArg3(x, y, mem)
  3088  		return true
  3089  	}
  3090  	// match: (PanicBounds [kind] x y mem)
  3091  	// cond: boundsABI(kind) == 1
  3092  	// result: (LoweredPanicBoundsB [kind] x y mem)
  3093  	for {
  3094  		kind := auxIntToInt64(v.AuxInt)
  3095  		x := v_0
  3096  		y := v_1
  3097  		mem := v_2
  3098  		if !(boundsABI(kind) == 1) {
  3099  			break
  3100  		}
  3101  		v.reset(OpRISCV64LoweredPanicBoundsB)
  3102  		v.AuxInt = int64ToAuxInt(kind)
  3103  		v.AddArg3(x, y, mem)
  3104  		return true
  3105  	}
  3106  	// match: (PanicBounds [kind] x y mem)
  3107  	// cond: boundsABI(kind) == 2
  3108  	// result: (LoweredPanicBoundsC [kind] x y mem)
  3109  	for {
  3110  		kind := auxIntToInt64(v.AuxInt)
  3111  		x := v_0
  3112  		y := v_1
  3113  		mem := v_2
  3114  		if !(boundsABI(kind) == 2) {
  3115  			break
  3116  		}
  3117  		v.reset(OpRISCV64LoweredPanicBoundsC)
  3118  		v.AuxInt = int64ToAuxInt(kind)
  3119  		v.AddArg3(x, y, mem)
  3120  		return true
  3121  	}
  3122  	return false
  3123  }
  3124  func rewriteValueRISCV64_OpRISCV64ADD(v *Value) bool {
  3125  	v_1 := v.Args[1]
  3126  	v_0 := v.Args[0]
  3127  	// match: (ADD (MOVDconst [val]) x)
  3128  	// cond: is32Bit(val)
  3129  	// result: (ADDI [val] x)
  3130  	for {
  3131  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  3132  			if v_0.Op != OpRISCV64MOVDconst {
  3133  				continue
  3134  			}
  3135  			val := auxIntToInt64(v_0.AuxInt)
  3136  			x := v_1
  3137  			if !(is32Bit(val)) {
  3138  				continue
  3139  			}
  3140  			v.reset(OpRISCV64ADDI)
  3141  			v.AuxInt = int64ToAuxInt(val)
  3142  			v.AddArg(x)
  3143  			return true
  3144  		}
  3145  		break
  3146  	}
  3147  	return false
  3148  }
  3149  func rewriteValueRISCV64_OpRISCV64ADDI(v *Value) bool {
  3150  	v_0 := v.Args[0]
  3151  	// match: (ADDI [c] (MOVaddr [d] {s} x))
  3152  	// cond: is32Bit(c+int64(d))
  3153  	// result: (MOVaddr [int32(c)+d] {s} x)
  3154  	for {
  3155  		c := auxIntToInt64(v.AuxInt)
  3156  		if v_0.Op != OpRISCV64MOVaddr {
  3157  			break
  3158  		}
  3159  		d := auxIntToInt32(v_0.AuxInt)
  3160  		s := auxToSym(v_0.Aux)
  3161  		x := v_0.Args[0]
  3162  		if !(is32Bit(c + int64(d))) {
  3163  			break
  3164  		}
  3165  		v.reset(OpRISCV64MOVaddr)
  3166  		v.AuxInt = int32ToAuxInt(int32(c) + d)
  3167  		v.Aux = symToAux(s)
  3168  		v.AddArg(x)
  3169  		return true
  3170  	}
  3171  	// match: (ADDI [0] x)
  3172  	// result: x
  3173  	for {
  3174  		if auxIntToInt64(v.AuxInt) != 0 {
  3175  			break
  3176  		}
  3177  		x := v_0
  3178  		v.copyOf(x)
  3179  		return true
  3180  	}
  3181  	// match: (ADDI [x] (MOVDconst [y]))
  3182  	// cond: is32Bit(x + y)
  3183  	// result: (MOVDconst [x + y])
  3184  	for {
  3185  		x := auxIntToInt64(v.AuxInt)
  3186  		if v_0.Op != OpRISCV64MOVDconst {
  3187  			break
  3188  		}
  3189  		y := auxIntToInt64(v_0.AuxInt)
  3190  		if !(is32Bit(x + y)) {
  3191  			break
  3192  		}
  3193  		v.reset(OpRISCV64MOVDconst)
  3194  		v.AuxInt = int64ToAuxInt(x + y)
  3195  		return true
  3196  	}
  3197  	// match: (ADDI [x] (ADDI [y] z))
  3198  	// cond: is32Bit(x + y)
  3199  	// result: (ADDI [x + y] z)
  3200  	for {
  3201  		x := auxIntToInt64(v.AuxInt)
  3202  		if v_0.Op != OpRISCV64ADDI {
  3203  			break
  3204  		}
  3205  		y := auxIntToInt64(v_0.AuxInt)
  3206  		z := v_0.Args[0]
  3207  		if !(is32Bit(x + y)) {
  3208  			break
  3209  		}
  3210  		v.reset(OpRISCV64ADDI)
  3211  		v.AuxInt = int64ToAuxInt(x + y)
  3212  		v.AddArg(z)
  3213  		return true
  3214  	}
  3215  	return false
  3216  }
  3217  func rewriteValueRISCV64_OpRISCV64AND(v *Value) bool {
  3218  	v_1 := v.Args[1]
  3219  	v_0 := v.Args[0]
  3220  	// match: (AND (MOVDconst [val]) x)
  3221  	// cond: is32Bit(val)
  3222  	// result: (ANDI [val] x)
  3223  	for {
  3224  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  3225  			if v_0.Op != OpRISCV64MOVDconst {
  3226  				continue
  3227  			}
  3228  			val := auxIntToInt64(v_0.AuxInt)
  3229  			x := v_1
  3230  			if !(is32Bit(val)) {
  3231  				continue
  3232  			}
  3233  			v.reset(OpRISCV64ANDI)
  3234  			v.AuxInt = int64ToAuxInt(val)
  3235  			v.AddArg(x)
  3236  			return true
  3237  		}
  3238  		break
  3239  	}
  3240  	return false
  3241  }
  3242  func rewriteValueRISCV64_OpRISCV64ANDI(v *Value) bool {
  3243  	v_0 := v.Args[0]
  3244  	// match: (ANDI [0] x)
  3245  	// result: (MOVDconst [0])
  3246  	for {
  3247  		if auxIntToInt64(v.AuxInt) != 0 {
  3248  			break
  3249  		}
  3250  		v.reset(OpRISCV64MOVDconst)
  3251  		v.AuxInt = int64ToAuxInt(0)
  3252  		return true
  3253  	}
  3254  	// match: (ANDI [-1] x)
  3255  	// result: x
  3256  	for {
  3257  		if auxIntToInt64(v.AuxInt) != -1 {
  3258  			break
  3259  		}
  3260  		x := v_0
  3261  		v.copyOf(x)
  3262  		return true
  3263  	}
  3264  	// match: (ANDI [x] (MOVDconst [y]))
  3265  	// result: (MOVDconst [x & y])
  3266  	for {
  3267  		x := auxIntToInt64(v.AuxInt)
  3268  		if v_0.Op != OpRISCV64MOVDconst {
  3269  			break
  3270  		}
  3271  		y := auxIntToInt64(v_0.AuxInt)
  3272  		v.reset(OpRISCV64MOVDconst)
  3273  		v.AuxInt = int64ToAuxInt(x & y)
  3274  		return true
  3275  	}
  3276  	// match: (ANDI [x] (ANDI [y] z))
  3277  	// result: (ANDI [x & y] z)
  3278  	for {
  3279  		x := auxIntToInt64(v.AuxInt)
  3280  		if v_0.Op != OpRISCV64ANDI {
  3281  			break
  3282  		}
  3283  		y := auxIntToInt64(v_0.AuxInt)
  3284  		z := v_0.Args[0]
  3285  		v.reset(OpRISCV64ANDI)
  3286  		v.AuxInt = int64ToAuxInt(x & y)
  3287  		v.AddArg(z)
  3288  		return true
  3289  	}
  3290  	return false
  3291  }
  3292  func rewriteValueRISCV64_OpRISCV64FMADDD(v *Value) bool {
  3293  	v_2 := v.Args[2]
  3294  	v_1 := v.Args[1]
  3295  	v_0 := v.Args[0]
  3296  	// match: (FMADDD neg:(FNEGD x) y z)
  3297  	// cond: neg.Uses == 1
  3298  	// result: (FNMADDD x y z)
  3299  	for {
  3300  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  3301  			neg := v_0
  3302  			if neg.Op != OpRISCV64FNEGD {
  3303  				continue
  3304  			}
  3305  			x := neg.Args[0]
  3306  			y := v_1
  3307  			z := v_2
  3308  			if !(neg.Uses == 1) {
  3309  				continue
  3310  			}
  3311  			v.reset(OpRISCV64FNMADDD)
  3312  			v.AddArg3(x, y, z)
  3313  			return true
  3314  		}
  3315  		break
  3316  	}
  3317  	// match: (FMADDD x y neg:(FNEGD z))
  3318  	// cond: neg.Uses == 1
  3319  	// result: (FMSUBD x y z)
  3320  	for {
  3321  		x := v_0
  3322  		y := v_1
  3323  		neg := v_2
  3324  		if neg.Op != OpRISCV64FNEGD {
  3325  			break
  3326  		}
  3327  		z := neg.Args[0]
  3328  		if !(neg.Uses == 1) {
  3329  			break
  3330  		}
  3331  		v.reset(OpRISCV64FMSUBD)
  3332  		v.AddArg3(x, y, z)
  3333  		return true
  3334  	}
  3335  	return false
  3336  }
  3337  func rewriteValueRISCV64_OpRISCV64FMSUBD(v *Value) bool {
  3338  	v_2 := v.Args[2]
  3339  	v_1 := v.Args[1]
  3340  	v_0 := v.Args[0]
  3341  	// match: (FMSUBD neg:(FNEGD x) y z)
  3342  	// cond: neg.Uses == 1
  3343  	// result: (FNMSUBD x y z)
  3344  	for {
  3345  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  3346  			neg := v_0
  3347  			if neg.Op != OpRISCV64FNEGD {
  3348  				continue
  3349  			}
  3350  			x := neg.Args[0]
  3351  			y := v_1
  3352  			z := v_2
  3353  			if !(neg.Uses == 1) {
  3354  				continue
  3355  			}
  3356  			v.reset(OpRISCV64FNMSUBD)
  3357  			v.AddArg3(x, y, z)
  3358  			return true
  3359  		}
  3360  		break
  3361  	}
  3362  	// match: (FMSUBD x y neg:(FNEGD z))
  3363  	// cond: neg.Uses == 1
  3364  	// result: (FMADDD x y z)
  3365  	for {
  3366  		x := v_0
  3367  		y := v_1
  3368  		neg := v_2
  3369  		if neg.Op != OpRISCV64FNEGD {
  3370  			break
  3371  		}
  3372  		z := neg.Args[0]
  3373  		if !(neg.Uses == 1) {
  3374  			break
  3375  		}
  3376  		v.reset(OpRISCV64FMADDD)
  3377  		v.AddArg3(x, y, z)
  3378  		return true
  3379  	}
  3380  	return false
  3381  }
  3382  func rewriteValueRISCV64_OpRISCV64FNMADDD(v *Value) bool {
  3383  	v_2 := v.Args[2]
  3384  	v_1 := v.Args[1]
  3385  	v_0 := v.Args[0]
  3386  	// match: (FNMADDD neg:(FNEGD x) y z)
  3387  	// cond: neg.Uses == 1
  3388  	// result: (FMADDD x y z)
  3389  	for {
  3390  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  3391  			neg := v_0
  3392  			if neg.Op != OpRISCV64FNEGD {
  3393  				continue
  3394  			}
  3395  			x := neg.Args[0]
  3396  			y := v_1
  3397  			z := v_2
  3398  			if !(neg.Uses == 1) {
  3399  				continue
  3400  			}
  3401  			v.reset(OpRISCV64FMADDD)
  3402  			v.AddArg3(x, y, z)
  3403  			return true
  3404  		}
  3405  		break
  3406  	}
  3407  	// match: (FNMADDD x y neg:(FNEGD z))
  3408  	// cond: neg.Uses == 1
  3409  	// result: (FNMSUBD x y z)
  3410  	for {
  3411  		x := v_0
  3412  		y := v_1
  3413  		neg := v_2
  3414  		if neg.Op != OpRISCV64FNEGD {
  3415  			break
  3416  		}
  3417  		z := neg.Args[0]
  3418  		if !(neg.Uses == 1) {
  3419  			break
  3420  		}
  3421  		v.reset(OpRISCV64FNMSUBD)
  3422  		v.AddArg3(x, y, z)
  3423  		return true
  3424  	}
  3425  	return false
  3426  }
  3427  func rewriteValueRISCV64_OpRISCV64FNMSUBD(v *Value) bool {
  3428  	v_2 := v.Args[2]
  3429  	v_1 := v.Args[1]
  3430  	v_0 := v.Args[0]
  3431  	// match: (FNMSUBD neg:(FNEGD x) y z)
  3432  	// cond: neg.Uses == 1
  3433  	// result: (FMSUBD x y z)
  3434  	for {
  3435  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  3436  			neg := v_0
  3437  			if neg.Op != OpRISCV64FNEGD {
  3438  				continue
  3439  			}
  3440  			x := neg.Args[0]
  3441  			y := v_1
  3442  			z := v_2
  3443  			if !(neg.Uses == 1) {
  3444  				continue
  3445  			}
  3446  			v.reset(OpRISCV64FMSUBD)
  3447  			v.AddArg3(x, y, z)
  3448  			return true
  3449  		}
  3450  		break
  3451  	}
  3452  	// match: (FNMSUBD x y neg:(FNEGD z))
  3453  	// cond: neg.Uses == 1
  3454  	// result: (FNMADDD x y z)
  3455  	for {
  3456  		x := v_0
  3457  		y := v_1
  3458  		neg := v_2
  3459  		if neg.Op != OpRISCV64FNEGD {
  3460  			break
  3461  		}
  3462  		z := neg.Args[0]
  3463  		if !(neg.Uses == 1) {
  3464  			break
  3465  		}
  3466  		v.reset(OpRISCV64FNMADDD)
  3467  		v.AddArg3(x, y, z)
  3468  		return true
  3469  	}
  3470  	return false
  3471  }
  3472  func rewriteValueRISCV64_OpRISCV64MOVBUload(v *Value) bool {
  3473  	v_1 := v.Args[1]
  3474  	v_0 := v.Args[0]
  3475  	// match: (MOVBUload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
  3476  	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
  3477  	// result: (MOVBUload [off1+off2] {mergeSym(sym1,sym2)} base mem)
  3478  	for {
  3479  		off1 := auxIntToInt32(v.AuxInt)
  3480  		sym1 := auxToSym(v.Aux)
  3481  		if v_0.Op != OpRISCV64MOVaddr {
  3482  			break
  3483  		}
  3484  		off2 := auxIntToInt32(v_0.AuxInt)
  3485  		sym2 := auxToSym(v_0.Aux)
  3486  		base := v_0.Args[0]
  3487  		mem := v_1
  3488  		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
  3489  			break
  3490  		}
  3491  		v.reset(OpRISCV64MOVBUload)
  3492  		v.AuxInt = int32ToAuxInt(off1 + off2)
  3493  		v.Aux = symToAux(mergeSym(sym1, sym2))
  3494  		v.AddArg2(base, mem)
  3495  		return true
  3496  	}
  3497  	// match: (MOVBUload [off1] {sym} (ADDI [off2] base) mem)
  3498  	// cond: is32Bit(int64(off1)+off2)
  3499  	// result: (MOVBUload [off1+int32(off2)] {sym} base mem)
  3500  	for {
  3501  		off1 := auxIntToInt32(v.AuxInt)
  3502  		sym := auxToSym(v.Aux)
  3503  		if v_0.Op != OpRISCV64ADDI {
  3504  			break
  3505  		}
  3506  		off2 := auxIntToInt64(v_0.AuxInt)
  3507  		base := v_0.Args[0]
  3508  		mem := v_1
  3509  		if !(is32Bit(int64(off1) + off2)) {
  3510  			break
  3511  		}
  3512  		v.reset(OpRISCV64MOVBUload)
  3513  		v.AuxInt = int32ToAuxInt(off1 + int32(off2))
  3514  		v.Aux = symToAux(sym)
  3515  		v.AddArg2(base, mem)
  3516  		return true
  3517  	}
  3518  	return false
  3519  }
  3520  func rewriteValueRISCV64_OpRISCV64MOVBUreg(v *Value) bool {
  3521  	v_0 := v.Args[0]
  3522  	b := v.Block
  3523  	// match: (MOVBUreg x:(FLES _ _))
  3524  	// result: x
  3525  	for {
  3526  		x := v_0
  3527  		if x.Op != OpRISCV64FLES {
  3528  			break
  3529  		}
  3530  		v.copyOf(x)
  3531  		return true
  3532  	}
  3533  	// match: (MOVBUreg x:(FLTS _ _))
  3534  	// result: x
  3535  	for {
  3536  		x := v_0
  3537  		if x.Op != OpRISCV64FLTS {
  3538  			break
  3539  		}
  3540  		v.copyOf(x)
  3541  		return true
  3542  	}
  3543  	// match: (MOVBUreg x:(FEQS _ _))
  3544  	// result: x
  3545  	for {
  3546  		x := v_0
  3547  		if x.Op != OpRISCV64FEQS {
  3548  			break
  3549  		}
  3550  		v.copyOf(x)
  3551  		return true
  3552  	}
  3553  	// match: (MOVBUreg x:(FNES _ _))
  3554  	// result: x
  3555  	for {
  3556  		x := v_0
  3557  		if x.Op != OpRISCV64FNES {
  3558  			break
  3559  		}
  3560  		v.copyOf(x)
  3561  		return true
  3562  	}
  3563  	// match: (MOVBUreg x:(FLED _ _))
  3564  	// result: x
  3565  	for {
  3566  		x := v_0
  3567  		if x.Op != OpRISCV64FLED {
  3568  			break
  3569  		}
  3570  		v.copyOf(x)
  3571  		return true
  3572  	}
  3573  	// match: (MOVBUreg x:(FLTD _ _))
  3574  	// result: x
  3575  	for {
  3576  		x := v_0
  3577  		if x.Op != OpRISCV64FLTD {
  3578  			break
  3579  		}
  3580  		v.copyOf(x)
  3581  		return true
  3582  	}
  3583  	// match: (MOVBUreg x:(FEQD _ _))
  3584  	// result: x
  3585  	for {
  3586  		x := v_0
  3587  		if x.Op != OpRISCV64FEQD {
  3588  			break
  3589  		}
  3590  		v.copyOf(x)
  3591  		return true
  3592  	}
  3593  	// match: (MOVBUreg x:(FNED _ _))
  3594  	// result: x
  3595  	for {
  3596  		x := v_0
  3597  		if x.Op != OpRISCV64FNED {
  3598  			break
  3599  		}
  3600  		v.copyOf(x)
  3601  		return true
  3602  	}
  3603  	// match: (MOVBUreg x:(SEQZ _))
  3604  	// result: x
  3605  	for {
  3606  		x := v_0
  3607  		if x.Op != OpRISCV64SEQZ {
  3608  			break
  3609  		}
  3610  		v.copyOf(x)
  3611  		return true
  3612  	}
  3613  	// match: (MOVBUreg x:(SNEZ _))
  3614  	// result: x
  3615  	for {
  3616  		x := v_0
  3617  		if x.Op != OpRISCV64SNEZ {
  3618  			break
  3619  		}
  3620  		v.copyOf(x)
  3621  		return true
  3622  	}
  3623  	// match: (MOVBUreg x:(SLT _ _))
  3624  	// result: x
  3625  	for {
  3626  		x := v_0
  3627  		if x.Op != OpRISCV64SLT {
  3628  			break
  3629  		}
  3630  		v.copyOf(x)
  3631  		return true
  3632  	}
  3633  	// match: (MOVBUreg x:(SLTU _ _))
  3634  	// result: x
  3635  	for {
  3636  		x := v_0
  3637  		if x.Op != OpRISCV64SLTU {
  3638  			break
  3639  		}
  3640  		v.copyOf(x)
  3641  		return true
  3642  	}
  3643  	// match: (MOVBUreg x:(ANDI [c] y))
  3644  	// cond: c >= 0 && int64(uint8(c)) == c
  3645  	// result: x
  3646  	for {
  3647  		x := v_0
  3648  		if x.Op != OpRISCV64ANDI {
  3649  			break
  3650  		}
  3651  		c := auxIntToInt64(x.AuxInt)
  3652  		if !(c >= 0 && int64(uint8(c)) == c) {
  3653  			break
  3654  		}
  3655  		v.copyOf(x)
  3656  		return true
  3657  	}
  3658  	// match: (MOVBUreg (ANDI [c] x))
  3659  	// cond: c < 0
  3660  	// result: (ANDI [int64(uint8(c))] x)
  3661  	for {
  3662  		if v_0.Op != OpRISCV64ANDI {
  3663  			break
  3664  		}
  3665  		c := auxIntToInt64(v_0.AuxInt)
  3666  		x := v_0.Args[0]
  3667  		if !(c < 0) {
  3668  			break
  3669  		}
  3670  		v.reset(OpRISCV64ANDI)
  3671  		v.AuxInt = int64ToAuxInt(int64(uint8(c)))
  3672  		v.AddArg(x)
  3673  		return true
  3674  	}
  3675  	// match: (MOVBUreg (MOVDconst [c]))
  3676  	// result: (MOVDconst [int64(uint8(c))])
  3677  	for {
  3678  		if v_0.Op != OpRISCV64MOVDconst {
  3679  			break
  3680  		}
  3681  		c := auxIntToInt64(v_0.AuxInt)
  3682  		v.reset(OpRISCV64MOVDconst)
  3683  		v.AuxInt = int64ToAuxInt(int64(uint8(c)))
  3684  		return true
  3685  	}
  3686  	// match: (MOVBUreg x:(MOVBUload _ _))
  3687  	// result: (MOVDreg x)
  3688  	for {
  3689  		x := v_0
  3690  		if x.Op != OpRISCV64MOVBUload {
  3691  			break
  3692  		}
  3693  		v.reset(OpRISCV64MOVDreg)
  3694  		v.AddArg(x)
  3695  		return true
  3696  	}
  3697  	// match: (MOVBUreg x:(Select0 (LoweredAtomicLoad8 _ _)))
  3698  	// result: (MOVDreg x)
  3699  	for {
  3700  		x := v_0
  3701  		if x.Op != OpSelect0 {
  3702  			break
  3703  		}
  3704  		x_0 := x.Args[0]
  3705  		if x_0.Op != OpRISCV64LoweredAtomicLoad8 {
  3706  			break
  3707  		}
  3708  		v.reset(OpRISCV64MOVDreg)
  3709  		v.AddArg(x)
  3710  		return true
  3711  	}
  3712  	// match: (MOVBUreg x:(Select0 (LoweredAtomicCas32 _ _ _ _)))
  3713  	// result: (MOVDreg x)
  3714  	for {
  3715  		x := v_0
  3716  		if x.Op != OpSelect0 {
  3717  			break
  3718  		}
  3719  		x_0 := x.Args[0]
  3720  		if x_0.Op != OpRISCV64LoweredAtomicCas32 {
  3721  			break
  3722  		}
  3723  		v.reset(OpRISCV64MOVDreg)
  3724  		v.AddArg(x)
  3725  		return true
  3726  	}
  3727  	// match: (MOVBUreg x:(Select0 (LoweredAtomicCas64 _ _ _ _)))
  3728  	// result: (MOVDreg x)
  3729  	for {
  3730  		x := v_0
  3731  		if x.Op != OpSelect0 {
  3732  			break
  3733  		}
  3734  		x_0 := x.Args[0]
  3735  		if x_0.Op != OpRISCV64LoweredAtomicCas64 {
  3736  			break
  3737  		}
  3738  		v.reset(OpRISCV64MOVDreg)
  3739  		v.AddArg(x)
  3740  		return true
  3741  	}
  3742  	// match: (MOVBUreg x:(MOVBUreg _))
  3743  	// result: (MOVDreg x)
  3744  	for {
  3745  		x := v_0
  3746  		if x.Op != OpRISCV64MOVBUreg {
  3747  			break
  3748  		}
  3749  		v.reset(OpRISCV64MOVDreg)
  3750  		v.AddArg(x)
  3751  		return true
  3752  	}
  3753  	// match: (MOVBUreg <t> x:(MOVBload [off] {sym} ptr mem))
  3754  	// cond: x.Uses == 1 && clobber(x)
  3755  	// result: @x.Block (MOVBUload <t> [off] {sym} ptr mem)
  3756  	for {
  3757  		t := v.Type
  3758  		x := v_0
  3759  		if x.Op != OpRISCV64MOVBload {
  3760  			break
  3761  		}
  3762  		off := auxIntToInt32(x.AuxInt)
  3763  		sym := auxToSym(x.Aux)
  3764  		mem := x.Args[1]
  3765  		ptr := x.Args[0]
  3766  		if !(x.Uses == 1 && clobber(x)) {
  3767  			break
  3768  		}
  3769  		b = x.Block
  3770  		v0 := b.NewValue0(x.Pos, OpRISCV64MOVBUload, t)
  3771  		v.copyOf(v0)
  3772  		v0.AuxInt = int32ToAuxInt(off)
  3773  		v0.Aux = symToAux(sym)
  3774  		v0.AddArg2(ptr, mem)
  3775  		return true
  3776  	}
  3777  	return false
  3778  }
  3779  func rewriteValueRISCV64_OpRISCV64MOVBload(v *Value) bool {
  3780  	v_1 := v.Args[1]
  3781  	v_0 := v.Args[0]
  3782  	// match: (MOVBload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
  3783  	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
  3784  	// result: (MOVBload [off1+off2] {mergeSym(sym1,sym2)} base mem)
  3785  	for {
  3786  		off1 := auxIntToInt32(v.AuxInt)
  3787  		sym1 := auxToSym(v.Aux)
  3788  		if v_0.Op != OpRISCV64MOVaddr {
  3789  			break
  3790  		}
  3791  		off2 := auxIntToInt32(v_0.AuxInt)
  3792  		sym2 := auxToSym(v_0.Aux)
  3793  		base := v_0.Args[0]
  3794  		mem := v_1
  3795  		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
  3796  			break
  3797  		}
  3798  		v.reset(OpRISCV64MOVBload)
  3799  		v.AuxInt = int32ToAuxInt(off1 + off2)
  3800  		v.Aux = symToAux(mergeSym(sym1, sym2))
  3801  		v.AddArg2(base, mem)
  3802  		return true
  3803  	}
  3804  	// match: (MOVBload [off1] {sym} (ADDI [off2] base) mem)
  3805  	// cond: is32Bit(int64(off1)+off2)
  3806  	// result: (MOVBload [off1+int32(off2)] {sym} base mem)
  3807  	for {
  3808  		off1 := auxIntToInt32(v.AuxInt)
  3809  		sym := auxToSym(v.Aux)
  3810  		if v_0.Op != OpRISCV64ADDI {
  3811  			break
  3812  		}
  3813  		off2 := auxIntToInt64(v_0.AuxInt)
  3814  		base := v_0.Args[0]
  3815  		mem := v_1
  3816  		if !(is32Bit(int64(off1) + off2)) {
  3817  			break
  3818  		}
  3819  		v.reset(OpRISCV64MOVBload)
  3820  		v.AuxInt = int32ToAuxInt(off1 + int32(off2))
  3821  		v.Aux = symToAux(sym)
  3822  		v.AddArg2(base, mem)
  3823  		return true
  3824  	}
  3825  	return false
  3826  }
  3827  func rewriteValueRISCV64_OpRISCV64MOVBreg(v *Value) bool {
  3828  	v_0 := v.Args[0]
  3829  	b := v.Block
  3830  	// match: (MOVBreg x:(ANDI [c] y))
  3831  	// cond: c >= 0 && int64(int8(c)) == c
  3832  	// result: x
  3833  	for {
  3834  		x := v_0
  3835  		if x.Op != OpRISCV64ANDI {
  3836  			break
  3837  		}
  3838  		c := auxIntToInt64(x.AuxInt)
  3839  		if !(c >= 0 && int64(int8(c)) == c) {
  3840  			break
  3841  		}
  3842  		v.copyOf(x)
  3843  		return true
  3844  	}
  3845  	// match: (MOVBreg (MOVDconst [c]))
  3846  	// result: (MOVDconst [int64(int8(c))])
  3847  	for {
  3848  		if v_0.Op != OpRISCV64MOVDconst {
  3849  			break
  3850  		}
  3851  		c := auxIntToInt64(v_0.AuxInt)
  3852  		v.reset(OpRISCV64MOVDconst)
  3853  		v.AuxInt = int64ToAuxInt(int64(int8(c)))
  3854  		return true
  3855  	}
  3856  	// match: (MOVBreg x:(MOVBload _ _))
  3857  	// result: (MOVDreg x)
  3858  	for {
  3859  		x := v_0
  3860  		if x.Op != OpRISCV64MOVBload {
  3861  			break
  3862  		}
  3863  		v.reset(OpRISCV64MOVDreg)
  3864  		v.AddArg(x)
  3865  		return true
  3866  	}
  3867  	// match: (MOVBreg x:(MOVBreg _))
  3868  	// result: (MOVDreg x)
  3869  	for {
  3870  		x := v_0
  3871  		if x.Op != OpRISCV64MOVBreg {
  3872  			break
  3873  		}
  3874  		v.reset(OpRISCV64MOVDreg)
  3875  		v.AddArg(x)
  3876  		return true
  3877  	}
  3878  	// match: (MOVBreg <t> x:(MOVBUload [off] {sym} ptr mem))
  3879  	// cond: x.Uses == 1 && clobber(x)
  3880  	// result: @x.Block (MOVBload <t> [off] {sym} ptr mem)
  3881  	for {
  3882  		t := v.Type
  3883  		x := v_0
  3884  		if x.Op != OpRISCV64MOVBUload {
  3885  			break
  3886  		}
  3887  		off := auxIntToInt32(x.AuxInt)
  3888  		sym := auxToSym(x.Aux)
  3889  		mem := x.Args[1]
  3890  		ptr := x.Args[0]
  3891  		if !(x.Uses == 1 && clobber(x)) {
  3892  			break
  3893  		}
  3894  		b = x.Block
  3895  		v0 := b.NewValue0(x.Pos, OpRISCV64MOVBload, t)
  3896  		v.copyOf(v0)
  3897  		v0.AuxInt = int32ToAuxInt(off)
  3898  		v0.Aux = symToAux(sym)
  3899  		v0.AddArg2(ptr, mem)
  3900  		return true
  3901  	}
  3902  	return false
  3903  }
  3904  func rewriteValueRISCV64_OpRISCV64MOVBstore(v *Value) bool {
  3905  	v_2 := v.Args[2]
  3906  	v_1 := v.Args[1]
  3907  	v_0 := v.Args[0]
  3908  	// match: (MOVBstore [off1] {sym1} (MOVaddr [off2] {sym2} base) val mem)
  3909  	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
  3910  	// result: (MOVBstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
  3911  	for {
  3912  		off1 := auxIntToInt32(v.AuxInt)
  3913  		sym1 := auxToSym(v.Aux)
  3914  		if v_0.Op != OpRISCV64MOVaddr {
  3915  			break
  3916  		}
  3917  		off2 := auxIntToInt32(v_0.AuxInt)
  3918  		sym2 := auxToSym(v_0.Aux)
  3919  		base := v_0.Args[0]
  3920  		val := v_1
  3921  		mem := v_2
  3922  		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
  3923  			break
  3924  		}
  3925  		v.reset(OpRISCV64MOVBstore)
  3926  		v.AuxInt = int32ToAuxInt(off1 + off2)
  3927  		v.Aux = symToAux(mergeSym(sym1, sym2))
  3928  		v.AddArg3(base, val, mem)
  3929  		return true
  3930  	}
  3931  	// match: (MOVBstore [off1] {sym} (ADDI [off2] base) val mem)
  3932  	// cond: is32Bit(int64(off1)+off2)
  3933  	// result: (MOVBstore [off1+int32(off2)] {sym} base val mem)
  3934  	for {
  3935  		off1 := auxIntToInt32(v.AuxInt)
  3936  		sym := auxToSym(v.Aux)
  3937  		if v_0.Op != OpRISCV64ADDI {
  3938  			break
  3939  		}
  3940  		off2 := auxIntToInt64(v_0.AuxInt)
  3941  		base := v_0.Args[0]
  3942  		val := v_1
  3943  		mem := v_2
  3944  		if !(is32Bit(int64(off1) + off2)) {
  3945  			break
  3946  		}
  3947  		v.reset(OpRISCV64MOVBstore)
  3948  		v.AuxInt = int32ToAuxInt(off1 + int32(off2))
  3949  		v.Aux = symToAux(sym)
  3950  		v.AddArg3(base, val, mem)
  3951  		return true
  3952  	}
  3953  	// match: (MOVBstore [off] {sym} ptr (MOVDconst [0]) mem)
  3954  	// result: (MOVBstorezero [off] {sym} ptr mem)
  3955  	for {
  3956  		off := auxIntToInt32(v.AuxInt)
  3957  		sym := auxToSym(v.Aux)
  3958  		ptr := v_0
  3959  		if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
  3960  			break
  3961  		}
  3962  		mem := v_2
  3963  		v.reset(OpRISCV64MOVBstorezero)
  3964  		v.AuxInt = int32ToAuxInt(off)
  3965  		v.Aux = symToAux(sym)
  3966  		v.AddArg2(ptr, mem)
  3967  		return true
  3968  	}
  3969  	// match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem)
  3970  	// result: (MOVBstore [off] {sym} ptr x mem)
  3971  	for {
  3972  		off := auxIntToInt32(v.AuxInt)
  3973  		sym := auxToSym(v.Aux)
  3974  		ptr := v_0
  3975  		if v_1.Op != OpRISCV64MOVBreg {
  3976  			break
  3977  		}
  3978  		x := v_1.Args[0]
  3979  		mem := v_2
  3980  		v.reset(OpRISCV64MOVBstore)
  3981  		v.AuxInt = int32ToAuxInt(off)
  3982  		v.Aux = symToAux(sym)
  3983  		v.AddArg3(ptr, x, mem)
  3984  		return true
  3985  	}
  3986  	// match: (MOVBstore [off] {sym} ptr (MOVHreg x) mem)
  3987  	// result: (MOVBstore [off] {sym} ptr x mem)
  3988  	for {
  3989  		off := auxIntToInt32(v.AuxInt)
  3990  		sym := auxToSym(v.Aux)
  3991  		ptr := v_0
  3992  		if v_1.Op != OpRISCV64MOVHreg {
  3993  			break
  3994  		}
  3995  		x := v_1.Args[0]
  3996  		mem := v_2
  3997  		v.reset(OpRISCV64MOVBstore)
  3998  		v.AuxInt = int32ToAuxInt(off)
  3999  		v.Aux = symToAux(sym)
  4000  		v.AddArg3(ptr, x, mem)
  4001  		return true
  4002  	}
  4003  	// match: (MOVBstore [off] {sym} ptr (MOVWreg x) mem)
  4004  	// result: (MOVBstore [off] {sym} ptr x mem)
  4005  	for {
  4006  		off := auxIntToInt32(v.AuxInt)
  4007  		sym := auxToSym(v.Aux)
  4008  		ptr := v_0
  4009  		if v_1.Op != OpRISCV64MOVWreg {
  4010  			break
  4011  		}
  4012  		x := v_1.Args[0]
  4013  		mem := v_2
  4014  		v.reset(OpRISCV64MOVBstore)
  4015  		v.AuxInt = int32ToAuxInt(off)
  4016  		v.Aux = symToAux(sym)
  4017  		v.AddArg3(ptr, x, mem)
  4018  		return true
  4019  	}
  4020  	// match: (MOVBstore [off] {sym} ptr (MOVBUreg x) mem)
  4021  	// result: (MOVBstore [off] {sym} ptr x mem)
  4022  	for {
  4023  		off := auxIntToInt32(v.AuxInt)
  4024  		sym := auxToSym(v.Aux)
  4025  		ptr := v_0
  4026  		if v_1.Op != OpRISCV64MOVBUreg {
  4027  			break
  4028  		}
  4029  		x := v_1.Args[0]
  4030  		mem := v_2
  4031  		v.reset(OpRISCV64MOVBstore)
  4032  		v.AuxInt = int32ToAuxInt(off)
  4033  		v.Aux = symToAux(sym)
  4034  		v.AddArg3(ptr, x, mem)
  4035  		return true
  4036  	}
  4037  	// match: (MOVBstore [off] {sym} ptr (MOVHUreg x) mem)
  4038  	// result: (MOVBstore [off] {sym} ptr x mem)
  4039  	for {
  4040  		off := auxIntToInt32(v.AuxInt)
  4041  		sym := auxToSym(v.Aux)
  4042  		ptr := v_0
  4043  		if v_1.Op != OpRISCV64MOVHUreg {
  4044  			break
  4045  		}
  4046  		x := v_1.Args[0]
  4047  		mem := v_2
  4048  		v.reset(OpRISCV64MOVBstore)
  4049  		v.AuxInt = int32ToAuxInt(off)
  4050  		v.Aux = symToAux(sym)
  4051  		v.AddArg3(ptr, x, mem)
  4052  		return true
  4053  	}
  4054  	// match: (MOVBstore [off] {sym} ptr (MOVWUreg x) mem)
  4055  	// result: (MOVBstore [off] {sym} ptr x mem)
  4056  	for {
  4057  		off := auxIntToInt32(v.AuxInt)
  4058  		sym := auxToSym(v.Aux)
  4059  		ptr := v_0
  4060  		if v_1.Op != OpRISCV64MOVWUreg {
  4061  			break
  4062  		}
  4063  		x := v_1.Args[0]
  4064  		mem := v_2
  4065  		v.reset(OpRISCV64MOVBstore)
  4066  		v.AuxInt = int32ToAuxInt(off)
  4067  		v.Aux = symToAux(sym)
  4068  		v.AddArg3(ptr, x, mem)
  4069  		return true
  4070  	}
  4071  	return false
  4072  }
  4073  func rewriteValueRISCV64_OpRISCV64MOVBstorezero(v *Value) bool {
  4074  	v_1 := v.Args[1]
  4075  	v_0 := v.Args[0]
  4076  	// match: (MOVBstorezero [off1] {sym1} (MOVaddr [off2] {sym2} ptr) mem)
  4077  	// cond: canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2))
  4078  	// result: (MOVBstorezero [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
  4079  	for {
  4080  		off1 := auxIntToInt32(v.AuxInt)
  4081  		sym1 := auxToSym(v.Aux)
  4082  		if v_0.Op != OpRISCV64MOVaddr {
  4083  			break
  4084  		}
  4085  		off2 := auxIntToInt32(v_0.AuxInt)
  4086  		sym2 := auxToSym(v_0.Aux)
  4087  		ptr := v_0.Args[0]
  4088  		mem := v_1
  4089  		if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
  4090  			break
  4091  		}
  4092  		v.reset(OpRISCV64MOVBstorezero)
  4093  		v.AuxInt = int32ToAuxInt(off1 + off2)
  4094  		v.Aux = symToAux(mergeSym(sym1, sym2))
  4095  		v.AddArg2(ptr, mem)
  4096  		return true
  4097  	}
  4098  	// match: (MOVBstorezero [off1] {sym} (ADDI [off2] ptr) mem)
  4099  	// cond: is32Bit(int64(off1)+off2)
  4100  	// result: (MOVBstorezero [off1+int32(off2)] {sym} ptr mem)
  4101  	for {
  4102  		off1 := auxIntToInt32(v.AuxInt)
  4103  		sym := auxToSym(v.Aux)
  4104  		if v_0.Op != OpRISCV64ADDI {
  4105  			break
  4106  		}
  4107  		off2 := auxIntToInt64(v_0.AuxInt)
  4108  		ptr := v_0.Args[0]
  4109  		mem := v_1
  4110  		if !(is32Bit(int64(off1) + off2)) {
  4111  			break
  4112  		}
  4113  		v.reset(OpRISCV64MOVBstorezero)
  4114  		v.AuxInt = int32ToAuxInt(off1 + int32(off2))
  4115  		v.Aux = symToAux(sym)
  4116  		v.AddArg2(ptr, mem)
  4117  		return true
  4118  	}
  4119  	return false
  4120  }
  4121  func rewriteValueRISCV64_OpRISCV64MOVDload(v *Value) bool {
  4122  	v_1 := v.Args[1]
  4123  	v_0 := v.Args[0]
  4124  	// match: (MOVDload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
  4125  	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
  4126  	// result: (MOVDload [off1+off2] {mergeSym(sym1,sym2)} base mem)
  4127  	for {
  4128  		off1 := auxIntToInt32(v.AuxInt)
  4129  		sym1 := auxToSym(v.Aux)
  4130  		if v_0.Op != OpRISCV64MOVaddr {
  4131  			break
  4132  		}
  4133  		off2 := auxIntToInt32(v_0.AuxInt)
  4134  		sym2 := auxToSym(v_0.Aux)
  4135  		base := v_0.Args[0]
  4136  		mem := v_1
  4137  		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
  4138  			break
  4139  		}
  4140  		v.reset(OpRISCV64MOVDload)
  4141  		v.AuxInt = int32ToAuxInt(off1 + off2)
  4142  		v.Aux = symToAux(mergeSym(sym1, sym2))
  4143  		v.AddArg2(base, mem)
  4144  		return true
  4145  	}
  4146  	// match: (MOVDload [off1] {sym} (ADDI [off2] base) mem)
  4147  	// cond: is32Bit(int64(off1)+off2)
  4148  	// result: (MOVDload [off1+int32(off2)] {sym} base mem)
  4149  	for {
  4150  		off1 := auxIntToInt32(v.AuxInt)
  4151  		sym := auxToSym(v.Aux)
  4152  		if v_0.Op != OpRISCV64ADDI {
  4153  			break
  4154  		}
  4155  		off2 := auxIntToInt64(v_0.AuxInt)
  4156  		base := v_0.Args[0]
  4157  		mem := v_1
  4158  		if !(is32Bit(int64(off1) + off2)) {
  4159  			break
  4160  		}
  4161  		v.reset(OpRISCV64MOVDload)
  4162  		v.AuxInt = int32ToAuxInt(off1 + int32(off2))
  4163  		v.Aux = symToAux(sym)
  4164  		v.AddArg2(base, mem)
  4165  		return true
  4166  	}
  4167  	return false
  4168  }
  4169  func rewriteValueRISCV64_OpRISCV64MOVDnop(v *Value) bool {
  4170  	v_0 := v.Args[0]
  4171  	// match: (MOVDnop (MOVDconst [c]))
  4172  	// result: (MOVDconst [c])
  4173  	for {
  4174  		if v_0.Op != OpRISCV64MOVDconst {
  4175  			break
  4176  		}
  4177  		c := auxIntToInt64(v_0.AuxInt)
  4178  		v.reset(OpRISCV64MOVDconst)
  4179  		v.AuxInt = int64ToAuxInt(c)
  4180  		return true
  4181  	}
  4182  	return false
  4183  }
  4184  func rewriteValueRISCV64_OpRISCV64MOVDreg(v *Value) bool {
  4185  	v_0 := v.Args[0]
  4186  	// match: (MOVDreg x)
  4187  	// cond: x.Uses == 1
  4188  	// result: (MOVDnop x)
  4189  	for {
  4190  		x := v_0
  4191  		if !(x.Uses == 1) {
  4192  			break
  4193  		}
  4194  		v.reset(OpRISCV64MOVDnop)
  4195  		v.AddArg(x)
  4196  		return true
  4197  	}
  4198  	return false
  4199  }
  4200  func rewriteValueRISCV64_OpRISCV64MOVDstore(v *Value) bool {
  4201  	v_2 := v.Args[2]
  4202  	v_1 := v.Args[1]
  4203  	v_0 := v.Args[0]
  4204  	// match: (MOVDstore [off1] {sym1} (MOVaddr [off2] {sym2} base) val mem)
  4205  	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
  4206  	// result: (MOVDstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
  4207  	for {
  4208  		off1 := auxIntToInt32(v.AuxInt)
  4209  		sym1 := auxToSym(v.Aux)
  4210  		if v_0.Op != OpRISCV64MOVaddr {
  4211  			break
  4212  		}
  4213  		off2 := auxIntToInt32(v_0.AuxInt)
  4214  		sym2 := auxToSym(v_0.Aux)
  4215  		base := v_0.Args[0]
  4216  		val := v_1
  4217  		mem := v_2
  4218  		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
  4219  			break
  4220  		}
  4221  		v.reset(OpRISCV64MOVDstore)
  4222  		v.AuxInt = int32ToAuxInt(off1 + off2)
  4223  		v.Aux = symToAux(mergeSym(sym1, sym2))
  4224  		v.AddArg3(base, val, mem)
  4225  		return true
  4226  	}
  4227  	// match: (MOVDstore [off1] {sym} (ADDI [off2] base) val mem)
  4228  	// cond: is32Bit(int64(off1)+off2)
  4229  	// result: (MOVDstore [off1+int32(off2)] {sym} base val mem)
  4230  	for {
  4231  		off1 := auxIntToInt32(v.AuxInt)
  4232  		sym := auxToSym(v.Aux)
  4233  		if v_0.Op != OpRISCV64ADDI {
  4234  			break
  4235  		}
  4236  		off2 := auxIntToInt64(v_0.AuxInt)
  4237  		base := v_0.Args[0]
  4238  		val := v_1
  4239  		mem := v_2
  4240  		if !(is32Bit(int64(off1) + off2)) {
  4241  			break
  4242  		}
  4243  		v.reset(OpRISCV64MOVDstore)
  4244  		v.AuxInt = int32ToAuxInt(off1 + int32(off2))
  4245  		v.Aux = symToAux(sym)
  4246  		v.AddArg3(base, val, mem)
  4247  		return true
  4248  	}
  4249  	// match: (MOVDstore [off] {sym} ptr (MOVDconst [0]) mem)
  4250  	// result: (MOVDstorezero [off] {sym} ptr mem)
  4251  	for {
  4252  		off := auxIntToInt32(v.AuxInt)
  4253  		sym := auxToSym(v.Aux)
  4254  		ptr := v_0
  4255  		if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
  4256  			break
  4257  		}
  4258  		mem := v_2
  4259  		v.reset(OpRISCV64MOVDstorezero)
  4260  		v.AuxInt = int32ToAuxInt(off)
  4261  		v.Aux = symToAux(sym)
  4262  		v.AddArg2(ptr, mem)
  4263  		return true
  4264  	}
  4265  	return false
  4266  }
  4267  func rewriteValueRISCV64_OpRISCV64MOVDstorezero(v *Value) bool {
  4268  	v_1 := v.Args[1]
  4269  	v_0 := v.Args[0]
  4270  	// match: (MOVDstorezero [off1] {sym1} (MOVaddr [off2] {sym2} ptr) mem)
  4271  	// cond: canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2))
  4272  	// result: (MOVDstorezero [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
  4273  	for {
  4274  		off1 := auxIntToInt32(v.AuxInt)
  4275  		sym1 := auxToSym(v.Aux)
  4276  		if v_0.Op != OpRISCV64MOVaddr {
  4277  			break
  4278  		}
  4279  		off2 := auxIntToInt32(v_0.AuxInt)
  4280  		sym2 := auxToSym(v_0.Aux)
  4281  		ptr := v_0.Args[0]
  4282  		mem := v_1
  4283  		if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
  4284  			break
  4285  		}
  4286  		v.reset(OpRISCV64MOVDstorezero)
  4287  		v.AuxInt = int32ToAuxInt(off1 + off2)
  4288  		v.Aux = symToAux(mergeSym(sym1, sym2))
  4289  		v.AddArg2(ptr, mem)
  4290  		return true
  4291  	}
  4292  	// match: (MOVDstorezero [off1] {sym} (ADDI [off2] ptr) mem)
  4293  	// cond: is32Bit(int64(off1)+off2)
  4294  	// result: (MOVDstorezero [off1+int32(off2)] {sym} ptr mem)
  4295  	for {
  4296  		off1 := auxIntToInt32(v.AuxInt)
  4297  		sym := auxToSym(v.Aux)
  4298  		if v_0.Op != OpRISCV64ADDI {
  4299  			break
  4300  		}
  4301  		off2 := auxIntToInt64(v_0.AuxInt)
  4302  		ptr := v_0.Args[0]
  4303  		mem := v_1
  4304  		if !(is32Bit(int64(off1) + off2)) {
  4305  			break
  4306  		}
  4307  		v.reset(OpRISCV64MOVDstorezero)
  4308  		v.AuxInt = int32ToAuxInt(off1 + int32(off2))
  4309  		v.Aux = symToAux(sym)
  4310  		v.AddArg2(ptr, mem)
  4311  		return true
  4312  	}
  4313  	return false
  4314  }
  4315  func rewriteValueRISCV64_OpRISCV64MOVHUload(v *Value) bool {
  4316  	v_1 := v.Args[1]
  4317  	v_0 := v.Args[0]
  4318  	// match: (MOVHUload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
  4319  	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
  4320  	// result: (MOVHUload [off1+off2] {mergeSym(sym1,sym2)} base mem)
  4321  	for {
  4322  		off1 := auxIntToInt32(v.AuxInt)
  4323  		sym1 := auxToSym(v.Aux)
  4324  		if v_0.Op != OpRISCV64MOVaddr {
  4325  			break
  4326  		}
  4327  		off2 := auxIntToInt32(v_0.AuxInt)
  4328  		sym2 := auxToSym(v_0.Aux)
  4329  		base := v_0.Args[0]
  4330  		mem := v_1
  4331  		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
  4332  			break
  4333  		}
  4334  		v.reset(OpRISCV64MOVHUload)
  4335  		v.AuxInt = int32ToAuxInt(off1 + off2)
  4336  		v.Aux = symToAux(mergeSym(sym1, sym2))
  4337  		v.AddArg2(base, mem)
  4338  		return true
  4339  	}
  4340  	// match: (MOVHUload [off1] {sym} (ADDI [off2] base) mem)
  4341  	// cond: is32Bit(int64(off1)+off2)
  4342  	// result: (MOVHUload [off1+int32(off2)] {sym} base mem)
  4343  	for {
  4344  		off1 := auxIntToInt32(v.AuxInt)
  4345  		sym := auxToSym(v.Aux)
  4346  		if v_0.Op != OpRISCV64ADDI {
  4347  			break
  4348  		}
  4349  		off2 := auxIntToInt64(v_0.AuxInt)
  4350  		base := v_0.Args[0]
  4351  		mem := v_1
  4352  		if !(is32Bit(int64(off1) + off2)) {
  4353  			break
  4354  		}
  4355  		v.reset(OpRISCV64MOVHUload)
  4356  		v.AuxInt = int32ToAuxInt(off1 + int32(off2))
  4357  		v.Aux = symToAux(sym)
  4358  		v.AddArg2(base, mem)
  4359  		return true
  4360  	}
  4361  	return false
  4362  }
  4363  func rewriteValueRISCV64_OpRISCV64MOVHUreg(v *Value) bool {
  4364  	v_0 := v.Args[0]
  4365  	b := v.Block
  4366  	// match: (MOVHUreg x:(ANDI [c] y))
  4367  	// cond: c >= 0 && int64(uint16(c)) == c
  4368  	// result: x
  4369  	for {
  4370  		x := v_0
  4371  		if x.Op != OpRISCV64ANDI {
  4372  			break
  4373  		}
  4374  		c := auxIntToInt64(x.AuxInt)
  4375  		if !(c >= 0 && int64(uint16(c)) == c) {
  4376  			break
  4377  		}
  4378  		v.copyOf(x)
  4379  		return true
  4380  	}
  4381  	// match: (MOVHUreg (ANDI [c] x))
  4382  	// cond: c < 0
  4383  	// result: (ANDI [int64(uint16(c))] x)
  4384  	for {
  4385  		if v_0.Op != OpRISCV64ANDI {
  4386  			break
  4387  		}
  4388  		c := auxIntToInt64(v_0.AuxInt)
  4389  		x := v_0.Args[0]
  4390  		if !(c < 0) {
  4391  			break
  4392  		}
  4393  		v.reset(OpRISCV64ANDI)
  4394  		v.AuxInt = int64ToAuxInt(int64(uint16(c)))
  4395  		v.AddArg(x)
  4396  		return true
  4397  	}
  4398  	// match: (MOVHUreg (MOVDconst [c]))
  4399  	// result: (MOVDconst [int64(uint16(c))])
  4400  	for {
  4401  		if v_0.Op != OpRISCV64MOVDconst {
  4402  			break
  4403  		}
  4404  		c := auxIntToInt64(v_0.AuxInt)
  4405  		v.reset(OpRISCV64MOVDconst)
  4406  		v.AuxInt = int64ToAuxInt(int64(uint16(c)))
  4407  		return true
  4408  	}
  4409  	// match: (MOVHUreg x:(MOVBUload _ _))
  4410  	// result: (MOVDreg x)
  4411  	for {
  4412  		x := v_0
  4413  		if x.Op != OpRISCV64MOVBUload {
  4414  			break
  4415  		}
  4416  		v.reset(OpRISCV64MOVDreg)
  4417  		v.AddArg(x)
  4418  		return true
  4419  	}
  4420  	// match: (MOVHUreg x:(MOVHUload _ _))
  4421  	// result: (MOVDreg x)
  4422  	for {
  4423  		x := v_0
  4424  		if x.Op != OpRISCV64MOVHUload {
  4425  			break
  4426  		}
  4427  		v.reset(OpRISCV64MOVDreg)
  4428  		v.AddArg(x)
  4429  		return true
  4430  	}
  4431  	// match: (MOVHUreg x:(MOVBUreg _))
  4432  	// result: (MOVDreg x)
  4433  	for {
  4434  		x := v_0
  4435  		if x.Op != OpRISCV64MOVBUreg {
  4436  			break
  4437  		}
  4438  		v.reset(OpRISCV64MOVDreg)
  4439  		v.AddArg(x)
  4440  		return true
  4441  	}
  4442  	// match: (MOVHUreg x:(MOVHUreg _))
  4443  	// result: (MOVDreg x)
  4444  	for {
  4445  		x := v_0
  4446  		if x.Op != OpRISCV64MOVHUreg {
  4447  			break
  4448  		}
  4449  		v.reset(OpRISCV64MOVDreg)
  4450  		v.AddArg(x)
  4451  		return true
  4452  	}
  4453  	// match: (MOVHUreg <t> x:(MOVHload [off] {sym} ptr mem))
  4454  	// cond: x.Uses == 1 && clobber(x)
  4455  	// result: @x.Block (MOVHUload <t> [off] {sym} ptr mem)
  4456  	for {
  4457  		t := v.Type
  4458  		x := v_0
  4459  		if x.Op != OpRISCV64MOVHload {
  4460  			break
  4461  		}
  4462  		off := auxIntToInt32(x.AuxInt)
  4463  		sym := auxToSym(x.Aux)
  4464  		mem := x.Args[1]
  4465  		ptr := x.Args[0]
  4466  		if !(x.Uses == 1 && clobber(x)) {
  4467  			break
  4468  		}
  4469  		b = x.Block
  4470  		v0 := b.NewValue0(x.Pos, OpRISCV64MOVHUload, t)
  4471  		v.copyOf(v0)
  4472  		v0.AuxInt = int32ToAuxInt(off)
  4473  		v0.Aux = symToAux(sym)
  4474  		v0.AddArg2(ptr, mem)
  4475  		return true
  4476  	}
  4477  	return false
  4478  }
  4479  func rewriteValueRISCV64_OpRISCV64MOVHload(v *Value) bool {
  4480  	v_1 := v.Args[1]
  4481  	v_0 := v.Args[0]
  4482  	// match: (MOVHload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
  4483  	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
  4484  	// result: (MOVHload [off1+off2] {mergeSym(sym1,sym2)} base mem)
  4485  	for {
  4486  		off1 := auxIntToInt32(v.AuxInt)
  4487  		sym1 := auxToSym(v.Aux)
  4488  		if v_0.Op != OpRISCV64MOVaddr {
  4489  			break
  4490  		}
  4491  		off2 := auxIntToInt32(v_0.AuxInt)
  4492  		sym2 := auxToSym(v_0.Aux)
  4493  		base := v_0.Args[0]
  4494  		mem := v_1
  4495  		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
  4496  			break
  4497  		}
  4498  		v.reset(OpRISCV64MOVHload)
  4499  		v.AuxInt = int32ToAuxInt(off1 + off2)
  4500  		v.Aux = symToAux(mergeSym(sym1, sym2))
  4501  		v.AddArg2(base, mem)
  4502  		return true
  4503  	}
  4504  	// match: (MOVHload [off1] {sym} (ADDI [off2] base) mem)
  4505  	// cond: is32Bit(int64(off1)+off2)
  4506  	// result: (MOVHload [off1+int32(off2)] {sym} base mem)
  4507  	for {
  4508  		off1 := auxIntToInt32(v.AuxInt)
  4509  		sym := auxToSym(v.Aux)
  4510  		if v_0.Op != OpRISCV64ADDI {
  4511  			break
  4512  		}
  4513  		off2 := auxIntToInt64(v_0.AuxInt)
  4514  		base := v_0.Args[0]
  4515  		mem := v_1
  4516  		if !(is32Bit(int64(off1) + off2)) {
  4517  			break
  4518  		}
  4519  		v.reset(OpRISCV64MOVHload)
  4520  		v.AuxInt = int32ToAuxInt(off1 + int32(off2))
  4521  		v.Aux = symToAux(sym)
  4522  		v.AddArg2(base, mem)
  4523  		return true
  4524  	}
  4525  	return false
  4526  }
  4527  func rewriteValueRISCV64_OpRISCV64MOVHreg(v *Value) bool {
  4528  	v_0 := v.Args[0]
  4529  	b := v.Block
  4530  	// match: (MOVHreg x:(ANDI [c] y))
  4531  	// cond: c >= 0 && int64(int16(c)) == c
  4532  	// result: x
  4533  	for {
  4534  		x := v_0
  4535  		if x.Op != OpRISCV64ANDI {
  4536  			break
  4537  		}
  4538  		c := auxIntToInt64(x.AuxInt)
  4539  		if !(c >= 0 && int64(int16(c)) == c) {
  4540  			break
  4541  		}
  4542  		v.copyOf(x)
  4543  		return true
  4544  	}
  4545  	// match: (MOVHreg (MOVDconst [c]))
  4546  	// result: (MOVDconst [int64(int16(c))])
  4547  	for {
  4548  		if v_0.Op != OpRISCV64MOVDconst {
  4549  			break
  4550  		}
  4551  		c := auxIntToInt64(v_0.AuxInt)
  4552  		v.reset(OpRISCV64MOVDconst)
  4553  		v.AuxInt = int64ToAuxInt(int64(int16(c)))
  4554  		return true
  4555  	}
  4556  	// match: (MOVHreg x:(MOVBload _ _))
  4557  	// result: (MOVDreg x)
  4558  	for {
  4559  		x := v_0
  4560  		if x.Op != OpRISCV64MOVBload {
  4561  			break
  4562  		}
  4563  		v.reset(OpRISCV64MOVDreg)
  4564  		v.AddArg(x)
  4565  		return true
  4566  	}
  4567  	// match: (MOVHreg x:(MOVBUload _ _))
  4568  	// result: (MOVDreg x)
  4569  	for {
  4570  		x := v_0
  4571  		if x.Op != OpRISCV64MOVBUload {
  4572  			break
  4573  		}
  4574  		v.reset(OpRISCV64MOVDreg)
  4575  		v.AddArg(x)
  4576  		return true
  4577  	}
  4578  	// match: (MOVHreg x:(MOVHload _ _))
  4579  	// result: (MOVDreg x)
  4580  	for {
  4581  		x := v_0
  4582  		if x.Op != OpRISCV64MOVHload {
  4583  			break
  4584  		}
  4585  		v.reset(OpRISCV64MOVDreg)
  4586  		v.AddArg(x)
  4587  		return true
  4588  	}
  4589  	// match: (MOVHreg x:(MOVBreg _))
  4590  	// result: (MOVDreg x)
  4591  	for {
  4592  		x := v_0
  4593  		if x.Op != OpRISCV64MOVBreg {
  4594  			break
  4595  		}
  4596  		v.reset(OpRISCV64MOVDreg)
  4597  		v.AddArg(x)
  4598  		return true
  4599  	}
  4600  	// match: (MOVHreg x:(MOVBUreg _))
  4601  	// result: (MOVDreg x)
  4602  	for {
  4603  		x := v_0
  4604  		if x.Op != OpRISCV64MOVBUreg {
  4605  			break
  4606  		}
  4607  		v.reset(OpRISCV64MOVDreg)
  4608  		v.AddArg(x)
  4609  		return true
  4610  	}
  4611  	// match: (MOVHreg x:(MOVHreg _))
  4612  	// result: (MOVDreg x)
  4613  	for {
  4614  		x := v_0
  4615  		if x.Op != OpRISCV64MOVHreg {
  4616  			break
  4617  		}
  4618  		v.reset(OpRISCV64MOVDreg)
  4619  		v.AddArg(x)
  4620  		return true
  4621  	}
  4622  	// match: (MOVHreg <t> x:(MOVHUload [off] {sym} ptr mem))
  4623  	// cond: x.Uses == 1 && clobber(x)
  4624  	// result: @x.Block (MOVHload <t> [off] {sym} ptr mem)
  4625  	for {
  4626  		t := v.Type
  4627  		x := v_0
  4628  		if x.Op != OpRISCV64MOVHUload {
  4629  			break
  4630  		}
  4631  		off := auxIntToInt32(x.AuxInt)
  4632  		sym := auxToSym(x.Aux)
  4633  		mem := x.Args[1]
  4634  		ptr := x.Args[0]
  4635  		if !(x.Uses == 1 && clobber(x)) {
  4636  			break
  4637  		}
  4638  		b = x.Block
  4639  		v0 := b.NewValue0(x.Pos, OpRISCV64MOVHload, t)
  4640  		v.copyOf(v0)
  4641  		v0.AuxInt = int32ToAuxInt(off)
  4642  		v0.Aux = symToAux(sym)
  4643  		v0.AddArg2(ptr, mem)
  4644  		return true
  4645  	}
  4646  	return false
  4647  }
  4648  func rewriteValueRISCV64_OpRISCV64MOVHstore(v *Value) bool {
  4649  	v_2 := v.Args[2]
  4650  	v_1 := v.Args[1]
  4651  	v_0 := v.Args[0]
  4652  	// match: (MOVHstore [off1] {sym1} (MOVaddr [off2] {sym2} base) val mem)
  4653  	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
  4654  	// result: (MOVHstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
  4655  	for {
  4656  		off1 := auxIntToInt32(v.AuxInt)
  4657  		sym1 := auxToSym(v.Aux)
  4658  		if v_0.Op != OpRISCV64MOVaddr {
  4659  			break
  4660  		}
  4661  		off2 := auxIntToInt32(v_0.AuxInt)
  4662  		sym2 := auxToSym(v_0.Aux)
  4663  		base := v_0.Args[0]
  4664  		val := v_1
  4665  		mem := v_2
  4666  		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
  4667  			break
  4668  		}
  4669  		v.reset(OpRISCV64MOVHstore)
  4670  		v.AuxInt = int32ToAuxInt(off1 + off2)
  4671  		v.Aux = symToAux(mergeSym(sym1, sym2))
  4672  		v.AddArg3(base, val, mem)
  4673  		return true
  4674  	}
  4675  	// match: (MOVHstore [off1] {sym} (ADDI [off2] base) val mem)
  4676  	// cond: is32Bit(int64(off1)+off2)
  4677  	// result: (MOVHstore [off1+int32(off2)] {sym} base val mem)
  4678  	for {
  4679  		off1 := auxIntToInt32(v.AuxInt)
  4680  		sym := auxToSym(v.Aux)
  4681  		if v_0.Op != OpRISCV64ADDI {
  4682  			break
  4683  		}
  4684  		off2 := auxIntToInt64(v_0.AuxInt)
  4685  		base := v_0.Args[0]
  4686  		val := v_1
  4687  		mem := v_2
  4688  		if !(is32Bit(int64(off1) + off2)) {
  4689  			break
  4690  		}
  4691  		v.reset(OpRISCV64MOVHstore)
  4692  		v.AuxInt = int32ToAuxInt(off1 + int32(off2))
  4693  		v.Aux = symToAux(sym)
  4694  		v.AddArg3(base, val, mem)
  4695  		return true
  4696  	}
  4697  	// match: (MOVHstore [off] {sym} ptr (MOVDconst [0]) mem)
  4698  	// result: (MOVHstorezero [off] {sym} ptr mem)
  4699  	for {
  4700  		off := auxIntToInt32(v.AuxInt)
  4701  		sym := auxToSym(v.Aux)
  4702  		ptr := v_0
  4703  		if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
  4704  			break
  4705  		}
  4706  		mem := v_2
  4707  		v.reset(OpRISCV64MOVHstorezero)
  4708  		v.AuxInt = int32ToAuxInt(off)
  4709  		v.Aux = symToAux(sym)
  4710  		v.AddArg2(ptr, mem)
  4711  		return true
  4712  	}
  4713  	// match: (MOVHstore [off] {sym} ptr (MOVHreg x) mem)
  4714  	// result: (MOVHstore [off] {sym} ptr x mem)
  4715  	for {
  4716  		off := auxIntToInt32(v.AuxInt)
  4717  		sym := auxToSym(v.Aux)
  4718  		ptr := v_0
  4719  		if v_1.Op != OpRISCV64MOVHreg {
  4720  			break
  4721  		}
  4722  		x := v_1.Args[0]
  4723  		mem := v_2
  4724  		v.reset(OpRISCV64MOVHstore)
  4725  		v.AuxInt = int32ToAuxInt(off)
  4726  		v.Aux = symToAux(sym)
  4727  		v.AddArg3(ptr, x, mem)
  4728  		return true
  4729  	}
  4730  	// match: (MOVHstore [off] {sym} ptr (MOVWreg x) mem)
  4731  	// result: (MOVHstore [off] {sym} ptr x mem)
  4732  	for {
  4733  		off := auxIntToInt32(v.AuxInt)
  4734  		sym := auxToSym(v.Aux)
  4735  		ptr := v_0
  4736  		if v_1.Op != OpRISCV64MOVWreg {
  4737  			break
  4738  		}
  4739  		x := v_1.Args[0]
  4740  		mem := v_2
  4741  		v.reset(OpRISCV64MOVHstore)
  4742  		v.AuxInt = int32ToAuxInt(off)
  4743  		v.Aux = symToAux(sym)
  4744  		v.AddArg3(ptr, x, mem)
  4745  		return true
  4746  	}
  4747  	// match: (MOVHstore [off] {sym} ptr (MOVHUreg x) mem)
  4748  	// result: (MOVHstore [off] {sym} ptr x mem)
  4749  	for {
  4750  		off := auxIntToInt32(v.AuxInt)
  4751  		sym := auxToSym(v.Aux)
  4752  		ptr := v_0
  4753  		if v_1.Op != OpRISCV64MOVHUreg {
  4754  			break
  4755  		}
  4756  		x := v_1.Args[0]
  4757  		mem := v_2
  4758  		v.reset(OpRISCV64MOVHstore)
  4759  		v.AuxInt = int32ToAuxInt(off)
  4760  		v.Aux = symToAux(sym)
  4761  		v.AddArg3(ptr, x, mem)
  4762  		return true
  4763  	}
  4764  	// match: (MOVHstore [off] {sym} ptr (MOVWUreg x) mem)
  4765  	// result: (MOVHstore [off] {sym} ptr x mem)
  4766  	for {
  4767  		off := auxIntToInt32(v.AuxInt)
  4768  		sym := auxToSym(v.Aux)
  4769  		ptr := v_0
  4770  		if v_1.Op != OpRISCV64MOVWUreg {
  4771  			break
  4772  		}
  4773  		x := v_1.Args[0]
  4774  		mem := v_2
  4775  		v.reset(OpRISCV64MOVHstore)
  4776  		v.AuxInt = int32ToAuxInt(off)
  4777  		v.Aux = symToAux(sym)
  4778  		v.AddArg3(ptr, x, mem)
  4779  		return true
  4780  	}
  4781  	return false
  4782  }
  4783  func rewriteValueRISCV64_OpRISCV64MOVHstorezero(v *Value) bool {
  4784  	v_1 := v.Args[1]
  4785  	v_0 := v.Args[0]
  4786  	// match: (MOVHstorezero [off1] {sym1} (MOVaddr [off2] {sym2} ptr) mem)
  4787  	// cond: canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2))
  4788  	// result: (MOVHstorezero [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
  4789  	for {
  4790  		off1 := auxIntToInt32(v.AuxInt)
  4791  		sym1 := auxToSym(v.Aux)
  4792  		if v_0.Op != OpRISCV64MOVaddr {
  4793  			break
  4794  		}
  4795  		off2 := auxIntToInt32(v_0.AuxInt)
  4796  		sym2 := auxToSym(v_0.Aux)
  4797  		ptr := v_0.Args[0]
  4798  		mem := v_1
  4799  		if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
  4800  			break
  4801  		}
  4802  		v.reset(OpRISCV64MOVHstorezero)
  4803  		v.AuxInt = int32ToAuxInt(off1 + off2)
  4804  		v.Aux = symToAux(mergeSym(sym1, sym2))
  4805  		v.AddArg2(ptr, mem)
  4806  		return true
  4807  	}
  4808  	// match: (MOVHstorezero [off1] {sym} (ADDI [off2] ptr) mem)
  4809  	// cond: is32Bit(int64(off1)+off2)
  4810  	// result: (MOVHstorezero [off1+int32(off2)] {sym} ptr mem)
  4811  	for {
  4812  		off1 := auxIntToInt32(v.AuxInt)
  4813  		sym := auxToSym(v.Aux)
  4814  		if v_0.Op != OpRISCV64ADDI {
  4815  			break
  4816  		}
  4817  		off2 := auxIntToInt64(v_0.AuxInt)
  4818  		ptr := v_0.Args[0]
  4819  		mem := v_1
  4820  		if !(is32Bit(int64(off1) + off2)) {
  4821  			break
  4822  		}
  4823  		v.reset(OpRISCV64MOVHstorezero)
  4824  		v.AuxInt = int32ToAuxInt(off1 + int32(off2))
  4825  		v.Aux = symToAux(sym)
  4826  		v.AddArg2(ptr, mem)
  4827  		return true
  4828  	}
  4829  	return false
  4830  }
  4831  func rewriteValueRISCV64_OpRISCV64MOVWUload(v *Value) bool {
  4832  	v_1 := v.Args[1]
  4833  	v_0 := v.Args[0]
  4834  	// match: (MOVWUload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
  4835  	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
  4836  	// result: (MOVWUload [off1+off2] {mergeSym(sym1,sym2)} base mem)
  4837  	for {
  4838  		off1 := auxIntToInt32(v.AuxInt)
  4839  		sym1 := auxToSym(v.Aux)
  4840  		if v_0.Op != OpRISCV64MOVaddr {
  4841  			break
  4842  		}
  4843  		off2 := auxIntToInt32(v_0.AuxInt)
  4844  		sym2 := auxToSym(v_0.Aux)
  4845  		base := v_0.Args[0]
  4846  		mem := v_1
  4847  		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
  4848  			break
  4849  		}
  4850  		v.reset(OpRISCV64MOVWUload)
  4851  		v.AuxInt = int32ToAuxInt(off1 + off2)
  4852  		v.Aux = symToAux(mergeSym(sym1, sym2))
  4853  		v.AddArg2(base, mem)
  4854  		return true
  4855  	}
  4856  	// match: (MOVWUload [off1] {sym} (ADDI [off2] base) mem)
  4857  	// cond: is32Bit(int64(off1)+off2)
  4858  	// result: (MOVWUload [off1+int32(off2)] {sym} base mem)
  4859  	for {
  4860  		off1 := auxIntToInt32(v.AuxInt)
  4861  		sym := auxToSym(v.Aux)
  4862  		if v_0.Op != OpRISCV64ADDI {
  4863  			break
  4864  		}
  4865  		off2 := auxIntToInt64(v_0.AuxInt)
  4866  		base := v_0.Args[0]
  4867  		mem := v_1
  4868  		if !(is32Bit(int64(off1) + off2)) {
  4869  			break
  4870  		}
  4871  		v.reset(OpRISCV64MOVWUload)
  4872  		v.AuxInt = int32ToAuxInt(off1 + int32(off2))
  4873  		v.Aux = symToAux(sym)
  4874  		v.AddArg2(base, mem)
  4875  		return true
  4876  	}
  4877  	return false
  4878  }
  4879  func rewriteValueRISCV64_OpRISCV64MOVWUreg(v *Value) bool {
  4880  	v_0 := v.Args[0]
  4881  	b := v.Block
  4882  	typ := &b.Func.Config.Types
  4883  	// match: (MOVWUreg x:(ANDI [c] y))
  4884  	// cond: c >= 0 && int64(uint32(c)) == c
  4885  	// result: x
  4886  	for {
  4887  		x := v_0
  4888  		if x.Op != OpRISCV64ANDI {
  4889  			break
  4890  		}
  4891  		c := auxIntToInt64(x.AuxInt)
  4892  		if !(c >= 0 && int64(uint32(c)) == c) {
  4893  			break
  4894  		}
  4895  		v.copyOf(x)
  4896  		return true
  4897  	}
  4898  	// match: (MOVWUreg (ANDI [c] x))
  4899  	// cond: c < 0
  4900  	// result: (AND (MOVDconst [int64(uint32(c))]) x)
  4901  	for {
  4902  		if v_0.Op != OpRISCV64ANDI {
  4903  			break
  4904  		}
  4905  		c := auxIntToInt64(v_0.AuxInt)
  4906  		x := v_0.Args[0]
  4907  		if !(c < 0) {
  4908  			break
  4909  		}
  4910  		v.reset(OpRISCV64AND)
  4911  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  4912  		v0.AuxInt = int64ToAuxInt(int64(uint32(c)))
  4913  		v.AddArg2(v0, x)
  4914  		return true
  4915  	}
  4916  	// match: (MOVWUreg (MOVDconst [c]))
  4917  	// result: (MOVDconst [int64(uint32(c))])
  4918  	for {
  4919  		if v_0.Op != OpRISCV64MOVDconst {
  4920  			break
  4921  		}
  4922  		c := auxIntToInt64(v_0.AuxInt)
  4923  		v.reset(OpRISCV64MOVDconst)
  4924  		v.AuxInt = int64ToAuxInt(int64(uint32(c)))
  4925  		return true
  4926  	}
  4927  	// match: (MOVWUreg x:(MOVBUload _ _))
  4928  	// result: (MOVDreg x)
  4929  	for {
  4930  		x := v_0
  4931  		if x.Op != OpRISCV64MOVBUload {
  4932  			break
  4933  		}
  4934  		v.reset(OpRISCV64MOVDreg)
  4935  		v.AddArg(x)
  4936  		return true
  4937  	}
  4938  	// match: (MOVWUreg x:(MOVHUload _ _))
  4939  	// result: (MOVDreg x)
  4940  	for {
  4941  		x := v_0
  4942  		if x.Op != OpRISCV64MOVHUload {
  4943  			break
  4944  		}
  4945  		v.reset(OpRISCV64MOVDreg)
  4946  		v.AddArg(x)
  4947  		return true
  4948  	}
  4949  	// match: (MOVWUreg x:(MOVWUload _ _))
  4950  	// result: (MOVDreg x)
  4951  	for {
  4952  		x := v_0
  4953  		if x.Op != OpRISCV64MOVWUload {
  4954  			break
  4955  		}
  4956  		v.reset(OpRISCV64MOVDreg)
  4957  		v.AddArg(x)
  4958  		return true
  4959  	}
  4960  	// match: (MOVWUreg x:(MOVBUreg _))
  4961  	// result: (MOVDreg x)
  4962  	for {
  4963  		x := v_0
  4964  		if x.Op != OpRISCV64MOVBUreg {
  4965  			break
  4966  		}
  4967  		v.reset(OpRISCV64MOVDreg)
  4968  		v.AddArg(x)
  4969  		return true
  4970  	}
  4971  	// match: (MOVWUreg x:(MOVHUreg _))
  4972  	// result: (MOVDreg x)
  4973  	for {
  4974  		x := v_0
  4975  		if x.Op != OpRISCV64MOVHUreg {
  4976  			break
  4977  		}
  4978  		v.reset(OpRISCV64MOVDreg)
  4979  		v.AddArg(x)
  4980  		return true
  4981  	}
  4982  	// match: (MOVWUreg x:(MOVWUreg _))
  4983  	// result: (MOVDreg x)
  4984  	for {
  4985  		x := v_0
  4986  		if x.Op != OpRISCV64MOVWUreg {
  4987  			break
  4988  		}
  4989  		v.reset(OpRISCV64MOVDreg)
  4990  		v.AddArg(x)
  4991  		return true
  4992  	}
  4993  	// match: (MOVWUreg <t> x:(MOVWload [off] {sym} ptr mem))
  4994  	// cond: x.Uses == 1 && clobber(x)
  4995  	// result: @x.Block (MOVWUload <t> [off] {sym} ptr mem)
  4996  	for {
  4997  		t := v.Type
  4998  		x := v_0
  4999  		if x.Op != OpRISCV64MOVWload {
  5000  			break
  5001  		}
  5002  		off := auxIntToInt32(x.AuxInt)
  5003  		sym := auxToSym(x.Aux)
  5004  		mem := x.Args[1]
  5005  		ptr := x.Args[0]
  5006  		if !(x.Uses == 1 && clobber(x)) {
  5007  			break
  5008  		}
  5009  		b = x.Block
  5010  		v0 := b.NewValue0(x.Pos, OpRISCV64MOVWUload, t)
  5011  		v.copyOf(v0)
  5012  		v0.AuxInt = int32ToAuxInt(off)
  5013  		v0.Aux = symToAux(sym)
  5014  		v0.AddArg2(ptr, mem)
  5015  		return true
  5016  	}
  5017  	return false
  5018  }
  5019  func rewriteValueRISCV64_OpRISCV64MOVWload(v *Value) bool {
  5020  	v_1 := v.Args[1]
  5021  	v_0 := v.Args[0]
  5022  	// match: (MOVWload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
  5023  	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
  5024  	// result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} base mem)
  5025  	for {
  5026  		off1 := auxIntToInt32(v.AuxInt)
  5027  		sym1 := auxToSym(v.Aux)
  5028  		if v_0.Op != OpRISCV64MOVaddr {
  5029  			break
  5030  		}
  5031  		off2 := auxIntToInt32(v_0.AuxInt)
  5032  		sym2 := auxToSym(v_0.Aux)
  5033  		base := v_0.Args[0]
  5034  		mem := v_1
  5035  		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
  5036  			break
  5037  		}
  5038  		v.reset(OpRISCV64MOVWload)
  5039  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5040  		v.Aux = symToAux(mergeSym(sym1, sym2))
  5041  		v.AddArg2(base, mem)
  5042  		return true
  5043  	}
  5044  	// match: (MOVWload [off1] {sym} (ADDI [off2] base) mem)
  5045  	// cond: is32Bit(int64(off1)+off2)
  5046  	// result: (MOVWload [off1+int32(off2)] {sym} base mem)
  5047  	for {
  5048  		off1 := auxIntToInt32(v.AuxInt)
  5049  		sym := auxToSym(v.Aux)
  5050  		if v_0.Op != OpRISCV64ADDI {
  5051  			break
  5052  		}
  5053  		off2 := auxIntToInt64(v_0.AuxInt)
  5054  		base := v_0.Args[0]
  5055  		mem := v_1
  5056  		if !(is32Bit(int64(off1) + off2)) {
  5057  			break
  5058  		}
  5059  		v.reset(OpRISCV64MOVWload)
  5060  		v.AuxInt = int32ToAuxInt(off1 + int32(off2))
  5061  		v.Aux = symToAux(sym)
  5062  		v.AddArg2(base, mem)
  5063  		return true
  5064  	}
  5065  	return false
  5066  }
  5067  func rewriteValueRISCV64_OpRISCV64MOVWreg(v *Value) bool {
  5068  	v_0 := v.Args[0]
  5069  	b := v.Block
  5070  	// match: (MOVWreg x:(ANDI [c] y))
  5071  	// cond: c >= 0 && int64(int32(c)) == c
  5072  	// result: x
  5073  	for {
  5074  		x := v_0
  5075  		if x.Op != OpRISCV64ANDI {
  5076  			break
  5077  		}
  5078  		c := auxIntToInt64(x.AuxInt)
  5079  		if !(c >= 0 && int64(int32(c)) == c) {
  5080  			break
  5081  		}
  5082  		v.copyOf(x)
  5083  		return true
  5084  	}
  5085  	// match: (MOVWreg (MOVDconst [c]))
  5086  	// result: (MOVDconst [int64(int32(c))])
  5087  	for {
  5088  		if v_0.Op != OpRISCV64MOVDconst {
  5089  			break
  5090  		}
  5091  		c := auxIntToInt64(v_0.AuxInt)
  5092  		v.reset(OpRISCV64MOVDconst)
  5093  		v.AuxInt = int64ToAuxInt(int64(int32(c)))
  5094  		return true
  5095  	}
  5096  	// match: (MOVWreg x:(MOVBload _ _))
  5097  	// result: (MOVDreg x)
  5098  	for {
  5099  		x := v_0
  5100  		if x.Op != OpRISCV64MOVBload {
  5101  			break
  5102  		}
  5103  		v.reset(OpRISCV64MOVDreg)
  5104  		v.AddArg(x)
  5105  		return true
  5106  	}
  5107  	// match: (MOVWreg x:(MOVBUload _ _))
  5108  	// result: (MOVDreg x)
  5109  	for {
  5110  		x := v_0
  5111  		if x.Op != OpRISCV64MOVBUload {
  5112  			break
  5113  		}
  5114  		v.reset(OpRISCV64MOVDreg)
  5115  		v.AddArg(x)
  5116  		return true
  5117  	}
  5118  	// match: (MOVWreg x:(MOVHload _ _))
  5119  	// result: (MOVDreg x)
  5120  	for {
  5121  		x := v_0
  5122  		if x.Op != OpRISCV64MOVHload {
  5123  			break
  5124  		}
  5125  		v.reset(OpRISCV64MOVDreg)
  5126  		v.AddArg(x)
  5127  		return true
  5128  	}
  5129  	// match: (MOVWreg x:(MOVHUload _ _))
  5130  	// result: (MOVDreg x)
  5131  	for {
  5132  		x := v_0
  5133  		if x.Op != OpRISCV64MOVHUload {
  5134  			break
  5135  		}
  5136  		v.reset(OpRISCV64MOVDreg)
  5137  		v.AddArg(x)
  5138  		return true
  5139  	}
  5140  	// match: (MOVWreg x:(MOVWload _ _))
  5141  	// result: (MOVDreg x)
  5142  	for {
  5143  		x := v_0
  5144  		if x.Op != OpRISCV64MOVWload {
  5145  			break
  5146  		}
  5147  		v.reset(OpRISCV64MOVDreg)
  5148  		v.AddArg(x)
  5149  		return true
  5150  	}
  5151  	// match: (MOVWreg x:(ADDIW _))
  5152  	// result: (MOVDreg x)
  5153  	for {
  5154  		x := v_0
  5155  		if x.Op != OpRISCV64ADDIW {
  5156  			break
  5157  		}
  5158  		v.reset(OpRISCV64MOVDreg)
  5159  		v.AddArg(x)
  5160  		return true
  5161  	}
  5162  	// match: (MOVWreg x:(SUBW _ _))
  5163  	// result: (MOVDreg x)
  5164  	for {
  5165  		x := v_0
  5166  		if x.Op != OpRISCV64SUBW {
  5167  			break
  5168  		}
  5169  		v.reset(OpRISCV64MOVDreg)
  5170  		v.AddArg(x)
  5171  		return true
  5172  	}
  5173  	// match: (MOVWreg x:(NEGW _))
  5174  	// result: (MOVDreg x)
  5175  	for {
  5176  		x := v_0
  5177  		if x.Op != OpRISCV64NEGW {
  5178  			break
  5179  		}
  5180  		v.reset(OpRISCV64MOVDreg)
  5181  		v.AddArg(x)
  5182  		return true
  5183  	}
  5184  	// match: (MOVWreg x:(MULW _ _))
  5185  	// result: (MOVDreg x)
  5186  	for {
  5187  		x := v_0
  5188  		if x.Op != OpRISCV64MULW {
  5189  			break
  5190  		}
  5191  		v.reset(OpRISCV64MOVDreg)
  5192  		v.AddArg(x)
  5193  		return true
  5194  	}
  5195  	// match: (MOVWreg x:(DIVW _ _))
  5196  	// result: (MOVDreg x)
  5197  	for {
  5198  		x := v_0
  5199  		if x.Op != OpRISCV64DIVW {
  5200  			break
  5201  		}
  5202  		v.reset(OpRISCV64MOVDreg)
  5203  		v.AddArg(x)
  5204  		return true
  5205  	}
  5206  	// match: (MOVWreg x:(DIVUW _ _))
  5207  	// result: (MOVDreg x)
  5208  	for {
  5209  		x := v_0
  5210  		if x.Op != OpRISCV64DIVUW {
  5211  			break
  5212  		}
  5213  		v.reset(OpRISCV64MOVDreg)
  5214  		v.AddArg(x)
  5215  		return true
  5216  	}
  5217  	// match: (MOVWreg x:(REMW _ _))
  5218  	// result: (MOVDreg x)
  5219  	for {
  5220  		x := v_0
  5221  		if x.Op != OpRISCV64REMW {
  5222  			break
  5223  		}
  5224  		v.reset(OpRISCV64MOVDreg)
  5225  		v.AddArg(x)
  5226  		return true
  5227  	}
  5228  	// match: (MOVWreg x:(REMUW _ _))
  5229  	// result: (MOVDreg x)
  5230  	for {
  5231  		x := v_0
  5232  		if x.Op != OpRISCV64REMUW {
  5233  			break
  5234  		}
  5235  		v.reset(OpRISCV64MOVDreg)
  5236  		v.AddArg(x)
  5237  		return true
  5238  	}
  5239  	// match: (MOVWreg x:(MOVBreg _))
  5240  	// result: (MOVDreg x)
  5241  	for {
  5242  		x := v_0
  5243  		if x.Op != OpRISCV64MOVBreg {
  5244  			break
  5245  		}
  5246  		v.reset(OpRISCV64MOVDreg)
  5247  		v.AddArg(x)
  5248  		return true
  5249  	}
  5250  	// match: (MOVWreg x:(MOVBUreg _))
  5251  	// result: (MOVDreg x)
  5252  	for {
  5253  		x := v_0
  5254  		if x.Op != OpRISCV64MOVBUreg {
  5255  			break
  5256  		}
  5257  		v.reset(OpRISCV64MOVDreg)
  5258  		v.AddArg(x)
  5259  		return true
  5260  	}
  5261  	// match: (MOVWreg x:(MOVHreg _))
  5262  	// result: (MOVDreg x)
  5263  	for {
  5264  		x := v_0
  5265  		if x.Op != OpRISCV64MOVHreg {
  5266  			break
  5267  		}
  5268  		v.reset(OpRISCV64MOVDreg)
  5269  		v.AddArg(x)
  5270  		return true
  5271  	}
  5272  	// match: (MOVWreg x:(MOVWreg _))
  5273  	// result: (MOVDreg x)
  5274  	for {
  5275  		x := v_0
  5276  		if x.Op != OpRISCV64MOVWreg {
  5277  			break
  5278  		}
  5279  		v.reset(OpRISCV64MOVDreg)
  5280  		v.AddArg(x)
  5281  		return true
  5282  	}
  5283  	// match: (MOVWreg <t> x:(MOVWUload [off] {sym} ptr mem))
  5284  	// cond: x.Uses == 1 && clobber(x)
  5285  	// result: @x.Block (MOVWload <t> [off] {sym} ptr mem)
  5286  	for {
  5287  		t := v.Type
  5288  		x := v_0
  5289  		if x.Op != OpRISCV64MOVWUload {
  5290  			break
  5291  		}
  5292  		off := auxIntToInt32(x.AuxInt)
  5293  		sym := auxToSym(x.Aux)
  5294  		mem := x.Args[1]
  5295  		ptr := x.Args[0]
  5296  		if !(x.Uses == 1 && clobber(x)) {
  5297  			break
  5298  		}
  5299  		b = x.Block
  5300  		v0 := b.NewValue0(x.Pos, OpRISCV64MOVWload, t)
  5301  		v.copyOf(v0)
  5302  		v0.AuxInt = int32ToAuxInt(off)
  5303  		v0.Aux = symToAux(sym)
  5304  		v0.AddArg2(ptr, mem)
  5305  		return true
  5306  	}
  5307  	return false
  5308  }
  5309  func rewriteValueRISCV64_OpRISCV64MOVWstore(v *Value) bool {
  5310  	v_2 := v.Args[2]
  5311  	v_1 := v.Args[1]
  5312  	v_0 := v.Args[0]
  5313  	// match: (MOVWstore [off1] {sym1} (MOVaddr [off2] {sym2} base) val mem)
  5314  	// cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
  5315  	// result: (MOVWstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
  5316  	for {
  5317  		off1 := auxIntToInt32(v.AuxInt)
  5318  		sym1 := auxToSym(v.Aux)
  5319  		if v_0.Op != OpRISCV64MOVaddr {
  5320  			break
  5321  		}
  5322  		off2 := auxIntToInt32(v_0.AuxInt)
  5323  		sym2 := auxToSym(v_0.Aux)
  5324  		base := v_0.Args[0]
  5325  		val := v_1
  5326  		mem := v_2
  5327  		if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
  5328  			break
  5329  		}
  5330  		v.reset(OpRISCV64MOVWstore)
  5331  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5332  		v.Aux = symToAux(mergeSym(sym1, sym2))
  5333  		v.AddArg3(base, val, mem)
  5334  		return true
  5335  	}
  5336  	// match: (MOVWstore [off1] {sym} (ADDI [off2] base) val mem)
  5337  	// cond: is32Bit(int64(off1)+off2)
  5338  	// result: (MOVWstore [off1+int32(off2)] {sym} base val mem)
  5339  	for {
  5340  		off1 := auxIntToInt32(v.AuxInt)
  5341  		sym := auxToSym(v.Aux)
  5342  		if v_0.Op != OpRISCV64ADDI {
  5343  			break
  5344  		}
  5345  		off2 := auxIntToInt64(v_0.AuxInt)
  5346  		base := v_0.Args[0]
  5347  		val := v_1
  5348  		mem := v_2
  5349  		if !(is32Bit(int64(off1) + off2)) {
  5350  			break
  5351  		}
  5352  		v.reset(OpRISCV64MOVWstore)
  5353  		v.AuxInt = int32ToAuxInt(off1 + int32(off2))
  5354  		v.Aux = symToAux(sym)
  5355  		v.AddArg3(base, val, mem)
  5356  		return true
  5357  	}
  5358  	// match: (MOVWstore [off] {sym} ptr (MOVDconst [0]) mem)
  5359  	// result: (MOVWstorezero [off] {sym} ptr mem)
  5360  	for {
  5361  		off := auxIntToInt32(v.AuxInt)
  5362  		sym := auxToSym(v.Aux)
  5363  		ptr := v_0
  5364  		if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
  5365  			break
  5366  		}
  5367  		mem := v_2
  5368  		v.reset(OpRISCV64MOVWstorezero)
  5369  		v.AuxInt = int32ToAuxInt(off)
  5370  		v.Aux = symToAux(sym)
  5371  		v.AddArg2(ptr, mem)
  5372  		return true
  5373  	}
  5374  	// match: (MOVWstore [off] {sym} ptr (MOVWreg x) mem)
  5375  	// result: (MOVWstore [off] {sym} ptr x mem)
  5376  	for {
  5377  		off := auxIntToInt32(v.AuxInt)
  5378  		sym := auxToSym(v.Aux)
  5379  		ptr := v_0
  5380  		if v_1.Op != OpRISCV64MOVWreg {
  5381  			break
  5382  		}
  5383  		x := v_1.Args[0]
  5384  		mem := v_2
  5385  		v.reset(OpRISCV64MOVWstore)
  5386  		v.AuxInt = int32ToAuxInt(off)
  5387  		v.Aux = symToAux(sym)
  5388  		v.AddArg3(ptr, x, mem)
  5389  		return true
  5390  	}
  5391  	// match: (MOVWstore [off] {sym} ptr (MOVWUreg x) mem)
  5392  	// result: (MOVWstore [off] {sym} ptr x mem)
  5393  	for {
  5394  		off := auxIntToInt32(v.AuxInt)
  5395  		sym := auxToSym(v.Aux)
  5396  		ptr := v_0
  5397  		if v_1.Op != OpRISCV64MOVWUreg {
  5398  			break
  5399  		}
  5400  		x := v_1.Args[0]
  5401  		mem := v_2
  5402  		v.reset(OpRISCV64MOVWstore)
  5403  		v.AuxInt = int32ToAuxInt(off)
  5404  		v.Aux = symToAux(sym)
  5405  		v.AddArg3(ptr, x, mem)
  5406  		return true
  5407  	}
  5408  	return false
  5409  }
  5410  func rewriteValueRISCV64_OpRISCV64MOVWstorezero(v *Value) bool {
  5411  	v_1 := v.Args[1]
  5412  	v_0 := v.Args[0]
  5413  	// match: (MOVWstorezero [off1] {sym1} (MOVaddr [off2] {sym2} ptr) mem)
  5414  	// cond: canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2))
  5415  	// result: (MOVWstorezero [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
  5416  	for {
  5417  		off1 := auxIntToInt32(v.AuxInt)
  5418  		sym1 := auxToSym(v.Aux)
  5419  		if v_0.Op != OpRISCV64MOVaddr {
  5420  			break
  5421  		}
  5422  		off2 := auxIntToInt32(v_0.AuxInt)
  5423  		sym2 := auxToSym(v_0.Aux)
  5424  		ptr := v_0.Args[0]
  5425  		mem := v_1
  5426  		if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
  5427  			break
  5428  		}
  5429  		v.reset(OpRISCV64MOVWstorezero)
  5430  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5431  		v.Aux = symToAux(mergeSym(sym1, sym2))
  5432  		v.AddArg2(ptr, mem)
  5433  		return true
  5434  	}
  5435  	// match: (MOVWstorezero [off1] {sym} (ADDI [off2] ptr) mem)
  5436  	// cond: is32Bit(int64(off1)+off2)
  5437  	// result: (MOVWstorezero [off1+int32(off2)] {sym} ptr mem)
  5438  	for {
  5439  		off1 := auxIntToInt32(v.AuxInt)
  5440  		sym := auxToSym(v.Aux)
  5441  		if v_0.Op != OpRISCV64ADDI {
  5442  			break
  5443  		}
  5444  		off2 := auxIntToInt64(v_0.AuxInt)
  5445  		ptr := v_0.Args[0]
  5446  		mem := v_1
  5447  		if !(is32Bit(int64(off1) + off2)) {
  5448  			break
  5449  		}
  5450  		v.reset(OpRISCV64MOVWstorezero)
  5451  		v.AuxInt = int32ToAuxInt(off1 + int32(off2))
  5452  		v.Aux = symToAux(sym)
  5453  		v.AddArg2(ptr, mem)
  5454  		return true
  5455  	}
  5456  	return false
  5457  }
  5458  func rewriteValueRISCV64_OpRISCV64NEG(v *Value) bool {
  5459  	v_0 := v.Args[0]
  5460  	b := v.Block
  5461  	// match: (NEG (SUB x y))
  5462  	// result: (SUB y x)
  5463  	for {
  5464  		if v_0.Op != OpRISCV64SUB {
  5465  			break
  5466  		}
  5467  		y := v_0.Args[1]
  5468  		x := v_0.Args[0]
  5469  		v.reset(OpRISCV64SUB)
  5470  		v.AddArg2(y, x)
  5471  		return true
  5472  	}
  5473  	// match: (NEG <t> s:(ADDI [val] (SUB x y)))
  5474  	// cond: s.Uses == 1 && is32Bit(-val)
  5475  	// result: (ADDI [-val] (SUB <t> y x))
  5476  	for {
  5477  		t := v.Type
  5478  		s := v_0
  5479  		if s.Op != OpRISCV64ADDI {
  5480  			break
  5481  		}
  5482  		val := auxIntToInt64(s.AuxInt)
  5483  		s_0 := s.Args[0]
  5484  		if s_0.Op != OpRISCV64SUB {
  5485  			break
  5486  		}
  5487  		y := s_0.Args[1]
  5488  		x := s_0.Args[0]
  5489  		if !(s.Uses == 1 && is32Bit(-val)) {
  5490  			break
  5491  		}
  5492  		v.reset(OpRISCV64ADDI)
  5493  		v.AuxInt = int64ToAuxInt(-val)
  5494  		v0 := b.NewValue0(v.Pos, OpRISCV64SUB, t)
  5495  		v0.AddArg2(y, x)
  5496  		v.AddArg(v0)
  5497  		return true
  5498  	}
  5499  	// match: (NEG (NEG x))
  5500  	// result: x
  5501  	for {
  5502  		if v_0.Op != OpRISCV64NEG {
  5503  			break
  5504  		}
  5505  		x := v_0.Args[0]
  5506  		v.copyOf(x)
  5507  		return true
  5508  	}
  5509  	// match: (NEG (MOVDconst [x]))
  5510  	// result: (MOVDconst [-x])
  5511  	for {
  5512  		if v_0.Op != OpRISCV64MOVDconst {
  5513  			break
  5514  		}
  5515  		x := auxIntToInt64(v_0.AuxInt)
  5516  		v.reset(OpRISCV64MOVDconst)
  5517  		v.AuxInt = int64ToAuxInt(-x)
  5518  		return true
  5519  	}
  5520  	return false
  5521  }
  5522  func rewriteValueRISCV64_OpRISCV64NEGW(v *Value) bool {
  5523  	v_0 := v.Args[0]
  5524  	// match: (NEGW (MOVDconst [x]))
  5525  	// result: (MOVDconst [int64(int32(-x))])
  5526  	for {
  5527  		if v_0.Op != OpRISCV64MOVDconst {
  5528  			break
  5529  		}
  5530  		x := auxIntToInt64(v_0.AuxInt)
  5531  		v.reset(OpRISCV64MOVDconst)
  5532  		v.AuxInt = int64ToAuxInt(int64(int32(-x)))
  5533  		return true
  5534  	}
  5535  	return false
  5536  }
  5537  func rewriteValueRISCV64_OpRISCV64OR(v *Value) bool {
  5538  	v_1 := v.Args[1]
  5539  	v_0 := v.Args[0]
  5540  	// match: (OR (MOVDconst [val]) x)
  5541  	// cond: is32Bit(val)
  5542  	// result: (ORI [val] x)
  5543  	for {
  5544  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  5545  			if v_0.Op != OpRISCV64MOVDconst {
  5546  				continue
  5547  			}
  5548  			val := auxIntToInt64(v_0.AuxInt)
  5549  			x := v_1
  5550  			if !(is32Bit(val)) {
  5551  				continue
  5552  			}
  5553  			v.reset(OpRISCV64ORI)
  5554  			v.AuxInt = int64ToAuxInt(val)
  5555  			v.AddArg(x)
  5556  			return true
  5557  		}
  5558  		break
  5559  	}
  5560  	return false
  5561  }
  5562  func rewriteValueRISCV64_OpRISCV64ORI(v *Value) bool {
  5563  	v_0 := v.Args[0]
  5564  	// match: (ORI [0] x)
  5565  	// result: x
  5566  	for {
  5567  		if auxIntToInt64(v.AuxInt) != 0 {
  5568  			break
  5569  		}
  5570  		x := v_0
  5571  		v.copyOf(x)
  5572  		return true
  5573  	}
  5574  	// match: (ORI [-1] x)
  5575  	// result: (MOVDconst [-1])
  5576  	for {
  5577  		if auxIntToInt64(v.AuxInt) != -1 {
  5578  			break
  5579  		}
  5580  		v.reset(OpRISCV64MOVDconst)
  5581  		v.AuxInt = int64ToAuxInt(-1)
  5582  		return true
  5583  	}
  5584  	// match: (ORI [x] (MOVDconst [y]))
  5585  	// result: (MOVDconst [x | y])
  5586  	for {
  5587  		x := auxIntToInt64(v.AuxInt)
  5588  		if v_0.Op != OpRISCV64MOVDconst {
  5589  			break
  5590  		}
  5591  		y := auxIntToInt64(v_0.AuxInt)
  5592  		v.reset(OpRISCV64MOVDconst)
  5593  		v.AuxInt = int64ToAuxInt(x | y)
  5594  		return true
  5595  	}
  5596  	// match: (ORI [x] (ORI [y] z))
  5597  	// result: (ORI [x | y] z)
  5598  	for {
  5599  		x := auxIntToInt64(v.AuxInt)
  5600  		if v_0.Op != OpRISCV64ORI {
  5601  			break
  5602  		}
  5603  		y := auxIntToInt64(v_0.AuxInt)
  5604  		z := v_0.Args[0]
  5605  		v.reset(OpRISCV64ORI)
  5606  		v.AuxInt = int64ToAuxInt(x | y)
  5607  		v.AddArg(z)
  5608  		return true
  5609  	}
  5610  	return false
  5611  }
  5612  func rewriteValueRISCV64_OpRISCV64SEQZ(v *Value) bool {
  5613  	v_0 := v.Args[0]
  5614  	// match: (SEQZ (NEG x))
  5615  	// result: (SEQZ x)
  5616  	for {
  5617  		if v_0.Op != OpRISCV64NEG {
  5618  			break
  5619  		}
  5620  		x := v_0.Args[0]
  5621  		v.reset(OpRISCV64SEQZ)
  5622  		v.AddArg(x)
  5623  		return true
  5624  	}
  5625  	// match: (SEQZ (SEQZ x))
  5626  	// result: (SNEZ x)
  5627  	for {
  5628  		if v_0.Op != OpRISCV64SEQZ {
  5629  			break
  5630  		}
  5631  		x := v_0.Args[0]
  5632  		v.reset(OpRISCV64SNEZ)
  5633  		v.AddArg(x)
  5634  		return true
  5635  	}
  5636  	// match: (SEQZ (SNEZ x))
  5637  	// result: (SEQZ x)
  5638  	for {
  5639  		if v_0.Op != OpRISCV64SNEZ {
  5640  			break
  5641  		}
  5642  		x := v_0.Args[0]
  5643  		v.reset(OpRISCV64SEQZ)
  5644  		v.AddArg(x)
  5645  		return true
  5646  	}
  5647  	return false
  5648  }
  5649  func rewriteValueRISCV64_OpRISCV64SLL(v *Value) bool {
  5650  	v_1 := v.Args[1]
  5651  	v_0 := v.Args[0]
  5652  	// match: (SLL x (MOVDconst [val]))
  5653  	// result: (SLLI [int64(val&63)] x)
  5654  	for {
  5655  		x := v_0
  5656  		if v_1.Op != OpRISCV64MOVDconst {
  5657  			break
  5658  		}
  5659  		val := auxIntToInt64(v_1.AuxInt)
  5660  		v.reset(OpRISCV64SLLI)
  5661  		v.AuxInt = int64ToAuxInt(int64(val & 63))
  5662  		v.AddArg(x)
  5663  		return true
  5664  	}
  5665  	return false
  5666  }
  5667  func rewriteValueRISCV64_OpRISCV64SLLI(v *Value) bool {
  5668  	v_0 := v.Args[0]
  5669  	// match: (SLLI [x] (MOVDconst [y]))
  5670  	// cond: is32Bit(y << uint32(x))
  5671  	// result: (MOVDconst [y << uint32(x)])
  5672  	for {
  5673  		x := auxIntToInt64(v.AuxInt)
  5674  		if v_0.Op != OpRISCV64MOVDconst {
  5675  			break
  5676  		}
  5677  		y := auxIntToInt64(v_0.AuxInt)
  5678  		if !(is32Bit(y << uint32(x))) {
  5679  			break
  5680  		}
  5681  		v.reset(OpRISCV64MOVDconst)
  5682  		v.AuxInt = int64ToAuxInt(y << uint32(x))
  5683  		return true
  5684  	}
  5685  	return false
  5686  }
  5687  func rewriteValueRISCV64_OpRISCV64SLT(v *Value) bool {
  5688  	v_1 := v.Args[1]
  5689  	v_0 := v.Args[0]
  5690  	// match: (SLT x (MOVDconst [val]))
  5691  	// cond: val >= -2048 && val <= 2047
  5692  	// result: (SLTI [val] x)
  5693  	for {
  5694  		x := v_0
  5695  		if v_1.Op != OpRISCV64MOVDconst {
  5696  			break
  5697  		}
  5698  		val := auxIntToInt64(v_1.AuxInt)
  5699  		if !(val >= -2048 && val <= 2047) {
  5700  			break
  5701  		}
  5702  		v.reset(OpRISCV64SLTI)
  5703  		v.AuxInt = int64ToAuxInt(val)
  5704  		v.AddArg(x)
  5705  		return true
  5706  	}
  5707  	// match: (SLT x x)
  5708  	// result: (MOVDconst [0])
  5709  	for {
  5710  		x := v_0
  5711  		if x != v_1 {
  5712  			break
  5713  		}
  5714  		v.reset(OpRISCV64MOVDconst)
  5715  		v.AuxInt = int64ToAuxInt(0)
  5716  		return true
  5717  	}
  5718  	return false
  5719  }
  5720  func rewriteValueRISCV64_OpRISCV64SLTI(v *Value) bool {
  5721  	v_0 := v.Args[0]
  5722  	// match: (SLTI [x] (MOVDconst [y]))
  5723  	// result: (MOVDconst [b2i(int64(y) < int64(x))])
  5724  	for {
  5725  		x := auxIntToInt64(v.AuxInt)
  5726  		if v_0.Op != OpRISCV64MOVDconst {
  5727  			break
  5728  		}
  5729  		y := auxIntToInt64(v_0.AuxInt)
  5730  		v.reset(OpRISCV64MOVDconst)
  5731  		v.AuxInt = int64ToAuxInt(b2i(int64(y) < int64(x)))
  5732  		return true
  5733  	}
  5734  	// match: (SLTI [x] (ANDI [y] _))
  5735  	// cond: y >= 0 && int64(y) < int64(x)
  5736  	// result: (MOVDconst [1])
  5737  	for {
  5738  		x := auxIntToInt64(v.AuxInt)
  5739  		if v_0.Op != OpRISCV64ANDI {
  5740  			break
  5741  		}
  5742  		y := auxIntToInt64(v_0.AuxInt)
  5743  		if !(y >= 0 && int64(y) < int64(x)) {
  5744  			break
  5745  		}
  5746  		v.reset(OpRISCV64MOVDconst)
  5747  		v.AuxInt = int64ToAuxInt(1)
  5748  		return true
  5749  	}
  5750  	// match: (SLTI [x] (ORI [y] _))
  5751  	// cond: y >= 0 && int64(y) >= int64(x)
  5752  	// result: (MOVDconst [0])
  5753  	for {
  5754  		x := auxIntToInt64(v.AuxInt)
  5755  		if v_0.Op != OpRISCV64ORI {
  5756  			break
  5757  		}
  5758  		y := auxIntToInt64(v_0.AuxInt)
  5759  		if !(y >= 0 && int64(y) >= int64(x)) {
  5760  			break
  5761  		}
  5762  		v.reset(OpRISCV64MOVDconst)
  5763  		v.AuxInt = int64ToAuxInt(0)
  5764  		return true
  5765  	}
  5766  	return false
  5767  }
  5768  func rewriteValueRISCV64_OpRISCV64SLTIU(v *Value) bool {
  5769  	v_0 := v.Args[0]
  5770  	// match: (SLTIU [x] (MOVDconst [y]))
  5771  	// result: (MOVDconst [b2i(uint64(y) < uint64(x))])
  5772  	for {
  5773  		x := auxIntToInt64(v.AuxInt)
  5774  		if v_0.Op != OpRISCV64MOVDconst {
  5775  			break
  5776  		}
  5777  		y := auxIntToInt64(v_0.AuxInt)
  5778  		v.reset(OpRISCV64MOVDconst)
  5779  		v.AuxInt = int64ToAuxInt(b2i(uint64(y) < uint64(x)))
  5780  		return true
  5781  	}
  5782  	// match: (SLTIU [x] (ANDI [y] _))
  5783  	// cond: y >= 0 && uint64(y) < uint64(x)
  5784  	// result: (MOVDconst [1])
  5785  	for {
  5786  		x := auxIntToInt64(v.AuxInt)
  5787  		if v_0.Op != OpRISCV64ANDI {
  5788  			break
  5789  		}
  5790  		y := auxIntToInt64(v_0.AuxInt)
  5791  		if !(y >= 0 && uint64(y) < uint64(x)) {
  5792  			break
  5793  		}
  5794  		v.reset(OpRISCV64MOVDconst)
  5795  		v.AuxInt = int64ToAuxInt(1)
  5796  		return true
  5797  	}
  5798  	// match: (SLTIU [x] (ORI [y] _))
  5799  	// cond: y >= 0 && uint64(y) >= uint64(x)
  5800  	// result: (MOVDconst [0])
  5801  	for {
  5802  		x := auxIntToInt64(v.AuxInt)
  5803  		if v_0.Op != OpRISCV64ORI {
  5804  			break
  5805  		}
  5806  		y := auxIntToInt64(v_0.AuxInt)
  5807  		if !(y >= 0 && uint64(y) >= uint64(x)) {
  5808  			break
  5809  		}
  5810  		v.reset(OpRISCV64MOVDconst)
  5811  		v.AuxInt = int64ToAuxInt(0)
  5812  		return true
  5813  	}
  5814  	return false
  5815  }
  5816  func rewriteValueRISCV64_OpRISCV64SLTU(v *Value) bool {
  5817  	v_1 := v.Args[1]
  5818  	v_0 := v.Args[0]
  5819  	// match: (SLTU x (MOVDconst [val]))
  5820  	// cond: val >= -2048 && val <= 2047
  5821  	// result: (SLTIU [val] x)
  5822  	for {
  5823  		x := v_0
  5824  		if v_1.Op != OpRISCV64MOVDconst {
  5825  			break
  5826  		}
  5827  		val := auxIntToInt64(v_1.AuxInt)
  5828  		if !(val >= -2048 && val <= 2047) {
  5829  			break
  5830  		}
  5831  		v.reset(OpRISCV64SLTIU)
  5832  		v.AuxInt = int64ToAuxInt(val)
  5833  		v.AddArg(x)
  5834  		return true
  5835  	}
  5836  	// match: (SLTU x x)
  5837  	// result: (MOVDconst [0])
  5838  	for {
  5839  		x := v_0
  5840  		if x != v_1 {
  5841  			break
  5842  		}
  5843  		v.reset(OpRISCV64MOVDconst)
  5844  		v.AuxInt = int64ToAuxInt(0)
  5845  		return true
  5846  	}
  5847  	return false
  5848  }
  5849  func rewriteValueRISCV64_OpRISCV64SNEZ(v *Value) bool {
  5850  	v_0 := v.Args[0]
  5851  	// match: (SNEZ (NEG x))
  5852  	// result: (SNEZ x)
  5853  	for {
  5854  		if v_0.Op != OpRISCV64NEG {
  5855  			break
  5856  		}
  5857  		x := v_0.Args[0]
  5858  		v.reset(OpRISCV64SNEZ)
  5859  		v.AddArg(x)
  5860  		return true
  5861  	}
  5862  	// match: (SNEZ (SEQZ x))
  5863  	// result: (SEQZ x)
  5864  	for {
  5865  		if v_0.Op != OpRISCV64SEQZ {
  5866  			break
  5867  		}
  5868  		x := v_0.Args[0]
  5869  		v.reset(OpRISCV64SEQZ)
  5870  		v.AddArg(x)
  5871  		return true
  5872  	}
  5873  	// match: (SNEZ (SNEZ x))
  5874  	// result: (SNEZ x)
  5875  	for {
  5876  		if v_0.Op != OpRISCV64SNEZ {
  5877  			break
  5878  		}
  5879  		x := v_0.Args[0]
  5880  		v.reset(OpRISCV64SNEZ)
  5881  		v.AddArg(x)
  5882  		return true
  5883  	}
  5884  	return false
  5885  }
  5886  func rewriteValueRISCV64_OpRISCV64SRA(v *Value) bool {
  5887  	v_1 := v.Args[1]
  5888  	v_0 := v.Args[0]
  5889  	// match: (SRA x (MOVDconst [val]))
  5890  	// result: (SRAI [int64(val&63)] x)
  5891  	for {
  5892  		x := v_0
  5893  		if v_1.Op != OpRISCV64MOVDconst {
  5894  			break
  5895  		}
  5896  		val := auxIntToInt64(v_1.AuxInt)
  5897  		v.reset(OpRISCV64SRAI)
  5898  		v.AuxInt = int64ToAuxInt(int64(val & 63))
  5899  		v.AddArg(x)
  5900  		return true
  5901  	}
  5902  	return false
  5903  }
  5904  func rewriteValueRISCV64_OpRISCV64SRAI(v *Value) bool {
  5905  	v_0 := v.Args[0]
  5906  	// match: (SRAI [x] (MOVDconst [y]))
  5907  	// result: (MOVDconst [int64(y) >> uint32(x)])
  5908  	for {
  5909  		x := auxIntToInt64(v.AuxInt)
  5910  		if v_0.Op != OpRISCV64MOVDconst {
  5911  			break
  5912  		}
  5913  		y := auxIntToInt64(v_0.AuxInt)
  5914  		v.reset(OpRISCV64MOVDconst)
  5915  		v.AuxInt = int64ToAuxInt(int64(y) >> uint32(x))
  5916  		return true
  5917  	}
  5918  	return false
  5919  }
  5920  func rewriteValueRISCV64_OpRISCV64SRL(v *Value) bool {
  5921  	v_1 := v.Args[1]
  5922  	v_0 := v.Args[0]
  5923  	// match: (SRL x (MOVDconst [val]))
  5924  	// result: (SRLI [int64(val&63)] x)
  5925  	for {
  5926  		x := v_0
  5927  		if v_1.Op != OpRISCV64MOVDconst {
  5928  			break
  5929  		}
  5930  		val := auxIntToInt64(v_1.AuxInt)
  5931  		v.reset(OpRISCV64SRLI)
  5932  		v.AuxInt = int64ToAuxInt(int64(val & 63))
  5933  		v.AddArg(x)
  5934  		return true
  5935  	}
  5936  	return false
  5937  }
  5938  func rewriteValueRISCV64_OpRISCV64SRLI(v *Value) bool {
  5939  	v_0 := v.Args[0]
  5940  	// match: (SRLI [x] (MOVDconst [y]))
  5941  	// result: (MOVDconst [int64(uint64(y) >> uint32(x))])
  5942  	for {
  5943  		x := auxIntToInt64(v.AuxInt)
  5944  		if v_0.Op != OpRISCV64MOVDconst {
  5945  			break
  5946  		}
  5947  		y := auxIntToInt64(v_0.AuxInt)
  5948  		v.reset(OpRISCV64MOVDconst)
  5949  		v.AuxInt = int64ToAuxInt(int64(uint64(y) >> uint32(x)))
  5950  		return true
  5951  	}
  5952  	return false
  5953  }
  5954  func rewriteValueRISCV64_OpRISCV64SUB(v *Value) bool {
  5955  	v_1 := v.Args[1]
  5956  	v_0 := v.Args[0]
  5957  	b := v.Block
  5958  	// match: (SUB x (MOVDconst [val]))
  5959  	// cond: is32Bit(-val)
  5960  	// result: (ADDI [-val] x)
  5961  	for {
  5962  		x := v_0
  5963  		if v_1.Op != OpRISCV64MOVDconst {
  5964  			break
  5965  		}
  5966  		val := auxIntToInt64(v_1.AuxInt)
  5967  		if !(is32Bit(-val)) {
  5968  			break
  5969  		}
  5970  		v.reset(OpRISCV64ADDI)
  5971  		v.AuxInt = int64ToAuxInt(-val)
  5972  		v.AddArg(x)
  5973  		return true
  5974  	}
  5975  	// match: (SUB <t> (MOVDconst [val]) y)
  5976  	// cond: is32Bit(-val)
  5977  	// result: (NEG (ADDI <t> [-val] y))
  5978  	for {
  5979  		t := v.Type
  5980  		if v_0.Op != OpRISCV64MOVDconst {
  5981  			break
  5982  		}
  5983  		val := auxIntToInt64(v_0.AuxInt)
  5984  		y := v_1
  5985  		if !(is32Bit(-val)) {
  5986  			break
  5987  		}
  5988  		v.reset(OpRISCV64NEG)
  5989  		v0 := b.NewValue0(v.Pos, OpRISCV64ADDI, t)
  5990  		v0.AuxInt = int64ToAuxInt(-val)
  5991  		v0.AddArg(y)
  5992  		v.AddArg(v0)
  5993  		return true
  5994  	}
  5995  	// match: (SUB x (MOVDconst [0]))
  5996  	// result: x
  5997  	for {
  5998  		x := v_0
  5999  		if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
  6000  			break
  6001  		}
  6002  		v.copyOf(x)
  6003  		return true
  6004  	}
  6005  	// match: (SUB (MOVDconst [0]) x)
  6006  	// result: (NEG x)
  6007  	for {
  6008  		if v_0.Op != OpRISCV64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
  6009  			break
  6010  		}
  6011  		x := v_1
  6012  		v.reset(OpRISCV64NEG)
  6013  		v.AddArg(x)
  6014  		return true
  6015  	}
  6016  	return false
  6017  }
  6018  func rewriteValueRISCV64_OpRISCV64SUBW(v *Value) bool {
  6019  	v_1 := v.Args[1]
  6020  	v_0 := v.Args[0]
  6021  	// match: (SUBW x (MOVDconst [0]))
  6022  	// result: (ADDIW [0] x)
  6023  	for {
  6024  		x := v_0
  6025  		if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
  6026  			break
  6027  		}
  6028  		v.reset(OpRISCV64ADDIW)
  6029  		v.AuxInt = int64ToAuxInt(0)
  6030  		v.AddArg(x)
  6031  		return true
  6032  	}
  6033  	// match: (SUBW (MOVDconst [0]) x)
  6034  	// result: (NEGW x)
  6035  	for {
  6036  		if v_0.Op != OpRISCV64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
  6037  			break
  6038  		}
  6039  		x := v_1
  6040  		v.reset(OpRISCV64NEGW)
  6041  		v.AddArg(x)
  6042  		return true
  6043  	}
  6044  	return false
  6045  }
  6046  func rewriteValueRISCV64_OpRISCV64XOR(v *Value) bool {
  6047  	v_1 := v.Args[1]
  6048  	v_0 := v.Args[0]
  6049  	// match: (XOR (MOVDconst [val]) x)
  6050  	// cond: is32Bit(val)
  6051  	// result: (XORI [val] x)
  6052  	for {
  6053  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  6054  			if v_0.Op != OpRISCV64MOVDconst {
  6055  				continue
  6056  			}
  6057  			val := auxIntToInt64(v_0.AuxInt)
  6058  			x := v_1
  6059  			if !(is32Bit(val)) {
  6060  				continue
  6061  			}
  6062  			v.reset(OpRISCV64XORI)
  6063  			v.AuxInt = int64ToAuxInt(val)
  6064  			v.AddArg(x)
  6065  			return true
  6066  		}
  6067  		break
  6068  	}
  6069  	return false
  6070  }
  6071  func rewriteValueRISCV64_OpRotateLeft16(v *Value) bool {
  6072  	v_1 := v.Args[1]
  6073  	v_0 := v.Args[0]
  6074  	b := v.Block
  6075  	typ := &b.Func.Config.Types
  6076  	// match: (RotateLeft16 <t> x (MOVDconst [c]))
  6077  	// result: (Or16 (Lsh16x64 <t> x (MOVDconst [c&15])) (Rsh16Ux64 <t> x (MOVDconst [-c&15])))
  6078  	for {
  6079  		t := v.Type
  6080  		x := v_0
  6081  		if v_1.Op != OpRISCV64MOVDconst {
  6082  			break
  6083  		}
  6084  		c := auxIntToInt64(v_1.AuxInt)
  6085  		v.reset(OpOr16)
  6086  		v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
  6087  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  6088  		v1.AuxInt = int64ToAuxInt(c & 15)
  6089  		v0.AddArg2(x, v1)
  6090  		v2 := b.NewValue0(v.Pos, OpRsh16Ux64, t)
  6091  		v3 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  6092  		v3.AuxInt = int64ToAuxInt(-c & 15)
  6093  		v2.AddArg2(x, v3)
  6094  		v.AddArg2(v0, v2)
  6095  		return true
  6096  	}
  6097  	return false
  6098  }
  6099  func rewriteValueRISCV64_OpRotateLeft32(v *Value) bool {
  6100  	v_1 := v.Args[1]
  6101  	v_0 := v.Args[0]
  6102  	b := v.Block
  6103  	typ := &b.Func.Config.Types
  6104  	// match: (RotateLeft32 <t> x (MOVDconst [c]))
  6105  	// result: (Or32 (Lsh32x64 <t> x (MOVDconst [c&31])) (Rsh32Ux64 <t> x (MOVDconst [-c&31])))
  6106  	for {
  6107  		t := v.Type
  6108  		x := v_0
  6109  		if v_1.Op != OpRISCV64MOVDconst {
  6110  			break
  6111  		}
  6112  		c := auxIntToInt64(v_1.AuxInt)
  6113  		v.reset(OpOr32)
  6114  		v0 := b.NewValue0(v.Pos, OpLsh32x64, t)
  6115  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  6116  		v1.AuxInt = int64ToAuxInt(c & 31)
  6117  		v0.AddArg2(x, v1)
  6118  		v2 := b.NewValue0(v.Pos, OpRsh32Ux64, t)
  6119  		v3 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  6120  		v3.AuxInt = int64ToAuxInt(-c & 31)
  6121  		v2.AddArg2(x, v3)
  6122  		v.AddArg2(v0, v2)
  6123  		return true
  6124  	}
  6125  	return false
  6126  }
  6127  func rewriteValueRISCV64_OpRotateLeft64(v *Value) bool {
  6128  	v_1 := v.Args[1]
  6129  	v_0 := v.Args[0]
  6130  	b := v.Block
  6131  	typ := &b.Func.Config.Types
  6132  	// match: (RotateLeft64 <t> x (MOVDconst [c]))
  6133  	// result: (Or64 (Lsh64x64 <t> x (MOVDconst [c&63])) (Rsh64Ux64 <t> x (MOVDconst [-c&63])))
  6134  	for {
  6135  		t := v.Type
  6136  		x := v_0
  6137  		if v_1.Op != OpRISCV64MOVDconst {
  6138  			break
  6139  		}
  6140  		c := auxIntToInt64(v_1.AuxInt)
  6141  		v.reset(OpOr64)
  6142  		v0 := b.NewValue0(v.Pos, OpLsh64x64, t)
  6143  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  6144  		v1.AuxInt = int64ToAuxInt(c & 63)
  6145  		v0.AddArg2(x, v1)
  6146  		v2 := b.NewValue0(v.Pos, OpRsh64Ux64, t)
  6147  		v3 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  6148  		v3.AuxInt = int64ToAuxInt(-c & 63)
  6149  		v2.AddArg2(x, v3)
  6150  		v.AddArg2(v0, v2)
  6151  		return true
  6152  	}
  6153  	return false
  6154  }
  6155  func rewriteValueRISCV64_OpRotateLeft8(v *Value) bool {
  6156  	v_1 := v.Args[1]
  6157  	v_0 := v.Args[0]
  6158  	b := v.Block
  6159  	typ := &b.Func.Config.Types
  6160  	// match: (RotateLeft8 <t> x (MOVDconst [c]))
  6161  	// result: (Or8 (Lsh8x64 <t> x (MOVDconst [c&7])) (Rsh8Ux64 <t> x (MOVDconst [-c&7])))
  6162  	for {
  6163  		t := v.Type
  6164  		x := v_0
  6165  		if v_1.Op != OpRISCV64MOVDconst {
  6166  			break
  6167  		}
  6168  		c := auxIntToInt64(v_1.AuxInt)
  6169  		v.reset(OpOr8)
  6170  		v0 := b.NewValue0(v.Pos, OpLsh8x64, t)
  6171  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  6172  		v1.AuxInt = int64ToAuxInt(c & 7)
  6173  		v0.AddArg2(x, v1)
  6174  		v2 := b.NewValue0(v.Pos, OpRsh8Ux64, t)
  6175  		v3 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  6176  		v3.AuxInt = int64ToAuxInt(-c & 7)
  6177  		v2.AddArg2(x, v3)
  6178  		v.AddArg2(v0, v2)
  6179  		return true
  6180  	}
  6181  	return false
  6182  }
  6183  func rewriteValueRISCV64_OpRsh16Ux16(v *Value) bool {
  6184  	v_1 := v.Args[1]
  6185  	v_0 := v.Args[0]
  6186  	b := v.Block
  6187  	typ := &b.Func.Config.Types
  6188  	// match: (Rsh16Ux16 <t> x y)
  6189  	// cond: !shiftIsBounded(v)
  6190  	// result: (AND (SRL <t> (ZeroExt16to64 x) y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
  6191  	for {
  6192  		t := v.Type
  6193  		x := v_0
  6194  		y := v_1
  6195  		if !(!shiftIsBounded(v)) {
  6196  			break
  6197  		}
  6198  		v.reset(OpRISCV64AND)
  6199  		v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
  6200  		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  6201  		v1.AddArg(x)
  6202  		v0.AddArg2(v1, y)
  6203  		v2 := b.NewValue0(v.Pos, OpNeg16, t)
  6204  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  6205  		v3.AuxInt = int64ToAuxInt(64)
  6206  		v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  6207  		v4.AddArg(y)
  6208  		v3.AddArg(v4)
  6209  		v2.AddArg(v3)
  6210  		v.AddArg2(v0, v2)
  6211  		return true
  6212  	}
  6213  	// match: (Rsh16Ux16 x y)
  6214  	// cond: shiftIsBounded(v)
  6215  	// result: (SRL (ZeroExt16to64 x) y)
  6216  	for {
  6217  		x := v_0
  6218  		y := v_1
  6219  		if !(shiftIsBounded(v)) {
  6220  			break
  6221  		}
  6222  		v.reset(OpRISCV64SRL)
  6223  		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  6224  		v0.AddArg(x)
  6225  		v.AddArg2(v0, y)
  6226  		return true
  6227  	}
  6228  	return false
  6229  }
  6230  func rewriteValueRISCV64_OpRsh16Ux32(v *Value) bool {
  6231  	v_1 := v.Args[1]
  6232  	v_0 := v.Args[0]
  6233  	b := v.Block
  6234  	typ := &b.Func.Config.Types
  6235  	// match: (Rsh16Ux32 <t> x y)
  6236  	// cond: !shiftIsBounded(v)
  6237  	// result: (AND (SRL <t> (ZeroExt16to64 x) y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
  6238  	for {
  6239  		t := v.Type
  6240  		x := v_0
  6241  		y := v_1
  6242  		if !(!shiftIsBounded(v)) {
  6243  			break
  6244  		}
  6245  		v.reset(OpRISCV64AND)
  6246  		v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
  6247  		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  6248  		v1.AddArg(x)
  6249  		v0.AddArg2(v1, y)
  6250  		v2 := b.NewValue0(v.Pos, OpNeg16, t)
  6251  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  6252  		v3.AuxInt = int64ToAuxInt(64)
  6253  		v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  6254  		v4.AddArg(y)
  6255  		v3.AddArg(v4)
  6256  		v2.AddArg(v3)
  6257  		v.AddArg2(v0, v2)
  6258  		return true
  6259  	}
  6260  	// match: (Rsh16Ux32 x y)
  6261  	// cond: shiftIsBounded(v)
  6262  	// result: (SRL (ZeroExt16to64 x) y)
  6263  	for {
  6264  		x := v_0
  6265  		y := v_1
  6266  		if !(shiftIsBounded(v)) {
  6267  			break
  6268  		}
  6269  		v.reset(OpRISCV64SRL)
  6270  		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  6271  		v0.AddArg(x)
  6272  		v.AddArg2(v0, y)
  6273  		return true
  6274  	}
  6275  	return false
  6276  }
  6277  func rewriteValueRISCV64_OpRsh16Ux64(v *Value) bool {
  6278  	v_1 := v.Args[1]
  6279  	v_0 := v.Args[0]
  6280  	b := v.Block
  6281  	typ := &b.Func.Config.Types
  6282  	// match: (Rsh16Ux64 <t> x y)
  6283  	// cond: !shiftIsBounded(v)
  6284  	// result: (AND (SRL <t> (ZeroExt16to64 x) y) (Neg16 <t> (SLTIU <t> [64] y)))
  6285  	for {
  6286  		t := v.Type
  6287  		x := v_0
  6288  		y := v_1
  6289  		if !(!shiftIsBounded(v)) {
  6290  			break
  6291  		}
  6292  		v.reset(OpRISCV64AND)
  6293  		v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
  6294  		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  6295  		v1.AddArg(x)
  6296  		v0.AddArg2(v1, y)
  6297  		v2 := b.NewValue0(v.Pos, OpNeg16, t)
  6298  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  6299  		v3.AuxInt = int64ToAuxInt(64)
  6300  		v3.AddArg(y)
  6301  		v2.AddArg(v3)
  6302  		v.AddArg2(v0, v2)
  6303  		return true
  6304  	}
  6305  	// match: (Rsh16Ux64 x y)
  6306  	// cond: shiftIsBounded(v)
  6307  	// result: (SRL (ZeroExt16to64 x) y)
  6308  	for {
  6309  		x := v_0
  6310  		y := v_1
  6311  		if !(shiftIsBounded(v)) {
  6312  			break
  6313  		}
  6314  		v.reset(OpRISCV64SRL)
  6315  		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  6316  		v0.AddArg(x)
  6317  		v.AddArg2(v0, y)
  6318  		return true
  6319  	}
  6320  	return false
  6321  }
  6322  func rewriteValueRISCV64_OpRsh16Ux8(v *Value) bool {
  6323  	v_1 := v.Args[1]
  6324  	v_0 := v.Args[0]
  6325  	b := v.Block
  6326  	typ := &b.Func.Config.Types
  6327  	// match: (Rsh16Ux8 <t> x y)
  6328  	// cond: !shiftIsBounded(v)
  6329  	// result: (AND (SRL <t> (ZeroExt16to64 x) y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
  6330  	for {
  6331  		t := v.Type
  6332  		x := v_0
  6333  		y := v_1
  6334  		if !(!shiftIsBounded(v)) {
  6335  			break
  6336  		}
  6337  		v.reset(OpRISCV64AND)
  6338  		v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
  6339  		v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  6340  		v1.AddArg(x)
  6341  		v0.AddArg2(v1, y)
  6342  		v2 := b.NewValue0(v.Pos, OpNeg16, t)
  6343  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  6344  		v3.AuxInt = int64ToAuxInt(64)
  6345  		v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  6346  		v4.AddArg(y)
  6347  		v3.AddArg(v4)
  6348  		v2.AddArg(v3)
  6349  		v.AddArg2(v0, v2)
  6350  		return true
  6351  	}
  6352  	// match: (Rsh16Ux8 x y)
  6353  	// cond: shiftIsBounded(v)
  6354  	// result: (SRL (ZeroExt16to64 x) y)
  6355  	for {
  6356  		x := v_0
  6357  		y := v_1
  6358  		if !(shiftIsBounded(v)) {
  6359  			break
  6360  		}
  6361  		v.reset(OpRISCV64SRL)
  6362  		v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  6363  		v0.AddArg(x)
  6364  		v.AddArg2(v0, y)
  6365  		return true
  6366  	}
  6367  	return false
  6368  }
  6369  func rewriteValueRISCV64_OpRsh16x16(v *Value) bool {
  6370  	v_1 := v.Args[1]
  6371  	v_0 := v.Args[0]
  6372  	b := v.Block
  6373  	typ := &b.Func.Config.Types
  6374  	// match: (Rsh16x16 <t> x y)
  6375  	// cond: !shiftIsBounded(v)
  6376  	// result: (SRA <t> (SignExt16to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt16to64 y)))))
  6377  	for {
  6378  		t := v.Type
  6379  		x := v_0
  6380  		y := v_1
  6381  		if !(!shiftIsBounded(v)) {
  6382  			break
  6383  		}
  6384  		v.reset(OpRISCV64SRA)
  6385  		v.Type = t
  6386  		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  6387  		v0.AddArg(x)
  6388  		v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
  6389  		v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
  6390  		v2.AuxInt = int64ToAuxInt(-1)
  6391  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
  6392  		v3.AuxInt = int64ToAuxInt(64)
  6393  		v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  6394  		v4.AddArg(y)
  6395  		v3.AddArg(v4)
  6396  		v2.AddArg(v3)
  6397  		v1.AddArg2(y, v2)
  6398  		v.AddArg2(v0, v1)
  6399  		return true
  6400  	}
  6401  	// match: (Rsh16x16 x y)
  6402  	// cond: shiftIsBounded(v)
  6403  	// result: (SRA (SignExt16to64 x) y)
  6404  	for {
  6405  		x := v_0
  6406  		y := v_1
  6407  		if !(shiftIsBounded(v)) {
  6408  			break
  6409  		}
  6410  		v.reset(OpRISCV64SRA)
  6411  		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  6412  		v0.AddArg(x)
  6413  		v.AddArg2(v0, y)
  6414  		return true
  6415  	}
  6416  	return false
  6417  }
  6418  func rewriteValueRISCV64_OpRsh16x32(v *Value) bool {
  6419  	v_1 := v.Args[1]
  6420  	v_0 := v.Args[0]
  6421  	b := v.Block
  6422  	typ := &b.Func.Config.Types
  6423  	// match: (Rsh16x32 <t> x y)
  6424  	// cond: !shiftIsBounded(v)
  6425  	// result: (SRA <t> (SignExt16to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt32to64 y)))))
  6426  	for {
  6427  		t := v.Type
  6428  		x := v_0
  6429  		y := v_1
  6430  		if !(!shiftIsBounded(v)) {
  6431  			break
  6432  		}
  6433  		v.reset(OpRISCV64SRA)
  6434  		v.Type = t
  6435  		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  6436  		v0.AddArg(x)
  6437  		v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
  6438  		v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
  6439  		v2.AuxInt = int64ToAuxInt(-1)
  6440  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
  6441  		v3.AuxInt = int64ToAuxInt(64)
  6442  		v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  6443  		v4.AddArg(y)
  6444  		v3.AddArg(v4)
  6445  		v2.AddArg(v3)
  6446  		v1.AddArg2(y, v2)
  6447  		v.AddArg2(v0, v1)
  6448  		return true
  6449  	}
  6450  	// match: (Rsh16x32 x y)
  6451  	// cond: shiftIsBounded(v)
  6452  	// result: (SRA (SignExt16to64 x) y)
  6453  	for {
  6454  		x := v_0
  6455  		y := v_1
  6456  		if !(shiftIsBounded(v)) {
  6457  			break
  6458  		}
  6459  		v.reset(OpRISCV64SRA)
  6460  		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  6461  		v0.AddArg(x)
  6462  		v.AddArg2(v0, y)
  6463  		return true
  6464  	}
  6465  	return false
  6466  }
  6467  func rewriteValueRISCV64_OpRsh16x64(v *Value) bool {
  6468  	v_1 := v.Args[1]
  6469  	v_0 := v.Args[0]
  6470  	b := v.Block
  6471  	typ := &b.Func.Config.Types
  6472  	// match: (Rsh16x64 <t> x y)
  6473  	// cond: !shiftIsBounded(v)
  6474  	// result: (SRA <t> (SignExt16to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] y))))
  6475  	for {
  6476  		t := v.Type
  6477  		x := v_0
  6478  		y := v_1
  6479  		if !(!shiftIsBounded(v)) {
  6480  			break
  6481  		}
  6482  		v.reset(OpRISCV64SRA)
  6483  		v.Type = t
  6484  		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  6485  		v0.AddArg(x)
  6486  		v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
  6487  		v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
  6488  		v2.AuxInt = int64ToAuxInt(-1)
  6489  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
  6490  		v3.AuxInt = int64ToAuxInt(64)
  6491  		v3.AddArg(y)
  6492  		v2.AddArg(v3)
  6493  		v1.AddArg2(y, v2)
  6494  		v.AddArg2(v0, v1)
  6495  		return true
  6496  	}
  6497  	// match: (Rsh16x64 x y)
  6498  	// cond: shiftIsBounded(v)
  6499  	// result: (SRA (SignExt16to64 x) y)
  6500  	for {
  6501  		x := v_0
  6502  		y := v_1
  6503  		if !(shiftIsBounded(v)) {
  6504  			break
  6505  		}
  6506  		v.reset(OpRISCV64SRA)
  6507  		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  6508  		v0.AddArg(x)
  6509  		v.AddArg2(v0, y)
  6510  		return true
  6511  	}
  6512  	return false
  6513  }
  6514  func rewriteValueRISCV64_OpRsh16x8(v *Value) bool {
  6515  	v_1 := v.Args[1]
  6516  	v_0 := v.Args[0]
  6517  	b := v.Block
  6518  	typ := &b.Func.Config.Types
  6519  	// match: (Rsh16x8 <t> x y)
  6520  	// cond: !shiftIsBounded(v)
  6521  	// result: (SRA <t> (SignExt16to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt8to64 y)))))
  6522  	for {
  6523  		t := v.Type
  6524  		x := v_0
  6525  		y := v_1
  6526  		if !(!shiftIsBounded(v)) {
  6527  			break
  6528  		}
  6529  		v.reset(OpRISCV64SRA)
  6530  		v.Type = t
  6531  		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  6532  		v0.AddArg(x)
  6533  		v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
  6534  		v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
  6535  		v2.AuxInt = int64ToAuxInt(-1)
  6536  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
  6537  		v3.AuxInt = int64ToAuxInt(64)
  6538  		v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  6539  		v4.AddArg(y)
  6540  		v3.AddArg(v4)
  6541  		v2.AddArg(v3)
  6542  		v1.AddArg2(y, v2)
  6543  		v.AddArg2(v0, v1)
  6544  		return true
  6545  	}
  6546  	// match: (Rsh16x8 x y)
  6547  	// cond: shiftIsBounded(v)
  6548  	// result: (SRA (SignExt16to64 x) y)
  6549  	for {
  6550  		x := v_0
  6551  		y := v_1
  6552  		if !(shiftIsBounded(v)) {
  6553  			break
  6554  		}
  6555  		v.reset(OpRISCV64SRA)
  6556  		v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
  6557  		v0.AddArg(x)
  6558  		v.AddArg2(v0, y)
  6559  		return true
  6560  	}
  6561  	return false
  6562  }
  6563  func rewriteValueRISCV64_OpRsh32Ux16(v *Value) bool {
  6564  	v_1 := v.Args[1]
  6565  	v_0 := v.Args[0]
  6566  	b := v.Block
  6567  	typ := &b.Func.Config.Types
  6568  	// match: (Rsh32Ux16 <t> x y)
  6569  	// cond: !shiftIsBounded(v)
  6570  	// result: (AND (SRL <t> (ZeroExt32to64 x) y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
  6571  	for {
  6572  		t := v.Type
  6573  		x := v_0
  6574  		y := v_1
  6575  		if !(!shiftIsBounded(v)) {
  6576  			break
  6577  		}
  6578  		v.reset(OpRISCV64AND)
  6579  		v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
  6580  		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  6581  		v1.AddArg(x)
  6582  		v0.AddArg2(v1, y)
  6583  		v2 := b.NewValue0(v.Pos, OpNeg32, t)
  6584  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  6585  		v3.AuxInt = int64ToAuxInt(64)
  6586  		v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  6587  		v4.AddArg(y)
  6588  		v3.AddArg(v4)
  6589  		v2.AddArg(v3)
  6590  		v.AddArg2(v0, v2)
  6591  		return true
  6592  	}
  6593  	// match: (Rsh32Ux16 x y)
  6594  	// cond: shiftIsBounded(v)
  6595  	// result: (SRL (ZeroExt32to64 x) y)
  6596  	for {
  6597  		x := v_0
  6598  		y := v_1
  6599  		if !(shiftIsBounded(v)) {
  6600  			break
  6601  		}
  6602  		v.reset(OpRISCV64SRL)
  6603  		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  6604  		v0.AddArg(x)
  6605  		v.AddArg2(v0, y)
  6606  		return true
  6607  	}
  6608  	return false
  6609  }
  6610  func rewriteValueRISCV64_OpRsh32Ux32(v *Value) bool {
  6611  	v_1 := v.Args[1]
  6612  	v_0 := v.Args[0]
  6613  	b := v.Block
  6614  	typ := &b.Func.Config.Types
  6615  	// match: (Rsh32Ux32 <t> x y)
  6616  	// cond: !shiftIsBounded(v)
  6617  	// result: (AND (SRL <t> (ZeroExt32to64 x) y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
  6618  	for {
  6619  		t := v.Type
  6620  		x := v_0
  6621  		y := v_1
  6622  		if !(!shiftIsBounded(v)) {
  6623  			break
  6624  		}
  6625  		v.reset(OpRISCV64AND)
  6626  		v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
  6627  		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  6628  		v1.AddArg(x)
  6629  		v0.AddArg2(v1, y)
  6630  		v2 := b.NewValue0(v.Pos, OpNeg32, t)
  6631  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  6632  		v3.AuxInt = int64ToAuxInt(64)
  6633  		v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  6634  		v4.AddArg(y)
  6635  		v3.AddArg(v4)
  6636  		v2.AddArg(v3)
  6637  		v.AddArg2(v0, v2)
  6638  		return true
  6639  	}
  6640  	// match: (Rsh32Ux32 x y)
  6641  	// cond: shiftIsBounded(v)
  6642  	// result: (SRL (ZeroExt32to64 x) y)
  6643  	for {
  6644  		x := v_0
  6645  		y := v_1
  6646  		if !(shiftIsBounded(v)) {
  6647  			break
  6648  		}
  6649  		v.reset(OpRISCV64SRL)
  6650  		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  6651  		v0.AddArg(x)
  6652  		v.AddArg2(v0, y)
  6653  		return true
  6654  	}
  6655  	return false
  6656  }
  6657  func rewriteValueRISCV64_OpRsh32Ux64(v *Value) bool {
  6658  	v_1 := v.Args[1]
  6659  	v_0 := v.Args[0]
  6660  	b := v.Block
  6661  	typ := &b.Func.Config.Types
  6662  	// match: (Rsh32Ux64 <t> x y)
  6663  	// cond: !shiftIsBounded(v)
  6664  	// result: (AND (SRL <t> (ZeroExt32to64 x) y) (Neg32 <t> (SLTIU <t> [64] y)))
  6665  	for {
  6666  		t := v.Type
  6667  		x := v_0
  6668  		y := v_1
  6669  		if !(!shiftIsBounded(v)) {
  6670  			break
  6671  		}
  6672  		v.reset(OpRISCV64AND)
  6673  		v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
  6674  		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  6675  		v1.AddArg(x)
  6676  		v0.AddArg2(v1, y)
  6677  		v2 := b.NewValue0(v.Pos, OpNeg32, t)
  6678  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  6679  		v3.AuxInt = int64ToAuxInt(64)
  6680  		v3.AddArg(y)
  6681  		v2.AddArg(v3)
  6682  		v.AddArg2(v0, v2)
  6683  		return true
  6684  	}
  6685  	// match: (Rsh32Ux64 x y)
  6686  	// cond: shiftIsBounded(v)
  6687  	// result: (SRL (ZeroExt32to64 x) y)
  6688  	for {
  6689  		x := v_0
  6690  		y := v_1
  6691  		if !(shiftIsBounded(v)) {
  6692  			break
  6693  		}
  6694  		v.reset(OpRISCV64SRL)
  6695  		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  6696  		v0.AddArg(x)
  6697  		v.AddArg2(v0, y)
  6698  		return true
  6699  	}
  6700  	return false
  6701  }
  6702  func rewriteValueRISCV64_OpRsh32Ux8(v *Value) bool {
  6703  	v_1 := v.Args[1]
  6704  	v_0 := v.Args[0]
  6705  	b := v.Block
  6706  	typ := &b.Func.Config.Types
  6707  	// match: (Rsh32Ux8 <t> x y)
  6708  	// cond: !shiftIsBounded(v)
  6709  	// result: (AND (SRL <t> (ZeroExt32to64 x) y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
  6710  	for {
  6711  		t := v.Type
  6712  		x := v_0
  6713  		y := v_1
  6714  		if !(!shiftIsBounded(v)) {
  6715  			break
  6716  		}
  6717  		v.reset(OpRISCV64AND)
  6718  		v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
  6719  		v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  6720  		v1.AddArg(x)
  6721  		v0.AddArg2(v1, y)
  6722  		v2 := b.NewValue0(v.Pos, OpNeg32, t)
  6723  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  6724  		v3.AuxInt = int64ToAuxInt(64)
  6725  		v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  6726  		v4.AddArg(y)
  6727  		v3.AddArg(v4)
  6728  		v2.AddArg(v3)
  6729  		v.AddArg2(v0, v2)
  6730  		return true
  6731  	}
  6732  	// match: (Rsh32Ux8 x y)
  6733  	// cond: shiftIsBounded(v)
  6734  	// result: (SRL (ZeroExt32to64 x) y)
  6735  	for {
  6736  		x := v_0
  6737  		y := v_1
  6738  		if !(shiftIsBounded(v)) {
  6739  			break
  6740  		}
  6741  		v.reset(OpRISCV64SRL)
  6742  		v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  6743  		v0.AddArg(x)
  6744  		v.AddArg2(v0, y)
  6745  		return true
  6746  	}
  6747  	return false
  6748  }
  6749  func rewriteValueRISCV64_OpRsh32x16(v *Value) bool {
  6750  	v_1 := v.Args[1]
  6751  	v_0 := v.Args[0]
  6752  	b := v.Block
  6753  	typ := &b.Func.Config.Types
  6754  	// match: (Rsh32x16 <t> x y)
  6755  	// cond: !shiftIsBounded(v)
  6756  	// result: (SRA <t> (SignExt32to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt16to64 y)))))
  6757  	for {
  6758  		t := v.Type
  6759  		x := v_0
  6760  		y := v_1
  6761  		if !(!shiftIsBounded(v)) {
  6762  			break
  6763  		}
  6764  		v.reset(OpRISCV64SRA)
  6765  		v.Type = t
  6766  		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  6767  		v0.AddArg(x)
  6768  		v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
  6769  		v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
  6770  		v2.AuxInt = int64ToAuxInt(-1)
  6771  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
  6772  		v3.AuxInt = int64ToAuxInt(64)
  6773  		v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  6774  		v4.AddArg(y)
  6775  		v3.AddArg(v4)
  6776  		v2.AddArg(v3)
  6777  		v1.AddArg2(y, v2)
  6778  		v.AddArg2(v0, v1)
  6779  		return true
  6780  	}
  6781  	// match: (Rsh32x16 x y)
  6782  	// cond: shiftIsBounded(v)
  6783  	// result: (SRA (SignExt32to64 x) y)
  6784  	for {
  6785  		x := v_0
  6786  		y := v_1
  6787  		if !(shiftIsBounded(v)) {
  6788  			break
  6789  		}
  6790  		v.reset(OpRISCV64SRA)
  6791  		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  6792  		v0.AddArg(x)
  6793  		v.AddArg2(v0, y)
  6794  		return true
  6795  	}
  6796  	return false
  6797  }
  6798  func rewriteValueRISCV64_OpRsh32x32(v *Value) bool {
  6799  	v_1 := v.Args[1]
  6800  	v_0 := v.Args[0]
  6801  	b := v.Block
  6802  	typ := &b.Func.Config.Types
  6803  	// match: (Rsh32x32 <t> x y)
  6804  	// cond: !shiftIsBounded(v)
  6805  	// result: (SRA <t> (SignExt32to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt32to64 y)))))
  6806  	for {
  6807  		t := v.Type
  6808  		x := v_0
  6809  		y := v_1
  6810  		if !(!shiftIsBounded(v)) {
  6811  			break
  6812  		}
  6813  		v.reset(OpRISCV64SRA)
  6814  		v.Type = t
  6815  		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  6816  		v0.AddArg(x)
  6817  		v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
  6818  		v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
  6819  		v2.AuxInt = int64ToAuxInt(-1)
  6820  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
  6821  		v3.AuxInt = int64ToAuxInt(64)
  6822  		v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  6823  		v4.AddArg(y)
  6824  		v3.AddArg(v4)
  6825  		v2.AddArg(v3)
  6826  		v1.AddArg2(y, v2)
  6827  		v.AddArg2(v0, v1)
  6828  		return true
  6829  	}
  6830  	// match: (Rsh32x32 x y)
  6831  	// cond: shiftIsBounded(v)
  6832  	// result: (SRA (SignExt32to64 x) y)
  6833  	for {
  6834  		x := v_0
  6835  		y := v_1
  6836  		if !(shiftIsBounded(v)) {
  6837  			break
  6838  		}
  6839  		v.reset(OpRISCV64SRA)
  6840  		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  6841  		v0.AddArg(x)
  6842  		v.AddArg2(v0, y)
  6843  		return true
  6844  	}
  6845  	return false
  6846  }
  6847  func rewriteValueRISCV64_OpRsh32x64(v *Value) bool {
  6848  	v_1 := v.Args[1]
  6849  	v_0 := v.Args[0]
  6850  	b := v.Block
  6851  	typ := &b.Func.Config.Types
  6852  	// match: (Rsh32x64 <t> x y)
  6853  	// cond: !shiftIsBounded(v)
  6854  	// result: (SRA <t> (SignExt32to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] y))))
  6855  	for {
  6856  		t := v.Type
  6857  		x := v_0
  6858  		y := v_1
  6859  		if !(!shiftIsBounded(v)) {
  6860  			break
  6861  		}
  6862  		v.reset(OpRISCV64SRA)
  6863  		v.Type = t
  6864  		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  6865  		v0.AddArg(x)
  6866  		v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
  6867  		v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
  6868  		v2.AuxInt = int64ToAuxInt(-1)
  6869  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
  6870  		v3.AuxInt = int64ToAuxInt(64)
  6871  		v3.AddArg(y)
  6872  		v2.AddArg(v3)
  6873  		v1.AddArg2(y, v2)
  6874  		v.AddArg2(v0, v1)
  6875  		return true
  6876  	}
  6877  	// match: (Rsh32x64 x y)
  6878  	// cond: shiftIsBounded(v)
  6879  	// result: (SRA (SignExt32to64 x) y)
  6880  	for {
  6881  		x := v_0
  6882  		y := v_1
  6883  		if !(shiftIsBounded(v)) {
  6884  			break
  6885  		}
  6886  		v.reset(OpRISCV64SRA)
  6887  		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  6888  		v0.AddArg(x)
  6889  		v.AddArg2(v0, y)
  6890  		return true
  6891  	}
  6892  	return false
  6893  }
  6894  func rewriteValueRISCV64_OpRsh32x8(v *Value) bool {
  6895  	v_1 := v.Args[1]
  6896  	v_0 := v.Args[0]
  6897  	b := v.Block
  6898  	typ := &b.Func.Config.Types
  6899  	// match: (Rsh32x8 <t> x y)
  6900  	// cond: !shiftIsBounded(v)
  6901  	// result: (SRA <t> (SignExt32to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt8to64 y)))))
  6902  	for {
  6903  		t := v.Type
  6904  		x := v_0
  6905  		y := v_1
  6906  		if !(!shiftIsBounded(v)) {
  6907  			break
  6908  		}
  6909  		v.reset(OpRISCV64SRA)
  6910  		v.Type = t
  6911  		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  6912  		v0.AddArg(x)
  6913  		v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
  6914  		v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
  6915  		v2.AuxInt = int64ToAuxInt(-1)
  6916  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
  6917  		v3.AuxInt = int64ToAuxInt(64)
  6918  		v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  6919  		v4.AddArg(y)
  6920  		v3.AddArg(v4)
  6921  		v2.AddArg(v3)
  6922  		v1.AddArg2(y, v2)
  6923  		v.AddArg2(v0, v1)
  6924  		return true
  6925  	}
  6926  	// match: (Rsh32x8 x y)
  6927  	// cond: shiftIsBounded(v)
  6928  	// result: (SRA (SignExt32to64 x) y)
  6929  	for {
  6930  		x := v_0
  6931  		y := v_1
  6932  		if !(shiftIsBounded(v)) {
  6933  			break
  6934  		}
  6935  		v.reset(OpRISCV64SRA)
  6936  		v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  6937  		v0.AddArg(x)
  6938  		v.AddArg2(v0, y)
  6939  		return true
  6940  	}
  6941  	return false
  6942  }
  6943  func rewriteValueRISCV64_OpRsh64Ux16(v *Value) bool {
  6944  	v_1 := v.Args[1]
  6945  	v_0 := v.Args[0]
  6946  	b := v.Block
  6947  	typ := &b.Func.Config.Types
  6948  	// match: (Rsh64Ux16 <t> x y)
  6949  	// cond: !shiftIsBounded(v)
  6950  	// result: (AND (SRL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
  6951  	for {
  6952  		t := v.Type
  6953  		x := v_0
  6954  		y := v_1
  6955  		if !(!shiftIsBounded(v)) {
  6956  			break
  6957  		}
  6958  		v.reset(OpRISCV64AND)
  6959  		v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
  6960  		v0.AddArg2(x, y)
  6961  		v1 := b.NewValue0(v.Pos, OpNeg64, t)
  6962  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  6963  		v2.AuxInt = int64ToAuxInt(64)
  6964  		v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  6965  		v3.AddArg(y)
  6966  		v2.AddArg(v3)
  6967  		v1.AddArg(v2)
  6968  		v.AddArg2(v0, v1)
  6969  		return true
  6970  	}
  6971  	// match: (Rsh64Ux16 x y)
  6972  	// cond: shiftIsBounded(v)
  6973  	// result: (SRL x y)
  6974  	for {
  6975  		x := v_0
  6976  		y := v_1
  6977  		if !(shiftIsBounded(v)) {
  6978  			break
  6979  		}
  6980  		v.reset(OpRISCV64SRL)
  6981  		v.AddArg2(x, y)
  6982  		return true
  6983  	}
  6984  	return false
  6985  }
  6986  func rewriteValueRISCV64_OpRsh64Ux32(v *Value) bool {
  6987  	v_1 := v.Args[1]
  6988  	v_0 := v.Args[0]
  6989  	b := v.Block
  6990  	typ := &b.Func.Config.Types
  6991  	// match: (Rsh64Ux32 <t> x y)
  6992  	// cond: !shiftIsBounded(v)
  6993  	// result: (AND (SRL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
  6994  	for {
  6995  		t := v.Type
  6996  		x := v_0
  6997  		y := v_1
  6998  		if !(!shiftIsBounded(v)) {
  6999  			break
  7000  		}
  7001  		v.reset(OpRISCV64AND)
  7002  		v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
  7003  		v0.AddArg2(x, y)
  7004  		v1 := b.NewValue0(v.Pos, OpNeg64, t)
  7005  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  7006  		v2.AuxInt = int64ToAuxInt(64)
  7007  		v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  7008  		v3.AddArg(y)
  7009  		v2.AddArg(v3)
  7010  		v1.AddArg(v2)
  7011  		v.AddArg2(v0, v1)
  7012  		return true
  7013  	}
  7014  	// match: (Rsh64Ux32 x y)
  7015  	// cond: shiftIsBounded(v)
  7016  	// result: (SRL x y)
  7017  	for {
  7018  		x := v_0
  7019  		y := v_1
  7020  		if !(shiftIsBounded(v)) {
  7021  			break
  7022  		}
  7023  		v.reset(OpRISCV64SRL)
  7024  		v.AddArg2(x, y)
  7025  		return true
  7026  	}
  7027  	return false
  7028  }
  7029  func rewriteValueRISCV64_OpRsh64Ux64(v *Value) bool {
  7030  	v_1 := v.Args[1]
  7031  	v_0 := v.Args[0]
  7032  	b := v.Block
  7033  	// match: (Rsh64Ux64 <t> x y)
  7034  	// cond: !shiftIsBounded(v)
  7035  	// result: (AND (SRL <t> x y) (Neg64 <t> (SLTIU <t> [64] y)))
  7036  	for {
  7037  		t := v.Type
  7038  		x := v_0
  7039  		y := v_1
  7040  		if !(!shiftIsBounded(v)) {
  7041  			break
  7042  		}
  7043  		v.reset(OpRISCV64AND)
  7044  		v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
  7045  		v0.AddArg2(x, y)
  7046  		v1 := b.NewValue0(v.Pos, OpNeg64, t)
  7047  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  7048  		v2.AuxInt = int64ToAuxInt(64)
  7049  		v2.AddArg(y)
  7050  		v1.AddArg(v2)
  7051  		v.AddArg2(v0, v1)
  7052  		return true
  7053  	}
  7054  	// match: (Rsh64Ux64 x y)
  7055  	// cond: shiftIsBounded(v)
  7056  	// result: (SRL x y)
  7057  	for {
  7058  		x := v_0
  7059  		y := v_1
  7060  		if !(shiftIsBounded(v)) {
  7061  			break
  7062  		}
  7063  		v.reset(OpRISCV64SRL)
  7064  		v.AddArg2(x, y)
  7065  		return true
  7066  	}
  7067  	return false
  7068  }
  7069  func rewriteValueRISCV64_OpRsh64Ux8(v *Value) bool {
  7070  	v_1 := v.Args[1]
  7071  	v_0 := v.Args[0]
  7072  	b := v.Block
  7073  	typ := &b.Func.Config.Types
  7074  	// match: (Rsh64Ux8 <t> x y)
  7075  	// cond: !shiftIsBounded(v)
  7076  	// result: (AND (SRL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
  7077  	for {
  7078  		t := v.Type
  7079  		x := v_0
  7080  		y := v_1
  7081  		if !(!shiftIsBounded(v)) {
  7082  			break
  7083  		}
  7084  		v.reset(OpRISCV64AND)
  7085  		v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
  7086  		v0.AddArg2(x, y)
  7087  		v1 := b.NewValue0(v.Pos, OpNeg64, t)
  7088  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  7089  		v2.AuxInt = int64ToAuxInt(64)
  7090  		v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  7091  		v3.AddArg(y)
  7092  		v2.AddArg(v3)
  7093  		v1.AddArg(v2)
  7094  		v.AddArg2(v0, v1)
  7095  		return true
  7096  	}
  7097  	// match: (Rsh64Ux8 x y)
  7098  	// cond: shiftIsBounded(v)
  7099  	// result: (SRL x y)
  7100  	for {
  7101  		x := v_0
  7102  		y := v_1
  7103  		if !(shiftIsBounded(v)) {
  7104  			break
  7105  		}
  7106  		v.reset(OpRISCV64SRL)
  7107  		v.AddArg2(x, y)
  7108  		return true
  7109  	}
  7110  	return false
  7111  }
  7112  func rewriteValueRISCV64_OpRsh64x16(v *Value) bool {
  7113  	v_1 := v.Args[1]
  7114  	v_0 := v.Args[0]
  7115  	b := v.Block
  7116  	typ := &b.Func.Config.Types
  7117  	// match: (Rsh64x16 <t> x y)
  7118  	// cond: !shiftIsBounded(v)
  7119  	// result: (SRA <t> x (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt16to64 y)))))
  7120  	for {
  7121  		t := v.Type
  7122  		x := v_0
  7123  		y := v_1
  7124  		if !(!shiftIsBounded(v)) {
  7125  			break
  7126  		}
  7127  		v.reset(OpRISCV64SRA)
  7128  		v.Type = t
  7129  		v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
  7130  		v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
  7131  		v1.AuxInt = int64ToAuxInt(-1)
  7132  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
  7133  		v2.AuxInt = int64ToAuxInt(64)
  7134  		v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  7135  		v3.AddArg(y)
  7136  		v2.AddArg(v3)
  7137  		v1.AddArg(v2)
  7138  		v0.AddArg2(y, v1)
  7139  		v.AddArg2(x, v0)
  7140  		return true
  7141  	}
  7142  	// match: (Rsh64x16 x y)
  7143  	// cond: shiftIsBounded(v)
  7144  	// result: (SRA x y)
  7145  	for {
  7146  		x := v_0
  7147  		y := v_1
  7148  		if !(shiftIsBounded(v)) {
  7149  			break
  7150  		}
  7151  		v.reset(OpRISCV64SRA)
  7152  		v.AddArg2(x, y)
  7153  		return true
  7154  	}
  7155  	return false
  7156  }
  7157  func rewriteValueRISCV64_OpRsh64x32(v *Value) bool {
  7158  	v_1 := v.Args[1]
  7159  	v_0 := v.Args[0]
  7160  	b := v.Block
  7161  	typ := &b.Func.Config.Types
  7162  	// match: (Rsh64x32 <t> x y)
  7163  	// cond: !shiftIsBounded(v)
  7164  	// result: (SRA <t> x (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt32to64 y)))))
  7165  	for {
  7166  		t := v.Type
  7167  		x := v_0
  7168  		y := v_1
  7169  		if !(!shiftIsBounded(v)) {
  7170  			break
  7171  		}
  7172  		v.reset(OpRISCV64SRA)
  7173  		v.Type = t
  7174  		v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
  7175  		v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
  7176  		v1.AuxInt = int64ToAuxInt(-1)
  7177  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
  7178  		v2.AuxInt = int64ToAuxInt(64)
  7179  		v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  7180  		v3.AddArg(y)
  7181  		v2.AddArg(v3)
  7182  		v1.AddArg(v2)
  7183  		v0.AddArg2(y, v1)
  7184  		v.AddArg2(x, v0)
  7185  		return true
  7186  	}
  7187  	// match: (Rsh64x32 x y)
  7188  	// cond: shiftIsBounded(v)
  7189  	// result: (SRA x y)
  7190  	for {
  7191  		x := v_0
  7192  		y := v_1
  7193  		if !(shiftIsBounded(v)) {
  7194  			break
  7195  		}
  7196  		v.reset(OpRISCV64SRA)
  7197  		v.AddArg2(x, y)
  7198  		return true
  7199  	}
  7200  	return false
  7201  }
  7202  func rewriteValueRISCV64_OpRsh64x64(v *Value) bool {
  7203  	v_1 := v.Args[1]
  7204  	v_0 := v.Args[0]
  7205  	b := v.Block
  7206  	// match: (Rsh64x64 <t> x y)
  7207  	// cond: !shiftIsBounded(v)
  7208  	// result: (SRA <t> x (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] y))))
  7209  	for {
  7210  		t := v.Type
  7211  		x := v_0
  7212  		y := v_1
  7213  		if !(!shiftIsBounded(v)) {
  7214  			break
  7215  		}
  7216  		v.reset(OpRISCV64SRA)
  7217  		v.Type = t
  7218  		v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
  7219  		v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
  7220  		v1.AuxInt = int64ToAuxInt(-1)
  7221  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
  7222  		v2.AuxInt = int64ToAuxInt(64)
  7223  		v2.AddArg(y)
  7224  		v1.AddArg(v2)
  7225  		v0.AddArg2(y, v1)
  7226  		v.AddArg2(x, v0)
  7227  		return true
  7228  	}
  7229  	// match: (Rsh64x64 x y)
  7230  	// cond: shiftIsBounded(v)
  7231  	// result: (SRA x y)
  7232  	for {
  7233  		x := v_0
  7234  		y := v_1
  7235  		if !(shiftIsBounded(v)) {
  7236  			break
  7237  		}
  7238  		v.reset(OpRISCV64SRA)
  7239  		v.AddArg2(x, y)
  7240  		return true
  7241  	}
  7242  	return false
  7243  }
  7244  func rewriteValueRISCV64_OpRsh64x8(v *Value) bool {
  7245  	v_1 := v.Args[1]
  7246  	v_0 := v.Args[0]
  7247  	b := v.Block
  7248  	typ := &b.Func.Config.Types
  7249  	// match: (Rsh64x8 <t> x y)
  7250  	// cond: !shiftIsBounded(v)
  7251  	// result: (SRA <t> x (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt8to64 y)))))
  7252  	for {
  7253  		t := v.Type
  7254  		x := v_0
  7255  		y := v_1
  7256  		if !(!shiftIsBounded(v)) {
  7257  			break
  7258  		}
  7259  		v.reset(OpRISCV64SRA)
  7260  		v.Type = t
  7261  		v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
  7262  		v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
  7263  		v1.AuxInt = int64ToAuxInt(-1)
  7264  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
  7265  		v2.AuxInt = int64ToAuxInt(64)
  7266  		v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  7267  		v3.AddArg(y)
  7268  		v2.AddArg(v3)
  7269  		v1.AddArg(v2)
  7270  		v0.AddArg2(y, v1)
  7271  		v.AddArg2(x, v0)
  7272  		return true
  7273  	}
  7274  	// match: (Rsh64x8 x y)
  7275  	// cond: shiftIsBounded(v)
  7276  	// result: (SRA x y)
  7277  	for {
  7278  		x := v_0
  7279  		y := v_1
  7280  		if !(shiftIsBounded(v)) {
  7281  			break
  7282  		}
  7283  		v.reset(OpRISCV64SRA)
  7284  		v.AddArg2(x, y)
  7285  		return true
  7286  	}
  7287  	return false
  7288  }
  7289  func rewriteValueRISCV64_OpRsh8Ux16(v *Value) bool {
  7290  	v_1 := v.Args[1]
  7291  	v_0 := v.Args[0]
  7292  	b := v.Block
  7293  	typ := &b.Func.Config.Types
  7294  	// match: (Rsh8Ux16 <t> x y)
  7295  	// cond: !shiftIsBounded(v)
  7296  	// result: (AND (SRL <t> (ZeroExt8to64 x) y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
  7297  	for {
  7298  		t := v.Type
  7299  		x := v_0
  7300  		y := v_1
  7301  		if !(!shiftIsBounded(v)) {
  7302  			break
  7303  		}
  7304  		v.reset(OpRISCV64AND)
  7305  		v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
  7306  		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  7307  		v1.AddArg(x)
  7308  		v0.AddArg2(v1, y)
  7309  		v2 := b.NewValue0(v.Pos, OpNeg8, t)
  7310  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  7311  		v3.AuxInt = int64ToAuxInt(64)
  7312  		v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  7313  		v4.AddArg(y)
  7314  		v3.AddArg(v4)
  7315  		v2.AddArg(v3)
  7316  		v.AddArg2(v0, v2)
  7317  		return true
  7318  	}
  7319  	// match: (Rsh8Ux16 x y)
  7320  	// cond: shiftIsBounded(v)
  7321  	// result: (SRL (ZeroExt8to64 x) y)
  7322  	for {
  7323  		x := v_0
  7324  		y := v_1
  7325  		if !(shiftIsBounded(v)) {
  7326  			break
  7327  		}
  7328  		v.reset(OpRISCV64SRL)
  7329  		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  7330  		v0.AddArg(x)
  7331  		v.AddArg2(v0, y)
  7332  		return true
  7333  	}
  7334  	return false
  7335  }
  7336  func rewriteValueRISCV64_OpRsh8Ux32(v *Value) bool {
  7337  	v_1 := v.Args[1]
  7338  	v_0 := v.Args[0]
  7339  	b := v.Block
  7340  	typ := &b.Func.Config.Types
  7341  	// match: (Rsh8Ux32 <t> x y)
  7342  	// cond: !shiftIsBounded(v)
  7343  	// result: (AND (SRL <t> (ZeroExt8to64 x) y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
  7344  	for {
  7345  		t := v.Type
  7346  		x := v_0
  7347  		y := v_1
  7348  		if !(!shiftIsBounded(v)) {
  7349  			break
  7350  		}
  7351  		v.reset(OpRISCV64AND)
  7352  		v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
  7353  		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  7354  		v1.AddArg(x)
  7355  		v0.AddArg2(v1, y)
  7356  		v2 := b.NewValue0(v.Pos, OpNeg8, t)
  7357  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  7358  		v3.AuxInt = int64ToAuxInt(64)
  7359  		v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  7360  		v4.AddArg(y)
  7361  		v3.AddArg(v4)
  7362  		v2.AddArg(v3)
  7363  		v.AddArg2(v0, v2)
  7364  		return true
  7365  	}
  7366  	// match: (Rsh8Ux32 x y)
  7367  	// cond: shiftIsBounded(v)
  7368  	// result: (SRL (ZeroExt8to64 x) y)
  7369  	for {
  7370  		x := v_0
  7371  		y := v_1
  7372  		if !(shiftIsBounded(v)) {
  7373  			break
  7374  		}
  7375  		v.reset(OpRISCV64SRL)
  7376  		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  7377  		v0.AddArg(x)
  7378  		v.AddArg2(v0, y)
  7379  		return true
  7380  	}
  7381  	return false
  7382  }
  7383  func rewriteValueRISCV64_OpRsh8Ux64(v *Value) bool {
  7384  	v_1 := v.Args[1]
  7385  	v_0 := v.Args[0]
  7386  	b := v.Block
  7387  	typ := &b.Func.Config.Types
  7388  	// match: (Rsh8Ux64 <t> x y)
  7389  	// cond: !shiftIsBounded(v)
  7390  	// result: (AND (SRL <t> (ZeroExt8to64 x) y) (Neg8 <t> (SLTIU <t> [64] y)))
  7391  	for {
  7392  		t := v.Type
  7393  		x := v_0
  7394  		y := v_1
  7395  		if !(!shiftIsBounded(v)) {
  7396  			break
  7397  		}
  7398  		v.reset(OpRISCV64AND)
  7399  		v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
  7400  		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  7401  		v1.AddArg(x)
  7402  		v0.AddArg2(v1, y)
  7403  		v2 := b.NewValue0(v.Pos, OpNeg8, t)
  7404  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  7405  		v3.AuxInt = int64ToAuxInt(64)
  7406  		v3.AddArg(y)
  7407  		v2.AddArg(v3)
  7408  		v.AddArg2(v0, v2)
  7409  		return true
  7410  	}
  7411  	// match: (Rsh8Ux64 x y)
  7412  	// cond: shiftIsBounded(v)
  7413  	// result: (SRL (ZeroExt8to64 x) y)
  7414  	for {
  7415  		x := v_0
  7416  		y := v_1
  7417  		if !(shiftIsBounded(v)) {
  7418  			break
  7419  		}
  7420  		v.reset(OpRISCV64SRL)
  7421  		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  7422  		v0.AddArg(x)
  7423  		v.AddArg2(v0, y)
  7424  		return true
  7425  	}
  7426  	return false
  7427  }
  7428  func rewriteValueRISCV64_OpRsh8Ux8(v *Value) bool {
  7429  	v_1 := v.Args[1]
  7430  	v_0 := v.Args[0]
  7431  	b := v.Block
  7432  	typ := &b.Func.Config.Types
  7433  	// match: (Rsh8Ux8 <t> x y)
  7434  	// cond: !shiftIsBounded(v)
  7435  	// result: (AND (SRL <t> (ZeroExt8to64 x) y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
  7436  	for {
  7437  		t := v.Type
  7438  		x := v_0
  7439  		y := v_1
  7440  		if !(!shiftIsBounded(v)) {
  7441  			break
  7442  		}
  7443  		v.reset(OpRISCV64AND)
  7444  		v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
  7445  		v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  7446  		v1.AddArg(x)
  7447  		v0.AddArg2(v1, y)
  7448  		v2 := b.NewValue0(v.Pos, OpNeg8, t)
  7449  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
  7450  		v3.AuxInt = int64ToAuxInt(64)
  7451  		v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  7452  		v4.AddArg(y)
  7453  		v3.AddArg(v4)
  7454  		v2.AddArg(v3)
  7455  		v.AddArg2(v0, v2)
  7456  		return true
  7457  	}
  7458  	// match: (Rsh8Ux8 x y)
  7459  	// cond: shiftIsBounded(v)
  7460  	// result: (SRL (ZeroExt8to64 x) y)
  7461  	for {
  7462  		x := v_0
  7463  		y := v_1
  7464  		if !(shiftIsBounded(v)) {
  7465  			break
  7466  		}
  7467  		v.reset(OpRISCV64SRL)
  7468  		v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  7469  		v0.AddArg(x)
  7470  		v.AddArg2(v0, y)
  7471  		return true
  7472  	}
  7473  	return false
  7474  }
  7475  func rewriteValueRISCV64_OpRsh8x16(v *Value) bool {
  7476  	v_1 := v.Args[1]
  7477  	v_0 := v.Args[0]
  7478  	b := v.Block
  7479  	typ := &b.Func.Config.Types
  7480  	// match: (Rsh8x16 <t> x y)
  7481  	// cond: !shiftIsBounded(v)
  7482  	// result: (SRA <t> (SignExt8to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt16to64 y)))))
  7483  	for {
  7484  		t := v.Type
  7485  		x := v_0
  7486  		y := v_1
  7487  		if !(!shiftIsBounded(v)) {
  7488  			break
  7489  		}
  7490  		v.reset(OpRISCV64SRA)
  7491  		v.Type = t
  7492  		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  7493  		v0.AddArg(x)
  7494  		v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
  7495  		v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
  7496  		v2.AuxInt = int64ToAuxInt(-1)
  7497  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
  7498  		v3.AuxInt = int64ToAuxInt(64)
  7499  		v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  7500  		v4.AddArg(y)
  7501  		v3.AddArg(v4)
  7502  		v2.AddArg(v3)
  7503  		v1.AddArg2(y, v2)
  7504  		v.AddArg2(v0, v1)
  7505  		return true
  7506  	}
  7507  	// match: (Rsh8x16 x y)
  7508  	// cond: shiftIsBounded(v)
  7509  	// result: (SRA (SignExt8to64 x) y)
  7510  	for {
  7511  		x := v_0
  7512  		y := v_1
  7513  		if !(shiftIsBounded(v)) {
  7514  			break
  7515  		}
  7516  		v.reset(OpRISCV64SRA)
  7517  		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  7518  		v0.AddArg(x)
  7519  		v.AddArg2(v0, y)
  7520  		return true
  7521  	}
  7522  	return false
  7523  }
  7524  func rewriteValueRISCV64_OpRsh8x32(v *Value) bool {
  7525  	v_1 := v.Args[1]
  7526  	v_0 := v.Args[0]
  7527  	b := v.Block
  7528  	typ := &b.Func.Config.Types
  7529  	// match: (Rsh8x32 <t> x y)
  7530  	// cond: !shiftIsBounded(v)
  7531  	// result: (SRA <t> (SignExt8to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt32to64 y)))))
  7532  	for {
  7533  		t := v.Type
  7534  		x := v_0
  7535  		y := v_1
  7536  		if !(!shiftIsBounded(v)) {
  7537  			break
  7538  		}
  7539  		v.reset(OpRISCV64SRA)
  7540  		v.Type = t
  7541  		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  7542  		v0.AddArg(x)
  7543  		v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
  7544  		v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
  7545  		v2.AuxInt = int64ToAuxInt(-1)
  7546  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
  7547  		v3.AuxInt = int64ToAuxInt(64)
  7548  		v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  7549  		v4.AddArg(y)
  7550  		v3.AddArg(v4)
  7551  		v2.AddArg(v3)
  7552  		v1.AddArg2(y, v2)
  7553  		v.AddArg2(v0, v1)
  7554  		return true
  7555  	}
  7556  	// match: (Rsh8x32 x y)
  7557  	// cond: shiftIsBounded(v)
  7558  	// result: (SRA (SignExt8to64 x) y)
  7559  	for {
  7560  		x := v_0
  7561  		y := v_1
  7562  		if !(shiftIsBounded(v)) {
  7563  			break
  7564  		}
  7565  		v.reset(OpRISCV64SRA)
  7566  		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  7567  		v0.AddArg(x)
  7568  		v.AddArg2(v0, y)
  7569  		return true
  7570  	}
  7571  	return false
  7572  }
  7573  func rewriteValueRISCV64_OpRsh8x64(v *Value) bool {
  7574  	v_1 := v.Args[1]
  7575  	v_0 := v.Args[0]
  7576  	b := v.Block
  7577  	typ := &b.Func.Config.Types
  7578  	// match: (Rsh8x64 <t> x y)
  7579  	// cond: !shiftIsBounded(v)
  7580  	// result: (SRA <t> (SignExt8to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] y))))
  7581  	for {
  7582  		t := v.Type
  7583  		x := v_0
  7584  		y := v_1
  7585  		if !(!shiftIsBounded(v)) {
  7586  			break
  7587  		}
  7588  		v.reset(OpRISCV64SRA)
  7589  		v.Type = t
  7590  		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  7591  		v0.AddArg(x)
  7592  		v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
  7593  		v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
  7594  		v2.AuxInt = int64ToAuxInt(-1)
  7595  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
  7596  		v3.AuxInt = int64ToAuxInt(64)
  7597  		v3.AddArg(y)
  7598  		v2.AddArg(v3)
  7599  		v1.AddArg2(y, v2)
  7600  		v.AddArg2(v0, v1)
  7601  		return true
  7602  	}
  7603  	// match: (Rsh8x64 x y)
  7604  	// cond: shiftIsBounded(v)
  7605  	// result: (SRA (SignExt8to64 x) y)
  7606  	for {
  7607  		x := v_0
  7608  		y := v_1
  7609  		if !(shiftIsBounded(v)) {
  7610  			break
  7611  		}
  7612  		v.reset(OpRISCV64SRA)
  7613  		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  7614  		v0.AddArg(x)
  7615  		v.AddArg2(v0, y)
  7616  		return true
  7617  	}
  7618  	return false
  7619  }
  7620  func rewriteValueRISCV64_OpRsh8x8(v *Value) bool {
  7621  	v_1 := v.Args[1]
  7622  	v_0 := v.Args[0]
  7623  	b := v.Block
  7624  	typ := &b.Func.Config.Types
  7625  	// match: (Rsh8x8 <t> x y)
  7626  	// cond: !shiftIsBounded(v)
  7627  	// result: (SRA <t> (SignExt8to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt8to64 y)))))
  7628  	for {
  7629  		t := v.Type
  7630  		x := v_0
  7631  		y := v_1
  7632  		if !(!shiftIsBounded(v)) {
  7633  			break
  7634  		}
  7635  		v.reset(OpRISCV64SRA)
  7636  		v.Type = t
  7637  		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  7638  		v0.AddArg(x)
  7639  		v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
  7640  		v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
  7641  		v2.AuxInt = int64ToAuxInt(-1)
  7642  		v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
  7643  		v3.AuxInt = int64ToAuxInt(64)
  7644  		v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
  7645  		v4.AddArg(y)
  7646  		v3.AddArg(v4)
  7647  		v2.AddArg(v3)
  7648  		v1.AddArg2(y, v2)
  7649  		v.AddArg2(v0, v1)
  7650  		return true
  7651  	}
  7652  	// match: (Rsh8x8 x y)
  7653  	// cond: shiftIsBounded(v)
  7654  	// result: (SRA (SignExt8to64 x) y)
  7655  	for {
  7656  		x := v_0
  7657  		y := v_1
  7658  		if !(shiftIsBounded(v)) {
  7659  			break
  7660  		}
  7661  		v.reset(OpRISCV64SRA)
  7662  		v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
  7663  		v0.AddArg(x)
  7664  		v.AddArg2(v0, y)
  7665  		return true
  7666  	}
  7667  	return false
  7668  }
  7669  func rewriteValueRISCV64_OpSelect0(v *Value) bool {
  7670  	v_0 := v.Args[0]
  7671  	b := v.Block
  7672  	typ := &b.Func.Config.Types
  7673  	// match: (Select0 (Add64carry x y c))
  7674  	// result: (ADD (ADD <typ.UInt64> x y) c)
  7675  	for {
  7676  		if v_0.Op != OpAdd64carry {
  7677  			break
  7678  		}
  7679  		c := v_0.Args[2]
  7680  		x := v_0.Args[0]
  7681  		y := v_0.Args[1]
  7682  		v.reset(OpRISCV64ADD)
  7683  		v0 := b.NewValue0(v.Pos, OpRISCV64ADD, typ.UInt64)
  7684  		v0.AddArg2(x, y)
  7685  		v.AddArg2(v0, c)
  7686  		return true
  7687  	}
  7688  	// match: (Select0 (Sub64borrow x y c))
  7689  	// result: (SUB (SUB <typ.UInt64> x y) c)
  7690  	for {
  7691  		if v_0.Op != OpSub64borrow {
  7692  			break
  7693  		}
  7694  		c := v_0.Args[2]
  7695  		x := v_0.Args[0]
  7696  		y := v_0.Args[1]
  7697  		v.reset(OpRISCV64SUB)
  7698  		v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.UInt64)
  7699  		v0.AddArg2(x, y)
  7700  		v.AddArg2(v0, c)
  7701  		return true
  7702  	}
  7703  	// match: (Select0 m:(LoweredMuluhilo x y))
  7704  	// cond: m.Uses == 1
  7705  	// result: (MULHU x y)
  7706  	for {
  7707  		m := v_0
  7708  		if m.Op != OpRISCV64LoweredMuluhilo {
  7709  			break
  7710  		}
  7711  		y := m.Args[1]
  7712  		x := m.Args[0]
  7713  		if !(m.Uses == 1) {
  7714  			break
  7715  		}
  7716  		v.reset(OpRISCV64MULHU)
  7717  		v.AddArg2(x, y)
  7718  		return true
  7719  	}
  7720  	return false
  7721  }
  7722  func rewriteValueRISCV64_OpSelect1(v *Value) bool {
  7723  	v_0 := v.Args[0]
  7724  	b := v.Block
  7725  	typ := &b.Func.Config.Types
  7726  	// match: (Select1 (Add64carry x y c))
  7727  	// result: (OR (SLTU <typ.UInt64> s:(ADD <typ.UInt64> x y) x) (SLTU <typ.UInt64> (ADD <typ.UInt64> s c) s))
  7728  	for {
  7729  		if v_0.Op != OpAdd64carry {
  7730  			break
  7731  		}
  7732  		c := v_0.Args[2]
  7733  		x := v_0.Args[0]
  7734  		y := v_0.Args[1]
  7735  		v.reset(OpRISCV64OR)
  7736  		v0 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
  7737  		s := b.NewValue0(v.Pos, OpRISCV64ADD, typ.UInt64)
  7738  		s.AddArg2(x, y)
  7739  		v0.AddArg2(s, x)
  7740  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
  7741  		v3 := b.NewValue0(v.Pos, OpRISCV64ADD, typ.UInt64)
  7742  		v3.AddArg2(s, c)
  7743  		v2.AddArg2(v3, s)
  7744  		v.AddArg2(v0, v2)
  7745  		return true
  7746  	}
  7747  	// match: (Select1 (Sub64borrow x y c))
  7748  	// result: (OR (SLTU <typ.UInt64> x s:(SUB <typ.UInt64> x y)) (SLTU <typ.UInt64> s (SUB <typ.UInt64> s c)))
  7749  	for {
  7750  		if v_0.Op != OpSub64borrow {
  7751  			break
  7752  		}
  7753  		c := v_0.Args[2]
  7754  		x := v_0.Args[0]
  7755  		y := v_0.Args[1]
  7756  		v.reset(OpRISCV64OR)
  7757  		v0 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
  7758  		s := b.NewValue0(v.Pos, OpRISCV64SUB, typ.UInt64)
  7759  		s.AddArg2(x, y)
  7760  		v0.AddArg2(x, s)
  7761  		v2 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
  7762  		v3 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.UInt64)
  7763  		v3.AddArg2(s, c)
  7764  		v2.AddArg2(s, v3)
  7765  		v.AddArg2(v0, v2)
  7766  		return true
  7767  	}
  7768  	// match: (Select1 m:(LoweredMuluhilo x y))
  7769  	// cond: m.Uses == 1
  7770  	// result: (MUL x y)
  7771  	for {
  7772  		m := v_0
  7773  		if m.Op != OpRISCV64LoweredMuluhilo {
  7774  			break
  7775  		}
  7776  		y := m.Args[1]
  7777  		x := m.Args[0]
  7778  		if !(m.Uses == 1) {
  7779  			break
  7780  		}
  7781  		v.reset(OpRISCV64MUL)
  7782  		v.AddArg2(x, y)
  7783  		return true
  7784  	}
  7785  	return false
  7786  }
  7787  func rewriteValueRISCV64_OpSlicemask(v *Value) bool {
  7788  	v_0 := v.Args[0]
  7789  	b := v.Block
  7790  	// match: (Slicemask <t> x)
  7791  	// result: (SRAI [63] (NEG <t> x))
  7792  	for {
  7793  		t := v.Type
  7794  		x := v_0
  7795  		v.reset(OpRISCV64SRAI)
  7796  		v.AuxInt = int64ToAuxInt(63)
  7797  		v0 := b.NewValue0(v.Pos, OpRISCV64NEG, t)
  7798  		v0.AddArg(x)
  7799  		v.AddArg(v0)
  7800  		return true
  7801  	}
  7802  }
  7803  func rewriteValueRISCV64_OpStore(v *Value) bool {
  7804  	v_2 := v.Args[2]
  7805  	v_1 := v.Args[1]
  7806  	v_0 := v.Args[0]
  7807  	// match: (Store {t} ptr val mem)
  7808  	// cond: t.Size() == 1
  7809  	// result: (MOVBstore ptr val mem)
  7810  	for {
  7811  		t := auxToType(v.Aux)
  7812  		ptr := v_0
  7813  		val := v_1
  7814  		mem := v_2
  7815  		if !(t.Size() == 1) {
  7816  			break
  7817  		}
  7818  		v.reset(OpRISCV64MOVBstore)
  7819  		v.AddArg3(ptr, val, mem)
  7820  		return true
  7821  	}
  7822  	// match: (Store {t} ptr val mem)
  7823  	// cond: t.Size() == 2
  7824  	// result: (MOVHstore ptr val mem)
  7825  	for {
  7826  		t := auxToType(v.Aux)
  7827  		ptr := v_0
  7828  		val := v_1
  7829  		mem := v_2
  7830  		if !(t.Size() == 2) {
  7831  			break
  7832  		}
  7833  		v.reset(OpRISCV64MOVHstore)
  7834  		v.AddArg3(ptr, val, mem)
  7835  		return true
  7836  	}
  7837  	// match: (Store {t} ptr val mem)
  7838  	// cond: t.Size() == 4 && !is32BitFloat(val.Type)
  7839  	// result: (MOVWstore ptr val mem)
  7840  	for {
  7841  		t := auxToType(v.Aux)
  7842  		ptr := v_0
  7843  		val := v_1
  7844  		mem := v_2
  7845  		if !(t.Size() == 4 && !is32BitFloat(val.Type)) {
  7846  			break
  7847  		}
  7848  		v.reset(OpRISCV64MOVWstore)
  7849  		v.AddArg3(ptr, val, mem)
  7850  		return true
  7851  	}
  7852  	// match: (Store {t} ptr val mem)
  7853  	// cond: t.Size() == 8 && !is64BitFloat(val.Type)
  7854  	// result: (MOVDstore ptr val mem)
  7855  	for {
  7856  		t := auxToType(v.Aux)
  7857  		ptr := v_0
  7858  		val := v_1
  7859  		mem := v_2
  7860  		if !(t.Size() == 8 && !is64BitFloat(val.Type)) {
  7861  			break
  7862  		}
  7863  		v.reset(OpRISCV64MOVDstore)
  7864  		v.AddArg3(ptr, val, mem)
  7865  		return true
  7866  	}
  7867  	// match: (Store {t} ptr val mem)
  7868  	// cond: t.Size() == 4 && is32BitFloat(val.Type)
  7869  	// result: (FMOVWstore ptr val mem)
  7870  	for {
  7871  		t := auxToType(v.Aux)
  7872  		ptr := v_0
  7873  		val := v_1
  7874  		mem := v_2
  7875  		if !(t.Size() == 4 && is32BitFloat(val.Type)) {
  7876  			break
  7877  		}
  7878  		v.reset(OpRISCV64FMOVWstore)
  7879  		v.AddArg3(ptr, val, mem)
  7880  		return true
  7881  	}
  7882  	// match: (Store {t} ptr val mem)
  7883  	// cond: t.Size() == 8 && is64BitFloat(val.Type)
  7884  	// result: (FMOVDstore ptr val mem)
  7885  	for {
  7886  		t := auxToType(v.Aux)
  7887  		ptr := v_0
  7888  		val := v_1
  7889  		mem := v_2
  7890  		if !(t.Size() == 8 && is64BitFloat(val.Type)) {
  7891  			break
  7892  		}
  7893  		v.reset(OpRISCV64FMOVDstore)
  7894  		v.AddArg3(ptr, val, mem)
  7895  		return true
  7896  	}
  7897  	return false
  7898  }
  7899  func rewriteValueRISCV64_OpZero(v *Value) bool {
  7900  	v_1 := v.Args[1]
  7901  	v_0 := v.Args[0]
  7902  	b := v.Block
  7903  	config := b.Func.Config
  7904  	typ := &b.Func.Config.Types
  7905  	// match: (Zero [0] _ mem)
  7906  	// result: mem
  7907  	for {
  7908  		if auxIntToInt64(v.AuxInt) != 0 {
  7909  			break
  7910  		}
  7911  		mem := v_1
  7912  		v.copyOf(mem)
  7913  		return true
  7914  	}
  7915  	// match: (Zero [1] ptr mem)
  7916  	// result: (MOVBstore ptr (MOVDconst [0]) mem)
  7917  	for {
  7918  		if auxIntToInt64(v.AuxInt) != 1 {
  7919  			break
  7920  		}
  7921  		ptr := v_0
  7922  		mem := v_1
  7923  		v.reset(OpRISCV64MOVBstore)
  7924  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  7925  		v0.AuxInt = int64ToAuxInt(0)
  7926  		v.AddArg3(ptr, v0, mem)
  7927  		return true
  7928  	}
  7929  	// match: (Zero [2] {t} ptr mem)
  7930  	// cond: t.Alignment()%2 == 0
  7931  	// result: (MOVHstore ptr (MOVDconst [0]) mem)
  7932  	for {
  7933  		if auxIntToInt64(v.AuxInt) != 2 {
  7934  			break
  7935  		}
  7936  		t := auxToType(v.Aux)
  7937  		ptr := v_0
  7938  		mem := v_1
  7939  		if !(t.Alignment()%2 == 0) {
  7940  			break
  7941  		}
  7942  		v.reset(OpRISCV64MOVHstore)
  7943  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  7944  		v0.AuxInt = int64ToAuxInt(0)
  7945  		v.AddArg3(ptr, v0, mem)
  7946  		return true
  7947  	}
  7948  	// match: (Zero [2] ptr mem)
  7949  	// result: (MOVBstore [1] ptr (MOVDconst [0]) (MOVBstore ptr (MOVDconst [0]) mem))
  7950  	for {
  7951  		if auxIntToInt64(v.AuxInt) != 2 {
  7952  			break
  7953  		}
  7954  		ptr := v_0
  7955  		mem := v_1
  7956  		v.reset(OpRISCV64MOVBstore)
  7957  		v.AuxInt = int32ToAuxInt(1)
  7958  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  7959  		v0.AuxInt = int64ToAuxInt(0)
  7960  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
  7961  		v1.AddArg3(ptr, v0, mem)
  7962  		v.AddArg3(ptr, v0, v1)
  7963  		return true
  7964  	}
  7965  	// match: (Zero [4] {t} ptr mem)
  7966  	// cond: t.Alignment()%4 == 0
  7967  	// result: (MOVWstore ptr (MOVDconst [0]) mem)
  7968  	for {
  7969  		if auxIntToInt64(v.AuxInt) != 4 {
  7970  			break
  7971  		}
  7972  		t := auxToType(v.Aux)
  7973  		ptr := v_0
  7974  		mem := v_1
  7975  		if !(t.Alignment()%4 == 0) {
  7976  			break
  7977  		}
  7978  		v.reset(OpRISCV64MOVWstore)
  7979  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  7980  		v0.AuxInt = int64ToAuxInt(0)
  7981  		v.AddArg3(ptr, v0, mem)
  7982  		return true
  7983  	}
  7984  	// match: (Zero [4] {t} ptr mem)
  7985  	// cond: t.Alignment()%2 == 0
  7986  	// result: (MOVHstore [2] ptr (MOVDconst [0]) (MOVHstore ptr (MOVDconst [0]) mem))
  7987  	for {
  7988  		if auxIntToInt64(v.AuxInt) != 4 {
  7989  			break
  7990  		}
  7991  		t := auxToType(v.Aux)
  7992  		ptr := v_0
  7993  		mem := v_1
  7994  		if !(t.Alignment()%2 == 0) {
  7995  			break
  7996  		}
  7997  		v.reset(OpRISCV64MOVHstore)
  7998  		v.AuxInt = int32ToAuxInt(2)
  7999  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  8000  		v0.AuxInt = int64ToAuxInt(0)
  8001  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
  8002  		v1.AddArg3(ptr, v0, mem)
  8003  		v.AddArg3(ptr, v0, v1)
  8004  		return true
  8005  	}
  8006  	// match: (Zero [4] ptr mem)
  8007  	// result: (MOVBstore [3] ptr (MOVDconst [0]) (MOVBstore [2] ptr (MOVDconst [0]) (MOVBstore [1] ptr (MOVDconst [0]) (MOVBstore ptr (MOVDconst [0]) mem))))
  8008  	for {
  8009  		if auxIntToInt64(v.AuxInt) != 4 {
  8010  			break
  8011  		}
  8012  		ptr := v_0
  8013  		mem := v_1
  8014  		v.reset(OpRISCV64MOVBstore)
  8015  		v.AuxInt = int32ToAuxInt(3)
  8016  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  8017  		v0.AuxInt = int64ToAuxInt(0)
  8018  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
  8019  		v1.AuxInt = int32ToAuxInt(2)
  8020  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
  8021  		v2.AuxInt = int32ToAuxInt(1)
  8022  		v3 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
  8023  		v3.AddArg3(ptr, v0, mem)
  8024  		v2.AddArg3(ptr, v0, v3)
  8025  		v1.AddArg3(ptr, v0, v2)
  8026  		v.AddArg3(ptr, v0, v1)
  8027  		return true
  8028  	}
  8029  	// match: (Zero [8] {t} ptr mem)
  8030  	// cond: t.Alignment()%8 == 0
  8031  	// result: (MOVDstore ptr (MOVDconst [0]) mem)
  8032  	for {
  8033  		if auxIntToInt64(v.AuxInt) != 8 {
  8034  			break
  8035  		}
  8036  		t := auxToType(v.Aux)
  8037  		ptr := v_0
  8038  		mem := v_1
  8039  		if !(t.Alignment()%8 == 0) {
  8040  			break
  8041  		}
  8042  		v.reset(OpRISCV64MOVDstore)
  8043  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  8044  		v0.AuxInt = int64ToAuxInt(0)
  8045  		v.AddArg3(ptr, v0, mem)
  8046  		return true
  8047  	}
  8048  	// match: (Zero [8] {t} ptr mem)
  8049  	// cond: t.Alignment()%4 == 0
  8050  	// result: (MOVWstore [4] ptr (MOVDconst [0]) (MOVWstore ptr (MOVDconst [0]) mem))
  8051  	for {
  8052  		if auxIntToInt64(v.AuxInt) != 8 {
  8053  			break
  8054  		}
  8055  		t := auxToType(v.Aux)
  8056  		ptr := v_0
  8057  		mem := v_1
  8058  		if !(t.Alignment()%4 == 0) {
  8059  			break
  8060  		}
  8061  		v.reset(OpRISCV64MOVWstore)
  8062  		v.AuxInt = int32ToAuxInt(4)
  8063  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  8064  		v0.AuxInt = int64ToAuxInt(0)
  8065  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
  8066  		v1.AddArg3(ptr, v0, mem)
  8067  		v.AddArg3(ptr, v0, v1)
  8068  		return true
  8069  	}
  8070  	// match: (Zero [8] {t} ptr mem)
  8071  	// cond: t.Alignment()%2 == 0
  8072  	// result: (MOVHstore [6] ptr (MOVDconst [0]) (MOVHstore [4] ptr (MOVDconst [0]) (MOVHstore [2] ptr (MOVDconst [0]) (MOVHstore ptr (MOVDconst [0]) mem))))
  8073  	for {
  8074  		if auxIntToInt64(v.AuxInt) != 8 {
  8075  			break
  8076  		}
  8077  		t := auxToType(v.Aux)
  8078  		ptr := v_0
  8079  		mem := v_1
  8080  		if !(t.Alignment()%2 == 0) {
  8081  			break
  8082  		}
  8083  		v.reset(OpRISCV64MOVHstore)
  8084  		v.AuxInt = int32ToAuxInt(6)
  8085  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  8086  		v0.AuxInt = int64ToAuxInt(0)
  8087  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
  8088  		v1.AuxInt = int32ToAuxInt(4)
  8089  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
  8090  		v2.AuxInt = int32ToAuxInt(2)
  8091  		v3 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
  8092  		v3.AddArg3(ptr, v0, mem)
  8093  		v2.AddArg3(ptr, v0, v3)
  8094  		v1.AddArg3(ptr, v0, v2)
  8095  		v.AddArg3(ptr, v0, v1)
  8096  		return true
  8097  	}
  8098  	// match: (Zero [3] ptr mem)
  8099  	// result: (MOVBstore [2] ptr (MOVDconst [0]) (MOVBstore [1] ptr (MOVDconst [0]) (MOVBstore ptr (MOVDconst [0]) mem)))
  8100  	for {
  8101  		if auxIntToInt64(v.AuxInt) != 3 {
  8102  			break
  8103  		}
  8104  		ptr := v_0
  8105  		mem := v_1
  8106  		v.reset(OpRISCV64MOVBstore)
  8107  		v.AuxInt = int32ToAuxInt(2)
  8108  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  8109  		v0.AuxInt = int64ToAuxInt(0)
  8110  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
  8111  		v1.AuxInt = int32ToAuxInt(1)
  8112  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
  8113  		v2.AddArg3(ptr, v0, mem)
  8114  		v1.AddArg3(ptr, v0, v2)
  8115  		v.AddArg3(ptr, v0, v1)
  8116  		return true
  8117  	}
  8118  	// match: (Zero [6] {t} ptr mem)
  8119  	// cond: t.Alignment()%2 == 0
  8120  	// result: (MOVHstore [4] ptr (MOVDconst [0]) (MOVHstore [2] ptr (MOVDconst [0]) (MOVHstore ptr (MOVDconst [0]) mem)))
  8121  	for {
  8122  		if auxIntToInt64(v.AuxInt) != 6 {
  8123  			break
  8124  		}
  8125  		t := auxToType(v.Aux)
  8126  		ptr := v_0
  8127  		mem := v_1
  8128  		if !(t.Alignment()%2 == 0) {
  8129  			break
  8130  		}
  8131  		v.reset(OpRISCV64MOVHstore)
  8132  		v.AuxInt = int32ToAuxInt(4)
  8133  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  8134  		v0.AuxInt = int64ToAuxInt(0)
  8135  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
  8136  		v1.AuxInt = int32ToAuxInt(2)
  8137  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
  8138  		v2.AddArg3(ptr, v0, mem)
  8139  		v1.AddArg3(ptr, v0, v2)
  8140  		v.AddArg3(ptr, v0, v1)
  8141  		return true
  8142  	}
  8143  	// match: (Zero [12] {t} ptr mem)
  8144  	// cond: t.Alignment()%4 == 0
  8145  	// result: (MOVWstore [8] ptr (MOVDconst [0]) (MOVWstore [4] ptr (MOVDconst [0]) (MOVWstore ptr (MOVDconst [0]) mem)))
  8146  	for {
  8147  		if auxIntToInt64(v.AuxInt) != 12 {
  8148  			break
  8149  		}
  8150  		t := auxToType(v.Aux)
  8151  		ptr := v_0
  8152  		mem := v_1
  8153  		if !(t.Alignment()%4 == 0) {
  8154  			break
  8155  		}
  8156  		v.reset(OpRISCV64MOVWstore)
  8157  		v.AuxInt = int32ToAuxInt(8)
  8158  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  8159  		v0.AuxInt = int64ToAuxInt(0)
  8160  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
  8161  		v1.AuxInt = int32ToAuxInt(4)
  8162  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
  8163  		v2.AddArg3(ptr, v0, mem)
  8164  		v1.AddArg3(ptr, v0, v2)
  8165  		v.AddArg3(ptr, v0, v1)
  8166  		return true
  8167  	}
  8168  	// match: (Zero [16] {t} ptr mem)
  8169  	// cond: t.Alignment()%8 == 0
  8170  	// result: (MOVDstore [8] ptr (MOVDconst [0]) (MOVDstore ptr (MOVDconst [0]) mem))
  8171  	for {
  8172  		if auxIntToInt64(v.AuxInt) != 16 {
  8173  			break
  8174  		}
  8175  		t := auxToType(v.Aux)
  8176  		ptr := v_0
  8177  		mem := v_1
  8178  		if !(t.Alignment()%8 == 0) {
  8179  			break
  8180  		}
  8181  		v.reset(OpRISCV64MOVDstore)
  8182  		v.AuxInt = int32ToAuxInt(8)
  8183  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  8184  		v0.AuxInt = int64ToAuxInt(0)
  8185  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
  8186  		v1.AddArg3(ptr, v0, mem)
  8187  		v.AddArg3(ptr, v0, v1)
  8188  		return true
  8189  	}
  8190  	// match: (Zero [24] {t} ptr mem)
  8191  	// cond: t.Alignment()%8 == 0
  8192  	// result: (MOVDstore [16] ptr (MOVDconst [0]) (MOVDstore [8] ptr (MOVDconst [0]) (MOVDstore ptr (MOVDconst [0]) mem)))
  8193  	for {
  8194  		if auxIntToInt64(v.AuxInt) != 24 {
  8195  			break
  8196  		}
  8197  		t := auxToType(v.Aux)
  8198  		ptr := v_0
  8199  		mem := v_1
  8200  		if !(t.Alignment()%8 == 0) {
  8201  			break
  8202  		}
  8203  		v.reset(OpRISCV64MOVDstore)
  8204  		v.AuxInt = int32ToAuxInt(16)
  8205  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  8206  		v0.AuxInt = int64ToAuxInt(0)
  8207  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
  8208  		v1.AuxInt = int32ToAuxInt(8)
  8209  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
  8210  		v2.AddArg3(ptr, v0, mem)
  8211  		v1.AddArg3(ptr, v0, v2)
  8212  		v.AddArg3(ptr, v0, v1)
  8213  		return true
  8214  	}
  8215  	// match: (Zero [32] {t} ptr mem)
  8216  	// cond: t.Alignment()%8 == 0
  8217  	// result: (MOVDstore [24] ptr (MOVDconst [0]) (MOVDstore [16] ptr (MOVDconst [0]) (MOVDstore [8] ptr (MOVDconst [0]) (MOVDstore ptr (MOVDconst [0]) mem))))
  8218  	for {
  8219  		if auxIntToInt64(v.AuxInt) != 32 {
  8220  			break
  8221  		}
  8222  		t := auxToType(v.Aux)
  8223  		ptr := v_0
  8224  		mem := v_1
  8225  		if !(t.Alignment()%8 == 0) {
  8226  			break
  8227  		}
  8228  		v.reset(OpRISCV64MOVDstore)
  8229  		v.AuxInt = int32ToAuxInt(24)
  8230  		v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  8231  		v0.AuxInt = int64ToAuxInt(0)
  8232  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
  8233  		v1.AuxInt = int32ToAuxInt(16)
  8234  		v2 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
  8235  		v2.AuxInt = int32ToAuxInt(8)
  8236  		v3 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
  8237  		v3.AddArg3(ptr, v0, mem)
  8238  		v2.AddArg3(ptr, v0, v3)
  8239  		v1.AddArg3(ptr, v0, v2)
  8240  		v.AddArg3(ptr, v0, v1)
  8241  		return true
  8242  	}
  8243  	// match: (Zero [s] {t} ptr mem)
  8244  	// cond: s%8 == 0 && s <= 8*128 && t.Alignment()%8 == 0 && !config.noDuffDevice
  8245  	// result: (DUFFZERO [8 * (128 - s/8)] ptr mem)
  8246  	for {
  8247  		s := auxIntToInt64(v.AuxInt)
  8248  		t := auxToType(v.Aux)
  8249  		ptr := v_0
  8250  		mem := v_1
  8251  		if !(s%8 == 0 && s <= 8*128 && t.Alignment()%8 == 0 && !config.noDuffDevice) {
  8252  			break
  8253  		}
  8254  		v.reset(OpRISCV64DUFFZERO)
  8255  		v.AuxInt = int64ToAuxInt(8 * (128 - s/8))
  8256  		v.AddArg2(ptr, mem)
  8257  		return true
  8258  	}
  8259  	// match: (Zero [s] {t} ptr mem)
  8260  	// result: (LoweredZero [t.Alignment()] ptr (ADD <ptr.Type> ptr (MOVDconst [s-moveSize(t.Alignment(), config)])) mem)
  8261  	for {
  8262  		s := auxIntToInt64(v.AuxInt)
  8263  		t := auxToType(v.Aux)
  8264  		ptr := v_0
  8265  		mem := v_1
  8266  		v.reset(OpRISCV64LoweredZero)
  8267  		v.AuxInt = int64ToAuxInt(t.Alignment())
  8268  		v0 := b.NewValue0(v.Pos, OpRISCV64ADD, ptr.Type)
  8269  		v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
  8270  		v1.AuxInt = int64ToAuxInt(s - moveSize(t.Alignment(), config))
  8271  		v0.AddArg2(ptr, v1)
  8272  		v.AddArg3(ptr, v0, mem)
  8273  		return true
  8274  	}
  8275  }
  8276  func rewriteBlockRISCV64(b *Block) bool {
  8277  	typ := &b.Func.Config.Types
  8278  	switch b.Kind {
  8279  	case BlockRISCV64BEQ:
  8280  		// match: (BEQ (MOVDconst [0]) cond yes no)
  8281  		// result: (BEQZ cond yes no)
  8282  		for b.Controls[0].Op == OpRISCV64MOVDconst {
  8283  			v_0 := b.Controls[0]
  8284  			if auxIntToInt64(v_0.AuxInt) != 0 {
  8285  				break
  8286  			}
  8287  			cond := b.Controls[1]
  8288  			b.resetWithControl(BlockRISCV64BEQZ, cond)
  8289  			return true
  8290  		}
  8291  		// match: (BEQ cond (MOVDconst [0]) yes no)
  8292  		// result: (BEQZ cond yes no)
  8293  		for b.Controls[1].Op == OpRISCV64MOVDconst {
  8294  			cond := b.Controls[0]
  8295  			v_1 := b.Controls[1]
  8296  			if auxIntToInt64(v_1.AuxInt) != 0 {
  8297  				break
  8298  			}
  8299  			b.resetWithControl(BlockRISCV64BEQZ, cond)
  8300  			return true
  8301  		}
  8302  	case BlockRISCV64BEQZ:
  8303  		// match: (BEQZ (SEQZ x) yes no)
  8304  		// result: (BNEZ x yes no)
  8305  		for b.Controls[0].Op == OpRISCV64SEQZ {
  8306  			v_0 := b.Controls[0]
  8307  			x := v_0.Args[0]
  8308  			b.resetWithControl(BlockRISCV64BNEZ, x)
  8309  			return true
  8310  		}
  8311  		// match: (BEQZ (SNEZ x) yes no)
  8312  		// result: (BEQZ x yes no)
  8313  		for b.Controls[0].Op == OpRISCV64SNEZ {
  8314  			v_0 := b.Controls[0]
  8315  			x := v_0.Args[0]
  8316  			b.resetWithControl(BlockRISCV64BEQZ, x)
  8317  			return true
  8318  		}
  8319  		// match: (BEQZ (NEG x) yes no)
  8320  		// result: (BEQZ x yes no)
  8321  		for b.Controls[0].Op == OpRISCV64NEG {
  8322  			v_0 := b.Controls[0]
  8323  			x := v_0.Args[0]
  8324  			b.resetWithControl(BlockRISCV64BEQZ, x)
  8325  			return true
  8326  		}
  8327  		// match: (BEQZ (FNES <t> x y) yes no)
  8328  		// result: (BNEZ (FEQS <t> x y) yes no)
  8329  		for b.Controls[0].Op == OpRISCV64FNES {
  8330  			v_0 := b.Controls[0]
  8331  			t := v_0.Type
  8332  			_ = v_0.Args[1]
  8333  			v_0_0 := v_0.Args[0]
  8334  			v_0_1 := v_0.Args[1]
  8335  			for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
  8336  				x := v_0_0
  8337  				y := v_0_1
  8338  				v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQS, t)
  8339  				v0.AddArg2(x, y)
  8340  				b.resetWithControl(BlockRISCV64BNEZ, v0)
  8341  				return true
  8342  			}
  8343  		}
  8344  		// match: (BEQZ (FNED <t> x y) yes no)
  8345  		// result: (BNEZ (FEQD <t> x y) yes no)
  8346  		for b.Controls[0].Op == OpRISCV64FNED {
  8347  			v_0 := b.Controls[0]
  8348  			t := v_0.Type
  8349  			_ = v_0.Args[1]
  8350  			v_0_0 := v_0.Args[0]
  8351  			v_0_1 := v_0.Args[1]
  8352  			for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
  8353  				x := v_0_0
  8354  				y := v_0_1
  8355  				v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQD, t)
  8356  				v0.AddArg2(x, y)
  8357  				b.resetWithControl(BlockRISCV64BNEZ, v0)
  8358  				return true
  8359  			}
  8360  		}
  8361  		// match: (BEQZ (SUB x y) yes no)
  8362  		// result: (BEQ x y yes no)
  8363  		for b.Controls[0].Op == OpRISCV64SUB {
  8364  			v_0 := b.Controls[0]
  8365  			y := v_0.Args[1]
  8366  			x := v_0.Args[0]
  8367  			b.resetWithControl2(BlockRISCV64BEQ, x, y)
  8368  			return true
  8369  		}
  8370  		// match: (BEQZ (SLT x y) yes no)
  8371  		// result: (BGE x y yes no)
  8372  		for b.Controls[0].Op == OpRISCV64SLT {
  8373  			v_0 := b.Controls[0]
  8374  			y := v_0.Args[1]
  8375  			x := v_0.Args[0]
  8376  			b.resetWithControl2(BlockRISCV64BGE, x, y)
  8377  			return true
  8378  		}
  8379  		// match: (BEQZ (SLTU x y) yes no)
  8380  		// result: (BGEU x y yes no)
  8381  		for b.Controls[0].Op == OpRISCV64SLTU {
  8382  			v_0 := b.Controls[0]
  8383  			y := v_0.Args[1]
  8384  			x := v_0.Args[0]
  8385  			b.resetWithControl2(BlockRISCV64BGEU, x, y)
  8386  			return true
  8387  		}
  8388  		// match: (BEQZ (SLTI [x] y) yes no)
  8389  		// result: (BGE y (MOVDconst [x]) yes no)
  8390  		for b.Controls[0].Op == OpRISCV64SLTI {
  8391  			v_0 := b.Controls[0]
  8392  			x := auxIntToInt64(v_0.AuxInt)
  8393  			y := v_0.Args[0]
  8394  			v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
  8395  			v0.AuxInt = int64ToAuxInt(x)
  8396  			b.resetWithControl2(BlockRISCV64BGE, y, v0)
  8397  			return true
  8398  		}
  8399  		// match: (BEQZ (SLTIU [x] y) yes no)
  8400  		// result: (BGEU y (MOVDconst [x]) yes no)
  8401  		for b.Controls[0].Op == OpRISCV64SLTIU {
  8402  			v_0 := b.Controls[0]
  8403  			x := auxIntToInt64(v_0.AuxInt)
  8404  			y := v_0.Args[0]
  8405  			v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
  8406  			v0.AuxInt = int64ToAuxInt(x)
  8407  			b.resetWithControl2(BlockRISCV64BGEU, y, v0)
  8408  			return true
  8409  		}
  8410  	case BlockRISCV64BGE:
  8411  		// match: (BGE (MOVDconst [0]) cond yes no)
  8412  		// result: (BLEZ cond yes no)
  8413  		for b.Controls[0].Op == OpRISCV64MOVDconst {
  8414  			v_0 := b.Controls[0]
  8415  			if auxIntToInt64(v_0.AuxInt) != 0 {
  8416  				break
  8417  			}
  8418  			cond := b.Controls[1]
  8419  			b.resetWithControl(BlockRISCV64BLEZ, cond)
  8420  			return true
  8421  		}
  8422  		// match: (BGE cond (MOVDconst [0]) yes no)
  8423  		// result: (BGEZ cond yes no)
  8424  		for b.Controls[1].Op == OpRISCV64MOVDconst {
  8425  			cond := b.Controls[0]
  8426  			v_1 := b.Controls[1]
  8427  			if auxIntToInt64(v_1.AuxInt) != 0 {
  8428  				break
  8429  			}
  8430  			b.resetWithControl(BlockRISCV64BGEZ, cond)
  8431  			return true
  8432  		}
  8433  	case BlockRISCV64BLT:
  8434  		// match: (BLT (MOVDconst [0]) cond yes no)
  8435  		// result: (BGTZ cond yes no)
  8436  		for b.Controls[0].Op == OpRISCV64MOVDconst {
  8437  			v_0 := b.Controls[0]
  8438  			if auxIntToInt64(v_0.AuxInt) != 0 {
  8439  				break
  8440  			}
  8441  			cond := b.Controls[1]
  8442  			b.resetWithControl(BlockRISCV64BGTZ, cond)
  8443  			return true
  8444  		}
  8445  		// match: (BLT cond (MOVDconst [0]) yes no)
  8446  		// result: (BLTZ cond yes no)
  8447  		for b.Controls[1].Op == OpRISCV64MOVDconst {
  8448  			cond := b.Controls[0]
  8449  			v_1 := b.Controls[1]
  8450  			if auxIntToInt64(v_1.AuxInt) != 0 {
  8451  				break
  8452  			}
  8453  			b.resetWithControl(BlockRISCV64BLTZ, cond)
  8454  			return true
  8455  		}
  8456  	case BlockRISCV64BNE:
  8457  		// match: (BNE (MOVDconst [0]) cond yes no)
  8458  		// result: (BNEZ cond yes no)
  8459  		for b.Controls[0].Op == OpRISCV64MOVDconst {
  8460  			v_0 := b.Controls[0]
  8461  			if auxIntToInt64(v_0.AuxInt) != 0 {
  8462  				break
  8463  			}
  8464  			cond := b.Controls[1]
  8465  			b.resetWithControl(BlockRISCV64BNEZ, cond)
  8466  			return true
  8467  		}
  8468  		// match: (BNE cond (MOVDconst [0]) yes no)
  8469  		// result: (BNEZ cond yes no)
  8470  		for b.Controls[1].Op == OpRISCV64MOVDconst {
  8471  			cond := b.Controls[0]
  8472  			v_1 := b.Controls[1]
  8473  			if auxIntToInt64(v_1.AuxInt) != 0 {
  8474  				break
  8475  			}
  8476  			b.resetWithControl(BlockRISCV64BNEZ, cond)
  8477  			return true
  8478  		}
  8479  	case BlockRISCV64BNEZ:
  8480  		// match: (BNEZ (SEQZ x) yes no)
  8481  		// result: (BEQZ x yes no)
  8482  		for b.Controls[0].Op == OpRISCV64SEQZ {
  8483  			v_0 := b.Controls[0]
  8484  			x := v_0.Args[0]
  8485  			b.resetWithControl(BlockRISCV64BEQZ, x)
  8486  			return true
  8487  		}
  8488  		// match: (BNEZ (SNEZ x) yes no)
  8489  		// result: (BNEZ x yes no)
  8490  		for b.Controls[0].Op == OpRISCV64SNEZ {
  8491  			v_0 := b.Controls[0]
  8492  			x := v_0.Args[0]
  8493  			b.resetWithControl(BlockRISCV64BNEZ, x)
  8494  			return true
  8495  		}
  8496  		// match: (BNEZ (NEG x) yes no)
  8497  		// result: (BNEZ x yes no)
  8498  		for b.Controls[0].Op == OpRISCV64NEG {
  8499  			v_0 := b.Controls[0]
  8500  			x := v_0.Args[0]
  8501  			b.resetWithControl(BlockRISCV64BNEZ, x)
  8502  			return true
  8503  		}
  8504  		// match: (BNEZ (FNES <t> x y) yes no)
  8505  		// result: (BEQZ (FEQS <t> x y) yes no)
  8506  		for b.Controls[0].Op == OpRISCV64FNES {
  8507  			v_0 := b.Controls[0]
  8508  			t := v_0.Type
  8509  			_ = v_0.Args[1]
  8510  			v_0_0 := v_0.Args[0]
  8511  			v_0_1 := v_0.Args[1]
  8512  			for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
  8513  				x := v_0_0
  8514  				y := v_0_1
  8515  				v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQS, t)
  8516  				v0.AddArg2(x, y)
  8517  				b.resetWithControl(BlockRISCV64BEQZ, v0)
  8518  				return true
  8519  			}
  8520  		}
  8521  		// match: (BNEZ (FNED <t> x y) yes no)
  8522  		// result: (BEQZ (FEQD <t> x y) yes no)
  8523  		for b.Controls[0].Op == OpRISCV64FNED {
  8524  			v_0 := b.Controls[0]
  8525  			t := v_0.Type
  8526  			_ = v_0.Args[1]
  8527  			v_0_0 := v_0.Args[0]
  8528  			v_0_1 := v_0.Args[1]
  8529  			for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
  8530  				x := v_0_0
  8531  				y := v_0_1
  8532  				v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQD, t)
  8533  				v0.AddArg2(x, y)
  8534  				b.resetWithControl(BlockRISCV64BEQZ, v0)
  8535  				return true
  8536  			}
  8537  		}
  8538  		// match: (BNEZ (SUB x y) yes no)
  8539  		// result: (BNE x y yes no)
  8540  		for b.Controls[0].Op == OpRISCV64SUB {
  8541  			v_0 := b.Controls[0]
  8542  			y := v_0.Args[1]
  8543  			x := v_0.Args[0]
  8544  			b.resetWithControl2(BlockRISCV64BNE, x, y)
  8545  			return true
  8546  		}
  8547  		// match: (BNEZ (SLT x y) yes no)
  8548  		// result: (BLT x y yes no)
  8549  		for b.Controls[0].Op == OpRISCV64SLT {
  8550  			v_0 := b.Controls[0]
  8551  			y := v_0.Args[1]
  8552  			x := v_0.Args[0]
  8553  			b.resetWithControl2(BlockRISCV64BLT, x, y)
  8554  			return true
  8555  		}
  8556  		// match: (BNEZ (SLTU x y) yes no)
  8557  		// result: (BLTU x y yes no)
  8558  		for b.Controls[0].Op == OpRISCV64SLTU {
  8559  			v_0 := b.Controls[0]
  8560  			y := v_0.Args[1]
  8561  			x := v_0.Args[0]
  8562  			b.resetWithControl2(BlockRISCV64BLTU, x, y)
  8563  			return true
  8564  		}
  8565  		// match: (BNEZ (SLTI [x] y) yes no)
  8566  		// result: (BLT y (MOVDconst [x]) yes no)
  8567  		for b.Controls[0].Op == OpRISCV64SLTI {
  8568  			v_0 := b.Controls[0]
  8569  			x := auxIntToInt64(v_0.AuxInt)
  8570  			y := v_0.Args[0]
  8571  			v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
  8572  			v0.AuxInt = int64ToAuxInt(x)
  8573  			b.resetWithControl2(BlockRISCV64BLT, y, v0)
  8574  			return true
  8575  		}
  8576  		// match: (BNEZ (SLTIU [x] y) yes no)
  8577  		// result: (BLTU y (MOVDconst [x]) yes no)
  8578  		for b.Controls[0].Op == OpRISCV64SLTIU {
  8579  			v_0 := b.Controls[0]
  8580  			x := auxIntToInt64(v_0.AuxInt)
  8581  			y := v_0.Args[0]
  8582  			v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
  8583  			v0.AuxInt = int64ToAuxInt(x)
  8584  			b.resetWithControl2(BlockRISCV64BLTU, y, v0)
  8585  			return true
  8586  		}
  8587  	case BlockIf:
  8588  		// match: (If cond yes no)
  8589  		// result: (BNEZ (MOVBUreg <typ.UInt64> cond) yes no)
  8590  		for {
  8591  			cond := b.Controls[0]
  8592  			v0 := b.NewValue0(cond.Pos, OpRISCV64MOVBUreg, typ.UInt64)
  8593  			v0.AddArg(cond)
  8594  			b.resetWithControl(BlockRISCV64BNEZ, v0)
  8595  			return true
  8596  		}
  8597  	}
  8598  	return false
  8599  }