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