github.com/FenixAra/go@v0.0.0-20170127160404-96ea0918e670/src/cmd/compile/internal/ssa/rewritePPC64.go (about) 1 // autogenerated from gen/PPC64.rules: do not edit! 2 // generated with: cd gen; go run *.go 3 4 package ssa 5 6 import "math" 7 8 var _ = math.MinInt8 // in case not otherwise used 9 func rewriteValuePPC64(v *Value, config *Config) bool { 10 switch v.Op { 11 case OpAdd16: 12 return rewriteValuePPC64_OpAdd16(v, config) 13 case OpAdd32: 14 return rewriteValuePPC64_OpAdd32(v, config) 15 case OpAdd32F: 16 return rewriteValuePPC64_OpAdd32F(v, config) 17 case OpAdd64: 18 return rewriteValuePPC64_OpAdd64(v, config) 19 case OpAdd64F: 20 return rewriteValuePPC64_OpAdd64F(v, config) 21 case OpAdd8: 22 return rewriteValuePPC64_OpAdd8(v, config) 23 case OpAddPtr: 24 return rewriteValuePPC64_OpAddPtr(v, config) 25 case OpAddr: 26 return rewriteValuePPC64_OpAddr(v, config) 27 case OpAnd16: 28 return rewriteValuePPC64_OpAnd16(v, config) 29 case OpAnd32: 30 return rewriteValuePPC64_OpAnd32(v, config) 31 case OpAnd64: 32 return rewriteValuePPC64_OpAnd64(v, config) 33 case OpAnd8: 34 return rewriteValuePPC64_OpAnd8(v, config) 35 case OpAndB: 36 return rewriteValuePPC64_OpAndB(v, config) 37 case OpAvg64u: 38 return rewriteValuePPC64_OpAvg64u(v, config) 39 case OpClosureCall: 40 return rewriteValuePPC64_OpClosureCall(v, config) 41 case OpCom16: 42 return rewriteValuePPC64_OpCom16(v, config) 43 case OpCom32: 44 return rewriteValuePPC64_OpCom32(v, config) 45 case OpCom64: 46 return rewriteValuePPC64_OpCom64(v, config) 47 case OpCom8: 48 return rewriteValuePPC64_OpCom8(v, config) 49 case OpConst16: 50 return rewriteValuePPC64_OpConst16(v, config) 51 case OpConst32: 52 return rewriteValuePPC64_OpConst32(v, config) 53 case OpConst32F: 54 return rewriteValuePPC64_OpConst32F(v, config) 55 case OpConst64: 56 return rewriteValuePPC64_OpConst64(v, config) 57 case OpConst64F: 58 return rewriteValuePPC64_OpConst64F(v, config) 59 case OpConst8: 60 return rewriteValuePPC64_OpConst8(v, config) 61 case OpConstBool: 62 return rewriteValuePPC64_OpConstBool(v, config) 63 case OpConstNil: 64 return rewriteValuePPC64_OpConstNil(v, config) 65 case OpConvert: 66 return rewriteValuePPC64_OpConvert(v, config) 67 case OpCvt32Fto32: 68 return rewriteValuePPC64_OpCvt32Fto32(v, config) 69 case OpCvt32Fto64: 70 return rewriteValuePPC64_OpCvt32Fto64(v, config) 71 case OpCvt32Fto64F: 72 return rewriteValuePPC64_OpCvt32Fto64F(v, config) 73 case OpCvt32to32F: 74 return rewriteValuePPC64_OpCvt32to32F(v, config) 75 case OpCvt32to64F: 76 return rewriteValuePPC64_OpCvt32to64F(v, config) 77 case OpCvt64Fto32: 78 return rewriteValuePPC64_OpCvt64Fto32(v, config) 79 case OpCvt64Fto32F: 80 return rewriteValuePPC64_OpCvt64Fto32F(v, config) 81 case OpCvt64Fto64: 82 return rewriteValuePPC64_OpCvt64Fto64(v, config) 83 case OpCvt64to32F: 84 return rewriteValuePPC64_OpCvt64to32F(v, config) 85 case OpCvt64to64F: 86 return rewriteValuePPC64_OpCvt64to64F(v, config) 87 case OpDeferCall: 88 return rewriteValuePPC64_OpDeferCall(v, config) 89 case OpDiv16: 90 return rewriteValuePPC64_OpDiv16(v, config) 91 case OpDiv16u: 92 return rewriteValuePPC64_OpDiv16u(v, config) 93 case OpDiv32: 94 return rewriteValuePPC64_OpDiv32(v, config) 95 case OpDiv32F: 96 return rewriteValuePPC64_OpDiv32F(v, config) 97 case OpDiv32u: 98 return rewriteValuePPC64_OpDiv32u(v, config) 99 case OpDiv64: 100 return rewriteValuePPC64_OpDiv64(v, config) 101 case OpDiv64F: 102 return rewriteValuePPC64_OpDiv64F(v, config) 103 case OpDiv64u: 104 return rewriteValuePPC64_OpDiv64u(v, config) 105 case OpDiv8: 106 return rewriteValuePPC64_OpDiv8(v, config) 107 case OpDiv8u: 108 return rewriteValuePPC64_OpDiv8u(v, config) 109 case OpEq16: 110 return rewriteValuePPC64_OpEq16(v, config) 111 case OpEq32: 112 return rewriteValuePPC64_OpEq32(v, config) 113 case OpEq32F: 114 return rewriteValuePPC64_OpEq32F(v, config) 115 case OpEq64: 116 return rewriteValuePPC64_OpEq64(v, config) 117 case OpEq64F: 118 return rewriteValuePPC64_OpEq64F(v, config) 119 case OpEq8: 120 return rewriteValuePPC64_OpEq8(v, config) 121 case OpEqB: 122 return rewriteValuePPC64_OpEqB(v, config) 123 case OpEqPtr: 124 return rewriteValuePPC64_OpEqPtr(v, config) 125 case OpGeq16: 126 return rewriteValuePPC64_OpGeq16(v, config) 127 case OpGeq16U: 128 return rewriteValuePPC64_OpGeq16U(v, config) 129 case OpGeq32: 130 return rewriteValuePPC64_OpGeq32(v, config) 131 case OpGeq32F: 132 return rewriteValuePPC64_OpGeq32F(v, config) 133 case OpGeq32U: 134 return rewriteValuePPC64_OpGeq32U(v, config) 135 case OpGeq64: 136 return rewriteValuePPC64_OpGeq64(v, config) 137 case OpGeq64F: 138 return rewriteValuePPC64_OpGeq64F(v, config) 139 case OpGeq64U: 140 return rewriteValuePPC64_OpGeq64U(v, config) 141 case OpGeq8: 142 return rewriteValuePPC64_OpGeq8(v, config) 143 case OpGeq8U: 144 return rewriteValuePPC64_OpGeq8U(v, config) 145 case OpGetClosurePtr: 146 return rewriteValuePPC64_OpGetClosurePtr(v, config) 147 case OpGoCall: 148 return rewriteValuePPC64_OpGoCall(v, config) 149 case OpGreater16: 150 return rewriteValuePPC64_OpGreater16(v, config) 151 case OpGreater16U: 152 return rewriteValuePPC64_OpGreater16U(v, config) 153 case OpGreater32: 154 return rewriteValuePPC64_OpGreater32(v, config) 155 case OpGreater32F: 156 return rewriteValuePPC64_OpGreater32F(v, config) 157 case OpGreater32U: 158 return rewriteValuePPC64_OpGreater32U(v, config) 159 case OpGreater64: 160 return rewriteValuePPC64_OpGreater64(v, config) 161 case OpGreater64F: 162 return rewriteValuePPC64_OpGreater64F(v, config) 163 case OpGreater64U: 164 return rewriteValuePPC64_OpGreater64U(v, config) 165 case OpGreater8: 166 return rewriteValuePPC64_OpGreater8(v, config) 167 case OpGreater8U: 168 return rewriteValuePPC64_OpGreater8U(v, config) 169 case OpHmul16: 170 return rewriteValuePPC64_OpHmul16(v, config) 171 case OpHmul16u: 172 return rewriteValuePPC64_OpHmul16u(v, config) 173 case OpHmul32: 174 return rewriteValuePPC64_OpHmul32(v, config) 175 case OpHmul32u: 176 return rewriteValuePPC64_OpHmul32u(v, config) 177 case OpHmul64: 178 return rewriteValuePPC64_OpHmul64(v, config) 179 case OpHmul64u: 180 return rewriteValuePPC64_OpHmul64u(v, config) 181 case OpHmul8: 182 return rewriteValuePPC64_OpHmul8(v, config) 183 case OpHmul8u: 184 return rewriteValuePPC64_OpHmul8u(v, config) 185 case OpInterCall: 186 return rewriteValuePPC64_OpInterCall(v, config) 187 case OpIsInBounds: 188 return rewriteValuePPC64_OpIsInBounds(v, config) 189 case OpIsNonNil: 190 return rewriteValuePPC64_OpIsNonNil(v, config) 191 case OpIsSliceInBounds: 192 return rewriteValuePPC64_OpIsSliceInBounds(v, config) 193 case OpLeq16: 194 return rewriteValuePPC64_OpLeq16(v, config) 195 case OpLeq16U: 196 return rewriteValuePPC64_OpLeq16U(v, config) 197 case OpLeq32: 198 return rewriteValuePPC64_OpLeq32(v, config) 199 case OpLeq32F: 200 return rewriteValuePPC64_OpLeq32F(v, config) 201 case OpLeq32U: 202 return rewriteValuePPC64_OpLeq32U(v, config) 203 case OpLeq64: 204 return rewriteValuePPC64_OpLeq64(v, config) 205 case OpLeq64F: 206 return rewriteValuePPC64_OpLeq64F(v, config) 207 case OpLeq64U: 208 return rewriteValuePPC64_OpLeq64U(v, config) 209 case OpLeq8: 210 return rewriteValuePPC64_OpLeq8(v, config) 211 case OpLeq8U: 212 return rewriteValuePPC64_OpLeq8U(v, config) 213 case OpLess16: 214 return rewriteValuePPC64_OpLess16(v, config) 215 case OpLess16U: 216 return rewriteValuePPC64_OpLess16U(v, config) 217 case OpLess32: 218 return rewriteValuePPC64_OpLess32(v, config) 219 case OpLess32F: 220 return rewriteValuePPC64_OpLess32F(v, config) 221 case OpLess32U: 222 return rewriteValuePPC64_OpLess32U(v, config) 223 case OpLess64: 224 return rewriteValuePPC64_OpLess64(v, config) 225 case OpLess64F: 226 return rewriteValuePPC64_OpLess64F(v, config) 227 case OpLess64U: 228 return rewriteValuePPC64_OpLess64U(v, config) 229 case OpLess8: 230 return rewriteValuePPC64_OpLess8(v, config) 231 case OpLess8U: 232 return rewriteValuePPC64_OpLess8U(v, config) 233 case OpLoad: 234 return rewriteValuePPC64_OpLoad(v, config) 235 case OpLsh16x16: 236 return rewriteValuePPC64_OpLsh16x16(v, config) 237 case OpLsh16x32: 238 return rewriteValuePPC64_OpLsh16x32(v, config) 239 case OpLsh16x64: 240 return rewriteValuePPC64_OpLsh16x64(v, config) 241 case OpLsh16x8: 242 return rewriteValuePPC64_OpLsh16x8(v, config) 243 case OpLsh32x16: 244 return rewriteValuePPC64_OpLsh32x16(v, config) 245 case OpLsh32x32: 246 return rewriteValuePPC64_OpLsh32x32(v, config) 247 case OpLsh32x64: 248 return rewriteValuePPC64_OpLsh32x64(v, config) 249 case OpLsh32x8: 250 return rewriteValuePPC64_OpLsh32x8(v, config) 251 case OpLsh64x16: 252 return rewriteValuePPC64_OpLsh64x16(v, config) 253 case OpLsh64x32: 254 return rewriteValuePPC64_OpLsh64x32(v, config) 255 case OpLsh64x64: 256 return rewriteValuePPC64_OpLsh64x64(v, config) 257 case OpLsh64x8: 258 return rewriteValuePPC64_OpLsh64x8(v, config) 259 case OpLsh8x16: 260 return rewriteValuePPC64_OpLsh8x16(v, config) 261 case OpLsh8x32: 262 return rewriteValuePPC64_OpLsh8x32(v, config) 263 case OpLsh8x64: 264 return rewriteValuePPC64_OpLsh8x64(v, config) 265 case OpLsh8x8: 266 return rewriteValuePPC64_OpLsh8x8(v, config) 267 case OpMod16: 268 return rewriteValuePPC64_OpMod16(v, config) 269 case OpMod16u: 270 return rewriteValuePPC64_OpMod16u(v, config) 271 case OpMod32: 272 return rewriteValuePPC64_OpMod32(v, config) 273 case OpMod32u: 274 return rewriteValuePPC64_OpMod32u(v, config) 275 case OpMod64: 276 return rewriteValuePPC64_OpMod64(v, config) 277 case OpMod64u: 278 return rewriteValuePPC64_OpMod64u(v, config) 279 case OpMod8: 280 return rewriteValuePPC64_OpMod8(v, config) 281 case OpMod8u: 282 return rewriteValuePPC64_OpMod8u(v, config) 283 case OpMove: 284 return rewriteValuePPC64_OpMove(v, config) 285 case OpMul16: 286 return rewriteValuePPC64_OpMul16(v, config) 287 case OpMul32: 288 return rewriteValuePPC64_OpMul32(v, config) 289 case OpMul32F: 290 return rewriteValuePPC64_OpMul32F(v, config) 291 case OpMul64: 292 return rewriteValuePPC64_OpMul64(v, config) 293 case OpMul64F: 294 return rewriteValuePPC64_OpMul64F(v, config) 295 case OpMul8: 296 return rewriteValuePPC64_OpMul8(v, config) 297 case OpNeg16: 298 return rewriteValuePPC64_OpNeg16(v, config) 299 case OpNeg32: 300 return rewriteValuePPC64_OpNeg32(v, config) 301 case OpNeg32F: 302 return rewriteValuePPC64_OpNeg32F(v, config) 303 case OpNeg64: 304 return rewriteValuePPC64_OpNeg64(v, config) 305 case OpNeg64F: 306 return rewriteValuePPC64_OpNeg64F(v, config) 307 case OpNeg8: 308 return rewriteValuePPC64_OpNeg8(v, config) 309 case OpNeq16: 310 return rewriteValuePPC64_OpNeq16(v, config) 311 case OpNeq32: 312 return rewriteValuePPC64_OpNeq32(v, config) 313 case OpNeq32F: 314 return rewriteValuePPC64_OpNeq32F(v, config) 315 case OpNeq64: 316 return rewriteValuePPC64_OpNeq64(v, config) 317 case OpNeq64F: 318 return rewriteValuePPC64_OpNeq64F(v, config) 319 case OpNeq8: 320 return rewriteValuePPC64_OpNeq8(v, config) 321 case OpNeqB: 322 return rewriteValuePPC64_OpNeqB(v, config) 323 case OpNeqPtr: 324 return rewriteValuePPC64_OpNeqPtr(v, config) 325 case OpNilCheck: 326 return rewriteValuePPC64_OpNilCheck(v, config) 327 case OpNot: 328 return rewriteValuePPC64_OpNot(v, config) 329 case OpOffPtr: 330 return rewriteValuePPC64_OpOffPtr(v, config) 331 case OpOr16: 332 return rewriteValuePPC64_OpOr16(v, config) 333 case OpOr32: 334 return rewriteValuePPC64_OpOr32(v, config) 335 case OpOr64: 336 return rewriteValuePPC64_OpOr64(v, config) 337 case OpOr8: 338 return rewriteValuePPC64_OpOr8(v, config) 339 case OpOrB: 340 return rewriteValuePPC64_OpOrB(v, config) 341 case OpPPC64ADD: 342 return rewriteValuePPC64_OpPPC64ADD(v, config) 343 case 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.Line, OpPPC64ADD, t) 781 v1 := b.NewValue0(v.Line, OpPPC64SRD, t) 782 v1.AddArg(x) 783 v2 := b.NewValue0(v.Line, OpPPC64MOVDconst, t) 784 v2.AuxInt = 1 785 v1.AddArg(v2) 786 v0.AddArg(v1) 787 v3 := b.NewValue0(v.Line, OpPPC64SRD, t) 788 v3.AddArg(y) 789 v4 := b.NewValue0(v.Line, OpPPC64MOVDconst, t) 790 v4.AuxInt = 1 791 v3.AddArg(v4) 792 v0.AddArg(v3) 793 v.AddArg(v0) 794 v5 := b.NewValue0(v.Line, OpPPC64ANDconst, t) 795 v5.AuxInt = 1 796 v6 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, OpPPC64FCFID, config.fe.TypeFloat64()) 1053 v1 := b.NewValue0(v.Line, OpPPC64Xi2f64, config.fe.TypeFloat64()) 1054 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64Xi2f64, config.fe.TypeFloat64()) 1072 v1 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, OpPPC64FCFID, config.fe.TypeFloat64()) 1132 v1 := b.NewValue0(v.Line, 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.Line, 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.Line, OpSignExt16to32, config.fe.TypeInt32()) 1180 v0.AddArg(x) 1181 v.AddArg(v0) 1182 v1 := b.NewValue0(v.Line, 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.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 1199 v0.AddArg(x) 1200 v.AddArg(v0) 1201 v1 := b.NewValue0(v.Line, 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.Line, OpSignExt8to32, config.fe.TypeInt32()) 1308 v0.AddArg(x) 1309 v.AddArg(v0) 1310 v1 := b.NewValue0(v.Line, 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.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 1327 v0.AddArg(x) 1328 v.AddArg(v0) 1329 v1 := b.NewValue0(v.Line, 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.Line, OpPPC64CMPW, TypeFlags) 1349 v1 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 1350 v1.AddArg(x) 1351 v0.AddArg(v1) 1352 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64CMPW, TypeFlags) 1366 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 1367 v1.AddArg(x) 1368 v0.AddArg(v1) 1369 v2 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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.Line, OpPPC64CMPW, TypeFlags) 1458 v1 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 1459 v1.AddArg(x) 1460 v0.AddArg(v1) 1461 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64CMPW, TypeFlags) 1475 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 1476 v1.AddArg(x) 1477 v0.AddArg(v1) 1478 v2 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, OpPPC64CMPW, TypeFlags) 1531 v1 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 1532 v1.AddArg(x) 1533 v0.AddArg(v1) 1534 v2 := b.NewValue0(v.Line, 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 (CMPWU (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.Line, OpPPC64CMPWU, TypeFlags) 1552 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 1553 v1.AddArg(x) 1554 v0.AddArg(v1) 1555 v2 := b.NewValue0(v.Line, 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.Line, 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.Line, 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 (CMPWU x y)) 1602 for { 1603 x := v.Args[0] 1604 y := v.Args[1] 1605 v.reset(OpPPC64GreaterEqual) 1606 v0 := b.NewValue0(v.Line, OpPPC64CMPWU, 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.Line, 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.Line, 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.Line, 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.Line, OpPPC64CMPW, TypeFlags) 1675 v1 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 1676 v1.AddArg(x) 1677 v0.AddArg(v1) 1678 v2 := b.NewValue0(v.Line, 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 (CMPWU (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.Line, OpPPC64CMPWU, TypeFlags) 1696 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 1697 v1.AddArg(x) 1698 v0.AddArg(v1) 1699 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64CMPW, TypeFlags) 1743 v1 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 1744 v1.AddArg(x) 1745 v0.AddArg(v1) 1746 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64CMPWU, TypeFlags) 1764 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 1765 v1.AddArg(x) 1766 v0.AddArg(v1) 1767 v2 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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.Line, OpPPC64CMPW, TypeFlags) 1887 v1 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 1888 v1.AddArg(x) 1889 v0.AddArg(v1) 1890 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64CMPWU, TypeFlags) 1908 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 1909 v1.AddArg(x) 1910 v0.AddArg(v1) 1911 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64MULLW, config.fe.TypeInt32()) 1930 v1 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 1931 v1.AddArg(x) 1932 v0.AddArg(v1) 1933 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64MULLW, config.fe.TypeUInt32()) 1952 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 1953 v1.AddArg(x) 1954 v0.AddArg(v1) 1955 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64MULLW, config.fe.TypeInt16()) 2034 v1 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 2035 v1.AddArg(x) 2036 v0.AddArg(v1) 2037 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64MULLW, config.fe.TypeUInt16()) 2056 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 2057 v1.AddArg(x) 2058 v0.AddArg(v1) 2059 v2 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, 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.Line, OpPPC64CMPW, TypeFlags) 2144 v1 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 2145 v1.AddArg(x) 2146 v0.AddArg(v1) 2147 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64CMPWU, TypeFlags) 2165 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 2166 v1.AddArg(x) 2167 v0.AddArg(v1) 2168 v2 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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.Line, OpPPC64CMPW, TypeFlags) 2288 v1 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 2289 v1.AddArg(x) 2290 v0.AddArg(v1) 2291 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64CMPWU, TypeFlags) 2309 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 2310 v1.AddArg(x) 2311 v0.AddArg(v1) 2312 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64CMPW, TypeFlags) 2330 v1 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 2331 v1.AddArg(x) 2332 v0.AddArg(v1) 2333 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64CMPWU, TypeFlags) 2351 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 2352 v1.AddArg(x) 2353 v0.AddArg(v1) 2354 v2 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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.Line, OpPPC64CMPW, TypeFlags) 2474 v1 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 2475 v1.AddArg(x) 2476 v0.AddArg(v1) 2477 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64CMPWU, TypeFlags) 2495 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 2496 v1.AddArg(x) 2497 v0.AddArg(v1) 2498 v2 := b.NewValue0(v.Line, 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.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 2674 v0.AddArg(y) 2675 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 2676 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 2677 v2.AuxInt = -16 2678 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 2735 v0.AddArg(y) 2736 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 2737 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 2738 v2.AuxInt = -16 2739 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 2812 v0.AddArg(y) 2813 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 2814 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 2835 v0.AddArg(y) 2836 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 2837 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 2838 v2.AuxInt = -16 2839 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 2860 v0.AddArg(y) 2861 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 2862 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 2863 v2.AuxInt = -32 2864 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 2921 v0.AddArg(y) 2922 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 2923 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 2924 v2.AuxInt = -32 2925 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 2998 v0.AddArg(y) 2999 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 3000 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 3021 v0.AddArg(y) 3022 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 3023 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 3024 v2.AuxInt = -32 3025 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 3046 v0.AddArg(y) 3047 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 3048 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 3049 v2.AuxInt = -64 3050 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 3107 v0.AddArg(y) 3108 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 3109 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 3110 v2.AuxInt = -64 3111 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 3184 v0.AddArg(y) 3185 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 3186 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 3207 v0.AddArg(y) 3208 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 3209 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 3210 v2.AuxInt = -64 3211 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 3232 v0.AddArg(y) 3233 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 3234 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 3235 v2.AuxInt = -8 3236 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 3293 v0.AddArg(y) 3294 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 3295 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 3296 v2.AuxInt = -8 3297 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 3370 v0.AddArg(y) 3371 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 3372 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 3393 v0.AddArg(y) 3394 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 3395 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 3396 v2.AuxInt = -8 3397 v3 := b.NewValue0(v.Line, 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.Line, OpSignExt16to32, config.fe.TypeInt32()) 3417 v0.AddArg(x) 3418 v.AddArg(v0) 3419 v1 := b.NewValue0(v.Line, 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.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 3436 v0.AddArg(x) 3437 v.AddArg(v0) 3438 v1 := b.NewValue0(v.Line, 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.Line, OpPPC64MULLW, config.fe.TypeInt32()) 3456 v0.AddArg(y) 3457 v1 := b.NewValue0(v.Line, 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.Line, OpPPC64MULLW, config.fe.TypeInt32()) 3477 v0.AddArg(y) 3478 v1 := b.NewValue0(v.Line, 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.Line, OpPPC64MULLD, config.fe.TypeInt64()) 3498 v0.AddArg(y) 3499 v1 := b.NewValue0(v.Line, 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.Line, OpPPC64MULLD, config.fe.TypeInt64()) 3519 v0.AddArg(y) 3520 v1 := b.NewValue0(v.Line, 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.Line, OpSignExt8to32, config.fe.TypeInt32()) 3539 v0.AddArg(x) 3540 v.AddArg(v0) 3541 v1 := b.NewValue0(v.Line, 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.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 3558 v0.AddArg(x) 3559 v.AddArg(v0) 3560 v1 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, 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.Line, OpPPC64MOVBstore, TypeMem) 3643 v1.AddArg(dst) 3644 v2 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, OpPPC64MOVHstore, TypeMem) 3692 v1.AddArg(dst) 3693 v2 := b.NewValue0(v.Line, 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.Line, 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.Line, OpPPC64MOVBstore, TypeMem) 3721 v1.AuxInt = 2 3722 v1.AddArg(dst) 3723 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64MOVBstore, TypeMem) 3729 v3.AuxInt = 1 3730 v3.AddArg(dst) 3731 v4 := b.NewValue0(v.Line, 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.Line, OpPPC64MOVBstore, TypeMem) 3737 v5.AddArg(dst) 3738 v6 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, OpPPC64MOVWstore, TypeMem) 3788 v1.AddArg(dst) 3789 v2 := b.NewValue0(v.Line, 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.Line, 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.Line, OpPPC64MOVHstore, TypeMem) 3817 v1.AuxInt = 4 3818 v1.AddArg(dst) 3819 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64MOVHstore, TypeMem) 3825 v3.AuxInt = 2 3826 v3.AddArg(dst) 3827 v4 := b.NewValue0(v.Line, 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.Line, OpPPC64MOVHstore, TypeMem) 3833 v5.AddArg(dst) 3834 v6 := b.NewValue0(v.Line, 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.Line, 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.Line, OpPPC64MOVBstore, TypeMem) 3864 v1.AuxInt = 1 3865 v1.AddArg(dst) 3866 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64MOVBstore, TypeMem) 3872 v3.AddArg(dst) 3873 v4 := b.NewValue0(v.Line, 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.Line, 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.Line, OpPPC64CMPW, TypeFlags) 4088 v1 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 4089 v1.AddArg(x) 4090 v0.AddArg(v1) 4091 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64CMPW, TypeFlags) 4105 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 4106 v1.AddArg(x) 4107 v0.AddArg(v1) 4108 v2 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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.Line, OpPPC64CMPW, TypeFlags) 4197 v1 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 4198 v1.AddArg(x) 4199 v0.AddArg(v1) 4200 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64CMPW, TypeFlags) 4214 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 4215 v1.AddArg(x) 4216 v0.AddArg(v1) 4217 v2 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 7451 v0.AddArg(x) 7452 v.AddArg(v0) 7453 v1 := b.NewValue0(v.Line, OpPPC64ORN, config.fe.TypeInt64()) 7454 v1.AddArg(y) 7455 v2 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 7456 v3 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 7457 v3.AuxInt = -16 7458 v4 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 7518 v0.AddArg(x) 7519 v.AddArg(v0) 7520 v1 := b.NewValue0(v.Line, OpPPC64ORN, config.fe.TypeInt64()) 7521 v1.AddArg(y) 7522 v2 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 7523 v3 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 7524 v3.AuxInt = -16 7525 v4 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 7601 v0.AddArg(x) 7602 v.AddArg(v0) 7603 v1 := b.NewValue0(v.Line, OpPPC64ORN, config.fe.TypeInt64()) 7604 v1.AddArg(y) 7605 v2 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 7606 v3 := b.NewValue0(v.Line, 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.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 7626 v0.AddArg(x) 7627 v.AddArg(v0) 7628 v1 := b.NewValue0(v.Line, OpPPC64ORN, config.fe.TypeInt64()) 7629 v1.AddArg(y) 7630 v2 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 7631 v3 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 7632 v3.AuxInt = -16 7633 v4 := b.NewValue0(v.Line, 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.Line, OpSignExt16to32, config.fe.TypeInt32()) 7653 v0.AddArg(x) 7654 v.AddArg(v0) 7655 v1 := b.NewValue0(v.Line, OpPPC64ORN, config.fe.TypeInt64()) 7656 v1.AddArg(y) 7657 v2 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 7658 v3 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 7659 v3.AuxInt = -16 7660 v4 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, OpSignExt16to32, config.fe.TypeInt32()) 7720 v0.AddArg(x) 7721 v.AddArg(v0) 7722 v1 := b.NewValue0(v.Line, OpPPC64ORN, config.fe.TypeInt64()) 7723 v1.AddArg(y) 7724 v2 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 7725 v3 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 7726 v3.AuxInt = -16 7727 v4 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, 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.Line, OpSignExt16to32, config.fe.TypeInt32()) 7807 v0.AddArg(x) 7808 v.AddArg(v0) 7809 v1 := b.NewValue0(v.Line, OpPPC64ORN, config.fe.TypeInt64()) 7810 v1.AddArg(y) 7811 v2 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 7812 v3 := b.NewValue0(v.Line, 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.Line, OpSignExt16to32, config.fe.TypeInt32()) 7832 v0.AddArg(x) 7833 v.AddArg(v0) 7834 v1 := b.NewValue0(v.Line, OpPPC64ORN, config.fe.TypeInt64()) 7835 v1.AddArg(y) 7836 v2 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 7837 v3 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 7838 v3.AuxInt = -16 7839 v4 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 7860 v0.AddArg(y) 7861 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 7862 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 7863 v2.AuxInt = -32 7864 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 7921 v0.AddArg(y) 7922 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 7923 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 7924 v2.AuxInt = -32 7925 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 7998 v0.AddArg(y) 7999 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8000 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 8021 v0.AddArg(y) 8022 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8023 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 8024 v2.AuxInt = -32 8025 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 8046 v0.AddArg(y) 8047 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8048 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 8049 v2.AuxInt = -32 8050 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 8107 v0.AddArg(y) 8108 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8109 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 8110 v2.AuxInt = -32 8111 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 8186 v0.AddArg(y) 8187 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8188 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 8209 v0.AddArg(y) 8210 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8211 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 8212 v2.AuxInt = -32 8213 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 8234 v0.AddArg(y) 8235 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8236 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 8237 v2.AuxInt = -64 8238 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 8295 v0.AddArg(y) 8296 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8297 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 8298 v2.AuxInt = -64 8299 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 8372 v0.AddArg(y) 8373 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8374 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 8395 v0.AddArg(y) 8396 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8397 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 8398 v2.AuxInt = -64 8399 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 8420 v0.AddArg(y) 8421 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8422 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 8423 v2.AuxInt = -64 8424 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 8481 v0.AddArg(y) 8482 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8483 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 8484 v2.AuxInt = -64 8485 v3 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 8560 v0.AddArg(y) 8561 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8562 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64ORN, config.fe.TypeInt64()) 8583 v0.AddArg(y) 8584 v1 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8585 v2 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 8586 v2.AuxInt = -64 8587 v3 := b.NewValue0(v.Line, 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.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 8607 v0.AddArg(x) 8608 v.AddArg(v0) 8609 v1 := b.NewValue0(v.Line, OpPPC64ORN, config.fe.TypeInt64()) 8610 v1.AddArg(y) 8611 v2 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8612 v3 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 8613 v3.AuxInt = -8 8614 v4 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 8674 v0.AddArg(x) 8675 v.AddArg(v0) 8676 v1 := b.NewValue0(v.Line, OpPPC64ORN, config.fe.TypeInt64()) 8677 v1.AddArg(y) 8678 v2 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8679 v3 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 8680 v3.AuxInt = -8 8681 v4 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 8757 v0.AddArg(x) 8758 v.AddArg(v0) 8759 v1 := b.NewValue0(v.Line, OpPPC64ORN, config.fe.TypeInt64()) 8760 v1.AddArg(y) 8761 v2 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8762 v3 := b.NewValue0(v.Line, 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.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 8782 v0.AddArg(x) 8783 v.AddArg(v0) 8784 v1 := b.NewValue0(v.Line, OpPPC64ORN, config.fe.TypeInt64()) 8785 v1.AddArg(y) 8786 v2 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8787 v3 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 8788 v3.AuxInt = -8 8789 v4 := b.NewValue0(v.Line, 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.Line, OpSignExt8to32, config.fe.TypeInt32()) 8809 v0.AddArg(x) 8810 v.AddArg(v0) 8811 v1 := b.NewValue0(v.Line, OpPPC64ORN, config.fe.TypeInt64()) 8812 v1.AddArg(y) 8813 v2 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8814 v3 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 8815 v3.AuxInt = -8 8816 v4 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, OpSignExt8to32, config.fe.TypeInt32()) 8876 v0.AddArg(x) 8877 v.AddArg(v0) 8878 v1 := b.NewValue0(v.Line, OpPPC64ORN, config.fe.TypeInt64()) 8879 v1.AddArg(y) 8880 v2 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8881 v3 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 8882 v3.AuxInt = -8 8883 v4 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, 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.Line, OpSignExt8to32, config.fe.TypeInt32()) 8963 v0.AddArg(x) 8964 v.AddArg(v0) 8965 v1 := b.NewValue0(v.Line, OpPPC64ORN, config.fe.TypeInt64()) 8966 v1.AddArg(y) 8967 v2 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8968 v3 := b.NewValue0(v.Line, 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.Line, OpSignExt8to32, config.fe.TypeInt32()) 8988 v0.AddArg(x) 8989 v.AddArg(v0) 8990 v1 := b.NewValue0(v.Line, OpPPC64ORN, config.fe.TypeInt64()) 8991 v1.AddArg(y) 8992 v2 := b.NewValue0(v.Line, OpPPC64MaskIfNotCarry, config.fe.TypeInt64()) 8993 v3 := b.NewValue0(v.Line, OpPPC64ADDconstForCarry, TypeFlags) 8994 v3.AuxInt = -8 8995 v4 := b.NewValue0(v.Line, 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.Line, OpPPC64SRADconst, t) 9094 v0.AuxInt = 63 9095 v1 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, OpPPC64MOVBstorezero, TypeMem) 9624 v0.AuxInt = 2 9625 v0.AddArg(destptr) 9626 v1 := b.NewValue0(v.Line, OpPPC64MOVBstorezero, TypeMem) 9627 v1.AuxInt = 1 9628 v1.AddArg(destptr) 9629 v2 := b.NewValue0(v.Line, 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.Line, 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.Line, OpPPC64MOVHstorezero, TypeMem) 9688 v0.AuxInt = 4 9689 v0.AddArg(destptr) 9690 v1 := b.NewValue0(v.Line, OpPPC64MOVHstorezero, TypeMem) 9691 v1.AuxInt = 2 9692 v1.AddArg(destptr) 9693 v2 := b.NewValue0(v.Line, 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.Line, OpPPC64MOVBstorezero, TypeMem) 9716 v0.AuxInt = 1 9717 v0.AddArg(destptr) 9718 v1 := b.NewValue0(v.Line, 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.Line, 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.Line, OpPPC64MOVDstorezero, TypeMem) 9760 v0.AuxInt = 8 9761 v0.AddArg(destptr) 9762 v1 := b.NewValue0(v.Line, 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.Line, OpPPC64MOVDstorezero, TypeMem) 9784 v0.AuxInt = 16 9785 v0.AddArg(destptr) 9786 v1 := b.NewValue0(v.Line, OpPPC64MOVDstorezero, TypeMem) 9787 v1.AuxInt = 8 9788 v1.AddArg(destptr) 9789 v2 := b.NewValue0(v.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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.Line, 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 }