github.com/euank/go@v0.0.0-20160829210321-495514729181/src/cmd/compile/internal/ssa/rewritePPC64.go (about)

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