...
Run Format

Source file src/cmd/compile/internal/ssa/rewriteS390X.go

Documentation: cmd/compile/internal/ssa

     1  // Code generated from gen/S390X.rules; DO NOT EDIT.
     2  // generated with: cd gen; go run *.go
     3  
     4  package ssa
     5  
     6  import "fmt"
     7  import "math"
     8  import "cmd/internal/obj"
     9  import "cmd/internal/objabi"
    10  import "cmd/compile/internal/types"
    11  
    12  var _ = fmt.Println   // in case not otherwise used
    13  var _ = math.MinInt8  // in case not otherwise used
    14  var _ = obj.ANOP      // in case not otherwise used
    15  var _ = objabi.GOROOT // in case not otherwise used
    16  var _ = types.TypeMem // in case not otherwise used
    17  
    18  func rewriteValueS390X(v *Value) bool {
    19  	switch v.Op {
    20  	case OpAdd16:
    21  		return rewriteValueS390X_OpAdd16_0(v)
    22  	case OpAdd32:
    23  		return rewriteValueS390X_OpAdd32_0(v)
    24  	case OpAdd32F:
    25  		return rewriteValueS390X_OpAdd32F_0(v)
    26  	case OpAdd64:
    27  		return rewriteValueS390X_OpAdd64_0(v)
    28  	case OpAdd64F:
    29  		return rewriteValueS390X_OpAdd64F_0(v)
    30  	case OpAdd8:
    31  		return rewriteValueS390X_OpAdd8_0(v)
    32  	case OpAddPtr:
    33  		return rewriteValueS390X_OpAddPtr_0(v)
    34  	case OpAddr:
    35  		return rewriteValueS390X_OpAddr_0(v)
    36  	case OpAnd16:
    37  		return rewriteValueS390X_OpAnd16_0(v)
    38  	case OpAnd32:
    39  		return rewriteValueS390X_OpAnd32_0(v)
    40  	case OpAnd64:
    41  		return rewriteValueS390X_OpAnd64_0(v)
    42  	case OpAnd8:
    43  		return rewriteValueS390X_OpAnd8_0(v)
    44  	case OpAndB:
    45  		return rewriteValueS390X_OpAndB_0(v)
    46  	case OpAtomicAdd32:
    47  		return rewriteValueS390X_OpAtomicAdd32_0(v)
    48  	case OpAtomicAdd64:
    49  		return rewriteValueS390X_OpAtomicAdd64_0(v)
    50  	case OpAtomicCompareAndSwap32:
    51  		return rewriteValueS390X_OpAtomicCompareAndSwap32_0(v)
    52  	case OpAtomicCompareAndSwap64:
    53  		return rewriteValueS390X_OpAtomicCompareAndSwap64_0(v)
    54  	case OpAtomicExchange32:
    55  		return rewriteValueS390X_OpAtomicExchange32_0(v)
    56  	case OpAtomicExchange64:
    57  		return rewriteValueS390X_OpAtomicExchange64_0(v)
    58  	case OpAtomicLoad32:
    59  		return rewriteValueS390X_OpAtomicLoad32_0(v)
    60  	case OpAtomicLoad64:
    61  		return rewriteValueS390X_OpAtomicLoad64_0(v)
    62  	case OpAtomicLoadPtr:
    63  		return rewriteValueS390X_OpAtomicLoadPtr_0(v)
    64  	case OpAtomicStore32:
    65  		return rewriteValueS390X_OpAtomicStore32_0(v)
    66  	case OpAtomicStore64:
    67  		return rewriteValueS390X_OpAtomicStore64_0(v)
    68  	case OpAtomicStorePtrNoWB:
    69  		return rewriteValueS390X_OpAtomicStorePtrNoWB_0(v)
    70  	case OpAvg64u:
    71  		return rewriteValueS390X_OpAvg64u_0(v)
    72  	case OpBitLen64:
    73  		return rewriteValueS390X_OpBitLen64_0(v)
    74  	case OpBswap32:
    75  		return rewriteValueS390X_OpBswap32_0(v)
    76  	case OpBswap64:
    77  		return rewriteValueS390X_OpBswap64_0(v)
    78  	case OpCeil:
    79  		return rewriteValueS390X_OpCeil_0(v)
    80  	case OpClosureCall:
    81  		return rewriteValueS390X_OpClosureCall_0(v)
    82  	case OpCom16:
    83  		return rewriteValueS390X_OpCom16_0(v)
    84  	case OpCom32:
    85  		return rewriteValueS390X_OpCom32_0(v)
    86  	case OpCom64:
    87  		return rewriteValueS390X_OpCom64_0(v)
    88  	case OpCom8:
    89  		return rewriteValueS390X_OpCom8_0(v)
    90  	case OpConst16:
    91  		return rewriteValueS390X_OpConst16_0(v)
    92  	case OpConst32:
    93  		return rewriteValueS390X_OpConst32_0(v)
    94  	case OpConst32F:
    95  		return rewriteValueS390X_OpConst32F_0(v)
    96  	case OpConst64:
    97  		return rewriteValueS390X_OpConst64_0(v)
    98  	case OpConst64F:
    99  		return rewriteValueS390X_OpConst64F_0(v)
   100  	case OpConst8:
   101  		return rewriteValueS390X_OpConst8_0(v)
   102  	case OpConstBool:
   103  		return rewriteValueS390X_OpConstBool_0(v)
   104  	case OpConstNil:
   105  		return rewriteValueS390X_OpConstNil_0(v)
   106  	case OpCtz32:
   107  		return rewriteValueS390X_OpCtz32_0(v)
   108  	case OpCtz32NonZero:
   109  		return rewriteValueS390X_OpCtz32NonZero_0(v)
   110  	case OpCtz64:
   111  		return rewriteValueS390X_OpCtz64_0(v)
   112  	case OpCtz64NonZero:
   113  		return rewriteValueS390X_OpCtz64NonZero_0(v)
   114  	case OpCvt32Fto32:
   115  		return rewriteValueS390X_OpCvt32Fto32_0(v)
   116  	case OpCvt32Fto64:
   117  		return rewriteValueS390X_OpCvt32Fto64_0(v)
   118  	case OpCvt32Fto64F:
   119  		return rewriteValueS390X_OpCvt32Fto64F_0(v)
   120  	case OpCvt32to32F:
   121  		return rewriteValueS390X_OpCvt32to32F_0(v)
   122  	case OpCvt32to64F:
   123  		return rewriteValueS390X_OpCvt32to64F_0(v)
   124  	case OpCvt64Fto32:
   125  		return rewriteValueS390X_OpCvt64Fto32_0(v)
   126  	case OpCvt64Fto32F:
   127  		return rewriteValueS390X_OpCvt64Fto32F_0(v)
   128  	case OpCvt64Fto64:
   129  		return rewriteValueS390X_OpCvt64Fto64_0(v)
   130  	case OpCvt64to32F:
   131  		return rewriteValueS390X_OpCvt64to32F_0(v)
   132  	case OpCvt64to64F:
   133  		return rewriteValueS390X_OpCvt64to64F_0(v)
   134  	case OpDiv16:
   135  		return rewriteValueS390X_OpDiv16_0(v)
   136  	case OpDiv16u:
   137  		return rewriteValueS390X_OpDiv16u_0(v)
   138  	case OpDiv32:
   139  		return rewriteValueS390X_OpDiv32_0(v)
   140  	case OpDiv32F:
   141  		return rewriteValueS390X_OpDiv32F_0(v)
   142  	case OpDiv32u:
   143  		return rewriteValueS390X_OpDiv32u_0(v)
   144  	case OpDiv64:
   145  		return rewriteValueS390X_OpDiv64_0(v)
   146  	case OpDiv64F:
   147  		return rewriteValueS390X_OpDiv64F_0(v)
   148  	case OpDiv64u:
   149  		return rewriteValueS390X_OpDiv64u_0(v)
   150  	case OpDiv8:
   151  		return rewriteValueS390X_OpDiv8_0(v)
   152  	case OpDiv8u:
   153  		return rewriteValueS390X_OpDiv8u_0(v)
   154  	case OpEq16:
   155  		return rewriteValueS390X_OpEq16_0(v)
   156  	case OpEq32:
   157  		return rewriteValueS390X_OpEq32_0(v)
   158  	case OpEq32F:
   159  		return rewriteValueS390X_OpEq32F_0(v)
   160  	case OpEq64:
   161  		return rewriteValueS390X_OpEq64_0(v)
   162  	case OpEq64F:
   163  		return rewriteValueS390X_OpEq64F_0(v)
   164  	case OpEq8:
   165  		return rewriteValueS390X_OpEq8_0(v)
   166  	case OpEqB:
   167  		return rewriteValueS390X_OpEqB_0(v)
   168  	case OpEqPtr:
   169  		return rewriteValueS390X_OpEqPtr_0(v)
   170  	case OpFloor:
   171  		return rewriteValueS390X_OpFloor_0(v)
   172  	case OpGeq16:
   173  		return rewriteValueS390X_OpGeq16_0(v)
   174  	case OpGeq16U:
   175  		return rewriteValueS390X_OpGeq16U_0(v)
   176  	case OpGeq32:
   177  		return rewriteValueS390X_OpGeq32_0(v)
   178  	case OpGeq32F:
   179  		return rewriteValueS390X_OpGeq32F_0(v)
   180  	case OpGeq32U:
   181  		return rewriteValueS390X_OpGeq32U_0(v)
   182  	case OpGeq64:
   183  		return rewriteValueS390X_OpGeq64_0(v)
   184  	case OpGeq64F:
   185  		return rewriteValueS390X_OpGeq64F_0(v)
   186  	case OpGeq64U:
   187  		return rewriteValueS390X_OpGeq64U_0(v)
   188  	case OpGeq8:
   189  		return rewriteValueS390X_OpGeq8_0(v)
   190  	case OpGeq8U:
   191  		return rewriteValueS390X_OpGeq8U_0(v)
   192  	case OpGetCallerPC:
   193  		return rewriteValueS390X_OpGetCallerPC_0(v)
   194  	case OpGetCallerSP:
   195  		return rewriteValueS390X_OpGetCallerSP_0(v)
   196  	case OpGetClosurePtr:
   197  		return rewriteValueS390X_OpGetClosurePtr_0(v)
   198  	case OpGetG:
   199  		return rewriteValueS390X_OpGetG_0(v)
   200  	case OpGreater16:
   201  		return rewriteValueS390X_OpGreater16_0(v)
   202  	case OpGreater16U:
   203  		return rewriteValueS390X_OpGreater16U_0(v)
   204  	case OpGreater32:
   205  		return rewriteValueS390X_OpGreater32_0(v)
   206  	case OpGreater32F:
   207  		return rewriteValueS390X_OpGreater32F_0(v)
   208  	case OpGreater32U:
   209  		return rewriteValueS390X_OpGreater32U_0(v)
   210  	case OpGreater64:
   211  		return rewriteValueS390X_OpGreater64_0(v)
   212  	case OpGreater64F:
   213  		return rewriteValueS390X_OpGreater64F_0(v)
   214  	case OpGreater64U:
   215  		return rewriteValueS390X_OpGreater64U_0(v)
   216  	case OpGreater8:
   217  		return rewriteValueS390X_OpGreater8_0(v)
   218  	case OpGreater8U:
   219  		return rewriteValueS390X_OpGreater8U_0(v)
   220  	case OpHmul32:
   221  		return rewriteValueS390X_OpHmul32_0(v)
   222  	case OpHmul32u:
   223  		return rewriteValueS390X_OpHmul32u_0(v)
   224  	case OpHmul64:
   225  		return rewriteValueS390X_OpHmul64_0(v)
   226  	case OpHmul64u:
   227  		return rewriteValueS390X_OpHmul64u_0(v)
   228  	case OpITab:
   229  		return rewriteValueS390X_OpITab_0(v)
   230  	case OpInterCall:
   231  		return rewriteValueS390X_OpInterCall_0(v)
   232  	case OpIsInBounds:
   233  		return rewriteValueS390X_OpIsInBounds_0(v)
   234  	case OpIsNonNil:
   235  		return rewriteValueS390X_OpIsNonNil_0(v)
   236  	case OpIsSliceInBounds:
   237  		return rewriteValueS390X_OpIsSliceInBounds_0(v)
   238  	case OpLeq16:
   239  		return rewriteValueS390X_OpLeq16_0(v)
   240  	case OpLeq16U:
   241  		return rewriteValueS390X_OpLeq16U_0(v)
   242  	case OpLeq32:
   243  		return rewriteValueS390X_OpLeq32_0(v)
   244  	case OpLeq32F:
   245  		return rewriteValueS390X_OpLeq32F_0(v)
   246  	case OpLeq32U:
   247  		return rewriteValueS390X_OpLeq32U_0(v)
   248  	case OpLeq64:
   249  		return rewriteValueS390X_OpLeq64_0(v)
   250  	case OpLeq64F:
   251  		return rewriteValueS390X_OpLeq64F_0(v)
   252  	case OpLeq64U:
   253  		return rewriteValueS390X_OpLeq64U_0(v)
   254  	case OpLeq8:
   255  		return rewriteValueS390X_OpLeq8_0(v)
   256  	case OpLeq8U:
   257  		return rewriteValueS390X_OpLeq8U_0(v)
   258  	case OpLess16:
   259  		return rewriteValueS390X_OpLess16_0(v)
   260  	case OpLess16U:
   261  		return rewriteValueS390X_OpLess16U_0(v)
   262  	case OpLess32:
   263  		return rewriteValueS390X_OpLess32_0(v)
   264  	case OpLess32F:
   265  		return rewriteValueS390X_OpLess32F_0(v)
   266  	case OpLess32U:
   267  		return rewriteValueS390X_OpLess32U_0(v)
   268  	case OpLess64:
   269  		return rewriteValueS390X_OpLess64_0(v)
   270  	case OpLess64F:
   271  		return rewriteValueS390X_OpLess64F_0(v)
   272  	case OpLess64U:
   273  		return rewriteValueS390X_OpLess64U_0(v)
   274  	case OpLess8:
   275  		return rewriteValueS390X_OpLess8_0(v)
   276  	case OpLess8U:
   277  		return rewriteValueS390X_OpLess8U_0(v)
   278  	case OpLoad:
   279  		return rewriteValueS390X_OpLoad_0(v)
   280  	case OpLocalAddr:
   281  		return rewriteValueS390X_OpLocalAddr_0(v)
   282  	case OpLsh16x16:
   283  		return rewriteValueS390X_OpLsh16x16_0(v)
   284  	case OpLsh16x32:
   285  		return rewriteValueS390X_OpLsh16x32_0(v)
   286  	case OpLsh16x64:
   287  		return rewriteValueS390X_OpLsh16x64_0(v)
   288  	case OpLsh16x8:
   289  		return rewriteValueS390X_OpLsh16x8_0(v)
   290  	case OpLsh32x16:
   291  		return rewriteValueS390X_OpLsh32x16_0(v)
   292  	case OpLsh32x32:
   293  		return rewriteValueS390X_OpLsh32x32_0(v)
   294  	case OpLsh32x64:
   295  		return rewriteValueS390X_OpLsh32x64_0(v)
   296  	case OpLsh32x8:
   297  		return rewriteValueS390X_OpLsh32x8_0(v)
   298  	case OpLsh64x16:
   299  		return rewriteValueS390X_OpLsh64x16_0(v)
   300  	case OpLsh64x32:
   301  		return rewriteValueS390X_OpLsh64x32_0(v)
   302  	case OpLsh64x64:
   303  		return rewriteValueS390X_OpLsh64x64_0(v)
   304  	case OpLsh64x8:
   305  		return rewriteValueS390X_OpLsh64x8_0(v)
   306  	case OpLsh8x16:
   307  		return rewriteValueS390X_OpLsh8x16_0(v)
   308  	case OpLsh8x32:
   309  		return rewriteValueS390X_OpLsh8x32_0(v)
   310  	case OpLsh8x64:
   311  		return rewriteValueS390X_OpLsh8x64_0(v)
   312  	case OpLsh8x8:
   313  		return rewriteValueS390X_OpLsh8x8_0(v)
   314  	case OpMod16:
   315  		return rewriteValueS390X_OpMod16_0(v)
   316  	case OpMod16u:
   317  		return rewriteValueS390X_OpMod16u_0(v)
   318  	case OpMod32:
   319  		return rewriteValueS390X_OpMod32_0(v)
   320  	case OpMod32u:
   321  		return rewriteValueS390X_OpMod32u_0(v)
   322  	case OpMod64:
   323  		return rewriteValueS390X_OpMod64_0(v)
   324  	case OpMod64u:
   325  		return rewriteValueS390X_OpMod64u_0(v)
   326  	case OpMod8:
   327  		return rewriteValueS390X_OpMod8_0(v)
   328  	case OpMod8u:
   329  		return rewriteValueS390X_OpMod8u_0(v)
   330  	case OpMove:
   331  		return rewriteValueS390X_OpMove_0(v) || rewriteValueS390X_OpMove_10(v)
   332  	case OpMul16:
   333  		return rewriteValueS390X_OpMul16_0(v)
   334  	case OpMul32:
   335  		return rewriteValueS390X_OpMul32_0(v)
   336  	case OpMul32F:
   337  		return rewriteValueS390X_OpMul32F_0(v)
   338  	case OpMul64:
   339  		return rewriteValueS390X_OpMul64_0(v)
   340  	case OpMul64F:
   341  		return rewriteValueS390X_OpMul64F_0(v)
   342  	case OpMul8:
   343  		return rewriteValueS390X_OpMul8_0(v)
   344  	case OpNeg16:
   345  		return rewriteValueS390X_OpNeg16_0(v)
   346  	case OpNeg32:
   347  		return rewriteValueS390X_OpNeg32_0(v)
   348  	case OpNeg32F:
   349  		return rewriteValueS390X_OpNeg32F_0(v)
   350  	case OpNeg64:
   351  		return rewriteValueS390X_OpNeg64_0(v)
   352  	case OpNeg64F:
   353  		return rewriteValueS390X_OpNeg64F_0(v)
   354  	case OpNeg8:
   355  		return rewriteValueS390X_OpNeg8_0(v)
   356  	case OpNeq16:
   357  		return rewriteValueS390X_OpNeq16_0(v)
   358  	case OpNeq32:
   359  		return rewriteValueS390X_OpNeq32_0(v)
   360  	case OpNeq32F:
   361  		return rewriteValueS390X_OpNeq32F_0(v)
   362  	case OpNeq64:
   363  		return rewriteValueS390X_OpNeq64_0(v)
   364  	case OpNeq64F:
   365  		return rewriteValueS390X_OpNeq64F_0(v)
   366  	case OpNeq8:
   367  		return rewriteValueS390X_OpNeq8_0(v)
   368  	case OpNeqB:
   369  		return rewriteValueS390X_OpNeqB_0(v)
   370  	case OpNeqPtr:
   371  		return rewriteValueS390X_OpNeqPtr_0(v)
   372  	case OpNilCheck:
   373  		return rewriteValueS390X_OpNilCheck_0(v)
   374  	case OpNot:
   375  		return rewriteValueS390X_OpNot_0(v)
   376  	case OpOffPtr:
   377  		return rewriteValueS390X_OpOffPtr_0(v)
   378  	case OpOr16:
   379  		return rewriteValueS390X_OpOr16_0(v)
   380  	case OpOr32:
   381  		return rewriteValueS390X_OpOr32_0(v)
   382  	case OpOr64:
   383  		return rewriteValueS390X_OpOr64_0(v)
   384  	case OpOr8:
   385  		return rewriteValueS390X_OpOr8_0(v)
   386  	case OpOrB:
   387  		return rewriteValueS390X_OpOrB_0(v)
   388  	case OpPopCount16:
   389  		return rewriteValueS390X_OpPopCount16_0(v)
   390  	case OpPopCount32:
   391  		return rewriteValueS390X_OpPopCount32_0(v)
   392  	case OpPopCount64:
   393  		return rewriteValueS390X_OpPopCount64_0(v)
   394  	case OpPopCount8:
   395  		return rewriteValueS390X_OpPopCount8_0(v)
   396  	case OpRotateLeft32:
   397  		return rewriteValueS390X_OpRotateLeft32_0(v)
   398  	case OpRotateLeft64:
   399  		return rewriteValueS390X_OpRotateLeft64_0(v)
   400  	case OpRound:
   401  		return rewriteValueS390X_OpRound_0(v)
   402  	case OpRound32F:
   403  		return rewriteValueS390X_OpRound32F_0(v)
   404  	case OpRound64F:
   405  		return rewriteValueS390X_OpRound64F_0(v)
   406  	case OpRoundToEven:
   407  		return rewriteValueS390X_OpRoundToEven_0(v)
   408  	case OpRsh16Ux16:
   409  		return rewriteValueS390X_OpRsh16Ux16_0(v)
   410  	case OpRsh16Ux32:
   411  		return rewriteValueS390X_OpRsh16Ux32_0(v)
   412  	case OpRsh16Ux64:
   413  		return rewriteValueS390X_OpRsh16Ux64_0(v)
   414  	case OpRsh16Ux8:
   415  		return rewriteValueS390X_OpRsh16Ux8_0(v)
   416  	case OpRsh16x16:
   417  		return rewriteValueS390X_OpRsh16x16_0(v)
   418  	case OpRsh16x32:
   419  		return rewriteValueS390X_OpRsh16x32_0(v)
   420  	case OpRsh16x64:
   421  		return rewriteValueS390X_OpRsh16x64_0(v)
   422  	case OpRsh16x8:
   423  		return rewriteValueS390X_OpRsh16x8_0(v)
   424  	case OpRsh32Ux16:
   425  		return rewriteValueS390X_OpRsh32Ux16_0(v)
   426  	case OpRsh32Ux32:
   427  		return rewriteValueS390X_OpRsh32Ux32_0(v)
   428  	case OpRsh32Ux64:
   429  		return rewriteValueS390X_OpRsh32Ux64_0(v)
   430  	case OpRsh32Ux8:
   431  		return rewriteValueS390X_OpRsh32Ux8_0(v)
   432  	case OpRsh32x16:
   433  		return rewriteValueS390X_OpRsh32x16_0(v)
   434  	case OpRsh32x32:
   435  		return rewriteValueS390X_OpRsh32x32_0(v)
   436  	case OpRsh32x64:
   437  		return rewriteValueS390X_OpRsh32x64_0(v)
   438  	case OpRsh32x8:
   439  		return rewriteValueS390X_OpRsh32x8_0(v)
   440  	case OpRsh64Ux16:
   441  		return rewriteValueS390X_OpRsh64Ux16_0(v)
   442  	case OpRsh64Ux32:
   443  		return rewriteValueS390X_OpRsh64Ux32_0(v)
   444  	case OpRsh64Ux64:
   445  		return rewriteValueS390X_OpRsh64Ux64_0(v)
   446  	case OpRsh64Ux8:
   447  		return rewriteValueS390X_OpRsh64Ux8_0(v)
   448  	case OpRsh64x16:
   449  		return rewriteValueS390X_OpRsh64x16_0(v)
   450  	case OpRsh64x32:
   451  		return rewriteValueS390X_OpRsh64x32_0(v)
   452  	case OpRsh64x64:
   453  		return rewriteValueS390X_OpRsh64x64_0(v)
   454  	case OpRsh64x8:
   455  		return rewriteValueS390X_OpRsh64x8_0(v)
   456  	case OpRsh8Ux16:
   457  		return rewriteValueS390X_OpRsh8Ux16_0(v)
   458  	case OpRsh8Ux32:
   459  		return rewriteValueS390X_OpRsh8Ux32_0(v)
   460  	case OpRsh8Ux64:
   461  		return rewriteValueS390X_OpRsh8Ux64_0(v)
   462  	case OpRsh8Ux8:
   463  		return rewriteValueS390X_OpRsh8Ux8_0(v)
   464  	case OpRsh8x16:
   465  		return rewriteValueS390X_OpRsh8x16_0(v)
   466  	case OpRsh8x32:
   467  		return rewriteValueS390X_OpRsh8x32_0(v)
   468  	case OpRsh8x64:
   469  		return rewriteValueS390X_OpRsh8x64_0(v)
   470  	case OpRsh8x8:
   471  		return rewriteValueS390X_OpRsh8x8_0(v)
   472  	case OpS390XADD:
   473  		return rewriteValueS390X_OpS390XADD_0(v) || rewriteValueS390X_OpS390XADD_10(v)
   474  	case OpS390XADDW:
   475  		return rewriteValueS390X_OpS390XADDW_0(v) || rewriteValueS390X_OpS390XADDW_10(v)
   476  	case OpS390XADDWconst:
   477  		return rewriteValueS390X_OpS390XADDWconst_0(v)
   478  	case OpS390XADDWload:
   479  		return rewriteValueS390X_OpS390XADDWload_0(v)
   480  	case OpS390XADDconst:
   481  		return rewriteValueS390X_OpS390XADDconst_0(v)
   482  	case OpS390XADDload:
   483  		return rewriteValueS390X_OpS390XADDload_0(v)
   484  	case OpS390XAND:
   485  		return rewriteValueS390X_OpS390XAND_0(v) || rewriteValueS390X_OpS390XAND_10(v)
   486  	case OpS390XANDW:
   487  		return rewriteValueS390X_OpS390XANDW_0(v) || rewriteValueS390X_OpS390XANDW_10(v)
   488  	case OpS390XANDWconst:
   489  		return rewriteValueS390X_OpS390XANDWconst_0(v)
   490  	case OpS390XANDWload:
   491  		return rewriteValueS390X_OpS390XANDWload_0(v)
   492  	case OpS390XANDconst:
   493  		return rewriteValueS390X_OpS390XANDconst_0(v)
   494  	case OpS390XANDload:
   495  		return rewriteValueS390X_OpS390XANDload_0(v)
   496  	case OpS390XCMP:
   497  		return rewriteValueS390X_OpS390XCMP_0(v)
   498  	case OpS390XCMPU:
   499  		return rewriteValueS390X_OpS390XCMPU_0(v)
   500  	case OpS390XCMPUconst:
   501  		return rewriteValueS390X_OpS390XCMPUconst_0(v) || rewriteValueS390X_OpS390XCMPUconst_10(v)
   502  	case OpS390XCMPW:
   503  		return rewriteValueS390X_OpS390XCMPW_0(v)
   504  	case OpS390XCMPWU:
   505  		return rewriteValueS390X_OpS390XCMPWU_0(v)
   506  	case OpS390XCMPWUconst:
   507  		return rewriteValueS390X_OpS390XCMPWUconst_0(v)
   508  	case OpS390XCMPWconst:
   509  		return rewriteValueS390X_OpS390XCMPWconst_0(v)
   510  	case OpS390XCMPconst:
   511  		return rewriteValueS390X_OpS390XCMPconst_0(v) || rewriteValueS390X_OpS390XCMPconst_10(v)
   512  	case OpS390XCPSDR:
   513  		return rewriteValueS390X_OpS390XCPSDR_0(v)
   514  	case OpS390XFADD:
   515  		return rewriteValueS390X_OpS390XFADD_0(v)
   516  	case OpS390XFADDS:
   517  		return rewriteValueS390X_OpS390XFADDS_0(v)
   518  	case OpS390XFMOVDload:
   519  		return rewriteValueS390X_OpS390XFMOVDload_0(v)
   520  	case OpS390XFMOVDloadidx:
   521  		return rewriteValueS390X_OpS390XFMOVDloadidx_0(v)
   522  	case OpS390XFMOVDstore:
   523  		return rewriteValueS390X_OpS390XFMOVDstore_0(v)
   524  	case OpS390XFMOVDstoreidx:
   525  		return rewriteValueS390X_OpS390XFMOVDstoreidx_0(v)
   526  	case OpS390XFMOVSload:
   527  		return rewriteValueS390X_OpS390XFMOVSload_0(v)
   528  	case OpS390XFMOVSloadidx:
   529  		return rewriteValueS390X_OpS390XFMOVSloadidx_0(v)
   530  	case OpS390XFMOVSstore:
   531  		return rewriteValueS390X_OpS390XFMOVSstore_0(v)
   532  	case OpS390XFMOVSstoreidx:
   533  		return rewriteValueS390X_OpS390XFMOVSstoreidx_0(v)
   534  	case OpS390XFNEG:
   535  		return rewriteValueS390X_OpS390XFNEG_0(v)
   536  	case OpS390XFNEGS:
   537  		return rewriteValueS390X_OpS390XFNEGS_0(v)
   538  	case OpS390XFSUB:
   539  		return rewriteValueS390X_OpS390XFSUB_0(v)
   540  	case OpS390XFSUBS:
   541  		return rewriteValueS390X_OpS390XFSUBS_0(v)
   542  	case OpS390XLDGR:
   543  		return rewriteValueS390X_OpS390XLDGR_0(v)
   544  	case OpS390XLEDBR:
   545  		return rewriteValueS390X_OpS390XLEDBR_0(v)
   546  	case OpS390XLGDR:
   547  		return rewriteValueS390X_OpS390XLGDR_0(v)
   548  	case OpS390XLoweredRound32F:
   549  		return rewriteValueS390X_OpS390XLoweredRound32F_0(v)
   550  	case OpS390XLoweredRound64F:
   551  		return rewriteValueS390X_OpS390XLoweredRound64F_0(v)
   552  	case OpS390XMOVBZload:
   553  		return rewriteValueS390X_OpS390XMOVBZload_0(v)
   554  	case OpS390XMOVBZloadidx:
   555  		return rewriteValueS390X_OpS390XMOVBZloadidx_0(v)
   556  	case OpS390XMOVBZreg:
   557  		return rewriteValueS390X_OpS390XMOVBZreg_0(v) || rewriteValueS390X_OpS390XMOVBZreg_10(v)
   558  	case OpS390XMOVBload:
   559  		return rewriteValueS390X_OpS390XMOVBload_0(v)
   560  	case OpS390XMOVBloadidx:
   561  		return rewriteValueS390X_OpS390XMOVBloadidx_0(v)
   562  	case OpS390XMOVBreg:
   563  		return rewriteValueS390X_OpS390XMOVBreg_0(v)
   564  	case OpS390XMOVBstore:
   565  		return rewriteValueS390X_OpS390XMOVBstore_0(v) || rewriteValueS390X_OpS390XMOVBstore_10(v)
   566  	case OpS390XMOVBstoreconst:
   567  		return rewriteValueS390X_OpS390XMOVBstoreconst_0(v)
   568  	case OpS390XMOVBstoreidx:
   569  		return rewriteValueS390X_OpS390XMOVBstoreidx_0(v) || rewriteValueS390X_OpS390XMOVBstoreidx_10(v) || rewriteValueS390X_OpS390XMOVBstoreidx_20(v) || rewriteValueS390X_OpS390XMOVBstoreidx_30(v)
   570  	case OpS390XMOVDEQ:
   571  		return rewriteValueS390X_OpS390XMOVDEQ_0(v)
   572  	case OpS390XMOVDGE:
   573  		return rewriteValueS390X_OpS390XMOVDGE_0(v)
   574  	case OpS390XMOVDGT:
   575  		return rewriteValueS390X_OpS390XMOVDGT_0(v)
   576  	case OpS390XMOVDLE:
   577  		return rewriteValueS390X_OpS390XMOVDLE_0(v)
   578  	case OpS390XMOVDLT:
   579  		return rewriteValueS390X_OpS390XMOVDLT_0(v)
   580  	case OpS390XMOVDNE:
   581  		return rewriteValueS390X_OpS390XMOVDNE_0(v)
   582  	case OpS390XMOVDaddridx:
   583  		return rewriteValueS390X_OpS390XMOVDaddridx_0(v)
   584  	case OpS390XMOVDload:
   585  		return rewriteValueS390X_OpS390XMOVDload_0(v)
   586  	case OpS390XMOVDloadidx:
   587  		return rewriteValueS390X_OpS390XMOVDloadidx_0(v)
   588  	case OpS390XMOVDnop:
   589  		return rewriteValueS390X_OpS390XMOVDnop_0(v) || rewriteValueS390X_OpS390XMOVDnop_10(v)
   590  	case OpS390XMOVDreg:
   591  		return rewriteValueS390X_OpS390XMOVDreg_0(v) || rewriteValueS390X_OpS390XMOVDreg_10(v)
   592  	case OpS390XMOVDstore:
   593  		return rewriteValueS390X_OpS390XMOVDstore_0(v)
   594  	case OpS390XMOVDstoreconst:
   595  		return rewriteValueS390X_OpS390XMOVDstoreconst_0(v)
   596  	case OpS390XMOVDstoreidx:
   597  		return rewriteValueS390X_OpS390XMOVDstoreidx_0(v)
   598  	case OpS390XMOVHBRstore:
   599  		return rewriteValueS390X_OpS390XMOVHBRstore_0(v)
   600  	case OpS390XMOVHBRstoreidx:
   601  		return rewriteValueS390X_OpS390XMOVHBRstoreidx_0(v) || rewriteValueS390X_OpS390XMOVHBRstoreidx_10(v)
   602  	case OpS390XMOVHZload:
   603  		return rewriteValueS390X_OpS390XMOVHZload_0(v)
   604  	case OpS390XMOVHZloadidx:
   605  		return rewriteValueS390X_OpS390XMOVHZloadidx_0(v)
   606  	case OpS390XMOVHZreg:
   607  		return rewriteValueS390X_OpS390XMOVHZreg_0(v) || rewriteValueS390X_OpS390XMOVHZreg_10(v)
   608  	case OpS390XMOVHload:
   609  		return rewriteValueS390X_OpS390XMOVHload_0(v)
   610  	case OpS390XMOVHloadidx:
   611  		return rewriteValueS390X_OpS390XMOVHloadidx_0(v)
   612  	case OpS390XMOVHreg:
   613  		return rewriteValueS390X_OpS390XMOVHreg_0(v) || rewriteValueS390X_OpS390XMOVHreg_10(v)
   614  	case OpS390XMOVHstore:
   615  		return rewriteValueS390X_OpS390XMOVHstore_0(v) || rewriteValueS390X_OpS390XMOVHstore_10(v)
   616  	case OpS390XMOVHstoreconst:
   617  		return rewriteValueS390X_OpS390XMOVHstoreconst_0(v)
   618  	case OpS390XMOVHstoreidx:
   619  		return rewriteValueS390X_OpS390XMOVHstoreidx_0(v) || rewriteValueS390X_OpS390XMOVHstoreidx_10(v)
   620  	case OpS390XMOVWBRstore:
   621  		return rewriteValueS390X_OpS390XMOVWBRstore_0(v)
   622  	case OpS390XMOVWBRstoreidx:
   623  		return rewriteValueS390X_OpS390XMOVWBRstoreidx_0(v)
   624  	case OpS390XMOVWZload:
   625  		return rewriteValueS390X_OpS390XMOVWZload_0(v)
   626  	case OpS390XMOVWZloadidx:
   627  		return rewriteValueS390X_OpS390XMOVWZloadidx_0(v)
   628  	case OpS390XMOVWZreg:
   629  		return rewriteValueS390X_OpS390XMOVWZreg_0(v) || rewriteValueS390X_OpS390XMOVWZreg_10(v)
   630  	case OpS390XMOVWload:
   631  		return rewriteValueS390X_OpS390XMOVWload_0(v)
   632  	case OpS390XMOVWloadidx:
   633  		return rewriteValueS390X_OpS390XMOVWloadidx_0(v)
   634  	case OpS390XMOVWreg:
   635  		return rewriteValueS390X_OpS390XMOVWreg_0(v) || rewriteValueS390X_OpS390XMOVWreg_10(v)
   636  	case OpS390XMOVWstore:
   637  		return rewriteValueS390X_OpS390XMOVWstore_0(v) || rewriteValueS390X_OpS390XMOVWstore_10(v)
   638  	case OpS390XMOVWstoreconst:
   639  		return rewriteValueS390X_OpS390XMOVWstoreconst_0(v)
   640  	case OpS390XMOVWstoreidx:
   641  		return rewriteValueS390X_OpS390XMOVWstoreidx_0(v) || rewriteValueS390X_OpS390XMOVWstoreidx_10(v)
   642  	case OpS390XMULLD:
   643  		return rewriteValueS390X_OpS390XMULLD_0(v)
   644  	case OpS390XMULLDconst:
   645  		return rewriteValueS390X_OpS390XMULLDconst_0(v)
   646  	case OpS390XMULLDload:
   647  		return rewriteValueS390X_OpS390XMULLDload_0(v)
   648  	case OpS390XMULLW:
   649  		return rewriteValueS390X_OpS390XMULLW_0(v)
   650  	case OpS390XMULLWconst:
   651  		return rewriteValueS390X_OpS390XMULLWconst_0(v)
   652  	case OpS390XMULLWload:
   653  		return rewriteValueS390X_OpS390XMULLWload_0(v)
   654  	case OpS390XNEG:
   655  		return rewriteValueS390X_OpS390XNEG_0(v)
   656  	case OpS390XNEGW:
   657  		return rewriteValueS390X_OpS390XNEGW_0(v)
   658  	case OpS390XNOT:
   659  		return rewriteValueS390X_OpS390XNOT_0(v)
   660  	case OpS390XNOTW:
   661  		return rewriteValueS390X_OpS390XNOTW_0(v)
   662  	case OpS390XOR:
   663  		return rewriteValueS390X_OpS390XOR_0(v) || rewriteValueS390X_OpS390XOR_10(v) || rewriteValueS390X_OpS390XOR_20(v) || rewriteValueS390X_OpS390XOR_30(v) || rewriteValueS390X_OpS390XOR_40(v) || rewriteValueS390X_OpS390XOR_50(v) || rewriteValueS390X_OpS390XOR_60(v) || rewriteValueS390X_OpS390XOR_70(v) || rewriteValueS390X_OpS390XOR_80(v) || rewriteValueS390X_OpS390XOR_90(v) || rewriteValueS390X_OpS390XOR_100(v) || rewriteValueS390X_OpS390XOR_110(v) || rewriteValueS390X_OpS390XOR_120(v) || rewriteValueS390X_OpS390XOR_130(v) || rewriteValueS390X_OpS390XOR_140(v) || rewriteValueS390X_OpS390XOR_150(v)
   664  	case OpS390XORW:
   665  		return rewriteValueS390X_OpS390XORW_0(v) || rewriteValueS390X_OpS390XORW_10(v) || rewriteValueS390X_OpS390XORW_20(v) || rewriteValueS390X_OpS390XORW_30(v) || rewriteValueS390X_OpS390XORW_40(v) || rewriteValueS390X_OpS390XORW_50(v) || rewriteValueS390X_OpS390XORW_60(v) || rewriteValueS390X_OpS390XORW_70(v) || rewriteValueS390X_OpS390XORW_80(v) || rewriteValueS390X_OpS390XORW_90(v)
   666  	case OpS390XORWconst:
   667  		return rewriteValueS390X_OpS390XORWconst_0(v)
   668  	case OpS390XORWload:
   669  		return rewriteValueS390X_OpS390XORWload_0(v)
   670  	case OpS390XORconst:
   671  		return rewriteValueS390X_OpS390XORconst_0(v)
   672  	case OpS390XORload:
   673  		return rewriteValueS390X_OpS390XORload_0(v)
   674  	case OpS390XRLL:
   675  		return rewriteValueS390X_OpS390XRLL_0(v)
   676  	case OpS390XRLLG:
   677  		return rewriteValueS390X_OpS390XRLLG_0(v)
   678  	case OpS390XSLD:
   679  		return rewriteValueS390X_OpS390XSLD_0(v) || rewriteValueS390X_OpS390XSLD_10(v)
   680  	case OpS390XSLW:
   681  		return rewriteValueS390X_OpS390XSLW_0(v) || rewriteValueS390X_OpS390XSLW_10(v)
   682  	case OpS390XSRAD:
   683  		return rewriteValueS390X_OpS390XSRAD_0(v) || rewriteValueS390X_OpS390XSRAD_10(v)
   684  	case OpS390XSRADconst:
   685  		return rewriteValueS390X_OpS390XSRADconst_0(v)
   686  	case OpS390XSRAW:
   687  		return rewriteValueS390X_OpS390XSRAW_0(v) || rewriteValueS390X_OpS390XSRAW_10(v)
   688  	case OpS390XSRAWconst:
   689  		return rewriteValueS390X_OpS390XSRAWconst_0(v)
   690  	case OpS390XSRD:
   691  		return rewriteValueS390X_OpS390XSRD_0(v) || rewriteValueS390X_OpS390XSRD_10(v)
   692  	case OpS390XSRDconst:
   693  		return rewriteValueS390X_OpS390XSRDconst_0(v)
   694  	case OpS390XSRW:
   695  		return rewriteValueS390X_OpS390XSRW_0(v) || rewriteValueS390X_OpS390XSRW_10(v)
   696  	case OpS390XSTM2:
   697  		return rewriteValueS390X_OpS390XSTM2_0(v)
   698  	case OpS390XSTMG2:
   699  		return rewriteValueS390X_OpS390XSTMG2_0(v)
   700  	case OpS390XSUB:
   701  		return rewriteValueS390X_OpS390XSUB_0(v)
   702  	case OpS390XSUBW:
   703  		return rewriteValueS390X_OpS390XSUBW_0(v)
   704  	case OpS390XSUBWconst:
   705  		return rewriteValueS390X_OpS390XSUBWconst_0(v)
   706  	case OpS390XSUBWload:
   707  		return rewriteValueS390X_OpS390XSUBWload_0(v)
   708  	case OpS390XSUBconst:
   709  		return rewriteValueS390X_OpS390XSUBconst_0(v)
   710  	case OpS390XSUBload:
   711  		return rewriteValueS390X_OpS390XSUBload_0(v)
   712  	case OpS390XSumBytes2:
   713  		return rewriteValueS390X_OpS390XSumBytes2_0(v)
   714  	case OpS390XSumBytes4:
   715  		return rewriteValueS390X_OpS390XSumBytes4_0(v)
   716  	case OpS390XSumBytes8:
   717  		return rewriteValueS390X_OpS390XSumBytes8_0(v)
   718  	case OpS390XXOR:
   719  		return rewriteValueS390X_OpS390XXOR_0(v) || rewriteValueS390X_OpS390XXOR_10(v)
   720  	case OpS390XXORW:
   721  		return rewriteValueS390X_OpS390XXORW_0(v) || rewriteValueS390X_OpS390XXORW_10(v)
   722  	case OpS390XXORWconst:
   723  		return rewriteValueS390X_OpS390XXORWconst_0(v)
   724  	case OpS390XXORWload:
   725  		return rewriteValueS390X_OpS390XXORWload_0(v)
   726  	case OpS390XXORconst:
   727  		return rewriteValueS390X_OpS390XXORconst_0(v)
   728  	case OpS390XXORload:
   729  		return rewriteValueS390X_OpS390XXORload_0(v)
   730  	case OpSelect0:
   731  		return rewriteValueS390X_OpSelect0_0(v)
   732  	case OpSelect1:
   733  		return rewriteValueS390X_OpSelect1_0(v)
   734  	case OpSignExt16to32:
   735  		return rewriteValueS390X_OpSignExt16to32_0(v)
   736  	case OpSignExt16to64:
   737  		return rewriteValueS390X_OpSignExt16to64_0(v)
   738  	case OpSignExt32to64:
   739  		return rewriteValueS390X_OpSignExt32to64_0(v)
   740  	case OpSignExt8to16:
   741  		return rewriteValueS390X_OpSignExt8to16_0(v)
   742  	case OpSignExt8to32:
   743  		return rewriteValueS390X_OpSignExt8to32_0(v)
   744  	case OpSignExt8to64:
   745  		return rewriteValueS390X_OpSignExt8to64_0(v)
   746  	case OpSlicemask:
   747  		return rewriteValueS390X_OpSlicemask_0(v)
   748  	case OpSqrt:
   749  		return rewriteValueS390X_OpSqrt_0(v)
   750  	case OpStaticCall:
   751  		return rewriteValueS390X_OpStaticCall_0(v)
   752  	case OpStore:
   753  		return rewriteValueS390X_OpStore_0(v)
   754  	case OpSub16:
   755  		return rewriteValueS390X_OpSub16_0(v)
   756  	case OpSub32:
   757  		return rewriteValueS390X_OpSub32_0(v)
   758  	case OpSub32F:
   759  		return rewriteValueS390X_OpSub32F_0(v)
   760  	case OpSub64:
   761  		return rewriteValueS390X_OpSub64_0(v)
   762  	case OpSub64F:
   763  		return rewriteValueS390X_OpSub64F_0(v)
   764  	case OpSub8:
   765  		return rewriteValueS390X_OpSub8_0(v)
   766  	case OpSubPtr:
   767  		return rewriteValueS390X_OpSubPtr_0(v)
   768  	case OpTrunc:
   769  		return rewriteValueS390X_OpTrunc_0(v)
   770  	case OpTrunc16to8:
   771  		return rewriteValueS390X_OpTrunc16to8_0(v)
   772  	case OpTrunc32to16:
   773  		return rewriteValueS390X_OpTrunc32to16_0(v)
   774  	case OpTrunc32to8:
   775  		return rewriteValueS390X_OpTrunc32to8_0(v)
   776  	case OpTrunc64to16:
   777  		return rewriteValueS390X_OpTrunc64to16_0(v)
   778  	case OpTrunc64to32:
   779  		return rewriteValueS390X_OpTrunc64to32_0(v)
   780  	case OpTrunc64to8:
   781  		return rewriteValueS390X_OpTrunc64to8_0(v)
   782  	case OpWB:
   783  		return rewriteValueS390X_OpWB_0(v)
   784  	case OpXor16:
   785  		return rewriteValueS390X_OpXor16_0(v)
   786  	case OpXor32:
   787  		return rewriteValueS390X_OpXor32_0(v)
   788  	case OpXor64:
   789  		return rewriteValueS390X_OpXor64_0(v)
   790  	case OpXor8:
   791  		return rewriteValueS390X_OpXor8_0(v)
   792  	case OpZero:
   793  		return rewriteValueS390X_OpZero_0(v) || rewriteValueS390X_OpZero_10(v)
   794  	case OpZeroExt16to32:
   795  		return rewriteValueS390X_OpZeroExt16to32_0(v)
   796  	case OpZeroExt16to64:
   797  		return rewriteValueS390X_OpZeroExt16to64_0(v)
   798  	case OpZeroExt32to64:
   799  		return rewriteValueS390X_OpZeroExt32to64_0(v)
   800  	case OpZeroExt8to16:
   801  		return rewriteValueS390X_OpZeroExt8to16_0(v)
   802  	case OpZeroExt8to32:
   803  		return rewriteValueS390X_OpZeroExt8to32_0(v)
   804  	case OpZeroExt8to64:
   805  		return rewriteValueS390X_OpZeroExt8to64_0(v)
   806  	}
   807  	return false
   808  }
   809  func rewriteValueS390X_OpAdd16_0(v *Value) bool {
   810  	// match: (Add16 x y)
   811  	// cond:
   812  	// result: (ADDW x y)
   813  	for {
   814  		_ = v.Args[1]
   815  		x := v.Args[0]
   816  		y := v.Args[1]
   817  		v.reset(OpS390XADDW)
   818  		v.AddArg(x)
   819  		v.AddArg(y)
   820  		return true
   821  	}
   822  }
   823  func rewriteValueS390X_OpAdd32_0(v *Value) bool {
   824  	// match: (Add32 x y)
   825  	// cond:
   826  	// result: (ADDW x y)
   827  	for {
   828  		_ = v.Args[1]
   829  		x := v.Args[0]
   830  		y := v.Args[1]
   831  		v.reset(OpS390XADDW)
   832  		v.AddArg(x)
   833  		v.AddArg(y)
   834  		return true
   835  	}
   836  }
   837  func rewriteValueS390X_OpAdd32F_0(v *Value) bool {
   838  	// match: (Add32F x y)
   839  	// cond:
   840  	// result: (FADDS x y)
   841  	for {
   842  		_ = v.Args[1]
   843  		x := v.Args[0]
   844  		y := v.Args[1]
   845  		v.reset(OpS390XFADDS)
   846  		v.AddArg(x)
   847  		v.AddArg(y)
   848  		return true
   849  	}
   850  }
   851  func rewriteValueS390X_OpAdd64_0(v *Value) bool {
   852  	// match: (Add64 x y)
   853  	// cond:
   854  	// result: (ADD x y)
   855  	for {
   856  		_ = v.Args[1]
   857  		x := v.Args[0]
   858  		y := v.Args[1]
   859  		v.reset(OpS390XADD)
   860  		v.AddArg(x)
   861  		v.AddArg(y)
   862  		return true
   863  	}
   864  }
   865  func rewriteValueS390X_OpAdd64F_0(v *Value) bool {
   866  	// match: (Add64F x y)
   867  	// cond:
   868  	// result: (FADD x y)
   869  	for {
   870  		_ = v.Args[1]
   871  		x := v.Args[0]
   872  		y := v.Args[1]
   873  		v.reset(OpS390XFADD)
   874  		v.AddArg(x)
   875  		v.AddArg(y)
   876  		return true
   877  	}
   878  }
   879  func rewriteValueS390X_OpAdd8_0(v *Value) bool {
   880  	// match: (Add8 x y)
   881  	// cond:
   882  	// result: (ADDW x y)
   883  	for {
   884  		_ = v.Args[1]
   885  		x := v.Args[0]
   886  		y := v.Args[1]
   887  		v.reset(OpS390XADDW)
   888  		v.AddArg(x)
   889  		v.AddArg(y)
   890  		return true
   891  	}
   892  }
   893  func rewriteValueS390X_OpAddPtr_0(v *Value) bool {
   894  	// match: (AddPtr x y)
   895  	// cond:
   896  	// result: (ADD x y)
   897  	for {
   898  		_ = v.Args[1]
   899  		x := v.Args[0]
   900  		y := v.Args[1]
   901  		v.reset(OpS390XADD)
   902  		v.AddArg(x)
   903  		v.AddArg(y)
   904  		return true
   905  	}
   906  }
   907  func rewriteValueS390X_OpAddr_0(v *Value) bool {
   908  	// match: (Addr {sym} base)
   909  	// cond:
   910  	// result: (MOVDaddr {sym} base)
   911  	for {
   912  		sym := v.Aux
   913  		base := v.Args[0]
   914  		v.reset(OpS390XMOVDaddr)
   915  		v.Aux = sym
   916  		v.AddArg(base)
   917  		return true
   918  	}
   919  }
   920  func rewriteValueS390X_OpAnd16_0(v *Value) bool {
   921  	// match: (And16 x y)
   922  	// cond:
   923  	// result: (ANDW x y)
   924  	for {
   925  		_ = v.Args[1]
   926  		x := v.Args[0]
   927  		y := v.Args[1]
   928  		v.reset(OpS390XANDW)
   929  		v.AddArg(x)
   930  		v.AddArg(y)
   931  		return true
   932  	}
   933  }
   934  func rewriteValueS390X_OpAnd32_0(v *Value) bool {
   935  	// match: (And32 x y)
   936  	// cond:
   937  	// result: (ANDW x y)
   938  	for {
   939  		_ = v.Args[1]
   940  		x := v.Args[0]
   941  		y := v.Args[1]
   942  		v.reset(OpS390XANDW)
   943  		v.AddArg(x)
   944  		v.AddArg(y)
   945  		return true
   946  	}
   947  }
   948  func rewriteValueS390X_OpAnd64_0(v *Value) bool {
   949  	// match: (And64 x y)
   950  	// cond:
   951  	// result: (AND x y)
   952  	for {
   953  		_ = v.Args[1]
   954  		x := v.Args[0]
   955  		y := v.Args[1]
   956  		v.reset(OpS390XAND)
   957  		v.AddArg(x)
   958  		v.AddArg(y)
   959  		return true
   960  	}
   961  }
   962  func rewriteValueS390X_OpAnd8_0(v *Value) bool {
   963  	// match: (And8 x y)
   964  	// cond:
   965  	// result: (ANDW x y)
   966  	for {
   967  		_ = v.Args[1]
   968  		x := v.Args[0]
   969  		y := v.Args[1]
   970  		v.reset(OpS390XANDW)
   971  		v.AddArg(x)
   972  		v.AddArg(y)
   973  		return true
   974  	}
   975  }
   976  func rewriteValueS390X_OpAndB_0(v *Value) bool {
   977  	// match: (AndB x y)
   978  	// cond:
   979  	// result: (ANDW x y)
   980  	for {
   981  		_ = v.Args[1]
   982  		x := v.Args[0]
   983  		y := v.Args[1]
   984  		v.reset(OpS390XANDW)
   985  		v.AddArg(x)
   986  		v.AddArg(y)
   987  		return true
   988  	}
   989  }
   990  func rewriteValueS390X_OpAtomicAdd32_0(v *Value) bool {
   991  	b := v.Block
   992  	_ = b
   993  	typ := &b.Func.Config.Types
   994  	_ = typ
   995  	// match: (AtomicAdd32 ptr val mem)
   996  	// cond:
   997  	// result: (AddTupleFirst32 val (LAA ptr val mem))
   998  	for {
   999  		_ = v.Args[2]
  1000  		ptr := v.Args[0]
  1001  		val := v.Args[1]
  1002  		mem := v.Args[2]
  1003  		v.reset(OpS390XAddTupleFirst32)
  1004  		v.AddArg(val)
  1005  		v0 := b.NewValue0(v.Pos, OpS390XLAA, types.NewTuple(typ.UInt32, types.TypeMem))
  1006  		v0.AddArg(ptr)
  1007  		v0.AddArg(val)
  1008  		v0.AddArg(mem)
  1009  		v.AddArg(v0)
  1010  		return true
  1011  	}
  1012  }
  1013  func rewriteValueS390X_OpAtomicAdd64_0(v *Value) bool {
  1014  	b := v.Block
  1015  	_ = b
  1016  	typ := &b.Func.Config.Types
  1017  	_ = typ
  1018  	// match: (AtomicAdd64 ptr val mem)
  1019  	// cond:
  1020  	// result: (AddTupleFirst64 val (LAAG ptr val mem))
  1021  	for {
  1022  		_ = v.Args[2]
  1023  		ptr := v.Args[0]
  1024  		val := v.Args[1]
  1025  		mem := v.Args[2]
  1026  		v.reset(OpS390XAddTupleFirst64)
  1027  		v.AddArg(val)
  1028  		v0 := b.NewValue0(v.Pos, OpS390XLAAG, types.NewTuple(typ.UInt64, types.TypeMem))
  1029  		v0.AddArg(ptr)
  1030  		v0.AddArg(val)
  1031  		v0.AddArg(mem)
  1032  		v.AddArg(v0)
  1033  		return true
  1034  	}
  1035  }
  1036  func rewriteValueS390X_OpAtomicCompareAndSwap32_0(v *Value) bool {
  1037  	// match: (AtomicCompareAndSwap32 ptr old new_ mem)
  1038  	// cond:
  1039  	// result: (LoweredAtomicCas32 ptr old new_ mem)
  1040  	for {
  1041  		_ = v.Args[3]
  1042  		ptr := v.Args[0]
  1043  		old := v.Args[1]
  1044  		new_ := v.Args[2]
  1045  		mem := v.Args[3]
  1046  		v.reset(OpS390XLoweredAtomicCas32)
  1047  		v.AddArg(ptr)
  1048  		v.AddArg(old)
  1049  		v.AddArg(new_)
  1050  		v.AddArg(mem)
  1051  		return true
  1052  	}
  1053  }
  1054  func rewriteValueS390X_OpAtomicCompareAndSwap64_0(v *Value) bool {
  1055  	// match: (AtomicCompareAndSwap64 ptr old new_ mem)
  1056  	// cond:
  1057  	// result: (LoweredAtomicCas64 ptr old new_ mem)
  1058  	for {
  1059  		_ = v.Args[3]
  1060  		ptr := v.Args[0]
  1061  		old := v.Args[1]
  1062  		new_ := v.Args[2]
  1063  		mem := v.Args[3]
  1064  		v.reset(OpS390XLoweredAtomicCas64)
  1065  		v.AddArg(ptr)
  1066  		v.AddArg(old)
  1067  		v.AddArg(new_)
  1068  		v.AddArg(mem)
  1069  		return true
  1070  	}
  1071  }
  1072  func rewriteValueS390X_OpAtomicExchange32_0(v *Value) bool {
  1073  	// match: (AtomicExchange32 ptr val mem)
  1074  	// cond:
  1075  	// result: (LoweredAtomicExchange32 ptr val mem)
  1076  	for {
  1077  		_ = v.Args[2]
  1078  		ptr := v.Args[0]
  1079  		val := v.Args[1]
  1080  		mem := v.Args[2]
  1081  		v.reset(OpS390XLoweredAtomicExchange32)
  1082  		v.AddArg(ptr)
  1083  		v.AddArg(val)
  1084  		v.AddArg(mem)
  1085  		return true
  1086  	}
  1087  }
  1088  func rewriteValueS390X_OpAtomicExchange64_0(v *Value) bool {
  1089  	// match: (AtomicExchange64 ptr val mem)
  1090  	// cond:
  1091  	// result: (LoweredAtomicExchange64 ptr val mem)
  1092  	for {
  1093  		_ = v.Args[2]
  1094  		ptr := v.Args[0]
  1095  		val := v.Args[1]
  1096  		mem := v.Args[2]
  1097  		v.reset(OpS390XLoweredAtomicExchange64)
  1098  		v.AddArg(ptr)
  1099  		v.AddArg(val)
  1100  		v.AddArg(mem)
  1101  		return true
  1102  	}
  1103  }
  1104  func rewriteValueS390X_OpAtomicLoad32_0(v *Value) bool {
  1105  	// match: (AtomicLoad32 ptr mem)
  1106  	// cond:
  1107  	// result: (MOVWZatomicload ptr mem)
  1108  	for {
  1109  		_ = v.Args[1]
  1110  		ptr := v.Args[0]
  1111  		mem := v.Args[1]
  1112  		v.reset(OpS390XMOVWZatomicload)
  1113  		v.AddArg(ptr)
  1114  		v.AddArg(mem)
  1115  		return true
  1116  	}
  1117  }
  1118  func rewriteValueS390X_OpAtomicLoad64_0(v *Value) bool {
  1119  	// match: (AtomicLoad64 ptr mem)
  1120  	// cond:
  1121  	// result: (MOVDatomicload ptr mem)
  1122  	for {
  1123  		_ = v.Args[1]
  1124  		ptr := v.Args[0]
  1125  		mem := v.Args[1]
  1126  		v.reset(OpS390XMOVDatomicload)
  1127  		v.AddArg(ptr)
  1128  		v.AddArg(mem)
  1129  		return true
  1130  	}
  1131  }
  1132  func rewriteValueS390X_OpAtomicLoadPtr_0(v *Value) bool {
  1133  	// match: (AtomicLoadPtr ptr mem)
  1134  	// cond:
  1135  	// result: (MOVDatomicload ptr mem)
  1136  	for {
  1137  		_ = v.Args[1]
  1138  		ptr := v.Args[0]
  1139  		mem := v.Args[1]
  1140  		v.reset(OpS390XMOVDatomicload)
  1141  		v.AddArg(ptr)
  1142  		v.AddArg(mem)
  1143  		return true
  1144  	}
  1145  }
  1146  func rewriteValueS390X_OpAtomicStore32_0(v *Value) bool {
  1147  	// match: (AtomicStore32 ptr val mem)
  1148  	// cond:
  1149  	// result: (MOVWatomicstore ptr val mem)
  1150  	for {
  1151  		_ = v.Args[2]
  1152  		ptr := v.Args[0]
  1153  		val := v.Args[1]
  1154  		mem := v.Args[2]
  1155  		v.reset(OpS390XMOVWatomicstore)
  1156  		v.AddArg(ptr)
  1157  		v.AddArg(val)
  1158  		v.AddArg(mem)
  1159  		return true
  1160  	}
  1161  }
  1162  func rewriteValueS390X_OpAtomicStore64_0(v *Value) bool {
  1163  	// match: (AtomicStore64 ptr val mem)
  1164  	// cond:
  1165  	// result: (MOVDatomicstore ptr val mem)
  1166  	for {
  1167  		_ = v.Args[2]
  1168  		ptr := v.Args[0]
  1169  		val := v.Args[1]
  1170  		mem := v.Args[2]
  1171  		v.reset(OpS390XMOVDatomicstore)
  1172  		v.AddArg(ptr)
  1173  		v.AddArg(val)
  1174  		v.AddArg(mem)
  1175  		return true
  1176  	}
  1177  }
  1178  func rewriteValueS390X_OpAtomicStorePtrNoWB_0(v *Value) bool {
  1179  	// match: (AtomicStorePtrNoWB ptr val mem)
  1180  	// cond:
  1181  	// result: (MOVDatomicstore ptr val mem)
  1182  	for {
  1183  		_ = v.Args[2]
  1184  		ptr := v.Args[0]
  1185  		val := v.Args[1]
  1186  		mem := v.Args[2]
  1187  		v.reset(OpS390XMOVDatomicstore)
  1188  		v.AddArg(ptr)
  1189  		v.AddArg(val)
  1190  		v.AddArg(mem)
  1191  		return true
  1192  	}
  1193  }
  1194  func rewriteValueS390X_OpAvg64u_0(v *Value) bool {
  1195  	b := v.Block
  1196  	_ = b
  1197  	// match: (Avg64u <t> x y)
  1198  	// cond:
  1199  	// result: (ADD (SRDconst <t> (SUB <t> x y) [1]) y)
  1200  	for {
  1201  		t := v.Type
  1202  		_ = v.Args[1]
  1203  		x := v.Args[0]
  1204  		y := v.Args[1]
  1205  		v.reset(OpS390XADD)
  1206  		v0 := b.NewValue0(v.Pos, OpS390XSRDconst, t)
  1207  		v0.AuxInt = 1
  1208  		v1 := b.NewValue0(v.Pos, OpS390XSUB, t)
  1209  		v1.AddArg(x)
  1210  		v1.AddArg(y)
  1211  		v0.AddArg(v1)
  1212  		v.AddArg(v0)
  1213  		v.AddArg(y)
  1214  		return true
  1215  	}
  1216  }
  1217  func rewriteValueS390X_OpBitLen64_0(v *Value) bool {
  1218  	b := v.Block
  1219  	_ = b
  1220  	typ := &b.Func.Config.Types
  1221  	_ = typ
  1222  	// match: (BitLen64 x)
  1223  	// cond:
  1224  	// result: (SUB (MOVDconst [64]) (FLOGR x))
  1225  	for {
  1226  		x := v.Args[0]
  1227  		v.reset(OpS390XSUB)
  1228  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1229  		v0.AuxInt = 64
  1230  		v.AddArg(v0)
  1231  		v1 := b.NewValue0(v.Pos, OpS390XFLOGR, typ.UInt64)
  1232  		v1.AddArg(x)
  1233  		v.AddArg(v1)
  1234  		return true
  1235  	}
  1236  }
  1237  func rewriteValueS390X_OpBswap32_0(v *Value) bool {
  1238  	// match: (Bswap32 x)
  1239  	// cond:
  1240  	// result: (MOVWBR x)
  1241  	for {
  1242  		x := v.Args[0]
  1243  		v.reset(OpS390XMOVWBR)
  1244  		v.AddArg(x)
  1245  		return true
  1246  	}
  1247  }
  1248  func rewriteValueS390X_OpBswap64_0(v *Value) bool {
  1249  	// match: (Bswap64 x)
  1250  	// cond:
  1251  	// result: (MOVDBR x)
  1252  	for {
  1253  		x := v.Args[0]
  1254  		v.reset(OpS390XMOVDBR)
  1255  		v.AddArg(x)
  1256  		return true
  1257  	}
  1258  }
  1259  func rewriteValueS390X_OpCeil_0(v *Value) bool {
  1260  	// match: (Ceil x)
  1261  	// cond:
  1262  	// result: (FIDBR [6] x)
  1263  	for {
  1264  		x := v.Args[0]
  1265  		v.reset(OpS390XFIDBR)
  1266  		v.AuxInt = 6
  1267  		v.AddArg(x)
  1268  		return true
  1269  	}
  1270  }
  1271  func rewriteValueS390X_OpClosureCall_0(v *Value) bool {
  1272  	// match: (ClosureCall [argwid] entry closure mem)
  1273  	// cond:
  1274  	// result: (CALLclosure [argwid] entry closure mem)
  1275  	for {
  1276  		argwid := v.AuxInt
  1277  		_ = v.Args[2]
  1278  		entry := v.Args[0]
  1279  		closure := v.Args[1]
  1280  		mem := v.Args[2]
  1281  		v.reset(OpS390XCALLclosure)
  1282  		v.AuxInt = argwid
  1283  		v.AddArg(entry)
  1284  		v.AddArg(closure)
  1285  		v.AddArg(mem)
  1286  		return true
  1287  	}
  1288  }
  1289  func rewriteValueS390X_OpCom16_0(v *Value) bool {
  1290  	// match: (Com16 x)
  1291  	// cond:
  1292  	// result: (NOTW x)
  1293  	for {
  1294  		x := v.Args[0]
  1295  		v.reset(OpS390XNOTW)
  1296  		v.AddArg(x)
  1297  		return true
  1298  	}
  1299  }
  1300  func rewriteValueS390X_OpCom32_0(v *Value) bool {
  1301  	// match: (Com32 x)
  1302  	// cond:
  1303  	// result: (NOTW x)
  1304  	for {
  1305  		x := v.Args[0]
  1306  		v.reset(OpS390XNOTW)
  1307  		v.AddArg(x)
  1308  		return true
  1309  	}
  1310  }
  1311  func rewriteValueS390X_OpCom64_0(v *Value) bool {
  1312  	// match: (Com64 x)
  1313  	// cond:
  1314  	// result: (NOT x)
  1315  	for {
  1316  		x := v.Args[0]
  1317  		v.reset(OpS390XNOT)
  1318  		v.AddArg(x)
  1319  		return true
  1320  	}
  1321  }
  1322  func rewriteValueS390X_OpCom8_0(v *Value) bool {
  1323  	// match: (Com8 x)
  1324  	// cond:
  1325  	// result: (NOTW x)
  1326  	for {
  1327  		x := v.Args[0]
  1328  		v.reset(OpS390XNOTW)
  1329  		v.AddArg(x)
  1330  		return true
  1331  	}
  1332  }
  1333  func rewriteValueS390X_OpConst16_0(v *Value) bool {
  1334  	// match: (Const16 [val])
  1335  	// cond:
  1336  	// result: (MOVDconst [val])
  1337  	for {
  1338  		val := v.AuxInt
  1339  		v.reset(OpS390XMOVDconst)
  1340  		v.AuxInt = val
  1341  		return true
  1342  	}
  1343  }
  1344  func rewriteValueS390X_OpConst32_0(v *Value) bool {
  1345  	// match: (Const32 [val])
  1346  	// cond:
  1347  	// result: (MOVDconst [val])
  1348  	for {
  1349  		val := v.AuxInt
  1350  		v.reset(OpS390XMOVDconst)
  1351  		v.AuxInt = val
  1352  		return true
  1353  	}
  1354  }
  1355  func rewriteValueS390X_OpConst32F_0(v *Value) bool {
  1356  	// match: (Const32F [val])
  1357  	// cond:
  1358  	// result: (FMOVSconst [val])
  1359  	for {
  1360  		val := v.AuxInt
  1361  		v.reset(OpS390XFMOVSconst)
  1362  		v.AuxInt = val
  1363  		return true
  1364  	}
  1365  }
  1366  func rewriteValueS390X_OpConst64_0(v *Value) bool {
  1367  	// match: (Const64 [val])
  1368  	// cond:
  1369  	// result: (MOVDconst [val])
  1370  	for {
  1371  		val := v.AuxInt
  1372  		v.reset(OpS390XMOVDconst)
  1373  		v.AuxInt = val
  1374  		return true
  1375  	}
  1376  }
  1377  func rewriteValueS390X_OpConst64F_0(v *Value) bool {
  1378  	// match: (Const64F [val])
  1379  	// cond:
  1380  	// result: (FMOVDconst [val])
  1381  	for {
  1382  		val := v.AuxInt
  1383  		v.reset(OpS390XFMOVDconst)
  1384  		v.AuxInt = val
  1385  		return true
  1386  	}
  1387  }
  1388  func rewriteValueS390X_OpConst8_0(v *Value) bool {
  1389  	// match: (Const8 [val])
  1390  	// cond:
  1391  	// result: (MOVDconst [val])
  1392  	for {
  1393  		val := v.AuxInt
  1394  		v.reset(OpS390XMOVDconst)
  1395  		v.AuxInt = val
  1396  		return true
  1397  	}
  1398  }
  1399  func rewriteValueS390X_OpConstBool_0(v *Value) bool {
  1400  	// match: (ConstBool [b])
  1401  	// cond:
  1402  	// result: (MOVDconst [b])
  1403  	for {
  1404  		b := v.AuxInt
  1405  		v.reset(OpS390XMOVDconst)
  1406  		v.AuxInt = b
  1407  		return true
  1408  	}
  1409  }
  1410  func rewriteValueS390X_OpConstNil_0(v *Value) bool {
  1411  	// match: (ConstNil)
  1412  	// cond:
  1413  	// result: (MOVDconst [0])
  1414  	for {
  1415  		v.reset(OpS390XMOVDconst)
  1416  		v.AuxInt = 0
  1417  		return true
  1418  	}
  1419  }
  1420  func rewriteValueS390X_OpCtz32_0(v *Value) bool {
  1421  	b := v.Block
  1422  	_ = b
  1423  	typ := &b.Func.Config.Types
  1424  	_ = typ
  1425  	// match: (Ctz32 <t> x)
  1426  	// cond:
  1427  	// result: (SUB (MOVDconst [64]) (FLOGR (MOVWZreg (ANDW <t> (SUBWconst <t> [1] x) (NOTW <t> x)))))
  1428  	for {
  1429  		t := v.Type
  1430  		x := v.Args[0]
  1431  		v.reset(OpS390XSUB)
  1432  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1433  		v0.AuxInt = 64
  1434  		v.AddArg(v0)
  1435  		v1 := b.NewValue0(v.Pos, OpS390XFLOGR, typ.UInt64)
  1436  		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
  1437  		v3 := b.NewValue0(v.Pos, OpS390XANDW, t)
  1438  		v4 := b.NewValue0(v.Pos, OpS390XSUBWconst, t)
  1439  		v4.AuxInt = 1
  1440  		v4.AddArg(x)
  1441  		v3.AddArg(v4)
  1442  		v5 := b.NewValue0(v.Pos, OpS390XNOTW, t)
  1443  		v5.AddArg(x)
  1444  		v3.AddArg(v5)
  1445  		v2.AddArg(v3)
  1446  		v1.AddArg(v2)
  1447  		v.AddArg(v1)
  1448  		return true
  1449  	}
  1450  }
  1451  func rewriteValueS390X_OpCtz32NonZero_0(v *Value) bool {
  1452  	// match: (Ctz32NonZero x)
  1453  	// cond:
  1454  	// result: (Ctz32 x)
  1455  	for {
  1456  		x := v.Args[0]
  1457  		v.reset(OpCtz32)
  1458  		v.AddArg(x)
  1459  		return true
  1460  	}
  1461  }
  1462  func rewriteValueS390X_OpCtz64_0(v *Value) bool {
  1463  	b := v.Block
  1464  	_ = b
  1465  	typ := &b.Func.Config.Types
  1466  	_ = typ
  1467  	// match: (Ctz64 <t> x)
  1468  	// cond:
  1469  	// result: (SUB (MOVDconst [64]) (FLOGR (AND <t> (SUBconst <t> [1] x) (NOT <t> x))))
  1470  	for {
  1471  		t := v.Type
  1472  		x := v.Args[0]
  1473  		v.reset(OpS390XSUB)
  1474  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1475  		v0.AuxInt = 64
  1476  		v.AddArg(v0)
  1477  		v1 := b.NewValue0(v.Pos, OpS390XFLOGR, typ.UInt64)
  1478  		v2 := b.NewValue0(v.Pos, OpS390XAND, t)
  1479  		v3 := b.NewValue0(v.Pos, OpS390XSUBconst, t)
  1480  		v3.AuxInt = 1
  1481  		v3.AddArg(x)
  1482  		v2.AddArg(v3)
  1483  		v4 := b.NewValue0(v.Pos, OpS390XNOT, t)
  1484  		v4.AddArg(x)
  1485  		v2.AddArg(v4)
  1486  		v1.AddArg(v2)
  1487  		v.AddArg(v1)
  1488  		return true
  1489  	}
  1490  }
  1491  func rewriteValueS390X_OpCtz64NonZero_0(v *Value) bool {
  1492  	// match: (Ctz64NonZero x)
  1493  	// cond:
  1494  	// result: (Ctz64 x)
  1495  	for {
  1496  		x := v.Args[0]
  1497  		v.reset(OpCtz64)
  1498  		v.AddArg(x)
  1499  		return true
  1500  	}
  1501  }
  1502  func rewriteValueS390X_OpCvt32Fto32_0(v *Value) bool {
  1503  	// match: (Cvt32Fto32 x)
  1504  	// cond:
  1505  	// result: (CFEBRA x)
  1506  	for {
  1507  		x := v.Args[0]
  1508  		v.reset(OpS390XCFEBRA)
  1509  		v.AddArg(x)
  1510  		return true
  1511  	}
  1512  }
  1513  func rewriteValueS390X_OpCvt32Fto64_0(v *Value) bool {
  1514  	// match: (Cvt32Fto64 x)
  1515  	// cond:
  1516  	// result: (CGEBRA x)
  1517  	for {
  1518  		x := v.Args[0]
  1519  		v.reset(OpS390XCGEBRA)
  1520  		v.AddArg(x)
  1521  		return true
  1522  	}
  1523  }
  1524  func rewriteValueS390X_OpCvt32Fto64F_0(v *Value) bool {
  1525  	// match: (Cvt32Fto64F x)
  1526  	// cond:
  1527  	// result: (LDEBR x)
  1528  	for {
  1529  		x := v.Args[0]
  1530  		v.reset(OpS390XLDEBR)
  1531  		v.AddArg(x)
  1532  		return true
  1533  	}
  1534  }
  1535  func rewriteValueS390X_OpCvt32to32F_0(v *Value) bool {
  1536  	// match: (Cvt32to32F x)
  1537  	// cond:
  1538  	// result: (CEFBRA x)
  1539  	for {
  1540  		x := v.Args[0]
  1541  		v.reset(OpS390XCEFBRA)
  1542  		v.AddArg(x)
  1543  		return true
  1544  	}
  1545  }
  1546  func rewriteValueS390X_OpCvt32to64F_0(v *Value) bool {
  1547  	// match: (Cvt32to64F x)
  1548  	// cond:
  1549  	// result: (CDFBRA x)
  1550  	for {
  1551  		x := v.Args[0]
  1552  		v.reset(OpS390XCDFBRA)
  1553  		v.AddArg(x)
  1554  		return true
  1555  	}
  1556  }
  1557  func rewriteValueS390X_OpCvt64Fto32_0(v *Value) bool {
  1558  	// match: (Cvt64Fto32 x)
  1559  	// cond:
  1560  	// result: (CFDBRA x)
  1561  	for {
  1562  		x := v.Args[0]
  1563  		v.reset(OpS390XCFDBRA)
  1564  		v.AddArg(x)
  1565  		return true
  1566  	}
  1567  }
  1568  func rewriteValueS390X_OpCvt64Fto32F_0(v *Value) bool {
  1569  	// match: (Cvt64Fto32F x)
  1570  	// cond:
  1571  	// result: (LEDBR x)
  1572  	for {
  1573  		x := v.Args[0]
  1574  		v.reset(OpS390XLEDBR)
  1575  		v.AddArg(x)
  1576  		return true
  1577  	}
  1578  }
  1579  func rewriteValueS390X_OpCvt64Fto64_0(v *Value) bool {
  1580  	// match: (Cvt64Fto64 x)
  1581  	// cond:
  1582  	// result: (CGDBRA x)
  1583  	for {
  1584  		x := v.Args[0]
  1585  		v.reset(OpS390XCGDBRA)
  1586  		v.AddArg(x)
  1587  		return true
  1588  	}
  1589  }
  1590  func rewriteValueS390X_OpCvt64to32F_0(v *Value) bool {
  1591  	// match: (Cvt64to32F x)
  1592  	// cond:
  1593  	// result: (CEGBRA x)
  1594  	for {
  1595  		x := v.Args[0]
  1596  		v.reset(OpS390XCEGBRA)
  1597  		v.AddArg(x)
  1598  		return true
  1599  	}
  1600  }
  1601  func rewriteValueS390X_OpCvt64to64F_0(v *Value) bool {
  1602  	// match: (Cvt64to64F x)
  1603  	// cond:
  1604  	// result: (CDGBRA x)
  1605  	for {
  1606  		x := v.Args[0]
  1607  		v.reset(OpS390XCDGBRA)
  1608  		v.AddArg(x)
  1609  		return true
  1610  	}
  1611  }
  1612  func rewriteValueS390X_OpDiv16_0(v *Value) bool {
  1613  	b := v.Block
  1614  	_ = b
  1615  	typ := &b.Func.Config.Types
  1616  	_ = typ
  1617  	// match: (Div16 x y)
  1618  	// cond:
  1619  	// result: (DIVW (MOVHreg x) (MOVHreg y))
  1620  	for {
  1621  		_ = v.Args[1]
  1622  		x := v.Args[0]
  1623  		y := v.Args[1]
  1624  		v.reset(OpS390XDIVW)
  1625  		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  1626  		v0.AddArg(x)
  1627  		v.AddArg(v0)
  1628  		v1 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  1629  		v1.AddArg(y)
  1630  		v.AddArg(v1)
  1631  		return true
  1632  	}
  1633  }
  1634  func rewriteValueS390X_OpDiv16u_0(v *Value) bool {
  1635  	b := v.Block
  1636  	_ = b
  1637  	typ := &b.Func.Config.Types
  1638  	_ = typ
  1639  	// match: (Div16u x y)
  1640  	// cond:
  1641  	// result: (DIVWU (MOVHZreg x) (MOVHZreg y))
  1642  	for {
  1643  		_ = v.Args[1]
  1644  		x := v.Args[0]
  1645  		y := v.Args[1]
  1646  		v.reset(OpS390XDIVWU)
  1647  		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  1648  		v0.AddArg(x)
  1649  		v.AddArg(v0)
  1650  		v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  1651  		v1.AddArg(y)
  1652  		v.AddArg(v1)
  1653  		return true
  1654  	}
  1655  }
  1656  func rewriteValueS390X_OpDiv32_0(v *Value) bool {
  1657  	b := v.Block
  1658  	_ = b
  1659  	typ := &b.Func.Config.Types
  1660  	_ = typ
  1661  	// match: (Div32 x y)
  1662  	// cond:
  1663  	// result: (DIVW (MOVWreg x) y)
  1664  	for {
  1665  		_ = v.Args[1]
  1666  		x := v.Args[0]
  1667  		y := v.Args[1]
  1668  		v.reset(OpS390XDIVW)
  1669  		v0 := b.NewValue0(v.Pos, OpS390XMOVWreg, typ.Int64)
  1670  		v0.AddArg(x)
  1671  		v.AddArg(v0)
  1672  		v.AddArg(y)
  1673  		return true
  1674  	}
  1675  }
  1676  func rewriteValueS390X_OpDiv32F_0(v *Value) bool {
  1677  	// match: (Div32F x y)
  1678  	// cond:
  1679  	// result: (FDIVS x y)
  1680  	for {
  1681  		_ = v.Args[1]
  1682  		x := v.Args[0]
  1683  		y := v.Args[1]
  1684  		v.reset(OpS390XFDIVS)
  1685  		v.AddArg(x)
  1686  		v.AddArg(y)
  1687  		return true
  1688  	}
  1689  }
  1690  func rewriteValueS390X_OpDiv32u_0(v *Value) bool {
  1691  	b := v.Block
  1692  	_ = b
  1693  	typ := &b.Func.Config.Types
  1694  	_ = typ
  1695  	// match: (Div32u x y)
  1696  	// cond:
  1697  	// result: (DIVWU (MOVWZreg x) y)
  1698  	for {
  1699  		_ = v.Args[1]
  1700  		x := v.Args[0]
  1701  		y := v.Args[1]
  1702  		v.reset(OpS390XDIVWU)
  1703  		v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
  1704  		v0.AddArg(x)
  1705  		v.AddArg(v0)
  1706  		v.AddArg(y)
  1707  		return true
  1708  	}
  1709  }
  1710  func rewriteValueS390X_OpDiv64_0(v *Value) bool {
  1711  	// match: (Div64 x y)
  1712  	// cond:
  1713  	// result: (DIVD x y)
  1714  	for {
  1715  		_ = v.Args[1]
  1716  		x := v.Args[0]
  1717  		y := v.Args[1]
  1718  		v.reset(OpS390XDIVD)
  1719  		v.AddArg(x)
  1720  		v.AddArg(y)
  1721  		return true
  1722  	}
  1723  }
  1724  func rewriteValueS390X_OpDiv64F_0(v *Value) bool {
  1725  	// match: (Div64F x y)
  1726  	// cond:
  1727  	// result: (FDIV x y)
  1728  	for {
  1729  		_ = v.Args[1]
  1730  		x := v.Args[0]
  1731  		y := v.Args[1]
  1732  		v.reset(OpS390XFDIV)
  1733  		v.AddArg(x)
  1734  		v.AddArg(y)
  1735  		return true
  1736  	}
  1737  }
  1738  func rewriteValueS390X_OpDiv64u_0(v *Value) bool {
  1739  	// match: (Div64u x y)
  1740  	// cond:
  1741  	// result: (DIVDU x y)
  1742  	for {
  1743  		_ = v.Args[1]
  1744  		x := v.Args[0]
  1745  		y := v.Args[1]
  1746  		v.reset(OpS390XDIVDU)
  1747  		v.AddArg(x)
  1748  		v.AddArg(y)
  1749  		return true
  1750  	}
  1751  }
  1752  func rewriteValueS390X_OpDiv8_0(v *Value) bool {
  1753  	b := v.Block
  1754  	_ = b
  1755  	typ := &b.Func.Config.Types
  1756  	_ = typ
  1757  	// match: (Div8 x y)
  1758  	// cond:
  1759  	// result: (DIVW (MOVBreg x) (MOVBreg y))
  1760  	for {
  1761  		_ = v.Args[1]
  1762  		x := v.Args[0]
  1763  		y := v.Args[1]
  1764  		v.reset(OpS390XDIVW)
  1765  		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  1766  		v0.AddArg(x)
  1767  		v.AddArg(v0)
  1768  		v1 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  1769  		v1.AddArg(y)
  1770  		v.AddArg(v1)
  1771  		return true
  1772  	}
  1773  }
  1774  func rewriteValueS390X_OpDiv8u_0(v *Value) bool {
  1775  	b := v.Block
  1776  	_ = b
  1777  	typ := &b.Func.Config.Types
  1778  	_ = typ
  1779  	// match: (Div8u x y)
  1780  	// cond:
  1781  	// result: (DIVWU (MOVBZreg x) (MOVBZreg y))
  1782  	for {
  1783  		_ = v.Args[1]
  1784  		x := v.Args[0]
  1785  		y := v.Args[1]
  1786  		v.reset(OpS390XDIVWU)
  1787  		v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  1788  		v0.AddArg(x)
  1789  		v.AddArg(v0)
  1790  		v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  1791  		v1.AddArg(y)
  1792  		v.AddArg(v1)
  1793  		return true
  1794  	}
  1795  }
  1796  func rewriteValueS390X_OpEq16_0(v *Value) bool {
  1797  	b := v.Block
  1798  	_ = b
  1799  	typ := &b.Func.Config.Types
  1800  	_ = typ
  1801  	// match: (Eq16 x y)
  1802  	// cond:
  1803  	// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVHreg x) (MOVHreg y)))
  1804  	for {
  1805  		_ = v.Args[1]
  1806  		x := v.Args[0]
  1807  		y := v.Args[1]
  1808  		v.reset(OpS390XMOVDEQ)
  1809  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1810  		v0.AuxInt = 0
  1811  		v.AddArg(v0)
  1812  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1813  		v1.AuxInt = 1
  1814  		v.AddArg(v1)
  1815  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  1816  		v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  1817  		v3.AddArg(x)
  1818  		v2.AddArg(v3)
  1819  		v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  1820  		v4.AddArg(y)
  1821  		v2.AddArg(v4)
  1822  		v.AddArg(v2)
  1823  		return true
  1824  	}
  1825  }
  1826  func rewriteValueS390X_OpEq32_0(v *Value) bool {
  1827  	b := v.Block
  1828  	_ = b
  1829  	typ := &b.Func.Config.Types
  1830  	_ = typ
  1831  	// match: (Eq32 x y)
  1832  	// cond:
  1833  	// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
  1834  	for {
  1835  		_ = v.Args[1]
  1836  		x := v.Args[0]
  1837  		y := v.Args[1]
  1838  		v.reset(OpS390XMOVDEQ)
  1839  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1840  		v0.AuxInt = 0
  1841  		v.AddArg(v0)
  1842  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1843  		v1.AuxInt = 1
  1844  		v.AddArg(v1)
  1845  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  1846  		v2.AddArg(x)
  1847  		v2.AddArg(y)
  1848  		v.AddArg(v2)
  1849  		return true
  1850  	}
  1851  }
  1852  func rewriteValueS390X_OpEq32F_0(v *Value) bool {
  1853  	b := v.Block
  1854  	_ = b
  1855  	typ := &b.Func.Config.Types
  1856  	_ = typ
  1857  	// match: (Eq32F x y)
  1858  	// cond:
  1859  	// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
  1860  	for {
  1861  		_ = v.Args[1]
  1862  		x := v.Args[0]
  1863  		y := v.Args[1]
  1864  		v.reset(OpS390XMOVDEQ)
  1865  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1866  		v0.AuxInt = 0
  1867  		v.AddArg(v0)
  1868  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1869  		v1.AuxInt = 1
  1870  		v.AddArg(v1)
  1871  		v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
  1872  		v2.AddArg(x)
  1873  		v2.AddArg(y)
  1874  		v.AddArg(v2)
  1875  		return true
  1876  	}
  1877  }
  1878  func rewriteValueS390X_OpEq64_0(v *Value) bool {
  1879  	b := v.Block
  1880  	_ = b
  1881  	typ := &b.Func.Config.Types
  1882  	_ = typ
  1883  	// match: (Eq64 x y)
  1884  	// cond:
  1885  	// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
  1886  	for {
  1887  		_ = v.Args[1]
  1888  		x := v.Args[0]
  1889  		y := v.Args[1]
  1890  		v.reset(OpS390XMOVDEQ)
  1891  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1892  		v0.AuxInt = 0
  1893  		v.AddArg(v0)
  1894  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1895  		v1.AuxInt = 1
  1896  		v.AddArg(v1)
  1897  		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
  1898  		v2.AddArg(x)
  1899  		v2.AddArg(y)
  1900  		v.AddArg(v2)
  1901  		return true
  1902  	}
  1903  }
  1904  func rewriteValueS390X_OpEq64F_0(v *Value) bool {
  1905  	b := v.Block
  1906  	_ = b
  1907  	typ := &b.Func.Config.Types
  1908  	_ = typ
  1909  	// match: (Eq64F x y)
  1910  	// cond:
  1911  	// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
  1912  	for {
  1913  		_ = v.Args[1]
  1914  		x := v.Args[0]
  1915  		y := v.Args[1]
  1916  		v.reset(OpS390XMOVDEQ)
  1917  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1918  		v0.AuxInt = 0
  1919  		v.AddArg(v0)
  1920  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1921  		v1.AuxInt = 1
  1922  		v.AddArg(v1)
  1923  		v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
  1924  		v2.AddArg(x)
  1925  		v2.AddArg(y)
  1926  		v.AddArg(v2)
  1927  		return true
  1928  	}
  1929  }
  1930  func rewriteValueS390X_OpEq8_0(v *Value) bool {
  1931  	b := v.Block
  1932  	_ = b
  1933  	typ := &b.Func.Config.Types
  1934  	_ = typ
  1935  	// match: (Eq8 x y)
  1936  	// cond:
  1937  	// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVBreg x) (MOVBreg y)))
  1938  	for {
  1939  		_ = v.Args[1]
  1940  		x := v.Args[0]
  1941  		y := v.Args[1]
  1942  		v.reset(OpS390XMOVDEQ)
  1943  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1944  		v0.AuxInt = 0
  1945  		v.AddArg(v0)
  1946  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1947  		v1.AuxInt = 1
  1948  		v.AddArg(v1)
  1949  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  1950  		v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  1951  		v3.AddArg(x)
  1952  		v2.AddArg(v3)
  1953  		v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  1954  		v4.AddArg(y)
  1955  		v2.AddArg(v4)
  1956  		v.AddArg(v2)
  1957  		return true
  1958  	}
  1959  }
  1960  func rewriteValueS390X_OpEqB_0(v *Value) bool {
  1961  	b := v.Block
  1962  	_ = b
  1963  	typ := &b.Func.Config.Types
  1964  	_ = typ
  1965  	// match: (EqB x y)
  1966  	// cond:
  1967  	// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVBreg x) (MOVBreg y)))
  1968  	for {
  1969  		_ = v.Args[1]
  1970  		x := v.Args[0]
  1971  		y := v.Args[1]
  1972  		v.reset(OpS390XMOVDEQ)
  1973  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1974  		v0.AuxInt = 0
  1975  		v.AddArg(v0)
  1976  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  1977  		v1.AuxInt = 1
  1978  		v.AddArg(v1)
  1979  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  1980  		v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  1981  		v3.AddArg(x)
  1982  		v2.AddArg(v3)
  1983  		v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  1984  		v4.AddArg(y)
  1985  		v2.AddArg(v4)
  1986  		v.AddArg(v2)
  1987  		return true
  1988  	}
  1989  }
  1990  func rewriteValueS390X_OpEqPtr_0(v *Value) bool {
  1991  	b := v.Block
  1992  	_ = b
  1993  	typ := &b.Func.Config.Types
  1994  	_ = typ
  1995  	// match: (EqPtr x y)
  1996  	// cond:
  1997  	// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
  1998  	for {
  1999  		_ = v.Args[1]
  2000  		x := v.Args[0]
  2001  		y := v.Args[1]
  2002  		v.reset(OpS390XMOVDEQ)
  2003  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2004  		v0.AuxInt = 0
  2005  		v.AddArg(v0)
  2006  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2007  		v1.AuxInt = 1
  2008  		v.AddArg(v1)
  2009  		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
  2010  		v2.AddArg(x)
  2011  		v2.AddArg(y)
  2012  		v.AddArg(v2)
  2013  		return true
  2014  	}
  2015  }
  2016  func rewriteValueS390X_OpFloor_0(v *Value) bool {
  2017  	// match: (Floor x)
  2018  	// cond:
  2019  	// result: (FIDBR [7] x)
  2020  	for {
  2021  		x := v.Args[0]
  2022  		v.reset(OpS390XFIDBR)
  2023  		v.AuxInt = 7
  2024  		v.AddArg(x)
  2025  		return true
  2026  	}
  2027  }
  2028  func rewriteValueS390X_OpGeq16_0(v *Value) bool {
  2029  	b := v.Block
  2030  	_ = b
  2031  	typ := &b.Func.Config.Types
  2032  	_ = typ
  2033  	// match: (Geq16 x y)
  2034  	// cond:
  2035  	// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVHreg x) (MOVHreg y)))
  2036  	for {
  2037  		_ = v.Args[1]
  2038  		x := v.Args[0]
  2039  		y := v.Args[1]
  2040  		v.reset(OpS390XMOVDGE)
  2041  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2042  		v0.AuxInt = 0
  2043  		v.AddArg(v0)
  2044  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2045  		v1.AuxInt = 1
  2046  		v.AddArg(v1)
  2047  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2048  		v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  2049  		v3.AddArg(x)
  2050  		v2.AddArg(v3)
  2051  		v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  2052  		v4.AddArg(y)
  2053  		v2.AddArg(v4)
  2054  		v.AddArg(v2)
  2055  		return true
  2056  	}
  2057  }
  2058  func rewriteValueS390X_OpGeq16U_0(v *Value) bool {
  2059  	b := v.Block
  2060  	_ = b
  2061  	typ := &b.Func.Config.Types
  2062  	_ = typ
  2063  	// match: (Geq16U x y)
  2064  	// cond:
  2065  	// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPWU (MOVHZreg x) (MOVHZreg y)))
  2066  	for {
  2067  		_ = v.Args[1]
  2068  		x := v.Args[0]
  2069  		y := v.Args[1]
  2070  		v.reset(OpS390XMOVDGE)
  2071  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2072  		v0.AuxInt = 0
  2073  		v.AddArg(v0)
  2074  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2075  		v1.AuxInt = 1
  2076  		v.AddArg(v1)
  2077  		v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2078  		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  2079  		v3.AddArg(x)
  2080  		v2.AddArg(v3)
  2081  		v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  2082  		v4.AddArg(y)
  2083  		v2.AddArg(v4)
  2084  		v.AddArg(v2)
  2085  		return true
  2086  	}
  2087  }
  2088  func rewriteValueS390X_OpGeq32_0(v *Value) bool {
  2089  	b := v.Block
  2090  	_ = b
  2091  	typ := &b.Func.Config.Types
  2092  	_ = typ
  2093  	// match: (Geq32 x y)
  2094  	// cond:
  2095  	// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
  2096  	for {
  2097  		_ = v.Args[1]
  2098  		x := v.Args[0]
  2099  		y := v.Args[1]
  2100  		v.reset(OpS390XMOVDGE)
  2101  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2102  		v0.AuxInt = 0
  2103  		v.AddArg(v0)
  2104  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2105  		v1.AuxInt = 1
  2106  		v.AddArg(v1)
  2107  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2108  		v2.AddArg(x)
  2109  		v2.AddArg(y)
  2110  		v.AddArg(v2)
  2111  		return true
  2112  	}
  2113  }
  2114  func rewriteValueS390X_OpGeq32F_0(v *Value) bool {
  2115  	b := v.Block
  2116  	_ = b
  2117  	typ := &b.Func.Config.Types
  2118  	_ = typ
  2119  	// match: (Geq32F x y)
  2120  	// cond:
  2121  	// result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
  2122  	for {
  2123  		_ = v.Args[1]
  2124  		x := v.Args[0]
  2125  		y := v.Args[1]
  2126  		v.reset(OpS390XMOVDGEnoinv)
  2127  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2128  		v0.AuxInt = 0
  2129  		v.AddArg(v0)
  2130  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2131  		v1.AuxInt = 1
  2132  		v.AddArg(v1)
  2133  		v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
  2134  		v2.AddArg(x)
  2135  		v2.AddArg(y)
  2136  		v.AddArg(v2)
  2137  		return true
  2138  	}
  2139  }
  2140  func rewriteValueS390X_OpGeq32U_0(v *Value) bool {
  2141  	b := v.Block
  2142  	_ = b
  2143  	typ := &b.Func.Config.Types
  2144  	_ = typ
  2145  	// match: (Geq32U x y)
  2146  	// cond:
  2147  	// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y))
  2148  	for {
  2149  		_ = v.Args[1]
  2150  		x := v.Args[0]
  2151  		y := v.Args[1]
  2152  		v.reset(OpS390XMOVDGE)
  2153  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2154  		v0.AuxInt = 0
  2155  		v.AddArg(v0)
  2156  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2157  		v1.AuxInt = 1
  2158  		v.AddArg(v1)
  2159  		v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2160  		v2.AddArg(x)
  2161  		v2.AddArg(y)
  2162  		v.AddArg(v2)
  2163  		return true
  2164  	}
  2165  }
  2166  func rewriteValueS390X_OpGeq64_0(v *Value) bool {
  2167  	b := v.Block
  2168  	_ = b
  2169  	typ := &b.Func.Config.Types
  2170  	_ = typ
  2171  	// match: (Geq64 x y)
  2172  	// cond:
  2173  	// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
  2174  	for {
  2175  		_ = v.Args[1]
  2176  		x := v.Args[0]
  2177  		y := v.Args[1]
  2178  		v.reset(OpS390XMOVDGE)
  2179  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2180  		v0.AuxInt = 0
  2181  		v.AddArg(v0)
  2182  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2183  		v1.AuxInt = 1
  2184  		v.AddArg(v1)
  2185  		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
  2186  		v2.AddArg(x)
  2187  		v2.AddArg(y)
  2188  		v.AddArg(v2)
  2189  		return true
  2190  	}
  2191  }
  2192  func rewriteValueS390X_OpGeq64F_0(v *Value) bool {
  2193  	b := v.Block
  2194  	_ = b
  2195  	typ := &b.Func.Config.Types
  2196  	_ = typ
  2197  	// match: (Geq64F x y)
  2198  	// cond:
  2199  	// result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
  2200  	for {
  2201  		_ = v.Args[1]
  2202  		x := v.Args[0]
  2203  		y := v.Args[1]
  2204  		v.reset(OpS390XMOVDGEnoinv)
  2205  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2206  		v0.AuxInt = 0
  2207  		v.AddArg(v0)
  2208  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2209  		v1.AuxInt = 1
  2210  		v.AddArg(v1)
  2211  		v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
  2212  		v2.AddArg(x)
  2213  		v2.AddArg(y)
  2214  		v.AddArg(v2)
  2215  		return true
  2216  	}
  2217  }
  2218  func rewriteValueS390X_OpGeq64U_0(v *Value) bool {
  2219  	b := v.Block
  2220  	_ = b
  2221  	typ := &b.Func.Config.Types
  2222  	_ = typ
  2223  	// match: (Geq64U x y)
  2224  	// cond:
  2225  	// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPU x y))
  2226  	for {
  2227  		_ = v.Args[1]
  2228  		x := v.Args[0]
  2229  		y := v.Args[1]
  2230  		v.reset(OpS390XMOVDGE)
  2231  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2232  		v0.AuxInt = 0
  2233  		v.AddArg(v0)
  2234  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2235  		v1.AuxInt = 1
  2236  		v.AddArg(v1)
  2237  		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
  2238  		v2.AddArg(x)
  2239  		v2.AddArg(y)
  2240  		v.AddArg(v2)
  2241  		return true
  2242  	}
  2243  }
  2244  func rewriteValueS390X_OpGeq8_0(v *Value) bool {
  2245  	b := v.Block
  2246  	_ = b
  2247  	typ := &b.Func.Config.Types
  2248  	_ = typ
  2249  	// match: (Geq8 x y)
  2250  	// cond:
  2251  	// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVBreg x) (MOVBreg y)))
  2252  	for {
  2253  		_ = v.Args[1]
  2254  		x := v.Args[0]
  2255  		y := v.Args[1]
  2256  		v.reset(OpS390XMOVDGE)
  2257  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2258  		v0.AuxInt = 0
  2259  		v.AddArg(v0)
  2260  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2261  		v1.AuxInt = 1
  2262  		v.AddArg(v1)
  2263  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2264  		v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  2265  		v3.AddArg(x)
  2266  		v2.AddArg(v3)
  2267  		v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  2268  		v4.AddArg(y)
  2269  		v2.AddArg(v4)
  2270  		v.AddArg(v2)
  2271  		return true
  2272  	}
  2273  }
  2274  func rewriteValueS390X_OpGeq8U_0(v *Value) bool {
  2275  	b := v.Block
  2276  	_ = b
  2277  	typ := &b.Func.Config.Types
  2278  	_ = typ
  2279  	// match: (Geq8U x y)
  2280  	// cond:
  2281  	// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPWU (MOVBZreg x) (MOVBZreg y)))
  2282  	for {
  2283  		_ = v.Args[1]
  2284  		x := v.Args[0]
  2285  		y := v.Args[1]
  2286  		v.reset(OpS390XMOVDGE)
  2287  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2288  		v0.AuxInt = 0
  2289  		v.AddArg(v0)
  2290  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2291  		v1.AuxInt = 1
  2292  		v.AddArg(v1)
  2293  		v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2294  		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  2295  		v3.AddArg(x)
  2296  		v2.AddArg(v3)
  2297  		v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  2298  		v4.AddArg(y)
  2299  		v2.AddArg(v4)
  2300  		v.AddArg(v2)
  2301  		return true
  2302  	}
  2303  }
  2304  func rewriteValueS390X_OpGetCallerPC_0(v *Value) bool {
  2305  	// match: (GetCallerPC)
  2306  	// cond:
  2307  	// result: (LoweredGetCallerPC)
  2308  	for {
  2309  		v.reset(OpS390XLoweredGetCallerPC)
  2310  		return true
  2311  	}
  2312  }
  2313  func rewriteValueS390X_OpGetCallerSP_0(v *Value) bool {
  2314  	// match: (GetCallerSP)
  2315  	// cond:
  2316  	// result: (LoweredGetCallerSP)
  2317  	for {
  2318  		v.reset(OpS390XLoweredGetCallerSP)
  2319  		return true
  2320  	}
  2321  }
  2322  func rewriteValueS390X_OpGetClosurePtr_0(v *Value) bool {
  2323  	// match: (GetClosurePtr)
  2324  	// cond:
  2325  	// result: (LoweredGetClosurePtr)
  2326  	for {
  2327  		v.reset(OpS390XLoweredGetClosurePtr)
  2328  		return true
  2329  	}
  2330  }
  2331  func rewriteValueS390X_OpGetG_0(v *Value) bool {
  2332  	// match: (GetG mem)
  2333  	// cond:
  2334  	// result: (LoweredGetG mem)
  2335  	for {
  2336  		mem := v.Args[0]
  2337  		v.reset(OpS390XLoweredGetG)
  2338  		v.AddArg(mem)
  2339  		return true
  2340  	}
  2341  }
  2342  func rewriteValueS390X_OpGreater16_0(v *Value) bool {
  2343  	b := v.Block
  2344  	_ = b
  2345  	typ := &b.Func.Config.Types
  2346  	_ = typ
  2347  	// match: (Greater16 x y)
  2348  	// cond:
  2349  	// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVHreg x) (MOVHreg y)))
  2350  	for {
  2351  		_ = v.Args[1]
  2352  		x := v.Args[0]
  2353  		y := v.Args[1]
  2354  		v.reset(OpS390XMOVDGT)
  2355  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2356  		v0.AuxInt = 0
  2357  		v.AddArg(v0)
  2358  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2359  		v1.AuxInt = 1
  2360  		v.AddArg(v1)
  2361  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2362  		v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  2363  		v3.AddArg(x)
  2364  		v2.AddArg(v3)
  2365  		v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  2366  		v4.AddArg(y)
  2367  		v2.AddArg(v4)
  2368  		v.AddArg(v2)
  2369  		return true
  2370  	}
  2371  }
  2372  func rewriteValueS390X_OpGreater16U_0(v *Value) bool {
  2373  	b := v.Block
  2374  	_ = b
  2375  	typ := &b.Func.Config.Types
  2376  	_ = typ
  2377  	// match: (Greater16U x y)
  2378  	// cond:
  2379  	// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPWU (MOVHZreg x) (MOVHZreg y)))
  2380  	for {
  2381  		_ = v.Args[1]
  2382  		x := v.Args[0]
  2383  		y := v.Args[1]
  2384  		v.reset(OpS390XMOVDGT)
  2385  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2386  		v0.AuxInt = 0
  2387  		v.AddArg(v0)
  2388  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2389  		v1.AuxInt = 1
  2390  		v.AddArg(v1)
  2391  		v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2392  		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  2393  		v3.AddArg(x)
  2394  		v2.AddArg(v3)
  2395  		v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  2396  		v4.AddArg(y)
  2397  		v2.AddArg(v4)
  2398  		v.AddArg(v2)
  2399  		return true
  2400  	}
  2401  }
  2402  func rewriteValueS390X_OpGreater32_0(v *Value) bool {
  2403  	b := v.Block
  2404  	_ = b
  2405  	typ := &b.Func.Config.Types
  2406  	_ = typ
  2407  	// match: (Greater32 x y)
  2408  	// cond:
  2409  	// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
  2410  	for {
  2411  		_ = v.Args[1]
  2412  		x := v.Args[0]
  2413  		y := v.Args[1]
  2414  		v.reset(OpS390XMOVDGT)
  2415  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2416  		v0.AuxInt = 0
  2417  		v.AddArg(v0)
  2418  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2419  		v1.AuxInt = 1
  2420  		v.AddArg(v1)
  2421  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2422  		v2.AddArg(x)
  2423  		v2.AddArg(y)
  2424  		v.AddArg(v2)
  2425  		return true
  2426  	}
  2427  }
  2428  func rewriteValueS390X_OpGreater32F_0(v *Value) bool {
  2429  	b := v.Block
  2430  	_ = b
  2431  	typ := &b.Func.Config.Types
  2432  	_ = typ
  2433  	// match: (Greater32F x y)
  2434  	// cond:
  2435  	// result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
  2436  	for {
  2437  		_ = v.Args[1]
  2438  		x := v.Args[0]
  2439  		y := v.Args[1]
  2440  		v.reset(OpS390XMOVDGTnoinv)
  2441  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2442  		v0.AuxInt = 0
  2443  		v.AddArg(v0)
  2444  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2445  		v1.AuxInt = 1
  2446  		v.AddArg(v1)
  2447  		v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
  2448  		v2.AddArg(x)
  2449  		v2.AddArg(y)
  2450  		v.AddArg(v2)
  2451  		return true
  2452  	}
  2453  }
  2454  func rewriteValueS390X_OpGreater32U_0(v *Value) bool {
  2455  	b := v.Block
  2456  	_ = b
  2457  	typ := &b.Func.Config.Types
  2458  	_ = typ
  2459  	// match: (Greater32U x y)
  2460  	// cond:
  2461  	// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y))
  2462  	for {
  2463  		_ = v.Args[1]
  2464  		x := v.Args[0]
  2465  		y := v.Args[1]
  2466  		v.reset(OpS390XMOVDGT)
  2467  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2468  		v0.AuxInt = 0
  2469  		v.AddArg(v0)
  2470  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2471  		v1.AuxInt = 1
  2472  		v.AddArg(v1)
  2473  		v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2474  		v2.AddArg(x)
  2475  		v2.AddArg(y)
  2476  		v.AddArg(v2)
  2477  		return true
  2478  	}
  2479  }
  2480  func rewriteValueS390X_OpGreater64_0(v *Value) bool {
  2481  	b := v.Block
  2482  	_ = b
  2483  	typ := &b.Func.Config.Types
  2484  	_ = typ
  2485  	// match: (Greater64 x y)
  2486  	// cond:
  2487  	// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
  2488  	for {
  2489  		_ = v.Args[1]
  2490  		x := v.Args[0]
  2491  		y := v.Args[1]
  2492  		v.reset(OpS390XMOVDGT)
  2493  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2494  		v0.AuxInt = 0
  2495  		v.AddArg(v0)
  2496  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2497  		v1.AuxInt = 1
  2498  		v.AddArg(v1)
  2499  		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
  2500  		v2.AddArg(x)
  2501  		v2.AddArg(y)
  2502  		v.AddArg(v2)
  2503  		return true
  2504  	}
  2505  }
  2506  func rewriteValueS390X_OpGreater64F_0(v *Value) bool {
  2507  	b := v.Block
  2508  	_ = b
  2509  	typ := &b.Func.Config.Types
  2510  	_ = typ
  2511  	// match: (Greater64F x y)
  2512  	// cond:
  2513  	// result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
  2514  	for {
  2515  		_ = v.Args[1]
  2516  		x := v.Args[0]
  2517  		y := v.Args[1]
  2518  		v.reset(OpS390XMOVDGTnoinv)
  2519  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2520  		v0.AuxInt = 0
  2521  		v.AddArg(v0)
  2522  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2523  		v1.AuxInt = 1
  2524  		v.AddArg(v1)
  2525  		v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
  2526  		v2.AddArg(x)
  2527  		v2.AddArg(y)
  2528  		v.AddArg(v2)
  2529  		return true
  2530  	}
  2531  }
  2532  func rewriteValueS390X_OpGreater64U_0(v *Value) bool {
  2533  	b := v.Block
  2534  	_ = b
  2535  	typ := &b.Func.Config.Types
  2536  	_ = typ
  2537  	// match: (Greater64U x y)
  2538  	// cond:
  2539  	// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPU x y))
  2540  	for {
  2541  		_ = v.Args[1]
  2542  		x := v.Args[0]
  2543  		y := v.Args[1]
  2544  		v.reset(OpS390XMOVDGT)
  2545  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2546  		v0.AuxInt = 0
  2547  		v.AddArg(v0)
  2548  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2549  		v1.AuxInt = 1
  2550  		v.AddArg(v1)
  2551  		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
  2552  		v2.AddArg(x)
  2553  		v2.AddArg(y)
  2554  		v.AddArg(v2)
  2555  		return true
  2556  	}
  2557  }
  2558  func rewriteValueS390X_OpGreater8_0(v *Value) bool {
  2559  	b := v.Block
  2560  	_ = b
  2561  	typ := &b.Func.Config.Types
  2562  	_ = typ
  2563  	// match: (Greater8 x y)
  2564  	// cond:
  2565  	// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVBreg x) (MOVBreg y)))
  2566  	for {
  2567  		_ = v.Args[1]
  2568  		x := v.Args[0]
  2569  		y := v.Args[1]
  2570  		v.reset(OpS390XMOVDGT)
  2571  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2572  		v0.AuxInt = 0
  2573  		v.AddArg(v0)
  2574  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2575  		v1.AuxInt = 1
  2576  		v.AddArg(v1)
  2577  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2578  		v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  2579  		v3.AddArg(x)
  2580  		v2.AddArg(v3)
  2581  		v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  2582  		v4.AddArg(y)
  2583  		v2.AddArg(v4)
  2584  		v.AddArg(v2)
  2585  		return true
  2586  	}
  2587  }
  2588  func rewriteValueS390X_OpGreater8U_0(v *Value) bool {
  2589  	b := v.Block
  2590  	_ = b
  2591  	typ := &b.Func.Config.Types
  2592  	_ = typ
  2593  	// match: (Greater8U x y)
  2594  	// cond:
  2595  	// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPWU (MOVBZreg x) (MOVBZreg y)))
  2596  	for {
  2597  		_ = v.Args[1]
  2598  		x := v.Args[0]
  2599  		y := v.Args[1]
  2600  		v.reset(OpS390XMOVDGT)
  2601  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2602  		v0.AuxInt = 0
  2603  		v.AddArg(v0)
  2604  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2605  		v1.AuxInt = 1
  2606  		v.AddArg(v1)
  2607  		v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2608  		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  2609  		v3.AddArg(x)
  2610  		v2.AddArg(v3)
  2611  		v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  2612  		v4.AddArg(y)
  2613  		v2.AddArg(v4)
  2614  		v.AddArg(v2)
  2615  		return true
  2616  	}
  2617  }
  2618  func rewriteValueS390X_OpHmul32_0(v *Value) bool {
  2619  	b := v.Block
  2620  	_ = b
  2621  	typ := &b.Func.Config.Types
  2622  	_ = typ
  2623  	// match: (Hmul32 x y)
  2624  	// cond:
  2625  	// result: (SRDconst [32] (MULLD (MOVWreg x) (MOVWreg y)))
  2626  	for {
  2627  		_ = v.Args[1]
  2628  		x := v.Args[0]
  2629  		y := v.Args[1]
  2630  		v.reset(OpS390XSRDconst)
  2631  		v.AuxInt = 32
  2632  		v0 := b.NewValue0(v.Pos, OpS390XMULLD, typ.Int64)
  2633  		v1 := b.NewValue0(v.Pos, OpS390XMOVWreg, typ.Int64)
  2634  		v1.AddArg(x)
  2635  		v0.AddArg(v1)
  2636  		v2 := b.NewValue0(v.Pos, OpS390XMOVWreg, typ.Int64)
  2637  		v2.AddArg(y)
  2638  		v0.AddArg(v2)
  2639  		v.AddArg(v0)
  2640  		return true
  2641  	}
  2642  }
  2643  func rewriteValueS390X_OpHmul32u_0(v *Value) bool {
  2644  	b := v.Block
  2645  	_ = b
  2646  	typ := &b.Func.Config.Types
  2647  	_ = typ
  2648  	// match: (Hmul32u x y)
  2649  	// cond:
  2650  	// result: (SRDconst [32] (MULLD (MOVWZreg x) (MOVWZreg y)))
  2651  	for {
  2652  		_ = v.Args[1]
  2653  		x := v.Args[0]
  2654  		y := v.Args[1]
  2655  		v.reset(OpS390XSRDconst)
  2656  		v.AuxInt = 32
  2657  		v0 := b.NewValue0(v.Pos, OpS390XMULLD, typ.Int64)
  2658  		v1 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
  2659  		v1.AddArg(x)
  2660  		v0.AddArg(v1)
  2661  		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
  2662  		v2.AddArg(y)
  2663  		v0.AddArg(v2)
  2664  		v.AddArg(v0)
  2665  		return true
  2666  	}
  2667  }
  2668  func rewriteValueS390X_OpHmul64_0(v *Value) bool {
  2669  	// match: (Hmul64 x y)
  2670  	// cond:
  2671  	// result: (MULHD x y)
  2672  	for {
  2673  		_ = v.Args[1]
  2674  		x := v.Args[0]
  2675  		y := v.Args[1]
  2676  		v.reset(OpS390XMULHD)
  2677  		v.AddArg(x)
  2678  		v.AddArg(y)
  2679  		return true
  2680  	}
  2681  }
  2682  func rewriteValueS390X_OpHmul64u_0(v *Value) bool {
  2683  	// match: (Hmul64u x y)
  2684  	// cond:
  2685  	// result: (MULHDU x y)
  2686  	for {
  2687  		_ = v.Args[1]
  2688  		x := v.Args[0]
  2689  		y := v.Args[1]
  2690  		v.reset(OpS390XMULHDU)
  2691  		v.AddArg(x)
  2692  		v.AddArg(y)
  2693  		return true
  2694  	}
  2695  }
  2696  func rewriteValueS390X_OpITab_0(v *Value) bool {
  2697  	// match: (ITab (Load ptr mem))
  2698  	// cond:
  2699  	// result: (MOVDload ptr mem)
  2700  	for {
  2701  		v_0 := v.Args[0]
  2702  		if v_0.Op != OpLoad {
  2703  			break
  2704  		}
  2705  		_ = v_0.Args[1]
  2706  		ptr := v_0.Args[0]
  2707  		mem := v_0.Args[1]
  2708  		v.reset(OpS390XMOVDload)
  2709  		v.AddArg(ptr)
  2710  		v.AddArg(mem)
  2711  		return true
  2712  	}
  2713  	return false
  2714  }
  2715  func rewriteValueS390X_OpInterCall_0(v *Value) bool {
  2716  	// match: (InterCall [argwid] entry mem)
  2717  	// cond:
  2718  	// result: (CALLinter [argwid] entry mem)
  2719  	for {
  2720  		argwid := v.AuxInt
  2721  		_ = v.Args[1]
  2722  		entry := v.Args[0]
  2723  		mem := v.Args[1]
  2724  		v.reset(OpS390XCALLinter)
  2725  		v.AuxInt = argwid
  2726  		v.AddArg(entry)
  2727  		v.AddArg(mem)
  2728  		return true
  2729  	}
  2730  }
  2731  func rewriteValueS390X_OpIsInBounds_0(v *Value) bool {
  2732  	b := v.Block
  2733  	_ = b
  2734  	typ := &b.Func.Config.Types
  2735  	_ = typ
  2736  	// match: (IsInBounds idx len)
  2737  	// cond:
  2738  	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPU idx len))
  2739  	for {
  2740  		_ = v.Args[1]
  2741  		idx := v.Args[0]
  2742  		len := v.Args[1]
  2743  		v.reset(OpS390XMOVDLT)
  2744  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2745  		v0.AuxInt = 0
  2746  		v.AddArg(v0)
  2747  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2748  		v1.AuxInt = 1
  2749  		v.AddArg(v1)
  2750  		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
  2751  		v2.AddArg(idx)
  2752  		v2.AddArg(len)
  2753  		v.AddArg(v2)
  2754  		return true
  2755  	}
  2756  }
  2757  func rewriteValueS390X_OpIsNonNil_0(v *Value) bool {
  2758  	b := v.Block
  2759  	_ = b
  2760  	typ := &b.Func.Config.Types
  2761  	_ = typ
  2762  	// match: (IsNonNil p)
  2763  	// cond:
  2764  	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMPconst p [0]))
  2765  	for {
  2766  		p := v.Args[0]
  2767  		v.reset(OpS390XMOVDNE)
  2768  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2769  		v0.AuxInt = 0
  2770  		v.AddArg(v0)
  2771  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2772  		v1.AuxInt = 1
  2773  		v.AddArg(v1)
  2774  		v2 := b.NewValue0(v.Pos, OpS390XCMPconst, types.TypeFlags)
  2775  		v2.AuxInt = 0
  2776  		v2.AddArg(p)
  2777  		v.AddArg(v2)
  2778  		return true
  2779  	}
  2780  }
  2781  func rewriteValueS390X_OpIsSliceInBounds_0(v *Value) bool {
  2782  	b := v.Block
  2783  	_ = b
  2784  	typ := &b.Func.Config.Types
  2785  	_ = typ
  2786  	// match: (IsSliceInBounds idx len)
  2787  	// cond:
  2788  	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPU idx len))
  2789  	for {
  2790  		_ = v.Args[1]
  2791  		idx := v.Args[0]
  2792  		len := v.Args[1]
  2793  		v.reset(OpS390XMOVDLE)
  2794  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2795  		v0.AuxInt = 0
  2796  		v.AddArg(v0)
  2797  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2798  		v1.AuxInt = 1
  2799  		v.AddArg(v1)
  2800  		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
  2801  		v2.AddArg(idx)
  2802  		v2.AddArg(len)
  2803  		v.AddArg(v2)
  2804  		return true
  2805  	}
  2806  }
  2807  func rewriteValueS390X_OpLeq16_0(v *Value) bool {
  2808  	b := v.Block
  2809  	_ = b
  2810  	typ := &b.Func.Config.Types
  2811  	_ = typ
  2812  	// match: (Leq16 x y)
  2813  	// cond:
  2814  	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVHreg x) (MOVHreg y)))
  2815  	for {
  2816  		_ = v.Args[1]
  2817  		x := v.Args[0]
  2818  		y := v.Args[1]
  2819  		v.reset(OpS390XMOVDLE)
  2820  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2821  		v0.AuxInt = 0
  2822  		v.AddArg(v0)
  2823  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2824  		v1.AuxInt = 1
  2825  		v.AddArg(v1)
  2826  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2827  		v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  2828  		v3.AddArg(x)
  2829  		v2.AddArg(v3)
  2830  		v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  2831  		v4.AddArg(y)
  2832  		v2.AddArg(v4)
  2833  		v.AddArg(v2)
  2834  		return true
  2835  	}
  2836  }
  2837  func rewriteValueS390X_OpLeq16U_0(v *Value) bool {
  2838  	b := v.Block
  2839  	_ = b
  2840  	typ := &b.Func.Config.Types
  2841  	_ = typ
  2842  	// match: (Leq16U x y)
  2843  	// cond:
  2844  	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPWU (MOVHZreg x) (MOVHZreg y)))
  2845  	for {
  2846  		_ = v.Args[1]
  2847  		x := v.Args[0]
  2848  		y := v.Args[1]
  2849  		v.reset(OpS390XMOVDLE)
  2850  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2851  		v0.AuxInt = 0
  2852  		v.AddArg(v0)
  2853  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2854  		v1.AuxInt = 1
  2855  		v.AddArg(v1)
  2856  		v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2857  		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  2858  		v3.AddArg(x)
  2859  		v2.AddArg(v3)
  2860  		v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  2861  		v4.AddArg(y)
  2862  		v2.AddArg(v4)
  2863  		v.AddArg(v2)
  2864  		return true
  2865  	}
  2866  }
  2867  func rewriteValueS390X_OpLeq32_0(v *Value) bool {
  2868  	b := v.Block
  2869  	_ = b
  2870  	typ := &b.Func.Config.Types
  2871  	_ = typ
  2872  	// match: (Leq32 x y)
  2873  	// cond:
  2874  	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
  2875  	for {
  2876  		_ = v.Args[1]
  2877  		x := v.Args[0]
  2878  		y := v.Args[1]
  2879  		v.reset(OpS390XMOVDLE)
  2880  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2881  		v0.AuxInt = 0
  2882  		v.AddArg(v0)
  2883  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2884  		v1.AuxInt = 1
  2885  		v.AddArg(v1)
  2886  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  2887  		v2.AddArg(x)
  2888  		v2.AddArg(y)
  2889  		v.AddArg(v2)
  2890  		return true
  2891  	}
  2892  }
  2893  func rewriteValueS390X_OpLeq32F_0(v *Value) bool {
  2894  	b := v.Block
  2895  	_ = b
  2896  	typ := &b.Func.Config.Types
  2897  	_ = typ
  2898  	// match: (Leq32F x y)
  2899  	// cond:
  2900  	// result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS y x))
  2901  	for {
  2902  		_ = v.Args[1]
  2903  		x := v.Args[0]
  2904  		y := v.Args[1]
  2905  		v.reset(OpS390XMOVDGEnoinv)
  2906  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2907  		v0.AuxInt = 0
  2908  		v.AddArg(v0)
  2909  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2910  		v1.AuxInt = 1
  2911  		v.AddArg(v1)
  2912  		v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
  2913  		v2.AddArg(y)
  2914  		v2.AddArg(x)
  2915  		v.AddArg(v2)
  2916  		return true
  2917  	}
  2918  }
  2919  func rewriteValueS390X_OpLeq32U_0(v *Value) bool {
  2920  	b := v.Block
  2921  	_ = b
  2922  	typ := &b.Func.Config.Types
  2923  	_ = typ
  2924  	// match: (Leq32U x y)
  2925  	// cond:
  2926  	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y))
  2927  	for {
  2928  		_ = v.Args[1]
  2929  		x := v.Args[0]
  2930  		y := v.Args[1]
  2931  		v.reset(OpS390XMOVDLE)
  2932  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2933  		v0.AuxInt = 0
  2934  		v.AddArg(v0)
  2935  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2936  		v1.AuxInt = 1
  2937  		v.AddArg(v1)
  2938  		v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  2939  		v2.AddArg(x)
  2940  		v2.AddArg(y)
  2941  		v.AddArg(v2)
  2942  		return true
  2943  	}
  2944  }
  2945  func rewriteValueS390X_OpLeq64_0(v *Value) bool {
  2946  	b := v.Block
  2947  	_ = b
  2948  	typ := &b.Func.Config.Types
  2949  	_ = typ
  2950  	// match: (Leq64 x y)
  2951  	// cond:
  2952  	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
  2953  	for {
  2954  		_ = v.Args[1]
  2955  		x := v.Args[0]
  2956  		y := v.Args[1]
  2957  		v.reset(OpS390XMOVDLE)
  2958  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2959  		v0.AuxInt = 0
  2960  		v.AddArg(v0)
  2961  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2962  		v1.AuxInt = 1
  2963  		v.AddArg(v1)
  2964  		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
  2965  		v2.AddArg(x)
  2966  		v2.AddArg(y)
  2967  		v.AddArg(v2)
  2968  		return true
  2969  	}
  2970  }
  2971  func rewriteValueS390X_OpLeq64F_0(v *Value) bool {
  2972  	b := v.Block
  2973  	_ = b
  2974  	typ := &b.Func.Config.Types
  2975  	_ = typ
  2976  	// match: (Leq64F x y)
  2977  	// cond:
  2978  	// result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP y x))
  2979  	for {
  2980  		_ = v.Args[1]
  2981  		x := v.Args[0]
  2982  		y := v.Args[1]
  2983  		v.reset(OpS390XMOVDGEnoinv)
  2984  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2985  		v0.AuxInt = 0
  2986  		v.AddArg(v0)
  2987  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  2988  		v1.AuxInt = 1
  2989  		v.AddArg(v1)
  2990  		v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
  2991  		v2.AddArg(y)
  2992  		v2.AddArg(x)
  2993  		v.AddArg(v2)
  2994  		return true
  2995  	}
  2996  }
  2997  func rewriteValueS390X_OpLeq64U_0(v *Value) bool {
  2998  	b := v.Block
  2999  	_ = b
  3000  	typ := &b.Func.Config.Types
  3001  	_ = typ
  3002  	// match: (Leq64U x y)
  3003  	// cond:
  3004  	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPU x y))
  3005  	for {
  3006  		_ = v.Args[1]
  3007  		x := v.Args[0]
  3008  		y := v.Args[1]
  3009  		v.reset(OpS390XMOVDLE)
  3010  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3011  		v0.AuxInt = 0
  3012  		v.AddArg(v0)
  3013  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3014  		v1.AuxInt = 1
  3015  		v.AddArg(v1)
  3016  		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
  3017  		v2.AddArg(x)
  3018  		v2.AddArg(y)
  3019  		v.AddArg(v2)
  3020  		return true
  3021  	}
  3022  }
  3023  func rewriteValueS390X_OpLeq8_0(v *Value) bool {
  3024  	b := v.Block
  3025  	_ = b
  3026  	typ := &b.Func.Config.Types
  3027  	_ = typ
  3028  	// match: (Leq8 x y)
  3029  	// cond:
  3030  	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVBreg x) (MOVBreg y)))
  3031  	for {
  3032  		_ = v.Args[1]
  3033  		x := v.Args[0]
  3034  		y := v.Args[1]
  3035  		v.reset(OpS390XMOVDLE)
  3036  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3037  		v0.AuxInt = 0
  3038  		v.AddArg(v0)
  3039  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3040  		v1.AuxInt = 1
  3041  		v.AddArg(v1)
  3042  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  3043  		v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  3044  		v3.AddArg(x)
  3045  		v2.AddArg(v3)
  3046  		v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  3047  		v4.AddArg(y)
  3048  		v2.AddArg(v4)
  3049  		v.AddArg(v2)
  3050  		return true
  3051  	}
  3052  }
  3053  func rewriteValueS390X_OpLeq8U_0(v *Value) bool {
  3054  	b := v.Block
  3055  	_ = b
  3056  	typ := &b.Func.Config.Types
  3057  	_ = typ
  3058  	// match: (Leq8U x y)
  3059  	// cond:
  3060  	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPWU (MOVBZreg x) (MOVBZreg y)))
  3061  	for {
  3062  		_ = v.Args[1]
  3063  		x := v.Args[0]
  3064  		y := v.Args[1]
  3065  		v.reset(OpS390XMOVDLE)
  3066  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3067  		v0.AuxInt = 0
  3068  		v.AddArg(v0)
  3069  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3070  		v1.AuxInt = 1
  3071  		v.AddArg(v1)
  3072  		v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  3073  		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  3074  		v3.AddArg(x)
  3075  		v2.AddArg(v3)
  3076  		v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  3077  		v4.AddArg(y)
  3078  		v2.AddArg(v4)
  3079  		v.AddArg(v2)
  3080  		return true
  3081  	}
  3082  }
  3083  func rewriteValueS390X_OpLess16_0(v *Value) bool {
  3084  	b := v.Block
  3085  	_ = b
  3086  	typ := &b.Func.Config.Types
  3087  	_ = typ
  3088  	// match: (Less16 x y)
  3089  	// cond:
  3090  	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVHreg x) (MOVHreg y)))
  3091  	for {
  3092  		_ = v.Args[1]
  3093  		x := v.Args[0]
  3094  		y := v.Args[1]
  3095  		v.reset(OpS390XMOVDLT)
  3096  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3097  		v0.AuxInt = 0
  3098  		v.AddArg(v0)
  3099  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3100  		v1.AuxInt = 1
  3101  		v.AddArg(v1)
  3102  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  3103  		v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  3104  		v3.AddArg(x)
  3105  		v2.AddArg(v3)
  3106  		v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  3107  		v4.AddArg(y)
  3108  		v2.AddArg(v4)
  3109  		v.AddArg(v2)
  3110  		return true
  3111  	}
  3112  }
  3113  func rewriteValueS390X_OpLess16U_0(v *Value) bool {
  3114  	b := v.Block
  3115  	_ = b
  3116  	typ := &b.Func.Config.Types
  3117  	_ = typ
  3118  	// match: (Less16U x y)
  3119  	// cond:
  3120  	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPWU (MOVHZreg x) (MOVHZreg y)))
  3121  	for {
  3122  		_ = v.Args[1]
  3123  		x := v.Args[0]
  3124  		y := v.Args[1]
  3125  		v.reset(OpS390XMOVDLT)
  3126  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3127  		v0.AuxInt = 0
  3128  		v.AddArg(v0)
  3129  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3130  		v1.AuxInt = 1
  3131  		v.AddArg(v1)
  3132  		v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  3133  		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  3134  		v3.AddArg(x)
  3135  		v2.AddArg(v3)
  3136  		v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  3137  		v4.AddArg(y)
  3138  		v2.AddArg(v4)
  3139  		v.AddArg(v2)
  3140  		return true
  3141  	}
  3142  }
  3143  func rewriteValueS390X_OpLess32_0(v *Value) bool {
  3144  	b := v.Block
  3145  	_ = b
  3146  	typ := &b.Func.Config.Types
  3147  	_ = typ
  3148  	// match: (Less32 x y)
  3149  	// cond:
  3150  	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
  3151  	for {
  3152  		_ = v.Args[1]
  3153  		x := v.Args[0]
  3154  		y := v.Args[1]
  3155  		v.reset(OpS390XMOVDLT)
  3156  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3157  		v0.AuxInt = 0
  3158  		v.AddArg(v0)
  3159  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3160  		v1.AuxInt = 1
  3161  		v.AddArg(v1)
  3162  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  3163  		v2.AddArg(x)
  3164  		v2.AddArg(y)
  3165  		v.AddArg(v2)
  3166  		return true
  3167  	}
  3168  }
  3169  func rewriteValueS390X_OpLess32F_0(v *Value) bool {
  3170  	b := v.Block
  3171  	_ = b
  3172  	typ := &b.Func.Config.Types
  3173  	_ = typ
  3174  	// match: (Less32F x y)
  3175  	// cond:
  3176  	// result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS y x))
  3177  	for {
  3178  		_ = v.Args[1]
  3179  		x := v.Args[0]
  3180  		y := v.Args[1]
  3181  		v.reset(OpS390XMOVDGTnoinv)
  3182  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3183  		v0.AuxInt = 0
  3184  		v.AddArg(v0)
  3185  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3186  		v1.AuxInt = 1
  3187  		v.AddArg(v1)
  3188  		v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
  3189  		v2.AddArg(y)
  3190  		v2.AddArg(x)
  3191  		v.AddArg(v2)
  3192  		return true
  3193  	}
  3194  }
  3195  func rewriteValueS390X_OpLess32U_0(v *Value) bool {
  3196  	b := v.Block
  3197  	_ = b
  3198  	typ := &b.Func.Config.Types
  3199  	_ = typ
  3200  	// match: (Less32U x y)
  3201  	// cond:
  3202  	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y))
  3203  	for {
  3204  		_ = v.Args[1]
  3205  		x := v.Args[0]
  3206  		y := v.Args[1]
  3207  		v.reset(OpS390XMOVDLT)
  3208  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3209  		v0.AuxInt = 0
  3210  		v.AddArg(v0)
  3211  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3212  		v1.AuxInt = 1
  3213  		v.AddArg(v1)
  3214  		v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  3215  		v2.AddArg(x)
  3216  		v2.AddArg(y)
  3217  		v.AddArg(v2)
  3218  		return true
  3219  	}
  3220  }
  3221  func rewriteValueS390X_OpLess64_0(v *Value) bool {
  3222  	b := v.Block
  3223  	_ = b
  3224  	typ := &b.Func.Config.Types
  3225  	_ = typ
  3226  	// match: (Less64 x y)
  3227  	// cond:
  3228  	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
  3229  	for {
  3230  		_ = v.Args[1]
  3231  		x := v.Args[0]
  3232  		y := v.Args[1]
  3233  		v.reset(OpS390XMOVDLT)
  3234  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3235  		v0.AuxInt = 0
  3236  		v.AddArg(v0)
  3237  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3238  		v1.AuxInt = 1
  3239  		v.AddArg(v1)
  3240  		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
  3241  		v2.AddArg(x)
  3242  		v2.AddArg(y)
  3243  		v.AddArg(v2)
  3244  		return true
  3245  	}
  3246  }
  3247  func rewriteValueS390X_OpLess64F_0(v *Value) bool {
  3248  	b := v.Block
  3249  	_ = b
  3250  	typ := &b.Func.Config.Types
  3251  	_ = typ
  3252  	// match: (Less64F x y)
  3253  	// cond:
  3254  	// result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP y x))
  3255  	for {
  3256  		_ = v.Args[1]
  3257  		x := v.Args[0]
  3258  		y := v.Args[1]
  3259  		v.reset(OpS390XMOVDGTnoinv)
  3260  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3261  		v0.AuxInt = 0
  3262  		v.AddArg(v0)
  3263  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3264  		v1.AuxInt = 1
  3265  		v.AddArg(v1)
  3266  		v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
  3267  		v2.AddArg(y)
  3268  		v2.AddArg(x)
  3269  		v.AddArg(v2)
  3270  		return true
  3271  	}
  3272  }
  3273  func rewriteValueS390X_OpLess64U_0(v *Value) bool {
  3274  	b := v.Block
  3275  	_ = b
  3276  	typ := &b.Func.Config.Types
  3277  	_ = typ
  3278  	// match: (Less64U x y)
  3279  	// cond:
  3280  	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPU x y))
  3281  	for {
  3282  		_ = v.Args[1]
  3283  		x := v.Args[0]
  3284  		y := v.Args[1]
  3285  		v.reset(OpS390XMOVDLT)
  3286  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3287  		v0.AuxInt = 0
  3288  		v.AddArg(v0)
  3289  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3290  		v1.AuxInt = 1
  3291  		v.AddArg(v1)
  3292  		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
  3293  		v2.AddArg(x)
  3294  		v2.AddArg(y)
  3295  		v.AddArg(v2)
  3296  		return true
  3297  	}
  3298  }
  3299  func rewriteValueS390X_OpLess8_0(v *Value) bool {
  3300  	b := v.Block
  3301  	_ = b
  3302  	typ := &b.Func.Config.Types
  3303  	_ = typ
  3304  	// match: (Less8 x y)
  3305  	// cond:
  3306  	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVBreg x) (MOVBreg y)))
  3307  	for {
  3308  		_ = v.Args[1]
  3309  		x := v.Args[0]
  3310  		y := v.Args[1]
  3311  		v.reset(OpS390XMOVDLT)
  3312  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3313  		v0.AuxInt = 0
  3314  		v.AddArg(v0)
  3315  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3316  		v1.AuxInt = 1
  3317  		v.AddArg(v1)
  3318  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  3319  		v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  3320  		v3.AddArg(x)
  3321  		v2.AddArg(v3)
  3322  		v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  3323  		v4.AddArg(y)
  3324  		v2.AddArg(v4)
  3325  		v.AddArg(v2)
  3326  		return true
  3327  	}
  3328  }
  3329  func rewriteValueS390X_OpLess8U_0(v *Value) bool {
  3330  	b := v.Block
  3331  	_ = b
  3332  	typ := &b.Func.Config.Types
  3333  	_ = typ
  3334  	// match: (Less8U x y)
  3335  	// cond:
  3336  	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPWU (MOVBZreg x) (MOVBZreg y)))
  3337  	for {
  3338  		_ = v.Args[1]
  3339  		x := v.Args[0]
  3340  		y := v.Args[1]
  3341  		v.reset(OpS390XMOVDLT)
  3342  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3343  		v0.AuxInt = 0
  3344  		v.AddArg(v0)
  3345  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3346  		v1.AuxInt = 1
  3347  		v.AddArg(v1)
  3348  		v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
  3349  		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  3350  		v3.AddArg(x)
  3351  		v2.AddArg(v3)
  3352  		v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  3353  		v4.AddArg(y)
  3354  		v2.AddArg(v4)
  3355  		v.AddArg(v2)
  3356  		return true
  3357  	}
  3358  }
  3359  func rewriteValueS390X_OpLoad_0(v *Value) bool {
  3360  	// match: (Load <t> ptr mem)
  3361  	// cond: (is64BitInt(t) || isPtr(t))
  3362  	// result: (MOVDload ptr mem)
  3363  	for {
  3364  		t := v.Type
  3365  		_ = v.Args[1]
  3366  		ptr := v.Args[0]
  3367  		mem := v.Args[1]
  3368  		if !(is64BitInt(t) || isPtr(t)) {
  3369  			break
  3370  		}
  3371  		v.reset(OpS390XMOVDload)
  3372  		v.AddArg(ptr)
  3373  		v.AddArg(mem)
  3374  		return true
  3375  	}
  3376  	// match: (Load <t> ptr mem)
  3377  	// cond: is32BitInt(t) && isSigned(t)
  3378  	// result: (MOVWload ptr mem)
  3379  	for {
  3380  		t := v.Type
  3381  		_ = v.Args[1]
  3382  		ptr := v.Args[0]
  3383  		mem := v.Args[1]
  3384  		if !(is32BitInt(t) && isSigned(t)) {
  3385  			break
  3386  		}
  3387  		v.reset(OpS390XMOVWload)
  3388  		v.AddArg(ptr)
  3389  		v.AddArg(mem)
  3390  		return true
  3391  	}
  3392  	// match: (Load <t> ptr mem)
  3393  	// cond: is32BitInt(t) && !isSigned(t)
  3394  	// result: (MOVWZload ptr mem)
  3395  	for {
  3396  		t := v.Type
  3397  		_ = v.Args[1]
  3398  		ptr := v.Args[0]
  3399  		mem := v.Args[1]
  3400  		if !(is32BitInt(t) && !isSigned(t)) {
  3401  			break
  3402  		}
  3403  		v.reset(OpS390XMOVWZload)
  3404  		v.AddArg(ptr)
  3405  		v.AddArg(mem)
  3406  		return true
  3407  	}
  3408  	// match: (Load <t> ptr mem)
  3409  	// cond: is16BitInt(t) && isSigned(t)
  3410  	// result: (MOVHload ptr mem)
  3411  	for {
  3412  		t := v.Type
  3413  		_ = v.Args[1]
  3414  		ptr := v.Args[0]
  3415  		mem := v.Args[1]
  3416  		if !(is16BitInt(t) && isSigned(t)) {
  3417  			break
  3418  		}
  3419  		v.reset(OpS390XMOVHload)
  3420  		v.AddArg(ptr)
  3421  		v.AddArg(mem)
  3422  		return true
  3423  	}
  3424  	// match: (Load <t> ptr mem)
  3425  	// cond: is16BitInt(t) && !isSigned(t)
  3426  	// result: (MOVHZload ptr mem)
  3427  	for {
  3428  		t := v.Type
  3429  		_ = v.Args[1]
  3430  		ptr := v.Args[0]
  3431  		mem := v.Args[1]
  3432  		if !(is16BitInt(t) && !isSigned(t)) {
  3433  			break
  3434  		}
  3435  		v.reset(OpS390XMOVHZload)
  3436  		v.AddArg(ptr)
  3437  		v.AddArg(mem)
  3438  		return true
  3439  	}
  3440  	// match: (Load <t> ptr mem)
  3441  	// cond: is8BitInt(t) && isSigned(t)
  3442  	// result: (MOVBload ptr mem)
  3443  	for {
  3444  		t := v.Type
  3445  		_ = v.Args[1]
  3446  		ptr := v.Args[0]
  3447  		mem := v.Args[1]
  3448  		if !(is8BitInt(t) && isSigned(t)) {
  3449  			break
  3450  		}
  3451  		v.reset(OpS390XMOVBload)
  3452  		v.AddArg(ptr)
  3453  		v.AddArg(mem)
  3454  		return true
  3455  	}
  3456  	// match: (Load <t> ptr mem)
  3457  	// cond: (t.IsBoolean() || (is8BitInt(t) && !isSigned(t)))
  3458  	// result: (MOVBZload ptr mem)
  3459  	for {
  3460  		t := v.Type
  3461  		_ = v.Args[1]
  3462  		ptr := v.Args[0]
  3463  		mem := v.Args[1]
  3464  		if !(t.IsBoolean() || (is8BitInt(t) && !isSigned(t))) {
  3465  			break
  3466  		}
  3467  		v.reset(OpS390XMOVBZload)
  3468  		v.AddArg(ptr)
  3469  		v.AddArg(mem)
  3470  		return true
  3471  	}
  3472  	// match: (Load <t> ptr mem)
  3473  	// cond: is32BitFloat(t)
  3474  	// result: (FMOVSload ptr mem)
  3475  	for {
  3476  		t := v.Type
  3477  		_ = v.Args[1]
  3478  		ptr := v.Args[0]
  3479  		mem := v.Args[1]
  3480  		if !(is32BitFloat(t)) {
  3481  			break
  3482  		}
  3483  		v.reset(OpS390XFMOVSload)
  3484  		v.AddArg(ptr)
  3485  		v.AddArg(mem)
  3486  		return true
  3487  	}
  3488  	// match: (Load <t> ptr mem)
  3489  	// cond: is64BitFloat(t)
  3490  	// result: (FMOVDload ptr mem)
  3491  	for {
  3492  		t := v.Type
  3493  		_ = v.Args[1]
  3494  		ptr := v.Args[0]
  3495  		mem := v.Args[1]
  3496  		if !(is64BitFloat(t)) {
  3497  			break
  3498  		}
  3499  		v.reset(OpS390XFMOVDload)
  3500  		v.AddArg(ptr)
  3501  		v.AddArg(mem)
  3502  		return true
  3503  	}
  3504  	return false
  3505  }
  3506  func rewriteValueS390X_OpLocalAddr_0(v *Value) bool {
  3507  	// match: (LocalAddr {sym} base _)
  3508  	// cond:
  3509  	// result: (MOVDaddr {sym} base)
  3510  	for {
  3511  		sym := v.Aux
  3512  		_ = v.Args[1]
  3513  		base := v.Args[0]
  3514  		v.reset(OpS390XMOVDaddr)
  3515  		v.Aux = sym
  3516  		v.AddArg(base)
  3517  		return true
  3518  	}
  3519  }
  3520  func rewriteValueS390X_OpLsh16x16_0(v *Value) bool {
  3521  	b := v.Block
  3522  	_ = b
  3523  	typ := &b.Func.Config.Types
  3524  	_ = typ
  3525  	// match: (Lsh16x16 x y)
  3526  	// cond: shiftIsBounded(v)
  3527  	// result: (SLW x y)
  3528  	for {
  3529  		_ = v.Args[1]
  3530  		x := v.Args[0]
  3531  		y := v.Args[1]
  3532  		if !(shiftIsBounded(v)) {
  3533  			break
  3534  		}
  3535  		v.reset(OpS390XSLW)
  3536  		v.AddArg(x)
  3537  		v.AddArg(y)
  3538  		return true
  3539  	}
  3540  	// match: (Lsh16x16 <t> x y)
  3541  	// cond:
  3542  	// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst (MOVHZreg y) [64]))
  3543  	for {
  3544  		t := v.Type
  3545  		_ = v.Args[1]
  3546  		x := v.Args[0]
  3547  		y := v.Args[1]
  3548  		v.reset(OpS390XMOVDGE)
  3549  		v.Type = t
  3550  		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3551  		v0.AddArg(x)
  3552  		v0.AddArg(y)
  3553  		v.AddArg(v0)
  3554  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3555  		v1.AuxInt = 0
  3556  		v.AddArg(v1)
  3557  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3558  		v2.AuxInt = 64
  3559  		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  3560  		v3.AddArg(y)
  3561  		v2.AddArg(v3)
  3562  		v.AddArg(v2)
  3563  		return true
  3564  	}
  3565  }
  3566  func rewriteValueS390X_OpLsh16x32_0(v *Value) bool {
  3567  	b := v.Block
  3568  	_ = b
  3569  	typ := &b.Func.Config.Types
  3570  	_ = typ
  3571  	// match: (Lsh16x32 x y)
  3572  	// cond: shiftIsBounded(v)
  3573  	// result: (SLW x y)
  3574  	for {
  3575  		_ = v.Args[1]
  3576  		x := v.Args[0]
  3577  		y := v.Args[1]
  3578  		if !(shiftIsBounded(v)) {
  3579  			break
  3580  		}
  3581  		v.reset(OpS390XSLW)
  3582  		v.AddArg(x)
  3583  		v.AddArg(y)
  3584  		return true
  3585  	}
  3586  	// match: (Lsh16x32 <t> x y)
  3587  	// cond:
  3588  	// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst y [64]))
  3589  	for {
  3590  		t := v.Type
  3591  		_ = v.Args[1]
  3592  		x := v.Args[0]
  3593  		y := v.Args[1]
  3594  		v.reset(OpS390XMOVDGE)
  3595  		v.Type = t
  3596  		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3597  		v0.AddArg(x)
  3598  		v0.AddArg(y)
  3599  		v.AddArg(v0)
  3600  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3601  		v1.AuxInt = 0
  3602  		v.AddArg(v1)
  3603  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3604  		v2.AuxInt = 64
  3605  		v2.AddArg(y)
  3606  		v.AddArg(v2)
  3607  		return true
  3608  	}
  3609  }
  3610  func rewriteValueS390X_OpLsh16x64_0(v *Value) bool {
  3611  	b := v.Block
  3612  	_ = b
  3613  	typ := &b.Func.Config.Types
  3614  	_ = typ
  3615  	// match: (Lsh16x64 x y)
  3616  	// cond: shiftIsBounded(v)
  3617  	// result: (SLW x y)
  3618  	for {
  3619  		_ = v.Args[1]
  3620  		x := v.Args[0]
  3621  		y := v.Args[1]
  3622  		if !(shiftIsBounded(v)) {
  3623  			break
  3624  		}
  3625  		v.reset(OpS390XSLW)
  3626  		v.AddArg(x)
  3627  		v.AddArg(y)
  3628  		return true
  3629  	}
  3630  	// match: (Lsh16x64 <t> x y)
  3631  	// cond:
  3632  	// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPUconst y [64]))
  3633  	for {
  3634  		t := v.Type
  3635  		_ = v.Args[1]
  3636  		x := v.Args[0]
  3637  		y := v.Args[1]
  3638  		v.reset(OpS390XMOVDGE)
  3639  		v.Type = t
  3640  		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3641  		v0.AddArg(x)
  3642  		v0.AddArg(y)
  3643  		v.AddArg(v0)
  3644  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3645  		v1.AuxInt = 0
  3646  		v.AddArg(v1)
  3647  		v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  3648  		v2.AuxInt = 64
  3649  		v2.AddArg(y)
  3650  		v.AddArg(v2)
  3651  		return true
  3652  	}
  3653  }
  3654  func rewriteValueS390X_OpLsh16x8_0(v *Value) bool {
  3655  	b := v.Block
  3656  	_ = b
  3657  	typ := &b.Func.Config.Types
  3658  	_ = typ
  3659  	// match: (Lsh16x8 x y)
  3660  	// cond: shiftIsBounded(v)
  3661  	// result: (SLW x y)
  3662  	for {
  3663  		_ = v.Args[1]
  3664  		x := v.Args[0]
  3665  		y := v.Args[1]
  3666  		if !(shiftIsBounded(v)) {
  3667  			break
  3668  		}
  3669  		v.reset(OpS390XSLW)
  3670  		v.AddArg(x)
  3671  		v.AddArg(y)
  3672  		return true
  3673  	}
  3674  	// match: (Lsh16x8 <t> x y)
  3675  	// cond:
  3676  	// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst (MOVBZreg y) [64]))
  3677  	for {
  3678  		t := v.Type
  3679  		_ = v.Args[1]
  3680  		x := v.Args[0]
  3681  		y := v.Args[1]
  3682  		v.reset(OpS390XMOVDGE)
  3683  		v.Type = t
  3684  		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3685  		v0.AddArg(x)
  3686  		v0.AddArg(y)
  3687  		v.AddArg(v0)
  3688  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3689  		v1.AuxInt = 0
  3690  		v.AddArg(v1)
  3691  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3692  		v2.AuxInt = 64
  3693  		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  3694  		v3.AddArg(y)
  3695  		v2.AddArg(v3)
  3696  		v.AddArg(v2)
  3697  		return true
  3698  	}
  3699  }
  3700  func rewriteValueS390X_OpLsh32x16_0(v *Value) bool {
  3701  	b := v.Block
  3702  	_ = b
  3703  	typ := &b.Func.Config.Types
  3704  	_ = typ
  3705  	// match: (Lsh32x16 x y)
  3706  	// cond: shiftIsBounded(v)
  3707  	// result: (SLW x y)
  3708  	for {
  3709  		_ = v.Args[1]
  3710  		x := v.Args[0]
  3711  		y := v.Args[1]
  3712  		if !(shiftIsBounded(v)) {
  3713  			break
  3714  		}
  3715  		v.reset(OpS390XSLW)
  3716  		v.AddArg(x)
  3717  		v.AddArg(y)
  3718  		return true
  3719  	}
  3720  	// match: (Lsh32x16 <t> x y)
  3721  	// cond:
  3722  	// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst (MOVHZreg y) [64]))
  3723  	for {
  3724  		t := v.Type
  3725  		_ = v.Args[1]
  3726  		x := v.Args[0]
  3727  		y := v.Args[1]
  3728  		v.reset(OpS390XMOVDGE)
  3729  		v.Type = t
  3730  		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3731  		v0.AddArg(x)
  3732  		v0.AddArg(y)
  3733  		v.AddArg(v0)
  3734  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3735  		v1.AuxInt = 0
  3736  		v.AddArg(v1)
  3737  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3738  		v2.AuxInt = 64
  3739  		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  3740  		v3.AddArg(y)
  3741  		v2.AddArg(v3)
  3742  		v.AddArg(v2)
  3743  		return true
  3744  	}
  3745  }
  3746  func rewriteValueS390X_OpLsh32x32_0(v *Value) bool {
  3747  	b := v.Block
  3748  	_ = b
  3749  	typ := &b.Func.Config.Types
  3750  	_ = typ
  3751  	// match: (Lsh32x32 x y)
  3752  	// cond: shiftIsBounded(v)
  3753  	// result: (SLW x y)
  3754  	for {
  3755  		_ = v.Args[1]
  3756  		x := v.Args[0]
  3757  		y := v.Args[1]
  3758  		if !(shiftIsBounded(v)) {
  3759  			break
  3760  		}
  3761  		v.reset(OpS390XSLW)
  3762  		v.AddArg(x)
  3763  		v.AddArg(y)
  3764  		return true
  3765  	}
  3766  	// match: (Lsh32x32 <t> x y)
  3767  	// cond:
  3768  	// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst y [64]))
  3769  	for {
  3770  		t := v.Type
  3771  		_ = v.Args[1]
  3772  		x := v.Args[0]
  3773  		y := v.Args[1]
  3774  		v.reset(OpS390XMOVDGE)
  3775  		v.Type = t
  3776  		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3777  		v0.AddArg(x)
  3778  		v0.AddArg(y)
  3779  		v.AddArg(v0)
  3780  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3781  		v1.AuxInt = 0
  3782  		v.AddArg(v1)
  3783  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3784  		v2.AuxInt = 64
  3785  		v2.AddArg(y)
  3786  		v.AddArg(v2)
  3787  		return true
  3788  	}
  3789  }
  3790  func rewriteValueS390X_OpLsh32x64_0(v *Value) bool {
  3791  	b := v.Block
  3792  	_ = b
  3793  	typ := &b.Func.Config.Types
  3794  	_ = typ
  3795  	// match: (Lsh32x64 x y)
  3796  	// cond: shiftIsBounded(v)
  3797  	// result: (SLW x y)
  3798  	for {
  3799  		_ = v.Args[1]
  3800  		x := v.Args[0]
  3801  		y := v.Args[1]
  3802  		if !(shiftIsBounded(v)) {
  3803  			break
  3804  		}
  3805  		v.reset(OpS390XSLW)
  3806  		v.AddArg(x)
  3807  		v.AddArg(y)
  3808  		return true
  3809  	}
  3810  	// match: (Lsh32x64 <t> x y)
  3811  	// cond:
  3812  	// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPUconst y [64]))
  3813  	for {
  3814  		t := v.Type
  3815  		_ = v.Args[1]
  3816  		x := v.Args[0]
  3817  		y := v.Args[1]
  3818  		v.reset(OpS390XMOVDGE)
  3819  		v.Type = t
  3820  		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3821  		v0.AddArg(x)
  3822  		v0.AddArg(y)
  3823  		v.AddArg(v0)
  3824  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3825  		v1.AuxInt = 0
  3826  		v.AddArg(v1)
  3827  		v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  3828  		v2.AuxInt = 64
  3829  		v2.AddArg(y)
  3830  		v.AddArg(v2)
  3831  		return true
  3832  	}
  3833  }
  3834  func rewriteValueS390X_OpLsh32x8_0(v *Value) bool {
  3835  	b := v.Block
  3836  	_ = b
  3837  	typ := &b.Func.Config.Types
  3838  	_ = typ
  3839  	// match: (Lsh32x8 x y)
  3840  	// cond: shiftIsBounded(v)
  3841  	// result: (SLW x y)
  3842  	for {
  3843  		_ = v.Args[1]
  3844  		x := v.Args[0]
  3845  		y := v.Args[1]
  3846  		if !(shiftIsBounded(v)) {
  3847  			break
  3848  		}
  3849  		v.reset(OpS390XSLW)
  3850  		v.AddArg(x)
  3851  		v.AddArg(y)
  3852  		return true
  3853  	}
  3854  	// match: (Lsh32x8 <t> x y)
  3855  	// cond:
  3856  	// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst (MOVBZreg y) [64]))
  3857  	for {
  3858  		t := v.Type
  3859  		_ = v.Args[1]
  3860  		x := v.Args[0]
  3861  		y := v.Args[1]
  3862  		v.reset(OpS390XMOVDGE)
  3863  		v.Type = t
  3864  		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  3865  		v0.AddArg(x)
  3866  		v0.AddArg(y)
  3867  		v.AddArg(v0)
  3868  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3869  		v1.AuxInt = 0
  3870  		v.AddArg(v1)
  3871  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3872  		v2.AuxInt = 64
  3873  		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  3874  		v3.AddArg(y)
  3875  		v2.AddArg(v3)
  3876  		v.AddArg(v2)
  3877  		return true
  3878  	}
  3879  }
  3880  func rewriteValueS390X_OpLsh64x16_0(v *Value) bool {
  3881  	b := v.Block
  3882  	_ = b
  3883  	typ := &b.Func.Config.Types
  3884  	_ = typ
  3885  	// match: (Lsh64x16 x y)
  3886  	// cond: shiftIsBounded(v)
  3887  	// result: (SLD x y)
  3888  	for {
  3889  		_ = v.Args[1]
  3890  		x := v.Args[0]
  3891  		y := v.Args[1]
  3892  		if !(shiftIsBounded(v)) {
  3893  			break
  3894  		}
  3895  		v.reset(OpS390XSLD)
  3896  		v.AddArg(x)
  3897  		v.AddArg(y)
  3898  		return true
  3899  	}
  3900  	// match: (Lsh64x16 <t> x y)
  3901  	// cond:
  3902  	// result: (MOVDGE <t> (SLD <t> x y) (MOVDconst [0]) (CMPWUconst (MOVHZreg y) [64]))
  3903  	for {
  3904  		t := v.Type
  3905  		_ = v.Args[1]
  3906  		x := v.Args[0]
  3907  		y := v.Args[1]
  3908  		v.reset(OpS390XMOVDGE)
  3909  		v.Type = t
  3910  		v0 := b.NewValue0(v.Pos, OpS390XSLD, t)
  3911  		v0.AddArg(x)
  3912  		v0.AddArg(y)
  3913  		v.AddArg(v0)
  3914  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3915  		v1.AuxInt = 0
  3916  		v.AddArg(v1)
  3917  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3918  		v2.AuxInt = 64
  3919  		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  3920  		v3.AddArg(y)
  3921  		v2.AddArg(v3)
  3922  		v.AddArg(v2)
  3923  		return true
  3924  	}
  3925  }
  3926  func rewriteValueS390X_OpLsh64x32_0(v *Value) bool {
  3927  	b := v.Block
  3928  	_ = b
  3929  	typ := &b.Func.Config.Types
  3930  	_ = typ
  3931  	// match: (Lsh64x32 x y)
  3932  	// cond: shiftIsBounded(v)
  3933  	// result: (SLD x y)
  3934  	for {
  3935  		_ = v.Args[1]
  3936  		x := v.Args[0]
  3937  		y := v.Args[1]
  3938  		if !(shiftIsBounded(v)) {
  3939  			break
  3940  		}
  3941  		v.reset(OpS390XSLD)
  3942  		v.AddArg(x)
  3943  		v.AddArg(y)
  3944  		return true
  3945  	}
  3946  	// match: (Lsh64x32 <t> x y)
  3947  	// cond:
  3948  	// result: (MOVDGE <t> (SLD <t> x y) (MOVDconst [0]) (CMPWUconst y [64]))
  3949  	for {
  3950  		t := v.Type
  3951  		_ = v.Args[1]
  3952  		x := v.Args[0]
  3953  		y := v.Args[1]
  3954  		v.reset(OpS390XMOVDGE)
  3955  		v.Type = t
  3956  		v0 := b.NewValue0(v.Pos, OpS390XSLD, t)
  3957  		v0.AddArg(x)
  3958  		v0.AddArg(y)
  3959  		v.AddArg(v0)
  3960  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  3961  		v1.AuxInt = 0
  3962  		v.AddArg(v1)
  3963  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  3964  		v2.AuxInt = 64
  3965  		v2.AddArg(y)
  3966  		v.AddArg(v2)
  3967  		return true
  3968  	}
  3969  }
  3970  func rewriteValueS390X_OpLsh64x64_0(v *Value) bool {
  3971  	b := v.Block
  3972  	_ = b
  3973  	typ := &b.Func.Config.Types
  3974  	_ = typ
  3975  	// match: (Lsh64x64 x y)
  3976  	// cond: shiftIsBounded(v)
  3977  	// result: (SLD x y)
  3978  	for {
  3979  		_ = v.Args[1]
  3980  		x := v.Args[0]
  3981  		y := v.Args[1]
  3982  		if !(shiftIsBounded(v)) {
  3983  			break
  3984  		}
  3985  		v.reset(OpS390XSLD)
  3986  		v.AddArg(x)
  3987  		v.AddArg(y)
  3988  		return true
  3989  	}
  3990  	// match: (Lsh64x64 <t> x y)
  3991  	// cond:
  3992  	// result: (MOVDGE <t> (SLD <t> x y) (MOVDconst [0]) (CMPUconst y [64]))
  3993  	for {
  3994  		t := v.Type
  3995  		_ = v.Args[1]
  3996  		x := v.Args[0]
  3997  		y := v.Args[1]
  3998  		v.reset(OpS390XMOVDGE)
  3999  		v.Type = t
  4000  		v0 := b.NewValue0(v.Pos, OpS390XSLD, t)
  4001  		v0.AddArg(x)
  4002  		v0.AddArg(y)
  4003  		v.AddArg(v0)
  4004  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4005  		v1.AuxInt = 0
  4006  		v.AddArg(v1)
  4007  		v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  4008  		v2.AuxInt = 64
  4009  		v2.AddArg(y)
  4010  		v.AddArg(v2)
  4011  		return true
  4012  	}
  4013  }
  4014  func rewriteValueS390X_OpLsh64x8_0(v *Value) bool {
  4015  	b := v.Block
  4016  	_ = b
  4017  	typ := &b.Func.Config.Types
  4018  	_ = typ
  4019  	// match: (Lsh64x8 x y)
  4020  	// cond: shiftIsBounded(v)
  4021  	// result: (SLD x y)
  4022  	for {
  4023  		_ = v.Args[1]
  4024  		x := v.Args[0]
  4025  		y := v.Args[1]
  4026  		if !(shiftIsBounded(v)) {
  4027  			break
  4028  		}
  4029  		v.reset(OpS390XSLD)
  4030  		v.AddArg(x)
  4031  		v.AddArg(y)
  4032  		return true
  4033  	}
  4034  	// match: (Lsh64x8 <t> x y)
  4035  	// cond:
  4036  	// result: (MOVDGE <t> (SLD <t> x y) (MOVDconst [0]) (CMPWUconst (MOVBZreg y) [64]))
  4037  	for {
  4038  		t := v.Type
  4039  		_ = v.Args[1]
  4040  		x := v.Args[0]
  4041  		y := v.Args[1]
  4042  		v.reset(OpS390XMOVDGE)
  4043  		v.Type = t
  4044  		v0 := b.NewValue0(v.Pos, OpS390XSLD, t)
  4045  		v0.AddArg(x)
  4046  		v0.AddArg(y)
  4047  		v.AddArg(v0)
  4048  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4049  		v1.AuxInt = 0
  4050  		v.AddArg(v1)
  4051  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  4052  		v2.AuxInt = 64
  4053  		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  4054  		v3.AddArg(y)
  4055  		v2.AddArg(v3)
  4056  		v.AddArg(v2)
  4057  		return true
  4058  	}
  4059  }
  4060  func rewriteValueS390X_OpLsh8x16_0(v *Value) bool {
  4061  	b := v.Block
  4062  	_ = b
  4063  	typ := &b.Func.Config.Types
  4064  	_ = typ
  4065  	// match: (Lsh8x16 x y)
  4066  	// cond: shiftIsBounded(v)
  4067  	// result: (SLW x y)
  4068  	for {
  4069  		_ = v.Args[1]
  4070  		x := v.Args[0]
  4071  		y := v.Args[1]
  4072  		if !(shiftIsBounded(v)) {
  4073  			break
  4074  		}
  4075  		v.reset(OpS390XSLW)
  4076  		v.AddArg(x)
  4077  		v.AddArg(y)
  4078  		return true
  4079  	}
  4080  	// match: (Lsh8x16 <t> x y)
  4081  	// cond:
  4082  	// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst (MOVHZreg y) [64]))
  4083  	for {
  4084  		t := v.Type
  4085  		_ = v.Args[1]
  4086  		x := v.Args[0]
  4087  		y := v.Args[1]
  4088  		v.reset(OpS390XMOVDGE)
  4089  		v.Type = t
  4090  		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  4091  		v0.AddArg(x)
  4092  		v0.AddArg(y)
  4093  		v.AddArg(v0)
  4094  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4095  		v1.AuxInt = 0
  4096  		v.AddArg(v1)
  4097  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  4098  		v2.AuxInt = 64
  4099  		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  4100  		v3.AddArg(y)
  4101  		v2.AddArg(v3)
  4102  		v.AddArg(v2)
  4103  		return true
  4104  	}
  4105  }
  4106  func rewriteValueS390X_OpLsh8x32_0(v *Value) bool {
  4107  	b := v.Block
  4108  	_ = b
  4109  	typ := &b.Func.Config.Types
  4110  	_ = typ
  4111  	// match: (Lsh8x32 x y)
  4112  	// cond: shiftIsBounded(v)
  4113  	// result: (SLW x y)
  4114  	for {
  4115  		_ = v.Args[1]
  4116  		x := v.Args[0]
  4117  		y := v.Args[1]
  4118  		if !(shiftIsBounded(v)) {
  4119  			break
  4120  		}
  4121  		v.reset(OpS390XSLW)
  4122  		v.AddArg(x)
  4123  		v.AddArg(y)
  4124  		return true
  4125  	}
  4126  	// match: (Lsh8x32 <t> x y)
  4127  	// cond:
  4128  	// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst y [64]))
  4129  	for {
  4130  		t := v.Type
  4131  		_ = v.Args[1]
  4132  		x := v.Args[0]
  4133  		y := v.Args[1]
  4134  		v.reset(OpS390XMOVDGE)
  4135  		v.Type = t
  4136  		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  4137  		v0.AddArg(x)
  4138  		v0.AddArg(y)
  4139  		v.AddArg(v0)
  4140  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4141  		v1.AuxInt = 0
  4142  		v.AddArg(v1)
  4143  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  4144  		v2.AuxInt = 64
  4145  		v2.AddArg(y)
  4146  		v.AddArg(v2)
  4147  		return true
  4148  	}
  4149  }
  4150  func rewriteValueS390X_OpLsh8x64_0(v *Value) bool {
  4151  	b := v.Block
  4152  	_ = b
  4153  	typ := &b.Func.Config.Types
  4154  	_ = typ
  4155  	// match: (Lsh8x64 x y)
  4156  	// cond: shiftIsBounded(v)
  4157  	// result: (SLW x y)
  4158  	for {
  4159  		_ = v.Args[1]
  4160  		x := v.Args[0]
  4161  		y := v.Args[1]
  4162  		if !(shiftIsBounded(v)) {
  4163  			break
  4164  		}
  4165  		v.reset(OpS390XSLW)
  4166  		v.AddArg(x)
  4167  		v.AddArg(y)
  4168  		return true
  4169  	}
  4170  	// match: (Lsh8x64 <t> x y)
  4171  	// cond:
  4172  	// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPUconst y [64]))
  4173  	for {
  4174  		t := v.Type
  4175  		_ = v.Args[1]
  4176  		x := v.Args[0]
  4177  		y := v.Args[1]
  4178  		v.reset(OpS390XMOVDGE)
  4179  		v.Type = t
  4180  		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  4181  		v0.AddArg(x)
  4182  		v0.AddArg(y)
  4183  		v.AddArg(v0)
  4184  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4185  		v1.AuxInt = 0
  4186  		v.AddArg(v1)
  4187  		v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  4188  		v2.AuxInt = 64
  4189  		v2.AddArg(y)
  4190  		v.AddArg(v2)
  4191  		return true
  4192  	}
  4193  }
  4194  func rewriteValueS390X_OpLsh8x8_0(v *Value) bool {
  4195  	b := v.Block
  4196  	_ = b
  4197  	typ := &b.Func.Config.Types
  4198  	_ = typ
  4199  	// match: (Lsh8x8 x y)
  4200  	// cond: shiftIsBounded(v)
  4201  	// result: (SLW x y)
  4202  	for {
  4203  		_ = v.Args[1]
  4204  		x := v.Args[0]
  4205  		y := v.Args[1]
  4206  		if !(shiftIsBounded(v)) {
  4207  			break
  4208  		}
  4209  		v.reset(OpS390XSLW)
  4210  		v.AddArg(x)
  4211  		v.AddArg(y)
  4212  		return true
  4213  	}
  4214  	// match: (Lsh8x8 <t> x y)
  4215  	// cond:
  4216  	// result: (MOVDGE <t> (SLW <t> x y) (MOVDconst [0]) (CMPWUconst (MOVBZreg y) [64]))
  4217  	for {
  4218  		t := v.Type
  4219  		_ = v.Args[1]
  4220  		x := v.Args[0]
  4221  		y := v.Args[1]
  4222  		v.reset(OpS390XMOVDGE)
  4223  		v.Type = t
  4224  		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
  4225  		v0.AddArg(x)
  4226  		v0.AddArg(y)
  4227  		v.AddArg(v0)
  4228  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4229  		v1.AuxInt = 0
  4230  		v.AddArg(v1)
  4231  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  4232  		v2.AuxInt = 64
  4233  		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  4234  		v3.AddArg(y)
  4235  		v2.AddArg(v3)
  4236  		v.AddArg(v2)
  4237  		return true
  4238  	}
  4239  }
  4240  func rewriteValueS390X_OpMod16_0(v *Value) bool {
  4241  	b := v.Block
  4242  	_ = b
  4243  	typ := &b.Func.Config.Types
  4244  	_ = typ
  4245  	// match: (Mod16 x y)
  4246  	// cond:
  4247  	// result: (MODW (MOVHreg x) (MOVHreg y))
  4248  	for {
  4249  		_ = v.Args[1]
  4250  		x := v.Args[0]
  4251  		y := v.Args[1]
  4252  		v.reset(OpS390XMODW)
  4253  		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  4254  		v0.AddArg(x)
  4255  		v.AddArg(v0)
  4256  		v1 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  4257  		v1.AddArg(y)
  4258  		v.AddArg(v1)
  4259  		return true
  4260  	}
  4261  }
  4262  func rewriteValueS390X_OpMod16u_0(v *Value) bool {
  4263  	b := v.Block
  4264  	_ = b
  4265  	typ := &b.Func.Config.Types
  4266  	_ = typ
  4267  	// match: (Mod16u x y)
  4268  	// cond:
  4269  	// result: (MODWU (MOVHZreg x) (MOVHZreg y))
  4270  	for {
  4271  		_ = v.Args[1]
  4272  		x := v.Args[0]
  4273  		y := v.Args[1]
  4274  		v.reset(OpS390XMODWU)
  4275  		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  4276  		v0.AddArg(x)
  4277  		v.AddArg(v0)
  4278  		v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  4279  		v1.AddArg(y)
  4280  		v.AddArg(v1)
  4281  		return true
  4282  	}
  4283  }
  4284  func rewriteValueS390X_OpMod32_0(v *Value) bool {
  4285  	b := v.Block
  4286  	_ = b
  4287  	typ := &b.Func.Config.Types
  4288  	_ = typ
  4289  	// match: (Mod32 x y)
  4290  	// cond:
  4291  	// result: (MODW (MOVWreg x) y)
  4292  	for {
  4293  		_ = v.Args[1]
  4294  		x := v.Args[0]
  4295  		y := v.Args[1]
  4296  		v.reset(OpS390XMODW)
  4297  		v0 := b.NewValue0(v.Pos, OpS390XMOVWreg, typ.Int64)
  4298  		v0.AddArg(x)
  4299  		v.AddArg(v0)
  4300  		v.AddArg(y)
  4301  		return true
  4302  	}
  4303  }
  4304  func rewriteValueS390X_OpMod32u_0(v *Value) bool {
  4305  	b := v.Block
  4306  	_ = b
  4307  	typ := &b.Func.Config.Types
  4308  	_ = typ
  4309  	// match: (Mod32u x y)
  4310  	// cond:
  4311  	// result: (MODWU (MOVWZreg x) y)
  4312  	for {
  4313  		_ = v.Args[1]
  4314  		x := v.Args[0]
  4315  		y := v.Args[1]
  4316  		v.reset(OpS390XMODWU)
  4317  		v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
  4318  		v0.AddArg(x)
  4319  		v.AddArg(v0)
  4320  		v.AddArg(y)
  4321  		return true
  4322  	}
  4323  }
  4324  func rewriteValueS390X_OpMod64_0(v *Value) bool {
  4325  	// match: (Mod64 x y)
  4326  	// cond:
  4327  	// result: (MODD x y)
  4328  	for {
  4329  		_ = v.Args[1]
  4330  		x := v.Args[0]
  4331  		y := v.Args[1]
  4332  		v.reset(OpS390XMODD)
  4333  		v.AddArg(x)
  4334  		v.AddArg(y)
  4335  		return true
  4336  	}
  4337  }
  4338  func rewriteValueS390X_OpMod64u_0(v *Value) bool {
  4339  	// match: (Mod64u x y)
  4340  	// cond:
  4341  	// result: (MODDU x y)
  4342  	for {
  4343  		_ = v.Args[1]
  4344  		x := v.Args[0]
  4345  		y := v.Args[1]
  4346  		v.reset(OpS390XMODDU)
  4347  		v.AddArg(x)
  4348  		v.AddArg(y)
  4349  		return true
  4350  	}
  4351  }
  4352  func rewriteValueS390X_OpMod8_0(v *Value) bool {
  4353  	b := v.Block
  4354  	_ = b
  4355  	typ := &b.Func.Config.Types
  4356  	_ = typ
  4357  	// match: (Mod8 x y)
  4358  	// cond:
  4359  	// result: (MODW (MOVBreg x) (MOVBreg y))
  4360  	for {
  4361  		_ = v.Args[1]
  4362  		x := v.Args[0]
  4363  		y := v.Args[1]
  4364  		v.reset(OpS390XMODW)
  4365  		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  4366  		v0.AddArg(x)
  4367  		v.AddArg(v0)
  4368  		v1 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  4369  		v1.AddArg(y)
  4370  		v.AddArg(v1)
  4371  		return true
  4372  	}
  4373  }
  4374  func rewriteValueS390X_OpMod8u_0(v *Value) bool {
  4375  	b := v.Block
  4376  	_ = b
  4377  	typ := &b.Func.Config.Types
  4378  	_ = typ
  4379  	// match: (Mod8u x y)
  4380  	// cond:
  4381  	// result: (MODWU (MOVBZreg x) (MOVBZreg y))
  4382  	for {
  4383  		_ = v.Args[1]
  4384  		x := v.Args[0]
  4385  		y := v.Args[1]
  4386  		v.reset(OpS390XMODWU)
  4387  		v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  4388  		v0.AddArg(x)
  4389  		v.AddArg(v0)
  4390  		v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  4391  		v1.AddArg(y)
  4392  		v.AddArg(v1)
  4393  		return true
  4394  	}
  4395  }
  4396  func rewriteValueS390X_OpMove_0(v *Value) bool {
  4397  	b := v.Block
  4398  	_ = b
  4399  	typ := &b.Func.Config.Types
  4400  	_ = typ
  4401  	// match: (Move [0] _ _ mem)
  4402  	// cond:
  4403  	// result: mem
  4404  	for {
  4405  		if v.AuxInt != 0 {
  4406  			break
  4407  		}
  4408  		_ = v.Args[2]
  4409  		mem := v.Args[2]
  4410  		v.reset(OpCopy)
  4411  		v.Type = mem.Type
  4412  		v.AddArg(mem)
  4413  		return true
  4414  	}
  4415  	// match: (Move [1] dst src mem)
  4416  	// cond:
  4417  	// result: (MOVBstore dst (MOVBZload src mem) mem)
  4418  	for {
  4419  		if v.AuxInt != 1 {
  4420  			break
  4421  		}
  4422  		_ = v.Args[2]
  4423  		dst := v.Args[0]
  4424  		src := v.Args[1]
  4425  		mem := v.Args[2]
  4426  		v.reset(OpS390XMOVBstore)
  4427  		v.AddArg(dst)
  4428  		v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, typ.UInt8)
  4429  		v0.AddArg(src)
  4430  		v0.AddArg(mem)
  4431  		v.AddArg(v0)
  4432  		v.AddArg(mem)
  4433  		return true
  4434  	}
  4435  	// match: (Move [2] dst src mem)
  4436  	// cond:
  4437  	// result: (MOVHstore dst (MOVHZload src mem) mem)
  4438  	for {
  4439  		if v.AuxInt != 2 {
  4440  			break
  4441  		}
  4442  		_ = v.Args[2]
  4443  		dst := v.Args[0]
  4444  		src := v.Args[1]
  4445  		mem := v.Args[2]
  4446  		v.reset(OpS390XMOVHstore)
  4447  		v.AddArg(dst)
  4448  		v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
  4449  		v0.AddArg(src)
  4450  		v0.AddArg(mem)
  4451  		v.AddArg(v0)
  4452  		v.AddArg(mem)
  4453  		return true
  4454  	}
  4455  	// match: (Move [4] dst src mem)
  4456  	// cond:
  4457  	// result: (MOVWstore dst (MOVWZload src mem) mem)
  4458  	for {
  4459  		if v.AuxInt != 4 {
  4460  			break
  4461  		}
  4462  		_ = v.Args[2]
  4463  		dst := v.Args[0]
  4464  		src := v.Args[1]
  4465  		mem := v.Args[2]
  4466  		v.reset(OpS390XMOVWstore)
  4467  		v.AddArg(dst)
  4468  		v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
  4469  		v0.AddArg(src)
  4470  		v0.AddArg(mem)
  4471  		v.AddArg(v0)
  4472  		v.AddArg(mem)
  4473  		return true
  4474  	}
  4475  	// match: (Move [8] dst src mem)
  4476  	// cond:
  4477  	// result: (MOVDstore dst (MOVDload src mem) mem)
  4478  	for {
  4479  		if v.AuxInt != 8 {
  4480  			break
  4481  		}
  4482  		_ = v.Args[2]
  4483  		dst := v.Args[0]
  4484  		src := v.Args[1]
  4485  		mem := v.Args[2]
  4486  		v.reset(OpS390XMOVDstore)
  4487  		v.AddArg(dst)
  4488  		v0 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
  4489  		v0.AddArg(src)
  4490  		v0.AddArg(mem)
  4491  		v.AddArg(v0)
  4492  		v.AddArg(mem)
  4493  		return true
  4494  	}
  4495  	// match: (Move [16] dst src mem)
  4496  	// cond:
  4497  	// result: (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem))
  4498  	for {
  4499  		if v.AuxInt != 16 {
  4500  			break
  4501  		}
  4502  		_ = v.Args[2]
  4503  		dst := v.Args[0]
  4504  		src := v.Args[1]
  4505  		mem := v.Args[2]
  4506  		v.reset(OpS390XMOVDstore)
  4507  		v.AuxInt = 8
  4508  		v.AddArg(dst)
  4509  		v0 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
  4510  		v0.AuxInt = 8
  4511  		v0.AddArg(src)
  4512  		v0.AddArg(mem)
  4513  		v.AddArg(v0)
  4514  		v1 := b.NewValue0(v.Pos, OpS390XMOVDstore, types.TypeMem)
  4515  		v1.AddArg(dst)
  4516  		v2 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
  4517  		v2.AddArg(src)
  4518  		v2.AddArg(mem)
  4519  		v1.AddArg(v2)
  4520  		v1.AddArg(mem)
  4521  		v.AddArg(v1)
  4522  		return true
  4523  	}
  4524  	// match: (Move [24] dst src mem)
  4525  	// cond:
  4526  	// result: (MOVDstore [16] dst (MOVDload [16] src mem) (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem)))
  4527  	for {
  4528  		if v.AuxInt != 24 {
  4529  			break
  4530  		}
  4531  		_ = v.Args[2]
  4532  		dst := v.Args[0]
  4533  		src := v.Args[1]
  4534  		mem := v.Args[2]
  4535  		v.reset(OpS390XMOVDstore)
  4536  		v.AuxInt = 16
  4537  		v.AddArg(dst)
  4538  		v0 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
  4539  		v0.AuxInt = 16
  4540  		v0.AddArg(src)
  4541  		v0.AddArg(mem)
  4542  		v.AddArg(v0)
  4543  		v1 := b.NewValue0(v.Pos, OpS390XMOVDstore, types.TypeMem)
  4544  		v1.AuxInt = 8
  4545  		v1.AddArg(dst)
  4546  		v2 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
  4547  		v2.AuxInt = 8
  4548  		v2.AddArg(src)
  4549  		v2.AddArg(mem)
  4550  		v1.AddArg(v2)
  4551  		v3 := b.NewValue0(v.Pos, OpS390XMOVDstore, types.TypeMem)
  4552  		v3.AddArg(dst)
  4553  		v4 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
  4554  		v4.AddArg(src)
  4555  		v4.AddArg(mem)
  4556  		v3.AddArg(v4)
  4557  		v3.AddArg(mem)
  4558  		v1.AddArg(v3)
  4559  		v.AddArg(v1)
  4560  		return true
  4561  	}
  4562  	// match: (Move [3] dst src mem)
  4563  	// cond:
  4564  	// result: (MOVBstore [2] dst (MOVBZload [2] src mem) (MOVHstore dst (MOVHZload src mem) mem))
  4565  	for {
  4566  		if v.AuxInt != 3 {
  4567  			break
  4568  		}
  4569  		_ = v.Args[2]
  4570  		dst := v.Args[0]
  4571  		src := v.Args[1]
  4572  		mem := v.Args[2]
  4573  		v.reset(OpS390XMOVBstore)
  4574  		v.AuxInt = 2
  4575  		v.AddArg(dst)
  4576  		v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, typ.UInt8)
  4577  		v0.AuxInt = 2
  4578  		v0.AddArg(src)
  4579  		v0.AddArg(mem)
  4580  		v.AddArg(v0)
  4581  		v1 := b.NewValue0(v.Pos, OpS390XMOVHstore, types.TypeMem)
  4582  		v1.AddArg(dst)
  4583  		v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
  4584  		v2.AddArg(src)
  4585  		v2.AddArg(mem)
  4586  		v1.AddArg(v2)
  4587  		v1.AddArg(mem)
  4588  		v.AddArg(v1)
  4589  		return true
  4590  	}
  4591  	// match: (Move [5] dst src mem)
  4592  	// cond:
  4593  	// result: (MOVBstore [4] dst (MOVBZload [4] src mem) (MOVWstore dst (MOVWZload src mem) mem))
  4594  	for {
  4595  		if v.AuxInt != 5 {
  4596  			break
  4597  		}
  4598  		_ = v.Args[2]
  4599  		dst := v.Args[0]
  4600  		src := v.Args[1]
  4601  		mem := v.Args[2]
  4602  		v.reset(OpS390XMOVBstore)
  4603  		v.AuxInt = 4
  4604  		v.AddArg(dst)
  4605  		v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, typ.UInt8)
  4606  		v0.AuxInt = 4
  4607  		v0.AddArg(src)
  4608  		v0.AddArg(mem)
  4609  		v.AddArg(v0)
  4610  		v1 := b.NewValue0(v.Pos, OpS390XMOVWstore, types.TypeMem)
  4611  		v1.AddArg(dst)
  4612  		v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
  4613  		v2.AddArg(src)
  4614  		v2.AddArg(mem)
  4615  		v1.AddArg(v2)
  4616  		v1.AddArg(mem)
  4617  		v.AddArg(v1)
  4618  		return true
  4619  	}
  4620  	// match: (Move [6] dst src mem)
  4621  	// cond:
  4622  	// result: (MOVHstore [4] dst (MOVHZload [4] src mem) (MOVWstore dst (MOVWZload src mem) mem))
  4623  	for {
  4624  		if v.AuxInt != 6 {
  4625  			break
  4626  		}
  4627  		_ = v.Args[2]
  4628  		dst := v.Args[0]
  4629  		src := v.Args[1]
  4630  		mem := v.Args[2]
  4631  		v.reset(OpS390XMOVHstore)
  4632  		v.AuxInt = 4
  4633  		v.AddArg(dst)
  4634  		v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
  4635  		v0.AuxInt = 4
  4636  		v0.AddArg(src)
  4637  		v0.AddArg(mem)
  4638  		v.AddArg(v0)
  4639  		v1 := b.NewValue0(v.Pos, OpS390XMOVWstore, types.TypeMem)
  4640  		v1.AddArg(dst)
  4641  		v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
  4642  		v2.AddArg(src)
  4643  		v2.AddArg(mem)
  4644  		v1.AddArg(v2)
  4645  		v1.AddArg(mem)
  4646  		v.AddArg(v1)
  4647  		return true
  4648  	}
  4649  	return false
  4650  }
  4651  func rewriteValueS390X_OpMove_10(v *Value) bool {
  4652  	b := v.Block
  4653  	_ = b
  4654  	typ := &b.Func.Config.Types
  4655  	_ = typ
  4656  	// match: (Move [7] dst src mem)
  4657  	// cond:
  4658  	// result: (MOVBstore [6] dst (MOVBZload [6] src mem) (MOVHstore [4] dst (MOVHZload [4] src mem) (MOVWstore dst (MOVWZload src mem) mem)))
  4659  	for {
  4660  		if v.AuxInt != 7 {
  4661  			break
  4662  		}
  4663  		_ = v.Args[2]
  4664  		dst := v.Args[0]
  4665  		src := v.Args[1]
  4666  		mem := v.Args[2]
  4667  		v.reset(OpS390XMOVBstore)
  4668  		v.AuxInt = 6
  4669  		v.AddArg(dst)
  4670  		v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, typ.UInt8)
  4671  		v0.AuxInt = 6
  4672  		v0.AddArg(src)
  4673  		v0.AddArg(mem)
  4674  		v.AddArg(v0)
  4675  		v1 := b.NewValue0(v.Pos, OpS390XMOVHstore, types.TypeMem)
  4676  		v1.AuxInt = 4
  4677  		v1.AddArg(dst)
  4678  		v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
  4679  		v2.AuxInt = 4
  4680  		v2.AddArg(src)
  4681  		v2.AddArg(mem)
  4682  		v1.AddArg(v2)
  4683  		v3 := b.NewValue0(v.Pos, OpS390XMOVWstore, types.TypeMem)
  4684  		v3.AddArg(dst)
  4685  		v4 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
  4686  		v4.AddArg(src)
  4687  		v4.AddArg(mem)
  4688  		v3.AddArg(v4)
  4689  		v3.AddArg(mem)
  4690  		v1.AddArg(v3)
  4691  		v.AddArg(v1)
  4692  		return true
  4693  	}
  4694  	// match: (Move [s] dst src mem)
  4695  	// cond: s > 0 && s <= 256
  4696  	// result: (MVC [makeValAndOff(s, 0)] dst src mem)
  4697  	for {
  4698  		s := v.AuxInt
  4699  		_ = v.Args[2]
  4700  		dst := v.Args[0]
  4701  		src := v.Args[1]
  4702  		mem := v.Args[2]
  4703  		if !(s > 0 && s <= 256) {
  4704  			break
  4705  		}
  4706  		v.reset(OpS390XMVC)
  4707  		v.AuxInt = makeValAndOff(s, 0)
  4708  		v.AddArg(dst)
  4709  		v.AddArg(src)
  4710  		v.AddArg(mem)
  4711  		return true
  4712  	}
  4713  	// match: (Move [s] dst src mem)
  4714  	// cond: s > 256 && s <= 512
  4715  	// result: (MVC [makeValAndOff(s-256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))
  4716  	for {
  4717  		s := v.AuxInt
  4718  		_ = v.Args[2]
  4719  		dst := v.Args[0]
  4720  		src := v.Args[1]
  4721  		mem := v.Args[2]
  4722  		if !(s > 256 && s <= 512) {
  4723  			break
  4724  		}
  4725  		v.reset(OpS390XMVC)
  4726  		v.AuxInt = makeValAndOff(s-256, 256)
  4727  		v.AddArg(dst)
  4728  		v.AddArg(src)
  4729  		v0 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
  4730  		v0.AuxInt = makeValAndOff(256, 0)
  4731  		v0.AddArg(dst)
  4732  		v0.AddArg(src)
  4733  		v0.AddArg(mem)
  4734  		v.AddArg(v0)
  4735  		return true
  4736  	}
  4737  	// match: (Move [s] dst src mem)
  4738  	// cond: s > 512 && s <= 768
  4739  	// result: (MVC [makeValAndOff(s-512, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem)))
  4740  	for {
  4741  		s := v.AuxInt
  4742  		_ = v.Args[2]
  4743  		dst := v.Args[0]
  4744  		src := v.Args[1]
  4745  		mem := v.Args[2]
  4746  		if !(s > 512 && s <= 768) {
  4747  			break
  4748  		}
  4749  		v.reset(OpS390XMVC)
  4750  		v.AuxInt = makeValAndOff(s-512, 512)
  4751  		v.AddArg(dst)
  4752  		v.AddArg(src)
  4753  		v0 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
  4754  		v0.AuxInt = makeValAndOff(256, 256)
  4755  		v0.AddArg(dst)
  4756  		v0.AddArg(src)
  4757  		v1 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
  4758  		v1.AuxInt = makeValAndOff(256, 0)
  4759  		v1.AddArg(dst)
  4760  		v1.AddArg(src)
  4761  		v1.AddArg(mem)
  4762  		v0.AddArg(v1)
  4763  		v.AddArg(v0)
  4764  		return true
  4765  	}
  4766  	// match: (Move [s] dst src mem)
  4767  	// cond: s > 768 && s <= 1024
  4768  	// result: (MVC [makeValAndOff(s-768, 768)] dst src (MVC [makeValAndOff(256, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))))
  4769  	for {
  4770  		s := v.AuxInt
  4771  		_ = v.Args[2]
  4772  		dst := v.Args[0]
  4773  		src := v.Args[1]
  4774  		mem := v.Args[2]
  4775  		if !(s > 768 && s <= 1024) {
  4776  			break
  4777  		}
  4778  		v.reset(OpS390XMVC)
  4779  		v.AuxInt = makeValAndOff(s-768, 768)
  4780  		v.AddArg(dst)
  4781  		v.AddArg(src)
  4782  		v0 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
  4783  		v0.AuxInt = makeValAndOff(256, 512)
  4784  		v0.AddArg(dst)
  4785  		v0.AddArg(src)
  4786  		v1 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
  4787  		v1.AuxInt = makeValAndOff(256, 256)
  4788  		v1.AddArg(dst)
  4789  		v1.AddArg(src)
  4790  		v2 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
  4791  		v2.AuxInt = makeValAndOff(256, 0)
  4792  		v2.AddArg(dst)
  4793  		v2.AddArg(src)
  4794  		v2.AddArg(mem)
  4795  		v1.AddArg(v2)
  4796  		v0.AddArg(v1)
  4797  		v.AddArg(v0)
  4798  		return true
  4799  	}
  4800  	// match: (Move [s] dst src mem)
  4801  	// cond: s > 1024
  4802  	// result: (LoweredMove [s%256] dst src (ADD <src.Type> src (MOVDconst [(s/256)*256])) mem)
  4803  	for {
  4804  		s := v.AuxInt
  4805  		_ = v.Args[2]
  4806  		dst := v.Args[0]
  4807  		src := v.Args[1]
  4808  		mem := v.Args[2]
  4809  		if !(s > 1024) {
  4810  			break
  4811  		}
  4812  		v.reset(OpS390XLoweredMove)
  4813  		v.AuxInt = s % 256
  4814  		v.AddArg(dst)
  4815  		v.AddArg(src)
  4816  		v0 := b.NewValue0(v.Pos, OpS390XADD, src.Type)
  4817  		v0.AddArg(src)
  4818  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4819  		v1.AuxInt = (s / 256) * 256
  4820  		v0.AddArg(v1)
  4821  		v.AddArg(v0)
  4822  		v.AddArg(mem)
  4823  		return true
  4824  	}
  4825  	return false
  4826  }
  4827  func rewriteValueS390X_OpMul16_0(v *Value) bool {
  4828  	// match: (Mul16 x y)
  4829  	// cond:
  4830  	// result: (MULLW x y)
  4831  	for {
  4832  		_ = v.Args[1]
  4833  		x := v.Args[0]
  4834  		y := v.Args[1]
  4835  		v.reset(OpS390XMULLW)
  4836  		v.AddArg(x)
  4837  		v.AddArg(y)
  4838  		return true
  4839  	}
  4840  }
  4841  func rewriteValueS390X_OpMul32_0(v *Value) bool {
  4842  	// match: (Mul32 x y)
  4843  	// cond:
  4844  	// result: (MULLW x y)
  4845  	for {
  4846  		_ = v.Args[1]
  4847  		x := v.Args[0]
  4848  		y := v.Args[1]
  4849  		v.reset(OpS390XMULLW)
  4850  		v.AddArg(x)
  4851  		v.AddArg(y)
  4852  		return true
  4853  	}
  4854  }
  4855  func rewriteValueS390X_OpMul32F_0(v *Value) bool {
  4856  	// match: (Mul32F x y)
  4857  	// cond:
  4858  	// result: (FMULS x y)
  4859  	for {
  4860  		_ = v.Args[1]
  4861  		x := v.Args[0]
  4862  		y := v.Args[1]
  4863  		v.reset(OpS390XFMULS)
  4864  		v.AddArg(x)
  4865  		v.AddArg(y)
  4866  		return true
  4867  	}
  4868  }
  4869  func rewriteValueS390X_OpMul64_0(v *Value) bool {
  4870  	// match: (Mul64 x y)
  4871  	// cond:
  4872  	// result: (MULLD x y)
  4873  	for {
  4874  		_ = v.Args[1]
  4875  		x := v.Args[0]
  4876  		y := v.Args[1]
  4877  		v.reset(OpS390XMULLD)
  4878  		v.AddArg(x)
  4879  		v.AddArg(y)
  4880  		return true
  4881  	}
  4882  }
  4883  func rewriteValueS390X_OpMul64F_0(v *Value) bool {
  4884  	// match: (Mul64F x y)
  4885  	// cond:
  4886  	// result: (FMUL x y)
  4887  	for {
  4888  		_ = v.Args[1]
  4889  		x := v.Args[0]
  4890  		y := v.Args[1]
  4891  		v.reset(OpS390XFMUL)
  4892  		v.AddArg(x)
  4893  		v.AddArg(y)
  4894  		return true
  4895  	}
  4896  }
  4897  func rewriteValueS390X_OpMul8_0(v *Value) bool {
  4898  	// match: (Mul8 x y)
  4899  	// cond:
  4900  	// result: (MULLW x y)
  4901  	for {
  4902  		_ = v.Args[1]
  4903  		x := v.Args[0]
  4904  		y := v.Args[1]
  4905  		v.reset(OpS390XMULLW)
  4906  		v.AddArg(x)
  4907  		v.AddArg(y)
  4908  		return true
  4909  	}
  4910  }
  4911  func rewriteValueS390X_OpNeg16_0(v *Value) bool {
  4912  	// match: (Neg16 x)
  4913  	// cond:
  4914  	// result: (NEGW x)
  4915  	for {
  4916  		x := v.Args[0]
  4917  		v.reset(OpS390XNEGW)
  4918  		v.AddArg(x)
  4919  		return true
  4920  	}
  4921  }
  4922  func rewriteValueS390X_OpNeg32_0(v *Value) bool {
  4923  	// match: (Neg32 x)
  4924  	// cond:
  4925  	// result: (NEGW x)
  4926  	for {
  4927  		x := v.Args[0]
  4928  		v.reset(OpS390XNEGW)
  4929  		v.AddArg(x)
  4930  		return true
  4931  	}
  4932  }
  4933  func rewriteValueS390X_OpNeg32F_0(v *Value) bool {
  4934  	// match: (Neg32F x)
  4935  	// cond:
  4936  	// result: (FNEGS x)
  4937  	for {
  4938  		x := v.Args[0]
  4939  		v.reset(OpS390XFNEGS)
  4940  		v.AddArg(x)
  4941  		return true
  4942  	}
  4943  }
  4944  func rewriteValueS390X_OpNeg64_0(v *Value) bool {
  4945  	// match: (Neg64 x)
  4946  	// cond:
  4947  	// result: (NEG x)
  4948  	for {
  4949  		x := v.Args[0]
  4950  		v.reset(OpS390XNEG)
  4951  		v.AddArg(x)
  4952  		return true
  4953  	}
  4954  }
  4955  func rewriteValueS390X_OpNeg64F_0(v *Value) bool {
  4956  	// match: (Neg64F x)
  4957  	// cond:
  4958  	// result: (FNEG x)
  4959  	for {
  4960  		x := v.Args[0]
  4961  		v.reset(OpS390XFNEG)
  4962  		v.AddArg(x)
  4963  		return true
  4964  	}
  4965  }
  4966  func rewriteValueS390X_OpNeg8_0(v *Value) bool {
  4967  	// match: (Neg8 x)
  4968  	// cond:
  4969  	// result: (NEGW x)
  4970  	for {
  4971  		x := v.Args[0]
  4972  		v.reset(OpS390XNEGW)
  4973  		v.AddArg(x)
  4974  		return true
  4975  	}
  4976  }
  4977  func rewriteValueS390X_OpNeq16_0(v *Value) bool {
  4978  	b := v.Block
  4979  	_ = b
  4980  	typ := &b.Func.Config.Types
  4981  	_ = typ
  4982  	// match: (Neq16 x y)
  4983  	// cond:
  4984  	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVHreg x) (MOVHreg y)))
  4985  	for {
  4986  		_ = v.Args[1]
  4987  		x := v.Args[0]
  4988  		y := v.Args[1]
  4989  		v.reset(OpS390XMOVDNE)
  4990  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4991  		v0.AuxInt = 0
  4992  		v.AddArg(v0)
  4993  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  4994  		v1.AuxInt = 1
  4995  		v.AddArg(v1)
  4996  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  4997  		v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  4998  		v3.AddArg(x)
  4999  		v2.AddArg(v3)
  5000  		v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5001  		v4.AddArg(y)
  5002  		v2.AddArg(v4)
  5003  		v.AddArg(v2)
  5004  		return true
  5005  	}
  5006  }
  5007  func rewriteValueS390X_OpNeq32_0(v *Value) bool {
  5008  	b := v.Block
  5009  	_ = b
  5010  	typ := &b.Func.Config.Types
  5011  	_ = typ
  5012  	// match: (Neq32 x y)
  5013  	// cond:
  5014  	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
  5015  	for {
  5016  		_ = v.Args[1]
  5017  		x := v.Args[0]
  5018  		y := v.Args[1]
  5019  		v.reset(OpS390XMOVDNE)
  5020  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5021  		v0.AuxInt = 0
  5022  		v.AddArg(v0)
  5023  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5024  		v1.AuxInt = 1
  5025  		v.AddArg(v1)
  5026  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  5027  		v2.AddArg(x)
  5028  		v2.AddArg(y)
  5029  		v.AddArg(v2)
  5030  		return true
  5031  	}
  5032  }
  5033  func rewriteValueS390X_OpNeq32F_0(v *Value) bool {
  5034  	b := v.Block
  5035  	_ = b
  5036  	typ := &b.Func.Config.Types
  5037  	_ = typ
  5038  	// match: (Neq32F x y)
  5039  	// cond:
  5040  	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
  5041  	for {
  5042  		_ = v.Args[1]
  5043  		x := v.Args[0]
  5044  		y := v.Args[1]
  5045  		v.reset(OpS390XMOVDNE)
  5046  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5047  		v0.AuxInt = 0
  5048  		v.AddArg(v0)
  5049  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5050  		v1.AuxInt = 1
  5051  		v.AddArg(v1)
  5052  		v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
  5053  		v2.AddArg(x)
  5054  		v2.AddArg(y)
  5055  		v.AddArg(v2)
  5056  		return true
  5057  	}
  5058  }
  5059  func rewriteValueS390X_OpNeq64_0(v *Value) bool {
  5060  	b := v.Block
  5061  	_ = b
  5062  	typ := &b.Func.Config.Types
  5063  	_ = typ
  5064  	// match: (Neq64 x y)
  5065  	// cond:
  5066  	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
  5067  	for {
  5068  		_ = v.Args[1]
  5069  		x := v.Args[0]
  5070  		y := v.Args[1]
  5071  		v.reset(OpS390XMOVDNE)
  5072  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5073  		v0.AuxInt = 0
  5074  		v.AddArg(v0)
  5075  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5076  		v1.AuxInt = 1
  5077  		v.AddArg(v1)
  5078  		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
  5079  		v2.AddArg(x)
  5080  		v2.AddArg(y)
  5081  		v.AddArg(v2)
  5082  		return true
  5083  	}
  5084  }
  5085  func rewriteValueS390X_OpNeq64F_0(v *Value) bool {
  5086  	b := v.Block
  5087  	_ = b
  5088  	typ := &b.Func.Config.Types
  5089  	_ = typ
  5090  	// match: (Neq64F x y)
  5091  	// cond:
  5092  	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
  5093  	for {
  5094  		_ = v.Args[1]
  5095  		x := v.Args[0]
  5096  		y := v.Args[1]
  5097  		v.reset(OpS390XMOVDNE)
  5098  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5099  		v0.AuxInt = 0
  5100  		v.AddArg(v0)
  5101  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5102  		v1.AuxInt = 1
  5103  		v.AddArg(v1)
  5104  		v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
  5105  		v2.AddArg(x)
  5106  		v2.AddArg(y)
  5107  		v.AddArg(v2)
  5108  		return true
  5109  	}
  5110  }
  5111  func rewriteValueS390X_OpNeq8_0(v *Value) bool {
  5112  	b := v.Block
  5113  	_ = b
  5114  	typ := &b.Func.Config.Types
  5115  	_ = typ
  5116  	// match: (Neq8 x y)
  5117  	// cond:
  5118  	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVBreg x) (MOVBreg y)))
  5119  	for {
  5120  		_ = v.Args[1]
  5121  		x := v.Args[0]
  5122  		y := v.Args[1]
  5123  		v.reset(OpS390XMOVDNE)
  5124  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5125  		v0.AuxInt = 0
  5126  		v.AddArg(v0)
  5127  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5128  		v1.AuxInt = 1
  5129  		v.AddArg(v1)
  5130  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  5131  		v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  5132  		v3.AddArg(x)
  5133  		v2.AddArg(v3)
  5134  		v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  5135  		v4.AddArg(y)
  5136  		v2.AddArg(v4)
  5137  		v.AddArg(v2)
  5138  		return true
  5139  	}
  5140  }
  5141  func rewriteValueS390X_OpNeqB_0(v *Value) bool {
  5142  	b := v.Block
  5143  	_ = b
  5144  	typ := &b.Func.Config.Types
  5145  	_ = typ
  5146  	// match: (NeqB x y)
  5147  	// cond:
  5148  	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMPW (MOVBreg x) (MOVBreg y)))
  5149  	for {
  5150  		_ = v.Args[1]
  5151  		x := v.Args[0]
  5152  		y := v.Args[1]
  5153  		v.reset(OpS390XMOVDNE)
  5154  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5155  		v0.AuxInt = 0
  5156  		v.AddArg(v0)
  5157  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5158  		v1.AuxInt = 1
  5159  		v.AddArg(v1)
  5160  		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
  5161  		v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  5162  		v3.AddArg(x)
  5163  		v2.AddArg(v3)
  5164  		v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  5165  		v4.AddArg(y)
  5166  		v2.AddArg(v4)
  5167  		v.AddArg(v2)
  5168  		return true
  5169  	}
  5170  }
  5171  func rewriteValueS390X_OpNeqPtr_0(v *Value) bool {
  5172  	b := v.Block
  5173  	_ = b
  5174  	typ := &b.Func.Config.Types
  5175  	_ = typ
  5176  	// match: (NeqPtr x y)
  5177  	// cond:
  5178  	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
  5179  	for {
  5180  		_ = v.Args[1]
  5181  		x := v.Args[0]
  5182  		y := v.Args[1]
  5183  		v.reset(OpS390XMOVDNE)
  5184  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5185  		v0.AuxInt = 0
  5186  		v.AddArg(v0)
  5187  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5188  		v1.AuxInt = 1
  5189  		v.AddArg(v1)
  5190  		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
  5191  		v2.AddArg(x)
  5192  		v2.AddArg(y)
  5193  		v.AddArg(v2)
  5194  		return true
  5195  	}
  5196  }
  5197  func rewriteValueS390X_OpNilCheck_0(v *Value) bool {
  5198  	// match: (NilCheck ptr mem)
  5199  	// cond:
  5200  	// result: (LoweredNilCheck ptr mem)
  5201  	for {
  5202  		_ = v.Args[1]
  5203  		ptr := v.Args[0]
  5204  		mem := v.Args[1]
  5205  		v.reset(OpS390XLoweredNilCheck)
  5206  		v.AddArg(ptr)
  5207  		v.AddArg(mem)
  5208  		return true
  5209  	}
  5210  }
  5211  func rewriteValueS390X_OpNot_0(v *Value) bool {
  5212  	// match: (Not x)
  5213  	// cond:
  5214  	// result: (XORWconst [1] x)
  5215  	for {
  5216  		x := v.Args[0]
  5217  		v.reset(OpS390XXORWconst)
  5218  		v.AuxInt = 1
  5219  		v.AddArg(x)
  5220  		return true
  5221  	}
  5222  }
  5223  func rewriteValueS390X_OpOffPtr_0(v *Value) bool {
  5224  	b := v.Block
  5225  	_ = b
  5226  	typ := &b.Func.Config.Types
  5227  	_ = typ
  5228  	// match: (OffPtr [off] ptr:(SP))
  5229  	// cond:
  5230  	// result: (MOVDaddr [off] ptr)
  5231  	for {
  5232  		off := v.AuxInt
  5233  		ptr := v.Args[0]
  5234  		if ptr.Op != OpSP {
  5235  			break
  5236  		}
  5237  		v.reset(OpS390XMOVDaddr)
  5238  		v.AuxInt = off
  5239  		v.AddArg(ptr)
  5240  		return true
  5241  	}
  5242  	// match: (OffPtr [off] ptr)
  5243  	// cond: is32Bit(off)
  5244  	// result: (ADDconst [off] ptr)
  5245  	for {
  5246  		off := v.AuxInt
  5247  		ptr := v.Args[0]
  5248  		if !(is32Bit(off)) {
  5249  			break
  5250  		}
  5251  		v.reset(OpS390XADDconst)
  5252  		v.AuxInt = off
  5253  		v.AddArg(ptr)
  5254  		return true
  5255  	}
  5256  	// match: (OffPtr [off] ptr)
  5257  	// cond:
  5258  	// result: (ADD (MOVDconst [off]) ptr)
  5259  	for {
  5260  		off := v.AuxInt
  5261  		ptr := v.Args[0]
  5262  		v.reset(OpS390XADD)
  5263  		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5264  		v0.AuxInt = off
  5265  		v.AddArg(v0)
  5266  		v.AddArg(ptr)
  5267  		return true
  5268  	}
  5269  }
  5270  func rewriteValueS390X_OpOr16_0(v *Value) bool {
  5271  	// match: (Or16 x y)
  5272  	// cond:
  5273  	// result: (ORW x y)
  5274  	for {
  5275  		_ = v.Args[1]
  5276  		x := v.Args[0]
  5277  		y := v.Args[1]
  5278  		v.reset(OpS390XORW)
  5279  		v.AddArg(x)
  5280  		v.AddArg(y)
  5281  		return true
  5282  	}
  5283  }
  5284  func rewriteValueS390X_OpOr32_0(v *Value) bool {
  5285  	// match: (Or32 x y)
  5286  	// cond:
  5287  	// result: (ORW x y)
  5288  	for {
  5289  		_ = v.Args[1]
  5290  		x := v.Args[0]
  5291  		y := v.Args[1]
  5292  		v.reset(OpS390XORW)
  5293  		v.AddArg(x)
  5294  		v.AddArg(y)
  5295  		return true
  5296  	}
  5297  }
  5298  func rewriteValueS390X_OpOr64_0(v *Value) bool {
  5299  	// match: (Or64 x y)
  5300  	// cond:
  5301  	// result: (OR x y)
  5302  	for {
  5303  		_ = v.Args[1]
  5304  		x := v.Args[0]
  5305  		y := v.Args[1]
  5306  		v.reset(OpS390XOR)
  5307  		v.AddArg(x)
  5308  		v.AddArg(y)
  5309  		return true
  5310  	}
  5311  }
  5312  func rewriteValueS390X_OpOr8_0(v *Value) bool {
  5313  	// match: (Or8 x y)
  5314  	// cond:
  5315  	// result: (ORW x y)
  5316  	for {
  5317  		_ = v.Args[1]
  5318  		x := v.Args[0]
  5319  		y := v.Args[1]
  5320  		v.reset(OpS390XORW)
  5321  		v.AddArg(x)
  5322  		v.AddArg(y)
  5323  		return true
  5324  	}
  5325  }
  5326  func rewriteValueS390X_OpOrB_0(v *Value) bool {
  5327  	// match: (OrB x y)
  5328  	// cond:
  5329  	// result: (ORW x y)
  5330  	for {
  5331  		_ = v.Args[1]
  5332  		x := v.Args[0]
  5333  		y := v.Args[1]
  5334  		v.reset(OpS390XORW)
  5335  		v.AddArg(x)
  5336  		v.AddArg(y)
  5337  		return true
  5338  	}
  5339  }
  5340  func rewriteValueS390X_OpPopCount16_0(v *Value) bool {
  5341  	b := v.Block
  5342  	_ = b
  5343  	typ := &b.Func.Config.Types
  5344  	_ = typ
  5345  	// match: (PopCount16 x)
  5346  	// cond:
  5347  	// result: (MOVBZreg (SumBytes2 (POPCNT <typ.UInt16> x)))
  5348  	for {
  5349  		x := v.Args[0]
  5350  		v.reset(OpS390XMOVBZreg)
  5351  		v0 := b.NewValue0(v.Pos, OpS390XSumBytes2, typ.UInt8)
  5352  		v1 := b.NewValue0(v.Pos, OpS390XPOPCNT, typ.UInt16)
  5353  		v1.AddArg(x)
  5354  		v0.AddArg(v1)
  5355  		v.AddArg(v0)
  5356  		return true
  5357  	}
  5358  }
  5359  func rewriteValueS390X_OpPopCount32_0(v *Value) bool {
  5360  	b := v.Block
  5361  	_ = b
  5362  	typ := &b.Func.Config.Types
  5363  	_ = typ
  5364  	// match: (PopCount32 x)
  5365  	// cond:
  5366  	// result: (MOVBZreg (SumBytes4 (POPCNT <typ.UInt32> x)))
  5367  	for {
  5368  		x := v.Args[0]
  5369  		v.reset(OpS390XMOVBZreg)
  5370  		v0 := b.NewValue0(v.Pos, OpS390XSumBytes4, typ.UInt8)
  5371  		v1 := b.NewValue0(v.Pos, OpS390XPOPCNT, typ.UInt32)
  5372  		v1.AddArg(x)
  5373  		v0.AddArg(v1)
  5374  		v.AddArg(v0)
  5375  		return true
  5376  	}
  5377  }
  5378  func rewriteValueS390X_OpPopCount64_0(v *Value) bool {
  5379  	b := v.Block
  5380  	_ = b
  5381  	typ := &b.Func.Config.Types
  5382  	_ = typ
  5383  	// match: (PopCount64 x)
  5384  	// cond:
  5385  	// result: (MOVBZreg (SumBytes8 (POPCNT <typ.UInt64> x)))
  5386  	for {
  5387  		x := v.Args[0]
  5388  		v.reset(OpS390XMOVBZreg)
  5389  		v0 := b.NewValue0(v.Pos, OpS390XSumBytes8, typ.UInt8)
  5390  		v1 := b.NewValue0(v.Pos, OpS390XPOPCNT, typ.UInt64)
  5391  		v1.AddArg(x)
  5392  		v0.AddArg(v1)
  5393  		v.AddArg(v0)
  5394  		return true
  5395  	}
  5396  }
  5397  func rewriteValueS390X_OpPopCount8_0(v *Value) bool {
  5398  	b := v.Block
  5399  	_ = b
  5400  	typ := &b.Func.Config.Types
  5401  	_ = typ
  5402  	// match: (PopCount8 x)
  5403  	// cond:
  5404  	// result: (POPCNT (MOVBZreg x))
  5405  	for {
  5406  		x := v.Args[0]
  5407  		v.reset(OpS390XPOPCNT)
  5408  		v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  5409  		v0.AddArg(x)
  5410  		v.AddArg(v0)
  5411  		return true
  5412  	}
  5413  }
  5414  func rewriteValueS390X_OpRotateLeft32_0(v *Value) bool {
  5415  	// match: (RotateLeft32 x y)
  5416  	// cond:
  5417  	// result: (RLL x y)
  5418  	for {
  5419  		_ = v.Args[1]
  5420  		x := v.Args[0]
  5421  		y := v.Args[1]
  5422  		v.reset(OpS390XRLL)
  5423  		v.AddArg(x)
  5424  		v.AddArg(y)
  5425  		return true
  5426  	}
  5427  }
  5428  func rewriteValueS390X_OpRotateLeft64_0(v *Value) bool {
  5429  	// match: (RotateLeft64 x y)
  5430  	// cond:
  5431  	// result: (RLLG x y)
  5432  	for {
  5433  		_ = v.Args[1]
  5434  		x := v.Args[0]
  5435  		y := v.Args[1]
  5436  		v.reset(OpS390XRLLG)
  5437  		v.AddArg(x)
  5438  		v.AddArg(y)
  5439  		return true
  5440  	}
  5441  }
  5442  func rewriteValueS390X_OpRound_0(v *Value) bool {
  5443  	// match: (Round x)
  5444  	// cond:
  5445  	// result: (FIDBR [1] x)
  5446  	for {
  5447  		x := v.Args[0]
  5448  		v.reset(OpS390XFIDBR)
  5449  		v.AuxInt = 1
  5450  		v.AddArg(x)
  5451  		return true
  5452  	}
  5453  }
  5454  func rewriteValueS390X_OpRound32F_0(v *Value) bool {
  5455  	// match: (Round32F x)
  5456  	// cond:
  5457  	// result: (LoweredRound32F x)
  5458  	for {
  5459  		x := v.Args[0]
  5460  		v.reset(OpS390XLoweredRound32F)
  5461  		v.AddArg(x)
  5462  		return true
  5463  	}
  5464  }
  5465  func rewriteValueS390X_OpRound64F_0(v *Value) bool {
  5466  	// match: (Round64F x)
  5467  	// cond:
  5468  	// result: (LoweredRound64F x)
  5469  	for {
  5470  		x := v.Args[0]
  5471  		v.reset(OpS390XLoweredRound64F)
  5472  		v.AddArg(x)
  5473  		return true
  5474  	}
  5475  }
  5476  func rewriteValueS390X_OpRoundToEven_0(v *Value) bool {
  5477  	// match: (RoundToEven x)
  5478  	// cond:
  5479  	// result: (FIDBR [4] x)
  5480  	for {
  5481  		x := v.Args[0]
  5482  		v.reset(OpS390XFIDBR)
  5483  		v.AuxInt = 4
  5484  		v.AddArg(x)
  5485  		return true
  5486  	}
  5487  }
  5488  func rewriteValueS390X_OpRsh16Ux16_0(v *Value) bool {
  5489  	b := v.Block
  5490  	_ = b
  5491  	typ := &b.Func.Config.Types
  5492  	_ = typ
  5493  	// match: (Rsh16Ux16 x y)
  5494  	// cond: shiftIsBounded(v)
  5495  	// result: (SRW (MOVHZreg x) y)
  5496  	for {
  5497  		_ = v.Args[1]
  5498  		x := v.Args[0]
  5499  		y := v.Args[1]
  5500  		if !(shiftIsBounded(v)) {
  5501  			break
  5502  		}
  5503  		v.reset(OpS390XSRW)
  5504  		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5505  		v0.AddArg(x)
  5506  		v.AddArg(v0)
  5507  		v.AddArg(y)
  5508  		return true
  5509  	}
  5510  	// match: (Rsh16Ux16 <t> x y)
  5511  	// cond:
  5512  	// result: (MOVDGE <t> (SRW <t> (MOVHZreg x) y) (MOVDconst [0]) (CMPWUconst (MOVHZreg y) [64]))
  5513  	for {
  5514  		t := v.Type
  5515  		_ = v.Args[1]
  5516  		x := v.Args[0]
  5517  		y := v.Args[1]
  5518  		v.reset(OpS390XMOVDGE)
  5519  		v.Type = t
  5520  		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  5521  		v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5522  		v1.AddArg(x)
  5523  		v0.AddArg(v1)
  5524  		v0.AddArg(y)
  5525  		v.AddArg(v0)
  5526  		v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5527  		v2.AuxInt = 0
  5528  		v.AddArg(v2)
  5529  		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5530  		v3.AuxInt = 64
  5531  		v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5532  		v4.AddArg(y)
  5533  		v3.AddArg(v4)
  5534  		v.AddArg(v3)
  5535  		return true
  5536  	}
  5537  }
  5538  func rewriteValueS390X_OpRsh16Ux32_0(v *Value) bool {
  5539  	b := v.Block
  5540  	_ = b
  5541  	typ := &b.Func.Config.Types
  5542  	_ = typ
  5543  	// match: (Rsh16Ux32 x y)
  5544  	// cond: shiftIsBounded(v)
  5545  	// result: (SRW (MOVHZreg x) y)
  5546  	for {
  5547  		_ = v.Args[1]
  5548  		x := v.Args[0]
  5549  		y := v.Args[1]
  5550  		if !(shiftIsBounded(v)) {
  5551  			break
  5552  		}
  5553  		v.reset(OpS390XSRW)
  5554  		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5555  		v0.AddArg(x)
  5556  		v.AddArg(v0)
  5557  		v.AddArg(y)
  5558  		return true
  5559  	}
  5560  	// match: (Rsh16Ux32 <t> x y)
  5561  	// cond:
  5562  	// result: (MOVDGE <t> (SRW <t> (MOVHZreg x) y) (MOVDconst [0]) (CMPWUconst y [64]))
  5563  	for {
  5564  		t := v.Type
  5565  		_ = v.Args[1]
  5566  		x := v.Args[0]
  5567  		y := v.Args[1]
  5568  		v.reset(OpS390XMOVDGE)
  5569  		v.Type = t
  5570  		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  5571  		v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5572  		v1.AddArg(x)
  5573  		v0.AddArg(v1)
  5574  		v0.AddArg(y)
  5575  		v.AddArg(v0)
  5576  		v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5577  		v2.AuxInt = 0
  5578  		v.AddArg(v2)
  5579  		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5580  		v3.AuxInt = 64
  5581  		v3.AddArg(y)
  5582  		v.AddArg(v3)
  5583  		return true
  5584  	}
  5585  }
  5586  func rewriteValueS390X_OpRsh16Ux64_0(v *Value) bool {
  5587  	b := v.Block
  5588  	_ = b
  5589  	typ := &b.Func.Config.Types
  5590  	_ = typ
  5591  	// match: (Rsh16Ux64 x y)
  5592  	// cond: shiftIsBounded(v)
  5593  	// result: (SRW (MOVHZreg x) y)
  5594  	for {
  5595  		_ = v.Args[1]
  5596  		x := v.Args[0]
  5597  		y := v.Args[1]
  5598  		if !(shiftIsBounded(v)) {
  5599  			break
  5600  		}
  5601  		v.reset(OpS390XSRW)
  5602  		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5603  		v0.AddArg(x)
  5604  		v.AddArg(v0)
  5605  		v.AddArg(y)
  5606  		return true
  5607  	}
  5608  	// match: (Rsh16Ux64 <t> x y)
  5609  	// cond:
  5610  	// result: (MOVDGE <t> (SRW <t> (MOVHZreg x) y) (MOVDconst [0]) (CMPUconst y [64]))
  5611  	for {
  5612  		t := v.Type
  5613  		_ = v.Args[1]
  5614  		x := v.Args[0]
  5615  		y := v.Args[1]
  5616  		v.reset(OpS390XMOVDGE)
  5617  		v.Type = t
  5618  		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  5619  		v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5620  		v1.AddArg(x)
  5621  		v0.AddArg(v1)
  5622  		v0.AddArg(y)
  5623  		v.AddArg(v0)
  5624  		v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5625  		v2.AuxInt = 0
  5626  		v.AddArg(v2)
  5627  		v3 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  5628  		v3.AuxInt = 64
  5629  		v3.AddArg(y)
  5630  		v.AddArg(v3)
  5631  		return true
  5632  	}
  5633  }
  5634  func rewriteValueS390X_OpRsh16Ux8_0(v *Value) bool {
  5635  	b := v.Block
  5636  	_ = b
  5637  	typ := &b.Func.Config.Types
  5638  	_ = typ
  5639  	// match: (Rsh16Ux8 x y)
  5640  	// cond: shiftIsBounded(v)
  5641  	// result: (SRW (MOVHZreg x) y)
  5642  	for {
  5643  		_ = v.Args[1]
  5644  		x := v.Args[0]
  5645  		y := v.Args[1]
  5646  		if !(shiftIsBounded(v)) {
  5647  			break
  5648  		}
  5649  		v.reset(OpS390XSRW)
  5650  		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5651  		v0.AddArg(x)
  5652  		v.AddArg(v0)
  5653  		v.AddArg(y)
  5654  		return true
  5655  	}
  5656  	// match: (Rsh16Ux8 <t> x y)
  5657  	// cond:
  5658  	// result: (MOVDGE <t> (SRW <t> (MOVHZreg x) y) (MOVDconst [0]) (CMPWUconst (MOVBZreg y) [64]))
  5659  	for {
  5660  		t := v.Type
  5661  		_ = v.Args[1]
  5662  		x := v.Args[0]
  5663  		y := v.Args[1]
  5664  		v.reset(OpS390XMOVDGE)
  5665  		v.Type = t
  5666  		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  5667  		v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5668  		v1.AddArg(x)
  5669  		v0.AddArg(v1)
  5670  		v0.AddArg(y)
  5671  		v.AddArg(v0)
  5672  		v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5673  		v2.AuxInt = 0
  5674  		v.AddArg(v2)
  5675  		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5676  		v3.AuxInt = 64
  5677  		v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  5678  		v4.AddArg(y)
  5679  		v3.AddArg(v4)
  5680  		v.AddArg(v3)
  5681  		return true
  5682  	}
  5683  }
  5684  func rewriteValueS390X_OpRsh16x16_0(v *Value) bool {
  5685  	b := v.Block
  5686  	_ = b
  5687  	typ := &b.Func.Config.Types
  5688  	_ = typ
  5689  	// match: (Rsh16x16 x y)
  5690  	// cond: shiftIsBounded(v)
  5691  	// result: (SRAW (MOVHreg x) y)
  5692  	for {
  5693  		_ = v.Args[1]
  5694  		x := v.Args[0]
  5695  		y := v.Args[1]
  5696  		if !(shiftIsBounded(v)) {
  5697  			break
  5698  		}
  5699  		v.reset(OpS390XSRAW)
  5700  		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5701  		v0.AddArg(x)
  5702  		v.AddArg(v0)
  5703  		v.AddArg(y)
  5704  		return true
  5705  	}
  5706  	// match: (Rsh16x16 x y)
  5707  	// cond:
  5708  	// result: (SRAW (MOVHreg x) (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst (MOVHZreg y) [64])))
  5709  	for {
  5710  		_ = v.Args[1]
  5711  		x := v.Args[0]
  5712  		y := v.Args[1]
  5713  		v.reset(OpS390XSRAW)
  5714  		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5715  		v0.AddArg(x)
  5716  		v.AddArg(v0)
  5717  		v1 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  5718  		v1.AddArg(y)
  5719  		v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  5720  		v2.AuxInt = 63
  5721  		v1.AddArg(v2)
  5722  		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5723  		v3.AuxInt = 64
  5724  		v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5725  		v4.AddArg(y)
  5726  		v3.AddArg(v4)
  5727  		v1.AddArg(v3)
  5728  		v.AddArg(v1)
  5729  		return true
  5730  	}
  5731  }
  5732  func rewriteValueS390X_OpRsh16x32_0(v *Value) bool {
  5733  	b := v.Block
  5734  	_ = b
  5735  	typ := &b.Func.Config.Types
  5736  	_ = typ
  5737  	// match: (Rsh16x32 x y)
  5738  	// cond: shiftIsBounded(v)
  5739  	// result: (SRAW (MOVHreg x) y)
  5740  	for {
  5741  		_ = v.Args[1]
  5742  		x := v.Args[0]
  5743  		y := v.Args[1]
  5744  		if !(shiftIsBounded(v)) {
  5745  			break
  5746  		}
  5747  		v.reset(OpS390XSRAW)
  5748  		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5749  		v0.AddArg(x)
  5750  		v.AddArg(v0)
  5751  		v.AddArg(y)
  5752  		return true
  5753  	}
  5754  	// match: (Rsh16x32 x y)
  5755  	// cond:
  5756  	// result: (SRAW (MOVHreg x) (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst y [64])))
  5757  	for {
  5758  		_ = v.Args[1]
  5759  		x := v.Args[0]
  5760  		y := v.Args[1]
  5761  		v.reset(OpS390XSRAW)
  5762  		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5763  		v0.AddArg(x)
  5764  		v.AddArg(v0)
  5765  		v1 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  5766  		v1.AddArg(y)
  5767  		v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  5768  		v2.AuxInt = 63
  5769  		v1.AddArg(v2)
  5770  		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5771  		v3.AuxInt = 64
  5772  		v3.AddArg(y)
  5773  		v1.AddArg(v3)
  5774  		v.AddArg(v1)
  5775  		return true
  5776  	}
  5777  }
  5778  func rewriteValueS390X_OpRsh16x64_0(v *Value) bool {
  5779  	b := v.Block
  5780  	_ = b
  5781  	typ := &b.Func.Config.Types
  5782  	_ = typ
  5783  	// match: (Rsh16x64 x y)
  5784  	// cond: shiftIsBounded(v)
  5785  	// result: (SRAW (MOVHreg x) y)
  5786  	for {
  5787  		_ = v.Args[1]
  5788  		x := v.Args[0]
  5789  		y := v.Args[1]
  5790  		if !(shiftIsBounded(v)) {
  5791  			break
  5792  		}
  5793  		v.reset(OpS390XSRAW)
  5794  		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5795  		v0.AddArg(x)
  5796  		v.AddArg(v0)
  5797  		v.AddArg(y)
  5798  		return true
  5799  	}
  5800  	// match: (Rsh16x64 x y)
  5801  	// cond:
  5802  	// result: (SRAW (MOVHreg x) (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPUconst y [64])))
  5803  	for {
  5804  		_ = v.Args[1]
  5805  		x := v.Args[0]
  5806  		y := v.Args[1]
  5807  		v.reset(OpS390XSRAW)
  5808  		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5809  		v0.AddArg(x)
  5810  		v.AddArg(v0)
  5811  		v1 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  5812  		v1.AddArg(y)
  5813  		v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  5814  		v2.AuxInt = 63
  5815  		v1.AddArg(v2)
  5816  		v3 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  5817  		v3.AuxInt = 64
  5818  		v3.AddArg(y)
  5819  		v1.AddArg(v3)
  5820  		v.AddArg(v1)
  5821  		return true
  5822  	}
  5823  }
  5824  func rewriteValueS390X_OpRsh16x8_0(v *Value) bool {
  5825  	b := v.Block
  5826  	_ = b
  5827  	typ := &b.Func.Config.Types
  5828  	_ = typ
  5829  	// match: (Rsh16x8 x y)
  5830  	// cond: shiftIsBounded(v)
  5831  	// result: (SRAW (MOVHreg x) y)
  5832  	for {
  5833  		_ = v.Args[1]
  5834  		x := v.Args[0]
  5835  		y := v.Args[1]
  5836  		if !(shiftIsBounded(v)) {
  5837  			break
  5838  		}
  5839  		v.reset(OpS390XSRAW)
  5840  		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5841  		v0.AddArg(x)
  5842  		v.AddArg(v0)
  5843  		v.AddArg(y)
  5844  		return true
  5845  	}
  5846  	// match: (Rsh16x8 x y)
  5847  	// cond:
  5848  	// result: (SRAW (MOVHreg x) (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst (MOVBZreg y) [64])))
  5849  	for {
  5850  		_ = v.Args[1]
  5851  		x := v.Args[0]
  5852  		y := v.Args[1]
  5853  		v.reset(OpS390XSRAW)
  5854  		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
  5855  		v0.AddArg(x)
  5856  		v.AddArg(v0)
  5857  		v1 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  5858  		v1.AddArg(y)
  5859  		v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  5860  		v2.AuxInt = 63
  5861  		v1.AddArg(v2)
  5862  		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5863  		v3.AuxInt = 64
  5864  		v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  5865  		v4.AddArg(y)
  5866  		v3.AddArg(v4)
  5867  		v1.AddArg(v3)
  5868  		v.AddArg(v1)
  5869  		return true
  5870  	}
  5871  }
  5872  func rewriteValueS390X_OpRsh32Ux16_0(v *Value) bool {
  5873  	b := v.Block
  5874  	_ = b
  5875  	typ := &b.Func.Config.Types
  5876  	_ = typ
  5877  	// match: (Rsh32Ux16 x y)
  5878  	// cond: shiftIsBounded(v)
  5879  	// result: (SRW x y)
  5880  	for {
  5881  		_ = v.Args[1]
  5882  		x := v.Args[0]
  5883  		y := v.Args[1]
  5884  		if !(shiftIsBounded(v)) {
  5885  			break
  5886  		}
  5887  		v.reset(OpS390XSRW)
  5888  		v.AddArg(x)
  5889  		v.AddArg(y)
  5890  		return true
  5891  	}
  5892  	// match: (Rsh32Ux16 <t> x y)
  5893  	// cond:
  5894  	// result: (MOVDGE <t> (SRW <t> x y) (MOVDconst [0]) (CMPWUconst (MOVHZreg y) [64]))
  5895  	for {
  5896  		t := v.Type
  5897  		_ = v.Args[1]
  5898  		x := v.Args[0]
  5899  		y := v.Args[1]
  5900  		v.reset(OpS390XMOVDGE)
  5901  		v.Type = t
  5902  		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  5903  		v0.AddArg(x)
  5904  		v0.AddArg(y)
  5905  		v.AddArg(v0)
  5906  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5907  		v1.AuxInt = 0
  5908  		v.AddArg(v1)
  5909  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5910  		v2.AuxInt = 64
  5911  		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  5912  		v3.AddArg(y)
  5913  		v2.AddArg(v3)
  5914  		v.AddArg(v2)
  5915  		return true
  5916  	}
  5917  }
  5918  func rewriteValueS390X_OpRsh32Ux32_0(v *Value) bool {
  5919  	b := v.Block
  5920  	_ = b
  5921  	typ := &b.Func.Config.Types
  5922  	_ = typ
  5923  	// match: (Rsh32Ux32 x y)
  5924  	// cond: shiftIsBounded(v)
  5925  	// result: (SRW x y)
  5926  	for {
  5927  		_ = v.Args[1]
  5928  		x := v.Args[0]
  5929  		y := v.Args[1]
  5930  		if !(shiftIsBounded(v)) {
  5931  			break
  5932  		}
  5933  		v.reset(OpS390XSRW)
  5934  		v.AddArg(x)
  5935  		v.AddArg(y)
  5936  		return true
  5937  	}
  5938  	// match: (Rsh32Ux32 <t> x y)
  5939  	// cond:
  5940  	// result: (MOVDGE <t> (SRW <t> x y) (MOVDconst [0]) (CMPWUconst y [64]))
  5941  	for {
  5942  		t := v.Type
  5943  		_ = v.Args[1]
  5944  		x := v.Args[0]
  5945  		y := v.Args[1]
  5946  		v.reset(OpS390XMOVDGE)
  5947  		v.Type = t
  5948  		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  5949  		v0.AddArg(x)
  5950  		v0.AddArg(y)
  5951  		v.AddArg(v0)
  5952  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5953  		v1.AuxInt = 0
  5954  		v.AddArg(v1)
  5955  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  5956  		v2.AuxInt = 64
  5957  		v2.AddArg(y)
  5958  		v.AddArg(v2)
  5959  		return true
  5960  	}
  5961  }
  5962  func rewriteValueS390X_OpRsh32Ux64_0(v *Value) bool {
  5963  	b := v.Block
  5964  	_ = b
  5965  	typ := &b.Func.Config.Types
  5966  	_ = typ
  5967  	// match: (Rsh32Ux64 x y)
  5968  	// cond: shiftIsBounded(v)
  5969  	// result: (SRW x y)
  5970  	for {
  5971  		_ = v.Args[1]
  5972  		x := v.Args[0]
  5973  		y := v.Args[1]
  5974  		if !(shiftIsBounded(v)) {
  5975  			break
  5976  		}
  5977  		v.reset(OpS390XSRW)
  5978  		v.AddArg(x)
  5979  		v.AddArg(y)
  5980  		return true
  5981  	}
  5982  	// match: (Rsh32Ux64 <t> x y)
  5983  	// cond:
  5984  	// result: (MOVDGE <t> (SRW <t> x y) (MOVDconst [0]) (CMPUconst y [64]))
  5985  	for {
  5986  		t := v.Type
  5987  		_ = v.Args[1]
  5988  		x := v.Args[0]
  5989  		y := v.Args[1]
  5990  		v.reset(OpS390XMOVDGE)
  5991  		v.Type = t
  5992  		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  5993  		v0.AddArg(x)
  5994  		v0.AddArg(y)
  5995  		v.AddArg(v0)
  5996  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  5997  		v1.AuxInt = 0
  5998  		v.AddArg(v1)
  5999  		v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  6000  		v2.AuxInt = 64
  6001  		v2.AddArg(y)
  6002  		v.AddArg(v2)
  6003  		return true
  6004  	}
  6005  }
  6006  func rewriteValueS390X_OpRsh32Ux8_0(v *Value) bool {
  6007  	b := v.Block
  6008  	_ = b
  6009  	typ := &b.Func.Config.Types
  6010  	_ = typ
  6011  	// match: (Rsh32Ux8 x y)
  6012  	// cond: shiftIsBounded(v)
  6013  	// result: (SRW x y)
  6014  	for {
  6015  		_ = v.Args[1]
  6016  		x := v.Args[0]
  6017  		y := v.Args[1]
  6018  		if !(shiftIsBounded(v)) {
  6019  			break
  6020  		}
  6021  		v.reset(OpS390XSRW)
  6022  		v.AddArg(x)
  6023  		v.AddArg(y)
  6024  		return true
  6025  	}
  6026  	// match: (Rsh32Ux8 <t> x y)
  6027  	// cond:
  6028  	// result: (MOVDGE <t> (SRW <t> x y) (MOVDconst [0]) (CMPWUconst (MOVBZreg y) [64]))
  6029  	for {
  6030  		t := v.Type
  6031  		_ = v.Args[1]
  6032  		x := v.Args[0]
  6033  		y := v.Args[1]
  6034  		v.reset(OpS390XMOVDGE)
  6035  		v.Type = t
  6036  		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  6037  		v0.AddArg(x)
  6038  		v0.AddArg(y)
  6039  		v.AddArg(v0)
  6040  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  6041  		v1.AuxInt = 0
  6042  		v.AddArg(v1)
  6043  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6044  		v2.AuxInt = 64
  6045  		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6046  		v3.AddArg(y)
  6047  		v2.AddArg(v3)
  6048  		v.AddArg(v2)
  6049  		return true
  6050  	}
  6051  }
  6052  func rewriteValueS390X_OpRsh32x16_0(v *Value) bool {
  6053  	b := v.Block
  6054  	_ = b
  6055  	typ := &b.Func.Config.Types
  6056  	_ = typ
  6057  	// match: (Rsh32x16 x y)
  6058  	// cond: shiftIsBounded(v)
  6059  	// result: (SRAW x y)
  6060  	for {
  6061  		_ = v.Args[1]
  6062  		x := v.Args[0]
  6063  		y := v.Args[1]
  6064  		if !(shiftIsBounded(v)) {
  6065  			break
  6066  		}
  6067  		v.reset(OpS390XSRAW)
  6068  		v.AddArg(x)
  6069  		v.AddArg(y)
  6070  		return true
  6071  	}
  6072  	// match: (Rsh32x16 x y)
  6073  	// cond:
  6074  	// result: (SRAW x (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst (MOVHZreg y) [64])))
  6075  	for {
  6076  		_ = v.Args[1]
  6077  		x := v.Args[0]
  6078  		y := v.Args[1]
  6079  		v.reset(OpS390XSRAW)
  6080  		v.AddArg(x)
  6081  		v0 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6082  		v0.AddArg(y)
  6083  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6084  		v1.AuxInt = 63
  6085  		v0.AddArg(v1)
  6086  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6087  		v2.AuxInt = 64
  6088  		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  6089  		v3.AddArg(y)
  6090  		v2.AddArg(v3)
  6091  		v0.AddArg(v2)
  6092  		v.AddArg(v0)
  6093  		return true
  6094  	}
  6095  }
  6096  func rewriteValueS390X_OpRsh32x32_0(v *Value) bool {
  6097  	b := v.Block
  6098  	_ = b
  6099  	// match: (Rsh32x32 x y)
  6100  	// cond: shiftIsBounded(v)
  6101  	// result: (SRAW x y)
  6102  	for {
  6103  		_ = v.Args[1]
  6104  		x := v.Args[0]
  6105  		y := v.Args[1]
  6106  		if !(shiftIsBounded(v)) {
  6107  			break
  6108  		}
  6109  		v.reset(OpS390XSRAW)
  6110  		v.AddArg(x)
  6111  		v.AddArg(y)
  6112  		return true
  6113  	}
  6114  	// match: (Rsh32x32 x y)
  6115  	// cond:
  6116  	// result: (SRAW x (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst y [64])))
  6117  	for {
  6118  		_ = v.Args[1]
  6119  		x := v.Args[0]
  6120  		y := v.Args[1]
  6121  		v.reset(OpS390XSRAW)
  6122  		v.AddArg(x)
  6123  		v0 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6124  		v0.AddArg(y)
  6125  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6126  		v1.AuxInt = 63
  6127  		v0.AddArg(v1)
  6128  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6129  		v2.AuxInt = 64
  6130  		v2.AddArg(y)
  6131  		v0.AddArg(v2)
  6132  		v.AddArg(v0)
  6133  		return true
  6134  	}
  6135  }
  6136  func rewriteValueS390X_OpRsh32x64_0(v *Value) bool {
  6137  	b := v.Block
  6138  	_ = b
  6139  	// match: (Rsh32x64 x y)
  6140  	// cond: shiftIsBounded(v)
  6141  	// result: (SRAW x y)
  6142  	for {
  6143  		_ = v.Args[1]
  6144  		x := v.Args[0]
  6145  		y := v.Args[1]
  6146  		if !(shiftIsBounded(v)) {
  6147  			break
  6148  		}
  6149  		v.reset(OpS390XSRAW)
  6150  		v.AddArg(x)
  6151  		v.AddArg(y)
  6152  		return true
  6153  	}
  6154  	// match: (Rsh32x64 x y)
  6155  	// cond:
  6156  	// result: (SRAW x (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPUconst y [64])))
  6157  	for {
  6158  		_ = v.Args[1]
  6159  		x := v.Args[0]
  6160  		y := v.Args[1]
  6161  		v.reset(OpS390XSRAW)
  6162  		v.AddArg(x)
  6163  		v0 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6164  		v0.AddArg(y)
  6165  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6166  		v1.AuxInt = 63
  6167  		v0.AddArg(v1)
  6168  		v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  6169  		v2.AuxInt = 64
  6170  		v2.AddArg(y)
  6171  		v0.AddArg(v2)
  6172  		v.AddArg(v0)
  6173  		return true
  6174  	}
  6175  }
  6176  func rewriteValueS390X_OpRsh32x8_0(v *Value) bool {
  6177  	b := v.Block
  6178  	_ = b
  6179  	typ := &b.Func.Config.Types
  6180  	_ = typ
  6181  	// match: (Rsh32x8 x y)
  6182  	// cond: shiftIsBounded(v)
  6183  	// result: (SRAW x y)
  6184  	for {
  6185  		_ = v.Args[1]
  6186  		x := v.Args[0]
  6187  		y := v.Args[1]
  6188  		if !(shiftIsBounded(v)) {
  6189  			break
  6190  		}
  6191  		v.reset(OpS390XSRAW)
  6192  		v.AddArg(x)
  6193  		v.AddArg(y)
  6194  		return true
  6195  	}
  6196  	// match: (Rsh32x8 x y)
  6197  	// cond:
  6198  	// result: (SRAW x (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst (MOVBZreg y) [64])))
  6199  	for {
  6200  		_ = v.Args[1]
  6201  		x := v.Args[0]
  6202  		y := v.Args[1]
  6203  		v.reset(OpS390XSRAW)
  6204  		v.AddArg(x)
  6205  		v0 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6206  		v0.AddArg(y)
  6207  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6208  		v1.AuxInt = 63
  6209  		v0.AddArg(v1)
  6210  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6211  		v2.AuxInt = 64
  6212  		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6213  		v3.AddArg(y)
  6214  		v2.AddArg(v3)
  6215  		v0.AddArg(v2)
  6216  		v.AddArg(v0)
  6217  		return true
  6218  	}
  6219  }
  6220  func rewriteValueS390X_OpRsh64Ux16_0(v *Value) bool {
  6221  	b := v.Block
  6222  	_ = b
  6223  	typ := &b.Func.Config.Types
  6224  	_ = typ
  6225  	// match: (Rsh64Ux16 x y)
  6226  	// cond: shiftIsBounded(v)
  6227  	// result: (SRD x y)
  6228  	for {
  6229  		_ = v.Args[1]
  6230  		x := v.Args[0]
  6231  		y := v.Args[1]
  6232  		if !(shiftIsBounded(v)) {
  6233  			break
  6234  		}
  6235  		v.reset(OpS390XSRD)
  6236  		v.AddArg(x)
  6237  		v.AddArg(y)
  6238  		return true
  6239  	}
  6240  	// match: (Rsh64Ux16 <t> x y)
  6241  	// cond:
  6242  	// result: (MOVDGE <t> (SRD <t> x y) (MOVDconst [0]) (CMPWUconst (MOVHZreg y) [64]))
  6243  	for {
  6244  		t := v.Type
  6245  		_ = v.Args[1]
  6246  		x := v.Args[0]
  6247  		y := v.Args[1]
  6248  		v.reset(OpS390XMOVDGE)
  6249  		v.Type = t
  6250  		v0 := b.NewValue0(v.Pos, OpS390XSRD, t)
  6251  		v0.AddArg(x)
  6252  		v0.AddArg(y)
  6253  		v.AddArg(v0)
  6254  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  6255  		v1.AuxInt = 0
  6256  		v.AddArg(v1)
  6257  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6258  		v2.AuxInt = 64
  6259  		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  6260  		v3.AddArg(y)
  6261  		v2.AddArg(v3)
  6262  		v.AddArg(v2)
  6263  		return true
  6264  	}
  6265  }
  6266  func rewriteValueS390X_OpRsh64Ux32_0(v *Value) bool {
  6267  	b := v.Block
  6268  	_ = b
  6269  	typ := &b.Func.Config.Types
  6270  	_ = typ
  6271  	// match: (Rsh64Ux32 x y)
  6272  	// cond: shiftIsBounded(v)
  6273  	// result: (SRD x y)
  6274  	for {
  6275  		_ = v.Args[1]
  6276  		x := v.Args[0]
  6277  		y := v.Args[1]
  6278  		if !(shiftIsBounded(v)) {
  6279  			break
  6280  		}
  6281  		v.reset(OpS390XSRD)
  6282  		v.AddArg(x)
  6283  		v.AddArg(y)
  6284  		return true
  6285  	}
  6286  	// match: (Rsh64Ux32 <t> x y)
  6287  	// cond:
  6288  	// result: (MOVDGE <t> (SRD <t> x y) (MOVDconst [0]) (CMPWUconst y [64]))
  6289  	for {
  6290  		t := v.Type
  6291  		_ = v.Args[1]
  6292  		x := v.Args[0]
  6293  		y := v.Args[1]
  6294  		v.reset(OpS390XMOVDGE)
  6295  		v.Type = t
  6296  		v0 := b.NewValue0(v.Pos, OpS390XSRD, t)
  6297  		v0.AddArg(x)
  6298  		v0.AddArg(y)
  6299  		v.AddArg(v0)
  6300  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  6301  		v1.AuxInt = 0
  6302  		v.AddArg(v1)
  6303  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6304  		v2.AuxInt = 64
  6305  		v2.AddArg(y)
  6306  		v.AddArg(v2)
  6307  		return true
  6308  	}
  6309  }
  6310  func rewriteValueS390X_OpRsh64Ux64_0(v *Value) bool {
  6311  	b := v.Block
  6312  	_ = b
  6313  	typ := &b.Func.Config.Types
  6314  	_ = typ
  6315  	// match: (Rsh64Ux64 x y)
  6316  	// cond: shiftIsBounded(v)
  6317  	// result: (SRD x y)
  6318  	for {
  6319  		_ = v.Args[1]
  6320  		x := v.Args[0]
  6321  		y := v.Args[1]
  6322  		if !(shiftIsBounded(v)) {
  6323  			break
  6324  		}
  6325  		v.reset(OpS390XSRD)
  6326  		v.AddArg(x)
  6327  		v.AddArg(y)
  6328  		return true
  6329  	}
  6330  	// match: (Rsh64Ux64 <t> x y)
  6331  	// cond:
  6332  	// result: (MOVDGE <t> (SRD <t> x y) (MOVDconst [0]) (CMPUconst y [64]))
  6333  	for {
  6334  		t := v.Type
  6335  		_ = v.Args[1]
  6336  		x := v.Args[0]
  6337  		y := v.Args[1]
  6338  		v.reset(OpS390XMOVDGE)
  6339  		v.Type = t
  6340  		v0 := b.NewValue0(v.Pos, OpS390XSRD, t)
  6341  		v0.AddArg(x)
  6342  		v0.AddArg(y)
  6343  		v.AddArg(v0)
  6344  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  6345  		v1.AuxInt = 0
  6346  		v.AddArg(v1)
  6347  		v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  6348  		v2.AuxInt = 64
  6349  		v2.AddArg(y)
  6350  		v.AddArg(v2)
  6351  		return true
  6352  	}
  6353  }
  6354  func rewriteValueS390X_OpRsh64Ux8_0(v *Value) bool {
  6355  	b := v.Block
  6356  	_ = b
  6357  	typ := &b.Func.Config.Types
  6358  	_ = typ
  6359  	// match: (Rsh64Ux8 x y)
  6360  	// cond: shiftIsBounded(v)
  6361  	// result: (SRD x y)
  6362  	for {
  6363  		_ = v.Args[1]
  6364  		x := v.Args[0]
  6365  		y := v.Args[1]
  6366  		if !(shiftIsBounded(v)) {
  6367  			break
  6368  		}
  6369  		v.reset(OpS390XSRD)
  6370  		v.AddArg(x)
  6371  		v.AddArg(y)
  6372  		return true
  6373  	}
  6374  	// match: (Rsh64Ux8 <t> x y)
  6375  	// cond:
  6376  	// result: (MOVDGE <t> (SRD <t> x y) (MOVDconst [0]) (CMPWUconst (MOVBZreg y) [64]))
  6377  	for {
  6378  		t := v.Type
  6379  		_ = v.Args[1]
  6380  		x := v.Args[0]
  6381  		y := v.Args[1]
  6382  		v.reset(OpS390XMOVDGE)
  6383  		v.Type = t
  6384  		v0 := b.NewValue0(v.Pos, OpS390XSRD, t)
  6385  		v0.AddArg(x)
  6386  		v0.AddArg(y)
  6387  		v.AddArg(v0)
  6388  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  6389  		v1.AuxInt = 0
  6390  		v.AddArg(v1)
  6391  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6392  		v2.AuxInt = 64
  6393  		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6394  		v3.AddArg(y)
  6395  		v2.AddArg(v3)
  6396  		v.AddArg(v2)
  6397  		return true
  6398  	}
  6399  }
  6400  func rewriteValueS390X_OpRsh64x16_0(v *Value) bool {
  6401  	b := v.Block
  6402  	_ = b
  6403  	typ := &b.Func.Config.Types
  6404  	_ = typ
  6405  	// match: (Rsh64x16 x y)
  6406  	// cond: shiftIsBounded(v)
  6407  	// result: (SRAD x y)
  6408  	for {
  6409  		_ = v.Args[1]
  6410  		x := v.Args[0]
  6411  		y := v.Args[1]
  6412  		if !(shiftIsBounded(v)) {
  6413  			break
  6414  		}
  6415  		v.reset(OpS390XSRAD)
  6416  		v.AddArg(x)
  6417  		v.AddArg(y)
  6418  		return true
  6419  	}
  6420  	// match: (Rsh64x16 x y)
  6421  	// cond:
  6422  	// result: (SRAD x (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst (MOVHZreg y) [64])))
  6423  	for {
  6424  		_ = v.Args[1]
  6425  		x := v.Args[0]
  6426  		y := v.Args[1]
  6427  		v.reset(OpS390XSRAD)
  6428  		v.AddArg(x)
  6429  		v0 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6430  		v0.AddArg(y)
  6431  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6432  		v1.AuxInt = 63
  6433  		v0.AddArg(v1)
  6434  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6435  		v2.AuxInt = 64
  6436  		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  6437  		v3.AddArg(y)
  6438  		v2.AddArg(v3)
  6439  		v0.AddArg(v2)
  6440  		v.AddArg(v0)
  6441  		return true
  6442  	}
  6443  }
  6444  func rewriteValueS390X_OpRsh64x32_0(v *Value) bool {
  6445  	b := v.Block
  6446  	_ = b
  6447  	// match: (Rsh64x32 x y)
  6448  	// cond: shiftIsBounded(v)
  6449  	// result: (SRAD x y)
  6450  	for {
  6451  		_ = v.Args[1]
  6452  		x := v.Args[0]
  6453  		y := v.Args[1]
  6454  		if !(shiftIsBounded(v)) {
  6455  			break
  6456  		}
  6457  		v.reset(OpS390XSRAD)
  6458  		v.AddArg(x)
  6459  		v.AddArg(y)
  6460  		return true
  6461  	}
  6462  	// match: (Rsh64x32 x y)
  6463  	// cond:
  6464  	// result: (SRAD x (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst y [64])))
  6465  	for {
  6466  		_ = v.Args[1]
  6467  		x := v.Args[0]
  6468  		y := v.Args[1]
  6469  		v.reset(OpS390XSRAD)
  6470  		v.AddArg(x)
  6471  		v0 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6472  		v0.AddArg(y)
  6473  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6474  		v1.AuxInt = 63
  6475  		v0.AddArg(v1)
  6476  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6477  		v2.AuxInt = 64
  6478  		v2.AddArg(y)
  6479  		v0.AddArg(v2)
  6480  		v.AddArg(v0)
  6481  		return true
  6482  	}
  6483  }
  6484  func rewriteValueS390X_OpRsh64x64_0(v *Value) bool {
  6485  	b := v.Block
  6486  	_ = b
  6487  	// match: (Rsh64x64 x y)
  6488  	// cond: shiftIsBounded(v)
  6489  	// result: (SRAD x y)
  6490  	for {
  6491  		_ = v.Args[1]
  6492  		x := v.Args[0]
  6493  		y := v.Args[1]
  6494  		if !(shiftIsBounded(v)) {
  6495  			break
  6496  		}
  6497  		v.reset(OpS390XSRAD)
  6498  		v.AddArg(x)
  6499  		v.AddArg(y)
  6500  		return true
  6501  	}
  6502  	// match: (Rsh64x64 x y)
  6503  	// cond:
  6504  	// result: (SRAD x (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPUconst y [64])))
  6505  	for {
  6506  		_ = v.Args[1]
  6507  		x := v.Args[0]
  6508  		y := v.Args[1]
  6509  		v.reset(OpS390XSRAD)
  6510  		v.AddArg(x)
  6511  		v0 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6512  		v0.AddArg(y)
  6513  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6514  		v1.AuxInt = 63
  6515  		v0.AddArg(v1)
  6516  		v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  6517  		v2.AuxInt = 64
  6518  		v2.AddArg(y)
  6519  		v0.AddArg(v2)
  6520  		v.AddArg(v0)
  6521  		return true
  6522  	}
  6523  }
  6524  func rewriteValueS390X_OpRsh64x8_0(v *Value) bool {
  6525  	b := v.Block
  6526  	_ = b
  6527  	typ := &b.Func.Config.Types
  6528  	_ = typ
  6529  	// match: (Rsh64x8 x y)
  6530  	// cond: shiftIsBounded(v)
  6531  	// result: (SRAD x y)
  6532  	for {
  6533  		_ = v.Args[1]
  6534  		x := v.Args[0]
  6535  		y := v.Args[1]
  6536  		if !(shiftIsBounded(v)) {
  6537  			break
  6538  		}
  6539  		v.reset(OpS390XSRAD)
  6540  		v.AddArg(x)
  6541  		v.AddArg(y)
  6542  		return true
  6543  	}
  6544  	// match: (Rsh64x8 x y)
  6545  	// cond:
  6546  	// result: (SRAD x (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst (MOVBZreg y) [64])))
  6547  	for {
  6548  		_ = v.Args[1]
  6549  		x := v.Args[0]
  6550  		y := v.Args[1]
  6551  		v.reset(OpS390XSRAD)
  6552  		v.AddArg(x)
  6553  		v0 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6554  		v0.AddArg(y)
  6555  		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6556  		v1.AuxInt = 63
  6557  		v0.AddArg(v1)
  6558  		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6559  		v2.AuxInt = 64
  6560  		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6561  		v3.AddArg(y)
  6562  		v2.AddArg(v3)
  6563  		v0.AddArg(v2)
  6564  		v.AddArg(v0)
  6565  		return true
  6566  	}
  6567  }
  6568  func rewriteValueS390X_OpRsh8Ux16_0(v *Value) bool {
  6569  	b := v.Block
  6570  	_ = b
  6571  	typ := &b.Func.Config.Types
  6572  	_ = typ
  6573  	// match: (Rsh8Ux16 x y)
  6574  	// cond: shiftIsBounded(v)
  6575  	// result: (SRW (MOVBZreg x) y)
  6576  	for {
  6577  		_ = v.Args[1]
  6578  		x := v.Args[0]
  6579  		y := v.Args[1]
  6580  		if !(shiftIsBounded(v)) {
  6581  			break
  6582  		}
  6583  		v.reset(OpS390XSRW)
  6584  		v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6585  		v0.AddArg(x)
  6586  		v.AddArg(v0)
  6587  		v.AddArg(y)
  6588  		return true
  6589  	}
  6590  	// match: (Rsh8Ux16 <t> x y)
  6591  	// cond:
  6592  	// result: (MOVDGE <t> (SRW <t> (MOVBZreg x) y) (MOVDconst [0]) (CMPWUconst (MOVHZreg y) [64]))
  6593  	for {
  6594  		t := v.Type
  6595  		_ = v.Args[1]
  6596  		x := v.Args[0]
  6597  		y := v.Args[1]
  6598  		v.reset(OpS390XMOVDGE)
  6599  		v.Type = t
  6600  		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  6601  		v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6602  		v1.AddArg(x)
  6603  		v0.AddArg(v1)
  6604  		v0.AddArg(y)
  6605  		v.AddArg(v0)
  6606  		v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  6607  		v2.AuxInt = 0
  6608  		v.AddArg(v2)
  6609  		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6610  		v3.AuxInt = 64
  6611  		v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  6612  		v4.AddArg(y)
  6613  		v3.AddArg(v4)
  6614  		v.AddArg(v3)
  6615  		return true
  6616  	}
  6617  }
  6618  func rewriteValueS390X_OpRsh8Ux32_0(v *Value) bool {
  6619  	b := v.Block
  6620  	_ = b
  6621  	typ := &b.Func.Config.Types
  6622  	_ = typ
  6623  	// match: (Rsh8Ux32 x y)
  6624  	// cond: shiftIsBounded(v)
  6625  	// result: (SRW (MOVBZreg x) y)
  6626  	for {
  6627  		_ = v.Args[1]
  6628  		x := v.Args[0]
  6629  		y := v.Args[1]
  6630  		if !(shiftIsBounded(v)) {
  6631  			break
  6632  		}
  6633  		v.reset(OpS390XSRW)
  6634  		v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6635  		v0.AddArg(x)
  6636  		v.AddArg(v0)
  6637  		v.AddArg(y)
  6638  		return true
  6639  	}
  6640  	// match: (Rsh8Ux32 <t> x y)
  6641  	// cond:
  6642  	// result: (MOVDGE <t> (SRW <t> (MOVBZreg x) y) (MOVDconst [0]) (CMPWUconst y [64]))
  6643  	for {
  6644  		t := v.Type
  6645  		_ = v.Args[1]
  6646  		x := v.Args[0]
  6647  		y := v.Args[1]
  6648  		v.reset(OpS390XMOVDGE)
  6649  		v.Type = t
  6650  		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  6651  		v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6652  		v1.AddArg(x)
  6653  		v0.AddArg(v1)
  6654  		v0.AddArg(y)
  6655  		v.AddArg(v0)
  6656  		v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  6657  		v2.AuxInt = 0
  6658  		v.AddArg(v2)
  6659  		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6660  		v3.AuxInt = 64
  6661  		v3.AddArg(y)
  6662  		v.AddArg(v3)
  6663  		return true
  6664  	}
  6665  }
  6666  func rewriteValueS390X_OpRsh8Ux64_0(v *Value) bool {
  6667  	b := v.Block
  6668  	_ = b
  6669  	typ := &b.Func.Config.Types
  6670  	_ = typ
  6671  	// match: (Rsh8Ux64 x y)
  6672  	// cond: shiftIsBounded(v)
  6673  	// result: (SRW (MOVBZreg x) y)
  6674  	for {
  6675  		_ = v.Args[1]
  6676  		x := v.Args[0]
  6677  		y := v.Args[1]
  6678  		if !(shiftIsBounded(v)) {
  6679  			break
  6680  		}
  6681  		v.reset(OpS390XSRW)
  6682  		v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6683  		v0.AddArg(x)
  6684  		v.AddArg(v0)
  6685  		v.AddArg(y)
  6686  		return true
  6687  	}
  6688  	// match: (Rsh8Ux64 <t> x y)
  6689  	// cond:
  6690  	// result: (MOVDGE <t> (SRW <t> (MOVBZreg x) y) (MOVDconst [0]) (CMPUconst y [64]))
  6691  	for {
  6692  		t := v.Type
  6693  		_ = v.Args[1]
  6694  		x := v.Args[0]
  6695  		y := v.Args[1]
  6696  		v.reset(OpS390XMOVDGE)
  6697  		v.Type = t
  6698  		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  6699  		v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6700  		v1.AddArg(x)
  6701  		v0.AddArg(v1)
  6702  		v0.AddArg(y)
  6703  		v.AddArg(v0)
  6704  		v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  6705  		v2.AuxInt = 0
  6706  		v.AddArg(v2)
  6707  		v3 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  6708  		v3.AuxInt = 64
  6709  		v3.AddArg(y)
  6710  		v.AddArg(v3)
  6711  		return true
  6712  	}
  6713  }
  6714  func rewriteValueS390X_OpRsh8Ux8_0(v *Value) bool {
  6715  	b := v.Block
  6716  	_ = b
  6717  	typ := &b.Func.Config.Types
  6718  	_ = typ
  6719  	// match: (Rsh8Ux8 x y)
  6720  	// cond: shiftIsBounded(v)
  6721  	// result: (SRW (MOVBZreg x) y)
  6722  	for {
  6723  		_ = v.Args[1]
  6724  		x := v.Args[0]
  6725  		y := v.Args[1]
  6726  		if !(shiftIsBounded(v)) {
  6727  			break
  6728  		}
  6729  		v.reset(OpS390XSRW)
  6730  		v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6731  		v0.AddArg(x)
  6732  		v.AddArg(v0)
  6733  		v.AddArg(y)
  6734  		return true
  6735  	}
  6736  	// match: (Rsh8Ux8 <t> x y)
  6737  	// cond:
  6738  	// result: (MOVDGE <t> (SRW <t> (MOVBZreg x) y) (MOVDconst [0]) (CMPWUconst (MOVBZreg y) [64]))
  6739  	for {
  6740  		t := v.Type
  6741  		_ = v.Args[1]
  6742  		x := v.Args[0]
  6743  		y := v.Args[1]
  6744  		v.reset(OpS390XMOVDGE)
  6745  		v.Type = t
  6746  		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
  6747  		v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6748  		v1.AddArg(x)
  6749  		v0.AddArg(v1)
  6750  		v0.AddArg(y)
  6751  		v.AddArg(v0)
  6752  		v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
  6753  		v2.AuxInt = 0
  6754  		v.AddArg(v2)
  6755  		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6756  		v3.AuxInt = 64
  6757  		v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6758  		v4.AddArg(y)
  6759  		v3.AddArg(v4)
  6760  		v.AddArg(v3)
  6761  		return true
  6762  	}
  6763  }
  6764  func rewriteValueS390X_OpRsh8x16_0(v *Value) bool {
  6765  	b := v.Block
  6766  	_ = b
  6767  	typ := &b.Func.Config.Types
  6768  	_ = typ
  6769  	// match: (Rsh8x16 x y)
  6770  	// cond: shiftIsBounded(v)
  6771  	// result: (SRAW (MOVBreg x) y)
  6772  	for {
  6773  		_ = v.Args[1]
  6774  		x := v.Args[0]
  6775  		y := v.Args[1]
  6776  		if !(shiftIsBounded(v)) {
  6777  			break
  6778  		}
  6779  		v.reset(OpS390XSRAW)
  6780  		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  6781  		v0.AddArg(x)
  6782  		v.AddArg(v0)
  6783  		v.AddArg(y)
  6784  		return true
  6785  	}
  6786  	// match: (Rsh8x16 x y)
  6787  	// cond:
  6788  	// result: (SRAW (MOVBreg x) (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst (MOVHZreg y) [64])))
  6789  	for {
  6790  		_ = v.Args[1]
  6791  		x := v.Args[0]
  6792  		y := v.Args[1]
  6793  		v.reset(OpS390XSRAW)
  6794  		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  6795  		v0.AddArg(x)
  6796  		v.AddArg(v0)
  6797  		v1 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6798  		v1.AddArg(y)
  6799  		v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6800  		v2.AuxInt = 63
  6801  		v1.AddArg(v2)
  6802  		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6803  		v3.AuxInt = 64
  6804  		v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
  6805  		v4.AddArg(y)
  6806  		v3.AddArg(v4)
  6807  		v1.AddArg(v3)
  6808  		v.AddArg(v1)
  6809  		return true
  6810  	}
  6811  }
  6812  func rewriteValueS390X_OpRsh8x32_0(v *Value) bool {
  6813  	b := v.Block
  6814  	_ = b
  6815  	typ := &b.Func.Config.Types
  6816  	_ = typ
  6817  	// match: (Rsh8x32 x y)
  6818  	// cond: shiftIsBounded(v)
  6819  	// result: (SRAW (MOVBreg x) y)
  6820  	for {
  6821  		_ = v.Args[1]
  6822  		x := v.Args[0]
  6823  		y := v.Args[1]
  6824  		if !(shiftIsBounded(v)) {
  6825  			break
  6826  		}
  6827  		v.reset(OpS390XSRAW)
  6828  		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  6829  		v0.AddArg(x)
  6830  		v.AddArg(v0)
  6831  		v.AddArg(y)
  6832  		return true
  6833  	}
  6834  	// match: (Rsh8x32 x y)
  6835  	// cond:
  6836  	// result: (SRAW (MOVBreg x) (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst y [64])))
  6837  	for {
  6838  		_ = v.Args[1]
  6839  		x := v.Args[0]
  6840  		y := v.Args[1]
  6841  		v.reset(OpS390XSRAW)
  6842  		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  6843  		v0.AddArg(x)
  6844  		v.AddArg(v0)
  6845  		v1 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6846  		v1.AddArg(y)
  6847  		v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6848  		v2.AuxInt = 63
  6849  		v1.AddArg(v2)
  6850  		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6851  		v3.AuxInt = 64
  6852  		v3.AddArg(y)
  6853  		v1.AddArg(v3)
  6854  		v.AddArg(v1)
  6855  		return true
  6856  	}
  6857  }
  6858  func rewriteValueS390X_OpRsh8x64_0(v *Value) bool {
  6859  	b := v.Block
  6860  	_ = b
  6861  	typ := &b.Func.Config.Types
  6862  	_ = typ
  6863  	// match: (Rsh8x64 x y)
  6864  	// cond: shiftIsBounded(v)
  6865  	// result: (SRAW (MOVBreg x) y)
  6866  	for {
  6867  		_ = v.Args[1]
  6868  		x := v.Args[0]
  6869  		y := v.Args[1]
  6870  		if !(shiftIsBounded(v)) {
  6871  			break
  6872  		}
  6873  		v.reset(OpS390XSRAW)
  6874  		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  6875  		v0.AddArg(x)
  6876  		v.AddArg(v0)
  6877  		v.AddArg(y)
  6878  		return true
  6879  	}
  6880  	// match: (Rsh8x64 x y)
  6881  	// cond:
  6882  	// result: (SRAW (MOVBreg x) (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPUconst y [64])))
  6883  	for {
  6884  		_ = v.Args[1]
  6885  		x := v.Args[0]
  6886  		y := v.Args[1]
  6887  		v.reset(OpS390XSRAW)
  6888  		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  6889  		v0.AddArg(x)
  6890  		v.AddArg(v0)
  6891  		v1 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6892  		v1.AddArg(y)
  6893  		v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6894  		v2.AuxInt = 63
  6895  		v1.AddArg(v2)
  6896  		v3 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  6897  		v3.AuxInt = 64
  6898  		v3.AddArg(y)
  6899  		v1.AddArg(v3)
  6900  		v.AddArg(v1)
  6901  		return true
  6902  	}
  6903  }
  6904  func rewriteValueS390X_OpRsh8x8_0(v *Value) bool {
  6905  	b := v.Block
  6906  	_ = b
  6907  	typ := &b.Func.Config.Types
  6908  	_ = typ
  6909  	// match: (Rsh8x8 x y)
  6910  	// cond: shiftIsBounded(v)
  6911  	// result: (SRAW (MOVBreg x) y)
  6912  	for {
  6913  		_ = v.Args[1]
  6914  		x := v.Args[0]
  6915  		y := v.Args[1]
  6916  		if !(shiftIsBounded(v)) {
  6917  			break
  6918  		}
  6919  		v.reset(OpS390XSRAW)
  6920  		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  6921  		v0.AddArg(x)
  6922  		v.AddArg(v0)
  6923  		v.AddArg(y)
  6924  		return true
  6925  	}
  6926  	// match: (Rsh8x8 x y)
  6927  	// cond:
  6928  	// result: (SRAW (MOVBreg x) (MOVDGE <y.Type> y (MOVDconst <y.Type> [63]) (CMPWUconst (MOVBZreg y) [64])))
  6929  	for {
  6930  		_ = v.Args[1]
  6931  		x := v.Args[0]
  6932  		y := v.Args[1]
  6933  		v.reset(OpS390XSRAW)
  6934  		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
  6935  		v0.AddArg(x)
  6936  		v.AddArg(v0)
  6937  		v1 := b.NewValue0(v.Pos, OpS390XMOVDGE, y.Type)
  6938  		v1.AddArg(y)
  6939  		v2 := b.NewValue0(v.Pos, OpS390XMOVDconst, y.Type)
  6940  		v2.AuxInt = 63
  6941  		v1.AddArg(v2)
  6942  		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  6943  		v3.AuxInt = 64
  6944  		v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
  6945  		v4.AddArg(y)
  6946  		v3.AddArg(v4)
  6947  		v1.AddArg(v3)
  6948  		v.AddArg(v1)
  6949  		return true
  6950  	}
  6951  }
  6952  func rewriteValueS390X_OpS390XADD_0(v *Value) bool {
  6953  	// match: (ADD x (MOVDconst [c]))
  6954  	// cond: is32Bit(c)
  6955  	// result: (ADDconst [c] x)
  6956  	for {
  6957  		_ = v.Args[1]
  6958  		x := v.Args[0]
  6959  		v_1 := v.Args[1]
  6960  		if v_1.Op != OpS390XMOVDconst {
  6961  			break
  6962  		}
  6963  		c := v_1.AuxInt
  6964  		if !(is32Bit(c)) {
  6965  			break
  6966  		}
  6967  		v.reset(OpS390XADDconst)
  6968  		v.AuxInt = c
  6969  		v.AddArg(x)
  6970  		return true
  6971  	}
  6972  	// match: (ADD (MOVDconst [c]) x)
  6973  	// cond: is32Bit(c)
  6974  	// result: (ADDconst [c] x)
  6975  	for {
  6976  		_ = v.Args[1]
  6977  		v_0 := v.Args[0]
  6978  		if v_0.Op != OpS390XMOVDconst {
  6979  			break
  6980  		}
  6981  		c := v_0.AuxInt
  6982  		x := v.Args[1]
  6983  		if !(is32Bit(c)) {
  6984  			break
  6985  		}
  6986  		v.reset(OpS390XADDconst)
  6987  		v.AuxInt = c
  6988  		v.AddArg(x)
  6989  		return true
  6990  	}
  6991  	// match: (ADD (SLDconst x [c]) (SRDconst x [d]))
  6992  	// cond: d == 64-c
  6993  	// result: (RLLGconst [c] x)
  6994  	for {
  6995  		_ = v.Args[1]
  6996  		v_0 := v.Args[0]
  6997  		if v_0.Op != OpS390XSLDconst {
  6998  			break
  6999  		}
  7000  		c := v_0.AuxInt
  7001  		x := v_0.Args[0]
  7002  		v_1 := v.Args[1]
  7003  		if v_1.Op != OpS390XSRDconst {
  7004  			break
  7005  		}
  7006  		d := v_1.AuxInt
  7007  		if x != v_1.Args[0] {
  7008  			break
  7009  		}
  7010  		if !(d == 64-c) {
  7011  			break
  7012  		}
  7013  		v.reset(OpS390XRLLGconst)
  7014  		v.AuxInt = c
  7015  		v.AddArg(x)
  7016  		return true
  7017  	}
  7018  	// match: (ADD (SRDconst x [d]) (SLDconst x [c]))
  7019  	// cond: d == 64-c
  7020  	// result: (RLLGconst [c] x)
  7021  	for {
  7022  		_ = v.Args[1]
  7023  		v_0 := v.Args[0]
  7024  		if v_0.Op != OpS390XSRDconst {
  7025  			break
  7026  		}
  7027  		d := v_0.AuxInt
  7028  		x := v_0.Args[0]
  7029  		v_1 := v.Args[1]
  7030  		if v_1.Op != OpS390XSLDconst {
  7031  			break
  7032  		}
  7033  		c := v_1.AuxInt
  7034  		if x != v_1.Args[0] {
  7035  			break
  7036  		}
  7037  		if !(d == 64-c) {
  7038  			break
  7039  		}
  7040  		v.reset(OpS390XRLLGconst)
  7041  		v.AuxInt = c
  7042  		v.AddArg(x)
  7043  		return true
  7044  	}
  7045  	// match: (ADD idx (MOVDaddr [c] {s} ptr))
  7046  	// cond: ptr.Op != OpSB && idx.Op != OpSB
  7047  	// result: (MOVDaddridx [c] {s} ptr idx)
  7048  	for {
  7049  		_ = v.Args[1]
  7050  		idx := v.Args[0]
  7051  		v_1 := v.Args[1]
  7052  		if v_1.Op != OpS390XMOVDaddr {
  7053  			break
  7054  		}
  7055  		c := v_1.AuxInt
  7056  		s := v_1.Aux
  7057  		ptr := v_1.Args[0]
  7058  		if !(ptr.Op != OpSB && idx.Op != OpSB) {
  7059  			break
  7060  		}
  7061  		v.reset(OpS390XMOVDaddridx)
  7062  		v.AuxInt = c
  7063  		v.Aux = s
  7064  		v.AddArg(ptr)
  7065  		v.AddArg(idx)
  7066  		return true
  7067  	}
  7068  	// match: (ADD (MOVDaddr [c] {s} ptr) idx)
  7069  	// cond: ptr.Op != OpSB && idx.Op != OpSB
  7070  	// result: (MOVDaddridx [c] {s} ptr idx)
  7071  	for {
  7072  		_ = v.Args[1]
  7073  		v_0 := v.Args[0]
  7074  		if v_0.Op != OpS390XMOVDaddr {
  7075  			break
  7076  		}
  7077  		c := v_0.AuxInt
  7078  		s := v_0.Aux
  7079  		ptr := v_0.Args[0]
  7080  		idx := v.Args[1]
  7081  		if !(ptr.Op != OpSB && idx.Op != OpSB) {
  7082  			break
  7083  		}
  7084  		v.reset(OpS390XMOVDaddridx)
  7085  		v.AuxInt = c
  7086  		v.Aux = s
  7087  		v.AddArg(ptr)
  7088  		v.AddArg(idx)
  7089  		return true
  7090  	}
  7091  	// match: (ADD x (NEG y))
  7092  	// cond:
  7093  	// result: (SUB x y)
  7094  	for {
  7095  		_ = v.Args[1]
  7096  		x := v.Args[0]
  7097  		v_1 := v.Args[1]
  7098  		if v_1.Op != OpS390XNEG {
  7099  			break
  7100  		}
  7101  		y := v_1.Args[0]
  7102  		v.reset(OpS390XSUB)
  7103  		v.AddArg(x)
  7104  		v.AddArg(y)
  7105  		return true
  7106  	}
  7107  	// match: (ADD (NEG y) x)
  7108  	// cond:
  7109  	// result: (SUB x y)
  7110  	for {
  7111  		_ = v.Args[1]
  7112  		v_0 := v.Args[0]
  7113  		if v_0.Op != OpS390XNEG {
  7114  			break
  7115  		}
  7116  		y := v_0.Args[0]
  7117  		x := v.Args[1]
  7118  		v.reset(OpS390XSUB)
  7119  		v.AddArg(x)
  7120  		v.AddArg(y)
  7121  		return true
  7122  	}
  7123  	// match: (ADD <t> x g:(MOVDload [off] {sym} ptr mem))
  7124  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7125  	// result: (ADDload <t> [off] {sym} x ptr mem)
  7126  	for {
  7127  		t := v.Type
  7128  		_ = v.Args[1]
  7129  		x := v.Args[0]
  7130  		g := v.Args[1]
  7131  		if g.Op != OpS390XMOVDload {
  7132  			break
  7133  		}
  7134  		off := g.AuxInt
  7135  		sym := g.Aux
  7136  		_ = g.Args[1]
  7137  		ptr := g.Args[0]
  7138  		mem := g.Args[1]
  7139  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7140  			break
  7141  		}
  7142  		v.reset(OpS390XADDload)
  7143  		v.Type = t
  7144  		v.AuxInt = off
  7145  		v.Aux = sym
  7146  		v.AddArg(x)
  7147  		v.AddArg(ptr)
  7148  		v.AddArg(mem)
  7149  		return true
  7150  	}
  7151  	// match: (ADD <t> g:(MOVDload [off] {sym} ptr mem) x)
  7152  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7153  	// result: (ADDload <t> [off] {sym} x ptr mem)
  7154  	for {
  7155  		t := v.Type
  7156  		_ = v.Args[1]
  7157  		g := v.Args[0]
  7158  		if g.Op != OpS390XMOVDload {
  7159  			break
  7160  		}
  7161  		off := g.AuxInt
  7162  		sym := g.Aux
  7163  		_ = g.Args[1]
  7164  		ptr := g.Args[0]
  7165  		mem := g.Args[1]
  7166  		x := v.Args[1]
  7167  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7168  			break
  7169  		}
  7170  		v.reset(OpS390XADDload)
  7171  		v.Type = t
  7172  		v.AuxInt = off
  7173  		v.Aux = sym
  7174  		v.AddArg(x)
  7175  		v.AddArg(ptr)
  7176  		v.AddArg(mem)
  7177  		return true
  7178  	}
  7179  	return false
  7180  }
  7181  func rewriteValueS390X_OpS390XADD_10(v *Value) bool {
  7182  	// match: (ADD <t> g:(MOVDload [off] {sym} ptr mem) x)
  7183  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7184  	// result: (ADDload <t> [off] {sym} x ptr mem)
  7185  	for {
  7186  		t := v.Type
  7187  		_ = v.Args[1]
  7188  		g := v.Args[0]
  7189  		if g.Op != OpS390XMOVDload {
  7190  			break
  7191  		}
  7192  		off := g.AuxInt
  7193  		sym := g.Aux
  7194  		_ = g.Args[1]
  7195  		ptr := g.Args[0]
  7196  		mem := g.Args[1]
  7197  		x := v.Args[1]
  7198  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7199  			break
  7200  		}
  7201  		v.reset(OpS390XADDload)
  7202  		v.Type = t
  7203  		v.AuxInt = off
  7204  		v.Aux = sym
  7205  		v.AddArg(x)
  7206  		v.AddArg(ptr)
  7207  		v.AddArg(mem)
  7208  		return true
  7209  	}
  7210  	// match: (ADD <t> x g:(MOVDload [off] {sym} ptr mem))
  7211  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7212  	// result: (ADDload <t> [off] {sym} x ptr mem)
  7213  	for {
  7214  		t := v.Type
  7215  		_ = v.Args[1]
  7216  		x := v.Args[0]
  7217  		g := v.Args[1]
  7218  		if g.Op != OpS390XMOVDload {
  7219  			break
  7220  		}
  7221  		off := g.AuxInt
  7222  		sym := g.Aux
  7223  		_ = g.Args[1]
  7224  		ptr := g.Args[0]
  7225  		mem := g.Args[1]
  7226  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7227  			break
  7228  		}
  7229  		v.reset(OpS390XADDload)
  7230  		v.Type = t
  7231  		v.AuxInt = off
  7232  		v.Aux = sym
  7233  		v.AddArg(x)
  7234  		v.AddArg(ptr)
  7235  		v.AddArg(mem)
  7236  		return true
  7237  	}
  7238  	return false
  7239  }
  7240  func rewriteValueS390X_OpS390XADDW_0(v *Value) bool {
  7241  	// match: (ADDW x (MOVDconst [c]))
  7242  	// cond:
  7243  	// result: (ADDWconst [int64(int32(c))] x)
  7244  	for {
  7245  		_ = v.Args[1]
  7246  		x := v.Args[0]
  7247  		v_1 := v.Args[1]
  7248  		if v_1.Op != OpS390XMOVDconst {
  7249  			break
  7250  		}
  7251  		c := v_1.AuxInt
  7252  		v.reset(OpS390XADDWconst)
  7253  		v.AuxInt = int64(int32(c))
  7254  		v.AddArg(x)
  7255  		return true
  7256  	}
  7257  	// match: (ADDW (MOVDconst [c]) x)
  7258  	// cond:
  7259  	// result: (ADDWconst [int64(int32(c))] x)
  7260  	for {
  7261  		_ = v.Args[1]
  7262  		v_0 := v.Args[0]
  7263  		if v_0.Op != OpS390XMOVDconst {
  7264  			break
  7265  		}
  7266  		c := v_0.AuxInt
  7267  		x := v.Args[1]
  7268  		v.reset(OpS390XADDWconst)
  7269  		v.AuxInt = int64(int32(c))
  7270  		v.AddArg(x)
  7271  		return true
  7272  	}
  7273  	// match: (ADDW (SLWconst x [c]) (SRWconst x [d]))
  7274  	// cond: d == 32-c
  7275  	// result: (RLLconst [c] x)
  7276  	for {
  7277  		_ = v.Args[1]
  7278  		v_0 := v.Args[0]
  7279  		if v_0.Op != OpS390XSLWconst {
  7280  			break
  7281  		}
  7282  		c := v_0.AuxInt
  7283  		x := v_0.Args[0]
  7284  		v_1 := v.Args[1]
  7285  		if v_1.Op != OpS390XSRWconst {
  7286  			break
  7287  		}
  7288  		d := v_1.AuxInt
  7289  		if x != v_1.Args[0] {
  7290  			break
  7291  		}
  7292  		if !(d == 32-c) {
  7293  			break
  7294  		}
  7295  		v.reset(OpS390XRLLconst)
  7296  		v.AuxInt = c
  7297  		v.AddArg(x)
  7298  		return true
  7299  	}
  7300  	// match: (ADDW (SRWconst x [d]) (SLWconst x [c]))
  7301  	// cond: d == 32-c
  7302  	// result: (RLLconst [c] x)
  7303  	for {
  7304  		_ = v.Args[1]
  7305  		v_0 := v.Args[0]
  7306  		if v_0.Op != OpS390XSRWconst {
  7307  			break
  7308  		}
  7309  		d := v_0.AuxInt
  7310  		x := v_0.Args[0]
  7311  		v_1 := v.Args[1]
  7312  		if v_1.Op != OpS390XSLWconst {
  7313  			break
  7314  		}
  7315  		c := v_1.AuxInt
  7316  		if x != v_1.Args[0] {
  7317  			break
  7318  		}
  7319  		if !(d == 32-c) {
  7320  			break
  7321  		}
  7322  		v.reset(OpS390XRLLconst)
  7323  		v.AuxInt = c
  7324  		v.AddArg(x)
  7325  		return true
  7326  	}
  7327  	// match: (ADDW x (NEGW y))
  7328  	// cond:
  7329  	// result: (SUBW x y)
  7330  	for {
  7331  		_ = v.Args[1]
  7332  		x := v.Args[0]
  7333  		v_1 := v.Args[1]
  7334  		if v_1.Op != OpS390XNEGW {
  7335  			break
  7336  		}
  7337  		y := v_1.Args[0]
  7338  		v.reset(OpS390XSUBW)
  7339  		v.AddArg(x)
  7340  		v.AddArg(y)
  7341  		return true
  7342  	}
  7343  	// match: (ADDW (NEGW y) x)
  7344  	// cond:
  7345  	// result: (SUBW x y)
  7346  	for {
  7347  		_ = v.Args[1]
  7348  		v_0 := v.Args[0]
  7349  		if v_0.Op != OpS390XNEGW {
  7350  			break
  7351  		}
  7352  		y := v_0.Args[0]
  7353  		x := v.Args[1]
  7354  		v.reset(OpS390XSUBW)
  7355  		v.AddArg(x)
  7356  		v.AddArg(y)
  7357  		return true
  7358  	}
  7359  	// match: (ADDW <t> x g:(MOVWload [off] {sym} ptr mem))
  7360  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7361  	// result: (ADDWload <t> [off] {sym} x ptr mem)
  7362  	for {
  7363  		t := v.Type
  7364  		_ = v.Args[1]
  7365  		x := v.Args[0]
  7366  		g := v.Args[1]
  7367  		if g.Op != OpS390XMOVWload {
  7368  			break
  7369  		}
  7370  		off := g.AuxInt
  7371  		sym := g.Aux
  7372  		_ = g.Args[1]
  7373  		ptr := g.Args[0]
  7374  		mem := g.Args[1]
  7375  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7376  			break
  7377  		}
  7378  		v.reset(OpS390XADDWload)
  7379  		v.Type = t
  7380  		v.AuxInt = off
  7381  		v.Aux = sym
  7382  		v.AddArg(x)
  7383  		v.AddArg(ptr)
  7384  		v.AddArg(mem)
  7385  		return true
  7386  	}
  7387  	// match: (ADDW <t> g:(MOVWload [off] {sym} ptr mem) x)
  7388  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7389  	// result: (ADDWload <t> [off] {sym} x ptr mem)
  7390  	for {
  7391  		t := v.Type
  7392  		_ = v.Args[1]
  7393  		g := v.Args[0]
  7394  		if g.Op != OpS390XMOVWload {
  7395  			break
  7396  		}
  7397  		off := g.AuxInt
  7398  		sym := g.Aux
  7399  		_ = g.Args[1]
  7400  		ptr := g.Args[0]
  7401  		mem := g.Args[1]
  7402  		x := v.Args[1]
  7403  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7404  			break
  7405  		}
  7406  		v.reset(OpS390XADDWload)
  7407  		v.Type = t
  7408  		v.AuxInt = off
  7409  		v.Aux = sym
  7410  		v.AddArg(x)
  7411  		v.AddArg(ptr)
  7412  		v.AddArg(mem)
  7413  		return true
  7414  	}
  7415  	// match: (ADDW <t> g:(MOVWload [off] {sym} ptr mem) x)
  7416  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7417  	// result: (ADDWload <t> [off] {sym} x ptr mem)
  7418  	for {
  7419  		t := v.Type
  7420  		_ = v.Args[1]
  7421  		g := v.Args[0]
  7422  		if g.Op != OpS390XMOVWload {
  7423  			break
  7424  		}
  7425  		off := g.AuxInt
  7426  		sym := g.Aux
  7427  		_ = g.Args[1]
  7428  		ptr := g.Args[0]
  7429  		mem := g.Args[1]
  7430  		x := v.Args[1]
  7431  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7432  			break
  7433  		}
  7434  		v.reset(OpS390XADDWload)
  7435  		v.Type = t
  7436  		v.AuxInt = off
  7437  		v.Aux = sym
  7438  		v.AddArg(x)
  7439  		v.AddArg(ptr)
  7440  		v.AddArg(mem)
  7441  		return true
  7442  	}
  7443  	// match: (ADDW <t> x g:(MOVWload [off] {sym} ptr mem))
  7444  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7445  	// result: (ADDWload <t> [off] {sym} x ptr mem)
  7446  	for {
  7447  		t := v.Type
  7448  		_ = v.Args[1]
  7449  		x := v.Args[0]
  7450  		g := v.Args[1]
  7451  		if g.Op != OpS390XMOVWload {
  7452  			break
  7453  		}
  7454  		off := g.AuxInt
  7455  		sym := g.Aux
  7456  		_ = g.Args[1]
  7457  		ptr := g.Args[0]
  7458  		mem := g.Args[1]
  7459  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7460  			break
  7461  		}
  7462  		v.reset(OpS390XADDWload)
  7463  		v.Type = t
  7464  		v.AuxInt = off
  7465  		v.Aux = sym
  7466  		v.AddArg(x)
  7467  		v.AddArg(ptr)
  7468  		v.AddArg(mem)
  7469  		return true
  7470  	}
  7471  	return false
  7472  }
  7473  func rewriteValueS390X_OpS390XADDW_10(v *Value) bool {
  7474  	// match: (ADDW <t> x g:(MOVWZload [off] {sym} ptr mem))
  7475  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7476  	// result: (ADDWload <t> [off] {sym} x ptr mem)
  7477  	for {
  7478  		t := v.Type
  7479  		_ = v.Args[1]
  7480  		x := v.Args[0]
  7481  		g := v.Args[1]
  7482  		if g.Op != OpS390XMOVWZload {
  7483  			break
  7484  		}
  7485  		off := g.AuxInt
  7486  		sym := g.Aux
  7487  		_ = g.Args[1]
  7488  		ptr := g.Args[0]
  7489  		mem := g.Args[1]
  7490  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7491  			break
  7492  		}
  7493  		v.reset(OpS390XADDWload)
  7494  		v.Type = t
  7495  		v.AuxInt = off
  7496  		v.Aux = sym
  7497  		v.AddArg(x)
  7498  		v.AddArg(ptr)
  7499  		v.AddArg(mem)
  7500  		return true
  7501  	}
  7502  	// match: (ADDW <t> g:(MOVWZload [off] {sym} ptr mem) x)
  7503  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7504  	// result: (ADDWload <t> [off] {sym} x ptr mem)
  7505  	for {
  7506  		t := v.Type
  7507  		_ = v.Args[1]
  7508  		g := v.Args[0]
  7509  		if g.Op != OpS390XMOVWZload {
  7510  			break
  7511  		}
  7512  		off := g.AuxInt
  7513  		sym := g.Aux
  7514  		_ = g.Args[1]
  7515  		ptr := g.Args[0]
  7516  		mem := g.Args[1]
  7517  		x := v.Args[1]
  7518  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7519  			break
  7520  		}
  7521  		v.reset(OpS390XADDWload)
  7522  		v.Type = t
  7523  		v.AuxInt = off
  7524  		v.Aux = sym
  7525  		v.AddArg(x)
  7526  		v.AddArg(ptr)
  7527  		v.AddArg(mem)
  7528  		return true
  7529  	}
  7530  	// match: (ADDW <t> g:(MOVWZload [off] {sym} ptr mem) x)
  7531  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7532  	// result: (ADDWload <t> [off] {sym} x ptr mem)
  7533  	for {
  7534  		t := v.Type
  7535  		_ = v.Args[1]
  7536  		g := v.Args[0]
  7537  		if g.Op != OpS390XMOVWZload {
  7538  			break
  7539  		}
  7540  		off := g.AuxInt
  7541  		sym := g.Aux
  7542  		_ = g.Args[1]
  7543  		ptr := g.Args[0]
  7544  		mem := g.Args[1]
  7545  		x := v.Args[1]
  7546  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7547  			break
  7548  		}
  7549  		v.reset(OpS390XADDWload)
  7550  		v.Type = t
  7551  		v.AuxInt = off
  7552  		v.Aux = sym
  7553  		v.AddArg(x)
  7554  		v.AddArg(ptr)
  7555  		v.AddArg(mem)
  7556  		return true
  7557  	}
  7558  	// match: (ADDW <t> x g:(MOVWZload [off] {sym} ptr mem))
  7559  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  7560  	// result: (ADDWload <t> [off] {sym} x ptr mem)
  7561  	for {
  7562  		t := v.Type
  7563  		_ = v.Args[1]
  7564  		x := v.Args[0]
  7565  		g := v.Args[1]
  7566  		if g.Op != OpS390XMOVWZload {
  7567  			break
  7568  		}
  7569  		off := g.AuxInt
  7570  		sym := g.Aux
  7571  		_ = g.Args[1]
  7572  		ptr := g.Args[0]
  7573  		mem := g.Args[1]
  7574  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  7575  			break
  7576  		}
  7577  		v.reset(OpS390XADDWload)
  7578  		v.Type = t
  7579  		v.AuxInt = off
  7580  		v.Aux = sym
  7581  		v.AddArg(x)
  7582  		v.AddArg(ptr)
  7583  		v.AddArg(mem)
  7584  		return true
  7585  	}
  7586  	return false
  7587  }
  7588  func rewriteValueS390X_OpS390XADDWconst_0(v *Value) bool {
  7589  	// match: (ADDWconst [c] x)
  7590  	// cond: int32(c)==0
  7591  	// result: x
  7592  	for {
  7593  		c := v.AuxInt
  7594  		x := v.Args[0]
  7595  		if !(int32(c) == 0) {
  7596  			break
  7597  		}
  7598  		v.reset(OpCopy)
  7599  		v.Type = x.Type
  7600  		v.AddArg(x)
  7601  		return true
  7602  	}
  7603  	// match: (ADDWconst [c] (MOVDconst [d]))
  7604  	// cond:
  7605  	// result: (MOVDconst [int64(int32(c+d))])
  7606  	for {
  7607  		c := v.AuxInt
  7608  		v_0 := v.Args[0]
  7609  		if v_0.Op != OpS390XMOVDconst {
  7610  			break
  7611  		}
  7612  		d := v_0.AuxInt
  7613  		v.reset(OpS390XMOVDconst)
  7614  		v.AuxInt = int64(int32(c + d))
  7615  		return true
  7616  	}
  7617  	// match: (ADDWconst [c] (ADDWconst [d] x))
  7618  	// cond:
  7619  	// result: (ADDWconst [int64(int32(c+d))] x)
  7620  	for {
  7621  		c := v.AuxInt
  7622  		v_0 := v.Args[0]
  7623  		if v_0.Op != OpS390XADDWconst {
  7624  			break
  7625  		}
  7626  		d := v_0.AuxInt
  7627  		x := v_0.Args[0]
  7628  		v.reset(OpS390XADDWconst)
  7629  		v.AuxInt = int64(int32(c + d))
  7630  		v.AddArg(x)
  7631  		return true
  7632  	}
  7633  	return false
  7634  }
  7635  func rewriteValueS390X_OpS390XADDWload_0(v *Value) bool {
  7636  	// match: (ADDWload [off1] {sym} x (ADDconst [off2] ptr) mem)
  7637  	// cond: ptr.Op != OpSB && is20Bit(off1+off2)
  7638  	// result: (ADDWload [off1+off2] {sym} x ptr mem)
  7639  	for {
  7640  		off1 := v.AuxInt
  7641  		sym := v.Aux
  7642  		_ = v.Args[2]
  7643  		x := v.Args[0]
  7644  		v_1 := v.Args[1]
  7645  		if v_1.Op != OpS390XADDconst {
  7646  			break
  7647  		}
  7648  		off2 := v_1.AuxInt
  7649  		ptr := v_1.Args[0]
  7650  		mem := v.Args[2]
  7651  		if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
  7652  			break
  7653  		}
  7654  		v.reset(OpS390XADDWload)
  7655  		v.AuxInt = off1 + off2
  7656  		v.Aux = sym
  7657  		v.AddArg(x)
  7658  		v.AddArg(ptr)
  7659  		v.AddArg(mem)
  7660  		return true
  7661  	}
  7662  	// match: (ADDWload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
  7663  	// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
  7664  	// result: (ADDWload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
  7665  	for {
  7666  		o1 := v.AuxInt
  7667  		s1 := v.Aux
  7668  		_ = v.Args[2]
  7669  		x := v.Args[0]
  7670  		v_1 := v.Args[1]
  7671  		if v_1.Op != OpS390XMOVDaddr {
  7672  			break
  7673  		}
  7674  		o2 := v_1.AuxInt
  7675  		s2 := v_1.Aux
  7676  		ptr := v_1.Args[0]
  7677  		mem := v.Args[2]
  7678  		if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
  7679  			break
  7680  		}
  7681  		v.reset(OpS390XADDWload)
  7682  		v.AuxInt = o1 + o2
  7683  		v.Aux = mergeSym(s1, s2)
  7684  		v.AddArg(x)
  7685  		v.AddArg(ptr)
  7686  		v.AddArg(mem)
  7687  		return true
  7688  	}
  7689  	return false
  7690  }
  7691  func rewriteValueS390X_OpS390XADDconst_0(v *Value) bool {
  7692  	// match: (ADDconst [c] (MOVDaddr [d] {s} x:(SB)))
  7693  	// cond: ((c+d)&1 == 0) && is32Bit(c+d)
  7694  	// result: (MOVDaddr [c+d] {s} x)
  7695  	for {
  7696  		c := v.AuxInt
  7697  		v_0 := v.Args[0]
  7698  		if v_0.Op != OpS390XMOVDaddr {
  7699  			break
  7700  		}
  7701  		d := v_0.AuxInt
  7702  		s := v_0.Aux
  7703  		x := v_0.Args[0]
  7704  		if x.Op != OpSB {
  7705  			break
  7706  		}
  7707  		if !(((c+d)&1 == 0) && is32Bit(c+d)) {
  7708  			break
  7709  		}
  7710  		v.reset(OpS390XMOVDaddr)
  7711  		v.AuxInt = c + d
  7712  		v.Aux = s
  7713  		v.AddArg(x)
  7714  		return true
  7715  	}
  7716  	// match: (ADDconst [c] (MOVDaddr [d] {s} x))
  7717  	// cond: x.Op != OpSB && is20Bit(c+d)
  7718  	// result: (MOVDaddr [c+d] {s} x)
  7719  	for {
  7720  		c := v.AuxInt
  7721  		v_0 := v.Args[0]
  7722  		if v_0.Op != OpS390XMOVDaddr {
  7723  			break
  7724  		}
  7725  		d := v_0.AuxInt
  7726  		s := v_0.Aux
  7727  		x := v_0.Args[0]
  7728  		if !(x.Op != OpSB && is20Bit(c+d)) {
  7729  			break
  7730  		}
  7731  		v.reset(OpS390XMOVDaddr)
  7732  		v.AuxInt = c + d
  7733  		v.Aux = s
  7734  		v.AddArg(x)
  7735  		return true
  7736  	}
  7737  	// match: (ADDconst [c] (MOVDaddridx [d] {s} x y))
  7738  	// cond: is20Bit(c+d)
  7739  	// result: (MOVDaddridx [c+d] {s} x y)
  7740  	for {
  7741  		c := v.AuxInt
  7742  		v_0 := v.Args[0]
  7743  		if v_0.Op != OpS390XMOVDaddridx {
  7744  			break
  7745  		}
  7746  		d := v_0.AuxInt
  7747  		s := v_0.Aux
  7748  		_ = v_0.Args[1]
  7749  		x := v_0.Args[0]
  7750  		y := v_0.Args[1]
  7751  		if !(is20Bit(c + d)) {
  7752  			break
  7753  		}
  7754  		v.reset(OpS390XMOVDaddridx)
  7755  		v.AuxInt = c + d
  7756  		v.Aux = s
  7757  		v.AddArg(x)
  7758  		v.AddArg(y)
  7759  		return true
  7760  	}
  7761  	// match: (ADDconst [0] x)
  7762  	// cond:
  7763  	// result: x
  7764  	for {
  7765  		if v.AuxInt != 0 {
  7766  			break
  7767  		}
  7768  		x := v.Args[0]
  7769  		v.reset(OpCopy)
  7770  		v.Type = x.Type
  7771  		v.AddArg(x)
  7772  		return true
  7773  	}
  7774  	// match: (ADDconst [c] (MOVDconst [d]))
  7775  	// cond:
  7776  	// result: (MOVDconst [c+d])
  7777  	for {
  7778  		c := v.AuxInt
  7779  		v_0 := v.Args[0]
  7780  		if v_0.Op != OpS390XMOVDconst {
  7781  			break
  7782  		}
  7783  		d := v_0.AuxInt
  7784  		v.reset(OpS390XMOVDconst)
  7785  		v.AuxInt = c + d
  7786  		return true
  7787  	}
  7788  	// match: (ADDconst [c] (ADDconst [d] x))
  7789  	// cond: is32Bit(c+d)
  7790  	// result: (ADDconst [c+d] x)
  7791  	for {
  7792  		c := v.AuxInt
  7793  		v_0 := v.Args[0]
  7794  		if v_0.Op != OpS390XADDconst {
  7795  			break
  7796  		}
  7797  		d := v_0.AuxInt
  7798  		x := v_0.Args[0]
  7799  		if !(is32Bit(c + d)) {
  7800  			break
  7801  		}
  7802  		v.reset(OpS390XADDconst)
  7803  		v.AuxInt = c + d
  7804  		v.AddArg(x)
  7805  		return true
  7806  	}
  7807  	return false
  7808  }
  7809  func rewriteValueS390X_OpS390XADDload_0(v *Value) bool {
  7810  	b := v.Block
  7811  	_ = b
  7812  	// match: (ADDload <t> [off] {sym} x ptr1 (FMOVDstore [off] {sym} ptr2 y _))
  7813  	// cond: isSamePtr(ptr1, ptr2)
  7814  	// result: (ADD x (LGDR <t> y))
  7815  	for {
  7816  		t := v.Type
  7817  		off := v.AuxInt
  7818  		sym := v.Aux
  7819  		_ = v.Args[2]
  7820  		x := v.Args[0]
  7821  		ptr1 := v.Args[1]
  7822  		v_2 := v.Args[2]
  7823  		if v_2.Op != OpS390XFMOVDstore {
  7824  			break
  7825  		}
  7826  		if v_2.AuxInt != off {
  7827  			break
  7828  		}
  7829  		if v_2.Aux != sym {
  7830  			break
  7831  		}
  7832  		_ = v_2.Args[2]
  7833  		ptr2 := v_2.Args[0]
  7834  		y := v_2.Args[1]
  7835  		if !(isSamePtr(ptr1, ptr2)) {
  7836  			break
  7837  		}
  7838  		v.reset(OpS390XADD)
  7839  		v.AddArg(x)
  7840  		v0 := b.NewValue0(v_2.Pos, OpS390XLGDR, t)
  7841  		v0.AddArg(y)
  7842  		v.AddArg(v0)
  7843  		return true
  7844  	}
  7845  	// match: (ADDload [off1] {sym} x (ADDconst [off2] ptr) mem)
  7846  	// cond: ptr.Op != OpSB && is20Bit(off1+off2)
  7847  	// result: (ADDload [off1+off2] {sym} x ptr mem)
  7848  	for {
  7849  		off1 := v.AuxInt
  7850  		sym := v.Aux
  7851  		_ = v.Args[2]
  7852  		x := v.Args[0]
  7853  		v_1 := v.Args[1]
  7854  		if v_1.Op != OpS390XADDconst {
  7855  			break
  7856  		}
  7857  		off2 := v_1.AuxInt
  7858  		ptr := v_1.Args[0]
  7859  		mem := v.Args[2]
  7860  		if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
  7861  			break
  7862  		}
  7863  		v.reset(OpS390XADDload)
  7864  		v.AuxInt = off1 + off2
  7865  		v.Aux = sym
  7866  		v.AddArg(x)
  7867  		v.AddArg(ptr)
  7868  		v.AddArg(mem)
  7869  		return true
  7870  	}
  7871  	// match: (ADDload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
  7872  	// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
  7873  	// result: (ADDload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
  7874  	for {
  7875  		o1 := v.AuxInt
  7876  		s1 := v.Aux
  7877  		_ = v.Args[2]
  7878  		x := v.Args[0]
  7879  		v_1 := v.Args[1]
  7880  		if v_1.Op != OpS390XMOVDaddr {
  7881  			break
  7882  		}
  7883  		o2 := v_1.AuxInt
  7884  		s2 := v_1.Aux
  7885  		ptr := v_1.Args[0]
  7886  		mem := v.Args[2]
  7887  		if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
  7888  			break
  7889  		}
  7890  		v.reset(OpS390XADDload)
  7891  		v.AuxInt = o1 + o2
  7892  		v.Aux = mergeSym(s1, s2)
  7893  		v.AddArg(x)
  7894  		v.AddArg(ptr)
  7895  		v.AddArg(mem)
  7896  		return true
  7897  	}
  7898  	return false
  7899  }
  7900  func rewriteValueS390X_OpS390XAND_0(v *Value) bool {
  7901  	b := v.Block
  7902  	_ = b
  7903  	typ := &b.Func.Config.Types
  7904  	_ = typ
  7905  	// match: (AND x (MOVDconst [c]))
  7906  	// cond: is32Bit(c) && c < 0
  7907  	// result: (ANDconst [c] x)
  7908  	for {
  7909  		_ = v.Args[1]
  7910  		x := v.Args[0]
  7911  		v_1 := v.Args[1]
  7912  		if v_1.Op != OpS390XMOVDconst {
  7913  			break
  7914  		}
  7915  		c := v_1.AuxInt
  7916  		if !(is32Bit(c) && c < 0) {
  7917  			break
  7918  		}
  7919  		v.reset(OpS390XANDconst)
  7920  		v.AuxInt = c
  7921  		v.AddArg(x)
  7922  		return true
  7923  	}
  7924  	// match: (AND (MOVDconst [c]) x)
  7925  	// cond: is32Bit(c) && c < 0
  7926  	// result: (ANDconst [c] x)
  7927  	for {
  7928  		_ = v.Args[1]
  7929  		v_0 := v.Args[0]
  7930  		if v_0.Op != OpS390XMOVDconst {
  7931  			break
  7932  		}
  7933  		c := v_0.AuxInt
  7934  		x := v.Args[1]
  7935  		if !(is32Bit(c) && c < 0) {
  7936  			break
  7937  		}
  7938  		v.reset(OpS390XANDconst)
  7939  		v.AuxInt = c
  7940  		v.AddArg(x)
  7941  		return true
  7942  	}
  7943  	// match: (AND x (MOVDconst [c]))
  7944  	// cond: is32Bit(c) && c >= 0
  7945  	// result: (MOVWZreg (ANDWconst <typ.UInt32> [int64(int32(c))] x))
  7946  	for {
  7947  		_ = v.Args[1]
  7948  		x := v.Args[0]
  7949  		v_1 := v.Args[1]
  7950  		if v_1.Op != OpS390XMOVDconst {
  7951  			break
  7952  		}
  7953  		c := v_1.AuxInt
  7954  		if !(is32Bit(c) && c >= 0) {
  7955  			break
  7956  		}
  7957  		v.reset(OpS390XMOVWZreg)
  7958  		v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
  7959  		v0.AuxInt = int64(int32(c))
  7960  		v0.AddArg(x)
  7961  		v.AddArg(v0)
  7962  		return true
  7963  	}
  7964  	// match: (AND (MOVDconst [c]) x)
  7965  	// cond: is32Bit(c) && c >= 0
  7966  	// result: (MOVWZreg (ANDWconst <typ.UInt32> [int64(int32(c))] x))
  7967  	for {
  7968  		_ = v.Args[1]
  7969  		v_0 := v.Args[0]
  7970  		if v_0.Op != OpS390XMOVDconst {
  7971  			break
  7972  		}
  7973  		c := v_0.AuxInt
  7974  		x := v.Args[1]
  7975  		if !(is32Bit(c) && c >= 0) {
  7976  			break
  7977  		}
  7978  		v.reset(OpS390XMOVWZreg)
  7979  		v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
  7980  		v0.AuxInt = int64(int32(c))
  7981  		v0.AddArg(x)
  7982  		v.AddArg(v0)
  7983  		return true
  7984  	}
  7985  	// match: (AND x (MOVDconst [0xFF]))
  7986  	// cond:
  7987  	// result: (MOVBZreg x)
  7988  	for {
  7989  		_ = v.Args[1]
  7990  		x := v.Args[0]
  7991  		v_1 := v.Args[1]
  7992  		if v_1.Op != OpS390XMOVDconst {
  7993  			break
  7994  		}
  7995  		if v_1.AuxInt != 0xFF {
  7996  			break
  7997  		}
  7998  		v.reset(OpS390XMOVBZreg)
  7999  		v.AddArg(x)
  8000  		return true
  8001  	}
  8002  	// match: (AND (MOVDconst [0xFF]) x)
  8003  	// cond:
  8004  	// result: (MOVBZreg x)
  8005  	for {
  8006  		_ = v.Args[1]
  8007  		v_0 := v.Args[0]
  8008  		if v_0.Op != OpS390XMOVDconst {
  8009  			break
  8010  		}
  8011  		if v_0.AuxInt != 0xFF {
  8012  			break
  8013  		}
  8014  		x := v.Args[1]
  8015  		v.reset(OpS390XMOVBZreg)
  8016  		v.AddArg(x)
  8017  		return true
  8018  	}
  8019  	// match: (AND x (MOVDconst [0xFFFF]))
  8020  	// cond:
  8021  	// result: (MOVHZreg x)
  8022  	for {
  8023  		_ = v.Args[1]
  8024  		x := v.Args[0]
  8025  		v_1 := v.Args[1]
  8026  		if v_1.Op != OpS390XMOVDconst {
  8027  			break
  8028  		}
  8029  		if v_1.AuxInt != 0xFFFF {
  8030  			break
  8031  		}
  8032  		v.reset(OpS390XMOVHZreg)
  8033  		v.AddArg(x)
  8034  		return true
  8035  	}
  8036  	// match: (AND (MOVDconst [0xFFFF]) x)
  8037  	// cond:
  8038  	// result: (MOVHZreg x)
  8039  	for {
  8040  		_ = v.Args[1]
  8041  		v_0 := v.Args[0]
  8042  		if v_0.Op != OpS390XMOVDconst {
  8043  			break
  8044  		}
  8045  		if v_0.AuxInt != 0xFFFF {
  8046  			break
  8047  		}
  8048  		x := v.Args[1]
  8049  		v.reset(OpS390XMOVHZreg)
  8050  		v.AddArg(x)
  8051  		return true
  8052  	}
  8053  	// match: (AND x (MOVDconst [0xFFFFFFFF]))
  8054  	// cond:
  8055  	// result: (MOVWZreg x)
  8056  	for {
  8057  		_ = v.Args[1]
  8058  		x := v.Args[0]
  8059  		v_1 := v.Args[1]
  8060  		if v_1.Op != OpS390XMOVDconst {
  8061  			break
  8062  		}
  8063  		if v_1.AuxInt != 0xFFFFFFFF {
  8064  			break
  8065  		}
  8066  		v.reset(OpS390XMOVWZreg)
  8067  		v.AddArg(x)
  8068  		return true
  8069  	}
  8070  	// match: (AND (MOVDconst [0xFFFFFFFF]) x)
  8071  	// cond:
  8072  	// result: (MOVWZreg x)
  8073  	for {
  8074  		_ = v.Args[1]
  8075  		v_0 := v.Args[0]
  8076  		if v_0.Op != OpS390XMOVDconst {
  8077  			break
  8078  		}
  8079  		if v_0.AuxInt != 0xFFFFFFFF {
  8080  			break
  8081  		}
  8082  		x := v.Args[1]
  8083  		v.reset(OpS390XMOVWZreg)
  8084  		v.AddArg(x)
  8085  		return true
  8086  	}
  8087  	return false
  8088  }
  8089  func rewriteValueS390X_OpS390XAND_10(v *Value) bool {
  8090  	// match: (AND (MOVDconst [c]) (MOVDconst [d]))
  8091  	// cond:
  8092  	// result: (MOVDconst [c&d])
  8093  	for {
  8094  		_ = v.Args[1]
  8095  		v_0 := v.Args[0]
  8096  		if v_0.Op != OpS390XMOVDconst {
  8097  			break
  8098  		}
  8099  		c := v_0.AuxInt
  8100  		v_1 := v.Args[1]
  8101  		if v_1.Op != OpS390XMOVDconst {
  8102  			break
  8103  		}
  8104  		d := v_1.AuxInt
  8105  		v.reset(OpS390XMOVDconst)
  8106  		v.AuxInt = c & d
  8107  		return true
  8108  	}
  8109  	// match: (AND (MOVDconst [d]) (MOVDconst [c]))
  8110  	// cond:
  8111  	// result: (MOVDconst [c&d])
  8112  	for {
  8113  		_ = v.Args[1]
  8114  		v_0 := v.Args[0]
  8115  		if v_0.Op != OpS390XMOVDconst {
  8116  			break
  8117  		}
  8118  		d := v_0.AuxInt
  8119  		v_1 := v.Args[1]
  8120  		if v_1.Op != OpS390XMOVDconst {
  8121  			break
  8122  		}
  8123  		c := v_1.AuxInt
  8124  		v.reset(OpS390XMOVDconst)
  8125  		v.AuxInt = c & d
  8126  		return true
  8127  	}
  8128  	// match: (AND x x)
  8129  	// cond:
  8130  	// result: x
  8131  	for {
  8132  		_ = v.Args[1]
  8133  		x := v.Args[0]
  8134  		if x != v.Args[1] {
  8135  			break
  8136  		}
  8137  		v.reset(OpCopy)
  8138  		v.Type = x.Type
  8139  		v.AddArg(x)
  8140  		return true
  8141  	}
  8142  	// match: (AND <t> x g:(MOVDload [off] {sym} ptr mem))
  8143  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8144  	// result: (ANDload <t> [off] {sym} x ptr mem)
  8145  	for {
  8146  		t := v.Type
  8147  		_ = v.Args[1]
  8148  		x := v.Args[0]
  8149  		g := v.Args[1]
  8150  		if g.Op != OpS390XMOVDload {
  8151  			break
  8152  		}
  8153  		off := g.AuxInt
  8154  		sym := g.Aux
  8155  		_ = g.Args[1]
  8156  		ptr := g.Args[0]
  8157  		mem := g.Args[1]
  8158  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8159  			break
  8160  		}
  8161  		v.reset(OpS390XANDload)
  8162  		v.Type = t
  8163  		v.AuxInt = off
  8164  		v.Aux = sym
  8165  		v.AddArg(x)
  8166  		v.AddArg(ptr)
  8167  		v.AddArg(mem)
  8168  		return true
  8169  	}
  8170  	// match: (AND <t> g:(MOVDload [off] {sym} ptr mem) x)
  8171  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8172  	// result: (ANDload <t> [off] {sym} x ptr mem)
  8173  	for {
  8174  		t := v.Type
  8175  		_ = v.Args[1]
  8176  		g := v.Args[0]
  8177  		if g.Op != OpS390XMOVDload {
  8178  			break
  8179  		}
  8180  		off := g.AuxInt
  8181  		sym := g.Aux
  8182  		_ = g.Args[1]
  8183  		ptr := g.Args[0]
  8184  		mem := g.Args[1]
  8185  		x := v.Args[1]
  8186  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8187  			break
  8188  		}
  8189  		v.reset(OpS390XANDload)
  8190  		v.Type = t
  8191  		v.AuxInt = off
  8192  		v.Aux = sym
  8193  		v.AddArg(x)
  8194  		v.AddArg(ptr)
  8195  		v.AddArg(mem)
  8196  		return true
  8197  	}
  8198  	// match: (AND <t> g:(MOVDload [off] {sym} ptr mem) x)
  8199  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8200  	// result: (ANDload <t> [off] {sym} x ptr mem)
  8201  	for {
  8202  		t := v.Type
  8203  		_ = v.Args[1]
  8204  		g := v.Args[0]
  8205  		if g.Op != OpS390XMOVDload {
  8206  			break
  8207  		}
  8208  		off := g.AuxInt
  8209  		sym := g.Aux
  8210  		_ = g.Args[1]
  8211  		ptr := g.Args[0]
  8212  		mem := g.Args[1]
  8213  		x := v.Args[1]
  8214  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8215  			break
  8216  		}
  8217  		v.reset(OpS390XANDload)
  8218  		v.Type = t
  8219  		v.AuxInt = off
  8220  		v.Aux = sym
  8221  		v.AddArg(x)
  8222  		v.AddArg(ptr)
  8223  		v.AddArg(mem)
  8224  		return true
  8225  	}
  8226  	// match: (AND <t> x g:(MOVDload [off] {sym} ptr mem))
  8227  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8228  	// result: (ANDload <t> [off] {sym} x ptr mem)
  8229  	for {
  8230  		t := v.Type
  8231  		_ = v.Args[1]
  8232  		x := v.Args[0]
  8233  		g := v.Args[1]
  8234  		if g.Op != OpS390XMOVDload {
  8235  			break
  8236  		}
  8237  		off := g.AuxInt
  8238  		sym := g.Aux
  8239  		_ = g.Args[1]
  8240  		ptr := g.Args[0]
  8241  		mem := g.Args[1]
  8242  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8243  			break
  8244  		}
  8245  		v.reset(OpS390XANDload)
  8246  		v.Type = t
  8247  		v.AuxInt = off
  8248  		v.Aux = sym
  8249  		v.AddArg(x)
  8250  		v.AddArg(ptr)
  8251  		v.AddArg(mem)
  8252  		return true
  8253  	}
  8254  	return false
  8255  }
  8256  func rewriteValueS390X_OpS390XANDW_0(v *Value) bool {
  8257  	// match: (ANDW x (MOVDconst [c]))
  8258  	// cond:
  8259  	// result: (ANDWconst [int64(int32(c))] x)
  8260  	for {
  8261  		_ = v.Args[1]
  8262  		x := v.Args[0]
  8263  		v_1 := v.Args[1]
  8264  		if v_1.Op != OpS390XMOVDconst {
  8265  			break
  8266  		}
  8267  		c := v_1.AuxInt
  8268  		v.reset(OpS390XANDWconst)
  8269  		v.AuxInt = int64(int32(c))
  8270  		v.AddArg(x)
  8271  		return true
  8272  	}
  8273  	// match: (ANDW (MOVDconst [c]) x)
  8274  	// cond:
  8275  	// result: (ANDWconst [int64(int32(c))] x)
  8276  	for {
  8277  		_ = v.Args[1]
  8278  		v_0 := v.Args[0]
  8279  		if v_0.Op != OpS390XMOVDconst {
  8280  			break
  8281  		}
  8282  		c := v_0.AuxInt
  8283  		x := v.Args[1]
  8284  		v.reset(OpS390XANDWconst)
  8285  		v.AuxInt = int64(int32(c))
  8286  		v.AddArg(x)
  8287  		return true
  8288  	}
  8289  	// match: (ANDW x x)
  8290  	// cond:
  8291  	// result: x
  8292  	for {
  8293  		_ = v.Args[1]
  8294  		x := v.Args[0]
  8295  		if x != v.Args[1] {
  8296  			break
  8297  		}
  8298  		v.reset(OpCopy)
  8299  		v.Type = x.Type
  8300  		v.AddArg(x)
  8301  		return true
  8302  	}
  8303  	// match: (ANDW <t> x g:(MOVWload [off] {sym} ptr mem))
  8304  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8305  	// result: (ANDWload <t> [off] {sym} x ptr mem)
  8306  	for {
  8307  		t := v.Type
  8308  		_ = v.Args[1]
  8309  		x := v.Args[0]
  8310  		g := v.Args[1]
  8311  		if g.Op != OpS390XMOVWload {
  8312  			break
  8313  		}
  8314  		off := g.AuxInt
  8315  		sym := g.Aux
  8316  		_ = g.Args[1]
  8317  		ptr := g.Args[0]
  8318  		mem := g.Args[1]
  8319  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8320  			break
  8321  		}
  8322  		v.reset(OpS390XANDWload)
  8323  		v.Type = t
  8324  		v.AuxInt = off
  8325  		v.Aux = sym
  8326  		v.AddArg(x)
  8327  		v.AddArg(ptr)
  8328  		v.AddArg(mem)
  8329  		return true
  8330  	}
  8331  	// match: (ANDW <t> g:(MOVWload [off] {sym} ptr mem) x)
  8332  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8333  	// result: (ANDWload <t> [off] {sym} x ptr mem)
  8334  	for {
  8335  		t := v.Type
  8336  		_ = v.Args[1]
  8337  		g := v.Args[0]
  8338  		if g.Op != OpS390XMOVWload {
  8339  			break
  8340  		}
  8341  		off := g.AuxInt
  8342  		sym := g.Aux
  8343  		_ = g.Args[1]
  8344  		ptr := g.Args[0]
  8345  		mem := g.Args[1]
  8346  		x := v.Args[1]
  8347  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8348  			break
  8349  		}
  8350  		v.reset(OpS390XANDWload)
  8351  		v.Type = t
  8352  		v.AuxInt = off
  8353  		v.Aux = sym
  8354  		v.AddArg(x)
  8355  		v.AddArg(ptr)
  8356  		v.AddArg(mem)
  8357  		return true
  8358  	}
  8359  	// match: (ANDW <t> g:(MOVWload [off] {sym} ptr mem) x)
  8360  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8361  	// result: (ANDWload <t> [off] {sym} x ptr mem)
  8362  	for {
  8363  		t := v.Type
  8364  		_ = v.Args[1]
  8365  		g := v.Args[0]
  8366  		if g.Op != OpS390XMOVWload {
  8367  			break
  8368  		}
  8369  		off := g.AuxInt
  8370  		sym := g.Aux
  8371  		_ = g.Args[1]
  8372  		ptr := g.Args[0]
  8373  		mem := g.Args[1]
  8374  		x := v.Args[1]
  8375  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8376  			break
  8377  		}
  8378  		v.reset(OpS390XANDWload)
  8379  		v.Type = t
  8380  		v.AuxInt = off
  8381  		v.Aux = sym
  8382  		v.AddArg(x)
  8383  		v.AddArg(ptr)
  8384  		v.AddArg(mem)
  8385  		return true
  8386  	}
  8387  	// match: (ANDW <t> x g:(MOVWload [off] {sym} ptr mem))
  8388  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8389  	// result: (ANDWload <t> [off] {sym} x ptr mem)
  8390  	for {
  8391  		t := v.Type
  8392  		_ = v.Args[1]
  8393  		x := v.Args[0]
  8394  		g := v.Args[1]
  8395  		if g.Op != OpS390XMOVWload {
  8396  			break
  8397  		}
  8398  		off := g.AuxInt
  8399  		sym := g.Aux
  8400  		_ = g.Args[1]
  8401  		ptr := g.Args[0]
  8402  		mem := g.Args[1]
  8403  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8404  			break
  8405  		}
  8406  		v.reset(OpS390XANDWload)
  8407  		v.Type = t
  8408  		v.AuxInt = off
  8409  		v.Aux = sym
  8410  		v.AddArg(x)
  8411  		v.AddArg(ptr)
  8412  		v.AddArg(mem)
  8413  		return true
  8414  	}
  8415  	// match: (ANDW <t> x g:(MOVWZload [off] {sym} ptr mem))
  8416  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8417  	// result: (ANDWload <t> [off] {sym} x ptr mem)
  8418  	for {
  8419  		t := v.Type
  8420  		_ = v.Args[1]
  8421  		x := v.Args[0]
  8422  		g := v.Args[1]
  8423  		if g.Op != OpS390XMOVWZload {
  8424  			break
  8425  		}
  8426  		off := g.AuxInt
  8427  		sym := g.Aux
  8428  		_ = g.Args[1]
  8429  		ptr := g.Args[0]
  8430  		mem := g.Args[1]
  8431  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8432  			break
  8433  		}
  8434  		v.reset(OpS390XANDWload)
  8435  		v.Type = t
  8436  		v.AuxInt = off
  8437  		v.Aux = sym
  8438  		v.AddArg(x)
  8439  		v.AddArg(ptr)
  8440  		v.AddArg(mem)
  8441  		return true
  8442  	}
  8443  	// match: (ANDW <t> g:(MOVWZload [off] {sym} ptr mem) x)
  8444  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8445  	// result: (ANDWload <t> [off] {sym} x ptr mem)
  8446  	for {
  8447  		t := v.Type
  8448  		_ = v.Args[1]
  8449  		g := v.Args[0]
  8450  		if g.Op != OpS390XMOVWZload {
  8451  			break
  8452  		}
  8453  		off := g.AuxInt
  8454  		sym := g.Aux
  8455  		_ = g.Args[1]
  8456  		ptr := g.Args[0]
  8457  		mem := g.Args[1]
  8458  		x := v.Args[1]
  8459  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8460  			break
  8461  		}
  8462  		v.reset(OpS390XANDWload)
  8463  		v.Type = t
  8464  		v.AuxInt = off
  8465  		v.Aux = sym
  8466  		v.AddArg(x)
  8467  		v.AddArg(ptr)
  8468  		v.AddArg(mem)
  8469  		return true
  8470  	}
  8471  	// match: (ANDW <t> g:(MOVWZload [off] {sym} ptr mem) x)
  8472  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8473  	// result: (ANDWload <t> [off] {sym} x ptr mem)
  8474  	for {
  8475  		t := v.Type
  8476  		_ = v.Args[1]
  8477  		g := v.Args[0]
  8478  		if g.Op != OpS390XMOVWZload {
  8479  			break
  8480  		}
  8481  		off := g.AuxInt
  8482  		sym := g.Aux
  8483  		_ = g.Args[1]
  8484  		ptr := g.Args[0]
  8485  		mem := g.Args[1]
  8486  		x := v.Args[1]
  8487  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8488  			break
  8489  		}
  8490  		v.reset(OpS390XANDWload)
  8491  		v.Type = t
  8492  		v.AuxInt = off
  8493  		v.Aux = sym
  8494  		v.AddArg(x)
  8495  		v.AddArg(ptr)
  8496  		v.AddArg(mem)
  8497  		return true
  8498  	}
  8499  	return false
  8500  }
  8501  func rewriteValueS390X_OpS390XANDW_10(v *Value) bool {
  8502  	// match: (ANDW <t> x g:(MOVWZload [off] {sym} ptr mem))
  8503  	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)
  8504  	// result: (ANDWload <t> [off] {sym} x ptr mem)
  8505  	for {
  8506  		t := v.Type
  8507  		_ = v.Args[1]
  8508  		x := v.Args[0]
  8509  		g := v.Args[1]
  8510  		if g.Op != OpS390XMOVWZload {
  8511  			break
  8512  		}
  8513  		off := g.AuxInt
  8514  		sym := g.Aux
  8515  		_ = g.Args[1]
  8516  		ptr := g.Args[0]
  8517  		mem := g.Args[1]
  8518  		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoadClobber(v, g, x) && clobber(g)) {
  8519  			break
  8520  		}
  8521  		v.reset(OpS390XANDWload)
  8522  		v.Type = t
  8523  		v.AuxInt = off
  8524  		v.Aux = sym
  8525  		v.AddArg(x)
  8526  		v.AddArg(ptr)
  8527  		v.AddArg(mem)
  8528  		return true
  8529  	}
  8530  	return false
  8531  }
  8532  func rewriteValueS390X_OpS390XANDWconst_0(v *Value) bool {
  8533  	// match: (ANDWconst [c] (ANDWconst [d] x))
  8534  	// cond:
  8535  	// result: (ANDWconst [c & d] x)
  8536  	for {
  8537  		c := v.AuxInt
  8538  		v_0 := v.Args[0]
  8539  		if v_0.Op != OpS390XANDWconst {
  8540  			break
  8541  		}
  8542  		d := v_0.AuxInt
  8543  		x := v_0.Args[0]
  8544  		v.reset(OpS390XANDWconst)
  8545  		v.AuxInt = c & d
  8546  		v.AddArg(x)
  8547  		return true
  8548  	}
  8549  	// match: (ANDWconst [0xFF] x)
  8550  	// cond:
  8551  	// result: (MOVBZreg x)
  8552  	for {
  8553  		if v.AuxInt != 0xFF {
  8554  			break
  8555  		}
  8556  		x := v.Args[0]
  8557  		v.reset(OpS390XMOVBZreg)
  8558  		v.AddArg(x)
  8559  		return true
  8560  	}
  8561  	// match: (ANDWconst [0xFFFF] x)
  8562  	// cond:
  8563  	// result: (MOVHZreg x)
  8564  	for {
  8565  		if v.AuxInt != 0xFFFF {
  8566  			break
  8567  		}
  8568  		x := v.Args[0]
  8569  		v.reset(OpS390XMOVHZreg)
  8570  		v.AddArg(x)
  8571  		return true
  8572  	}
  8573  	// match: (ANDWconst [c] _)
  8574  	// cond: int32(c)==0
  8575  	// result: (MOVDconst [0])
  8576  	for {
  8577  		c := v.AuxInt
  8578  		if !(int32(c) == 0) {
  8579  			break
  8580  		}
  8581  		v.reset(OpS390XMOVDconst)
  8582  		v.AuxInt = 0
  8583  		return true
  8584  	}
  8585  	// match: (ANDWconst [c] x)
  8586  	// cond: int32(c)==-1
  8587  	// result: x
  8588  	for {
  8589  		c := v.AuxInt
  8590  		x := v.Args[0]
  8591  		if !(int32(c) == -1) {
  8592  			break
  8593  		}
  8594  		v.reset(OpCopy)
  8595  		v.Type = x.Type
  8596  		v.AddArg(x)
  8597  		return true
  8598  	}
  8599  	// match: (ANDWconst [c] (MOVDconst [d]))
  8600  	// cond:
  8601  	// result: (MOVDconst [c&d])
  8602  	for {
  8603  		c := v.AuxInt
  8604  		v_0 := v.Args[0]
  8605  		if v_0.Op != OpS390XMOVDconst {
  8606  			break
  8607  		}
  8608  		d := v_0.AuxInt
  8609  		v.reset(OpS390XMOVDconst)
  8610  		v.AuxInt = c & d
  8611  		return true
  8612  	}
  8613  	return false
  8614  }
  8615  func rewriteValueS390X_OpS390XANDWload_0(v *Value) bool {
  8616  	// match: (ANDWload [off1] {sym} x (ADDconst [off2] ptr) mem)
  8617  	// cond: ptr.Op != OpSB && is20Bit(off1+off2)
  8618  	// result: (ANDWload [off1+off2] {sym} x ptr mem)
  8619  	for {
  8620  		off1 := v.AuxInt
  8621  		sym := v.Aux
  8622  		_ = v.Args[2]
  8623  		x := v.Args[0]
  8624  		v_1 := v.Args[1]
  8625  		if v_1.Op != OpS390XADDconst {
  8626  			break
  8627  		}
  8628  		off2 := v_1.AuxInt
  8629  		ptr := v_1.Args[0]
  8630  		mem := v.Args[2]
  8631  		if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
  8632  			break
  8633  		}
  8634  		v.reset(OpS390XANDWload)
  8635  		v.AuxInt = off1 + off2
  8636  		v.Aux = sym
  8637  		v.AddArg(x)
  8638  		v.AddArg(ptr)
  8639  		v.AddArg(mem)
  8640  		return true
  8641  	}
  8642  	// match: (ANDWload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
  8643  	// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
  8644  	// result: (ANDWload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
  8645  	for {
  8646  		o1 := v.AuxInt
  8647  		s1 := v.Aux
  8648  		_ = v.Args[2]
  8649  		x := v.Args[0]
  8650  		v_1 := v.Args[1]
  8651  		if v_1.Op != OpS390XMOVDaddr {
  8652  			break
  8653  		}
  8654  		o2 := v_1.AuxInt
  8655  		s2 := v_1.Aux
  8656  		ptr := v_1.Args[0]
  8657  		mem := v.Args[2]
  8658  		if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
  8659  			break
  8660  		}
  8661  		v.reset(OpS390XANDWload)
  8662  		v.AuxInt = o1 + o2
  8663  		v.Aux = mergeSym(s1, s2)
  8664  		v.AddArg(x)
  8665  		v.AddArg(ptr)
  8666  		v.AddArg(mem)
  8667  		return true
  8668  	}
  8669  	return false
  8670  }
  8671  func rewriteValueS390X_OpS390XANDconst_0(v *Value) bool {
  8672  	// match: (ANDconst [c] (ANDconst [d] x))
  8673  	// cond:
  8674  	// result: (ANDconst [c & d] x)
  8675  	for {
  8676  		c := v.AuxInt
  8677  		v_0 := v.Args[0]
  8678  		if v_0.Op != OpS390XANDconst {
  8679  			break
  8680  		}
  8681  		d := v_0.AuxInt
  8682  		x := v_0.Args[0]
  8683  		v.reset(OpS390XANDconst)
  8684  		v.AuxInt = c & d
  8685  		v.AddArg(x)
  8686  		return true
  8687  	}
  8688  	// match: (ANDconst [0] _)
  8689  	// cond:
  8690  	// result: (MOVDconst [0])
  8691  	for {
  8692  		if v.AuxInt != 0 {
  8693  			break
  8694  		}
  8695  		v.reset(OpS390XMOVDconst)
  8696  		v.AuxInt = 0
  8697  		return true
  8698  	}
  8699  	// match: (ANDconst [-1] x)
  8700  	// cond:
  8701  	// result: x
  8702  	for {
  8703  		if v.AuxInt != -1 {
  8704  			break
  8705  		}
  8706  		x := v.Args[0]
  8707  		v.reset(OpCopy)
  8708  		v.Type = x.Type
  8709  		v.AddArg(x)
  8710  		return true
  8711  	}
  8712  	// match: (ANDconst [c] (MOVDconst [d]))
  8713  	// cond:
  8714  	// result: (MOVDconst [c&d])
  8715  	for {
  8716  		c := v.AuxInt
  8717  		v_0 := v.Args[0]
  8718  		if v_0.Op != OpS390XMOVDconst {
  8719  			break
  8720  		}
  8721  		d := v_0.AuxInt
  8722  		v.reset(OpS390XMOVDconst)
  8723  		v.AuxInt = c & d
  8724  		return true
  8725  	}
  8726  	return false
  8727  }
  8728  func rewriteValueS390X_OpS390XANDload_0(v *Value) bool {
  8729  	b := v.Block
  8730  	_ = b
  8731  	// match: (ANDload <t> [off] {sym} x ptr1 (FMOVDstore [off] {sym} ptr2 y _))
  8732  	// cond: isSamePtr(ptr1, ptr2)
  8733  	// result: (AND x (LGDR <t> y))
  8734  	for {
  8735  		t := v.Type
  8736  		off := v.AuxInt
  8737  		sym := v.Aux
  8738  		_ = v.Args[2]
  8739  		x := v.Args[0]
  8740  		ptr1 := v.Args[1]
  8741  		v_2 := v.Args[2]
  8742  		if v_2.Op != OpS390XFMOVDstore {
  8743  			break
  8744  		}
  8745  		if v_2.AuxInt != off {
  8746  			break
  8747  		}
  8748  		if v_2.Aux != sym {
  8749  			break
  8750  		}
  8751  		_ = v_2.Args[2]
  8752  		ptr2 := v_2.Args[0]
  8753  		y := v_2.Args[1]
  8754  		if !(isSamePtr(ptr1, ptr2)) {
  8755  			break
  8756  		}
  8757  		v.reset(OpS390XAND)
  8758  		v.AddArg(x)
  8759  		v0 := b.NewValue0(v_2.Pos, OpS390XLGDR, t)
  8760  		v0.AddArg(y)
  8761  		v.AddArg(v0)
  8762  		return true
  8763  	}
  8764  	// match: (ANDload [off1] {sym} x (ADDconst [off2] ptr) mem)
  8765  	// cond: ptr.Op != OpSB && is20Bit(off1+off2)
  8766  	// result: (ANDload [off1+off2] {sym} x ptr mem)
  8767  	for {
  8768  		off1 := v.AuxInt
  8769  		sym := v.Aux
  8770  		_ = v.Args[2]
  8771  		x := v.Args[0]
  8772  		v_1 := v.Args[1]
  8773  		if v_1.Op != OpS390XADDconst {
  8774  			break
  8775  		}
  8776  		off2 := v_1.AuxInt
  8777  		ptr := v_1.Args[0]
  8778  		mem := v.Args[2]
  8779  		if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
  8780  			break
  8781  		}
  8782  		v.reset(OpS390XANDload)
  8783  		v.AuxInt = off1 + off2
  8784  		v.Aux = sym
  8785  		v.AddArg(x)
  8786  		v.AddArg(ptr)
  8787  		v.AddArg(mem)
  8788  		return true
  8789  	}
  8790  	// match: (ANDload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
  8791  	// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
  8792  	// result: (ANDload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
  8793  	for {
  8794  		o1 := v.AuxInt
  8795  		s1 := v.Aux
  8796  		_ = v.Args[2]
  8797  		x := v.Args[0]
  8798  		v_1 := v.Args[1]
  8799  		if v_1.Op != OpS390XMOVDaddr {
  8800  			break
  8801  		}
  8802  		o2 := v_1.AuxInt
  8803  		s2 := v_1.Aux
  8804  		ptr := v_1.Args[0]
  8805  		mem := v.Args[2]
  8806  		if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
  8807  			break
  8808  		}
  8809  		v.reset(OpS390XANDload)
  8810  		v.AuxInt = o1 + o2
  8811  		v.Aux = mergeSym(s1, s2)
  8812  		v.AddArg(x)
  8813  		v.AddArg(ptr)
  8814  		v.AddArg(mem)
  8815  		return true
  8816  	}
  8817  	return false
  8818  }
  8819  func rewriteValueS390X_OpS390XCMP_0(v *Value) bool {
  8820  	b := v.Block
  8821  	_ = b
  8822  	// match: (CMP x (MOVDconst [c]))
  8823  	// cond: is32Bit(c)
  8824  	// result: (CMPconst x [c])
  8825  	for {
  8826  		_ = v.Args[1]
  8827  		x := v.Args[0]
  8828  		v_1 := v.Args[1]
  8829  		if v_1.Op != OpS390XMOVDconst {
  8830  			break
  8831  		}
  8832  		c := v_1.AuxInt
  8833  		if !(is32Bit(c)) {
  8834  			break
  8835  		}
  8836  		v.reset(OpS390XCMPconst)
  8837  		v.AuxInt = c
  8838  		v.AddArg(x)
  8839  		return true
  8840  	}
  8841  	// match: (CMP (MOVDconst [c]) x)
  8842  	// cond: is32Bit(c)
  8843  	// result: (InvertFlags (CMPconst x [c]))
  8844  	for {
  8845  		_ = v.Args[1]
  8846  		v_0 := v.Args[0]
  8847  		if v_0.Op != OpS390XMOVDconst {
  8848  			break
  8849  		}
  8850  		c := v_0.AuxInt
  8851  		x := v.Args[1]
  8852  		if !(is32Bit(c)) {
  8853  			break
  8854  		}
  8855  		v.reset(OpS390XInvertFlags)
  8856  		v0 := b.NewValue0(v.Pos, OpS390XCMPconst, types.TypeFlags)
  8857  		v0.AuxInt = c
  8858  		v0.AddArg(x)
  8859  		v.AddArg(v0)
  8860  		return true
  8861  	}
  8862  	return false
  8863  }
  8864  func rewriteValueS390X_OpS390XCMPU_0(v *Value) bool {
  8865  	b := v.Block
  8866  	_ = b
  8867  	// match: (CMPU x (MOVDconst [c]))
  8868  	// cond: isU32Bit(c)
  8869  	// result: (CMPUconst x [int64(int32(c))])
  8870  	for {
  8871  		_ = v.Args[1]
  8872  		x := v.Args[0]
  8873  		v_1 := v.Args[1]
  8874  		if v_1.Op != OpS390XMOVDconst {
  8875  			break
  8876  		}
  8877  		c := v_1.AuxInt
  8878  		if !(isU32Bit(c)) {
  8879  			break
  8880  		}
  8881  		v.reset(OpS390XCMPUconst)
  8882  		v.AuxInt = int64(int32(c))
  8883  		v.AddArg(x)
  8884  		return true
  8885  	}
  8886  	// match: (CMPU (MOVDconst [c]) x)
  8887  	// cond: isU32Bit(c)
  8888  	// result: (InvertFlags (CMPUconst x [int64(int32(c))]))
  8889  	for {
  8890  		_ = v.Args[1]
  8891  		v_0 := v.Args[0]
  8892  		if v_0.Op != OpS390XMOVDconst {
  8893  			break
  8894  		}
  8895  		c := v_0.AuxInt
  8896  		x := v.Args[1]
  8897  		if !(isU32Bit(c)) {
  8898  			break
  8899  		}
  8900  		v.reset(OpS390XInvertFlags)
  8901  		v0 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
  8902  		v0.AuxInt = int64(int32(c))
  8903  		v0.AddArg(x)
  8904  		v.AddArg(v0)
  8905  		return true
  8906  	}
  8907  	return false
  8908  }
  8909  func rewriteValueS390X_OpS390XCMPUconst_0(v *Value) bool {
  8910  	// match: (CMPUconst (MOVDconst [x]) [y])
  8911  	// cond: uint64(x)==uint64(y)
  8912  	// result: (FlagEQ)
  8913  	for {
  8914  		y := v.AuxInt
  8915  		v_0 := v.Args[0]
  8916  		if v_0.Op != OpS390XMOVDconst {
  8917  			break
  8918  		}
  8919  		x := v_0.AuxInt
  8920  		if !(uint64(x) == uint64(y)) {
  8921  			break
  8922  		}
  8923  		v.reset(OpS390XFlagEQ)
  8924  		return true
  8925  	}
  8926  	// match: (CMPUconst (MOVDconst [x]) [y])
  8927  	// cond: uint64(x)<uint64(y)
  8928  	// result: (FlagLT)
  8929  	for {
  8930  		y := v.AuxInt
  8931  		v_0 := v.Args[0]
  8932  		if v_0.Op != OpS390XMOVDconst {
  8933  			break
  8934  		}
  8935  		x := v_0.AuxInt
  8936  		if !(uint64(x) < uint64(y)) {
  8937  			break
  8938  		}
  8939  		v.reset(OpS390XFlagLT)
  8940  		return true
  8941  	}
  8942  	// match: (CMPUconst (MOVDconst [x]) [y])
  8943  	// cond: uint64(x)>uint64(y)
  8944  	// result: (FlagGT)
  8945  	for {
  8946  		y := v.AuxInt
  8947  		v_0 := v.Args[0]
  8948  		if v_0.Op != OpS390XMOVDconst {
  8949  			break
  8950  		}
  8951  		x := v_0.AuxInt
  8952  		if !(uint64(x) > uint64(y)) {
  8953  			break
  8954  		}
  8955  		v.reset(OpS390XFlagGT)
  8956  		return true
  8957  	}
  8958  	// match: (CMPUconst (SRDconst _ [c]) [n])
  8959  	// cond: c > 0 && c < 64 && (1<<uint(64-c)) <= uint64(n)
  8960  	// result: (FlagLT)
  8961  	for {
  8962  		n := v.AuxInt
  8963  		v_0 := v.Args[0]
  8964  		if v_0.Op != OpS390XSRDconst {
  8965  			break
  8966  		}
  8967  		c := v_0.AuxInt
  8968  		if !(c > 0 && c < 64 && (1<<uint(64-c)) <= uint64(n)) {
  8969  			break
  8970  		}
  8971  		v.reset(OpS390XFlagLT)
  8972  		return true
  8973  	}
  8974  	// match: (CMPUconst (MOVWZreg x) [c])
  8975  	// cond:
  8976  	// result: (CMPWUconst x [c])
  8977  	for {
  8978  		c := v.AuxInt
  8979  		v_0 := v.Args[0]
  8980  		if v_0.Op != OpS390XMOVWZreg {
  8981  			break
  8982  		}
  8983  		x := v_0.Args[0]
  8984  		v.reset(OpS390XCMPWUconst)
  8985  		v.AuxInt = c
  8986  		v.AddArg(x)
  8987  		return true
  8988  	}
  8989  	// match: (CMPUconst x:(MOVHreg _) [c])
  8990  	// cond:
  8991  	// result: (CMPWUconst x [c])
  8992  	for {
  8993  		c := v.AuxInt
  8994  		x := v.Args[0]
  8995  		if x.Op != OpS390XMOVHreg {
  8996  			break
  8997  		}
  8998  		v.reset(OpS390XCMPWUconst)
  8999  		v.AuxInt = c
  9000  		v.AddArg(x)
  9001  		return true
  9002  	}
  9003  	// match: (CMPUconst x:(MOVHZreg _) [c])
  9004  	// cond:
  9005  	// result: (CMPWUconst x [c])
  9006  	for {
  9007  		c := v.AuxInt
  9008  		x := v.Args[0]
  9009  		if x.Op != OpS390XMOVHZreg {
  9010  			break
  9011  		}
  9012  		v.reset(OpS390XCMPWUconst)
  9013  		v.AuxInt = c
  9014  		v.AddArg(x)
  9015  		return true
  9016  	}
  9017  	// match: (CMPUconst x:(MOVBreg _) [c])
  9018  	// cond:
  9019  	// result: (CMPWUconst x [c])
  9020  	for {
  9021  		c := v.AuxInt
  9022  		x := v.Args[0]
  9023  		if x.Op != OpS390XMOVBreg {
  9024  			break
  9025  		}
  9026  		v.reset(OpS390XCMPWUconst)
  9027  		v.AuxInt = c
  9028  		v.AddArg(x)
  9029  		return true
  9030  	}
  9031  	// match: (CMPUconst x:(MOVBZreg _) [c])
  9032  	// cond:
  9033  	// result: (CMPWUconst x [c])
  9034  	for {
  9035  		c := v.AuxInt
  9036  		x := v.Args[0]
  9037  		if x.Op != OpS390XMOVBZreg {
  9038  			break
  9039  		}
  9040  		v.reset(OpS390XCMPWUconst)
  9041  		v.AuxInt = c
  9042  		v.AddArg(x)
  9043  		return true
  9044  	}
  9045  	// match: (CMPUconst (MOVWZreg x:(ANDWconst [m] _)) [c])
  9046  	// cond: int32(m) >= 0
  9047  	// result: (CMPWUconst x [c])
  9048  	for {
  9049  		c := v.AuxInt
  9050  		v_0 := v.Args[0]
  9051  		if v_0.Op != OpS390XMOVWZreg {
  9052  			break
  9053  		}
  9054  		x := v_0.Args[0]
  9055  		if x.Op != OpS390XANDWconst {
  9056  			break
  9057  		}
  9058  		m := x.AuxInt
  9059  		if !(int32(m) >= 0) {
  9060  			break
  9061  		}
  9062  		v.reset(OpS390XCMPWUconst)
  9063  		v.AuxInt = c
  9064  		v.AddArg(x)
  9065  		return true
  9066  	}
  9067  	return false
  9068  }
  9069  func rewriteValueS390X_OpS390XCMPUconst_10(v *Value) bool {
  9070  	// match: (CMPUconst (MOVWreg x:(ANDWconst [m] _)) [c])
  9071  	// cond: int32(m) >= 0
  9072  	// result: (CMPWUconst x [c])
  9073  	for {
  9074  		c := v.AuxInt
  9075  		v_0 := v.Args[0]
  9076  		if v_0.Op != OpS390XMOVWreg {
  9077  			break
  9078  		}
  9079  		x := v_0.Args[0]
  9080  		if x.Op != OpS390XANDWconst {
  9081  			break
  9082  		}
  9083  		m := x.AuxInt
  9084  		if !(int32(m) >= 0) {
  9085  			break
  9086  		}
  9087  		v.reset(OpS390XCMPWUconst)
  9088  		v.AuxInt = c
  9089  		v.AddArg(x)
  9090  		return true
  9091  	}
  9092  	return false
  9093  }
  9094  func rewriteValueS390X_OpS390XCMPW_0(v *Value) bool {
  9095  	b := v.Block
  9096  	_ = b
  9097  	// match: (CMPW x (MOVDconst [c]))
  9098  	// cond:
  9099  	// result: (CMPWconst x [int64(int32(c))])
  9100  	for {
  9101  		_ = v.Args[1]
  9102  		x := v.Args[0]
  9103  		v_1 := v.Args[1]
  9104  		if v_1.Op != OpS390XMOVDconst {
  9105  			break
  9106  		}
  9107  		c := v_1.AuxInt
  9108  		v.reset(OpS390XCMPWconst)
  9109  		v.AuxInt = int64(int32(c))
  9110  		v.AddArg(x)
  9111  		return true
  9112  	}
  9113  	// match: (CMPW (MOVDconst [c]) x)
  9114  	// cond:
  9115  	// result: (InvertFlags (CMPWconst x [int64(int32(c))]))
  9116  	for {
  9117  		_ = v.Args[1]
  9118  		v_0 := v.Args[0]
  9119  		if v_0.Op != OpS390XMOVDconst {
  9120  			break
  9121  		}
  9122  		c := v_0.AuxInt
  9123  		x := v.Args[1]
  9124  		v.reset(OpS390XInvertFlags)
  9125  		v0 := b.NewValue0(v.Pos, OpS390XCMPWconst, types.TypeFlags)
  9126  		v0.AuxInt = int64(int32(c))
  9127  		v0.AddArg(x)
  9128  		v.AddArg(v0)
  9129  		return true
  9130  	}
  9131  	// match: (CMPW x (MOVWreg y))
  9132  	// cond:
  9133  	// result: (CMPW x y)
  9134  	for {
  9135  		_ = v.Args[1]
  9136  		x := v.Args[0]
  9137  		v_1 := v.Args[1]
  9138  		if v_1.Op != OpS390XMOVWreg {
  9139  			break
  9140  		}
  9141  		y := v_1.Args[0]
  9142  		v.reset(OpS390XCMPW)
  9143  		v.AddArg(x)
  9144  		v.AddArg(y)
  9145  		return true
  9146  	}
  9147  	// match: (CMPW x (MOVWZreg y))
  9148  	// cond:
  9149  	// result: (CMPW x y)
  9150  	for {
  9151  		_ = v.Args[1]
  9152  		x := v.Args[0]
  9153  		v_1 := v.Args[1]
  9154  		if v_1.Op != OpS390XMOVWZreg {
  9155  			break
  9156  		}
  9157  		y := v_1.Args[0]
  9158  		v.reset(OpS390XCMPW)
  9159  		v.AddArg(x)
  9160  		v.AddArg(y)
  9161  		return true
  9162  	}
  9163  	// match: (CMPW (MOVWreg x) y)
  9164  	// cond:
  9165  	// result: (CMPW x y)
  9166  	for {
  9167  		_ = v.Args[1]
  9168  		v_0 := v.Args[0]
  9169  		if v_0.Op != OpS390XMOVWreg {
  9170  			break
  9171  		}
  9172  		x := v_0.Args[0]
  9173  		y := v.Args[1]
  9174  		v.reset(OpS390XCMPW)
  9175  		v.AddArg(x)
  9176  		v.AddArg(y)
  9177  		return true
  9178  	}
  9179  	// match: (CMPW (MOVWZreg x) y)
  9180  	// cond:
  9181  	// result: (CMPW x y)
  9182  	for {
  9183  		_ = v.Args[1]
  9184  		v_0 := v.Args[0]
  9185  		if v_0.Op != OpS390XMOVWZreg {
  9186  			break
  9187  		}
  9188  		x := v_0.Args[0]
  9189  		y := v.Args[1]
  9190  		v.reset(OpS390XCMPW)
  9191  		v.AddArg(x)
  9192  		v.AddArg(y)
  9193  		return true
  9194  	}
  9195  	return false
  9196  }
  9197  func rewriteValueS390X_OpS390XCMPWU_0(v *Value) bool {
  9198  	b := v.Block
  9199  	_ = b
  9200  	// match: (CMPWU x (MOVDconst [c]))
  9201  	// cond:
  9202  	// result: (CMPWUconst x [int64(int32(c))])
  9203  	for {
  9204  		_ = v.Args[1]
  9205  		x := v.Args[0]
  9206  		v_1 := v.Args[1]
  9207  		if v_1.Op != OpS390XMOVDconst {
  9208  			break
  9209  		}
  9210  		c := v_1.AuxInt
  9211  		v.reset(OpS390XCMPWUconst)
  9212  		v.AuxInt = int64(int32(c))
  9213  		v.AddArg(x)
  9214  		return true
  9215  	}
  9216  	// match: (CMPWU (MOVDconst [c]) x)
  9217  	// cond:
  9218  	// result: (InvertFlags (CMPWUconst x [int64(int32(c))]))
  9219  	for {
  9220  		_ = v.Args[1]
  9221  		v_0 := v.Args[0]
  9222  		if v_0.Op != OpS390XMOVDconst {
  9223  			break
  9224  		}
  9225  		c := v_0.AuxInt
  9226  		x := v.Args[1]
  9227  		v.reset(OpS390XInvertFlags)
  9228  		v0 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
  9229  		v0.AuxInt = int64(int32(c))
  9230  		v0.AddArg(x)
  9231  		v.AddArg(v0)
  9232  		return true
  9233  	}
  9234  	// match: (CMPWU x (MOVWreg y))
  9235  	// cond:
  9236  	// result: (CMPWU x y)
  9237  	for {
  9238  		_ = v.Args[1]
  9239  		x := v.Args[0]
  9240  		v_1 := v.Args[1]
  9241  		if v_1.Op != OpS390XMOVWreg {
  9242  			break
  9243  		}
  9244  		y := v_1.Args[0]
  9245  		v.reset(OpS390XCMPWU)
  9246  		v.AddArg(x)
  9247  		v.AddArg(y)
  9248  		return true
  9249  	}
  9250  	// match: (CMPWU x (MOVWZreg y))
  9251  	// cond:
  9252  	// result: (CMPWU x y)
  9253  	for {
  9254  		_ = v.Args[1]
  9255  		x := v.Args[0]
  9256  		v_1 := v.Args[1]
  9257  		if v_1.Op != OpS390XMOVWZreg {
  9258  			break
  9259  		}
  9260  		y := v_1.Args[0]
  9261  		v.reset(OpS390XCMPWU)
  9262  		v.AddArg(x)
  9263  		v.AddArg(y)
  9264  		return true
  9265  	}
  9266  	// match: (CMPWU (MOVWreg x) y)
  9267  	// cond:
  9268  	// result: (CMPWU x y)
  9269  	for {
  9270  		_ = v.Args[1]
  9271  		v_0 := v.Args[0]
  9272  		if v_0.Op != OpS390XMOVWreg {
  9273  			break
  9274  		}
  9275  		x := v_0.Args[0]
  9276  		y := v.Args[1]
  9277  		v.reset(OpS390XCMPWU)
  9278  		v.AddArg(x)
  9279  		v.AddArg(y)
  9280  		return true
  9281  	}
  9282  	// match: (CMPWU (MOVWZreg x) y)
  9283  	// cond:
  9284  	// result: (CMPWU x y)
  9285  	for {
  9286  		_ = v.Args[1]
  9287  		v_0 := v.Args[0]
  9288  		if v_0.Op != OpS390XMOVWZreg {
  9289  			break
  9290  		}
  9291  		x := v_0.Args[0]
  9292  		y := v.Args[1]
  9293  		v.reset(OpS390XCMPWU)
  9294  		v.AddArg(x)
  9295  		v.AddArg(y)
  9296  		return true
  9297  	}
  9298  	return false
  9299  }
  9300  func rewriteValueS390X_OpS390XCMPWUconst_0(v *Value) bool {
  9301  	// match: (CMPWUconst (MOVDconst [x]) [y])
  9302  	// cond: uint32(x)==uint32(y)
  9303  	// result: (FlagEQ)
  9304  	for {
  9305  		y := v.AuxInt
  9306  		v_0 := v.Args[0]
  9307  		if v_0.Op != OpS390XMOVDconst {
  9308  			break
  9309  		}
  9310  		x := v_0.AuxInt
  9311  		if !(uint32(x) == uint32(y)) {
  9312  			break
  9313  		}
  9314  		v.reset(OpS390XFlagEQ)
  9315  		return true
  9316  	}
  9317  	// match: (CMPWUconst (MOVDconst [x]) [y])
  9318  	// cond: uint32(x)<uint32(y)
  9319  	// result: (FlagLT)
  9320  	for {
  9321  		y := v.AuxInt
  9322  		v_0 := v.Args[0]
  9323  		if v_0.Op != OpS390XMOVDconst {
  9324  			break
  9325  		}
  9326  		x := v_0.AuxInt
  9327  		if !(uint32(x) < uint32(y)) {
  9328  			break
  9329  		}
  9330  		v.reset(OpS390XFlagLT)
  9331  		return true
  9332  	}
  9333  	// match: (CMPWUconst (MOVDconst [x]) [y])
  9334  	// cond: uint32(x)>uint32(y)
  9335  	// result: (FlagGT)
  9336  	for {
  9337  		y := v.AuxInt
  9338  		v_0 := v.Args[0]
  9339  		if v_0.Op != OpS390XMOVDconst {
  9340  			break
  9341  		}
  9342  		x := v_0.AuxInt
  9343  		if !(uint32(x) > uint32(y)) {
  9344  			break
  9345  		}
  9346  		v.reset(OpS390XFlagGT)
  9347  		return true
  9348  	}
  9349  	// match: (CMPWUconst (MOVBZreg _) [c])
  9350  	// cond: 0xff < c
  9351  	// result: (FlagLT)
  9352  	for {
  9353  		c := v.AuxInt
  9354  		v_0 := v.Args[0]
  9355  		if v_0.Op != OpS390XMOVBZreg {
  9356  			break
  9357  		}
  9358  		if !(0xff < c) {
  9359  			break
  9360  		}
  9361  		v.reset(OpS390XFlagLT)
  9362  		return true
  9363  	}
  9364  	// match: (CMPWUconst (MOVHZreg _) [c])
  9365  	// cond: 0xffff < c
  9366  	// result: (FlagLT)
  9367  	for {
  9368  		c := v.AuxInt
  9369  		v_0 := v.Args[0]
  9370  		if v_0.Op != OpS390XMOVHZreg {
  9371  			break
  9372  		}
  9373  		if !(0xffff < c) {
  9374  			break
  9375  		}
  9376  		v.reset(OpS390XFlagLT)
  9377  		return true
  9378  	}
  9379  	// match: (CMPWUconst (SRWconst _ [c]) [n])
  9380  	// cond: c > 0 && c < 32 && (1<<uint(32-c)) <= uint32(n)
  9381  	// result: (FlagLT)
  9382  	for {
  9383  		n := v.AuxInt
  9384  		v_0 := v.Args[0]
  9385  		if v_0.Op != OpS390XSRWconst {
  9386  			break
  9387  		}
  9388  		c := v_0.AuxInt
  9389  		if !(c > 0 && c < 32 && (1<<uint(32-c)) <= uint32(n)) {
  9390  			break
  9391  		}
  9392  		v.reset(OpS390XFlagLT)
  9393  		return true
  9394  	}
  9395  	// match: (CMPWUconst (ANDWconst _ [m]) [n])
  9396  	// cond: uint32(m) < uint32(n)
  9397  	// result: (FlagLT)
  9398  	for {
  9399  		n := v.AuxInt
  9400  		v_0 := v.Args[0]
  9401  		if v_0.Op != OpS390XANDWconst {
  9402  			break
  9403  		}
  9404  		m := v_0.AuxInt
  9405  		if !(uint32(m) < uint32(n)) {
  9406  			break
  9407  		}
  9408  		v.reset(OpS390XFlagLT)
  9409  		return true
  9410  	}
  9411  	// match: (CMPWUconst (MOVWreg x) [c])
  9412  	// cond:
  9413  	// result: (CMPWUconst x [c])
  9414  	for {
  9415  		c := v.AuxInt
  9416  		v_0 := v.Args[0]
  9417  		if v_0.Op != OpS390XMOVWreg {
  9418  			break
  9419  		}
  9420  		x := v_0.Args[0]
  9421  		v.reset(OpS390XCMPWUconst)
  9422  		v.AuxInt = c
  9423  		v.AddArg(x)
  9424  		return true
  9425  	}
  9426  	// match: (CMPWUconst (MOVWZreg x) [c])
  9427  	// cond:
  9428  	// result: (CMPWUconst x [c])
  9429  	for {
  9430  		c := v.AuxInt
  9431  		v_0 := v.Args[0]
  9432  		if v_0.Op != OpS390XMOVWZreg {
  9433  			break
  9434  		}
  9435  		x := v_0.Args[0]
  9436  		v.reset(OpS390XCMPWUconst)
  9437  		v.AuxInt = c
  9438  		v.AddArg(x)
  9439  		return true
  9440  	}
  9441  	return false
  9442  }
  9443  func rewriteValueS390X_OpS390XCMPWconst_0(v *Value) bool {
  9444  	// match: (CMPWconst (MOVDconst [x]) [y])
  9445  	// cond: int32(x)==int32(y)
  9446  	// result: (FlagEQ)
  9447  	for {
  9448  		y := v.AuxInt
  9449  		v_0 := v.Args[0]
  9450  		if v_0.Op != OpS390XMOVDconst {
  9451  			break
  9452  		}
  9453  		x := v_0.AuxInt
  9454  		if !(int32(x) == int32(y)) {
  9455  			break
  9456  		}
  9457  		v.reset(OpS390XFlagEQ)
  9458  		return true
  9459  	}
  9460  	// match: (CMPWconst (MOVDconst [x]) [y])
  9461  	// cond: int32(x)<int32(y)
  9462  	// result: (FlagLT)
  9463  	for {
  9464  		y := v.AuxInt
  9465  		v_0 := v.Args[0]
  9466  		if v_0.Op != OpS390XMOVDconst {
  9467  			break
  9468  		}
  9469  		x := v_0.AuxInt
  9470  		if !(int32(x) < int32(y)) {
  9471  			break
  9472  		}
  9473  		v.reset(OpS390XFlagLT)
  9474  		return true
  9475  	}
  9476  	// match: (CMPWconst (MOVDconst [x]) [y])
  9477  	// cond: int32(x)>int32(y)
  9478  	// result: (FlagGT)
  9479  	for {
  9480  		y := v.AuxInt
  9481  		v_0 := v.Args[0]
  9482  		if v_0.Op != OpS390XMOVDconst {
  9483  			break
  9484  		}
  9485  		x := v_0.AuxInt
  9486  		if !(int32(x) > int32(y)) {
  9487  			break
  9488  		}
  9489  		v.reset(OpS390XFlagGT)
  9490  		return true
  9491  	}
  9492  	// match: (CMPWconst (MOVBZreg _) [c])
  9493  	// cond: 0xff < c
  9494  	// result: (FlagLT)
  9495  	for {
  9496  		c := v.AuxInt
  9497  		v_0 := v.Args[0]
  9498  		if v_0.Op != OpS390XMOVBZreg {
  9499  			break
  9500  		}
  9501  		if !(0xff < c) {
  9502  			break
  9503  		}
  9504  		v.reset(OpS390XFlagLT)
  9505  		return true
  9506  	}
  9507  	// match: (CMPWconst (MOVHZreg _) [c])
  9508  	// cond: 0xffff < c
  9509  	// result: (FlagLT)
  9510  	for {
  9511  		c := v.AuxInt
  9512  		v_0 := v.Args[0]
  9513  		if v_0.Op != OpS390XMOVHZreg {
  9514  			break
  9515  		}
  9516  		if !(0xffff < c) {
  9517  			break
  9518  		}
  9519  		v.reset(OpS390XFlagLT)
  9520  		return true
  9521  	}
  9522  	// match: (CMPWconst (SRWconst _ [c]) [n])
  9523  	// cond: c > 0 && n < 0
  9524  	// result: (FlagGT)
  9525  	for {
  9526  		n := v.AuxInt
  9527  		v_0 := v.Args[0]
  9528  		if v_0.Op != OpS390XSRWconst {
  9529  			break
  9530  		}
  9531  		c := v_0.AuxInt
  9532  		if !(c > 0 && n < 0) {
  9533  			break
  9534  		}
  9535  		v.reset(OpS390XFlagGT)
  9536  		return true
  9537  	}
  9538  	// match: (CMPWconst (ANDWconst _ [m]) [n])
  9539  	// cond: int32(m) >= 0 && int32(m) < int32(n)
  9540  	// result: (FlagLT)
  9541  	for {
  9542  		n := v.AuxInt
  9543  		v_0 := v.Args[0]
  9544  		if v_0.Op != OpS390XANDWconst {
  9545  			break
  9546  		}
  9547  		m := v_0.AuxInt
  9548  		if !(int32(m) >= 0 && int32(m) < int32(n)) {
  9549  			break
  9550  		}
  9551  		v.reset(OpS390XFlagLT)
  9552  		return true
  9553  	}
  9554  	// match: (CMPWconst x:(SRWconst _ [c]) [n])
  9555  	// cond: c > 0 && n >= 0
  9556  	// result: (CMPWUconst x [n])
  9557  	for {
  9558  		n := v.AuxInt
  9559  		x := v.Args[0]
  9560  		if x.Op != OpS390XSRWconst {
  9561  			break
  9562  		}
  9563  		c := x.AuxInt
  9564  		if !(c > 0 && n >= 0) {
  9565  			break
  9566  		}
  9567  		v.reset(OpS390XCMPWUconst)
  9568  		v.AuxInt = n
  9569  		v.AddArg(x)
  9570  		return true
  9571  	}
  9572  	// match: (CMPWconst (MOVWreg x) [c])
  9573  	// cond:
  9574  	// result: (CMPWconst x [c])
  9575  	for {
  9576  		c := v.AuxInt
  9577  		v_0 := v.Args[0]
  9578  		if v_0.Op != OpS390XMOVWreg {
  9579  			break
  9580  		}
  9581  		x := v_0.Args[0]
  9582  		v.reset(OpS390XCMPWconst)
  9583  		v.AuxInt = c
  9584  		v.AddArg(x)
  9585  		return true
  9586  	}
  9587  	// match: (CMPWconst (MOVWZreg x) [c])
  9588  	// cond:
  9589  	// result: (CMPWconst x [c])
  9590  	for {
  9591  		c := v.AuxInt
  9592  		v_0 := v.Args[0]
  9593  		if v_0.Op != OpS390XMOVWZreg {
  9594  			break
  9595  		}
  9596  		x := v_0.Args[0]
  9597  		v.reset(OpS390XCMPWconst)
  9598  		v.AuxInt = c
  9599  		v.AddArg(x)
  9600  		return true
  9601  	}
  9602  	return false
  9603  }
  9604  func rewriteValueS390X_OpS390XCMPconst_0(v *Value) bool {
  9605  	// match: (CMPconst (MOVDconst [x]) [y])
  9606  	// cond: x==y
  9607  	// result: (FlagEQ)
  9608  	for {
  9609  		y := v.AuxInt
  9610  		v_0 := v.Args[0]
  9611  		if v_0.Op != OpS390XMOVDconst {
  9612  			break
  9613  		}
  9614  		x := v_0.AuxInt
  9615  		if !(x == y) {
  9616  			break
  9617  		}
  9618  		v.reset(OpS390XFlagEQ)
  9619  		return true
  9620  	}
  9621  	// match: (CMPconst (MOVDconst [x]) [y])
  9622  	// cond: x<y
  9623  	// result: (FlagLT)
  9624  	for {
  9625  		y := v.AuxInt
  9626  		v_0 := v.Args[0]
  9627  		if v_0.Op != OpS390XMOVDconst {
  9628  			break
  9629  		}
  9630  		x := v_0.AuxInt
  9631  		if !(x < y) {
  9632  			break
  9633  		}
  9634  		v.reset(OpS390XFlagLT)
  9635  		return true
  9636  	}
  9637  	// match: (CMPconst (MOVDconst [x]) [y])
  9638  	// cond: x>y
  9639  	// result: (FlagGT)
  9640  	for {
  9641  		y := v.AuxInt
  9642  		v_0 := v.Args[0]
  9643  		if v_0.Op != OpS390XMOVDconst {
  9644  			break
  9645  		}
  9646  		x := v_0.AuxInt
  9647  		if !(x > y) {
  9648  			break
  9649  		}
  9650  		v.reset(OpS390XFlagGT)
  9651  		return true
  9652  	}
  9653  	// match: (CMPconst (SRDconst _ [c]) [n])
  9654  	// cond: c > 0 && n < 0
  9655  	// result: (FlagGT)
  9656  	for {
  9657  		n := v.AuxInt
  9658  		v_0 := v.Args[0]
  9659  		if v_0.Op != OpS390XSRDconst {
  9660  			break
  9661  		}
  9662  		c := v_0.AuxInt
  9663  		if !(c > 0 && n < 0) {
  9664  			break
  9665  		}
  9666  		v.reset(OpS390XFlagGT)
  9667  		return true
  9668  	}
  9669  	// match: (CMPconst (MOVWreg x) [c])
  9670  	// cond:
  9671  	// result: (CMPWconst x [c])
  9672  	for {
  9673  		c := v.AuxInt
  9674  		v_0 := v.Args[0]
  9675  		if v_0.Op != OpS390XMOVWreg {
  9676  			break
  9677  		}
  9678  		x := v_0.Args[0]
  9679  		v.reset(OpS390XCMPWconst)
  9680  		v.AuxInt = c
  9681  		v.AddArg(x)
  9682  		return true
  9683  	}
  9684  	// match: (CMPconst x:(MOVHreg _) [c])
  9685  	// cond:
  9686  	// result: (CMPWconst x [c])
  9687  	for {
  9688  		c := v.AuxInt
  9689  		x := v.Args[0]
  9690  		if x.Op != OpS390XMOVHreg {
  9691  			break
  9692  		}
  9693  		v.reset(OpS390XCMPWconst)
  9694  		v.AuxInt = c
  9695  		v.AddArg(x)
  9696  		return true
  9697  	}
  9698  	// match: (CMPconst x:(MOVHZreg _) [c])
  9699  	// cond:
  9700  	// result: (CMPWconst x [c])
  9701  	for {
  9702  		c := v.AuxInt
  9703  		x := v.Args[0]
  9704  		if x.Op != OpS390XMOVHZreg {
  9705  			break
  9706  		}
  9707  		v.reset(OpS390XCMPWconst)
  9708  		v.AuxInt = c
  9709  		v.AddArg(x)
  9710  		return true
  9711  	}
  9712  	// match: (CMPconst x:(MOVBreg _) [c])
  9713  	// cond:
  9714  	// result: (CMPWconst x [c])
  9715  	for {
  9716  		c := v.AuxInt
  9717  		x := v.Args[0]
  9718  		if x.Op != OpS390XMOVBreg {
  9719  			break
  9720  		}
  9721  		v.reset(OpS390XCMPWconst)
  9722  		v.AuxInt = c
  9723  		v.AddArg(x)
  9724  		return true
  9725  	}
  9726  	// match: (CMPconst x:(MOVBZreg _) [c])
  9727  	// cond:
  9728  	// result: (CMPWconst x [c])
  9729  	for {
  9730  		c := v.AuxInt
  9731  		x := v.Args[0]
  9732  		if x.Op != OpS390XMOVBZreg {
  9733  			break
  9734  		}
  9735  		v.reset(OpS390XCMPWconst)
  9736  		v.AuxInt = c
  9737  		v.AddArg(x)
  9738  		return true
  9739  	}
  9740  	// match: (CMPconst (MOVWZreg x:(ANDWconst [m] _)) [c])
  9741  	// cond: int32(m) >= 0 && c >= 0
  9742  	// result: (CMPWUconst x [c])
  9743  	for {
  9744  		c := v.AuxInt
  9745  		v_0 := v.Args[0]
  9746  		if v_0.Op != OpS390XMOVWZreg {
  9747  			break
  9748  		}
  9749  		x := v_0.Args[0]
  9750  		if x.Op != OpS390XANDWconst {
  9751  			break
  9752  		}
  9753  		m := x.AuxInt
  9754  		if !(int32(m) >= 0 && c >= 0) {
  9755  			break
  9756  		}
  9757  		v.reset(OpS390XCMPWUconst)
  9758  		v.AuxInt = c
  9759  		v.AddArg(x)
  9760  		return true
  9761  	}
  9762  	return false
  9763  }
  9764  func rewriteValueS390X_OpS390XCMPconst_10(v *Value) bool {
  9765  	// match: (CMPconst (MOVWreg x:(ANDWconst [m] _)) [c])
  9766  	// cond: int32(m) >= 0 && c >= 0
  9767  	// result: (CMPWUconst x [c])
  9768  	for {
  9769  		c := v.AuxInt
  9770  		v_0 := v.Args[0]
  9771  		if v_0.Op != OpS390XMOVWreg {
  9772  			break
  9773  		}
  9774  		x := v_0.Args[0]
  9775  		if x.Op != OpS390XANDWconst {
  9776  			break
  9777  		}
  9778  		m := x.AuxInt
  9779  		if !(int32(m) >= 0 && c >= 0) {
  9780  			break
  9781  		}
  9782  		v.reset(OpS390XCMPWUconst)
  9783  		v.AuxInt = c
  9784  		v.AddArg(x)
  9785  		return true
  9786  	}
  9787  	// match: (CMPconst x:(SRDconst _ [c]) [n])
  9788  	// cond: c > 0 && n >= 0
  9789  	// result: (CMPUconst x [n])
  9790  	for {
  9791  		n := v.AuxInt
  9792  		x := v.Args[0]
  9793  		if x.Op != OpS390XSRDconst {
  9794  			break
  9795  		}
  9796  		c := x.AuxInt
  9797  		if !(c > 0 && n >= 0) {
  9798  			break
  9799  		}
  9800  		v.reset(OpS390XCMPUconst)
  9801  		v.AuxInt = n
  9802  		v.AddArg(x)
  9803  		return true
  9804  	}
  9805  	return false
  9806  }
  9807  func rewriteValueS390X_OpS390XCPSDR_0(v *Value) bool {
  9808  	// match: (CPSDR y (FMOVDconst [c]))
  9809  	// cond: c & -1<<63 == 0
  9810  	// result: (LPDFR y)
  9811  	for {
  9812  		_ = v.Args[1]
  9813  		y := v.Args[0]
  9814  		v_1 := v.Args[1]
  9815  		if v_1.Op != OpS390XFMOVDconst {
  9816  			break
  9817  		}
  9818  		c := v_1.AuxInt
  9819  		if !(c&-1<<63 == 0) {
  9820  			break
  9821  		}
  9822  		v.reset(OpS390XLPDFR)
  9823  		v.AddArg(y)
  9824  		return true
  9825  	}
  9826  	// match: (CPSDR y (FMOVDconst [c]))
  9827  	// cond: c & -1<<63 != 0
  9828  	// result: (LNDFR y)
  9829  	for {
  9830  		_ = v.Args[1]
  9831  		y := v.Args[0]
  9832  		v_1 := v.Args[1]
  9833  		if v_1.Op != OpS390XFMOVDconst {
  9834  			break
  9835  		}
  9836  		c := v_1.AuxInt
  9837  		if !(c&-1<<63 != 0) {
  9838  			break
  9839  		}
  9840  		v.reset(OpS390XLNDFR)
  9841  		v.AddArg(y)
  9842  		return true
  9843  	}
  9844  	return false
  9845  }
  9846  func rewriteValueS390X_OpS390XFADD_0(v *Value) bool {
  9847  	// match: (FADD (FMUL y z) x)
  9848  	// cond:
  9849  	// result: (FMADD x y z)
  9850  	for {
  9851  		_ = v.Args[1]
  9852  		v_0 := v.Args[0]
  9853  		if v_0.Op != OpS390XFMUL {
  9854  			break
  9855  		}
  9856  		_ = v_0.Args[1]
  9857  		y := v_0.Args[0]
  9858  		z := v_0.Args[1]
  9859  		x := v.Args[1]
  9860  		v.reset(OpS390XFMADD)
  9861  		v.AddArg(x)
  9862  		v.AddArg(y)
  9863  		v.AddArg(z)
  9864  		return true
  9865  	}
  9866  	// match: (FADD x (FMUL y z))
  9867  	// cond:
  9868  	// result: (FMADD x y z)
  9869  	for {
  9870  		_ = v.Args[1]
  9871  		x := v.Args[0]
  9872  		v_1 := v.Args[1]
  9873  		if v_1.Op != OpS390XFMUL {
  9874  			break
  9875  		}
  9876  		_ = v_1.Args[1]
  9877  		y := v_1.Args[0]
  9878  		z := v_1.Args[1]
  9879  		v.reset(OpS390XFMADD)
  9880  		v.AddArg(x)
  9881  		v.AddArg(y)
  9882  		v.AddArg(z)
  9883  		return true
  9884  	}
  9885  	return false
  9886  }
  9887  func rewriteValueS390X_OpS390XFADDS_0(v *Value) bool {
  9888  	// match: (FADDS (FMULS y z) x)
  9889  	// cond:
  9890  	// result: (FMADDS x y z)
  9891  	for {
  9892  		_ = v.Args[1]
  9893  		v_0 := v.Args[0]
  9894  		if v_0.Op != OpS390XFMULS {
  9895  			break
  9896  		}
  9897  		_ = v_0.Args[1]
  9898  		y := v_0.Args[0]
  9899  		z := v_0.Args[1]
  9900  		x := v.Args[1]
  9901  		v.reset(OpS390XFMADDS)
  9902  		v.AddArg(x)
  9903  		v.AddArg(y)
  9904  		v.AddArg(z)
  9905  		return true
  9906  	}
  9907  	// match: (FADDS x (FMULS y z))
  9908  	// cond:
  9909  	// result: (FMADDS x y z)
  9910  	for {
  9911  		_ = v.Args[1]
  9912  		x := v.Args[0]
  9913  		v_1 := v.Args[1]
  9914  		if v_1.Op != OpS390XFMULS {
  9915  			break
  9916  		}
  9917  		_ = v_1.Args[1]
  9918  		y := v_1.Args[0]
  9919  		z := v_1.Args[1]
  9920  		v.reset(OpS390XFMADDS)
  9921  		v.AddArg(x)
  9922  		v.AddArg(y)
  9923  		v.AddArg(z)
  9924  		return true
  9925  	}
  9926  	return false
  9927  }
  9928  func rewriteValueS390X_OpS390XFMOVDload_0(v *Value) bool {
  9929  	// match: (FMOVDload [off] {sym} ptr1 (MOVDstore [off] {sym} ptr2 x _))
  9930  	// cond: isSamePtr(ptr1, ptr2)
  9931  	// result: (LDGR x)
  9932  	for {
  9933  		off := v.AuxInt
  9934  		sym := v.Aux
  9935  		_ = v.Args[1]
  9936  		ptr1 := v.Args[0]
  9937  		v_1 := v.Args[1]
  9938  		if v_1.Op != OpS390XMOVDstore {
  9939  			break
  9940  		}
  9941  		if v_1.AuxInt != off {
  9942  			break
  9943  		}
  9944  		if v_1.Aux != sym {
  9945  			break
  9946  		}
  9947  		_ = v_1.Args[2]
  9948  		ptr2 := v_1.Args[0]
  9949  		x := v_1.Args[1]
  9950  		if !(isSamePtr(ptr1, ptr2)) {
  9951  			break
  9952  		}
  9953  		v.reset(OpS390XLDGR)
  9954  		v.AddArg(x)
  9955  		return true
  9956  	}
  9957  	// match: (FMOVDload [off] {sym} ptr1 (FMOVDstore [off] {sym} ptr2 x _))
  9958  	// cond: isSamePtr(ptr1, ptr2)
  9959  	// result: x
  9960  	for {
  9961  		off := v.AuxInt
  9962  		sym := v.Aux
  9963  		_ = v.Args[1]
  9964  		ptr1 := v.Args[0]
  9965  		v_1 := v.Args[1]
  9966  		if v_1.Op != OpS390XFMOVDstore {
  9967  			break
  9968  		}
  9969  		if v_1.AuxInt != off {
  9970  			break
  9971  		}
  9972  		if v_1.Aux != sym {
  9973  			break
  9974  		}
  9975  		_ = v_1.Args[2]
  9976  		ptr2 := v_1.Args[0]
  9977  		x := v_1.Args[1]
  9978  		if !(isSamePtr(ptr1, ptr2)) {
  9979  			break
  9980  		}
  9981  		v.reset(OpCopy)
  9982  		v.Type = x.Type
  9983  		v.AddArg(x)
  9984  		return true
  9985  	}
  9986  	// match: (FMOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
  9987  	// cond: is20Bit(off1+off2)
  9988  	// result: (FMOVDload [off1+off2] {sym} ptr mem)
  9989  	for {
  9990  		off1 := v.AuxInt
  9991  		sym := v.Aux
  9992  		_ = v.Args[1]
  9993  		v_0 := v.Args[0]
  9994  		if v_0.Op != OpS390XADDconst {
  9995  			break
  9996  		}
  9997  		off2 := v_0.AuxInt
  9998  		ptr := v_0.Args[0]
  9999  		mem := v.Args[1]
 10000  		if !(is20Bit(off1 + off2)) {
 10001  			break
 10002  		}
 10003  		v.reset(OpS390XFMOVDload)
 10004  		v.AuxInt = off1 + off2
 10005  		v.Aux = sym
 10006  		v.AddArg(ptr)
 10007  		v.AddArg(mem)
 10008  		return true
 10009  	}
 10010  	// match: (FMOVDload [off1] {sym1} (MOVDaddr [off2] {sym2} base) mem)
 10011  	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 10012  	// result: (FMOVDload [off1+off2] {mergeSym(sym1,sym2)} base mem)
 10013  	for {
 10014  		off1 := v.AuxInt
 10015  		sym1 := v.Aux
 10016  		_ = v.Args[1]
 10017  		v_0 := v.Args[0]
 10018  		if v_0.Op != OpS390XMOVDaddr {
 10019  			break
 10020  		}
 10021  		off2 := v_0.AuxInt
 10022  		sym2 := v_0.Aux
 10023  		base := v_0.Args[0]
 10024  		mem := v.Args[1]
 10025  		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 10026  			break
 10027  		}
 10028  		v.reset(OpS390XFMOVDload)
 10029  		v.AuxInt = off1 + off2
 10030  		v.Aux = mergeSym(sym1, sym2)
 10031  		v.AddArg(base)
 10032  		v.AddArg(mem)
 10033  		return true
 10034  	}
 10035  	// match: (FMOVDload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
 10036  	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 10037  	// result: (FMOVDloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
 10038  	for {
 10039  		off1 := v.AuxInt
 10040  		sym1 := v.Aux
 10041  		_ = v.Args[1]
 10042  		v_0 := v.Args[0]
 10043  		if v_0.Op != OpS390XMOVDaddridx {
 10044  			break
 10045  		}
 10046  		off2 := v_0.AuxInt
 10047  		sym2 := v_0.Aux
 10048  		_ = v_0.Args[1]
 10049  		ptr := v_0.Args[0]
 10050  		idx := v_0.Args[1]
 10051  		mem := v.Args[1]
 10052  		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 10053  			break
 10054  		}
 10055  		v.reset(OpS390XFMOVDloadidx)
 10056  		v.AuxInt = off1 + off2
 10057  		v.Aux = mergeSym(sym1, sym2)
 10058  		v.AddArg(ptr)
 10059  		v.AddArg(idx)
 10060  		v.AddArg(mem)
 10061  		return true
 10062  	}
 10063  	// match: (FMOVDload [off] {sym} (ADD ptr idx) mem)
 10064  	// cond: ptr.Op != OpSB
 10065  	// result: (FMOVDloadidx [off] {sym} ptr idx mem)
 10066  	for {
 10067  		off := v.AuxInt
 10068  		sym := v.Aux
 10069  		_ = v.Args[1]
 10070  		v_0 := v.Args[0]
 10071  		if v_0.Op != OpS390XADD {
 10072  			break
 10073  		}
 10074  		_ = v_0.Args[1]
 10075  		ptr := v_0.Args[0]
 10076  		idx := v_0.Args[1]
 10077  		mem := v.Args[1]
 10078  		if !(ptr.Op != OpSB) {
 10079  			break
 10080  		}
 10081  		v.reset(OpS390XFMOVDloadidx)
 10082  		v.AuxInt = off
 10083  		v.Aux = sym
 10084  		v.AddArg(ptr)
 10085  		v.AddArg(idx)
 10086  		v.AddArg(mem)
 10087  		return true
 10088  	}
 10089  	return false
 10090  }
 10091  func rewriteValueS390X_OpS390XFMOVDloadidx_0(v *Value) bool {
 10092  	// match: (FMOVDloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 10093  	// cond: is20Bit(c+d)
 10094  	// result: (FMOVDloadidx [c+d] {sym} ptr idx mem)
 10095  	for {
 10096  		c := v.AuxInt
 10097  		sym := v.Aux
 10098  		_ = v.Args[2]
 10099  		v_0 := v.Args[0]
 10100  		if v_0.Op != OpS390XADDconst {
 10101  			break
 10102  		}
 10103  		d := v_0.AuxInt
 10104  		ptr := v_0.Args[0]
 10105  		idx := v.Args[1]
 10106  		mem := v.Args[2]
 10107  		if !(is20Bit(c + d)) {
 10108  			break
 10109  		}
 10110  		v.reset(OpS390XFMOVDloadidx)
 10111  		v.AuxInt = c + d
 10112  		v.Aux = sym
 10113  		v.AddArg(ptr)
 10114  		v.AddArg(idx)
 10115  		v.AddArg(mem)
 10116  		return true
 10117  	}
 10118  	// match: (FMOVDloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
 10119  	// cond: is20Bit(c+d)
 10120  	// result: (FMOVDloadidx [c+d] {sym} ptr idx mem)
 10121  	for {
 10122  		c := v.AuxInt
 10123  		sym := v.Aux
 10124  		_ = v.Args[2]
 10125  		ptr := v.Args[0]
 10126  		v_1 := v.Args[1]
 10127  		if v_1.Op != OpS390XADDconst {
 10128  			break
 10129  		}
 10130  		d := v_1.AuxInt
 10131  		idx := v_1.Args[0]
 10132  		mem := v.Args[2]
 10133  		if !(is20Bit(c + d)) {
 10134  			break
 10135  		}
 10136  		v.reset(OpS390XFMOVDloadidx)
 10137  		v.AuxInt = c + d
 10138  		v.Aux = sym
 10139  		v.AddArg(ptr)
 10140  		v.AddArg(idx)
 10141  		v.AddArg(mem)
 10142  		return true
 10143  	}
 10144  	return false
 10145  }
 10146  func rewriteValueS390X_OpS390XFMOVDstore_0(v *Value) bool {
 10147  	// match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 10148  	// cond: is20Bit(off1+off2)
 10149  	// result: (FMOVDstore [off1+off2] {sym} ptr val mem)
 10150  	for {
 10151  		off1 := v.AuxInt
 10152  		sym := v.Aux
 10153  		_ = v.Args[2]
 10154  		v_0 := v.Args[0]
 10155  		if v_0.Op != OpS390XADDconst {
 10156  			break
 10157  		}
 10158  		off2 := v_0.AuxInt
 10159  		ptr := v_0.Args[0]
 10160  		val := v.Args[1]
 10161  		mem := v.Args[2]
 10162  		if !(is20Bit(off1 + off2)) {
 10163  			break
 10164  		}
 10165  		v.reset(OpS390XFMOVDstore)
 10166  		v.AuxInt = off1 + off2
 10167  		v.Aux = sym
 10168  		v.AddArg(ptr)
 10169  		v.AddArg(val)
 10170  		v.AddArg(mem)
 10171  		return true
 10172  	}
 10173  	// match: (FMOVDstore [off1] {sym1} (MOVDaddr [off2] {sym2} base) val mem)
 10174  	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 10175  	// result: (FMOVDstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
 10176  	for {
 10177  		off1 := v.AuxInt
 10178  		sym1 := v.Aux
 10179  		_ = v.Args[2]
 10180  		v_0 := v.Args[0]
 10181  		if v_0.Op != OpS390XMOVDaddr {
 10182  			break
 10183  		}
 10184  		off2 := v_0.AuxInt
 10185  		sym2 := v_0.Aux
 10186  		base := v_0.Args[0]
 10187  		val := v.Args[1]
 10188  		mem := v.Args[2]
 10189  		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 10190  			break
 10191  		}
 10192  		v.reset(OpS390XFMOVDstore)
 10193  		v.AuxInt = off1 + off2
 10194  		v.Aux = mergeSym(sym1, sym2)
 10195  		v.AddArg(base)
 10196  		v.AddArg(val)
 10197  		v.AddArg(mem)
 10198  		return true
 10199  	}
 10200  	// match: (FMOVDstore [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) val mem)
 10201  	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 10202  	// result: (FMOVDstoreidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
 10203  	for {
 10204  		off1 := v.AuxInt
 10205  		sym1 := v.Aux
 10206  		_ = v.Args[2]
 10207  		v_0 := v.Args[0]
 10208  		if v_0.Op != OpS390XMOVDaddridx {
 10209  			break
 10210  		}
 10211  		off2 := v_0.AuxInt
 10212  		sym2 := v_0.Aux
 10213  		_ = v_0.Args[1]
 10214  		ptr := v_0.Args[0]
 10215  		idx := v_0.Args[1]
 10216  		val := v.Args[1]
 10217  		mem := v.Args[2]
 10218  		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 10219  			break
 10220  		}
 10221  		v.reset(OpS390XFMOVDstoreidx)
 10222  		v.AuxInt = off1 + off2
 10223  		v.Aux = mergeSym(sym1, sym2)
 10224  		v.AddArg(ptr)
 10225  		v.AddArg(idx)
 10226  		v.AddArg(val)
 10227  		v.AddArg(mem)
 10228  		return true
 10229  	}
 10230  	// match: (FMOVDstore [off] {sym} (ADD ptr idx) val mem)
 10231  	// cond: ptr.Op != OpSB
 10232  	// result: (FMOVDstoreidx [off] {sym} ptr idx val mem)
 10233  	for {
 10234  		off := v.AuxInt
 10235  		sym := v.Aux
 10236  		_ = v.Args[2]
 10237  		v_0 := v.Args[0]
 10238  		if v_0.Op != OpS390XADD {
 10239  			break
 10240  		}
 10241  		_ = v_0.Args[1]
 10242  		ptr := v_0.Args[0]
 10243  		idx := v_0.Args[1]
 10244  		val := v.Args[1]
 10245  		mem := v.Args[2]
 10246  		if !(ptr.Op != OpSB) {
 10247  			break
 10248  		}
 10249  		v.reset(OpS390XFMOVDstoreidx)
 10250  		v.AuxInt = off
 10251  		v.Aux = sym
 10252  		v.AddArg(ptr)
 10253  		v.AddArg(idx)
 10254  		v.AddArg(val)
 10255  		v.AddArg(mem)
 10256  		return true
 10257  	}
 10258  	return false
 10259  }
 10260  func rewriteValueS390X_OpS390XFMOVDstoreidx_0(v *Value) bool {
 10261  	// match: (FMOVDstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
 10262  	// cond: is20Bit(c+d)
 10263  	// result: (FMOVDstoreidx [c+d] {sym} ptr idx val mem)
 10264  	for {
 10265  		c := v.AuxInt
 10266  		sym := v.Aux
 10267  		_ = v.Args[3]
 10268  		v_0 := v.Args[0]
 10269  		if v_0.Op != OpS390XADDconst {
 10270  			break
 10271  		}
 10272  		d := v_0.AuxInt
 10273  		ptr := v_0.Args[0]
 10274  		idx := v.Args[1]
 10275  		val := v.Args[2]
 10276  		mem := v.Args[3]
 10277  		if !(is20Bit(c + d)) {
 10278  			break
 10279  		}
 10280  		v.reset(OpS390XFMOVDstoreidx)
 10281  		v.AuxInt = c + d
 10282  		v.Aux = sym
 10283  		v.AddArg(ptr)
 10284  		v.AddArg(idx)
 10285  		v.AddArg(val)
 10286  		v.AddArg(mem)
 10287  		return true
 10288  	}
 10289  	// match: (FMOVDstoreidx [c] {sym} ptr (ADDconst [d] idx) val mem)
 10290  	// cond: is20Bit(c+d)
 10291  	// result: (FMOVDstoreidx [c+d] {sym} ptr idx val mem)
 10292  	for {
 10293  		c := v.AuxInt
 10294  		sym := v.Aux
 10295  		_ = v.Args[3]
 10296  		ptr := v.Args[0]
 10297  		v_1 := v.Args[1]
 10298  		if v_1.Op != OpS390XADDconst {
 10299  			break
 10300  		}
 10301  		d := v_1.AuxInt
 10302  		idx := v_1.Args[0]
 10303  		val := v.Args[2]
 10304  		mem := v.Args[3]
 10305  		if !(is20Bit(c + d)) {
 10306  			break
 10307  		}
 10308  		v.reset(OpS390XFMOVDstoreidx)
 10309  		v.AuxInt = c + d
 10310  		v.Aux = sym
 10311  		v.AddArg(ptr)
 10312  		v.AddArg(idx)
 10313  		v.AddArg(val)
 10314  		v.AddArg(mem)
 10315  		return true
 10316  	}
 10317  	return false
 10318  }
 10319  func rewriteValueS390X_OpS390XFMOVSload_0(v *Value) bool {
 10320  	// match: (FMOVSload [off] {sym} ptr1 (FMOVSstore [off] {sym} ptr2 x _))
 10321  	// cond: isSamePtr(ptr1, ptr2)
 10322  	// result: x
 10323  	for {
 10324  		off := v.AuxInt
 10325  		sym := v.Aux
 10326  		_ = v.Args[1]
 10327  		ptr1 := v.Args[0]
 10328  		v_1 := v.Args[1]
 10329  		if v_1.Op != OpS390XFMOVSstore {
 10330  			break
 10331  		}
 10332  		if v_1.AuxInt != off {
 10333  			break
 10334  		}
 10335  		if v_1.Aux != sym {
 10336  			break
 10337  		}
 10338  		_ = v_1.Args[2]
 10339  		ptr2 := v_1.Args[0]
 10340  		x := v_1.Args[1]
 10341  		if !(isSamePtr(ptr1, ptr2)) {
 10342  			break
 10343  		}
 10344  		v.reset(OpCopy)
 10345  		v.Type = x.Type
 10346  		v.AddArg(x)
 10347  		return true
 10348  	}
 10349  	// match: (FMOVSload [off1] {sym} (ADDconst [off2] ptr) mem)
 10350  	// cond: is20Bit(off1+off2)
 10351  	// result: (FMOVSload [off1+off2] {sym} ptr mem)
 10352  	for {
 10353  		off1 := v.AuxInt
 10354  		sym := v.Aux
 10355  		_ = v.Args[1]
 10356  		v_0 := v.Args[0]
 10357  		if v_0.Op != OpS390XADDconst {
 10358  			break
 10359  		}
 10360  		off2 := v_0.AuxInt
 10361  		ptr := v_0.Args[0]
 10362  		mem := v.Args[1]
 10363  		if !(is20Bit(off1 + off2)) {
 10364  			break
 10365  		}
 10366  		v.reset(OpS390XFMOVSload)
 10367  		v.AuxInt = off1 + off2
 10368  		v.Aux = sym
 10369  		v.AddArg(ptr)
 10370  		v.AddArg(mem)
 10371  		return true
 10372  	}
 10373  	// match: (FMOVSload [off1] {sym1} (MOVDaddr [off2] {sym2} base) mem)
 10374  	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 10375  	// result: (FMOVSload [off1+off2] {mergeSym(sym1,sym2)} base mem)
 10376  	for {
 10377  		off1 := v.AuxInt
 10378  		sym1 := v.Aux
 10379  		_ = v.Args[1]
 10380  		v_0 := v.Args[0]
 10381  		if v_0.Op != OpS390XMOVDaddr {
 10382  			break
 10383  		}
 10384  		off2 := v_0.AuxInt
 10385  		sym2 := v_0.Aux
 10386  		base := v_0.Args[0]
 10387  		mem := v.Args[1]
 10388  		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 10389  			break
 10390  		}
 10391  		v.reset(OpS390XFMOVSload)
 10392  		v.AuxInt = off1 + off2
 10393  		v.Aux = mergeSym(sym1, sym2)
 10394  		v.AddArg(base)
 10395  		v.AddArg(mem)
 10396  		return true
 10397  	}
 10398  	// match: (FMOVSload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
 10399  	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 10400  	// result: (FMOVSloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
 10401  	for {
 10402  		off1 := v.AuxInt
 10403  		sym1 := v.Aux
 10404  		_ = v.Args[1]
 10405  		v_0 := v.Args[0]
 10406  		if v_0.Op != OpS390XMOVDaddridx {
 10407  			break
 10408  		}
 10409  		off2 := v_0.AuxInt
 10410  		sym2 := v_0.Aux
 10411  		_ = v_0.Args[1]
 10412  		ptr := v_0.Args[0]
 10413  		idx := v_0.Args[1]
 10414  		mem := v.Args[1]
 10415  		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 10416  			break
 10417  		}
 10418  		v.reset(OpS390XFMOVSloadidx)
 10419  		v.AuxInt = off1 + off2
 10420  		v.Aux = mergeSym(sym1, sym2)
 10421  		v.AddArg(ptr)
 10422  		v.AddArg(idx)
 10423  		v.AddArg(mem)
 10424  		return true
 10425  	}
 10426  	// match: (FMOVSload [off] {sym} (ADD ptr idx) mem)
 10427  	// cond: ptr.Op != OpSB
 10428  	// result: (FMOVSloadidx [off] {sym} ptr idx mem)
 10429  	for {
 10430  		off := v.AuxInt
 10431  		sym := v.Aux
 10432  		_ = v.Args[1]
 10433  		v_0 := v.Args[0]
 10434  		if v_0.Op != OpS390XADD {
 10435  			break
 10436  		}
 10437  		_ = v_0.Args[1]
 10438  		ptr := v_0.Args[0]
 10439  		idx := v_0.Args[1]
 10440  		mem := v.Args[1]
 10441  		if !(ptr.Op != OpSB) {
 10442  			break
 10443  		}
 10444  		v.reset(OpS390XFMOVSloadidx)
 10445  		v.AuxInt = off
 10446  		v.Aux = sym
 10447  		v.AddArg(ptr)
 10448  		v.AddArg(idx)
 10449  		v.AddArg(mem)
 10450  		return true
 10451  	}
 10452  	return false
 10453  }
 10454  func rewriteValueS390X_OpS390XFMOVSloadidx_0(v *Value) bool {
 10455  	// match: (FMOVSloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 10456  	// cond: is20Bit(c+d)
 10457  	// result: (FMOVSloadidx [c+d] {sym} ptr idx mem)
 10458  	for {
 10459  		c := v.AuxInt
 10460  		sym := v.Aux
 10461  		_ = v.Args[2]
 10462  		v_0 := v.Args[0]
 10463  		if v_0.Op != OpS390XADDconst {
 10464  			break
 10465  		}
 10466  		d := v_0.AuxInt
 10467  		ptr := v_0.Args[0]
 10468  		idx := v.Args[1]
 10469  		mem := v.Args[2]
 10470  		if !(is20Bit(c + d)) {
 10471  			break
 10472  		}
 10473  		v.reset(OpS390XFMOVSloadidx)
 10474  		v.AuxInt = c + d
 10475  		v.Aux = sym
 10476  		v.AddArg(ptr)
 10477  		v.AddArg(idx)
 10478  		v.AddArg(mem)
 10479  		return true
 10480  	}
 10481  	// match: (FMOVSloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
 10482  	// cond: is20Bit(c+d)
 10483  	// result: (FMOVSloadidx [c+d] {sym} ptr idx mem)
 10484  	for {
 10485  		c := v.AuxInt
 10486  		sym := v.Aux
 10487  		_ = v.Args[2]
 10488  		ptr := v.Args[0]
 10489  		v_1 := v.Args[1]
 10490  		if v_1.Op != OpS390XADDconst {
 10491  			break
 10492  		}
 10493  		d := v_1.AuxInt
 10494  		idx := v_1.Args[0]
 10495  		mem := v.Args[2]
 10496  		if !(is20Bit(c + d)) {
 10497  			break
 10498  		}
 10499  		v.reset(OpS390XFMOVSloadidx)
 10500  		v.AuxInt = c + d
 10501  		v.Aux = sym
 10502  		v.AddArg(ptr)
 10503  		v.AddArg(idx)
 10504  		v.AddArg(mem)
 10505  		return true
 10506  	}
 10507  	return false
 10508  }
 10509  func rewriteValueS390X_OpS390XFMOVSstore_0(v *Value) bool {
 10510  	// match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 10511  	// cond: is20Bit(off1+off2)
 10512  	// result: (FMOVSstore [off1+off2] {sym} ptr val mem)
 10513  	for {
 10514  		off1 := v.AuxInt
 10515  		sym := v.Aux
 10516  		_ = v.Args[2]
 10517  		v_0 := v.Args[0]
 10518  		if v_0.Op != OpS390XADDconst {
 10519  			break
 10520  		}
 10521  		off2 := v_0.AuxInt
 10522  		ptr := v_0.Args[0]
 10523  		val := v.Args[1]
 10524  		mem := v.Args[2]
 10525  		if !(is20Bit(off1 + off2)) {
 10526  			break
 10527  		}
 10528  		v.reset(OpS390XFMOVSstore)
 10529  		v.AuxInt = off1 + off2
 10530  		v.Aux = sym
 10531  		v.AddArg(ptr)
 10532  		v.AddArg(val)
 10533  		v.AddArg(mem)
 10534  		return true
 10535  	}
 10536  	// match: (FMOVSstore [off1] {sym1} (MOVDaddr [off2] {sym2} base) val mem)
 10537  	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 10538  	// result: (FMOVSstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
 10539  	for {
 10540  		off1 := v.AuxInt
 10541  		sym1 := v.Aux
 10542  		_ = v.Args[2]
 10543  		v_0 := v.Args[0]
 10544  		if v_0.Op != OpS390XMOVDaddr {
 10545  			break
 10546  		}
 10547  		off2 := v_0.AuxInt
 10548  		sym2 := v_0.Aux
 10549  		base := v_0.Args[0]
 10550  		val := v.Args[1]
 10551  		mem := v.Args[2]
 10552  		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 10553  			break
 10554  		}
 10555  		v.reset(OpS390XFMOVSstore)
 10556  		v.AuxInt = off1 + off2
 10557  		v.Aux = mergeSym(sym1, sym2)
 10558  		v.AddArg(base)
 10559  		v.AddArg(val)
 10560  		v.AddArg(mem)
 10561  		return true
 10562  	}
 10563  	// match: (FMOVSstore [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) val mem)
 10564  	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 10565  	// result: (FMOVSstoreidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
 10566  	for {
 10567  		off1 := v.AuxInt
 10568  		sym1 := v.Aux
 10569  		_ = v.Args[2]
 10570  		v_0 := v.Args[0]
 10571  		if v_0.Op != OpS390XMOVDaddridx {
 10572  			break
 10573  		}
 10574  		off2 := v_0.AuxInt
 10575  		sym2 := v_0.Aux
 10576  		_ = v_0.Args[1]
 10577  		ptr := v_0.Args[0]
 10578  		idx := v_0.Args[1]
 10579  		val := v.Args[1]
 10580  		mem := v.Args[2]
 10581  		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 10582  			break
 10583  		}
 10584  		v.reset(OpS390XFMOVSstoreidx)
 10585  		v.AuxInt = off1 + off2
 10586  		v.Aux = mergeSym(sym1, sym2)
 10587  		v.AddArg(ptr)
 10588  		v.AddArg(idx)
 10589  		v.AddArg(val)
 10590  		v.AddArg(mem)
 10591  		return true
 10592  	}
 10593  	// match: (FMOVSstore [off] {sym} (ADD ptr idx) val mem)
 10594  	// cond: ptr.Op != OpSB
 10595  	// result: (FMOVSstoreidx [off] {sym} ptr idx val mem)
 10596  	for {
 10597  		off := v.AuxInt
 10598  		sym := v.Aux
 10599  		_ = v.Args[2]
 10600  		v_0 := v.Args[0]
 10601  		if v_0.Op != OpS390XADD {
 10602  			break
 10603  		}
 10604  		_ = v_0.Args[1]
 10605  		ptr := v_0.Args[0]
 10606  		idx := v_0.Args[1]
 10607  		val := v.Args[1]
 10608  		mem := v.Args[2]
 10609  		if !(ptr.Op != OpSB) {
 10610  			break
 10611  		}
 10612  		v.reset(OpS390XFMOVSstoreidx)
 10613  		v.AuxInt = off
 10614  		v.Aux = sym
 10615  		v.AddArg(ptr)
 10616  		v.AddArg(idx)
 10617  		v.AddArg(val)
 10618  		v.AddArg(mem)
 10619  		return true
 10620  	}
 10621  	return false
 10622  }
 10623  func rewriteValueS390X_OpS390XFMOVSstoreidx_0(v *Value) bool {
 10624  	// match: (FMOVSstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
 10625  	// cond: is20Bit(c+d)
 10626  	// result: (FMOVSstoreidx [c+d] {sym} ptr idx val mem)
 10627  	for {
 10628  		c := v.AuxInt
 10629  		sym := v.Aux
 10630  		_ = v.Args[3]
 10631  		v_0 := v.Args[0]
 10632  		if v_0.Op != OpS390XADDconst {
 10633  			break
 10634  		}
 10635  		d := v_0.AuxInt
 10636  		ptr := v_0.Args[0]
 10637  		idx := v.Args[1]
 10638  		val := v.Args[2]
 10639  		mem := v.Args[3]
 10640  		if !(is20Bit(c + d)) {
 10641  			break
 10642  		}
 10643  		v.reset(OpS390XFMOVSstoreidx)
 10644  		v.AuxInt = c + d
 10645  		v.Aux = sym
 10646  		v.AddArg(ptr)
 10647  		v.AddArg(idx)
 10648  		v.AddArg(val)
 10649  		v.AddArg(mem)
 10650  		return true
 10651  	}
 10652  	// match: (FMOVSstoreidx [c] {sym} ptr (ADDconst [d] idx) val mem)
 10653  	// cond: is20Bit(c+d)
 10654  	// result: (FMOVSstoreidx [c+d] {sym} ptr idx val mem)
 10655  	for {
 10656  		c := v.AuxInt
 10657  		sym := v.Aux
 10658  		_ = v.Args[3]
 10659  		ptr := v.Args[0]
 10660  		v_1 := v.Args[1]
 10661  		if v_1.Op != OpS390XADDconst {
 10662  			break
 10663  		}
 10664  		d := v_1.AuxInt
 10665  		idx := v_1.Args[0]
 10666  		val := v.Args[2]
 10667  		mem := v.Args[3]
 10668  		if !(is20Bit(c + d)) {
 10669  			break
 10670  		}
 10671  		v.reset(OpS390XFMOVSstoreidx)
 10672  		v.AuxInt = c + d
 10673  		v.Aux = sym
 10674  		v.AddArg(ptr)
 10675  		v.AddArg(idx)
 10676  		v.AddArg(val)
 10677  		v.AddArg(mem)
 10678  		return true
 10679  	}
 10680  	return false
 10681  }
 10682  func rewriteValueS390X_OpS390XFNEG_0(v *Value) bool {
 10683  	// match: (FNEG (LPDFR x))
 10684  	// cond:
 10685  	// result: (LNDFR x)
 10686  	for {
 10687  		v_0 := v.Args[0]
 10688  		if v_0.Op != OpS390XLPDFR {
 10689  			break
 10690  		}
 10691  		x := v_0.Args[0]
 10692  		v.reset(OpS390XLNDFR)
 10693  		v.AddArg(x)
 10694  		return true
 10695  	}
 10696  	// match: (FNEG (LNDFR x))
 10697  	// cond:
 10698  	// result: (LPDFR x)
 10699  	for {
 10700  		v_0 := v.Args[0]
 10701  		if v_0.Op != OpS390XLNDFR {
 10702  			break
 10703  		}
 10704  		x := v_0.Args[0]
 10705  		v.reset(OpS390XLPDFR)
 10706  		v.AddArg(x)
 10707  		return true
 10708  	}
 10709  	return false
 10710  }
 10711  func rewriteValueS390X_OpS390XFNEGS_0(v *Value) bool {
 10712  	// match: (FNEGS (LPDFR x))
 10713  	// cond:
 10714  	// result: (LNDFR x)
 10715  	for {
 10716  		v_0 := v.Args[0]
 10717  		if v_0.Op != OpS390XLPDFR {
 10718  			break
 10719  		}
 10720  		x := v_0.Args[0]
 10721  		v.reset(OpS390XLNDFR)
 10722  		v.AddArg(x)
 10723  		return true
 10724  	}
 10725  	// match: (FNEGS (LNDFR x))
 10726  	// cond:
 10727  	// result: (LPDFR x)
 10728  	for {
 10729  		v_0 := v.Args[0]
 10730  		if v_0.Op != OpS390XLNDFR {
 10731  			break
 10732  		}
 10733  		x := v_0.Args[0]
 10734  		v.reset(OpS390XLPDFR)
 10735  		v.AddArg(x)
 10736  		return true
 10737  	}
 10738  	return false
 10739  }
 10740  func rewriteValueS390X_OpS390XFSUB_0(v *Value) bool {
 10741  	// match: (FSUB (FMUL y z) x)
 10742  	// cond:
 10743  	// result: (FMSUB x y z)
 10744  	for {
 10745  		_ = v.Args[1]
 10746  		v_0 := v.Args[0]
 10747  		if v_0.Op != OpS390XFMUL {
 10748  			break
 10749  		}
 10750  		_ = v_0.Args[1]
 10751  		y := v_0.Args[0]
 10752  		z := v_0.Args[1]
 10753  		x := v.Args[1]
 10754  		v.reset(OpS390XFMSUB)
 10755  		v.AddArg(x)
 10756  		v.AddArg(y)
 10757  		v.AddArg(z)
 10758  		return true
 10759  	}
 10760  	return false
 10761  }
 10762  func rewriteValueS390X_OpS390XFSUBS_0(v *Value) bool {
 10763  	// match: (FSUBS (FMULS y z) x)
 10764  	// cond:
 10765  	// result: (FMSUBS x y z)
 10766  	for {
 10767  		_ = v.Args[1]
 10768  		v_0 := v.Args[0]
 10769  		if v_0.Op != OpS390XFMULS {
 10770  			break
 10771  		}
 10772  		_ = v_0.Args[1]
 10773  		y := v_0.Args[0]
 10774  		z := v_0.Args[1]
 10775  		x := v.Args[1]
 10776  		v.reset(OpS390XFMSUBS)
 10777  		v.AddArg(x)
 10778  		v.AddArg(y)
 10779  		v.AddArg(z)
 10780  		return true
 10781  	}
 10782  	return false
 10783  }
 10784  func rewriteValueS390X_OpS390XLDGR_0(v *Value) bool {
 10785  	b := v.Block
 10786  	_ = b
 10787  	// match: (LDGR <t> (SRDconst [1] (SLDconst [1] x)))
 10788  	// cond:
 10789  	// result: (LPDFR (LDGR <t> x))
 10790  	for {
 10791  		t := v.Type
 10792  		v_0 := v.Args[0]
 10793  		if v_0.Op != OpS390XSRDconst {
 10794  			break
 10795  		}
 10796  		if v_0.AuxInt != 1 {
 10797  			break
 10798  		}
 10799  		v_0_0 := v_0.Args[0]
 10800  		if v_0_0.Op != OpS390XSLDconst {
 10801  			break
 10802  		}
 10803  		if v_0_0.AuxInt != 1 {
 10804  			break
 10805  		}
 10806  		x := v_0_0.Args[0]
 10807  		v.reset(OpS390XLPDFR)
 10808  		v0 := b.NewValue0(v.Pos, OpS390XLDGR, t)
 10809  		v0.AddArg(x)
 10810  		v.AddArg(v0)
 10811  		return true
 10812  	}
 10813  	// match: (LDGR <t> (OR (MOVDconst [-1<<63]) x))
 10814  	// cond:
 10815  	// result: (LNDFR (LDGR <t> x))
 10816  	for {
 10817  		t := v.Type
 10818  		v_0 := v.Args[0]
 10819  		if v_0.Op != OpS390XOR {
 10820  			break
 10821  		}
 10822  		_ = v_0.Args[1]
 10823  		v_0_0 := v_0.Args[0]
 10824  		if v_0_0.Op != OpS390XMOVDconst {
 10825  			break
 10826  		}
 10827  		if v_0_0.AuxInt != -1<<63 {
 10828  			break
 10829  		}
 10830  		x := v_0.Args[1]
 10831  		v.reset(OpS390XLNDFR)
 10832  		v0 := b.NewValue0(v.Pos, OpS390XLDGR, t)
 10833  		v0.AddArg(x)
 10834  		v.AddArg(v0)
 10835  		return true
 10836  	}
 10837  	// match: (LDGR <t> (OR x (MOVDconst [-1<<63])))
 10838  	// cond:
 10839  	// result: (LNDFR (LDGR <t> x))
 10840  	for {
 10841  		t := v.Type
 10842  		v_0 := v.Args[0]
 10843  		if v_0.Op != OpS390XOR {
 10844  			break
 10845  		}
 10846  		_ = v_0.Args[1]
 10847  		x := v_0.Args[0]
 10848  		v_0_1 := v_0.Args[1]
 10849  		if v_0_1.Op != OpS390XMOVDconst {
 10850  			break
 10851  		}
 10852  		if v_0_1.AuxInt != -1<<63 {
 10853  			break
 10854  		}
 10855  		v.reset(OpS390XLNDFR)
 10856  		v0 := b.NewValue0(v.Pos, OpS390XLDGR, t)
 10857  		v0.AddArg(x)
 10858  		v.AddArg(v0)
 10859  		return true
 10860  	}
 10861  	// match: (LDGR <t> x:(ORload <t1> [off] {sym} (MOVDconst [-1<<63]) ptr mem))
 10862  	// cond: x.Uses == 1 && clobber(x)
 10863  	// result: @x.Block (LNDFR <t> (LDGR <t> (MOVDload <t1> [off] {sym} ptr mem)))
 10864  	for {
 10865  		t := v.Type
 10866  		x := v.Args[0]
 10867  		if x.Op != OpS390XORload {
 10868  			break
 10869  		}
 10870  		t1 := x.Type
 10871  		off := x.AuxInt
 10872  		sym := x.Aux
 10873  		_ = x.Args[2]
 10874  		x_0 := x.Args[0]
 10875  		if x_0.Op != OpS390XMOVDconst {
 10876  			break
 10877  		}
 10878  		if x_0.AuxInt != -1<<63 {
 10879  			break
 10880  		}
 10881  		ptr := x.Args[1]
 10882  		mem := x.Args[2]
 10883  		if !(x.Uses == 1 && clobber(x)) {
 10884  			break
 10885  		}
 10886  		b = x.Block
 10887  		v0 := b.NewValue0(x.Pos, OpS390XLNDFR, t)
 10888  		v.reset(OpCopy)
 10889  		v.AddArg(v0)
 10890  		v1 := b.NewValue0(x.Pos, OpS390XLDGR, t)
 10891  		v2 := b.NewValue0(x.Pos, OpS390XMOVDload, t1)
 10892  		v2.AuxInt = off
 10893  		v2.Aux = sym
 10894  		v2.AddArg(ptr)
 10895  		v2.AddArg(mem)
 10896  		v1.AddArg(v2)
 10897  		v0.AddArg(v1)
 10898  		return true
 10899  	}
 10900  	// match: (LDGR (LGDR x))
 10901  	// cond:
 10902  	// result: x
 10903  	for {
 10904  		v_0 := v.Args[0]
 10905  		if v_0.Op != OpS390XLGDR {
 10906  			break
 10907  		}
 10908  		x := v_0.Args[0]
 10909  		v.reset(OpCopy)
 10910  		v.Type = x.Type
 10911  		v.AddArg(x)
 10912  		return true
 10913  	}
 10914  	return false
 10915  }
 10916  func rewriteValueS390X_OpS390XLEDBR_0(v *Value) bool {
 10917  	// match: (LEDBR (LPDFR (LDEBR x)))
 10918  	// cond:
 10919  	// result: (LPDFR x)
 10920  	for {
 10921  		v_0 := v.Args[0]
 10922  		if v_0.Op != OpS390XLPDFR {
 10923  			break
 10924  		}
 10925  		v_0_0 := v_0.Args[0]
 10926  		if v_0_0.Op != OpS390XLDEBR {
 10927  			break
 10928  		}
 10929  		x := v_0_0.Args[0]
 10930  		v.reset(OpS390XLPDFR)
 10931  		v.AddArg(x)
 10932  		return true
 10933  	}
 10934  	// match: (LEDBR (LNDFR (LDEBR x)))
 10935  	// cond:
 10936  	// result: (LNDFR x)
 10937  	for {
 10938  		v_0 := v.Args[0]
 10939  		if v_0.Op != OpS390XLNDFR {
 10940  			break
 10941  		}
 10942  		v_0_0 := v_0.Args[0]
 10943  		if v_0_0.Op != OpS390XLDEBR {
 10944  			break
 10945  		}
 10946  		x := v_0_0.Args[0]
 10947  		v.reset(OpS390XLNDFR)
 10948  		v.AddArg(x)
 10949  		return true
 10950  	}
 10951  	return false
 10952  }
 10953  func rewriteValueS390X_OpS390XLGDR_0(v *Value) bool {
 10954  	// match: (LGDR (LDGR x))
 10955  	// cond:
 10956  	// result: (MOVDreg x)
 10957  	for {
 10958  		v_0 := v.Args[0]
 10959  		if v_0.Op != OpS390XLDGR {
 10960  			break
 10961  		}
 10962  		x := v_0.Args[0]
 10963  		v.reset(OpS390XMOVDreg)
 10964  		v.AddArg(x)
 10965  		return true
 10966  	}
 10967  	return false
 10968  }
 10969  func rewriteValueS390X_OpS390XLoweredRound32F_0(v *Value) bool {
 10970  	// match: (LoweredRound32F x:(FMOVSconst))
 10971  	// cond:
 10972  	// result: x
 10973  	for {
 10974  		x := v.Args[0]
 10975  		if x.Op != OpS390XFMOVSconst {
 10976  			break
 10977  		}
 10978  		v.reset(OpCopy)
 10979  		v.Type = x.Type
 10980  		v.AddArg(x)
 10981  		return true
 10982  	}
 10983  	return false
 10984  }
 10985  func rewriteValueS390X_OpS390XLoweredRound64F_0(v *Value) bool {
 10986  	// match: (LoweredRound64F x:(FMOVDconst))
 10987  	// cond:
 10988  	// result: x
 10989  	for {
 10990  		x := v.Args[0]
 10991  		if x.Op != OpS390XFMOVDconst {
 10992  			break
 10993  		}
 10994  		v.reset(OpCopy)
 10995  		v.Type = x.Type
 10996  		v.AddArg(x)
 10997  		return true
 10998  	}
 10999  	return false
 11000  }
 11001  func rewriteValueS390X_OpS390XMOVBZload_0(v *Value) bool {
 11002  	// match: (MOVBZload [off] {sym} ptr1 (MOVBstore [off] {sym} ptr2 x _))
 11003  	// cond: isSamePtr(ptr1, ptr2)
 11004  	// result: (MOVBZreg x)
 11005  	for {
 11006  		off := v.AuxInt
 11007  		sym := v.Aux
 11008  		_ = v.Args[1]
 11009  		ptr1 := v.Args[0]
 11010  		v_1 := v.Args[1]
 11011  		if v_1.Op != OpS390XMOVBstore {
 11012  			break
 11013  		}
 11014  		if v_1.AuxInt != off {
 11015  			break
 11016  		}
 11017  		if v_1.Aux != sym {
 11018  			break
 11019  		}
 11020  		_ = v_1.Args[2]
 11021  		ptr2 := v_1.Args[0]
 11022  		x := v_1.Args[1]
 11023  		if !(isSamePtr(ptr1, ptr2)) {
 11024  			break
 11025  		}
 11026  		v.reset(OpS390XMOVBZreg)
 11027  		v.AddArg(x)
 11028  		return true
 11029  	}
 11030  	// match: (MOVBZload [off1] {sym} (ADDconst [off2] ptr) mem)
 11031  	// cond: is20Bit(off1+off2)
 11032  	// result: (MOVBZload [off1+off2] {sym} ptr mem)
 11033  	for {
 11034  		off1 := v.AuxInt
 11035  		sym := v.Aux
 11036  		_ = v.Args[1]
 11037  		v_0 := v.Args[0]
 11038  		if v_0.Op != OpS390XADDconst {
 11039  			break
 11040  		}
 11041  		off2 := v_0.AuxInt
 11042  		ptr := v_0.Args[0]
 11043  		mem := v.Args[1]
 11044  		if !(is20Bit(off1 + off2)) {
 11045  			break
 11046  		}
 11047  		v.reset(OpS390XMOVBZload)
 11048  		v.AuxInt = off1 + off2
 11049  		v.Aux = sym
 11050  		v.AddArg(ptr)
 11051  		v.AddArg(mem)
 11052  		return true
 11053  	}
 11054  	// match: (MOVBZload [off1] {sym1} (MOVDaddr [off2] {sym2} base) mem)
 11055  	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 11056  	// result: (MOVBZload [off1+off2] {mergeSym(sym1,sym2)} base mem)
 11057  	for {
 11058  		off1 := v.AuxInt
 11059  		sym1 := v.Aux
 11060  		_ = v.Args[1]
 11061  		v_0 := v.Args[0]
 11062  		if v_0.Op != OpS390XMOVDaddr {
 11063  			break
 11064  		}
 11065  		off2 := v_0.AuxInt
 11066  		sym2 := v_0.Aux
 11067  		base := v_0.Args[0]
 11068  		mem := v.Args[1]
 11069  		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 11070  			break
 11071  		}
 11072  		v.reset(OpS390XMOVBZload)
 11073  		v.AuxInt = off1 + off2
 11074  		v.Aux = mergeSym(sym1, sym2)
 11075  		v.AddArg(base)
 11076  		v.AddArg(mem)
 11077  		return true
 11078  	}
 11079  	// match: (MOVBZload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
 11080  	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 11081  	// result: (MOVBZloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
 11082  	for {
 11083  		off1 := v.AuxInt
 11084  		sym1 := v.Aux
 11085  		_ = v.Args[1]
 11086  		v_0 := v.Args[0]
 11087  		if v_0.Op != OpS390XMOVDaddridx {
 11088  			break
 11089  		}
 11090  		off2 := v_0.AuxInt
 11091  		sym2 := v_0.Aux
 11092  		_ = v_0.Args[1]
 11093  		ptr := v_0.Args[0]
 11094  		idx := v_0.Args[1]
 11095  		mem := v.Args[1]
 11096  		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 11097  			break
 11098  		}
 11099  		v.reset(OpS390XMOVBZloadidx)
 11100  		v.AuxInt = off1 + off2
 11101  		v.Aux = mergeSym(sym1, sym2)
 11102  		v.AddArg(ptr)
 11103  		v.AddArg(idx)
 11104  		v.AddArg(mem)
 11105  		return true
 11106  	}
 11107  	// match: (MOVBZload [off] {sym} (ADD ptr idx) mem)
 11108  	// cond: ptr.Op != OpSB
 11109  	// result: (MOVBZloadidx [off] {sym} ptr idx mem)
 11110  	for {
 11111  		off := v.AuxInt
 11112  		sym := v.Aux
 11113  		_ = v.Args[1]
 11114  		v_0 := v.Args[0]
 11115  		if v_0.Op != OpS390XADD {
 11116  			break
 11117  		}
 11118  		_ = v_0.Args[1]
 11119  		ptr := v_0.Args[0]
 11120  		idx := v_0.Args[1]
 11121  		mem := v.Args[1]
 11122  		if !(ptr.Op != OpSB) {
 11123  			break
 11124  		}
 11125  		v.reset(OpS390XMOVBZloadidx)
 11126  		v.AuxInt = off
 11127  		v.Aux = sym
 11128  		v.AddArg(ptr)
 11129  		v.AddArg(idx)
 11130  		v.AddArg(mem)
 11131  		return true
 11132  	}
 11133  	return false
 11134  }
 11135  func rewriteValueS390X_OpS390XMOVBZloadidx_0(v *Value) bool {
 11136  	// match: (MOVBZloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 11137  	// cond: is20Bit(c+d)
 11138  	// result: (MOVBZloadidx [c+d] {sym} ptr idx mem)
 11139  	for {
 11140  		c := v.AuxInt
 11141  		sym := v.Aux
 11142  		_ = v.Args[2]
 11143  		v_0 := v.Args[0]
 11144  		if v_0.Op != OpS390XADDconst {
 11145  			break
 11146  		}
 11147  		d := v_0.AuxInt
 11148  		ptr := v_0.Args[0]
 11149  		idx := v.Args[1]
 11150  		mem := v.Args[2]
 11151  		if !(is20Bit(c + d)) {
 11152  			break
 11153  		}
 11154  		v.reset(OpS390XMOVBZloadidx)
 11155  		v.AuxInt = c + d
 11156  		v.Aux = sym
 11157  		v.AddArg(ptr)
 11158  		v.AddArg(idx)
 11159  		v.AddArg(mem)
 11160  		return true
 11161  	}
 11162  	// match: (MOVBZloadidx [c] {sym} idx (ADDconst [d] ptr) mem)
 11163  	// cond: is20Bit(c+d)
 11164  	// result: (MOVBZloadidx [c+d] {sym} ptr idx mem)
 11165  	for {
 11166  		c := v.AuxInt
 11167  		sym := v.Aux
 11168  		_ = v.Args[2]
 11169  		idx := v.Args[0]
 11170  		v_1 := v.Args[1]
 11171  		if v_1.Op != OpS390XADDconst {
 11172  			break
 11173  		}
 11174  		d := v_1.AuxInt
 11175  		ptr := v_1.Args[0]
 11176  		mem := v.Args[2]
 11177  		if !(is20Bit(c + d)) {
 11178  			break
 11179  		}
 11180  		v.reset(OpS390XMOVBZloadidx)
 11181  		v.AuxInt = c + d
 11182  		v.Aux = sym
 11183  		v.AddArg(ptr)
 11184  		v.AddArg(idx)
 11185  		v.AddArg(mem)
 11186  		return true
 11187  	}
 11188  	// match: (MOVBZloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
 11189  	// cond: is20Bit(c+d)
 11190  	// result: (MOVBZloadidx [c+d] {sym} ptr idx mem)
 11191  	for {
 11192  		c := v.AuxInt
 11193  		sym := v.Aux
 11194  		_ = v.Args[2]
 11195  		ptr := v.Args[0]
 11196  		v_1 := v.Args[1]
 11197  		if v_1.Op != OpS390XADDconst {
 11198  			break
 11199  		}
 11200  		d := v_1.AuxInt
 11201  		idx := v_1.Args[0]
 11202  		mem := v.Args[2]
 11203  		if !(is20Bit(c + d)) {
 11204  			break
 11205  		}
 11206  		v.reset(OpS390XMOVBZloadidx)
 11207  		v.AuxInt = c + d
 11208  		v.Aux = sym
 11209  		v.AddArg(ptr)
 11210  		v.AddArg(idx)
 11211  		v.AddArg(mem)
 11212  		return true
 11213  	}
 11214  	// match: (MOVBZloadidx [c] {sym} (ADDconst [d] idx) ptr mem)
 11215  	// cond: is20Bit(c+d)
 11216  	// result: (MOVBZloadidx [c+d] {sym} ptr idx mem)
 11217  	for {
 11218  		c := v.AuxInt
 11219  		sym := v.Aux
 11220  		_ = v.Args[2]
 11221  		v_0 := v.Args[0]
 11222  		if v_0.Op != OpS390XADDconst {
 11223  			break
 11224  		}
 11225  		d := v_0.AuxInt
 11226  		idx := v_0.Args[0]
 11227  		ptr := v.Args[1]
 11228  		mem := v.Args[2]
 11229  		if !(is20Bit(c + d)) {
 11230  			break
 11231  		}
 11232  		v.reset(OpS390XMOVBZloadidx)
 11233  		v.AuxInt = c + d
 11234  		v.Aux = sym
 11235  		v.AddArg(ptr)
 11236  		v.AddArg(idx)
 11237  		v.AddArg(mem)
 11238  		return true
 11239  	}
 11240  	return false
 11241  }
 11242  func rewriteValueS390X_OpS390XMOVBZreg_0(v *Value) bool {
 11243  	// match: (MOVBZreg x:(MOVDLT (MOVDconst [c]) (MOVDconst [d]) _))
 11244  	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 11245  	// result: (MOVDreg x)
 11246  	for {
 11247  		x := v.Args[0]
 11248  		if x.Op != OpS390XMOVDLT {
 11249  			break
 11250  		}
 11251  		_ = x.Args[2]
 11252  		x_0 := x.Args[0]
 11253  		if x_0.Op != OpS390XMOVDconst {
 11254  			break
 11255  		}
 11256  		c := x_0.AuxInt
 11257  		x_1 := x.Args[1]
 11258  		if x_1.Op != OpS390XMOVDconst {
 11259  			break
 11260  		}
 11261  		d := x_1.AuxInt
 11262  		if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
 11263  			break
 11264  		}
 11265  		v.reset(OpS390XMOVDreg)
 11266  		v.AddArg(x)
 11267  		return true
 11268  	}
 11269  	// match: (MOVBZreg x:(MOVDLE (MOVDconst [c]) (MOVDconst [d]) _))
 11270  	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 11271  	// result: (MOVDreg x)
 11272  	for {
 11273  		x := v.Args[0]
 11274  		if x.Op != OpS390XMOVDLE {
 11275  			break
 11276  		}
 11277  		_ = x.Args[2]
 11278  		x_0 := x.Args[0]
 11279  		if x_0.Op != OpS390XMOVDconst {
 11280  			break
 11281  		}
 11282  		c := x_0.AuxInt
 11283  		x_1 := x.Args[1]
 11284  		if x_1.Op != OpS390XMOVDconst {
 11285  			break
 11286  		}
 11287  		d := x_1.AuxInt
 11288  		if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
 11289  			break
 11290  		}
 11291  		v.reset(OpS390XMOVDreg)
 11292  		v.AddArg(x)
 11293  		return true
 11294  	}
 11295  	// match: (MOVBZreg x:(MOVDGT (MOVDconst [c]) (MOVDconst [d]) _))
 11296  	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 11297  	// result: (MOVDreg x)
 11298  	for {
 11299  		x := v.Args[0]
 11300  		if x.Op != OpS390XMOVDGT {
 11301  			break
 11302  		}
 11303  		_ = x.Args[2]
 11304  		x_0 := x.Args[0]
 11305  		if x_0.Op != OpS390XMOVDconst {
 11306  			break
 11307  		}
 11308  		c := x_0.AuxInt
 11309  		x_1 := x.Args[1]
 11310  		if x_1.Op != OpS390XMOVDconst {
 11311  			break
 11312  		}
 11313  		d := x_1.AuxInt
 11314  		if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
 11315  			break
 11316  		}
 11317  		v.reset(OpS390XMOVDreg)
 11318  		v.AddArg(x)
 11319  		return true
 11320  	}
 11321  	// match: (MOVBZreg x:(MOVDGE (MOVDconst [c]) (MOVDconst [d]) _))
 11322  	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 11323  	// result: (MOVDreg x)
 11324  	for {
 11325  		x := v.Args[0]
 11326  		if x.Op != OpS390XMOVDGE {
 11327  			break
 11328  		}
 11329  		_ = x.Args[2]
 11330  		x_0 := x.Args[0]
 11331  		if x_0.Op != OpS390XMOVDconst {
 11332  			break
 11333  		}
 11334  		c := x_0.AuxInt
 11335  		x_1 := x.Args[1]
 11336  		if x_1.Op != OpS390XMOVDconst {
 11337  			break
 11338  		}
 11339  		d := x_1.AuxInt
 11340  		if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
 11341  			break
 11342  		}
 11343  		v.reset(OpS390XMOVDreg)
 11344  		v.AddArg(x)
 11345  		return true
 11346  	}
 11347  	// match: (MOVBZreg x:(MOVDEQ (MOVDconst [c]) (MOVDconst [d]) _))
 11348  	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 11349  	// result: (MOVDreg x)
 11350  	for {
 11351  		x := v.Args[0]
 11352  		if x.Op != OpS390XMOVDEQ {
 11353  			break
 11354  		}
 11355  		_ = x.Args[2]
 11356  		x_0 := x.Args[0]
 11357  		if x_0.Op != OpS390XMOVDconst {
 11358  			break
 11359  		}
 11360  		c := x_0.AuxInt
 11361  		x_1 := x.Args[1]
 11362  		if x_1.Op != OpS390XMOVDconst {
 11363  			break
 11364  		}
 11365  		d := x_1.AuxInt
 11366  		if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
 11367  			break
 11368  		}
 11369  		v.reset(OpS390XMOVDreg)
 11370  		v.AddArg(x)
 11371  		return true
 11372  	}
 11373  	// match: (MOVBZreg x:(MOVDNE (MOVDconst [c]) (MOVDconst [d]) _))
 11374  	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 11375  	// result: (MOVDreg x)
 11376  	for {
 11377  		x := v.Args[0]
 11378  		if x.Op != OpS390XMOVDNE {
 11379  			break
 11380  		}
 11381  		_ = x.Args[2]
 11382  		x_0 := x.Args[0]
 11383  		if x_0.Op != OpS390XMOVDconst {
 11384  			break
 11385  		}
 11386  		c := x_0.AuxInt
 11387  		x_1 := x.Args[1]
 11388  		if x_1.Op != OpS390XMOVDconst {
 11389  			break
 11390  		}
 11391  		d := x_1.AuxInt
 11392  		if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
 11393  			break
 11394  		}
 11395  		v.reset(OpS390XMOVDreg)
 11396  		v.AddArg(x)
 11397  		return true
 11398  	}
 11399  	// match: (MOVBZreg x:(MOVDGTnoinv (MOVDconst [c]) (MOVDconst [d]) _))
 11400  	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 11401  	// result: (MOVDreg x)
 11402  	for {
 11403  		x := v.Args[0]
 11404  		if x.Op != OpS390XMOVDGTnoinv {
 11405  			break
 11406  		}
 11407  		_ = x.Args[2]
 11408  		x_0 := x.Args[0]
 11409  		if x_0.Op != OpS390XMOVDconst {
 11410  			break
 11411  		}
 11412  		c := x_0.AuxInt
 11413  		x_1 := x.Args[1]
 11414  		if x_1.Op != OpS390XMOVDconst {
 11415  			break
 11416  		}
 11417  		d := x_1.AuxInt
 11418  		if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
 11419  			break
 11420  		}
 11421  		v.reset(OpS390XMOVDreg)
 11422  		v.AddArg(x)
 11423  		return true
 11424  	}
 11425  	// match: (MOVBZreg x:(MOVDGEnoinv (MOVDconst [c]) (MOVDconst [d]) _))
 11426  	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
 11427  	// result: (MOVDreg x)
 11428  	for {
 11429  		x := v.Args[0]
 11430  		if x.Op != OpS390XMOVDGEnoinv {
 11431  			break
 11432  		}
 11433  		_ = x.Args[2]
 11434  		x_0 := x.Args[0]
 11435  		if x_0.Op != OpS390XMOVDconst {
 11436  			break
 11437  		}
 11438  		c := x_0.AuxInt
 11439  		x_1 := x.Args[1]
 11440  		if x_1.Op != OpS390XMOVDconst {
 11441  			break
 11442  		}
 11443  		d := x_1.AuxInt
 11444  		if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
 11445  			break
 11446  		}
 11447  		v.reset(OpS390XMOVDreg)
 11448  		v.AddArg(x)
 11449  		return true
 11450  	}
 11451  	// match: (MOVBZreg x:(MOVBZload _ _))
 11452  	// cond:
 11453  	// result: (MOVDreg x)
 11454  	for {
 11455  		x := v.Args[0]
 11456  		if x.Op != OpS390XMOVBZload {
 11457  			break
 11458  		}
 11459  		_ = x.Args[1]
 11460  		v.reset(OpS390XMOVDreg)
 11461  		v.AddArg(x)
 11462  		return true
 11463  	}
 11464  	// match: (MOVBZreg x:(Arg <t>))
 11465  	// cond: is8BitInt(t) && !isSigned(t)
 11466  	// result: (MOVDreg x)
 11467  	for {
 11468  		x := v.Args[0]
 11469  		if x.Op != OpArg {
 11470  			break
 11471  		}
 11472  		t := x.Type
 11473  		if !(is8BitInt(t) && !isSigned(t)) {
 11474  			break
 11475  		}
 11476  		v.reset(OpS390XMOVDreg)
 11477  		v.AddArg(x)
 11478  		return true
 11479  	}
 11480  	return false
 11481  }
 11482  func rewriteValueS390X_OpS390XMOVBZreg_10(v *Value) bool {
 11483  	b := v.Block
 11484  	_ = b
 11485  	typ := &b.Func.Config.Types
 11486  	_ = typ
 11487  	// match: (MOVBZreg x:(MOVBZreg _))
 11488  	// cond:
 11489  	// result: (MOVDreg x)
 11490  	for {
 11491  		x := v.Args[0]
 11492  		if x.Op != OpS390XMOVBZreg {
 11493  			break
 11494  		}
 11495  		v.reset(OpS390XMOVDreg)
 11496  		v.AddArg(x)
 11497  		return true
 11498  	}
 11499  	// match: (MOVBZreg (MOVBreg x))
 11500  	// cond:
 11501  	// result: (MOVBZreg x)
 11502  	for {
 11503  		v_0 := v.Args[0]
 11504  		if v_0.Op != OpS390XMOVBreg {
 11505  			break
 11506  		}
 11507  		x := v_0.Args[0]
 11508  		v.reset(OpS390XMOVBZreg)
 11509  		v.AddArg(x)
 11510  		return true
 11511  	}
 11512  	// match: (MOVBZreg (MOVDconst [c]))
 11513  	// cond:
 11514  	// result: (MOVDconst [int64(uint8(c))])
 11515  	for {
 11516  		v_0 := v.Args[0]
 11517  		if v_0.Op != OpS390XMOVDconst {
 11518  			break
 11519  		}
 11520  		c := v_0.AuxInt
 11521  		v.reset(OpS390XMOVDconst)
 11522  		v.AuxInt = int64(uint8(c))
 11523  		return true
 11524  	}
 11525  	// match: (MOVBZreg x:(MOVBZload [off] {sym} ptr mem))
 11526  	// cond: x.Uses == 1 && clobber(x)
 11527  	// result: @x.Block (MOVBZload <v.Type> [off] {sym} ptr mem)
 11528  	for {
 11529  		x := v.Args[0]
 11530  		if x.Op != OpS390XMOVBZload {
 11531  			break
 11532  		}
 11533  		off := x.AuxInt
 11534  		sym := x.Aux
 11535  		_ = x.Args[1]
 11536  		ptr := x.Args[0]
 11537  		mem := x.Args[1]
 11538  		if !(x.Uses == 1 && clobber(x)) {
 11539  			break
 11540  		}
 11541  		b = x.Block
 11542  		v0 := b.NewValue0(x.Pos, OpS390XMOVBZload, v.Type)
 11543  		v.reset(OpCopy)
 11544  		v.AddArg(v0)
 11545  		v0.AuxInt = off
 11546  		v0.Aux = sym
 11547  		v0.AddArg(ptr)
 11548  		v0.AddArg(mem)
 11549  		return true
 11550  	}
 11551  	// match: (MOVBZreg x:(MOVBload [off] {sym} ptr mem))
 11552  	// cond: x.Uses == 1 && clobber(x)
 11553  	// result: @x.Block (MOVBZload <v.Type> [off] {sym} ptr mem)
 11554  	for {
 11555  		x := v.Args[0]
 11556  		if x.Op != OpS390XMOVBload {
 11557  			break
 11558  		}
 11559  		off := x.AuxInt
 11560  		sym := x.Aux
 11561  		_ = x.Args[1]
 11562  		ptr := x.Args[0]
 11563  		mem := x.Args[1]
 11564  		if !(x.Uses == 1 && clobber(x)) {
 11565  			break
 11566  		}
 11567  		b = x.Block
 11568  		v0 := b.NewValue0(x.Pos, OpS390XMOVBZload, v.Type)
 11569  		v.reset(OpCopy)
 11570  		v.AddArg(v0)
 11571  		v0.AuxInt = off
 11572  		v0.Aux = sym
 11573  		v0.AddArg(ptr)
 11574  		v0.AddArg(mem)
 11575  		return true
 11576  	}
 11577  	// match: (MOVBZreg x:(MOVBZloadidx [off] {sym} ptr idx mem))
 11578  	// cond: x.Uses == 1 && clobber(x)
 11579  	// result: @x.Block (MOVBZloadidx <v.Type> [off] {sym} ptr idx mem)
 11580  	for {
 11581  		x := v.Args[0]
 11582  		if x.Op != OpS390XMOVBZloadidx {
 11583  			break
 11584  		}
 11585  		off := x.AuxInt
 11586  		sym := x.Aux
 11587  		_ = x.Args[2]
 11588  		ptr := x.Args[0]
 11589  		idx := x.Args[1]
 11590  		mem := x.Args[2]
 11591  		if !(x.Uses == 1 && clobber(x)) {
 11592  			break
 11593  		}
 11594  		b = x.Block
 11595  		v0 := b.NewValue0(v.Pos, OpS390XMOVBZloadidx, v.Type)
 11596  		v.reset(OpCopy)
 11597  		v.AddArg(v0)
 11598  		v0.AuxInt = off
 11599  		v0.Aux = sym
 11600  		v0.AddArg(ptr)
 11601  		v0.AddArg(idx)
 11602  		v0.AddArg(mem)
 11603  		return true
 11604  	}
 11605  	// match: (MOVBZreg x:(MOVBloadidx [off] {sym} ptr idx mem))
 11606  	// cond: x.Uses == 1 && clobber(x)
 11607  	// result: @x.Block (MOVBZloadidx <v.Type> [off] {sym} ptr idx mem)
 11608  	for {
 11609  		x := v.Args[0]
 11610  		if x.Op != OpS390XMOVBloadidx {
 11611  			break
 11612  		}
 11613  		off := x.AuxInt
 11614  		sym := x.Aux
 11615  		_ = x.Args[2]
 11616  		ptr := x.Args[0]
 11617  		idx := x.Args[1]
 11618  		mem := x.Args[2]
 11619  		if !(x.Uses == 1 && clobber(x)) {
 11620  			break
 11621  		}
 11622  		b = x.Block
 11623  		v0 := b.NewValue0(v.Pos, OpS390XMOVBZloadidx, v.Type)
 11624  		v.reset(OpCopy)
 11625  		v.AddArg(v0)
 11626  		v0.AuxInt = off
 11627  		v0.Aux = sym
 11628  		v0.AddArg(ptr)
 11629  		v0.AddArg(idx)
 11630  		v0.AddArg(mem)
 11631  		return true
 11632  	}
 11633  	// match: (MOVBZreg (ANDWconst [m] x))
 11634  	// cond:
 11635  	// result: (MOVWZreg (ANDWconst <typ.UInt32> [int64( uint8(m))] x))
 11636  	for {
 11637  		v_0 := v.Args[0]
 11638  		if v_0.Op != OpS390XANDWconst {
 11639  			break
 11640  		}
 11641  		m := v_0.AuxInt
 11642  		x := v_0.Args[0]
 11643  		v.reset(OpS390XMOVWZreg)
 11644  		v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 11645  		v0.AuxInt = int64(uint8(m))
 11646  		v0.AddArg(x)
 11647  		v.AddArg(v0)
 11648  		return true
 11649  	}
 11650  	return false
 11651  }
 11652  func rewriteValueS390X_OpS390XMOVBload_0(v *Value) bool {
 11653  	// match: (MOVBload [off] {sym} ptr1 (MOVBstore [off] {sym} ptr2 x _))
 11654  	// cond: isSamePtr(ptr1, ptr2)
 11655  	// result: (MOVBreg x)
 11656  	for {
 11657  		off := v.AuxInt
 11658  		sym := v.Aux
 11659  		_ = v.Args[1]
 11660  		ptr1 := v.Args[0]
 11661  		v_1 := v.Args[1]
 11662  		if v_1.Op != OpS390XMOVBstore {
 11663  			break
 11664  		}
 11665  		if v_1.AuxInt != off {
 11666  			break
 11667  		}
 11668  		if v_1.Aux != sym {
 11669  			break
 11670  		}
 11671  		_ = v_1.Args[2]
 11672  		ptr2 := v_1.Args[0]
 11673  		x := v_1.Args[1]
 11674  		if !(isSamePtr(ptr1, ptr2)) {
 11675  			break
 11676  		}
 11677  		v.reset(OpS390XMOVBreg)
 11678  		v.AddArg(x)
 11679  		return true
 11680  	}
 11681  	// match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem)
 11682  	// cond: is20Bit(off1+off2)
 11683  	// result: (MOVBload [off1+off2] {sym} ptr mem)
 11684  	for {
 11685  		off1 := v.AuxInt
 11686  		sym := v.Aux
 11687  		_ = v.Args[1]
 11688  		v_0 := v.Args[0]
 11689  		if v_0.Op != OpS390XADDconst {
 11690  			break
 11691  		}
 11692  		off2 := v_0.AuxInt
 11693  		ptr := v_0.Args[0]
 11694  		mem := v.Args[1]
 11695  		if !(is20Bit(off1 + off2)) {
 11696  			break
 11697  		}
 11698  		v.reset(OpS390XMOVBload)
 11699  		v.AuxInt = off1 + off2
 11700  		v.Aux = sym
 11701  		v.AddArg(ptr)
 11702  		v.AddArg(mem)
 11703  		return true
 11704  	}
 11705  	// match: (MOVBload [off1] {sym1} (MOVDaddr [off2] {sym2} base) mem)
 11706  	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 11707  	// result: (MOVBload [off1+off2] {mergeSym(sym1,sym2)} base mem)
 11708  	for {
 11709  		off1 := v.AuxInt
 11710  		sym1 := v.Aux
 11711  		_ = v.Args[1]
 11712  		v_0 := v.Args[0]
 11713  		if v_0.Op != OpS390XMOVDaddr {
 11714  			break
 11715  		}
 11716  		off2 := v_0.AuxInt
 11717  		sym2 := v_0.Aux
 11718  		base := v_0.Args[0]
 11719  		mem := v.Args[1]
 11720  		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 11721  			break
 11722  		}
 11723  		v.reset(OpS390XMOVBload)
 11724  		v.AuxInt = off1 + off2
 11725  		v.Aux = mergeSym(sym1, sym2)
 11726  		v.AddArg(base)
 11727  		v.AddArg(mem)
 11728  		return true
 11729  	}
 11730  	// match: (MOVBload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
 11731  	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 11732  	// result: (MOVBloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
 11733  	for {
 11734  		off1 := v.AuxInt
 11735  		sym1 := v.Aux
 11736  		_ = v.Args[1]
 11737  		v_0 := v.Args[0]
 11738  		if v_0.Op != OpS390XMOVDaddridx {
 11739  			break
 11740  		}
 11741  		off2 := v_0.AuxInt
 11742  		sym2 := v_0.Aux
 11743  		_ = v_0.Args[1]
 11744  		ptr := v_0.Args[0]
 11745  		idx := v_0.Args[1]
 11746  		mem := v.Args[1]
 11747  		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 11748  			break
 11749  		}
 11750  		v.reset(OpS390XMOVBloadidx)
 11751  		v.AuxInt = off1 + off2
 11752  		v.Aux = mergeSym(sym1, sym2)
 11753  		v.AddArg(ptr)
 11754  		v.AddArg(idx)
 11755  		v.AddArg(mem)
 11756  		return true
 11757  	}
 11758  	// match: (MOVBload [off] {sym} (ADD ptr idx) mem)
 11759  	// cond: ptr.Op != OpSB
 11760  	// result: (MOVBloadidx [off] {sym} ptr idx mem)
 11761  	for {
 11762  		off := v.AuxInt
 11763  		sym := v.Aux
 11764  		_ = v.Args[1]
 11765  		v_0 := v.Args[0]
 11766  		if v_0.Op != OpS390XADD {
 11767  			break
 11768  		}
 11769  		_ = v_0.Args[1]
 11770  		ptr := v_0.Args[0]
 11771  		idx := v_0.Args[1]
 11772  		mem := v.Args[1]
 11773  		if !(ptr.Op != OpSB) {
 11774  			break
 11775  		}
 11776  		v.reset(OpS390XMOVBloadidx)
 11777  		v.AuxInt = off
 11778  		v.Aux = sym
 11779  		v.AddArg(ptr)
 11780  		v.AddArg(idx)
 11781  		v.AddArg(mem)
 11782  		return true
 11783  	}
 11784  	return false
 11785  }
 11786  func rewriteValueS390X_OpS390XMOVBloadidx_0(v *Value) bool {
 11787  	// match: (MOVBloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
 11788  	// cond: is20Bit(c+d)
 11789  	// result: (MOVBloadidx [c+d] {sym} ptr idx mem)
 11790  	for {
 11791  		c := v.AuxInt
 11792  		sym := v.Aux
 11793  		_ = v.Args[2]
 11794  		v_0 := v.Args[0]
 11795  		if v_0.Op != OpS390XADDconst {
 11796  			break
 11797  		}
 11798  		d := v_0.AuxInt
 11799  		ptr := v_0.Args[0]
 11800  		idx := v.Args[1]
 11801  		mem := v.Args[2]
 11802  		if !(is20Bit(c + d)) {
 11803  			break
 11804  		}
 11805  		v.reset(OpS390XMOVBloadidx)
 11806  		v.AuxInt = c + d
 11807  		v.Aux = sym
 11808  		v.AddArg(ptr)
 11809  		v.AddArg(idx)
 11810  		v.AddArg(mem)
 11811  		return true
 11812  	}
 11813  	// match: (MOVBloadidx [c] {sym} idx (ADDconst [d] ptr) mem)
 11814  	// cond: is20Bit(c+d)
 11815  	// result: (MOVBloadidx [c+d] {sym} ptr idx mem)
 11816  	for {
 11817  		c := v.AuxInt
 11818  		sym := v.Aux
 11819  		_ = v.Args[2]
 11820  		idx := v.Args[0]
 11821  		v_1 := v.Args[1]
 11822  		if v_1.Op != OpS390XADDconst {
 11823  			break
 11824  		}
 11825  		d := v_1.AuxInt
 11826  		ptr := v_1.Args[0]
 11827  		mem := v.Args[2]
 11828  		if !(is20Bit(c + d)) {
 11829  			break
 11830  		}
 11831  		v.reset(OpS390XMOVBloadidx)
 11832  		v.AuxInt = c + d
 11833  		v.Aux = sym
 11834  		v.AddArg(ptr)
 11835  		v.AddArg(idx)
 11836  		v.AddArg(mem)
 11837  		return true
 11838  	}
 11839  	// match: (MOVBloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
 11840  	// cond: is20Bit(c+d)
 11841  	// result: (MOVBloadidx [c+d] {sym} ptr idx mem)
 11842  	for {
 11843  		c := v.AuxInt
 11844  		sym := v.Aux
 11845  		_ = v.Args[2]
 11846  		ptr := v.Args[0]
 11847  		v_1 := v.Args[1]
 11848  		if v_1.Op != OpS390XADDconst {
 11849  			break
 11850  		}
 11851  		d := v_1.AuxInt
 11852  		idx := v_1.Args[0]
 11853  		mem := v.Args[2]
 11854  		if !(is20Bit(c + d)) {
 11855  			break
 11856  		}
 11857  		v.reset(OpS390XMOVBloadidx)
 11858  		v.AuxInt = c + d
 11859  		v.Aux = sym
 11860  		v.AddArg(ptr)
 11861  		v.AddArg(idx)
 11862  		v.AddArg(mem)
 11863  		return true
 11864  	}
 11865  	// match: (MOVBloadidx [c] {sym} (ADDconst [d] idx) ptr mem)
 11866  	// cond: is20Bit(c+d)
 11867  	// result: (MOVBloadidx [c+d] {sym} ptr idx mem)
 11868  	for {
 11869  		c := v.AuxInt
 11870  		sym := v.Aux
 11871  		_ = v.Args[2]
 11872  		v_0 := v.Args[0]
 11873  		if v_0.Op != OpS390XADDconst {
 11874  			break
 11875  		}
 11876  		d := v_0.AuxInt
 11877  		idx := v_0.Args[0]
 11878  		ptr := v.Args[1]
 11879  		mem := v.Args[2]
 11880  		if !(is20Bit(c + d)) {
 11881  			break
 11882  		}
 11883  		v.reset(OpS390XMOVBloadidx)
 11884  		v.AuxInt = c + d
 11885  		v.Aux = sym
 11886  		v.AddArg(ptr)
 11887  		v.AddArg(idx)
 11888  		v.AddArg(mem)
 11889  		return true
 11890  	}
 11891  	return false
 11892  }
 11893  func rewriteValueS390X_OpS390XMOVBreg_0(v *Value) bool {
 11894  	b := v.Block
 11895  	_ = b
 11896  	typ := &b.Func.Config.Types
 11897  	_ = typ
 11898  	// match: (MOVBreg x:(MOVBload _ _))
 11899  	// cond:
 11900  	// result: (MOVDreg x)
 11901  	for {
 11902  		x := v.Args[0]
 11903  		if x.Op != OpS390XMOVBload {
 11904  			break
 11905  		}
 11906  		_ = x.Args[1]
 11907  		v.reset(OpS390XMOVDreg)
 11908  		v.AddArg(x)
 11909  		return true
 11910  	}
 11911  	// match: (MOVBreg x:(Arg <t>))
 11912  	// cond: is8BitInt(t) && isSigned(t)
 11913  	// result: (MOVDreg x)
 11914  	for {
 11915  		x := v.Args[0]
 11916  		if x.Op != OpArg {
 11917  			break
 11918  		}
 11919  		t := x.Type
 11920  		if !(is8BitInt(t) && isSigned(t)) {
 11921  			break
 11922  		}
 11923  		v.reset(OpS390XMOVDreg)
 11924  		v.AddArg(x)
 11925  		return true
 11926  	}
 11927  	// match: (MOVBreg x:(MOVBreg _))
 11928  	// cond:
 11929  	// result: (MOVDreg x)
 11930  	for {
 11931  		x := v.Args[0]
 11932  		if x.Op != OpS390XMOVBreg {
 11933  			break
 11934  		}
 11935  		v.reset(OpS390XMOVDreg)
 11936  		v.AddArg(x)
 11937  		return true
 11938  	}
 11939  	// match: (MOVBreg (MOVBZreg x))
 11940  	// cond:
 11941  	// result: (MOVBreg x)
 11942  	for {
 11943  		v_0 := v.Args[0]
 11944  		if v_0.Op != OpS390XMOVBZreg {
 11945  			break
 11946  		}
 11947  		x := v_0.Args[0]
 11948  		v.reset(OpS390XMOVBreg)
 11949  		v.AddArg(x)
 11950  		return true
 11951  	}
 11952  	// match: (MOVBreg (MOVDconst [c]))
 11953  	// cond:
 11954  	// result: (MOVDconst [int64(int8(c))])
 11955  	for {
 11956  		v_0 := v.Args[0]
 11957  		if v_0.Op != OpS390XMOVDconst {
 11958  			break
 11959  		}
 11960  		c := v_0.AuxInt
 11961  		v.reset(OpS390XMOVDconst)
 11962  		v.AuxInt = int64(int8(c))
 11963  		return true
 11964  	}
 11965  	// match: (MOVBreg x:(MOVBZload [off] {sym} ptr mem))
 11966  	// cond: x.Uses == 1 && clobber(x)
 11967  	// result: @x.Block (MOVBload <v.Type> [off] {sym} ptr mem)
 11968  	for {
 11969  		x := v.Args[0]
 11970  		if x.Op != OpS390XMOVBZload {
 11971  			break
 11972  		}
 11973  		off := x.AuxInt
 11974  		sym := x.Aux
 11975  		_ = x.Args[1]
 11976  		ptr := x.Args[0]
 11977  		mem := x.Args[1]
 11978  		if !(x.Uses == 1 && clobber(x)) {
 11979  			break
 11980  		}
 11981  		b = x.Block
 11982  		v0 := b.NewValue0(x.Pos, OpS390XMOVBload, v.Type)
 11983  		v.reset(OpCopy)
 11984  		v.AddArg(v0)
 11985  		v0.AuxInt = off
 11986  		v0.Aux = sym
 11987  		v0.AddArg(ptr)
 11988  		v0.AddArg(mem)
 11989  		return true
 11990  	}
 11991  	// match: (MOVBreg x:(MOVBload [off] {sym} ptr mem))
 11992  	// cond: x.Uses == 1 && clobber(x)
 11993  	// result: @x.Block (MOVBload <v.Type> [off] {sym} ptr mem)
 11994  	for {
 11995  		x := v.Args[0]
 11996  		if x.Op != OpS390XMOVBload {
 11997  			break
 11998  		}
 11999  		off := x.AuxInt
 12000  		sym := x.Aux
 12001  		_ = x.Args[1]
 12002  		ptr := x.Args[0]
 12003  		mem := x.Args[1]
 12004  		if !(x.Uses == 1 && clobber(x)) {
 12005  			break
 12006  		}
 12007  		b = x.Block
 12008  		v0 := b.NewValue0(x.Pos, OpS390XMOVBload, v.Type)
 12009  		v.reset(OpCopy)
 12010  		v.AddArg(v0)
 12011  		v0.AuxInt = off
 12012  		v0.Aux = sym
 12013  		v0.AddArg(ptr)
 12014  		v0.AddArg(mem)
 12015  		return true
 12016  	}
 12017  	// match: (MOVBreg x:(MOVBZloadidx [off] {sym} ptr idx mem))
 12018  	// cond: x.Uses == 1 && clobber(x)
 12019  	// result: @x.Block (MOVBloadidx <v.Type> [off] {sym} ptr idx mem)
 12020  	for {
 12021  		x := v.Args[0]
 12022  		if x.Op != OpS390XMOVBZloadidx {
 12023  			break
 12024  		}
 12025  		off := x.AuxInt
 12026  		sym := x.Aux
 12027  		_ = x.Args[2]
 12028  		ptr := x.Args[0]
 12029  		idx := x.Args[1]
 12030  		mem := x.Args[2]
 12031  		if !(x.Uses == 1 && clobber(x)) {
 12032  			break
 12033  		}
 12034  		b = x.Block
 12035  		v0 := b.NewValue0(v.Pos, OpS390XMOVBloadidx, v.Type)
 12036  		v.reset(OpCopy)
 12037  		v.AddArg(v0)
 12038  		v0.AuxInt = off
 12039  		v0.Aux = sym
 12040  		v0.AddArg(ptr)
 12041  		v0.AddArg(idx)
 12042  		v0.AddArg(mem)
 12043  		return true
 12044  	}
 12045  	// match: (MOVBreg x:(MOVBloadidx [off] {sym} ptr idx mem))
 12046  	// cond: x.Uses == 1 && clobber(x)
 12047  	// result: @x.Block (MOVBloadidx <v.Type> [off] {sym} ptr idx mem)
 12048  	for {
 12049  		x := v.Args[0]
 12050  		if x.Op != OpS390XMOVBloadidx {
 12051  			break
 12052  		}
 12053  		off := x.AuxInt
 12054  		sym := x.Aux
 12055  		_ = x.Args[2]
 12056  		ptr := x.Args[0]
 12057  		idx := x.Args[1]
 12058  		mem := x.Args[2]
 12059  		if !(x.Uses == 1 && clobber(x)) {
 12060  			break
 12061  		}
 12062  		b = x.Block
 12063  		v0 := b.NewValue0(v.Pos, OpS390XMOVBloadidx, v.Type)
 12064  		v.reset(OpCopy)
 12065  		v.AddArg(v0)
 12066  		v0.AuxInt = off
 12067  		v0.Aux = sym
 12068  		v0.AddArg(ptr)
 12069  		v0.AddArg(idx)
 12070  		v0.AddArg(mem)
 12071  		return true
 12072  	}
 12073  	// match: (MOVBreg (ANDWconst [m] x))
 12074  	// cond: int8(m) >= 0
 12075  	// result: (MOVWZreg (ANDWconst <typ.UInt32> [int64( uint8(m))] x))
 12076  	for {
 12077  		v_0 := v.Args[0]
 12078  		if v_0.Op != OpS390XANDWconst {
 12079  			break
 12080  		}
 12081  		m := v_0.AuxInt
 12082  		x := v_0.Args[0]
 12083  		if !(int8(m) >= 0) {
 12084  			break
 12085  		}
 12086  		v.reset(OpS390XMOVWZreg)
 12087  		v0 := b.NewValue0(v.Pos, OpS390XANDWconst, typ.UInt32)
 12088  		v0.AuxInt = int64(uint8(m))
 12089  		v0.AddArg(x)
 12090  		v.AddArg(v0)
 12091  		return true
 12092  	}
 12093  	return false
 12094  }
 12095  func rewriteValueS390X_OpS390XMOVBstore_0(v *Value) bool {
 12096  	// match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem)
 12097  	// cond:
 12098  	// result: (MOVBstore [off] {sym} ptr x mem)
 12099  	for {
 12100  		off := v.AuxInt
 12101  		sym := v.Aux
 12102  		_ = v.Args[2]
 12103  		ptr := v.Args[0]
 12104  		v_1 := v.Args[1]
 12105  		if v_1.Op != OpS390XMOVBreg {
 12106  			break
 12107  		}
 12108  		x := v_1.Args[0]
 12109  		mem := v.Args[2]
 12110  		v.reset(OpS390XMOVBstore)
 12111  		v.AuxInt = off
 12112  		v.Aux = sym
 12113  		v.AddArg(ptr)
 12114  		v.AddArg(x)
 12115  		v.AddArg(mem)
 12116  		return true
 12117  	}
 12118  	// match: (MOVBstore [off] {sym} ptr (MOVBZreg x) mem)
 12119  	// cond:
 12120  	// result: (MOVBstore [off] {sym} ptr x mem)
 12121  	for {
 12122  		off := v.AuxInt
 12123  		sym := v.Aux
 12124  		_ = v.Args[2]
 12125  		ptr := v.Args[0]
 12126  		v_1 := v.Args[1]
 12127  		if v_1.Op != OpS390XMOVBZreg {
 12128  			break
 12129  		}
 12130  		x := v_1.Args[0]
 12131  		mem := v.Args[2]
 12132  		v.reset(OpS390XMOVBstore)
 12133  		v.AuxInt = off
 12134  		v.Aux = sym
 12135  		v.AddArg(ptr)
 12136  		v.AddArg(x)
 12137  		v.AddArg(mem)
 12138  		return true
 12139  	}
 12140  	// match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem)
 12141  	// cond: is20Bit(off1+off2)
 12142  	// result: (MOVBstore [off1+off2] {sym} ptr val mem)
 12143  	for {
 12144  		off1 := v.AuxInt
 12145  		sym := v.Aux
 12146  		_ = v.Args[2]
 12147  		v_0 := v.Args[0]
 12148  		if v_0.Op != OpS390XADDconst {
 12149  			break
 12150  		}
 12151  		off2 := v_0.AuxInt
 12152  		ptr := v_0.Args[0]
 12153  		val := v.Args[1]
 12154  		mem := v.Args[2]
 12155  		if !(is20Bit(off1 + off2)) {
 12156  			break
 12157  		}
 12158  		v.reset(OpS390XMOVBstore)
 12159  		v.AuxInt = off1 + off2
 12160  		v.Aux = sym
 12161  		v.AddArg(ptr)
 12162  		v.AddArg(val)
 12163  		v.AddArg(mem)
 12164  		return true
 12165  	}
 12166  	// match: (MOVBstore [off] {sym} ptr (MOVDconst [c]) mem)
 12167  	// cond: is20Bit(off) && ptr.Op != OpSB
 12168  	// result: (MOVBstoreconst [makeValAndOff(int64(int8(c)),off)] {sym} ptr mem)
 12169  	for {
 12170  		off := v.AuxInt
 12171  		sym := v.Aux
 12172  		_ = v.Args[2]
 12173  		ptr := v.Args[0]
 12174  		v_1 := v.Args[1]
 12175  		if v_1.Op != OpS390XMOVDconst {
 12176  			break
 12177  		}
 12178  		c := v_1.AuxInt
 12179  		mem := v.Args[2]
 12180  		if !(is20Bit(off) && ptr.Op != OpSB) {
 12181  			break
 12182  		}
 12183  		v.reset(OpS390XMOVBstoreconst)
 12184  		v.AuxInt = makeValAndOff(int64(int8(c)), off)
 12185  		v.Aux = sym
 12186  		v.AddArg(ptr)
 12187  		v.AddArg(mem)
 12188  		return true
 12189  	}
 12190  	// match: (MOVBstore [off1] {sym1} (MOVDaddr [off2] {sym2} base) val mem)
 12191  	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 12192  	// result: (MOVBstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
 12193  	for {
 12194  		off1 := v.AuxInt
 12195  		sym1 := v.Aux
 12196  		_ = v.Args[2]
 12197  		v_0 := v.Args[0]
 12198  		if v_0.Op != OpS390XMOVDaddr {
 12199  			break
 12200  		}
 12201  		off2 := v_0.AuxInt
 12202  		sym2 := v_0.Aux
 12203  		base := v_0.Args[0]
 12204  		val := v.Args[1]
 12205  		mem := v.Args[2]
 12206  		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 12207  			break
 12208  		}
 12209  		v.reset(OpS390XMOVBstore)
 12210  		v.AuxInt = off1 + off2
 12211  		v.Aux = mergeSym(sym1, sym2)
 12212  		v.AddArg(base)
 12213  		v.AddArg(val)
 12214  		v.AddArg(mem)
 12215  		return true
 12216  	}
 12217  	// match: (MOVBstore [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) val mem)
 12218  	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
 12219  	// result: (MOVBstoreidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
 12220  	for {
 12221  		off1 := v.AuxInt
 12222  		sym1 := v.Aux
 12223  		_ = v.Args[2]
 12224  		v_0 := v.Args[0]
 12225  		if v_0.Op != OpS390XMOVDaddridx {
 12226  			break
 12227  		}
 12228  		off2 := v_0.AuxInt
 12229  		sym2 := v_0.Aux
 12230  		_ = v_0.Args[1]
 12231  		ptr := v_0.Args[0]
 12232  		idx := v_0.Args[1]
 12233  		val := v.Args[1]
 12234  		mem := v.Args[2]
 12235  		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
 12236  			break
 12237  		}
 12238  		v.reset(OpS390XMOVBstoreidx)
 12239  		v.AuxInt = off1 + off2
 12240  		v.Aux = mergeSym(sym1, sym2)
 12241  		v.AddArg(ptr)
 12242  		v.AddArg(idx)
 12243  		v.AddArg(val)
 12244  		v.AddArg(mem)
 12245  		return true
 12246  	}
 12247  	// match: (MOVBstore [off] {sym} (ADD ptr idx) val mem)
 12248  	// cond: ptr.Op != OpSB
 12249  	// result: (MOVBstoreidx [off] {sym} ptr idx val mem)
 12250  	for {
 12251  		off := v.AuxInt
 12252  		sym := v.Aux
 12253  		_ = v.Args[2]
 12254  		v_0 := v.Args[0]
 12255  		if v_0.Op != OpS390XADD {
 12256  			break
 12257  		}
 12258  		_ = v_0.Args[1]
 12259  		ptr := v_0.Args[0]
 12260  		idx := v_0.Args[1]
 12261  		val := v.Args[1]
 12262  		mem := v.Args[2]
 12263  		if !(ptr.Op != OpSB) {
 12264  			break
 12265  		}
 12266  		v.reset(OpS390XMOVBstoreidx)
 12267  		v.AuxInt = off
 12268  		v.Aux = sym
 12269  		v.AddArg(ptr)
 12270  		v.AddArg(idx)
 12271  		v.AddArg(val)
 12272  		v.AddArg(mem)
 12273  		return true
 12274  	}
 12275  	// match: (MOVBstore [i] {s} p w x:(MOVBstore [i-1] {s} p (SRDconst [8] w) mem))
 12276  	// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 12277  	// result: (MOVHstore [i-1] {s} p w mem)
 12278  	for {
 12279  		i := v.AuxInt
 12280  		s := v.Aux
 12281  		_ = v.Args[2]
 12282  		p := v.Args[0]
 12283  		w := v.Args[1]
 12284  		x := v.Args[2]
 12285  		if x.Op != OpS390XMOVBstore {
 12286  			break
 12287  		}
 12288  		if x.AuxInt != i-1 {
 12289  			break
 12290  		}
 12291  		if x.Aux != s {
 12292  			break
 12293  		}
 12294  		_ = x.Args[2]
 12295  		if p != x.Args[0] {
 12296  			break
 12297  		}
 12298  		x_1 := x.Args[1]
 12299  		if x_1.Op != OpS390XSRDconst {
 12300  			break
 12301  		}
 12302  		if x_1.AuxInt != 8 {
 12303  			break
 12304  		}
 12305  		if w != x_1.Args[0] {
 12306  			break
 12307  		}
 12308  		mem := x.Args[2]
 12309  		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 12310  			break
 12311  		}
 12312  		v.reset(OpS390XMOVHstore)
 12313  		v.AuxInt = i - 1
 12314  		v.Aux = s
 12315  		v.AddArg(p)
 12316  		v.AddArg(w)
 12317  		v.AddArg(mem)
 12318  		return true
 12319  	}
 12320  	// match: (MOVBstore [i] {s} p w0:(SRDconst [j] w) x:(MOVBstore [i-1] {s} p (SRDconst [j+8] w) mem))
 12321  	// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 12322  	// result: (MOVHstore [i-1] {s} p w0 mem)
 12323  	for {
 12324  		i := v.AuxInt
 12325  		s := v.Aux
 12326  		_ = v.Args[2]
 12327  		p := v.Args[0]
 12328  		w0 := v.Args[1]
 12329  		if w0.Op != OpS390XSRDconst {
 12330  			break
 12331  		}
 12332  		j := w0.AuxInt
 12333  		w := w0.Args[0]
 12334  		x := v.Args[2]
 12335  		if x.Op != OpS390XMOVBstore {
 12336  			break
 12337  		}
 12338  		if x.AuxInt != i-1 {
 12339  			break
 12340  		}
 12341  		if x.Aux != s {
 12342  			break
 12343  		}
 12344  		_ = x.Args[2]
 12345  		if p != x.Args[0] {
 12346  			break
 12347  		}
 12348  		x_1 := x.Args[1]
 12349  		if x_1.Op != OpS390XSRDconst {
 12350  			break
 12351  		}
 12352  		if x_1.AuxInt != j+8 {
 12353  			break
 12354  		}
 12355  		if w != x_1.Args[0] {
 12356  			break
 12357  		}
 12358  		mem := x.Args[2]
 12359  		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 12360  			break
 12361  		}
 12362  		v.reset(OpS390XMOVHstore)
 12363  		v.AuxInt = i - 1
 12364  		v.Aux = s
 12365  		v.AddArg(p)
 12366  		v.AddArg(w0)
 12367  		v.AddArg(mem)
 12368  		return true
 12369  	}
 12370  	// match: (MOVBstore [i] {s} p w x:(MOVBstore [i-1] {s} p (SRWconst [8] w) mem))
 12371  	// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 12372  	// result: (MOVHstore [i-1] {s} p w mem)
 12373  	for {
 12374  		i := v.AuxInt
 12375  		s := v.Aux
 12376  		_ = v.Args[2]
 12377  		p := v.Args[0]
 12378  		w := v.Args[1]
 12379  		x := v.Args[2]
 12380  		if x.Op != OpS390XMOVBstore {
 12381  			break
 12382  		}
 12383  		if x.AuxInt != i-1 {
 12384  			break
 12385  		}
 12386  		if x.Aux != s {
 12387  			break
 12388  		}
 12389  		_ = x.Args[2]
 12390  		if p != x.Args[0] {
 12391  			break
 12392  		}
 12393  		x_1 := x.Args[1]
 12394  		if x_1.Op != OpS390XSRWconst {
 12395  			break
 12396  		}
 12397  		if x_1.AuxInt != 8 {
 12398  			break
 12399  		}
 12400  		if w != x_1.Args[0] {
 12401  			break
 12402  		}
 12403  		mem := x.Args[2]
 12404  		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 12405  			break
 12406  		}
 12407  		v.reset(OpS390XMOVHstore)
 12408  		v.AuxInt = i - 1
 12409  		v.Aux = s
 12410  		v.AddArg(p)
 12411  		v.AddArg(w)
 12412  		v.AddArg(mem)
 12413  		return true
 12414  	}
 12415  	return false
 12416  }
 12417  func rewriteValueS390X_OpS390XMOVBstore_10(v *Value) bool {
 12418  	// match: (MOVBstore [i] {s} p w0:(SRWconst [j] w) x:(MOVBstore [i-1] {s} p (SRWconst [j+8] w) mem))
 12419  	// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 12420  	// result: (MOVHstore [i-1] {s} p w0 mem)
 12421  	for {
 12422  		i := v.AuxInt
 12423  		s := v.Aux
 12424  		_ = v.Args[2]
 12425  		p := v.Args[0]
 12426  		w0 := v.Args[1]
 12427  		if w0.Op != OpS390XSRWconst {
 12428  			break
 12429  		}
 12430  		j := w0.AuxInt
 12431  		w := w0.Args[0]
 12432  		x := v.Args[2]
 12433  		if x.Op != OpS390XMOVBstore {
 12434  			break
 12435  		}
 12436  		if x.AuxInt != i-1 {
 12437  			break
 12438  		}
 12439  		if x.Aux != s {
 12440  			break
 12441  		}
 12442  		_ = x.Args[2]
 12443  		if p != x.Args[0] {
 12444  			break
 12445  		}
 12446  		x_1 := x.Args[1]
 12447  		if x_1.Op != OpS390XSRWconst {
 12448  			break
 12449  		}
 12450  		if x_1.AuxInt != j+8 {
 12451  			break
 12452  		}
 12453  		if w != x_1.Args[0] {
 12454  			break
 12455  		}
 12456  		mem := x.Args[2]
 12457  		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 12458  			break
 12459  		}
 12460  		v.reset(OpS390XMOVHstore)
 12461  		v.AuxInt = i - 1
 12462  		v.Aux = s
 12463  		v.AddArg(p)
 12464  		v.AddArg(w0)
 12465  		v.AddArg(mem)
 12466  		return true
 12467  	}
 12468  	// match: (MOVBstore [i] {s} p (SRDconst [8] w) x:(MOVBstore [i-1] {s} p w mem))
 12469  	// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 12470  	// result: (MOVHBRstore [i-1] {s} p w mem)
 12471  	for {
 12472  		i := v.AuxInt
 12473  		s := v.Aux
 12474  		_ = v.Args[2]
 12475  		p := v.Args[0]
 12476  		v_1 := v.Args[1]
 12477  		if v_1.Op != OpS390XSRDconst {
 12478  			break
 12479  		}
 12480  		if v_1.AuxInt != 8 {
 12481  			break
 12482  		}
 12483  		w := v_1.Args[0]
 12484  		x := v.Args[2]
 12485  		if x.Op != OpS390XMOVBstore {
 12486  			break
 12487  		}
 12488  		if x.AuxInt != i-1 {
 12489  			break
 12490  		}
 12491  		if x.Aux != s {
 12492  			break
 12493  		}
 12494  		_ = x.Args[2]
 12495  		if p != x.Args[0] {
 12496  			break
 12497  		}
 12498  		if w != x.Args[1] {
 12499  			break
 12500  		}
 12501  		mem := x.Args[2]
 12502  		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 12503  			break
 12504  		}
 12505  		v.reset(OpS390XMOVHBRstore)
 12506  		v.AuxInt = i - 1
 12507  		v.Aux = s
 12508  		v.AddArg(p)
 12509  		v.AddArg(w)
 12510  		v.AddArg(mem)
 12511  		return true
 12512  	}
 12513  	// match: (MOVBstore [i] {s} p (SRDconst [j] w) x:(MOVBstore [i-1] {s} p w0:(SRDconst [j-8] w) mem))
 12514  	// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 12515  	// result: (MOVHBRstore [i-1] {s} p w0 mem)
 12516  	for {
 12517  		i := v.AuxInt
 12518  		s := v.Aux
 12519  		_ = v.Args[2]
 12520  		p := v.Args[0]
 12521  		v_1 := v.Args[1]
 12522  		if v_1.Op != OpS390XSRDconst {
 12523  			break
 12524  		}
 12525  		j := v_1.AuxInt
 12526  		w := v_1.Args[0]
 12527  		x := v.Args[2]
 12528  		if x.Op != OpS390XMOVBstore {
 12529  			break
 12530  		}
 12531  		if x.AuxInt != i-1 {
 12532  			break
 12533  		}
 12534  		if x.Aux != s {
 12535  			break
 12536  		}
 12537  		_ = x.Args[2]
 12538  		if p != x.Args[0] {
 12539  			break
 12540  		}
 12541  		w0 := x.Args[1]
 12542  		if w0.Op != OpS390XSRDconst {
 12543  			break
 12544  		}
 12545  		if w0.AuxInt != j-8 {
 12546  			break
 12547  		}
 12548  		if w != w0.Args[0] {
 12549  			break
 12550  		}
 12551  		mem := x.Args[2]
 12552  		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 12553  			break
 12554  		}
 12555  		v.reset(OpS390XMOVHBRstore)
 12556  		v.AuxInt = i - 1
 12557  		v.Aux = s
 12558  		v.AddArg(p)
 12559  		v.AddArg(w0)
 12560  		v.AddArg(mem)
 12561  		return true
 12562  	}
 12563  	// match: (MOVBstore [i] {s} p (SRWconst [8] w) x:(MOVBstore [i-1] {s} p w mem))
 12564  	// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 12565  	// result: (MOVHBRstore [i-1] {s} p w mem)
 12566  	for {
 12567  		i := v.AuxInt
 12568  		s := v.Aux
 12569  		_ = v.Args[2]
 12570  		p := v.Args[0]
 12571  		v_1 := v.Args[1]
 12572  		if v_1.Op != OpS390XSRWconst {
 12573  			break
 12574  		}
 12575  		if v_1.AuxInt != 8 {
 12576  			break
 12577  		}
 12578  		w := v_1.Args[0]
 12579  		x := v.Args[2]
 12580  		if x.Op != OpS390XMOVBstore {
 12581  			break
 12582  		}
 12583  		if x.AuxInt != i-1 {
 12584  			break
 12585  		}
 12586  		if x.Aux != s {
 12587  			break
 12588  		}
 12589  		_ = x.Args[2]
 12590  		if p != x.Args[0] {
 12591  			break
 12592  		}
 12593  		if w != x.Args[1] {
 12594  			break
 12595  		}
 12596  		mem := x.Args[2]
 12597  		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 12598  			break
 12599  		}
 12600  		v.reset(OpS390XMOVHBRstore)
 12601  		v.AuxInt = i - 1
 12602  		v.Aux = s
 12603  		v.AddArg(p)
 12604  		v.AddArg(w)
 12605  		v.AddArg(mem)
 12606  		return true
 12607  	}
 12608  	// match: (MOVBstore [i] {s} p (SRWconst [j] w) x:(MOVBstore [i-1] {s} p w0:(SRWconst [j-8] w) mem))
 12609  	// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
 12610  	// result: (MOVHBRstore [i-1] {s} p w0 mem)
 12611  	for {
 12612  		i := v.AuxInt
 12613  		s := v.Aux
 12614  		_ = v.Args[2]
 12615  		p := v.Args[0]
 12616  		v_1 := v.Args[1]
 12617  		if v_1.Op != OpS390XSRWconst {
 12618  			break
 12619  		}
 12620  		j := v_1.AuxInt
 12621  		w := v_1.Args[0]
 12622  		x := v.Args[2]
 12623  		if x.Op != OpS390XMOVBstore {
 12624  			break
 12625  		}
 12626  		if x.AuxInt != i-1 {
 12627  			break
 12628  		}
 12629  		if x.Aux != s {
 12630  			break
 12631  		}
 12632  		_ = x.Args[2]
 12633  		if p != x.Args[0] {
 12634  			break
 12635  		}
 12636  		w0 := x.Args[1]
 12637  		if w0.Op != OpS390XSRWconst {
 12638  			break
 12639  		}
 12640  		if w0.AuxInt != j-8 {
 12641  			break
 12642  		}
 12643  		if w != w0.Args[0] {
 12644  			break
 12645  		}
 12646  		mem := x.Args[2]
 12647  		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
 12648  			break
 12649  		}
 12650  		v.reset(OpS390XMOVHBRstore)
 12651  		v.AuxInt = i - 1
 12652  		v.Aux = s
 12653  		v.AddArg(p)
 12654  		v.AddArg(w0)
 12655  		v.AddArg(mem)
 12656  		return true
 12657  	}
 12658  	return false
 12659  }
 12660  func rewriteValueS390X_OpS390XMOVBstoreconst_0(v *Value) bool {
 12661  	// match: (MOVBstoreconst [sc] {s} (ADDconst [off] ptr) mem)
 12662  	// cond: is20Bit(ValAndOff(sc).Off()+off)
 12663  	// result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
 12664  	for {
 12665  		sc := v.AuxInt
 12666  		s := v.Aux
 12667  		_ = v.Args[1]
 12668  		v_0 := v.Args[0]
 12669  		if v_0.Op != OpS390XADDconst {
 12670  			break
 12671  		}
 12672  		off := v_0.AuxInt
 12673  		ptr := v_0.Args[0]
 12674  		mem := v.Args[1]
 12675  		if !(is20Bit(ValAndOff(sc).Off() + off)) {
 12676  			break
 12677  		}
 12678  		v.reset(OpS390XMOVBstoreconst)
 12679  		v.AuxInt = ValAndOff(sc).add(off)
 12680  		v.Aux = s
 12681  		v.AddArg(ptr)
 12682  		v.AddArg(mem)
 12683  		return true
 12684  	}
 12685  	// match: (MOVBstoreconst [sc] {sym1} (MOVDaddr [off] {sym2} ptr) mem)
 12686  	// cond: ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
 12687  	// result: (MOVBstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
 12688  	for {
 12689  		sc := v.AuxInt
 12690  		sym1 := v.Aux
 12691  		_ = v.Args[1]
 12692  		v_0 := v.Args[0]
 12693  		if v_0.Op != OpS390XMOVDaddr {
 12694  			break
 12695  		}
 12696  		off := v_0.AuxInt
 12697  		sym2 := v_0.Aux
 12698  		ptr := v_0.Args[0]
 12699  		mem := v.Args[1]
 12700  		if !(ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
 12701  			break
 12702  		}
 12703  		v.reset(OpS390XMOVBstoreconst)
 12704  		v.AuxInt = ValAndOff(sc).add(off)
 12705  		v.Aux = mergeSym(sym1, sym2)
 12706  		v.AddArg(ptr)
 12707  		v.AddArg(mem)
 12708  		return true
 12709  	}
 12710  	// match: (MOVBstoreconst [c] {s} p x:(MOVBstoreconst [a] {s} p mem))
 12711  	// cond: p.Op != OpSB && x.Uses == 1 && ValAndOff(a).Off() + 1 == ValAndOff(c).Off() && clobber(x)
 12712  	// result: (MOVHstoreconst [makeValAndOff(ValAndOff(c).Val()&0xff | ValAndOff(a).Val()<<8, ValAndOff(a).Off())] {s} p mem)
 12713  	for {
 12714  		c := v.AuxInt
 12715  		s := v.Aux
 12716  		_ = v.Args[1]
 12717  		p := v.Args[0]
 12718  		x := v.Args[1]
 12719  		if x.Op != OpS390XMOVBstoreconst {
 12720  			break
 12721  		}
 12722  		a := x.AuxInt
 12723  		if x.Aux != s {
 12724  			break
 12725  		}
 12726  		_ = x.Args[1]
 12727  		if p != x.Args[0] {
 12728  			break
 12729  		}
 12730  		mem := x.Args[1]
 12731  		if !(p.Op != OpSB && x.Uses == 1 && ValAndOff(a).Off()+1 == ValAndOff(c).Off() && clobber(x)) {
 12732  			break
 12733  		}
 12734  		v.reset(OpS390XMOVHstoreconst)
 12735  		v.AuxInt = makeValAndOff(ValAndOff(c).Val()&0xff|ValAndOff(a).Val()<<8, ValAndOff(a).Off())
 12736  		v.Aux = s
 12737  		v.AddArg(p)
 12738  		v.AddArg(mem)
 12739  		return true
 12740  	}
 12741  	return false
 12742  }
 12743  func rewriteValueS390X_OpS390XMOVBstoreidx_0(v *Value) bool {
 12744  	// match: (MOVBstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
 12745  	// cond: is20Bit(c+d)
 12746  	// result: (MOVBstoreidx [c+d] {sym} ptr idx val mem)
 12747  	for {
 12748  		c := v.AuxInt
 12749  		sym := v.Aux
 12750  		_ = v.Args[3]
 12751  		v_0 := v.Args[0]
 12752  		if v_0.Op != OpS390XADDconst {
 12753  			break
 12754  		}
 12755  		d := v_0.AuxInt
 12756  		ptr := v_0.Args[0]
 12757  		idx := v.Args[1]
 12758  		val := v.Args[2]
 12759  		mem := v.Args[3]
 12760  		if !(is20Bit(c + d)) {
 12761  			break
 12762  		}
 12763  		v.reset(OpS390XMOVBstoreidx)
 12764  		v.AuxInt = c + d
 12765  		v.Aux = sym
 12766  		v.AddArg(ptr)
 12767  		v.AddArg(idx)
 12768  		v.AddArg(val)
 12769  		v.AddArg(mem)
 12770  		return true
 12771  	}
 12772  	// match: (MOVBstoreidx [c] {sym} idx (ADDconst [d] ptr) val mem)
 12773  	// cond: is20Bit(c+d)
 12774  	// result: (MOVBstoreidx [c+d] {sym} ptr idx val mem)
 12775  	for {
 12776  		c := v.AuxInt
 12777  		sym := v.Aux
 12778  		_ = v.Args[3]
 12779  		idx := v.Args[0]
 12780  		v_1 := v.Args[1]
 12781  		if v_1.Op != OpS390XADDconst {
 12782  			break
 12783  		}
 12784  		d := v_1.AuxInt
 12785  		ptr := v_1.Args[0]
 12786  		val := v.Args[2]
 12787  		mem := v.Args[3]
 12788  		if !(is20Bit(c + d)) {
 12789  			break
 12790  		}
 12791  		v.reset(OpS390XMOVBstoreidx)
 12792  		v.AuxInt = c + d
 12793  		v.Aux = sym
 12794  		v.AddArg(ptr)
 12795  		v.AddArg(idx)
 12796  		v.AddArg(val)
 12797  		v.AddArg(mem)
 12798  		return true
 12799  	}
 12800  	// match: (MOVBstoreidx [c] {sym} ptr (ADDconst [d] idx) val mem)
 12801  	// cond: is20Bit(c+d)
 12802  	// result: (MOVBstoreidx [c+d] {sym} ptr idx val mem)
 12803  	for {
 12804  		c := v.AuxInt
 12805  		sym := v.Aux
 12806  		_ = v.Args[3]
 12807  		ptr := v.Args[0]
 12808  		v_1 := v.Args[1]
 12809  		if v_1.Op != OpS390XADDconst {
 12810  			break
 12811  		}
 12812  		d := v_1.AuxInt
 12813  		idx := v_1.Args[0]
 12814  		val := v.Args[2]
 12815  		mem := v.Args[3]
 12816  		if !(is20Bit(c + d)) {
 12817  			break
 12818  		}
 12819  		v.reset(OpS390XMOVBstoreidx)
 12820  		v.AuxInt = c + d
 12821  		v.Aux = sym
 12822  		v.AddArg(ptr)
 12823  		v.AddArg(idx)
 12824  		v.AddArg(val)
 12825  		v.AddArg(mem)
 12826  		return true
 12827  	}
 12828  	// match: (MOVBstoreidx [c] {sym} (ADDconst [d] idx) ptr val mem)
 12829  	// cond: is20Bit(c+d)
 12830  	// result: (MOVBstoreidx [c+d] {sym} ptr idx val mem)
 12831  	for {
 12832  		c := v.AuxInt
 12833  		sym := v.Aux
 12834  		_ = v.Args[3]
 12835  		v_0 := v.Args[0]
 12836  		if v_0.Op != OpS390XADDconst {
 12837  			break
 12838  		}
 12839  		d := v_0.AuxInt
 12840  		idx := v_0.Args[0]
 12841  		ptr := v.Args[1]
 12842  		val := v.Args[2]
 12843  		mem := v.Args[3]
 12844  		if !(is20Bit(c + d)) {
 12845  			break
 12846  		}
 12847  		v.reset(OpS390XMOVBstoreidx)
 12848  		v.AuxInt = c + d
 12849  		v.Aux = sym
 12850  		v.AddArg(ptr)
 12851  		v.AddArg(idx)
 12852  		v.AddArg(val)
 12853  		v.AddArg(mem)
 12854  		return true
 12855  	}
 12856  	// match: (MOVBstoreidx [i] {s} p idx w x:(MOVBstoreidx [i-1] {s} p idx (SRDconst [8] w) mem))
 12857  	// cond: x.Uses == 1 && clobber(x)
 12858  	// result: (MOVHstoreidx [i-1] {s} p idx w mem)
 12859  	for {
 12860  		i := v.AuxInt
 12861  		s := v.Aux
 12862  		_ = v.Args[3]
 12863  		p := v.Args[0]
 12864  		idx := v.Args[1]
 12865  		w := v.Args[2]
 12866  		x := v.Args[3]
 12867  		if x.Op != OpS390XMOVBstoreidx {
 12868  			break
 12869  		}
 12870  		if x.AuxInt != i-1 {
 12871  			break
 12872  		}
 12873  		if x.Aux != s {
 12874  			break
 12875  		}
 12876  		_ = x.Args[3]
 12877  		if p != x.Args[0] {
 12878  			break
 12879  		}
 12880  		if idx != x.Args[1] {
 12881  			break
 12882  		}
 12883  		x_2 := x.Args[2]
 12884  		if x_2.Op != OpS390XSRDconst {
 12885  			break
 12886  		}
 12887  		if x_2.AuxInt != 8 {
 12888  			break
 12889  		}
 12890  		if w != x_2.Args[0] {
 12891  			break
 12892  		}
 12893  		mem := x.Args[3]
 12894  		if !(x.Uses == 1 && clobber(x)) {
 12895  			break
 12896  		}
 12897  		v.reset(OpS390XMOVHstoreidx)
 12898  		v.AuxInt = i - 1
 12899  		v.Aux = s
 12900  		v.AddArg(p)
 12901  		v.AddArg(idx)
 12902  		v.AddArg(w)
 12903  		v.AddArg(mem)
 12904  		return true
 12905  	}
 12906  	// match: (MOVBstoreidx [i] {s} p idx w x:(MOVBstoreidx [i-1] {s} idx p (SRDconst [8] w) mem))
 12907  	// cond: x.Uses == 1 && clobber(x)
 12908  	// result: (MOVHstoreidx [i-1] {s} p idx w mem)
 12909  	for {
 12910  		i := v.AuxInt
 12911  		s := v.Aux
 12912  		_ = v.Args[3]
 12913  		p := v.Args[0]
 12914  		idx := v.Args[1]
 12915  		w := v.Args[2]
 12916  		x := v.Args[3]
 12917  		if x.Op != OpS390XMOVBstoreidx {
 12918  			break
 12919  		}
 12920  		if x.AuxInt != i-1 {
 12921  			break
 12922  		}
 12923  		if x.Aux != s {
 12924  			break
 12925  		}
 12926  		_ = x.Args[3]
 12927  		if idx != x.Args[0] {
 12928  			break
 12929  		}
 12930  		if p != x.Args[1] {
 12931  			break
 12932  		}
 12933  		x_2 := x.Args[2]
 12934  		if x_2.Op != OpS390XSRDconst {
 12935  			break
 12936  		}
 12937  		if x_2.AuxInt != 8 {
 12938  			break
 12939  		}
 12940  		if w != x_2.Args[0] {
 12941  			break
 12942  		}
 12943  		mem := x.Args[3]
 12944  		if !(x.Uses == 1 && clobber(x)) {
 12945  			break
 12946  		}
 12947  		v.reset(OpS390XMOVHstoreidx)
 12948  		v.AuxInt = i - 1
 12949  		v.Aux = s
 12950  		v.AddArg(p)
 12951  		v.AddArg(idx)
 12952  		v.AddArg(w)
 12953  		v.AddArg(mem)
 12954  		return true
 12955  	}
 12956  	// match: (MOVBstoreidx [i] {s} idx p w x:(MOVBstoreidx [i-1] {s} p idx (SRDconst [8] w) mem))
 12957  	// cond: x.Uses == 1 && clobber(x)
 12958  	// result: (MOVHstoreidx [i-1] {s} p idx w mem)
 12959  	for {
 12960  		i := v.AuxInt
 12961  		s := v.Aux
 12962  		_ = v.Args[3]
 12963  		idx := v.Args[0]
 12964  		p := v.Args[1]
 12965  		w := v.Args[2]
 12966  		x := v.Args[3]
 12967  		if x.Op != OpS390XMOVBstoreidx {
 12968  			break
 12969  		}
 12970  		if x.AuxInt != i-1 {
 12971  			break
 12972  		}
 12973  		if x.Aux != s {
 12974  			break
 12975  		}
 12976  		_ = x.Args[3]
 12977  		if p != x.Args[0] {
 12978  			break
 12979  		}
 12980  		if idx != x.Args[1] {
 12981  			break
 12982  		}
 12983  		x_2 := x.Args[2]
 12984  		if x_2.Op != OpS390XSRDconst {
 12985  			break
 12986  		}
 12987  		if x_2.AuxInt != 8 {
 12988  			break
 12989  		}
 12990  		if w != x_2.Args[0] {
 12991  			break
 12992  		}
 12993  		mem := x.Args[3]
 12994  		if !(x.Uses == 1 && clobber(x)) {
 12995  			break
 12996  		}
 12997  		v.reset(OpS390XMOVHstoreidx)
 12998  		v.AuxInt = i - 1
 12999  		v.Aux = s
 13000  		v.AddArg(p)
 13001  		v.AddArg(idx)
 13002  		v.AddArg(w)
 13003  		v.AddArg(mem)
 13004  		return true
 13005  	}
 13006  	// match: (MOVBstoreidx [i] {s} idx p w x:(MOVBstoreidx [i-1] {s} idx p (SRDconst [8] w) mem))
 13007  	// cond: x.Uses == 1 && clobber(x)
 13008  	// result: (MOVHstoreidx [i-1] {s} p idx w mem)
 13009  	for {
 13010  		i := v.AuxInt
 13011  		s := v.Aux
 13012  		_ = v.Args[3]
 13013  		idx := v.Args[0]
 13014  		p := v.Args[1]
 13015  		w := v.Args[2]
 13016  		x := v.Args[3]
 13017  		if x.Op != OpS390XMOVBstoreidx {
 13018  			break
 13019  		}
 13020  		if x.AuxInt != i-1 {
 13021  			break
 13022  		}
 13023  		if x.Aux != s {
 13024  			break
 13025  		}
 13026  		_ = x.Args[3]
 13027  		if idx != x.Args[0] {
 13028  			break
 13029  		}
 13030  		if p != x.Args[1] {
 13031  			break
 13032  		}
 13033  		x_2 := x.Args[2]
 13034  		if x_2.Op != OpS390XSRDconst {
 13035  			break
 13036  		}
 13037  		if x_2.AuxInt != 8 {
 13038  			break
 13039  		}
 13040  		if w != x_2.Args[0] {
 13041  			break
 13042  		}
 13043  		mem := x.Args[3]
 13044  		if !(x.Uses == 1 && clobber(x)) {
 13045  			break
 13046  		}
 13047  		v.reset(OpS390XMOVHstoreidx)
 13048  		v.AuxInt = i - 1
 13049  		v.Aux = s
 13050  		v.AddArg(p)
 13051  		v.AddArg(idx)
 13052  		v.AddArg(w)
 13053  		v.AddArg(mem)
 13054  		return true
 13055  	}
 13056  	// match: (MOVBstoreidx [i] {s} p idx w0:(SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx (SRDconst [j+8] w) mem))
 13057  	// cond: x.Uses == 1 && clobber(x)
 13058  	// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
 13059  	for {
 13060  		i := v.AuxInt
 13061  		s := v.Aux
 13062  		_ = v.Args[3]
 13063  		p := v.Args[0]
 13064  		idx := v.Args[1]
 13065  		w0 := v.Args[2]
 13066  		if w0.Op != OpS390XSRDconst {
 13067  			break
 13068  		}
 13069  		j := w0.AuxInt
 13070  		w := w0.Args[0]
 13071  		x := v.Args[3]
 13072  		if x.Op != OpS390XMOVBstoreidx {
 13073  			break
 13074  		}
 13075  		if x.AuxInt != i-1 {
 13076  			break
 13077  		}
 13078  		if x.Aux != s {
 13079  			break
 13080  		}
 13081  		_ = x.Args[3]
 13082  		if p != x.Args[0] {
 13083  			break
 13084  		}
 13085  		if idx != x.Args[1] {
 13086  			break
 13087  		}
 13088  		x_2 := x.Args[2]
 13089  		if x_2.Op != OpS390XSRDconst {
 13090  			break
 13091  		}
 13092  		if x_2.AuxInt != j+8 {
 13093  			break
 13094  		}
 13095  		if w != x_2.Args[0] {
 13096  			break
 13097  		}
 13098  		mem := x.Args[3]
 13099  		if !(x.Uses == 1 && clobber(x)) {
 13100  			break
 13101  		}
 13102  		v.reset(OpS390XMOVHstoreidx)
 13103  		v.AuxInt = i - 1
 13104  		v.Aux = s
 13105  		v.AddArg(p)
 13106  		v.AddArg(idx)
 13107  		v.AddArg(w0)
 13108  		v.AddArg(mem)
 13109  		return true
 13110  	}
 13111  	// match: (MOVBstoreidx [i] {s} p idx w0:(SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p (SRDconst [j+8] w) mem))
 13112  	// cond: x.Uses == 1 && clobber(x)
 13113  	// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
 13114  	for {
 13115  		i := v.AuxInt
 13116  		s := v.Aux
 13117  		_ = v.Args[3]
 13118  		p := v.Args[0]
 13119  		idx := v.Args[1]
 13120  		w0 := v.Args[2]
 13121  		if w0.Op != OpS390XSRDconst {
 13122  			break
 13123  		}
 13124  		j := w0.AuxInt
 13125  		w := w0.Args[0]
 13126  		x := v.Args[3]
 13127  		if x.Op != OpS390XMOVBstoreidx {
 13128  			break
 13129  		}
 13130  		if x.AuxInt != i-1 {
 13131  			break
 13132  		}
 13133  		if x.Aux != s {
 13134  			break
 13135  		}
 13136  		_ = x.Args[3]
 13137  		if idx != x.Args[0] {
 13138  			break
 13139  		}
 13140  		if p != x.Args[1] {
 13141  			break
 13142  		}
 13143  		x_2 := x.Args[2]
 13144  		if x_2.Op != OpS390XSRDconst {
 13145  			break
 13146  		}
 13147  		if x_2.AuxInt != j+8 {
 13148  			break
 13149  		}
 13150  		if w != x_2.Args[0] {
 13151  			break
 13152  		}
 13153  		mem := x.Args[3]
 13154  		if !(x.Uses == 1 && clobber(x)) {
 13155  			break
 13156  		}
 13157  		v.reset(OpS390XMOVHstoreidx)
 13158  		v.AuxInt = i - 1
 13159  		v.Aux = s
 13160  		v.AddArg(p)
 13161  		v.AddArg(idx)
 13162  		v.AddArg(w0)
 13163  		v.AddArg(mem)
 13164  		return true
 13165  	}
 13166  	return false
 13167  }
 13168  func rewriteValueS390X_OpS390XMOVBstoreidx_10(v *Value) bool {
 13169  	// match: (MOVBstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx (SRDconst [j+8] w) mem))
 13170  	// cond: x.Uses == 1 && clobber(x)
 13171  	// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
 13172  	for {
 13173  		i := v.AuxInt
 13174  		s := v.Aux
 13175  		_ = v.Args[3]
 13176  		idx := v.Args[0]
 13177  		p := v.Args[1]
 13178  		w0 := v.Args[2]
 13179  		if w0.Op != OpS390XSRDconst {
 13180  			break
 13181  		}
 13182  		j := w0.AuxInt
 13183  		w := w0.Args[0]
 13184  		x := v.Args[3]
 13185  		if x.Op != OpS390XMOVBstoreidx {
 13186  			break
 13187  		}
 13188  		if x.AuxInt != i-1 {
 13189  			break
 13190  		}
 13191  		if x.Aux != s {
 13192  			break
 13193  		}
 13194  		_ = x.Args[3]
 13195  		if p != x.Args[0] {
 13196  			break
 13197  		}
 13198  		if idx != x.Args[1] {
 13199  			break
 13200  		}
 13201  		x_2 := x.Args[2]
 13202  		if x_2.Op != OpS390XSRDconst {
 13203  			break
 13204  		}
 13205  		if x_2.AuxInt != j+8 {
 13206  			break
 13207  		}
 13208  		if w != x_2.Args[0] {
 13209  			break
 13210  		}
 13211  		mem := x.Args[3]
 13212  		if !(x.Uses == 1 && clobber(x)) {
 13213  			break
 13214  		}
 13215  		v.reset(OpS390XMOVHstoreidx)
 13216  		v.AuxInt = i - 1
 13217  		v.Aux = s
 13218  		v.AddArg(p)
 13219  		v.AddArg(idx)
 13220  		v.AddArg(w0)
 13221  		v.AddArg(mem)
 13222  		return true
 13223  	}
 13224  	// match: (MOVBstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p (SRDconst [j+8] w) mem))
 13225  	// cond: x.Uses == 1 && clobber(x)
 13226  	// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
 13227  	for {
 13228  		i := v.AuxInt
 13229  		s := v.Aux
 13230  		_ = v.Args[3]
 13231  		idx := v.Args[0]
 13232  		p := v.Args[1]
 13233  		w0 := v.Args[2]
 13234  		if w0.Op != OpS390XSRDconst {
 13235  			break
 13236  		}
 13237  		j := w0.AuxInt
 13238  		w := w0.Args[0]
 13239  		x := v.Args[3]
 13240  		if x.Op != OpS390XMOVBstoreidx {
 13241  			break
 13242  		}
 13243  		if x.AuxInt != i-1 {
 13244  			break
 13245  		}
 13246  		if x.Aux != s {
 13247  			break
 13248  		}
 13249  		_ = x.Args[3]
 13250  		if idx != x.Args[0] {
 13251  			break
 13252  		}
 13253  		if p != x.Args[1] {
 13254  			break
 13255  		}
 13256  		x_2 := x.Args[2]
 13257  		if x_2.Op != OpS390XSRDconst {
 13258  			break
 13259  		}
 13260  		if x_2.AuxInt != j+8 {
 13261  			break
 13262  		}
 13263  		if w != x_2.Args[0] {
 13264  			break
 13265  		}
 13266  		mem := x.Args[3]
 13267  		if !(x.Uses == 1 && clobber(x)) {
 13268  			break
 13269  		}
 13270  		v.reset(OpS390XMOVHstoreidx)
 13271  		v.AuxInt = i - 1
 13272  		v.Aux = s
 13273  		v.AddArg(p)
 13274  		v.AddArg(idx)
 13275  		v.AddArg(w0)
 13276  		v.AddArg(mem)
 13277  		return true
 13278  	}
 13279  	// match: (MOVBstoreidx [i] {s} p idx w x:(MOVBstoreidx [i-1] {s} p idx (SRWconst [8] w) mem))
 13280  	// cond: x.Uses == 1 && clobber(x)
 13281  	// result: (MOVHstoreidx [i-1] {s} p idx w mem)
 13282  	for {
 13283  		i := v.AuxInt
 13284  		s := v.Aux
 13285  		_ = v.Args[3]
 13286  		p := v.Args[0]
 13287  		idx := v.Args[1]
 13288  		w := v.Args[2]
 13289  		x := v.Args[3]
 13290  		if x.Op != OpS390XMOVBstoreidx {
 13291  			break
 13292  		}
 13293  		if x.AuxInt != i-1 {
 13294  			break
 13295  		}
 13296  		if x.Aux != s {
 13297  			break
 13298  		}
 13299  		_ = x.Args[3]
 13300  		if p != x.Args[0] {
 13301  			break
 13302  		}
 13303  		if idx != x.Args[1] {
 13304  			break
 13305  		}
 13306  		x_2 := x.Args[2]
 13307  		if x_2.Op != OpS390XSRWconst {
 13308  			break
 13309  		}
 13310  		if x_2.AuxInt != 8 {
 13311  			break
 13312  		}
 13313  		if w != x_2.Args[0] {
 13314  			break
 13315  		}
 13316  		mem := x.Args[3]
 13317  		if !(x.Uses == 1 && clobber(x)) {
 13318  			break
 13319  		}
 13320  		v.reset(OpS390XMOVHstoreidx)
 13321  		v.AuxInt = i - 1
 13322  		v.Aux = s
 13323  		v.AddArg(p)
 13324  		v.AddArg(idx)