github.com/eun/go@v0.0.0-20170811110501-92cfd07a6cfd/src/cmd/compile/internal/ssa/rewritegeneric.go (about) 1 // Code generated from gen/generic.rules; DO NOT EDIT. 2 // generated with: cd gen; go run *.go 3 4 package ssa 5 6 import "math" 7 import "cmd/internal/obj" 8 import "cmd/internal/objabi" 9 import "cmd/compile/internal/types" 10 11 var _ = math.MinInt8 // in case not otherwise used 12 var _ = obj.ANOP // in case not otherwise used 13 var _ = objabi.GOROOT // in case not otherwise used 14 var _ = types.TypeMem // in case not otherwise used 15 16 func rewriteValuegeneric(v *Value) bool { 17 switch v.Op { 18 case OpAdd16: 19 return rewriteValuegeneric_OpAdd16_0(v) || rewriteValuegeneric_OpAdd16_10(v) || rewriteValuegeneric_OpAdd16_20(v) 20 case OpAdd32: 21 return rewriteValuegeneric_OpAdd32_0(v) || rewriteValuegeneric_OpAdd32_10(v) || rewriteValuegeneric_OpAdd32_20(v) 22 case OpAdd32F: 23 return rewriteValuegeneric_OpAdd32F_0(v) 24 case OpAdd64: 25 return rewriteValuegeneric_OpAdd64_0(v) || rewriteValuegeneric_OpAdd64_10(v) || rewriteValuegeneric_OpAdd64_20(v) 26 case OpAdd64F: 27 return rewriteValuegeneric_OpAdd64F_0(v) 28 case OpAdd8: 29 return rewriteValuegeneric_OpAdd8_0(v) || rewriteValuegeneric_OpAdd8_10(v) || rewriteValuegeneric_OpAdd8_20(v) 30 case OpAddPtr: 31 return rewriteValuegeneric_OpAddPtr_0(v) 32 case OpAnd16: 33 return rewriteValuegeneric_OpAnd16_0(v) || rewriteValuegeneric_OpAnd16_10(v) 34 case OpAnd32: 35 return rewriteValuegeneric_OpAnd32_0(v) || rewriteValuegeneric_OpAnd32_10(v) 36 case OpAnd64: 37 return rewriteValuegeneric_OpAnd64_0(v) || rewriteValuegeneric_OpAnd64_10(v) || rewriteValuegeneric_OpAnd64_20(v) 38 case OpAnd8: 39 return rewriteValuegeneric_OpAnd8_0(v) || rewriteValuegeneric_OpAnd8_10(v) 40 case OpArg: 41 return rewriteValuegeneric_OpArg_0(v) || rewriteValuegeneric_OpArg_10(v) 42 case OpArraySelect: 43 return rewriteValuegeneric_OpArraySelect_0(v) 44 case OpCom16: 45 return rewriteValuegeneric_OpCom16_0(v) 46 case OpCom32: 47 return rewriteValuegeneric_OpCom32_0(v) 48 case OpCom64: 49 return rewriteValuegeneric_OpCom64_0(v) 50 case OpCom8: 51 return rewriteValuegeneric_OpCom8_0(v) 52 case OpConstInterface: 53 return rewriteValuegeneric_OpConstInterface_0(v) 54 case OpConstSlice: 55 return rewriteValuegeneric_OpConstSlice_0(v) 56 case OpConstString: 57 return rewriteValuegeneric_OpConstString_0(v) 58 case OpConvert: 59 return rewriteValuegeneric_OpConvert_0(v) 60 case OpCvt32Fto64F: 61 return rewriteValuegeneric_OpCvt32Fto64F_0(v) 62 case OpCvt64Fto32F: 63 return rewriteValuegeneric_OpCvt64Fto32F_0(v) 64 case OpDiv16: 65 return rewriteValuegeneric_OpDiv16_0(v) 66 case OpDiv16u: 67 return rewriteValuegeneric_OpDiv16u_0(v) 68 case OpDiv32: 69 return rewriteValuegeneric_OpDiv32_0(v) 70 case OpDiv32F: 71 return rewriteValuegeneric_OpDiv32F_0(v) 72 case OpDiv32u: 73 return rewriteValuegeneric_OpDiv32u_0(v) 74 case OpDiv64: 75 return rewriteValuegeneric_OpDiv64_0(v) 76 case OpDiv64F: 77 return rewriteValuegeneric_OpDiv64F_0(v) 78 case OpDiv64u: 79 return rewriteValuegeneric_OpDiv64u_0(v) 80 case OpDiv8: 81 return rewriteValuegeneric_OpDiv8_0(v) 82 case OpDiv8u: 83 return rewriteValuegeneric_OpDiv8u_0(v) 84 case OpEq16: 85 return rewriteValuegeneric_OpEq16_0(v) 86 case OpEq32: 87 return rewriteValuegeneric_OpEq32_0(v) 88 case OpEq64: 89 return rewriteValuegeneric_OpEq64_0(v) 90 case OpEq8: 91 return rewriteValuegeneric_OpEq8_0(v) 92 case OpEqB: 93 return rewriteValuegeneric_OpEqB_0(v) 94 case OpEqInter: 95 return rewriteValuegeneric_OpEqInter_0(v) 96 case OpEqPtr: 97 return rewriteValuegeneric_OpEqPtr_0(v) 98 case OpEqSlice: 99 return rewriteValuegeneric_OpEqSlice_0(v) 100 case OpGeq16: 101 return rewriteValuegeneric_OpGeq16_0(v) 102 case OpGeq16U: 103 return rewriteValuegeneric_OpGeq16U_0(v) 104 case OpGeq32: 105 return rewriteValuegeneric_OpGeq32_0(v) 106 case OpGeq32U: 107 return rewriteValuegeneric_OpGeq32U_0(v) 108 case OpGeq64: 109 return rewriteValuegeneric_OpGeq64_0(v) 110 case OpGeq64U: 111 return rewriteValuegeneric_OpGeq64U_0(v) 112 case OpGeq8: 113 return rewriteValuegeneric_OpGeq8_0(v) 114 case OpGeq8U: 115 return rewriteValuegeneric_OpGeq8U_0(v) 116 case OpGreater16: 117 return rewriteValuegeneric_OpGreater16_0(v) 118 case OpGreater16U: 119 return rewriteValuegeneric_OpGreater16U_0(v) 120 case OpGreater32: 121 return rewriteValuegeneric_OpGreater32_0(v) 122 case OpGreater32U: 123 return rewriteValuegeneric_OpGreater32U_0(v) 124 case OpGreater64: 125 return rewriteValuegeneric_OpGreater64_0(v) 126 case OpGreater64U: 127 return rewriteValuegeneric_OpGreater64U_0(v) 128 case OpGreater8: 129 return rewriteValuegeneric_OpGreater8_0(v) 130 case OpGreater8U: 131 return rewriteValuegeneric_OpGreater8U_0(v) 132 case OpIMake: 133 return rewriteValuegeneric_OpIMake_0(v) 134 case OpInterCall: 135 return rewriteValuegeneric_OpInterCall_0(v) 136 case OpIsInBounds: 137 return rewriteValuegeneric_OpIsInBounds_0(v) || rewriteValuegeneric_OpIsInBounds_10(v) || rewriteValuegeneric_OpIsInBounds_20(v) || rewriteValuegeneric_OpIsInBounds_30(v) 138 case OpIsNonNil: 139 return rewriteValuegeneric_OpIsNonNil_0(v) 140 case OpIsSliceInBounds: 141 return rewriteValuegeneric_OpIsSliceInBounds_0(v) 142 case OpLeq16: 143 return rewriteValuegeneric_OpLeq16_0(v) 144 case OpLeq16U: 145 return rewriteValuegeneric_OpLeq16U_0(v) 146 case OpLeq32: 147 return rewriteValuegeneric_OpLeq32_0(v) 148 case OpLeq32U: 149 return rewriteValuegeneric_OpLeq32U_0(v) 150 case OpLeq64: 151 return rewriteValuegeneric_OpLeq64_0(v) 152 case OpLeq64U: 153 return rewriteValuegeneric_OpLeq64U_0(v) 154 case OpLeq8: 155 return rewriteValuegeneric_OpLeq8_0(v) 156 case OpLeq8U: 157 return rewriteValuegeneric_OpLeq8U_0(v) 158 case OpLess16: 159 return rewriteValuegeneric_OpLess16_0(v) 160 case OpLess16U: 161 return rewriteValuegeneric_OpLess16U_0(v) 162 case OpLess32: 163 return rewriteValuegeneric_OpLess32_0(v) 164 case OpLess32U: 165 return rewriteValuegeneric_OpLess32U_0(v) 166 case OpLess64: 167 return rewriteValuegeneric_OpLess64_0(v) 168 case OpLess64U: 169 return rewriteValuegeneric_OpLess64U_0(v) 170 case OpLess8: 171 return rewriteValuegeneric_OpLess8_0(v) 172 case OpLess8U: 173 return rewriteValuegeneric_OpLess8U_0(v) 174 case OpLoad: 175 return rewriteValuegeneric_OpLoad_0(v) 176 case OpLsh16x16: 177 return rewriteValuegeneric_OpLsh16x16_0(v) 178 case OpLsh16x32: 179 return rewriteValuegeneric_OpLsh16x32_0(v) 180 case OpLsh16x64: 181 return rewriteValuegeneric_OpLsh16x64_0(v) 182 case OpLsh16x8: 183 return rewriteValuegeneric_OpLsh16x8_0(v) 184 case OpLsh32x16: 185 return rewriteValuegeneric_OpLsh32x16_0(v) 186 case OpLsh32x32: 187 return rewriteValuegeneric_OpLsh32x32_0(v) 188 case OpLsh32x64: 189 return rewriteValuegeneric_OpLsh32x64_0(v) 190 case OpLsh32x8: 191 return rewriteValuegeneric_OpLsh32x8_0(v) 192 case OpLsh64x16: 193 return rewriteValuegeneric_OpLsh64x16_0(v) 194 case OpLsh64x32: 195 return rewriteValuegeneric_OpLsh64x32_0(v) 196 case OpLsh64x64: 197 return rewriteValuegeneric_OpLsh64x64_0(v) 198 case OpLsh64x8: 199 return rewriteValuegeneric_OpLsh64x8_0(v) 200 case OpLsh8x16: 201 return rewriteValuegeneric_OpLsh8x16_0(v) 202 case OpLsh8x32: 203 return rewriteValuegeneric_OpLsh8x32_0(v) 204 case OpLsh8x64: 205 return rewriteValuegeneric_OpLsh8x64_0(v) 206 case OpLsh8x8: 207 return rewriteValuegeneric_OpLsh8x8_0(v) 208 case OpMod16: 209 return rewriteValuegeneric_OpMod16_0(v) 210 case OpMod16u: 211 return rewriteValuegeneric_OpMod16u_0(v) 212 case OpMod32: 213 return rewriteValuegeneric_OpMod32_0(v) 214 case OpMod32u: 215 return rewriteValuegeneric_OpMod32u_0(v) 216 case OpMod64: 217 return rewriteValuegeneric_OpMod64_0(v) 218 case OpMod64u: 219 return rewriteValuegeneric_OpMod64u_0(v) 220 case OpMod8: 221 return rewriteValuegeneric_OpMod8_0(v) 222 case OpMod8u: 223 return rewriteValuegeneric_OpMod8u_0(v) 224 case OpMul16: 225 return rewriteValuegeneric_OpMul16_0(v) || rewriteValuegeneric_OpMul16_10(v) 226 case OpMul32: 227 return rewriteValuegeneric_OpMul32_0(v) || rewriteValuegeneric_OpMul32_10(v) 228 case OpMul32F: 229 return rewriteValuegeneric_OpMul32F_0(v) 230 case OpMul64: 231 return rewriteValuegeneric_OpMul64_0(v) || rewriteValuegeneric_OpMul64_10(v) 232 case OpMul64F: 233 return rewriteValuegeneric_OpMul64F_0(v) 234 case OpMul8: 235 return rewriteValuegeneric_OpMul8_0(v) || rewriteValuegeneric_OpMul8_10(v) 236 case OpNeg16: 237 return rewriteValuegeneric_OpNeg16_0(v) 238 case OpNeg32: 239 return rewriteValuegeneric_OpNeg32_0(v) 240 case OpNeg32F: 241 return rewriteValuegeneric_OpNeg32F_0(v) 242 case OpNeg64: 243 return rewriteValuegeneric_OpNeg64_0(v) 244 case OpNeg64F: 245 return rewriteValuegeneric_OpNeg64F_0(v) 246 case OpNeg8: 247 return rewriteValuegeneric_OpNeg8_0(v) 248 case OpNeq16: 249 return rewriteValuegeneric_OpNeq16_0(v) 250 case OpNeq32: 251 return rewriteValuegeneric_OpNeq32_0(v) 252 case OpNeq64: 253 return rewriteValuegeneric_OpNeq64_0(v) 254 case OpNeq8: 255 return rewriteValuegeneric_OpNeq8_0(v) 256 case OpNeqB: 257 return rewriteValuegeneric_OpNeqB_0(v) 258 case OpNeqInter: 259 return rewriteValuegeneric_OpNeqInter_0(v) 260 case OpNeqPtr: 261 return rewriteValuegeneric_OpNeqPtr_0(v) 262 case OpNeqSlice: 263 return rewriteValuegeneric_OpNeqSlice_0(v) 264 case OpNilCheck: 265 return rewriteValuegeneric_OpNilCheck_0(v) 266 case OpNot: 267 return rewriteValuegeneric_OpNot_0(v) || rewriteValuegeneric_OpNot_10(v) || rewriteValuegeneric_OpNot_20(v) || rewriteValuegeneric_OpNot_30(v) || rewriteValuegeneric_OpNot_40(v) 268 case OpOffPtr: 269 return rewriteValuegeneric_OpOffPtr_0(v) 270 case OpOr16: 271 return rewriteValuegeneric_OpOr16_0(v) || rewriteValuegeneric_OpOr16_10(v) || rewriteValuegeneric_OpOr16_20(v) 272 case OpOr32: 273 return rewriteValuegeneric_OpOr32_0(v) || rewriteValuegeneric_OpOr32_10(v) || rewriteValuegeneric_OpOr32_20(v) 274 case OpOr64: 275 return rewriteValuegeneric_OpOr64_0(v) || rewriteValuegeneric_OpOr64_10(v) || rewriteValuegeneric_OpOr64_20(v) 276 case OpOr8: 277 return rewriteValuegeneric_OpOr8_0(v) || rewriteValuegeneric_OpOr8_10(v) || rewriteValuegeneric_OpOr8_20(v) 278 case OpPhi: 279 return rewriteValuegeneric_OpPhi_0(v) 280 case OpPtrIndex: 281 return rewriteValuegeneric_OpPtrIndex_0(v) 282 case OpRound32F: 283 return rewriteValuegeneric_OpRound32F_0(v) 284 case OpRound64F: 285 return rewriteValuegeneric_OpRound64F_0(v) 286 case OpRsh16Ux16: 287 return rewriteValuegeneric_OpRsh16Ux16_0(v) 288 case OpRsh16Ux32: 289 return rewriteValuegeneric_OpRsh16Ux32_0(v) 290 case OpRsh16Ux64: 291 return rewriteValuegeneric_OpRsh16Ux64_0(v) 292 case OpRsh16Ux8: 293 return rewriteValuegeneric_OpRsh16Ux8_0(v) 294 case OpRsh16x16: 295 return rewriteValuegeneric_OpRsh16x16_0(v) 296 case OpRsh16x32: 297 return rewriteValuegeneric_OpRsh16x32_0(v) 298 case OpRsh16x64: 299 return rewriteValuegeneric_OpRsh16x64_0(v) 300 case OpRsh16x8: 301 return rewriteValuegeneric_OpRsh16x8_0(v) 302 case OpRsh32Ux16: 303 return rewriteValuegeneric_OpRsh32Ux16_0(v) 304 case OpRsh32Ux32: 305 return rewriteValuegeneric_OpRsh32Ux32_0(v) 306 case OpRsh32Ux64: 307 return rewriteValuegeneric_OpRsh32Ux64_0(v) 308 case OpRsh32Ux8: 309 return rewriteValuegeneric_OpRsh32Ux8_0(v) 310 case OpRsh32x16: 311 return rewriteValuegeneric_OpRsh32x16_0(v) 312 case OpRsh32x32: 313 return rewriteValuegeneric_OpRsh32x32_0(v) 314 case OpRsh32x64: 315 return rewriteValuegeneric_OpRsh32x64_0(v) 316 case OpRsh32x8: 317 return rewriteValuegeneric_OpRsh32x8_0(v) 318 case OpRsh64Ux16: 319 return rewriteValuegeneric_OpRsh64Ux16_0(v) 320 case OpRsh64Ux32: 321 return rewriteValuegeneric_OpRsh64Ux32_0(v) 322 case OpRsh64Ux64: 323 return rewriteValuegeneric_OpRsh64Ux64_0(v) 324 case OpRsh64Ux8: 325 return rewriteValuegeneric_OpRsh64Ux8_0(v) 326 case OpRsh64x16: 327 return rewriteValuegeneric_OpRsh64x16_0(v) 328 case OpRsh64x32: 329 return rewriteValuegeneric_OpRsh64x32_0(v) 330 case OpRsh64x64: 331 return rewriteValuegeneric_OpRsh64x64_0(v) 332 case OpRsh64x8: 333 return rewriteValuegeneric_OpRsh64x8_0(v) 334 case OpRsh8Ux16: 335 return rewriteValuegeneric_OpRsh8Ux16_0(v) 336 case OpRsh8Ux32: 337 return rewriteValuegeneric_OpRsh8Ux32_0(v) 338 case OpRsh8Ux64: 339 return rewriteValuegeneric_OpRsh8Ux64_0(v) 340 case OpRsh8Ux8: 341 return rewriteValuegeneric_OpRsh8Ux8_0(v) 342 case OpRsh8x16: 343 return rewriteValuegeneric_OpRsh8x16_0(v) 344 case OpRsh8x32: 345 return rewriteValuegeneric_OpRsh8x32_0(v) 346 case OpRsh8x64: 347 return rewriteValuegeneric_OpRsh8x64_0(v) 348 case OpRsh8x8: 349 return rewriteValuegeneric_OpRsh8x8_0(v) 350 case OpSignExt16to32: 351 return rewriteValuegeneric_OpSignExt16to32_0(v) 352 case OpSignExt16to64: 353 return rewriteValuegeneric_OpSignExt16to64_0(v) 354 case OpSignExt32to64: 355 return rewriteValuegeneric_OpSignExt32to64_0(v) 356 case OpSignExt8to16: 357 return rewriteValuegeneric_OpSignExt8to16_0(v) 358 case OpSignExt8to32: 359 return rewriteValuegeneric_OpSignExt8to32_0(v) 360 case OpSignExt8to64: 361 return rewriteValuegeneric_OpSignExt8to64_0(v) 362 case OpSliceCap: 363 return rewriteValuegeneric_OpSliceCap_0(v) 364 case OpSliceLen: 365 return rewriteValuegeneric_OpSliceLen_0(v) 366 case OpSlicePtr: 367 return rewriteValuegeneric_OpSlicePtr_0(v) 368 case OpSlicemask: 369 return rewriteValuegeneric_OpSlicemask_0(v) 370 case OpSqrt: 371 return rewriteValuegeneric_OpSqrt_0(v) 372 case OpStore: 373 return rewriteValuegeneric_OpStore_0(v) || rewriteValuegeneric_OpStore_10(v) 374 case OpStringLen: 375 return rewriteValuegeneric_OpStringLen_0(v) 376 case OpStringPtr: 377 return rewriteValuegeneric_OpStringPtr_0(v) 378 case OpStructSelect: 379 return rewriteValuegeneric_OpStructSelect_0(v) || rewriteValuegeneric_OpStructSelect_10(v) 380 case OpSub16: 381 return rewriteValuegeneric_OpSub16_0(v) || rewriteValuegeneric_OpSub16_10(v) 382 case OpSub32: 383 return rewriteValuegeneric_OpSub32_0(v) || rewriteValuegeneric_OpSub32_10(v) 384 case OpSub32F: 385 return rewriteValuegeneric_OpSub32F_0(v) 386 case OpSub64: 387 return rewriteValuegeneric_OpSub64_0(v) || rewriteValuegeneric_OpSub64_10(v) 388 case OpSub64F: 389 return rewriteValuegeneric_OpSub64F_0(v) 390 case OpSub8: 391 return rewriteValuegeneric_OpSub8_0(v) || rewriteValuegeneric_OpSub8_10(v) 392 case OpTrunc16to8: 393 return rewriteValuegeneric_OpTrunc16to8_0(v) 394 case OpTrunc32to16: 395 return rewriteValuegeneric_OpTrunc32to16_0(v) 396 case OpTrunc32to8: 397 return rewriteValuegeneric_OpTrunc32to8_0(v) 398 case OpTrunc64to16: 399 return rewriteValuegeneric_OpTrunc64to16_0(v) 400 case OpTrunc64to32: 401 return rewriteValuegeneric_OpTrunc64to32_0(v) 402 case OpTrunc64to8: 403 return rewriteValuegeneric_OpTrunc64to8_0(v) 404 case OpXor16: 405 return rewriteValuegeneric_OpXor16_0(v) || rewriteValuegeneric_OpXor16_10(v) 406 case OpXor32: 407 return rewriteValuegeneric_OpXor32_0(v) || rewriteValuegeneric_OpXor32_10(v) 408 case OpXor64: 409 return rewriteValuegeneric_OpXor64_0(v) || rewriteValuegeneric_OpXor64_10(v) 410 case OpXor8: 411 return rewriteValuegeneric_OpXor8_0(v) || rewriteValuegeneric_OpXor8_10(v) 412 case OpZero: 413 return rewriteValuegeneric_OpZero_0(v) 414 case OpZeroExt16to32: 415 return rewriteValuegeneric_OpZeroExt16to32_0(v) 416 case OpZeroExt16to64: 417 return rewriteValuegeneric_OpZeroExt16to64_0(v) 418 case OpZeroExt32to64: 419 return rewriteValuegeneric_OpZeroExt32to64_0(v) 420 case OpZeroExt8to16: 421 return rewriteValuegeneric_OpZeroExt8to16_0(v) 422 case OpZeroExt8to32: 423 return rewriteValuegeneric_OpZeroExt8to32_0(v) 424 case OpZeroExt8to64: 425 return rewriteValuegeneric_OpZeroExt8to64_0(v) 426 } 427 return false 428 } 429 func rewriteValuegeneric_OpAdd16_0(v *Value) bool { 430 b := v.Block 431 _ = b 432 // match: (Add16 (Const16 [c]) (Const16 [d])) 433 // cond: 434 // result: (Const16 [int64(int16(c+d))]) 435 for { 436 _ = v.Args[1] 437 v_0 := v.Args[0] 438 if v_0.Op != OpConst16 { 439 break 440 } 441 c := v_0.AuxInt 442 v_1 := v.Args[1] 443 if v_1.Op != OpConst16 { 444 break 445 } 446 d := v_1.AuxInt 447 v.reset(OpConst16) 448 v.AuxInt = int64(int16(c + d)) 449 return true 450 } 451 // match: (Add16 (Const16 [d]) (Const16 [c])) 452 // cond: 453 // result: (Const16 [int64(int16(c+d))]) 454 for { 455 _ = v.Args[1] 456 v_0 := v.Args[0] 457 if v_0.Op != OpConst16 { 458 break 459 } 460 d := v_0.AuxInt 461 v_1 := v.Args[1] 462 if v_1.Op != OpConst16 { 463 break 464 } 465 c := v_1.AuxInt 466 v.reset(OpConst16) 467 v.AuxInt = int64(int16(c + d)) 468 return true 469 } 470 // match: (Add16 (Const16 [0]) x) 471 // cond: 472 // result: x 473 for { 474 _ = v.Args[1] 475 v_0 := v.Args[0] 476 if v_0.Op != OpConst16 { 477 break 478 } 479 if v_0.AuxInt != 0 { 480 break 481 } 482 x := v.Args[1] 483 v.reset(OpCopy) 484 v.Type = x.Type 485 v.AddArg(x) 486 return true 487 } 488 // match: (Add16 x (Const16 [0])) 489 // cond: 490 // result: x 491 for { 492 _ = v.Args[1] 493 x := v.Args[0] 494 v_1 := v.Args[1] 495 if v_1.Op != OpConst16 { 496 break 497 } 498 if v_1.AuxInt != 0 { 499 break 500 } 501 v.reset(OpCopy) 502 v.Type = x.Type 503 v.AddArg(x) 504 return true 505 } 506 // match: (Add16 (Const16 [1]) (Com16 x)) 507 // cond: 508 // result: (Neg16 x) 509 for { 510 _ = v.Args[1] 511 v_0 := v.Args[0] 512 if v_0.Op != OpConst16 { 513 break 514 } 515 if v_0.AuxInt != 1 { 516 break 517 } 518 v_1 := v.Args[1] 519 if v_1.Op != OpCom16 { 520 break 521 } 522 x := v_1.Args[0] 523 v.reset(OpNeg16) 524 v.AddArg(x) 525 return true 526 } 527 // match: (Add16 (Com16 x) (Const16 [1])) 528 // cond: 529 // result: (Neg16 x) 530 for { 531 _ = v.Args[1] 532 v_0 := v.Args[0] 533 if v_0.Op != OpCom16 { 534 break 535 } 536 x := v_0.Args[0] 537 v_1 := v.Args[1] 538 if v_1.Op != OpConst16 { 539 break 540 } 541 if v_1.AuxInt != 1 { 542 break 543 } 544 v.reset(OpNeg16) 545 v.AddArg(x) 546 return true 547 } 548 // match: (Add16 (Add16 i:(Const16 <t>) z) x) 549 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 550 // result: (Add16 i (Add16 <t> z x)) 551 for { 552 _ = v.Args[1] 553 v_0 := v.Args[0] 554 if v_0.Op != OpAdd16 { 555 break 556 } 557 _ = v_0.Args[1] 558 i := v_0.Args[0] 559 if i.Op != OpConst16 { 560 break 561 } 562 t := i.Type 563 z := v_0.Args[1] 564 x := v.Args[1] 565 if !(z.Op != OpConst16 && x.Op != OpConst16) { 566 break 567 } 568 v.reset(OpAdd16) 569 v.AddArg(i) 570 v0 := b.NewValue0(v.Pos, OpAdd16, t) 571 v0.AddArg(z) 572 v0.AddArg(x) 573 v.AddArg(v0) 574 return true 575 } 576 // match: (Add16 (Add16 z i:(Const16 <t>)) x) 577 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 578 // result: (Add16 i (Add16 <t> z x)) 579 for { 580 _ = v.Args[1] 581 v_0 := v.Args[0] 582 if v_0.Op != OpAdd16 { 583 break 584 } 585 _ = v_0.Args[1] 586 z := v_0.Args[0] 587 i := v_0.Args[1] 588 if i.Op != OpConst16 { 589 break 590 } 591 t := i.Type 592 x := v.Args[1] 593 if !(z.Op != OpConst16 && x.Op != OpConst16) { 594 break 595 } 596 v.reset(OpAdd16) 597 v.AddArg(i) 598 v0 := b.NewValue0(v.Pos, OpAdd16, t) 599 v0.AddArg(z) 600 v0.AddArg(x) 601 v.AddArg(v0) 602 return true 603 } 604 // match: (Add16 x (Add16 i:(Const16 <t>) z)) 605 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 606 // result: (Add16 i (Add16 <t> z x)) 607 for { 608 _ = v.Args[1] 609 x := v.Args[0] 610 v_1 := v.Args[1] 611 if v_1.Op != OpAdd16 { 612 break 613 } 614 _ = v_1.Args[1] 615 i := v_1.Args[0] 616 if i.Op != OpConst16 { 617 break 618 } 619 t := i.Type 620 z := v_1.Args[1] 621 if !(z.Op != OpConst16 && x.Op != OpConst16) { 622 break 623 } 624 v.reset(OpAdd16) 625 v.AddArg(i) 626 v0 := b.NewValue0(v.Pos, OpAdd16, t) 627 v0.AddArg(z) 628 v0.AddArg(x) 629 v.AddArg(v0) 630 return true 631 } 632 // match: (Add16 x (Add16 z i:(Const16 <t>))) 633 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 634 // result: (Add16 i (Add16 <t> z x)) 635 for { 636 _ = v.Args[1] 637 x := v.Args[0] 638 v_1 := v.Args[1] 639 if v_1.Op != OpAdd16 { 640 break 641 } 642 _ = v_1.Args[1] 643 z := v_1.Args[0] 644 i := v_1.Args[1] 645 if i.Op != OpConst16 { 646 break 647 } 648 t := i.Type 649 if !(z.Op != OpConst16 && x.Op != OpConst16) { 650 break 651 } 652 v.reset(OpAdd16) 653 v.AddArg(i) 654 v0 := b.NewValue0(v.Pos, OpAdd16, t) 655 v0.AddArg(z) 656 v0.AddArg(x) 657 v.AddArg(v0) 658 return true 659 } 660 return false 661 } 662 func rewriteValuegeneric_OpAdd16_10(v *Value) bool { 663 b := v.Block 664 _ = b 665 // match: (Add16 (Sub16 i:(Const16 <t>) z) x) 666 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 667 // result: (Add16 i (Sub16 <t> x z)) 668 for { 669 _ = v.Args[1] 670 v_0 := v.Args[0] 671 if v_0.Op != OpSub16 { 672 break 673 } 674 _ = v_0.Args[1] 675 i := v_0.Args[0] 676 if i.Op != OpConst16 { 677 break 678 } 679 t := i.Type 680 z := v_0.Args[1] 681 x := v.Args[1] 682 if !(z.Op != OpConst16 && x.Op != OpConst16) { 683 break 684 } 685 v.reset(OpAdd16) 686 v.AddArg(i) 687 v0 := b.NewValue0(v.Pos, OpSub16, t) 688 v0.AddArg(x) 689 v0.AddArg(z) 690 v.AddArg(v0) 691 return true 692 } 693 // match: (Add16 x (Sub16 i:(Const16 <t>) z)) 694 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 695 // result: (Add16 i (Sub16 <t> x z)) 696 for { 697 _ = v.Args[1] 698 x := v.Args[0] 699 v_1 := v.Args[1] 700 if v_1.Op != OpSub16 { 701 break 702 } 703 _ = v_1.Args[1] 704 i := v_1.Args[0] 705 if i.Op != OpConst16 { 706 break 707 } 708 t := i.Type 709 z := v_1.Args[1] 710 if !(z.Op != OpConst16 && x.Op != OpConst16) { 711 break 712 } 713 v.reset(OpAdd16) 714 v.AddArg(i) 715 v0 := b.NewValue0(v.Pos, OpSub16, t) 716 v0.AddArg(x) 717 v0.AddArg(z) 718 v.AddArg(v0) 719 return true 720 } 721 // match: (Add16 x (Sub16 i:(Const16 <t>) z)) 722 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 723 // result: (Add16 i (Sub16 <t> x z)) 724 for { 725 _ = v.Args[1] 726 x := v.Args[0] 727 v_1 := v.Args[1] 728 if v_1.Op != OpSub16 { 729 break 730 } 731 _ = v_1.Args[1] 732 i := v_1.Args[0] 733 if i.Op != OpConst16 { 734 break 735 } 736 t := i.Type 737 z := v_1.Args[1] 738 if !(z.Op != OpConst16 && x.Op != OpConst16) { 739 break 740 } 741 v.reset(OpAdd16) 742 v.AddArg(i) 743 v0 := b.NewValue0(v.Pos, OpSub16, t) 744 v0.AddArg(x) 745 v0.AddArg(z) 746 v.AddArg(v0) 747 return true 748 } 749 // match: (Add16 (Sub16 i:(Const16 <t>) z) x) 750 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 751 // result: (Add16 i (Sub16 <t> x z)) 752 for { 753 _ = v.Args[1] 754 v_0 := v.Args[0] 755 if v_0.Op != OpSub16 { 756 break 757 } 758 _ = v_0.Args[1] 759 i := v_0.Args[0] 760 if i.Op != OpConst16 { 761 break 762 } 763 t := i.Type 764 z := v_0.Args[1] 765 x := v.Args[1] 766 if !(z.Op != OpConst16 && x.Op != OpConst16) { 767 break 768 } 769 v.reset(OpAdd16) 770 v.AddArg(i) 771 v0 := b.NewValue0(v.Pos, OpSub16, t) 772 v0.AddArg(x) 773 v0.AddArg(z) 774 v.AddArg(v0) 775 return true 776 } 777 // match: (Add16 (Sub16 z i:(Const16 <t>)) x) 778 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 779 // result: (Sub16 (Add16 <t> x z) i) 780 for { 781 _ = v.Args[1] 782 v_0 := v.Args[0] 783 if v_0.Op != OpSub16 { 784 break 785 } 786 _ = v_0.Args[1] 787 z := v_0.Args[0] 788 i := v_0.Args[1] 789 if i.Op != OpConst16 { 790 break 791 } 792 t := i.Type 793 x := v.Args[1] 794 if !(z.Op != OpConst16 && x.Op != OpConst16) { 795 break 796 } 797 v.reset(OpSub16) 798 v0 := b.NewValue0(v.Pos, OpAdd16, t) 799 v0.AddArg(x) 800 v0.AddArg(z) 801 v.AddArg(v0) 802 v.AddArg(i) 803 return true 804 } 805 // match: (Add16 x (Sub16 z i:(Const16 <t>))) 806 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 807 // result: (Sub16 (Add16 <t> x z) i) 808 for { 809 _ = v.Args[1] 810 x := v.Args[0] 811 v_1 := v.Args[1] 812 if v_1.Op != OpSub16 { 813 break 814 } 815 _ = v_1.Args[1] 816 z := v_1.Args[0] 817 i := v_1.Args[1] 818 if i.Op != OpConst16 { 819 break 820 } 821 t := i.Type 822 if !(z.Op != OpConst16 && x.Op != OpConst16) { 823 break 824 } 825 v.reset(OpSub16) 826 v0 := b.NewValue0(v.Pos, OpAdd16, t) 827 v0.AddArg(x) 828 v0.AddArg(z) 829 v.AddArg(v0) 830 v.AddArg(i) 831 return true 832 } 833 // match: (Add16 x (Sub16 z i:(Const16 <t>))) 834 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 835 // result: (Sub16 (Add16 <t> x z) i) 836 for { 837 _ = v.Args[1] 838 x := v.Args[0] 839 v_1 := v.Args[1] 840 if v_1.Op != OpSub16 { 841 break 842 } 843 _ = v_1.Args[1] 844 z := v_1.Args[0] 845 i := v_1.Args[1] 846 if i.Op != OpConst16 { 847 break 848 } 849 t := i.Type 850 if !(z.Op != OpConst16 && x.Op != OpConst16) { 851 break 852 } 853 v.reset(OpSub16) 854 v0 := b.NewValue0(v.Pos, OpAdd16, t) 855 v0.AddArg(x) 856 v0.AddArg(z) 857 v.AddArg(v0) 858 v.AddArg(i) 859 return true 860 } 861 // match: (Add16 (Sub16 z i:(Const16 <t>)) x) 862 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 863 // result: (Sub16 (Add16 <t> x z) i) 864 for { 865 _ = v.Args[1] 866 v_0 := v.Args[0] 867 if v_0.Op != OpSub16 { 868 break 869 } 870 _ = v_0.Args[1] 871 z := v_0.Args[0] 872 i := v_0.Args[1] 873 if i.Op != OpConst16 { 874 break 875 } 876 t := i.Type 877 x := v.Args[1] 878 if !(z.Op != OpConst16 && x.Op != OpConst16) { 879 break 880 } 881 v.reset(OpSub16) 882 v0 := b.NewValue0(v.Pos, OpAdd16, t) 883 v0.AddArg(x) 884 v0.AddArg(z) 885 v.AddArg(v0) 886 v.AddArg(i) 887 return true 888 } 889 // match: (Add16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x)) 890 // cond: 891 // result: (Add16 (Const16 <t> [int64(int16(c+d))]) x) 892 for { 893 _ = v.Args[1] 894 v_0 := v.Args[0] 895 if v_0.Op != OpConst16 { 896 break 897 } 898 t := v_0.Type 899 c := v_0.AuxInt 900 v_1 := v.Args[1] 901 if v_1.Op != OpAdd16 { 902 break 903 } 904 _ = v_1.Args[1] 905 v_1_0 := v_1.Args[0] 906 if v_1_0.Op != OpConst16 { 907 break 908 } 909 if v_1_0.Type != t { 910 break 911 } 912 d := v_1_0.AuxInt 913 x := v_1.Args[1] 914 v.reset(OpAdd16) 915 v0 := b.NewValue0(v.Pos, OpConst16, t) 916 v0.AuxInt = int64(int16(c + d)) 917 v.AddArg(v0) 918 v.AddArg(x) 919 return true 920 } 921 // match: (Add16 (Const16 <t> [c]) (Add16 x (Const16 <t> [d]))) 922 // cond: 923 // result: (Add16 (Const16 <t> [int64(int16(c+d))]) x) 924 for { 925 _ = v.Args[1] 926 v_0 := v.Args[0] 927 if v_0.Op != OpConst16 { 928 break 929 } 930 t := v_0.Type 931 c := v_0.AuxInt 932 v_1 := v.Args[1] 933 if v_1.Op != OpAdd16 { 934 break 935 } 936 _ = v_1.Args[1] 937 x := v_1.Args[0] 938 v_1_1 := v_1.Args[1] 939 if v_1_1.Op != OpConst16 { 940 break 941 } 942 if v_1_1.Type != t { 943 break 944 } 945 d := v_1_1.AuxInt 946 v.reset(OpAdd16) 947 v0 := b.NewValue0(v.Pos, OpConst16, t) 948 v0.AuxInt = int64(int16(c + d)) 949 v.AddArg(v0) 950 v.AddArg(x) 951 return true 952 } 953 return false 954 } 955 func rewriteValuegeneric_OpAdd16_20(v *Value) bool { 956 b := v.Block 957 _ = b 958 // match: (Add16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c])) 959 // cond: 960 // result: (Add16 (Const16 <t> [int64(int16(c+d))]) x) 961 for { 962 _ = v.Args[1] 963 v_0 := v.Args[0] 964 if v_0.Op != OpAdd16 { 965 break 966 } 967 _ = v_0.Args[1] 968 v_0_0 := v_0.Args[0] 969 if v_0_0.Op != OpConst16 { 970 break 971 } 972 t := v_0_0.Type 973 d := v_0_0.AuxInt 974 x := v_0.Args[1] 975 v_1 := v.Args[1] 976 if v_1.Op != OpConst16 { 977 break 978 } 979 if v_1.Type != t { 980 break 981 } 982 c := v_1.AuxInt 983 v.reset(OpAdd16) 984 v0 := b.NewValue0(v.Pos, OpConst16, t) 985 v0.AuxInt = int64(int16(c + d)) 986 v.AddArg(v0) 987 v.AddArg(x) 988 return true 989 } 990 // match: (Add16 (Add16 x (Const16 <t> [d])) (Const16 <t> [c])) 991 // cond: 992 // result: (Add16 (Const16 <t> [int64(int16(c+d))]) x) 993 for { 994 _ = v.Args[1] 995 v_0 := v.Args[0] 996 if v_0.Op != OpAdd16 { 997 break 998 } 999 _ = v_0.Args[1] 1000 x := v_0.Args[0] 1001 v_0_1 := v_0.Args[1] 1002 if v_0_1.Op != OpConst16 { 1003 break 1004 } 1005 t := v_0_1.Type 1006 d := v_0_1.AuxInt 1007 v_1 := v.Args[1] 1008 if v_1.Op != OpConst16 { 1009 break 1010 } 1011 if v_1.Type != t { 1012 break 1013 } 1014 c := v_1.AuxInt 1015 v.reset(OpAdd16) 1016 v0 := b.NewValue0(v.Pos, OpConst16, t) 1017 v0.AuxInt = int64(int16(c + d)) 1018 v.AddArg(v0) 1019 v.AddArg(x) 1020 return true 1021 } 1022 // match: (Add16 (Const16 <t> [c]) (Sub16 (Const16 <t> [d]) x)) 1023 // cond: 1024 // result: (Sub16 (Const16 <t> [int64(int16(c+d))]) x) 1025 for { 1026 _ = v.Args[1] 1027 v_0 := v.Args[0] 1028 if v_0.Op != OpConst16 { 1029 break 1030 } 1031 t := v_0.Type 1032 c := v_0.AuxInt 1033 v_1 := v.Args[1] 1034 if v_1.Op != OpSub16 { 1035 break 1036 } 1037 _ = v_1.Args[1] 1038 v_1_0 := v_1.Args[0] 1039 if v_1_0.Op != OpConst16 { 1040 break 1041 } 1042 if v_1_0.Type != t { 1043 break 1044 } 1045 d := v_1_0.AuxInt 1046 x := v_1.Args[1] 1047 v.reset(OpSub16) 1048 v0 := b.NewValue0(v.Pos, OpConst16, t) 1049 v0.AuxInt = int64(int16(c + d)) 1050 v.AddArg(v0) 1051 v.AddArg(x) 1052 return true 1053 } 1054 // match: (Add16 (Sub16 (Const16 <t> [d]) x) (Const16 <t> [c])) 1055 // cond: 1056 // result: (Sub16 (Const16 <t> [int64(int16(c+d))]) x) 1057 for { 1058 _ = v.Args[1] 1059 v_0 := v.Args[0] 1060 if v_0.Op != OpSub16 { 1061 break 1062 } 1063 _ = v_0.Args[1] 1064 v_0_0 := v_0.Args[0] 1065 if v_0_0.Op != OpConst16 { 1066 break 1067 } 1068 t := v_0_0.Type 1069 d := v_0_0.AuxInt 1070 x := v_0.Args[1] 1071 v_1 := v.Args[1] 1072 if v_1.Op != OpConst16 { 1073 break 1074 } 1075 if v_1.Type != t { 1076 break 1077 } 1078 c := v_1.AuxInt 1079 v.reset(OpSub16) 1080 v0 := b.NewValue0(v.Pos, OpConst16, t) 1081 v0.AuxInt = int64(int16(c + d)) 1082 v.AddArg(v0) 1083 v.AddArg(x) 1084 return true 1085 } 1086 // match: (Add16 (Const16 <t> [c]) (Sub16 x (Const16 <t> [d]))) 1087 // cond: 1088 // result: (Add16 (Const16 <t> [int64(int16(c-d))]) x) 1089 for { 1090 _ = v.Args[1] 1091 v_0 := v.Args[0] 1092 if v_0.Op != OpConst16 { 1093 break 1094 } 1095 t := v_0.Type 1096 c := v_0.AuxInt 1097 v_1 := v.Args[1] 1098 if v_1.Op != OpSub16 { 1099 break 1100 } 1101 _ = v_1.Args[1] 1102 x := v_1.Args[0] 1103 v_1_1 := v_1.Args[1] 1104 if v_1_1.Op != OpConst16 { 1105 break 1106 } 1107 if v_1_1.Type != t { 1108 break 1109 } 1110 d := v_1_1.AuxInt 1111 v.reset(OpAdd16) 1112 v0 := b.NewValue0(v.Pos, OpConst16, t) 1113 v0.AuxInt = int64(int16(c - d)) 1114 v.AddArg(v0) 1115 v.AddArg(x) 1116 return true 1117 } 1118 // match: (Add16 (Sub16 x (Const16 <t> [d])) (Const16 <t> [c])) 1119 // cond: 1120 // result: (Add16 (Const16 <t> [int64(int16(c-d))]) x) 1121 for { 1122 _ = v.Args[1] 1123 v_0 := v.Args[0] 1124 if v_0.Op != OpSub16 { 1125 break 1126 } 1127 _ = v_0.Args[1] 1128 x := v_0.Args[0] 1129 v_0_1 := v_0.Args[1] 1130 if v_0_1.Op != OpConst16 { 1131 break 1132 } 1133 t := v_0_1.Type 1134 d := v_0_1.AuxInt 1135 v_1 := v.Args[1] 1136 if v_1.Op != OpConst16 { 1137 break 1138 } 1139 if v_1.Type != t { 1140 break 1141 } 1142 c := v_1.AuxInt 1143 v.reset(OpAdd16) 1144 v0 := b.NewValue0(v.Pos, OpConst16, t) 1145 v0.AuxInt = int64(int16(c - d)) 1146 v.AddArg(v0) 1147 v.AddArg(x) 1148 return true 1149 } 1150 return false 1151 } 1152 func rewriteValuegeneric_OpAdd32_0(v *Value) bool { 1153 b := v.Block 1154 _ = b 1155 // match: (Add32 (Const32 [c]) (Const32 [d])) 1156 // cond: 1157 // result: (Const32 [int64(int32(c+d))]) 1158 for { 1159 _ = v.Args[1] 1160 v_0 := v.Args[0] 1161 if v_0.Op != OpConst32 { 1162 break 1163 } 1164 c := v_0.AuxInt 1165 v_1 := v.Args[1] 1166 if v_1.Op != OpConst32 { 1167 break 1168 } 1169 d := v_1.AuxInt 1170 v.reset(OpConst32) 1171 v.AuxInt = int64(int32(c + d)) 1172 return true 1173 } 1174 // match: (Add32 (Const32 [d]) (Const32 [c])) 1175 // cond: 1176 // result: (Const32 [int64(int32(c+d))]) 1177 for { 1178 _ = v.Args[1] 1179 v_0 := v.Args[0] 1180 if v_0.Op != OpConst32 { 1181 break 1182 } 1183 d := v_0.AuxInt 1184 v_1 := v.Args[1] 1185 if v_1.Op != OpConst32 { 1186 break 1187 } 1188 c := v_1.AuxInt 1189 v.reset(OpConst32) 1190 v.AuxInt = int64(int32(c + d)) 1191 return true 1192 } 1193 // match: (Add32 (Const32 [0]) x) 1194 // cond: 1195 // result: x 1196 for { 1197 _ = v.Args[1] 1198 v_0 := v.Args[0] 1199 if v_0.Op != OpConst32 { 1200 break 1201 } 1202 if v_0.AuxInt != 0 { 1203 break 1204 } 1205 x := v.Args[1] 1206 v.reset(OpCopy) 1207 v.Type = x.Type 1208 v.AddArg(x) 1209 return true 1210 } 1211 // match: (Add32 x (Const32 [0])) 1212 // cond: 1213 // result: x 1214 for { 1215 _ = v.Args[1] 1216 x := v.Args[0] 1217 v_1 := v.Args[1] 1218 if v_1.Op != OpConst32 { 1219 break 1220 } 1221 if v_1.AuxInt != 0 { 1222 break 1223 } 1224 v.reset(OpCopy) 1225 v.Type = x.Type 1226 v.AddArg(x) 1227 return true 1228 } 1229 // match: (Add32 (Const32 [1]) (Com32 x)) 1230 // cond: 1231 // result: (Neg32 x) 1232 for { 1233 _ = v.Args[1] 1234 v_0 := v.Args[0] 1235 if v_0.Op != OpConst32 { 1236 break 1237 } 1238 if v_0.AuxInt != 1 { 1239 break 1240 } 1241 v_1 := v.Args[1] 1242 if v_1.Op != OpCom32 { 1243 break 1244 } 1245 x := v_1.Args[0] 1246 v.reset(OpNeg32) 1247 v.AddArg(x) 1248 return true 1249 } 1250 // match: (Add32 (Com32 x) (Const32 [1])) 1251 // cond: 1252 // result: (Neg32 x) 1253 for { 1254 _ = v.Args[1] 1255 v_0 := v.Args[0] 1256 if v_0.Op != OpCom32 { 1257 break 1258 } 1259 x := v_0.Args[0] 1260 v_1 := v.Args[1] 1261 if v_1.Op != OpConst32 { 1262 break 1263 } 1264 if v_1.AuxInt != 1 { 1265 break 1266 } 1267 v.reset(OpNeg32) 1268 v.AddArg(x) 1269 return true 1270 } 1271 // match: (Add32 (Add32 i:(Const32 <t>) z) x) 1272 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1273 // result: (Add32 i (Add32 <t> z x)) 1274 for { 1275 _ = v.Args[1] 1276 v_0 := v.Args[0] 1277 if v_0.Op != OpAdd32 { 1278 break 1279 } 1280 _ = v_0.Args[1] 1281 i := v_0.Args[0] 1282 if i.Op != OpConst32 { 1283 break 1284 } 1285 t := i.Type 1286 z := v_0.Args[1] 1287 x := v.Args[1] 1288 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1289 break 1290 } 1291 v.reset(OpAdd32) 1292 v.AddArg(i) 1293 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1294 v0.AddArg(z) 1295 v0.AddArg(x) 1296 v.AddArg(v0) 1297 return true 1298 } 1299 // match: (Add32 (Add32 z i:(Const32 <t>)) x) 1300 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1301 // result: (Add32 i (Add32 <t> z x)) 1302 for { 1303 _ = v.Args[1] 1304 v_0 := v.Args[0] 1305 if v_0.Op != OpAdd32 { 1306 break 1307 } 1308 _ = v_0.Args[1] 1309 z := v_0.Args[0] 1310 i := v_0.Args[1] 1311 if i.Op != OpConst32 { 1312 break 1313 } 1314 t := i.Type 1315 x := v.Args[1] 1316 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1317 break 1318 } 1319 v.reset(OpAdd32) 1320 v.AddArg(i) 1321 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1322 v0.AddArg(z) 1323 v0.AddArg(x) 1324 v.AddArg(v0) 1325 return true 1326 } 1327 // match: (Add32 x (Add32 i:(Const32 <t>) z)) 1328 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1329 // result: (Add32 i (Add32 <t> z x)) 1330 for { 1331 _ = v.Args[1] 1332 x := v.Args[0] 1333 v_1 := v.Args[1] 1334 if v_1.Op != OpAdd32 { 1335 break 1336 } 1337 _ = v_1.Args[1] 1338 i := v_1.Args[0] 1339 if i.Op != OpConst32 { 1340 break 1341 } 1342 t := i.Type 1343 z := v_1.Args[1] 1344 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1345 break 1346 } 1347 v.reset(OpAdd32) 1348 v.AddArg(i) 1349 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1350 v0.AddArg(z) 1351 v0.AddArg(x) 1352 v.AddArg(v0) 1353 return true 1354 } 1355 // match: (Add32 x (Add32 z i:(Const32 <t>))) 1356 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1357 // result: (Add32 i (Add32 <t> z x)) 1358 for { 1359 _ = v.Args[1] 1360 x := v.Args[0] 1361 v_1 := v.Args[1] 1362 if v_1.Op != OpAdd32 { 1363 break 1364 } 1365 _ = v_1.Args[1] 1366 z := v_1.Args[0] 1367 i := v_1.Args[1] 1368 if i.Op != OpConst32 { 1369 break 1370 } 1371 t := i.Type 1372 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1373 break 1374 } 1375 v.reset(OpAdd32) 1376 v.AddArg(i) 1377 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1378 v0.AddArg(z) 1379 v0.AddArg(x) 1380 v.AddArg(v0) 1381 return true 1382 } 1383 return false 1384 } 1385 func rewriteValuegeneric_OpAdd32_10(v *Value) bool { 1386 b := v.Block 1387 _ = b 1388 // match: (Add32 (Sub32 i:(Const32 <t>) z) x) 1389 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1390 // result: (Add32 i (Sub32 <t> x z)) 1391 for { 1392 _ = v.Args[1] 1393 v_0 := v.Args[0] 1394 if v_0.Op != OpSub32 { 1395 break 1396 } 1397 _ = v_0.Args[1] 1398 i := v_0.Args[0] 1399 if i.Op != OpConst32 { 1400 break 1401 } 1402 t := i.Type 1403 z := v_0.Args[1] 1404 x := v.Args[1] 1405 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1406 break 1407 } 1408 v.reset(OpAdd32) 1409 v.AddArg(i) 1410 v0 := b.NewValue0(v.Pos, OpSub32, t) 1411 v0.AddArg(x) 1412 v0.AddArg(z) 1413 v.AddArg(v0) 1414 return true 1415 } 1416 // match: (Add32 x (Sub32 i:(Const32 <t>) z)) 1417 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1418 // result: (Add32 i (Sub32 <t> x z)) 1419 for { 1420 _ = v.Args[1] 1421 x := v.Args[0] 1422 v_1 := v.Args[1] 1423 if v_1.Op != OpSub32 { 1424 break 1425 } 1426 _ = v_1.Args[1] 1427 i := v_1.Args[0] 1428 if i.Op != OpConst32 { 1429 break 1430 } 1431 t := i.Type 1432 z := v_1.Args[1] 1433 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1434 break 1435 } 1436 v.reset(OpAdd32) 1437 v.AddArg(i) 1438 v0 := b.NewValue0(v.Pos, OpSub32, t) 1439 v0.AddArg(x) 1440 v0.AddArg(z) 1441 v.AddArg(v0) 1442 return true 1443 } 1444 // match: (Add32 x (Sub32 i:(Const32 <t>) z)) 1445 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1446 // result: (Add32 i (Sub32 <t> x z)) 1447 for { 1448 _ = v.Args[1] 1449 x := v.Args[0] 1450 v_1 := v.Args[1] 1451 if v_1.Op != OpSub32 { 1452 break 1453 } 1454 _ = v_1.Args[1] 1455 i := v_1.Args[0] 1456 if i.Op != OpConst32 { 1457 break 1458 } 1459 t := i.Type 1460 z := v_1.Args[1] 1461 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1462 break 1463 } 1464 v.reset(OpAdd32) 1465 v.AddArg(i) 1466 v0 := b.NewValue0(v.Pos, OpSub32, t) 1467 v0.AddArg(x) 1468 v0.AddArg(z) 1469 v.AddArg(v0) 1470 return true 1471 } 1472 // match: (Add32 (Sub32 i:(Const32 <t>) z) x) 1473 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1474 // result: (Add32 i (Sub32 <t> x z)) 1475 for { 1476 _ = v.Args[1] 1477 v_0 := v.Args[0] 1478 if v_0.Op != OpSub32 { 1479 break 1480 } 1481 _ = v_0.Args[1] 1482 i := v_0.Args[0] 1483 if i.Op != OpConst32 { 1484 break 1485 } 1486 t := i.Type 1487 z := v_0.Args[1] 1488 x := v.Args[1] 1489 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1490 break 1491 } 1492 v.reset(OpAdd32) 1493 v.AddArg(i) 1494 v0 := b.NewValue0(v.Pos, OpSub32, t) 1495 v0.AddArg(x) 1496 v0.AddArg(z) 1497 v.AddArg(v0) 1498 return true 1499 } 1500 // match: (Add32 (Sub32 z i:(Const32 <t>)) x) 1501 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1502 // result: (Sub32 (Add32 <t> x z) i) 1503 for { 1504 _ = v.Args[1] 1505 v_0 := v.Args[0] 1506 if v_0.Op != OpSub32 { 1507 break 1508 } 1509 _ = v_0.Args[1] 1510 z := v_0.Args[0] 1511 i := v_0.Args[1] 1512 if i.Op != OpConst32 { 1513 break 1514 } 1515 t := i.Type 1516 x := v.Args[1] 1517 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1518 break 1519 } 1520 v.reset(OpSub32) 1521 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1522 v0.AddArg(x) 1523 v0.AddArg(z) 1524 v.AddArg(v0) 1525 v.AddArg(i) 1526 return true 1527 } 1528 // match: (Add32 x (Sub32 z i:(Const32 <t>))) 1529 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1530 // result: (Sub32 (Add32 <t> x z) i) 1531 for { 1532 _ = v.Args[1] 1533 x := v.Args[0] 1534 v_1 := v.Args[1] 1535 if v_1.Op != OpSub32 { 1536 break 1537 } 1538 _ = v_1.Args[1] 1539 z := v_1.Args[0] 1540 i := v_1.Args[1] 1541 if i.Op != OpConst32 { 1542 break 1543 } 1544 t := i.Type 1545 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1546 break 1547 } 1548 v.reset(OpSub32) 1549 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1550 v0.AddArg(x) 1551 v0.AddArg(z) 1552 v.AddArg(v0) 1553 v.AddArg(i) 1554 return true 1555 } 1556 // match: (Add32 x (Sub32 z i:(Const32 <t>))) 1557 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1558 // result: (Sub32 (Add32 <t> x z) i) 1559 for { 1560 _ = v.Args[1] 1561 x := v.Args[0] 1562 v_1 := v.Args[1] 1563 if v_1.Op != OpSub32 { 1564 break 1565 } 1566 _ = v_1.Args[1] 1567 z := v_1.Args[0] 1568 i := v_1.Args[1] 1569 if i.Op != OpConst32 { 1570 break 1571 } 1572 t := i.Type 1573 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1574 break 1575 } 1576 v.reset(OpSub32) 1577 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1578 v0.AddArg(x) 1579 v0.AddArg(z) 1580 v.AddArg(v0) 1581 v.AddArg(i) 1582 return true 1583 } 1584 // match: (Add32 (Sub32 z i:(Const32 <t>)) x) 1585 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1586 // result: (Sub32 (Add32 <t> x z) i) 1587 for { 1588 _ = v.Args[1] 1589 v_0 := v.Args[0] 1590 if v_0.Op != OpSub32 { 1591 break 1592 } 1593 _ = v_0.Args[1] 1594 z := v_0.Args[0] 1595 i := v_0.Args[1] 1596 if i.Op != OpConst32 { 1597 break 1598 } 1599 t := i.Type 1600 x := v.Args[1] 1601 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1602 break 1603 } 1604 v.reset(OpSub32) 1605 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1606 v0.AddArg(x) 1607 v0.AddArg(z) 1608 v.AddArg(v0) 1609 v.AddArg(i) 1610 return true 1611 } 1612 // match: (Add32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x)) 1613 // cond: 1614 // result: (Add32 (Const32 <t> [int64(int32(c+d))]) x) 1615 for { 1616 _ = v.Args[1] 1617 v_0 := v.Args[0] 1618 if v_0.Op != OpConst32 { 1619 break 1620 } 1621 t := v_0.Type 1622 c := v_0.AuxInt 1623 v_1 := v.Args[1] 1624 if v_1.Op != OpAdd32 { 1625 break 1626 } 1627 _ = v_1.Args[1] 1628 v_1_0 := v_1.Args[0] 1629 if v_1_0.Op != OpConst32 { 1630 break 1631 } 1632 if v_1_0.Type != t { 1633 break 1634 } 1635 d := v_1_0.AuxInt 1636 x := v_1.Args[1] 1637 v.reset(OpAdd32) 1638 v0 := b.NewValue0(v.Pos, OpConst32, t) 1639 v0.AuxInt = int64(int32(c + d)) 1640 v.AddArg(v0) 1641 v.AddArg(x) 1642 return true 1643 } 1644 // match: (Add32 (Const32 <t> [c]) (Add32 x (Const32 <t> [d]))) 1645 // cond: 1646 // result: (Add32 (Const32 <t> [int64(int32(c+d))]) x) 1647 for { 1648 _ = v.Args[1] 1649 v_0 := v.Args[0] 1650 if v_0.Op != OpConst32 { 1651 break 1652 } 1653 t := v_0.Type 1654 c := v_0.AuxInt 1655 v_1 := v.Args[1] 1656 if v_1.Op != OpAdd32 { 1657 break 1658 } 1659 _ = v_1.Args[1] 1660 x := v_1.Args[0] 1661 v_1_1 := v_1.Args[1] 1662 if v_1_1.Op != OpConst32 { 1663 break 1664 } 1665 if v_1_1.Type != t { 1666 break 1667 } 1668 d := v_1_1.AuxInt 1669 v.reset(OpAdd32) 1670 v0 := b.NewValue0(v.Pos, OpConst32, t) 1671 v0.AuxInt = int64(int32(c + d)) 1672 v.AddArg(v0) 1673 v.AddArg(x) 1674 return true 1675 } 1676 return false 1677 } 1678 func rewriteValuegeneric_OpAdd32_20(v *Value) bool { 1679 b := v.Block 1680 _ = b 1681 // match: (Add32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c])) 1682 // cond: 1683 // result: (Add32 (Const32 <t> [int64(int32(c+d))]) x) 1684 for { 1685 _ = v.Args[1] 1686 v_0 := v.Args[0] 1687 if v_0.Op != OpAdd32 { 1688 break 1689 } 1690 _ = v_0.Args[1] 1691 v_0_0 := v_0.Args[0] 1692 if v_0_0.Op != OpConst32 { 1693 break 1694 } 1695 t := v_0_0.Type 1696 d := v_0_0.AuxInt 1697 x := v_0.Args[1] 1698 v_1 := v.Args[1] 1699 if v_1.Op != OpConst32 { 1700 break 1701 } 1702 if v_1.Type != t { 1703 break 1704 } 1705 c := v_1.AuxInt 1706 v.reset(OpAdd32) 1707 v0 := b.NewValue0(v.Pos, OpConst32, t) 1708 v0.AuxInt = int64(int32(c + d)) 1709 v.AddArg(v0) 1710 v.AddArg(x) 1711 return true 1712 } 1713 // match: (Add32 (Add32 x (Const32 <t> [d])) (Const32 <t> [c])) 1714 // cond: 1715 // result: (Add32 (Const32 <t> [int64(int32(c+d))]) x) 1716 for { 1717 _ = v.Args[1] 1718 v_0 := v.Args[0] 1719 if v_0.Op != OpAdd32 { 1720 break 1721 } 1722 _ = v_0.Args[1] 1723 x := v_0.Args[0] 1724 v_0_1 := v_0.Args[1] 1725 if v_0_1.Op != OpConst32 { 1726 break 1727 } 1728 t := v_0_1.Type 1729 d := v_0_1.AuxInt 1730 v_1 := v.Args[1] 1731 if v_1.Op != OpConst32 { 1732 break 1733 } 1734 if v_1.Type != t { 1735 break 1736 } 1737 c := v_1.AuxInt 1738 v.reset(OpAdd32) 1739 v0 := b.NewValue0(v.Pos, OpConst32, t) 1740 v0.AuxInt = int64(int32(c + d)) 1741 v.AddArg(v0) 1742 v.AddArg(x) 1743 return true 1744 } 1745 // match: (Add32 (Const32 <t> [c]) (Sub32 (Const32 <t> [d]) x)) 1746 // cond: 1747 // result: (Sub32 (Const32 <t> [int64(int32(c+d))]) x) 1748 for { 1749 _ = v.Args[1] 1750 v_0 := v.Args[0] 1751 if v_0.Op != OpConst32 { 1752 break 1753 } 1754 t := v_0.Type 1755 c := v_0.AuxInt 1756 v_1 := v.Args[1] 1757 if v_1.Op != OpSub32 { 1758 break 1759 } 1760 _ = v_1.Args[1] 1761 v_1_0 := v_1.Args[0] 1762 if v_1_0.Op != OpConst32 { 1763 break 1764 } 1765 if v_1_0.Type != t { 1766 break 1767 } 1768 d := v_1_0.AuxInt 1769 x := v_1.Args[1] 1770 v.reset(OpSub32) 1771 v0 := b.NewValue0(v.Pos, OpConst32, t) 1772 v0.AuxInt = int64(int32(c + d)) 1773 v.AddArg(v0) 1774 v.AddArg(x) 1775 return true 1776 } 1777 // match: (Add32 (Sub32 (Const32 <t> [d]) x) (Const32 <t> [c])) 1778 // cond: 1779 // result: (Sub32 (Const32 <t> [int64(int32(c+d))]) x) 1780 for { 1781 _ = v.Args[1] 1782 v_0 := v.Args[0] 1783 if v_0.Op != OpSub32 { 1784 break 1785 } 1786 _ = v_0.Args[1] 1787 v_0_0 := v_0.Args[0] 1788 if v_0_0.Op != OpConst32 { 1789 break 1790 } 1791 t := v_0_0.Type 1792 d := v_0_0.AuxInt 1793 x := v_0.Args[1] 1794 v_1 := v.Args[1] 1795 if v_1.Op != OpConst32 { 1796 break 1797 } 1798 if v_1.Type != t { 1799 break 1800 } 1801 c := v_1.AuxInt 1802 v.reset(OpSub32) 1803 v0 := b.NewValue0(v.Pos, OpConst32, t) 1804 v0.AuxInt = int64(int32(c + d)) 1805 v.AddArg(v0) 1806 v.AddArg(x) 1807 return true 1808 } 1809 // match: (Add32 (Const32 <t> [c]) (Sub32 x (Const32 <t> [d]))) 1810 // cond: 1811 // result: (Add32 (Const32 <t> [int64(int32(c-d))]) x) 1812 for { 1813 _ = v.Args[1] 1814 v_0 := v.Args[0] 1815 if v_0.Op != OpConst32 { 1816 break 1817 } 1818 t := v_0.Type 1819 c := v_0.AuxInt 1820 v_1 := v.Args[1] 1821 if v_1.Op != OpSub32 { 1822 break 1823 } 1824 _ = v_1.Args[1] 1825 x := v_1.Args[0] 1826 v_1_1 := v_1.Args[1] 1827 if v_1_1.Op != OpConst32 { 1828 break 1829 } 1830 if v_1_1.Type != t { 1831 break 1832 } 1833 d := v_1_1.AuxInt 1834 v.reset(OpAdd32) 1835 v0 := b.NewValue0(v.Pos, OpConst32, t) 1836 v0.AuxInt = int64(int32(c - d)) 1837 v.AddArg(v0) 1838 v.AddArg(x) 1839 return true 1840 } 1841 // match: (Add32 (Sub32 x (Const32 <t> [d])) (Const32 <t> [c])) 1842 // cond: 1843 // result: (Add32 (Const32 <t> [int64(int32(c-d))]) x) 1844 for { 1845 _ = v.Args[1] 1846 v_0 := v.Args[0] 1847 if v_0.Op != OpSub32 { 1848 break 1849 } 1850 _ = v_0.Args[1] 1851 x := v_0.Args[0] 1852 v_0_1 := v_0.Args[1] 1853 if v_0_1.Op != OpConst32 { 1854 break 1855 } 1856 t := v_0_1.Type 1857 d := v_0_1.AuxInt 1858 v_1 := v.Args[1] 1859 if v_1.Op != OpConst32 { 1860 break 1861 } 1862 if v_1.Type != t { 1863 break 1864 } 1865 c := v_1.AuxInt 1866 v.reset(OpAdd32) 1867 v0 := b.NewValue0(v.Pos, OpConst32, t) 1868 v0.AuxInt = int64(int32(c - d)) 1869 v.AddArg(v0) 1870 v.AddArg(x) 1871 return true 1872 } 1873 return false 1874 } 1875 func rewriteValuegeneric_OpAdd32F_0(v *Value) bool { 1876 // match: (Add32F (Const32F [c]) (Const32F [d])) 1877 // cond: 1878 // result: (Const32F [f2i(float64(i2f32(c) + i2f32(d)))]) 1879 for { 1880 _ = v.Args[1] 1881 v_0 := v.Args[0] 1882 if v_0.Op != OpConst32F { 1883 break 1884 } 1885 c := v_0.AuxInt 1886 v_1 := v.Args[1] 1887 if v_1.Op != OpConst32F { 1888 break 1889 } 1890 d := v_1.AuxInt 1891 v.reset(OpConst32F) 1892 v.AuxInt = f2i(float64(i2f32(c) + i2f32(d))) 1893 return true 1894 } 1895 // match: (Add32F (Const32F [d]) (Const32F [c])) 1896 // cond: 1897 // result: (Const32F [f2i(float64(i2f32(c) + i2f32(d)))]) 1898 for { 1899 _ = v.Args[1] 1900 v_0 := v.Args[0] 1901 if v_0.Op != OpConst32F { 1902 break 1903 } 1904 d := v_0.AuxInt 1905 v_1 := v.Args[1] 1906 if v_1.Op != OpConst32F { 1907 break 1908 } 1909 c := v_1.AuxInt 1910 v.reset(OpConst32F) 1911 v.AuxInt = f2i(float64(i2f32(c) + i2f32(d))) 1912 return true 1913 } 1914 // match: (Add32F x (Const32F [0])) 1915 // cond: 1916 // result: x 1917 for { 1918 _ = v.Args[1] 1919 x := v.Args[0] 1920 v_1 := v.Args[1] 1921 if v_1.Op != OpConst32F { 1922 break 1923 } 1924 if v_1.AuxInt != 0 { 1925 break 1926 } 1927 v.reset(OpCopy) 1928 v.Type = x.Type 1929 v.AddArg(x) 1930 return true 1931 } 1932 // match: (Add32F (Const32F [0]) x) 1933 // cond: 1934 // result: x 1935 for { 1936 _ = v.Args[1] 1937 v_0 := v.Args[0] 1938 if v_0.Op != OpConst32F { 1939 break 1940 } 1941 if v_0.AuxInt != 0 { 1942 break 1943 } 1944 x := v.Args[1] 1945 v.reset(OpCopy) 1946 v.Type = x.Type 1947 v.AddArg(x) 1948 return true 1949 } 1950 return false 1951 } 1952 func rewriteValuegeneric_OpAdd64_0(v *Value) bool { 1953 b := v.Block 1954 _ = b 1955 // match: (Add64 (Const64 [c]) (Const64 [d])) 1956 // cond: 1957 // result: (Const64 [c+d]) 1958 for { 1959 _ = v.Args[1] 1960 v_0 := v.Args[0] 1961 if v_0.Op != OpConst64 { 1962 break 1963 } 1964 c := v_0.AuxInt 1965 v_1 := v.Args[1] 1966 if v_1.Op != OpConst64 { 1967 break 1968 } 1969 d := v_1.AuxInt 1970 v.reset(OpConst64) 1971 v.AuxInt = c + d 1972 return true 1973 } 1974 // match: (Add64 (Const64 [d]) (Const64 [c])) 1975 // cond: 1976 // result: (Const64 [c+d]) 1977 for { 1978 _ = v.Args[1] 1979 v_0 := v.Args[0] 1980 if v_0.Op != OpConst64 { 1981 break 1982 } 1983 d := v_0.AuxInt 1984 v_1 := v.Args[1] 1985 if v_1.Op != OpConst64 { 1986 break 1987 } 1988 c := v_1.AuxInt 1989 v.reset(OpConst64) 1990 v.AuxInt = c + d 1991 return true 1992 } 1993 // match: (Add64 (Const64 [0]) x) 1994 // cond: 1995 // result: x 1996 for { 1997 _ = v.Args[1] 1998 v_0 := v.Args[0] 1999 if v_0.Op != OpConst64 { 2000 break 2001 } 2002 if v_0.AuxInt != 0 { 2003 break 2004 } 2005 x := v.Args[1] 2006 v.reset(OpCopy) 2007 v.Type = x.Type 2008 v.AddArg(x) 2009 return true 2010 } 2011 // match: (Add64 x (Const64 [0])) 2012 // cond: 2013 // result: x 2014 for { 2015 _ = v.Args[1] 2016 x := v.Args[0] 2017 v_1 := v.Args[1] 2018 if v_1.Op != OpConst64 { 2019 break 2020 } 2021 if v_1.AuxInt != 0 { 2022 break 2023 } 2024 v.reset(OpCopy) 2025 v.Type = x.Type 2026 v.AddArg(x) 2027 return true 2028 } 2029 // match: (Add64 (Const64 [1]) (Com64 x)) 2030 // cond: 2031 // result: (Neg64 x) 2032 for { 2033 _ = v.Args[1] 2034 v_0 := v.Args[0] 2035 if v_0.Op != OpConst64 { 2036 break 2037 } 2038 if v_0.AuxInt != 1 { 2039 break 2040 } 2041 v_1 := v.Args[1] 2042 if v_1.Op != OpCom64 { 2043 break 2044 } 2045 x := v_1.Args[0] 2046 v.reset(OpNeg64) 2047 v.AddArg(x) 2048 return true 2049 } 2050 // match: (Add64 (Com64 x) (Const64 [1])) 2051 // cond: 2052 // result: (Neg64 x) 2053 for { 2054 _ = v.Args[1] 2055 v_0 := v.Args[0] 2056 if v_0.Op != OpCom64 { 2057 break 2058 } 2059 x := v_0.Args[0] 2060 v_1 := v.Args[1] 2061 if v_1.Op != OpConst64 { 2062 break 2063 } 2064 if v_1.AuxInt != 1 { 2065 break 2066 } 2067 v.reset(OpNeg64) 2068 v.AddArg(x) 2069 return true 2070 } 2071 // match: (Add64 (Add64 i:(Const64 <t>) z) x) 2072 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2073 // result: (Add64 i (Add64 <t> z x)) 2074 for { 2075 _ = v.Args[1] 2076 v_0 := v.Args[0] 2077 if v_0.Op != OpAdd64 { 2078 break 2079 } 2080 _ = v_0.Args[1] 2081 i := v_0.Args[0] 2082 if i.Op != OpConst64 { 2083 break 2084 } 2085 t := i.Type 2086 z := v_0.Args[1] 2087 x := v.Args[1] 2088 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2089 break 2090 } 2091 v.reset(OpAdd64) 2092 v.AddArg(i) 2093 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2094 v0.AddArg(z) 2095 v0.AddArg(x) 2096 v.AddArg(v0) 2097 return true 2098 } 2099 // match: (Add64 (Add64 z i:(Const64 <t>)) x) 2100 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2101 // result: (Add64 i (Add64 <t> z x)) 2102 for { 2103 _ = v.Args[1] 2104 v_0 := v.Args[0] 2105 if v_0.Op != OpAdd64 { 2106 break 2107 } 2108 _ = v_0.Args[1] 2109 z := v_0.Args[0] 2110 i := v_0.Args[1] 2111 if i.Op != OpConst64 { 2112 break 2113 } 2114 t := i.Type 2115 x := v.Args[1] 2116 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2117 break 2118 } 2119 v.reset(OpAdd64) 2120 v.AddArg(i) 2121 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2122 v0.AddArg(z) 2123 v0.AddArg(x) 2124 v.AddArg(v0) 2125 return true 2126 } 2127 // match: (Add64 x (Add64 i:(Const64 <t>) z)) 2128 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2129 // result: (Add64 i (Add64 <t> z x)) 2130 for { 2131 _ = v.Args[1] 2132 x := v.Args[0] 2133 v_1 := v.Args[1] 2134 if v_1.Op != OpAdd64 { 2135 break 2136 } 2137 _ = v_1.Args[1] 2138 i := v_1.Args[0] 2139 if i.Op != OpConst64 { 2140 break 2141 } 2142 t := i.Type 2143 z := v_1.Args[1] 2144 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2145 break 2146 } 2147 v.reset(OpAdd64) 2148 v.AddArg(i) 2149 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2150 v0.AddArg(z) 2151 v0.AddArg(x) 2152 v.AddArg(v0) 2153 return true 2154 } 2155 // match: (Add64 x (Add64 z i:(Const64 <t>))) 2156 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2157 // result: (Add64 i (Add64 <t> z x)) 2158 for { 2159 _ = v.Args[1] 2160 x := v.Args[0] 2161 v_1 := v.Args[1] 2162 if v_1.Op != OpAdd64 { 2163 break 2164 } 2165 _ = v_1.Args[1] 2166 z := v_1.Args[0] 2167 i := v_1.Args[1] 2168 if i.Op != OpConst64 { 2169 break 2170 } 2171 t := i.Type 2172 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2173 break 2174 } 2175 v.reset(OpAdd64) 2176 v.AddArg(i) 2177 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2178 v0.AddArg(z) 2179 v0.AddArg(x) 2180 v.AddArg(v0) 2181 return true 2182 } 2183 return false 2184 } 2185 func rewriteValuegeneric_OpAdd64_10(v *Value) bool { 2186 b := v.Block 2187 _ = b 2188 // match: (Add64 (Sub64 i:(Const64 <t>) z) x) 2189 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2190 // result: (Add64 i (Sub64 <t> x z)) 2191 for { 2192 _ = v.Args[1] 2193 v_0 := v.Args[0] 2194 if v_0.Op != OpSub64 { 2195 break 2196 } 2197 _ = v_0.Args[1] 2198 i := v_0.Args[0] 2199 if i.Op != OpConst64 { 2200 break 2201 } 2202 t := i.Type 2203 z := v_0.Args[1] 2204 x := v.Args[1] 2205 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2206 break 2207 } 2208 v.reset(OpAdd64) 2209 v.AddArg(i) 2210 v0 := b.NewValue0(v.Pos, OpSub64, t) 2211 v0.AddArg(x) 2212 v0.AddArg(z) 2213 v.AddArg(v0) 2214 return true 2215 } 2216 // match: (Add64 x (Sub64 i:(Const64 <t>) z)) 2217 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2218 // result: (Add64 i (Sub64 <t> x z)) 2219 for { 2220 _ = v.Args[1] 2221 x := v.Args[0] 2222 v_1 := v.Args[1] 2223 if v_1.Op != OpSub64 { 2224 break 2225 } 2226 _ = v_1.Args[1] 2227 i := v_1.Args[0] 2228 if i.Op != OpConst64 { 2229 break 2230 } 2231 t := i.Type 2232 z := v_1.Args[1] 2233 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2234 break 2235 } 2236 v.reset(OpAdd64) 2237 v.AddArg(i) 2238 v0 := b.NewValue0(v.Pos, OpSub64, t) 2239 v0.AddArg(x) 2240 v0.AddArg(z) 2241 v.AddArg(v0) 2242 return true 2243 } 2244 // match: (Add64 x (Sub64 i:(Const64 <t>) z)) 2245 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2246 // result: (Add64 i (Sub64 <t> x z)) 2247 for { 2248 _ = v.Args[1] 2249 x := v.Args[0] 2250 v_1 := v.Args[1] 2251 if v_1.Op != OpSub64 { 2252 break 2253 } 2254 _ = v_1.Args[1] 2255 i := v_1.Args[0] 2256 if i.Op != OpConst64 { 2257 break 2258 } 2259 t := i.Type 2260 z := v_1.Args[1] 2261 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2262 break 2263 } 2264 v.reset(OpAdd64) 2265 v.AddArg(i) 2266 v0 := b.NewValue0(v.Pos, OpSub64, t) 2267 v0.AddArg(x) 2268 v0.AddArg(z) 2269 v.AddArg(v0) 2270 return true 2271 } 2272 // match: (Add64 (Sub64 i:(Const64 <t>) z) x) 2273 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2274 // result: (Add64 i (Sub64 <t> x z)) 2275 for { 2276 _ = v.Args[1] 2277 v_0 := v.Args[0] 2278 if v_0.Op != OpSub64 { 2279 break 2280 } 2281 _ = v_0.Args[1] 2282 i := v_0.Args[0] 2283 if i.Op != OpConst64 { 2284 break 2285 } 2286 t := i.Type 2287 z := v_0.Args[1] 2288 x := v.Args[1] 2289 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2290 break 2291 } 2292 v.reset(OpAdd64) 2293 v.AddArg(i) 2294 v0 := b.NewValue0(v.Pos, OpSub64, t) 2295 v0.AddArg(x) 2296 v0.AddArg(z) 2297 v.AddArg(v0) 2298 return true 2299 } 2300 // match: (Add64 (Sub64 z i:(Const64 <t>)) x) 2301 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2302 // result: (Sub64 (Add64 <t> x z) i) 2303 for { 2304 _ = v.Args[1] 2305 v_0 := v.Args[0] 2306 if v_0.Op != OpSub64 { 2307 break 2308 } 2309 _ = v_0.Args[1] 2310 z := v_0.Args[0] 2311 i := v_0.Args[1] 2312 if i.Op != OpConst64 { 2313 break 2314 } 2315 t := i.Type 2316 x := v.Args[1] 2317 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2318 break 2319 } 2320 v.reset(OpSub64) 2321 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2322 v0.AddArg(x) 2323 v0.AddArg(z) 2324 v.AddArg(v0) 2325 v.AddArg(i) 2326 return true 2327 } 2328 // match: (Add64 x (Sub64 z i:(Const64 <t>))) 2329 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2330 // result: (Sub64 (Add64 <t> x z) i) 2331 for { 2332 _ = v.Args[1] 2333 x := v.Args[0] 2334 v_1 := v.Args[1] 2335 if v_1.Op != OpSub64 { 2336 break 2337 } 2338 _ = v_1.Args[1] 2339 z := v_1.Args[0] 2340 i := v_1.Args[1] 2341 if i.Op != OpConst64 { 2342 break 2343 } 2344 t := i.Type 2345 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2346 break 2347 } 2348 v.reset(OpSub64) 2349 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2350 v0.AddArg(x) 2351 v0.AddArg(z) 2352 v.AddArg(v0) 2353 v.AddArg(i) 2354 return true 2355 } 2356 // match: (Add64 x (Sub64 z i:(Const64 <t>))) 2357 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2358 // result: (Sub64 (Add64 <t> x z) i) 2359 for { 2360 _ = v.Args[1] 2361 x := v.Args[0] 2362 v_1 := v.Args[1] 2363 if v_1.Op != OpSub64 { 2364 break 2365 } 2366 _ = v_1.Args[1] 2367 z := v_1.Args[0] 2368 i := v_1.Args[1] 2369 if i.Op != OpConst64 { 2370 break 2371 } 2372 t := i.Type 2373 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2374 break 2375 } 2376 v.reset(OpSub64) 2377 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2378 v0.AddArg(x) 2379 v0.AddArg(z) 2380 v.AddArg(v0) 2381 v.AddArg(i) 2382 return true 2383 } 2384 // match: (Add64 (Sub64 z i:(Const64 <t>)) x) 2385 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2386 // result: (Sub64 (Add64 <t> x z) i) 2387 for { 2388 _ = v.Args[1] 2389 v_0 := v.Args[0] 2390 if v_0.Op != OpSub64 { 2391 break 2392 } 2393 _ = v_0.Args[1] 2394 z := v_0.Args[0] 2395 i := v_0.Args[1] 2396 if i.Op != OpConst64 { 2397 break 2398 } 2399 t := i.Type 2400 x := v.Args[1] 2401 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2402 break 2403 } 2404 v.reset(OpSub64) 2405 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2406 v0.AddArg(x) 2407 v0.AddArg(z) 2408 v.AddArg(v0) 2409 v.AddArg(i) 2410 return true 2411 } 2412 // match: (Add64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x)) 2413 // cond: 2414 // result: (Add64 (Const64 <t> [c+d]) x) 2415 for { 2416 _ = v.Args[1] 2417 v_0 := v.Args[0] 2418 if v_0.Op != OpConst64 { 2419 break 2420 } 2421 t := v_0.Type 2422 c := v_0.AuxInt 2423 v_1 := v.Args[1] 2424 if v_1.Op != OpAdd64 { 2425 break 2426 } 2427 _ = v_1.Args[1] 2428 v_1_0 := v_1.Args[0] 2429 if v_1_0.Op != OpConst64 { 2430 break 2431 } 2432 if v_1_0.Type != t { 2433 break 2434 } 2435 d := v_1_0.AuxInt 2436 x := v_1.Args[1] 2437 v.reset(OpAdd64) 2438 v0 := b.NewValue0(v.Pos, OpConst64, t) 2439 v0.AuxInt = c + d 2440 v.AddArg(v0) 2441 v.AddArg(x) 2442 return true 2443 } 2444 // match: (Add64 (Const64 <t> [c]) (Add64 x (Const64 <t> [d]))) 2445 // cond: 2446 // result: (Add64 (Const64 <t> [c+d]) x) 2447 for { 2448 _ = v.Args[1] 2449 v_0 := v.Args[0] 2450 if v_0.Op != OpConst64 { 2451 break 2452 } 2453 t := v_0.Type 2454 c := v_0.AuxInt 2455 v_1 := v.Args[1] 2456 if v_1.Op != OpAdd64 { 2457 break 2458 } 2459 _ = v_1.Args[1] 2460 x := v_1.Args[0] 2461 v_1_1 := v_1.Args[1] 2462 if v_1_1.Op != OpConst64 { 2463 break 2464 } 2465 if v_1_1.Type != t { 2466 break 2467 } 2468 d := v_1_1.AuxInt 2469 v.reset(OpAdd64) 2470 v0 := b.NewValue0(v.Pos, OpConst64, t) 2471 v0.AuxInt = c + d 2472 v.AddArg(v0) 2473 v.AddArg(x) 2474 return true 2475 } 2476 return false 2477 } 2478 func rewriteValuegeneric_OpAdd64_20(v *Value) bool { 2479 b := v.Block 2480 _ = b 2481 // match: (Add64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c])) 2482 // cond: 2483 // result: (Add64 (Const64 <t> [c+d]) x) 2484 for { 2485 _ = v.Args[1] 2486 v_0 := v.Args[0] 2487 if v_0.Op != OpAdd64 { 2488 break 2489 } 2490 _ = v_0.Args[1] 2491 v_0_0 := v_0.Args[0] 2492 if v_0_0.Op != OpConst64 { 2493 break 2494 } 2495 t := v_0_0.Type 2496 d := v_0_0.AuxInt 2497 x := v_0.Args[1] 2498 v_1 := v.Args[1] 2499 if v_1.Op != OpConst64 { 2500 break 2501 } 2502 if v_1.Type != t { 2503 break 2504 } 2505 c := v_1.AuxInt 2506 v.reset(OpAdd64) 2507 v0 := b.NewValue0(v.Pos, OpConst64, t) 2508 v0.AuxInt = c + d 2509 v.AddArg(v0) 2510 v.AddArg(x) 2511 return true 2512 } 2513 // match: (Add64 (Add64 x (Const64 <t> [d])) (Const64 <t> [c])) 2514 // cond: 2515 // result: (Add64 (Const64 <t> [c+d]) x) 2516 for { 2517 _ = v.Args[1] 2518 v_0 := v.Args[0] 2519 if v_0.Op != OpAdd64 { 2520 break 2521 } 2522 _ = v_0.Args[1] 2523 x := v_0.Args[0] 2524 v_0_1 := v_0.Args[1] 2525 if v_0_1.Op != OpConst64 { 2526 break 2527 } 2528 t := v_0_1.Type 2529 d := v_0_1.AuxInt 2530 v_1 := v.Args[1] 2531 if v_1.Op != OpConst64 { 2532 break 2533 } 2534 if v_1.Type != t { 2535 break 2536 } 2537 c := v_1.AuxInt 2538 v.reset(OpAdd64) 2539 v0 := b.NewValue0(v.Pos, OpConst64, t) 2540 v0.AuxInt = c + d 2541 v.AddArg(v0) 2542 v.AddArg(x) 2543 return true 2544 } 2545 // match: (Add64 (Const64 <t> [c]) (Sub64 (Const64 <t> [d]) x)) 2546 // cond: 2547 // result: (Sub64 (Const64 <t> [c+d]) x) 2548 for { 2549 _ = v.Args[1] 2550 v_0 := v.Args[0] 2551 if v_0.Op != OpConst64 { 2552 break 2553 } 2554 t := v_0.Type 2555 c := v_0.AuxInt 2556 v_1 := v.Args[1] 2557 if v_1.Op != OpSub64 { 2558 break 2559 } 2560 _ = v_1.Args[1] 2561 v_1_0 := v_1.Args[0] 2562 if v_1_0.Op != OpConst64 { 2563 break 2564 } 2565 if v_1_0.Type != t { 2566 break 2567 } 2568 d := v_1_0.AuxInt 2569 x := v_1.Args[1] 2570 v.reset(OpSub64) 2571 v0 := b.NewValue0(v.Pos, OpConst64, t) 2572 v0.AuxInt = c + d 2573 v.AddArg(v0) 2574 v.AddArg(x) 2575 return true 2576 } 2577 // match: (Add64 (Sub64 (Const64 <t> [d]) x) (Const64 <t> [c])) 2578 // cond: 2579 // result: (Sub64 (Const64 <t> [c+d]) x) 2580 for { 2581 _ = v.Args[1] 2582 v_0 := v.Args[0] 2583 if v_0.Op != OpSub64 { 2584 break 2585 } 2586 _ = v_0.Args[1] 2587 v_0_0 := v_0.Args[0] 2588 if v_0_0.Op != OpConst64 { 2589 break 2590 } 2591 t := v_0_0.Type 2592 d := v_0_0.AuxInt 2593 x := v_0.Args[1] 2594 v_1 := v.Args[1] 2595 if v_1.Op != OpConst64 { 2596 break 2597 } 2598 if v_1.Type != t { 2599 break 2600 } 2601 c := v_1.AuxInt 2602 v.reset(OpSub64) 2603 v0 := b.NewValue0(v.Pos, OpConst64, t) 2604 v0.AuxInt = c + d 2605 v.AddArg(v0) 2606 v.AddArg(x) 2607 return true 2608 } 2609 // match: (Add64 (Const64 <t> [c]) (Sub64 x (Const64 <t> [d]))) 2610 // cond: 2611 // result: (Add64 (Const64 <t> [c-d]) x) 2612 for { 2613 _ = v.Args[1] 2614 v_0 := v.Args[0] 2615 if v_0.Op != OpConst64 { 2616 break 2617 } 2618 t := v_0.Type 2619 c := v_0.AuxInt 2620 v_1 := v.Args[1] 2621 if v_1.Op != OpSub64 { 2622 break 2623 } 2624 _ = v_1.Args[1] 2625 x := v_1.Args[0] 2626 v_1_1 := v_1.Args[1] 2627 if v_1_1.Op != OpConst64 { 2628 break 2629 } 2630 if v_1_1.Type != t { 2631 break 2632 } 2633 d := v_1_1.AuxInt 2634 v.reset(OpAdd64) 2635 v0 := b.NewValue0(v.Pos, OpConst64, t) 2636 v0.AuxInt = c - d 2637 v.AddArg(v0) 2638 v.AddArg(x) 2639 return true 2640 } 2641 // match: (Add64 (Sub64 x (Const64 <t> [d])) (Const64 <t> [c])) 2642 // cond: 2643 // result: (Add64 (Const64 <t> [c-d]) x) 2644 for { 2645 _ = v.Args[1] 2646 v_0 := v.Args[0] 2647 if v_0.Op != OpSub64 { 2648 break 2649 } 2650 _ = v_0.Args[1] 2651 x := v_0.Args[0] 2652 v_0_1 := v_0.Args[1] 2653 if v_0_1.Op != OpConst64 { 2654 break 2655 } 2656 t := v_0_1.Type 2657 d := v_0_1.AuxInt 2658 v_1 := v.Args[1] 2659 if v_1.Op != OpConst64 { 2660 break 2661 } 2662 if v_1.Type != t { 2663 break 2664 } 2665 c := v_1.AuxInt 2666 v.reset(OpAdd64) 2667 v0 := b.NewValue0(v.Pos, OpConst64, t) 2668 v0.AuxInt = c - d 2669 v.AddArg(v0) 2670 v.AddArg(x) 2671 return true 2672 } 2673 return false 2674 } 2675 func rewriteValuegeneric_OpAdd64F_0(v *Value) bool { 2676 // match: (Add64F (Const64F [c]) (Const64F [d])) 2677 // cond: 2678 // result: (Const64F [f2i(i2f(c) + i2f(d))]) 2679 for { 2680 _ = v.Args[1] 2681 v_0 := v.Args[0] 2682 if v_0.Op != OpConst64F { 2683 break 2684 } 2685 c := v_0.AuxInt 2686 v_1 := v.Args[1] 2687 if v_1.Op != OpConst64F { 2688 break 2689 } 2690 d := v_1.AuxInt 2691 v.reset(OpConst64F) 2692 v.AuxInt = f2i(i2f(c) + i2f(d)) 2693 return true 2694 } 2695 // match: (Add64F (Const64F [d]) (Const64F [c])) 2696 // cond: 2697 // result: (Const64F [f2i(i2f(c) + i2f(d))]) 2698 for { 2699 _ = v.Args[1] 2700 v_0 := v.Args[0] 2701 if v_0.Op != OpConst64F { 2702 break 2703 } 2704 d := v_0.AuxInt 2705 v_1 := v.Args[1] 2706 if v_1.Op != OpConst64F { 2707 break 2708 } 2709 c := v_1.AuxInt 2710 v.reset(OpConst64F) 2711 v.AuxInt = f2i(i2f(c) + i2f(d)) 2712 return true 2713 } 2714 // match: (Add64F x (Const64F [0])) 2715 // cond: 2716 // result: x 2717 for { 2718 _ = v.Args[1] 2719 x := v.Args[0] 2720 v_1 := v.Args[1] 2721 if v_1.Op != OpConst64F { 2722 break 2723 } 2724 if v_1.AuxInt != 0 { 2725 break 2726 } 2727 v.reset(OpCopy) 2728 v.Type = x.Type 2729 v.AddArg(x) 2730 return true 2731 } 2732 // match: (Add64F (Const64F [0]) x) 2733 // cond: 2734 // result: x 2735 for { 2736 _ = v.Args[1] 2737 v_0 := v.Args[0] 2738 if v_0.Op != OpConst64F { 2739 break 2740 } 2741 if v_0.AuxInt != 0 { 2742 break 2743 } 2744 x := v.Args[1] 2745 v.reset(OpCopy) 2746 v.Type = x.Type 2747 v.AddArg(x) 2748 return true 2749 } 2750 return false 2751 } 2752 func rewriteValuegeneric_OpAdd8_0(v *Value) bool { 2753 b := v.Block 2754 _ = b 2755 // match: (Add8 (Const8 [c]) (Const8 [d])) 2756 // cond: 2757 // result: (Const8 [int64(int8(c+d))]) 2758 for { 2759 _ = v.Args[1] 2760 v_0 := v.Args[0] 2761 if v_0.Op != OpConst8 { 2762 break 2763 } 2764 c := v_0.AuxInt 2765 v_1 := v.Args[1] 2766 if v_1.Op != OpConst8 { 2767 break 2768 } 2769 d := v_1.AuxInt 2770 v.reset(OpConst8) 2771 v.AuxInt = int64(int8(c + d)) 2772 return true 2773 } 2774 // match: (Add8 (Const8 [d]) (Const8 [c])) 2775 // cond: 2776 // result: (Const8 [int64(int8(c+d))]) 2777 for { 2778 _ = v.Args[1] 2779 v_0 := v.Args[0] 2780 if v_0.Op != OpConst8 { 2781 break 2782 } 2783 d := v_0.AuxInt 2784 v_1 := v.Args[1] 2785 if v_1.Op != OpConst8 { 2786 break 2787 } 2788 c := v_1.AuxInt 2789 v.reset(OpConst8) 2790 v.AuxInt = int64(int8(c + d)) 2791 return true 2792 } 2793 // match: (Add8 (Const8 [0]) x) 2794 // cond: 2795 // result: x 2796 for { 2797 _ = v.Args[1] 2798 v_0 := v.Args[0] 2799 if v_0.Op != OpConst8 { 2800 break 2801 } 2802 if v_0.AuxInt != 0 { 2803 break 2804 } 2805 x := v.Args[1] 2806 v.reset(OpCopy) 2807 v.Type = x.Type 2808 v.AddArg(x) 2809 return true 2810 } 2811 // match: (Add8 x (Const8 [0])) 2812 // cond: 2813 // result: x 2814 for { 2815 _ = v.Args[1] 2816 x := v.Args[0] 2817 v_1 := v.Args[1] 2818 if v_1.Op != OpConst8 { 2819 break 2820 } 2821 if v_1.AuxInt != 0 { 2822 break 2823 } 2824 v.reset(OpCopy) 2825 v.Type = x.Type 2826 v.AddArg(x) 2827 return true 2828 } 2829 // match: (Add8 (Const8 [1]) (Com8 x)) 2830 // cond: 2831 // result: (Neg8 x) 2832 for { 2833 _ = v.Args[1] 2834 v_0 := v.Args[0] 2835 if v_0.Op != OpConst8 { 2836 break 2837 } 2838 if v_0.AuxInt != 1 { 2839 break 2840 } 2841 v_1 := v.Args[1] 2842 if v_1.Op != OpCom8 { 2843 break 2844 } 2845 x := v_1.Args[0] 2846 v.reset(OpNeg8) 2847 v.AddArg(x) 2848 return true 2849 } 2850 // match: (Add8 (Com8 x) (Const8 [1])) 2851 // cond: 2852 // result: (Neg8 x) 2853 for { 2854 _ = v.Args[1] 2855 v_0 := v.Args[0] 2856 if v_0.Op != OpCom8 { 2857 break 2858 } 2859 x := v_0.Args[0] 2860 v_1 := v.Args[1] 2861 if v_1.Op != OpConst8 { 2862 break 2863 } 2864 if v_1.AuxInt != 1 { 2865 break 2866 } 2867 v.reset(OpNeg8) 2868 v.AddArg(x) 2869 return true 2870 } 2871 // match: (Add8 (Add8 i:(Const8 <t>) z) x) 2872 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 2873 // result: (Add8 i (Add8 <t> z x)) 2874 for { 2875 _ = v.Args[1] 2876 v_0 := v.Args[0] 2877 if v_0.Op != OpAdd8 { 2878 break 2879 } 2880 _ = v_0.Args[1] 2881 i := v_0.Args[0] 2882 if i.Op != OpConst8 { 2883 break 2884 } 2885 t := i.Type 2886 z := v_0.Args[1] 2887 x := v.Args[1] 2888 if !(z.Op != OpConst8 && x.Op != OpConst8) { 2889 break 2890 } 2891 v.reset(OpAdd8) 2892 v.AddArg(i) 2893 v0 := b.NewValue0(v.Pos, OpAdd8, t) 2894 v0.AddArg(z) 2895 v0.AddArg(x) 2896 v.AddArg(v0) 2897 return true 2898 } 2899 // match: (Add8 (Add8 z i:(Const8 <t>)) x) 2900 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 2901 // result: (Add8 i (Add8 <t> z x)) 2902 for { 2903 _ = v.Args[1] 2904 v_0 := v.Args[0] 2905 if v_0.Op != OpAdd8 { 2906 break 2907 } 2908 _ = v_0.Args[1] 2909 z := v_0.Args[0] 2910 i := v_0.Args[1] 2911 if i.Op != OpConst8 { 2912 break 2913 } 2914 t := i.Type 2915 x := v.Args[1] 2916 if !(z.Op != OpConst8 && x.Op != OpConst8) { 2917 break 2918 } 2919 v.reset(OpAdd8) 2920 v.AddArg(i) 2921 v0 := b.NewValue0(v.Pos, OpAdd8, t) 2922 v0.AddArg(z) 2923 v0.AddArg(x) 2924 v.AddArg(v0) 2925 return true 2926 } 2927 // match: (Add8 x (Add8 i:(Const8 <t>) z)) 2928 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 2929 // result: (Add8 i (Add8 <t> z x)) 2930 for { 2931 _ = v.Args[1] 2932 x := v.Args[0] 2933 v_1 := v.Args[1] 2934 if v_1.Op != OpAdd8 { 2935 break 2936 } 2937 _ = v_1.Args[1] 2938 i := v_1.Args[0] 2939 if i.Op != OpConst8 { 2940 break 2941 } 2942 t := i.Type 2943 z := v_1.Args[1] 2944 if !(z.Op != OpConst8 && x.Op != OpConst8) { 2945 break 2946 } 2947 v.reset(OpAdd8) 2948 v.AddArg(i) 2949 v0 := b.NewValue0(v.Pos, OpAdd8, t) 2950 v0.AddArg(z) 2951 v0.AddArg(x) 2952 v.AddArg(v0) 2953 return true 2954 } 2955 // match: (Add8 x (Add8 z i:(Const8 <t>))) 2956 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 2957 // result: (Add8 i (Add8 <t> z x)) 2958 for { 2959 _ = v.Args[1] 2960 x := v.Args[0] 2961 v_1 := v.Args[1] 2962 if v_1.Op != OpAdd8 { 2963 break 2964 } 2965 _ = v_1.Args[1] 2966 z := v_1.Args[0] 2967 i := v_1.Args[1] 2968 if i.Op != OpConst8 { 2969 break 2970 } 2971 t := i.Type 2972 if !(z.Op != OpConst8 && x.Op != OpConst8) { 2973 break 2974 } 2975 v.reset(OpAdd8) 2976 v.AddArg(i) 2977 v0 := b.NewValue0(v.Pos, OpAdd8, t) 2978 v0.AddArg(z) 2979 v0.AddArg(x) 2980 v.AddArg(v0) 2981 return true 2982 } 2983 return false 2984 } 2985 func rewriteValuegeneric_OpAdd8_10(v *Value) bool { 2986 b := v.Block 2987 _ = b 2988 // match: (Add8 (Sub8 i:(Const8 <t>) z) x) 2989 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 2990 // result: (Add8 i (Sub8 <t> x z)) 2991 for { 2992 _ = v.Args[1] 2993 v_0 := v.Args[0] 2994 if v_0.Op != OpSub8 { 2995 break 2996 } 2997 _ = v_0.Args[1] 2998 i := v_0.Args[0] 2999 if i.Op != OpConst8 { 3000 break 3001 } 3002 t := i.Type 3003 z := v_0.Args[1] 3004 x := v.Args[1] 3005 if !(z.Op != OpConst8 && x.Op != OpConst8) { 3006 break 3007 } 3008 v.reset(OpAdd8) 3009 v.AddArg(i) 3010 v0 := b.NewValue0(v.Pos, OpSub8, t) 3011 v0.AddArg(x) 3012 v0.AddArg(z) 3013 v.AddArg(v0) 3014 return true 3015 } 3016 // match: (Add8 x (Sub8 i:(Const8 <t>) z)) 3017 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 3018 // result: (Add8 i (Sub8 <t> x z)) 3019 for { 3020 _ = v.Args[1] 3021 x := v.Args[0] 3022 v_1 := v.Args[1] 3023 if v_1.Op != OpSub8 { 3024 break 3025 } 3026 _ = v_1.Args[1] 3027 i := v_1.Args[0] 3028 if i.Op != OpConst8 { 3029 break 3030 } 3031 t := i.Type 3032 z := v_1.Args[1] 3033 if !(z.Op != OpConst8 && x.Op != OpConst8) { 3034 break 3035 } 3036 v.reset(OpAdd8) 3037 v.AddArg(i) 3038 v0 := b.NewValue0(v.Pos, OpSub8, t) 3039 v0.AddArg(x) 3040 v0.AddArg(z) 3041 v.AddArg(v0) 3042 return true 3043 } 3044 // match: (Add8 x (Sub8 i:(Const8 <t>) z)) 3045 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 3046 // result: (Add8 i (Sub8 <t> x z)) 3047 for { 3048 _ = v.Args[1] 3049 x := v.Args[0] 3050 v_1 := v.Args[1] 3051 if v_1.Op != OpSub8 { 3052 break 3053 } 3054 _ = v_1.Args[1] 3055 i := v_1.Args[0] 3056 if i.Op != OpConst8 { 3057 break 3058 } 3059 t := i.Type 3060 z := v_1.Args[1] 3061 if !(z.Op != OpConst8 && x.Op != OpConst8) { 3062 break 3063 } 3064 v.reset(OpAdd8) 3065 v.AddArg(i) 3066 v0 := b.NewValue0(v.Pos, OpSub8, t) 3067 v0.AddArg(x) 3068 v0.AddArg(z) 3069 v.AddArg(v0) 3070 return true 3071 } 3072 // match: (Add8 (Sub8 i:(Const8 <t>) z) x) 3073 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 3074 // result: (Add8 i (Sub8 <t> x z)) 3075 for { 3076 _ = v.Args[1] 3077 v_0 := v.Args[0] 3078 if v_0.Op != OpSub8 { 3079 break 3080 } 3081 _ = v_0.Args[1] 3082 i := v_0.Args[0] 3083 if i.Op != OpConst8 { 3084 break 3085 } 3086 t := i.Type 3087 z := v_0.Args[1] 3088 x := v.Args[1] 3089 if !(z.Op != OpConst8 && x.Op != OpConst8) { 3090 break 3091 } 3092 v.reset(OpAdd8) 3093 v.AddArg(i) 3094 v0 := b.NewValue0(v.Pos, OpSub8, t) 3095 v0.AddArg(x) 3096 v0.AddArg(z) 3097 v.AddArg(v0) 3098 return true 3099 } 3100 // match: (Add8 (Sub8 z i:(Const8 <t>)) x) 3101 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 3102 // result: (Sub8 (Add8 <t> x z) i) 3103 for { 3104 _ = v.Args[1] 3105 v_0 := v.Args[0] 3106 if v_0.Op != OpSub8 { 3107 break 3108 } 3109 _ = v_0.Args[1] 3110 z := v_0.Args[0] 3111 i := v_0.Args[1] 3112 if i.Op != OpConst8 { 3113 break 3114 } 3115 t := i.Type 3116 x := v.Args[1] 3117 if !(z.Op != OpConst8 && x.Op != OpConst8) { 3118 break 3119 } 3120 v.reset(OpSub8) 3121 v0 := b.NewValue0(v.Pos, OpAdd8, t) 3122 v0.AddArg(x) 3123 v0.AddArg(z) 3124 v.AddArg(v0) 3125 v.AddArg(i) 3126 return true 3127 } 3128 // match: (Add8 x (Sub8 z i:(Const8 <t>))) 3129 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 3130 // result: (Sub8 (Add8 <t> x z) i) 3131 for { 3132 _ = v.Args[1] 3133 x := v.Args[0] 3134 v_1 := v.Args[1] 3135 if v_1.Op != OpSub8 { 3136 break 3137 } 3138 _ = v_1.Args[1] 3139 z := v_1.Args[0] 3140 i := v_1.Args[1] 3141 if i.Op != OpConst8 { 3142 break 3143 } 3144 t := i.Type 3145 if !(z.Op != OpConst8 && x.Op != OpConst8) { 3146 break 3147 } 3148 v.reset(OpSub8) 3149 v0 := b.NewValue0(v.Pos, OpAdd8, t) 3150 v0.AddArg(x) 3151 v0.AddArg(z) 3152 v.AddArg(v0) 3153 v.AddArg(i) 3154 return true 3155 } 3156 // match: (Add8 x (Sub8 z i:(Const8 <t>))) 3157 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 3158 // result: (Sub8 (Add8 <t> x z) i) 3159 for { 3160 _ = v.Args[1] 3161 x := v.Args[0] 3162 v_1 := v.Args[1] 3163 if v_1.Op != OpSub8 { 3164 break 3165 } 3166 _ = v_1.Args[1] 3167 z := v_1.Args[0] 3168 i := v_1.Args[1] 3169 if i.Op != OpConst8 { 3170 break 3171 } 3172 t := i.Type 3173 if !(z.Op != OpConst8 && x.Op != OpConst8) { 3174 break 3175 } 3176 v.reset(OpSub8) 3177 v0 := b.NewValue0(v.Pos, OpAdd8, t) 3178 v0.AddArg(x) 3179 v0.AddArg(z) 3180 v.AddArg(v0) 3181 v.AddArg(i) 3182 return true 3183 } 3184 // match: (Add8 (Sub8 z i:(Const8 <t>)) x) 3185 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 3186 // result: (Sub8 (Add8 <t> x z) i) 3187 for { 3188 _ = v.Args[1] 3189 v_0 := v.Args[0] 3190 if v_0.Op != OpSub8 { 3191 break 3192 } 3193 _ = v_0.Args[1] 3194 z := v_0.Args[0] 3195 i := v_0.Args[1] 3196 if i.Op != OpConst8 { 3197 break 3198 } 3199 t := i.Type 3200 x := v.Args[1] 3201 if !(z.Op != OpConst8 && x.Op != OpConst8) { 3202 break 3203 } 3204 v.reset(OpSub8) 3205 v0 := b.NewValue0(v.Pos, OpAdd8, t) 3206 v0.AddArg(x) 3207 v0.AddArg(z) 3208 v.AddArg(v0) 3209 v.AddArg(i) 3210 return true 3211 } 3212 // match: (Add8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x)) 3213 // cond: 3214 // result: (Add8 (Const8 <t> [int64(int8(c+d))]) x) 3215 for { 3216 _ = v.Args[1] 3217 v_0 := v.Args[0] 3218 if v_0.Op != OpConst8 { 3219 break 3220 } 3221 t := v_0.Type 3222 c := v_0.AuxInt 3223 v_1 := v.Args[1] 3224 if v_1.Op != OpAdd8 { 3225 break 3226 } 3227 _ = v_1.Args[1] 3228 v_1_0 := v_1.Args[0] 3229 if v_1_0.Op != OpConst8 { 3230 break 3231 } 3232 if v_1_0.Type != t { 3233 break 3234 } 3235 d := v_1_0.AuxInt 3236 x := v_1.Args[1] 3237 v.reset(OpAdd8) 3238 v0 := b.NewValue0(v.Pos, OpConst8, t) 3239 v0.AuxInt = int64(int8(c + d)) 3240 v.AddArg(v0) 3241 v.AddArg(x) 3242 return true 3243 } 3244 // match: (Add8 (Const8 <t> [c]) (Add8 x (Const8 <t> [d]))) 3245 // cond: 3246 // result: (Add8 (Const8 <t> [int64(int8(c+d))]) x) 3247 for { 3248 _ = v.Args[1] 3249 v_0 := v.Args[0] 3250 if v_0.Op != OpConst8 { 3251 break 3252 } 3253 t := v_0.Type 3254 c := v_0.AuxInt 3255 v_1 := v.Args[1] 3256 if v_1.Op != OpAdd8 { 3257 break 3258 } 3259 _ = v_1.Args[1] 3260 x := v_1.Args[0] 3261 v_1_1 := v_1.Args[1] 3262 if v_1_1.Op != OpConst8 { 3263 break 3264 } 3265 if v_1_1.Type != t { 3266 break 3267 } 3268 d := v_1_1.AuxInt 3269 v.reset(OpAdd8) 3270 v0 := b.NewValue0(v.Pos, OpConst8, t) 3271 v0.AuxInt = int64(int8(c + d)) 3272 v.AddArg(v0) 3273 v.AddArg(x) 3274 return true 3275 } 3276 return false 3277 } 3278 func rewriteValuegeneric_OpAdd8_20(v *Value) bool { 3279 b := v.Block 3280 _ = b 3281 // match: (Add8 (Add8 (Const8 <t> [d]) x) (Const8 <t> [c])) 3282 // cond: 3283 // result: (Add8 (Const8 <t> [int64(int8(c+d))]) x) 3284 for { 3285 _ = v.Args[1] 3286 v_0 := v.Args[0] 3287 if v_0.Op != OpAdd8 { 3288 break 3289 } 3290 _ = v_0.Args[1] 3291 v_0_0 := v_0.Args[0] 3292 if v_0_0.Op != OpConst8 { 3293 break 3294 } 3295 t := v_0_0.Type 3296 d := v_0_0.AuxInt 3297 x := v_0.Args[1] 3298 v_1 := v.Args[1] 3299 if v_1.Op != OpConst8 { 3300 break 3301 } 3302 if v_1.Type != t { 3303 break 3304 } 3305 c := v_1.AuxInt 3306 v.reset(OpAdd8) 3307 v0 := b.NewValue0(v.Pos, OpConst8, t) 3308 v0.AuxInt = int64(int8(c + d)) 3309 v.AddArg(v0) 3310 v.AddArg(x) 3311 return true 3312 } 3313 // match: (Add8 (Add8 x (Const8 <t> [d])) (Const8 <t> [c])) 3314 // cond: 3315 // result: (Add8 (Const8 <t> [int64(int8(c+d))]) x) 3316 for { 3317 _ = v.Args[1] 3318 v_0 := v.Args[0] 3319 if v_0.Op != OpAdd8 { 3320 break 3321 } 3322 _ = v_0.Args[1] 3323 x := v_0.Args[0] 3324 v_0_1 := v_0.Args[1] 3325 if v_0_1.Op != OpConst8 { 3326 break 3327 } 3328 t := v_0_1.Type 3329 d := v_0_1.AuxInt 3330 v_1 := v.Args[1] 3331 if v_1.Op != OpConst8 { 3332 break 3333 } 3334 if v_1.Type != t { 3335 break 3336 } 3337 c := v_1.AuxInt 3338 v.reset(OpAdd8) 3339 v0 := b.NewValue0(v.Pos, OpConst8, t) 3340 v0.AuxInt = int64(int8(c + d)) 3341 v.AddArg(v0) 3342 v.AddArg(x) 3343 return true 3344 } 3345 // match: (Add8 (Const8 <t> [c]) (Sub8 (Const8 <t> [d]) x)) 3346 // cond: 3347 // result: (Sub8 (Const8 <t> [int64(int8(c+d))]) x) 3348 for { 3349 _ = v.Args[1] 3350 v_0 := v.Args[0] 3351 if v_0.Op != OpConst8 { 3352 break 3353 } 3354 t := v_0.Type 3355 c := v_0.AuxInt 3356 v_1 := v.Args[1] 3357 if v_1.Op != OpSub8 { 3358 break 3359 } 3360 _ = v_1.Args[1] 3361 v_1_0 := v_1.Args[0] 3362 if v_1_0.Op != OpConst8 { 3363 break 3364 } 3365 if v_1_0.Type != t { 3366 break 3367 } 3368 d := v_1_0.AuxInt 3369 x := v_1.Args[1] 3370 v.reset(OpSub8) 3371 v0 := b.NewValue0(v.Pos, OpConst8, t) 3372 v0.AuxInt = int64(int8(c + d)) 3373 v.AddArg(v0) 3374 v.AddArg(x) 3375 return true 3376 } 3377 // match: (Add8 (Sub8 (Const8 <t> [d]) x) (Const8 <t> [c])) 3378 // cond: 3379 // result: (Sub8 (Const8 <t> [int64(int8(c+d))]) x) 3380 for { 3381 _ = v.Args[1] 3382 v_0 := v.Args[0] 3383 if v_0.Op != OpSub8 { 3384 break 3385 } 3386 _ = v_0.Args[1] 3387 v_0_0 := v_0.Args[0] 3388 if v_0_0.Op != OpConst8 { 3389 break 3390 } 3391 t := v_0_0.Type 3392 d := v_0_0.AuxInt 3393 x := v_0.Args[1] 3394 v_1 := v.Args[1] 3395 if v_1.Op != OpConst8 { 3396 break 3397 } 3398 if v_1.Type != t { 3399 break 3400 } 3401 c := v_1.AuxInt 3402 v.reset(OpSub8) 3403 v0 := b.NewValue0(v.Pos, OpConst8, t) 3404 v0.AuxInt = int64(int8(c + d)) 3405 v.AddArg(v0) 3406 v.AddArg(x) 3407 return true 3408 } 3409 // match: (Add8 (Const8 <t> [c]) (Sub8 x (Const8 <t> [d]))) 3410 // cond: 3411 // result: (Add8 (Const8 <t> [int64(int8(c-d))]) x) 3412 for { 3413 _ = v.Args[1] 3414 v_0 := v.Args[0] 3415 if v_0.Op != OpConst8 { 3416 break 3417 } 3418 t := v_0.Type 3419 c := v_0.AuxInt 3420 v_1 := v.Args[1] 3421 if v_1.Op != OpSub8 { 3422 break 3423 } 3424 _ = v_1.Args[1] 3425 x := v_1.Args[0] 3426 v_1_1 := v_1.Args[1] 3427 if v_1_1.Op != OpConst8 { 3428 break 3429 } 3430 if v_1_1.Type != t { 3431 break 3432 } 3433 d := v_1_1.AuxInt 3434 v.reset(OpAdd8) 3435 v0 := b.NewValue0(v.Pos, OpConst8, t) 3436 v0.AuxInt = int64(int8(c - d)) 3437 v.AddArg(v0) 3438 v.AddArg(x) 3439 return true 3440 } 3441 // match: (Add8 (Sub8 x (Const8 <t> [d])) (Const8 <t> [c])) 3442 // cond: 3443 // result: (Add8 (Const8 <t> [int64(int8(c-d))]) x) 3444 for { 3445 _ = v.Args[1] 3446 v_0 := v.Args[0] 3447 if v_0.Op != OpSub8 { 3448 break 3449 } 3450 _ = v_0.Args[1] 3451 x := v_0.Args[0] 3452 v_0_1 := v_0.Args[1] 3453 if v_0_1.Op != OpConst8 { 3454 break 3455 } 3456 t := v_0_1.Type 3457 d := v_0_1.AuxInt 3458 v_1 := v.Args[1] 3459 if v_1.Op != OpConst8 { 3460 break 3461 } 3462 if v_1.Type != t { 3463 break 3464 } 3465 c := v_1.AuxInt 3466 v.reset(OpAdd8) 3467 v0 := b.NewValue0(v.Pos, OpConst8, t) 3468 v0.AuxInt = int64(int8(c - d)) 3469 v.AddArg(v0) 3470 v.AddArg(x) 3471 return true 3472 } 3473 return false 3474 } 3475 func rewriteValuegeneric_OpAddPtr_0(v *Value) bool { 3476 // match: (AddPtr <t> x (Const64 [c])) 3477 // cond: 3478 // result: (OffPtr <t> x [c]) 3479 for { 3480 t := v.Type 3481 _ = v.Args[1] 3482 x := v.Args[0] 3483 v_1 := v.Args[1] 3484 if v_1.Op != OpConst64 { 3485 break 3486 } 3487 c := v_1.AuxInt 3488 v.reset(OpOffPtr) 3489 v.Type = t 3490 v.AuxInt = c 3491 v.AddArg(x) 3492 return true 3493 } 3494 // match: (AddPtr <t> x (Const32 [c])) 3495 // cond: 3496 // result: (OffPtr <t> x [c]) 3497 for { 3498 t := v.Type 3499 _ = v.Args[1] 3500 x := v.Args[0] 3501 v_1 := v.Args[1] 3502 if v_1.Op != OpConst32 { 3503 break 3504 } 3505 c := v_1.AuxInt 3506 v.reset(OpOffPtr) 3507 v.Type = t 3508 v.AuxInt = c 3509 v.AddArg(x) 3510 return true 3511 } 3512 return false 3513 } 3514 func rewriteValuegeneric_OpAnd16_0(v *Value) bool { 3515 // match: (And16 (Const16 [c]) (Const16 [d])) 3516 // cond: 3517 // result: (Const16 [int64(int16(c&d))]) 3518 for { 3519 _ = v.Args[1] 3520 v_0 := v.Args[0] 3521 if v_0.Op != OpConst16 { 3522 break 3523 } 3524 c := v_0.AuxInt 3525 v_1 := v.Args[1] 3526 if v_1.Op != OpConst16 { 3527 break 3528 } 3529 d := v_1.AuxInt 3530 v.reset(OpConst16) 3531 v.AuxInt = int64(int16(c & d)) 3532 return true 3533 } 3534 // match: (And16 (Const16 [d]) (Const16 [c])) 3535 // cond: 3536 // result: (Const16 [int64(int16(c&d))]) 3537 for { 3538 _ = v.Args[1] 3539 v_0 := v.Args[0] 3540 if v_0.Op != OpConst16 { 3541 break 3542 } 3543 d := v_0.AuxInt 3544 v_1 := v.Args[1] 3545 if v_1.Op != OpConst16 { 3546 break 3547 } 3548 c := v_1.AuxInt 3549 v.reset(OpConst16) 3550 v.AuxInt = int64(int16(c & d)) 3551 return true 3552 } 3553 // match: (And16 x x) 3554 // cond: 3555 // result: x 3556 for { 3557 _ = v.Args[1] 3558 x := v.Args[0] 3559 if x != v.Args[1] { 3560 break 3561 } 3562 v.reset(OpCopy) 3563 v.Type = x.Type 3564 v.AddArg(x) 3565 return true 3566 } 3567 // match: (And16 (Const16 [-1]) x) 3568 // cond: 3569 // result: x 3570 for { 3571 _ = v.Args[1] 3572 v_0 := v.Args[0] 3573 if v_0.Op != OpConst16 { 3574 break 3575 } 3576 if v_0.AuxInt != -1 { 3577 break 3578 } 3579 x := v.Args[1] 3580 v.reset(OpCopy) 3581 v.Type = x.Type 3582 v.AddArg(x) 3583 return true 3584 } 3585 // match: (And16 x (Const16 [-1])) 3586 // cond: 3587 // result: x 3588 for { 3589 _ = v.Args[1] 3590 x := v.Args[0] 3591 v_1 := v.Args[1] 3592 if v_1.Op != OpConst16 { 3593 break 3594 } 3595 if v_1.AuxInt != -1 { 3596 break 3597 } 3598 v.reset(OpCopy) 3599 v.Type = x.Type 3600 v.AddArg(x) 3601 return true 3602 } 3603 // match: (And16 (Const16 [0]) _) 3604 // cond: 3605 // result: (Const16 [0]) 3606 for { 3607 _ = v.Args[1] 3608 v_0 := v.Args[0] 3609 if v_0.Op != OpConst16 { 3610 break 3611 } 3612 if v_0.AuxInt != 0 { 3613 break 3614 } 3615 v.reset(OpConst16) 3616 v.AuxInt = 0 3617 return true 3618 } 3619 // match: (And16 _ (Const16 [0])) 3620 // cond: 3621 // result: (Const16 [0]) 3622 for { 3623 _ = v.Args[1] 3624 v_1 := v.Args[1] 3625 if v_1.Op != OpConst16 { 3626 break 3627 } 3628 if v_1.AuxInt != 0 { 3629 break 3630 } 3631 v.reset(OpConst16) 3632 v.AuxInt = 0 3633 return true 3634 } 3635 // match: (And16 x (And16 x y)) 3636 // cond: 3637 // result: (And16 x y) 3638 for { 3639 _ = v.Args[1] 3640 x := v.Args[0] 3641 v_1 := v.Args[1] 3642 if v_1.Op != OpAnd16 { 3643 break 3644 } 3645 _ = v_1.Args[1] 3646 if x != v_1.Args[0] { 3647 break 3648 } 3649 y := v_1.Args[1] 3650 v.reset(OpAnd16) 3651 v.AddArg(x) 3652 v.AddArg(y) 3653 return true 3654 } 3655 // match: (And16 x (And16 y x)) 3656 // cond: 3657 // result: (And16 x y) 3658 for { 3659 _ = v.Args[1] 3660 x := v.Args[0] 3661 v_1 := v.Args[1] 3662 if v_1.Op != OpAnd16 { 3663 break 3664 } 3665 _ = v_1.Args[1] 3666 y := v_1.Args[0] 3667 if x != v_1.Args[1] { 3668 break 3669 } 3670 v.reset(OpAnd16) 3671 v.AddArg(x) 3672 v.AddArg(y) 3673 return true 3674 } 3675 // match: (And16 (And16 x y) x) 3676 // cond: 3677 // result: (And16 x y) 3678 for { 3679 _ = v.Args[1] 3680 v_0 := v.Args[0] 3681 if v_0.Op != OpAnd16 { 3682 break 3683 } 3684 _ = v_0.Args[1] 3685 x := v_0.Args[0] 3686 y := v_0.Args[1] 3687 if x != v.Args[1] { 3688 break 3689 } 3690 v.reset(OpAnd16) 3691 v.AddArg(x) 3692 v.AddArg(y) 3693 return true 3694 } 3695 return false 3696 } 3697 func rewriteValuegeneric_OpAnd16_10(v *Value) bool { 3698 b := v.Block 3699 _ = b 3700 // match: (And16 (And16 y x) x) 3701 // cond: 3702 // result: (And16 x y) 3703 for { 3704 _ = v.Args[1] 3705 v_0 := v.Args[0] 3706 if v_0.Op != OpAnd16 { 3707 break 3708 } 3709 _ = v_0.Args[1] 3710 y := v_0.Args[0] 3711 x := v_0.Args[1] 3712 if x != v.Args[1] { 3713 break 3714 } 3715 v.reset(OpAnd16) 3716 v.AddArg(x) 3717 v.AddArg(y) 3718 return true 3719 } 3720 // match: (And16 (And16 i:(Const16 <t>) z) x) 3721 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 3722 // result: (And16 i (And16 <t> z x)) 3723 for { 3724 _ = v.Args[1] 3725 v_0 := v.Args[0] 3726 if v_0.Op != OpAnd16 { 3727 break 3728 } 3729 _ = v_0.Args[1] 3730 i := v_0.Args[0] 3731 if i.Op != OpConst16 { 3732 break 3733 } 3734 t := i.Type 3735 z := v_0.Args[1] 3736 x := v.Args[1] 3737 if !(z.Op != OpConst16 && x.Op != OpConst16) { 3738 break 3739 } 3740 v.reset(OpAnd16) 3741 v.AddArg(i) 3742 v0 := b.NewValue0(v.Pos, OpAnd16, t) 3743 v0.AddArg(z) 3744 v0.AddArg(x) 3745 v.AddArg(v0) 3746 return true 3747 } 3748 // match: (And16 (And16 z i:(Const16 <t>)) x) 3749 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 3750 // result: (And16 i (And16 <t> z x)) 3751 for { 3752 _ = v.Args[1] 3753 v_0 := v.Args[0] 3754 if v_0.Op != OpAnd16 { 3755 break 3756 } 3757 _ = v_0.Args[1] 3758 z := v_0.Args[0] 3759 i := v_0.Args[1] 3760 if i.Op != OpConst16 { 3761 break 3762 } 3763 t := i.Type 3764 x := v.Args[1] 3765 if !(z.Op != OpConst16 && x.Op != OpConst16) { 3766 break 3767 } 3768 v.reset(OpAnd16) 3769 v.AddArg(i) 3770 v0 := b.NewValue0(v.Pos, OpAnd16, t) 3771 v0.AddArg(z) 3772 v0.AddArg(x) 3773 v.AddArg(v0) 3774 return true 3775 } 3776 // match: (And16 x (And16 i:(Const16 <t>) z)) 3777 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 3778 // result: (And16 i (And16 <t> z x)) 3779 for { 3780 _ = v.Args[1] 3781 x := v.Args[0] 3782 v_1 := v.Args[1] 3783 if v_1.Op != OpAnd16 { 3784 break 3785 } 3786 _ = v_1.Args[1] 3787 i := v_1.Args[0] 3788 if i.Op != OpConst16 { 3789 break 3790 } 3791 t := i.Type 3792 z := v_1.Args[1] 3793 if !(z.Op != OpConst16 && x.Op != OpConst16) { 3794 break 3795 } 3796 v.reset(OpAnd16) 3797 v.AddArg(i) 3798 v0 := b.NewValue0(v.Pos, OpAnd16, t) 3799 v0.AddArg(z) 3800 v0.AddArg(x) 3801 v.AddArg(v0) 3802 return true 3803 } 3804 // match: (And16 x (And16 z i:(Const16 <t>))) 3805 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 3806 // result: (And16 i (And16 <t> z x)) 3807 for { 3808 _ = v.Args[1] 3809 x := v.Args[0] 3810 v_1 := v.Args[1] 3811 if v_1.Op != OpAnd16 { 3812 break 3813 } 3814 _ = v_1.Args[1] 3815 z := v_1.Args[0] 3816 i := v_1.Args[1] 3817 if i.Op != OpConst16 { 3818 break 3819 } 3820 t := i.Type 3821 if !(z.Op != OpConst16 && x.Op != OpConst16) { 3822 break 3823 } 3824 v.reset(OpAnd16) 3825 v.AddArg(i) 3826 v0 := b.NewValue0(v.Pos, OpAnd16, t) 3827 v0.AddArg(z) 3828 v0.AddArg(x) 3829 v.AddArg(v0) 3830 return true 3831 } 3832 // match: (And16 (Const16 <t> [c]) (And16 (Const16 <t> [d]) x)) 3833 // cond: 3834 // result: (And16 (Const16 <t> [int64(int16(c&d))]) x) 3835 for { 3836 _ = v.Args[1] 3837 v_0 := v.Args[0] 3838 if v_0.Op != OpConst16 { 3839 break 3840 } 3841 t := v_0.Type 3842 c := v_0.AuxInt 3843 v_1 := v.Args[1] 3844 if v_1.Op != OpAnd16 { 3845 break 3846 } 3847 _ = v_1.Args[1] 3848 v_1_0 := v_1.Args[0] 3849 if v_1_0.Op != OpConst16 { 3850 break 3851 } 3852 if v_1_0.Type != t { 3853 break 3854 } 3855 d := v_1_0.AuxInt 3856 x := v_1.Args[1] 3857 v.reset(OpAnd16) 3858 v0 := b.NewValue0(v.Pos, OpConst16, t) 3859 v0.AuxInt = int64(int16(c & d)) 3860 v.AddArg(v0) 3861 v.AddArg(x) 3862 return true 3863 } 3864 // match: (And16 (Const16 <t> [c]) (And16 x (Const16 <t> [d]))) 3865 // cond: 3866 // result: (And16 (Const16 <t> [int64(int16(c&d))]) x) 3867 for { 3868 _ = v.Args[1] 3869 v_0 := v.Args[0] 3870 if v_0.Op != OpConst16 { 3871 break 3872 } 3873 t := v_0.Type 3874 c := v_0.AuxInt 3875 v_1 := v.Args[1] 3876 if v_1.Op != OpAnd16 { 3877 break 3878 } 3879 _ = v_1.Args[1] 3880 x := v_1.Args[0] 3881 v_1_1 := v_1.Args[1] 3882 if v_1_1.Op != OpConst16 { 3883 break 3884 } 3885 if v_1_1.Type != t { 3886 break 3887 } 3888 d := v_1_1.AuxInt 3889 v.reset(OpAnd16) 3890 v0 := b.NewValue0(v.Pos, OpConst16, t) 3891 v0.AuxInt = int64(int16(c & d)) 3892 v.AddArg(v0) 3893 v.AddArg(x) 3894 return true 3895 } 3896 // match: (And16 (And16 (Const16 <t> [d]) x) (Const16 <t> [c])) 3897 // cond: 3898 // result: (And16 (Const16 <t> [int64(int16(c&d))]) x) 3899 for { 3900 _ = v.Args[1] 3901 v_0 := v.Args[0] 3902 if v_0.Op != OpAnd16 { 3903 break 3904 } 3905 _ = v_0.Args[1] 3906 v_0_0 := v_0.Args[0] 3907 if v_0_0.Op != OpConst16 { 3908 break 3909 } 3910 t := v_0_0.Type 3911 d := v_0_0.AuxInt 3912 x := v_0.Args[1] 3913 v_1 := v.Args[1] 3914 if v_1.Op != OpConst16 { 3915 break 3916 } 3917 if v_1.Type != t { 3918 break 3919 } 3920 c := v_1.AuxInt 3921 v.reset(OpAnd16) 3922 v0 := b.NewValue0(v.Pos, OpConst16, t) 3923 v0.AuxInt = int64(int16(c & d)) 3924 v.AddArg(v0) 3925 v.AddArg(x) 3926 return true 3927 } 3928 // match: (And16 (And16 x (Const16 <t> [d])) (Const16 <t> [c])) 3929 // cond: 3930 // result: (And16 (Const16 <t> [int64(int16(c&d))]) x) 3931 for { 3932 _ = v.Args[1] 3933 v_0 := v.Args[0] 3934 if v_0.Op != OpAnd16 { 3935 break 3936 } 3937 _ = v_0.Args[1] 3938 x := v_0.Args[0] 3939 v_0_1 := v_0.Args[1] 3940 if v_0_1.Op != OpConst16 { 3941 break 3942 } 3943 t := v_0_1.Type 3944 d := v_0_1.AuxInt 3945 v_1 := v.Args[1] 3946 if v_1.Op != OpConst16 { 3947 break 3948 } 3949 if v_1.Type != t { 3950 break 3951 } 3952 c := v_1.AuxInt 3953 v.reset(OpAnd16) 3954 v0 := b.NewValue0(v.Pos, OpConst16, t) 3955 v0.AuxInt = int64(int16(c & d)) 3956 v.AddArg(v0) 3957 v.AddArg(x) 3958 return true 3959 } 3960 return false 3961 } 3962 func rewriteValuegeneric_OpAnd32_0(v *Value) bool { 3963 // match: (And32 (Const32 [c]) (Const32 [d])) 3964 // cond: 3965 // result: (Const32 [int64(int32(c&d))]) 3966 for { 3967 _ = v.Args[1] 3968 v_0 := v.Args[0] 3969 if v_0.Op != OpConst32 { 3970 break 3971 } 3972 c := v_0.AuxInt 3973 v_1 := v.Args[1] 3974 if v_1.Op != OpConst32 { 3975 break 3976 } 3977 d := v_1.AuxInt 3978 v.reset(OpConst32) 3979 v.AuxInt = int64(int32(c & d)) 3980 return true 3981 } 3982 // match: (And32 (Const32 [d]) (Const32 [c])) 3983 // cond: 3984 // result: (Const32 [int64(int32(c&d))]) 3985 for { 3986 _ = v.Args[1] 3987 v_0 := v.Args[0] 3988 if v_0.Op != OpConst32 { 3989 break 3990 } 3991 d := v_0.AuxInt 3992 v_1 := v.Args[1] 3993 if v_1.Op != OpConst32 { 3994 break 3995 } 3996 c := v_1.AuxInt 3997 v.reset(OpConst32) 3998 v.AuxInt = int64(int32(c & d)) 3999 return true 4000 } 4001 // match: (And32 x x) 4002 // cond: 4003 // result: x 4004 for { 4005 _ = v.Args[1] 4006 x := v.Args[0] 4007 if x != v.Args[1] { 4008 break 4009 } 4010 v.reset(OpCopy) 4011 v.Type = x.Type 4012 v.AddArg(x) 4013 return true 4014 } 4015 // match: (And32 (Const32 [-1]) x) 4016 // cond: 4017 // result: x 4018 for { 4019 _ = v.Args[1] 4020 v_0 := v.Args[0] 4021 if v_0.Op != OpConst32 { 4022 break 4023 } 4024 if v_0.AuxInt != -1 { 4025 break 4026 } 4027 x := v.Args[1] 4028 v.reset(OpCopy) 4029 v.Type = x.Type 4030 v.AddArg(x) 4031 return true 4032 } 4033 // match: (And32 x (Const32 [-1])) 4034 // cond: 4035 // result: x 4036 for { 4037 _ = v.Args[1] 4038 x := v.Args[0] 4039 v_1 := v.Args[1] 4040 if v_1.Op != OpConst32 { 4041 break 4042 } 4043 if v_1.AuxInt != -1 { 4044 break 4045 } 4046 v.reset(OpCopy) 4047 v.Type = x.Type 4048 v.AddArg(x) 4049 return true 4050 } 4051 // match: (And32 (Const32 [0]) _) 4052 // cond: 4053 // result: (Const32 [0]) 4054 for { 4055 _ = v.Args[1] 4056 v_0 := v.Args[0] 4057 if v_0.Op != OpConst32 { 4058 break 4059 } 4060 if v_0.AuxInt != 0 { 4061 break 4062 } 4063 v.reset(OpConst32) 4064 v.AuxInt = 0 4065 return true 4066 } 4067 // match: (And32 _ (Const32 [0])) 4068 // cond: 4069 // result: (Const32 [0]) 4070 for { 4071 _ = v.Args[1] 4072 v_1 := v.Args[1] 4073 if v_1.Op != OpConst32 { 4074 break 4075 } 4076 if v_1.AuxInt != 0 { 4077 break 4078 } 4079 v.reset(OpConst32) 4080 v.AuxInt = 0 4081 return true 4082 } 4083 // match: (And32 x (And32 x y)) 4084 // cond: 4085 // result: (And32 x y) 4086 for { 4087 _ = v.Args[1] 4088 x := v.Args[0] 4089 v_1 := v.Args[1] 4090 if v_1.Op != OpAnd32 { 4091 break 4092 } 4093 _ = v_1.Args[1] 4094 if x != v_1.Args[0] { 4095 break 4096 } 4097 y := v_1.Args[1] 4098 v.reset(OpAnd32) 4099 v.AddArg(x) 4100 v.AddArg(y) 4101 return true 4102 } 4103 // match: (And32 x (And32 y x)) 4104 // cond: 4105 // result: (And32 x y) 4106 for { 4107 _ = v.Args[1] 4108 x := v.Args[0] 4109 v_1 := v.Args[1] 4110 if v_1.Op != OpAnd32 { 4111 break 4112 } 4113 _ = v_1.Args[1] 4114 y := v_1.Args[0] 4115 if x != v_1.Args[1] { 4116 break 4117 } 4118 v.reset(OpAnd32) 4119 v.AddArg(x) 4120 v.AddArg(y) 4121 return true 4122 } 4123 // match: (And32 (And32 x y) x) 4124 // cond: 4125 // result: (And32 x y) 4126 for { 4127 _ = v.Args[1] 4128 v_0 := v.Args[0] 4129 if v_0.Op != OpAnd32 { 4130 break 4131 } 4132 _ = v_0.Args[1] 4133 x := v_0.Args[0] 4134 y := v_0.Args[1] 4135 if x != v.Args[1] { 4136 break 4137 } 4138 v.reset(OpAnd32) 4139 v.AddArg(x) 4140 v.AddArg(y) 4141 return true 4142 } 4143 return false 4144 } 4145 func rewriteValuegeneric_OpAnd32_10(v *Value) bool { 4146 b := v.Block 4147 _ = b 4148 // match: (And32 (And32 y x) x) 4149 // cond: 4150 // result: (And32 x y) 4151 for { 4152 _ = v.Args[1] 4153 v_0 := v.Args[0] 4154 if v_0.Op != OpAnd32 { 4155 break 4156 } 4157 _ = v_0.Args[1] 4158 y := v_0.Args[0] 4159 x := v_0.Args[1] 4160 if x != v.Args[1] { 4161 break 4162 } 4163 v.reset(OpAnd32) 4164 v.AddArg(x) 4165 v.AddArg(y) 4166 return true 4167 } 4168 // match: (And32 (And32 i:(Const32 <t>) z) x) 4169 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 4170 // result: (And32 i (And32 <t> z x)) 4171 for { 4172 _ = v.Args[1] 4173 v_0 := v.Args[0] 4174 if v_0.Op != OpAnd32 { 4175 break 4176 } 4177 _ = v_0.Args[1] 4178 i := v_0.Args[0] 4179 if i.Op != OpConst32 { 4180 break 4181 } 4182 t := i.Type 4183 z := v_0.Args[1] 4184 x := v.Args[1] 4185 if !(z.Op != OpConst32 && x.Op != OpConst32) { 4186 break 4187 } 4188 v.reset(OpAnd32) 4189 v.AddArg(i) 4190 v0 := b.NewValue0(v.Pos, OpAnd32, t) 4191 v0.AddArg(z) 4192 v0.AddArg(x) 4193 v.AddArg(v0) 4194 return true 4195 } 4196 // match: (And32 (And32 z i:(Const32 <t>)) x) 4197 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 4198 // result: (And32 i (And32 <t> z x)) 4199 for { 4200 _ = v.Args[1] 4201 v_0 := v.Args[0] 4202 if v_0.Op != OpAnd32 { 4203 break 4204 } 4205 _ = v_0.Args[1] 4206 z := v_0.Args[0] 4207 i := v_0.Args[1] 4208 if i.Op != OpConst32 { 4209 break 4210 } 4211 t := i.Type 4212 x := v.Args[1] 4213 if !(z.Op != OpConst32 && x.Op != OpConst32) { 4214 break 4215 } 4216 v.reset(OpAnd32) 4217 v.AddArg(i) 4218 v0 := b.NewValue0(v.Pos, OpAnd32, t) 4219 v0.AddArg(z) 4220 v0.AddArg(x) 4221 v.AddArg(v0) 4222 return true 4223 } 4224 // match: (And32 x (And32 i:(Const32 <t>) z)) 4225 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 4226 // result: (And32 i (And32 <t> z x)) 4227 for { 4228 _ = v.Args[1] 4229 x := v.Args[0] 4230 v_1 := v.Args[1] 4231 if v_1.Op != OpAnd32 { 4232 break 4233 } 4234 _ = v_1.Args[1] 4235 i := v_1.Args[0] 4236 if i.Op != OpConst32 { 4237 break 4238 } 4239 t := i.Type 4240 z := v_1.Args[1] 4241 if !(z.Op != OpConst32 && x.Op != OpConst32) { 4242 break 4243 } 4244 v.reset(OpAnd32) 4245 v.AddArg(i) 4246 v0 := b.NewValue0(v.Pos, OpAnd32, t) 4247 v0.AddArg(z) 4248 v0.AddArg(x) 4249 v.AddArg(v0) 4250 return true 4251 } 4252 // match: (And32 x (And32 z i:(Const32 <t>))) 4253 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 4254 // result: (And32 i (And32 <t> z x)) 4255 for { 4256 _ = v.Args[1] 4257 x := v.Args[0] 4258 v_1 := v.Args[1] 4259 if v_1.Op != OpAnd32 { 4260 break 4261 } 4262 _ = v_1.Args[1] 4263 z := v_1.Args[0] 4264 i := v_1.Args[1] 4265 if i.Op != OpConst32 { 4266 break 4267 } 4268 t := i.Type 4269 if !(z.Op != OpConst32 && x.Op != OpConst32) { 4270 break 4271 } 4272 v.reset(OpAnd32) 4273 v.AddArg(i) 4274 v0 := b.NewValue0(v.Pos, OpAnd32, t) 4275 v0.AddArg(z) 4276 v0.AddArg(x) 4277 v.AddArg(v0) 4278 return true 4279 } 4280 // match: (And32 (Const32 <t> [c]) (And32 (Const32 <t> [d]) x)) 4281 // cond: 4282 // result: (And32 (Const32 <t> [int64(int32(c&d))]) x) 4283 for { 4284 _ = v.Args[1] 4285 v_0 := v.Args[0] 4286 if v_0.Op != OpConst32 { 4287 break 4288 } 4289 t := v_0.Type 4290 c := v_0.AuxInt 4291 v_1 := v.Args[1] 4292 if v_1.Op != OpAnd32 { 4293 break 4294 } 4295 _ = v_1.Args[1] 4296 v_1_0 := v_1.Args[0] 4297 if v_1_0.Op != OpConst32 { 4298 break 4299 } 4300 if v_1_0.Type != t { 4301 break 4302 } 4303 d := v_1_0.AuxInt 4304 x := v_1.Args[1] 4305 v.reset(OpAnd32) 4306 v0 := b.NewValue0(v.Pos, OpConst32, t) 4307 v0.AuxInt = int64(int32(c & d)) 4308 v.AddArg(v0) 4309 v.AddArg(x) 4310 return true 4311 } 4312 // match: (And32 (Const32 <t> [c]) (And32 x (Const32 <t> [d]))) 4313 // cond: 4314 // result: (And32 (Const32 <t> [int64(int32(c&d))]) x) 4315 for { 4316 _ = v.Args[1] 4317 v_0 := v.Args[0] 4318 if v_0.Op != OpConst32 { 4319 break 4320 } 4321 t := v_0.Type 4322 c := v_0.AuxInt 4323 v_1 := v.Args[1] 4324 if v_1.Op != OpAnd32 { 4325 break 4326 } 4327 _ = v_1.Args[1] 4328 x := v_1.Args[0] 4329 v_1_1 := v_1.Args[1] 4330 if v_1_1.Op != OpConst32 { 4331 break 4332 } 4333 if v_1_1.Type != t { 4334 break 4335 } 4336 d := v_1_1.AuxInt 4337 v.reset(OpAnd32) 4338 v0 := b.NewValue0(v.Pos, OpConst32, t) 4339 v0.AuxInt = int64(int32(c & d)) 4340 v.AddArg(v0) 4341 v.AddArg(x) 4342 return true 4343 } 4344 // match: (And32 (And32 (Const32 <t> [d]) x) (Const32 <t> [c])) 4345 // cond: 4346 // result: (And32 (Const32 <t> [int64(int32(c&d))]) x) 4347 for { 4348 _ = v.Args[1] 4349 v_0 := v.Args[0] 4350 if v_0.Op != OpAnd32 { 4351 break 4352 } 4353 _ = v_0.Args[1] 4354 v_0_0 := v_0.Args[0] 4355 if v_0_0.Op != OpConst32 { 4356 break 4357 } 4358 t := v_0_0.Type 4359 d := v_0_0.AuxInt 4360 x := v_0.Args[1] 4361 v_1 := v.Args[1] 4362 if v_1.Op != OpConst32 { 4363 break 4364 } 4365 if v_1.Type != t { 4366 break 4367 } 4368 c := v_1.AuxInt 4369 v.reset(OpAnd32) 4370 v0 := b.NewValue0(v.Pos, OpConst32, t) 4371 v0.AuxInt = int64(int32(c & d)) 4372 v.AddArg(v0) 4373 v.AddArg(x) 4374 return true 4375 } 4376 // match: (And32 (And32 x (Const32 <t> [d])) (Const32 <t> [c])) 4377 // cond: 4378 // result: (And32 (Const32 <t> [int64(int32(c&d))]) x) 4379 for { 4380 _ = v.Args[1] 4381 v_0 := v.Args[0] 4382 if v_0.Op != OpAnd32 { 4383 break 4384 } 4385 _ = v_0.Args[1] 4386 x := v_0.Args[0] 4387 v_0_1 := v_0.Args[1] 4388 if v_0_1.Op != OpConst32 { 4389 break 4390 } 4391 t := v_0_1.Type 4392 d := v_0_1.AuxInt 4393 v_1 := v.Args[1] 4394 if v_1.Op != OpConst32 { 4395 break 4396 } 4397 if v_1.Type != t { 4398 break 4399 } 4400 c := v_1.AuxInt 4401 v.reset(OpAnd32) 4402 v0 := b.NewValue0(v.Pos, OpConst32, t) 4403 v0.AuxInt = int64(int32(c & d)) 4404 v.AddArg(v0) 4405 v.AddArg(x) 4406 return true 4407 } 4408 return false 4409 } 4410 func rewriteValuegeneric_OpAnd64_0(v *Value) bool { 4411 // match: (And64 (Const64 [c]) (Const64 [d])) 4412 // cond: 4413 // result: (Const64 [c&d]) 4414 for { 4415 _ = v.Args[1] 4416 v_0 := v.Args[0] 4417 if v_0.Op != OpConst64 { 4418 break 4419 } 4420 c := v_0.AuxInt 4421 v_1 := v.Args[1] 4422 if v_1.Op != OpConst64 { 4423 break 4424 } 4425 d := v_1.AuxInt 4426 v.reset(OpConst64) 4427 v.AuxInt = c & d 4428 return true 4429 } 4430 // match: (And64 (Const64 [d]) (Const64 [c])) 4431 // cond: 4432 // result: (Const64 [c&d]) 4433 for { 4434 _ = v.Args[1] 4435 v_0 := v.Args[0] 4436 if v_0.Op != OpConst64 { 4437 break 4438 } 4439 d := v_0.AuxInt 4440 v_1 := v.Args[1] 4441 if v_1.Op != OpConst64 { 4442 break 4443 } 4444 c := v_1.AuxInt 4445 v.reset(OpConst64) 4446 v.AuxInt = c & d 4447 return true 4448 } 4449 // match: (And64 x x) 4450 // cond: 4451 // result: x 4452 for { 4453 _ = v.Args[1] 4454 x := v.Args[0] 4455 if x != v.Args[1] { 4456 break 4457 } 4458 v.reset(OpCopy) 4459 v.Type = x.Type 4460 v.AddArg(x) 4461 return true 4462 } 4463 // match: (And64 (Const64 [-1]) x) 4464 // cond: 4465 // result: x 4466 for { 4467 _ = v.Args[1] 4468 v_0 := v.Args[0] 4469 if v_0.Op != OpConst64 { 4470 break 4471 } 4472 if v_0.AuxInt != -1 { 4473 break 4474 } 4475 x := v.Args[1] 4476 v.reset(OpCopy) 4477 v.Type = x.Type 4478 v.AddArg(x) 4479 return true 4480 } 4481 // match: (And64 x (Const64 [-1])) 4482 // cond: 4483 // result: x 4484 for { 4485 _ = v.Args[1] 4486 x := v.Args[0] 4487 v_1 := v.Args[1] 4488 if v_1.Op != OpConst64 { 4489 break 4490 } 4491 if v_1.AuxInt != -1 { 4492 break 4493 } 4494 v.reset(OpCopy) 4495 v.Type = x.Type 4496 v.AddArg(x) 4497 return true 4498 } 4499 // match: (And64 (Const64 [0]) _) 4500 // cond: 4501 // result: (Const64 [0]) 4502 for { 4503 _ = v.Args[1] 4504 v_0 := v.Args[0] 4505 if v_0.Op != OpConst64 { 4506 break 4507 } 4508 if v_0.AuxInt != 0 { 4509 break 4510 } 4511 v.reset(OpConst64) 4512 v.AuxInt = 0 4513 return true 4514 } 4515 // match: (And64 _ (Const64 [0])) 4516 // cond: 4517 // result: (Const64 [0]) 4518 for { 4519 _ = v.Args[1] 4520 v_1 := v.Args[1] 4521 if v_1.Op != OpConst64 { 4522 break 4523 } 4524 if v_1.AuxInt != 0 { 4525 break 4526 } 4527 v.reset(OpConst64) 4528 v.AuxInt = 0 4529 return true 4530 } 4531 // match: (And64 x (And64 x y)) 4532 // cond: 4533 // result: (And64 x y) 4534 for { 4535 _ = v.Args[1] 4536 x := v.Args[0] 4537 v_1 := v.Args[1] 4538 if v_1.Op != OpAnd64 { 4539 break 4540 } 4541 _ = v_1.Args[1] 4542 if x != v_1.Args[0] { 4543 break 4544 } 4545 y := v_1.Args[1] 4546 v.reset(OpAnd64) 4547 v.AddArg(x) 4548 v.AddArg(y) 4549 return true 4550 } 4551 // match: (And64 x (And64 y x)) 4552 // cond: 4553 // result: (And64 x y) 4554 for { 4555 _ = v.Args[1] 4556 x := v.Args[0] 4557 v_1 := v.Args[1] 4558 if v_1.Op != OpAnd64 { 4559 break 4560 } 4561 _ = v_1.Args[1] 4562 y := v_1.Args[0] 4563 if x != v_1.Args[1] { 4564 break 4565 } 4566 v.reset(OpAnd64) 4567 v.AddArg(x) 4568 v.AddArg(y) 4569 return true 4570 } 4571 // match: (And64 (And64 x y) x) 4572 // cond: 4573 // result: (And64 x y) 4574 for { 4575 _ = v.Args[1] 4576 v_0 := v.Args[0] 4577 if v_0.Op != OpAnd64 { 4578 break 4579 } 4580 _ = v_0.Args[1] 4581 x := v_0.Args[0] 4582 y := v_0.Args[1] 4583 if x != v.Args[1] { 4584 break 4585 } 4586 v.reset(OpAnd64) 4587 v.AddArg(x) 4588 v.AddArg(y) 4589 return true 4590 } 4591 return false 4592 } 4593 func rewriteValuegeneric_OpAnd64_10(v *Value) bool { 4594 b := v.Block 4595 _ = b 4596 // match: (And64 (And64 y x) x) 4597 // cond: 4598 // result: (And64 x y) 4599 for { 4600 _ = v.Args[1] 4601 v_0 := v.Args[0] 4602 if v_0.Op != OpAnd64 { 4603 break 4604 } 4605 _ = v_0.Args[1] 4606 y := v_0.Args[0] 4607 x := v_0.Args[1] 4608 if x != v.Args[1] { 4609 break 4610 } 4611 v.reset(OpAnd64) 4612 v.AddArg(x) 4613 v.AddArg(y) 4614 return true 4615 } 4616 // match: (And64 <t> (Const64 [y]) x) 4617 // cond: nlz(y) + nto(y) == 64 && nto(y) >= 32 4618 // result: (Rsh64Ux64 (Lsh64x64 <t> x (Const64 <t> [nlz(y)])) (Const64 <t> [nlz(y)])) 4619 for { 4620 t := v.Type 4621 _ = v.Args[1] 4622 v_0 := v.Args[0] 4623 if v_0.Op != OpConst64 { 4624 break 4625 } 4626 y := v_0.AuxInt 4627 x := v.Args[1] 4628 if !(nlz(y)+nto(y) == 64 && nto(y) >= 32) { 4629 break 4630 } 4631 v.reset(OpRsh64Ux64) 4632 v0 := b.NewValue0(v.Pos, OpLsh64x64, t) 4633 v0.AddArg(x) 4634 v1 := b.NewValue0(v.Pos, OpConst64, t) 4635 v1.AuxInt = nlz(y) 4636 v0.AddArg(v1) 4637 v.AddArg(v0) 4638 v2 := b.NewValue0(v.Pos, OpConst64, t) 4639 v2.AuxInt = nlz(y) 4640 v.AddArg(v2) 4641 return true 4642 } 4643 // match: (And64 <t> x (Const64 [y])) 4644 // cond: nlz(y) + nto(y) == 64 && nto(y) >= 32 4645 // result: (Rsh64Ux64 (Lsh64x64 <t> x (Const64 <t> [nlz(y)])) (Const64 <t> [nlz(y)])) 4646 for { 4647 t := v.Type 4648 _ = v.Args[1] 4649 x := v.Args[0] 4650 v_1 := v.Args[1] 4651 if v_1.Op != OpConst64 { 4652 break 4653 } 4654 y := v_1.AuxInt 4655 if !(nlz(y)+nto(y) == 64 && nto(y) >= 32) { 4656 break 4657 } 4658 v.reset(OpRsh64Ux64) 4659 v0 := b.NewValue0(v.Pos, OpLsh64x64, t) 4660 v0.AddArg(x) 4661 v1 := b.NewValue0(v.Pos, OpConst64, t) 4662 v1.AuxInt = nlz(y) 4663 v0.AddArg(v1) 4664 v.AddArg(v0) 4665 v2 := b.NewValue0(v.Pos, OpConst64, t) 4666 v2.AuxInt = nlz(y) 4667 v.AddArg(v2) 4668 return true 4669 } 4670 // match: (And64 <t> (Const64 [y]) x) 4671 // cond: nlo(y) + ntz(y) == 64 && ntz(y) >= 32 4672 // result: (Lsh64x64 (Rsh64Ux64 <t> x (Const64 <t> [ntz(y)])) (Const64 <t> [ntz(y)])) 4673 for { 4674 t := v.Type 4675 _ = v.Args[1] 4676 v_0 := v.Args[0] 4677 if v_0.Op != OpConst64 { 4678 break 4679 } 4680 y := v_0.AuxInt 4681 x := v.Args[1] 4682 if !(nlo(y)+ntz(y) == 64 && ntz(y) >= 32) { 4683 break 4684 } 4685 v.reset(OpLsh64x64) 4686 v0 := b.NewValue0(v.Pos, OpRsh64Ux64, t) 4687 v0.AddArg(x) 4688 v1 := b.NewValue0(v.Pos, OpConst64, t) 4689 v1.AuxInt = ntz(y) 4690 v0.AddArg(v1) 4691 v.AddArg(v0) 4692 v2 := b.NewValue0(v.Pos, OpConst64, t) 4693 v2.AuxInt = ntz(y) 4694 v.AddArg(v2) 4695 return true 4696 } 4697 // match: (And64 <t> x (Const64 [y])) 4698 // cond: nlo(y) + ntz(y) == 64 && ntz(y) >= 32 4699 // result: (Lsh64x64 (Rsh64Ux64 <t> x (Const64 <t> [ntz(y)])) (Const64 <t> [ntz(y)])) 4700 for { 4701 t := v.Type 4702 _ = v.Args[1] 4703 x := v.Args[0] 4704 v_1 := v.Args[1] 4705 if v_1.Op != OpConst64 { 4706 break 4707 } 4708 y := v_1.AuxInt 4709 if !(nlo(y)+ntz(y) == 64 && ntz(y) >= 32) { 4710 break 4711 } 4712 v.reset(OpLsh64x64) 4713 v0 := b.NewValue0(v.Pos, OpRsh64Ux64, t) 4714 v0.AddArg(x) 4715 v1 := b.NewValue0(v.Pos, OpConst64, t) 4716 v1.AuxInt = ntz(y) 4717 v0.AddArg(v1) 4718 v.AddArg(v0) 4719 v2 := b.NewValue0(v.Pos, OpConst64, t) 4720 v2.AuxInt = ntz(y) 4721 v.AddArg(v2) 4722 return true 4723 } 4724 // match: (And64 (And64 i:(Const64 <t>) z) x) 4725 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 4726 // result: (And64 i (And64 <t> z x)) 4727 for { 4728 _ = v.Args[1] 4729 v_0 := v.Args[0] 4730 if v_0.Op != OpAnd64 { 4731 break 4732 } 4733 _ = v_0.Args[1] 4734 i := v_0.Args[0] 4735 if i.Op != OpConst64 { 4736 break 4737 } 4738 t := i.Type 4739 z := v_0.Args[1] 4740 x := v.Args[1] 4741 if !(z.Op != OpConst64 && x.Op != OpConst64) { 4742 break 4743 } 4744 v.reset(OpAnd64) 4745 v.AddArg(i) 4746 v0 := b.NewValue0(v.Pos, OpAnd64, t) 4747 v0.AddArg(z) 4748 v0.AddArg(x) 4749 v.AddArg(v0) 4750 return true 4751 } 4752 // match: (And64 (And64 z i:(Const64 <t>)) x) 4753 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 4754 // result: (And64 i (And64 <t> z x)) 4755 for { 4756 _ = v.Args[1] 4757 v_0 := v.Args[0] 4758 if v_0.Op != OpAnd64 { 4759 break 4760 } 4761 _ = v_0.Args[1] 4762 z := v_0.Args[0] 4763 i := v_0.Args[1] 4764 if i.Op != OpConst64 { 4765 break 4766 } 4767 t := i.Type 4768 x := v.Args[1] 4769 if !(z.Op != OpConst64 && x.Op != OpConst64) { 4770 break 4771 } 4772 v.reset(OpAnd64) 4773 v.AddArg(i) 4774 v0 := b.NewValue0(v.Pos, OpAnd64, t) 4775 v0.AddArg(z) 4776 v0.AddArg(x) 4777 v.AddArg(v0) 4778 return true 4779 } 4780 // match: (And64 x (And64 i:(Const64 <t>) z)) 4781 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 4782 // result: (And64 i (And64 <t> z x)) 4783 for { 4784 _ = v.Args[1] 4785 x := v.Args[0] 4786 v_1 := v.Args[1] 4787 if v_1.Op != OpAnd64 { 4788 break 4789 } 4790 _ = v_1.Args[1] 4791 i := v_1.Args[0] 4792 if i.Op != OpConst64 { 4793 break 4794 } 4795 t := i.Type 4796 z := v_1.Args[1] 4797 if !(z.Op != OpConst64 && x.Op != OpConst64) { 4798 break 4799 } 4800 v.reset(OpAnd64) 4801 v.AddArg(i) 4802 v0 := b.NewValue0(v.Pos, OpAnd64, t) 4803 v0.AddArg(z) 4804 v0.AddArg(x) 4805 v.AddArg(v0) 4806 return true 4807 } 4808 // match: (And64 x (And64 z i:(Const64 <t>))) 4809 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 4810 // result: (And64 i (And64 <t> z x)) 4811 for { 4812 _ = v.Args[1] 4813 x := v.Args[0] 4814 v_1 := v.Args[1] 4815 if v_1.Op != OpAnd64 { 4816 break 4817 } 4818 _ = v_1.Args[1] 4819 z := v_1.Args[0] 4820 i := v_1.Args[1] 4821 if i.Op != OpConst64 { 4822 break 4823 } 4824 t := i.Type 4825 if !(z.Op != OpConst64 && x.Op != OpConst64) { 4826 break 4827 } 4828 v.reset(OpAnd64) 4829 v.AddArg(i) 4830 v0 := b.NewValue0(v.Pos, OpAnd64, t) 4831 v0.AddArg(z) 4832 v0.AddArg(x) 4833 v.AddArg(v0) 4834 return true 4835 } 4836 // match: (And64 (Const64 <t> [c]) (And64 (Const64 <t> [d]) x)) 4837 // cond: 4838 // result: (And64 (Const64 <t> [c&d]) x) 4839 for { 4840 _ = v.Args[1] 4841 v_0 := v.Args[0] 4842 if v_0.Op != OpConst64 { 4843 break 4844 } 4845 t := v_0.Type 4846 c := v_0.AuxInt 4847 v_1 := v.Args[1] 4848 if v_1.Op != OpAnd64 { 4849 break 4850 } 4851 _ = v_1.Args[1] 4852 v_1_0 := v_1.Args[0] 4853 if v_1_0.Op != OpConst64 { 4854 break 4855 } 4856 if v_1_0.Type != t { 4857 break 4858 } 4859 d := v_1_0.AuxInt 4860 x := v_1.Args[1] 4861 v.reset(OpAnd64) 4862 v0 := b.NewValue0(v.Pos, OpConst64, t) 4863 v0.AuxInt = c & d 4864 v.AddArg(v0) 4865 v.AddArg(x) 4866 return true 4867 } 4868 return false 4869 } 4870 func rewriteValuegeneric_OpAnd64_20(v *Value) bool { 4871 b := v.Block 4872 _ = b 4873 // match: (And64 (Const64 <t> [c]) (And64 x (Const64 <t> [d]))) 4874 // cond: 4875 // result: (And64 (Const64 <t> [c&d]) x) 4876 for { 4877 _ = v.Args[1] 4878 v_0 := v.Args[0] 4879 if v_0.Op != OpConst64 { 4880 break 4881 } 4882 t := v_0.Type 4883 c := v_0.AuxInt 4884 v_1 := v.Args[1] 4885 if v_1.Op != OpAnd64 { 4886 break 4887 } 4888 _ = v_1.Args[1] 4889 x := v_1.Args[0] 4890 v_1_1 := v_1.Args[1] 4891 if v_1_1.Op != OpConst64 { 4892 break 4893 } 4894 if v_1_1.Type != t { 4895 break 4896 } 4897 d := v_1_1.AuxInt 4898 v.reset(OpAnd64) 4899 v0 := b.NewValue0(v.Pos, OpConst64, t) 4900 v0.AuxInt = c & d 4901 v.AddArg(v0) 4902 v.AddArg(x) 4903 return true 4904 } 4905 // match: (And64 (And64 (Const64 <t> [d]) x) (Const64 <t> [c])) 4906 // cond: 4907 // result: (And64 (Const64 <t> [c&d]) x) 4908 for { 4909 _ = v.Args[1] 4910 v_0 := v.Args[0] 4911 if v_0.Op != OpAnd64 { 4912 break 4913 } 4914 _ = v_0.Args[1] 4915 v_0_0 := v_0.Args[0] 4916 if v_0_0.Op != OpConst64 { 4917 break 4918 } 4919 t := v_0_0.Type 4920 d := v_0_0.AuxInt 4921 x := v_0.Args[1] 4922 v_1 := v.Args[1] 4923 if v_1.Op != OpConst64 { 4924 break 4925 } 4926 if v_1.Type != t { 4927 break 4928 } 4929 c := v_1.AuxInt 4930 v.reset(OpAnd64) 4931 v0 := b.NewValue0(v.Pos, OpConst64, t) 4932 v0.AuxInt = c & d 4933 v.AddArg(v0) 4934 v.AddArg(x) 4935 return true 4936 } 4937 // match: (And64 (And64 x (Const64 <t> [d])) (Const64 <t> [c])) 4938 // cond: 4939 // result: (And64 (Const64 <t> [c&d]) x) 4940 for { 4941 _ = v.Args[1] 4942 v_0 := v.Args[0] 4943 if v_0.Op != OpAnd64 { 4944 break 4945 } 4946 _ = v_0.Args[1] 4947 x := v_0.Args[0] 4948 v_0_1 := v_0.Args[1] 4949 if v_0_1.Op != OpConst64 { 4950 break 4951 } 4952 t := v_0_1.Type 4953 d := v_0_1.AuxInt 4954 v_1 := v.Args[1] 4955 if v_1.Op != OpConst64 { 4956 break 4957 } 4958 if v_1.Type != t { 4959 break 4960 } 4961 c := v_1.AuxInt 4962 v.reset(OpAnd64) 4963 v0 := b.NewValue0(v.Pos, OpConst64, t) 4964 v0.AuxInt = c & d 4965 v.AddArg(v0) 4966 v.AddArg(x) 4967 return true 4968 } 4969 return false 4970 } 4971 func rewriteValuegeneric_OpAnd8_0(v *Value) bool { 4972 // match: (And8 (Const8 [c]) (Const8 [d])) 4973 // cond: 4974 // result: (Const8 [int64(int8(c&d))]) 4975 for { 4976 _ = v.Args[1] 4977 v_0 := v.Args[0] 4978 if v_0.Op != OpConst8 { 4979 break 4980 } 4981 c := v_0.AuxInt 4982 v_1 := v.Args[1] 4983 if v_1.Op != OpConst8 { 4984 break 4985 } 4986 d := v_1.AuxInt 4987 v.reset(OpConst8) 4988 v.AuxInt = int64(int8(c & d)) 4989 return true 4990 } 4991 // match: (And8 (Const8 [d]) (Const8 [c])) 4992 // cond: 4993 // result: (Const8 [int64(int8(c&d))]) 4994 for { 4995 _ = v.Args[1] 4996 v_0 := v.Args[0] 4997 if v_0.Op != OpConst8 { 4998 break 4999 } 5000 d := v_0.AuxInt 5001 v_1 := v.Args[1] 5002 if v_1.Op != OpConst8 { 5003 break 5004 } 5005 c := v_1.AuxInt 5006 v.reset(OpConst8) 5007 v.AuxInt = int64(int8(c & d)) 5008 return true 5009 } 5010 // match: (And8 x x) 5011 // cond: 5012 // result: x 5013 for { 5014 _ = v.Args[1] 5015 x := v.Args[0] 5016 if x != v.Args[1] { 5017 break 5018 } 5019 v.reset(OpCopy) 5020 v.Type = x.Type 5021 v.AddArg(x) 5022 return true 5023 } 5024 // match: (And8 (Const8 [-1]) x) 5025 // cond: 5026 // result: x 5027 for { 5028 _ = v.Args[1] 5029 v_0 := v.Args[0] 5030 if v_0.Op != OpConst8 { 5031 break 5032 } 5033 if v_0.AuxInt != -1 { 5034 break 5035 } 5036 x := v.Args[1] 5037 v.reset(OpCopy) 5038 v.Type = x.Type 5039 v.AddArg(x) 5040 return true 5041 } 5042 // match: (And8 x (Const8 [-1])) 5043 // cond: 5044 // result: x 5045 for { 5046 _ = v.Args[1] 5047 x := v.Args[0] 5048 v_1 := v.Args[1] 5049 if v_1.Op != OpConst8 { 5050 break 5051 } 5052 if v_1.AuxInt != -1 { 5053 break 5054 } 5055 v.reset(OpCopy) 5056 v.Type = x.Type 5057 v.AddArg(x) 5058 return true 5059 } 5060 // match: (And8 (Const8 [0]) _) 5061 // cond: 5062 // result: (Const8 [0]) 5063 for { 5064 _ = v.Args[1] 5065 v_0 := v.Args[0] 5066 if v_0.Op != OpConst8 { 5067 break 5068 } 5069 if v_0.AuxInt != 0 { 5070 break 5071 } 5072 v.reset(OpConst8) 5073 v.AuxInt = 0 5074 return true 5075 } 5076 // match: (And8 _ (Const8 [0])) 5077 // cond: 5078 // result: (Const8 [0]) 5079 for { 5080 _ = v.Args[1] 5081 v_1 := v.Args[1] 5082 if v_1.Op != OpConst8 { 5083 break 5084 } 5085 if v_1.AuxInt != 0 { 5086 break 5087 } 5088 v.reset(OpConst8) 5089 v.AuxInt = 0 5090 return true 5091 } 5092 // match: (And8 x (And8 x y)) 5093 // cond: 5094 // result: (And8 x y) 5095 for { 5096 _ = v.Args[1] 5097 x := v.Args[0] 5098 v_1 := v.Args[1] 5099 if v_1.Op != OpAnd8 { 5100 break 5101 } 5102 _ = v_1.Args[1] 5103 if x != v_1.Args[0] { 5104 break 5105 } 5106 y := v_1.Args[1] 5107 v.reset(OpAnd8) 5108 v.AddArg(x) 5109 v.AddArg(y) 5110 return true 5111 } 5112 // match: (And8 x (And8 y x)) 5113 // cond: 5114 // result: (And8 x y) 5115 for { 5116 _ = v.Args[1] 5117 x := v.Args[0] 5118 v_1 := v.Args[1] 5119 if v_1.Op != OpAnd8 { 5120 break 5121 } 5122 _ = v_1.Args[1] 5123 y := v_1.Args[0] 5124 if x != v_1.Args[1] { 5125 break 5126 } 5127 v.reset(OpAnd8) 5128 v.AddArg(x) 5129 v.AddArg(y) 5130 return true 5131 } 5132 // match: (And8 (And8 x y) x) 5133 // cond: 5134 // result: (And8 x y) 5135 for { 5136 _ = v.Args[1] 5137 v_0 := v.Args[0] 5138 if v_0.Op != OpAnd8 { 5139 break 5140 } 5141 _ = v_0.Args[1] 5142 x := v_0.Args[0] 5143 y := v_0.Args[1] 5144 if x != v.Args[1] { 5145 break 5146 } 5147 v.reset(OpAnd8) 5148 v.AddArg(x) 5149 v.AddArg(y) 5150 return true 5151 } 5152 return false 5153 } 5154 func rewriteValuegeneric_OpAnd8_10(v *Value) bool { 5155 b := v.Block 5156 _ = b 5157 // match: (And8 (And8 y x) x) 5158 // cond: 5159 // result: (And8 x y) 5160 for { 5161 _ = v.Args[1] 5162 v_0 := v.Args[0] 5163 if v_0.Op != OpAnd8 { 5164 break 5165 } 5166 _ = v_0.Args[1] 5167 y := v_0.Args[0] 5168 x := v_0.Args[1] 5169 if x != v.Args[1] { 5170 break 5171 } 5172 v.reset(OpAnd8) 5173 v.AddArg(x) 5174 v.AddArg(y) 5175 return true 5176 } 5177 // match: (And8 (And8 i:(Const8 <t>) z) x) 5178 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 5179 // result: (And8 i (And8 <t> z x)) 5180 for { 5181 _ = v.Args[1] 5182 v_0 := v.Args[0] 5183 if v_0.Op != OpAnd8 { 5184 break 5185 } 5186 _ = v_0.Args[1] 5187 i := v_0.Args[0] 5188 if i.Op != OpConst8 { 5189 break 5190 } 5191 t := i.Type 5192 z := v_0.Args[1] 5193 x := v.Args[1] 5194 if !(z.Op != OpConst8 && x.Op != OpConst8) { 5195 break 5196 } 5197 v.reset(OpAnd8) 5198 v.AddArg(i) 5199 v0 := b.NewValue0(v.Pos, OpAnd8, t) 5200 v0.AddArg(z) 5201 v0.AddArg(x) 5202 v.AddArg(v0) 5203 return true 5204 } 5205 // match: (And8 (And8 z i:(Const8 <t>)) x) 5206 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 5207 // result: (And8 i (And8 <t> z x)) 5208 for { 5209 _ = v.Args[1] 5210 v_0 := v.Args[0] 5211 if v_0.Op != OpAnd8 { 5212 break 5213 } 5214 _ = v_0.Args[1] 5215 z := v_0.Args[0] 5216 i := v_0.Args[1] 5217 if i.Op != OpConst8 { 5218 break 5219 } 5220 t := i.Type 5221 x := v.Args[1] 5222 if !(z.Op != OpConst8 && x.Op != OpConst8) { 5223 break 5224 } 5225 v.reset(OpAnd8) 5226 v.AddArg(i) 5227 v0 := b.NewValue0(v.Pos, OpAnd8, t) 5228 v0.AddArg(z) 5229 v0.AddArg(x) 5230 v.AddArg(v0) 5231 return true 5232 } 5233 // match: (And8 x (And8 i:(Const8 <t>) z)) 5234 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 5235 // result: (And8 i (And8 <t> z x)) 5236 for { 5237 _ = v.Args[1] 5238 x := v.Args[0] 5239 v_1 := v.Args[1] 5240 if v_1.Op != OpAnd8 { 5241 break 5242 } 5243 _ = v_1.Args[1] 5244 i := v_1.Args[0] 5245 if i.Op != OpConst8 { 5246 break 5247 } 5248 t := i.Type 5249 z := v_1.Args[1] 5250 if !(z.Op != OpConst8 && x.Op != OpConst8) { 5251 break 5252 } 5253 v.reset(OpAnd8) 5254 v.AddArg(i) 5255 v0 := b.NewValue0(v.Pos, OpAnd8, t) 5256 v0.AddArg(z) 5257 v0.AddArg(x) 5258 v.AddArg(v0) 5259 return true 5260 } 5261 // match: (And8 x (And8 z i:(Const8 <t>))) 5262 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 5263 // result: (And8 i (And8 <t> z x)) 5264 for { 5265 _ = v.Args[1] 5266 x := v.Args[0] 5267 v_1 := v.Args[1] 5268 if v_1.Op != OpAnd8 { 5269 break 5270 } 5271 _ = v_1.Args[1] 5272 z := v_1.Args[0] 5273 i := v_1.Args[1] 5274 if i.Op != OpConst8 { 5275 break 5276 } 5277 t := i.Type 5278 if !(z.Op != OpConst8 && x.Op != OpConst8) { 5279 break 5280 } 5281 v.reset(OpAnd8) 5282 v.AddArg(i) 5283 v0 := b.NewValue0(v.Pos, OpAnd8, t) 5284 v0.AddArg(z) 5285 v0.AddArg(x) 5286 v.AddArg(v0) 5287 return true 5288 } 5289 // match: (And8 (Const8 <t> [c]) (And8 (Const8 <t> [d]) x)) 5290 // cond: 5291 // result: (And8 (Const8 <t> [int64(int8(c&d))]) x) 5292 for { 5293 _ = v.Args[1] 5294 v_0 := v.Args[0] 5295 if v_0.Op != OpConst8 { 5296 break 5297 } 5298 t := v_0.Type 5299 c := v_0.AuxInt 5300 v_1 := v.Args[1] 5301 if v_1.Op != OpAnd8 { 5302 break 5303 } 5304 _ = v_1.Args[1] 5305 v_1_0 := v_1.Args[0] 5306 if v_1_0.Op != OpConst8 { 5307 break 5308 } 5309 if v_1_0.Type != t { 5310 break 5311 } 5312 d := v_1_0.AuxInt 5313 x := v_1.Args[1] 5314 v.reset(OpAnd8) 5315 v0 := b.NewValue0(v.Pos, OpConst8, t) 5316 v0.AuxInt = int64(int8(c & d)) 5317 v.AddArg(v0) 5318 v.AddArg(x) 5319 return true 5320 } 5321 // match: (And8 (Const8 <t> [c]) (And8 x (Const8 <t> [d]))) 5322 // cond: 5323 // result: (And8 (Const8 <t> [int64(int8(c&d))]) x) 5324 for { 5325 _ = v.Args[1] 5326 v_0 := v.Args[0] 5327 if v_0.Op != OpConst8 { 5328 break 5329 } 5330 t := v_0.Type 5331 c := v_0.AuxInt 5332 v_1 := v.Args[1] 5333 if v_1.Op != OpAnd8 { 5334 break 5335 } 5336 _ = v_1.Args[1] 5337 x := v_1.Args[0] 5338 v_1_1 := v_1.Args[1] 5339 if v_1_1.Op != OpConst8 { 5340 break 5341 } 5342 if v_1_1.Type != t { 5343 break 5344 } 5345 d := v_1_1.AuxInt 5346 v.reset(OpAnd8) 5347 v0 := b.NewValue0(v.Pos, OpConst8, t) 5348 v0.AuxInt = int64(int8(c & d)) 5349 v.AddArg(v0) 5350 v.AddArg(x) 5351 return true 5352 } 5353 // match: (And8 (And8 (Const8 <t> [d]) x) (Const8 <t> [c])) 5354 // cond: 5355 // result: (And8 (Const8 <t> [int64(int8(c&d))]) x) 5356 for { 5357 _ = v.Args[1] 5358 v_0 := v.Args[0] 5359 if v_0.Op != OpAnd8 { 5360 break 5361 } 5362 _ = v_0.Args[1] 5363 v_0_0 := v_0.Args[0] 5364 if v_0_0.Op != OpConst8 { 5365 break 5366 } 5367 t := v_0_0.Type 5368 d := v_0_0.AuxInt 5369 x := v_0.Args[1] 5370 v_1 := v.Args[1] 5371 if v_1.Op != OpConst8 { 5372 break 5373 } 5374 if v_1.Type != t { 5375 break 5376 } 5377 c := v_1.AuxInt 5378 v.reset(OpAnd8) 5379 v0 := b.NewValue0(v.Pos, OpConst8, t) 5380 v0.AuxInt = int64(int8(c & d)) 5381 v.AddArg(v0) 5382 v.AddArg(x) 5383 return true 5384 } 5385 // match: (And8 (And8 x (Const8 <t> [d])) (Const8 <t> [c])) 5386 // cond: 5387 // result: (And8 (Const8 <t> [int64(int8(c&d))]) x) 5388 for { 5389 _ = v.Args[1] 5390 v_0 := v.Args[0] 5391 if v_0.Op != OpAnd8 { 5392 break 5393 } 5394 _ = v_0.Args[1] 5395 x := v_0.Args[0] 5396 v_0_1 := v_0.Args[1] 5397 if v_0_1.Op != OpConst8 { 5398 break 5399 } 5400 t := v_0_1.Type 5401 d := v_0_1.AuxInt 5402 v_1 := v.Args[1] 5403 if v_1.Op != OpConst8 { 5404 break 5405 } 5406 if v_1.Type != t { 5407 break 5408 } 5409 c := v_1.AuxInt 5410 v.reset(OpAnd8) 5411 v0 := b.NewValue0(v.Pos, OpConst8, t) 5412 v0.AuxInt = int64(int8(c & d)) 5413 v.AddArg(v0) 5414 v.AddArg(x) 5415 return true 5416 } 5417 return false 5418 } 5419 func rewriteValuegeneric_OpArg_0(v *Value) bool { 5420 b := v.Block 5421 _ = b 5422 config := b.Func.Config 5423 _ = config 5424 fe := b.Func.fe 5425 _ = fe 5426 typ := &b.Func.Config.Types 5427 _ = typ 5428 // match: (Arg {n} [off]) 5429 // cond: v.Type.IsString() 5430 // result: (StringMake (Arg <typ.BytePtr> {n} [off]) (Arg <typ.Int> {n} [off+config.PtrSize])) 5431 for { 5432 off := v.AuxInt 5433 n := v.Aux 5434 if !(v.Type.IsString()) { 5435 break 5436 } 5437 v.reset(OpStringMake) 5438 v0 := b.NewValue0(v.Pos, OpArg, typ.BytePtr) 5439 v0.AuxInt = off 5440 v0.Aux = n 5441 v.AddArg(v0) 5442 v1 := b.NewValue0(v.Pos, OpArg, typ.Int) 5443 v1.AuxInt = off + config.PtrSize 5444 v1.Aux = n 5445 v.AddArg(v1) 5446 return true 5447 } 5448 // match: (Arg {n} [off]) 5449 // cond: v.Type.IsSlice() 5450 // result: (SliceMake (Arg <v.Type.ElemType().PtrTo()> {n} [off]) (Arg <typ.Int> {n} [off+config.PtrSize]) (Arg <typ.Int> {n} [off+2*config.PtrSize])) 5451 for { 5452 off := v.AuxInt 5453 n := v.Aux 5454 if !(v.Type.IsSlice()) { 5455 break 5456 } 5457 v.reset(OpSliceMake) 5458 v0 := b.NewValue0(v.Pos, OpArg, v.Type.ElemType().PtrTo()) 5459 v0.AuxInt = off 5460 v0.Aux = n 5461 v.AddArg(v0) 5462 v1 := b.NewValue0(v.Pos, OpArg, typ.Int) 5463 v1.AuxInt = off + config.PtrSize 5464 v1.Aux = n 5465 v.AddArg(v1) 5466 v2 := b.NewValue0(v.Pos, OpArg, typ.Int) 5467 v2.AuxInt = off + 2*config.PtrSize 5468 v2.Aux = n 5469 v.AddArg(v2) 5470 return true 5471 } 5472 // match: (Arg {n} [off]) 5473 // cond: v.Type.IsInterface() 5474 // result: (IMake (Arg <typ.BytePtr> {n} [off]) (Arg <typ.BytePtr> {n} [off+config.PtrSize])) 5475 for { 5476 off := v.AuxInt 5477 n := v.Aux 5478 if !(v.Type.IsInterface()) { 5479 break 5480 } 5481 v.reset(OpIMake) 5482 v0 := b.NewValue0(v.Pos, OpArg, typ.BytePtr) 5483 v0.AuxInt = off 5484 v0.Aux = n 5485 v.AddArg(v0) 5486 v1 := b.NewValue0(v.Pos, OpArg, typ.BytePtr) 5487 v1.AuxInt = off + config.PtrSize 5488 v1.Aux = n 5489 v.AddArg(v1) 5490 return true 5491 } 5492 // match: (Arg {n} [off]) 5493 // cond: v.Type.IsComplex() && v.Type.Size() == 16 5494 // result: (ComplexMake (Arg <typ.Float64> {n} [off]) (Arg <typ.Float64> {n} [off+8])) 5495 for { 5496 off := v.AuxInt 5497 n := v.Aux 5498 if !(v.Type.IsComplex() && v.Type.Size() == 16) { 5499 break 5500 } 5501 v.reset(OpComplexMake) 5502 v0 := b.NewValue0(v.Pos, OpArg, typ.Float64) 5503 v0.AuxInt = off 5504 v0.Aux = n 5505 v.AddArg(v0) 5506 v1 := b.NewValue0(v.Pos, OpArg, typ.Float64) 5507 v1.AuxInt = off + 8 5508 v1.Aux = n 5509 v.AddArg(v1) 5510 return true 5511 } 5512 // match: (Arg {n} [off]) 5513 // cond: v.Type.IsComplex() && v.Type.Size() == 8 5514 // result: (ComplexMake (Arg <typ.Float32> {n} [off]) (Arg <typ.Float32> {n} [off+4])) 5515 for { 5516 off := v.AuxInt 5517 n := v.Aux 5518 if !(v.Type.IsComplex() && v.Type.Size() == 8) { 5519 break 5520 } 5521 v.reset(OpComplexMake) 5522 v0 := b.NewValue0(v.Pos, OpArg, typ.Float32) 5523 v0.AuxInt = off 5524 v0.Aux = n 5525 v.AddArg(v0) 5526 v1 := b.NewValue0(v.Pos, OpArg, typ.Float32) 5527 v1.AuxInt = off + 4 5528 v1.Aux = n 5529 v.AddArg(v1) 5530 return true 5531 } 5532 // match: (Arg <t>) 5533 // cond: t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t) 5534 // result: (StructMake0) 5535 for { 5536 t := v.Type 5537 if !(t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t)) { 5538 break 5539 } 5540 v.reset(OpStructMake0) 5541 return true 5542 } 5543 // match: (Arg <t> {n} [off]) 5544 // cond: t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t) 5545 // result: (StructMake1 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)])) 5546 for { 5547 t := v.Type 5548 off := v.AuxInt 5549 n := v.Aux 5550 if !(t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t)) { 5551 break 5552 } 5553 v.reset(OpStructMake1) 5554 v0 := b.NewValue0(v.Pos, OpArg, t.FieldType(0)) 5555 v0.AuxInt = off + t.FieldOff(0) 5556 v0.Aux = n 5557 v.AddArg(v0) 5558 return true 5559 } 5560 // match: (Arg <t> {n} [off]) 5561 // cond: t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t) 5562 // result: (StructMake2 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)])) 5563 for { 5564 t := v.Type 5565 off := v.AuxInt 5566 n := v.Aux 5567 if !(t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t)) { 5568 break 5569 } 5570 v.reset(OpStructMake2) 5571 v0 := b.NewValue0(v.Pos, OpArg, t.FieldType(0)) 5572 v0.AuxInt = off + t.FieldOff(0) 5573 v0.Aux = n 5574 v.AddArg(v0) 5575 v1 := b.NewValue0(v.Pos, OpArg, t.FieldType(1)) 5576 v1.AuxInt = off + t.FieldOff(1) 5577 v1.Aux = n 5578 v.AddArg(v1) 5579 return true 5580 } 5581 // match: (Arg <t> {n} [off]) 5582 // cond: t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t) 5583 // result: (StructMake3 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)]) (Arg <t.FieldType(2)> {n} [off+t.FieldOff(2)])) 5584 for { 5585 t := v.Type 5586 off := v.AuxInt 5587 n := v.Aux 5588 if !(t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t)) { 5589 break 5590 } 5591 v.reset(OpStructMake3) 5592 v0 := b.NewValue0(v.Pos, OpArg, t.FieldType(0)) 5593 v0.AuxInt = off + t.FieldOff(0) 5594 v0.Aux = n 5595 v.AddArg(v0) 5596 v1 := b.NewValue0(v.Pos, OpArg, t.FieldType(1)) 5597 v1.AuxInt = off + t.FieldOff(1) 5598 v1.Aux = n 5599 v.AddArg(v1) 5600 v2 := b.NewValue0(v.Pos, OpArg, t.FieldType(2)) 5601 v2.AuxInt = off + t.FieldOff(2) 5602 v2.Aux = n 5603 v.AddArg(v2) 5604 return true 5605 } 5606 // match: (Arg <t> {n} [off]) 5607 // cond: t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t) 5608 // result: (StructMake4 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)]) (Arg <t.FieldType(2)> {n} [off+t.FieldOff(2)]) (Arg <t.FieldType(3)> {n} [off+t.FieldOff(3)])) 5609 for { 5610 t := v.Type 5611 off := v.AuxInt 5612 n := v.Aux 5613 if !(t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t)) { 5614 break 5615 } 5616 v.reset(OpStructMake4) 5617 v0 := b.NewValue0(v.Pos, OpArg, t.FieldType(0)) 5618 v0.AuxInt = off + t.FieldOff(0) 5619 v0.Aux = n 5620 v.AddArg(v0) 5621 v1 := b.NewValue0(v.Pos, OpArg, t.FieldType(1)) 5622 v1.AuxInt = off + t.FieldOff(1) 5623 v1.Aux = n 5624 v.AddArg(v1) 5625 v2 := b.NewValue0(v.Pos, OpArg, t.FieldType(2)) 5626 v2.AuxInt = off + t.FieldOff(2) 5627 v2.Aux = n 5628 v.AddArg(v2) 5629 v3 := b.NewValue0(v.Pos, OpArg, t.FieldType(3)) 5630 v3.AuxInt = off + t.FieldOff(3) 5631 v3.Aux = n 5632 v.AddArg(v3) 5633 return true 5634 } 5635 return false 5636 } 5637 func rewriteValuegeneric_OpArg_10(v *Value) bool { 5638 b := v.Block 5639 _ = b 5640 fe := b.Func.fe 5641 _ = fe 5642 // match: (Arg <t>) 5643 // cond: t.IsArray() && t.NumElem() == 0 5644 // result: (ArrayMake0) 5645 for { 5646 t := v.Type 5647 if !(t.IsArray() && t.NumElem() == 0) { 5648 break 5649 } 5650 v.reset(OpArrayMake0) 5651 return true 5652 } 5653 // match: (Arg <t> {n} [off]) 5654 // cond: t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t) 5655 // result: (ArrayMake1 (Arg <t.ElemType()> {n} [off])) 5656 for { 5657 t := v.Type 5658 off := v.AuxInt 5659 n := v.Aux 5660 if !(t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t)) { 5661 break 5662 } 5663 v.reset(OpArrayMake1) 5664 v0 := b.NewValue0(v.Pos, OpArg, t.ElemType()) 5665 v0.AuxInt = off 5666 v0.Aux = n 5667 v.AddArg(v0) 5668 return true 5669 } 5670 return false 5671 } 5672 func rewriteValuegeneric_OpArraySelect_0(v *Value) bool { 5673 // match: (ArraySelect (ArrayMake1 x)) 5674 // cond: 5675 // result: x 5676 for { 5677 v_0 := v.Args[0] 5678 if v_0.Op != OpArrayMake1 { 5679 break 5680 } 5681 x := v_0.Args[0] 5682 v.reset(OpCopy) 5683 v.Type = x.Type 5684 v.AddArg(x) 5685 return true 5686 } 5687 // match: (ArraySelect [0] (Load ptr mem)) 5688 // cond: 5689 // result: (Load ptr mem) 5690 for { 5691 if v.AuxInt != 0 { 5692 break 5693 } 5694 v_0 := v.Args[0] 5695 if v_0.Op != OpLoad { 5696 break 5697 } 5698 _ = v_0.Args[1] 5699 ptr := v_0.Args[0] 5700 mem := v_0.Args[1] 5701 v.reset(OpLoad) 5702 v.AddArg(ptr) 5703 v.AddArg(mem) 5704 return true 5705 } 5706 // match: (ArraySelect [0] x:(IData _)) 5707 // cond: 5708 // result: x 5709 for { 5710 if v.AuxInt != 0 { 5711 break 5712 } 5713 x := v.Args[0] 5714 if x.Op != OpIData { 5715 break 5716 } 5717 v.reset(OpCopy) 5718 v.Type = x.Type 5719 v.AddArg(x) 5720 return true 5721 } 5722 return false 5723 } 5724 func rewriteValuegeneric_OpCom16_0(v *Value) bool { 5725 // match: (Com16 (Com16 x)) 5726 // cond: 5727 // result: x 5728 for { 5729 v_0 := v.Args[0] 5730 if v_0.Op != OpCom16 { 5731 break 5732 } 5733 x := v_0.Args[0] 5734 v.reset(OpCopy) 5735 v.Type = x.Type 5736 v.AddArg(x) 5737 return true 5738 } 5739 // match: (Com16 (Const16 [c])) 5740 // cond: 5741 // result: (Const16 [^c]) 5742 for { 5743 v_0 := v.Args[0] 5744 if v_0.Op != OpConst16 { 5745 break 5746 } 5747 c := v_0.AuxInt 5748 v.reset(OpConst16) 5749 v.AuxInt = ^c 5750 return true 5751 } 5752 return false 5753 } 5754 func rewriteValuegeneric_OpCom32_0(v *Value) bool { 5755 // match: (Com32 (Com32 x)) 5756 // cond: 5757 // result: x 5758 for { 5759 v_0 := v.Args[0] 5760 if v_0.Op != OpCom32 { 5761 break 5762 } 5763 x := v_0.Args[0] 5764 v.reset(OpCopy) 5765 v.Type = x.Type 5766 v.AddArg(x) 5767 return true 5768 } 5769 // match: (Com32 (Const32 [c])) 5770 // cond: 5771 // result: (Const32 [^c]) 5772 for { 5773 v_0 := v.Args[0] 5774 if v_0.Op != OpConst32 { 5775 break 5776 } 5777 c := v_0.AuxInt 5778 v.reset(OpConst32) 5779 v.AuxInt = ^c 5780 return true 5781 } 5782 return false 5783 } 5784 func rewriteValuegeneric_OpCom64_0(v *Value) bool { 5785 // match: (Com64 (Com64 x)) 5786 // cond: 5787 // result: x 5788 for { 5789 v_0 := v.Args[0] 5790 if v_0.Op != OpCom64 { 5791 break 5792 } 5793 x := v_0.Args[0] 5794 v.reset(OpCopy) 5795 v.Type = x.Type 5796 v.AddArg(x) 5797 return true 5798 } 5799 // match: (Com64 (Const64 [c])) 5800 // cond: 5801 // result: (Const64 [^c]) 5802 for { 5803 v_0 := v.Args[0] 5804 if v_0.Op != OpConst64 { 5805 break 5806 } 5807 c := v_0.AuxInt 5808 v.reset(OpConst64) 5809 v.AuxInt = ^c 5810 return true 5811 } 5812 return false 5813 } 5814 func rewriteValuegeneric_OpCom8_0(v *Value) bool { 5815 // match: (Com8 (Com8 x)) 5816 // cond: 5817 // result: x 5818 for { 5819 v_0 := v.Args[0] 5820 if v_0.Op != OpCom8 { 5821 break 5822 } 5823 x := v_0.Args[0] 5824 v.reset(OpCopy) 5825 v.Type = x.Type 5826 v.AddArg(x) 5827 return true 5828 } 5829 // match: (Com8 (Const8 [c])) 5830 // cond: 5831 // result: (Const8 [^c]) 5832 for { 5833 v_0 := v.Args[0] 5834 if v_0.Op != OpConst8 { 5835 break 5836 } 5837 c := v_0.AuxInt 5838 v.reset(OpConst8) 5839 v.AuxInt = ^c 5840 return true 5841 } 5842 return false 5843 } 5844 func rewriteValuegeneric_OpConstInterface_0(v *Value) bool { 5845 b := v.Block 5846 _ = b 5847 typ := &b.Func.Config.Types 5848 _ = typ 5849 // match: (ConstInterface) 5850 // cond: 5851 // result: (IMake (ConstNil <typ.BytePtr>) (ConstNil <typ.BytePtr>)) 5852 for { 5853 v.reset(OpIMake) 5854 v0 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr) 5855 v.AddArg(v0) 5856 v1 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr) 5857 v.AddArg(v1) 5858 return true 5859 } 5860 } 5861 func rewriteValuegeneric_OpConstSlice_0(v *Value) bool { 5862 b := v.Block 5863 _ = b 5864 config := b.Func.Config 5865 _ = config 5866 typ := &b.Func.Config.Types 5867 _ = typ 5868 // match: (ConstSlice) 5869 // cond: config.PtrSize == 4 5870 // result: (SliceMake (ConstNil <v.Type.ElemType().PtrTo()>) (Const32 <typ.Int> [0]) (Const32 <typ.Int> [0])) 5871 for { 5872 if !(config.PtrSize == 4) { 5873 break 5874 } 5875 v.reset(OpSliceMake) 5876 v0 := b.NewValue0(v.Pos, OpConstNil, v.Type.ElemType().PtrTo()) 5877 v.AddArg(v0) 5878 v1 := b.NewValue0(v.Pos, OpConst32, typ.Int) 5879 v1.AuxInt = 0 5880 v.AddArg(v1) 5881 v2 := b.NewValue0(v.Pos, OpConst32, typ.Int) 5882 v2.AuxInt = 0 5883 v.AddArg(v2) 5884 return true 5885 } 5886 // match: (ConstSlice) 5887 // cond: config.PtrSize == 8 5888 // result: (SliceMake (ConstNil <v.Type.ElemType().PtrTo()>) (Const64 <typ.Int> [0]) (Const64 <typ.Int> [0])) 5889 for { 5890 if !(config.PtrSize == 8) { 5891 break 5892 } 5893 v.reset(OpSliceMake) 5894 v0 := b.NewValue0(v.Pos, OpConstNil, v.Type.ElemType().PtrTo()) 5895 v.AddArg(v0) 5896 v1 := b.NewValue0(v.Pos, OpConst64, typ.Int) 5897 v1.AuxInt = 0 5898 v.AddArg(v1) 5899 v2 := b.NewValue0(v.Pos, OpConst64, typ.Int) 5900 v2.AuxInt = 0 5901 v.AddArg(v2) 5902 return true 5903 } 5904 return false 5905 } 5906 func rewriteValuegeneric_OpConstString_0(v *Value) bool { 5907 b := v.Block 5908 _ = b 5909 config := b.Func.Config 5910 _ = config 5911 fe := b.Func.fe 5912 _ = fe 5913 typ := &b.Func.Config.Types 5914 _ = typ 5915 // match: (ConstString {s}) 5916 // cond: config.PtrSize == 4 && s.(string) == "" 5917 // result: (StringMake (ConstNil) (Const32 <typ.Int> [0])) 5918 for { 5919 s := v.Aux 5920 if !(config.PtrSize == 4 && s.(string) == "") { 5921 break 5922 } 5923 v.reset(OpStringMake) 5924 v0 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr) 5925 v.AddArg(v0) 5926 v1 := b.NewValue0(v.Pos, OpConst32, typ.Int) 5927 v1.AuxInt = 0 5928 v.AddArg(v1) 5929 return true 5930 } 5931 // match: (ConstString {s}) 5932 // cond: config.PtrSize == 8 && s.(string) == "" 5933 // result: (StringMake (ConstNil) (Const64 <typ.Int> [0])) 5934 for { 5935 s := v.Aux 5936 if !(config.PtrSize == 8 && s.(string) == "") { 5937 break 5938 } 5939 v.reset(OpStringMake) 5940 v0 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr) 5941 v.AddArg(v0) 5942 v1 := b.NewValue0(v.Pos, OpConst64, typ.Int) 5943 v1.AuxInt = 0 5944 v.AddArg(v1) 5945 return true 5946 } 5947 // match: (ConstString {s}) 5948 // cond: config.PtrSize == 4 && s.(string) != "" 5949 // result: (StringMake (Addr <typ.BytePtr> {fe.StringData(s.(string))} (SB)) (Const32 <typ.Int> [int64(len(s.(string)))])) 5950 for { 5951 s := v.Aux 5952 if !(config.PtrSize == 4 && s.(string) != "") { 5953 break 5954 } 5955 v.reset(OpStringMake) 5956 v0 := b.NewValue0(v.Pos, OpAddr, typ.BytePtr) 5957 v0.Aux = fe.StringData(s.(string)) 5958 v1 := b.NewValue0(v.Pos, OpSB, typ.Uintptr) 5959 v0.AddArg(v1) 5960 v.AddArg(v0) 5961 v2 := b.NewValue0(v.Pos, OpConst32, typ.Int) 5962 v2.AuxInt = int64(len(s.(string))) 5963 v.AddArg(v2) 5964 return true 5965 } 5966 // match: (ConstString {s}) 5967 // cond: config.PtrSize == 8 && s.(string) != "" 5968 // result: (StringMake (Addr <typ.BytePtr> {fe.StringData(s.(string))} (SB)) (Const64 <typ.Int> [int64(len(s.(string)))])) 5969 for { 5970 s := v.Aux 5971 if !(config.PtrSize == 8 && s.(string) != "") { 5972 break 5973 } 5974 v.reset(OpStringMake) 5975 v0 := b.NewValue0(v.Pos, OpAddr, typ.BytePtr) 5976 v0.Aux = fe.StringData(s.(string)) 5977 v1 := b.NewValue0(v.Pos, OpSB, typ.Uintptr) 5978 v0.AddArg(v1) 5979 v.AddArg(v0) 5980 v2 := b.NewValue0(v.Pos, OpConst64, typ.Int) 5981 v2.AuxInt = int64(len(s.(string))) 5982 v.AddArg(v2) 5983 return true 5984 } 5985 return false 5986 } 5987 func rewriteValuegeneric_OpConvert_0(v *Value) bool { 5988 // match: (Convert (Add64 (Convert ptr mem) off) mem) 5989 // cond: 5990 // result: (Add64 ptr off) 5991 for { 5992 _ = v.Args[1] 5993 v_0 := v.Args[0] 5994 if v_0.Op != OpAdd64 { 5995 break 5996 } 5997 _ = v_0.Args[1] 5998 v_0_0 := v_0.Args[0] 5999 if v_0_0.Op != OpConvert { 6000 break 6001 } 6002 _ = v_0_0.Args[1] 6003 ptr := v_0_0.Args[0] 6004 mem := v_0_0.Args[1] 6005 off := v_0.Args[1] 6006 if mem != v.Args[1] { 6007 break 6008 } 6009 v.reset(OpAdd64) 6010 v.AddArg(ptr) 6011 v.AddArg(off) 6012 return true 6013 } 6014 // match: (Convert (Add64 off (Convert ptr mem)) mem) 6015 // cond: 6016 // result: (Add64 ptr off) 6017 for { 6018 _ = v.Args[1] 6019 v_0 := v.Args[0] 6020 if v_0.Op != OpAdd64 { 6021 break 6022 } 6023 _ = v_0.Args[1] 6024 off := v_0.Args[0] 6025 v_0_1 := v_0.Args[1] 6026 if v_0_1.Op != OpConvert { 6027 break 6028 } 6029 _ = v_0_1.Args[1] 6030 ptr := v_0_1.Args[0] 6031 mem := v_0_1.Args[1] 6032 if mem != v.Args[1] { 6033 break 6034 } 6035 v.reset(OpAdd64) 6036 v.AddArg(ptr) 6037 v.AddArg(off) 6038 return true 6039 } 6040 // match: (Convert (Convert ptr mem) mem) 6041 // cond: 6042 // result: ptr 6043 for { 6044 _ = v.Args[1] 6045 v_0 := v.Args[0] 6046 if v_0.Op != OpConvert { 6047 break 6048 } 6049 _ = v_0.Args[1] 6050 ptr := v_0.Args[0] 6051 mem := v_0.Args[1] 6052 if mem != v.Args[1] { 6053 break 6054 } 6055 v.reset(OpCopy) 6056 v.Type = ptr.Type 6057 v.AddArg(ptr) 6058 return true 6059 } 6060 return false 6061 } 6062 func rewriteValuegeneric_OpCvt32Fto64F_0(v *Value) bool { 6063 // match: (Cvt32Fto64F (Const32F [c])) 6064 // cond: 6065 // result: (Const64F [c]) 6066 for { 6067 v_0 := v.Args[0] 6068 if v_0.Op != OpConst32F { 6069 break 6070 } 6071 c := v_0.AuxInt 6072 v.reset(OpConst64F) 6073 v.AuxInt = c 6074 return true 6075 } 6076 return false 6077 } 6078 func rewriteValuegeneric_OpCvt64Fto32F_0(v *Value) bool { 6079 // match: (Cvt64Fto32F (Const64F [c])) 6080 // cond: 6081 // result: (Const32F [f2i(float64(i2f32(c)))]) 6082 for { 6083 v_0 := v.Args[0] 6084 if v_0.Op != OpConst64F { 6085 break 6086 } 6087 c := v_0.AuxInt 6088 v.reset(OpConst32F) 6089 v.AuxInt = f2i(float64(i2f32(c))) 6090 return true 6091 } 6092 return false 6093 } 6094 func rewriteValuegeneric_OpDiv16_0(v *Value) bool { 6095 b := v.Block 6096 _ = b 6097 typ := &b.Func.Config.Types 6098 _ = typ 6099 // match: (Div16 (Const16 [c]) (Const16 [d])) 6100 // cond: d != 0 6101 // result: (Const16 [int64(int16(c)/int16(d))]) 6102 for { 6103 _ = v.Args[1] 6104 v_0 := v.Args[0] 6105 if v_0.Op != OpConst16 { 6106 break 6107 } 6108 c := v_0.AuxInt 6109 v_1 := v.Args[1] 6110 if v_1.Op != OpConst16 { 6111 break 6112 } 6113 d := v_1.AuxInt 6114 if !(d != 0) { 6115 break 6116 } 6117 v.reset(OpConst16) 6118 v.AuxInt = int64(int16(c) / int16(d)) 6119 return true 6120 } 6121 // match: (Div16 <t> n (Const16 [c])) 6122 // cond: c < 0 && c != -1<<15 6123 // result: (Neg16 (Div16 <t> n (Const16 <t> [-c]))) 6124 for { 6125 t := v.Type 6126 _ = v.Args[1] 6127 n := v.Args[0] 6128 v_1 := v.Args[1] 6129 if v_1.Op != OpConst16 { 6130 break 6131 } 6132 c := v_1.AuxInt 6133 if !(c < 0 && c != -1<<15) { 6134 break 6135 } 6136 v.reset(OpNeg16) 6137 v0 := b.NewValue0(v.Pos, OpDiv16, t) 6138 v0.AddArg(n) 6139 v1 := b.NewValue0(v.Pos, OpConst16, t) 6140 v1.AuxInt = -c 6141 v0.AddArg(v1) 6142 v.AddArg(v0) 6143 return true 6144 } 6145 // match: (Div16 <t> x (Const16 [-1<<15])) 6146 // cond: 6147 // result: (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <typ.UInt64> [15])) 6148 for { 6149 t := v.Type 6150 _ = v.Args[1] 6151 x := v.Args[0] 6152 v_1 := v.Args[1] 6153 if v_1.Op != OpConst16 { 6154 break 6155 } 6156 if v_1.AuxInt != -1<<15 { 6157 break 6158 } 6159 v.reset(OpRsh16Ux64) 6160 v0 := b.NewValue0(v.Pos, OpAnd16, t) 6161 v0.AddArg(x) 6162 v1 := b.NewValue0(v.Pos, OpNeg16, t) 6163 v1.AddArg(x) 6164 v0.AddArg(v1) 6165 v.AddArg(v0) 6166 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6167 v2.AuxInt = 15 6168 v.AddArg(v2) 6169 return true 6170 } 6171 // match: (Div16 <t> n (Const16 [c])) 6172 // cond: isPowerOfTwo(c) 6173 // result: (Rsh16x64 (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <typ.UInt64> [15])) (Const64 <typ.UInt64> [16-log2(c)]))) (Const64 <typ.UInt64> [log2(c)])) 6174 for { 6175 t := v.Type 6176 _ = v.Args[1] 6177 n := v.Args[0] 6178 v_1 := v.Args[1] 6179 if v_1.Op != OpConst16 { 6180 break 6181 } 6182 c := v_1.AuxInt 6183 if !(isPowerOfTwo(c)) { 6184 break 6185 } 6186 v.reset(OpRsh16x64) 6187 v0 := b.NewValue0(v.Pos, OpAdd16, t) 6188 v0.AddArg(n) 6189 v1 := b.NewValue0(v.Pos, OpRsh16Ux64, t) 6190 v2 := b.NewValue0(v.Pos, OpRsh16x64, t) 6191 v2.AddArg(n) 6192 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6193 v3.AuxInt = 15 6194 v2.AddArg(v3) 6195 v1.AddArg(v2) 6196 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6197 v4.AuxInt = 16 - log2(c) 6198 v1.AddArg(v4) 6199 v0.AddArg(v1) 6200 v.AddArg(v0) 6201 v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6202 v5.AuxInt = log2(c) 6203 v.AddArg(v5) 6204 return true 6205 } 6206 // match: (Div16 <t> x (Const16 [c])) 6207 // cond: smagicOK(16,c) 6208 // result: (Sub16 <t> (Rsh32x64 <t> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(smagic(16,c).m)]) (SignExt16to32 x)) (Const64 <typ.UInt64> [16+smagic(16,c).s])) (Rsh32x64 <t> (SignExt16to32 x) (Const64 <typ.UInt64> [31]))) 6209 for { 6210 t := v.Type 6211 _ = v.Args[1] 6212 x := v.Args[0] 6213 v_1 := v.Args[1] 6214 if v_1.Op != OpConst16 { 6215 break 6216 } 6217 c := v_1.AuxInt 6218 if !(smagicOK(16, c)) { 6219 break 6220 } 6221 v.reset(OpSub16) 6222 v.Type = t 6223 v0 := b.NewValue0(v.Pos, OpRsh32x64, t) 6224 v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) 6225 v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 6226 v2.AuxInt = int64(smagic(16, c).m) 6227 v1.AddArg(v2) 6228 v3 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 6229 v3.AddArg(x) 6230 v1.AddArg(v3) 6231 v0.AddArg(v1) 6232 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6233 v4.AuxInt = 16 + smagic(16, c).s 6234 v0.AddArg(v4) 6235 v.AddArg(v0) 6236 v5 := b.NewValue0(v.Pos, OpRsh32x64, t) 6237 v6 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 6238 v6.AddArg(x) 6239 v5.AddArg(v6) 6240 v7 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6241 v7.AuxInt = 31 6242 v5.AddArg(v7) 6243 v.AddArg(v5) 6244 return true 6245 } 6246 return false 6247 } 6248 func rewriteValuegeneric_OpDiv16u_0(v *Value) bool { 6249 b := v.Block 6250 _ = b 6251 config := b.Func.Config 6252 _ = config 6253 typ := &b.Func.Config.Types 6254 _ = typ 6255 // match: (Div16u (Const16 [c]) (Const16 [d])) 6256 // cond: d != 0 6257 // result: (Const16 [int64(int16(uint16(c)/uint16(d)))]) 6258 for { 6259 _ = v.Args[1] 6260 v_0 := v.Args[0] 6261 if v_0.Op != OpConst16 { 6262 break 6263 } 6264 c := v_0.AuxInt 6265 v_1 := v.Args[1] 6266 if v_1.Op != OpConst16 { 6267 break 6268 } 6269 d := v_1.AuxInt 6270 if !(d != 0) { 6271 break 6272 } 6273 v.reset(OpConst16) 6274 v.AuxInt = int64(int16(uint16(c) / uint16(d))) 6275 return true 6276 } 6277 // match: (Div16u n (Const16 [c])) 6278 // cond: isPowerOfTwo(c&0xffff) 6279 // result: (Rsh16Ux64 n (Const64 <typ.UInt64> [log2(c&0xffff)])) 6280 for { 6281 _ = v.Args[1] 6282 n := v.Args[0] 6283 v_1 := v.Args[1] 6284 if v_1.Op != OpConst16 { 6285 break 6286 } 6287 c := v_1.AuxInt 6288 if !(isPowerOfTwo(c & 0xffff)) { 6289 break 6290 } 6291 v.reset(OpRsh16Ux64) 6292 v.AddArg(n) 6293 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6294 v0.AuxInt = log2(c & 0xffff) 6295 v.AddArg(v0) 6296 return true 6297 } 6298 // match: (Div16u x (Const16 [c])) 6299 // cond: umagicOK(16, c) && config.RegSize == 8 6300 // result: (Trunc64to16 (Rsh64Ux64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<16+umagic(16,c).m)]) (ZeroExt16to64 x)) (Const64 <typ.UInt64> [16+umagic(16,c).s]))) 6301 for { 6302 _ = v.Args[1] 6303 x := v.Args[0] 6304 v_1 := v.Args[1] 6305 if v_1.Op != OpConst16 { 6306 break 6307 } 6308 c := v_1.AuxInt 6309 if !(umagicOK(16, c) && config.RegSize == 8) { 6310 break 6311 } 6312 v.reset(OpTrunc64to16) 6313 v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) 6314 v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) 6315 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6316 v2.AuxInt = int64(1<<16 + umagic(16, c).m) 6317 v1.AddArg(v2) 6318 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64) 6319 v3.AddArg(x) 6320 v1.AddArg(v3) 6321 v0.AddArg(v1) 6322 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6323 v4.AuxInt = 16 + umagic(16, c).s 6324 v0.AddArg(v4) 6325 v.AddArg(v0) 6326 return true 6327 } 6328 // match: (Div16u x (Const16 [c])) 6329 // cond: umagicOK(16, c) && config.RegSize == 4 && umagic(16,c).m&1 == 0 6330 // result: (Trunc32to16 (Rsh32Ux64 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(1<<15+umagic(16,c).m/2)]) (ZeroExt16to32 x)) (Const64 <typ.UInt64> [16+umagic(16,c).s-1]))) 6331 for { 6332 _ = v.Args[1] 6333 x := v.Args[0] 6334 v_1 := v.Args[1] 6335 if v_1.Op != OpConst16 { 6336 break 6337 } 6338 c := v_1.AuxInt 6339 if !(umagicOK(16, c) && config.RegSize == 4 && umagic(16, c).m&1 == 0) { 6340 break 6341 } 6342 v.reset(OpTrunc32to16) 6343 v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) 6344 v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) 6345 v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 6346 v2.AuxInt = int64(1<<15 + umagic(16, c).m/2) 6347 v1.AddArg(v2) 6348 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 6349 v3.AddArg(x) 6350 v1.AddArg(v3) 6351 v0.AddArg(v1) 6352 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6353 v4.AuxInt = 16 + umagic(16, c).s - 1 6354 v0.AddArg(v4) 6355 v.AddArg(v0) 6356 return true 6357 } 6358 // match: (Div16u x (Const16 [c])) 6359 // cond: umagicOK(16, c) && config.RegSize == 4 && c&1 == 0 6360 // result: (Trunc32to16 (Rsh32Ux64 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(1<<15+(umagic(16,c).m+1)/2)]) (Rsh32Ux64 <typ.UInt32> (ZeroExt16to32 x) (Const64 <typ.UInt64> [1]))) (Const64 <typ.UInt64> [16+umagic(16,c).s-2]))) 6361 for { 6362 _ = v.Args[1] 6363 x := v.Args[0] 6364 v_1 := v.Args[1] 6365 if v_1.Op != OpConst16 { 6366 break 6367 } 6368 c := v_1.AuxInt 6369 if !(umagicOK(16, c) && config.RegSize == 4 && c&1 == 0) { 6370 break 6371 } 6372 v.reset(OpTrunc32to16) 6373 v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) 6374 v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) 6375 v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 6376 v2.AuxInt = int64(1<<15 + (umagic(16, c).m+1)/2) 6377 v1.AddArg(v2) 6378 v3 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) 6379 v4 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 6380 v4.AddArg(x) 6381 v3.AddArg(v4) 6382 v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6383 v5.AuxInt = 1 6384 v3.AddArg(v5) 6385 v1.AddArg(v3) 6386 v0.AddArg(v1) 6387 v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6388 v6.AuxInt = 16 + umagic(16, c).s - 2 6389 v0.AddArg(v6) 6390 v.AddArg(v0) 6391 return true 6392 } 6393 // match: (Div16u x (Const16 [c])) 6394 // cond: umagicOK(16, c) && config.RegSize == 4 6395 // result: (Trunc32to16 (Rsh32Ux64 <typ.UInt32> (Avg32u (Lsh32x64 <typ.UInt32> (ZeroExt16to32 x) (Const64 <typ.UInt64> [16])) (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(umagic(16,c).m)]) (ZeroExt16to32 x))) (Const64 <typ.UInt64> [16+umagic(16,c).s-1]))) 6396 for { 6397 _ = v.Args[1] 6398 x := v.Args[0] 6399 v_1 := v.Args[1] 6400 if v_1.Op != OpConst16 { 6401 break 6402 } 6403 c := v_1.AuxInt 6404 if !(umagicOK(16, c) && config.RegSize == 4) { 6405 break 6406 } 6407 v.reset(OpTrunc32to16) 6408 v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) 6409 v1 := b.NewValue0(v.Pos, OpAvg32u, typ.UInt32) 6410 v2 := b.NewValue0(v.Pos, OpLsh32x64, typ.UInt32) 6411 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 6412 v3.AddArg(x) 6413 v2.AddArg(v3) 6414 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6415 v4.AuxInt = 16 6416 v2.AddArg(v4) 6417 v1.AddArg(v2) 6418 v5 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) 6419 v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 6420 v6.AuxInt = int64(umagic(16, c).m) 6421 v5.AddArg(v6) 6422 v7 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 6423 v7.AddArg(x) 6424 v5.AddArg(v7) 6425 v1.AddArg(v5) 6426 v0.AddArg(v1) 6427 v8 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6428 v8.AuxInt = 16 + umagic(16, c).s - 1 6429 v0.AddArg(v8) 6430 v.AddArg(v0) 6431 return true 6432 } 6433 return false 6434 } 6435 func rewriteValuegeneric_OpDiv32_0(v *Value) bool { 6436 b := v.Block 6437 _ = b 6438 config := b.Func.Config 6439 _ = config 6440 typ := &b.Func.Config.Types 6441 _ = typ 6442 // match: (Div32 (Const32 [c]) (Const32 [d])) 6443 // cond: d != 0 6444 // result: (Const32 [int64(int32(c)/int32(d))]) 6445 for { 6446 _ = v.Args[1] 6447 v_0 := v.Args[0] 6448 if v_0.Op != OpConst32 { 6449 break 6450 } 6451 c := v_0.AuxInt 6452 v_1 := v.Args[1] 6453 if v_1.Op != OpConst32 { 6454 break 6455 } 6456 d := v_1.AuxInt 6457 if !(d != 0) { 6458 break 6459 } 6460 v.reset(OpConst32) 6461 v.AuxInt = int64(int32(c) / int32(d)) 6462 return true 6463 } 6464 // match: (Div32 <t> n (Const32 [c])) 6465 // cond: c < 0 && c != -1<<31 6466 // result: (Neg32 (Div32 <t> n (Const32 <t> [-c]))) 6467 for { 6468 t := v.Type 6469 _ = v.Args[1] 6470 n := v.Args[0] 6471 v_1 := v.Args[1] 6472 if v_1.Op != OpConst32 { 6473 break 6474 } 6475 c := v_1.AuxInt 6476 if !(c < 0 && c != -1<<31) { 6477 break 6478 } 6479 v.reset(OpNeg32) 6480 v0 := b.NewValue0(v.Pos, OpDiv32, t) 6481 v0.AddArg(n) 6482 v1 := b.NewValue0(v.Pos, OpConst32, t) 6483 v1.AuxInt = -c 6484 v0.AddArg(v1) 6485 v.AddArg(v0) 6486 return true 6487 } 6488 // match: (Div32 <t> x (Const32 [-1<<31])) 6489 // cond: 6490 // result: (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <typ.UInt64> [31])) 6491 for { 6492 t := v.Type 6493 _ = v.Args[1] 6494 x := v.Args[0] 6495 v_1 := v.Args[1] 6496 if v_1.Op != OpConst32 { 6497 break 6498 } 6499 if v_1.AuxInt != -1<<31 { 6500 break 6501 } 6502 v.reset(OpRsh32Ux64) 6503 v0 := b.NewValue0(v.Pos, OpAnd32, t) 6504 v0.AddArg(x) 6505 v1 := b.NewValue0(v.Pos, OpNeg32, t) 6506 v1.AddArg(x) 6507 v0.AddArg(v1) 6508 v.AddArg(v0) 6509 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6510 v2.AuxInt = 31 6511 v.AddArg(v2) 6512 return true 6513 } 6514 // match: (Div32 <t> n (Const32 [c])) 6515 // cond: isPowerOfTwo(c) 6516 // result: (Rsh32x64 (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <typ.UInt64> [31])) (Const64 <typ.UInt64> [32-log2(c)]))) (Const64 <typ.UInt64> [log2(c)])) 6517 for { 6518 t := v.Type 6519 _ = v.Args[1] 6520 n := v.Args[0] 6521 v_1 := v.Args[1] 6522 if v_1.Op != OpConst32 { 6523 break 6524 } 6525 c := v_1.AuxInt 6526 if !(isPowerOfTwo(c)) { 6527 break 6528 } 6529 v.reset(OpRsh32x64) 6530 v0 := b.NewValue0(v.Pos, OpAdd32, t) 6531 v0.AddArg(n) 6532 v1 := b.NewValue0(v.Pos, OpRsh32Ux64, t) 6533 v2 := b.NewValue0(v.Pos, OpRsh32x64, t) 6534 v2.AddArg(n) 6535 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6536 v3.AuxInt = 31 6537 v2.AddArg(v3) 6538 v1.AddArg(v2) 6539 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6540 v4.AuxInt = 32 - log2(c) 6541 v1.AddArg(v4) 6542 v0.AddArg(v1) 6543 v.AddArg(v0) 6544 v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6545 v5.AuxInt = log2(c) 6546 v.AddArg(v5) 6547 return true 6548 } 6549 // match: (Div32 <t> x (Const32 [c])) 6550 // cond: smagicOK(32,c) && config.RegSize == 8 6551 // result: (Sub32 <t> (Rsh64x64 <t> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(smagic(32,c).m)]) (SignExt32to64 x)) (Const64 <typ.UInt64> [32+smagic(32,c).s])) (Rsh64x64 <t> (SignExt32to64 x) (Const64 <typ.UInt64> [63]))) 6552 for { 6553 t := v.Type 6554 _ = v.Args[1] 6555 x := v.Args[0] 6556 v_1 := v.Args[1] 6557 if v_1.Op != OpConst32 { 6558 break 6559 } 6560 c := v_1.AuxInt 6561 if !(smagicOK(32, c) && config.RegSize == 8) { 6562 break 6563 } 6564 v.reset(OpSub32) 6565 v.Type = t 6566 v0 := b.NewValue0(v.Pos, OpRsh64x64, t) 6567 v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) 6568 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6569 v2.AuxInt = int64(smagic(32, c).m) 6570 v1.AddArg(v2) 6571 v3 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64) 6572 v3.AddArg(x) 6573 v1.AddArg(v3) 6574 v0.AddArg(v1) 6575 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6576 v4.AuxInt = 32 + smagic(32, c).s 6577 v0.AddArg(v4) 6578 v.AddArg(v0) 6579 v5 := b.NewValue0(v.Pos, OpRsh64x64, t) 6580 v6 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64) 6581 v6.AddArg(x) 6582 v5.AddArg(v6) 6583 v7 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6584 v7.AuxInt = 63 6585 v5.AddArg(v7) 6586 v.AddArg(v5) 6587 return true 6588 } 6589 // match: (Div32 <t> x (Const32 [c])) 6590 // cond: smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 == 0 6591 // result: (Sub32 <t> (Rsh32x64 <t> (Hmul32 <t> (Const32 <typ.UInt32> [int64(int32(smagic(32,c).m/2))]) x) (Const64 <typ.UInt64> [smagic(32,c).s-1])) (Rsh32x64 <t> x (Const64 <typ.UInt64> [31]))) 6592 for { 6593 t := v.Type 6594 _ = v.Args[1] 6595 x := v.Args[0] 6596 v_1 := v.Args[1] 6597 if v_1.Op != OpConst32 { 6598 break 6599 } 6600 c := v_1.AuxInt 6601 if !(smagicOK(32, c) && config.RegSize == 4 && smagic(32, c).m&1 == 0) { 6602 break 6603 } 6604 v.reset(OpSub32) 6605 v.Type = t 6606 v0 := b.NewValue0(v.Pos, OpRsh32x64, t) 6607 v1 := b.NewValue0(v.Pos, OpHmul32, t) 6608 v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 6609 v2.AuxInt = int64(int32(smagic(32, c).m / 2)) 6610 v1.AddArg(v2) 6611 v1.AddArg(x) 6612 v0.AddArg(v1) 6613 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6614 v3.AuxInt = smagic(32, c).s - 1 6615 v0.AddArg(v3) 6616 v.AddArg(v0) 6617 v4 := b.NewValue0(v.Pos, OpRsh32x64, t) 6618 v4.AddArg(x) 6619 v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6620 v5.AuxInt = 31 6621 v4.AddArg(v5) 6622 v.AddArg(v4) 6623 return true 6624 } 6625 // match: (Div32 <t> x (Const32 [c])) 6626 // cond: smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 != 0 6627 // result: (Sub32 <t> (Rsh32x64 <t> (Add32 <t> (Hmul32 <t> (Const32 <typ.UInt32> [int64(int32(smagic(32,c).m))]) x) x) (Const64 <typ.UInt64> [smagic(32,c).s])) (Rsh32x64 <t> x (Const64 <typ.UInt64> [31]))) 6628 for { 6629 t := v.Type 6630 _ = v.Args[1] 6631 x := v.Args[0] 6632 v_1 := v.Args[1] 6633 if v_1.Op != OpConst32 { 6634 break 6635 } 6636 c := v_1.AuxInt 6637 if !(smagicOK(32, c) && config.RegSize == 4 && smagic(32, c).m&1 != 0) { 6638 break 6639 } 6640 v.reset(OpSub32) 6641 v.Type = t 6642 v0 := b.NewValue0(v.Pos, OpRsh32x64, t) 6643 v1 := b.NewValue0(v.Pos, OpAdd32, t) 6644 v2 := b.NewValue0(v.Pos, OpHmul32, t) 6645 v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 6646 v3.AuxInt = int64(int32(smagic(32, c).m)) 6647 v2.AddArg(v3) 6648 v2.AddArg(x) 6649 v1.AddArg(v2) 6650 v1.AddArg(x) 6651 v0.AddArg(v1) 6652 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6653 v4.AuxInt = smagic(32, c).s 6654 v0.AddArg(v4) 6655 v.AddArg(v0) 6656 v5 := b.NewValue0(v.Pos, OpRsh32x64, t) 6657 v5.AddArg(x) 6658 v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6659 v6.AuxInt = 31 6660 v5.AddArg(v6) 6661 v.AddArg(v5) 6662 return true 6663 } 6664 return false 6665 } 6666 func rewriteValuegeneric_OpDiv32F_0(v *Value) bool { 6667 b := v.Block 6668 _ = b 6669 // match: (Div32F (Const32F [c]) (Const32F [d])) 6670 // cond: 6671 // result: (Const32F [f2i(float64(i2f32(c) / i2f32(d)))]) 6672 for { 6673 _ = v.Args[1] 6674 v_0 := v.Args[0] 6675 if v_0.Op != OpConst32F { 6676 break 6677 } 6678 c := v_0.AuxInt 6679 v_1 := v.Args[1] 6680 if v_1.Op != OpConst32F { 6681 break 6682 } 6683 d := v_1.AuxInt 6684 v.reset(OpConst32F) 6685 v.AuxInt = f2i(float64(i2f32(c) / i2f32(d))) 6686 return true 6687 } 6688 // match: (Div32F x (Const32F <t> [c])) 6689 // cond: reciprocalExact32(float32(i2f(c))) 6690 // result: (Mul32F x (Const32F <t> [f2i(1/i2f(c))])) 6691 for { 6692 _ = v.Args[1] 6693 x := v.Args[0] 6694 v_1 := v.Args[1] 6695 if v_1.Op != OpConst32F { 6696 break 6697 } 6698 t := v_1.Type 6699 c := v_1.AuxInt 6700 if !(reciprocalExact32(float32(i2f(c)))) { 6701 break 6702 } 6703 v.reset(OpMul32F) 6704 v.AddArg(x) 6705 v0 := b.NewValue0(v.Pos, OpConst32F, t) 6706 v0.AuxInt = f2i(1 / i2f(c)) 6707 v.AddArg(v0) 6708 return true 6709 } 6710 return false 6711 } 6712 func rewriteValuegeneric_OpDiv32u_0(v *Value) bool { 6713 b := v.Block 6714 _ = b 6715 config := b.Func.Config 6716 _ = config 6717 typ := &b.Func.Config.Types 6718 _ = typ 6719 // match: (Div32u (Const32 [c]) (Const32 [d])) 6720 // cond: d != 0 6721 // result: (Const32 [int64(int32(uint32(c)/uint32(d)))]) 6722 for { 6723 _ = v.Args[1] 6724 v_0 := v.Args[0] 6725 if v_0.Op != OpConst32 { 6726 break 6727 } 6728 c := v_0.AuxInt 6729 v_1 := v.Args[1] 6730 if v_1.Op != OpConst32 { 6731 break 6732 } 6733 d := v_1.AuxInt 6734 if !(d != 0) { 6735 break 6736 } 6737 v.reset(OpConst32) 6738 v.AuxInt = int64(int32(uint32(c) / uint32(d))) 6739 return true 6740 } 6741 // match: (Div32u n (Const32 [c])) 6742 // cond: isPowerOfTwo(c&0xffffffff) 6743 // result: (Rsh32Ux64 n (Const64 <typ.UInt64> [log2(c&0xffffffff)])) 6744 for { 6745 _ = v.Args[1] 6746 n := v.Args[0] 6747 v_1 := v.Args[1] 6748 if v_1.Op != OpConst32 { 6749 break 6750 } 6751 c := v_1.AuxInt 6752 if !(isPowerOfTwo(c & 0xffffffff)) { 6753 break 6754 } 6755 v.reset(OpRsh32Ux64) 6756 v.AddArg(n) 6757 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6758 v0.AuxInt = log2(c & 0xffffffff) 6759 v.AddArg(v0) 6760 return true 6761 } 6762 // match: (Div32u x (Const32 [c])) 6763 // cond: umagicOK(32, c) && config.RegSize == 4 && umagic(32,c).m&1 == 0 6764 // result: (Rsh32Ux64 <typ.UInt32> (Hmul32u <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(1<<31+umagic(32,c).m/2))]) x) (Const64 <typ.UInt64> [umagic(32,c).s-1])) 6765 for { 6766 _ = v.Args[1] 6767 x := v.Args[0] 6768 v_1 := v.Args[1] 6769 if v_1.Op != OpConst32 { 6770 break 6771 } 6772 c := v_1.AuxInt 6773 if !(umagicOK(32, c) && config.RegSize == 4 && umagic(32, c).m&1 == 0) { 6774 break 6775 } 6776 v.reset(OpRsh32Ux64) 6777 v.Type = typ.UInt32 6778 v0 := b.NewValue0(v.Pos, OpHmul32u, typ.UInt32) 6779 v1 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 6780 v1.AuxInt = int64(int32(1<<31 + umagic(32, c).m/2)) 6781 v0.AddArg(v1) 6782 v0.AddArg(x) 6783 v.AddArg(v0) 6784 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6785 v2.AuxInt = umagic(32, c).s - 1 6786 v.AddArg(v2) 6787 return true 6788 } 6789 // match: (Div32u x (Const32 [c])) 6790 // cond: umagicOK(32, c) && config.RegSize == 4 && c&1 == 0 6791 // result: (Rsh32Ux64 <typ.UInt32> (Hmul32u <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(1<<31+(umagic(32,c).m+1)/2))]) (Rsh32Ux64 <typ.UInt32> x (Const64 <typ.UInt64> [1]))) (Const64 <typ.UInt64> [umagic(32,c).s-2])) 6792 for { 6793 _ = v.Args[1] 6794 x := v.Args[0] 6795 v_1 := v.Args[1] 6796 if v_1.Op != OpConst32 { 6797 break 6798 } 6799 c := v_1.AuxInt 6800 if !(umagicOK(32, c) && config.RegSize == 4 && c&1 == 0) { 6801 break 6802 } 6803 v.reset(OpRsh32Ux64) 6804 v.Type = typ.UInt32 6805 v0 := b.NewValue0(v.Pos, OpHmul32u, typ.UInt32) 6806 v1 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 6807 v1.AuxInt = int64(int32(1<<31 + (umagic(32, c).m+1)/2)) 6808 v0.AddArg(v1) 6809 v2 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) 6810 v2.AddArg(x) 6811 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6812 v3.AuxInt = 1 6813 v2.AddArg(v3) 6814 v0.AddArg(v2) 6815 v.AddArg(v0) 6816 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6817 v4.AuxInt = umagic(32, c).s - 2 6818 v.AddArg(v4) 6819 return true 6820 } 6821 // match: (Div32u x (Const32 [c])) 6822 // cond: umagicOK(32, c) && config.RegSize == 4 6823 // result: (Rsh32Ux64 <typ.UInt32> (Avg32u x (Hmul32u <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(umagic(32,c).m))]) x)) (Const64 <typ.UInt64> [umagic(32,c).s-1])) 6824 for { 6825 _ = v.Args[1] 6826 x := v.Args[0] 6827 v_1 := v.Args[1] 6828 if v_1.Op != OpConst32 { 6829 break 6830 } 6831 c := v_1.AuxInt 6832 if !(umagicOK(32, c) && config.RegSize == 4) { 6833 break 6834 } 6835 v.reset(OpRsh32Ux64) 6836 v.Type = typ.UInt32 6837 v0 := b.NewValue0(v.Pos, OpAvg32u, typ.UInt32) 6838 v0.AddArg(x) 6839 v1 := b.NewValue0(v.Pos, OpHmul32u, typ.UInt32) 6840 v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 6841 v2.AuxInt = int64(int32(umagic(32, c).m)) 6842 v1.AddArg(v2) 6843 v1.AddArg(x) 6844 v0.AddArg(v1) 6845 v.AddArg(v0) 6846 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6847 v3.AuxInt = umagic(32, c).s - 1 6848 v.AddArg(v3) 6849 return true 6850 } 6851 // match: (Div32u x (Const32 [c])) 6852 // cond: umagicOK(32, c) && config.RegSize == 8 && umagic(32,c).m&1 == 0 6853 // result: (Trunc64to32 (Rsh64Ux64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<31+umagic(32,c).m/2)]) (ZeroExt32to64 x)) (Const64 <typ.UInt64> [32+umagic(32,c).s-1]))) 6854 for { 6855 _ = v.Args[1] 6856 x := v.Args[0] 6857 v_1 := v.Args[1] 6858 if v_1.Op != OpConst32 { 6859 break 6860 } 6861 c := v_1.AuxInt 6862 if !(umagicOK(32, c) && config.RegSize == 8 && umagic(32, c).m&1 == 0) { 6863 break 6864 } 6865 v.reset(OpTrunc64to32) 6866 v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) 6867 v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) 6868 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6869 v2.AuxInt = int64(1<<31 + umagic(32, c).m/2) 6870 v1.AddArg(v2) 6871 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64) 6872 v3.AddArg(x) 6873 v1.AddArg(v3) 6874 v0.AddArg(v1) 6875 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6876 v4.AuxInt = 32 + umagic(32, c).s - 1 6877 v0.AddArg(v4) 6878 v.AddArg(v0) 6879 return true 6880 } 6881 // match: (Div32u x (Const32 [c])) 6882 // cond: umagicOK(32, c) && config.RegSize == 8 && c&1 == 0 6883 // result: (Trunc64to32 (Rsh64Ux64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<31+(umagic(32,c).m+1)/2)]) (Rsh64Ux64 <typ.UInt64> (ZeroExt32to64 x) (Const64 <typ.UInt64> [1]))) (Const64 <typ.UInt64> [32+umagic(32,c).s-2]))) 6884 for { 6885 _ = v.Args[1] 6886 x := v.Args[0] 6887 v_1 := v.Args[1] 6888 if v_1.Op != OpConst32 { 6889 break 6890 } 6891 c := v_1.AuxInt 6892 if !(umagicOK(32, c) && config.RegSize == 8 && c&1 == 0) { 6893 break 6894 } 6895 v.reset(OpTrunc64to32) 6896 v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) 6897 v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) 6898 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6899 v2.AuxInt = int64(1<<31 + (umagic(32, c).m+1)/2) 6900 v1.AddArg(v2) 6901 v3 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) 6902 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64) 6903 v4.AddArg(x) 6904 v3.AddArg(v4) 6905 v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6906 v5.AuxInt = 1 6907 v3.AddArg(v5) 6908 v1.AddArg(v3) 6909 v0.AddArg(v1) 6910 v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6911 v6.AuxInt = 32 + umagic(32, c).s - 2 6912 v0.AddArg(v6) 6913 v.AddArg(v0) 6914 return true 6915 } 6916 // match: (Div32u x (Const32 [c])) 6917 // cond: umagicOK(32, c) && config.RegSize == 8 6918 // result: (Trunc64to32 (Rsh64Ux64 <typ.UInt64> (Avg64u (Lsh64x64 <typ.UInt64> (ZeroExt32to64 x) (Const64 <typ.UInt64> [32])) (Mul64 <typ.UInt64> (Const64 <typ.UInt32> [int64(umagic(32,c).m)]) (ZeroExt32to64 x))) (Const64 <typ.UInt64> [32+umagic(32,c).s-1]))) 6919 for { 6920 _ = v.Args[1] 6921 x := v.Args[0] 6922 v_1 := v.Args[1] 6923 if v_1.Op != OpConst32 { 6924 break 6925 } 6926 c := v_1.AuxInt 6927 if !(umagicOK(32, c) && config.RegSize == 8) { 6928 break 6929 } 6930 v.reset(OpTrunc64to32) 6931 v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) 6932 v1 := b.NewValue0(v.Pos, OpAvg64u, typ.UInt64) 6933 v2 := b.NewValue0(v.Pos, OpLsh64x64, typ.UInt64) 6934 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64) 6935 v3.AddArg(x) 6936 v2.AddArg(v3) 6937 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6938 v4.AuxInt = 32 6939 v2.AddArg(v4) 6940 v1.AddArg(v2) 6941 v5 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) 6942 v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt32) 6943 v6.AuxInt = int64(umagic(32, c).m) 6944 v5.AddArg(v6) 6945 v7 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64) 6946 v7.AddArg(x) 6947 v5.AddArg(v7) 6948 v1.AddArg(v5) 6949 v0.AddArg(v1) 6950 v8 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 6951 v8.AuxInt = 32 + umagic(32, c).s - 1 6952 v0.AddArg(v8) 6953 v.AddArg(v0) 6954 return true 6955 } 6956 return false 6957 } 6958 func rewriteValuegeneric_OpDiv64_0(v *Value) bool { 6959 b := v.Block 6960 _ = b 6961 typ := &b.Func.Config.Types 6962 _ = typ 6963 // match: (Div64 (Const64 [c]) (Const64 [d])) 6964 // cond: d != 0 6965 // result: (Const64 [c/d]) 6966 for { 6967 _ = v.Args[1] 6968 v_0 := v.Args[0] 6969 if v_0.Op != OpConst64 { 6970 break 6971 } 6972 c := v_0.AuxInt 6973 v_1 := v.Args[1] 6974 if v_1.Op != OpConst64 { 6975 break 6976 } 6977 d := v_1.AuxInt 6978 if !(d != 0) { 6979 break 6980 } 6981 v.reset(OpConst64) 6982 v.AuxInt = c / d 6983 return true 6984 } 6985 // match: (Div64 <t> n (Const64 [c])) 6986 // cond: c < 0 && c != -1<<63 6987 // result: (Neg64 (Div64 <t> n (Const64 <t> [-c]))) 6988 for { 6989 t := v.Type 6990 _ = v.Args[1] 6991 n := v.Args[0] 6992 v_1 := v.Args[1] 6993 if v_1.Op != OpConst64 { 6994 break 6995 } 6996 c := v_1.AuxInt 6997 if !(c < 0 && c != -1<<63) { 6998 break 6999 } 7000 v.reset(OpNeg64) 7001 v0 := b.NewValue0(v.Pos, OpDiv64, t) 7002 v0.AddArg(n) 7003 v1 := b.NewValue0(v.Pos, OpConst64, t) 7004 v1.AuxInt = -c 7005 v0.AddArg(v1) 7006 v.AddArg(v0) 7007 return true 7008 } 7009 // match: (Div64 <t> x (Const64 [-1<<63])) 7010 // cond: 7011 // result: (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <typ.UInt64> [63])) 7012 for { 7013 t := v.Type 7014 _ = v.Args[1] 7015 x := v.Args[0] 7016 v_1 := v.Args[1] 7017 if v_1.Op != OpConst64 { 7018 break 7019 } 7020 if v_1.AuxInt != -1<<63 { 7021 break 7022 } 7023 v.reset(OpRsh64Ux64) 7024 v0 := b.NewValue0(v.Pos, OpAnd64, t) 7025 v0.AddArg(x) 7026 v1 := b.NewValue0(v.Pos, OpNeg64, t) 7027 v1.AddArg(x) 7028 v0.AddArg(v1) 7029 v.AddArg(v0) 7030 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7031 v2.AuxInt = 63 7032 v.AddArg(v2) 7033 return true 7034 } 7035 // match: (Div64 <t> n (Const64 [c])) 7036 // cond: isPowerOfTwo(c) 7037 // result: (Rsh64x64 (Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <typ.UInt64> [63])) (Const64 <typ.UInt64> [64-log2(c)]))) (Const64 <typ.UInt64> [log2(c)])) 7038 for { 7039 t := v.Type 7040 _ = v.Args[1] 7041 n := v.Args[0] 7042 v_1 := v.Args[1] 7043 if v_1.Op != OpConst64 { 7044 break 7045 } 7046 c := v_1.AuxInt 7047 if !(isPowerOfTwo(c)) { 7048 break 7049 } 7050 v.reset(OpRsh64x64) 7051 v0 := b.NewValue0(v.Pos, OpAdd64, t) 7052 v0.AddArg(n) 7053 v1 := b.NewValue0(v.Pos, OpRsh64Ux64, t) 7054 v2 := b.NewValue0(v.Pos, OpRsh64x64, t) 7055 v2.AddArg(n) 7056 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7057 v3.AuxInt = 63 7058 v2.AddArg(v3) 7059 v1.AddArg(v2) 7060 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7061 v4.AuxInt = 64 - log2(c) 7062 v1.AddArg(v4) 7063 v0.AddArg(v1) 7064 v.AddArg(v0) 7065 v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7066 v5.AuxInt = log2(c) 7067 v.AddArg(v5) 7068 return true 7069 } 7070 // match: (Div64 <t> x (Const64 [c])) 7071 // cond: smagicOK(64,c) && smagic(64,c).m&1 == 0 7072 // result: (Sub64 <t> (Rsh64x64 <t> (Hmul64 <t> (Const64 <typ.UInt64> [int64(smagic(64,c).m/2)]) x) (Const64 <typ.UInt64> [smagic(64,c).s-1])) (Rsh64x64 <t> x (Const64 <typ.UInt64> [63]))) 7073 for { 7074 t := v.Type 7075 _ = v.Args[1] 7076 x := v.Args[0] 7077 v_1 := v.Args[1] 7078 if v_1.Op != OpConst64 { 7079 break 7080 } 7081 c := v_1.AuxInt 7082 if !(smagicOK(64, c) && smagic(64, c).m&1 == 0) { 7083 break 7084 } 7085 v.reset(OpSub64) 7086 v.Type = t 7087 v0 := b.NewValue0(v.Pos, OpRsh64x64, t) 7088 v1 := b.NewValue0(v.Pos, OpHmul64, t) 7089 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7090 v2.AuxInt = int64(smagic(64, c).m / 2) 7091 v1.AddArg(v2) 7092 v1.AddArg(x) 7093 v0.AddArg(v1) 7094 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7095 v3.AuxInt = smagic(64, c).s - 1 7096 v0.AddArg(v3) 7097 v.AddArg(v0) 7098 v4 := b.NewValue0(v.Pos, OpRsh64x64, t) 7099 v4.AddArg(x) 7100 v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7101 v5.AuxInt = 63 7102 v4.AddArg(v5) 7103 v.AddArg(v4) 7104 return true 7105 } 7106 // match: (Div64 <t> x (Const64 [c])) 7107 // cond: smagicOK(64,c) && smagic(64,c).m&1 != 0 7108 // result: (Sub64 <t> (Rsh64x64 <t> (Add64 <t> (Hmul64 <t> (Const64 <typ.UInt64> [int64(smagic(64,c).m)]) x) x) (Const64 <typ.UInt64> [smagic(64,c).s])) (Rsh64x64 <t> x (Const64 <typ.UInt64> [63]))) 7109 for { 7110 t := v.Type 7111 _ = v.Args[1] 7112 x := v.Args[0] 7113 v_1 := v.Args[1] 7114 if v_1.Op != OpConst64 { 7115 break 7116 } 7117 c := v_1.AuxInt 7118 if !(smagicOK(64, c) && smagic(64, c).m&1 != 0) { 7119 break 7120 } 7121 v.reset(OpSub64) 7122 v.Type = t 7123 v0 := b.NewValue0(v.Pos, OpRsh64x64, t) 7124 v1 := b.NewValue0(v.Pos, OpAdd64, t) 7125 v2 := b.NewValue0(v.Pos, OpHmul64, t) 7126 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7127 v3.AuxInt = int64(smagic(64, c).m) 7128 v2.AddArg(v3) 7129 v2.AddArg(x) 7130 v1.AddArg(v2) 7131 v1.AddArg(x) 7132 v0.AddArg(v1) 7133 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7134 v4.AuxInt = smagic(64, c).s 7135 v0.AddArg(v4) 7136 v.AddArg(v0) 7137 v5 := b.NewValue0(v.Pos, OpRsh64x64, t) 7138 v5.AddArg(x) 7139 v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7140 v6.AuxInt = 63 7141 v5.AddArg(v6) 7142 v.AddArg(v5) 7143 return true 7144 } 7145 return false 7146 } 7147 func rewriteValuegeneric_OpDiv64F_0(v *Value) bool { 7148 b := v.Block 7149 _ = b 7150 // match: (Div64F (Const64F [c]) (Const64F [d])) 7151 // cond: 7152 // result: (Const64F [f2i(i2f(c) / i2f(d))]) 7153 for { 7154 _ = v.Args[1] 7155 v_0 := v.Args[0] 7156 if v_0.Op != OpConst64F { 7157 break 7158 } 7159 c := v_0.AuxInt 7160 v_1 := v.Args[1] 7161 if v_1.Op != OpConst64F { 7162 break 7163 } 7164 d := v_1.AuxInt 7165 v.reset(OpConst64F) 7166 v.AuxInt = f2i(i2f(c) / i2f(d)) 7167 return true 7168 } 7169 // match: (Div64F x (Const64F <t> [c])) 7170 // cond: reciprocalExact64(i2f(c)) 7171 // result: (Mul64F x (Const64F <t> [f2i(1/i2f(c))])) 7172 for { 7173 _ = v.Args[1] 7174 x := v.Args[0] 7175 v_1 := v.Args[1] 7176 if v_1.Op != OpConst64F { 7177 break 7178 } 7179 t := v_1.Type 7180 c := v_1.AuxInt 7181 if !(reciprocalExact64(i2f(c))) { 7182 break 7183 } 7184 v.reset(OpMul64F) 7185 v.AddArg(x) 7186 v0 := b.NewValue0(v.Pos, OpConst64F, t) 7187 v0.AuxInt = f2i(1 / i2f(c)) 7188 v.AddArg(v0) 7189 return true 7190 } 7191 return false 7192 } 7193 func rewriteValuegeneric_OpDiv64u_0(v *Value) bool { 7194 b := v.Block 7195 _ = b 7196 config := b.Func.Config 7197 _ = config 7198 typ := &b.Func.Config.Types 7199 _ = typ 7200 // match: (Div64u (Const64 [c]) (Const64 [d])) 7201 // cond: d != 0 7202 // result: (Const64 [int64(uint64(c)/uint64(d))]) 7203 for { 7204 _ = v.Args[1] 7205 v_0 := v.Args[0] 7206 if v_0.Op != OpConst64 { 7207 break 7208 } 7209 c := v_0.AuxInt 7210 v_1 := v.Args[1] 7211 if v_1.Op != OpConst64 { 7212 break 7213 } 7214 d := v_1.AuxInt 7215 if !(d != 0) { 7216 break 7217 } 7218 v.reset(OpConst64) 7219 v.AuxInt = int64(uint64(c) / uint64(d)) 7220 return true 7221 } 7222 // match: (Div64u n (Const64 [c])) 7223 // cond: isPowerOfTwo(c) 7224 // result: (Rsh64Ux64 n (Const64 <typ.UInt64> [log2(c)])) 7225 for { 7226 _ = v.Args[1] 7227 n := v.Args[0] 7228 v_1 := v.Args[1] 7229 if v_1.Op != OpConst64 { 7230 break 7231 } 7232 c := v_1.AuxInt 7233 if !(isPowerOfTwo(c)) { 7234 break 7235 } 7236 v.reset(OpRsh64Ux64) 7237 v.AddArg(n) 7238 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7239 v0.AuxInt = log2(c) 7240 v.AddArg(v0) 7241 return true 7242 } 7243 // match: (Div64u x (Const64 [c])) 7244 // cond: umagicOK(64, c) && config.RegSize == 8 && umagic(64,c).m&1 == 0 7245 // result: (Rsh64Ux64 <typ.UInt64> (Hmul64u <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<63+umagic(64,c).m/2)]) x) (Const64 <typ.UInt64> [umagic(64,c).s-1])) 7246 for { 7247 _ = v.Args[1] 7248 x := v.Args[0] 7249 v_1 := v.Args[1] 7250 if v_1.Op != OpConst64 { 7251 break 7252 } 7253 c := v_1.AuxInt 7254 if !(umagicOK(64, c) && config.RegSize == 8 && umagic(64, c).m&1 == 0) { 7255 break 7256 } 7257 v.reset(OpRsh64Ux64) 7258 v.Type = typ.UInt64 7259 v0 := b.NewValue0(v.Pos, OpHmul64u, typ.UInt64) 7260 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7261 v1.AuxInt = int64(1<<63 + umagic(64, c).m/2) 7262 v0.AddArg(v1) 7263 v0.AddArg(x) 7264 v.AddArg(v0) 7265 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7266 v2.AuxInt = umagic(64, c).s - 1 7267 v.AddArg(v2) 7268 return true 7269 } 7270 // match: (Div64u x (Const64 [c])) 7271 // cond: umagicOK(64, c) && config.RegSize == 8 && c&1 == 0 7272 // result: (Rsh64Ux64 <typ.UInt64> (Hmul64u <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<63+(umagic(64,c).m+1)/2)]) (Rsh64Ux64 <typ.UInt64> x (Const64 <typ.UInt64> [1]))) (Const64 <typ.UInt64> [umagic(64,c).s-2])) 7273 for { 7274 _ = v.Args[1] 7275 x := v.Args[0] 7276 v_1 := v.Args[1] 7277 if v_1.Op != OpConst64 { 7278 break 7279 } 7280 c := v_1.AuxInt 7281 if !(umagicOK(64, c) && config.RegSize == 8 && c&1 == 0) { 7282 break 7283 } 7284 v.reset(OpRsh64Ux64) 7285 v.Type = typ.UInt64 7286 v0 := b.NewValue0(v.Pos, OpHmul64u, typ.UInt64) 7287 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7288 v1.AuxInt = int64(1<<63 + (umagic(64, c).m+1)/2) 7289 v0.AddArg(v1) 7290 v2 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) 7291 v2.AddArg(x) 7292 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7293 v3.AuxInt = 1 7294 v2.AddArg(v3) 7295 v0.AddArg(v2) 7296 v.AddArg(v0) 7297 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7298 v4.AuxInt = umagic(64, c).s - 2 7299 v.AddArg(v4) 7300 return true 7301 } 7302 // match: (Div64u x (Const64 [c])) 7303 // cond: umagicOK(64, c) && config.RegSize == 8 7304 // result: (Rsh64Ux64 <typ.UInt64> (Avg64u x (Hmul64u <typ.UInt64> (Const64 <typ.UInt64> [int64(umagic(64,c).m)]) x)) (Const64 <typ.UInt64> [umagic(64,c).s-1])) 7305 for { 7306 _ = v.Args[1] 7307 x := v.Args[0] 7308 v_1 := v.Args[1] 7309 if v_1.Op != OpConst64 { 7310 break 7311 } 7312 c := v_1.AuxInt 7313 if !(umagicOK(64, c) && config.RegSize == 8) { 7314 break 7315 } 7316 v.reset(OpRsh64Ux64) 7317 v.Type = typ.UInt64 7318 v0 := b.NewValue0(v.Pos, OpAvg64u, typ.UInt64) 7319 v0.AddArg(x) 7320 v1 := b.NewValue0(v.Pos, OpHmul64u, typ.UInt64) 7321 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7322 v2.AuxInt = int64(umagic(64, c).m) 7323 v1.AddArg(v2) 7324 v1.AddArg(x) 7325 v0.AddArg(v1) 7326 v.AddArg(v0) 7327 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7328 v3.AuxInt = umagic(64, c).s - 1 7329 v.AddArg(v3) 7330 return true 7331 } 7332 return false 7333 } 7334 func rewriteValuegeneric_OpDiv8_0(v *Value) bool { 7335 b := v.Block 7336 _ = b 7337 typ := &b.Func.Config.Types 7338 _ = typ 7339 // match: (Div8 (Const8 [c]) (Const8 [d])) 7340 // cond: d != 0 7341 // result: (Const8 [int64(int8(c)/int8(d))]) 7342 for { 7343 _ = v.Args[1] 7344 v_0 := v.Args[0] 7345 if v_0.Op != OpConst8 { 7346 break 7347 } 7348 c := v_0.AuxInt 7349 v_1 := v.Args[1] 7350 if v_1.Op != OpConst8 { 7351 break 7352 } 7353 d := v_1.AuxInt 7354 if !(d != 0) { 7355 break 7356 } 7357 v.reset(OpConst8) 7358 v.AuxInt = int64(int8(c) / int8(d)) 7359 return true 7360 } 7361 // match: (Div8 <t> n (Const8 [c])) 7362 // cond: c < 0 && c != -1<<7 7363 // result: (Neg8 (Div8 <t> n (Const8 <t> [-c]))) 7364 for { 7365 t := v.Type 7366 _ = v.Args[1] 7367 n := v.Args[0] 7368 v_1 := v.Args[1] 7369 if v_1.Op != OpConst8 { 7370 break 7371 } 7372 c := v_1.AuxInt 7373 if !(c < 0 && c != -1<<7) { 7374 break 7375 } 7376 v.reset(OpNeg8) 7377 v0 := b.NewValue0(v.Pos, OpDiv8, t) 7378 v0.AddArg(n) 7379 v1 := b.NewValue0(v.Pos, OpConst8, t) 7380 v1.AuxInt = -c 7381 v0.AddArg(v1) 7382 v.AddArg(v0) 7383 return true 7384 } 7385 // match: (Div8 <t> x (Const8 [-1<<7 ])) 7386 // cond: 7387 // result: (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <typ.UInt64> [7 ])) 7388 for { 7389 t := v.Type 7390 _ = v.Args[1] 7391 x := v.Args[0] 7392 v_1 := v.Args[1] 7393 if v_1.Op != OpConst8 { 7394 break 7395 } 7396 if v_1.AuxInt != -1<<7 { 7397 break 7398 } 7399 v.reset(OpRsh8Ux64) 7400 v0 := b.NewValue0(v.Pos, OpAnd8, t) 7401 v0.AddArg(x) 7402 v1 := b.NewValue0(v.Pos, OpNeg8, t) 7403 v1.AddArg(x) 7404 v0.AddArg(v1) 7405 v.AddArg(v0) 7406 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7407 v2.AuxInt = 7 7408 v.AddArg(v2) 7409 return true 7410 } 7411 // match: (Div8 <t> n (Const8 [c])) 7412 // cond: isPowerOfTwo(c) 7413 // result: (Rsh8x64 (Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <typ.UInt64> [ 7])) (Const64 <typ.UInt64> [ 8-log2(c)]))) (Const64 <typ.UInt64> [log2(c)])) 7414 for { 7415 t := v.Type 7416 _ = v.Args[1] 7417 n := v.Args[0] 7418 v_1 := v.Args[1] 7419 if v_1.Op != OpConst8 { 7420 break 7421 } 7422 c := v_1.AuxInt 7423 if !(isPowerOfTwo(c)) { 7424 break 7425 } 7426 v.reset(OpRsh8x64) 7427 v0 := b.NewValue0(v.Pos, OpAdd8, t) 7428 v0.AddArg(n) 7429 v1 := b.NewValue0(v.Pos, OpRsh8Ux64, t) 7430 v2 := b.NewValue0(v.Pos, OpRsh8x64, t) 7431 v2.AddArg(n) 7432 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7433 v3.AuxInt = 7 7434 v2.AddArg(v3) 7435 v1.AddArg(v2) 7436 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7437 v4.AuxInt = 8 - log2(c) 7438 v1.AddArg(v4) 7439 v0.AddArg(v1) 7440 v.AddArg(v0) 7441 v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7442 v5.AuxInt = log2(c) 7443 v.AddArg(v5) 7444 return true 7445 } 7446 // match: (Div8 <t> x (Const8 [c])) 7447 // cond: smagicOK(8,c) 7448 // result: (Sub8 <t> (Rsh32x64 <t> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(smagic(8,c).m)]) (SignExt8to32 x)) (Const64 <typ.UInt64> [8+smagic(8,c).s])) (Rsh32x64 <t> (SignExt8to32 x) (Const64 <typ.UInt64> [31]))) 7449 for { 7450 t := v.Type 7451 _ = v.Args[1] 7452 x := v.Args[0] 7453 v_1 := v.Args[1] 7454 if v_1.Op != OpConst8 { 7455 break 7456 } 7457 c := v_1.AuxInt 7458 if !(smagicOK(8, c)) { 7459 break 7460 } 7461 v.reset(OpSub8) 7462 v.Type = t 7463 v0 := b.NewValue0(v.Pos, OpRsh32x64, t) 7464 v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) 7465 v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 7466 v2.AuxInt = int64(smagic(8, c).m) 7467 v1.AddArg(v2) 7468 v3 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 7469 v3.AddArg(x) 7470 v1.AddArg(v3) 7471 v0.AddArg(v1) 7472 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7473 v4.AuxInt = 8 + smagic(8, c).s 7474 v0.AddArg(v4) 7475 v.AddArg(v0) 7476 v5 := b.NewValue0(v.Pos, OpRsh32x64, t) 7477 v6 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 7478 v6.AddArg(x) 7479 v5.AddArg(v6) 7480 v7 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7481 v7.AuxInt = 31 7482 v5.AddArg(v7) 7483 v.AddArg(v5) 7484 return true 7485 } 7486 return false 7487 } 7488 func rewriteValuegeneric_OpDiv8u_0(v *Value) bool { 7489 b := v.Block 7490 _ = b 7491 typ := &b.Func.Config.Types 7492 _ = typ 7493 // match: (Div8u (Const8 [c]) (Const8 [d])) 7494 // cond: d != 0 7495 // result: (Const8 [int64(int8(uint8(c)/uint8(d)))]) 7496 for { 7497 _ = v.Args[1] 7498 v_0 := v.Args[0] 7499 if v_0.Op != OpConst8 { 7500 break 7501 } 7502 c := v_0.AuxInt 7503 v_1 := v.Args[1] 7504 if v_1.Op != OpConst8 { 7505 break 7506 } 7507 d := v_1.AuxInt 7508 if !(d != 0) { 7509 break 7510 } 7511 v.reset(OpConst8) 7512 v.AuxInt = int64(int8(uint8(c) / uint8(d))) 7513 return true 7514 } 7515 // match: (Div8u n (Const8 [c])) 7516 // cond: isPowerOfTwo(c&0xff) 7517 // result: (Rsh8Ux64 n (Const64 <typ.UInt64> [log2(c&0xff)])) 7518 for { 7519 _ = v.Args[1] 7520 n := v.Args[0] 7521 v_1 := v.Args[1] 7522 if v_1.Op != OpConst8 { 7523 break 7524 } 7525 c := v_1.AuxInt 7526 if !(isPowerOfTwo(c & 0xff)) { 7527 break 7528 } 7529 v.reset(OpRsh8Ux64) 7530 v.AddArg(n) 7531 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7532 v0.AuxInt = log2(c & 0xff) 7533 v.AddArg(v0) 7534 return true 7535 } 7536 // match: (Div8u x (Const8 [c])) 7537 // cond: umagicOK(8, c) 7538 // result: (Trunc32to8 (Rsh32Ux64 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(1<<8+umagic(8,c).m)]) (ZeroExt8to32 x)) (Const64 <typ.UInt64> [8+umagic(8,c).s]))) 7539 for { 7540 _ = v.Args[1] 7541 x := v.Args[0] 7542 v_1 := v.Args[1] 7543 if v_1.Op != OpConst8 { 7544 break 7545 } 7546 c := v_1.AuxInt 7547 if !(umagicOK(8, c)) { 7548 break 7549 } 7550 v.reset(OpTrunc32to8) 7551 v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) 7552 v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) 7553 v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 7554 v2.AuxInt = int64(1<<8 + umagic(8, c).m) 7555 v1.AddArg(v2) 7556 v3 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 7557 v3.AddArg(x) 7558 v1.AddArg(v3) 7559 v0.AddArg(v1) 7560 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7561 v4.AuxInt = 8 + umagic(8, c).s 7562 v0.AddArg(v4) 7563 v.AddArg(v0) 7564 return true 7565 } 7566 return false 7567 } 7568 func rewriteValuegeneric_OpEq16_0(v *Value) bool { 7569 b := v.Block 7570 _ = b 7571 // match: (Eq16 x x) 7572 // cond: 7573 // result: (ConstBool [1]) 7574 for { 7575 _ = v.Args[1] 7576 x := v.Args[0] 7577 if x != v.Args[1] { 7578 break 7579 } 7580 v.reset(OpConstBool) 7581 v.AuxInt = 1 7582 return true 7583 } 7584 // match: (Eq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x)) 7585 // cond: 7586 // result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x) 7587 for { 7588 _ = v.Args[1] 7589 v_0 := v.Args[0] 7590 if v_0.Op != OpConst16 { 7591 break 7592 } 7593 t := v_0.Type 7594 c := v_0.AuxInt 7595 v_1 := v.Args[1] 7596 if v_1.Op != OpAdd16 { 7597 break 7598 } 7599 _ = v_1.Args[1] 7600 v_1_0 := v_1.Args[0] 7601 if v_1_0.Op != OpConst16 { 7602 break 7603 } 7604 if v_1_0.Type != t { 7605 break 7606 } 7607 d := v_1_0.AuxInt 7608 x := v_1.Args[1] 7609 v.reset(OpEq16) 7610 v0 := b.NewValue0(v.Pos, OpConst16, t) 7611 v0.AuxInt = int64(int16(c - d)) 7612 v.AddArg(v0) 7613 v.AddArg(x) 7614 return true 7615 } 7616 // match: (Eq16 (Const16 <t> [c]) (Add16 x (Const16 <t> [d]))) 7617 // cond: 7618 // result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x) 7619 for { 7620 _ = v.Args[1] 7621 v_0 := v.Args[0] 7622 if v_0.Op != OpConst16 { 7623 break 7624 } 7625 t := v_0.Type 7626 c := v_0.AuxInt 7627 v_1 := v.Args[1] 7628 if v_1.Op != OpAdd16 { 7629 break 7630 } 7631 _ = v_1.Args[1] 7632 x := v_1.Args[0] 7633 v_1_1 := v_1.Args[1] 7634 if v_1_1.Op != OpConst16 { 7635 break 7636 } 7637 if v_1_1.Type != t { 7638 break 7639 } 7640 d := v_1_1.AuxInt 7641 v.reset(OpEq16) 7642 v0 := b.NewValue0(v.Pos, OpConst16, t) 7643 v0.AuxInt = int64(int16(c - d)) 7644 v.AddArg(v0) 7645 v.AddArg(x) 7646 return true 7647 } 7648 // match: (Eq16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c])) 7649 // cond: 7650 // result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x) 7651 for { 7652 _ = v.Args[1] 7653 v_0 := v.Args[0] 7654 if v_0.Op != OpAdd16 { 7655 break 7656 } 7657 _ = v_0.Args[1] 7658 v_0_0 := v_0.Args[0] 7659 if v_0_0.Op != OpConst16 { 7660 break 7661 } 7662 t := v_0_0.Type 7663 d := v_0_0.AuxInt 7664 x := v_0.Args[1] 7665 v_1 := v.Args[1] 7666 if v_1.Op != OpConst16 { 7667 break 7668 } 7669 if v_1.Type != t { 7670 break 7671 } 7672 c := v_1.AuxInt 7673 v.reset(OpEq16) 7674 v0 := b.NewValue0(v.Pos, OpConst16, t) 7675 v0.AuxInt = int64(int16(c - d)) 7676 v.AddArg(v0) 7677 v.AddArg(x) 7678 return true 7679 } 7680 // match: (Eq16 (Add16 x (Const16 <t> [d])) (Const16 <t> [c])) 7681 // cond: 7682 // result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x) 7683 for { 7684 _ = v.Args[1] 7685 v_0 := v.Args[0] 7686 if v_0.Op != OpAdd16 { 7687 break 7688 } 7689 _ = v_0.Args[1] 7690 x := v_0.Args[0] 7691 v_0_1 := v_0.Args[1] 7692 if v_0_1.Op != OpConst16 { 7693 break 7694 } 7695 t := v_0_1.Type 7696 d := v_0_1.AuxInt 7697 v_1 := v.Args[1] 7698 if v_1.Op != OpConst16 { 7699 break 7700 } 7701 if v_1.Type != t { 7702 break 7703 } 7704 c := v_1.AuxInt 7705 v.reset(OpEq16) 7706 v0 := b.NewValue0(v.Pos, OpConst16, t) 7707 v0.AuxInt = int64(int16(c - d)) 7708 v.AddArg(v0) 7709 v.AddArg(x) 7710 return true 7711 } 7712 // match: (Eq16 (Const16 [c]) (Const16 [d])) 7713 // cond: 7714 // result: (ConstBool [b2i(c == d)]) 7715 for { 7716 _ = v.Args[1] 7717 v_0 := v.Args[0] 7718 if v_0.Op != OpConst16 { 7719 break 7720 } 7721 c := v_0.AuxInt 7722 v_1 := v.Args[1] 7723 if v_1.Op != OpConst16 { 7724 break 7725 } 7726 d := v_1.AuxInt 7727 v.reset(OpConstBool) 7728 v.AuxInt = b2i(c == d) 7729 return true 7730 } 7731 // match: (Eq16 (Const16 [d]) (Const16 [c])) 7732 // cond: 7733 // result: (ConstBool [b2i(c == d)]) 7734 for { 7735 _ = v.Args[1] 7736 v_0 := v.Args[0] 7737 if v_0.Op != OpConst16 { 7738 break 7739 } 7740 d := v_0.AuxInt 7741 v_1 := v.Args[1] 7742 if v_1.Op != OpConst16 { 7743 break 7744 } 7745 c := v_1.AuxInt 7746 v.reset(OpConstBool) 7747 v.AuxInt = b2i(c == d) 7748 return true 7749 } 7750 return false 7751 } 7752 func rewriteValuegeneric_OpEq32_0(v *Value) bool { 7753 b := v.Block 7754 _ = b 7755 // match: (Eq32 x x) 7756 // cond: 7757 // result: (ConstBool [1]) 7758 for { 7759 _ = v.Args[1] 7760 x := v.Args[0] 7761 if x != v.Args[1] { 7762 break 7763 } 7764 v.reset(OpConstBool) 7765 v.AuxInt = 1 7766 return true 7767 } 7768 // match: (Eq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x)) 7769 // cond: 7770 // result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x) 7771 for { 7772 _ = v.Args[1] 7773 v_0 := v.Args[0] 7774 if v_0.Op != OpConst32 { 7775 break 7776 } 7777 t := v_0.Type 7778 c := v_0.AuxInt 7779 v_1 := v.Args[1] 7780 if v_1.Op != OpAdd32 { 7781 break 7782 } 7783 _ = v_1.Args[1] 7784 v_1_0 := v_1.Args[0] 7785 if v_1_0.Op != OpConst32 { 7786 break 7787 } 7788 if v_1_0.Type != t { 7789 break 7790 } 7791 d := v_1_0.AuxInt 7792 x := v_1.Args[1] 7793 v.reset(OpEq32) 7794 v0 := b.NewValue0(v.Pos, OpConst32, t) 7795 v0.AuxInt = int64(int32(c - d)) 7796 v.AddArg(v0) 7797 v.AddArg(x) 7798 return true 7799 } 7800 // match: (Eq32 (Const32 <t> [c]) (Add32 x (Const32 <t> [d]))) 7801 // cond: 7802 // result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x) 7803 for { 7804 _ = v.Args[1] 7805 v_0 := v.Args[0] 7806 if v_0.Op != OpConst32 { 7807 break 7808 } 7809 t := v_0.Type 7810 c := v_0.AuxInt 7811 v_1 := v.Args[1] 7812 if v_1.Op != OpAdd32 { 7813 break 7814 } 7815 _ = v_1.Args[1] 7816 x := v_1.Args[0] 7817 v_1_1 := v_1.Args[1] 7818 if v_1_1.Op != OpConst32 { 7819 break 7820 } 7821 if v_1_1.Type != t { 7822 break 7823 } 7824 d := v_1_1.AuxInt 7825 v.reset(OpEq32) 7826 v0 := b.NewValue0(v.Pos, OpConst32, t) 7827 v0.AuxInt = int64(int32(c - d)) 7828 v.AddArg(v0) 7829 v.AddArg(x) 7830 return true 7831 } 7832 // match: (Eq32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c])) 7833 // cond: 7834 // result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x) 7835 for { 7836 _ = v.Args[1] 7837 v_0 := v.Args[0] 7838 if v_0.Op != OpAdd32 { 7839 break 7840 } 7841 _ = v_0.Args[1] 7842 v_0_0 := v_0.Args[0] 7843 if v_0_0.Op != OpConst32 { 7844 break 7845 } 7846 t := v_0_0.Type 7847 d := v_0_0.AuxInt 7848 x := v_0.Args[1] 7849 v_1 := v.Args[1] 7850 if v_1.Op != OpConst32 { 7851 break 7852 } 7853 if v_1.Type != t { 7854 break 7855 } 7856 c := v_1.AuxInt 7857 v.reset(OpEq32) 7858 v0 := b.NewValue0(v.Pos, OpConst32, t) 7859 v0.AuxInt = int64(int32(c - d)) 7860 v.AddArg(v0) 7861 v.AddArg(x) 7862 return true 7863 } 7864 // match: (Eq32 (Add32 x (Const32 <t> [d])) (Const32 <t> [c])) 7865 // cond: 7866 // result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x) 7867 for { 7868 _ = v.Args[1] 7869 v_0 := v.Args[0] 7870 if v_0.Op != OpAdd32 { 7871 break 7872 } 7873 _ = v_0.Args[1] 7874 x := v_0.Args[0] 7875 v_0_1 := v_0.Args[1] 7876 if v_0_1.Op != OpConst32 { 7877 break 7878 } 7879 t := v_0_1.Type 7880 d := v_0_1.AuxInt 7881 v_1 := v.Args[1] 7882 if v_1.Op != OpConst32 { 7883 break 7884 } 7885 if v_1.Type != t { 7886 break 7887 } 7888 c := v_1.AuxInt 7889 v.reset(OpEq32) 7890 v0 := b.NewValue0(v.Pos, OpConst32, t) 7891 v0.AuxInt = int64(int32(c - d)) 7892 v.AddArg(v0) 7893 v.AddArg(x) 7894 return true 7895 } 7896 // match: (Eq32 (Const32 [c]) (Const32 [d])) 7897 // cond: 7898 // result: (ConstBool [b2i(c == d)]) 7899 for { 7900 _ = v.Args[1] 7901 v_0 := v.Args[0] 7902 if v_0.Op != OpConst32 { 7903 break 7904 } 7905 c := v_0.AuxInt 7906 v_1 := v.Args[1] 7907 if v_1.Op != OpConst32 { 7908 break 7909 } 7910 d := v_1.AuxInt 7911 v.reset(OpConstBool) 7912 v.AuxInt = b2i(c == d) 7913 return true 7914 } 7915 // match: (Eq32 (Const32 [d]) (Const32 [c])) 7916 // cond: 7917 // result: (ConstBool [b2i(c == d)]) 7918 for { 7919 _ = v.Args[1] 7920 v_0 := v.Args[0] 7921 if v_0.Op != OpConst32 { 7922 break 7923 } 7924 d := v_0.AuxInt 7925 v_1 := v.Args[1] 7926 if v_1.Op != OpConst32 { 7927 break 7928 } 7929 c := v_1.AuxInt 7930 v.reset(OpConstBool) 7931 v.AuxInt = b2i(c == d) 7932 return true 7933 } 7934 return false 7935 } 7936 func rewriteValuegeneric_OpEq64_0(v *Value) bool { 7937 b := v.Block 7938 _ = b 7939 // match: (Eq64 x x) 7940 // cond: 7941 // result: (ConstBool [1]) 7942 for { 7943 _ = v.Args[1] 7944 x := v.Args[0] 7945 if x != v.Args[1] { 7946 break 7947 } 7948 v.reset(OpConstBool) 7949 v.AuxInt = 1 7950 return true 7951 } 7952 // match: (Eq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x)) 7953 // cond: 7954 // result: (Eq64 (Const64 <t> [c-d]) x) 7955 for { 7956 _ = v.Args[1] 7957 v_0 := v.Args[0] 7958 if v_0.Op != OpConst64 { 7959 break 7960 } 7961 t := v_0.Type 7962 c := v_0.AuxInt 7963 v_1 := v.Args[1] 7964 if v_1.Op != OpAdd64 { 7965 break 7966 } 7967 _ = v_1.Args[1] 7968 v_1_0 := v_1.Args[0] 7969 if v_1_0.Op != OpConst64 { 7970 break 7971 } 7972 if v_1_0.Type != t { 7973 break 7974 } 7975 d := v_1_0.AuxInt 7976 x := v_1.Args[1] 7977 v.reset(OpEq64) 7978 v0 := b.NewValue0(v.Pos, OpConst64, t) 7979 v0.AuxInt = c - d 7980 v.AddArg(v0) 7981 v.AddArg(x) 7982 return true 7983 } 7984 // match: (Eq64 (Const64 <t> [c]) (Add64 x (Const64 <t> [d]))) 7985 // cond: 7986 // result: (Eq64 (Const64 <t> [c-d]) x) 7987 for { 7988 _ = v.Args[1] 7989 v_0 := v.Args[0] 7990 if v_0.Op != OpConst64 { 7991 break 7992 } 7993 t := v_0.Type 7994 c := v_0.AuxInt 7995 v_1 := v.Args[1] 7996 if v_1.Op != OpAdd64 { 7997 break 7998 } 7999 _ = v_1.Args[1] 8000 x := v_1.Args[0] 8001 v_1_1 := v_1.Args[1] 8002 if v_1_1.Op != OpConst64 { 8003 break 8004 } 8005 if v_1_1.Type != t { 8006 break 8007 } 8008 d := v_1_1.AuxInt 8009 v.reset(OpEq64) 8010 v0 := b.NewValue0(v.Pos, OpConst64, t) 8011 v0.AuxInt = c - d 8012 v.AddArg(v0) 8013 v.AddArg(x) 8014 return true 8015 } 8016 // match: (Eq64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c])) 8017 // cond: 8018 // result: (Eq64 (Const64 <t> [c-d]) x) 8019 for { 8020 _ = v.Args[1] 8021 v_0 := v.Args[0] 8022 if v_0.Op != OpAdd64 { 8023 break 8024 } 8025 _ = v_0.Args[1] 8026 v_0_0 := v_0.Args[0] 8027 if v_0_0.Op != OpConst64 { 8028 break 8029 } 8030 t := v_0_0.Type 8031 d := v_0_0.AuxInt 8032 x := v_0.Args[1] 8033 v_1 := v.Args[1] 8034 if v_1.Op != OpConst64 { 8035 break 8036 } 8037 if v_1.Type != t { 8038 break 8039 } 8040 c := v_1.AuxInt 8041 v.reset(OpEq64) 8042 v0 := b.NewValue0(v.Pos, OpConst64, t) 8043 v0.AuxInt = c - d 8044 v.AddArg(v0) 8045 v.AddArg(x) 8046 return true 8047 } 8048 // match: (Eq64 (Add64 x (Const64 <t> [d])) (Const64 <t> [c])) 8049 // cond: 8050 // result: (Eq64 (Const64 <t> [c-d]) x) 8051 for { 8052 _ = v.Args[1] 8053 v_0 := v.Args[0] 8054 if v_0.Op != OpAdd64 { 8055 break 8056 } 8057 _ = v_0.Args[1] 8058 x := v_0.Args[0] 8059 v_0_1 := v_0.Args[1] 8060 if v_0_1.Op != OpConst64 { 8061 break 8062 } 8063 t := v_0_1.Type 8064 d := v_0_1.AuxInt 8065 v_1 := v.Args[1] 8066 if v_1.Op != OpConst64 { 8067 break 8068 } 8069 if v_1.Type != t { 8070 break 8071 } 8072 c := v_1.AuxInt 8073 v.reset(OpEq64) 8074 v0 := b.NewValue0(v.Pos, OpConst64, t) 8075 v0.AuxInt = c - d 8076 v.AddArg(v0) 8077 v.AddArg(x) 8078 return true 8079 } 8080 // match: (Eq64 (Const64 [c]) (Const64 [d])) 8081 // cond: 8082 // result: (ConstBool [b2i(c == d)]) 8083 for { 8084 _ = v.Args[1] 8085 v_0 := v.Args[0] 8086 if v_0.Op != OpConst64 { 8087 break 8088 } 8089 c := v_0.AuxInt 8090 v_1 := v.Args[1] 8091 if v_1.Op != OpConst64 { 8092 break 8093 } 8094 d := v_1.AuxInt 8095 v.reset(OpConstBool) 8096 v.AuxInt = b2i(c == d) 8097 return true 8098 } 8099 // match: (Eq64 (Const64 [d]) (Const64 [c])) 8100 // cond: 8101 // result: (ConstBool [b2i(c == d)]) 8102 for { 8103 _ = v.Args[1] 8104 v_0 := v.Args[0] 8105 if v_0.Op != OpConst64 { 8106 break 8107 } 8108 d := v_0.AuxInt 8109 v_1 := v.Args[1] 8110 if v_1.Op != OpConst64 { 8111 break 8112 } 8113 c := v_1.AuxInt 8114 v.reset(OpConstBool) 8115 v.AuxInt = b2i(c == d) 8116 return true 8117 } 8118 return false 8119 } 8120 func rewriteValuegeneric_OpEq8_0(v *Value) bool { 8121 b := v.Block 8122 _ = b 8123 // match: (Eq8 x x) 8124 // cond: 8125 // result: (ConstBool [1]) 8126 for { 8127 _ = v.Args[1] 8128 x := v.Args[0] 8129 if x != v.Args[1] { 8130 break 8131 } 8132 v.reset(OpConstBool) 8133 v.AuxInt = 1 8134 return true 8135 } 8136 // match: (Eq8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x)) 8137 // cond: 8138 // result: (Eq8 (Const8 <t> [int64(int8(c-d))]) x) 8139 for { 8140 _ = v.Args[1] 8141 v_0 := v.Args[0] 8142 if v_0.Op != OpConst8 { 8143 break 8144 } 8145 t := v_0.Type 8146 c := v_0.AuxInt 8147 v_1 := v.Args[1] 8148 if v_1.Op != OpAdd8 { 8149 break 8150 } 8151 _ = v_1.Args[1] 8152 v_1_0 := v_1.Args[0] 8153 if v_1_0.Op != OpConst8 { 8154 break 8155 } 8156 if v_1_0.Type != t { 8157 break 8158 } 8159 d := v_1_0.AuxInt 8160 x := v_1.Args[1] 8161 v.reset(OpEq8) 8162 v0 := b.NewValue0(v.Pos, OpConst8, t) 8163 v0.AuxInt = int64(int8(c - d)) 8164 v.AddArg(v0) 8165 v.AddArg(x) 8166 return true 8167 } 8168 // match: (Eq8 (Const8 <t> [c]) (Add8 x (Const8 <t> [d]))) 8169 // cond: 8170 // result: (Eq8 (Const8 <t> [int64(int8(c-d))]) x) 8171 for { 8172 _ = v.Args[1] 8173 v_0 := v.Args[0] 8174 if v_0.Op != OpConst8 { 8175 break 8176 } 8177 t := v_0.Type 8178 c := v_0.AuxInt 8179 v_1 := v.Args[1] 8180 if v_1.Op != OpAdd8 { 8181 break 8182 } 8183 _ = v_1.Args[1] 8184 x := v_1.Args[0] 8185 v_1_1 := v_1.Args[1] 8186 if v_1_1.Op != OpConst8 { 8187 break 8188 } 8189 if v_1_1.Type != t { 8190 break 8191 } 8192 d := v_1_1.AuxInt 8193 v.reset(OpEq8) 8194 v0 := b.NewValue0(v.Pos, OpConst8, t) 8195 v0.AuxInt = int64(int8(c - d)) 8196 v.AddArg(v0) 8197 v.AddArg(x) 8198 return true 8199 } 8200 // match: (Eq8 (Add8 (Const8 <t> [d]) x) (Const8 <t> [c])) 8201 // cond: 8202 // result: (Eq8 (Const8 <t> [int64(int8(c-d))]) x) 8203 for { 8204 _ = v.Args[1] 8205 v_0 := v.Args[0] 8206 if v_0.Op != OpAdd8 { 8207 break 8208 } 8209 _ = v_0.Args[1] 8210 v_0_0 := v_0.Args[0] 8211 if v_0_0.Op != OpConst8 { 8212 break 8213 } 8214 t := v_0_0.Type 8215 d := v_0_0.AuxInt 8216 x := v_0.Args[1] 8217 v_1 := v.Args[1] 8218 if v_1.Op != OpConst8 { 8219 break 8220 } 8221 if v_1.Type != t { 8222 break 8223 } 8224 c := v_1.AuxInt 8225 v.reset(OpEq8) 8226 v0 := b.NewValue0(v.Pos, OpConst8, t) 8227 v0.AuxInt = int64(int8(c - d)) 8228 v.AddArg(v0) 8229 v.AddArg(x) 8230 return true 8231 } 8232 // match: (Eq8 (Add8 x (Const8 <t> [d])) (Const8 <t> [c])) 8233 // cond: 8234 // result: (Eq8 (Const8 <t> [int64(int8(c-d))]) x) 8235 for { 8236 _ = v.Args[1] 8237 v_0 := v.Args[0] 8238 if v_0.Op != OpAdd8 { 8239 break 8240 } 8241 _ = v_0.Args[1] 8242 x := v_0.Args[0] 8243 v_0_1 := v_0.Args[1] 8244 if v_0_1.Op != OpConst8 { 8245 break 8246 } 8247 t := v_0_1.Type 8248 d := v_0_1.AuxInt 8249 v_1 := v.Args[1] 8250 if v_1.Op != OpConst8 { 8251 break 8252 } 8253 if v_1.Type != t { 8254 break 8255 } 8256 c := v_1.AuxInt 8257 v.reset(OpEq8) 8258 v0 := b.NewValue0(v.Pos, OpConst8, t) 8259 v0.AuxInt = int64(int8(c - d)) 8260 v.AddArg(v0) 8261 v.AddArg(x) 8262 return true 8263 } 8264 // match: (Eq8 (Const8 [c]) (Const8 [d])) 8265 // cond: 8266 // result: (ConstBool [b2i(c == d)]) 8267 for { 8268 _ = v.Args[1] 8269 v_0 := v.Args[0] 8270 if v_0.Op != OpConst8 { 8271 break 8272 } 8273 c := v_0.AuxInt 8274 v_1 := v.Args[1] 8275 if v_1.Op != OpConst8 { 8276 break 8277 } 8278 d := v_1.AuxInt 8279 v.reset(OpConstBool) 8280 v.AuxInt = b2i(c == d) 8281 return true 8282 } 8283 // match: (Eq8 (Const8 [d]) (Const8 [c])) 8284 // cond: 8285 // result: (ConstBool [b2i(c == d)]) 8286 for { 8287 _ = v.Args[1] 8288 v_0 := v.Args[0] 8289 if v_0.Op != OpConst8 { 8290 break 8291 } 8292 d := v_0.AuxInt 8293 v_1 := v.Args[1] 8294 if v_1.Op != OpConst8 { 8295 break 8296 } 8297 c := v_1.AuxInt 8298 v.reset(OpConstBool) 8299 v.AuxInt = b2i(c == d) 8300 return true 8301 } 8302 return false 8303 } 8304 func rewriteValuegeneric_OpEqB_0(v *Value) bool { 8305 // match: (EqB (ConstBool [c]) (ConstBool [d])) 8306 // cond: 8307 // result: (ConstBool [b2i(c == d)]) 8308 for { 8309 _ = v.Args[1] 8310 v_0 := v.Args[0] 8311 if v_0.Op != OpConstBool { 8312 break 8313 } 8314 c := v_0.AuxInt 8315 v_1 := v.Args[1] 8316 if v_1.Op != OpConstBool { 8317 break 8318 } 8319 d := v_1.AuxInt 8320 v.reset(OpConstBool) 8321 v.AuxInt = b2i(c == d) 8322 return true 8323 } 8324 // match: (EqB (ConstBool [d]) (ConstBool [c])) 8325 // cond: 8326 // result: (ConstBool [b2i(c == d)]) 8327 for { 8328 _ = v.Args[1] 8329 v_0 := v.Args[0] 8330 if v_0.Op != OpConstBool { 8331 break 8332 } 8333 d := v_0.AuxInt 8334 v_1 := v.Args[1] 8335 if v_1.Op != OpConstBool { 8336 break 8337 } 8338 c := v_1.AuxInt 8339 v.reset(OpConstBool) 8340 v.AuxInt = b2i(c == d) 8341 return true 8342 } 8343 // match: (EqB (ConstBool [0]) x) 8344 // cond: 8345 // result: (Not x) 8346 for { 8347 _ = v.Args[1] 8348 v_0 := v.Args[0] 8349 if v_0.Op != OpConstBool { 8350 break 8351 } 8352 if v_0.AuxInt != 0 { 8353 break 8354 } 8355 x := v.Args[1] 8356 v.reset(OpNot) 8357 v.AddArg(x) 8358 return true 8359 } 8360 // match: (EqB x (ConstBool [0])) 8361 // cond: 8362 // result: (Not x) 8363 for { 8364 _ = v.Args[1] 8365 x := v.Args[0] 8366 v_1 := v.Args[1] 8367 if v_1.Op != OpConstBool { 8368 break 8369 } 8370 if v_1.AuxInt != 0 { 8371 break 8372 } 8373 v.reset(OpNot) 8374 v.AddArg(x) 8375 return true 8376 } 8377 // match: (EqB (ConstBool [1]) x) 8378 // cond: 8379 // result: x 8380 for { 8381 _ = v.Args[1] 8382 v_0 := v.Args[0] 8383 if v_0.Op != OpConstBool { 8384 break 8385 } 8386 if v_0.AuxInt != 1 { 8387 break 8388 } 8389 x := v.Args[1] 8390 v.reset(OpCopy) 8391 v.Type = x.Type 8392 v.AddArg(x) 8393 return true 8394 } 8395 // match: (EqB x (ConstBool [1])) 8396 // cond: 8397 // result: x 8398 for { 8399 _ = v.Args[1] 8400 x := v.Args[0] 8401 v_1 := v.Args[1] 8402 if v_1.Op != OpConstBool { 8403 break 8404 } 8405 if v_1.AuxInt != 1 { 8406 break 8407 } 8408 v.reset(OpCopy) 8409 v.Type = x.Type 8410 v.AddArg(x) 8411 return true 8412 } 8413 return false 8414 } 8415 func rewriteValuegeneric_OpEqInter_0(v *Value) bool { 8416 b := v.Block 8417 _ = b 8418 typ := &b.Func.Config.Types 8419 _ = typ 8420 // match: (EqInter x y) 8421 // cond: 8422 // result: (EqPtr (ITab x) (ITab y)) 8423 for { 8424 _ = v.Args[1] 8425 x := v.Args[0] 8426 y := v.Args[1] 8427 v.reset(OpEqPtr) 8428 v0 := b.NewValue0(v.Pos, OpITab, typ.BytePtr) 8429 v0.AddArg(x) 8430 v.AddArg(v0) 8431 v1 := b.NewValue0(v.Pos, OpITab, typ.BytePtr) 8432 v1.AddArg(y) 8433 v.AddArg(v1) 8434 return true 8435 } 8436 } 8437 func rewriteValuegeneric_OpEqPtr_0(v *Value) bool { 8438 b := v.Block 8439 _ = b 8440 typ := &b.Func.Config.Types 8441 _ = typ 8442 // match: (EqPtr p (ConstNil)) 8443 // cond: 8444 // result: (Not (IsNonNil p)) 8445 for { 8446 _ = v.Args[1] 8447 p := v.Args[0] 8448 v_1 := v.Args[1] 8449 if v_1.Op != OpConstNil { 8450 break 8451 } 8452 v.reset(OpNot) 8453 v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool) 8454 v0.AddArg(p) 8455 v.AddArg(v0) 8456 return true 8457 } 8458 // match: (EqPtr (ConstNil) p) 8459 // cond: 8460 // result: (Not (IsNonNil p)) 8461 for { 8462 _ = v.Args[1] 8463 v_0 := v.Args[0] 8464 if v_0.Op != OpConstNil { 8465 break 8466 } 8467 p := v.Args[1] 8468 v.reset(OpNot) 8469 v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool) 8470 v0.AddArg(p) 8471 v.AddArg(v0) 8472 return true 8473 } 8474 // match: (EqPtr x x) 8475 // cond: 8476 // result: (ConstBool [1]) 8477 for { 8478 _ = v.Args[1] 8479 x := v.Args[0] 8480 if x != v.Args[1] { 8481 break 8482 } 8483 v.reset(OpConstBool) 8484 v.AuxInt = 1 8485 return true 8486 } 8487 // match: (EqPtr (Addr {a} x) (Addr {b} x)) 8488 // cond: 8489 // result: (ConstBool [b2i(a == b)]) 8490 for { 8491 _ = v.Args[1] 8492 v_0 := v.Args[0] 8493 if v_0.Op != OpAddr { 8494 break 8495 } 8496 a := v_0.Aux 8497 x := v_0.Args[0] 8498 v_1 := v.Args[1] 8499 if v_1.Op != OpAddr { 8500 break 8501 } 8502 b := v_1.Aux 8503 if x != v_1.Args[0] { 8504 break 8505 } 8506 v.reset(OpConstBool) 8507 v.AuxInt = b2i(a == b) 8508 return true 8509 } 8510 // match: (EqPtr (Addr {b} x) (Addr {a} x)) 8511 // cond: 8512 // result: (ConstBool [b2i(a == b)]) 8513 for { 8514 _ = v.Args[1] 8515 v_0 := v.Args[0] 8516 if v_0.Op != OpAddr { 8517 break 8518 } 8519 b := v_0.Aux 8520 x := v_0.Args[0] 8521 v_1 := v.Args[1] 8522 if v_1.Op != OpAddr { 8523 break 8524 } 8525 a := v_1.Aux 8526 if x != v_1.Args[0] { 8527 break 8528 } 8529 v.reset(OpConstBool) 8530 v.AuxInt = b2i(a == b) 8531 return true 8532 } 8533 return false 8534 } 8535 func rewriteValuegeneric_OpEqSlice_0(v *Value) bool { 8536 b := v.Block 8537 _ = b 8538 typ := &b.Func.Config.Types 8539 _ = typ 8540 // match: (EqSlice x y) 8541 // cond: 8542 // result: (EqPtr (SlicePtr x) (SlicePtr y)) 8543 for { 8544 _ = v.Args[1] 8545 x := v.Args[0] 8546 y := v.Args[1] 8547 v.reset(OpEqPtr) 8548 v0 := b.NewValue0(v.Pos, OpSlicePtr, typ.BytePtr) 8549 v0.AddArg(x) 8550 v.AddArg(v0) 8551 v1 := b.NewValue0(v.Pos, OpSlicePtr, typ.BytePtr) 8552 v1.AddArg(y) 8553 v.AddArg(v1) 8554 return true 8555 } 8556 } 8557 func rewriteValuegeneric_OpGeq16_0(v *Value) bool { 8558 // match: (Geq16 (Const16 [c]) (Const16 [d])) 8559 // cond: 8560 // result: (ConstBool [b2i(c >= d)]) 8561 for { 8562 _ = v.Args[1] 8563 v_0 := v.Args[0] 8564 if v_0.Op != OpConst16 { 8565 break 8566 } 8567 c := v_0.AuxInt 8568 v_1 := v.Args[1] 8569 if v_1.Op != OpConst16 { 8570 break 8571 } 8572 d := v_1.AuxInt 8573 v.reset(OpConstBool) 8574 v.AuxInt = b2i(c >= d) 8575 return true 8576 } 8577 return false 8578 } 8579 func rewriteValuegeneric_OpGeq16U_0(v *Value) bool { 8580 // match: (Geq16U (Const16 [c]) (Const16 [d])) 8581 // cond: 8582 // result: (ConstBool [b2i(uint16(c) >= uint16(d))]) 8583 for { 8584 _ = v.Args[1] 8585 v_0 := v.Args[0] 8586 if v_0.Op != OpConst16 { 8587 break 8588 } 8589 c := v_0.AuxInt 8590 v_1 := v.Args[1] 8591 if v_1.Op != OpConst16 { 8592 break 8593 } 8594 d := v_1.AuxInt 8595 v.reset(OpConstBool) 8596 v.AuxInt = b2i(uint16(c) >= uint16(d)) 8597 return true 8598 } 8599 return false 8600 } 8601 func rewriteValuegeneric_OpGeq32_0(v *Value) bool { 8602 // match: (Geq32 (Const32 [c]) (Const32 [d])) 8603 // cond: 8604 // result: (ConstBool [b2i(c >= d)]) 8605 for { 8606 _ = v.Args[1] 8607 v_0 := v.Args[0] 8608 if v_0.Op != OpConst32 { 8609 break 8610 } 8611 c := v_0.AuxInt 8612 v_1 := v.Args[1] 8613 if v_1.Op != OpConst32 { 8614 break 8615 } 8616 d := v_1.AuxInt 8617 v.reset(OpConstBool) 8618 v.AuxInt = b2i(c >= d) 8619 return true 8620 } 8621 return false 8622 } 8623 func rewriteValuegeneric_OpGeq32U_0(v *Value) bool { 8624 // match: (Geq32U (Const32 [c]) (Const32 [d])) 8625 // cond: 8626 // result: (ConstBool [b2i(uint32(c) >= uint32(d))]) 8627 for { 8628 _ = v.Args[1] 8629 v_0 := v.Args[0] 8630 if v_0.Op != OpConst32 { 8631 break 8632 } 8633 c := v_0.AuxInt 8634 v_1 := v.Args[1] 8635 if v_1.Op != OpConst32 { 8636 break 8637 } 8638 d := v_1.AuxInt 8639 v.reset(OpConstBool) 8640 v.AuxInt = b2i(uint32(c) >= uint32(d)) 8641 return true 8642 } 8643 return false 8644 } 8645 func rewriteValuegeneric_OpGeq64_0(v *Value) bool { 8646 // match: (Geq64 (Const64 [c]) (Const64 [d])) 8647 // cond: 8648 // result: (ConstBool [b2i(c >= d)]) 8649 for { 8650 _ = v.Args[1] 8651 v_0 := v.Args[0] 8652 if v_0.Op != OpConst64 { 8653 break 8654 } 8655 c := v_0.AuxInt 8656 v_1 := v.Args[1] 8657 if v_1.Op != OpConst64 { 8658 break 8659 } 8660 d := v_1.AuxInt 8661 v.reset(OpConstBool) 8662 v.AuxInt = b2i(c >= d) 8663 return true 8664 } 8665 return false 8666 } 8667 func rewriteValuegeneric_OpGeq64U_0(v *Value) bool { 8668 // match: (Geq64U (Const64 [c]) (Const64 [d])) 8669 // cond: 8670 // result: (ConstBool [b2i(uint64(c) >= uint64(d))]) 8671 for { 8672 _ = v.Args[1] 8673 v_0 := v.Args[0] 8674 if v_0.Op != OpConst64 { 8675 break 8676 } 8677 c := v_0.AuxInt 8678 v_1 := v.Args[1] 8679 if v_1.Op != OpConst64 { 8680 break 8681 } 8682 d := v_1.AuxInt 8683 v.reset(OpConstBool) 8684 v.AuxInt = b2i(uint64(c) >= uint64(d)) 8685 return true 8686 } 8687 return false 8688 } 8689 func rewriteValuegeneric_OpGeq8_0(v *Value) bool { 8690 // match: (Geq8 (Const8 [c]) (Const8 [d])) 8691 // cond: 8692 // result: (ConstBool [b2i(c >= d)]) 8693 for { 8694 _ = v.Args[1] 8695 v_0 := v.Args[0] 8696 if v_0.Op != OpConst8 { 8697 break 8698 } 8699 c := v_0.AuxInt 8700 v_1 := v.Args[1] 8701 if v_1.Op != OpConst8 { 8702 break 8703 } 8704 d := v_1.AuxInt 8705 v.reset(OpConstBool) 8706 v.AuxInt = b2i(c >= d) 8707 return true 8708 } 8709 return false 8710 } 8711 func rewriteValuegeneric_OpGeq8U_0(v *Value) bool { 8712 // match: (Geq8U (Const8 [c]) (Const8 [d])) 8713 // cond: 8714 // result: (ConstBool [b2i(uint8(c) >= uint8(d))]) 8715 for { 8716 _ = v.Args[1] 8717 v_0 := v.Args[0] 8718 if v_0.Op != OpConst8 { 8719 break 8720 } 8721 c := v_0.AuxInt 8722 v_1 := v.Args[1] 8723 if v_1.Op != OpConst8 { 8724 break 8725 } 8726 d := v_1.AuxInt 8727 v.reset(OpConstBool) 8728 v.AuxInt = b2i(uint8(c) >= uint8(d)) 8729 return true 8730 } 8731 return false 8732 } 8733 func rewriteValuegeneric_OpGreater16_0(v *Value) bool { 8734 // match: (Greater16 (Const16 [c]) (Const16 [d])) 8735 // cond: 8736 // result: (ConstBool [b2i(c > d)]) 8737 for { 8738 _ = v.Args[1] 8739 v_0 := v.Args[0] 8740 if v_0.Op != OpConst16 { 8741 break 8742 } 8743 c := v_0.AuxInt 8744 v_1 := v.Args[1] 8745 if v_1.Op != OpConst16 { 8746 break 8747 } 8748 d := v_1.AuxInt 8749 v.reset(OpConstBool) 8750 v.AuxInt = b2i(c > d) 8751 return true 8752 } 8753 return false 8754 } 8755 func rewriteValuegeneric_OpGreater16U_0(v *Value) bool { 8756 // match: (Greater16U (Const16 [c]) (Const16 [d])) 8757 // cond: 8758 // result: (ConstBool [b2i(uint16(c) > uint16(d))]) 8759 for { 8760 _ = v.Args[1] 8761 v_0 := v.Args[0] 8762 if v_0.Op != OpConst16 { 8763 break 8764 } 8765 c := v_0.AuxInt 8766 v_1 := v.Args[1] 8767 if v_1.Op != OpConst16 { 8768 break 8769 } 8770 d := v_1.AuxInt 8771 v.reset(OpConstBool) 8772 v.AuxInt = b2i(uint16(c) > uint16(d)) 8773 return true 8774 } 8775 return false 8776 } 8777 func rewriteValuegeneric_OpGreater32_0(v *Value) bool { 8778 // match: (Greater32 (Const32 [c]) (Const32 [d])) 8779 // cond: 8780 // result: (ConstBool [b2i(c > d)]) 8781 for { 8782 _ = v.Args[1] 8783 v_0 := v.Args[0] 8784 if v_0.Op != OpConst32 { 8785 break 8786 } 8787 c := v_0.AuxInt 8788 v_1 := v.Args[1] 8789 if v_1.Op != OpConst32 { 8790 break 8791 } 8792 d := v_1.AuxInt 8793 v.reset(OpConstBool) 8794 v.AuxInt = b2i(c > d) 8795 return true 8796 } 8797 return false 8798 } 8799 func rewriteValuegeneric_OpGreater32U_0(v *Value) bool { 8800 // match: (Greater32U (Const32 [c]) (Const32 [d])) 8801 // cond: 8802 // result: (ConstBool [b2i(uint32(c) > uint32(d))]) 8803 for { 8804 _ = v.Args[1] 8805 v_0 := v.Args[0] 8806 if v_0.Op != OpConst32 { 8807 break 8808 } 8809 c := v_0.AuxInt 8810 v_1 := v.Args[1] 8811 if v_1.Op != OpConst32 { 8812 break 8813 } 8814 d := v_1.AuxInt 8815 v.reset(OpConstBool) 8816 v.AuxInt = b2i(uint32(c) > uint32(d)) 8817 return true 8818 } 8819 return false 8820 } 8821 func rewriteValuegeneric_OpGreater64_0(v *Value) bool { 8822 // match: (Greater64 (Const64 [c]) (Const64 [d])) 8823 // cond: 8824 // result: (ConstBool [b2i(c > d)]) 8825 for { 8826 _ = v.Args[1] 8827 v_0 := v.Args[0] 8828 if v_0.Op != OpConst64 { 8829 break 8830 } 8831 c := v_0.AuxInt 8832 v_1 := v.Args[1] 8833 if v_1.Op != OpConst64 { 8834 break 8835 } 8836 d := v_1.AuxInt 8837 v.reset(OpConstBool) 8838 v.AuxInt = b2i(c > d) 8839 return true 8840 } 8841 return false 8842 } 8843 func rewriteValuegeneric_OpGreater64U_0(v *Value) bool { 8844 // match: (Greater64U (Const64 [c]) (Const64 [d])) 8845 // cond: 8846 // result: (ConstBool [b2i(uint64(c) > uint64(d))]) 8847 for { 8848 _ = v.Args[1] 8849 v_0 := v.Args[0] 8850 if v_0.Op != OpConst64 { 8851 break 8852 } 8853 c := v_0.AuxInt 8854 v_1 := v.Args[1] 8855 if v_1.Op != OpConst64 { 8856 break 8857 } 8858 d := v_1.AuxInt 8859 v.reset(OpConstBool) 8860 v.AuxInt = b2i(uint64(c) > uint64(d)) 8861 return true 8862 } 8863 return false 8864 } 8865 func rewriteValuegeneric_OpGreater8_0(v *Value) bool { 8866 // match: (Greater8 (Const8 [c]) (Const8 [d])) 8867 // cond: 8868 // result: (ConstBool [b2i(c > d)]) 8869 for { 8870 _ = v.Args[1] 8871 v_0 := v.Args[0] 8872 if v_0.Op != OpConst8 { 8873 break 8874 } 8875 c := v_0.AuxInt 8876 v_1 := v.Args[1] 8877 if v_1.Op != OpConst8 { 8878 break 8879 } 8880 d := v_1.AuxInt 8881 v.reset(OpConstBool) 8882 v.AuxInt = b2i(c > d) 8883 return true 8884 } 8885 return false 8886 } 8887 func rewriteValuegeneric_OpGreater8U_0(v *Value) bool { 8888 // match: (Greater8U (Const8 [c]) (Const8 [d])) 8889 // cond: 8890 // result: (ConstBool [b2i(uint8(c) > uint8(d))]) 8891 for { 8892 _ = v.Args[1] 8893 v_0 := v.Args[0] 8894 if v_0.Op != OpConst8 { 8895 break 8896 } 8897 c := v_0.AuxInt 8898 v_1 := v.Args[1] 8899 if v_1.Op != OpConst8 { 8900 break 8901 } 8902 d := v_1.AuxInt 8903 v.reset(OpConstBool) 8904 v.AuxInt = b2i(uint8(c) > uint8(d)) 8905 return true 8906 } 8907 return false 8908 } 8909 func rewriteValuegeneric_OpIMake_0(v *Value) bool { 8910 // match: (IMake typ (StructMake1 val)) 8911 // cond: 8912 // result: (IMake typ val) 8913 for { 8914 _ = v.Args[1] 8915 typ := v.Args[0] 8916 v_1 := v.Args[1] 8917 if v_1.Op != OpStructMake1 { 8918 break 8919 } 8920 val := v_1.Args[0] 8921 v.reset(OpIMake) 8922 v.AddArg(typ) 8923 v.AddArg(val) 8924 return true 8925 } 8926 // match: (IMake typ (ArrayMake1 val)) 8927 // cond: 8928 // result: (IMake typ val) 8929 for { 8930 _ = v.Args[1] 8931 typ := v.Args[0] 8932 v_1 := v.Args[1] 8933 if v_1.Op != OpArrayMake1 { 8934 break 8935 } 8936 val := v_1.Args[0] 8937 v.reset(OpIMake) 8938 v.AddArg(typ) 8939 v.AddArg(val) 8940 return true 8941 } 8942 return false 8943 } 8944 func rewriteValuegeneric_OpInterCall_0(v *Value) bool { 8945 // match: (InterCall [argsize] (Load (OffPtr [off] (ITab (IMake (Addr {itab} (SB)) _))) _) mem) 8946 // cond: devirt(v, itab, off) != nil 8947 // result: (StaticCall [argsize] {devirt(v, itab, off)} mem) 8948 for { 8949 argsize := v.AuxInt 8950 _ = v.Args[1] 8951 v_0 := v.Args[0] 8952 if v_0.Op != OpLoad { 8953 break 8954 } 8955 _ = v_0.Args[1] 8956 v_0_0 := v_0.Args[0] 8957 if v_0_0.Op != OpOffPtr { 8958 break 8959 } 8960 off := v_0_0.AuxInt 8961 v_0_0_0 := v_0_0.Args[0] 8962 if v_0_0_0.Op != OpITab { 8963 break 8964 } 8965 v_0_0_0_0 := v_0_0_0.Args[0] 8966 if v_0_0_0_0.Op != OpIMake { 8967 break 8968 } 8969 _ = v_0_0_0_0.Args[1] 8970 v_0_0_0_0_0 := v_0_0_0_0.Args[0] 8971 if v_0_0_0_0_0.Op != OpAddr { 8972 break 8973 } 8974 itab := v_0_0_0_0_0.Aux 8975 v_0_0_0_0_0_0 := v_0_0_0_0_0.Args[0] 8976 if v_0_0_0_0_0_0.Op != OpSB { 8977 break 8978 } 8979 mem := v.Args[1] 8980 if !(devirt(v, itab, off) != nil) { 8981 break 8982 } 8983 v.reset(OpStaticCall) 8984 v.AuxInt = argsize 8985 v.Aux = devirt(v, itab, off) 8986 v.AddArg(mem) 8987 return true 8988 } 8989 return false 8990 } 8991 func rewriteValuegeneric_OpIsInBounds_0(v *Value) bool { 8992 // match: (IsInBounds (ZeroExt8to32 _) (Const32 [c])) 8993 // cond: (1 << 8) <= c 8994 // result: (ConstBool [1]) 8995 for { 8996 _ = v.Args[1] 8997 v_0 := v.Args[0] 8998 if v_0.Op != OpZeroExt8to32 { 8999 break 9000 } 9001 v_1 := v.Args[1] 9002 if v_1.Op != OpConst32 { 9003 break 9004 } 9005 c := v_1.AuxInt 9006 if !((1 << 8) <= c) { 9007 break 9008 } 9009 v.reset(OpConstBool) 9010 v.AuxInt = 1 9011 return true 9012 } 9013 // match: (IsInBounds (ZeroExt8to64 _) (Const64 [c])) 9014 // cond: (1 << 8) <= c 9015 // result: (ConstBool [1]) 9016 for { 9017 _ = v.Args[1] 9018 v_0 := v.Args[0] 9019 if v_0.Op != OpZeroExt8to64 { 9020 break 9021 } 9022 v_1 := v.Args[1] 9023 if v_1.Op != OpConst64 { 9024 break 9025 } 9026 c := v_1.AuxInt 9027 if !((1 << 8) <= c) { 9028 break 9029 } 9030 v.reset(OpConstBool) 9031 v.AuxInt = 1 9032 return true 9033 } 9034 // match: (IsInBounds (ZeroExt16to32 _) (Const32 [c])) 9035 // cond: (1 << 16) <= c 9036 // result: (ConstBool [1]) 9037 for { 9038 _ = v.Args[1] 9039 v_0 := v.Args[0] 9040 if v_0.Op != OpZeroExt16to32 { 9041 break 9042 } 9043 v_1 := v.Args[1] 9044 if v_1.Op != OpConst32 { 9045 break 9046 } 9047 c := v_1.AuxInt 9048 if !((1 << 16) <= c) { 9049 break 9050 } 9051 v.reset(OpConstBool) 9052 v.AuxInt = 1 9053 return true 9054 } 9055 // match: (IsInBounds (ZeroExt16to64 _) (Const64 [c])) 9056 // cond: (1 << 16) <= c 9057 // result: (ConstBool [1]) 9058 for { 9059 _ = v.Args[1] 9060 v_0 := v.Args[0] 9061 if v_0.Op != OpZeroExt16to64 { 9062 break 9063 } 9064 v_1 := v.Args[1] 9065 if v_1.Op != OpConst64 { 9066 break 9067 } 9068 c := v_1.AuxInt 9069 if !((1 << 16) <= c) { 9070 break 9071 } 9072 v.reset(OpConstBool) 9073 v.AuxInt = 1 9074 return true 9075 } 9076 // match: (IsInBounds x x) 9077 // cond: 9078 // result: (ConstBool [0]) 9079 for { 9080 _ = v.Args[1] 9081 x := v.Args[0] 9082 if x != v.Args[1] { 9083 break 9084 } 9085 v.reset(OpConstBool) 9086 v.AuxInt = 0 9087 return true 9088 } 9089 // match: (IsInBounds (And8 (Const8 [c]) _) (Const8 [d])) 9090 // cond: 0 <= c && c < d 9091 // result: (ConstBool [1]) 9092 for { 9093 _ = v.Args[1] 9094 v_0 := v.Args[0] 9095 if v_0.Op != OpAnd8 { 9096 break 9097 } 9098 _ = v_0.Args[1] 9099 v_0_0 := v_0.Args[0] 9100 if v_0_0.Op != OpConst8 { 9101 break 9102 } 9103 c := v_0_0.AuxInt 9104 v_1 := v.Args[1] 9105 if v_1.Op != OpConst8 { 9106 break 9107 } 9108 d := v_1.AuxInt 9109 if !(0 <= c && c < d) { 9110 break 9111 } 9112 v.reset(OpConstBool) 9113 v.AuxInt = 1 9114 return true 9115 } 9116 // match: (IsInBounds (And8 _ (Const8 [c])) (Const8 [d])) 9117 // cond: 0 <= c && c < d 9118 // result: (ConstBool [1]) 9119 for { 9120 _ = v.Args[1] 9121 v_0 := v.Args[0] 9122 if v_0.Op != OpAnd8 { 9123 break 9124 } 9125 _ = v_0.Args[1] 9126 v_0_1 := v_0.Args[1] 9127 if v_0_1.Op != OpConst8 { 9128 break 9129 } 9130 c := v_0_1.AuxInt 9131 v_1 := v.Args[1] 9132 if v_1.Op != OpConst8 { 9133 break 9134 } 9135 d := v_1.AuxInt 9136 if !(0 <= c && c < d) { 9137 break 9138 } 9139 v.reset(OpConstBool) 9140 v.AuxInt = 1 9141 return true 9142 } 9143 // match: (IsInBounds (ZeroExt8to16 (And8 (Const8 [c]) _)) (Const16 [d])) 9144 // cond: 0 <= c && c < d 9145 // result: (ConstBool [1]) 9146 for { 9147 _ = v.Args[1] 9148 v_0 := v.Args[0] 9149 if v_0.Op != OpZeroExt8to16 { 9150 break 9151 } 9152 v_0_0 := v_0.Args[0] 9153 if v_0_0.Op != OpAnd8 { 9154 break 9155 } 9156 _ = v_0_0.Args[1] 9157 v_0_0_0 := v_0_0.Args[0] 9158 if v_0_0_0.Op != OpConst8 { 9159 break 9160 } 9161 c := v_0_0_0.AuxInt 9162 v_1 := v.Args[1] 9163 if v_1.Op != OpConst16 { 9164 break 9165 } 9166 d := v_1.AuxInt 9167 if !(0 <= c && c < d) { 9168 break 9169 } 9170 v.reset(OpConstBool) 9171 v.AuxInt = 1 9172 return true 9173 } 9174 // match: (IsInBounds (ZeroExt8to16 (And8 _ (Const8 [c]))) (Const16 [d])) 9175 // cond: 0 <= c && c < d 9176 // result: (ConstBool [1]) 9177 for { 9178 _ = v.Args[1] 9179 v_0 := v.Args[0] 9180 if v_0.Op != OpZeroExt8to16 { 9181 break 9182 } 9183 v_0_0 := v_0.Args[0] 9184 if v_0_0.Op != OpAnd8 { 9185 break 9186 } 9187 _ = v_0_0.Args[1] 9188 v_0_0_1 := v_0_0.Args[1] 9189 if v_0_0_1.Op != OpConst8 { 9190 break 9191 } 9192 c := v_0_0_1.AuxInt 9193 v_1 := v.Args[1] 9194 if v_1.Op != OpConst16 { 9195 break 9196 } 9197 d := v_1.AuxInt 9198 if !(0 <= c && c < d) { 9199 break 9200 } 9201 v.reset(OpConstBool) 9202 v.AuxInt = 1 9203 return true 9204 } 9205 // match: (IsInBounds (ZeroExt8to32 (And8 (Const8 [c]) _)) (Const32 [d])) 9206 // cond: 0 <= c && c < d 9207 // result: (ConstBool [1]) 9208 for { 9209 _ = v.Args[1] 9210 v_0 := v.Args[0] 9211 if v_0.Op != OpZeroExt8to32 { 9212 break 9213 } 9214 v_0_0 := v_0.Args[0] 9215 if v_0_0.Op != OpAnd8 { 9216 break 9217 } 9218 _ = v_0_0.Args[1] 9219 v_0_0_0 := v_0_0.Args[0] 9220 if v_0_0_0.Op != OpConst8 { 9221 break 9222 } 9223 c := v_0_0_0.AuxInt 9224 v_1 := v.Args[1] 9225 if v_1.Op != OpConst32 { 9226 break 9227 } 9228 d := v_1.AuxInt 9229 if !(0 <= c && c < d) { 9230 break 9231 } 9232 v.reset(OpConstBool) 9233 v.AuxInt = 1 9234 return true 9235 } 9236 return false 9237 } 9238 func rewriteValuegeneric_OpIsInBounds_10(v *Value) bool { 9239 // match: (IsInBounds (ZeroExt8to32 (And8 _ (Const8 [c]))) (Const32 [d])) 9240 // cond: 0 <= c && c < d 9241 // result: (ConstBool [1]) 9242 for { 9243 _ = v.Args[1] 9244 v_0 := v.Args[0] 9245 if v_0.Op != OpZeroExt8to32 { 9246 break 9247 } 9248 v_0_0 := v_0.Args[0] 9249 if v_0_0.Op != OpAnd8 { 9250 break 9251 } 9252 _ = v_0_0.Args[1] 9253 v_0_0_1 := v_0_0.Args[1] 9254 if v_0_0_1.Op != OpConst8 { 9255 break 9256 } 9257 c := v_0_0_1.AuxInt 9258 v_1 := v.Args[1] 9259 if v_1.Op != OpConst32 { 9260 break 9261 } 9262 d := v_1.AuxInt 9263 if !(0 <= c && c < d) { 9264 break 9265 } 9266 v.reset(OpConstBool) 9267 v.AuxInt = 1 9268 return true 9269 } 9270 // match: (IsInBounds (ZeroExt8to64 (And8 (Const8 [c]) _)) (Const64 [d])) 9271 // cond: 0 <= c && c < d 9272 // result: (ConstBool [1]) 9273 for { 9274 _ = v.Args[1] 9275 v_0 := v.Args[0] 9276 if v_0.Op != OpZeroExt8to64 { 9277 break 9278 } 9279 v_0_0 := v_0.Args[0] 9280 if v_0_0.Op != OpAnd8 { 9281 break 9282 } 9283 _ = v_0_0.Args[1] 9284 v_0_0_0 := v_0_0.Args[0] 9285 if v_0_0_0.Op != OpConst8 { 9286 break 9287 } 9288 c := v_0_0_0.AuxInt 9289 v_1 := v.Args[1] 9290 if v_1.Op != OpConst64 { 9291 break 9292 } 9293 d := v_1.AuxInt 9294 if !(0 <= c && c < d) { 9295 break 9296 } 9297 v.reset(OpConstBool) 9298 v.AuxInt = 1 9299 return true 9300 } 9301 // match: (IsInBounds (ZeroExt8to64 (And8 _ (Const8 [c]))) (Const64 [d])) 9302 // cond: 0 <= c && c < d 9303 // result: (ConstBool [1]) 9304 for { 9305 _ = v.Args[1] 9306 v_0 := v.Args[0] 9307 if v_0.Op != OpZeroExt8to64 { 9308 break 9309 } 9310 v_0_0 := v_0.Args[0] 9311 if v_0_0.Op != OpAnd8 { 9312 break 9313 } 9314 _ = v_0_0.Args[1] 9315 v_0_0_1 := v_0_0.Args[1] 9316 if v_0_0_1.Op != OpConst8 { 9317 break 9318 } 9319 c := v_0_0_1.AuxInt 9320 v_1 := v.Args[1] 9321 if v_1.Op != OpConst64 { 9322 break 9323 } 9324 d := v_1.AuxInt 9325 if !(0 <= c && c < d) { 9326 break 9327 } 9328 v.reset(OpConstBool) 9329 v.AuxInt = 1 9330 return true 9331 } 9332 // match: (IsInBounds (And16 (Const16 [c]) _) (Const16 [d])) 9333 // cond: 0 <= c && c < d 9334 // result: (ConstBool [1]) 9335 for { 9336 _ = v.Args[1] 9337 v_0 := v.Args[0] 9338 if v_0.Op != OpAnd16 { 9339 break 9340 } 9341 _ = v_0.Args[1] 9342 v_0_0 := v_0.Args[0] 9343 if v_0_0.Op != OpConst16 { 9344 break 9345 } 9346 c := v_0_0.AuxInt 9347 v_1 := v.Args[1] 9348 if v_1.Op != OpConst16 { 9349 break 9350 } 9351 d := v_1.AuxInt 9352 if !(0 <= c && c < d) { 9353 break 9354 } 9355 v.reset(OpConstBool) 9356 v.AuxInt = 1 9357 return true 9358 } 9359 // match: (IsInBounds (And16 _ (Const16 [c])) (Const16 [d])) 9360 // cond: 0 <= c && c < d 9361 // result: (ConstBool [1]) 9362 for { 9363 _ = v.Args[1] 9364 v_0 := v.Args[0] 9365 if v_0.Op != OpAnd16 { 9366 break 9367 } 9368 _ = v_0.Args[1] 9369 v_0_1 := v_0.Args[1] 9370 if v_0_1.Op != OpConst16 { 9371 break 9372 } 9373 c := v_0_1.AuxInt 9374 v_1 := v.Args[1] 9375 if v_1.Op != OpConst16 { 9376 break 9377 } 9378 d := v_1.AuxInt 9379 if !(0 <= c && c < d) { 9380 break 9381 } 9382 v.reset(OpConstBool) 9383 v.AuxInt = 1 9384 return true 9385 } 9386 // match: (IsInBounds (ZeroExt16to32 (And16 (Const16 [c]) _)) (Const32 [d])) 9387 // cond: 0 <= c && c < d 9388 // result: (ConstBool [1]) 9389 for { 9390 _ = v.Args[1] 9391 v_0 := v.Args[0] 9392 if v_0.Op != OpZeroExt16to32 { 9393 break 9394 } 9395 v_0_0 := v_0.Args[0] 9396 if v_0_0.Op != OpAnd16 { 9397 break 9398 } 9399 _ = v_0_0.Args[1] 9400 v_0_0_0 := v_0_0.Args[0] 9401 if v_0_0_0.Op != OpConst16 { 9402 break 9403 } 9404 c := v_0_0_0.AuxInt 9405 v_1 := v.Args[1] 9406 if v_1.Op != OpConst32 { 9407 break 9408 } 9409 d := v_1.AuxInt 9410 if !(0 <= c && c < d) { 9411 break 9412 } 9413 v.reset(OpConstBool) 9414 v.AuxInt = 1 9415 return true 9416 } 9417 // match: (IsInBounds (ZeroExt16to32 (And16 _ (Const16 [c]))) (Const32 [d])) 9418 // cond: 0 <= c && c < d 9419 // result: (ConstBool [1]) 9420 for { 9421 _ = v.Args[1] 9422 v_0 := v.Args[0] 9423 if v_0.Op != OpZeroExt16to32 { 9424 break 9425 } 9426 v_0_0 := v_0.Args[0] 9427 if v_0_0.Op != OpAnd16 { 9428 break 9429 } 9430 _ = v_0_0.Args[1] 9431 v_0_0_1 := v_0_0.Args[1] 9432 if v_0_0_1.Op != OpConst16 { 9433 break 9434 } 9435 c := v_0_0_1.AuxInt 9436 v_1 := v.Args[1] 9437 if v_1.Op != OpConst32 { 9438 break 9439 } 9440 d := v_1.AuxInt 9441 if !(0 <= c && c < d) { 9442 break 9443 } 9444 v.reset(OpConstBool) 9445 v.AuxInt = 1 9446 return true 9447 } 9448 // match: (IsInBounds (ZeroExt16to64 (And16 (Const16 [c]) _)) (Const64 [d])) 9449 // cond: 0 <= c && c < d 9450 // result: (ConstBool [1]) 9451 for { 9452 _ = v.Args[1] 9453 v_0 := v.Args[0] 9454 if v_0.Op != OpZeroExt16to64 { 9455 break 9456 } 9457 v_0_0 := v_0.Args[0] 9458 if v_0_0.Op != OpAnd16 { 9459 break 9460 } 9461 _ = v_0_0.Args[1] 9462 v_0_0_0 := v_0_0.Args[0] 9463 if v_0_0_0.Op != OpConst16 { 9464 break 9465 } 9466 c := v_0_0_0.AuxInt 9467 v_1 := v.Args[1] 9468 if v_1.Op != OpConst64 { 9469 break 9470 } 9471 d := v_1.AuxInt 9472 if !(0 <= c && c < d) { 9473 break 9474 } 9475 v.reset(OpConstBool) 9476 v.AuxInt = 1 9477 return true 9478 } 9479 // match: (IsInBounds (ZeroExt16to64 (And16 _ (Const16 [c]))) (Const64 [d])) 9480 // cond: 0 <= c && c < d 9481 // result: (ConstBool [1]) 9482 for { 9483 _ = v.Args[1] 9484 v_0 := v.Args[0] 9485 if v_0.Op != OpZeroExt16to64 { 9486 break 9487 } 9488 v_0_0 := v_0.Args[0] 9489 if v_0_0.Op != OpAnd16 { 9490 break 9491 } 9492 _ = v_0_0.Args[1] 9493 v_0_0_1 := v_0_0.Args[1] 9494 if v_0_0_1.Op != OpConst16 { 9495 break 9496 } 9497 c := v_0_0_1.AuxInt 9498 v_1 := v.Args[1] 9499 if v_1.Op != OpConst64 { 9500 break 9501 } 9502 d := v_1.AuxInt 9503 if !(0 <= c && c < d) { 9504 break 9505 } 9506 v.reset(OpConstBool) 9507 v.AuxInt = 1 9508 return true 9509 } 9510 // match: (IsInBounds (And32 (Const32 [c]) _) (Const32 [d])) 9511 // cond: 0 <= c && c < d 9512 // result: (ConstBool [1]) 9513 for { 9514 _ = v.Args[1] 9515 v_0 := v.Args[0] 9516 if v_0.Op != OpAnd32 { 9517 break 9518 } 9519 _ = v_0.Args[1] 9520 v_0_0 := v_0.Args[0] 9521 if v_0_0.Op != OpConst32 { 9522 break 9523 } 9524 c := v_0_0.AuxInt 9525 v_1 := v.Args[1] 9526 if v_1.Op != OpConst32 { 9527 break 9528 } 9529 d := v_1.AuxInt 9530 if !(0 <= c && c < d) { 9531 break 9532 } 9533 v.reset(OpConstBool) 9534 v.AuxInt = 1 9535 return true 9536 } 9537 return false 9538 } 9539 func rewriteValuegeneric_OpIsInBounds_20(v *Value) bool { 9540 // match: (IsInBounds (And32 _ (Const32 [c])) (Const32 [d])) 9541 // cond: 0 <= c && c < d 9542 // result: (ConstBool [1]) 9543 for { 9544 _ = v.Args[1] 9545 v_0 := v.Args[0] 9546 if v_0.Op != OpAnd32 { 9547 break 9548 } 9549 _ = v_0.Args[1] 9550 v_0_1 := v_0.Args[1] 9551 if v_0_1.Op != OpConst32 { 9552 break 9553 } 9554 c := v_0_1.AuxInt 9555 v_1 := v.Args[1] 9556 if v_1.Op != OpConst32 { 9557 break 9558 } 9559 d := v_1.AuxInt 9560 if !(0 <= c && c < d) { 9561 break 9562 } 9563 v.reset(OpConstBool) 9564 v.AuxInt = 1 9565 return true 9566 } 9567 // match: (IsInBounds (ZeroExt32to64 (And32 (Const32 [c]) _)) (Const64 [d])) 9568 // cond: 0 <= c && c < d 9569 // result: (ConstBool [1]) 9570 for { 9571 _ = v.Args[1] 9572 v_0 := v.Args[0] 9573 if v_0.Op != OpZeroExt32to64 { 9574 break 9575 } 9576 v_0_0 := v_0.Args[0] 9577 if v_0_0.Op != OpAnd32 { 9578 break 9579 } 9580 _ = v_0_0.Args[1] 9581 v_0_0_0 := v_0_0.Args[0] 9582 if v_0_0_0.Op != OpConst32 { 9583 break 9584 } 9585 c := v_0_0_0.AuxInt 9586 v_1 := v.Args[1] 9587 if v_1.Op != OpConst64 { 9588 break 9589 } 9590 d := v_1.AuxInt 9591 if !(0 <= c && c < d) { 9592 break 9593 } 9594 v.reset(OpConstBool) 9595 v.AuxInt = 1 9596 return true 9597 } 9598 // match: (IsInBounds (ZeroExt32to64 (And32 _ (Const32 [c]))) (Const64 [d])) 9599 // cond: 0 <= c && c < d 9600 // result: (ConstBool [1]) 9601 for { 9602 _ = v.Args[1] 9603 v_0 := v.Args[0] 9604 if v_0.Op != OpZeroExt32to64 { 9605 break 9606 } 9607 v_0_0 := v_0.Args[0] 9608 if v_0_0.Op != OpAnd32 { 9609 break 9610 } 9611 _ = v_0_0.Args[1] 9612 v_0_0_1 := v_0_0.Args[1] 9613 if v_0_0_1.Op != OpConst32 { 9614 break 9615 } 9616 c := v_0_0_1.AuxInt 9617 v_1 := v.Args[1] 9618 if v_1.Op != OpConst64 { 9619 break 9620 } 9621 d := v_1.AuxInt 9622 if !(0 <= c && c < d) { 9623 break 9624 } 9625 v.reset(OpConstBool) 9626 v.AuxInt = 1 9627 return true 9628 } 9629 // match: (IsInBounds (And64 (Const64 [c]) _) (Const64 [d])) 9630 // cond: 0 <= c && c < d 9631 // result: (ConstBool [1]) 9632 for { 9633 _ = v.Args[1] 9634 v_0 := v.Args[0] 9635 if v_0.Op != OpAnd64 { 9636 break 9637 } 9638 _ = v_0.Args[1] 9639 v_0_0 := v_0.Args[0] 9640 if v_0_0.Op != OpConst64 { 9641 break 9642 } 9643 c := v_0_0.AuxInt 9644 v_1 := v.Args[1] 9645 if v_1.Op != OpConst64 { 9646 break 9647 } 9648 d := v_1.AuxInt 9649 if !(0 <= c && c < d) { 9650 break 9651 } 9652 v.reset(OpConstBool) 9653 v.AuxInt = 1 9654 return true 9655 } 9656 // match: (IsInBounds (And64 _ (Const64 [c])) (Const64 [d])) 9657 // cond: 0 <= c && c < d 9658 // result: (ConstBool [1]) 9659 for { 9660 _ = v.Args[1] 9661 v_0 := v.Args[0] 9662 if v_0.Op != OpAnd64 { 9663 break 9664 } 9665 _ = v_0.Args[1] 9666 v_0_1 := v_0.Args[1] 9667 if v_0_1.Op != OpConst64 { 9668 break 9669 } 9670 c := v_0_1.AuxInt 9671 v_1 := v.Args[1] 9672 if v_1.Op != OpConst64 { 9673 break 9674 } 9675 d := v_1.AuxInt 9676 if !(0 <= c && c < d) { 9677 break 9678 } 9679 v.reset(OpConstBool) 9680 v.AuxInt = 1 9681 return true 9682 } 9683 // match: (IsInBounds (Const32 [c]) (Const32 [d])) 9684 // cond: 9685 // result: (ConstBool [b2i(0 <= c && c < d)]) 9686 for { 9687 _ = v.Args[1] 9688 v_0 := v.Args[0] 9689 if v_0.Op != OpConst32 { 9690 break 9691 } 9692 c := v_0.AuxInt 9693 v_1 := v.Args[1] 9694 if v_1.Op != OpConst32 { 9695 break 9696 } 9697 d := v_1.AuxInt 9698 v.reset(OpConstBool) 9699 v.AuxInt = b2i(0 <= c && c < d) 9700 return true 9701 } 9702 // match: (IsInBounds (Const64 [c]) (Const64 [d])) 9703 // cond: 9704 // result: (ConstBool [b2i(0 <= c && c < d)]) 9705 for { 9706 _ = v.Args[1] 9707 v_0 := v.Args[0] 9708 if v_0.Op != OpConst64 { 9709 break 9710 } 9711 c := v_0.AuxInt 9712 v_1 := v.Args[1] 9713 if v_1.Op != OpConst64 { 9714 break 9715 } 9716 d := v_1.AuxInt 9717 v.reset(OpConstBool) 9718 v.AuxInt = b2i(0 <= c && c < d) 9719 return true 9720 } 9721 // match: (IsInBounds (Mod32u _ y) y) 9722 // cond: 9723 // result: (ConstBool [1]) 9724 for { 9725 _ = v.Args[1] 9726 v_0 := v.Args[0] 9727 if v_0.Op != OpMod32u { 9728 break 9729 } 9730 _ = v_0.Args[1] 9731 y := v_0.Args[1] 9732 if y != v.Args[1] { 9733 break 9734 } 9735 v.reset(OpConstBool) 9736 v.AuxInt = 1 9737 return true 9738 } 9739 // match: (IsInBounds (Mod64u _ y) y) 9740 // cond: 9741 // result: (ConstBool [1]) 9742 for { 9743 _ = v.Args[1] 9744 v_0 := v.Args[0] 9745 if v_0.Op != OpMod64u { 9746 break 9747 } 9748 _ = v_0.Args[1] 9749 y := v_0.Args[1] 9750 if y != v.Args[1] { 9751 break 9752 } 9753 v.reset(OpConstBool) 9754 v.AuxInt = 1 9755 return true 9756 } 9757 // match: (IsInBounds (ZeroExt8to64 (Rsh8Ux64 _ (Const64 [c]))) (Const64 [d])) 9758 // cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d 9759 // result: (ConstBool [1]) 9760 for { 9761 _ = v.Args[1] 9762 v_0 := v.Args[0] 9763 if v_0.Op != OpZeroExt8to64 { 9764 break 9765 } 9766 v_0_0 := v_0.Args[0] 9767 if v_0_0.Op != OpRsh8Ux64 { 9768 break 9769 } 9770 _ = v_0_0.Args[1] 9771 v_0_0_1 := v_0_0.Args[1] 9772 if v_0_0_1.Op != OpConst64 { 9773 break 9774 } 9775 c := v_0_0_1.AuxInt 9776 v_1 := v.Args[1] 9777 if v_1.Op != OpConst64 { 9778 break 9779 } 9780 d := v_1.AuxInt 9781 if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) { 9782 break 9783 } 9784 v.reset(OpConstBool) 9785 v.AuxInt = 1 9786 return true 9787 } 9788 return false 9789 } 9790 func rewriteValuegeneric_OpIsInBounds_30(v *Value) bool { 9791 // match: (IsInBounds (ZeroExt8to32 (Rsh8Ux64 _ (Const64 [c]))) (Const32 [d])) 9792 // cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d 9793 // result: (ConstBool [1]) 9794 for { 9795 _ = v.Args[1] 9796 v_0 := v.Args[0] 9797 if v_0.Op != OpZeroExt8to32 { 9798 break 9799 } 9800 v_0_0 := v_0.Args[0] 9801 if v_0_0.Op != OpRsh8Ux64 { 9802 break 9803 } 9804 _ = v_0_0.Args[1] 9805 v_0_0_1 := v_0_0.Args[1] 9806 if v_0_0_1.Op != OpConst64 { 9807 break 9808 } 9809 c := v_0_0_1.AuxInt 9810 v_1 := v.Args[1] 9811 if v_1.Op != OpConst32 { 9812 break 9813 } 9814 d := v_1.AuxInt 9815 if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) { 9816 break 9817 } 9818 v.reset(OpConstBool) 9819 v.AuxInt = 1 9820 return true 9821 } 9822 // match: (IsInBounds (ZeroExt8to16 (Rsh8Ux64 _ (Const64 [c]))) (Const16 [d])) 9823 // cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d 9824 // result: (ConstBool [1]) 9825 for { 9826 _ = v.Args[1] 9827 v_0 := v.Args[0] 9828 if v_0.Op != OpZeroExt8to16 { 9829 break 9830 } 9831 v_0_0 := v_0.Args[0] 9832 if v_0_0.Op != OpRsh8Ux64 { 9833 break 9834 } 9835 _ = v_0_0.Args[1] 9836 v_0_0_1 := v_0_0.Args[1] 9837 if v_0_0_1.Op != OpConst64 { 9838 break 9839 } 9840 c := v_0_0_1.AuxInt 9841 v_1 := v.Args[1] 9842 if v_1.Op != OpConst16 { 9843 break 9844 } 9845 d := v_1.AuxInt 9846 if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) { 9847 break 9848 } 9849 v.reset(OpConstBool) 9850 v.AuxInt = 1 9851 return true 9852 } 9853 // match: (IsInBounds (Rsh8Ux64 _ (Const64 [c])) (Const64 [d])) 9854 // cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d 9855 // result: (ConstBool [1]) 9856 for { 9857 _ = v.Args[1] 9858 v_0 := v.Args[0] 9859 if v_0.Op != OpRsh8Ux64 { 9860 break 9861 } 9862 _ = v_0.Args[1] 9863 v_0_1 := v_0.Args[1] 9864 if v_0_1.Op != OpConst64 { 9865 break 9866 } 9867 c := v_0_1.AuxInt 9868 v_1 := v.Args[1] 9869 if v_1.Op != OpConst64 { 9870 break 9871 } 9872 d := v_1.AuxInt 9873 if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) { 9874 break 9875 } 9876 v.reset(OpConstBool) 9877 v.AuxInt = 1 9878 return true 9879 } 9880 // match: (IsInBounds (ZeroExt16to64 (Rsh16Ux64 _ (Const64 [c]))) (Const64 [d])) 9881 // cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d 9882 // result: (ConstBool [1]) 9883 for { 9884 _ = v.Args[1] 9885 v_0 := v.Args[0] 9886 if v_0.Op != OpZeroExt16to64 { 9887 break 9888 } 9889 v_0_0 := v_0.Args[0] 9890 if v_0_0.Op != OpRsh16Ux64 { 9891 break 9892 } 9893 _ = v_0_0.Args[1] 9894 v_0_0_1 := v_0_0.Args[1] 9895 if v_0_0_1.Op != OpConst64 { 9896 break 9897 } 9898 c := v_0_0_1.AuxInt 9899 v_1 := v.Args[1] 9900 if v_1.Op != OpConst64 { 9901 break 9902 } 9903 d := v_1.AuxInt 9904 if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) { 9905 break 9906 } 9907 v.reset(OpConstBool) 9908 v.AuxInt = 1 9909 return true 9910 } 9911 // match: (IsInBounds (ZeroExt16to32 (Rsh16Ux64 _ (Const64 [c]))) (Const64 [d])) 9912 // cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d 9913 // result: (ConstBool [1]) 9914 for { 9915 _ = v.Args[1] 9916 v_0 := v.Args[0] 9917 if v_0.Op != OpZeroExt16to32 { 9918 break 9919 } 9920 v_0_0 := v_0.Args[0] 9921 if v_0_0.Op != OpRsh16Ux64 { 9922 break 9923 } 9924 _ = v_0_0.Args[1] 9925 v_0_0_1 := v_0_0.Args[1] 9926 if v_0_0_1.Op != OpConst64 { 9927 break 9928 } 9929 c := v_0_0_1.AuxInt 9930 v_1 := v.Args[1] 9931 if v_1.Op != OpConst64 { 9932 break 9933 } 9934 d := v_1.AuxInt 9935 if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) { 9936 break 9937 } 9938 v.reset(OpConstBool) 9939 v.AuxInt = 1 9940 return true 9941 } 9942 // match: (IsInBounds (Rsh16Ux64 _ (Const64 [c])) (Const64 [d])) 9943 // cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d 9944 // result: (ConstBool [1]) 9945 for { 9946 _ = v.Args[1] 9947 v_0 := v.Args[0] 9948 if v_0.Op != OpRsh16Ux64 { 9949 break 9950 } 9951 _ = v_0.Args[1] 9952 v_0_1 := v_0.Args[1] 9953 if v_0_1.Op != OpConst64 { 9954 break 9955 } 9956 c := v_0_1.AuxInt 9957 v_1 := v.Args[1] 9958 if v_1.Op != OpConst64 { 9959 break 9960 } 9961 d := v_1.AuxInt 9962 if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) { 9963 break 9964 } 9965 v.reset(OpConstBool) 9966 v.AuxInt = 1 9967 return true 9968 } 9969 // match: (IsInBounds (ZeroExt32to64 (Rsh32Ux64 _ (Const64 [c]))) (Const64 [d])) 9970 // cond: 0 < c && c < 32 && 1<<uint(32-c)-1 < d 9971 // result: (ConstBool [1]) 9972 for { 9973 _ = v.Args[1] 9974 v_0 := v.Args[0] 9975 if v_0.Op != OpZeroExt32to64 { 9976 break 9977 } 9978 v_0_0 := v_0.Args[0] 9979 if v_0_0.Op != OpRsh32Ux64 { 9980 break 9981 } 9982 _ = v_0_0.Args[1] 9983 v_0_0_1 := v_0_0.Args[1] 9984 if v_0_0_1.Op != OpConst64 { 9985 break 9986 } 9987 c := v_0_0_1.AuxInt 9988 v_1 := v.Args[1] 9989 if v_1.Op != OpConst64 { 9990 break 9991 } 9992 d := v_1.AuxInt 9993 if !(0 < c && c < 32 && 1<<uint(32-c)-1 < d) { 9994 break 9995 } 9996 v.reset(OpConstBool) 9997 v.AuxInt = 1 9998 return true 9999 } 10000 // match: (IsInBounds (Rsh32Ux64 _ (Const64 [c])) (Const64 [d])) 10001 // cond: 0 < c && c < 32 && 1<<uint(32-c)-1 < d 10002 // result: (ConstBool [1]) 10003 for { 10004 _ = v.Args[1] 10005 v_0 := v.Args[0] 10006 if v_0.Op != OpRsh32Ux64 { 10007 break 10008 } 10009 _ = v_0.Args[1] 10010 v_0_1 := v_0.Args[1] 10011 if v_0_1.Op != OpConst64 { 10012 break 10013 } 10014 c := v_0_1.AuxInt 10015 v_1 := v.Args[1] 10016 if v_1.Op != OpConst64 { 10017 break 10018 } 10019 d := v_1.AuxInt 10020 if !(0 < c && c < 32 && 1<<uint(32-c)-1 < d) { 10021 break 10022 } 10023 v.reset(OpConstBool) 10024 v.AuxInt = 1 10025 return true 10026 } 10027 // match: (IsInBounds (Rsh64Ux64 _ (Const64 [c])) (Const64 [d])) 10028 // cond: 0 < c && c < 64 && 1<<uint(64-c)-1 < d 10029 // result: (ConstBool [1]) 10030 for { 10031 _ = v.Args[1] 10032 v_0 := v.Args[0] 10033 if v_0.Op != OpRsh64Ux64 { 10034 break 10035 } 10036 _ = v_0.Args[1] 10037 v_0_1 := v_0.Args[1] 10038 if v_0_1.Op != OpConst64 { 10039 break 10040 } 10041 c := v_0_1.AuxInt 10042 v_1 := v.Args[1] 10043 if v_1.Op != OpConst64 { 10044 break 10045 } 10046 d := v_1.AuxInt 10047 if !(0 < c && c < 64 && 1<<uint(64-c)-1 < d) { 10048 break 10049 } 10050 v.reset(OpConstBool) 10051 v.AuxInt = 1 10052 return true 10053 } 10054 return false 10055 } 10056 func rewriteValuegeneric_OpIsNonNil_0(v *Value) bool { 10057 // match: (IsNonNil (ConstNil)) 10058 // cond: 10059 // result: (ConstBool [0]) 10060 for { 10061 v_0 := v.Args[0] 10062 if v_0.Op != OpConstNil { 10063 break 10064 } 10065 v.reset(OpConstBool) 10066 v.AuxInt = 0 10067 return true 10068 } 10069 return false 10070 } 10071 func rewriteValuegeneric_OpIsSliceInBounds_0(v *Value) bool { 10072 // match: (IsSliceInBounds x x) 10073 // cond: 10074 // result: (ConstBool [1]) 10075 for { 10076 _ = v.Args[1] 10077 x := v.Args[0] 10078 if x != v.Args[1] { 10079 break 10080 } 10081 v.reset(OpConstBool) 10082 v.AuxInt = 1 10083 return true 10084 } 10085 // match: (IsSliceInBounds (And32 (Const32 [c]) _) (Const32 [d])) 10086 // cond: 0 <= c && c <= d 10087 // result: (ConstBool [1]) 10088 for { 10089 _ = v.Args[1] 10090 v_0 := v.Args[0] 10091 if v_0.Op != OpAnd32 { 10092 break 10093 } 10094 _ = v_0.Args[1] 10095 v_0_0 := v_0.Args[0] 10096 if v_0_0.Op != OpConst32 { 10097 break 10098 } 10099 c := v_0_0.AuxInt 10100 v_1 := v.Args[1] 10101 if v_1.Op != OpConst32 { 10102 break 10103 } 10104 d := v_1.AuxInt 10105 if !(0 <= c && c <= d) { 10106 break 10107 } 10108 v.reset(OpConstBool) 10109 v.AuxInt = 1 10110 return true 10111 } 10112 // match: (IsSliceInBounds (And32 _ (Const32 [c])) (Const32 [d])) 10113 // cond: 0 <= c && c <= d 10114 // result: (ConstBool [1]) 10115 for { 10116 _ = v.Args[1] 10117 v_0 := v.Args[0] 10118 if v_0.Op != OpAnd32 { 10119 break 10120 } 10121 _ = v_0.Args[1] 10122 v_0_1 := v_0.Args[1] 10123 if v_0_1.Op != OpConst32 { 10124 break 10125 } 10126 c := v_0_1.AuxInt 10127 v_1 := v.Args[1] 10128 if v_1.Op != OpConst32 { 10129 break 10130 } 10131 d := v_1.AuxInt 10132 if !(0 <= c && c <= d) { 10133 break 10134 } 10135 v.reset(OpConstBool) 10136 v.AuxInt = 1 10137 return true 10138 } 10139 // match: (IsSliceInBounds (And64 (Const64 [c]) _) (Const64 [d])) 10140 // cond: 0 <= c && c <= d 10141 // result: (ConstBool [1]) 10142 for { 10143 _ = v.Args[1] 10144 v_0 := v.Args[0] 10145 if v_0.Op != OpAnd64 { 10146 break 10147 } 10148 _ = v_0.Args[1] 10149 v_0_0 := v_0.Args[0] 10150 if v_0_0.Op != OpConst64 { 10151 break 10152 } 10153 c := v_0_0.AuxInt 10154 v_1 := v.Args[1] 10155 if v_1.Op != OpConst64 { 10156 break 10157 } 10158 d := v_1.AuxInt 10159 if !(0 <= c && c <= d) { 10160 break 10161 } 10162 v.reset(OpConstBool) 10163 v.AuxInt = 1 10164 return true 10165 } 10166 // match: (IsSliceInBounds (And64 _ (Const64 [c])) (Const64 [d])) 10167 // cond: 0 <= c && c <= d 10168 // result: (ConstBool [1]) 10169 for { 10170 _ = v.Args[1] 10171 v_0 := v.Args[0] 10172 if v_0.Op != OpAnd64 { 10173 break 10174 } 10175 _ = v_0.Args[1] 10176 v_0_1 := v_0.Args[1] 10177 if v_0_1.Op != OpConst64 { 10178 break 10179 } 10180 c := v_0_1.AuxInt 10181 v_1 := v.Args[1] 10182 if v_1.Op != OpConst64 { 10183 break 10184 } 10185 d := v_1.AuxInt 10186 if !(0 <= c && c <= d) { 10187 break 10188 } 10189 v.reset(OpConstBool) 10190 v.AuxInt = 1 10191 return true 10192 } 10193 // match: (IsSliceInBounds (Const32 [0]) _) 10194 // cond: 10195 // result: (ConstBool [1]) 10196 for { 10197 _ = v.Args[1] 10198 v_0 := v.Args[0] 10199 if v_0.Op != OpConst32 { 10200 break 10201 } 10202 if v_0.AuxInt != 0 { 10203 break 10204 } 10205 v.reset(OpConstBool) 10206 v.AuxInt = 1 10207 return true 10208 } 10209 // match: (IsSliceInBounds (Const64 [0]) _) 10210 // cond: 10211 // result: (ConstBool [1]) 10212 for { 10213 _ = v.Args[1] 10214 v_0 := v.Args[0] 10215 if v_0.Op != OpConst64 { 10216 break 10217 } 10218 if v_0.AuxInt != 0 { 10219 break 10220 } 10221 v.reset(OpConstBool) 10222 v.AuxInt = 1 10223 return true 10224 } 10225 // match: (IsSliceInBounds (Const32 [c]) (Const32 [d])) 10226 // cond: 10227 // result: (ConstBool [b2i(0 <= c && c <= d)]) 10228 for { 10229 _ = v.Args[1] 10230 v_0 := v.Args[0] 10231 if v_0.Op != OpConst32 { 10232 break 10233 } 10234 c := v_0.AuxInt 10235 v_1 := v.Args[1] 10236 if v_1.Op != OpConst32 { 10237 break 10238 } 10239 d := v_1.AuxInt 10240 v.reset(OpConstBool) 10241 v.AuxInt = b2i(0 <= c && c <= d) 10242 return true 10243 } 10244 // match: (IsSliceInBounds (Const64 [c]) (Const64 [d])) 10245 // cond: 10246 // result: (ConstBool [b2i(0 <= c && c <= d)]) 10247 for { 10248 _ = v.Args[1] 10249 v_0 := v.Args[0] 10250 if v_0.Op != OpConst64 { 10251 break 10252 } 10253 c := v_0.AuxInt 10254 v_1 := v.Args[1] 10255 if v_1.Op != OpConst64 { 10256 break 10257 } 10258 d := v_1.AuxInt 10259 v.reset(OpConstBool) 10260 v.AuxInt = b2i(0 <= c && c <= d) 10261 return true 10262 } 10263 // match: (IsSliceInBounds (SliceLen x) (SliceCap x)) 10264 // cond: 10265 // result: (ConstBool [1]) 10266 for { 10267 _ = v.Args[1] 10268 v_0 := v.Args[0] 10269 if v_0.Op != OpSliceLen { 10270 break 10271 } 10272 x := v_0.Args[0] 10273 v_1 := v.Args[1] 10274 if v_1.Op != OpSliceCap { 10275 break 10276 } 10277 if x != v_1.Args[0] { 10278 break 10279 } 10280 v.reset(OpConstBool) 10281 v.AuxInt = 1 10282 return true 10283 } 10284 return false 10285 } 10286 func rewriteValuegeneric_OpLeq16_0(v *Value) bool { 10287 // match: (Leq16 (Const16 [c]) (Const16 [d])) 10288 // cond: 10289 // result: (ConstBool [b2i(c <= d)]) 10290 for { 10291 _ = v.Args[1] 10292 v_0 := v.Args[0] 10293 if v_0.Op != OpConst16 { 10294 break 10295 } 10296 c := v_0.AuxInt 10297 v_1 := v.Args[1] 10298 if v_1.Op != OpConst16 { 10299 break 10300 } 10301 d := v_1.AuxInt 10302 v.reset(OpConstBool) 10303 v.AuxInt = b2i(c <= d) 10304 return true 10305 } 10306 return false 10307 } 10308 func rewriteValuegeneric_OpLeq16U_0(v *Value) bool { 10309 // match: (Leq16U (Const16 [c]) (Const16 [d])) 10310 // cond: 10311 // result: (ConstBool [b2i(uint16(c) <= uint16(d))]) 10312 for { 10313 _ = v.Args[1] 10314 v_0 := v.Args[0] 10315 if v_0.Op != OpConst16 { 10316 break 10317 } 10318 c := v_0.AuxInt 10319 v_1 := v.Args[1] 10320 if v_1.Op != OpConst16 { 10321 break 10322 } 10323 d := v_1.AuxInt 10324 v.reset(OpConstBool) 10325 v.AuxInt = b2i(uint16(c) <= uint16(d)) 10326 return true 10327 } 10328 return false 10329 } 10330 func rewriteValuegeneric_OpLeq32_0(v *Value) bool { 10331 // match: (Leq32 (Const32 [c]) (Const32 [d])) 10332 // cond: 10333 // result: (ConstBool [b2i(c <= d)]) 10334 for { 10335 _ = v.Args[1] 10336 v_0 := v.Args[0] 10337 if v_0.Op != OpConst32 { 10338 break 10339 } 10340 c := v_0.AuxInt 10341 v_1 := v.Args[1] 10342 if v_1.Op != OpConst32 { 10343 break 10344 } 10345 d := v_1.AuxInt 10346 v.reset(OpConstBool) 10347 v.AuxInt = b2i(c <= d) 10348 return true 10349 } 10350 return false 10351 } 10352 func rewriteValuegeneric_OpLeq32U_0(v *Value) bool { 10353 // match: (Leq32U (Const32 [c]) (Const32 [d])) 10354 // cond: 10355 // result: (ConstBool [b2i(uint32(c) <= uint32(d))]) 10356 for { 10357 _ = v.Args[1] 10358 v_0 := v.Args[0] 10359 if v_0.Op != OpConst32 { 10360 break 10361 } 10362 c := v_0.AuxInt 10363 v_1 := v.Args[1] 10364 if v_1.Op != OpConst32 { 10365 break 10366 } 10367 d := v_1.AuxInt 10368 v.reset(OpConstBool) 10369 v.AuxInt = b2i(uint32(c) <= uint32(d)) 10370 return true 10371 } 10372 return false 10373 } 10374 func rewriteValuegeneric_OpLeq64_0(v *Value) bool { 10375 // match: (Leq64 (Const64 [c]) (Const64 [d])) 10376 // cond: 10377 // result: (ConstBool [b2i(c <= d)]) 10378 for { 10379 _ = v.Args[1] 10380 v_0 := v.Args[0] 10381 if v_0.Op != OpConst64 { 10382 break 10383 } 10384 c := v_0.AuxInt 10385 v_1 := v.Args[1] 10386 if v_1.Op != OpConst64 { 10387 break 10388 } 10389 d := v_1.AuxInt 10390 v.reset(OpConstBool) 10391 v.AuxInt = b2i(c <= d) 10392 return true 10393 } 10394 return false 10395 } 10396 func rewriteValuegeneric_OpLeq64U_0(v *Value) bool { 10397 // match: (Leq64U (Const64 [c]) (Const64 [d])) 10398 // cond: 10399 // result: (ConstBool [b2i(uint64(c) <= uint64(d))]) 10400 for { 10401 _ = v.Args[1] 10402 v_0 := v.Args[0] 10403 if v_0.Op != OpConst64 { 10404 break 10405 } 10406 c := v_0.AuxInt 10407 v_1 := v.Args[1] 10408 if v_1.Op != OpConst64 { 10409 break 10410 } 10411 d := v_1.AuxInt 10412 v.reset(OpConstBool) 10413 v.AuxInt = b2i(uint64(c) <= uint64(d)) 10414 return true 10415 } 10416 return false 10417 } 10418 func rewriteValuegeneric_OpLeq8_0(v *Value) bool { 10419 // match: (Leq8 (Const8 [c]) (Const8 [d])) 10420 // cond: 10421 // result: (ConstBool [b2i(c <= d)]) 10422 for { 10423 _ = v.Args[1] 10424 v_0 := v.Args[0] 10425 if v_0.Op != OpConst8 { 10426 break 10427 } 10428 c := v_0.AuxInt 10429 v_1 := v.Args[1] 10430 if v_1.Op != OpConst8 { 10431 break 10432 } 10433 d := v_1.AuxInt 10434 v.reset(OpConstBool) 10435 v.AuxInt = b2i(c <= d) 10436 return true 10437 } 10438 return false 10439 } 10440 func rewriteValuegeneric_OpLeq8U_0(v *Value) bool { 10441 // match: (Leq8U (Const8 [c]) (Const8 [d])) 10442 // cond: 10443 // result: (ConstBool [b2i(uint8(c) <= uint8(d))]) 10444 for { 10445 _ = v.Args[1] 10446 v_0 := v.Args[0] 10447 if v_0.Op != OpConst8 { 10448 break 10449 } 10450 c := v_0.AuxInt 10451 v_1 := v.Args[1] 10452 if v_1.Op != OpConst8 { 10453 break 10454 } 10455 d := v_1.AuxInt 10456 v.reset(OpConstBool) 10457 v.AuxInt = b2i(uint8(c) <= uint8(d)) 10458 return true 10459 } 10460 return false 10461 } 10462 func rewriteValuegeneric_OpLess16_0(v *Value) bool { 10463 // match: (Less16 (Const16 [c]) (Const16 [d])) 10464 // cond: 10465 // result: (ConstBool [b2i(c < d)]) 10466 for { 10467 _ = v.Args[1] 10468 v_0 := v.Args[0] 10469 if v_0.Op != OpConst16 { 10470 break 10471 } 10472 c := v_0.AuxInt 10473 v_1 := v.Args[1] 10474 if v_1.Op != OpConst16 { 10475 break 10476 } 10477 d := v_1.AuxInt 10478 v.reset(OpConstBool) 10479 v.AuxInt = b2i(c < d) 10480 return true 10481 } 10482 return false 10483 } 10484 func rewriteValuegeneric_OpLess16U_0(v *Value) bool { 10485 // match: (Less16U (Const16 [c]) (Const16 [d])) 10486 // cond: 10487 // result: (ConstBool [b2i(uint16(c) < uint16(d))]) 10488 for { 10489 _ = v.Args[1] 10490 v_0 := v.Args[0] 10491 if v_0.Op != OpConst16 { 10492 break 10493 } 10494 c := v_0.AuxInt 10495 v_1 := v.Args[1] 10496 if v_1.Op != OpConst16 { 10497 break 10498 } 10499 d := v_1.AuxInt 10500 v.reset(OpConstBool) 10501 v.AuxInt = b2i(uint16(c) < uint16(d)) 10502 return true 10503 } 10504 return false 10505 } 10506 func rewriteValuegeneric_OpLess32_0(v *Value) bool { 10507 // match: (Less32 (Const32 [c]) (Const32 [d])) 10508 // cond: 10509 // result: (ConstBool [b2i(c < d)]) 10510 for { 10511 _ = v.Args[1] 10512 v_0 := v.Args[0] 10513 if v_0.Op != OpConst32 { 10514 break 10515 } 10516 c := v_0.AuxInt 10517 v_1 := v.Args[1] 10518 if v_1.Op != OpConst32 { 10519 break 10520 } 10521 d := v_1.AuxInt 10522 v.reset(OpConstBool) 10523 v.AuxInt = b2i(c < d) 10524 return true 10525 } 10526 return false 10527 } 10528 func rewriteValuegeneric_OpLess32U_0(v *Value) bool { 10529 // match: (Less32U (Const32 [c]) (Const32 [d])) 10530 // cond: 10531 // result: (ConstBool [b2i(uint32(c) < uint32(d))]) 10532 for { 10533 _ = v.Args[1] 10534 v_0 := v.Args[0] 10535 if v_0.Op != OpConst32 { 10536 break 10537 } 10538 c := v_0.AuxInt 10539 v_1 := v.Args[1] 10540 if v_1.Op != OpConst32 { 10541 break 10542 } 10543 d := v_1.AuxInt 10544 v.reset(OpConstBool) 10545 v.AuxInt = b2i(uint32(c) < uint32(d)) 10546 return true 10547 } 10548 return false 10549 } 10550 func rewriteValuegeneric_OpLess64_0(v *Value) bool { 10551 // match: (Less64 (Const64 [c]) (Const64 [d])) 10552 // cond: 10553 // result: (ConstBool [b2i(c < d)]) 10554 for { 10555 _ = v.Args[1] 10556 v_0 := v.Args[0] 10557 if v_0.Op != OpConst64 { 10558 break 10559 } 10560 c := v_0.AuxInt 10561 v_1 := v.Args[1] 10562 if v_1.Op != OpConst64 { 10563 break 10564 } 10565 d := v_1.AuxInt 10566 v.reset(OpConstBool) 10567 v.AuxInt = b2i(c < d) 10568 return true 10569 } 10570 return false 10571 } 10572 func rewriteValuegeneric_OpLess64U_0(v *Value) bool { 10573 // match: (Less64U (Const64 [c]) (Const64 [d])) 10574 // cond: 10575 // result: (ConstBool [b2i(uint64(c) < uint64(d))]) 10576 for { 10577 _ = v.Args[1] 10578 v_0 := v.Args[0] 10579 if v_0.Op != OpConst64 { 10580 break 10581 } 10582 c := v_0.AuxInt 10583 v_1 := v.Args[1] 10584 if v_1.Op != OpConst64 { 10585 break 10586 } 10587 d := v_1.AuxInt 10588 v.reset(OpConstBool) 10589 v.AuxInt = b2i(uint64(c) < uint64(d)) 10590 return true 10591 } 10592 return false 10593 } 10594 func rewriteValuegeneric_OpLess8_0(v *Value) bool { 10595 // match: (Less8 (Const8 [c]) (Const8 [d])) 10596 // cond: 10597 // result: (ConstBool [b2i(c < d)]) 10598 for { 10599 _ = v.Args[1] 10600 v_0 := v.Args[0] 10601 if v_0.Op != OpConst8 { 10602 break 10603 } 10604 c := v_0.AuxInt 10605 v_1 := v.Args[1] 10606 if v_1.Op != OpConst8 { 10607 break 10608 } 10609 d := v_1.AuxInt 10610 v.reset(OpConstBool) 10611 v.AuxInt = b2i(c < d) 10612 return true 10613 } 10614 return false 10615 } 10616 func rewriteValuegeneric_OpLess8U_0(v *Value) bool { 10617 // match: (Less8U (Const8 [c]) (Const8 [d])) 10618 // cond: 10619 // result: (ConstBool [b2i(uint8(c) < uint8(d))]) 10620 for { 10621 _ = v.Args[1] 10622 v_0 := v.Args[0] 10623 if v_0.Op != OpConst8 { 10624 break 10625 } 10626 c := v_0.AuxInt 10627 v_1 := v.Args[1] 10628 if v_1.Op != OpConst8 { 10629 break 10630 } 10631 d := v_1.AuxInt 10632 v.reset(OpConstBool) 10633 v.AuxInt = b2i(uint8(c) < uint8(d)) 10634 return true 10635 } 10636 return false 10637 } 10638 func rewriteValuegeneric_OpLoad_0(v *Value) bool { 10639 b := v.Block 10640 _ = b 10641 fe := b.Func.fe 10642 _ = fe 10643 // match: (Load <t1> p1 (Store {t2} p2 x _)) 10644 // cond: isSamePtr(p1,p2) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == t2.(*types.Type).Size() 10645 // result: x 10646 for { 10647 t1 := v.Type 10648 _ = v.Args[1] 10649 p1 := v.Args[0] 10650 v_1 := v.Args[1] 10651 if v_1.Op != OpStore { 10652 break 10653 } 10654 t2 := v_1.Aux 10655 _ = v_1.Args[2] 10656 p2 := v_1.Args[0] 10657 x := v_1.Args[1] 10658 if !(isSamePtr(p1, p2) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == t2.(*types.Type).Size()) { 10659 break 10660 } 10661 v.reset(OpCopy) 10662 v.Type = x.Type 10663 v.AddArg(x) 10664 return true 10665 } 10666 // match: (Load <t> _ _) 10667 // cond: t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t) 10668 // result: (StructMake0) 10669 for { 10670 t := v.Type 10671 _ = v.Args[1] 10672 if !(t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t)) { 10673 break 10674 } 10675 v.reset(OpStructMake0) 10676 return true 10677 } 10678 // match: (Load <t> ptr mem) 10679 // cond: t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t) 10680 // result: (StructMake1 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem)) 10681 for { 10682 t := v.Type 10683 _ = v.Args[1] 10684 ptr := v.Args[0] 10685 mem := v.Args[1] 10686 if !(t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t)) { 10687 break 10688 } 10689 v.reset(OpStructMake1) 10690 v0 := b.NewValue0(v.Pos, OpLoad, t.FieldType(0)) 10691 v1 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo()) 10692 v1.AuxInt = 0 10693 v1.AddArg(ptr) 10694 v0.AddArg(v1) 10695 v0.AddArg(mem) 10696 v.AddArg(v0) 10697 return true 10698 } 10699 // match: (Load <t> ptr mem) 10700 // cond: t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t) 10701 // result: (StructMake2 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem)) 10702 for { 10703 t := v.Type 10704 _ = v.Args[1] 10705 ptr := v.Args[0] 10706 mem := v.Args[1] 10707 if !(t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t)) { 10708 break 10709 } 10710 v.reset(OpStructMake2) 10711 v0 := b.NewValue0(v.Pos, OpLoad, t.FieldType(0)) 10712 v1 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo()) 10713 v1.AuxInt = 0 10714 v1.AddArg(ptr) 10715 v0.AddArg(v1) 10716 v0.AddArg(mem) 10717 v.AddArg(v0) 10718 v2 := b.NewValue0(v.Pos, OpLoad, t.FieldType(1)) 10719 v3 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo()) 10720 v3.AuxInt = t.FieldOff(1) 10721 v3.AddArg(ptr) 10722 v2.AddArg(v3) 10723 v2.AddArg(mem) 10724 v.AddArg(v2) 10725 return true 10726 } 10727 // match: (Load <t> ptr mem) 10728 // cond: t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t) 10729 // result: (StructMake3 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem) (Load <t.FieldType(2)> (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] ptr) mem)) 10730 for { 10731 t := v.Type 10732 _ = v.Args[1] 10733 ptr := v.Args[0] 10734 mem := v.Args[1] 10735 if !(t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t)) { 10736 break 10737 } 10738 v.reset(OpStructMake3) 10739 v0 := b.NewValue0(v.Pos, OpLoad, t.FieldType(0)) 10740 v1 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo()) 10741 v1.AuxInt = 0 10742 v1.AddArg(ptr) 10743 v0.AddArg(v1) 10744 v0.AddArg(mem) 10745 v.AddArg(v0) 10746 v2 := b.NewValue0(v.Pos, OpLoad, t.FieldType(1)) 10747 v3 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo()) 10748 v3.AuxInt = t.FieldOff(1) 10749 v3.AddArg(ptr) 10750 v2.AddArg(v3) 10751 v2.AddArg(mem) 10752 v.AddArg(v2) 10753 v4 := b.NewValue0(v.Pos, OpLoad, t.FieldType(2)) 10754 v5 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo()) 10755 v5.AuxInt = t.FieldOff(2) 10756 v5.AddArg(ptr) 10757 v4.AddArg(v5) 10758 v4.AddArg(mem) 10759 v.AddArg(v4) 10760 return true 10761 } 10762 // match: (Load <t> ptr mem) 10763 // cond: t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t) 10764 // result: (StructMake4 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem) (Load <t.FieldType(2)> (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] ptr) mem) (Load <t.FieldType(3)> (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] ptr) mem)) 10765 for { 10766 t := v.Type 10767 _ = v.Args[1] 10768 ptr := v.Args[0] 10769 mem := v.Args[1] 10770 if !(t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t)) { 10771 break 10772 } 10773 v.reset(OpStructMake4) 10774 v0 := b.NewValue0(v.Pos, OpLoad, t.FieldType(0)) 10775 v1 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo()) 10776 v1.AuxInt = 0 10777 v1.AddArg(ptr) 10778 v0.AddArg(v1) 10779 v0.AddArg(mem) 10780 v.AddArg(v0) 10781 v2 := b.NewValue0(v.Pos, OpLoad, t.FieldType(1)) 10782 v3 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo()) 10783 v3.AuxInt = t.FieldOff(1) 10784 v3.AddArg(ptr) 10785 v2.AddArg(v3) 10786 v2.AddArg(mem) 10787 v.AddArg(v2) 10788 v4 := b.NewValue0(v.Pos, OpLoad, t.FieldType(2)) 10789 v5 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo()) 10790 v5.AuxInt = t.FieldOff(2) 10791 v5.AddArg(ptr) 10792 v4.AddArg(v5) 10793 v4.AddArg(mem) 10794 v.AddArg(v4) 10795 v6 := b.NewValue0(v.Pos, OpLoad, t.FieldType(3)) 10796 v7 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(3).PtrTo()) 10797 v7.AuxInt = t.FieldOff(3) 10798 v7.AddArg(ptr) 10799 v6.AddArg(v7) 10800 v6.AddArg(mem) 10801 v.AddArg(v6) 10802 return true 10803 } 10804 // match: (Load <t> _ _) 10805 // cond: t.IsArray() && t.NumElem() == 0 10806 // result: (ArrayMake0) 10807 for { 10808 t := v.Type 10809 _ = v.Args[1] 10810 if !(t.IsArray() && t.NumElem() == 0) { 10811 break 10812 } 10813 v.reset(OpArrayMake0) 10814 return true 10815 } 10816 // match: (Load <t> ptr mem) 10817 // cond: t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t) 10818 // result: (ArrayMake1 (Load <t.ElemType()> ptr mem)) 10819 for { 10820 t := v.Type 10821 _ = v.Args[1] 10822 ptr := v.Args[0] 10823 mem := v.Args[1] 10824 if !(t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t)) { 10825 break 10826 } 10827 v.reset(OpArrayMake1) 10828 v0 := b.NewValue0(v.Pos, OpLoad, t.ElemType()) 10829 v0.AddArg(ptr) 10830 v0.AddArg(mem) 10831 v.AddArg(v0) 10832 return true 10833 } 10834 return false 10835 } 10836 func rewriteValuegeneric_OpLsh16x16_0(v *Value) bool { 10837 b := v.Block 10838 _ = b 10839 // match: (Lsh16x16 <t> x (Const16 [c])) 10840 // cond: 10841 // result: (Lsh16x64 x (Const64 <t> [int64(uint16(c))])) 10842 for { 10843 t := v.Type 10844 _ = v.Args[1] 10845 x := v.Args[0] 10846 v_1 := v.Args[1] 10847 if v_1.Op != OpConst16 { 10848 break 10849 } 10850 c := v_1.AuxInt 10851 v.reset(OpLsh16x64) 10852 v.AddArg(x) 10853 v0 := b.NewValue0(v.Pos, OpConst64, t) 10854 v0.AuxInt = int64(uint16(c)) 10855 v.AddArg(v0) 10856 return true 10857 } 10858 // match: (Lsh16x16 (Const16 [0]) _) 10859 // cond: 10860 // result: (Const16 [0]) 10861 for { 10862 _ = v.Args[1] 10863 v_0 := v.Args[0] 10864 if v_0.Op != OpConst16 { 10865 break 10866 } 10867 if v_0.AuxInt != 0 { 10868 break 10869 } 10870 v.reset(OpConst16) 10871 v.AuxInt = 0 10872 return true 10873 } 10874 return false 10875 } 10876 func rewriteValuegeneric_OpLsh16x32_0(v *Value) bool { 10877 b := v.Block 10878 _ = b 10879 // match: (Lsh16x32 <t> x (Const32 [c])) 10880 // cond: 10881 // result: (Lsh16x64 x (Const64 <t> [int64(uint32(c))])) 10882 for { 10883 t := v.Type 10884 _ = v.Args[1] 10885 x := v.Args[0] 10886 v_1 := v.Args[1] 10887 if v_1.Op != OpConst32 { 10888 break 10889 } 10890 c := v_1.AuxInt 10891 v.reset(OpLsh16x64) 10892 v.AddArg(x) 10893 v0 := b.NewValue0(v.Pos, OpConst64, t) 10894 v0.AuxInt = int64(uint32(c)) 10895 v.AddArg(v0) 10896 return true 10897 } 10898 // match: (Lsh16x32 (Const16 [0]) _) 10899 // cond: 10900 // result: (Const16 [0]) 10901 for { 10902 _ = v.Args[1] 10903 v_0 := v.Args[0] 10904 if v_0.Op != OpConst16 { 10905 break 10906 } 10907 if v_0.AuxInt != 0 { 10908 break 10909 } 10910 v.reset(OpConst16) 10911 v.AuxInt = 0 10912 return true 10913 } 10914 return false 10915 } 10916 func rewriteValuegeneric_OpLsh16x64_0(v *Value) bool { 10917 b := v.Block 10918 _ = b 10919 typ := &b.Func.Config.Types 10920 _ = typ 10921 // match: (Lsh16x64 (Const16 [c]) (Const64 [d])) 10922 // cond: 10923 // result: (Const16 [int64(int16(c) << uint64(d))]) 10924 for { 10925 _ = v.Args[1] 10926 v_0 := v.Args[0] 10927 if v_0.Op != OpConst16 { 10928 break 10929 } 10930 c := v_0.AuxInt 10931 v_1 := v.Args[1] 10932 if v_1.Op != OpConst64 { 10933 break 10934 } 10935 d := v_1.AuxInt 10936 v.reset(OpConst16) 10937 v.AuxInt = int64(int16(c) << uint64(d)) 10938 return true 10939 } 10940 // match: (Lsh16x64 x (Const64 [0])) 10941 // cond: 10942 // result: x 10943 for { 10944 _ = v.Args[1] 10945 x := v.Args[0] 10946 v_1 := v.Args[1] 10947 if v_1.Op != OpConst64 { 10948 break 10949 } 10950 if v_1.AuxInt != 0 { 10951 break 10952 } 10953 v.reset(OpCopy) 10954 v.Type = x.Type 10955 v.AddArg(x) 10956 return true 10957 } 10958 // match: (Lsh16x64 (Const16 [0]) _) 10959 // cond: 10960 // result: (Const16 [0]) 10961 for { 10962 _ = v.Args[1] 10963 v_0 := v.Args[0] 10964 if v_0.Op != OpConst16 { 10965 break 10966 } 10967 if v_0.AuxInt != 0 { 10968 break 10969 } 10970 v.reset(OpConst16) 10971 v.AuxInt = 0 10972 return true 10973 } 10974 // match: (Lsh16x64 _ (Const64 [c])) 10975 // cond: uint64(c) >= 16 10976 // result: (Const16 [0]) 10977 for { 10978 _ = v.Args[1] 10979 v_1 := v.Args[1] 10980 if v_1.Op != OpConst64 { 10981 break 10982 } 10983 c := v_1.AuxInt 10984 if !(uint64(c) >= 16) { 10985 break 10986 } 10987 v.reset(OpConst16) 10988 v.AuxInt = 0 10989 return true 10990 } 10991 // match: (Lsh16x64 <t> (Lsh16x64 x (Const64 [c])) (Const64 [d])) 10992 // cond: !uaddOvf(c,d) 10993 // result: (Lsh16x64 x (Const64 <t> [c+d])) 10994 for { 10995 t := v.Type 10996 _ = v.Args[1] 10997 v_0 := v.Args[0] 10998 if v_0.Op != OpLsh16x64 { 10999 break 11000 } 11001 _ = v_0.Args[1] 11002 x := v_0.Args[0] 11003 v_0_1 := v_0.Args[1] 11004 if v_0_1.Op != OpConst64 { 11005 break 11006 } 11007 c := v_0_1.AuxInt 11008 v_1 := v.Args[1] 11009 if v_1.Op != OpConst64 { 11010 break 11011 } 11012 d := v_1.AuxInt 11013 if !(!uaddOvf(c, d)) { 11014 break 11015 } 11016 v.reset(OpLsh16x64) 11017 v.AddArg(x) 11018 v0 := b.NewValue0(v.Pos, OpConst64, t) 11019 v0.AuxInt = c + d 11020 v.AddArg(v0) 11021 return true 11022 } 11023 // match: (Lsh16x64 (Rsh16Ux64 (Lsh16x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) 11024 // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) 11025 // result: (Lsh16x64 x (Const64 <typ.UInt64> [c1-c2+c3])) 11026 for { 11027 _ = v.Args[1] 11028 v_0 := v.Args[0] 11029 if v_0.Op != OpRsh16Ux64 { 11030 break 11031 } 11032 _ = v_0.Args[1] 11033 v_0_0 := v_0.Args[0] 11034 if v_0_0.Op != OpLsh16x64 { 11035 break 11036 } 11037 _ = v_0_0.Args[1] 11038 x := v_0_0.Args[0] 11039 v_0_0_1 := v_0_0.Args[1] 11040 if v_0_0_1.Op != OpConst64 { 11041 break 11042 } 11043 c1 := v_0_0_1.AuxInt 11044 v_0_1 := v_0.Args[1] 11045 if v_0_1.Op != OpConst64 { 11046 break 11047 } 11048 c2 := v_0_1.AuxInt 11049 v_1 := v.Args[1] 11050 if v_1.Op != OpConst64 { 11051 break 11052 } 11053 c3 := v_1.AuxInt 11054 if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { 11055 break 11056 } 11057 v.reset(OpLsh16x64) 11058 v.AddArg(x) 11059 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 11060 v0.AuxInt = c1 - c2 + c3 11061 v.AddArg(v0) 11062 return true 11063 } 11064 return false 11065 } 11066 func rewriteValuegeneric_OpLsh16x8_0(v *Value) bool { 11067 b := v.Block 11068 _ = b 11069 // match: (Lsh16x8 <t> x (Const8 [c])) 11070 // cond: 11071 // result: (Lsh16x64 x (Const64 <t> [int64(uint8(c))])) 11072 for { 11073 t := v.Type 11074 _ = v.Args[1] 11075 x := v.Args[0] 11076 v_1 := v.Args[1] 11077 if v_1.Op != OpConst8 { 11078 break 11079 } 11080 c := v_1.AuxInt 11081 v.reset(OpLsh16x64) 11082 v.AddArg(x) 11083 v0 := b.NewValue0(v.Pos, OpConst64, t) 11084 v0.AuxInt = int64(uint8(c)) 11085 v.AddArg(v0) 11086 return true 11087 } 11088 // match: (Lsh16x8 (Const16 [0]) _) 11089 // cond: 11090 // result: (Const16 [0]) 11091 for { 11092 _ = v.Args[1] 11093 v_0 := v.Args[0] 11094 if v_0.Op != OpConst16 { 11095 break 11096 } 11097 if v_0.AuxInt != 0 { 11098 break 11099 } 11100 v.reset(OpConst16) 11101 v.AuxInt = 0 11102 return true 11103 } 11104 return false 11105 } 11106 func rewriteValuegeneric_OpLsh32x16_0(v *Value) bool { 11107 b := v.Block 11108 _ = b 11109 // match: (Lsh32x16 <t> x (Const16 [c])) 11110 // cond: 11111 // result: (Lsh32x64 x (Const64 <t> [int64(uint16(c))])) 11112 for { 11113 t := v.Type 11114 _ = v.Args[1] 11115 x := v.Args[0] 11116 v_1 := v.Args[1] 11117 if v_1.Op != OpConst16 { 11118 break 11119 } 11120 c := v_1.AuxInt 11121 v.reset(OpLsh32x64) 11122 v.AddArg(x) 11123 v0 := b.NewValue0(v.Pos, OpConst64, t) 11124 v0.AuxInt = int64(uint16(c)) 11125 v.AddArg(v0) 11126 return true 11127 } 11128 // match: (Lsh32x16 (Const32 [0]) _) 11129 // cond: 11130 // result: (Const32 [0]) 11131 for { 11132 _ = v.Args[1] 11133 v_0 := v.Args[0] 11134 if v_0.Op != OpConst32 { 11135 break 11136 } 11137 if v_0.AuxInt != 0 { 11138 break 11139 } 11140 v.reset(OpConst32) 11141 v.AuxInt = 0 11142 return true 11143 } 11144 return false 11145 } 11146 func rewriteValuegeneric_OpLsh32x32_0(v *Value) bool { 11147 b := v.Block 11148 _ = b 11149 // match: (Lsh32x32 <t> x (Const32 [c])) 11150 // cond: 11151 // result: (Lsh32x64 x (Const64 <t> [int64(uint32(c))])) 11152 for { 11153 t := v.Type 11154 _ = v.Args[1] 11155 x := v.Args[0] 11156 v_1 := v.Args[1] 11157 if v_1.Op != OpConst32 { 11158 break 11159 } 11160 c := v_1.AuxInt 11161 v.reset(OpLsh32x64) 11162 v.AddArg(x) 11163 v0 := b.NewValue0(v.Pos, OpConst64, t) 11164 v0.AuxInt = int64(uint32(c)) 11165 v.AddArg(v0) 11166 return true 11167 } 11168 // match: (Lsh32x32 (Const32 [0]) _) 11169 // cond: 11170 // result: (Const32 [0]) 11171 for { 11172 _ = v.Args[1] 11173 v_0 := v.Args[0] 11174 if v_0.Op != OpConst32 { 11175 break 11176 } 11177 if v_0.AuxInt != 0 { 11178 break 11179 } 11180 v.reset(OpConst32) 11181 v.AuxInt = 0 11182 return true 11183 } 11184 return false 11185 } 11186 func rewriteValuegeneric_OpLsh32x64_0(v *Value) bool { 11187 b := v.Block 11188 _ = b 11189 typ := &b.Func.Config.Types 11190 _ = typ 11191 // match: (Lsh32x64 (Const32 [c]) (Const64 [d])) 11192 // cond: 11193 // result: (Const32 [int64(int32(c) << uint64(d))]) 11194 for { 11195 _ = v.Args[1] 11196 v_0 := v.Args[0] 11197 if v_0.Op != OpConst32 { 11198 break 11199 } 11200 c := v_0.AuxInt 11201 v_1 := v.Args[1] 11202 if v_1.Op != OpConst64 { 11203 break 11204 } 11205 d := v_1.AuxInt 11206 v.reset(OpConst32) 11207 v.AuxInt = int64(int32(c) << uint64(d)) 11208 return true 11209 } 11210 // match: (Lsh32x64 x (Const64 [0])) 11211 // cond: 11212 // result: x 11213 for { 11214 _ = v.Args[1] 11215 x := v.Args[0] 11216 v_1 := v.Args[1] 11217 if v_1.Op != OpConst64 { 11218 break 11219 } 11220 if v_1.AuxInt != 0 { 11221 break 11222 } 11223 v.reset(OpCopy) 11224 v.Type = x.Type 11225 v.AddArg(x) 11226 return true 11227 } 11228 // match: (Lsh32x64 (Const32 [0]) _) 11229 // cond: 11230 // result: (Const32 [0]) 11231 for { 11232 _ = v.Args[1] 11233 v_0 := v.Args[0] 11234 if v_0.Op != OpConst32 { 11235 break 11236 } 11237 if v_0.AuxInt != 0 { 11238 break 11239 } 11240 v.reset(OpConst32) 11241 v.AuxInt = 0 11242 return true 11243 } 11244 // match: (Lsh32x64 _ (Const64 [c])) 11245 // cond: uint64(c) >= 32 11246 // result: (Const32 [0]) 11247 for { 11248 _ = v.Args[1] 11249 v_1 := v.Args[1] 11250 if v_1.Op != OpConst64 { 11251 break 11252 } 11253 c := v_1.AuxInt 11254 if !(uint64(c) >= 32) { 11255 break 11256 } 11257 v.reset(OpConst32) 11258 v.AuxInt = 0 11259 return true 11260 } 11261 // match: (Lsh32x64 <t> (Lsh32x64 x (Const64 [c])) (Const64 [d])) 11262 // cond: !uaddOvf(c,d) 11263 // result: (Lsh32x64 x (Const64 <t> [c+d])) 11264 for { 11265 t := v.Type 11266 _ = v.Args[1] 11267 v_0 := v.Args[0] 11268 if v_0.Op != OpLsh32x64 { 11269 break 11270 } 11271 _ = v_0.Args[1] 11272 x := v_0.Args[0] 11273 v_0_1 := v_0.Args[1] 11274 if v_0_1.Op != OpConst64 { 11275 break 11276 } 11277 c := v_0_1.AuxInt 11278 v_1 := v.Args[1] 11279 if v_1.Op != OpConst64 { 11280 break 11281 } 11282 d := v_1.AuxInt 11283 if !(!uaddOvf(c, d)) { 11284 break 11285 } 11286 v.reset(OpLsh32x64) 11287 v.AddArg(x) 11288 v0 := b.NewValue0(v.Pos, OpConst64, t) 11289 v0.AuxInt = c + d 11290 v.AddArg(v0) 11291 return true 11292 } 11293 // match: (Lsh32x64 (Rsh32Ux64 (Lsh32x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) 11294 // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) 11295 // result: (Lsh32x64 x (Const64 <typ.UInt64> [c1-c2+c3])) 11296 for { 11297 _ = v.Args[1] 11298 v_0 := v.Args[0] 11299 if v_0.Op != OpRsh32Ux64 { 11300 break 11301 } 11302 _ = v_0.Args[1] 11303 v_0_0 := v_0.Args[0] 11304 if v_0_0.Op != OpLsh32x64 { 11305 break 11306 } 11307 _ = v_0_0.Args[1] 11308 x := v_0_0.Args[0] 11309 v_0_0_1 := v_0_0.Args[1] 11310 if v_0_0_1.Op != OpConst64 { 11311 break 11312 } 11313 c1 := v_0_0_1.AuxInt 11314 v_0_1 := v_0.Args[1] 11315 if v_0_1.Op != OpConst64 { 11316 break 11317 } 11318 c2 := v_0_1.AuxInt 11319 v_1 := v.Args[1] 11320 if v_1.Op != OpConst64 { 11321 break 11322 } 11323 c3 := v_1.AuxInt 11324 if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { 11325 break 11326 } 11327 v.reset(OpLsh32x64) 11328 v.AddArg(x) 11329 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 11330 v0.AuxInt = c1 - c2 + c3 11331 v.AddArg(v0) 11332 return true 11333 } 11334 return false 11335 } 11336 func rewriteValuegeneric_OpLsh32x8_0(v *Value) bool { 11337 b := v.Block 11338 _ = b 11339 // match: (Lsh32x8 <t> x (Const8 [c])) 11340 // cond: 11341 // result: (Lsh32x64 x (Const64 <t> [int64(uint8(c))])) 11342 for { 11343 t := v.Type 11344 _ = v.Args[1] 11345 x := v.Args[0] 11346 v_1 := v.Args[1] 11347 if v_1.Op != OpConst8 { 11348 break 11349 } 11350 c := v_1.AuxInt 11351 v.reset(OpLsh32x64) 11352 v.AddArg(x) 11353 v0 := b.NewValue0(v.Pos, OpConst64, t) 11354 v0.AuxInt = int64(uint8(c)) 11355 v.AddArg(v0) 11356 return true 11357 } 11358 // match: (Lsh32x8 (Const32 [0]) _) 11359 // cond: 11360 // result: (Const32 [0]) 11361 for { 11362 _ = v.Args[1] 11363 v_0 := v.Args[0] 11364 if v_0.Op != OpConst32 { 11365 break 11366 } 11367 if v_0.AuxInt != 0 { 11368 break 11369 } 11370 v.reset(OpConst32) 11371 v.AuxInt = 0 11372 return true 11373 } 11374 return false 11375 } 11376 func rewriteValuegeneric_OpLsh64x16_0(v *Value) bool { 11377 b := v.Block 11378 _ = b 11379 // match: (Lsh64x16 <t> x (Const16 [c])) 11380 // cond: 11381 // result: (Lsh64x64 x (Const64 <t> [int64(uint16(c))])) 11382 for { 11383 t := v.Type 11384 _ = v.Args[1] 11385 x := v.Args[0] 11386 v_1 := v.Args[1] 11387 if v_1.Op != OpConst16 { 11388 break 11389 } 11390 c := v_1.AuxInt 11391 v.reset(OpLsh64x64) 11392 v.AddArg(x) 11393 v0 := b.NewValue0(v.Pos, OpConst64, t) 11394 v0.AuxInt = int64(uint16(c)) 11395 v.AddArg(v0) 11396 return true 11397 } 11398 // match: (Lsh64x16 (Const64 [0]) _) 11399 // cond: 11400 // result: (Const64 [0]) 11401 for { 11402 _ = v.Args[1] 11403 v_0 := v.Args[0] 11404 if v_0.Op != OpConst64 { 11405 break 11406 } 11407 if v_0.AuxInt != 0 { 11408 break 11409 } 11410 v.reset(OpConst64) 11411 v.AuxInt = 0 11412 return true 11413 } 11414 return false 11415 } 11416 func rewriteValuegeneric_OpLsh64x32_0(v *Value) bool { 11417 b := v.Block 11418 _ = b 11419 // match: (Lsh64x32 <t> x (Const32 [c])) 11420 // cond: 11421 // result: (Lsh64x64 x (Const64 <t> [int64(uint32(c))])) 11422 for { 11423 t := v.Type 11424 _ = v.Args[1] 11425 x := v.Args[0] 11426 v_1 := v.Args[1] 11427 if v_1.Op != OpConst32 { 11428 break 11429 } 11430 c := v_1.AuxInt 11431 v.reset(OpLsh64x64) 11432 v.AddArg(x) 11433 v0 := b.NewValue0(v.Pos, OpConst64, t) 11434 v0.AuxInt = int64(uint32(c)) 11435 v.AddArg(v0) 11436 return true 11437 } 11438 // match: (Lsh64x32 (Const64 [0]) _) 11439 // cond: 11440 // result: (Const64 [0]) 11441 for { 11442 _ = v.Args[1] 11443 v_0 := v.Args[0] 11444 if v_0.Op != OpConst64 { 11445 break 11446 } 11447 if v_0.AuxInt != 0 { 11448 break 11449 } 11450 v.reset(OpConst64) 11451 v.AuxInt = 0 11452 return true 11453 } 11454 return false 11455 } 11456 func rewriteValuegeneric_OpLsh64x64_0(v *Value) bool { 11457 b := v.Block 11458 _ = b 11459 typ := &b.Func.Config.Types 11460 _ = typ 11461 // match: (Lsh64x64 (Const64 [c]) (Const64 [d])) 11462 // cond: 11463 // result: (Const64 [c << uint64(d)]) 11464 for { 11465 _ = v.Args[1] 11466 v_0 := v.Args[0] 11467 if v_0.Op != OpConst64 { 11468 break 11469 } 11470 c := v_0.AuxInt 11471 v_1 := v.Args[1] 11472 if v_1.Op != OpConst64 { 11473 break 11474 } 11475 d := v_1.AuxInt 11476 v.reset(OpConst64) 11477 v.AuxInt = c << uint64(d) 11478 return true 11479 } 11480 // match: (Lsh64x64 x (Const64 [0])) 11481 // cond: 11482 // result: x 11483 for { 11484 _ = v.Args[1] 11485 x := v.Args[0] 11486 v_1 := v.Args[1] 11487 if v_1.Op != OpConst64 { 11488 break 11489 } 11490 if v_1.AuxInt != 0 { 11491 break 11492 } 11493 v.reset(OpCopy) 11494 v.Type = x.Type 11495 v.AddArg(x) 11496 return true 11497 } 11498 // match: (Lsh64x64 (Const64 [0]) _) 11499 // cond: 11500 // result: (Const64 [0]) 11501 for { 11502 _ = v.Args[1] 11503 v_0 := v.Args[0] 11504 if v_0.Op != OpConst64 { 11505 break 11506 } 11507 if v_0.AuxInt != 0 { 11508 break 11509 } 11510 v.reset(OpConst64) 11511 v.AuxInt = 0 11512 return true 11513 } 11514 // match: (Lsh64x64 _ (Const64 [c])) 11515 // cond: uint64(c) >= 64 11516 // result: (Const64 [0]) 11517 for { 11518 _ = v.Args[1] 11519 v_1 := v.Args[1] 11520 if v_1.Op != OpConst64 { 11521 break 11522 } 11523 c := v_1.AuxInt 11524 if !(uint64(c) >= 64) { 11525 break 11526 } 11527 v.reset(OpConst64) 11528 v.AuxInt = 0 11529 return true 11530 } 11531 // match: (Lsh64x64 <t> (Lsh64x64 x (Const64 [c])) (Const64 [d])) 11532 // cond: !uaddOvf(c,d) 11533 // result: (Lsh64x64 x (Const64 <t> [c+d])) 11534 for { 11535 t := v.Type 11536 _ = v.Args[1] 11537 v_0 := v.Args[0] 11538 if v_0.Op != OpLsh64x64 { 11539 break 11540 } 11541 _ = v_0.Args[1] 11542 x := v_0.Args[0] 11543 v_0_1 := v_0.Args[1] 11544 if v_0_1.Op != OpConst64 { 11545 break 11546 } 11547 c := v_0_1.AuxInt 11548 v_1 := v.Args[1] 11549 if v_1.Op != OpConst64 { 11550 break 11551 } 11552 d := v_1.AuxInt 11553 if !(!uaddOvf(c, d)) { 11554 break 11555 } 11556 v.reset(OpLsh64x64) 11557 v.AddArg(x) 11558 v0 := b.NewValue0(v.Pos, OpConst64, t) 11559 v0.AuxInt = c + d 11560 v.AddArg(v0) 11561 return true 11562 } 11563 // match: (Lsh64x64 (Rsh64Ux64 (Lsh64x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) 11564 // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) 11565 // result: (Lsh64x64 x (Const64 <typ.UInt64> [c1-c2+c3])) 11566 for { 11567 _ = v.Args[1] 11568 v_0 := v.Args[0] 11569 if v_0.Op != OpRsh64Ux64 { 11570 break 11571 } 11572 _ = v_0.Args[1] 11573 v_0_0 := v_0.Args[0] 11574 if v_0_0.Op != OpLsh64x64 { 11575 break 11576 } 11577 _ = v_0_0.Args[1] 11578 x := v_0_0.Args[0] 11579 v_0_0_1 := v_0_0.Args[1] 11580 if v_0_0_1.Op != OpConst64 { 11581 break 11582 } 11583 c1 := v_0_0_1.AuxInt 11584 v_0_1 := v_0.Args[1] 11585 if v_0_1.Op != OpConst64 { 11586 break 11587 } 11588 c2 := v_0_1.AuxInt 11589 v_1 := v.Args[1] 11590 if v_1.Op != OpConst64 { 11591 break 11592 } 11593 c3 := v_1.AuxInt 11594 if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { 11595 break 11596 } 11597 v.reset(OpLsh64x64) 11598 v.AddArg(x) 11599 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 11600 v0.AuxInt = c1 - c2 + c3 11601 v.AddArg(v0) 11602 return true 11603 } 11604 return false 11605 } 11606 func rewriteValuegeneric_OpLsh64x8_0(v *Value) bool { 11607 b := v.Block 11608 _ = b 11609 // match: (Lsh64x8 <t> x (Const8 [c])) 11610 // cond: 11611 // result: (Lsh64x64 x (Const64 <t> [int64(uint8(c))])) 11612 for { 11613 t := v.Type 11614 _ = v.Args[1] 11615 x := v.Args[0] 11616 v_1 := v.Args[1] 11617 if v_1.Op != OpConst8 { 11618 break 11619 } 11620 c := v_1.AuxInt 11621 v.reset(OpLsh64x64) 11622 v.AddArg(x) 11623 v0 := b.NewValue0(v.Pos, OpConst64, t) 11624 v0.AuxInt = int64(uint8(c)) 11625 v.AddArg(v0) 11626 return true 11627 } 11628 // match: (Lsh64x8 (Const64 [0]) _) 11629 // cond: 11630 // result: (Const64 [0]) 11631 for { 11632 _ = v.Args[1] 11633 v_0 := v.Args[0] 11634 if v_0.Op != OpConst64 { 11635 break 11636 } 11637 if v_0.AuxInt != 0 { 11638 break 11639 } 11640 v.reset(OpConst64) 11641 v.AuxInt = 0 11642 return true 11643 } 11644 return false 11645 } 11646 func rewriteValuegeneric_OpLsh8x16_0(v *Value) bool { 11647 b := v.Block 11648 _ = b 11649 // match: (Lsh8x16 <t> x (Const16 [c])) 11650 // cond: 11651 // result: (Lsh8x64 x (Const64 <t> [int64(uint16(c))])) 11652 for { 11653 t := v.Type 11654 _ = v.Args[1] 11655 x := v.Args[0] 11656 v_1 := v.Args[1] 11657 if v_1.Op != OpConst16 { 11658 break 11659 } 11660 c := v_1.AuxInt 11661 v.reset(OpLsh8x64) 11662 v.AddArg(x) 11663 v0 := b.NewValue0(v.Pos, OpConst64, t) 11664 v0.AuxInt = int64(uint16(c)) 11665 v.AddArg(v0) 11666 return true 11667 } 11668 // match: (Lsh8x16 (Const8 [0]) _) 11669 // cond: 11670 // result: (Const8 [0]) 11671 for { 11672 _ = v.Args[1] 11673 v_0 := v.Args[0] 11674 if v_0.Op != OpConst8 { 11675 break 11676 } 11677 if v_0.AuxInt != 0 { 11678 break 11679 } 11680 v.reset(OpConst8) 11681 v.AuxInt = 0 11682 return true 11683 } 11684 return false 11685 } 11686 func rewriteValuegeneric_OpLsh8x32_0(v *Value) bool { 11687 b := v.Block 11688 _ = b 11689 // match: (Lsh8x32 <t> x (Const32 [c])) 11690 // cond: 11691 // result: (Lsh8x64 x (Const64 <t> [int64(uint32(c))])) 11692 for { 11693 t := v.Type 11694 _ = v.Args[1] 11695 x := v.Args[0] 11696 v_1 := v.Args[1] 11697 if v_1.Op != OpConst32 { 11698 break 11699 } 11700 c := v_1.AuxInt 11701 v.reset(OpLsh8x64) 11702 v.AddArg(x) 11703 v0 := b.NewValue0(v.Pos, OpConst64, t) 11704 v0.AuxInt = int64(uint32(c)) 11705 v.AddArg(v0) 11706 return true 11707 } 11708 // match: (Lsh8x32 (Const8 [0]) _) 11709 // cond: 11710 // result: (Const8 [0]) 11711 for { 11712 _ = v.Args[1] 11713 v_0 := v.Args[0] 11714 if v_0.Op != OpConst8 { 11715 break 11716 } 11717 if v_0.AuxInt != 0 { 11718 break 11719 } 11720 v.reset(OpConst8) 11721 v.AuxInt = 0 11722 return true 11723 } 11724 return false 11725 } 11726 func rewriteValuegeneric_OpLsh8x64_0(v *Value) bool { 11727 b := v.Block 11728 _ = b 11729 typ := &b.Func.Config.Types 11730 _ = typ 11731 // match: (Lsh8x64 (Const8 [c]) (Const64 [d])) 11732 // cond: 11733 // result: (Const8 [int64(int8(c) << uint64(d))]) 11734 for { 11735 _ = v.Args[1] 11736 v_0 := v.Args[0] 11737 if v_0.Op != OpConst8 { 11738 break 11739 } 11740 c := v_0.AuxInt 11741 v_1 := v.Args[1] 11742 if v_1.Op != OpConst64 { 11743 break 11744 } 11745 d := v_1.AuxInt 11746 v.reset(OpConst8) 11747 v.AuxInt = int64(int8(c) << uint64(d)) 11748 return true 11749 } 11750 // match: (Lsh8x64 x (Const64 [0])) 11751 // cond: 11752 // result: x 11753 for { 11754 _ = v.Args[1] 11755 x := v.Args[0] 11756 v_1 := v.Args[1] 11757 if v_1.Op != OpConst64 { 11758 break 11759 } 11760 if v_1.AuxInt != 0 { 11761 break 11762 } 11763 v.reset(OpCopy) 11764 v.Type = x.Type 11765 v.AddArg(x) 11766 return true 11767 } 11768 // match: (Lsh8x64 (Const8 [0]) _) 11769 // cond: 11770 // result: (Const8 [0]) 11771 for { 11772 _ = v.Args[1] 11773 v_0 := v.Args[0] 11774 if v_0.Op != OpConst8 { 11775 break 11776 } 11777 if v_0.AuxInt != 0 { 11778 break 11779 } 11780 v.reset(OpConst8) 11781 v.AuxInt = 0 11782 return true 11783 } 11784 // match: (Lsh8x64 _ (Const64 [c])) 11785 // cond: uint64(c) >= 8 11786 // result: (Const8 [0]) 11787 for { 11788 _ = v.Args[1] 11789 v_1 := v.Args[1] 11790 if v_1.Op != OpConst64 { 11791 break 11792 } 11793 c := v_1.AuxInt 11794 if !(uint64(c) >= 8) { 11795 break 11796 } 11797 v.reset(OpConst8) 11798 v.AuxInt = 0 11799 return true 11800 } 11801 // match: (Lsh8x64 <t> (Lsh8x64 x (Const64 [c])) (Const64 [d])) 11802 // cond: !uaddOvf(c,d) 11803 // result: (Lsh8x64 x (Const64 <t> [c+d])) 11804 for { 11805 t := v.Type 11806 _ = v.Args[1] 11807 v_0 := v.Args[0] 11808 if v_0.Op != OpLsh8x64 { 11809 break 11810 } 11811 _ = v_0.Args[1] 11812 x := v_0.Args[0] 11813 v_0_1 := v_0.Args[1] 11814 if v_0_1.Op != OpConst64 { 11815 break 11816 } 11817 c := v_0_1.AuxInt 11818 v_1 := v.Args[1] 11819 if v_1.Op != OpConst64 { 11820 break 11821 } 11822 d := v_1.AuxInt 11823 if !(!uaddOvf(c, d)) { 11824 break 11825 } 11826 v.reset(OpLsh8x64) 11827 v.AddArg(x) 11828 v0 := b.NewValue0(v.Pos, OpConst64, t) 11829 v0.AuxInt = c + d 11830 v.AddArg(v0) 11831 return true 11832 } 11833 // match: (Lsh8x64 (Rsh8Ux64 (Lsh8x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) 11834 // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) 11835 // result: (Lsh8x64 x (Const64 <typ.UInt64> [c1-c2+c3])) 11836 for { 11837 _ = v.Args[1] 11838 v_0 := v.Args[0] 11839 if v_0.Op != OpRsh8Ux64 { 11840 break 11841 } 11842 _ = v_0.Args[1] 11843 v_0_0 := v_0.Args[0] 11844 if v_0_0.Op != OpLsh8x64 { 11845 break 11846 } 11847 _ = v_0_0.Args[1] 11848 x := v_0_0.Args[0] 11849 v_0_0_1 := v_0_0.Args[1] 11850 if v_0_0_1.Op != OpConst64 { 11851 break 11852 } 11853 c1 := v_0_0_1.AuxInt 11854 v_0_1 := v_0.Args[1] 11855 if v_0_1.Op != OpConst64 { 11856 break 11857 } 11858 c2 := v_0_1.AuxInt 11859 v_1 := v.Args[1] 11860 if v_1.Op != OpConst64 { 11861 break 11862 } 11863 c3 := v_1.AuxInt 11864 if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { 11865 break 11866 } 11867 v.reset(OpLsh8x64) 11868 v.AddArg(x) 11869 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 11870 v0.AuxInt = c1 - c2 + c3 11871 v.AddArg(v0) 11872 return true 11873 } 11874 return false 11875 } 11876 func rewriteValuegeneric_OpLsh8x8_0(v *Value) bool { 11877 b := v.Block 11878 _ = b 11879 // match: (Lsh8x8 <t> x (Const8 [c])) 11880 // cond: 11881 // result: (Lsh8x64 x (Const64 <t> [int64(uint8(c))])) 11882 for { 11883 t := v.Type 11884 _ = v.Args[1] 11885 x := v.Args[0] 11886 v_1 := v.Args[1] 11887 if v_1.Op != OpConst8 { 11888 break 11889 } 11890 c := v_1.AuxInt 11891 v.reset(OpLsh8x64) 11892 v.AddArg(x) 11893 v0 := b.NewValue0(v.Pos, OpConst64, t) 11894 v0.AuxInt = int64(uint8(c)) 11895 v.AddArg(v0) 11896 return true 11897 } 11898 // match: (Lsh8x8 (Const8 [0]) _) 11899 // cond: 11900 // result: (Const8 [0]) 11901 for { 11902 _ = v.Args[1] 11903 v_0 := v.Args[0] 11904 if v_0.Op != OpConst8 { 11905 break 11906 } 11907 if v_0.AuxInt != 0 { 11908 break 11909 } 11910 v.reset(OpConst8) 11911 v.AuxInt = 0 11912 return true 11913 } 11914 return false 11915 } 11916 func rewriteValuegeneric_OpMod16_0(v *Value) bool { 11917 b := v.Block 11918 _ = b 11919 // match: (Mod16 (Const16 [c]) (Const16 [d])) 11920 // cond: d != 0 11921 // result: (Const16 [int64(int16(c % d))]) 11922 for { 11923 _ = v.Args[1] 11924 v_0 := v.Args[0] 11925 if v_0.Op != OpConst16 { 11926 break 11927 } 11928 c := v_0.AuxInt 11929 v_1 := v.Args[1] 11930 if v_1.Op != OpConst16 { 11931 break 11932 } 11933 d := v_1.AuxInt 11934 if !(d != 0) { 11935 break 11936 } 11937 v.reset(OpConst16) 11938 v.AuxInt = int64(int16(c % d)) 11939 return true 11940 } 11941 // match: (Mod16 <t> n (Const16 [c])) 11942 // cond: c < 0 && c != -1<<15 11943 // result: (Mod16 <t> n (Const16 <t> [-c])) 11944 for { 11945 t := v.Type 11946 _ = v.Args[1] 11947 n := v.Args[0] 11948 v_1 := v.Args[1] 11949 if v_1.Op != OpConst16 { 11950 break 11951 } 11952 c := v_1.AuxInt 11953 if !(c < 0 && c != -1<<15) { 11954 break 11955 } 11956 v.reset(OpMod16) 11957 v.Type = t 11958 v.AddArg(n) 11959 v0 := b.NewValue0(v.Pos, OpConst16, t) 11960 v0.AuxInt = -c 11961 v.AddArg(v0) 11962 return true 11963 } 11964 // match: (Mod16 <t> x (Const16 [c])) 11965 // cond: x.Op != OpConst16 && (c > 0 || c == -1<<15) 11966 // result: (Sub16 x (Mul16 <t> (Div16 <t> x (Const16 <t> [c])) (Const16 <t> [c]))) 11967 for { 11968 t := v.Type 11969 _ = v.Args[1] 11970 x := v.Args[0] 11971 v_1 := v.Args[1] 11972 if v_1.Op != OpConst16 { 11973 break 11974 } 11975 c := v_1.AuxInt 11976 if !(x.Op != OpConst16 && (c > 0 || c == -1<<15)) { 11977 break 11978 } 11979 v.reset(OpSub16) 11980 v.AddArg(x) 11981 v0 := b.NewValue0(v.Pos, OpMul16, t) 11982 v1 := b.NewValue0(v.Pos, OpDiv16, t) 11983 v1.AddArg(x) 11984 v2 := b.NewValue0(v.Pos, OpConst16, t) 11985 v2.AuxInt = c 11986 v1.AddArg(v2) 11987 v0.AddArg(v1) 11988 v3 := b.NewValue0(v.Pos, OpConst16, t) 11989 v3.AuxInt = c 11990 v0.AddArg(v3) 11991 v.AddArg(v0) 11992 return true 11993 } 11994 return false 11995 } 11996 func rewriteValuegeneric_OpMod16u_0(v *Value) bool { 11997 b := v.Block 11998 _ = b 11999 // match: (Mod16u (Const16 [c]) (Const16 [d])) 12000 // cond: d != 0 12001 // result: (Const16 [int64(uint16(c) % uint16(d))]) 12002 for { 12003 _ = v.Args[1] 12004 v_0 := v.Args[0] 12005 if v_0.Op != OpConst16 { 12006 break 12007 } 12008 c := v_0.AuxInt 12009 v_1 := v.Args[1] 12010 if v_1.Op != OpConst16 { 12011 break 12012 } 12013 d := v_1.AuxInt 12014 if !(d != 0) { 12015 break 12016 } 12017 v.reset(OpConst16) 12018 v.AuxInt = int64(uint16(c) % uint16(d)) 12019 return true 12020 } 12021 // match: (Mod16u <t> n (Const16 [c])) 12022 // cond: isPowerOfTwo(c&0xffff) 12023 // result: (And16 n (Const16 <t> [(c&0xffff)-1])) 12024 for { 12025 t := v.Type 12026 _ = v.Args[1] 12027 n := v.Args[0] 12028 v_1 := v.Args[1] 12029 if v_1.Op != OpConst16 { 12030 break 12031 } 12032 c := v_1.AuxInt 12033 if !(isPowerOfTwo(c & 0xffff)) { 12034 break 12035 } 12036 v.reset(OpAnd16) 12037 v.AddArg(n) 12038 v0 := b.NewValue0(v.Pos, OpConst16, t) 12039 v0.AuxInt = (c & 0xffff) - 1 12040 v.AddArg(v0) 12041 return true 12042 } 12043 // match: (Mod16u <t> x (Const16 [c])) 12044 // cond: x.Op != OpConst16 && c > 0 && umagicOK(16,c) 12045 // result: (Sub16 x (Mul16 <t> (Div16u <t> x (Const16 <t> [c])) (Const16 <t> [c]))) 12046 for { 12047 t := v.Type 12048 _ = v.Args[1] 12049 x := v.Args[0] 12050 v_1 := v.Args[1] 12051 if v_1.Op != OpConst16 { 12052 break 12053 } 12054 c := v_1.AuxInt 12055 if !(x.Op != OpConst16 && c > 0 && umagicOK(16, c)) { 12056 break 12057 } 12058 v.reset(OpSub16) 12059 v.AddArg(x) 12060 v0 := b.NewValue0(v.Pos, OpMul16, t) 12061 v1 := b.NewValue0(v.Pos, OpDiv16u, t) 12062 v1.AddArg(x) 12063 v2 := b.NewValue0(v.Pos, OpConst16, t) 12064 v2.AuxInt = c 12065 v1.AddArg(v2) 12066 v0.AddArg(v1) 12067 v3 := b.NewValue0(v.Pos, OpConst16, t) 12068 v3.AuxInt = c 12069 v0.AddArg(v3) 12070 v.AddArg(v0) 12071 return true 12072 } 12073 return false 12074 } 12075 func rewriteValuegeneric_OpMod32_0(v *Value) bool { 12076 b := v.Block 12077 _ = b 12078 // match: (Mod32 (Const32 [c]) (Const32 [d])) 12079 // cond: d != 0 12080 // result: (Const32 [int64(int32(c % d))]) 12081 for { 12082 _ = v.Args[1] 12083 v_0 := v.Args[0] 12084 if v_0.Op != OpConst32 { 12085 break 12086 } 12087 c := v_0.AuxInt 12088 v_1 := v.Args[1] 12089 if v_1.Op != OpConst32 { 12090 break 12091 } 12092 d := v_1.AuxInt 12093 if !(d != 0) { 12094 break 12095 } 12096 v.reset(OpConst32) 12097 v.AuxInt = int64(int32(c % d)) 12098 return true 12099 } 12100 // match: (Mod32 <t> n (Const32 [c])) 12101 // cond: c < 0 && c != -1<<31 12102 // result: (Mod32 <t> n (Const32 <t> [-c])) 12103 for { 12104 t := v.Type 12105 _ = v.Args[1] 12106 n := v.Args[0] 12107 v_1 := v.Args[1] 12108 if v_1.Op != OpConst32 { 12109 break 12110 } 12111 c := v_1.AuxInt 12112 if !(c < 0 && c != -1<<31) { 12113 break 12114 } 12115 v.reset(OpMod32) 12116 v.Type = t 12117 v.AddArg(n) 12118 v0 := b.NewValue0(v.Pos, OpConst32, t) 12119 v0.AuxInt = -c 12120 v.AddArg(v0) 12121 return true 12122 } 12123 // match: (Mod32 <t> x (Const32 [c])) 12124 // cond: x.Op != OpConst32 && (c > 0 || c == -1<<31) 12125 // result: (Sub32 x (Mul32 <t> (Div32 <t> x (Const32 <t> [c])) (Const32 <t> [c]))) 12126 for { 12127 t := v.Type 12128 _ = v.Args[1] 12129 x := v.Args[0] 12130 v_1 := v.Args[1] 12131 if v_1.Op != OpConst32 { 12132 break 12133 } 12134 c := v_1.AuxInt 12135 if !(x.Op != OpConst32 && (c > 0 || c == -1<<31)) { 12136 break 12137 } 12138 v.reset(OpSub32) 12139 v.AddArg(x) 12140 v0 := b.NewValue0(v.Pos, OpMul32, t) 12141 v1 := b.NewValue0(v.Pos, OpDiv32, t) 12142 v1.AddArg(x) 12143 v2 := b.NewValue0(v.Pos, OpConst32, t) 12144 v2.AuxInt = c 12145 v1.AddArg(v2) 12146 v0.AddArg(v1) 12147 v3 := b.NewValue0(v.Pos, OpConst32, t) 12148 v3.AuxInt = c 12149 v0.AddArg(v3) 12150 v.AddArg(v0) 12151 return true 12152 } 12153 return false 12154 } 12155 func rewriteValuegeneric_OpMod32u_0(v *Value) bool { 12156 b := v.Block 12157 _ = b 12158 // match: (Mod32u (Const32 [c]) (Const32 [d])) 12159 // cond: d != 0 12160 // result: (Const32 [int64(uint32(c) % uint32(d))]) 12161 for { 12162 _ = v.Args[1] 12163 v_0 := v.Args[0] 12164 if v_0.Op != OpConst32 { 12165 break 12166 } 12167 c := v_0.AuxInt 12168 v_1 := v.Args[1] 12169 if v_1.Op != OpConst32 { 12170 break 12171 } 12172 d := v_1.AuxInt 12173 if !(d != 0) { 12174 break 12175 } 12176 v.reset(OpConst32) 12177 v.AuxInt = int64(uint32(c) % uint32(d)) 12178 return true 12179 } 12180 // match: (Mod32u <t> n (Const32 [c])) 12181 // cond: isPowerOfTwo(c&0xffffffff) 12182 // result: (And32 n (Const32 <t> [(c&0xffffffff)-1])) 12183 for { 12184 t := v.Type 12185 _ = v.Args[1] 12186 n := v.Args[0] 12187 v_1 := v.Args[1] 12188 if v_1.Op != OpConst32 { 12189 break 12190 } 12191 c := v_1.AuxInt 12192 if !(isPowerOfTwo(c & 0xffffffff)) { 12193 break 12194 } 12195 v.reset(OpAnd32) 12196 v.AddArg(n) 12197 v0 := b.NewValue0(v.Pos, OpConst32, t) 12198 v0.AuxInt = (c & 0xffffffff) - 1 12199 v.AddArg(v0) 12200 return true 12201 } 12202 // match: (Mod32u <t> x (Const32 [c])) 12203 // cond: x.Op != OpConst32 && c > 0 && umagicOK(32,c) 12204 // result: (Sub32 x (Mul32 <t> (Div32u <t> x (Const32 <t> [c])) (Const32 <t> [c]))) 12205 for { 12206 t := v.Type 12207 _ = v.Args[1] 12208 x := v.Args[0] 12209 v_1 := v.Args[1] 12210 if v_1.Op != OpConst32 { 12211 break 12212 } 12213 c := v_1.AuxInt 12214 if !(x.Op != OpConst32 && c > 0 && umagicOK(32, c)) { 12215 break 12216 } 12217 v.reset(OpSub32) 12218 v.AddArg(x) 12219 v0 := b.NewValue0(v.Pos, OpMul32, t) 12220 v1 := b.NewValue0(v.Pos, OpDiv32u, t) 12221 v1.AddArg(x) 12222 v2 := b.NewValue0(v.Pos, OpConst32, t) 12223 v2.AuxInt = c 12224 v1.AddArg(v2) 12225 v0.AddArg(v1) 12226 v3 := b.NewValue0(v.Pos, OpConst32, t) 12227 v3.AuxInt = c 12228 v0.AddArg(v3) 12229 v.AddArg(v0) 12230 return true 12231 } 12232 return false 12233 } 12234 func rewriteValuegeneric_OpMod64_0(v *Value) bool { 12235 b := v.Block 12236 _ = b 12237 // match: (Mod64 (Const64 [c]) (Const64 [d])) 12238 // cond: d != 0 12239 // result: (Const64 [c % d]) 12240 for { 12241 _ = v.Args[1] 12242 v_0 := v.Args[0] 12243 if v_0.Op != OpConst64 { 12244 break 12245 } 12246 c := v_0.AuxInt 12247 v_1 := v.Args[1] 12248 if v_1.Op != OpConst64 { 12249 break 12250 } 12251 d := v_1.AuxInt 12252 if !(d != 0) { 12253 break 12254 } 12255 v.reset(OpConst64) 12256 v.AuxInt = c % d 12257 return true 12258 } 12259 // match: (Mod64 <t> n (Const64 [c])) 12260 // cond: c < 0 && c != -1<<63 12261 // result: (Mod64 <t> n (Const64 <t> [-c])) 12262 for { 12263 t := v.Type 12264 _ = v.Args[1] 12265 n := v.Args[0] 12266 v_1 := v.Args[1] 12267 if v_1.Op != OpConst64 { 12268 break 12269 } 12270 c := v_1.AuxInt 12271 if !(c < 0 && c != -1<<63) { 12272 break 12273 } 12274 v.reset(OpMod64) 12275 v.Type = t 12276 v.AddArg(n) 12277 v0 := b.NewValue0(v.Pos, OpConst64, t) 12278 v0.AuxInt = -c 12279 v.AddArg(v0) 12280 return true 12281 } 12282 // match: (Mod64 <t> x (Const64 [c])) 12283 // cond: x.Op != OpConst64 && (c > 0 || c == -1<<63) 12284 // result: (Sub64 x (Mul64 <t> (Div64 <t> x (Const64 <t> [c])) (Const64 <t> [c]))) 12285 for { 12286 t := v.Type 12287 _ = v.Args[1] 12288 x := v.Args[0] 12289 v_1 := v.Args[1] 12290 if v_1.Op != OpConst64 { 12291 break 12292 } 12293 c := v_1.AuxInt 12294 if !(x.Op != OpConst64 && (c > 0 || c == -1<<63)) { 12295 break 12296 } 12297 v.reset(OpSub64) 12298 v.AddArg(x) 12299 v0 := b.NewValue0(v.Pos, OpMul64, t) 12300 v1 := b.NewValue0(v.Pos, OpDiv64, t) 12301 v1.AddArg(x) 12302 v2 := b.NewValue0(v.Pos, OpConst64, t) 12303 v2.AuxInt = c 12304 v1.AddArg(v2) 12305 v0.AddArg(v1) 12306 v3 := b.NewValue0(v.Pos, OpConst64, t) 12307 v3.AuxInt = c 12308 v0.AddArg(v3) 12309 v.AddArg(v0) 12310 return true 12311 } 12312 return false 12313 } 12314 func rewriteValuegeneric_OpMod64u_0(v *Value) bool { 12315 b := v.Block 12316 _ = b 12317 // match: (Mod64u (Const64 [c]) (Const64 [d])) 12318 // cond: d != 0 12319 // result: (Const64 [int64(uint64(c) % uint64(d))]) 12320 for { 12321 _ = v.Args[1] 12322 v_0 := v.Args[0] 12323 if v_0.Op != OpConst64 { 12324 break 12325 } 12326 c := v_0.AuxInt 12327 v_1 := v.Args[1] 12328 if v_1.Op != OpConst64 { 12329 break 12330 } 12331 d := v_1.AuxInt 12332 if !(d != 0) { 12333 break 12334 } 12335 v.reset(OpConst64) 12336 v.AuxInt = int64(uint64(c) % uint64(d)) 12337 return true 12338 } 12339 // match: (Mod64u <t> n (Const64 [c])) 12340 // cond: isPowerOfTwo(c) 12341 // result: (And64 n (Const64 <t> [c-1])) 12342 for { 12343 t := v.Type 12344 _ = v.Args[1] 12345 n := v.Args[0] 12346 v_1 := v.Args[1] 12347 if v_1.Op != OpConst64 { 12348 break 12349 } 12350 c := v_1.AuxInt 12351 if !(isPowerOfTwo(c)) { 12352 break 12353 } 12354 v.reset(OpAnd64) 12355 v.AddArg(n) 12356 v0 := b.NewValue0(v.Pos, OpConst64, t) 12357 v0.AuxInt = c - 1 12358 v.AddArg(v0) 12359 return true 12360 } 12361 // match: (Mod64u <t> x (Const64 [c])) 12362 // cond: x.Op != OpConst64 && c > 0 && umagicOK(64,c) 12363 // result: (Sub64 x (Mul64 <t> (Div64u <t> x (Const64 <t> [c])) (Const64 <t> [c]))) 12364 for { 12365 t := v.Type 12366 _ = v.Args[1] 12367 x := v.Args[0] 12368 v_1 := v.Args[1] 12369 if v_1.Op != OpConst64 { 12370 break 12371 } 12372 c := v_1.AuxInt 12373 if !(x.Op != OpConst64 && c > 0 && umagicOK(64, c)) { 12374 break 12375 } 12376 v.reset(OpSub64) 12377 v.AddArg(x) 12378 v0 := b.NewValue0(v.Pos, OpMul64, t) 12379 v1 := b.NewValue0(v.Pos, OpDiv64u, t) 12380 v1.AddArg(x) 12381 v2 := b.NewValue0(v.Pos, OpConst64, t) 12382 v2.AuxInt = c 12383 v1.AddArg(v2) 12384 v0.AddArg(v1) 12385 v3 := b.NewValue0(v.Pos, OpConst64, t) 12386 v3.AuxInt = c 12387 v0.AddArg(v3) 12388 v.AddArg(v0) 12389 return true 12390 } 12391 return false 12392 } 12393 func rewriteValuegeneric_OpMod8_0(v *Value) bool { 12394 b := v.Block 12395 _ = b 12396 // match: (Mod8 (Const8 [c]) (Const8 [d])) 12397 // cond: d != 0 12398 // result: (Const8 [int64(int8(c % d))]) 12399 for { 12400 _ = v.Args[1] 12401 v_0 := v.Args[0] 12402 if v_0.Op != OpConst8 { 12403 break 12404 } 12405 c := v_0.AuxInt 12406 v_1 := v.Args[1] 12407 if v_1.Op != OpConst8 { 12408 break 12409 } 12410 d := v_1.AuxInt 12411 if !(d != 0) { 12412 break 12413 } 12414 v.reset(OpConst8) 12415 v.AuxInt = int64(int8(c % d)) 12416 return true 12417 } 12418 // match: (Mod8 <t> n (Const8 [c])) 12419 // cond: c < 0 && c != -1<<7 12420 // result: (Mod8 <t> n (Const8 <t> [-c])) 12421 for { 12422 t := v.Type 12423 _ = v.Args[1] 12424 n := v.Args[0] 12425 v_1 := v.Args[1] 12426 if v_1.Op != OpConst8 { 12427 break 12428 } 12429 c := v_1.AuxInt 12430 if !(c < 0 && c != -1<<7) { 12431 break 12432 } 12433 v.reset(OpMod8) 12434 v.Type = t 12435 v.AddArg(n) 12436 v0 := b.NewValue0(v.Pos, OpConst8, t) 12437 v0.AuxInt = -c 12438 v.AddArg(v0) 12439 return true 12440 } 12441 // match: (Mod8 <t> x (Const8 [c])) 12442 // cond: x.Op != OpConst8 && (c > 0 || c == -1<<7) 12443 // result: (Sub8 x (Mul8 <t> (Div8 <t> x (Const8 <t> [c])) (Const8 <t> [c]))) 12444 for { 12445 t := v.Type 12446 _ = v.Args[1] 12447 x := v.Args[0] 12448 v_1 := v.Args[1] 12449 if v_1.Op != OpConst8 { 12450 break 12451 } 12452 c := v_1.AuxInt 12453 if !(x.Op != OpConst8 && (c > 0 || c == -1<<7)) { 12454 break 12455 } 12456 v.reset(OpSub8) 12457 v.AddArg(x) 12458 v0 := b.NewValue0(v.Pos, OpMul8, t) 12459 v1 := b.NewValue0(v.Pos, OpDiv8, t) 12460 v1.AddArg(x) 12461 v2 := b.NewValue0(v.Pos, OpConst8, t) 12462 v2.AuxInt = c 12463 v1.AddArg(v2) 12464 v0.AddArg(v1) 12465 v3 := b.NewValue0(v.Pos, OpConst8, t) 12466 v3.AuxInt = c 12467 v0.AddArg(v3) 12468 v.AddArg(v0) 12469 return true 12470 } 12471 return false 12472 } 12473 func rewriteValuegeneric_OpMod8u_0(v *Value) bool { 12474 b := v.Block 12475 _ = b 12476 // match: (Mod8u (Const8 [c]) (Const8 [d])) 12477 // cond: d != 0 12478 // result: (Const8 [int64(uint8(c) % uint8(d))]) 12479 for { 12480 _ = v.Args[1] 12481 v_0 := v.Args[0] 12482 if v_0.Op != OpConst8 { 12483 break 12484 } 12485 c := v_0.AuxInt 12486 v_1 := v.Args[1] 12487 if v_1.Op != OpConst8 { 12488 break 12489 } 12490 d := v_1.AuxInt 12491 if !(d != 0) { 12492 break 12493 } 12494 v.reset(OpConst8) 12495 v.AuxInt = int64(uint8(c) % uint8(d)) 12496 return true 12497 } 12498 // match: (Mod8u <t> n (Const8 [c])) 12499 // cond: isPowerOfTwo(c&0xff) 12500 // result: (And8 n (Const8 <t> [(c&0xff)-1])) 12501 for { 12502 t := v.Type 12503 _ = v.Args[1] 12504 n := v.Args[0] 12505 v_1 := v.Args[1] 12506 if v_1.Op != OpConst8 { 12507 break 12508 } 12509 c := v_1.AuxInt 12510 if !(isPowerOfTwo(c & 0xff)) { 12511 break 12512 } 12513 v.reset(OpAnd8) 12514 v.AddArg(n) 12515 v0 := b.NewValue0(v.Pos, OpConst8, t) 12516 v0.AuxInt = (c & 0xff) - 1 12517 v.AddArg(v0) 12518 return true 12519 } 12520 // match: (Mod8u <t> x (Const8 [c])) 12521 // cond: x.Op != OpConst8 && c > 0 && umagicOK(8 ,c) 12522 // result: (Sub8 x (Mul8 <t> (Div8u <t> x (Const8 <t> [c])) (Const8 <t> [c]))) 12523 for { 12524 t := v.Type 12525 _ = v.Args[1] 12526 x := v.Args[0] 12527 v_1 := v.Args[1] 12528 if v_1.Op != OpConst8 { 12529 break 12530 } 12531 c := v_1.AuxInt 12532 if !(x.Op != OpConst8 && c > 0 && umagicOK(8, c)) { 12533 break 12534 } 12535 v.reset(OpSub8) 12536 v.AddArg(x) 12537 v0 := b.NewValue0(v.Pos, OpMul8, t) 12538 v1 := b.NewValue0(v.Pos, OpDiv8u, t) 12539 v1.AddArg(x) 12540 v2 := b.NewValue0(v.Pos, OpConst8, t) 12541 v2.AuxInt = c 12542 v1.AddArg(v2) 12543 v0.AddArg(v1) 12544 v3 := b.NewValue0(v.Pos, OpConst8, t) 12545 v3.AuxInt = c 12546 v0.AddArg(v3) 12547 v.AddArg(v0) 12548 return true 12549 } 12550 return false 12551 } 12552 func rewriteValuegeneric_OpMul16_0(v *Value) bool { 12553 b := v.Block 12554 _ = b 12555 typ := &b.Func.Config.Types 12556 _ = typ 12557 // match: (Mul16 (Const16 [c]) (Const16 [d])) 12558 // cond: 12559 // result: (Const16 [int64(int16(c*d))]) 12560 for { 12561 _ = v.Args[1] 12562 v_0 := v.Args[0] 12563 if v_0.Op != OpConst16 { 12564 break 12565 } 12566 c := v_0.AuxInt 12567 v_1 := v.Args[1] 12568 if v_1.Op != OpConst16 { 12569 break 12570 } 12571 d := v_1.AuxInt 12572 v.reset(OpConst16) 12573 v.AuxInt = int64(int16(c * d)) 12574 return true 12575 } 12576 // match: (Mul16 (Const16 [d]) (Const16 [c])) 12577 // cond: 12578 // result: (Const16 [int64(int16(c*d))]) 12579 for { 12580 _ = v.Args[1] 12581 v_0 := v.Args[0] 12582 if v_0.Op != OpConst16 { 12583 break 12584 } 12585 d := v_0.AuxInt 12586 v_1 := v.Args[1] 12587 if v_1.Op != OpConst16 { 12588 break 12589 } 12590 c := v_1.AuxInt 12591 v.reset(OpConst16) 12592 v.AuxInt = int64(int16(c * d)) 12593 return true 12594 } 12595 // match: (Mul16 (Const16 [1]) x) 12596 // cond: 12597 // result: x 12598 for { 12599 _ = v.Args[1] 12600 v_0 := v.Args[0] 12601 if v_0.Op != OpConst16 { 12602 break 12603 } 12604 if v_0.AuxInt != 1 { 12605 break 12606 } 12607 x := v.Args[1] 12608 v.reset(OpCopy) 12609 v.Type = x.Type 12610 v.AddArg(x) 12611 return true 12612 } 12613 // match: (Mul16 x (Const16 [1])) 12614 // cond: 12615 // result: x 12616 for { 12617 _ = v.Args[1] 12618 x := v.Args[0] 12619 v_1 := v.Args[1] 12620 if v_1.Op != OpConst16 { 12621 break 12622 } 12623 if v_1.AuxInt != 1 { 12624 break 12625 } 12626 v.reset(OpCopy) 12627 v.Type = x.Type 12628 v.AddArg(x) 12629 return true 12630 } 12631 // match: (Mul16 (Const16 [-1]) x) 12632 // cond: 12633 // result: (Neg16 x) 12634 for { 12635 _ = v.Args[1] 12636 v_0 := v.Args[0] 12637 if v_0.Op != OpConst16 { 12638 break 12639 } 12640 if v_0.AuxInt != -1 { 12641 break 12642 } 12643 x := v.Args[1] 12644 v.reset(OpNeg16) 12645 v.AddArg(x) 12646 return true 12647 } 12648 // match: (Mul16 x (Const16 [-1])) 12649 // cond: 12650 // result: (Neg16 x) 12651 for { 12652 _ = v.Args[1] 12653 x := v.Args[0] 12654 v_1 := v.Args[1] 12655 if v_1.Op != OpConst16 { 12656 break 12657 } 12658 if v_1.AuxInt != -1 { 12659 break 12660 } 12661 v.reset(OpNeg16) 12662 v.AddArg(x) 12663 return true 12664 } 12665 // match: (Mul16 <t> n (Const16 [c])) 12666 // cond: isPowerOfTwo(c) 12667 // result: (Lsh16x64 <t> n (Const64 <typ.UInt64> [log2(c)])) 12668 for { 12669 t := v.Type 12670 _ = v.Args[1] 12671 n := v.Args[0] 12672 v_1 := v.Args[1] 12673 if v_1.Op != OpConst16 { 12674 break 12675 } 12676 c := v_1.AuxInt 12677 if !(isPowerOfTwo(c)) { 12678 break 12679 } 12680 v.reset(OpLsh16x64) 12681 v.Type = t 12682 v.AddArg(n) 12683 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 12684 v0.AuxInt = log2(c) 12685 v.AddArg(v0) 12686 return true 12687 } 12688 // match: (Mul16 <t> (Const16 [c]) n) 12689 // cond: isPowerOfTwo(c) 12690 // result: (Lsh16x64 <t> n (Const64 <typ.UInt64> [log2(c)])) 12691 for { 12692 t := v.Type 12693 _ = v.Args[1] 12694 v_0 := v.Args[0] 12695 if v_0.Op != OpConst16 { 12696 break 12697 } 12698 c := v_0.AuxInt 12699 n := v.Args[1] 12700 if !(isPowerOfTwo(c)) { 12701 break 12702 } 12703 v.reset(OpLsh16x64) 12704 v.Type = t 12705 v.AddArg(n) 12706 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 12707 v0.AuxInt = log2(c) 12708 v.AddArg(v0) 12709 return true 12710 } 12711 // match: (Mul16 <t> n (Const16 [c])) 12712 // cond: t.IsSigned() && isPowerOfTwo(-c) 12713 // result: (Neg16 (Lsh16x64 <t> n (Const64 <typ.UInt64> [log2(-c)]))) 12714 for { 12715 t := v.Type 12716 _ = v.Args[1] 12717 n := v.Args[0] 12718 v_1 := v.Args[1] 12719 if v_1.Op != OpConst16 { 12720 break 12721 } 12722 c := v_1.AuxInt 12723 if !(t.IsSigned() && isPowerOfTwo(-c)) { 12724 break 12725 } 12726 v.reset(OpNeg16) 12727 v0 := b.NewValue0(v.Pos, OpLsh16x64, t) 12728 v0.AddArg(n) 12729 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 12730 v1.AuxInt = log2(-c) 12731 v0.AddArg(v1) 12732 v.AddArg(v0) 12733 return true 12734 } 12735 // match: (Mul16 <t> (Const16 [c]) n) 12736 // cond: t.IsSigned() && isPowerOfTwo(-c) 12737 // result: (Neg16 (Lsh16x64 <t> n (Const64 <typ.UInt64> [log2(-c)]))) 12738 for { 12739 t := v.Type 12740 _ = v.Args[1] 12741 v_0 := v.Args[0] 12742 if v_0.Op != OpConst16 { 12743 break 12744 } 12745 c := v_0.AuxInt 12746 n := v.Args[1] 12747 if !(t.IsSigned() && isPowerOfTwo(-c)) { 12748 break 12749 } 12750 v.reset(OpNeg16) 12751 v0 := b.NewValue0(v.Pos, OpLsh16x64, t) 12752 v0.AddArg(n) 12753 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 12754 v1.AuxInt = log2(-c) 12755 v0.AddArg(v1) 12756 v.AddArg(v0) 12757 return true 12758 } 12759 return false 12760 } 12761 func rewriteValuegeneric_OpMul16_10(v *Value) bool { 12762 b := v.Block 12763 _ = b 12764 // match: (Mul16 (Const16 [0]) _) 12765 // cond: 12766 // result: (Const16 [0]) 12767 for { 12768 _ = v.Args[1] 12769 v_0 := v.Args[0] 12770 if v_0.Op != OpConst16 { 12771 break 12772 } 12773 if v_0.AuxInt != 0 { 12774 break 12775 } 12776 v.reset(OpConst16) 12777 v.AuxInt = 0 12778 return true 12779 } 12780 // match: (Mul16 _ (Const16 [0])) 12781 // cond: 12782 // result: (Const16 [0]) 12783 for { 12784 _ = v.Args[1] 12785 v_1 := v.Args[1] 12786 if v_1.Op != OpConst16 { 12787 break 12788 } 12789 if v_1.AuxInt != 0 { 12790 break 12791 } 12792 v.reset(OpConst16) 12793 v.AuxInt = 0 12794 return true 12795 } 12796 // match: (Mul16 (Const16 <t> [c]) (Mul16 (Const16 <t> [d]) x)) 12797 // cond: 12798 // result: (Mul16 (Const16 <t> [int64(int16(c*d))]) x) 12799 for { 12800 _ = v.Args[1] 12801 v_0 := v.Args[0] 12802 if v_0.Op != OpConst16 { 12803 break 12804 } 12805 t := v_0.Type 12806 c := v_0.AuxInt 12807 v_1 := v.Args[1] 12808 if v_1.Op != OpMul16 { 12809 break 12810 } 12811 _ = v_1.Args[1] 12812 v_1_0 := v_1.Args[0] 12813 if v_1_0.Op != OpConst16 { 12814 break 12815 } 12816 if v_1_0.Type != t { 12817 break 12818 } 12819 d := v_1_0.AuxInt 12820 x := v_1.Args[1] 12821 v.reset(OpMul16) 12822 v0 := b.NewValue0(v.Pos, OpConst16, t) 12823 v0.AuxInt = int64(int16(c * d)) 12824 v.AddArg(v0) 12825 v.AddArg(x) 12826 return true 12827 } 12828 // match: (Mul16 (Const16 <t> [c]) (Mul16 x (Const16 <t> [d]))) 12829 // cond: 12830 // result: (Mul16 (Const16 <t> [int64(int16(c*d))]) x) 12831 for { 12832 _ = v.Args[1] 12833 v_0 := v.Args[0] 12834 if v_0.Op != OpConst16 { 12835 break 12836 } 12837 t := v_0.Type 12838 c := v_0.AuxInt 12839 v_1 := v.Args[1] 12840 if v_1.Op != OpMul16 { 12841 break 12842 } 12843 _ = v_1.Args[1] 12844 x := v_1.Args[0] 12845 v_1_1 := v_1.Args[1] 12846 if v_1_1.Op != OpConst16 { 12847 break 12848 } 12849 if v_1_1.Type != t { 12850 break 12851 } 12852 d := v_1_1.AuxInt 12853 v.reset(OpMul16) 12854 v0 := b.NewValue0(v.Pos, OpConst16, t) 12855 v0.AuxInt = int64(int16(c * d)) 12856 v.AddArg(v0) 12857 v.AddArg(x) 12858 return true 12859 } 12860 // match: (Mul16 (Mul16 (Const16 <t> [d]) x) (Const16 <t> [c])) 12861 // cond: 12862 // result: (Mul16 (Const16 <t> [int64(int16(c*d))]) x) 12863 for { 12864 _ = v.Args[1] 12865 v_0 := v.Args[0] 12866 if v_0.Op != OpMul16 { 12867 break 12868 } 12869 _ = v_0.Args[1] 12870 v_0_0 := v_0.Args[0] 12871 if v_0_0.Op != OpConst16 { 12872 break 12873 } 12874 t := v_0_0.Type 12875 d := v_0_0.AuxInt 12876 x := v_0.Args[1] 12877 v_1 := v.Args[1] 12878 if v_1.Op != OpConst16 { 12879 break 12880 } 12881 if v_1.Type != t { 12882 break 12883 } 12884 c := v_1.AuxInt 12885 v.reset(OpMul16) 12886 v0 := b.NewValue0(v.Pos, OpConst16, t) 12887 v0.AuxInt = int64(int16(c * d)) 12888 v.AddArg(v0) 12889 v.AddArg(x) 12890 return true 12891 } 12892 // match: (Mul16 (Mul16 x (Const16 <t> [d])) (Const16 <t> [c])) 12893 // cond: 12894 // result: (Mul16 (Const16 <t> [int64(int16(c*d))]) x) 12895 for { 12896 _ = v.Args[1] 12897 v_0 := v.Args[0] 12898 if v_0.Op != OpMul16 { 12899 break 12900 } 12901 _ = v_0.Args[1] 12902 x := v_0.Args[0] 12903 v_0_1 := v_0.Args[1] 12904 if v_0_1.Op != OpConst16 { 12905 break 12906 } 12907 t := v_0_1.Type 12908 d := v_0_1.AuxInt 12909 v_1 := v.Args[1] 12910 if v_1.Op != OpConst16 { 12911 break 12912 } 12913 if v_1.Type != t { 12914 break 12915 } 12916 c := v_1.AuxInt 12917 v.reset(OpMul16) 12918 v0 := b.NewValue0(v.Pos, OpConst16, t) 12919 v0.AuxInt = int64(int16(c * d)) 12920 v.AddArg(v0) 12921 v.AddArg(x) 12922 return true 12923 } 12924 return false 12925 } 12926 func rewriteValuegeneric_OpMul32_0(v *Value) bool { 12927 b := v.Block 12928 _ = b 12929 typ := &b.Func.Config.Types 12930 _ = typ 12931 // match: (Mul32 (Const32 [c]) (Const32 [d])) 12932 // cond: 12933 // result: (Const32 [int64(int32(c*d))]) 12934 for { 12935 _ = v.Args[1] 12936 v_0 := v.Args[0] 12937 if v_0.Op != OpConst32 { 12938 break 12939 } 12940 c := v_0.AuxInt 12941 v_1 := v.Args[1] 12942 if v_1.Op != OpConst32 { 12943 break 12944 } 12945 d := v_1.AuxInt 12946 v.reset(OpConst32) 12947 v.AuxInt = int64(int32(c * d)) 12948 return true 12949 } 12950 // match: (Mul32 (Const32 [d]) (Const32 [c])) 12951 // cond: 12952 // result: (Const32 [int64(int32(c*d))]) 12953 for { 12954 _ = v.Args[1] 12955 v_0 := v.Args[0] 12956 if v_0.Op != OpConst32 { 12957 break 12958 } 12959 d := v_0.AuxInt 12960 v_1 := v.Args[1] 12961 if v_1.Op != OpConst32 { 12962 break 12963 } 12964 c := v_1.AuxInt 12965 v.reset(OpConst32) 12966 v.AuxInt = int64(int32(c * d)) 12967 return true 12968 } 12969 // match: (Mul32 (Const32 [1]) x) 12970 // cond: 12971 // result: x 12972 for { 12973 _ = v.Args[1] 12974 v_0 := v.Args[0] 12975 if v_0.Op != OpConst32 { 12976 break 12977 } 12978 if v_0.AuxInt != 1 { 12979 break 12980 } 12981 x := v.Args[1] 12982 v.reset(OpCopy) 12983 v.Type = x.Type 12984 v.AddArg(x) 12985 return true 12986 } 12987 // match: (Mul32 x (Const32 [1])) 12988 // cond: 12989 // result: x 12990 for { 12991 _ = v.Args[1] 12992 x := v.Args[0] 12993 v_1 := v.Args[1] 12994 if v_1.Op != OpConst32 { 12995 break 12996 } 12997 if v_1.AuxInt != 1 { 12998 break 12999 } 13000 v.reset(OpCopy) 13001 v.Type = x.Type 13002 v.AddArg(x) 13003 return true 13004 } 13005 // match: (Mul32 (Const32 [-1]) x) 13006 // cond: 13007 // result: (Neg32 x) 13008 for { 13009 _ = v.Args[1] 13010 v_0 := v.Args[0] 13011 if v_0.Op != OpConst32 { 13012 break 13013 } 13014 if v_0.AuxInt != -1 { 13015 break 13016 } 13017 x := v.Args[1] 13018 v.reset(OpNeg32) 13019 v.AddArg(x) 13020 return true 13021 } 13022 // match: (Mul32 x (Const32 [-1])) 13023 // cond: 13024 // result: (Neg32 x) 13025 for { 13026 _ = v.Args[1] 13027 x := v.Args[0] 13028 v_1 := v.Args[1] 13029 if v_1.Op != OpConst32 { 13030 break 13031 } 13032 if v_1.AuxInt != -1 { 13033 break 13034 } 13035 v.reset(OpNeg32) 13036 v.AddArg(x) 13037 return true 13038 } 13039 // match: (Mul32 <t> n (Const32 [c])) 13040 // cond: isPowerOfTwo(c) 13041 // result: (Lsh32x64 <t> n (Const64 <typ.UInt64> [log2(c)])) 13042 for { 13043 t := v.Type 13044 _ = v.Args[1] 13045 n := v.Args[0] 13046 v_1 := v.Args[1] 13047 if v_1.Op != OpConst32 { 13048 break 13049 } 13050 c := v_1.AuxInt 13051 if !(isPowerOfTwo(c)) { 13052 break 13053 } 13054 v.reset(OpLsh32x64) 13055 v.Type = t 13056 v.AddArg(n) 13057 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 13058 v0.AuxInt = log2(c) 13059 v.AddArg(v0) 13060 return true 13061 } 13062 // match: (Mul32 <t> (Const32 [c]) n) 13063 // cond: isPowerOfTwo(c) 13064 // result: (Lsh32x64 <t> n (Const64 <typ.UInt64> [log2(c)])) 13065 for { 13066 t := v.Type 13067 _ = v.Args[1] 13068 v_0 := v.Args[0] 13069 if v_0.Op != OpConst32 { 13070 break 13071 } 13072 c := v_0.AuxInt 13073 n := v.Args[1] 13074 if !(isPowerOfTwo(c)) { 13075 break 13076 } 13077 v.reset(OpLsh32x64) 13078 v.Type = t 13079 v.AddArg(n) 13080 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 13081 v0.AuxInt = log2(c) 13082 v.AddArg(v0) 13083 return true 13084 } 13085 // match: (Mul32 <t> n (Const32 [c])) 13086 // cond: t.IsSigned() && isPowerOfTwo(-c) 13087 // result: (Neg32 (Lsh32x64 <t> n (Const64 <typ.UInt64> [log2(-c)]))) 13088 for { 13089 t := v.Type 13090 _ = v.Args[1] 13091 n := v.Args[0] 13092 v_1 := v.Args[1] 13093 if v_1.Op != OpConst32 { 13094 break 13095 } 13096 c := v_1.AuxInt 13097 if !(t.IsSigned() && isPowerOfTwo(-c)) { 13098 break 13099 } 13100 v.reset(OpNeg32) 13101 v0 := b.NewValue0(v.Pos, OpLsh32x64, t) 13102 v0.AddArg(n) 13103 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 13104 v1.AuxInt = log2(-c) 13105 v0.AddArg(v1) 13106 v.AddArg(v0) 13107 return true 13108 } 13109 // match: (Mul32 <t> (Const32 [c]) n) 13110 // cond: t.IsSigned() && isPowerOfTwo(-c) 13111 // result: (Neg32 (Lsh32x64 <t> n (Const64 <typ.UInt64> [log2(-c)]))) 13112 for { 13113 t := v.Type 13114 _ = v.Args[1] 13115 v_0 := v.Args[0] 13116 if v_0.Op != OpConst32 { 13117 break 13118 } 13119 c := v_0.AuxInt 13120 n := v.Args[1] 13121 if !(t.IsSigned() && isPowerOfTwo(-c)) { 13122 break 13123 } 13124 v.reset(OpNeg32) 13125 v0 := b.NewValue0(v.Pos, OpLsh32x64, t) 13126 v0.AddArg(n) 13127 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 13128 v1.AuxInt = log2(-c) 13129 v0.AddArg(v1) 13130 v.AddArg(v0) 13131 return true 13132 } 13133 return false 13134 } 13135 func rewriteValuegeneric_OpMul32_10(v *Value) bool { 13136 b := v.Block 13137 _ = b 13138 // match: (Mul32 (Const32 <t> [c]) (Add32 <t> (Const32 <t> [d]) x)) 13139 // cond: 13140 // result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x)) 13141 for { 13142 _ = v.Args[1] 13143 v_0 := v.Args[0] 13144 if v_0.Op != OpConst32 { 13145 break 13146 } 13147 t := v_0.Type 13148 c := v_0.AuxInt 13149 v_1 := v.Args[1] 13150 if v_1.Op != OpAdd32 { 13151 break 13152 } 13153 if v_1.Type != t { 13154 break 13155 } 13156 _ = v_1.Args[1] 13157 v_1_0 := v_1.Args[0] 13158 if v_1_0.Op != OpConst32 { 13159 break 13160 } 13161 if v_1_0.Type != t { 13162 break 13163 } 13164 d := v_1_0.AuxInt 13165 x := v_1.Args[1] 13166 v.reset(OpAdd32) 13167 v0 := b.NewValue0(v.Pos, OpConst32, t) 13168 v0.AuxInt = int64(int32(c * d)) 13169 v.AddArg(v0) 13170 v1 := b.NewValue0(v.Pos, OpMul32, t) 13171 v2 := b.NewValue0(v.Pos, OpConst32, t) 13172 v2.AuxInt = c 13173 v1.AddArg(v2) 13174 v1.AddArg(x) 13175 v.AddArg(v1) 13176 return true 13177 } 13178 // match: (Mul32 (Const32 <t> [c]) (Add32 <t> x (Const32 <t> [d]))) 13179 // cond: 13180 // result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x)) 13181 for { 13182 _ = v.Args[1] 13183 v_0 := v.Args[0] 13184 if v_0.Op != OpConst32 { 13185 break 13186 } 13187 t := v_0.Type 13188 c := v_0.AuxInt 13189 v_1 := v.Args[1] 13190 if v_1.Op != OpAdd32 { 13191 break 13192 } 13193 if v_1.Type != t { 13194 break 13195 } 13196 _ = v_1.Args[1] 13197 x := v_1.Args[0] 13198 v_1_1 := v_1.Args[1] 13199 if v_1_1.Op != OpConst32 { 13200 break 13201 } 13202 if v_1_1.Type != t { 13203 break 13204 } 13205 d := v_1_1.AuxInt 13206 v.reset(OpAdd32) 13207 v0 := b.NewValue0(v.Pos, OpConst32, t) 13208 v0.AuxInt = int64(int32(c * d)) 13209 v.AddArg(v0) 13210 v1 := b.NewValue0(v.Pos, OpMul32, t) 13211 v2 := b.NewValue0(v.Pos, OpConst32, t) 13212 v2.AuxInt = c 13213 v1.AddArg(v2) 13214 v1.AddArg(x) 13215 v.AddArg(v1) 13216 return true 13217 } 13218 // match: (Mul32 (Add32 <t> (Const32 <t> [d]) x) (Const32 <t> [c])) 13219 // cond: 13220 // result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x)) 13221 for { 13222 _ = v.Args[1] 13223 v_0 := v.Args[0] 13224 if v_0.Op != OpAdd32 { 13225 break 13226 } 13227 t := v_0.Type 13228 _ = v_0.Args[1] 13229 v_0_0 := v_0.Args[0] 13230 if v_0_0.Op != OpConst32 { 13231 break 13232 } 13233 if v_0_0.Type != t { 13234 break 13235 } 13236 d := v_0_0.AuxInt 13237 x := v_0.Args[1] 13238 v_1 := v.Args[1] 13239 if v_1.Op != OpConst32 { 13240 break 13241 } 13242 if v_1.Type != t { 13243 break 13244 } 13245 c := v_1.AuxInt 13246 v.reset(OpAdd32) 13247 v0 := b.NewValue0(v.Pos, OpConst32, t) 13248 v0.AuxInt = int64(int32(c * d)) 13249 v.AddArg(v0) 13250 v1 := b.NewValue0(v.Pos, OpMul32, t) 13251 v2 := b.NewValue0(v.Pos, OpConst32, t) 13252 v2.AuxInt = c 13253 v1.AddArg(v2) 13254 v1.AddArg(x) 13255 v.AddArg(v1) 13256 return true 13257 } 13258 // match: (Mul32 (Add32 <t> x (Const32 <t> [d])) (Const32 <t> [c])) 13259 // cond: 13260 // result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x)) 13261 for { 13262 _ = v.Args[1] 13263 v_0 := v.Args[0] 13264 if v_0.Op != OpAdd32 { 13265 break 13266 } 13267 t := v_0.Type 13268 _ = v_0.Args[1] 13269 x := v_0.Args[0] 13270 v_0_1 := v_0.Args[1] 13271 if v_0_1.Op != OpConst32 { 13272 break 13273 } 13274 if v_0_1.Type != t { 13275 break 13276 } 13277 d := v_0_1.AuxInt 13278 v_1 := v.Args[1] 13279 if v_1.Op != OpConst32 { 13280 break 13281 } 13282 if v_1.Type != t { 13283 break 13284 } 13285 c := v_1.AuxInt 13286 v.reset(OpAdd32) 13287 v0 := b.NewValue0(v.Pos, OpConst32, t) 13288 v0.AuxInt = int64(int32(c * d)) 13289 v.AddArg(v0) 13290 v1 := b.NewValue0(v.Pos, OpMul32, t) 13291 v2 := b.NewValue0(v.Pos, OpConst32, t) 13292 v2.AuxInt = c 13293 v1.AddArg(v2) 13294 v1.AddArg(x) 13295 v.AddArg(v1) 13296 return true 13297 } 13298 // match: (Mul32 (Const32 [0]) _) 13299 // cond: 13300 // result: (Const32 [0]) 13301 for { 13302 _ = v.Args[1] 13303 v_0 := v.Args[0] 13304 if v_0.Op != OpConst32 { 13305 break 13306 } 13307 if v_0.AuxInt != 0 { 13308 break 13309 } 13310 v.reset(OpConst32) 13311 v.AuxInt = 0 13312 return true 13313 } 13314 // match: (Mul32 _ (Const32 [0])) 13315 // cond: 13316 // result: (Const32 [0]) 13317 for { 13318 _ = v.Args[1] 13319 v_1 := v.Args[1] 13320 if v_1.Op != OpConst32 { 13321 break 13322 } 13323 if v_1.AuxInt != 0 { 13324 break 13325 } 13326 v.reset(OpConst32) 13327 v.AuxInt = 0 13328 return true 13329 } 13330 // match: (Mul32 (Const32 <t> [c]) (Mul32 (Const32 <t> [d]) x)) 13331 // cond: 13332 // result: (Mul32 (Const32 <t> [int64(int32(c*d))]) x) 13333 for { 13334 _ = v.Args[1] 13335 v_0 := v.Args[0] 13336 if v_0.Op != OpConst32 { 13337 break 13338 } 13339 t := v_0.Type 13340 c := v_0.AuxInt 13341 v_1 := v.Args[1] 13342 if v_1.Op != OpMul32 { 13343 break 13344 } 13345 _ = v_1.Args[1] 13346 v_1_0 := v_1.Args[0] 13347 if v_1_0.Op != OpConst32 { 13348 break 13349 } 13350 if v_1_0.Type != t { 13351 break 13352 } 13353 d := v_1_0.AuxInt 13354 x := v_1.Args[1] 13355 v.reset(OpMul32) 13356 v0 := b.NewValue0(v.Pos, OpConst32, t) 13357 v0.AuxInt = int64(int32(c * d)) 13358 v.AddArg(v0) 13359 v.AddArg(x) 13360 return true 13361 } 13362 // match: (Mul32 (Const32 <t> [c]) (Mul32 x (Const32 <t> [d]))) 13363 // cond: 13364 // result: (Mul32 (Const32 <t> [int64(int32(c*d))]) x) 13365 for { 13366 _ = v.Args[1] 13367 v_0 := v.Args[0] 13368 if v_0.Op != OpConst32 { 13369 break 13370 } 13371 t := v_0.Type 13372 c := v_0.AuxInt 13373 v_1 := v.Args[1] 13374 if v_1.Op != OpMul32 { 13375 break 13376 } 13377 _ = v_1.Args[1] 13378 x := v_1.Args[0] 13379 v_1_1 := v_1.Args[1] 13380 if v_1_1.Op != OpConst32 { 13381 break 13382 } 13383 if v_1_1.Type != t { 13384 break 13385 } 13386 d := v_1_1.AuxInt 13387 v.reset(OpMul32) 13388 v0 := b.NewValue0(v.Pos, OpConst32, t) 13389 v0.AuxInt = int64(int32(c * d)) 13390 v.AddArg(v0) 13391 v.AddArg(x) 13392 return true 13393 } 13394 // match: (Mul32 (Mul32 (Const32 <t> [d]) x) (Const32 <t> [c])) 13395 // cond: 13396 // result: (Mul32 (Const32 <t> [int64(int32(c*d))]) x) 13397 for { 13398 _ = v.Args[1] 13399 v_0 := v.Args[0] 13400 if v_0.Op != OpMul32 { 13401 break 13402 } 13403 _ = v_0.Args[1] 13404 v_0_0 := v_0.Args[0] 13405 if v_0_0.Op != OpConst32 { 13406 break 13407 } 13408 t := v_0_0.Type 13409 d := v_0_0.AuxInt 13410 x := v_0.Args[1] 13411 v_1 := v.Args[1] 13412 if v_1.Op != OpConst32 { 13413 break 13414 } 13415 if v_1.Type != t { 13416 break 13417 } 13418 c := v_1.AuxInt 13419 v.reset(OpMul32) 13420 v0 := b.NewValue0(v.Pos, OpConst32, t) 13421 v0.AuxInt = int64(int32(c * d)) 13422 v.AddArg(v0) 13423 v.AddArg(x) 13424 return true 13425 } 13426 // match: (Mul32 (Mul32 x (Const32 <t> [d])) (Const32 <t> [c])) 13427 // cond: 13428 // result: (Mul32 (Const32 <t> [int64(int32(c*d))]) x) 13429 for { 13430 _ = v.Args[1] 13431 v_0 := v.Args[0] 13432 if v_0.Op != OpMul32 { 13433 break 13434 } 13435 _ = v_0.Args[1] 13436 x := v_0.Args[0] 13437 v_0_1 := v_0.Args[1] 13438 if v_0_1.Op != OpConst32 { 13439 break 13440 } 13441 t := v_0_1.Type 13442 d := v_0_1.AuxInt 13443 v_1 := v.Args[1] 13444 if v_1.Op != OpConst32 { 13445 break 13446 } 13447 if v_1.Type != t { 13448 break 13449 } 13450 c := v_1.AuxInt 13451 v.reset(OpMul32) 13452 v0 := b.NewValue0(v.Pos, OpConst32, t) 13453 v0.AuxInt = int64(int32(c * d)) 13454 v.AddArg(v0) 13455 v.AddArg(x) 13456 return true 13457 } 13458 return false 13459 } 13460 func rewriteValuegeneric_OpMul32F_0(v *Value) bool { 13461 // match: (Mul32F (Const32F [c]) (Const32F [d])) 13462 // cond: 13463 // result: (Const32F [f2i(float64(i2f32(c) * i2f32(d)))]) 13464 for { 13465 _ = v.Args[1] 13466 v_0 := v.Args[0] 13467 if v_0.Op != OpConst32F { 13468 break 13469 } 13470 c := v_0.AuxInt 13471 v_1 := v.Args[1] 13472 if v_1.Op != OpConst32F { 13473 break 13474 } 13475 d := v_1.AuxInt 13476 v.reset(OpConst32F) 13477 v.AuxInt = f2i(float64(i2f32(c) * i2f32(d))) 13478 return true 13479 } 13480 // match: (Mul32F (Const32F [d]) (Const32F [c])) 13481 // cond: 13482 // result: (Const32F [f2i(float64(i2f32(c) * i2f32(d)))]) 13483 for { 13484 _ = v.Args[1] 13485 v_0 := v.Args[0] 13486 if v_0.Op != OpConst32F { 13487 break 13488 } 13489 d := v_0.AuxInt 13490 v_1 := v.Args[1] 13491 if v_1.Op != OpConst32F { 13492 break 13493 } 13494 c := v_1.AuxInt 13495 v.reset(OpConst32F) 13496 v.AuxInt = f2i(float64(i2f32(c) * i2f32(d))) 13497 return true 13498 } 13499 // match: (Mul32F x (Const32F [f2i(1)])) 13500 // cond: 13501 // result: x 13502 for { 13503 _ = v.Args[1] 13504 x := v.Args[0] 13505 v_1 := v.Args[1] 13506 if v_1.Op != OpConst32F { 13507 break 13508 } 13509 if v_1.AuxInt != f2i(1) { 13510 break 13511 } 13512 v.reset(OpCopy) 13513 v.Type = x.Type 13514 v.AddArg(x) 13515 return true 13516 } 13517 // match: (Mul32F (Const32F [f2i(1)]) x) 13518 // cond: 13519 // result: x 13520 for { 13521 _ = v.Args[1] 13522 v_0 := v.Args[0] 13523 if v_0.Op != OpConst32F { 13524 break 13525 } 13526 if v_0.AuxInt != f2i(1) { 13527 break 13528 } 13529 x := v.Args[1] 13530 v.reset(OpCopy) 13531 v.Type = x.Type 13532 v.AddArg(x) 13533 return true 13534 } 13535 // match: (Mul32F x (Const32F [f2i(-1)])) 13536 // cond: 13537 // result: (Neg32F x) 13538 for { 13539 _ = v.Args[1] 13540 x := v.Args[0] 13541 v_1 := v.Args[1] 13542 if v_1.Op != OpConst32F { 13543 break 13544 } 13545 if v_1.AuxInt != f2i(-1) { 13546 break 13547 } 13548 v.reset(OpNeg32F) 13549 v.AddArg(x) 13550 return true 13551 } 13552 // match: (Mul32F (Const32F [f2i(-1)]) x) 13553 // cond: 13554 // result: (Neg32F x) 13555 for { 13556 _ = v.Args[1] 13557 v_0 := v.Args[0] 13558 if v_0.Op != OpConst32F { 13559 break 13560 } 13561 if v_0.AuxInt != f2i(-1) { 13562 break 13563 } 13564 x := v.Args[1] 13565 v.reset(OpNeg32F) 13566 v.AddArg(x) 13567 return true 13568 } 13569 // match: (Mul32F x (Const32F [f2i(2)])) 13570 // cond: 13571 // result: (Add32F x x) 13572 for { 13573 _ = v.Args[1] 13574 x := v.Args[0] 13575 v_1 := v.Args[1] 13576 if v_1.Op != OpConst32F { 13577 break 13578 } 13579 if v_1.AuxInt != f2i(2) { 13580 break 13581 } 13582 v.reset(OpAdd32F) 13583 v.AddArg(x) 13584 v.AddArg(x) 13585 return true 13586 } 13587 // match: (Mul32F (Const32F [f2i(2)]) x) 13588 // cond: 13589 // result: (Add32F x x) 13590 for { 13591 _ = v.Args[1] 13592 v_0 := v.Args[0] 13593 if v_0.Op != OpConst32F { 13594 break 13595 } 13596 if v_0.AuxInt != f2i(2) { 13597 break 13598 } 13599 x := v.Args[1] 13600 v.reset(OpAdd32F) 13601 v.AddArg(x) 13602 v.AddArg(x) 13603 return true 13604 } 13605 return false 13606 } 13607 func rewriteValuegeneric_OpMul64_0(v *Value) bool { 13608 b := v.Block 13609 _ = b 13610 typ := &b.Func.Config.Types 13611 _ = typ 13612 // match: (Mul64 (Const64 [c]) (Const64 [d])) 13613 // cond: 13614 // result: (Const64 [c*d]) 13615 for { 13616 _ = v.Args[1] 13617 v_0 := v.Args[0] 13618 if v_0.Op != OpConst64 { 13619 break 13620 } 13621 c := v_0.AuxInt 13622 v_1 := v.Args[1] 13623 if v_1.Op != OpConst64 { 13624 break 13625 } 13626 d := v_1.AuxInt 13627 v.reset(OpConst64) 13628 v.AuxInt = c * d 13629 return true 13630 } 13631 // match: (Mul64 (Const64 [d]) (Const64 [c])) 13632 // cond: 13633 // result: (Const64 [c*d]) 13634 for { 13635 _ = v.Args[1] 13636 v_0 := v.Args[0] 13637 if v_0.Op != OpConst64 { 13638 break 13639 } 13640 d := v_0.AuxInt 13641 v_1 := v.Args[1] 13642 if v_1.Op != OpConst64 { 13643 break 13644 } 13645 c := v_1.AuxInt 13646 v.reset(OpConst64) 13647 v.AuxInt = c * d 13648 return true 13649 } 13650 // match: (Mul64 (Const64 [1]) x) 13651 // cond: 13652 // result: x 13653 for { 13654 _ = v.Args[1] 13655 v_0 := v.Args[0] 13656 if v_0.Op != OpConst64 { 13657 break 13658 } 13659 if v_0.AuxInt != 1 { 13660 break 13661 } 13662 x := v.Args[1] 13663 v.reset(OpCopy) 13664 v.Type = x.Type 13665 v.AddArg(x) 13666 return true 13667 } 13668 // match: (Mul64 x (Const64 [1])) 13669 // cond: 13670 // result: x 13671 for { 13672 _ = v.Args[1] 13673 x := v.Args[0] 13674 v_1 := v.Args[1] 13675 if v_1.Op != OpConst64 { 13676 break 13677 } 13678 if v_1.AuxInt != 1 { 13679 break 13680 } 13681 v.reset(OpCopy) 13682 v.Type = x.Type 13683 v.AddArg(x) 13684 return true 13685 } 13686 // match: (Mul64 (Const64 [-1]) x) 13687 // cond: 13688 // result: (Neg64 x) 13689 for { 13690 _ = v.Args[1] 13691 v_0 := v.Args[0] 13692 if v_0.Op != OpConst64 { 13693 break 13694 } 13695 if v_0.AuxInt != -1 { 13696 break 13697 } 13698 x := v.Args[1] 13699 v.reset(OpNeg64) 13700 v.AddArg(x) 13701 return true 13702 } 13703 // match: (Mul64 x (Const64 [-1])) 13704 // cond: 13705 // result: (Neg64 x) 13706 for { 13707 _ = v.Args[1] 13708 x := v.Args[0] 13709 v_1 := v.Args[1] 13710 if v_1.Op != OpConst64 { 13711 break 13712 } 13713 if v_1.AuxInt != -1 { 13714 break 13715 } 13716 v.reset(OpNeg64) 13717 v.AddArg(x) 13718 return true 13719 } 13720 // match: (Mul64 <t> n (Const64 [c])) 13721 // cond: isPowerOfTwo(c) 13722 // result: (Lsh64x64 <t> n (Const64 <typ.UInt64> [log2(c)])) 13723 for { 13724 t := v.Type 13725 _ = v.Args[1] 13726 n := v.Args[0] 13727 v_1 := v.Args[1] 13728 if v_1.Op != OpConst64 { 13729 break 13730 } 13731 c := v_1.AuxInt 13732 if !(isPowerOfTwo(c)) { 13733 break 13734 } 13735 v.reset(OpLsh64x64) 13736 v.Type = t 13737 v.AddArg(n) 13738 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 13739 v0.AuxInt = log2(c) 13740 v.AddArg(v0) 13741 return true 13742 } 13743 // match: (Mul64 <t> (Const64 [c]) n) 13744 // cond: isPowerOfTwo(c) 13745 // result: (Lsh64x64 <t> n (Const64 <typ.UInt64> [log2(c)])) 13746 for { 13747 t := v.Type 13748 _ = v.Args[1] 13749 v_0 := v.Args[0] 13750 if v_0.Op != OpConst64 { 13751 break 13752 } 13753 c := v_0.AuxInt 13754 n := v.Args[1] 13755 if !(isPowerOfTwo(c)) { 13756 break 13757 } 13758 v.reset(OpLsh64x64) 13759 v.Type = t 13760 v.AddArg(n) 13761 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 13762 v0.AuxInt = log2(c) 13763 v.AddArg(v0) 13764 return true 13765 } 13766 // match: (Mul64 <t> n (Const64 [c])) 13767 // cond: t.IsSigned() && isPowerOfTwo(-c) 13768 // result: (Neg64 (Lsh64x64 <t> n (Const64 <typ.UInt64> [log2(-c)]))) 13769 for { 13770 t := v.Type 13771 _ = v.Args[1] 13772 n := v.Args[0] 13773 v_1 := v.Args[1] 13774 if v_1.Op != OpConst64 { 13775 break 13776 } 13777 c := v_1.AuxInt 13778 if !(t.IsSigned() && isPowerOfTwo(-c)) { 13779 break 13780 } 13781 v.reset(OpNeg64) 13782 v0 := b.NewValue0(v.Pos, OpLsh64x64, t) 13783 v0.AddArg(n) 13784 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 13785 v1.AuxInt = log2(-c) 13786 v0.AddArg(v1) 13787 v.AddArg(v0) 13788 return true 13789 } 13790 // match: (Mul64 <t> (Const64 [c]) n) 13791 // cond: t.IsSigned() && isPowerOfTwo(-c) 13792 // result: (Neg64 (Lsh64x64 <t> n (Const64 <typ.UInt64> [log2(-c)]))) 13793 for { 13794 t := v.Type 13795 _ = v.Args[1] 13796 v_0 := v.Args[0] 13797 if v_0.Op != OpConst64 { 13798 break 13799 } 13800 c := v_0.AuxInt 13801 n := v.Args[1] 13802 if !(t.IsSigned() && isPowerOfTwo(-c)) { 13803 break 13804 } 13805 v.reset(OpNeg64) 13806 v0 := b.NewValue0(v.Pos, OpLsh64x64, t) 13807 v0.AddArg(n) 13808 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 13809 v1.AuxInt = log2(-c) 13810 v0.AddArg(v1) 13811 v.AddArg(v0) 13812 return true 13813 } 13814 return false 13815 } 13816 func rewriteValuegeneric_OpMul64_10(v *Value) bool { 13817 b := v.Block 13818 _ = b 13819 // match: (Mul64 (Const64 <t> [c]) (Add64 <t> (Const64 <t> [d]) x)) 13820 // cond: 13821 // result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x)) 13822 for { 13823 _ = v.Args[1] 13824 v_0 := v.Args[0] 13825 if v_0.Op != OpConst64 { 13826 break 13827 } 13828 t := v_0.Type 13829 c := v_0.AuxInt 13830 v_1 := v.Args[1] 13831 if v_1.Op != OpAdd64 { 13832 break 13833 } 13834 if v_1.Type != t { 13835 break 13836 } 13837 _ = v_1.Args[1] 13838 v_1_0 := v_1.Args[0] 13839 if v_1_0.Op != OpConst64 { 13840 break 13841 } 13842 if v_1_0.Type != t { 13843 break 13844 } 13845 d := v_1_0.AuxInt 13846 x := v_1.Args[1] 13847 v.reset(OpAdd64) 13848 v0 := b.NewValue0(v.Pos, OpConst64, t) 13849 v0.AuxInt = c * d 13850 v.AddArg(v0) 13851 v1 := b.NewValue0(v.Pos, OpMul64, t) 13852 v2 := b.NewValue0(v.Pos, OpConst64, t) 13853 v2.AuxInt = c 13854 v1.AddArg(v2) 13855 v1.AddArg(x) 13856 v.AddArg(v1) 13857 return true 13858 } 13859 // match: (Mul64 (Const64 <t> [c]) (Add64 <t> x (Const64 <t> [d]))) 13860 // cond: 13861 // result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x)) 13862 for { 13863 _ = v.Args[1] 13864 v_0 := v.Args[0] 13865 if v_0.Op != OpConst64 { 13866 break 13867 } 13868 t := v_0.Type 13869 c := v_0.AuxInt 13870 v_1 := v.Args[1] 13871 if v_1.Op != OpAdd64 { 13872 break 13873 } 13874 if v_1.Type != t { 13875 break 13876 } 13877 _ = v_1.Args[1] 13878 x := v_1.Args[0] 13879 v_1_1 := v_1.Args[1] 13880 if v_1_1.Op != OpConst64 { 13881 break 13882 } 13883 if v_1_1.Type != t { 13884 break 13885 } 13886 d := v_1_1.AuxInt 13887 v.reset(OpAdd64) 13888 v0 := b.NewValue0(v.Pos, OpConst64, t) 13889 v0.AuxInt = c * d 13890 v.AddArg(v0) 13891 v1 := b.NewValue0(v.Pos, OpMul64, t) 13892 v2 := b.NewValue0(v.Pos, OpConst64, t) 13893 v2.AuxInt = c 13894 v1.AddArg(v2) 13895 v1.AddArg(x) 13896 v.AddArg(v1) 13897 return true 13898 } 13899 // match: (Mul64 (Add64 <t> (Const64 <t> [d]) x) (Const64 <t> [c])) 13900 // cond: 13901 // result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x)) 13902 for { 13903 _ = v.Args[1] 13904 v_0 := v.Args[0] 13905 if v_0.Op != OpAdd64 { 13906 break 13907 } 13908 t := v_0.Type 13909 _ = v_0.Args[1] 13910 v_0_0 := v_0.Args[0] 13911 if v_0_0.Op != OpConst64 { 13912 break 13913 } 13914 if v_0_0.Type != t { 13915 break 13916 } 13917 d := v_0_0.AuxInt 13918 x := v_0.Args[1] 13919 v_1 := v.Args[1] 13920 if v_1.Op != OpConst64 { 13921 break 13922 } 13923 if v_1.Type != t { 13924 break 13925 } 13926 c := v_1.AuxInt 13927 v.reset(OpAdd64) 13928 v0 := b.NewValue0(v.Pos, OpConst64, t) 13929 v0.AuxInt = c * d 13930 v.AddArg(v0) 13931 v1 := b.NewValue0(v.Pos, OpMul64, t) 13932 v2 := b.NewValue0(v.Pos, OpConst64, t) 13933 v2.AuxInt = c 13934 v1.AddArg(v2) 13935 v1.AddArg(x) 13936 v.AddArg(v1) 13937 return true 13938 } 13939 // match: (Mul64 (Add64 <t> x (Const64 <t> [d])) (Const64 <t> [c])) 13940 // cond: 13941 // result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x)) 13942 for { 13943 _ = v.Args[1] 13944 v_0 := v.Args[0] 13945 if v_0.Op != OpAdd64 { 13946 break 13947 } 13948 t := v_0.Type 13949 _ = v_0.Args[1] 13950 x := v_0.Args[0] 13951 v_0_1 := v_0.Args[1] 13952 if v_0_1.Op != OpConst64 { 13953 break 13954 } 13955 if v_0_1.Type != t { 13956 break 13957 } 13958 d := v_0_1.AuxInt 13959 v_1 := v.Args[1] 13960 if v_1.Op != OpConst64 { 13961 break 13962 } 13963 if v_1.Type != t { 13964 break 13965 } 13966 c := v_1.AuxInt 13967 v.reset(OpAdd64) 13968 v0 := b.NewValue0(v.Pos, OpConst64, t) 13969 v0.AuxInt = c * d 13970 v.AddArg(v0) 13971 v1 := b.NewValue0(v.Pos, OpMul64, t) 13972 v2 := b.NewValue0(v.Pos, OpConst64, t) 13973 v2.AuxInt = c 13974 v1.AddArg(v2) 13975 v1.AddArg(x) 13976 v.AddArg(v1) 13977 return true 13978 } 13979 // match: (Mul64 (Const64 [0]) _) 13980 // cond: 13981 // result: (Const64 [0]) 13982 for { 13983 _ = v.Args[1] 13984 v_0 := v.Args[0] 13985 if v_0.Op != OpConst64 { 13986 break 13987 } 13988 if v_0.AuxInt != 0 { 13989 break 13990 } 13991 v.reset(OpConst64) 13992 v.AuxInt = 0 13993 return true 13994 } 13995 // match: (Mul64 _ (Const64 [0])) 13996 // cond: 13997 // result: (Const64 [0]) 13998 for { 13999 _ = v.Args[1] 14000 v_1 := v.Args[1] 14001 if v_1.Op != OpConst64 { 14002 break 14003 } 14004 if v_1.AuxInt != 0 { 14005 break 14006 } 14007 v.reset(OpConst64) 14008 v.AuxInt = 0 14009 return true 14010 } 14011 // match: (Mul64 (Const64 <t> [c]) (Mul64 (Const64 <t> [d]) x)) 14012 // cond: 14013 // result: (Mul64 (Const64 <t> [c*d]) x) 14014 for { 14015 _ = v.Args[1] 14016 v_0 := v.Args[0] 14017 if v_0.Op != OpConst64 { 14018 break 14019 } 14020 t := v_0.Type 14021 c := v_0.AuxInt 14022 v_1 := v.Args[1] 14023 if v_1.Op != OpMul64 { 14024 break 14025 } 14026 _ = v_1.Args[1] 14027 v_1_0 := v_1.Args[0] 14028 if v_1_0.Op != OpConst64 { 14029 break 14030 } 14031 if v_1_0.Type != t { 14032 break 14033 } 14034 d := v_1_0.AuxInt 14035 x := v_1.Args[1] 14036 v.reset(OpMul64) 14037 v0 := b.NewValue0(v.Pos, OpConst64, t) 14038 v0.AuxInt = c * d 14039 v.AddArg(v0) 14040 v.AddArg(x) 14041 return true 14042 } 14043 // match: (Mul64 (Const64 <t> [c]) (Mul64 x (Const64 <t> [d]))) 14044 // cond: 14045 // result: (Mul64 (Const64 <t> [c*d]) x) 14046 for { 14047 _ = v.Args[1] 14048 v_0 := v.Args[0] 14049 if v_0.Op != OpConst64 { 14050 break 14051 } 14052 t := v_0.Type 14053 c := v_0.AuxInt 14054 v_1 := v.Args[1] 14055 if v_1.Op != OpMul64 { 14056 break 14057 } 14058 _ = v_1.Args[1] 14059 x := v_1.Args[0] 14060 v_1_1 := v_1.Args[1] 14061 if v_1_1.Op != OpConst64 { 14062 break 14063 } 14064 if v_1_1.Type != t { 14065 break 14066 } 14067 d := v_1_1.AuxInt 14068 v.reset(OpMul64) 14069 v0 := b.NewValue0(v.Pos, OpConst64, t) 14070 v0.AuxInt = c * d 14071 v.AddArg(v0) 14072 v.AddArg(x) 14073 return true 14074 } 14075 // match: (Mul64 (Mul64 (Const64 <t> [d]) x) (Const64 <t> [c])) 14076 // cond: 14077 // result: (Mul64 (Const64 <t> [c*d]) x) 14078 for { 14079 _ = v.Args[1] 14080 v_0 := v.Args[0] 14081 if v_0.Op != OpMul64 { 14082 break 14083 } 14084 _ = v_0.Args[1] 14085 v_0_0 := v_0.Args[0] 14086 if v_0_0.Op != OpConst64 { 14087 break 14088 } 14089 t := v_0_0.Type 14090 d := v_0_0.AuxInt 14091 x := v_0.Args[1] 14092 v_1 := v.Args[1] 14093 if v_1.Op != OpConst64 { 14094 break 14095 } 14096 if v_1.Type != t { 14097 break 14098 } 14099 c := v_1.AuxInt 14100 v.reset(OpMul64) 14101 v0 := b.NewValue0(v.Pos, OpConst64, t) 14102 v0.AuxInt = c * d 14103 v.AddArg(v0) 14104 v.AddArg(x) 14105 return true 14106 } 14107 // match: (Mul64 (Mul64 x (Const64 <t> [d])) (Const64 <t> [c])) 14108 // cond: 14109 // result: (Mul64 (Const64 <t> [c*d]) x) 14110 for { 14111 _ = v.Args[1] 14112 v_0 := v.Args[0] 14113 if v_0.Op != OpMul64 { 14114 break 14115 } 14116 _ = v_0.Args[1] 14117 x := v_0.Args[0] 14118 v_0_1 := v_0.Args[1] 14119 if v_0_1.Op != OpConst64 { 14120 break 14121 } 14122 t := v_0_1.Type 14123 d := v_0_1.AuxInt 14124 v_1 := v.Args[1] 14125 if v_1.Op != OpConst64 { 14126 break 14127 } 14128 if v_1.Type != t { 14129 break 14130 } 14131 c := v_1.AuxInt 14132 v.reset(OpMul64) 14133 v0 := b.NewValue0(v.Pos, OpConst64, t) 14134 v0.AuxInt = c * d 14135 v.AddArg(v0) 14136 v.AddArg(x) 14137 return true 14138 } 14139 return false 14140 } 14141 func rewriteValuegeneric_OpMul64F_0(v *Value) bool { 14142 // match: (Mul64F (Const64F [c]) (Const64F [d])) 14143 // cond: 14144 // result: (Const64F [f2i(i2f(c) * i2f(d))]) 14145 for { 14146 _ = v.Args[1] 14147 v_0 := v.Args[0] 14148 if v_0.Op != OpConst64F { 14149 break 14150 } 14151 c := v_0.AuxInt 14152 v_1 := v.Args[1] 14153 if v_1.Op != OpConst64F { 14154 break 14155 } 14156 d := v_1.AuxInt 14157 v.reset(OpConst64F) 14158 v.AuxInt = f2i(i2f(c) * i2f(d)) 14159 return true 14160 } 14161 // match: (Mul64F (Const64F [d]) (Const64F [c])) 14162 // cond: 14163 // result: (Const64F [f2i(i2f(c) * i2f(d))]) 14164 for { 14165 _ = v.Args[1] 14166 v_0 := v.Args[0] 14167 if v_0.Op != OpConst64F { 14168 break 14169 } 14170 d := v_0.AuxInt 14171 v_1 := v.Args[1] 14172 if v_1.Op != OpConst64F { 14173 break 14174 } 14175 c := v_1.AuxInt 14176 v.reset(OpConst64F) 14177 v.AuxInt = f2i(i2f(c) * i2f(d)) 14178 return true 14179 } 14180 // match: (Mul64F x (Const64F [f2i(1)])) 14181 // cond: 14182 // result: x 14183 for { 14184 _ = v.Args[1] 14185 x := v.Args[0] 14186 v_1 := v.Args[1] 14187 if v_1.Op != OpConst64F { 14188 break 14189 } 14190 if v_1.AuxInt != f2i(1) { 14191 break 14192 } 14193 v.reset(OpCopy) 14194 v.Type = x.Type 14195 v.AddArg(x) 14196 return true 14197 } 14198 // match: (Mul64F (Const64F [f2i(1)]) x) 14199 // cond: 14200 // result: x 14201 for { 14202 _ = v.Args[1] 14203 v_0 := v.Args[0] 14204 if v_0.Op != OpConst64F { 14205 break 14206 } 14207 if v_0.AuxInt != f2i(1) { 14208 break 14209 } 14210 x := v.Args[1] 14211 v.reset(OpCopy) 14212 v.Type = x.Type 14213 v.AddArg(x) 14214 return true 14215 } 14216 // match: (Mul64F x (Const64F [f2i(-1)])) 14217 // cond: 14218 // result: (Neg64F x) 14219 for { 14220 _ = v.Args[1] 14221 x := v.Args[0] 14222 v_1 := v.Args[1] 14223 if v_1.Op != OpConst64F { 14224 break 14225 } 14226 if v_1.AuxInt != f2i(-1) { 14227 break 14228 } 14229 v.reset(OpNeg64F) 14230 v.AddArg(x) 14231 return true 14232 } 14233 // match: (Mul64F (Const64F [f2i(-1)]) x) 14234 // cond: 14235 // result: (Neg64F x) 14236 for { 14237 _ = v.Args[1] 14238 v_0 := v.Args[0] 14239 if v_0.Op != OpConst64F { 14240 break 14241 } 14242 if v_0.AuxInt != f2i(-1) { 14243 break 14244 } 14245 x := v.Args[1] 14246 v.reset(OpNeg64F) 14247 v.AddArg(x) 14248 return true 14249 } 14250 // match: (Mul64F x (Const64F [f2i(2)])) 14251 // cond: 14252 // result: (Add64F x x) 14253 for { 14254 _ = v.Args[1] 14255 x := v.Args[0] 14256 v_1 := v.Args[1] 14257 if v_1.Op != OpConst64F { 14258 break 14259 } 14260 if v_1.AuxInt != f2i(2) { 14261 break 14262 } 14263 v.reset(OpAdd64F) 14264 v.AddArg(x) 14265 v.AddArg(x) 14266 return true 14267 } 14268 // match: (Mul64F (Const64F [f2i(2)]) x) 14269 // cond: 14270 // result: (Add64F x x) 14271 for { 14272 _ = v.Args[1] 14273 v_0 := v.Args[0] 14274 if v_0.Op != OpConst64F { 14275 break 14276 } 14277 if v_0.AuxInt != f2i(2) { 14278 break 14279 } 14280 x := v.Args[1] 14281 v.reset(OpAdd64F) 14282 v.AddArg(x) 14283 v.AddArg(x) 14284 return true 14285 } 14286 return false 14287 } 14288 func rewriteValuegeneric_OpMul8_0(v *Value) bool { 14289 b := v.Block 14290 _ = b 14291 typ := &b.Func.Config.Types 14292 _ = typ 14293 // match: (Mul8 (Const8 [c]) (Const8 [d])) 14294 // cond: 14295 // result: (Const8 [int64(int8(c*d))]) 14296 for { 14297 _ = v.Args[1] 14298 v_0 := v.Args[0] 14299 if v_0.Op != OpConst8 { 14300 break 14301 } 14302 c := v_0.AuxInt 14303 v_1 := v.Args[1] 14304 if v_1.Op != OpConst8 { 14305 break 14306 } 14307 d := v_1.AuxInt 14308 v.reset(OpConst8) 14309 v.AuxInt = int64(int8(c * d)) 14310 return true 14311 } 14312 // match: (Mul8 (Const8 [d]) (Const8 [c])) 14313 // cond: 14314 // result: (Const8 [int64(int8(c*d))]) 14315 for { 14316 _ = v.Args[1] 14317 v_0 := v.Args[0] 14318 if v_0.Op != OpConst8 { 14319 break 14320 } 14321 d := v_0.AuxInt 14322 v_1 := v.Args[1] 14323 if v_1.Op != OpConst8 { 14324 break 14325 } 14326 c := v_1.AuxInt 14327 v.reset(OpConst8) 14328 v.AuxInt = int64(int8(c * d)) 14329 return true 14330 } 14331 // match: (Mul8 (Const8 [1]) x) 14332 // cond: 14333 // result: x 14334 for { 14335 _ = v.Args[1] 14336 v_0 := v.Args[0] 14337 if v_0.Op != OpConst8 { 14338 break 14339 } 14340 if v_0.AuxInt != 1 { 14341 break 14342 } 14343 x := v.Args[1] 14344 v.reset(OpCopy) 14345 v.Type = x.Type 14346 v.AddArg(x) 14347 return true 14348 } 14349 // match: (Mul8 x (Const8 [1])) 14350 // cond: 14351 // result: x 14352 for { 14353 _ = v.Args[1] 14354 x := v.Args[0] 14355 v_1 := v.Args[1] 14356 if v_1.Op != OpConst8 { 14357 break 14358 } 14359 if v_1.AuxInt != 1 { 14360 break 14361 } 14362 v.reset(OpCopy) 14363 v.Type = x.Type 14364 v.AddArg(x) 14365 return true 14366 } 14367 // match: (Mul8 (Const8 [-1]) x) 14368 // cond: 14369 // result: (Neg8 x) 14370 for { 14371 _ = v.Args[1] 14372 v_0 := v.Args[0] 14373 if v_0.Op != OpConst8 { 14374 break 14375 } 14376 if v_0.AuxInt != -1 { 14377 break 14378 } 14379 x := v.Args[1] 14380 v.reset(OpNeg8) 14381 v.AddArg(x) 14382 return true 14383 } 14384 // match: (Mul8 x (Const8 [-1])) 14385 // cond: 14386 // result: (Neg8 x) 14387 for { 14388 _ = v.Args[1] 14389 x := v.Args[0] 14390 v_1 := v.Args[1] 14391 if v_1.Op != OpConst8 { 14392 break 14393 } 14394 if v_1.AuxInt != -1 { 14395 break 14396 } 14397 v.reset(OpNeg8) 14398 v.AddArg(x) 14399 return true 14400 } 14401 // match: (Mul8 <t> n (Const8 [c])) 14402 // cond: isPowerOfTwo(c) 14403 // result: (Lsh8x64 <t> n (Const64 <typ.UInt64> [log2(c)])) 14404 for { 14405 t := v.Type 14406 _ = v.Args[1] 14407 n := v.Args[0] 14408 v_1 := v.Args[1] 14409 if v_1.Op != OpConst8 { 14410 break 14411 } 14412 c := v_1.AuxInt 14413 if !(isPowerOfTwo(c)) { 14414 break 14415 } 14416 v.reset(OpLsh8x64) 14417 v.Type = t 14418 v.AddArg(n) 14419 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 14420 v0.AuxInt = log2(c) 14421 v.AddArg(v0) 14422 return true 14423 } 14424 // match: (Mul8 <t> (Const8 [c]) n) 14425 // cond: isPowerOfTwo(c) 14426 // result: (Lsh8x64 <t> n (Const64 <typ.UInt64> [log2(c)])) 14427 for { 14428 t := v.Type 14429 _ = v.Args[1] 14430 v_0 := v.Args[0] 14431 if v_0.Op != OpConst8 { 14432 break 14433 } 14434 c := v_0.AuxInt 14435 n := v.Args[1] 14436 if !(isPowerOfTwo(c)) { 14437 break 14438 } 14439 v.reset(OpLsh8x64) 14440 v.Type = t 14441 v.AddArg(n) 14442 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 14443 v0.AuxInt = log2(c) 14444 v.AddArg(v0) 14445 return true 14446 } 14447 // match: (Mul8 <t> n (Const8 [c])) 14448 // cond: t.IsSigned() && isPowerOfTwo(-c) 14449 // result: (Neg8 (Lsh8x64 <t> n (Const64 <typ.UInt64> [log2(-c)]))) 14450 for { 14451 t := v.Type 14452 _ = v.Args[1] 14453 n := v.Args[0] 14454 v_1 := v.Args[1] 14455 if v_1.Op != OpConst8 { 14456 break 14457 } 14458 c := v_1.AuxInt 14459 if !(t.IsSigned() && isPowerOfTwo(-c)) { 14460 break 14461 } 14462 v.reset(OpNeg8) 14463 v0 := b.NewValue0(v.Pos, OpLsh8x64, t) 14464 v0.AddArg(n) 14465 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 14466 v1.AuxInt = log2(-c) 14467 v0.AddArg(v1) 14468 v.AddArg(v0) 14469 return true 14470 } 14471 // match: (Mul8 <t> (Const8 [c]) n) 14472 // cond: t.IsSigned() && isPowerOfTwo(-c) 14473 // result: (Neg8 (Lsh8x64 <t> n (Const64 <typ.UInt64> [log2(-c)]))) 14474 for { 14475 t := v.Type 14476 _ = v.Args[1] 14477 v_0 := v.Args[0] 14478 if v_0.Op != OpConst8 { 14479 break 14480 } 14481 c := v_0.AuxInt 14482 n := v.Args[1] 14483 if !(t.IsSigned() && isPowerOfTwo(-c)) { 14484 break 14485 } 14486 v.reset(OpNeg8) 14487 v0 := b.NewValue0(v.Pos, OpLsh8x64, t) 14488 v0.AddArg(n) 14489 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 14490 v1.AuxInt = log2(-c) 14491 v0.AddArg(v1) 14492 v.AddArg(v0) 14493 return true 14494 } 14495 return false 14496 } 14497 func rewriteValuegeneric_OpMul8_10(v *Value) bool { 14498 b := v.Block 14499 _ = b 14500 // match: (Mul8 (Const8 [0]) _) 14501 // cond: 14502 // result: (Const8 [0]) 14503 for { 14504 _ = v.Args[1] 14505 v_0 := v.Args[0] 14506 if v_0.Op != OpConst8 { 14507 break 14508 } 14509 if v_0.AuxInt != 0 { 14510 break 14511 } 14512 v.reset(OpConst8) 14513 v.AuxInt = 0 14514 return true 14515 } 14516 // match: (Mul8 _ (Const8 [0])) 14517 // cond: 14518 // result: (Const8 [0]) 14519 for { 14520 _ = v.Args[1] 14521 v_1 := v.Args[1] 14522 if v_1.Op != OpConst8 { 14523 break 14524 } 14525 if v_1.AuxInt != 0 { 14526 break 14527 } 14528 v.reset(OpConst8) 14529 v.AuxInt = 0 14530 return true 14531 } 14532 // match: (Mul8 (Const8 <t> [c]) (Mul8 (Const8 <t> [d]) x)) 14533 // cond: 14534 // result: (Mul8 (Const8 <t> [int64(int8(c*d))]) x) 14535 for { 14536 _ = v.Args[1] 14537 v_0 := v.Args[0] 14538 if v_0.Op != OpConst8 { 14539 break 14540 } 14541 t := v_0.Type 14542 c := v_0.AuxInt 14543 v_1 := v.Args[1] 14544 if v_1.Op != OpMul8 { 14545 break 14546 } 14547 _ = v_1.Args[1] 14548 v_1_0 := v_1.Args[0] 14549 if v_1_0.Op != OpConst8 { 14550 break 14551 } 14552 if v_1_0.Type != t { 14553 break 14554 } 14555 d := v_1_0.AuxInt 14556 x := v_1.Args[1] 14557 v.reset(OpMul8) 14558 v0 := b.NewValue0(v.Pos, OpConst8, t) 14559 v0.AuxInt = int64(int8(c * d)) 14560 v.AddArg(v0) 14561 v.AddArg(x) 14562 return true 14563 } 14564 // match: (Mul8 (Const8 <t> [c]) (Mul8 x (Const8 <t> [d]))) 14565 // cond: 14566 // result: (Mul8 (Const8 <t> [int64(int8(c*d))]) x) 14567 for { 14568 _ = v.Args[1] 14569 v_0 := v.Args[0] 14570 if v_0.Op != OpConst8 { 14571 break 14572 } 14573 t := v_0.Type 14574 c := v_0.AuxInt 14575 v_1 := v.Args[1] 14576 if v_1.Op != OpMul8 { 14577 break 14578 } 14579 _ = v_1.Args[1] 14580 x := v_1.Args[0] 14581 v_1_1 := v_1.Args[1] 14582 if v_1_1.Op != OpConst8 { 14583 break 14584 } 14585 if v_1_1.Type != t { 14586 break 14587 } 14588 d := v_1_1.AuxInt 14589 v.reset(OpMul8) 14590 v0 := b.NewValue0(v.Pos, OpConst8, t) 14591 v0.AuxInt = int64(int8(c * d)) 14592 v.AddArg(v0) 14593 v.AddArg(x) 14594 return true 14595 } 14596 // match: (Mul8 (Mul8 (Const8 <t> [d]) x) (Const8 <t> [c])) 14597 // cond: 14598 // result: (Mul8 (Const8 <t> [int64(int8(c*d))]) x) 14599 for { 14600 _ = v.Args[1] 14601 v_0 := v.Args[0] 14602 if v_0.Op != OpMul8 { 14603 break 14604 } 14605 _ = v_0.Args[1] 14606 v_0_0 := v_0.Args[0] 14607 if v_0_0.Op != OpConst8 { 14608 break 14609 } 14610 t := v_0_0.Type 14611 d := v_0_0.AuxInt 14612 x := v_0.Args[1] 14613 v_1 := v.Args[1] 14614 if v_1.Op != OpConst8 { 14615 break 14616 } 14617 if v_1.Type != t { 14618 break 14619 } 14620 c := v_1.AuxInt 14621 v.reset(OpMul8) 14622 v0 := b.NewValue0(v.Pos, OpConst8, t) 14623 v0.AuxInt = int64(int8(c * d)) 14624 v.AddArg(v0) 14625 v.AddArg(x) 14626 return true 14627 } 14628 // match: (Mul8 (Mul8 x (Const8 <t> [d])) (Const8 <t> [c])) 14629 // cond: 14630 // result: (Mul8 (Const8 <t> [int64(int8(c*d))]) x) 14631 for { 14632 _ = v.Args[1] 14633 v_0 := v.Args[0] 14634 if v_0.Op != OpMul8 { 14635 break 14636 } 14637 _ = v_0.Args[1] 14638 x := v_0.Args[0] 14639 v_0_1 := v_0.Args[1] 14640 if v_0_1.Op != OpConst8 { 14641 break 14642 } 14643 t := v_0_1.Type 14644 d := v_0_1.AuxInt 14645 v_1 := v.Args[1] 14646 if v_1.Op != OpConst8 { 14647 break 14648 } 14649 if v_1.Type != t { 14650 break 14651 } 14652 c := v_1.AuxInt 14653 v.reset(OpMul8) 14654 v0 := b.NewValue0(v.Pos, OpConst8, t) 14655 v0.AuxInt = int64(int8(c * d)) 14656 v.AddArg(v0) 14657 v.AddArg(x) 14658 return true 14659 } 14660 return false 14661 } 14662 func rewriteValuegeneric_OpNeg16_0(v *Value) bool { 14663 // match: (Neg16 (Const16 [c])) 14664 // cond: 14665 // result: (Const16 [int64(-int16(c))]) 14666 for { 14667 v_0 := v.Args[0] 14668 if v_0.Op != OpConst16 { 14669 break 14670 } 14671 c := v_0.AuxInt 14672 v.reset(OpConst16) 14673 v.AuxInt = int64(-int16(c)) 14674 return true 14675 } 14676 // match: (Neg16 (Sub16 x y)) 14677 // cond: 14678 // result: (Sub16 y x) 14679 for { 14680 v_0 := v.Args[0] 14681 if v_0.Op != OpSub16 { 14682 break 14683 } 14684 _ = v_0.Args[1] 14685 x := v_0.Args[0] 14686 y := v_0.Args[1] 14687 v.reset(OpSub16) 14688 v.AddArg(y) 14689 v.AddArg(x) 14690 return true 14691 } 14692 return false 14693 } 14694 func rewriteValuegeneric_OpNeg32_0(v *Value) bool { 14695 // match: (Neg32 (Const32 [c])) 14696 // cond: 14697 // result: (Const32 [int64(-int32(c))]) 14698 for { 14699 v_0 := v.Args[0] 14700 if v_0.Op != OpConst32 { 14701 break 14702 } 14703 c := v_0.AuxInt 14704 v.reset(OpConst32) 14705 v.AuxInt = int64(-int32(c)) 14706 return true 14707 } 14708 // match: (Neg32 (Sub32 x y)) 14709 // cond: 14710 // result: (Sub32 y x) 14711 for { 14712 v_0 := v.Args[0] 14713 if v_0.Op != OpSub32 { 14714 break 14715 } 14716 _ = v_0.Args[1] 14717 x := v_0.Args[0] 14718 y := v_0.Args[1] 14719 v.reset(OpSub32) 14720 v.AddArg(y) 14721 v.AddArg(x) 14722 return true 14723 } 14724 return false 14725 } 14726 func rewriteValuegeneric_OpNeg32F_0(v *Value) bool { 14727 // match: (Neg32F (Const32F [c])) 14728 // cond: i2f(c) != 0 14729 // result: (Const32F [f2i(-i2f(c))]) 14730 for { 14731 v_0 := v.Args[0] 14732 if v_0.Op != OpConst32F { 14733 break 14734 } 14735 c := v_0.AuxInt 14736 if !(i2f(c) != 0) { 14737 break 14738 } 14739 v.reset(OpConst32F) 14740 v.AuxInt = f2i(-i2f(c)) 14741 return true 14742 } 14743 return false 14744 } 14745 func rewriteValuegeneric_OpNeg64_0(v *Value) bool { 14746 // match: (Neg64 (Const64 [c])) 14747 // cond: 14748 // result: (Const64 [-c]) 14749 for { 14750 v_0 := v.Args[0] 14751 if v_0.Op != OpConst64 { 14752 break 14753 } 14754 c := v_0.AuxInt 14755 v.reset(OpConst64) 14756 v.AuxInt = -c 14757 return true 14758 } 14759 // match: (Neg64 (Sub64 x y)) 14760 // cond: 14761 // result: (Sub64 y x) 14762 for { 14763 v_0 := v.Args[0] 14764 if v_0.Op != OpSub64 { 14765 break 14766 } 14767 _ = v_0.Args[1] 14768 x := v_0.Args[0] 14769 y := v_0.Args[1] 14770 v.reset(OpSub64) 14771 v.AddArg(y) 14772 v.AddArg(x) 14773 return true 14774 } 14775 return false 14776 } 14777 func rewriteValuegeneric_OpNeg64F_0(v *Value) bool { 14778 // match: (Neg64F (Const64F [c])) 14779 // cond: i2f(c) != 0 14780 // result: (Const64F [f2i(-i2f(c))]) 14781 for { 14782 v_0 := v.Args[0] 14783 if v_0.Op != OpConst64F { 14784 break 14785 } 14786 c := v_0.AuxInt 14787 if !(i2f(c) != 0) { 14788 break 14789 } 14790 v.reset(OpConst64F) 14791 v.AuxInt = f2i(-i2f(c)) 14792 return true 14793 } 14794 return false 14795 } 14796 func rewriteValuegeneric_OpNeg8_0(v *Value) bool { 14797 // match: (Neg8 (Const8 [c])) 14798 // cond: 14799 // result: (Const8 [int64( -int8(c))]) 14800 for { 14801 v_0 := v.Args[0] 14802 if v_0.Op != OpConst8 { 14803 break 14804 } 14805 c := v_0.AuxInt 14806 v.reset(OpConst8) 14807 v.AuxInt = int64(-int8(c)) 14808 return true 14809 } 14810 // match: (Neg8 (Sub8 x y)) 14811 // cond: 14812 // result: (Sub8 y x) 14813 for { 14814 v_0 := v.Args[0] 14815 if v_0.Op != OpSub8 { 14816 break 14817 } 14818 _ = v_0.Args[1] 14819 x := v_0.Args[0] 14820 y := v_0.Args[1] 14821 v.reset(OpSub8) 14822 v.AddArg(y) 14823 v.AddArg(x) 14824 return true 14825 } 14826 return false 14827 } 14828 func rewriteValuegeneric_OpNeq16_0(v *Value) bool { 14829 b := v.Block 14830 _ = b 14831 // match: (Neq16 x x) 14832 // cond: 14833 // result: (ConstBool [0]) 14834 for { 14835 _ = v.Args[1] 14836 x := v.Args[0] 14837 if x != v.Args[1] { 14838 break 14839 } 14840 v.reset(OpConstBool) 14841 v.AuxInt = 0 14842 return true 14843 } 14844 // match: (Neq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x)) 14845 // cond: 14846 // result: (Neq16 (Const16 <t> [int64(int16(c-d))]) x) 14847 for { 14848 _ = v.Args[1] 14849 v_0 := v.Args[0] 14850 if v_0.Op != OpConst16 { 14851 break 14852 } 14853 t := v_0.Type 14854 c := v_0.AuxInt 14855 v_1 := v.Args[1] 14856 if v_1.Op != OpAdd16 { 14857 break 14858 } 14859 _ = v_1.Args[1] 14860 v_1_0 := v_1.Args[0] 14861 if v_1_0.Op != OpConst16 { 14862 break 14863 } 14864 if v_1_0.Type != t { 14865 break 14866 } 14867 d := v_1_0.AuxInt 14868 x := v_1.Args[1] 14869 v.reset(OpNeq16) 14870 v0 := b.NewValue0(v.Pos, OpConst16, t) 14871 v0.AuxInt = int64(int16(c - d)) 14872 v.AddArg(v0) 14873 v.AddArg(x) 14874 return true 14875 } 14876 // match: (Neq16 (Const16 <t> [c]) (Add16 x (Const16 <t> [d]))) 14877 // cond: 14878 // result: (Neq16 (Const16 <t> [int64(int16(c-d))]) x) 14879 for { 14880 _ = v.Args[1] 14881 v_0 := v.Args[0] 14882 if v_0.Op != OpConst16 { 14883 break 14884 } 14885 t := v_0.Type 14886 c := v_0.AuxInt 14887 v_1 := v.Args[1] 14888 if v_1.Op != OpAdd16 { 14889 break 14890 } 14891 _ = v_1.Args[1] 14892 x := v_1.Args[0] 14893 v_1_1 := v_1.Args[1] 14894 if v_1_1.Op != OpConst16 { 14895 break 14896 } 14897 if v_1_1.Type != t { 14898 break 14899 } 14900 d := v_1_1.AuxInt 14901 v.reset(OpNeq16) 14902 v0 := b.NewValue0(v.Pos, OpConst16, t) 14903 v0.AuxInt = int64(int16(c - d)) 14904 v.AddArg(v0) 14905 v.AddArg(x) 14906 return true 14907 } 14908 // match: (Neq16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c])) 14909 // cond: 14910 // result: (Neq16 (Const16 <t> [int64(int16(c-d))]) x) 14911 for { 14912 _ = v.Args[1] 14913 v_0 := v.Args[0] 14914 if v_0.Op != OpAdd16 { 14915 break 14916 } 14917 _ = v_0.Args[1] 14918 v_0_0 := v_0.Args[0] 14919 if v_0_0.Op != OpConst16 { 14920 break 14921 } 14922 t := v_0_0.Type 14923 d := v_0_0.AuxInt 14924 x := v_0.Args[1] 14925 v_1 := v.Args[1] 14926 if v_1.Op != OpConst16 { 14927 break 14928 } 14929 if v_1.Type != t { 14930 break 14931 } 14932 c := v_1.AuxInt 14933 v.reset(OpNeq16) 14934 v0 := b.NewValue0(v.Pos, OpConst16, t) 14935 v0.AuxInt = int64(int16(c - d)) 14936 v.AddArg(v0) 14937 v.AddArg(x) 14938 return true 14939 } 14940 // match: (Neq16 (Add16 x (Const16 <t> [d])) (Const16 <t> [c])) 14941 // cond: 14942 // result: (Neq16 (Const16 <t> [int64(int16(c-d))]) x) 14943 for { 14944 _ = v.Args[1] 14945 v_0 := v.Args[0] 14946 if v_0.Op != OpAdd16 { 14947 break 14948 } 14949 _ = v_0.Args[1] 14950 x := v_0.Args[0] 14951 v_0_1 := v_0.Args[1] 14952 if v_0_1.Op != OpConst16 { 14953 break 14954 } 14955 t := v_0_1.Type 14956 d := v_0_1.AuxInt 14957 v_1 := v.Args[1] 14958 if v_1.Op != OpConst16 { 14959 break 14960 } 14961 if v_1.Type != t { 14962 break 14963 } 14964 c := v_1.AuxInt 14965 v.reset(OpNeq16) 14966 v0 := b.NewValue0(v.Pos, OpConst16, t) 14967 v0.AuxInt = int64(int16(c - d)) 14968 v.AddArg(v0) 14969 v.AddArg(x) 14970 return true 14971 } 14972 // match: (Neq16 (Const16 [c]) (Const16 [d])) 14973 // cond: 14974 // result: (ConstBool [b2i(c != d)]) 14975 for { 14976 _ = v.Args[1] 14977 v_0 := v.Args[0] 14978 if v_0.Op != OpConst16 { 14979 break 14980 } 14981 c := v_0.AuxInt 14982 v_1 := v.Args[1] 14983 if v_1.Op != OpConst16 { 14984 break 14985 } 14986 d := v_1.AuxInt 14987 v.reset(OpConstBool) 14988 v.AuxInt = b2i(c != d) 14989 return true 14990 } 14991 // match: (Neq16 (Const16 [d]) (Const16 [c])) 14992 // cond: 14993 // result: (ConstBool [b2i(c != d)]) 14994 for { 14995 _ = v.Args[1] 14996 v_0 := v.Args[0] 14997 if v_0.Op != OpConst16 { 14998 break 14999 } 15000 d := v_0.AuxInt 15001 v_1 := v.Args[1] 15002 if v_1.Op != OpConst16 { 15003 break 15004 } 15005 c := v_1.AuxInt 15006 v.reset(OpConstBool) 15007 v.AuxInt = b2i(c != d) 15008 return true 15009 } 15010 return false 15011 } 15012 func rewriteValuegeneric_OpNeq32_0(v *Value) bool { 15013 b := v.Block 15014 _ = b 15015 // match: (Neq32 x x) 15016 // cond: 15017 // result: (ConstBool [0]) 15018 for { 15019 _ = v.Args[1] 15020 x := v.Args[0] 15021 if x != v.Args[1] { 15022 break 15023 } 15024 v.reset(OpConstBool) 15025 v.AuxInt = 0 15026 return true 15027 } 15028 // match: (Neq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x)) 15029 // cond: 15030 // result: (Neq32 (Const32 <t> [int64(int32(c-d))]) x) 15031 for { 15032 _ = v.Args[1] 15033 v_0 := v.Args[0] 15034 if v_0.Op != OpConst32 { 15035 break 15036 } 15037 t := v_0.Type 15038 c := v_0.AuxInt 15039 v_1 := v.Args[1] 15040 if v_1.Op != OpAdd32 { 15041 break 15042 } 15043 _ = v_1.Args[1] 15044 v_1_0 := v_1.Args[0] 15045 if v_1_0.Op != OpConst32 { 15046 break 15047 } 15048 if v_1_0.Type != t { 15049 break 15050 } 15051 d := v_1_0.AuxInt 15052 x := v_1.Args[1] 15053 v.reset(OpNeq32) 15054 v0 := b.NewValue0(v.Pos, OpConst32, t) 15055 v0.AuxInt = int64(int32(c - d)) 15056 v.AddArg(v0) 15057 v.AddArg(x) 15058 return true 15059 } 15060 // match: (Neq32 (Const32 <t> [c]) (Add32 x (Const32 <t> [d]))) 15061 // cond: 15062 // result: (Neq32 (Const32 <t> [int64(int32(c-d))]) x) 15063 for { 15064 _ = v.Args[1] 15065 v_0 := v.Args[0] 15066 if v_0.Op != OpConst32 { 15067 break 15068 } 15069 t := v_0.Type 15070 c := v_0.AuxInt 15071 v_1 := v.Args[1] 15072 if v_1.Op != OpAdd32 { 15073 break 15074 } 15075 _ = v_1.Args[1] 15076 x := v_1.Args[0] 15077 v_1_1 := v_1.Args[1] 15078 if v_1_1.Op != OpConst32 { 15079 break 15080 } 15081 if v_1_1.Type != t { 15082 break 15083 } 15084 d := v_1_1.AuxInt 15085 v.reset(OpNeq32) 15086 v0 := b.NewValue0(v.Pos, OpConst32, t) 15087 v0.AuxInt = int64(int32(c - d)) 15088 v.AddArg(v0) 15089 v.AddArg(x) 15090 return true 15091 } 15092 // match: (Neq32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c])) 15093 // cond: 15094 // result: (Neq32 (Const32 <t> [int64(int32(c-d))]) x) 15095 for { 15096 _ = v.Args[1] 15097 v_0 := v.Args[0] 15098 if v_0.Op != OpAdd32 { 15099 break 15100 } 15101 _ = v_0.Args[1] 15102 v_0_0 := v_0.Args[0] 15103 if v_0_0.Op != OpConst32 { 15104 break 15105 } 15106 t := v_0_0.Type 15107 d := v_0_0.AuxInt 15108 x := v_0.Args[1] 15109 v_1 := v.Args[1] 15110 if v_1.Op != OpConst32 { 15111 break 15112 } 15113 if v_1.Type != t { 15114 break 15115 } 15116 c := v_1.AuxInt 15117 v.reset(OpNeq32) 15118 v0 := b.NewValue0(v.Pos, OpConst32, t) 15119 v0.AuxInt = int64(int32(c - d)) 15120 v.AddArg(v0) 15121 v.AddArg(x) 15122 return true 15123 } 15124 // match: (Neq32 (Add32 x (Const32 <t> [d])) (Const32 <t> [c])) 15125 // cond: 15126 // result: (Neq32 (Const32 <t> [int64(int32(c-d))]) x) 15127 for { 15128 _ = v.Args[1] 15129 v_0 := v.Args[0] 15130 if v_0.Op != OpAdd32 { 15131 break 15132 } 15133 _ = v_0.Args[1] 15134 x := v_0.Args[0] 15135 v_0_1 := v_0.Args[1] 15136 if v_0_1.Op != OpConst32 { 15137 break 15138 } 15139 t := v_0_1.Type 15140 d := v_0_1.AuxInt 15141 v_1 := v.Args[1] 15142 if v_1.Op != OpConst32 { 15143 break 15144 } 15145 if v_1.Type != t { 15146 break 15147 } 15148 c := v_1.AuxInt 15149 v.reset(OpNeq32) 15150 v0 := b.NewValue0(v.Pos, OpConst32, t) 15151 v0.AuxInt = int64(int32(c - d)) 15152 v.AddArg(v0) 15153 v.AddArg(x) 15154 return true 15155 } 15156 // match: (Neq32 (Const32 [c]) (Const32 [d])) 15157 // cond: 15158 // result: (ConstBool [b2i(c != d)]) 15159 for { 15160 _ = v.Args[1] 15161 v_0 := v.Args[0] 15162 if v_0.Op != OpConst32 { 15163 break 15164 } 15165 c := v_0.AuxInt 15166 v_1 := v.Args[1] 15167 if v_1.Op != OpConst32 { 15168 break 15169 } 15170 d := v_1.AuxInt 15171 v.reset(OpConstBool) 15172 v.AuxInt = b2i(c != d) 15173 return true 15174 } 15175 // match: (Neq32 (Const32 [d]) (Const32 [c])) 15176 // cond: 15177 // result: (ConstBool [b2i(c != d)]) 15178 for { 15179 _ = v.Args[1] 15180 v_0 := v.Args[0] 15181 if v_0.Op != OpConst32 { 15182 break 15183 } 15184 d := v_0.AuxInt 15185 v_1 := v.Args[1] 15186 if v_1.Op != OpConst32 { 15187 break 15188 } 15189 c := v_1.AuxInt 15190 v.reset(OpConstBool) 15191 v.AuxInt = b2i(c != d) 15192 return true 15193 } 15194 return false 15195 } 15196 func rewriteValuegeneric_OpNeq64_0(v *Value) bool { 15197 b := v.Block 15198 _ = b 15199 // match: (Neq64 x x) 15200 // cond: 15201 // result: (ConstBool [0]) 15202 for { 15203 _ = v.Args[1] 15204 x := v.Args[0] 15205 if x != v.Args[1] { 15206 break 15207 } 15208 v.reset(OpConstBool) 15209 v.AuxInt = 0 15210 return true 15211 } 15212 // match: (Neq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x)) 15213 // cond: 15214 // result: (Neq64 (Const64 <t> [c-d]) x) 15215 for { 15216 _ = v.Args[1] 15217 v_0 := v.Args[0] 15218 if v_0.Op != OpConst64 { 15219 break 15220 } 15221 t := v_0.Type 15222 c := v_0.AuxInt 15223 v_1 := v.Args[1] 15224 if v_1.Op != OpAdd64 { 15225 break 15226 } 15227 _ = v_1.Args[1] 15228 v_1_0 := v_1.Args[0] 15229 if v_1_0.Op != OpConst64 { 15230 break 15231 } 15232 if v_1_0.Type != t { 15233 break 15234 } 15235 d := v_1_0.AuxInt 15236 x := v_1.Args[1] 15237 v.reset(OpNeq64) 15238 v0 := b.NewValue0(v.Pos, OpConst64, t) 15239 v0.AuxInt = c - d 15240 v.AddArg(v0) 15241 v.AddArg(x) 15242 return true 15243 } 15244 // match: (Neq64 (Const64 <t> [c]) (Add64 x (Const64 <t> [d]))) 15245 // cond: 15246 // result: (Neq64 (Const64 <t> [c-d]) x) 15247 for { 15248 _ = v.Args[1] 15249 v_0 := v.Args[0] 15250 if v_0.Op != OpConst64 { 15251 break 15252 } 15253 t := v_0.Type 15254 c := v_0.AuxInt 15255 v_1 := v.Args[1] 15256 if v_1.Op != OpAdd64 { 15257 break 15258 } 15259 _ = v_1.Args[1] 15260 x := v_1.Args[0] 15261 v_1_1 := v_1.Args[1] 15262 if v_1_1.Op != OpConst64 { 15263 break 15264 } 15265 if v_1_1.Type != t { 15266 break 15267 } 15268 d := v_1_1.AuxInt 15269 v.reset(OpNeq64) 15270 v0 := b.NewValue0(v.Pos, OpConst64, t) 15271 v0.AuxInt = c - d 15272 v.AddArg(v0) 15273 v.AddArg(x) 15274 return true 15275 } 15276 // match: (Neq64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c])) 15277 // cond: 15278 // result: (Neq64 (Const64 <t> [c-d]) x) 15279 for { 15280 _ = v.Args[1] 15281 v_0 := v.Args[0] 15282 if v_0.Op != OpAdd64 { 15283 break 15284 } 15285 _ = v_0.Args[1] 15286 v_0_0 := v_0.Args[0] 15287 if v_0_0.Op != OpConst64 { 15288 break 15289 } 15290 t := v_0_0.Type 15291 d := v_0_0.AuxInt 15292 x := v_0.Args[1] 15293 v_1 := v.Args[1] 15294 if v_1.Op != OpConst64 { 15295 break 15296 } 15297 if v_1.Type != t { 15298 break 15299 } 15300 c := v_1.AuxInt 15301 v.reset(OpNeq64) 15302 v0 := b.NewValue0(v.Pos, OpConst64, t) 15303 v0.AuxInt = c - d 15304 v.AddArg(v0) 15305 v.AddArg(x) 15306 return true 15307 } 15308 // match: (Neq64 (Add64 x (Const64 <t> [d])) (Const64 <t> [c])) 15309 // cond: 15310 // result: (Neq64 (Const64 <t> [c-d]) x) 15311 for { 15312 _ = v.Args[1] 15313 v_0 := v.Args[0] 15314 if v_0.Op != OpAdd64 { 15315 break 15316 } 15317 _ = v_0.Args[1] 15318 x := v_0.Args[0] 15319 v_0_1 := v_0.Args[1] 15320 if v_0_1.Op != OpConst64 { 15321 break 15322 } 15323 t := v_0_1.Type 15324 d := v_0_1.AuxInt 15325 v_1 := v.Args[1] 15326 if v_1.Op != OpConst64 { 15327 break 15328 } 15329 if v_1.Type != t { 15330 break 15331 } 15332 c := v_1.AuxInt 15333 v.reset(OpNeq64) 15334 v0 := b.NewValue0(v.Pos, OpConst64, t) 15335 v0.AuxInt = c - d 15336 v.AddArg(v0) 15337 v.AddArg(x) 15338 return true 15339 } 15340 // match: (Neq64 (Const64 [c]) (Const64 [d])) 15341 // cond: 15342 // result: (ConstBool [b2i(c != d)]) 15343 for { 15344 _ = v.Args[1] 15345 v_0 := v.Args[0] 15346 if v_0.Op != OpConst64 { 15347 break 15348 } 15349 c := v_0.AuxInt 15350 v_1 := v.Args[1] 15351 if v_1.Op != OpConst64 { 15352 break 15353 } 15354 d := v_1.AuxInt 15355 v.reset(OpConstBool) 15356 v.AuxInt = b2i(c != d) 15357 return true 15358 } 15359 // match: (Neq64 (Const64 [d]) (Const64 [c])) 15360 // cond: 15361 // result: (ConstBool [b2i(c != d)]) 15362 for { 15363 _ = v.Args[1] 15364 v_0 := v.Args[0] 15365 if v_0.Op != OpConst64 { 15366 break 15367 } 15368 d := v_0.AuxInt 15369 v_1 := v.Args[1] 15370 if v_1.Op != OpConst64 { 15371 break 15372 } 15373 c := v_1.AuxInt 15374 v.reset(OpConstBool) 15375 v.AuxInt = b2i(c != d) 15376 return true 15377 } 15378 return false 15379 } 15380 func rewriteValuegeneric_OpNeq8_0(v *Value) bool { 15381 b := v.Block 15382 _ = b 15383 // match: (Neq8 x x) 15384 // cond: 15385 // result: (ConstBool [0]) 15386 for { 15387 _ = v.Args[1] 15388 x := v.Args[0] 15389 if x != v.Args[1] { 15390 break 15391 } 15392 v.reset(OpConstBool) 15393 v.AuxInt = 0 15394 return true 15395 } 15396 // match: (Neq8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x)) 15397 // cond: 15398 // result: (Neq8 (Const8 <t> [int64(int8(c-d))]) x) 15399 for { 15400 _ = v.Args[1] 15401 v_0 := v.Args[0] 15402 if v_0.Op != OpConst8 { 15403 break 15404 } 15405 t := v_0.Type 15406 c := v_0.AuxInt 15407 v_1 := v.Args[1] 15408 if v_1.Op != OpAdd8 { 15409 break 15410 } 15411 _ = v_1.Args[1] 15412 v_1_0 := v_1.Args[0] 15413 if v_1_0.Op != OpConst8 { 15414 break 15415 } 15416 if v_1_0.Type != t { 15417 break 15418 } 15419 d := v_1_0.AuxInt 15420 x := v_1.Args[1] 15421 v.reset(OpNeq8) 15422 v0 := b.NewValue0(v.Pos, OpConst8, t) 15423 v0.AuxInt = int64(int8(c - d)) 15424 v.AddArg(v0) 15425 v.AddArg(x) 15426 return true 15427 } 15428 // match: (Neq8 (Const8 <t> [c]) (Add8 x (Const8 <t> [d]))) 15429 // cond: 15430 // result: (Neq8 (Const8 <t> [int64(int8(c-d))]) x) 15431 for { 15432 _ = v.Args[1] 15433 v_0 := v.Args[0] 15434 if v_0.Op != OpConst8 { 15435 break 15436 } 15437 t := v_0.Type 15438 c := v_0.AuxInt 15439 v_1 := v.Args[1] 15440 if v_1.Op != OpAdd8 { 15441 break 15442 } 15443 _ = v_1.Args[1] 15444 x := v_1.Args[0] 15445 v_1_1 := v_1.Args[1] 15446 if v_1_1.Op != OpConst8 { 15447 break 15448 } 15449 if v_1_1.Type != t { 15450 break 15451 } 15452 d := v_1_1.AuxInt 15453 v.reset(OpNeq8) 15454 v0 := b.NewValue0(v.Pos, OpConst8, t) 15455 v0.AuxInt = int64(int8(c - d)) 15456 v.AddArg(v0) 15457 v.AddArg(x) 15458 return true 15459 } 15460 // match: (Neq8 (Add8 (Const8 <t> [d]) x) (Const8 <t> [c])) 15461 // cond: 15462 // result: (Neq8 (Const8 <t> [int64(int8(c-d))]) x) 15463 for { 15464 _ = v.Args[1] 15465 v_0 := v.Args[0] 15466 if v_0.Op != OpAdd8 { 15467 break 15468 } 15469 _ = v_0.Args[1] 15470 v_0_0 := v_0.Args[0] 15471 if v_0_0.Op != OpConst8 { 15472 break 15473 } 15474 t := v_0_0.Type 15475 d := v_0_0.AuxInt 15476 x := v_0.Args[1] 15477 v_1 := v.Args[1] 15478 if v_1.Op != OpConst8 { 15479 break 15480 } 15481 if v_1.Type != t { 15482 break 15483 } 15484 c := v_1.AuxInt 15485 v.reset(OpNeq8) 15486 v0 := b.NewValue0(v.Pos, OpConst8, t) 15487 v0.AuxInt = int64(int8(c - d)) 15488 v.AddArg(v0) 15489 v.AddArg(x) 15490 return true 15491 } 15492 // match: (Neq8 (Add8 x (Const8 <t> [d])) (Const8 <t> [c])) 15493 // cond: 15494 // result: (Neq8 (Const8 <t> [int64(int8(c-d))]) x) 15495 for { 15496 _ = v.Args[1] 15497 v_0 := v.Args[0] 15498 if v_0.Op != OpAdd8 { 15499 break 15500 } 15501 _ = v_0.Args[1] 15502 x := v_0.Args[0] 15503 v_0_1 := v_0.Args[1] 15504 if v_0_1.Op != OpConst8 { 15505 break 15506 } 15507 t := v_0_1.Type 15508 d := v_0_1.AuxInt 15509 v_1 := v.Args[1] 15510 if v_1.Op != OpConst8 { 15511 break 15512 } 15513 if v_1.Type != t { 15514 break 15515 } 15516 c := v_1.AuxInt 15517 v.reset(OpNeq8) 15518 v0 := b.NewValue0(v.Pos, OpConst8, t) 15519 v0.AuxInt = int64(int8(c - d)) 15520 v.AddArg(v0) 15521 v.AddArg(x) 15522 return true 15523 } 15524 // match: (Neq8 (Const8 [c]) (Const8 [d])) 15525 // cond: 15526 // result: (ConstBool [b2i(c != d)]) 15527 for { 15528 _ = v.Args[1] 15529 v_0 := v.Args[0] 15530 if v_0.Op != OpConst8 { 15531 break 15532 } 15533 c := v_0.AuxInt 15534 v_1 := v.Args[1] 15535 if v_1.Op != OpConst8 { 15536 break 15537 } 15538 d := v_1.AuxInt 15539 v.reset(OpConstBool) 15540 v.AuxInt = b2i(c != d) 15541 return true 15542 } 15543 // match: (Neq8 (Const8 [d]) (Const8 [c])) 15544 // cond: 15545 // result: (ConstBool [b2i(c != d)]) 15546 for { 15547 _ = v.Args[1] 15548 v_0 := v.Args[0] 15549 if v_0.Op != OpConst8 { 15550 break 15551 } 15552 d := v_0.AuxInt 15553 v_1 := v.Args[1] 15554 if v_1.Op != OpConst8 { 15555 break 15556 } 15557 c := v_1.AuxInt 15558 v.reset(OpConstBool) 15559 v.AuxInt = b2i(c != d) 15560 return true 15561 } 15562 return false 15563 } 15564 func rewriteValuegeneric_OpNeqB_0(v *Value) bool { 15565 // match: (NeqB (ConstBool [c]) (ConstBool [d])) 15566 // cond: 15567 // result: (ConstBool [b2i(c != d)]) 15568 for { 15569 _ = v.Args[1] 15570 v_0 := v.Args[0] 15571 if v_0.Op != OpConstBool { 15572 break 15573 } 15574 c := v_0.AuxInt 15575 v_1 := v.Args[1] 15576 if v_1.Op != OpConstBool { 15577 break 15578 } 15579 d := v_1.AuxInt 15580 v.reset(OpConstBool) 15581 v.AuxInt = b2i(c != d) 15582 return true 15583 } 15584 // match: (NeqB (ConstBool [d]) (ConstBool [c])) 15585 // cond: 15586 // result: (ConstBool [b2i(c != d)]) 15587 for { 15588 _ = v.Args[1] 15589 v_0 := v.Args[0] 15590 if v_0.Op != OpConstBool { 15591 break 15592 } 15593 d := v_0.AuxInt 15594 v_1 := v.Args[1] 15595 if v_1.Op != OpConstBool { 15596 break 15597 } 15598 c := v_1.AuxInt 15599 v.reset(OpConstBool) 15600 v.AuxInt = b2i(c != d) 15601 return true 15602 } 15603 // match: (NeqB (ConstBool [0]) x) 15604 // cond: 15605 // result: x 15606 for { 15607 _ = v.Args[1] 15608 v_0 := v.Args[0] 15609 if v_0.Op != OpConstBool { 15610 break 15611 } 15612 if v_0.AuxInt != 0 { 15613 break 15614 } 15615 x := v.Args[1] 15616 v.reset(OpCopy) 15617 v.Type = x.Type 15618 v.AddArg(x) 15619 return true 15620 } 15621 // match: (NeqB x (ConstBool [0])) 15622 // cond: 15623 // result: x 15624 for { 15625 _ = v.Args[1] 15626 x := v.Args[0] 15627 v_1 := v.Args[1] 15628 if v_1.Op != OpConstBool { 15629 break 15630 } 15631 if v_1.AuxInt != 0 { 15632 break 15633 } 15634 v.reset(OpCopy) 15635 v.Type = x.Type 15636 v.AddArg(x) 15637 return true 15638 } 15639 // match: (NeqB (ConstBool [1]) x) 15640 // cond: 15641 // result: (Not x) 15642 for { 15643 _ = v.Args[1] 15644 v_0 := v.Args[0] 15645 if v_0.Op != OpConstBool { 15646 break 15647 } 15648 if v_0.AuxInt != 1 { 15649 break 15650 } 15651 x := v.Args[1] 15652 v.reset(OpNot) 15653 v.AddArg(x) 15654 return true 15655 } 15656 // match: (NeqB x (ConstBool [1])) 15657 // cond: 15658 // result: (Not x) 15659 for { 15660 _ = v.Args[1] 15661 x := v.Args[0] 15662 v_1 := v.Args[1] 15663 if v_1.Op != OpConstBool { 15664 break 15665 } 15666 if v_1.AuxInt != 1 { 15667 break 15668 } 15669 v.reset(OpNot) 15670 v.AddArg(x) 15671 return true 15672 } 15673 // match: (NeqB (Not x) (Not y)) 15674 // cond: 15675 // result: (NeqB x y) 15676 for { 15677 _ = v.Args[1] 15678 v_0 := v.Args[0] 15679 if v_0.Op != OpNot { 15680 break 15681 } 15682 x := v_0.Args[0] 15683 v_1 := v.Args[1] 15684 if v_1.Op != OpNot { 15685 break 15686 } 15687 y := v_1.Args[0] 15688 v.reset(OpNeqB) 15689 v.AddArg(x) 15690 v.AddArg(y) 15691 return true 15692 } 15693 // match: (NeqB (Not y) (Not x)) 15694 // cond: 15695 // result: (NeqB x y) 15696 for { 15697 _ = v.Args[1] 15698 v_0 := v.Args[0] 15699 if v_0.Op != OpNot { 15700 break 15701 } 15702 y := v_0.Args[0] 15703 v_1 := v.Args[1] 15704 if v_1.Op != OpNot { 15705 break 15706 } 15707 x := v_1.Args[0] 15708 v.reset(OpNeqB) 15709 v.AddArg(x) 15710 v.AddArg(y) 15711 return true 15712 } 15713 return false 15714 } 15715 func rewriteValuegeneric_OpNeqInter_0(v *Value) bool { 15716 b := v.Block 15717 _ = b 15718 typ := &b.Func.Config.Types 15719 _ = typ 15720 // match: (NeqInter x y) 15721 // cond: 15722 // result: (NeqPtr (ITab x) (ITab y)) 15723 for { 15724 _ = v.Args[1] 15725 x := v.Args[0] 15726 y := v.Args[1] 15727 v.reset(OpNeqPtr) 15728 v0 := b.NewValue0(v.Pos, OpITab, typ.BytePtr) 15729 v0.AddArg(x) 15730 v.AddArg(v0) 15731 v1 := b.NewValue0(v.Pos, OpITab, typ.BytePtr) 15732 v1.AddArg(y) 15733 v.AddArg(v1) 15734 return true 15735 } 15736 } 15737 func rewriteValuegeneric_OpNeqPtr_0(v *Value) bool { 15738 // match: (NeqPtr p (ConstNil)) 15739 // cond: 15740 // result: (IsNonNil p) 15741 for { 15742 _ = v.Args[1] 15743 p := v.Args[0] 15744 v_1 := v.Args[1] 15745 if v_1.Op != OpConstNil { 15746 break 15747 } 15748 v.reset(OpIsNonNil) 15749 v.AddArg(p) 15750 return true 15751 } 15752 // match: (NeqPtr (ConstNil) p) 15753 // cond: 15754 // result: (IsNonNil p) 15755 for { 15756 _ = v.Args[1] 15757 v_0 := v.Args[0] 15758 if v_0.Op != OpConstNil { 15759 break 15760 } 15761 p := v.Args[1] 15762 v.reset(OpIsNonNil) 15763 v.AddArg(p) 15764 return true 15765 } 15766 return false 15767 } 15768 func rewriteValuegeneric_OpNeqSlice_0(v *Value) bool { 15769 b := v.Block 15770 _ = b 15771 typ := &b.Func.Config.Types 15772 _ = typ 15773 // match: (NeqSlice x y) 15774 // cond: 15775 // result: (NeqPtr (SlicePtr x) (SlicePtr y)) 15776 for { 15777 _ = v.Args[1] 15778 x := v.Args[0] 15779 y := v.Args[1] 15780 v.reset(OpNeqPtr) 15781 v0 := b.NewValue0(v.Pos, OpSlicePtr, typ.BytePtr) 15782 v0.AddArg(x) 15783 v.AddArg(v0) 15784 v1 := b.NewValue0(v.Pos, OpSlicePtr, typ.BytePtr) 15785 v1.AddArg(y) 15786 v.AddArg(v1) 15787 return true 15788 } 15789 } 15790 func rewriteValuegeneric_OpNilCheck_0(v *Value) bool { 15791 b := v.Block 15792 _ = b 15793 config := b.Func.Config 15794 _ = config 15795 fe := b.Func.fe 15796 _ = fe 15797 // match: (NilCheck (GetG mem) mem) 15798 // cond: 15799 // result: mem 15800 for { 15801 _ = v.Args[1] 15802 v_0 := v.Args[0] 15803 if v_0.Op != OpGetG { 15804 break 15805 } 15806 mem := v_0.Args[0] 15807 if mem != v.Args[1] { 15808 break 15809 } 15810 v.reset(OpCopy) 15811 v.Type = mem.Type 15812 v.AddArg(mem) 15813 return true 15814 } 15815 // match: (NilCheck (Load (OffPtr [c] (SP)) mem) mem) 15816 // cond: mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize && warnRule(fe.Debug_checknil() && v.Pos.Line() > 1, v, "removed nil check") 15817 // result: (Invalid) 15818 for { 15819 _ = v.Args[1] 15820 v_0 := v.Args[0] 15821 if v_0.Op != OpLoad { 15822 break 15823 } 15824 _ = v_0.Args[1] 15825 v_0_0 := v_0.Args[0] 15826 if v_0_0.Op != OpOffPtr { 15827 break 15828 } 15829 c := v_0_0.AuxInt 15830 v_0_0_0 := v_0_0.Args[0] 15831 if v_0_0_0.Op != OpSP { 15832 break 15833 } 15834 mem := v_0.Args[1] 15835 if mem != v.Args[1] { 15836 break 15837 } 15838 if !(mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize && warnRule(fe.Debug_checknil() && v.Pos.Line() > 1, v, "removed nil check")) { 15839 break 15840 } 15841 v.reset(OpInvalid) 15842 return true 15843 } 15844 // match: (NilCheck (OffPtr (Load (OffPtr [c] (SP)) mem)) mem) 15845 // cond: mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize && warnRule(fe.Debug_checknil() && v.Pos.Line() > 1, v, "removed nil check") 15846 // result: (Invalid) 15847 for { 15848 _ = v.Args[1] 15849 v_0 := v.Args[0] 15850 if v_0.Op != OpOffPtr { 15851 break 15852 } 15853 v_0_0 := v_0.Args[0] 15854 if v_0_0.Op != OpLoad { 15855 break 15856 } 15857 _ = v_0_0.Args[1] 15858 v_0_0_0 := v_0_0.Args[0] 15859 if v_0_0_0.Op != OpOffPtr { 15860 break 15861 } 15862 c := v_0_0_0.AuxInt 15863 v_0_0_0_0 := v_0_0_0.Args[0] 15864 if v_0_0_0_0.Op != OpSP { 15865 break 15866 } 15867 mem := v_0_0.Args[1] 15868 if mem != v.Args[1] { 15869 break 15870 } 15871 if !(mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize && warnRule(fe.Debug_checknil() && v.Pos.Line() > 1, v, "removed nil check")) { 15872 break 15873 } 15874 v.reset(OpInvalid) 15875 return true 15876 } 15877 return false 15878 } 15879 func rewriteValuegeneric_OpNot_0(v *Value) bool { 15880 // match: (Not (Eq64 x y)) 15881 // cond: 15882 // result: (Neq64 x y) 15883 for { 15884 v_0 := v.Args[0] 15885 if v_0.Op != OpEq64 { 15886 break 15887 } 15888 _ = v_0.Args[1] 15889 x := v_0.Args[0] 15890 y := v_0.Args[1] 15891 v.reset(OpNeq64) 15892 v.AddArg(x) 15893 v.AddArg(y) 15894 return true 15895 } 15896 // match: (Not (Eq32 x y)) 15897 // cond: 15898 // result: (Neq32 x y) 15899 for { 15900 v_0 := v.Args[0] 15901 if v_0.Op != OpEq32 { 15902 break 15903 } 15904 _ = v_0.Args[1] 15905 x := v_0.Args[0] 15906 y := v_0.Args[1] 15907 v.reset(OpNeq32) 15908 v.AddArg(x) 15909 v.AddArg(y) 15910 return true 15911 } 15912 // match: (Not (Eq16 x y)) 15913 // cond: 15914 // result: (Neq16 x y) 15915 for { 15916 v_0 := v.Args[0] 15917 if v_0.Op != OpEq16 { 15918 break 15919 } 15920 _ = v_0.Args[1] 15921 x := v_0.Args[0] 15922 y := v_0.Args[1] 15923 v.reset(OpNeq16) 15924 v.AddArg(x) 15925 v.AddArg(y) 15926 return true 15927 } 15928 // match: (Not (Eq8 x y)) 15929 // cond: 15930 // result: (Neq8 x y) 15931 for { 15932 v_0 := v.Args[0] 15933 if v_0.Op != OpEq8 { 15934 break 15935 } 15936 _ = v_0.Args[1] 15937 x := v_0.Args[0] 15938 y := v_0.Args[1] 15939 v.reset(OpNeq8) 15940 v.AddArg(x) 15941 v.AddArg(y) 15942 return true 15943 } 15944 // match: (Not (EqB x y)) 15945 // cond: 15946 // result: (NeqB x y) 15947 for { 15948 v_0 := v.Args[0] 15949 if v_0.Op != OpEqB { 15950 break 15951 } 15952 _ = v_0.Args[1] 15953 x := v_0.Args[0] 15954 y := v_0.Args[1] 15955 v.reset(OpNeqB) 15956 v.AddArg(x) 15957 v.AddArg(y) 15958 return true 15959 } 15960 // match: (Not (Neq64 x y)) 15961 // cond: 15962 // result: (Eq64 x y) 15963 for { 15964 v_0 := v.Args[0] 15965 if v_0.Op != OpNeq64 { 15966 break 15967 } 15968 _ = v_0.Args[1] 15969 x := v_0.Args[0] 15970 y := v_0.Args[1] 15971 v.reset(OpEq64) 15972 v.AddArg(x) 15973 v.AddArg(y) 15974 return true 15975 } 15976 // match: (Not (Neq32 x y)) 15977 // cond: 15978 // result: (Eq32 x y) 15979 for { 15980 v_0 := v.Args[0] 15981 if v_0.Op != OpNeq32 { 15982 break 15983 } 15984 _ = v_0.Args[1] 15985 x := v_0.Args[0] 15986 y := v_0.Args[1] 15987 v.reset(OpEq32) 15988 v.AddArg(x) 15989 v.AddArg(y) 15990 return true 15991 } 15992 // match: (Not (Neq16 x y)) 15993 // cond: 15994 // result: (Eq16 x y) 15995 for { 15996 v_0 := v.Args[0] 15997 if v_0.Op != OpNeq16 { 15998 break 15999 } 16000 _ = v_0.Args[1] 16001 x := v_0.Args[0] 16002 y := v_0.Args[1] 16003 v.reset(OpEq16) 16004 v.AddArg(x) 16005 v.AddArg(y) 16006 return true 16007 } 16008 // match: (Not (Neq8 x y)) 16009 // cond: 16010 // result: (Eq8 x y) 16011 for { 16012 v_0 := v.Args[0] 16013 if v_0.Op != OpNeq8 { 16014 break 16015 } 16016 _ = v_0.Args[1] 16017 x := v_0.Args[0] 16018 y := v_0.Args[1] 16019 v.reset(OpEq8) 16020 v.AddArg(x) 16021 v.AddArg(y) 16022 return true 16023 } 16024 // match: (Not (NeqB x y)) 16025 // cond: 16026 // result: (EqB x y) 16027 for { 16028 v_0 := v.Args[0] 16029 if v_0.Op != OpNeqB { 16030 break 16031 } 16032 _ = v_0.Args[1] 16033 x := v_0.Args[0] 16034 y := v_0.Args[1] 16035 v.reset(OpEqB) 16036 v.AddArg(x) 16037 v.AddArg(y) 16038 return true 16039 } 16040 return false 16041 } 16042 func rewriteValuegeneric_OpNot_10(v *Value) bool { 16043 // match: (Not (Greater64 x y)) 16044 // cond: 16045 // result: (Leq64 x y) 16046 for { 16047 v_0 := v.Args[0] 16048 if v_0.Op != OpGreater64 { 16049 break 16050 } 16051 _ = v_0.Args[1] 16052 x := v_0.Args[0] 16053 y := v_0.Args[1] 16054 v.reset(OpLeq64) 16055 v.AddArg(x) 16056 v.AddArg(y) 16057 return true 16058 } 16059 // match: (Not (Greater32 x y)) 16060 // cond: 16061 // result: (Leq32 x y) 16062 for { 16063 v_0 := v.Args[0] 16064 if v_0.Op != OpGreater32 { 16065 break 16066 } 16067 _ = v_0.Args[1] 16068 x := v_0.Args[0] 16069 y := v_0.Args[1] 16070 v.reset(OpLeq32) 16071 v.AddArg(x) 16072 v.AddArg(y) 16073 return true 16074 } 16075 // match: (Not (Greater16 x y)) 16076 // cond: 16077 // result: (Leq16 x y) 16078 for { 16079 v_0 := v.Args[0] 16080 if v_0.Op != OpGreater16 { 16081 break 16082 } 16083 _ = v_0.Args[1] 16084 x := v_0.Args[0] 16085 y := v_0.Args[1] 16086 v.reset(OpLeq16) 16087 v.AddArg(x) 16088 v.AddArg(y) 16089 return true 16090 } 16091 // match: (Not (Greater8 x y)) 16092 // cond: 16093 // result: (Leq8 x y) 16094 for { 16095 v_0 := v.Args[0] 16096 if v_0.Op != OpGreater8 { 16097 break 16098 } 16099 _ = v_0.Args[1] 16100 x := v_0.Args[0] 16101 y := v_0.Args[1] 16102 v.reset(OpLeq8) 16103 v.AddArg(x) 16104 v.AddArg(y) 16105 return true 16106 } 16107 // match: (Not (Greater64U x y)) 16108 // cond: 16109 // result: (Leq64U x y) 16110 for { 16111 v_0 := v.Args[0] 16112 if v_0.Op != OpGreater64U { 16113 break 16114 } 16115 _ = v_0.Args[1] 16116 x := v_0.Args[0] 16117 y := v_0.Args[1] 16118 v.reset(OpLeq64U) 16119 v.AddArg(x) 16120 v.AddArg(y) 16121 return true 16122 } 16123 // match: (Not (Greater32U x y)) 16124 // cond: 16125 // result: (Leq32U x y) 16126 for { 16127 v_0 := v.Args[0] 16128 if v_0.Op != OpGreater32U { 16129 break 16130 } 16131 _ = v_0.Args[1] 16132 x := v_0.Args[0] 16133 y := v_0.Args[1] 16134 v.reset(OpLeq32U) 16135 v.AddArg(x) 16136 v.AddArg(y) 16137 return true 16138 } 16139 // match: (Not (Greater16U x y)) 16140 // cond: 16141 // result: (Leq16U x y) 16142 for { 16143 v_0 := v.Args[0] 16144 if v_0.Op != OpGreater16U { 16145 break 16146 } 16147 _ = v_0.Args[1] 16148 x := v_0.Args[0] 16149 y := v_0.Args[1] 16150 v.reset(OpLeq16U) 16151 v.AddArg(x) 16152 v.AddArg(y) 16153 return true 16154 } 16155 // match: (Not (Greater8U x y)) 16156 // cond: 16157 // result: (Leq8U x y) 16158 for { 16159 v_0 := v.Args[0] 16160 if v_0.Op != OpGreater8U { 16161 break 16162 } 16163 _ = v_0.Args[1] 16164 x := v_0.Args[0] 16165 y := v_0.Args[1] 16166 v.reset(OpLeq8U) 16167 v.AddArg(x) 16168 v.AddArg(y) 16169 return true 16170 } 16171 // match: (Not (Geq64 x y)) 16172 // cond: 16173 // result: (Less64 x y) 16174 for { 16175 v_0 := v.Args[0] 16176 if v_0.Op != OpGeq64 { 16177 break 16178 } 16179 _ = v_0.Args[1] 16180 x := v_0.Args[0] 16181 y := v_0.Args[1] 16182 v.reset(OpLess64) 16183 v.AddArg(x) 16184 v.AddArg(y) 16185 return true 16186 } 16187 // match: (Not (Geq32 x y)) 16188 // cond: 16189 // result: (Less32 x y) 16190 for { 16191 v_0 := v.Args[0] 16192 if v_0.Op != OpGeq32 { 16193 break 16194 } 16195 _ = v_0.Args[1] 16196 x := v_0.Args[0] 16197 y := v_0.Args[1] 16198 v.reset(OpLess32) 16199 v.AddArg(x) 16200 v.AddArg(y) 16201 return true 16202 } 16203 return false 16204 } 16205 func rewriteValuegeneric_OpNot_20(v *Value) bool { 16206 // match: (Not (Geq16 x y)) 16207 // cond: 16208 // result: (Less16 x y) 16209 for { 16210 v_0 := v.Args[0] 16211 if v_0.Op != OpGeq16 { 16212 break 16213 } 16214 _ = v_0.Args[1] 16215 x := v_0.Args[0] 16216 y := v_0.Args[1] 16217 v.reset(OpLess16) 16218 v.AddArg(x) 16219 v.AddArg(y) 16220 return true 16221 } 16222 // match: (Not (Geq8 x y)) 16223 // cond: 16224 // result: (Less8 x y) 16225 for { 16226 v_0 := v.Args[0] 16227 if v_0.Op != OpGeq8 { 16228 break 16229 } 16230 _ = v_0.Args[1] 16231 x := v_0.Args[0] 16232 y := v_0.Args[1] 16233 v.reset(OpLess8) 16234 v.AddArg(x) 16235 v.AddArg(y) 16236 return true 16237 } 16238 // match: (Not (Geq64U x y)) 16239 // cond: 16240 // result: (Less64U x y) 16241 for { 16242 v_0 := v.Args[0] 16243 if v_0.Op != OpGeq64U { 16244 break 16245 } 16246 _ = v_0.Args[1] 16247 x := v_0.Args[0] 16248 y := v_0.Args[1] 16249 v.reset(OpLess64U) 16250 v.AddArg(x) 16251 v.AddArg(y) 16252 return true 16253 } 16254 // match: (Not (Geq32U x y)) 16255 // cond: 16256 // result: (Less32U x y) 16257 for { 16258 v_0 := v.Args[0] 16259 if v_0.Op != OpGeq32U { 16260 break 16261 } 16262 _ = v_0.Args[1] 16263 x := v_0.Args[0] 16264 y := v_0.Args[1] 16265 v.reset(OpLess32U) 16266 v.AddArg(x) 16267 v.AddArg(y) 16268 return true 16269 } 16270 // match: (Not (Geq16U x y)) 16271 // cond: 16272 // result: (Less16U x y) 16273 for { 16274 v_0 := v.Args[0] 16275 if v_0.Op != OpGeq16U { 16276 break 16277 } 16278 _ = v_0.Args[1] 16279 x := v_0.Args[0] 16280 y := v_0.Args[1] 16281 v.reset(OpLess16U) 16282 v.AddArg(x) 16283 v.AddArg(y) 16284 return true 16285 } 16286 // match: (Not (Geq8U x y)) 16287 // cond: 16288 // result: (Less8U x y) 16289 for { 16290 v_0 := v.Args[0] 16291 if v_0.Op != OpGeq8U { 16292 break 16293 } 16294 _ = v_0.Args[1] 16295 x := v_0.Args[0] 16296 y := v_0.Args[1] 16297 v.reset(OpLess8U) 16298 v.AddArg(x) 16299 v.AddArg(y) 16300 return true 16301 } 16302 // match: (Not (Less64 x y)) 16303 // cond: 16304 // result: (Geq64 x y) 16305 for { 16306 v_0 := v.Args[0] 16307 if v_0.Op != OpLess64 { 16308 break 16309 } 16310 _ = v_0.Args[1] 16311 x := v_0.Args[0] 16312 y := v_0.Args[1] 16313 v.reset(OpGeq64) 16314 v.AddArg(x) 16315 v.AddArg(y) 16316 return true 16317 } 16318 // match: (Not (Less32 x y)) 16319 // cond: 16320 // result: (Geq32 x y) 16321 for { 16322 v_0 := v.Args[0] 16323 if v_0.Op != OpLess32 { 16324 break 16325 } 16326 _ = v_0.Args[1] 16327 x := v_0.Args[0] 16328 y := v_0.Args[1] 16329 v.reset(OpGeq32) 16330 v.AddArg(x) 16331 v.AddArg(y) 16332 return true 16333 } 16334 // match: (Not (Less16 x y)) 16335 // cond: 16336 // result: (Geq16 x y) 16337 for { 16338 v_0 := v.Args[0] 16339 if v_0.Op != OpLess16 { 16340 break 16341 } 16342 _ = v_0.Args[1] 16343 x := v_0.Args[0] 16344 y := v_0.Args[1] 16345 v.reset(OpGeq16) 16346 v.AddArg(x) 16347 v.AddArg(y) 16348 return true 16349 } 16350 // match: (Not (Less8 x y)) 16351 // cond: 16352 // result: (Geq8 x y) 16353 for { 16354 v_0 := v.Args[0] 16355 if v_0.Op != OpLess8 { 16356 break 16357 } 16358 _ = v_0.Args[1] 16359 x := v_0.Args[0] 16360 y := v_0.Args[1] 16361 v.reset(OpGeq8) 16362 v.AddArg(x) 16363 v.AddArg(y) 16364 return true 16365 } 16366 return false 16367 } 16368 func rewriteValuegeneric_OpNot_30(v *Value) bool { 16369 // match: (Not (Less64U x y)) 16370 // cond: 16371 // result: (Geq64U x y) 16372 for { 16373 v_0 := v.Args[0] 16374 if v_0.Op != OpLess64U { 16375 break 16376 } 16377 _ = v_0.Args[1] 16378 x := v_0.Args[0] 16379 y := v_0.Args[1] 16380 v.reset(OpGeq64U) 16381 v.AddArg(x) 16382 v.AddArg(y) 16383 return true 16384 } 16385 // match: (Not (Less32U x y)) 16386 // cond: 16387 // result: (Geq32U x y) 16388 for { 16389 v_0 := v.Args[0] 16390 if v_0.Op != OpLess32U { 16391 break 16392 } 16393 _ = v_0.Args[1] 16394 x := v_0.Args[0] 16395 y := v_0.Args[1] 16396 v.reset(OpGeq32U) 16397 v.AddArg(x) 16398 v.AddArg(y) 16399 return true 16400 } 16401 // match: (Not (Less16U x y)) 16402 // cond: 16403 // result: (Geq16U x y) 16404 for { 16405 v_0 := v.Args[0] 16406 if v_0.Op != OpLess16U { 16407 break 16408 } 16409 _ = v_0.Args[1] 16410 x := v_0.Args[0] 16411 y := v_0.Args[1] 16412 v.reset(OpGeq16U) 16413 v.AddArg(x) 16414 v.AddArg(y) 16415 return true 16416 } 16417 // match: (Not (Less8U x y)) 16418 // cond: 16419 // result: (Geq8U x y) 16420 for { 16421 v_0 := v.Args[0] 16422 if v_0.Op != OpLess8U { 16423 break 16424 } 16425 _ = v_0.Args[1] 16426 x := v_0.Args[0] 16427 y := v_0.Args[1] 16428 v.reset(OpGeq8U) 16429 v.AddArg(x) 16430 v.AddArg(y) 16431 return true 16432 } 16433 // match: (Not (Leq64 x y)) 16434 // cond: 16435 // result: (Greater64 x y) 16436 for { 16437 v_0 := v.Args[0] 16438 if v_0.Op != OpLeq64 { 16439 break 16440 } 16441 _ = v_0.Args[1] 16442 x := v_0.Args[0] 16443 y := v_0.Args[1] 16444 v.reset(OpGreater64) 16445 v.AddArg(x) 16446 v.AddArg(y) 16447 return true 16448 } 16449 // match: (Not (Leq32 x y)) 16450 // cond: 16451 // result: (Greater32 x y) 16452 for { 16453 v_0 := v.Args[0] 16454 if v_0.Op != OpLeq32 { 16455 break 16456 } 16457 _ = v_0.Args[1] 16458 x := v_0.Args[0] 16459 y := v_0.Args[1] 16460 v.reset(OpGreater32) 16461 v.AddArg(x) 16462 v.AddArg(y) 16463 return true 16464 } 16465 // match: (Not (Leq16 x y)) 16466 // cond: 16467 // result: (Greater16 x y) 16468 for { 16469 v_0 := v.Args[0] 16470 if v_0.Op != OpLeq16 { 16471 break 16472 } 16473 _ = v_0.Args[1] 16474 x := v_0.Args[0] 16475 y := v_0.Args[1] 16476 v.reset(OpGreater16) 16477 v.AddArg(x) 16478 v.AddArg(y) 16479 return true 16480 } 16481 // match: (Not (Leq8 x y)) 16482 // cond: 16483 // result: (Greater8 x y) 16484 for { 16485 v_0 := v.Args[0] 16486 if v_0.Op != OpLeq8 { 16487 break 16488 } 16489 _ = v_0.Args[1] 16490 x := v_0.Args[0] 16491 y := v_0.Args[1] 16492 v.reset(OpGreater8) 16493 v.AddArg(x) 16494 v.AddArg(y) 16495 return true 16496 } 16497 // match: (Not (Leq64U x y)) 16498 // cond: 16499 // result: (Greater64U x y) 16500 for { 16501 v_0 := v.Args[0] 16502 if v_0.Op != OpLeq64U { 16503 break 16504 } 16505 _ = v_0.Args[1] 16506 x := v_0.Args[0] 16507 y := v_0.Args[1] 16508 v.reset(OpGreater64U) 16509 v.AddArg(x) 16510 v.AddArg(y) 16511 return true 16512 } 16513 // match: (Not (Leq32U x y)) 16514 // cond: 16515 // result: (Greater32U x y) 16516 for { 16517 v_0 := v.Args[0] 16518 if v_0.Op != OpLeq32U { 16519 break 16520 } 16521 _ = v_0.Args[1] 16522 x := v_0.Args[0] 16523 y := v_0.Args[1] 16524 v.reset(OpGreater32U) 16525 v.AddArg(x) 16526 v.AddArg(y) 16527 return true 16528 } 16529 return false 16530 } 16531 func rewriteValuegeneric_OpNot_40(v *Value) bool { 16532 // match: (Not (Leq16U x y)) 16533 // cond: 16534 // result: (Greater16U x y) 16535 for { 16536 v_0 := v.Args[0] 16537 if v_0.Op != OpLeq16U { 16538 break 16539 } 16540 _ = v_0.Args[1] 16541 x := v_0.Args[0] 16542 y := v_0.Args[1] 16543 v.reset(OpGreater16U) 16544 v.AddArg(x) 16545 v.AddArg(y) 16546 return true 16547 } 16548 // match: (Not (Leq8U x y)) 16549 // cond: 16550 // result: (Greater8U x y) 16551 for { 16552 v_0 := v.Args[0] 16553 if v_0.Op != OpLeq8U { 16554 break 16555 } 16556 _ = v_0.Args[1] 16557 x := v_0.Args[0] 16558 y := v_0.Args[1] 16559 v.reset(OpGreater8U) 16560 v.AddArg(x) 16561 v.AddArg(y) 16562 return true 16563 } 16564 return false 16565 } 16566 func rewriteValuegeneric_OpOffPtr_0(v *Value) bool { 16567 // match: (OffPtr (OffPtr p [b]) [a]) 16568 // cond: 16569 // result: (OffPtr p [a+b]) 16570 for { 16571 a := v.AuxInt 16572 v_0 := v.Args[0] 16573 if v_0.Op != OpOffPtr { 16574 break 16575 } 16576 b := v_0.AuxInt 16577 p := v_0.Args[0] 16578 v.reset(OpOffPtr) 16579 v.AuxInt = a + b 16580 v.AddArg(p) 16581 return true 16582 } 16583 // match: (OffPtr p [0]) 16584 // cond: v.Type.Compare(p.Type) == types.CMPeq 16585 // result: p 16586 for { 16587 if v.AuxInt != 0 { 16588 break 16589 } 16590 p := v.Args[0] 16591 if !(v.Type.Compare(p.Type) == types.CMPeq) { 16592 break 16593 } 16594 v.reset(OpCopy) 16595 v.Type = p.Type 16596 v.AddArg(p) 16597 return true 16598 } 16599 return false 16600 } 16601 func rewriteValuegeneric_OpOr16_0(v *Value) bool { 16602 // match: (Or16 (Const16 [c]) (Const16 [d])) 16603 // cond: 16604 // result: (Const16 [int64(int16(c|d))]) 16605 for { 16606 _ = v.Args[1] 16607 v_0 := v.Args[0] 16608 if v_0.Op != OpConst16 { 16609 break 16610 } 16611 c := v_0.AuxInt 16612 v_1 := v.Args[1] 16613 if v_1.Op != OpConst16 { 16614 break 16615 } 16616 d := v_1.AuxInt 16617 v.reset(OpConst16) 16618 v.AuxInt = int64(int16(c | d)) 16619 return true 16620 } 16621 // match: (Or16 (Const16 [d]) (Const16 [c])) 16622 // cond: 16623 // result: (Const16 [int64(int16(c|d))]) 16624 for { 16625 _ = v.Args[1] 16626 v_0 := v.Args[0] 16627 if v_0.Op != OpConst16 { 16628 break 16629 } 16630 d := v_0.AuxInt 16631 v_1 := v.Args[1] 16632 if v_1.Op != OpConst16 { 16633 break 16634 } 16635 c := v_1.AuxInt 16636 v.reset(OpConst16) 16637 v.AuxInt = int64(int16(c | d)) 16638 return true 16639 } 16640 // match: (Or16 x x) 16641 // cond: 16642 // result: x 16643 for { 16644 _ = v.Args[1] 16645 x := v.Args[0] 16646 if x != v.Args[1] { 16647 break 16648 } 16649 v.reset(OpCopy) 16650 v.Type = x.Type 16651 v.AddArg(x) 16652 return true 16653 } 16654 // match: (Or16 (Const16 [0]) x) 16655 // cond: 16656 // result: x 16657 for { 16658 _ = v.Args[1] 16659 v_0 := v.Args[0] 16660 if v_0.Op != OpConst16 { 16661 break 16662 } 16663 if v_0.AuxInt != 0 { 16664 break 16665 } 16666 x := v.Args[1] 16667 v.reset(OpCopy) 16668 v.Type = x.Type 16669 v.AddArg(x) 16670 return true 16671 } 16672 // match: (Or16 x (Const16 [0])) 16673 // cond: 16674 // result: x 16675 for { 16676 _ = v.Args[1] 16677 x := v.Args[0] 16678 v_1 := v.Args[1] 16679 if v_1.Op != OpConst16 { 16680 break 16681 } 16682 if v_1.AuxInt != 0 { 16683 break 16684 } 16685 v.reset(OpCopy) 16686 v.Type = x.Type 16687 v.AddArg(x) 16688 return true 16689 } 16690 // match: (Or16 (Const16 [-1]) _) 16691 // cond: 16692 // result: (Const16 [-1]) 16693 for { 16694 _ = v.Args[1] 16695 v_0 := v.Args[0] 16696 if v_0.Op != OpConst16 { 16697 break 16698 } 16699 if v_0.AuxInt != -1 { 16700 break 16701 } 16702 v.reset(OpConst16) 16703 v.AuxInt = -1 16704 return true 16705 } 16706 // match: (Or16 _ (Const16 [-1])) 16707 // cond: 16708 // result: (Const16 [-1]) 16709 for { 16710 _ = v.Args[1] 16711 v_1 := v.Args[1] 16712 if v_1.Op != OpConst16 { 16713 break 16714 } 16715 if v_1.AuxInt != -1 { 16716 break 16717 } 16718 v.reset(OpConst16) 16719 v.AuxInt = -1 16720 return true 16721 } 16722 // match: (Or16 x (Or16 x y)) 16723 // cond: 16724 // result: (Or16 x y) 16725 for { 16726 _ = v.Args[1] 16727 x := v.Args[0] 16728 v_1 := v.Args[1] 16729 if v_1.Op != OpOr16 { 16730 break 16731 } 16732 _ = v_1.Args[1] 16733 if x != v_1.Args[0] { 16734 break 16735 } 16736 y := v_1.Args[1] 16737 v.reset(OpOr16) 16738 v.AddArg(x) 16739 v.AddArg(y) 16740 return true 16741 } 16742 // match: (Or16 x (Or16 y x)) 16743 // cond: 16744 // result: (Or16 x y) 16745 for { 16746 _ = v.Args[1] 16747 x := v.Args[0] 16748 v_1 := v.Args[1] 16749 if v_1.Op != OpOr16 { 16750 break 16751 } 16752 _ = v_1.Args[1] 16753 y := v_1.Args[0] 16754 if x != v_1.Args[1] { 16755 break 16756 } 16757 v.reset(OpOr16) 16758 v.AddArg(x) 16759 v.AddArg(y) 16760 return true 16761 } 16762 // match: (Or16 (Or16 x y) x) 16763 // cond: 16764 // result: (Or16 x y) 16765 for { 16766 _ = v.Args[1] 16767 v_0 := v.Args[0] 16768 if v_0.Op != OpOr16 { 16769 break 16770 } 16771 _ = v_0.Args[1] 16772 x := v_0.Args[0] 16773 y := v_0.Args[1] 16774 if x != v.Args[1] { 16775 break 16776 } 16777 v.reset(OpOr16) 16778 v.AddArg(x) 16779 v.AddArg(y) 16780 return true 16781 } 16782 return false 16783 } 16784 func rewriteValuegeneric_OpOr16_10(v *Value) bool { 16785 b := v.Block 16786 _ = b 16787 // match: (Or16 (Or16 y x) x) 16788 // cond: 16789 // result: (Or16 x y) 16790 for { 16791 _ = v.Args[1] 16792 v_0 := v.Args[0] 16793 if v_0.Op != OpOr16 { 16794 break 16795 } 16796 _ = v_0.Args[1] 16797 y := v_0.Args[0] 16798 x := v_0.Args[1] 16799 if x != v.Args[1] { 16800 break 16801 } 16802 v.reset(OpOr16) 16803 v.AddArg(x) 16804 v.AddArg(y) 16805 return true 16806 } 16807 // match: (Or16 (And16 x (Const16 [c2])) (Const16 <t> [c1])) 16808 // cond: ^(c1 | c2) == 0 16809 // result: (Or16 (Const16 <t> [c1]) x) 16810 for { 16811 _ = v.Args[1] 16812 v_0 := v.Args[0] 16813 if v_0.Op != OpAnd16 { 16814 break 16815 } 16816 _ = v_0.Args[1] 16817 x := v_0.Args[0] 16818 v_0_1 := v_0.Args[1] 16819 if v_0_1.Op != OpConst16 { 16820 break 16821 } 16822 c2 := v_0_1.AuxInt 16823 v_1 := v.Args[1] 16824 if v_1.Op != OpConst16 { 16825 break 16826 } 16827 t := v_1.Type 16828 c1 := v_1.AuxInt 16829 if !(^(c1 | c2) == 0) { 16830 break 16831 } 16832 v.reset(OpOr16) 16833 v0 := b.NewValue0(v.Pos, OpConst16, t) 16834 v0.AuxInt = c1 16835 v.AddArg(v0) 16836 v.AddArg(x) 16837 return true 16838 } 16839 // match: (Or16 (And16 (Const16 [c2]) x) (Const16 <t> [c1])) 16840 // cond: ^(c1 | c2) == 0 16841 // result: (Or16 (Const16 <t> [c1]) x) 16842 for { 16843 _ = v.Args[1] 16844 v_0 := v.Args[0] 16845 if v_0.Op != OpAnd16 { 16846 break 16847 } 16848 _ = v_0.Args[1] 16849 v_0_0 := v_0.Args[0] 16850 if v_0_0.Op != OpConst16 { 16851 break 16852 } 16853 c2 := v_0_0.AuxInt 16854 x := v_0.Args[1] 16855 v_1 := v.Args[1] 16856 if v_1.Op != OpConst16 { 16857 break 16858 } 16859 t := v_1.Type 16860 c1 := v_1.AuxInt 16861 if !(^(c1 | c2) == 0) { 16862 break 16863 } 16864 v.reset(OpOr16) 16865 v0 := b.NewValue0(v.Pos, OpConst16, t) 16866 v0.AuxInt = c1 16867 v.AddArg(v0) 16868 v.AddArg(x) 16869 return true 16870 } 16871 // match: (Or16 (Const16 <t> [c1]) (And16 x (Const16 [c2]))) 16872 // cond: ^(c1 | c2) == 0 16873 // result: (Or16 (Const16 <t> [c1]) x) 16874 for { 16875 _ = v.Args[1] 16876 v_0 := v.Args[0] 16877 if v_0.Op != OpConst16 { 16878 break 16879 } 16880 t := v_0.Type 16881 c1 := v_0.AuxInt 16882 v_1 := v.Args[1] 16883 if v_1.Op != OpAnd16 { 16884 break 16885 } 16886 _ = v_1.Args[1] 16887 x := v_1.Args[0] 16888 v_1_1 := v_1.Args[1] 16889 if v_1_1.Op != OpConst16 { 16890 break 16891 } 16892 c2 := v_1_1.AuxInt 16893 if !(^(c1 | c2) == 0) { 16894 break 16895 } 16896 v.reset(OpOr16) 16897 v0 := b.NewValue0(v.Pos, OpConst16, t) 16898 v0.AuxInt = c1 16899 v.AddArg(v0) 16900 v.AddArg(x) 16901 return true 16902 } 16903 // match: (Or16 (Const16 <t> [c1]) (And16 (Const16 [c2]) x)) 16904 // cond: ^(c1 | c2) == 0 16905 // result: (Or16 (Const16 <t> [c1]) x) 16906 for { 16907 _ = v.Args[1] 16908 v_0 := v.Args[0] 16909 if v_0.Op != OpConst16 { 16910 break 16911 } 16912 t := v_0.Type 16913 c1 := v_0.AuxInt 16914 v_1 := v.Args[1] 16915 if v_1.Op != OpAnd16 { 16916 break 16917 } 16918 _ = v_1.Args[1] 16919 v_1_0 := v_1.Args[0] 16920 if v_1_0.Op != OpConst16 { 16921 break 16922 } 16923 c2 := v_1_0.AuxInt 16924 x := v_1.Args[1] 16925 if !(^(c1 | c2) == 0) { 16926 break 16927 } 16928 v.reset(OpOr16) 16929 v0 := b.NewValue0(v.Pos, OpConst16, t) 16930 v0.AuxInt = c1 16931 v.AddArg(v0) 16932 v.AddArg(x) 16933 return true 16934 } 16935 // match: (Or16 (Or16 i:(Const16 <t>) z) x) 16936 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 16937 // result: (Or16 i (Or16 <t> z x)) 16938 for { 16939 _ = v.Args[1] 16940 v_0 := v.Args[0] 16941 if v_0.Op != OpOr16 { 16942 break 16943 } 16944 _ = v_0.Args[1] 16945 i := v_0.Args[0] 16946 if i.Op != OpConst16 { 16947 break 16948 } 16949 t := i.Type 16950 z := v_0.Args[1] 16951 x := v.Args[1] 16952 if !(z.Op != OpConst16 && x.Op != OpConst16) { 16953 break 16954 } 16955 v.reset(OpOr16) 16956 v.AddArg(i) 16957 v0 := b.NewValue0(v.Pos, OpOr16, t) 16958 v0.AddArg(z) 16959 v0.AddArg(x) 16960 v.AddArg(v0) 16961 return true 16962 } 16963 // match: (Or16 (Or16 z i:(Const16 <t>)) x) 16964 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 16965 // result: (Or16 i (Or16 <t> z x)) 16966 for { 16967 _ = v.Args[1] 16968 v_0 := v.Args[0] 16969 if v_0.Op != OpOr16 { 16970 break 16971 } 16972 _ = v_0.Args[1] 16973 z := v_0.Args[0] 16974 i := v_0.Args[1] 16975 if i.Op != OpConst16 { 16976 break 16977 } 16978 t := i.Type 16979 x := v.Args[1] 16980 if !(z.Op != OpConst16 && x.Op != OpConst16) { 16981 break 16982 } 16983 v.reset(OpOr16) 16984 v.AddArg(i) 16985 v0 := b.NewValue0(v.Pos, OpOr16, t) 16986 v0.AddArg(z) 16987 v0.AddArg(x) 16988 v.AddArg(v0) 16989 return true 16990 } 16991 // match: (Or16 x (Or16 i:(Const16 <t>) z)) 16992 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 16993 // result: (Or16 i (Or16 <t> z x)) 16994 for { 16995 _ = v.Args[1] 16996 x := v.Args[0] 16997 v_1 := v.Args[1] 16998 if v_1.Op != OpOr16 { 16999 break 17000 } 17001 _ = v_1.Args[1] 17002 i := v_1.Args[0] 17003 if i.Op != OpConst16 { 17004 break 17005 } 17006 t := i.Type 17007 z := v_1.Args[1] 17008 if !(z.Op != OpConst16 && x.Op != OpConst16) { 17009 break 17010 } 17011 v.reset(OpOr16) 17012 v.AddArg(i) 17013 v0 := b.NewValue0(v.Pos, OpOr16, t) 17014 v0.AddArg(z) 17015 v0.AddArg(x) 17016 v.AddArg(v0) 17017 return true 17018 } 17019 // match: (Or16 x (Or16 z i:(Const16 <t>))) 17020 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 17021 // result: (Or16 i (Or16 <t> z x)) 17022 for { 17023 _ = v.Args[1] 17024 x := v.Args[0] 17025 v_1 := v.Args[1] 17026 if v_1.Op != OpOr16 { 17027 break 17028 } 17029 _ = v_1.Args[1] 17030 z := v_1.Args[0] 17031 i := v_1.Args[1] 17032 if i.Op != OpConst16 { 17033 break 17034 } 17035 t := i.Type 17036 if !(z.Op != OpConst16 && x.Op != OpConst16) { 17037 break 17038 } 17039 v.reset(OpOr16) 17040 v.AddArg(i) 17041 v0 := b.NewValue0(v.Pos, OpOr16, t) 17042 v0.AddArg(z) 17043 v0.AddArg(x) 17044 v.AddArg(v0) 17045 return true 17046 } 17047 // match: (Or16 (Const16 <t> [c]) (Or16 (Const16 <t> [d]) x)) 17048 // cond: 17049 // result: (Or16 (Const16 <t> [int64(int16(c|d))]) x) 17050 for { 17051 _ = v.Args[1] 17052 v_0 := v.Args[0] 17053 if v_0.Op != OpConst16 { 17054 break 17055 } 17056 t := v_0.Type 17057 c := v_0.AuxInt 17058 v_1 := v.Args[1] 17059 if v_1.Op != OpOr16 { 17060 break 17061 } 17062 _ = v_1.Args[1] 17063 v_1_0 := v_1.Args[0] 17064 if v_1_0.Op != OpConst16 { 17065 break 17066 } 17067 if v_1_0.Type != t { 17068 break 17069 } 17070 d := v_1_0.AuxInt 17071 x := v_1.Args[1] 17072 v.reset(OpOr16) 17073 v0 := b.NewValue0(v.Pos, OpConst16, t) 17074 v0.AuxInt = int64(int16(c | d)) 17075 v.AddArg(v0) 17076 v.AddArg(x) 17077 return true 17078 } 17079 return false 17080 } 17081 func rewriteValuegeneric_OpOr16_20(v *Value) bool { 17082 b := v.Block 17083 _ = b 17084 // match: (Or16 (Const16 <t> [c]) (Or16 x (Const16 <t> [d]))) 17085 // cond: 17086 // result: (Or16 (Const16 <t> [int64(int16(c|d))]) x) 17087 for { 17088 _ = v.Args[1] 17089 v_0 := v.Args[0] 17090 if v_0.Op != OpConst16 { 17091 break 17092 } 17093 t := v_0.Type 17094 c := v_0.AuxInt 17095 v_1 := v.Args[1] 17096 if v_1.Op != OpOr16 { 17097 break 17098 } 17099 _ = v_1.Args[1] 17100 x := v_1.Args[0] 17101 v_1_1 := v_1.Args[1] 17102 if v_1_1.Op != OpConst16 { 17103 break 17104 } 17105 if v_1_1.Type != t { 17106 break 17107 } 17108 d := v_1_1.AuxInt 17109 v.reset(OpOr16) 17110 v0 := b.NewValue0(v.Pos, OpConst16, t) 17111 v0.AuxInt = int64(int16(c | d)) 17112 v.AddArg(v0) 17113 v.AddArg(x) 17114 return true 17115 } 17116 // match: (Or16 (Or16 (Const16 <t> [d]) x) (Const16 <t> [c])) 17117 // cond: 17118 // result: (Or16 (Const16 <t> [int64(int16(c|d))]) x) 17119 for { 17120 _ = v.Args[1] 17121 v_0 := v.Args[0] 17122 if v_0.Op != OpOr16 { 17123 break 17124 } 17125 _ = v_0.Args[1] 17126 v_0_0 := v_0.Args[0] 17127 if v_0_0.Op != OpConst16 { 17128 break 17129 } 17130 t := v_0_0.Type 17131 d := v_0_0.AuxInt 17132 x := v_0.Args[1] 17133 v_1 := v.Args[1] 17134 if v_1.Op != OpConst16 { 17135 break 17136 } 17137 if v_1.Type != t { 17138 break 17139 } 17140 c := v_1.AuxInt 17141 v.reset(OpOr16) 17142 v0 := b.NewValue0(v.Pos, OpConst16, t) 17143 v0.AuxInt = int64(int16(c | d)) 17144 v.AddArg(v0) 17145 v.AddArg(x) 17146 return true 17147 } 17148 // match: (Or16 (Or16 x (Const16 <t> [d])) (Const16 <t> [c])) 17149 // cond: 17150 // result: (Or16 (Const16 <t> [int64(int16(c|d))]) x) 17151 for { 17152 _ = v.Args[1] 17153 v_0 := v.Args[0] 17154 if v_0.Op != OpOr16 { 17155 break 17156 } 17157 _ = v_0.Args[1] 17158 x := v_0.Args[0] 17159 v_0_1 := v_0.Args[1] 17160 if v_0_1.Op != OpConst16 { 17161 break 17162 } 17163 t := v_0_1.Type 17164 d := v_0_1.AuxInt 17165 v_1 := v.Args[1] 17166 if v_1.Op != OpConst16 { 17167 break 17168 } 17169 if v_1.Type != t { 17170 break 17171 } 17172 c := v_1.AuxInt 17173 v.reset(OpOr16) 17174 v0 := b.NewValue0(v.Pos, OpConst16, t) 17175 v0.AuxInt = int64(int16(c | d)) 17176 v.AddArg(v0) 17177 v.AddArg(x) 17178 return true 17179 } 17180 return false 17181 } 17182 func rewriteValuegeneric_OpOr32_0(v *Value) bool { 17183 // match: (Or32 (Const32 [c]) (Const32 [d])) 17184 // cond: 17185 // result: (Const32 [int64(int32(c|d))]) 17186 for { 17187 _ = v.Args[1] 17188 v_0 := v.Args[0] 17189 if v_0.Op != OpConst32 { 17190 break 17191 } 17192 c := v_0.AuxInt 17193 v_1 := v.Args[1] 17194 if v_1.Op != OpConst32 { 17195 break 17196 } 17197 d := v_1.AuxInt 17198 v.reset(OpConst32) 17199 v.AuxInt = int64(int32(c | d)) 17200 return true 17201 } 17202 // match: (Or32 (Const32 [d]) (Const32 [c])) 17203 // cond: 17204 // result: (Const32 [int64(int32(c|d))]) 17205 for { 17206 _ = v.Args[1] 17207 v_0 := v.Args[0] 17208 if v_0.Op != OpConst32 { 17209 break 17210 } 17211 d := v_0.AuxInt 17212 v_1 := v.Args[1] 17213 if v_1.Op != OpConst32 { 17214 break 17215 } 17216 c := v_1.AuxInt 17217 v.reset(OpConst32) 17218 v.AuxInt = int64(int32(c | d)) 17219 return true 17220 } 17221 // match: (Or32 x x) 17222 // cond: 17223 // result: x 17224 for { 17225 _ = v.Args[1] 17226 x := v.Args[0] 17227 if x != v.Args[1] { 17228 break 17229 } 17230 v.reset(OpCopy) 17231 v.Type = x.Type 17232 v.AddArg(x) 17233 return true 17234 } 17235 // match: (Or32 (Const32 [0]) x) 17236 // cond: 17237 // result: x 17238 for { 17239 _ = v.Args[1] 17240 v_0 := v.Args[0] 17241 if v_0.Op != OpConst32 { 17242 break 17243 } 17244 if v_0.AuxInt != 0 { 17245 break 17246 } 17247 x := v.Args[1] 17248 v.reset(OpCopy) 17249 v.Type = x.Type 17250 v.AddArg(x) 17251 return true 17252 } 17253 // match: (Or32 x (Const32 [0])) 17254 // cond: 17255 // result: x 17256 for { 17257 _ = v.Args[1] 17258 x := v.Args[0] 17259 v_1 := v.Args[1] 17260 if v_1.Op != OpConst32 { 17261 break 17262 } 17263 if v_1.AuxInt != 0 { 17264 break 17265 } 17266 v.reset(OpCopy) 17267 v.Type = x.Type 17268 v.AddArg(x) 17269 return true 17270 } 17271 // match: (Or32 (Const32 [-1]) _) 17272 // cond: 17273 // result: (Const32 [-1]) 17274 for { 17275 _ = v.Args[1] 17276 v_0 := v.Args[0] 17277 if v_0.Op != OpConst32 { 17278 break 17279 } 17280 if v_0.AuxInt != -1 { 17281 break 17282 } 17283 v.reset(OpConst32) 17284 v.AuxInt = -1 17285 return true 17286 } 17287 // match: (Or32 _ (Const32 [-1])) 17288 // cond: 17289 // result: (Const32 [-1]) 17290 for { 17291 _ = v.Args[1] 17292 v_1 := v.Args[1] 17293 if v_1.Op != OpConst32 { 17294 break 17295 } 17296 if v_1.AuxInt != -1 { 17297 break 17298 } 17299 v.reset(OpConst32) 17300 v.AuxInt = -1 17301 return true 17302 } 17303 // match: (Or32 x (Or32 x y)) 17304 // cond: 17305 // result: (Or32 x y) 17306 for { 17307 _ = v.Args[1] 17308 x := v.Args[0] 17309 v_1 := v.Args[1] 17310 if v_1.Op != OpOr32 { 17311 break 17312 } 17313 _ = v_1.Args[1] 17314 if x != v_1.Args[0] { 17315 break 17316 } 17317 y := v_1.Args[1] 17318 v.reset(OpOr32) 17319 v.AddArg(x) 17320 v.AddArg(y) 17321 return true 17322 } 17323 // match: (Or32 x (Or32 y x)) 17324 // cond: 17325 // result: (Or32 x y) 17326 for { 17327 _ = v.Args[1] 17328 x := v.Args[0] 17329 v_1 := v.Args[1] 17330 if v_1.Op != OpOr32 { 17331 break 17332 } 17333 _ = v_1.Args[1] 17334 y := v_1.Args[0] 17335 if x != v_1.Args[1] { 17336 break 17337 } 17338 v.reset(OpOr32) 17339 v.AddArg(x) 17340 v.AddArg(y) 17341 return true 17342 } 17343 // match: (Or32 (Or32 x y) x) 17344 // cond: 17345 // result: (Or32 x y) 17346 for { 17347 _ = v.Args[1] 17348 v_0 := v.Args[0] 17349 if v_0.Op != OpOr32 { 17350 break 17351 } 17352 _ = v_0.Args[1] 17353 x := v_0.Args[0] 17354 y := v_0.Args[1] 17355 if x != v.Args[1] { 17356 break 17357 } 17358 v.reset(OpOr32) 17359 v.AddArg(x) 17360 v.AddArg(y) 17361 return true 17362 } 17363 return false 17364 } 17365 func rewriteValuegeneric_OpOr32_10(v *Value) bool { 17366 b := v.Block 17367 _ = b 17368 // match: (Or32 (Or32 y x) x) 17369 // cond: 17370 // result: (Or32 x y) 17371 for { 17372 _ = v.Args[1] 17373 v_0 := v.Args[0] 17374 if v_0.Op != OpOr32 { 17375 break 17376 } 17377 _ = v_0.Args[1] 17378 y := v_0.Args[0] 17379 x := v_0.Args[1] 17380 if x != v.Args[1] { 17381 break 17382 } 17383 v.reset(OpOr32) 17384 v.AddArg(x) 17385 v.AddArg(y) 17386 return true 17387 } 17388 // match: (Or32 (And32 x (Const32 [c2])) (Const32 <t> [c1])) 17389 // cond: ^(c1 | c2) == 0 17390 // result: (Or32 (Const32 <t> [c1]) x) 17391 for { 17392 _ = v.Args[1] 17393 v_0 := v.Args[0] 17394 if v_0.Op != OpAnd32 { 17395 break 17396 } 17397 _ = v_0.Args[1] 17398 x := v_0.Args[0] 17399 v_0_1 := v_0.Args[1] 17400 if v_0_1.Op != OpConst32 { 17401 break 17402 } 17403 c2 := v_0_1.AuxInt 17404 v_1 := v.Args[1] 17405 if v_1.Op != OpConst32 { 17406 break 17407 } 17408 t := v_1.Type 17409 c1 := v_1.AuxInt 17410 if !(^(c1 | c2) == 0) { 17411 break 17412 } 17413 v.reset(OpOr32) 17414 v0 := b.NewValue0(v.Pos, OpConst32, t) 17415 v0.AuxInt = c1 17416 v.AddArg(v0) 17417 v.AddArg(x) 17418 return true 17419 } 17420 // match: (Or32 (And32 (Const32 [c2]) x) (Const32 <t> [c1])) 17421 // cond: ^(c1 | c2) == 0 17422 // result: (Or32 (Const32 <t> [c1]) x) 17423 for { 17424 _ = v.Args[1] 17425 v_0 := v.Args[0] 17426 if v_0.Op != OpAnd32 { 17427 break 17428 } 17429 _ = v_0.Args[1] 17430 v_0_0 := v_0.Args[0] 17431 if v_0_0.Op != OpConst32 { 17432 break 17433 } 17434 c2 := v_0_0.AuxInt 17435 x := v_0.Args[1] 17436 v_1 := v.Args[1] 17437 if v_1.Op != OpConst32 { 17438 break 17439 } 17440 t := v_1.Type 17441 c1 := v_1.AuxInt 17442 if !(^(c1 | c2) == 0) { 17443 break 17444 } 17445 v.reset(OpOr32) 17446 v0 := b.NewValue0(v.Pos, OpConst32, t) 17447 v0.AuxInt = c1 17448 v.AddArg(v0) 17449 v.AddArg(x) 17450 return true 17451 } 17452 // match: (Or32 (Const32 <t> [c1]) (And32 x (Const32 [c2]))) 17453 // cond: ^(c1 | c2) == 0 17454 // result: (Or32 (Const32 <t> [c1]) x) 17455 for { 17456 _ = v.Args[1] 17457 v_0 := v.Args[0] 17458 if v_0.Op != OpConst32 { 17459 break 17460 } 17461 t := v_0.Type 17462 c1 := v_0.AuxInt 17463 v_1 := v.Args[1] 17464 if v_1.Op != OpAnd32 { 17465 break 17466 } 17467 _ = v_1.Args[1] 17468 x := v_1.Args[0] 17469 v_1_1 := v_1.Args[1] 17470 if v_1_1.Op != OpConst32 { 17471 break 17472 } 17473 c2 := v_1_1.AuxInt 17474 if !(^(c1 | c2) == 0) { 17475 break 17476 } 17477 v.reset(OpOr32) 17478 v0 := b.NewValue0(v.Pos, OpConst32, t) 17479 v0.AuxInt = c1 17480 v.AddArg(v0) 17481 v.AddArg(x) 17482 return true 17483 } 17484 // match: (Or32 (Const32 <t> [c1]) (And32 (Const32 [c2]) x)) 17485 // cond: ^(c1 | c2) == 0 17486 // result: (Or32 (Const32 <t> [c1]) x) 17487 for { 17488 _ = v.Args[1] 17489 v_0 := v.Args[0] 17490 if v_0.Op != OpConst32 { 17491 break 17492 } 17493 t := v_0.Type 17494 c1 := v_0.AuxInt 17495 v_1 := v.Args[1] 17496 if v_1.Op != OpAnd32 { 17497 break 17498 } 17499 _ = v_1.Args[1] 17500 v_1_0 := v_1.Args[0] 17501 if v_1_0.Op != OpConst32 { 17502 break 17503 } 17504 c2 := v_1_0.AuxInt 17505 x := v_1.Args[1] 17506 if !(^(c1 | c2) == 0) { 17507 break 17508 } 17509 v.reset(OpOr32) 17510 v0 := b.NewValue0(v.Pos, OpConst32, t) 17511 v0.AuxInt = c1 17512 v.AddArg(v0) 17513 v.AddArg(x) 17514 return true 17515 } 17516 // match: (Or32 (Or32 i:(Const32 <t>) z) x) 17517 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 17518 // result: (Or32 i (Or32 <t> z x)) 17519 for { 17520 _ = v.Args[1] 17521 v_0 := v.Args[0] 17522 if v_0.Op != OpOr32 { 17523 break 17524 } 17525 _ = v_0.Args[1] 17526 i := v_0.Args[0] 17527 if i.Op != OpConst32 { 17528 break 17529 } 17530 t := i.Type 17531 z := v_0.Args[1] 17532 x := v.Args[1] 17533 if !(z.Op != OpConst32 && x.Op != OpConst32) { 17534 break 17535 } 17536 v.reset(OpOr32) 17537 v.AddArg(i) 17538 v0 := b.NewValue0(v.Pos, OpOr32, t) 17539 v0.AddArg(z) 17540 v0.AddArg(x) 17541 v.AddArg(v0) 17542 return true 17543 } 17544 // match: (Or32 (Or32 z i:(Const32 <t>)) x) 17545 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 17546 // result: (Or32 i (Or32 <t> z x)) 17547 for { 17548 _ = v.Args[1] 17549 v_0 := v.Args[0] 17550 if v_0.Op != OpOr32 { 17551 break 17552 } 17553 _ = v_0.Args[1] 17554 z := v_0.Args[0] 17555 i := v_0.Args[1] 17556 if i.Op != OpConst32 { 17557 break 17558 } 17559 t := i.Type 17560 x := v.Args[1] 17561 if !(z.Op != OpConst32 && x.Op != OpConst32) { 17562 break 17563 } 17564 v.reset(OpOr32) 17565 v.AddArg(i) 17566 v0 := b.NewValue0(v.Pos, OpOr32, t) 17567 v0.AddArg(z) 17568 v0.AddArg(x) 17569 v.AddArg(v0) 17570 return true 17571 } 17572 // match: (Or32 x (Or32 i:(Const32 <t>) z)) 17573 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 17574 // result: (Or32 i (Or32 <t> z x)) 17575 for { 17576 _ = v.Args[1] 17577 x := v.Args[0] 17578 v_1 := v.Args[1] 17579 if v_1.Op != OpOr32 { 17580 break 17581 } 17582 _ = v_1.Args[1] 17583 i := v_1.Args[0] 17584 if i.Op != OpConst32 { 17585 break 17586 } 17587 t := i.Type 17588 z := v_1.Args[1] 17589 if !(z.Op != OpConst32 && x.Op != OpConst32) { 17590 break 17591 } 17592 v.reset(OpOr32) 17593 v.AddArg(i) 17594 v0 := b.NewValue0(v.Pos, OpOr32, t) 17595 v0.AddArg(z) 17596 v0.AddArg(x) 17597 v.AddArg(v0) 17598 return true 17599 } 17600 // match: (Or32 x (Or32 z i:(Const32 <t>))) 17601 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 17602 // result: (Or32 i (Or32 <t> z x)) 17603 for { 17604 _ = v.Args[1] 17605 x := v.Args[0] 17606 v_1 := v.Args[1] 17607 if v_1.Op != OpOr32 { 17608 break 17609 } 17610 _ = v_1.Args[1] 17611 z := v_1.Args[0] 17612 i := v_1.Args[1] 17613 if i.Op != OpConst32 { 17614 break 17615 } 17616 t := i.Type 17617 if !(z.Op != OpConst32 && x.Op != OpConst32) { 17618 break 17619 } 17620 v.reset(OpOr32) 17621 v.AddArg(i) 17622 v0 := b.NewValue0(v.Pos, OpOr32, t) 17623 v0.AddArg(z) 17624 v0.AddArg(x) 17625 v.AddArg(v0) 17626 return true 17627 } 17628 // match: (Or32 (Const32 <t> [c]) (Or32 (Const32 <t> [d]) x)) 17629 // cond: 17630 // result: (Or32 (Const32 <t> [int64(int32(c|d))]) x) 17631 for { 17632 _ = v.Args[1] 17633 v_0 := v.Args[0] 17634 if v_0.Op != OpConst32 { 17635 break 17636 } 17637 t := v_0.Type 17638 c := v_0.AuxInt 17639 v_1 := v.Args[1] 17640 if v_1.Op != OpOr32 { 17641 break 17642 } 17643 _ = v_1.Args[1] 17644 v_1_0 := v_1.Args[0] 17645 if v_1_0.Op != OpConst32 { 17646 break 17647 } 17648 if v_1_0.Type != t { 17649 break 17650 } 17651 d := v_1_0.AuxInt 17652 x := v_1.Args[1] 17653 v.reset(OpOr32) 17654 v0 := b.NewValue0(v.Pos, OpConst32, t) 17655 v0.AuxInt = int64(int32(c | d)) 17656 v.AddArg(v0) 17657 v.AddArg(x) 17658 return true 17659 } 17660 return false 17661 } 17662 func rewriteValuegeneric_OpOr32_20(v *Value) bool { 17663 b := v.Block 17664 _ = b 17665 // match: (Or32 (Const32 <t> [c]) (Or32 x (Const32 <t> [d]))) 17666 // cond: 17667 // result: (Or32 (Const32 <t> [int64(int32(c|d))]) x) 17668 for { 17669 _ = v.Args[1] 17670 v_0 := v.Args[0] 17671 if v_0.Op != OpConst32 { 17672 break 17673 } 17674 t := v_0.Type 17675 c := v_0.AuxInt 17676 v_1 := v.Args[1] 17677 if v_1.Op != OpOr32 { 17678 break 17679 } 17680 _ = v_1.Args[1] 17681 x := v_1.Args[0] 17682 v_1_1 := v_1.Args[1] 17683 if v_1_1.Op != OpConst32 { 17684 break 17685 } 17686 if v_1_1.Type != t { 17687 break 17688 } 17689 d := v_1_1.AuxInt 17690 v.reset(OpOr32) 17691 v0 := b.NewValue0(v.Pos, OpConst32, t) 17692 v0.AuxInt = int64(int32(c | d)) 17693 v.AddArg(v0) 17694 v.AddArg(x) 17695 return true 17696 } 17697 // match: (Or32 (Or32 (Const32 <t> [d]) x) (Const32 <t> [c])) 17698 // cond: 17699 // result: (Or32 (Const32 <t> [int64(int32(c|d))]) x) 17700 for { 17701 _ = v.Args[1] 17702 v_0 := v.Args[0] 17703 if v_0.Op != OpOr32 { 17704 break 17705 } 17706 _ = v_0.Args[1] 17707 v_0_0 := v_0.Args[0] 17708 if v_0_0.Op != OpConst32 { 17709 break 17710 } 17711 t := v_0_0.Type 17712 d := v_0_0.AuxInt 17713 x := v_0.Args[1] 17714 v_1 := v.Args[1] 17715 if v_1.Op != OpConst32 { 17716 break 17717 } 17718 if v_1.Type != t { 17719 break 17720 } 17721 c := v_1.AuxInt 17722 v.reset(OpOr32) 17723 v0 := b.NewValue0(v.Pos, OpConst32, t) 17724 v0.AuxInt = int64(int32(c | d)) 17725 v.AddArg(v0) 17726 v.AddArg(x) 17727 return true 17728 } 17729 // match: (Or32 (Or32 x (Const32 <t> [d])) (Const32 <t> [c])) 17730 // cond: 17731 // result: (Or32 (Const32 <t> [int64(int32(c|d))]) x) 17732 for { 17733 _ = v.Args[1] 17734 v_0 := v.Args[0] 17735 if v_0.Op != OpOr32 { 17736 break 17737 } 17738 _ = v_0.Args[1] 17739 x := v_0.Args[0] 17740 v_0_1 := v_0.Args[1] 17741 if v_0_1.Op != OpConst32 { 17742 break 17743 } 17744 t := v_0_1.Type 17745 d := v_0_1.AuxInt 17746 v_1 := v.Args[1] 17747 if v_1.Op != OpConst32 { 17748 break 17749 } 17750 if v_1.Type != t { 17751 break 17752 } 17753 c := v_1.AuxInt 17754 v.reset(OpOr32) 17755 v0 := b.NewValue0(v.Pos, OpConst32, t) 17756 v0.AuxInt = int64(int32(c | d)) 17757 v.AddArg(v0) 17758 v.AddArg(x) 17759 return true 17760 } 17761 return false 17762 } 17763 func rewriteValuegeneric_OpOr64_0(v *Value) bool { 17764 // match: (Or64 (Const64 [c]) (Const64 [d])) 17765 // cond: 17766 // result: (Const64 [c|d]) 17767 for { 17768 _ = v.Args[1] 17769 v_0 := v.Args[0] 17770 if v_0.Op != OpConst64 { 17771 break 17772 } 17773 c := v_0.AuxInt 17774 v_1 := v.Args[1] 17775 if v_1.Op != OpConst64 { 17776 break 17777 } 17778 d := v_1.AuxInt 17779 v.reset(OpConst64) 17780 v.AuxInt = c | d 17781 return true 17782 } 17783 // match: (Or64 (Const64 [d]) (Const64 [c])) 17784 // cond: 17785 // result: (Const64 [c|d]) 17786 for { 17787 _ = v.Args[1] 17788 v_0 := v.Args[0] 17789 if v_0.Op != OpConst64 { 17790 break 17791 } 17792 d := v_0.AuxInt 17793 v_1 := v.Args[1] 17794 if v_1.Op != OpConst64 { 17795 break 17796 } 17797 c := v_1.AuxInt 17798 v.reset(OpConst64) 17799 v.AuxInt = c | d 17800 return true 17801 } 17802 // match: (Or64 x x) 17803 // cond: 17804 // result: x 17805 for { 17806 _ = v.Args[1] 17807 x := v.Args[0] 17808 if x != v.Args[1] { 17809 break 17810 } 17811 v.reset(OpCopy) 17812 v.Type = x.Type 17813 v.AddArg(x) 17814 return true 17815 } 17816 // match: (Or64 (Const64 [0]) x) 17817 // cond: 17818 // result: x 17819 for { 17820 _ = v.Args[1] 17821 v_0 := v.Args[0] 17822 if v_0.Op != OpConst64 { 17823 break 17824 } 17825 if v_0.AuxInt != 0 { 17826 break 17827 } 17828 x := v.Args[1] 17829 v.reset(OpCopy) 17830 v.Type = x.Type 17831 v.AddArg(x) 17832 return true 17833 } 17834 // match: (Or64 x (Const64 [0])) 17835 // cond: 17836 // result: x 17837 for { 17838 _ = v.Args[1] 17839 x := v.Args[0] 17840 v_1 := v.Args[1] 17841 if v_1.Op != OpConst64 { 17842 break 17843 } 17844 if v_1.AuxInt != 0 { 17845 break 17846 } 17847 v.reset(OpCopy) 17848 v.Type = x.Type 17849 v.AddArg(x) 17850 return true 17851 } 17852 // match: (Or64 (Const64 [-1]) _) 17853 // cond: 17854 // result: (Const64 [-1]) 17855 for { 17856 _ = v.Args[1] 17857 v_0 := v.Args[0] 17858 if v_0.Op != OpConst64 { 17859 break 17860 } 17861 if v_0.AuxInt != -1 { 17862 break 17863 } 17864 v.reset(OpConst64) 17865 v.AuxInt = -1 17866 return true 17867 } 17868 // match: (Or64 _ (Const64 [-1])) 17869 // cond: 17870 // result: (Const64 [-1]) 17871 for { 17872 _ = v.Args[1] 17873 v_1 := v.Args[1] 17874 if v_1.Op != OpConst64 { 17875 break 17876 } 17877 if v_1.AuxInt != -1 { 17878 break 17879 } 17880 v.reset(OpConst64) 17881 v.AuxInt = -1 17882 return true 17883 } 17884 // match: (Or64 x (Or64 x y)) 17885 // cond: 17886 // result: (Or64 x y) 17887 for { 17888 _ = v.Args[1] 17889 x := v.Args[0] 17890 v_1 := v.Args[1] 17891 if v_1.Op != OpOr64 { 17892 break 17893 } 17894 _ = v_1.Args[1] 17895 if x != v_1.Args[0] { 17896 break 17897 } 17898 y := v_1.Args[1] 17899 v.reset(OpOr64) 17900 v.AddArg(x) 17901 v.AddArg(y) 17902 return true 17903 } 17904 // match: (Or64 x (Or64 y x)) 17905 // cond: 17906 // result: (Or64 x y) 17907 for { 17908 _ = v.Args[1] 17909 x := v.Args[0] 17910 v_1 := v.Args[1] 17911 if v_1.Op != OpOr64 { 17912 break 17913 } 17914 _ = v_1.Args[1] 17915 y := v_1.Args[0] 17916 if x != v_1.Args[1] { 17917 break 17918 } 17919 v.reset(OpOr64) 17920 v.AddArg(x) 17921 v.AddArg(y) 17922 return true 17923 } 17924 // match: (Or64 (Or64 x y) x) 17925 // cond: 17926 // result: (Or64 x y) 17927 for { 17928 _ = v.Args[1] 17929 v_0 := v.Args[0] 17930 if v_0.Op != OpOr64 { 17931 break 17932 } 17933 _ = v_0.Args[1] 17934 x := v_0.Args[0] 17935 y := v_0.Args[1] 17936 if x != v.Args[1] { 17937 break 17938 } 17939 v.reset(OpOr64) 17940 v.AddArg(x) 17941 v.AddArg(y) 17942 return true 17943 } 17944 return false 17945 } 17946 func rewriteValuegeneric_OpOr64_10(v *Value) bool { 17947 b := v.Block 17948 _ = b 17949 // match: (Or64 (Or64 y x) x) 17950 // cond: 17951 // result: (Or64 x y) 17952 for { 17953 _ = v.Args[1] 17954 v_0 := v.Args[0] 17955 if v_0.Op != OpOr64 { 17956 break 17957 } 17958 _ = v_0.Args[1] 17959 y := v_0.Args[0] 17960 x := v_0.Args[1] 17961 if x != v.Args[1] { 17962 break 17963 } 17964 v.reset(OpOr64) 17965 v.AddArg(x) 17966 v.AddArg(y) 17967 return true 17968 } 17969 // match: (Or64 (And64 x (Const64 [c2])) (Const64 <t> [c1])) 17970 // cond: ^(c1 | c2) == 0 17971 // result: (Or64 (Const64 <t> [c1]) x) 17972 for { 17973 _ = v.Args[1] 17974 v_0 := v.Args[0] 17975 if v_0.Op != OpAnd64 { 17976 break 17977 } 17978 _ = v_0.Args[1] 17979 x := v_0.Args[0] 17980 v_0_1 := v_0.Args[1] 17981 if v_0_1.Op != OpConst64 { 17982 break 17983 } 17984 c2 := v_0_1.AuxInt 17985 v_1 := v.Args[1] 17986 if v_1.Op != OpConst64 { 17987 break 17988 } 17989 t := v_1.Type 17990 c1 := v_1.AuxInt 17991 if !(^(c1 | c2) == 0) { 17992 break 17993 } 17994 v.reset(OpOr64) 17995 v0 := b.NewValue0(v.Pos, OpConst64, t) 17996 v0.AuxInt = c1 17997 v.AddArg(v0) 17998 v.AddArg(x) 17999 return true 18000 } 18001 // match: (Or64 (And64 (Const64 [c2]) x) (Const64 <t> [c1])) 18002 // cond: ^(c1 | c2) == 0 18003 // result: (Or64 (Const64 <t> [c1]) x) 18004 for { 18005 _ = v.Args[1] 18006 v_0 := v.Args[0] 18007 if v_0.Op != OpAnd64 { 18008 break 18009 } 18010 _ = v_0.Args[1] 18011 v_0_0 := v_0.Args[0] 18012 if v_0_0.Op != OpConst64 { 18013 break 18014 } 18015 c2 := v_0_0.AuxInt 18016 x := v_0.Args[1] 18017 v_1 := v.Args[1] 18018 if v_1.Op != OpConst64 { 18019 break 18020 } 18021 t := v_1.Type 18022 c1 := v_1.AuxInt 18023 if !(^(c1 | c2) == 0) { 18024 break 18025 } 18026 v.reset(OpOr64) 18027 v0 := b.NewValue0(v.Pos, OpConst64, t) 18028 v0.AuxInt = c1 18029 v.AddArg(v0) 18030 v.AddArg(x) 18031 return true 18032 } 18033 // match: (Or64 (Const64 <t> [c1]) (And64 x (Const64 [c2]))) 18034 // cond: ^(c1 | c2) == 0 18035 // result: (Or64 (Const64 <t> [c1]) x) 18036 for { 18037 _ = v.Args[1] 18038 v_0 := v.Args[0] 18039 if v_0.Op != OpConst64 { 18040 break 18041 } 18042 t := v_0.Type 18043 c1 := v_0.AuxInt 18044 v_1 := v.Args[1] 18045 if v_1.Op != OpAnd64 { 18046 break 18047 } 18048 _ = v_1.Args[1] 18049 x := v_1.Args[0] 18050 v_1_1 := v_1.Args[1] 18051 if v_1_1.Op != OpConst64 { 18052 break 18053 } 18054 c2 := v_1_1.AuxInt 18055 if !(^(c1 | c2) == 0) { 18056 break 18057 } 18058 v.reset(OpOr64) 18059 v0 := b.NewValue0(v.Pos, OpConst64, t) 18060 v0.AuxInt = c1 18061 v.AddArg(v0) 18062 v.AddArg(x) 18063 return true 18064 } 18065 // match: (Or64 (Const64 <t> [c1]) (And64 (Const64 [c2]) x)) 18066 // cond: ^(c1 | c2) == 0 18067 // result: (Or64 (Const64 <t> [c1]) x) 18068 for { 18069 _ = v.Args[1] 18070 v_0 := v.Args[0] 18071 if v_0.Op != OpConst64 { 18072 break 18073 } 18074 t := v_0.Type 18075 c1 := v_0.AuxInt 18076 v_1 := v.Args[1] 18077 if v_1.Op != OpAnd64 { 18078 break 18079 } 18080 _ = v_1.Args[1] 18081 v_1_0 := v_1.Args[0] 18082 if v_1_0.Op != OpConst64 { 18083 break 18084 } 18085 c2 := v_1_0.AuxInt 18086 x := v_1.Args[1] 18087 if !(^(c1 | c2) == 0) { 18088 break 18089 } 18090 v.reset(OpOr64) 18091 v0 := b.NewValue0(v.Pos, OpConst64, t) 18092 v0.AuxInt = c1 18093 v.AddArg(v0) 18094 v.AddArg(x) 18095 return true 18096 } 18097 // match: (Or64 (Or64 i:(Const64 <t>) z) x) 18098 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 18099 // result: (Or64 i (Or64 <t> z x)) 18100 for { 18101 _ = v.Args[1] 18102 v_0 := v.Args[0] 18103 if v_0.Op != OpOr64 { 18104 break 18105 } 18106 _ = v_0.Args[1] 18107 i := v_0.Args[0] 18108 if i.Op != OpConst64 { 18109 break 18110 } 18111 t := i.Type 18112 z := v_0.Args[1] 18113 x := v.Args[1] 18114 if !(z.Op != OpConst64 && x.Op != OpConst64) { 18115 break 18116 } 18117 v.reset(OpOr64) 18118 v.AddArg(i) 18119 v0 := b.NewValue0(v.Pos, OpOr64, t) 18120 v0.AddArg(z) 18121 v0.AddArg(x) 18122 v.AddArg(v0) 18123 return true 18124 } 18125 // match: (Or64 (Or64 z i:(Const64 <t>)) x) 18126 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 18127 // result: (Or64 i (Or64 <t> z x)) 18128 for { 18129 _ = v.Args[1] 18130 v_0 := v.Args[0] 18131 if v_0.Op != OpOr64 { 18132 break 18133 } 18134 _ = v_0.Args[1] 18135 z := v_0.Args[0] 18136 i := v_0.Args[1] 18137 if i.Op != OpConst64 { 18138 break 18139 } 18140 t := i.Type 18141 x := v.Args[1] 18142 if !(z.Op != OpConst64 && x.Op != OpConst64) { 18143 break 18144 } 18145 v.reset(OpOr64) 18146 v.AddArg(i) 18147 v0 := b.NewValue0(v.Pos, OpOr64, t) 18148 v0.AddArg(z) 18149 v0.AddArg(x) 18150 v.AddArg(v0) 18151 return true 18152 } 18153 // match: (Or64 x (Or64 i:(Const64 <t>) z)) 18154 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 18155 // result: (Or64 i (Or64 <t> z x)) 18156 for { 18157 _ = v.Args[1] 18158 x := v.Args[0] 18159 v_1 := v.Args[1] 18160 if v_1.Op != OpOr64 { 18161 break 18162 } 18163 _ = v_1.Args[1] 18164 i := v_1.Args[0] 18165 if i.Op != OpConst64 { 18166 break 18167 } 18168 t := i.Type 18169 z := v_1.Args[1] 18170 if !(z.Op != OpConst64 && x.Op != OpConst64) { 18171 break 18172 } 18173 v.reset(OpOr64) 18174 v.AddArg(i) 18175 v0 := b.NewValue0(v.Pos, OpOr64, t) 18176 v0.AddArg(z) 18177 v0.AddArg(x) 18178 v.AddArg(v0) 18179 return true 18180 } 18181 // match: (Or64 x (Or64 z i:(Const64 <t>))) 18182 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 18183 // result: (Or64 i (Or64 <t> z x)) 18184 for { 18185 _ = v.Args[1] 18186 x := v.Args[0] 18187 v_1 := v.Args[1] 18188 if v_1.Op != OpOr64 { 18189 break 18190 } 18191 _ = v_1.Args[1] 18192 z := v_1.Args[0] 18193 i := v_1.Args[1] 18194 if i.Op != OpConst64 { 18195 break 18196 } 18197 t := i.Type 18198 if !(z.Op != OpConst64 && x.Op != OpConst64) { 18199 break 18200 } 18201 v.reset(OpOr64) 18202 v.AddArg(i) 18203 v0 := b.NewValue0(v.Pos, OpOr64, t) 18204 v0.AddArg(z) 18205 v0.AddArg(x) 18206 v.AddArg(v0) 18207 return true 18208 } 18209 // match: (Or64 (Const64 <t> [c]) (Or64 (Const64 <t> [d]) x)) 18210 // cond: 18211 // result: (Or64 (Const64 <t> [c|d]) x) 18212 for { 18213 _ = v.Args[1] 18214 v_0 := v.Args[0] 18215 if v_0.Op != OpConst64 { 18216 break 18217 } 18218 t := v_0.Type 18219 c := v_0.AuxInt 18220 v_1 := v.Args[1] 18221 if v_1.Op != OpOr64 { 18222 break 18223 } 18224 _ = v_1.Args[1] 18225 v_1_0 := v_1.Args[0] 18226 if v_1_0.Op != OpConst64 { 18227 break 18228 } 18229 if v_1_0.Type != t { 18230 break 18231 } 18232 d := v_1_0.AuxInt 18233 x := v_1.Args[1] 18234 v.reset(OpOr64) 18235 v0 := b.NewValue0(v.Pos, OpConst64, t) 18236 v0.AuxInt = c | d 18237 v.AddArg(v0) 18238 v.AddArg(x) 18239 return true 18240 } 18241 return false 18242 } 18243 func rewriteValuegeneric_OpOr64_20(v *Value) bool { 18244 b := v.Block 18245 _ = b 18246 // match: (Or64 (Const64 <t> [c]) (Or64 x (Const64 <t> [d]))) 18247 // cond: 18248 // result: (Or64 (Const64 <t> [c|d]) x) 18249 for { 18250 _ = v.Args[1] 18251 v_0 := v.Args[0] 18252 if v_0.Op != OpConst64 { 18253 break 18254 } 18255 t := v_0.Type 18256 c := v_0.AuxInt 18257 v_1 := v.Args[1] 18258 if v_1.Op != OpOr64 { 18259 break 18260 } 18261 _ = v_1.Args[1] 18262 x := v_1.Args[0] 18263 v_1_1 := v_1.Args[1] 18264 if v_1_1.Op != OpConst64 { 18265 break 18266 } 18267 if v_1_1.Type != t { 18268 break 18269 } 18270 d := v_1_1.AuxInt 18271 v.reset(OpOr64) 18272 v0 := b.NewValue0(v.Pos, OpConst64, t) 18273 v0.AuxInt = c | d 18274 v.AddArg(v0) 18275 v.AddArg(x) 18276 return true 18277 } 18278 // match: (Or64 (Or64 (Const64 <t> [d]) x) (Const64 <t> [c])) 18279 // cond: 18280 // result: (Or64 (Const64 <t> [c|d]) x) 18281 for { 18282 _ = v.Args[1] 18283 v_0 := v.Args[0] 18284 if v_0.Op != OpOr64 { 18285 break 18286 } 18287 _ = v_0.Args[1] 18288 v_0_0 := v_0.Args[0] 18289 if v_0_0.Op != OpConst64 { 18290 break 18291 } 18292 t := v_0_0.Type 18293 d := v_0_0.AuxInt 18294 x := v_0.Args[1] 18295 v_1 := v.Args[1] 18296 if v_1.Op != OpConst64 { 18297 break 18298 } 18299 if v_1.Type != t { 18300 break 18301 } 18302 c := v_1.AuxInt 18303 v.reset(OpOr64) 18304 v0 := b.NewValue0(v.Pos, OpConst64, t) 18305 v0.AuxInt = c | d 18306 v.AddArg(v0) 18307 v.AddArg(x) 18308 return true 18309 } 18310 // match: (Or64 (Or64 x (Const64 <t> [d])) (Const64 <t> [c])) 18311 // cond: 18312 // result: (Or64 (Const64 <t> [c|d]) x) 18313 for { 18314 _ = v.Args[1] 18315 v_0 := v.Args[0] 18316 if v_0.Op != OpOr64 { 18317 break 18318 } 18319 _ = v_0.Args[1] 18320 x := v_0.Args[0] 18321 v_0_1 := v_0.Args[1] 18322 if v_0_1.Op != OpConst64 { 18323 break 18324 } 18325 t := v_0_1.Type 18326 d := v_0_1.AuxInt 18327 v_1 := v.Args[1] 18328 if v_1.Op != OpConst64 { 18329 break 18330 } 18331 if v_1.Type != t { 18332 break 18333 } 18334 c := v_1.AuxInt 18335 v.reset(OpOr64) 18336 v0 := b.NewValue0(v.Pos, OpConst64, t) 18337 v0.AuxInt = c | d 18338 v.AddArg(v0) 18339 v.AddArg(x) 18340 return true 18341 } 18342 return false 18343 } 18344 func rewriteValuegeneric_OpOr8_0(v *Value) bool { 18345 // match: (Or8 (Const8 [c]) (Const8 [d])) 18346 // cond: 18347 // result: (Const8 [int64(int8(c|d))]) 18348 for { 18349 _ = v.Args[1] 18350 v_0 := v.Args[0] 18351 if v_0.Op != OpConst8 { 18352 break 18353 } 18354 c := v_0.AuxInt 18355 v_1 := v.Args[1] 18356 if v_1.Op != OpConst8 { 18357 break 18358 } 18359 d := v_1.AuxInt 18360 v.reset(OpConst8) 18361 v.AuxInt = int64(int8(c | d)) 18362 return true 18363 } 18364 // match: (Or8 (Const8 [d]) (Const8 [c])) 18365 // cond: 18366 // result: (Const8 [int64(int8(c|d))]) 18367 for { 18368 _ = v.Args[1] 18369 v_0 := v.Args[0] 18370 if v_0.Op != OpConst8 { 18371 break 18372 } 18373 d := v_0.AuxInt 18374 v_1 := v.Args[1] 18375 if v_1.Op != OpConst8 { 18376 break 18377 } 18378 c := v_1.AuxInt 18379 v.reset(OpConst8) 18380 v.AuxInt = int64(int8(c | d)) 18381 return true 18382 } 18383 // match: (Or8 x x) 18384 // cond: 18385 // result: x 18386 for { 18387 _ = v.Args[1] 18388 x := v.Args[0] 18389 if x != v.Args[1] { 18390 break 18391 } 18392 v.reset(OpCopy) 18393 v.Type = x.Type 18394 v.AddArg(x) 18395 return true 18396 } 18397 // match: (Or8 (Const8 [0]) x) 18398 // cond: 18399 // result: x 18400 for { 18401 _ = v.Args[1] 18402 v_0 := v.Args[0] 18403 if v_0.Op != OpConst8 { 18404 break 18405 } 18406 if v_0.AuxInt != 0 { 18407 break 18408 } 18409 x := v.Args[1] 18410 v.reset(OpCopy) 18411 v.Type = x.Type 18412 v.AddArg(x) 18413 return true 18414 } 18415 // match: (Or8 x (Const8 [0])) 18416 // cond: 18417 // result: x 18418 for { 18419 _ = v.Args[1] 18420 x := v.Args[0] 18421 v_1 := v.Args[1] 18422 if v_1.Op != OpConst8 { 18423 break 18424 } 18425 if v_1.AuxInt != 0 { 18426 break 18427 } 18428 v.reset(OpCopy) 18429 v.Type = x.Type 18430 v.AddArg(x) 18431 return true 18432 } 18433 // match: (Or8 (Const8 [-1]) _) 18434 // cond: 18435 // result: (Const8 [-1]) 18436 for { 18437 _ = v.Args[1] 18438 v_0 := v.Args[0] 18439 if v_0.Op != OpConst8 { 18440 break 18441 } 18442 if v_0.AuxInt != -1 { 18443 break 18444 } 18445 v.reset(OpConst8) 18446 v.AuxInt = -1 18447 return true 18448 } 18449 // match: (Or8 _ (Const8 [-1])) 18450 // cond: 18451 // result: (Const8 [-1]) 18452 for { 18453 _ = v.Args[1] 18454 v_1 := v.Args[1] 18455 if v_1.Op != OpConst8 { 18456 break 18457 } 18458 if v_1.AuxInt != -1 { 18459 break 18460 } 18461 v.reset(OpConst8) 18462 v.AuxInt = -1 18463 return true 18464 } 18465 // match: (Or8 x (Or8 x y)) 18466 // cond: 18467 // result: (Or8 x y) 18468 for { 18469 _ = v.Args[1] 18470 x := v.Args[0] 18471 v_1 := v.Args[1] 18472 if v_1.Op != OpOr8 { 18473 break 18474 } 18475 _ = v_1.Args[1] 18476 if x != v_1.Args[0] { 18477 break 18478 } 18479 y := v_1.Args[1] 18480 v.reset(OpOr8) 18481 v.AddArg(x) 18482 v.AddArg(y) 18483 return true 18484 } 18485 // match: (Or8 x (Or8 y x)) 18486 // cond: 18487 // result: (Or8 x y) 18488 for { 18489 _ = v.Args[1] 18490 x := v.Args[0] 18491 v_1 := v.Args[1] 18492 if v_1.Op != OpOr8 { 18493 break 18494 } 18495 _ = v_1.Args[1] 18496 y := v_1.Args[0] 18497 if x != v_1.Args[1] { 18498 break 18499 } 18500 v.reset(OpOr8) 18501 v.AddArg(x) 18502 v.AddArg(y) 18503 return true 18504 } 18505 // match: (Or8 (Or8 x y) x) 18506 // cond: 18507 // result: (Or8 x y) 18508 for { 18509 _ = v.Args[1] 18510 v_0 := v.Args[0] 18511 if v_0.Op != OpOr8 { 18512 break 18513 } 18514 _ = v_0.Args[1] 18515 x := v_0.Args[0] 18516 y := v_0.Args[1] 18517 if x != v.Args[1] { 18518 break 18519 } 18520 v.reset(OpOr8) 18521 v.AddArg(x) 18522 v.AddArg(y) 18523 return true 18524 } 18525 return false 18526 } 18527 func rewriteValuegeneric_OpOr8_10(v *Value) bool { 18528 b := v.Block 18529 _ = b 18530 // match: (Or8 (Or8 y x) x) 18531 // cond: 18532 // result: (Or8 x y) 18533 for { 18534 _ = v.Args[1] 18535 v_0 := v.Args[0] 18536 if v_0.Op != OpOr8 { 18537 break 18538 } 18539 _ = v_0.Args[1] 18540 y := v_0.Args[0] 18541 x := v_0.Args[1] 18542 if x != v.Args[1] { 18543 break 18544 } 18545 v.reset(OpOr8) 18546 v.AddArg(x) 18547 v.AddArg(y) 18548 return true 18549 } 18550 // match: (Or8 (And8 x (Const8 [c2])) (Const8 <t> [c1])) 18551 // cond: ^(c1 | c2) == 0 18552 // result: (Or8 (Const8 <t> [c1]) x) 18553 for { 18554 _ = v.Args[1] 18555 v_0 := v.Args[0] 18556 if v_0.Op != OpAnd8 { 18557 break 18558 } 18559 _ = v_0.Args[1] 18560 x := v_0.Args[0] 18561 v_0_1 := v_0.Args[1] 18562 if v_0_1.Op != OpConst8 { 18563 break 18564 } 18565 c2 := v_0_1.AuxInt 18566 v_1 := v.Args[1] 18567 if v_1.Op != OpConst8 { 18568 break 18569 } 18570 t := v_1.Type 18571 c1 := v_1.AuxInt 18572 if !(^(c1 | c2) == 0) { 18573 break 18574 } 18575 v.reset(OpOr8) 18576 v0 := b.NewValue0(v.Pos, OpConst8, t) 18577 v0.AuxInt = c1 18578 v.AddArg(v0) 18579 v.AddArg(x) 18580 return true 18581 } 18582 // match: (Or8 (And8 (Const8 [c2]) x) (Const8 <t> [c1])) 18583 // cond: ^(c1 | c2) == 0 18584 // result: (Or8 (Const8 <t> [c1]) x) 18585 for { 18586 _ = v.Args[1] 18587 v_0 := v.Args[0] 18588 if v_0.Op != OpAnd8 { 18589 break 18590 } 18591 _ = v_0.Args[1] 18592 v_0_0 := v_0.Args[0] 18593 if v_0_0.Op != OpConst8 { 18594 break 18595 } 18596 c2 := v_0_0.AuxInt 18597 x := v_0.Args[1] 18598 v_1 := v.Args[1] 18599 if v_1.Op != OpConst8 { 18600 break 18601 } 18602 t := v_1.Type 18603 c1 := v_1.AuxInt 18604 if !(^(c1 | c2) == 0) { 18605 break 18606 } 18607 v.reset(OpOr8) 18608 v0 := b.NewValue0(v.Pos, OpConst8, t) 18609 v0.AuxInt = c1 18610 v.AddArg(v0) 18611 v.AddArg(x) 18612 return true 18613 } 18614 // match: (Or8 (Const8 <t> [c1]) (And8 x (Const8 [c2]))) 18615 // cond: ^(c1 | c2) == 0 18616 // result: (Or8 (Const8 <t> [c1]) x) 18617 for { 18618 _ = v.Args[1] 18619 v_0 := v.Args[0] 18620 if v_0.Op != OpConst8 { 18621 break 18622 } 18623 t := v_0.Type 18624 c1 := v_0.AuxInt 18625 v_1 := v.Args[1] 18626 if v_1.Op != OpAnd8 { 18627 break 18628 } 18629 _ = v_1.Args[1] 18630 x := v_1.Args[0] 18631 v_1_1 := v_1.Args[1] 18632 if v_1_1.Op != OpConst8 { 18633 break 18634 } 18635 c2 := v_1_1.AuxInt 18636 if !(^(c1 | c2) == 0) { 18637 break 18638 } 18639 v.reset(OpOr8) 18640 v0 := b.NewValue0(v.Pos, OpConst8, t) 18641 v0.AuxInt = c1 18642 v.AddArg(v0) 18643 v.AddArg(x) 18644 return true 18645 } 18646 // match: (Or8 (Const8 <t> [c1]) (And8 (Const8 [c2]) x)) 18647 // cond: ^(c1 | c2) == 0 18648 // result: (Or8 (Const8 <t> [c1]) x) 18649 for { 18650 _ = v.Args[1] 18651 v_0 := v.Args[0] 18652 if v_0.Op != OpConst8 { 18653 break 18654 } 18655 t := v_0.Type 18656 c1 := v_0.AuxInt 18657 v_1 := v.Args[1] 18658 if v_1.Op != OpAnd8 { 18659 break 18660 } 18661 _ = v_1.Args[1] 18662 v_1_0 := v_1.Args[0] 18663 if v_1_0.Op != OpConst8 { 18664 break 18665 } 18666 c2 := v_1_0.AuxInt 18667 x := v_1.Args[1] 18668 if !(^(c1 | c2) == 0) { 18669 break 18670 } 18671 v.reset(OpOr8) 18672 v0 := b.NewValue0(v.Pos, OpConst8, t) 18673 v0.AuxInt = c1 18674 v.AddArg(v0) 18675 v.AddArg(x) 18676 return true 18677 } 18678 // match: (Or8 (Or8 i:(Const8 <t>) z) x) 18679 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 18680 // result: (Or8 i (Or8 <t> z x)) 18681 for { 18682 _ = v.Args[1] 18683 v_0 := v.Args[0] 18684 if v_0.Op != OpOr8 { 18685 break 18686 } 18687 _ = v_0.Args[1] 18688 i := v_0.Args[0] 18689 if i.Op != OpConst8 { 18690 break 18691 } 18692 t := i.Type 18693 z := v_0.Args[1] 18694 x := v.Args[1] 18695 if !(z.Op != OpConst8 && x.Op != OpConst8) { 18696 break 18697 } 18698 v.reset(OpOr8) 18699 v.AddArg(i) 18700 v0 := b.NewValue0(v.Pos, OpOr8, t) 18701 v0.AddArg(z) 18702 v0.AddArg(x) 18703 v.AddArg(v0) 18704 return true 18705 } 18706 // match: (Or8 (Or8 z i:(Const8 <t>)) x) 18707 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 18708 // result: (Or8 i (Or8 <t> z x)) 18709 for { 18710 _ = v.Args[1] 18711 v_0 := v.Args[0] 18712 if v_0.Op != OpOr8 { 18713 break 18714 } 18715 _ = v_0.Args[1] 18716 z := v_0.Args[0] 18717 i := v_0.Args[1] 18718 if i.Op != OpConst8 { 18719 break 18720 } 18721 t := i.Type 18722 x := v.Args[1] 18723 if !(z.Op != OpConst8 && x.Op != OpConst8) { 18724 break 18725 } 18726 v.reset(OpOr8) 18727 v.AddArg(i) 18728 v0 := b.NewValue0(v.Pos, OpOr8, t) 18729 v0.AddArg(z) 18730 v0.AddArg(x) 18731 v.AddArg(v0) 18732 return true 18733 } 18734 // match: (Or8 x (Or8 i:(Const8 <t>) z)) 18735 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 18736 // result: (Or8 i (Or8 <t> z x)) 18737 for { 18738 _ = v.Args[1] 18739 x := v.Args[0] 18740 v_1 := v.Args[1] 18741 if v_1.Op != OpOr8 { 18742 break 18743 } 18744 _ = v_1.Args[1] 18745 i := v_1.Args[0] 18746 if i.Op != OpConst8 { 18747 break 18748 } 18749 t := i.Type 18750 z := v_1.Args[1] 18751 if !(z.Op != OpConst8 && x.Op != OpConst8) { 18752 break 18753 } 18754 v.reset(OpOr8) 18755 v.AddArg(i) 18756 v0 := b.NewValue0(v.Pos, OpOr8, t) 18757 v0.AddArg(z) 18758 v0.AddArg(x) 18759 v.AddArg(v0) 18760 return true 18761 } 18762 // match: (Or8 x (Or8 z i:(Const8 <t>))) 18763 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 18764 // result: (Or8 i (Or8 <t> z x)) 18765 for { 18766 _ = v.Args[1] 18767 x := v.Args[0] 18768 v_1 := v.Args[1] 18769 if v_1.Op != OpOr8 { 18770 break 18771 } 18772 _ = v_1.Args[1] 18773 z := v_1.Args[0] 18774 i := v_1.Args[1] 18775 if i.Op != OpConst8 { 18776 break 18777 } 18778 t := i.Type 18779 if !(z.Op != OpConst8 && x.Op != OpConst8) { 18780 break 18781 } 18782 v.reset(OpOr8) 18783 v.AddArg(i) 18784 v0 := b.NewValue0(v.Pos, OpOr8, t) 18785 v0.AddArg(z) 18786 v0.AddArg(x) 18787 v.AddArg(v0) 18788 return true 18789 } 18790 // match: (Or8 (Const8 <t> [c]) (Or8 (Const8 <t> [d]) x)) 18791 // cond: 18792 // result: (Or8 (Const8 <t> [int64(int8(c|d))]) x) 18793 for { 18794 _ = v.Args[1] 18795 v_0 := v.Args[0] 18796 if v_0.Op != OpConst8 { 18797 break 18798 } 18799 t := v_0.Type 18800 c := v_0.AuxInt 18801 v_1 := v.Args[1] 18802 if v_1.Op != OpOr8 { 18803 break 18804 } 18805 _ = v_1.Args[1] 18806 v_1_0 := v_1.Args[0] 18807 if v_1_0.Op != OpConst8 { 18808 break 18809 } 18810 if v_1_0.Type != t { 18811 break 18812 } 18813 d := v_1_0.AuxInt 18814 x := v_1.Args[1] 18815 v.reset(OpOr8) 18816 v0 := b.NewValue0(v.Pos, OpConst8, t) 18817 v0.AuxInt = int64(int8(c | d)) 18818 v.AddArg(v0) 18819 v.AddArg(x) 18820 return true 18821 } 18822 return false 18823 } 18824 func rewriteValuegeneric_OpOr8_20(v *Value) bool { 18825 b := v.Block 18826 _ = b 18827 // match: (Or8 (Const8 <t> [c]) (Or8 x (Const8 <t> [d]))) 18828 // cond: 18829 // result: (Or8 (Const8 <t> [int64(int8(c|d))]) x) 18830 for { 18831 _ = v.Args[1] 18832 v_0 := v.Args[0] 18833 if v_0.Op != OpConst8 { 18834 break 18835 } 18836 t := v_0.Type 18837 c := v_0.AuxInt 18838 v_1 := v.Args[1] 18839 if v_1.Op != OpOr8 { 18840 break 18841 } 18842 _ = v_1.Args[1] 18843 x := v_1.Args[0] 18844 v_1_1 := v_1.Args[1] 18845 if v_1_1.Op != OpConst8 { 18846 break 18847 } 18848 if v_1_1.Type != t { 18849 break 18850 } 18851 d := v_1_1.AuxInt 18852 v.reset(OpOr8) 18853 v0 := b.NewValue0(v.Pos, OpConst8, t) 18854 v0.AuxInt = int64(int8(c | d)) 18855 v.AddArg(v0) 18856 v.AddArg(x) 18857 return true 18858 } 18859 // match: (Or8 (Or8 (Const8 <t> [d]) x) (Const8 <t> [c])) 18860 // cond: 18861 // result: (Or8 (Const8 <t> [int64(int8(c|d))]) x) 18862 for { 18863 _ = v.Args[1] 18864 v_0 := v.Args[0] 18865 if v_0.Op != OpOr8 { 18866 break 18867 } 18868 _ = v_0.Args[1] 18869 v_0_0 := v_0.Args[0] 18870 if v_0_0.Op != OpConst8 { 18871 break 18872 } 18873 t := v_0_0.Type 18874 d := v_0_0.AuxInt 18875 x := v_0.Args[1] 18876 v_1 := v.Args[1] 18877 if v_1.Op != OpConst8 { 18878 break 18879 } 18880 if v_1.Type != t { 18881 break 18882 } 18883 c := v_1.AuxInt 18884 v.reset(OpOr8) 18885 v0 := b.NewValue0(v.Pos, OpConst8, t) 18886 v0.AuxInt = int64(int8(c | d)) 18887 v.AddArg(v0) 18888 v.AddArg(x) 18889 return true 18890 } 18891 // match: (Or8 (Or8 x (Const8 <t> [d])) (Const8 <t> [c])) 18892 // cond: 18893 // result: (Or8 (Const8 <t> [int64(int8(c|d))]) x) 18894 for { 18895 _ = v.Args[1] 18896 v_0 := v.Args[0] 18897 if v_0.Op != OpOr8 { 18898 break 18899 } 18900 _ = v_0.Args[1] 18901 x := v_0.Args[0] 18902 v_0_1 := v_0.Args[1] 18903 if v_0_1.Op != OpConst8 { 18904 break 18905 } 18906 t := v_0_1.Type 18907 d := v_0_1.AuxInt 18908 v_1 := v.Args[1] 18909 if v_1.Op != OpConst8 { 18910 break 18911 } 18912 if v_1.Type != t { 18913 break 18914 } 18915 c := v_1.AuxInt 18916 v.reset(OpOr8) 18917 v0 := b.NewValue0(v.Pos, OpConst8, t) 18918 v0.AuxInt = int64(int8(c | d)) 18919 v.AddArg(v0) 18920 v.AddArg(x) 18921 return true 18922 } 18923 return false 18924 } 18925 func rewriteValuegeneric_OpPhi_0(v *Value) bool { 18926 // match: (Phi (Const8 [c]) (Const8 [c])) 18927 // cond: 18928 // result: (Const8 [c]) 18929 for { 18930 _ = v.Args[1] 18931 v_0 := v.Args[0] 18932 if v_0.Op != OpConst8 { 18933 break 18934 } 18935 c := v_0.AuxInt 18936 v_1 := v.Args[1] 18937 if v_1.Op != OpConst8 { 18938 break 18939 } 18940 if v_1.AuxInt != c { 18941 break 18942 } 18943 if len(v.Args) != 2 { 18944 break 18945 } 18946 v.reset(OpConst8) 18947 v.AuxInt = c 18948 return true 18949 } 18950 // match: (Phi (Const16 [c]) (Const16 [c])) 18951 // cond: 18952 // result: (Const16 [c]) 18953 for { 18954 _ = v.Args[1] 18955 v_0 := v.Args[0] 18956 if v_0.Op != OpConst16 { 18957 break 18958 } 18959 c := v_0.AuxInt 18960 v_1 := v.Args[1] 18961 if v_1.Op != OpConst16 { 18962 break 18963 } 18964 if v_1.AuxInt != c { 18965 break 18966 } 18967 if len(v.Args) != 2 { 18968 break 18969 } 18970 v.reset(OpConst16) 18971 v.AuxInt = c 18972 return true 18973 } 18974 // match: (Phi (Const32 [c]) (Const32 [c])) 18975 // cond: 18976 // result: (Const32 [c]) 18977 for { 18978 _ = v.Args[1] 18979 v_0 := v.Args[0] 18980 if v_0.Op != OpConst32 { 18981 break 18982 } 18983 c := v_0.AuxInt 18984 v_1 := v.Args[1] 18985 if v_1.Op != OpConst32 { 18986 break 18987 } 18988 if v_1.AuxInt != c { 18989 break 18990 } 18991 if len(v.Args) != 2 { 18992 break 18993 } 18994 v.reset(OpConst32) 18995 v.AuxInt = c 18996 return true 18997 } 18998 // match: (Phi (Const64 [c]) (Const64 [c])) 18999 // cond: 19000 // result: (Const64 [c]) 19001 for { 19002 _ = v.Args[1] 19003 v_0 := v.Args[0] 19004 if v_0.Op != OpConst64 { 19005 break 19006 } 19007 c := v_0.AuxInt 19008 v_1 := v.Args[1] 19009 if v_1.Op != OpConst64 { 19010 break 19011 } 19012 if v_1.AuxInt != c { 19013 break 19014 } 19015 if len(v.Args) != 2 { 19016 break 19017 } 19018 v.reset(OpConst64) 19019 v.AuxInt = c 19020 return true 19021 } 19022 return false 19023 } 19024 func rewriteValuegeneric_OpPtrIndex_0(v *Value) bool { 19025 b := v.Block 19026 _ = b 19027 config := b.Func.Config 19028 _ = config 19029 typ := &b.Func.Config.Types 19030 _ = typ 19031 // match: (PtrIndex <t> ptr idx) 19032 // cond: config.PtrSize == 4 19033 // result: (AddPtr ptr (Mul32 <typ.Int> idx (Const32 <typ.Int> [t.ElemType().Size()]))) 19034 for { 19035 t := v.Type 19036 _ = v.Args[1] 19037 ptr := v.Args[0] 19038 idx := v.Args[1] 19039 if !(config.PtrSize == 4) { 19040 break 19041 } 19042 v.reset(OpAddPtr) 19043 v.AddArg(ptr) 19044 v0 := b.NewValue0(v.Pos, OpMul32, typ.Int) 19045 v0.AddArg(idx) 19046 v1 := b.NewValue0(v.Pos, OpConst32, typ.Int) 19047 v1.AuxInt = t.ElemType().Size() 19048 v0.AddArg(v1) 19049 v.AddArg(v0) 19050 return true 19051 } 19052 // match: (PtrIndex <t> ptr idx) 19053 // cond: config.PtrSize == 8 19054 // result: (AddPtr ptr (Mul64 <typ.Int> idx (Const64 <typ.Int> [t.ElemType().Size()]))) 19055 for { 19056 t := v.Type 19057 _ = v.Args[1] 19058 ptr := v.Args[0] 19059 idx := v.Args[1] 19060 if !(config.PtrSize == 8) { 19061 break 19062 } 19063 v.reset(OpAddPtr) 19064 v.AddArg(ptr) 19065 v0 := b.NewValue0(v.Pos, OpMul64, typ.Int) 19066 v0.AddArg(idx) 19067 v1 := b.NewValue0(v.Pos, OpConst64, typ.Int) 19068 v1.AuxInt = t.ElemType().Size() 19069 v0.AddArg(v1) 19070 v.AddArg(v0) 19071 return true 19072 } 19073 return false 19074 } 19075 func rewriteValuegeneric_OpRound32F_0(v *Value) bool { 19076 // match: (Round32F x:(Const32F)) 19077 // cond: 19078 // result: x 19079 for { 19080 x := v.Args[0] 19081 if x.Op != OpConst32F { 19082 break 19083 } 19084 v.reset(OpCopy) 19085 v.Type = x.Type 19086 v.AddArg(x) 19087 return true 19088 } 19089 return false 19090 } 19091 func rewriteValuegeneric_OpRound64F_0(v *Value) bool { 19092 // match: (Round64F x:(Const64F)) 19093 // cond: 19094 // result: x 19095 for { 19096 x := v.Args[0] 19097 if x.Op != OpConst64F { 19098 break 19099 } 19100 v.reset(OpCopy) 19101 v.Type = x.Type 19102 v.AddArg(x) 19103 return true 19104 } 19105 return false 19106 } 19107 func rewriteValuegeneric_OpRsh16Ux16_0(v *Value) bool { 19108 b := v.Block 19109 _ = b 19110 // match: (Rsh16Ux16 <t> x (Const16 [c])) 19111 // cond: 19112 // result: (Rsh16Ux64 x (Const64 <t> [int64(uint16(c))])) 19113 for { 19114 t := v.Type 19115 _ = v.Args[1] 19116 x := v.Args[0] 19117 v_1 := v.Args[1] 19118 if v_1.Op != OpConst16 { 19119 break 19120 } 19121 c := v_1.AuxInt 19122 v.reset(OpRsh16Ux64) 19123 v.AddArg(x) 19124 v0 := b.NewValue0(v.Pos, OpConst64, t) 19125 v0.AuxInt = int64(uint16(c)) 19126 v.AddArg(v0) 19127 return true 19128 } 19129 // match: (Rsh16Ux16 (Const16 [0]) _) 19130 // cond: 19131 // result: (Const16 [0]) 19132 for { 19133 _ = v.Args[1] 19134 v_0 := v.Args[0] 19135 if v_0.Op != OpConst16 { 19136 break 19137 } 19138 if v_0.AuxInt != 0 { 19139 break 19140 } 19141 v.reset(OpConst16) 19142 v.AuxInt = 0 19143 return true 19144 } 19145 return false 19146 } 19147 func rewriteValuegeneric_OpRsh16Ux32_0(v *Value) bool { 19148 b := v.Block 19149 _ = b 19150 // match: (Rsh16Ux32 <t> x (Const32 [c])) 19151 // cond: 19152 // result: (Rsh16Ux64 x (Const64 <t> [int64(uint32(c))])) 19153 for { 19154 t := v.Type 19155 _ = v.Args[1] 19156 x := v.Args[0] 19157 v_1 := v.Args[1] 19158 if v_1.Op != OpConst32 { 19159 break 19160 } 19161 c := v_1.AuxInt 19162 v.reset(OpRsh16Ux64) 19163 v.AddArg(x) 19164 v0 := b.NewValue0(v.Pos, OpConst64, t) 19165 v0.AuxInt = int64(uint32(c)) 19166 v.AddArg(v0) 19167 return true 19168 } 19169 // match: (Rsh16Ux32 (Const16 [0]) _) 19170 // cond: 19171 // result: (Const16 [0]) 19172 for { 19173 _ = v.Args[1] 19174 v_0 := v.Args[0] 19175 if v_0.Op != OpConst16 { 19176 break 19177 } 19178 if v_0.AuxInt != 0 { 19179 break 19180 } 19181 v.reset(OpConst16) 19182 v.AuxInt = 0 19183 return true 19184 } 19185 return false 19186 } 19187 func rewriteValuegeneric_OpRsh16Ux64_0(v *Value) bool { 19188 b := v.Block 19189 _ = b 19190 typ := &b.Func.Config.Types 19191 _ = typ 19192 // match: (Rsh16Ux64 (Const16 [c]) (Const64 [d])) 19193 // cond: 19194 // result: (Const16 [int64(int16(uint16(c) >> uint64(d)))]) 19195 for { 19196 _ = v.Args[1] 19197 v_0 := v.Args[0] 19198 if v_0.Op != OpConst16 { 19199 break 19200 } 19201 c := v_0.AuxInt 19202 v_1 := v.Args[1] 19203 if v_1.Op != OpConst64 { 19204 break 19205 } 19206 d := v_1.AuxInt 19207 v.reset(OpConst16) 19208 v.AuxInt = int64(int16(uint16(c) >> uint64(d))) 19209 return true 19210 } 19211 // match: (Rsh16Ux64 x (Const64 [0])) 19212 // cond: 19213 // result: x 19214 for { 19215 _ = v.Args[1] 19216 x := v.Args[0] 19217 v_1 := v.Args[1] 19218 if v_1.Op != OpConst64 { 19219 break 19220 } 19221 if v_1.AuxInt != 0 { 19222 break 19223 } 19224 v.reset(OpCopy) 19225 v.Type = x.Type 19226 v.AddArg(x) 19227 return true 19228 } 19229 // match: (Rsh16Ux64 (Const16 [0]) _) 19230 // cond: 19231 // result: (Const16 [0]) 19232 for { 19233 _ = v.Args[1] 19234 v_0 := v.Args[0] 19235 if v_0.Op != OpConst16 { 19236 break 19237 } 19238 if v_0.AuxInt != 0 { 19239 break 19240 } 19241 v.reset(OpConst16) 19242 v.AuxInt = 0 19243 return true 19244 } 19245 // match: (Rsh16Ux64 _ (Const64 [c])) 19246 // cond: uint64(c) >= 16 19247 // result: (Const16 [0]) 19248 for { 19249 _ = v.Args[1] 19250 v_1 := v.Args[1] 19251 if v_1.Op != OpConst64 { 19252 break 19253 } 19254 c := v_1.AuxInt 19255 if !(uint64(c) >= 16) { 19256 break 19257 } 19258 v.reset(OpConst16) 19259 v.AuxInt = 0 19260 return true 19261 } 19262 // match: (Rsh16Ux64 <t> (Rsh16Ux64 x (Const64 [c])) (Const64 [d])) 19263 // cond: !uaddOvf(c,d) 19264 // result: (Rsh16Ux64 x (Const64 <t> [c+d])) 19265 for { 19266 t := v.Type 19267 _ = v.Args[1] 19268 v_0 := v.Args[0] 19269 if v_0.Op != OpRsh16Ux64 { 19270 break 19271 } 19272 _ = v_0.Args[1] 19273 x := v_0.Args[0] 19274 v_0_1 := v_0.Args[1] 19275 if v_0_1.Op != OpConst64 { 19276 break 19277 } 19278 c := v_0_1.AuxInt 19279 v_1 := v.Args[1] 19280 if v_1.Op != OpConst64 { 19281 break 19282 } 19283 d := v_1.AuxInt 19284 if !(!uaddOvf(c, d)) { 19285 break 19286 } 19287 v.reset(OpRsh16Ux64) 19288 v.AddArg(x) 19289 v0 := b.NewValue0(v.Pos, OpConst64, t) 19290 v0.AuxInt = c + d 19291 v.AddArg(v0) 19292 return true 19293 } 19294 // match: (Rsh16Ux64 (Lsh16x64 (Rsh16Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) 19295 // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) 19296 // result: (Rsh16Ux64 x (Const64 <typ.UInt64> [c1-c2+c3])) 19297 for { 19298 _ = v.Args[1] 19299 v_0 := v.Args[0] 19300 if v_0.Op != OpLsh16x64 { 19301 break 19302 } 19303 _ = v_0.Args[1] 19304 v_0_0 := v_0.Args[0] 19305 if v_0_0.Op != OpRsh16Ux64 { 19306 break 19307 } 19308 _ = v_0_0.Args[1] 19309 x := v_0_0.Args[0] 19310 v_0_0_1 := v_0_0.Args[1] 19311 if v_0_0_1.Op != OpConst64 { 19312 break 19313 } 19314 c1 := v_0_0_1.AuxInt 19315 v_0_1 := v_0.Args[1] 19316 if v_0_1.Op != OpConst64 { 19317 break 19318 } 19319 c2 := v_0_1.AuxInt 19320 v_1 := v.Args[1] 19321 if v_1.Op != OpConst64 { 19322 break 19323 } 19324 c3 := v_1.AuxInt 19325 if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { 19326 break 19327 } 19328 v.reset(OpRsh16Ux64) 19329 v.AddArg(x) 19330 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 19331 v0.AuxInt = c1 - c2 + c3 19332 v.AddArg(v0) 19333 return true 19334 } 19335 // match: (Rsh16Ux64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) 19336 // cond: 19337 // result: (ZeroExt8to16 (Trunc16to8 <typ.UInt8> x)) 19338 for { 19339 _ = v.Args[1] 19340 v_0 := v.Args[0] 19341 if v_0.Op != OpLsh16x64 { 19342 break 19343 } 19344 _ = v_0.Args[1] 19345 x := v_0.Args[0] 19346 v_0_1 := v_0.Args[1] 19347 if v_0_1.Op != OpConst64 { 19348 break 19349 } 19350 if v_0_1.AuxInt != 8 { 19351 break 19352 } 19353 v_1 := v.Args[1] 19354 if v_1.Op != OpConst64 { 19355 break 19356 } 19357 if v_1.AuxInt != 8 { 19358 break 19359 } 19360 v.reset(OpZeroExt8to16) 19361 v0 := b.NewValue0(v.Pos, OpTrunc16to8, typ.UInt8) 19362 v0.AddArg(x) 19363 v.AddArg(v0) 19364 return true 19365 } 19366 return false 19367 } 19368 func rewriteValuegeneric_OpRsh16Ux8_0(v *Value) bool { 19369 b := v.Block 19370 _ = b 19371 // match: (Rsh16Ux8 <t> x (Const8 [c])) 19372 // cond: 19373 // result: (Rsh16Ux64 x (Const64 <t> [int64(uint8(c))])) 19374 for { 19375 t := v.Type 19376 _ = v.Args[1] 19377 x := v.Args[0] 19378 v_1 := v.Args[1] 19379 if v_1.Op != OpConst8 { 19380 break 19381 } 19382 c := v_1.AuxInt 19383 v.reset(OpRsh16Ux64) 19384 v.AddArg(x) 19385 v0 := b.NewValue0(v.Pos, OpConst64, t) 19386 v0.AuxInt = int64(uint8(c)) 19387 v.AddArg(v0) 19388 return true 19389 } 19390 // match: (Rsh16Ux8 (Const16 [0]) _) 19391 // cond: 19392 // result: (Const16 [0]) 19393 for { 19394 _ = v.Args[1] 19395 v_0 := v.Args[0] 19396 if v_0.Op != OpConst16 { 19397 break 19398 } 19399 if v_0.AuxInt != 0 { 19400 break 19401 } 19402 v.reset(OpConst16) 19403 v.AuxInt = 0 19404 return true 19405 } 19406 return false 19407 } 19408 func rewriteValuegeneric_OpRsh16x16_0(v *Value) bool { 19409 b := v.Block 19410 _ = b 19411 // match: (Rsh16x16 <t> x (Const16 [c])) 19412 // cond: 19413 // result: (Rsh16x64 x (Const64 <t> [int64(uint16(c))])) 19414 for { 19415 t := v.Type 19416 _ = v.Args[1] 19417 x := v.Args[0] 19418 v_1 := v.Args[1] 19419 if v_1.Op != OpConst16 { 19420 break 19421 } 19422 c := v_1.AuxInt 19423 v.reset(OpRsh16x64) 19424 v.AddArg(x) 19425 v0 := b.NewValue0(v.Pos, OpConst64, t) 19426 v0.AuxInt = int64(uint16(c)) 19427 v.AddArg(v0) 19428 return true 19429 } 19430 // match: (Rsh16x16 (Const16 [0]) _) 19431 // cond: 19432 // result: (Const16 [0]) 19433 for { 19434 _ = v.Args[1] 19435 v_0 := v.Args[0] 19436 if v_0.Op != OpConst16 { 19437 break 19438 } 19439 if v_0.AuxInt != 0 { 19440 break 19441 } 19442 v.reset(OpConst16) 19443 v.AuxInt = 0 19444 return true 19445 } 19446 return false 19447 } 19448 func rewriteValuegeneric_OpRsh16x32_0(v *Value) bool { 19449 b := v.Block 19450 _ = b 19451 // match: (Rsh16x32 <t> x (Const32 [c])) 19452 // cond: 19453 // result: (Rsh16x64 x (Const64 <t> [int64(uint32(c))])) 19454 for { 19455 t := v.Type 19456 _ = v.Args[1] 19457 x := v.Args[0] 19458 v_1 := v.Args[1] 19459 if v_1.Op != OpConst32 { 19460 break 19461 } 19462 c := v_1.AuxInt 19463 v.reset(OpRsh16x64) 19464 v.AddArg(x) 19465 v0 := b.NewValue0(v.Pos, OpConst64, t) 19466 v0.AuxInt = int64(uint32(c)) 19467 v.AddArg(v0) 19468 return true 19469 } 19470 // match: (Rsh16x32 (Const16 [0]) _) 19471 // cond: 19472 // result: (Const16 [0]) 19473 for { 19474 _ = v.Args[1] 19475 v_0 := v.Args[0] 19476 if v_0.Op != OpConst16 { 19477 break 19478 } 19479 if v_0.AuxInt != 0 { 19480 break 19481 } 19482 v.reset(OpConst16) 19483 v.AuxInt = 0 19484 return true 19485 } 19486 return false 19487 } 19488 func rewriteValuegeneric_OpRsh16x64_0(v *Value) bool { 19489 b := v.Block 19490 _ = b 19491 typ := &b.Func.Config.Types 19492 _ = typ 19493 // match: (Rsh16x64 (Const16 [c]) (Const64 [d])) 19494 // cond: 19495 // result: (Const16 [int64(int16(c) >> uint64(d))]) 19496 for { 19497 _ = v.Args[1] 19498 v_0 := v.Args[0] 19499 if v_0.Op != OpConst16 { 19500 break 19501 } 19502 c := v_0.AuxInt 19503 v_1 := v.Args[1] 19504 if v_1.Op != OpConst64 { 19505 break 19506 } 19507 d := v_1.AuxInt 19508 v.reset(OpConst16) 19509 v.AuxInt = int64(int16(c) >> uint64(d)) 19510 return true 19511 } 19512 // match: (Rsh16x64 x (Const64 [0])) 19513 // cond: 19514 // result: x 19515 for { 19516 _ = v.Args[1] 19517 x := v.Args[0] 19518 v_1 := v.Args[1] 19519 if v_1.Op != OpConst64 { 19520 break 19521 } 19522 if v_1.AuxInt != 0 { 19523 break 19524 } 19525 v.reset(OpCopy) 19526 v.Type = x.Type 19527 v.AddArg(x) 19528 return true 19529 } 19530 // match: (Rsh16x64 (Const16 [0]) _) 19531 // cond: 19532 // result: (Const16 [0]) 19533 for { 19534 _ = v.Args[1] 19535 v_0 := v.Args[0] 19536 if v_0.Op != OpConst16 { 19537 break 19538 } 19539 if v_0.AuxInt != 0 { 19540 break 19541 } 19542 v.reset(OpConst16) 19543 v.AuxInt = 0 19544 return true 19545 } 19546 // match: (Rsh16x64 <t> (Rsh16x64 x (Const64 [c])) (Const64 [d])) 19547 // cond: !uaddOvf(c,d) 19548 // result: (Rsh16x64 x (Const64 <t> [c+d])) 19549 for { 19550 t := v.Type 19551 _ = v.Args[1] 19552 v_0 := v.Args[0] 19553 if v_0.Op != OpRsh16x64 { 19554 break 19555 } 19556 _ = v_0.Args[1] 19557 x := v_0.Args[0] 19558 v_0_1 := v_0.Args[1] 19559 if v_0_1.Op != OpConst64 { 19560 break 19561 } 19562 c := v_0_1.AuxInt 19563 v_1 := v.Args[1] 19564 if v_1.Op != OpConst64 { 19565 break 19566 } 19567 d := v_1.AuxInt 19568 if !(!uaddOvf(c, d)) { 19569 break 19570 } 19571 v.reset(OpRsh16x64) 19572 v.AddArg(x) 19573 v0 := b.NewValue0(v.Pos, OpConst64, t) 19574 v0.AuxInt = c + d 19575 v.AddArg(v0) 19576 return true 19577 } 19578 // match: (Rsh16x64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) 19579 // cond: 19580 // result: (SignExt8to16 (Trunc16to8 <typ.Int8> x)) 19581 for { 19582 _ = v.Args[1] 19583 v_0 := v.Args[0] 19584 if v_0.Op != OpLsh16x64 { 19585 break 19586 } 19587 _ = v_0.Args[1] 19588 x := v_0.Args[0] 19589 v_0_1 := v_0.Args[1] 19590 if v_0_1.Op != OpConst64 { 19591 break 19592 } 19593 if v_0_1.AuxInt != 8 { 19594 break 19595 } 19596 v_1 := v.Args[1] 19597 if v_1.Op != OpConst64 { 19598 break 19599 } 19600 if v_1.AuxInt != 8 { 19601 break 19602 } 19603 v.reset(OpSignExt8to16) 19604 v0 := b.NewValue0(v.Pos, OpTrunc16to8, typ.Int8) 19605 v0.AddArg(x) 19606 v.AddArg(v0) 19607 return true 19608 } 19609 return false 19610 } 19611 func rewriteValuegeneric_OpRsh16x8_0(v *Value) bool { 19612 b := v.Block 19613 _ = b 19614 // match: (Rsh16x8 <t> x (Const8 [c])) 19615 // cond: 19616 // result: (Rsh16x64 x (Const64 <t> [int64(uint8(c))])) 19617 for { 19618 t := v.Type 19619 _ = v.Args[1] 19620 x := v.Args[0] 19621 v_1 := v.Args[1] 19622 if v_1.Op != OpConst8 { 19623 break 19624 } 19625 c := v_1.AuxInt 19626 v.reset(OpRsh16x64) 19627 v.AddArg(x) 19628 v0 := b.NewValue0(v.Pos, OpConst64, t) 19629 v0.AuxInt = int64(uint8(c)) 19630 v.AddArg(v0) 19631 return true 19632 } 19633 // match: (Rsh16x8 (Const16 [0]) _) 19634 // cond: 19635 // result: (Const16 [0]) 19636 for { 19637 _ = v.Args[1] 19638 v_0 := v.Args[0] 19639 if v_0.Op != OpConst16 { 19640 break 19641 } 19642 if v_0.AuxInt != 0 { 19643 break 19644 } 19645 v.reset(OpConst16) 19646 v.AuxInt = 0 19647 return true 19648 } 19649 return false 19650 } 19651 func rewriteValuegeneric_OpRsh32Ux16_0(v *Value) bool { 19652 b := v.Block 19653 _ = b 19654 // match: (Rsh32Ux16 <t> x (Const16 [c])) 19655 // cond: 19656 // result: (Rsh32Ux64 x (Const64 <t> [int64(uint16(c))])) 19657 for { 19658 t := v.Type 19659 _ = v.Args[1] 19660 x := v.Args[0] 19661 v_1 := v.Args[1] 19662 if v_1.Op != OpConst16 { 19663 break 19664 } 19665 c := v_1.AuxInt 19666 v.reset(OpRsh32Ux64) 19667 v.AddArg(x) 19668 v0 := b.NewValue0(v.Pos, OpConst64, t) 19669 v0.AuxInt = int64(uint16(c)) 19670 v.AddArg(v0) 19671 return true 19672 } 19673 // match: (Rsh32Ux16 (Const32 [0]) _) 19674 // cond: 19675 // result: (Const32 [0]) 19676 for { 19677 _ = v.Args[1] 19678 v_0 := v.Args[0] 19679 if v_0.Op != OpConst32 { 19680 break 19681 } 19682 if v_0.AuxInt != 0 { 19683 break 19684 } 19685 v.reset(OpConst32) 19686 v.AuxInt = 0 19687 return true 19688 } 19689 return false 19690 } 19691 func rewriteValuegeneric_OpRsh32Ux32_0(v *Value) bool { 19692 b := v.Block 19693 _ = b 19694 // match: (Rsh32Ux32 <t> x (Const32 [c])) 19695 // cond: 19696 // result: (Rsh32Ux64 x (Const64 <t> [int64(uint32(c))])) 19697 for { 19698 t := v.Type 19699 _ = v.Args[1] 19700 x := v.Args[0] 19701 v_1 := v.Args[1] 19702 if v_1.Op != OpConst32 { 19703 break 19704 } 19705 c := v_1.AuxInt 19706 v.reset(OpRsh32Ux64) 19707 v.AddArg(x) 19708 v0 := b.NewValue0(v.Pos, OpConst64, t) 19709 v0.AuxInt = int64(uint32(c)) 19710 v.AddArg(v0) 19711 return true 19712 } 19713 // match: (Rsh32Ux32 (Const32 [0]) _) 19714 // cond: 19715 // result: (Const32 [0]) 19716 for { 19717 _ = v.Args[1] 19718 v_0 := v.Args[0] 19719 if v_0.Op != OpConst32 { 19720 break 19721 } 19722 if v_0.AuxInt != 0 { 19723 break 19724 } 19725 v.reset(OpConst32) 19726 v.AuxInt = 0 19727 return true 19728 } 19729 return false 19730 } 19731 func rewriteValuegeneric_OpRsh32Ux64_0(v *Value) bool { 19732 b := v.Block 19733 _ = b 19734 typ := &b.Func.Config.Types 19735 _ = typ 19736 // match: (Rsh32Ux64 (Const32 [c]) (Const64 [d])) 19737 // cond: 19738 // result: (Const32 [int64(int32(uint32(c) >> uint64(d)))]) 19739 for { 19740 _ = v.Args[1] 19741 v_0 := v.Args[0] 19742 if v_0.Op != OpConst32 { 19743 break 19744 } 19745 c := v_0.AuxInt 19746 v_1 := v.Args[1] 19747 if v_1.Op != OpConst64 { 19748 break 19749 } 19750 d := v_1.AuxInt 19751 v.reset(OpConst32) 19752 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 19753 return true 19754 } 19755 // match: (Rsh32Ux64 x (Const64 [0])) 19756 // cond: 19757 // result: x 19758 for { 19759 _ = v.Args[1] 19760 x := v.Args[0] 19761 v_1 := v.Args[1] 19762 if v_1.Op != OpConst64 { 19763 break 19764 } 19765 if v_1.AuxInt != 0 { 19766 break 19767 } 19768 v.reset(OpCopy) 19769 v.Type = x.Type 19770 v.AddArg(x) 19771 return true 19772 } 19773 // match: (Rsh32Ux64 (Const32 [0]) _) 19774 // cond: 19775 // result: (Const32 [0]) 19776 for { 19777 _ = v.Args[1] 19778 v_0 := v.Args[0] 19779 if v_0.Op != OpConst32 { 19780 break 19781 } 19782 if v_0.AuxInt != 0 { 19783 break 19784 } 19785 v.reset(OpConst32) 19786 v.AuxInt = 0 19787 return true 19788 } 19789 // match: (Rsh32Ux64 _ (Const64 [c])) 19790 // cond: uint64(c) >= 32 19791 // result: (Const32 [0]) 19792 for { 19793 _ = v.Args[1] 19794 v_1 := v.Args[1] 19795 if v_1.Op != OpConst64 { 19796 break 19797 } 19798 c := v_1.AuxInt 19799 if !(uint64(c) >= 32) { 19800 break 19801 } 19802 v.reset(OpConst32) 19803 v.AuxInt = 0 19804 return true 19805 } 19806 // match: (Rsh32Ux64 <t> (Rsh32Ux64 x (Const64 [c])) (Const64 [d])) 19807 // cond: !uaddOvf(c,d) 19808 // result: (Rsh32Ux64 x (Const64 <t> [c+d])) 19809 for { 19810 t := v.Type 19811 _ = v.Args[1] 19812 v_0 := v.Args[0] 19813 if v_0.Op != OpRsh32Ux64 { 19814 break 19815 } 19816 _ = v_0.Args[1] 19817 x := v_0.Args[0] 19818 v_0_1 := v_0.Args[1] 19819 if v_0_1.Op != OpConst64 { 19820 break 19821 } 19822 c := v_0_1.AuxInt 19823 v_1 := v.Args[1] 19824 if v_1.Op != OpConst64 { 19825 break 19826 } 19827 d := v_1.AuxInt 19828 if !(!uaddOvf(c, d)) { 19829 break 19830 } 19831 v.reset(OpRsh32Ux64) 19832 v.AddArg(x) 19833 v0 := b.NewValue0(v.Pos, OpConst64, t) 19834 v0.AuxInt = c + d 19835 v.AddArg(v0) 19836 return true 19837 } 19838 // match: (Rsh32Ux64 (Lsh32x64 (Rsh32Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) 19839 // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) 19840 // result: (Rsh32Ux64 x (Const64 <typ.UInt64> [c1-c2+c3])) 19841 for { 19842 _ = v.Args[1] 19843 v_0 := v.Args[0] 19844 if v_0.Op != OpLsh32x64 { 19845 break 19846 } 19847 _ = v_0.Args[1] 19848 v_0_0 := v_0.Args[0] 19849 if v_0_0.Op != OpRsh32Ux64 { 19850 break 19851 } 19852 _ = v_0_0.Args[1] 19853 x := v_0_0.Args[0] 19854 v_0_0_1 := v_0_0.Args[1] 19855 if v_0_0_1.Op != OpConst64 { 19856 break 19857 } 19858 c1 := v_0_0_1.AuxInt 19859 v_0_1 := v_0.Args[1] 19860 if v_0_1.Op != OpConst64 { 19861 break 19862 } 19863 c2 := v_0_1.AuxInt 19864 v_1 := v.Args[1] 19865 if v_1.Op != OpConst64 { 19866 break 19867 } 19868 c3 := v_1.AuxInt 19869 if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { 19870 break 19871 } 19872 v.reset(OpRsh32Ux64) 19873 v.AddArg(x) 19874 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 19875 v0.AuxInt = c1 - c2 + c3 19876 v.AddArg(v0) 19877 return true 19878 } 19879 // match: (Rsh32Ux64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) 19880 // cond: 19881 // result: (ZeroExt8to32 (Trunc32to8 <typ.UInt8> x)) 19882 for { 19883 _ = v.Args[1] 19884 v_0 := v.Args[0] 19885 if v_0.Op != OpLsh32x64 { 19886 break 19887 } 19888 _ = v_0.Args[1] 19889 x := v_0.Args[0] 19890 v_0_1 := v_0.Args[1] 19891 if v_0_1.Op != OpConst64 { 19892 break 19893 } 19894 if v_0_1.AuxInt != 24 { 19895 break 19896 } 19897 v_1 := v.Args[1] 19898 if v_1.Op != OpConst64 { 19899 break 19900 } 19901 if v_1.AuxInt != 24 { 19902 break 19903 } 19904 v.reset(OpZeroExt8to32) 19905 v0 := b.NewValue0(v.Pos, OpTrunc32to8, typ.UInt8) 19906 v0.AddArg(x) 19907 v.AddArg(v0) 19908 return true 19909 } 19910 // match: (Rsh32Ux64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) 19911 // cond: 19912 // result: (ZeroExt16to32 (Trunc32to16 <typ.UInt16> x)) 19913 for { 19914 _ = v.Args[1] 19915 v_0 := v.Args[0] 19916 if v_0.Op != OpLsh32x64 { 19917 break 19918 } 19919 _ = v_0.Args[1] 19920 x := v_0.Args[0] 19921 v_0_1 := v_0.Args[1] 19922 if v_0_1.Op != OpConst64 { 19923 break 19924 } 19925 if v_0_1.AuxInt != 16 { 19926 break 19927 } 19928 v_1 := v.Args[1] 19929 if v_1.Op != OpConst64 { 19930 break 19931 } 19932 if v_1.AuxInt != 16 { 19933 break 19934 } 19935 v.reset(OpZeroExt16to32) 19936 v0 := b.NewValue0(v.Pos, OpTrunc32to16, typ.UInt16) 19937 v0.AddArg(x) 19938 v.AddArg(v0) 19939 return true 19940 } 19941 return false 19942 } 19943 func rewriteValuegeneric_OpRsh32Ux8_0(v *Value) bool { 19944 b := v.Block 19945 _ = b 19946 // match: (Rsh32Ux8 <t> x (Const8 [c])) 19947 // cond: 19948 // result: (Rsh32Ux64 x (Const64 <t> [int64(uint8(c))])) 19949 for { 19950 t := v.Type 19951 _ = v.Args[1] 19952 x := v.Args[0] 19953 v_1 := v.Args[1] 19954 if v_1.Op != OpConst8 { 19955 break 19956 } 19957 c := v_1.AuxInt 19958 v.reset(OpRsh32Ux64) 19959 v.AddArg(x) 19960 v0 := b.NewValue0(v.Pos, OpConst64, t) 19961 v0.AuxInt = int64(uint8(c)) 19962 v.AddArg(v0) 19963 return true 19964 } 19965 // match: (Rsh32Ux8 (Const32 [0]) _) 19966 // cond: 19967 // result: (Const32 [0]) 19968 for { 19969 _ = v.Args[1] 19970 v_0 := v.Args[0] 19971 if v_0.Op != OpConst32 { 19972 break 19973 } 19974 if v_0.AuxInt != 0 { 19975 break 19976 } 19977 v.reset(OpConst32) 19978 v.AuxInt = 0 19979 return true 19980 } 19981 return false 19982 } 19983 func rewriteValuegeneric_OpRsh32x16_0(v *Value) bool { 19984 b := v.Block 19985 _ = b 19986 // match: (Rsh32x16 <t> x (Const16 [c])) 19987 // cond: 19988 // result: (Rsh32x64 x (Const64 <t> [int64(uint16(c))])) 19989 for { 19990 t := v.Type 19991 _ = v.Args[1] 19992 x := v.Args[0] 19993 v_1 := v.Args[1] 19994 if v_1.Op != OpConst16 { 19995 break 19996 } 19997 c := v_1.AuxInt 19998 v.reset(OpRsh32x64) 19999 v.AddArg(x) 20000 v0 := b.NewValue0(v.Pos, OpConst64, t) 20001 v0.AuxInt = int64(uint16(c)) 20002 v.AddArg(v0) 20003 return true 20004 } 20005 // match: (Rsh32x16 (Const32 [0]) _) 20006 // cond: 20007 // result: (Const32 [0]) 20008 for { 20009 _ = v.Args[1] 20010 v_0 := v.Args[0] 20011 if v_0.Op != OpConst32 { 20012 break 20013 } 20014 if v_0.AuxInt != 0 { 20015 break 20016 } 20017 v.reset(OpConst32) 20018 v.AuxInt = 0 20019 return true 20020 } 20021 return false 20022 } 20023 func rewriteValuegeneric_OpRsh32x32_0(v *Value) bool { 20024 b := v.Block 20025 _ = b 20026 // match: (Rsh32x32 <t> x (Const32 [c])) 20027 // cond: 20028 // result: (Rsh32x64 x (Const64 <t> [int64(uint32(c))])) 20029 for { 20030 t := v.Type 20031 _ = v.Args[1] 20032 x := v.Args[0] 20033 v_1 := v.Args[1] 20034 if v_1.Op != OpConst32 { 20035 break 20036 } 20037 c := v_1.AuxInt 20038 v.reset(OpRsh32x64) 20039 v.AddArg(x) 20040 v0 := b.NewValue0(v.Pos, OpConst64, t) 20041 v0.AuxInt = int64(uint32(c)) 20042 v.AddArg(v0) 20043 return true 20044 } 20045 // match: (Rsh32x32 (Const32 [0]) _) 20046 // cond: 20047 // result: (Const32 [0]) 20048 for { 20049 _ = v.Args[1] 20050 v_0 := v.Args[0] 20051 if v_0.Op != OpConst32 { 20052 break 20053 } 20054 if v_0.AuxInt != 0 { 20055 break 20056 } 20057 v.reset(OpConst32) 20058 v.AuxInt = 0 20059 return true 20060 } 20061 return false 20062 } 20063 func rewriteValuegeneric_OpRsh32x64_0(v *Value) bool { 20064 b := v.Block 20065 _ = b 20066 typ := &b.Func.Config.Types 20067 _ = typ 20068 // match: (Rsh32x64 (Const32 [c]) (Const64 [d])) 20069 // cond: 20070 // result: (Const32 [int64(int32(c) >> uint64(d))]) 20071 for { 20072 _ = v.Args[1] 20073 v_0 := v.Args[0] 20074 if v_0.Op != OpConst32 { 20075 break 20076 } 20077 c := v_0.AuxInt 20078 v_1 := v.Args[1] 20079 if v_1.Op != OpConst64 { 20080 break 20081 } 20082 d := v_1.AuxInt 20083 v.reset(OpConst32) 20084 v.AuxInt = int64(int32(c) >> uint64(d)) 20085 return true 20086 } 20087 // match: (Rsh32x64 x (Const64 [0])) 20088 // cond: 20089 // result: x 20090 for { 20091 _ = v.Args[1] 20092 x := v.Args[0] 20093 v_1 := v.Args[1] 20094 if v_1.Op != OpConst64 { 20095 break 20096 } 20097 if v_1.AuxInt != 0 { 20098 break 20099 } 20100 v.reset(OpCopy) 20101 v.Type = x.Type 20102 v.AddArg(x) 20103 return true 20104 } 20105 // match: (Rsh32x64 (Const32 [0]) _) 20106 // cond: 20107 // result: (Const32 [0]) 20108 for { 20109 _ = v.Args[1] 20110 v_0 := v.Args[0] 20111 if v_0.Op != OpConst32 { 20112 break 20113 } 20114 if v_0.AuxInt != 0 { 20115 break 20116 } 20117 v.reset(OpConst32) 20118 v.AuxInt = 0 20119 return true 20120 } 20121 // match: (Rsh32x64 <t> (Rsh32x64 x (Const64 [c])) (Const64 [d])) 20122 // cond: !uaddOvf(c,d) 20123 // result: (Rsh32x64 x (Const64 <t> [c+d])) 20124 for { 20125 t := v.Type 20126 _ = v.Args[1] 20127 v_0 := v.Args[0] 20128 if v_0.Op != OpRsh32x64 { 20129 break 20130 } 20131 _ = v_0.Args[1] 20132 x := v_0.Args[0] 20133 v_0_1 := v_0.Args[1] 20134 if v_0_1.Op != OpConst64 { 20135 break 20136 } 20137 c := v_0_1.AuxInt 20138 v_1 := v.Args[1] 20139 if v_1.Op != OpConst64 { 20140 break 20141 } 20142 d := v_1.AuxInt 20143 if !(!uaddOvf(c, d)) { 20144 break 20145 } 20146 v.reset(OpRsh32x64) 20147 v.AddArg(x) 20148 v0 := b.NewValue0(v.Pos, OpConst64, t) 20149 v0.AuxInt = c + d 20150 v.AddArg(v0) 20151 return true 20152 } 20153 // match: (Rsh32x64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) 20154 // cond: 20155 // result: (SignExt8to32 (Trunc32to8 <typ.Int8> x)) 20156 for { 20157 _ = v.Args[1] 20158 v_0 := v.Args[0] 20159 if v_0.Op != OpLsh32x64 { 20160 break 20161 } 20162 _ = v_0.Args[1] 20163 x := v_0.Args[0] 20164 v_0_1 := v_0.Args[1] 20165 if v_0_1.Op != OpConst64 { 20166 break 20167 } 20168 if v_0_1.AuxInt != 24 { 20169 break 20170 } 20171 v_1 := v.Args[1] 20172 if v_1.Op != OpConst64 { 20173 break 20174 } 20175 if v_1.AuxInt != 24 { 20176 break 20177 } 20178 v.reset(OpSignExt8to32) 20179 v0 := b.NewValue0(v.Pos, OpTrunc32to8, typ.Int8) 20180 v0.AddArg(x) 20181 v.AddArg(v0) 20182 return true 20183 } 20184 // match: (Rsh32x64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) 20185 // cond: 20186 // result: (SignExt16to32 (Trunc32to16 <typ.Int16> x)) 20187 for { 20188 _ = v.Args[1] 20189 v_0 := v.Args[0] 20190 if v_0.Op != OpLsh32x64 { 20191 break 20192 } 20193 _ = v_0.Args[1] 20194 x := v_0.Args[0] 20195 v_0_1 := v_0.Args[1] 20196 if v_0_1.Op != OpConst64 { 20197 break 20198 } 20199 if v_0_1.AuxInt != 16 { 20200 break 20201 } 20202 v_1 := v.Args[1] 20203 if v_1.Op != OpConst64 { 20204 break 20205 } 20206 if v_1.AuxInt != 16 { 20207 break 20208 } 20209 v.reset(OpSignExt16to32) 20210 v0 := b.NewValue0(v.Pos, OpTrunc32to16, typ.Int16) 20211 v0.AddArg(x) 20212 v.AddArg(v0) 20213 return true 20214 } 20215 return false 20216 } 20217 func rewriteValuegeneric_OpRsh32x8_0(v *Value) bool { 20218 b := v.Block 20219 _ = b 20220 // match: (Rsh32x8 <t> x (Const8 [c])) 20221 // cond: 20222 // result: (Rsh32x64 x (Const64 <t> [int64(uint8(c))])) 20223 for { 20224 t := v.Type 20225 _ = v.Args[1] 20226 x := v.Args[0] 20227 v_1 := v.Args[1] 20228 if v_1.Op != OpConst8 { 20229 break 20230 } 20231 c := v_1.AuxInt 20232 v.reset(OpRsh32x64) 20233 v.AddArg(x) 20234 v0 := b.NewValue0(v.Pos, OpConst64, t) 20235 v0.AuxInt = int64(uint8(c)) 20236 v.AddArg(v0) 20237 return true 20238 } 20239 // match: (Rsh32x8 (Const32 [0]) _) 20240 // cond: 20241 // result: (Const32 [0]) 20242 for { 20243 _ = v.Args[1] 20244 v_0 := v.Args[0] 20245 if v_0.Op != OpConst32 { 20246 break 20247 } 20248 if v_0.AuxInt != 0 { 20249 break 20250 } 20251 v.reset(OpConst32) 20252 v.AuxInt = 0 20253 return true 20254 } 20255 return false 20256 } 20257 func rewriteValuegeneric_OpRsh64Ux16_0(v *Value) bool { 20258 b := v.Block 20259 _ = b 20260 // match: (Rsh64Ux16 <t> x (Const16 [c])) 20261 // cond: 20262 // result: (Rsh64Ux64 x (Const64 <t> [int64(uint16(c))])) 20263 for { 20264 t := v.Type 20265 _ = v.Args[1] 20266 x := v.Args[0] 20267 v_1 := v.Args[1] 20268 if v_1.Op != OpConst16 { 20269 break 20270 } 20271 c := v_1.AuxInt 20272 v.reset(OpRsh64Ux64) 20273 v.AddArg(x) 20274 v0 := b.NewValue0(v.Pos, OpConst64, t) 20275 v0.AuxInt = int64(uint16(c)) 20276 v.AddArg(v0) 20277 return true 20278 } 20279 // match: (Rsh64Ux16 (Const64 [0]) _) 20280 // cond: 20281 // result: (Const64 [0]) 20282 for { 20283 _ = v.Args[1] 20284 v_0 := v.Args[0] 20285 if v_0.Op != OpConst64 { 20286 break 20287 } 20288 if v_0.AuxInt != 0 { 20289 break 20290 } 20291 v.reset(OpConst64) 20292 v.AuxInt = 0 20293 return true 20294 } 20295 return false 20296 } 20297 func rewriteValuegeneric_OpRsh64Ux32_0(v *Value) bool { 20298 b := v.Block 20299 _ = b 20300 // match: (Rsh64Ux32 <t> x (Const32 [c])) 20301 // cond: 20302 // result: (Rsh64Ux64 x (Const64 <t> [int64(uint32(c))])) 20303 for { 20304 t := v.Type 20305 _ = v.Args[1] 20306 x := v.Args[0] 20307 v_1 := v.Args[1] 20308 if v_1.Op != OpConst32 { 20309 break 20310 } 20311 c := v_1.AuxInt 20312 v.reset(OpRsh64Ux64) 20313 v.AddArg(x) 20314 v0 := b.NewValue0(v.Pos, OpConst64, t) 20315 v0.AuxInt = int64(uint32(c)) 20316 v.AddArg(v0) 20317 return true 20318 } 20319 // match: (Rsh64Ux32 (Const64 [0]) _) 20320 // cond: 20321 // result: (Const64 [0]) 20322 for { 20323 _ = v.Args[1] 20324 v_0 := v.Args[0] 20325 if v_0.Op != OpConst64 { 20326 break 20327 } 20328 if v_0.AuxInt != 0 { 20329 break 20330 } 20331 v.reset(OpConst64) 20332 v.AuxInt = 0 20333 return true 20334 } 20335 return false 20336 } 20337 func rewriteValuegeneric_OpRsh64Ux64_0(v *Value) bool { 20338 b := v.Block 20339 _ = b 20340 typ := &b.Func.Config.Types 20341 _ = typ 20342 // match: (Rsh64Ux64 (Const64 [c]) (Const64 [d])) 20343 // cond: 20344 // result: (Const64 [int64(uint64(c) >> uint64(d))]) 20345 for { 20346 _ = v.Args[1] 20347 v_0 := v.Args[0] 20348 if v_0.Op != OpConst64 { 20349 break 20350 } 20351 c := v_0.AuxInt 20352 v_1 := v.Args[1] 20353 if v_1.Op != OpConst64 { 20354 break 20355 } 20356 d := v_1.AuxInt 20357 v.reset(OpConst64) 20358 v.AuxInt = int64(uint64(c) >> uint64(d)) 20359 return true 20360 } 20361 // match: (Rsh64Ux64 x (Const64 [0])) 20362 // cond: 20363 // result: x 20364 for { 20365 _ = v.Args[1] 20366 x := v.Args[0] 20367 v_1 := v.Args[1] 20368 if v_1.Op != OpConst64 { 20369 break 20370 } 20371 if v_1.AuxInt != 0 { 20372 break 20373 } 20374 v.reset(OpCopy) 20375 v.Type = x.Type 20376 v.AddArg(x) 20377 return true 20378 } 20379 // match: (Rsh64Ux64 (Const64 [0]) _) 20380 // cond: 20381 // result: (Const64 [0]) 20382 for { 20383 _ = v.Args[1] 20384 v_0 := v.Args[0] 20385 if v_0.Op != OpConst64 { 20386 break 20387 } 20388 if v_0.AuxInt != 0 { 20389 break 20390 } 20391 v.reset(OpConst64) 20392 v.AuxInt = 0 20393 return true 20394 } 20395 // match: (Rsh64Ux64 _ (Const64 [c])) 20396 // cond: uint64(c) >= 64 20397 // result: (Const64 [0]) 20398 for { 20399 _ = v.Args[1] 20400 v_1 := v.Args[1] 20401 if v_1.Op != OpConst64 { 20402 break 20403 } 20404 c := v_1.AuxInt 20405 if !(uint64(c) >= 64) { 20406 break 20407 } 20408 v.reset(OpConst64) 20409 v.AuxInt = 0 20410 return true 20411 } 20412 // match: (Rsh64Ux64 <t> (Rsh64Ux64 x (Const64 [c])) (Const64 [d])) 20413 // cond: !uaddOvf(c,d) 20414 // result: (Rsh64Ux64 x (Const64 <t> [c+d])) 20415 for { 20416 t := v.Type 20417 _ = v.Args[1] 20418 v_0 := v.Args[0] 20419 if v_0.Op != OpRsh64Ux64 { 20420 break 20421 } 20422 _ = v_0.Args[1] 20423 x := v_0.Args[0] 20424 v_0_1 := v_0.Args[1] 20425 if v_0_1.Op != OpConst64 { 20426 break 20427 } 20428 c := v_0_1.AuxInt 20429 v_1 := v.Args[1] 20430 if v_1.Op != OpConst64 { 20431 break 20432 } 20433 d := v_1.AuxInt 20434 if !(!uaddOvf(c, d)) { 20435 break 20436 } 20437 v.reset(OpRsh64Ux64) 20438 v.AddArg(x) 20439 v0 := b.NewValue0(v.Pos, OpConst64, t) 20440 v0.AuxInt = c + d 20441 v.AddArg(v0) 20442 return true 20443 } 20444 // match: (Rsh64Ux64 (Lsh64x64 (Rsh64Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) 20445 // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) 20446 // result: (Rsh64Ux64 x (Const64 <typ.UInt64> [c1-c2+c3])) 20447 for { 20448 _ = v.Args[1] 20449 v_0 := v.Args[0] 20450 if v_0.Op != OpLsh64x64 { 20451 break 20452 } 20453 _ = v_0.Args[1] 20454 v_0_0 := v_0.Args[0] 20455 if v_0_0.Op != OpRsh64Ux64 { 20456 break 20457 } 20458 _ = v_0_0.Args[1] 20459 x := v_0_0.Args[0] 20460 v_0_0_1 := v_0_0.Args[1] 20461 if v_0_0_1.Op != OpConst64 { 20462 break 20463 } 20464 c1 := v_0_0_1.AuxInt 20465 v_0_1 := v_0.Args[1] 20466 if v_0_1.Op != OpConst64 { 20467 break 20468 } 20469 c2 := v_0_1.AuxInt 20470 v_1 := v.Args[1] 20471 if v_1.Op != OpConst64 { 20472 break 20473 } 20474 c3 := v_1.AuxInt 20475 if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { 20476 break 20477 } 20478 v.reset(OpRsh64Ux64) 20479 v.AddArg(x) 20480 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 20481 v0.AuxInt = c1 - c2 + c3 20482 v.AddArg(v0) 20483 return true 20484 } 20485 // match: (Rsh64Ux64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) 20486 // cond: 20487 // result: (ZeroExt8to64 (Trunc64to8 <typ.UInt8> x)) 20488 for { 20489 _ = v.Args[1] 20490 v_0 := v.Args[0] 20491 if v_0.Op != OpLsh64x64 { 20492 break 20493 } 20494 _ = v_0.Args[1] 20495 x := v_0.Args[0] 20496 v_0_1 := v_0.Args[1] 20497 if v_0_1.Op != OpConst64 { 20498 break 20499 } 20500 if v_0_1.AuxInt != 56 { 20501 break 20502 } 20503 v_1 := v.Args[1] 20504 if v_1.Op != OpConst64 { 20505 break 20506 } 20507 if v_1.AuxInt != 56 { 20508 break 20509 } 20510 v.reset(OpZeroExt8to64) 20511 v0 := b.NewValue0(v.Pos, OpTrunc64to8, typ.UInt8) 20512 v0.AddArg(x) 20513 v.AddArg(v0) 20514 return true 20515 } 20516 // match: (Rsh64Ux64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) 20517 // cond: 20518 // result: (ZeroExt16to64 (Trunc64to16 <typ.UInt16> x)) 20519 for { 20520 _ = v.Args[1] 20521 v_0 := v.Args[0] 20522 if v_0.Op != OpLsh64x64 { 20523 break 20524 } 20525 _ = v_0.Args[1] 20526 x := v_0.Args[0] 20527 v_0_1 := v_0.Args[1] 20528 if v_0_1.Op != OpConst64 { 20529 break 20530 } 20531 if v_0_1.AuxInt != 48 { 20532 break 20533 } 20534 v_1 := v.Args[1] 20535 if v_1.Op != OpConst64 { 20536 break 20537 } 20538 if v_1.AuxInt != 48 { 20539 break 20540 } 20541 v.reset(OpZeroExt16to64) 20542 v0 := b.NewValue0(v.Pos, OpTrunc64to16, typ.UInt16) 20543 v0.AddArg(x) 20544 v.AddArg(v0) 20545 return true 20546 } 20547 // match: (Rsh64Ux64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) 20548 // cond: 20549 // result: (ZeroExt32to64 (Trunc64to32 <typ.UInt32> x)) 20550 for { 20551 _ = v.Args[1] 20552 v_0 := v.Args[0] 20553 if v_0.Op != OpLsh64x64 { 20554 break 20555 } 20556 _ = v_0.Args[1] 20557 x := v_0.Args[0] 20558 v_0_1 := v_0.Args[1] 20559 if v_0_1.Op != OpConst64 { 20560 break 20561 } 20562 if v_0_1.AuxInt != 32 { 20563 break 20564 } 20565 v_1 := v.Args[1] 20566 if v_1.Op != OpConst64 { 20567 break 20568 } 20569 if v_1.AuxInt != 32 { 20570 break 20571 } 20572 v.reset(OpZeroExt32to64) 20573 v0 := b.NewValue0(v.Pos, OpTrunc64to32, typ.UInt32) 20574 v0.AddArg(x) 20575 v.AddArg(v0) 20576 return true 20577 } 20578 return false 20579 } 20580 func rewriteValuegeneric_OpRsh64Ux8_0(v *Value) bool { 20581 b := v.Block 20582 _ = b 20583 // match: (Rsh64Ux8 <t> x (Const8 [c])) 20584 // cond: 20585 // result: (Rsh64Ux64 x (Const64 <t> [int64(uint8(c))])) 20586 for { 20587 t := v.Type 20588 _ = v.Args[1] 20589 x := v.Args[0] 20590 v_1 := v.Args[1] 20591 if v_1.Op != OpConst8 { 20592 break 20593 } 20594 c := v_1.AuxInt 20595 v.reset(OpRsh64Ux64) 20596 v.AddArg(x) 20597 v0 := b.NewValue0(v.Pos, OpConst64, t) 20598 v0.AuxInt = int64(uint8(c)) 20599 v.AddArg(v0) 20600 return true 20601 } 20602 // match: (Rsh64Ux8 (Const64 [0]) _) 20603 // cond: 20604 // result: (Const64 [0]) 20605 for { 20606 _ = v.Args[1] 20607 v_0 := v.Args[0] 20608 if v_0.Op != OpConst64 { 20609 break 20610 } 20611 if v_0.AuxInt != 0 { 20612 break 20613 } 20614 v.reset(OpConst64) 20615 v.AuxInt = 0 20616 return true 20617 } 20618 return false 20619 } 20620 func rewriteValuegeneric_OpRsh64x16_0(v *Value) bool { 20621 b := v.Block 20622 _ = b 20623 // match: (Rsh64x16 <t> x (Const16 [c])) 20624 // cond: 20625 // result: (Rsh64x64 x (Const64 <t> [int64(uint16(c))])) 20626 for { 20627 t := v.Type 20628 _ = v.Args[1] 20629 x := v.Args[0] 20630 v_1 := v.Args[1] 20631 if v_1.Op != OpConst16 { 20632 break 20633 } 20634 c := v_1.AuxInt 20635 v.reset(OpRsh64x64) 20636 v.AddArg(x) 20637 v0 := b.NewValue0(v.Pos, OpConst64, t) 20638 v0.AuxInt = int64(uint16(c)) 20639 v.AddArg(v0) 20640 return true 20641 } 20642 // match: (Rsh64x16 (Const64 [0]) _) 20643 // cond: 20644 // result: (Const64 [0]) 20645 for { 20646 _ = v.Args[1] 20647 v_0 := v.Args[0] 20648 if v_0.Op != OpConst64 { 20649 break 20650 } 20651 if v_0.AuxInt != 0 { 20652 break 20653 } 20654 v.reset(OpConst64) 20655 v.AuxInt = 0 20656 return true 20657 } 20658 return false 20659 } 20660 func rewriteValuegeneric_OpRsh64x32_0(v *Value) bool { 20661 b := v.Block 20662 _ = b 20663 // match: (Rsh64x32 <t> x (Const32 [c])) 20664 // cond: 20665 // result: (Rsh64x64 x (Const64 <t> [int64(uint32(c))])) 20666 for { 20667 t := v.Type 20668 _ = v.Args[1] 20669 x := v.Args[0] 20670 v_1 := v.Args[1] 20671 if v_1.Op != OpConst32 { 20672 break 20673 } 20674 c := v_1.AuxInt 20675 v.reset(OpRsh64x64) 20676 v.AddArg(x) 20677 v0 := b.NewValue0(v.Pos, OpConst64, t) 20678 v0.AuxInt = int64(uint32(c)) 20679 v.AddArg(v0) 20680 return true 20681 } 20682 // match: (Rsh64x32 (Const64 [0]) _) 20683 // cond: 20684 // result: (Const64 [0]) 20685 for { 20686 _ = v.Args[1] 20687 v_0 := v.Args[0] 20688 if v_0.Op != OpConst64 { 20689 break 20690 } 20691 if v_0.AuxInt != 0 { 20692 break 20693 } 20694 v.reset(OpConst64) 20695 v.AuxInt = 0 20696 return true 20697 } 20698 return false 20699 } 20700 func rewriteValuegeneric_OpRsh64x64_0(v *Value) bool { 20701 b := v.Block 20702 _ = b 20703 typ := &b.Func.Config.Types 20704 _ = typ 20705 // match: (Rsh64x64 (Const64 [c]) (Const64 [d])) 20706 // cond: 20707 // result: (Const64 [c >> uint64(d)]) 20708 for { 20709 _ = v.Args[1] 20710 v_0 := v.Args[0] 20711 if v_0.Op != OpConst64 { 20712 break 20713 } 20714 c := v_0.AuxInt 20715 v_1 := v.Args[1] 20716 if v_1.Op != OpConst64 { 20717 break 20718 } 20719 d := v_1.AuxInt 20720 v.reset(OpConst64) 20721 v.AuxInt = c >> uint64(d) 20722 return true 20723 } 20724 // match: (Rsh64x64 x (Const64 [0])) 20725 // cond: 20726 // result: x 20727 for { 20728 _ = v.Args[1] 20729 x := v.Args[0] 20730 v_1 := v.Args[1] 20731 if v_1.Op != OpConst64 { 20732 break 20733 } 20734 if v_1.AuxInt != 0 { 20735 break 20736 } 20737 v.reset(OpCopy) 20738 v.Type = x.Type 20739 v.AddArg(x) 20740 return true 20741 } 20742 // match: (Rsh64x64 (Const64 [0]) _) 20743 // cond: 20744 // result: (Const64 [0]) 20745 for { 20746 _ = v.Args[1] 20747 v_0 := v.Args[0] 20748 if v_0.Op != OpConst64 { 20749 break 20750 } 20751 if v_0.AuxInt != 0 { 20752 break 20753 } 20754 v.reset(OpConst64) 20755 v.AuxInt = 0 20756 return true 20757 } 20758 // match: (Rsh64x64 <t> (Rsh64x64 x (Const64 [c])) (Const64 [d])) 20759 // cond: !uaddOvf(c,d) 20760 // result: (Rsh64x64 x (Const64 <t> [c+d])) 20761 for { 20762 t := v.Type 20763 _ = v.Args[1] 20764 v_0 := v.Args[0] 20765 if v_0.Op != OpRsh64x64 { 20766 break 20767 } 20768 _ = v_0.Args[1] 20769 x := v_0.Args[0] 20770 v_0_1 := v_0.Args[1] 20771 if v_0_1.Op != OpConst64 { 20772 break 20773 } 20774 c := v_0_1.AuxInt 20775 v_1 := v.Args[1] 20776 if v_1.Op != OpConst64 { 20777 break 20778 } 20779 d := v_1.AuxInt 20780 if !(!uaddOvf(c, d)) { 20781 break 20782 } 20783 v.reset(OpRsh64x64) 20784 v.AddArg(x) 20785 v0 := b.NewValue0(v.Pos, OpConst64, t) 20786 v0.AuxInt = c + d 20787 v.AddArg(v0) 20788 return true 20789 } 20790 // match: (Rsh64x64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) 20791 // cond: 20792 // result: (SignExt8to64 (Trunc64to8 <typ.Int8> x)) 20793 for { 20794 _ = v.Args[1] 20795 v_0 := v.Args[0] 20796 if v_0.Op != OpLsh64x64 { 20797 break 20798 } 20799 _ = v_0.Args[1] 20800 x := v_0.Args[0] 20801 v_0_1 := v_0.Args[1] 20802 if v_0_1.Op != OpConst64 { 20803 break 20804 } 20805 if v_0_1.AuxInt != 56 { 20806 break 20807 } 20808 v_1 := v.Args[1] 20809 if v_1.Op != OpConst64 { 20810 break 20811 } 20812 if v_1.AuxInt != 56 { 20813 break 20814 } 20815 v.reset(OpSignExt8to64) 20816 v0 := b.NewValue0(v.Pos, OpTrunc64to8, typ.Int8) 20817 v0.AddArg(x) 20818 v.AddArg(v0) 20819 return true 20820 } 20821 // match: (Rsh64x64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) 20822 // cond: 20823 // result: (SignExt16to64 (Trunc64to16 <typ.Int16> x)) 20824 for { 20825 _ = v.Args[1] 20826 v_0 := v.Args[0] 20827 if v_0.Op != OpLsh64x64 { 20828 break 20829 } 20830 _ = v_0.Args[1] 20831 x := v_0.Args[0] 20832 v_0_1 := v_0.Args[1] 20833 if v_0_1.Op != OpConst64 { 20834 break 20835 } 20836 if v_0_1.AuxInt != 48 { 20837 break 20838 } 20839 v_1 := v.Args[1] 20840 if v_1.Op != OpConst64 { 20841 break 20842 } 20843 if v_1.AuxInt != 48 { 20844 break 20845 } 20846 v.reset(OpSignExt16to64) 20847 v0 := b.NewValue0(v.Pos, OpTrunc64to16, typ.Int16) 20848 v0.AddArg(x) 20849 v.AddArg(v0) 20850 return true 20851 } 20852 // match: (Rsh64x64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) 20853 // cond: 20854 // result: (SignExt32to64 (Trunc64to32 <typ.Int32> x)) 20855 for { 20856 _ = v.Args[1] 20857 v_0 := v.Args[0] 20858 if v_0.Op != OpLsh64x64 { 20859 break 20860 } 20861 _ = v_0.Args[1] 20862 x := v_0.Args[0] 20863 v_0_1 := v_0.Args[1] 20864 if v_0_1.Op != OpConst64 { 20865 break 20866 } 20867 if v_0_1.AuxInt != 32 { 20868 break 20869 } 20870 v_1 := v.Args[1] 20871 if v_1.Op != OpConst64 { 20872 break 20873 } 20874 if v_1.AuxInt != 32 { 20875 break 20876 } 20877 v.reset(OpSignExt32to64) 20878 v0 := b.NewValue0(v.Pos, OpTrunc64to32, typ.Int32) 20879 v0.AddArg(x) 20880 v.AddArg(v0) 20881 return true 20882 } 20883 return false 20884 } 20885 func rewriteValuegeneric_OpRsh64x8_0(v *Value) bool { 20886 b := v.Block 20887 _ = b 20888 // match: (Rsh64x8 <t> x (Const8 [c])) 20889 // cond: 20890 // result: (Rsh64x64 x (Const64 <t> [int64(uint8(c))])) 20891 for { 20892 t := v.Type 20893 _ = v.Args[1] 20894 x := v.Args[0] 20895 v_1 := v.Args[1] 20896 if v_1.Op != OpConst8 { 20897 break 20898 } 20899 c := v_1.AuxInt 20900 v.reset(OpRsh64x64) 20901 v.AddArg(x) 20902 v0 := b.NewValue0(v.Pos, OpConst64, t) 20903 v0.AuxInt = int64(uint8(c)) 20904 v.AddArg(v0) 20905 return true 20906 } 20907 // match: (Rsh64x8 (Const64 [0]) _) 20908 // cond: 20909 // result: (Const64 [0]) 20910 for { 20911 _ = v.Args[1] 20912 v_0 := v.Args[0] 20913 if v_0.Op != OpConst64 { 20914 break 20915 } 20916 if v_0.AuxInt != 0 { 20917 break 20918 } 20919 v.reset(OpConst64) 20920 v.AuxInt = 0 20921 return true 20922 } 20923 return false 20924 } 20925 func rewriteValuegeneric_OpRsh8Ux16_0(v *Value) bool { 20926 b := v.Block 20927 _ = b 20928 // match: (Rsh8Ux16 <t> x (Const16 [c])) 20929 // cond: 20930 // result: (Rsh8Ux64 x (Const64 <t> [int64(uint16(c))])) 20931 for { 20932 t := v.Type 20933 _ = v.Args[1] 20934 x := v.Args[0] 20935 v_1 := v.Args[1] 20936 if v_1.Op != OpConst16 { 20937 break 20938 } 20939 c := v_1.AuxInt 20940 v.reset(OpRsh8Ux64) 20941 v.AddArg(x) 20942 v0 := b.NewValue0(v.Pos, OpConst64, t) 20943 v0.AuxInt = int64(uint16(c)) 20944 v.AddArg(v0) 20945 return true 20946 } 20947 // match: (Rsh8Ux16 (Const8 [0]) _) 20948 // cond: 20949 // result: (Const8 [0]) 20950 for { 20951 _ = v.Args[1] 20952 v_0 := v.Args[0] 20953 if v_0.Op != OpConst8 { 20954 break 20955 } 20956 if v_0.AuxInt != 0 { 20957 break 20958 } 20959 v.reset(OpConst8) 20960 v.AuxInt = 0 20961 return true 20962 } 20963 return false 20964 } 20965 func rewriteValuegeneric_OpRsh8Ux32_0(v *Value) bool { 20966 b := v.Block 20967 _ = b 20968 // match: (Rsh8Ux32 <t> x (Const32 [c])) 20969 // cond: 20970 // result: (Rsh8Ux64 x (Const64 <t> [int64(uint32(c))])) 20971 for { 20972 t := v.Type 20973 _ = v.Args[1] 20974 x := v.Args[0] 20975 v_1 := v.Args[1] 20976 if v_1.Op != OpConst32 { 20977 break 20978 } 20979 c := v_1.AuxInt 20980 v.reset(OpRsh8Ux64) 20981 v.AddArg(x) 20982 v0 := b.NewValue0(v.Pos, OpConst64, t) 20983 v0.AuxInt = int64(uint32(c)) 20984 v.AddArg(v0) 20985 return true 20986 } 20987 // match: (Rsh8Ux32 (Const8 [0]) _) 20988 // cond: 20989 // result: (Const8 [0]) 20990 for { 20991 _ = v.Args[1] 20992 v_0 := v.Args[0] 20993 if v_0.Op != OpConst8 { 20994 break 20995 } 20996 if v_0.AuxInt != 0 { 20997 break 20998 } 20999 v.reset(OpConst8) 21000 v.AuxInt = 0 21001 return true 21002 } 21003 return false 21004 } 21005 func rewriteValuegeneric_OpRsh8Ux64_0(v *Value) bool { 21006 b := v.Block 21007 _ = b 21008 typ := &b.Func.Config.Types 21009 _ = typ 21010 // match: (Rsh8Ux64 (Const8 [c]) (Const64 [d])) 21011 // cond: 21012 // result: (Const8 [int64(int8(uint8(c) >> uint64(d)))]) 21013 for { 21014 _ = v.Args[1] 21015 v_0 := v.Args[0] 21016 if v_0.Op != OpConst8 { 21017 break 21018 } 21019 c := v_0.AuxInt 21020 v_1 := v.Args[1] 21021 if v_1.Op != OpConst64 { 21022 break 21023 } 21024 d := v_1.AuxInt 21025 v.reset(OpConst8) 21026 v.AuxInt = int64(int8(uint8(c) >> uint64(d))) 21027 return true 21028 } 21029 // match: (Rsh8Ux64 x (Const64 [0])) 21030 // cond: 21031 // result: x 21032 for { 21033 _ = v.Args[1] 21034 x := v.Args[0] 21035 v_1 := v.Args[1] 21036 if v_1.Op != OpConst64 { 21037 break 21038 } 21039 if v_1.AuxInt != 0 { 21040 break 21041 } 21042 v.reset(OpCopy) 21043 v.Type = x.Type 21044 v.AddArg(x) 21045 return true 21046 } 21047 // match: (Rsh8Ux64 (Const8 [0]) _) 21048 // cond: 21049 // result: (Const8 [0]) 21050 for { 21051 _ = v.Args[1] 21052 v_0 := v.Args[0] 21053 if v_0.Op != OpConst8 { 21054 break 21055 } 21056 if v_0.AuxInt != 0 { 21057 break 21058 } 21059 v.reset(OpConst8) 21060 v.AuxInt = 0 21061 return true 21062 } 21063 // match: (Rsh8Ux64 _ (Const64 [c])) 21064 // cond: uint64(c) >= 8 21065 // result: (Const8 [0]) 21066 for { 21067 _ = v.Args[1] 21068 v_1 := v.Args[1] 21069 if v_1.Op != OpConst64 { 21070 break 21071 } 21072 c := v_1.AuxInt 21073 if !(uint64(c) >= 8) { 21074 break 21075 } 21076 v.reset(OpConst8) 21077 v.AuxInt = 0 21078 return true 21079 } 21080 // match: (Rsh8Ux64 <t> (Rsh8Ux64 x (Const64 [c])) (Const64 [d])) 21081 // cond: !uaddOvf(c,d) 21082 // result: (Rsh8Ux64 x (Const64 <t> [c+d])) 21083 for { 21084 t := v.Type 21085 _ = v.Args[1] 21086 v_0 := v.Args[0] 21087 if v_0.Op != OpRsh8Ux64 { 21088 break 21089 } 21090 _ = v_0.Args[1] 21091 x := v_0.Args[0] 21092 v_0_1 := v_0.Args[1] 21093 if v_0_1.Op != OpConst64 { 21094 break 21095 } 21096 c := v_0_1.AuxInt 21097 v_1 := v.Args[1] 21098 if v_1.Op != OpConst64 { 21099 break 21100 } 21101 d := v_1.AuxInt 21102 if !(!uaddOvf(c, d)) { 21103 break 21104 } 21105 v.reset(OpRsh8Ux64) 21106 v.AddArg(x) 21107 v0 := b.NewValue0(v.Pos, OpConst64, t) 21108 v0.AuxInt = c + d 21109 v.AddArg(v0) 21110 return true 21111 } 21112 // match: (Rsh8Ux64 (Lsh8x64 (Rsh8Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) 21113 // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) 21114 // result: (Rsh8Ux64 x (Const64 <typ.UInt64> [c1-c2+c3])) 21115 for { 21116 _ = v.Args[1] 21117 v_0 := v.Args[0] 21118 if v_0.Op != OpLsh8x64 { 21119 break 21120 } 21121 _ = v_0.Args[1] 21122 v_0_0 := v_0.Args[0] 21123 if v_0_0.Op != OpRsh8Ux64 { 21124 break 21125 } 21126 _ = v_0_0.Args[1] 21127 x := v_0_0.Args[0] 21128 v_0_0_1 := v_0_0.Args[1] 21129 if v_0_0_1.Op != OpConst64 { 21130 break 21131 } 21132 c1 := v_0_0_1.AuxInt 21133 v_0_1 := v_0.Args[1] 21134 if v_0_1.Op != OpConst64 { 21135 break 21136 } 21137 c2 := v_0_1.AuxInt 21138 v_1 := v.Args[1] 21139 if v_1.Op != OpConst64 { 21140 break 21141 } 21142 c3 := v_1.AuxInt 21143 if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { 21144 break 21145 } 21146 v.reset(OpRsh8Ux64) 21147 v.AddArg(x) 21148 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 21149 v0.AuxInt = c1 - c2 + c3 21150 v.AddArg(v0) 21151 return true 21152 } 21153 return false 21154 } 21155 func rewriteValuegeneric_OpRsh8Ux8_0(v *Value) bool { 21156 b := v.Block 21157 _ = b 21158 // match: (Rsh8Ux8 <t> x (Const8 [c])) 21159 // cond: 21160 // result: (Rsh8Ux64 x (Const64 <t> [int64(uint8(c))])) 21161 for { 21162 t := v.Type 21163 _ = v.Args[1] 21164 x := v.Args[0] 21165 v_1 := v.Args[1] 21166 if v_1.Op != OpConst8 { 21167 break 21168 } 21169 c := v_1.AuxInt 21170 v.reset(OpRsh8Ux64) 21171 v.AddArg(x) 21172 v0 := b.NewValue0(v.Pos, OpConst64, t) 21173 v0.AuxInt = int64(uint8(c)) 21174 v.AddArg(v0) 21175 return true 21176 } 21177 // match: (Rsh8Ux8 (Const8 [0]) _) 21178 // cond: 21179 // result: (Const8 [0]) 21180 for { 21181 _ = v.Args[1] 21182 v_0 := v.Args[0] 21183 if v_0.Op != OpConst8 { 21184 break 21185 } 21186 if v_0.AuxInt != 0 { 21187 break 21188 } 21189 v.reset(OpConst8) 21190 v.AuxInt = 0 21191 return true 21192 } 21193 return false 21194 } 21195 func rewriteValuegeneric_OpRsh8x16_0(v *Value) bool { 21196 b := v.Block 21197 _ = b 21198 // match: (Rsh8x16 <t> x (Const16 [c])) 21199 // cond: 21200 // result: (Rsh8x64 x (Const64 <t> [int64(uint16(c))])) 21201 for { 21202 t := v.Type 21203 _ = v.Args[1] 21204 x := v.Args[0] 21205 v_1 := v.Args[1] 21206 if v_1.Op != OpConst16 { 21207 break 21208 } 21209 c := v_1.AuxInt 21210 v.reset(OpRsh8x64) 21211 v.AddArg(x) 21212 v0 := b.NewValue0(v.Pos, OpConst64, t) 21213 v0.AuxInt = int64(uint16(c)) 21214 v.AddArg(v0) 21215 return true 21216 } 21217 // match: (Rsh8x16 (Const8 [0]) _) 21218 // cond: 21219 // result: (Const8 [0]) 21220 for { 21221 _ = v.Args[1] 21222 v_0 := v.Args[0] 21223 if v_0.Op != OpConst8 { 21224 break 21225 } 21226 if v_0.AuxInt != 0 { 21227 break 21228 } 21229 v.reset(OpConst8) 21230 v.AuxInt = 0 21231 return true 21232 } 21233 return false 21234 } 21235 func rewriteValuegeneric_OpRsh8x32_0(v *Value) bool { 21236 b := v.Block 21237 _ = b 21238 // match: (Rsh8x32 <t> x (Const32 [c])) 21239 // cond: 21240 // result: (Rsh8x64 x (Const64 <t> [int64(uint32(c))])) 21241 for { 21242 t := v.Type 21243 _ = v.Args[1] 21244 x := v.Args[0] 21245 v_1 := v.Args[1] 21246 if v_1.Op != OpConst32 { 21247 break 21248 } 21249 c := v_1.AuxInt 21250 v.reset(OpRsh8x64) 21251 v.AddArg(x) 21252 v0 := b.NewValue0(v.Pos, OpConst64, t) 21253 v0.AuxInt = int64(uint32(c)) 21254 v.AddArg(v0) 21255 return true 21256 } 21257 // match: (Rsh8x32 (Const8 [0]) _) 21258 // cond: 21259 // result: (Const8 [0]) 21260 for { 21261 _ = v.Args[1] 21262 v_0 := v.Args[0] 21263 if v_0.Op != OpConst8 { 21264 break 21265 } 21266 if v_0.AuxInt != 0 { 21267 break 21268 } 21269 v.reset(OpConst8) 21270 v.AuxInt = 0 21271 return true 21272 } 21273 return false 21274 } 21275 func rewriteValuegeneric_OpRsh8x64_0(v *Value) bool { 21276 b := v.Block 21277 _ = b 21278 // match: (Rsh8x64 (Const8 [c]) (Const64 [d])) 21279 // cond: 21280 // result: (Const8 [int64(int8(c) >> uint64(d))]) 21281 for { 21282 _ = v.Args[1] 21283 v_0 := v.Args[0] 21284 if v_0.Op != OpConst8 { 21285 break 21286 } 21287 c := v_0.AuxInt 21288 v_1 := v.Args[1] 21289 if v_1.Op != OpConst64 { 21290 break 21291 } 21292 d := v_1.AuxInt 21293 v.reset(OpConst8) 21294 v.AuxInt = int64(int8(c) >> uint64(d)) 21295 return true 21296 } 21297 // match: (Rsh8x64 x (Const64 [0])) 21298 // cond: 21299 // result: x 21300 for { 21301 _ = v.Args[1] 21302 x := v.Args[0] 21303 v_1 := v.Args[1] 21304 if v_1.Op != OpConst64 { 21305 break 21306 } 21307 if v_1.AuxInt != 0 { 21308 break 21309 } 21310 v.reset(OpCopy) 21311 v.Type = x.Type 21312 v.AddArg(x) 21313 return true 21314 } 21315 // match: (Rsh8x64 (Const8 [0]) _) 21316 // cond: 21317 // result: (Const8 [0]) 21318 for { 21319 _ = v.Args[1] 21320 v_0 := v.Args[0] 21321 if v_0.Op != OpConst8 { 21322 break 21323 } 21324 if v_0.AuxInt != 0 { 21325 break 21326 } 21327 v.reset(OpConst8) 21328 v.AuxInt = 0 21329 return true 21330 } 21331 // match: (Rsh8x64 <t> (Rsh8x64 x (Const64 [c])) (Const64 [d])) 21332 // cond: !uaddOvf(c,d) 21333 // result: (Rsh8x64 x (Const64 <t> [c+d])) 21334 for { 21335 t := v.Type 21336 _ = v.Args[1] 21337 v_0 := v.Args[0] 21338 if v_0.Op != OpRsh8x64 { 21339 break 21340 } 21341 _ = v_0.Args[1] 21342 x := v_0.Args[0] 21343 v_0_1 := v_0.Args[1] 21344 if v_0_1.Op != OpConst64 { 21345 break 21346 } 21347 c := v_0_1.AuxInt 21348 v_1 := v.Args[1] 21349 if v_1.Op != OpConst64 { 21350 break 21351 } 21352 d := v_1.AuxInt 21353 if !(!uaddOvf(c, d)) { 21354 break 21355 } 21356 v.reset(OpRsh8x64) 21357 v.AddArg(x) 21358 v0 := b.NewValue0(v.Pos, OpConst64, t) 21359 v0.AuxInt = c + d 21360 v.AddArg(v0) 21361 return true 21362 } 21363 return false 21364 } 21365 func rewriteValuegeneric_OpRsh8x8_0(v *Value) bool { 21366 b := v.Block 21367 _ = b 21368 // match: (Rsh8x8 <t> x (Const8 [c])) 21369 // cond: 21370 // result: (Rsh8x64 x (Const64 <t> [int64(uint8(c))])) 21371 for { 21372 t := v.Type 21373 _ = v.Args[1] 21374 x := v.Args[0] 21375 v_1 := v.Args[1] 21376 if v_1.Op != OpConst8 { 21377 break 21378 } 21379 c := v_1.AuxInt 21380 v.reset(OpRsh8x64) 21381 v.AddArg(x) 21382 v0 := b.NewValue0(v.Pos, OpConst64, t) 21383 v0.AuxInt = int64(uint8(c)) 21384 v.AddArg(v0) 21385 return true 21386 } 21387 // match: (Rsh8x8 (Const8 [0]) _) 21388 // cond: 21389 // result: (Const8 [0]) 21390 for { 21391 _ = v.Args[1] 21392 v_0 := v.Args[0] 21393 if v_0.Op != OpConst8 { 21394 break 21395 } 21396 if v_0.AuxInt != 0 { 21397 break 21398 } 21399 v.reset(OpConst8) 21400 v.AuxInt = 0 21401 return true 21402 } 21403 return false 21404 } 21405 func rewriteValuegeneric_OpSignExt16to32_0(v *Value) bool { 21406 // match: (SignExt16to32 (Const16 [c])) 21407 // cond: 21408 // result: (Const32 [int64( int16(c))]) 21409 for { 21410 v_0 := v.Args[0] 21411 if v_0.Op != OpConst16 { 21412 break 21413 } 21414 c := v_0.AuxInt 21415 v.reset(OpConst32) 21416 v.AuxInt = int64(int16(c)) 21417 return true 21418 } 21419 // match: (SignExt16to32 (Trunc32to16 x:(Rsh32x64 _ (Const64 [s])))) 21420 // cond: s >= 16 21421 // result: x 21422 for { 21423 v_0 := v.Args[0] 21424 if v_0.Op != OpTrunc32to16 { 21425 break 21426 } 21427 x := v_0.Args[0] 21428 if x.Op != OpRsh32x64 { 21429 break 21430 } 21431 _ = x.Args[1] 21432 x_1 := x.Args[1] 21433 if x_1.Op != OpConst64 { 21434 break 21435 } 21436 s := x_1.AuxInt 21437 if !(s >= 16) { 21438 break 21439 } 21440 v.reset(OpCopy) 21441 v.Type = x.Type 21442 v.AddArg(x) 21443 return true 21444 } 21445 return false 21446 } 21447 func rewriteValuegeneric_OpSignExt16to64_0(v *Value) bool { 21448 // match: (SignExt16to64 (Const16 [c])) 21449 // cond: 21450 // result: (Const64 [int64( int16(c))]) 21451 for { 21452 v_0 := v.Args[0] 21453 if v_0.Op != OpConst16 { 21454 break 21455 } 21456 c := v_0.AuxInt 21457 v.reset(OpConst64) 21458 v.AuxInt = int64(int16(c)) 21459 return true 21460 } 21461 // match: (SignExt16to64 (Trunc64to16 x:(Rsh64x64 _ (Const64 [s])))) 21462 // cond: s >= 48 21463 // result: x 21464 for { 21465 v_0 := v.Args[0] 21466 if v_0.Op != OpTrunc64to16 { 21467 break 21468 } 21469 x := v_0.Args[0] 21470 if x.Op != OpRsh64x64 { 21471 break 21472 } 21473 _ = x.Args[1] 21474 x_1 := x.Args[1] 21475 if x_1.Op != OpConst64 { 21476 break 21477 } 21478 s := x_1.AuxInt 21479 if !(s >= 48) { 21480 break 21481 } 21482 v.reset(OpCopy) 21483 v.Type = x.Type 21484 v.AddArg(x) 21485 return true 21486 } 21487 return false 21488 } 21489 func rewriteValuegeneric_OpSignExt32to64_0(v *Value) bool { 21490 // match: (SignExt32to64 (Const32 [c])) 21491 // cond: 21492 // result: (Const64 [int64( int32(c))]) 21493 for { 21494 v_0 := v.Args[0] 21495 if v_0.Op != OpConst32 { 21496 break 21497 } 21498 c := v_0.AuxInt 21499 v.reset(OpConst64) 21500 v.AuxInt = int64(int32(c)) 21501 return true 21502 } 21503 // match: (SignExt32to64 (Trunc64to32 x:(Rsh64x64 _ (Const64 [s])))) 21504 // cond: s >= 32 21505 // result: x 21506 for { 21507 v_0 := v.Args[0] 21508 if v_0.Op != OpTrunc64to32 { 21509 break 21510 } 21511 x := v_0.Args[0] 21512 if x.Op != OpRsh64x64 { 21513 break 21514 } 21515 _ = x.Args[1] 21516 x_1 := x.Args[1] 21517 if x_1.Op != OpConst64 { 21518 break 21519 } 21520 s := x_1.AuxInt 21521 if !(s >= 32) { 21522 break 21523 } 21524 v.reset(OpCopy) 21525 v.Type = x.Type 21526 v.AddArg(x) 21527 return true 21528 } 21529 return false 21530 } 21531 func rewriteValuegeneric_OpSignExt8to16_0(v *Value) bool { 21532 // match: (SignExt8to16 (Const8 [c])) 21533 // cond: 21534 // result: (Const16 [int64( int8(c))]) 21535 for { 21536 v_0 := v.Args[0] 21537 if v_0.Op != OpConst8 { 21538 break 21539 } 21540 c := v_0.AuxInt 21541 v.reset(OpConst16) 21542 v.AuxInt = int64(int8(c)) 21543 return true 21544 } 21545 // match: (SignExt8to16 (Trunc16to8 x:(Rsh16x64 _ (Const64 [s])))) 21546 // cond: s >= 8 21547 // result: x 21548 for { 21549 v_0 := v.Args[0] 21550 if v_0.Op != OpTrunc16to8 { 21551 break 21552 } 21553 x := v_0.Args[0] 21554 if x.Op != OpRsh16x64 { 21555 break 21556 } 21557 _ = x.Args[1] 21558 x_1 := x.Args[1] 21559 if x_1.Op != OpConst64 { 21560 break 21561 } 21562 s := x_1.AuxInt 21563 if !(s >= 8) { 21564 break 21565 } 21566 v.reset(OpCopy) 21567 v.Type = x.Type 21568 v.AddArg(x) 21569 return true 21570 } 21571 return false 21572 } 21573 func rewriteValuegeneric_OpSignExt8to32_0(v *Value) bool { 21574 // match: (SignExt8to32 (Const8 [c])) 21575 // cond: 21576 // result: (Const32 [int64( int8(c))]) 21577 for { 21578 v_0 := v.Args[0] 21579 if v_0.Op != OpConst8 { 21580 break 21581 } 21582 c := v_0.AuxInt 21583 v.reset(OpConst32) 21584 v.AuxInt = int64(int8(c)) 21585 return true 21586 } 21587 // match: (SignExt8to32 (Trunc32to8 x:(Rsh32x64 _ (Const64 [s])))) 21588 // cond: s >= 24 21589 // result: x 21590 for { 21591 v_0 := v.Args[0] 21592 if v_0.Op != OpTrunc32to8 { 21593 break 21594 } 21595 x := v_0.Args[0] 21596 if x.Op != OpRsh32x64 { 21597 break 21598 } 21599 _ = x.Args[1] 21600 x_1 := x.Args[1] 21601 if x_1.Op != OpConst64 { 21602 break 21603 } 21604 s := x_1.AuxInt 21605 if !(s >= 24) { 21606 break 21607 } 21608 v.reset(OpCopy) 21609 v.Type = x.Type 21610 v.AddArg(x) 21611 return true 21612 } 21613 return false 21614 } 21615 func rewriteValuegeneric_OpSignExt8to64_0(v *Value) bool { 21616 // match: (SignExt8to64 (Const8 [c])) 21617 // cond: 21618 // result: (Const64 [int64( int8(c))]) 21619 for { 21620 v_0 := v.Args[0] 21621 if v_0.Op != OpConst8 { 21622 break 21623 } 21624 c := v_0.AuxInt 21625 v.reset(OpConst64) 21626 v.AuxInt = int64(int8(c)) 21627 return true 21628 } 21629 // match: (SignExt8to64 (Trunc64to8 x:(Rsh64x64 _ (Const64 [s])))) 21630 // cond: s >= 56 21631 // result: x 21632 for { 21633 v_0 := v.Args[0] 21634 if v_0.Op != OpTrunc64to8 { 21635 break 21636 } 21637 x := v_0.Args[0] 21638 if x.Op != OpRsh64x64 { 21639 break 21640 } 21641 _ = x.Args[1] 21642 x_1 := x.Args[1] 21643 if x_1.Op != OpConst64 { 21644 break 21645 } 21646 s := x_1.AuxInt 21647 if !(s >= 56) { 21648 break 21649 } 21650 v.reset(OpCopy) 21651 v.Type = x.Type 21652 v.AddArg(x) 21653 return true 21654 } 21655 return false 21656 } 21657 func rewriteValuegeneric_OpSliceCap_0(v *Value) bool { 21658 // match: (SliceCap (SliceMake _ _ (Const64 <t> [c]))) 21659 // cond: 21660 // result: (Const64 <t> [c]) 21661 for { 21662 v_0 := v.Args[0] 21663 if v_0.Op != OpSliceMake { 21664 break 21665 } 21666 _ = v_0.Args[2] 21667 v_0_2 := v_0.Args[2] 21668 if v_0_2.Op != OpConst64 { 21669 break 21670 } 21671 t := v_0_2.Type 21672 c := v_0_2.AuxInt 21673 v.reset(OpConst64) 21674 v.Type = t 21675 v.AuxInt = c 21676 return true 21677 } 21678 // match: (SliceCap (SliceMake _ _ (Const32 <t> [c]))) 21679 // cond: 21680 // result: (Const32 <t> [c]) 21681 for { 21682 v_0 := v.Args[0] 21683 if v_0.Op != OpSliceMake { 21684 break 21685 } 21686 _ = v_0.Args[2] 21687 v_0_2 := v_0.Args[2] 21688 if v_0_2.Op != OpConst32 { 21689 break 21690 } 21691 t := v_0_2.Type 21692 c := v_0_2.AuxInt 21693 v.reset(OpConst32) 21694 v.Type = t 21695 v.AuxInt = c 21696 return true 21697 } 21698 // match: (SliceCap (SliceMake _ _ (SliceCap x))) 21699 // cond: 21700 // result: (SliceCap x) 21701 for { 21702 v_0 := v.Args[0] 21703 if v_0.Op != OpSliceMake { 21704 break 21705 } 21706 _ = v_0.Args[2] 21707 v_0_2 := v_0.Args[2] 21708 if v_0_2.Op != OpSliceCap { 21709 break 21710 } 21711 x := v_0_2.Args[0] 21712 v.reset(OpSliceCap) 21713 v.AddArg(x) 21714 return true 21715 } 21716 // match: (SliceCap (SliceMake _ _ (SliceLen x))) 21717 // cond: 21718 // result: (SliceLen x) 21719 for { 21720 v_0 := v.Args[0] 21721 if v_0.Op != OpSliceMake { 21722 break 21723 } 21724 _ = v_0.Args[2] 21725 v_0_2 := v_0.Args[2] 21726 if v_0_2.Op != OpSliceLen { 21727 break 21728 } 21729 x := v_0_2.Args[0] 21730 v.reset(OpSliceLen) 21731 v.AddArg(x) 21732 return true 21733 } 21734 return false 21735 } 21736 func rewriteValuegeneric_OpSliceLen_0(v *Value) bool { 21737 // match: (SliceLen (SliceMake _ (Const64 <t> [c]) _)) 21738 // cond: 21739 // result: (Const64 <t> [c]) 21740 for { 21741 v_0 := v.Args[0] 21742 if v_0.Op != OpSliceMake { 21743 break 21744 } 21745 _ = v_0.Args[2] 21746 v_0_1 := v_0.Args[1] 21747 if v_0_1.Op != OpConst64 { 21748 break 21749 } 21750 t := v_0_1.Type 21751 c := v_0_1.AuxInt 21752 v.reset(OpConst64) 21753 v.Type = t 21754 v.AuxInt = c 21755 return true 21756 } 21757 // match: (SliceLen (SliceMake _ (Const32 <t> [c]) _)) 21758 // cond: 21759 // result: (Const32 <t> [c]) 21760 for { 21761 v_0 := v.Args[0] 21762 if v_0.Op != OpSliceMake { 21763 break 21764 } 21765 _ = v_0.Args[2] 21766 v_0_1 := v_0.Args[1] 21767 if v_0_1.Op != OpConst32 { 21768 break 21769 } 21770 t := v_0_1.Type 21771 c := v_0_1.AuxInt 21772 v.reset(OpConst32) 21773 v.Type = t 21774 v.AuxInt = c 21775 return true 21776 } 21777 // match: (SliceLen (SliceMake _ (SliceLen x) _)) 21778 // cond: 21779 // result: (SliceLen x) 21780 for { 21781 v_0 := v.Args[0] 21782 if v_0.Op != OpSliceMake { 21783 break 21784 } 21785 _ = v_0.Args[2] 21786 v_0_1 := v_0.Args[1] 21787 if v_0_1.Op != OpSliceLen { 21788 break 21789 } 21790 x := v_0_1.Args[0] 21791 v.reset(OpSliceLen) 21792 v.AddArg(x) 21793 return true 21794 } 21795 return false 21796 } 21797 func rewriteValuegeneric_OpSlicePtr_0(v *Value) bool { 21798 // match: (SlicePtr (SliceMake (SlicePtr x) _ _)) 21799 // cond: 21800 // result: (SlicePtr x) 21801 for { 21802 v_0 := v.Args[0] 21803 if v_0.Op != OpSliceMake { 21804 break 21805 } 21806 _ = v_0.Args[2] 21807 v_0_0 := v_0.Args[0] 21808 if v_0_0.Op != OpSlicePtr { 21809 break 21810 } 21811 x := v_0_0.Args[0] 21812 v.reset(OpSlicePtr) 21813 v.AddArg(x) 21814 return true 21815 } 21816 return false 21817 } 21818 func rewriteValuegeneric_OpSlicemask_0(v *Value) bool { 21819 // match: (Slicemask (Const32 [x])) 21820 // cond: x > 0 21821 // result: (Const32 [-1]) 21822 for { 21823 v_0 := v.Args[0] 21824 if v_0.Op != OpConst32 { 21825 break 21826 } 21827 x := v_0.AuxInt 21828 if !(x > 0) { 21829 break 21830 } 21831 v.reset(OpConst32) 21832 v.AuxInt = -1 21833 return true 21834 } 21835 // match: (Slicemask (Const32 [0])) 21836 // cond: 21837 // result: (Const32 [0]) 21838 for { 21839 v_0 := v.Args[0] 21840 if v_0.Op != OpConst32 { 21841 break 21842 } 21843 if v_0.AuxInt != 0 { 21844 break 21845 } 21846 v.reset(OpConst32) 21847 v.AuxInt = 0 21848 return true 21849 } 21850 // match: (Slicemask (Const64 [x])) 21851 // cond: x > 0 21852 // result: (Const64 [-1]) 21853 for { 21854 v_0 := v.Args[0] 21855 if v_0.Op != OpConst64 { 21856 break 21857 } 21858 x := v_0.AuxInt 21859 if !(x > 0) { 21860 break 21861 } 21862 v.reset(OpConst64) 21863 v.AuxInt = -1 21864 return true 21865 } 21866 // match: (Slicemask (Const64 [0])) 21867 // cond: 21868 // result: (Const64 [0]) 21869 for { 21870 v_0 := v.Args[0] 21871 if v_0.Op != OpConst64 { 21872 break 21873 } 21874 if v_0.AuxInt != 0 { 21875 break 21876 } 21877 v.reset(OpConst64) 21878 v.AuxInt = 0 21879 return true 21880 } 21881 return false 21882 } 21883 func rewriteValuegeneric_OpSqrt_0(v *Value) bool { 21884 // match: (Sqrt (Const64F [c])) 21885 // cond: 21886 // result: (Const64F [f2i(math.Sqrt(i2f(c)))]) 21887 for { 21888 v_0 := v.Args[0] 21889 if v_0.Op != OpConst64F { 21890 break 21891 } 21892 c := v_0.AuxInt 21893 v.reset(OpConst64F) 21894 v.AuxInt = f2i(math.Sqrt(i2f(c))) 21895 return true 21896 } 21897 return false 21898 } 21899 func rewriteValuegeneric_OpStore_0(v *Value) bool { 21900 b := v.Block 21901 _ = b 21902 fe := b.Func.fe 21903 _ = fe 21904 // match: (Store {t1} p1 (Load <t2> p2 mem) mem) 21905 // cond: isSamePtr(p1, p2) && t2.Size() == t1.(*types.Type).Size() 21906 // result: mem 21907 for { 21908 t1 := v.Aux 21909 _ = v.Args[2] 21910 p1 := v.Args[0] 21911 v_1 := v.Args[1] 21912 if v_1.Op != OpLoad { 21913 break 21914 } 21915 t2 := v_1.Type 21916 _ = v_1.Args[1] 21917 p2 := v_1.Args[0] 21918 mem := v_1.Args[1] 21919 if mem != v.Args[2] { 21920 break 21921 } 21922 if !(isSamePtr(p1, p2) && t2.Size() == t1.(*types.Type).Size()) { 21923 break 21924 } 21925 v.reset(OpCopy) 21926 v.Type = mem.Type 21927 v.AddArg(mem) 21928 return true 21929 } 21930 // match: (Store {t1} (OffPtr [o1] p1) (Load <t2> (OffPtr [o1] p2) oldmem) mem:(Store {t3} (OffPtr [o3] p3) _ oldmem)) 21931 // cond: isSamePtr(p1, p2) && isSamePtr(p1, p3) && t2.Size() == t1.(*types.Type).Size() && !overlap(o1, t2.Size(), o3, t3.(*types.Type).Size()) 21932 // result: mem 21933 for { 21934 t1 := v.Aux 21935 _ = v.Args[2] 21936 v_0 := v.Args[0] 21937 if v_0.Op != OpOffPtr { 21938 break 21939 } 21940 o1 := v_0.AuxInt 21941 p1 := v_0.Args[0] 21942 v_1 := v.Args[1] 21943 if v_1.Op != OpLoad { 21944 break 21945 } 21946 t2 := v_1.Type 21947 _ = v_1.Args[1] 21948 v_1_0 := v_1.Args[0] 21949 if v_1_0.Op != OpOffPtr { 21950 break 21951 } 21952 if v_1_0.AuxInt != o1 { 21953 break 21954 } 21955 p2 := v_1_0.Args[0] 21956 oldmem := v_1.Args[1] 21957 mem := v.Args[2] 21958 if mem.Op != OpStore { 21959 break 21960 } 21961 t3 := mem.Aux 21962 _ = mem.Args[2] 21963 mem_0 := mem.Args[0] 21964 if mem_0.Op != OpOffPtr { 21965 break 21966 } 21967 o3 := mem_0.AuxInt 21968 p3 := mem_0.Args[0] 21969 if oldmem != mem.Args[2] { 21970 break 21971 } 21972 if !(isSamePtr(p1, p2) && isSamePtr(p1, p3) && t2.Size() == t1.(*types.Type).Size() && !overlap(o1, t2.Size(), o3, t3.(*types.Type).Size())) { 21973 break 21974 } 21975 v.reset(OpCopy) 21976 v.Type = mem.Type 21977 v.AddArg(mem) 21978 return true 21979 } 21980 // match: (Store {t1} (OffPtr [o1] p1) (Load <t2> (OffPtr [o1] p2) oldmem) mem:(Store {t3} (OffPtr [o3] p3) _ (Store {t4} (OffPtr [o4] p4) _ oldmem))) 21981 // cond: isSamePtr(p1, p2) && isSamePtr(p1, p3) && isSamePtr(p1, p4) && t2.Size() == t1.(*types.Type).Size() && !overlap(o1, t2.Size(), o3, t3.(*types.Type).Size()) && !overlap(o1, t2.Size(), o4, t4.(*types.Type).Size()) 21982 // result: mem 21983 for { 21984 t1 := v.Aux 21985 _ = v.Args[2] 21986 v_0 := v.Args[0] 21987 if v_0.Op != OpOffPtr { 21988 break 21989 } 21990 o1 := v_0.AuxInt 21991 p1 := v_0.Args[0] 21992 v_1 := v.Args[1] 21993 if v_1.Op != OpLoad { 21994 break 21995 } 21996 t2 := v_1.Type 21997 _ = v_1.Args[1] 21998 v_1_0 := v_1.Args[0] 21999 if v_1_0.Op != OpOffPtr { 22000 break 22001 } 22002 if v_1_0.AuxInt != o1 { 22003 break 22004 } 22005 p2 := v_1_0.Args[0] 22006 oldmem := v_1.Args[1] 22007 mem := v.Args[2] 22008 if mem.Op != OpStore { 22009 break 22010 } 22011 t3 := mem.Aux 22012 _ = mem.Args[2] 22013 mem_0 := mem.Args[0] 22014 if mem_0.Op != OpOffPtr { 22015 break 22016 } 22017 o3 := mem_0.AuxInt 22018 p3 := mem_0.Args[0] 22019 mem_2 := mem.Args[2] 22020 if mem_2.Op != OpStore { 22021 break 22022 } 22023 t4 := mem_2.Aux 22024 _ = mem_2.Args[2] 22025 mem_2_0 := mem_2.Args[0] 22026 if mem_2_0.Op != OpOffPtr { 22027 break 22028 } 22029 o4 := mem_2_0.AuxInt 22030 p4 := mem_2_0.Args[0] 22031 if oldmem != mem_2.Args[2] { 22032 break 22033 } 22034 if !(isSamePtr(p1, p2) && isSamePtr(p1, p3) && isSamePtr(p1, p4) && t2.Size() == t1.(*types.Type).Size() && !overlap(o1, t2.Size(), o3, t3.(*types.Type).Size()) && !overlap(o1, t2.Size(), o4, t4.(*types.Type).Size())) { 22035 break 22036 } 22037 v.reset(OpCopy) 22038 v.Type = mem.Type 22039 v.AddArg(mem) 22040 return true 22041 } 22042 // match: (Store {t1} (OffPtr [o1] p1) (Load <t2> (OffPtr [o1] p2) oldmem) mem:(Store {t3} (OffPtr [o3] p3) _ (Store {t4} (OffPtr [o4] p4) _ (Store {t5} (OffPtr [o5] p5) _ oldmem)))) 22043 // cond: isSamePtr(p1, p2) && isSamePtr(p1, p3) && isSamePtr(p1, p4) && isSamePtr(p1, p5) && t2.Size() == t1.(*types.Type).Size() && !overlap(o1, t2.Size(), o3, t3.(*types.Type).Size()) && !overlap(o1, t2.Size(), o4, t4.(*types.Type).Size()) && !overlap(o1, t2.Size(), o5, t5.(*types.Type).Size()) 22044 // result: mem 22045 for { 22046 t1 := v.Aux 22047 _ = v.Args[2] 22048 v_0 := v.Args[0] 22049 if v_0.Op != OpOffPtr { 22050 break 22051 } 22052 o1 := v_0.AuxInt 22053 p1 := v_0.Args[0] 22054 v_1 := v.Args[1] 22055 if v_1.Op != OpLoad { 22056 break 22057 } 22058 t2 := v_1.Type 22059 _ = v_1.Args[1] 22060 v_1_0 := v_1.Args[0] 22061 if v_1_0.Op != OpOffPtr { 22062 break 22063 } 22064 if v_1_0.AuxInt != o1 { 22065 break 22066 } 22067 p2 := v_1_0.Args[0] 22068 oldmem := v_1.Args[1] 22069 mem := v.Args[2] 22070 if mem.Op != OpStore { 22071 break 22072 } 22073 t3 := mem.Aux 22074 _ = mem.Args[2] 22075 mem_0 := mem.Args[0] 22076 if mem_0.Op != OpOffPtr { 22077 break 22078 } 22079 o3 := mem_0.AuxInt 22080 p3 := mem_0.Args[0] 22081 mem_2 := mem.Args[2] 22082 if mem_2.Op != OpStore { 22083 break 22084 } 22085 t4 := mem_2.Aux 22086 _ = mem_2.Args[2] 22087 mem_2_0 := mem_2.Args[0] 22088 if mem_2_0.Op != OpOffPtr { 22089 break 22090 } 22091 o4 := mem_2_0.AuxInt 22092 p4 := mem_2_0.Args[0] 22093 mem_2_2 := mem_2.Args[2] 22094 if mem_2_2.Op != OpStore { 22095 break 22096 } 22097 t5 := mem_2_2.Aux 22098 _ = mem_2_2.Args[2] 22099 mem_2_2_0 := mem_2_2.Args[0] 22100 if mem_2_2_0.Op != OpOffPtr { 22101 break 22102 } 22103 o5 := mem_2_2_0.AuxInt 22104 p5 := mem_2_2_0.Args[0] 22105 if oldmem != mem_2_2.Args[2] { 22106 break 22107 } 22108 if !(isSamePtr(p1, p2) && isSamePtr(p1, p3) && isSamePtr(p1, p4) && isSamePtr(p1, p5) && t2.Size() == t1.(*types.Type).Size() && !overlap(o1, t2.Size(), o3, t3.(*types.Type).Size()) && !overlap(o1, t2.Size(), o4, t4.(*types.Type).Size()) && !overlap(o1, t2.Size(), o5, t5.(*types.Type).Size())) { 22109 break 22110 } 22111 v.reset(OpCopy) 22112 v.Type = mem.Type 22113 v.AddArg(mem) 22114 return true 22115 } 22116 // match: (Store _ (StructMake0) mem) 22117 // cond: 22118 // result: mem 22119 for { 22120 _ = v.Args[2] 22121 v_1 := v.Args[1] 22122 if v_1.Op != OpStructMake0 { 22123 break 22124 } 22125 mem := v.Args[2] 22126 v.reset(OpCopy) 22127 v.Type = mem.Type 22128 v.AddArg(mem) 22129 return true 22130 } 22131 // match: (Store dst (StructMake1 <t> f0) mem) 22132 // cond: 22133 // result: (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem) 22134 for { 22135 _ = v.Args[2] 22136 dst := v.Args[0] 22137 v_1 := v.Args[1] 22138 if v_1.Op != OpStructMake1 { 22139 break 22140 } 22141 t := v_1.Type 22142 f0 := v_1.Args[0] 22143 mem := v.Args[2] 22144 v.reset(OpStore) 22145 v.Aux = t.FieldType(0) 22146 v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo()) 22147 v0.AuxInt = 0 22148 v0.AddArg(dst) 22149 v.AddArg(v0) 22150 v.AddArg(f0) 22151 v.AddArg(mem) 22152 return true 22153 } 22154 // match: (Store dst (StructMake2 <t> f0 f1) mem) 22155 // cond: 22156 // result: (Store {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem)) 22157 for { 22158 _ = v.Args[2] 22159 dst := v.Args[0] 22160 v_1 := v.Args[1] 22161 if v_1.Op != OpStructMake2 { 22162 break 22163 } 22164 t := v_1.Type 22165 _ = v_1.Args[1] 22166 f0 := v_1.Args[0] 22167 f1 := v_1.Args[1] 22168 mem := v.Args[2] 22169 v.reset(OpStore) 22170 v.Aux = t.FieldType(1) 22171 v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo()) 22172 v0.AuxInt = t.FieldOff(1) 22173 v0.AddArg(dst) 22174 v.AddArg(v0) 22175 v.AddArg(f1) 22176 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 22177 v1.Aux = t.FieldType(0) 22178 v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo()) 22179 v2.AuxInt = 0 22180 v2.AddArg(dst) 22181 v1.AddArg(v2) 22182 v1.AddArg(f0) 22183 v1.AddArg(mem) 22184 v.AddArg(v1) 22185 return true 22186 } 22187 // match: (Store dst (StructMake3 <t> f0 f1 f2) mem) 22188 // cond: 22189 // result: (Store {t.FieldType(2)} (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst) f2 (Store {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem))) 22190 for { 22191 _ = v.Args[2] 22192 dst := v.Args[0] 22193 v_1 := v.Args[1] 22194 if v_1.Op != OpStructMake3 { 22195 break 22196 } 22197 t := v_1.Type 22198 _ = v_1.Args[2] 22199 f0 := v_1.Args[0] 22200 f1 := v_1.Args[1] 22201 f2 := v_1.Args[2] 22202 mem := v.Args[2] 22203 v.reset(OpStore) 22204 v.Aux = t.FieldType(2) 22205 v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo()) 22206 v0.AuxInt = t.FieldOff(2) 22207 v0.AddArg(dst) 22208 v.AddArg(v0) 22209 v.AddArg(f2) 22210 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 22211 v1.Aux = t.FieldType(1) 22212 v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo()) 22213 v2.AuxInt = t.FieldOff(1) 22214 v2.AddArg(dst) 22215 v1.AddArg(v2) 22216 v1.AddArg(f1) 22217 v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 22218 v3.Aux = t.FieldType(0) 22219 v4 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo()) 22220 v4.AuxInt = 0 22221 v4.AddArg(dst) 22222 v3.AddArg(v4) 22223 v3.AddArg(f0) 22224 v3.AddArg(mem) 22225 v1.AddArg(v3) 22226 v.AddArg(v1) 22227 return true 22228 } 22229 // match: (Store dst (StructMake4 <t> f0 f1 f2 f3) mem) 22230 // cond: 22231 // result: (Store {t.FieldType(3)} (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] dst) f3 (Store {t.FieldType(2)} (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst) f2 (Store {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem)))) 22232 for { 22233 _ = v.Args[2] 22234 dst := v.Args[0] 22235 v_1 := v.Args[1] 22236 if v_1.Op != OpStructMake4 { 22237 break 22238 } 22239 t := v_1.Type 22240 _ = v_1.Args[3] 22241 f0 := v_1.Args[0] 22242 f1 := v_1.Args[1] 22243 f2 := v_1.Args[2] 22244 f3 := v_1.Args[3] 22245 mem := v.Args[2] 22246 v.reset(OpStore) 22247 v.Aux = t.FieldType(3) 22248 v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(3).PtrTo()) 22249 v0.AuxInt = t.FieldOff(3) 22250 v0.AddArg(dst) 22251 v.AddArg(v0) 22252 v.AddArg(f3) 22253 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 22254 v1.Aux = t.FieldType(2) 22255 v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo()) 22256 v2.AuxInt = t.FieldOff(2) 22257 v2.AddArg(dst) 22258 v1.AddArg(v2) 22259 v1.AddArg(f2) 22260 v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 22261 v3.Aux = t.FieldType(1) 22262 v4 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo()) 22263 v4.AuxInt = t.FieldOff(1) 22264 v4.AddArg(dst) 22265 v3.AddArg(v4) 22266 v3.AddArg(f1) 22267 v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 22268 v5.Aux = t.FieldType(0) 22269 v6 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo()) 22270 v6.AuxInt = 0 22271 v6.AddArg(dst) 22272 v5.AddArg(v6) 22273 v5.AddArg(f0) 22274 v5.AddArg(mem) 22275 v3.AddArg(v5) 22276 v1.AddArg(v3) 22277 v.AddArg(v1) 22278 return true 22279 } 22280 // match: (Store {t} dst (Load src mem) mem) 22281 // cond: !fe.CanSSA(t.(*types.Type)) 22282 // result: (Move {t} [t.(*types.Type).Size()] dst src mem) 22283 for { 22284 t := v.Aux 22285 _ = v.Args[2] 22286 dst := v.Args[0] 22287 v_1 := v.Args[1] 22288 if v_1.Op != OpLoad { 22289 break 22290 } 22291 _ = v_1.Args[1] 22292 src := v_1.Args[0] 22293 mem := v_1.Args[1] 22294 if mem != v.Args[2] { 22295 break 22296 } 22297 if !(!fe.CanSSA(t.(*types.Type))) { 22298 break 22299 } 22300 v.reset(OpMove) 22301 v.AuxInt = t.(*types.Type).Size() 22302 v.Aux = t 22303 v.AddArg(dst) 22304 v.AddArg(src) 22305 v.AddArg(mem) 22306 return true 22307 } 22308 return false 22309 } 22310 func rewriteValuegeneric_OpStore_10(v *Value) bool { 22311 b := v.Block 22312 _ = b 22313 config := b.Func.Config 22314 _ = config 22315 fe := b.Func.fe 22316 _ = fe 22317 // match: (Store {t} dst (Load src mem) (VarDef {x} mem)) 22318 // cond: !fe.CanSSA(t.(*types.Type)) 22319 // result: (Move {t} [t.(*types.Type).Size()] dst src (VarDef {x} mem)) 22320 for { 22321 t := v.Aux 22322 _ = v.Args[2] 22323 dst := v.Args[0] 22324 v_1 := v.Args[1] 22325 if v_1.Op != OpLoad { 22326 break 22327 } 22328 _ = v_1.Args[1] 22329 src := v_1.Args[0] 22330 mem := v_1.Args[1] 22331 v_2 := v.Args[2] 22332 if v_2.Op != OpVarDef { 22333 break 22334 } 22335 x := v_2.Aux 22336 if mem != v_2.Args[0] { 22337 break 22338 } 22339 if !(!fe.CanSSA(t.(*types.Type))) { 22340 break 22341 } 22342 v.reset(OpMove) 22343 v.AuxInt = t.(*types.Type).Size() 22344 v.Aux = t 22345 v.AddArg(dst) 22346 v.AddArg(src) 22347 v0 := b.NewValue0(v.Pos, OpVarDef, types.TypeMem) 22348 v0.Aux = x 22349 v0.AddArg(mem) 22350 v.AddArg(v0) 22351 return true 22352 } 22353 // match: (Store _ (ArrayMake0) mem) 22354 // cond: 22355 // result: mem 22356 for { 22357 _ = v.Args[2] 22358 v_1 := v.Args[1] 22359 if v_1.Op != OpArrayMake0 { 22360 break 22361 } 22362 mem := v.Args[2] 22363 v.reset(OpCopy) 22364 v.Type = mem.Type 22365 v.AddArg(mem) 22366 return true 22367 } 22368 // match: (Store dst (ArrayMake1 e) mem) 22369 // cond: 22370 // result: (Store {e.Type} dst e mem) 22371 for { 22372 _ = v.Args[2] 22373 dst := v.Args[0] 22374 v_1 := v.Args[1] 22375 if v_1.Op != OpArrayMake1 { 22376 break 22377 } 22378 e := v_1.Args[0] 22379 mem := v.Args[2] 22380 v.reset(OpStore) 22381 v.Aux = e.Type 22382 v.AddArg(dst) 22383 v.AddArg(e) 22384 v.AddArg(mem) 22385 return true 22386 } 22387 // match: (Store (Load (OffPtr [c] (SP)) mem) x mem) 22388 // cond: isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize 22389 // result: mem 22390 for { 22391 _ = v.Args[2] 22392 v_0 := v.Args[0] 22393 if v_0.Op != OpLoad { 22394 break 22395 } 22396 _ = v_0.Args[1] 22397 v_0_0 := v_0.Args[0] 22398 if v_0_0.Op != OpOffPtr { 22399 break 22400 } 22401 c := v_0_0.AuxInt 22402 v_0_0_0 := v_0_0.Args[0] 22403 if v_0_0_0.Op != OpSP { 22404 break 22405 } 22406 mem := v_0.Args[1] 22407 x := v.Args[1] 22408 if mem != v.Args[2] { 22409 break 22410 } 22411 if !(isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) { 22412 break 22413 } 22414 v.reset(OpCopy) 22415 v.Type = mem.Type 22416 v.AddArg(mem) 22417 return true 22418 } 22419 // match: (Store (OffPtr (Load (OffPtr [c] (SP)) mem)) x mem) 22420 // cond: isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize 22421 // result: mem 22422 for { 22423 _ = v.Args[2] 22424 v_0 := v.Args[0] 22425 if v_0.Op != OpOffPtr { 22426 break 22427 } 22428 v_0_0 := v_0.Args[0] 22429 if v_0_0.Op != OpLoad { 22430 break 22431 } 22432 _ = v_0_0.Args[1] 22433 v_0_0_0 := v_0_0.Args[0] 22434 if v_0_0_0.Op != OpOffPtr { 22435 break 22436 } 22437 c := v_0_0_0.AuxInt 22438 v_0_0_0_0 := v_0_0_0.Args[0] 22439 if v_0_0_0_0.Op != OpSP { 22440 break 22441 } 22442 mem := v_0_0.Args[1] 22443 x := v.Args[1] 22444 if mem != v.Args[2] { 22445 break 22446 } 22447 if !(isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) { 22448 break 22449 } 22450 v.reset(OpCopy) 22451 v.Type = mem.Type 22452 v.AddArg(mem) 22453 return true 22454 } 22455 return false 22456 } 22457 func rewriteValuegeneric_OpStringLen_0(v *Value) bool { 22458 // match: (StringLen (StringMake _ (Const64 <t> [c]))) 22459 // cond: 22460 // result: (Const64 <t> [c]) 22461 for { 22462 v_0 := v.Args[0] 22463 if v_0.Op != OpStringMake { 22464 break 22465 } 22466 _ = v_0.Args[1] 22467 v_0_1 := v_0.Args[1] 22468 if v_0_1.Op != OpConst64 { 22469 break 22470 } 22471 t := v_0_1.Type 22472 c := v_0_1.AuxInt 22473 v.reset(OpConst64) 22474 v.Type = t 22475 v.AuxInt = c 22476 return true 22477 } 22478 return false 22479 } 22480 func rewriteValuegeneric_OpStringPtr_0(v *Value) bool { 22481 // match: (StringPtr (StringMake (Const64 <t> [c]) _)) 22482 // cond: 22483 // result: (Const64 <t> [c]) 22484 for { 22485 v_0 := v.Args[0] 22486 if v_0.Op != OpStringMake { 22487 break 22488 } 22489 _ = v_0.Args[1] 22490 v_0_0 := v_0.Args[0] 22491 if v_0_0.Op != OpConst64 { 22492 break 22493 } 22494 t := v_0_0.Type 22495 c := v_0_0.AuxInt 22496 v.reset(OpConst64) 22497 v.Type = t 22498 v.AuxInt = c 22499 return true 22500 } 22501 return false 22502 } 22503 func rewriteValuegeneric_OpStructSelect_0(v *Value) bool { 22504 // match: (StructSelect (StructMake1 x)) 22505 // cond: 22506 // result: x 22507 for { 22508 v_0 := v.Args[0] 22509 if v_0.Op != OpStructMake1 { 22510 break 22511 } 22512 x := v_0.Args[0] 22513 v.reset(OpCopy) 22514 v.Type = x.Type 22515 v.AddArg(x) 22516 return true 22517 } 22518 // match: (StructSelect [0] (StructMake2 x _)) 22519 // cond: 22520 // result: x 22521 for { 22522 if v.AuxInt != 0 { 22523 break 22524 } 22525 v_0 := v.Args[0] 22526 if v_0.Op != OpStructMake2 { 22527 break 22528 } 22529 _ = v_0.Args[1] 22530 x := v_0.Args[0] 22531 v.reset(OpCopy) 22532 v.Type = x.Type 22533 v.AddArg(x) 22534 return true 22535 } 22536 // match: (StructSelect [1] (StructMake2 _ x)) 22537 // cond: 22538 // result: x 22539 for { 22540 if v.AuxInt != 1 { 22541 break 22542 } 22543 v_0 := v.Args[0] 22544 if v_0.Op != OpStructMake2 { 22545 break 22546 } 22547 _ = v_0.Args[1] 22548 x := v_0.Args[1] 22549 v.reset(OpCopy) 22550 v.Type = x.Type 22551 v.AddArg(x) 22552 return true 22553 } 22554 // match: (StructSelect [0] (StructMake3 x _ _)) 22555 // cond: 22556 // result: x 22557 for { 22558 if v.AuxInt != 0 { 22559 break 22560 } 22561 v_0 := v.Args[0] 22562 if v_0.Op != OpStructMake3 { 22563 break 22564 } 22565 _ = v_0.Args[2] 22566 x := v_0.Args[0] 22567 v.reset(OpCopy) 22568 v.Type = x.Type 22569 v.AddArg(x) 22570 return true 22571 } 22572 // match: (StructSelect [1] (StructMake3 _ x _)) 22573 // cond: 22574 // result: x 22575 for { 22576 if v.AuxInt != 1 { 22577 break 22578 } 22579 v_0 := v.Args[0] 22580 if v_0.Op != OpStructMake3 { 22581 break 22582 } 22583 _ = v_0.Args[2] 22584 x := v_0.Args[1] 22585 v.reset(OpCopy) 22586 v.Type = x.Type 22587 v.AddArg(x) 22588 return true 22589 } 22590 // match: (StructSelect [2] (StructMake3 _ _ x)) 22591 // cond: 22592 // result: x 22593 for { 22594 if v.AuxInt != 2 { 22595 break 22596 } 22597 v_0 := v.Args[0] 22598 if v_0.Op != OpStructMake3 { 22599 break 22600 } 22601 _ = v_0.Args[2] 22602 x := v_0.Args[2] 22603 v.reset(OpCopy) 22604 v.Type = x.Type 22605 v.AddArg(x) 22606 return true 22607 } 22608 // match: (StructSelect [0] (StructMake4 x _ _ _)) 22609 // cond: 22610 // result: x 22611 for { 22612 if v.AuxInt != 0 { 22613 break 22614 } 22615 v_0 := v.Args[0] 22616 if v_0.Op != OpStructMake4 { 22617 break 22618 } 22619 _ = v_0.Args[3] 22620 x := v_0.Args[0] 22621 v.reset(OpCopy) 22622 v.Type = x.Type 22623 v.AddArg(x) 22624 return true 22625 } 22626 // match: (StructSelect [1] (StructMake4 _ x _ _)) 22627 // cond: 22628 // result: x 22629 for { 22630 if v.AuxInt != 1 { 22631 break 22632 } 22633 v_0 := v.Args[0] 22634 if v_0.Op != OpStructMake4 { 22635 break 22636 } 22637 _ = v_0.Args[3] 22638 x := v_0.Args[1] 22639 v.reset(OpCopy) 22640 v.Type = x.Type 22641 v.AddArg(x) 22642 return true 22643 } 22644 // match: (StructSelect [2] (StructMake4 _ _ x _)) 22645 // cond: 22646 // result: x 22647 for { 22648 if v.AuxInt != 2 { 22649 break 22650 } 22651 v_0 := v.Args[0] 22652 if v_0.Op != OpStructMake4 { 22653 break 22654 } 22655 _ = v_0.Args[3] 22656 x := v_0.Args[2] 22657 v.reset(OpCopy) 22658 v.Type = x.Type 22659 v.AddArg(x) 22660 return true 22661 } 22662 // match: (StructSelect [3] (StructMake4 _ _ _ x)) 22663 // cond: 22664 // result: x 22665 for { 22666 if v.AuxInt != 3 { 22667 break 22668 } 22669 v_0 := v.Args[0] 22670 if v_0.Op != OpStructMake4 { 22671 break 22672 } 22673 _ = v_0.Args[3] 22674 x := v_0.Args[3] 22675 v.reset(OpCopy) 22676 v.Type = x.Type 22677 v.AddArg(x) 22678 return true 22679 } 22680 return false 22681 } 22682 func rewriteValuegeneric_OpStructSelect_10(v *Value) bool { 22683 b := v.Block 22684 _ = b 22685 fe := b.Func.fe 22686 _ = fe 22687 // match: (StructSelect [i] x:(Load <t> ptr mem)) 22688 // cond: !fe.CanSSA(t) 22689 // result: @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(int(i))] ptr) mem) 22690 for { 22691 i := v.AuxInt 22692 x := v.Args[0] 22693 if x.Op != OpLoad { 22694 break 22695 } 22696 t := x.Type 22697 _ = x.Args[1] 22698 ptr := x.Args[0] 22699 mem := x.Args[1] 22700 if !(!fe.CanSSA(t)) { 22701 break 22702 } 22703 b = x.Block 22704 v0 := b.NewValue0(v.Pos, OpLoad, v.Type) 22705 v.reset(OpCopy) 22706 v.AddArg(v0) 22707 v1 := b.NewValue0(v.Pos, OpOffPtr, v.Type.PtrTo()) 22708 v1.AuxInt = t.FieldOff(int(i)) 22709 v1.AddArg(ptr) 22710 v0.AddArg(v1) 22711 v0.AddArg(mem) 22712 return true 22713 } 22714 // match: (StructSelect [0] x:(IData _)) 22715 // cond: 22716 // result: x 22717 for { 22718 if v.AuxInt != 0 { 22719 break 22720 } 22721 x := v.Args[0] 22722 if x.Op != OpIData { 22723 break 22724 } 22725 v.reset(OpCopy) 22726 v.Type = x.Type 22727 v.AddArg(x) 22728 return true 22729 } 22730 return false 22731 } 22732 func rewriteValuegeneric_OpSub16_0(v *Value) bool { 22733 b := v.Block 22734 _ = b 22735 // match: (Sub16 (Const16 [c]) (Const16 [d])) 22736 // cond: 22737 // result: (Const16 [int64(int16(c-d))]) 22738 for { 22739 _ = v.Args[1] 22740 v_0 := v.Args[0] 22741 if v_0.Op != OpConst16 { 22742 break 22743 } 22744 c := v_0.AuxInt 22745 v_1 := v.Args[1] 22746 if v_1.Op != OpConst16 { 22747 break 22748 } 22749 d := v_1.AuxInt 22750 v.reset(OpConst16) 22751 v.AuxInt = int64(int16(c - d)) 22752 return true 22753 } 22754 // match: (Sub16 x (Const16 <t> [c])) 22755 // cond: x.Op != OpConst16 22756 // result: (Add16 (Const16 <t> [int64(int16(-c))]) x) 22757 for { 22758 _ = v.Args[1] 22759 x := v.Args[0] 22760 v_1 := v.Args[1] 22761 if v_1.Op != OpConst16 { 22762 break 22763 } 22764 t := v_1.Type 22765 c := v_1.AuxInt 22766 if !(x.Op != OpConst16) { 22767 break 22768 } 22769 v.reset(OpAdd16) 22770 v0 := b.NewValue0(v.Pos, OpConst16, t) 22771 v0.AuxInt = int64(int16(-c)) 22772 v.AddArg(v0) 22773 v.AddArg(x) 22774 return true 22775 } 22776 // match: (Sub16 x x) 22777 // cond: 22778 // result: (Const16 [0]) 22779 for { 22780 _ = v.Args[1] 22781 x := v.Args[0] 22782 if x != v.Args[1] { 22783 break 22784 } 22785 v.reset(OpConst16) 22786 v.AuxInt = 0 22787 return true 22788 } 22789 // match: (Sub16 (Add16 x y) x) 22790 // cond: 22791 // result: y 22792 for { 22793 _ = v.Args[1] 22794 v_0 := v.Args[0] 22795 if v_0.Op != OpAdd16 { 22796 break 22797 } 22798 _ = v_0.Args[1] 22799 x := v_0.Args[0] 22800 y := v_0.Args[1] 22801 if x != v.Args[1] { 22802 break 22803 } 22804 v.reset(OpCopy) 22805 v.Type = y.Type 22806 v.AddArg(y) 22807 return true 22808 } 22809 // match: (Sub16 (Add16 y x) x) 22810 // cond: 22811 // result: y 22812 for { 22813 _ = v.Args[1] 22814 v_0 := v.Args[0] 22815 if v_0.Op != OpAdd16 { 22816 break 22817 } 22818 _ = v_0.Args[1] 22819 y := v_0.Args[0] 22820 x := v_0.Args[1] 22821 if x != v.Args[1] { 22822 break 22823 } 22824 v.reset(OpCopy) 22825 v.Type = y.Type 22826 v.AddArg(y) 22827 return true 22828 } 22829 // match: (Sub16 (Add16 x y) y) 22830 // cond: 22831 // result: x 22832 for { 22833 _ = v.Args[1] 22834 v_0 := v.Args[0] 22835 if v_0.Op != OpAdd16 { 22836 break 22837 } 22838 _ = v_0.Args[1] 22839 x := v_0.Args[0] 22840 y := v_0.Args[1] 22841 if y != v.Args[1] { 22842 break 22843 } 22844 v.reset(OpCopy) 22845 v.Type = x.Type 22846 v.AddArg(x) 22847 return true 22848 } 22849 // match: (Sub16 (Add16 y x) y) 22850 // cond: 22851 // result: x 22852 for { 22853 _ = v.Args[1] 22854 v_0 := v.Args[0] 22855 if v_0.Op != OpAdd16 { 22856 break 22857 } 22858 _ = v_0.Args[1] 22859 y := v_0.Args[0] 22860 x := v_0.Args[1] 22861 if y != v.Args[1] { 22862 break 22863 } 22864 v.reset(OpCopy) 22865 v.Type = x.Type 22866 v.AddArg(x) 22867 return true 22868 } 22869 // match: (Sub16 x (Sub16 i:(Const16 <t>) z)) 22870 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 22871 // result: (Sub16 (Add16 <t> x z) i) 22872 for { 22873 _ = v.Args[1] 22874 x := v.Args[0] 22875 v_1 := v.Args[1] 22876 if v_1.Op != OpSub16 { 22877 break 22878 } 22879 _ = v_1.Args[1] 22880 i := v_1.Args[0] 22881 if i.Op != OpConst16 { 22882 break 22883 } 22884 t := i.Type 22885 z := v_1.Args[1] 22886 if !(z.Op != OpConst16 && x.Op != OpConst16) { 22887 break 22888 } 22889 v.reset(OpSub16) 22890 v0 := b.NewValue0(v.Pos, OpAdd16, t) 22891 v0.AddArg(x) 22892 v0.AddArg(z) 22893 v.AddArg(v0) 22894 v.AddArg(i) 22895 return true 22896 } 22897 // match: (Sub16 x (Sub16 z i:(Const16 <t>))) 22898 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 22899 // result: (Add16 i (Sub16 <t> x z)) 22900 for { 22901 _ = v.Args[1] 22902 x := v.Args[0] 22903 v_1 := v.Args[1] 22904 if v_1.Op != OpSub16 { 22905 break 22906 } 22907 _ = v_1.Args[1] 22908 z := v_1.Args[0] 22909 i := v_1.Args[1] 22910 if i.Op != OpConst16 { 22911 break 22912 } 22913 t := i.Type 22914 if !(z.Op != OpConst16 && x.Op != OpConst16) { 22915 break 22916 } 22917 v.reset(OpAdd16) 22918 v.AddArg(i) 22919 v0 := b.NewValue0(v.Pos, OpSub16, t) 22920 v0.AddArg(x) 22921 v0.AddArg(z) 22922 v.AddArg(v0) 22923 return true 22924 } 22925 // match: (Sub16 (Const16 <t> [c]) (Sub16 x (Const16 <t> [d]))) 22926 // cond: 22927 // result: (Sub16 (Const16 <t> [int64(int16(c+d))]) x) 22928 for { 22929 _ = v.Args[1] 22930 v_0 := v.Args[0] 22931 if v_0.Op != OpConst16 { 22932 break 22933 } 22934 t := v_0.Type 22935 c := v_0.AuxInt 22936 v_1 := v.Args[1] 22937 if v_1.Op != OpSub16 { 22938 break 22939 } 22940 _ = v_1.Args[1] 22941 x := v_1.Args[0] 22942 v_1_1 := v_1.Args[1] 22943 if v_1_1.Op != OpConst16 { 22944 break 22945 } 22946 if v_1_1.Type != t { 22947 break 22948 } 22949 d := v_1_1.AuxInt 22950 v.reset(OpSub16) 22951 v0 := b.NewValue0(v.Pos, OpConst16, t) 22952 v0.AuxInt = int64(int16(c + d)) 22953 v.AddArg(v0) 22954 v.AddArg(x) 22955 return true 22956 } 22957 return false 22958 } 22959 func rewriteValuegeneric_OpSub16_10(v *Value) bool { 22960 b := v.Block 22961 _ = b 22962 // match: (Sub16 (Const16 <t> [c]) (Sub16 (Const16 <t> [d]) x)) 22963 // cond: 22964 // result: (Add16 (Const16 <t> [int64(int16(c-d))]) x) 22965 for { 22966 _ = v.Args[1] 22967 v_0 := v.Args[0] 22968 if v_0.Op != OpConst16 { 22969 break 22970 } 22971 t := v_0.Type 22972 c := v_0.AuxInt 22973 v_1 := v.Args[1] 22974 if v_1.Op != OpSub16 { 22975 break 22976 } 22977 _ = v_1.Args[1] 22978 v_1_0 := v_1.Args[0] 22979 if v_1_0.Op != OpConst16 { 22980 break 22981 } 22982 if v_1_0.Type != t { 22983 break 22984 } 22985 d := v_1_0.AuxInt 22986 x := v_1.Args[1] 22987 v.reset(OpAdd16) 22988 v0 := b.NewValue0(v.Pos, OpConst16, t) 22989 v0.AuxInt = int64(int16(c - d)) 22990 v.AddArg(v0) 22991 v.AddArg(x) 22992 return true 22993 } 22994 return false 22995 } 22996 func rewriteValuegeneric_OpSub32_0(v *Value) bool { 22997 b := v.Block 22998 _ = b 22999 // match: (Sub32 (Const32 [c]) (Const32 [d])) 23000 // cond: 23001 // result: (Const32 [int64(int32(c-d))]) 23002 for { 23003 _ = v.Args[1] 23004 v_0 := v.Args[0] 23005 if v_0.Op != OpConst32 { 23006 break 23007 } 23008 c := v_0.AuxInt 23009 v_1 := v.Args[1] 23010 if v_1.Op != OpConst32 { 23011 break 23012 } 23013 d := v_1.AuxInt 23014 v.reset(OpConst32) 23015 v.AuxInt = int64(int32(c - d)) 23016 return true 23017 } 23018 // match: (Sub32 x (Const32 <t> [c])) 23019 // cond: x.Op != OpConst32 23020 // result: (Add32 (Const32 <t> [int64(int32(-c))]) x) 23021 for { 23022 _ = v.Args[1] 23023 x := v.Args[0] 23024 v_1 := v.Args[1] 23025 if v_1.Op != OpConst32 { 23026 break 23027 } 23028 t := v_1.Type 23029 c := v_1.AuxInt 23030 if !(x.Op != OpConst32) { 23031 break 23032 } 23033 v.reset(OpAdd32) 23034 v0 := b.NewValue0(v.Pos, OpConst32, t) 23035 v0.AuxInt = int64(int32(-c)) 23036 v.AddArg(v0) 23037 v.AddArg(x) 23038 return true 23039 } 23040 // match: (Sub32 x x) 23041 // cond: 23042 // result: (Const32 [0]) 23043 for { 23044 _ = v.Args[1] 23045 x := v.Args[0] 23046 if x != v.Args[1] { 23047 break 23048 } 23049 v.reset(OpConst32) 23050 v.AuxInt = 0 23051 return true 23052 } 23053 // match: (Sub32 (Add32 x y) x) 23054 // cond: 23055 // result: y 23056 for { 23057 _ = v.Args[1] 23058 v_0 := v.Args[0] 23059 if v_0.Op != OpAdd32 { 23060 break 23061 } 23062 _ = v_0.Args[1] 23063 x := v_0.Args[0] 23064 y := v_0.Args[1] 23065 if x != v.Args[1] { 23066 break 23067 } 23068 v.reset(OpCopy) 23069 v.Type = y.Type 23070 v.AddArg(y) 23071 return true 23072 } 23073 // match: (Sub32 (Add32 y x) x) 23074 // cond: 23075 // result: y 23076 for { 23077 _ = v.Args[1] 23078 v_0 := v.Args[0] 23079 if v_0.Op != OpAdd32 { 23080 break 23081 } 23082 _ = v_0.Args[1] 23083 y := v_0.Args[0] 23084 x := v_0.Args[1] 23085 if x != v.Args[1] { 23086 break 23087 } 23088 v.reset(OpCopy) 23089 v.Type = y.Type 23090 v.AddArg(y) 23091 return true 23092 } 23093 // match: (Sub32 (Add32 x y) y) 23094 // cond: 23095 // result: x 23096 for { 23097 _ = v.Args[1] 23098 v_0 := v.Args[0] 23099 if v_0.Op != OpAdd32 { 23100 break 23101 } 23102 _ = v_0.Args[1] 23103 x := v_0.Args[0] 23104 y := v_0.Args[1] 23105 if y != v.Args[1] { 23106 break 23107 } 23108 v.reset(OpCopy) 23109 v.Type = x.Type 23110 v.AddArg(x) 23111 return true 23112 } 23113 // match: (Sub32 (Add32 y x) y) 23114 // cond: 23115 // result: x 23116 for { 23117 _ = v.Args[1] 23118 v_0 := v.Args[0] 23119 if v_0.Op != OpAdd32 { 23120 break 23121 } 23122 _ = v_0.Args[1] 23123 y := v_0.Args[0] 23124 x := v_0.Args[1] 23125 if y != v.Args[1] { 23126 break 23127 } 23128 v.reset(OpCopy) 23129 v.Type = x.Type 23130 v.AddArg(x) 23131 return true 23132 } 23133 // match: (Sub32 x (Sub32 i:(Const32 <t>) z)) 23134 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 23135 // result: (Sub32 (Add32 <t> x z) i) 23136 for { 23137 _ = v.Args[1] 23138 x := v.Args[0] 23139 v_1 := v.Args[1] 23140 if v_1.Op != OpSub32 { 23141 break 23142 } 23143 _ = v_1.Args[1] 23144 i := v_1.Args[0] 23145 if i.Op != OpConst32 { 23146 break 23147 } 23148 t := i.Type 23149 z := v_1.Args[1] 23150 if !(z.Op != OpConst32 && x.Op != OpConst32) { 23151 break 23152 } 23153 v.reset(OpSub32) 23154 v0 := b.NewValue0(v.Pos, OpAdd32, t) 23155 v0.AddArg(x) 23156 v0.AddArg(z) 23157 v.AddArg(v0) 23158 v.AddArg(i) 23159 return true 23160 } 23161 // match: (Sub32 x (Sub32 z i:(Const32 <t>))) 23162 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 23163 // result: (Add32 i (Sub32 <t> x z)) 23164 for { 23165 _ = v.Args[1] 23166 x := v.Args[0] 23167 v_1 := v.Args[1] 23168 if v_1.Op != OpSub32 { 23169 break 23170 } 23171 _ = v_1.Args[1] 23172 z := v_1.Args[0] 23173 i := v_1.Args[1] 23174 if i.Op != OpConst32 { 23175 break 23176 } 23177 t := i.Type 23178 if !(z.Op != OpConst32 && x.Op != OpConst32) { 23179 break 23180 } 23181 v.reset(OpAdd32) 23182 v.AddArg(i) 23183 v0 := b.NewValue0(v.Pos, OpSub32, t) 23184 v0.AddArg(x) 23185 v0.AddArg(z) 23186 v.AddArg(v0) 23187 return true 23188 } 23189 // match: (Sub32 (Const32 <t> [c]) (Sub32 x (Const32 <t> [d]))) 23190 // cond: 23191 // result: (Sub32 (Const32 <t> [int64(int32(c+d))]) x) 23192 for { 23193 _ = v.Args[1] 23194 v_0 := v.Args[0] 23195 if v_0.Op != OpConst32 { 23196 break 23197 } 23198 t := v_0.Type 23199 c := v_0.AuxInt 23200 v_1 := v.Args[1] 23201 if v_1.Op != OpSub32 { 23202 break 23203 } 23204 _ = v_1.Args[1] 23205 x := v_1.Args[0] 23206 v_1_1 := v_1.Args[1] 23207 if v_1_1.Op != OpConst32 { 23208 break 23209 } 23210 if v_1_1.Type != t { 23211 break 23212 } 23213 d := v_1_1.AuxInt 23214 v.reset(OpSub32) 23215 v0 := b.NewValue0(v.Pos, OpConst32, t) 23216 v0.AuxInt = int64(int32(c + d)) 23217 v.AddArg(v0) 23218 v.AddArg(x) 23219 return true 23220 } 23221 return false 23222 } 23223 func rewriteValuegeneric_OpSub32_10(v *Value) bool { 23224 b := v.Block 23225 _ = b 23226 // match: (Sub32 (Const32 <t> [c]) (Sub32 (Const32 <t> [d]) x)) 23227 // cond: 23228 // result: (Add32 (Const32 <t> [int64(int32(c-d))]) x) 23229 for { 23230 _ = v.Args[1] 23231 v_0 := v.Args[0] 23232 if v_0.Op != OpConst32 { 23233 break 23234 } 23235 t := v_0.Type 23236 c := v_0.AuxInt 23237 v_1 := v.Args[1] 23238 if v_1.Op != OpSub32 { 23239 break 23240 } 23241 _ = v_1.Args[1] 23242 v_1_0 := v_1.Args[0] 23243 if v_1_0.Op != OpConst32 { 23244 break 23245 } 23246 if v_1_0.Type != t { 23247 break 23248 } 23249 d := v_1_0.AuxInt 23250 x := v_1.Args[1] 23251 v.reset(OpAdd32) 23252 v0 := b.NewValue0(v.Pos, OpConst32, t) 23253 v0.AuxInt = int64(int32(c - d)) 23254 v.AddArg(v0) 23255 v.AddArg(x) 23256 return true 23257 } 23258 return false 23259 } 23260 func rewriteValuegeneric_OpSub32F_0(v *Value) bool { 23261 // match: (Sub32F (Const32F [c]) (Const32F [d])) 23262 // cond: 23263 // result: (Const32F [f2i(float64(i2f32(c) - i2f32(d)))]) 23264 for { 23265 _ = v.Args[1] 23266 v_0 := v.Args[0] 23267 if v_0.Op != OpConst32F { 23268 break 23269 } 23270 c := v_0.AuxInt 23271 v_1 := v.Args[1] 23272 if v_1.Op != OpConst32F { 23273 break 23274 } 23275 d := v_1.AuxInt 23276 v.reset(OpConst32F) 23277 v.AuxInt = f2i(float64(i2f32(c) - i2f32(d))) 23278 return true 23279 } 23280 // match: (Sub32F x (Const32F [0])) 23281 // cond: 23282 // result: x 23283 for { 23284 _ = v.Args[1] 23285 x := v.Args[0] 23286 v_1 := v.Args[1] 23287 if v_1.Op != OpConst32F { 23288 break 23289 } 23290 if v_1.AuxInt != 0 { 23291 break 23292 } 23293 v.reset(OpCopy) 23294 v.Type = x.Type 23295 v.AddArg(x) 23296 return true 23297 } 23298 return false 23299 } 23300 func rewriteValuegeneric_OpSub64_0(v *Value) bool { 23301 b := v.Block 23302 _ = b 23303 // match: (Sub64 (Const64 [c]) (Const64 [d])) 23304 // cond: 23305 // result: (Const64 [c-d]) 23306 for { 23307 _ = v.Args[1] 23308 v_0 := v.Args[0] 23309 if v_0.Op != OpConst64 { 23310 break 23311 } 23312 c := v_0.AuxInt 23313 v_1 := v.Args[1] 23314 if v_1.Op != OpConst64 { 23315 break 23316 } 23317 d := v_1.AuxInt 23318 v.reset(OpConst64) 23319 v.AuxInt = c - d 23320 return true 23321 } 23322 // match: (Sub64 x (Const64 <t> [c])) 23323 // cond: x.Op != OpConst64 23324 // result: (Add64 (Const64 <t> [-c]) x) 23325 for { 23326 _ = v.Args[1] 23327 x := v.Args[0] 23328 v_1 := v.Args[1] 23329 if v_1.Op != OpConst64 { 23330 break 23331 } 23332 t := v_1.Type 23333 c := v_1.AuxInt 23334 if !(x.Op != OpConst64) { 23335 break 23336 } 23337 v.reset(OpAdd64) 23338 v0 := b.NewValue0(v.Pos, OpConst64, t) 23339 v0.AuxInt = -c 23340 v.AddArg(v0) 23341 v.AddArg(x) 23342 return true 23343 } 23344 // match: (Sub64 x x) 23345 // cond: 23346 // result: (Const64 [0]) 23347 for { 23348 _ = v.Args[1] 23349 x := v.Args[0] 23350 if x != v.Args[1] { 23351 break 23352 } 23353 v.reset(OpConst64) 23354 v.AuxInt = 0 23355 return true 23356 } 23357 // match: (Sub64 (Add64 x y) x) 23358 // cond: 23359 // result: y 23360 for { 23361 _ = v.Args[1] 23362 v_0 := v.Args[0] 23363 if v_0.Op != OpAdd64 { 23364 break 23365 } 23366 _ = v_0.Args[1] 23367 x := v_0.Args[0] 23368 y := v_0.Args[1] 23369 if x != v.Args[1] { 23370 break 23371 } 23372 v.reset(OpCopy) 23373 v.Type = y.Type 23374 v.AddArg(y) 23375 return true 23376 } 23377 // match: (Sub64 (Add64 y x) x) 23378 // cond: 23379 // result: y 23380 for { 23381 _ = v.Args[1] 23382 v_0 := v.Args[0] 23383 if v_0.Op != OpAdd64 { 23384 break 23385 } 23386 _ = v_0.Args[1] 23387 y := v_0.Args[0] 23388 x := v_0.Args[1] 23389 if x != v.Args[1] { 23390 break 23391 } 23392 v.reset(OpCopy) 23393 v.Type = y.Type 23394 v.AddArg(y) 23395 return true 23396 } 23397 // match: (Sub64 (Add64 x y) y) 23398 // cond: 23399 // result: x 23400 for { 23401 _ = v.Args[1] 23402 v_0 := v.Args[0] 23403 if v_0.Op != OpAdd64 { 23404 break 23405 } 23406 _ = v_0.Args[1] 23407 x := v_0.Args[0] 23408 y := v_0.Args[1] 23409 if y != v.Args[1] { 23410 break 23411 } 23412 v.reset(OpCopy) 23413 v.Type = x.Type 23414 v.AddArg(x) 23415 return true 23416 } 23417 // match: (Sub64 (Add64 y x) y) 23418 // cond: 23419 // result: x 23420 for { 23421 _ = v.Args[1] 23422 v_0 := v.Args[0] 23423 if v_0.Op != OpAdd64 { 23424 break 23425 } 23426 _ = v_0.Args[1] 23427 y := v_0.Args[0] 23428 x := v_0.Args[1] 23429 if y != v.Args[1] { 23430 break 23431 } 23432 v.reset(OpCopy) 23433 v.Type = x.Type 23434 v.AddArg(x) 23435 return true 23436 } 23437 // match: (Sub64 x (Sub64 i:(Const64 <t>) z)) 23438 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 23439 // result: (Sub64 (Add64 <t> x z) i) 23440 for { 23441 _ = v.Args[1] 23442 x := v.Args[0] 23443 v_1 := v.Args[1] 23444 if v_1.Op != OpSub64 { 23445 break 23446 } 23447 _ = v_1.Args[1] 23448 i := v_1.Args[0] 23449 if i.Op != OpConst64 { 23450 break 23451 } 23452 t := i.Type 23453 z := v_1.Args[1] 23454 if !(z.Op != OpConst64 && x.Op != OpConst64) { 23455 break 23456 } 23457 v.reset(OpSub64) 23458 v0 := b.NewValue0(v.Pos, OpAdd64, t) 23459 v0.AddArg(x) 23460 v0.AddArg(z) 23461 v.AddArg(v0) 23462 v.AddArg(i) 23463 return true 23464 } 23465 // match: (Sub64 x (Sub64 z i:(Const64 <t>))) 23466 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 23467 // result: (Add64 i (Sub64 <t> x z)) 23468 for { 23469 _ = v.Args[1] 23470 x := v.Args[0] 23471 v_1 := v.Args[1] 23472 if v_1.Op != OpSub64 { 23473 break 23474 } 23475 _ = v_1.Args[1] 23476 z := v_1.Args[0] 23477 i := v_1.Args[1] 23478 if i.Op != OpConst64 { 23479 break 23480 } 23481 t := i.Type 23482 if !(z.Op != OpConst64 && x.Op != OpConst64) { 23483 break 23484 } 23485 v.reset(OpAdd64) 23486 v.AddArg(i) 23487 v0 := b.NewValue0(v.Pos, OpSub64, t) 23488 v0.AddArg(x) 23489 v0.AddArg(z) 23490 v.AddArg(v0) 23491 return true 23492 } 23493 // match: (Sub64 (Const64 <t> [c]) (Sub64 x (Const64 <t> [d]))) 23494 // cond: 23495 // result: (Sub64 (Const64 <t> [c+d]) x) 23496 for { 23497 _ = v.Args[1] 23498 v_0 := v.Args[0] 23499 if v_0.Op != OpConst64 { 23500 break 23501 } 23502 t := v_0.Type 23503 c := v_0.AuxInt 23504 v_1 := v.Args[1] 23505 if v_1.Op != OpSub64 { 23506 break 23507 } 23508 _ = v_1.Args[1] 23509 x := v_1.Args[0] 23510 v_1_1 := v_1.Args[1] 23511 if v_1_1.Op != OpConst64 { 23512 break 23513 } 23514 if v_1_1.Type != t { 23515 break 23516 } 23517 d := v_1_1.AuxInt 23518 v.reset(OpSub64) 23519 v0 := b.NewValue0(v.Pos, OpConst64, t) 23520 v0.AuxInt = c + d 23521 v.AddArg(v0) 23522 v.AddArg(x) 23523 return true 23524 } 23525 return false 23526 } 23527 func rewriteValuegeneric_OpSub64_10(v *Value) bool { 23528 b := v.Block 23529 _ = b 23530 // match: (Sub64 (Const64 <t> [c]) (Sub64 (Const64 <t> [d]) x)) 23531 // cond: 23532 // result: (Add64 (Const64 <t> [c-d]) x) 23533 for { 23534 _ = v.Args[1] 23535 v_0 := v.Args[0] 23536 if v_0.Op != OpConst64 { 23537 break 23538 } 23539 t := v_0.Type 23540 c := v_0.AuxInt 23541 v_1 := v.Args[1] 23542 if v_1.Op != OpSub64 { 23543 break 23544 } 23545 _ = v_1.Args[1] 23546 v_1_0 := v_1.Args[0] 23547 if v_1_0.Op != OpConst64 { 23548 break 23549 } 23550 if v_1_0.Type != t { 23551 break 23552 } 23553 d := v_1_0.AuxInt 23554 x := v_1.Args[1] 23555 v.reset(OpAdd64) 23556 v0 := b.NewValue0(v.Pos, OpConst64, t) 23557 v0.AuxInt = c - d 23558 v.AddArg(v0) 23559 v.AddArg(x) 23560 return true 23561 } 23562 return false 23563 } 23564 func rewriteValuegeneric_OpSub64F_0(v *Value) bool { 23565 // match: (Sub64F (Const64F [c]) (Const64F [d])) 23566 // cond: 23567 // result: (Const64F [f2i(i2f(c) - i2f(d))]) 23568 for { 23569 _ = v.Args[1] 23570 v_0 := v.Args[0] 23571 if v_0.Op != OpConst64F { 23572 break 23573 } 23574 c := v_0.AuxInt 23575 v_1 := v.Args[1] 23576 if v_1.Op != OpConst64F { 23577 break 23578 } 23579 d := v_1.AuxInt 23580 v.reset(OpConst64F) 23581 v.AuxInt = f2i(i2f(c) - i2f(d)) 23582 return true 23583 } 23584 // match: (Sub64F x (Const64F [0])) 23585 // cond: 23586 // result: x 23587 for { 23588 _ = v.Args[1] 23589 x := v.Args[0] 23590 v_1 := v.Args[1] 23591 if v_1.Op != OpConst64F { 23592 break 23593 } 23594 if v_1.AuxInt != 0 { 23595 break 23596 } 23597 v.reset(OpCopy) 23598 v.Type = x.Type 23599 v.AddArg(x) 23600 return true 23601 } 23602 return false 23603 } 23604 func rewriteValuegeneric_OpSub8_0(v *Value) bool { 23605 b := v.Block 23606 _ = b 23607 // match: (Sub8 (Const8 [c]) (Const8 [d])) 23608 // cond: 23609 // result: (Const8 [int64(int8(c-d))]) 23610 for { 23611 _ = v.Args[1] 23612 v_0 := v.Args[0] 23613 if v_0.Op != OpConst8 { 23614 break 23615 } 23616 c := v_0.AuxInt 23617 v_1 := v.Args[1] 23618 if v_1.Op != OpConst8 { 23619 break 23620 } 23621 d := v_1.AuxInt 23622 v.reset(OpConst8) 23623 v.AuxInt = int64(int8(c - d)) 23624 return true 23625 } 23626 // match: (Sub8 x (Const8 <t> [c])) 23627 // cond: x.Op != OpConst8 23628 // result: (Add8 (Const8 <t> [int64(int8(-c))]) x) 23629 for { 23630 _ = v.Args[1] 23631 x := v.Args[0] 23632 v_1 := v.Args[1] 23633 if v_1.Op != OpConst8 { 23634 break 23635 } 23636 t := v_1.Type 23637 c := v_1.AuxInt 23638 if !(x.Op != OpConst8) { 23639 break 23640 } 23641 v.reset(OpAdd8) 23642 v0 := b.NewValue0(v.Pos, OpConst8, t) 23643 v0.AuxInt = int64(int8(-c)) 23644 v.AddArg(v0) 23645 v.AddArg(x) 23646 return true 23647 } 23648 // match: (Sub8 x x) 23649 // cond: 23650 // result: (Const8 [0]) 23651 for { 23652 _ = v.Args[1] 23653 x := v.Args[0] 23654 if x != v.Args[1] { 23655 break 23656 } 23657 v.reset(OpConst8) 23658 v.AuxInt = 0 23659 return true 23660 } 23661 // match: (Sub8 (Add8 x y) x) 23662 // cond: 23663 // result: y 23664 for { 23665 _ = v.Args[1] 23666 v_0 := v.Args[0] 23667 if v_0.Op != OpAdd8 { 23668 break 23669 } 23670 _ = v_0.Args[1] 23671 x := v_0.Args[0] 23672 y := v_0.Args[1] 23673 if x != v.Args[1] { 23674 break 23675 } 23676 v.reset(OpCopy) 23677 v.Type = y.Type 23678 v.AddArg(y) 23679 return true 23680 } 23681 // match: (Sub8 (Add8 y x) x) 23682 // cond: 23683 // result: y 23684 for { 23685 _ = v.Args[1] 23686 v_0 := v.Args[0] 23687 if v_0.Op != OpAdd8 { 23688 break 23689 } 23690 _ = v_0.Args[1] 23691 y := v_0.Args[0] 23692 x := v_0.Args[1] 23693 if x != v.Args[1] { 23694 break 23695 } 23696 v.reset(OpCopy) 23697 v.Type = y.Type 23698 v.AddArg(y) 23699 return true 23700 } 23701 // match: (Sub8 (Add8 x y) y) 23702 // cond: 23703 // result: x 23704 for { 23705 _ = v.Args[1] 23706 v_0 := v.Args[0] 23707 if v_0.Op != OpAdd8 { 23708 break 23709 } 23710 _ = v_0.Args[1] 23711 x := v_0.Args[0] 23712 y := v_0.Args[1] 23713 if y != v.Args[1] { 23714 break 23715 } 23716 v.reset(OpCopy) 23717 v.Type = x.Type 23718 v.AddArg(x) 23719 return true 23720 } 23721 // match: (Sub8 (Add8 y x) y) 23722 // cond: 23723 // result: x 23724 for { 23725 _ = v.Args[1] 23726 v_0 := v.Args[0] 23727 if v_0.Op != OpAdd8 { 23728 break 23729 } 23730 _ = v_0.Args[1] 23731 y := v_0.Args[0] 23732 x := v_0.Args[1] 23733 if y != v.Args[1] { 23734 break 23735 } 23736 v.reset(OpCopy) 23737 v.Type = x.Type 23738 v.AddArg(x) 23739 return true 23740 } 23741 // match: (Sub8 x (Sub8 i:(Const8 <t>) z)) 23742 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 23743 // result: (Sub8 (Add8 <t> x z) i) 23744 for { 23745 _ = v.Args[1] 23746 x := v.Args[0] 23747 v_1 := v.Args[1] 23748 if v_1.Op != OpSub8 { 23749 break 23750 } 23751 _ = v_1.Args[1] 23752 i := v_1.Args[0] 23753 if i.Op != OpConst8 { 23754 break 23755 } 23756 t := i.Type 23757 z := v_1.Args[1] 23758 if !(z.Op != OpConst8 && x.Op != OpConst8) { 23759 break 23760 } 23761 v.reset(OpSub8) 23762 v0 := b.NewValue0(v.Pos, OpAdd8, t) 23763 v0.AddArg(x) 23764 v0.AddArg(z) 23765 v.AddArg(v0) 23766 v.AddArg(i) 23767 return true 23768 } 23769 // match: (Sub8 x (Sub8 z i:(Const8 <t>))) 23770 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 23771 // result: (Add8 i (Sub8 <t> x z)) 23772 for { 23773 _ = v.Args[1] 23774 x := v.Args[0] 23775 v_1 := v.Args[1] 23776 if v_1.Op != OpSub8 { 23777 break 23778 } 23779 _ = v_1.Args[1] 23780 z := v_1.Args[0] 23781 i := v_1.Args[1] 23782 if i.Op != OpConst8 { 23783 break 23784 } 23785 t := i.Type 23786 if !(z.Op != OpConst8 && x.Op != OpConst8) { 23787 break 23788 } 23789 v.reset(OpAdd8) 23790 v.AddArg(i) 23791 v0 := b.NewValue0(v.Pos, OpSub8, t) 23792 v0.AddArg(x) 23793 v0.AddArg(z) 23794 v.AddArg(v0) 23795 return true 23796 } 23797 // match: (Sub8 (Const8 <t> [c]) (Sub8 x (Const8 <t> [d]))) 23798 // cond: 23799 // result: (Sub8 (Const8 <t> [int64(int8(c+d))]) x) 23800 for { 23801 _ = v.Args[1] 23802 v_0 := v.Args[0] 23803 if v_0.Op != OpConst8 { 23804 break 23805 } 23806 t := v_0.Type 23807 c := v_0.AuxInt 23808 v_1 := v.Args[1] 23809 if v_1.Op != OpSub8 { 23810 break 23811 } 23812 _ = v_1.Args[1] 23813 x := v_1.Args[0] 23814 v_1_1 := v_1.Args[1] 23815 if v_1_1.Op != OpConst8 { 23816 break 23817 } 23818 if v_1_1.Type != t { 23819 break 23820 } 23821 d := v_1_1.AuxInt 23822 v.reset(OpSub8) 23823 v0 := b.NewValue0(v.Pos, OpConst8, t) 23824 v0.AuxInt = int64(int8(c + d)) 23825 v.AddArg(v0) 23826 v.AddArg(x) 23827 return true 23828 } 23829 return false 23830 } 23831 func rewriteValuegeneric_OpSub8_10(v *Value) bool { 23832 b := v.Block 23833 _ = b 23834 // match: (Sub8 (Const8 <t> [c]) (Sub8 (Const8 <t> [d]) x)) 23835 // cond: 23836 // result: (Add8 (Const8 <t> [int64(int8(c-d))]) x) 23837 for { 23838 _ = v.Args[1] 23839 v_0 := v.Args[0] 23840 if v_0.Op != OpConst8 { 23841 break 23842 } 23843 t := v_0.Type 23844 c := v_0.AuxInt 23845 v_1 := v.Args[1] 23846 if v_1.Op != OpSub8 { 23847 break 23848 } 23849 _ = v_1.Args[1] 23850 v_1_0 := v_1.Args[0] 23851 if v_1_0.Op != OpConst8 { 23852 break 23853 } 23854 if v_1_0.Type != t { 23855 break 23856 } 23857 d := v_1_0.AuxInt 23858 x := v_1.Args[1] 23859 v.reset(OpAdd8) 23860 v0 := b.NewValue0(v.Pos, OpConst8, t) 23861 v0.AuxInt = int64(int8(c - d)) 23862 v.AddArg(v0) 23863 v.AddArg(x) 23864 return true 23865 } 23866 return false 23867 } 23868 func rewriteValuegeneric_OpTrunc16to8_0(v *Value) bool { 23869 // match: (Trunc16to8 (Const16 [c])) 23870 // cond: 23871 // result: (Const8 [int64(int8(c))]) 23872 for { 23873 v_0 := v.Args[0] 23874 if v_0.Op != OpConst16 { 23875 break 23876 } 23877 c := v_0.AuxInt 23878 v.reset(OpConst8) 23879 v.AuxInt = int64(int8(c)) 23880 return true 23881 } 23882 // match: (Trunc16to8 (ZeroExt8to16 x)) 23883 // cond: 23884 // result: x 23885 for { 23886 v_0 := v.Args[0] 23887 if v_0.Op != OpZeroExt8to16 { 23888 break 23889 } 23890 x := v_0.Args[0] 23891 v.reset(OpCopy) 23892 v.Type = x.Type 23893 v.AddArg(x) 23894 return true 23895 } 23896 // match: (Trunc16to8 (SignExt8to16 x)) 23897 // cond: 23898 // result: x 23899 for { 23900 v_0 := v.Args[0] 23901 if v_0.Op != OpSignExt8to16 { 23902 break 23903 } 23904 x := v_0.Args[0] 23905 v.reset(OpCopy) 23906 v.Type = x.Type 23907 v.AddArg(x) 23908 return true 23909 } 23910 // match: (Trunc16to8 (And16 (Const16 [y]) x)) 23911 // cond: y&0xFF == 0xFF 23912 // result: (Trunc16to8 x) 23913 for { 23914 v_0 := v.Args[0] 23915 if v_0.Op != OpAnd16 { 23916 break 23917 } 23918 _ = v_0.Args[1] 23919 v_0_0 := v_0.Args[0] 23920 if v_0_0.Op != OpConst16 { 23921 break 23922 } 23923 y := v_0_0.AuxInt 23924 x := v_0.Args[1] 23925 if !(y&0xFF == 0xFF) { 23926 break 23927 } 23928 v.reset(OpTrunc16to8) 23929 v.AddArg(x) 23930 return true 23931 } 23932 // match: (Trunc16to8 (And16 x (Const16 [y]))) 23933 // cond: y&0xFF == 0xFF 23934 // result: (Trunc16to8 x) 23935 for { 23936 v_0 := v.Args[0] 23937 if v_0.Op != OpAnd16 { 23938 break 23939 } 23940 _ = v_0.Args[1] 23941 x := v_0.Args[0] 23942 v_0_1 := v_0.Args[1] 23943 if v_0_1.Op != OpConst16 { 23944 break 23945 } 23946 y := v_0_1.AuxInt 23947 if !(y&0xFF == 0xFF) { 23948 break 23949 } 23950 v.reset(OpTrunc16to8) 23951 v.AddArg(x) 23952 return true 23953 } 23954 return false 23955 } 23956 func rewriteValuegeneric_OpTrunc32to16_0(v *Value) bool { 23957 // match: (Trunc32to16 (Const32 [c])) 23958 // cond: 23959 // result: (Const16 [int64(int16(c))]) 23960 for { 23961 v_0 := v.Args[0] 23962 if v_0.Op != OpConst32 { 23963 break 23964 } 23965 c := v_0.AuxInt 23966 v.reset(OpConst16) 23967 v.AuxInt = int64(int16(c)) 23968 return true 23969 } 23970 // match: (Trunc32to16 (ZeroExt8to32 x)) 23971 // cond: 23972 // result: (ZeroExt8to16 x) 23973 for { 23974 v_0 := v.Args[0] 23975 if v_0.Op != OpZeroExt8to32 { 23976 break 23977 } 23978 x := v_0.Args[0] 23979 v.reset(OpZeroExt8to16) 23980 v.AddArg(x) 23981 return true 23982 } 23983 // match: (Trunc32to16 (ZeroExt16to32 x)) 23984 // cond: 23985 // result: x 23986 for { 23987 v_0 := v.Args[0] 23988 if v_0.Op != OpZeroExt16to32 { 23989 break 23990 } 23991 x := v_0.Args[0] 23992 v.reset(OpCopy) 23993 v.Type = x.Type 23994 v.AddArg(x) 23995 return true 23996 } 23997 // match: (Trunc32to16 (SignExt8to32 x)) 23998 // cond: 23999 // result: (SignExt8to16 x) 24000 for { 24001 v_0 := v.Args[0] 24002 if v_0.Op != OpSignExt8to32 { 24003 break 24004 } 24005 x := v_0.Args[0] 24006 v.reset(OpSignExt8to16) 24007 v.AddArg(x) 24008 return true 24009 } 24010 // match: (Trunc32to16 (SignExt16to32 x)) 24011 // cond: 24012 // result: x 24013 for { 24014 v_0 := v.Args[0] 24015 if v_0.Op != OpSignExt16to32 { 24016 break 24017 } 24018 x := v_0.Args[0] 24019 v.reset(OpCopy) 24020 v.Type = x.Type 24021 v.AddArg(x) 24022 return true 24023 } 24024 // match: (Trunc32to16 (And32 (Const32 [y]) x)) 24025 // cond: y&0xFFFF == 0xFFFF 24026 // result: (Trunc32to16 x) 24027 for { 24028 v_0 := v.Args[0] 24029 if v_0.Op != OpAnd32 { 24030 break 24031 } 24032 _ = v_0.Args[1] 24033 v_0_0 := v_0.Args[0] 24034 if v_0_0.Op != OpConst32 { 24035 break 24036 } 24037 y := v_0_0.AuxInt 24038 x := v_0.Args[1] 24039 if !(y&0xFFFF == 0xFFFF) { 24040 break 24041 } 24042 v.reset(OpTrunc32to16) 24043 v.AddArg(x) 24044 return true 24045 } 24046 // match: (Trunc32to16 (And32 x (Const32 [y]))) 24047 // cond: y&0xFFFF == 0xFFFF 24048 // result: (Trunc32to16 x) 24049 for { 24050 v_0 := v.Args[0] 24051 if v_0.Op != OpAnd32 { 24052 break 24053 } 24054 _ = v_0.Args[1] 24055 x := v_0.Args[0] 24056 v_0_1 := v_0.Args[1] 24057 if v_0_1.Op != OpConst32 { 24058 break 24059 } 24060 y := v_0_1.AuxInt 24061 if !(y&0xFFFF == 0xFFFF) { 24062 break 24063 } 24064 v.reset(OpTrunc32to16) 24065 v.AddArg(x) 24066 return true 24067 } 24068 return false 24069 } 24070 func rewriteValuegeneric_OpTrunc32to8_0(v *Value) bool { 24071 // match: (Trunc32to8 (Const32 [c])) 24072 // cond: 24073 // result: (Const8 [int64(int8(c))]) 24074 for { 24075 v_0 := v.Args[0] 24076 if v_0.Op != OpConst32 { 24077 break 24078 } 24079 c := v_0.AuxInt 24080 v.reset(OpConst8) 24081 v.AuxInt = int64(int8(c)) 24082 return true 24083 } 24084 // match: (Trunc32to8 (ZeroExt8to32 x)) 24085 // cond: 24086 // result: x 24087 for { 24088 v_0 := v.Args[0] 24089 if v_0.Op != OpZeroExt8to32 { 24090 break 24091 } 24092 x := v_0.Args[0] 24093 v.reset(OpCopy) 24094 v.Type = x.Type 24095 v.AddArg(x) 24096 return true 24097 } 24098 // match: (Trunc32to8 (SignExt8to32 x)) 24099 // cond: 24100 // result: x 24101 for { 24102 v_0 := v.Args[0] 24103 if v_0.Op != OpSignExt8to32 { 24104 break 24105 } 24106 x := v_0.Args[0] 24107 v.reset(OpCopy) 24108 v.Type = x.Type 24109 v.AddArg(x) 24110 return true 24111 } 24112 // match: (Trunc32to8 (And32 (Const32 [y]) x)) 24113 // cond: y&0xFF == 0xFF 24114 // result: (Trunc32to8 x) 24115 for { 24116 v_0 := v.Args[0] 24117 if v_0.Op != OpAnd32 { 24118 break 24119 } 24120 _ = v_0.Args[1] 24121 v_0_0 := v_0.Args[0] 24122 if v_0_0.Op != OpConst32 { 24123 break 24124 } 24125 y := v_0_0.AuxInt 24126 x := v_0.Args[1] 24127 if !(y&0xFF == 0xFF) { 24128 break 24129 } 24130 v.reset(OpTrunc32to8) 24131 v.AddArg(x) 24132 return true 24133 } 24134 // match: (Trunc32to8 (And32 x (Const32 [y]))) 24135 // cond: y&0xFF == 0xFF 24136 // result: (Trunc32to8 x) 24137 for { 24138 v_0 := v.Args[0] 24139 if v_0.Op != OpAnd32 { 24140 break 24141 } 24142 _ = v_0.Args[1] 24143 x := v_0.Args[0] 24144 v_0_1 := v_0.Args[1] 24145 if v_0_1.Op != OpConst32 { 24146 break 24147 } 24148 y := v_0_1.AuxInt 24149 if !(y&0xFF == 0xFF) { 24150 break 24151 } 24152 v.reset(OpTrunc32to8) 24153 v.AddArg(x) 24154 return true 24155 } 24156 return false 24157 } 24158 func rewriteValuegeneric_OpTrunc64to16_0(v *Value) bool { 24159 // match: (Trunc64to16 (Const64 [c])) 24160 // cond: 24161 // result: (Const16 [int64(int16(c))]) 24162 for { 24163 v_0 := v.Args[0] 24164 if v_0.Op != OpConst64 { 24165 break 24166 } 24167 c := v_0.AuxInt 24168 v.reset(OpConst16) 24169 v.AuxInt = int64(int16(c)) 24170 return true 24171 } 24172 // match: (Trunc64to16 (ZeroExt8to64 x)) 24173 // cond: 24174 // result: (ZeroExt8to16 x) 24175 for { 24176 v_0 := v.Args[0] 24177 if v_0.Op != OpZeroExt8to64 { 24178 break 24179 } 24180 x := v_0.Args[0] 24181 v.reset(OpZeroExt8to16) 24182 v.AddArg(x) 24183 return true 24184 } 24185 // match: (Trunc64to16 (ZeroExt16to64 x)) 24186 // cond: 24187 // result: x 24188 for { 24189 v_0 := v.Args[0] 24190 if v_0.Op != OpZeroExt16to64 { 24191 break 24192 } 24193 x := v_0.Args[0] 24194 v.reset(OpCopy) 24195 v.Type = x.Type 24196 v.AddArg(x) 24197 return true 24198 } 24199 // match: (Trunc64to16 (SignExt8to64 x)) 24200 // cond: 24201 // result: (SignExt8to16 x) 24202 for { 24203 v_0 := v.Args[0] 24204 if v_0.Op != OpSignExt8to64 { 24205 break 24206 } 24207 x := v_0.Args[0] 24208 v.reset(OpSignExt8to16) 24209 v.AddArg(x) 24210 return true 24211 } 24212 // match: (Trunc64to16 (SignExt16to64 x)) 24213 // cond: 24214 // result: x 24215 for { 24216 v_0 := v.Args[0] 24217 if v_0.Op != OpSignExt16to64 { 24218 break 24219 } 24220 x := v_0.Args[0] 24221 v.reset(OpCopy) 24222 v.Type = x.Type 24223 v.AddArg(x) 24224 return true 24225 } 24226 // match: (Trunc64to16 (And64 (Const64 [y]) x)) 24227 // cond: y&0xFFFF == 0xFFFF 24228 // result: (Trunc64to16 x) 24229 for { 24230 v_0 := v.Args[0] 24231 if v_0.Op != OpAnd64 { 24232 break 24233 } 24234 _ = v_0.Args[1] 24235 v_0_0 := v_0.Args[0] 24236 if v_0_0.Op != OpConst64 { 24237 break 24238 } 24239 y := v_0_0.AuxInt 24240 x := v_0.Args[1] 24241 if !(y&0xFFFF == 0xFFFF) { 24242 break 24243 } 24244 v.reset(OpTrunc64to16) 24245 v.AddArg(x) 24246 return true 24247 } 24248 // match: (Trunc64to16 (And64 x (Const64 [y]))) 24249 // cond: y&0xFFFF == 0xFFFF 24250 // result: (Trunc64to16 x) 24251 for { 24252 v_0 := v.Args[0] 24253 if v_0.Op != OpAnd64 { 24254 break 24255 } 24256 _ = v_0.Args[1] 24257 x := v_0.Args[0] 24258 v_0_1 := v_0.Args[1] 24259 if v_0_1.Op != OpConst64 { 24260 break 24261 } 24262 y := v_0_1.AuxInt 24263 if !(y&0xFFFF == 0xFFFF) { 24264 break 24265 } 24266 v.reset(OpTrunc64to16) 24267 v.AddArg(x) 24268 return true 24269 } 24270 return false 24271 } 24272 func rewriteValuegeneric_OpTrunc64to32_0(v *Value) bool { 24273 // match: (Trunc64to32 (Const64 [c])) 24274 // cond: 24275 // result: (Const32 [int64(int32(c))]) 24276 for { 24277 v_0 := v.Args[0] 24278 if v_0.Op != OpConst64 { 24279 break 24280 } 24281 c := v_0.AuxInt 24282 v.reset(OpConst32) 24283 v.AuxInt = int64(int32(c)) 24284 return true 24285 } 24286 // match: (Trunc64to32 (ZeroExt8to64 x)) 24287 // cond: 24288 // result: (ZeroExt8to32 x) 24289 for { 24290 v_0 := v.Args[0] 24291 if v_0.Op != OpZeroExt8to64 { 24292 break 24293 } 24294 x := v_0.Args[0] 24295 v.reset(OpZeroExt8to32) 24296 v.AddArg(x) 24297 return true 24298 } 24299 // match: (Trunc64to32 (ZeroExt16to64 x)) 24300 // cond: 24301 // result: (ZeroExt16to32 x) 24302 for { 24303 v_0 := v.Args[0] 24304 if v_0.Op != OpZeroExt16to64 { 24305 break 24306 } 24307 x := v_0.Args[0] 24308 v.reset(OpZeroExt16to32) 24309 v.AddArg(x) 24310 return true 24311 } 24312 // match: (Trunc64to32 (ZeroExt32to64 x)) 24313 // cond: 24314 // result: x 24315 for { 24316 v_0 := v.Args[0] 24317 if v_0.Op != OpZeroExt32to64 { 24318 break 24319 } 24320 x := v_0.Args[0] 24321 v.reset(OpCopy) 24322 v.Type = x.Type 24323 v.AddArg(x) 24324 return true 24325 } 24326 // match: (Trunc64to32 (SignExt8to64 x)) 24327 // cond: 24328 // result: (SignExt8to32 x) 24329 for { 24330 v_0 := v.Args[0] 24331 if v_0.Op != OpSignExt8to64 { 24332 break 24333 } 24334 x := v_0.Args[0] 24335 v.reset(OpSignExt8to32) 24336 v.AddArg(x) 24337 return true 24338 } 24339 // match: (Trunc64to32 (SignExt16to64 x)) 24340 // cond: 24341 // result: (SignExt16to32 x) 24342 for { 24343 v_0 := v.Args[0] 24344 if v_0.Op != OpSignExt16to64 { 24345 break 24346 } 24347 x := v_0.Args[0] 24348 v.reset(OpSignExt16to32) 24349 v.AddArg(x) 24350 return true 24351 } 24352 // match: (Trunc64to32 (SignExt32to64 x)) 24353 // cond: 24354 // result: x 24355 for { 24356 v_0 := v.Args[0] 24357 if v_0.Op != OpSignExt32to64 { 24358 break 24359 } 24360 x := v_0.Args[0] 24361 v.reset(OpCopy) 24362 v.Type = x.Type 24363 v.AddArg(x) 24364 return true 24365 } 24366 // match: (Trunc64to32 (And64 (Const64 [y]) x)) 24367 // cond: y&0xFFFFFFFF == 0xFFFFFFFF 24368 // result: (Trunc64to32 x) 24369 for { 24370 v_0 := v.Args[0] 24371 if v_0.Op != OpAnd64 { 24372 break 24373 } 24374 _ = v_0.Args[1] 24375 v_0_0 := v_0.Args[0] 24376 if v_0_0.Op != OpConst64 { 24377 break 24378 } 24379 y := v_0_0.AuxInt 24380 x := v_0.Args[1] 24381 if !(y&0xFFFFFFFF == 0xFFFFFFFF) { 24382 break 24383 } 24384 v.reset(OpTrunc64to32) 24385 v.AddArg(x) 24386 return true 24387 } 24388 // match: (Trunc64to32 (And64 x (Const64 [y]))) 24389 // cond: y&0xFFFFFFFF == 0xFFFFFFFF 24390 // result: (Trunc64to32 x) 24391 for { 24392 v_0 := v.Args[0] 24393 if v_0.Op != OpAnd64 { 24394 break 24395 } 24396 _ = v_0.Args[1] 24397 x := v_0.Args[0] 24398 v_0_1 := v_0.Args[1] 24399 if v_0_1.Op != OpConst64 { 24400 break 24401 } 24402 y := v_0_1.AuxInt 24403 if !(y&0xFFFFFFFF == 0xFFFFFFFF) { 24404 break 24405 } 24406 v.reset(OpTrunc64to32) 24407 v.AddArg(x) 24408 return true 24409 } 24410 return false 24411 } 24412 func rewriteValuegeneric_OpTrunc64to8_0(v *Value) bool { 24413 // match: (Trunc64to8 (Const64 [c])) 24414 // cond: 24415 // result: (Const8 [int64(int8(c))]) 24416 for { 24417 v_0 := v.Args[0] 24418 if v_0.Op != OpConst64 { 24419 break 24420 } 24421 c := v_0.AuxInt 24422 v.reset(OpConst8) 24423 v.AuxInt = int64(int8(c)) 24424 return true 24425 } 24426 // match: (Trunc64to8 (ZeroExt8to64 x)) 24427 // cond: 24428 // result: x 24429 for { 24430 v_0 := v.Args[0] 24431 if v_0.Op != OpZeroExt8to64 { 24432 break 24433 } 24434 x := v_0.Args[0] 24435 v.reset(OpCopy) 24436 v.Type = x.Type 24437 v.AddArg(x) 24438 return true 24439 } 24440 // match: (Trunc64to8 (SignExt8to64 x)) 24441 // cond: 24442 // result: x 24443 for { 24444 v_0 := v.Args[0] 24445 if v_0.Op != OpSignExt8to64 { 24446 break 24447 } 24448 x := v_0.Args[0] 24449 v.reset(OpCopy) 24450 v.Type = x.Type 24451 v.AddArg(x) 24452 return true 24453 } 24454 // match: (Trunc64to8 (And64 (Const64 [y]) x)) 24455 // cond: y&0xFF == 0xFF 24456 // result: (Trunc64to8 x) 24457 for { 24458 v_0 := v.Args[0] 24459 if v_0.Op != OpAnd64 { 24460 break 24461 } 24462 _ = v_0.Args[1] 24463 v_0_0 := v_0.Args[0] 24464 if v_0_0.Op != OpConst64 { 24465 break 24466 } 24467 y := v_0_0.AuxInt 24468 x := v_0.Args[1] 24469 if !(y&0xFF == 0xFF) { 24470 break 24471 } 24472 v.reset(OpTrunc64to8) 24473 v.AddArg(x) 24474 return true 24475 } 24476 // match: (Trunc64to8 (And64 x (Const64 [y]))) 24477 // cond: y&0xFF == 0xFF 24478 // result: (Trunc64to8 x) 24479 for { 24480 v_0 := v.Args[0] 24481 if v_0.Op != OpAnd64 { 24482 break 24483 } 24484 _ = v_0.Args[1] 24485 x := v_0.Args[0] 24486 v_0_1 := v_0.Args[1] 24487 if v_0_1.Op != OpConst64 { 24488 break 24489 } 24490 y := v_0_1.AuxInt 24491 if !(y&0xFF == 0xFF) { 24492 break 24493 } 24494 v.reset(OpTrunc64to8) 24495 v.AddArg(x) 24496 return true 24497 } 24498 return false 24499 } 24500 func rewriteValuegeneric_OpXor16_0(v *Value) bool { 24501 b := v.Block 24502 _ = b 24503 // match: (Xor16 (Const16 [c]) (Const16 [d])) 24504 // cond: 24505 // result: (Const16 [int64(int16(c^d))]) 24506 for { 24507 _ = v.Args[1] 24508 v_0 := v.Args[0] 24509 if v_0.Op != OpConst16 { 24510 break 24511 } 24512 c := v_0.AuxInt 24513 v_1 := v.Args[1] 24514 if v_1.Op != OpConst16 { 24515 break 24516 } 24517 d := v_1.AuxInt 24518 v.reset(OpConst16) 24519 v.AuxInt = int64(int16(c ^ d)) 24520 return true 24521 } 24522 // match: (Xor16 (Const16 [d]) (Const16 [c])) 24523 // cond: 24524 // result: (Const16 [int64(int16(c^d))]) 24525 for { 24526 _ = v.Args[1] 24527 v_0 := v.Args[0] 24528 if v_0.Op != OpConst16 { 24529 break 24530 } 24531 d := v_0.AuxInt 24532 v_1 := v.Args[1] 24533 if v_1.Op != OpConst16 { 24534 break 24535 } 24536 c := v_1.AuxInt 24537 v.reset(OpConst16) 24538 v.AuxInt = int64(int16(c ^ d)) 24539 return true 24540 } 24541 // match: (Xor16 x x) 24542 // cond: 24543 // result: (Const16 [0]) 24544 for { 24545 _ = v.Args[1] 24546 x := v.Args[0] 24547 if x != v.Args[1] { 24548 break 24549 } 24550 v.reset(OpConst16) 24551 v.AuxInt = 0 24552 return true 24553 } 24554 // match: (Xor16 (Const16 [0]) x) 24555 // cond: 24556 // result: x 24557 for { 24558 _ = v.Args[1] 24559 v_0 := v.Args[0] 24560 if v_0.Op != OpConst16 { 24561 break 24562 } 24563 if v_0.AuxInt != 0 { 24564 break 24565 } 24566 x := v.Args[1] 24567 v.reset(OpCopy) 24568 v.Type = x.Type 24569 v.AddArg(x) 24570 return true 24571 } 24572 // match: (Xor16 x (Const16 [0])) 24573 // cond: 24574 // result: x 24575 for { 24576 _ = v.Args[1] 24577 x := v.Args[0] 24578 v_1 := v.Args[1] 24579 if v_1.Op != OpConst16 { 24580 break 24581 } 24582 if v_1.AuxInt != 0 { 24583 break 24584 } 24585 v.reset(OpCopy) 24586 v.Type = x.Type 24587 v.AddArg(x) 24588 return true 24589 } 24590 // match: (Xor16 x (Xor16 x y)) 24591 // cond: 24592 // result: y 24593 for { 24594 _ = v.Args[1] 24595 x := v.Args[0] 24596 v_1 := v.Args[1] 24597 if v_1.Op != OpXor16 { 24598 break 24599 } 24600 _ = v_1.Args[1] 24601 if x != v_1.Args[0] { 24602 break 24603 } 24604 y := v_1.Args[1] 24605 v.reset(OpCopy) 24606 v.Type = y.Type 24607 v.AddArg(y) 24608 return true 24609 } 24610 // match: (Xor16 x (Xor16 y x)) 24611 // cond: 24612 // result: y 24613 for { 24614 _ = v.Args[1] 24615 x := v.Args[0] 24616 v_1 := v.Args[1] 24617 if v_1.Op != OpXor16 { 24618 break 24619 } 24620 _ = v_1.Args[1] 24621 y := v_1.Args[0] 24622 if x != v_1.Args[1] { 24623 break 24624 } 24625 v.reset(OpCopy) 24626 v.Type = y.Type 24627 v.AddArg(y) 24628 return true 24629 } 24630 // match: (Xor16 (Xor16 x y) x) 24631 // cond: 24632 // result: y 24633 for { 24634 _ = v.Args[1] 24635 v_0 := v.Args[0] 24636 if v_0.Op != OpXor16 { 24637 break 24638 } 24639 _ = v_0.Args[1] 24640 x := v_0.Args[0] 24641 y := v_0.Args[1] 24642 if x != v.Args[1] { 24643 break 24644 } 24645 v.reset(OpCopy) 24646 v.Type = y.Type 24647 v.AddArg(y) 24648 return true 24649 } 24650 // match: (Xor16 (Xor16 y x) x) 24651 // cond: 24652 // result: y 24653 for { 24654 _ = v.Args[1] 24655 v_0 := v.Args[0] 24656 if v_0.Op != OpXor16 { 24657 break 24658 } 24659 _ = v_0.Args[1] 24660 y := v_0.Args[0] 24661 x := v_0.Args[1] 24662 if x != v.Args[1] { 24663 break 24664 } 24665 v.reset(OpCopy) 24666 v.Type = y.Type 24667 v.AddArg(y) 24668 return true 24669 } 24670 // match: (Xor16 (Xor16 i:(Const16 <t>) z) x) 24671 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 24672 // result: (Xor16 i (Xor16 <t> z x)) 24673 for { 24674 _ = v.Args[1] 24675 v_0 := v.Args[0] 24676 if v_0.Op != OpXor16 { 24677 break 24678 } 24679 _ = v_0.Args[1] 24680 i := v_0.Args[0] 24681 if i.Op != OpConst16 { 24682 break 24683 } 24684 t := i.Type 24685 z := v_0.Args[1] 24686 x := v.Args[1] 24687 if !(z.Op != OpConst16 && x.Op != OpConst16) { 24688 break 24689 } 24690 v.reset(OpXor16) 24691 v.AddArg(i) 24692 v0 := b.NewValue0(v.Pos, OpXor16, t) 24693 v0.AddArg(z) 24694 v0.AddArg(x) 24695 v.AddArg(v0) 24696 return true 24697 } 24698 return false 24699 } 24700 func rewriteValuegeneric_OpXor16_10(v *Value) bool { 24701 b := v.Block 24702 _ = b 24703 // match: (Xor16 (Xor16 z i:(Const16 <t>)) x) 24704 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 24705 // result: (Xor16 i (Xor16 <t> z x)) 24706 for { 24707 _ = v.Args[1] 24708 v_0 := v.Args[0] 24709 if v_0.Op != OpXor16 { 24710 break 24711 } 24712 _ = v_0.Args[1] 24713 z := v_0.Args[0] 24714 i := v_0.Args[1] 24715 if i.Op != OpConst16 { 24716 break 24717 } 24718 t := i.Type 24719 x := v.Args[1] 24720 if !(z.Op != OpConst16 && x.Op != OpConst16) { 24721 break 24722 } 24723 v.reset(OpXor16) 24724 v.AddArg(i) 24725 v0 := b.NewValue0(v.Pos, OpXor16, t) 24726 v0.AddArg(z) 24727 v0.AddArg(x) 24728 v.AddArg(v0) 24729 return true 24730 } 24731 // match: (Xor16 x (Xor16 i:(Const16 <t>) z)) 24732 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 24733 // result: (Xor16 i (Xor16 <t> z x)) 24734 for { 24735 _ = v.Args[1] 24736 x := v.Args[0] 24737 v_1 := v.Args[1] 24738 if v_1.Op != OpXor16 { 24739 break 24740 } 24741 _ = v_1.Args[1] 24742 i := v_1.Args[0] 24743 if i.Op != OpConst16 { 24744 break 24745 } 24746 t := i.Type 24747 z := v_1.Args[1] 24748 if !(z.Op != OpConst16 && x.Op != OpConst16) { 24749 break 24750 } 24751 v.reset(OpXor16) 24752 v.AddArg(i) 24753 v0 := b.NewValue0(v.Pos, OpXor16, t) 24754 v0.AddArg(z) 24755 v0.AddArg(x) 24756 v.AddArg(v0) 24757 return true 24758 } 24759 // match: (Xor16 x (Xor16 z i:(Const16 <t>))) 24760 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 24761 // result: (Xor16 i (Xor16 <t> z x)) 24762 for { 24763 _ = v.Args[1] 24764 x := v.Args[0] 24765 v_1 := v.Args[1] 24766 if v_1.Op != OpXor16 { 24767 break 24768 } 24769 _ = v_1.Args[1] 24770 z := v_1.Args[0] 24771 i := v_1.Args[1] 24772 if i.Op != OpConst16 { 24773 break 24774 } 24775 t := i.Type 24776 if !(z.Op != OpConst16 && x.Op != OpConst16) { 24777 break 24778 } 24779 v.reset(OpXor16) 24780 v.AddArg(i) 24781 v0 := b.NewValue0(v.Pos, OpXor16, t) 24782 v0.AddArg(z) 24783 v0.AddArg(x) 24784 v.AddArg(v0) 24785 return true 24786 } 24787 // match: (Xor16 (Const16 <t> [c]) (Xor16 (Const16 <t> [d]) x)) 24788 // cond: 24789 // result: (Xor16 (Const16 <t> [int64(int16(c^d))]) x) 24790 for { 24791 _ = v.Args[1] 24792 v_0 := v.Args[0] 24793 if v_0.Op != OpConst16 { 24794 break 24795 } 24796 t := v_0.Type 24797 c := v_0.AuxInt 24798 v_1 := v.Args[1] 24799 if v_1.Op != OpXor16 { 24800 break 24801 } 24802 _ = v_1.Args[1] 24803 v_1_0 := v_1.Args[0] 24804 if v_1_0.Op != OpConst16 { 24805 break 24806 } 24807 if v_1_0.Type != t { 24808 break 24809 } 24810 d := v_1_0.AuxInt 24811 x := v_1.Args[1] 24812 v.reset(OpXor16) 24813 v0 := b.NewValue0(v.Pos, OpConst16, t) 24814 v0.AuxInt = int64(int16(c ^ d)) 24815 v.AddArg(v0) 24816 v.AddArg(x) 24817 return true 24818 } 24819 // match: (Xor16 (Const16 <t> [c]) (Xor16 x (Const16 <t> [d]))) 24820 // cond: 24821 // result: (Xor16 (Const16 <t> [int64(int16(c^d))]) x) 24822 for { 24823 _ = v.Args[1] 24824 v_0 := v.Args[0] 24825 if v_0.Op != OpConst16 { 24826 break 24827 } 24828 t := v_0.Type 24829 c := v_0.AuxInt 24830 v_1 := v.Args[1] 24831 if v_1.Op != OpXor16 { 24832 break 24833 } 24834 _ = v_1.Args[1] 24835 x := v_1.Args[0] 24836 v_1_1 := v_1.Args[1] 24837 if v_1_1.Op != OpConst16 { 24838 break 24839 } 24840 if v_1_1.Type != t { 24841 break 24842 } 24843 d := v_1_1.AuxInt 24844 v.reset(OpXor16) 24845 v0 := b.NewValue0(v.Pos, OpConst16, t) 24846 v0.AuxInt = int64(int16(c ^ d)) 24847 v.AddArg(v0) 24848 v.AddArg(x) 24849 return true 24850 } 24851 // match: (Xor16 (Xor16 (Const16 <t> [d]) x) (Const16 <t> [c])) 24852 // cond: 24853 // result: (Xor16 (Const16 <t> [int64(int16(c^d))]) x) 24854 for { 24855 _ = v.Args[1] 24856 v_0 := v.Args[0] 24857 if v_0.Op != OpXor16 { 24858 break 24859 } 24860 _ = v_0.Args[1] 24861 v_0_0 := v_0.Args[0] 24862 if v_0_0.Op != OpConst16 { 24863 break 24864 } 24865 t := v_0_0.Type 24866 d := v_0_0.AuxInt 24867 x := v_0.Args[1] 24868 v_1 := v.Args[1] 24869 if v_1.Op != OpConst16 { 24870 break 24871 } 24872 if v_1.Type != t { 24873 break 24874 } 24875 c := v_1.AuxInt 24876 v.reset(OpXor16) 24877 v0 := b.NewValue0(v.Pos, OpConst16, t) 24878 v0.AuxInt = int64(int16(c ^ d)) 24879 v.AddArg(v0) 24880 v.AddArg(x) 24881 return true 24882 } 24883 // match: (Xor16 (Xor16 x (Const16 <t> [d])) (Const16 <t> [c])) 24884 // cond: 24885 // result: (Xor16 (Const16 <t> [int64(int16(c^d))]) x) 24886 for { 24887 _ = v.Args[1] 24888 v_0 := v.Args[0] 24889 if v_0.Op != OpXor16 { 24890 break 24891 } 24892 _ = v_0.Args[1] 24893 x := v_0.Args[0] 24894 v_0_1 := v_0.Args[1] 24895 if v_0_1.Op != OpConst16 { 24896 break 24897 } 24898 t := v_0_1.Type 24899 d := v_0_1.AuxInt 24900 v_1 := v.Args[1] 24901 if v_1.Op != OpConst16 { 24902 break 24903 } 24904 if v_1.Type != t { 24905 break 24906 } 24907 c := v_1.AuxInt 24908 v.reset(OpXor16) 24909 v0 := b.NewValue0(v.Pos, OpConst16, t) 24910 v0.AuxInt = int64(int16(c ^ d)) 24911 v.AddArg(v0) 24912 v.AddArg(x) 24913 return true 24914 } 24915 return false 24916 } 24917 func rewriteValuegeneric_OpXor32_0(v *Value) bool { 24918 b := v.Block 24919 _ = b 24920 // match: (Xor32 (Const32 [c]) (Const32 [d])) 24921 // cond: 24922 // result: (Const32 [int64(int32(c^d))]) 24923 for { 24924 _ = v.Args[1] 24925 v_0 := v.Args[0] 24926 if v_0.Op != OpConst32 { 24927 break 24928 } 24929 c := v_0.AuxInt 24930 v_1 := v.Args[1] 24931 if v_1.Op != OpConst32 { 24932 break 24933 } 24934 d := v_1.AuxInt 24935 v.reset(OpConst32) 24936 v.AuxInt = int64(int32(c ^ d)) 24937 return true 24938 } 24939 // match: (Xor32 (Const32 [d]) (Const32 [c])) 24940 // cond: 24941 // result: (Const32 [int64(int32(c^d))]) 24942 for { 24943 _ = v.Args[1] 24944 v_0 := v.Args[0] 24945 if v_0.Op != OpConst32 { 24946 break 24947 } 24948 d := v_0.AuxInt 24949 v_1 := v.Args[1] 24950 if v_1.Op != OpConst32 { 24951 break 24952 } 24953 c := v_1.AuxInt 24954 v.reset(OpConst32) 24955 v.AuxInt = int64(int32(c ^ d)) 24956 return true 24957 } 24958 // match: (Xor32 x x) 24959 // cond: 24960 // result: (Const32 [0]) 24961 for { 24962 _ = v.Args[1] 24963 x := v.Args[0] 24964 if x != v.Args[1] { 24965 break 24966 } 24967 v.reset(OpConst32) 24968 v.AuxInt = 0 24969 return true 24970 } 24971 // match: (Xor32 (Const32 [0]) x) 24972 // cond: 24973 // result: x 24974 for { 24975 _ = v.Args[1] 24976 v_0 := v.Args[0] 24977 if v_0.Op != OpConst32 { 24978 break 24979 } 24980 if v_0.AuxInt != 0 { 24981 break 24982 } 24983 x := v.Args[1] 24984 v.reset(OpCopy) 24985 v.Type = x.Type 24986 v.AddArg(x) 24987 return true 24988 } 24989 // match: (Xor32 x (Const32 [0])) 24990 // cond: 24991 // result: x 24992 for { 24993 _ = v.Args[1] 24994 x := v.Args[0] 24995 v_1 := v.Args[1] 24996 if v_1.Op != OpConst32 { 24997 break 24998 } 24999 if v_1.AuxInt != 0 { 25000 break 25001 } 25002 v.reset(OpCopy) 25003 v.Type = x.Type 25004 v.AddArg(x) 25005 return true 25006 } 25007 // match: (Xor32 x (Xor32 x y)) 25008 // cond: 25009 // result: y 25010 for { 25011 _ = v.Args[1] 25012 x := v.Args[0] 25013 v_1 := v.Args[1] 25014 if v_1.Op != OpXor32 { 25015 break 25016 } 25017 _ = v_1.Args[1] 25018 if x != v_1.Args[0] { 25019 break 25020 } 25021 y := v_1.Args[1] 25022 v.reset(OpCopy) 25023 v.Type = y.Type 25024 v.AddArg(y) 25025 return true 25026 } 25027 // match: (Xor32 x (Xor32 y x)) 25028 // cond: 25029 // result: y 25030 for { 25031 _ = v.Args[1] 25032 x := v.Args[0] 25033 v_1 := v.Args[1] 25034 if v_1.Op != OpXor32 { 25035 break 25036 } 25037 _ = v_1.Args[1] 25038 y := v_1.Args[0] 25039 if x != v_1.Args[1] { 25040 break 25041 } 25042 v.reset(OpCopy) 25043 v.Type = y.Type 25044 v.AddArg(y) 25045 return true 25046 } 25047 // match: (Xor32 (Xor32 x y) x) 25048 // cond: 25049 // result: y 25050 for { 25051 _ = v.Args[1] 25052 v_0 := v.Args[0] 25053 if v_0.Op != OpXor32 { 25054 break 25055 } 25056 _ = v_0.Args[1] 25057 x := v_0.Args[0] 25058 y := v_0.Args[1] 25059 if x != v.Args[1] { 25060 break 25061 } 25062 v.reset(OpCopy) 25063 v.Type = y.Type 25064 v.AddArg(y) 25065 return true 25066 } 25067 // match: (Xor32 (Xor32 y x) x) 25068 // cond: 25069 // result: y 25070 for { 25071 _ = v.Args[1] 25072 v_0 := v.Args[0] 25073 if v_0.Op != OpXor32 { 25074 break 25075 } 25076 _ = v_0.Args[1] 25077 y := v_0.Args[0] 25078 x := v_0.Args[1] 25079 if x != v.Args[1] { 25080 break 25081 } 25082 v.reset(OpCopy) 25083 v.Type = y.Type 25084 v.AddArg(y) 25085 return true 25086 } 25087 // match: (Xor32 (Xor32 i:(Const32 <t>) z) x) 25088 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 25089 // result: (Xor32 i (Xor32 <t> z x)) 25090 for { 25091 _ = v.Args[1] 25092 v_0 := v.Args[0] 25093 if v_0.Op != OpXor32 { 25094 break 25095 } 25096 _ = v_0.Args[1] 25097 i := v_0.Args[0] 25098 if i.Op != OpConst32 { 25099 break 25100 } 25101 t := i.Type 25102 z := v_0.Args[1] 25103 x := v.Args[1] 25104 if !(z.Op != OpConst32 && x.Op != OpConst32) { 25105 break 25106 } 25107 v.reset(OpXor32) 25108 v.AddArg(i) 25109 v0 := b.NewValue0(v.Pos, OpXor32, t) 25110 v0.AddArg(z) 25111 v0.AddArg(x) 25112 v.AddArg(v0) 25113 return true 25114 } 25115 return false 25116 } 25117 func rewriteValuegeneric_OpXor32_10(v *Value) bool { 25118 b := v.Block 25119 _ = b 25120 // match: (Xor32 (Xor32 z i:(Const32 <t>)) x) 25121 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 25122 // result: (Xor32 i (Xor32 <t> z x)) 25123 for { 25124 _ = v.Args[1] 25125 v_0 := v.Args[0] 25126 if v_0.Op != OpXor32 { 25127 break 25128 } 25129 _ = v_0.Args[1] 25130 z := v_0.Args[0] 25131 i := v_0.Args[1] 25132 if i.Op != OpConst32 { 25133 break 25134 } 25135 t := i.Type 25136 x := v.Args[1] 25137 if !(z.Op != OpConst32 && x.Op != OpConst32) { 25138 break 25139 } 25140 v.reset(OpXor32) 25141 v.AddArg(i) 25142 v0 := b.NewValue0(v.Pos, OpXor32, t) 25143 v0.AddArg(z) 25144 v0.AddArg(x) 25145 v.AddArg(v0) 25146 return true 25147 } 25148 // match: (Xor32 x (Xor32 i:(Const32 <t>) z)) 25149 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 25150 // result: (Xor32 i (Xor32 <t> z x)) 25151 for { 25152 _ = v.Args[1] 25153 x := v.Args[0] 25154 v_1 := v.Args[1] 25155 if v_1.Op != OpXor32 { 25156 break 25157 } 25158 _ = v_1.Args[1] 25159 i := v_1.Args[0] 25160 if i.Op != OpConst32 { 25161 break 25162 } 25163 t := i.Type 25164 z := v_1.Args[1] 25165 if !(z.Op != OpConst32 && x.Op != OpConst32) { 25166 break 25167 } 25168 v.reset(OpXor32) 25169 v.AddArg(i) 25170 v0 := b.NewValue0(v.Pos, OpXor32, t) 25171 v0.AddArg(z) 25172 v0.AddArg(x) 25173 v.AddArg(v0) 25174 return true 25175 } 25176 // match: (Xor32 x (Xor32 z i:(Const32 <t>))) 25177 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 25178 // result: (Xor32 i (Xor32 <t> z x)) 25179 for { 25180 _ = v.Args[1] 25181 x := v.Args[0] 25182 v_1 := v.Args[1] 25183 if v_1.Op != OpXor32 { 25184 break 25185 } 25186 _ = v_1.Args[1] 25187 z := v_1.Args[0] 25188 i := v_1.Args[1] 25189 if i.Op != OpConst32 { 25190 break 25191 } 25192 t := i.Type 25193 if !(z.Op != OpConst32 && x.Op != OpConst32) { 25194 break 25195 } 25196 v.reset(OpXor32) 25197 v.AddArg(i) 25198 v0 := b.NewValue0(v.Pos, OpXor32, t) 25199 v0.AddArg(z) 25200 v0.AddArg(x) 25201 v.AddArg(v0) 25202 return true 25203 } 25204 // match: (Xor32 (Const32 <t> [c]) (Xor32 (Const32 <t> [d]) x)) 25205 // cond: 25206 // result: (Xor32 (Const32 <t> [int64(int32(c^d))]) x) 25207 for { 25208 _ = v.Args[1] 25209 v_0 := v.Args[0] 25210 if v_0.Op != OpConst32 { 25211 break 25212 } 25213 t := v_0.Type 25214 c := v_0.AuxInt 25215 v_1 := v.Args[1] 25216 if v_1.Op != OpXor32 { 25217 break 25218 } 25219 _ = v_1.Args[1] 25220 v_1_0 := v_1.Args[0] 25221 if v_1_0.Op != OpConst32 { 25222 break 25223 } 25224 if v_1_0.Type != t { 25225 break 25226 } 25227 d := v_1_0.AuxInt 25228 x := v_1.Args[1] 25229 v.reset(OpXor32) 25230 v0 := b.NewValue0(v.Pos, OpConst32, t) 25231 v0.AuxInt = int64(int32(c ^ d)) 25232 v.AddArg(v0) 25233 v.AddArg(x) 25234 return true 25235 } 25236 // match: (Xor32 (Const32 <t> [c]) (Xor32 x (Const32 <t> [d]))) 25237 // cond: 25238 // result: (Xor32 (Const32 <t> [int64(int32(c^d))]) x) 25239 for { 25240 _ = v.Args[1] 25241 v_0 := v.Args[0] 25242 if v_0.Op != OpConst32 { 25243 break 25244 } 25245 t := v_0.Type 25246 c := v_0.AuxInt 25247 v_1 := v.Args[1] 25248 if v_1.Op != OpXor32 { 25249 break 25250 } 25251 _ = v_1.Args[1] 25252 x := v_1.Args[0] 25253 v_1_1 := v_1.Args[1] 25254 if v_1_1.Op != OpConst32 { 25255 break 25256 } 25257 if v_1_1.Type != t { 25258 break 25259 } 25260 d := v_1_1.AuxInt 25261 v.reset(OpXor32) 25262 v0 := b.NewValue0(v.Pos, OpConst32, t) 25263 v0.AuxInt = int64(int32(c ^ d)) 25264 v.AddArg(v0) 25265 v.AddArg(x) 25266 return true 25267 } 25268 // match: (Xor32 (Xor32 (Const32 <t> [d]) x) (Const32 <t> [c])) 25269 // cond: 25270 // result: (Xor32 (Const32 <t> [int64(int32(c^d))]) x) 25271 for { 25272 _ = v.Args[1] 25273 v_0 := v.Args[0] 25274 if v_0.Op != OpXor32 { 25275 break 25276 } 25277 _ = v_0.Args[1] 25278 v_0_0 := v_0.Args[0] 25279 if v_0_0.Op != OpConst32 { 25280 break 25281 } 25282 t := v_0_0.Type 25283 d := v_0_0.AuxInt 25284 x := v_0.Args[1] 25285 v_1 := v.Args[1] 25286 if v_1.Op != OpConst32 { 25287 break 25288 } 25289 if v_1.Type != t { 25290 break 25291 } 25292 c := v_1.AuxInt 25293 v.reset(OpXor32) 25294 v0 := b.NewValue0(v.Pos, OpConst32, t) 25295 v0.AuxInt = int64(int32(c ^ d)) 25296 v.AddArg(v0) 25297 v.AddArg(x) 25298 return true 25299 } 25300 // match: (Xor32 (Xor32 x (Const32 <t> [d])) (Const32 <t> [c])) 25301 // cond: 25302 // result: (Xor32 (Const32 <t> [int64(int32(c^d))]) x) 25303 for { 25304 _ = v.Args[1] 25305 v_0 := v.Args[0] 25306 if v_0.Op != OpXor32 { 25307 break 25308 } 25309 _ = v_0.Args[1] 25310 x := v_0.Args[0] 25311 v_0_1 := v_0.Args[1] 25312 if v_0_1.Op != OpConst32 { 25313 break 25314 } 25315 t := v_0_1.Type 25316 d := v_0_1.AuxInt 25317 v_1 := v.Args[1] 25318 if v_1.Op != OpConst32 { 25319 break 25320 } 25321 if v_1.Type != t { 25322 break 25323 } 25324 c := v_1.AuxInt 25325 v.reset(OpXor32) 25326 v0 := b.NewValue0(v.Pos, OpConst32, t) 25327 v0.AuxInt = int64(int32(c ^ d)) 25328 v.AddArg(v0) 25329 v.AddArg(x) 25330 return true 25331 } 25332 return false 25333 } 25334 func rewriteValuegeneric_OpXor64_0(v *Value) bool { 25335 b := v.Block 25336 _ = b 25337 // match: (Xor64 (Const64 [c]) (Const64 [d])) 25338 // cond: 25339 // result: (Const64 [c^d]) 25340 for { 25341 _ = v.Args[1] 25342 v_0 := v.Args[0] 25343 if v_0.Op != OpConst64 { 25344 break 25345 } 25346 c := v_0.AuxInt 25347 v_1 := v.Args[1] 25348 if v_1.Op != OpConst64 { 25349 break 25350 } 25351 d := v_1.AuxInt 25352 v.reset(OpConst64) 25353 v.AuxInt = c ^ d 25354 return true 25355 } 25356 // match: (Xor64 (Const64 [d]) (Const64 [c])) 25357 // cond: 25358 // result: (Const64 [c^d]) 25359 for { 25360 _ = v.Args[1] 25361 v_0 := v.Args[0] 25362 if v_0.Op != OpConst64 { 25363 break 25364 } 25365 d := v_0.AuxInt 25366 v_1 := v.Args[1] 25367 if v_1.Op != OpConst64 { 25368 break 25369 } 25370 c := v_1.AuxInt 25371 v.reset(OpConst64) 25372 v.AuxInt = c ^ d 25373 return true 25374 } 25375 // match: (Xor64 x x) 25376 // cond: 25377 // result: (Const64 [0]) 25378 for { 25379 _ = v.Args[1] 25380 x := v.Args[0] 25381 if x != v.Args[1] { 25382 break 25383 } 25384 v.reset(OpConst64) 25385 v.AuxInt = 0 25386 return true 25387 } 25388 // match: (Xor64 (Const64 [0]) x) 25389 // cond: 25390 // result: x 25391 for { 25392 _ = v.Args[1] 25393 v_0 := v.Args[0] 25394 if v_0.Op != OpConst64 { 25395 break 25396 } 25397 if v_0.AuxInt != 0 { 25398 break 25399 } 25400 x := v.Args[1] 25401 v.reset(OpCopy) 25402 v.Type = x.Type 25403 v.AddArg(x) 25404 return true 25405 } 25406 // match: (Xor64 x (Const64 [0])) 25407 // cond: 25408 // result: x 25409 for { 25410 _ = v.Args[1] 25411 x := v.Args[0] 25412 v_1 := v.Args[1] 25413 if v_1.Op != OpConst64 { 25414 break 25415 } 25416 if v_1.AuxInt != 0 { 25417 break 25418 } 25419 v.reset(OpCopy) 25420 v.Type = x.Type 25421 v.AddArg(x) 25422 return true 25423 } 25424 // match: (Xor64 x (Xor64 x y)) 25425 // cond: 25426 // result: y 25427 for { 25428 _ = v.Args[1] 25429 x := v.Args[0] 25430 v_1 := v.Args[1] 25431 if v_1.Op != OpXor64 { 25432 break 25433 } 25434 _ = v_1.Args[1] 25435 if x != v_1.Args[0] { 25436 break 25437 } 25438 y := v_1.Args[1] 25439 v.reset(OpCopy) 25440 v.Type = y.Type 25441 v.AddArg(y) 25442 return true 25443 } 25444 // match: (Xor64 x (Xor64 y x)) 25445 // cond: 25446 // result: y 25447 for { 25448 _ = v.Args[1] 25449 x := v.Args[0] 25450 v_1 := v.Args[1] 25451 if v_1.Op != OpXor64 { 25452 break 25453 } 25454 _ = v_1.Args[1] 25455 y := v_1.Args[0] 25456 if x != v_1.Args[1] { 25457 break 25458 } 25459 v.reset(OpCopy) 25460 v.Type = y.Type 25461 v.AddArg(y) 25462 return true 25463 } 25464 // match: (Xor64 (Xor64 x y) x) 25465 // cond: 25466 // result: y 25467 for { 25468 _ = v.Args[1] 25469 v_0 := v.Args[0] 25470 if v_0.Op != OpXor64 { 25471 break 25472 } 25473 _ = v_0.Args[1] 25474 x := v_0.Args[0] 25475 y := v_0.Args[1] 25476 if x != v.Args[1] { 25477 break 25478 } 25479 v.reset(OpCopy) 25480 v.Type = y.Type 25481 v.AddArg(y) 25482 return true 25483 } 25484 // match: (Xor64 (Xor64 y x) x) 25485 // cond: 25486 // result: y 25487 for { 25488 _ = v.Args[1] 25489 v_0 := v.Args[0] 25490 if v_0.Op != OpXor64 { 25491 break 25492 } 25493 _ = v_0.Args[1] 25494 y := v_0.Args[0] 25495 x := v_0.Args[1] 25496 if x != v.Args[1] { 25497 break 25498 } 25499 v.reset(OpCopy) 25500 v.Type = y.Type 25501 v.AddArg(y) 25502 return true 25503 } 25504 // match: (Xor64 (Xor64 i:(Const64 <t>) z) x) 25505 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 25506 // result: (Xor64 i (Xor64 <t> z x)) 25507 for { 25508 _ = v.Args[1] 25509 v_0 := v.Args[0] 25510 if v_0.Op != OpXor64 { 25511 break 25512 } 25513 _ = v_0.Args[1] 25514 i := v_0.Args[0] 25515 if i.Op != OpConst64 { 25516 break 25517 } 25518 t := i.Type 25519 z := v_0.Args[1] 25520 x := v.Args[1] 25521 if !(z.Op != OpConst64 && x.Op != OpConst64) { 25522 break 25523 } 25524 v.reset(OpXor64) 25525 v.AddArg(i) 25526 v0 := b.NewValue0(v.Pos, OpXor64, t) 25527 v0.AddArg(z) 25528 v0.AddArg(x) 25529 v.AddArg(v0) 25530 return true 25531 } 25532 return false 25533 } 25534 func rewriteValuegeneric_OpXor64_10(v *Value) bool { 25535 b := v.Block 25536 _ = b 25537 // match: (Xor64 (Xor64 z i:(Const64 <t>)) x) 25538 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 25539 // result: (Xor64 i (Xor64 <t> z x)) 25540 for { 25541 _ = v.Args[1] 25542 v_0 := v.Args[0] 25543 if v_0.Op != OpXor64 { 25544 break 25545 } 25546 _ = v_0.Args[1] 25547 z := v_0.Args[0] 25548 i := v_0.Args[1] 25549 if i.Op != OpConst64 { 25550 break 25551 } 25552 t := i.Type 25553 x := v.Args[1] 25554 if !(z.Op != OpConst64 && x.Op != OpConst64) { 25555 break 25556 } 25557 v.reset(OpXor64) 25558 v.AddArg(i) 25559 v0 := b.NewValue0(v.Pos, OpXor64, t) 25560 v0.AddArg(z) 25561 v0.AddArg(x) 25562 v.AddArg(v0) 25563 return true 25564 } 25565 // match: (Xor64 x (Xor64 i:(Const64 <t>) z)) 25566 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 25567 // result: (Xor64 i (Xor64 <t> z x)) 25568 for { 25569 _ = v.Args[1] 25570 x := v.Args[0] 25571 v_1 := v.Args[1] 25572 if v_1.Op != OpXor64 { 25573 break 25574 } 25575 _ = v_1.Args[1] 25576 i := v_1.Args[0] 25577 if i.Op != OpConst64 { 25578 break 25579 } 25580 t := i.Type 25581 z := v_1.Args[1] 25582 if !(z.Op != OpConst64 && x.Op != OpConst64) { 25583 break 25584 } 25585 v.reset(OpXor64) 25586 v.AddArg(i) 25587 v0 := b.NewValue0(v.Pos, OpXor64, t) 25588 v0.AddArg(z) 25589 v0.AddArg(x) 25590 v.AddArg(v0) 25591 return true 25592 } 25593 // match: (Xor64 x (Xor64 z i:(Const64 <t>))) 25594 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 25595 // result: (Xor64 i (Xor64 <t> z x)) 25596 for { 25597 _ = v.Args[1] 25598 x := v.Args[0] 25599 v_1 := v.Args[1] 25600 if v_1.Op != OpXor64 { 25601 break 25602 } 25603 _ = v_1.Args[1] 25604 z := v_1.Args[0] 25605 i := v_1.Args[1] 25606 if i.Op != OpConst64 { 25607 break 25608 } 25609 t := i.Type 25610 if !(z.Op != OpConst64 && x.Op != OpConst64) { 25611 break 25612 } 25613 v.reset(OpXor64) 25614 v.AddArg(i) 25615 v0 := b.NewValue0(v.Pos, OpXor64, t) 25616 v0.AddArg(z) 25617 v0.AddArg(x) 25618 v.AddArg(v0) 25619 return true 25620 } 25621 // match: (Xor64 (Const64 <t> [c]) (Xor64 (Const64 <t> [d]) x)) 25622 // cond: 25623 // result: (Xor64 (Const64 <t> [c^d]) x) 25624 for { 25625 _ = v.Args[1] 25626 v_0 := v.Args[0] 25627 if v_0.Op != OpConst64 { 25628 break 25629 } 25630 t := v_0.Type 25631 c := v_0.AuxInt 25632 v_1 := v.Args[1] 25633 if v_1.Op != OpXor64 { 25634 break 25635 } 25636 _ = v_1.Args[1] 25637 v_1_0 := v_1.Args[0] 25638 if v_1_0.Op != OpConst64 { 25639 break 25640 } 25641 if v_1_0.Type != t { 25642 break 25643 } 25644 d := v_1_0.AuxInt 25645 x := v_1.Args[1] 25646 v.reset(OpXor64) 25647 v0 := b.NewValue0(v.Pos, OpConst64, t) 25648 v0.AuxInt = c ^ d 25649 v.AddArg(v0) 25650 v.AddArg(x) 25651 return true 25652 } 25653 // match: (Xor64 (Const64 <t> [c]) (Xor64 x (Const64 <t> [d]))) 25654 // cond: 25655 // result: (Xor64 (Const64 <t> [c^d]) x) 25656 for { 25657 _ = v.Args[1] 25658 v_0 := v.Args[0] 25659 if v_0.Op != OpConst64 { 25660 break 25661 } 25662 t := v_0.Type 25663 c := v_0.AuxInt 25664 v_1 := v.Args[1] 25665 if v_1.Op != OpXor64 { 25666 break 25667 } 25668 _ = v_1.Args[1] 25669 x := v_1.Args[0] 25670 v_1_1 := v_1.Args[1] 25671 if v_1_1.Op != OpConst64 { 25672 break 25673 } 25674 if v_1_1.Type != t { 25675 break 25676 } 25677 d := v_1_1.AuxInt 25678 v.reset(OpXor64) 25679 v0 := b.NewValue0(v.Pos, OpConst64, t) 25680 v0.AuxInt = c ^ d 25681 v.AddArg(v0) 25682 v.AddArg(x) 25683 return true 25684 } 25685 // match: (Xor64 (Xor64 (Const64 <t> [d]) x) (Const64 <t> [c])) 25686 // cond: 25687 // result: (Xor64 (Const64 <t> [c^d]) x) 25688 for { 25689 _ = v.Args[1] 25690 v_0 := v.Args[0] 25691 if v_0.Op != OpXor64 { 25692 break 25693 } 25694 _ = v_0.Args[1] 25695 v_0_0 := v_0.Args[0] 25696 if v_0_0.Op != OpConst64 { 25697 break 25698 } 25699 t := v_0_0.Type 25700 d := v_0_0.AuxInt 25701 x := v_0.Args[1] 25702 v_1 := v.Args[1] 25703 if v_1.Op != OpConst64 { 25704 break 25705 } 25706 if v_1.Type != t { 25707 break 25708 } 25709 c := v_1.AuxInt 25710 v.reset(OpXor64) 25711 v0 := b.NewValue0(v.Pos, OpConst64, t) 25712 v0.AuxInt = c ^ d 25713 v.AddArg(v0) 25714 v.AddArg(x) 25715 return true 25716 } 25717 // match: (Xor64 (Xor64 x (Const64 <t> [d])) (Const64 <t> [c])) 25718 // cond: 25719 // result: (Xor64 (Const64 <t> [c^d]) x) 25720 for { 25721 _ = v.Args[1] 25722 v_0 := v.Args[0] 25723 if v_0.Op != OpXor64 { 25724 break 25725 } 25726 _ = v_0.Args[1] 25727 x := v_0.Args[0] 25728 v_0_1 := v_0.Args[1] 25729 if v_0_1.Op != OpConst64 { 25730 break 25731 } 25732 t := v_0_1.Type 25733 d := v_0_1.AuxInt 25734 v_1 := v.Args[1] 25735 if v_1.Op != OpConst64 { 25736 break 25737 } 25738 if v_1.Type != t { 25739 break 25740 } 25741 c := v_1.AuxInt 25742 v.reset(OpXor64) 25743 v0 := b.NewValue0(v.Pos, OpConst64, t) 25744 v0.AuxInt = c ^ d 25745 v.AddArg(v0) 25746 v.AddArg(x) 25747 return true 25748 } 25749 return false 25750 } 25751 func rewriteValuegeneric_OpXor8_0(v *Value) bool { 25752 b := v.Block 25753 _ = b 25754 // match: (Xor8 (Const8 [c]) (Const8 [d])) 25755 // cond: 25756 // result: (Const8 [int64(int8(c^d))]) 25757 for { 25758 _ = v.Args[1] 25759 v_0 := v.Args[0] 25760 if v_0.Op != OpConst8 { 25761 break 25762 } 25763 c := v_0.AuxInt 25764 v_1 := v.Args[1] 25765 if v_1.Op != OpConst8 { 25766 break 25767 } 25768 d := v_1.AuxInt 25769 v.reset(OpConst8) 25770 v.AuxInt = int64(int8(c ^ d)) 25771 return true 25772 } 25773 // match: (Xor8 (Const8 [d]) (Const8 [c])) 25774 // cond: 25775 // result: (Const8 [int64(int8(c^d))]) 25776 for { 25777 _ = v.Args[1] 25778 v_0 := v.Args[0] 25779 if v_0.Op != OpConst8 { 25780 break 25781 } 25782 d := v_0.AuxInt 25783 v_1 := v.Args[1] 25784 if v_1.Op != OpConst8 { 25785 break 25786 } 25787 c := v_1.AuxInt 25788 v.reset(OpConst8) 25789 v.AuxInt = int64(int8(c ^ d)) 25790 return true 25791 } 25792 // match: (Xor8 x x) 25793 // cond: 25794 // result: (Const8 [0]) 25795 for { 25796 _ = v.Args[1] 25797 x := v.Args[0] 25798 if x != v.Args[1] { 25799 break 25800 } 25801 v.reset(OpConst8) 25802 v.AuxInt = 0 25803 return true 25804 } 25805 // match: (Xor8 (Const8 [0]) x) 25806 // cond: 25807 // result: x 25808 for { 25809 _ = v.Args[1] 25810 v_0 := v.Args[0] 25811 if v_0.Op != OpConst8 { 25812 break 25813 } 25814 if v_0.AuxInt != 0 { 25815 break 25816 } 25817 x := v.Args[1] 25818 v.reset(OpCopy) 25819 v.Type = x.Type 25820 v.AddArg(x) 25821 return true 25822 } 25823 // match: (Xor8 x (Const8 [0])) 25824 // cond: 25825 // result: x 25826 for { 25827 _ = v.Args[1] 25828 x := v.Args[0] 25829 v_1 := v.Args[1] 25830 if v_1.Op != OpConst8 { 25831 break 25832 } 25833 if v_1.AuxInt != 0 { 25834 break 25835 } 25836 v.reset(OpCopy) 25837 v.Type = x.Type 25838 v.AddArg(x) 25839 return true 25840 } 25841 // match: (Xor8 x (Xor8 x y)) 25842 // cond: 25843 // result: y 25844 for { 25845 _ = v.Args[1] 25846 x := v.Args[0] 25847 v_1 := v.Args[1] 25848 if v_1.Op != OpXor8 { 25849 break 25850 } 25851 _ = v_1.Args[1] 25852 if x != v_1.Args[0] { 25853 break 25854 } 25855 y := v_1.Args[1] 25856 v.reset(OpCopy) 25857 v.Type = y.Type 25858 v.AddArg(y) 25859 return true 25860 } 25861 // match: (Xor8 x (Xor8 y x)) 25862 // cond: 25863 // result: y 25864 for { 25865 _ = v.Args[1] 25866 x := v.Args[0] 25867 v_1 := v.Args[1] 25868 if v_1.Op != OpXor8 { 25869 break 25870 } 25871 _ = v_1.Args[1] 25872 y := v_1.Args[0] 25873 if x != v_1.Args[1] { 25874 break 25875 } 25876 v.reset(OpCopy) 25877 v.Type = y.Type 25878 v.AddArg(y) 25879 return true 25880 } 25881 // match: (Xor8 (Xor8 x y) x) 25882 // cond: 25883 // result: y 25884 for { 25885 _ = v.Args[1] 25886 v_0 := v.Args[0] 25887 if v_0.Op != OpXor8 { 25888 break 25889 } 25890 _ = v_0.Args[1] 25891 x := v_0.Args[0] 25892 y := v_0.Args[1] 25893 if x != v.Args[1] { 25894 break 25895 } 25896 v.reset(OpCopy) 25897 v.Type = y.Type 25898 v.AddArg(y) 25899 return true 25900 } 25901 // match: (Xor8 (Xor8 y x) x) 25902 // cond: 25903 // result: y 25904 for { 25905 _ = v.Args[1] 25906 v_0 := v.Args[0] 25907 if v_0.Op != OpXor8 { 25908 break 25909 } 25910 _ = v_0.Args[1] 25911 y := v_0.Args[0] 25912 x := v_0.Args[1] 25913 if x != v.Args[1] { 25914 break 25915 } 25916 v.reset(OpCopy) 25917 v.Type = y.Type 25918 v.AddArg(y) 25919 return true 25920 } 25921 // match: (Xor8 (Xor8 i:(Const8 <t>) z) x) 25922 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 25923 // result: (Xor8 i (Xor8 <t> z x)) 25924 for { 25925 _ = v.Args[1] 25926 v_0 := v.Args[0] 25927 if v_0.Op != OpXor8 { 25928 break 25929 } 25930 _ = v_0.Args[1] 25931 i := v_0.Args[0] 25932 if i.Op != OpConst8 { 25933 break 25934 } 25935 t := i.Type 25936 z := v_0.Args[1] 25937 x := v.Args[1] 25938 if !(z.Op != OpConst8 && x.Op != OpConst8) { 25939 break 25940 } 25941 v.reset(OpXor8) 25942 v.AddArg(i) 25943 v0 := b.NewValue0(v.Pos, OpXor8, t) 25944 v0.AddArg(z) 25945 v0.AddArg(x) 25946 v.AddArg(v0) 25947 return true 25948 } 25949 return false 25950 } 25951 func rewriteValuegeneric_OpXor8_10(v *Value) bool { 25952 b := v.Block 25953 _ = b 25954 // match: (Xor8 (Xor8 z i:(Const8 <t>)) x) 25955 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 25956 // result: (Xor8 i (Xor8 <t> z x)) 25957 for { 25958 _ = v.Args[1] 25959 v_0 := v.Args[0] 25960 if v_0.Op != OpXor8 { 25961 break 25962 } 25963 _ = v_0.Args[1] 25964 z := v_0.Args[0] 25965 i := v_0.Args[1] 25966 if i.Op != OpConst8 { 25967 break 25968 } 25969 t := i.Type 25970 x := v.Args[1] 25971 if !(z.Op != OpConst8 && x.Op != OpConst8) { 25972 break 25973 } 25974 v.reset(OpXor8) 25975 v.AddArg(i) 25976 v0 := b.NewValue0(v.Pos, OpXor8, t) 25977 v0.AddArg(z) 25978 v0.AddArg(x) 25979 v.AddArg(v0) 25980 return true 25981 } 25982 // match: (Xor8 x (Xor8 i:(Const8 <t>) z)) 25983 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 25984 // result: (Xor8 i (Xor8 <t> z x)) 25985 for { 25986 _ = v.Args[1] 25987 x := v.Args[0] 25988 v_1 := v.Args[1] 25989 if v_1.Op != OpXor8 { 25990 break 25991 } 25992 _ = v_1.Args[1] 25993 i := v_1.Args[0] 25994 if i.Op != OpConst8 { 25995 break 25996 } 25997 t := i.Type 25998 z := v_1.Args[1] 25999 if !(z.Op != OpConst8 && x.Op != OpConst8) { 26000 break 26001 } 26002 v.reset(OpXor8) 26003 v.AddArg(i) 26004 v0 := b.NewValue0(v.Pos, OpXor8, t) 26005 v0.AddArg(z) 26006 v0.AddArg(x) 26007 v.AddArg(v0) 26008 return true 26009 } 26010 // match: (Xor8 x (Xor8 z i:(Const8 <t>))) 26011 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 26012 // result: (Xor8 i (Xor8 <t> z x)) 26013 for { 26014 _ = v.Args[1] 26015 x := v.Args[0] 26016 v_1 := v.Args[1] 26017 if v_1.Op != OpXor8 { 26018 break 26019 } 26020 _ = v_1.Args[1] 26021 z := v_1.Args[0] 26022 i := v_1.Args[1] 26023 if i.Op != OpConst8 { 26024 break 26025 } 26026 t := i.Type 26027 if !(z.Op != OpConst8 && x.Op != OpConst8) { 26028 break 26029 } 26030 v.reset(OpXor8) 26031 v.AddArg(i) 26032 v0 := b.NewValue0(v.Pos, OpXor8, t) 26033 v0.AddArg(z) 26034 v0.AddArg(x) 26035 v.AddArg(v0) 26036 return true 26037 } 26038 // match: (Xor8 (Const8 <t> [c]) (Xor8 (Const8 <t> [d]) x)) 26039 // cond: 26040 // result: (Xor8 (Const8 <t> [int64(int8(c^d))]) x) 26041 for { 26042 _ = v.Args[1] 26043 v_0 := v.Args[0] 26044 if v_0.Op != OpConst8 { 26045 break 26046 } 26047 t := v_0.Type 26048 c := v_0.AuxInt 26049 v_1 := v.Args[1] 26050 if v_1.Op != OpXor8 { 26051 break 26052 } 26053 _ = v_1.Args[1] 26054 v_1_0 := v_1.Args[0] 26055 if v_1_0.Op != OpConst8 { 26056 break 26057 } 26058 if v_1_0.Type != t { 26059 break 26060 } 26061 d := v_1_0.AuxInt 26062 x := v_1.Args[1] 26063 v.reset(OpXor8) 26064 v0 := b.NewValue0(v.Pos, OpConst8, t) 26065 v0.AuxInt = int64(int8(c ^ d)) 26066 v.AddArg(v0) 26067 v.AddArg(x) 26068 return true 26069 } 26070 // match: (Xor8 (Const8 <t> [c]) (Xor8 x (Const8 <t> [d]))) 26071 // cond: 26072 // result: (Xor8 (Const8 <t> [int64(int8(c^d))]) x) 26073 for { 26074 _ = v.Args[1] 26075 v_0 := v.Args[0] 26076 if v_0.Op != OpConst8 { 26077 break 26078 } 26079 t := v_0.Type 26080 c := v_0.AuxInt 26081 v_1 := v.Args[1] 26082 if v_1.Op != OpXor8 { 26083 break 26084 } 26085 _ = v_1.Args[1] 26086 x := v_1.Args[0] 26087 v_1_1 := v_1.Args[1] 26088 if v_1_1.Op != OpConst8 { 26089 break 26090 } 26091 if v_1_1.Type != t { 26092 break 26093 } 26094 d := v_1_1.AuxInt 26095 v.reset(OpXor8) 26096 v0 := b.NewValue0(v.Pos, OpConst8, t) 26097 v0.AuxInt = int64(int8(c ^ d)) 26098 v.AddArg(v0) 26099 v.AddArg(x) 26100 return true 26101 } 26102 // match: (Xor8 (Xor8 (Const8 <t> [d]) x) (Const8 <t> [c])) 26103 // cond: 26104 // result: (Xor8 (Const8 <t> [int64(int8(c^d))]) x) 26105 for { 26106 _ = v.Args[1] 26107 v_0 := v.Args[0] 26108 if v_0.Op != OpXor8 { 26109 break 26110 } 26111 _ = v_0.Args[1] 26112 v_0_0 := v_0.Args[0] 26113 if v_0_0.Op != OpConst8 { 26114 break 26115 } 26116 t := v_0_0.Type 26117 d := v_0_0.AuxInt 26118 x := v_0.Args[1] 26119 v_1 := v.Args[1] 26120 if v_1.Op != OpConst8 { 26121 break 26122 } 26123 if v_1.Type != t { 26124 break 26125 } 26126 c := v_1.AuxInt 26127 v.reset(OpXor8) 26128 v0 := b.NewValue0(v.Pos, OpConst8, t) 26129 v0.AuxInt = int64(int8(c ^ d)) 26130 v.AddArg(v0) 26131 v.AddArg(x) 26132 return true 26133 } 26134 // match: (Xor8 (Xor8 x (Const8 <t> [d])) (Const8 <t> [c])) 26135 // cond: 26136 // result: (Xor8 (Const8 <t> [int64(int8(c^d))]) x) 26137 for { 26138 _ = v.Args[1] 26139 v_0 := v.Args[0] 26140 if v_0.Op != OpXor8 { 26141 break 26142 } 26143 _ = v_0.Args[1] 26144 x := v_0.Args[0] 26145 v_0_1 := v_0.Args[1] 26146 if v_0_1.Op != OpConst8 { 26147 break 26148 } 26149 t := v_0_1.Type 26150 d := v_0_1.AuxInt 26151 v_1 := v.Args[1] 26152 if v_1.Op != OpConst8 { 26153 break 26154 } 26155 if v_1.Type != t { 26156 break 26157 } 26158 c := v_1.AuxInt 26159 v.reset(OpXor8) 26160 v0 := b.NewValue0(v.Pos, OpConst8, t) 26161 v0.AuxInt = int64(int8(c ^ d)) 26162 v.AddArg(v0) 26163 v.AddArg(x) 26164 return true 26165 } 26166 return false 26167 } 26168 func rewriteValuegeneric_OpZero_0(v *Value) bool { 26169 b := v.Block 26170 _ = b 26171 config := b.Func.Config 26172 _ = config 26173 // match: (Zero (Load (OffPtr [c] (SP)) mem) mem) 26174 // cond: mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize 26175 // result: mem 26176 for { 26177 _ = v.Args[1] 26178 v_0 := v.Args[0] 26179 if v_0.Op != OpLoad { 26180 break 26181 } 26182 _ = v_0.Args[1] 26183 v_0_0 := v_0.Args[0] 26184 if v_0_0.Op != OpOffPtr { 26185 break 26186 } 26187 c := v_0_0.AuxInt 26188 v_0_0_0 := v_0_0.Args[0] 26189 if v_0_0_0.Op != OpSP { 26190 break 26191 } 26192 mem := v_0.Args[1] 26193 if mem != v.Args[1] { 26194 break 26195 } 26196 if !(mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) { 26197 break 26198 } 26199 v.reset(OpCopy) 26200 v.Type = mem.Type 26201 v.AddArg(mem) 26202 return true 26203 } 26204 return false 26205 } 26206 func rewriteValuegeneric_OpZeroExt16to32_0(v *Value) bool { 26207 // match: (ZeroExt16to32 (Const16 [c])) 26208 // cond: 26209 // result: (Const32 [int64(uint16(c))]) 26210 for { 26211 v_0 := v.Args[0] 26212 if v_0.Op != OpConst16 { 26213 break 26214 } 26215 c := v_0.AuxInt 26216 v.reset(OpConst32) 26217 v.AuxInt = int64(uint16(c)) 26218 return true 26219 } 26220 // match: (ZeroExt16to32 (Trunc32to16 x:(Rsh32Ux64 _ (Const64 [s])))) 26221 // cond: s >= 16 26222 // result: x 26223 for { 26224 v_0 := v.Args[0] 26225 if v_0.Op != OpTrunc32to16 { 26226 break 26227 } 26228 x := v_0.Args[0] 26229 if x.Op != OpRsh32Ux64 { 26230 break 26231 } 26232 _ = x.Args[1] 26233 x_1 := x.Args[1] 26234 if x_1.Op != OpConst64 { 26235 break 26236 } 26237 s := x_1.AuxInt 26238 if !(s >= 16) { 26239 break 26240 } 26241 v.reset(OpCopy) 26242 v.Type = x.Type 26243 v.AddArg(x) 26244 return true 26245 } 26246 return false 26247 } 26248 func rewriteValuegeneric_OpZeroExt16to64_0(v *Value) bool { 26249 // match: (ZeroExt16to64 (Const16 [c])) 26250 // cond: 26251 // result: (Const64 [int64(uint16(c))]) 26252 for { 26253 v_0 := v.Args[0] 26254 if v_0.Op != OpConst16 { 26255 break 26256 } 26257 c := v_0.AuxInt 26258 v.reset(OpConst64) 26259 v.AuxInt = int64(uint16(c)) 26260 return true 26261 } 26262 // match: (ZeroExt16to64 (Trunc64to16 x:(Rsh64Ux64 _ (Const64 [s])))) 26263 // cond: s >= 48 26264 // result: x 26265 for { 26266 v_0 := v.Args[0] 26267 if v_0.Op != OpTrunc64to16 { 26268 break 26269 } 26270 x := v_0.Args[0] 26271 if x.Op != OpRsh64Ux64 { 26272 break 26273 } 26274 _ = x.Args[1] 26275 x_1 := x.Args[1] 26276 if x_1.Op != OpConst64 { 26277 break 26278 } 26279 s := x_1.AuxInt 26280 if !(s >= 48) { 26281 break 26282 } 26283 v.reset(OpCopy) 26284 v.Type = x.Type 26285 v.AddArg(x) 26286 return true 26287 } 26288 return false 26289 } 26290 func rewriteValuegeneric_OpZeroExt32to64_0(v *Value) bool { 26291 // match: (ZeroExt32to64 (Const32 [c])) 26292 // cond: 26293 // result: (Const64 [int64(uint32(c))]) 26294 for { 26295 v_0 := v.Args[0] 26296 if v_0.Op != OpConst32 { 26297 break 26298 } 26299 c := v_0.AuxInt 26300 v.reset(OpConst64) 26301 v.AuxInt = int64(uint32(c)) 26302 return true 26303 } 26304 // match: (ZeroExt32to64 (Trunc64to32 x:(Rsh64Ux64 _ (Const64 [s])))) 26305 // cond: s >= 32 26306 // result: x 26307 for { 26308 v_0 := v.Args[0] 26309 if v_0.Op != OpTrunc64to32 { 26310 break 26311 } 26312 x := v_0.Args[0] 26313 if x.Op != OpRsh64Ux64 { 26314 break 26315 } 26316 _ = x.Args[1] 26317 x_1 := x.Args[1] 26318 if x_1.Op != OpConst64 { 26319 break 26320 } 26321 s := x_1.AuxInt 26322 if !(s >= 32) { 26323 break 26324 } 26325 v.reset(OpCopy) 26326 v.Type = x.Type 26327 v.AddArg(x) 26328 return true 26329 } 26330 return false 26331 } 26332 func rewriteValuegeneric_OpZeroExt8to16_0(v *Value) bool { 26333 // match: (ZeroExt8to16 (Const8 [c])) 26334 // cond: 26335 // result: (Const16 [int64( uint8(c))]) 26336 for { 26337 v_0 := v.Args[0] 26338 if v_0.Op != OpConst8 { 26339 break 26340 } 26341 c := v_0.AuxInt 26342 v.reset(OpConst16) 26343 v.AuxInt = int64(uint8(c)) 26344 return true 26345 } 26346 // match: (ZeroExt8to16 (Trunc16to8 x:(Rsh16Ux64 _ (Const64 [s])))) 26347 // cond: s >= 8 26348 // result: x 26349 for { 26350 v_0 := v.Args[0] 26351 if v_0.Op != OpTrunc16to8 { 26352 break 26353 } 26354 x := v_0.Args[0] 26355 if x.Op != OpRsh16Ux64 { 26356 break 26357 } 26358 _ = x.Args[1] 26359 x_1 := x.Args[1] 26360 if x_1.Op != OpConst64 { 26361 break 26362 } 26363 s := x_1.AuxInt 26364 if !(s >= 8) { 26365 break 26366 } 26367 v.reset(OpCopy) 26368 v.Type = x.Type 26369 v.AddArg(x) 26370 return true 26371 } 26372 return false 26373 } 26374 func rewriteValuegeneric_OpZeroExt8to32_0(v *Value) bool { 26375 // match: (ZeroExt8to32 (Const8 [c])) 26376 // cond: 26377 // result: (Const32 [int64( uint8(c))]) 26378 for { 26379 v_0 := v.Args[0] 26380 if v_0.Op != OpConst8 { 26381 break 26382 } 26383 c := v_0.AuxInt 26384 v.reset(OpConst32) 26385 v.AuxInt = int64(uint8(c)) 26386 return true 26387 } 26388 // match: (ZeroExt8to32 (Trunc32to8 x:(Rsh32Ux64 _ (Const64 [s])))) 26389 // cond: s >= 24 26390 // result: x 26391 for { 26392 v_0 := v.Args[0] 26393 if v_0.Op != OpTrunc32to8 { 26394 break 26395 } 26396 x := v_0.Args[0] 26397 if x.Op != OpRsh32Ux64 { 26398 break 26399 } 26400 _ = x.Args[1] 26401 x_1 := x.Args[1] 26402 if x_1.Op != OpConst64 { 26403 break 26404 } 26405 s := x_1.AuxInt 26406 if !(s >= 24) { 26407 break 26408 } 26409 v.reset(OpCopy) 26410 v.Type = x.Type 26411 v.AddArg(x) 26412 return true 26413 } 26414 return false 26415 } 26416 func rewriteValuegeneric_OpZeroExt8to64_0(v *Value) bool { 26417 // match: (ZeroExt8to64 (Const8 [c])) 26418 // cond: 26419 // result: (Const64 [int64( uint8(c))]) 26420 for { 26421 v_0 := v.Args[0] 26422 if v_0.Op != OpConst8 { 26423 break 26424 } 26425 c := v_0.AuxInt 26426 v.reset(OpConst64) 26427 v.AuxInt = int64(uint8(c)) 26428 return true 26429 } 26430 // match: (ZeroExt8to64 (Trunc64to8 x:(Rsh64Ux64 _ (Const64 [s])))) 26431 // cond: s >= 56 26432 // result: x 26433 for { 26434 v_0 := v.Args[0] 26435 if v_0.Op != OpTrunc64to8 { 26436 break 26437 } 26438 x := v_0.Args[0] 26439 if x.Op != OpRsh64Ux64 { 26440 break 26441 } 26442 _ = x.Args[1] 26443 x_1 := x.Args[1] 26444 if x_1.Op != OpConst64 { 26445 break 26446 } 26447 s := x_1.AuxInt 26448 if !(s >= 56) { 26449 break 26450 } 26451 v.reset(OpCopy) 26452 v.Type = x.Type 26453 v.AddArg(x) 26454 return true 26455 } 26456 return false 26457 } 26458 func rewriteBlockgeneric(b *Block) bool { 26459 config := b.Func.Config 26460 _ = config 26461 fe := b.Func.fe 26462 _ = fe 26463 typ := &config.Types 26464 _ = typ 26465 switch b.Kind { 26466 case BlockIf: 26467 // match: (If (Not cond) yes no) 26468 // cond: 26469 // result: (If cond no yes) 26470 for { 26471 v := b.Control 26472 if v.Op != OpNot { 26473 break 26474 } 26475 cond := v.Args[0] 26476 b.Kind = BlockIf 26477 b.SetControl(cond) 26478 b.swapSuccessors() 26479 return true 26480 } 26481 // match: (If (ConstBool [c]) yes no) 26482 // cond: c == 1 26483 // result: (First nil yes no) 26484 for { 26485 v := b.Control 26486 if v.Op != OpConstBool { 26487 break 26488 } 26489 c := v.AuxInt 26490 if !(c == 1) { 26491 break 26492 } 26493 b.Kind = BlockFirst 26494 b.SetControl(nil) 26495 return true 26496 } 26497 // match: (If (ConstBool [c]) yes no) 26498 // cond: c == 0 26499 // result: (First nil no yes) 26500 for { 26501 v := b.Control 26502 if v.Op != OpConstBool { 26503 break 26504 } 26505 c := v.AuxInt 26506 if !(c == 0) { 26507 break 26508 } 26509 b.Kind = BlockFirst 26510 b.SetControl(nil) 26511 b.swapSuccessors() 26512 return true 26513 } 26514 } 26515 return false 26516 }