src/cmd/compile/internal/ssa/rewritePPC64.go

   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 OpPPC64ADDconst:
 344                 return rewriteValuePPC64_OpPPC64ADDconst(v, config)
 345         case OpPPC64AND:
 346                 return rewriteValuePPC64_OpPPC64AND(v, config)
 347         case OpPPC64ANDconst:
 348                 return rewriteValuePPC64_OpPPC64ANDconst(v, config)
 349         case OpPPC64CMP:
 350                 return rewriteValuePPC64_OpPPC64CMP(v, config)
 351         case OpPPC64CMPU:
 352                 return rewriteValuePPC64_OpPPC64CMPU(v, config)
 353         case OpPPC64CMPUconst:
 354                 return rewriteValuePPC64_OpPPC64CMPUconst(v, config)
 355         case OpPPC64CMPW:
 356                 return rewriteValuePPC64_OpPPC64CMPW(v, config)
 357         case OpPPC64CMPWU:
 358                 return rewriteValuePPC64_OpPPC64CMPWU(v, config)
 359         case OpPPC64CMPWUconst:
 360                 return rewriteValuePPC64_OpPPC64CMPWUconst(v, config)
 361         case OpPPC64CMPWconst:
 362                 return rewriteValuePPC64_OpPPC64CMPWconst(v, config)
 363         case OpPPC64CMPconst:
 364                 return rewriteValuePPC64_OpPPC64CMPconst(v, config)
 365         case OpPPC64Equal:
 366                 return rewriteValuePPC64_OpPPC64Equal(v, config)
 367         case OpPPC64FMOVDload:
 368                 return rewriteValuePPC64_OpPPC64FMOVDload(v, config)
 369         case OpPPC64FMOVDstore:
 370                 return rewriteValuePPC64_OpPPC64FMOVDstore(v, config)
 371         case OpPPC64FMOVSload:
 372                 return rewriteValuePPC64_OpPPC64FMOVSload(v, config)
 373         case OpPPC64FMOVSstore:
 374                 return rewriteValuePPC64_OpPPC64FMOVSstore(v, config)
 375         case OpPPC64GreaterEqual:
 376                 return rewriteValuePPC64_OpPPC64GreaterEqual(v, config)
 377         case OpPPC64GreaterThan:
 378                 return rewriteValuePPC64_OpPPC64GreaterThan(v, config)
 379         case OpPPC64LessEqual:
 380                 return rewriteValuePPC64_OpPPC64LessEqual(v, config)
 381         case OpPPC64LessThan:
 382                 return rewriteValuePPC64_OpPPC64LessThan(v, config)
 383         case OpPPC64MOVBZload:
 384                 return rewriteValuePPC64_OpPPC64MOVBZload(v, config)
 385         case OpPPC64MOVBZreg:
 386                 return rewriteValuePPC64_OpPPC64MOVBZreg(v, config)
 387         case OpPPC64MOVBreg:
 388                 return rewriteValuePPC64_OpPPC64MOVBreg(v, config)
 389         case OpPPC64MOVBstore:
 390                 return rewriteValuePPC64_OpPPC64MOVBstore(v, config)
 391         case OpPPC64MOVBstorezero:
 392                 return rewriteValuePPC64_OpPPC64MOVBstorezero(v, config)
 393         case OpPPC64MOVDload:
 394                 return rewriteValuePPC64_OpPPC64MOVDload(v, config)
 395         case OpPPC64MOVDstore:
 396                 return rewriteValuePPC64_OpPPC64MOVDstore(v, config)
 397         case OpPPC64MOVDstorezero:
 398                 return rewriteValuePPC64_OpPPC64MOVDstorezero(v, config)
 399         case OpPPC64MOVHZload:
 400                 return rewriteValuePPC64_OpPPC64MOVHZload(v, config)
 401         case OpPPC64MOVHZreg:
 402                 return rewriteValuePPC64_OpPPC64MOVHZreg(v, config)
 403         case OpPPC64MOVHload:
 404                 return rewriteValuePPC64_OpPPC64MOVHload(v, config)
 405         case OpPPC64MOVHreg:
 406                 return rewriteValuePPC64_OpPPC64MOVHreg(v, config)
 407         case OpPPC64MOVHstore:
 408                 return rewriteValuePPC64_OpPPC64MOVHstore(v, config)
 409         case OpPPC64MOVHstorezero:
 410                 return rewriteValuePPC64_OpPPC64MOVHstorezero(v, config)
 411         case OpPPC64MOVWZload:
 412                 return rewriteValuePPC64_OpPPC64MOVWZload(v, config)
 413         case OpPPC64MOVWZreg:
 414                 return rewriteValuePPC64_OpPPC64MOVWZreg(v, config)
 415         case OpPPC64MOVWload:
 416                 return rewriteValuePPC64_OpPPC64MOVWload(v, config)
 417         case OpPPC64MOVWreg:
 418                 return rewriteValuePPC64_OpPPC64MOVWreg(v, config)
 419         case OpPPC64MOVWstore:
 420                 return rewriteValuePPC64_OpPPC64MOVWstore(v, config)
 421         case OpPPC64MOVWstorezero:
 422                 return rewriteValuePPC64_OpPPC64MOVWstorezero(v, config)
 423         case OpPPC64MaskIfNotCarry:
 424                 return rewriteValuePPC64_OpPPC64MaskIfNotCarry(v, config)
 425         case OpPPC64NotEqual:
 426                 return rewriteValuePPC64_OpPPC64NotEqual(v, config)
 427         case OpPPC64OR:
 428                 return rewriteValuePPC64_OpPPC64OR(v, config)
 429         case OpPPC64ORN:
 430                 return rewriteValuePPC64_OpPPC64ORN(v, config)
 431         case OpPPC64ORconst:
 432                 return rewriteValuePPC64_OpPPC64ORconst(v, config)
 433         case OpPPC64SUB:
 434                 return rewriteValuePPC64_OpPPC64SUB(v, config)
 435         case OpPPC64XOR:
 436                 return rewriteValuePPC64_OpPPC64XOR(v, config)
 437         case OpPPC64XORconst:
 438                 return rewriteValuePPC64_OpPPC64XORconst(v, config)
 439         case OpRsh16Ux16:
 440                 return rewriteValuePPC64_OpRsh16Ux16(v, config)
 441         case OpRsh16Ux32:
 442                 return rewriteValuePPC64_OpRsh16Ux32(v, config)
 443         case OpRsh16Ux64:
 444                 return rewriteValuePPC64_OpRsh16Ux64(v, config)
 445         case OpRsh16Ux8:
 446                 return rewriteValuePPC64_OpRsh16Ux8(v, config)
 447         case OpRsh16x16:
 448                 return rewriteValuePPC64_OpRsh16x16(v, config)
 449         case OpRsh16x32:
 450                 return rewriteValuePPC64_OpRsh16x32(v, config)
 451         case OpRsh16x64:
 452                 return rewriteValuePPC64_OpRsh16x64(v, config)
 453         case OpRsh16x8:
 454                 return rewriteValuePPC64_OpRsh16x8(v, config)
 455         case OpRsh32Ux16:
 456                 return rewriteValuePPC64_OpRsh32Ux16(v, config)
 457         case OpRsh32Ux32:
 458                 return rewriteValuePPC64_OpRsh32Ux32(v, config)
 459         case OpRsh32Ux64:
 460                 return rewriteValuePPC64_OpRsh32Ux64(v, config)
 461         case OpRsh32Ux8:
 462                 return rewriteValuePPC64_OpRsh32Ux8(v, config)
 463         case OpRsh32x16:
 464                 return rewriteValuePPC64_OpRsh32x16(v, config)
 465         case OpRsh32x32:
 466                 return rewriteValuePPC64_OpRsh32x32(v, config)
 467         case OpRsh32x64:
 468                 return rewriteValuePPC64_OpRsh32x64(v, config)
 469         case OpRsh32x8:
 470                 return rewriteValuePPC64_OpRsh32x8(v, config)
 471         case OpRsh64Ux16:
 472                 return rewriteValuePPC64_OpRsh64Ux16(v, config)
 473         case OpRsh64Ux32:
 474                 return rewriteValuePPC64_OpRsh64Ux32(v, config)
 475         case OpRsh64Ux64:
 476                 return rewriteValuePPC64_OpRsh64Ux64(v, config)
 477         case OpRsh64Ux8:
 478                 return rewriteValuePPC64_OpRsh64Ux8(v, config)
 479         case OpRsh64x16:
 480                 return rewriteValuePPC64_OpRsh64x16(v, config)
 481         case OpRsh64x32:
 482                 return rewriteValuePPC64_OpRsh64x32(v, config)
 483         case OpRsh64x64:
 484                 return rewriteValuePPC64_OpRsh64x64(v, config)
 485         case OpRsh64x8:
 486                 return rewriteValuePPC64_OpRsh64x8(v, config)
 487         case OpRsh8Ux16:
 488                 return rewriteValuePPC64_OpRsh8Ux16(v, config)
 489         case OpRsh8Ux32:
 490                 return rewriteValuePPC64_OpRsh8Ux32(v, config)
 491         case OpRsh8Ux64:
 492                 return rewriteValuePPC64_OpRsh8Ux64(v, config)
 493         case OpRsh8Ux8:
 494                 return rewriteValuePPC64_OpRsh8Ux8(v, config)
 495         case OpRsh8x16:
 496                 return rewriteValuePPC64_OpRsh8x16(v, config)
 497         case OpRsh8x32:
 498                 return rewriteValuePPC64_OpRsh8x32(v, config)
 499         case OpRsh8x64:
 500                 return rewriteValuePPC64_OpRsh8x64(v, config)
 501         case OpRsh8x8:
 502                 return rewriteValuePPC64_OpRsh8x8(v, config)
 503         case OpSignExt16to32:
 504                 return rewriteValuePPC64_OpSignExt16to32(v, config)
 505         case OpSignExt16to64:
 506                 return rewriteValuePPC64_OpSignExt16to64(v, config)
 507         case OpSignExt32to64:
 508                 return rewriteValuePPC64_OpSignExt32to64(v, config)
 509         case OpSignExt8to16:
 510                 return rewriteValuePPC64_OpSignExt8to16(v, config)
 511         case OpSignExt8to32:
 512                 return rewriteValuePPC64_OpSignExt8to32(v, config)
 513         case OpSignExt8to64:
 514                 return rewriteValuePPC64_OpSignExt8to64(v, config)
 515         case OpSlicemask:
 516                 return rewriteValuePPC64_OpSlicemask(v, config)
 517         case OpSqrt:
 518                 return rewriteValuePPC64_OpSqrt(v, config)
 519         case OpStaticCall:
 520                 return rewriteValuePPC64_OpStaticCall(v, config)
 521         case OpStore:
 522                 return rewriteValuePPC64_OpStore(v, config)
 523         case OpSub16:
 524                 return rewriteValuePPC64_OpSub16(v, config)
 525         case OpSub32:
 526                 return rewriteValuePPC64_OpSub32(v, config)
 527         case OpSub32F:
 528                 return rewriteValuePPC64_OpSub32F(v, config)
 529         case OpSub64:
 530                 return rewriteValuePPC64_OpSub64(v, config)
 531         case OpSub64F:
 532                 return rewriteValuePPC64_OpSub64F(v, config)
 533         case OpSub8:
 534                 return rewriteValuePPC64_OpSub8(v, config)
 535         case OpSubPtr:
 536                 return rewriteValuePPC64_OpSubPtr(v, config)
 537         case OpTrunc16to8:
 538                 return rewriteValuePPC64_OpTrunc16to8(v, config)
 539         case OpTrunc32to16:
 540                 return rewriteValuePPC64_OpTrunc32to16(v, config)
 541         case OpTrunc32to8:
 542                 return rewriteValuePPC64_OpTrunc32to8(v, config)
 543         case OpTrunc64to16:
 544                 return rewriteValuePPC64_OpTrunc64to16(v, config)
 545         case OpTrunc64to32:
 546                 return rewriteValuePPC64_OpTrunc64to32(v, config)
 547         case OpTrunc64to8:
 548                 return rewriteValuePPC64_OpTrunc64to8(v, config)
 549         case OpXor16:
 550                 return rewriteValuePPC64_OpXor16(v, config)
 551         case OpXor32:
 552                 return rewriteValuePPC64_OpXor32(v, config)
 553         case OpXor64:
 554                 return rewriteValuePPC64_OpXor64(v, config)
 555         case OpXor8:
 556                 return rewriteValuePPC64_OpXor8(v, config)
 557         case OpZero:
 558                 return rewriteValuePPC64_OpZero(v, config)
 559         case OpZeroExt16to32:
 560                 return rewriteValuePPC64_OpZeroExt16to32(v, config)
 561         case OpZeroExt16to64:
 562                 return rewriteValuePPC64_OpZeroExt16to64(v, config)
 563         case OpZeroExt32to64:
 564                 return rewriteValuePPC64_OpZeroExt32to64(v, config)
 565         case OpZeroExt8to16:
 566                 return rewriteValuePPC64_OpZeroExt8to16(v, config)
 567         case OpZeroExt8to32:
 568                 return rewriteValuePPC64_OpZeroExt8to32(v, config)
 569         case OpZeroExt8to64:
 570                 return rewriteValuePPC64_OpZeroExt8to64(v, config)
 571         }
 572         return false
 573 }
 574 func rewriteValuePPC64_OpAdd16(v *Value, config *Config) bool {
 575         b := v.Block
 576         _ = b
 577         // match: (Add16  x y)
 578         // cond:
 579         // result: (ADD x y)
 580         for {
 581                 x := v.Args[0]
 582                 y := v.Args[1]
 583                 v.reset(OpPPC64ADD)
 584                 v.AddArg(x)
 585                 v.AddArg(y)
 586                 return true
 587         }
 588 }
 589 func rewriteValuePPC64_OpAdd32(v *Value, config *Config) bool {
 590         b := v.Block
 591         _ = b
 592         // match: (Add32  x y)
 593         // cond:
 594         // result: (ADD x y)
 595         for {
 596                 x := v.Args[0]
 597                 y := v.Args[1]
 598                 v.reset(OpPPC64ADD)
 599                 v.AddArg(x)
 600                 v.AddArg(y)
 601                 return true
 602         }
 603 }
 604 func rewriteValuePPC64_OpAdd32F(v *Value, config *Config) bool {
 605         b := v.Block
 606         _ = b
 607         // match: (Add32F x y)
 608         // cond:
 609         // result: (FADDS x y)
 610         for {
 611                 x := v.Args[0]
 612                 y := v.Args[1]
 613                 v.reset(OpPPC64FADDS)
 614                 v.AddArg(x)
 615                 v.AddArg(y)
 616                 return true
 617         }
 618 }
 619 func rewriteValuePPC64_OpAdd64(v *Value, config *Config) bool {
 620         b := v.Block
 621         _ = b
 622         // match: (Add64  x y)
 623         // cond:
 624         // result: (ADD  x y)
 625         for {
 626                 x := v.Args[0]
 627                 y := v.Args[1]
 628                 v.reset(OpPPC64ADD)
 629                 v.AddArg(x)
 630                 v.AddArg(y)
 631                 return true
 632         }
 633 }
 634 func rewriteValuePPC64_OpAdd64F(v *Value, config *Config) bool {
 635         b := v.Block
 636         _ = b
 637         // match: (Add64F x y)
 638         // cond:
 639         // result: (FADD x y)
 640         for {
 641                 x := v.Args[0]
 642                 y := v.Args[1]
 643                 v.reset(OpPPC64FADD)
 644                 v.AddArg(x)
 645                 v.AddArg(y)
 646                 return true
 647         }
 648 }
 649 func rewriteValuePPC64_OpAdd8(v *Value, config *Config) bool {
 650         b := v.Block
 651         _ = b
 652         // match: (Add8   x y)
 653         // cond:
 654         // result: (ADD x y)
 655         for {
 656                 x := v.Args[0]
 657                 y := v.Args[1]
 658                 v.reset(OpPPC64ADD)
 659                 v.AddArg(x)
 660                 v.AddArg(y)
 661                 return true
 662         }
 663 }
 664 func rewriteValuePPC64_OpAddPtr(v *Value, config *Config) bool {
 665         b := v.Block
 666         _ = b
 667         // match: (AddPtr x y)
 668         // cond:
 669         // result: (ADD  x y)
 670         for {
 671                 x := v.Args[0]
 672                 y := v.Args[1]
 673                 v.reset(OpPPC64ADD)
 674                 v.AddArg(x)
 675                 v.AddArg(y)
 676                 return true
 677         }
 678 }
 679 func rewriteValuePPC64_OpAddr(v *Value, config *Config) bool {
 680         b := v.Block
 681         _ = b
 682         // match: (Addr {sym} base)
 683         // cond:
 684         // result: (MOVDaddr {sym} base)
 685         for {
 686                 sym := v.Aux
 687                 base := v.Args[0]
 688                 v.reset(OpPPC64MOVDaddr)
 689                 v.Aux = sym
 690                 v.AddArg(base)
 691                 return true
 692         }
 693 }
 694 func rewriteValuePPC64_OpAnd16(v *Value, config *Config) bool {
 695         b := v.Block
 696         _ = b
 697         // match: (And16 x y)
 698         // cond:
 699         // result: (AND x y)
 700         for {
 701                 x := v.Args[0]
 702                 y := v.Args[1]
 703                 v.reset(OpPPC64AND)
 704                 v.AddArg(x)
 705                 v.AddArg(y)
 706                 return true
 707         }
 708 }
 709 func rewriteValuePPC64_OpAnd32(v *Value, config *Config) bool {
 710         b := v.Block
 711         _ = b
 712         // match: (And32 x y)
 713         // cond:
 714         // result: (AND x y)
 715         for {
 716                 x := v.Args[0]
 717                 y := v.Args[1]
 718                 v.reset(OpPPC64AND)
 719                 v.AddArg(x)
 720                 v.AddArg(y)
 721                 return true
 722         }
 723 }
 724 func rewriteValuePPC64_OpAnd64(v *Value, config *Config) bool {
 725         b := v.Block
 726         _ = b
 727         // match: (And64 x y)
 728         // cond:
 729         // result: (AND x y)
 730         for {
 731                 x := v.Args[0]
 732                 y := v.Args[1]
 733                 v.reset(OpPPC64AND)
 734                 v.AddArg(x)
 735                 v.AddArg(y)
 736                 return true
 737         }
 738 }
 739 func rewriteValuePPC64_OpAnd8(v *Value, config *Config) bool {
 740         b := v.Block
 741         _ = b
 742         // match: (And8  x y)
 743         // cond:
 744         // result: (AND x y)
 745         for {
 746                 x := v.Args[0]
 747                 y := v.Args[1]
 748                 v.reset(OpPPC64AND)
 749                 v.AddArg(x)
 750                 v.AddArg(y)
 751                 return true
 752         }
 753 }
 754 func rewriteValuePPC64_OpAndB(v *Value, config *Config) bool {
 755         b := v.Block
 756         _ = b
 757         // match: (AndB x y)
 758         // cond:
 759         // result: (AND x y)
 760         for {
 761                 x := v.Args[0]
 762                 y := v.Args[1]
 763                 v.reset(OpPPC64AND)
 764                 v.AddArg(x)
 765                 v.AddArg(y)
 766                 return true
 767         }
 768 }
 769 func rewriteValuePPC64_OpAvg64u(v *Value, config *Config) bool {
 770         b := v.Block
 771         _ = b
 772         // match: (Avg64u <t> x y)
 773         // cond:
 774         // result: (ADD (ADD <t> (SRD <t> x (MOVDconst <t> [1])) (SRD <t> y (MOVDconst <t> [1]))) (ANDconst <t> (AND <t> x y) [1]))
 775         for {
 776                 t := v.Type
 777                 x := v.Args[0]
 778                 y := v.Args[1]
 779                 v.reset(OpPPC64ADD)
 780                 v0 := b.NewValue0(v.Pos, OpPPC64ADD, t)
 781                 v1 := b.NewValue0(v.Pos, OpPPC64SRD, t)
 782                 v1.AddArg(x)
 783                 v2 := b.NewValue0(v.Pos, OpPPC64MOVDconst, t)
 784                 v2.AuxInt = 1
 785                 v1.AddArg(v2)
 786                 v0.AddArg(v1)
 787                 v3 := b.NewValue0(v.Pos, OpPPC64SRD, t)
 788                 v3.AddArg(y)
 789                 v4 := b.NewValue0(v.Pos, OpPPC64MOVDconst, t)
 790                 v4.AuxInt = 1
 791                 v3.AddArg(v4)
 792                 v0.AddArg(v3)
 793                 v.AddArg(v0)
 794                 v5 := b.NewValue0(v.Pos, OpPPC64ANDconst, t)
 795                 v5.AuxInt = 1
 796                 v6 := b.NewValue0(v.Pos, OpPPC64AND, t)
 797                 v6.AddArg(x)
 798                 v6.AddArg(y)
 799                 v5.AddArg(v6)
 800                 v.AddArg(v5)
 801                 return true
 802         }
 803 }
 804 func rewriteValuePPC64_OpClosureCall(v *Value, config *Config) bool {
 805         b := v.Block
 806         _ = b
 807         // match: (ClosureCall [argwid] entry closure mem)
 808         // cond:
 809         // result: (CALLclosure [argwid] entry closure mem)
 810         for {
 811                 argwid := v.AuxInt
 812                 entry := v.Args[0]
 813                 closure := v.Args[1]
 814                 mem := v.Args[2]
 815                 v.reset(OpPPC64CALLclosure)
 816                 v.AuxInt = argwid
 817                 v.AddArg(entry)
 818                 v.AddArg(closure)
 819                 v.AddArg(mem)
 820                 return true
 821         }
 822 }
 823 func rewriteValuePPC64_OpCom16(v *Value, config *Config) bool {
 824         b := v.Block
 825         _ = b
 826         // match: (Com16 x)
 827         // cond:
 828         // result: (XORconst [-1] x)
 829         for {
 830                 x := v.Args[0]
 831                 v.reset(OpPPC64XORconst)
 832                 v.AuxInt = -1
 833                 v.AddArg(x)
 834                 return true
 835         }
 836 }
 837 func rewriteValuePPC64_OpCom32(v *Value, config *Config) bool {
 838         b := v.Block
 839         _ = b
 840         // match: (Com32 x)
 841         // cond:
 842         // result: (XORconst [-1] x)
 843         for {
 844                 x := v.Args[0]
 845                 v.reset(OpPPC64XORconst)
 846                 v.AuxInt = -1
 847                 v.AddArg(x)
 848                 return true
 849         }
 850 }
 851 func rewriteValuePPC64_OpCom64(v *Value, config *Config) bool {
 852         b := v.Block
 853         _ = b
 854         // match: (Com64 x)
 855         // cond:
 856         // result: (XORconst [-1] x)
 857         for {
 858                 x := v.Args[0]
 859                 v.reset(OpPPC64XORconst)
 860                 v.AuxInt = -1
 861                 v.AddArg(x)
 862                 return true
 863         }
 864 }
 865 func rewriteValuePPC64_OpCom8(v *Value, config *Config) bool {
 866         b := v.Block
 867         _ = b
 868         // match: (Com8  x)
 869         // cond:
 870         // result: (XORconst [-1] x)
 871         for {
 872                 x := v.Args[0]
 873                 v.reset(OpPPC64XORconst)
 874                 v.AuxInt = -1
 875                 v.AddArg(x)
 876                 return true
 877         }
 878 }
 879 func rewriteValuePPC64_OpConst16(v *Value, config *Config) bool {
 880         b := v.Block
 881         _ = b
 882         // match: (Const16  [val])
 883         // cond:
 884         // result: (MOVDconst [val])
 885         for {
 886                 val := v.AuxInt
 887                 v.reset(OpPPC64MOVDconst)
 888                 v.AuxInt = val
 889                 return true
 890         }
 891 }
 892 func rewriteValuePPC64_OpConst32(v *Value, config *Config) bool {
 893         b := v.Block
 894         _ = b
 895         // match: (Const32  [val])
 896         // cond:
 897         // result: (MOVDconst [val])
 898         for {
 899                 val := v.AuxInt
 900                 v.reset(OpPPC64MOVDconst)
 901                 v.AuxInt = val
 902                 return true
 903         }
 904 }
 905 func rewriteValuePPC64_OpConst32F(v *Value, config *Config) bool {
 906         b := v.Block
 907         _ = b
 908         // match: (Const32F [val])
 909         // cond:
 910         // result: (FMOVSconst [val])
 911         for {
 912                 val := v.AuxInt
 913                 v.reset(OpPPC64FMOVSconst)
 914                 v.AuxInt = val
 915                 return true
 916         }
 917 }
 918 func rewriteValuePPC64_OpConst64(v *Value, config *Config) bool {
 919         b := v.Block
 920         _ = b
 921         // match: (Const64  [val])
 922         // cond:
 923         // result: (MOVDconst [val])
 924         for {
 925                 val := v.AuxInt
 926                 v.reset(OpPPC64MOVDconst)
 927                 v.AuxInt = val
 928                 return true
 929         }
 930 }
 931 func rewriteValuePPC64_OpConst64F(v *Value, config *Config) bool {
 932         b := v.Block
 933         _ = b
 934         // match: (Const64F [val])
 935         // cond:
 936         // result: (FMOVDconst [val])
 937         for {
 938                 val := v.AuxInt
 939                 v.reset(OpPPC64FMOVDconst)
 940                 v.AuxInt = val
 941                 return true
 942         }
 943 }
 944 func rewriteValuePPC64_OpConst8(v *Value, config *Config) bool {
 945         b := v.Block
 946         _ = b
 947         // match: (Const8   [val])
 948         // cond:
 949         // result: (MOVDconst [val])
 950         for {
 951                 val := v.AuxInt
 952                 v.reset(OpPPC64MOVDconst)
 953                 v.AuxInt = val
 954                 return true
 955         }
 956 }
 957 func rewriteValuePPC64_OpConstBool(v *Value, config *Config) bool {
 958         b := v.Block
 959         _ = b
 960         // match: (ConstBool [b])
 961         // cond:
 962         // result: (MOVDconst [b])
 963         for {
 964                 b := v.AuxInt
 965                 v.reset(OpPPC64MOVDconst)
 966                 v.AuxInt = b
 967                 return true
 968         }
 969 }
 970 func rewriteValuePPC64_OpConstNil(v *Value, config *Config) bool {
 971         b := v.Block
 972         _ = b
 973         // match: (ConstNil)
 974         // cond:
 975         // result: (MOVDconst [0])
 976         for {
 977                 v.reset(OpPPC64MOVDconst)
 978                 v.AuxInt = 0
 979                 return true
 980         }
 981 }
 982 func rewriteValuePPC64_OpConvert(v *Value, config *Config) bool {
 983         b := v.Block
 984         _ = b
 985         // match: (Convert <t> x mem)
 986         // cond:
 987         // result: (MOVDconvert <t> x mem)
 988         for {
 989                 t := v.Type
 990                 x := v.Args[0]
 991                 mem := v.Args[1]
 992                 v.reset(OpPPC64MOVDconvert)
 993                 v.Type = t
 994                 v.AddArg(x)
 995                 v.AddArg(mem)
 996                 return true
 997         }
 998 }
 999 func rewriteValuePPC64_OpCvt32Fto32(v *Value, config *Config) bool {
1000         b := v.Block
1001         _ = b
1002         // match: (Cvt32Fto32 x)
1003         // cond:
1004         // result: (Xf2i64 (FCTIWZ x))
1005         for {
1006                 x := v.Args[0]
1007                 v.reset(OpPPC64Xf2i64)
1008                 v0 := b.NewValue0(v.Pos, OpPPC64FCTIWZ, config.fe.TypeFloat64())
1009                 v0.AddArg(x)
1010                 v.AddArg(v0)
1011                 return true
1012         }
1013 }
1014 func rewriteValuePPC64_OpCvt32Fto64(v *Value, config *Config) bool {
1015         b := v.Block
1016         _ = b
1017         // match: (Cvt32Fto64 x)
1018         // cond:
1019         // result: (Xf2i64 (FCTIDZ x))
1020         for {
1021                 x := v.Args[0]
1022                 v.reset(OpPPC64Xf2i64)
1023                 v0 := b.NewValue0(v.Pos, OpPPC64FCTIDZ, config.fe.TypeFloat64())
1024                 v0.AddArg(x)
1025                 v.AddArg(v0)
1026                 return true
1027         }
1028 }
1029 func rewriteValuePPC64_OpCvt32Fto64F(v *Value, config *Config) bool {
1030         b := v.Block
1031         _ = b
1032         // match: (Cvt32Fto64F x)
1033         // cond:
1034         // result: x
1035         for {
1036                 x := v.Args[0]
1037                 v.reset(OpCopy)
1038                 v.Type = x.Type
1039                 v.AddArg(x)
1040                 return true
1041         }
1042 }
1043 func rewriteValuePPC64_OpCvt32to32F(v *Value, config *Config) bool {
1044         b := v.Block
1045         _ = b
1046         // match: (Cvt32to32F x)
1047         // cond:
1048         // result: (FRSP (FCFID (Xi2f64 (SignExt32to64 x))))
1049         for {
1050                 x := v.Args[0]
1051                 v.reset(OpPPC64FRSP)
1052                 v0 := b.NewValue0(v.Pos, OpPPC64FCFID, config.fe.TypeFloat64())
1053                 v1 := b.NewValue0(v.Pos, OpPPC64Xi2f64, config.fe.TypeFloat64())
1054                 v2 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64())
1055                 v2.AddArg(x)
1056                 v1.AddArg(v2)
1057                 v0.AddArg(v1)
1058                 v.AddArg(v0)
1059                 return true
1060         }
1061 }
1062 func rewriteValuePPC64_OpCvt32to64F(v *Value, config *Config) bool {
1063         b := v.Block
1064         _ = b
1065         // match: (Cvt32to64F x)
1066         // cond:
1067         // result: (FCFID (Xi2f64 (SignExt32to64 x)))
1068         for {
1069                 x := v.Args[0]
1070                 v.reset(OpPPC64FCFID)
1071                 v0 := b.NewValue0(v.Pos, OpPPC64Xi2f64, config.fe.TypeFloat64())
1072                 v1 := b.NewValue0(v.Pos, OpSignExt32to64, config.fe.TypeInt64())
1073                 v1.AddArg(x)
1074                 v0.AddArg(v1)
1075                 v.AddArg(v0)
1076                 return true
1077         }
1078 }
1079 func rewriteValuePPC64_OpCvt64Fto32(v *Value, config *Config) bool {
1080         b := v.Block
1081         _ = b
1082         // match: (Cvt64Fto32 x)
1083         // cond:
1084         // result: (Xf2i64 (FCTIWZ x))
1085         for {
1086                 x := v.Args[0]
1087                 v.reset(OpPPC64Xf2i64)
1088                 v0 := b.NewValue0(v.Pos, OpPPC64FCTIWZ, config.fe.TypeFloat64())
1089                 v0.AddArg(x)
1090                 v.AddArg(v0)
1091                 return true
1092         }
1093 }
1094 func rewriteValuePPC64_OpCvt64Fto32F(v *Value, config *Config) bool {
1095         b := v.Block
1096         _ = b
1097         // match: (Cvt64Fto32F x)
1098         // cond:
1099         // result: (FRSP x)
1100         for {
1101                 x := v.Args[0]
1102                 v.reset(OpPPC64FRSP)
1103                 v.AddArg(x)
1104                 return true
1105         }
1106 }
1107 func rewriteValuePPC64_OpCvt64Fto64(v *Value, config *Config) bool {
1108         b := v.Block
1109         _ = b
1110         // match: (Cvt64Fto64 x)
1111         // cond:
1112         // result: (Xf2i64 (FCTIDZ x))
1113         for {
1114                 x := v.Args[0]
1115                 v.reset(OpPPC64Xf2i64)
1116                 v0 := b.NewValue0(v.Pos, OpPPC64FCTIDZ, config.fe.TypeFloat64())
1117                 v0.AddArg(x)
1118                 v.AddArg(v0)
1119                 return true
1120         }
1121 }
1122 func rewriteValuePPC64_OpCvt64to32F(v *Value, config *Config) bool {
1123         b := v.Block
1124         _ = b
1125         // match: (Cvt64to32F x)
1126         // cond:
1127         // result: (FRSP (FCFID (Xi2f64 x)))
1128         for {
1129                 x := v.Args[0]
1130                 v.reset(OpPPC64FRSP)
1131                 v0 := b.NewValue0(v.Pos, OpPPC64FCFID, config.fe.TypeFloat64())
1132                 v1 := b.NewValue0(v.Pos, OpPPC64Xi2f64, config.fe.TypeFloat64())
1133                 v1.AddArg(x)
1134                 v0.AddArg(v1)
1135                 v.AddArg(v0)
1136                 return true
1137         }
1138 }
1139 func rewriteValuePPC64_OpCvt64to64F(v *Value, config *Config) bool {
1140         b := v.Block
1141         _ = b
1142         // match: (Cvt64to64F x)
1143         // cond:
1144         // result: (FCFID (Xi2f64 x))
1145         for {
1146                 x := v.Args[0]
1147                 v.reset(OpPPC64FCFID)
1148                 v0 := b.NewValue0(v.Pos, OpPPC64Xi2f64, config.fe.TypeFloat64())
1149                 v0.AddArg(x)
1150                 v.AddArg(v0)
1151                 return true
1152         }
1153 }
1154 func rewriteValuePPC64_OpDeferCall(v *Value, config *Config) bool {
1155         b := v.Block
1156         _ = b
1157         // match: (DeferCall [argwid] mem)
1158         // cond:
1159         // result: (CALLdefer [argwid] mem)
1160         for {
1161                 argwid := v.AuxInt
1162                 mem := v.Args[0]
1163                 v.reset(OpPPC64CALLdefer)
1164                 v.AuxInt = argwid
1165                 v.AddArg(mem)
1166                 return true
1167         }
1168 }
1169 func rewriteValuePPC64_OpDiv16(v *Value, config *Config) bool {
1170         b := v.Block
1171         _ = b
1172         // match: (Div16  x y)
1173         // cond:
1174         // result: (DIVW  (SignExt16to32 x) (SignExt16to32 y))
1175         for {
1176                 x := v.Args[0]
1177                 y := v.Args[1]
1178                 v.reset(OpPPC64DIVW)
1179                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
1180                 v0.AddArg(x)
1181                 v.AddArg(v0)
1182                 v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
1183                 v1.AddArg(y)
1184                 v.AddArg(v1)
1185                 return true
1186         }
1187 }
1188 func rewriteValuePPC64_OpDiv16u(v *Value, config *Config) bool {
1189         b := v.Block
1190         _ = b
1191         // match: (Div16u x y)
1192         // cond:
1193         // result: (DIVWU (ZeroExt16to32 x) (ZeroExt16to32 y))
1194         for {
1195                 x := v.Args[0]
1196                 y := v.Args[1]
1197                 v.reset(OpPPC64DIVWU)
1198                 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
1199                 v0.AddArg(x)
1200                 v.AddArg(v0)
1201                 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
1202                 v1.AddArg(y)
1203                 v.AddArg(v1)
1204                 return true
1205         }
1206 }
1207 func rewriteValuePPC64_OpDiv32(v *Value, config *Config) bool {
1208         b := v.Block
1209         _ = b
1210         // match: (Div32  x y)
1211         // cond:
1212         // result: (DIVW  x y)
1213         for {
1214                 x := v.Args[0]
1215                 y := v.Args[1]
1216                 v.reset(OpPPC64DIVW)
1217                 v.AddArg(x)
1218                 v.AddArg(y)
1219                 return true
1220         }
1221 }
1222 func rewriteValuePPC64_OpDiv32F(v *Value, config *Config) bool {
1223         b := v.Block
1224         _ = b
1225         // match: (Div32F x y)
1226         // cond:
1227         // result: (FDIVS x y)
1228         for {
1229                 x := v.Args[0]
1230                 y := v.Args[1]
1231                 v.reset(OpPPC64FDIVS)
1232                 v.AddArg(x)
1233                 v.AddArg(y)
1234                 return true
1235         }
1236 }
1237 func rewriteValuePPC64_OpDiv32u(v *Value, config *Config) bool {
1238         b := v.Block
1239         _ = b
1240         // match: (Div32u x y)
1241         // cond:
1242         // result: (DIVWU x y)
1243         for {
1244                 x := v.Args[0]
1245                 y := v.Args[1]
1246                 v.reset(OpPPC64DIVWU)
1247                 v.AddArg(x)
1248                 v.AddArg(y)
1249                 return true
1250         }
1251 }
1252 func rewriteValuePPC64_OpDiv64(v *Value, config *Config) bool {
1253         b := v.Block
1254         _ = b
1255         // match: (Div64  x y)
1256         // cond:
1257         // result: (DIVD  x y)
1258         for {
1259                 x := v.Args[0]
1260                 y := v.Args[1]
1261                 v.reset(OpPPC64DIVD)
1262                 v.AddArg(x)
1263                 v.AddArg(y)
1264                 return true
1265         }
1266 }
1267 func rewriteValuePPC64_OpDiv64F(v *Value, config *Config) bool {
1268         b := v.Block
1269         _ = b
1270         // match: (Div64F x y)
1271         // cond:
1272         // result: (FDIV x y)
1273         for {
1274                 x := v.Args[0]
1275                 y := v.Args[1]
1276                 v.reset(OpPPC64FDIV)
1277                 v.AddArg(x)
1278                 v.AddArg(y)
1279                 return true
1280         }
1281 }
1282 func rewriteValuePPC64_OpDiv64u(v *Value, config *Config) bool {
1283         b := v.Block
1284         _ = b
1285         // match: (Div64u x y)
1286         // cond:
1287         // result: (DIVDU x y)
1288         for {
1289                 x := v.Args[0]
1290                 y := v.Args[1]
1291                 v.reset(OpPPC64DIVDU)
1292                 v.AddArg(x)
1293                 v.AddArg(y)
1294                 return true
1295         }
1296 }
1297 func rewriteValuePPC64_OpDiv8(v *Value, config *Config) bool {
1298         b := v.Block
1299         _ = b
1300         // match: (Div8   x y)
1301         // cond:
1302         // result: (DIVW  (SignExt8to32 x) (SignExt8to32 y))
1303         for {
1304                 x := v.Args[0]
1305                 y := v.Args[1]
1306                 v.reset(OpPPC64DIVW)
1307                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
1308                 v0.AddArg(x)
1309                 v.AddArg(v0)
1310                 v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
1311                 v1.AddArg(y)
1312                 v.AddArg(v1)
1313                 return true
1314         }
1315 }
1316 func rewriteValuePPC64_OpDiv8u(v *Value, config *Config) bool {
1317         b := v.Block
1318         _ = b
1319         // match: (Div8u  x y)
1320         // cond:
1321         // result: (DIVWU (ZeroExt8to32 x) (ZeroExt8to32 y))
1322         for {
1323                 x := v.Args[0]
1324                 y := v.Args[1]
1325                 v.reset(OpPPC64DIVWU)
1326                 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
1327                 v0.AddArg(x)
1328                 v.AddArg(v0)
1329                 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
1330                 v1.AddArg(y)
1331                 v.AddArg(v1)
1332                 return true
1333         }
1334 }
1335 func rewriteValuePPC64_OpEq16(v *Value, config *Config) bool {
1336         b := v.Block
1337         _ = b
1338         // match: (Eq16 x y)
1339         // cond: isSigned(x.Type) && isSigned(y.Type)
1340         // result: (Equal (CMPW (SignExt16to32 x) (SignExt16to32 y)))
1341         for {
1342                 x := v.Args[0]
1343                 y := v.Args[1]
1344                 if !(isSigned(x.Type) && isSigned(y.Type)) {
1345                         break
1346                 }
1347                 v.reset(OpPPC64Equal)
1348                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
1349                 v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
1350                 v1.AddArg(x)
1351                 v0.AddArg(v1)
1352                 v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
1353                 v2.AddArg(y)
1354                 v0.AddArg(v2)
1355                 v.AddArg(v0)
1356                 return true
1357         }
1358         // match: (Eq16 x y)
1359         // cond:
1360         // result: (Equal (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y)))
1361         for {
1362                 x := v.Args[0]
1363                 y := v.Args[1]
1364                 v.reset(OpPPC64Equal)
1365                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
1366                 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
1367                 v1.AddArg(x)
1368                 v0.AddArg(v1)
1369                 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
1370                 v2.AddArg(y)
1371                 v0.AddArg(v2)
1372                 v.AddArg(v0)
1373                 return true
1374         }
1375 }
1376 func rewriteValuePPC64_OpEq32(v *Value, config *Config) bool {
1377         b := v.Block
1378         _ = b
1379         // match: (Eq32 x y)
1380         // cond:
1381         // result: (Equal (CMPW x y))
1382         for {
1383                 x := v.Args[0]
1384                 y := v.Args[1]
1385                 v.reset(OpPPC64Equal)
1386                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
1387                 v0.AddArg(x)
1388                 v0.AddArg(y)
1389                 v.AddArg(v0)
1390                 return true
1391         }
1392 }
1393 func rewriteValuePPC64_OpEq32F(v *Value, config *Config) bool {
1394         b := v.Block
1395         _ = b
1396         // match: (Eq32F x y)
1397         // cond:
1398         // result: (Equal (FCMPU x y))
1399         for {
1400                 x := v.Args[0]
1401                 y := v.Args[1]
1402                 v.reset(OpPPC64Equal)
1403                 v0 := b.NewValue0(v.Pos, OpPPC64FCMPU, TypeFlags)
1404                 v0.AddArg(x)
1405                 v0.AddArg(y)
1406                 v.AddArg(v0)
1407                 return true
1408         }
1409 }
1410 func rewriteValuePPC64_OpEq64(v *Value, config *Config) bool {
1411         b := v.Block
1412         _ = b
1413         // match: (Eq64 x y)
1414         // cond:
1415         // result: (Equal (CMP x y))
1416         for {
1417                 x := v.Args[0]
1418                 y := v.Args[1]
1419                 v.reset(OpPPC64Equal)
1420                 v0 := b.NewValue0(v.Pos, OpPPC64CMP, TypeFlags)
1421                 v0.AddArg(x)
1422                 v0.AddArg(y)
1423                 v.AddArg(v0)
1424                 return true
1425         }
1426 }
1427 func rewriteValuePPC64_OpEq64F(v *Value, config *Config) bool {
1428         b := v.Block
1429         _ = b
1430         // match: (Eq64F x y)
1431         // cond:
1432         // result: (Equal (FCMPU x y))
1433         for {
1434                 x := v.Args[0]
1435                 y := v.Args[1]
1436                 v.reset(OpPPC64Equal)
1437                 v0 := b.NewValue0(v.Pos, OpPPC64FCMPU, TypeFlags)
1438                 v0.AddArg(x)
1439                 v0.AddArg(y)
1440                 v.AddArg(v0)
1441                 return true
1442         }
1443 }
1444 func rewriteValuePPC64_OpEq8(v *Value, config *Config) bool {
1445         b := v.Block
1446         _ = b
1447         // match: (Eq8 x y)
1448         // cond: isSigned(x.Type) && isSigned(y.Type)
1449         // result: (Equal (CMPW (SignExt8to32 x) (SignExt8to32 y)))
1450         for {
1451                 x := v.Args[0]
1452                 y := v.Args[1]
1453                 if !(isSigned(x.Type) && isSigned(y.Type)) {
1454                         break
1455                 }
1456                 v.reset(OpPPC64Equal)
1457                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
1458                 v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
1459                 v1.AddArg(x)
1460                 v0.AddArg(v1)
1461                 v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
1462                 v2.AddArg(y)
1463                 v0.AddArg(v2)
1464                 v.AddArg(v0)
1465                 return true
1466         }
1467         // match: (Eq8 x y)
1468         // cond:
1469         // result: (Equal (CMPW (ZeroExt8to32 x) (ZeroExt8to32 y)))
1470         for {
1471                 x := v.Args[0]
1472                 y := v.Args[1]
1473                 v.reset(OpPPC64Equal)
1474                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
1475                 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
1476                 v1.AddArg(x)
1477                 v0.AddArg(v1)
1478                 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
1479                 v2.AddArg(y)
1480                 v0.AddArg(v2)
1481                 v.AddArg(v0)
1482                 return true
1483         }
1484 }
1485 func rewriteValuePPC64_OpEqB(v *Value, config *Config) bool {
1486         b := v.Block
1487         _ = b
1488         // match: (EqB x y)
1489         // cond:
1490         // result: (ANDconst [1] (EQV x y))
1491         for {
1492                 x := v.Args[0]
1493                 y := v.Args[1]
1494                 v.reset(OpPPC64ANDconst)
1495                 v.AuxInt = 1
1496                 v0 := b.NewValue0(v.Pos, OpPPC64EQV, config.fe.TypeInt64())
1497                 v0.AddArg(x)
1498                 v0.AddArg(y)
1499                 v.AddArg(v0)
1500                 return true
1501         }
1502 }
1503 func rewriteValuePPC64_OpEqPtr(v *Value, config *Config) bool {
1504         b := v.Block
1505         _ = b
1506         // match: (EqPtr x y)
1507         // cond:
1508         // result: (Equal (CMP x y))
1509         for {
1510                 x := v.Args[0]
1511                 y := v.Args[1]
1512                 v.reset(OpPPC64Equal)
1513                 v0 := b.NewValue0(v.Pos, OpPPC64CMP, TypeFlags)
1514                 v0.AddArg(x)
1515                 v0.AddArg(y)
1516                 v.AddArg(v0)
1517                 return true
1518         }
1519 }
1520 func rewriteValuePPC64_OpGeq16(v *Value, config *Config) bool {
1521         b := v.Block
1522         _ = b
1523         // match: (Geq16 x y)
1524         // cond:
1525         // result: (GreaterEqual (CMPW (SignExt16to32 x) (SignExt16to32 y)))
1526         for {
1527                 x := v.Args[0]
1528                 y := v.Args[1]
1529                 v.reset(OpPPC64GreaterEqual)
1530                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
1531                 v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
1532                 v1.AddArg(x)
1533                 v0.AddArg(v1)
1534                 v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
1535                 v2.AddArg(y)
1536                 v0.AddArg(v2)
1537                 v.AddArg(v0)
1538                 return true
1539         }
1540 }
1541 func rewriteValuePPC64_OpGeq16U(v *Value, config *Config) bool {
1542         b := v.Block
1543         _ = b
1544         // match: (Geq16U x y)
1545         // cond:
1546         // result: (GreaterEqual (CMPU (ZeroExt16to32 x) (ZeroExt16to32 y)))
1547         for {
1548                 x := v.Args[0]
1549                 y := v.Args[1]
1550                 v.reset(OpPPC64GreaterEqual)
1551                 v0 := b.NewValue0(v.Pos, OpPPC64CMPU, TypeFlags)
1552                 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
1553                 v1.AddArg(x)
1554                 v0.AddArg(v1)
1555                 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
1556                 v2.AddArg(y)
1557                 v0.AddArg(v2)
1558                 v.AddArg(v0)
1559                 return true
1560         }
1561 }
1562 func rewriteValuePPC64_OpGeq32(v *Value, config *Config) bool {
1563         b := v.Block
1564         _ = b
1565         // match: (Geq32 x y)
1566         // cond:
1567         // result: (GreaterEqual (CMPW x y))
1568         for {
1569                 x := v.Args[0]
1570                 y := v.Args[1]
1571                 v.reset(OpPPC64GreaterEqual)
1572                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
1573                 v0.AddArg(x)
1574                 v0.AddArg(y)
1575                 v.AddArg(v0)
1576                 return true
1577         }
1578 }
1579 func rewriteValuePPC64_OpGeq32F(v *Value, config *Config) bool {
1580         b := v.Block
1581         _ = b
1582         // match: (Geq32F x y)
1583         // cond:
1584         // result: (FGreaterEqual (FCMPU x y))
1585         for {
1586                 x := v.Args[0]
1587                 y := v.Args[1]
1588                 v.reset(OpPPC64FGreaterEqual)
1589                 v0 := b.NewValue0(v.Pos, OpPPC64FCMPU, TypeFlags)
1590                 v0.AddArg(x)
1591                 v0.AddArg(y)
1592                 v.AddArg(v0)
1593                 return true
1594         }
1595 }
1596 func rewriteValuePPC64_OpGeq32U(v *Value, config *Config) bool {
1597         b := v.Block
1598         _ = b
1599         // match: (Geq32U x y)
1600         // cond:
1601         // result: (GreaterEqual (CMPU x y))
1602         for {
1603                 x := v.Args[0]
1604                 y := v.Args[1]
1605                 v.reset(OpPPC64GreaterEqual)
1606                 v0 := b.NewValue0(v.Pos, OpPPC64CMPU, TypeFlags)
1607                 v0.AddArg(x)
1608                 v0.AddArg(y)
1609                 v.AddArg(v0)
1610                 return true
1611         }
1612 }
1613 func rewriteValuePPC64_OpGeq64(v *Value, config *Config) bool {
1614         b := v.Block
1615         _ = b
1616         // match: (Geq64 x y)
1617         // cond:
1618         // result: (GreaterEqual (CMP x y))
1619         for {
1620                 x := v.Args[0]
1621                 y := v.Args[1]
1622                 v.reset(OpPPC64GreaterEqual)
1623                 v0 := b.NewValue0(v.Pos, OpPPC64CMP, TypeFlags)
1624                 v0.AddArg(x)
1625                 v0.AddArg(y)
1626                 v.AddArg(v0)
1627                 return true
1628         }
1629 }
1630 func rewriteValuePPC64_OpGeq64F(v *Value, config *Config) bool {
1631         b := v.Block
1632         _ = b
1633         // match: (Geq64F x y)
1634         // cond:
1635         // result: (FGreaterEqual (FCMPU x y))
1636         for {
1637                 x := v.Args[0]
1638                 y := v.Args[1]
1639                 v.reset(OpPPC64FGreaterEqual)
1640                 v0 := b.NewValue0(v.Pos, OpPPC64FCMPU, TypeFlags)
1641                 v0.AddArg(x)
1642                 v0.AddArg(y)
1643                 v.AddArg(v0)
1644                 return true
1645         }
1646 }
1647 func rewriteValuePPC64_OpGeq64U(v *Value, config *Config) bool {
1648         b := v.Block
1649         _ = b
1650         // match: (Geq64U x y)
1651         // cond:
1652         // result: (GreaterEqual (CMPU x y))
1653         for {
1654                 x := v.Args[0]
1655                 y := v.Args[1]
1656                 v.reset(OpPPC64GreaterEqual)
1657                 v0 := b.NewValue0(v.Pos, OpPPC64CMPU, TypeFlags)
1658                 v0.AddArg(x)
1659                 v0.AddArg(y)
1660                 v.AddArg(v0)
1661                 return true
1662         }
1663 }
1664 func rewriteValuePPC64_OpGeq8(v *Value, config *Config) bool {
1665         b := v.Block
1666         _ = b
1667         // match: (Geq8 x y)
1668         // cond:
1669         // result: (GreaterEqual (CMPW (SignExt8to32 x) (SignExt8to32 y)))
1670         for {
1671                 x := v.Args[0]
1672                 y := v.Args[1]
1673                 v.reset(OpPPC64GreaterEqual)
1674                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
1675                 v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
1676                 v1.AddArg(x)
1677                 v0.AddArg(v1)
1678                 v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
1679                 v2.AddArg(y)
1680                 v0.AddArg(v2)
1681                 v.AddArg(v0)
1682                 return true
1683         }
1684 }
1685 func rewriteValuePPC64_OpGeq8U(v *Value, config *Config) bool {
1686         b := v.Block
1687         _ = b
1688         // match: (Geq8U x y)
1689         // cond:
1690         // result: (GreaterEqual (CMPU (ZeroExt8to32 x) (ZeroExt8to32 y)))
1691         for {
1692                 x := v.Args[0]
1693                 y := v.Args[1]
1694                 v.reset(OpPPC64GreaterEqual)
1695                 v0 := b.NewValue0(v.Pos, OpPPC64CMPU, TypeFlags)
1696                 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
1697                 v1.AddArg(x)
1698                 v0.AddArg(v1)
1699                 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
1700                 v2.AddArg(y)
1701                 v0.AddArg(v2)
1702                 v.AddArg(v0)
1703                 return true
1704         }
1705 }
1706 func rewriteValuePPC64_OpGetClosurePtr(v *Value, config *Config) bool {
1707         b := v.Block
1708         _ = b
1709         // match: (GetClosurePtr)
1710         // cond:
1711         // result: (LoweredGetClosurePtr)
1712         for {
1713                 v.reset(OpPPC64LoweredGetClosurePtr)
1714                 return true
1715         }
1716 }
1717 func rewriteValuePPC64_OpGoCall(v *Value, config *Config) bool {
1718         b := v.Block
1719         _ = b
1720         // match: (GoCall [argwid] mem)
1721         // cond:
1722         // result: (CALLgo [argwid] mem)
1723         for {
1724                 argwid := v.AuxInt
1725                 mem := v.Args[0]
1726                 v.reset(OpPPC64CALLgo)
1727                 v.AuxInt = argwid
1728                 v.AddArg(mem)
1729                 return true
1730         }
1731 }
1732 func rewriteValuePPC64_OpGreater16(v *Value, config *Config) bool {
1733         b := v.Block
1734         _ = b
1735         // match: (Greater16 x y)
1736         // cond:
1737         // result: (GreaterThan (CMPW (SignExt16to32 x) (SignExt16to32 y)))
1738         for {
1739                 x := v.Args[0]
1740                 y := v.Args[1]
1741                 v.reset(OpPPC64GreaterThan)
1742                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
1743                 v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
1744                 v1.AddArg(x)
1745                 v0.AddArg(v1)
1746                 v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
1747                 v2.AddArg(y)
1748                 v0.AddArg(v2)
1749                 v.AddArg(v0)
1750                 return true
1751         }
1752 }
1753 func rewriteValuePPC64_OpGreater16U(v *Value, config *Config) bool {
1754         b := v.Block
1755         _ = b
1756         // match: (Greater16U x y)
1757         // cond:
1758         // result: (GreaterThan (CMPWU (ZeroExt16to32 x) (ZeroExt16to32 y)))
1759         for {
1760                 x := v.Args[0]
1761                 y := v.Args[1]
1762                 v.reset(OpPPC64GreaterThan)
1763                 v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
1764                 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
1765                 v1.AddArg(x)
1766                 v0.AddArg(v1)
1767                 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
1768                 v2.AddArg(y)
1769                 v0.AddArg(v2)
1770                 v.AddArg(v0)
1771                 return true
1772         }
1773 }
1774 func rewriteValuePPC64_OpGreater32(v *Value, config *Config) bool {
1775         b := v.Block
1776         _ = b
1777         // match: (Greater32 x y)
1778         // cond:
1779         // result: (GreaterThan (CMPW x y))
1780         for {
1781                 x := v.Args[0]
1782                 y := v.Args[1]
1783                 v.reset(OpPPC64GreaterThan)
1784                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
1785                 v0.AddArg(x)
1786                 v0.AddArg(y)
1787                 v.AddArg(v0)
1788                 return true
1789         }
1790 }
1791 func rewriteValuePPC64_OpGreater32F(v *Value, config *Config) bool {
1792         b := v.Block
1793         _ = b
1794         // match: (Greater32F x y)
1795         // cond:
1796         // result: (FGreaterThan (FCMPU x y))
1797         for {
1798                 x := v.Args[0]
1799                 y := v.Args[1]
1800                 v.reset(OpPPC64FGreaterThan)
1801                 v0 := b.NewValue0(v.Pos, OpPPC64FCMPU, TypeFlags)
1802                 v0.AddArg(x)
1803                 v0.AddArg(y)
1804                 v.AddArg(v0)
1805                 return true
1806         }
1807 }
1808 func rewriteValuePPC64_OpGreater32U(v *Value, config *Config) bool {
1809         b := v.Block
1810         _ = b
1811         // match: (Greater32U x y)
1812         // cond:
1813         // result: (GreaterThan (CMPWU x y))
1814         for {
1815                 x := v.Args[0]
1816                 y := v.Args[1]
1817                 v.reset(OpPPC64GreaterThan)
1818                 v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
1819                 v0.AddArg(x)
1820                 v0.AddArg(y)
1821                 v.AddArg(v0)
1822                 return true
1823         }
1824 }
1825 func rewriteValuePPC64_OpGreater64(v *Value, config *Config) bool {
1826         b := v.Block
1827         _ = b
1828         // match: (Greater64 x y)
1829         // cond:
1830         // result: (GreaterThan (CMP x y))
1831         for {
1832                 x := v.Args[0]
1833                 y := v.Args[1]
1834                 v.reset(OpPPC64GreaterThan)
1835                 v0 := b.NewValue0(v.Pos, OpPPC64CMP, TypeFlags)
1836                 v0.AddArg(x)
1837                 v0.AddArg(y)
1838                 v.AddArg(v0)
1839                 return true
1840         }
1841 }
1842 func rewriteValuePPC64_OpGreater64F(v *Value, config *Config) bool {
1843         b := v.Block
1844         _ = b
1845         // match: (Greater64F x y)
1846         // cond:
1847         // result: (FGreaterThan (FCMPU x y))
1848         for {
1849                 x := v.Args[0]
1850                 y := v.Args[1]
1851                 v.reset(OpPPC64FGreaterThan)
1852                 v0 := b.NewValue0(v.Pos, OpPPC64FCMPU, TypeFlags)
1853                 v0.AddArg(x)
1854                 v0.AddArg(y)
1855                 v.AddArg(v0)
1856                 return true
1857         }
1858 }
1859 func rewriteValuePPC64_OpGreater64U(v *Value, config *Config) bool {
1860         b := v.Block
1861         _ = b
1862         // match: (Greater64U x y)
1863         // cond:
1864         // result: (GreaterThan (CMPU x y))
1865         for {
1866                 x := v.Args[0]
1867                 y := v.Args[1]
1868                 v.reset(OpPPC64GreaterThan)
1869                 v0 := b.NewValue0(v.Pos, OpPPC64CMPU, TypeFlags)
1870                 v0.AddArg(x)
1871                 v0.AddArg(y)
1872                 v.AddArg(v0)
1873                 return true
1874         }
1875 }
1876 func rewriteValuePPC64_OpGreater8(v *Value, config *Config) bool {
1877         b := v.Block
1878         _ = b
1879         // match: (Greater8 x y)
1880         // cond:
1881         // result: (GreaterThan (CMPW (SignExt8to32 x) (SignExt8to32 y)))
1882         for {
1883                 x := v.Args[0]
1884                 y := v.Args[1]
1885                 v.reset(OpPPC64GreaterThan)
1886                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
1887                 v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
1888                 v1.AddArg(x)
1889                 v0.AddArg(v1)
1890                 v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
1891                 v2.AddArg(y)
1892                 v0.AddArg(v2)
1893                 v.AddArg(v0)
1894                 return true
1895         }
1896 }
1897 func rewriteValuePPC64_OpGreater8U(v *Value, config *Config) bool {
1898         b := v.Block
1899         _ = b
1900         // match: (Greater8U x y)
1901         // cond:
1902         // result: (GreaterThan (CMPWU (ZeroExt8to32 x) (ZeroExt8to32 y)))
1903         for {
1904                 x := v.Args[0]
1905                 y := v.Args[1]
1906                 v.reset(OpPPC64GreaterThan)
1907                 v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
1908                 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
1909                 v1.AddArg(x)
1910                 v0.AddArg(v1)
1911                 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
1912                 v2.AddArg(y)
1913                 v0.AddArg(v2)
1914                 v.AddArg(v0)
1915                 return true
1916         }
1917 }
1918 func rewriteValuePPC64_OpHmul16(v *Value, config *Config) bool {
1919         b := v.Block
1920         _ = b
1921         // match: (Hmul16 x y)
1922         // cond:
1923         // result: (SRAWconst (MULLW <config.fe.TypeInt32()> (SignExt16to32 x) (SignExt16to32 y)) [16])
1924         for {
1925                 x := v.Args[0]
1926                 y := v.Args[1]
1927                 v.reset(OpPPC64SRAWconst)
1928                 v.AuxInt = 16
1929                 v0 := b.NewValue0(v.Pos, OpPPC64MULLW, config.fe.TypeInt32())
1930                 v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
1931                 v1.AddArg(x)
1932                 v0.AddArg(v1)
1933                 v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
1934                 v2.AddArg(y)
1935                 v0.AddArg(v2)
1936                 v.AddArg(v0)
1937                 return true
1938         }
1939 }
1940 func rewriteValuePPC64_OpHmul16u(v *Value, config *Config) bool {
1941         b := v.Block
1942         _ = b
1943         // match: (Hmul16u x y)
1944         // cond:
1945         // result: (SRWconst (MULLW <config.fe.TypeUInt32()> (ZeroExt16to32 x) (ZeroExt16to32 y)) [16])
1946         for {
1947                 x := v.Args[0]
1948                 y := v.Args[1]
1949                 v.reset(OpPPC64SRWconst)
1950                 v.AuxInt = 16
1951                 v0 := b.NewValue0(v.Pos, OpPPC64MULLW, config.fe.TypeUInt32())
1952                 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
1953                 v1.AddArg(x)
1954                 v0.AddArg(v1)
1955                 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
1956                 v2.AddArg(y)
1957                 v0.AddArg(v2)
1958                 v.AddArg(v0)
1959                 return true
1960         }
1961 }
1962 func rewriteValuePPC64_OpHmul32(v *Value, config *Config) bool {
1963         b := v.Block
1964         _ = b
1965         // match: (Hmul32  x y)
1966         // cond:
1967         // result: (MULHW  x y)
1968         for {
1969                 x := v.Args[0]
1970                 y := v.Args[1]
1971                 v.reset(OpPPC64MULHW)
1972                 v.AddArg(x)
1973                 v.AddArg(y)
1974                 return true
1975         }
1976 }
1977 func rewriteValuePPC64_OpHmul32u(v *Value, config *Config) bool {
1978         b := v.Block
1979         _ = b
1980         // match: (Hmul32u  x y)
1981         // cond:
1982         // result: (MULHWU x y)
1983         for {
1984                 x := v.Args[0]
1985                 y := v.Args[1]
1986                 v.reset(OpPPC64MULHWU)
1987                 v.AddArg(x)
1988                 v.AddArg(y)
1989                 return true
1990         }
1991 }
1992 func rewriteValuePPC64_OpHmul64(v *Value, config *Config) bool {
1993         b := v.Block
1994         _ = b
1995         // match: (Hmul64  x y)
1996         // cond:
1997         // result: (MULHD  x y)
1998         for {
1999                 x := v.Args[0]
2000                 y := v.Args[1]
2001                 v.reset(OpPPC64MULHD)
2002                 v.AddArg(x)
2003                 v.AddArg(y)
2004                 return true
2005         }
2006 }
2007 func rewriteValuePPC64_OpHmul64u(v *Value, config *Config) bool {
2008         b := v.Block
2009         _ = b
2010         // match: (Hmul64u  x y)
2011         // cond:
2012         // result: (MULHDU x y)
2013         for {
2014                 x := v.Args[0]
2015                 y := v.Args[1]
2016                 v.reset(OpPPC64MULHDU)
2017                 v.AddArg(x)
2018                 v.AddArg(y)
2019                 return true
2020         }
2021 }
2022 func rewriteValuePPC64_OpHmul8(v *Value, config *Config) bool {
2023         b := v.Block
2024         _ = b
2025         // match: (Hmul8 x y)
2026         // cond:
2027         // result: (SRAWconst (MULLW <config.fe.TypeInt16()> (SignExt8to32 x) (SignExt8to32 y)) [8])
2028         for {
2029                 x := v.Args[0]
2030                 y := v.Args[1]
2031                 v.reset(OpPPC64SRAWconst)
2032                 v.AuxInt = 8
2033                 v0 := b.NewValue0(v.Pos, OpPPC64MULLW, config.fe.TypeInt16())
2034                 v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
2035                 v1.AddArg(x)
2036                 v0.AddArg(v1)
2037                 v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
2038                 v2.AddArg(y)
2039                 v0.AddArg(v2)
2040                 v.AddArg(v0)
2041                 return true
2042         }
2043 }
2044 func rewriteValuePPC64_OpHmul8u(v *Value, config *Config) bool {
2045         b := v.Block
2046         _ = b
2047         // match: (Hmul8u x y)
2048         // cond:
2049         // result: (SRWconst (MULLW <config.fe.TypeUInt16()> (ZeroExt8to32 x) (ZeroExt8to32 y)) [8])
2050         for {
2051                 x := v.Args[0]
2052                 y := v.Args[1]
2053                 v.reset(OpPPC64SRWconst)
2054                 v.AuxInt = 8
2055                 v0 := b.NewValue0(v.Pos, OpPPC64MULLW, config.fe.TypeUInt16())
2056                 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
2057                 v1.AddArg(x)
2058                 v0.AddArg(v1)
2059                 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
2060                 v2.AddArg(y)
2061                 v0.AddArg(v2)
2062                 v.AddArg(v0)
2063                 return true
2064         }
2065 }
2066 func rewriteValuePPC64_OpInterCall(v *Value, config *Config) bool {
2067         b := v.Block
2068         _ = b
2069         // match: (InterCall [argwid] entry mem)
2070         // cond:
2071         // result: (CALLinter [argwid] entry mem)
2072         for {
2073                 argwid := v.AuxInt
2074                 entry := v.Args[0]
2075                 mem := v.Args[1]
2076                 v.reset(OpPPC64CALLinter)
2077                 v.AuxInt = argwid
2078                 v.AddArg(entry)
2079                 v.AddArg(mem)
2080                 return true
2081         }
2082 }
2083 func rewriteValuePPC64_OpIsInBounds(v *Value, config *Config) bool {
2084         b := v.Block
2085         _ = b
2086         // match: (IsInBounds idx len)
2087         // cond:
2088         // result: (LessThan (CMPU idx len))
2089         for {
2090                 idx := v.Args[0]
2091                 len := v.Args[1]
2092                 v.reset(OpPPC64LessThan)
2093                 v0 := b.NewValue0(v.Pos, OpPPC64CMPU, TypeFlags)
2094                 v0.AddArg(idx)
2095                 v0.AddArg(len)
2096                 v.AddArg(v0)
2097                 return true
2098         }
2099 }
2100 func rewriteValuePPC64_OpIsNonNil(v *Value, config *Config) bool {
2101         b := v.Block
2102         _ = b
2103         // match: (IsNonNil ptr)
2104         // cond:
2105         // result: (NotEqual (CMPconst [0] ptr))
2106         for {
2107                 ptr := v.Args[0]
2108                 v.reset(OpPPC64NotEqual)
2109                 v0 := b.NewValue0(v.Pos, OpPPC64CMPconst, TypeFlags)
2110                 v0.AuxInt = 0
2111                 v0.AddArg(ptr)
2112                 v.AddArg(v0)
2113                 return true
2114         }
2115 }
2116 func rewriteValuePPC64_OpIsSliceInBounds(v *Value, config *Config) bool {
2117         b := v.Block
2118         _ = b
2119         // match: (IsSliceInBounds idx len)
2120         // cond:
2121         // result: (LessEqual (CMPU idx len))
2122         for {
2123                 idx := v.Args[0]
2124                 len := v.Args[1]
2125                 v.reset(OpPPC64LessEqual)
2126                 v0 := b.NewValue0(v.Pos, OpPPC64CMPU, TypeFlags)
2127                 v0.AddArg(idx)
2128                 v0.AddArg(len)
2129                 v.AddArg(v0)
2130                 return true
2131         }
2132 }
2133 func rewriteValuePPC64_OpLeq16(v *Value, config *Config) bool {
2134         b := v.Block
2135         _ = b
2136         // match: (Leq16 x y)
2137         // cond:
2138         // result: (LessEqual (CMPW (SignExt16to32 x) (SignExt16to32 y)))
2139         for {
2140                 x := v.Args[0]
2141                 y := v.Args[1]
2142                 v.reset(OpPPC64LessEqual)
2143                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
2144                 v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
2145                 v1.AddArg(x)
2146                 v0.AddArg(v1)
2147                 v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
2148                 v2.AddArg(y)
2149                 v0.AddArg(v2)
2150                 v.AddArg(v0)
2151                 return true
2152         }
2153 }
2154 func rewriteValuePPC64_OpLeq16U(v *Value, config *Config) bool {
2155         b := v.Block
2156         _ = b
2157         // match: (Leq16U x y)
2158         // cond:
2159         // result: (LessEqual (CMPWU (ZeroExt16to32 x) (ZeroExt16to32 y)))
2160         for {
2161                 x := v.Args[0]
2162                 y := v.Args[1]
2163                 v.reset(OpPPC64LessEqual)
2164                 v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
2165                 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
2166                 v1.AddArg(x)
2167                 v0.AddArg(v1)
2168                 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
2169                 v2.AddArg(y)
2170                 v0.AddArg(v2)
2171                 v.AddArg(v0)
2172                 return true
2173         }
2174 }
2175 func rewriteValuePPC64_OpLeq32(v *Value, config *Config) bool {
2176         b := v.Block
2177         _ = b
2178         // match: (Leq32 x y)
2179         // cond:
2180         // result: (LessEqual (CMPW x y))
2181         for {
2182                 x := v.Args[0]
2183                 y := v.Args[1]
2184                 v.reset(OpPPC64LessEqual)
2185                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
2186                 v0.AddArg(x)
2187                 v0.AddArg(y)
2188                 v.AddArg(v0)
2189                 return true
2190         }
2191 }
2192 func rewriteValuePPC64_OpLeq32F(v *Value, config *Config) bool {
2193         b := v.Block
2194         _ = b
2195         // match: (Leq32F x y)
2196         // cond:
2197         // result: (FLessEqual (FCMPU x y))
2198         for {
2199                 x := v.Args[0]
2200                 y := v.Args[1]
2201                 v.reset(OpPPC64FLessEqual)
2202                 v0 := b.NewValue0(v.Pos, OpPPC64FCMPU, TypeFlags)
2203                 v0.AddArg(x)
2204                 v0.AddArg(y)
2205                 v.AddArg(v0)
2206                 return true
2207         }
2208 }
2209 func rewriteValuePPC64_OpLeq32U(v *Value, config *Config) bool {
2210         b := v.Block
2211         _ = b
2212         // match: (Leq32U x y)
2213         // cond:
2214         // result: (LessEqual (CMPWU x y))
2215         for {
2216                 x := v.Args[0]
2217                 y := v.Args[1]
2218                 v.reset(OpPPC64LessEqual)
2219                 v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
2220                 v0.AddArg(x)
2221                 v0.AddArg(y)
2222                 v.AddArg(v0)
2223                 return true
2224         }
2225 }
2226 func rewriteValuePPC64_OpLeq64(v *Value, config *Config) bool {
2227         b := v.Block
2228         _ = b
2229         // match: (Leq64 x y)
2230         // cond:
2231         // result: (LessEqual (CMP x y))
2232         for {
2233                 x := v.Args[0]
2234                 y := v.Args[1]
2235                 v.reset(OpPPC64LessEqual)
2236                 v0 := b.NewValue0(v.Pos, OpPPC64CMP, TypeFlags)
2237                 v0.AddArg(x)
2238                 v0.AddArg(y)
2239                 v.AddArg(v0)
2240                 return true
2241         }
2242 }
2243 func rewriteValuePPC64_OpLeq64F(v *Value, config *Config) bool {
2244         b := v.Block
2245         _ = b
2246         // match: (Leq64F x y)
2247         // cond:
2248         // result: (FLessEqual (FCMPU x y))
2249         for {
2250                 x := v.Args[0]
2251                 y := v.Args[1]
2252                 v.reset(OpPPC64FLessEqual)
2253                 v0 := b.NewValue0(v.Pos, OpPPC64FCMPU, TypeFlags)
2254                 v0.AddArg(x)
2255                 v0.AddArg(y)
2256                 v.AddArg(v0)
2257                 return true
2258         }
2259 }
2260 func rewriteValuePPC64_OpLeq64U(v *Value, config *Config) bool {
2261         b := v.Block
2262         _ = b
2263         // match: (Leq64U x y)
2264         // cond:
2265         // result: (LessEqual (CMPU x y))
2266         for {
2267                 x := v.Args[0]
2268                 y := v.Args[1]
2269                 v.reset(OpPPC64LessEqual)
2270                 v0 := b.NewValue0(v.Pos, OpPPC64CMPU, TypeFlags)
2271                 v0.AddArg(x)
2272                 v0.AddArg(y)
2273                 v.AddArg(v0)
2274                 return true
2275         }
2276 }
2277 func rewriteValuePPC64_OpLeq8(v *Value, config *Config) bool {
2278         b := v.Block
2279         _ = b
2280         // match: (Leq8 x y)
2281         // cond:
2282         // result: (LessEqual (CMPW (SignExt8to32 x) (SignExt8to32 y)))
2283         for {
2284                 x := v.Args[0]
2285                 y := v.Args[1]
2286                 v.reset(OpPPC64LessEqual)
2287                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
2288                 v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
2289                 v1.AddArg(x)
2290                 v0.AddArg(v1)
2291                 v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
2292                 v2.AddArg(y)
2293                 v0.AddArg(v2)
2294                 v.AddArg(v0)
2295                 return true
2296         }
2297 }
2298 func rewriteValuePPC64_OpLeq8U(v *Value, config *Config) bool {
2299         b := v.Block
2300         _ = b
2301         // match: (Leq8U x y)
2302         // cond:
2303         // result: (LessEqual (CMPWU (ZeroExt8to32 x) (ZeroExt8to32 y)))
2304         for {
2305                 x := v.Args[0]
2306                 y := v.Args[1]
2307                 v.reset(OpPPC64LessEqual)
2308                 v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
2309                 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
2310                 v1.AddArg(x)
2311                 v0.AddArg(v1)
2312                 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
2313                 v2.AddArg(y)
2314                 v0.AddArg(v2)
2315                 v.AddArg(v0)
2316                 return true
2317         }
2318 }
2319 func rewriteValuePPC64_OpLess16(v *Value, config *Config) bool {
2320         b := v.Block
2321         _ = b
2322         // match: (Less16 x y)
2323         // cond:
2324         // result: (LessThan (CMPW (SignExt16to32 x) (SignExt16to32 y)))
2325         for {
2326                 x := v.Args[0]
2327                 y := v.Args[1]
2328                 v.reset(OpPPC64LessThan)
2329                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
2330                 v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
2331                 v1.AddArg(x)
2332                 v0.AddArg(v1)
2333                 v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
2334                 v2.AddArg(y)
2335                 v0.AddArg(v2)
2336                 v.AddArg(v0)
2337                 return true
2338         }
2339 }
2340 func rewriteValuePPC64_OpLess16U(v *Value, config *Config) bool {
2341         b := v.Block
2342         _ = b
2343         // match: (Less16U x y)
2344         // cond:
2345         // result: (LessThan (CMPWU (ZeroExt16to32 x) (ZeroExt16to32 y)))
2346         for {
2347                 x := v.Args[0]
2348                 y := v.Args[1]
2349                 v.reset(OpPPC64LessThan)
2350                 v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
2351                 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
2352                 v1.AddArg(x)
2353                 v0.AddArg(v1)
2354                 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
2355                 v2.AddArg(y)
2356                 v0.AddArg(v2)
2357                 v.AddArg(v0)
2358                 return true
2359         }
2360 }
2361 func rewriteValuePPC64_OpLess32(v *Value, config *Config) bool {
2362         b := v.Block
2363         _ = b
2364         // match: (Less32 x y)
2365         // cond:
2366         // result: (LessThan (CMPW x y))
2367         for {
2368                 x := v.Args[0]
2369                 y := v.Args[1]
2370                 v.reset(OpPPC64LessThan)
2371                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
2372                 v0.AddArg(x)
2373                 v0.AddArg(y)
2374                 v.AddArg(v0)
2375                 return true
2376         }
2377 }
2378 func rewriteValuePPC64_OpLess32F(v *Value, config *Config) bool {
2379         b := v.Block
2380         _ = b
2381         // match: (Less32F x y)
2382         // cond:
2383         // result: (FLessThan (FCMPU x y))
2384         for {
2385                 x := v.Args[0]
2386                 y := v.Args[1]
2387                 v.reset(OpPPC64FLessThan)
2388                 v0 := b.NewValue0(v.Pos, OpPPC64FCMPU, TypeFlags)
2389                 v0.AddArg(x)
2390                 v0.AddArg(y)
2391                 v.AddArg(v0)
2392                 return true
2393         }
2394 }
2395 func rewriteValuePPC64_OpLess32U(v *Value, config *Config) bool {
2396         b := v.Block
2397         _ = b
2398         // match: (Less32U x y)
2399         // cond:
2400         // result: (LessThan (CMPWU x y))
2401         for {
2402                 x := v.Args[0]
2403                 y := v.Args[1]
2404                 v.reset(OpPPC64LessThan)
2405                 v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
2406                 v0.AddArg(x)
2407                 v0.AddArg(y)
2408                 v.AddArg(v0)
2409                 return true
2410         }
2411 }
2412 func rewriteValuePPC64_OpLess64(v *Value, config *Config) bool {
2413         b := v.Block
2414         _ = b
2415         // match: (Less64 x y)
2416         // cond:
2417         // result: (LessThan (CMP x y))
2418         for {
2419                 x := v.Args[0]
2420                 y := v.Args[1]
2421                 v.reset(OpPPC64LessThan)
2422                 v0 := b.NewValue0(v.Pos, OpPPC64CMP, TypeFlags)
2423                 v0.AddArg(x)
2424                 v0.AddArg(y)
2425                 v.AddArg(v0)
2426                 return true
2427         }
2428 }
2429 func rewriteValuePPC64_OpLess64F(v *Value, config *Config) bool {
2430         b := v.Block
2431         _ = b
2432         // match: (Less64F x y)
2433         // cond:
2434         // result: (FLessThan (FCMPU x y))
2435         for {
2436                 x := v.Args[0]
2437                 y := v.Args[1]
2438                 v.reset(OpPPC64FLessThan)
2439                 v0 := b.NewValue0(v.Pos, OpPPC64FCMPU, TypeFlags)
2440                 v0.AddArg(x)
2441                 v0.AddArg(y)
2442                 v.AddArg(v0)
2443                 return true
2444         }
2445 }
2446 func rewriteValuePPC64_OpLess64U(v *Value, config *Config) bool {
2447         b := v.Block
2448         _ = b
2449         // match: (Less64U x y)
2450         // cond:
2451         // result: (LessThan (CMPU x y))
2452         for {
2453                 x := v.Args[0]
2454                 y := v.Args[1]
2455                 v.reset(OpPPC64LessThan)
2456                 v0 := b.NewValue0(v.Pos, OpPPC64CMPU, TypeFlags)
2457                 v0.AddArg(x)
2458                 v0.AddArg(y)
2459                 v.AddArg(v0)
2460                 return true
2461         }
2462 }
2463 func rewriteValuePPC64_OpLess8(v *Value, config *Config) bool {
2464         b := v.Block
2465         _ = b
2466         // match: (Less8 x y)
2467         // cond:
2468         // result: (LessThan (CMPW (SignExt8to32 x) (SignExt8to32 y)))
2469         for {
2470                 x := v.Args[0]
2471                 y := v.Args[1]
2472                 v.reset(OpPPC64LessThan)
2473                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
2474                 v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
2475                 v1.AddArg(x)
2476                 v0.AddArg(v1)
2477                 v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
2478                 v2.AddArg(y)
2479                 v0.AddArg(v2)
2480                 v.AddArg(v0)
2481                 return true
2482         }
2483 }
2484 func rewriteValuePPC64_OpLess8U(v *Value, config *Config) bool {
2485         b := v.Block
2486         _ = b
2487         // match: (Less8U x y)
2488         // cond:
2489         // result: (LessThan (CMPWU (ZeroExt8to32 x) (ZeroExt8to32 y)))
2490         for {
2491                 x := v.Args[0]
2492                 y := v.Args[1]
2493                 v.reset(OpPPC64LessThan)
2494                 v0 := b.NewValue0(v.Pos, OpPPC64CMPWU, TypeFlags)
2495                 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
2496                 v1.AddArg(x)
2497                 v0.AddArg(v1)
2498                 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
2499                 v2.AddArg(y)
2500                 v0.AddArg(v2)
2501                 v.AddArg(v0)
2502                 return true
2503         }
2504 }
2505 func rewriteValuePPC64_OpLoad(v *Value, config *Config) bool {
2506         b := v.Block
2507         _ = b
2508         // match: (Load <t> ptr mem)
2509         // cond: (is64BitInt(t) || isPtr(t))
2510         // result: (MOVDload ptr mem)
2511         for {
2512                 t := v.Type
2513                 ptr := v.Args[0]
2514                 mem := v.Args[1]
2515                 if !(is64BitInt(t) || isPtr(t)) {
2516                         break
2517                 }
2518                 v.reset(OpPPC64MOVDload)
2519                 v.AddArg(ptr)
2520                 v.AddArg(mem)
2521                 return true
2522         }
2523         // match: (Load <t> ptr mem)
2524         // cond: is32BitInt(t) && isSigned(t)
2525         // result: (MOVWload ptr mem)
2526         for {
2527                 t := v.Type
2528                 ptr := v.Args[0]
2529                 mem := v.Args[1]
2530                 if !(is32BitInt(t) && isSigned(t)) {
2531                         break
2532                 }
2533                 v.reset(OpPPC64MOVWload)
2534                 v.AddArg(ptr)
2535                 v.AddArg(mem)
2536                 return true
2537         }
2538         // match: (Load <t> ptr mem)
2539         // cond: is32BitInt(t) && !isSigned(t)
2540         // result: (MOVWZload ptr mem)
2541         for {
2542                 t := v.Type
2543                 ptr := v.Args[0]
2544                 mem := v.Args[1]
2545                 if !(is32BitInt(t) && !isSigned(t)) {
2546                         break
2547                 }
2548                 v.reset(OpPPC64MOVWZload)
2549                 v.AddArg(ptr)
2550                 v.AddArg(mem)
2551                 return true
2552         }
2553         // match: (Load <t> ptr mem)
2554         // cond: is16BitInt(t) && isSigned(t)
2555         // result: (MOVHload ptr mem)
2556         for {
2557                 t := v.Type
2558                 ptr := v.Args[0]
2559                 mem := v.Args[1]
2560                 if !(is16BitInt(t) && isSigned(t)) {
2561                         break
2562                 }
2563                 v.reset(OpPPC64MOVHload)
2564                 v.AddArg(ptr)
2565                 v.AddArg(mem)
2566                 return true
2567         }
2568         // match: (Load <t> ptr mem)
2569         // cond: is16BitInt(t) && !isSigned(t)
2570         // result: (MOVHZload ptr mem)
2571         for {
2572                 t := v.Type
2573                 ptr := v.Args[0]
2574                 mem := v.Args[1]
2575                 if !(is16BitInt(t) && !isSigned(t)) {
2576                         break
2577                 }
2578                 v.reset(OpPPC64MOVHZload)
2579                 v.AddArg(ptr)
2580                 v.AddArg(mem)
2581                 return true
2582         }
2583         // match: (Load <t> ptr mem)
2584         // cond: t.IsBoolean()
2585         // result: (MOVBZload ptr mem)
2586         for {
2587                 t := v.Type
2588                 ptr := v.Args[0]
2589                 mem := v.Args[1]
2590                 if !(t.IsBoolean()) {
2591                         break
2592                 }
2593                 v.reset(OpPPC64MOVBZload)
2594                 v.AddArg(ptr)
2595                 v.AddArg(mem)
2596                 return true
2597         }
2598         // match: (Load <t> ptr mem)
2599         // cond: is8BitInt(t) && isSigned(t)
2600         // result: (MOVBreg (MOVBZload ptr mem))
2601         for {
2602                 t := v.Type
2603                 ptr := v.Args[0]
2604                 mem := v.Args[1]
2605                 if !(is8BitInt(t) && isSigned(t)) {
2606                         break
2607                 }
2608                 v.reset(OpPPC64MOVBreg)
2609                 v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8())
2610                 v0.AddArg(ptr)
2611                 v0.AddArg(mem)
2612                 v.AddArg(v0)
2613                 return true
2614         }
2615         // match: (Load <t> ptr mem)
2616         // cond: is8BitInt(t) && !isSigned(t)
2617         // result: (MOVBZload ptr mem)
2618         for {
2619                 t := v.Type
2620                 ptr := v.Args[0]
2621                 mem := v.Args[1]
2622                 if !(is8BitInt(t) && !isSigned(t)) {
2623                         break
2624                 }
2625                 v.reset(OpPPC64MOVBZload)
2626                 v.AddArg(ptr)
2627                 v.AddArg(mem)
2628                 return true
2629         }
2630         // match: (Load <t> ptr mem)
2631         // cond: is32BitFloat(t)
2632         // result: (FMOVSload ptr mem)
2633         for {
2634                 t := v.Type
2635                 ptr := v.Args[0]
2636                 mem := v.Args[1]
2637                 if !(is32BitFloat(t)) {
2638                         break
2639                 }
2640                 v.reset(OpPPC64FMOVSload)
2641                 v.AddArg(ptr)
2642                 v.AddArg(mem)
2643                 return true
2644         }
2645         // match: (Load <t> ptr mem)
2646         // cond: is64BitFloat(t)
2647         // result: (FMOVDload ptr mem)
2648         for {
2649                 t := v.Type
2650                 ptr := v.Args[0]
2651                 mem := v.Args[1]
2652                 if !(is64BitFloat(t)) {
2653                         break
2654                 }
2655                 v.reset(OpPPC64FMOVDload)
2656                 v.AddArg(ptr)
2657                 v.AddArg(mem)
2658                 return true
2659         }
2660         return false
2661 }
2662 func rewriteValuePPC64_OpLsh16x16(v *Value, config *Config) bool {
2663         b := v.Block
2664         _ = b
2665         // match: (Lsh16x16 x y)
2666         // cond:
2667         // result: (SLW  x                 (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
2668         for {
2669                 x := v.Args[0]
2670                 y := v.Args[1]
2671                 v.reset(OpPPC64SLW)
2672                 v.AddArg(x)
2673                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
2674                 v0.AddArg(y)
2675                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
2676                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
2677                 v2.AuxInt = -16
2678                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64())
2679                 v3.AddArg(y)
2680                 v2.AddArg(v3)
2681                 v1.AddArg(v2)
2682                 v0.AddArg(v1)
2683                 v.AddArg(v0)
2684                 return true
2685         }
2686 }
2687 func rewriteValuePPC64_OpLsh16x32(v *Value, config *Config) bool {
2688         b := v.Block
2689         _ = b
2690         // match: (Lsh16x32  x (Const64 [c]))
2691         // cond: uint32(c) < 16
2692         // result: (SLWconst x [c])
2693         for {
2694                 x := v.Args[0]
2695                 v_1 := v.Args[1]
2696                 if v_1.Op != OpConst64 {
2697                         break
2698                 }
2699                 c := v_1.AuxInt
2700                 if !(uint32(c) < 16) {
2701                         break
2702                 }
2703                 v.reset(OpPPC64SLWconst)
2704                 v.AuxInt = c
2705                 v.AddArg(x)
2706                 return true
2707         }
2708         // match: (Lsh16x32  x (MOVDconst [c]))
2709         // cond: uint32(c) < 16
2710         // result: (SLWconst x [c])
2711         for {
2712                 x := v.Args[0]
2713                 v_1 := v.Args[1]
2714                 if v_1.Op != OpPPC64MOVDconst {
2715                         break
2716                 }
2717                 c := v_1.AuxInt
2718                 if !(uint32(c) < 16) {
2719                         break
2720                 }
2721                 v.reset(OpPPC64SLWconst)
2722                 v.AuxInt = c
2723                 v.AddArg(x)
2724                 return true
2725         }
2726         // match: (Lsh16x32 x y)
2727         // cond:
2728         // result: (SLW  x                 (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
2729         for {
2730                 x := v.Args[0]
2731                 y := v.Args[1]
2732                 v.reset(OpPPC64SLW)
2733                 v.AddArg(x)
2734                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
2735                 v0.AddArg(y)
2736                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
2737                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
2738                 v2.AuxInt = -16
2739                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64())
2740                 v3.AddArg(y)
2741                 v2.AddArg(v3)
2742                 v1.AddArg(v2)
2743                 v0.AddArg(v1)
2744                 v.AddArg(v0)
2745                 return true
2746         }
2747 }
2748 func rewriteValuePPC64_OpLsh16x64(v *Value, config *Config) bool {
2749         b := v.Block
2750         _ = b
2751         // match: (Lsh16x64  x (Const64 [c]))
2752         // cond: uint64(c) < 16
2753         // result: (SLWconst x [c])
2754         for {
2755                 x := v.Args[0]
2756                 v_1 := v.Args[1]
2757                 if v_1.Op != OpConst64 {
2758                         break
2759                 }
2760                 c := v_1.AuxInt
2761                 if !(uint64(c) < 16) {
2762                         break
2763                 }
2764                 v.reset(OpPPC64SLWconst)
2765                 v.AuxInt = c
2766                 v.AddArg(x)
2767                 return true
2768         }
2769         // match: (Lsh16x64  _ (Const64 [c]))
2770         // cond: uint64(c) >= 16
2771         // result: (MOVDconst [0])
2772         for {
2773                 v_1 := v.Args[1]
2774                 if v_1.Op != OpConst64 {
2775                         break
2776                 }
2777                 c := v_1.AuxInt
2778                 if !(uint64(c) >= 16) {
2779                         break
2780                 }
2781                 v.reset(OpPPC64MOVDconst)
2782                 v.AuxInt = 0
2783                 return true
2784         }
2785         // match: (Lsh16x64  x (MOVDconst [c]))
2786         // cond: uint64(c) < 16
2787         // result: (SLWconst x [c])
2788         for {
2789                 x := v.Args[0]
2790                 v_1 := v.Args[1]
2791                 if v_1.Op != OpPPC64MOVDconst {
2792                         break
2793                 }
2794                 c := v_1.AuxInt
2795                 if !(uint64(c) < 16) {
2796                         break
2797                 }
2798                 v.reset(OpPPC64SLWconst)
2799                 v.AuxInt = c
2800                 v.AddArg(x)
2801                 return true
2802         }
2803         // match: (Lsh16x64 x y)
2804         // cond:
2805         // result: (SLW  x                 (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
2806         for {
2807                 x := v.Args[0]
2808                 y := v.Args[1]
2809                 v.reset(OpPPC64SLW)
2810                 v.AddArg(x)
2811                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
2812                 v0.AddArg(y)
2813                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
2814                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
2815                 v2.AuxInt = -16
2816                 v2.AddArg(y)
2817                 v1.AddArg(v2)
2818                 v0.AddArg(v1)
2819                 v.AddArg(v0)
2820                 return true
2821         }
2822 }
2823 func rewriteValuePPC64_OpLsh16x8(v *Value, config *Config) bool {
2824         b := v.Block
2825         _ = b
2826         // match: (Lsh16x8 x y)
2827         // cond:
2828         // result: (SLW  x                 (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
2829         for {
2830                 x := v.Args[0]
2831                 y := v.Args[1]
2832                 v.reset(OpPPC64SLW)
2833                 v.AddArg(x)
2834                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
2835                 v0.AddArg(y)
2836                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
2837                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
2838                 v2.AuxInt = -16
2839                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64())
2840                 v3.AddArg(y)
2841                 v2.AddArg(v3)
2842                 v1.AddArg(v2)
2843                 v0.AddArg(v1)
2844                 v.AddArg(v0)
2845                 return true
2846         }
2847 }
2848 func rewriteValuePPC64_OpLsh32x16(v *Value, config *Config) bool {
2849         b := v.Block
2850         _ = b
2851         // match: (Lsh32x16 x y)
2852         // cond:
2853         // result: (SLW x  (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
2854         for {
2855                 x := v.Args[0]
2856                 y := v.Args[1]
2857                 v.reset(OpPPC64SLW)
2858                 v.AddArg(x)
2859                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
2860                 v0.AddArg(y)
2861                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
2862                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
2863                 v2.AuxInt = -32
2864                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64())
2865                 v3.AddArg(y)
2866                 v2.AddArg(v3)
2867                 v1.AddArg(v2)
2868                 v0.AddArg(v1)
2869                 v.AddArg(v0)
2870                 return true
2871         }
2872 }
2873 func rewriteValuePPC64_OpLsh32x32(v *Value, config *Config) bool {
2874         b := v.Block
2875         _ = b
2876         // match: (Lsh32x32  x (Const64 [c]))
2877         // cond: uint32(c) < 32
2878         // result: (SLWconst x [c])
2879         for {
2880                 x := v.Args[0]
2881                 v_1 := v.Args[1]
2882                 if v_1.Op != OpConst64 {
2883                         break
2884                 }
2885                 c := v_1.AuxInt
2886                 if !(uint32(c) < 32) {
2887                         break
2888                 }
2889                 v.reset(OpPPC64SLWconst)
2890                 v.AuxInt = c
2891                 v.AddArg(x)
2892                 return true
2893         }
2894         // match: (Lsh32x32  x (MOVDconst [c]))
2895         // cond: uint32(c) < 32
2896         // result: (SLWconst x [c])
2897         for {
2898                 x := v.Args[0]
2899                 v_1 := v.Args[1]
2900                 if v_1.Op != OpPPC64MOVDconst {
2901                         break
2902                 }
2903                 c := v_1.AuxInt
2904                 if !(uint32(c) < 32) {
2905                         break
2906                 }
2907                 v.reset(OpPPC64SLWconst)
2908                 v.AuxInt = c
2909                 v.AddArg(x)
2910                 return true
2911         }
2912         // match: (Lsh32x32 x y)
2913         // cond:
2914         // result: (SLW x  (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 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.Pos, OpPPC64ORN, config.fe.TypeInt64())
2921                 v0.AddArg(y)
2922                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
2923                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
2924                 v2.AuxInt = -32
2925                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64())
2926                 v3.AddArg(y)
2927                 v2.AddArg(v3)
2928                 v1.AddArg(v2)
2929                 v0.AddArg(v1)
2930                 v.AddArg(v0)
2931                 return true
2932         }
2933 }
2934 func rewriteValuePPC64_OpLsh32x64(v *Value, config *Config) bool {
2935         b := v.Block
2936         _ = b
2937         // match: (Lsh32x64  x (Const64 [c]))
2938         // cond: uint64(c) < 32
2939         // result: (SLWconst x [c])
2940         for {
2941                 x := v.Args[0]
2942                 v_1 := v.Args[1]
2943                 if v_1.Op != OpConst64 {
2944                         break
2945                 }
2946                 c := v_1.AuxInt
2947                 if !(uint64(c) < 32) {
2948                         break
2949                 }
2950                 v.reset(OpPPC64SLWconst)
2951                 v.AuxInt = c
2952                 v.AddArg(x)
2953                 return true
2954         }
2955         // match: (Lsh32x64  _ (Const64 [c]))
2956         // cond: uint64(c) >= 32
2957         // result: (MOVDconst [0])
2958         for {
2959                 v_1 := v.Args[1]
2960                 if v_1.Op != OpConst64 {
2961                         break
2962                 }
2963                 c := v_1.AuxInt
2964                 if !(uint64(c) >= 32) {
2965                         break
2966                 }
2967                 v.reset(OpPPC64MOVDconst)
2968                 v.AuxInt = 0
2969                 return true
2970         }
2971         // match: (Lsh32x64  x (MOVDconst [c]))
2972         // cond: uint64(c) < 32
2973         // result: (SLWconst x [c])
2974         for {
2975                 x := v.Args[0]
2976                 v_1 := v.Args[1]
2977                 if v_1.Op != OpPPC64MOVDconst {
2978                         break
2979                 }
2980                 c := v_1.AuxInt
2981                 if !(uint64(c) < 32) {
2982                         break
2983                 }
2984                 v.reset(OpPPC64SLWconst)
2985                 v.AuxInt = c
2986                 v.AddArg(x)
2987                 return true
2988         }
2989         // match: (Lsh32x64 x y)
2990         // cond:
2991         // result: (SLW  x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
2992         for {
2993                 x := v.Args[0]
2994                 y := v.Args[1]
2995                 v.reset(OpPPC64SLW)
2996                 v.AddArg(x)
2997                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
2998                 v0.AddArg(y)
2999                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
3000                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
3001                 v2.AuxInt = -32
3002                 v2.AddArg(y)
3003                 v1.AddArg(v2)
3004                 v0.AddArg(v1)
3005                 v.AddArg(v0)
3006                 return true
3007         }
3008 }
3009 func rewriteValuePPC64_OpLsh32x8(v *Value, config *Config) bool {
3010         b := v.Block
3011         _ = b
3012         // match: (Lsh32x8 x y)
3013         // cond:
3014         // result: (SLW x  (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
3015         for {
3016                 x := v.Args[0]
3017                 y := v.Args[1]
3018                 v.reset(OpPPC64SLW)
3019                 v.AddArg(x)
3020                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
3021                 v0.AddArg(y)
3022                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
3023                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
3024                 v2.AuxInt = -32
3025                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64())
3026                 v3.AddArg(y)
3027                 v2.AddArg(v3)
3028                 v1.AddArg(v2)
3029                 v0.AddArg(v1)
3030                 v.AddArg(v0)
3031                 return true
3032         }
3033 }
3034 func rewriteValuePPC64_OpLsh64x16(v *Value, config *Config) bool {
3035         b := v.Block
3036         _ = b
3037         // match: (Lsh64x16 x y)
3038         // cond:
3039         // result: (SLD x  (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
3040         for {
3041                 x := v.Args[0]
3042                 y := v.Args[1]
3043                 v.reset(OpPPC64SLD)
3044                 v.AddArg(x)
3045                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
3046                 v0.AddArg(y)
3047                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
3048                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
3049                 v2.AuxInt = -64
3050                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64())
3051                 v3.AddArg(y)
3052                 v2.AddArg(v3)
3053                 v1.AddArg(v2)
3054                 v0.AddArg(v1)
3055                 v.AddArg(v0)
3056                 return true
3057         }
3058 }
3059 func rewriteValuePPC64_OpLsh64x32(v *Value, config *Config) bool {
3060         b := v.Block
3061         _ = b
3062         // match: (Lsh64x32  x (Const64 [c]))
3063         // cond: uint32(c) < 64
3064         // result: (SLDconst x [c])
3065         for {
3066                 x := v.Args[0]
3067                 v_1 := v.Args[1]
3068                 if v_1.Op != OpConst64 {
3069                         break
3070                 }
3071                 c := v_1.AuxInt
3072                 if !(uint32(c) < 64) {
3073                         break
3074                 }
3075                 v.reset(OpPPC64SLDconst)
3076                 v.AuxInt = c
3077                 v.AddArg(x)
3078                 return true
3079         }
3080         // match: (Lsh64x32  x (MOVDconst [c]))
3081         // cond: uint32(c) < 64
3082         // result: (SLDconst x [c])
3083         for {
3084                 x := v.Args[0]
3085                 v_1 := v.Args[1]
3086                 if v_1.Op != OpPPC64MOVDconst {
3087                         break
3088                 }
3089                 c := v_1.AuxInt
3090                 if !(uint32(c) < 64) {
3091                         break
3092                 }
3093                 v.reset(OpPPC64SLDconst)
3094                 v.AuxInt = c
3095                 v.AddArg(x)
3096                 return true
3097         }
3098         // match: (Lsh64x32 x y)
3099         // cond:
3100         // result: (SLD x  (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
3101         for {
3102                 x := v.Args[0]
3103                 y := v.Args[1]
3104                 v.reset(OpPPC64SLD)
3105                 v.AddArg(x)
3106                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
3107                 v0.AddArg(y)
3108                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
3109                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
3110                 v2.AuxInt = -64
3111                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64())
3112                 v3.AddArg(y)
3113                 v2.AddArg(v3)
3114                 v1.AddArg(v2)
3115                 v0.AddArg(v1)
3116                 v.AddArg(v0)
3117                 return true
3118         }
3119 }
3120 func rewriteValuePPC64_OpLsh64x64(v *Value, config *Config) bool {
3121         b := v.Block
3122         _ = b
3123         // match: (Lsh64x64  x (Const64 [c]))
3124         // cond: uint64(c) < 64
3125         // result: (SLDconst x [c])
3126         for {
3127                 x := v.Args[0]
3128                 v_1 := v.Args[1]
3129                 if v_1.Op != OpConst64 {
3130                         break
3131                 }
3132                 c := v_1.AuxInt
3133                 if !(uint64(c) < 64) {
3134                         break
3135                 }
3136                 v.reset(OpPPC64SLDconst)
3137                 v.AuxInt = c
3138                 v.AddArg(x)
3139                 return true
3140         }
3141         // match: (Lsh64x64  _ (Const64 [c]))
3142         // cond: uint64(c) >= 64
3143         // result: (MOVDconst [0])
3144         for {
3145                 v_1 := v.Args[1]
3146                 if v_1.Op != OpConst64 {
3147                         break
3148                 }
3149                 c := v_1.AuxInt
3150                 if !(uint64(c) >= 64) {
3151                         break
3152                 }
3153                 v.reset(OpPPC64MOVDconst)
3154                 v.AuxInt = 0
3155                 return true
3156         }
3157         // match: (Lsh64x64  x (MOVDconst [c]))
3158         // cond: uint64(c) < 64
3159         // result: (SLDconst x [c])
3160         for {
3161                 x := v.Args[0]
3162                 v_1 := v.Args[1]
3163                 if v_1.Op != OpPPC64MOVDconst {
3164                         break
3165                 }
3166                 c := v_1.AuxInt
3167                 if !(uint64(c) < 64) {
3168                         break
3169                 }
3170                 v.reset(OpPPC64SLDconst)
3171                 v.AuxInt = c
3172                 v.AddArg(x)
3173                 return true
3174         }
3175         // match: (Lsh64x64 x y)
3176         // cond:
3177         // result: (SLD  x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
3178         for {
3179                 x := v.Args[0]
3180                 y := v.Args[1]
3181                 v.reset(OpPPC64SLD)
3182                 v.AddArg(x)
3183                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
3184                 v0.AddArg(y)
3185                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
3186                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
3187                 v2.AuxInt = -64
3188                 v2.AddArg(y)
3189                 v1.AddArg(v2)
3190                 v0.AddArg(v1)
3191                 v.AddArg(v0)
3192                 return true
3193         }
3194 }
3195 func rewriteValuePPC64_OpLsh64x8(v *Value, config *Config) bool {
3196         b := v.Block
3197         _ = b
3198         // match: (Lsh64x8 x y)
3199         // cond:
3200         // result: (SLD x  (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
3201         for {
3202                 x := v.Args[0]
3203                 y := v.Args[1]
3204                 v.reset(OpPPC64SLD)
3205                 v.AddArg(x)
3206                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
3207                 v0.AddArg(y)
3208                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
3209                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
3210                 v2.AuxInt = -64
3211                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64())
3212                 v3.AddArg(y)
3213                 v2.AddArg(v3)
3214                 v1.AddArg(v2)
3215                 v0.AddArg(v1)
3216                 v.AddArg(v0)
3217                 return true
3218         }
3219 }
3220 func rewriteValuePPC64_OpLsh8x16(v *Value, config *Config) bool {
3221         b := v.Block
3222         _ = b
3223         // match: (Lsh8x16 x y)
3224         // cond:
3225         // result: (SLW  x                (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
3226         for {
3227                 x := v.Args[0]
3228                 y := v.Args[1]
3229                 v.reset(OpPPC64SLW)
3230                 v.AddArg(x)
3231                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
3232                 v0.AddArg(y)
3233                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
3234                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
3235                 v2.AuxInt = -8
3236                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64())
3237                 v3.AddArg(y)
3238                 v2.AddArg(v3)
3239                 v1.AddArg(v2)
3240                 v0.AddArg(v1)
3241                 v.AddArg(v0)
3242                 return true
3243         }
3244 }
3245 func rewriteValuePPC64_OpLsh8x32(v *Value, config *Config) bool {
3246         b := v.Block
3247         _ = b
3248         // match: (Lsh8x32   x (Const64 [c]))
3249         // cond: uint32(c) < 8
3250         // result: (SLWconst x [c])
3251         for {
3252                 x := v.Args[0]
3253                 v_1 := v.Args[1]
3254                 if v_1.Op != OpConst64 {
3255                         break
3256                 }
3257                 c := v_1.AuxInt
3258                 if !(uint32(c) < 8) {
3259                         break
3260                 }
3261                 v.reset(OpPPC64SLWconst)
3262                 v.AuxInt = c
3263                 v.AddArg(x)
3264                 return true
3265         }
3266         // match: (Lsh8x32   x (MOVDconst [c]))
3267         // cond: uint32(c) < 8
3268         // result: (SLWconst x [c])
3269         for {
3270                 x := v.Args[0]
3271                 v_1 := v.Args[1]
3272                 if v_1.Op != OpPPC64MOVDconst {
3273                         break
3274                 }
3275                 c := v_1.AuxInt
3276                 if !(uint32(c) < 8) {
3277                         break
3278                 }
3279                 v.reset(OpPPC64SLWconst)
3280                 v.AuxInt = c
3281                 v.AddArg(x)
3282                 return true
3283         }
3284         // match: (Lsh8x32 x y)
3285         // cond:
3286         // result: (SLW  x                (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
3287         for {
3288                 x := v.Args[0]
3289                 y := v.Args[1]
3290                 v.reset(OpPPC64SLW)
3291                 v.AddArg(x)
3292                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
3293                 v0.AddArg(y)
3294                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
3295                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
3296                 v2.AuxInt = -8
3297                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64())
3298                 v3.AddArg(y)
3299                 v2.AddArg(v3)
3300                 v1.AddArg(v2)
3301                 v0.AddArg(v1)
3302                 v.AddArg(v0)
3303                 return true
3304         }
3305 }
3306 func rewriteValuePPC64_OpLsh8x64(v *Value, config *Config) bool {
3307         b := v.Block
3308         _ = b
3309         // match: (Lsh8x64   x (Const64 [c]))
3310         // cond: uint64(c) < 8
3311         // result: (SLWconst x [c])
3312         for {
3313                 x := v.Args[0]
3314                 v_1 := v.Args[1]
3315                 if v_1.Op != OpConst64 {
3316                         break
3317                 }
3318                 c := v_1.AuxInt
3319                 if !(uint64(c) < 8) {
3320                         break
3321                 }
3322                 v.reset(OpPPC64SLWconst)
3323                 v.AuxInt = c
3324                 v.AddArg(x)
3325                 return true
3326         }
3327         // match: (Lsh8x64   _ (Const64 [c]))
3328         // cond: uint64(c) >= 8
3329         // result: (MOVDconst [0])
3330         for {
3331                 v_1 := v.Args[1]
3332                 if v_1.Op != OpConst64 {
3333                         break
3334                 }
3335                 c := v_1.AuxInt
3336                 if !(uint64(c) >= 8) {
3337                         break
3338                 }
3339                 v.reset(OpPPC64MOVDconst)
3340                 v.AuxInt = 0
3341                 return true
3342         }
3343         // match: (Lsh8x64   x (MOVDconst [c]))
3344         // cond: uint64(c) < 8
3345         // result: (SLWconst x [c])
3346         for {
3347                 x := v.Args[0]
3348                 v_1 := v.Args[1]
3349                 if v_1.Op != OpPPC64MOVDconst {
3350                         break
3351                 }
3352                 c := v_1.AuxInt
3353                 if !(uint64(c) < 8) {
3354                         break
3355                 }
3356                 v.reset(OpPPC64SLWconst)
3357                 v.AuxInt = c
3358                 v.AddArg(x)
3359                 return true
3360         }
3361         // match: (Lsh8x64 x y)
3362         // cond:
3363         // result: (SLW  x                (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
3364         for {
3365                 x := v.Args[0]
3366                 y := v.Args[1]
3367                 v.reset(OpPPC64SLW)
3368                 v.AddArg(x)
3369                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
3370                 v0.AddArg(y)
3371                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
3372                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
3373                 v2.AuxInt = -8
3374                 v2.AddArg(y)
3375                 v1.AddArg(v2)
3376                 v0.AddArg(v1)
3377                 v.AddArg(v0)
3378                 return true
3379         }
3380 }
3381 func rewriteValuePPC64_OpLsh8x8(v *Value, config *Config) bool {
3382         b := v.Block
3383         _ = b
3384         // match: (Lsh8x8 x y)
3385         // cond:
3386         // result: (SLW  x                (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
3387         for {
3388                 x := v.Args[0]
3389                 y := v.Args[1]
3390                 v.reset(OpPPC64SLW)
3391                 v.AddArg(x)
3392                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
3393                 v0.AddArg(y)
3394                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
3395                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
3396                 v2.AuxInt = -8
3397                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64())
3398                 v3.AddArg(y)
3399                 v2.AddArg(v3)
3400                 v1.AddArg(v2)
3401                 v0.AddArg(v1)
3402                 v.AddArg(v0)
3403                 return true
3404         }
3405 }
3406 func rewriteValuePPC64_OpMod16(v *Value, config *Config) bool {
3407         b := v.Block
3408         _ = b
3409         // match: (Mod16 x y)
3410         // cond:
3411         // result: (Mod32 (SignExt16to32 x) (SignExt16to32 y))
3412         for {
3413                 x := v.Args[0]
3414                 y := v.Args[1]
3415                 v.reset(OpMod32)
3416                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
3417                 v0.AddArg(x)
3418                 v.AddArg(v0)
3419                 v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
3420                 v1.AddArg(y)
3421                 v.AddArg(v1)
3422                 return true
3423         }
3424 }
3425 func rewriteValuePPC64_OpMod16u(v *Value, config *Config) bool {
3426         b := v.Block
3427         _ = b
3428         // match: (Mod16u x y)
3429         // cond:
3430         // result: (Mod32u (ZeroExt16to32 x) (ZeroExt16to32 y))
3431         for {
3432                 x := v.Args[0]
3433                 y := v.Args[1]
3434                 v.reset(OpMod32u)
3435                 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
3436                 v0.AddArg(x)
3437                 v.AddArg(v0)
3438                 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
3439                 v1.AddArg(y)
3440                 v.AddArg(v1)
3441                 return true
3442         }
3443 }
3444 func rewriteValuePPC64_OpMod32(v *Value, config *Config) bool {
3445         b := v.Block
3446         _ = b
3447         // match: (Mod32 x y)
3448         // cond:
3449         // result: (SUB x (MULLW y (DIVW x y)))
3450         for {
3451                 x := v.Args[0]
3452                 y := v.Args[1]
3453                 v.reset(OpPPC64SUB)
3454                 v.AddArg(x)
3455                 v0 := b.NewValue0(v.Pos, OpPPC64MULLW, config.fe.TypeInt32())
3456                 v0.AddArg(y)
3457                 v1 := b.NewValue0(v.Pos, OpPPC64DIVW, config.fe.TypeInt32())
3458                 v1.AddArg(x)
3459                 v1.AddArg(y)
3460                 v0.AddArg(v1)
3461                 v.AddArg(v0)
3462                 return true
3463         }
3464 }
3465 func rewriteValuePPC64_OpMod32u(v *Value, config *Config) bool {
3466         b := v.Block
3467         _ = b
3468         // match: (Mod32u x y)
3469         // cond:
3470         // result: (SUB x (MULLW y (DIVWU x y)))
3471         for {
3472                 x := v.Args[0]
3473                 y := v.Args[1]
3474                 v.reset(OpPPC64SUB)
3475                 v.AddArg(x)
3476                 v0 := b.NewValue0(v.Pos, OpPPC64MULLW, config.fe.TypeInt32())
3477                 v0.AddArg(y)
3478                 v1 := b.NewValue0(v.Pos, OpPPC64DIVWU, config.fe.TypeInt32())
3479                 v1.AddArg(x)
3480                 v1.AddArg(y)
3481                 v0.AddArg(v1)
3482                 v.AddArg(v0)
3483                 return true
3484         }
3485 }
3486 func rewriteValuePPC64_OpMod64(v *Value, config *Config) bool {
3487         b := v.Block
3488         _ = b
3489         // match: (Mod64 x y)
3490         // cond:
3491         // result: (SUB x (MULLD y (DIVD x y)))
3492         for {
3493                 x := v.Args[0]
3494                 y := v.Args[1]
3495                 v.reset(OpPPC64SUB)
3496                 v.AddArg(x)
3497                 v0 := b.NewValue0(v.Pos, OpPPC64MULLD, config.fe.TypeInt64())
3498                 v0.AddArg(y)
3499                 v1 := b.NewValue0(v.Pos, OpPPC64DIVD, config.fe.TypeInt64())
3500                 v1.AddArg(x)
3501                 v1.AddArg(y)
3502                 v0.AddArg(v1)
3503                 v.AddArg(v0)
3504                 return true
3505         }
3506 }
3507 func rewriteValuePPC64_OpMod64u(v *Value, config *Config) bool {
3508         b := v.Block
3509         _ = b
3510         // match: (Mod64u x y)
3511         // cond:
3512         // result: (SUB x (MULLD y (DIVDU x y)))
3513         for {
3514                 x := v.Args[0]
3515                 y := v.Args[1]
3516                 v.reset(OpPPC64SUB)
3517                 v.AddArg(x)
3518                 v0 := b.NewValue0(v.Pos, OpPPC64MULLD, config.fe.TypeInt64())
3519                 v0.AddArg(y)
3520                 v1 := b.NewValue0(v.Pos, OpPPC64DIVDU, config.fe.TypeInt64())
3521                 v1.AddArg(x)
3522                 v1.AddArg(y)
3523                 v0.AddArg(v1)
3524                 v.AddArg(v0)
3525                 return true
3526         }
3527 }
3528 func rewriteValuePPC64_OpMod8(v *Value, config *Config) bool {
3529         b := v.Block
3530         _ = b
3531         // match: (Mod8 x y)
3532         // cond:
3533         // result: (Mod32 (SignExt8to32 x) (SignExt8to32 y))
3534         for {
3535                 x := v.Args[0]
3536                 y := v.Args[1]
3537                 v.reset(OpMod32)
3538                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
3539                 v0.AddArg(x)
3540                 v.AddArg(v0)
3541                 v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
3542                 v1.AddArg(y)
3543                 v.AddArg(v1)
3544                 return true
3545         }
3546 }
3547 func rewriteValuePPC64_OpMod8u(v *Value, config *Config) bool {
3548         b := v.Block
3549         _ = b
3550         // match: (Mod8u x y)
3551         // cond:
3552         // result: (Mod32u (ZeroExt8to32 x) (ZeroExt8to32 y))
3553         for {
3554                 x := v.Args[0]
3555                 y := v.Args[1]
3556                 v.reset(OpMod32u)
3557                 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
3558                 v0.AddArg(x)
3559                 v.AddArg(v0)
3560                 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
3561                 v1.AddArg(y)
3562                 v.AddArg(v1)
3563                 return true
3564         }
3565 }
3566 func rewriteValuePPC64_OpMove(v *Value, config *Config) bool {
3567         b := v.Block
3568         _ = b
3569         // match: (Move [s] _ _ mem)
3570         // cond: SizeAndAlign(s).Size() == 0
3571         // result: mem
3572         for {
3573                 s := v.AuxInt
3574                 mem := v.Args[2]
3575                 if !(SizeAndAlign(s).Size() == 0) {
3576                         break
3577                 }
3578                 v.reset(OpCopy)
3579                 v.Type = mem.Type
3580                 v.AddArg(mem)
3581                 return true
3582         }
3583         // match: (Move [s] dst src mem)
3584         // cond: SizeAndAlign(s).Size() == 1
3585         // result: (MOVBstore dst (MOVBZload src mem) mem)
3586         for {
3587                 s := v.AuxInt
3588                 dst := v.Args[0]
3589                 src := v.Args[1]
3590                 mem := v.Args[2]
3591                 if !(SizeAndAlign(s).Size() == 1) {
3592                         break
3593                 }
3594                 v.reset(OpPPC64MOVBstore)
3595                 v.AddArg(dst)
3596                 v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8())
3597                 v0.AddArg(src)
3598                 v0.AddArg(mem)
3599                 v.AddArg(v0)
3600                 v.AddArg(mem)
3601                 return true
3602         }
3603         // match: (Move [s] dst src mem)
3604         // cond: SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0
3605         // result: (MOVHstore dst (MOVHZload src mem) mem)
3606         for {
3607                 s := v.AuxInt
3608                 dst := v.Args[0]
3609                 src := v.Args[1]
3610                 mem := v.Args[2]
3611                 if !(SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0) {
3612                         break
3613                 }
3614                 v.reset(OpPPC64MOVHstore)
3615                 v.AddArg(dst)
3616                 v0 := b.NewValue0(v.Pos, OpPPC64MOVHZload, config.fe.TypeUInt16())
3617                 v0.AddArg(src)
3618                 v0.AddArg(mem)
3619                 v.AddArg(v0)
3620                 v.AddArg(mem)
3621                 return true
3622         }
3623         // match: (Move [s] dst src mem)
3624         // cond: SizeAndAlign(s).Size() == 2
3625         // result: (MOVBstore [1] dst (MOVBZload [1] src mem)           (MOVBstore dst (MOVBZload src mem) mem))
3626         for {
3627                 s := v.AuxInt
3628                 dst := v.Args[0]
3629                 src := v.Args[1]
3630                 mem := v.Args[2]
3631                 if !(SizeAndAlign(s).Size() == 2) {
3632                         break
3633                 }
3634                 v.reset(OpPPC64MOVBstore)
3635                 v.AuxInt = 1
3636                 v.AddArg(dst)
3637                 v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8())
3638                 v0.AuxInt = 1
3639                 v0.AddArg(src)
3640                 v0.AddArg(mem)
3641                 v.AddArg(v0)
3642                 v1 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem)
3643                 v1.AddArg(dst)
3644                 v2 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8())
3645                 v2.AddArg(src)
3646                 v2.AddArg(mem)
3647                 v1.AddArg(v2)
3648                 v1.AddArg(mem)
3649                 v.AddArg(v1)
3650                 return true
3651         }
3652         // match: (Move [s] dst src mem)
3653         // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0
3654         // result: (MOVWstore dst (MOVWload src mem) mem)
3655         for {
3656                 s := v.AuxInt
3657                 dst := v.Args[0]
3658                 src := v.Args[1]
3659                 mem := v.Args[2]
3660                 if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0) {
3661                         break
3662                 }
3663                 v.reset(OpPPC64MOVWstore)
3664                 v.AddArg(dst)
3665                 v0 := b.NewValue0(v.Pos, OpPPC64MOVWload, config.fe.TypeInt32())
3666                 v0.AddArg(src)
3667                 v0.AddArg(mem)
3668                 v.AddArg(v0)
3669                 v.AddArg(mem)
3670                 return true
3671         }
3672         // match: (Move [s] dst src mem)
3673         // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0
3674         // result: (MOVHstore [2] dst (MOVHZload [2] src mem)           (MOVHstore dst (MOVHZload src mem) mem))
3675         for {
3676                 s := v.AuxInt
3677                 dst := v.Args[0]
3678                 src := v.Args[1]
3679                 mem := v.Args[2]
3680                 if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0) {
3681                         break
3682                 }
3683                 v.reset(OpPPC64MOVHstore)
3684                 v.AuxInt = 2
3685                 v.AddArg(dst)
3686                 v0 := b.NewValue0(v.Pos, OpPPC64MOVHZload, config.fe.TypeUInt16())
3687                 v0.AuxInt = 2
3688                 v0.AddArg(src)
3689                 v0.AddArg(mem)
3690                 v.AddArg(v0)
3691                 v1 := b.NewValue0(v.Pos, OpPPC64MOVHstore, TypeMem)
3692                 v1.AddArg(dst)
3693                 v2 := b.NewValue0(v.Pos, OpPPC64MOVHZload, config.fe.TypeUInt16())
3694                 v2.AddArg(src)
3695                 v2.AddArg(mem)
3696                 v1.AddArg(v2)
3697                 v1.AddArg(mem)
3698                 v.AddArg(v1)
3699                 return true
3700         }
3701         // match: (Move [s] dst src mem)
3702         // cond: SizeAndAlign(s).Size() == 4
3703         // 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))))
3704         for {
3705                 s := v.AuxInt
3706                 dst := v.Args[0]
3707                 src := v.Args[1]
3708                 mem := v.Args[2]
3709                 if !(SizeAndAlign(s).Size() == 4) {
3710                         break
3711                 }
3712                 v.reset(OpPPC64MOVBstore)
3713                 v.AuxInt = 3
3714                 v.AddArg(dst)
3715                 v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8())
3716                 v0.AuxInt = 3
3717                 v0.AddArg(src)
3718                 v0.AddArg(mem)
3719                 v.AddArg(v0)
3720                 v1 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem)
3721                 v1.AuxInt = 2
3722                 v1.AddArg(dst)
3723                 v2 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8())
3724                 v2.AuxInt = 2
3725                 v2.AddArg(src)
3726                 v2.AddArg(mem)
3727                 v1.AddArg(v2)
3728                 v3 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem)
3729                 v3.AuxInt = 1
3730                 v3.AddArg(dst)
3731                 v4 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8())
3732                 v4.AuxInt = 1
3733                 v4.AddArg(src)
3734                 v4.AddArg(mem)
3735                 v3.AddArg(v4)
3736                 v5 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem)
3737                 v5.AddArg(dst)
3738                 v6 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8())
3739                 v6.AddArg(src)
3740                 v6.AddArg(mem)
3741                 v5.AddArg(v6)
3742                 v5.AddArg(mem)
3743                 v3.AddArg(v5)
3744                 v1.AddArg(v3)
3745                 v.AddArg(v1)
3746                 return true
3747         }
3748         // match: (Move [s] dst src mem)
3749         // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0
3750         // result: (MOVDstore dst (MOVDload src mem) mem)
3751         for {
3752                 s := v.AuxInt
3753                 dst := v.Args[0]
3754                 src := v.Args[1]
3755                 mem := v.Args[2]
3756                 if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0) {
3757                         break
3758                 }
3759                 v.reset(OpPPC64MOVDstore)
3760                 v.AddArg(dst)
3761                 v0 := b.NewValue0(v.Pos, OpPPC64MOVDload, config.fe.TypeInt64())
3762                 v0.AddArg(src)
3763                 v0.AddArg(mem)
3764                 v.AddArg(v0)
3765                 v.AddArg(mem)
3766                 return true
3767         }
3768         // match: (Move [s] dst src mem)
3769         // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0
3770         // result: (MOVWstore [4] dst (MOVWZload [4] src mem)           (MOVWstore dst (MOVWZload src mem) mem))
3771         for {
3772                 s := v.AuxInt
3773                 dst := v.Args[0]
3774                 src := v.Args[1]
3775                 mem := v.Args[2]
3776                 if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0) {
3777                         break
3778                 }
3779                 v.reset(OpPPC64MOVWstore)
3780                 v.AuxInt = 4
3781                 v.AddArg(dst)
3782                 v0 := b.NewValue0(v.Pos, OpPPC64MOVWZload, config.fe.TypeUInt32())
3783                 v0.AuxInt = 4
3784                 v0.AddArg(src)
3785                 v0.AddArg(mem)
3786                 v.AddArg(v0)
3787                 v1 := b.NewValue0(v.Pos, OpPPC64MOVWstore, TypeMem)
3788                 v1.AddArg(dst)
3789                 v2 := b.NewValue0(v.Pos, OpPPC64MOVWZload, config.fe.TypeUInt32())
3790                 v2.AddArg(src)
3791                 v2.AddArg(mem)
3792                 v1.AddArg(v2)
3793                 v1.AddArg(mem)
3794                 v.AddArg(v1)
3795                 return true
3796         }
3797         // match: (Move [s] dst src mem)
3798         // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0
3799         // 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))))
3800         for {
3801                 s := v.AuxInt
3802                 dst := v.Args[0]
3803                 src := v.Args[1]
3804                 mem := v.Args[2]
3805                 if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0) {
3806                         break
3807                 }
3808                 v.reset(OpPPC64MOVHstore)
3809                 v.AuxInt = 6
3810                 v.AddArg(dst)
3811                 v0 := b.NewValue0(v.Pos, OpPPC64MOVHZload, config.fe.TypeUInt16())
3812                 v0.AuxInt = 6
3813                 v0.AddArg(src)
3814                 v0.AddArg(mem)
3815                 v.AddArg(v0)
3816                 v1 := b.NewValue0(v.Pos, OpPPC64MOVHstore, TypeMem)
3817                 v1.AuxInt = 4
3818                 v1.AddArg(dst)
3819                 v2 := b.NewValue0(v.Pos, OpPPC64MOVHZload, config.fe.TypeUInt16())
3820                 v2.AuxInt = 4
3821                 v2.AddArg(src)
3822                 v2.AddArg(mem)
3823                 v1.AddArg(v2)
3824                 v3 := b.NewValue0(v.Pos, OpPPC64MOVHstore, TypeMem)
3825                 v3.AuxInt = 2
3826                 v3.AddArg(dst)
3827                 v4 := b.NewValue0(v.Pos, OpPPC64MOVHZload, config.fe.TypeUInt16())
3828                 v4.AuxInt = 2
3829                 v4.AddArg(src)
3830                 v4.AddArg(mem)
3831                 v3.AddArg(v4)
3832                 v5 := b.NewValue0(v.Pos, OpPPC64MOVHstore, TypeMem)
3833                 v5.AddArg(dst)
3834                 v6 := b.NewValue0(v.Pos, OpPPC64MOVHZload, config.fe.TypeUInt16())
3835                 v6.AddArg(src)
3836                 v6.AddArg(mem)
3837                 v5.AddArg(v6)
3838                 v5.AddArg(mem)
3839                 v3.AddArg(v5)
3840                 v1.AddArg(v3)
3841                 v.AddArg(v1)
3842                 return true
3843         }
3844         // match: (Move [s] dst src mem)
3845         // cond: SizeAndAlign(s).Size() == 3
3846         // result: (MOVBstore [2] dst (MOVBZload [2] src mem)           (MOVBstore [1] dst (MOVBZload [1] src mem)                      (MOVBstore dst (MOVBZload src mem) mem)))
3847         for {
3848                 s := v.AuxInt
3849                 dst := v.Args[0]
3850                 src := v.Args[1]
3851                 mem := v.Args[2]
3852                 if !(SizeAndAlign(s).Size() == 3) {
3853                         break
3854                 }
3855                 v.reset(OpPPC64MOVBstore)
3856                 v.AuxInt = 2
3857                 v.AddArg(dst)
3858                 v0 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8())
3859                 v0.AuxInt = 2
3860                 v0.AddArg(src)
3861                 v0.AddArg(mem)
3862                 v.AddArg(v0)
3863                 v1 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem)
3864                 v1.AuxInt = 1
3865                 v1.AddArg(dst)
3866                 v2 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8())
3867                 v2.AuxInt = 1
3868                 v2.AddArg(src)
3869                 v2.AddArg(mem)
3870                 v1.AddArg(v2)
3871                 v3 := b.NewValue0(v.Pos, OpPPC64MOVBstore, TypeMem)
3872                 v3.AddArg(dst)
3873                 v4 := b.NewValue0(v.Pos, OpPPC64MOVBZload, config.fe.TypeUInt8())
3874                 v4.AddArg(src)
3875                 v4.AddArg(mem)
3876                 v3.AddArg(v4)
3877                 v3.AddArg(mem)
3878                 v1.AddArg(v3)
3879                 v.AddArg(v1)
3880                 return true
3881         }
3882         // match: (Move [s] dst src mem)
3883         // cond: (SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%8 != 0
3884         // result: (LoweredMove [SizeAndAlign(s).Align()]               dst             src             (ADDconst <src.Type> src [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)])            mem)
3885         for {
3886                 s := v.AuxInt
3887                 dst := v.Args[0]
3888                 src := v.Args[1]
3889                 mem := v.Args[2]
3890                 if !((SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%8 != 0) {
3891                         break
3892                 }
3893                 v.reset(OpPPC64LoweredMove)
3894                 v.AuxInt = SizeAndAlign(s).Align()
3895                 v.AddArg(dst)
3896                 v.AddArg(src)
3897                 v0 := b.NewValue0(v.Pos, OpPPC64ADDconst, src.Type)
3898                 v0.AuxInt = SizeAndAlign(s).Size() - moveSize(SizeAndAlign(s).Align(), config)
3899                 v0.AddArg(src)
3900                 v.AddArg(v0)
3901                 v.AddArg(mem)
3902                 return true
3903         }
3904         return false
3905 }
3906 func rewriteValuePPC64_OpMul16(v *Value, config *Config) bool {
3907         b := v.Block
3908         _ = b
3909         // match: (Mul16  x y)
3910         // cond:
3911         // result: (MULLW x y)
3912         for {
3913                 x := v.Args[0]
3914                 y := v.Args[1]
3915                 v.reset(OpPPC64MULLW)
3916                 v.AddArg(x)
3917                 v.AddArg(y)
3918                 return true
3919         }
3920 }
3921 func rewriteValuePPC64_OpMul32(v *Value, config *Config) bool {
3922         b := v.Block
3923         _ = b
3924         // match: (Mul32  x y)
3925         // cond:
3926         // result: (MULLW  x y)
3927         for {
3928                 x := v.Args[0]
3929                 y := v.Args[1]
3930                 v.reset(OpPPC64MULLW)
3931                 v.AddArg(x)
3932                 v.AddArg(y)
3933                 return true
3934         }
3935 }
3936 func rewriteValuePPC64_OpMul32F(v *Value, config *Config) bool {
3937         b := v.Block
3938         _ = b
3939         // match: (Mul32F x y)
3940         // cond:
3941         // result: (FMULS x y)
3942         for {
3943                 x := v.Args[0]
3944                 y := v.Args[1]
3945                 v.reset(OpPPC64FMULS)
3946                 v.AddArg(x)
3947                 v.AddArg(y)
3948                 return true
3949         }
3950 }
3951 func rewriteValuePPC64_OpMul64(v *Value, config *Config) bool {
3952         b := v.Block
3953         _ = b
3954         // match: (Mul64  x y)
3955         // cond:
3956         // result: (MULLD  x y)
3957         for {
3958                 x := v.Args[0]
3959                 y := v.Args[1]
3960                 v.reset(OpPPC64MULLD)
3961                 v.AddArg(x)
3962                 v.AddArg(y)
3963                 return true
3964         }
3965 }
3966 func rewriteValuePPC64_OpMul64F(v *Value, config *Config) bool {
3967         b := v.Block
3968         _ = b
3969         // match: (Mul64F x y)
3970         // cond:
3971         // result: (FMUL x y)
3972         for {
3973                 x := v.Args[0]
3974                 y := v.Args[1]
3975                 v.reset(OpPPC64FMUL)
3976                 v.AddArg(x)
3977                 v.AddArg(y)
3978                 return true
3979         }
3980 }
3981 func rewriteValuePPC64_OpMul8(v *Value, config *Config) bool {
3982         b := v.Block
3983         _ = b
3984         // match: (Mul8   x y)
3985         // cond:
3986         // result: (MULLW x y)
3987         for {
3988                 x := v.Args[0]
3989                 y := v.Args[1]
3990                 v.reset(OpPPC64MULLW)
3991                 v.AddArg(x)
3992                 v.AddArg(y)
3993                 return true
3994         }
3995 }
3996 func rewriteValuePPC64_OpNeg16(v *Value, config *Config) bool {
3997         b := v.Block
3998         _ = b
3999         // match: (Neg16  x)
4000         // cond:
4001         // result: (NEG x)
4002         for {
4003                 x := v.Args[0]
4004                 v.reset(OpPPC64NEG)
4005                 v.AddArg(x)
4006                 return true
4007         }
4008 }
4009 func rewriteValuePPC64_OpNeg32(v *Value, config *Config) bool {
4010         b := v.Block
4011         _ = b
4012         // match: (Neg32  x)
4013         // cond:
4014         // result: (NEG x)
4015         for {
4016                 x := v.Args[0]
4017                 v.reset(OpPPC64NEG)
4018                 v.AddArg(x)
4019                 return true
4020         }
4021 }
4022 func rewriteValuePPC64_OpNeg32F(v *Value, config *Config) bool {
4023         b := v.Block
4024         _ = b
4025         // match: (Neg32F x)
4026         // cond:
4027         // result: (FNEG x)
4028         for {
4029                 x := v.Args[0]
4030                 v.reset(OpPPC64FNEG)
4031                 v.AddArg(x)
4032                 return true
4033         }
4034 }
4035 func rewriteValuePPC64_OpNeg64(v *Value, config *Config) bool {
4036         b := v.Block
4037         _ = b
4038         // match: (Neg64  x)
4039         // cond:
4040         // result: (NEG x)
4041         for {
4042                 x := v.Args[0]
4043                 v.reset(OpPPC64NEG)
4044                 v.AddArg(x)
4045                 return true
4046         }
4047 }
4048 func rewriteValuePPC64_OpNeg64F(v *Value, config *Config) bool {
4049         b := v.Block
4050         _ = b
4051         // match: (Neg64F x)
4052         // cond:
4053         // result: (FNEG x)
4054         for {
4055                 x := v.Args[0]
4056                 v.reset(OpPPC64FNEG)
4057                 v.AddArg(x)
4058                 return true
4059         }
4060 }
4061 func rewriteValuePPC64_OpNeg8(v *Value, config *Config) bool {
4062         b := v.Block
4063         _ = b
4064         // match: (Neg8   x)
4065         // cond:
4066         // result: (NEG x)
4067         for {
4068                 x := v.Args[0]
4069                 v.reset(OpPPC64NEG)
4070                 v.AddArg(x)
4071                 return true
4072         }
4073 }
4074 func rewriteValuePPC64_OpNeq16(v *Value, config *Config) bool {
4075         b := v.Block
4076         _ = b
4077         // match: (Neq16 x y)
4078         // cond: isSigned(x.Type) && isSigned(y.Type)
4079         // result: (NotEqual (CMPW (SignExt16to32 x) (SignExt16to32 y)))
4080         for {
4081                 x := v.Args[0]
4082                 y := v.Args[1]
4083                 if !(isSigned(x.Type) && isSigned(y.Type)) {
4084                         break
4085                 }
4086                 v.reset(OpPPC64NotEqual)
4087                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
4088                 v1 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
4089                 v1.AddArg(x)
4090                 v0.AddArg(v1)
4091                 v2 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
4092                 v2.AddArg(y)
4093                 v0.AddArg(v2)
4094                 v.AddArg(v0)
4095                 return true
4096         }
4097         // match: (Neq16 x y)
4098         // cond:
4099         // result: (NotEqual (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y)))
4100         for {
4101                 x := v.Args[0]
4102                 y := v.Args[1]
4103                 v.reset(OpPPC64NotEqual)
4104                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
4105                 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
4106                 v1.AddArg(x)
4107                 v0.AddArg(v1)
4108                 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
4109                 v2.AddArg(y)
4110                 v0.AddArg(v2)
4111                 v.AddArg(v0)
4112                 return true
4113         }
4114 }
4115 func rewriteValuePPC64_OpNeq32(v *Value, config *Config) bool {
4116         b := v.Block
4117         _ = b
4118         // match: (Neq32 x y)
4119         // cond:
4120         // result: (NotEqual (CMPW x y))
4121         for {
4122                 x := v.Args[0]
4123                 y := v.Args[1]
4124                 v.reset(OpPPC64NotEqual)
4125                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
4126                 v0.AddArg(x)
4127                 v0.AddArg(y)
4128                 v.AddArg(v0)
4129                 return true
4130         }
4131 }
4132 func rewriteValuePPC64_OpNeq32F(v *Value, config *Config) bool {
4133         b := v.Block
4134         _ = b
4135         // match: (Neq32F x y)
4136         // cond:
4137         // result: (NotEqual (FCMPU x y))
4138         for {
4139                 x := v.Args[0]
4140                 y := v.Args[1]
4141                 v.reset(OpPPC64NotEqual)
4142                 v0 := b.NewValue0(v.Pos, OpPPC64FCMPU, TypeFlags)
4143                 v0.AddArg(x)
4144                 v0.AddArg(y)
4145                 v.AddArg(v0)
4146                 return true
4147         }
4148 }
4149 func rewriteValuePPC64_OpNeq64(v *Value, config *Config) bool {
4150         b := v.Block
4151         _ = b
4152         // match: (Neq64 x y)
4153         // cond:
4154         // result: (NotEqual (CMP x y))
4155         for {
4156                 x := v.Args[0]
4157                 y := v.Args[1]
4158                 v.reset(OpPPC64NotEqual)
4159                 v0 := b.NewValue0(v.Pos, OpPPC64CMP, TypeFlags)
4160                 v0.AddArg(x)
4161                 v0.AddArg(y)
4162                 v.AddArg(v0)
4163                 return true
4164         }
4165 }
4166 func rewriteValuePPC64_OpNeq64F(v *Value, config *Config) bool {
4167         b := v.Block
4168         _ = b
4169         // match: (Neq64F x y)
4170         // cond:
4171         // result: (NotEqual (FCMPU x y))
4172         for {
4173                 x := v.Args[0]
4174                 y := v.Args[1]
4175                 v.reset(OpPPC64NotEqual)
4176                 v0 := b.NewValue0(v.Pos, OpPPC64FCMPU, TypeFlags)
4177                 v0.AddArg(x)
4178                 v0.AddArg(y)
4179                 v.AddArg(v0)
4180                 return true
4181         }
4182 }
4183 func rewriteValuePPC64_OpNeq8(v *Value, config *Config) bool {
4184         b := v.Block
4185         _ = b
4186         // match: (Neq8 x y)
4187         // cond: isSigned(x.Type) && isSigned(y.Type)
4188         // result: (NotEqual (CMPW (SignExt8to32 x) (SignExt8to32 y)))
4189         for {
4190                 x := v.Args[0]
4191                 y := v.Args[1]
4192                 if !(isSigned(x.Type) && isSigned(y.Type)) {
4193                         break
4194                 }
4195                 v.reset(OpPPC64NotEqual)
4196                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
4197                 v1 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
4198                 v1.AddArg(x)
4199                 v0.AddArg(v1)
4200                 v2 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
4201                 v2.AddArg(y)
4202                 v0.AddArg(v2)
4203                 v.AddArg(v0)
4204                 return true
4205         }
4206         // match: (Neq8 x y)
4207         // cond:
4208         // result: (NotEqual (CMPW (ZeroExt8to32 x) (ZeroExt8to32 y)))
4209         for {
4210                 x := v.Args[0]
4211                 y := v.Args[1]
4212                 v.reset(OpPPC64NotEqual)
4213                 v0 := b.NewValue0(v.Pos, OpPPC64CMPW, TypeFlags)
4214                 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
4215                 v1.AddArg(x)
4216                 v0.AddArg(v1)
4217                 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
4218                 v2.AddArg(y)
4219                 v0.AddArg(v2)
4220                 v.AddArg(v0)
4221                 return true
4222         }
4223 }
4224 func rewriteValuePPC64_OpNeqB(v *Value, config *Config) bool {
4225         b := v.Block
4226         _ = b
4227         // match: (NeqB x y)
4228         // cond:
4229         // result: (XOR x y)
4230         for {
4231                 x := v.Args[0]
4232                 y := v.Args[1]
4233                 v.reset(OpPPC64XOR)
4234                 v.AddArg(x)
4235                 v.AddArg(y)
4236                 return true
4237         }
4238 }
4239 func rewriteValuePPC64_OpNeqPtr(v *Value, config *Config) bool {
4240         b := v.Block
4241         _ = b
4242         // match: (NeqPtr x y)
4243         // cond:
4244         // result: (NotEqual (CMP x y))
4245         for {
4246                 x := v.Args[0]
4247                 y := v.Args[1]
4248                 v.reset(OpPPC64NotEqual)
4249                 v0 := b.NewValue0(v.Pos, OpPPC64CMP, TypeFlags)
4250                 v0.AddArg(x)
4251                 v0.AddArg(y)
4252                 v.AddArg(v0)
4253                 return true
4254         }
4255 }
4256 func rewriteValuePPC64_OpNilCheck(v *Value, config *Config) bool {
4257         b := v.Block
4258         _ = b
4259         // match: (NilCheck ptr mem)
4260         // cond:
4261         // result: (LoweredNilCheck ptr mem)
4262         for {
4263                 ptr := v.Args[0]
4264                 mem := v.Args[1]
4265                 v.reset(OpPPC64LoweredNilCheck)
4266                 v.AddArg(ptr)
4267                 v.AddArg(mem)
4268                 return true
4269         }
4270 }
4271 func rewriteValuePPC64_OpNot(v *Value, config *Config) bool {
4272         b := v.Block
4273         _ = b
4274         // match: (Not x)
4275         // cond:
4276         // result: (XORconst [1] x)
4277         for {
4278                 x := v.Args[0]
4279                 v.reset(OpPPC64XORconst)
4280                 v.AuxInt = 1
4281                 v.AddArg(x)
4282                 return true
4283         }
4284 }
4285 func rewriteValuePPC64_OpOffPtr(v *Value, config *Config) bool {
4286         b := v.Block
4287         _ = b
4288         // match: (OffPtr [off] ptr)
4289         // cond:
4290         // result: (ADD (MOVDconst <config.Frontend().TypeInt64()> [off]) ptr)
4291         for {
4292                 off := v.AuxInt
4293                 ptr := v.Args[0]
4294                 v.reset(OpPPC64ADD)
4295                 v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, config.Frontend().TypeInt64())
4296                 v0.AuxInt = off
4297                 v.AddArg(v0)
4298                 v.AddArg(ptr)
4299                 return true
4300         }
4301 }
4302 func rewriteValuePPC64_OpOr16(v *Value, config *Config) bool {
4303         b := v.Block
4304         _ = b
4305         // match: (Or16 x y)
4306         // cond:
4307         // result: (OR x y)
4308         for {
4309                 x := v.Args[0]
4310                 y := v.Args[1]
4311                 v.reset(OpPPC64OR)
4312                 v.AddArg(x)
4313                 v.AddArg(y)
4314                 return true
4315         }
4316 }
4317 func rewriteValuePPC64_OpOr32(v *Value, config *Config) bool {
4318         b := v.Block
4319         _ = b
4320         // match: (Or32 x y)
4321         // cond:
4322         // result: (OR x y)
4323         for {
4324                 x := v.Args[0]
4325                 y := v.Args[1]
4326                 v.reset(OpPPC64OR)
4327                 v.AddArg(x)
4328                 v.AddArg(y)
4329                 return true
4330         }
4331 }
4332 func rewriteValuePPC64_OpOr64(v *Value, config *Config) bool {
4333         b := v.Block
4334         _ = b
4335         // match: (Or64 x y)
4336         // cond:
4337         // result: (OR x y)
4338         for {
4339                 x := v.Args[0]
4340                 y := v.Args[1]
4341                 v.reset(OpPPC64OR)
4342                 v.AddArg(x)
4343                 v.AddArg(y)
4344                 return true
4345         }
4346 }
4347 func rewriteValuePPC64_OpOr8(v *Value, config *Config) bool {
4348         b := v.Block
4349         _ = b
4350         // match: (Or8  x y)
4351         // cond:
4352         // result: (OR x y)
4353         for {
4354                 x := v.Args[0]
4355                 y := v.Args[1]
4356                 v.reset(OpPPC64OR)
4357                 v.AddArg(x)
4358                 v.AddArg(y)
4359                 return true
4360         }
4361 }
4362 func rewriteValuePPC64_OpOrB(v *Value, config *Config) bool {
4363         b := v.Block
4364         _ = b
4365         // match: (OrB x y)
4366         // cond:
4367         // result: (OR x y)
4368         for {
4369                 x := v.Args[0]
4370                 y := v.Args[1]
4371                 v.reset(OpPPC64OR)
4372                 v.AddArg(x)
4373                 v.AddArg(y)
4374                 return true
4375         }
4376 }
4377 func rewriteValuePPC64_OpPPC64ADD(v *Value, config *Config) bool {
4378         b := v.Block
4379         _ = b
4380         // match: (ADD (MOVDconst [c]) x)
4381         // cond: is32Bit(c)
4382         // result: (ADDconst [c] x)
4383         for {
4384                 v_0 := v.Args[0]
4385                 if v_0.Op != OpPPC64MOVDconst {
4386                         break
4387                 }
4388                 c := v_0.AuxInt
4389                 x := v.Args[1]
4390                 if !(is32Bit(c)) {
4391                         break
4392                 }
4393                 v.reset(OpPPC64ADDconst)
4394                 v.AuxInt = c
4395                 v.AddArg(x)
4396                 return true
4397         }
4398         // match: (ADD x (MOVDconst [c]))
4399         // cond: is32Bit(c)
4400         // result: (ADDconst [c] x)
4401         for {
4402                 x := v.Args[0]
4403                 v_1 := v.Args[1]
4404                 if v_1.Op != OpPPC64MOVDconst {
4405                         break
4406                 }
4407                 c := v_1.AuxInt
4408                 if !(is32Bit(c)) {
4409                         break
4410                 }
4411                 v.reset(OpPPC64ADDconst)
4412                 v.AuxInt = c
4413                 v.AddArg(x)
4414                 return true
4415         }
4416         return false
4417 }
4418 func rewriteValuePPC64_OpPPC64ADDconst(v *Value, config *Config) bool {
4419         b := v.Block
4420         _ = b
4421         // match: (ADDconst [c] (ADDconst [d] x))
4422         // cond: is32Bit(c+d)
4423         // result: (ADDconst [c+d] x)
4424         for {
4425                 c := v.AuxInt
4426                 v_0 := v.Args[0]
4427                 if v_0.Op != OpPPC64ADDconst {
4428                         break
4429                 }
4430                 d := v_0.AuxInt
4431                 x := v_0.Args[0]
4432                 if !(is32Bit(c + d)) {
4433                         break
4434                 }
4435                 v.reset(OpPPC64ADDconst)
4436                 v.AuxInt = c + d
4437                 v.AddArg(x)
4438                 return true
4439         }
4440         // match: (ADDconst [0] x)
4441         // cond:
4442         // result: x
4443         for {
4444                 if v.AuxInt != 0 {
4445                         break
4446                 }
4447                 x := v.Args[0]
4448                 v.reset(OpCopy)
4449                 v.Type = x.Type
4450                 v.AddArg(x)
4451                 return true
4452         }
4453         // match: (ADDconst [c] (MOVDaddr [d] {sym} x))
4454         // cond:
4455         // result: (MOVDaddr [c+d] {sym} x)
4456         for {
4457                 c := v.AuxInt
4458                 v_0 := v.Args[0]
4459                 if v_0.Op != OpPPC64MOVDaddr {
4460                         break
4461                 }
4462                 d := v_0.AuxInt
4463                 sym := v_0.Aux
4464                 x := v_0.Args[0]
4465                 v.reset(OpPPC64MOVDaddr)
4466                 v.AuxInt = c + d
4467                 v.Aux = sym
4468                 v.AddArg(x)
4469                 return true
4470         }
4471         return false
4472 }
4473 func rewriteValuePPC64_OpPPC64AND(v *Value, config *Config) bool {
4474         b := v.Block
4475         _ = b
4476         // match: (AND x (XORconst [-1] y))
4477         // cond:
4478         // result: (ANDN x y)
4479         for {
4480                 x := v.Args[0]
4481                 v_1 := v.Args[1]
4482                 if v_1.Op != OpPPC64XORconst {
4483                         break
4484                 }
4485                 if v_1.AuxInt != -1 {
4486                         break
4487                 }
4488                 y := v_1.Args[0]
4489                 v.reset(OpPPC64ANDN)
4490                 v.AddArg(x)
4491                 v.AddArg(y)
4492                 return true
4493         }
4494         // match: (AND (MOVDconst [c]) (MOVDconst [d]))
4495         // cond:
4496         // result: (MOVDconst [c&d])
4497         for {
4498                 v_0 := v.Args[0]
4499                 if v_0.Op != OpPPC64MOVDconst {
4500                         break
4501                 }
4502                 c := v_0.AuxInt
4503                 v_1 := v.Args[1]
4504                 if v_1.Op != OpPPC64MOVDconst {
4505                         break
4506                 }
4507                 d := v_1.AuxInt
4508                 v.reset(OpPPC64MOVDconst)
4509                 v.AuxInt = c & d
4510                 return true
4511         }
4512         // match: (AND x (MOVDconst [c]))
4513         // cond: isU16Bit(c)
4514         // result: (ANDconst [c] x)
4515         for {
4516                 x := v.Args[0]
4517                 v_1 := v.Args[1]
4518                 if v_1.Op != OpPPC64MOVDconst {
4519                         break
4520                 }
4521                 c := v_1.AuxInt
4522                 if !(isU16Bit(c)) {
4523                         break
4524                 }
4525                 v.reset(OpPPC64ANDconst)
4526                 v.AuxInt = c
4527                 v.AddArg(x)
4528                 return true
4529         }
4530         // match: (AND (MOVDconst [c]) x)
4531         // cond: isU16Bit(c)
4532         // result: (ANDconst [c] x)
4533         for {
4534                 v_0 := v.Args[0]
4535                 if v_0.Op != OpPPC64MOVDconst {
4536                         break
4537                 }
4538                 c := v_0.AuxInt
4539                 x := v.Args[1]
4540                 if !(isU16Bit(c)) {
4541                         break
4542                 }
4543                 v.reset(OpPPC64ANDconst)
4544                 v.AuxInt = c
4545                 v.AddArg(x)
4546                 return true
4547         }
4548         // match: (AND (MOVDconst [c]) x:(MOVBZload _ _))
4549         // cond:
4550         // result: (ANDconst [c&0xFF] x)
4551         for {
4552                 v_0 := v.Args[0]
4553                 if v_0.Op != OpPPC64MOVDconst {
4554                         break
4555                 }
4556                 c := v_0.AuxInt
4557                 x := v.Args[1]
4558                 if x.Op != OpPPC64MOVBZload {
4559                         break
4560                 }
4561                 v.reset(OpPPC64ANDconst)
4562                 v.AuxInt = c & 0xFF
4563                 v.AddArg(x)
4564                 return true
4565         }
4566         // match: (AND x:(MOVBZload _ _) (MOVDconst [c]))
4567         // cond:
4568         // result: (ANDconst [c&0xFF] x)
4569         for {
4570                 x := v.Args[0]
4571                 if x.Op != OpPPC64MOVBZload {
4572                         break
4573                 }
4574                 v_1 := v.Args[1]
4575                 if v_1.Op != OpPPC64MOVDconst {
4576                         break
4577                 }
4578                 c := v_1.AuxInt
4579                 v.reset(OpPPC64ANDconst)
4580                 v.AuxInt = c & 0xFF
4581                 v.AddArg(x)
4582                 return true
4583         }
4584         return false
4585 }
4586 func rewriteValuePPC64_OpPPC64ANDconst(v *Value, config *Config) bool {
4587         b := v.Block
4588         _ = b
4589         // match: (ANDconst [c] (ANDconst [d] x))
4590         // cond:
4591         // result: (ANDconst [c&d] x)
4592         for {
4593                 c := v.AuxInt
4594                 v_0 := v.Args[0]
4595                 if v_0.Op != OpPPC64ANDconst {
4596                         break
4597                 }
4598                 d := v_0.AuxInt
4599                 x := v_0.Args[0]
4600                 v.reset(OpPPC64ANDconst)
4601                 v.AuxInt = c & d
4602                 v.AddArg(x)
4603                 return true
4604         }
4605         // match: (ANDconst [-1] x)
4606         // cond:
4607         // result: x
4608         for {
4609                 if v.AuxInt != -1 {
4610                         break
4611                 }
4612                 x := v.Args[0]
4613                 v.reset(OpCopy)
4614                 v.Type = x.Type
4615                 v.AddArg(x)
4616                 return true
4617         }
4618         // match: (ANDconst [0] _)
4619         // cond:
4620         // result: (MOVDconst [0])
4621         for {
4622                 if v.AuxInt != 0 {
4623                         break
4624                 }
4625                 v.reset(OpPPC64MOVDconst)
4626                 v.AuxInt = 0
4627                 return true
4628         }
4629         // match: (ANDconst [c] y:(MOVBZreg _))
4630         // cond: c&0xFF == 0xFF
4631         // result: y
4632         for {
4633                 c := v.AuxInt
4634                 y := v.Args[0]
4635                 if y.Op != OpPPC64MOVBZreg {
4636                         break
4637                 }
4638                 if !(c&0xFF == 0xFF) {
4639                         break
4640                 }
4641                 v.reset(OpCopy)
4642                 v.Type = y.Type
4643                 v.AddArg(y)
4644                 return true
4645         }
4646         // match: (ANDconst [c] y:(MOVHZreg _))
4647         // cond: c&0xFFFF == 0xFFFF
4648         // result: y
4649         for {
4650                 c := v.AuxInt
4651                 y := v.Args[0]
4652                 if y.Op != OpPPC64MOVHZreg {
4653                         break
4654                 }
4655                 if !(c&0xFFFF == 0xFFFF) {
4656                         break
4657                 }
4658                 v.reset(OpCopy)
4659                 v.Type = y.Type
4660                 v.AddArg(y)
4661                 return true
4662         }
4663         // match: (ANDconst [c] y:(MOVWZreg _))
4664         // cond: c&0xFFFFFFFF == 0xFFFFFFFF
4665         // result: y
4666         for {
4667                 c := v.AuxInt
4668                 y := v.Args[0]
4669                 if y.Op != OpPPC64MOVWZreg {
4670                         break
4671                 }
4672                 if !(c&0xFFFFFFFF == 0xFFFFFFFF) {
4673                         break
4674                 }
4675                 v.reset(OpCopy)
4676                 v.Type = y.Type
4677                 v.AddArg(y)
4678                 return true
4679         }
4680         // match: (ANDconst [c] (MOVBZreg x))
4681         // cond:
4682         // result: (ANDconst [c&0xFF] x)
4683         for {
4684                 c := v.AuxInt
4685                 v_0 := v.Args[0]
4686                 if v_0.Op != OpPPC64MOVBZreg {
4687                         break
4688                 }
4689                 x := v_0.Args[0]
4690                 v.reset(OpPPC64ANDconst)
4691                 v.AuxInt = c & 0xFF
4692                 v.AddArg(x)
4693                 return true
4694         }
4695         // match: (ANDconst [c] (MOVHZreg x))
4696         // cond:
4697         // result: (ANDconst [c&0xFFFF] x)
4698         for {
4699                 c := v.AuxInt
4700                 v_0 := v.Args[0]
4701                 if v_0.Op != OpPPC64MOVHZreg {
4702                         break
4703                 }
4704                 x := v_0.Args[0]
4705                 v.reset(OpPPC64ANDconst)
4706                 v.AuxInt = c & 0xFFFF
4707                 v.AddArg(x)
4708                 return true
4709         }
4710         // match: (ANDconst [c] (MOVWZreg x))
4711         // cond:
4712         // result: (ANDconst [c&0xFFFFFFFF] x)
4713         for {
4714                 c := v.AuxInt
4715                 v_0 := v.Args[0]
4716                 if v_0.Op != OpPPC64MOVWZreg {
4717                         break
4718                 }
4719                 x := v_0.Args[0]
4720                 v.reset(OpPPC64ANDconst)
4721                 v.AuxInt = c & 0xFFFFFFFF
4722                 v.AddArg(x)
4723                 return true
4724         }
4725         return false
4726 }
4727 func rewriteValuePPC64_OpPPC64CMP(v *Value, config *Config) bool {
4728         b := v.Block
4729         _ = b
4730         // match: (CMP x (MOVDconst [c]))
4731         // cond: is16Bit(c)
4732         // result: (CMPconst x [c])
4733         for {
4734                 x := v.Args[0]
4735                 v_1 := v.Args[1]
4736                 if v_1.Op != OpPPC64MOVDconst {
4737                         break
4738                 }
4739                 c := v_1.AuxInt
4740                 if !(is16Bit(c)) {
4741                         break
4742                 }
4743                 v.reset(OpPPC64CMPconst)
4744                 v.AuxInt = c
4745                 v.AddArg(x)
4746                 return true
4747         }
4748         // match: (CMP (MOVDconst [c]) y)
4749         // cond: is16Bit(c)
4750         // result: (InvertFlags (CMPconst y [c]))
4751         for {
4752                 v_0 := v.Args[0]
4753                 if v_0.Op != OpPPC64MOVDconst {
4754                         break
4755                 }
4756                 c := v_0.AuxInt
4757                 y := v.Args[1]
4758                 if !(is16Bit(c)) {
4759                         break
4760                 }
4761                 v.reset(OpPPC64InvertFlags)
4762                 v0 := b.NewValue0(v.Pos, OpPPC64CMPconst, TypeFlags)
4763                 v0.AuxInt = c
4764                 v0.AddArg(y)
4765                 v.AddArg(v0)
4766                 return true
4767         }
4768         return false
4769 }
4770 func rewriteValuePPC64_OpPPC64CMPU(v *Value, config *Config) bool {
4771         b := v.Block
4772         _ = b
4773         // match: (CMPU x (MOVDconst [c]))
4774         // cond: isU16Bit(c)
4775         // result: (CMPUconst x [c])
4776         for {
4777                 x := v.Args[0]
4778                 v_1 := v.Args[1]
4779                 if v_1.Op != OpPPC64MOVDconst {
4780                         break
4781                 }
4782                 c := v_1.AuxInt
4783                 if !(isU16Bit(c)) {
4784                         break
4785                 }
4786                 v.reset(OpPPC64CMPUconst)
4787                 v.AuxInt = c
4788                 v.AddArg(x)
4789                 return true
4790         }
4791         // match: (CMPU (MOVDconst [c]) y)
4792         // cond: isU16Bit(c)
4793         // result: (InvertFlags (CMPUconst y [c]))
4794         for {
4795                 v_0 := v.Args[0]
4796                 if v_0.Op != OpPPC64MOVDconst {
4797                         break
4798                 }
4799                 c := v_0.AuxInt
4800                 y := v.Args[1]
4801                 if !(isU16Bit(c)) {
4802                         break
4803                 }
4804                 v.reset(OpPPC64InvertFlags)
4805                 v0 := b.NewValue0(v.Pos, OpPPC64CMPUconst, TypeFlags)
4806                 v0.AuxInt = c
4807                 v0.AddArg(y)
4808                 v.AddArg(v0)
4809                 return true
4810         }
4811         return false
4812 }
4813 func rewriteValuePPC64_OpPPC64CMPUconst(v *Value, config *Config) bool {
4814         b := v.Block
4815         _ = b
4816         // match: (CMPUconst (MOVDconst [x]) [y])
4817         // cond: int64(x)==int64(y)
4818         // result: (FlagEQ)
4819         for {
4820                 y := v.AuxInt
4821                 v_0 := v.Args[0]
4822                 if v_0.Op != OpPPC64MOVDconst {
4823                         break
4824                 }
4825                 x := v_0.AuxInt
4826                 if !(int64(x) == int64(y)) {
4827                         break
4828                 }
4829                 v.reset(OpPPC64FlagEQ)
4830                 return true
4831         }
4832         // match: (CMPUconst (MOVDconst [x]) [y])
4833         // cond: uint64(x)<uint64(y)
4834         // result: (FlagLT)
4835         for {
4836                 y := v.AuxInt
4837                 v_0 := v.Args[0]
4838                 if v_0.Op != OpPPC64MOVDconst {
4839                         break
4840                 }
4841                 x := v_0.AuxInt
4842                 if !(uint64(x) < uint64(y)) {
4843                         break
4844                 }
4845                 v.reset(OpPPC64FlagLT)
4846                 return true
4847         }
4848         // match: (CMPUconst (MOVDconst [x]) [y])
4849         // cond: uint64(x)>uint64(y)
4850         // result: (FlagGT)
4851         for {
4852                 y := v.AuxInt
4853                 v_0 := v.Args[0]
4854                 if v_0.Op != OpPPC64MOVDconst {
4855                         break
4856                 }
4857                 x := v_0.AuxInt
4858                 if !(uint64(x) > uint64(y)) {
4859                         break
4860                 }
4861                 v.reset(OpPPC64FlagGT)
4862                 return true
4863         }
4864         return false
4865 }
4866 func rewriteValuePPC64_OpPPC64CMPW(v *Value, config *Config) bool {
4867         b := v.Block
4868         _ = b
4869         // match: (CMPW x (MOVWreg y))
4870         // cond:
4871         // result: (CMPW x y)
4872         for {
4873                 x := v.Args[0]
4874                 v_1 := v.Args[1]
4875                 if v_1.Op != OpPPC64MOVWreg {
4876                         break
4877                 }
4878                 y := v_1.Args[0]
4879                 v.reset(OpPPC64CMPW)
4880                 v.AddArg(x)
4881                 v.AddArg(y)
4882                 return true
4883         }
4884         // match: (CMPW (MOVWreg x) y)
4885         // cond:
4886         // result: (CMPW x y)
4887         for {
4888                 v_0 := v.Args[0]
4889                 if v_0.Op != OpPPC64MOVWreg {
4890                         break
4891                 }
4892                 x := v_0.Args[0]
4893                 y := v.Args[1]
4894                 v.reset(OpPPC64CMPW)
4895                 v.AddArg(x)
4896                 v.AddArg(y)
4897                 return true
4898         }
4899         // match: (CMPW x (MOVDconst [c]))
4900         // cond: is16Bit(c)
4901         // result: (CMPWconst x [c])
4902         for {
4903                 x := v.Args[0]
4904                 v_1 := v.Args[1]
4905                 if v_1.Op != OpPPC64MOVDconst {
4906                         break
4907                 }
4908                 c := v_1.AuxInt
4909                 if !(is16Bit(c)) {
4910                         break
4911                 }
4912                 v.reset(OpPPC64CMPWconst)
4913                 v.AuxInt = c
4914                 v.AddArg(x)
4915                 return true
4916         }
4917         // match: (CMPW (MOVDconst [c]) y)
4918         // cond: is16Bit(c)
4919         // result: (InvertFlags (CMPWconst y [c]))
4920         for {
4921                 v_0 := v.Args[0]
4922                 if v_0.Op != OpPPC64MOVDconst {
4923                         break
4924                 }
4925                 c := v_0.AuxInt
4926                 y := v.Args[1]
4927                 if !(is16Bit(c)) {
4928                         break
4929                 }
4930                 v.reset(OpPPC64InvertFlags)
4931                 v0 := b.NewValue0(v.Pos, OpPPC64CMPWconst, TypeFlags)
4932                 v0.AuxInt = c
4933                 v0.AddArg(y)
4934                 v.AddArg(v0)
4935                 return true
4936         }
4937         return false
4938 }
4939 func rewriteValuePPC64_OpPPC64CMPWU(v *Value, config *Config) bool {
4940         b := v.Block
4941         _ = b
4942         // match: (CMPWU x (MOVWZreg y))
4943         // cond:
4944         // result: (CMPWU x y)
4945         for {
4946                 x := v.Args[0]
4947                 v_1 := v.Args[1]
4948                 if v_1.Op != OpPPC64MOVWZreg {
4949                         break
4950                 }
4951                 y := v_1.Args[0]
4952                 v.reset(OpPPC64CMPWU)
4953                 v.AddArg(x)
4954                 v.AddArg(y)
4955                 return true
4956         }
4957         // match: (CMPWU (MOVWZreg x) y)
4958         // cond:
4959         // result: (CMPWU x y)
4960         for {
4961                 v_0 := v.Args[0]
4962                 if v_0.Op != OpPPC64MOVWZreg {
4963                         break
4964                 }
4965                 x := v_0.Args[0]
4966                 y := v.Args[1]
4967                 v.reset(OpPPC64CMPWU)
4968                 v.AddArg(x)
4969                 v.AddArg(y)
4970                 return true
4971         }
4972         // match: (CMPWU x (MOVDconst [c]))
4973         // cond: isU16Bit(c)
4974         // result: (CMPWUconst x [c])
4975         for {
4976                 x := v.Args[0]
4977                 v_1 := v.Args[1]
4978                 if v_1.Op != OpPPC64MOVDconst {
4979                         break
4980                 }
4981                 c := v_1.AuxInt
4982                 if !(isU16Bit(c)) {
4983                         break
4984                 }
4985                 v.reset(OpPPC64CMPWUconst)
4986                 v.AuxInt = c
4987                 v.AddArg(x)
4988                 return true
4989         }
4990         // match: (CMPWU (MOVDconst [c]) y)
4991         // cond: isU16Bit(c)
4992         // result: (InvertFlags (CMPWUconst y [c]))
4993         for {
4994                 v_0 := v.Args[0]
4995                 if v_0.Op != OpPPC64MOVDconst {
4996                         break
4997                 }
4998                 c := v_0.AuxInt
4999                 y := v.Args[1]
5000                 if !(isU16Bit(c)) {
5001                         break
5002                 }
5003                 v.reset(OpPPC64InvertFlags)
5004                 v0 := b.NewValue0(v.Pos, OpPPC64CMPWUconst, TypeFlags)
5005                 v0.AuxInt = c
5006                 v0.AddArg(y)
5007                 v.AddArg(v0)
5008                 return true
5009         }
5010         return false
5011 }
5012 func rewriteValuePPC64_OpPPC64CMPWUconst(v *Value, config *Config) bool {
5013         b := v.Block
5014         _ = b
5015         // match: (CMPWUconst (MOVDconst [x]) [y])
5016         // cond: int32(x)==int32(y)
5017         // result: (FlagEQ)
5018         for {
5019                 y := v.AuxInt
5020                 v_0 := v.Args[0]
5021                 if v_0.Op != OpPPC64MOVDconst {
5022                         break
5023                 }
5024                 x := v_0.AuxInt
5025                 if !(int32(x) == int32(y)) {
5026                         break
5027                 }
5028                 v.reset(OpPPC64FlagEQ)
5029                 return true
5030         }
5031         // match: (CMPWUconst (MOVDconst [x]) [y])
5032         // cond: uint32(x)<uint32(y)
5033         // result: (FlagLT)
5034         for {
5035                 y := v.AuxInt
5036                 v_0 := v.Args[0]
5037                 if v_0.Op != OpPPC64MOVDconst {
5038                         break
5039                 }
5040                 x := v_0.AuxInt
5041                 if !(uint32(x) < uint32(y)) {
5042                         break
5043                 }
5044                 v.reset(OpPPC64FlagLT)
5045                 return true
5046         }
5047         // match: (CMPWUconst (MOVDconst [x]) [y])
5048         // cond: uint32(x)>uint32(y)
5049         // result: (FlagGT)
5050         for {
5051                 y := v.AuxInt
5052                 v_0 := v.Args[0]
5053                 if v_0.Op != OpPPC64MOVDconst {
5054                         break
5055                 }
5056                 x := v_0.AuxInt
5057                 if !(uint32(x) > uint32(y)) {
5058                         break
5059                 }
5060                 v.reset(OpPPC64FlagGT)
5061                 return true
5062         }
5063         return false
5064 }
5065 func rewriteValuePPC64_OpPPC64CMPWconst(v *Value, config *Config) bool {
5066         b := v.Block
5067         _ = b
5068         // match: (CMPWconst (MOVDconst [x]) [y])
5069         // cond: int32(x)==int32(y)
5070         // result: (FlagEQ)
5071         for {
5072                 y := v.AuxInt
5073                 v_0 := v.Args[0]
5074                 if v_0.Op != OpPPC64MOVDconst {
5075                         break
5076                 }
5077                 x := v_0.AuxInt
5078                 if !(int32(x) == int32(y)) {
5079                         break
5080                 }
5081                 v.reset(OpPPC64FlagEQ)
5082                 return true
5083         }
5084         // match: (CMPWconst (MOVDconst [x]) [y])
5085         // cond: int32(x)<int32(y)
5086         // result: (FlagLT)
5087         for {
5088                 y := v.AuxInt
5089                 v_0 := v.Args[0]
5090                 if v_0.Op != OpPPC64MOVDconst {
5091                         break
5092                 }
5093                 x := v_0.AuxInt
5094                 if !(int32(x) < int32(y)) {
5095                         break
5096                 }
5097                 v.reset(OpPPC64FlagLT)
5098                 return true
5099         }
5100         // match: (CMPWconst (MOVDconst [x]) [y])
5101         // cond: int32(x)>int32(y)
5102         // result: (FlagGT)
5103         for {
5104                 y := v.AuxInt
5105                 v_0 := v.Args[0]
5106                 if v_0.Op != OpPPC64MOVDconst {
5107                         break
5108                 }
5109                 x := v_0.AuxInt
5110                 if !(int32(x) > int32(y)) {
5111                         break
5112                 }
5113                 v.reset(OpPPC64FlagGT)
5114                 return true
5115         }
5116         return false
5117 }
5118 func rewriteValuePPC64_OpPPC64CMPconst(v *Value, config *Config) bool {
5119         b := v.Block
5120         _ = b
5121         // match: (CMPconst (MOVDconst [x]) [y])
5122         // cond: int64(x)==int64(y)
5123         // result: (FlagEQ)
5124         for {
5125                 y := v.AuxInt
5126                 v_0 := v.Args[0]
5127                 if v_0.Op != OpPPC64MOVDconst {
5128                         break
5129                 }
5130                 x := v_0.AuxInt
5131                 if !(int64(x) == int64(y)) {
5132                         break
5133                 }
5134                 v.reset(OpPPC64FlagEQ)
5135                 return true
5136         }
5137         // match: (CMPconst (MOVDconst [x]) [y])
5138         // cond: int64(x)<int64(y)
5139         // result: (FlagLT)
5140         for {
5141                 y := v.AuxInt
5142                 v_0 := v.Args[0]
5143                 if v_0.Op != OpPPC64MOVDconst {
5144                         break
5145                 }
5146                 x := v_0.AuxInt
5147                 if !(int64(x) < int64(y)) {
5148                         break
5149                 }
5150                 v.reset(OpPPC64FlagLT)
5151                 return true
5152         }
5153         // match: (CMPconst (MOVDconst [x]) [y])
5154         // cond: int64(x)>int64(y)
5155         // result: (FlagGT)
5156         for {
5157                 y := v.AuxInt
5158                 v_0 := v.Args[0]
5159                 if v_0.Op != OpPPC64MOVDconst {
5160                         break
5161                 }
5162                 x := v_0.AuxInt
5163                 if !(int64(x) > int64(y)) {
5164                         break
5165                 }
5166                 v.reset(OpPPC64FlagGT)
5167                 return true
5168         }
5169         return false
5170 }
5171 func rewriteValuePPC64_OpPPC64Equal(v *Value, config *Config) bool {
5172         b := v.Block
5173         _ = b
5174         // match: (Equal (FlagEQ))
5175         // cond:
5176         // result: (MOVDconst [1])
5177         for {
5178                 v_0 := v.Args[0]
5179                 if v_0.Op != OpPPC64FlagEQ {
5180                         break
5181                 }
5182                 v.reset(OpPPC64MOVDconst)
5183                 v.AuxInt = 1
5184                 return true
5185         }
5186         // match: (Equal (FlagLT))
5187         // cond:
5188         // result: (MOVDconst [0])
5189         for {
5190                 v_0 := v.Args[0]
5191                 if v_0.Op != OpPPC64FlagLT {
5192                         break
5193                 }
5194                 v.reset(OpPPC64MOVDconst)
5195                 v.AuxInt = 0
5196                 return true
5197         }
5198         // match: (Equal (FlagGT))
5199         // cond:
5200         // result: (MOVDconst [0])
5201         for {
5202                 v_0 := v.Args[0]
5203                 if v_0.Op != OpPPC64FlagGT {
5204                         break
5205                 }
5206                 v.reset(OpPPC64MOVDconst)
5207                 v.AuxInt = 0
5208                 return true
5209         }
5210         // match: (Equal (InvertFlags x))
5211         // cond:
5212         // result: (Equal x)
5213         for {
5214                 v_0 := v.Args[0]
5215                 if v_0.Op != OpPPC64InvertFlags {
5216                         break
5217                 }
5218                 x := v_0.Args[0]
5219                 v.reset(OpPPC64Equal)
5220                 v.AddArg(x)
5221                 return true
5222         }
5223         return false
5224 }
5225 func rewriteValuePPC64_OpPPC64FMOVDload(v *Value, config *Config) bool {
5226         b := v.Block
5227         _ = b
5228         // match: (FMOVDload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
5229         // cond: canMergeSym(sym1,sym2)
5230         // result: (FMOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
5231         for {
5232                 off1 := v.AuxInt
5233                 sym1 := v.Aux
5234                 v_0 := v.Args[0]
5235                 if v_0.Op != OpPPC64MOVDaddr {
5236                         break
5237                 }
5238                 off2 := v_0.AuxInt
5239                 sym2 := v_0.Aux
5240                 ptr := v_0.Args[0]
5241                 mem := v.Args[1]
5242                 if !(canMergeSym(sym1, sym2)) {
5243                         break
5244                 }
5245                 v.reset(OpPPC64FMOVDload)
5246                 v.AuxInt = off1 + off2
5247                 v.Aux = mergeSym(sym1, sym2)
5248                 v.AddArg(ptr)
5249                 v.AddArg(mem)
5250                 return true
5251         }
5252         // match: (FMOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
5253         // cond: is16Bit(off1+off2)
5254         // result: (FMOVDload [off1+off2] {sym} ptr mem)
5255         for {
5256                 off1 := v.AuxInt
5257                 sym := v.Aux
5258                 v_0 := v.Args[0]
5259                 if v_0.Op != OpPPC64ADDconst {
5260                         break
5261                 }
5262                 off2 := v_0.AuxInt
5263                 ptr := v_0.Args[0]
5264                 mem := v.Args[1]
5265                 if !(is16Bit(off1 + off2)) {
5266                         break
5267                 }
5268                 v.reset(OpPPC64FMOVDload)
5269                 v.AuxInt = off1 + off2
5270                 v.Aux = sym
5271                 v.AddArg(ptr)
5272                 v.AddArg(mem)
5273                 return true
5274         }
5275         return false
5276 }
5277 func rewriteValuePPC64_OpPPC64FMOVDstore(v *Value, config *Config) bool {
5278         b := v.Block
5279         _ = b
5280         // match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
5281         // cond: is16Bit(off1+off2)
5282         // result: (FMOVDstore [off1+off2] {sym} ptr val mem)
5283         for {
5284                 off1 := v.AuxInt
5285                 sym := v.Aux
5286                 v_0 := v.Args[0]
5287                 if v_0.Op != OpPPC64ADDconst {
5288                         break
5289                 }
5290                 off2 := v_0.AuxInt
5291                 ptr := v_0.Args[0]
5292                 val := v.Args[1]
5293                 mem := v.Args[2]
5294                 if !(is16Bit(off1 + off2)) {
5295                         break
5296                 }
5297                 v.reset(OpPPC64FMOVDstore)
5298                 v.AuxInt = off1 + off2
5299                 v.Aux = sym
5300                 v.AddArg(ptr)
5301                 v.AddArg(val)
5302                 v.AddArg(mem)
5303                 return true
5304         }
5305         // match: (FMOVDstore [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) val mem)
5306         // cond: canMergeSym(sym1,sym2)
5307         // result: (FMOVDstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem)
5308         for {
5309                 off1 := v.AuxInt
5310                 sym1 := v.Aux
5311                 v_0 := v.Args[0]
5312                 if v_0.Op != OpPPC64MOVDaddr {
5313                         break
5314                 }
5315                 off2 := v_0.AuxInt
5316                 sym2 := v_0.Aux
5317                 ptr := v_0.Args[0]
5318                 val := v.Args[1]
5319                 mem := v.Args[2]
5320                 if !(canMergeSym(sym1, sym2)) {
5321                         break
5322                 }
5323                 v.reset(OpPPC64FMOVDstore)
5324                 v.AuxInt = off1 + off2
5325                 v.Aux = mergeSym(sym1, sym2)
5326                 v.AddArg(ptr)
5327                 v.AddArg(val)
5328                 v.AddArg(mem)
5329                 return true
5330         }
5331         return false
5332 }
5333 func rewriteValuePPC64_OpPPC64FMOVSload(v *Value, config *Config) bool {
5334         b := v.Block
5335         _ = b
5336         // match: (FMOVSload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
5337         // cond: canMergeSym(sym1,sym2)
5338         // result: (FMOVSload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
5339         for {
5340                 off1 := v.AuxInt
5341                 sym1 := v.Aux
5342                 v_0 := v.Args[0]
5343                 if v_0.Op != OpPPC64MOVDaddr {
5344                         break
5345                 }
5346                 off2 := v_0.AuxInt
5347                 sym2 := v_0.Aux
5348                 ptr := v_0.Args[0]
5349                 mem := v.Args[1]
5350                 if !(canMergeSym(sym1, sym2)) {
5351                         break
5352                 }
5353                 v.reset(OpPPC64FMOVSload)
5354                 v.AuxInt = off1 + off2
5355                 v.Aux = mergeSym(sym1, sym2)
5356                 v.AddArg(ptr)
5357                 v.AddArg(mem)
5358                 return true
5359         }
5360         // match: (FMOVSload [off1] {sym} (ADDconst [off2] ptr) mem)
5361         // cond: is16Bit(off1+off2)
5362         // result: (FMOVSload [off1+off2] {sym} ptr mem)
5363         for {
5364                 off1 := v.AuxInt
5365                 sym := v.Aux
5366                 v_0 := v.Args[0]
5367                 if v_0.Op != OpPPC64ADDconst {
5368                         break
5369                 }
5370                 off2 := v_0.AuxInt
5371                 ptr := v_0.Args[0]
5372                 mem := v.Args[1]
5373                 if !(is16Bit(off1 + off2)) {
5374                         break
5375                 }
5376                 v.reset(OpPPC64FMOVSload)
5377                 v.AuxInt = off1 + off2
5378                 v.Aux = sym
5379                 v.AddArg(ptr)
5380                 v.AddArg(mem)
5381                 return true
5382         }
5383         return false
5384 }
5385 func rewriteValuePPC64_OpPPC64FMOVSstore(v *Value, config *Config) bool {
5386         b := v.Block
5387         _ = b
5388         // match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem)
5389         // cond: is16Bit(off1+off2)
5390         // result: (FMOVSstore [off1+off2] {sym} ptr val mem)
5391         for {
5392                 off1 := v.AuxInt
5393                 sym := v.Aux
5394                 v_0 := v.Args[0]
5395                 if v_0.Op != OpPPC64ADDconst {
5396                         break
5397                 }
5398                 off2 := v_0.AuxInt
5399                 ptr := v_0.Args[0]
5400                 val := v.Args[1]
5401                 mem := v.Args[2]
5402                 if !(is16Bit(off1 + off2)) {
5403                         break
5404                 }
5405                 v.reset(OpPPC64FMOVSstore)
5406                 v.AuxInt = off1 + off2
5407                 v.Aux = sym
5408                 v.AddArg(ptr)
5409                 v.AddArg(val)
5410                 v.AddArg(mem)
5411                 return true
5412         }
5413         // match: (FMOVSstore [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) val mem)
5414         // cond: canMergeSym(sym1,sym2)
5415         // result: (FMOVSstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem)
5416         for {
5417                 off1 := v.AuxInt
5418                 sym1 := v.Aux
5419                 v_0 := v.Args[0]
5420                 if v_0.Op != OpPPC64MOVDaddr {
5421                         break
5422                 }
5423                 off2 := v_0.AuxInt
5424                 sym2 := v_0.Aux
5425                 ptr := v_0.Args[0]
5426                 val := v.Args[1]
5427                 mem := v.Args[2]
5428                 if !(canMergeSym(sym1, sym2)) {
5429                         break
5430                 }
5431                 v.reset(OpPPC64FMOVSstore)
5432                 v.AuxInt = off1 + off2
5433                 v.Aux = mergeSym(sym1, sym2)
5434                 v.AddArg(ptr)
5435                 v.AddArg(val)
5436                 v.AddArg(mem)
5437                 return true
5438         }
5439         return false
5440 }
5441 func rewriteValuePPC64_OpPPC64GreaterEqual(v *Value, config *Config) bool {
5442         b := v.Block
5443         _ = b
5444         // match: (GreaterEqual (FlagEQ))
5445         // cond:
5446         // result: (MOVDconst [1])
5447         for {
5448                 v_0 := v.Args[0]
5449                 if v_0.Op != OpPPC64FlagEQ {
5450                         break
5451                 }
5452                 v.reset(OpPPC64MOVDconst)
5453                 v.AuxInt = 1
5454                 return true
5455         }
5456         // match: (GreaterEqual (FlagLT))
5457         // cond:
5458         // result: (MOVDconst [0])
5459         for {
5460                 v_0 := v.Args[0]
5461                 if v_0.Op != OpPPC64FlagLT {
5462                         break
5463                 }
5464                 v.reset(OpPPC64MOVDconst)
5465                 v.AuxInt = 0
5466                 return true
5467         }
5468         // match: (GreaterEqual (FlagGT))
5469         // cond:
5470         // result: (MOVDconst [1])
5471         for {
5472                 v_0 := v.Args[0]
5473                 if v_0.Op != OpPPC64FlagGT {
5474                         break
5475                 }
5476                 v.reset(OpPPC64MOVDconst)
5477                 v.AuxInt = 1
5478                 return true
5479         }
5480         // match: (GreaterEqual (InvertFlags x))
5481         // cond:
5482         // result: (LessEqual x)
5483         for {
5484                 v_0 := v.Args[0]
5485                 if v_0.Op != OpPPC64InvertFlags {
5486                         break
5487                 }
5488                 x := v_0.Args[0]
5489                 v.reset(OpPPC64LessEqual)
5490                 v.AddArg(x)
5491                 return true
5492         }
5493         return false
5494 }
5495 func rewriteValuePPC64_OpPPC64GreaterThan(v *Value, config *Config) bool {
5496         b := v.Block
5497         _ = b
5498         // match: (GreaterThan (FlagEQ))
5499         // cond:
5500         // result: (MOVDconst [0])
5501         for {
5502                 v_0 := v.Args[0]
5503                 if v_0.Op != OpPPC64FlagEQ {
5504                         break
5505                 }
5506                 v.reset(OpPPC64MOVDconst)
5507                 v.AuxInt = 0
5508                 return true
5509         }
5510         // match: (GreaterThan (FlagLT))
5511         // cond:
5512         // result: (MOVDconst [0])
5513         for {
5514                 v_0 := v.Args[0]
5515                 if v_0.Op != OpPPC64FlagLT {
5516                         break
5517                 }
5518                 v.reset(OpPPC64MOVDconst)
5519                 v.AuxInt = 0
5520                 return true
5521         }
5522         // match: (GreaterThan (FlagGT))
5523         // cond:
5524         // result: (MOVDconst [1])
5525         for {
5526                 v_0 := v.Args[0]
5527                 if v_0.Op != OpPPC64FlagGT {
5528                         break
5529                 }
5530                 v.reset(OpPPC64MOVDconst)
5531                 v.AuxInt = 1
5532                 return true
5533         }
5534         // match: (GreaterThan (InvertFlags x))
5535         // cond:
5536         // result: (LessThan x)
5537         for {
5538                 v_0 := v.Args[0]
5539                 if v_0.Op != OpPPC64InvertFlags {
5540                         break
5541                 }
5542                 x := v_0.Args[0]
5543                 v.reset(OpPPC64LessThan)
5544                 v.AddArg(x)
5545                 return true
5546         }
5547         return false
5548 }
5549 func rewriteValuePPC64_OpPPC64LessEqual(v *Value, config *Config) bool {
5550         b := v.Block
5551         _ = b
5552         // match: (LessEqual (FlagEQ))
5553         // cond:
5554         // result: (MOVDconst [1])
5555         for {
5556                 v_0 := v.Args[0]
5557                 if v_0.Op != OpPPC64FlagEQ {
5558                         break
5559                 }
5560                 v.reset(OpPPC64MOVDconst)
5561                 v.AuxInt = 1
5562                 return true
5563         }
5564         // match: (LessEqual (FlagLT))
5565         // cond:
5566         // result: (MOVDconst [1])
5567         for {
5568                 v_0 := v.Args[0]
5569                 if v_0.Op != OpPPC64FlagLT {
5570                         break
5571                 }
5572                 v.reset(OpPPC64MOVDconst)
5573                 v.AuxInt = 1
5574                 return true
5575         }
5576         // match: (LessEqual (FlagGT))
5577         // cond:
5578         // result: (MOVDconst [0])
5579         for {
5580                 v_0 := v.Args[0]
5581                 if v_0.Op != OpPPC64FlagGT {
5582                         break
5583                 }
5584                 v.reset(OpPPC64MOVDconst)
5585                 v.AuxInt = 0
5586                 return true
5587         }
5588         // match: (LessEqual (InvertFlags x))
5589         // cond:
5590         // result: (GreaterEqual x)
5591         for {
5592                 v_0 := v.Args[0]
5593                 if v_0.Op != OpPPC64InvertFlags {
5594                         break
5595                 }
5596                 x := v_0.Args[0]
5597                 v.reset(OpPPC64GreaterEqual)
5598                 v.AddArg(x)
5599                 return true
5600         }
5601         return false
5602 }
5603 func rewriteValuePPC64_OpPPC64LessThan(v *Value, config *Config) bool {
5604         b := v.Block
5605         _ = b
5606         // match: (LessThan (FlagEQ))
5607         // cond:
5608         // result: (MOVDconst [0])
5609         for {
5610                 v_0 := v.Args[0]
5611                 if v_0.Op != OpPPC64FlagEQ {
5612                         break
5613                 }
5614                 v.reset(OpPPC64MOVDconst)
5615                 v.AuxInt = 0
5616                 return true
5617         }
5618         // match: (LessThan (FlagLT))
5619         // cond:
5620         // result: (MOVDconst [1])
5621         for {
5622                 v_0 := v.Args[0]
5623                 if v_0.Op != OpPPC64FlagLT {
5624                         break
5625                 }
5626                 v.reset(OpPPC64MOVDconst)
5627                 v.AuxInt = 1
5628                 return true
5629         }
5630         // match: (LessThan (FlagGT))
5631         // cond:
5632         // result: (MOVDconst [0])
5633         for {
5634                 v_0 := v.Args[0]
5635                 if v_0.Op != OpPPC64FlagGT {
5636                         break
5637                 }
5638                 v.reset(OpPPC64MOVDconst)
5639                 v.AuxInt = 0
5640                 return true
5641         }
5642         // match: (LessThan (InvertFlags x))
5643         // cond:
5644         // result: (GreaterThan x)
5645         for {
5646                 v_0 := v.Args[0]
5647                 if v_0.Op != OpPPC64InvertFlags {
5648                         break
5649                 }
5650                 x := v_0.Args[0]
5651                 v.reset(OpPPC64GreaterThan)
5652                 v.AddArg(x)
5653                 return true
5654         }
5655         return false
5656 }
5657 func rewriteValuePPC64_OpPPC64MOVBZload(v *Value, config *Config) bool {
5658         b := v.Block
5659         _ = b
5660         // match: (MOVBZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
5661         // cond: canMergeSym(sym1,sym2)
5662         // result: (MOVBZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
5663         for {
5664                 off1 := v.AuxInt
5665                 sym1 := v.Aux
5666                 v_0 := v.Args[0]
5667                 if v_0.Op != OpPPC64MOVDaddr {
5668                         break
5669                 }
5670                 off2 := v_0.AuxInt
5671                 sym2 := v_0.Aux
5672                 ptr := v_0.Args[0]
5673                 mem := v.Args[1]
5674                 if !(canMergeSym(sym1, sym2)) {
5675                         break
5676                 }
5677                 v.reset(OpPPC64MOVBZload)
5678                 v.AuxInt = off1 + off2
5679                 v.Aux = mergeSym(sym1, sym2)
5680                 v.AddArg(ptr)
5681                 v.AddArg(mem)
5682                 return true
5683         }
5684         // match: (MOVBZload [off1] {sym} (ADDconst [off2] x) mem)
5685         // cond: is16Bit(off1+off2)
5686         // result: (MOVBZload [off1+off2] {sym} x mem)
5687         for {
5688                 off1 := v.AuxInt
5689                 sym := v.Aux
5690                 v_0 := v.Args[0]
5691                 if v_0.Op != OpPPC64ADDconst {
5692                         break
5693                 }
5694                 off2 := v_0.AuxInt
5695                 x := v_0.Args[0]
5696                 mem := v.Args[1]
5697                 if !(is16Bit(off1 + off2)) {
5698                         break
5699                 }
5700                 v.reset(OpPPC64MOVBZload)
5701                 v.AuxInt = off1 + off2
5702                 v.Aux = sym
5703                 v.AddArg(x)
5704                 v.AddArg(mem)
5705                 return true
5706         }
5707         return false
5708 }
5709 func rewriteValuePPC64_OpPPC64MOVBZreg(v *Value, config *Config) bool {
5710         b := v.Block
5711         _ = b
5712         // match: (MOVBZreg y:(ANDconst [c] _))
5713         // cond: uint64(c) <= 0xFF
5714         // result: y
5715         for {
5716                 y := v.Args[0]
5717                 if y.Op != OpPPC64ANDconst {
5718                         break
5719                 }
5720                 c := y.AuxInt
5721                 if !(uint64(c) <= 0xFF) {
5722                         break
5723                 }
5724                 v.reset(OpCopy)
5725                 v.Type = y.Type
5726                 v.AddArg(y)
5727                 return true
5728         }
5729         // match: (MOVBZreg y:(MOVBZreg _))
5730         // cond:
5731         // result: y
5732         for {
5733                 y := v.Args[0]
5734                 if y.Op != OpPPC64MOVBZreg {
5735                         break
5736                 }
5737                 v.reset(OpCopy)
5738                 v.Type = y.Type
5739                 v.AddArg(y)
5740                 return true
5741         }
5742         // match: (MOVBZreg (MOVBreg x))
5743         // cond:
5744         // result: (MOVBZreg x)
5745         for {
5746                 v_0 := v.Args[0]
5747                 if v_0.Op != OpPPC64MOVBreg {
5748                         break
5749                 }
5750                 x := v_0.Args[0]
5751                 v.reset(OpPPC64MOVBZreg)
5752                 v.AddArg(x)
5753                 return true
5754         }
5755         // match: (MOVBZreg x:(MOVBZload _ _))
5756         // cond:
5757         // result: x
5758         for {
5759                 x := v.Args[0]
5760                 if x.Op != OpPPC64MOVBZload {
5761                         break
5762                 }
5763                 v.reset(OpCopy)
5764                 v.Type = x.Type
5765                 v.AddArg(x)
5766                 return true
5767         }
5768         // match: (MOVBZreg (MOVDconst [c]))
5769         // cond:
5770         // result: (MOVDconst [int64(uint8(c))])
5771         for {
5772                 v_0 := v.Args[0]
5773                 if v_0.Op != OpPPC64MOVDconst {
5774                         break
5775                 }
5776                 c := v_0.AuxInt
5777                 v.reset(OpPPC64MOVDconst)
5778                 v.AuxInt = int64(uint8(c))
5779                 return true
5780         }
5781         return false
5782 }
5783 func rewriteValuePPC64_OpPPC64MOVBreg(v *Value, config *Config) bool {
5784         b := v.Block
5785         _ = b
5786         // match: (MOVBreg y:(ANDconst [c] _))
5787         // cond: uint64(c) <= 0x7F
5788         // result: y
5789         for {
5790                 y := v.Args[0]
5791                 if y.Op != OpPPC64ANDconst {
5792                         break
5793                 }
5794                 c := y.AuxInt
5795                 if !(uint64(c) <= 0x7F) {
5796                         break
5797                 }
5798                 v.reset(OpCopy)
5799                 v.Type = y.Type
5800                 v.AddArg(y)
5801                 return true
5802         }
5803         // match: (MOVBreg y:(MOVBreg _))
5804         // cond:
5805         // result: y
5806         for {
5807                 y := v.Args[0]
5808                 if y.Op != OpPPC64MOVBreg {
5809                         break
5810                 }
5811                 v.reset(OpCopy)
5812                 v.Type = y.Type
5813                 v.AddArg(y)
5814                 return true
5815         }
5816         // match: (MOVBreg (MOVBZreg x))
5817         // cond:
5818         // result: (MOVBreg x)
5819         for {
5820                 v_0 := v.Args[0]
5821                 if v_0.Op != OpPPC64MOVBZreg {
5822                         break
5823                 }
5824                 x := v_0.Args[0]
5825                 v.reset(OpPPC64MOVBreg)
5826                 v.AddArg(x)
5827                 return true
5828         }
5829         // match: (MOVBreg (MOVDconst [c]))
5830         // cond:
5831         // result: (MOVDconst [int64(int8(c))])
5832         for {
5833                 v_0 := v.Args[0]
5834                 if v_0.Op != OpPPC64MOVDconst {
5835                         break
5836                 }
5837                 c := v_0.AuxInt
5838                 v.reset(OpPPC64MOVDconst)
5839                 v.AuxInt = int64(int8(c))
5840                 return true
5841         }
5842         return false
5843 }
5844 func rewriteValuePPC64_OpPPC64MOVBstore(v *Value, config *Config) bool {
5845         b := v.Block
5846         _ = b
5847         // match: (MOVBstore [off1] {sym} (ADDconst [off2] x) val mem)
5848         // cond: is16Bit(off1+off2)
5849         // result: (MOVBstore [off1+off2] {sym} x val mem)
5850         for {
5851                 off1 := v.AuxInt
5852                 sym := v.Aux
5853                 v_0 := v.Args[0]
5854                 if v_0.Op != OpPPC64ADDconst {
5855                         break
5856                 }
5857                 off2 := v_0.AuxInt
5858                 x := v_0.Args[0]
5859                 val := v.Args[1]
5860                 mem := v.Args[2]
5861                 if !(is16Bit(off1 + off2)) {
5862                         break
5863                 }
5864                 v.reset(OpPPC64MOVBstore)
5865                 v.AuxInt = off1 + off2
5866                 v.Aux = sym
5867                 v.AddArg(x)
5868                 v.AddArg(val)
5869                 v.AddArg(mem)
5870                 return true
5871         }
5872         // match: (MOVBstore [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) val mem)
5873         // cond: canMergeSym(sym1,sym2)
5874         // result: (MOVBstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem)
5875         for {
5876                 off1 := v.AuxInt
5877                 sym1 := v.Aux
5878                 v_0 := v.Args[0]
5879                 if v_0.Op != OpPPC64MOVDaddr {
5880                         break
5881                 }
5882                 off2 := v_0.AuxInt
5883                 sym2 := v_0.Aux
5884                 ptr := v_0.Args[0]
5885                 val := v.Args[1]
5886                 mem := v.Args[2]
5887                 if !(canMergeSym(sym1, sym2)) {
5888                         break
5889                 }
5890                 v.reset(OpPPC64MOVBstore)
5891                 v.AuxInt = off1 + off2
5892                 v.Aux = mergeSym(sym1, sym2)
5893                 v.AddArg(ptr)
5894                 v.AddArg(val)
5895                 v.AddArg(mem)
5896                 return true
5897         }
5898         // match: (MOVBstore [off] {sym} ptr (MOVDconst [c]) mem)
5899         // cond: c == 0
5900         // result: (MOVBstorezero [off] {sym} ptr mem)
5901         for {
5902                 off := v.AuxInt
5903                 sym := v.Aux
5904                 ptr := v.Args[0]
5905                 v_1 := v.Args[1]
5906                 if v_1.Op != OpPPC64MOVDconst {
5907                         break
5908                 }
5909                 c := v_1.AuxInt
5910                 mem := v.Args[2]
5911                 if !(c == 0) {
5912                         break
5913                 }
5914                 v.reset(OpPPC64MOVBstorezero)
5915                 v.AuxInt = off
5916                 v.Aux = sym
5917                 v.AddArg(ptr)
5918                 v.AddArg(mem)
5919                 return true
5920         }
5921         // match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem)
5922         // cond:
5923         // result: (MOVBstore [off] {sym} ptr x mem)
5924         for {
5925                 off := v.AuxInt
5926                 sym := v.Aux
5927                 ptr := v.Args[0]
5928                 v_1 := v.Args[1]
5929                 if v_1.Op != OpPPC64MOVBreg {
5930                         break
5931                 }
5932                 x := v_1.Args[0]
5933                 mem := v.Args[2]
5934                 v.reset(OpPPC64MOVBstore)
5935                 v.AuxInt = off
5936                 v.Aux = sym
5937                 v.AddArg(ptr)
5938                 v.AddArg(x)
5939                 v.AddArg(mem)
5940                 return true
5941         }
5942         // match: (MOVBstore [off] {sym} ptr (MOVBZreg x) mem)
5943         // cond:
5944         // result: (MOVBstore [off] {sym} ptr x mem)
5945         for {
5946                 off := v.AuxInt
5947                 sym := v.Aux
5948                 ptr := v.Args[0]
5949                 v_1 := v.Args[1]
5950                 if v_1.Op != OpPPC64MOVBZreg {
5951                         break
5952                 }
5953                 x := v_1.Args[0]
5954                 mem := v.Args[2]
5955                 v.reset(OpPPC64MOVBstore)
5956                 v.AuxInt = off
5957                 v.Aux = sym
5958                 v.AddArg(ptr)
5959                 v.AddArg(x)
5960                 v.AddArg(mem)
5961                 return true
5962         }
5963         return false
5964 }
5965 func rewriteValuePPC64_OpPPC64MOVBstorezero(v *Value, config *Config) bool {
5966         b := v.Block
5967         _ = b
5968         // match: (MOVBstorezero [off1] {sym} (ADDconst [off2] x) mem)
5969         // cond: is16Bit(off1+off2)
5970         // result: (MOVBstorezero [off1+off2] {sym} x mem)
5971         for {
5972                 off1 := v.AuxInt
5973                 sym := v.Aux
5974                 v_0 := v.Args[0]
5975                 if v_0.Op != OpPPC64ADDconst {
5976                         break
5977                 }
5978                 off2 := v_0.AuxInt
5979                 x := v_0.Args[0]
5980                 mem := v.Args[1]
5981                 if !(is16Bit(off1 + off2)) {
5982                         break
5983                 }
5984                 v.reset(OpPPC64MOVBstorezero)
5985                 v.AuxInt = off1 + off2
5986                 v.Aux = sym
5987                 v.AddArg(x)
5988                 v.AddArg(mem)
5989                 return true
5990         }
5991         // match: (MOVBstorezero [off1] {sym1} (MOVDaddr [off2] {sym2} x) mem)
5992         // cond: canMergeSym(sym1,sym2)
5993         // result: (MOVBstorezero [off1+off2] {mergeSym(sym1,sym2)} x mem)
5994         for {
5995                 off1 := v.AuxInt
5996                 sym1 := v.Aux
5997                 v_0 := v.Args[0]
5998                 if v_0.Op != OpPPC64MOVDaddr {
5999                         break
6000                 }
6001                 off2 := v_0.AuxInt
6002                 sym2 := v_0.Aux
6003                 x := v_0.Args[0]
6004                 mem := v.Args[1]
6005                 if !(canMergeSym(sym1, sym2)) {
6006                         break
6007                 }
6008                 v.reset(OpPPC64MOVBstorezero)
6009                 v.AuxInt = off1 + off2
6010                 v.Aux = mergeSym(sym1, sym2)
6011                 v.AddArg(x)
6012                 v.AddArg(mem)
6013                 return true
6014         }
6015         return false
6016 }
6017 func rewriteValuePPC64_OpPPC64MOVDload(v *Value, config *Config) bool {
6018         b := v.Block
6019         _ = b
6020         // match: (MOVDload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
6021         // cond: canMergeSym(sym1,sym2)
6022         // result: (MOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
6023         for {
6024                 off1 := v.AuxInt
6025                 sym1 := v.Aux
6026                 v_0 := v.Args[0]
6027                 if v_0.Op != OpPPC64MOVDaddr {
6028                         break
6029                 }
6030                 off2 := v_0.AuxInt
6031                 sym2 := v_0.Aux
6032                 ptr := v_0.Args[0]
6033                 mem := v.Args[1]
6034                 if !(canMergeSym(sym1, sym2)) {
6035                         break
6036                 }
6037                 v.reset(OpPPC64MOVDload)
6038                 v.AuxInt = off1 + off2
6039                 v.Aux = mergeSym(sym1, sym2)
6040                 v.AddArg(ptr)
6041                 v.AddArg(mem)
6042                 return true
6043         }
6044         // match: (MOVDload [off1] {sym} (ADDconst [off2] x) mem)
6045         // cond: is16Bit(off1+off2)
6046         // result: (MOVDload [off1+off2] {sym} x mem)
6047         for {
6048                 off1 := v.AuxInt
6049                 sym := v.Aux
6050                 v_0 := v.Args[0]
6051                 if v_0.Op != OpPPC64ADDconst {
6052                         break
6053                 }
6054                 off2 := v_0.AuxInt
6055                 x := v_0.Args[0]
6056                 mem := v.Args[1]
6057                 if !(is16Bit(off1 + off2)) {
6058                         break
6059                 }
6060                 v.reset(OpPPC64MOVDload)
6061                 v.AuxInt = off1 + off2
6062                 v.Aux = sym
6063                 v.AddArg(x)
6064                 v.AddArg(mem)
6065                 return true
6066         }
6067         return false
6068 }
6069 func rewriteValuePPC64_OpPPC64MOVDstore(v *Value, config *Config) bool {
6070         b := v.Block
6071         _ = b
6072         // match: (MOVDstore [off1] {sym} (ADDconst [off2] x) val mem)
6073         // cond: is16Bit(off1+off2)
6074         // result: (MOVDstore [off1+off2] {sym} x val mem)
6075         for {
6076                 off1 := v.AuxInt
6077                 sym := v.Aux
6078                 v_0 := v.Args[0]
6079                 if v_0.Op != OpPPC64ADDconst {
6080                         break
6081                 }
6082                 off2 := v_0.AuxInt
6083                 x := v_0.Args[0]
6084                 val := v.Args[1]
6085                 mem := v.Args[2]
6086                 if !(is16Bit(off1 + off2)) {
6087                         break
6088                 }
6089                 v.reset(OpPPC64MOVDstore)
6090                 v.AuxInt = off1 + off2
6091                 v.Aux = sym
6092                 v.AddArg(x)
6093                 v.AddArg(val)
6094                 v.AddArg(mem)
6095                 return true
6096         }
6097         // match: (MOVDstore [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) val mem)
6098         // cond: canMergeSym(sym1,sym2)
6099         // result: (MOVDstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem)
6100         for {
6101                 off1 := v.AuxInt
6102                 sym1 := v.Aux
6103                 v_0 := v.Args[0]
6104                 if v_0.Op != OpPPC64MOVDaddr {
6105                         break
6106                 }
6107                 off2 := v_0.AuxInt
6108                 sym2 := v_0.Aux
6109                 ptr := v_0.Args[0]
6110                 val := v.Args[1]
6111                 mem := v.Args[2]
6112                 if !(canMergeSym(sym1, sym2)) {
6113                         break
6114                 }
6115                 v.reset(OpPPC64MOVDstore)
6116                 v.AuxInt = off1 + off2
6117                 v.Aux = mergeSym(sym1, sym2)
6118                 v.AddArg(ptr)
6119                 v.AddArg(val)
6120                 v.AddArg(mem)
6121                 return true
6122         }
6123         // match: (MOVDstore [off] {sym} ptr (MOVDconst [c]) mem)
6124         // cond: c == 0
6125         // result: (MOVDstorezero [off] {sym} ptr mem)
6126         for {
6127                 off := v.AuxInt
6128                 sym := v.Aux
6129                 ptr := v.Args[0]
6130                 v_1 := v.Args[1]
6131                 if v_1.Op != OpPPC64MOVDconst {
6132                         break
6133                 }
6134                 c := v_1.AuxInt
6135                 mem := v.Args[2]
6136                 if !(c == 0) {
6137                         break
6138                 }
6139                 v.reset(OpPPC64MOVDstorezero)
6140                 v.AuxInt = off
6141                 v.Aux = sym
6142                 v.AddArg(ptr)
6143                 v.AddArg(mem)
6144                 return true
6145         }
6146         return false
6147 }
6148 func rewriteValuePPC64_OpPPC64MOVDstorezero(v *Value, config *Config) bool {
6149         b := v.Block
6150         _ = b
6151         // match: (MOVDstorezero [off1] {sym} (ADDconst [off2] x) mem)
6152         // cond: is16Bit(off1+off2)
6153         // result: (MOVDstorezero [off1+off2] {sym} x mem)
6154         for {
6155                 off1 := v.AuxInt
6156                 sym := v.Aux
6157                 v_0 := v.Args[0]
6158                 if v_0.Op != OpPPC64ADDconst {
6159                         break
6160                 }
6161                 off2 := v_0.AuxInt
6162                 x := v_0.Args[0]
6163                 mem := v.Args[1]
6164                 if !(is16Bit(off1 + off2)) {
6165                         break
6166                 }
6167                 v.reset(OpPPC64MOVDstorezero)
6168                 v.AuxInt = off1 + off2
6169                 v.Aux = sym
6170                 v.AddArg(x)
6171                 v.AddArg(mem)
6172                 return true
6173         }
6174         // match: (MOVDstorezero [off1] {sym1} (MOVDaddr [off2] {sym2} x) mem)
6175         // cond: canMergeSym(sym1,sym2)
6176         // result: (MOVDstorezero [off1+off2] {mergeSym(sym1,sym2)} x mem)
6177         for {
6178                 off1 := v.AuxInt
6179                 sym1 := v.Aux
6180                 v_0 := v.Args[0]
6181                 if v_0.Op != OpPPC64MOVDaddr {
6182                         break
6183                 }
6184                 off2 := v_0.AuxInt
6185                 sym2 := v_0.Aux
6186                 x := v_0.Args[0]
6187                 mem := v.Args[1]
6188                 if !(canMergeSym(sym1, sym2)) {
6189                         break
6190                 }
6191                 v.reset(OpPPC64MOVDstorezero)
6192                 v.AuxInt = off1 + off2
6193                 v.Aux = mergeSym(sym1, sym2)
6194                 v.AddArg(x)
6195                 v.AddArg(mem)
6196                 return true
6197         }
6198         return false
6199 }
6200 func rewriteValuePPC64_OpPPC64MOVHZload(v *Value, config *Config) bool {
6201         b := v.Block
6202         _ = b
6203         // match: (MOVHZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
6204         // cond: canMergeSym(sym1,sym2)
6205         // result: (MOVHZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
6206         for {
6207                 off1 := v.AuxInt
6208                 sym1 := v.Aux
6209                 v_0 := v.Args[0]
6210                 if v_0.Op != OpPPC64MOVDaddr {
6211                         break
6212                 }
6213                 off2 := v_0.AuxInt
6214                 sym2 := v_0.Aux
6215                 ptr := v_0.Args[0]
6216                 mem := v.Args[1]
6217                 if !(canMergeSym(sym1, sym2)) {
6218                         break
6219                 }
6220                 v.reset(OpPPC64MOVHZload)
6221                 v.AuxInt = off1 + off2
6222                 v.Aux = mergeSym(sym1, sym2)
6223                 v.AddArg(ptr)
6224                 v.AddArg(mem)
6225                 return true
6226         }
6227         // match: (MOVHZload [off1] {sym} (ADDconst [off2] x) mem)
6228         // cond: is16Bit(off1+off2)
6229         // result: (MOVHZload [off1+off2] {sym} x mem)
6230         for {
6231                 off1 := v.AuxInt
6232                 sym := v.Aux
6233                 v_0 := v.Args[0]
6234                 if v_0.Op != OpPPC64ADDconst {
6235                         break
6236                 }
6237                 off2 := v_0.AuxInt
6238                 x := v_0.Args[0]
6239                 mem := v.Args[1]
6240                 if !(is16Bit(off1 + off2)) {
6241                         break
6242                 }
6243                 v.reset(OpPPC64MOVHZload)
6244                 v.AuxInt = off1 + off2
6245                 v.Aux = sym
6246                 v.AddArg(x)
6247                 v.AddArg(mem)
6248                 return true
6249         }
6250         return false
6251 }
6252 func rewriteValuePPC64_OpPPC64MOVHZreg(v *Value, config *Config) bool {
6253         b := v.Block
6254         _ = b
6255         // match: (MOVHZreg y:(ANDconst [c] _))
6256         // cond: uint64(c) <= 0xFFFF
6257         // result: y
6258         for {
6259                 y := v.Args[0]
6260                 if y.Op != OpPPC64ANDconst {
6261                         break
6262                 }
6263                 c := y.AuxInt
6264                 if !(uint64(c) <= 0xFFFF) {
6265                         break
6266                 }
6267                 v.reset(OpCopy)
6268                 v.Type = y.Type
6269                 v.AddArg(y)
6270                 return true
6271         }
6272         // match: (MOVHZreg y:(MOVHZreg _))
6273         // cond:
6274         // result: y
6275         for {
6276                 y := v.Args[0]
6277                 if y.Op != OpPPC64MOVHZreg {
6278                         break
6279                 }
6280                 v.reset(OpCopy)
6281                 v.Type = y.Type
6282                 v.AddArg(y)
6283                 return true
6284         }
6285         // match: (MOVHZreg y:(MOVBZreg _))
6286         // cond:
6287         // result: y
6288         for {
6289                 y := v.Args[0]
6290                 if y.Op != OpPPC64MOVBZreg {
6291                         break
6292                 }
6293                 v.reset(OpCopy)
6294                 v.Type = y.Type
6295                 v.AddArg(y)
6296                 return true
6297         }
6298         // match: (MOVHZreg y:(MOVHreg x))
6299         // cond:
6300         // result: (MOVHZreg x)
6301         for {
6302                 y := v.Args[0]
6303                 if y.Op != OpPPC64MOVHreg {
6304                         break
6305                 }
6306                 x := y.Args[0]
6307                 v.reset(OpPPC64MOVHZreg)
6308                 v.AddArg(x)
6309                 return true
6310         }
6311         // match: (MOVHZreg x:(MOVHZload _ _))
6312         // cond:
6313         // result: x
6314         for {
6315                 x := v.Args[0]
6316                 if x.Op != OpPPC64MOVHZload {
6317                         break
6318                 }
6319                 v.reset(OpCopy)
6320                 v.Type = x.Type
6321                 v.AddArg(x)
6322                 return true
6323         }
6324         // match: (MOVHZreg (MOVDconst [c]))
6325         // cond:
6326         // result: (MOVDconst [int64(uint16(c))])
6327         for {
6328                 v_0 := v.Args[0]
6329                 if v_0.Op != OpPPC64MOVDconst {
6330                         break
6331                 }
6332                 c := v_0.AuxInt
6333                 v.reset(OpPPC64MOVDconst)
6334                 v.AuxInt = int64(uint16(c))
6335                 return true
6336         }
6337         return false
6338 }
6339 func rewriteValuePPC64_OpPPC64MOVHload(v *Value, config *Config) bool {
6340         b := v.Block
6341         _ = b
6342         // match: (MOVHload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
6343         // cond: canMergeSym(sym1,sym2)
6344         // result: (MOVHload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
6345         for {
6346                 off1 := v.AuxInt
6347                 sym1 := v.Aux
6348                 v_0 := v.Args[0]
6349                 if v_0.Op != OpPPC64MOVDaddr {
6350                         break
6351                 }
6352                 off2 := v_0.AuxInt
6353                 sym2 := v_0.Aux
6354                 ptr := v_0.Args[0]
6355                 mem := v.Args[1]
6356                 if !(canMergeSym(sym1, sym2)) {
6357                         break
6358                 }
6359                 v.reset(OpPPC64MOVHload)
6360                 v.AuxInt = off1 + off2
6361                 v.Aux = mergeSym(sym1, sym2)
6362                 v.AddArg(ptr)
6363                 v.AddArg(mem)
6364                 return true
6365         }
6366         // match: (MOVHload [off1] {sym} (ADDconst [off2] x) mem)
6367         // cond: is16Bit(off1+off2)
6368         // result: (MOVHload [off1+off2] {sym} x mem)
6369         for {
6370                 off1 := v.AuxInt
6371                 sym := v.Aux
6372                 v_0 := v.Args[0]
6373                 if v_0.Op != OpPPC64ADDconst {
6374                         break
6375                 }
6376                 off2 := v_0.AuxInt
6377                 x := v_0.Args[0]
6378                 mem := v.Args[1]
6379                 if !(is16Bit(off1 + off2)) {
6380                         break
6381                 }
6382                 v.reset(OpPPC64MOVHload)
6383                 v.AuxInt = off1 + off2
6384                 v.Aux = sym
6385                 v.AddArg(x)
6386                 v.AddArg(mem)
6387                 return true
6388         }
6389         return false
6390 }
6391 func rewriteValuePPC64_OpPPC64MOVHreg(v *Value, config *Config) bool {
6392         b := v.Block
6393         _ = b
6394         // match: (MOVHreg y:(ANDconst [c] _))
6395         // cond: uint64(c) <= 0x7FFF
6396         // result: y
6397         for {
6398                 y := v.Args[0]
6399                 if y.Op != OpPPC64ANDconst {
6400                         break
6401                 }
6402                 c := y.AuxInt
6403                 if !(uint64(c) <= 0x7FFF) {
6404                         break
6405                 }
6406                 v.reset(OpCopy)
6407                 v.Type = y.Type
6408                 v.AddArg(y)
6409                 return true
6410         }
6411         // match: (MOVHreg y:(MOVHreg _))
6412         // cond:
6413         // result: y
6414         for {
6415                 y := v.Args[0]
6416                 if y.Op != OpPPC64MOVHreg {
6417                         break
6418                 }
6419                 v.reset(OpCopy)
6420                 v.Type = y.Type
6421                 v.AddArg(y)
6422                 return true
6423         }
6424         // match: (MOVHreg y:(MOVBreg _))
6425         // cond:
6426         // result: y
6427         for {
6428                 y := v.Args[0]
6429                 if y.Op != OpPPC64MOVBreg {
6430                         break
6431                 }
6432                 v.reset(OpCopy)
6433                 v.Type = y.Type
6434                 v.AddArg(y)
6435                 return true
6436         }
6437         // match: (MOVHreg y:(MOVHZreg x))
6438         // cond:
6439         // result: (MOVHreg x)
6440         for {
6441                 y := v.Args[0]
6442                 if y.Op != OpPPC64MOVHZreg {
6443                         break
6444                 }
6445                 x := y.Args[0]
6446                 v.reset(OpPPC64MOVHreg)
6447                 v.AddArg(x)
6448                 return true
6449         }
6450         // match: (MOVHreg x:(MOVHload _ _))
6451         // cond:
6452         // result: x
6453         for {
6454                 x := v.Args[0]
6455                 if x.Op != OpPPC64MOVHload {
6456                         break
6457                 }
6458                 v.reset(OpCopy)
6459                 v.Type = x.Type
6460                 v.AddArg(x)
6461                 return true
6462         }
6463         // match: (MOVHreg (MOVDconst [c]))
6464         // cond:
6465         // result: (MOVDconst [int64(int16(c))])
6466         for {
6467                 v_0 := v.Args[0]
6468                 if v_0.Op != OpPPC64MOVDconst {
6469                         break
6470                 }
6471                 c := v_0.AuxInt
6472                 v.reset(OpPPC64MOVDconst)
6473                 v.AuxInt = int64(int16(c))
6474                 return true
6475         }
6476         return false
6477 }
6478 func rewriteValuePPC64_OpPPC64MOVHstore(v *Value, config *Config) bool {
6479         b := v.Block
6480         _ = b
6481         // match: (MOVHstore [off1] {sym} (ADDconst [off2] x) val mem)
6482         // cond: is16Bit(off1+off2)
6483         // result: (MOVHstore [off1+off2] {sym} x val mem)
6484         for {
6485                 off1 := v.AuxInt
6486                 sym := v.Aux
6487                 v_0 := v.Args[0]
6488                 if v_0.Op != OpPPC64ADDconst {
6489                         break
6490                 }
6491                 off2 := v_0.AuxInt
6492                 x := v_0.Args[0]
6493                 val := v.Args[1]
6494                 mem := v.Args[2]
6495                 if !(is16Bit(off1 + off2)) {
6496                         break
6497                 }
6498                 v.reset(OpPPC64MOVHstore)
6499                 v.AuxInt = off1 + off2
6500                 v.Aux = sym
6501                 v.AddArg(x)
6502                 v.AddArg(val)
6503                 v.AddArg(mem)
6504                 return true
6505         }
6506         // match: (MOVHstore [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) val mem)
6507         // cond: canMergeSym(sym1,sym2)
6508         // result: (MOVHstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem)
6509         for {
6510                 off1 := v.AuxInt
6511                 sym1 := v.Aux
6512                 v_0 := v.Args[0]
6513                 if v_0.Op != OpPPC64MOVDaddr {
6514                         break
6515                 }
6516                 off2 := v_0.AuxInt
6517                 sym2 := v_0.Aux
6518                 ptr := v_0.Args[0]
6519                 val := v.Args[1]
6520                 mem := v.Args[2]
6521                 if !(canMergeSym(sym1, sym2)) {
6522                         break
6523                 }
6524                 v.reset(OpPPC64MOVHstore)
6525                 v.AuxInt = off1 + off2
6526                 v.Aux = mergeSym(sym1, sym2)
6527                 v.AddArg(ptr)
6528                 v.AddArg(val)
6529                 v.AddArg(mem)
6530                 return true
6531         }
6532         // match: (MOVHstore [off] {sym} ptr (MOVDconst [c]) mem)
6533         // cond: c == 0
6534         // result: (MOVHstorezero [off] {sym} ptr mem)
6535         for {
6536                 off := v.AuxInt
6537                 sym := v.Aux
6538                 ptr := v.Args[0]
6539                 v_1 := v.Args[1]
6540                 if v_1.Op != OpPPC64MOVDconst {
6541                         break
6542                 }
6543                 c := v_1.AuxInt
6544                 mem := v.Args[2]
6545                 if !(c == 0) {
6546                         break
6547                 }
6548                 v.reset(OpPPC64MOVHstorezero)
6549                 v.AuxInt = off
6550                 v.Aux = sym
6551                 v.AddArg(ptr)
6552                 v.AddArg(mem)
6553                 return true
6554         }
6555         // match: (MOVHstore [off] {sym} ptr (MOVHreg x) mem)
6556         // cond:
6557         // result: (MOVHstore [off] {sym} ptr x mem)
6558         for {
6559                 off := v.AuxInt
6560                 sym := v.Aux
6561                 ptr := v.Args[0]
6562                 v_1 := v.Args[1]
6563                 if v_1.Op != OpPPC64MOVHreg {
6564                         break
6565                 }
6566                 x := v_1.Args[0]
6567                 mem := v.Args[2]
6568                 v.reset(OpPPC64MOVHstore)
6569                 v.AuxInt = off
6570                 v.Aux = sym
6571                 v.AddArg(ptr)
6572                 v.AddArg(x)
6573                 v.AddArg(mem)
6574                 return true
6575         }
6576         // match: (MOVHstore [off] {sym} ptr (MOVHZreg x) mem)
6577         // cond:
6578         // result: (MOVHstore [off] {sym} ptr x mem)
6579         for {
6580                 off := v.AuxInt
6581                 sym := v.Aux
6582                 ptr := v.Args[0]
6583                 v_1 := v.Args[1]
6584                 if v_1.Op != OpPPC64MOVHZreg {
6585                         break
6586                 }
6587                 x := v_1.Args[0]
6588                 mem := v.Args[2]
6589                 v.reset(OpPPC64MOVHstore)
6590                 v.AuxInt = off
6591                 v.Aux = sym
6592                 v.AddArg(ptr)
6593                 v.AddArg(x)
6594                 v.AddArg(mem)
6595                 return true
6596         }
6597         return false
6598 }
6599 func rewriteValuePPC64_OpPPC64MOVHstorezero(v *Value, config *Config) bool {
6600         b := v.Block
6601         _ = b
6602         // match: (MOVHstorezero [off1] {sym} (ADDconst [off2] x) mem)
6603         // cond: is16Bit(off1+off2)
6604         // result: (MOVHstorezero [off1+off2] {sym} x mem)
6605         for {
6606                 off1 := v.AuxInt
6607                 sym := v.Aux
6608                 v_0 := v.Args[0]
6609                 if v_0.Op != OpPPC64ADDconst {
6610                         break
6611                 }
6612                 off2 := v_0.AuxInt
6613                 x := v_0.Args[0]
6614                 mem := v.Args[1]
6615                 if !(is16Bit(off1 + off2)) {
6616                         break
6617                 }
6618                 v.reset(OpPPC64MOVHstorezero)
6619                 v.AuxInt = off1 + off2
6620                 v.Aux = sym
6621                 v.AddArg(x)
6622                 v.AddArg(mem)
6623                 return true
6624         }
6625         // match: (MOVHstorezero [off1] {sym1} (MOVDaddr [off2] {sym2} x) mem)
6626         // cond: canMergeSym(sym1,sym2)
6627         // result: (MOVHstorezero [off1+off2] {mergeSym(sym1,sym2)} x mem)
6628         for {
6629                 off1 := v.AuxInt
6630                 sym1 := v.Aux
6631                 v_0 := v.Args[0]
6632                 if v_0.Op != OpPPC64MOVDaddr {
6633                         break
6634                 }
6635                 off2 := v_0.AuxInt
6636                 sym2 := v_0.Aux
6637                 x := v_0.Args[0]
6638                 mem := v.Args[1]
6639                 if !(canMergeSym(sym1, sym2)) {
6640                         break
6641                 }
6642                 v.reset(OpPPC64MOVHstorezero)
6643                 v.AuxInt = off1 + off2
6644                 v.Aux = mergeSym(sym1, sym2)
6645                 v.AddArg(x)
6646                 v.AddArg(mem)
6647                 return true
6648         }
6649         return false
6650 }
6651 func rewriteValuePPC64_OpPPC64MOVWZload(v *Value, config *Config) bool {
6652         b := v.Block
6653         _ = b
6654         // match: (MOVWZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
6655         // cond: canMergeSym(sym1,sym2)
6656         // result: (MOVWZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
6657         for {
6658                 off1 := v.AuxInt
6659                 sym1 := v.Aux
6660                 v_0 := v.Args[0]
6661                 if v_0.Op != OpPPC64MOVDaddr {
6662                         break
6663                 }
6664                 off2 := v_0.AuxInt
6665                 sym2 := v_0.Aux
6666                 ptr := v_0.Args[0]
6667                 mem := v.Args[1]
6668                 if !(canMergeSym(sym1, sym2)) {
6669                         break
6670                 }
6671                 v.reset(OpPPC64MOVWZload)
6672                 v.AuxInt = off1 + off2
6673                 v.Aux = mergeSym(sym1, sym2)
6674                 v.AddArg(ptr)
6675                 v.AddArg(mem)
6676                 return true
6677         }
6678         // match: (MOVWZload [off1] {sym} (ADDconst [off2] x) mem)
6679         // cond: is16Bit(off1+off2)
6680         // result: (MOVWZload [off1+off2] {sym} x mem)
6681         for {
6682                 off1 := v.AuxInt
6683                 sym := v.Aux
6684                 v_0 := v.Args[0]
6685                 if v_0.Op != OpPPC64ADDconst {
6686                         break
6687                 }
6688                 off2 := v_0.AuxInt
6689                 x := v_0.Args[0]
6690                 mem := v.Args[1]
6691                 if !(is16Bit(off1 + off2)) {
6692                         break
6693                 }
6694                 v.reset(OpPPC64MOVWZload)
6695                 v.AuxInt = off1 + off2
6696                 v.Aux = sym
6697                 v.AddArg(x)
6698                 v.AddArg(mem)
6699                 return true
6700         }
6701         return false
6702 }
6703 func rewriteValuePPC64_OpPPC64MOVWZreg(v *Value, config *Config) bool {
6704         b := v.Block
6705         _ = b
6706         // match: (MOVWZreg y:(ANDconst [c] _))
6707         // cond: uint64(c) <= 0xFFFFFFFF
6708         // result: y
6709         for {
6710                 y := v.Args[0]
6711                 if y.Op != OpPPC64ANDconst {
6712                         break
6713                 }
6714                 c := y.AuxInt
6715                 if !(uint64(c) <= 0xFFFFFFFF) {
6716                         break
6717                 }
6718                 v.reset(OpCopy)
6719                 v.Type = y.Type
6720                 v.AddArg(y)
6721                 return true
6722         }
6723         // match: (MOVWZreg y:(AND (MOVDconst [c]) _))
6724         // cond: uint64(c) <= 0xFFFFFFFF
6725         // result: y
6726         for {
6727                 y := v.Args[0]
6728                 if y.Op != OpPPC64AND {
6729                         break
6730                 }
6731                 y_0 := y.Args[0]
6732                 if y_0.Op != OpPPC64MOVDconst {
6733                         break
6734                 }
6735                 c := y_0.AuxInt
6736                 if !(uint64(c) <= 0xFFFFFFFF) {
6737                         break
6738                 }
6739                 v.reset(OpCopy)
6740                 v.Type = y.Type
6741                 v.AddArg(y)
6742                 return true
6743         }
6744         // match: (MOVWZreg y:(MOVWZreg _))
6745         // cond:
6746         // result: y
6747         for {
6748                 y := v.Args[0]
6749                 if y.Op != OpPPC64MOVWZreg {
6750                         break
6751                 }
6752                 v.reset(OpCopy)
6753                 v.Type = y.Type
6754                 v.AddArg(y)
6755                 return true
6756         }
6757         // match: (MOVWZreg y:(MOVHZreg _))
6758         // cond:
6759         // result: y
6760         for {
6761                 y := v.Args[0]
6762                 if y.Op != OpPPC64MOVHZreg {
6763                         break
6764                 }
6765                 v.reset(OpCopy)
6766                 v.Type = y.Type
6767                 v.AddArg(y)
6768                 return true
6769         }
6770         // match: (MOVWZreg y:(MOVBZreg _))
6771         // cond:
6772         // result: y
6773         for {
6774                 y := v.Args[0]
6775                 if y.Op != OpPPC64MOVBZreg {
6776                         break
6777                 }
6778                 v.reset(OpCopy)
6779                 v.Type = y.Type
6780                 v.AddArg(y)
6781                 return true
6782         }
6783         // match: (MOVWZreg y:(MOVWreg x))
6784         // cond:
6785         // result: (MOVWZreg x)
6786         for {
6787                 y := v.Args[0]
6788                 if y.Op != OpPPC64MOVWreg {
6789                         break
6790                 }
6791                 x := y.Args[0]
6792                 v.reset(OpPPC64MOVWZreg)
6793                 v.AddArg(x)
6794                 return true
6795         }
6796         return false
6797 }
6798 func rewriteValuePPC64_OpPPC64MOVWload(v *Value, config *Config) bool {
6799         b := v.Block
6800         _ = b
6801         // match: (MOVWload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
6802         // cond: canMergeSym(sym1,sym2)
6803         // result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
6804         for {
6805                 off1 := v.AuxInt
6806                 sym1 := v.Aux
6807                 v_0 := v.Args[0]
6808                 if v_0.Op != OpPPC64MOVDaddr {
6809                         break
6810                 }
6811                 off2 := v_0.AuxInt
6812                 sym2 := v_0.Aux
6813                 ptr := v_0.Args[0]
6814                 mem := v.Args[1]
6815                 if !(canMergeSym(sym1, sym2)) {
6816                         break
6817                 }
6818                 v.reset(OpPPC64MOVWload)
6819                 v.AuxInt = off1 + off2
6820                 v.Aux = mergeSym(sym1, sym2)
6821                 v.AddArg(ptr)
6822                 v.AddArg(mem)
6823                 return true
6824         }
6825         // match: (MOVWload [off1] {sym} (ADDconst [off2] x) mem)
6826         // cond: is16Bit(off1+off2)
6827         // result: (MOVWload [off1+off2] {sym} x mem)
6828         for {
6829                 off1 := v.AuxInt
6830                 sym := v.Aux
6831                 v_0 := v.Args[0]
6832                 if v_0.Op != OpPPC64ADDconst {
6833                         break
6834                 }
6835                 off2 := v_0.AuxInt
6836                 x := v_0.Args[0]
6837                 mem := v.Args[1]
6838                 if !(is16Bit(off1 + off2)) {
6839                         break
6840                 }
6841                 v.reset(OpPPC64MOVWload)
6842                 v.AuxInt = off1 + off2
6843                 v.Aux = sym
6844                 v.AddArg(x)
6845                 v.AddArg(mem)
6846                 return true
6847         }
6848         return false
6849 }
6850 func rewriteValuePPC64_OpPPC64MOVWreg(v *Value, config *Config) bool {
6851         b := v.Block
6852         _ = b
6853         // match: (MOVWreg y:(ANDconst [c] _))
6854         // cond: uint64(c) <= 0xFFFF
6855         // result: y
6856         for {
6857                 y := v.Args[0]
6858                 if y.Op != OpPPC64ANDconst {
6859                         break
6860                 }
6861                 c := y.AuxInt
6862                 if !(uint64(c) <= 0xFFFF) {
6863                         break
6864                 }
6865                 v.reset(OpCopy)
6866                 v.Type = y.Type
6867                 v.AddArg(y)
6868                 return true
6869         }
6870         // match: (MOVWreg y:(AND (MOVDconst [c]) _))
6871         // cond: uint64(c) <= 0x7FFFFFFF
6872         // result: y
6873         for {
6874                 y := v.Args[0]
6875                 if y.Op != OpPPC64AND {
6876                         break
6877                 }
6878                 y_0 := y.Args[0]
6879                 if y_0.Op != OpPPC64MOVDconst {
6880                         break
6881                 }
6882                 c := y_0.AuxInt
6883                 if !(uint64(c) <= 0x7FFFFFFF) {
6884                         break
6885                 }
6886                 v.reset(OpCopy)
6887                 v.Type = y.Type
6888                 v.AddArg(y)
6889                 return true
6890         }
6891         // match: (MOVWreg y:(MOVWreg _))
6892         // cond:
6893         // result: y
6894         for {
6895                 y := v.Args[0]
6896                 if y.Op != OpPPC64MOVWreg {
6897                         break
6898                 }
6899                 v.reset(OpCopy)
6900                 v.Type = y.Type
6901                 v.AddArg(y)
6902                 return true
6903         }
6904         // match: (MOVWreg y:(MOVHreg _))
6905         // cond:
6906         // result: y
6907         for {
6908                 y := v.Args[0]
6909                 if y.Op != OpPPC64MOVHreg {
6910                         break
6911                 }
6912                 v.reset(OpCopy)
6913                 v.Type = y.Type
6914                 v.AddArg(y)
6915                 return true
6916         }
6917         // match: (MOVWreg y:(MOVBreg _))
6918         // cond:
6919         // result: y
6920         for {
6921                 y := v.Args[0]
6922                 if y.Op != OpPPC64MOVBreg {
6923                         break
6924                 }
6925                 v.reset(OpCopy)
6926                 v.Type = y.Type
6927                 v.AddArg(y)
6928                 return true
6929         }
6930         // match: (MOVWreg y:(MOVWZreg x))
6931         // cond:
6932         // result: (MOVWreg x)
6933         for {
6934                 y := v.Args[0]
6935                 if y.Op != OpPPC64MOVWZreg {
6936                         break
6937                 }
6938                 x := y.Args[0]
6939                 v.reset(OpPPC64MOVWreg)
6940                 v.AddArg(x)
6941                 return true
6942         }
6943         return false
6944 }
6945 func rewriteValuePPC64_OpPPC64MOVWstore(v *Value, config *Config) bool {
6946         b := v.Block
6947         _ = b
6948         // match: (MOVWstore [off1] {sym} (ADDconst [off2] x) val mem)
6949         // cond: is16Bit(off1+off2)
6950         // result: (MOVWstore [off1+off2] {sym} x val mem)
6951         for {
6952                 off1 := v.AuxInt
6953                 sym := v.Aux
6954                 v_0 := v.Args[0]
6955                 if v_0.Op != OpPPC64ADDconst {
6956                         break
6957                 }
6958                 off2 := v_0.AuxInt
6959                 x := v_0.Args[0]
6960                 val := v.Args[1]
6961                 mem := v.Args[2]
6962                 if !(is16Bit(off1 + off2)) {
6963                         break
6964                 }
6965                 v.reset(OpPPC64MOVWstore)
6966                 v.AuxInt = off1 + off2
6967                 v.Aux = sym
6968                 v.AddArg(x)
6969                 v.AddArg(val)
6970                 v.AddArg(mem)
6971                 return true
6972         }
6973         // match: (MOVWstore [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) val mem)
6974         // cond: canMergeSym(sym1,sym2)
6975         // result: (MOVWstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem)
6976         for {
6977                 off1 := v.AuxInt
6978                 sym1 := v.Aux
6979                 v_0 := v.Args[0]
6980                 if v_0.Op != OpPPC64MOVDaddr {
6981                         break
6982                 }
6983                 off2 := v_0.AuxInt
6984                 sym2 := v_0.Aux
6985                 ptr := v_0.Args[0]
6986                 val := v.Args[1]
6987                 mem := v.Args[2]
6988                 if !(canMergeSym(sym1, sym2)) {
6989                         break
6990                 }
6991                 v.reset(OpPPC64MOVWstore)
6992                 v.AuxInt = off1 + off2
6993                 v.Aux = mergeSym(sym1, sym2)
6994                 v.AddArg(ptr)
6995                 v.AddArg(val)
6996                 v.AddArg(mem)
6997                 return true
6998         }
6999         // match: (MOVWstore [off] {sym} ptr (MOVDconst [c]) mem)
7000         // cond: c == 0
7001         // result: (MOVWstorezero [off] {sym} ptr mem)
7002         for {
7003                 off := v.AuxInt
7004                 sym := v.Aux
7005                 ptr := v.Args[0]
7006                 v_1 := v.Args[1]
7007                 if v_1.Op != OpPPC64MOVDconst {
7008                         break
7009                 }
7010                 c := v_1.AuxInt
7011                 mem := v.Args[2]
7012                 if !(c == 0) {
7013                         break
7014                 }
7015                 v.reset(OpPPC64MOVWstorezero)
7016                 v.AuxInt = off
7017                 v.Aux = sym
7018                 v.AddArg(ptr)
7019                 v.AddArg(mem)
7020                 return true
7021         }
7022         // match: (MOVWstore [off] {sym} ptr (MOVWreg x) mem)
7023         // cond:
7024         // result: (MOVWstore [off] {sym} ptr x mem)
7025         for {
7026                 off := v.AuxInt
7027                 sym := v.Aux
7028                 ptr := v.Args[0]
7029                 v_1 := v.Args[1]
7030                 if v_1.Op != OpPPC64MOVWreg {
7031                         break
7032                 }
7033                 x := v_1.Args[0]
7034                 mem := v.Args[2]
7035                 v.reset(OpPPC64MOVWstore)
7036                 v.AuxInt = off
7037                 v.Aux = sym
7038                 v.AddArg(ptr)
7039                 v.AddArg(x)
7040                 v.AddArg(mem)
7041                 return true
7042         }
7043         // match: (MOVWstore [off] {sym} ptr (MOVWZreg x) mem)
7044         // cond:
7045         // result: (MOVWstore [off] {sym} ptr x mem)
7046         for {
7047                 off := v.AuxInt
7048                 sym := v.Aux
7049                 ptr := v.Args[0]
7050                 v_1 := v.Args[1]
7051                 if v_1.Op != OpPPC64MOVWZreg {
7052                         break
7053                 }
7054                 x := v_1.Args[0]
7055                 mem := v.Args[2]
7056                 v.reset(OpPPC64MOVWstore)
7057                 v.AuxInt = off
7058                 v.Aux = sym
7059                 v.AddArg(ptr)
7060                 v.AddArg(x)
7061                 v.AddArg(mem)
7062                 return true
7063         }
7064         return false
7065 }
7066 func rewriteValuePPC64_OpPPC64MOVWstorezero(v *Value, config *Config) bool {
7067         b := v.Block
7068         _ = b
7069         // match: (MOVWstorezero [off1] {sym} (ADDconst [off2] x) mem)
7070         // cond: is16Bit(off1+off2)
7071         // result: (MOVWstorezero [off1+off2] {sym} x mem)
7072         for {
7073                 off1 := v.AuxInt
7074                 sym := v.Aux
7075                 v_0 := v.Args[0]
7076                 if v_0.Op != OpPPC64ADDconst {
7077                         break
7078                 }
7079                 off2 := v_0.AuxInt
7080                 x := v_0.Args[0]
7081                 mem := v.Args[1]
7082                 if !(is16Bit(off1 + off2)) {
7083                         break
7084                 }
7085                 v.reset(OpPPC64MOVWstorezero)
7086                 v.AuxInt = off1 + off2
7087                 v.Aux = sym
7088                 v.AddArg(x)
7089                 v.AddArg(mem)
7090                 return true
7091         }
7092         // match: (MOVWstorezero [off1] {sym1} (MOVDaddr [off2] {sym2} x) mem)
7093         // cond: canMergeSym(sym1,sym2)
7094         // result: (MOVWstorezero [off1+off2] {mergeSym(sym1,sym2)} x mem)
7095         for {
7096                 off1 := v.AuxInt
7097                 sym1 := v.Aux
7098                 v_0 := v.Args[0]
7099                 if v_0.Op != OpPPC64MOVDaddr {
7100                         break
7101                 }
7102                 off2 := v_0.AuxInt
7103                 sym2 := v_0.Aux
7104                 x := v_0.Args[0]
7105                 mem := v.Args[1]
7106                 if !(canMergeSym(sym1, sym2)) {
7107                         break
7108                 }
7109                 v.reset(OpPPC64MOVWstorezero)
7110                 v.AuxInt = off1 + off2
7111                 v.Aux = mergeSym(sym1, sym2)
7112                 v.AddArg(x)
7113                 v.AddArg(mem)
7114                 return true
7115         }
7116         return false
7117 }
7118 func rewriteValuePPC64_OpPPC64MaskIfNotCarry(v *Value, config *Config) bool {
7119         b := v.Block
7120         _ = b
7121         // match: (MaskIfNotCarry (ADDconstForCarry [c] (ANDconst [d] _)))
7122         // cond: c < 0 && d > 0 && c + d < 0
7123         // result: (MOVDconst [-1])
7124         for {
7125                 v_0 := v.Args[0]
7126                 if v_0.Op != OpPPC64ADDconstForCarry {
7127                         break
7128                 }
7129                 c := v_0.AuxInt
7130                 v_0_0 := v_0.Args[0]
7131                 if v_0_0.Op != OpPPC64ANDconst {
7132                         break
7133                 }
7134                 d := v_0_0.AuxInt
7135                 if !(c < 0 && d > 0 && c+d < 0) {
7136                         break
7137                 }
7138                 v.reset(OpPPC64MOVDconst)
7139                 v.AuxInt = -1
7140                 return true
7141         }
7142         return false
7143 }
7144 func rewriteValuePPC64_OpPPC64NotEqual(v *Value, config *Config) bool {
7145         b := v.Block
7146         _ = b
7147         // match: (NotEqual (FlagEQ))
7148         // cond:
7149         // result: (MOVDconst [0])
7150         for {
7151                 v_0 := v.Args[0]
7152                 if v_0.Op != OpPPC64FlagEQ {
7153                         break
7154                 }
7155                 v.reset(OpPPC64MOVDconst)
7156                 v.AuxInt = 0
7157                 return true
7158         }
7159         // match: (NotEqual (FlagLT))
7160         // cond:
7161         // result: (MOVDconst [1])
7162         for {
7163                 v_0 := v.Args[0]
7164                 if v_0.Op != OpPPC64FlagLT {
7165                         break
7166                 }
7167                 v.reset(OpPPC64MOVDconst)
7168                 v.AuxInt = 1
7169                 return true
7170         }
7171         // match: (NotEqual (FlagGT))
7172         // cond:
7173         // result: (MOVDconst [1])
7174         for {
7175                 v_0 := v.Args[0]
7176                 if v_0.Op != OpPPC64FlagGT {
7177                         break
7178                 }
7179                 v.reset(OpPPC64MOVDconst)
7180                 v.AuxInt = 1
7181                 return true
7182         }
7183         // match: (NotEqual (InvertFlags x))
7184         // cond:
7185         // result: (NotEqual x)
7186         for {
7187                 v_0 := v.Args[0]
7188                 if v_0.Op != OpPPC64InvertFlags {
7189                         break
7190                 }
7191                 x := v_0.Args[0]
7192                 v.reset(OpPPC64NotEqual)
7193                 v.AddArg(x)
7194                 return true
7195         }
7196         return false
7197 }
7198 func rewriteValuePPC64_OpPPC64OR(v *Value, config *Config) bool {
7199         b := v.Block
7200         _ = b
7201         // match: (OR (MOVDconst [c]) (MOVDconst [d]))
7202         // cond:
7203         // result: (MOVDconst [c|d])
7204         for {
7205                 v_0 := v.Args[0]
7206                 if v_0.Op != OpPPC64MOVDconst {
7207                         break
7208                 }
7209                 c := v_0.AuxInt
7210                 v_1 := v.Args[1]
7211                 if v_1.Op != OpPPC64MOVDconst {
7212                         break
7213                 }
7214                 d := v_1.AuxInt
7215                 v.reset(OpPPC64MOVDconst)
7216                 v.AuxInt = c | d
7217                 return true
7218         }
7219         // match: (OR x (MOVDconst [c]))
7220         // cond: isU32Bit(c)
7221         // result: (ORconst [c] x)
7222         for {
7223                 x := v.Args[0]
7224                 v_1 := v.Args[1]
7225                 if v_1.Op != OpPPC64MOVDconst {
7226                         break
7227                 }
7228                 c := v_1.AuxInt
7229                 if !(isU32Bit(c)) {
7230                         break
7231                 }
7232                 v.reset(OpPPC64ORconst)
7233                 v.AuxInt = c
7234                 v.AddArg(x)
7235                 return true
7236         }
7237         // match: (OR (MOVDconst [c]) x)
7238         // cond: isU32Bit(c)
7239         // result: (ORconst [c] x)
7240         for {
7241                 v_0 := v.Args[0]
7242                 if v_0.Op != OpPPC64MOVDconst {
7243                         break
7244                 }
7245                 c := v_0.AuxInt
7246                 x := v.Args[1]
7247                 if !(isU32Bit(c)) {
7248                         break
7249                 }
7250                 v.reset(OpPPC64ORconst)
7251                 v.AuxInt = c
7252                 v.AddArg(x)
7253                 return true
7254         }
7255         return false
7256 }
7257 func rewriteValuePPC64_OpPPC64ORN(v *Value, config *Config) bool {
7258         b := v.Block
7259         _ = b
7260         // match: (ORN x (MOVDconst [-1]))
7261         // cond:
7262         // result: x
7263         for {
7264                 x := v.Args[0]
7265                 v_1 := v.Args[1]
7266                 if v_1.Op != OpPPC64MOVDconst {
7267                         break
7268                 }
7269                 if v_1.AuxInt != -1 {
7270                         break
7271                 }
7272                 v.reset(OpCopy)
7273                 v.Type = x.Type
7274                 v.AddArg(x)
7275                 return true
7276         }
7277         return false
7278 }
7279 func rewriteValuePPC64_OpPPC64ORconst(v *Value, config *Config) bool {
7280         b := v.Block
7281         _ = b
7282         // match: (ORconst [c] (ORconst [d] x))
7283         // cond:
7284         // result: (ORconst [c|d] x)
7285         for {
7286                 c := v.AuxInt
7287                 v_0 := v.Args[0]
7288                 if v_0.Op != OpPPC64ORconst {
7289                         break
7290                 }
7291                 d := v_0.AuxInt
7292                 x := v_0.Args[0]
7293                 v.reset(OpPPC64ORconst)
7294                 v.AuxInt = c | d
7295                 v.AddArg(x)
7296                 return true
7297         }
7298         // match: (ORconst [-1] _)
7299         // cond:
7300         // result: (MOVDconst [-1])
7301         for {
7302                 if v.AuxInt != -1 {
7303                         break
7304                 }
7305                 v.reset(OpPPC64MOVDconst)
7306                 v.AuxInt = -1
7307                 return true
7308         }
7309         // match: (ORconst [0] x)
7310         // cond:
7311         // result: x
7312         for {
7313                 if v.AuxInt != 0 {
7314                         break
7315                 }
7316                 x := v.Args[0]
7317                 v.reset(OpCopy)
7318                 v.Type = x.Type
7319                 v.AddArg(x)
7320                 return true
7321         }
7322         return false
7323 }
7324 func rewriteValuePPC64_OpPPC64SUB(v *Value, config *Config) bool {
7325         b := v.Block
7326         _ = b
7327         // match: (SUB x (MOVDconst [c]))
7328         // cond: is32Bit(-c)
7329         // result: (ADDconst [-c] x)
7330         for {
7331                 x := v.Args[0]
7332                 v_1 := v.Args[1]
7333                 if v_1.Op != OpPPC64MOVDconst {
7334                         break
7335                 }
7336                 c := v_1.AuxInt
7337                 if !(is32Bit(-c)) {
7338                         break
7339                 }
7340                 v.reset(OpPPC64ADDconst)
7341                 v.AuxInt = -c
7342                 v.AddArg(x)
7343                 return true
7344         }
7345         return false
7346 }
7347 func rewriteValuePPC64_OpPPC64XOR(v *Value, config *Config) bool {
7348         b := v.Block
7349         _ = b
7350         // match: (XOR (MOVDconst [c]) (MOVDconst [d]))
7351         // cond:
7352         // result: (MOVDconst [c^d])
7353         for {
7354                 v_0 := v.Args[0]
7355                 if v_0.Op != OpPPC64MOVDconst {
7356                         break
7357                 }
7358                 c := v_0.AuxInt
7359                 v_1 := v.Args[1]
7360                 if v_1.Op != OpPPC64MOVDconst {
7361                         break
7362                 }
7363                 d := v_1.AuxInt
7364                 v.reset(OpPPC64MOVDconst)
7365                 v.AuxInt = c ^ d
7366                 return true
7367         }
7368         // match: (XOR x (MOVDconst [c]))
7369         // cond: isU32Bit(c)
7370         // result: (XORconst [c] x)
7371         for {
7372                 x := v.Args[0]
7373                 v_1 := v.Args[1]
7374                 if v_1.Op != OpPPC64MOVDconst {
7375                         break
7376                 }
7377                 c := v_1.AuxInt
7378                 if !(isU32Bit(c)) {
7379                         break
7380                 }
7381                 v.reset(OpPPC64XORconst)
7382                 v.AuxInt = c
7383                 v.AddArg(x)
7384                 return true
7385         }
7386         // match: (XOR (MOVDconst [c]) x)
7387         // cond: isU32Bit(c)
7388         // result: (XORconst [c] x)
7389         for {
7390                 v_0 := v.Args[0]
7391                 if v_0.Op != OpPPC64MOVDconst {
7392                         break
7393                 }
7394                 c := v_0.AuxInt
7395                 x := v.Args[1]
7396                 if !(isU32Bit(c)) {
7397                         break
7398                 }
7399                 v.reset(OpPPC64XORconst)
7400                 v.AuxInt = c
7401                 v.AddArg(x)
7402                 return true
7403         }
7404         return false
7405 }
7406 func rewriteValuePPC64_OpPPC64XORconst(v *Value, config *Config) bool {
7407         b := v.Block
7408         _ = b
7409         // match: (XORconst [c] (XORconst [d] x))
7410         // cond:
7411         // result: (XORconst [c^d] x)
7412         for {
7413                 c := v.AuxInt
7414                 v_0 := v.Args[0]
7415                 if v_0.Op != OpPPC64XORconst {
7416                         break
7417                 }
7418                 d := v_0.AuxInt
7419                 x := v_0.Args[0]
7420                 v.reset(OpPPC64XORconst)
7421                 v.AuxInt = c ^ d
7422                 v.AddArg(x)
7423                 return true
7424         }
7425         // match: (XORconst [0] x)
7426         // cond:
7427         // result: x
7428         for {
7429                 if v.AuxInt != 0 {
7430                         break
7431                 }
7432                 x := v.Args[0]
7433                 v.reset(OpCopy)
7434                 v.Type = x.Type
7435                 v.AddArg(x)
7436                 return true
7437         }
7438         return false
7439 }
7440 func rewriteValuePPC64_OpRsh16Ux16(v *Value, config *Config) bool {
7441         b := v.Block
7442         _ = b
7443         // match: (Rsh16Ux16 x y)
7444         // cond:
7445         // result: (SRW  (ZeroExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
7446         for {
7447                 x := v.Args[0]
7448                 y := v.Args[1]
7449                 v.reset(OpPPC64SRW)
7450                 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
7451                 v0.AddArg(x)
7452                 v.AddArg(v0)
7453                 v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
7454                 v1.AddArg(y)
7455                 v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
7456                 v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
7457                 v3.AuxInt = -16
7458                 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64())
7459                 v4.AddArg(y)
7460                 v3.AddArg(v4)
7461                 v2.AddArg(v3)
7462                 v1.AddArg(v2)
7463                 v.AddArg(v1)
7464                 return true
7465         }
7466 }
7467 func rewriteValuePPC64_OpRsh16Ux32(v *Value, config *Config) bool {
7468         b := v.Block
7469         _ = b
7470         // match: (Rsh16Ux32 x (Const64 [c]))
7471         // cond: uint32(c) < 16
7472         // result: (SRWconst (ZeroExt16to32 x) [c])
7473         for {
7474                 x := v.Args[0]
7475                 v_1 := v.Args[1]
7476                 if v_1.Op != OpConst64 {
7477                         break
7478                 }
7479                 c := v_1.AuxInt
7480                 if !(uint32(c) < 16) {
7481                         break
7482                 }
7483                 v.reset(OpPPC64SRWconst)
7484                 v.AuxInt = c
7485                 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
7486                 v0.AddArg(x)
7487                 v.AddArg(v0)
7488                 return true
7489         }
7490         // match: (Rsh16Ux32 x (MOVDconst [c]))
7491         // cond: uint32(c) < 16
7492         // result: (SRWconst (ZeroExt16to32 x) [c])
7493         for {
7494                 x := v.Args[0]
7495                 v_1 := v.Args[1]
7496                 if v_1.Op != OpPPC64MOVDconst {
7497                         break
7498                 }
7499                 c := v_1.AuxInt
7500                 if !(uint32(c) < 16) {
7501                         break
7502                 }
7503                 v.reset(OpPPC64SRWconst)
7504                 v.AuxInt = c
7505                 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
7506                 v0.AddArg(x)
7507                 v.AddArg(v0)
7508                 return true
7509         }
7510         // match: (Rsh16Ux32 x y)
7511         // cond:
7512         // result: (SRW  (ZeroExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
7513         for {
7514                 x := v.Args[0]
7515                 y := v.Args[1]
7516                 v.reset(OpPPC64SRW)
7517                 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
7518                 v0.AddArg(x)
7519                 v.AddArg(v0)
7520                 v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
7521                 v1.AddArg(y)
7522                 v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
7523                 v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
7524                 v3.AuxInt = -16
7525                 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64())
7526                 v4.AddArg(y)
7527                 v3.AddArg(v4)
7528                 v2.AddArg(v3)
7529                 v1.AddArg(v2)
7530                 v.AddArg(v1)
7531                 return true
7532         }
7533 }
7534 func rewriteValuePPC64_OpRsh16Ux64(v *Value, config *Config) bool {
7535         b := v.Block
7536         _ = b
7537         // match: (Rsh16Ux64 x (Const64 [c]))
7538         // cond: uint64(c) < 16
7539         // result: (SRWconst (ZeroExt16to32 x) [c])
7540         for {
7541                 x := v.Args[0]
7542                 v_1 := v.Args[1]
7543                 if v_1.Op != OpConst64 {
7544                         break
7545                 }
7546                 c := v_1.AuxInt
7547                 if !(uint64(c) < 16) {
7548                         break
7549                 }
7550                 v.reset(OpPPC64SRWconst)
7551                 v.AuxInt = c
7552                 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
7553                 v0.AddArg(x)
7554                 v.AddArg(v0)
7555                 return true
7556         }
7557         // match: (Rsh16Ux64 _ (Const64 [c]))
7558         // cond: uint64(c) >= 16
7559         // result: (MOVDconst [0])
7560         for {
7561                 v_1 := v.Args[1]
7562                 if v_1.Op != OpConst64 {
7563                         break
7564                 }
7565                 c := v_1.AuxInt
7566                 if !(uint64(c) >= 16) {
7567                         break
7568                 }
7569                 v.reset(OpPPC64MOVDconst)
7570                 v.AuxInt = 0
7571                 return true
7572         }
7573         // match: (Rsh16Ux64 x (MOVDconst [c]))
7574         // cond: uint64(c) < 16
7575         // result: (SRWconst (ZeroExt16to32 x) [c])
7576         for {
7577                 x := v.Args[0]
7578                 v_1 := v.Args[1]
7579                 if v_1.Op != OpPPC64MOVDconst {
7580                         break
7581                 }
7582                 c := v_1.AuxInt
7583                 if !(uint64(c) < 16) {
7584                         break
7585                 }
7586                 v.reset(OpPPC64SRWconst)
7587                 v.AuxInt = c
7588                 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
7589                 v0.AddArg(x)
7590                 v.AddArg(v0)
7591                 return true
7592         }
7593         // match: (Rsh16Ux64 x y)
7594         // cond:
7595         // result: (SRW  (ZeroExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
7596         for {
7597                 x := v.Args[0]
7598                 y := v.Args[1]
7599                 v.reset(OpPPC64SRW)
7600                 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
7601                 v0.AddArg(x)
7602                 v.AddArg(v0)
7603                 v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
7604                 v1.AddArg(y)
7605                 v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
7606                 v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
7607                 v3.AuxInt = -16
7608                 v3.AddArg(y)
7609                 v2.AddArg(v3)
7610                 v1.AddArg(v2)
7611                 v.AddArg(v1)
7612                 return true
7613         }
7614 }
7615 func rewriteValuePPC64_OpRsh16Ux8(v *Value, config *Config) bool {
7616         b := v.Block
7617         _ = b
7618         // match: (Rsh16Ux8 x y)
7619         // cond:
7620         // result: (SRW  (ZeroExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
7621         for {
7622                 x := v.Args[0]
7623                 y := v.Args[1]
7624                 v.reset(OpPPC64SRW)
7625                 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, config.fe.TypeUInt32())
7626                 v0.AddArg(x)
7627                 v.AddArg(v0)
7628                 v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
7629                 v1.AddArg(y)
7630                 v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
7631                 v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
7632                 v3.AuxInt = -16
7633                 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64())
7634                 v4.AddArg(y)
7635                 v3.AddArg(v4)
7636                 v2.AddArg(v3)
7637                 v1.AddArg(v2)
7638                 v.AddArg(v1)
7639                 return true
7640         }
7641 }
7642 func rewriteValuePPC64_OpRsh16x16(v *Value, config *Config) bool {
7643         b := v.Block
7644         _ = b
7645         // match: (Rsh16x16 x y)
7646         // cond:
7647         // result: (SRAW (SignExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt16to64 y)))))
7648         for {
7649                 x := v.Args[0]
7650                 y := v.Args[1]
7651                 v.reset(OpPPC64SRAW)
7652                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
7653                 v0.AddArg(x)
7654                 v.AddArg(v0)
7655                 v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
7656                 v1.AddArg(y)
7657                 v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
7658                 v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
7659                 v3.AuxInt = -16
7660                 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64())
7661                 v4.AddArg(y)
7662                 v3.AddArg(v4)
7663                 v2.AddArg(v3)
7664                 v1.AddArg(v2)
7665                 v.AddArg(v1)
7666                 return true
7667         }
7668 }
7669 func rewriteValuePPC64_OpRsh16x32(v *Value, config *Config) bool {
7670         b := v.Block
7671         _ = b
7672         // match: (Rsh16x32  x (Const64 [c]))
7673         // cond: uint32(c) < 16
7674         // result: (SRAWconst (SignExt16to32 x) [c])
7675         for {
7676                 x := v.Args[0]
7677                 v_1 := v.Args[1]
7678                 if v_1.Op != OpConst64 {
7679                         break
7680                 }
7681                 c := v_1.AuxInt
7682                 if !(uint32(c) < 16) {
7683                         break
7684                 }
7685                 v.reset(OpPPC64SRAWconst)
7686                 v.AuxInt = c
7687                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
7688                 v0.AddArg(x)
7689                 v.AddArg(v0)
7690                 return true
7691         }
7692         // match: (Rsh16x32  x (MOVDconst [c]))
7693         // cond: uint32(c) < 16
7694         // result: (SRAWconst (SignExt16to32 x) [c])
7695         for {
7696                 x := v.Args[0]
7697                 v_1 := v.Args[1]
7698                 if v_1.Op != OpPPC64MOVDconst {
7699                         break
7700                 }
7701                 c := v_1.AuxInt
7702                 if !(uint32(c) < 16) {
7703                         break
7704                 }
7705                 v.reset(OpPPC64SRAWconst)
7706                 v.AuxInt = c
7707                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
7708                 v0.AddArg(x)
7709                 v.AddArg(v0)
7710                 return true
7711         }
7712         // match: (Rsh16x32 x y)
7713         // cond:
7714         // result: (SRAW (SignExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt32to64 y)))))
7715         for {
7716                 x := v.Args[0]
7717                 y := v.Args[1]
7718                 v.reset(OpPPC64SRAW)
7719                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
7720                 v0.AddArg(x)
7721                 v.AddArg(v0)
7722                 v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
7723                 v1.AddArg(y)
7724                 v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
7725                 v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
7726                 v3.AuxInt = -16
7727                 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64())
7728                 v4.AddArg(y)
7729                 v3.AddArg(v4)
7730                 v2.AddArg(v3)
7731                 v1.AddArg(v2)
7732                 v.AddArg(v1)
7733                 return true
7734         }
7735 }
7736 func rewriteValuePPC64_OpRsh16x64(v *Value, config *Config) bool {
7737         b := v.Block
7738         _ = b
7739         // match: (Rsh16x64  x (Const64 [c]))
7740         // cond: uint64(c) < 16
7741         // result: (SRAWconst (SignExt16to32 x) [c])
7742         for {
7743                 x := v.Args[0]
7744                 v_1 := v.Args[1]
7745                 if v_1.Op != OpConst64 {
7746                         break
7747                 }
7748                 c := v_1.AuxInt
7749                 if !(uint64(c) < 16) {
7750                         break
7751                 }
7752                 v.reset(OpPPC64SRAWconst)
7753                 v.AuxInt = c
7754                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
7755                 v0.AddArg(x)
7756                 v.AddArg(v0)
7757                 return true
7758         }
7759         // match: (Rsh16x64 x (Const64 [c]))
7760         // cond: uint64(c) >= 16
7761         // result: (SRAWconst (SignExt16to32 x) [63])
7762         for {
7763                 x := v.Args[0]
7764                 v_1 := v.Args[1]
7765                 if v_1.Op != OpConst64 {
7766                         break
7767                 }
7768                 c := v_1.AuxInt
7769                 if !(uint64(c) >= 16) {
7770                         break
7771                 }
7772                 v.reset(OpPPC64SRAWconst)
7773                 v.AuxInt = 63
7774                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
7775                 v0.AddArg(x)
7776                 v.AddArg(v0)
7777                 return true
7778         }
7779         // match: (Rsh16x64  x (MOVDconst [c]))
7780         // cond: uint64(c) < 16
7781         // result: (SRAWconst (SignExt16to32 x) [c])
7782         for {
7783                 x := v.Args[0]
7784                 v_1 := v.Args[1]
7785                 if v_1.Op != OpPPC64MOVDconst {
7786                         break
7787                 }
7788                 c := v_1.AuxInt
7789                 if !(uint64(c) < 16) {
7790                         break
7791                 }
7792                 v.reset(OpPPC64SRAWconst)
7793                 v.AuxInt = c
7794                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
7795                 v0.AddArg(x)
7796                 v.AddArg(v0)
7797                 return true
7798         }
7799         // match: (Rsh16x64 x y)
7800         // cond:
7801         // result: (SRAW (SignExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] y))))
7802         for {
7803                 x := v.Args[0]
7804                 y := v.Args[1]
7805                 v.reset(OpPPC64SRAW)
7806                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
7807                 v0.AddArg(x)
7808                 v.AddArg(v0)
7809                 v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
7810                 v1.AddArg(y)
7811                 v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
7812                 v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
7813                 v3.AuxInt = -16
7814                 v3.AddArg(y)
7815                 v2.AddArg(v3)
7816                 v1.AddArg(v2)
7817                 v.AddArg(v1)
7818                 return true
7819         }
7820 }
7821 func rewriteValuePPC64_OpRsh16x8(v *Value, config *Config) bool {
7822         b := v.Block
7823         _ = b
7824         // match: (Rsh16x8 x y)
7825         // cond:
7826         // result: (SRAW (SignExt16to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-16] (ZeroExt8to64 y)))))
7827         for {
7828                 x := v.Args[0]
7829                 y := v.Args[1]
7830                 v.reset(OpPPC64SRAW)
7831                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, config.fe.TypeInt32())
7832                 v0.AddArg(x)
7833                 v.AddArg(v0)
7834                 v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
7835                 v1.AddArg(y)
7836                 v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
7837                 v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
7838                 v3.AuxInt = -16
7839                 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64())
7840                 v4.AddArg(y)
7841                 v3.AddArg(v4)
7842                 v2.AddArg(v3)
7843                 v1.AddArg(v2)
7844                 v.AddArg(v1)
7845                 return true
7846         }
7847 }
7848 func rewriteValuePPC64_OpRsh32Ux16(v *Value, config *Config) bool {
7849         b := v.Block
7850         _ = b
7851         // match: (Rsh32Ux16 x y)
7852         // cond:
7853         // result: (SRW x  (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
7854         for {
7855                 x := v.Args[0]
7856                 y := v.Args[1]
7857                 v.reset(OpPPC64SRW)
7858                 v.AddArg(x)
7859                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
7860                 v0.AddArg(y)
7861                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
7862                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
7863                 v2.AuxInt = -32
7864                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64())
7865                 v3.AddArg(y)
7866                 v2.AddArg(v3)
7867                 v1.AddArg(v2)
7868                 v0.AddArg(v1)
7869                 v.AddArg(v0)
7870                 return true
7871         }
7872 }
7873 func rewriteValuePPC64_OpRsh32Ux32(v *Value, config *Config) bool {
7874         b := v.Block
7875         _ = b
7876         // match: (Rsh32Ux32 x (Const64 [c]))
7877         // cond: uint32(c) < 32
7878         // result: (SRWconst x [c])
7879         for {
7880                 x := v.Args[0]
7881                 v_1 := v.Args[1]
7882                 if v_1.Op != OpConst64 {
7883                         break
7884                 }
7885                 c := v_1.AuxInt
7886                 if !(uint32(c) < 32) {
7887                         break
7888                 }
7889                 v.reset(OpPPC64SRWconst)
7890                 v.AuxInt = c
7891                 v.AddArg(x)
7892                 return true
7893         }
7894         // match: (Rsh32Ux32 x (MOVDconst [c]))
7895         // cond: uint32(c) < 32
7896         // result: (SRWconst x [c])
7897         for {
7898                 x := v.Args[0]
7899                 v_1 := v.Args[1]
7900                 if v_1.Op != OpPPC64MOVDconst {
7901                         break
7902                 }
7903                 c := v_1.AuxInt
7904                 if !(uint32(c) < 32) {
7905                         break
7906                 }
7907                 v.reset(OpPPC64SRWconst)
7908                 v.AuxInt = c
7909                 v.AddArg(x)
7910                 return true
7911         }
7912         // match: (Rsh32Ux32 x y)
7913         // cond:
7914         // result: (SRW x  (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
7915         for {
7916                 x := v.Args[0]
7917                 y := v.Args[1]
7918                 v.reset(OpPPC64SRW)
7919                 v.AddArg(x)
7920                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
7921                 v0.AddArg(y)
7922                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
7923                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
7924                 v2.AuxInt = -32
7925                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64())
7926                 v3.AddArg(y)
7927                 v2.AddArg(v3)
7928                 v1.AddArg(v2)
7929                 v0.AddArg(v1)
7930                 v.AddArg(v0)
7931                 return true
7932         }
7933 }
7934 func rewriteValuePPC64_OpRsh32Ux64(v *Value, config *Config) bool {
7935         b := v.Block
7936         _ = b
7937         // match: (Rsh32Ux64 x (Const64 [c]))
7938         // cond: uint64(c) < 32
7939         // result: (SRWconst x [c])
7940         for {
7941                 x := v.Args[0]
7942                 v_1 := v.Args[1]
7943                 if v_1.Op != OpConst64 {
7944                         break
7945                 }
7946                 c := v_1.AuxInt
7947                 if !(uint64(c) < 32) {
7948                         break
7949                 }
7950                 v.reset(OpPPC64SRWconst)
7951                 v.AuxInt = c
7952                 v.AddArg(x)
7953                 return true
7954         }
7955         // match: (Rsh32Ux64 _ (Const64 [c]))
7956         // cond: uint64(c) >= 32
7957         // result: (MOVDconst [0])
7958         for {
7959                 v_1 := v.Args[1]
7960                 if v_1.Op != OpConst64 {
7961                         break
7962                 }
7963                 c := v_1.AuxInt
7964                 if !(uint64(c) >= 32) {
7965                         break
7966                 }
7967                 v.reset(OpPPC64MOVDconst)
7968                 v.AuxInt = 0
7969                 return true
7970         }
7971         // match: (Rsh32Ux64 x (MOVDconst [c]))
7972         // cond: uint64(c) < 32
7973         // result: (SRWconst x [c])
7974         for {
7975                 x := v.Args[0]
7976                 v_1 := v.Args[1]
7977                 if v_1.Op != OpPPC64MOVDconst {
7978                         break
7979                 }
7980                 c := v_1.AuxInt
7981                 if !(uint64(c) < 32) {
7982                         break
7983                 }
7984                 v.reset(OpPPC64SRWconst)
7985                 v.AuxInt = c
7986                 v.AddArg(x)
7987                 return true
7988         }
7989         // match: (Rsh32Ux64 x y)
7990         // cond:
7991         // result: (SRW  x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
7992         for {
7993                 x := v.Args[0]
7994                 y := v.Args[1]
7995                 v.reset(OpPPC64SRW)
7996                 v.AddArg(x)
7997                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
7998                 v0.AddArg(y)
7999                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8000                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8001                 v2.AuxInt = -32
8002                 v2.AddArg(y)
8003                 v1.AddArg(v2)
8004                 v0.AddArg(v1)
8005                 v.AddArg(v0)
8006                 return true
8007         }
8008 }
8009 func rewriteValuePPC64_OpRsh32Ux8(v *Value, config *Config) bool {
8010         b := v.Block
8011         _ = b
8012         // match: (Rsh32Ux8 x y)
8013         // cond:
8014         // result: (SRW x  (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
8015         for {
8016                 x := v.Args[0]
8017                 y := v.Args[1]
8018                 v.reset(OpPPC64SRW)
8019                 v.AddArg(x)
8020                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8021                 v0.AddArg(y)
8022                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8023                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8024                 v2.AuxInt = -32
8025                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64())
8026                 v3.AddArg(y)
8027                 v2.AddArg(v3)
8028                 v1.AddArg(v2)
8029                 v0.AddArg(v1)
8030                 v.AddArg(v0)
8031                 return true
8032         }
8033 }
8034 func rewriteValuePPC64_OpRsh32x16(v *Value, config *Config) bool {
8035         b := v.Block
8036         _ = b
8037         // match: (Rsh32x16 x y)
8038         // cond:
8039         // result: (SRAW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt16to64 y)))))
8040         for {
8041                 x := v.Args[0]
8042                 y := v.Args[1]
8043                 v.reset(OpPPC64SRAW)
8044                 v.AddArg(x)
8045                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8046                 v0.AddArg(y)
8047                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8048                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8049                 v2.AuxInt = -32
8050                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64())
8051                 v3.AddArg(y)
8052                 v2.AddArg(v3)
8053                 v1.AddArg(v2)
8054                 v0.AddArg(v1)
8055                 v.AddArg(v0)
8056                 return true
8057         }
8058 }
8059 func rewriteValuePPC64_OpRsh32x32(v *Value, config *Config) bool {
8060         b := v.Block
8061         _ = b
8062         // match: (Rsh32x32  x (Const64 [c]))
8063         // cond: uint32(c) < 32
8064         // result: (SRAWconst x [c])
8065         for {
8066                 x := v.Args[0]
8067                 v_1 := v.Args[1]
8068                 if v_1.Op != OpConst64 {
8069                         break
8070                 }
8071                 c := v_1.AuxInt
8072                 if !(uint32(c) < 32) {
8073                         break
8074                 }
8075                 v.reset(OpPPC64SRAWconst)
8076                 v.AuxInt = c
8077                 v.AddArg(x)
8078                 return true
8079         }
8080         // match: (Rsh32x32  x (MOVDconst [c]))
8081         // cond: uint32(c) < 32
8082         // result: (SRAWconst x [c])
8083         for {
8084                 x := v.Args[0]
8085                 v_1 := v.Args[1]
8086                 if v_1.Op != OpPPC64MOVDconst {
8087                         break
8088                 }
8089                 c := v_1.AuxInt
8090                 if !(uint32(c) < 32) {
8091                         break
8092                 }
8093                 v.reset(OpPPC64SRAWconst)
8094                 v.AuxInt = c
8095                 v.AddArg(x)
8096                 return true
8097         }
8098         // match: (Rsh32x32 x y)
8099         // cond:
8100         // result: (SRAW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt32to64 y)))))
8101         for {
8102                 x := v.Args[0]
8103                 y := v.Args[1]
8104                 v.reset(OpPPC64SRAW)
8105                 v.AddArg(x)
8106                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8107                 v0.AddArg(y)
8108                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8109                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8110                 v2.AuxInt = -32
8111                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64())
8112                 v3.AddArg(y)
8113                 v2.AddArg(v3)
8114                 v1.AddArg(v2)
8115                 v0.AddArg(v1)
8116                 v.AddArg(v0)
8117                 return true
8118         }
8119 }
8120 func rewriteValuePPC64_OpRsh32x64(v *Value, config *Config) bool {
8121         b := v.Block
8122         _ = b
8123         // match: (Rsh32x64  x (Const64 [c]))
8124         // cond: uint64(c) < 32
8125         // result: (SRAWconst x [c])
8126         for {
8127                 x := v.Args[0]
8128                 v_1 := v.Args[1]
8129                 if v_1.Op != OpConst64 {
8130                         break
8131                 }
8132                 c := v_1.AuxInt
8133                 if !(uint64(c) < 32) {
8134                         break
8135                 }
8136                 v.reset(OpPPC64SRAWconst)
8137                 v.AuxInt = c
8138                 v.AddArg(x)
8139                 return true
8140         }
8141         // match: (Rsh32x64 x (Const64 [c]))
8142         // cond: uint64(c) >= 32
8143         // result: (SRAWconst x [63])
8144         for {
8145                 x := v.Args[0]
8146                 v_1 := v.Args[1]
8147                 if v_1.Op != OpConst64 {
8148                         break
8149                 }
8150                 c := v_1.AuxInt
8151                 if !(uint64(c) >= 32) {
8152                         break
8153                 }
8154                 v.reset(OpPPC64SRAWconst)
8155                 v.AuxInt = 63
8156                 v.AddArg(x)
8157                 return true
8158         }
8159         // match: (Rsh32x64  x (MOVDconst [c]))
8160         // cond: uint64(c) < 32
8161         // result: (SRAWconst x [c])
8162         for {
8163                 x := v.Args[0]
8164                 v_1 := v.Args[1]
8165                 if v_1.Op != OpPPC64MOVDconst {
8166                         break
8167                 }
8168                 c := v_1.AuxInt
8169                 if !(uint64(c) < 32) {
8170                         break
8171                 }
8172                 v.reset(OpPPC64SRAWconst)
8173                 v.AuxInt = c
8174                 v.AddArg(x)
8175                 return true
8176         }
8177         // match: (Rsh32x64 x y)
8178         // cond:
8179         // result: (SRAW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] y))))
8180         for {
8181                 x := v.Args[0]
8182                 y := v.Args[1]
8183                 v.reset(OpPPC64SRAW)
8184                 v.AddArg(x)
8185                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8186                 v0.AddArg(y)
8187                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8188                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8189                 v2.AuxInt = -32
8190                 v2.AddArg(y)
8191                 v1.AddArg(v2)
8192                 v0.AddArg(v1)
8193                 v.AddArg(v0)
8194                 return true
8195         }
8196 }
8197 func rewriteValuePPC64_OpRsh32x8(v *Value, config *Config) bool {
8198         b := v.Block
8199         _ = b
8200         // match: (Rsh32x8 x y)
8201         // cond:
8202         // result: (SRAW x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-32] (ZeroExt8to64 y)))))
8203         for {
8204                 x := v.Args[0]
8205                 y := v.Args[1]
8206                 v.reset(OpPPC64SRAW)
8207                 v.AddArg(x)
8208                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8209                 v0.AddArg(y)
8210                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8211                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8212                 v2.AuxInt = -32
8213                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64())
8214                 v3.AddArg(y)
8215                 v2.AddArg(v3)
8216                 v1.AddArg(v2)
8217                 v0.AddArg(v1)
8218                 v.AddArg(v0)
8219                 return true
8220         }
8221 }
8222 func rewriteValuePPC64_OpRsh64Ux16(v *Value, config *Config) bool {
8223         b := v.Block
8224         _ = b
8225         // match: (Rsh64Ux16 x y)
8226         // cond:
8227         // result: (SRD x  (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
8228         for {
8229                 x := v.Args[0]
8230                 y := v.Args[1]
8231                 v.reset(OpPPC64SRD)
8232                 v.AddArg(x)
8233                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8234                 v0.AddArg(y)
8235                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8236                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8237                 v2.AuxInt = -64
8238                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64())
8239                 v3.AddArg(y)
8240                 v2.AddArg(v3)
8241                 v1.AddArg(v2)
8242                 v0.AddArg(v1)
8243                 v.AddArg(v0)
8244                 return true
8245         }
8246 }
8247 func rewriteValuePPC64_OpRsh64Ux32(v *Value, config *Config) bool {
8248         b := v.Block
8249         _ = b
8250         // match: (Rsh64Ux32 x (Const64 [c]))
8251         // cond: uint32(c) < 64
8252         // result: (SRDconst x [c])
8253         for {
8254                 x := v.Args[0]
8255                 v_1 := v.Args[1]
8256                 if v_1.Op != OpConst64 {
8257                         break
8258                 }
8259                 c := v_1.AuxInt
8260                 if !(uint32(c) < 64) {
8261                         break
8262                 }
8263                 v.reset(OpPPC64SRDconst)
8264                 v.AuxInt = c
8265                 v.AddArg(x)
8266                 return true
8267         }
8268         // match: (Rsh64Ux32 x (MOVDconst [c]))
8269         // cond: uint32(c) < 64
8270         // result: (SRDconst x [c])
8271         for {
8272                 x := v.Args[0]
8273                 v_1 := v.Args[1]
8274                 if v_1.Op != OpPPC64MOVDconst {
8275                         break
8276                 }
8277                 c := v_1.AuxInt
8278                 if !(uint32(c) < 64) {
8279                         break
8280                 }
8281                 v.reset(OpPPC64SRDconst)
8282                 v.AuxInt = c
8283                 v.AddArg(x)
8284                 return true
8285         }
8286         // match: (Rsh64Ux32 x y)
8287         // cond:
8288         // result: (SRD x  (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
8289         for {
8290                 x := v.Args[0]
8291                 y := v.Args[1]
8292                 v.reset(OpPPC64SRD)
8293                 v.AddArg(x)
8294                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8295                 v0.AddArg(y)
8296                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8297                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8298                 v2.AuxInt = -64
8299                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64())
8300                 v3.AddArg(y)
8301                 v2.AddArg(v3)
8302                 v1.AddArg(v2)
8303                 v0.AddArg(v1)
8304                 v.AddArg(v0)
8305                 return true
8306         }
8307 }
8308 func rewriteValuePPC64_OpRsh64Ux64(v *Value, config *Config) bool {
8309         b := v.Block
8310         _ = b
8311         // match: (Rsh64Ux64 x (Const64 [c]))
8312         // cond: uint64(c) < 64
8313         // result: (SRDconst x [c])
8314         for {
8315                 x := v.Args[0]
8316                 v_1 := v.Args[1]
8317                 if v_1.Op != OpConst64 {
8318                         break
8319                 }
8320                 c := v_1.AuxInt
8321                 if !(uint64(c) < 64) {
8322                         break
8323                 }
8324                 v.reset(OpPPC64SRDconst)
8325                 v.AuxInt = c
8326                 v.AddArg(x)
8327                 return true
8328         }
8329         // match: (Rsh64Ux64 _ (Const64 [c]))
8330         // cond: uint64(c) >= 64
8331         // result: (MOVDconst [0])
8332         for {
8333                 v_1 := v.Args[1]
8334                 if v_1.Op != OpConst64 {
8335                         break
8336                 }
8337                 c := v_1.AuxInt
8338                 if !(uint64(c) >= 64) {
8339                         break
8340                 }
8341                 v.reset(OpPPC64MOVDconst)
8342                 v.AuxInt = 0
8343                 return true
8344         }
8345         // match: (Rsh64Ux64 x (MOVDconst [c]))
8346         // cond: uint64(c) < 64
8347         // result: (SRDconst x [c])
8348         for {
8349                 x := v.Args[0]
8350                 v_1 := v.Args[1]
8351                 if v_1.Op != OpPPC64MOVDconst {
8352                         break
8353                 }
8354                 c := v_1.AuxInt
8355                 if !(uint64(c) < 64) {
8356                         break
8357                 }
8358                 v.reset(OpPPC64SRDconst)
8359                 v.AuxInt = c
8360                 v.AddArg(x)
8361                 return true
8362         }
8363         // match: (Rsh64Ux64 x y)
8364         // cond:
8365         // result: (SRD  x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
8366         for {
8367                 x := v.Args[0]
8368                 y := v.Args[1]
8369                 v.reset(OpPPC64SRD)
8370                 v.AddArg(x)
8371                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8372                 v0.AddArg(y)
8373                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8374                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8375                 v2.AuxInt = -64
8376                 v2.AddArg(y)
8377                 v1.AddArg(v2)
8378                 v0.AddArg(v1)
8379                 v.AddArg(v0)
8380                 return true
8381         }
8382 }
8383 func rewriteValuePPC64_OpRsh64Ux8(v *Value, config *Config) bool {
8384         b := v.Block
8385         _ = b
8386         // match: (Rsh64Ux8 x y)
8387         // cond:
8388         // result: (SRD x  (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
8389         for {
8390                 x := v.Args[0]
8391                 y := v.Args[1]
8392                 v.reset(OpPPC64SRD)
8393                 v.AddArg(x)
8394                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8395                 v0.AddArg(y)
8396                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8397                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8398                 v2.AuxInt = -64
8399                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64())
8400                 v3.AddArg(y)
8401                 v2.AddArg(v3)
8402                 v1.AddArg(v2)
8403                 v0.AddArg(v1)
8404                 v.AddArg(v0)
8405                 return true
8406         }
8407 }
8408 func rewriteValuePPC64_OpRsh64x16(v *Value, config *Config) bool {
8409         b := v.Block
8410         _ = b
8411         // match: (Rsh64x16 x y)
8412         // cond:
8413         // result: (SRAD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt16to64 y)))))
8414         for {
8415                 x := v.Args[0]
8416                 y := v.Args[1]
8417                 v.reset(OpPPC64SRAD)
8418                 v.AddArg(x)
8419                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8420                 v0.AddArg(y)
8421                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8422                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8423                 v2.AuxInt = -64
8424                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64())
8425                 v3.AddArg(y)
8426                 v2.AddArg(v3)
8427                 v1.AddArg(v2)
8428                 v0.AddArg(v1)
8429                 v.AddArg(v0)
8430                 return true
8431         }
8432 }
8433 func rewriteValuePPC64_OpRsh64x32(v *Value, config *Config) bool {
8434         b := v.Block
8435         _ = b
8436         // match: (Rsh64x32  x (Const64 [c]))
8437         // cond: uint32(c) < 64
8438         // result: (SRADconst x [c])
8439         for {
8440                 x := v.Args[0]
8441                 v_1 := v.Args[1]
8442                 if v_1.Op != OpConst64 {
8443                         break
8444                 }
8445                 c := v_1.AuxInt
8446                 if !(uint32(c) < 64) {
8447                         break
8448                 }
8449                 v.reset(OpPPC64SRADconst)
8450                 v.AuxInt = c
8451                 v.AddArg(x)
8452                 return true
8453         }
8454         // match: (Rsh64x32  x (MOVDconst [c]))
8455         // cond: uint32(c) < 64
8456         // result: (SRADconst x [c])
8457         for {
8458                 x := v.Args[0]
8459                 v_1 := v.Args[1]
8460                 if v_1.Op != OpPPC64MOVDconst {
8461                         break
8462                 }
8463                 c := v_1.AuxInt
8464                 if !(uint32(c) < 64) {
8465                         break
8466                 }
8467                 v.reset(OpPPC64SRADconst)
8468                 v.AuxInt = c
8469                 v.AddArg(x)
8470                 return true
8471         }
8472         // match: (Rsh64x32 x y)
8473         // cond:
8474         // result: (SRAD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt32to64 y)))))
8475         for {
8476                 x := v.Args[0]
8477                 y := v.Args[1]
8478                 v.reset(OpPPC64SRAD)
8479                 v.AddArg(x)
8480                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8481                 v0.AddArg(y)
8482                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8483                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8484                 v2.AuxInt = -64
8485                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64())
8486                 v3.AddArg(y)
8487                 v2.AddArg(v3)
8488                 v1.AddArg(v2)
8489                 v0.AddArg(v1)
8490                 v.AddArg(v0)
8491                 return true
8492         }
8493 }
8494 func rewriteValuePPC64_OpRsh64x64(v *Value, config *Config) bool {
8495         b := v.Block
8496         _ = b
8497         // match: (Rsh64x64  x (Const64 [c]))
8498         // cond: uint64(c) < 64
8499         // result: (SRADconst x [c])
8500         for {
8501                 x := v.Args[0]
8502                 v_1 := v.Args[1]
8503                 if v_1.Op != OpConst64 {
8504                         break
8505                 }
8506                 c := v_1.AuxInt
8507                 if !(uint64(c) < 64) {
8508                         break
8509                 }
8510                 v.reset(OpPPC64SRADconst)
8511                 v.AuxInt = c
8512                 v.AddArg(x)
8513                 return true
8514         }
8515         // match: (Rsh64x64 x (Const64 [c]))
8516         // cond: uint64(c) >= 64
8517         // result: (SRADconst x [63])
8518         for {
8519                 x := v.Args[0]
8520                 v_1 := v.Args[1]
8521                 if v_1.Op != OpConst64 {
8522                         break
8523                 }
8524                 c := v_1.AuxInt
8525                 if !(uint64(c) >= 64) {
8526                         break
8527                 }
8528                 v.reset(OpPPC64SRADconst)
8529                 v.AuxInt = 63
8530                 v.AddArg(x)
8531                 return true
8532         }
8533         // match: (Rsh64x64  x (MOVDconst [c]))
8534         // cond: uint64(c) < 64
8535         // result: (SRADconst x [c])
8536         for {
8537                 x := v.Args[0]
8538                 v_1 := v.Args[1]
8539                 if v_1.Op != OpPPC64MOVDconst {
8540                         break
8541                 }
8542                 c := v_1.AuxInt
8543                 if !(uint64(c) < 64) {
8544                         break
8545                 }
8546                 v.reset(OpPPC64SRADconst)
8547                 v.AuxInt = c
8548                 v.AddArg(x)
8549                 return true
8550         }
8551         // match: (Rsh64x64 x y)
8552         // cond:
8553         // result: (SRAD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] y))))
8554         for {
8555                 x := v.Args[0]
8556                 y := v.Args[1]
8557                 v.reset(OpPPC64SRAD)
8558                 v.AddArg(x)
8559                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8560                 v0.AddArg(y)
8561                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8562                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8563                 v2.AuxInt = -64
8564                 v2.AddArg(y)
8565                 v1.AddArg(v2)
8566                 v0.AddArg(v1)
8567                 v.AddArg(v0)
8568                 return true
8569         }
8570 }
8571 func rewriteValuePPC64_OpRsh64x8(v *Value, config *Config) bool {
8572         b := v.Block
8573         _ = b
8574         // match: (Rsh64x8 x y)
8575         // cond:
8576         // result: (SRAD x (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-64] (ZeroExt8to64 y)))))
8577         for {
8578                 x := v.Args[0]
8579                 y := v.Args[1]
8580                 v.reset(OpPPC64SRAD)
8581                 v.AddArg(x)
8582                 v0 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8583                 v0.AddArg(y)
8584                 v1 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8585                 v2 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8586                 v2.AuxInt = -64
8587                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64())
8588                 v3.AddArg(y)
8589                 v2.AddArg(v3)
8590                 v1.AddArg(v2)
8591                 v0.AddArg(v1)
8592                 v.AddArg(v0)
8593                 return true
8594         }
8595 }
8596 func rewriteValuePPC64_OpRsh8Ux16(v *Value, config *Config) bool {
8597         b := v.Block
8598         _ = b
8599         // match: (Rsh8Ux16 x y)
8600         // cond:
8601         // result: (SRW  (ZeroExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
8602         for {
8603                 x := v.Args[0]
8604                 y := v.Args[1]
8605                 v.reset(OpPPC64SRW)
8606                 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
8607                 v0.AddArg(x)
8608                 v.AddArg(v0)
8609                 v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8610                 v1.AddArg(y)
8611                 v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8612                 v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8613                 v3.AuxInt = -8
8614                 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64())
8615                 v4.AddArg(y)
8616                 v3.AddArg(v4)
8617                 v2.AddArg(v3)
8618                 v1.AddArg(v2)
8619                 v.AddArg(v1)
8620                 return true
8621         }
8622 }
8623 func rewriteValuePPC64_OpRsh8Ux32(v *Value, config *Config) bool {
8624         b := v.Block
8625         _ = b
8626         // match: (Rsh8Ux32  x (Const64 [c]))
8627         // cond: uint32(c) < 8
8628         // result: (SRWconst (ZeroExt8to32  x) [c])
8629         for {
8630                 x := v.Args[0]
8631                 v_1 := v.Args[1]
8632                 if v_1.Op != OpConst64 {
8633                         break
8634                 }
8635                 c := v_1.AuxInt
8636                 if !(uint32(c) < 8) {
8637                         break
8638                 }
8639                 v.reset(OpPPC64SRWconst)
8640                 v.AuxInt = c
8641                 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
8642                 v0.AddArg(x)
8643                 v.AddArg(v0)
8644                 return true
8645         }
8646         // match: (Rsh8Ux32  x (MOVDconst [c]))
8647         // cond: uint32(c) < 8
8648         // result: (SRWconst (ZeroExt8to32  x) [c])
8649         for {
8650                 x := v.Args[0]
8651                 v_1 := v.Args[1]
8652                 if v_1.Op != OpPPC64MOVDconst {
8653                         break
8654                 }
8655                 c := v_1.AuxInt
8656                 if !(uint32(c) < 8) {
8657                         break
8658                 }
8659                 v.reset(OpPPC64SRWconst)
8660                 v.AuxInt = c
8661                 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
8662                 v0.AddArg(x)
8663                 v.AddArg(v0)
8664                 return true
8665         }
8666         // match: (Rsh8Ux32 x y)
8667         // cond:
8668         // result: (SRW  (ZeroExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
8669         for {
8670                 x := v.Args[0]
8671                 y := v.Args[1]
8672                 v.reset(OpPPC64SRW)
8673                 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
8674                 v0.AddArg(x)
8675                 v.AddArg(v0)
8676                 v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8677                 v1.AddArg(y)
8678                 v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8679                 v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8680                 v3.AuxInt = -8
8681                 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64())
8682                 v4.AddArg(y)
8683                 v3.AddArg(v4)
8684                 v2.AddArg(v3)
8685                 v1.AddArg(v2)
8686                 v.AddArg(v1)
8687                 return true
8688         }
8689 }
8690 func rewriteValuePPC64_OpRsh8Ux64(v *Value, config *Config) bool {
8691         b := v.Block
8692         _ = b
8693         // match: (Rsh8Ux64  x (Const64 [c]))
8694         // cond: uint64(c) < 8
8695         // result: (SRWconst (ZeroExt8to32  x) [c])
8696         for {
8697                 x := v.Args[0]
8698                 v_1 := v.Args[1]
8699                 if v_1.Op != OpConst64 {
8700                         break
8701                 }
8702                 c := v_1.AuxInt
8703                 if !(uint64(c) < 8) {
8704                         break
8705                 }
8706                 v.reset(OpPPC64SRWconst)
8707                 v.AuxInt = c
8708                 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
8709                 v0.AddArg(x)
8710                 v.AddArg(v0)
8711                 return true
8712         }
8713         // match: (Rsh8Ux64  _ (Const64 [c]))
8714         // cond: uint64(c) >= 8
8715         // result: (MOVDconst [0])
8716         for {
8717                 v_1 := v.Args[1]
8718                 if v_1.Op != OpConst64 {
8719                         break
8720                 }
8721                 c := v_1.AuxInt
8722                 if !(uint64(c) >= 8) {
8723                         break
8724                 }
8725                 v.reset(OpPPC64MOVDconst)
8726                 v.AuxInt = 0
8727                 return true
8728         }
8729         // match: (Rsh8Ux64  x (MOVDconst [c]))
8730         // cond: uint64(c) < 8
8731         // result: (SRWconst (ZeroExt8to32  x) [c])
8732         for {
8733                 x := v.Args[0]
8734                 v_1 := v.Args[1]
8735                 if v_1.Op != OpPPC64MOVDconst {
8736                         break
8737                 }
8738                 c := v_1.AuxInt
8739                 if !(uint64(c) < 8) {
8740                         break
8741                 }
8742                 v.reset(OpPPC64SRWconst)
8743                 v.AuxInt = c
8744                 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
8745                 v0.AddArg(x)
8746                 v.AddArg(v0)
8747                 return true
8748         }
8749         // match: (Rsh8Ux64 x y)
8750         // cond:
8751         // result: (SRW  (ZeroExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
8752         for {
8753                 x := v.Args[0]
8754                 y := v.Args[1]
8755                 v.reset(OpPPC64SRW)
8756                 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
8757                 v0.AddArg(x)
8758                 v.AddArg(v0)
8759                 v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8760                 v1.AddArg(y)
8761                 v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8762                 v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8763                 v3.AuxInt = -8
8764                 v3.AddArg(y)
8765                 v2.AddArg(v3)
8766                 v1.AddArg(v2)
8767                 v.AddArg(v1)
8768                 return true
8769         }
8770 }
8771 func rewriteValuePPC64_OpRsh8Ux8(v *Value, config *Config) bool {
8772         b := v.Block
8773         _ = b
8774         // match: (Rsh8Ux8 x y)
8775         // cond:
8776         // result: (SRW  (ZeroExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
8777         for {
8778                 x := v.Args[0]
8779                 y := v.Args[1]
8780                 v.reset(OpPPC64SRW)
8781                 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, config.fe.TypeUInt32())
8782                 v0.AddArg(x)
8783                 v.AddArg(v0)
8784                 v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8785                 v1.AddArg(y)
8786                 v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8787                 v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8788                 v3.AuxInt = -8
8789                 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64())
8790                 v4.AddArg(y)
8791                 v3.AddArg(v4)
8792                 v2.AddArg(v3)
8793                 v1.AddArg(v2)
8794                 v.AddArg(v1)
8795                 return true
8796         }
8797 }
8798 func rewriteValuePPC64_OpRsh8x16(v *Value, config *Config) bool {
8799         b := v.Block
8800         _ = b
8801         // match: (Rsh8x16 x y)
8802         // cond:
8803         // result: (SRAW (SignExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt16to64 y)))))
8804         for {
8805                 x := v.Args[0]
8806                 y := v.Args[1]
8807                 v.reset(OpPPC64SRAW)
8808                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
8809                 v0.AddArg(x)
8810                 v.AddArg(v0)
8811                 v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8812                 v1.AddArg(y)
8813                 v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8814                 v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8815                 v3.AuxInt = -8
8816                 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, config.fe.TypeUInt64())
8817                 v4.AddArg(y)
8818                 v3.AddArg(v4)
8819                 v2.AddArg(v3)
8820                 v1.AddArg(v2)
8821                 v.AddArg(v1)
8822                 return true
8823         }
8824 }
8825 func rewriteValuePPC64_OpRsh8x32(v *Value, config *Config) bool {
8826         b := v.Block
8827         _ = b
8828         // match: (Rsh8x32   x (Const64 [c]))
8829         // cond: uint32(c) < 8
8830         // result: (SRAWconst (SignExt8to32  x) [c])
8831         for {
8832                 x := v.Args[0]
8833                 v_1 := v.Args[1]
8834                 if v_1.Op != OpConst64 {
8835                         break
8836                 }
8837                 c := v_1.AuxInt
8838                 if !(uint32(c) < 8) {
8839                         break
8840                 }
8841                 v.reset(OpPPC64SRAWconst)
8842                 v.AuxInt = c
8843                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
8844                 v0.AddArg(x)
8845                 v.AddArg(v0)
8846                 return true
8847         }
8848         // match: (Rsh8x32   x (MOVDconst [c]))
8849         // cond: uint32(c) < 8
8850         // result: (SRAWconst (SignExt8to32  x) [c])
8851         for {
8852                 x := v.Args[0]
8853                 v_1 := v.Args[1]
8854                 if v_1.Op != OpPPC64MOVDconst {
8855                         break
8856                 }
8857                 c := v_1.AuxInt
8858                 if !(uint32(c) < 8) {
8859                         break
8860                 }
8861                 v.reset(OpPPC64SRAWconst)
8862                 v.AuxInt = c
8863                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
8864                 v0.AddArg(x)
8865                 v.AddArg(v0)
8866                 return true
8867         }
8868         // match: (Rsh8x32 x y)
8869         // cond:
8870         // result: (SRAW (SignExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt32to64 y)))))
8871         for {
8872                 x := v.Args[0]
8873                 y := v.Args[1]
8874                 v.reset(OpPPC64SRAW)
8875                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
8876                 v0.AddArg(x)
8877                 v.AddArg(v0)
8878                 v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8879                 v1.AddArg(y)
8880                 v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8881                 v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8882                 v3.AuxInt = -8
8883                 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, config.fe.TypeUInt64())
8884                 v4.AddArg(y)
8885                 v3.AddArg(v4)
8886                 v2.AddArg(v3)
8887                 v1.AddArg(v2)
8888                 v.AddArg(v1)
8889                 return true
8890         }
8891 }
8892 func rewriteValuePPC64_OpRsh8x64(v *Value, config *Config) bool {
8893         b := v.Block
8894         _ = b
8895         // match: (Rsh8x64   x (Const64 [c]))
8896         // cond: uint64(c) < 8
8897         // result: (SRAWconst (SignExt8to32  x) [c])
8898         for {
8899                 x := v.Args[0]
8900                 v_1 := v.Args[1]
8901                 if v_1.Op != OpConst64 {
8902                         break
8903                 }
8904                 c := v_1.AuxInt
8905                 if !(uint64(c) < 8) {
8906                         break
8907                 }
8908                 v.reset(OpPPC64SRAWconst)
8909                 v.AuxInt = c
8910                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
8911                 v0.AddArg(x)
8912                 v.AddArg(v0)
8913                 return true
8914         }
8915         // match: (Rsh8x64  x (Const64 [c]))
8916         // cond: uint64(c) >= 8
8917         // result: (SRAWconst (SignExt8to32  x) [63])
8918         for {
8919                 x := v.Args[0]
8920                 v_1 := v.Args[1]
8921                 if v_1.Op != OpConst64 {
8922                         break
8923                 }
8924                 c := v_1.AuxInt
8925                 if !(uint64(c) >= 8) {
8926                         break
8927                 }
8928                 v.reset(OpPPC64SRAWconst)
8929                 v.AuxInt = 63
8930                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
8931                 v0.AddArg(x)
8932                 v.AddArg(v0)
8933                 return true
8934         }
8935         // match: (Rsh8x64   x (MOVDconst [c]))
8936         // cond: uint64(c) < 8
8937         // result: (SRAWconst (SignExt8to32  x) [c])
8938         for {
8939                 x := v.Args[0]
8940                 v_1 := v.Args[1]
8941                 if v_1.Op != OpPPC64MOVDconst {
8942                         break
8943                 }
8944                 c := v_1.AuxInt
8945                 if !(uint64(c) < 8) {
8946                         break
8947                 }
8948                 v.reset(OpPPC64SRAWconst)
8949                 v.AuxInt = c
8950                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
8951                 v0.AddArg(x)
8952                 v.AddArg(v0)
8953                 return true
8954         }
8955         // match: (Rsh8x64 x y)
8956         // cond:
8957         // result: (SRAW (SignExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] y))))
8958         for {
8959                 x := v.Args[0]
8960                 y := v.Args[1]
8961                 v.reset(OpPPC64SRAW)
8962                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
8963                 v0.AddArg(x)
8964                 v.AddArg(v0)
8965                 v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8966                 v1.AddArg(y)
8967                 v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8968                 v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8969                 v3.AuxInt = -8
8970                 v3.AddArg(y)
8971                 v2.AddArg(v3)
8972                 v1.AddArg(v2)
8973                 v.AddArg(v1)
8974                 return true
8975         }
8976 }
8977 func rewriteValuePPC64_OpRsh8x8(v *Value, config *Config) bool {
8978         b := v.Block
8979         _ = b
8980         // match: (Rsh8x8 x y)
8981         // cond:
8982         // result: (SRAW (SignExt8to32 x) (ORN y <config.fe.TypeInt64()> (MaskIfNotCarry (ADDconstForCarry [-8] (ZeroExt8to64 y)))))
8983         for {
8984                 x := v.Args[0]
8985                 y := v.Args[1]
8986                 v.reset(OpPPC64SRAW)
8987                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, config.fe.TypeInt32())
8988                 v0.AddArg(x)
8989                 v.AddArg(v0)
8990                 v1 := b.NewValue0(v.Pos, OpPPC64ORN, config.fe.TypeInt64())
8991                 v1.AddArg(y)
8992                 v2 := b.NewValue0(v.Pos, OpPPC64MaskIfNotCarry, config.fe.TypeInt64())
8993                 v3 := b.NewValue0(v.Pos, OpPPC64ADDconstForCarry, TypeFlags)
8994                 v3.AuxInt = -8
8995                 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, config.fe.TypeUInt64())
8996                 v4.AddArg(y)
8997                 v3.AddArg(v4)
8998                 v2.AddArg(v3)
8999                 v1.AddArg(v2)
9000                 v.AddArg(v1)
9001                 return true
9002         }
9003 }
9004 func rewriteValuePPC64_OpSignExt16to32(v *Value, config *Config) bool {
9005         b := v.Block
9006         _ = b
9007         // match: (SignExt16to32 x)
9008         // cond:
9009         // result: (MOVHreg x)
9010         for {
9011                 x := v.Args[0]
9012                 v.reset(OpPPC64MOVHreg)
9013                 v.AddArg(x)
9014                 return true
9015         }
9016 }
9017 func rewriteValuePPC64_OpSignExt16to64(v *Value, config *Config) bool {
9018         b := v.Block
9019         _ = b
9020         // match: (SignExt16to64 x)
9021         // cond:
9022         // result: (MOVHreg x)
9023         for {
9024                 x := v.Args[0]
9025                 v.reset(OpPPC64MOVHreg)
9026                 v.AddArg(x)
9027                 return true
9028         }
9029 }
9030 func rewriteValuePPC64_OpSignExt32to64(v *Value, config *Config) bool {
9031         b := v.Block
9032         _ = b
9033         // match: (SignExt32to64 x)
9034         // cond:
9035         // result: (MOVWreg x)
9036         for {
9037                 x := v.Args[0]
9038                 v.reset(OpPPC64MOVWreg)
9039                 v.AddArg(x)
9040                 return true
9041         }
9042 }
9043 func rewriteValuePPC64_OpSignExt8to16(v *Value, config *Config) bool {
9044         b := v.Block
9045         _ = b
9046         // match: (SignExt8to16  x)
9047         // cond:
9048         // result: (MOVBreg x)
9049         for {
9050                 x := v.Args[0]
9051                 v.reset(OpPPC64MOVBreg)
9052                 v.AddArg(x)
9053                 return true
9054         }
9055 }
9056 func rewriteValuePPC64_OpSignExt8to32(v *Value, config *Config) bool {
9057         b := v.Block
9058         _ = b
9059         // match: (SignExt8to32  x)
9060         // cond:
9061         // result: (MOVBreg x)
9062         for {
9063                 x := v.Args[0]
9064                 v.reset(OpPPC64MOVBreg)
9065                 v.AddArg(x)
9066                 return true
9067         }
9068 }
9069 func rewriteValuePPC64_OpSignExt8to64(v *Value, config *Config) bool {
9070         b := v.Block
9071         _ = b
9072         // match: (SignExt8to64  x)
9073         // cond:
9074         // result: (MOVBreg x)
9075         for {
9076                 x := v.Args[0]
9077                 v.reset(OpPPC64MOVBreg)
9078                 v.AddArg(x)
9079                 return true
9080         }
9081 }
9082 func rewriteValuePPC64_OpSlicemask(v *Value, config *Config) bool {
9083         b := v.Block
9084         _ = b
9085         // match: (Slicemask <t> x)
9086         // cond:
9087         // result: (XORconst [-1] (SRADconst <t> (ADDconst <t> x [-1]) [63]))
9088         for {
9089                 t := v.Type
9090                 x := v.Args[0]
9091                 v.reset(OpPPC64XORconst)
9092                 v.AuxInt = -1
9093                 v0 := b.NewValue0(v.Pos, OpPPC64SRADconst, t)
9094                 v0.AuxInt = 63
9095                 v1 := b.NewValue0(v.Pos, OpPPC64ADDconst, t)
9096                 v1.AuxInt = -1
9097                 v1.AddArg(x)
9098                 v0.AddArg(v1)
9099                 v.AddArg(v0)
9100                 return true
9101         }
9102 }
9103 func rewriteValuePPC64_OpSqrt(v *Value, config *Config) bool {
9104         b := v.Block
9105         _ = b
9106         // match: (Sqrt x)
9107         // cond:
9108         // result: (FSQRT x)
9109         for {
9110                 x := v.Args[0]
9111                 v.reset(OpPPC64FSQRT)
9112                 v.AddArg(x)
9113                 return true
9114         }
9115 }
9116 func rewriteValuePPC64_OpStaticCall(v *Value, config *Config) bool {
9117         b := v.Block
9118         _ = b
9119         // match: (StaticCall [argwid] {target} mem)
9120         // cond:
9121         // result: (CALLstatic [argwid] {target} mem)
9122         for {
9123                 argwid := v.AuxInt
9124                 target := v.Aux
9125                 mem := v.Args[0]
9126                 v.reset(OpPPC64CALLstatic)
9127                 v.AuxInt = argwid
9128                 v.Aux = target
9129                 v.AddArg(mem)
9130                 return true
9131         }
9132 }
9133 func rewriteValuePPC64_OpStore(v *Value, config *Config) bool {
9134         b := v.Block
9135         _ = b
9136         // match: (Store [8] ptr val mem)
9137         // cond: is64BitFloat(val.Type)
9138         // result: (FMOVDstore ptr val mem)
9139         for {
9140                 if v.AuxInt != 8 {
9141                         break
9142                 }
9143                 ptr := v.Args[0]
9144                 val := v.Args[1]
9145                 mem := v.Args[2]
9146                 if !(is64BitFloat(val.Type)) {
9147                         break
9148                 }
9149                 v.reset(OpPPC64FMOVDstore)
9150                 v.AddArg(ptr)
9151                 v.AddArg(val)
9152                 v.AddArg(mem)
9153                 return true
9154         }
9155         // match: (Store [8] ptr val mem)
9156         // cond: is32BitFloat(val.Type)
9157         // result: (FMOVDstore ptr val mem)
9158         for {
9159                 if v.AuxInt != 8 {
9160                         break
9161                 }
9162                 ptr := v.Args[0]
9163                 val := v.Args[1]
9164                 mem := v.Args[2]
9165                 if !(is32BitFloat(val.Type)) {
9166                         break
9167                 }
9168                 v.reset(OpPPC64FMOVDstore)
9169                 v.AddArg(ptr)
9170                 v.AddArg(val)
9171                 v.AddArg(mem)
9172                 return true
9173         }
9174         // match: (Store [4] ptr val mem)
9175         // cond: is32BitFloat(val.Type)
9176         // result: (FMOVSstore ptr val mem)
9177         for {
9178                 if v.AuxInt != 4 {
9179                         break
9180                 }
9181                 ptr := v.Args[0]
9182                 val := v.Args[1]
9183                 mem := v.Args[2]
9184                 if !(is32BitFloat(val.Type)) {
9185                         break
9186                 }
9187                 v.reset(OpPPC64FMOVSstore)
9188                 v.AddArg(ptr)
9189                 v.AddArg(val)
9190                 v.AddArg(mem)
9191                 return true
9192         }
9193         // match: (Store [8] ptr val mem)
9194         // cond: (is64BitInt(val.Type) || isPtr(val.Type))
9195         // result: (MOVDstore ptr val mem)
9196         for {
9197                 if v.AuxInt != 8 {
9198                         break
9199                 }
9200                 ptr := v.Args[0]
9201                 val := v.Args[1]
9202                 mem := v.Args[2]
9203                 if !(is64BitInt(val.Type) || isPtr(val.Type)) {
9204                         break
9205                 }
9206                 v.reset(OpPPC64MOVDstore)
9207                 v.AddArg(ptr)
9208                 v.AddArg(val)
9209                 v.AddArg(mem)
9210                 return true
9211         }
9212         // match: (Store [4] ptr val mem)
9213         // cond: is32BitInt(val.Type)
9214         // result: (MOVWstore ptr val mem)
9215         for {
9216                 if v.AuxInt != 4 {
9217                         break
9218                 }
9219                 ptr := v.Args[0]
9220                 val := v.Args[1]
9221                 mem := v.Args[2]
9222                 if !(is32BitInt(val.Type)) {
9223                         break
9224                 }
9225                 v.reset(OpPPC64MOVWstore)
9226                 v.AddArg(ptr)
9227                 v.AddArg(val)
9228                 v.AddArg(mem)
9229                 return true
9230         }
9231         // match: (Store [2] ptr val mem)
9232         // cond:
9233         // result: (MOVHstore ptr val mem)
9234         for {
9235                 if v.AuxInt != 2 {
9236                         break
9237                 }
9238                 ptr := v.Args[0]
9239                 val := v.Args[1]
9240                 mem := v.Args[2]
9241                 v.reset(OpPPC64MOVHstore)
9242                 v.AddArg(ptr)
9243                 v.AddArg(val)
9244                 v.AddArg(mem)
9245                 return true
9246         }
9247         // match: (Store [1] ptr val mem)
9248         // cond:
9249         // result: (MOVBstore ptr val mem)
9250         for {
9251                 if v.AuxInt != 1 {
9252                         break
9253                 }
9254                 ptr := v.Args[0]
9255                 val := v.Args[1]
9256                 mem := v.Args[2]
9257                 v.reset(OpPPC64MOVBstore)
9258                 v.AddArg(ptr)
9259                 v.AddArg(val)
9260                 v.AddArg(mem)
9261                 return true
9262         }
9263         return false
9264 }
9265 func rewriteValuePPC64_OpSub16(v *Value, config *Config) bool {
9266         b := v.Block
9267         _ = b
9268         // match: (Sub16  x y)
9269         // cond:
9270         // result: (SUB x y)
9271         for {
9272                 x := v.Args[0]
9273                 y := v.Args[1]
9274                 v.reset(OpPPC64SUB)
9275                 v.AddArg(x)
9276                 v.AddArg(y)
9277                 return true
9278         }
9279 }
9280 func rewriteValuePPC64_OpSub32(v *Value, config *Config) bool {
9281         b := v.Block
9282         _ = b
9283         // match: (Sub32  x y)
9284         // cond:
9285         // result: (SUB x y)
9286         for {
9287                 x := v.Args[0]
9288                 y := v.Args[1]
9289                 v.reset(OpPPC64SUB)
9290                 v.AddArg(x)
9291                 v.AddArg(y)
9292                 return true
9293         }
9294 }
9295 func rewriteValuePPC64_OpSub32F(v *Value, config *Config) bool {
9296         b := v.Block
9297         _ = b
9298         // match: (Sub32F x y)
9299         // cond:
9300         // result: (FSUBS x y)
9301         for {
9302                 x := v.Args[0]
9303                 y := v.Args[1]
9304                 v.reset(OpPPC64FSUBS)
9305                 v.AddArg(x)
9306                 v.AddArg(y)
9307                 return true
9308         }
9309 }
9310 func rewriteValuePPC64_OpSub64(v *Value, config *Config) bool {
9311         b := v.Block
9312         _ = b
9313         // match: (Sub64  x y)
9314         // cond:
9315         // result: (SUB  x y)
9316         for {
9317                 x := v.Args[0]
9318                 y := v.Args[1]
9319                 v.reset(OpPPC64SUB)
9320                 v.AddArg(x)
9321                 v.AddArg(y)
9322                 return true
9323         }
9324 }
9325 func rewriteValuePPC64_OpSub64F(v *Value, config *Config) bool {
9326         b := v.Block
9327         _ = b
9328         // match: (Sub64F x y)
9329         // cond:
9330         // result: (FSUB x y)
9331         for {
9332                 x := v.Args[0]
9333                 y := v.Args[1]
9334                 v.reset(OpPPC64FSUB)
9335                 v.AddArg(x)
9336                 v.AddArg(y)
9337                 return true
9338         }
9339 }
9340 func rewriteValuePPC64_OpSub8(v *Value, config *Config) bool {
9341         b := v.Block
9342         _ = b
9343         // match: (Sub8   x y)
9344         // cond:
9345         // result: (SUB x y)
9346         for {
9347                 x := v.Args[0]
9348                 y := v.Args[1]
9349                 v.reset(OpPPC64SUB)
9350                 v.AddArg(x)
9351                 v.AddArg(y)
9352                 return true
9353         }
9354 }
9355 func rewriteValuePPC64_OpSubPtr(v *Value, config *Config) bool {
9356         b := v.Block
9357         _ = b
9358         // match: (SubPtr x y)
9359         // cond:
9360         // result: (SUB  x y)
9361         for {
9362                 x := v.Args[0]
9363                 y := v.Args[1]
9364                 v.reset(OpPPC64SUB)
9365                 v.AddArg(x)
9366                 v.AddArg(y)
9367                 return true
9368         }
9369 }
9370 func rewriteValuePPC64_OpTrunc16to8(v *Value, config *Config) bool {
9371         b := v.Block
9372         _ = b
9373         // match: (Trunc16to8  x)
9374         // cond:
9375         // result: (MOVBreg x)
9376         for {
9377                 x := v.Args[0]
9378                 v.reset(OpPPC64MOVBreg)
9379                 v.AddArg(x)
9380                 return true
9381         }
9382 }
9383 func rewriteValuePPC64_OpTrunc32to16(v *Value, config *Config) bool {
9384         b := v.Block
9385         _ = b
9386         // match: (Trunc32to16 x)
9387         // cond:
9388         // result: (MOVHreg x)
9389         for {
9390                 x := v.Args[0]
9391                 v.reset(OpPPC64MOVHreg)
9392                 v.AddArg(x)
9393                 return true
9394         }
9395 }
9396 func rewriteValuePPC64_OpTrunc32to8(v *Value, config *Config) bool {
9397         b := v.Block
9398         _ = b
9399         // match: (Trunc32to8  x)
9400         // cond:
9401         // result: (MOVBreg x)
9402         for {
9403                 x := v.Args[0]
9404                 v.reset(OpPPC64MOVBreg)
9405                 v.AddArg(x)
9406                 return true
9407         }
9408 }
9409 func rewriteValuePPC64_OpTrunc64to16(v *Value, config *Config) bool {
9410         b := v.Block
9411         _ = b
9412         // match: (Trunc64to16 x)
9413         // cond:
9414         // result: (MOVHreg x)
9415         for {
9416                 x := v.Args[0]
9417                 v.reset(OpPPC64MOVHreg)
9418                 v.AddArg(x)
9419                 return true
9420         }
9421 }
9422 func rewriteValuePPC64_OpTrunc64to32(v *Value, config *Config) bool {
9423         b := v.Block
9424         _ = b
9425         // match: (Trunc64to32 x)
9426         // cond:
9427         // result: (MOVWreg x)
9428         for {
9429                 x := v.Args[0]
9430                 v.reset(OpPPC64MOVWreg)
9431                 v.AddArg(x)
9432                 return true
9433         }
9434 }
9435 func rewriteValuePPC64_OpTrunc64to8(v *Value, config *Config) bool {
9436         b := v.Block
9437         _ = b
9438         // match: (Trunc64to8  x)
9439         // cond:
9440         // result: (MOVBreg x)
9441         for {
9442                 x := v.Args[0]
9443                 v.reset(OpPPC64MOVBreg)
9444                 v.AddArg(x)
9445                 return true
9446         }
9447 }
9448 func rewriteValuePPC64_OpXor16(v *Value, config *Config) bool {
9449         b := v.Block
9450         _ = b
9451         // match: (Xor16 x y)
9452         // cond:
9453         // result: (XOR x y)
9454         for {
9455                 x := v.Args[0]
9456                 y := v.Args[1]
9457                 v.reset(OpPPC64XOR)
9458                 v.AddArg(x)
9459                 v.AddArg(y)
9460                 return true
9461         }
9462 }
9463 func rewriteValuePPC64_OpXor32(v *Value, config *Config) bool {
9464         b := v.Block
9465         _ = b
9466         // match: (Xor32 x y)
9467         // cond:
9468         // result: (XOR x y)
9469         for {
9470                 x := v.Args[0]
9471                 y := v.Args[1]
9472                 v.reset(OpPPC64XOR)
9473                 v.AddArg(x)
9474                 v.AddArg(y)
9475                 return true
9476         }
9477 }
9478 func rewriteValuePPC64_OpXor64(v *Value, config *Config) bool {
9479         b := v.Block
9480         _ = b
9481         // match: (Xor64 x y)
9482         // cond:
9483         // result: (XOR x y)
9484         for {
9485                 x := v.Args[0]
9486                 y := v.Args[1]
9487                 v.reset(OpPPC64XOR)
9488                 v.AddArg(x)
9489                 v.AddArg(y)
9490                 return true
9491         }
9492 }
9493 func rewriteValuePPC64_OpXor8(v *Value, config *Config) bool {
9494         b := v.Block
9495         _ = b
9496         // match: (Xor8  x y)
9497         // cond:
9498         // result: (XOR x y)
9499         for {
9500                 x := v.Args[0]
9501                 y := v.Args[1]
9502                 v.reset(OpPPC64XOR)
9503                 v.AddArg(x)
9504                 v.AddArg(y)
9505                 return true
9506         }
9507 }
9508 func rewriteValuePPC64_OpZero(v *Value, config *Config) bool {
9509         b := v.Block
9510         _ = b
9511         // match: (Zero [s] _ mem)
9512         // cond: SizeAndAlign(s).Size() == 0
9513         // result: mem
9514         for {
9515                 s := v.AuxInt
9516                 mem := v.Args[1]
9517                 if !(SizeAndAlign(s).Size() == 0) {
9518                         break
9519                 }
9520                 v.reset(OpCopy)
9521                 v.Type = mem.Type
9522                 v.AddArg(mem)
9523                 return true
9524         }
9525         // match: (Zero [s] destptr mem)
9526         // cond: SizeAndAlign(s).Size() == 1
9527         // result: (MOVBstorezero destptr mem)
9528         for {
9529                 s := v.AuxInt
9530                 destptr := v.Args[0]
9531                 mem := v.Args[1]
9532                 if !(SizeAndAlign(s).Size() == 1) {
9533                         break
9534                 }
9535                 v.reset(OpPPC64MOVBstorezero)
9536                 v.AddArg(destptr)
9537                 v.AddArg(mem)
9538                 return true
9539         }
9540         // match: (Zero [s] destptr mem)
9541         // cond: SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0
9542         // result: (MOVHstorezero destptr mem)
9543         for {
9544                 s := v.AuxInt
9545                 destptr := v.Args[0]
9546                 mem := v.Args[1]
9547                 if !(SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0) {
9548                         break
9549                 }
9550                 v.reset(OpPPC64MOVHstorezero)
9551                 v.AddArg(destptr)
9552                 v.AddArg(mem)
9553                 return true
9554         }
9555         // match: (Zero [s] destptr mem)
9556         // cond: SizeAndAlign(s).Size() == 2
9557         // result: (MOVBstorezero [1] destptr           (MOVBstorezero [0] destptr mem))
9558         for {
9559                 s := v.AuxInt
9560                 destptr := v.Args[0]
9561                 mem := v.Args[1]
9562                 if !(SizeAndAlign(s).Size() == 2) {
9563                         break
9564                 }
9565                 v.reset(OpPPC64MOVBstorezero)
9566                 v.AuxInt = 1
9567                 v.AddArg(destptr)
9568                 v0 := b.NewValue0(v.Pos, OpPPC64MOVBstorezero, TypeMem)
9569                 v0.AuxInt = 0
9570                 v0.AddArg(destptr)
9571                 v0.AddArg(mem)
9572                 v.AddArg(v0)
9573                 return true
9574         }
9575         // match: (Zero [s] destptr mem)
9576         // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0
9577         // result: (MOVWstorezero destptr mem)
9578         for {
9579                 s := v.AuxInt
9580                 destptr := v.Args[0]
9581                 mem := v.Args[1]
9582                 if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0) {
9583                         break
9584                 }
9585                 v.reset(OpPPC64MOVWstorezero)
9586                 v.AddArg(destptr)
9587                 v.AddArg(mem)
9588                 return true
9589         }
9590         // match: (Zero [s] destptr mem)
9591         // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0
9592         // result: (MOVHstorezero [2] destptr           (MOVHstorezero [0] destptr mem))
9593         for {
9594                 s := v.AuxInt
9595                 destptr := v.Args[0]
9596                 mem := v.Args[1]
9597                 if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0) {
9598                         break
9599                 }
9600                 v.reset(OpPPC64MOVHstorezero)
9601                 v.AuxInt = 2
9602                 v.AddArg(destptr)
9603                 v0 := b.NewValue0(v.Pos, OpPPC64MOVHstorezero, TypeMem)
9604                 v0.AuxInt = 0
9605                 v0.AddArg(destptr)
9606                 v0.AddArg(mem)
9607                 v.AddArg(v0)
9608                 return true
9609         }
9610         // match: (Zero [s] destptr mem)
9611         // cond: SizeAndAlign(s).Size() == 4
9612         // result: (MOVBstorezero [3] destptr           (MOVBstorezero [2] destptr                      (MOVBstorezero [1] destptr                              (MOVBstorezero [0] destptr mem))))
9613         for {
9614                 s := v.AuxInt
9615                 destptr := v.Args[0]
9616                 mem := v.Args[1]
9617                 if !(SizeAndAlign(s).Size() == 4) {
9618                         break
9619                 }
9620                 v.reset(OpPPC64MOVBstorezero)
9621                 v.AuxInt = 3
9622                 v.AddArg(destptr)
9623                 v0 := b.NewValue0(v.Pos, OpPPC64MOVBstorezero, TypeMem)
9624                 v0.AuxInt = 2
9625                 v0.AddArg(destptr)
9626                 v1 := b.NewValue0(v.Pos, OpPPC64MOVBstorezero, TypeMem)
9627                 v1.AuxInt = 1
9628                 v1.AddArg(destptr)
9629                 v2 := b.NewValue0(v.Pos, OpPPC64MOVBstorezero, TypeMem)
9630                 v2.AuxInt = 0
9631                 v2.AddArg(destptr)
9632                 v2.AddArg(mem)
9633                 v1.AddArg(v2)
9634                 v0.AddArg(v1)
9635                 v.AddArg(v0)
9636                 return true
9637         }
9638         // match: (Zero [s] destptr mem)
9639         // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0
9640         // result: (MOVDstorezero [0] destptr mem)
9641         for {
9642                 s := v.AuxInt
9643                 destptr := v.Args[0]
9644                 mem := v.Args[1]
9645                 if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%8 == 0) {
9646                         break
9647                 }
9648                 v.reset(OpPPC64MOVDstorezero)
9649                 v.AuxInt = 0
9650                 v.AddArg(destptr)
9651                 v.AddArg(mem)
9652                 return true
9653         }
9654         // match: (Zero [s] destptr mem)
9655         // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0
9656         // result: (MOVWstorezero [4] destptr           (MOVWstorezero [0] destptr mem))
9657         for {
9658                 s := v.AuxInt
9659                 destptr := v.Args[0]
9660                 mem := v.Args[1]
9661                 if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%4 == 0) {
9662                         break
9663                 }
9664                 v.reset(OpPPC64MOVWstorezero)
9665                 v.AuxInt = 4
9666                 v.AddArg(destptr)
9667                 v0 := b.NewValue0(v.Pos, OpPPC64MOVWstorezero, TypeMem)
9668                 v0.AuxInt = 0
9669                 v0.AddArg(destptr)
9670                 v0.AddArg(mem)
9671                 v.AddArg(v0)
9672                 return true
9673         }
9674         // match: (Zero [s] destptr mem)
9675         // cond: SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0
9676         // result: (MOVHstorezero [6] destptr           (MOVHstorezero [4] destptr                      (MOVHstorezero [2] destptr                              (MOVHstorezero [0] destptr mem))))
9677         for {
9678                 s := v.AuxInt
9679                 destptr := v.Args[0]
9680                 mem := v.Args[1]
9681                 if !(SizeAndAlign(s).Size() == 8 && SizeAndAlign(s).Align()%2 == 0) {
9682                         break
9683                 }
9684                 v.reset(OpPPC64MOVHstorezero)
9685                 v.AuxInt = 6
9686                 v.AddArg(destptr)
9687                 v0 := b.NewValue0(v.Pos, OpPPC64MOVHstorezero, TypeMem)
9688                 v0.AuxInt = 4
9689                 v0.AddArg(destptr)
9690                 v1 := b.NewValue0(v.Pos, OpPPC64MOVHstorezero, TypeMem)
9691                 v1.AuxInt = 2
9692                 v1.AddArg(destptr)
9693                 v2 := b.NewValue0(v.Pos, OpPPC64MOVHstorezero, TypeMem)
9694                 v2.AuxInt = 0
9695                 v2.AddArg(destptr)
9696                 v2.AddArg(mem)
9697                 v1.AddArg(v2)
9698                 v0.AddArg(v1)
9699                 v.AddArg(v0)
9700                 return true
9701         }
9702         // match: (Zero [s] destptr mem)
9703         // cond: SizeAndAlign(s).Size() == 3
9704         // result: (MOVBstorezero [2] destptr           (MOVBstorezero [1] destptr                      (MOVBstorezero [0] destptr mem)))
9705         for {
9706                 s := v.AuxInt
9707                 destptr := v.Args[0]
9708                 mem := v.Args[1]
9709                 if !(SizeAndAlign(s).Size() == 3) {
9710                         break
9711                 }
9712                 v.reset(OpPPC64MOVBstorezero)
9713                 v.AuxInt = 2
9714                 v.AddArg(destptr)
9715                 v0 := b.NewValue0(v.Pos, OpPPC64MOVBstorezero, TypeMem)
9716                 v0.AuxInt = 1
9717                 v0.AddArg(destptr)
9718                 v1 := b.NewValue0(v.Pos, OpPPC64MOVBstorezero, TypeMem)
9719                 v1.AuxInt = 0
9720                 v1.AddArg(destptr)
9721                 v1.AddArg(mem)
9722                 v0.AddArg(v1)
9723                 v.AddArg(v0)
9724                 return true
9725         }
9726         // match: (Zero [s] destptr mem)
9727         // cond: SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%8 == 0
9728         // result: (MOVDstorezero [8] destptr                 (MOVDstorezero [0] destptr mem))
9729         for {
9730                 s := v.AuxInt
9731                 destptr := v.Args[0]
9732                 mem := v.Args[1]
9733                 if !(SizeAndAlign(s).Size() == 16 && SizeAndAlign(s).Align()%8 == 0) {
9734                         break
9735                 }
9736                 v.reset(OpPPC64MOVDstorezero)
9737                 v.AuxInt = 8
9738                 v.AddArg(destptr)
9739                 v0 := b.NewValue0(v.Pos, OpPPC64MOVDstorezero, TypeMem)
9740                 v0.AuxInt = 0
9741                 v0.AddArg(destptr)
9742                 v0.AddArg(mem)
9743                 v.AddArg(v0)
9744                 return true
9745         }
9746         // match: (Zero [s] destptr mem)
9747         // cond: SizeAndAlign(s).Size() == 24 && SizeAndAlign(s).Align()%8 == 0
9748         // result: (MOVDstorezero [16] destptr          (MOVDstorezero [8] destptr                      (MOVDstorezero [0] destptr mem)))
9749         for {
9750                 s := v.AuxInt
9751                 destptr := v.Args[0]
9752                 mem := v.Args[1]
9753                 if !(SizeAndAlign(s).Size() == 24 && SizeAndAlign(s).Align()%8 == 0) {
9754                         break
9755                 }
9756                 v.reset(OpPPC64MOVDstorezero)
9757                 v.AuxInt = 16
9758                 v.AddArg(destptr)
9759                 v0 := b.NewValue0(v.Pos, OpPPC64MOVDstorezero, TypeMem)
9760                 v0.AuxInt = 8
9761                 v0.AddArg(destptr)
9762                 v1 := b.NewValue0(v.Pos, OpPPC64MOVDstorezero, TypeMem)
9763                 v1.AuxInt = 0
9764                 v1.AddArg(destptr)
9765                 v1.AddArg(mem)
9766                 v0.AddArg(v1)
9767                 v.AddArg(v0)
9768                 return true
9769         }
9770         // match: (Zero [s] destptr mem)
9771         // cond: SizeAndAlign(s).Size() == 32 && SizeAndAlign(s).Align()%8 == 0
9772         // result: (MOVDstorezero [24] destptr          (MOVDstorezero [16] destptr                     (MOVDstorezero [8] destptr                              (MOVDstorezero [0] destptr mem))))
9773         for {
9774                 s := v.AuxInt
9775                 destptr := v.Args[0]
9776                 mem := v.Args[1]
9777                 if !(SizeAndAlign(s).Size() == 32 && SizeAndAlign(s).Align()%8 == 0) {
9778                         break
9779                 }
9780                 v.reset(OpPPC64MOVDstorezero)
9781                 v.AuxInt = 24
9782                 v.AddArg(destptr)
9783                 v0 := b.NewValue0(v.Pos, OpPPC64MOVDstorezero, TypeMem)
9784                 v0.AuxInt = 16
9785                 v0.AddArg(destptr)
9786                 v1 := b.NewValue0(v.Pos, OpPPC64MOVDstorezero, TypeMem)
9787                 v1.AuxInt = 8
9788                 v1.AddArg(destptr)
9789                 v2 := b.NewValue0(v.Pos, OpPPC64MOVDstorezero, TypeMem)
9790                 v2.AuxInt = 0
9791                 v2.AddArg(destptr)
9792                 v2.AddArg(mem)
9793                 v1.AddArg(v2)
9794                 v0.AddArg(v1)
9795                 v.AddArg(v0)
9796                 return true
9797         }
9798         // match: (Zero [s] ptr mem)
9799         // cond: (SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%8 != 0
9800         // result: (LoweredZero [SizeAndAlign(s).Align()]               ptr             (ADDconst <ptr.Type> ptr [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)])            mem)
9801         for {
9802                 s := v.AuxInt
9803                 ptr := v.Args[0]
9804                 mem := v.Args[1]
9805                 if !((SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%8 != 0) {
9806                         break
9807                 }
9808                 v.reset(OpPPC64LoweredZero)
9809                 v.AuxInt = SizeAndAlign(s).Align()
9810                 v.AddArg(ptr)
9811                 v0 := b.NewValue0(v.Pos, OpPPC64ADDconst, ptr.Type)
9812                 v0.AuxInt = SizeAndAlign(s).Size() - moveSize(SizeAndAlign(s).Align(), config)
9813                 v0.AddArg(ptr)
9814                 v.AddArg(v0)
9815                 v.AddArg(mem)
9816                 return true
9817         }
9818         return false
9819 }
9820 func rewriteValuePPC64_OpZeroExt16to32(v *Value, config *Config) bool {
9821         b := v.Block
9822         _ = b
9823         // match: (ZeroExt16to32 x)
9824         // cond:
9825         // result: (MOVHZreg x)
9826         for {
9827                 x := v.Args[0]
9828                 v.reset(OpPPC64MOVHZreg)
9829                 v.AddArg(x)
9830                 return true
9831         }
9832 }
9833 func rewriteValuePPC64_OpZeroExt16to64(v *Value, config *Config) bool {
9834         b := v.Block
9835         _ = b
9836         // match: (ZeroExt16to64 x)
9837         // cond:
9838         // result: (MOVHZreg x)
9839         for {
9840                 x := v.Args[0]
9841                 v.reset(OpPPC64MOVHZreg)
9842                 v.AddArg(x)
9843                 return true
9844         }
9845 }
9846 func rewriteValuePPC64_OpZeroExt32to64(v *Value, config *Config) bool {
9847         b := v.Block
9848         _ = b
9849         // match: (ZeroExt32to64 x)
9850         // cond:
9851         // result: (MOVWZreg x)
9852         for {
9853                 x := v.Args[0]
9854                 v.reset(OpPPC64MOVWZreg)
9855                 v.AddArg(x)
9856                 return true
9857         }
9858 }
9859 func rewriteValuePPC64_OpZeroExt8to16(v *Value, config *Config) bool {
9860         b := v.Block
9861         _ = b
9862         // match: (ZeroExt8to16  x)
9863         // cond:
9864         // result: (MOVBZreg x)
9865         for {
9866                 x := v.Args[0]
9867                 v.reset(OpPPC64MOVBZreg)
9868                 v.AddArg(x)
9869                 return true
9870         }
9871 }
9872 func rewriteValuePPC64_OpZeroExt8to32(v *Value, config *Config) bool {
9873         b := v.Block
9874         _ = b
9875         // match: (ZeroExt8to32  x)
9876         // cond:
9877         // result: (MOVBZreg x)
9878         for {
9879                 x := v.Args[0]
9880                 v.reset(OpPPC64MOVBZreg)
9881                 v.AddArg(x)
9882                 return true
9883         }
9884 }
9885 func rewriteValuePPC64_OpZeroExt8to64(v *Value, config *Config) bool {
9886         b := v.Block
9887         _ = b
9888         // match: (ZeroExt8to64  x)
9889         // cond:
9890         // result: (MOVBZreg x)
9891         for {
9892                 x := v.Args[0]
9893                 v.reset(OpPPC64MOVBZreg)
9894                 v.AddArg(x)
9895                 return true
9896         }
9897 }
9898 func rewriteBlockPPC64(b *Block, config *Config) bool {
9899         switch b.Kind {
9900         case BlockPPC64EQ:
9901                 // match: (EQ (CMPconst [0] (ANDconst [c] x)) yes no)
9902                 // cond:
9903                 // result: (EQ (ANDCCconst [c] x) yes no)
9904                 for {
9905                         v := b.Control
9906                         if v.Op != OpPPC64CMPconst {
9907                                 break
9908                         }
9909                         if v.AuxInt != 0 {
9910                                 break
9911                         }
9912                         v_0 := v.Args[0]
9913                         if v_0.Op != OpPPC64ANDconst {
9914                                 break
9915                         }
9916                         c := v_0.AuxInt
9917                         x := v_0.Args[0]
9918                         yes := b.Succs[0]
9919                         no := b.Succs[1]
9920                         b.Kind = BlockPPC64EQ
9921                         v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, TypeFlags)
9922                         v0.AuxInt = c
9923                         v0.AddArg(x)
9924                         b.SetControl(v0)
9925                         _ = yes
9926                         _ = no
9927                         return true
9928                 }
9929                 // match: (EQ (CMPWconst [0] (ANDconst [c] x)) yes no)
9930                 // cond:
9931                 // result: (EQ (ANDCCconst [c] x) yes no)
9932                 for {
9933                         v := b.Control
9934                         if v.Op != OpPPC64CMPWconst {
9935                                 break
9936                         }
9937                         if v.AuxInt != 0 {
9938                                 break
9939                         }
9940                         v_0 := v.Args[0]
9941                         if v_0.Op != OpPPC64ANDconst {
9942                                 break
9943                         }
9944                         c := v_0.AuxInt
9945                         x := v_0.Args[0]
9946                         yes := b.Succs[0]
9947                         no := b.Succs[1]
9948                         b.Kind = BlockPPC64EQ
9949                         v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, TypeFlags)
9950                         v0.AuxInt = c
9951                         v0.AddArg(x)
9952                         b.SetControl(v0)
9953                         _ = yes
9954                         _ = no
9955                         return true
9956                 }
9957                 // match: (EQ (FlagEQ) yes no)
9958                 // cond:
9959                 // result: (First nil yes no)
9960                 for {
9961                         v := b.Control
9962                         if v.Op != OpPPC64FlagEQ {
9963                                 break
9964                         }
9965                         yes := b.Succs[0]
9966                         no := b.Succs[1]
9967                         b.Kind = BlockFirst
9968                         b.SetControl(nil)
9969                         _ = yes
9970                         _ = no
9971                         return true
9972                 }
9973                 // match: (EQ (FlagLT) yes no)
9974                 // cond:
9975                 // result: (First nil no yes)
9976                 for {
9977                         v := b.Control
9978                         if v.Op != OpPPC64FlagLT {
9979                                 break
9980                         }
9981                         yes := b.Succs[0]
9982                         no := b.Succs[1]
9983                         b.Kind = BlockFirst
9984                         b.SetControl(nil)
9985                         b.swapSuccessors()
9986                         _ = no
9987                         _ = yes
9988                         return true
9989                 }
9990                 // match: (EQ (FlagGT) yes no)
9991                 // cond:
9992                 // result: (First nil no yes)
9993                 for {
9994                         v := b.Control
9995                         if v.Op != OpPPC64FlagGT {
9996                                 break
9997                         }
9998                         yes := b.Succs[0]
9999                         no := b.Succs[1]
10000                         b.Kind = BlockFirst
10001                         b.SetControl(nil)
10002                         b.swapSuccessors()
10003                         _ = no
10004                         _ = yes
10005                         return true
10006                 }
10007                 // match: (EQ (InvertFlags cmp) yes no)
10008                 // cond:
10009                 // result: (EQ cmp yes no)
10010                 for {
10011                         v := b.Control
10012                         if v.Op != OpPPC64InvertFlags {
10013                                 break
10014                         }
10015                         cmp := v.Args[0]
10016                         yes := b.Succs[0]
10017                         no := b.Succs[1]
10018                         b.Kind = BlockPPC64EQ
10019                         b.SetControl(cmp)
10020                         _ = yes
10021                         _ = no
10022                         return true
10023                 }
10024         case BlockPPC64GE:
10025                 // match: (GE (FlagEQ) yes no)
10026                 // cond:
10027                 // result: (First nil yes no)
10028                 for {
10029                         v := b.Control
10030                         if v.Op != OpPPC64FlagEQ {
10031                                 break
10032                         }
10033                         yes := b.Succs[0]
10034                         no := b.Succs[1]
10035                         b.Kind = BlockFirst
10036                         b.SetControl(nil)
10037                         _ = yes
10038                         _ = no
10039                         return true
10040                 }
10041                 // match: (GE (FlagLT) yes no)
10042                 // cond:
10043                 // result: (First nil no yes)
10044                 for {
10045                         v := b.Control
10046                         if v.Op != OpPPC64FlagLT {
10047                                 break
10048                         }
10049                         yes := b.Succs[0]
10050                         no := b.Succs[1]
10051                         b.Kind = BlockFirst
10052                         b.SetControl(nil)
10053                         b.swapSuccessors()
10054                         _ = no
10055                         _ = yes
10056                         return true
10057                 }
10058                 // match: (GE (FlagGT) yes no)
10059                 // cond:
10060                 // result: (First nil yes no)
10061                 for {
10062                         v := b.Control
10063                         if v.Op != OpPPC64FlagGT {
10064                                 break
10065                         }
10066                         yes := b.Succs[0]
10067                         no := b.Succs[1]
10068                         b.Kind = BlockFirst
10069                         b.SetControl(nil)
10070                         _ = yes
10071                         _ = no
10072                         return true
10073                 }
10074                 // match: (GE (InvertFlags cmp) yes no)
10075                 // cond:
10076                 // result: (LE cmp yes no)
10077                 for {
10078                         v := b.Control
10079                         if v.Op != OpPPC64InvertFlags {
10080                                 break
10081                         }
10082                         cmp := v.Args[0]
10083                         yes := b.Succs[0]
10084                         no := b.Succs[1]
10085                         b.Kind = BlockPPC64LE
10086                         b.SetControl(cmp)
10087                         _ = yes
10088                         _ = no
10089                         return true
10090                 }
10091         case BlockPPC64GT:
10092                 // match: (GT (FlagEQ) yes no)
10093                 // cond:
10094                 // result: (First nil no yes)
10095                 for {
10096                         v := b.Control
10097                         if v.Op != OpPPC64FlagEQ {
10098                                 break
10099                         }
10100                         yes := b.Succs[0]
10101                         no := b.Succs[1]
10102                         b.Kind = BlockFirst
10103                         b.SetControl(nil)
10104                         b.swapSuccessors()
10105                         _ = no
10106                         _ = yes
10107                         return true
10108                 }
10109                 // match: (GT (FlagLT) yes no)
10110                 // cond:
10111                 // result: (First nil no yes)
10112                 for {
10113                         v := b.Control
10114                         if v.Op != OpPPC64FlagLT {
10115                                 break
10116                         }
10117                         yes := b.Succs[0]
10118                         no := b.Succs[1]
10119                         b.Kind = BlockFirst
10120                         b.SetControl(nil)
10121                         b.swapSuccessors()
10122                         _ = no
10123                         _ = yes
10124                         return true
10125                 }
10126                 // match: (GT (FlagGT) yes no)
10127                 // cond:
10128                 // result: (First nil yes no)
10129                 for {
10130                         v := b.Control
10131                         if v.Op != OpPPC64FlagGT {
10132                                 break
10133                         }
10134                         yes := b.Succs[0]
10135                         no := b.Succs[1]
10136                         b.Kind = BlockFirst
10137                         b.SetControl(nil)
10138                         _ = yes
10139                         _ = no
10140                         return true
10141                 }
10142                 // match: (GT (InvertFlags cmp) yes no)
10143                 // cond:
10144                 // result: (LT cmp yes no)
10145                 for {
10146                         v := b.Control
10147                         if v.Op != OpPPC64InvertFlags {
10148                                 break
10149                         }
10150                         cmp := v.Args[0]
10151                         yes := b.Succs[0]
10152                         no := b.Succs[1]
10153                         b.Kind = BlockPPC64LT
10154                         b.SetControl(cmp)
10155                         _ = yes
10156                         _ = no
10157                         return true
10158                 }
10159         case BlockIf:
10160                 // match: (If (Equal cc) yes no)
10161                 // cond:
10162                 // result: (EQ cc yes no)
10163                 for {
10164                         v := b.Control
10165                         if v.Op != OpPPC64Equal {
10166                                 break
10167                         }
10168                         cc := v.Args[0]
10169                         yes := b.Succs[0]
10170                         no := b.Succs[1]
10171                         b.Kind = BlockPPC64EQ
10172                         b.SetControl(cc)
10173                         _ = yes
10174                         _ = no
10175                         return true
10176                 }
10177                 // match: (If (NotEqual cc) yes no)
10178                 // cond:
10179                 // result: (NE cc yes no)
10180                 for {
10181                         v := b.Control
10182                         if v.Op != OpPPC64NotEqual {
10183                                 break
10184                         }
10185                         cc := v.Args[0]
10186                         yes := b.Succs[0]
10187                         no := b.Succs[1]
10188                         b.Kind = BlockPPC64NE
10189                         b.SetControl(cc)
10190                         _ = yes
10191                         _ = no
10192                         return true
10193                 }
10194                 // match: (If (LessThan cc) yes no)
10195                 // cond:
10196                 // result: (LT cc yes no)
10197                 for {
10198                         v := b.Control
10199                         if v.Op != OpPPC64LessThan {
10200                                 break
10201                         }
10202                         cc := v.Args[0]
10203                         yes := b.Succs[0]
10204                         no := b.Succs[1]
10205                         b.Kind = BlockPPC64LT
10206                         b.SetControl(cc)
10207                         _ = yes
10208                         _ = no
10209                         return true
10210                 }
10211                 // match: (If (LessEqual cc) yes no)
10212                 // cond:
10213                 // result: (LE cc yes no)
10214                 for {
10215                         v := b.Control
10216                         if v.Op != OpPPC64LessEqual {
10217                                 break
10218                         }
10219                         cc := v.Args[0]
10220                         yes := b.Succs[0]
10221                         no := b.Succs[1]
10222                         b.Kind = BlockPPC64LE
10223                         b.SetControl(cc)
10224                         _ = yes
10225                         _ = no
10226                         return true
10227                 }
10228                 // match: (If (GreaterThan cc) yes no)
10229                 // cond:
10230                 // result: (GT cc yes no)
10231                 for {
10232                         v := b.Control
10233                         if v.Op != OpPPC64GreaterThan {
10234                                 break
10235                         }
10236                         cc := v.Args[0]
10237                         yes := b.Succs[0]
10238                         no := b.Succs[1]
10239                         b.Kind = BlockPPC64GT
10240                         b.SetControl(cc)
10241                         _ = yes
10242                         _ = no
10243                         return true
10244                 }
10245                 // match: (If (GreaterEqual cc) yes no)
10246                 // cond:
10247                 // result: (GE cc yes no)
10248                 for {
10249                         v := b.Control
10250                         if v.Op != OpPPC64GreaterEqual {
10251                                 break
10252                         }
10253                         cc := v.Args[0]
10254                         yes := b.Succs[0]
10255                         no := b.Succs[1]
10256                         b.Kind = BlockPPC64GE
10257                         b.SetControl(cc)
10258                         _ = yes
10259                         _ = no
10260                         return true
10261                 }
10262                 // match: (If (FLessThan cc) yes no)
10263                 // cond:
10264                 // result: (FLT cc yes no)
10265                 for {
10266                         v := b.Control
10267                         if v.Op != OpPPC64FLessThan {
10268                                 break
10269                         }
10270                         cc := v.Args[0]
10271                         yes := b.Succs[0]
10272                         no := b.Succs[1]
10273                         b.Kind = BlockPPC64FLT
10274                         b.SetControl(cc)
10275                         _ = yes
10276                         _ = no
10277                         return true
10278                 }
10279                 // match: (If (FLessEqual cc) yes no)
10280                 // cond:
10281                 // result: (FLE cc yes no)
10282                 for {
10283                         v := b.Control
10284                         if v.Op != OpPPC64FLessEqual {
10285                                 break
10286                         }
10287                         cc := v.Args[0]
10288                         yes := b.Succs[0]
10289                         no := b.Succs[1]
10290                         b.Kind = BlockPPC64FLE
10291                         b.SetControl(cc)
10292                         _ = yes
10293                         _ = no
10294                         return true
10295                 }
10296                 // match: (If (FGreaterThan cc) yes no)
10297                 // cond:
10298                 // result: (FGT cc yes no)
10299                 for {
10300                         v := b.Control
10301                         if v.Op != OpPPC64FGreaterThan {
10302                                 break
10303                         }
10304                         cc := v.Args[0]
10305                         yes := b.Succs[0]
10306                         no := b.Succs[1]
10307                         b.Kind = BlockPPC64FGT
10308                         b.SetControl(cc)
10309                         _ = yes
10310                         _ = no
10311                         return true
10312                 }
10313                 // match: (If (FGreaterEqual cc) yes no)
10314                 // cond:
10315                 // result: (FGE cc yes no)
10316                 for {
10317                         v := b.Control
10318                         if v.Op != OpPPC64FGreaterEqual {
10319                                 break
10320                         }
10321                         cc := v.Args[0]
10322                         yes := b.Succs[0]
10323                         no := b.Succs[1]
10324                         b.Kind = BlockPPC64FGE
10325                         b.SetControl(cc)
10326                         _ = yes
10327                         _ = no
10328                         return true
10329                 }
10330                 // match: (If cond yes no)
10331                 // cond:
10332                 // result: (NE (CMPWconst [0] cond) yes no)
10333                 for {
10334                         v := b.Control
10335                         _ = v
10336                         cond := b.Control
10337                         yes := b.Succs[0]
10338                         no := b.Succs[1]
10339                         b.Kind = BlockPPC64NE
10340                         v0 := b.NewValue0(v.Pos, OpPPC64CMPWconst, TypeFlags)
10341                         v0.AuxInt = 0
10342                         v0.AddArg(cond)
10343                         b.SetControl(v0)
10344                         _ = yes
10345                         _ = no
10346                         return true
10347                 }
10348         case BlockPPC64LE:
10349                 // match: (LE (FlagEQ) yes no)
10350                 // cond:
10351                 // result: (First nil yes no)
10352                 for {
10353                         v := b.Control
10354                         if v.Op != OpPPC64FlagEQ {
10355                                 break
10356                         }
10357                         yes := b.Succs[0]
10358                         no := b.Succs[1]
10359                         b.Kind = BlockFirst
10360                         b.SetControl(nil)
10361                         _ = yes
10362                         _ = no
10363                         return true
10364                 }
10365                 // match: (LE (FlagLT) yes no)
10366                 // cond:
10367                 // result: (First nil yes no)
10368                 for {
10369                         v := b.Control
10370                         if v.Op != OpPPC64FlagLT {
10371                                 break
10372                         }
10373                         yes := b.Succs[0]
10374                         no := b.Succs[1]
10375                         b.Kind = BlockFirst
10376                         b.SetControl(nil)
10377                         _ = yes
10378                         _ = no
10379                         return true
10380                 }
10381                 // match: (LE (FlagGT) yes no)
10382                 // cond:
10383                 // result: (First nil no yes)
10384                 for {
10385                         v := b.Control
10386                         if v.Op != OpPPC64FlagGT {
10387                                 break
10388                         }
10389                         yes := b.Succs[0]
10390                         no := b.Succs[1]
10391                         b.Kind = BlockFirst
10392                         b.SetControl(nil)
10393                         b.swapSuccessors()
10394                         _ = no
10395                         _ = yes
10396                         return true
10397                 }
10398                 // match: (LE (InvertFlags cmp) yes no)
10399                 // cond:
10400                 // result: (GE cmp yes no)
10401                 for {
10402                         v := b.Control
10403                         if v.Op != OpPPC64InvertFlags {
10404                                 break
10405                         }
10406                         cmp := v.Args[0]
10407                         yes := b.Succs[0]
10408                         no := b.Succs[1]
10409                         b.Kind = BlockPPC64GE
10410                         b.SetControl(cmp)
10411                         _ = yes
10412                         _ = no
10413                         return true
10414                 }
10415         case BlockPPC64LT:
10416                 // match: (LT (FlagEQ) yes no)
10417                 // cond:
10418                 // result: (First nil no yes)
10419                 for {
10420                         v := b.Control
10421                         if v.Op != OpPPC64FlagEQ {
10422                                 break
10423                         }
10424                         yes := b.Succs[0]
10425                         no := b.Succs[1]
10426                         b.Kind = BlockFirst
10427                         b.SetControl(nil)
10428                         b.swapSuccessors()
10429                         _ = no
10430                         _ = yes
10431                         return true
10432                 }
10433                 // match: (LT (FlagLT) yes no)
10434                 // cond:
10435                 // result: (First nil yes no)
10436                 for {
10437                         v := b.Control
10438                         if v.Op != OpPPC64FlagLT {
10439                                 break
10440                         }
10441                         yes := b.Succs[0]
10442                         no := b.Succs[1]
10443                         b.Kind = BlockFirst
10444                         b.SetControl(nil)
10445                         _ = yes
10446                         _ = no
10447                         return true
10448                 }
10449                 // match: (LT (FlagGT) yes no)
10450                 // cond:
10451                 // result: (First nil no yes)
10452                 for {
10453                         v := b.Control
10454                         if v.Op != OpPPC64FlagGT {
10455                                 break
10456                         }
10457                         yes := b.Succs[0]
10458                         no := b.Succs[1]
10459                         b.Kind = BlockFirst
10460                         b.SetControl(nil)
10461                         b.swapSuccessors()
10462                         _ = no
10463                         _ = yes
10464                         return true
10465                 }
10466                 // match: (LT (InvertFlags cmp) yes no)
10467                 // cond:
10468                 // result: (GT cmp yes no)
10469                 for {
10470                         v := b.Control
10471                         if v.Op != OpPPC64InvertFlags {
10472                                 break
10473                         }
10474                         cmp := v.Args[0]
10475                         yes := b.Succs[0]
10476                         no := b.Succs[1]
10477                         b.Kind = BlockPPC64GT
10478                         b.SetControl(cmp)
10479                         _ = yes
10480                         _ = no
10481                         return true
10482                 }
10483         case BlockPPC64NE:
10484                 // match: (NE (CMPWconst [0] (Equal cc)) yes no)
10485                 // cond:
10486                 // result: (EQ cc yes no)
10487                 for {
10488                         v := b.Control
10489                         if v.Op != OpPPC64CMPWconst {
10490                                 break
10491                         }
10492                         if v.AuxInt != 0 {
10493                                 break
10494                         }
10495                         v_0 := v.Args[0]
10496                         if v_0.Op != OpPPC64Equal {
10497                                 break
10498                         }
10499                         cc := v_0.Args[0]
10500                         yes := b.Succs[0]
10501                         no := b.Succs[1]
10502                         b.Kind = BlockPPC64EQ
10503                         b.SetControl(cc)
10504                         _ = yes
10505                         _ = no
10506                         return true
10507                 }
10508                 // match: (NE (CMPWconst [0] (NotEqual cc)) yes no)
10509                 // cond:
10510                 // result: (NE cc yes no)
10511                 for {
10512                         v := b.Control
10513                         if v.Op != OpPPC64CMPWconst {
10514                                 break
10515                         }
10516                         if v.AuxInt != 0 {
10517                                 break
10518                         }
10519                         v_0 := v.Args[0]
10520                         if v_0.Op != OpPPC64NotEqual {
10521                                 break
10522                         }
10523                         cc := v_0.Args[0]
10524                         yes := b.Succs[0]
10525                         no := b.Succs[1]
10526                         b.Kind = BlockPPC64NE
10527                         b.SetControl(cc)
10528                         _ = yes
10529                         _ = no
10530                         return true
10531                 }
10532                 // match: (NE (CMPWconst [0] (LessThan cc)) yes no)
10533                 // cond:
10534                 // result: (LT cc yes no)
10535                 for {
10536                         v := b.Control
10537                         if v.Op != OpPPC64CMPWconst {
10538                                 break
10539                         }
10540                         if v.AuxInt != 0 {
10541                                 break
10542                         }
10543                         v_0 := v.Args[0]
10544                         if v_0.Op != OpPPC64LessThan {
10545                                 break
10546                         }
10547                         cc := v_0.Args[0]
10548                         yes := b.Succs[0]
10549                         no := b.Succs[1]
10550                         b.Kind = BlockPPC64LT
10551                         b.SetControl(cc)
10552                         _ = yes
10553                         _ = no
10554                         return true
10555                 }
10556                 // match: (NE (CMPWconst [0] (LessEqual cc)) yes no)
10557                 // cond:
10558                 // result: (LE cc yes no)
10559                 for {
10560                         v := b.Control
10561                         if v.Op != OpPPC64CMPWconst {
10562                                 break
10563                         }
10564                         if v.AuxInt != 0 {
10565                                 break
10566                         }
10567                         v_0 := v.Args[0]
10568                         if v_0.Op != OpPPC64LessEqual {
10569                                 break
10570                         }
10571                         cc := v_0.Args[0]
10572                         yes := b.Succs[0]
10573                         no := b.Succs[1]
10574                         b.Kind = BlockPPC64LE
10575                         b.SetControl(cc)
10576                         _ = yes
10577                         _ = no
10578                         return true
10579                 }
10580                 // match: (NE (CMPWconst [0] (GreaterThan cc)) yes no)
10581                 // cond:
10582                 // result: (GT cc yes no)
10583                 for {
10584                         v := b.Control
10585                         if v.Op != OpPPC64CMPWconst {
10586                                 break
10587                         }
10588                         if v.AuxInt != 0 {
10589                                 break
10590                         }
10591                         v_0 := v.Args[0]
10592                         if v_0.Op != OpPPC64GreaterThan {
10593                                 break
10594                         }
10595                         cc := v_0.Args[0]
10596                         yes := b.Succs[0]
10597                         no := b.Succs[1]
10598                         b.Kind = BlockPPC64GT
10599                         b.SetControl(cc)
10600                         _ = yes
10601                         _ = no
10602                         return true
10603                 }
10604                 // match: (NE (CMPWconst [0] (GreaterEqual cc)) yes no)
10605                 // cond:
10606                 // result: (GE cc yes no)
10607                 for {
10608                         v := b.Control
10609                         if v.Op != OpPPC64CMPWconst {
10610                                 break
10611                         }
10612                         if v.AuxInt != 0 {
10613                                 break
10614                         }
10615                         v_0 := v.Args[0]
10616                         if v_0.Op != OpPPC64GreaterEqual {
10617                                 break
10618                         }
10619                         cc := v_0.Args[0]
10620                         yes := b.Succs[0]
10621                         no := b.Succs[1]
10622                         b.Kind = BlockPPC64GE
10623                         b.SetControl(cc)
10624                         _ = yes
10625                         _ = no
10626                         return true
10627                 }
10628                 // match: (NE (CMPWconst [0] (FLessThan cc)) yes no)
10629                 // cond:
10630                 // result: (FLT cc yes no)
10631                 for {
10632                         v := b.Control
10633                         if v.Op != OpPPC64CMPWconst {
10634                                 break
10635                         }
10636                         if v.AuxInt != 0 {
10637                                 break
10638                         }
10639                         v_0 := v.Args[0]
10640                         if v_0.Op != OpPPC64FLessThan {
10641                                 break
10642                         }
10643                         cc := v_0.Args[0]
10644                         yes := b.Succs[0]
10645                         no := b.Succs[1]
10646                         b.Kind = BlockPPC64FLT
10647                         b.SetControl(cc)
10648                         _ = yes
10649                         _ = no
10650                         return true
10651                 }
10652                 // match: (NE (CMPWconst [0] (FLessEqual cc)) yes no)
10653                 // cond:
10654                 // result: (FLE cc yes no)
10655                 for {
10656                         v := b.Control
10657                         if v.Op != OpPPC64CMPWconst {
10658                                 break
10659                         }
10660                         if v.AuxInt != 0 {
10661                                 break
10662                         }
10663                         v_0 := v.Args[0]
10664                         if v_0.Op != OpPPC64FLessEqual {
10665                                 break
10666                         }
10667                         cc := v_0.Args[0]
10668                         yes := b.Succs[0]
10669                         no := b.Succs[1]
10670                         b.Kind = BlockPPC64FLE
10671                         b.SetControl(cc)
10672                         _ = yes
10673                         _ = no
10674                         return true
10675                 }
10676                 // match: (NE (CMPWconst [0] (FGreaterThan cc)) yes no)
10677                 // cond:
10678                 // result: (FGT cc yes no)
10679                 for {
10680                         v := b.Control
10681                         if v.Op != OpPPC64CMPWconst {
10682                                 break
10683                         }
10684                         if v.AuxInt != 0 {
10685                                 break
10686                         }
10687                         v_0 := v.Args[0]
10688                         if v_0.Op != OpPPC64FGreaterThan {
10689                                 break
10690                         }
10691                         cc := v_0.Args[0]
10692                         yes := b.Succs[0]
10693                         no := b.Succs[1]
10694                         b.Kind = BlockPPC64FGT
10695                         b.SetControl(cc)
10696                         _ = yes
10697                         _ = no
10698                         return true
10699                 }
10700                 // match: (NE (CMPWconst [0] (FGreaterEqual cc)) yes no)
10701                 // cond:
10702                 // result: (FGE cc yes no)
10703                 for {
10704                         v := b.Control
10705                         if v.Op != OpPPC64CMPWconst {
10706                                 break
10707                         }
10708                         if v.AuxInt != 0 {
10709                                 break
10710                         }
10711                         v_0 := v.Args[0]
10712                         if v_0.Op != OpPPC64FGreaterEqual {
10713                                 break
10714                         }
10715                         cc := v_0.Args[0]
10716                         yes := b.Succs[0]
10717                         no := b.Succs[1]
10718                         b.Kind = BlockPPC64FGE
10719                         b.SetControl(cc)
10720                         _ = yes
10721                         _ = no
10722                         return true
10723                 }
10724                 // match: (NE (CMPconst [0] (ANDconst [c] x)) yes no)
10725                 // cond:
10726                 // result: (NE (ANDCCconst [c] x) yes no)
10727                 for {
10728                         v := b.Control
10729                         if v.Op != OpPPC64CMPconst {
10730                                 break
10731                         }
10732                         if v.AuxInt != 0 {
10733                                 break
10734                         }
10735                         v_0 := v.Args[0]
10736                         if v_0.Op != OpPPC64ANDconst {
10737                                 break
10738                         }
10739                         c := v_0.AuxInt
10740                         x := v_0.Args[0]
10741                         yes := b.Succs[0]
10742                         no := b.Succs[1]
10743                         b.Kind = BlockPPC64NE
10744                         v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, TypeFlags)
10745                         v0.AuxInt = c
10746                         v0.AddArg(x)
10747                         b.SetControl(v0)
10748                         _ = yes
10749                         _ = no
10750                         return true
10751                 }
10752                 // match: (NE (CMPWconst [0] (ANDconst [c] x)) yes no)
10753                 // cond:
10754                 // result: (NE (ANDCCconst [c] x) yes no)
10755                 for {
10756                         v := b.Control
10757                         if v.Op != OpPPC64CMPWconst {
10758                                 break
10759                         }
10760                         if v.AuxInt != 0 {
10761                                 break
10762                         }
10763                         v_0 := v.Args[0]
10764                         if v_0.Op != OpPPC64ANDconst {
10765                                 break
10766                         }
10767                         c := v_0.AuxInt
10768                         x := v_0.Args[0]
10769                         yes := b.Succs[0]
10770                         no := b.Succs[1]
10771                         b.Kind = BlockPPC64NE
10772                         v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, TypeFlags)
10773                         v0.AuxInt = c
10774                         v0.AddArg(x)
10775                         b.SetControl(v0)
10776                         _ = yes
10777                         _ = no
10778                         return true
10779                 }
10780                 // match: (NE (FlagEQ) yes no)
10781                 // cond:
10782                 // result: (First nil no yes)
10783                 for {
10784                         v := b.Control
10785                         if v.Op != OpPPC64FlagEQ {
10786                                 break
10787                         }
10788                         yes := b.Succs[0]
10789                         no := b.Succs[1]
10790                         b.Kind = BlockFirst
10791                         b.SetControl(nil)
10792                         b.swapSuccessors()
10793                         _ = no
10794                         _ = yes
10795                         return true
10796                 }
10797                 // match: (NE (FlagLT) yes no)
10798                 // cond:
10799                 // result: (First nil yes no)
10800                 for {
10801                         v := b.Control
10802                         if v.Op != OpPPC64FlagLT {
10803                                 break
10804                         }
10805                         yes := b.Succs[0]
10806                         no := b.Succs[1]
10807                         b.Kind = BlockFirst
10808                         b.SetControl(nil)
10809                         _ = yes
10810                         _ = no
10811                         return true
10812                 }
10813                 // match: (NE (FlagGT) yes no)
10814                 // cond:
10815                 // result: (First nil yes no)
10816                 for {
10817                         v := b.Control
10818                         if v.Op != OpPPC64FlagGT {
10819                                 break
10820                         }
10821                         yes := b.Succs[0]
10822                         no := b.Succs[1]
10823                         b.Kind = BlockFirst
10824                         b.SetControl(nil)
10825                         _ = yes
10826                         _ = no
10827                         return true
10828                 }
10829                 // match: (NE (InvertFlags cmp) yes no)
10830                 // cond:
10831                 // result: (NE cmp yes no)
10832                 for {
10833                         v := b.Control
10834                         if v.Op != OpPPC64InvertFlags {
10835                                 break
10836                         }
10837                         cmp := v.Args[0]
10838                         yes := b.Succs[0]
10839                         no := b.Succs[1]
10840                         b.Kind = BlockPPC64NE
10841                         b.SetControl(cmp)
10842                         _ = yes
10843                         _ = no
10844                         return true
10845                 }
10846         }
10847         return false
10848 }