github.com/megatontech/mynoteforgo@v0.0.0-20200507084910-5d0c6ea6e890/源码/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 "fmt" 7 import "math" 8 import "cmd/internal/obj" 9 import "cmd/internal/objabi" 10 import "cmd/compile/internal/types" 11 12 var _ = fmt.Println // in case not otherwise used 13 var _ = math.MinInt8 // in case not otherwise used 14 var _ = obj.ANOP // in case not otherwise used 15 var _ = objabi.GOROOT // in case not otherwise used 16 var _ = types.TypeMem // in case not otherwise used 17 18 func rewriteValuegeneric(v *Value) bool { 19 switch v.Op { 20 case OpAdd16: 21 return rewriteValuegeneric_OpAdd16_0(v) || rewriteValuegeneric_OpAdd16_10(v) || rewriteValuegeneric_OpAdd16_20(v) || rewriteValuegeneric_OpAdd16_30(v) 22 case OpAdd32: 23 return rewriteValuegeneric_OpAdd32_0(v) || rewriteValuegeneric_OpAdd32_10(v) || rewriteValuegeneric_OpAdd32_20(v) || rewriteValuegeneric_OpAdd32_30(v) 24 case OpAdd32F: 25 return rewriteValuegeneric_OpAdd32F_0(v) 26 case OpAdd64: 27 return rewriteValuegeneric_OpAdd64_0(v) || rewriteValuegeneric_OpAdd64_10(v) || rewriteValuegeneric_OpAdd64_20(v) || rewriteValuegeneric_OpAdd64_30(v) 28 case OpAdd64F: 29 return rewriteValuegeneric_OpAdd64F_0(v) 30 case OpAdd8: 31 return rewriteValuegeneric_OpAdd8_0(v) || rewriteValuegeneric_OpAdd8_10(v) || rewriteValuegeneric_OpAdd8_20(v) || rewriteValuegeneric_OpAdd8_30(v) 32 case OpAddPtr: 33 return rewriteValuegeneric_OpAddPtr_0(v) 34 case OpAnd16: 35 return rewriteValuegeneric_OpAnd16_0(v) || rewriteValuegeneric_OpAnd16_10(v) || rewriteValuegeneric_OpAnd16_20(v) 36 case OpAnd32: 37 return rewriteValuegeneric_OpAnd32_0(v) || rewriteValuegeneric_OpAnd32_10(v) || rewriteValuegeneric_OpAnd32_20(v) 38 case OpAnd64: 39 return rewriteValuegeneric_OpAnd64_0(v) || rewriteValuegeneric_OpAnd64_10(v) || rewriteValuegeneric_OpAnd64_20(v) 40 case OpAnd8: 41 return rewriteValuegeneric_OpAnd8_0(v) || rewriteValuegeneric_OpAnd8_10(v) || rewriteValuegeneric_OpAnd8_20(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 OpCvt32Fto32: 61 return rewriteValuegeneric_OpCvt32Fto32_0(v) 62 case OpCvt32Fto64: 63 return rewriteValuegeneric_OpCvt32Fto64_0(v) 64 case OpCvt32Fto64F: 65 return rewriteValuegeneric_OpCvt32Fto64F_0(v) 66 case OpCvt32to32F: 67 return rewriteValuegeneric_OpCvt32to32F_0(v) 68 case OpCvt32to64F: 69 return rewriteValuegeneric_OpCvt32to64F_0(v) 70 case OpCvt64Fto32: 71 return rewriteValuegeneric_OpCvt64Fto32_0(v) 72 case OpCvt64Fto32F: 73 return rewriteValuegeneric_OpCvt64Fto32F_0(v) 74 case OpCvt64Fto64: 75 return rewriteValuegeneric_OpCvt64Fto64_0(v) 76 case OpCvt64to32F: 77 return rewriteValuegeneric_OpCvt64to32F_0(v) 78 case OpCvt64to64F: 79 return rewriteValuegeneric_OpCvt64to64F_0(v) 80 case OpDiv16: 81 return rewriteValuegeneric_OpDiv16_0(v) 82 case OpDiv16u: 83 return rewriteValuegeneric_OpDiv16u_0(v) 84 case OpDiv32: 85 return rewriteValuegeneric_OpDiv32_0(v) 86 case OpDiv32F: 87 return rewriteValuegeneric_OpDiv32F_0(v) 88 case OpDiv32u: 89 return rewriteValuegeneric_OpDiv32u_0(v) 90 case OpDiv64: 91 return rewriteValuegeneric_OpDiv64_0(v) 92 case OpDiv64F: 93 return rewriteValuegeneric_OpDiv64F_0(v) 94 case OpDiv64u: 95 return rewriteValuegeneric_OpDiv64u_0(v) 96 case OpDiv8: 97 return rewriteValuegeneric_OpDiv8_0(v) 98 case OpDiv8u: 99 return rewriteValuegeneric_OpDiv8u_0(v) 100 case OpEq16: 101 return rewriteValuegeneric_OpEq16_0(v) 102 case OpEq32: 103 return rewriteValuegeneric_OpEq32_0(v) 104 case OpEq32F: 105 return rewriteValuegeneric_OpEq32F_0(v) 106 case OpEq64: 107 return rewriteValuegeneric_OpEq64_0(v) 108 case OpEq64F: 109 return rewriteValuegeneric_OpEq64F_0(v) 110 case OpEq8: 111 return rewriteValuegeneric_OpEq8_0(v) 112 case OpEqB: 113 return rewriteValuegeneric_OpEqB_0(v) 114 case OpEqInter: 115 return rewriteValuegeneric_OpEqInter_0(v) 116 case OpEqPtr: 117 return rewriteValuegeneric_OpEqPtr_0(v) || rewriteValuegeneric_OpEqPtr_10(v) || rewriteValuegeneric_OpEqPtr_20(v) 118 case OpEqSlice: 119 return rewriteValuegeneric_OpEqSlice_0(v) 120 case OpGeq16: 121 return rewriteValuegeneric_OpGeq16_0(v) 122 case OpGeq16U: 123 return rewriteValuegeneric_OpGeq16U_0(v) 124 case OpGeq32: 125 return rewriteValuegeneric_OpGeq32_0(v) 126 case OpGeq32F: 127 return rewriteValuegeneric_OpGeq32F_0(v) 128 case OpGeq32U: 129 return rewriteValuegeneric_OpGeq32U_0(v) 130 case OpGeq64: 131 return rewriteValuegeneric_OpGeq64_0(v) 132 case OpGeq64F: 133 return rewriteValuegeneric_OpGeq64F_0(v) 134 case OpGeq64U: 135 return rewriteValuegeneric_OpGeq64U_0(v) 136 case OpGeq8: 137 return rewriteValuegeneric_OpGeq8_0(v) 138 case OpGeq8U: 139 return rewriteValuegeneric_OpGeq8U_0(v) 140 case OpGreater16: 141 return rewriteValuegeneric_OpGreater16_0(v) 142 case OpGreater16U: 143 return rewriteValuegeneric_OpGreater16U_0(v) 144 case OpGreater32: 145 return rewriteValuegeneric_OpGreater32_0(v) 146 case OpGreater32F: 147 return rewriteValuegeneric_OpGreater32F_0(v) 148 case OpGreater32U: 149 return rewriteValuegeneric_OpGreater32U_0(v) 150 case OpGreater64: 151 return rewriteValuegeneric_OpGreater64_0(v) 152 case OpGreater64F: 153 return rewriteValuegeneric_OpGreater64F_0(v) 154 case OpGreater64U: 155 return rewriteValuegeneric_OpGreater64U_0(v) 156 case OpGreater8: 157 return rewriteValuegeneric_OpGreater8_0(v) 158 case OpGreater8U: 159 return rewriteValuegeneric_OpGreater8U_0(v) 160 case OpIMake: 161 return rewriteValuegeneric_OpIMake_0(v) 162 case OpInterCall: 163 return rewriteValuegeneric_OpInterCall_0(v) 164 case OpIsInBounds: 165 return rewriteValuegeneric_OpIsInBounds_0(v) || rewriteValuegeneric_OpIsInBounds_10(v) || rewriteValuegeneric_OpIsInBounds_20(v) || rewriteValuegeneric_OpIsInBounds_30(v) 166 case OpIsNonNil: 167 return rewriteValuegeneric_OpIsNonNil_0(v) 168 case OpIsSliceInBounds: 169 return rewriteValuegeneric_OpIsSliceInBounds_0(v) 170 case OpLeq16: 171 return rewriteValuegeneric_OpLeq16_0(v) 172 case OpLeq16U: 173 return rewriteValuegeneric_OpLeq16U_0(v) 174 case OpLeq32: 175 return rewriteValuegeneric_OpLeq32_0(v) 176 case OpLeq32F: 177 return rewriteValuegeneric_OpLeq32F_0(v) 178 case OpLeq32U: 179 return rewriteValuegeneric_OpLeq32U_0(v) 180 case OpLeq64: 181 return rewriteValuegeneric_OpLeq64_0(v) 182 case OpLeq64F: 183 return rewriteValuegeneric_OpLeq64F_0(v) 184 case OpLeq64U: 185 return rewriteValuegeneric_OpLeq64U_0(v) 186 case OpLeq8: 187 return rewriteValuegeneric_OpLeq8_0(v) 188 case OpLeq8U: 189 return rewriteValuegeneric_OpLeq8U_0(v) 190 case OpLess16: 191 return rewriteValuegeneric_OpLess16_0(v) 192 case OpLess16U: 193 return rewriteValuegeneric_OpLess16U_0(v) 194 case OpLess32: 195 return rewriteValuegeneric_OpLess32_0(v) 196 case OpLess32F: 197 return rewriteValuegeneric_OpLess32F_0(v) 198 case OpLess32U: 199 return rewriteValuegeneric_OpLess32U_0(v) 200 case OpLess64: 201 return rewriteValuegeneric_OpLess64_0(v) 202 case OpLess64F: 203 return rewriteValuegeneric_OpLess64F_0(v) 204 case OpLess64U: 205 return rewriteValuegeneric_OpLess64U_0(v) 206 case OpLess8: 207 return rewriteValuegeneric_OpLess8_0(v) 208 case OpLess8U: 209 return rewriteValuegeneric_OpLess8U_0(v) 210 case OpLoad: 211 return rewriteValuegeneric_OpLoad_0(v) || rewriteValuegeneric_OpLoad_10(v) || rewriteValuegeneric_OpLoad_20(v) 212 case OpLsh16x16: 213 return rewriteValuegeneric_OpLsh16x16_0(v) 214 case OpLsh16x32: 215 return rewriteValuegeneric_OpLsh16x32_0(v) 216 case OpLsh16x64: 217 return rewriteValuegeneric_OpLsh16x64_0(v) 218 case OpLsh16x8: 219 return rewriteValuegeneric_OpLsh16x8_0(v) 220 case OpLsh32x16: 221 return rewriteValuegeneric_OpLsh32x16_0(v) 222 case OpLsh32x32: 223 return rewriteValuegeneric_OpLsh32x32_0(v) 224 case OpLsh32x64: 225 return rewriteValuegeneric_OpLsh32x64_0(v) 226 case OpLsh32x8: 227 return rewriteValuegeneric_OpLsh32x8_0(v) 228 case OpLsh64x16: 229 return rewriteValuegeneric_OpLsh64x16_0(v) 230 case OpLsh64x32: 231 return rewriteValuegeneric_OpLsh64x32_0(v) 232 case OpLsh64x64: 233 return rewriteValuegeneric_OpLsh64x64_0(v) 234 case OpLsh64x8: 235 return rewriteValuegeneric_OpLsh64x8_0(v) 236 case OpLsh8x16: 237 return rewriteValuegeneric_OpLsh8x16_0(v) 238 case OpLsh8x32: 239 return rewriteValuegeneric_OpLsh8x32_0(v) 240 case OpLsh8x64: 241 return rewriteValuegeneric_OpLsh8x64_0(v) 242 case OpLsh8x8: 243 return rewriteValuegeneric_OpLsh8x8_0(v) 244 case OpMod16: 245 return rewriteValuegeneric_OpMod16_0(v) 246 case OpMod16u: 247 return rewriteValuegeneric_OpMod16u_0(v) 248 case OpMod32: 249 return rewriteValuegeneric_OpMod32_0(v) 250 case OpMod32u: 251 return rewriteValuegeneric_OpMod32u_0(v) 252 case OpMod64: 253 return rewriteValuegeneric_OpMod64_0(v) 254 case OpMod64u: 255 return rewriteValuegeneric_OpMod64u_0(v) 256 case OpMod8: 257 return rewriteValuegeneric_OpMod8_0(v) 258 case OpMod8u: 259 return rewriteValuegeneric_OpMod8u_0(v) 260 case OpMove: 261 return rewriteValuegeneric_OpMove_0(v) || rewriteValuegeneric_OpMove_10(v) || rewriteValuegeneric_OpMove_20(v) 262 case OpMul16: 263 return rewriteValuegeneric_OpMul16_0(v) || rewriteValuegeneric_OpMul16_10(v) 264 case OpMul32: 265 return rewriteValuegeneric_OpMul32_0(v) || rewriteValuegeneric_OpMul32_10(v) 266 case OpMul32F: 267 return rewriteValuegeneric_OpMul32F_0(v) 268 case OpMul64: 269 return rewriteValuegeneric_OpMul64_0(v) || rewriteValuegeneric_OpMul64_10(v) 270 case OpMul64F: 271 return rewriteValuegeneric_OpMul64F_0(v) 272 case OpMul8: 273 return rewriteValuegeneric_OpMul8_0(v) || rewriteValuegeneric_OpMul8_10(v) 274 case OpNeg16: 275 return rewriteValuegeneric_OpNeg16_0(v) 276 case OpNeg32: 277 return rewriteValuegeneric_OpNeg32_0(v) 278 case OpNeg32F: 279 return rewriteValuegeneric_OpNeg32F_0(v) 280 case OpNeg64: 281 return rewriteValuegeneric_OpNeg64_0(v) 282 case OpNeg64F: 283 return rewriteValuegeneric_OpNeg64F_0(v) 284 case OpNeg8: 285 return rewriteValuegeneric_OpNeg8_0(v) 286 case OpNeq16: 287 return rewriteValuegeneric_OpNeq16_0(v) 288 case OpNeq32: 289 return rewriteValuegeneric_OpNeq32_0(v) 290 case OpNeq32F: 291 return rewriteValuegeneric_OpNeq32F_0(v) 292 case OpNeq64: 293 return rewriteValuegeneric_OpNeq64_0(v) 294 case OpNeq64F: 295 return rewriteValuegeneric_OpNeq64F_0(v) 296 case OpNeq8: 297 return rewriteValuegeneric_OpNeq8_0(v) 298 case OpNeqB: 299 return rewriteValuegeneric_OpNeqB_0(v) 300 case OpNeqInter: 301 return rewriteValuegeneric_OpNeqInter_0(v) 302 case OpNeqPtr: 303 return rewriteValuegeneric_OpNeqPtr_0(v) || rewriteValuegeneric_OpNeqPtr_10(v) || rewriteValuegeneric_OpNeqPtr_20(v) 304 case OpNeqSlice: 305 return rewriteValuegeneric_OpNeqSlice_0(v) 306 case OpNilCheck: 307 return rewriteValuegeneric_OpNilCheck_0(v) 308 case OpNot: 309 return rewriteValuegeneric_OpNot_0(v) || rewriteValuegeneric_OpNot_10(v) || rewriteValuegeneric_OpNot_20(v) || rewriteValuegeneric_OpNot_30(v) || rewriteValuegeneric_OpNot_40(v) 310 case OpOffPtr: 311 return rewriteValuegeneric_OpOffPtr_0(v) 312 case OpOr16: 313 return rewriteValuegeneric_OpOr16_0(v) || rewriteValuegeneric_OpOr16_10(v) || rewriteValuegeneric_OpOr16_20(v) 314 case OpOr32: 315 return rewriteValuegeneric_OpOr32_0(v) || rewriteValuegeneric_OpOr32_10(v) || rewriteValuegeneric_OpOr32_20(v) 316 case OpOr64: 317 return rewriteValuegeneric_OpOr64_0(v) || rewriteValuegeneric_OpOr64_10(v) || rewriteValuegeneric_OpOr64_20(v) 318 case OpOr8: 319 return rewriteValuegeneric_OpOr8_0(v) || rewriteValuegeneric_OpOr8_10(v) || rewriteValuegeneric_OpOr8_20(v) 320 case OpPhi: 321 return rewriteValuegeneric_OpPhi_0(v) 322 case OpPtrIndex: 323 return rewriteValuegeneric_OpPtrIndex_0(v) 324 case OpRound32F: 325 return rewriteValuegeneric_OpRound32F_0(v) 326 case OpRound64F: 327 return rewriteValuegeneric_OpRound64F_0(v) 328 case OpRsh16Ux16: 329 return rewriteValuegeneric_OpRsh16Ux16_0(v) 330 case OpRsh16Ux32: 331 return rewriteValuegeneric_OpRsh16Ux32_0(v) 332 case OpRsh16Ux64: 333 return rewriteValuegeneric_OpRsh16Ux64_0(v) 334 case OpRsh16Ux8: 335 return rewriteValuegeneric_OpRsh16Ux8_0(v) 336 case OpRsh16x16: 337 return rewriteValuegeneric_OpRsh16x16_0(v) 338 case OpRsh16x32: 339 return rewriteValuegeneric_OpRsh16x32_0(v) 340 case OpRsh16x64: 341 return rewriteValuegeneric_OpRsh16x64_0(v) 342 case OpRsh16x8: 343 return rewriteValuegeneric_OpRsh16x8_0(v) 344 case OpRsh32Ux16: 345 return rewriteValuegeneric_OpRsh32Ux16_0(v) 346 case OpRsh32Ux32: 347 return rewriteValuegeneric_OpRsh32Ux32_0(v) 348 case OpRsh32Ux64: 349 return rewriteValuegeneric_OpRsh32Ux64_0(v) 350 case OpRsh32Ux8: 351 return rewriteValuegeneric_OpRsh32Ux8_0(v) 352 case OpRsh32x16: 353 return rewriteValuegeneric_OpRsh32x16_0(v) 354 case OpRsh32x32: 355 return rewriteValuegeneric_OpRsh32x32_0(v) 356 case OpRsh32x64: 357 return rewriteValuegeneric_OpRsh32x64_0(v) 358 case OpRsh32x8: 359 return rewriteValuegeneric_OpRsh32x8_0(v) 360 case OpRsh64Ux16: 361 return rewriteValuegeneric_OpRsh64Ux16_0(v) 362 case OpRsh64Ux32: 363 return rewriteValuegeneric_OpRsh64Ux32_0(v) 364 case OpRsh64Ux64: 365 return rewriteValuegeneric_OpRsh64Ux64_0(v) 366 case OpRsh64Ux8: 367 return rewriteValuegeneric_OpRsh64Ux8_0(v) 368 case OpRsh64x16: 369 return rewriteValuegeneric_OpRsh64x16_0(v) 370 case OpRsh64x32: 371 return rewriteValuegeneric_OpRsh64x32_0(v) 372 case OpRsh64x64: 373 return rewriteValuegeneric_OpRsh64x64_0(v) 374 case OpRsh64x8: 375 return rewriteValuegeneric_OpRsh64x8_0(v) 376 case OpRsh8Ux16: 377 return rewriteValuegeneric_OpRsh8Ux16_0(v) 378 case OpRsh8Ux32: 379 return rewriteValuegeneric_OpRsh8Ux32_0(v) 380 case OpRsh8Ux64: 381 return rewriteValuegeneric_OpRsh8Ux64_0(v) 382 case OpRsh8Ux8: 383 return rewriteValuegeneric_OpRsh8Ux8_0(v) 384 case OpRsh8x16: 385 return rewriteValuegeneric_OpRsh8x16_0(v) 386 case OpRsh8x32: 387 return rewriteValuegeneric_OpRsh8x32_0(v) 388 case OpRsh8x64: 389 return rewriteValuegeneric_OpRsh8x64_0(v) 390 case OpRsh8x8: 391 return rewriteValuegeneric_OpRsh8x8_0(v) 392 case OpSignExt16to32: 393 return rewriteValuegeneric_OpSignExt16to32_0(v) 394 case OpSignExt16to64: 395 return rewriteValuegeneric_OpSignExt16to64_0(v) 396 case OpSignExt32to64: 397 return rewriteValuegeneric_OpSignExt32to64_0(v) 398 case OpSignExt8to16: 399 return rewriteValuegeneric_OpSignExt8to16_0(v) 400 case OpSignExt8to32: 401 return rewriteValuegeneric_OpSignExt8to32_0(v) 402 case OpSignExt8to64: 403 return rewriteValuegeneric_OpSignExt8to64_0(v) 404 case OpSliceCap: 405 return rewriteValuegeneric_OpSliceCap_0(v) 406 case OpSliceLen: 407 return rewriteValuegeneric_OpSliceLen_0(v) 408 case OpSlicePtr: 409 return rewriteValuegeneric_OpSlicePtr_0(v) 410 case OpSlicemask: 411 return rewriteValuegeneric_OpSlicemask_0(v) 412 case OpSqrt: 413 return rewriteValuegeneric_OpSqrt_0(v) 414 case OpStaticCall: 415 return rewriteValuegeneric_OpStaticCall_0(v) 416 case OpStore: 417 return rewriteValuegeneric_OpStore_0(v) || rewriteValuegeneric_OpStore_10(v) || rewriteValuegeneric_OpStore_20(v) 418 case OpStringLen: 419 return rewriteValuegeneric_OpStringLen_0(v) 420 case OpStringPtr: 421 return rewriteValuegeneric_OpStringPtr_0(v) 422 case OpStructSelect: 423 return rewriteValuegeneric_OpStructSelect_0(v) || rewriteValuegeneric_OpStructSelect_10(v) 424 case OpSub16: 425 return rewriteValuegeneric_OpSub16_0(v) || rewriteValuegeneric_OpSub16_10(v) 426 case OpSub32: 427 return rewriteValuegeneric_OpSub32_0(v) || rewriteValuegeneric_OpSub32_10(v) 428 case OpSub32F: 429 return rewriteValuegeneric_OpSub32F_0(v) 430 case OpSub64: 431 return rewriteValuegeneric_OpSub64_0(v) || rewriteValuegeneric_OpSub64_10(v) 432 case OpSub64F: 433 return rewriteValuegeneric_OpSub64F_0(v) 434 case OpSub8: 435 return rewriteValuegeneric_OpSub8_0(v) || rewriteValuegeneric_OpSub8_10(v) 436 case OpTrunc16to8: 437 return rewriteValuegeneric_OpTrunc16to8_0(v) 438 case OpTrunc32to16: 439 return rewriteValuegeneric_OpTrunc32to16_0(v) 440 case OpTrunc32to8: 441 return rewriteValuegeneric_OpTrunc32to8_0(v) 442 case OpTrunc64to16: 443 return rewriteValuegeneric_OpTrunc64to16_0(v) 444 case OpTrunc64to32: 445 return rewriteValuegeneric_OpTrunc64to32_0(v) 446 case OpTrunc64to8: 447 return rewriteValuegeneric_OpTrunc64to8_0(v) 448 case OpXor16: 449 return rewriteValuegeneric_OpXor16_0(v) || rewriteValuegeneric_OpXor16_10(v) 450 case OpXor32: 451 return rewriteValuegeneric_OpXor32_0(v) || rewriteValuegeneric_OpXor32_10(v) 452 case OpXor64: 453 return rewriteValuegeneric_OpXor64_0(v) || rewriteValuegeneric_OpXor64_10(v) 454 case OpXor8: 455 return rewriteValuegeneric_OpXor8_0(v) || rewriteValuegeneric_OpXor8_10(v) 456 case OpZero: 457 return rewriteValuegeneric_OpZero_0(v) 458 case OpZeroExt16to32: 459 return rewriteValuegeneric_OpZeroExt16to32_0(v) 460 case OpZeroExt16to64: 461 return rewriteValuegeneric_OpZeroExt16to64_0(v) 462 case OpZeroExt32to64: 463 return rewriteValuegeneric_OpZeroExt32to64_0(v) 464 case OpZeroExt8to16: 465 return rewriteValuegeneric_OpZeroExt8to16_0(v) 466 case OpZeroExt8to32: 467 return rewriteValuegeneric_OpZeroExt8to32_0(v) 468 case OpZeroExt8to64: 469 return rewriteValuegeneric_OpZeroExt8to64_0(v) 470 } 471 return false 472 } 473 func rewriteValuegeneric_OpAdd16_0(v *Value) bool { 474 b := v.Block 475 _ = b 476 // match: (Add16 (Const16 [c]) (Const16 [d])) 477 // cond: 478 // result: (Const16 [int64(int16(c+d))]) 479 for { 480 _ = v.Args[1] 481 v_0 := v.Args[0] 482 if v_0.Op != OpConst16 { 483 break 484 } 485 c := v_0.AuxInt 486 v_1 := v.Args[1] 487 if v_1.Op != OpConst16 { 488 break 489 } 490 d := v_1.AuxInt 491 v.reset(OpConst16) 492 v.AuxInt = int64(int16(c + d)) 493 return true 494 } 495 // match: (Add16 (Const16 [d]) (Const16 [c])) 496 // cond: 497 // result: (Const16 [int64(int16(c+d))]) 498 for { 499 _ = v.Args[1] 500 v_0 := v.Args[0] 501 if v_0.Op != OpConst16 { 502 break 503 } 504 d := v_0.AuxInt 505 v_1 := v.Args[1] 506 if v_1.Op != OpConst16 { 507 break 508 } 509 c := v_1.AuxInt 510 v.reset(OpConst16) 511 v.AuxInt = int64(int16(c + d)) 512 return true 513 } 514 // match: (Add16 <t> (Mul16 x y) (Mul16 x z)) 515 // cond: 516 // result: (Mul16 x (Add16 <t> y z)) 517 for { 518 t := v.Type 519 _ = v.Args[1] 520 v_0 := v.Args[0] 521 if v_0.Op != OpMul16 { 522 break 523 } 524 _ = v_0.Args[1] 525 x := v_0.Args[0] 526 y := v_0.Args[1] 527 v_1 := v.Args[1] 528 if v_1.Op != OpMul16 { 529 break 530 } 531 _ = v_1.Args[1] 532 if x != v_1.Args[0] { 533 break 534 } 535 z := v_1.Args[1] 536 v.reset(OpMul16) 537 v.AddArg(x) 538 v0 := b.NewValue0(v.Pos, OpAdd16, t) 539 v0.AddArg(y) 540 v0.AddArg(z) 541 v.AddArg(v0) 542 return true 543 } 544 // match: (Add16 <t> (Mul16 y x) (Mul16 x z)) 545 // cond: 546 // result: (Mul16 x (Add16 <t> y z)) 547 for { 548 t := v.Type 549 _ = v.Args[1] 550 v_0 := v.Args[0] 551 if v_0.Op != OpMul16 { 552 break 553 } 554 _ = v_0.Args[1] 555 y := v_0.Args[0] 556 x := v_0.Args[1] 557 v_1 := v.Args[1] 558 if v_1.Op != OpMul16 { 559 break 560 } 561 _ = v_1.Args[1] 562 if x != v_1.Args[0] { 563 break 564 } 565 z := v_1.Args[1] 566 v.reset(OpMul16) 567 v.AddArg(x) 568 v0 := b.NewValue0(v.Pos, OpAdd16, t) 569 v0.AddArg(y) 570 v0.AddArg(z) 571 v.AddArg(v0) 572 return true 573 } 574 // match: (Add16 <t> (Mul16 x y) (Mul16 z x)) 575 // cond: 576 // result: (Mul16 x (Add16 <t> y z)) 577 for { 578 t := v.Type 579 _ = v.Args[1] 580 v_0 := v.Args[0] 581 if v_0.Op != OpMul16 { 582 break 583 } 584 _ = v_0.Args[1] 585 x := v_0.Args[0] 586 y := v_0.Args[1] 587 v_1 := v.Args[1] 588 if v_1.Op != OpMul16 { 589 break 590 } 591 _ = v_1.Args[1] 592 z := v_1.Args[0] 593 if x != v_1.Args[1] { 594 break 595 } 596 v.reset(OpMul16) 597 v.AddArg(x) 598 v0 := b.NewValue0(v.Pos, OpAdd16, t) 599 v0.AddArg(y) 600 v0.AddArg(z) 601 v.AddArg(v0) 602 return true 603 } 604 // match: (Add16 <t> (Mul16 y x) (Mul16 z x)) 605 // cond: 606 // result: (Mul16 x (Add16 <t> y z)) 607 for { 608 t := v.Type 609 _ = v.Args[1] 610 v_0 := v.Args[0] 611 if v_0.Op != OpMul16 { 612 break 613 } 614 _ = v_0.Args[1] 615 y := v_0.Args[0] 616 x := v_0.Args[1] 617 v_1 := v.Args[1] 618 if v_1.Op != OpMul16 { 619 break 620 } 621 _ = v_1.Args[1] 622 z := v_1.Args[0] 623 if x != v_1.Args[1] { 624 break 625 } 626 v.reset(OpMul16) 627 v.AddArg(x) 628 v0 := b.NewValue0(v.Pos, OpAdd16, t) 629 v0.AddArg(y) 630 v0.AddArg(z) 631 v.AddArg(v0) 632 return true 633 } 634 // match: (Add16 <t> (Mul16 x z) (Mul16 x y)) 635 // cond: 636 // result: (Mul16 x (Add16 <t> y z)) 637 for { 638 t := v.Type 639 _ = v.Args[1] 640 v_0 := v.Args[0] 641 if v_0.Op != OpMul16 { 642 break 643 } 644 _ = v_0.Args[1] 645 x := v_0.Args[0] 646 z := v_0.Args[1] 647 v_1 := v.Args[1] 648 if v_1.Op != OpMul16 { 649 break 650 } 651 _ = v_1.Args[1] 652 if x != v_1.Args[0] { 653 break 654 } 655 y := v_1.Args[1] 656 v.reset(OpMul16) 657 v.AddArg(x) 658 v0 := b.NewValue0(v.Pos, OpAdd16, t) 659 v0.AddArg(y) 660 v0.AddArg(z) 661 v.AddArg(v0) 662 return true 663 } 664 // match: (Add16 <t> (Mul16 z x) (Mul16 x y)) 665 // cond: 666 // result: (Mul16 x (Add16 <t> y z)) 667 for { 668 t := v.Type 669 _ = v.Args[1] 670 v_0 := v.Args[0] 671 if v_0.Op != OpMul16 { 672 break 673 } 674 _ = v_0.Args[1] 675 z := v_0.Args[0] 676 x := v_0.Args[1] 677 v_1 := v.Args[1] 678 if v_1.Op != OpMul16 { 679 break 680 } 681 _ = v_1.Args[1] 682 if x != v_1.Args[0] { 683 break 684 } 685 y := v_1.Args[1] 686 v.reset(OpMul16) 687 v.AddArg(x) 688 v0 := b.NewValue0(v.Pos, OpAdd16, t) 689 v0.AddArg(y) 690 v0.AddArg(z) 691 v.AddArg(v0) 692 return true 693 } 694 // match: (Add16 <t> (Mul16 x z) (Mul16 y x)) 695 // cond: 696 // result: (Mul16 x (Add16 <t> y z)) 697 for { 698 t := v.Type 699 _ = v.Args[1] 700 v_0 := v.Args[0] 701 if v_0.Op != OpMul16 { 702 break 703 } 704 _ = v_0.Args[1] 705 x := v_0.Args[0] 706 z := v_0.Args[1] 707 v_1 := v.Args[1] 708 if v_1.Op != OpMul16 { 709 break 710 } 711 _ = v_1.Args[1] 712 y := v_1.Args[0] 713 if x != v_1.Args[1] { 714 break 715 } 716 v.reset(OpMul16) 717 v.AddArg(x) 718 v0 := b.NewValue0(v.Pos, OpAdd16, t) 719 v0.AddArg(y) 720 v0.AddArg(z) 721 v.AddArg(v0) 722 return true 723 } 724 // match: (Add16 <t> (Mul16 z x) (Mul16 y x)) 725 // cond: 726 // result: (Mul16 x (Add16 <t> y z)) 727 for { 728 t := v.Type 729 _ = v.Args[1] 730 v_0 := v.Args[0] 731 if v_0.Op != OpMul16 { 732 break 733 } 734 _ = v_0.Args[1] 735 z := v_0.Args[0] 736 x := v_0.Args[1] 737 v_1 := v.Args[1] 738 if v_1.Op != OpMul16 { 739 break 740 } 741 _ = v_1.Args[1] 742 y := v_1.Args[0] 743 if x != v_1.Args[1] { 744 break 745 } 746 v.reset(OpMul16) 747 v.AddArg(x) 748 v0 := b.NewValue0(v.Pos, OpAdd16, t) 749 v0.AddArg(y) 750 v0.AddArg(z) 751 v.AddArg(v0) 752 return true 753 } 754 return false 755 } 756 func rewriteValuegeneric_OpAdd16_10(v *Value) bool { 757 b := v.Block 758 _ = b 759 // match: (Add16 (Const16 [0]) x) 760 // cond: 761 // result: x 762 for { 763 _ = v.Args[1] 764 v_0 := v.Args[0] 765 if v_0.Op != OpConst16 { 766 break 767 } 768 if v_0.AuxInt != 0 { 769 break 770 } 771 x := v.Args[1] 772 v.reset(OpCopy) 773 v.Type = x.Type 774 v.AddArg(x) 775 return true 776 } 777 // match: (Add16 x (Const16 [0])) 778 // cond: 779 // result: x 780 for { 781 _ = v.Args[1] 782 x := v.Args[0] 783 v_1 := v.Args[1] 784 if v_1.Op != OpConst16 { 785 break 786 } 787 if v_1.AuxInt != 0 { 788 break 789 } 790 v.reset(OpCopy) 791 v.Type = x.Type 792 v.AddArg(x) 793 return true 794 } 795 // match: (Add16 (Const16 [1]) (Com16 x)) 796 // cond: 797 // result: (Neg16 x) 798 for { 799 _ = v.Args[1] 800 v_0 := v.Args[0] 801 if v_0.Op != OpConst16 { 802 break 803 } 804 if v_0.AuxInt != 1 { 805 break 806 } 807 v_1 := v.Args[1] 808 if v_1.Op != OpCom16 { 809 break 810 } 811 x := v_1.Args[0] 812 v.reset(OpNeg16) 813 v.AddArg(x) 814 return true 815 } 816 // match: (Add16 (Com16 x) (Const16 [1])) 817 // cond: 818 // result: (Neg16 x) 819 for { 820 _ = v.Args[1] 821 v_0 := v.Args[0] 822 if v_0.Op != OpCom16 { 823 break 824 } 825 x := v_0.Args[0] 826 v_1 := v.Args[1] 827 if v_1.Op != OpConst16 { 828 break 829 } 830 if v_1.AuxInt != 1 { 831 break 832 } 833 v.reset(OpNeg16) 834 v.AddArg(x) 835 return true 836 } 837 // match: (Add16 (Add16 i:(Const16 <t>) z) x) 838 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 839 // result: (Add16 i (Add16 <t> z x)) 840 for { 841 _ = v.Args[1] 842 v_0 := v.Args[0] 843 if v_0.Op != OpAdd16 { 844 break 845 } 846 _ = v_0.Args[1] 847 i := v_0.Args[0] 848 if i.Op != OpConst16 { 849 break 850 } 851 t := i.Type 852 z := v_0.Args[1] 853 x := v.Args[1] 854 if !(z.Op != OpConst16 && x.Op != OpConst16) { 855 break 856 } 857 v.reset(OpAdd16) 858 v.AddArg(i) 859 v0 := b.NewValue0(v.Pos, OpAdd16, t) 860 v0.AddArg(z) 861 v0.AddArg(x) 862 v.AddArg(v0) 863 return true 864 } 865 // match: (Add16 (Add16 z i:(Const16 <t>)) x) 866 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 867 // result: (Add16 i (Add16 <t> z x)) 868 for { 869 _ = v.Args[1] 870 v_0 := v.Args[0] 871 if v_0.Op != OpAdd16 { 872 break 873 } 874 _ = v_0.Args[1] 875 z := v_0.Args[0] 876 i := v_0.Args[1] 877 if i.Op != OpConst16 { 878 break 879 } 880 t := i.Type 881 x := v.Args[1] 882 if !(z.Op != OpConst16 && x.Op != OpConst16) { 883 break 884 } 885 v.reset(OpAdd16) 886 v.AddArg(i) 887 v0 := b.NewValue0(v.Pos, OpAdd16, t) 888 v0.AddArg(z) 889 v0.AddArg(x) 890 v.AddArg(v0) 891 return true 892 } 893 // match: (Add16 x (Add16 i:(Const16 <t>) z)) 894 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 895 // result: (Add16 i (Add16 <t> z x)) 896 for { 897 _ = v.Args[1] 898 x := v.Args[0] 899 v_1 := v.Args[1] 900 if v_1.Op != OpAdd16 { 901 break 902 } 903 _ = v_1.Args[1] 904 i := v_1.Args[0] 905 if i.Op != OpConst16 { 906 break 907 } 908 t := i.Type 909 z := v_1.Args[1] 910 if !(z.Op != OpConst16 && x.Op != OpConst16) { 911 break 912 } 913 v.reset(OpAdd16) 914 v.AddArg(i) 915 v0 := b.NewValue0(v.Pos, OpAdd16, t) 916 v0.AddArg(z) 917 v0.AddArg(x) 918 v.AddArg(v0) 919 return true 920 } 921 // match: (Add16 x (Add16 z i:(Const16 <t>))) 922 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 923 // result: (Add16 i (Add16 <t> z x)) 924 for { 925 _ = v.Args[1] 926 x := v.Args[0] 927 v_1 := v.Args[1] 928 if v_1.Op != OpAdd16 { 929 break 930 } 931 _ = v_1.Args[1] 932 z := v_1.Args[0] 933 i := v_1.Args[1] 934 if i.Op != OpConst16 { 935 break 936 } 937 t := i.Type 938 if !(z.Op != OpConst16 && x.Op != OpConst16) { 939 break 940 } 941 v.reset(OpAdd16) 942 v.AddArg(i) 943 v0 := b.NewValue0(v.Pos, OpAdd16, t) 944 v0.AddArg(z) 945 v0.AddArg(x) 946 v.AddArg(v0) 947 return true 948 } 949 // match: (Add16 (Sub16 i:(Const16 <t>) z) x) 950 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 951 // result: (Add16 i (Sub16 <t> x z)) 952 for { 953 _ = v.Args[1] 954 v_0 := v.Args[0] 955 if v_0.Op != OpSub16 { 956 break 957 } 958 _ = v_0.Args[1] 959 i := v_0.Args[0] 960 if i.Op != OpConst16 { 961 break 962 } 963 t := i.Type 964 z := v_0.Args[1] 965 x := v.Args[1] 966 if !(z.Op != OpConst16 && x.Op != OpConst16) { 967 break 968 } 969 v.reset(OpAdd16) 970 v.AddArg(i) 971 v0 := b.NewValue0(v.Pos, OpSub16, t) 972 v0.AddArg(x) 973 v0.AddArg(z) 974 v.AddArg(v0) 975 return true 976 } 977 // match: (Add16 x (Sub16 i:(Const16 <t>) z)) 978 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 979 // result: (Add16 i (Sub16 <t> x z)) 980 for { 981 _ = v.Args[1] 982 x := v.Args[0] 983 v_1 := v.Args[1] 984 if v_1.Op != OpSub16 { 985 break 986 } 987 _ = v_1.Args[1] 988 i := v_1.Args[0] 989 if i.Op != OpConst16 { 990 break 991 } 992 t := i.Type 993 z := v_1.Args[1] 994 if !(z.Op != OpConst16 && x.Op != OpConst16) { 995 break 996 } 997 v.reset(OpAdd16) 998 v.AddArg(i) 999 v0 := b.NewValue0(v.Pos, OpSub16, t) 1000 v0.AddArg(x) 1001 v0.AddArg(z) 1002 v.AddArg(v0) 1003 return true 1004 } 1005 return false 1006 } 1007 func rewriteValuegeneric_OpAdd16_20(v *Value) bool { 1008 b := v.Block 1009 _ = b 1010 // match: (Add16 x (Sub16 i:(Const16 <t>) z)) 1011 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 1012 // result: (Add16 i (Sub16 <t> x z)) 1013 for { 1014 _ = v.Args[1] 1015 x := v.Args[0] 1016 v_1 := v.Args[1] 1017 if v_1.Op != OpSub16 { 1018 break 1019 } 1020 _ = v_1.Args[1] 1021 i := v_1.Args[0] 1022 if i.Op != OpConst16 { 1023 break 1024 } 1025 t := i.Type 1026 z := v_1.Args[1] 1027 if !(z.Op != OpConst16 && x.Op != OpConst16) { 1028 break 1029 } 1030 v.reset(OpAdd16) 1031 v.AddArg(i) 1032 v0 := b.NewValue0(v.Pos, OpSub16, t) 1033 v0.AddArg(x) 1034 v0.AddArg(z) 1035 v.AddArg(v0) 1036 return true 1037 } 1038 // match: (Add16 (Sub16 i:(Const16 <t>) z) x) 1039 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 1040 // result: (Add16 i (Sub16 <t> x z)) 1041 for { 1042 _ = v.Args[1] 1043 v_0 := v.Args[0] 1044 if v_0.Op != OpSub16 { 1045 break 1046 } 1047 _ = v_0.Args[1] 1048 i := v_0.Args[0] 1049 if i.Op != OpConst16 { 1050 break 1051 } 1052 t := i.Type 1053 z := v_0.Args[1] 1054 x := v.Args[1] 1055 if !(z.Op != OpConst16 && x.Op != OpConst16) { 1056 break 1057 } 1058 v.reset(OpAdd16) 1059 v.AddArg(i) 1060 v0 := b.NewValue0(v.Pos, OpSub16, t) 1061 v0.AddArg(x) 1062 v0.AddArg(z) 1063 v.AddArg(v0) 1064 return true 1065 } 1066 // match: (Add16 (Sub16 z i:(Const16 <t>)) x) 1067 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 1068 // result: (Sub16 (Add16 <t> x z) i) 1069 for { 1070 _ = v.Args[1] 1071 v_0 := v.Args[0] 1072 if v_0.Op != OpSub16 { 1073 break 1074 } 1075 _ = v_0.Args[1] 1076 z := v_0.Args[0] 1077 i := v_0.Args[1] 1078 if i.Op != OpConst16 { 1079 break 1080 } 1081 t := i.Type 1082 x := v.Args[1] 1083 if !(z.Op != OpConst16 && x.Op != OpConst16) { 1084 break 1085 } 1086 v.reset(OpSub16) 1087 v0 := b.NewValue0(v.Pos, OpAdd16, t) 1088 v0.AddArg(x) 1089 v0.AddArg(z) 1090 v.AddArg(v0) 1091 v.AddArg(i) 1092 return true 1093 } 1094 // match: (Add16 x (Sub16 z i:(Const16 <t>))) 1095 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 1096 // result: (Sub16 (Add16 <t> x z) i) 1097 for { 1098 _ = v.Args[1] 1099 x := v.Args[0] 1100 v_1 := v.Args[1] 1101 if v_1.Op != OpSub16 { 1102 break 1103 } 1104 _ = v_1.Args[1] 1105 z := v_1.Args[0] 1106 i := v_1.Args[1] 1107 if i.Op != OpConst16 { 1108 break 1109 } 1110 t := i.Type 1111 if !(z.Op != OpConst16 && x.Op != OpConst16) { 1112 break 1113 } 1114 v.reset(OpSub16) 1115 v0 := b.NewValue0(v.Pos, OpAdd16, t) 1116 v0.AddArg(x) 1117 v0.AddArg(z) 1118 v.AddArg(v0) 1119 v.AddArg(i) 1120 return true 1121 } 1122 // match: (Add16 x (Sub16 z i:(Const16 <t>))) 1123 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 1124 // result: (Sub16 (Add16 <t> x z) i) 1125 for { 1126 _ = v.Args[1] 1127 x := v.Args[0] 1128 v_1 := v.Args[1] 1129 if v_1.Op != OpSub16 { 1130 break 1131 } 1132 _ = v_1.Args[1] 1133 z := v_1.Args[0] 1134 i := v_1.Args[1] 1135 if i.Op != OpConst16 { 1136 break 1137 } 1138 t := i.Type 1139 if !(z.Op != OpConst16 && x.Op != OpConst16) { 1140 break 1141 } 1142 v.reset(OpSub16) 1143 v0 := b.NewValue0(v.Pos, OpAdd16, t) 1144 v0.AddArg(x) 1145 v0.AddArg(z) 1146 v.AddArg(v0) 1147 v.AddArg(i) 1148 return true 1149 } 1150 // match: (Add16 (Sub16 z i:(Const16 <t>)) x) 1151 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 1152 // result: (Sub16 (Add16 <t> x z) i) 1153 for { 1154 _ = v.Args[1] 1155 v_0 := v.Args[0] 1156 if v_0.Op != OpSub16 { 1157 break 1158 } 1159 _ = v_0.Args[1] 1160 z := v_0.Args[0] 1161 i := v_0.Args[1] 1162 if i.Op != OpConst16 { 1163 break 1164 } 1165 t := i.Type 1166 x := v.Args[1] 1167 if !(z.Op != OpConst16 && x.Op != OpConst16) { 1168 break 1169 } 1170 v.reset(OpSub16) 1171 v0 := b.NewValue0(v.Pos, OpAdd16, t) 1172 v0.AddArg(x) 1173 v0.AddArg(z) 1174 v.AddArg(v0) 1175 v.AddArg(i) 1176 return true 1177 } 1178 // match: (Add16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x)) 1179 // cond: 1180 // result: (Add16 (Const16 <t> [int64(int16(c+d))]) x) 1181 for { 1182 _ = v.Args[1] 1183 v_0 := v.Args[0] 1184 if v_0.Op != OpConst16 { 1185 break 1186 } 1187 t := v_0.Type 1188 c := v_0.AuxInt 1189 v_1 := v.Args[1] 1190 if v_1.Op != OpAdd16 { 1191 break 1192 } 1193 _ = v_1.Args[1] 1194 v_1_0 := v_1.Args[0] 1195 if v_1_0.Op != OpConst16 { 1196 break 1197 } 1198 if v_1_0.Type != t { 1199 break 1200 } 1201 d := v_1_0.AuxInt 1202 x := v_1.Args[1] 1203 v.reset(OpAdd16) 1204 v0 := b.NewValue0(v.Pos, OpConst16, t) 1205 v0.AuxInt = int64(int16(c + d)) 1206 v.AddArg(v0) 1207 v.AddArg(x) 1208 return true 1209 } 1210 // match: (Add16 (Const16 <t> [c]) (Add16 x (Const16 <t> [d]))) 1211 // cond: 1212 // result: (Add16 (Const16 <t> [int64(int16(c+d))]) x) 1213 for { 1214 _ = v.Args[1] 1215 v_0 := v.Args[0] 1216 if v_0.Op != OpConst16 { 1217 break 1218 } 1219 t := v_0.Type 1220 c := v_0.AuxInt 1221 v_1 := v.Args[1] 1222 if v_1.Op != OpAdd16 { 1223 break 1224 } 1225 _ = v_1.Args[1] 1226 x := v_1.Args[0] 1227 v_1_1 := v_1.Args[1] 1228 if v_1_1.Op != OpConst16 { 1229 break 1230 } 1231 if v_1_1.Type != t { 1232 break 1233 } 1234 d := v_1_1.AuxInt 1235 v.reset(OpAdd16) 1236 v0 := b.NewValue0(v.Pos, OpConst16, t) 1237 v0.AuxInt = int64(int16(c + d)) 1238 v.AddArg(v0) 1239 v.AddArg(x) 1240 return true 1241 } 1242 // match: (Add16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c])) 1243 // cond: 1244 // result: (Add16 (Const16 <t> [int64(int16(c+d))]) x) 1245 for { 1246 _ = v.Args[1] 1247 v_0 := v.Args[0] 1248 if v_0.Op != OpAdd16 { 1249 break 1250 } 1251 _ = v_0.Args[1] 1252 v_0_0 := v_0.Args[0] 1253 if v_0_0.Op != OpConst16 { 1254 break 1255 } 1256 t := v_0_0.Type 1257 d := v_0_0.AuxInt 1258 x := v_0.Args[1] 1259 v_1 := v.Args[1] 1260 if v_1.Op != OpConst16 { 1261 break 1262 } 1263 if v_1.Type != t { 1264 break 1265 } 1266 c := v_1.AuxInt 1267 v.reset(OpAdd16) 1268 v0 := b.NewValue0(v.Pos, OpConst16, t) 1269 v0.AuxInt = int64(int16(c + d)) 1270 v.AddArg(v0) 1271 v.AddArg(x) 1272 return true 1273 } 1274 // match: (Add16 (Add16 x (Const16 <t> [d])) (Const16 <t> [c])) 1275 // cond: 1276 // result: (Add16 (Const16 <t> [int64(int16(c+d))]) x) 1277 for { 1278 _ = v.Args[1] 1279 v_0 := v.Args[0] 1280 if v_0.Op != OpAdd16 { 1281 break 1282 } 1283 _ = v_0.Args[1] 1284 x := v_0.Args[0] 1285 v_0_1 := v_0.Args[1] 1286 if v_0_1.Op != OpConst16 { 1287 break 1288 } 1289 t := v_0_1.Type 1290 d := v_0_1.AuxInt 1291 v_1 := v.Args[1] 1292 if v_1.Op != OpConst16 { 1293 break 1294 } 1295 if v_1.Type != t { 1296 break 1297 } 1298 c := v_1.AuxInt 1299 v.reset(OpAdd16) 1300 v0 := b.NewValue0(v.Pos, OpConst16, t) 1301 v0.AuxInt = int64(int16(c + d)) 1302 v.AddArg(v0) 1303 v.AddArg(x) 1304 return true 1305 } 1306 return false 1307 } 1308 func rewriteValuegeneric_OpAdd16_30(v *Value) bool { 1309 b := v.Block 1310 _ = b 1311 // match: (Add16 (Const16 <t> [c]) (Sub16 (Const16 <t> [d]) x)) 1312 // cond: 1313 // result: (Sub16 (Const16 <t> [int64(int16(c+d))]) x) 1314 for { 1315 _ = v.Args[1] 1316 v_0 := v.Args[0] 1317 if v_0.Op != OpConst16 { 1318 break 1319 } 1320 t := v_0.Type 1321 c := v_0.AuxInt 1322 v_1 := v.Args[1] 1323 if v_1.Op != OpSub16 { 1324 break 1325 } 1326 _ = v_1.Args[1] 1327 v_1_0 := v_1.Args[0] 1328 if v_1_0.Op != OpConst16 { 1329 break 1330 } 1331 if v_1_0.Type != t { 1332 break 1333 } 1334 d := v_1_0.AuxInt 1335 x := v_1.Args[1] 1336 v.reset(OpSub16) 1337 v0 := b.NewValue0(v.Pos, OpConst16, t) 1338 v0.AuxInt = int64(int16(c + d)) 1339 v.AddArg(v0) 1340 v.AddArg(x) 1341 return true 1342 } 1343 // match: (Add16 (Sub16 (Const16 <t> [d]) x) (Const16 <t> [c])) 1344 // cond: 1345 // result: (Sub16 (Const16 <t> [int64(int16(c+d))]) x) 1346 for { 1347 _ = v.Args[1] 1348 v_0 := v.Args[0] 1349 if v_0.Op != OpSub16 { 1350 break 1351 } 1352 _ = v_0.Args[1] 1353 v_0_0 := v_0.Args[0] 1354 if v_0_0.Op != OpConst16 { 1355 break 1356 } 1357 t := v_0_0.Type 1358 d := v_0_0.AuxInt 1359 x := v_0.Args[1] 1360 v_1 := v.Args[1] 1361 if v_1.Op != OpConst16 { 1362 break 1363 } 1364 if v_1.Type != t { 1365 break 1366 } 1367 c := v_1.AuxInt 1368 v.reset(OpSub16) 1369 v0 := b.NewValue0(v.Pos, OpConst16, t) 1370 v0.AuxInt = int64(int16(c + d)) 1371 v.AddArg(v0) 1372 v.AddArg(x) 1373 return true 1374 } 1375 // match: (Add16 (Const16 <t> [c]) (Sub16 x (Const16 <t> [d]))) 1376 // cond: 1377 // result: (Add16 (Const16 <t> [int64(int16(c-d))]) x) 1378 for { 1379 _ = v.Args[1] 1380 v_0 := v.Args[0] 1381 if v_0.Op != OpConst16 { 1382 break 1383 } 1384 t := v_0.Type 1385 c := v_0.AuxInt 1386 v_1 := v.Args[1] 1387 if v_1.Op != OpSub16 { 1388 break 1389 } 1390 _ = v_1.Args[1] 1391 x := v_1.Args[0] 1392 v_1_1 := v_1.Args[1] 1393 if v_1_1.Op != OpConst16 { 1394 break 1395 } 1396 if v_1_1.Type != t { 1397 break 1398 } 1399 d := v_1_1.AuxInt 1400 v.reset(OpAdd16) 1401 v0 := b.NewValue0(v.Pos, OpConst16, t) 1402 v0.AuxInt = int64(int16(c - d)) 1403 v.AddArg(v0) 1404 v.AddArg(x) 1405 return true 1406 } 1407 // match: (Add16 (Sub16 x (Const16 <t> [d])) (Const16 <t> [c])) 1408 // cond: 1409 // result: (Add16 (Const16 <t> [int64(int16(c-d))]) x) 1410 for { 1411 _ = v.Args[1] 1412 v_0 := v.Args[0] 1413 if v_0.Op != OpSub16 { 1414 break 1415 } 1416 _ = v_0.Args[1] 1417 x := v_0.Args[0] 1418 v_0_1 := v_0.Args[1] 1419 if v_0_1.Op != OpConst16 { 1420 break 1421 } 1422 t := v_0_1.Type 1423 d := v_0_1.AuxInt 1424 v_1 := v.Args[1] 1425 if v_1.Op != OpConst16 { 1426 break 1427 } 1428 if v_1.Type != t { 1429 break 1430 } 1431 c := v_1.AuxInt 1432 v.reset(OpAdd16) 1433 v0 := b.NewValue0(v.Pos, OpConst16, t) 1434 v0.AuxInt = int64(int16(c - d)) 1435 v.AddArg(v0) 1436 v.AddArg(x) 1437 return true 1438 } 1439 return false 1440 } 1441 func rewriteValuegeneric_OpAdd32_0(v *Value) bool { 1442 b := v.Block 1443 _ = b 1444 // match: (Add32 (Const32 [c]) (Const32 [d])) 1445 // cond: 1446 // result: (Const32 [int64(int32(c+d))]) 1447 for { 1448 _ = v.Args[1] 1449 v_0 := v.Args[0] 1450 if v_0.Op != OpConst32 { 1451 break 1452 } 1453 c := v_0.AuxInt 1454 v_1 := v.Args[1] 1455 if v_1.Op != OpConst32 { 1456 break 1457 } 1458 d := v_1.AuxInt 1459 v.reset(OpConst32) 1460 v.AuxInt = int64(int32(c + d)) 1461 return true 1462 } 1463 // match: (Add32 (Const32 [d]) (Const32 [c])) 1464 // cond: 1465 // result: (Const32 [int64(int32(c+d))]) 1466 for { 1467 _ = v.Args[1] 1468 v_0 := v.Args[0] 1469 if v_0.Op != OpConst32 { 1470 break 1471 } 1472 d := v_0.AuxInt 1473 v_1 := v.Args[1] 1474 if v_1.Op != OpConst32 { 1475 break 1476 } 1477 c := v_1.AuxInt 1478 v.reset(OpConst32) 1479 v.AuxInt = int64(int32(c + d)) 1480 return true 1481 } 1482 // match: (Add32 <t> (Mul32 x y) (Mul32 x z)) 1483 // cond: 1484 // result: (Mul32 x (Add32 <t> y z)) 1485 for { 1486 t := v.Type 1487 _ = v.Args[1] 1488 v_0 := v.Args[0] 1489 if v_0.Op != OpMul32 { 1490 break 1491 } 1492 _ = v_0.Args[1] 1493 x := v_0.Args[0] 1494 y := v_0.Args[1] 1495 v_1 := v.Args[1] 1496 if v_1.Op != OpMul32 { 1497 break 1498 } 1499 _ = v_1.Args[1] 1500 if x != v_1.Args[0] { 1501 break 1502 } 1503 z := v_1.Args[1] 1504 v.reset(OpMul32) 1505 v.AddArg(x) 1506 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1507 v0.AddArg(y) 1508 v0.AddArg(z) 1509 v.AddArg(v0) 1510 return true 1511 } 1512 // match: (Add32 <t> (Mul32 y x) (Mul32 x z)) 1513 // cond: 1514 // result: (Mul32 x (Add32 <t> y z)) 1515 for { 1516 t := v.Type 1517 _ = v.Args[1] 1518 v_0 := v.Args[0] 1519 if v_0.Op != OpMul32 { 1520 break 1521 } 1522 _ = v_0.Args[1] 1523 y := v_0.Args[0] 1524 x := v_0.Args[1] 1525 v_1 := v.Args[1] 1526 if v_1.Op != OpMul32 { 1527 break 1528 } 1529 _ = v_1.Args[1] 1530 if x != v_1.Args[0] { 1531 break 1532 } 1533 z := v_1.Args[1] 1534 v.reset(OpMul32) 1535 v.AddArg(x) 1536 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1537 v0.AddArg(y) 1538 v0.AddArg(z) 1539 v.AddArg(v0) 1540 return true 1541 } 1542 // match: (Add32 <t> (Mul32 x y) (Mul32 z x)) 1543 // cond: 1544 // result: (Mul32 x (Add32 <t> y z)) 1545 for { 1546 t := v.Type 1547 _ = v.Args[1] 1548 v_0 := v.Args[0] 1549 if v_0.Op != OpMul32 { 1550 break 1551 } 1552 _ = v_0.Args[1] 1553 x := v_0.Args[0] 1554 y := v_0.Args[1] 1555 v_1 := v.Args[1] 1556 if v_1.Op != OpMul32 { 1557 break 1558 } 1559 _ = v_1.Args[1] 1560 z := v_1.Args[0] 1561 if x != v_1.Args[1] { 1562 break 1563 } 1564 v.reset(OpMul32) 1565 v.AddArg(x) 1566 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1567 v0.AddArg(y) 1568 v0.AddArg(z) 1569 v.AddArg(v0) 1570 return true 1571 } 1572 // match: (Add32 <t> (Mul32 y x) (Mul32 z x)) 1573 // cond: 1574 // result: (Mul32 x (Add32 <t> y z)) 1575 for { 1576 t := v.Type 1577 _ = v.Args[1] 1578 v_0 := v.Args[0] 1579 if v_0.Op != OpMul32 { 1580 break 1581 } 1582 _ = v_0.Args[1] 1583 y := v_0.Args[0] 1584 x := v_0.Args[1] 1585 v_1 := v.Args[1] 1586 if v_1.Op != OpMul32 { 1587 break 1588 } 1589 _ = v_1.Args[1] 1590 z := v_1.Args[0] 1591 if x != v_1.Args[1] { 1592 break 1593 } 1594 v.reset(OpMul32) 1595 v.AddArg(x) 1596 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1597 v0.AddArg(y) 1598 v0.AddArg(z) 1599 v.AddArg(v0) 1600 return true 1601 } 1602 // match: (Add32 <t> (Mul32 x z) (Mul32 x y)) 1603 // cond: 1604 // result: (Mul32 x (Add32 <t> y z)) 1605 for { 1606 t := v.Type 1607 _ = v.Args[1] 1608 v_0 := v.Args[0] 1609 if v_0.Op != OpMul32 { 1610 break 1611 } 1612 _ = v_0.Args[1] 1613 x := v_0.Args[0] 1614 z := v_0.Args[1] 1615 v_1 := v.Args[1] 1616 if v_1.Op != OpMul32 { 1617 break 1618 } 1619 _ = v_1.Args[1] 1620 if x != v_1.Args[0] { 1621 break 1622 } 1623 y := v_1.Args[1] 1624 v.reset(OpMul32) 1625 v.AddArg(x) 1626 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1627 v0.AddArg(y) 1628 v0.AddArg(z) 1629 v.AddArg(v0) 1630 return true 1631 } 1632 // match: (Add32 <t> (Mul32 z x) (Mul32 x y)) 1633 // cond: 1634 // result: (Mul32 x (Add32 <t> y z)) 1635 for { 1636 t := v.Type 1637 _ = v.Args[1] 1638 v_0 := v.Args[0] 1639 if v_0.Op != OpMul32 { 1640 break 1641 } 1642 _ = v_0.Args[1] 1643 z := v_0.Args[0] 1644 x := v_0.Args[1] 1645 v_1 := v.Args[1] 1646 if v_1.Op != OpMul32 { 1647 break 1648 } 1649 _ = v_1.Args[1] 1650 if x != v_1.Args[0] { 1651 break 1652 } 1653 y := v_1.Args[1] 1654 v.reset(OpMul32) 1655 v.AddArg(x) 1656 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1657 v0.AddArg(y) 1658 v0.AddArg(z) 1659 v.AddArg(v0) 1660 return true 1661 } 1662 // match: (Add32 <t> (Mul32 x z) (Mul32 y x)) 1663 // cond: 1664 // result: (Mul32 x (Add32 <t> y z)) 1665 for { 1666 t := v.Type 1667 _ = v.Args[1] 1668 v_0 := v.Args[0] 1669 if v_0.Op != OpMul32 { 1670 break 1671 } 1672 _ = v_0.Args[1] 1673 x := v_0.Args[0] 1674 z := v_0.Args[1] 1675 v_1 := v.Args[1] 1676 if v_1.Op != OpMul32 { 1677 break 1678 } 1679 _ = v_1.Args[1] 1680 y := v_1.Args[0] 1681 if x != v_1.Args[1] { 1682 break 1683 } 1684 v.reset(OpMul32) 1685 v.AddArg(x) 1686 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1687 v0.AddArg(y) 1688 v0.AddArg(z) 1689 v.AddArg(v0) 1690 return true 1691 } 1692 // match: (Add32 <t> (Mul32 z x) (Mul32 y x)) 1693 // cond: 1694 // result: (Mul32 x (Add32 <t> y z)) 1695 for { 1696 t := v.Type 1697 _ = v.Args[1] 1698 v_0 := v.Args[0] 1699 if v_0.Op != OpMul32 { 1700 break 1701 } 1702 _ = v_0.Args[1] 1703 z := v_0.Args[0] 1704 x := v_0.Args[1] 1705 v_1 := v.Args[1] 1706 if v_1.Op != OpMul32 { 1707 break 1708 } 1709 _ = v_1.Args[1] 1710 y := v_1.Args[0] 1711 if x != v_1.Args[1] { 1712 break 1713 } 1714 v.reset(OpMul32) 1715 v.AddArg(x) 1716 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1717 v0.AddArg(y) 1718 v0.AddArg(z) 1719 v.AddArg(v0) 1720 return true 1721 } 1722 return false 1723 } 1724 func rewriteValuegeneric_OpAdd32_10(v *Value) bool { 1725 b := v.Block 1726 _ = b 1727 // match: (Add32 (Const32 [0]) x) 1728 // cond: 1729 // result: x 1730 for { 1731 _ = v.Args[1] 1732 v_0 := v.Args[0] 1733 if v_0.Op != OpConst32 { 1734 break 1735 } 1736 if v_0.AuxInt != 0 { 1737 break 1738 } 1739 x := v.Args[1] 1740 v.reset(OpCopy) 1741 v.Type = x.Type 1742 v.AddArg(x) 1743 return true 1744 } 1745 // match: (Add32 x (Const32 [0])) 1746 // cond: 1747 // result: x 1748 for { 1749 _ = v.Args[1] 1750 x := v.Args[0] 1751 v_1 := v.Args[1] 1752 if v_1.Op != OpConst32 { 1753 break 1754 } 1755 if v_1.AuxInt != 0 { 1756 break 1757 } 1758 v.reset(OpCopy) 1759 v.Type = x.Type 1760 v.AddArg(x) 1761 return true 1762 } 1763 // match: (Add32 (Const32 [1]) (Com32 x)) 1764 // cond: 1765 // result: (Neg32 x) 1766 for { 1767 _ = v.Args[1] 1768 v_0 := v.Args[0] 1769 if v_0.Op != OpConst32 { 1770 break 1771 } 1772 if v_0.AuxInt != 1 { 1773 break 1774 } 1775 v_1 := v.Args[1] 1776 if v_1.Op != OpCom32 { 1777 break 1778 } 1779 x := v_1.Args[0] 1780 v.reset(OpNeg32) 1781 v.AddArg(x) 1782 return true 1783 } 1784 // match: (Add32 (Com32 x) (Const32 [1])) 1785 // cond: 1786 // result: (Neg32 x) 1787 for { 1788 _ = v.Args[1] 1789 v_0 := v.Args[0] 1790 if v_0.Op != OpCom32 { 1791 break 1792 } 1793 x := v_0.Args[0] 1794 v_1 := v.Args[1] 1795 if v_1.Op != OpConst32 { 1796 break 1797 } 1798 if v_1.AuxInt != 1 { 1799 break 1800 } 1801 v.reset(OpNeg32) 1802 v.AddArg(x) 1803 return true 1804 } 1805 // match: (Add32 (Add32 i:(Const32 <t>) z) x) 1806 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1807 // result: (Add32 i (Add32 <t> z x)) 1808 for { 1809 _ = v.Args[1] 1810 v_0 := v.Args[0] 1811 if v_0.Op != OpAdd32 { 1812 break 1813 } 1814 _ = v_0.Args[1] 1815 i := v_0.Args[0] 1816 if i.Op != OpConst32 { 1817 break 1818 } 1819 t := i.Type 1820 z := v_0.Args[1] 1821 x := v.Args[1] 1822 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1823 break 1824 } 1825 v.reset(OpAdd32) 1826 v.AddArg(i) 1827 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1828 v0.AddArg(z) 1829 v0.AddArg(x) 1830 v.AddArg(v0) 1831 return true 1832 } 1833 // match: (Add32 (Add32 z i:(Const32 <t>)) x) 1834 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1835 // result: (Add32 i (Add32 <t> z x)) 1836 for { 1837 _ = v.Args[1] 1838 v_0 := v.Args[0] 1839 if v_0.Op != OpAdd32 { 1840 break 1841 } 1842 _ = v_0.Args[1] 1843 z := v_0.Args[0] 1844 i := v_0.Args[1] 1845 if i.Op != OpConst32 { 1846 break 1847 } 1848 t := i.Type 1849 x := v.Args[1] 1850 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1851 break 1852 } 1853 v.reset(OpAdd32) 1854 v.AddArg(i) 1855 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1856 v0.AddArg(z) 1857 v0.AddArg(x) 1858 v.AddArg(v0) 1859 return true 1860 } 1861 // match: (Add32 x (Add32 i:(Const32 <t>) z)) 1862 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1863 // result: (Add32 i (Add32 <t> z x)) 1864 for { 1865 _ = v.Args[1] 1866 x := v.Args[0] 1867 v_1 := v.Args[1] 1868 if v_1.Op != OpAdd32 { 1869 break 1870 } 1871 _ = v_1.Args[1] 1872 i := v_1.Args[0] 1873 if i.Op != OpConst32 { 1874 break 1875 } 1876 t := i.Type 1877 z := v_1.Args[1] 1878 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1879 break 1880 } 1881 v.reset(OpAdd32) 1882 v.AddArg(i) 1883 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1884 v0.AddArg(z) 1885 v0.AddArg(x) 1886 v.AddArg(v0) 1887 return true 1888 } 1889 // match: (Add32 x (Add32 z i:(Const32 <t>))) 1890 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1891 // result: (Add32 i (Add32 <t> z x)) 1892 for { 1893 _ = v.Args[1] 1894 x := v.Args[0] 1895 v_1 := v.Args[1] 1896 if v_1.Op != OpAdd32 { 1897 break 1898 } 1899 _ = v_1.Args[1] 1900 z := v_1.Args[0] 1901 i := v_1.Args[1] 1902 if i.Op != OpConst32 { 1903 break 1904 } 1905 t := i.Type 1906 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1907 break 1908 } 1909 v.reset(OpAdd32) 1910 v.AddArg(i) 1911 v0 := b.NewValue0(v.Pos, OpAdd32, t) 1912 v0.AddArg(z) 1913 v0.AddArg(x) 1914 v.AddArg(v0) 1915 return true 1916 } 1917 // match: (Add32 (Sub32 i:(Const32 <t>) z) x) 1918 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1919 // result: (Add32 i (Sub32 <t> x z)) 1920 for { 1921 _ = v.Args[1] 1922 v_0 := v.Args[0] 1923 if v_0.Op != OpSub32 { 1924 break 1925 } 1926 _ = v_0.Args[1] 1927 i := v_0.Args[0] 1928 if i.Op != OpConst32 { 1929 break 1930 } 1931 t := i.Type 1932 z := v_0.Args[1] 1933 x := v.Args[1] 1934 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1935 break 1936 } 1937 v.reset(OpAdd32) 1938 v.AddArg(i) 1939 v0 := b.NewValue0(v.Pos, OpSub32, t) 1940 v0.AddArg(x) 1941 v0.AddArg(z) 1942 v.AddArg(v0) 1943 return true 1944 } 1945 // match: (Add32 x (Sub32 i:(Const32 <t>) z)) 1946 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1947 // result: (Add32 i (Sub32 <t> x z)) 1948 for { 1949 _ = v.Args[1] 1950 x := v.Args[0] 1951 v_1 := v.Args[1] 1952 if v_1.Op != OpSub32 { 1953 break 1954 } 1955 _ = v_1.Args[1] 1956 i := v_1.Args[0] 1957 if i.Op != OpConst32 { 1958 break 1959 } 1960 t := i.Type 1961 z := v_1.Args[1] 1962 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1963 break 1964 } 1965 v.reset(OpAdd32) 1966 v.AddArg(i) 1967 v0 := b.NewValue0(v.Pos, OpSub32, t) 1968 v0.AddArg(x) 1969 v0.AddArg(z) 1970 v.AddArg(v0) 1971 return true 1972 } 1973 return false 1974 } 1975 func rewriteValuegeneric_OpAdd32_20(v *Value) bool { 1976 b := v.Block 1977 _ = b 1978 // match: (Add32 x (Sub32 i:(Const32 <t>) z)) 1979 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 1980 // result: (Add32 i (Sub32 <t> x z)) 1981 for { 1982 _ = v.Args[1] 1983 x := v.Args[0] 1984 v_1 := v.Args[1] 1985 if v_1.Op != OpSub32 { 1986 break 1987 } 1988 _ = v_1.Args[1] 1989 i := v_1.Args[0] 1990 if i.Op != OpConst32 { 1991 break 1992 } 1993 t := i.Type 1994 z := v_1.Args[1] 1995 if !(z.Op != OpConst32 && x.Op != OpConst32) { 1996 break 1997 } 1998 v.reset(OpAdd32) 1999 v.AddArg(i) 2000 v0 := b.NewValue0(v.Pos, OpSub32, t) 2001 v0.AddArg(x) 2002 v0.AddArg(z) 2003 v.AddArg(v0) 2004 return true 2005 } 2006 // match: (Add32 (Sub32 i:(Const32 <t>) z) x) 2007 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 2008 // result: (Add32 i (Sub32 <t> x z)) 2009 for { 2010 _ = v.Args[1] 2011 v_0 := v.Args[0] 2012 if v_0.Op != OpSub32 { 2013 break 2014 } 2015 _ = v_0.Args[1] 2016 i := v_0.Args[0] 2017 if i.Op != OpConst32 { 2018 break 2019 } 2020 t := i.Type 2021 z := v_0.Args[1] 2022 x := v.Args[1] 2023 if !(z.Op != OpConst32 && x.Op != OpConst32) { 2024 break 2025 } 2026 v.reset(OpAdd32) 2027 v.AddArg(i) 2028 v0 := b.NewValue0(v.Pos, OpSub32, t) 2029 v0.AddArg(x) 2030 v0.AddArg(z) 2031 v.AddArg(v0) 2032 return true 2033 } 2034 // match: (Add32 (Sub32 z i:(Const32 <t>)) x) 2035 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 2036 // result: (Sub32 (Add32 <t> x z) i) 2037 for { 2038 _ = v.Args[1] 2039 v_0 := v.Args[0] 2040 if v_0.Op != OpSub32 { 2041 break 2042 } 2043 _ = v_0.Args[1] 2044 z := v_0.Args[0] 2045 i := v_0.Args[1] 2046 if i.Op != OpConst32 { 2047 break 2048 } 2049 t := i.Type 2050 x := v.Args[1] 2051 if !(z.Op != OpConst32 && x.Op != OpConst32) { 2052 break 2053 } 2054 v.reset(OpSub32) 2055 v0 := b.NewValue0(v.Pos, OpAdd32, t) 2056 v0.AddArg(x) 2057 v0.AddArg(z) 2058 v.AddArg(v0) 2059 v.AddArg(i) 2060 return true 2061 } 2062 // match: (Add32 x (Sub32 z i:(Const32 <t>))) 2063 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 2064 // result: (Sub32 (Add32 <t> x z) i) 2065 for { 2066 _ = v.Args[1] 2067 x := v.Args[0] 2068 v_1 := v.Args[1] 2069 if v_1.Op != OpSub32 { 2070 break 2071 } 2072 _ = v_1.Args[1] 2073 z := v_1.Args[0] 2074 i := v_1.Args[1] 2075 if i.Op != OpConst32 { 2076 break 2077 } 2078 t := i.Type 2079 if !(z.Op != OpConst32 && x.Op != OpConst32) { 2080 break 2081 } 2082 v.reset(OpSub32) 2083 v0 := b.NewValue0(v.Pos, OpAdd32, t) 2084 v0.AddArg(x) 2085 v0.AddArg(z) 2086 v.AddArg(v0) 2087 v.AddArg(i) 2088 return true 2089 } 2090 // match: (Add32 x (Sub32 z i:(Const32 <t>))) 2091 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 2092 // result: (Sub32 (Add32 <t> x z) i) 2093 for { 2094 _ = v.Args[1] 2095 x := v.Args[0] 2096 v_1 := v.Args[1] 2097 if v_1.Op != OpSub32 { 2098 break 2099 } 2100 _ = v_1.Args[1] 2101 z := v_1.Args[0] 2102 i := v_1.Args[1] 2103 if i.Op != OpConst32 { 2104 break 2105 } 2106 t := i.Type 2107 if !(z.Op != OpConst32 && x.Op != OpConst32) { 2108 break 2109 } 2110 v.reset(OpSub32) 2111 v0 := b.NewValue0(v.Pos, OpAdd32, t) 2112 v0.AddArg(x) 2113 v0.AddArg(z) 2114 v.AddArg(v0) 2115 v.AddArg(i) 2116 return true 2117 } 2118 // match: (Add32 (Sub32 z i:(Const32 <t>)) x) 2119 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 2120 // result: (Sub32 (Add32 <t> x z) i) 2121 for { 2122 _ = v.Args[1] 2123 v_0 := v.Args[0] 2124 if v_0.Op != OpSub32 { 2125 break 2126 } 2127 _ = v_0.Args[1] 2128 z := v_0.Args[0] 2129 i := v_0.Args[1] 2130 if i.Op != OpConst32 { 2131 break 2132 } 2133 t := i.Type 2134 x := v.Args[1] 2135 if !(z.Op != OpConst32 && x.Op != OpConst32) { 2136 break 2137 } 2138 v.reset(OpSub32) 2139 v0 := b.NewValue0(v.Pos, OpAdd32, t) 2140 v0.AddArg(x) 2141 v0.AddArg(z) 2142 v.AddArg(v0) 2143 v.AddArg(i) 2144 return true 2145 } 2146 // match: (Add32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x)) 2147 // cond: 2148 // result: (Add32 (Const32 <t> [int64(int32(c+d))]) x) 2149 for { 2150 _ = v.Args[1] 2151 v_0 := v.Args[0] 2152 if v_0.Op != OpConst32 { 2153 break 2154 } 2155 t := v_0.Type 2156 c := v_0.AuxInt 2157 v_1 := v.Args[1] 2158 if v_1.Op != OpAdd32 { 2159 break 2160 } 2161 _ = v_1.Args[1] 2162 v_1_0 := v_1.Args[0] 2163 if v_1_0.Op != OpConst32 { 2164 break 2165 } 2166 if v_1_0.Type != t { 2167 break 2168 } 2169 d := v_1_0.AuxInt 2170 x := v_1.Args[1] 2171 v.reset(OpAdd32) 2172 v0 := b.NewValue0(v.Pos, OpConst32, t) 2173 v0.AuxInt = int64(int32(c + d)) 2174 v.AddArg(v0) 2175 v.AddArg(x) 2176 return true 2177 } 2178 // match: (Add32 (Const32 <t> [c]) (Add32 x (Const32 <t> [d]))) 2179 // cond: 2180 // result: (Add32 (Const32 <t> [int64(int32(c+d))]) x) 2181 for { 2182 _ = v.Args[1] 2183 v_0 := v.Args[0] 2184 if v_0.Op != OpConst32 { 2185 break 2186 } 2187 t := v_0.Type 2188 c := v_0.AuxInt 2189 v_1 := v.Args[1] 2190 if v_1.Op != OpAdd32 { 2191 break 2192 } 2193 _ = v_1.Args[1] 2194 x := v_1.Args[0] 2195 v_1_1 := v_1.Args[1] 2196 if v_1_1.Op != OpConst32 { 2197 break 2198 } 2199 if v_1_1.Type != t { 2200 break 2201 } 2202 d := v_1_1.AuxInt 2203 v.reset(OpAdd32) 2204 v0 := b.NewValue0(v.Pos, OpConst32, t) 2205 v0.AuxInt = int64(int32(c + d)) 2206 v.AddArg(v0) 2207 v.AddArg(x) 2208 return true 2209 } 2210 // match: (Add32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c])) 2211 // cond: 2212 // result: (Add32 (Const32 <t> [int64(int32(c+d))]) x) 2213 for { 2214 _ = v.Args[1] 2215 v_0 := v.Args[0] 2216 if v_0.Op != OpAdd32 { 2217 break 2218 } 2219 _ = v_0.Args[1] 2220 v_0_0 := v_0.Args[0] 2221 if v_0_0.Op != OpConst32 { 2222 break 2223 } 2224 t := v_0_0.Type 2225 d := v_0_0.AuxInt 2226 x := v_0.Args[1] 2227 v_1 := v.Args[1] 2228 if v_1.Op != OpConst32 { 2229 break 2230 } 2231 if v_1.Type != t { 2232 break 2233 } 2234 c := v_1.AuxInt 2235 v.reset(OpAdd32) 2236 v0 := b.NewValue0(v.Pos, OpConst32, t) 2237 v0.AuxInt = int64(int32(c + d)) 2238 v.AddArg(v0) 2239 v.AddArg(x) 2240 return true 2241 } 2242 // match: (Add32 (Add32 x (Const32 <t> [d])) (Const32 <t> [c])) 2243 // cond: 2244 // result: (Add32 (Const32 <t> [int64(int32(c+d))]) x) 2245 for { 2246 _ = v.Args[1] 2247 v_0 := v.Args[0] 2248 if v_0.Op != OpAdd32 { 2249 break 2250 } 2251 _ = v_0.Args[1] 2252 x := v_0.Args[0] 2253 v_0_1 := v_0.Args[1] 2254 if v_0_1.Op != OpConst32 { 2255 break 2256 } 2257 t := v_0_1.Type 2258 d := v_0_1.AuxInt 2259 v_1 := v.Args[1] 2260 if v_1.Op != OpConst32 { 2261 break 2262 } 2263 if v_1.Type != t { 2264 break 2265 } 2266 c := v_1.AuxInt 2267 v.reset(OpAdd32) 2268 v0 := b.NewValue0(v.Pos, OpConst32, t) 2269 v0.AuxInt = int64(int32(c + d)) 2270 v.AddArg(v0) 2271 v.AddArg(x) 2272 return true 2273 } 2274 return false 2275 } 2276 func rewriteValuegeneric_OpAdd32_30(v *Value) bool { 2277 b := v.Block 2278 _ = b 2279 // match: (Add32 (Const32 <t> [c]) (Sub32 (Const32 <t> [d]) x)) 2280 // cond: 2281 // result: (Sub32 (Const32 <t> [int64(int32(c+d))]) x) 2282 for { 2283 _ = v.Args[1] 2284 v_0 := v.Args[0] 2285 if v_0.Op != OpConst32 { 2286 break 2287 } 2288 t := v_0.Type 2289 c := v_0.AuxInt 2290 v_1 := v.Args[1] 2291 if v_1.Op != OpSub32 { 2292 break 2293 } 2294 _ = v_1.Args[1] 2295 v_1_0 := v_1.Args[0] 2296 if v_1_0.Op != OpConst32 { 2297 break 2298 } 2299 if v_1_0.Type != t { 2300 break 2301 } 2302 d := v_1_0.AuxInt 2303 x := v_1.Args[1] 2304 v.reset(OpSub32) 2305 v0 := b.NewValue0(v.Pos, OpConst32, t) 2306 v0.AuxInt = int64(int32(c + d)) 2307 v.AddArg(v0) 2308 v.AddArg(x) 2309 return true 2310 } 2311 // match: (Add32 (Sub32 (Const32 <t> [d]) x) (Const32 <t> [c])) 2312 // cond: 2313 // result: (Sub32 (Const32 <t> [int64(int32(c+d))]) x) 2314 for { 2315 _ = v.Args[1] 2316 v_0 := v.Args[0] 2317 if v_0.Op != OpSub32 { 2318 break 2319 } 2320 _ = v_0.Args[1] 2321 v_0_0 := v_0.Args[0] 2322 if v_0_0.Op != OpConst32 { 2323 break 2324 } 2325 t := v_0_0.Type 2326 d := v_0_0.AuxInt 2327 x := v_0.Args[1] 2328 v_1 := v.Args[1] 2329 if v_1.Op != OpConst32 { 2330 break 2331 } 2332 if v_1.Type != t { 2333 break 2334 } 2335 c := v_1.AuxInt 2336 v.reset(OpSub32) 2337 v0 := b.NewValue0(v.Pos, OpConst32, t) 2338 v0.AuxInt = int64(int32(c + d)) 2339 v.AddArg(v0) 2340 v.AddArg(x) 2341 return true 2342 } 2343 // match: (Add32 (Const32 <t> [c]) (Sub32 x (Const32 <t> [d]))) 2344 // cond: 2345 // result: (Add32 (Const32 <t> [int64(int32(c-d))]) x) 2346 for { 2347 _ = v.Args[1] 2348 v_0 := v.Args[0] 2349 if v_0.Op != OpConst32 { 2350 break 2351 } 2352 t := v_0.Type 2353 c := v_0.AuxInt 2354 v_1 := v.Args[1] 2355 if v_1.Op != OpSub32 { 2356 break 2357 } 2358 _ = v_1.Args[1] 2359 x := v_1.Args[0] 2360 v_1_1 := v_1.Args[1] 2361 if v_1_1.Op != OpConst32 { 2362 break 2363 } 2364 if v_1_1.Type != t { 2365 break 2366 } 2367 d := v_1_1.AuxInt 2368 v.reset(OpAdd32) 2369 v0 := b.NewValue0(v.Pos, OpConst32, t) 2370 v0.AuxInt = int64(int32(c - d)) 2371 v.AddArg(v0) 2372 v.AddArg(x) 2373 return true 2374 } 2375 // match: (Add32 (Sub32 x (Const32 <t> [d])) (Const32 <t> [c])) 2376 // cond: 2377 // result: (Add32 (Const32 <t> [int64(int32(c-d))]) x) 2378 for { 2379 _ = v.Args[1] 2380 v_0 := v.Args[0] 2381 if v_0.Op != OpSub32 { 2382 break 2383 } 2384 _ = v_0.Args[1] 2385 x := v_0.Args[0] 2386 v_0_1 := v_0.Args[1] 2387 if v_0_1.Op != OpConst32 { 2388 break 2389 } 2390 t := v_0_1.Type 2391 d := v_0_1.AuxInt 2392 v_1 := v.Args[1] 2393 if v_1.Op != OpConst32 { 2394 break 2395 } 2396 if v_1.Type != t { 2397 break 2398 } 2399 c := v_1.AuxInt 2400 v.reset(OpAdd32) 2401 v0 := b.NewValue0(v.Pos, OpConst32, t) 2402 v0.AuxInt = int64(int32(c - d)) 2403 v.AddArg(v0) 2404 v.AddArg(x) 2405 return true 2406 } 2407 return false 2408 } 2409 func rewriteValuegeneric_OpAdd32F_0(v *Value) bool { 2410 // match: (Add32F (Const32F [c]) (Const32F [d])) 2411 // cond: 2412 // result: (Const32F [auxFrom32F(auxTo32F(c) + auxTo32F(d))]) 2413 for { 2414 _ = v.Args[1] 2415 v_0 := v.Args[0] 2416 if v_0.Op != OpConst32F { 2417 break 2418 } 2419 c := v_0.AuxInt 2420 v_1 := v.Args[1] 2421 if v_1.Op != OpConst32F { 2422 break 2423 } 2424 d := v_1.AuxInt 2425 v.reset(OpConst32F) 2426 v.AuxInt = auxFrom32F(auxTo32F(c) + auxTo32F(d)) 2427 return true 2428 } 2429 // match: (Add32F (Const32F [d]) (Const32F [c])) 2430 // cond: 2431 // result: (Const32F [auxFrom32F(auxTo32F(c) + auxTo32F(d))]) 2432 for { 2433 _ = v.Args[1] 2434 v_0 := v.Args[0] 2435 if v_0.Op != OpConst32F { 2436 break 2437 } 2438 d := v_0.AuxInt 2439 v_1 := v.Args[1] 2440 if v_1.Op != OpConst32F { 2441 break 2442 } 2443 c := v_1.AuxInt 2444 v.reset(OpConst32F) 2445 v.AuxInt = auxFrom32F(auxTo32F(c) + auxTo32F(d)) 2446 return true 2447 } 2448 return false 2449 } 2450 func rewriteValuegeneric_OpAdd64_0(v *Value) bool { 2451 b := v.Block 2452 _ = b 2453 // match: (Add64 (Const64 [c]) (Const64 [d])) 2454 // cond: 2455 // result: (Const64 [c+d]) 2456 for { 2457 _ = v.Args[1] 2458 v_0 := v.Args[0] 2459 if v_0.Op != OpConst64 { 2460 break 2461 } 2462 c := v_0.AuxInt 2463 v_1 := v.Args[1] 2464 if v_1.Op != OpConst64 { 2465 break 2466 } 2467 d := v_1.AuxInt 2468 v.reset(OpConst64) 2469 v.AuxInt = c + d 2470 return true 2471 } 2472 // match: (Add64 (Const64 [d]) (Const64 [c])) 2473 // cond: 2474 // result: (Const64 [c+d]) 2475 for { 2476 _ = v.Args[1] 2477 v_0 := v.Args[0] 2478 if v_0.Op != OpConst64 { 2479 break 2480 } 2481 d := v_0.AuxInt 2482 v_1 := v.Args[1] 2483 if v_1.Op != OpConst64 { 2484 break 2485 } 2486 c := v_1.AuxInt 2487 v.reset(OpConst64) 2488 v.AuxInt = c + d 2489 return true 2490 } 2491 // match: (Add64 <t> (Mul64 x y) (Mul64 x z)) 2492 // cond: 2493 // result: (Mul64 x (Add64 <t> y z)) 2494 for { 2495 t := v.Type 2496 _ = v.Args[1] 2497 v_0 := v.Args[0] 2498 if v_0.Op != OpMul64 { 2499 break 2500 } 2501 _ = v_0.Args[1] 2502 x := v_0.Args[0] 2503 y := v_0.Args[1] 2504 v_1 := v.Args[1] 2505 if v_1.Op != OpMul64 { 2506 break 2507 } 2508 _ = v_1.Args[1] 2509 if x != v_1.Args[0] { 2510 break 2511 } 2512 z := v_1.Args[1] 2513 v.reset(OpMul64) 2514 v.AddArg(x) 2515 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2516 v0.AddArg(y) 2517 v0.AddArg(z) 2518 v.AddArg(v0) 2519 return true 2520 } 2521 // match: (Add64 <t> (Mul64 y x) (Mul64 x z)) 2522 // cond: 2523 // result: (Mul64 x (Add64 <t> y z)) 2524 for { 2525 t := v.Type 2526 _ = v.Args[1] 2527 v_0 := v.Args[0] 2528 if v_0.Op != OpMul64 { 2529 break 2530 } 2531 _ = v_0.Args[1] 2532 y := v_0.Args[0] 2533 x := v_0.Args[1] 2534 v_1 := v.Args[1] 2535 if v_1.Op != OpMul64 { 2536 break 2537 } 2538 _ = v_1.Args[1] 2539 if x != v_1.Args[0] { 2540 break 2541 } 2542 z := v_1.Args[1] 2543 v.reset(OpMul64) 2544 v.AddArg(x) 2545 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2546 v0.AddArg(y) 2547 v0.AddArg(z) 2548 v.AddArg(v0) 2549 return true 2550 } 2551 // match: (Add64 <t> (Mul64 x y) (Mul64 z x)) 2552 // cond: 2553 // result: (Mul64 x (Add64 <t> y z)) 2554 for { 2555 t := v.Type 2556 _ = v.Args[1] 2557 v_0 := v.Args[0] 2558 if v_0.Op != OpMul64 { 2559 break 2560 } 2561 _ = v_0.Args[1] 2562 x := v_0.Args[0] 2563 y := v_0.Args[1] 2564 v_1 := v.Args[1] 2565 if v_1.Op != OpMul64 { 2566 break 2567 } 2568 _ = v_1.Args[1] 2569 z := v_1.Args[0] 2570 if x != v_1.Args[1] { 2571 break 2572 } 2573 v.reset(OpMul64) 2574 v.AddArg(x) 2575 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2576 v0.AddArg(y) 2577 v0.AddArg(z) 2578 v.AddArg(v0) 2579 return true 2580 } 2581 // match: (Add64 <t> (Mul64 y x) (Mul64 z x)) 2582 // cond: 2583 // result: (Mul64 x (Add64 <t> y z)) 2584 for { 2585 t := v.Type 2586 _ = v.Args[1] 2587 v_0 := v.Args[0] 2588 if v_0.Op != OpMul64 { 2589 break 2590 } 2591 _ = v_0.Args[1] 2592 y := v_0.Args[0] 2593 x := v_0.Args[1] 2594 v_1 := v.Args[1] 2595 if v_1.Op != OpMul64 { 2596 break 2597 } 2598 _ = v_1.Args[1] 2599 z := v_1.Args[0] 2600 if x != v_1.Args[1] { 2601 break 2602 } 2603 v.reset(OpMul64) 2604 v.AddArg(x) 2605 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2606 v0.AddArg(y) 2607 v0.AddArg(z) 2608 v.AddArg(v0) 2609 return true 2610 } 2611 // match: (Add64 <t> (Mul64 x z) (Mul64 x y)) 2612 // cond: 2613 // result: (Mul64 x (Add64 <t> y z)) 2614 for { 2615 t := v.Type 2616 _ = v.Args[1] 2617 v_0 := v.Args[0] 2618 if v_0.Op != OpMul64 { 2619 break 2620 } 2621 _ = v_0.Args[1] 2622 x := v_0.Args[0] 2623 z := v_0.Args[1] 2624 v_1 := v.Args[1] 2625 if v_1.Op != OpMul64 { 2626 break 2627 } 2628 _ = v_1.Args[1] 2629 if x != v_1.Args[0] { 2630 break 2631 } 2632 y := v_1.Args[1] 2633 v.reset(OpMul64) 2634 v.AddArg(x) 2635 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2636 v0.AddArg(y) 2637 v0.AddArg(z) 2638 v.AddArg(v0) 2639 return true 2640 } 2641 // match: (Add64 <t> (Mul64 z x) (Mul64 x y)) 2642 // cond: 2643 // result: (Mul64 x (Add64 <t> y z)) 2644 for { 2645 t := v.Type 2646 _ = v.Args[1] 2647 v_0 := v.Args[0] 2648 if v_0.Op != OpMul64 { 2649 break 2650 } 2651 _ = v_0.Args[1] 2652 z := v_0.Args[0] 2653 x := v_0.Args[1] 2654 v_1 := v.Args[1] 2655 if v_1.Op != OpMul64 { 2656 break 2657 } 2658 _ = v_1.Args[1] 2659 if x != v_1.Args[0] { 2660 break 2661 } 2662 y := v_1.Args[1] 2663 v.reset(OpMul64) 2664 v.AddArg(x) 2665 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2666 v0.AddArg(y) 2667 v0.AddArg(z) 2668 v.AddArg(v0) 2669 return true 2670 } 2671 // match: (Add64 <t> (Mul64 x z) (Mul64 y x)) 2672 // cond: 2673 // result: (Mul64 x (Add64 <t> y z)) 2674 for { 2675 t := v.Type 2676 _ = v.Args[1] 2677 v_0 := v.Args[0] 2678 if v_0.Op != OpMul64 { 2679 break 2680 } 2681 _ = v_0.Args[1] 2682 x := v_0.Args[0] 2683 z := v_0.Args[1] 2684 v_1 := v.Args[1] 2685 if v_1.Op != OpMul64 { 2686 break 2687 } 2688 _ = v_1.Args[1] 2689 y := v_1.Args[0] 2690 if x != v_1.Args[1] { 2691 break 2692 } 2693 v.reset(OpMul64) 2694 v.AddArg(x) 2695 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2696 v0.AddArg(y) 2697 v0.AddArg(z) 2698 v.AddArg(v0) 2699 return true 2700 } 2701 // match: (Add64 <t> (Mul64 z x) (Mul64 y x)) 2702 // cond: 2703 // result: (Mul64 x (Add64 <t> y z)) 2704 for { 2705 t := v.Type 2706 _ = v.Args[1] 2707 v_0 := v.Args[0] 2708 if v_0.Op != OpMul64 { 2709 break 2710 } 2711 _ = v_0.Args[1] 2712 z := v_0.Args[0] 2713 x := v_0.Args[1] 2714 v_1 := v.Args[1] 2715 if v_1.Op != OpMul64 { 2716 break 2717 } 2718 _ = v_1.Args[1] 2719 y := v_1.Args[0] 2720 if x != v_1.Args[1] { 2721 break 2722 } 2723 v.reset(OpMul64) 2724 v.AddArg(x) 2725 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2726 v0.AddArg(y) 2727 v0.AddArg(z) 2728 v.AddArg(v0) 2729 return true 2730 } 2731 return false 2732 } 2733 func rewriteValuegeneric_OpAdd64_10(v *Value) bool { 2734 b := v.Block 2735 _ = b 2736 // match: (Add64 (Const64 [0]) x) 2737 // cond: 2738 // result: x 2739 for { 2740 _ = v.Args[1] 2741 v_0 := v.Args[0] 2742 if v_0.Op != OpConst64 { 2743 break 2744 } 2745 if v_0.AuxInt != 0 { 2746 break 2747 } 2748 x := v.Args[1] 2749 v.reset(OpCopy) 2750 v.Type = x.Type 2751 v.AddArg(x) 2752 return true 2753 } 2754 // match: (Add64 x (Const64 [0])) 2755 // cond: 2756 // result: x 2757 for { 2758 _ = v.Args[1] 2759 x := v.Args[0] 2760 v_1 := v.Args[1] 2761 if v_1.Op != OpConst64 { 2762 break 2763 } 2764 if v_1.AuxInt != 0 { 2765 break 2766 } 2767 v.reset(OpCopy) 2768 v.Type = x.Type 2769 v.AddArg(x) 2770 return true 2771 } 2772 // match: (Add64 (Const64 [1]) (Com64 x)) 2773 // cond: 2774 // result: (Neg64 x) 2775 for { 2776 _ = v.Args[1] 2777 v_0 := v.Args[0] 2778 if v_0.Op != OpConst64 { 2779 break 2780 } 2781 if v_0.AuxInt != 1 { 2782 break 2783 } 2784 v_1 := v.Args[1] 2785 if v_1.Op != OpCom64 { 2786 break 2787 } 2788 x := v_1.Args[0] 2789 v.reset(OpNeg64) 2790 v.AddArg(x) 2791 return true 2792 } 2793 // match: (Add64 (Com64 x) (Const64 [1])) 2794 // cond: 2795 // result: (Neg64 x) 2796 for { 2797 _ = v.Args[1] 2798 v_0 := v.Args[0] 2799 if v_0.Op != OpCom64 { 2800 break 2801 } 2802 x := v_0.Args[0] 2803 v_1 := v.Args[1] 2804 if v_1.Op != OpConst64 { 2805 break 2806 } 2807 if v_1.AuxInt != 1 { 2808 break 2809 } 2810 v.reset(OpNeg64) 2811 v.AddArg(x) 2812 return true 2813 } 2814 // match: (Add64 (Add64 i:(Const64 <t>) z) x) 2815 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2816 // result: (Add64 i (Add64 <t> z x)) 2817 for { 2818 _ = v.Args[1] 2819 v_0 := v.Args[0] 2820 if v_0.Op != OpAdd64 { 2821 break 2822 } 2823 _ = v_0.Args[1] 2824 i := v_0.Args[0] 2825 if i.Op != OpConst64 { 2826 break 2827 } 2828 t := i.Type 2829 z := v_0.Args[1] 2830 x := v.Args[1] 2831 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2832 break 2833 } 2834 v.reset(OpAdd64) 2835 v.AddArg(i) 2836 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2837 v0.AddArg(z) 2838 v0.AddArg(x) 2839 v.AddArg(v0) 2840 return true 2841 } 2842 // match: (Add64 (Add64 z i:(Const64 <t>)) x) 2843 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2844 // result: (Add64 i (Add64 <t> z x)) 2845 for { 2846 _ = v.Args[1] 2847 v_0 := v.Args[0] 2848 if v_0.Op != OpAdd64 { 2849 break 2850 } 2851 _ = v_0.Args[1] 2852 z := v_0.Args[0] 2853 i := v_0.Args[1] 2854 if i.Op != OpConst64 { 2855 break 2856 } 2857 t := i.Type 2858 x := v.Args[1] 2859 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2860 break 2861 } 2862 v.reset(OpAdd64) 2863 v.AddArg(i) 2864 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2865 v0.AddArg(z) 2866 v0.AddArg(x) 2867 v.AddArg(v0) 2868 return true 2869 } 2870 // match: (Add64 x (Add64 i:(Const64 <t>) z)) 2871 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2872 // result: (Add64 i (Add64 <t> z x)) 2873 for { 2874 _ = v.Args[1] 2875 x := v.Args[0] 2876 v_1 := v.Args[1] 2877 if v_1.Op != OpAdd64 { 2878 break 2879 } 2880 _ = v_1.Args[1] 2881 i := v_1.Args[0] 2882 if i.Op != OpConst64 { 2883 break 2884 } 2885 t := i.Type 2886 z := v_1.Args[1] 2887 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2888 break 2889 } 2890 v.reset(OpAdd64) 2891 v.AddArg(i) 2892 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2893 v0.AddArg(z) 2894 v0.AddArg(x) 2895 v.AddArg(v0) 2896 return true 2897 } 2898 // match: (Add64 x (Add64 z i:(Const64 <t>))) 2899 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2900 // result: (Add64 i (Add64 <t> z x)) 2901 for { 2902 _ = v.Args[1] 2903 x := v.Args[0] 2904 v_1 := v.Args[1] 2905 if v_1.Op != OpAdd64 { 2906 break 2907 } 2908 _ = v_1.Args[1] 2909 z := v_1.Args[0] 2910 i := v_1.Args[1] 2911 if i.Op != OpConst64 { 2912 break 2913 } 2914 t := i.Type 2915 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2916 break 2917 } 2918 v.reset(OpAdd64) 2919 v.AddArg(i) 2920 v0 := b.NewValue0(v.Pos, OpAdd64, t) 2921 v0.AddArg(z) 2922 v0.AddArg(x) 2923 v.AddArg(v0) 2924 return true 2925 } 2926 // match: (Add64 (Sub64 i:(Const64 <t>) z) x) 2927 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2928 // result: (Add64 i (Sub64 <t> x z)) 2929 for { 2930 _ = v.Args[1] 2931 v_0 := v.Args[0] 2932 if v_0.Op != OpSub64 { 2933 break 2934 } 2935 _ = v_0.Args[1] 2936 i := v_0.Args[0] 2937 if i.Op != OpConst64 { 2938 break 2939 } 2940 t := i.Type 2941 z := v_0.Args[1] 2942 x := v.Args[1] 2943 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2944 break 2945 } 2946 v.reset(OpAdd64) 2947 v.AddArg(i) 2948 v0 := b.NewValue0(v.Pos, OpSub64, t) 2949 v0.AddArg(x) 2950 v0.AddArg(z) 2951 v.AddArg(v0) 2952 return true 2953 } 2954 // match: (Add64 x (Sub64 i:(Const64 <t>) z)) 2955 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2956 // result: (Add64 i (Sub64 <t> x z)) 2957 for { 2958 _ = v.Args[1] 2959 x := v.Args[0] 2960 v_1 := v.Args[1] 2961 if v_1.Op != OpSub64 { 2962 break 2963 } 2964 _ = v_1.Args[1] 2965 i := v_1.Args[0] 2966 if i.Op != OpConst64 { 2967 break 2968 } 2969 t := i.Type 2970 z := v_1.Args[1] 2971 if !(z.Op != OpConst64 && x.Op != OpConst64) { 2972 break 2973 } 2974 v.reset(OpAdd64) 2975 v.AddArg(i) 2976 v0 := b.NewValue0(v.Pos, OpSub64, t) 2977 v0.AddArg(x) 2978 v0.AddArg(z) 2979 v.AddArg(v0) 2980 return true 2981 } 2982 return false 2983 } 2984 func rewriteValuegeneric_OpAdd64_20(v *Value) bool { 2985 b := v.Block 2986 _ = b 2987 // match: (Add64 x (Sub64 i:(Const64 <t>) z)) 2988 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 2989 // result: (Add64 i (Sub64 <t> x z)) 2990 for { 2991 _ = v.Args[1] 2992 x := v.Args[0] 2993 v_1 := v.Args[1] 2994 if v_1.Op != OpSub64 { 2995 break 2996 } 2997 _ = v_1.Args[1] 2998 i := v_1.Args[0] 2999 if i.Op != OpConst64 { 3000 break 3001 } 3002 t := i.Type 3003 z := v_1.Args[1] 3004 if !(z.Op != OpConst64 && x.Op != OpConst64) { 3005 break 3006 } 3007 v.reset(OpAdd64) 3008 v.AddArg(i) 3009 v0 := b.NewValue0(v.Pos, OpSub64, t) 3010 v0.AddArg(x) 3011 v0.AddArg(z) 3012 v.AddArg(v0) 3013 return true 3014 } 3015 // match: (Add64 (Sub64 i:(Const64 <t>) z) x) 3016 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 3017 // result: (Add64 i (Sub64 <t> x z)) 3018 for { 3019 _ = v.Args[1] 3020 v_0 := v.Args[0] 3021 if v_0.Op != OpSub64 { 3022 break 3023 } 3024 _ = v_0.Args[1] 3025 i := v_0.Args[0] 3026 if i.Op != OpConst64 { 3027 break 3028 } 3029 t := i.Type 3030 z := v_0.Args[1] 3031 x := v.Args[1] 3032 if !(z.Op != OpConst64 && x.Op != OpConst64) { 3033 break 3034 } 3035 v.reset(OpAdd64) 3036 v.AddArg(i) 3037 v0 := b.NewValue0(v.Pos, OpSub64, t) 3038 v0.AddArg(x) 3039 v0.AddArg(z) 3040 v.AddArg(v0) 3041 return true 3042 } 3043 // match: (Add64 (Sub64 z i:(Const64 <t>)) x) 3044 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 3045 // result: (Sub64 (Add64 <t> x z) i) 3046 for { 3047 _ = v.Args[1] 3048 v_0 := v.Args[0] 3049 if v_0.Op != OpSub64 { 3050 break 3051 } 3052 _ = v_0.Args[1] 3053 z := v_0.Args[0] 3054 i := v_0.Args[1] 3055 if i.Op != OpConst64 { 3056 break 3057 } 3058 t := i.Type 3059 x := v.Args[1] 3060 if !(z.Op != OpConst64 && x.Op != OpConst64) { 3061 break 3062 } 3063 v.reset(OpSub64) 3064 v0 := b.NewValue0(v.Pos, OpAdd64, t) 3065 v0.AddArg(x) 3066 v0.AddArg(z) 3067 v.AddArg(v0) 3068 v.AddArg(i) 3069 return true 3070 } 3071 // match: (Add64 x (Sub64 z i:(Const64 <t>))) 3072 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 3073 // result: (Sub64 (Add64 <t> x z) i) 3074 for { 3075 _ = v.Args[1] 3076 x := v.Args[0] 3077 v_1 := v.Args[1] 3078 if v_1.Op != OpSub64 { 3079 break 3080 } 3081 _ = v_1.Args[1] 3082 z := v_1.Args[0] 3083 i := v_1.Args[1] 3084 if i.Op != OpConst64 { 3085 break 3086 } 3087 t := i.Type 3088 if !(z.Op != OpConst64 && x.Op != OpConst64) { 3089 break 3090 } 3091 v.reset(OpSub64) 3092 v0 := b.NewValue0(v.Pos, OpAdd64, t) 3093 v0.AddArg(x) 3094 v0.AddArg(z) 3095 v.AddArg(v0) 3096 v.AddArg(i) 3097 return true 3098 } 3099 // match: (Add64 x (Sub64 z i:(Const64 <t>))) 3100 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 3101 // result: (Sub64 (Add64 <t> x z) i) 3102 for { 3103 _ = v.Args[1] 3104 x := v.Args[0] 3105 v_1 := v.Args[1] 3106 if v_1.Op != OpSub64 { 3107 break 3108 } 3109 _ = v_1.Args[1] 3110 z := v_1.Args[0] 3111 i := v_1.Args[1] 3112 if i.Op != OpConst64 { 3113 break 3114 } 3115 t := i.Type 3116 if !(z.Op != OpConst64 && x.Op != OpConst64) { 3117 break 3118 } 3119 v.reset(OpSub64) 3120 v0 := b.NewValue0(v.Pos, OpAdd64, t) 3121 v0.AddArg(x) 3122 v0.AddArg(z) 3123 v.AddArg(v0) 3124 v.AddArg(i) 3125 return true 3126 } 3127 // match: (Add64 (Sub64 z i:(Const64 <t>)) x) 3128 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 3129 // result: (Sub64 (Add64 <t> x z) i) 3130 for { 3131 _ = v.Args[1] 3132 v_0 := v.Args[0] 3133 if v_0.Op != OpSub64 { 3134 break 3135 } 3136 _ = v_0.Args[1] 3137 z := v_0.Args[0] 3138 i := v_0.Args[1] 3139 if i.Op != OpConst64 { 3140 break 3141 } 3142 t := i.Type 3143 x := v.Args[1] 3144 if !(z.Op != OpConst64 && x.Op != OpConst64) { 3145 break 3146 } 3147 v.reset(OpSub64) 3148 v0 := b.NewValue0(v.Pos, OpAdd64, t) 3149 v0.AddArg(x) 3150 v0.AddArg(z) 3151 v.AddArg(v0) 3152 v.AddArg(i) 3153 return true 3154 } 3155 // match: (Add64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x)) 3156 // cond: 3157 // result: (Add64 (Const64 <t> [c+d]) x) 3158 for { 3159 _ = v.Args[1] 3160 v_0 := v.Args[0] 3161 if v_0.Op != OpConst64 { 3162 break 3163 } 3164 t := v_0.Type 3165 c := v_0.AuxInt 3166 v_1 := v.Args[1] 3167 if v_1.Op != OpAdd64 { 3168 break 3169 } 3170 _ = v_1.Args[1] 3171 v_1_0 := v_1.Args[0] 3172 if v_1_0.Op != OpConst64 { 3173 break 3174 } 3175 if v_1_0.Type != t { 3176 break 3177 } 3178 d := v_1_0.AuxInt 3179 x := v_1.Args[1] 3180 v.reset(OpAdd64) 3181 v0 := b.NewValue0(v.Pos, OpConst64, t) 3182 v0.AuxInt = c + d 3183 v.AddArg(v0) 3184 v.AddArg(x) 3185 return true 3186 } 3187 // match: (Add64 (Const64 <t> [c]) (Add64 x (Const64 <t> [d]))) 3188 // cond: 3189 // result: (Add64 (Const64 <t> [c+d]) x) 3190 for { 3191 _ = v.Args[1] 3192 v_0 := v.Args[0] 3193 if v_0.Op != OpConst64 { 3194 break 3195 } 3196 t := v_0.Type 3197 c := v_0.AuxInt 3198 v_1 := v.Args[1] 3199 if v_1.Op != OpAdd64 { 3200 break 3201 } 3202 _ = v_1.Args[1] 3203 x := v_1.Args[0] 3204 v_1_1 := v_1.Args[1] 3205 if v_1_1.Op != OpConst64 { 3206 break 3207 } 3208 if v_1_1.Type != t { 3209 break 3210 } 3211 d := v_1_1.AuxInt 3212 v.reset(OpAdd64) 3213 v0 := b.NewValue0(v.Pos, OpConst64, t) 3214 v0.AuxInt = c + d 3215 v.AddArg(v0) 3216 v.AddArg(x) 3217 return true 3218 } 3219 // match: (Add64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c])) 3220 // cond: 3221 // result: (Add64 (Const64 <t> [c+d]) x) 3222 for { 3223 _ = v.Args[1] 3224 v_0 := v.Args[0] 3225 if v_0.Op != OpAdd64 { 3226 break 3227 } 3228 _ = v_0.Args[1] 3229 v_0_0 := v_0.Args[0] 3230 if v_0_0.Op != OpConst64 { 3231 break 3232 } 3233 t := v_0_0.Type 3234 d := v_0_0.AuxInt 3235 x := v_0.Args[1] 3236 v_1 := v.Args[1] 3237 if v_1.Op != OpConst64 { 3238 break 3239 } 3240 if v_1.Type != t { 3241 break 3242 } 3243 c := v_1.AuxInt 3244 v.reset(OpAdd64) 3245 v0 := b.NewValue0(v.Pos, OpConst64, t) 3246 v0.AuxInt = c + d 3247 v.AddArg(v0) 3248 v.AddArg(x) 3249 return true 3250 } 3251 // match: (Add64 (Add64 x (Const64 <t> [d])) (Const64 <t> [c])) 3252 // cond: 3253 // result: (Add64 (Const64 <t> [c+d]) x) 3254 for { 3255 _ = v.Args[1] 3256 v_0 := v.Args[0] 3257 if v_0.Op != OpAdd64 { 3258 break 3259 } 3260 _ = v_0.Args[1] 3261 x := v_0.Args[0] 3262 v_0_1 := v_0.Args[1] 3263 if v_0_1.Op != OpConst64 { 3264 break 3265 } 3266 t := v_0_1.Type 3267 d := v_0_1.AuxInt 3268 v_1 := v.Args[1] 3269 if v_1.Op != OpConst64 { 3270 break 3271 } 3272 if v_1.Type != t { 3273 break 3274 } 3275 c := v_1.AuxInt 3276 v.reset(OpAdd64) 3277 v0 := b.NewValue0(v.Pos, OpConst64, t) 3278 v0.AuxInt = c + d 3279 v.AddArg(v0) 3280 v.AddArg(x) 3281 return true 3282 } 3283 return false 3284 } 3285 func rewriteValuegeneric_OpAdd64_30(v *Value) bool { 3286 b := v.Block 3287 _ = b 3288 // match: (Add64 (Const64 <t> [c]) (Sub64 (Const64 <t> [d]) x)) 3289 // cond: 3290 // result: (Sub64 (Const64 <t> [c+d]) x) 3291 for { 3292 _ = v.Args[1] 3293 v_0 := v.Args[0] 3294 if v_0.Op != OpConst64 { 3295 break 3296 } 3297 t := v_0.Type 3298 c := v_0.AuxInt 3299 v_1 := v.Args[1] 3300 if v_1.Op != OpSub64 { 3301 break 3302 } 3303 _ = v_1.Args[1] 3304 v_1_0 := v_1.Args[0] 3305 if v_1_0.Op != OpConst64 { 3306 break 3307 } 3308 if v_1_0.Type != t { 3309 break 3310 } 3311 d := v_1_0.AuxInt 3312 x := v_1.Args[1] 3313 v.reset(OpSub64) 3314 v0 := b.NewValue0(v.Pos, OpConst64, t) 3315 v0.AuxInt = c + d 3316 v.AddArg(v0) 3317 v.AddArg(x) 3318 return true 3319 } 3320 // match: (Add64 (Sub64 (Const64 <t> [d]) x) (Const64 <t> [c])) 3321 // cond: 3322 // result: (Sub64 (Const64 <t> [c+d]) x) 3323 for { 3324 _ = v.Args[1] 3325 v_0 := v.Args[0] 3326 if v_0.Op != OpSub64 { 3327 break 3328 } 3329 _ = v_0.Args[1] 3330 v_0_0 := v_0.Args[0] 3331 if v_0_0.Op != OpConst64 { 3332 break 3333 } 3334 t := v_0_0.Type 3335 d := v_0_0.AuxInt 3336 x := v_0.Args[1] 3337 v_1 := v.Args[1] 3338 if v_1.Op != OpConst64 { 3339 break 3340 } 3341 if v_1.Type != t { 3342 break 3343 } 3344 c := v_1.AuxInt 3345 v.reset(OpSub64) 3346 v0 := b.NewValue0(v.Pos, OpConst64, t) 3347 v0.AuxInt = c + d 3348 v.AddArg(v0) 3349 v.AddArg(x) 3350 return true 3351 } 3352 // match: (Add64 (Const64 <t> [c]) (Sub64 x (Const64 <t> [d]))) 3353 // cond: 3354 // result: (Add64 (Const64 <t> [c-d]) x) 3355 for { 3356 _ = v.Args[1] 3357 v_0 := v.Args[0] 3358 if v_0.Op != OpConst64 { 3359 break 3360 } 3361 t := v_0.Type 3362 c := v_0.AuxInt 3363 v_1 := v.Args[1] 3364 if v_1.Op != OpSub64 { 3365 break 3366 } 3367 _ = v_1.Args[1] 3368 x := v_1.Args[0] 3369 v_1_1 := v_1.Args[1] 3370 if v_1_1.Op != OpConst64 { 3371 break 3372 } 3373 if v_1_1.Type != t { 3374 break 3375 } 3376 d := v_1_1.AuxInt 3377 v.reset(OpAdd64) 3378 v0 := b.NewValue0(v.Pos, OpConst64, t) 3379 v0.AuxInt = c - d 3380 v.AddArg(v0) 3381 v.AddArg(x) 3382 return true 3383 } 3384 // match: (Add64 (Sub64 x (Const64 <t> [d])) (Const64 <t> [c])) 3385 // cond: 3386 // result: (Add64 (Const64 <t> [c-d]) x) 3387 for { 3388 _ = v.Args[1] 3389 v_0 := v.Args[0] 3390 if v_0.Op != OpSub64 { 3391 break 3392 } 3393 _ = v_0.Args[1] 3394 x := v_0.Args[0] 3395 v_0_1 := v_0.Args[1] 3396 if v_0_1.Op != OpConst64 { 3397 break 3398 } 3399 t := v_0_1.Type 3400 d := v_0_1.AuxInt 3401 v_1 := v.Args[1] 3402 if v_1.Op != OpConst64 { 3403 break 3404 } 3405 if v_1.Type != t { 3406 break 3407 } 3408 c := v_1.AuxInt 3409 v.reset(OpAdd64) 3410 v0 := b.NewValue0(v.Pos, OpConst64, t) 3411 v0.AuxInt = c - d 3412 v.AddArg(v0) 3413 v.AddArg(x) 3414 return true 3415 } 3416 return false 3417 } 3418 func rewriteValuegeneric_OpAdd64F_0(v *Value) bool { 3419 // match: (Add64F (Const64F [c]) (Const64F [d])) 3420 // cond: 3421 // result: (Const64F [auxFrom64F(auxTo64F(c) + auxTo64F(d))]) 3422 for { 3423 _ = v.Args[1] 3424 v_0 := v.Args[0] 3425 if v_0.Op != OpConst64F { 3426 break 3427 } 3428 c := v_0.AuxInt 3429 v_1 := v.Args[1] 3430 if v_1.Op != OpConst64F { 3431 break 3432 } 3433 d := v_1.AuxInt 3434 v.reset(OpConst64F) 3435 v.AuxInt = auxFrom64F(auxTo64F(c) + auxTo64F(d)) 3436 return true 3437 } 3438 // match: (Add64F (Const64F [d]) (Const64F [c])) 3439 // cond: 3440 // result: (Const64F [auxFrom64F(auxTo64F(c) + auxTo64F(d))]) 3441 for { 3442 _ = v.Args[1] 3443 v_0 := v.Args[0] 3444 if v_0.Op != OpConst64F { 3445 break 3446 } 3447 d := v_0.AuxInt 3448 v_1 := v.Args[1] 3449 if v_1.Op != OpConst64F { 3450 break 3451 } 3452 c := v_1.AuxInt 3453 v.reset(OpConst64F) 3454 v.AuxInt = auxFrom64F(auxTo64F(c) + auxTo64F(d)) 3455 return true 3456 } 3457 return false 3458 } 3459 func rewriteValuegeneric_OpAdd8_0(v *Value) bool { 3460 b := v.Block 3461 _ = b 3462 // match: (Add8 (Const8 [c]) (Const8 [d])) 3463 // cond: 3464 // result: (Const8 [int64(int8(c+d))]) 3465 for { 3466 _ = v.Args[1] 3467 v_0 := v.Args[0] 3468 if v_0.Op != OpConst8 { 3469 break 3470 } 3471 c := v_0.AuxInt 3472 v_1 := v.Args[1] 3473 if v_1.Op != OpConst8 { 3474 break 3475 } 3476 d := v_1.AuxInt 3477 v.reset(OpConst8) 3478 v.AuxInt = int64(int8(c + d)) 3479 return true 3480 } 3481 // match: (Add8 (Const8 [d]) (Const8 [c])) 3482 // cond: 3483 // result: (Const8 [int64(int8(c+d))]) 3484 for { 3485 _ = v.Args[1] 3486 v_0 := v.Args[0] 3487 if v_0.Op != OpConst8 { 3488 break 3489 } 3490 d := v_0.AuxInt 3491 v_1 := v.Args[1] 3492 if v_1.Op != OpConst8 { 3493 break 3494 } 3495 c := v_1.AuxInt 3496 v.reset(OpConst8) 3497 v.AuxInt = int64(int8(c + d)) 3498 return true 3499 } 3500 // match: (Add8 <t> (Mul8 x y) (Mul8 x z)) 3501 // cond: 3502 // result: (Mul8 x (Add8 <t> y z)) 3503 for { 3504 t := v.Type 3505 _ = v.Args[1] 3506 v_0 := v.Args[0] 3507 if v_0.Op != OpMul8 { 3508 break 3509 } 3510 _ = v_0.Args[1] 3511 x := v_0.Args[0] 3512 y := v_0.Args[1] 3513 v_1 := v.Args[1] 3514 if v_1.Op != OpMul8 { 3515 break 3516 } 3517 _ = v_1.Args[1] 3518 if x != v_1.Args[0] { 3519 break 3520 } 3521 z := v_1.Args[1] 3522 v.reset(OpMul8) 3523 v.AddArg(x) 3524 v0 := b.NewValue0(v.Pos, OpAdd8, t) 3525 v0.AddArg(y) 3526 v0.AddArg(z) 3527 v.AddArg(v0) 3528 return true 3529 } 3530 // match: (Add8 <t> (Mul8 y x) (Mul8 x z)) 3531 // cond: 3532 // result: (Mul8 x (Add8 <t> y z)) 3533 for { 3534 t := v.Type 3535 _ = v.Args[1] 3536 v_0 := v.Args[0] 3537 if v_0.Op != OpMul8 { 3538 break 3539 } 3540 _ = v_0.Args[1] 3541 y := v_0.Args[0] 3542 x := v_0.Args[1] 3543 v_1 := v.Args[1] 3544 if v_1.Op != OpMul8 { 3545 break 3546 } 3547 _ = v_1.Args[1] 3548 if x != v_1.Args[0] { 3549 break 3550 } 3551 z := v_1.Args[1] 3552 v.reset(OpMul8) 3553 v.AddArg(x) 3554 v0 := b.NewValue0(v.Pos, OpAdd8, t) 3555 v0.AddArg(y) 3556 v0.AddArg(z) 3557 v.AddArg(v0) 3558 return true 3559 } 3560 // match: (Add8 <t> (Mul8 x y) (Mul8 z x)) 3561 // cond: 3562 // result: (Mul8 x (Add8 <t> y z)) 3563 for { 3564 t := v.Type 3565 _ = v.Args[1] 3566 v_0 := v.Args[0] 3567 if v_0.Op != OpMul8 { 3568 break 3569 } 3570 _ = v_0.Args[1] 3571 x := v_0.Args[0] 3572 y := v_0.Args[1] 3573 v_1 := v.Args[1] 3574 if v_1.Op != OpMul8 { 3575 break 3576 } 3577 _ = v_1.Args[1] 3578 z := v_1.Args[0] 3579 if x != v_1.Args[1] { 3580 break 3581 } 3582 v.reset(OpMul8) 3583 v.AddArg(x) 3584 v0 := b.NewValue0(v.Pos, OpAdd8, t) 3585 v0.AddArg(y) 3586 v0.AddArg(z) 3587 v.AddArg(v0) 3588 return true 3589 } 3590 // match: (Add8 <t> (Mul8 y x) (Mul8 z x)) 3591 // cond: 3592 // result: (Mul8 x (Add8 <t> y z)) 3593 for { 3594 t := v.Type 3595 _ = v.Args[1] 3596 v_0 := v.Args[0] 3597 if v_0.Op != OpMul8 { 3598 break 3599 } 3600 _ = v_0.Args[1] 3601 y := v_0.Args[0] 3602 x := v_0.Args[1] 3603 v_1 := v.Args[1] 3604 if v_1.Op != OpMul8 { 3605 break 3606 } 3607 _ = v_1.Args[1] 3608 z := v_1.Args[0] 3609 if x != v_1.Args[1] { 3610 break 3611 } 3612 v.reset(OpMul8) 3613 v.AddArg(x) 3614 v0 := b.NewValue0(v.Pos, OpAdd8, t) 3615 v0.AddArg(y) 3616 v0.AddArg(z) 3617 v.AddArg(v0) 3618 return true 3619 } 3620 // match: (Add8 <t> (Mul8 x z) (Mul8 x y)) 3621 // cond: 3622 // result: (Mul8 x (Add8 <t> y z)) 3623 for { 3624 t := v.Type 3625 _ = v.Args[1] 3626 v_0 := v.Args[0] 3627 if v_0.Op != OpMul8 { 3628 break 3629 } 3630 _ = v_0.Args[1] 3631 x := v_0.Args[0] 3632 z := v_0.Args[1] 3633 v_1 := v.Args[1] 3634 if v_1.Op != OpMul8 { 3635 break 3636 } 3637 _ = v_1.Args[1] 3638 if x != v_1.Args[0] { 3639 break 3640 } 3641 y := v_1.Args[1] 3642 v.reset(OpMul8) 3643 v.AddArg(x) 3644 v0 := b.NewValue0(v.Pos, OpAdd8, t) 3645 v0.AddArg(y) 3646 v0.AddArg(z) 3647 v.AddArg(v0) 3648 return true 3649 } 3650 // match: (Add8 <t> (Mul8 z x) (Mul8 x y)) 3651 // cond: 3652 // result: (Mul8 x (Add8 <t> y z)) 3653 for { 3654 t := v.Type 3655 _ = v.Args[1] 3656 v_0 := v.Args[0] 3657 if v_0.Op != OpMul8 { 3658 break 3659 } 3660 _ = v_0.Args[1] 3661 z := v_0.Args[0] 3662 x := v_0.Args[1] 3663 v_1 := v.Args[1] 3664 if v_1.Op != OpMul8 { 3665 break 3666 } 3667 _ = v_1.Args[1] 3668 if x != v_1.Args[0] { 3669 break 3670 } 3671 y := v_1.Args[1] 3672 v.reset(OpMul8) 3673 v.AddArg(x) 3674 v0 := b.NewValue0(v.Pos, OpAdd8, t) 3675 v0.AddArg(y) 3676 v0.AddArg(z) 3677 v.AddArg(v0) 3678 return true 3679 } 3680 // match: (Add8 <t> (Mul8 x z) (Mul8 y x)) 3681 // cond: 3682 // result: (Mul8 x (Add8 <t> y z)) 3683 for { 3684 t := v.Type 3685 _ = v.Args[1] 3686 v_0 := v.Args[0] 3687 if v_0.Op != OpMul8 { 3688 break 3689 } 3690 _ = v_0.Args[1] 3691 x := v_0.Args[0] 3692 z := v_0.Args[1] 3693 v_1 := v.Args[1] 3694 if v_1.Op != OpMul8 { 3695 break 3696 } 3697 _ = v_1.Args[1] 3698 y := v_1.Args[0] 3699 if x != v_1.Args[1] { 3700 break 3701 } 3702 v.reset(OpMul8) 3703 v.AddArg(x) 3704 v0 := b.NewValue0(v.Pos, OpAdd8, t) 3705 v0.AddArg(y) 3706 v0.AddArg(z) 3707 v.AddArg(v0) 3708 return true 3709 } 3710 // match: (Add8 <t> (Mul8 z x) (Mul8 y x)) 3711 // cond: 3712 // result: (Mul8 x (Add8 <t> y z)) 3713 for { 3714 t := v.Type 3715 _ = v.Args[1] 3716 v_0 := v.Args[0] 3717 if v_0.Op != OpMul8 { 3718 break 3719 } 3720 _ = v_0.Args[1] 3721 z := v_0.Args[0] 3722 x := v_0.Args[1] 3723 v_1 := v.Args[1] 3724 if v_1.Op != OpMul8 { 3725 break 3726 } 3727 _ = v_1.Args[1] 3728 y := v_1.Args[0] 3729 if x != v_1.Args[1] { 3730 break 3731 } 3732 v.reset(OpMul8) 3733 v.AddArg(x) 3734 v0 := b.NewValue0(v.Pos, OpAdd8, t) 3735 v0.AddArg(y) 3736 v0.AddArg(z) 3737 v.AddArg(v0) 3738 return true 3739 } 3740 return false 3741 } 3742 func rewriteValuegeneric_OpAdd8_10(v *Value) bool { 3743 b := v.Block 3744 _ = b 3745 // match: (Add8 (Const8 [0]) x) 3746 // cond: 3747 // result: x 3748 for { 3749 _ = v.Args[1] 3750 v_0 := v.Args[0] 3751 if v_0.Op != OpConst8 { 3752 break 3753 } 3754 if v_0.AuxInt != 0 { 3755 break 3756 } 3757 x := v.Args[1] 3758 v.reset(OpCopy) 3759 v.Type = x.Type 3760 v.AddArg(x) 3761 return true 3762 } 3763 // match: (Add8 x (Const8 [0])) 3764 // cond: 3765 // result: x 3766 for { 3767 _ = v.Args[1] 3768 x := v.Args[0] 3769 v_1 := v.Args[1] 3770 if v_1.Op != OpConst8 { 3771 break 3772 } 3773 if v_1.AuxInt != 0 { 3774 break 3775 } 3776 v.reset(OpCopy) 3777 v.Type = x.Type 3778 v.AddArg(x) 3779 return true 3780 } 3781 // match: (Add8 (Const8 [1]) (Com8 x)) 3782 // cond: 3783 // result: (Neg8 x) 3784 for { 3785 _ = v.Args[1] 3786 v_0 := v.Args[0] 3787 if v_0.Op != OpConst8 { 3788 break 3789 } 3790 if v_0.AuxInt != 1 { 3791 break 3792 } 3793 v_1 := v.Args[1] 3794 if v_1.Op != OpCom8 { 3795 break 3796 } 3797 x := v_1.Args[0] 3798 v.reset(OpNeg8) 3799 v.AddArg(x) 3800 return true 3801 } 3802 // match: (Add8 (Com8 x) (Const8 [1])) 3803 // cond: 3804 // result: (Neg8 x) 3805 for { 3806 _ = v.Args[1] 3807 v_0 := v.Args[0] 3808 if v_0.Op != OpCom8 { 3809 break 3810 } 3811 x := v_0.Args[0] 3812 v_1 := v.Args[1] 3813 if v_1.Op != OpConst8 { 3814 break 3815 } 3816 if v_1.AuxInt != 1 { 3817 break 3818 } 3819 v.reset(OpNeg8) 3820 v.AddArg(x) 3821 return true 3822 } 3823 // match: (Add8 (Add8 i:(Const8 <t>) z) x) 3824 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 3825 // result: (Add8 i (Add8 <t> z x)) 3826 for { 3827 _ = v.Args[1] 3828 v_0 := v.Args[0] 3829 if v_0.Op != OpAdd8 { 3830 break 3831 } 3832 _ = v_0.Args[1] 3833 i := v_0.Args[0] 3834 if i.Op != OpConst8 { 3835 break 3836 } 3837 t := i.Type 3838 z := v_0.Args[1] 3839 x := v.Args[1] 3840 if !(z.Op != OpConst8 && x.Op != OpConst8) { 3841 break 3842 } 3843 v.reset(OpAdd8) 3844 v.AddArg(i) 3845 v0 := b.NewValue0(v.Pos, OpAdd8, t) 3846 v0.AddArg(z) 3847 v0.AddArg(x) 3848 v.AddArg(v0) 3849 return true 3850 } 3851 // match: (Add8 (Add8 z i:(Const8 <t>)) x) 3852 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 3853 // result: (Add8 i (Add8 <t> z x)) 3854 for { 3855 _ = v.Args[1] 3856 v_0 := v.Args[0] 3857 if v_0.Op != OpAdd8 { 3858 break 3859 } 3860 _ = v_0.Args[1] 3861 z := v_0.Args[0] 3862 i := v_0.Args[1] 3863 if i.Op != OpConst8 { 3864 break 3865 } 3866 t := i.Type 3867 x := v.Args[1] 3868 if !(z.Op != OpConst8 && x.Op != OpConst8) { 3869 break 3870 } 3871 v.reset(OpAdd8) 3872 v.AddArg(i) 3873 v0 := b.NewValue0(v.Pos, OpAdd8, t) 3874 v0.AddArg(z) 3875 v0.AddArg(x) 3876 v.AddArg(v0) 3877 return true 3878 } 3879 // match: (Add8 x (Add8 i:(Const8 <t>) z)) 3880 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 3881 // result: (Add8 i (Add8 <t> z x)) 3882 for { 3883 _ = v.Args[1] 3884 x := v.Args[0] 3885 v_1 := v.Args[1] 3886 if v_1.Op != OpAdd8 { 3887 break 3888 } 3889 _ = v_1.Args[1] 3890 i := v_1.Args[0] 3891 if i.Op != OpConst8 { 3892 break 3893 } 3894 t := i.Type 3895 z := v_1.Args[1] 3896 if !(z.Op != OpConst8 && x.Op != OpConst8) { 3897 break 3898 } 3899 v.reset(OpAdd8) 3900 v.AddArg(i) 3901 v0 := b.NewValue0(v.Pos, OpAdd8, t) 3902 v0.AddArg(z) 3903 v0.AddArg(x) 3904 v.AddArg(v0) 3905 return true 3906 } 3907 // match: (Add8 x (Add8 z i:(Const8 <t>))) 3908 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 3909 // result: (Add8 i (Add8 <t> z x)) 3910 for { 3911 _ = v.Args[1] 3912 x := v.Args[0] 3913 v_1 := v.Args[1] 3914 if v_1.Op != OpAdd8 { 3915 break 3916 } 3917 _ = v_1.Args[1] 3918 z := v_1.Args[0] 3919 i := v_1.Args[1] 3920 if i.Op != OpConst8 { 3921 break 3922 } 3923 t := i.Type 3924 if !(z.Op != OpConst8 && x.Op != OpConst8) { 3925 break 3926 } 3927 v.reset(OpAdd8) 3928 v.AddArg(i) 3929 v0 := b.NewValue0(v.Pos, OpAdd8, t) 3930 v0.AddArg(z) 3931 v0.AddArg(x) 3932 v.AddArg(v0) 3933 return true 3934 } 3935 // match: (Add8 (Sub8 i:(Const8 <t>) z) x) 3936 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 3937 // result: (Add8 i (Sub8 <t> x z)) 3938 for { 3939 _ = v.Args[1] 3940 v_0 := v.Args[0] 3941 if v_0.Op != OpSub8 { 3942 break 3943 } 3944 _ = v_0.Args[1] 3945 i := v_0.Args[0] 3946 if i.Op != OpConst8 { 3947 break 3948 } 3949 t := i.Type 3950 z := v_0.Args[1] 3951 x := v.Args[1] 3952 if !(z.Op != OpConst8 && x.Op != OpConst8) { 3953 break 3954 } 3955 v.reset(OpAdd8) 3956 v.AddArg(i) 3957 v0 := b.NewValue0(v.Pos, OpSub8, t) 3958 v0.AddArg(x) 3959 v0.AddArg(z) 3960 v.AddArg(v0) 3961 return true 3962 } 3963 // match: (Add8 x (Sub8 i:(Const8 <t>) z)) 3964 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 3965 // result: (Add8 i (Sub8 <t> x z)) 3966 for { 3967 _ = v.Args[1] 3968 x := v.Args[0] 3969 v_1 := v.Args[1] 3970 if v_1.Op != OpSub8 { 3971 break 3972 } 3973 _ = v_1.Args[1] 3974 i := v_1.Args[0] 3975 if i.Op != OpConst8 { 3976 break 3977 } 3978 t := i.Type 3979 z := v_1.Args[1] 3980 if !(z.Op != OpConst8 && x.Op != OpConst8) { 3981 break 3982 } 3983 v.reset(OpAdd8) 3984 v.AddArg(i) 3985 v0 := b.NewValue0(v.Pos, OpSub8, t) 3986 v0.AddArg(x) 3987 v0.AddArg(z) 3988 v.AddArg(v0) 3989 return true 3990 } 3991 return false 3992 } 3993 func rewriteValuegeneric_OpAdd8_20(v *Value) bool { 3994 b := v.Block 3995 _ = b 3996 // match: (Add8 x (Sub8 i:(Const8 <t>) z)) 3997 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 3998 // result: (Add8 i (Sub8 <t> x z)) 3999 for { 4000 _ = v.Args[1] 4001 x := v.Args[0] 4002 v_1 := v.Args[1] 4003 if v_1.Op != OpSub8 { 4004 break 4005 } 4006 _ = v_1.Args[1] 4007 i := v_1.Args[0] 4008 if i.Op != OpConst8 { 4009 break 4010 } 4011 t := i.Type 4012 z := v_1.Args[1] 4013 if !(z.Op != OpConst8 && x.Op != OpConst8) { 4014 break 4015 } 4016 v.reset(OpAdd8) 4017 v.AddArg(i) 4018 v0 := b.NewValue0(v.Pos, OpSub8, t) 4019 v0.AddArg(x) 4020 v0.AddArg(z) 4021 v.AddArg(v0) 4022 return true 4023 } 4024 // match: (Add8 (Sub8 i:(Const8 <t>) z) x) 4025 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 4026 // result: (Add8 i (Sub8 <t> x z)) 4027 for { 4028 _ = v.Args[1] 4029 v_0 := v.Args[0] 4030 if v_0.Op != OpSub8 { 4031 break 4032 } 4033 _ = v_0.Args[1] 4034 i := v_0.Args[0] 4035 if i.Op != OpConst8 { 4036 break 4037 } 4038 t := i.Type 4039 z := v_0.Args[1] 4040 x := v.Args[1] 4041 if !(z.Op != OpConst8 && x.Op != OpConst8) { 4042 break 4043 } 4044 v.reset(OpAdd8) 4045 v.AddArg(i) 4046 v0 := b.NewValue0(v.Pos, OpSub8, t) 4047 v0.AddArg(x) 4048 v0.AddArg(z) 4049 v.AddArg(v0) 4050 return true 4051 } 4052 // match: (Add8 (Sub8 z i:(Const8 <t>)) x) 4053 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 4054 // result: (Sub8 (Add8 <t> x z) i) 4055 for { 4056 _ = v.Args[1] 4057 v_0 := v.Args[0] 4058 if v_0.Op != OpSub8 { 4059 break 4060 } 4061 _ = v_0.Args[1] 4062 z := v_0.Args[0] 4063 i := v_0.Args[1] 4064 if i.Op != OpConst8 { 4065 break 4066 } 4067 t := i.Type 4068 x := v.Args[1] 4069 if !(z.Op != OpConst8 && x.Op != OpConst8) { 4070 break 4071 } 4072 v.reset(OpSub8) 4073 v0 := b.NewValue0(v.Pos, OpAdd8, t) 4074 v0.AddArg(x) 4075 v0.AddArg(z) 4076 v.AddArg(v0) 4077 v.AddArg(i) 4078 return true 4079 } 4080 // match: (Add8 x (Sub8 z i:(Const8 <t>))) 4081 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 4082 // result: (Sub8 (Add8 <t> x z) i) 4083 for { 4084 _ = v.Args[1] 4085 x := v.Args[0] 4086 v_1 := v.Args[1] 4087 if v_1.Op != OpSub8 { 4088 break 4089 } 4090 _ = v_1.Args[1] 4091 z := v_1.Args[0] 4092 i := v_1.Args[1] 4093 if i.Op != OpConst8 { 4094 break 4095 } 4096 t := i.Type 4097 if !(z.Op != OpConst8 && x.Op != OpConst8) { 4098 break 4099 } 4100 v.reset(OpSub8) 4101 v0 := b.NewValue0(v.Pos, OpAdd8, t) 4102 v0.AddArg(x) 4103 v0.AddArg(z) 4104 v.AddArg(v0) 4105 v.AddArg(i) 4106 return true 4107 } 4108 // match: (Add8 x (Sub8 z i:(Const8 <t>))) 4109 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 4110 // result: (Sub8 (Add8 <t> x z) i) 4111 for { 4112 _ = v.Args[1] 4113 x := v.Args[0] 4114 v_1 := v.Args[1] 4115 if v_1.Op != OpSub8 { 4116 break 4117 } 4118 _ = v_1.Args[1] 4119 z := v_1.Args[0] 4120 i := v_1.Args[1] 4121 if i.Op != OpConst8 { 4122 break 4123 } 4124 t := i.Type 4125 if !(z.Op != OpConst8 && x.Op != OpConst8) { 4126 break 4127 } 4128 v.reset(OpSub8) 4129 v0 := b.NewValue0(v.Pos, OpAdd8, t) 4130 v0.AddArg(x) 4131 v0.AddArg(z) 4132 v.AddArg(v0) 4133 v.AddArg(i) 4134 return true 4135 } 4136 // match: (Add8 (Sub8 z i:(Const8 <t>)) x) 4137 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 4138 // result: (Sub8 (Add8 <t> x z) i) 4139 for { 4140 _ = v.Args[1] 4141 v_0 := v.Args[0] 4142 if v_0.Op != OpSub8 { 4143 break 4144 } 4145 _ = v_0.Args[1] 4146 z := v_0.Args[0] 4147 i := v_0.Args[1] 4148 if i.Op != OpConst8 { 4149 break 4150 } 4151 t := i.Type 4152 x := v.Args[1] 4153 if !(z.Op != OpConst8 && x.Op != OpConst8) { 4154 break 4155 } 4156 v.reset(OpSub8) 4157 v0 := b.NewValue0(v.Pos, OpAdd8, t) 4158 v0.AddArg(x) 4159 v0.AddArg(z) 4160 v.AddArg(v0) 4161 v.AddArg(i) 4162 return true 4163 } 4164 // match: (Add8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x)) 4165 // cond: 4166 // result: (Add8 (Const8 <t> [int64(int8(c+d))]) x) 4167 for { 4168 _ = v.Args[1] 4169 v_0 := v.Args[0] 4170 if v_0.Op != OpConst8 { 4171 break 4172 } 4173 t := v_0.Type 4174 c := v_0.AuxInt 4175 v_1 := v.Args[1] 4176 if v_1.Op != OpAdd8 { 4177 break 4178 } 4179 _ = v_1.Args[1] 4180 v_1_0 := v_1.Args[0] 4181 if v_1_0.Op != OpConst8 { 4182 break 4183 } 4184 if v_1_0.Type != t { 4185 break 4186 } 4187 d := v_1_0.AuxInt 4188 x := v_1.Args[1] 4189 v.reset(OpAdd8) 4190 v0 := b.NewValue0(v.Pos, OpConst8, t) 4191 v0.AuxInt = int64(int8(c + d)) 4192 v.AddArg(v0) 4193 v.AddArg(x) 4194 return true 4195 } 4196 // match: (Add8 (Const8 <t> [c]) (Add8 x (Const8 <t> [d]))) 4197 // cond: 4198 // result: (Add8 (Const8 <t> [int64(int8(c+d))]) x) 4199 for { 4200 _ = v.Args[1] 4201 v_0 := v.Args[0] 4202 if v_0.Op != OpConst8 { 4203 break 4204 } 4205 t := v_0.Type 4206 c := v_0.AuxInt 4207 v_1 := v.Args[1] 4208 if v_1.Op != OpAdd8 { 4209 break 4210 } 4211 _ = v_1.Args[1] 4212 x := v_1.Args[0] 4213 v_1_1 := v_1.Args[1] 4214 if v_1_1.Op != OpConst8 { 4215 break 4216 } 4217 if v_1_1.Type != t { 4218 break 4219 } 4220 d := v_1_1.AuxInt 4221 v.reset(OpAdd8) 4222 v0 := b.NewValue0(v.Pos, OpConst8, t) 4223 v0.AuxInt = int64(int8(c + d)) 4224 v.AddArg(v0) 4225 v.AddArg(x) 4226 return true 4227 } 4228 // match: (Add8 (Add8 (Const8 <t> [d]) x) (Const8 <t> [c])) 4229 // cond: 4230 // result: (Add8 (Const8 <t> [int64(int8(c+d))]) x) 4231 for { 4232 _ = v.Args[1] 4233 v_0 := v.Args[0] 4234 if v_0.Op != OpAdd8 { 4235 break 4236 } 4237 _ = v_0.Args[1] 4238 v_0_0 := v_0.Args[0] 4239 if v_0_0.Op != OpConst8 { 4240 break 4241 } 4242 t := v_0_0.Type 4243 d := v_0_0.AuxInt 4244 x := v_0.Args[1] 4245 v_1 := v.Args[1] 4246 if v_1.Op != OpConst8 { 4247 break 4248 } 4249 if v_1.Type != t { 4250 break 4251 } 4252 c := v_1.AuxInt 4253 v.reset(OpAdd8) 4254 v0 := b.NewValue0(v.Pos, OpConst8, t) 4255 v0.AuxInt = int64(int8(c + d)) 4256 v.AddArg(v0) 4257 v.AddArg(x) 4258 return true 4259 } 4260 // match: (Add8 (Add8 x (Const8 <t> [d])) (Const8 <t> [c])) 4261 // cond: 4262 // result: (Add8 (Const8 <t> [int64(int8(c+d))]) x) 4263 for { 4264 _ = v.Args[1] 4265 v_0 := v.Args[0] 4266 if v_0.Op != OpAdd8 { 4267 break 4268 } 4269 _ = v_0.Args[1] 4270 x := v_0.Args[0] 4271 v_0_1 := v_0.Args[1] 4272 if v_0_1.Op != OpConst8 { 4273 break 4274 } 4275 t := v_0_1.Type 4276 d := v_0_1.AuxInt 4277 v_1 := v.Args[1] 4278 if v_1.Op != OpConst8 { 4279 break 4280 } 4281 if v_1.Type != t { 4282 break 4283 } 4284 c := v_1.AuxInt 4285 v.reset(OpAdd8) 4286 v0 := b.NewValue0(v.Pos, OpConst8, t) 4287 v0.AuxInt = int64(int8(c + d)) 4288 v.AddArg(v0) 4289 v.AddArg(x) 4290 return true 4291 } 4292 return false 4293 } 4294 func rewriteValuegeneric_OpAdd8_30(v *Value) bool { 4295 b := v.Block 4296 _ = b 4297 // match: (Add8 (Const8 <t> [c]) (Sub8 (Const8 <t> [d]) x)) 4298 // cond: 4299 // result: (Sub8 (Const8 <t> [int64(int8(c+d))]) x) 4300 for { 4301 _ = v.Args[1] 4302 v_0 := v.Args[0] 4303 if v_0.Op != OpConst8 { 4304 break 4305 } 4306 t := v_0.Type 4307 c := v_0.AuxInt 4308 v_1 := v.Args[1] 4309 if v_1.Op != OpSub8 { 4310 break 4311 } 4312 _ = v_1.Args[1] 4313 v_1_0 := v_1.Args[0] 4314 if v_1_0.Op != OpConst8 { 4315 break 4316 } 4317 if v_1_0.Type != t { 4318 break 4319 } 4320 d := v_1_0.AuxInt 4321 x := v_1.Args[1] 4322 v.reset(OpSub8) 4323 v0 := b.NewValue0(v.Pos, OpConst8, t) 4324 v0.AuxInt = int64(int8(c + d)) 4325 v.AddArg(v0) 4326 v.AddArg(x) 4327 return true 4328 } 4329 // match: (Add8 (Sub8 (Const8 <t> [d]) x) (Const8 <t> [c])) 4330 // cond: 4331 // result: (Sub8 (Const8 <t> [int64(int8(c+d))]) x) 4332 for { 4333 _ = v.Args[1] 4334 v_0 := v.Args[0] 4335 if v_0.Op != OpSub8 { 4336 break 4337 } 4338 _ = v_0.Args[1] 4339 v_0_0 := v_0.Args[0] 4340 if v_0_0.Op != OpConst8 { 4341 break 4342 } 4343 t := v_0_0.Type 4344 d := v_0_0.AuxInt 4345 x := v_0.Args[1] 4346 v_1 := v.Args[1] 4347 if v_1.Op != OpConst8 { 4348 break 4349 } 4350 if v_1.Type != t { 4351 break 4352 } 4353 c := v_1.AuxInt 4354 v.reset(OpSub8) 4355 v0 := b.NewValue0(v.Pos, OpConst8, t) 4356 v0.AuxInt = int64(int8(c + d)) 4357 v.AddArg(v0) 4358 v.AddArg(x) 4359 return true 4360 } 4361 // match: (Add8 (Const8 <t> [c]) (Sub8 x (Const8 <t> [d]))) 4362 // cond: 4363 // result: (Add8 (Const8 <t> [int64(int8(c-d))]) x) 4364 for { 4365 _ = v.Args[1] 4366 v_0 := v.Args[0] 4367 if v_0.Op != OpConst8 { 4368 break 4369 } 4370 t := v_0.Type 4371 c := v_0.AuxInt 4372 v_1 := v.Args[1] 4373 if v_1.Op != OpSub8 { 4374 break 4375 } 4376 _ = v_1.Args[1] 4377 x := v_1.Args[0] 4378 v_1_1 := v_1.Args[1] 4379 if v_1_1.Op != OpConst8 { 4380 break 4381 } 4382 if v_1_1.Type != t { 4383 break 4384 } 4385 d := v_1_1.AuxInt 4386 v.reset(OpAdd8) 4387 v0 := b.NewValue0(v.Pos, OpConst8, t) 4388 v0.AuxInt = int64(int8(c - d)) 4389 v.AddArg(v0) 4390 v.AddArg(x) 4391 return true 4392 } 4393 // match: (Add8 (Sub8 x (Const8 <t> [d])) (Const8 <t> [c])) 4394 // cond: 4395 // result: (Add8 (Const8 <t> [int64(int8(c-d))]) x) 4396 for { 4397 _ = v.Args[1] 4398 v_0 := v.Args[0] 4399 if v_0.Op != OpSub8 { 4400 break 4401 } 4402 _ = v_0.Args[1] 4403 x := v_0.Args[0] 4404 v_0_1 := v_0.Args[1] 4405 if v_0_1.Op != OpConst8 { 4406 break 4407 } 4408 t := v_0_1.Type 4409 d := v_0_1.AuxInt 4410 v_1 := v.Args[1] 4411 if v_1.Op != OpConst8 { 4412 break 4413 } 4414 if v_1.Type != t { 4415 break 4416 } 4417 c := v_1.AuxInt 4418 v.reset(OpAdd8) 4419 v0 := b.NewValue0(v.Pos, OpConst8, t) 4420 v0.AuxInt = int64(int8(c - d)) 4421 v.AddArg(v0) 4422 v.AddArg(x) 4423 return true 4424 } 4425 return false 4426 } 4427 func rewriteValuegeneric_OpAddPtr_0(v *Value) bool { 4428 // match: (AddPtr <t> x (Const64 [c])) 4429 // cond: 4430 // result: (OffPtr <t> x [c]) 4431 for { 4432 t := v.Type 4433 _ = v.Args[1] 4434 x := v.Args[0] 4435 v_1 := v.Args[1] 4436 if v_1.Op != OpConst64 { 4437 break 4438 } 4439 c := v_1.AuxInt 4440 v.reset(OpOffPtr) 4441 v.Type = t 4442 v.AuxInt = c 4443 v.AddArg(x) 4444 return true 4445 } 4446 // match: (AddPtr <t> x (Const32 [c])) 4447 // cond: 4448 // result: (OffPtr <t> x [c]) 4449 for { 4450 t := v.Type 4451 _ = v.Args[1] 4452 x := v.Args[0] 4453 v_1 := v.Args[1] 4454 if v_1.Op != OpConst32 { 4455 break 4456 } 4457 c := v_1.AuxInt 4458 v.reset(OpOffPtr) 4459 v.Type = t 4460 v.AuxInt = c 4461 v.AddArg(x) 4462 return true 4463 } 4464 return false 4465 } 4466 func rewriteValuegeneric_OpAnd16_0(v *Value) bool { 4467 // match: (And16 (Const16 [c]) (Const16 [d])) 4468 // cond: 4469 // result: (Const16 [int64(int16(c&d))]) 4470 for { 4471 _ = v.Args[1] 4472 v_0 := v.Args[0] 4473 if v_0.Op != OpConst16 { 4474 break 4475 } 4476 c := v_0.AuxInt 4477 v_1 := v.Args[1] 4478 if v_1.Op != OpConst16 { 4479 break 4480 } 4481 d := v_1.AuxInt 4482 v.reset(OpConst16) 4483 v.AuxInt = int64(int16(c & d)) 4484 return true 4485 } 4486 // match: (And16 (Const16 [d]) (Const16 [c])) 4487 // cond: 4488 // result: (Const16 [int64(int16(c&d))]) 4489 for { 4490 _ = v.Args[1] 4491 v_0 := v.Args[0] 4492 if v_0.Op != OpConst16 { 4493 break 4494 } 4495 d := v_0.AuxInt 4496 v_1 := v.Args[1] 4497 if v_1.Op != OpConst16 { 4498 break 4499 } 4500 c := v_1.AuxInt 4501 v.reset(OpConst16) 4502 v.AuxInt = int64(int16(c & d)) 4503 return true 4504 } 4505 // match: (And16 (Const16 [m]) (Rsh16Ux64 _ (Const64 [c]))) 4506 // cond: c >= 64-ntz(m) 4507 // result: (Const16 [0]) 4508 for { 4509 _ = v.Args[1] 4510 v_0 := v.Args[0] 4511 if v_0.Op != OpConst16 { 4512 break 4513 } 4514 m := v_0.AuxInt 4515 v_1 := v.Args[1] 4516 if v_1.Op != OpRsh16Ux64 { 4517 break 4518 } 4519 _ = v_1.Args[1] 4520 v_1_1 := v_1.Args[1] 4521 if v_1_1.Op != OpConst64 { 4522 break 4523 } 4524 c := v_1_1.AuxInt 4525 if !(c >= 64-ntz(m)) { 4526 break 4527 } 4528 v.reset(OpConst16) 4529 v.AuxInt = 0 4530 return true 4531 } 4532 // match: (And16 (Rsh16Ux64 _ (Const64 [c])) (Const16 [m])) 4533 // cond: c >= 64-ntz(m) 4534 // result: (Const16 [0]) 4535 for { 4536 _ = v.Args[1] 4537 v_0 := v.Args[0] 4538 if v_0.Op != OpRsh16Ux64 { 4539 break 4540 } 4541 _ = v_0.Args[1] 4542 v_0_1 := v_0.Args[1] 4543 if v_0_1.Op != OpConst64 { 4544 break 4545 } 4546 c := v_0_1.AuxInt 4547 v_1 := v.Args[1] 4548 if v_1.Op != OpConst16 { 4549 break 4550 } 4551 m := v_1.AuxInt 4552 if !(c >= 64-ntz(m)) { 4553 break 4554 } 4555 v.reset(OpConst16) 4556 v.AuxInt = 0 4557 return true 4558 } 4559 // match: (And16 (Const16 [m]) (Lsh16x64 _ (Const64 [c]))) 4560 // cond: c >= 64-nlz(m) 4561 // result: (Const16 [0]) 4562 for { 4563 _ = v.Args[1] 4564 v_0 := v.Args[0] 4565 if v_0.Op != OpConst16 { 4566 break 4567 } 4568 m := v_0.AuxInt 4569 v_1 := v.Args[1] 4570 if v_1.Op != OpLsh16x64 { 4571 break 4572 } 4573 _ = v_1.Args[1] 4574 v_1_1 := v_1.Args[1] 4575 if v_1_1.Op != OpConst64 { 4576 break 4577 } 4578 c := v_1_1.AuxInt 4579 if !(c >= 64-nlz(m)) { 4580 break 4581 } 4582 v.reset(OpConst16) 4583 v.AuxInt = 0 4584 return true 4585 } 4586 // match: (And16 (Lsh16x64 _ (Const64 [c])) (Const16 [m])) 4587 // cond: c >= 64-nlz(m) 4588 // result: (Const16 [0]) 4589 for { 4590 _ = v.Args[1] 4591 v_0 := v.Args[0] 4592 if v_0.Op != OpLsh16x64 { 4593 break 4594 } 4595 _ = v_0.Args[1] 4596 v_0_1 := v_0.Args[1] 4597 if v_0_1.Op != OpConst64 { 4598 break 4599 } 4600 c := v_0_1.AuxInt 4601 v_1 := v.Args[1] 4602 if v_1.Op != OpConst16 { 4603 break 4604 } 4605 m := v_1.AuxInt 4606 if !(c >= 64-nlz(m)) { 4607 break 4608 } 4609 v.reset(OpConst16) 4610 v.AuxInt = 0 4611 return true 4612 } 4613 // match: (And16 x x) 4614 // cond: 4615 // result: x 4616 for { 4617 _ = v.Args[1] 4618 x := v.Args[0] 4619 if x != v.Args[1] { 4620 break 4621 } 4622 v.reset(OpCopy) 4623 v.Type = x.Type 4624 v.AddArg(x) 4625 return true 4626 } 4627 // match: (And16 (Const16 [-1]) x) 4628 // cond: 4629 // result: x 4630 for { 4631 _ = v.Args[1] 4632 v_0 := v.Args[0] 4633 if v_0.Op != OpConst16 { 4634 break 4635 } 4636 if v_0.AuxInt != -1 { 4637 break 4638 } 4639 x := v.Args[1] 4640 v.reset(OpCopy) 4641 v.Type = x.Type 4642 v.AddArg(x) 4643 return true 4644 } 4645 // match: (And16 x (Const16 [-1])) 4646 // cond: 4647 // result: x 4648 for { 4649 _ = v.Args[1] 4650 x := v.Args[0] 4651 v_1 := v.Args[1] 4652 if v_1.Op != OpConst16 { 4653 break 4654 } 4655 if v_1.AuxInt != -1 { 4656 break 4657 } 4658 v.reset(OpCopy) 4659 v.Type = x.Type 4660 v.AddArg(x) 4661 return true 4662 } 4663 // match: (And16 (Const16 [0]) _) 4664 // cond: 4665 // result: (Const16 [0]) 4666 for { 4667 _ = v.Args[1] 4668 v_0 := v.Args[0] 4669 if v_0.Op != OpConst16 { 4670 break 4671 } 4672 if v_0.AuxInt != 0 { 4673 break 4674 } 4675 v.reset(OpConst16) 4676 v.AuxInt = 0 4677 return true 4678 } 4679 return false 4680 } 4681 func rewriteValuegeneric_OpAnd16_10(v *Value) bool { 4682 b := v.Block 4683 _ = b 4684 // match: (And16 _ (Const16 [0])) 4685 // cond: 4686 // result: (Const16 [0]) 4687 for { 4688 _ = v.Args[1] 4689 v_1 := v.Args[1] 4690 if v_1.Op != OpConst16 { 4691 break 4692 } 4693 if v_1.AuxInt != 0 { 4694 break 4695 } 4696 v.reset(OpConst16) 4697 v.AuxInt = 0 4698 return true 4699 } 4700 // match: (And16 x (And16 x y)) 4701 // cond: 4702 // result: (And16 x y) 4703 for { 4704 _ = v.Args[1] 4705 x := v.Args[0] 4706 v_1 := v.Args[1] 4707 if v_1.Op != OpAnd16 { 4708 break 4709 } 4710 _ = v_1.Args[1] 4711 if x != v_1.Args[0] { 4712 break 4713 } 4714 y := v_1.Args[1] 4715 v.reset(OpAnd16) 4716 v.AddArg(x) 4717 v.AddArg(y) 4718 return true 4719 } 4720 // match: (And16 x (And16 y x)) 4721 // cond: 4722 // result: (And16 x y) 4723 for { 4724 _ = v.Args[1] 4725 x := v.Args[0] 4726 v_1 := v.Args[1] 4727 if v_1.Op != OpAnd16 { 4728 break 4729 } 4730 _ = v_1.Args[1] 4731 y := v_1.Args[0] 4732 if x != v_1.Args[1] { 4733 break 4734 } 4735 v.reset(OpAnd16) 4736 v.AddArg(x) 4737 v.AddArg(y) 4738 return true 4739 } 4740 // match: (And16 (And16 x y) x) 4741 // cond: 4742 // result: (And16 x y) 4743 for { 4744 _ = v.Args[1] 4745 v_0 := v.Args[0] 4746 if v_0.Op != OpAnd16 { 4747 break 4748 } 4749 _ = v_0.Args[1] 4750 x := v_0.Args[0] 4751 y := v_0.Args[1] 4752 if x != v.Args[1] { 4753 break 4754 } 4755 v.reset(OpAnd16) 4756 v.AddArg(x) 4757 v.AddArg(y) 4758 return true 4759 } 4760 // match: (And16 (And16 y x) x) 4761 // cond: 4762 // result: (And16 x y) 4763 for { 4764 _ = v.Args[1] 4765 v_0 := v.Args[0] 4766 if v_0.Op != OpAnd16 { 4767 break 4768 } 4769 _ = v_0.Args[1] 4770 y := v_0.Args[0] 4771 x := v_0.Args[1] 4772 if x != v.Args[1] { 4773 break 4774 } 4775 v.reset(OpAnd16) 4776 v.AddArg(x) 4777 v.AddArg(y) 4778 return true 4779 } 4780 // match: (And16 (And16 i:(Const16 <t>) z) x) 4781 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 4782 // result: (And16 i (And16 <t> z x)) 4783 for { 4784 _ = v.Args[1] 4785 v_0 := v.Args[0] 4786 if v_0.Op != OpAnd16 { 4787 break 4788 } 4789 _ = v_0.Args[1] 4790 i := v_0.Args[0] 4791 if i.Op != OpConst16 { 4792 break 4793 } 4794 t := i.Type 4795 z := v_0.Args[1] 4796 x := v.Args[1] 4797 if !(z.Op != OpConst16 && x.Op != OpConst16) { 4798 break 4799 } 4800 v.reset(OpAnd16) 4801 v.AddArg(i) 4802 v0 := b.NewValue0(v.Pos, OpAnd16, t) 4803 v0.AddArg(z) 4804 v0.AddArg(x) 4805 v.AddArg(v0) 4806 return true 4807 } 4808 // match: (And16 (And16 z i:(Const16 <t>)) x) 4809 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 4810 // result: (And16 i (And16 <t> z x)) 4811 for { 4812 _ = v.Args[1] 4813 v_0 := v.Args[0] 4814 if v_0.Op != OpAnd16 { 4815 break 4816 } 4817 _ = v_0.Args[1] 4818 z := v_0.Args[0] 4819 i := v_0.Args[1] 4820 if i.Op != OpConst16 { 4821 break 4822 } 4823 t := i.Type 4824 x := v.Args[1] 4825 if !(z.Op != OpConst16 && x.Op != OpConst16) { 4826 break 4827 } 4828 v.reset(OpAnd16) 4829 v.AddArg(i) 4830 v0 := b.NewValue0(v.Pos, OpAnd16, t) 4831 v0.AddArg(z) 4832 v0.AddArg(x) 4833 v.AddArg(v0) 4834 return true 4835 } 4836 // match: (And16 x (And16 i:(Const16 <t>) z)) 4837 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 4838 // result: (And16 i (And16 <t> z x)) 4839 for { 4840 _ = v.Args[1] 4841 x := v.Args[0] 4842 v_1 := v.Args[1] 4843 if v_1.Op != OpAnd16 { 4844 break 4845 } 4846 _ = v_1.Args[1] 4847 i := v_1.Args[0] 4848 if i.Op != OpConst16 { 4849 break 4850 } 4851 t := i.Type 4852 z := v_1.Args[1] 4853 if !(z.Op != OpConst16 && x.Op != OpConst16) { 4854 break 4855 } 4856 v.reset(OpAnd16) 4857 v.AddArg(i) 4858 v0 := b.NewValue0(v.Pos, OpAnd16, t) 4859 v0.AddArg(z) 4860 v0.AddArg(x) 4861 v.AddArg(v0) 4862 return true 4863 } 4864 // match: (And16 x (And16 z i:(Const16 <t>))) 4865 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 4866 // result: (And16 i (And16 <t> z x)) 4867 for { 4868 _ = v.Args[1] 4869 x := v.Args[0] 4870 v_1 := v.Args[1] 4871 if v_1.Op != OpAnd16 { 4872 break 4873 } 4874 _ = v_1.Args[1] 4875 z := v_1.Args[0] 4876 i := v_1.Args[1] 4877 if i.Op != OpConst16 { 4878 break 4879 } 4880 t := i.Type 4881 if !(z.Op != OpConst16 && x.Op != OpConst16) { 4882 break 4883 } 4884 v.reset(OpAnd16) 4885 v.AddArg(i) 4886 v0 := b.NewValue0(v.Pos, OpAnd16, t) 4887 v0.AddArg(z) 4888 v0.AddArg(x) 4889 v.AddArg(v0) 4890 return true 4891 } 4892 // match: (And16 (Const16 <t> [c]) (And16 (Const16 <t> [d]) x)) 4893 // cond: 4894 // result: (And16 (Const16 <t> [int64(int16(c&d))]) x) 4895 for { 4896 _ = v.Args[1] 4897 v_0 := v.Args[0] 4898 if v_0.Op != OpConst16 { 4899 break 4900 } 4901 t := v_0.Type 4902 c := v_0.AuxInt 4903 v_1 := v.Args[1] 4904 if v_1.Op != OpAnd16 { 4905 break 4906 } 4907 _ = v_1.Args[1] 4908 v_1_0 := v_1.Args[0] 4909 if v_1_0.Op != OpConst16 { 4910 break 4911 } 4912 if v_1_0.Type != t { 4913 break 4914 } 4915 d := v_1_0.AuxInt 4916 x := v_1.Args[1] 4917 v.reset(OpAnd16) 4918 v0 := b.NewValue0(v.Pos, OpConst16, t) 4919 v0.AuxInt = int64(int16(c & d)) 4920 v.AddArg(v0) 4921 v.AddArg(x) 4922 return true 4923 } 4924 return false 4925 } 4926 func rewriteValuegeneric_OpAnd16_20(v *Value) bool { 4927 b := v.Block 4928 _ = b 4929 // match: (And16 (Const16 <t> [c]) (And16 x (Const16 <t> [d]))) 4930 // cond: 4931 // result: (And16 (Const16 <t> [int64(int16(c&d))]) x) 4932 for { 4933 _ = v.Args[1] 4934 v_0 := v.Args[0] 4935 if v_0.Op != OpConst16 { 4936 break 4937 } 4938 t := v_0.Type 4939 c := v_0.AuxInt 4940 v_1 := v.Args[1] 4941 if v_1.Op != OpAnd16 { 4942 break 4943 } 4944 _ = v_1.Args[1] 4945 x := v_1.Args[0] 4946 v_1_1 := v_1.Args[1] 4947 if v_1_1.Op != OpConst16 { 4948 break 4949 } 4950 if v_1_1.Type != t { 4951 break 4952 } 4953 d := v_1_1.AuxInt 4954 v.reset(OpAnd16) 4955 v0 := b.NewValue0(v.Pos, OpConst16, t) 4956 v0.AuxInt = int64(int16(c & d)) 4957 v.AddArg(v0) 4958 v.AddArg(x) 4959 return true 4960 } 4961 // match: (And16 (And16 (Const16 <t> [d]) x) (Const16 <t> [c])) 4962 // cond: 4963 // result: (And16 (Const16 <t> [int64(int16(c&d))]) x) 4964 for { 4965 _ = v.Args[1] 4966 v_0 := v.Args[0] 4967 if v_0.Op != OpAnd16 { 4968 break 4969 } 4970 _ = v_0.Args[1] 4971 v_0_0 := v_0.Args[0] 4972 if v_0_0.Op != OpConst16 { 4973 break 4974 } 4975 t := v_0_0.Type 4976 d := v_0_0.AuxInt 4977 x := v_0.Args[1] 4978 v_1 := v.Args[1] 4979 if v_1.Op != OpConst16 { 4980 break 4981 } 4982 if v_1.Type != t { 4983 break 4984 } 4985 c := v_1.AuxInt 4986 v.reset(OpAnd16) 4987 v0 := b.NewValue0(v.Pos, OpConst16, t) 4988 v0.AuxInt = int64(int16(c & d)) 4989 v.AddArg(v0) 4990 v.AddArg(x) 4991 return true 4992 } 4993 // match: (And16 (And16 x (Const16 <t> [d])) (Const16 <t> [c])) 4994 // cond: 4995 // result: (And16 (Const16 <t> [int64(int16(c&d))]) x) 4996 for { 4997 _ = v.Args[1] 4998 v_0 := v.Args[0] 4999 if v_0.Op != OpAnd16 { 5000 break 5001 } 5002 _ = v_0.Args[1] 5003 x := v_0.Args[0] 5004 v_0_1 := v_0.Args[1] 5005 if v_0_1.Op != OpConst16 { 5006 break 5007 } 5008 t := v_0_1.Type 5009 d := v_0_1.AuxInt 5010 v_1 := v.Args[1] 5011 if v_1.Op != OpConst16 { 5012 break 5013 } 5014 if v_1.Type != t { 5015 break 5016 } 5017 c := v_1.AuxInt 5018 v.reset(OpAnd16) 5019 v0 := b.NewValue0(v.Pos, OpConst16, t) 5020 v0.AuxInt = int64(int16(c & d)) 5021 v.AddArg(v0) 5022 v.AddArg(x) 5023 return true 5024 } 5025 return false 5026 } 5027 func rewriteValuegeneric_OpAnd32_0(v *Value) bool { 5028 // match: (And32 (Const32 [c]) (Const32 [d])) 5029 // cond: 5030 // result: (Const32 [int64(int32(c&d))]) 5031 for { 5032 _ = v.Args[1] 5033 v_0 := v.Args[0] 5034 if v_0.Op != OpConst32 { 5035 break 5036 } 5037 c := v_0.AuxInt 5038 v_1 := v.Args[1] 5039 if v_1.Op != OpConst32 { 5040 break 5041 } 5042 d := v_1.AuxInt 5043 v.reset(OpConst32) 5044 v.AuxInt = int64(int32(c & d)) 5045 return true 5046 } 5047 // match: (And32 (Const32 [d]) (Const32 [c])) 5048 // cond: 5049 // result: (Const32 [int64(int32(c&d))]) 5050 for { 5051 _ = v.Args[1] 5052 v_0 := v.Args[0] 5053 if v_0.Op != OpConst32 { 5054 break 5055 } 5056 d := v_0.AuxInt 5057 v_1 := v.Args[1] 5058 if v_1.Op != OpConst32 { 5059 break 5060 } 5061 c := v_1.AuxInt 5062 v.reset(OpConst32) 5063 v.AuxInt = int64(int32(c & d)) 5064 return true 5065 } 5066 // match: (And32 (Const32 [m]) (Rsh32Ux64 _ (Const64 [c]))) 5067 // cond: c >= 64-ntz(m) 5068 // result: (Const32 [0]) 5069 for { 5070 _ = v.Args[1] 5071 v_0 := v.Args[0] 5072 if v_0.Op != OpConst32 { 5073 break 5074 } 5075 m := v_0.AuxInt 5076 v_1 := v.Args[1] 5077 if v_1.Op != OpRsh32Ux64 { 5078 break 5079 } 5080 _ = v_1.Args[1] 5081 v_1_1 := v_1.Args[1] 5082 if v_1_1.Op != OpConst64 { 5083 break 5084 } 5085 c := v_1_1.AuxInt 5086 if !(c >= 64-ntz(m)) { 5087 break 5088 } 5089 v.reset(OpConst32) 5090 v.AuxInt = 0 5091 return true 5092 } 5093 // match: (And32 (Rsh32Ux64 _ (Const64 [c])) (Const32 [m])) 5094 // cond: c >= 64-ntz(m) 5095 // result: (Const32 [0]) 5096 for { 5097 _ = v.Args[1] 5098 v_0 := v.Args[0] 5099 if v_0.Op != OpRsh32Ux64 { 5100 break 5101 } 5102 _ = v_0.Args[1] 5103 v_0_1 := v_0.Args[1] 5104 if v_0_1.Op != OpConst64 { 5105 break 5106 } 5107 c := v_0_1.AuxInt 5108 v_1 := v.Args[1] 5109 if v_1.Op != OpConst32 { 5110 break 5111 } 5112 m := v_1.AuxInt 5113 if !(c >= 64-ntz(m)) { 5114 break 5115 } 5116 v.reset(OpConst32) 5117 v.AuxInt = 0 5118 return true 5119 } 5120 // match: (And32 (Const32 [m]) (Lsh32x64 _ (Const64 [c]))) 5121 // cond: c >= 64-nlz(m) 5122 // result: (Const32 [0]) 5123 for { 5124 _ = v.Args[1] 5125 v_0 := v.Args[0] 5126 if v_0.Op != OpConst32 { 5127 break 5128 } 5129 m := v_0.AuxInt 5130 v_1 := v.Args[1] 5131 if v_1.Op != OpLsh32x64 { 5132 break 5133 } 5134 _ = v_1.Args[1] 5135 v_1_1 := v_1.Args[1] 5136 if v_1_1.Op != OpConst64 { 5137 break 5138 } 5139 c := v_1_1.AuxInt 5140 if !(c >= 64-nlz(m)) { 5141 break 5142 } 5143 v.reset(OpConst32) 5144 v.AuxInt = 0 5145 return true 5146 } 5147 // match: (And32 (Lsh32x64 _ (Const64 [c])) (Const32 [m])) 5148 // cond: c >= 64-nlz(m) 5149 // result: (Const32 [0]) 5150 for { 5151 _ = v.Args[1] 5152 v_0 := v.Args[0] 5153 if v_0.Op != OpLsh32x64 { 5154 break 5155 } 5156 _ = v_0.Args[1] 5157 v_0_1 := v_0.Args[1] 5158 if v_0_1.Op != OpConst64 { 5159 break 5160 } 5161 c := v_0_1.AuxInt 5162 v_1 := v.Args[1] 5163 if v_1.Op != OpConst32 { 5164 break 5165 } 5166 m := v_1.AuxInt 5167 if !(c >= 64-nlz(m)) { 5168 break 5169 } 5170 v.reset(OpConst32) 5171 v.AuxInt = 0 5172 return true 5173 } 5174 // match: (And32 x x) 5175 // cond: 5176 // result: x 5177 for { 5178 _ = v.Args[1] 5179 x := v.Args[0] 5180 if x != v.Args[1] { 5181 break 5182 } 5183 v.reset(OpCopy) 5184 v.Type = x.Type 5185 v.AddArg(x) 5186 return true 5187 } 5188 // match: (And32 (Const32 [-1]) x) 5189 // cond: 5190 // result: x 5191 for { 5192 _ = v.Args[1] 5193 v_0 := v.Args[0] 5194 if v_0.Op != OpConst32 { 5195 break 5196 } 5197 if v_0.AuxInt != -1 { 5198 break 5199 } 5200 x := v.Args[1] 5201 v.reset(OpCopy) 5202 v.Type = x.Type 5203 v.AddArg(x) 5204 return true 5205 } 5206 // match: (And32 x (Const32 [-1])) 5207 // cond: 5208 // result: x 5209 for { 5210 _ = v.Args[1] 5211 x := v.Args[0] 5212 v_1 := v.Args[1] 5213 if v_1.Op != OpConst32 { 5214 break 5215 } 5216 if v_1.AuxInt != -1 { 5217 break 5218 } 5219 v.reset(OpCopy) 5220 v.Type = x.Type 5221 v.AddArg(x) 5222 return true 5223 } 5224 // match: (And32 (Const32 [0]) _) 5225 // cond: 5226 // result: (Const32 [0]) 5227 for { 5228 _ = v.Args[1] 5229 v_0 := v.Args[0] 5230 if v_0.Op != OpConst32 { 5231 break 5232 } 5233 if v_0.AuxInt != 0 { 5234 break 5235 } 5236 v.reset(OpConst32) 5237 v.AuxInt = 0 5238 return true 5239 } 5240 return false 5241 } 5242 func rewriteValuegeneric_OpAnd32_10(v *Value) bool { 5243 b := v.Block 5244 _ = b 5245 // match: (And32 _ (Const32 [0])) 5246 // cond: 5247 // result: (Const32 [0]) 5248 for { 5249 _ = v.Args[1] 5250 v_1 := v.Args[1] 5251 if v_1.Op != OpConst32 { 5252 break 5253 } 5254 if v_1.AuxInt != 0 { 5255 break 5256 } 5257 v.reset(OpConst32) 5258 v.AuxInt = 0 5259 return true 5260 } 5261 // match: (And32 x (And32 x y)) 5262 // cond: 5263 // result: (And32 x y) 5264 for { 5265 _ = v.Args[1] 5266 x := v.Args[0] 5267 v_1 := v.Args[1] 5268 if v_1.Op != OpAnd32 { 5269 break 5270 } 5271 _ = v_1.Args[1] 5272 if x != v_1.Args[0] { 5273 break 5274 } 5275 y := v_1.Args[1] 5276 v.reset(OpAnd32) 5277 v.AddArg(x) 5278 v.AddArg(y) 5279 return true 5280 } 5281 // match: (And32 x (And32 y x)) 5282 // cond: 5283 // result: (And32 x y) 5284 for { 5285 _ = v.Args[1] 5286 x := v.Args[0] 5287 v_1 := v.Args[1] 5288 if v_1.Op != OpAnd32 { 5289 break 5290 } 5291 _ = v_1.Args[1] 5292 y := v_1.Args[0] 5293 if x != v_1.Args[1] { 5294 break 5295 } 5296 v.reset(OpAnd32) 5297 v.AddArg(x) 5298 v.AddArg(y) 5299 return true 5300 } 5301 // match: (And32 (And32 x y) x) 5302 // cond: 5303 // result: (And32 x y) 5304 for { 5305 _ = v.Args[1] 5306 v_0 := v.Args[0] 5307 if v_0.Op != OpAnd32 { 5308 break 5309 } 5310 _ = v_0.Args[1] 5311 x := v_0.Args[0] 5312 y := v_0.Args[1] 5313 if x != v.Args[1] { 5314 break 5315 } 5316 v.reset(OpAnd32) 5317 v.AddArg(x) 5318 v.AddArg(y) 5319 return true 5320 } 5321 // match: (And32 (And32 y x) x) 5322 // cond: 5323 // result: (And32 x y) 5324 for { 5325 _ = v.Args[1] 5326 v_0 := v.Args[0] 5327 if v_0.Op != OpAnd32 { 5328 break 5329 } 5330 _ = v_0.Args[1] 5331 y := v_0.Args[0] 5332 x := v_0.Args[1] 5333 if x != v.Args[1] { 5334 break 5335 } 5336 v.reset(OpAnd32) 5337 v.AddArg(x) 5338 v.AddArg(y) 5339 return true 5340 } 5341 // match: (And32 (And32 i:(Const32 <t>) z) x) 5342 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 5343 // result: (And32 i (And32 <t> z x)) 5344 for { 5345 _ = v.Args[1] 5346 v_0 := v.Args[0] 5347 if v_0.Op != OpAnd32 { 5348 break 5349 } 5350 _ = v_0.Args[1] 5351 i := v_0.Args[0] 5352 if i.Op != OpConst32 { 5353 break 5354 } 5355 t := i.Type 5356 z := v_0.Args[1] 5357 x := v.Args[1] 5358 if !(z.Op != OpConst32 && x.Op != OpConst32) { 5359 break 5360 } 5361 v.reset(OpAnd32) 5362 v.AddArg(i) 5363 v0 := b.NewValue0(v.Pos, OpAnd32, t) 5364 v0.AddArg(z) 5365 v0.AddArg(x) 5366 v.AddArg(v0) 5367 return true 5368 } 5369 // match: (And32 (And32 z i:(Const32 <t>)) x) 5370 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 5371 // result: (And32 i (And32 <t> z x)) 5372 for { 5373 _ = v.Args[1] 5374 v_0 := v.Args[0] 5375 if v_0.Op != OpAnd32 { 5376 break 5377 } 5378 _ = v_0.Args[1] 5379 z := v_0.Args[0] 5380 i := v_0.Args[1] 5381 if i.Op != OpConst32 { 5382 break 5383 } 5384 t := i.Type 5385 x := v.Args[1] 5386 if !(z.Op != OpConst32 && x.Op != OpConst32) { 5387 break 5388 } 5389 v.reset(OpAnd32) 5390 v.AddArg(i) 5391 v0 := b.NewValue0(v.Pos, OpAnd32, t) 5392 v0.AddArg(z) 5393 v0.AddArg(x) 5394 v.AddArg(v0) 5395 return true 5396 } 5397 // match: (And32 x (And32 i:(Const32 <t>) z)) 5398 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 5399 // result: (And32 i (And32 <t> z x)) 5400 for { 5401 _ = v.Args[1] 5402 x := v.Args[0] 5403 v_1 := v.Args[1] 5404 if v_1.Op != OpAnd32 { 5405 break 5406 } 5407 _ = v_1.Args[1] 5408 i := v_1.Args[0] 5409 if i.Op != OpConst32 { 5410 break 5411 } 5412 t := i.Type 5413 z := v_1.Args[1] 5414 if !(z.Op != OpConst32 && x.Op != OpConst32) { 5415 break 5416 } 5417 v.reset(OpAnd32) 5418 v.AddArg(i) 5419 v0 := b.NewValue0(v.Pos, OpAnd32, t) 5420 v0.AddArg(z) 5421 v0.AddArg(x) 5422 v.AddArg(v0) 5423 return true 5424 } 5425 // match: (And32 x (And32 z i:(Const32 <t>))) 5426 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 5427 // result: (And32 i (And32 <t> z x)) 5428 for { 5429 _ = v.Args[1] 5430 x := v.Args[0] 5431 v_1 := v.Args[1] 5432 if v_1.Op != OpAnd32 { 5433 break 5434 } 5435 _ = v_1.Args[1] 5436 z := v_1.Args[0] 5437 i := v_1.Args[1] 5438 if i.Op != OpConst32 { 5439 break 5440 } 5441 t := i.Type 5442 if !(z.Op != OpConst32 && x.Op != OpConst32) { 5443 break 5444 } 5445 v.reset(OpAnd32) 5446 v.AddArg(i) 5447 v0 := b.NewValue0(v.Pos, OpAnd32, t) 5448 v0.AddArg(z) 5449 v0.AddArg(x) 5450 v.AddArg(v0) 5451 return true 5452 } 5453 // match: (And32 (Const32 <t> [c]) (And32 (Const32 <t> [d]) x)) 5454 // cond: 5455 // result: (And32 (Const32 <t> [int64(int32(c&d))]) x) 5456 for { 5457 _ = v.Args[1] 5458 v_0 := v.Args[0] 5459 if v_0.Op != OpConst32 { 5460 break 5461 } 5462 t := v_0.Type 5463 c := v_0.AuxInt 5464 v_1 := v.Args[1] 5465 if v_1.Op != OpAnd32 { 5466 break 5467 } 5468 _ = v_1.Args[1] 5469 v_1_0 := v_1.Args[0] 5470 if v_1_0.Op != OpConst32 { 5471 break 5472 } 5473 if v_1_0.Type != t { 5474 break 5475 } 5476 d := v_1_0.AuxInt 5477 x := v_1.Args[1] 5478 v.reset(OpAnd32) 5479 v0 := b.NewValue0(v.Pos, OpConst32, t) 5480 v0.AuxInt = int64(int32(c & d)) 5481 v.AddArg(v0) 5482 v.AddArg(x) 5483 return true 5484 } 5485 return false 5486 } 5487 func rewriteValuegeneric_OpAnd32_20(v *Value) bool { 5488 b := v.Block 5489 _ = b 5490 // match: (And32 (Const32 <t> [c]) (And32 x (Const32 <t> [d]))) 5491 // cond: 5492 // result: (And32 (Const32 <t> [int64(int32(c&d))]) x) 5493 for { 5494 _ = v.Args[1] 5495 v_0 := v.Args[0] 5496 if v_0.Op != OpConst32 { 5497 break 5498 } 5499 t := v_0.Type 5500 c := v_0.AuxInt 5501 v_1 := v.Args[1] 5502 if v_1.Op != OpAnd32 { 5503 break 5504 } 5505 _ = v_1.Args[1] 5506 x := v_1.Args[0] 5507 v_1_1 := v_1.Args[1] 5508 if v_1_1.Op != OpConst32 { 5509 break 5510 } 5511 if v_1_1.Type != t { 5512 break 5513 } 5514 d := v_1_1.AuxInt 5515 v.reset(OpAnd32) 5516 v0 := b.NewValue0(v.Pos, OpConst32, t) 5517 v0.AuxInt = int64(int32(c & d)) 5518 v.AddArg(v0) 5519 v.AddArg(x) 5520 return true 5521 } 5522 // match: (And32 (And32 (Const32 <t> [d]) x) (Const32 <t> [c])) 5523 // cond: 5524 // result: (And32 (Const32 <t> [int64(int32(c&d))]) x) 5525 for { 5526 _ = v.Args[1] 5527 v_0 := v.Args[0] 5528 if v_0.Op != OpAnd32 { 5529 break 5530 } 5531 _ = v_0.Args[1] 5532 v_0_0 := v_0.Args[0] 5533 if v_0_0.Op != OpConst32 { 5534 break 5535 } 5536 t := v_0_0.Type 5537 d := v_0_0.AuxInt 5538 x := v_0.Args[1] 5539 v_1 := v.Args[1] 5540 if v_1.Op != OpConst32 { 5541 break 5542 } 5543 if v_1.Type != t { 5544 break 5545 } 5546 c := v_1.AuxInt 5547 v.reset(OpAnd32) 5548 v0 := b.NewValue0(v.Pos, OpConst32, t) 5549 v0.AuxInt = int64(int32(c & d)) 5550 v.AddArg(v0) 5551 v.AddArg(x) 5552 return true 5553 } 5554 // match: (And32 (And32 x (Const32 <t> [d])) (Const32 <t> [c])) 5555 // cond: 5556 // result: (And32 (Const32 <t> [int64(int32(c&d))]) x) 5557 for { 5558 _ = v.Args[1] 5559 v_0 := v.Args[0] 5560 if v_0.Op != OpAnd32 { 5561 break 5562 } 5563 _ = v_0.Args[1] 5564 x := v_0.Args[0] 5565 v_0_1 := v_0.Args[1] 5566 if v_0_1.Op != OpConst32 { 5567 break 5568 } 5569 t := v_0_1.Type 5570 d := v_0_1.AuxInt 5571 v_1 := v.Args[1] 5572 if v_1.Op != OpConst32 { 5573 break 5574 } 5575 if v_1.Type != t { 5576 break 5577 } 5578 c := v_1.AuxInt 5579 v.reset(OpAnd32) 5580 v0 := b.NewValue0(v.Pos, OpConst32, t) 5581 v0.AuxInt = int64(int32(c & d)) 5582 v.AddArg(v0) 5583 v.AddArg(x) 5584 return true 5585 } 5586 return false 5587 } 5588 func rewriteValuegeneric_OpAnd64_0(v *Value) bool { 5589 // match: (And64 (Const64 [c]) (Const64 [d])) 5590 // cond: 5591 // result: (Const64 [c&d]) 5592 for { 5593 _ = v.Args[1] 5594 v_0 := v.Args[0] 5595 if v_0.Op != OpConst64 { 5596 break 5597 } 5598 c := v_0.AuxInt 5599 v_1 := v.Args[1] 5600 if v_1.Op != OpConst64 { 5601 break 5602 } 5603 d := v_1.AuxInt 5604 v.reset(OpConst64) 5605 v.AuxInt = c & d 5606 return true 5607 } 5608 // match: (And64 (Const64 [d]) (Const64 [c])) 5609 // cond: 5610 // result: (Const64 [c&d]) 5611 for { 5612 _ = v.Args[1] 5613 v_0 := v.Args[0] 5614 if v_0.Op != OpConst64 { 5615 break 5616 } 5617 d := v_0.AuxInt 5618 v_1 := v.Args[1] 5619 if v_1.Op != OpConst64 { 5620 break 5621 } 5622 c := v_1.AuxInt 5623 v.reset(OpConst64) 5624 v.AuxInt = c & d 5625 return true 5626 } 5627 // match: (And64 (Const64 [m]) (Rsh64Ux64 _ (Const64 [c]))) 5628 // cond: c >= 64-ntz(m) 5629 // result: (Const64 [0]) 5630 for { 5631 _ = v.Args[1] 5632 v_0 := v.Args[0] 5633 if v_0.Op != OpConst64 { 5634 break 5635 } 5636 m := v_0.AuxInt 5637 v_1 := v.Args[1] 5638 if v_1.Op != OpRsh64Ux64 { 5639 break 5640 } 5641 _ = v_1.Args[1] 5642 v_1_1 := v_1.Args[1] 5643 if v_1_1.Op != OpConst64 { 5644 break 5645 } 5646 c := v_1_1.AuxInt 5647 if !(c >= 64-ntz(m)) { 5648 break 5649 } 5650 v.reset(OpConst64) 5651 v.AuxInt = 0 5652 return true 5653 } 5654 // match: (And64 (Rsh64Ux64 _ (Const64 [c])) (Const64 [m])) 5655 // cond: c >= 64-ntz(m) 5656 // result: (Const64 [0]) 5657 for { 5658 _ = v.Args[1] 5659 v_0 := v.Args[0] 5660 if v_0.Op != OpRsh64Ux64 { 5661 break 5662 } 5663 _ = v_0.Args[1] 5664 v_0_1 := v_0.Args[1] 5665 if v_0_1.Op != OpConst64 { 5666 break 5667 } 5668 c := v_0_1.AuxInt 5669 v_1 := v.Args[1] 5670 if v_1.Op != OpConst64 { 5671 break 5672 } 5673 m := v_1.AuxInt 5674 if !(c >= 64-ntz(m)) { 5675 break 5676 } 5677 v.reset(OpConst64) 5678 v.AuxInt = 0 5679 return true 5680 } 5681 // match: (And64 (Const64 [m]) (Lsh64x64 _ (Const64 [c]))) 5682 // cond: c >= 64-nlz(m) 5683 // result: (Const64 [0]) 5684 for { 5685 _ = v.Args[1] 5686 v_0 := v.Args[0] 5687 if v_0.Op != OpConst64 { 5688 break 5689 } 5690 m := v_0.AuxInt 5691 v_1 := v.Args[1] 5692 if v_1.Op != OpLsh64x64 { 5693 break 5694 } 5695 _ = v_1.Args[1] 5696 v_1_1 := v_1.Args[1] 5697 if v_1_1.Op != OpConst64 { 5698 break 5699 } 5700 c := v_1_1.AuxInt 5701 if !(c >= 64-nlz(m)) { 5702 break 5703 } 5704 v.reset(OpConst64) 5705 v.AuxInt = 0 5706 return true 5707 } 5708 // match: (And64 (Lsh64x64 _ (Const64 [c])) (Const64 [m])) 5709 // cond: c >= 64-nlz(m) 5710 // result: (Const64 [0]) 5711 for { 5712 _ = v.Args[1] 5713 v_0 := v.Args[0] 5714 if v_0.Op != OpLsh64x64 { 5715 break 5716 } 5717 _ = v_0.Args[1] 5718 v_0_1 := v_0.Args[1] 5719 if v_0_1.Op != OpConst64 { 5720 break 5721 } 5722 c := v_0_1.AuxInt 5723 v_1 := v.Args[1] 5724 if v_1.Op != OpConst64 { 5725 break 5726 } 5727 m := v_1.AuxInt 5728 if !(c >= 64-nlz(m)) { 5729 break 5730 } 5731 v.reset(OpConst64) 5732 v.AuxInt = 0 5733 return true 5734 } 5735 // match: (And64 x x) 5736 // cond: 5737 // result: x 5738 for { 5739 _ = v.Args[1] 5740 x := v.Args[0] 5741 if x != v.Args[1] { 5742 break 5743 } 5744 v.reset(OpCopy) 5745 v.Type = x.Type 5746 v.AddArg(x) 5747 return true 5748 } 5749 // match: (And64 (Const64 [-1]) x) 5750 // cond: 5751 // result: x 5752 for { 5753 _ = v.Args[1] 5754 v_0 := v.Args[0] 5755 if v_0.Op != OpConst64 { 5756 break 5757 } 5758 if v_0.AuxInt != -1 { 5759 break 5760 } 5761 x := v.Args[1] 5762 v.reset(OpCopy) 5763 v.Type = x.Type 5764 v.AddArg(x) 5765 return true 5766 } 5767 // match: (And64 x (Const64 [-1])) 5768 // cond: 5769 // result: x 5770 for { 5771 _ = v.Args[1] 5772 x := v.Args[0] 5773 v_1 := v.Args[1] 5774 if v_1.Op != OpConst64 { 5775 break 5776 } 5777 if v_1.AuxInt != -1 { 5778 break 5779 } 5780 v.reset(OpCopy) 5781 v.Type = x.Type 5782 v.AddArg(x) 5783 return true 5784 } 5785 // match: (And64 (Const64 [0]) _) 5786 // cond: 5787 // result: (Const64 [0]) 5788 for { 5789 _ = v.Args[1] 5790 v_0 := v.Args[0] 5791 if v_0.Op != OpConst64 { 5792 break 5793 } 5794 if v_0.AuxInt != 0 { 5795 break 5796 } 5797 v.reset(OpConst64) 5798 v.AuxInt = 0 5799 return true 5800 } 5801 return false 5802 } 5803 func rewriteValuegeneric_OpAnd64_10(v *Value) bool { 5804 b := v.Block 5805 _ = b 5806 // match: (And64 _ (Const64 [0])) 5807 // cond: 5808 // result: (Const64 [0]) 5809 for { 5810 _ = v.Args[1] 5811 v_1 := v.Args[1] 5812 if v_1.Op != OpConst64 { 5813 break 5814 } 5815 if v_1.AuxInt != 0 { 5816 break 5817 } 5818 v.reset(OpConst64) 5819 v.AuxInt = 0 5820 return true 5821 } 5822 // match: (And64 x (And64 x y)) 5823 // cond: 5824 // result: (And64 x y) 5825 for { 5826 _ = v.Args[1] 5827 x := v.Args[0] 5828 v_1 := v.Args[1] 5829 if v_1.Op != OpAnd64 { 5830 break 5831 } 5832 _ = v_1.Args[1] 5833 if x != v_1.Args[0] { 5834 break 5835 } 5836 y := v_1.Args[1] 5837 v.reset(OpAnd64) 5838 v.AddArg(x) 5839 v.AddArg(y) 5840 return true 5841 } 5842 // match: (And64 x (And64 y x)) 5843 // cond: 5844 // result: (And64 x y) 5845 for { 5846 _ = v.Args[1] 5847 x := v.Args[0] 5848 v_1 := v.Args[1] 5849 if v_1.Op != OpAnd64 { 5850 break 5851 } 5852 _ = v_1.Args[1] 5853 y := v_1.Args[0] 5854 if x != v_1.Args[1] { 5855 break 5856 } 5857 v.reset(OpAnd64) 5858 v.AddArg(x) 5859 v.AddArg(y) 5860 return true 5861 } 5862 // match: (And64 (And64 x y) x) 5863 // cond: 5864 // result: (And64 x y) 5865 for { 5866 _ = v.Args[1] 5867 v_0 := v.Args[0] 5868 if v_0.Op != OpAnd64 { 5869 break 5870 } 5871 _ = v_0.Args[1] 5872 x := v_0.Args[0] 5873 y := v_0.Args[1] 5874 if x != v.Args[1] { 5875 break 5876 } 5877 v.reset(OpAnd64) 5878 v.AddArg(x) 5879 v.AddArg(y) 5880 return true 5881 } 5882 // match: (And64 (And64 y x) x) 5883 // cond: 5884 // result: (And64 x y) 5885 for { 5886 _ = v.Args[1] 5887 v_0 := v.Args[0] 5888 if v_0.Op != OpAnd64 { 5889 break 5890 } 5891 _ = v_0.Args[1] 5892 y := v_0.Args[0] 5893 x := v_0.Args[1] 5894 if x != v.Args[1] { 5895 break 5896 } 5897 v.reset(OpAnd64) 5898 v.AddArg(x) 5899 v.AddArg(y) 5900 return true 5901 } 5902 // match: (And64 <t> (Const64 [y]) x) 5903 // cond: nlz(y) + nto(y) == 64 && nto(y) >= 32 5904 // result: (Rsh64Ux64 (Lsh64x64 <t> x (Const64 <t> [nlz(y)])) (Const64 <t> [nlz(y)])) 5905 for { 5906 t := v.Type 5907 _ = v.Args[1] 5908 v_0 := v.Args[0] 5909 if v_0.Op != OpConst64 { 5910 break 5911 } 5912 y := v_0.AuxInt 5913 x := v.Args[1] 5914 if !(nlz(y)+nto(y) == 64 && nto(y) >= 32) { 5915 break 5916 } 5917 v.reset(OpRsh64Ux64) 5918 v0 := b.NewValue0(v.Pos, OpLsh64x64, t) 5919 v0.AddArg(x) 5920 v1 := b.NewValue0(v.Pos, OpConst64, t) 5921 v1.AuxInt = nlz(y) 5922 v0.AddArg(v1) 5923 v.AddArg(v0) 5924 v2 := b.NewValue0(v.Pos, OpConst64, t) 5925 v2.AuxInt = nlz(y) 5926 v.AddArg(v2) 5927 return true 5928 } 5929 // match: (And64 <t> x (Const64 [y])) 5930 // cond: nlz(y) + nto(y) == 64 && nto(y) >= 32 5931 // result: (Rsh64Ux64 (Lsh64x64 <t> x (Const64 <t> [nlz(y)])) (Const64 <t> [nlz(y)])) 5932 for { 5933 t := v.Type 5934 _ = v.Args[1] 5935 x := v.Args[0] 5936 v_1 := v.Args[1] 5937 if v_1.Op != OpConst64 { 5938 break 5939 } 5940 y := v_1.AuxInt 5941 if !(nlz(y)+nto(y) == 64 && nto(y) >= 32) { 5942 break 5943 } 5944 v.reset(OpRsh64Ux64) 5945 v0 := b.NewValue0(v.Pos, OpLsh64x64, t) 5946 v0.AddArg(x) 5947 v1 := b.NewValue0(v.Pos, OpConst64, t) 5948 v1.AuxInt = nlz(y) 5949 v0.AddArg(v1) 5950 v.AddArg(v0) 5951 v2 := b.NewValue0(v.Pos, OpConst64, t) 5952 v2.AuxInt = nlz(y) 5953 v.AddArg(v2) 5954 return true 5955 } 5956 // match: (And64 <t> (Const64 [y]) x) 5957 // cond: nlo(y) + ntz(y) == 64 && ntz(y) >= 32 5958 // result: (Lsh64x64 (Rsh64Ux64 <t> x (Const64 <t> [ntz(y)])) (Const64 <t> [ntz(y)])) 5959 for { 5960 t := v.Type 5961 _ = v.Args[1] 5962 v_0 := v.Args[0] 5963 if v_0.Op != OpConst64 { 5964 break 5965 } 5966 y := v_0.AuxInt 5967 x := v.Args[1] 5968 if !(nlo(y)+ntz(y) == 64 && ntz(y) >= 32) { 5969 break 5970 } 5971 v.reset(OpLsh64x64) 5972 v0 := b.NewValue0(v.Pos, OpRsh64Ux64, t) 5973 v0.AddArg(x) 5974 v1 := b.NewValue0(v.Pos, OpConst64, t) 5975 v1.AuxInt = ntz(y) 5976 v0.AddArg(v1) 5977 v.AddArg(v0) 5978 v2 := b.NewValue0(v.Pos, OpConst64, t) 5979 v2.AuxInt = ntz(y) 5980 v.AddArg(v2) 5981 return true 5982 } 5983 // match: (And64 <t> x (Const64 [y])) 5984 // cond: nlo(y) + ntz(y) == 64 && ntz(y) >= 32 5985 // result: (Lsh64x64 (Rsh64Ux64 <t> x (Const64 <t> [ntz(y)])) (Const64 <t> [ntz(y)])) 5986 for { 5987 t := v.Type 5988 _ = v.Args[1] 5989 x := v.Args[0] 5990 v_1 := v.Args[1] 5991 if v_1.Op != OpConst64 { 5992 break 5993 } 5994 y := v_1.AuxInt 5995 if !(nlo(y)+ntz(y) == 64 && ntz(y) >= 32) { 5996 break 5997 } 5998 v.reset(OpLsh64x64) 5999 v0 := b.NewValue0(v.Pos, OpRsh64Ux64, t) 6000 v0.AddArg(x) 6001 v1 := b.NewValue0(v.Pos, OpConst64, t) 6002 v1.AuxInt = ntz(y) 6003 v0.AddArg(v1) 6004 v.AddArg(v0) 6005 v2 := b.NewValue0(v.Pos, OpConst64, t) 6006 v2.AuxInt = ntz(y) 6007 v.AddArg(v2) 6008 return true 6009 } 6010 // match: (And64 (And64 i:(Const64 <t>) z) x) 6011 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 6012 // result: (And64 i (And64 <t> z x)) 6013 for { 6014 _ = v.Args[1] 6015 v_0 := v.Args[0] 6016 if v_0.Op != OpAnd64 { 6017 break 6018 } 6019 _ = v_0.Args[1] 6020 i := v_0.Args[0] 6021 if i.Op != OpConst64 { 6022 break 6023 } 6024 t := i.Type 6025 z := v_0.Args[1] 6026 x := v.Args[1] 6027 if !(z.Op != OpConst64 && x.Op != OpConst64) { 6028 break 6029 } 6030 v.reset(OpAnd64) 6031 v.AddArg(i) 6032 v0 := b.NewValue0(v.Pos, OpAnd64, t) 6033 v0.AddArg(z) 6034 v0.AddArg(x) 6035 v.AddArg(v0) 6036 return true 6037 } 6038 return false 6039 } 6040 func rewriteValuegeneric_OpAnd64_20(v *Value) bool { 6041 b := v.Block 6042 _ = b 6043 // match: (And64 (And64 z i:(Const64 <t>)) x) 6044 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 6045 // result: (And64 i (And64 <t> z x)) 6046 for { 6047 _ = v.Args[1] 6048 v_0 := v.Args[0] 6049 if v_0.Op != OpAnd64 { 6050 break 6051 } 6052 _ = v_0.Args[1] 6053 z := v_0.Args[0] 6054 i := v_0.Args[1] 6055 if i.Op != OpConst64 { 6056 break 6057 } 6058 t := i.Type 6059 x := v.Args[1] 6060 if !(z.Op != OpConst64 && x.Op != OpConst64) { 6061 break 6062 } 6063 v.reset(OpAnd64) 6064 v.AddArg(i) 6065 v0 := b.NewValue0(v.Pos, OpAnd64, t) 6066 v0.AddArg(z) 6067 v0.AddArg(x) 6068 v.AddArg(v0) 6069 return true 6070 } 6071 // match: (And64 x (And64 i:(Const64 <t>) z)) 6072 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 6073 // result: (And64 i (And64 <t> z x)) 6074 for { 6075 _ = v.Args[1] 6076 x := v.Args[0] 6077 v_1 := v.Args[1] 6078 if v_1.Op != OpAnd64 { 6079 break 6080 } 6081 _ = v_1.Args[1] 6082 i := v_1.Args[0] 6083 if i.Op != OpConst64 { 6084 break 6085 } 6086 t := i.Type 6087 z := v_1.Args[1] 6088 if !(z.Op != OpConst64 && x.Op != OpConst64) { 6089 break 6090 } 6091 v.reset(OpAnd64) 6092 v.AddArg(i) 6093 v0 := b.NewValue0(v.Pos, OpAnd64, t) 6094 v0.AddArg(z) 6095 v0.AddArg(x) 6096 v.AddArg(v0) 6097 return true 6098 } 6099 // match: (And64 x (And64 z i:(Const64 <t>))) 6100 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 6101 // result: (And64 i (And64 <t> z x)) 6102 for { 6103 _ = v.Args[1] 6104 x := v.Args[0] 6105 v_1 := v.Args[1] 6106 if v_1.Op != OpAnd64 { 6107 break 6108 } 6109 _ = v_1.Args[1] 6110 z := v_1.Args[0] 6111 i := v_1.Args[1] 6112 if i.Op != OpConst64 { 6113 break 6114 } 6115 t := i.Type 6116 if !(z.Op != OpConst64 && x.Op != OpConst64) { 6117 break 6118 } 6119 v.reset(OpAnd64) 6120 v.AddArg(i) 6121 v0 := b.NewValue0(v.Pos, OpAnd64, t) 6122 v0.AddArg(z) 6123 v0.AddArg(x) 6124 v.AddArg(v0) 6125 return true 6126 } 6127 // match: (And64 (Const64 <t> [c]) (And64 (Const64 <t> [d]) x)) 6128 // cond: 6129 // result: (And64 (Const64 <t> [c&d]) x) 6130 for { 6131 _ = v.Args[1] 6132 v_0 := v.Args[0] 6133 if v_0.Op != OpConst64 { 6134 break 6135 } 6136 t := v_0.Type 6137 c := v_0.AuxInt 6138 v_1 := v.Args[1] 6139 if v_1.Op != OpAnd64 { 6140 break 6141 } 6142 _ = v_1.Args[1] 6143 v_1_0 := v_1.Args[0] 6144 if v_1_0.Op != OpConst64 { 6145 break 6146 } 6147 if v_1_0.Type != t { 6148 break 6149 } 6150 d := v_1_0.AuxInt 6151 x := v_1.Args[1] 6152 v.reset(OpAnd64) 6153 v0 := b.NewValue0(v.Pos, OpConst64, t) 6154 v0.AuxInt = c & d 6155 v.AddArg(v0) 6156 v.AddArg(x) 6157 return true 6158 } 6159 // match: (And64 (Const64 <t> [c]) (And64 x (Const64 <t> [d]))) 6160 // cond: 6161 // result: (And64 (Const64 <t> [c&d]) x) 6162 for { 6163 _ = v.Args[1] 6164 v_0 := v.Args[0] 6165 if v_0.Op != OpConst64 { 6166 break 6167 } 6168 t := v_0.Type 6169 c := v_0.AuxInt 6170 v_1 := v.Args[1] 6171 if v_1.Op != OpAnd64 { 6172 break 6173 } 6174 _ = v_1.Args[1] 6175 x := v_1.Args[0] 6176 v_1_1 := v_1.Args[1] 6177 if v_1_1.Op != OpConst64 { 6178 break 6179 } 6180 if v_1_1.Type != t { 6181 break 6182 } 6183 d := v_1_1.AuxInt 6184 v.reset(OpAnd64) 6185 v0 := b.NewValue0(v.Pos, OpConst64, t) 6186 v0.AuxInt = c & d 6187 v.AddArg(v0) 6188 v.AddArg(x) 6189 return true 6190 } 6191 // match: (And64 (And64 (Const64 <t> [d]) x) (Const64 <t> [c])) 6192 // cond: 6193 // result: (And64 (Const64 <t> [c&d]) x) 6194 for { 6195 _ = v.Args[1] 6196 v_0 := v.Args[0] 6197 if v_0.Op != OpAnd64 { 6198 break 6199 } 6200 _ = v_0.Args[1] 6201 v_0_0 := v_0.Args[0] 6202 if v_0_0.Op != OpConst64 { 6203 break 6204 } 6205 t := v_0_0.Type 6206 d := v_0_0.AuxInt 6207 x := v_0.Args[1] 6208 v_1 := v.Args[1] 6209 if v_1.Op != OpConst64 { 6210 break 6211 } 6212 if v_1.Type != t { 6213 break 6214 } 6215 c := v_1.AuxInt 6216 v.reset(OpAnd64) 6217 v0 := b.NewValue0(v.Pos, OpConst64, t) 6218 v0.AuxInt = c & d 6219 v.AddArg(v0) 6220 v.AddArg(x) 6221 return true 6222 } 6223 // match: (And64 (And64 x (Const64 <t> [d])) (Const64 <t> [c])) 6224 // cond: 6225 // result: (And64 (Const64 <t> [c&d]) x) 6226 for { 6227 _ = v.Args[1] 6228 v_0 := v.Args[0] 6229 if v_0.Op != OpAnd64 { 6230 break 6231 } 6232 _ = v_0.Args[1] 6233 x := v_0.Args[0] 6234 v_0_1 := v_0.Args[1] 6235 if v_0_1.Op != OpConst64 { 6236 break 6237 } 6238 t := v_0_1.Type 6239 d := v_0_1.AuxInt 6240 v_1 := v.Args[1] 6241 if v_1.Op != OpConst64 { 6242 break 6243 } 6244 if v_1.Type != t { 6245 break 6246 } 6247 c := v_1.AuxInt 6248 v.reset(OpAnd64) 6249 v0 := b.NewValue0(v.Pos, OpConst64, t) 6250 v0.AuxInt = c & d 6251 v.AddArg(v0) 6252 v.AddArg(x) 6253 return true 6254 } 6255 return false 6256 } 6257 func rewriteValuegeneric_OpAnd8_0(v *Value) bool { 6258 // match: (And8 (Const8 [c]) (Const8 [d])) 6259 // cond: 6260 // result: (Const8 [int64(int8(c&d))]) 6261 for { 6262 _ = v.Args[1] 6263 v_0 := v.Args[0] 6264 if v_0.Op != OpConst8 { 6265 break 6266 } 6267 c := v_0.AuxInt 6268 v_1 := v.Args[1] 6269 if v_1.Op != OpConst8 { 6270 break 6271 } 6272 d := v_1.AuxInt 6273 v.reset(OpConst8) 6274 v.AuxInt = int64(int8(c & d)) 6275 return true 6276 } 6277 // match: (And8 (Const8 [d]) (Const8 [c])) 6278 // cond: 6279 // result: (Const8 [int64(int8(c&d))]) 6280 for { 6281 _ = v.Args[1] 6282 v_0 := v.Args[0] 6283 if v_0.Op != OpConst8 { 6284 break 6285 } 6286 d := v_0.AuxInt 6287 v_1 := v.Args[1] 6288 if v_1.Op != OpConst8 { 6289 break 6290 } 6291 c := v_1.AuxInt 6292 v.reset(OpConst8) 6293 v.AuxInt = int64(int8(c & d)) 6294 return true 6295 } 6296 // match: (And8 (Const8 [m]) (Rsh8Ux64 _ (Const64 [c]))) 6297 // cond: c >= 64-ntz(m) 6298 // result: (Const8 [0]) 6299 for { 6300 _ = v.Args[1] 6301 v_0 := v.Args[0] 6302 if v_0.Op != OpConst8 { 6303 break 6304 } 6305 m := v_0.AuxInt 6306 v_1 := v.Args[1] 6307 if v_1.Op != OpRsh8Ux64 { 6308 break 6309 } 6310 _ = v_1.Args[1] 6311 v_1_1 := v_1.Args[1] 6312 if v_1_1.Op != OpConst64 { 6313 break 6314 } 6315 c := v_1_1.AuxInt 6316 if !(c >= 64-ntz(m)) { 6317 break 6318 } 6319 v.reset(OpConst8) 6320 v.AuxInt = 0 6321 return true 6322 } 6323 // match: (And8 (Rsh8Ux64 _ (Const64 [c])) (Const8 [m])) 6324 // cond: c >= 64-ntz(m) 6325 // result: (Const8 [0]) 6326 for { 6327 _ = v.Args[1] 6328 v_0 := v.Args[0] 6329 if v_0.Op != OpRsh8Ux64 { 6330 break 6331 } 6332 _ = v_0.Args[1] 6333 v_0_1 := v_0.Args[1] 6334 if v_0_1.Op != OpConst64 { 6335 break 6336 } 6337 c := v_0_1.AuxInt 6338 v_1 := v.Args[1] 6339 if v_1.Op != OpConst8 { 6340 break 6341 } 6342 m := v_1.AuxInt 6343 if !(c >= 64-ntz(m)) { 6344 break 6345 } 6346 v.reset(OpConst8) 6347 v.AuxInt = 0 6348 return true 6349 } 6350 // match: (And8 (Const8 [m]) (Lsh8x64 _ (Const64 [c]))) 6351 // cond: c >= 64-nlz(m) 6352 // result: (Const8 [0]) 6353 for { 6354 _ = v.Args[1] 6355 v_0 := v.Args[0] 6356 if v_0.Op != OpConst8 { 6357 break 6358 } 6359 m := v_0.AuxInt 6360 v_1 := v.Args[1] 6361 if v_1.Op != OpLsh8x64 { 6362 break 6363 } 6364 _ = v_1.Args[1] 6365 v_1_1 := v_1.Args[1] 6366 if v_1_1.Op != OpConst64 { 6367 break 6368 } 6369 c := v_1_1.AuxInt 6370 if !(c >= 64-nlz(m)) { 6371 break 6372 } 6373 v.reset(OpConst8) 6374 v.AuxInt = 0 6375 return true 6376 } 6377 // match: (And8 (Lsh8x64 _ (Const64 [c])) (Const8 [m])) 6378 // cond: c >= 64-nlz(m) 6379 // result: (Const8 [0]) 6380 for { 6381 _ = v.Args[1] 6382 v_0 := v.Args[0] 6383 if v_0.Op != OpLsh8x64 { 6384 break 6385 } 6386 _ = v_0.Args[1] 6387 v_0_1 := v_0.Args[1] 6388 if v_0_1.Op != OpConst64 { 6389 break 6390 } 6391 c := v_0_1.AuxInt 6392 v_1 := v.Args[1] 6393 if v_1.Op != OpConst8 { 6394 break 6395 } 6396 m := v_1.AuxInt 6397 if !(c >= 64-nlz(m)) { 6398 break 6399 } 6400 v.reset(OpConst8) 6401 v.AuxInt = 0 6402 return true 6403 } 6404 // match: (And8 x x) 6405 // cond: 6406 // result: x 6407 for { 6408 _ = v.Args[1] 6409 x := v.Args[0] 6410 if x != v.Args[1] { 6411 break 6412 } 6413 v.reset(OpCopy) 6414 v.Type = x.Type 6415 v.AddArg(x) 6416 return true 6417 } 6418 // match: (And8 (Const8 [-1]) x) 6419 // cond: 6420 // result: x 6421 for { 6422 _ = v.Args[1] 6423 v_0 := v.Args[0] 6424 if v_0.Op != OpConst8 { 6425 break 6426 } 6427 if v_0.AuxInt != -1 { 6428 break 6429 } 6430 x := v.Args[1] 6431 v.reset(OpCopy) 6432 v.Type = x.Type 6433 v.AddArg(x) 6434 return true 6435 } 6436 // match: (And8 x (Const8 [-1])) 6437 // cond: 6438 // result: x 6439 for { 6440 _ = v.Args[1] 6441 x := v.Args[0] 6442 v_1 := v.Args[1] 6443 if v_1.Op != OpConst8 { 6444 break 6445 } 6446 if v_1.AuxInt != -1 { 6447 break 6448 } 6449 v.reset(OpCopy) 6450 v.Type = x.Type 6451 v.AddArg(x) 6452 return true 6453 } 6454 // match: (And8 (Const8 [0]) _) 6455 // cond: 6456 // result: (Const8 [0]) 6457 for { 6458 _ = v.Args[1] 6459 v_0 := v.Args[0] 6460 if v_0.Op != OpConst8 { 6461 break 6462 } 6463 if v_0.AuxInt != 0 { 6464 break 6465 } 6466 v.reset(OpConst8) 6467 v.AuxInt = 0 6468 return true 6469 } 6470 return false 6471 } 6472 func rewriteValuegeneric_OpAnd8_10(v *Value) bool { 6473 b := v.Block 6474 _ = b 6475 // match: (And8 _ (Const8 [0])) 6476 // cond: 6477 // result: (Const8 [0]) 6478 for { 6479 _ = v.Args[1] 6480 v_1 := v.Args[1] 6481 if v_1.Op != OpConst8 { 6482 break 6483 } 6484 if v_1.AuxInt != 0 { 6485 break 6486 } 6487 v.reset(OpConst8) 6488 v.AuxInt = 0 6489 return true 6490 } 6491 // match: (And8 x (And8 x y)) 6492 // cond: 6493 // result: (And8 x y) 6494 for { 6495 _ = v.Args[1] 6496 x := v.Args[0] 6497 v_1 := v.Args[1] 6498 if v_1.Op != OpAnd8 { 6499 break 6500 } 6501 _ = v_1.Args[1] 6502 if x != v_1.Args[0] { 6503 break 6504 } 6505 y := v_1.Args[1] 6506 v.reset(OpAnd8) 6507 v.AddArg(x) 6508 v.AddArg(y) 6509 return true 6510 } 6511 // match: (And8 x (And8 y x)) 6512 // cond: 6513 // result: (And8 x y) 6514 for { 6515 _ = v.Args[1] 6516 x := v.Args[0] 6517 v_1 := v.Args[1] 6518 if v_1.Op != OpAnd8 { 6519 break 6520 } 6521 _ = v_1.Args[1] 6522 y := v_1.Args[0] 6523 if x != v_1.Args[1] { 6524 break 6525 } 6526 v.reset(OpAnd8) 6527 v.AddArg(x) 6528 v.AddArg(y) 6529 return true 6530 } 6531 // match: (And8 (And8 x y) x) 6532 // cond: 6533 // result: (And8 x y) 6534 for { 6535 _ = v.Args[1] 6536 v_0 := v.Args[0] 6537 if v_0.Op != OpAnd8 { 6538 break 6539 } 6540 _ = v_0.Args[1] 6541 x := v_0.Args[0] 6542 y := v_0.Args[1] 6543 if x != v.Args[1] { 6544 break 6545 } 6546 v.reset(OpAnd8) 6547 v.AddArg(x) 6548 v.AddArg(y) 6549 return true 6550 } 6551 // match: (And8 (And8 y x) x) 6552 // cond: 6553 // result: (And8 x y) 6554 for { 6555 _ = v.Args[1] 6556 v_0 := v.Args[0] 6557 if v_0.Op != OpAnd8 { 6558 break 6559 } 6560 _ = v_0.Args[1] 6561 y := v_0.Args[0] 6562 x := v_0.Args[1] 6563 if x != v.Args[1] { 6564 break 6565 } 6566 v.reset(OpAnd8) 6567 v.AddArg(x) 6568 v.AddArg(y) 6569 return true 6570 } 6571 // match: (And8 (And8 i:(Const8 <t>) z) x) 6572 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 6573 // result: (And8 i (And8 <t> z x)) 6574 for { 6575 _ = v.Args[1] 6576 v_0 := v.Args[0] 6577 if v_0.Op != OpAnd8 { 6578 break 6579 } 6580 _ = v_0.Args[1] 6581 i := v_0.Args[0] 6582 if i.Op != OpConst8 { 6583 break 6584 } 6585 t := i.Type 6586 z := v_0.Args[1] 6587 x := v.Args[1] 6588 if !(z.Op != OpConst8 && x.Op != OpConst8) { 6589 break 6590 } 6591 v.reset(OpAnd8) 6592 v.AddArg(i) 6593 v0 := b.NewValue0(v.Pos, OpAnd8, t) 6594 v0.AddArg(z) 6595 v0.AddArg(x) 6596 v.AddArg(v0) 6597 return true 6598 } 6599 // match: (And8 (And8 z i:(Const8 <t>)) x) 6600 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 6601 // result: (And8 i (And8 <t> z x)) 6602 for { 6603 _ = v.Args[1] 6604 v_0 := v.Args[0] 6605 if v_0.Op != OpAnd8 { 6606 break 6607 } 6608 _ = v_0.Args[1] 6609 z := v_0.Args[0] 6610 i := v_0.Args[1] 6611 if i.Op != OpConst8 { 6612 break 6613 } 6614 t := i.Type 6615 x := v.Args[1] 6616 if !(z.Op != OpConst8 && x.Op != OpConst8) { 6617 break 6618 } 6619 v.reset(OpAnd8) 6620 v.AddArg(i) 6621 v0 := b.NewValue0(v.Pos, OpAnd8, t) 6622 v0.AddArg(z) 6623 v0.AddArg(x) 6624 v.AddArg(v0) 6625 return true 6626 } 6627 // match: (And8 x (And8 i:(Const8 <t>) z)) 6628 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 6629 // result: (And8 i (And8 <t> z x)) 6630 for { 6631 _ = v.Args[1] 6632 x := v.Args[0] 6633 v_1 := v.Args[1] 6634 if v_1.Op != OpAnd8 { 6635 break 6636 } 6637 _ = v_1.Args[1] 6638 i := v_1.Args[0] 6639 if i.Op != OpConst8 { 6640 break 6641 } 6642 t := i.Type 6643 z := v_1.Args[1] 6644 if !(z.Op != OpConst8 && x.Op != OpConst8) { 6645 break 6646 } 6647 v.reset(OpAnd8) 6648 v.AddArg(i) 6649 v0 := b.NewValue0(v.Pos, OpAnd8, t) 6650 v0.AddArg(z) 6651 v0.AddArg(x) 6652 v.AddArg(v0) 6653 return true 6654 } 6655 // match: (And8 x (And8 z i:(Const8 <t>))) 6656 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 6657 // result: (And8 i (And8 <t> z x)) 6658 for { 6659 _ = v.Args[1] 6660 x := v.Args[0] 6661 v_1 := v.Args[1] 6662 if v_1.Op != OpAnd8 { 6663 break 6664 } 6665 _ = v_1.Args[1] 6666 z := v_1.Args[0] 6667 i := v_1.Args[1] 6668 if i.Op != OpConst8 { 6669 break 6670 } 6671 t := i.Type 6672 if !(z.Op != OpConst8 && x.Op != OpConst8) { 6673 break 6674 } 6675 v.reset(OpAnd8) 6676 v.AddArg(i) 6677 v0 := b.NewValue0(v.Pos, OpAnd8, t) 6678 v0.AddArg(z) 6679 v0.AddArg(x) 6680 v.AddArg(v0) 6681 return true 6682 } 6683 // match: (And8 (Const8 <t> [c]) (And8 (Const8 <t> [d]) x)) 6684 // cond: 6685 // result: (And8 (Const8 <t> [int64(int8(c&d))]) x) 6686 for { 6687 _ = v.Args[1] 6688 v_0 := v.Args[0] 6689 if v_0.Op != OpConst8 { 6690 break 6691 } 6692 t := v_0.Type 6693 c := v_0.AuxInt 6694 v_1 := v.Args[1] 6695 if v_1.Op != OpAnd8 { 6696 break 6697 } 6698 _ = v_1.Args[1] 6699 v_1_0 := v_1.Args[0] 6700 if v_1_0.Op != OpConst8 { 6701 break 6702 } 6703 if v_1_0.Type != t { 6704 break 6705 } 6706 d := v_1_0.AuxInt 6707 x := v_1.Args[1] 6708 v.reset(OpAnd8) 6709 v0 := b.NewValue0(v.Pos, OpConst8, t) 6710 v0.AuxInt = int64(int8(c & d)) 6711 v.AddArg(v0) 6712 v.AddArg(x) 6713 return true 6714 } 6715 return false 6716 } 6717 func rewriteValuegeneric_OpAnd8_20(v *Value) bool { 6718 b := v.Block 6719 _ = b 6720 // match: (And8 (Const8 <t> [c]) (And8 x (Const8 <t> [d]))) 6721 // cond: 6722 // result: (And8 (Const8 <t> [int64(int8(c&d))]) x) 6723 for { 6724 _ = v.Args[1] 6725 v_0 := v.Args[0] 6726 if v_0.Op != OpConst8 { 6727 break 6728 } 6729 t := v_0.Type 6730 c := v_0.AuxInt 6731 v_1 := v.Args[1] 6732 if v_1.Op != OpAnd8 { 6733 break 6734 } 6735 _ = v_1.Args[1] 6736 x := v_1.Args[0] 6737 v_1_1 := v_1.Args[1] 6738 if v_1_1.Op != OpConst8 { 6739 break 6740 } 6741 if v_1_1.Type != t { 6742 break 6743 } 6744 d := v_1_1.AuxInt 6745 v.reset(OpAnd8) 6746 v0 := b.NewValue0(v.Pos, OpConst8, t) 6747 v0.AuxInt = int64(int8(c & d)) 6748 v.AddArg(v0) 6749 v.AddArg(x) 6750 return true 6751 } 6752 // match: (And8 (And8 (Const8 <t> [d]) x) (Const8 <t> [c])) 6753 // cond: 6754 // result: (And8 (Const8 <t> [int64(int8(c&d))]) x) 6755 for { 6756 _ = v.Args[1] 6757 v_0 := v.Args[0] 6758 if v_0.Op != OpAnd8 { 6759 break 6760 } 6761 _ = v_0.Args[1] 6762 v_0_0 := v_0.Args[0] 6763 if v_0_0.Op != OpConst8 { 6764 break 6765 } 6766 t := v_0_0.Type 6767 d := v_0_0.AuxInt 6768 x := v_0.Args[1] 6769 v_1 := v.Args[1] 6770 if v_1.Op != OpConst8 { 6771 break 6772 } 6773 if v_1.Type != t { 6774 break 6775 } 6776 c := v_1.AuxInt 6777 v.reset(OpAnd8) 6778 v0 := b.NewValue0(v.Pos, OpConst8, t) 6779 v0.AuxInt = int64(int8(c & d)) 6780 v.AddArg(v0) 6781 v.AddArg(x) 6782 return true 6783 } 6784 // match: (And8 (And8 x (Const8 <t> [d])) (Const8 <t> [c])) 6785 // cond: 6786 // result: (And8 (Const8 <t> [int64(int8(c&d))]) x) 6787 for { 6788 _ = v.Args[1] 6789 v_0 := v.Args[0] 6790 if v_0.Op != OpAnd8 { 6791 break 6792 } 6793 _ = v_0.Args[1] 6794 x := v_0.Args[0] 6795 v_0_1 := v_0.Args[1] 6796 if v_0_1.Op != OpConst8 { 6797 break 6798 } 6799 t := v_0_1.Type 6800 d := v_0_1.AuxInt 6801 v_1 := v.Args[1] 6802 if v_1.Op != OpConst8 { 6803 break 6804 } 6805 if v_1.Type != t { 6806 break 6807 } 6808 c := v_1.AuxInt 6809 v.reset(OpAnd8) 6810 v0 := b.NewValue0(v.Pos, OpConst8, t) 6811 v0.AuxInt = int64(int8(c & d)) 6812 v.AddArg(v0) 6813 v.AddArg(x) 6814 return true 6815 } 6816 return false 6817 } 6818 func rewriteValuegeneric_OpArraySelect_0(v *Value) bool { 6819 // match: (ArraySelect (ArrayMake1 x)) 6820 // cond: 6821 // result: x 6822 for { 6823 v_0 := v.Args[0] 6824 if v_0.Op != OpArrayMake1 { 6825 break 6826 } 6827 x := v_0.Args[0] 6828 v.reset(OpCopy) 6829 v.Type = x.Type 6830 v.AddArg(x) 6831 return true 6832 } 6833 // match: (ArraySelect [0] x:(IData _)) 6834 // cond: 6835 // result: x 6836 for { 6837 if v.AuxInt != 0 { 6838 break 6839 } 6840 x := v.Args[0] 6841 if x.Op != OpIData { 6842 break 6843 } 6844 v.reset(OpCopy) 6845 v.Type = x.Type 6846 v.AddArg(x) 6847 return true 6848 } 6849 return false 6850 } 6851 func rewriteValuegeneric_OpCom16_0(v *Value) bool { 6852 // match: (Com16 (Com16 x)) 6853 // cond: 6854 // result: x 6855 for { 6856 v_0 := v.Args[0] 6857 if v_0.Op != OpCom16 { 6858 break 6859 } 6860 x := v_0.Args[0] 6861 v.reset(OpCopy) 6862 v.Type = x.Type 6863 v.AddArg(x) 6864 return true 6865 } 6866 // match: (Com16 (Const16 [c])) 6867 // cond: 6868 // result: (Const16 [^c]) 6869 for { 6870 v_0 := v.Args[0] 6871 if v_0.Op != OpConst16 { 6872 break 6873 } 6874 c := v_0.AuxInt 6875 v.reset(OpConst16) 6876 v.AuxInt = ^c 6877 return true 6878 } 6879 return false 6880 } 6881 func rewriteValuegeneric_OpCom32_0(v *Value) bool { 6882 // match: (Com32 (Com32 x)) 6883 // cond: 6884 // result: x 6885 for { 6886 v_0 := v.Args[0] 6887 if v_0.Op != OpCom32 { 6888 break 6889 } 6890 x := v_0.Args[0] 6891 v.reset(OpCopy) 6892 v.Type = x.Type 6893 v.AddArg(x) 6894 return true 6895 } 6896 // match: (Com32 (Const32 [c])) 6897 // cond: 6898 // result: (Const32 [^c]) 6899 for { 6900 v_0 := v.Args[0] 6901 if v_0.Op != OpConst32 { 6902 break 6903 } 6904 c := v_0.AuxInt 6905 v.reset(OpConst32) 6906 v.AuxInt = ^c 6907 return true 6908 } 6909 return false 6910 } 6911 func rewriteValuegeneric_OpCom64_0(v *Value) bool { 6912 // match: (Com64 (Com64 x)) 6913 // cond: 6914 // result: x 6915 for { 6916 v_0 := v.Args[0] 6917 if v_0.Op != OpCom64 { 6918 break 6919 } 6920 x := v_0.Args[0] 6921 v.reset(OpCopy) 6922 v.Type = x.Type 6923 v.AddArg(x) 6924 return true 6925 } 6926 // match: (Com64 (Const64 [c])) 6927 // cond: 6928 // result: (Const64 [^c]) 6929 for { 6930 v_0 := v.Args[0] 6931 if v_0.Op != OpConst64 { 6932 break 6933 } 6934 c := v_0.AuxInt 6935 v.reset(OpConst64) 6936 v.AuxInt = ^c 6937 return true 6938 } 6939 return false 6940 } 6941 func rewriteValuegeneric_OpCom8_0(v *Value) bool { 6942 // match: (Com8 (Com8 x)) 6943 // cond: 6944 // result: x 6945 for { 6946 v_0 := v.Args[0] 6947 if v_0.Op != OpCom8 { 6948 break 6949 } 6950 x := v_0.Args[0] 6951 v.reset(OpCopy) 6952 v.Type = x.Type 6953 v.AddArg(x) 6954 return true 6955 } 6956 // match: (Com8 (Const8 [c])) 6957 // cond: 6958 // result: (Const8 [^c]) 6959 for { 6960 v_0 := v.Args[0] 6961 if v_0.Op != OpConst8 { 6962 break 6963 } 6964 c := v_0.AuxInt 6965 v.reset(OpConst8) 6966 v.AuxInt = ^c 6967 return true 6968 } 6969 return false 6970 } 6971 func rewriteValuegeneric_OpConstInterface_0(v *Value) bool { 6972 b := v.Block 6973 _ = b 6974 typ := &b.Func.Config.Types 6975 _ = typ 6976 // match: (ConstInterface) 6977 // cond: 6978 // result: (IMake (ConstNil <typ.Uintptr>) (ConstNil <typ.BytePtr>)) 6979 for { 6980 v.reset(OpIMake) 6981 v0 := b.NewValue0(v.Pos, OpConstNil, typ.Uintptr) 6982 v.AddArg(v0) 6983 v1 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr) 6984 v.AddArg(v1) 6985 return true 6986 } 6987 } 6988 func rewriteValuegeneric_OpConstSlice_0(v *Value) bool { 6989 b := v.Block 6990 _ = b 6991 config := b.Func.Config 6992 _ = config 6993 typ := &b.Func.Config.Types 6994 _ = typ 6995 // match: (ConstSlice) 6996 // cond: config.PtrSize == 4 6997 // result: (SliceMake (ConstNil <v.Type.Elem().PtrTo()>) (Const32 <typ.Int> [0]) (Const32 <typ.Int> [0])) 6998 for { 6999 if !(config.PtrSize == 4) { 7000 break 7001 } 7002 v.reset(OpSliceMake) 7003 v0 := b.NewValue0(v.Pos, OpConstNil, v.Type.Elem().PtrTo()) 7004 v.AddArg(v0) 7005 v1 := b.NewValue0(v.Pos, OpConst32, typ.Int) 7006 v1.AuxInt = 0 7007 v.AddArg(v1) 7008 v2 := b.NewValue0(v.Pos, OpConst32, typ.Int) 7009 v2.AuxInt = 0 7010 v.AddArg(v2) 7011 return true 7012 } 7013 // match: (ConstSlice) 7014 // cond: config.PtrSize == 8 7015 // result: (SliceMake (ConstNil <v.Type.Elem().PtrTo()>) (Const64 <typ.Int> [0]) (Const64 <typ.Int> [0])) 7016 for { 7017 if !(config.PtrSize == 8) { 7018 break 7019 } 7020 v.reset(OpSliceMake) 7021 v0 := b.NewValue0(v.Pos, OpConstNil, v.Type.Elem().PtrTo()) 7022 v.AddArg(v0) 7023 v1 := b.NewValue0(v.Pos, OpConst64, typ.Int) 7024 v1.AuxInt = 0 7025 v.AddArg(v1) 7026 v2 := b.NewValue0(v.Pos, OpConst64, typ.Int) 7027 v2.AuxInt = 0 7028 v.AddArg(v2) 7029 return true 7030 } 7031 return false 7032 } 7033 func rewriteValuegeneric_OpConstString_0(v *Value) bool { 7034 b := v.Block 7035 _ = b 7036 config := b.Func.Config 7037 _ = config 7038 fe := b.Func.fe 7039 _ = fe 7040 typ := &b.Func.Config.Types 7041 _ = typ 7042 // match: (ConstString {s}) 7043 // cond: config.PtrSize == 4 && s.(string) == "" 7044 // result: (StringMake (ConstNil) (Const32 <typ.Int> [0])) 7045 for { 7046 s := v.Aux 7047 if !(config.PtrSize == 4 && s.(string) == "") { 7048 break 7049 } 7050 v.reset(OpStringMake) 7051 v0 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr) 7052 v.AddArg(v0) 7053 v1 := b.NewValue0(v.Pos, OpConst32, typ.Int) 7054 v1.AuxInt = 0 7055 v.AddArg(v1) 7056 return true 7057 } 7058 // match: (ConstString {s}) 7059 // cond: config.PtrSize == 8 && s.(string) == "" 7060 // result: (StringMake (ConstNil) (Const64 <typ.Int> [0])) 7061 for { 7062 s := v.Aux 7063 if !(config.PtrSize == 8 && s.(string) == "") { 7064 break 7065 } 7066 v.reset(OpStringMake) 7067 v0 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr) 7068 v.AddArg(v0) 7069 v1 := b.NewValue0(v.Pos, OpConst64, typ.Int) 7070 v1.AuxInt = 0 7071 v.AddArg(v1) 7072 return true 7073 } 7074 // match: (ConstString {s}) 7075 // cond: config.PtrSize == 4 && s.(string) != "" 7076 // result: (StringMake (Addr <typ.BytePtr> {fe.StringData(s.(string))} (SB)) (Const32 <typ.Int> [int64(len(s.(string)))])) 7077 for { 7078 s := v.Aux 7079 if !(config.PtrSize == 4 && s.(string) != "") { 7080 break 7081 } 7082 v.reset(OpStringMake) 7083 v0 := b.NewValue0(v.Pos, OpAddr, typ.BytePtr) 7084 v0.Aux = fe.StringData(s.(string)) 7085 v1 := b.NewValue0(v.Pos, OpSB, typ.Uintptr) 7086 v0.AddArg(v1) 7087 v.AddArg(v0) 7088 v2 := b.NewValue0(v.Pos, OpConst32, typ.Int) 7089 v2.AuxInt = int64(len(s.(string))) 7090 v.AddArg(v2) 7091 return true 7092 } 7093 // match: (ConstString {s}) 7094 // cond: config.PtrSize == 8 && s.(string) != "" 7095 // result: (StringMake (Addr <typ.BytePtr> {fe.StringData(s.(string))} (SB)) (Const64 <typ.Int> [int64(len(s.(string)))])) 7096 for { 7097 s := v.Aux 7098 if !(config.PtrSize == 8 && s.(string) != "") { 7099 break 7100 } 7101 v.reset(OpStringMake) 7102 v0 := b.NewValue0(v.Pos, OpAddr, typ.BytePtr) 7103 v0.Aux = fe.StringData(s.(string)) 7104 v1 := b.NewValue0(v.Pos, OpSB, typ.Uintptr) 7105 v0.AddArg(v1) 7106 v.AddArg(v0) 7107 v2 := b.NewValue0(v.Pos, OpConst64, typ.Int) 7108 v2.AuxInt = int64(len(s.(string))) 7109 v.AddArg(v2) 7110 return true 7111 } 7112 return false 7113 } 7114 func rewriteValuegeneric_OpConvert_0(v *Value) bool { 7115 // match: (Convert (Add64 (Convert ptr mem) off) mem) 7116 // cond: 7117 // result: (Add64 ptr off) 7118 for { 7119 _ = v.Args[1] 7120 v_0 := v.Args[0] 7121 if v_0.Op != OpAdd64 { 7122 break 7123 } 7124 _ = v_0.Args[1] 7125 v_0_0 := v_0.Args[0] 7126 if v_0_0.Op != OpConvert { 7127 break 7128 } 7129 _ = v_0_0.Args[1] 7130 ptr := v_0_0.Args[0] 7131 mem := v_0_0.Args[1] 7132 off := v_0.Args[1] 7133 if mem != v.Args[1] { 7134 break 7135 } 7136 v.reset(OpAdd64) 7137 v.AddArg(ptr) 7138 v.AddArg(off) 7139 return true 7140 } 7141 // match: (Convert (Add64 off (Convert ptr mem)) mem) 7142 // cond: 7143 // result: (Add64 ptr off) 7144 for { 7145 _ = v.Args[1] 7146 v_0 := v.Args[0] 7147 if v_0.Op != OpAdd64 { 7148 break 7149 } 7150 _ = v_0.Args[1] 7151 off := v_0.Args[0] 7152 v_0_1 := v_0.Args[1] 7153 if v_0_1.Op != OpConvert { 7154 break 7155 } 7156 _ = v_0_1.Args[1] 7157 ptr := v_0_1.Args[0] 7158 mem := v_0_1.Args[1] 7159 if mem != v.Args[1] { 7160 break 7161 } 7162 v.reset(OpAdd64) 7163 v.AddArg(ptr) 7164 v.AddArg(off) 7165 return true 7166 } 7167 // match: (Convert (Add32 (Convert ptr mem) off) mem) 7168 // cond: 7169 // result: (Add32 ptr off) 7170 for { 7171 _ = v.Args[1] 7172 v_0 := v.Args[0] 7173 if v_0.Op != OpAdd32 { 7174 break 7175 } 7176 _ = v_0.Args[1] 7177 v_0_0 := v_0.Args[0] 7178 if v_0_0.Op != OpConvert { 7179 break 7180 } 7181 _ = v_0_0.Args[1] 7182 ptr := v_0_0.Args[0] 7183 mem := v_0_0.Args[1] 7184 off := v_0.Args[1] 7185 if mem != v.Args[1] { 7186 break 7187 } 7188 v.reset(OpAdd32) 7189 v.AddArg(ptr) 7190 v.AddArg(off) 7191 return true 7192 } 7193 // match: (Convert (Add32 off (Convert ptr mem)) mem) 7194 // cond: 7195 // result: (Add32 ptr off) 7196 for { 7197 _ = v.Args[1] 7198 v_0 := v.Args[0] 7199 if v_0.Op != OpAdd32 { 7200 break 7201 } 7202 _ = v_0.Args[1] 7203 off := v_0.Args[0] 7204 v_0_1 := v_0.Args[1] 7205 if v_0_1.Op != OpConvert { 7206 break 7207 } 7208 _ = v_0_1.Args[1] 7209 ptr := v_0_1.Args[0] 7210 mem := v_0_1.Args[1] 7211 if mem != v.Args[1] { 7212 break 7213 } 7214 v.reset(OpAdd32) 7215 v.AddArg(ptr) 7216 v.AddArg(off) 7217 return true 7218 } 7219 // match: (Convert (Convert ptr mem) mem) 7220 // cond: 7221 // result: ptr 7222 for { 7223 _ = v.Args[1] 7224 v_0 := v.Args[0] 7225 if v_0.Op != OpConvert { 7226 break 7227 } 7228 _ = v_0.Args[1] 7229 ptr := v_0.Args[0] 7230 mem := v_0.Args[1] 7231 if mem != v.Args[1] { 7232 break 7233 } 7234 v.reset(OpCopy) 7235 v.Type = ptr.Type 7236 v.AddArg(ptr) 7237 return true 7238 } 7239 return false 7240 } 7241 func rewriteValuegeneric_OpCvt32Fto32_0(v *Value) bool { 7242 // match: (Cvt32Fto32 (Const32F [c])) 7243 // cond: 7244 // result: (Const32 [int64(int32(auxTo32F(c)))]) 7245 for { 7246 v_0 := v.Args[0] 7247 if v_0.Op != OpConst32F { 7248 break 7249 } 7250 c := v_0.AuxInt 7251 v.reset(OpConst32) 7252 v.AuxInt = int64(int32(auxTo32F(c))) 7253 return true 7254 } 7255 return false 7256 } 7257 func rewriteValuegeneric_OpCvt32Fto64_0(v *Value) bool { 7258 // match: (Cvt32Fto64 (Const32F [c])) 7259 // cond: 7260 // result: (Const64 [int64(auxTo32F(c))]) 7261 for { 7262 v_0 := v.Args[0] 7263 if v_0.Op != OpConst32F { 7264 break 7265 } 7266 c := v_0.AuxInt 7267 v.reset(OpConst64) 7268 v.AuxInt = int64(auxTo32F(c)) 7269 return true 7270 } 7271 return false 7272 } 7273 func rewriteValuegeneric_OpCvt32Fto64F_0(v *Value) bool { 7274 // match: (Cvt32Fto64F (Const32F [c])) 7275 // cond: 7276 // result: (Const64F [c]) 7277 for { 7278 v_0 := v.Args[0] 7279 if v_0.Op != OpConst32F { 7280 break 7281 } 7282 c := v_0.AuxInt 7283 v.reset(OpConst64F) 7284 v.AuxInt = c 7285 return true 7286 } 7287 return false 7288 } 7289 func rewriteValuegeneric_OpCvt32to32F_0(v *Value) bool { 7290 // match: (Cvt32to32F (Const32 [c])) 7291 // cond: 7292 // result: (Const32F [auxFrom32F(float32(int32(c)))]) 7293 for { 7294 v_0 := v.Args[0] 7295 if v_0.Op != OpConst32 { 7296 break 7297 } 7298 c := v_0.AuxInt 7299 v.reset(OpConst32F) 7300 v.AuxInt = auxFrom32F(float32(int32(c))) 7301 return true 7302 } 7303 return false 7304 } 7305 func rewriteValuegeneric_OpCvt32to64F_0(v *Value) bool { 7306 // match: (Cvt32to64F (Const32 [c])) 7307 // cond: 7308 // result: (Const64F [auxFrom64F(float64(int32(c)))]) 7309 for { 7310 v_0 := v.Args[0] 7311 if v_0.Op != OpConst32 { 7312 break 7313 } 7314 c := v_0.AuxInt 7315 v.reset(OpConst64F) 7316 v.AuxInt = auxFrom64F(float64(int32(c))) 7317 return true 7318 } 7319 return false 7320 } 7321 func rewriteValuegeneric_OpCvt64Fto32_0(v *Value) bool { 7322 // match: (Cvt64Fto32 (Const64F [c])) 7323 // cond: 7324 // result: (Const32 [int64(int32(auxTo64F(c)))]) 7325 for { 7326 v_0 := v.Args[0] 7327 if v_0.Op != OpConst64F { 7328 break 7329 } 7330 c := v_0.AuxInt 7331 v.reset(OpConst32) 7332 v.AuxInt = int64(int32(auxTo64F(c))) 7333 return true 7334 } 7335 return false 7336 } 7337 func rewriteValuegeneric_OpCvt64Fto32F_0(v *Value) bool { 7338 // match: (Cvt64Fto32F (Const64F [c])) 7339 // cond: 7340 // result: (Const32F [auxFrom32F(float32(auxTo64F(c)))]) 7341 for { 7342 v_0 := v.Args[0] 7343 if v_0.Op != OpConst64F { 7344 break 7345 } 7346 c := v_0.AuxInt 7347 v.reset(OpConst32F) 7348 v.AuxInt = auxFrom32F(float32(auxTo64F(c))) 7349 return true 7350 } 7351 return false 7352 } 7353 func rewriteValuegeneric_OpCvt64Fto64_0(v *Value) bool { 7354 // match: (Cvt64Fto64 (Const64F [c])) 7355 // cond: 7356 // result: (Const64 [int64(auxTo64F(c))]) 7357 for { 7358 v_0 := v.Args[0] 7359 if v_0.Op != OpConst64F { 7360 break 7361 } 7362 c := v_0.AuxInt 7363 v.reset(OpConst64) 7364 v.AuxInt = int64(auxTo64F(c)) 7365 return true 7366 } 7367 return false 7368 } 7369 func rewriteValuegeneric_OpCvt64to32F_0(v *Value) bool { 7370 // match: (Cvt64to32F (Const64 [c])) 7371 // cond: 7372 // result: (Const32F [auxFrom32F(float32(c))]) 7373 for { 7374 v_0 := v.Args[0] 7375 if v_0.Op != OpConst64 { 7376 break 7377 } 7378 c := v_0.AuxInt 7379 v.reset(OpConst32F) 7380 v.AuxInt = auxFrom32F(float32(c)) 7381 return true 7382 } 7383 return false 7384 } 7385 func rewriteValuegeneric_OpCvt64to64F_0(v *Value) bool { 7386 // match: (Cvt64to64F (Const64 [c])) 7387 // cond: 7388 // result: (Const64F [auxFrom64F(float64(c))]) 7389 for { 7390 v_0 := v.Args[0] 7391 if v_0.Op != OpConst64 { 7392 break 7393 } 7394 c := v_0.AuxInt 7395 v.reset(OpConst64F) 7396 v.AuxInt = auxFrom64F(float64(c)) 7397 return true 7398 } 7399 return false 7400 } 7401 func rewriteValuegeneric_OpDiv16_0(v *Value) bool { 7402 b := v.Block 7403 _ = b 7404 typ := &b.Func.Config.Types 7405 _ = typ 7406 // match: (Div16 (Const16 [c]) (Const16 [d])) 7407 // cond: d != 0 7408 // result: (Const16 [int64(int16(c)/int16(d))]) 7409 for { 7410 _ = v.Args[1] 7411 v_0 := v.Args[0] 7412 if v_0.Op != OpConst16 { 7413 break 7414 } 7415 c := v_0.AuxInt 7416 v_1 := v.Args[1] 7417 if v_1.Op != OpConst16 { 7418 break 7419 } 7420 d := v_1.AuxInt 7421 if !(d != 0) { 7422 break 7423 } 7424 v.reset(OpConst16) 7425 v.AuxInt = int64(int16(c) / int16(d)) 7426 return true 7427 } 7428 // match: (Div16 n (Const16 [c])) 7429 // cond: isNonNegative(n) && isPowerOfTwo(c&0xffff) 7430 // result: (Rsh16Ux64 n (Const64 <typ.UInt64> [log2(c&0xffff)])) 7431 for { 7432 _ = v.Args[1] 7433 n := v.Args[0] 7434 v_1 := v.Args[1] 7435 if v_1.Op != OpConst16 { 7436 break 7437 } 7438 c := v_1.AuxInt 7439 if !(isNonNegative(n) && isPowerOfTwo(c&0xffff)) { 7440 break 7441 } 7442 v.reset(OpRsh16Ux64) 7443 v.AddArg(n) 7444 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7445 v0.AuxInt = log2(c & 0xffff) 7446 v.AddArg(v0) 7447 return true 7448 } 7449 // match: (Div16 <t> n (Const16 [c])) 7450 // cond: c < 0 && c != -1<<15 7451 // result: (Neg16 (Div16 <t> n (Const16 <t> [-c]))) 7452 for { 7453 t := v.Type 7454 _ = v.Args[1] 7455 n := v.Args[0] 7456 v_1 := v.Args[1] 7457 if v_1.Op != OpConst16 { 7458 break 7459 } 7460 c := v_1.AuxInt 7461 if !(c < 0 && c != -1<<15) { 7462 break 7463 } 7464 v.reset(OpNeg16) 7465 v0 := b.NewValue0(v.Pos, OpDiv16, t) 7466 v0.AddArg(n) 7467 v1 := b.NewValue0(v.Pos, OpConst16, t) 7468 v1.AuxInt = -c 7469 v0.AddArg(v1) 7470 v.AddArg(v0) 7471 return true 7472 } 7473 // match: (Div16 <t> x (Const16 [-1<<15])) 7474 // cond: 7475 // result: (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <typ.UInt64> [15])) 7476 for { 7477 t := v.Type 7478 _ = v.Args[1] 7479 x := v.Args[0] 7480 v_1 := v.Args[1] 7481 if v_1.Op != OpConst16 { 7482 break 7483 } 7484 if v_1.AuxInt != -1<<15 { 7485 break 7486 } 7487 v.reset(OpRsh16Ux64) 7488 v0 := b.NewValue0(v.Pos, OpAnd16, t) 7489 v0.AddArg(x) 7490 v1 := b.NewValue0(v.Pos, OpNeg16, t) 7491 v1.AddArg(x) 7492 v0.AddArg(v1) 7493 v.AddArg(v0) 7494 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7495 v2.AuxInt = 15 7496 v.AddArg(v2) 7497 return true 7498 } 7499 // match: (Div16 <t> n (Const16 [c])) 7500 // cond: isPowerOfTwo(c) 7501 // 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)])) 7502 for { 7503 t := v.Type 7504 _ = v.Args[1] 7505 n := v.Args[0] 7506 v_1 := v.Args[1] 7507 if v_1.Op != OpConst16 { 7508 break 7509 } 7510 c := v_1.AuxInt 7511 if !(isPowerOfTwo(c)) { 7512 break 7513 } 7514 v.reset(OpRsh16x64) 7515 v0 := b.NewValue0(v.Pos, OpAdd16, t) 7516 v0.AddArg(n) 7517 v1 := b.NewValue0(v.Pos, OpRsh16Ux64, t) 7518 v2 := b.NewValue0(v.Pos, OpRsh16x64, t) 7519 v2.AddArg(n) 7520 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7521 v3.AuxInt = 15 7522 v2.AddArg(v3) 7523 v1.AddArg(v2) 7524 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7525 v4.AuxInt = 16 - log2(c) 7526 v1.AddArg(v4) 7527 v0.AddArg(v1) 7528 v.AddArg(v0) 7529 v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7530 v5.AuxInt = log2(c) 7531 v.AddArg(v5) 7532 return true 7533 } 7534 // match: (Div16 <t> x (Const16 [c])) 7535 // cond: smagicOK(16,c) 7536 // 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]))) 7537 for { 7538 t := v.Type 7539 _ = v.Args[1] 7540 x := v.Args[0] 7541 v_1 := v.Args[1] 7542 if v_1.Op != OpConst16 { 7543 break 7544 } 7545 c := v_1.AuxInt 7546 if !(smagicOK(16, c)) { 7547 break 7548 } 7549 v.reset(OpSub16) 7550 v.Type = t 7551 v0 := b.NewValue0(v.Pos, OpRsh32x64, t) 7552 v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) 7553 v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 7554 v2.AuxInt = int64(smagic(16, c).m) 7555 v1.AddArg(v2) 7556 v3 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 7557 v3.AddArg(x) 7558 v1.AddArg(v3) 7559 v0.AddArg(v1) 7560 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7561 v4.AuxInt = 16 + smagic(16, c).s 7562 v0.AddArg(v4) 7563 v.AddArg(v0) 7564 v5 := b.NewValue0(v.Pos, OpRsh32x64, t) 7565 v6 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 7566 v6.AddArg(x) 7567 v5.AddArg(v6) 7568 v7 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7569 v7.AuxInt = 31 7570 v5.AddArg(v7) 7571 v.AddArg(v5) 7572 return true 7573 } 7574 return false 7575 } 7576 func rewriteValuegeneric_OpDiv16u_0(v *Value) bool { 7577 b := v.Block 7578 _ = b 7579 config := b.Func.Config 7580 _ = config 7581 typ := &b.Func.Config.Types 7582 _ = typ 7583 // match: (Div16u (Const16 [c]) (Const16 [d])) 7584 // cond: d != 0 7585 // result: (Const16 [int64(int16(uint16(c)/uint16(d)))]) 7586 for { 7587 _ = v.Args[1] 7588 v_0 := v.Args[0] 7589 if v_0.Op != OpConst16 { 7590 break 7591 } 7592 c := v_0.AuxInt 7593 v_1 := v.Args[1] 7594 if v_1.Op != OpConst16 { 7595 break 7596 } 7597 d := v_1.AuxInt 7598 if !(d != 0) { 7599 break 7600 } 7601 v.reset(OpConst16) 7602 v.AuxInt = int64(int16(uint16(c) / uint16(d))) 7603 return true 7604 } 7605 // match: (Div16u n (Const16 [c])) 7606 // cond: isPowerOfTwo(c&0xffff) 7607 // result: (Rsh16Ux64 n (Const64 <typ.UInt64> [log2(c&0xffff)])) 7608 for { 7609 _ = v.Args[1] 7610 n := v.Args[0] 7611 v_1 := v.Args[1] 7612 if v_1.Op != OpConst16 { 7613 break 7614 } 7615 c := v_1.AuxInt 7616 if !(isPowerOfTwo(c & 0xffff)) { 7617 break 7618 } 7619 v.reset(OpRsh16Ux64) 7620 v.AddArg(n) 7621 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7622 v0.AuxInt = log2(c & 0xffff) 7623 v.AddArg(v0) 7624 return true 7625 } 7626 // match: (Div16u x (Const16 [c])) 7627 // cond: umagicOK(16, c) && config.RegSize == 8 7628 // 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]))) 7629 for { 7630 _ = v.Args[1] 7631 x := v.Args[0] 7632 v_1 := v.Args[1] 7633 if v_1.Op != OpConst16 { 7634 break 7635 } 7636 c := v_1.AuxInt 7637 if !(umagicOK(16, c) && config.RegSize == 8) { 7638 break 7639 } 7640 v.reset(OpTrunc64to16) 7641 v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) 7642 v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) 7643 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7644 v2.AuxInt = int64(1<<16 + umagic(16, c).m) 7645 v1.AddArg(v2) 7646 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64) 7647 v3.AddArg(x) 7648 v1.AddArg(v3) 7649 v0.AddArg(v1) 7650 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7651 v4.AuxInt = 16 + umagic(16, c).s 7652 v0.AddArg(v4) 7653 v.AddArg(v0) 7654 return true 7655 } 7656 // match: (Div16u x (Const16 [c])) 7657 // cond: umagicOK(16, c) && config.RegSize == 4 && umagic(16,c).m&1 == 0 7658 // 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]))) 7659 for { 7660 _ = v.Args[1] 7661 x := v.Args[0] 7662 v_1 := v.Args[1] 7663 if v_1.Op != OpConst16 { 7664 break 7665 } 7666 c := v_1.AuxInt 7667 if !(umagicOK(16, c) && config.RegSize == 4 && umagic(16, c).m&1 == 0) { 7668 break 7669 } 7670 v.reset(OpTrunc32to16) 7671 v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) 7672 v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) 7673 v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 7674 v2.AuxInt = int64(1<<15 + umagic(16, c).m/2) 7675 v1.AddArg(v2) 7676 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 7677 v3.AddArg(x) 7678 v1.AddArg(v3) 7679 v0.AddArg(v1) 7680 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7681 v4.AuxInt = 16 + umagic(16, c).s - 1 7682 v0.AddArg(v4) 7683 v.AddArg(v0) 7684 return true 7685 } 7686 // match: (Div16u x (Const16 [c])) 7687 // cond: umagicOK(16, c) && config.RegSize == 4 && c&1 == 0 7688 // 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]))) 7689 for { 7690 _ = v.Args[1] 7691 x := v.Args[0] 7692 v_1 := v.Args[1] 7693 if v_1.Op != OpConst16 { 7694 break 7695 } 7696 c := v_1.AuxInt 7697 if !(umagicOK(16, c) && config.RegSize == 4 && c&1 == 0) { 7698 break 7699 } 7700 v.reset(OpTrunc32to16) 7701 v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) 7702 v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) 7703 v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 7704 v2.AuxInt = int64(1<<15 + (umagic(16, c).m+1)/2) 7705 v1.AddArg(v2) 7706 v3 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) 7707 v4 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 7708 v4.AddArg(x) 7709 v3.AddArg(v4) 7710 v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7711 v5.AuxInt = 1 7712 v3.AddArg(v5) 7713 v1.AddArg(v3) 7714 v0.AddArg(v1) 7715 v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7716 v6.AuxInt = 16 + umagic(16, c).s - 2 7717 v0.AddArg(v6) 7718 v.AddArg(v0) 7719 return true 7720 } 7721 // match: (Div16u x (Const16 [c])) 7722 // cond: umagicOK(16, c) && config.RegSize == 4 && config.useAvg 7723 // 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]))) 7724 for { 7725 _ = v.Args[1] 7726 x := v.Args[0] 7727 v_1 := v.Args[1] 7728 if v_1.Op != OpConst16 { 7729 break 7730 } 7731 c := v_1.AuxInt 7732 if !(umagicOK(16, c) && config.RegSize == 4 && config.useAvg) { 7733 break 7734 } 7735 v.reset(OpTrunc32to16) 7736 v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) 7737 v1 := b.NewValue0(v.Pos, OpAvg32u, typ.UInt32) 7738 v2 := b.NewValue0(v.Pos, OpLsh32x64, typ.UInt32) 7739 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 7740 v3.AddArg(x) 7741 v2.AddArg(v3) 7742 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7743 v4.AuxInt = 16 7744 v2.AddArg(v4) 7745 v1.AddArg(v2) 7746 v5 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) 7747 v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 7748 v6.AuxInt = int64(umagic(16, c).m) 7749 v5.AddArg(v6) 7750 v7 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 7751 v7.AddArg(x) 7752 v5.AddArg(v7) 7753 v1.AddArg(v5) 7754 v0.AddArg(v1) 7755 v8 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7756 v8.AuxInt = 16 + umagic(16, c).s - 1 7757 v0.AddArg(v8) 7758 v.AddArg(v0) 7759 return true 7760 } 7761 return false 7762 } 7763 func rewriteValuegeneric_OpDiv32_0(v *Value) bool { 7764 b := v.Block 7765 _ = b 7766 config := b.Func.Config 7767 _ = config 7768 typ := &b.Func.Config.Types 7769 _ = typ 7770 // match: (Div32 (Const32 [c]) (Const32 [d])) 7771 // cond: d != 0 7772 // result: (Const32 [int64(int32(c)/int32(d))]) 7773 for { 7774 _ = v.Args[1] 7775 v_0 := v.Args[0] 7776 if v_0.Op != OpConst32 { 7777 break 7778 } 7779 c := v_0.AuxInt 7780 v_1 := v.Args[1] 7781 if v_1.Op != OpConst32 { 7782 break 7783 } 7784 d := v_1.AuxInt 7785 if !(d != 0) { 7786 break 7787 } 7788 v.reset(OpConst32) 7789 v.AuxInt = int64(int32(c) / int32(d)) 7790 return true 7791 } 7792 // match: (Div32 n (Const32 [c])) 7793 // cond: isNonNegative(n) && isPowerOfTwo(c&0xffffffff) 7794 // result: (Rsh32Ux64 n (Const64 <typ.UInt64> [log2(c&0xffffffff)])) 7795 for { 7796 _ = v.Args[1] 7797 n := v.Args[0] 7798 v_1 := v.Args[1] 7799 if v_1.Op != OpConst32 { 7800 break 7801 } 7802 c := v_1.AuxInt 7803 if !(isNonNegative(n) && isPowerOfTwo(c&0xffffffff)) { 7804 break 7805 } 7806 v.reset(OpRsh32Ux64) 7807 v.AddArg(n) 7808 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7809 v0.AuxInt = log2(c & 0xffffffff) 7810 v.AddArg(v0) 7811 return true 7812 } 7813 // match: (Div32 <t> n (Const32 [c])) 7814 // cond: c < 0 && c != -1<<31 7815 // result: (Neg32 (Div32 <t> n (Const32 <t> [-c]))) 7816 for { 7817 t := v.Type 7818 _ = v.Args[1] 7819 n := v.Args[0] 7820 v_1 := v.Args[1] 7821 if v_1.Op != OpConst32 { 7822 break 7823 } 7824 c := v_1.AuxInt 7825 if !(c < 0 && c != -1<<31) { 7826 break 7827 } 7828 v.reset(OpNeg32) 7829 v0 := b.NewValue0(v.Pos, OpDiv32, t) 7830 v0.AddArg(n) 7831 v1 := b.NewValue0(v.Pos, OpConst32, t) 7832 v1.AuxInt = -c 7833 v0.AddArg(v1) 7834 v.AddArg(v0) 7835 return true 7836 } 7837 // match: (Div32 <t> x (Const32 [-1<<31])) 7838 // cond: 7839 // result: (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <typ.UInt64> [31])) 7840 for { 7841 t := v.Type 7842 _ = v.Args[1] 7843 x := v.Args[0] 7844 v_1 := v.Args[1] 7845 if v_1.Op != OpConst32 { 7846 break 7847 } 7848 if v_1.AuxInt != -1<<31 { 7849 break 7850 } 7851 v.reset(OpRsh32Ux64) 7852 v0 := b.NewValue0(v.Pos, OpAnd32, t) 7853 v0.AddArg(x) 7854 v1 := b.NewValue0(v.Pos, OpNeg32, t) 7855 v1.AddArg(x) 7856 v0.AddArg(v1) 7857 v.AddArg(v0) 7858 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7859 v2.AuxInt = 31 7860 v.AddArg(v2) 7861 return true 7862 } 7863 // match: (Div32 <t> n (Const32 [c])) 7864 // cond: isPowerOfTwo(c) 7865 // 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)])) 7866 for { 7867 t := v.Type 7868 _ = v.Args[1] 7869 n := v.Args[0] 7870 v_1 := v.Args[1] 7871 if v_1.Op != OpConst32 { 7872 break 7873 } 7874 c := v_1.AuxInt 7875 if !(isPowerOfTwo(c)) { 7876 break 7877 } 7878 v.reset(OpRsh32x64) 7879 v0 := b.NewValue0(v.Pos, OpAdd32, t) 7880 v0.AddArg(n) 7881 v1 := b.NewValue0(v.Pos, OpRsh32Ux64, t) 7882 v2 := b.NewValue0(v.Pos, OpRsh32x64, t) 7883 v2.AddArg(n) 7884 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7885 v3.AuxInt = 31 7886 v2.AddArg(v3) 7887 v1.AddArg(v2) 7888 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7889 v4.AuxInt = 32 - log2(c) 7890 v1.AddArg(v4) 7891 v0.AddArg(v1) 7892 v.AddArg(v0) 7893 v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7894 v5.AuxInt = log2(c) 7895 v.AddArg(v5) 7896 return true 7897 } 7898 // match: (Div32 <t> x (Const32 [c])) 7899 // cond: smagicOK(32,c) && config.RegSize == 8 7900 // 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]))) 7901 for { 7902 t := v.Type 7903 _ = v.Args[1] 7904 x := v.Args[0] 7905 v_1 := v.Args[1] 7906 if v_1.Op != OpConst32 { 7907 break 7908 } 7909 c := v_1.AuxInt 7910 if !(smagicOK(32, c) && config.RegSize == 8) { 7911 break 7912 } 7913 v.reset(OpSub32) 7914 v.Type = t 7915 v0 := b.NewValue0(v.Pos, OpRsh64x64, t) 7916 v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) 7917 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7918 v2.AuxInt = int64(smagic(32, c).m) 7919 v1.AddArg(v2) 7920 v3 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64) 7921 v3.AddArg(x) 7922 v1.AddArg(v3) 7923 v0.AddArg(v1) 7924 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7925 v4.AuxInt = 32 + smagic(32, c).s 7926 v0.AddArg(v4) 7927 v.AddArg(v0) 7928 v5 := b.NewValue0(v.Pos, OpRsh64x64, t) 7929 v6 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64) 7930 v6.AddArg(x) 7931 v5.AddArg(v6) 7932 v7 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7933 v7.AuxInt = 63 7934 v5.AddArg(v7) 7935 v.AddArg(v5) 7936 return true 7937 } 7938 // match: (Div32 <t> x (Const32 [c])) 7939 // cond: smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 == 0 && config.useHmul 7940 // 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]))) 7941 for { 7942 t := v.Type 7943 _ = v.Args[1] 7944 x := v.Args[0] 7945 v_1 := v.Args[1] 7946 if v_1.Op != OpConst32 { 7947 break 7948 } 7949 c := v_1.AuxInt 7950 if !(smagicOK(32, c) && config.RegSize == 4 && smagic(32, c).m&1 == 0 && config.useHmul) { 7951 break 7952 } 7953 v.reset(OpSub32) 7954 v.Type = t 7955 v0 := b.NewValue0(v.Pos, OpRsh32x64, t) 7956 v1 := b.NewValue0(v.Pos, OpHmul32, t) 7957 v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 7958 v2.AuxInt = int64(int32(smagic(32, c).m / 2)) 7959 v1.AddArg(v2) 7960 v1.AddArg(x) 7961 v0.AddArg(v1) 7962 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7963 v3.AuxInt = smagic(32, c).s - 1 7964 v0.AddArg(v3) 7965 v.AddArg(v0) 7966 v4 := b.NewValue0(v.Pos, OpRsh32x64, t) 7967 v4.AddArg(x) 7968 v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 7969 v5.AuxInt = 31 7970 v4.AddArg(v5) 7971 v.AddArg(v4) 7972 return true 7973 } 7974 // match: (Div32 <t> x (Const32 [c])) 7975 // cond: smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 != 0 && config.useHmul 7976 // 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]))) 7977 for { 7978 t := v.Type 7979 _ = v.Args[1] 7980 x := v.Args[0] 7981 v_1 := v.Args[1] 7982 if v_1.Op != OpConst32 { 7983 break 7984 } 7985 c := v_1.AuxInt 7986 if !(smagicOK(32, c) && config.RegSize == 4 && smagic(32, c).m&1 != 0 && config.useHmul) { 7987 break 7988 } 7989 v.reset(OpSub32) 7990 v.Type = t 7991 v0 := b.NewValue0(v.Pos, OpRsh32x64, t) 7992 v1 := b.NewValue0(v.Pos, OpAdd32, t) 7993 v2 := b.NewValue0(v.Pos, OpHmul32, t) 7994 v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 7995 v3.AuxInt = int64(int32(smagic(32, c).m)) 7996 v2.AddArg(v3) 7997 v2.AddArg(x) 7998 v1.AddArg(v2) 7999 v1.AddArg(x) 8000 v0.AddArg(v1) 8001 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8002 v4.AuxInt = smagic(32, c).s 8003 v0.AddArg(v4) 8004 v.AddArg(v0) 8005 v5 := b.NewValue0(v.Pos, OpRsh32x64, t) 8006 v5.AddArg(x) 8007 v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8008 v6.AuxInt = 31 8009 v5.AddArg(v6) 8010 v.AddArg(v5) 8011 return true 8012 } 8013 return false 8014 } 8015 func rewriteValuegeneric_OpDiv32F_0(v *Value) bool { 8016 b := v.Block 8017 _ = b 8018 // match: (Div32F (Const32F [c]) (Const32F [d])) 8019 // cond: 8020 // result: (Const32F [auxFrom32F(auxTo32F(c) / auxTo32F(d))]) 8021 for { 8022 _ = v.Args[1] 8023 v_0 := v.Args[0] 8024 if v_0.Op != OpConst32F { 8025 break 8026 } 8027 c := v_0.AuxInt 8028 v_1 := v.Args[1] 8029 if v_1.Op != OpConst32F { 8030 break 8031 } 8032 d := v_1.AuxInt 8033 v.reset(OpConst32F) 8034 v.AuxInt = auxFrom32F(auxTo32F(c) / auxTo32F(d)) 8035 return true 8036 } 8037 // match: (Div32F x (Const32F <t> [c])) 8038 // cond: reciprocalExact32(auxTo32F(c)) 8039 // result: (Mul32F x (Const32F <t> [auxFrom32F(1/auxTo32F(c))])) 8040 for { 8041 _ = v.Args[1] 8042 x := v.Args[0] 8043 v_1 := v.Args[1] 8044 if v_1.Op != OpConst32F { 8045 break 8046 } 8047 t := v_1.Type 8048 c := v_1.AuxInt 8049 if !(reciprocalExact32(auxTo32F(c))) { 8050 break 8051 } 8052 v.reset(OpMul32F) 8053 v.AddArg(x) 8054 v0 := b.NewValue0(v.Pos, OpConst32F, t) 8055 v0.AuxInt = auxFrom32F(1 / auxTo32F(c)) 8056 v.AddArg(v0) 8057 return true 8058 } 8059 return false 8060 } 8061 func rewriteValuegeneric_OpDiv32u_0(v *Value) bool { 8062 b := v.Block 8063 _ = b 8064 config := b.Func.Config 8065 _ = config 8066 typ := &b.Func.Config.Types 8067 _ = typ 8068 // match: (Div32u (Const32 [c]) (Const32 [d])) 8069 // cond: d != 0 8070 // result: (Const32 [int64(int32(uint32(c)/uint32(d)))]) 8071 for { 8072 _ = v.Args[1] 8073 v_0 := v.Args[0] 8074 if v_0.Op != OpConst32 { 8075 break 8076 } 8077 c := v_0.AuxInt 8078 v_1 := v.Args[1] 8079 if v_1.Op != OpConst32 { 8080 break 8081 } 8082 d := v_1.AuxInt 8083 if !(d != 0) { 8084 break 8085 } 8086 v.reset(OpConst32) 8087 v.AuxInt = int64(int32(uint32(c) / uint32(d))) 8088 return true 8089 } 8090 // match: (Div32u n (Const32 [c])) 8091 // cond: isPowerOfTwo(c&0xffffffff) 8092 // result: (Rsh32Ux64 n (Const64 <typ.UInt64> [log2(c&0xffffffff)])) 8093 for { 8094 _ = v.Args[1] 8095 n := v.Args[0] 8096 v_1 := v.Args[1] 8097 if v_1.Op != OpConst32 { 8098 break 8099 } 8100 c := v_1.AuxInt 8101 if !(isPowerOfTwo(c & 0xffffffff)) { 8102 break 8103 } 8104 v.reset(OpRsh32Ux64) 8105 v.AddArg(n) 8106 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8107 v0.AuxInt = log2(c & 0xffffffff) 8108 v.AddArg(v0) 8109 return true 8110 } 8111 // match: (Div32u x (Const32 [c])) 8112 // cond: umagicOK(32, c) && config.RegSize == 4 && umagic(32,c).m&1 == 0 && config.useHmul 8113 // 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])) 8114 for { 8115 _ = v.Args[1] 8116 x := v.Args[0] 8117 v_1 := v.Args[1] 8118 if v_1.Op != OpConst32 { 8119 break 8120 } 8121 c := v_1.AuxInt 8122 if !(umagicOK(32, c) && config.RegSize == 4 && umagic(32, c).m&1 == 0 && config.useHmul) { 8123 break 8124 } 8125 v.reset(OpRsh32Ux64) 8126 v.Type = typ.UInt32 8127 v0 := b.NewValue0(v.Pos, OpHmul32u, typ.UInt32) 8128 v1 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 8129 v1.AuxInt = int64(int32(1<<31 + umagic(32, c).m/2)) 8130 v0.AddArg(v1) 8131 v0.AddArg(x) 8132 v.AddArg(v0) 8133 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8134 v2.AuxInt = umagic(32, c).s - 1 8135 v.AddArg(v2) 8136 return true 8137 } 8138 // match: (Div32u x (Const32 [c])) 8139 // cond: umagicOK(32, c) && config.RegSize == 4 && c&1 == 0 && config.useHmul 8140 // 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])) 8141 for { 8142 _ = v.Args[1] 8143 x := v.Args[0] 8144 v_1 := v.Args[1] 8145 if v_1.Op != OpConst32 { 8146 break 8147 } 8148 c := v_1.AuxInt 8149 if !(umagicOK(32, c) && config.RegSize == 4 && c&1 == 0 && config.useHmul) { 8150 break 8151 } 8152 v.reset(OpRsh32Ux64) 8153 v.Type = typ.UInt32 8154 v0 := b.NewValue0(v.Pos, OpHmul32u, typ.UInt32) 8155 v1 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 8156 v1.AuxInt = int64(int32(1<<31 + (umagic(32, c).m+1)/2)) 8157 v0.AddArg(v1) 8158 v2 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) 8159 v2.AddArg(x) 8160 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8161 v3.AuxInt = 1 8162 v2.AddArg(v3) 8163 v0.AddArg(v2) 8164 v.AddArg(v0) 8165 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8166 v4.AuxInt = umagic(32, c).s - 2 8167 v.AddArg(v4) 8168 return true 8169 } 8170 // match: (Div32u x (Const32 [c])) 8171 // cond: umagicOK(32, c) && config.RegSize == 4 && config.useAvg && config.useHmul 8172 // 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])) 8173 for { 8174 _ = v.Args[1] 8175 x := v.Args[0] 8176 v_1 := v.Args[1] 8177 if v_1.Op != OpConst32 { 8178 break 8179 } 8180 c := v_1.AuxInt 8181 if !(umagicOK(32, c) && config.RegSize == 4 && config.useAvg && config.useHmul) { 8182 break 8183 } 8184 v.reset(OpRsh32Ux64) 8185 v.Type = typ.UInt32 8186 v0 := b.NewValue0(v.Pos, OpAvg32u, typ.UInt32) 8187 v0.AddArg(x) 8188 v1 := b.NewValue0(v.Pos, OpHmul32u, typ.UInt32) 8189 v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 8190 v2.AuxInt = int64(int32(umagic(32, c).m)) 8191 v1.AddArg(v2) 8192 v1.AddArg(x) 8193 v0.AddArg(v1) 8194 v.AddArg(v0) 8195 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8196 v3.AuxInt = umagic(32, c).s - 1 8197 v.AddArg(v3) 8198 return true 8199 } 8200 // match: (Div32u x (Const32 [c])) 8201 // cond: umagicOK(32, c) && config.RegSize == 8 && umagic(32,c).m&1 == 0 8202 // 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]))) 8203 for { 8204 _ = v.Args[1] 8205 x := v.Args[0] 8206 v_1 := v.Args[1] 8207 if v_1.Op != OpConst32 { 8208 break 8209 } 8210 c := v_1.AuxInt 8211 if !(umagicOK(32, c) && config.RegSize == 8 && umagic(32, c).m&1 == 0) { 8212 break 8213 } 8214 v.reset(OpTrunc64to32) 8215 v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) 8216 v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) 8217 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8218 v2.AuxInt = int64(1<<31 + umagic(32, c).m/2) 8219 v1.AddArg(v2) 8220 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64) 8221 v3.AddArg(x) 8222 v1.AddArg(v3) 8223 v0.AddArg(v1) 8224 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8225 v4.AuxInt = 32 + umagic(32, c).s - 1 8226 v0.AddArg(v4) 8227 v.AddArg(v0) 8228 return true 8229 } 8230 // match: (Div32u x (Const32 [c])) 8231 // cond: umagicOK(32, c) && config.RegSize == 8 && c&1 == 0 8232 // 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]))) 8233 for { 8234 _ = v.Args[1] 8235 x := v.Args[0] 8236 v_1 := v.Args[1] 8237 if v_1.Op != OpConst32 { 8238 break 8239 } 8240 c := v_1.AuxInt 8241 if !(umagicOK(32, c) && config.RegSize == 8 && c&1 == 0) { 8242 break 8243 } 8244 v.reset(OpTrunc64to32) 8245 v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) 8246 v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) 8247 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8248 v2.AuxInt = int64(1<<31 + (umagic(32, c).m+1)/2) 8249 v1.AddArg(v2) 8250 v3 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) 8251 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64) 8252 v4.AddArg(x) 8253 v3.AddArg(v4) 8254 v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8255 v5.AuxInt = 1 8256 v3.AddArg(v5) 8257 v1.AddArg(v3) 8258 v0.AddArg(v1) 8259 v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8260 v6.AuxInt = 32 + umagic(32, c).s - 2 8261 v0.AddArg(v6) 8262 v.AddArg(v0) 8263 return true 8264 } 8265 // match: (Div32u x (Const32 [c])) 8266 // cond: umagicOK(32, c) && config.RegSize == 8 && config.useAvg 8267 // 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]))) 8268 for { 8269 _ = v.Args[1] 8270 x := v.Args[0] 8271 v_1 := v.Args[1] 8272 if v_1.Op != OpConst32 { 8273 break 8274 } 8275 c := v_1.AuxInt 8276 if !(umagicOK(32, c) && config.RegSize == 8 && config.useAvg) { 8277 break 8278 } 8279 v.reset(OpTrunc64to32) 8280 v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) 8281 v1 := b.NewValue0(v.Pos, OpAvg64u, typ.UInt64) 8282 v2 := b.NewValue0(v.Pos, OpLsh64x64, typ.UInt64) 8283 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64) 8284 v3.AddArg(x) 8285 v2.AddArg(v3) 8286 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8287 v4.AuxInt = 32 8288 v2.AddArg(v4) 8289 v1.AddArg(v2) 8290 v5 := b.NewValue0(v.Pos, OpMul64, typ.UInt64) 8291 v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt32) 8292 v6.AuxInt = int64(umagic(32, c).m) 8293 v5.AddArg(v6) 8294 v7 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64) 8295 v7.AddArg(x) 8296 v5.AddArg(v7) 8297 v1.AddArg(v5) 8298 v0.AddArg(v1) 8299 v8 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8300 v8.AuxInt = 32 + umagic(32, c).s - 1 8301 v0.AddArg(v8) 8302 v.AddArg(v0) 8303 return true 8304 } 8305 return false 8306 } 8307 func rewriteValuegeneric_OpDiv64_0(v *Value) bool { 8308 b := v.Block 8309 _ = b 8310 config := b.Func.Config 8311 _ = config 8312 typ := &b.Func.Config.Types 8313 _ = typ 8314 // match: (Div64 (Const64 [c]) (Const64 [d])) 8315 // cond: d != 0 8316 // result: (Const64 [c/d]) 8317 for { 8318 _ = v.Args[1] 8319 v_0 := v.Args[0] 8320 if v_0.Op != OpConst64 { 8321 break 8322 } 8323 c := v_0.AuxInt 8324 v_1 := v.Args[1] 8325 if v_1.Op != OpConst64 { 8326 break 8327 } 8328 d := v_1.AuxInt 8329 if !(d != 0) { 8330 break 8331 } 8332 v.reset(OpConst64) 8333 v.AuxInt = c / d 8334 return true 8335 } 8336 // match: (Div64 n (Const64 [c])) 8337 // cond: isNonNegative(n) && isPowerOfTwo(c) 8338 // result: (Rsh64Ux64 n (Const64 <typ.UInt64> [log2(c)])) 8339 for { 8340 _ = v.Args[1] 8341 n := v.Args[0] 8342 v_1 := v.Args[1] 8343 if v_1.Op != OpConst64 { 8344 break 8345 } 8346 c := v_1.AuxInt 8347 if !(isNonNegative(n) && isPowerOfTwo(c)) { 8348 break 8349 } 8350 v.reset(OpRsh64Ux64) 8351 v.AddArg(n) 8352 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8353 v0.AuxInt = log2(c) 8354 v.AddArg(v0) 8355 return true 8356 } 8357 // match: (Div64 n (Const64 [-1<<63])) 8358 // cond: isNonNegative(n) 8359 // result: (Const64 [0]) 8360 for { 8361 _ = v.Args[1] 8362 n := v.Args[0] 8363 v_1 := v.Args[1] 8364 if v_1.Op != OpConst64 { 8365 break 8366 } 8367 if v_1.AuxInt != -1<<63 { 8368 break 8369 } 8370 if !(isNonNegative(n)) { 8371 break 8372 } 8373 v.reset(OpConst64) 8374 v.AuxInt = 0 8375 return true 8376 } 8377 // match: (Div64 <t> n (Const64 [c])) 8378 // cond: c < 0 && c != -1<<63 8379 // result: (Neg64 (Div64 <t> n (Const64 <t> [-c]))) 8380 for { 8381 t := v.Type 8382 _ = v.Args[1] 8383 n := v.Args[0] 8384 v_1 := v.Args[1] 8385 if v_1.Op != OpConst64 { 8386 break 8387 } 8388 c := v_1.AuxInt 8389 if !(c < 0 && c != -1<<63) { 8390 break 8391 } 8392 v.reset(OpNeg64) 8393 v0 := b.NewValue0(v.Pos, OpDiv64, t) 8394 v0.AddArg(n) 8395 v1 := b.NewValue0(v.Pos, OpConst64, t) 8396 v1.AuxInt = -c 8397 v0.AddArg(v1) 8398 v.AddArg(v0) 8399 return true 8400 } 8401 // match: (Div64 <t> x (Const64 [-1<<63])) 8402 // cond: 8403 // result: (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <typ.UInt64> [63])) 8404 for { 8405 t := v.Type 8406 _ = v.Args[1] 8407 x := v.Args[0] 8408 v_1 := v.Args[1] 8409 if v_1.Op != OpConst64 { 8410 break 8411 } 8412 if v_1.AuxInt != -1<<63 { 8413 break 8414 } 8415 v.reset(OpRsh64Ux64) 8416 v0 := b.NewValue0(v.Pos, OpAnd64, t) 8417 v0.AddArg(x) 8418 v1 := b.NewValue0(v.Pos, OpNeg64, t) 8419 v1.AddArg(x) 8420 v0.AddArg(v1) 8421 v.AddArg(v0) 8422 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8423 v2.AuxInt = 63 8424 v.AddArg(v2) 8425 return true 8426 } 8427 // match: (Div64 <t> n (Const64 [c])) 8428 // cond: isPowerOfTwo(c) 8429 // 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)])) 8430 for { 8431 t := v.Type 8432 _ = v.Args[1] 8433 n := v.Args[0] 8434 v_1 := v.Args[1] 8435 if v_1.Op != OpConst64 { 8436 break 8437 } 8438 c := v_1.AuxInt 8439 if !(isPowerOfTwo(c)) { 8440 break 8441 } 8442 v.reset(OpRsh64x64) 8443 v0 := b.NewValue0(v.Pos, OpAdd64, t) 8444 v0.AddArg(n) 8445 v1 := b.NewValue0(v.Pos, OpRsh64Ux64, t) 8446 v2 := b.NewValue0(v.Pos, OpRsh64x64, t) 8447 v2.AddArg(n) 8448 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8449 v3.AuxInt = 63 8450 v2.AddArg(v3) 8451 v1.AddArg(v2) 8452 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8453 v4.AuxInt = 64 - log2(c) 8454 v1.AddArg(v4) 8455 v0.AddArg(v1) 8456 v.AddArg(v0) 8457 v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8458 v5.AuxInt = log2(c) 8459 v.AddArg(v5) 8460 return true 8461 } 8462 // match: (Div64 <t> x (Const64 [c])) 8463 // cond: smagicOK(64,c) && smagic(64,c).m&1 == 0 && config.useHmul 8464 // 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]))) 8465 for { 8466 t := v.Type 8467 _ = v.Args[1] 8468 x := v.Args[0] 8469 v_1 := v.Args[1] 8470 if v_1.Op != OpConst64 { 8471 break 8472 } 8473 c := v_1.AuxInt 8474 if !(smagicOK(64, c) && smagic(64, c).m&1 == 0 && config.useHmul) { 8475 break 8476 } 8477 v.reset(OpSub64) 8478 v.Type = t 8479 v0 := b.NewValue0(v.Pos, OpRsh64x64, t) 8480 v1 := b.NewValue0(v.Pos, OpHmul64, t) 8481 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8482 v2.AuxInt = int64(smagic(64, c).m / 2) 8483 v1.AddArg(v2) 8484 v1.AddArg(x) 8485 v0.AddArg(v1) 8486 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8487 v3.AuxInt = smagic(64, c).s - 1 8488 v0.AddArg(v3) 8489 v.AddArg(v0) 8490 v4 := b.NewValue0(v.Pos, OpRsh64x64, t) 8491 v4.AddArg(x) 8492 v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8493 v5.AuxInt = 63 8494 v4.AddArg(v5) 8495 v.AddArg(v4) 8496 return true 8497 } 8498 // match: (Div64 <t> x (Const64 [c])) 8499 // cond: smagicOK(64,c) && smagic(64,c).m&1 != 0 && config.useHmul 8500 // 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]))) 8501 for { 8502 t := v.Type 8503 _ = v.Args[1] 8504 x := v.Args[0] 8505 v_1 := v.Args[1] 8506 if v_1.Op != OpConst64 { 8507 break 8508 } 8509 c := v_1.AuxInt 8510 if !(smagicOK(64, c) && smagic(64, c).m&1 != 0 && config.useHmul) { 8511 break 8512 } 8513 v.reset(OpSub64) 8514 v.Type = t 8515 v0 := b.NewValue0(v.Pos, OpRsh64x64, t) 8516 v1 := b.NewValue0(v.Pos, OpAdd64, t) 8517 v2 := b.NewValue0(v.Pos, OpHmul64, t) 8518 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8519 v3.AuxInt = int64(smagic(64, c).m) 8520 v2.AddArg(v3) 8521 v2.AddArg(x) 8522 v1.AddArg(v2) 8523 v1.AddArg(x) 8524 v0.AddArg(v1) 8525 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8526 v4.AuxInt = smagic(64, c).s 8527 v0.AddArg(v4) 8528 v.AddArg(v0) 8529 v5 := b.NewValue0(v.Pos, OpRsh64x64, t) 8530 v5.AddArg(x) 8531 v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8532 v6.AuxInt = 63 8533 v5.AddArg(v6) 8534 v.AddArg(v5) 8535 return true 8536 } 8537 return false 8538 } 8539 func rewriteValuegeneric_OpDiv64F_0(v *Value) bool { 8540 b := v.Block 8541 _ = b 8542 // match: (Div64F (Const64F [c]) (Const64F [d])) 8543 // cond: 8544 // result: (Const64F [auxFrom64F(auxTo64F(c) / auxTo64F(d))]) 8545 for { 8546 _ = v.Args[1] 8547 v_0 := v.Args[0] 8548 if v_0.Op != OpConst64F { 8549 break 8550 } 8551 c := v_0.AuxInt 8552 v_1 := v.Args[1] 8553 if v_1.Op != OpConst64F { 8554 break 8555 } 8556 d := v_1.AuxInt 8557 v.reset(OpConst64F) 8558 v.AuxInt = auxFrom64F(auxTo64F(c) / auxTo64F(d)) 8559 return true 8560 } 8561 // match: (Div64F x (Const64F <t> [c])) 8562 // cond: reciprocalExact64(auxTo64F(c)) 8563 // result: (Mul64F x (Const64F <t> [auxFrom64F(1/auxTo64F(c))])) 8564 for { 8565 _ = v.Args[1] 8566 x := v.Args[0] 8567 v_1 := v.Args[1] 8568 if v_1.Op != OpConst64F { 8569 break 8570 } 8571 t := v_1.Type 8572 c := v_1.AuxInt 8573 if !(reciprocalExact64(auxTo64F(c))) { 8574 break 8575 } 8576 v.reset(OpMul64F) 8577 v.AddArg(x) 8578 v0 := b.NewValue0(v.Pos, OpConst64F, t) 8579 v0.AuxInt = auxFrom64F(1 / auxTo64F(c)) 8580 v.AddArg(v0) 8581 return true 8582 } 8583 return false 8584 } 8585 func rewriteValuegeneric_OpDiv64u_0(v *Value) bool { 8586 b := v.Block 8587 _ = b 8588 config := b.Func.Config 8589 _ = config 8590 typ := &b.Func.Config.Types 8591 _ = typ 8592 // match: (Div64u (Const64 [c]) (Const64 [d])) 8593 // cond: d != 0 8594 // result: (Const64 [int64(uint64(c)/uint64(d))]) 8595 for { 8596 _ = v.Args[1] 8597 v_0 := v.Args[0] 8598 if v_0.Op != OpConst64 { 8599 break 8600 } 8601 c := v_0.AuxInt 8602 v_1 := v.Args[1] 8603 if v_1.Op != OpConst64 { 8604 break 8605 } 8606 d := v_1.AuxInt 8607 if !(d != 0) { 8608 break 8609 } 8610 v.reset(OpConst64) 8611 v.AuxInt = int64(uint64(c) / uint64(d)) 8612 return true 8613 } 8614 // match: (Div64u n (Const64 [c])) 8615 // cond: isPowerOfTwo(c) 8616 // result: (Rsh64Ux64 n (Const64 <typ.UInt64> [log2(c)])) 8617 for { 8618 _ = v.Args[1] 8619 n := v.Args[0] 8620 v_1 := v.Args[1] 8621 if v_1.Op != OpConst64 { 8622 break 8623 } 8624 c := v_1.AuxInt 8625 if !(isPowerOfTwo(c)) { 8626 break 8627 } 8628 v.reset(OpRsh64Ux64) 8629 v.AddArg(n) 8630 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8631 v0.AuxInt = log2(c) 8632 v.AddArg(v0) 8633 return true 8634 } 8635 // match: (Div64u n (Const64 [-1<<63])) 8636 // cond: 8637 // result: (Rsh64Ux64 n (Const64 <typ.UInt64> [63])) 8638 for { 8639 _ = v.Args[1] 8640 n := v.Args[0] 8641 v_1 := v.Args[1] 8642 if v_1.Op != OpConst64 { 8643 break 8644 } 8645 if v_1.AuxInt != -1<<63 { 8646 break 8647 } 8648 v.reset(OpRsh64Ux64) 8649 v.AddArg(n) 8650 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8651 v0.AuxInt = 63 8652 v.AddArg(v0) 8653 return true 8654 } 8655 // match: (Div64u x (Const64 [c])) 8656 // cond: umagicOK(64, c) && config.RegSize == 8 && umagic(64,c).m&1 == 0 && config.useHmul 8657 // 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])) 8658 for { 8659 _ = v.Args[1] 8660 x := v.Args[0] 8661 v_1 := v.Args[1] 8662 if v_1.Op != OpConst64 { 8663 break 8664 } 8665 c := v_1.AuxInt 8666 if !(umagicOK(64, c) && config.RegSize == 8 && umagic(64, c).m&1 == 0 && config.useHmul) { 8667 break 8668 } 8669 v.reset(OpRsh64Ux64) 8670 v.Type = typ.UInt64 8671 v0 := b.NewValue0(v.Pos, OpHmul64u, typ.UInt64) 8672 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8673 v1.AuxInt = int64(1<<63 + umagic(64, c).m/2) 8674 v0.AddArg(v1) 8675 v0.AddArg(x) 8676 v.AddArg(v0) 8677 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8678 v2.AuxInt = umagic(64, c).s - 1 8679 v.AddArg(v2) 8680 return true 8681 } 8682 // match: (Div64u x (Const64 [c])) 8683 // cond: umagicOK(64, c) && config.RegSize == 8 && c&1 == 0 && config.useHmul 8684 // 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])) 8685 for { 8686 _ = v.Args[1] 8687 x := v.Args[0] 8688 v_1 := v.Args[1] 8689 if v_1.Op != OpConst64 { 8690 break 8691 } 8692 c := v_1.AuxInt 8693 if !(umagicOK(64, c) && config.RegSize == 8 && c&1 == 0 && config.useHmul) { 8694 break 8695 } 8696 v.reset(OpRsh64Ux64) 8697 v.Type = typ.UInt64 8698 v0 := b.NewValue0(v.Pos, OpHmul64u, typ.UInt64) 8699 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8700 v1.AuxInt = int64(1<<63 + (umagic(64, c).m+1)/2) 8701 v0.AddArg(v1) 8702 v2 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64) 8703 v2.AddArg(x) 8704 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8705 v3.AuxInt = 1 8706 v2.AddArg(v3) 8707 v0.AddArg(v2) 8708 v.AddArg(v0) 8709 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8710 v4.AuxInt = umagic(64, c).s - 2 8711 v.AddArg(v4) 8712 return true 8713 } 8714 // match: (Div64u x (Const64 [c])) 8715 // cond: umagicOK(64, c) && config.RegSize == 8 && config.useAvg && config.useHmul 8716 // 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])) 8717 for { 8718 _ = v.Args[1] 8719 x := v.Args[0] 8720 v_1 := v.Args[1] 8721 if v_1.Op != OpConst64 { 8722 break 8723 } 8724 c := v_1.AuxInt 8725 if !(umagicOK(64, c) && config.RegSize == 8 && config.useAvg && config.useHmul) { 8726 break 8727 } 8728 v.reset(OpRsh64Ux64) 8729 v.Type = typ.UInt64 8730 v0 := b.NewValue0(v.Pos, OpAvg64u, typ.UInt64) 8731 v0.AddArg(x) 8732 v1 := b.NewValue0(v.Pos, OpHmul64u, typ.UInt64) 8733 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8734 v2.AuxInt = int64(umagic(64, c).m) 8735 v1.AddArg(v2) 8736 v1.AddArg(x) 8737 v0.AddArg(v1) 8738 v.AddArg(v0) 8739 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8740 v3.AuxInt = umagic(64, c).s - 1 8741 v.AddArg(v3) 8742 return true 8743 } 8744 return false 8745 } 8746 func rewriteValuegeneric_OpDiv8_0(v *Value) bool { 8747 b := v.Block 8748 _ = b 8749 typ := &b.Func.Config.Types 8750 _ = typ 8751 // match: (Div8 (Const8 [c]) (Const8 [d])) 8752 // cond: d != 0 8753 // result: (Const8 [int64(int8(c)/int8(d))]) 8754 for { 8755 _ = v.Args[1] 8756 v_0 := v.Args[0] 8757 if v_0.Op != OpConst8 { 8758 break 8759 } 8760 c := v_0.AuxInt 8761 v_1 := v.Args[1] 8762 if v_1.Op != OpConst8 { 8763 break 8764 } 8765 d := v_1.AuxInt 8766 if !(d != 0) { 8767 break 8768 } 8769 v.reset(OpConst8) 8770 v.AuxInt = int64(int8(c) / int8(d)) 8771 return true 8772 } 8773 // match: (Div8 n (Const8 [c])) 8774 // cond: isNonNegative(n) && isPowerOfTwo(c&0xff) 8775 // result: (Rsh8Ux64 n (Const64 <typ.UInt64> [log2(c&0xff)])) 8776 for { 8777 _ = v.Args[1] 8778 n := v.Args[0] 8779 v_1 := v.Args[1] 8780 if v_1.Op != OpConst8 { 8781 break 8782 } 8783 c := v_1.AuxInt 8784 if !(isNonNegative(n) && isPowerOfTwo(c&0xff)) { 8785 break 8786 } 8787 v.reset(OpRsh8Ux64) 8788 v.AddArg(n) 8789 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8790 v0.AuxInt = log2(c & 0xff) 8791 v.AddArg(v0) 8792 return true 8793 } 8794 // match: (Div8 <t> n (Const8 [c])) 8795 // cond: c < 0 && c != -1<<7 8796 // result: (Neg8 (Div8 <t> n (Const8 <t> [-c]))) 8797 for { 8798 t := v.Type 8799 _ = v.Args[1] 8800 n := v.Args[0] 8801 v_1 := v.Args[1] 8802 if v_1.Op != OpConst8 { 8803 break 8804 } 8805 c := v_1.AuxInt 8806 if !(c < 0 && c != -1<<7) { 8807 break 8808 } 8809 v.reset(OpNeg8) 8810 v0 := b.NewValue0(v.Pos, OpDiv8, t) 8811 v0.AddArg(n) 8812 v1 := b.NewValue0(v.Pos, OpConst8, t) 8813 v1.AuxInt = -c 8814 v0.AddArg(v1) 8815 v.AddArg(v0) 8816 return true 8817 } 8818 // match: (Div8 <t> x (Const8 [-1<<7 ])) 8819 // cond: 8820 // result: (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <typ.UInt64> [7 ])) 8821 for { 8822 t := v.Type 8823 _ = v.Args[1] 8824 x := v.Args[0] 8825 v_1 := v.Args[1] 8826 if v_1.Op != OpConst8 { 8827 break 8828 } 8829 if v_1.AuxInt != -1<<7 { 8830 break 8831 } 8832 v.reset(OpRsh8Ux64) 8833 v0 := b.NewValue0(v.Pos, OpAnd8, t) 8834 v0.AddArg(x) 8835 v1 := b.NewValue0(v.Pos, OpNeg8, t) 8836 v1.AddArg(x) 8837 v0.AddArg(v1) 8838 v.AddArg(v0) 8839 v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8840 v2.AuxInt = 7 8841 v.AddArg(v2) 8842 return true 8843 } 8844 // match: (Div8 <t> n (Const8 [c])) 8845 // cond: isPowerOfTwo(c) 8846 // 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)])) 8847 for { 8848 t := v.Type 8849 _ = v.Args[1] 8850 n := v.Args[0] 8851 v_1 := v.Args[1] 8852 if v_1.Op != OpConst8 { 8853 break 8854 } 8855 c := v_1.AuxInt 8856 if !(isPowerOfTwo(c)) { 8857 break 8858 } 8859 v.reset(OpRsh8x64) 8860 v0 := b.NewValue0(v.Pos, OpAdd8, t) 8861 v0.AddArg(n) 8862 v1 := b.NewValue0(v.Pos, OpRsh8Ux64, t) 8863 v2 := b.NewValue0(v.Pos, OpRsh8x64, t) 8864 v2.AddArg(n) 8865 v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8866 v3.AuxInt = 7 8867 v2.AddArg(v3) 8868 v1.AddArg(v2) 8869 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8870 v4.AuxInt = 8 - log2(c) 8871 v1.AddArg(v4) 8872 v0.AddArg(v1) 8873 v.AddArg(v0) 8874 v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8875 v5.AuxInt = log2(c) 8876 v.AddArg(v5) 8877 return true 8878 } 8879 // match: (Div8 <t> x (Const8 [c])) 8880 // cond: smagicOK(8,c) 8881 // 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]))) 8882 for { 8883 t := v.Type 8884 _ = v.Args[1] 8885 x := v.Args[0] 8886 v_1 := v.Args[1] 8887 if v_1.Op != OpConst8 { 8888 break 8889 } 8890 c := v_1.AuxInt 8891 if !(smagicOK(8, c)) { 8892 break 8893 } 8894 v.reset(OpSub8) 8895 v.Type = t 8896 v0 := b.NewValue0(v.Pos, OpRsh32x64, t) 8897 v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) 8898 v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 8899 v2.AuxInt = int64(smagic(8, c).m) 8900 v1.AddArg(v2) 8901 v3 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 8902 v3.AddArg(x) 8903 v1.AddArg(v3) 8904 v0.AddArg(v1) 8905 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8906 v4.AuxInt = 8 + smagic(8, c).s 8907 v0.AddArg(v4) 8908 v.AddArg(v0) 8909 v5 := b.NewValue0(v.Pos, OpRsh32x64, t) 8910 v6 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 8911 v6.AddArg(x) 8912 v5.AddArg(v6) 8913 v7 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8914 v7.AuxInt = 31 8915 v5.AddArg(v7) 8916 v.AddArg(v5) 8917 return true 8918 } 8919 return false 8920 } 8921 func rewriteValuegeneric_OpDiv8u_0(v *Value) bool { 8922 b := v.Block 8923 _ = b 8924 typ := &b.Func.Config.Types 8925 _ = typ 8926 // match: (Div8u (Const8 [c]) (Const8 [d])) 8927 // cond: d != 0 8928 // result: (Const8 [int64(int8(uint8(c)/uint8(d)))]) 8929 for { 8930 _ = v.Args[1] 8931 v_0 := v.Args[0] 8932 if v_0.Op != OpConst8 { 8933 break 8934 } 8935 c := v_0.AuxInt 8936 v_1 := v.Args[1] 8937 if v_1.Op != OpConst8 { 8938 break 8939 } 8940 d := v_1.AuxInt 8941 if !(d != 0) { 8942 break 8943 } 8944 v.reset(OpConst8) 8945 v.AuxInt = int64(int8(uint8(c) / uint8(d))) 8946 return true 8947 } 8948 // match: (Div8u n (Const8 [c])) 8949 // cond: isPowerOfTwo(c&0xff) 8950 // result: (Rsh8Ux64 n (Const64 <typ.UInt64> [log2(c&0xff)])) 8951 for { 8952 _ = v.Args[1] 8953 n := v.Args[0] 8954 v_1 := v.Args[1] 8955 if v_1.Op != OpConst8 { 8956 break 8957 } 8958 c := v_1.AuxInt 8959 if !(isPowerOfTwo(c & 0xff)) { 8960 break 8961 } 8962 v.reset(OpRsh8Ux64) 8963 v.AddArg(n) 8964 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8965 v0.AuxInt = log2(c & 0xff) 8966 v.AddArg(v0) 8967 return true 8968 } 8969 // match: (Div8u x (Const8 [c])) 8970 // cond: umagicOK(8, c) 8971 // 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]))) 8972 for { 8973 _ = v.Args[1] 8974 x := v.Args[0] 8975 v_1 := v.Args[1] 8976 if v_1.Op != OpConst8 { 8977 break 8978 } 8979 c := v_1.AuxInt 8980 if !(umagicOK(8, c)) { 8981 break 8982 } 8983 v.reset(OpTrunc32to8) 8984 v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32) 8985 v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) 8986 v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 8987 v2.AuxInt = int64(1<<8 + umagic(8, c).m) 8988 v1.AddArg(v2) 8989 v3 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 8990 v3.AddArg(x) 8991 v1.AddArg(v3) 8992 v0.AddArg(v1) 8993 v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 8994 v4.AuxInt = 8 + umagic(8, c).s 8995 v0.AddArg(v4) 8996 v.AddArg(v0) 8997 return true 8998 } 8999 return false 9000 } 9001 func rewriteValuegeneric_OpEq16_0(v *Value) bool { 9002 b := v.Block 9003 _ = b 9004 // match: (Eq16 x x) 9005 // cond: 9006 // result: (ConstBool [1]) 9007 for { 9008 _ = v.Args[1] 9009 x := v.Args[0] 9010 if x != v.Args[1] { 9011 break 9012 } 9013 v.reset(OpConstBool) 9014 v.AuxInt = 1 9015 return true 9016 } 9017 // match: (Eq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x)) 9018 // cond: 9019 // result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x) 9020 for { 9021 _ = v.Args[1] 9022 v_0 := v.Args[0] 9023 if v_0.Op != OpConst16 { 9024 break 9025 } 9026 t := v_0.Type 9027 c := v_0.AuxInt 9028 v_1 := v.Args[1] 9029 if v_1.Op != OpAdd16 { 9030 break 9031 } 9032 _ = v_1.Args[1] 9033 v_1_0 := v_1.Args[0] 9034 if v_1_0.Op != OpConst16 { 9035 break 9036 } 9037 if v_1_0.Type != t { 9038 break 9039 } 9040 d := v_1_0.AuxInt 9041 x := v_1.Args[1] 9042 v.reset(OpEq16) 9043 v0 := b.NewValue0(v.Pos, OpConst16, t) 9044 v0.AuxInt = int64(int16(c - d)) 9045 v.AddArg(v0) 9046 v.AddArg(x) 9047 return true 9048 } 9049 // match: (Eq16 (Const16 <t> [c]) (Add16 x (Const16 <t> [d]))) 9050 // cond: 9051 // result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x) 9052 for { 9053 _ = v.Args[1] 9054 v_0 := v.Args[0] 9055 if v_0.Op != OpConst16 { 9056 break 9057 } 9058 t := v_0.Type 9059 c := v_0.AuxInt 9060 v_1 := v.Args[1] 9061 if v_1.Op != OpAdd16 { 9062 break 9063 } 9064 _ = v_1.Args[1] 9065 x := v_1.Args[0] 9066 v_1_1 := v_1.Args[1] 9067 if v_1_1.Op != OpConst16 { 9068 break 9069 } 9070 if v_1_1.Type != t { 9071 break 9072 } 9073 d := v_1_1.AuxInt 9074 v.reset(OpEq16) 9075 v0 := b.NewValue0(v.Pos, OpConst16, t) 9076 v0.AuxInt = int64(int16(c - d)) 9077 v.AddArg(v0) 9078 v.AddArg(x) 9079 return true 9080 } 9081 // match: (Eq16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c])) 9082 // cond: 9083 // result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x) 9084 for { 9085 _ = v.Args[1] 9086 v_0 := v.Args[0] 9087 if v_0.Op != OpAdd16 { 9088 break 9089 } 9090 _ = v_0.Args[1] 9091 v_0_0 := v_0.Args[0] 9092 if v_0_0.Op != OpConst16 { 9093 break 9094 } 9095 t := v_0_0.Type 9096 d := v_0_0.AuxInt 9097 x := v_0.Args[1] 9098 v_1 := v.Args[1] 9099 if v_1.Op != OpConst16 { 9100 break 9101 } 9102 if v_1.Type != t { 9103 break 9104 } 9105 c := v_1.AuxInt 9106 v.reset(OpEq16) 9107 v0 := b.NewValue0(v.Pos, OpConst16, t) 9108 v0.AuxInt = int64(int16(c - d)) 9109 v.AddArg(v0) 9110 v.AddArg(x) 9111 return true 9112 } 9113 // match: (Eq16 (Add16 x (Const16 <t> [d])) (Const16 <t> [c])) 9114 // cond: 9115 // result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x) 9116 for { 9117 _ = v.Args[1] 9118 v_0 := v.Args[0] 9119 if v_0.Op != OpAdd16 { 9120 break 9121 } 9122 _ = v_0.Args[1] 9123 x := v_0.Args[0] 9124 v_0_1 := v_0.Args[1] 9125 if v_0_1.Op != OpConst16 { 9126 break 9127 } 9128 t := v_0_1.Type 9129 d := v_0_1.AuxInt 9130 v_1 := v.Args[1] 9131 if v_1.Op != OpConst16 { 9132 break 9133 } 9134 if v_1.Type != t { 9135 break 9136 } 9137 c := v_1.AuxInt 9138 v.reset(OpEq16) 9139 v0 := b.NewValue0(v.Pos, OpConst16, t) 9140 v0.AuxInt = int64(int16(c - d)) 9141 v.AddArg(v0) 9142 v.AddArg(x) 9143 return true 9144 } 9145 // match: (Eq16 (Const16 [c]) (Const16 [d])) 9146 // cond: 9147 // result: (ConstBool [b2i(c == d)]) 9148 for { 9149 _ = v.Args[1] 9150 v_0 := v.Args[0] 9151 if v_0.Op != OpConst16 { 9152 break 9153 } 9154 c := v_0.AuxInt 9155 v_1 := v.Args[1] 9156 if v_1.Op != OpConst16 { 9157 break 9158 } 9159 d := v_1.AuxInt 9160 v.reset(OpConstBool) 9161 v.AuxInt = b2i(c == d) 9162 return true 9163 } 9164 // match: (Eq16 (Const16 [d]) (Const16 [c])) 9165 // cond: 9166 // result: (ConstBool [b2i(c == d)]) 9167 for { 9168 _ = v.Args[1] 9169 v_0 := v.Args[0] 9170 if v_0.Op != OpConst16 { 9171 break 9172 } 9173 d := v_0.AuxInt 9174 v_1 := v.Args[1] 9175 if v_1.Op != OpConst16 { 9176 break 9177 } 9178 c := v_1.AuxInt 9179 v.reset(OpConstBool) 9180 v.AuxInt = b2i(c == d) 9181 return true 9182 } 9183 // match: (Eq16 s:(Sub16 x y) (Const16 [0])) 9184 // cond: s.Uses == 1 9185 // result: (Eq16 x y) 9186 for { 9187 _ = v.Args[1] 9188 s := v.Args[0] 9189 if s.Op != OpSub16 { 9190 break 9191 } 9192 _ = s.Args[1] 9193 x := s.Args[0] 9194 y := s.Args[1] 9195 v_1 := v.Args[1] 9196 if v_1.Op != OpConst16 { 9197 break 9198 } 9199 if v_1.AuxInt != 0 { 9200 break 9201 } 9202 if !(s.Uses == 1) { 9203 break 9204 } 9205 v.reset(OpEq16) 9206 v.AddArg(x) 9207 v.AddArg(y) 9208 return true 9209 } 9210 // match: (Eq16 (Const16 [0]) s:(Sub16 x y)) 9211 // cond: s.Uses == 1 9212 // result: (Eq16 x y) 9213 for { 9214 _ = v.Args[1] 9215 v_0 := v.Args[0] 9216 if v_0.Op != OpConst16 { 9217 break 9218 } 9219 if v_0.AuxInt != 0 { 9220 break 9221 } 9222 s := v.Args[1] 9223 if s.Op != OpSub16 { 9224 break 9225 } 9226 _ = s.Args[1] 9227 x := s.Args[0] 9228 y := s.Args[1] 9229 if !(s.Uses == 1) { 9230 break 9231 } 9232 v.reset(OpEq16) 9233 v.AddArg(x) 9234 v.AddArg(y) 9235 return true 9236 } 9237 return false 9238 } 9239 func rewriteValuegeneric_OpEq32_0(v *Value) bool { 9240 b := v.Block 9241 _ = b 9242 // match: (Eq32 x x) 9243 // cond: 9244 // result: (ConstBool [1]) 9245 for { 9246 _ = v.Args[1] 9247 x := v.Args[0] 9248 if x != v.Args[1] { 9249 break 9250 } 9251 v.reset(OpConstBool) 9252 v.AuxInt = 1 9253 return true 9254 } 9255 // match: (Eq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x)) 9256 // cond: 9257 // result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x) 9258 for { 9259 _ = v.Args[1] 9260 v_0 := v.Args[0] 9261 if v_0.Op != OpConst32 { 9262 break 9263 } 9264 t := v_0.Type 9265 c := v_0.AuxInt 9266 v_1 := v.Args[1] 9267 if v_1.Op != OpAdd32 { 9268 break 9269 } 9270 _ = v_1.Args[1] 9271 v_1_0 := v_1.Args[0] 9272 if v_1_0.Op != OpConst32 { 9273 break 9274 } 9275 if v_1_0.Type != t { 9276 break 9277 } 9278 d := v_1_0.AuxInt 9279 x := v_1.Args[1] 9280 v.reset(OpEq32) 9281 v0 := b.NewValue0(v.Pos, OpConst32, t) 9282 v0.AuxInt = int64(int32(c - d)) 9283 v.AddArg(v0) 9284 v.AddArg(x) 9285 return true 9286 } 9287 // match: (Eq32 (Const32 <t> [c]) (Add32 x (Const32 <t> [d]))) 9288 // cond: 9289 // result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x) 9290 for { 9291 _ = v.Args[1] 9292 v_0 := v.Args[0] 9293 if v_0.Op != OpConst32 { 9294 break 9295 } 9296 t := v_0.Type 9297 c := v_0.AuxInt 9298 v_1 := v.Args[1] 9299 if v_1.Op != OpAdd32 { 9300 break 9301 } 9302 _ = v_1.Args[1] 9303 x := v_1.Args[0] 9304 v_1_1 := v_1.Args[1] 9305 if v_1_1.Op != OpConst32 { 9306 break 9307 } 9308 if v_1_1.Type != t { 9309 break 9310 } 9311 d := v_1_1.AuxInt 9312 v.reset(OpEq32) 9313 v0 := b.NewValue0(v.Pos, OpConst32, t) 9314 v0.AuxInt = int64(int32(c - d)) 9315 v.AddArg(v0) 9316 v.AddArg(x) 9317 return true 9318 } 9319 // match: (Eq32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c])) 9320 // cond: 9321 // result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x) 9322 for { 9323 _ = v.Args[1] 9324 v_0 := v.Args[0] 9325 if v_0.Op != OpAdd32 { 9326 break 9327 } 9328 _ = v_0.Args[1] 9329 v_0_0 := v_0.Args[0] 9330 if v_0_0.Op != OpConst32 { 9331 break 9332 } 9333 t := v_0_0.Type 9334 d := v_0_0.AuxInt 9335 x := v_0.Args[1] 9336 v_1 := v.Args[1] 9337 if v_1.Op != OpConst32 { 9338 break 9339 } 9340 if v_1.Type != t { 9341 break 9342 } 9343 c := v_1.AuxInt 9344 v.reset(OpEq32) 9345 v0 := b.NewValue0(v.Pos, OpConst32, t) 9346 v0.AuxInt = int64(int32(c - d)) 9347 v.AddArg(v0) 9348 v.AddArg(x) 9349 return true 9350 } 9351 // match: (Eq32 (Add32 x (Const32 <t> [d])) (Const32 <t> [c])) 9352 // cond: 9353 // result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x) 9354 for { 9355 _ = v.Args[1] 9356 v_0 := v.Args[0] 9357 if v_0.Op != OpAdd32 { 9358 break 9359 } 9360 _ = v_0.Args[1] 9361 x := v_0.Args[0] 9362 v_0_1 := v_0.Args[1] 9363 if v_0_1.Op != OpConst32 { 9364 break 9365 } 9366 t := v_0_1.Type 9367 d := v_0_1.AuxInt 9368 v_1 := v.Args[1] 9369 if v_1.Op != OpConst32 { 9370 break 9371 } 9372 if v_1.Type != t { 9373 break 9374 } 9375 c := v_1.AuxInt 9376 v.reset(OpEq32) 9377 v0 := b.NewValue0(v.Pos, OpConst32, t) 9378 v0.AuxInt = int64(int32(c - d)) 9379 v.AddArg(v0) 9380 v.AddArg(x) 9381 return true 9382 } 9383 // match: (Eq32 (Const32 [c]) (Const32 [d])) 9384 // cond: 9385 // result: (ConstBool [b2i(c == d)]) 9386 for { 9387 _ = v.Args[1] 9388 v_0 := v.Args[0] 9389 if v_0.Op != OpConst32 { 9390 break 9391 } 9392 c := v_0.AuxInt 9393 v_1 := v.Args[1] 9394 if v_1.Op != OpConst32 { 9395 break 9396 } 9397 d := v_1.AuxInt 9398 v.reset(OpConstBool) 9399 v.AuxInt = b2i(c == d) 9400 return true 9401 } 9402 // match: (Eq32 (Const32 [d]) (Const32 [c])) 9403 // cond: 9404 // result: (ConstBool [b2i(c == d)]) 9405 for { 9406 _ = v.Args[1] 9407 v_0 := v.Args[0] 9408 if v_0.Op != OpConst32 { 9409 break 9410 } 9411 d := v_0.AuxInt 9412 v_1 := v.Args[1] 9413 if v_1.Op != OpConst32 { 9414 break 9415 } 9416 c := v_1.AuxInt 9417 v.reset(OpConstBool) 9418 v.AuxInt = b2i(c == d) 9419 return true 9420 } 9421 // match: (Eq32 s:(Sub32 x y) (Const32 [0])) 9422 // cond: s.Uses == 1 9423 // result: (Eq32 x y) 9424 for { 9425 _ = v.Args[1] 9426 s := v.Args[0] 9427 if s.Op != OpSub32 { 9428 break 9429 } 9430 _ = s.Args[1] 9431 x := s.Args[0] 9432 y := s.Args[1] 9433 v_1 := v.Args[1] 9434 if v_1.Op != OpConst32 { 9435 break 9436 } 9437 if v_1.AuxInt != 0 { 9438 break 9439 } 9440 if !(s.Uses == 1) { 9441 break 9442 } 9443 v.reset(OpEq32) 9444 v.AddArg(x) 9445 v.AddArg(y) 9446 return true 9447 } 9448 // match: (Eq32 (Const32 [0]) s:(Sub32 x y)) 9449 // cond: s.Uses == 1 9450 // result: (Eq32 x y) 9451 for { 9452 _ = v.Args[1] 9453 v_0 := v.Args[0] 9454 if v_0.Op != OpConst32 { 9455 break 9456 } 9457 if v_0.AuxInt != 0 { 9458 break 9459 } 9460 s := v.Args[1] 9461 if s.Op != OpSub32 { 9462 break 9463 } 9464 _ = s.Args[1] 9465 x := s.Args[0] 9466 y := s.Args[1] 9467 if !(s.Uses == 1) { 9468 break 9469 } 9470 v.reset(OpEq32) 9471 v.AddArg(x) 9472 v.AddArg(y) 9473 return true 9474 } 9475 return false 9476 } 9477 func rewriteValuegeneric_OpEq32F_0(v *Value) bool { 9478 // match: (Eq32F (Const32F [c]) (Const32F [d])) 9479 // cond: 9480 // result: (ConstBool [b2i(auxTo32F(c) == auxTo32F(d))]) 9481 for { 9482 _ = v.Args[1] 9483 v_0 := v.Args[0] 9484 if v_0.Op != OpConst32F { 9485 break 9486 } 9487 c := v_0.AuxInt 9488 v_1 := v.Args[1] 9489 if v_1.Op != OpConst32F { 9490 break 9491 } 9492 d := v_1.AuxInt 9493 v.reset(OpConstBool) 9494 v.AuxInt = b2i(auxTo32F(c) == auxTo32F(d)) 9495 return true 9496 } 9497 // match: (Eq32F (Const32F [d]) (Const32F [c])) 9498 // cond: 9499 // result: (ConstBool [b2i(auxTo32F(c) == auxTo32F(d))]) 9500 for { 9501 _ = v.Args[1] 9502 v_0 := v.Args[0] 9503 if v_0.Op != OpConst32F { 9504 break 9505 } 9506 d := v_0.AuxInt 9507 v_1 := v.Args[1] 9508 if v_1.Op != OpConst32F { 9509 break 9510 } 9511 c := v_1.AuxInt 9512 v.reset(OpConstBool) 9513 v.AuxInt = b2i(auxTo32F(c) == auxTo32F(d)) 9514 return true 9515 } 9516 return false 9517 } 9518 func rewriteValuegeneric_OpEq64_0(v *Value) bool { 9519 b := v.Block 9520 _ = b 9521 // match: (Eq64 x x) 9522 // cond: 9523 // result: (ConstBool [1]) 9524 for { 9525 _ = v.Args[1] 9526 x := v.Args[0] 9527 if x != v.Args[1] { 9528 break 9529 } 9530 v.reset(OpConstBool) 9531 v.AuxInt = 1 9532 return true 9533 } 9534 // match: (Eq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x)) 9535 // cond: 9536 // result: (Eq64 (Const64 <t> [c-d]) x) 9537 for { 9538 _ = v.Args[1] 9539 v_0 := v.Args[0] 9540 if v_0.Op != OpConst64 { 9541 break 9542 } 9543 t := v_0.Type 9544 c := v_0.AuxInt 9545 v_1 := v.Args[1] 9546 if v_1.Op != OpAdd64 { 9547 break 9548 } 9549 _ = v_1.Args[1] 9550 v_1_0 := v_1.Args[0] 9551 if v_1_0.Op != OpConst64 { 9552 break 9553 } 9554 if v_1_0.Type != t { 9555 break 9556 } 9557 d := v_1_0.AuxInt 9558 x := v_1.Args[1] 9559 v.reset(OpEq64) 9560 v0 := b.NewValue0(v.Pos, OpConst64, t) 9561 v0.AuxInt = c - d 9562 v.AddArg(v0) 9563 v.AddArg(x) 9564 return true 9565 } 9566 // match: (Eq64 (Const64 <t> [c]) (Add64 x (Const64 <t> [d]))) 9567 // cond: 9568 // result: (Eq64 (Const64 <t> [c-d]) x) 9569 for { 9570 _ = v.Args[1] 9571 v_0 := v.Args[0] 9572 if v_0.Op != OpConst64 { 9573 break 9574 } 9575 t := v_0.Type 9576 c := v_0.AuxInt 9577 v_1 := v.Args[1] 9578 if v_1.Op != OpAdd64 { 9579 break 9580 } 9581 _ = v_1.Args[1] 9582 x := v_1.Args[0] 9583 v_1_1 := v_1.Args[1] 9584 if v_1_1.Op != OpConst64 { 9585 break 9586 } 9587 if v_1_1.Type != t { 9588 break 9589 } 9590 d := v_1_1.AuxInt 9591 v.reset(OpEq64) 9592 v0 := b.NewValue0(v.Pos, OpConst64, t) 9593 v0.AuxInt = c - d 9594 v.AddArg(v0) 9595 v.AddArg(x) 9596 return true 9597 } 9598 // match: (Eq64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c])) 9599 // cond: 9600 // result: (Eq64 (Const64 <t> [c-d]) x) 9601 for { 9602 _ = v.Args[1] 9603 v_0 := v.Args[0] 9604 if v_0.Op != OpAdd64 { 9605 break 9606 } 9607 _ = v_0.Args[1] 9608 v_0_0 := v_0.Args[0] 9609 if v_0_0.Op != OpConst64 { 9610 break 9611 } 9612 t := v_0_0.Type 9613 d := v_0_0.AuxInt 9614 x := v_0.Args[1] 9615 v_1 := v.Args[1] 9616 if v_1.Op != OpConst64 { 9617 break 9618 } 9619 if v_1.Type != t { 9620 break 9621 } 9622 c := v_1.AuxInt 9623 v.reset(OpEq64) 9624 v0 := b.NewValue0(v.Pos, OpConst64, t) 9625 v0.AuxInt = c - d 9626 v.AddArg(v0) 9627 v.AddArg(x) 9628 return true 9629 } 9630 // match: (Eq64 (Add64 x (Const64 <t> [d])) (Const64 <t> [c])) 9631 // cond: 9632 // result: (Eq64 (Const64 <t> [c-d]) x) 9633 for { 9634 _ = v.Args[1] 9635 v_0 := v.Args[0] 9636 if v_0.Op != OpAdd64 { 9637 break 9638 } 9639 _ = v_0.Args[1] 9640 x := v_0.Args[0] 9641 v_0_1 := v_0.Args[1] 9642 if v_0_1.Op != OpConst64 { 9643 break 9644 } 9645 t := v_0_1.Type 9646 d := v_0_1.AuxInt 9647 v_1 := v.Args[1] 9648 if v_1.Op != OpConst64 { 9649 break 9650 } 9651 if v_1.Type != t { 9652 break 9653 } 9654 c := v_1.AuxInt 9655 v.reset(OpEq64) 9656 v0 := b.NewValue0(v.Pos, OpConst64, t) 9657 v0.AuxInt = c - d 9658 v.AddArg(v0) 9659 v.AddArg(x) 9660 return true 9661 } 9662 // match: (Eq64 (Const64 [c]) (Const64 [d])) 9663 // cond: 9664 // result: (ConstBool [b2i(c == d)]) 9665 for { 9666 _ = v.Args[1] 9667 v_0 := v.Args[0] 9668 if v_0.Op != OpConst64 { 9669 break 9670 } 9671 c := v_0.AuxInt 9672 v_1 := v.Args[1] 9673 if v_1.Op != OpConst64 { 9674 break 9675 } 9676 d := v_1.AuxInt 9677 v.reset(OpConstBool) 9678 v.AuxInt = b2i(c == d) 9679 return true 9680 } 9681 // match: (Eq64 (Const64 [d]) (Const64 [c])) 9682 // cond: 9683 // result: (ConstBool [b2i(c == d)]) 9684 for { 9685 _ = v.Args[1] 9686 v_0 := v.Args[0] 9687 if v_0.Op != OpConst64 { 9688 break 9689 } 9690 d := v_0.AuxInt 9691 v_1 := v.Args[1] 9692 if v_1.Op != OpConst64 { 9693 break 9694 } 9695 c := v_1.AuxInt 9696 v.reset(OpConstBool) 9697 v.AuxInt = b2i(c == d) 9698 return true 9699 } 9700 // match: (Eq64 s:(Sub64 x y) (Const64 [0])) 9701 // cond: s.Uses == 1 9702 // result: (Eq64 x y) 9703 for { 9704 _ = v.Args[1] 9705 s := v.Args[0] 9706 if s.Op != OpSub64 { 9707 break 9708 } 9709 _ = s.Args[1] 9710 x := s.Args[0] 9711 y := s.Args[1] 9712 v_1 := v.Args[1] 9713 if v_1.Op != OpConst64 { 9714 break 9715 } 9716 if v_1.AuxInt != 0 { 9717 break 9718 } 9719 if !(s.Uses == 1) { 9720 break 9721 } 9722 v.reset(OpEq64) 9723 v.AddArg(x) 9724 v.AddArg(y) 9725 return true 9726 } 9727 // match: (Eq64 (Const64 [0]) s:(Sub64 x y)) 9728 // cond: s.Uses == 1 9729 // result: (Eq64 x y) 9730 for { 9731 _ = v.Args[1] 9732 v_0 := v.Args[0] 9733 if v_0.Op != OpConst64 { 9734 break 9735 } 9736 if v_0.AuxInt != 0 { 9737 break 9738 } 9739 s := v.Args[1] 9740 if s.Op != OpSub64 { 9741 break 9742 } 9743 _ = s.Args[1] 9744 x := s.Args[0] 9745 y := s.Args[1] 9746 if !(s.Uses == 1) { 9747 break 9748 } 9749 v.reset(OpEq64) 9750 v.AddArg(x) 9751 v.AddArg(y) 9752 return true 9753 } 9754 return false 9755 } 9756 func rewriteValuegeneric_OpEq64F_0(v *Value) bool { 9757 // match: (Eq64F (Const64F [c]) (Const64F [d])) 9758 // cond: 9759 // result: (ConstBool [b2i(auxTo64F(c) == auxTo64F(d))]) 9760 for { 9761 _ = v.Args[1] 9762 v_0 := v.Args[0] 9763 if v_0.Op != OpConst64F { 9764 break 9765 } 9766 c := v_0.AuxInt 9767 v_1 := v.Args[1] 9768 if v_1.Op != OpConst64F { 9769 break 9770 } 9771 d := v_1.AuxInt 9772 v.reset(OpConstBool) 9773 v.AuxInt = b2i(auxTo64F(c) == auxTo64F(d)) 9774 return true 9775 } 9776 // match: (Eq64F (Const64F [d]) (Const64F [c])) 9777 // cond: 9778 // result: (ConstBool [b2i(auxTo64F(c) == auxTo64F(d))]) 9779 for { 9780 _ = v.Args[1] 9781 v_0 := v.Args[0] 9782 if v_0.Op != OpConst64F { 9783 break 9784 } 9785 d := v_0.AuxInt 9786 v_1 := v.Args[1] 9787 if v_1.Op != OpConst64F { 9788 break 9789 } 9790 c := v_1.AuxInt 9791 v.reset(OpConstBool) 9792 v.AuxInt = b2i(auxTo64F(c) == auxTo64F(d)) 9793 return true 9794 } 9795 return false 9796 } 9797 func rewriteValuegeneric_OpEq8_0(v *Value) bool { 9798 b := v.Block 9799 _ = b 9800 // match: (Eq8 x x) 9801 // cond: 9802 // result: (ConstBool [1]) 9803 for { 9804 _ = v.Args[1] 9805 x := v.Args[0] 9806 if x != v.Args[1] { 9807 break 9808 } 9809 v.reset(OpConstBool) 9810 v.AuxInt = 1 9811 return true 9812 } 9813 // match: (Eq8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x)) 9814 // cond: 9815 // result: (Eq8 (Const8 <t> [int64(int8(c-d))]) x) 9816 for { 9817 _ = v.Args[1] 9818 v_0 := v.Args[0] 9819 if v_0.Op != OpConst8 { 9820 break 9821 } 9822 t := v_0.Type 9823 c := v_0.AuxInt 9824 v_1 := v.Args[1] 9825 if v_1.Op != OpAdd8 { 9826 break 9827 } 9828 _ = v_1.Args[1] 9829 v_1_0 := v_1.Args[0] 9830 if v_1_0.Op != OpConst8 { 9831 break 9832 } 9833 if v_1_0.Type != t { 9834 break 9835 } 9836 d := v_1_0.AuxInt 9837 x := v_1.Args[1] 9838 v.reset(OpEq8) 9839 v0 := b.NewValue0(v.Pos, OpConst8, t) 9840 v0.AuxInt = int64(int8(c - d)) 9841 v.AddArg(v0) 9842 v.AddArg(x) 9843 return true 9844 } 9845 // match: (Eq8 (Const8 <t> [c]) (Add8 x (Const8 <t> [d]))) 9846 // cond: 9847 // result: (Eq8 (Const8 <t> [int64(int8(c-d))]) x) 9848 for { 9849 _ = v.Args[1] 9850 v_0 := v.Args[0] 9851 if v_0.Op != OpConst8 { 9852 break 9853 } 9854 t := v_0.Type 9855 c := v_0.AuxInt 9856 v_1 := v.Args[1] 9857 if v_1.Op != OpAdd8 { 9858 break 9859 } 9860 _ = v_1.Args[1] 9861 x := v_1.Args[0] 9862 v_1_1 := v_1.Args[1] 9863 if v_1_1.Op != OpConst8 { 9864 break 9865 } 9866 if v_1_1.Type != t { 9867 break 9868 } 9869 d := v_1_1.AuxInt 9870 v.reset(OpEq8) 9871 v0 := b.NewValue0(v.Pos, OpConst8, t) 9872 v0.AuxInt = int64(int8(c - d)) 9873 v.AddArg(v0) 9874 v.AddArg(x) 9875 return true 9876 } 9877 // match: (Eq8 (Add8 (Const8 <t> [d]) x) (Const8 <t> [c])) 9878 // cond: 9879 // result: (Eq8 (Const8 <t> [int64(int8(c-d))]) x) 9880 for { 9881 _ = v.Args[1] 9882 v_0 := v.Args[0] 9883 if v_0.Op != OpAdd8 { 9884 break 9885 } 9886 _ = v_0.Args[1] 9887 v_0_0 := v_0.Args[0] 9888 if v_0_0.Op != OpConst8 { 9889 break 9890 } 9891 t := v_0_0.Type 9892 d := v_0_0.AuxInt 9893 x := v_0.Args[1] 9894 v_1 := v.Args[1] 9895 if v_1.Op != OpConst8 { 9896 break 9897 } 9898 if v_1.Type != t { 9899 break 9900 } 9901 c := v_1.AuxInt 9902 v.reset(OpEq8) 9903 v0 := b.NewValue0(v.Pos, OpConst8, t) 9904 v0.AuxInt = int64(int8(c - d)) 9905 v.AddArg(v0) 9906 v.AddArg(x) 9907 return true 9908 } 9909 // match: (Eq8 (Add8 x (Const8 <t> [d])) (Const8 <t> [c])) 9910 // cond: 9911 // result: (Eq8 (Const8 <t> [int64(int8(c-d))]) x) 9912 for { 9913 _ = v.Args[1] 9914 v_0 := v.Args[0] 9915 if v_0.Op != OpAdd8 { 9916 break 9917 } 9918 _ = v_0.Args[1] 9919 x := v_0.Args[0] 9920 v_0_1 := v_0.Args[1] 9921 if v_0_1.Op != OpConst8 { 9922 break 9923 } 9924 t := v_0_1.Type 9925 d := v_0_1.AuxInt 9926 v_1 := v.Args[1] 9927 if v_1.Op != OpConst8 { 9928 break 9929 } 9930 if v_1.Type != t { 9931 break 9932 } 9933 c := v_1.AuxInt 9934 v.reset(OpEq8) 9935 v0 := b.NewValue0(v.Pos, OpConst8, t) 9936 v0.AuxInt = int64(int8(c - d)) 9937 v.AddArg(v0) 9938 v.AddArg(x) 9939 return true 9940 } 9941 // match: (Eq8 (Const8 [c]) (Const8 [d])) 9942 // cond: 9943 // result: (ConstBool [b2i(c == d)]) 9944 for { 9945 _ = v.Args[1] 9946 v_0 := v.Args[0] 9947 if v_0.Op != OpConst8 { 9948 break 9949 } 9950 c := v_0.AuxInt 9951 v_1 := v.Args[1] 9952 if v_1.Op != OpConst8 { 9953 break 9954 } 9955 d := v_1.AuxInt 9956 v.reset(OpConstBool) 9957 v.AuxInt = b2i(c == d) 9958 return true 9959 } 9960 // match: (Eq8 (Const8 [d]) (Const8 [c])) 9961 // cond: 9962 // result: (ConstBool [b2i(c == d)]) 9963 for { 9964 _ = v.Args[1] 9965 v_0 := v.Args[0] 9966 if v_0.Op != OpConst8 { 9967 break 9968 } 9969 d := v_0.AuxInt 9970 v_1 := v.Args[1] 9971 if v_1.Op != OpConst8 { 9972 break 9973 } 9974 c := v_1.AuxInt 9975 v.reset(OpConstBool) 9976 v.AuxInt = b2i(c == d) 9977 return true 9978 } 9979 // match: (Eq8 s:(Sub8 x y) (Const8 [0])) 9980 // cond: s.Uses == 1 9981 // result: (Eq8 x y) 9982 for { 9983 _ = v.Args[1] 9984 s := v.Args[0] 9985 if s.Op != OpSub8 { 9986 break 9987 } 9988 _ = s.Args[1] 9989 x := s.Args[0] 9990 y := s.Args[1] 9991 v_1 := v.Args[1] 9992 if v_1.Op != OpConst8 { 9993 break 9994 } 9995 if v_1.AuxInt != 0 { 9996 break 9997 } 9998 if !(s.Uses == 1) { 9999 break 10000 } 10001 v.reset(OpEq8) 10002 v.AddArg(x) 10003 v.AddArg(y) 10004 return true 10005 } 10006 // match: (Eq8 (Const8 [0]) s:(Sub8 x y)) 10007 // cond: s.Uses == 1 10008 // result: (Eq8 x y) 10009 for { 10010 _ = v.Args[1] 10011 v_0 := v.Args[0] 10012 if v_0.Op != OpConst8 { 10013 break 10014 } 10015 if v_0.AuxInt != 0 { 10016 break 10017 } 10018 s := v.Args[1] 10019 if s.Op != OpSub8 { 10020 break 10021 } 10022 _ = s.Args[1] 10023 x := s.Args[0] 10024 y := s.Args[1] 10025 if !(s.Uses == 1) { 10026 break 10027 } 10028 v.reset(OpEq8) 10029 v.AddArg(x) 10030 v.AddArg(y) 10031 return true 10032 } 10033 return false 10034 } 10035 func rewriteValuegeneric_OpEqB_0(v *Value) bool { 10036 // match: (EqB (ConstBool [c]) (ConstBool [d])) 10037 // cond: 10038 // result: (ConstBool [b2i(c == d)]) 10039 for { 10040 _ = v.Args[1] 10041 v_0 := v.Args[0] 10042 if v_0.Op != OpConstBool { 10043 break 10044 } 10045 c := v_0.AuxInt 10046 v_1 := v.Args[1] 10047 if v_1.Op != OpConstBool { 10048 break 10049 } 10050 d := v_1.AuxInt 10051 v.reset(OpConstBool) 10052 v.AuxInt = b2i(c == d) 10053 return true 10054 } 10055 // match: (EqB (ConstBool [d]) (ConstBool [c])) 10056 // cond: 10057 // result: (ConstBool [b2i(c == d)]) 10058 for { 10059 _ = v.Args[1] 10060 v_0 := v.Args[0] 10061 if v_0.Op != OpConstBool { 10062 break 10063 } 10064 d := v_0.AuxInt 10065 v_1 := v.Args[1] 10066 if v_1.Op != OpConstBool { 10067 break 10068 } 10069 c := v_1.AuxInt 10070 v.reset(OpConstBool) 10071 v.AuxInt = b2i(c == d) 10072 return true 10073 } 10074 // match: (EqB (ConstBool [0]) x) 10075 // cond: 10076 // result: (Not x) 10077 for { 10078 _ = v.Args[1] 10079 v_0 := v.Args[0] 10080 if v_0.Op != OpConstBool { 10081 break 10082 } 10083 if v_0.AuxInt != 0 { 10084 break 10085 } 10086 x := v.Args[1] 10087 v.reset(OpNot) 10088 v.AddArg(x) 10089 return true 10090 } 10091 // match: (EqB x (ConstBool [0])) 10092 // cond: 10093 // result: (Not x) 10094 for { 10095 _ = v.Args[1] 10096 x := v.Args[0] 10097 v_1 := v.Args[1] 10098 if v_1.Op != OpConstBool { 10099 break 10100 } 10101 if v_1.AuxInt != 0 { 10102 break 10103 } 10104 v.reset(OpNot) 10105 v.AddArg(x) 10106 return true 10107 } 10108 // match: (EqB (ConstBool [1]) x) 10109 // cond: 10110 // result: x 10111 for { 10112 _ = v.Args[1] 10113 v_0 := v.Args[0] 10114 if v_0.Op != OpConstBool { 10115 break 10116 } 10117 if v_0.AuxInt != 1 { 10118 break 10119 } 10120 x := v.Args[1] 10121 v.reset(OpCopy) 10122 v.Type = x.Type 10123 v.AddArg(x) 10124 return true 10125 } 10126 // match: (EqB x (ConstBool [1])) 10127 // cond: 10128 // result: x 10129 for { 10130 _ = v.Args[1] 10131 x := v.Args[0] 10132 v_1 := v.Args[1] 10133 if v_1.Op != OpConstBool { 10134 break 10135 } 10136 if v_1.AuxInt != 1 { 10137 break 10138 } 10139 v.reset(OpCopy) 10140 v.Type = x.Type 10141 v.AddArg(x) 10142 return true 10143 } 10144 return false 10145 } 10146 func rewriteValuegeneric_OpEqInter_0(v *Value) bool { 10147 b := v.Block 10148 _ = b 10149 typ := &b.Func.Config.Types 10150 _ = typ 10151 // match: (EqInter x y) 10152 // cond: 10153 // result: (EqPtr (ITab x) (ITab y)) 10154 for { 10155 _ = v.Args[1] 10156 x := v.Args[0] 10157 y := v.Args[1] 10158 v.reset(OpEqPtr) 10159 v0 := b.NewValue0(v.Pos, OpITab, typ.Uintptr) 10160 v0.AddArg(x) 10161 v.AddArg(v0) 10162 v1 := b.NewValue0(v.Pos, OpITab, typ.Uintptr) 10163 v1.AddArg(y) 10164 v.AddArg(v1) 10165 return true 10166 } 10167 } 10168 func rewriteValuegeneric_OpEqPtr_0(v *Value) bool { 10169 // match: (EqPtr x x) 10170 // cond: 10171 // result: (ConstBool [1]) 10172 for { 10173 _ = v.Args[1] 10174 x := v.Args[0] 10175 if x != v.Args[1] { 10176 break 10177 } 10178 v.reset(OpConstBool) 10179 v.AuxInt = 1 10180 return true 10181 } 10182 // match: (EqPtr (Addr {a} _) (Addr {b} _)) 10183 // cond: 10184 // result: (ConstBool [b2i(a == b)]) 10185 for { 10186 _ = v.Args[1] 10187 v_0 := v.Args[0] 10188 if v_0.Op != OpAddr { 10189 break 10190 } 10191 a := v_0.Aux 10192 v_1 := v.Args[1] 10193 if v_1.Op != OpAddr { 10194 break 10195 } 10196 b := v_1.Aux 10197 v.reset(OpConstBool) 10198 v.AuxInt = b2i(a == b) 10199 return true 10200 } 10201 // match: (EqPtr (Addr {b} _) (Addr {a} _)) 10202 // cond: 10203 // result: (ConstBool [b2i(a == b)]) 10204 for { 10205 _ = v.Args[1] 10206 v_0 := v.Args[0] 10207 if v_0.Op != OpAddr { 10208 break 10209 } 10210 b := v_0.Aux 10211 v_1 := v.Args[1] 10212 if v_1.Op != OpAddr { 10213 break 10214 } 10215 a := v_1.Aux 10216 v.reset(OpConstBool) 10217 v.AuxInt = b2i(a == b) 10218 return true 10219 } 10220 // match: (EqPtr (LocalAddr {a} _ _) (LocalAddr {b} _ _)) 10221 // cond: 10222 // result: (ConstBool [b2i(a == b)]) 10223 for { 10224 _ = v.Args[1] 10225 v_0 := v.Args[0] 10226 if v_0.Op != OpLocalAddr { 10227 break 10228 } 10229 a := v_0.Aux 10230 _ = v_0.Args[1] 10231 v_1 := v.Args[1] 10232 if v_1.Op != OpLocalAddr { 10233 break 10234 } 10235 b := v_1.Aux 10236 _ = v_1.Args[1] 10237 v.reset(OpConstBool) 10238 v.AuxInt = b2i(a == b) 10239 return true 10240 } 10241 // match: (EqPtr (LocalAddr {b} _ _) (LocalAddr {a} _ _)) 10242 // cond: 10243 // result: (ConstBool [b2i(a == b)]) 10244 for { 10245 _ = v.Args[1] 10246 v_0 := v.Args[0] 10247 if v_0.Op != OpLocalAddr { 10248 break 10249 } 10250 b := v_0.Aux 10251 _ = v_0.Args[1] 10252 v_1 := v.Args[1] 10253 if v_1.Op != OpLocalAddr { 10254 break 10255 } 10256 a := v_1.Aux 10257 _ = v_1.Args[1] 10258 v.reset(OpConstBool) 10259 v.AuxInt = b2i(a == b) 10260 return true 10261 } 10262 // match: (EqPtr (OffPtr [o1] p1) p2) 10263 // cond: isSamePtr(p1, p2) 10264 // result: (ConstBool [b2i(o1 == 0)]) 10265 for { 10266 _ = v.Args[1] 10267 v_0 := v.Args[0] 10268 if v_0.Op != OpOffPtr { 10269 break 10270 } 10271 o1 := v_0.AuxInt 10272 p1 := v_0.Args[0] 10273 p2 := v.Args[1] 10274 if !(isSamePtr(p1, p2)) { 10275 break 10276 } 10277 v.reset(OpConstBool) 10278 v.AuxInt = b2i(o1 == 0) 10279 return true 10280 } 10281 // match: (EqPtr p2 (OffPtr [o1] p1)) 10282 // cond: isSamePtr(p1, p2) 10283 // result: (ConstBool [b2i(o1 == 0)]) 10284 for { 10285 _ = v.Args[1] 10286 p2 := v.Args[0] 10287 v_1 := v.Args[1] 10288 if v_1.Op != OpOffPtr { 10289 break 10290 } 10291 o1 := v_1.AuxInt 10292 p1 := v_1.Args[0] 10293 if !(isSamePtr(p1, p2)) { 10294 break 10295 } 10296 v.reset(OpConstBool) 10297 v.AuxInt = b2i(o1 == 0) 10298 return true 10299 } 10300 // match: (EqPtr (OffPtr [o1] p1) (OffPtr [o2] p2)) 10301 // cond: isSamePtr(p1, p2) 10302 // result: (ConstBool [b2i(o1 == o2)]) 10303 for { 10304 _ = v.Args[1] 10305 v_0 := v.Args[0] 10306 if v_0.Op != OpOffPtr { 10307 break 10308 } 10309 o1 := v_0.AuxInt 10310 p1 := v_0.Args[0] 10311 v_1 := v.Args[1] 10312 if v_1.Op != OpOffPtr { 10313 break 10314 } 10315 o2 := v_1.AuxInt 10316 p2 := v_1.Args[0] 10317 if !(isSamePtr(p1, p2)) { 10318 break 10319 } 10320 v.reset(OpConstBool) 10321 v.AuxInt = b2i(o1 == o2) 10322 return true 10323 } 10324 // match: (EqPtr (OffPtr [o2] p2) (OffPtr [o1] p1)) 10325 // cond: isSamePtr(p1, p2) 10326 // result: (ConstBool [b2i(o1 == o2)]) 10327 for { 10328 _ = v.Args[1] 10329 v_0 := v.Args[0] 10330 if v_0.Op != OpOffPtr { 10331 break 10332 } 10333 o2 := v_0.AuxInt 10334 p2 := v_0.Args[0] 10335 v_1 := v.Args[1] 10336 if v_1.Op != OpOffPtr { 10337 break 10338 } 10339 o1 := v_1.AuxInt 10340 p1 := v_1.Args[0] 10341 if !(isSamePtr(p1, p2)) { 10342 break 10343 } 10344 v.reset(OpConstBool) 10345 v.AuxInt = b2i(o1 == o2) 10346 return true 10347 } 10348 // match: (EqPtr (Const32 [c]) (Const32 [d])) 10349 // cond: 10350 // result: (ConstBool [b2i(c == d)]) 10351 for { 10352 _ = v.Args[1] 10353 v_0 := v.Args[0] 10354 if v_0.Op != OpConst32 { 10355 break 10356 } 10357 c := v_0.AuxInt 10358 v_1 := v.Args[1] 10359 if v_1.Op != OpConst32 { 10360 break 10361 } 10362 d := v_1.AuxInt 10363 v.reset(OpConstBool) 10364 v.AuxInt = b2i(c == d) 10365 return true 10366 } 10367 return false 10368 } 10369 func rewriteValuegeneric_OpEqPtr_10(v *Value) bool { 10370 b := v.Block 10371 _ = b 10372 typ := &b.Func.Config.Types 10373 _ = typ 10374 // match: (EqPtr (Const32 [d]) (Const32 [c])) 10375 // cond: 10376 // result: (ConstBool [b2i(c == d)]) 10377 for { 10378 _ = v.Args[1] 10379 v_0 := v.Args[0] 10380 if v_0.Op != OpConst32 { 10381 break 10382 } 10383 d := v_0.AuxInt 10384 v_1 := v.Args[1] 10385 if v_1.Op != OpConst32 { 10386 break 10387 } 10388 c := v_1.AuxInt 10389 v.reset(OpConstBool) 10390 v.AuxInt = b2i(c == d) 10391 return true 10392 } 10393 // match: (EqPtr (Const64 [c]) (Const64 [d])) 10394 // cond: 10395 // result: (ConstBool [b2i(c == d)]) 10396 for { 10397 _ = v.Args[1] 10398 v_0 := v.Args[0] 10399 if v_0.Op != OpConst64 { 10400 break 10401 } 10402 c := v_0.AuxInt 10403 v_1 := v.Args[1] 10404 if v_1.Op != OpConst64 { 10405 break 10406 } 10407 d := v_1.AuxInt 10408 v.reset(OpConstBool) 10409 v.AuxInt = b2i(c == d) 10410 return true 10411 } 10412 // match: (EqPtr (Const64 [d]) (Const64 [c])) 10413 // cond: 10414 // result: (ConstBool [b2i(c == d)]) 10415 for { 10416 _ = v.Args[1] 10417 v_0 := v.Args[0] 10418 if v_0.Op != OpConst64 { 10419 break 10420 } 10421 d := v_0.AuxInt 10422 v_1 := v.Args[1] 10423 if v_1.Op != OpConst64 { 10424 break 10425 } 10426 c := v_1.AuxInt 10427 v.reset(OpConstBool) 10428 v.AuxInt = b2i(c == d) 10429 return true 10430 } 10431 // match: (EqPtr (LocalAddr _ _) (Addr _)) 10432 // cond: 10433 // result: (ConstBool [0]) 10434 for { 10435 _ = v.Args[1] 10436 v_0 := v.Args[0] 10437 if v_0.Op != OpLocalAddr { 10438 break 10439 } 10440 _ = v_0.Args[1] 10441 v_1 := v.Args[1] 10442 if v_1.Op != OpAddr { 10443 break 10444 } 10445 v.reset(OpConstBool) 10446 v.AuxInt = 0 10447 return true 10448 } 10449 // match: (EqPtr (Addr _) (LocalAddr _ _)) 10450 // cond: 10451 // result: (ConstBool [0]) 10452 for { 10453 _ = v.Args[1] 10454 v_0 := v.Args[0] 10455 if v_0.Op != OpAddr { 10456 break 10457 } 10458 v_1 := v.Args[1] 10459 if v_1.Op != OpLocalAddr { 10460 break 10461 } 10462 _ = v_1.Args[1] 10463 v.reset(OpConstBool) 10464 v.AuxInt = 0 10465 return true 10466 } 10467 // match: (EqPtr (Addr _) (LocalAddr _ _)) 10468 // cond: 10469 // result: (ConstBool [0]) 10470 for { 10471 _ = v.Args[1] 10472 v_0 := v.Args[0] 10473 if v_0.Op != OpAddr { 10474 break 10475 } 10476 v_1 := v.Args[1] 10477 if v_1.Op != OpLocalAddr { 10478 break 10479 } 10480 _ = v_1.Args[1] 10481 v.reset(OpConstBool) 10482 v.AuxInt = 0 10483 return true 10484 } 10485 // match: (EqPtr (LocalAddr _ _) (Addr _)) 10486 // cond: 10487 // result: (ConstBool [0]) 10488 for { 10489 _ = v.Args[1] 10490 v_0 := v.Args[0] 10491 if v_0.Op != OpLocalAddr { 10492 break 10493 } 10494 _ = v_0.Args[1] 10495 v_1 := v.Args[1] 10496 if v_1.Op != OpAddr { 10497 break 10498 } 10499 v.reset(OpConstBool) 10500 v.AuxInt = 0 10501 return true 10502 } 10503 // match: (EqPtr (AddPtr p1 o1) p2) 10504 // cond: isSamePtr(p1, p2) 10505 // result: (Not (IsNonNil o1)) 10506 for { 10507 _ = v.Args[1] 10508 v_0 := v.Args[0] 10509 if v_0.Op != OpAddPtr { 10510 break 10511 } 10512 _ = v_0.Args[1] 10513 p1 := v_0.Args[0] 10514 o1 := v_0.Args[1] 10515 p2 := v.Args[1] 10516 if !(isSamePtr(p1, p2)) { 10517 break 10518 } 10519 v.reset(OpNot) 10520 v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool) 10521 v0.AddArg(o1) 10522 v.AddArg(v0) 10523 return true 10524 } 10525 // match: (EqPtr p2 (AddPtr p1 o1)) 10526 // cond: isSamePtr(p1, p2) 10527 // result: (Not (IsNonNil o1)) 10528 for { 10529 _ = v.Args[1] 10530 p2 := v.Args[0] 10531 v_1 := v.Args[1] 10532 if v_1.Op != OpAddPtr { 10533 break 10534 } 10535 _ = v_1.Args[1] 10536 p1 := v_1.Args[0] 10537 o1 := v_1.Args[1] 10538 if !(isSamePtr(p1, p2)) { 10539 break 10540 } 10541 v.reset(OpNot) 10542 v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool) 10543 v0.AddArg(o1) 10544 v.AddArg(v0) 10545 return true 10546 } 10547 // match: (EqPtr (Const32 [0]) p) 10548 // cond: 10549 // result: (Not (IsNonNil p)) 10550 for { 10551 _ = v.Args[1] 10552 v_0 := v.Args[0] 10553 if v_0.Op != OpConst32 { 10554 break 10555 } 10556 if v_0.AuxInt != 0 { 10557 break 10558 } 10559 p := v.Args[1] 10560 v.reset(OpNot) 10561 v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool) 10562 v0.AddArg(p) 10563 v.AddArg(v0) 10564 return true 10565 } 10566 return false 10567 } 10568 func rewriteValuegeneric_OpEqPtr_20(v *Value) bool { 10569 b := v.Block 10570 _ = b 10571 typ := &b.Func.Config.Types 10572 _ = typ 10573 // match: (EqPtr p (Const32 [0])) 10574 // cond: 10575 // result: (Not (IsNonNil p)) 10576 for { 10577 _ = v.Args[1] 10578 p := v.Args[0] 10579 v_1 := v.Args[1] 10580 if v_1.Op != OpConst32 { 10581 break 10582 } 10583 if v_1.AuxInt != 0 { 10584 break 10585 } 10586 v.reset(OpNot) 10587 v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool) 10588 v0.AddArg(p) 10589 v.AddArg(v0) 10590 return true 10591 } 10592 // match: (EqPtr (Const64 [0]) p) 10593 // cond: 10594 // result: (Not (IsNonNil p)) 10595 for { 10596 _ = v.Args[1] 10597 v_0 := v.Args[0] 10598 if v_0.Op != OpConst64 { 10599 break 10600 } 10601 if v_0.AuxInt != 0 { 10602 break 10603 } 10604 p := v.Args[1] 10605 v.reset(OpNot) 10606 v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool) 10607 v0.AddArg(p) 10608 v.AddArg(v0) 10609 return true 10610 } 10611 // match: (EqPtr p (Const64 [0])) 10612 // cond: 10613 // result: (Not (IsNonNil p)) 10614 for { 10615 _ = v.Args[1] 10616 p := v.Args[0] 10617 v_1 := v.Args[1] 10618 if v_1.Op != OpConst64 { 10619 break 10620 } 10621 if v_1.AuxInt != 0 { 10622 break 10623 } 10624 v.reset(OpNot) 10625 v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool) 10626 v0.AddArg(p) 10627 v.AddArg(v0) 10628 return true 10629 } 10630 // match: (EqPtr (ConstNil) p) 10631 // cond: 10632 // result: (Not (IsNonNil p)) 10633 for { 10634 _ = v.Args[1] 10635 v_0 := v.Args[0] 10636 if v_0.Op != OpConstNil { 10637 break 10638 } 10639 p := v.Args[1] 10640 v.reset(OpNot) 10641 v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool) 10642 v0.AddArg(p) 10643 v.AddArg(v0) 10644 return true 10645 } 10646 // match: (EqPtr p (ConstNil)) 10647 // cond: 10648 // result: (Not (IsNonNil p)) 10649 for { 10650 _ = v.Args[1] 10651 p := v.Args[0] 10652 v_1 := v.Args[1] 10653 if v_1.Op != OpConstNil { 10654 break 10655 } 10656 v.reset(OpNot) 10657 v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool) 10658 v0.AddArg(p) 10659 v.AddArg(v0) 10660 return true 10661 } 10662 return false 10663 } 10664 func rewriteValuegeneric_OpEqSlice_0(v *Value) bool { 10665 b := v.Block 10666 _ = b 10667 typ := &b.Func.Config.Types 10668 _ = typ 10669 // match: (EqSlice x y) 10670 // cond: 10671 // result: (EqPtr (SlicePtr x) (SlicePtr y)) 10672 for { 10673 _ = v.Args[1] 10674 x := v.Args[0] 10675 y := v.Args[1] 10676 v.reset(OpEqPtr) 10677 v0 := b.NewValue0(v.Pos, OpSlicePtr, typ.BytePtr) 10678 v0.AddArg(x) 10679 v.AddArg(v0) 10680 v1 := b.NewValue0(v.Pos, OpSlicePtr, typ.BytePtr) 10681 v1.AddArg(y) 10682 v.AddArg(v1) 10683 return true 10684 } 10685 } 10686 func rewriteValuegeneric_OpGeq16_0(v *Value) bool { 10687 // match: (Geq16 (Const16 [c]) (Const16 [d])) 10688 // cond: 10689 // result: (ConstBool [b2i(c >= d)]) 10690 for { 10691 _ = v.Args[1] 10692 v_0 := v.Args[0] 10693 if v_0.Op != OpConst16 { 10694 break 10695 } 10696 c := v_0.AuxInt 10697 v_1 := v.Args[1] 10698 if v_1.Op != OpConst16 { 10699 break 10700 } 10701 d := v_1.AuxInt 10702 v.reset(OpConstBool) 10703 v.AuxInt = b2i(c >= d) 10704 return true 10705 } 10706 return false 10707 } 10708 func rewriteValuegeneric_OpGeq16U_0(v *Value) bool { 10709 // match: (Geq16U (Const16 [c]) (Const16 [d])) 10710 // cond: 10711 // result: (ConstBool [b2i(uint16(c) >= uint16(d))]) 10712 for { 10713 _ = v.Args[1] 10714 v_0 := v.Args[0] 10715 if v_0.Op != OpConst16 { 10716 break 10717 } 10718 c := v_0.AuxInt 10719 v_1 := v.Args[1] 10720 if v_1.Op != OpConst16 { 10721 break 10722 } 10723 d := v_1.AuxInt 10724 v.reset(OpConstBool) 10725 v.AuxInt = b2i(uint16(c) >= uint16(d)) 10726 return true 10727 } 10728 return false 10729 } 10730 func rewriteValuegeneric_OpGeq32_0(v *Value) bool { 10731 // match: (Geq32 (Const32 [c]) (Const32 [d])) 10732 // cond: 10733 // result: (ConstBool [b2i(c >= d)]) 10734 for { 10735 _ = v.Args[1] 10736 v_0 := v.Args[0] 10737 if v_0.Op != OpConst32 { 10738 break 10739 } 10740 c := v_0.AuxInt 10741 v_1 := v.Args[1] 10742 if v_1.Op != OpConst32 { 10743 break 10744 } 10745 d := v_1.AuxInt 10746 v.reset(OpConstBool) 10747 v.AuxInt = b2i(c >= d) 10748 return true 10749 } 10750 return false 10751 } 10752 func rewriteValuegeneric_OpGeq32F_0(v *Value) bool { 10753 // match: (Geq32F (Const32F [c]) (Const32F [d])) 10754 // cond: 10755 // result: (ConstBool [b2i(auxTo32F(c) >= auxTo32F(d))]) 10756 for { 10757 _ = v.Args[1] 10758 v_0 := v.Args[0] 10759 if v_0.Op != OpConst32F { 10760 break 10761 } 10762 c := v_0.AuxInt 10763 v_1 := v.Args[1] 10764 if v_1.Op != OpConst32F { 10765 break 10766 } 10767 d := v_1.AuxInt 10768 v.reset(OpConstBool) 10769 v.AuxInt = b2i(auxTo32F(c) >= auxTo32F(d)) 10770 return true 10771 } 10772 return false 10773 } 10774 func rewriteValuegeneric_OpGeq32U_0(v *Value) bool { 10775 // match: (Geq32U (Const32 [c]) (Const32 [d])) 10776 // cond: 10777 // result: (ConstBool [b2i(uint32(c) >= uint32(d))]) 10778 for { 10779 _ = v.Args[1] 10780 v_0 := v.Args[0] 10781 if v_0.Op != OpConst32 { 10782 break 10783 } 10784 c := v_0.AuxInt 10785 v_1 := v.Args[1] 10786 if v_1.Op != OpConst32 { 10787 break 10788 } 10789 d := v_1.AuxInt 10790 v.reset(OpConstBool) 10791 v.AuxInt = b2i(uint32(c) >= uint32(d)) 10792 return true 10793 } 10794 return false 10795 } 10796 func rewriteValuegeneric_OpGeq64_0(v *Value) bool { 10797 // match: (Geq64 (Const64 [c]) (Const64 [d])) 10798 // cond: 10799 // result: (ConstBool [b2i(c >= d)]) 10800 for { 10801 _ = v.Args[1] 10802 v_0 := v.Args[0] 10803 if v_0.Op != OpConst64 { 10804 break 10805 } 10806 c := v_0.AuxInt 10807 v_1 := v.Args[1] 10808 if v_1.Op != OpConst64 { 10809 break 10810 } 10811 d := v_1.AuxInt 10812 v.reset(OpConstBool) 10813 v.AuxInt = b2i(c >= d) 10814 return true 10815 } 10816 return false 10817 } 10818 func rewriteValuegeneric_OpGeq64F_0(v *Value) bool { 10819 // match: (Geq64F (Const64F [c]) (Const64F [d])) 10820 // cond: 10821 // result: (ConstBool [b2i(auxTo64F(c) >= auxTo64F(d))]) 10822 for { 10823 _ = v.Args[1] 10824 v_0 := v.Args[0] 10825 if v_0.Op != OpConst64F { 10826 break 10827 } 10828 c := v_0.AuxInt 10829 v_1 := v.Args[1] 10830 if v_1.Op != OpConst64F { 10831 break 10832 } 10833 d := v_1.AuxInt 10834 v.reset(OpConstBool) 10835 v.AuxInt = b2i(auxTo64F(c) >= auxTo64F(d)) 10836 return true 10837 } 10838 return false 10839 } 10840 func rewriteValuegeneric_OpGeq64U_0(v *Value) bool { 10841 // match: (Geq64U (Const64 [c]) (Const64 [d])) 10842 // cond: 10843 // result: (ConstBool [b2i(uint64(c) >= uint64(d))]) 10844 for { 10845 _ = v.Args[1] 10846 v_0 := v.Args[0] 10847 if v_0.Op != OpConst64 { 10848 break 10849 } 10850 c := v_0.AuxInt 10851 v_1 := v.Args[1] 10852 if v_1.Op != OpConst64 { 10853 break 10854 } 10855 d := v_1.AuxInt 10856 v.reset(OpConstBool) 10857 v.AuxInt = b2i(uint64(c) >= uint64(d)) 10858 return true 10859 } 10860 return false 10861 } 10862 func rewriteValuegeneric_OpGeq8_0(v *Value) bool { 10863 // match: (Geq8 (Const8 [c]) (Const8 [d])) 10864 // cond: 10865 // result: (ConstBool [b2i(c >= d)]) 10866 for { 10867 _ = v.Args[1] 10868 v_0 := v.Args[0] 10869 if v_0.Op != OpConst8 { 10870 break 10871 } 10872 c := v_0.AuxInt 10873 v_1 := v.Args[1] 10874 if v_1.Op != OpConst8 { 10875 break 10876 } 10877 d := v_1.AuxInt 10878 v.reset(OpConstBool) 10879 v.AuxInt = b2i(c >= d) 10880 return true 10881 } 10882 return false 10883 } 10884 func rewriteValuegeneric_OpGeq8U_0(v *Value) bool { 10885 // match: (Geq8U (Const8 [c]) (Const8 [d])) 10886 // cond: 10887 // result: (ConstBool [b2i(uint8(c) >= uint8(d))]) 10888 for { 10889 _ = v.Args[1] 10890 v_0 := v.Args[0] 10891 if v_0.Op != OpConst8 { 10892 break 10893 } 10894 c := v_0.AuxInt 10895 v_1 := v.Args[1] 10896 if v_1.Op != OpConst8 { 10897 break 10898 } 10899 d := v_1.AuxInt 10900 v.reset(OpConstBool) 10901 v.AuxInt = b2i(uint8(c) >= uint8(d)) 10902 return true 10903 } 10904 return false 10905 } 10906 func rewriteValuegeneric_OpGreater16_0(v *Value) bool { 10907 // match: (Greater16 (Const16 [c]) (Const16 [d])) 10908 // cond: 10909 // result: (ConstBool [b2i(c > d)]) 10910 for { 10911 _ = v.Args[1] 10912 v_0 := v.Args[0] 10913 if v_0.Op != OpConst16 { 10914 break 10915 } 10916 c := v_0.AuxInt 10917 v_1 := v.Args[1] 10918 if v_1.Op != OpConst16 { 10919 break 10920 } 10921 d := v_1.AuxInt 10922 v.reset(OpConstBool) 10923 v.AuxInt = b2i(c > d) 10924 return true 10925 } 10926 return false 10927 } 10928 func rewriteValuegeneric_OpGreater16U_0(v *Value) bool { 10929 // match: (Greater16U (Const16 [c]) (Const16 [d])) 10930 // cond: 10931 // result: (ConstBool [b2i(uint16(c) > uint16(d))]) 10932 for { 10933 _ = v.Args[1] 10934 v_0 := v.Args[0] 10935 if v_0.Op != OpConst16 { 10936 break 10937 } 10938 c := v_0.AuxInt 10939 v_1 := v.Args[1] 10940 if v_1.Op != OpConst16 { 10941 break 10942 } 10943 d := v_1.AuxInt 10944 v.reset(OpConstBool) 10945 v.AuxInt = b2i(uint16(c) > uint16(d)) 10946 return true 10947 } 10948 return false 10949 } 10950 func rewriteValuegeneric_OpGreater32_0(v *Value) bool { 10951 // match: (Greater32 (Const32 [c]) (Const32 [d])) 10952 // cond: 10953 // result: (ConstBool [b2i(c > d)]) 10954 for { 10955 _ = v.Args[1] 10956 v_0 := v.Args[0] 10957 if v_0.Op != OpConst32 { 10958 break 10959 } 10960 c := v_0.AuxInt 10961 v_1 := v.Args[1] 10962 if v_1.Op != OpConst32 { 10963 break 10964 } 10965 d := v_1.AuxInt 10966 v.reset(OpConstBool) 10967 v.AuxInt = b2i(c > d) 10968 return true 10969 } 10970 return false 10971 } 10972 func rewriteValuegeneric_OpGreater32F_0(v *Value) bool { 10973 // match: (Greater32F (Const32F [c]) (Const32F [d])) 10974 // cond: 10975 // result: (ConstBool [b2i(auxTo32F(c) > auxTo32F(d))]) 10976 for { 10977 _ = v.Args[1] 10978 v_0 := v.Args[0] 10979 if v_0.Op != OpConst32F { 10980 break 10981 } 10982 c := v_0.AuxInt 10983 v_1 := v.Args[1] 10984 if v_1.Op != OpConst32F { 10985 break 10986 } 10987 d := v_1.AuxInt 10988 v.reset(OpConstBool) 10989 v.AuxInt = b2i(auxTo32F(c) > auxTo32F(d)) 10990 return true 10991 } 10992 return false 10993 } 10994 func rewriteValuegeneric_OpGreater32U_0(v *Value) bool { 10995 // match: (Greater32U (Const32 [c]) (Const32 [d])) 10996 // cond: 10997 // result: (ConstBool [b2i(uint32(c) > uint32(d))]) 10998 for { 10999 _ = v.Args[1] 11000 v_0 := v.Args[0] 11001 if v_0.Op != OpConst32 { 11002 break 11003 } 11004 c := v_0.AuxInt 11005 v_1 := v.Args[1] 11006 if v_1.Op != OpConst32 { 11007 break 11008 } 11009 d := v_1.AuxInt 11010 v.reset(OpConstBool) 11011 v.AuxInt = b2i(uint32(c) > uint32(d)) 11012 return true 11013 } 11014 return false 11015 } 11016 func rewriteValuegeneric_OpGreater64_0(v *Value) bool { 11017 // match: (Greater64 (Const64 [c]) (Const64 [d])) 11018 // cond: 11019 // result: (ConstBool [b2i(c > d)]) 11020 for { 11021 _ = v.Args[1] 11022 v_0 := v.Args[0] 11023 if v_0.Op != OpConst64 { 11024 break 11025 } 11026 c := v_0.AuxInt 11027 v_1 := v.Args[1] 11028 if v_1.Op != OpConst64 { 11029 break 11030 } 11031 d := v_1.AuxInt 11032 v.reset(OpConstBool) 11033 v.AuxInt = b2i(c > d) 11034 return true 11035 } 11036 return false 11037 } 11038 func rewriteValuegeneric_OpGreater64F_0(v *Value) bool { 11039 // match: (Greater64F (Const64F [c]) (Const64F [d])) 11040 // cond: 11041 // result: (ConstBool [b2i(auxTo64F(c) > auxTo64F(d))]) 11042 for { 11043 _ = v.Args[1] 11044 v_0 := v.Args[0] 11045 if v_0.Op != OpConst64F { 11046 break 11047 } 11048 c := v_0.AuxInt 11049 v_1 := v.Args[1] 11050 if v_1.Op != OpConst64F { 11051 break 11052 } 11053 d := v_1.AuxInt 11054 v.reset(OpConstBool) 11055 v.AuxInt = b2i(auxTo64F(c) > auxTo64F(d)) 11056 return true 11057 } 11058 return false 11059 } 11060 func rewriteValuegeneric_OpGreater64U_0(v *Value) bool { 11061 // match: (Greater64U (Const64 [c]) (Const64 [d])) 11062 // cond: 11063 // result: (ConstBool [b2i(uint64(c) > uint64(d))]) 11064 for { 11065 _ = v.Args[1] 11066 v_0 := v.Args[0] 11067 if v_0.Op != OpConst64 { 11068 break 11069 } 11070 c := v_0.AuxInt 11071 v_1 := v.Args[1] 11072 if v_1.Op != OpConst64 { 11073 break 11074 } 11075 d := v_1.AuxInt 11076 v.reset(OpConstBool) 11077 v.AuxInt = b2i(uint64(c) > uint64(d)) 11078 return true 11079 } 11080 return false 11081 } 11082 func rewriteValuegeneric_OpGreater8_0(v *Value) bool { 11083 // match: (Greater8 (Const8 [c]) (Const8 [d])) 11084 // cond: 11085 // result: (ConstBool [b2i(c > d)]) 11086 for { 11087 _ = v.Args[1] 11088 v_0 := v.Args[0] 11089 if v_0.Op != OpConst8 { 11090 break 11091 } 11092 c := v_0.AuxInt 11093 v_1 := v.Args[1] 11094 if v_1.Op != OpConst8 { 11095 break 11096 } 11097 d := v_1.AuxInt 11098 v.reset(OpConstBool) 11099 v.AuxInt = b2i(c > d) 11100 return true 11101 } 11102 return false 11103 } 11104 func rewriteValuegeneric_OpGreater8U_0(v *Value) bool { 11105 // match: (Greater8U (Const8 [c]) (Const8 [d])) 11106 // cond: 11107 // result: (ConstBool [b2i(uint8(c) > uint8(d))]) 11108 for { 11109 _ = v.Args[1] 11110 v_0 := v.Args[0] 11111 if v_0.Op != OpConst8 { 11112 break 11113 } 11114 c := v_0.AuxInt 11115 v_1 := v.Args[1] 11116 if v_1.Op != OpConst8 { 11117 break 11118 } 11119 d := v_1.AuxInt 11120 v.reset(OpConstBool) 11121 v.AuxInt = b2i(uint8(c) > uint8(d)) 11122 return true 11123 } 11124 return false 11125 } 11126 func rewriteValuegeneric_OpIMake_0(v *Value) bool { 11127 // match: (IMake typ (StructMake1 val)) 11128 // cond: 11129 // result: (IMake typ val) 11130 for { 11131 _ = v.Args[1] 11132 typ := v.Args[0] 11133 v_1 := v.Args[1] 11134 if v_1.Op != OpStructMake1 { 11135 break 11136 } 11137 val := v_1.Args[0] 11138 v.reset(OpIMake) 11139 v.AddArg(typ) 11140 v.AddArg(val) 11141 return true 11142 } 11143 // match: (IMake typ (ArrayMake1 val)) 11144 // cond: 11145 // result: (IMake typ val) 11146 for { 11147 _ = v.Args[1] 11148 typ := v.Args[0] 11149 v_1 := v.Args[1] 11150 if v_1.Op != OpArrayMake1 { 11151 break 11152 } 11153 val := v_1.Args[0] 11154 v.reset(OpIMake) 11155 v.AddArg(typ) 11156 v.AddArg(val) 11157 return true 11158 } 11159 return false 11160 } 11161 func rewriteValuegeneric_OpInterCall_0(v *Value) bool { 11162 // match: (InterCall [argsize] (Load (OffPtr [off] (ITab (IMake (Addr {itab} (SB)) _))) _) mem) 11163 // cond: devirt(v, itab, off) != nil 11164 // result: (StaticCall [argsize] {devirt(v, itab, off)} mem) 11165 for { 11166 argsize := v.AuxInt 11167 _ = v.Args[1] 11168 v_0 := v.Args[0] 11169 if v_0.Op != OpLoad { 11170 break 11171 } 11172 _ = v_0.Args[1] 11173 v_0_0 := v_0.Args[0] 11174 if v_0_0.Op != OpOffPtr { 11175 break 11176 } 11177 off := v_0_0.AuxInt 11178 v_0_0_0 := v_0_0.Args[0] 11179 if v_0_0_0.Op != OpITab { 11180 break 11181 } 11182 v_0_0_0_0 := v_0_0_0.Args[0] 11183 if v_0_0_0_0.Op != OpIMake { 11184 break 11185 } 11186 _ = v_0_0_0_0.Args[1] 11187 v_0_0_0_0_0 := v_0_0_0_0.Args[0] 11188 if v_0_0_0_0_0.Op != OpAddr { 11189 break 11190 } 11191 itab := v_0_0_0_0_0.Aux 11192 v_0_0_0_0_0_0 := v_0_0_0_0_0.Args[0] 11193 if v_0_0_0_0_0_0.Op != OpSB { 11194 break 11195 } 11196 mem := v.Args[1] 11197 if !(devirt(v, itab, off) != nil) { 11198 break 11199 } 11200 v.reset(OpStaticCall) 11201 v.AuxInt = argsize 11202 v.Aux = devirt(v, itab, off) 11203 v.AddArg(mem) 11204 return true 11205 } 11206 return false 11207 } 11208 func rewriteValuegeneric_OpIsInBounds_0(v *Value) bool { 11209 // match: (IsInBounds (ZeroExt8to32 _) (Const32 [c])) 11210 // cond: (1 << 8) <= c 11211 // result: (ConstBool [1]) 11212 for { 11213 _ = v.Args[1] 11214 v_0 := v.Args[0] 11215 if v_0.Op != OpZeroExt8to32 { 11216 break 11217 } 11218 v_1 := v.Args[1] 11219 if v_1.Op != OpConst32 { 11220 break 11221 } 11222 c := v_1.AuxInt 11223 if !((1 << 8) <= c) { 11224 break 11225 } 11226 v.reset(OpConstBool) 11227 v.AuxInt = 1 11228 return true 11229 } 11230 // match: (IsInBounds (ZeroExt8to64 _) (Const64 [c])) 11231 // cond: (1 << 8) <= c 11232 // result: (ConstBool [1]) 11233 for { 11234 _ = v.Args[1] 11235 v_0 := v.Args[0] 11236 if v_0.Op != OpZeroExt8to64 { 11237 break 11238 } 11239 v_1 := v.Args[1] 11240 if v_1.Op != OpConst64 { 11241 break 11242 } 11243 c := v_1.AuxInt 11244 if !((1 << 8) <= c) { 11245 break 11246 } 11247 v.reset(OpConstBool) 11248 v.AuxInt = 1 11249 return true 11250 } 11251 // match: (IsInBounds (ZeroExt16to32 _) (Const32 [c])) 11252 // cond: (1 << 16) <= c 11253 // result: (ConstBool [1]) 11254 for { 11255 _ = v.Args[1] 11256 v_0 := v.Args[0] 11257 if v_0.Op != OpZeroExt16to32 { 11258 break 11259 } 11260 v_1 := v.Args[1] 11261 if v_1.Op != OpConst32 { 11262 break 11263 } 11264 c := v_1.AuxInt 11265 if !((1 << 16) <= c) { 11266 break 11267 } 11268 v.reset(OpConstBool) 11269 v.AuxInt = 1 11270 return true 11271 } 11272 // match: (IsInBounds (ZeroExt16to64 _) (Const64 [c])) 11273 // cond: (1 << 16) <= c 11274 // result: (ConstBool [1]) 11275 for { 11276 _ = v.Args[1] 11277 v_0 := v.Args[0] 11278 if v_0.Op != OpZeroExt16to64 { 11279 break 11280 } 11281 v_1 := v.Args[1] 11282 if v_1.Op != OpConst64 { 11283 break 11284 } 11285 c := v_1.AuxInt 11286 if !((1 << 16) <= c) { 11287 break 11288 } 11289 v.reset(OpConstBool) 11290 v.AuxInt = 1 11291 return true 11292 } 11293 // match: (IsInBounds x x) 11294 // cond: 11295 // result: (ConstBool [0]) 11296 for { 11297 _ = v.Args[1] 11298 x := v.Args[0] 11299 if x != v.Args[1] { 11300 break 11301 } 11302 v.reset(OpConstBool) 11303 v.AuxInt = 0 11304 return true 11305 } 11306 // match: (IsInBounds (And8 (Const8 [c]) _) (Const8 [d])) 11307 // cond: 0 <= c && c < d 11308 // result: (ConstBool [1]) 11309 for { 11310 _ = v.Args[1] 11311 v_0 := v.Args[0] 11312 if v_0.Op != OpAnd8 { 11313 break 11314 } 11315 _ = v_0.Args[1] 11316 v_0_0 := v_0.Args[0] 11317 if v_0_0.Op != OpConst8 { 11318 break 11319 } 11320 c := v_0_0.AuxInt 11321 v_1 := v.Args[1] 11322 if v_1.Op != OpConst8 { 11323 break 11324 } 11325 d := v_1.AuxInt 11326 if !(0 <= c && c < d) { 11327 break 11328 } 11329 v.reset(OpConstBool) 11330 v.AuxInt = 1 11331 return true 11332 } 11333 // match: (IsInBounds (And8 _ (Const8 [c])) (Const8 [d])) 11334 // cond: 0 <= c && c < d 11335 // result: (ConstBool [1]) 11336 for { 11337 _ = v.Args[1] 11338 v_0 := v.Args[0] 11339 if v_0.Op != OpAnd8 { 11340 break 11341 } 11342 _ = v_0.Args[1] 11343 v_0_1 := v_0.Args[1] 11344 if v_0_1.Op != OpConst8 { 11345 break 11346 } 11347 c := v_0_1.AuxInt 11348 v_1 := v.Args[1] 11349 if v_1.Op != OpConst8 { 11350 break 11351 } 11352 d := v_1.AuxInt 11353 if !(0 <= c && c < d) { 11354 break 11355 } 11356 v.reset(OpConstBool) 11357 v.AuxInt = 1 11358 return true 11359 } 11360 // match: (IsInBounds (ZeroExt8to16 (And8 (Const8 [c]) _)) (Const16 [d])) 11361 // cond: 0 <= c && c < d 11362 // result: (ConstBool [1]) 11363 for { 11364 _ = v.Args[1] 11365 v_0 := v.Args[0] 11366 if v_0.Op != OpZeroExt8to16 { 11367 break 11368 } 11369 v_0_0 := v_0.Args[0] 11370 if v_0_0.Op != OpAnd8 { 11371 break 11372 } 11373 _ = v_0_0.Args[1] 11374 v_0_0_0 := v_0_0.Args[0] 11375 if v_0_0_0.Op != OpConst8 { 11376 break 11377 } 11378 c := v_0_0_0.AuxInt 11379 v_1 := v.Args[1] 11380 if v_1.Op != OpConst16 { 11381 break 11382 } 11383 d := v_1.AuxInt 11384 if !(0 <= c && c < d) { 11385 break 11386 } 11387 v.reset(OpConstBool) 11388 v.AuxInt = 1 11389 return true 11390 } 11391 // match: (IsInBounds (ZeroExt8to16 (And8 _ (Const8 [c]))) (Const16 [d])) 11392 // cond: 0 <= c && c < d 11393 // result: (ConstBool [1]) 11394 for { 11395 _ = v.Args[1] 11396 v_0 := v.Args[0] 11397 if v_0.Op != OpZeroExt8to16 { 11398 break 11399 } 11400 v_0_0 := v_0.Args[0] 11401 if v_0_0.Op != OpAnd8 { 11402 break 11403 } 11404 _ = v_0_0.Args[1] 11405 v_0_0_1 := v_0_0.Args[1] 11406 if v_0_0_1.Op != OpConst8 { 11407 break 11408 } 11409 c := v_0_0_1.AuxInt 11410 v_1 := v.Args[1] 11411 if v_1.Op != OpConst16 { 11412 break 11413 } 11414 d := v_1.AuxInt 11415 if !(0 <= c && c < d) { 11416 break 11417 } 11418 v.reset(OpConstBool) 11419 v.AuxInt = 1 11420 return true 11421 } 11422 // match: (IsInBounds (ZeroExt8to32 (And8 (Const8 [c]) _)) (Const32 [d])) 11423 // cond: 0 <= c && c < d 11424 // result: (ConstBool [1]) 11425 for { 11426 _ = v.Args[1] 11427 v_0 := v.Args[0] 11428 if v_0.Op != OpZeroExt8to32 { 11429 break 11430 } 11431 v_0_0 := v_0.Args[0] 11432 if v_0_0.Op != OpAnd8 { 11433 break 11434 } 11435 _ = v_0_0.Args[1] 11436 v_0_0_0 := v_0_0.Args[0] 11437 if v_0_0_0.Op != OpConst8 { 11438 break 11439 } 11440 c := v_0_0_0.AuxInt 11441 v_1 := v.Args[1] 11442 if v_1.Op != OpConst32 { 11443 break 11444 } 11445 d := v_1.AuxInt 11446 if !(0 <= c && c < d) { 11447 break 11448 } 11449 v.reset(OpConstBool) 11450 v.AuxInt = 1 11451 return true 11452 } 11453 return false 11454 } 11455 func rewriteValuegeneric_OpIsInBounds_10(v *Value) bool { 11456 // match: (IsInBounds (ZeroExt8to32 (And8 _ (Const8 [c]))) (Const32 [d])) 11457 // cond: 0 <= c && c < d 11458 // result: (ConstBool [1]) 11459 for { 11460 _ = v.Args[1] 11461 v_0 := v.Args[0] 11462 if v_0.Op != OpZeroExt8to32 { 11463 break 11464 } 11465 v_0_0 := v_0.Args[0] 11466 if v_0_0.Op != OpAnd8 { 11467 break 11468 } 11469 _ = v_0_0.Args[1] 11470 v_0_0_1 := v_0_0.Args[1] 11471 if v_0_0_1.Op != OpConst8 { 11472 break 11473 } 11474 c := v_0_0_1.AuxInt 11475 v_1 := v.Args[1] 11476 if v_1.Op != OpConst32 { 11477 break 11478 } 11479 d := v_1.AuxInt 11480 if !(0 <= c && c < d) { 11481 break 11482 } 11483 v.reset(OpConstBool) 11484 v.AuxInt = 1 11485 return true 11486 } 11487 // match: (IsInBounds (ZeroExt8to64 (And8 (Const8 [c]) _)) (Const64 [d])) 11488 // cond: 0 <= c && c < d 11489 // result: (ConstBool [1]) 11490 for { 11491 _ = v.Args[1] 11492 v_0 := v.Args[0] 11493 if v_0.Op != OpZeroExt8to64 { 11494 break 11495 } 11496 v_0_0 := v_0.Args[0] 11497 if v_0_0.Op != OpAnd8 { 11498 break 11499 } 11500 _ = v_0_0.Args[1] 11501 v_0_0_0 := v_0_0.Args[0] 11502 if v_0_0_0.Op != OpConst8 { 11503 break 11504 } 11505 c := v_0_0_0.AuxInt 11506 v_1 := v.Args[1] 11507 if v_1.Op != OpConst64 { 11508 break 11509 } 11510 d := v_1.AuxInt 11511 if !(0 <= c && c < d) { 11512 break 11513 } 11514 v.reset(OpConstBool) 11515 v.AuxInt = 1 11516 return true 11517 } 11518 // match: (IsInBounds (ZeroExt8to64 (And8 _ (Const8 [c]))) (Const64 [d])) 11519 // cond: 0 <= c && c < d 11520 // result: (ConstBool [1]) 11521 for { 11522 _ = v.Args[1] 11523 v_0 := v.Args[0] 11524 if v_0.Op != OpZeroExt8to64 { 11525 break 11526 } 11527 v_0_0 := v_0.Args[0] 11528 if v_0_0.Op != OpAnd8 { 11529 break 11530 } 11531 _ = v_0_0.Args[1] 11532 v_0_0_1 := v_0_0.Args[1] 11533 if v_0_0_1.Op != OpConst8 { 11534 break 11535 } 11536 c := v_0_0_1.AuxInt 11537 v_1 := v.Args[1] 11538 if v_1.Op != OpConst64 { 11539 break 11540 } 11541 d := v_1.AuxInt 11542 if !(0 <= c && c < d) { 11543 break 11544 } 11545 v.reset(OpConstBool) 11546 v.AuxInt = 1 11547 return true 11548 } 11549 // match: (IsInBounds (And16 (Const16 [c]) _) (Const16 [d])) 11550 // cond: 0 <= c && c < d 11551 // result: (ConstBool [1]) 11552 for { 11553 _ = v.Args[1] 11554 v_0 := v.Args[0] 11555 if v_0.Op != OpAnd16 { 11556 break 11557 } 11558 _ = v_0.Args[1] 11559 v_0_0 := v_0.Args[0] 11560 if v_0_0.Op != OpConst16 { 11561 break 11562 } 11563 c := v_0_0.AuxInt 11564 v_1 := v.Args[1] 11565 if v_1.Op != OpConst16 { 11566 break 11567 } 11568 d := v_1.AuxInt 11569 if !(0 <= c && c < d) { 11570 break 11571 } 11572 v.reset(OpConstBool) 11573 v.AuxInt = 1 11574 return true 11575 } 11576 // match: (IsInBounds (And16 _ (Const16 [c])) (Const16 [d])) 11577 // cond: 0 <= c && c < d 11578 // result: (ConstBool [1]) 11579 for { 11580 _ = v.Args[1] 11581 v_0 := v.Args[0] 11582 if v_0.Op != OpAnd16 { 11583 break 11584 } 11585 _ = v_0.Args[1] 11586 v_0_1 := v_0.Args[1] 11587 if v_0_1.Op != OpConst16 { 11588 break 11589 } 11590 c := v_0_1.AuxInt 11591 v_1 := v.Args[1] 11592 if v_1.Op != OpConst16 { 11593 break 11594 } 11595 d := v_1.AuxInt 11596 if !(0 <= c && c < d) { 11597 break 11598 } 11599 v.reset(OpConstBool) 11600 v.AuxInt = 1 11601 return true 11602 } 11603 // match: (IsInBounds (ZeroExt16to32 (And16 (Const16 [c]) _)) (Const32 [d])) 11604 // cond: 0 <= c && c < d 11605 // result: (ConstBool [1]) 11606 for { 11607 _ = v.Args[1] 11608 v_0 := v.Args[0] 11609 if v_0.Op != OpZeroExt16to32 { 11610 break 11611 } 11612 v_0_0 := v_0.Args[0] 11613 if v_0_0.Op != OpAnd16 { 11614 break 11615 } 11616 _ = v_0_0.Args[1] 11617 v_0_0_0 := v_0_0.Args[0] 11618 if v_0_0_0.Op != OpConst16 { 11619 break 11620 } 11621 c := v_0_0_0.AuxInt 11622 v_1 := v.Args[1] 11623 if v_1.Op != OpConst32 { 11624 break 11625 } 11626 d := v_1.AuxInt 11627 if !(0 <= c && c < d) { 11628 break 11629 } 11630 v.reset(OpConstBool) 11631 v.AuxInt = 1 11632 return true 11633 } 11634 // match: (IsInBounds (ZeroExt16to32 (And16 _ (Const16 [c]))) (Const32 [d])) 11635 // cond: 0 <= c && c < d 11636 // result: (ConstBool [1]) 11637 for { 11638 _ = v.Args[1] 11639 v_0 := v.Args[0] 11640 if v_0.Op != OpZeroExt16to32 { 11641 break 11642 } 11643 v_0_0 := v_0.Args[0] 11644 if v_0_0.Op != OpAnd16 { 11645 break 11646 } 11647 _ = v_0_0.Args[1] 11648 v_0_0_1 := v_0_0.Args[1] 11649 if v_0_0_1.Op != OpConst16 { 11650 break 11651 } 11652 c := v_0_0_1.AuxInt 11653 v_1 := v.Args[1] 11654 if v_1.Op != OpConst32 { 11655 break 11656 } 11657 d := v_1.AuxInt 11658 if !(0 <= c && c < d) { 11659 break 11660 } 11661 v.reset(OpConstBool) 11662 v.AuxInt = 1 11663 return true 11664 } 11665 // match: (IsInBounds (ZeroExt16to64 (And16 (Const16 [c]) _)) (Const64 [d])) 11666 // cond: 0 <= c && c < d 11667 // result: (ConstBool [1]) 11668 for { 11669 _ = v.Args[1] 11670 v_0 := v.Args[0] 11671 if v_0.Op != OpZeroExt16to64 { 11672 break 11673 } 11674 v_0_0 := v_0.Args[0] 11675 if v_0_0.Op != OpAnd16 { 11676 break 11677 } 11678 _ = v_0_0.Args[1] 11679 v_0_0_0 := v_0_0.Args[0] 11680 if v_0_0_0.Op != OpConst16 { 11681 break 11682 } 11683 c := v_0_0_0.AuxInt 11684 v_1 := v.Args[1] 11685 if v_1.Op != OpConst64 { 11686 break 11687 } 11688 d := v_1.AuxInt 11689 if !(0 <= c && c < d) { 11690 break 11691 } 11692 v.reset(OpConstBool) 11693 v.AuxInt = 1 11694 return true 11695 } 11696 // match: (IsInBounds (ZeroExt16to64 (And16 _ (Const16 [c]))) (Const64 [d])) 11697 // cond: 0 <= c && c < d 11698 // result: (ConstBool [1]) 11699 for { 11700 _ = v.Args[1] 11701 v_0 := v.Args[0] 11702 if v_0.Op != OpZeroExt16to64 { 11703 break 11704 } 11705 v_0_0 := v_0.Args[0] 11706 if v_0_0.Op != OpAnd16 { 11707 break 11708 } 11709 _ = v_0_0.Args[1] 11710 v_0_0_1 := v_0_0.Args[1] 11711 if v_0_0_1.Op != OpConst16 { 11712 break 11713 } 11714 c := v_0_0_1.AuxInt 11715 v_1 := v.Args[1] 11716 if v_1.Op != OpConst64 { 11717 break 11718 } 11719 d := v_1.AuxInt 11720 if !(0 <= c && c < d) { 11721 break 11722 } 11723 v.reset(OpConstBool) 11724 v.AuxInt = 1 11725 return true 11726 } 11727 // match: (IsInBounds (And32 (Const32 [c]) _) (Const32 [d])) 11728 // cond: 0 <= c && c < d 11729 // result: (ConstBool [1]) 11730 for { 11731 _ = v.Args[1] 11732 v_0 := v.Args[0] 11733 if v_0.Op != OpAnd32 { 11734 break 11735 } 11736 _ = v_0.Args[1] 11737 v_0_0 := v_0.Args[0] 11738 if v_0_0.Op != OpConst32 { 11739 break 11740 } 11741 c := v_0_0.AuxInt 11742 v_1 := v.Args[1] 11743 if v_1.Op != OpConst32 { 11744 break 11745 } 11746 d := v_1.AuxInt 11747 if !(0 <= c && c < d) { 11748 break 11749 } 11750 v.reset(OpConstBool) 11751 v.AuxInt = 1 11752 return true 11753 } 11754 return false 11755 } 11756 func rewriteValuegeneric_OpIsInBounds_20(v *Value) bool { 11757 // match: (IsInBounds (And32 _ (Const32 [c])) (Const32 [d])) 11758 // cond: 0 <= c && c < d 11759 // result: (ConstBool [1]) 11760 for { 11761 _ = v.Args[1] 11762 v_0 := v.Args[0] 11763 if v_0.Op != OpAnd32 { 11764 break 11765 } 11766 _ = v_0.Args[1] 11767 v_0_1 := v_0.Args[1] 11768 if v_0_1.Op != OpConst32 { 11769 break 11770 } 11771 c := v_0_1.AuxInt 11772 v_1 := v.Args[1] 11773 if v_1.Op != OpConst32 { 11774 break 11775 } 11776 d := v_1.AuxInt 11777 if !(0 <= c && c < d) { 11778 break 11779 } 11780 v.reset(OpConstBool) 11781 v.AuxInt = 1 11782 return true 11783 } 11784 // match: (IsInBounds (ZeroExt32to64 (And32 (Const32 [c]) _)) (Const64 [d])) 11785 // cond: 0 <= c && c < d 11786 // result: (ConstBool [1]) 11787 for { 11788 _ = v.Args[1] 11789 v_0 := v.Args[0] 11790 if v_0.Op != OpZeroExt32to64 { 11791 break 11792 } 11793 v_0_0 := v_0.Args[0] 11794 if v_0_0.Op != OpAnd32 { 11795 break 11796 } 11797 _ = v_0_0.Args[1] 11798 v_0_0_0 := v_0_0.Args[0] 11799 if v_0_0_0.Op != OpConst32 { 11800 break 11801 } 11802 c := v_0_0_0.AuxInt 11803 v_1 := v.Args[1] 11804 if v_1.Op != OpConst64 { 11805 break 11806 } 11807 d := v_1.AuxInt 11808 if !(0 <= c && c < d) { 11809 break 11810 } 11811 v.reset(OpConstBool) 11812 v.AuxInt = 1 11813 return true 11814 } 11815 // match: (IsInBounds (ZeroExt32to64 (And32 _ (Const32 [c]))) (Const64 [d])) 11816 // cond: 0 <= c && c < d 11817 // result: (ConstBool [1]) 11818 for { 11819 _ = v.Args[1] 11820 v_0 := v.Args[0] 11821 if v_0.Op != OpZeroExt32to64 { 11822 break 11823 } 11824 v_0_0 := v_0.Args[0] 11825 if v_0_0.Op != OpAnd32 { 11826 break 11827 } 11828 _ = v_0_0.Args[1] 11829 v_0_0_1 := v_0_0.Args[1] 11830 if v_0_0_1.Op != OpConst32 { 11831 break 11832 } 11833 c := v_0_0_1.AuxInt 11834 v_1 := v.Args[1] 11835 if v_1.Op != OpConst64 { 11836 break 11837 } 11838 d := v_1.AuxInt 11839 if !(0 <= c && c < d) { 11840 break 11841 } 11842 v.reset(OpConstBool) 11843 v.AuxInt = 1 11844 return true 11845 } 11846 // match: (IsInBounds (And64 (Const64 [c]) _) (Const64 [d])) 11847 // cond: 0 <= c && c < d 11848 // result: (ConstBool [1]) 11849 for { 11850 _ = v.Args[1] 11851 v_0 := v.Args[0] 11852 if v_0.Op != OpAnd64 { 11853 break 11854 } 11855 _ = v_0.Args[1] 11856 v_0_0 := v_0.Args[0] 11857 if v_0_0.Op != OpConst64 { 11858 break 11859 } 11860 c := v_0_0.AuxInt 11861 v_1 := v.Args[1] 11862 if v_1.Op != OpConst64 { 11863 break 11864 } 11865 d := v_1.AuxInt 11866 if !(0 <= c && c < d) { 11867 break 11868 } 11869 v.reset(OpConstBool) 11870 v.AuxInt = 1 11871 return true 11872 } 11873 // match: (IsInBounds (And64 _ (Const64 [c])) (Const64 [d])) 11874 // cond: 0 <= c && c < d 11875 // result: (ConstBool [1]) 11876 for { 11877 _ = v.Args[1] 11878 v_0 := v.Args[0] 11879 if v_0.Op != OpAnd64 { 11880 break 11881 } 11882 _ = v_0.Args[1] 11883 v_0_1 := v_0.Args[1] 11884 if v_0_1.Op != OpConst64 { 11885 break 11886 } 11887 c := v_0_1.AuxInt 11888 v_1 := v.Args[1] 11889 if v_1.Op != OpConst64 { 11890 break 11891 } 11892 d := v_1.AuxInt 11893 if !(0 <= c && c < d) { 11894 break 11895 } 11896 v.reset(OpConstBool) 11897 v.AuxInt = 1 11898 return true 11899 } 11900 // match: (IsInBounds (Const32 [c]) (Const32 [d])) 11901 // cond: 11902 // result: (ConstBool [b2i(0 <= c && c < d)]) 11903 for { 11904 _ = v.Args[1] 11905 v_0 := v.Args[0] 11906 if v_0.Op != OpConst32 { 11907 break 11908 } 11909 c := v_0.AuxInt 11910 v_1 := v.Args[1] 11911 if v_1.Op != OpConst32 { 11912 break 11913 } 11914 d := v_1.AuxInt 11915 v.reset(OpConstBool) 11916 v.AuxInt = b2i(0 <= c && c < d) 11917 return true 11918 } 11919 // match: (IsInBounds (Const64 [c]) (Const64 [d])) 11920 // cond: 11921 // result: (ConstBool [b2i(0 <= c && c < d)]) 11922 for { 11923 _ = v.Args[1] 11924 v_0 := v.Args[0] 11925 if v_0.Op != OpConst64 { 11926 break 11927 } 11928 c := v_0.AuxInt 11929 v_1 := v.Args[1] 11930 if v_1.Op != OpConst64 { 11931 break 11932 } 11933 d := v_1.AuxInt 11934 v.reset(OpConstBool) 11935 v.AuxInt = b2i(0 <= c && c < d) 11936 return true 11937 } 11938 // match: (IsInBounds (Mod32u _ y) y) 11939 // cond: 11940 // result: (ConstBool [1]) 11941 for { 11942 _ = v.Args[1] 11943 v_0 := v.Args[0] 11944 if v_0.Op != OpMod32u { 11945 break 11946 } 11947 _ = v_0.Args[1] 11948 y := v_0.Args[1] 11949 if y != v.Args[1] { 11950 break 11951 } 11952 v.reset(OpConstBool) 11953 v.AuxInt = 1 11954 return true 11955 } 11956 // match: (IsInBounds (Mod64u _ y) y) 11957 // cond: 11958 // result: (ConstBool [1]) 11959 for { 11960 _ = v.Args[1] 11961 v_0 := v.Args[0] 11962 if v_0.Op != OpMod64u { 11963 break 11964 } 11965 _ = v_0.Args[1] 11966 y := v_0.Args[1] 11967 if y != v.Args[1] { 11968 break 11969 } 11970 v.reset(OpConstBool) 11971 v.AuxInt = 1 11972 return true 11973 } 11974 // match: (IsInBounds (ZeroExt8to64 (Rsh8Ux64 _ (Const64 [c]))) (Const64 [d])) 11975 // cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d 11976 // result: (ConstBool [1]) 11977 for { 11978 _ = v.Args[1] 11979 v_0 := v.Args[0] 11980 if v_0.Op != OpZeroExt8to64 { 11981 break 11982 } 11983 v_0_0 := v_0.Args[0] 11984 if v_0_0.Op != OpRsh8Ux64 { 11985 break 11986 } 11987 _ = v_0_0.Args[1] 11988 v_0_0_1 := v_0_0.Args[1] 11989 if v_0_0_1.Op != OpConst64 { 11990 break 11991 } 11992 c := v_0_0_1.AuxInt 11993 v_1 := v.Args[1] 11994 if v_1.Op != OpConst64 { 11995 break 11996 } 11997 d := v_1.AuxInt 11998 if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) { 11999 break 12000 } 12001 v.reset(OpConstBool) 12002 v.AuxInt = 1 12003 return true 12004 } 12005 return false 12006 } 12007 func rewriteValuegeneric_OpIsInBounds_30(v *Value) bool { 12008 // match: (IsInBounds (ZeroExt8to32 (Rsh8Ux64 _ (Const64 [c]))) (Const32 [d])) 12009 // cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d 12010 // result: (ConstBool [1]) 12011 for { 12012 _ = v.Args[1] 12013 v_0 := v.Args[0] 12014 if v_0.Op != OpZeroExt8to32 { 12015 break 12016 } 12017 v_0_0 := v_0.Args[0] 12018 if v_0_0.Op != OpRsh8Ux64 { 12019 break 12020 } 12021 _ = v_0_0.Args[1] 12022 v_0_0_1 := v_0_0.Args[1] 12023 if v_0_0_1.Op != OpConst64 { 12024 break 12025 } 12026 c := v_0_0_1.AuxInt 12027 v_1 := v.Args[1] 12028 if v_1.Op != OpConst32 { 12029 break 12030 } 12031 d := v_1.AuxInt 12032 if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) { 12033 break 12034 } 12035 v.reset(OpConstBool) 12036 v.AuxInt = 1 12037 return true 12038 } 12039 // match: (IsInBounds (ZeroExt8to16 (Rsh8Ux64 _ (Const64 [c]))) (Const16 [d])) 12040 // cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d 12041 // result: (ConstBool [1]) 12042 for { 12043 _ = v.Args[1] 12044 v_0 := v.Args[0] 12045 if v_0.Op != OpZeroExt8to16 { 12046 break 12047 } 12048 v_0_0 := v_0.Args[0] 12049 if v_0_0.Op != OpRsh8Ux64 { 12050 break 12051 } 12052 _ = v_0_0.Args[1] 12053 v_0_0_1 := v_0_0.Args[1] 12054 if v_0_0_1.Op != OpConst64 { 12055 break 12056 } 12057 c := v_0_0_1.AuxInt 12058 v_1 := v.Args[1] 12059 if v_1.Op != OpConst16 { 12060 break 12061 } 12062 d := v_1.AuxInt 12063 if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) { 12064 break 12065 } 12066 v.reset(OpConstBool) 12067 v.AuxInt = 1 12068 return true 12069 } 12070 // match: (IsInBounds (Rsh8Ux64 _ (Const64 [c])) (Const64 [d])) 12071 // cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d 12072 // result: (ConstBool [1]) 12073 for { 12074 _ = v.Args[1] 12075 v_0 := v.Args[0] 12076 if v_0.Op != OpRsh8Ux64 { 12077 break 12078 } 12079 _ = v_0.Args[1] 12080 v_0_1 := v_0.Args[1] 12081 if v_0_1.Op != OpConst64 { 12082 break 12083 } 12084 c := v_0_1.AuxInt 12085 v_1 := v.Args[1] 12086 if v_1.Op != OpConst64 { 12087 break 12088 } 12089 d := v_1.AuxInt 12090 if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) { 12091 break 12092 } 12093 v.reset(OpConstBool) 12094 v.AuxInt = 1 12095 return true 12096 } 12097 // match: (IsInBounds (ZeroExt16to64 (Rsh16Ux64 _ (Const64 [c]))) (Const64 [d])) 12098 // cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d 12099 // result: (ConstBool [1]) 12100 for { 12101 _ = v.Args[1] 12102 v_0 := v.Args[0] 12103 if v_0.Op != OpZeroExt16to64 { 12104 break 12105 } 12106 v_0_0 := v_0.Args[0] 12107 if v_0_0.Op != OpRsh16Ux64 { 12108 break 12109 } 12110 _ = v_0_0.Args[1] 12111 v_0_0_1 := v_0_0.Args[1] 12112 if v_0_0_1.Op != OpConst64 { 12113 break 12114 } 12115 c := v_0_0_1.AuxInt 12116 v_1 := v.Args[1] 12117 if v_1.Op != OpConst64 { 12118 break 12119 } 12120 d := v_1.AuxInt 12121 if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) { 12122 break 12123 } 12124 v.reset(OpConstBool) 12125 v.AuxInt = 1 12126 return true 12127 } 12128 // match: (IsInBounds (ZeroExt16to32 (Rsh16Ux64 _ (Const64 [c]))) (Const64 [d])) 12129 // cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d 12130 // result: (ConstBool [1]) 12131 for { 12132 _ = v.Args[1] 12133 v_0 := v.Args[0] 12134 if v_0.Op != OpZeroExt16to32 { 12135 break 12136 } 12137 v_0_0 := v_0.Args[0] 12138 if v_0_0.Op != OpRsh16Ux64 { 12139 break 12140 } 12141 _ = v_0_0.Args[1] 12142 v_0_0_1 := v_0_0.Args[1] 12143 if v_0_0_1.Op != OpConst64 { 12144 break 12145 } 12146 c := v_0_0_1.AuxInt 12147 v_1 := v.Args[1] 12148 if v_1.Op != OpConst64 { 12149 break 12150 } 12151 d := v_1.AuxInt 12152 if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) { 12153 break 12154 } 12155 v.reset(OpConstBool) 12156 v.AuxInt = 1 12157 return true 12158 } 12159 // match: (IsInBounds (Rsh16Ux64 _ (Const64 [c])) (Const64 [d])) 12160 // cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d 12161 // result: (ConstBool [1]) 12162 for { 12163 _ = v.Args[1] 12164 v_0 := v.Args[0] 12165 if v_0.Op != OpRsh16Ux64 { 12166 break 12167 } 12168 _ = v_0.Args[1] 12169 v_0_1 := v_0.Args[1] 12170 if v_0_1.Op != OpConst64 { 12171 break 12172 } 12173 c := v_0_1.AuxInt 12174 v_1 := v.Args[1] 12175 if v_1.Op != OpConst64 { 12176 break 12177 } 12178 d := v_1.AuxInt 12179 if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) { 12180 break 12181 } 12182 v.reset(OpConstBool) 12183 v.AuxInt = 1 12184 return true 12185 } 12186 // match: (IsInBounds (ZeroExt32to64 (Rsh32Ux64 _ (Const64 [c]))) (Const64 [d])) 12187 // cond: 0 < c && c < 32 && 1<<uint(32-c)-1 < d 12188 // result: (ConstBool [1]) 12189 for { 12190 _ = v.Args[1] 12191 v_0 := v.Args[0] 12192 if v_0.Op != OpZeroExt32to64 { 12193 break 12194 } 12195 v_0_0 := v_0.Args[0] 12196 if v_0_0.Op != OpRsh32Ux64 { 12197 break 12198 } 12199 _ = v_0_0.Args[1] 12200 v_0_0_1 := v_0_0.Args[1] 12201 if v_0_0_1.Op != OpConst64 { 12202 break 12203 } 12204 c := v_0_0_1.AuxInt 12205 v_1 := v.Args[1] 12206 if v_1.Op != OpConst64 { 12207 break 12208 } 12209 d := v_1.AuxInt 12210 if !(0 < c && c < 32 && 1<<uint(32-c)-1 < d) { 12211 break 12212 } 12213 v.reset(OpConstBool) 12214 v.AuxInt = 1 12215 return true 12216 } 12217 // match: (IsInBounds (Rsh32Ux64 _ (Const64 [c])) (Const64 [d])) 12218 // cond: 0 < c && c < 32 && 1<<uint(32-c)-1 < d 12219 // result: (ConstBool [1]) 12220 for { 12221 _ = v.Args[1] 12222 v_0 := v.Args[0] 12223 if v_0.Op != OpRsh32Ux64 { 12224 break 12225 } 12226 _ = v_0.Args[1] 12227 v_0_1 := v_0.Args[1] 12228 if v_0_1.Op != OpConst64 { 12229 break 12230 } 12231 c := v_0_1.AuxInt 12232 v_1 := v.Args[1] 12233 if v_1.Op != OpConst64 { 12234 break 12235 } 12236 d := v_1.AuxInt 12237 if !(0 < c && c < 32 && 1<<uint(32-c)-1 < d) { 12238 break 12239 } 12240 v.reset(OpConstBool) 12241 v.AuxInt = 1 12242 return true 12243 } 12244 // match: (IsInBounds (Rsh64Ux64 _ (Const64 [c])) (Const64 [d])) 12245 // cond: 0 < c && c < 64 && 1<<uint(64-c)-1 < d 12246 // result: (ConstBool [1]) 12247 for { 12248 _ = v.Args[1] 12249 v_0 := v.Args[0] 12250 if v_0.Op != OpRsh64Ux64 { 12251 break 12252 } 12253 _ = v_0.Args[1] 12254 v_0_1 := v_0.Args[1] 12255 if v_0_1.Op != OpConst64 { 12256 break 12257 } 12258 c := v_0_1.AuxInt 12259 v_1 := v.Args[1] 12260 if v_1.Op != OpConst64 { 12261 break 12262 } 12263 d := v_1.AuxInt 12264 if !(0 < c && c < 64 && 1<<uint(64-c)-1 < d) { 12265 break 12266 } 12267 v.reset(OpConstBool) 12268 v.AuxInt = 1 12269 return true 12270 } 12271 return false 12272 } 12273 func rewriteValuegeneric_OpIsNonNil_0(v *Value) bool { 12274 // match: (IsNonNil (ConstNil)) 12275 // cond: 12276 // result: (ConstBool [0]) 12277 for { 12278 v_0 := v.Args[0] 12279 if v_0.Op != OpConstNil { 12280 break 12281 } 12282 v.reset(OpConstBool) 12283 v.AuxInt = 0 12284 return true 12285 } 12286 // match: (IsNonNil (Const32 [c])) 12287 // cond: 12288 // result: (ConstBool [b2i(c != 0)]) 12289 for { 12290 v_0 := v.Args[0] 12291 if v_0.Op != OpConst32 { 12292 break 12293 } 12294 c := v_0.AuxInt 12295 v.reset(OpConstBool) 12296 v.AuxInt = b2i(c != 0) 12297 return true 12298 } 12299 // match: (IsNonNil (Const64 [c])) 12300 // cond: 12301 // result: (ConstBool [b2i(c != 0)]) 12302 for { 12303 v_0 := v.Args[0] 12304 if v_0.Op != OpConst64 { 12305 break 12306 } 12307 c := v_0.AuxInt 12308 v.reset(OpConstBool) 12309 v.AuxInt = b2i(c != 0) 12310 return true 12311 } 12312 // match: (IsNonNil (Addr _)) 12313 // cond: 12314 // result: (ConstBool [1]) 12315 for { 12316 v_0 := v.Args[0] 12317 if v_0.Op != OpAddr { 12318 break 12319 } 12320 v.reset(OpConstBool) 12321 v.AuxInt = 1 12322 return true 12323 } 12324 // match: (IsNonNil (LocalAddr _ _)) 12325 // cond: 12326 // result: (ConstBool [1]) 12327 for { 12328 v_0 := v.Args[0] 12329 if v_0.Op != OpLocalAddr { 12330 break 12331 } 12332 _ = v_0.Args[1] 12333 v.reset(OpConstBool) 12334 v.AuxInt = 1 12335 return true 12336 } 12337 return false 12338 } 12339 func rewriteValuegeneric_OpIsSliceInBounds_0(v *Value) bool { 12340 // match: (IsSliceInBounds x x) 12341 // cond: 12342 // result: (ConstBool [1]) 12343 for { 12344 _ = v.Args[1] 12345 x := v.Args[0] 12346 if x != v.Args[1] { 12347 break 12348 } 12349 v.reset(OpConstBool) 12350 v.AuxInt = 1 12351 return true 12352 } 12353 // match: (IsSliceInBounds (And32 (Const32 [c]) _) (Const32 [d])) 12354 // cond: 0 <= c && c <= d 12355 // result: (ConstBool [1]) 12356 for { 12357 _ = v.Args[1] 12358 v_0 := v.Args[0] 12359 if v_0.Op != OpAnd32 { 12360 break 12361 } 12362 _ = v_0.Args[1] 12363 v_0_0 := v_0.Args[0] 12364 if v_0_0.Op != OpConst32 { 12365 break 12366 } 12367 c := v_0_0.AuxInt 12368 v_1 := v.Args[1] 12369 if v_1.Op != OpConst32 { 12370 break 12371 } 12372 d := v_1.AuxInt 12373 if !(0 <= c && c <= d) { 12374 break 12375 } 12376 v.reset(OpConstBool) 12377 v.AuxInt = 1 12378 return true 12379 } 12380 // match: (IsSliceInBounds (And32 _ (Const32 [c])) (Const32 [d])) 12381 // cond: 0 <= c && c <= d 12382 // result: (ConstBool [1]) 12383 for { 12384 _ = v.Args[1] 12385 v_0 := v.Args[0] 12386 if v_0.Op != OpAnd32 { 12387 break 12388 } 12389 _ = v_0.Args[1] 12390 v_0_1 := v_0.Args[1] 12391 if v_0_1.Op != OpConst32 { 12392 break 12393 } 12394 c := v_0_1.AuxInt 12395 v_1 := v.Args[1] 12396 if v_1.Op != OpConst32 { 12397 break 12398 } 12399 d := v_1.AuxInt 12400 if !(0 <= c && c <= d) { 12401 break 12402 } 12403 v.reset(OpConstBool) 12404 v.AuxInt = 1 12405 return true 12406 } 12407 // match: (IsSliceInBounds (And64 (Const64 [c]) _) (Const64 [d])) 12408 // cond: 0 <= c && c <= d 12409 // result: (ConstBool [1]) 12410 for { 12411 _ = v.Args[1] 12412 v_0 := v.Args[0] 12413 if v_0.Op != OpAnd64 { 12414 break 12415 } 12416 _ = v_0.Args[1] 12417 v_0_0 := v_0.Args[0] 12418 if v_0_0.Op != OpConst64 { 12419 break 12420 } 12421 c := v_0_0.AuxInt 12422 v_1 := v.Args[1] 12423 if v_1.Op != OpConst64 { 12424 break 12425 } 12426 d := v_1.AuxInt 12427 if !(0 <= c && c <= d) { 12428 break 12429 } 12430 v.reset(OpConstBool) 12431 v.AuxInt = 1 12432 return true 12433 } 12434 // match: (IsSliceInBounds (And64 _ (Const64 [c])) (Const64 [d])) 12435 // cond: 0 <= c && c <= d 12436 // result: (ConstBool [1]) 12437 for { 12438 _ = v.Args[1] 12439 v_0 := v.Args[0] 12440 if v_0.Op != OpAnd64 { 12441 break 12442 } 12443 _ = v_0.Args[1] 12444 v_0_1 := v_0.Args[1] 12445 if v_0_1.Op != OpConst64 { 12446 break 12447 } 12448 c := v_0_1.AuxInt 12449 v_1 := v.Args[1] 12450 if v_1.Op != OpConst64 { 12451 break 12452 } 12453 d := v_1.AuxInt 12454 if !(0 <= c && c <= d) { 12455 break 12456 } 12457 v.reset(OpConstBool) 12458 v.AuxInt = 1 12459 return true 12460 } 12461 // match: (IsSliceInBounds (Const32 [0]) _) 12462 // cond: 12463 // result: (ConstBool [1]) 12464 for { 12465 _ = v.Args[1] 12466 v_0 := v.Args[0] 12467 if v_0.Op != OpConst32 { 12468 break 12469 } 12470 if v_0.AuxInt != 0 { 12471 break 12472 } 12473 v.reset(OpConstBool) 12474 v.AuxInt = 1 12475 return true 12476 } 12477 // match: (IsSliceInBounds (Const64 [0]) _) 12478 // cond: 12479 // result: (ConstBool [1]) 12480 for { 12481 _ = v.Args[1] 12482 v_0 := v.Args[0] 12483 if v_0.Op != OpConst64 { 12484 break 12485 } 12486 if v_0.AuxInt != 0 { 12487 break 12488 } 12489 v.reset(OpConstBool) 12490 v.AuxInt = 1 12491 return true 12492 } 12493 // match: (IsSliceInBounds (Const32 [c]) (Const32 [d])) 12494 // cond: 12495 // result: (ConstBool [b2i(0 <= c && c <= d)]) 12496 for { 12497 _ = v.Args[1] 12498 v_0 := v.Args[0] 12499 if v_0.Op != OpConst32 { 12500 break 12501 } 12502 c := v_0.AuxInt 12503 v_1 := v.Args[1] 12504 if v_1.Op != OpConst32 { 12505 break 12506 } 12507 d := v_1.AuxInt 12508 v.reset(OpConstBool) 12509 v.AuxInt = b2i(0 <= c && c <= d) 12510 return true 12511 } 12512 // match: (IsSliceInBounds (Const64 [c]) (Const64 [d])) 12513 // cond: 12514 // result: (ConstBool [b2i(0 <= c && c <= d)]) 12515 for { 12516 _ = v.Args[1] 12517 v_0 := v.Args[0] 12518 if v_0.Op != OpConst64 { 12519 break 12520 } 12521 c := v_0.AuxInt 12522 v_1 := v.Args[1] 12523 if v_1.Op != OpConst64 { 12524 break 12525 } 12526 d := v_1.AuxInt 12527 v.reset(OpConstBool) 12528 v.AuxInt = b2i(0 <= c && c <= d) 12529 return true 12530 } 12531 // match: (IsSliceInBounds (SliceLen x) (SliceCap x)) 12532 // cond: 12533 // result: (ConstBool [1]) 12534 for { 12535 _ = v.Args[1] 12536 v_0 := v.Args[0] 12537 if v_0.Op != OpSliceLen { 12538 break 12539 } 12540 x := v_0.Args[0] 12541 v_1 := v.Args[1] 12542 if v_1.Op != OpSliceCap { 12543 break 12544 } 12545 if x != v_1.Args[0] { 12546 break 12547 } 12548 v.reset(OpConstBool) 12549 v.AuxInt = 1 12550 return true 12551 } 12552 return false 12553 } 12554 func rewriteValuegeneric_OpLeq16_0(v *Value) bool { 12555 // match: (Leq16 (Const16 [c]) (Const16 [d])) 12556 // cond: 12557 // result: (ConstBool [b2i(c <= d)]) 12558 for { 12559 _ = v.Args[1] 12560 v_0 := v.Args[0] 12561 if v_0.Op != OpConst16 { 12562 break 12563 } 12564 c := v_0.AuxInt 12565 v_1 := v.Args[1] 12566 if v_1.Op != OpConst16 { 12567 break 12568 } 12569 d := v_1.AuxInt 12570 v.reset(OpConstBool) 12571 v.AuxInt = b2i(c <= d) 12572 return true 12573 } 12574 return false 12575 } 12576 func rewriteValuegeneric_OpLeq16U_0(v *Value) bool { 12577 // match: (Leq16U (Const16 [c]) (Const16 [d])) 12578 // cond: 12579 // result: (ConstBool [b2i(uint16(c) <= uint16(d))]) 12580 for { 12581 _ = v.Args[1] 12582 v_0 := v.Args[0] 12583 if v_0.Op != OpConst16 { 12584 break 12585 } 12586 c := v_0.AuxInt 12587 v_1 := v.Args[1] 12588 if v_1.Op != OpConst16 { 12589 break 12590 } 12591 d := v_1.AuxInt 12592 v.reset(OpConstBool) 12593 v.AuxInt = b2i(uint16(c) <= uint16(d)) 12594 return true 12595 } 12596 return false 12597 } 12598 func rewriteValuegeneric_OpLeq32_0(v *Value) bool { 12599 // match: (Leq32 (Const32 [c]) (Const32 [d])) 12600 // cond: 12601 // result: (ConstBool [b2i(c <= d)]) 12602 for { 12603 _ = v.Args[1] 12604 v_0 := v.Args[0] 12605 if v_0.Op != OpConst32 { 12606 break 12607 } 12608 c := v_0.AuxInt 12609 v_1 := v.Args[1] 12610 if v_1.Op != OpConst32 { 12611 break 12612 } 12613 d := v_1.AuxInt 12614 v.reset(OpConstBool) 12615 v.AuxInt = b2i(c <= d) 12616 return true 12617 } 12618 return false 12619 } 12620 func rewriteValuegeneric_OpLeq32F_0(v *Value) bool { 12621 // match: (Leq32F (Const32F [c]) (Const32F [d])) 12622 // cond: 12623 // result: (ConstBool [b2i(auxTo32F(c) <= auxTo32F(d))]) 12624 for { 12625 _ = v.Args[1] 12626 v_0 := v.Args[0] 12627 if v_0.Op != OpConst32F { 12628 break 12629 } 12630 c := v_0.AuxInt 12631 v_1 := v.Args[1] 12632 if v_1.Op != OpConst32F { 12633 break 12634 } 12635 d := v_1.AuxInt 12636 v.reset(OpConstBool) 12637 v.AuxInt = b2i(auxTo32F(c) <= auxTo32F(d)) 12638 return true 12639 } 12640 return false 12641 } 12642 func rewriteValuegeneric_OpLeq32U_0(v *Value) bool { 12643 // match: (Leq32U (Const32 [c]) (Const32 [d])) 12644 // cond: 12645 // result: (ConstBool [b2i(uint32(c) <= uint32(d))]) 12646 for { 12647 _ = v.Args[1] 12648 v_0 := v.Args[0] 12649 if v_0.Op != OpConst32 { 12650 break 12651 } 12652 c := v_0.AuxInt 12653 v_1 := v.Args[1] 12654 if v_1.Op != OpConst32 { 12655 break 12656 } 12657 d := v_1.AuxInt 12658 v.reset(OpConstBool) 12659 v.AuxInt = b2i(uint32(c) <= uint32(d)) 12660 return true 12661 } 12662 return false 12663 } 12664 func rewriteValuegeneric_OpLeq64_0(v *Value) bool { 12665 // match: (Leq64 (Const64 [c]) (Const64 [d])) 12666 // cond: 12667 // result: (ConstBool [b2i(c <= d)]) 12668 for { 12669 _ = v.Args[1] 12670 v_0 := v.Args[0] 12671 if v_0.Op != OpConst64 { 12672 break 12673 } 12674 c := v_0.AuxInt 12675 v_1 := v.Args[1] 12676 if v_1.Op != OpConst64 { 12677 break 12678 } 12679 d := v_1.AuxInt 12680 v.reset(OpConstBool) 12681 v.AuxInt = b2i(c <= d) 12682 return true 12683 } 12684 return false 12685 } 12686 func rewriteValuegeneric_OpLeq64F_0(v *Value) bool { 12687 // match: (Leq64F (Const64F [c]) (Const64F [d])) 12688 // cond: 12689 // result: (ConstBool [b2i(auxTo64F(c) <= auxTo64F(d))]) 12690 for { 12691 _ = v.Args[1] 12692 v_0 := v.Args[0] 12693 if v_0.Op != OpConst64F { 12694 break 12695 } 12696 c := v_0.AuxInt 12697 v_1 := v.Args[1] 12698 if v_1.Op != OpConst64F { 12699 break 12700 } 12701 d := v_1.AuxInt 12702 v.reset(OpConstBool) 12703 v.AuxInt = b2i(auxTo64F(c) <= auxTo64F(d)) 12704 return true 12705 } 12706 return false 12707 } 12708 func rewriteValuegeneric_OpLeq64U_0(v *Value) bool { 12709 // match: (Leq64U (Const64 [c]) (Const64 [d])) 12710 // cond: 12711 // result: (ConstBool [b2i(uint64(c) <= uint64(d))]) 12712 for { 12713 _ = v.Args[1] 12714 v_0 := v.Args[0] 12715 if v_0.Op != OpConst64 { 12716 break 12717 } 12718 c := v_0.AuxInt 12719 v_1 := v.Args[1] 12720 if v_1.Op != OpConst64 { 12721 break 12722 } 12723 d := v_1.AuxInt 12724 v.reset(OpConstBool) 12725 v.AuxInt = b2i(uint64(c) <= uint64(d)) 12726 return true 12727 } 12728 return false 12729 } 12730 func rewriteValuegeneric_OpLeq8_0(v *Value) bool { 12731 // match: (Leq8 (Const8 [c]) (Const8 [d])) 12732 // cond: 12733 // result: (ConstBool [b2i(c <= d)]) 12734 for { 12735 _ = v.Args[1] 12736 v_0 := v.Args[0] 12737 if v_0.Op != OpConst8 { 12738 break 12739 } 12740 c := v_0.AuxInt 12741 v_1 := v.Args[1] 12742 if v_1.Op != OpConst8 { 12743 break 12744 } 12745 d := v_1.AuxInt 12746 v.reset(OpConstBool) 12747 v.AuxInt = b2i(c <= d) 12748 return true 12749 } 12750 return false 12751 } 12752 func rewriteValuegeneric_OpLeq8U_0(v *Value) bool { 12753 // match: (Leq8U (Const8 [c]) (Const8 [d])) 12754 // cond: 12755 // result: (ConstBool [b2i(uint8(c) <= uint8(d))]) 12756 for { 12757 _ = v.Args[1] 12758 v_0 := v.Args[0] 12759 if v_0.Op != OpConst8 { 12760 break 12761 } 12762 c := v_0.AuxInt 12763 v_1 := v.Args[1] 12764 if v_1.Op != OpConst8 { 12765 break 12766 } 12767 d := v_1.AuxInt 12768 v.reset(OpConstBool) 12769 v.AuxInt = b2i(uint8(c) <= uint8(d)) 12770 return true 12771 } 12772 return false 12773 } 12774 func rewriteValuegeneric_OpLess16_0(v *Value) bool { 12775 // match: (Less16 (Const16 [c]) (Const16 [d])) 12776 // cond: 12777 // result: (ConstBool [b2i(c < d)]) 12778 for { 12779 _ = v.Args[1] 12780 v_0 := v.Args[0] 12781 if v_0.Op != OpConst16 { 12782 break 12783 } 12784 c := v_0.AuxInt 12785 v_1 := v.Args[1] 12786 if v_1.Op != OpConst16 { 12787 break 12788 } 12789 d := v_1.AuxInt 12790 v.reset(OpConstBool) 12791 v.AuxInt = b2i(c < d) 12792 return true 12793 } 12794 return false 12795 } 12796 func rewriteValuegeneric_OpLess16U_0(v *Value) bool { 12797 // match: (Less16U (Const16 [c]) (Const16 [d])) 12798 // cond: 12799 // result: (ConstBool [b2i(uint16(c) < uint16(d))]) 12800 for { 12801 _ = v.Args[1] 12802 v_0 := v.Args[0] 12803 if v_0.Op != OpConst16 { 12804 break 12805 } 12806 c := v_0.AuxInt 12807 v_1 := v.Args[1] 12808 if v_1.Op != OpConst16 { 12809 break 12810 } 12811 d := v_1.AuxInt 12812 v.reset(OpConstBool) 12813 v.AuxInt = b2i(uint16(c) < uint16(d)) 12814 return true 12815 } 12816 return false 12817 } 12818 func rewriteValuegeneric_OpLess32_0(v *Value) bool { 12819 // match: (Less32 (Const32 [c]) (Const32 [d])) 12820 // cond: 12821 // result: (ConstBool [b2i(c < d)]) 12822 for { 12823 _ = v.Args[1] 12824 v_0 := v.Args[0] 12825 if v_0.Op != OpConst32 { 12826 break 12827 } 12828 c := v_0.AuxInt 12829 v_1 := v.Args[1] 12830 if v_1.Op != OpConst32 { 12831 break 12832 } 12833 d := v_1.AuxInt 12834 v.reset(OpConstBool) 12835 v.AuxInt = b2i(c < d) 12836 return true 12837 } 12838 return false 12839 } 12840 func rewriteValuegeneric_OpLess32F_0(v *Value) bool { 12841 // match: (Less32F (Const32F [c]) (Const32F [d])) 12842 // cond: 12843 // result: (ConstBool [b2i(auxTo32F(c) < auxTo32F(d))]) 12844 for { 12845 _ = v.Args[1] 12846 v_0 := v.Args[0] 12847 if v_0.Op != OpConst32F { 12848 break 12849 } 12850 c := v_0.AuxInt 12851 v_1 := v.Args[1] 12852 if v_1.Op != OpConst32F { 12853 break 12854 } 12855 d := v_1.AuxInt 12856 v.reset(OpConstBool) 12857 v.AuxInt = b2i(auxTo32F(c) < auxTo32F(d)) 12858 return true 12859 } 12860 return false 12861 } 12862 func rewriteValuegeneric_OpLess32U_0(v *Value) bool { 12863 // match: (Less32U (Const32 [c]) (Const32 [d])) 12864 // cond: 12865 // result: (ConstBool [b2i(uint32(c) < uint32(d))]) 12866 for { 12867 _ = v.Args[1] 12868 v_0 := v.Args[0] 12869 if v_0.Op != OpConst32 { 12870 break 12871 } 12872 c := v_0.AuxInt 12873 v_1 := v.Args[1] 12874 if v_1.Op != OpConst32 { 12875 break 12876 } 12877 d := v_1.AuxInt 12878 v.reset(OpConstBool) 12879 v.AuxInt = b2i(uint32(c) < uint32(d)) 12880 return true 12881 } 12882 return false 12883 } 12884 func rewriteValuegeneric_OpLess64_0(v *Value) bool { 12885 // match: (Less64 (Const64 [c]) (Const64 [d])) 12886 // cond: 12887 // result: (ConstBool [b2i(c < d)]) 12888 for { 12889 _ = v.Args[1] 12890 v_0 := v.Args[0] 12891 if v_0.Op != OpConst64 { 12892 break 12893 } 12894 c := v_0.AuxInt 12895 v_1 := v.Args[1] 12896 if v_1.Op != OpConst64 { 12897 break 12898 } 12899 d := v_1.AuxInt 12900 v.reset(OpConstBool) 12901 v.AuxInt = b2i(c < d) 12902 return true 12903 } 12904 return false 12905 } 12906 func rewriteValuegeneric_OpLess64F_0(v *Value) bool { 12907 // match: (Less64F (Const64F [c]) (Const64F [d])) 12908 // cond: 12909 // result: (ConstBool [b2i(auxTo64F(c) < auxTo64F(d))]) 12910 for { 12911 _ = v.Args[1] 12912 v_0 := v.Args[0] 12913 if v_0.Op != OpConst64F { 12914 break 12915 } 12916 c := v_0.AuxInt 12917 v_1 := v.Args[1] 12918 if v_1.Op != OpConst64F { 12919 break 12920 } 12921 d := v_1.AuxInt 12922 v.reset(OpConstBool) 12923 v.AuxInt = b2i(auxTo64F(c) < auxTo64F(d)) 12924 return true 12925 } 12926 return false 12927 } 12928 func rewriteValuegeneric_OpLess64U_0(v *Value) bool { 12929 // match: (Less64U (Const64 [c]) (Const64 [d])) 12930 // cond: 12931 // result: (ConstBool [b2i(uint64(c) < uint64(d))]) 12932 for { 12933 _ = v.Args[1] 12934 v_0 := v.Args[0] 12935 if v_0.Op != OpConst64 { 12936 break 12937 } 12938 c := v_0.AuxInt 12939 v_1 := v.Args[1] 12940 if v_1.Op != OpConst64 { 12941 break 12942 } 12943 d := v_1.AuxInt 12944 v.reset(OpConstBool) 12945 v.AuxInt = b2i(uint64(c) < uint64(d)) 12946 return true 12947 } 12948 return false 12949 } 12950 func rewriteValuegeneric_OpLess8_0(v *Value) bool { 12951 // match: (Less8 (Const8 [c]) (Const8 [d])) 12952 // cond: 12953 // result: (ConstBool [b2i(c < d)]) 12954 for { 12955 _ = v.Args[1] 12956 v_0 := v.Args[0] 12957 if v_0.Op != OpConst8 { 12958 break 12959 } 12960 c := v_0.AuxInt 12961 v_1 := v.Args[1] 12962 if v_1.Op != OpConst8 { 12963 break 12964 } 12965 d := v_1.AuxInt 12966 v.reset(OpConstBool) 12967 v.AuxInt = b2i(c < d) 12968 return true 12969 } 12970 return false 12971 } 12972 func rewriteValuegeneric_OpLess8U_0(v *Value) bool { 12973 // match: (Less8U (Const8 [c]) (Const8 [d])) 12974 // cond: 12975 // result: (ConstBool [b2i(uint8(c) < uint8(d))]) 12976 for { 12977 _ = v.Args[1] 12978 v_0 := v.Args[0] 12979 if v_0.Op != OpConst8 { 12980 break 12981 } 12982 c := v_0.AuxInt 12983 v_1 := v.Args[1] 12984 if v_1.Op != OpConst8 { 12985 break 12986 } 12987 d := v_1.AuxInt 12988 v.reset(OpConstBool) 12989 v.AuxInt = b2i(uint8(c) < uint8(d)) 12990 return true 12991 } 12992 return false 12993 } 12994 func rewriteValuegeneric_OpLoad_0(v *Value) bool { 12995 b := v.Block 12996 _ = b 12997 fe := b.Func.fe 12998 _ = fe 12999 // match: (Load <t1> p1 (Store {t2} p2 x _)) 13000 // cond: isSamePtr(p1, p2) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) 13001 // result: x 13002 for { 13003 t1 := v.Type 13004 _ = v.Args[1] 13005 p1 := v.Args[0] 13006 v_1 := v.Args[1] 13007 if v_1.Op != OpStore { 13008 break 13009 } 13010 t2 := v_1.Aux 13011 _ = v_1.Args[2] 13012 p2 := v_1.Args[0] 13013 x := v_1.Args[1] 13014 if !(isSamePtr(p1, p2) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2)) { 13015 break 13016 } 13017 v.reset(OpCopy) 13018 v.Type = x.Type 13019 v.AddArg(x) 13020 return true 13021 } 13022 // match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 x _))) 13023 // cond: isSamePtr(p1, p3) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p3, sizeof(t3), p2, sizeof(t2)) 13024 // result: x 13025 for { 13026 t1 := v.Type 13027 _ = v.Args[1] 13028 p1 := v.Args[0] 13029 v_1 := v.Args[1] 13030 if v_1.Op != OpStore { 13031 break 13032 } 13033 t2 := v_1.Aux 13034 _ = v_1.Args[2] 13035 p2 := v_1.Args[0] 13036 v_1_2 := v_1.Args[2] 13037 if v_1_2.Op != OpStore { 13038 break 13039 } 13040 t3 := v_1_2.Aux 13041 _ = v_1_2.Args[2] 13042 p3 := v_1_2.Args[0] 13043 x := v_1_2.Args[1] 13044 if !(isSamePtr(p1, p3) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p3, sizeof(t3), p2, sizeof(t2))) { 13045 break 13046 } 13047 v.reset(OpCopy) 13048 v.Type = x.Type 13049 v.AddArg(x) 13050 return true 13051 } 13052 // match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 x _)))) 13053 // cond: isSamePtr(p1, p4) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p4, sizeof(t4), p2, sizeof(t2)) && disjoint(p4, sizeof(t4), p3, sizeof(t3)) 13054 // result: x 13055 for { 13056 t1 := v.Type 13057 _ = v.Args[1] 13058 p1 := v.Args[0] 13059 v_1 := v.Args[1] 13060 if v_1.Op != OpStore { 13061 break 13062 } 13063 t2 := v_1.Aux 13064 _ = v_1.Args[2] 13065 p2 := v_1.Args[0] 13066 v_1_2 := v_1.Args[2] 13067 if v_1_2.Op != OpStore { 13068 break 13069 } 13070 t3 := v_1_2.Aux 13071 _ = v_1_2.Args[2] 13072 p3 := v_1_2.Args[0] 13073 v_1_2_2 := v_1_2.Args[2] 13074 if v_1_2_2.Op != OpStore { 13075 break 13076 } 13077 t4 := v_1_2_2.Aux 13078 _ = v_1_2_2.Args[2] 13079 p4 := v_1_2_2.Args[0] 13080 x := v_1_2_2.Args[1] 13081 if !(isSamePtr(p1, p4) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p4, sizeof(t4), p2, sizeof(t2)) && disjoint(p4, sizeof(t4), p3, sizeof(t3))) { 13082 break 13083 } 13084 v.reset(OpCopy) 13085 v.Type = x.Type 13086 v.AddArg(x) 13087 return true 13088 } 13089 // match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 x _))))) 13090 // cond: isSamePtr(p1, p5) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p5, sizeof(t5), p2, sizeof(t2)) && disjoint(p5, sizeof(t5), p3, sizeof(t3)) && disjoint(p5, sizeof(t5), p4, sizeof(t4)) 13091 // result: x 13092 for { 13093 t1 := v.Type 13094 _ = v.Args[1] 13095 p1 := v.Args[0] 13096 v_1 := v.Args[1] 13097 if v_1.Op != OpStore { 13098 break 13099 } 13100 t2 := v_1.Aux 13101 _ = v_1.Args[2] 13102 p2 := v_1.Args[0] 13103 v_1_2 := v_1.Args[2] 13104 if v_1_2.Op != OpStore { 13105 break 13106 } 13107 t3 := v_1_2.Aux 13108 _ = v_1_2.Args[2] 13109 p3 := v_1_2.Args[0] 13110 v_1_2_2 := v_1_2.Args[2] 13111 if v_1_2_2.Op != OpStore { 13112 break 13113 } 13114 t4 := v_1_2_2.Aux 13115 _ = v_1_2_2.Args[2] 13116 p4 := v_1_2_2.Args[0] 13117 v_1_2_2_2 := v_1_2_2.Args[2] 13118 if v_1_2_2_2.Op != OpStore { 13119 break 13120 } 13121 t5 := v_1_2_2_2.Aux 13122 _ = v_1_2_2_2.Args[2] 13123 p5 := v_1_2_2_2.Args[0] 13124 x := v_1_2_2_2.Args[1] 13125 if !(isSamePtr(p1, p5) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p5, sizeof(t5), p2, sizeof(t2)) && disjoint(p5, sizeof(t5), p3, sizeof(t3)) && disjoint(p5, sizeof(t5), p4, sizeof(t4))) { 13126 break 13127 } 13128 v.reset(OpCopy) 13129 v.Type = x.Type 13130 v.AddArg(x) 13131 return true 13132 } 13133 // match: (Load <t1> p1 (Store {t2} p2 (Const64 [x]) _)) 13134 // cond: isSamePtr(p1,p2) && sizeof(t2) == 8 && is64BitFloat(t1) 13135 // result: (Const64F [x]) 13136 for { 13137 t1 := v.Type 13138 _ = v.Args[1] 13139 p1 := v.Args[0] 13140 v_1 := v.Args[1] 13141 if v_1.Op != OpStore { 13142 break 13143 } 13144 t2 := v_1.Aux 13145 _ = v_1.Args[2] 13146 p2 := v_1.Args[0] 13147 v_1_1 := v_1.Args[1] 13148 if v_1_1.Op != OpConst64 { 13149 break 13150 } 13151 x := v_1_1.AuxInt 13152 if !(isSamePtr(p1, p2) && sizeof(t2) == 8 && is64BitFloat(t1)) { 13153 break 13154 } 13155 v.reset(OpConst64F) 13156 v.AuxInt = x 13157 return true 13158 } 13159 // match: (Load <t1> p1 (Store {t2} p2 (Const32 [x]) _)) 13160 // cond: isSamePtr(p1,p2) && sizeof(t2) == 4 && is32BitFloat(t1) 13161 // result: (Const32F [auxFrom32F(math.Float32frombits(uint32(x)))]) 13162 for { 13163 t1 := v.Type 13164 _ = v.Args[1] 13165 p1 := v.Args[0] 13166 v_1 := v.Args[1] 13167 if v_1.Op != OpStore { 13168 break 13169 } 13170 t2 := v_1.Aux 13171 _ = v_1.Args[2] 13172 p2 := v_1.Args[0] 13173 v_1_1 := v_1.Args[1] 13174 if v_1_1.Op != OpConst32 { 13175 break 13176 } 13177 x := v_1_1.AuxInt 13178 if !(isSamePtr(p1, p2) && sizeof(t2) == 4 && is32BitFloat(t1)) { 13179 break 13180 } 13181 v.reset(OpConst32F) 13182 v.AuxInt = auxFrom32F(math.Float32frombits(uint32(x))) 13183 return true 13184 } 13185 // match: (Load <t1> p1 (Store {t2} p2 (Const64F [x]) _)) 13186 // cond: isSamePtr(p1,p2) && sizeof(t2) == 8 && is64BitInt(t1) 13187 // result: (Const64 [x]) 13188 for { 13189 t1 := v.Type 13190 _ = v.Args[1] 13191 p1 := v.Args[0] 13192 v_1 := v.Args[1] 13193 if v_1.Op != OpStore { 13194 break 13195 } 13196 t2 := v_1.Aux 13197 _ = v_1.Args[2] 13198 p2 := v_1.Args[0] 13199 v_1_1 := v_1.Args[1] 13200 if v_1_1.Op != OpConst64F { 13201 break 13202 } 13203 x := v_1_1.AuxInt 13204 if !(isSamePtr(p1, p2) && sizeof(t2) == 8 && is64BitInt(t1)) { 13205 break 13206 } 13207 v.reset(OpConst64) 13208 v.AuxInt = x 13209 return true 13210 } 13211 // match: (Load <t1> p1 (Store {t2} p2 (Const32F [x]) _)) 13212 // cond: isSamePtr(p1,p2) && sizeof(t2) == 4 && is32BitInt(t1) 13213 // result: (Const32 [int64(int32(math.Float32bits(auxTo32F(x))))]) 13214 for { 13215 t1 := v.Type 13216 _ = v.Args[1] 13217 p1 := v.Args[0] 13218 v_1 := v.Args[1] 13219 if v_1.Op != OpStore { 13220 break 13221 } 13222 t2 := v_1.Aux 13223 _ = v_1.Args[2] 13224 p2 := v_1.Args[0] 13225 v_1_1 := v_1.Args[1] 13226 if v_1_1.Op != OpConst32F { 13227 break 13228 } 13229 x := v_1_1.AuxInt 13230 if !(isSamePtr(p1, p2) && sizeof(t2) == 4 && is32BitInt(t1)) { 13231 break 13232 } 13233 v.reset(OpConst32) 13234 v.AuxInt = int64(int32(math.Float32bits(auxTo32F(x)))) 13235 return true 13236 } 13237 // match: (Load <t1> op:(OffPtr [o1] p1) (Store {t2} p2 _ mem:(Zero [n] p3 _))) 13238 // cond: o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p3) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) 13239 // result: @mem.Block (Load <t1> (OffPtr <op.Type> [o1] p3) mem) 13240 for { 13241 t1 := v.Type 13242 _ = v.Args[1] 13243 op := v.Args[0] 13244 if op.Op != OpOffPtr { 13245 break 13246 } 13247 o1 := op.AuxInt 13248 p1 := op.Args[0] 13249 v_1 := v.Args[1] 13250 if v_1.Op != OpStore { 13251 break 13252 } 13253 t2 := v_1.Aux 13254 _ = v_1.Args[2] 13255 p2 := v_1.Args[0] 13256 mem := v_1.Args[2] 13257 if mem.Op != OpZero { 13258 break 13259 } 13260 n := mem.AuxInt 13261 _ = mem.Args[1] 13262 p3 := mem.Args[0] 13263 if !(o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p3) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2))) { 13264 break 13265 } 13266 b = mem.Block 13267 v0 := b.NewValue0(v.Pos, OpLoad, t1) 13268 v.reset(OpCopy) 13269 v.AddArg(v0) 13270 v1 := b.NewValue0(v.Pos, OpOffPtr, op.Type) 13271 v1.AuxInt = o1 13272 v1.AddArg(p3) 13273 v0.AddArg(v1) 13274 v0.AddArg(mem) 13275 return true 13276 } 13277 // match: (Load <t1> op:(OffPtr [o1] p1) (Store {t2} p2 _ (Store {t3} p3 _ mem:(Zero [n] p4 _)))) 13278 // cond: o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p4) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3)) 13279 // result: @mem.Block (Load <t1> (OffPtr <op.Type> [o1] p4) mem) 13280 for { 13281 t1 := v.Type 13282 _ = v.Args[1] 13283 op := v.Args[0] 13284 if op.Op != OpOffPtr { 13285 break 13286 } 13287 o1 := op.AuxInt 13288 p1 := op.Args[0] 13289 v_1 := v.Args[1] 13290 if v_1.Op != OpStore { 13291 break 13292 } 13293 t2 := v_1.Aux 13294 _ = v_1.Args[2] 13295 p2 := v_1.Args[0] 13296 v_1_2 := v_1.Args[2] 13297 if v_1_2.Op != OpStore { 13298 break 13299 } 13300 t3 := v_1_2.Aux 13301 _ = v_1_2.Args[2] 13302 p3 := v_1_2.Args[0] 13303 mem := v_1_2.Args[2] 13304 if mem.Op != OpZero { 13305 break 13306 } 13307 n := mem.AuxInt 13308 _ = mem.Args[1] 13309 p4 := mem.Args[0] 13310 if !(o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p4) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3))) { 13311 break 13312 } 13313 b = mem.Block 13314 v0 := b.NewValue0(v.Pos, OpLoad, t1) 13315 v.reset(OpCopy) 13316 v.AddArg(v0) 13317 v1 := b.NewValue0(v.Pos, OpOffPtr, op.Type) 13318 v1.AuxInt = o1 13319 v1.AddArg(p4) 13320 v0.AddArg(v1) 13321 v0.AddArg(mem) 13322 return true 13323 } 13324 return false 13325 } 13326 func rewriteValuegeneric_OpLoad_10(v *Value) bool { 13327 b := v.Block 13328 _ = b 13329 fe := b.Func.fe 13330 _ = fe 13331 // match: (Load <t1> op:(OffPtr [o1] p1) (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ mem:(Zero [n] p5 _))))) 13332 // cond: o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p5) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3)) && disjoint(op, t1.Size(), p4, sizeof(t4)) 13333 // result: @mem.Block (Load <t1> (OffPtr <op.Type> [o1] p5) mem) 13334 for { 13335 t1 := v.Type 13336 _ = v.Args[1] 13337 op := v.Args[0] 13338 if op.Op != OpOffPtr { 13339 break 13340 } 13341 o1 := op.AuxInt 13342 p1 := op.Args[0] 13343 v_1 := v.Args[1] 13344 if v_1.Op != OpStore { 13345 break 13346 } 13347 t2 := v_1.Aux 13348 _ = v_1.Args[2] 13349 p2 := v_1.Args[0] 13350 v_1_2 := v_1.Args[2] 13351 if v_1_2.Op != OpStore { 13352 break 13353 } 13354 t3 := v_1_2.Aux 13355 _ = v_1_2.Args[2] 13356 p3 := v_1_2.Args[0] 13357 v_1_2_2 := v_1_2.Args[2] 13358 if v_1_2_2.Op != OpStore { 13359 break 13360 } 13361 t4 := v_1_2_2.Aux 13362 _ = v_1_2_2.Args[2] 13363 p4 := v_1_2_2.Args[0] 13364 mem := v_1_2_2.Args[2] 13365 if mem.Op != OpZero { 13366 break 13367 } 13368 n := mem.AuxInt 13369 _ = mem.Args[1] 13370 p5 := mem.Args[0] 13371 if !(o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p5) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3)) && disjoint(op, t1.Size(), p4, sizeof(t4))) { 13372 break 13373 } 13374 b = mem.Block 13375 v0 := b.NewValue0(v.Pos, OpLoad, t1) 13376 v.reset(OpCopy) 13377 v.AddArg(v0) 13378 v1 := b.NewValue0(v.Pos, OpOffPtr, op.Type) 13379 v1.AuxInt = o1 13380 v1.AddArg(p5) 13381 v0.AddArg(v1) 13382 v0.AddArg(mem) 13383 return true 13384 } 13385 // match: (Load <t1> op:(OffPtr [o1] p1) (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 _ mem:(Zero [n] p6 _)))))) 13386 // cond: o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p6) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3)) && disjoint(op, t1.Size(), p4, sizeof(t4)) && disjoint(op, t1.Size(), p5, sizeof(t5)) 13387 // result: @mem.Block (Load <t1> (OffPtr <op.Type> [o1] p6) mem) 13388 for { 13389 t1 := v.Type 13390 _ = v.Args[1] 13391 op := v.Args[0] 13392 if op.Op != OpOffPtr { 13393 break 13394 } 13395 o1 := op.AuxInt 13396 p1 := op.Args[0] 13397 v_1 := v.Args[1] 13398 if v_1.Op != OpStore { 13399 break 13400 } 13401 t2 := v_1.Aux 13402 _ = v_1.Args[2] 13403 p2 := v_1.Args[0] 13404 v_1_2 := v_1.Args[2] 13405 if v_1_2.Op != OpStore { 13406 break 13407 } 13408 t3 := v_1_2.Aux 13409 _ = v_1_2.Args[2] 13410 p3 := v_1_2.Args[0] 13411 v_1_2_2 := v_1_2.Args[2] 13412 if v_1_2_2.Op != OpStore { 13413 break 13414 } 13415 t4 := v_1_2_2.Aux 13416 _ = v_1_2_2.Args[2] 13417 p4 := v_1_2_2.Args[0] 13418 v_1_2_2_2 := v_1_2_2.Args[2] 13419 if v_1_2_2_2.Op != OpStore { 13420 break 13421 } 13422 t5 := v_1_2_2_2.Aux 13423 _ = v_1_2_2_2.Args[2] 13424 p5 := v_1_2_2_2.Args[0] 13425 mem := v_1_2_2_2.Args[2] 13426 if mem.Op != OpZero { 13427 break 13428 } 13429 n := mem.AuxInt 13430 _ = mem.Args[1] 13431 p6 := mem.Args[0] 13432 if !(o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p6) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3)) && disjoint(op, t1.Size(), p4, sizeof(t4)) && disjoint(op, t1.Size(), p5, sizeof(t5))) { 13433 break 13434 } 13435 b = mem.Block 13436 v0 := b.NewValue0(v.Pos, OpLoad, t1) 13437 v.reset(OpCopy) 13438 v.AddArg(v0) 13439 v1 := b.NewValue0(v.Pos, OpOffPtr, op.Type) 13440 v1.AuxInt = o1 13441 v1.AddArg(p6) 13442 v0.AddArg(v1) 13443 v0.AddArg(mem) 13444 return true 13445 } 13446 // match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _)) 13447 // cond: t1.IsBoolean() && isSamePtr(p1, p2) && n >= o + 1 13448 // result: (ConstBool [0]) 13449 for { 13450 t1 := v.Type 13451 _ = v.Args[1] 13452 v_0 := v.Args[0] 13453 if v_0.Op != OpOffPtr { 13454 break 13455 } 13456 o := v_0.AuxInt 13457 p1 := v_0.Args[0] 13458 v_1 := v.Args[1] 13459 if v_1.Op != OpZero { 13460 break 13461 } 13462 n := v_1.AuxInt 13463 _ = v_1.Args[1] 13464 p2 := v_1.Args[0] 13465 if !(t1.IsBoolean() && isSamePtr(p1, p2) && n >= o+1) { 13466 break 13467 } 13468 v.reset(OpConstBool) 13469 v.AuxInt = 0 13470 return true 13471 } 13472 // match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _)) 13473 // cond: is8BitInt(t1) && isSamePtr(p1, p2) && n >= o + 1 13474 // result: (Const8 [0]) 13475 for { 13476 t1 := v.Type 13477 _ = v.Args[1] 13478 v_0 := v.Args[0] 13479 if v_0.Op != OpOffPtr { 13480 break 13481 } 13482 o := v_0.AuxInt 13483 p1 := v_0.Args[0] 13484 v_1 := v.Args[1] 13485 if v_1.Op != OpZero { 13486 break 13487 } 13488 n := v_1.AuxInt 13489 _ = v_1.Args[1] 13490 p2 := v_1.Args[0] 13491 if !(is8BitInt(t1) && isSamePtr(p1, p2) && n >= o+1) { 13492 break 13493 } 13494 v.reset(OpConst8) 13495 v.AuxInt = 0 13496 return true 13497 } 13498 // match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _)) 13499 // cond: is16BitInt(t1) && isSamePtr(p1, p2) && n >= o + 2 13500 // result: (Const16 [0]) 13501 for { 13502 t1 := v.Type 13503 _ = v.Args[1] 13504 v_0 := v.Args[0] 13505 if v_0.Op != OpOffPtr { 13506 break 13507 } 13508 o := v_0.AuxInt 13509 p1 := v_0.Args[0] 13510 v_1 := v.Args[1] 13511 if v_1.Op != OpZero { 13512 break 13513 } 13514 n := v_1.AuxInt 13515 _ = v_1.Args[1] 13516 p2 := v_1.Args[0] 13517 if !(is16BitInt(t1) && isSamePtr(p1, p2) && n >= o+2) { 13518 break 13519 } 13520 v.reset(OpConst16) 13521 v.AuxInt = 0 13522 return true 13523 } 13524 // match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _)) 13525 // cond: is32BitInt(t1) && isSamePtr(p1, p2) && n >= o + 4 13526 // result: (Const32 [0]) 13527 for { 13528 t1 := v.Type 13529 _ = v.Args[1] 13530 v_0 := v.Args[0] 13531 if v_0.Op != OpOffPtr { 13532 break 13533 } 13534 o := v_0.AuxInt 13535 p1 := v_0.Args[0] 13536 v_1 := v.Args[1] 13537 if v_1.Op != OpZero { 13538 break 13539 } 13540 n := v_1.AuxInt 13541 _ = v_1.Args[1] 13542 p2 := v_1.Args[0] 13543 if !(is32BitInt(t1) && isSamePtr(p1, p2) && n >= o+4) { 13544 break 13545 } 13546 v.reset(OpConst32) 13547 v.AuxInt = 0 13548 return true 13549 } 13550 // match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _)) 13551 // cond: is64BitInt(t1) && isSamePtr(p1, p2) && n >= o + 8 13552 // result: (Const64 [0]) 13553 for { 13554 t1 := v.Type 13555 _ = v.Args[1] 13556 v_0 := v.Args[0] 13557 if v_0.Op != OpOffPtr { 13558 break 13559 } 13560 o := v_0.AuxInt 13561 p1 := v_0.Args[0] 13562 v_1 := v.Args[1] 13563 if v_1.Op != OpZero { 13564 break 13565 } 13566 n := v_1.AuxInt 13567 _ = v_1.Args[1] 13568 p2 := v_1.Args[0] 13569 if !(is64BitInt(t1) && isSamePtr(p1, p2) && n >= o+8) { 13570 break 13571 } 13572 v.reset(OpConst64) 13573 v.AuxInt = 0 13574 return true 13575 } 13576 // match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _)) 13577 // cond: is32BitFloat(t1) && isSamePtr(p1, p2) && n >= o + 4 13578 // result: (Const32F [0]) 13579 for { 13580 t1 := v.Type 13581 _ = v.Args[1] 13582 v_0 := v.Args[0] 13583 if v_0.Op != OpOffPtr { 13584 break 13585 } 13586 o := v_0.AuxInt 13587 p1 := v_0.Args[0] 13588 v_1 := v.Args[1] 13589 if v_1.Op != OpZero { 13590 break 13591 } 13592 n := v_1.AuxInt 13593 _ = v_1.Args[1] 13594 p2 := v_1.Args[0] 13595 if !(is32BitFloat(t1) && isSamePtr(p1, p2) && n >= o+4) { 13596 break 13597 } 13598 v.reset(OpConst32F) 13599 v.AuxInt = 0 13600 return true 13601 } 13602 // match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _)) 13603 // cond: is64BitFloat(t1) && isSamePtr(p1, p2) && n >= o + 8 13604 // result: (Const64F [0]) 13605 for { 13606 t1 := v.Type 13607 _ = v.Args[1] 13608 v_0 := v.Args[0] 13609 if v_0.Op != OpOffPtr { 13610 break 13611 } 13612 o := v_0.AuxInt 13613 p1 := v_0.Args[0] 13614 v_1 := v.Args[1] 13615 if v_1.Op != OpZero { 13616 break 13617 } 13618 n := v_1.AuxInt 13619 _ = v_1.Args[1] 13620 p2 := v_1.Args[0] 13621 if !(is64BitFloat(t1) && isSamePtr(p1, p2) && n >= o+8) { 13622 break 13623 } 13624 v.reset(OpConst64F) 13625 v.AuxInt = 0 13626 return true 13627 } 13628 // match: (Load <t> _ _) 13629 // cond: t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t) 13630 // result: (StructMake0) 13631 for { 13632 t := v.Type 13633 _ = v.Args[1] 13634 if !(t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t)) { 13635 break 13636 } 13637 v.reset(OpStructMake0) 13638 return true 13639 } 13640 return false 13641 } 13642 func rewriteValuegeneric_OpLoad_20(v *Value) bool { 13643 b := v.Block 13644 _ = b 13645 fe := b.Func.fe 13646 _ = fe 13647 // match: (Load <t> ptr mem) 13648 // cond: t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t) 13649 // result: (StructMake1 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem)) 13650 for { 13651 t := v.Type 13652 _ = v.Args[1] 13653 ptr := v.Args[0] 13654 mem := v.Args[1] 13655 if !(t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t)) { 13656 break 13657 } 13658 v.reset(OpStructMake1) 13659 v0 := b.NewValue0(v.Pos, OpLoad, t.FieldType(0)) 13660 v1 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo()) 13661 v1.AuxInt = 0 13662 v1.AddArg(ptr) 13663 v0.AddArg(v1) 13664 v0.AddArg(mem) 13665 v.AddArg(v0) 13666 return true 13667 } 13668 // match: (Load <t> ptr mem) 13669 // cond: t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t) 13670 // 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)) 13671 for { 13672 t := v.Type 13673 _ = v.Args[1] 13674 ptr := v.Args[0] 13675 mem := v.Args[1] 13676 if !(t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t)) { 13677 break 13678 } 13679 v.reset(OpStructMake2) 13680 v0 := b.NewValue0(v.Pos, OpLoad, t.FieldType(0)) 13681 v1 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo()) 13682 v1.AuxInt = 0 13683 v1.AddArg(ptr) 13684 v0.AddArg(v1) 13685 v0.AddArg(mem) 13686 v.AddArg(v0) 13687 v2 := b.NewValue0(v.Pos, OpLoad, t.FieldType(1)) 13688 v3 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo()) 13689 v3.AuxInt = t.FieldOff(1) 13690 v3.AddArg(ptr) 13691 v2.AddArg(v3) 13692 v2.AddArg(mem) 13693 v.AddArg(v2) 13694 return true 13695 } 13696 // match: (Load <t> ptr mem) 13697 // cond: t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t) 13698 // 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)) 13699 for { 13700 t := v.Type 13701 _ = v.Args[1] 13702 ptr := v.Args[0] 13703 mem := v.Args[1] 13704 if !(t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t)) { 13705 break 13706 } 13707 v.reset(OpStructMake3) 13708 v0 := b.NewValue0(v.Pos, OpLoad, t.FieldType(0)) 13709 v1 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo()) 13710 v1.AuxInt = 0 13711 v1.AddArg(ptr) 13712 v0.AddArg(v1) 13713 v0.AddArg(mem) 13714 v.AddArg(v0) 13715 v2 := b.NewValue0(v.Pos, OpLoad, t.FieldType(1)) 13716 v3 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo()) 13717 v3.AuxInt = t.FieldOff(1) 13718 v3.AddArg(ptr) 13719 v2.AddArg(v3) 13720 v2.AddArg(mem) 13721 v.AddArg(v2) 13722 v4 := b.NewValue0(v.Pos, OpLoad, t.FieldType(2)) 13723 v5 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo()) 13724 v5.AuxInt = t.FieldOff(2) 13725 v5.AddArg(ptr) 13726 v4.AddArg(v5) 13727 v4.AddArg(mem) 13728 v.AddArg(v4) 13729 return true 13730 } 13731 // match: (Load <t> ptr mem) 13732 // cond: t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t) 13733 // 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)) 13734 for { 13735 t := v.Type 13736 _ = v.Args[1] 13737 ptr := v.Args[0] 13738 mem := v.Args[1] 13739 if !(t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t)) { 13740 break 13741 } 13742 v.reset(OpStructMake4) 13743 v0 := b.NewValue0(v.Pos, OpLoad, t.FieldType(0)) 13744 v1 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo()) 13745 v1.AuxInt = 0 13746 v1.AddArg(ptr) 13747 v0.AddArg(v1) 13748 v0.AddArg(mem) 13749 v.AddArg(v0) 13750 v2 := b.NewValue0(v.Pos, OpLoad, t.FieldType(1)) 13751 v3 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo()) 13752 v3.AuxInt = t.FieldOff(1) 13753 v3.AddArg(ptr) 13754 v2.AddArg(v3) 13755 v2.AddArg(mem) 13756 v.AddArg(v2) 13757 v4 := b.NewValue0(v.Pos, OpLoad, t.FieldType(2)) 13758 v5 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo()) 13759 v5.AuxInt = t.FieldOff(2) 13760 v5.AddArg(ptr) 13761 v4.AddArg(v5) 13762 v4.AddArg(mem) 13763 v.AddArg(v4) 13764 v6 := b.NewValue0(v.Pos, OpLoad, t.FieldType(3)) 13765 v7 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(3).PtrTo()) 13766 v7.AuxInt = t.FieldOff(3) 13767 v7.AddArg(ptr) 13768 v6.AddArg(v7) 13769 v6.AddArg(mem) 13770 v.AddArg(v6) 13771 return true 13772 } 13773 // match: (Load <t> _ _) 13774 // cond: t.IsArray() && t.NumElem() == 0 13775 // result: (ArrayMake0) 13776 for { 13777 t := v.Type 13778 _ = v.Args[1] 13779 if !(t.IsArray() && t.NumElem() == 0) { 13780 break 13781 } 13782 v.reset(OpArrayMake0) 13783 return true 13784 } 13785 // match: (Load <t> ptr mem) 13786 // cond: t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t) 13787 // result: (ArrayMake1 (Load <t.Elem()> ptr mem)) 13788 for { 13789 t := v.Type 13790 _ = v.Args[1] 13791 ptr := v.Args[0] 13792 mem := v.Args[1] 13793 if !(t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t)) { 13794 break 13795 } 13796 v.reset(OpArrayMake1) 13797 v0 := b.NewValue0(v.Pos, OpLoad, t.Elem()) 13798 v0.AddArg(ptr) 13799 v0.AddArg(mem) 13800 v.AddArg(v0) 13801 return true 13802 } 13803 return false 13804 } 13805 func rewriteValuegeneric_OpLsh16x16_0(v *Value) bool { 13806 b := v.Block 13807 _ = b 13808 // match: (Lsh16x16 <t> x (Const16 [c])) 13809 // cond: 13810 // result: (Lsh16x64 x (Const64 <t> [int64(uint16(c))])) 13811 for { 13812 t := v.Type 13813 _ = v.Args[1] 13814 x := v.Args[0] 13815 v_1 := v.Args[1] 13816 if v_1.Op != OpConst16 { 13817 break 13818 } 13819 c := v_1.AuxInt 13820 v.reset(OpLsh16x64) 13821 v.AddArg(x) 13822 v0 := b.NewValue0(v.Pos, OpConst64, t) 13823 v0.AuxInt = int64(uint16(c)) 13824 v.AddArg(v0) 13825 return true 13826 } 13827 // match: (Lsh16x16 (Const16 [0]) _) 13828 // cond: 13829 // result: (Const16 [0]) 13830 for { 13831 _ = v.Args[1] 13832 v_0 := v.Args[0] 13833 if v_0.Op != OpConst16 { 13834 break 13835 } 13836 if v_0.AuxInt != 0 { 13837 break 13838 } 13839 v.reset(OpConst16) 13840 v.AuxInt = 0 13841 return true 13842 } 13843 return false 13844 } 13845 func rewriteValuegeneric_OpLsh16x32_0(v *Value) bool { 13846 b := v.Block 13847 _ = b 13848 // match: (Lsh16x32 <t> x (Const32 [c])) 13849 // cond: 13850 // result: (Lsh16x64 x (Const64 <t> [int64(uint32(c))])) 13851 for { 13852 t := v.Type 13853 _ = v.Args[1] 13854 x := v.Args[0] 13855 v_1 := v.Args[1] 13856 if v_1.Op != OpConst32 { 13857 break 13858 } 13859 c := v_1.AuxInt 13860 v.reset(OpLsh16x64) 13861 v.AddArg(x) 13862 v0 := b.NewValue0(v.Pos, OpConst64, t) 13863 v0.AuxInt = int64(uint32(c)) 13864 v.AddArg(v0) 13865 return true 13866 } 13867 // match: (Lsh16x32 (Const16 [0]) _) 13868 // cond: 13869 // result: (Const16 [0]) 13870 for { 13871 _ = v.Args[1] 13872 v_0 := v.Args[0] 13873 if v_0.Op != OpConst16 { 13874 break 13875 } 13876 if v_0.AuxInt != 0 { 13877 break 13878 } 13879 v.reset(OpConst16) 13880 v.AuxInt = 0 13881 return true 13882 } 13883 return false 13884 } 13885 func rewriteValuegeneric_OpLsh16x64_0(v *Value) bool { 13886 b := v.Block 13887 _ = b 13888 typ := &b.Func.Config.Types 13889 _ = typ 13890 // match: (Lsh16x64 (Const16 [c]) (Const64 [d])) 13891 // cond: 13892 // result: (Const16 [int64(int16(c) << uint64(d))]) 13893 for { 13894 _ = v.Args[1] 13895 v_0 := v.Args[0] 13896 if v_0.Op != OpConst16 { 13897 break 13898 } 13899 c := v_0.AuxInt 13900 v_1 := v.Args[1] 13901 if v_1.Op != OpConst64 { 13902 break 13903 } 13904 d := v_1.AuxInt 13905 v.reset(OpConst16) 13906 v.AuxInt = int64(int16(c) << uint64(d)) 13907 return true 13908 } 13909 // match: (Lsh16x64 x (Const64 [0])) 13910 // cond: 13911 // result: x 13912 for { 13913 _ = v.Args[1] 13914 x := v.Args[0] 13915 v_1 := v.Args[1] 13916 if v_1.Op != OpConst64 { 13917 break 13918 } 13919 if v_1.AuxInt != 0 { 13920 break 13921 } 13922 v.reset(OpCopy) 13923 v.Type = x.Type 13924 v.AddArg(x) 13925 return true 13926 } 13927 // match: (Lsh16x64 (Const16 [0]) _) 13928 // cond: 13929 // result: (Const16 [0]) 13930 for { 13931 _ = v.Args[1] 13932 v_0 := v.Args[0] 13933 if v_0.Op != OpConst16 { 13934 break 13935 } 13936 if v_0.AuxInt != 0 { 13937 break 13938 } 13939 v.reset(OpConst16) 13940 v.AuxInt = 0 13941 return true 13942 } 13943 // match: (Lsh16x64 _ (Const64 [c])) 13944 // cond: uint64(c) >= 16 13945 // result: (Const16 [0]) 13946 for { 13947 _ = v.Args[1] 13948 v_1 := v.Args[1] 13949 if v_1.Op != OpConst64 { 13950 break 13951 } 13952 c := v_1.AuxInt 13953 if !(uint64(c) >= 16) { 13954 break 13955 } 13956 v.reset(OpConst16) 13957 v.AuxInt = 0 13958 return true 13959 } 13960 // match: (Lsh16x64 <t> (Lsh16x64 x (Const64 [c])) (Const64 [d])) 13961 // cond: !uaddOvf(c,d) 13962 // result: (Lsh16x64 x (Const64 <t> [c+d])) 13963 for { 13964 t := v.Type 13965 _ = v.Args[1] 13966 v_0 := v.Args[0] 13967 if v_0.Op != OpLsh16x64 { 13968 break 13969 } 13970 _ = v_0.Args[1] 13971 x := v_0.Args[0] 13972 v_0_1 := v_0.Args[1] 13973 if v_0_1.Op != OpConst64 { 13974 break 13975 } 13976 c := v_0_1.AuxInt 13977 v_1 := v.Args[1] 13978 if v_1.Op != OpConst64 { 13979 break 13980 } 13981 d := v_1.AuxInt 13982 if !(!uaddOvf(c, d)) { 13983 break 13984 } 13985 v.reset(OpLsh16x64) 13986 v.AddArg(x) 13987 v0 := b.NewValue0(v.Pos, OpConst64, t) 13988 v0.AuxInt = c + d 13989 v.AddArg(v0) 13990 return true 13991 } 13992 // match: (Lsh16x64 (Rsh16Ux64 (Lsh16x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) 13993 // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) 13994 // result: (Lsh16x64 x (Const64 <typ.UInt64> [c1-c2+c3])) 13995 for { 13996 _ = v.Args[1] 13997 v_0 := v.Args[0] 13998 if v_0.Op != OpRsh16Ux64 { 13999 break 14000 } 14001 _ = v_0.Args[1] 14002 v_0_0 := v_0.Args[0] 14003 if v_0_0.Op != OpLsh16x64 { 14004 break 14005 } 14006 _ = v_0_0.Args[1] 14007 x := v_0_0.Args[0] 14008 v_0_0_1 := v_0_0.Args[1] 14009 if v_0_0_1.Op != OpConst64 { 14010 break 14011 } 14012 c1 := v_0_0_1.AuxInt 14013 v_0_1 := v_0.Args[1] 14014 if v_0_1.Op != OpConst64 { 14015 break 14016 } 14017 c2 := v_0_1.AuxInt 14018 v_1 := v.Args[1] 14019 if v_1.Op != OpConst64 { 14020 break 14021 } 14022 c3 := v_1.AuxInt 14023 if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { 14024 break 14025 } 14026 v.reset(OpLsh16x64) 14027 v.AddArg(x) 14028 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 14029 v0.AuxInt = c1 - c2 + c3 14030 v.AddArg(v0) 14031 return true 14032 } 14033 return false 14034 } 14035 func rewriteValuegeneric_OpLsh16x8_0(v *Value) bool { 14036 b := v.Block 14037 _ = b 14038 // match: (Lsh16x8 <t> x (Const8 [c])) 14039 // cond: 14040 // result: (Lsh16x64 x (Const64 <t> [int64(uint8(c))])) 14041 for { 14042 t := v.Type 14043 _ = v.Args[1] 14044 x := v.Args[0] 14045 v_1 := v.Args[1] 14046 if v_1.Op != OpConst8 { 14047 break 14048 } 14049 c := v_1.AuxInt 14050 v.reset(OpLsh16x64) 14051 v.AddArg(x) 14052 v0 := b.NewValue0(v.Pos, OpConst64, t) 14053 v0.AuxInt = int64(uint8(c)) 14054 v.AddArg(v0) 14055 return true 14056 } 14057 // match: (Lsh16x8 (Const16 [0]) _) 14058 // cond: 14059 // result: (Const16 [0]) 14060 for { 14061 _ = v.Args[1] 14062 v_0 := v.Args[0] 14063 if v_0.Op != OpConst16 { 14064 break 14065 } 14066 if v_0.AuxInt != 0 { 14067 break 14068 } 14069 v.reset(OpConst16) 14070 v.AuxInt = 0 14071 return true 14072 } 14073 return false 14074 } 14075 func rewriteValuegeneric_OpLsh32x16_0(v *Value) bool { 14076 b := v.Block 14077 _ = b 14078 // match: (Lsh32x16 <t> x (Const16 [c])) 14079 // cond: 14080 // result: (Lsh32x64 x (Const64 <t> [int64(uint16(c))])) 14081 for { 14082 t := v.Type 14083 _ = v.Args[1] 14084 x := v.Args[0] 14085 v_1 := v.Args[1] 14086 if v_1.Op != OpConst16 { 14087 break 14088 } 14089 c := v_1.AuxInt 14090 v.reset(OpLsh32x64) 14091 v.AddArg(x) 14092 v0 := b.NewValue0(v.Pos, OpConst64, t) 14093 v0.AuxInt = int64(uint16(c)) 14094 v.AddArg(v0) 14095 return true 14096 } 14097 // match: (Lsh32x16 (Const32 [0]) _) 14098 // cond: 14099 // result: (Const32 [0]) 14100 for { 14101 _ = v.Args[1] 14102 v_0 := v.Args[0] 14103 if v_0.Op != OpConst32 { 14104 break 14105 } 14106 if v_0.AuxInt != 0 { 14107 break 14108 } 14109 v.reset(OpConst32) 14110 v.AuxInt = 0 14111 return true 14112 } 14113 return false 14114 } 14115 func rewriteValuegeneric_OpLsh32x32_0(v *Value) bool { 14116 b := v.Block 14117 _ = b 14118 // match: (Lsh32x32 <t> x (Const32 [c])) 14119 // cond: 14120 // result: (Lsh32x64 x (Const64 <t> [int64(uint32(c))])) 14121 for { 14122 t := v.Type 14123 _ = v.Args[1] 14124 x := v.Args[0] 14125 v_1 := v.Args[1] 14126 if v_1.Op != OpConst32 { 14127 break 14128 } 14129 c := v_1.AuxInt 14130 v.reset(OpLsh32x64) 14131 v.AddArg(x) 14132 v0 := b.NewValue0(v.Pos, OpConst64, t) 14133 v0.AuxInt = int64(uint32(c)) 14134 v.AddArg(v0) 14135 return true 14136 } 14137 // match: (Lsh32x32 (Const32 [0]) _) 14138 // cond: 14139 // result: (Const32 [0]) 14140 for { 14141 _ = v.Args[1] 14142 v_0 := v.Args[0] 14143 if v_0.Op != OpConst32 { 14144 break 14145 } 14146 if v_0.AuxInt != 0 { 14147 break 14148 } 14149 v.reset(OpConst32) 14150 v.AuxInt = 0 14151 return true 14152 } 14153 return false 14154 } 14155 func rewriteValuegeneric_OpLsh32x64_0(v *Value) bool { 14156 b := v.Block 14157 _ = b 14158 typ := &b.Func.Config.Types 14159 _ = typ 14160 // match: (Lsh32x64 (Const32 [c]) (Const64 [d])) 14161 // cond: 14162 // result: (Const32 [int64(int32(c) << uint64(d))]) 14163 for { 14164 _ = v.Args[1] 14165 v_0 := v.Args[0] 14166 if v_0.Op != OpConst32 { 14167 break 14168 } 14169 c := v_0.AuxInt 14170 v_1 := v.Args[1] 14171 if v_1.Op != OpConst64 { 14172 break 14173 } 14174 d := v_1.AuxInt 14175 v.reset(OpConst32) 14176 v.AuxInt = int64(int32(c) << uint64(d)) 14177 return true 14178 } 14179 // match: (Lsh32x64 x (Const64 [0])) 14180 // cond: 14181 // result: x 14182 for { 14183 _ = v.Args[1] 14184 x := v.Args[0] 14185 v_1 := v.Args[1] 14186 if v_1.Op != OpConst64 { 14187 break 14188 } 14189 if v_1.AuxInt != 0 { 14190 break 14191 } 14192 v.reset(OpCopy) 14193 v.Type = x.Type 14194 v.AddArg(x) 14195 return true 14196 } 14197 // match: (Lsh32x64 (Const32 [0]) _) 14198 // cond: 14199 // result: (Const32 [0]) 14200 for { 14201 _ = v.Args[1] 14202 v_0 := v.Args[0] 14203 if v_0.Op != OpConst32 { 14204 break 14205 } 14206 if v_0.AuxInt != 0 { 14207 break 14208 } 14209 v.reset(OpConst32) 14210 v.AuxInt = 0 14211 return true 14212 } 14213 // match: (Lsh32x64 _ (Const64 [c])) 14214 // cond: uint64(c) >= 32 14215 // result: (Const32 [0]) 14216 for { 14217 _ = v.Args[1] 14218 v_1 := v.Args[1] 14219 if v_1.Op != OpConst64 { 14220 break 14221 } 14222 c := v_1.AuxInt 14223 if !(uint64(c) >= 32) { 14224 break 14225 } 14226 v.reset(OpConst32) 14227 v.AuxInt = 0 14228 return true 14229 } 14230 // match: (Lsh32x64 <t> (Lsh32x64 x (Const64 [c])) (Const64 [d])) 14231 // cond: !uaddOvf(c,d) 14232 // result: (Lsh32x64 x (Const64 <t> [c+d])) 14233 for { 14234 t := v.Type 14235 _ = v.Args[1] 14236 v_0 := v.Args[0] 14237 if v_0.Op != OpLsh32x64 { 14238 break 14239 } 14240 _ = v_0.Args[1] 14241 x := v_0.Args[0] 14242 v_0_1 := v_0.Args[1] 14243 if v_0_1.Op != OpConst64 { 14244 break 14245 } 14246 c := v_0_1.AuxInt 14247 v_1 := v.Args[1] 14248 if v_1.Op != OpConst64 { 14249 break 14250 } 14251 d := v_1.AuxInt 14252 if !(!uaddOvf(c, d)) { 14253 break 14254 } 14255 v.reset(OpLsh32x64) 14256 v.AddArg(x) 14257 v0 := b.NewValue0(v.Pos, OpConst64, t) 14258 v0.AuxInt = c + d 14259 v.AddArg(v0) 14260 return true 14261 } 14262 // match: (Lsh32x64 (Rsh32Ux64 (Lsh32x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) 14263 // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) 14264 // result: (Lsh32x64 x (Const64 <typ.UInt64> [c1-c2+c3])) 14265 for { 14266 _ = v.Args[1] 14267 v_0 := v.Args[0] 14268 if v_0.Op != OpRsh32Ux64 { 14269 break 14270 } 14271 _ = v_0.Args[1] 14272 v_0_0 := v_0.Args[0] 14273 if v_0_0.Op != OpLsh32x64 { 14274 break 14275 } 14276 _ = v_0_0.Args[1] 14277 x := v_0_0.Args[0] 14278 v_0_0_1 := v_0_0.Args[1] 14279 if v_0_0_1.Op != OpConst64 { 14280 break 14281 } 14282 c1 := v_0_0_1.AuxInt 14283 v_0_1 := v_0.Args[1] 14284 if v_0_1.Op != OpConst64 { 14285 break 14286 } 14287 c2 := v_0_1.AuxInt 14288 v_1 := v.Args[1] 14289 if v_1.Op != OpConst64 { 14290 break 14291 } 14292 c3 := v_1.AuxInt 14293 if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { 14294 break 14295 } 14296 v.reset(OpLsh32x64) 14297 v.AddArg(x) 14298 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 14299 v0.AuxInt = c1 - c2 + c3 14300 v.AddArg(v0) 14301 return true 14302 } 14303 return false 14304 } 14305 func rewriteValuegeneric_OpLsh32x8_0(v *Value) bool { 14306 b := v.Block 14307 _ = b 14308 // match: (Lsh32x8 <t> x (Const8 [c])) 14309 // cond: 14310 // result: (Lsh32x64 x (Const64 <t> [int64(uint8(c))])) 14311 for { 14312 t := v.Type 14313 _ = v.Args[1] 14314 x := v.Args[0] 14315 v_1 := v.Args[1] 14316 if v_1.Op != OpConst8 { 14317 break 14318 } 14319 c := v_1.AuxInt 14320 v.reset(OpLsh32x64) 14321 v.AddArg(x) 14322 v0 := b.NewValue0(v.Pos, OpConst64, t) 14323 v0.AuxInt = int64(uint8(c)) 14324 v.AddArg(v0) 14325 return true 14326 } 14327 // match: (Lsh32x8 (Const32 [0]) _) 14328 // cond: 14329 // result: (Const32 [0]) 14330 for { 14331 _ = v.Args[1] 14332 v_0 := v.Args[0] 14333 if v_0.Op != OpConst32 { 14334 break 14335 } 14336 if v_0.AuxInt != 0 { 14337 break 14338 } 14339 v.reset(OpConst32) 14340 v.AuxInt = 0 14341 return true 14342 } 14343 return false 14344 } 14345 func rewriteValuegeneric_OpLsh64x16_0(v *Value) bool { 14346 b := v.Block 14347 _ = b 14348 // match: (Lsh64x16 <t> x (Const16 [c])) 14349 // cond: 14350 // result: (Lsh64x64 x (Const64 <t> [int64(uint16(c))])) 14351 for { 14352 t := v.Type 14353 _ = v.Args[1] 14354 x := v.Args[0] 14355 v_1 := v.Args[1] 14356 if v_1.Op != OpConst16 { 14357 break 14358 } 14359 c := v_1.AuxInt 14360 v.reset(OpLsh64x64) 14361 v.AddArg(x) 14362 v0 := b.NewValue0(v.Pos, OpConst64, t) 14363 v0.AuxInt = int64(uint16(c)) 14364 v.AddArg(v0) 14365 return true 14366 } 14367 // match: (Lsh64x16 (Const64 [0]) _) 14368 // cond: 14369 // result: (Const64 [0]) 14370 for { 14371 _ = v.Args[1] 14372 v_0 := v.Args[0] 14373 if v_0.Op != OpConst64 { 14374 break 14375 } 14376 if v_0.AuxInt != 0 { 14377 break 14378 } 14379 v.reset(OpConst64) 14380 v.AuxInt = 0 14381 return true 14382 } 14383 return false 14384 } 14385 func rewriteValuegeneric_OpLsh64x32_0(v *Value) bool { 14386 b := v.Block 14387 _ = b 14388 // match: (Lsh64x32 <t> x (Const32 [c])) 14389 // cond: 14390 // result: (Lsh64x64 x (Const64 <t> [int64(uint32(c))])) 14391 for { 14392 t := v.Type 14393 _ = v.Args[1] 14394 x := v.Args[0] 14395 v_1 := v.Args[1] 14396 if v_1.Op != OpConst32 { 14397 break 14398 } 14399 c := v_1.AuxInt 14400 v.reset(OpLsh64x64) 14401 v.AddArg(x) 14402 v0 := b.NewValue0(v.Pos, OpConst64, t) 14403 v0.AuxInt = int64(uint32(c)) 14404 v.AddArg(v0) 14405 return true 14406 } 14407 // match: (Lsh64x32 (Const64 [0]) _) 14408 // cond: 14409 // result: (Const64 [0]) 14410 for { 14411 _ = v.Args[1] 14412 v_0 := v.Args[0] 14413 if v_0.Op != OpConst64 { 14414 break 14415 } 14416 if v_0.AuxInt != 0 { 14417 break 14418 } 14419 v.reset(OpConst64) 14420 v.AuxInt = 0 14421 return true 14422 } 14423 return false 14424 } 14425 func rewriteValuegeneric_OpLsh64x64_0(v *Value) bool { 14426 b := v.Block 14427 _ = b 14428 typ := &b.Func.Config.Types 14429 _ = typ 14430 // match: (Lsh64x64 (Const64 [c]) (Const64 [d])) 14431 // cond: 14432 // result: (Const64 [c << uint64(d)]) 14433 for { 14434 _ = v.Args[1] 14435 v_0 := v.Args[0] 14436 if v_0.Op != OpConst64 { 14437 break 14438 } 14439 c := v_0.AuxInt 14440 v_1 := v.Args[1] 14441 if v_1.Op != OpConst64 { 14442 break 14443 } 14444 d := v_1.AuxInt 14445 v.reset(OpConst64) 14446 v.AuxInt = c << uint64(d) 14447 return true 14448 } 14449 // match: (Lsh64x64 x (Const64 [0])) 14450 // cond: 14451 // result: x 14452 for { 14453 _ = v.Args[1] 14454 x := v.Args[0] 14455 v_1 := v.Args[1] 14456 if v_1.Op != OpConst64 { 14457 break 14458 } 14459 if v_1.AuxInt != 0 { 14460 break 14461 } 14462 v.reset(OpCopy) 14463 v.Type = x.Type 14464 v.AddArg(x) 14465 return true 14466 } 14467 // match: (Lsh64x64 (Const64 [0]) _) 14468 // cond: 14469 // result: (Const64 [0]) 14470 for { 14471 _ = v.Args[1] 14472 v_0 := v.Args[0] 14473 if v_0.Op != OpConst64 { 14474 break 14475 } 14476 if v_0.AuxInt != 0 { 14477 break 14478 } 14479 v.reset(OpConst64) 14480 v.AuxInt = 0 14481 return true 14482 } 14483 // match: (Lsh64x64 _ (Const64 [c])) 14484 // cond: uint64(c) >= 64 14485 // result: (Const64 [0]) 14486 for { 14487 _ = v.Args[1] 14488 v_1 := v.Args[1] 14489 if v_1.Op != OpConst64 { 14490 break 14491 } 14492 c := v_1.AuxInt 14493 if !(uint64(c) >= 64) { 14494 break 14495 } 14496 v.reset(OpConst64) 14497 v.AuxInt = 0 14498 return true 14499 } 14500 // match: (Lsh64x64 <t> (Lsh64x64 x (Const64 [c])) (Const64 [d])) 14501 // cond: !uaddOvf(c,d) 14502 // result: (Lsh64x64 x (Const64 <t> [c+d])) 14503 for { 14504 t := v.Type 14505 _ = v.Args[1] 14506 v_0 := v.Args[0] 14507 if v_0.Op != OpLsh64x64 { 14508 break 14509 } 14510 _ = v_0.Args[1] 14511 x := v_0.Args[0] 14512 v_0_1 := v_0.Args[1] 14513 if v_0_1.Op != OpConst64 { 14514 break 14515 } 14516 c := v_0_1.AuxInt 14517 v_1 := v.Args[1] 14518 if v_1.Op != OpConst64 { 14519 break 14520 } 14521 d := v_1.AuxInt 14522 if !(!uaddOvf(c, d)) { 14523 break 14524 } 14525 v.reset(OpLsh64x64) 14526 v.AddArg(x) 14527 v0 := b.NewValue0(v.Pos, OpConst64, t) 14528 v0.AuxInt = c + d 14529 v.AddArg(v0) 14530 return true 14531 } 14532 // match: (Lsh64x64 (Rsh64Ux64 (Lsh64x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) 14533 // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) 14534 // result: (Lsh64x64 x (Const64 <typ.UInt64> [c1-c2+c3])) 14535 for { 14536 _ = v.Args[1] 14537 v_0 := v.Args[0] 14538 if v_0.Op != OpRsh64Ux64 { 14539 break 14540 } 14541 _ = v_0.Args[1] 14542 v_0_0 := v_0.Args[0] 14543 if v_0_0.Op != OpLsh64x64 { 14544 break 14545 } 14546 _ = v_0_0.Args[1] 14547 x := v_0_0.Args[0] 14548 v_0_0_1 := v_0_0.Args[1] 14549 if v_0_0_1.Op != OpConst64 { 14550 break 14551 } 14552 c1 := v_0_0_1.AuxInt 14553 v_0_1 := v_0.Args[1] 14554 if v_0_1.Op != OpConst64 { 14555 break 14556 } 14557 c2 := v_0_1.AuxInt 14558 v_1 := v.Args[1] 14559 if v_1.Op != OpConst64 { 14560 break 14561 } 14562 c3 := v_1.AuxInt 14563 if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { 14564 break 14565 } 14566 v.reset(OpLsh64x64) 14567 v.AddArg(x) 14568 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 14569 v0.AuxInt = c1 - c2 + c3 14570 v.AddArg(v0) 14571 return true 14572 } 14573 return false 14574 } 14575 func rewriteValuegeneric_OpLsh64x8_0(v *Value) bool { 14576 b := v.Block 14577 _ = b 14578 // match: (Lsh64x8 <t> x (Const8 [c])) 14579 // cond: 14580 // result: (Lsh64x64 x (Const64 <t> [int64(uint8(c))])) 14581 for { 14582 t := v.Type 14583 _ = v.Args[1] 14584 x := v.Args[0] 14585 v_1 := v.Args[1] 14586 if v_1.Op != OpConst8 { 14587 break 14588 } 14589 c := v_1.AuxInt 14590 v.reset(OpLsh64x64) 14591 v.AddArg(x) 14592 v0 := b.NewValue0(v.Pos, OpConst64, t) 14593 v0.AuxInt = int64(uint8(c)) 14594 v.AddArg(v0) 14595 return true 14596 } 14597 // match: (Lsh64x8 (Const64 [0]) _) 14598 // cond: 14599 // result: (Const64 [0]) 14600 for { 14601 _ = v.Args[1] 14602 v_0 := v.Args[0] 14603 if v_0.Op != OpConst64 { 14604 break 14605 } 14606 if v_0.AuxInt != 0 { 14607 break 14608 } 14609 v.reset(OpConst64) 14610 v.AuxInt = 0 14611 return true 14612 } 14613 return false 14614 } 14615 func rewriteValuegeneric_OpLsh8x16_0(v *Value) bool { 14616 b := v.Block 14617 _ = b 14618 // match: (Lsh8x16 <t> x (Const16 [c])) 14619 // cond: 14620 // result: (Lsh8x64 x (Const64 <t> [int64(uint16(c))])) 14621 for { 14622 t := v.Type 14623 _ = v.Args[1] 14624 x := v.Args[0] 14625 v_1 := v.Args[1] 14626 if v_1.Op != OpConst16 { 14627 break 14628 } 14629 c := v_1.AuxInt 14630 v.reset(OpLsh8x64) 14631 v.AddArg(x) 14632 v0 := b.NewValue0(v.Pos, OpConst64, t) 14633 v0.AuxInt = int64(uint16(c)) 14634 v.AddArg(v0) 14635 return true 14636 } 14637 // match: (Lsh8x16 (Const8 [0]) _) 14638 // cond: 14639 // result: (Const8 [0]) 14640 for { 14641 _ = v.Args[1] 14642 v_0 := v.Args[0] 14643 if v_0.Op != OpConst8 { 14644 break 14645 } 14646 if v_0.AuxInt != 0 { 14647 break 14648 } 14649 v.reset(OpConst8) 14650 v.AuxInt = 0 14651 return true 14652 } 14653 return false 14654 } 14655 func rewriteValuegeneric_OpLsh8x32_0(v *Value) bool { 14656 b := v.Block 14657 _ = b 14658 // match: (Lsh8x32 <t> x (Const32 [c])) 14659 // cond: 14660 // result: (Lsh8x64 x (Const64 <t> [int64(uint32(c))])) 14661 for { 14662 t := v.Type 14663 _ = v.Args[1] 14664 x := v.Args[0] 14665 v_1 := v.Args[1] 14666 if v_1.Op != OpConst32 { 14667 break 14668 } 14669 c := v_1.AuxInt 14670 v.reset(OpLsh8x64) 14671 v.AddArg(x) 14672 v0 := b.NewValue0(v.Pos, OpConst64, t) 14673 v0.AuxInt = int64(uint32(c)) 14674 v.AddArg(v0) 14675 return true 14676 } 14677 // match: (Lsh8x32 (Const8 [0]) _) 14678 // cond: 14679 // result: (Const8 [0]) 14680 for { 14681 _ = v.Args[1] 14682 v_0 := v.Args[0] 14683 if v_0.Op != OpConst8 { 14684 break 14685 } 14686 if v_0.AuxInt != 0 { 14687 break 14688 } 14689 v.reset(OpConst8) 14690 v.AuxInt = 0 14691 return true 14692 } 14693 return false 14694 } 14695 func rewriteValuegeneric_OpLsh8x64_0(v *Value) bool { 14696 b := v.Block 14697 _ = b 14698 typ := &b.Func.Config.Types 14699 _ = typ 14700 // match: (Lsh8x64 (Const8 [c]) (Const64 [d])) 14701 // cond: 14702 // result: (Const8 [int64(int8(c) << uint64(d))]) 14703 for { 14704 _ = v.Args[1] 14705 v_0 := v.Args[0] 14706 if v_0.Op != OpConst8 { 14707 break 14708 } 14709 c := v_0.AuxInt 14710 v_1 := v.Args[1] 14711 if v_1.Op != OpConst64 { 14712 break 14713 } 14714 d := v_1.AuxInt 14715 v.reset(OpConst8) 14716 v.AuxInt = int64(int8(c) << uint64(d)) 14717 return true 14718 } 14719 // match: (Lsh8x64 x (Const64 [0])) 14720 // cond: 14721 // result: x 14722 for { 14723 _ = v.Args[1] 14724 x := v.Args[0] 14725 v_1 := v.Args[1] 14726 if v_1.Op != OpConst64 { 14727 break 14728 } 14729 if v_1.AuxInt != 0 { 14730 break 14731 } 14732 v.reset(OpCopy) 14733 v.Type = x.Type 14734 v.AddArg(x) 14735 return true 14736 } 14737 // match: (Lsh8x64 (Const8 [0]) _) 14738 // cond: 14739 // result: (Const8 [0]) 14740 for { 14741 _ = v.Args[1] 14742 v_0 := v.Args[0] 14743 if v_0.Op != OpConst8 { 14744 break 14745 } 14746 if v_0.AuxInt != 0 { 14747 break 14748 } 14749 v.reset(OpConst8) 14750 v.AuxInt = 0 14751 return true 14752 } 14753 // match: (Lsh8x64 _ (Const64 [c])) 14754 // cond: uint64(c) >= 8 14755 // result: (Const8 [0]) 14756 for { 14757 _ = v.Args[1] 14758 v_1 := v.Args[1] 14759 if v_1.Op != OpConst64 { 14760 break 14761 } 14762 c := v_1.AuxInt 14763 if !(uint64(c) >= 8) { 14764 break 14765 } 14766 v.reset(OpConst8) 14767 v.AuxInt = 0 14768 return true 14769 } 14770 // match: (Lsh8x64 <t> (Lsh8x64 x (Const64 [c])) (Const64 [d])) 14771 // cond: !uaddOvf(c,d) 14772 // result: (Lsh8x64 x (Const64 <t> [c+d])) 14773 for { 14774 t := v.Type 14775 _ = v.Args[1] 14776 v_0 := v.Args[0] 14777 if v_0.Op != OpLsh8x64 { 14778 break 14779 } 14780 _ = v_0.Args[1] 14781 x := v_0.Args[0] 14782 v_0_1 := v_0.Args[1] 14783 if v_0_1.Op != OpConst64 { 14784 break 14785 } 14786 c := v_0_1.AuxInt 14787 v_1 := v.Args[1] 14788 if v_1.Op != OpConst64 { 14789 break 14790 } 14791 d := v_1.AuxInt 14792 if !(!uaddOvf(c, d)) { 14793 break 14794 } 14795 v.reset(OpLsh8x64) 14796 v.AddArg(x) 14797 v0 := b.NewValue0(v.Pos, OpConst64, t) 14798 v0.AuxInt = c + d 14799 v.AddArg(v0) 14800 return true 14801 } 14802 // match: (Lsh8x64 (Rsh8Ux64 (Lsh8x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) 14803 // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) 14804 // result: (Lsh8x64 x (Const64 <typ.UInt64> [c1-c2+c3])) 14805 for { 14806 _ = v.Args[1] 14807 v_0 := v.Args[0] 14808 if v_0.Op != OpRsh8Ux64 { 14809 break 14810 } 14811 _ = v_0.Args[1] 14812 v_0_0 := v_0.Args[0] 14813 if v_0_0.Op != OpLsh8x64 { 14814 break 14815 } 14816 _ = v_0_0.Args[1] 14817 x := v_0_0.Args[0] 14818 v_0_0_1 := v_0_0.Args[1] 14819 if v_0_0_1.Op != OpConst64 { 14820 break 14821 } 14822 c1 := v_0_0_1.AuxInt 14823 v_0_1 := v_0.Args[1] 14824 if v_0_1.Op != OpConst64 { 14825 break 14826 } 14827 c2 := v_0_1.AuxInt 14828 v_1 := v.Args[1] 14829 if v_1.Op != OpConst64 { 14830 break 14831 } 14832 c3 := v_1.AuxInt 14833 if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { 14834 break 14835 } 14836 v.reset(OpLsh8x64) 14837 v.AddArg(x) 14838 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 14839 v0.AuxInt = c1 - c2 + c3 14840 v.AddArg(v0) 14841 return true 14842 } 14843 return false 14844 } 14845 func rewriteValuegeneric_OpLsh8x8_0(v *Value) bool { 14846 b := v.Block 14847 _ = b 14848 // match: (Lsh8x8 <t> x (Const8 [c])) 14849 // cond: 14850 // result: (Lsh8x64 x (Const64 <t> [int64(uint8(c))])) 14851 for { 14852 t := v.Type 14853 _ = v.Args[1] 14854 x := v.Args[0] 14855 v_1 := v.Args[1] 14856 if v_1.Op != OpConst8 { 14857 break 14858 } 14859 c := v_1.AuxInt 14860 v.reset(OpLsh8x64) 14861 v.AddArg(x) 14862 v0 := b.NewValue0(v.Pos, OpConst64, t) 14863 v0.AuxInt = int64(uint8(c)) 14864 v.AddArg(v0) 14865 return true 14866 } 14867 // match: (Lsh8x8 (Const8 [0]) _) 14868 // cond: 14869 // result: (Const8 [0]) 14870 for { 14871 _ = v.Args[1] 14872 v_0 := v.Args[0] 14873 if v_0.Op != OpConst8 { 14874 break 14875 } 14876 if v_0.AuxInt != 0 { 14877 break 14878 } 14879 v.reset(OpConst8) 14880 v.AuxInt = 0 14881 return true 14882 } 14883 return false 14884 } 14885 func rewriteValuegeneric_OpMod16_0(v *Value) bool { 14886 b := v.Block 14887 _ = b 14888 // match: (Mod16 (Const16 [c]) (Const16 [d])) 14889 // cond: d != 0 14890 // result: (Const16 [int64(int16(c % d))]) 14891 for { 14892 _ = v.Args[1] 14893 v_0 := v.Args[0] 14894 if v_0.Op != OpConst16 { 14895 break 14896 } 14897 c := v_0.AuxInt 14898 v_1 := v.Args[1] 14899 if v_1.Op != OpConst16 { 14900 break 14901 } 14902 d := v_1.AuxInt 14903 if !(d != 0) { 14904 break 14905 } 14906 v.reset(OpConst16) 14907 v.AuxInt = int64(int16(c % d)) 14908 return true 14909 } 14910 // match: (Mod16 <t> n (Const16 [c])) 14911 // cond: isNonNegative(n) && isPowerOfTwo(c&0xffff) 14912 // result: (And16 n (Const16 <t> [(c&0xffff)-1])) 14913 for { 14914 t := v.Type 14915 _ = v.Args[1] 14916 n := v.Args[0] 14917 v_1 := v.Args[1] 14918 if v_1.Op != OpConst16 { 14919 break 14920 } 14921 c := v_1.AuxInt 14922 if !(isNonNegative(n) && isPowerOfTwo(c&0xffff)) { 14923 break 14924 } 14925 v.reset(OpAnd16) 14926 v.AddArg(n) 14927 v0 := b.NewValue0(v.Pos, OpConst16, t) 14928 v0.AuxInt = (c & 0xffff) - 1 14929 v.AddArg(v0) 14930 return true 14931 } 14932 // match: (Mod16 <t> n (Const16 [c])) 14933 // cond: c < 0 && c != -1<<15 14934 // result: (Mod16 <t> n (Const16 <t> [-c])) 14935 for { 14936 t := v.Type 14937 _ = v.Args[1] 14938 n := v.Args[0] 14939 v_1 := v.Args[1] 14940 if v_1.Op != OpConst16 { 14941 break 14942 } 14943 c := v_1.AuxInt 14944 if !(c < 0 && c != -1<<15) { 14945 break 14946 } 14947 v.reset(OpMod16) 14948 v.Type = t 14949 v.AddArg(n) 14950 v0 := b.NewValue0(v.Pos, OpConst16, t) 14951 v0.AuxInt = -c 14952 v.AddArg(v0) 14953 return true 14954 } 14955 // match: (Mod16 <t> x (Const16 [c])) 14956 // cond: x.Op != OpConst16 && (c > 0 || c == -1<<15) 14957 // result: (Sub16 x (Mul16 <t> (Div16 <t> x (Const16 <t> [c])) (Const16 <t> [c]))) 14958 for { 14959 t := v.Type 14960 _ = v.Args[1] 14961 x := v.Args[0] 14962 v_1 := v.Args[1] 14963 if v_1.Op != OpConst16 { 14964 break 14965 } 14966 c := v_1.AuxInt 14967 if !(x.Op != OpConst16 && (c > 0 || c == -1<<15)) { 14968 break 14969 } 14970 v.reset(OpSub16) 14971 v.AddArg(x) 14972 v0 := b.NewValue0(v.Pos, OpMul16, t) 14973 v1 := b.NewValue0(v.Pos, OpDiv16, t) 14974 v1.AddArg(x) 14975 v2 := b.NewValue0(v.Pos, OpConst16, t) 14976 v2.AuxInt = c 14977 v1.AddArg(v2) 14978 v0.AddArg(v1) 14979 v3 := b.NewValue0(v.Pos, OpConst16, t) 14980 v3.AuxInt = c 14981 v0.AddArg(v3) 14982 v.AddArg(v0) 14983 return true 14984 } 14985 return false 14986 } 14987 func rewriteValuegeneric_OpMod16u_0(v *Value) bool { 14988 b := v.Block 14989 _ = b 14990 // match: (Mod16u (Const16 [c]) (Const16 [d])) 14991 // cond: d != 0 14992 // result: (Const16 [int64(uint16(c) % uint16(d))]) 14993 for { 14994 _ = v.Args[1] 14995 v_0 := v.Args[0] 14996 if v_0.Op != OpConst16 { 14997 break 14998 } 14999 c := v_0.AuxInt 15000 v_1 := v.Args[1] 15001 if v_1.Op != OpConst16 { 15002 break 15003 } 15004 d := v_1.AuxInt 15005 if !(d != 0) { 15006 break 15007 } 15008 v.reset(OpConst16) 15009 v.AuxInt = int64(uint16(c) % uint16(d)) 15010 return true 15011 } 15012 // match: (Mod16u <t> n (Const16 [c])) 15013 // cond: isPowerOfTwo(c&0xffff) 15014 // result: (And16 n (Const16 <t> [(c&0xffff)-1])) 15015 for { 15016 t := v.Type 15017 _ = v.Args[1] 15018 n := v.Args[0] 15019 v_1 := v.Args[1] 15020 if v_1.Op != OpConst16 { 15021 break 15022 } 15023 c := v_1.AuxInt 15024 if !(isPowerOfTwo(c & 0xffff)) { 15025 break 15026 } 15027 v.reset(OpAnd16) 15028 v.AddArg(n) 15029 v0 := b.NewValue0(v.Pos, OpConst16, t) 15030 v0.AuxInt = (c & 0xffff) - 1 15031 v.AddArg(v0) 15032 return true 15033 } 15034 // match: (Mod16u <t> x (Const16 [c])) 15035 // cond: x.Op != OpConst16 && c > 0 && umagicOK(16,c) 15036 // result: (Sub16 x (Mul16 <t> (Div16u <t> x (Const16 <t> [c])) (Const16 <t> [c]))) 15037 for { 15038 t := v.Type 15039 _ = v.Args[1] 15040 x := v.Args[0] 15041 v_1 := v.Args[1] 15042 if v_1.Op != OpConst16 { 15043 break 15044 } 15045 c := v_1.AuxInt 15046 if !(x.Op != OpConst16 && c > 0 && umagicOK(16, c)) { 15047 break 15048 } 15049 v.reset(OpSub16) 15050 v.AddArg(x) 15051 v0 := b.NewValue0(v.Pos, OpMul16, t) 15052 v1 := b.NewValue0(v.Pos, OpDiv16u, t) 15053 v1.AddArg(x) 15054 v2 := b.NewValue0(v.Pos, OpConst16, t) 15055 v2.AuxInt = c 15056 v1.AddArg(v2) 15057 v0.AddArg(v1) 15058 v3 := b.NewValue0(v.Pos, OpConst16, t) 15059 v3.AuxInt = c 15060 v0.AddArg(v3) 15061 v.AddArg(v0) 15062 return true 15063 } 15064 return false 15065 } 15066 func rewriteValuegeneric_OpMod32_0(v *Value) bool { 15067 b := v.Block 15068 _ = b 15069 // match: (Mod32 (Const32 [c]) (Const32 [d])) 15070 // cond: d != 0 15071 // result: (Const32 [int64(int32(c % d))]) 15072 for { 15073 _ = v.Args[1] 15074 v_0 := v.Args[0] 15075 if v_0.Op != OpConst32 { 15076 break 15077 } 15078 c := v_0.AuxInt 15079 v_1 := v.Args[1] 15080 if v_1.Op != OpConst32 { 15081 break 15082 } 15083 d := v_1.AuxInt 15084 if !(d != 0) { 15085 break 15086 } 15087 v.reset(OpConst32) 15088 v.AuxInt = int64(int32(c % d)) 15089 return true 15090 } 15091 // match: (Mod32 <t> n (Const32 [c])) 15092 // cond: isNonNegative(n) && isPowerOfTwo(c&0xffffffff) 15093 // result: (And32 n (Const32 <t> [(c&0xffffffff)-1])) 15094 for { 15095 t := v.Type 15096 _ = v.Args[1] 15097 n := v.Args[0] 15098 v_1 := v.Args[1] 15099 if v_1.Op != OpConst32 { 15100 break 15101 } 15102 c := v_1.AuxInt 15103 if !(isNonNegative(n) && isPowerOfTwo(c&0xffffffff)) { 15104 break 15105 } 15106 v.reset(OpAnd32) 15107 v.AddArg(n) 15108 v0 := b.NewValue0(v.Pos, OpConst32, t) 15109 v0.AuxInt = (c & 0xffffffff) - 1 15110 v.AddArg(v0) 15111 return true 15112 } 15113 // match: (Mod32 <t> n (Const32 [c])) 15114 // cond: c < 0 && c != -1<<31 15115 // result: (Mod32 <t> n (Const32 <t> [-c])) 15116 for { 15117 t := v.Type 15118 _ = v.Args[1] 15119 n := v.Args[0] 15120 v_1 := v.Args[1] 15121 if v_1.Op != OpConst32 { 15122 break 15123 } 15124 c := v_1.AuxInt 15125 if !(c < 0 && c != -1<<31) { 15126 break 15127 } 15128 v.reset(OpMod32) 15129 v.Type = t 15130 v.AddArg(n) 15131 v0 := b.NewValue0(v.Pos, OpConst32, t) 15132 v0.AuxInt = -c 15133 v.AddArg(v0) 15134 return true 15135 } 15136 // match: (Mod32 <t> x (Const32 [c])) 15137 // cond: x.Op != OpConst32 && (c > 0 || c == -1<<31) 15138 // result: (Sub32 x (Mul32 <t> (Div32 <t> x (Const32 <t> [c])) (Const32 <t> [c]))) 15139 for { 15140 t := v.Type 15141 _ = v.Args[1] 15142 x := v.Args[0] 15143 v_1 := v.Args[1] 15144 if v_1.Op != OpConst32 { 15145 break 15146 } 15147 c := v_1.AuxInt 15148 if !(x.Op != OpConst32 && (c > 0 || c == -1<<31)) { 15149 break 15150 } 15151 v.reset(OpSub32) 15152 v.AddArg(x) 15153 v0 := b.NewValue0(v.Pos, OpMul32, t) 15154 v1 := b.NewValue0(v.Pos, OpDiv32, t) 15155 v1.AddArg(x) 15156 v2 := b.NewValue0(v.Pos, OpConst32, t) 15157 v2.AuxInt = c 15158 v1.AddArg(v2) 15159 v0.AddArg(v1) 15160 v3 := b.NewValue0(v.Pos, OpConst32, t) 15161 v3.AuxInt = c 15162 v0.AddArg(v3) 15163 v.AddArg(v0) 15164 return true 15165 } 15166 return false 15167 } 15168 func rewriteValuegeneric_OpMod32u_0(v *Value) bool { 15169 b := v.Block 15170 _ = b 15171 // match: (Mod32u (Const32 [c]) (Const32 [d])) 15172 // cond: d != 0 15173 // result: (Const32 [int64(uint32(c) % uint32(d))]) 15174 for { 15175 _ = v.Args[1] 15176 v_0 := v.Args[0] 15177 if v_0.Op != OpConst32 { 15178 break 15179 } 15180 c := v_0.AuxInt 15181 v_1 := v.Args[1] 15182 if v_1.Op != OpConst32 { 15183 break 15184 } 15185 d := v_1.AuxInt 15186 if !(d != 0) { 15187 break 15188 } 15189 v.reset(OpConst32) 15190 v.AuxInt = int64(uint32(c) % uint32(d)) 15191 return true 15192 } 15193 // match: (Mod32u <t> n (Const32 [c])) 15194 // cond: isPowerOfTwo(c&0xffffffff) 15195 // result: (And32 n (Const32 <t> [(c&0xffffffff)-1])) 15196 for { 15197 t := v.Type 15198 _ = v.Args[1] 15199 n := v.Args[0] 15200 v_1 := v.Args[1] 15201 if v_1.Op != OpConst32 { 15202 break 15203 } 15204 c := v_1.AuxInt 15205 if !(isPowerOfTwo(c & 0xffffffff)) { 15206 break 15207 } 15208 v.reset(OpAnd32) 15209 v.AddArg(n) 15210 v0 := b.NewValue0(v.Pos, OpConst32, t) 15211 v0.AuxInt = (c & 0xffffffff) - 1 15212 v.AddArg(v0) 15213 return true 15214 } 15215 // match: (Mod32u <t> x (Const32 [c])) 15216 // cond: x.Op != OpConst32 && c > 0 && umagicOK(32,c) 15217 // result: (Sub32 x (Mul32 <t> (Div32u <t> x (Const32 <t> [c])) (Const32 <t> [c]))) 15218 for { 15219 t := v.Type 15220 _ = v.Args[1] 15221 x := v.Args[0] 15222 v_1 := v.Args[1] 15223 if v_1.Op != OpConst32 { 15224 break 15225 } 15226 c := v_1.AuxInt 15227 if !(x.Op != OpConst32 && c > 0 && umagicOK(32, c)) { 15228 break 15229 } 15230 v.reset(OpSub32) 15231 v.AddArg(x) 15232 v0 := b.NewValue0(v.Pos, OpMul32, t) 15233 v1 := b.NewValue0(v.Pos, OpDiv32u, t) 15234 v1.AddArg(x) 15235 v2 := b.NewValue0(v.Pos, OpConst32, t) 15236 v2.AuxInt = c 15237 v1.AddArg(v2) 15238 v0.AddArg(v1) 15239 v3 := b.NewValue0(v.Pos, OpConst32, t) 15240 v3.AuxInt = c 15241 v0.AddArg(v3) 15242 v.AddArg(v0) 15243 return true 15244 } 15245 return false 15246 } 15247 func rewriteValuegeneric_OpMod64_0(v *Value) bool { 15248 b := v.Block 15249 _ = b 15250 // match: (Mod64 (Const64 [c]) (Const64 [d])) 15251 // cond: d != 0 15252 // result: (Const64 [c % d]) 15253 for { 15254 _ = v.Args[1] 15255 v_0 := v.Args[0] 15256 if v_0.Op != OpConst64 { 15257 break 15258 } 15259 c := v_0.AuxInt 15260 v_1 := v.Args[1] 15261 if v_1.Op != OpConst64 { 15262 break 15263 } 15264 d := v_1.AuxInt 15265 if !(d != 0) { 15266 break 15267 } 15268 v.reset(OpConst64) 15269 v.AuxInt = c % d 15270 return true 15271 } 15272 // match: (Mod64 <t> n (Const64 [c])) 15273 // cond: isNonNegative(n) && isPowerOfTwo(c) 15274 // result: (And64 n (Const64 <t> [c-1])) 15275 for { 15276 t := v.Type 15277 _ = v.Args[1] 15278 n := v.Args[0] 15279 v_1 := v.Args[1] 15280 if v_1.Op != OpConst64 { 15281 break 15282 } 15283 c := v_1.AuxInt 15284 if !(isNonNegative(n) && isPowerOfTwo(c)) { 15285 break 15286 } 15287 v.reset(OpAnd64) 15288 v.AddArg(n) 15289 v0 := b.NewValue0(v.Pos, OpConst64, t) 15290 v0.AuxInt = c - 1 15291 v.AddArg(v0) 15292 return true 15293 } 15294 // match: (Mod64 n (Const64 [-1<<63])) 15295 // cond: isNonNegative(n) 15296 // result: n 15297 for { 15298 _ = v.Args[1] 15299 n := v.Args[0] 15300 v_1 := v.Args[1] 15301 if v_1.Op != OpConst64 { 15302 break 15303 } 15304 if v_1.AuxInt != -1<<63 { 15305 break 15306 } 15307 if !(isNonNegative(n)) { 15308 break 15309 } 15310 v.reset(OpCopy) 15311 v.Type = n.Type 15312 v.AddArg(n) 15313 return true 15314 } 15315 // match: (Mod64 <t> n (Const64 [c])) 15316 // cond: c < 0 && c != -1<<63 15317 // result: (Mod64 <t> n (Const64 <t> [-c])) 15318 for { 15319 t := v.Type 15320 _ = v.Args[1] 15321 n := v.Args[0] 15322 v_1 := v.Args[1] 15323 if v_1.Op != OpConst64 { 15324 break 15325 } 15326 c := v_1.AuxInt 15327 if !(c < 0 && c != -1<<63) { 15328 break 15329 } 15330 v.reset(OpMod64) 15331 v.Type = t 15332 v.AddArg(n) 15333 v0 := b.NewValue0(v.Pos, OpConst64, t) 15334 v0.AuxInt = -c 15335 v.AddArg(v0) 15336 return true 15337 } 15338 // match: (Mod64 <t> x (Const64 [c])) 15339 // cond: x.Op != OpConst64 && (c > 0 || c == -1<<63) 15340 // result: (Sub64 x (Mul64 <t> (Div64 <t> x (Const64 <t> [c])) (Const64 <t> [c]))) 15341 for { 15342 t := v.Type 15343 _ = v.Args[1] 15344 x := v.Args[0] 15345 v_1 := v.Args[1] 15346 if v_1.Op != OpConst64 { 15347 break 15348 } 15349 c := v_1.AuxInt 15350 if !(x.Op != OpConst64 && (c > 0 || c == -1<<63)) { 15351 break 15352 } 15353 v.reset(OpSub64) 15354 v.AddArg(x) 15355 v0 := b.NewValue0(v.Pos, OpMul64, t) 15356 v1 := b.NewValue0(v.Pos, OpDiv64, t) 15357 v1.AddArg(x) 15358 v2 := b.NewValue0(v.Pos, OpConst64, t) 15359 v2.AuxInt = c 15360 v1.AddArg(v2) 15361 v0.AddArg(v1) 15362 v3 := b.NewValue0(v.Pos, OpConst64, t) 15363 v3.AuxInt = c 15364 v0.AddArg(v3) 15365 v.AddArg(v0) 15366 return true 15367 } 15368 return false 15369 } 15370 func rewriteValuegeneric_OpMod64u_0(v *Value) bool { 15371 b := v.Block 15372 _ = b 15373 // match: (Mod64u (Const64 [c]) (Const64 [d])) 15374 // cond: d != 0 15375 // result: (Const64 [int64(uint64(c) % uint64(d))]) 15376 for { 15377 _ = v.Args[1] 15378 v_0 := v.Args[0] 15379 if v_0.Op != OpConst64 { 15380 break 15381 } 15382 c := v_0.AuxInt 15383 v_1 := v.Args[1] 15384 if v_1.Op != OpConst64 { 15385 break 15386 } 15387 d := v_1.AuxInt 15388 if !(d != 0) { 15389 break 15390 } 15391 v.reset(OpConst64) 15392 v.AuxInt = int64(uint64(c) % uint64(d)) 15393 return true 15394 } 15395 // match: (Mod64u <t> n (Const64 [c])) 15396 // cond: isPowerOfTwo(c) 15397 // result: (And64 n (Const64 <t> [c-1])) 15398 for { 15399 t := v.Type 15400 _ = v.Args[1] 15401 n := v.Args[0] 15402 v_1 := v.Args[1] 15403 if v_1.Op != OpConst64 { 15404 break 15405 } 15406 c := v_1.AuxInt 15407 if !(isPowerOfTwo(c)) { 15408 break 15409 } 15410 v.reset(OpAnd64) 15411 v.AddArg(n) 15412 v0 := b.NewValue0(v.Pos, OpConst64, t) 15413 v0.AuxInt = c - 1 15414 v.AddArg(v0) 15415 return true 15416 } 15417 // match: (Mod64u <t> n (Const64 [-1<<63])) 15418 // cond: 15419 // result: (And64 n (Const64 <t> [1<<63-1])) 15420 for { 15421 t := v.Type 15422 _ = v.Args[1] 15423 n := v.Args[0] 15424 v_1 := v.Args[1] 15425 if v_1.Op != OpConst64 { 15426 break 15427 } 15428 if v_1.AuxInt != -1<<63 { 15429 break 15430 } 15431 v.reset(OpAnd64) 15432 v.AddArg(n) 15433 v0 := b.NewValue0(v.Pos, OpConst64, t) 15434 v0.AuxInt = 1<<63 - 1 15435 v.AddArg(v0) 15436 return true 15437 } 15438 // match: (Mod64u <t> x (Const64 [c])) 15439 // cond: x.Op != OpConst64 && c > 0 && umagicOK(64,c) 15440 // result: (Sub64 x (Mul64 <t> (Div64u <t> x (Const64 <t> [c])) (Const64 <t> [c]))) 15441 for { 15442 t := v.Type 15443 _ = v.Args[1] 15444 x := v.Args[0] 15445 v_1 := v.Args[1] 15446 if v_1.Op != OpConst64 { 15447 break 15448 } 15449 c := v_1.AuxInt 15450 if !(x.Op != OpConst64 && c > 0 && umagicOK(64, c)) { 15451 break 15452 } 15453 v.reset(OpSub64) 15454 v.AddArg(x) 15455 v0 := b.NewValue0(v.Pos, OpMul64, t) 15456 v1 := b.NewValue0(v.Pos, OpDiv64u, t) 15457 v1.AddArg(x) 15458 v2 := b.NewValue0(v.Pos, OpConst64, t) 15459 v2.AuxInt = c 15460 v1.AddArg(v2) 15461 v0.AddArg(v1) 15462 v3 := b.NewValue0(v.Pos, OpConst64, t) 15463 v3.AuxInt = c 15464 v0.AddArg(v3) 15465 v.AddArg(v0) 15466 return true 15467 } 15468 return false 15469 } 15470 func rewriteValuegeneric_OpMod8_0(v *Value) bool { 15471 b := v.Block 15472 _ = b 15473 // match: (Mod8 (Const8 [c]) (Const8 [d])) 15474 // cond: d != 0 15475 // result: (Const8 [int64(int8(c % d))]) 15476 for { 15477 _ = v.Args[1] 15478 v_0 := v.Args[0] 15479 if v_0.Op != OpConst8 { 15480 break 15481 } 15482 c := v_0.AuxInt 15483 v_1 := v.Args[1] 15484 if v_1.Op != OpConst8 { 15485 break 15486 } 15487 d := v_1.AuxInt 15488 if !(d != 0) { 15489 break 15490 } 15491 v.reset(OpConst8) 15492 v.AuxInt = int64(int8(c % d)) 15493 return true 15494 } 15495 // match: (Mod8 <t> n (Const8 [c])) 15496 // cond: isNonNegative(n) && isPowerOfTwo(c&0xff) 15497 // result: (And8 n (Const8 <t> [(c&0xff)-1])) 15498 for { 15499 t := v.Type 15500 _ = v.Args[1] 15501 n := v.Args[0] 15502 v_1 := v.Args[1] 15503 if v_1.Op != OpConst8 { 15504 break 15505 } 15506 c := v_1.AuxInt 15507 if !(isNonNegative(n) && isPowerOfTwo(c&0xff)) { 15508 break 15509 } 15510 v.reset(OpAnd8) 15511 v.AddArg(n) 15512 v0 := b.NewValue0(v.Pos, OpConst8, t) 15513 v0.AuxInt = (c & 0xff) - 1 15514 v.AddArg(v0) 15515 return true 15516 } 15517 // match: (Mod8 <t> n (Const8 [c])) 15518 // cond: c < 0 && c != -1<<7 15519 // result: (Mod8 <t> n (Const8 <t> [-c])) 15520 for { 15521 t := v.Type 15522 _ = v.Args[1] 15523 n := v.Args[0] 15524 v_1 := v.Args[1] 15525 if v_1.Op != OpConst8 { 15526 break 15527 } 15528 c := v_1.AuxInt 15529 if !(c < 0 && c != -1<<7) { 15530 break 15531 } 15532 v.reset(OpMod8) 15533 v.Type = t 15534 v.AddArg(n) 15535 v0 := b.NewValue0(v.Pos, OpConst8, t) 15536 v0.AuxInt = -c 15537 v.AddArg(v0) 15538 return true 15539 } 15540 // match: (Mod8 <t> x (Const8 [c])) 15541 // cond: x.Op != OpConst8 && (c > 0 || c == -1<<7) 15542 // result: (Sub8 x (Mul8 <t> (Div8 <t> x (Const8 <t> [c])) (Const8 <t> [c]))) 15543 for { 15544 t := v.Type 15545 _ = v.Args[1] 15546 x := v.Args[0] 15547 v_1 := v.Args[1] 15548 if v_1.Op != OpConst8 { 15549 break 15550 } 15551 c := v_1.AuxInt 15552 if !(x.Op != OpConst8 && (c > 0 || c == -1<<7)) { 15553 break 15554 } 15555 v.reset(OpSub8) 15556 v.AddArg(x) 15557 v0 := b.NewValue0(v.Pos, OpMul8, t) 15558 v1 := b.NewValue0(v.Pos, OpDiv8, t) 15559 v1.AddArg(x) 15560 v2 := b.NewValue0(v.Pos, OpConst8, t) 15561 v2.AuxInt = c 15562 v1.AddArg(v2) 15563 v0.AddArg(v1) 15564 v3 := b.NewValue0(v.Pos, OpConst8, t) 15565 v3.AuxInt = c 15566 v0.AddArg(v3) 15567 v.AddArg(v0) 15568 return true 15569 } 15570 return false 15571 } 15572 func rewriteValuegeneric_OpMod8u_0(v *Value) bool { 15573 b := v.Block 15574 _ = b 15575 // match: (Mod8u (Const8 [c]) (Const8 [d])) 15576 // cond: d != 0 15577 // result: (Const8 [int64(uint8(c) % uint8(d))]) 15578 for { 15579 _ = v.Args[1] 15580 v_0 := v.Args[0] 15581 if v_0.Op != OpConst8 { 15582 break 15583 } 15584 c := v_0.AuxInt 15585 v_1 := v.Args[1] 15586 if v_1.Op != OpConst8 { 15587 break 15588 } 15589 d := v_1.AuxInt 15590 if !(d != 0) { 15591 break 15592 } 15593 v.reset(OpConst8) 15594 v.AuxInt = int64(uint8(c) % uint8(d)) 15595 return true 15596 } 15597 // match: (Mod8u <t> n (Const8 [c])) 15598 // cond: isPowerOfTwo(c&0xff) 15599 // result: (And8 n (Const8 <t> [(c&0xff)-1])) 15600 for { 15601 t := v.Type 15602 _ = v.Args[1] 15603 n := v.Args[0] 15604 v_1 := v.Args[1] 15605 if v_1.Op != OpConst8 { 15606 break 15607 } 15608 c := v_1.AuxInt 15609 if !(isPowerOfTwo(c & 0xff)) { 15610 break 15611 } 15612 v.reset(OpAnd8) 15613 v.AddArg(n) 15614 v0 := b.NewValue0(v.Pos, OpConst8, t) 15615 v0.AuxInt = (c & 0xff) - 1 15616 v.AddArg(v0) 15617 return true 15618 } 15619 // match: (Mod8u <t> x (Const8 [c])) 15620 // cond: x.Op != OpConst8 && c > 0 && umagicOK(8 ,c) 15621 // result: (Sub8 x (Mul8 <t> (Div8u <t> x (Const8 <t> [c])) (Const8 <t> [c]))) 15622 for { 15623 t := v.Type 15624 _ = v.Args[1] 15625 x := v.Args[0] 15626 v_1 := v.Args[1] 15627 if v_1.Op != OpConst8 { 15628 break 15629 } 15630 c := v_1.AuxInt 15631 if !(x.Op != OpConst8 && c > 0 && umagicOK(8, c)) { 15632 break 15633 } 15634 v.reset(OpSub8) 15635 v.AddArg(x) 15636 v0 := b.NewValue0(v.Pos, OpMul8, t) 15637 v1 := b.NewValue0(v.Pos, OpDiv8u, t) 15638 v1.AddArg(x) 15639 v2 := b.NewValue0(v.Pos, OpConst8, t) 15640 v2.AuxInt = c 15641 v1.AddArg(v2) 15642 v0.AddArg(v1) 15643 v3 := b.NewValue0(v.Pos, OpConst8, t) 15644 v3.AuxInt = c 15645 v0.AddArg(v3) 15646 v.AddArg(v0) 15647 return true 15648 } 15649 return false 15650 } 15651 func rewriteValuegeneric_OpMove_0(v *Value) bool { 15652 b := v.Block 15653 _ = b 15654 // match: (Move {t} [n] dst1 src mem:(Zero {t} [n] dst2 _)) 15655 // cond: isSamePtr(src, dst2) 15656 // result: (Zero {t} [n] dst1 mem) 15657 for { 15658 n := v.AuxInt 15659 t := v.Aux 15660 _ = v.Args[2] 15661 dst1 := v.Args[0] 15662 src := v.Args[1] 15663 mem := v.Args[2] 15664 if mem.Op != OpZero { 15665 break 15666 } 15667 if mem.AuxInt != n { 15668 break 15669 } 15670 if mem.Aux != t { 15671 break 15672 } 15673 _ = mem.Args[1] 15674 dst2 := mem.Args[0] 15675 if !(isSamePtr(src, dst2)) { 15676 break 15677 } 15678 v.reset(OpZero) 15679 v.AuxInt = n 15680 v.Aux = t 15681 v.AddArg(dst1) 15682 v.AddArg(mem) 15683 return true 15684 } 15685 // match: (Move {t} [n] dst1 src mem:(VarDef (Zero {t} [n] dst0 _))) 15686 // cond: isSamePtr(src, dst0) 15687 // result: (Zero {t} [n] dst1 mem) 15688 for { 15689 n := v.AuxInt 15690 t := v.Aux 15691 _ = v.Args[2] 15692 dst1 := v.Args[0] 15693 src := v.Args[1] 15694 mem := v.Args[2] 15695 if mem.Op != OpVarDef { 15696 break 15697 } 15698 mem_0 := mem.Args[0] 15699 if mem_0.Op != OpZero { 15700 break 15701 } 15702 if mem_0.AuxInt != n { 15703 break 15704 } 15705 if mem_0.Aux != t { 15706 break 15707 } 15708 _ = mem_0.Args[1] 15709 dst0 := mem_0.Args[0] 15710 if !(isSamePtr(src, dst0)) { 15711 break 15712 } 15713 v.reset(OpZero) 15714 v.AuxInt = n 15715 v.Aux = t 15716 v.AddArg(dst1) 15717 v.AddArg(mem) 15718 return true 15719 } 15720 // match: (Move {t1} [n] dst1 src1 store:(Store {t2} op:(OffPtr [o2] dst2) _ mem)) 15721 // cond: isSamePtr(dst1, dst2) && store.Uses == 1 && n >= o2 + sizeof(t2) && disjoint(src1, n, op, sizeof(t2)) && clobber(store) 15722 // result: (Move {t1} [n] dst1 src1 mem) 15723 for { 15724 n := v.AuxInt 15725 t1 := v.Aux 15726 _ = v.Args[2] 15727 dst1 := v.Args[0] 15728 src1 := v.Args[1] 15729 store := v.Args[2] 15730 if store.Op != OpStore { 15731 break 15732 } 15733 t2 := store.Aux 15734 _ = store.Args[2] 15735 op := store.Args[0] 15736 if op.Op != OpOffPtr { 15737 break 15738 } 15739 o2 := op.AuxInt 15740 dst2 := op.Args[0] 15741 mem := store.Args[2] 15742 if !(isSamePtr(dst1, dst2) && store.Uses == 1 && n >= o2+sizeof(t2) && disjoint(src1, n, op, sizeof(t2)) && clobber(store)) { 15743 break 15744 } 15745 v.reset(OpMove) 15746 v.AuxInt = n 15747 v.Aux = t1 15748 v.AddArg(dst1) 15749 v.AddArg(src1) 15750 v.AddArg(mem) 15751 return true 15752 } 15753 // match: (Move {t} [n] dst1 src1 move:(Move {t} [n] dst2 _ mem)) 15754 // cond: move.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(move) 15755 // result: (Move {t} [n] dst1 src1 mem) 15756 for { 15757 n := v.AuxInt 15758 t := v.Aux 15759 _ = v.Args[2] 15760 dst1 := v.Args[0] 15761 src1 := v.Args[1] 15762 move := v.Args[2] 15763 if move.Op != OpMove { 15764 break 15765 } 15766 if move.AuxInt != n { 15767 break 15768 } 15769 if move.Aux != t { 15770 break 15771 } 15772 _ = move.Args[2] 15773 dst2 := move.Args[0] 15774 mem := move.Args[2] 15775 if !(move.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(move)) { 15776 break 15777 } 15778 v.reset(OpMove) 15779 v.AuxInt = n 15780 v.Aux = t 15781 v.AddArg(dst1) 15782 v.AddArg(src1) 15783 v.AddArg(mem) 15784 return true 15785 } 15786 // match: (Move {t} [n] dst1 src1 vardef:(VarDef {x} move:(Move {t} [n] dst2 _ mem))) 15787 // cond: move.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(move) && clobber(vardef) 15788 // result: (Move {t} [n] dst1 src1 (VarDef {x} mem)) 15789 for { 15790 n := v.AuxInt 15791 t := v.Aux 15792 _ = v.Args[2] 15793 dst1 := v.Args[0] 15794 src1 := v.Args[1] 15795 vardef := v.Args[2] 15796 if vardef.Op != OpVarDef { 15797 break 15798 } 15799 x := vardef.Aux 15800 move := vardef.Args[0] 15801 if move.Op != OpMove { 15802 break 15803 } 15804 if move.AuxInt != n { 15805 break 15806 } 15807 if move.Aux != t { 15808 break 15809 } 15810 _ = move.Args[2] 15811 dst2 := move.Args[0] 15812 mem := move.Args[2] 15813 if !(move.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(move) && clobber(vardef)) { 15814 break 15815 } 15816 v.reset(OpMove) 15817 v.AuxInt = n 15818 v.Aux = t 15819 v.AddArg(dst1) 15820 v.AddArg(src1) 15821 v0 := b.NewValue0(v.Pos, OpVarDef, types.TypeMem) 15822 v0.Aux = x 15823 v0.AddArg(mem) 15824 v.AddArg(v0) 15825 return true 15826 } 15827 // match: (Move {t} [n] dst1 src1 zero:(Zero {t} [n] dst2 mem)) 15828 // cond: zero.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(zero) 15829 // result: (Move {t} [n] dst1 src1 mem) 15830 for { 15831 n := v.AuxInt 15832 t := v.Aux 15833 _ = v.Args[2] 15834 dst1 := v.Args[0] 15835 src1 := v.Args[1] 15836 zero := v.Args[2] 15837 if zero.Op != OpZero { 15838 break 15839 } 15840 if zero.AuxInt != n { 15841 break 15842 } 15843 if zero.Aux != t { 15844 break 15845 } 15846 _ = zero.Args[1] 15847 dst2 := zero.Args[0] 15848 mem := zero.Args[1] 15849 if !(zero.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(zero)) { 15850 break 15851 } 15852 v.reset(OpMove) 15853 v.AuxInt = n 15854 v.Aux = t 15855 v.AddArg(dst1) 15856 v.AddArg(src1) 15857 v.AddArg(mem) 15858 return true 15859 } 15860 // match: (Move {t} [n] dst1 src1 vardef:(VarDef {x} zero:(Zero {t} [n] dst2 mem))) 15861 // cond: zero.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(zero) && clobber(vardef) 15862 // result: (Move {t} [n] dst1 src1 (VarDef {x} mem)) 15863 for { 15864 n := v.AuxInt 15865 t := v.Aux 15866 _ = v.Args[2] 15867 dst1 := v.Args[0] 15868 src1 := v.Args[1] 15869 vardef := v.Args[2] 15870 if vardef.Op != OpVarDef { 15871 break 15872 } 15873 x := vardef.Aux 15874 zero := vardef.Args[0] 15875 if zero.Op != OpZero { 15876 break 15877 } 15878 if zero.AuxInt != n { 15879 break 15880 } 15881 if zero.Aux != t { 15882 break 15883 } 15884 _ = zero.Args[1] 15885 dst2 := zero.Args[0] 15886 mem := zero.Args[1] 15887 if !(zero.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(zero) && clobber(vardef)) { 15888 break 15889 } 15890 v.reset(OpMove) 15891 v.AuxInt = n 15892 v.Aux = t 15893 v.AddArg(dst1) 15894 v.AddArg(src1) 15895 v0 := b.NewValue0(v.Pos, OpVarDef, types.TypeMem) 15896 v0.Aux = x 15897 v0.AddArg(mem) 15898 v.AddArg(v0) 15899 return true 15900 } 15901 // match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [0] p3) d2 _))) 15902 // cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && o2 == sizeof(t3) && n == sizeof(t2) + sizeof(t3) 15903 // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [0] dst) d2 mem)) 15904 for { 15905 n := v.AuxInt 15906 t1 := v.Aux 15907 _ = v.Args[2] 15908 dst := v.Args[0] 15909 p1 := v.Args[1] 15910 mem := v.Args[2] 15911 if mem.Op != OpStore { 15912 break 15913 } 15914 t2 := mem.Aux 15915 _ = mem.Args[2] 15916 op2 := mem.Args[0] 15917 if op2.Op != OpOffPtr { 15918 break 15919 } 15920 tt2 := op2.Type 15921 o2 := op2.AuxInt 15922 p2 := op2.Args[0] 15923 d1 := mem.Args[1] 15924 mem_2 := mem.Args[2] 15925 if mem_2.Op != OpStore { 15926 break 15927 } 15928 t3 := mem_2.Aux 15929 _ = mem_2.Args[2] 15930 op3 := mem_2.Args[0] 15931 if op3.Op != OpOffPtr { 15932 break 15933 } 15934 tt3 := op3.Type 15935 if op3.AuxInt != 0 { 15936 break 15937 } 15938 p3 := op3.Args[0] 15939 d2 := mem_2.Args[1] 15940 if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && o2 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)) { 15941 break 15942 } 15943 v.reset(OpStore) 15944 v.Aux = t2 15945 v0 := b.NewValue0(v.Pos, OpOffPtr, tt2) 15946 v0.AuxInt = o2 15947 v0.AddArg(dst) 15948 v.AddArg(v0) 15949 v.AddArg(d1) 15950 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 15951 v1.Aux = t3 15952 v2 := b.NewValue0(v.Pos, OpOffPtr, tt3) 15953 v2.AuxInt = 0 15954 v2.AddArg(dst) 15955 v1.AddArg(v2) 15956 v1.AddArg(d2) 15957 v1.AddArg(mem) 15958 v.AddArg(v1) 15959 return true 15960 } 15961 // match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [0] p4) d3 _)))) 15962 // cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2) + sizeof(t3) + sizeof(t4) 15963 // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [0] dst) d3 mem))) 15964 for { 15965 n := v.AuxInt 15966 t1 := v.Aux 15967 _ = v.Args[2] 15968 dst := v.Args[0] 15969 p1 := v.Args[1] 15970 mem := v.Args[2] 15971 if mem.Op != OpStore { 15972 break 15973 } 15974 t2 := mem.Aux 15975 _ = mem.Args[2] 15976 op2 := mem.Args[0] 15977 if op2.Op != OpOffPtr { 15978 break 15979 } 15980 tt2 := op2.Type 15981 o2 := op2.AuxInt 15982 p2 := op2.Args[0] 15983 d1 := mem.Args[1] 15984 mem_2 := mem.Args[2] 15985 if mem_2.Op != OpStore { 15986 break 15987 } 15988 t3 := mem_2.Aux 15989 _ = mem_2.Args[2] 15990 op3 := mem_2.Args[0] 15991 if op3.Op != OpOffPtr { 15992 break 15993 } 15994 tt3 := op3.Type 15995 o3 := op3.AuxInt 15996 p3 := op3.Args[0] 15997 d2 := mem_2.Args[1] 15998 mem_2_2 := mem_2.Args[2] 15999 if mem_2_2.Op != OpStore { 16000 break 16001 } 16002 t4 := mem_2_2.Aux 16003 _ = mem_2_2.Args[2] 16004 op4 := mem_2_2.Args[0] 16005 if op4.Op != OpOffPtr { 16006 break 16007 } 16008 tt4 := op4.Type 16009 if op4.AuxInt != 0 { 16010 break 16011 } 16012 p4 := op4.Args[0] 16013 d3 := mem_2_2.Args[1] 16014 if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)+sizeof(t4)) { 16015 break 16016 } 16017 v.reset(OpStore) 16018 v.Aux = t2 16019 v0 := b.NewValue0(v.Pos, OpOffPtr, tt2) 16020 v0.AuxInt = o2 16021 v0.AddArg(dst) 16022 v.AddArg(v0) 16023 v.AddArg(d1) 16024 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16025 v1.Aux = t3 16026 v2 := b.NewValue0(v.Pos, OpOffPtr, tt3) 16027 v2.AuxInt = o3 16028 v2.AddArg(dst) 16029 v1.AddArg(v2) 16030 v1.AddArg(d2) 16031 v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16032 v3.Aux = t4 16033 v4 := b.NewValue0(v.Pos, OpOffPtr, tt4) 16034 v4.AuxInt = 0 16035 v4.AddArg(dst) 16036 v3.AddArg(v4) 16037 v3.AddArg(d3) 16038 v3.AddArg(mem) 16039 v1.AddArg(v3) 16040 v.AddArg(v1) 16041 return true 16042 } 16043 // match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [o4] p4) d3 (Store {t5} op5:(OffPtr <tt5> [0] p5) d4 _))))) 16044 // cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == sizeof(t5) && o3-o4 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2) + sizeof(t3) + sizeof(t4) + sizeof(t5) 16045 // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [0] dst) d4 mem)))) 16046 for { 16047 n := v.AuxInt 16048 t1 := v.Aux 16049 _ = v.Args[2] 16050 dst := v.Args[0] 16051 p1 := v.Args[1] 16052 mem := v.Args[2] 16053 if mem.Op != OpStore { 16054 break 16055 } 16056 t2 := mem.Aux 16057 _ = mem.Args[2] 16058 op2 := mem.Args[0] 16059 if op2.Op != OpOffPtr { 16060 break 16061 } 16062 tt2 := op2.Type 16063 o2 := op2.AuxInt 16064 p2 := op2.Args[0] 16065 d1 := mem.Args[1] 16066 mem_2 := mem.Args[2] 16067 if mem_2.Op != OpStore { 16068 break 16069 } 16070 t3 := mem_2.Aux 16071 _ = mem_2.Args[2] 16072 op3 := mem_2.Args[0] 16073 if op3.Op != OpOffPtr { 16074 break 16075 } 16076 tt3 := op3.Type 16077 o3 := op3.AuxInt 16078 p3 := op3.Args[0] 16079 d2 := mem_2.Args[1] 16080 mem_2_2 := mem_2.Args[2] 16081 if mem_2_2.Op != OpStore { 16082 break 16083 } 16084 t4 := mem_2_2.Aux 16085 _ = mem_2_2.Args[2] 16086 op4 := mem_2_2.Args[0] 16087 if op4.Op != OpOffPtr { 16088 break 16089 } 16090 tt4 := op4.Type 16091 o4 := op4.AuxInt 16092 p4 := op4.Args[0] 16093 d3 := mem_2_2.Args[1] 16094 mem_2_2_2 := mem_2_2.Args[2] 16095 if mem_2_2_2.Op != OpStore { 16096 break 16097 } 16098 t5 := mem_2_2_2.Aux 16099 _ = mem_2_2_2.Args[2] 16100 op5 := mem_2_2_2.Args[0] 16101 if op5.Op != OpOffPtr { 16102 break 16103 } 16104 tt5 := op5.Type 16105 if op5.AuxInt != 0 { 16106 break 16107 } 16108 p5 := op5.Args[0] 16109 d4 := mem_2_2_2.Args[1] 16110 if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == sizeof(t5) && o3-o4 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)+sizeof(t4)+sizeof(t5)) { 16111 break 16112 } 16113 v.reset(OpStore) 16114 v.Aux = t2 16115 v0 := b.NewValue0(v.Pos, OpOffPtr, tt2) 16116 v0.AuxInt = o2 16117 v0.AddArg(dst) 16118 v.AddArg(v0) 16119 v.AddArg(d1) 16120 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16121 v1.Aux = t3 16122 v2 := b.NewValue0(v.Pos, OpOffPtr, tt3) 16123 v2.AuxInt = o3 16124 v2.AddArg(dst) 16125 v1.AddArg(v2) 16126 v1.AddArg(d2) 16127 v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16128 v3.Aux = t4 16129 v4 := b.NewValue0(v.Pos, OpOffPtr, tt4) 16130 v4.AuxInt = o4 16131 v4.AddArg(dst) 16132 v3.AddArg(v4) 16133 v3.AddArg(d3) 16134 v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16135 v5.Aux = t5 16136 v6 := b.NewValue0(v.Pos, OpOffPtr, tt5) 16137 v6.AuxInt = 0 16138 v6.AddArg(dst) 16139 v5.AddArg(v6) 16140 v5.AddArg(d4) 16141 v5.AddArg(mem) 16142 v3.AddArg(v5) 16143 v1.AddArg(v3) 16144 v.AddArg(v1) 16145 return true 16146 } 16147 return false 16148 } 16149 func rewriteValuegeneric_OpMove_10(v *Value) bool { 16150 b := v.Block 16151 _ = b 16152 // match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [0] p3) d2 _)))) 16153 // cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && o2 == sizeof(t3) && n == sizeof(t2) + sizeof(t3) 16154 // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [0] dst) d2 mem)) 16155 for { 16156 n := v.AuxInt 16157 t1 := v.Aux 16158 _ = v.Args[2] 16159 dst := v.Args[0] 16160 p1 := v.Args[1] 16161 mem := v.Args[2] 16162 if mem.Op != OpVarDef { 16163 break 16164 } 16165 mem_0 := mem.Args[0] 16166 if mem_0.Op != OpStore { 16167 break 16168 } 16169 t2 := mem_0.Aux 16170 _ = mem_0.Args[2] 16171 op2 := mem_0.Args[0] 16172 if op2.Op != OpOffPtr { 16173 break 16174 } 16175 tt2 := op2.Type 16176 o2 := op2.AuxInt 16177 p2 := op2.Args[0] 16178 d1 := mem_0.Args[1] 16179 mem_0_2 := mem_0.Args[2] 16180 if mem_0_2.Op != OpStore { 16181 break 16182 } 16183 t3 := mem_0_2.Aux 16184 _ = mem_0_2.Args[2] 16185 op3 := mem_0_2.Args[0] 16186 if op3.Op != OpOffPtr { 16187 break 16188 } 16189 tt3 := op3.Type 16190 if op3.AuxInt != 0 { 16191 break 16192 } 16193 p3 := op3.Args[0] 16194 d2 := mem_0_2.Args[1] 16195 if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && o2 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)) { 16196 break 16197 } 16198 v.reset(OpStore) 16199 v.Aux = t2 16200 v0 := b.NewValue0(v.Pos, OpOffPtr, tt2) 16201 v0.AuxInt = o2 16202 v0.AddArg(dst) 16203 v.AddArg(v0) 16204 v.AddArg(d1) 16205 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16206 v1.Aux = t3 16207 v2 := b.NewValue0(v.Pos, OpOffPtr, tt3) 16208 v2.AuxInt = 0 16209 v2.AddArg(dst) 16210 v1.AddArg(v2) 16211 v1.AddArg(d2) 16212 v1.AddArg(mem) 16213 v.AddArg(v1) 16214 return true 16215 } 16216 // match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [0] p4) d3 _))))) 16217 // cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2) + sizeof(t3) + sizeof(t4) 16218 // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [0] dst) d3 mem))) 16219 for { 16220 n := v.AuxInt 16221 t1 := v.Aux 16222 _ = v.Args[2] 16223 dst := v.Args[0] 16224 p1 := v.Args[1] 16225 mem := v.Args[2] 16226 if mem.Op != OpVarDef { 16227 break 16228 } 16229 mem_0 := mem.Args[0] 16230 if mem_0.Op != OpStore { 16231 break 16232 } 16233 t2 := mem_0.Aux 16234 _ = mem_0.Args[2] 16235 op2 := mem_0.Args[0] 16236 if op2.Op != OpOffPtr { 16237 break 16238 } 16239 tt2 := op2.Type 16240 o2 := op2.AuxInt 16241 p2 := op2.Args[0] 16242 d1 := mem_0.Args[1] 16243 mem_0_2 := mem_0.Args[2] 16244 if mem_0_2.Op != OpStore { 16245 break 16246 } 16247 t3 := mem_0_2.Aux 16248 _ = mem_0_2.Args[2] 16249 op3 := mem_0_2.Args[0] 16250 if op3.Op != OpOffPtr { 16251 break 16252 } 16253 tt3 := op3.Type 16254 o3 := op3.AuxInt 16255 p3 := op3.Args[0] 16256 d2 := mem_0_2.Args[1] 16257 mem_0_2_2 := mem_0_2.Args[2] 16258 if mem_0_2_2.Op != OpStore { 16259 break 16260 } 16261 t4 := mem_0_2_2.Aux 16262 _ = mem_0_2_2.Args[2] 16263 op4 := mem_0_2_2.Args[0] 16264 if op4.Op != OpOffPtr { 16265 break 16266 } 16267 tt4 := op4.Type 16268 if op4.AuxInt != 0 { 16269 break 16270 } 16271 p4 := op4.Args[0] 16272 d3 := mem_0_2_2.Args[1] 16273 if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)+sizeof(t4)) { 16274 break 16275 } 16276 v.reset(OpStore) 16277 v.Aux = t2 16278 v0 := b.NewValue0(v.Pos, OpOffPtr, tt2) 16279 v0.AuxInt = o2 16280 v0.AddArg(dst) 16281 v.AddArg(v0) 16282 v.AddArg(d1) 16283 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16284 v1.Aux = t3 16285 v2 := b.NewValue0(v.Pos, OpOffPtr, tt3) 16286 v2.AuxInt = o3 16287 v2.AddArg(dst) 16288 v1.AddArg(v2) 16289 v1.AddArg(d2) 16290 v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16291 v3.Aux = t4 16292 v4 := b.NewValue0(v.Pos, OpOffPtr, tt4) 16293 v4.AuxInt = 0 16294 v4.AddArg(dst) 16295 v3.AddArg(v4) 16296 v3.AddArg(d3) 16297 v3.AddArg(mem) 16298 v1.AddArg(v3) 16299 v.AddArg(v1) 16300 return true 16301 } 16302 // match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [o4] p4) d3 (Store {t5} op5:(OffPtr <tt5> [0] p5) d4 _)))))) 16303 // cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == sizeof(t5) && o3-o4 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2) + sizeof(t3) + sizeof(t4) + sizeof(t5) 16304 // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [0] dst) d4 mem)))) 16305 for { 16306 n := v.AuxInt 16307 t1 := v.Aux 16308 _ = v.Args[2] 16309 dst := v.Args[0] 16310 p1 := v.Args[1] 16311 mem := v.Args[2] 16312 if mem.Op != OpVarDef { 16313 break 16314 } 16315 mem_0 := mem.Args[0] 16316 if mem_0.Op != OpStore { 16317 break 16318 } 16319 t2 := mem_0.Aux 16320 _ = mem_0.Args[2] 16321 op2 := mem_0.Args[0] 16322 if op2.Op != OpOffPtr { 16323 break 16324 } 16325 tt2 := op2.Type 16326 o2 := op2.AuxInt 16327 p2 := op2.Args[0] 16328 d1 := mem_0.Args[1] 16329 mem_0_2 := mem_0.Args[2] 16330 if mem_0_2.Op != OpStore { 16331 break 16332 } 16333 t3 := mem_0_2.Aux 16334 _ = mem_0_2.Args[2] 16335 op3 := mem_0_2.Args[0] 16336 if op3.Op != OpOffPtr { 16337 break 16338 } 16339 tt3 := op3.Type 16340 o3 := op3.AuxInt 16341 p3 := op3.Args[0] 16342 d2 := mem_0_2.Args[1] 16343 mem_0_2_2 := mem_0_2.Args[2] 16344 if mem_0_2_2.Op != OpStore { 16345 break 16346 } 16347 t4 := mem_0_2_2.Aux 16348 _ = mem_0_2_2.Args[2] 16349 op4 := mem_0_2_2.Args[0] 16350 if op4.Op != OpOffPtr { 16351 break 16352 } 16353 tt4 := op4.Type 16354 o4 := op4.AuxInt 16355 p4 := op4.Args[0] 16356 d3 := mem_0_2_2.Args[1] 16357 mem_0_2_2_2 := mem_0_2_2.Args[2] 16358 if mem_0_2_2_2.Op != OpStore { 16359 break 16360 } 16361 t5 := mem_0_2_2_2.Aux 16362 _ = mem_0_2_2_2.Args[2] 16363 op5 := mem_0_2_2_2.Args[0] 16364 if op5.Op != OpOffPtr { 16365 break 16366 } 16367 tt5 := op5.Type 16368 if op5.AuxInt != 0 { 16369 break 16370 } 16371 p5 := op5.Args[0] 16372 d4 := mem_0_2_2_2.Args[1] 16373 if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == sizeof(t5) && o3-o4 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)+sizeof(t4)+sizeof(t5)) { 16374 break 16375 } 16376 v.reset(OpStore) 16377 v.Aux = t2 16378 v0 := b.NewValue0(v.Pos, OpOffPtr, tt2) 16379 v0.AuxInt = o2 16380 v0.AddArg(dst) 16381 v.AddArg(v0) 16382 v.AddArg(d1) 16383 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16384 v1.Aux = t3 16385 v2 := b.NewValue0(v.Pos, OpOffPtr, tt3) 16386 v2.AuxInt = o3 16387 v2.AddArg(dst) 16388 v1.AddArg(v2) 16389 v1.AddArg(d2) 16390 v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16391 v3.Aux = t4 16392 v4 := b.NewValue0(v.Pos, OpOffPtr, tt4) 16393 v4.AuxInt = o4 16394 v4.AddArg(dst) 16395 v3.AddArg(v4) 16396 v3.AddArg(d3) 16397 v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16398 v5.Aux = t5 16399 v6 := b.NewValue0(v.Pos, OpOffPtr, tt5) 16400 v6.AuxInt = 0 16401 v6.AddArg(dst) 16402 v5.AddArg(v6) 16403 v5.AddArg(d4) 16404 v5.AddArg(mem) 16405 v3.AddArg(v5) 16406 v1.AddArg(v3) 16407 v.AddArg(v1) 16408 return true 16409 } 16410 // match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Zero {t3} [n] p3 _))) 16411 // cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && n >= o2 + sizeof(t2) 16412 // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Zero {t1} [n] dst mem)) 16413 for { 16414 n := v.AuxInt 16415 t1 := v.Aux 16416 _ = v.Args[2] 16417 dst := v.Args[0] 16418 p1 := v.Args[1] 16419 mem := v.Args[2] 16420 if mem.Op != OpStore { 16421 break 16422 } 16423 t2 := mem.Aux 16424 _ = mem.Args[2] 16425 op2 := mem.Args[0] 16426 if op2.Op != OpOffPtr { 16427 break 16428 } 16429 tt2 := op2.Type 16430 o2 := op2.AuxInt 16431 p2 := op2.Args[0] 16432 d1 := mem.Args[1] 16433 mem_2 := mem.Args[2] 16434 if mem_2.Op != OpZero { 16435 break 16436 } 16437 if mem_2.AuxInt != n { 16438 break 16439 } 16440 t3 := mem_2.Aux 16441 _ = mem_2.Args[1] 16442 p3 := mem_2.Args[0] 16443 if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && n >= o2+sizeof(t2)) { 16444 break 16445 } 16446 v.reset(OpStore) 16447 v.Aux = t2 16448 v0 := b.NewValue0(v.Pos, OpOffPtr, tt2) 16449 v0.AuxInt = o2 16450 v0.AddArg(dst) 16451 v.AddArg(v0) 16452 v.AddArg(d1) 16453 v1 := b.NewValue0(v.Pos, OpZero, types.TypeMem) 16454 v1.AuxInt = n 16455 v1.Aux = t1 16456 v1.AddArg(dst) 16457 v1.AddArg(mem) 16458 v.AddArg(v1) 16459 return true 16460 } 16461 // match: (Move {t1} [n] dst p1 mem:(Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Zero {t4} [n] p4 _)))) 16462 // cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3) 16463 // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Zero {t1} [n] dst mem))) 16464 for { 16465 n := v.AuxInt 16466 t1 := v.Aux 16467 _ = v.Args[2] 16468 dst := v.Args[0] 16469 p1 := v.Args[1] 16470 mem := v.Args[2] 16471 if mem.Op != OpStore { 16472 break 16473 } 16474 t2 := mem.Aux 16475 _ = mem.Args[2] 16476 mem_0 := mem.Args[0] 16477 if mem_0.Op != OpOffPtr { 16478 break 16479 } 16480 tt2 := mem_0.Type 16481 o2 := mem_0.AuxInt 16482 p2 := mem_0.Args[0] 16483 d1 := mem.Args[1] 16484 mem_2 := mem.Args[2] 16485 if mem_2.Op != OpStore { 16486 break 16487 } 16488 t3 := mem_2.Aux 16489 _ = mem_2.Args[2] 16490 mem_2_0 := mem_2.Args[0] 16491 if mem_2_0.Op != OpOffPtr { 16492 break 16493 } 16494 tt3 := mem_2_0.Type 16495 o3 := mem_2_0.AuxInt 16496 p3 := mem_2_0.Args[0] 16497 d2 := mem_2.Args[1] 16498 mem_2_2 := mem_2.Args[2] 16499 if mem_2_2.Op != OpZero { 16500 break 16501 } 16502 if mem_2_2.AuxInt != n { 16503 break 16504 } 16505 t4 := mem_2_2.Aux 16506 _ = mem_2_2.Args[1] 16507 p4 := mem_2_2.Args[0] 16508 if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3)) { 16509 break 16510 } 16511 v.reset(OpStore) 16512 v.Aux = t2 16513 v0 := b.NewValue0(v.Pos, OpOffPtr, tt2) 16514 v0.AuxInt = o2 16515 v0.AddArg(dst) 16516 v.AddArg(v0) 16517 v.AddArg(d1) 16518 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16519 v1.Aux = t3 16520 v2 := b.NewValue0(v.Pos, OpOffPtr, tt3) 16521 v2.AuxInt = o3 16522 v2.AddArg(dst) 16523 v1.AddArg(v2) 16524 v1.AddArg(d2) 16525 v3 := b.NewValue0(v.Pos, OpZero, types.TypeMem) 16526 v3.AuxInt = n 16527 v3.Aux = t1 16528 v3.AddArg(dst) 16529 v3.AddArg(mem) 16530 v1.AddArg(v3) 16531 v.AddArg(v1) 16532 return true 16533 } 16534 // match: (Move {t1} [n] dst p1 mem:(Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Zero {t5} [n] p5 _))))) 16535 // cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3) && n >= o4 + sizeof(t4) 16536 // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Zero {t1} [n] dst mem)))) 16537 for { 16538 n := v.AuxInt 16539 t1 := v.Aux 16540 _ = v.Args[2] 16541 dst := v.Args[0] 16542 p1 := v.Args[1] 16543 mem := v.Args[2] 16544 if mem.Op != OpStore { 16545 break 16546 } 16547 t2 := mem.Aux 16548 _ = mem.Args[2] 16549 mem_0 := mem.Args[0] 16550 if mem_0.Op != OpOffPtr { 16551 break 16552 } 16553 tt2 := mem_0.Type 16554 o2 := mem_0.AuxInt 16555 p2 := mem_0.Args[0] 16556 d1 := mem.Args[1] 16557 mem_2 := mem.Args[2] 16558 if mem_2.Op != OpStore { 16559 break 16560 } 16561 t3 := mem_2.Aux 16562 _ = mem_2.Args[2] 16563 mem_2_0 := mem_2.Args[0] 16564 if mem_2_0.Op != OpOffPtr { 16565 break 16566 } 16567 tt3 := mem_2_0.Type 16568 o3 := mem_2_0.AuxInt 16569 p3 := mem_2_0.Args[0] 16570 d2 := mem_2.Args[1] 16571 mem_2_2 := mem_2.Args[2] 16572 if mem_2_2.Op != OpStore { 16573 break 16574 } 16575 t4 := mem_2_2.Aux 16576 _ = mem_2_2.Args[2] 16577 mem_2_2_0 := mem_2_2.Args[0] 16578 if mem_2_2_0.Op != OpOffPtr { 16579 break 16580 } 16581 tt4 := mem_2_2_0.Type 16582 o4 := mem_2_2_0.AuxInt 16583 p4 := mem_2_2_0.Args[0] 16584 d3 := mem_2_2.Args[1] 16585 mem_2_2_2 := mem_2_2.Args[2] 16586 if mem_2_2_2.Op != OpZero { 16587 break 16588 } 16589 if mem_2_2_2.AuxInt != n { 16590 break 16591 } 16592 t5 := mem_2_2_2.Aux 16593 _ = mem_2_2_2.Args[1] 16594 p5 := mem_2_2_2.Args[0] 16595 if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3) && n >= o4+sizeof(t4)) { 16596 break 16597 } 16598 v.reset(OpStore) 16599 v.Aux = t2 16600 v0 := b.NewValue0(v.Pos, OpOffPtr, tt2) 16601 v0.AuxInt = o2 16602 v0.AddArg(dst) 16603 v.AddArg(v0) 16604 v.AddArg(d1) 16605 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16606 v1.Aux = t3 16607 v2 := b.NewValue0(v.Pos, OpOffPtr, tt3) 16608 v2.AuxInt = o3 16609 v2.AddArg(dst) 16610 v1.AddArg(v2) 16611 v1.AddArg(d2) 16612 v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16613 v3.Aux = t4 16614 v4 := b.NewValue0(v.Pos, OpOffPtr, tt4) 16615 v4.AuxInt = o4 16616 v4.AddArg(dst) 16617 v3.AddArg(v4) 16618 v3.AddArg(d3) 16619 v5 := b.NewValue0(v.Pos, OpZero, types.TypeMem) 16620 v5.AuxInt = n 16621 v5.Aux = t1 16622 v5.AddArg(dst) 16623 v5.AddArg(mem) 16624 v3.AddArg(v5) 16625 v1.AddArg(v3) 16626 v.AddArg(v1) 16627 return true 16628 } 16629 // match: (Move {t1} [n] dst p1 mem:(Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Store {t5} (OffPtr <tt5> [o5] p5) d4 (Zero {t6} [n] p6 _)))))) 16630 // cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && isSamePtr(p5, p6) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && alignof(t6) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3) && n >= o4 + sizeof(t4) && n >= o5 + sizeof(t5) 16631 // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [o5] dst) d4 (Zero {t1} [n] dst mem))))) 16632 for { 16633 n := v.AuxInt 16634 t1 := v.Aux 16635 _ = v.Args[2] 16636 dst := v.Args[0] 16637 p1 := v.Args[1] 16638 mem := v.Args[2] 16639 if mem.Op != OpStore { 16640 break 16641 } 16642 t2 := mem.Aux 16643 _ = mem.Args[2] 16644 mem_0 := mem.Args[0] 16645 if mem_0.Op != OpOffPtr { 16646 break 16647 } 16648 tt2 := mem_0.Type 16649 o2 := mem_0.AuxInt 16650 p2 := mem_0.Args[0] 16651 d1 := mem.Args[1] 16652 mem_2 := mem.Args[2] 16653 if mem_2.Op != OpStore { 16654 break 16655 } 16656 t3 := mem_2.Aux 16657 _ = mem_2.Args[2] 16658 mem_2_0 := mem_2.Args[0] 16659 if mem_2_0.Op != OpOffPtr { 16660 break 16661 } 16662 tt3 := mem_2_0.Type 16663 o3 := mem_2_0.AuxInt 16664 p3 := mem_2_0.Args[0] 16665 d2 := mem_2.Args[1] 16666 mem_2_2 := mem_2.Args[2] 16667 if mem_2_2.Op != OpStore { 16668 break 16669 } 16670 t4 := mem_2_2.Aux 16671 _ = mem_2_2.Args[2] 16672 mem_2_2_0 := mem_2_2.Args[0] 16673 if mem_2_2_0.Op != OpOffPtr { 16674 break 16675 } 16676 tt4 := mem_2_2_0.Type 16677 o4 := mem_2_2_0.AuxInt 16678 p4 := mem_2_2_0.Args[0] 16679 d3 := mem_2_2.Args[1] 16680 mem_2_2_2 := mem_2_2.Args[2] 16681 if mem_2_2_2.Op != OpStore { 16682 break 16683 } 16684 t5 := mem_2_2_2.Aux 16685 _ = mem_2_2_2.Args[2] 16686 mem_2_2_2_0 := mem_2_2_2.Args[0] 16687 if mem_2_2_2_0.Op != OpOffPtr { 16688 break 16689 } 16690 tt5 := mem_2_2_2_0.Type 16691 o5 := mem_2_2_2_0.AuxInt 16692 p5 := mem_2_2_2_0.Args[0] 16693 d4 := mem_2_2_2.Args[1] 16694 mem_2_2_2_2 := mem_2_2_2.Args[2] 16695 if mem_2_2_2_2.Op != OpZero { 16696 break 16697 } 16698 if mem_2_2_2_2.AuxInt != n { 16699 break 16700 } 16701 t6 := mem_2_2_2_2.Aux 16702 _ = mem_2_2_2_2.Args[1] 16703 p6 := mem_2_2_2_2.Args[0] 16704 if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && isSamePtr(p5, p6) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && alignof(t6) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3) && n >= o4+sizeof(t4) && n >= o5+sizeof(t5)) { 16705 break 16706 } 16707 v.reset(OpStore) 16708 v.Aux = t2 16709 v0 := b.NewValue0(v.Pos, OpOffPtr, tt2) 16710 v0.AuxInt = o2 16711 v0.AddArg(dst) 16712 v.AddArg(v0) 16713 v.AddArg(d1) 16714 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16715 v1.Aux = t3 16716 v2 := b.NewValue0(v.Pos, OpOffPtr, tt3) 16717 v2.AuxInt = o3 16718 v2.AddArg(dst) 16719 v1.AddArg(v2) 16720 v1.AddArg(d2) 16721 v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16722 v3.Aux = t4 16723 v4 := b.NewValue0(v.Pos, OpOffPtr, tt4) 16724 v4.AuxInt = o4 16725 v4.AddArg(dst) 16726 v3.AddArg(v4) 16727 v3.AddArg(d3) 16728 v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16729 v5.Aux = t5 16730 v6 := b.NewValue0(v.Pos, OpOffPtr, tt5) 16731 v6.AuxInt = o5 16732 v6.AddArg(dst) 16733 v5.AddArg(v6) 16734 v5.AddArg(d4) 16735 v7 := b.NewValue0(v.Pos, OpZero, types.TypeMem) 16736 v7.AuxInt = n 16737 v7.Aux = t1 16738 v7.AddArg(dst) 16739 v7.AddArg(mem) 16740 v5.AddArg(v7) 16741 v3.AddArg(v5) 16742 v1.AddArg(v3) 16743 v.AddArg(v1) 16744 return true 16745 } 16746 // match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Zero {t3} [n] p3 _)))) 16747 // cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && n >= o2 + sizeof(t2) 16748 // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Zero {t1} [n] dst mem)) 16749 for { 16750 n := v.AuxInt 16751 t1 := v.Aux 16752 _ = v.Args[2] 16753 dst := v.Args[0] 16754 p1 := v.Args[1] 16755 mem := v.Args[2] 16756 if mem.Op != OpVarDef { 16757 break 16758 } 16759 mem_0 := mem.Args[0] 16760 if mem_0.Op != OpStore { 16761 break 16762 } 16763 t2 := mem_0.Aux 16764 _ = mem_0.Args[2] 16765 op2 := mem_0.Args[0] 16766 if op2.Op != OpOffPtr { 16767 break 16768 } 16769 tt2 := op2.Type 16770 o2 := op2.AuxInt 16771 p2 := op2.Args[0] 16772 d1 := mem_0.Args[1] 16773 mem_0_2 := mem_0.Args[2] 16774 if mem_0_2.Op != OpZero { 16775 break 16776 } 16777 if mem_0_2.AuxInt != n { 16778 break 16779 } 16780 t3 := mem_0_2.Aux 16781 _ = mem_0_2.Args[1] 16782 p3 := mem_0_2.Args[0] 16783 if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && n >= o2+sizeof(t2)) { 16784 break 16785 } 16786 v.reset(OpStore) 16787 v.Aux = t2 16788 v0 := b.NewValue0(v.Pos, OpOffPtr, tt2) 16789 v0.AuxInt = o2 16790 v0.AddArg(dst) 16791 v.AddArg(v0) 16792 v.AddArg(d1) 16793 v1 := b.NewValue0(v.Pos, OpZero, types.TypeMem) 16794 v1.AuxInt = n 16795 v1.Aux = t1 16796 v1.AddArg(dst) 16797 v1.AddArg(mem) 16798 v.AddArg(v1) 16799 return true 16800 } 16801 // match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Zero {t4} [n] p4 _))))) 16802 // cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3) 16803 // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Zero {t1} [n] dst mem))) 16804 for { 16805 n := v.AuxInt 16806 t1 := v.Aux 16807 _ = v.Args[2] 16808 dst := v.Args[0] 16809 p1 := v.Args[1] 16810 mem := v.Args[2] 16811 if mem.Op != OpVarDef { 16812 break 16813 } 16814 mem_0 := mem.Args[0] 16815 if mem_0.Op != OpStore { 16816 break 16817 } 16818 t2 := mem_0.Aux 16819 _ = mem_0.Args[2] 16820 mem_0_0 := mem_0.Args[0] 16821 if mem_0_0.Op != OpOffPtr { 16822 break 16823 } 16824 tt2 := mem_0_0.Type 16825 o2 := mem_0_0.AuxInt 16826 p2 := mem_0_0.Args[0] 16827 d1 := mem_0.Args[1] 16828 mem_0_2 := mem_0.Args[2] 16829 if mem_0_2.Op != OpStore { 16830 break 16831 } 16832 t3 := mem_0_2.Aux 16833 _ = mem_0_2.Args[2] 16834 mem_0_2_0 := mem_0_2.Args[0] 16835 if mem_0_2_0.Op != OpOffPtr { 16836 break 16837 } 16838 tt3 := mem_0_2_0.Type 16839 o3 := mem_0_2_0.AuxInt 16840 p3 := mem_0_2_0.Args[0] 16841 d2 := mem_0_2.Args[1] 16842 mem_0_2_2 := mem_0_2.Args[2] 16843 if mem_0_2_2.Op != OpZero { 16844 break 16845 } 16846 if mem_0_2_2.AuxInt != n { 16847 break 16848 } 16849 t4 := mem_0_2_2.Aux 16850 _ = mem_0_2_2.Args[1] 16851 p4 := mem_0_2_2.Args[0] 16852 if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3)) { 16853 break 16854 } 16855 v.reset(OpStore) 16856 v.Aux = t2 16857 v0 := b.NewValue0(v.Pos, OpOffPtr, tt2) 16858 v0.AuxInt = o2 16859 v0.AddArg(dst) 16860 v.AddArg(v0) 16861 v.AddArg(d1) 16862 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16863 v1.Aux = t3 16864 v2 := b.NewValue0(v.Pos, OpOffPtr, tt3) 16865 v2.AuxInt = o3 16866 v2.AddArg(dst) 16867 v1.AddArg(v2) 16868 v1.AddArg(d2) 16869 v3 := b.NewValue0(v.Pos, OpZero, types.TypeMem) 16870 v3.AuxInt = n 16871 v3.Aux = t1 16872 v3.AddArg(dst) 16873 v3.AddArg(mem) 16874 v1.AddArg(v3) 16875 v.AddArg(v1) 16876 return true 16877 } 16878 // match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Zero {t5} [n] p5 _)))))) 16879 // cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3) && n >= o4 + sizeof(t4) 16880 // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Zero {t1} [n] dst mem)))) 16881 for { 16882 n := v.AuxInt 16883 t1 := v.Aux 16884 _ = v.Args[2] 16885 dst := v.Args[0] 16886 p1 := v.Args[1] 16887 mem := v.Args[2] 16888 if mem.Op != OpVarDef { 16889 break 16890 } 16891 mem_0 := mem.Args[0] 16892 if mem_0.Op != OpStore { 16893 break 16894 } 16895 t2 := mem_0.Aux 16896 _ = mem_0.Args[2] 16897 mem_0_0 := mem_0.Args[0] 16898 if mem_0_0.Op != OpOffPtr { 16899 break 16900 } 16901 tt2 := mem_0_0.Type 16902 o2 := mem_0_0.AuxInt 16903 p2 := mem_0_0.Args[0] 16904 d1 := mem_0.Args[1] 16905 mem_0_2 := mem_0.Args[2] 16906 if mem_0_2.Op != OpStore { 16907 break 16908 } 16909 t3 := mem_0_2.Aux 16910 _ = mem_0_2.Args[2] 16911 mem_0_2_0 := mem_0_2.Args[0] 16912 if mem_0_2_0.Op != OpOffPtr { 16913 break 16914 } 16915 tt3 := mem_0_2_0.Type 16916 o3 := mem_0_2_0.AuxInt 16917 p3 := mem_0_2_0.Args[0] 16918 d2 := mem_0_2.Args[1] 16919 mem_0_2_2 := mem_0_2.Args[2] 16920 if mem_0_2_2.Op != OpStore { 16921 break 16922 } 16923 t4 := mem_0_2_2.Aux 16924 _ = mem_0_2_2.Args[2] 16925 mem_0_2_2_0 := mem_0_2_2.Args[0] 16926 if mem_0_2_2_0.Op != OpOffPtr { 16927 break 16928 } 16929 tt4 := mem_0_2_2_0.Type 16930 o4 := mem_0_2_2_0.AuxInt 16931 p4 := mem_0_2_2_0.Args[0] 16932 d3 := mem_0_2_2.Args[1] 16933 mem_0_2_2_2 := mem_0_2_2.Args[2] 16934 if mem_0_2_2_2.Op != OpZero { 16935 break 16936 } 16937 if mem_0_2_2_2.AuxInt != n { 16938 break 16939 } 16940 t5 := mem_0_2_2_2.Aux 16941 _ = mem_0_2_2_2.Args[1] 16942 p5 := mem_0_2_2_2.Args[0] 16943 if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3) && n >= o4+sizeof(t4)) { 16944 break 16945 } 16946 v.reset(OpStore) 16947 v.Aux = t2 16948 v0 := b.NewValue0(v.Pos, OpOffPtr, tt2) 16949 v0.AuxInt = o2 16950 v0.AddArg(dst) 16951 v.AddArg(v0) 16952 v.AddArg(d1) 16953 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16954 v1.Aux = t3 16955 v2 := b.NewValue0(v.Pos, OpOffPtr, tt3) 16956 v2.AuxInt = o3 16957 v2.AddArg(dst) 16958 v1.AddArg(v2) 16959 v1.AddArg(d2) 16960 v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 16961 v3.Aux = t4 16962 v4 := b.NewValue0(v.Pos, OpOffPtr, tt4) 16963 v4.AuxInt = o4 16964 v4.AddArg(dst) 16965 v3.AddArg(v4) 16966 v3.AddArg(d3) 16967 v5 := b.NewValue0(v.Pos, OpZero, types.TypeMem) 16968 v5.AuxInt = n 16969 v5.Aux = t1 16970 v5.AddArg(dst) 16971 v5.AddArg(mem) 16972 v3.AddArg(v5) 16973 v1.AddArg(v3) 16974 v.AddArg(v1) 16975 return true 16976 } 16977 return false 16978 } 16979 func rewriteValuegeneric_OpMove_20(v *Value) bool { 16980 b := v.Block 16981 _ = b 16982 config := b.Func.Config 16983 _ = config 16984 // match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Store {t5} (OffPtr <tt5> [o5] p5) d4 (Zero {t6} [n] p6 _))))))) 16985 // cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && isSamePtr(p5, p6) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && alignof(t6) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3) && n >= o4 + sizeof(t4) && n >= o5 + sizeof(t5) 16986 // result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [o5] dst) d4 (Zero {t1} [n] dst mem))))) 16987 for { 16988 n := v.AuxInt 16989 t1 := v.Aux 16990 _ = v.Args[2] 16991 dst := v.Args[0] 16992 p1 := v.Args[1] 16993 mem := v.Args[2] 16994 if mem.Op != OpVarDef { 16995 break 16996 } 16997 mem_0 := mem.Args[0] 16998 if mem_0.Op != OpStore { 16999 break 17000 } 17001 t2 := mem_0.Aux 17002 _ = mem_0.Args[2] 17003 mem_0_0 := mem_0.Args[0] 17004 if mem_0_0.Op != OpOffPtr { 17005 break 17006 } 17007 tt2 := mem_0_0.Type 17008 o2 := mem_0_0.AuxInt 17009 p2 := mem_0_0.Args[0] 17010 d1 := mem_0.Args[1] 17011 mem_0_2 := mem_0.Args[2] 17012 if mem_0_2.Op != OpStore { 17013 break 17014 } 17015 t3 := mem_0_2.Aux 17016 _ = mem_0_2.Args[2] 17017 mem_0_2_0 := mem_0_2.Args[0] 17018 if mem_0_2_0.Op != OpOffPtr { 17019 break 17020 } 17021 tt3 := mem_0_2_0.Type 17022 o3 := mem_0_2_0.AuxInt 17023 p3 := mem_0_2_0.Args[0] 17024 d2 := mem_0_2.Args[1] 17025 mem_0_2_2 := mem_0_2.Args[2] 17026 if mem_0_2_2.Op != OpStore { 17027 break 17028 } 17029 t4 := mem_0_2_2.Aux 17030 _ = mem_0_2_2.Args[2] 17031 mem_0_2_2_0 := mem_0_2_2.Args[0] 17032 if mem_0_2_2_0.Op != OpOffPtr { 17033 break 17034 } 17035 tt4 := mem_0_2_2_0.Type 17036 o4 := mem_0_2_2_0.AuxInt 17037 p4 := mem_0_2_2_0.Args[0] 17038 d3 := mem_0_2_2.Args[1] 17039 mem_0_2_2_2 := mem_0_2_2.Args[2] 17040 if mem_0_2_2_2.Op != OpStore { 17041 break 17042 } 17043 t5 := mem_0_2_2_2.Aux 17044 _ = mem_0_2_2_2.Args[2] 17045 mem_0_2_2_2_0 := mem_0_2_2_2.Args[0] 17046 if mem_0_2_2_2_0.Op != OpOffPtr { 17047 break 17048 } 17049 tt5 := mem_0_2_2_2_0.Type 17050 o5 := mem_0_2_2_2_0.AuxInt 17051 p5 := mem_0_2_2_2_0.Args[0] 17052 d4 := mem_0_2_2_2.Args[1] 17053 mem_0_2_2_2_2 := mem_0_2_2_2.Args[2] 17054 if mem_0_2_2_2_2.Op != OpZero { 17055 break 17056 } 17057 if mem_0_2_2_2_2.AuxInt != n { 17058 break 17059 } 17060 t6 := mem_0_2_2_2_2.Aux 17061 _ = mem_0_2_2_2_2.Args[1] 17062 p6 := mem_0_2_2_2_2.Args[0] 17063 if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && isSamePtr(p5, p6) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && alignof(t6) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3) && n >= o4+sizeof(t4) && n >= o5+sizeof(t5)) { 17064 break 17065 } 17066 v.reset(OpStore) 17067 v.Aux = t2 17068 v0 := b.NewValue0(v.Pos, OpOffPtr, tt2) 17069 v0.AuxInt = o2 17070 v0.AddArg(dst) 17071 v.AddArg(v0) 17072 v.AddArg(d1) 17073 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 17074 v1.Aux = t3 17075 v2 := b.NewValue0(v.Pos, OpOffPtr, tt3) 17076 v2.AuxInt = o3 17077 v2.AddArg(dst) 17078 v1.AddArg(v2) 17079 v1.AddArg(d2) 17080 v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 17081 v3.Aux = t4 17082 v4 := b.NewValue0(v.Pos, OpOffPtr, tt4) 17083 v4.AuxInt = o4 17084 v4.AddArg(dst) 17085 v3.AddArg(v4) 17086 v3.AddArg(d3) 17087 v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 17088 v5.Aux = t5 17089 v6 := b.NewValue0(v.Pos, OpOffPtr, tt5) 17090 v6.AuxInt = o5 17091 v6.AddArg(dst) 17092 v5.AddArg(v6) 17093 v5.AddArg(d4) 17094 v7 := b.NewValue0(v.Pos, OpZero, types.TypeMem) 17095 v7.AuxInt = n 17096 v7.Aux = t1 17097 v7.AddArg(dst) 17098 v7.AddArg(mem) 17099 v5.AddArg(v7) 17100 v3.AddArg(v5) 17101 v1.AddArg(v3) 17102 v.AddArg(v1) 17103 return true 17104 } 17105 // match: (Move {t1} [s] dst tmp1 midmem:(Move {t2} [s] tmp2 src _)) 17106 // cond: t1.(*types.Type).Compare(t2.(*types.Type)) == types.CMPeq && isSamePtr(tmp1, tmp2) && isStackPtr(src) && disjoint(src, s, tmp2, s) && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config)) 17107 // result: (Move {t1} [s] dst src midmem) 17108 for { 17109 s := v.AuxInt 17110 t1 := v.Aux 17111 _ = v.Args[2] 17112 dst := v.Args[0] 17113 tmp1 := v.Args[1] 17114 midmem := v.Args[2] 17115 if midmem.Op != OpMove { 17116 break 17117 } 17118 if midmem.AuxInt != s { 17119 break 17120 } 17121 t2 := midmem.Aux 17122 _ = midmem.Args[2] 17123 tmp2 := midmem.Args[0] 17124 src := midmem.Args[1] 17125 if !(t1.(*types.Type).Compare(t2.(*types.Type)) == types.CMPeq && isSamePtr(tmp1, tmp2) && isStackPtr(src) && disjoint(src, s, tmp2, s) && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config))) { 17126 break 17127 } 17128 v.reset(OpMove) 17129 v.AuxInt = s 17130 v.Aux = t1 17131 v.AddArg(dst) 17132 v.AddArg(src) 17133 v.AddArg(midmem) 17134 return true 17135 } 17136 // match: (Move {t1} [s] dst tmp1 midmem:(VarDef (Move {t2} [s] tmp2 src _))) 17137 // cond: t1.(*types.Type).Compare(t2.(*types.Type)) == types.CMPeq && isSamePtr(tmp1, tmp2) && isStackPtr(src) && disjoint(src, s, tmp2, s) && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config)) 17138 // result: (Move {t1} [s] dst src midmem) 17139 for { 17140 s := v.AuxInt 17141 t1 := v.Aux 17142 _ = v.Args[2] 17143 dst := v.Args[0] 17144 tmp1 := v.Args[1] 17145 midmem := v.Args[2] 17146 if midmem.Op != OpVarDef { 17147 break 17148 } 17149 midmem_0 := midmem.Args[0] 17150 if midmem_0.Op != OpMove { 17151 break 17152 } 17153 if midmem_0.AuxInt != s { 17154 break 17155 } 17156 t2 := midmem_0.Aux 17157 _ = midmem_0.Args[2] 17158 tmp2 := midmem_0.Args[0] 17159 src := midmem_0.Args[1] 17160 if !(t1.(*types.Type).Compare(t2.(*types.Type)) == types.CMPeq && isSamePtr(tmp1, tmp2) && isStackPtr(src) && disjoint(src, s, tmp2, s) && (disjoint(src, s, dst, s) || isInlinableMemmove(dst, src, s, config))) { 17161 break 17162 } 17163 v.reset(OpMove) 17164 v.AuxInt = s 17165 v.Aux = t1 17166 v.AddArg(dst) 17167 v.AddArg(src) 17168 v.AddArg(midmem) 17169 return true 17170 } 17171 // match: (Move dst src mem) 17172 // cond: isSamePtr(dst, src) 17173 // result: mem 17174 for { 17175 _ = v.Args[2] 17176 dst := v.Args[0] 17177 src := v.Args[1] 17178 mem := v.Args[2] 17179 if !(isSamePtr(dst, src)) { 17180 break 17181 } 17182 v.reset(OpCopy) 17183 v.Type = mem.Type 17184 v.AddArg(mem) 17185 return true 17186 } 17187 return false 17188 } 17189 func rewriteValuegeneric_OpMul16_0(v *Value) bool { 17190 b := v.Block 17191 _ = b 17192 typ := &b.Func.Config.Types 17193 _ = typ 17194 // match: (Mul16 (Const16 [c]) (Const16 [d])) 17195 // cond: 17196 // result: (Const16 [int64(int16(c*d))]) 17197 for { 17198 _ = v.Args[1] 17199 v_0 := v.Args[0] 17200 if v_0.Op != OpConst16 { 17201 break 17202 } 17203 c := v_0.AuxInt 17204 v_1 := v.Args[1] 17205 if v_1.Op != OpConst16 { 17206 break 17207 } 17208 d := v_1.AuxInt 17209 v.reset(OpConst16) 17210 v.AuxInt = int64(int16(c * d)) 17211 return true 17212 } 17213 // match: (Mul16 (Const16 [d]) (Const16 [c])) 17214 // cond: 17215 // result: (Const16 [int64(int16(c*d))]) 17216 for { 17217 _ = v.Args[1] 17218 v_0 := v.Args[0] 17219 if v_0.Op != OpConst16 { 17220 break 17221 } 17222 d := v_0.AuxInt 17223 v_1 := v.Args[1] 17224 if v_1.Op != OpConst16 { 17225 break 17226 } 17227 c := v_1.AuxInt 17228 v.reset(OpConst16) 17229 v.AuxInt = int64(int16(c * d)) 17230 return true 17231 } 17232 // match: (Mul16 (Const16 [1]) x) 17233 // cond: 17234 // result: x 17235 for { 17236 _ = v.Args[1] 17237 v_0 := v.Args[0] 17238 if v_0.Op != OpConst16 { 17239 break 17240 } 17241 if v_0.AuxInt != 1 { 17242 break 17243 } 17244 x := v.Args[1] 17245 v.reset(OpCopy) 17246 v.Type = x.Type 17247 v.AddArg(x) 17248 return true 17249 } 17250 // match: (Mul16 x (Const16 [1])) 17251 // cond: 17252 // result: x 17253 for { 17254 _ = v.Args[1] 17255 x := v.Args[0] 17256 v_1 := v.Args[1] 17257 if v_1.Op != OpConst16 { 17258 break 17259 } 17260 if v_1.AuxInt != 1 { 17261 break 17262 } 17263 v.reset(OpCopy) 17264 v.Type = x.Type 17265 v.AddArg(x) 17266 return true 17267 } 17268 // match: (Mul16 (Const16 [-1]) x) 17269 // cond: 17270 // result: (Neg16 x) 17271 for { 17272 _ = v.Args[1] 17273 v_0 := v.Args[0] 17274 if v_0.Op != OpConst16 { 17275 break 17276 } 17277 if v_0.AuxInt != -1 { 17278 break 17279 } 17280 x := v.Args[1] 17281 v.reset(OpNeg16) 17282 v.AddArg(x) 17283 return true 17284 } 17285 // match: (Mul16 x (Const16 [-1])) 17286 // cond: 17287 // result: (Neg16 x) 17288 for { 17289 _ = v.Args[1] 17290 x := v.Args[0] 17291 v_1 := v.Args[1] 17292 if v_1.Op != OpConst16 { 17293 break 17294 } 17295 if v_1.AuxInt != -1 { 17296 break 17297 } 17298 v.reset(OpNeg16) 17299 v.AddArg(x) 17300 return true 17301 } 17302 // match: (Mul16 <t> n (Const16 [c])) 17303 // cond: isPowerOfTwo(c) 17304 // result: (Lsh16x64 <t> n (Const64 <typ.UInt64> [log2(c)])) 17305 for { 17306 t := v.Type 17307 _ = v.Args[1] 17308 n := v.Args[0] 17309 v_1 := v.Args[1] 17310 if v_1.Op != OpConst16 { 17311 break 17312 } 17313 c := v_1.AuxInt 17314 if !(isPowerOfTwo(c)) { 17315 break 17316 } 17317 v.reset(OpLsh16x64) 17318 v.Type = t 17319 v.AddArg(n) 17320 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 17321 v0.AuxInt = log2(c) 17322 v.AddArg(v0) 17323 return true 17324 } 17325 // match: (Mul16 <t> (Const16 [c]) n) 17326 // cond: isPowerOfTwo(c) 17327 // result: (Lsh16x64 <t> n (Const64 <typ.UInt64> [log2(c)])) 17328 for { 17329 t := v.Type 17330 _ = v.Args[1] 17331 v_0 := v.Args[0] 17332 if v_0.Op != OpConst16 { 17333 break 17334 } 17335 c := v_0.AuxInt 17336 n := v.Args[1] 17337 if !(isPowerOfTwo(c)) { 17338 break 17339 } 17340 v.reset(OpLsh16x64) 17341 v.Type = t 17342 v.AddArg(n) 17343 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 17344 v0.AuxInt = log2(c) 17345 v.AddArg(v0) 17346 return true 17347 } 17348 // match: (Mul16 <t> n (Const16 [c])) 17349 // cond: t.IsSigned() && isPowerOfTwo(-c) 17350 // result: (Neg16 (Lsh16x64 <t> n (Const64 <typ.UInt64> [log2(-c)]))) 17351 for { 17352 t := v.Type 17353 _ = v.Args[1] 17354 n := v.Args[0] 17355 v_1 := v.Args[1] 17356 if v_1.Op != OpConst16 { 17357 break 17358 } 17359 c := v_1.AuxInt 17360 if !(t.IsSigned() && isPowerOfTwo(-c)) { 17361 break 17362 } 17363 v.reset(OpNeg16) 17364 v0 := b.NewValue0(v.Pos, OpLsh16x64, t) 17365 v0.AddArg(n) 17366 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 17367 v1.AuxInt = log2(-c) 17368 v0.AddArg(v1) 17369 v.AddArg(v0) 17370 return true 17371 } 17372 // match: (Mul16 <t> (Const16 [c]) n) 17373 // cond: t.IsSigned() && isPowerOfTwo(-c) 17374 // result: (Neg16 (Lsh16x64 <t> n (Const64 <typ.UInt64> [log2(-c)]))) 17375 for { 17376 t := v.Type 17377 _ = v.Args[1] 17378 v_0 := v.Args[0] 17379 if v_0.Op != OpConst16 { 17380 break 17381 } 17382 c := v_0.AuxInt 17383 n := v.Args[1] 17384 if !(t.IsSigned() && isPowerOfTwo(-c)) { 17385 break 17386 } 17387 v.reset(OpNeg16) 17388 v0 := b.NewValue0(v.Pos, OpLsh16x64, t) 17389 v0.AddArg(n) 17390 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 17391 v1.AuxInt = log2(-c) 17392 v0.AddArg(v1) 17393 v.AddArg(v0) 17394 return true 17395 } 17396 return false 17397 } 17398 func rewriteValuegeneric_OpMul16_10(v *Value) bool { 17399 b := v.Block 17400 _ = b 17401 // match: (Mul16 (Const16 [0]) _) 17402 // cond: 17403 // result: (Const16 [0]) 17404 for { 17405 _ = v.Args[1] 17406 v_0 := v.Args[0] 17407 if v_0.Op != OpConst16 { 17408 break 17409 } 17410 if v_0.AuxInt != 0 { 17411 break 17412 } 17413 v.reset(OpConst16) 17414 v.AuxInt = 0 17415 return true 17416 } 17417 // match: (Mul16 _ (Const16 [0])) 17418 // cond: 17419 // result: (Const16 [0]) 17420 for { 17421 _ = v.Args[1] 17422 v_1 := v.Args[1] 17423 if v_1.Op != OpConst16 { 17424 break 17425 } 17426 if v_1.AuxInt != 0 { 17427 break 17428 } 17429 v.reset(OpConst16) 17430 v.AuxInt = 0 17431 return true 17432 } 17433 // match: (Mul16 (Const16 <t> [c]) (Mul16 (Const16 <t> [d]) x)) 17434 // cond: 17435 // result: (Mul16 (Const16 <t> [int64(int16(c*d))]) x) 17436 for { 17437 _ = v.Args[1] 17438 v_0 := v.Args[0] 17439 if v_0.Op != OpConst16 { 17440 break 17441 } 17442 t := v_0.Type 17443 c := v_0.AuxInt 17444 v_1 := v.Args[1] 17445 if v_1.Op != OpMul16 { 17446 break 17447 } 17448 _ = v_1.Args[1] 17449 v_1_0 := v_1.Args[0] 17450 if v_1_0.Op != OpConst16 { 17451 break 17452 } 17453 if v_1_0.Type != t { 17454 break 17455 } 17456 d := v_1_0.AuxInt 17457 x := v_1.Args[1] 17458 v.reset(OpMul16) 17459 v0 := b.NewValue0(v.Pos, OpConst16, t) 17460 v0.AuxInt = int64(int16(c * d)) 17461 v.AddArg(v0) 17462 v.AddArg(x) 17463 return true 17464 } 17465 // match: (Mul16 (Const16 <t> [c]) (Mul16 x (Const16 <t> [d]))) 17466 // cond: 17467 // result: (Mul16 (Const16 <t> [int64(int16(c*d))]) x) 17468 for { 17469 _ = v.Args[1] 17470 v_0 := v.Args[0] 17471 if v_0.Op != OpConst16 { 17472 break 17473 } 17474 t := v_0.Type 17475 c := v_0.AuxInt 17476 v_1 := v.Args[1] 17477 if v_1.Op != OpMul16 { 17478 break 17479 } 17480 _ = v_1.Args[1] 17481 x := v_1.Args[0] 17482 v_1_1 := v_1.Args[1] 17483 if v_1_1.Op != OpConst16 { 17484 break 17485 } 17486 if v_1_1.Type != t { 17487 break 17488 } 17489 d := v_1_1.AuxInt 17490 v.reset(OpMul16) 17491 v0 := b.NewValue0(v.Pos, OpConst16, t) 17492 v0.AuxInt = int64(int16(c * d)) 17493 v.AddArg(v0) 17494 v.AddArg(x) 17495 return true 17496 } 17497 // match: (Mul16 (Mul16 (Const16 <t> [d]) x) (Const16 <t> [c])) 17498 // cond: 17499 // result: (Mul16 (Const16 <t> [int64(int16(c*d))]) x) 17500 for { 17501 _ = v.Args[1] 17502 v_0 := v.Args[0] 17503 if v_0.Op != OpMul16 { 17504 break 17505 } 17506 _ = v_0.Args[1] 17507 v_0_0 := v_0.Args[0] 17508 if v_0_0.Op != OpConst16 { 17509 break 17510 } 17511 t := v_0_0.Type 17512 d := v_0_0.AuxInt 17513 x := v_0.Args[1] 17514 v_1 := v.Args[1] 17515 if v_1.Op != OpConst16 { 17516 break 17517 } 17518 if v_1.Type != t { 17519 break 17520 } 17521 c := v_1.AuxInt 17522 v.reset(OpMul16) 17523 v0 := b.NewValue0(v.Pos, OpConst16, t) 17524 v0.AuxInt = int64(int16(c * d)) 17525 v.AddArg(v0) 17526 v.AddArg(x) 17527 return true 17528 } 17529 // match: (Mul16 (Mul16 x (Const16 <t> [d])) (Const16 <t> [c])) 17530 // cond: 17531 // result: (Mul16 (Const16 <t> [int64(int16(c*d))]) x) 17532 for { 17533 _ = v.Args[1] 17534 v_0 := v.Args[0] 17535 if v_0.Op != OpMul16 { 17536 break 17537 } 17538 _ = v_0.Args[1] 17539 x := v_0.Args[0] 17540 v_0_1 := v_0.Args[1] 17541 if v_0_1.Op != OpConst16 { 17542 break 17543 } 17544 t := v_0_1.Type 17545 d := v_0_1.AuxInt 17546 v_1 := v.Args[1] 17547 if v_1.Op != OpConst16 { 17548 break 17549 } 17550 if v_1.Type != t { 17551 break 17552 } 17553 c := v_1.AuxInt 17554 v.reset(OpMul16) 17555 v0 := b.NewValue0(v.Pos, OpConst16, t) 17556 v0.AuxInt = int64(int16(c * d)) 17557 v.AddArg(v0) 17558 v.AddArg(x) 17559 return true 17560 } 17561 return false 17562 } 17563 func rewriteValuegeneric_OpMul32_0(v *Value) bool { 17564 b := v.Block 17565 _ = b 17566 typ := &b.Func.Config.Types 17567 _ = typ 17568 // match: (Mul32 (Const32 [c]) (Const32 [d])) 17569 // cond: 17570 // result: (Const32 [int64(int32(c*d))]) 17571 for { 17572 _ = v.Args[1] 17573 v_0 := v.Args[0] 17574 if v_0.Op != OpConst32 { 17575 break 17576 } 17577 c := v_0.AuxInt 17578 v_1 := v.Args[1] 17579 if v_1.Op != OpConst32 { 17580 break 17581 } 17582 d := v_1.AuxInt 17583 v.reset(OpConst32) 17584 v.AuxInt = int64(int32(c * d)) 17585 return true 17586 } 17587 // match: (Mul32 (Const32 [d]) (Const32 [c])) 17588 // cond: 17589 // result: (Const32 [int64(int32(c*d))]) 17590 for { 17591 _ = v.Args[1] 17592 v_0 := v.Args[0] 17593 if v_0.Op != OpConst32 { 17594 break 17595 } 17596 d := v_0.AuxInt 17597 v_1 := v.Args[1] 17598 if v_1.Op != OpConst32 { 17599 break 17600 } 17601 c := v_1.AuxInt 17602 v.reset(OpConst32) 17603 v.AuxInt = int64(int32(c * d)) 17604 return true 17605 } 17606 // match: (Mul32 (Const32 [1]) x) 17607 // cond: 17608 // result: x 17609 for { 17610 _ = v.Args[1] 17611 v_0 := v.Args[0] 17612 if v_0.Op != OpConst32 { 17613 break 17614 } 17615 if v_0.AuxInt != 1 { 17616 break 17617 } 17618 x := v.Args[1] 17619 v.reset(OpCopy) 17620 v.Type = x.Type 17621 v.AddArg(x) 17622 return true 17623 } 17624 // match: (Mul32 x (Const32 [1])) 17625 // cond: 17626 // result: x 17627 for { 17628 _ = v.Args[1] 17629 x := v.Args[0] 17630 v_1 := v.Args[1] 17631 if v_1.Op != OpConst32 { 17632 break 17633 } 17634 if v_1.AuxInt != 1 { 17635 break 17636 } 17637 v.reset(OpCopy) 17638 v.Type = x.Type 17639 v.AddArg(x) 17640 return true 17641 } 17642 // match: (Mul32 (Const32 [-1]) x) 17643 // cond: 17644 // result: (Neg32 x) 17645 for { 17646 _ = v.Args[1] 17647 v_0 := v.Args[0] 17648 if v_0.Op != OpConst32 { 17649 break 17650 } 17651 if v_0.AuxInt != -1 { 17652 break 17653 } 17654 x := v.Args[1] 17655 v.reset(OpNeg32) 17656 v.AddArg(x) 17657 return true 17658 } 17659 // match: (Mul32 x (Const32 [-1])) 17660 // cond: 17661 // result: (Neg32 x) 17662 for { 17663 _ = v.Args[1] 17664 x := v.Args[0] 17665 v_1 := v.Args[1] 17666 if v_1.Op != OpConst32 { 17667 break 17668 } 17669 if v_1.AuxInt != -1 { 17670 break 17671 } 17672 v.reset(OpNeg32) 17673 v.AddArg(x) 17674 return true 17675 } 17676 // match: (Mul32 <t> n (Const32 [c])) 17677 // cond: isPowerOfTwo(c) 17678 // result: (Lsh32x64 <t> n (Const64 <typ.UInt64> [log2(c)])) 17679 for { 17680 t := v.Type 17681 _ = v.Args[1] 17682 n := v.Args[0] 17683 v_1 := v.Args[1] 17684 if v_1.Op != OpConst32 { 17685 break 17686 } 17687 c := v_1.AuxInt 17688 if !(isPowerOfTwo(c)) { 17689 break 17690 } 17691 v.reset(OpLsh32x64) 17692 v.Type = t 17693 v.AddArg(n) 17694 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 17695 v0.AuxInt = log2(c) 17696 v.AddArg(v0) 17697 return true 17698 } 17699 // match: (Mul32 <t> (Const32 [c]) n) 17700 // cond: isPowerOfTwo(c) 17701 // result: (Lsh32x64 <t> n (Const64 <typ.UInt64> [log2(c)])) 17702 for { 17703 t := v.Type 17704 _ = v.Args[1] 17705 v_0 := v.Args[0] 17706 if v_0.Op != OpConst32 { 17707 break 17708 } 17709 c := v_0.AuxInt 17710 n := v.Args[1] 17711 if !(isPowerOfTwo(c)) { 17712 break 17713 } 17714 v.reset(OpLsh32x64) 17715 v.Type = t 17716 v.AddArg(n) 17717 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 17718 v0.AuxInt = log2(c) 17719 v.AddArg(v0) 17720 return true 17721 } 17722 // match: (Mul32 <t> n (Const32 [c])) 17723 // cond: t.IsSigned() && isPowerOfTwo(-c) 17724 // result: (Neg32 (Lsh32x64 <t> n (Const64 <typ.UInt64> [log2(-c)]))) 17725 for { 17726 t := v.Type 17727 _ = v.Args[1] 17728 n := v.Args[0] 17729 v_1 := v.Args[1] 17730 if v_1.Op != OpConst32 { 17731 break 17732 } 17733 c := v_1.AuxInt 17734 if !(t.IsSigned() && isPowerOfTwo(-c)) { 17735 break 17736 } 17737 v.reset(OpNeg32) 17738 v0 := b.NewValue0(v.Pos, OpLsh32x64, t) 17739 v0.AddArg(n) 17740 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 17741 v1.AuxInt = log2(-c) 17742 v0.AddArg(v1) 17743 v.AddArg(v0) 17744 return true 17745 } 17746 // match: (Mul32 <t> (Const32 [c]) n) 17747 // cond: t.IsSigned() && isPowerOfTwo(-c) 17748 // result: (Neg32 (Lsh32x64 <t> n (Const64 <typ.UInt64> [log2(-c)]))) 17749 for { 17750 t := v.Type 17751 _ = v.Args[1] 17752 v_0 := v.Args[0] 17753 if v_0.Op != OpConst32 { 17754 break 17755 } 17756 c := v_0.AuxInt 17757 n := v.Args[1] 17758 if !(t.IsSigned() && isPowerOfTwo(-c)) { 17759 break 17760 } 17761 v.reset(OpNeg32) 17762 v0 := b.NewValue0(v.Pos, OpLsh32x64, t) 17763 v0.AddArg(n) 17764 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 17765 v1.AuxInt = log2(-c) 17766 v0.AddArg(v1) 17767 v.AddArg(v0) 17768 return true 17769 } 17770 return false 17771 } 17772 func rewriteValuegeneric_OpMul32_10(v *Value) bool { 17773 b := v.Block 17774 _ = b 17775 // match: (Mul32 (Const32 <t> [c]) (Add32 <t> (Const32 <t> [d]) x)) 17776 // cond: 17777 // result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x)) 17778 for { 17779 _ = v.Args[1] 17780 v_0 := v.Args[0] 17781 if v_0.Op != OpConst32 { 17782 break 17783 } 17784 t := v_0.Type 17785 c := v_0.AuxInt 17786 v_1 := v.Args[1] 17787 if v_1.Op != OpAdd32 { 17788 break 17789 } 17790 if v_1.Type != t { 17791 break 17792 } 17793 _ = v_1.Args[1] 17794 v_1_0 := v_1.Args[0] 17795 if v_1_0.Op != OpConst32 { 17796 break 17797 } 17798 if v_1_0.Type != t { 17799 break 17800 } 17801 d := v_1_0.AuxInt 17802 x := v_1.Args[1] 17803 v.reset(OpAdd32) 17804 v0 := b.NewValue0(v.Pos, OpConst32, t) 17805 v0.AuxInt = int64(int32(c * d)) 17806 v.AddArg(v0) 17807 v1 := b.NewValue0(v.Pos, OpMul32, t) 17808 v2 := b.NewValue0(v.Pos, OpConst32, t) 17809 v2.AuxInt = c 17810 v1.AddArg(v2) 17811 v1.AddArg(x) 17812 v.AddArg(v1) 17813 return true 17814 } 17815 // match: (Mul32 (Const32 <t> [c]) (Add32 <t> x (Const32 <t> [d]))) 17816 // cond: 17817 // result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x)) 17818 for { 17819 _ = v.Args[1] 17820 v_0 := v.Args[0] 17821 if v_0.Op != OpConst32 { 17822 break 17823 } 17824 t := v_0.Type 17825 c := v_0.AuxInt 17826 v_1 := v.Args[1] 17827 if v_1.Op != OpAdd32 { 17828 break 17829 } 17830 if v_1.Type != t { 17831 break 17832 } 17833 _ = v_1.Args[1] 17834 x := v_1.Args[0] 17835 v_1_1 := v_1.Args[1] 17836 if v_1_1.Op != OpConst32 { 17837 break 17838 } 17839 if v_1_1.Type != t { 17840 break 17841 } 17842 d := v_1_1.AuxInt 17843 v.reset(OpAdd32) 17844 v0 := b.NewValue0(v.Pos, OpConst32, t) 17845 v0.AuxInt = int64(int32(c * d)) 17846 v.AddArg(v0) 17847 v1 := b.NewValue0(v.Pos, OpMul32, t) 17848 v2 := b.NewValue0(v.Pos, OpConst32, t) 17849 v2.AuxInt = c 17850 v1.AddArg(v2) 17851 v1.AddArg(x) 17852 v.AddArg(v1) 17853 return true 17854 } 17855 // match: (Mul32 (Add32 <t> (Const32 <t> [d]) x) (Const32 <t> [c])) 17856 // cond: 17857 // result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x)) 17858 for { 17859 _ = v.Args[1] 17860 v_0 := v.Args[0] 17861 if v_0.Op != OpAdd32 { 17862 break 17863 } 17864 t := v_0.Type 17865 _ = v_0.Args[1] 17866 v_0_0 := v_0.Args[0] 17867 if v_0_0.Op != OpConst32 { 17868 break 17869 } 17870 if v_0_0.Type != t { 17871 break 17872 } 17873 d := v_0_0.AuxInt 17874 x := v_0.Args[1] 17875 v_1 := v.Args[1] 17876 if v_1.Op != OpConst32 { 17877 break 17878 } 17879 if v_1.Type != t { 17880 break 17881 } 17882 c := v_1.AuxInt 17883 v.reset(OpAdd32) 17884 v0 := b.NewValue0(v.Pos, OpConst32, t) 17885 v0.AuxInt = int64(int32(c * d)) 17886 v.AddArg(v0) 17887 v1 := b.NewValue0(v.Pos, OpMul32, t) 17888 v2 := b.NewValue0(v.Pos, OpConst32, t) 17889 v2.AuxInt = c 17890 v1.AddArg(v2) 17891 v1.AddArg(x) 17892 v.AddArg(v1) 17893 return true 17894 } 17895 // match: (Mul32 (Add32 <t> x (Const32 <t> [d])) (Const32 <t> [c])) 17896 // cond: 17897 // result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x)) 17898 for { 17899 _ = v.Args[1] 17900 v_0 := v.Args[0] 17901 if v_0.Op != OpAdd32 { 17902 break 17903 } 17904 t := v_0.Type 17905 _ = v_0.Args[1] 17906 x := v_0.Args[0] 17907 v_0_1 := v_0.Args[1] 17908 if v_0_1.Op != OpConst32 { 17909 break 17910 } 17911 if v_0_1.Type != t { 17912 break 17913 } 17914 d := v_0_1.AuxInt 17915 v_1 := v.Args[1] 17916 if v_1.Op != OpConst32 { 17917 break 17918 } 17919 if v_1.Type != t { 17920 break 17921 } 17922 c := v_1.AuxInt 17923 v.reset(OpAdd32) 17924 v0 := b.NewValue0(v.Pos, OpConst32, t) 17925 v0.AuxInt = int64(int32(c * d)) 17926 v.AddArg(v0) 17927 v1 := b.NewValue0(v.Pos, OpMul32, t) 17928 v2 := b.NewValue0(v.Pos, OpConst32, t) 17929 v2.AuxInt = c 17930 v1.AddArg(v2) 17931 v1.AddArg(x) 17932 v.AddArg(v1) 17933 return true 17934 } 17935 // match: (Mul32 (Const32 [0]) _) 17936 // cond: 17937 // result: (Const32 [0]) 17938 for { 17939 _ = v.Args[1] 17940 v_0 := v.Args[0] 17941 if v_0.Op != OpConst32 { 17942 break 17943 } 17944 if v_0.AuxInt != 0 { 17945 break 17946 } 17947 v.reset(OpConst32) 17948 v.AuxInt = 0 17949 return true 17950 } 17951 // match: (Mul32 _ (Const32 [0])) 17952 // cond: 17953 // result: (Const32 [0]) 17954 for { 17955 _ = v.Args[1] 17956 v_1 := v.Args[1] 17957 if v_1.Op != OpConst32 { 17958 break 17959 } 17960 if v_1.AuxInt != 0 { 17961 break 17962 } 17963 v.reset(OpConst32) 17964 v.AuxInt = 0 17965 return true 17966 } 17967 // match: (Mul32 (Const32 <t> [c]) (Mul32 (Const32 <t> [d]) x)) 17968 // cond: 17969 // result: (Mul32 (Const32 <t> [int64(int32(c*d))]) x) 17970 for { 17971 _ = v.Args[1] 17972 v_0 := v.Args[0] 17973 if v_0.Op != OpConst32 { 17974 break 17975 } 17976 t := v_0.Type 17977 c := v_0.AuxInt 17978 v_1 := v.Args[1] 17979 if v_1.Op != OpMul32 { 17980 break 17981 } 17982 _ = v_1.Args[1] 17983 v_1_0 := v_1.Args[0] 17984 if v_1_0.Op != OpConst32 { 17985 break 17986 } 17987 if v_1_0.Type != t { 17988 break 17989 } 17990 d := v_1_0.AuxInt 17991 x := v_1.Args[1] 17992 v.reset(OpMul32) 17993 v0 := b.NewValue0(v.Pos, OpConst32, t) 17994 v0.AuxInt = int64(int32(c * d)) 17995 v.AddArg(v0) 17996 v.AddArg(x) 17997 return true 17998 } 17999 // match: (Mul32 (Const32 <t> [c]) (Mul32 x (Const32 <t> [d]))) 18000 // cond: 18001 // result: (Mul32 (Const32 <t> [int64(int32(c*d))]) x) 18002 for { 18003 _ = v.Args[1] 18004 v_0 := v.Args[0] 18005 if v_0.Op != OpConst32 { 18006 break 18007 } 18008 t := v_0.Type 18009 c := v_0.AuxInt 18010 v_1 := v.Args[1] 18011 if v_1.Op != OpMul32 { 18012 break 18013 } 18014 _ = v_1.Args[1] 18015 x := v_1.Args[0] 18016 v_1_1 := v_1.Args[1] 18017 if v_1_1.Op != OpConst32 { 18018 break 18019 } 18020 if v_1_1.Type != t { 18021 break 18022 } 18023 d := v_1_1.AuxInt 18024 v.reset(OpMul32) 18025 v0 := b.NewValue0(v.Pos, OpConst32, t) 18026 v0.AuxInt = int64(int32(c * d)) 18027 v.AddArg(v0) 18028 v.AddArg(x) 18029 return true 18030 } 18031 // match: (Mul32 (Mul32 (Const32 <t> [d]) x) (Const32 <t> [c])) 18032 // cond: 18033 // result: (Mul32 (Const32 <t> [int64(int32(c*d))]) x) 18034 for { 18035 _ = v.Args[1] 18036 v_0 := v.Args[0] 18037 if v_0.Op != OpMul32 { 18038 break 18039 } 18040 _ = v_0.Args[1] 18041 v_0_0 := v_0.Args[0] 18042 if v_0_0.Op != OpConst32 { 18043 break 18044 } 18045 t := v_0_0.Type 18046 d := v_0_0.AuxInt 18047 x := v_0.Args[1] 18048 v_1 := v.Args[1] 18049 if v_1.Op != OpConst32 { 18050 break 18051 } 18052 if v_1.Type != t { 18053 break 18054 } 18055 c := v_1.AuxInt 18056 v.reset(OpMul32) 18057 v0 := b.NewValue0(v.Pos, OpConst32, t) 18058 v0.AuxInt = int64(int32(c * d)) 18059 v.AddArg(v0) 18060 v.AddArg(x) 18061 return true 18062 } 18063 // match: (Mul32 (Mul32 x (Const32 <t> [d])) (Const32 <t> [c])) 18064 // cond: 18065 // result: (Mul32 (Const32 <t> [int64(int32(c*d))]) x) 18066 for { 18067 _ = v.Args[1] 18068 v_0 := v.Args[0] 18069 if v_0.Op != OpMul32 { 18070 break 18071 } 18072 _ = v_0.Args[1] 18073 x := v_0.Args[0] 18074 v_0_1 := v_0.Args[1] 18075 if v_0_1.Op != OpConst32 { 18076 break 18077 } 18078 t := v_0_1.Type 18079 d := v_0_1.AuxInt 18080 v_1 := v.Args[1] 18081 if v_1.Op != OpConst32 { 18082 break 18083 } 18084 if v_1.Type != t { 18085 break 18086 } 18087 c := v_1.AuxInt 18088 v.reset(OpMul32) 18089 v0 := b.NewValue0(v.Pos, OpConst32, t) 18090 v0.AuxInt = int64(int32(c * d)) 18091 v.AddArg(v0) 18092 v.AddArg(x) 18093 return true 18094 } 18095 return false 18096 } 18097 func rewriteValuegeneric_OpMul32F_0(v *Value) bool { 18098 // match: (Mul32F (Const32F [c]) (Const32F [d])) 18099 // cond: 18100 // result: (Const32F [auxFrom32F(auxTo32F(c) * auxTo32F(d))]) 18101 for { 18102 _ = v.Args[1] 18103 v_0 := v.Args[0] 18104 if v_0.Op != OpConst32F { 18105 break 18106 } 18107 c := v_0.AuxInt 18108 v_1 := v.Args[1] 18109 if v_1.Op != OpConst32F { 18110 break 18111 } 18112 d := v_1.AuxInt 18113 v.reset(OpConst32F) 18114 v.AuxInt = auxFrom32F(auxTo32F(c) * auxTo32F(d)) 18115 return true 18116 } 18117 // match: (Mul32F (Const32F [d]) (Const32F [c])) 18118 // cond: 18119 // result: (Const32F [auxFrom32F(auxTo32F(c) * auxTo32F(d))]) 18120 for { 18121 _ = v.Args[1] 18122 v_0 := v.Args[0] 18123 if v_0.Op != OpConst32F { 18124 break 18125 } 18126 d := v_0.AuxInt 18127 v_1 := v.Args[1] 18128 if v_1.Op != OpConst32F { 18129 break 18130 } 18131 c := v_1.AuxInt 18132 v.reset(OpConst32F) 18133 v.AuxInt = auxFrom32F(auxTo32F(c) * auxTo32F(d)) 18134 return true 18135 } 18136 // match: (Mul32F x (Const32F [auxFrom64F(1)])) 18137 // cond: 18138 // result: x 18139 for { 18140 _ = v.Args[1] 18141 x := v.Args[0] 18142 v_1 := v.Args[1] 18143 if v_1.Op != OpConst32F { 18144 break 18145 } 18146 if v_1.AuxInt != auxFrom64F(1) { 18147 break 18148 } 18149 v.reset(OpCopy) 18150 v.Type = x.Type 18151 v.AddArg(x) 18152 return true 18153 } 18154 // match: (Mul32F (Const32F [auxFrom64F(1)]) x) 18155 // cond: 18156 // result: x 18157 for { 18158 _ = v.Args[1] 18159 v_0 := v.Args[0] 18160 if v_0.Op != OpConst32F { 18161 break 18162 } 18163 if v_0.AuxInt != auxFrom64F(1) { 18164 break 18165 } 18166 x := v.Args[1] 18167 v.reset(OpCopy) 18168 v.Type = x.Type 18169 v.AddArg(x) 18170 return true 18171 } 18172 // match: (Mul32F x (Const32F [auxFrom32F(-1)])) 18173 // cond: 18174 // result: (Neg32F x) 18175 for { 18176 _ = v.Args[1] 18177 x := v.Args[0] 18178 v_1 := v.Args[1] 18179 if v_1.Op != OpConst32F { 18180 break 18181 } 18182 if v_1.AuxInt != auxFrom32F(-1) { 18183 break 18184 } 18185 v.reset(OpNeg32F) 18186 v.AddArg(x) 18187 return true 18188 } 18189 // match: (Mul32F (Const32F [auxFrom32F(-1)]) x) 18190 // cond: 18191 // result: (Neg32F x) 18192 for { 18193 _ = v.Args[1] 18194 v_0 := v.Args[0] 18195 if v_0.Op != OpConst32F { 18196 break 18197 } 18198 if v_0.AuxInt != auxFrom32F(-1) { 18199 break 18200 } 18201 x := v.Args[1] 18202 v.reset(OpNeg32F) 18203 v.AddArg(x) 18204 return true 18205 } 18206 // match: (Mul32F x (Const32F [auxFrom32F(2)])) 18207 // cond: 18208 // result: (Add32F x x) 18209 for { 18210 _ = v.Args[1] 18211 x := v.Args[0] 18212 v_1 := v.Args[1] 18213 if v_1.Op != OpConst32F { 18214 break 18215 } 18216 if v_1.AuxInt != auxFrom32F(2) { 18217 break 18218 } 18219 v.reset(OpAdd32F) 18220 v.AddArg(x) 18221 v.AddArg(x) 18222 return true 18223 } 18224 // match: (Mul32F (Const32F [auxFrom32F(2)]) x) 18225 // cond: 18226 // result: (Add32F x x) 18227 for { 18228 _ = v.Args[1] 18229 v_0 := v.Args[0] 18230 if v_0.Op != OpConst32F { 18231 break 18232 } 18233 if v_0.AuxInt != auxFrom32F(2) { 18234 break 18235 } 18236 x := v.Args[1] 18237 v.reset(OpAdd32F) 18238 v.AddArg(x) 18239 v.AddArg(x) 18240 return true 18241 } 18242 return false 18243 } 18244 func rewriteValuegeneric_OpMul64_0(v *Value) bool { 18245 b := v.Block 18246 _ = b 18247 typ := &b.Func.Config.Types 18248 _ = typ 18249 // match: (Mul64 (Const64 [c]) (Const64 [d])) 18250 // cond: 18251 // result: (Const64 [c*d]) 18252 for { 18253 _ = v.Args[1] 18254 v_0 := v.Args[0] 18255 if v_0.Op != OpConst64 { 18256 break 18257 } 18258 c := v_0.AuxInt 18259 v_1 := v.Args[1] 18260 if v_1.Op != OpConst64 { 18261 break 18262 } 18263 d := v_1.AuxInt 18264 v.reset(OpConst64) 18265 v.AuxInt = c * d 18266 return true 18267 } 18268 // match: (Mul64 (Const64 [d]) (Const64 [c])) 18269 // cond: 18270 // result: (Const64 [c*d]) 18271 for { 18272 _ = v.Args[1] 18273 v_0 := v.Args[0] 18274 if v_0.Op != OpConst64 { 18275 break 18276 } 18277 d := v_0.AuxInt 18278 v_1 := v.Args[1] 18279 if v_1.Op != OpConst64 { 18280 break 18281 } 18282 c := v_1.AuxInt 18283 v.reset(OpConst64) 18284 v.AuxInt = c * d 18285 return true 18286 } 18287 // match: (Mul64 (Const64 [1]) x) 18288 // cond: 18289 // result: x 18290 for { 18291 _ = v.Args[1] 18292 v_0 := v.Args[0] 18293 if v_0.Op != OpConst64 { 18294 break 18295 } 18296 if v_0.AuxInt != 1 { 18297 break 18298 } 18299 x := v.Args[1] 18300 v.reset(OpCopy) 18301 v.Type = x.Type 18302 v.AddArg(x) 18303 return true 18304 } 18305 // match: (Mul64 x (Const64 [1])) 18306 // cond: 18307 // result: x 18308 for { 18309 _ = v.Args[1] 18310 x := v.Args[0] 18311 v_1 := v.Args[1] 18312 if v_1.Op != OpConst64 { 18313 break 18314 } 18315 if v_1.AuxInt != 1 { 18316 break 18317 } 18318 v.reset(OpCopy) 18319 v.Type = x.Type 18320 v.AddArg(x) 18321 return true 18322 } 18323 // match: (Mul64 (Const64 [-1]) x) 18324 // cond: 18325 // result: (Neg64 x) 18326 for { 18327 _ = v.Args[1] 18328 v_0 := v.Args[0] 18329 if v_0.Op != OpConst64 { 18330 break 18331 } 18332 if v_0.AuxInt != -1 { 18333 break 18334 } 18335 x := v.Args[1] 18336 v.reset(OpNeg64) 18337 v.AddArg(x) 18338 return true 18339 } 18340 // match: (Mul64 x (Const64 [-1])) 18341 // cond: 18342 // result: (Neg64 x) 18343 for { 18344 _ = v.Args[1] 18345 x := v.Args[0] 18346 v_1 := v.Args[1] 18347 if v_1.Op != OpConst64 { 18348 break 18349 } 18350 if v_1.AuxInt != -1 { 18351 break 18352 } 18353 v.reset(OpNeg64) 18354 v.AddArg(x) 18355 return true 18356 } 18357 // match: (Mul64 <t> n (Const64 [c])) 18358 // cond: isPowerOfTwo(c) 18359 // result: (Lsh64x64 <t> n (Const64 <typ.UInt64> [log2(c)])) 18360 for { 18361 t := v.Type 18362 _ = v.Args[1] 18363 n := v.Args[0] 18364 v_1 := v.Args[1] 18365 if v_1.Op != OpConst64 { 18366 break 18367 } 18368 c := v_1.AuxInt 18369 if !(isPowerOfTwo(c)) { 18370 break 18371 } 18372 v.reset(OpLsh64x64) 18373 v.Type = t 18374 v.AddArg(n) 18375 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 18376 v0.AuxInt = log2(c) 18377 v.AddArg(v0) 18378 return true 18379 } 18380 // match: (Mul64 <t> (Const64 [c]) n) 18381 // cond: isPowerOfTwo(c) 18382 // result: (Lsh64x64 <t> n (Const64 <typ.UInt64> [log2(c)])) 18383 for { 18384 t := v.Type 18385 _ = v.Args[1] 18386 v_0 := v.Args[0] 18387 if v_0.Op != OpConst64 { 18388 break 18389 } 18390 c := v_0.AuxInt 18391 n := v.Args[1] 18392 if !(isPowerOfTwo(c)) { 18393 break 18394 } 18395 v.reset(OpLsh64x64) 18396 v.Type = t 18397 v.AddArg(n) 18398 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 18399 v0.AuxInt = log2(c) 18400 v.AddArg(v0) 18401 return true 18402 } 18403 // match: (Mul64 <t> n (Const64 [c])) 18404 // cond: t.IsSigned() && isPowerOfTwo(-c) 18405 // result: (Neg64 (Lsh64x64 <t> n (Const64 <typ.UInt64> [log2(-c)]))) 18406 for { 18407 t := v.Type 18408 _ = v.Args[1] 18409 n := v.Args[0] 18410 v_1 := v.Args[1] 18411 if v_1.Op != OpConst64 { 18412 break 18413 } 18414 c := v_1.AuxInt 18415 if !(t.IsSigned() && isPowerOfTwo(-c)) { 18416 break 18417 } 18418 v.reset(OpNeg64) 18419 v0 := b.NewValue0(v.Pos, OpLsh64x64, t) 18420 v0.AddArg(n) 18421 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 18422 v1.AuxInt = log2(-c) 18423 v0.AddArg(v1) 18424 v.AddArg(v0) 18425 return true 18426 } 18427 // match: (Mul64 <t> (Const64 [c]) n) 18428 // cond: t.IsSigned() && isPowerOfTwo(-c) 18429 // result: (Neg64 (Lsh64x64 <t> n (Const64 <typ.UInt64> [log2(-c)]))) 18430 for { 18431 t := v.Type 18432 _ = v.Args[1] 18433 v_0 := v.Args[0] 18434 if v_0.Op != OpConst64 { 18435 break 18436 } 18437 c := v_0.AuxInt 18438 n := v.Args[1] 18439 if !(t.IsSigned() && isPowerOfTwo(-c)) { 18440 break 18441 } 18442 v.reset(OpNeg64) 18443 v0 := b.NewValue0(v.Pos, OpLsh64x64, t) 18444 v0.AddArg(n) 18445 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 18446 v1.AuxInt = log2(-c) 18447 v0.AddArg(v1) 18448 v.AddArg(v0) 18449 return true 18450 } 18451 return false 18452 } 18453 func rewriteValuegeneric_OpMul64_10(v *Value) bool { 18454 b := v.Block 18455 _ = b 18456 // match: (Mul64 (Const64 <t> [c]) (Add64 <t> (Const64 <t> [d]) x)) 18457 // cond: 18458 // result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x)) 18459 for { 18460 _ = v.Args[1] 18461 v_0 := v.Args[0] 18462 if v_0.Op != OpConst64 { 18463 break 18464 } 18465 t := v_0.Type 18466 c := v_0.AuxInt 18467 v_1 := v.Args[1] 18468 if v_1.Op != OpAdd64 { 18469 break 18470 } 18471 if v_1.Type != t { 18472 break 18473 } 18474 _ = v_1.Args[1] 18475 v_1_0 := v_1.Args[0] 18476 if v_1_0.Op != OpConst64 { 18477 break 18478 } 18479 if v_1_0.Type != t { 18480 break 18481 } 18482 d := v_1_0.AuxInt 18483 x := v_1.Args[1] 18484 v.reset(OpAdd64) 18485 v0 := b.NewValue0(v.Pos, OpConst64, t) 18486 v0.AuxInt = c * d 18487 v.AddArg(v0) 18488 v1 := b.NewValue0(v.Pos, OpMul64, t) 18489 v2 := b.NewValue0(v.Pos, OpConst64, t) 18490 v2.AuxInt = c 18491 v1.AddArg(v2) 18492 v1.AddArg(x) 18493 v.AddArg(v1) 18494 return true 18495 } 18496 // match: (Mul64 (Const64 <t> [c]) (Add64 <t> x (Const64 <t> [d]))) 18497 // cond: 18498 // result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x)) 18499 for { 18500 _ = v.Args[1] 18501 v_0 := v.Args[0] 18502 if v_0.Op != OpConst64 { 18503 break 18504 } 18505 t := v_0.Type 18506 c := v_0.AuxInt 18507 v_1 := v.Args[1] 18508 if v_1.Op != OpAdd64 { 18509 break 18510 } 18511 if v_1.Type != t { 18512 break 18513 } 18514 _ = v_1.Args[1] 18515 x := v_1.Args[0] 18516 v_1_1 := v_1.Args[1] 18517 if v_1_1.Op != OpConst64 { 18518 break 18519 } 18520 if v_1_1.Type != t { 18521 break 18522 } 18523 d := v_1_1.AuxInt 18524 v.reset(OpAdd64) 18525 v0 := b.NewValue0(v.Pos, OpConst64, t) 18526 v0.AuxInt = c * d 18527 v.AddArg(v0) 18528 v1 := b.NewValue0(v.Pos, OpMul64, t) 18529 v2 := b.NewValue0(v.Pos, OpConst64, t) 18530 v2.AuxInt = c 18531 v1.AddArg(v2) 18532 v1.AddArg(x) 18533 v.AddArg(v1) 18534 return true 18535 } 18536 // match: (Mul64 (Add64 <t> (Const64 <t> [d]) x) (Const64 <t> [c])) 18537 // cond: 18538 // result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x)) 18539 for { 18540 _ = v.Args[1] 18541 v_0 := v.Args[0] 18542 if v_0.Op != OpAdd64 { 18543 break 18544 } 18545 t := v_0.Type 18546 _ = v_0.Args[1] 18547 v_0_0 := v_0.Args[0] 18548 if v_0_0.Op != OpConst64 { 18549 break 18550 } 18551 if v_0_0.Type != t { 18552 break 18553 } 18554 d := v_0_0.AuxInt 18555 x := v_0.Args[1] 18556 v_1 := v.Args[1] 18557 if v_1.Op != OpConst64 { 18558 break 18559 } 18560 if v_1.Type != t { 18561 break 18562 } 18563 c := v_1.AuxInt 18564 v.reset(OpAdd64) 18565 v0 := b.NewValue0(v.Pos, OpConst64, t) 18566 v0.AuxInt = c * d 18567 v.AddArg(v0) 18568 v1 := b.NewValue0(v.Pos, OpMul64, t) 18569 v2 := b.NewValue0(v.Pos, OpConst64, t) 18570 v2.AuxInt = c 18571 v1.AddArg(v2) 18572 v1.AddArg(x) 18573 v.AddArg(v1) 18574 return true 18575 } 18576 // match: (Mul64 (Add64 <t> x (Const64 <t> [d])) (Const64 <t> [c])) 18577 // cond: 18578 // result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x)) 18579 for { 18580 _ = v.Args[1] 18581 v_0 := v.Args[0] 18582 if v_0.Op != OpAdd64 { 18583 break 18584 } 18585 t := v_0.Type 18586 _ = v_0.Args[1] 18587 x := v_0.Args[0] 18588 v_0_1 := v_0.Args[1] 18589 if v_0_1.Op != OpConst64 { 18590 break 18591 } 18592 if v_0_1.Type != t { 18593 break 18594 } 18595 d := v_0_1.AuxInt 18596 v_1 := v.Args[1] 18597 if v_1.Op != OpConst64 { 18598 break 18599 } 18600 if v_1.Type != t { 18601 break 18602 } 18603 c := v_1.AuxInt 18604 v.reset(OpAdd64) 18605 v0 := b.NewValue0(v.Pos, OpConst64, t) 18606 v0.AuxInt = c * d 18607 v.AddArg(v0) 18608 v1 := b.NewValue0(v.Pos, OpMul64, t) 18609 v2 := b.NewValue0(v.Pos, OpConst64, t) 18610 v2.AuxInt = c 18611 v1.AddArg(v2) 18612 v1.AddArg(x) 18613 v.AddArg(v1) 18614 return true 18615 } 18616 // match: (Mul64 (Const64 [0]) _) 18617 // cond: 18618 // result: (Const64 [0]) 18619 for { 18620 _ = v.Args[1] 18621 v_0 := v.Args[0] 18622 if v_0.Op != OpConst64 { 18623 break 18624 } 18625 if v_0.AuxInt != 0 { 18626 break 18627 } 18628 v.reset(OpConst64) 18629 v.AuxInt = 0 18630 return true 18631 } 18632 // match: (Mul64 _ (Const64 [0])) 18633 // cond: 18634 // result: (Const64 [0]) 18635 for { 18636 _ = v.Args[1] 18637 v_1 := v.Args[1] 18638 if v_1.Op != OpConst64 { 18639 break 18640 } 18641 if v_1.AuxInt != 0 { 18642 break 18643 } 18644 v.reset(OpConst64) 18645 v.AuxInt = 0 18646 return true 18647 } 18648 // match: (Mul64 (Const64 <t> [c]) (Mul64 (Const64 <t> [d]) x)) 18649 // cond: 18650 // result: (Mul64 (Const64 <t> [c*d]) x) 18651 for { 18652 _ = v.Args[1] 18653 v_0 := v.Args[0] 18654 if v_0.Op != OpConst64 { 18655 break 18656 } 18657 t := v_0.Type 18658 c := v_0.AuxInt 18659 v_1 := v.Args[1] 18660 if v_1.Op != OpMul64 { 18661 break 18662 } 18663 _ = v_1.Args[1] 18664 v_1_0 := v_1.Args[0] 18665 if v_1_0.Op != OpConst64 { 18666 break 18667 } 18668 if v_1_0.Type != t { 18669 break 18670 } 18671 d := v_1_0.AuxInt 18672 x := v_1.Args[1] 18673 v.reset(OpMul64) 18674 v0 := b.NewValue0(v.Pos, OpConst64, t) 18675 v0.AuxInt = c * d 18676 v.AddArg(v0) 18677 v.AddArg(x) 18678 return true 18679 } 18680 // match: (Mul64 (Const64 <t> [c]) (Mul64 x (Const64 <t> [d]))) 18681 // cond: 18682 // result: (Mul64 (Const64 <t> [c*d]) x) 18683 for { 18684 _ = v.Args[1] 18685 v_0 := v.Args[0] 18686 if v_0.Op != OpConst64 { 18687 break 18688 } 18689 t := v_0.Type 18690 c := v_0.AuxInt 18691 v_1 := v.Args[1] 18692 if v_1.Op != OpMul64 { 18693 break 18694 } 18695 _ = v_1.Args[1] 18696 x := v_1.Args[0] 18697 v_1_1 := v_1.Args[1] 18698 if v_1_1.Op != OpConst64 { 18699 break 18700 } 18701 if v_1_1.Type != t { 18702 break 18703 } 18704 d := v_1_1.AuxInt 18705 v.reset(OpMul64) 18706 v0 := b.NewValue0(v.Pos, OpConst64, t) 18707 v0.AuxInt = c * d 18708 v.AddArg(v0) 18709 v.AddArg(x) 18710 return true 18711 } 18712 // match: (Mul64 (Mul64 (Const64 <t> [d]) x) (Const64 <t> [c])) 18713 // cond: 18714 // result: (Mul64 (Const64 <t> [c*d]) x) 18715 for { 18716 _ = v.Args[1] 18717 v_0 := v.Args[0] 18718 if v_0.Op != OpMul64 { 18719 break 18720 } 18721 _ = v_0.Args[1] 18722 v_0_0 := v_0.Args[0] 18723 if v_0_0.Op != OpConst64 { 18724 break 18725 } 18726 t := v_0_0.Type 18727 d := v_0_0.AuxInt 18728 x := v_0.Args[1] 18729 v_1 := v.Args[1] 18730 if v_1.Op != OpConst64 { 18731 break 18732 } 18733 if v_1.Type != t { 18734 break 18735 } 18736 c := v_1.AuxInt 18737 v.reset(OpMul64) 18738 v0 := b.NewValue0(v.Pos, OpConst64, t) 18739 v0.AuxInt = c * d 18740 v.AddArg(v0) 18741 v.AddArg(x) 18742 return true 18743 } 18744 // match: (Mul64 (Mul64 x (Const64 <t> [d])) (Const64 <t> [c])) 18745 // cond: 18746 // result: (Mul64 (Const64 <t> [c*d]) x) 18747 for { 18748 _ = v.Args[1] 18749 v_0 := v.Args[0] 18750 if v_0.Op != OpMul64 { 18751 break 18752 } 18753 _ = v_0.Args[1] 18754 x := v_0.Args[0] 18755 v_0_1 := v_0.Args[1] 18756 if v_0_1.Op != OpConst64 { 18757 break 18758 } 18759 t := v_0_1.Type 18760 d := v_0_1.AuxInt 18761 v_1 := v.Args[1] 18762 if v_1.Op != OpConst64 { 18763 break 18764 } 18765 if v_1.Type != t { 18766 break 18767 } 18768 c := v_1.AuxInt 18769 v.reset(OpMul64) 18770 v0 := b.NewValue0(v.Pos, OpConst64, t) 18771 v0.AuxInt = c * d 18772 v.AddArg(v0) 18773 v.AddArg(x) 18774 return true 18775 } 18776 return false 18777 } 18778 func rewriteValuegeneric_OpMul64F_0(v *Value) bool { 18779 // match: (Mul64F (Const64F [c]) (Const64F [d])) 18780 // cond: 18781 // result: (Const64F [auxFrom64F(auxTo64F(c) * auxTo64F(d))]) 18782 for { 18783 _ = v.Args[1] 18784 v_0 := v.Args[0] 18785 if v_0.Op != OpConst64F { 18786 break 18787 } 18788 c := v_0.AuxInt 18789 v_1 := v.Args[1] 18790 if v_1.Op != OpConst64F { 18791 break 18792 } 18793 d := v_1.AuxInt 18794 v.reset(OpConst64F) 18795 v.AuxInt = auxFrom64F(auxTo64F(c) * auxTo64F(d)) 18796 return true 18797 } 18798 // match: (Mul64F (Const64F [d]) (Const64F [c])) 18799 // cond: 18800 // result: (Const64F [auxFrom64F(auxTo64F(c) * auxTo64F(d))]) 18801 for { 18802 _ = v.Args[1] 18803 v_0 := v.Args[0] 18804 if v_0.Op != OpConst64F { 18805 break 18806 } 18807 d := v_0.AuxInt 18808 v_1 := v.Args[1] 18809 if v_1.Op != OpConst64F { 18810 break 18811 } 18812 c := v_1.AuxInt 18813 v.reset(OpConst64F) 18814 v.AuxInt = auxFrom64F(auxTo64F(c) * auxTo64F(d)) 18815 return true 18816 } 18817 // match: (Mul64F x (Const64F [auxFrom64F(1)])) 18818 // cond: 18819 // result: x 18820 for { 18821 _ = v.Args[1] 18822 x := v.Args[0] 18823 v_1 := v.Args[1] 18824 if v_1.Op != OpConst64F { 18825 break 18826 } 18827 if v_1.AuxInt != auxFrom64F(1) { 18828 break 18829 } 18830 v.reset(OpCopy) 18831 v.Type = x.Type 18832 v.AddArg(x) 18833 return true 18834 } 18835 // match: (Mul64F (Const64F [auxFrom64F(1)]) x) 18836 // cond: 18837 // result: x 18838 for { 18839 _ = v.Args[1] 18840 v_0 := v.Args[0] 18841 if v_0.Op != OpConst64F { 18842 break 18843 } 18844 if v_0.AuxInt != auxFrom64F(1) { 18845 break 18846 } 18847 x := v.Args[1] 18848 v.reset(OpCopy) 18849 v.Type = x.Type 18850 v.AddArg(x) 18851 return true 18852 } 18853 // match: (Mul64F x (Const64F [auxFrom64F(-1)])) 18854 // cond: 18855 // result: (Neg64F x) 18856 for { 18857 _ = v.Args[1] 18858 x := v.Args[0] 18859 v_1 := v.Args[1] 18860 if v_1.Op != OpConst64F { 18861 break 18862 } 18863 if v_1.AuxInt != auxFrom64F(-1) { 18864 break 18865 } 18866 v.reset(OpNeg64F) 18867 v.AddArg(x) 18868 return true 18869 } 18870 // match: (Mul64F (Const64F [auxFrom64F(-1)]) x) 18871 // cond: 18872 // result: (Neg64F x) 18873 for { 18874 _ = v.Args[1] 18875 v_0 := v.Args[0] 18876 if v_0.Op != OpConst64F { 18877 break 18878 } 18879 if v_0.AuxInt != auxFrom64F(-1) { 18880 break 18881 } 18882 x := v.Args[1] 18883 v.reset(OpNeg64F) 18884 v.AddArg(x) 18885 return true 18886 } 18887 // match: (Mul64F x (Const64F [auxFrom64F(2)])) 18888 // cond: 18889 // result: (Add64F x x) 18890 for { 18891 _ = v.Args[1] 18892 x := v.Args[0] 18893 v_1 := v.Args[1] 18894 if v_1.Op != OpConst64F { 18895 break 18896 } 18897 if v_1.AuxInt != auxFrom64F(2) { 18898 break 18899 } 18900 v.reset(OpAdd64F) 18901 v.AddArg(x) 18902 v.AddArg(x) 18903 return true 18904 } 18905 // match: (Mul64F (Const64F [auxFrom64F(2)]) x) 18906 // cond: 18907 // result: (Add64F x x) 18908 for { 18909 _ = v.Args[1] 18910 v_0 := v.Args[0] 18911 if v_0.Op != OpConst64F { 18912 break 18913 } 18914 if v_0.AuxInt != auxFrom64F(2) { 18915 break 18916 } 18917 x := v.Args[1] 18918 v.reset(OpAdd64F) 18919 v.AddArg(x) 18920 v.AddArg(x) 18921 return true 18922 } 18923 return false 18924 } 18925 func rewriteValuegeneric_OpMul8_0(v *Value) bool { 18926 b := v.Block 18927 _ = b 18928 typ := &b.Func.Config.Types 18929 _ = typ 18930 // match: (Mul8 (Const8 [c]) (Const8 [d])) 18931 // cond: 18932 // result: (Const8 [int64(int8(c*d))]) 18933 for { 18934 _ = v.Args[1] 18935 v_0 := v.Args[0] 18936 if v_0.Op != OpConst8 { 18937 break 18938 } 18939 c := v_0.AuxInt 18940 v_1 := v.Args[1] 18941 if v_1.Op != OpConst8 { 18942 break 18943 } 18944 d := v_1.AuxInt 18945 v.reset(OpConst8) 18946 v.AuxInt = int64(int8(c * d)) 18947 return true 18948 } 18949 // match: (Mul8 (Const8 [d]) (Const8 [c])) 18950 // cond: 18951 // result: (Const8 [int64(int8(c*d))]) 18952 for { 18953 _ = v.Args[1] 18954 v_0 := v.Args[0] 18955 if v_0.Op != OpConst8 { 18956 break 18957 } 18958 d := v_0.AuxInt 18959 v_1 := v.Args[1] 18960 if v_1.Op != OpConst8 { 18961 break 18962 } 18963 c := v_1.AuxInt 18964 v.reset(OpConst8) 18965 v.AuxInt = int64(int8(c * d)) 18966 return true 18967 } 18968 // match: (Mul8 (Const8 [1]) x) 18969 // cond: 18970 // result: x 18971 for { 18972 _ = v.Args[1] 18973 v_0 := v.Args[0] 18974 if v_0.Op != OpConst8 { 18975 break 18976 } 18977 if v_0.AuxInt != 1 { 18978 break 18979 } 18980 x := v.Args[1] 18981 v.reset(OpCopy) 18982 v.Type = x.Type 18983 v.AddArg(x) 18984 return true 18985 } 18986 // match: (Mul8 x (Const8 [1])) 18987 // cond: 18988 // result: x 18989 for { 18990 _ = v.Args[1] 18991 x := v.Args[0] 18992 v_1 := v.Args[1] 18993 if v_1.Op != OpConst8 { 18994 break 18995 } 18996 if v_1.AuxInt != 1 { 18997 break 18998 } 18999 v.reset(OpCopy) 19000 v.Type = x.Type 19001 v.AddArg(x) 19002 return true 19003 } 19004 // match: (Mul8 (Const8 [-1]) x) 19005 // cond: 19006 // result: (Neg8 x) 19007 for { 19008 _ = v.Args[1] 19009 v_0 := v.Args[0] 19010 if v_0.Op != OpConst8 { 19011 break 19012 } 19013 if v_0.AuxInt != -1 { 19014 break 19015 } 19016 x := v.Args[1] 19017 v.reset(OpNeg8) 19018 v.AddArg(x) 19019 return true 19020 } 19021 // match: (Mul8 x (Const8 [-1])) 19022 // cond: 19023 // result: (Neg8 x) 19024 for { 19025 _ = v.Args[1] 19026 x := v.Args[0] 19027 v_1 := v.Args[1] 19028 if v_1.Op != OpConst8 { 19029 break 19030 } 19031 if v_1.AuxInt != -1 { 19032 break 19033 } 19034 v.reset(OpNeg8) 19035 v.AddArg(x) 19036 return true 19037 } 19038 // match: (Mul8 <t> n (Const8 [c])) 19039 // cond: isPowerOfTwo(c) 19040 // result: (Lsh8x64 <t> n (Const64 <typ.UInt64> [log2(c)])) 19041 for { 19042 t := v.Type 19043 _ = v.Args[1] 19044 n := v.Args[0] 19045 v_1 := v.Args[1] 19046 if v_1.Op != OpConst8 { 19047 break 19048 } 19049 c := v_1.AuxInt 19050 if !(isPowerOfTwo(c)) { 19051 break 19052 } 19053 v.reset(OpLsh8x64) 19054 v.Type = t 19055 v.AddArg(n) 19056 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 19057 v0.AuxInt = log2(c) 19058 v.AddArg(v0) 19059 return true 19060 } 19061 // match: (Mul8 <t> (Const8 [c]) n) 19062 // cond: isPowerOfTwo(c) 19063 // result: (Lsh8x64 <t> n (Const64 <typ.UInt64> [log2(c)])) 19064 for { 19065 t := v.Type 19066 _ = v.Args[1] 19067 v_0 := v.Args[0] 19068 if v_0.Op != OpConst8 { 19069 break 19070 } 19071 c := v_0.AuxInt 19072 n := v.Args[1] 19073 if !(isPowerOfTwo(c)) { 19074 break 19075 } 19076 v.reset(OpLsh8x64) 19077 v.Type = t 19078 v.AddArg(n) 19079 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 19080 v0.AuxInt = log2(c) 19081 v.AddArg(v0) 19082 return true 19083 } 19084 // match: (Mul8 <t> n (Const8 [c])) 19085 // cond: t.IsSigned() && isPowerOfTwo(-c) 19086 // result: (Neg8 (Lsh8x64 <t> n (Const64 <typ.UInt64> [log2(-c)]))) 19087 for { 19088 t := v.Type 19089 _ = v.Args[1] 19090 n := v.Args[0] 19091 v_1 := v.Args[1] 19092 if v_1.Op != OpConst8 { 19093 break 19094 } 19095 c := v_1.AuxInt 19096 if !(t.IsSigned() && isPowerOfTwo(-c)) { 19097 break 19098 } 19099 v.reset(OpNeg8) 19100 v0 := b.NewValue0(v.Pos, OpLsh8x64, t) 19101 v0.AddArg(n) 19102 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 19103 v1.AuxInt = log2(-c) 19104 v0.AddArg(v1) 19105 v.AddArg(v0) 19106 return true 19107 } 19108 // match: (Mul8 <t> (Const8 [c]) n) 19109 // cond: t.IsSigned() && isPowerOfTwo(-c) 19110 // result: (Neg8 (Lsh8x64 <t> n (Const64 <typ.UInt64> [log2(-c)]))) 19111 for { 19112 t := v.Type 19113 _ = v.Args[1] 19114 v_0 := v.Args[0] 19115 if v_0.Op != OpConst8 { 19116 break 19117 } 19118 c := v_0.AuxInt 19119 n := v.Args[1] 19120 if !(t.IsSigned() && isPowerOfTwo(-c)) { 19121 break 19122 } 19123 v.reset(OpNeg8) 19124 v0 := b.NewValue0(v.Pos, OpLsh8x64, t) 19125 v0.AddArg(n) 19126 v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 19127 v1.AuxInt = log2(-c) 19128 v0.AddArg(v1) 19129 v.AddArg(v0) 19130 return true 19131 } 19132 return false 19133 } 19134 func rewriteValuegeneric_OpMul8_10(v *Value) bool { 19135 b := v.Block 19136 _ = b 19137 // match: (Mul8 (Const8 [0]) _) 19138 // cond: 19139 // result: (Const8 [0]) 19140 for { 19141 _ = v.Args[1] 19142 v_0 := v.Args[0] 19143 if v_0.Op != OpConst8 { 19144 break 19145 } 19146 if v_0.AuxInt != 0 { 19147 break 19148 } 19149 v.reset(OpConst8) 19150 v.AuxInt = 0 19151 return true 19152 } 19153 // match: (Mul8 _ (Const8 [0])) 19154 // cond: 19155 // result: (Const8 [0]) 19156 for { 19157 _ = v.Args[1] 19158 v_1 := v.Args[1] 19159 if v_1.Op != OpConst8 { 19160 break 19161 } 19162 if v_1.AuxInt != 0 { 19163 break 19164 } 19165 v.reset(OpConst8) 19166 v.AuxInt = 0 19167 return true 19168 } 19169 // match: (Mul8 (Const8 <t> [c]) (Mul8 (Const8 <t> [d]) x)) 19170 // cond: 19171 // result: (Mul8 (Const8 <t> [int64(int8(c*d))]) x) 19172 for { 19173 _ = v.Args[1] 19174 v_0 := v.Args[0] 19175 if v_0.Op != OpConst8 { 19176 break 19177 } 19178 t := v_0.Type 19179 c := v_0.AuxInt 19180 v_1 := v.Args[1] 19181 if v_1.Op != OpMul8 { 19182 break 19183 } 19184 _ = v_1.Args[1] 19185 v_1_0 := v_1.Args[0] 19186 if v_1_0.Op != OpConst8 { 19187 break 19188 } 19189 if v_1_0.Type != t { 19190 break 19191 } 19192 d := v_1_0.AuxInt 19193 x := v_1.Args[1] 19194 v.reset(OpMul8) 19195 v0 := b.NewValue0(v.Pos, OpConst8, t) 19196 v0.AuxInt = int64(int8(c * d)) 19197 v.AddArg(v0) 19198 v.AddArg(x) 19199 return true 19200 } 19201 // match: (Mul8 (Const8 <t> [c]) (Mul8 x (Const8 <t> [d]))) 19202 // cond: 19203 // result: (Mul8 (Const8 <t> [int64(int8(c*d))]) x) 19204 for { 19205 _ = v.Args[1] 19206 v_0 := v.Args[0] 19207 if v_0.Op != OpConst8 { 19208 break 19209 } 19210 t := v_0.Type 19211 c := v_0.AuxInt 19212 v_1 := v.Args[1] 19213 if v_1.Op != OpMul8 { 19214 break 19215 } 19216 _ = v_1.Args[1] 19217 x := v_1.Args[0] 19218 v_1_1 := v_1.Args[1] 19219 if v_1_1.Op != OpConst8 { 19220 break 19221 } 19222 if v_1_1.Type != t { 19223 break 19224 } 19225 d := v_1_1.AuxInt 19226 v.reset(OpMul8) 19227 v0 := b.NewValue0(v.Pos, OpConst8, t) 19228 v0.AuxInt = int64(int8(c * d)) 19229 v.AddArg(v0) 19230 v.AddArg(x) 19231 return true 19232 } 19233 // match: (Mul8 (Mul8 (Const8 <t> [d]) x) (Const8 <t> [c])) 19234 // cond: 19235 // result: (Mul8 (Const8 <t> [int64(int8(c*d))]) x) 19236 for { 19237 _ = v.Args[1] 19238 v_0 := v.Args[0] 19239 if v_0.Op != OpMul8 { 19240 break 19241 } 19242 _ = v_0.Args[1] 19243 v_0_0 := v_0.Args[0] 19244 if v_0_0.Op != OpConst8 { 19245 break 19246 } 19247 t := v_0_0.Type 19248 d := v_0_0.AuxInt 19249 x := v_0.Args[1] 19250 v_1 := v.Args[1] 19251 if v_1.Op != OpConst8 { 19252 break 19253 } 19254 if v_1.Type != t { 19255 break 19256 } 19257 c := v_1.AuxInt 19258 v.reset(OpMul8) 19259 v0 := b.NewValue0(v.Pos, OpConst8, t) 19260 v0.AuxInt = int64(int8(c * d)) 19261 v.AddArg(v0) 19262 v.AddArg(x) 19263 return true 19264 } 19265 // match: (Mul8 (Mul8 x (Const8 <t> [d])) (Const8 <t> [c])) 19266 // cond: 19267 // result: (Mul8 (Const8 <t> [int64(int8(c*d))]) x) 19268 for { 19269 _ = v.Args[1] 19270 v_0 := v.Args[0] 19271 if v_0.Op != OpMul8 { 19272 break 19273 } 19274 _ = v_0.Args[1] 19275 x := v_0.Args[0] 19276 v_0_1 := v_0.Args[1] 19277 if v_0_1.Op != OpConst8 { 19278 break 19279 } 19280 t := v_0_1.Type 19281 d := v_0_1.AuxInt 19282 v_1 := v.Args[1] 19283 if v_1.Op != OpConst8 { 19284 break 19285 } 19286 if v_1.Type != t { 19287 break 19288 } 19289 c := v_1.AuxInt 19290 v.reset(OpMul8) 19291 v0 := b.NewValue0(v.Pos, OpConst8, t) 19292 v0.AuxInt = int64(int8(c * d)) 19293 v.AddArg(v0) 19294 v.AddArg(x) 19295 return true 19296 } 19297 return false 19298 } 19299 func rewriteValuegeneric_OpNeg16_0(v *Value) bool { 19300 // match: (Neg16 (Const16 [c])) 19301 // cond: 19302 // result: (Const16 [int64(-int16(c))]) 19303 for { 19304 v_0 := v.Args[0] 19305 if v_0.Op != OpConst16 { 19306 break 19307 } 19308 c := v_0.AuxInt 19309 v.reset(OpConst16) 19310 v.AuxInt = int64(-int16(c)) 19311 return true 19312 } 19313 // match: (Neg16 (Sub16 x y)) 19314 // cond: 19315 // result: (Sub16 y x) 19316 for { 19317 v_0 := v.Args[0] 19318 if v_0.Op != OpSub16 { 19319 break 19320 } 19321 _ = v_0.Args[1] 19322 x := v_0.Args[0] 19323 y := v_0.Args[1] 19324 v.reset(OpSub16) 19325 v.AddArg(y) 19326 v.AddArg(x) 19327 return true 19328 } 19329 return false 19330 } 19331 func rewriteValuegeneric_OpNeg32_0(v *Value) bool { 19332 // match: (Neg32 (Const32 [c])) 19333 // cond: 19334 // result: (Const32 [int64(-int32(c))]) 19335 for { 19336 v_0 := v.Args[0] 19337 if v_0.Op != OpConst32 { 19338 break 19339 } 19340 c := v_0.AuxInt 19341 v.reset(OpConst32) 19342 v.AuxInt = int64(-int32(c)) 19343 return true 19344 } 19345 // match: (Neg32 (Sub32 x y)) 19346 // cond: 19347 // result: (Sub32 y x) 19348 for { 19349 v_0 := v.Args[0] 19350 if v_0.Op != OpSub32 { 19351 break 19352 } 19353 _ = v_0.Args[1] 19354 x := v_0.Args[0] 19355 y := v_0.Args[1] 19356 v.reset(OpSub32) 19357 v.AddArg(y) 19358 v.AddArg(x) 19359 return true 19360 } 19361 return false 19362 } 19363 func rewriteValuegeneric_OpNeg32F_0(v *Value) bool { 19364 // match: (Neg32F (Const32F [c])) 19365 // cond: auxTo32F(c) != 0 19366 // result: (Const32F [auxFrom32F(-auxTo32F(c))]) 19367 for { 19368 v_0 := v.Args[0] 19369 if v_0.Op != OpConst32F { 19370 break 19371 } 19372 c := v_0.AuxInt 19373 if !(auxTo32F(c) != 0) { 19374 break 19375 } 19376 v.reset(OpConst32F) 19377 v.AuxInt = auxFrom32F(-auxTo32F(c)) 19378 return true 19379 } 19380 return false 19381 } 19382 func rewriteValuegeneric_OpNeg64_0(v *Value) bool { 19383 // match: (Neg64 (Const64 [c])) 19384 // cond: 19385 // result: (Const64 [-c]) 19386 for { 19387 v_0 := v.Args[0] 19388 if v_0.Op != OpConst64 { 19389 break 19390 } 19391 c := v_0.AuxInt 19392 v.reset(OpConst64) 19393 v.AuxInt = -c 19394 return true 19395 } 19396 // match: (Neg64 (Sub64 x y)) 19397 // cond: 19398 // result: (Sub64 y x) 19399 for { 19400 v_0 := v.Args[0] 19401 if v_0.Op != OpSub64 { 19402 break 19403 } 19404 _ = v_0.Args[1] 19405 x := v_0.Args[0] 19406 y := v_0.Args[1] 19407 v.reset(OpSub64) 19408 v.AddArg(y) 19409 v.AddArg(x) 19410 return true 19411 } 19412 return false 19413 } 19414 func rewriteValuegeneric_OpNeg64F_0(v *Value) bool { 19415 // match: (Neg64F (Const64F [c])) 19416 // cond: auxTo64F(c) != 0 19417 // result: (Const64F [auxFrom64F(-auxTo64F(c))]) 19418 for { 19419 v_0 := v.Args[0] 19420 if v_0.Op != OpConst64F { 19421 break 19422 } 19423 c := v_0.AuxInt 19424 if !(auxTo64F(c) != 0) { 19425 break 19426 } 19427 v.reset(OpConst64F) 19428 v.AuxInt = auxFrom64F(-auxTo64F(c)) 19429 return true 19430 } 19431 return false 19432 } 19433 func rewriteValuegeneric_OpNeg8_0(v *Value) bool { 19434 // match: (Neg8 (Const8 [c])) 19435 // cond: 19436 // result: (Const8 [int64( -int8(c))]) 19437 for { 19438 v_0 := v.Args[0] 19439 if v_0.Op != OpConst8 { 19440 break 19441 } 19442 c := v_0.AuxInt 19443 v.reset(OpConst8) 19444 v.AuxInt = int64(-int8(c)) 19445 return true 19446 } 19447 // match: (Neg8 (Sub8 x y)) 19448 // cond: 19449 // result: (Sub8 y x) 19450 for { 19451 v_0 := v.Args[0] 19452 if v_0.Op != OpSub8 { 19453 break 19454 } 19455 _ = v_0.Args[1] 19456 x := v_0.Args[0] 19457 y := v_0.Args[1] 19458 v.reset(OpSub8) 19459 v.AddArg(y) 19460 v.AddArg(x) 19461 return true 19462 } 19463 return false 19464 } 19465 func rewriteValuegeneric_OpNeq16_0(v *Value) bool { 19466 b := v.Block 19467 _ = b 19468 // match: (Neq16 x x) 19469 // cond: 19470 // result: (ConstBool [0]) 19471 for { 19472 _ = v.Args[1] 19473 x := v.Args[0] 19474 if x != v.Args[1] { 19475 break 19476 } 19477 v.reset(OpConstBool) 19478 v.AuxInt = 0 19479 return true 19480 } 19481 // match: (Neq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x)) 19482 // cond: 19483 // result: (Neq16 (Const16 <t> [int64(int16(c-d))]) x) 19484 for { 19485 _ = v.Args[1] 19486 v_0 := v.Args[0] 19487 if v_0.Op != OpConst16 { 19488 break 19489 } 19490 t := v_0.Type 19491 c := v_0.AuxInt 19492 v_1 := v.Args[1] 19493 if v_1.Op != OpAdd16 { 19494 break 19495 } 19496 _ = v_1.Args[1] 19497 v_1_0 := v_1.Args[0] 19498 if v_1_0.Op != OpConst16 { 19499 break 19500 } 19501 if v_1_0.Type != t { 19502 break 19503 } 19504 d := v_1_0.AuxInt 19505 x := v_1.Args[1] 19506 v.reset(OpNeq16) 19507 v0 := b.NewValue0(v.Pos, OpConst16, t) 19508 v0.AuxInt = int64(int16(c - d)) 19509 v.AddArg(v0) 19510 v.AddArg(x) 19511 return true 19512 } 19513 // match: (Neq16 (Const16 <t> [c]) (Add16 x (Const16 <t> [d]))) 19514 // cond: 19515 // result: (Neq16 (Const16 <t> [int64(int16(c-d))]) x) 19516 for { 19517 _ = v.Args[1] 19518 v_0 := v.Args[0] 19519 if v_0.Op != OpConst16 { 19520 break 19521 } 19522 t := v_0.Type 19523 c := v_0.AuxInt 19524 v_1 := v.Args[1] 19525 if v_1.Op != OpAdd16 { 19526 break 19527 } 19528 _ = v_1.Args[1] 19529 x := v_1.Args[0] 19530 v_1_1 := v_1.Args[1] 19531 if v_1_1.Op != OpConst16 { 19532 break 19533 } 19534 if v_1_1.Type != t { 19535 break 19536 } 19537 d := v_1_1.AuxInt 19538 v.reset(OpNeq16) 19539 v0 := b.NewValue0(v.Pos, OpConst16, t) 19540 v0.AuxInt = int64(int16(c - d)) 19541 v.AddArg(v0) 19542 v.AddArg(x) 19543 return true 19544 } 19545 // match: (Neq16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c])) 19546 // cond: 19547 // result: (Neq16 (Const16 <t> [int64(int16(c-d))]) x) 19548 for { 19549 _ = v.Args[1] 19550 v_0 := v.Args[0] 19551 if v_0.Op != OpAdd16 { 19552 break 19553 } 19554 _ = v_0.Args[1] 19555 v_0_0 := v_0.Args[0] 19556 if v_0_0.Op != OpConst16 { 19557 break 19558 } 19559 t := v_0_0.Type 19560 d := v_0_0.AuxInt 19561 x := v_0.Args[1] 19562 v_1 := v.Args[1] 19563 if v_1.Op != OpConst16 { 19564 break 19565 } 19566 if v_1.Type != t { 19567 break 19568 } 19569 c := v_1.AuxInt 19570 v.reset(OpNeq16) 19571 v0 := b.NewValue0(v.Pos, OpConst16, t) 19572 v0.AuxInt = int64(int16(c - d)) 19573 v.AddArg(v0) 19574 v.AddArg(x) 19575 return true 19576 } 19577 // match: (Neq16 (Add16 x (Const16 <t> [d])) (Const16 <t> [c])) 19578 // cond: 19579 // result: (Neq16 (Const16 <t> [int64(int16(c-d))]) x) 19580 for { 19581 _ = v.Args[1] 19582 v_0 := v.Args[0] 19583 if v_0.Op != OpAdd16 { 19584 break 19585 } 19586 _ = v_0.Args[1] 19587 x := v_0.Args[0] 19588 v_0_1 := v_0.Args[1] 19589 if v_0_1.Op != OpConst16 { 19590 break 19591 } 19592 t := v_0_1.Type 19593 d := v_0_1.AuxInt 19594 v_1 := v.Args[1] 19595 if v_1.Op != OpConst16 { 19596 break 19597 } 19598 if v_1.Type != t { 19599 break 19600 } 19601 c := v_1.AuxInt 19602 v.reset(OpNeq16) 19603 v0 := b.NewValue0(v.Pos, OpConst16, t) 19604 v0.AuxInt = int64(int16(c - d)) 19605 v.AddArg(v0) 19606 v.AddArg(x) 19607 return true 19608 } 19609 // match: (Neq16 (Const16 [c]) (Const16 [d])) 19610 // cond: 19611 // result: (ConstBool [b2i(c != d)]) 19612 for { 19613 _ = v.Args[1] 19614 v_0 := v.Args[0] 19615 if v_0.Op != OpConst16 { 19616 break 19617 } 19618 c := v_0.AuxInt 19619 v_1 := v.Args[1] 19620 if v_1.Op != OpConst16 { 19621 break 19622 } 19623 d := v_1.AuxInt 19624 v.reset(OpConstBool) 19625 v.AuxInt = b2i(c != d) 19626 return true 19627 } 19628 // match: (Neq16 (Const16 [d]) (Const16 [c])) 19629 // cond: 19630 // result: (ConstBool [b2i(c != d)]) 19631 for { 19632 _ = v.Args[1] 19633 v_0 := v.Args[0] 19634 if v_0.Op != OpConst16 { 19635 break 19636 } 19637 d := v_0.AuxInt 19638 v_1 := v.Args[1] 19639 if v_1.Op != OpConst16 { 19640 break 19641 } 19642 c := v_1.AuxInt 19643 v.reset(OpConstBool) 19644 v.AuxInt = b2i(c != d) 19645 return true 19646 } 19647 // match: (Neq16 s:(Sub16 x y) (Const16 [0])) 19648 // cond: s.Uses == 1 19649 // result: (Neq16 x y) 19650 for { 19651 _ = v.Args[1] 19652 s := v.Args[0] 19653 if s.Op != OpSub16 { 19654 break 19655 } 19656 _ = s.Args[1] 19657 x := s.Args[0] 19658 y := s.Args[1] 19659 v_1 := v.Args[1] 19660 if v_1.Op != OpConst16 { 19661 break 19662 } 19663 if v_1.AuxInt != 0 { 19664 break 19665 } 19666 if !(s.Uses == 1) { 19667 break 19668 } 19669 v.reset(OpNeq16) 19670 v.AddArg(x) 19671 v.AddArg(y) 19672 return true 19673 } 19674 // match: (Neq16 (Const16 [0]) s:(Sub16 x y)) 19675 // cond: s.Uses == 1 19676 // result: (Neq16 x y) 19677 for { 19678 _ = v.Args[1] 19679 v_0 := v.Args[0] 19680 if v_0.Op != OpConst16 { 19681 break 19682 } 19683 if v_0.AuxInt != 0 { 19684 break 19685 } 19686 s := v.Args[1] 19687 if s.Op != OpSub16 { 19688 break 19689 } 19690 _ = s.Args[1] 19691 x := s.Args[0] 19692 y := s.Args[1] 19693 if !(s.Uses == 1) { 19694 break 19695 } 19696 v.reset(OpNeq16) 19697 v.AddArg(x) 19698 v.AddArg(y) 19699 return true 19700 } 19701 return false 19702 } 19703 func rewriteValuegeneric_OpNeq32_0(v *Value) bool { 19704 b := v.Block 19705 _ = b 19706 // match: (Neq32 x x) 19707 // cond: 19708 // result: (ConstBool [0]) 19709 for { 19710 _ = v.Args[1] 19711 x := v.Args[0] 19712 if x != v.Args[1] { 19713 break 19714 } 19715 v.reset(OpConstBool) 19716 v.AuxInt = 0 19717 return true 19718 } 19719 // match: (Neq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x)) 19720 // cond: 19721 // result: (Neq32 (Const32 <t> [int64(int32(c-d))]) x) 19722 for { 19723 _ = v.Args[1] 19724 v_0 := v.Args[0] 19725 if v_0.Op != OpConst32 { 19726 break 19727 } 19728 t := v_0.Type 19729 c := v_0.AuxInt 19730 v_1 := v.Args[1] 19731 if v_1.Op != OpAdd32 { 19732 break 19733 } 19734 _ = v_1.Args[1] 19735 v_1_0 := v_1.Args[0] 19736 if v_1_0.Op != OpConst32 { 19737 break 19738 } 19739 if v_1_0.Type != t { 19740 break 19741 } 19742 d := v_1_0.AuxInt 19743 x := v_1.Args[1] 19744 v.reset(OpNeq32) 19745 v0 := b.NewValue0(v.Pos, OpConst32, t) 19746 v0.AuxInt = int64(int32(c - d)) 19747 v.AddArg(v0) 19748 v.AddArg(x) 19749 return true 19750 } 19751 // match: (Neq32 (Const32 <t> [c]) (Add32 x (Const32 <t> [d]))) 19752 // cond: 19753 // result: (Neq32 (Const32 <t> [int64(int32(c-d))]) x) 19754 for { 19755 _ = v.Args[1] 19756 v_0 := v.Args[0] 19757 if v_0.Op != OpConst32 { 19758 break 19759 } 19760 t := v_0.Type 19761 c := v_0.AuxInt 19762 v_1 := v.Args[1] 19763 if v_1.Op != OpAdd32 { 19764 break 19765 } 19766 _ = v_1.Args[1] 19767 x := v_1.Args[0] 19768 v_1_1 := v_1.Args[1] 19769 if v_1_1.Op != OpConst32 { 19770 break 19771 } 19772 if v_1_1.Type != t { 19773 break 19774 } 19775 d := v_1_1.AuxInt 19776 v.reset(OpNeq32) 19777 v0 := b.NewValue0(v.Pos, OpConst32, t) 19778 v0.AuxInt = int64(int32(c - d)) 19779 v.AddArg(v0) 19780 v.AddArg(x) 19781 return true 19782 } 19783 // match: (Neq32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c])) 19784 // cond: 19785 // result: (Neq32 (Const32 <t> [int64(int32(c-d))]) x) 19786 for { 19787 _ = v.Args[1] 19788 v_0 := v.Args[0] 19789 if v_0.Op != OpAdd32 { 19790 break 19791 } 19792 _ = v_0.Args[1] 19793 v_0_0 := v_0.Args[0] 19794 if v_0_0.Op != OpConst32 { 19795 break 19796 } 19797 t := v_0_0.Type 19798 d := v_0_0.AuxInt 19799 x := v_0.Args[1] 19800 v_1 := v.Args[1] 19801 if v_1.Op != OpConst32 { 19802 break 19803 } 19804 if v_1.Type != t { 19805 break 19806 } 19807 c := v_1.AuxInt 19808 v.reset(OpNeq32) 19809 v0 := b.NewValue0(v.Pos, OpConst32, t) 19810 v0.AuxInt = int64(int32(c - d)) 19811 v.AddArg(v0) 19812 v.AddArg(x) 19813 return true 19814 } 19815 // match: (Neq32 (Add32 x (Const32 <t> [d])) (Const32 <t> [c])) 19816 // cond: 19817 // result: (Neq32 (Const32 <t> [int64(int32(c-d))]) x) 19818 for { 19819 _ = v.Args[1] 19820 v_0 := v.Args[0] 19821 if v_0.Op != OpAdd32 { 19822 break 19823 } 19824 _ = v_0.Args[1] 19825 x := v_0.Args[0] 19826 v_0_1 := v_0.Args[1] 19827 if v_0_1.Op != OpConst32 { 19828 break 19829 } 19830 t := v_0_1.Type 19831 d := v_0_1.AuxInt 19832 v_1 := v.Args[1] 19833 if v_1.Op != OpConst32 { 19834 break 19835 } 19836 if v_1.Type != t { 19837 break 19838 } 19839 c := v_1.AuxInt 19840 v.reset(OpNeq32) 19841 v0 := b.NewValue0(v.Pos, OpConst32, t) 19842 v0.AuxInt = int64(int32(c - d)) 19843 v.AddArg(v0) 19844 v.AddArg(x) 19845 return true 19846 } 19847 // match: (Neq32 (Const32 [c]) (Const32 [d])) 19848 // cond: 19849 // result: (ConstBool [b2i(c != d)]) 19850 for { 19851 _ = v.Args[1] 19852 v_0 := v.Args[0] 19853 if v_0.Op != OpConst32 { 19854 break 19855 } 19856 c := v_0.AuxInt 19857 v_1 := v.Args[1] 19858 if v_1.Op != OpConst32 { 19859 break 19860 } 19861 d := v_1.AuxInt 19862 v.reset(OpConstBool) 19863 v.AuxInt = b2i(c != d) 19864 return true 19865 } 19866 // match: (Neq32 (Const32 [d]) (Const32 [c])) 19867 // cond: 19868 // result: (ConstBool [b2i(c != d)]) 19869 for { 19870 _ = v.Args[1] 19871 v_0 := v.Args[0] 19872 if v_0.Op != OpConst32 { 19873 break 19874 } 19875 d := v_0.AuxInt 19876 v_1 := v.Args[1] 19877 if v_1.Op != OpConst32 { 19878 break 19879 } 19880 c := v_1.AuxInt 19881 v.reset(OpConstBool) 19882 v.AuxInt = b2i(c != d) 19883 return true 19884 } 19885 // match: (Neq32 s:(Sub32 x y) (Const32 [0])) 19886 // cond: s.Uses == 1 19887 // result: (Neq32 x y) 19888 for { 19889 _ = v.Args[1] 19890 s := v.Args[0] 19891 if s.Op != OpSub32 { 19892 break 19893 } 19894 _ = s.Args[1] 19895 x := s.Args[0] 19896 y := s.Args[1] 19897 v_1 := v.Args[1] 19898 if v_1.Op != OpConst32 { 19899 break 19900 } 19901 if v_1.AuxInt != 0 { 19902 break 19903 } 19904 if !(s.Uses == 1) { 19905 break 19906 } 19907 v.reset(OpNeq32) 19908 v.AddArg(x) 19909 v.AddArg(y) 19910 return true 19911 } 19912 // match: (Neq32 (Const32 [0]) s:(Sub32 x y)) 19913 // cond: s.Uses == 1 19914 // result: (Neq32 x y) 19915 for { 19916 _ = v.Args[1] 19917 v_0 := v.Args[0] 19918 if v_0.Op != OpConst32 { 19919 break 19920 } 19921 if v_0.AuxInt != 0 { 19922 break 19923 } 19924 s := v.Args[1] 19925 if s.Op != OpSub32 { 19926 break 19927 } 19928 _ = s.Args[1] 19929 x := s.Args[0] 19930 y := s.Args[1] 19931 if !(s.Uses == 1) { 19932 break 19933 } 19934 v.reset(OpNeq32) 19935 v.AddArg(x) 19936 v.AddArg(y) 19937 return true 19938 } 19939 return false 19940 } 19941 func rewriteValuegeneric_OpNeq32F_0(v *Value) bool { 19942 // match: (Neq32F (Const32F [c]) (Const32F [d])) 19943 // cond: 19944 // result: (ConstBool [b2i(auxTo32F(c) != auxTo32F(d))]) 19945 for { 19946 _ = v.Args[1] 19947 v_0 := v.Args[0] 19948 if v_0.Op != OpConst32F { 19949 break 19950 } 19951 c := v_0.AuxInt 19952 v_1 := v.Args[1] 19953 if v_1.Op != OpConst32F { 19954 break 19955 } 19956 d := v_1.AuxInt 19957 v.reset(OpConstBool) 19958 v.AuxInt = b2i(auxTo32F(c) != auxTo32F(d)) 19959 return true 19960 } 19961 // match: (Neq32F (Const32F [d]) (Const32F [c])) 19962 // cond: 19963 // result: (ConstBool [b2i(auxTo32F(c) != auxTo32F(d))]) 19964 for { 19965 _ = v.Args[1] 19966 v_0 := v.Args[0] 19967 if v_0.Op != OpConst32F { 19968 break 19969 } 19970 d := v_0.AuxInt 19971 v_1 := v.Args[1] 19972 if v_1.Op != OpConst32F { 19973 break 19974 } 19975 c := v_1.AuxInt 19976 v.reset(OpConstBool) 19977 v.AuxInt = b2i(auxTo32F(c) != auxTo32F(d)) 19978 return true 19979 } 19980 return false 19981 } 19982 func rewriteValuegeneric_OpNeq64_0(v *Value) bool { 19983 b := v.Block 19984 _ = b 19985 // match: (Neq64 x x) 19986 // cond: 19987 // result: (ConstBool [0]) 19988 for { 19989 _ = v.Args[1] 19990 x := v.Args[0] 19991 if x != v.Args[1] { 19992 break 19993 } 19994 v.reset(OpConstBool) 19995 v.AuxInt = 0 19996 return true 19997 } 19998 // match: (Neq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x)) 19999 // cond: 20000 // result: (Neq64 (Const64 <t> [c-d]) x) 20001 for { 20002 _ = v.Args[1] 20003 v_0 := v.Args[0] 20004 if v_0.Op != OpConst64 { 20005 break 20006 } 20007 t := v_0.Type 20008 c := v_0.AuxInt 20009 v_1 := v.Args[1] 20010 if v_1.Op != OpAdd64 { 20011 break 20012 } 20013 _ = v_1.Args[1] 20014 v_1_0 := v_1.Args[0] 20015 if v_1_0.Op != OpConst64 { 20016 break 20017 } 20018 if v_1_0.Type != t { 20019 break 20020 } 20021 d := v_1_0.AuxInt 20022 x := v_1.Args[1] 20023 v.reset(OpNeq64) 20024 v0 := b.NewValue0(v.Pos, OpConst64, t) 20025 v0.AuxInt = c - d 20026 v.AddArg(v0) 20027 v.AddArg(x) 20028 return true 20029 } 20030 // match: (Neq64 (Const64 <t> [c]) (Add64 x (Const64 <t> [d]))) 20031 // cond: 20032 // result: (Neq64 (Const64 <t> [c-d]) x) 20033 for { 20034 _ = v.Args[1] 20035 v_0 := v.Args[0] 20036 if v_0.Op != OpConst64 { 20037 break 20038 } 20039 t := v_0.Type 20040 c := v_0.AuxInt 20041 v_1 := v.Args[1] 20042 if v_1.Op != OpAdd64 { 20043 break 20044 } 20045 _ = v_1.Args[1] 20046 x := v_1.Args[0] 20047 v_1_1 := v_1.Args[1] 20048 if v_1_1.Op != OpConst64 { 20049 break 20050 } 20051 if v_1_1.Type != t { 20052 break 20053 } 20054 d := v_1_1.AuxInt 20055 v.reset(OpNeq64) 20056 v0 := b.NewValue0(v.Pos, OpConst64, t) 20057 v0.AuxInt = c - d 20058 v.AddArg(v0) 20059 v.AddArg(x) 20060 return true 20061 } 20062 // match: (Neq64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c])) 20063 // cond: 20064 // result: (Neq64 (Const64 <t> [c-d]) x) 20065 for { 20066 _ = v.Args[1] 20067 v_0 := v.Args[0] 20068 if v_0.Op != OpAdd64 { 20069 break 20070 } 20071 _ = v_0.Args[1] 20072 v_0_0 := v_0.Args[0] 20073 if v_0_0.Op != OpConst64 { 20074 break 20075 } 20076 t := v_0_0.Type 20077 d := v_0_0.AuxInt 20078 x := v_0.Args[1] 20079 v_1 := v.Args[1] 20080 if v_1.Op != OpConst64 { 20081 break 20082 } 20083 if v_1.Type != t { 20084 break 20085 } 20086 c := v_1.AuxInt 20087 v.reset(OpNeq64) 20088 v0 := b.NewValue0(v.Pos, OpConst64, t) 20089 v0.AuxInt = c - d 20090 v.AddArg(v0) 20091 v.AddArg(x) 20092 return true 20093 } 20094 // match: (Neq64 (Add64 x (Const64 <t> [d])) (Const64 <t> [c])) 20095 // cond: 20096 // result: (Neq64 (Const64 <t> [c-d]) x) 20097 for { 20098 _ = v.Args[1] 20099 v_0 := v.Args[0] 20100 if v_0.Op != OpAdd64 { 20101 break 20102 } 20103 _ = v_0.Args[1] 20104 x := v_0.Args[0] 20105 v_0_1 := v_0.Args[1] 20106 if v_0_1.Op != OpConst64 { 20107 break 20108 } 20109 t := v_0_1.Type 20110 d := v_0_1.AuxInt 20111 v_1 := v.Args[1] 20112 if v_1.Op != OpConst64 { 20113 break 20114 } 20115 if v_1.Type != t { 20116 break 20117 } 20118 c := v_1.AuxInt 20119 v.reset(OpNeq64) 20120 v0 := b.NewValue0(v.Pos, OpConst64, t) 20121 v0.AuxInt = c - d 20122 v.AddArg(v0) 20123 v.AddArg(x) 20124 return true 20125 } 20126 // match: (Neq64 (Const64 [c]) (Const64 [d])) 20127 // cond: 20128 // result: (ConstBool [b2i(c != d)]) 20129 for { 20130 _ = v.Args[1] 20131 v_0 := v.Args[0] 20132 if v_0.Op != OpConst64 { 20133 break 20134 } 20135 c := v_0.AuxInt 20136 v_1 := v.Args[1] 20137 if v_1.Op != OpConst64 { 20138 break 20139 } 20140 d := v_1.AuxInt 20141 v.reset(OpConstBool) 20142 v.AuxInt = b2i(c != d) 20143 return true 20144 } 20145 // match: (Neq64 (Const64 [d]) (Const64 [c])) 20146 // cond: 20147 // result: (ConstBool [b2i(c != d)]) 20148 for { 20149 _ = v.Args[1] 20150 v_0 := v.Args[0] 20151 if v_0.Op != OpConst64 { 20152 break 20153 } 20154 d := v_0.AuxInt 20155 v_1 := v.Args[1] 20156 if v_1.Op != OpConst64 { 20157 break 20158 } 20159 c := v_1.AuxInt 20160 v.reset(OpConstBool) 20161 v.AuxInt = b2i(c != d) 20162 return true 20163 } 20164 // match: (Neq64 s:(Sub64 x y) (Const64 [0])) 20165 // cond: s.Uses == 1 20166 // result: (Neq64 x y) 20167 for { 20168 _ = v.Args[1] 20169 s := v.Args[0] 20170 if s.Op != OpSub64 { 20171 break 20172 } 20173 _ = s.Args[1] 20174 x := s.Args[0] 20175 y := s.Args[1] 20176 v_1 := v.Args[1] 20177 if v_1.Op != OpConst64 { 20178 break 20179 } 20180 if v_1.AuxInt != 0 { 20181 break 20182 } 20183 if !(s.Uses == 1) { 20184 break 20185 } 20186 v.reset(OpNeq64) 20187 v.AddArg(x) 20188 v.AddArg(y) 20189 return true 20190 } 20191 // match: (Neq64 (Const64 [0]) s:(Sub64 x y)) 20192 // cond: s.Uses == 1 20193 // result: (Neq64 x y) 20194 for { 20195 _ = v.Args[1] 20196 v_0 := v.Args[0] 20197 if v_0.Op != OpConst64 { 20198 break 20199 } 20200 if v_0.AuxInt != 0 { 20201 break 20202 } 20203 s := v.Args[1] 20204 if s.Op != OpSub64 { 20205 break 20206 } 20207 _ = s.Args[1] 20208 x := s.Args[0] 20209 y := s.Args[1] 20210 if !(s.Uses == 1) { 20211 break 20212 } 20213 v.reset(OpNeq64) 20214 v.AddArg(x) 20215 v.AddArg(y) 20216 return true 20217 } 20218 return false 20219 } 20220 func rewriteValuegeneric_OpNeq64F_0(v *Value) bool { 20221 // match: (Neq64F (Const64F [c]) (Const64F [d])) 20222 // cond: 20223 // result: (ConstBool [b2i(auxTo64F(c) != auxTo64F(d))]) 20224 for { 20225 _ = v.Args[1] 20226 v_0 := v.Args[0] 20227 if v_0.Op != OpConst64F { 20228 break 20229 } 20230 c := v_0.AuxInt 20231 v_1 := v.Args[1] 20232 if v_1.Op != OpConst64F { 20233 break 20234 } 20235 d := v_1.AuxInt 20236 v.reset(OpConstBool) 20237 v.AuxInt = b2i(auxTo64F(c) != auxTo64F(d)) 20238 return true 20239 } 20240 // match: (Neq64F (Const64F [d]) (Const64F [c])) 20241 // cond: 20242 // result: (ConstBool [b2i(auxTo64F(c) != auxTo64F(d))]) 20243 for { 20244 _ = v.Args[1] 20245 v_0 := v.Args[0] 20246 if v_0.Op != OpConst64F { 20247 break 20248 } 20249 d := v_0.AuxInt 20250 v_1 := v.Args[1] 20251 if v_1.Op != OpConst64F { 20252 break 20253 } 20254 c := v_1.AuxInt 20255 v.reset(OpConstBool) 20256 v.AuxInt = b2i(auxTo64F(c) != auxTo64F(d)) 20257 return true 20258 } 20259 return false 20260 } 20261 func rewriteValuegeneric_OpNeq8_0(v *Value) bool { 20262 b := v.Block 20263 _ = b 20264 // match: (Neq8 x x) 20265 // cond: 20266 // result: (ConstBool [0]) 20267 for { 20268 _ = v.Args[1] 20269 x := v.Args[0] 20270 if x != v.Args[1] { 20271 break 20272 } 20273 v.reset(OpConstBool) 20274 v.AuxInt = 0 20275 return true 20276 } 20277 // match: (Neq8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x)) 20278 // cond: 20279 // result: (Neq8 (Const8 <t> [int64(int8(c-d))]) x) 20280 for { 20281 _ = v.Args[1] 20282 v_0 := v.Args[0] 20283 if v_0.Op != OpConst8 { 20284 break 20285 } 20286 t := v_0.Type 20287 c := v_0.AuxInt 20288 v_1 := v.Args[1] 20289 if v_1.Op != OpAdd8 { 20290 break 20291 } 20292 _ = v_1.Args[1] 20293 v_1_0 := v_1.Args[0] 20294 if v_1_0.Op != OpConst8 { 20295 break 20296 } 20297 if v_1_0.Type != t { 20298 break 20299 } 20300 d := v_1_0.AuxInt 20301 x := v_1.Args[1] 20302 v.reset(OpNeq8) 20303 v0 := b.NewValue0(v.Pos, OpConst8, t) 20304 v0.AuxInt = int64(int8(c - d)) 20305 v.AddArg(v0) 20306 v.AddArg(x) 20307 return true 20308 } 20309 // match: (Neq8 (Const8 <t> [c]) (Add8 x (Const8 <t> [d]))) 20310 // cond: 20311 // result: (Neq8 (Const8 <t> [int64(int8(c-d))]) x) 20312 for { 20313 _ = v.Args[1] 20314 v_0 := v.Args[0] 20315 if v_0.Op != OpConst8 { 20316 break 20317 } 20318 t := v_0.Type 20319 c := v_0.AuxInt 20320 v_1 := v.Args[1] 20321 if v_1.Op != OpAdd8 { 20322 break 20323 } 20324 _ = v_1.Args[1] 20325 x := v_1.Args[0] 20326 v_1_1 := v_1.Args[1] 20327 if v_1_1.Op != OpConst8 { 20328 break 20329 } 20330 if v_1_1.Type != t { 20331 break 20332 } 20333 d := v_1_1.AuxInt 20334 v.reset(OpNeq8) 20335 v0 := b.NewValue0(v.Pos, OpConst8, t) 20336 v0.AuxInt = int64(int8(c - d)) 20337 v.AddArg(v0) 20338 v.AddArg(x) 20339 return true 20340 } 20341 // match: (Neq8 (Add8 (Const8 <t> [d]) x) (Const8 <t> [c])) 20342 // cond: 20343 // result: (Neq8 (Const8 <t> [int64(int8(c-d))]) x) 20344 for { 20345 _ = v.Args[1] 20346 v_0 := v.Args[0] 20347 if v_0.Op != OpAdd8 { 20348 break 20349 } 20350 _ = v_0.Args[1] 20351 v_0_0 := v_0.Args[0] 20352 if v_0_0.Op != OpConst8 { 20353 break 20354 } 20355 t := v_0_0.Type 20356 d := v_0_0.AuxInt 20357 x := v_0.Args[1] 20358 v_1 := v.Args[1] 20359 if v_1.Op != OpConst8 { 20360 break 20361 } 20362 if v_1.Type != t { 20363 break 20364 } 20365 c := v_1.AuxInt 20366 v.reset(OpNeq8) 20367 v0 := b.NewValue0(v.Pos, OpConst8, t) 20368 v0.AuxInt = int64(int8(c - d)) 20369 v.AddArg(v0) 20370 v.AddArg(x) 20371 return true 20372 } 20373 // match: (Neq8 (Add8 x (Const8 <t> [d])) (Const8 <t> [c])) 20374 // cond: 20375 // result: (Neq8 (Const8 <t> [int64(int8(c-d))]) x) 20376 for { 20377 _ = v.Args[1] 20378 v_0 := v.Args[0] 20379 if v_0.Op != OpAdd8 { 20380 break 20381 } 20382 _ = v_0.Args[1] 20383 x := v_0.Args[0] 20384 v_0_1 := v_0.Args[1] 20385 if v_0_1.Op != OpConst8 { 20386 break 20387 } 20388 t := v_0_1.Type 20389 d := v_0_1.AuxInt 20390 v_1 := v.Args[1] 20391 if v_1.Op != OpConst8 { 20392 break 20393 } 20394 if v_1.Type != t { 20395 break 20396 } 20397 c := v_1.AuxInt 20398 v.reset(OpNeq8) 20399 v0 := b.NewValue0(v.Pos, OpConst8, t) 20400 v0.AuxInt = int64(int8(c - d)) 20401 v.AddArg(v0) 20402 v.AddArg(x) 20403 return true 20404 } 20405 // match: (Neq8 (Const8 [c]) (Const8 [d])) 20406 // cond: 20407 // result: (ConstBool [b2i(c != d)]) 20408 for { 20409 _ = v.Args[1] 20410 v_0 := v.Args[0] 20411 if v_0.Op != OpConst8 { 20412 break 20413 } 20414 c := v_0.AuxInt 20415 v_1 := v.Args[1] 20416 if v_1.Op != OpConst8 { 20417 break 20418 } 20419 d := v_1.AuxInt 20420 v.reset(OpConstBool) 20421 v.AuxInt = b2i(c != d) 20422 return true 20423 } 20424 // match: (Neq8 (Const8 [d]) (Const8 [c])) 20425 // cond: 20426 // result: (ConstBool [b2i(c != d)]) 20427 for { 20428 _ = v.Args[1] 20429 v_0 := v.Args[0] 20430 if v_0.Op != OpConst8 { 20431 break 20432 } 20433 d := v_0.AuxInt 20434 v_1 := v.Args[1] 20435 if v_1.Op != OpConst8 { 20436 break 20437 } 20438 c := v_1.AuxInt 20439 v.reset(OpConstBool) 20440 v.AuxInt = b2i(c != d) 20441 return true 20442 } 20443 // match: (Neq8 s:(Sub8 x y) (Const8 [0])) 20444 // cond: s.Uses == 1 20445 // result: (Neq8 x y) 20446 for { 20447 _ = v.Args[1] 20448 s := v.Args[0] 20449 if s.Op != OpSub8 { 20450 break 20451 } 20452 _ = s.Args[1] 20453 x := s.Args[0] 20454 y := s.Args[1] 20455 v_1 := v.Args[1] 20456 if v_1.Op != OpConst8 { 20457 break 20458 } 20459 if v_1.AuxInt != 0 { 20460 break 20461 } 20462 if !(s.Uses == 1) { 20463 break 20464 } 20465 v.reset(OpNeq8) 20466 v.AddArg(x) 20467 v.AddArg(y) 20468 return true 20469 } 20470 // match: (Neq8 (Const8 [0]) s:(Sub8 x y)) 20471 // cond: s.Uses == 1 20472 // result: (Neq8 x y) 20473 for { 20474 _ = v.Args[1] 20475 v_0 := v.Args[0] 20476 if v_0.Op != OpConst8 { 20477 break 20478 } 20479 if v_0.AuxInt != 0 { 20480 break 20481 } 20482 s := v.Args[1] 20483 if s.Op != OpSub8 { 20484 break 20485 } 20486 _ = s.Args[1] 20487 x := s.Args[0] 20488 y := s.Args[1] 20489 if !(s.Uses == 1) { 20490 break 20491 } 20492 v.reset(OpNeq8) 20493 v.AddArg(x) 20494 v.AddArg(y) 20495 return true 20496 } 20497 return false 20498 } 20499 func rewriteValuegeneric_OpNeqB_0(v *Value) bool { 20500 // match: (NeqB (ConstBool [c]) (ConstBool [d])) 20501 // cond: 20502 // result: (ConstBool [b2i(c != d)]) 20503 for { 20504 _ = v.Args[1] 20505 v_0 := v.Args[0] 20506 if v_0.Op != OpConstBool { 20507 break 20508 } 20509 c := v_0.AuxInt 20510 v_1 := v.Args[1] 20511 if v_1.Op != OpConstBool { 20512 break 20513 } 20514 d := v_1.AuxInt 20515 v.reset(OpConstBool) 20516 v.AuxInt = b2i(c != d) 20517 return true 20518 } 20519 // match: (NeqB (ConstBool [d]) (ConstBool [c])) 20520 // cond: 20521 // result: (ConstBool [b2i(c != d)]) 20522 for { 20523 _ = v.Args[1] 20524 v_0 := v.Args[0] 20525 if v_0.Op != OpConstBool { 20526 break 20527 } 20528 d := v_0.AuxInt 20529 v_1 := v.Args[1] 20530 if v_1.Op != OpConstBool { 20531 break 20532 } 20533 c := v_1.AuxInt 20534 v.reset(OpConstBool) 20535 v.AuxInt = b2i(c != d) 20536 return true 20537 } 20538 // match: (NeqB (ConstBool [0]) x) 20539 // cond: 20540 // result: x 20541 for { 20542 _ = v.Args[1] 20543 v_0 := v.Args[0] 20544 if v_0.Op != OpConstBool { 20545 break 20546 } 20547 if v_0.AuxInt != 0 { 20548 break 20549 } 20550 x := v.Args[1] 20551 v.reset(OpCopy) 20552 v.Type = x.Type 20553 v.AddArg(x) 20554 return true 20555 } 20556 // match: (NeqB x (ConstBool [0])) 20557 // cond: 20558 // result: x 20559 for { 20560 _ = v.Args[1] 20561 x := v.Args[0] 20562 v_1 := v.Args[1] 20563 if v_1.Op != OpConstBool { 20564 break 20565 } 20566 if v_1.AuxInt != 0 { 20567 break 20568 } 20569 v.reset(OpCopy) 20570 v.Type = x.Type 20571 v.AddArg(x) 20572 return true 20573 } 20574 // match: (NeqB (ConstBool [1]) x) 20575 // cond: 20576 // result: (Not x) 20577 for { 20578 _ = v.Args[1] 20579 v_0 := v.Args[0] 20580 if v_0.Op != OpConstBool { 20581 break 20582 } 20583 if v_0.AuxInt != 1 { 20584 break 20585 } 20586 x := v.Args[1] 20587 v.reset(OpNot) 20588 v.AddArg(x) 20589 return true 20590 } 20591 // match: (NeqB x (ConstBool [1])) 20592 // cond: 20593 // result: (Not x) 20594 for { 20595 _ = v.Args[1] 20596 x := v.Args[0] 20597 v_1 := v.Args[1] 20598 if v_1.Op != OpConstBool { 20599 break 20600 } 20601 if v_1.AuxInt != 1 { 20602 break 20603 } 20604 v.reset(OpNot) 20605 v.AddArg(x) 20606 return true 20607 } 20608 // match: (NeqB (Not x) (Not y)) 20609 // cond: 20610 // result: (NeqB x y) 20611 for { 20612 _ = v.Args[1] 20613 v_0 := v.Args[0] 20614 if v_0.Op != OpNot { 20615 break 20616 } 20617 x := v_0.Args[0] 20618 v_1 := v.Args[1] 20619 if v_1.Op != OpNot { 20620 break 20621 } 20622 y := v_1.Args[0] 20623 v.reset(OpNeqB) 20624 v.AddArg(x) 20625 v.AddArg(y) 20626 return true 20627 } 20628 // match: (NeqB (Not y) (Not x)) 20629 // cond: 20630 // result: (NeqB x y) 20631 for { 20632 _ = v.Args[1] 20633 v_0 := v.Args[0] 20634 if v_0.Op != OpNot { 20635 break 20636 } 20637 y := v_0.Args[0] 20638 v_1 := v.Args[1] 20639 if v_1.Op != OpNot { 20640 break 20641 } 20642 x := v_1.Args[0] 20643 v.reset(OpNeqB) 20644 v.AddArg(x) 20645 v.AddArg(y) 20646 return true 20647 } 20648 return false 20649 } 20650 func rewriteValuegeneric_OpNeqInter_0(v *Value) bool { 20651 b := v.Block 20652 _ = b 20653 typ := &b.Func.Config.Types 20654 _ = typ 20655 // match: (NeqInter x y) 20656 // cond: 20657 // result: (NeqPtr (ITab x) (ITab y)) 20658 for { 20659 _ = v.Args[1] 20660 x := v.Args[0] 20661 y := v.Args[1] 20662 v.reset(OpNeqPtr) 20663 v0 := b.NewValue0(v.Pos, OpITab, typ.Uintptr) 20664 v0.AddArg(x) 20665 v.AddArg(v0) 20666 v1 := b.NewValue0(v.Pos, OpITab, typ.Uintptr) 20667 v1.AddArg(y) 20668 v.AddArg(v1) 20669 return true 20670 } 20671 } 20672 func rewriteValuegeneric_OpNeqPtr_0(v *Value) bool { 20673 // match: (NeqPtr x x) 20674 // cond: 20675 // result: (ConstBool [0]) 20676 for { 20677 _ = v.Args[1] 20678 x := v.Args[0] 20679 if x != v.Args[1] { 20680 break 20681 } 20682 v.reset(OpConstBool) 20683 v.AuxInt = 0 20684 return true 20685 } 20686 // match: (NeqPtr (Addr {a} _) (Addr {b} _)) 20687 // cond: 20688 // result: (ConstBool [b2i(a != b)]) 20689 for { 20690 _ = v.Args[1] 20691 v_0 := v.Args[0] 20692 if v_0.Op != OpAddr { 20693 break 20694 } 20695 a := v_0.Aux 20696 v_1 := v.Args[1] 20697 if v_1.Op != OpAddr { 20698 break 20699 } 20700 b := v_1.Aux 20701 v.reset(OpConstBool) 20702 v.AuxInt = b2i(a != b) 20703 return true 20704 } 20705 // match: (NeqPtr (Addr {b} _) (Addr {a} _)) 20706 // cond: 20707 // result: (ConstBool [b2i(a != b)]) 20708 for { 20709 _ = v.Args[1] 20710 v_0 := v.Args[0] 20711 if v_0.Op != OpAddr { 20712 break 20713 } 20714 b := v_0.Aux 20715 v_1 := v.Args[1] 20716 if v_1.Op != OpAddr { 20717 break 20718 } 20719 a := v_1.Aux 20720 v.reset(OpConstBool) 20721 v.AuxInt = b2i(a != b) 20722 return true 20723 } 20724 // match: (NeqPtr (LocalAddr {a} _ _) (LocalAddr {b} _ _)) 20725 // cond: 20726 // result: (ConstBool [b2i(a != b)]) 20727 for { 20728 _ = v.Args[1] 20729 v_0 := v.Args[0] 20730 if v_0.Op != OpLocalAddr { 20731 break 20732 } 20733 a := v_0.Aux 20734 _ = v_0.Args[1] 20735 v_1 := v.Args[1] 20736 if v_1.Op != OpLocalAddr { 20737 break 20738 } 20739 b := v_1.Aux 20740 _ = v_1.Args[1] 20741 v.reset(OpConstBool) 20742 v.AuxInt = b2i(a != b) 20743 return true 20744 } 20745 // match: (NeqPtr (LocalAddr {b} _ _) (LocalAddr {a} _ _)) 20746 // cond: 20747 // result: (ConstBool [b2i(a != b)]) 20748 for { 20749 _ = v.Args[1] 20750 v_0 := v.Args[0] 20751 if v_0.Op != OpLocalAddr { 20752 break 20753 } 20754 b := v_0.Aux 20755 _ = v_0.Args[1] 20756 v_1 := v.Args[1] 20757 if v_1.Op != OpLocalAddr { 20758 break 20759 } 20760 a := v_1.Aux 20761 _ = v_1.Args[1] 20762 v.reset(OpConstBool) 20763 v.AuxInt = b2i(a != b) 20764 return true 20765 } 20766 // match: (NeqPtr (OffPtr [o1] p1) p2) 20767 // cond: isSamePtr(p1, p2) 20768 // result: (ConstBool [b2i(o1 != 0)]) 20769 for { 20770 _ = v.Args[1] 20771 v_0 := v.Args[0] 20772 if v_0.Op != OpOffPtr { 20773 break 20774 } 20775 o1 := v_0.AuxInt 20776 p1 := v_0.Args[0] 20777 p2 := v.Args[1] 20778 if !(isSamePtr(p1, p2)) { 20779 break 20780 } 20781 v.reset(OpConstBool) 20782 v.AuxInt = b2i(o1 != 0) 20783 return true 20784 } 20785 // match: (NeqPtr p2 (OffPtr [o1] p1)) 20786 // cond: isSamePtr(p1, p2) 20787 // result: (ConstBool [b2i(o1 != 0)]) 20788 for { 20789 _ = v.Args[1] 20790 p2 := v.Args[0] 20791 v_1 := v.Args[1] 20792 if v_1.Op != OpOffPtr { 20793 break 20794 } 20795 o1 := v_1.AuxInt 20796 p1 := v_1.Args[0] 20797 if !(isSamePtr(p1, p2)) { 20798 break 20799 } 20800 v.reset(OpConstBool) 20801 v.AuxInt = b2i(o1 != 0) 20802 return true 20803 } 20804 // match: (NeqPtr (OffPtr [o1] p1) (OffPtr [o2] p2)) 20805 // cond: isSamePtr(p1, p2) 20806 // result: (ConstBool [b2i(o1 != o2)]) 20807 for { 20808 _ = v.Args[1] 20809 v_0 := v.Args[0] 20810 if v_0.Op != OpOffPtr { 20811 break 20812 } 20813 o1 := v_0.AuxInt 20814 p1 := v_0.Args[0] 20815 v_1 := v.Args[1] 20816 if v_1.Op != OpOffPtr { 20817 break 20818 } 20819 o2 := v_1.AuxInt 20820 p2 := v_1.Args[0] 20821 if !(isSamePtr(p1, p2)) { 20822 break 20823 } 20824 v.reset(OpConstBool) 20825 v.AuxInt = b2i(o1 != o2) 20826 return true 20827 } 20828 // match: (NeqPtr (OffPtr [o2] p2) (OffPtr [o1] p1)) 20829 // cond: isSamePtr(p1, p2) 20830 // result: (ConstBool [b2i(o1 != o2)]) 20831 for { 20832 _ = v.Args[1] 20833 v_0 := v.Args[0] 20834 if v_0.Op != OpOffPtr { 20835 break 20836 } 20837 o2 := v_0.AuxInt 20838 p2 := v_0.Args[0] 20839 v_1 := v.Args[1] 20840 if v_1.Op != OpOffPtr { 20841 break 20842 } 20843 o1 := v_1.AuxInt 20844 p1 := v_1.Args[0] 20845 if !(isSamePtr(p1, p2)) { 20846 break 20847 } 20848 v.reset(OpConstBool) 20849 v.AuxInt = b2i(o1 != o2) 20850 return true 20851 } 20852 // match: (NeqPtr (Const32 [c]) (Const32 [d])) 20853 // cond: 20854 // result: (ConstBool [b2i(c != d)]) 20855 for { 20856 _ = v.Args[1] 20857 v_0 := v.Args[0] 20858 if v_0.Op != OpConst32 { 20859 break 20860 } 20861 c := v_0.AuxInt 20862 v_1 := v.Args[1] 20863 if v_1.Op != OpConst32 { 20864 break 20865 } 20866 d := v_1.AuxInt 20867 v.reset(OpConstBool) 20868 v.AuxInt = b2i(c != d) 20869 return true 20870 } 20871 return false 20872 } 20873 func rewriteValuegeneric_OpNeqPtr_10(v *Value) bool { 20874 // match: (NeqPtr (Const32 [d]) (Const32 [c])) 20875 // cond: 20876 // result: (ConstBool [b2i(c != d)]) 20877 for { 20878 _ = v.Args[1] 20879 v_0 := v.Args[0] 20880 if v_0.Op != OpConst32 { 20881 break 20882 } 20883 d := v_0.AuxInt 20884 v_1 := v.Args[1] 20885 if v_1.Op != OpConst32 { 20886 break 20887 } 20888 c := v_1.AuxInt 20889 v.reset(OpConstBool) 20890 v.AuxInt = b2i(c != d) 20891 return true 20892 } 20893 // match: (NeqPtr (Const64 [c]) (Const64 [d])) 20894 // cond: 20895 // result: (ConstBool [b2i(c != d)]) 20896 for { 20897 _ = v.Args[1] 20898 v_0 := v.Args[0] 20899 if v_0.Op != OpConst64 { 20900 break 20901 } 20902 c := v_0.AuxInt 20903 v_1 := v.Args[1] 20904 if v_1.Op != OpConst64 { 20905 break 20906 } 20907 d := v_1.AuxInt 20908 v.reset(OpConstBool) 20909 v.AuxInt = b2i(c != d) 20910 return true 20911 } 20912 // match: (NeqPtr (Const64 [d]) (Const64 [c])) 20913 // cond: 20914 // result: (ConstBool [b2i(c != d)]) 20915 for { 20916 _ = v.Args[1] 20917 v_0 := v.Args[0] 20918 if v_0.Op != OpConst64 { 20919 break 20920 } 20921 d := v_0.AuxInt 20922 v_1 := v.Args[1] 20923 if v_1.Op != OpConst64 { 20924 break 20925 } 20926 c := v_1.AuxInt 20927 v.reset(OpConstBool) 20928 v.AuxInt = b2i(c != d) 20929 return true 20930 } 20931 // match: (NeqPtr (LocalAddr _ _) (Addr _)) 20932 // cond: 20933 // result: (ConstBool [1]) 20934 for { 20935 _ = v.Args[1] 20936 v_0 := v.Args[0] 20937 if v_0.Op != OpLocalAddr { 20938 break 20939 } 20940 _ = v_0.Args[1] 20941 v_1 := v.Args[1] 20942 if v_1.Op != OpAddr { 20943 break 20944 } 20945 v.reset(OpConstBool) 20946 v.AuxInt = 1 20947 return true 20948 } 20949 // match: (NeqPtr (Addr _) (LocalAddr _ _)) 20950 // cond: 20951 // result: (ConstBool [1]) 20952 for { 20953 _ = v.Args[1] 20954 v_0 := v.Args[0] 20955 if v_0.Op != OpAddr { 20956 break 20957 } 20958 v_1 := v.Args[1] 20959 if v_1.Op != OpLocalAddr { 20960 break 20961 } 20962 _ = v_1.Args[1] 20963 v.reset(OpConstBool) 20964 v.AuxInt = 1 20965 return true 20966 } 20967 // match: (NeqPtr (Addr _) (LocalAddr _ _)) 20968 // cond: 20969 // result: (ConstBool [1]) 20970 for { 20971 _ = v.Args[1] 20972 v_0 := v.Args[0] 20973 if v_0.Op != OpAddr { 20974 break 20975 } 20976 v_1 := v.Args[1] 20977 if v_1.Op != OpLocalAddr { 20978 break 20979 } 20980 _ = v_1.Args[1] 20981 v.reset(OpConstBool) 20982 v.AuxInt = 1 20983 return true 20984 } 20985 // match: (NeqPtr (LocalAddr _ _) (Addr _)) 20986 // cond: 20987 // result: (ConstBool [1]) 20988 for { 20989 _ = v.Args[1] 20990 v_0 := v.Args[0] 20991 if v_0.Op != OpLocalAddr { 20992 break 20993 } 20994 _ = v_0.Args[1] 20995 v_1 := v.Args[1] 20996 if v_1.Op != OpAddr { 20997 break 20998 } 20999 v.reset(OpConstBool) 21000 v.AuxInt = 1 21001 return true 21002 } 21003 // match: (NeqPtr (AddPtr p1 o1) p2) 21004 // cond: isSamePtr(p1, p2) 21005 // result: (IsNonNil o1) 21006 for { 21007 _ = v.Args[1] 21008 v_0 := v.Args[0] 21009 if v_0.Op != OpAddPtr { 21010 break 21011 } 21012 _ = v_0.Args[1] 21013 p1 := v_0.Args[0] 21014 o1 := v_0.Args[1] 21015 p2 := v.Args[1] 21016 if !(isSamePtr(p1, p2)) { 21017 break 21018 } 21019 v.reset(OpIsNonNil) 21020 v.AddArg(o1) 21021 return true 21022 } 21023 // match: (NeqPtr p2 (AddPtr p1 o1)) 21024 // cond: isSamePtr(p1, p2) 21025 // result: (IsNonNil o1) 21026 for { 21027 _ = v.Args[1] 21028 p2 := v.Args[0] 21029 v_1 := v.Args[1] 21030 if v_1.Op != OpAddPtr { 21031 break 21032 } 21033 _ = v_1.Args[1] 21034 p1 := v_1.Args[0] 21035 o1 := v_1.Args[1] 21036 if !(isSamePtr(p1, p2)) { 21037 break 21038 } 21039 v.reset(OpIsNonNil) 21040 v.AddArg(o1) 21041 return true 21042 } 21043 // match: (NeqPtr (Const32 [0]) p) 21044 // cond: 21045 // result: (IsNonNil p) 21046 for { 21047 _ = v.Args[1] 21048 v_0 := v.Args[0] 21049 if v_0.Op != OpConst32 { 21050 break 21051 } 21052 if v_0.AuxInt != 0 { 21053 break 21054 } 21055 p := v.Args[1] 21056 v.reset(OpIsNonNil) 21057 v.AddArg(p) 21058 return true 21059 } 21060 return false 21061 } 21062 func rewriteValuegeneric_OpNeqPtr_20(v *Value) bool { 21063 // match: (NeqPtr p (Const32 [0])) 21064 // cond: 21065 // result: (IsNonNil p) 21066 for { 21067 _ = v.Args[1] 21068 p := v.Args[0] 21069 v_1 := v.Args[1] 21070 if v_1.Op != OpConst32 { 21071 break 21072 } 21073 if v_1.AuxInt != 0 { 21074 break 21075 } 21076 v.reset(OpIsNonNil) 21077 v.AddArg(p) 21078 return true 21079 } 21080 // match: (NeqPtr (Const64 [0]) p) 21081 // cond: 21082 // result: (IsNonNil p) 21083 for { 21084 _ = v.Args[1] 21085 v_0 := v.Args[0] 21086 if v_0.Op != OpConst64 { 21087 break 21088 } 21089 if v_0.AuxInt != 0 { 21090 break 21091 } 21092 p := v.Args[1] 21093 v.reset(OpIsNonNil) 21094 v.AddArg(p) 21095 return true 21096 } 21097 // match: (NeqPtr p (Const64 [0])) 21098 // cond: 21099 // result: (IsNonNil p) 21100 for { 21101 _ = v.Args[1] 21102 p := v.Args[0] 21103 v_1 := v.Args[1] 21104 if v_1.Op != OpConst64 { 21105 break 21106 } 21107 if v_1.AuxInt != 0 { 21108 break 21109 } 21110 v.reset(OpIsNonNil) 21111 v.AddArg(p) 21112 return true 21113 } 21114 // match: (NeqPtr (ConstNil) p) 21115 // cond: 21116 // result: (IsNonNil p) 21117 for { 21118 _ = v.Args[1] 21119 v_0 := v.Args[0] 21120 if v_0.Op != OpConstNil { 21121 break 21122 } 21123 p := v.Args[1] 21124 v.reset(OpIsNonNil) 21125 v.AddArg(p) 21126 return true 21127 } 21128 // match: (NeqPtr p (ConstNil)) 21129 // cond: 21130 // result: (IsNonNil p) 21131 for { 21132 _ = v.Args[1] 21133 p := v.Args[0] 21134 v_1 := v.Args[1] 21135 if v_1.Op != OpConstNil { 21136 break 21137 } 21138 v.reset(OpIsNonNil) 21139 v.AddArg(p) 21140 return true 21141 } 21142 return false 21143 } 21144 func rewriteValuegeneric_OpNeqSlice_0(v *Value) bool { 21145 b := v.Block 21146 _ = b 21147 typ := &b.Func.Config.Types 21148 _ = typ 21149 // match: (NeqSlice x y) 21150 // cond: 21151 // result: (NeqPtr (SlicePtr x) (SlicePtr y)) 21152 for { 21153 _ = v.Args[1] 21154 x := v.Args[0] 21155 y := v.Args[1] 21156 v.reset(OpNeqPtr) 21157 v0 := b.NewValue0(v.Pos, OpSlicePtr, typ.BytePtr) 21158 v0.AddArg(x) 21159 v.AddArg(v0) 21160 v1 := b.NewValue0(v.Pos, OpSlicePtr, typ.BytePtr) 21161 v1.AddArg(y) 21162 v.AddArg(v1) 21163 return true 21164 } 21165 } 21166 func rewriteValuegeneric_OpNilCheck_0(v *Value) bool { 21167 b := v.Block 21168 _ = b 21169 config := b.Func.Config 21170 _ = config 21171 fe := b.Func.fe 21172 _ = fe 21173 // match: (NilCheck (GetG mem) mem) 21174 // cond: 21175 // result: mem 21176 for { 21177 _ = v.Args[1] 21178 v_0 := v.Args[0] 21179 if v_0.Op != OpGetG { 21180 break 21181 } 21182 mem := v_0.Args[0] 21183 if mem != v.Args[1] { 21184 break 21185 } 21186 v.reset(OpCopy) 21187 v.Type = mem.Type 21188 v.AddArg(mem) 21189 return true 21190 } 21191 // match: (NilCheck (Load (OffPtr [c] (SP)) (StaticCall {sym} _)) _) 21192 // cond: isSameSym(sym, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize && warnRule(fe.Debug_checknil(), v, "removed nil check") 21193 // result: (Invalid) 21194 for { 21195 _ = v.Args[1] 21196 v_0 := v.Args[0] 21197 if v_0.Op != OpLoad { 21198 break 21199 } 21200 _ = v_0.Args[1] 21201 v_0_0 := v_0.Args[0] 21202 if v_0_0.Op != OpOffPtr { 21203 break 21204 } 21205 c := v_0_0.AuxInt 21206 v_0_0_0 := v_0_0.Args[0] 21207 if v_0_0_0.Op != OpSP { 21208 break 21209 } 21210 v_0_1 := v_0.Args[1] 21211 if v_0_1.Op != OpStaticCall { 21212 break 21213 } 21214 sym := v_0_1.Aux 21215 if !(isSameSym(sym, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize && warnRule(fe.Debug_checknil(), v, "removed nil check")) { 21216 break 21217 } 21218 v.reset(OpInvalid) 21219 return true 21220 } 21221 // match: (NilCheck (OffPtr (Load (OffPtr [c] (SP)) (StaticCall {sym} _))) _) 21222 // cond: isSameSym(sym, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize && warnRule(fe.Debug_checknil(), v, "removed nil check") 21223 // result: (Invalid) 21224 for { 21225 _ = v.Args[1] 21226 v_0 := v.Args[0] 21227 if v_0.Op != OpOffPtr { 21228 break 21229 } 21230 v_0_0 := v_0.Args[0] 21231 if v_0_0.Op != OpLoad { 21232 break 21233 } 21234 _ = v_0_0.Args[1] 21235 v_0_0_0 := v_0_0.Args[0] 21236 if v_0_0_0.Op != OpOffPtr { 21237 break 21238 } 21239 c := v_0_0_0.AuxInt 21240 v_0_0_0_0 := v_0_0_0.Args[0] 21241 if v_0_0_0_0.Op != OpSP { 21242 break 21243 } 21244 v_0_0_1 := v_0_0.Args[1] 21245 if v_0_0_1.Op != OpStaticCall { 21246 break 21247 } 21248 sym := v_0_0_1.Aux 21249 if !(isSameSym(sym, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize && warnRule(fe.Debug_checknil(), v, "removed nil check")) { 21250 break 21251 } 21252 v.reset(OpInvalid) 21253 return true 21254 } 21255 return false 21256 } 21257 func rewriteValuegeneric_OpNot_0(v *Value) bool { 21258 // match: (Not (ConstBool [c])) 21259 // cond: 21260 // result: (ConstBool [1-c]) 21261 for { 21262 v_0 := v.Args[0] 21263 if v_0.Op != OpConstBool { 21264 break 21265 } 21266 c := v_0.AuxInt 21267 v.reset(OpConstBool) 21268 v.AuxInt = 1 - c 21269 return true 21270 } 21271 // match: (Not (Eq64 x y)) 21272 // cond: 21273 // result: (Neq64 x y) 21274 for { 21275 v_0 := v.Args[0] 21276 if v_0.Op != OpEq64 { 21277 break 21278 } 21279 _ = v_0.Args[1] 21280 x := v_0.Args[0] 21281 y := v_0.Args[1] 21282 v.reset(OpNeq64) 21283 v.AddArg(x) 21284 v.AddArg(y) 21285 return true 21286 } 21287 // match: (Not (Eq32 x y)) 21288 // cond: 21289 // result: (Neq32 x y) 21290 for { 21291 v_0 := v.Args[0] 21292 if v_0.Op != OpEq32 { 21293 break 21294 } 21295 _ = v_0.Args[1] 21296 x := v_0.Args[0] 21297 y := v_0.Args[1] 21298 v.reset(OpNeq32) 21299 v.AddArg(x) 21300 v.AddArg(y) 21301 return true 21302 } 21303 // match: (Not (Eq16 x y)) 21304 // cond: 21305 // result: (Neq16 x y) 21306 for { 21307 v_0 := v.Args[0] 21308 if v_0.Op != OpEq16 { 21309 break 21310 } 21311 _ = v_0.Args[1] 21312 x := v_0.Args[0] 21313 y := v_0.Args[1] 21314 v.reset(OpNeq16) 21315 v.AddArg(x) 21316 v.AddArg(y) 21317 return true 21318 } 21319 // match: (Not (Eq8 x y)) 21320 // cond: 21321 // result: (Neq8 x y) 21322 for { 21323 v_0 := v.Args[0] 21324 if v_0.Op != OpEq8 { 21325 break 21326 } 21327 _ = v_0.Args[1] 21328 x := v_0.Args[0] 21329 y := v_0.Args[1] 21330 v.reset(OpNeq8) 21331 v.AddArg(x) 21332 v.AddArg(y) 21333 return true 21334 } 21335 // match: (Not (EqB x y)) 21336 // cond: 21337 // result: (NeqB x y) 21338 for { 21339 v_0 := v.Args[0] 21340 if v_0.Op != OpEqB { 21341 break 21342 } 21343 _ = v_0.Args[1] 21344 x := v_0.Args[0] 21345 y := v_0.Args[1] 21346 v.reset(OpNeqB) 21347 v.AddArg(x) 21348 v.AddArg(y) 21349 return true 21350 } 21351 // match: (Not (Neq64 x y)) 21352 // cond: 21353 // result: (Eq64 x y) 21354 for { 21355 v_0 := v.Args[0] 21356 if v_0.Op != OpNeq64 { 21357 break 21358 } 21359 _ = v_0.Args[1] 21360 x := v_0.Args[0] 21361 y := v_0.Args[1] 21362 v.reset(OpEq64) 21363 v.AddArg(x) 21364 v.AddArg(y) 21365 return true 21366 } 21367 // match: (Not (Neq32 x y)) 21368 // cond: 21369 // result: (Eq32 x y) 21370 for { 21371 v_0 := v.Args[0] 21372 if v_0.Op != OpNeq32 { 21373 break 21374 } 21375 _ = v_0.Args[1] 21376 x := v_0.Args[0] 21377 y := v_0.Args[1] 21378 v.reset(OpEq32) 21379 v.AddArg(x) 21380 v.AddArg(y) 21381 return true 21382 } 21383 // match: (Not (Neq16 x y)) 21384 // cond: 21385 // result: (Eq16 x y) 21386 for { 21387 v_0 := v.Args[0] 21388 if v_0.Op != OpNeq16 { 21389 break 21390 } 21391 _ = v_0.Args[1] 21392 x := v_0.Args[0] 21393 y := v_0.Args[1] 21394 v.reset(OpEq16) 21395 v.AddArg(x) 21396 v.AddArg(y) 21397 return true 21398 } 21399 // match: (Not (Neq8 x y)) 21400 // cond: 21401 // result: (Eq8 x y) 21402 for { 21403 v_0 := v.Args[0] 21404 if v_0.Op != OpNeq8 { 21405 break 21406 } 21407 _ = v_0.Args[1] 21408 x := v_0.Args[0] 21409 y := v_0.Args[1] 21410 v.reset(OpEq8) 21411 v.AddArg(x) 21412 v.AddArg(y) 21413 return true 21414 } 21415 return false 21416 } 21417 func rewriteValuegeneric_OpNot_10(v *Value) bool { 21418 // match: (Not (NeqB x y)) 21419 // cond: 21420 // result: (EqB x y) 21421 for { 21422 v_0 := v.Args[0] 21423 if v_0.Op != OpNeqB { 21424 break 21425 } 21426 _ = v_0.Args[1] 21427 x := v_0.Args[0] 21428 y := v_0.Args[1] 21429 v.reset(OpEqB) 21430 v.AddArg(x) 21431 v.AddArg(y) 21432 return true 21433 } 21434 // match: (Not (Greater64 x y)) 21435 // cond: 21436 // result: (Leq64 x y) 21437 for { 21438 v_0 := v.Args[0] 21439 if v_0.Op != OpGreater64 { 21440 break 21441 } 21442 _ = v_0.Args[1] 21443 x := v_0.Args[0] 21444 y := v_0.Args[1] 21445 v.reset(OpLeq64) 21446 v.AddArg(x) 21447 v.AddArg(y) 21448 return true 21449 } 21450 // match: (Not (Greater32 x y)) 21451 // cond: 21452 // result: (Leq32 x y) 21453 for { 21454 v_0 := v.Args[0] 21455 if v_0.Op != OpGreater32 { 21456 break 21457 } 21458 _ = v_0.Args[1] 21459 x := v_0.Args[0] 21460 y := v_0.Args[1] 21461 v.reset(OpLeq32) 21462 v.AddArg(x) 21463 v.AddArg(y) 21464 return true 21465 } 21466 // match: (Not (Greater16 x y)) 21467 // cond: 21468 // result: (Leq16 x y) 21469 for { 21470 v_0 := v.Args[0] 21471 if v_0.Op != OpGreater16 { 21472 break 21473 } 21474 _ = v_0.Args[1] 21475 x := v_0.Args[0] 21476 y := v_0.Args[1] 21477 v.reset(OpLeq16) 21478 v.AddArg(x) 21479 v.AddArg(y) 21480 return true 21481 } 21482 // match: (Not (Greater8 x y)) 21483 // cond: 21484 // result: (Leq8 x y) 21485 for { 21486 v_0 := v.Args[0] 21487 if v_0.Op != OpGreater8 { 21488 break 21489 } 21490 _ = v_0.Args[1] 21491 x := v_0.Args[0] 21492 y := v_0.Args[1] 21493 v.reset(OpLeq8) 21494 v.AddArg(x) 21495 v.AddArg(y) 21496 return true 21497 } 21498 // match: (Not (Greater64U x y)) 21499 // cond: 21500 // result: (Leq64U x y) 21501 for { 21502 v_0 := v.Args[0] 21503 if v_0.Op != OpGreater64U { 21504 break 21505 } 21506 _ = v_0.Args[1] 21507 x := v_0.Args[0] 21508 y := v_0.Args[1] 21509 v.reset(OpLeq64U) 21510 v.AddArg(x) 21511 v.AddArg(y) 21512 return true 21513 } 21514 // match: (Not (Greater32U x y)) 21515 // cond: 21516 // result: (Leq32U x y) 21517 for { 21518 v_0 := v.Args[0] 21519 if v_0.Op != OpGreater32U { 21520 break 21521 } 21522 _ = v_0.Args[1] 21523 x := v_0.Args[0] 21524 y := v_0.Args[1] 21525 v.reset(OpLeq32U) 21526 v.AddArg(x) 21527 v.AddArg(y) 21528 return true 21529 } 21530 // match: (Not (Greater16U x y)) 21531 // cond: 21532 // result: (Leq16U x y) 21533 for { 21534 v_0 := v.Args[0] 21535 if v_0.Op != OpGreater16U { 21536 break 21537 } 21538 _ = v_0.Args[1] 21539 x := v_0.Args[0] 21540 y := v_0.Args[1] 21541 v.reset(OpLeq16U) 21542 v.AddArg(x) 21543 v.AddArg(y) 21544 return true 21545 } 21546 // match: (Not (Greater8U x y)) 21547 // cond: 21548 // result: (Leq8U x y) 21549 for { 21550 v_0 := v.Args[0] 21551 if v_0.Op != OpGreater8U { 21552 break 21553 } 21554 _ = v_0.Args[1] 21555 x := v_0.Args[0] 21556 y := v_0.Args[1] 21557 v.reset(OpLeq8U) 21558 v.AddArg(x) 21559 v.AddArg(y) 21560 return true 21561 } 21562 // match: (Not (Geq64 x y)) 21563 // cond: 21564 // result: (Less64 x y) 21565 for { 21566 v_0 := v.Args[0] 21567 if v_0.Op != OpGeq64 { 21568 break 21569 } 21570 _ = v_0.Args[1] 21571 x := v_0.Args[0] 21572 y := v_0.Args[1] 21573 v.reset(OpLess64) 21574 v.AddArg(x) 21575 v.AddArg(y) 21576 return true 21577 } 21578 return false 21579 } 21580 func rewriteValuegeneric_OpNot_20(v *Value) bool { 21581 // match: (Not (Geq32 x y)) 21582 // cond: 21583 // result: (Less32 x y) 21584 for { 21585 v_0 := v.Args[0] 21586 if v_0.Op != OpGeq32 { 21587 break 21588 } 21589 _ = v_0.Args[1] 21590 x := v_0.Args[0] 21591 y := v_0.Args[1] 21592 v.reset(OpLess32) 21593 v.AddArg(x) 21594 v.AddArg(y) 21595 return true 21596 } 21597 // match: (Not (Geq16 x y)) 21598 // cond: 21599 // result: (Less16 x y) 21600 for { 21601 v_0 := v.Args[0] 21602 if v_0.Op != OpGeq16 { 21603 break 21604 } 21605 _ = v_0.Args[1] 21606 x := v_0.Args[0] 21607 y := v_0.Args[1] 21608 v.reset(OpLess16) 21609 v.AddArg(x) 21610 v.AddArg(y) 21611 return true 21612 } 21613 // match: (Not (Geq8 x y)) 21614 // cond: 21615 // result: (Less8 x y) 21616 for { 21617 v_0 := v.Args[0] 21618 if v_0.Op != OpGeq8 { 21619 break 21620 } 21621 _ = v_0.Args[1] 21622 x := v_0.Args[0] 21623 y := v_0.Args[1] 21624 v.reset(OpLess8) 21625 v.AddArg(x) 21626 v.AddArg(y) 21627 return true 21628 } 21629 // match: (Not (Geq64U x y)) 21630 // cond: 21631 // result: (Less64U x y) 21632 for { 21633 v_0 := v.Args[0] 21634 if v_0.Op != OpGeq64U { 21635 break 21636 } 21637 _ = v_0.Args[1] 21638 x := v_0.Args[0] 21639 y := v_0.Args[1] 21640 v.reset(OpLess64U) 21641 v.AddArg(x) 21642 v.AddArg(y) 21643 return true 21644 } 21645 // match: (Not (Geq32U x y)) 21646 // cond: 21647 // result: (Less32U x y) 21648 for { 21649 v_0 := v.Args[0] 21650 if v_0.Op != OpGeq32U { 21651 break 21652 } 21653 _ = v_0.Args[1] 21654 x := v_0.Args[0] 21655 y := v_0.Args[1] 21656 v.reset(OpLess32U) 21657 v.AddArg(x) 21658 v.AddArg(y) 21659 return true 21660 } 21661 // match: (Not (Geq16U x y)) 21662 // cond: 21663 // result: (Less16U x y) 21664 for { 21665 v_0 := v.Args[0] 21666 if v_0.Op != OpGeq16U { 21667 break 21668 } 21669 _ = v_0.Args[1] 21670 x := v_0.Args[0] 21671 y := v_0.Args[1] 21672 v.reset(OpLess16U) 21673 v.AddArg(x) 21674 v.AddArg(y) 21675 return true 21676 } 21677 // match: (Not (Geq8U x y)) 21678 // cond: 21679 // result: (Less8U x y) 21680 for { 21681 v_0 := v.Args[0] 21682 if v_0.Op != OpGeq8U { 21683 break 21684 } 21685 _ = v_0.Args[1] 21686 x := v_0.Args[0] 21687 y := v_0.Args[1] 21688 v.reset(OpLess8U) 21689 v.AddArg(x) 21690 v.AddArg(y) 21691 return true 21692 } 21693 // match: (Not (Less64 x y)) 21694 // cond: 21695 // result: (Geq64 x y) 21696 for { 21697 v_0 := v.Args[0] 21698 if v_0.Op != OpLess64 { 21699 break 21700 } 21701 _ = v_0.Args[1] 21702 x := v_0.Args[0] 21703 y := v_0.Args[1] 21704 v.reset(OpGeq64) 21705 v.AddArg(x) 21706 v.AddArg(y) 21707 return true 21708 } 21709 // match: (Not (Less32 x y)) 21710 // cond: 21711 // result: (Geq32 x y) 21712 for { 21713 v_0 := v.Args[0] 21714 if v_0.Op != OpLess32 { 21715 break 21716 } 21717 _ = v_0.Args[1] 21718 x := v_0.Args[0] 21719 y := v_0.Args[1] 21720 v.reset(OpGeq32) 21721 v.AddArg(x) 21722 v.AddArg(y) 21723 return true 21724 } 21725 // match: (Not (Less16 x y)) 21726 // cond: 21727 // result: (Geq16 x y) 21728 for { 21729 v_0 := v.Args[0] 21730 if v_0.Op != OpLess16 { 21731 break 21732 } 21733 _ = v_0.Args[1] 21734 x := v_0.Args[0] 21735 y := v_0.Args[1] 21736 v.reset(OpGeq16) 21737 v.AddArg(x) 21738 v.AddArg(y) 21739 return true 21740 } 21741 return false 21742 } 21743 func rewriteValuegeneric_OpNot_30(v *Value) bool { 21744 // match: (Not (Less8 x y)) 21745 // cond: 21746 // result: (Geq8 x y) 21747 for { 21748 v_0 := v.Args[0] 21749 if v_0.Op != OpLess8 { 21750 break 21751 } 21752 _ = v_0.Args[1] 21753 x := v_0.Args[0] 21754 y := v_0.Args[1] 21755 v.reset(OpGeq8) 21756 v.AddArg(x) 21757 v.AddArg(y) 21758 return true 21759 } 21760 // match: (Not (Less64U x y)) 21761 // cond: 21762 // result: (Geq64U x y) 21763 for { 21764 v_0 := v.Args[0] 21765 if v_0.Op != OpLess64U { 21766 break 21767 } 21768 _ = v_0.Args[1] 21769 x := v_0.Args[0] 21770 y := v_0.Args[1] 21771 v.reset(OpGeq64U) 21772 v.AddArg(x) 21773 v.AddArg(y) 21774 return true 21775 } 21776 // match: (Not (Less32U x y)) 21777 // cond: 21778 // result: (Geq32U x y) 21779 for { 21780 v_0 := v.Args[0] 21781 if v_0.Op != OpLess32U { 21782 break 21783 } 21784 _ = v_0.Args[1] 21785 x := v_0.Args[0] 21786 y := v_0.Args[1] 21787 v.reset(OpGeq32U) 21788 v.AddArg(x) 21789 v.AddArg(y) 21790 return true 21791 } 21792 // match: (Not (Less16U x y)) 21793 // cond: 21794 // result: (Geq16U x y) 21795 for { 21796 v_0 := v.Args[0] 21797 if v_0.Op != OpLess16U { 21798 break 21799 } 21800 _ = v_0.Args[1] 21801 x := v_0.Args[0] 21802 y := v_0.Args[1] 21803 v.reset(OpGeq16U) 21804 v.AddArg(x) 21805 v.AddArg(y) 21806 return true 21807 } 21808 // match: (Not (Less8U x y)) 21809 // cond: 21810 // result: (Geq8U x y) 21811 for { 21812 v_0 := v.Args[0] 21813 if v_0.Op != OpLess8U { 21814 break 21815 } 21816 _ = v_0.Args[1] 21817 x := v_0.Args[0] 21818 y := v_0.Args[1] 21819 v.reset(OpGeq8U) 21820 v.AddArg(x) 21821 v.AddArg(y) 21822 return true 21823 } 21824 // match: (Not (Leq64 x y)) 21825 // cond: 21826 // result: (Greater64 x y) 21827 for { 21828 v_0 := v.Args[0] 21829 if v_0.Op != OpLeq64 { 21830 break 21831 } 21832 _ = v_0.Args[1] 21833 x := v_0.Args[0] 21834 y := v_0.Args[1] 21835 v.reset(OpGreater64) 21836 v.AddArg(x) 21837 v.AddArg(y) 21838 return true 21839 } 21840 // match: (Not (Leq32 x y)) 21841 // cond: 21842 // result: (Greater32 x y) 21843 for { 21844 v_0 := v.Args[0] 21845 if v_0.Op != OpLeq32 { 21846 break 21847 } 21848 _ = v_0.Args[1] 21849 x := v_0.Args[0] 21850 y := v_0.Args[1] 21851 v.reset(OpGreater32) 21852 v.AddArg(x) 21853 v.AddArg(y) 21854 return true 21855 } 21856 // match: (Not (Leq16 x y)) 21857 // cond: 21858 // result: (Greater16 x y) 21859 for { 21860 v_0 := v.Args[0] 21861 if v_0.Op != OpLeq16 { 21862 break 21863 } 21864 _ = v_0.Args[1] 21865 x := v_0.Args[0] 21866 y := v_0.Args[1] 21867 v.reset(OpGreater16) 21868 v.AddArg(x) 21869 v.AddArg(y) 21870 return true 21871 } 21872 // match: (Not (Leq8 x y)) 21873 // cond: 21874 // result: (Greater8 x y) 21875 for { 21876 v_0 := v.Args[0] 21877 if v_0.Op != OpLeq8 { 21878 break 21879 } 21880 _ = v_0.Args[1] 21881 x := v_0.Args[0] 21882 y := v_0.Args[1] 21883 v.reset(OpGreater8) 21884 v.AddArg(x) 21885 v.AddArg(y) 21886 return true 21887 } 21888 // match: (Not (Leq64U x y)) 21889 // cond: 21890 // result: (Greater64U x y) 21891 for { 21892 v_0 := v.Args[0] 21893 if v_0.Op != OpLeq64U { 21894 break 21895 } 21896 _ = v_0.Args[1] 21897 x := v_0.Args[0] 21898 y := v_0.Args[1] 21899 v.reset(OpGreater64U) 21900 v.AddArg(x) 21901 v.AddArg(y) 21902 return true 21903 } 21904 return false 21905 } 21906 func rewriteValuegeneric_OpNot_40(v *Value) bool { 21907 // match: (Not (Leq32U x y)) 21908 // cond: 21909 // result: (Greater32U x y) 21910 for { 21911 v_0 := v.Args[0] 21912 if v_0.Op != OpLeq32U { 21913 break 21914 } 21915 _ = v_0.Args[1] 21916 x := v_0.Args[0] 21917 y := v_0.Args[1] 21918 v.reset(OpGreater32U) 21919 v.AddArg(x) 21920 v.AddArg(y) 21921 return true 21922 } 21923 // match: (Not (Leq16U x y)) 21924 // cond: 21925 // result: (Greater16U x y) 21926 for { 21927 v_0 := v.Args[0] 21928 if v_0.Op != OpLeq16U { 21929 break 21930 } 21931 _ = v_0.Args[1] 21932 x := v_0.Args[0] 21933 y := v_0.Args[1] 21934 v.reset(OpGreater16U) 21935 v.AddArg(x) 21936 v.AddArg(y) 21937 return true 21938 } 21939 // match: (Not (Leq8U x y)) 21940 // cond: 21941 // result: (Greater8U x y) 21942 for { 21943 v_0 := v.Args[0] 21944 if v_0.Op != OpLeq8U { 21945 break 21946 } 21947 _ = v_0.Args[1] 21948 x := v_0.Args[0] 21949 y := v_0.Args[1] 21950 v.reset(OpGreater8U) 21951 v.AddArg(x) 21952 v.AddArg(y) 21953 return true 21954 } 21955 return false 21956 } 21957 func rewriteValuegeneric_OpOffPtr_0(v *Value) bool { 21958 // match: (OffPtr (OffPtr p [b]) [a]) 21959 // cond: 21960 // result: (OffPtr p [a+b]) 21961 for { 21962 a := v.AuxInt 21963 v_0 := v.Args[0] 21964 if v_0.Op != OpOffPtr { 21965 break 21966 } 21967 b := v_0.AuxInt 21968 p := v_0.Args[0] 21969 v.reset(OpOffPtr) 21970 v.AuxInt = a + b 21971 v.AddArg(p) 21972 return true 21973 } 21974 // match: (OffPtr p [0]) 21975 // cond: v.Type.Compare(p.Type) == types.CMPeq 21976 // result: p 21977 for { 21978 if v.AuxInt != 0 { 21979 break 21980 } 21981 p := v.Args[0] 21982 if !(v.Type.Compare(p.Type) == types.CMPeq) { 21983 break 21984 } 21985 v.reset(OpCopy) 21986 v.Type = p.Type 21987 v.AddArg(p) 21988 return true 21989 } 21990 return false 21991 } 21992 func rewriteValuegeneric_OpOr16_0(v *Value) bool { 21993 // match: (Or16 (Const16 [c]) (Const16 [d])) 21994 // cond: 21995 // result: (Const16 [int64(int16(c|d))]) 21996 for { 21997 _ = v.Args[1] 21998 v_0 := v.Args[0] 21999 if v_0.Op != OpConst16 { 22000 break 22001 } 22002 c := v_0.AuxInt 22003 v_1 := v.Args[1] 22004 if v_1.Op != OpConst16 { 22005 break 22006 } 22007 d := v_1.AuxInt 22008 v.reset(OpConst16) 22009 v.AuxInt = int64(int16(c | d)) 22010 return true 22011 } 22012 // match: (Or16 (Const16 [d]) (Const16 [c])) 22013 // cond: 22014 // result: (Const16 [int64(int16(c|d))]) 22015 for { 22016 _ = v.Args[1] 22017 v_0 := v.Args[0] 22018 if v_0.Op != OpConst16 { 22019 break 22020 } 22021 d := v_0.AuxInt 22022 v_1 := v.Args[1] 22023 if v_1.Op != OpConst16 { 22024 break 22025 } 22026 c := v_1.AuxInt 22027 v.reset(OpConst16) 22028 v.AuxInt = int64(int16(c | d)) 22029 return true 22030 } 22031 // match: (Or16 x x) 22032 // cond: 22033 // result: x 22034 for { 22035 _ = v.Args[1] 22036 x := v.Args[0] 22037 if x != v.Args[1] { 22038 break 22039 } 22040 v.reset(OpCopy) 22041 v.Type = x.Type 22042 v.AddArg(x) 22043 return true 22044 } 22045 // match: (Or16 (Const16 [0]) x) 22046 // cond: 22047 // result: x 22048 for { 22049 _ = v.Args[1] 22050 v_0 := v.Args[0] 22051 if v_0.Op != OpConst16 { 22052 break 22053 } 22054 if v_0.AuxInt != 0 { 22055 break 22056 } 22057 x := v.Args[1] 22058 v.reset(OpCopy) 22059 v.Type = x.Type 22060 v.AddArg(x) 22061 return true 22062 } 22063 // match: (Or16 x (Const16 [0])) 22064 // cond: 22065 // result: x 22066 for { 22067 _ = v.Args[1] 22068 x := v.Args[0] 22069 v_1 := v.Args[1] 22070 if v_1.Op != OpConst16 { 22071 break 22072 } 22073 if v_1.AuxInt != 0 { 22074 break 22075 } 22076 v.reset(OpCopy) 22077 v.Type = x.Type 22078 v.AddArg(x) 22079 return true 22080 } 22081 // match: (Or16 (Const16 [-1]) _) 22082 // cond: 22083 // result: (Const16 [-1]) 22084 for { 22085 _ = v.Args[1] 22086 v_0 := v.Args[0] 22087 if v_0.Op != OpConst16 { 22088 break 22089 } 22090 if v_0.AuxInt != -1 { 22091 break 22092 } 22093 v.reset(OpConst16) 22094 v.AuxInt = -1 22095 return true 22096 } 22097 // match: (Or16 _ (Const16 [-1])) 22098 // cond: 22099 // result: (Const16 [-1]) 22100 for { 22101 _ = v.Args[1] 22102 v_1 := v.Args[1] 22103 if v_1.Op != OpConst16 { 22104 break 22105 } 22106 if v_1.AuxInt != -1 { 22107 break 22108 } 22109 v.reset(OpConst16) 22110 v.AuxInt = -1 22111 return true 22112 } 22113 // match: (Or16 x (Or16 x y)) 22114 // cond: 22115 // result: (Or16 x y) 22116 for { 22117 _ = v.Args[1] 22118 x := v.Args[0] 22119 v_1 := v.Args[1] 22120 if v_1.Op != OpOr16 { 22121 break 22122 } 22123 _ = v_1.Args[1] 22124 if x != v_1.Args[0] { 22125 break 22126 } 22127 y := v_1.Args[1] 22128 v.reset(OpOr16) 22129 v.AddArg(x) 22130 v.AddArg(y) 22131 return true 22132 } 22133 // match: (Or16 x (Or16 y x)) 22134 // cond: 22135 // result: (Or16 x y) 22136 for { 22137 _ = v.Args[1] 22138 x := v.Args[0] 22139 v_1 := v.Args[1] 22140 if v_1.Op != OpOr16 { 22141 break 22142 } 22143 _ = v_1.Args[1] 22144 y := v_1.Args[0] 22145 if x != v_1.Args[1] { 22146 break 22147 } 22148 v.reset(OpOr16) 22149 v.AddArg(x) 22150 v.AddArg(y) 22151 return true 22152 } 22153 // match: (Or16 (Or16 x y) x) 22154 // cond: 22155 // result: (Or16 x y) 22156 for { 22157 _ = v.Args[1] 22158 v_0 := v.Args[0] 22159 if v_0.Op != OpOr16 { 22160 break 22161 } 22162 _ = v_0.Args[1] 22163 x := v_0.Args[0] 22164 y := v_0.Args[1] 22165 if x != v.Args[1] { 22166 break 22167 } 22168 v.reset(OpOr16) 22169 v.AddArg(x) 22170 v.AddArg(y) 22171 return true 22172 } 22173 return false 22174 } 22175 func rewriteValuegeneric_OpOr16_10(v *Value) bool { 22176 b := v.Block 22177 _ = b 22178 // match: (Or16 (Or16 y x) x) 22179 // cond: 22180 // result: (Or16 x y) 22181 for { 22182 _ = v.Args[1] 22183 v_0 := v.Args[0] 22184 if v_0.Op != OpOr16 { 22185 break 22186 } 22187 _ = v_0.Args[1] 22188 y := v_0.Args[0] 22189 x := v_0.Args[1] 22190 if x != v.Args[1] { 22191 break 22192 } 22193 v.reset(OpOr16) 22194 v.AddArg(x) 22195 v.AddArg(y) 22196 return true 22197 } 22198 // match: (Or16 (And16 x (Const16 [c2])) (Const16 <t> [c1])) 22199 // cond: ^(c1 | c2) == 0 22200 // result: (Or16 (Const16 <t> [c1]) x) 22201 for { 22202 _ = v.Args[1] 22203 v_0 := v.Args[0] 22204 if v_0.Op != OpAnd16 { 22205 break 22206 } 22207 _ = v_0.Args[1] 22208 x := v_0.Args[0] 22209 v_0_1 := v_0.Args[1] 22210 if v_0_1.Op != OpConst16 { 22211 break 22212 } 22213 c2 := v_0_1.AuxInt 22214 v_1 := v.Args[1] 22215 if v_1.Op != OpConst16 { 22216 break 22217 } 22218 t := v_1.Type 22219 c1 := v_1.AuxInt 22220 if !(^(c1 | c2) == 0) { 22221 break 22222 } 22223 v.reset(OpOr16) 22224 v0 := b.NewValue0(v.Pos, OpConst16, t) 22225 v0.AuxInt = c1 22226 v.AddArg(v0) 22227 v.AddArg(x) 22228 return true 22229 } 22230 // match: (Or16 (And16 (Const16 [c2]) x) (Const16 <t> [c1])) 22231 // cond: ^(c1 | c2) == 0 22232 // result: (Or16 (Const16 <t> [c1]) x) 22233 for { 22234 _ = v.Args[1] 22235 v_0 := v.Args[0] 22236 if v_0.Op != OpAnd16 { 22237 break 22238 } 22239 _ = v_0.Args[1] 22240 v_0_0 := v_0.Args[0] 22241 if v_0_0.Op != OpConst16 { 22242 break 22243 } 22244 c2 := v_0_0.AuxInt 22245 x := v_0.Args[1] 22246 v_1 := v.Args[1] 22247 if v_1.Op != OpConst16 { 22248 break 22249 } 22250 t := v_1.Type 22251 c1 := v_1.AuxInt 22252 if !(^(c1 | c2) == 0) { 22253 break 22254 } 22255 v.reset(OpOr16) 22256 v0 := b.NewValue0(v.Pos, OpConst16, t) 22257 v0.AuxInt = c1 22258 v.AddArg(v0) 22259 v.AddArg(x) 22260 return true 22261 } 22262 // match: (Or16 (Const16 <t> [c1]) (And16 x (Const16 [c2]))) 22263 // cond: ^(c1 | c2) == 0 22264 // result: (Or16 (Const16 <t> [c1]) x) 22265 for { 22266 _ = v.Args[1] 22267 v_0 := v.Args[0] 22268 if v_0.Op != OpConst16 { 22269 break 22270 } 22271 t := v_0.Type 22272 c1 := v_0.AuxInt 22273 v_1 := v.Args[1] 22274 if v_1.Op != OpAnd16 { 22275 break 22276 } 22277 _ = v_1.Args[1] 22278 x := v_1.Args[0] 22279 v_1_1 := v_1.Args[1] 22280 if v_1_1.Op != OpConst16 { 22281 break 22282 } 22283 c2 := v_1_1.AuxInt 22284 if !(^(c1 | c2) == 0) { 22285 break 22286 } 22287 v.reset(OpOr16) 22288 v0 := b.NewValue0(v.Pos, OpConst16, t) 22289 v0.AuxInt = c1 22290 v.AddArg(v0) 22291 v.AddArg(x) 22292 return true 22293 } 22294 // match: (Or16 (Const16 <t> [c1]) (And16 (Const16 [c2]) x)) 22295 // cond: ^(c1 | c2) == 0 22296 // result: (Or16 (Const16 <t> [c1]) x) 22297 for { 22298 _ = v.Args[1] 22299 v_0 := v.Args[0] 22300 if v_0.Op != OpConst16 { 22301 break 22302 } 22303 t := v_0.Type 22304 c1 := v_0.AuxInt 22305 v_1 := v.Args[1] 22306 if v_1.Op != OpAnd16 { 22307 break 22308 } 22309 _ = v_1.Args[1] 22310 v_1_0 := v_1.Args[0] 22311 if v_1_0.Op != OpConst16 { 22312 break 22313 } 22314 c2 := v_1_0.AuxInt 22315 x := v_1.Args[1] 22316 if !(^(c1 | c2) == 0) { 22317 break 22318 } 22319 v.reset(OpOr16) 22320 v0 := b.NewValue0(v.Pos, OpConst16, t) 22321 v0.AuxInt = c1 22322 v.AddArg(v0) 22323 v.AddArg(x) 22324 return true 22325 } 22326 // match: (Or16 (Or16 i:(Const16 <t>) z) x) 22327 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 22328 // result: (Or16 i (Or16 <t> z x)) 22329 for { 22330 _ = v.Args[1] 22331 v_0 := v.Args[0] 22332 if v_0.Op != OpOr16 { 22333 break 22334 } 22335 _ = v_0.Args[1] 22336 i := v_0.Args[0] 22337 if i.Op != OpConst16 { 22338 break 22339 } 22340 t := i.Type 22341 z := v_0.Args[1] 22342 x := v.Args[1] 22343 if !(z.Op != OpConst16 && x.Op != OpConst16) { 22344 break 22345 } 22346 v.reset(OpOr16) 22347 v.AddArg(i) 22348 v0 := b.NewValue0(v.Pos, OpOr16, t) 22349 v0.AddArg(z) 22350 v0.AddArg(x) 22351 v.AddArg(v0) 22352 return true 22353 } 22354 // match: (Or16 (Or16 z i:(Const16 <t>)) x) 22355 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 22356 // result: (Or16 i (Or16 <t> z x)) 22357 for { 22358 _ = v.Args[1] 22359 v_0 := v.Args[0] 22360 if v_0.Op != OpOr16 { 22361 break 22362 } 22363 _ = v_0.Args[1] 22364 z := v_0.Args[0] 22365 i := v_0.Args[1] 22366 if i.Op != OpConst16 { 22367 break 22368 } 22369 t := i.Type 22370 x := v.Args[1] 22371 if !(z.Op != OpConst16 && x.Op != OpConst16) { 22372 break 22373 } 22374 v.reset(OpOr16) 22375 v.AddArg(i) 22376 v0 := b.NewValue0(v.Pos, OpOr16, t) 22377 v0.AddArg(z) 22378 v0.AddArg(x) 22379 v.AddArg(v0) 22380 return true 22381 } 22382 // match: (Or16 x (Or16 i:(Const16 <t>) z)) 22383 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 22384 // result: (Or16 i (Or16 <t> z x)) 22385 for { 22386 _ = v.Args[1] 22387 x := v.Args[0] 22388 v_1 := v.Args[1] 22389 if v_1.Op != OpOr16 { 22390 break 22391 } 22392 _ = v_1.Args[1] 22393 i := v_1.Args[0] 22394 if i.Op != OpConst16 { 22395 break 22396 } 22397 t := i.Type 22398 z := v_1.Args[1] 22399 if !(z.Op != OpConst16 && x.Op != OpConst16) { 22400 break 22401 } 22402 v.reset(OpOr16) 22403 v.AddArg(i) 22404 v0 := b.NewValue0(v.Pos, OpOr16, t) 22405 v0.AddArg(z) 22406 v0.AddArg(x) 22407 v.AddArg(v0) 22408 return true 22409 } 22410 // match: (Or16 x (Or16 z i:(Const16 <t>))) 22411 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 22412 // result: (Or16 i (Or16 <t> z x)) 22413 for { 22414 _ = v.Args[1] 22415 x := v.Args[0] 22416 v_1 := v.Args[1] 22417 if v_1.Op != OpOr16 { 22418 break 22419 } 22420 _ = v_1.Args[1] 22421 z := v_1.Args[0] 22422 i := v_1.Args[1] 22423 if i.Op != OpConst16 { 22424 break 22425 } 22426 t := i.Type 22427 if !(z.Op != OpConst16 && x.Op != OpConst16) { 22428 break 22429 } 22430 v.reset(OpOr16) 22431 v.AddArg(i) 22432 v0 := b.NewValue0(v.Pos, OpOr16, t) 22433 v0.AddArg(z) 22434 v0.AddArg(x) 22435 v.AddArg(v0) 22436 return true 22437 } 22438 // match: (Or16 (Const16 <t> [c]) (Or16 (Const16 <t> [d]) x)) 22439 // cond: 22440 // result: (Or16 (Const16 <t> [int64(int16(c|d))]) x) 22441 for { 22442 _ = v.Args[1] 22443 v_0 := v.Args[0] 22444 if v_0.Op != OpConst16 { 22445 break 22446 } 22447 t := v_0.Type 22448 c := v_0.AuxInt 22449 v_1 := v.Args[1] 22450 if v_1.Op != OpOr16 { 22451 break 22452 } 22453 _ = v_1.Args[1] 22454 v_1_0 := v_1.Args[0] 22455 if v_1_0.Op != OpConst16 { 22456 break 22457 } 22458 if v_1_0.Type != t { 22459 break 22460 } 22461 d := v_1_0.AuxInt 22462 x := v_1.Args[1] 22463 v.reset(OpOr16) 22464 v0 := b.NewValue0(v.Pos, OpConst16, t) 22465 v0.AuxInt = int64(int16(c | d)) 22466 v.AddArg(v0) 22467 v.AddArg(x) 22468 return true 22469 } 22470 return false 22471 } 22472 func rewriteValuegeneric_OpOr16_20(v *Value) bool { 22473 b := v.Block 22474 _ = b 22475 // match: (Or16 (Const16 <t> [c]) (Or16 x (Const16 <t> [d]))) 22476 // cond: 22477 // result: (Or16 (Const16 <t> [int64(int16(c|d))]) x) 22478 for { 22479 _ = v.Args[1] 22480 v_0 := v.Args[0] 22481 if v_0.Op != OpConst16 { 22482 break 22483 } 22484 t := v_0.Type 22485 c := v_0.AuxInt 22486 v_1 := v.Args[1] 22487 if v_1.Op != OpOr16 { 22488 break 22489 } 22490 _ = v_1.Args[1] 22491 x := v_1.Args[0] 22492 v_1_1 := v_1.Args[1] 22493 if v_1_1.Op != OpConst16 { 22494 break 22495 } 22496 if v_1_1.Type != t { 22497 break 22498 } 22499 d := v_1_1.AuxInt 22500 v.reset(OpOr16) 22501 v0 := b.NewValue0(v.Pos, OpConst16, t) 22502 v0.AuxInt = int64(int16(c | d)) 22503 v.AddArg(v0) 22504 v.AddArg(x) 22505 return true 22506 } 22507 // match: (Or16 (Or16 (Const16 <t> [d]) x) (Const16 <t> [c])) 22508 // cond: 22509 // result: (Or16 (Const16 <t> [int64(int16(c|d))]) x) 22510 for { 22511 _ = v.Args[1] 22512 v_0 := v.Args[0] 22513 if v_0.Op != OpOr16 { 22514 break 22515 } 22516 _ = v_0.Args[1] 22517 v_0_0 := v_0.Args[0] 22518 if v_0_0.Op != OpConst16 { 22519 break 22520 } 22521 t := v_0_0.Type 22522 d := v_0_0.AuxInt 22523 x := v_0.Args[1] 22524 v_1 := v.Args[1] 22525 if v_1.Op != OpConst16 { 22526 break 22527 } 22528 if v_1.Type != t { 22529 break 22530 } 22531 c := v_1.AuxInt 22532 v.reset(OpOr16) 22533 v0 := b.NewValue0(v.Pos, OpConst16, t) 22534 v0.AuxInt = int64(int16(c | d)) 22535 v.AddArg(v0) 22536 v.AddArg(x) 22537 return true 22538 } 22539 // match: (Or16 (Or16 x (Const16 <t> [d])) (Const16 <t> [c])) 22540 // cond: 22541 // result: (Or16 (Const16 <t> [int64(int16(c|d))]) x) 22542 for { 22543 _ = v.Args[1] 22544 v_0 := v.Args[0] 22545 if v_0.Op != OpOr16 { 22546 break 22547 } 22548 _ = v_0.Args[1] 22549 x := v_0.Args[0] 22550 v_0_1 := v_0.Args[1] 22551 if v_0_1.Op != OpConst16 { 22552 break 22553 } 22554 t := v_0_1.Type 22555 d := v_0_1.AuxInt 22556 v_1 := v.Args[1] 22557 if v_1.Op != OpConst16 { 22558 break 22559 } 22560 if v_1.Type != t { 22561 break 22562 } 22563 c := v_1.AuxInt 22564 v.reset(OpOr16) 22565 v0 := b.NewValue0(v.Pos, OpConst16, t) 22566 v0.AuxInt = int64(int16(c | d)) 22567 v.AddArg(v0) 22568 v.AddArg(x) 22569 return true 22570 } 22571 return false 22572 } 22573 func rewriteValuegeneric_OpOr32_0(v *Value) bool { 22574 // match: (Or32 (Const32 [c]) (Const32 [d])) 22575 // cond: 22576 // result: (Const32 [int64(int32(c|d))]) 22577 for { 22578 _ = v.Args[1] 22579 v_0 := v.Args[0] 22580 if v_0.Op != OpConst32 { 22581 break 22582 } 22583 c := v_0.AuxInt 22584 v_1 := v.Args[1] 22585 if v_1.Op != OpConst32 { 22586 break 22587 } 22588 d := v_1.AuxInt 22589 v.reset(OpConst32) 22590 v.AuxInt = int64(int32(c | d)) 22591 return true 22592 } 22593 // match: (Or32 (Const32 [d]) (Const32 [c])) 22594 // cond: 22595 // result: (Const32 [int64(int32(c|d))]) 22596 for { 22597 _ = v.Args[1] 22598 v_0 := v.Args[0] 22599 if v_0.Op != OpConst32 { 22600 break 22601 } 22602 d := v_0.AuxInt 22603 v_1 := v.Args[1] 22604 if v_1.Op != OpConst32 { 22605 break 22606 } 22607 c := v_1.AuxInt 22608 v.reset(OpConst32) 22609 v.AuxInt = int64(int32(c | d)) 22610 return true 22611 } 22612 // match: (Or32 x x) 22613 // cond: 22614 // result: x 22615 for { 22616 _ = v.Args[1] 22617 x := v.Args[0] 22618 if x != v.Args[1] { 22619 break 22620 } 22621 v.reset(OpCopy) 22622 v.Type = x.Type 22623 v.AddArg(x) 22624 return true 22625 } 22626 // match: (Or32 (Const32 [0]) x) 22627 // cond: 22628 // result: x 22629 for { 22630 _ = v.Args[1] 22631 v_0 := v.Args[0] 22632 if v_0.Op != OpConst32 { 22633 break 22634 } 22635 if v_0.AuxInt != 0 { 22636 break 22637 } 22638 x := v.Args[1] 22639 v.reset(OpCopy) 22640 v.Type = x.Type 22641 v.AddArg(x) 22642 return true 22643 } 22644 // match: (Or32 x (Const32 [0])) 22645 // cond: 22646 // result: x 22647 for { 22648 _ = v.Args[1] 22649 x := v.Args[0] 22650 v_1 := v.Args[1] 22651 if v_1.Op != OpConst32 { 22652 break 22653 } 22654 if v_1.AuxInt != 0 { 22655 break 22656 } 22657 v.reset(OpCopy) 22658 v.Type = x.Type 22659 v.AddArg(x) 22660 return true 22661 } 22662 // match: (Or32 (Const32 [-1]) _) 22663 // cond: 22664 // result: (Const32 [-1]) 22665 for { 22666 _ = v.Args[1] 22667 v_0 := v.Args[0] 22668 if v_0.Op != OpConst32 { 22669 break 22670 } 22671 if v_0.AuxInt != -1 { 22672 break 22673 } 22674 v.reset(OpConst32) 22675 v.AuxInt = -1 22676 return true 22677 } 22678 // match: (Or32 _ (Const32 [-1])) 22679 // cond: 22680 // result: (Const32 [-1]) 22681 for { 22682 _ = v.Args[1] 22683 v_1 := v.Args[1] 22684 if v_1.Op != OpConst32 { 22685 break 22686 } 22687 if v_1.AuxInt != -1 { 22688 break 22689 } 22690 v.reset(OpConst32) 22691 v.AuxInt = -1 22692 return true 22693 } 22694 // match: (Or32 x (Or32 x y)) 22695 // cond: 22696 // result: (Or32 x y) 22697 for { 22698 _ = v.Args[1] 22699 x := v.Args[0] 22700 v_1 := v.Args[1] 22701 if v_1.Op != OpOr32 { 22702 break 22703 } 22704 _ = v_1.Args[1] 22705 if x != v_1.Args[0] { 22706 break 22707 } 22708 y := v_1.Args[1] 22709 v.reset(OpOr32) 22710 v.AddArg(x) 22711 v.AddArg(y) 22712 return true 22713 } 22714 // match: (Or32 x (Or32 y x)) 22715 // cond: 22716 // result: (Or32 x y) 22717 for { 22718 _ = v.Args[1] 22719 x := v.Args[0] 22720 v_1 := v.Args[1] 22721 if v_1.Op != OpOr32 { 22722 break 22723 } 22724 _ = v_1.Args[1] 22725 y := v_1.Args[0] 22726 if x != v_1.Args[1] { 22727 break 22728 } 22729 v.reset(OpOr32) 22730 v.AddArg(x) 22731 v.AddArg(y) 22732 return true 22733 } 22734 // match: (Or32 (Or32 x y) x) 22735 // cond: 22736 // result: (Or32 x y) 22737 for { 22738 _ = v.Args[1] 22739 v_0 := v.Args[0] 22740 if v_0.Op != OpOr32 { 22741 break 22742 } 22743 _ = v_0.Args[1] 22744 x := v_0.Args[0] 22745 y := v_0.Args[1] 22746 if x != v.Args[1] { 22747 break 22748 } 22749 v.reset(OpOr32) 22750 v.AddArg(x) 22751 v.AddArg(y) 22752 return true 22753 } 22754 return false 22755 } 22756 func rewriteValuegeneric_OpOr32_10(v *Value) bool { 22757 b := v.Block 22758 _ = b 22759 // match: (Or32 (Or32 y x) x) 22760 // cond: 22761 // result: (Or32 x y) 22762 for { 22763 _ = v.Args[1] 22764 v_0 := v.Args[0] 22765 if v_0.Op != OpOr32 { 22766 break 22767 } 22768 _ = v_0.Args[1] 22769 y := v_0.Args[0] 22770 x := v_0.Args[1] 22771 if x != v.Args[1] { 22772 break 22773 } 22774 v.reset(OpOr32) 22775 v.AddArg(x) 22776 v.AddArg(y) 22777 return true 22778 } 22779 // match: (Or32 (And32 x (Const32 [c2])) (Const32 <t> [c1])) 22780 // cond: ^(c1 | c2) == 0 22781 // result: (Or32 (Const32 <t> [c1]) x) 22782 for { 22783 _ = v.Args[1] 22784 v_0 := v.Args[0] 22785 if v_0.Op != OpAnd32 { 22786 break 22787 } 22788 _ = v_0.Args[1] 22789 x := v_0.Args[0] 22790 v_0_1 := v_0.Args[1] 22791 if v_0_1.Op != OpConst32 { 22792 break 22793 } 22794 c2 := v_0_1.AuxInt 22795 v_1 := v.Args[1] 22796 if v_1.Op != OpConst32 { 22797 break 22798 } 22799 t := v_1.Type 22800 c1 := v_1.AuxInt 22801 if !(^(c1 | c2) == 0) { 22802 break 22803 } 22804 v.reset(OpOr32) 22805 v0 := b.NewValue0(v.Pos, OpConst32, t) 22806 v0.AuxInt = c1 22807 v.AddArg(v0) 22808 v.AddArg(x) 22809 return true 22810 } 22811 // match: (Or32 (And32 (Const32 [c2]) x) (Const32 <t> [c1])) 22812 // cond: ^(c1 | c2) == 0 22813 // result: (Or32 (Const32 <t> [c1]) x) 22814 for { 22815 _ = v.Args[1] 22816 v_0 := v.Args[0] 22817 if v_0.Op != OpAnd32 { 22818 break 22819 } 22820 _ = v_0.Args[1] 22821 v_0_0 := v_0.Args[0] 22822 if v_0_0.Op != OpConst32 { 22823 break 22824 } 22825 c2 := v_0_0.AuxInt 22826 x := v_0.Args[1] 22827 v_1 := v.Args[1] 22828 if v_1.Op != OpConst32 { 22829 break 22830 } 22831 t := v_1.Type 22832 c1 := v_1.AuxInt 22833 if !(^(c1 | c2) == 0) { 22834 break 22835 } 22836 v.reset(OpOr32) 22837 v0 := b.NewValue0(v.Pos, OpConst32, t) 22838 v0.AuxInt = c1 22839 v.AddArg(v0) 22840 v.AddArg(x) 22841 return true 22842 } 22843 // match: (Or32 (Const32 <t> [c1]) (And32 x (Const32 [c2]))) 22844 // cond: ^(c1 | c2) == 0 22845 // result: (Or32 (Const32 <t> [c1]) x) 22846 for { 22847 _ = v.Args[1] 22848 v_0 := v.Args[0] 22849 if v_0.Op != OpConst32 { 22850 break 22851 } 22852 t := v_0.Type 22853 c1 := v_0.AuxInt 22854 v_1 := v.Args[1] 22855 if v_1.Op != OpAnd32 { 22856 break 22857 } 22858 _ = v_1.Args[1] 22859 x := v_1.Args[0] 22860 v_1_1 := v_1.Args[1] 22861 if v_1_1.Op != OpConst32 { 22862 break 22863 } 22864 c2 := v_1_1.AuxInt 22865 if !(^(c1 | c2) == 0) { 22866 break 22867 } 22868 v.reset(OpOr32) 22869 v0 := b.NewValue0(v.Pos, OpConst32, t) 22870 v0.AuxInt = c1 22871 v.AddArg(v0) 22872 v.AddArg(x) 22873 return true 22874 } 22875 // match: (Or32 (Const32 <t> [c1]) (And32 (Const32 [c2]) x)) 22876 // cond: ^(c1 | c2) == 0 22877 // result: (Or32 (Const32 <t> [c1]) x) 22878 for { 22879 _ = v.Args[1] 22880 v_0 := v.Args[0] 22881 if v_0.Op != OpConst32 { 22882 break 22883 } 22884 t := v_0.Type 22885 c1 := v_0.AuxInt 22886 v_1 := v.Args[1] 22887 if v_1.Op != OpAnd32 { 22888 break 22889 } 22890 _ = v_1.Args[1] 22891 v_1_0 := v_1.Args[0] 22892 if v_1_0.Op != OpConst32 { 22893 break 22894 } 22895 c2 := v_1_0.AuxInt 22896 x := v_1.Args[1] 22897 if !(^(c1 | c2) == 0) { 22898 break 22899 } 22900 v.reset(OpOr32) 22901 v0 := b.NewValue0(v.Pos, OpConst32, t) 22902 v0.AuxInt = c1 22903 v.AddArg(v0) 22904 v.AddArg(x) 22905 return true 22906 } 22907 // match: (Or32 (Or32 i:(Const32 <t>) z) x) 22908 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 22909 // result: (Or32 i (Or32 <t> z x)) 22910 for { 22911 _ = v.Args[1] 22912 v_0 := v.Args[0] 22913 if v_0.Op != OpOr32 { 22914 break 22915 } 22916 _ = v_0.Args[1] 22917 i := v_0.Args[0] 22918 if i.Op != OpConst32 { 22919 break 22920 } 22921 t := i.Type 22922 z := v_0.Args[1] 22923 x := v.Args[1] 22924 if !(z.Op != OpConst32 && x.Op != OpConst32) { 22925 break 22926 } 22927 v.reset(OpOr32) 22928 v.AddArg(i) 22929 v0 := b.NewValue0(v.Pos, OpOr32, t) 22930 v0.AddArg(z) 22931 v0.AddArg(x) 22932 v.AddArg(v0) 22933 return true 22934 } 22935 // match: (Or32 (Or32 z i:(Const32 <t>)) x) 22936 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 22937 // result: (Or32 i (Or32 <t> z x)) 22938 for { 22939 _ = v.Args[1] 22940 v_0 := v.Args[0] 22941 if v_0.Op != OpOr32 { 22942 break 22943 } 22944 _ = v_0.Args[1] 22945 z := v_0.Args[0] 22946 i := v_0.Args[1] 22947 if i.Op != OpConst32 { 22948 break 22949 } 22950 t := i.Type 22951 x := v.Args[1] 22952 if !(z.Op != OpConst32 && x.Op != OpConst32) { 22953 break 22954 } 22955 v.reset(OpOr32) 22956 v.AddArg(i) 22957 v0 := b.NewValue0(v.Pos, OpOr32, t) 22958 v0.AddArg(z) 22959 v0.AddArg(x) 22960 v.AddArg(v0) 22961 return true 22962 } 22963 // match: (Or32 x (Or32 i:(Const32 <t>) z)) 22964 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 22965 // result: (Or32 i (Or32 <t> z x)) 22966 for { 22967 _ = v.Args[1] 22968 x := v.Args[0] 22969 v_1 := v.Args[1] 22970 if v_1.Op != OpOr32 { 22971 break 22972 } 22973 _ = v_1.Args[1] 22974 i := v_1.Args[0] 22975 if i.Op != OpConst32 { 22976 break 22977 } 22978 t := i.Type 22979 z := v_1.Args[1] 22980 if !(z.Op != OpConst32 && x.Op != OpConst32) { 22981 break 22982 } 22983 v.reset(OpOr32) 22984 v.AddArg(i) 22985 v0 := b.NewValue0(v.Pos, OpOr32, t) 22986 v0.AddArg(z) 22987 v0.AddArg(x) 22988 v.AddArg(v0) 22989 return true 22990 } 22991 // match: (Or32 x (Or32 z i:(Const32 <t>))) 22992 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 22993 // result: (Or32 i (Or32 <t> z x)) 22994 for { 22995 _ = v.Args[1] 22996 x := v.Args[0] 22997 v_1 := v.Args[1] 22998 if v_1.Op != OpOr32 { 22999 break 23000 } 23001 _ = v_1.Args[1] 23002 z := v_1.Args[0] 23003 i := v_1.Args[1] 23004 if i.Op != OpConst32 { 23005 break 23006 } 23007 t := i.Type 23008 if !(z.Op != OpConst32 && x.Op != OpConst32) { 23009 break 23010 } 23011 v.reset(OpOr32) 23012 v.AddArg(i) 23013 v0 := b.NewValue0(v.Pos, OpOr32, t) 23014 v0.AddArg(z) 23015 v0.AddArg(x) 23016 v.AddArg(v0) 23017 return true 23018 } 23019 // match: (Or32 (Const32 <t> [c]) (Or32 (Const32 <t> [d]) x)) 23020 // cond: 23021 // result: (Or32 (Const32 <t> [int64(int32(c|d))]) x) 23022 for { 23023 _ = v.Args[1] 23024 v_0 := v.Args[0] 23025 if v_0.Op != OpConst32 { 23026 break 23027 } 23028 t := v_0.Type 23029 c := v_0.AuxInt 23030 v_1 := v.Args[1] 23031 if v_1.Op != OpOr32 { 23032 break 23033 } 23034 _ = v_1.Args[1] 23035 v_1_0 := v_1.Args[0] 23036 if v_1_0.Op != OpConst32 { 23037 break 23038 } 23039 if v_1_0.Type != t { 23040 break 23041 } 23042 d := v_1_0.AuxInt 23043 x := v_1.Args[1] 23044 v.reset(OpOr32) 23045 v0 := b.NewValue0(v.Pos, OpConst32, t) 23046 v0.AuxInt = int64(int32(c | d)) 23047 v.AddArg(v0) 23048 v.AddArg(x) 23049 return true 23050 } 23051 return false 23052 } 23053 func rewriteValuegeneric_OpOr32_20(v *Value) bool { 23054 b := v.Block 23055 _ = b 23056 // match: (Or32 (Const32 <t> [c]) (Or32 x (Const32 <t> [d]))) 23057 // cond: 23058 // result: (Or32 (Const32 <t> [int64(int32(c|d))]) x) 23059 for { 23060 _ = v.Args[1] 23061 v_0 := v.Args[0] 23062 if v_0.Op != OpConst32 { 23063 break 23064 } 23065 t := v_0.Type 23066 c := v_0.AuxInt 23067 v_1 := v.Args[1] 23068 if v_1.Op != OpOr32 { 23069 break 23070 } 23071 _ = v_1.Args[1] 23072 x := v_1.Args[0] 23073 v_1_1 := v_1.Args[1] 23074 if v_1_1.Op != OpConst32 { 23075 break 23076 } 23077 if v_1_1.Type != t { 23078 break 23079 } 23080 d := v_1_1.AuxInt 23081 v.reset(OpOr32) 23082 v0 := b.NewValue0(v.Pos, OpConst32, t) 23083 v0.AuxInt = int64(int32(c | d)) 23084 v.AddArg(v0) 23085 v.AddArg(x) 23086 return true 23087 } 23088 // match: (Or32 (Or32 (Const32 <t> [d]) x) (Const32 <t> [c])) 23089 // cond: 23090 // result: (Or32 (Const32 <t> [int64(int32(c|d))]) x) 23091 for { 23092 _ = v.Args[1] 23093 v_0 := v.Args[0] 23094 if v_0.Op != OpOr32 { 23095 break 23096 } 23097 _ = v_0.Args[1] 23098 v_0_0 := v_0.Args[0] 23099 if v_0_0.Op != OpConst32 { 23100 break 23101 } 23102 t := v_0_0.Type 23103 d := v_0_0.AuxInt 23104 x := v_0.Args[1] 23105 v_1 := v.Args[1] 23106 if v_1.Op != OpConst32 { 23107 break 23108 } 23109 if v_1.Type != t { 23110 break 23111 } 23112 c := v_1.AuxInt 23113 v.reset(OpOr32) 23114 v0 := b.NewValue0(v.Pos, OpConst32, t) 23115 v0.AuxInt = int64(int32(c | d)) 23116 v.AddArg(v0) 23117 v.AddArg(x) 23118 return true 23119 } 23120 // match: (Or32 (Or32 x (Const32 <t> [d])) (Const32 <t> [c])) 23121 // cond: 23122 // result: (Or32 (Const32 <t> [int64(int32(c|d))]) x) 23123 for { 23124 _ = v.Args[1] 23125 v_0 := v.Args[0] 23126 if v_0.Op != OpOr32 { 23127 break 23128 } 23129 _ = v_0.Args[1] 23130 x := v_0.Args[0] 23131 v_0_1 := v_0.Args[1] 23132 if v_0_1.Op != OpConst32 { 23133 break 23134 } 23135 t := v_0_1.Type 23136 d := v_0_1.AuxInt 23137 v_1 := v.Args[1] 23138 if v_1.Op != OpConst32 { 23139 break 23140 } 23141 if v_1.Type != t { 23142 break 23143 } 23144 c := v_1.AuxInt 23145 v.reset(OpOr32) 23146 v0 := b.NewValue0(v.Pos, OpConst32, t) 23147 v0.AuxInt = int64(int32(c | d)) 23148 v.AddArg(v0) 23149 v.AddArg(x) 23150 return true 23151 } 23152 return false 23153 } 23154 func rewriteValuegeneric_OpOr64_0(v *Value) bool { 23155 // match: (Or64 (Const64 [c]) (Const64 [d])) 23156 // cond: 23157 // result: (Const64 [c|d]) 23158 for { 23159 _ = v.Args[1] 23160 v_0 := v.Args[0] 23161 if v_0.Op != OpConst64 { 23162 break 23163 } 23164 c := v_0.AuxInt 23165 v_1 := v.Args[1] 23166 if v_1.Op != OpConst64 { 23167 break 23168 } 23169 d := v_1.AuxInt 23170 v.reset(OpConst64) 23171 v.AuxInt = c | d 23172 return true 23173 } 23174 // match: (Or64 (Const64 [d]) (Const64 [c])) 23175 // cond: 23176 // result: (Const64 [c|d]) 23177 for { 23178 _ = v.Args[1] 23179 v_0 := v.Args[0] 23180 if v_0.Op != OpConst64 { 23181 break 23182 } 23183 d := v_0.AuxInt 23184 v_1 := v.Args[1] 23185 if v_1.Op != OpConst64 { 23186 break 23187 } 23188 c := v_1.AuxInt 23189 v.reset(OpConst64) 23190 v.AuxInt = c | d 23191 return true 23192 } 23193 // match: (Or64 x x) 23194 // cond: 23195 // result: x 23196 for { 23197 _ = v.Args[1] 23198 x := v.Args[0] 23199 if x != v.Args[1] { 23200 break 23201 } 23202 v.reset(OpCopy) 23203 v.Type = x.Type 23204 v.AddArg(x) 23205 return true 23206 } 23207 // match: (Or64 (Const64 [0]) x) 23208 // cond: 23209 // result: x 23210 for { 23211 _ = v.Args[1] 23212 v_0 := v.Args[0] 23213 if v_0.Op != OpConst64 { 23214 break 23215 } 23216 if v_0.AuxInt != 0 { 23217 break 23218 } 23219 x := v.Args[1] 23220 v.reset(OpCopy) 23221 v.Type = x.Type 23222 v.AddArg(x) 23223 return true 23224 } 23225 // match: (Or64 x (Const64 [0])) 23226 // cond: 23227 // result: x 23228 for { 23229 _ = v.Args[1] 23230 x := v.Args[0] 23231 v_1 := v.Args[1] 23232 if v_1.Op != OpConst64 { 23233 break 23234 } 23235 if v_1.AuxInt != 0 { 23236 break 23237 } 23238 v.reset(OpCopy) 23239 v.Type = x.Type 23240 v.AddArg(x) 23241 return true 23242 } 23243 // match: (Or64 (Const64 [-1]) _) 23244 // cond: 23245 // result: (Const64 [-1]) 23246 for { 23247 _ = v.Args[1] 23248 v_0 := v.Args[0] 23249 if v_0.Op != OpConst64 { 23250 break 23251 } 23252 if v_0.AuxInt != -1 { 23253 break 23254 } 23255 v.reset(OpConst64) 23256 v.AuxInt = -1 23257 return true 23258 } 23259 // match: (Or64 _ (Const64 [-1])) 23260 // cond: 23261 // result: (Const64 [-1]) 23262 for { 23263 _ = v.Args[1] 23264 v_1 := v.Args[1] 23265 if v_1.Op != OpConst64 { 23266 break 23267 } 23268 if v_1.AuxInt != -1 { 23269 break 23270 } 23271 v.reset(OpConst64) 23272 v.AuxInt = -1 23273 return true 23274 } 23275 // match: (Or64 x (Or64 x y)) 23276 // cond: 23277 // result: (Or64 x y) 23278 for { 23279 _ = v.Args[1] 23280 x := v.Args[0] 23281 v_1 := v.Args[1] 23282 if v_1.Op != OpOr64 { 23283 break 23284 } 23285 _ = v_1.Args[1] 23286 if x != v_1.Args[0] { 23287 break 23288 } 23289 y := v_1.Args[1] 23290 v.reset(OpOr64) 23291 v.AddArg(x) 23292 v.AddArg(y) 23293 return true 23294 } 23295 // match: (Or64 x (Or64 y x)) 23296 // cond: 23297 // result: (Or64 x y) 23298 for { 23299 _ = v.Args[1] 23300 x := v.Args[0] 23301 v_1 := v.Args[1] 23302 if v_1.Op != OpOr64 { 23303 break 23304 } 23305 _ = v_1.Args[1] 23306 y := v_1.Args[0] 23307 if x != v_1.Args[1] { 23308 break 23309 } 23310 v.reset(OpOr64) 23311 v.AddArg(x) 23312 v.AddArg(y) 23313 return true 23314 } 23315 // match: (Or64 (Or64 x y) x) 23316 // cond: 23317 // result: (Or64 x y) 23318 for { 23319 _ = v.Args[1] 23320 v_0 := v.Args[0] 23321 if v_0.Op != OpOr64 { 23322 break 23323 } 23324 _ = v_0.Args[1] 23325 x := v_0.Args[0] 23326 y := v_0.Args[1] 23327 if x != v.Args[1] { 23328 break 23329 } 23330 v.reset(OpOr64) 23331 v.AddArg(x) 23332 v.AddArg(y) 23333 return true 23334 } 23335 return false 23336 } 23337 func rewriteValuegeneric_OpOr64_10(v *Value) bool { 23338 b := v.Block 23339 _ = b 23340 // match: (Or64 (Or64 y x) x) 23341 // cond: 23342 // result: (Or64 x y) 23343 for { 23344 _ = v.Args[1] 23345 v_0 := v.Args[0] 23346 if v_0.Op != OpOr64 { 23347 break 23348 } 23349 _ = v_0.Args[1] 23350 y := v_0.Args[0] 23351 x := v_0.Args[1] 23352 if x != v.Args[1] { 23353 break 23354 } 23355 v.reset(OpOr64) 23356 v.AddArg(x) 23357 v.AddArg(y) 23358 return true 23359 } 23360 // match: (Or64 (And64 x (Const64 [c2])) (Const64 <t> [c1])) 23361 // cond: ^(c1 | c2) == 0 23362 // result: (Or64 (Const64 <t> [c1]) x) 23363 for { 23364 _ = v.Args[1] 23365 v_0 := v.Args[0] 23366 if v_0.Op != OpAnd64 { 23367 break 23368 } 23369 _ = v_0.Args[1] 23370 x := v_0.Args[0] 23371 v_0_1 := v_0.Args[1] 23372 if v_0_1.Op != OpConst64 { 23373 break 23374 } 23375 c2 := v_0_1.AuxInt 23376 v_1 := v.Args[1] 23377 if v_1.Op != OpConst64 { 23378 break 23379 } 23380 t := v_1.Type 23381 c1 := v_1.AuxInt 23382 if !(^(c1 | c2) == 0) { 23383 break 23384 } 23385 v.reset(OpOr64) 23386 v0 := b.NewValue0(v.Pos, OpConst64, t) 23387 v0.AuxInt = c1 23388 v.AddArg(v0) 23389 v.AddArg(x) 23390 return true 23391 } 23392 // match: (Or64 (And64 (Const64 [c2]) x) (Const64 <t> [c1])) 23393 // cond: ^(c1 | c2) == 0 23394 // result: (Or64 (Const64 <t> [c1]) x) 23395 for { 23396 _ = v.Args[1] 23397 v_0 := v.Args[0] 23398 if v_0.Op != OpAnd64 { 23399 break 23400 } 23401 _ = v_0.Args[1] 23402 v_0_0 := v_0.Args[0] 23403 if v_0_0.Op != OpConst64 { 23404 break 23405 } 23406 c2 := v_0_0.AuxInt 23407 x := v_0.Args[1] 23408 v_1 := v.Args[1] 23409 if v_1.Op != OpConst64 { 23410 break 23411 } 23412 t := v_1.Type 23413 c1 := v_1.AuxInt 23414 if !(^(c1 | c2) == 0) { 23415 break 23416 } 23417 v.reset(OpOr64) 23418 v0 := b.NewValue0(v.Pos, OpConst64, t) 23419 v0.AuxInt = c1 23420 v.AddArg(v0) 23421 v.AddArg(x) 23422 return true 23423 } 23424 // match: (Or64 (Const64 <t> [c1]) (And64 x (Const64 [c2]))) 23425 // cond: ^(c1 | c2) == 0 23426 // result: (Or64 (Const64 <t> [c1]) x) 23427 for { 23428 _ = v.Args[1] 23429 v_0 := v.Args[0] 23430 if v_0.Op != OpConst64 { 23431 break 23432 } 23433 t := v_0.Type 23434 c1 := v_0.AuxInt 23435 v_1 := v.Args[1] 23436 if v_1.Op != OpAnd64 { 23437 break 23438 } 23439 _ = v_1.Args[1] 23440 x := v_1.Args[0] 23441 v_1_1 := v_1.Args[1] 23442 if v_1_1.Op != OpConst64 { 23443 break 23444 } 23445 c2 := v_1_1.AuxInt 23446 if !(^(c1 | c2) == 0) { 23447 break 23448 } 23449 v.reset(OpOr64) 23450 v0 := b.NewValue0(v.Pos, OpConst64, t) 23451 v0.AuxInt = c1 23452 v.AddArg(v0) 23453 v.AddArg(x) 23454 return true 23455 } 23456 // match: (Or64 (Const64 <t> [c1]) (And64 (Const64 [c2]) x)) 23457 // cond: ^(c1 | c2) == 0 23458 // result: (Or64 (Const64 <t> [c1]) x) 23459 for { 23460 _ = v.Args[1] 23461 v_0 := v.Args[0] 23462 if v_0.Op != OpConst64 { 23463 break 23464 } 23465 t := v_0.Type 23466 c1 := v_0.AuxInt 23467 v_1 := v.Args[1] 23468 if v_1.Op != OpAnd64 { 23469 break 23470 } 23471 _ = v_1.Args[1] 23472 v_1_0 := v_1.Args[0] 23473 if v_1_0.Op != OpConst64 { 23474 break 23475 } 23476 c2 := v_1_0.AuxInt 23477 x := v_1.Args[1] 23478 if !(^(c1 | c2) == 0) { 23479 break 23480 } 23481 v.reset(OpOr64) 23482 v0 := b.NewValue0(v.Pos, OpConst64, t) 23483 v0.AuxInt = c1 23484 v.AddArg(v0) 23485 v.AddArg(x) 23486 return true 23487 } 23488 // match: (Or64 (Or64 i:(Const64 <t>) z) x) 23489 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 23490 // result: (Or64 i (Or64 <t> z x)) 23491 for { 23492 _ = v.Args[1] 23493 v_0 := v.Args[0] 23494 if v_0.Op != OpOr64 { 23495 break 23496 } 23497 _ = v_0.Args[1] 23498 i := v_0.Args[0] 23499 if i.Op != OpConst64 { 23500 break 23501 } 23502 t := i.Type 23503 z := v_0.Args[1] 23504 x := v.Args[1] 23505 if !(z.Op != OpConst64 && x.Op != OpConst64) { 23506 break 23507 } 23508 v.reset(OpOr64) 23509 v.AddArg(i) 23510 v0 := b.NewValue0(v.Pos, OpOr64, t) 23511 v0.AddArg(z) 23512 v0.AddArg(x) 23513 v.AddArg(v0) 23514 return true 23515 } 23516 // match: (Or64 (Or64 z i:(Const64 <t>)) x) 23517 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 23518 // result: (Or64 i (Or64 <t> z x)) 23519 for { 23520 _ = v.Args[1] 23521 v_0 := v.Args[0] 23522 if v_0.Op != OpOr64 { 23523 break 23524 } 23525 _ = v_0.Args[1] 23526 z := v_0.Args[0] 23527 i := v_0.Args[1] 23528 if i.Op != OpConst64 { 23529 break 23530 } 23531 t := i.Type 23532 x := v.Args[1] 23533 if !(z.Op != OpConst64 && x.Op != OpConst64) { 23534 break 23535 } 23536 v.reset(OpOr64) 23537 v.AddArg(i) 23538 v0 := b.NewValue0(v.Pos, OpOr64, t) 23539 v0.AddArg(z) 23540 v0.AddArg(x) 23541 v.AddArg(v0) 23542 return true 23543 } 23544 // match: (Or64 x (Or64 i:(Const64 <t>) z)) 23545 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 23546 // result: (Or64 i (Or64 <t> z x)) 23547 for { 23548 _ = v.Args[1] 23549 x := v.Args[0] 23550 v_1 := v.Args[1] 23551 if v_1.Op != OpOr64 { 23552 break 23553 } 23554 _ = v_1.Args[1] 23555 i := v_1.Args[0] 23556 if i.Op != OpConst64 { 23557 break 23558 } 23559 t := i.Type 23560 z := v_1.Args[1] 23561 if !(z.Op != OpConst64 && x.Op != OpConst64) { 23562 break 23563 } 23564 v.reset(OpOr64) 23565 v.AddArg(i) 23566 v0 := b.NewValue0(v.Pos, OpOr64, t) 23567 v0.AddArg(z) 23568 v0.AddArg(x) 23569 v.AddArg(v0) 23570 return true 23571 } 23572 // match: (Or64 x (Or64 z i:(Const64 <t>))) 23573 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 23574 // result: (Or64 i (Or64 <t> z x)) 23575 for { 23576 _ = v.Args[1] 23577 x := v.Args[0] 23578 v_1 := v.Args[1] 23579 if v_1.Op != OpOr64 { 23580 break 23581 } 23582 _ = v_1.Args[1] 23583 z := v_1.Args[0] 23584 i := v_1.Args[1] 23585 if i.Op != OpConst64 { 23586 break 23587 } 23588 t := i.Type 23589 if !(z.Op != OpConst64 && x.Op != OpConst64) { 23590 break 23591 } 23592 v.reset(OpOr64) 23593 v.AddArg(i) 23594 v0 := b.NewValue0(v.Pos, OpOr64, t) 23595 v0.AddArg(z) 23596 v0.AddArg(x) 23597 v.AddArg(v0) 23598 return true 23599 } 23600 // match: (Or64 (Const64 <t> [c]) (Or64 (Const64 <t> [d]) x)) 23601 // cond: 23602 // result: (Or64 (Const64 <t> [c|d]) x) 23603 for { 23604 _ = v.Args[1] 23605 v_0 := v.Args[0] 23606 if v_0.Op != OpConst64 { 23607 break 23608 } 23609 t := v_0.Type 23610 c := v_0.AuxInt 23611 v_1 := v.Args[1] 23612 if v_1.Op != OpOr64 { 23613 break 23614 } 23615 _ = v_1.Args[1] 23616 v_1_0 := v_1.Args[0] 23617 if v_1_0.Op != OpConst64 { 23618 break 23619 } 23620 if v_1_0.Type != t { 23621 break 23622 } 23623 d := v_1_0.AuxInt 23624 x := v_1.Args[1] 23625 v.reset(OpOr64) 23626 v0 := b.NewValue0(v.Pos, OpConst64, t) 23627 v0.AuxInt = c | d 23628 v.AddArg(v0) 23629 v.AddArg(x) 23630 return true 23631 } 23632 return false 23633 } 23634 func rewriteValuegeneric_OpOr64_20(v *Value) bool { 23635 b := v.Block 23636 _ = b 23637 // match: (Or64 (Const64 <t> [c]) (Or64 x (Const64 <t> [d]))) 23638 // cond: 23639 // result: (Or64 (Const64 <t> [c|d]) x) 23640 for { 23641 _ = v.Args[1] 23642 v_0 := v.Args[0] 23643 if v_0.Op != OpConst64 { 23644 break 23645 } 23646 t := v_0.Type 23647 c := v_0.AuxInt 23648 v_1 := v.Args[1] 23649 if v_1.Op != OpOr64 { 23650 break 23651 } 23652 _ = v_1.Args[1] 23653 x := v_1.Args[0] 23654 v_1_1 := v_1.Args[1] 23655 if v_1_1.Op != OpConst64 { 23656 break 23657 } 23658 if v_1_1.Type != t { 23659 break 23660 } 23661 d := v_1_1.AuxInt 23662 v.reset(OpOr64) 23663 v0 := b.NewValue0(v.Pos, OpConst64, t) 23664 v0.AuxInt = c | d 23665 v.AddArg(v0) 23666 v.AddArg(x) 23667 return true 23668 } 23669 // match: (Or64 (Or64 (Const64 <t> [d]) x) (Const64 <t> [c])) 23670 // cond: 23671 // result: (Or64 (Const64 <t> [c|d]) x) 23672 for { 23673 _ = v.Args[1] 23674 v_0 := v.Args[0] 23675 if v_0.Op != OpOr64 { 23676 break 23677 } 23678 _ = v_0.Args[1] 23679 v_0_0 := v_0.Args[0] 23680 if v_0_0.Op != OpConst64 { 23681 break 23682 } 23683 t := v_0_0.Type 23684 d := v_0_0.AuxInt 23685 x := v_0.Args[1] 23686 v_1 := v.Args[1] 23687 if v_1.Op != OpConst64 { 23688 break 23689 } 23690 if v_1.Type != t { 23691 break 23692 } 23693 c := v_1.AuxInt 23694 v.reset(OpOr64) 23695 v0 := b.NewValue0(v.Pos, OpConst64, t) 23696 v0.AuxInt = c | d 23697 v.AddArg(v0) 23698 v.AddArg(x) 23699 return true 23700 } 23701 // match: (Or64 (Or64 x (Const64 <t> [d])) (Const64 <t> [c])) 23702 // cond: 23703 // result: (Or64 (Const64 <t> [c|d]) x) 23704 for { 23705 _ = v.Args[1] 23706 v_0 := v.Args[0] 23707 if v_0.Op != OpOr64 { 23708 break 23709 } 23710 _ = v_0.Args[1] 23711 x := v_0.Args[0] 23712 v_0_1 := v_0.Args[1] 23713 if v_0_1.Op != OpConst64 { 23714 break 23715 } 23716 t := v_0_1.Type 23717 d := v_0_1.AuxInt 23718 v_1 := v.Args[1] 23719 if v_1.Op != OpConst64 { 23720 break 23721 } 23722 if v_1.Type != t { 23723 break 23724 } 23725 c := v_1.AuxInt 23726 v.reset(OpOr64) 23727 v0 := b.NewValue0(v.Pos, OpConst64, t) 23728 v0.AuxInt = c | d 23729 v.AddArg(v0) 23730 v.AddArg(x) 23731 return true 23732 } 23733 return false 23734 } 23735 func rewriteValuegeneric_OpOr8_0(v *Value) bool { 23736 // match: (Or8 (Const8 [c]) (Const8 [d])) 23737 // cond: 23738 // result: (Const8 [int64(int8(c|d))]) 23739 for { 23740 _ = v.Args[1] 23741 v_0 := v.Args[0] 23742 if v_0.Op != OpConst8 { 23743 break 23744 } 23745 c := v_0.AuxInt 23746 v_1 := v.Args[1] 23747 if v_1.Op != OpConst8 { 23748 break 23749 } 23750 d := v_1.AuxInt 23751 v.reset(OpConst8) 23752 v.AuxInt = int64(int8(c | d)) 23753 return true 23754 } 23755 // match: (Or8 (Const8 [d]) (Const8 [c])) 23756 // cond: 23757 // result: (Const8 [int64(int8(c|d))]) 23758 for { 23759 _ = v.Args[1] 23760 v_0 := v.Args[0] 23761 if v_0.Op != OpConst8 { 23762 break 23763 } 23764 d := v_0.AuxInt 23765 v_1 := v.Args[1] 23766 if v_1.Op != OpConst8 { 23767 break 23768 } 23769 c := v_1.AuxInt 23770 v.reset(OpConst8) 23771 v.AuxInt = int64(int8(c | d)) 23772 return true 23773 } 23774 // match: (Or8 x x) 23775 // cond: 23776 // result: x 23777 for { 23778 _ = v.Args[1] 23779 x := v.Args[0] 23780 if x != v.Args[1] { 23781 break 23782 } 23783 v.reset(OpCopy) 23784 v.Type = x.Type 23785 v.AddArg(x) 23786 return true 23787 } 23788 // match: (Or8 (Const8 [0]) x) 23789 // cond: 23790 // result: x 23791 for { 23792 _ = v.Args[1] 23793 v_0 := v.Args[0] 23794 if v_0.Op != OpConst8 { 23795 break 23796 } 23797 if v_0.AuxInt != 0 { 23798 break 23799 } 23800 x := v.Args[1] 23801 v.reset(OpCopy) 23802 v.Type = x.Type 23803 v.AddArg(x) 23804 return true 23805 } 23806 // match: (Or8 x (Const8 [0])) 23807 // cond: 23808 // result: x 23809 for { 23810 _ = v.Args[1] 23811 x := v.Args[0] 23812 v_1 := v.Args[1] 23813 if v_1.Op != OpConst8 { 23814 break 23815 } 23816 if v_1.AuxInt != 0 { 23817 break 23818 } 23819 v.reset(OpCopy) 23820 v.Type = x.Type 23821 v.AddArg(x) 23822 return true 23823 } 23824 // match: (Or8 (Const8 [-1]) _) 23825 // cond: 23826 // result: (Const8 [-1]) 23827 for { 23828 _ = v.Args[1] 23829 v_0 := v.Args[0] 23830 if v_0.Op != OpConst8 { 23831 break 23832 } 23833 if v_0.AuxInt != -1 { 23834 break 23835 } 23836 v.reset(OpConst8) 23837 v.AuxInt = -1 23838 return true 23839 } 23840 // match: (Or8 _ (Const8 [-1])) 23841 // cond: 23842 // result: (Const8 [-1]) 23843 for { 23844 _ = v.Args[1] 23845 v_1 := v.Args[1] 23846 if v_1.Op != OpConst8 { 23847 break 23848 } 23849 if v_1.AuxInt != -1 { 23850 break 23851 } 23852 v.reset(OpConst8) 23853 v.AuxInt = -1 23854 return true 23855 } 23856 // match: (Or8 x (Or8 x y)) 23857 // cond: 23858 // result: (Or8 x y) 23859 for { 23860 _ = v.Args[1] 23861 x := v.Args[0] 23862 v_1 := v.Args[1] 23863 if v_1.Op != OpOr8 { 23864 break 23865 } 23866 _ = v_1.Args[1] 23867 if x != v_1.Args[0] { 23868 break 23869 } 23870 y := v_1.Args[1] 23871 v.reset(OpOr8) 23872 v.AddArg(x) 23873 v.AddArg(y) 23874 return true 23875 } 23876 // match: (Or8 x (Or8 y x)) 23877 // cond: 23878 // result: (Or8 x y) 23879 for { 23880 _ = v.Args[1] 23881 x := v.Args[0] 23882 v_1 := v.Args[1] 23883 if v_1.Op != OpOr8 { 23884 break 23885 } 23886 _ = v_1.Args[1] 23887 y := v_1.Args[0] 23888 if x != v_1.Args[1] { 23889 break 23890 } 23891 v.reset(OpOr8) 23892 v.AddArg(x) 23893 v.AddArg(y) 23894 return true 23895 } 23896 // match: (Or8 (Or8 x y) x) 23897 // cond: 23898 // result: (Or8 x y) 23899 for { 23900 _ = v.Args[1] 23901 v_0 := v.Args[0] 23902 if v_0.Op != OpOr8 { 23903 break 23904 } 23905 _ = v_0.Args[1] 23906 x := v_0.Args[0] 23907 y := v_0.Args[1] 23908 if x != v.Args[1] { 23909 break 23910 } 23911 v.reset(OpOr8) 23912 v.AddArg(x) 23913 v.AddArg(y) 23914 return true 23915 } 23916 return false 23917 } 23918 func rewriteValuegeneric_OpOr8_10(v *Value) bool { 23919 b := v.Block 23920 _ = b 23921 // match: (Or8 (Or8 y x) x) 23922 // cond: 23923 // result: (Or8 x y) 23924 for { 23925 _ = v.Args[1] 23926 v_0 := v.Args[0] 23927 if v_0.Op != OpOr8 { 23928 break 23929 } 23930 _ = v_0.Args[1] 23931 y := v_0.Args[0] 23932 x := v_0.Args[1] 23933 if x != v.Args[1] { 23934 break 23935 } 23936 v.reset(OpOr8) 23937 v.AddArg(x) 23938 v.AddArg(y) 23939 return true 23940 } 23941 // match: (Or8 (And8 x (Const8 [c2])) (Const8 <t> [c1])) 23942 // cond: ^(c1 | c2) == 0 23943 // result: (Or8 (Const8 <t> [c1]) x) 23944 for { 23945 _ = v.Args[1] 23946 v_0 := v.Args[0] 23947 if v_0.Op != OpAnd8 { 23948 break 23949 } 23950 _ = v_0.Args[1] 23951 x := v_0.Args[0] 23952 v_0_1 := v_0.Args[1] 23953 if v_0_1.Op != OpConst8 { 23954 break 23955 } 23956 c2 := v_0_1.AuxInt 23957 v_1 := v.Args[1] 23958 if v_1.Op != OpConst8 { 23959 break 23960 } 23961 t := v_1.Type 23962 c1 := v_1.AuxInt 23963 if !(^(c1 | c2) == 0) { 23964 break 23965 } 23966 v.reset(OpOr8) 23967 v0 := b.NewValue0(v.Pos, OpConst8, t) 23968 v0.AuxInt = c1 23969 v.AddArg(v0) 23970 v.AddArg(x) 23971 return true 23972 } 23973 // match: (Or8 (And8 (Const8 [c2]) x) (Const8 <t> [c1])) 23974 // cond: ^(c1 | c2) == 0 23975 // result: (Or8 (Const8 <t> [c1]) x) 23976 for { 23977 _ = v.Args[1] 23978 v_0 := v.Args[0] 23979 if v_0.Op != OpAnd8 { 23980 break 23981 } 23982 _ = v_0.Args[1] 23983 v_0_0 := v_0.Args[0] 23984 if v_0_0.Op != OpConst8 { 23985 break 23986 } 23987 c2 := v_0_0.AuxInt 23988 x := v_0.Args[1] 23989 v_1 := v.Args[1] 23990 if v_1.Op != OpConst8 { 23991 break 23992 } 23993 t := v_1.Type 23994 c1 := v_1.AuxInt 23995 if !(^(c1 | c2) == 0) { 23996 break 23997 } 23998 v.reset(OpOr8) 23999 v0 := b.NewValue0(v.Pos, OpConst8, t) 24000 v0.AuxInt = c1 24001 v.AddArg(v0) 24002 v.AddArg(x) 24003 return true 24004 } 24005 // match: (Or8 (Const8 <t> [c1]) (And8 x (Const8 [c2]))) 24006 // cond: ^(c1 | c2) == 0 24007 // result: (Or8 (Const8 <t> [c1]) x) 24008 for { 24009 _ = v.Args[1] 24010 v_0 := v.Args[0] 24011 if v_0.Op != OpConst8 { 24012 break 24013 } 24014 t := v_0.Type 24015 c1 := v_0.AuxInt 24016 v_1 := v.Args[1] 24017 if v_1.Op != OpAnd8 { 24018 break 24019 } 24020 _ = v_1.Args[1] 24021 x := v_1.Args[0] 24022 v_1_1 := v_1.Args[1] 24023 if v_1_1.Op != OpConst8 { 24024 break 24025 } 24026 c2 := v_1_1.AuxInt 24027 if !(^(c1 | c2) == 0) { 24028 break 24029 } 24030 v.reset(OpOr8) 24031 v0 := b.NewValue0(v.Pos, OpConst8, t) 24032 v0.AuxInt = c1 24033 v.AddArg(v0) 24034 v.AddArg(x) 24035 return true 24036 } 24037 // match: (Or8 (Const8 <t> [c1]) (And8 (Const8 [c2]) x)) 24038 // cond: ^(c1 | c2) == 0 24039 // result: (Or8 (Const8 <t> [c1]) x) 24040 for { 24041 _ = v.Args[1] 24042 v_0 := v.Args[0] 24043 if v_0.Op != OpConst8 { 24044 break 24045 } 24046 t := v_0.Type 24047 c1 := v_0.AuxInt 24048 v_1 := v.Args[1] 24049 if v_1.Op != OpAnd8 { 24050 break 24051 } 24052 _ = v_1.Args[1] 24053 v_1_0 := v_1.Args[0] 24054 if v_1_0.Op != OpConst8 { 24055 break 24056 } 24057 c2 := v_1_0.AuxInt 24058 x := v_1.Args[1] 24059 if !(^(c1 | c2) == 0) { 24060 break 24061 } 24062 v.reset(OpOr8) 24063 v0 := b.NewValue0(v.Pos, OpConst8, t) 24064 v0.AuxInt = c1 24065 v.AddArg(v0) 24066 v.AddArg(x) 24067 return true 24068 } 24069 // match: (Or8 (Or8 i:(Const8 <t>) z) x) 24070 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 24071 // result: (Or8 i (Or8 <t> z x)) 24072 for { 24073 _ = v.Args[1] 24074 v_0 := v.Args[0] 24075 if v_0.Op != OpOr8 { 24076 break 24077 } 24078 _ = v_0.Args[1] 24079 i := v_0.Args[0] 24080 if i.Op != OpConst8 { 24081 break 24082 } 24083 t := i.Type 24084 z := v_0.Args[1] 24085 x := v.Args[1] 24086 if !(z.Op != OpConst8 && x.Op != OpConst8) { 24087 break 24088 } 24089 v.reset(OpOr8) 24090 v.AddArg(i) 24091 v0 := b.NewValue0(v.Pos, OpOr8, t) 24092 v0.AddArg(z) 24093 v0.AddArg(x) 24094 v.AddArg(v0) 24095 return true 24096 } 24097 // match: (Or8 (Or8 z i:(Const8 <t>)) x) 24098 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 24099 // result: (Or8 i (Or8 <t> z x)) 24100 for { 24101 _ = v.Args[1] 24102 v_0 := v.Args[0] 24103 if v_0.Op != OpOr8 { 24104 break 24105 } 24106 _ = v_0.Args[1] 24107 z := v_0.Args[0] 24108 i := v_0.Args[1] 24109 if i.Op != OpConst8 { 24110 break 24111 } 24112 t := i.Type 24113 x := v.Args[1] 24114 if !(z.Op != OpConst8 && x.Op != OpConst8) { 24115 break 24116 } 24117 v.reset(OpOr8) 24118 v.AddArg(i) 24119 v0 := b.NewValue0(v.Pos, OpOr8, t) 24120 v0.AddArg(z) 24121 v0.AddArg(x) 24122 v.AddArg(v0) 24123 return true 24124 } 24125 // match: (Or8 x (Or8 i:(Const8 <t>) z)) 24126 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 24127 // result: (Or8 i (Or8 <t> z x)) 24128 for { 24129 _ = v.Args[1] 24130 x := v.Args[0] 24131 v_1 := v.Args[1] 24132 if v_1.Op != OpOr8 { 24133 break 24134 } 24135 _ = v_1.Args[1] 24136 i := v_1.Args[0] 24137 if i.Op != OpConst8 { 24138 break 24139 } 24140 t := i.Type 24141 z := v_1.Args[1] 24142 if !(z.Op != OpConst8 && x.Op != OpConst8) { 24143 break 24144 } 24145 v.reset(OpOr8) 24146 v.AddArg(i) 24147 v0 := b.NewValue0(v.Pos, OpOr8, t) 24148 v0.AddArg(z) 24149 v0.AddArg(x) 24150 v.AddArg(v0) 24151 return true 24152 } 24153 // match: (Or8 x (Or8 z i:(Const8 <t>))) 24154 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 24155 // result: (Or8 i (Or8 <t> z x)) 24156 for { 24157 _ = v.Args[1] 24158 x := v.Args[0] 24159 v_1 := v.Args[1] 24160 if v_1.Op != OpOr8 { 24161 break 24162 } 24163 _ = v_1.Args[1] 24164 z := v_1.Args[0] 24165 i := v_1.Args[1] 24166 if i.Op != OpConst8 { 24167 break 24168 } 24169 t := i.Type 24170 if !(z.Op != OpConst8 && x.Op != OpConst8) { 24171 break 24172 } 24173 v.reset(OpOr8) 24174 v.AddArg(i) 24175 v0 := b.NewValue0(v.Pos, OpOr8, t) 24176 v0.AddArg(z) 24177 v0.AddArg(x) 24178 v.AddArg(v0) 24179 return true 24180 } 24181 // match: (Or8 (Const8 <t> [c]) (Or8 (Const8 <t> [d]) x)) 24182 // cond: 24183 // result: (Or8 (Const8 <t> [int64(int8(c|d))]) x) 24184 for { 24185 _ = v.Args[1] 24186 v_0 := v.Args[0] 24187 if v_0.Op != OpConst8 { 24188 break 24189 } 24190 t := v_0.Type 24191 c := v_0.AuxInt 24192 v_1 := v.Args[1] 24193 if v_1.Op != OpOr8 { 24194 break 24195 } 24196 _ = v_1.Args[1] 24197 v_1_0 := v_1.Args[0] 24198 if v_1_0.Op != OpConst8 { 24199 break 24200 } 24201 if v_1_0.Type != t { 24202 break 24203 } 24204 d := v_1_0.AuxInt 24205 x := v_1.Args[1] 24206 v.reset(OpOr8) 24207 v0 := b.NewValue0(v.Pos, OpConst8, t) 24208 v0.AuxInt = int64(int8(c | d)) 24209 v.AddArg(v0) 24210 v.AddArg(x) 24211 return true 24212 } 24213 return false 24214 } 24215 func rewriteValuegeneric_OpOr8_20(v *Value) bool { 24216 b := v.Block 24217 _ = b 24218 // match: (Or8 (Const8 <t> [c]) (Or8 x (Const8 <t> [d]))) 24219 // cond: 24220 // result: (Or8 (Const8 <t> [int64(int8(c|d))]) x) 24221 for { 24222 _ = v.Args[1] 24223 v_0 := v.Args[0] 24224 if v_0.Op != OpConst8 { 24225 break 24226 } 24227 t := v_0.Type 24228 c := v_0.AuxInt 24229 v_1 := v.Args[1] 24230 if v_1.Op != OpOr8 { 24231 break 24232 } 24233 _ = v_1.Args[1] 24234 x := v_1.Args[0] 24235 v_1_1 := v_1.Args[1] 24236 if v_1_1.Op != OpConst8 { 24237 break 24238 } 24239 if v_1_1.Type != t { 24240 break 24241 } 24242 d := v_1_1.AuxInt 24243 v.reset(OpOr8) 24244 v0 := b.NewValue0(v.Pos, OpConst8, t) 24245 v0.AuxInt = int64(int8(c | d)) 24246 v.AddArg(v0) 24247 v.AddArg(x) 24248 return true 24249 } 24250 // match: (Or8 (Or8 (Const8 <t> [d]) x) (Const8 <t> [c])) 24251 // cond: 24252 // result: (Or8 (Const8 <t> [int64(int8(c|d))]) x) 24253 for { 24254 _ = v.Args[1] 24255 v_0 := v.Args[0] 24256 if v_0.Op != OpOr8 { 24257 break 24258 } 24259 _ = v_0.Args[1] 24260 v_0_0 := v_0.Args[0] 24261 if v_0_0.Op != OpConst8 { 24262 break 24263 } 24264 t := v_0_0.Type 24265 d := v_0_0.AuxInt 24266 x := v_0.Args[1] 24267 v_1 := v.Args[1] 24268 if v_1.Op != OpConst8 { 24269 break 24270 } 24271 if v_1.Type != t { 24272 break 24273 } 24274 c := v_1.AuxInt 24275 v.reset(OpOr8) 24276 v0 := b.NewValue0(v.Pos, OpConst8, t) 24277 v0.AuxInt = int64(int8(c | d)) 24278 v.AddArg(v0) 24279 v.AddArg(x) 24280 return true 24281 } 24282 // match: (Or8 (Or8 x (Const8 <t> [d])) (Const8 <t> [c])) 24283 // cond: 24284 // result: (Or8 (Const8 <t> [int64(int8(c|d))]) x) 24285 for { 24286 _ = v.Args[1] 24287 v_0 := v.Args[0] 24288 if v_0.Op != OpOr8 { 24289 break 24290 } 24291 _ = v_0.Args[1] 24292 x := v_0.Args[0] 24293 v_0_1 := v_0.Args[1] 24294 if v_0_1.Op != OpConst8 { 24295 break 24296 } 24297 t := v_0_1.Type 24298 d := v_0_1.AuxInt 24299 v_1 := v.Args[1] 24300 if v_1.Op != OpConst8 { 24301 break 24302 } 24303 if v_1.Type != t { 24304 break 24305 } 24306 c := v_1.AuxInt 24307 v.reset(OpOr8) 24308 v0 := b.NewValue0(v.Pos, OpConst8, t) 24309 v0.AuxInt = int64(int8(c | d)) 24310 v.AddArg(v0) 24311 v.AddArg(x) 24312 return true 24313 } 24314 return false 24315 } 24316 func rewriteValuegeneric_OpPhi_0(v *Value) bool { 24317 // match: (Phi (Const8 [c]) (Const8 [c])) 24318 // cond: 24319 // result: (Const8 [c]) 24320 for { 24321 _ = v.Args[1] 24322 v_0 := v.Args[0] 24323 if v_0.Op != OpConst8 { 24324 break 24325 } 24326 c := v_0.AuxInt 24327 v_1 := v.Args[1] 24328 if v_1.Op != OpConst8 { 24329 break 24330 } 24331 if v_1.AuxInt != c { 24332 break 24333 } 24334 if len(v.Args) != 2 { 24335 break 24336 } 24337 v.reset(OpConst8) 24338 v.AuxInt = c 24339 return true 24340 } 24341 // match: (Phi (Const16 [c]) (Const16 [c])) 24342 // cond: 24343 // result: (Const16 [c]) 24344 for { 24345 _ = v.Args[1] 24346 v_0 := v.Args[0] 24347 if v_0.Op != OpConst16 { 24348 break 24349 } 24350 c := v_0.AuxInt 24351 v_1 := v.Args[1] 24352 if v_1.Op != OpConst16 { 24353 break 24354 } 24355 if v_1.AuxInt != c { 24356 break 24357 } 24358 if len(v.Args) != 2 { 24359 break 24360 } 24361 v.reset(OpConst16) 24362 v.AuxInt = c 24363 return true 24364 } 24365 // match: (Phi (Const32 [c]) (Const32 [c])) 24366 // cond: 24367 // result: (Const32 [c]) 24368 for { 24369 _ = v.Args[1] 24370 v_0 := v.Args[0] 24371 if v_0.Op != OpConst32 { 24372 break 24373 } 24374 c := v_0.AuxInt 24375 v_1 := v.Args[1] 24376 if v_1.Op != OpConst32 { 24377 break 24378 } 24379 if v_1.AuxInt != c { 24380 break 24381 } 24382 if len(v.Args) != 2 { 24383 break 24384 } 24385 v.reset(OpConst32) 24386 v.AuxInt = c 24387 return true 24388 } 24389 // match: (Phi (Const64 [c]) (Const64 [c])) 24390 // cond: 24391 // result: (Const64 [c]) 24392 for { 24393 _ = v.Args[1] 24394 v_0 := v.Args[0] 24395 if v_0.Op != OpConst64 { 24396 break 24397 } 24398 c := v_0.AuxInt 24399 v_1 := v.Args[1] 24400 if v_1.Op != OpConst64 { 24401 break 24402 } 24403 if v_1.AuxInt != c { 24404 break 24405 } 24406 if len(v.Args) != 2 { 24407 break 24408 } 24409 v.reset(OpConst64) 24410 v.AuxInt = c 24411 return true 24412 } 24413 return false 24414 } 24415 func rewriteValuegeneric_OpPtrIndex_0(v *Value) bool { 24416 b := v.Block 24417 _ = b 24418 config := b.Func.Config 24419 _ = config 24420 typ := &b.Func.Config.Types 24421 _ = typ 24422 // match: (PtrIndex <t> ptr idx) 24423 // cond: config.PtrSize == 4 24424 // result: (AddPtr ptr (Mul32 <typ.Int> idx (Const32 <typ.Int> [t.Elem().Size()]))) 24425 for { 24426 t := v.Type 24427 _ = v.Args[1] 24428 ptr := v.Args[0] 24429 idx := v.Args[1] 24430 if !(config.PtrSize == 4) { 24431 break 24432 } 24433 v.reset(OpAddPtr) 24434 v.AddArg(ptr) 24435 v0 := b.NewValue0(v.Pos, OpMul32, typ.Int) 24436 v0.AddArg(idx) 24437 v1 := b.NewValue0(v.Pos, OpConst32, typ.Int) 24438 v1.AuxInt = t.Elem().Size() 24439 v0.AddArg(v1) 24440 v.AddArg(v0) 24441 return true 24442 } 24443 // match: (PtrIndex <t> ptr idx) 24444 // cond: config.PtrSize == 8 24445 // result: (AddPtr ptr (Mul64 <typ.Int> idx (Const64 <typ.Int> [t.Elem().Size()]))) 24446 for { 24447 t := v.Type 24448 _ = v.Args[1] 24449 ptr := v.Args[0] 24450 idx := v.Args[1] 24451 if !(config.PtrSize == 8) { 24452 break 24453 } 24454 v.reset(OpAddPtr) 24455 v.AddArg(ptr) 24456 v0 := b.NewValue0(v.Pos, OpMul64, typ.Int) 24457 v0.AddArg(idx) 24458 v1 := b.NewValue0(v.Pos, OpConst64, typ.Int) 24459 v1.AuxInt = t.Elem().Size() 24460 v0.AddArg(v1) 24461 v.AddArg(v0) 24462 return true 24463 } 24464 return false 24465 } 24466 func rewriteValuegeneric_OpRound32F_0(v *Value) bool { 24467 // match: (Round32F x:(Const32F)) 24468 // cond: 24469 // result: x 24470 for { 24471 x := v.Args[0] 24472 if x.Op != OpConst32F { 24473 break 24474 } 24475 v.reset(OpCopy) 24476 v.Type = x.Type 24477 v.AddArg(x) 24478 return true 24479 } 24480 return false 24481 } 24482 func rewriteValuegeneric_OpRound64F_0(v *Value) bool { 24483 // match: (Round64F x:(Const64F)) 24484 // cond: 24485 // result: x 24486 for { 24487 x := v.Args[0] 24488 if x.Op != OpConst64F { 24489 break 24490 } 24491 v.reset(OpCopy) 24492 v.Type = x.Type 24493 v.AddArg(x) 24494 return true 24495 } 24496 return false 24497 } 24498 func rewriteValuegeneric_OpRsh16Ux16_0(v *Value) bool { 24499 b := v.Block 24500 _ = b 24501 // match: (Rsh16Ux16 <t> x (Const16 [c])) 24502 // cond: 24503 // result: (Rsh16Ux64 x (Const64 <t> [int64(uint16(c))])) 24504 for { 24505 t := v.Type 24506 _ = v.Args[1] 24507 x := v.Args[0] 24508 v_1 := v.Args[1] 24509 if v_1.Op != OpConst16 { 24510 break 24511 } 24512 c := v_1.AuxInt 24513 v.reset(OpRsh16Ux64) 24514 v.AddArg(x) 24515 v0 := b.NewValue0(v.Pos, OpConst64, t) 24516 v0.AuxInt = int64(uint16(c)) 24517 v.AddArg(v0) 24518 return true 24519 } 24520 // match: (Rsh16Ux16 (Const16 [0]) _) 24521 // cond: 24522 // result: (Const16 [0]) 24523 for { 24524 _ = v.Args[1] 24525 v_0 := v.Args[0] 24526 if v_0.Op != OpConst16 { 24527 break 24528 } 24529 if v_0.AuxInt != 0 { 24530 break 24531 } 24532 v.reset(OpConst16) 24533 v.AuxInt = 0 24534 return true 24535 } 24536 return false 24537 } 24538 func rewriteValuegeneric_OpRsh16Ux32_0(v *Value) bool { 24539 b := v.Block 24540 _ = b 24541 // match: (Rsh16Ux32 <t> x (Const32 [c])) 24542 // cond: 24543 // result: (Rsh16Ux64 x (Const64 <t> [int64(uint32(c))])) 24544 for { 24545 t := v.Type 24546 _ = v.Args[1] 24547 x := v.Args[0] 24548 v_1 := v.Args[1] 24549 if v_1.Op != OpConst32 { 24550 break 24551 } 24552 c := v_1.AuxInt 24553 v.reset(OpRsh16Ux64) 24554 v.AddArg(x) 24555 v0 := b.NewValue0(v.Pos, OpConst64, t) 24556 v0.AuxInt = int64(uint32(c)) 24557 v.AddArg(v0) 24558 return true 24559 } 24560 // match: (Rsh16Ux32 (Const16 [0]) _) 24561 // cond: 24562 // result: (Const16 [0]) 24563 for { 24564 _ = v.Args[1] 24565 v_0 := v.Args[0] 24566 if v_0.Op != OpConst16 { 24567 break 24568 } 24569 if v_0.AuxInt != 0 { 24570 break 24571 } 24572 v.reset(OpConst16) 24573 v.AuxInt = 0 24574 return true 24575 } 24576 return false 24577 } 24578 func rewriteValuegeneric_OpRsh16Ux64_0(v *Value) bool { 24579 b := v.Block 24580 _ = b 24581 typ := &b.Func.Config.Types 24582 _ = typ 24583 // match: (Rsh16Ux64 (Const16 [c]) (Const64 [d])) 24584 // cond: 24585 // result: (Const16 [int64(int16(uint16(c) >> uint64(d)))]) 24586 for { 24587 _ = v.Args[1] 24588 v_0 := v.Args[0] 24589 if v_0.Op != OpConst16 { 24590 break 24591 } 24592 c := v_0.AuxInt 24593 v_1 := v.Args[1] 24594 if v_1.Op != OpConst64 { 24595 break 24596 } 24597 d := v_1.AuxInt 24598 v.reset(OpConst16) 24599 v.AuxInt = int64(int16(uint16(c) >> uint64(d))) 24600 return true 24601 } 24602 // match: (Rsh16Ux64 x (Const64 [0])) 24603 // cond: 24604 // result: x 24605 for { 24606 _ = v.Args[1] 24607 x := v.Args[0] 24608 v_1 := v.Args[1] 24609 if v_1.Op != OpConst64 { 24610 break 24611 } 24612 if v_1.AuxInt != 0 { 24613 break 24614 } 24615 v.reset(OpCopy) 24616 v.Type = x.Type 24617 v.AddArg(x) 24618 return true 24619 } 24620 // match: (Rsh16Ux64 (Const16 [0]) _) 24621 // cond: 24622 // result: (Const16 [0]) 24623 for { 24624 _ = v.Args[1] 24625 v_0 := v.Args[0] 24626 if v_0.Op != OpConst16 { 24627 break 24628 } 24629 if v_0.AuxInt != 0 { 24630 break 24631 } 24632 v.reset(OpConst16) 24633 v.AuxInt = 0 24634 return true 24635 } 24636 // match: (Rsh16Ux64 _ (Const64 [c])) 24637 // cond: uint64(c) >= 16 24638 // result: (Const16 [0]) 24639 for { 24640 _ = v.Args[1] 24641 v_1 := v.Args[1] 24642 if v_1.Op != OpConst64 { 24643 break 24644 } 24645 c := v_1.AuxInt 24646 if !(uint64(c) >= 16) { 24647 break 24648 } 24649 v.reset(OpConst16) 24650 v.AuxInt = 0 24651 return true 24652 } 24653 // match: (Rsh16Ux64 <t> (Rsh16Ux64 x (Const64 [c])) (Const64 [d])) 24654 // cond: !uaddOvf(c,d) 24655 // result: (Rsh16Ux64 x (Const64 <t> [c+d])) 24656 for { 24657 t := v.Type 24658 _ = v.Args[1] 24659 v_0 := v.Args[0] 24660 if v_0.Op != OpRsh16Ux64 { 24661 break 24662 } 24663 _ = v_0.Args[1] 24664 x := v_0.Args[0] 24665 v_0_1 := v_0.Args[1] 24666 if v_0_1.Op != OpConst64 { 24667 break 24668 } 24669 c := v_0_1.AuxInt 24670 v_1 := v.Args[1] 24671 if v_1.Op != OpConst64 { 24672 break 24673 } 24674 d := v_1.AuxInt 24675 if !(!uaddOvf(c, d)) { 24676 break 24677 } 24678 v.reset(OpRsh16Ux64) 24679 v.AddArg(x) 24680 v0 := b.NewValue0(v.Pos, OpConst64, t) 24681 v0.AuxInt = c + d 24682 v.AddArg(v0) 24683 return true 24684 } 24685 // match: (Rsh16Ux64 (Rsh16x64 x _) (Const64 <t> [15])) 24686 // cond: 24687 // result: (Rsh16Ux64 x (Const64 <t> [15])) 24688 for { 24689 _ = v.Args[1] 24690 v_0 := v.Args[0] 24691 if v_0.Op != OpRsh16x64 { 24692 break 24693 } 24694 _ = v_0.Args[1] 24695 x := v_0.Args[0] 24696 v_1 := v.Args[1] 24697 if v_1.Op != OpConst64 { 24698 break 24699 } 24700 t := v_1.Type 24701 if v_1.AuxInt != 15 { 24702 break 24703 } 24704 v.reset(OpRsh16Ux64) 24705 v.AddArg(x) 24706 v0 := b.NewValue0(v.Pos, OpConst64, t) 24707 v0.AuxInt = 15 24708 v.AddArg(v0) 24709 return true 24710 } 24711 // match: (Rsh16Ux64 (Lsh16x64 (Rsh16Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) 24712 // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) 24713 // result: (Rsh16Ux64 x (Const64 <typ.UInt64> [c1-c2+c3])) 24714 for { 24715 _ = v.Args[1] 24716 v_0 := v.Args[0] 24717 if v_0.Op != OpLsh16x64 { 24718 break 24719 } 24720 _ = v_0.Args[1] 24721 v_0_0 := v_0.Args[0] 24722 if v_0_0.Op != OpRsh16Ux64 { 24723 break 24724 } 24725 _ = v_0_0.Args[1] 24726 x := v_0_0.Args[0] 24727 v_0_0_1 := v_0_0.Args[1] 24728 if v_0_0_1.Op != OpConst64 { 24729 break 24730 } 24731 c1 := v_0_0_1.AuxInt 24732 v_0_1 := v_0.Args[1] 24733 if v_0_1.Op != OpConst64 { 24734 break 24735 } 24736 c2 := v_0_1.AuxInt 24737 v_1 := v.Args[1] 24738 if v_1.Op != OpConst64 { 24739 break 24740 } 24741 c3 := v_1.AuxInt 24742 if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { 24743 break 24744 } 24745 v.reset(OpRsh16Ux64) 24746 v.AddArg(x) 24747 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 24748 v0.AuxInt = c1 - c2 + c3 24749 v.AddArg(v0) 24750 return true 24751 } 24752 // match: (Rsh16Ux64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) 24753 // cond: 24754 // result: (ZeroExt8to16 (Trunc16to8 <typ.UInt8> x)) 24755 for { 24756 _ = v.Args[1] 24757 v_0 := v.Args[0] 24758 if v_0.Op != OpLsh16x64 { 24759 break 24760 } 24761 _ = v_0.Args[1] 24762 x := v_0.Args[0] 24763 v_0_1 := v_0.Args[1] 24764 if v_0_1.Op != OpConst64 { 24765 break 24766 } 24767 if v_0_1.AuxInt != 8 { 24768 break 24769 } 24770 v_1 := v.Args[1] 24771 if v_1.Op != OpConst64 { 24772 break 24773 } 24774 if v_1.AuxInt != 8 { 24775 break 24776 } 24777 v.reset(OpZeroExt8to16) 24778 v0 := b.NewValue0(v.Pos, OpTrunc16to8, typ.UInt8) 24779 v0.AddArg(x) 24780 v.AddArg(v0) 24781 return true 24782 } 24783 return false 24784 } 24785 func rewriteValuegeneric_OpRsh16Ux8_0(v *Value) bool { 24786 b := v.Block 24787 _ = b 24788 // match: (Rsh16Ux8 <t> x (Const8 [c])) 24789 // cond: 24790 // result: (Rsh16Ux64 x (Const64 <t> [int64(uint8(c))])) 24791 for { 24792 t := v.Type 24793 _ = v.Args[1] 24794 x := v.Args[0] 24795 v_1 := v.Args[1] 24796 if v_1.Op != OpConst8 { 24797 break 24798 } 24799 c := v_1.AuxInt 24800 v.reset(OpRsh16Ux64) 24801 v.AddArg(x) 24802 v0 := b.NewValue0(v.Pos, OpConst64, t) 24803 v0.AuxInt = int64(uint8(c)) 24804 v.AddArg(v0) 24805 return true 24806 } 24807 // match: (Rsh16Ux8 (Const16 [0]) _) 24808 // cond: 24809 // result: (Const16 [0]) 24810 for { 24811 _ = v.Args[1] 24812 v_0 := v.Args[0] 24813 if v_0.Op != OpConst16 { 24814 break 24815 } 24816 if v_0.AuxInt != 0 { 24817 break 24818 } 24819 v.reset(OpConst16) 24820 v.AuxInt = 0 24821 return true 24822 } 24823 return false 24824 } 24825 func rewriteValuegeneric_OpRsh16x16_0(v *Value) bool { 24826 b := v.Block 24827 _ = b 24828 // match: (Rsh16x16 <t> x (Const16 [c])) 24829 // cond: 24830 // result: (Rsh16x64 x (Const64 <t> [int64(uint16(c))])) 24831 for { 24832 t := v.Type 24833 _ = v.Args[1] 24834 x := v.Args[0] 24835 v_1 := v.Args[1] 24836 if v_1.Op != OpConst16 { 24837 break 24838 } 24839 c := v_1.AuxInt 24840 v.reset(OpRsh16x64) 24841 v.AddArg(x) 24842 v0 := b.NewValue0(v.Pos, OpConst64, t) 24843 v0.AuxInt = int64(uint16(c)) 24844 v.AddArg(v0) 24845 return true 24846 } 24847 // match: (Rsh16x16 (Const16 [0]) _) 24848 // cond: 24849 // result: (Const16 [0]) 24850 for { 24851 _ = v.Args[1] 24852 v_0 := v.Args[0] 24853 if v_0.Op != OpConst16 { 24854 break 24855 } 24856 if v_0.AuxInt != 0 { 24857 break 24858 } 24859 v.reset(OpConst16) 24860 v.AuxInt = 0 24861 return true 24862 } 24863 return false 24864 } 24865 func rewriteValuegeneric_OpRsh16x32_0(v *Value) bool { 24866 b := v.Block 24867 _ = b 24868 // match: (Rsh16x32 <t> x (Const32 [c])) 24869 // cond: 24870 // result: (Rsh16x64 x (Const64 <t> [int64(uint32(c))])) 24871 for { 24872 t := v.Type 24873 _ = v.Args[1] 24874 x := v.Args[0] 24875 v_1 := v.Args[1] 24876 if v_1.Op != OpConst32 { 24877 break 24878 } 24879 c := v_1.AuxInt 24880 v.reset(OpRsh16x64) 24881 v.AddArg(x) 24882 v0 := b.NewValue0(v.Pos, OpConst64, t) 24883 v0.AuxInt = int64(uint32(c)) 24884 v.AddArg(v0) 24885 return true 24886 } 24887 // match: (Rsh16x32 (Const16 [0]) _) 24888 // cond: 24889 // result: (Const16 [0]) 24890 for { 24891 _ = v.Args[1] 24892 v_0 := v.Args[0] 24893 if v_0.Op != OpConst16 { 24894 break 24895 } 24896 if v_0.AuxInt != 0 { 24897 break 24898 } 24899 v.reset(OpConst16) 24900 v.AuxInt = 0 24901 return true 24902 } 24903 return false 24904 } 24905 func rewriteValuegeneric_OpRsh16x64_0(v *Value) bool { 24906 b := v.Block 24907 _ = b 24908 typ := &b.Func.Config.Types 24909 _ = typ 24910 // match: (Rsh16x64 (Const16 [c]) (Const64 [d])) 24911 // cond: 24912 // result: (Const16 [int64(int16(c) >> uint64(d))]) 24913 for { 24914 _ = v.Args[1] 24915 v_0 := v.Args[0] 24916 if v_0.Op != OpConst16 { 24917 break 24918 } 24919 c := v_0.AuxInt 24920 v_1 := v.Args[1] 24921 if v_1.Op != OpConst64 { 24922 break 24923 } 24924 d := v_1.AuxInt 24925 v.reset(OpConst16) 24926 v.AuxInt = int64(int16(c) >> uint64(d)) 24927 return true 24928 } 24929 // match: (Rsh16x64 x (Const64 [0])) 24930 // cond: 24931 // result: x 24932 for { 24933 _ = v.Args[1] 24934 x := v.Args[0] 24935 v_1 := v.Args[1] 24936 if v_1.Op != OpConst64 { 24937 break 24938 } 24939 if v_1.AuxInt != 0 { 24940 break 24941 } 24942 v.reset(OpCopy) 24943 v.Type = x.Type 24944 v.AddArg(x) 24945 return true 24946 } 24947 // match: (Rsh16x64 (Const16 [0]) _) 24948 // cond: 24949 // result: (Const16 [0]) 24950 for { 24951 _ = v.Args[1] 24952 v_0 := v.Args[0] 24953 if v_0.Op != OpConst16 { 24954 break 24955 } 24956 if v_0.AuxInt != 0 { 24957 break 24958 } 24959 v.reset(OpConst16) 24960 v.AuxInt = 0 24961 return true 24962 } 24963 // match: (Rsh16x64 <t> (Rsh16x64 x (Const64 [c])) (Const64 [d])) 24964 // cond: !uaddOvf(c,d) 24965 // result: (Rsh16x64 x (Const64 <t> [c+d])) 24966 for { 24967 t := v.Type 24968 _ = v.Args[1] 24969 v_0 := v.Args[0] 24970 if v_0.Op != OpRsh16x64 { 24971 break 24972 } 24973 _ = v_0.Args[1] 24974 x := v_0.Args[0] 24975 v_0_1 := v_0.Args[1] 24976 if v_0_1.Op != OpConst64 { 24977 break 24978 } 24979 c := v_0_1.AuxInt 24980 v_1 := v.Args[1] 24981 if v_1.Op != OpConst64 { 24982 break 24983 } 24984 d := v_1.AuxInt 24985 if !(!uaddOvf(c, d)) { 24986 break 24987 } 24988 v.reset(OpRsh16x64) 24989 v.AddArg(x) 24990 v0 := b.NewValue0(v.Pos, OpConst64, t) 24991 v0.AuxInt = c + d 24992 v.AddArg(v0) 24993 return true 24994 } 24995 // match: (Rsh16x64 (Lsh16x64 x (Const64 [8])) (Const64 [8])) 24996 // cond: 24997 // result: (SignExt8to16 (Trunc16to8 <typ.Int8> x)) 24998 for { 24999 _ = v.Args[1] 25000 v_0 := v.Args[0] 25001 if v_0.Op != OpLsh16x64 { 25002 break 25003 } 25004 _ = v_0.Args[1] 25005 x := v_0.Args[0] 25006 v_0_1 := v_0.Args[1] 25007 if v_0_1.Op != OpConst64 { 25008 break 25009 } 25010 if v_0_1.AuxInt != 8 { 25011 break 25012 } 25013 v_1 := v.Args[1] 25014 if v_1.Op != OpConst64 { 25015 break 25016 } 25017 if v_1.AuxInt != 8 { 25018 break 25019 } 25020 v.reset(OpSignExt8to16) 25021 v0 := b.NewValue0(v.Pos, OpTrunc16to8, typ.Int8) 25022 v0.AddArg(x) 25023 v.AddArg(v0) 25024 return true 25025 } 25026 return false 25027 } 25028 func rewriteValuegeneric_OpRsh16x8_0(v *Value) bool { 25029 b := v.Block 25030 _ = b 25031 // match: (Rsh16x8 <t> x (Const8 [c])) 25032 // cond: 25033 // result: (Rsh16x64 x (Const64 <t> [int64(uint8(c))])) 25034 for { 25035 t := v.Type 25036 _ = v.Args[1] 25037 x := v.Args[0] 25038 v_1 := v.Args[1] 25039 if v_1.Op != OpConst8 { 25040 break 25041 } 25042 c := v_1.AuxInt 25043 v.reset(OpRsh16x64) 25044 v.AddArg(x) 25045 v0 := b.NewValue0(v.Pos, OpConst64, t) 25046 v0.AuxInt = int64(uint8(c)) 25047 v.AddArg(v0) 25048 return true 25049 } 25050 // match: (Rsh16x8 (Const16 [0]) _) 25051 // cond: 25052 // result: (Const16 [0]) 25053 for { 25054 _ = v.Args[1] 25055 v_0 := v.Args[0] 25056 if v_0.Op != OpConst16 { 25057 break 25058 } 25059 if v_0.AuxInt != 0 { 25060 break 25061 } 25062 v.reset(OpConst16) 25063 v.AuxInt = 0 25064 return true 25065 } 25066 return false 25067 } 25068 func rewriteValuegeneric_OpRsh32Ux16_0(v *Value) bool { 25069 b := v.Block 25070 _ = b 25071 // match: (Rsh32Ux16 <t> x (Const16 [c])) 25072 // cond: 25073 // result: (Rsh32Ux64 x (Const64 <t> [int64(uint16(c))])) 25074 for { 25075 t := v.Type 25076 _ = v.Args[1] 25077 x := v.Args[0] 25078 v_1 := v.Args[1] 25079 if v_1.Op != OpConst16 { 25080 break 25081 } 25082 c := v_1.AuxInt 25083 v.reset(OpRsh32Ux64) 25084 v.AddArg(x) 25085 v0 := b.NewValue0(v.Pos, OpConst64, t) 25086 v0.AuxInt = int64(uint16(c)) 25087 v.AddArg(v0) 25088 return true 25089 } 25090 // match: (Rsh32Ux16 (Const32 [0]) _) 25091 // cond: 25092 // result: (Const32 [0]) 25093 for { 25094 _ = v.Args[1] 25095 v_0 := v.Args[0] 25096 if v_0.Op != OpConst32 { 25097 break 25098 } 25099 if v_0.AuxInt != 0 { 25100 break 25101 } 25102 v.reset(OpConst32) 25103 v.AuxInt = 0 25104 return true 25105 } 25106 return false 25107 } 25108 func rewriteValuegeneric_OpRsh32Ux32_0(v *Value) bool { 25109 b := v.Block 25110 _ = b 25111 // match: (Rsh32Ux32 <t> x (Const32 [c])) 25112 // cond: 25113 // result: (Rsh32Ux64 x (Const64 <t> [int64(uint32(c))])) 25114 for { 25115 t := v.Type 25116 _ = v.Args[1] 25117 x := v.Args[0] 25118 v_1 := v.Args[1] 25119 if v_1.Op != OpConst32 { 25120 break 25121 } 25122 c := v_1.AuxInt 25123 v.reset(OpRsh32Ux64) 25124 v.AddArg(x) 25125 v0 := b.NewValue0(v.Pos, OpConst64, t) 25126 v0.AuxInt = int64(uint32(c)) 25127 v.AddArg(v0) 25128 return true 25129 } 25130 // match: (Rsh32Ux32 (Const32 [0]) _) 25131 // cond: 25132 // result: (Const32 [0]) 25133 for { 25134 _ = v.Args[1] 25135 v_0 := v.Args[0] 25136 if v_0.Op != OpConst32 { 25137 break 25138 } 25139 if v_0.AuxInt != 0 { 25140 break 25141 } 25142 v.reset(OpConst32) 25143 v.AuxInt = 0 25144 return true 25145 } 25146 return false 25147 } 25148 func rewriteValuegeneric_OpRsh32Ux64_0(v *Value) bool { 25149 b := v.Block 25150 _ = b 25151 typ := &b.Func.Config.Types 25152 _ = typ 25153 // match: (Rsh32Ux64 (Const32 [c]) (Const64 [d])) 25154 // cond: 25155 // result: (Const32 [int64(int32(uint32(c) >> uint64(d)))]) 25156 for { 25157 _ = v.Args[1] 25158 v_0 := v.Args[0] 25159 if v_0.Op != OpConst32 { 25160 break 25161 } 25162 c := v_0.AuxInt 25163 v_1 := v.Args[1] 25164 if v_1.Op != OpConst64 { 25165 break 25166 } 25167 d := v_1.AuxInt 25168 v.reset(OpConst32) 25169 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 25170 return true 25171 } 25172 // match: (Rsh32Ux64 x (Const64 [0])) 25173 // cond: 25174 // result: x 25175 for { 25176 _ = v.Args[1] 25177 x := v.Args[0] 25178 v_1 := v.Args[1] 25179 if v_1.Op != OpConst64 { 25180 break 25181 } 25182 if v_1.AuxInt != 0 { 25183 break 25184 } 25185 v.reset(OpCopy) 25186 v.Type = x.Type 25187 v.AddArg(x) 25188 return true 25189 } 25190 // match: (Rsh32Ux64 (Const32 [0]) _) 25191 // cond: 25192 // result: (Const32 [0]) 25193 for { 25194 _ = v.Args[1] 25195 v_0 := v.Args[0] 25196 if v_0.Op != OpConst32 { 25197 break 25198 } 25199 if v_0.AuxInt != 0 { 25200 break 25201 } 25202 v.reset(OpConst32) 25203 v.AuxInt = 0 25204 return true 25205 } 25206 // match: (Rsh32Ux64 _ (Const64 [c])) 25207 // cond: uint64(c) >= 32 25208 // result: (Const32 [0]) 25209 for { 25210 _ = v.Args[1] 25211 v_1 := v.Args[1] 25212 if v_1.Op != OpConst64 { 25213 break 25214 } 25215 c := v_1.AuxInt 25216 if !(uint64(c) >= 32) { 25217 break 25218 } 25219 v.reset(OpConst32) 25220 v.AuxInt = 0 25221 return true 25222 } 25223 // match: (Rsh32Ux64 <t> (Rsh32Ux64 x (Const64 [c])) (Const64 [d])) 25224 // cond: !uaddOvf(c,d) 25225 // result: (Rsh32Ux64 x (Const64 <t> [c+d])) 25226 for { 25227 t := v.Type 25228 _ = v.Args[1] 25229 v_0 := v.Args[0] 25230 if v_0.Op != OpRsh32Ux64 { 25231 break 25232 } 25233 _ = v_0.Args[1] 25234 x := v_0.Args[0] 25235 v_0_1 := v_0.Args[1] 25236 if v_0_1.Op != OpConst64 { 25237 break 25238 } 25239 c := v_0_1.AuxInt 25240 v_1 := v.Args[1] 25241 if v_1.Op != OpConst64 { 25242 break 25243 } 25244 d := v_1.AuxInt 25245 if !(!uaddOvf(c, d)) { 25246 break 25247 } 25248 v.reset(OpRsh32Ux64) 25249 v.AddArg(x) 25250 v0 := b.NewValue0(v.Pos, OpConst64, t) 25251 v0.AuxInt = c + d 25252 v.AddArg(v0) 25253 return true 25254 } 25255 // match: (Rsh32Ux64 (Rsh32x64 x _) (Const64 <t> [31])) 25256 // cond: 25257 // result: (Rsh32Ux64 x (Const64 <t> [31])) 25258 for { 25259 _ = v.Args[1] 25260 v_0 := v.Args[0] 25261 if v_0.Op != OpRsh32x64 { 25262 break 25263 } 25264 _ = v_0.Args[1] 25265 x := v_0.Args[0] 25266 v_1 := v.Args[1] 25267 if v_1.Op != OpConst64 { 25268 break 25269 } 25270 t := v_1.Type 25271 if v_1.AuxInt != 31 { 25272 break 25273 } 25274 v.reset(OpRsh32Ux64) 25275 v.AddArg(x) 25276 v0 := b.NewValue0(v.Pos, OpConst64, t) 25277 v0.AuxInt = 31 25278 v.AddArg(v0) 25279 return true 25280 } 25281 // match: (Rsh32Ux64 (Lsh32x64 (Rsh32Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) 25282 // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) 25283 // result: (Rsh32Ux64 x (Const64 <typ.UInt64> [c1-c2+c3])) 25284 for { 25285 _ = v.Args[1] 25286 v_0 := v.Args[0] 25287 if v_0.Op != OpLsh32x64 { 25288 break 25289 } 25290 _ = v_0.Args[1] 25291 v_0_0 := v_0.Args[0] 25292 if v_0_0.Op != OpRsh32Ux64 { 25293 break 25294 } 25295 _ = v_0_0.Args[1] 25296 x := v_0_0.Args[0] 25297 v_0_0_1 := v_0_0.Args[1] 25298 if v_0_0_1.Op != OpConst64 { 25299 break 25300 } 25301 c1 := v_0_0_1.AuxInt 25302 v_0_1 := v_0.Args[1] 25303 if v_0_1.Op != OpConst64 { 25304 break 25305 } 25306 c2 := v_0_1.AuxInt 25307 v_1 := v.Args[1] 25308 if v_1.Op != OpConst64 { 25309 break 25310 } 25311 c3 := v_1.AuxInt 25312 if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { 25313 break 25314 } 25315 v.reset(OpRsh32Ux64) 25316 v.AddArg(x) 25317 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 25318 v0.AuxInt = c1 - c2 + c3 25319 v.AddArg(v0) 25320 return true 25321 } 25322 // match: (Rsh32Ux64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) 25323 // cond: 25324 // result: (ZeroExt8to32 (Trunc32to8 <typ.UInt8> x)) 25325 for { 25326 _ = v.Args[1] 25327 v_0 := v.Args[0] 25328 if v_0.Op != OpLsh32x64 { 25329 break 25330 } 25331 _ = v_0.Args[1] 25332 x := v_0.Args[0] 25333 v_0_1 := v_0.Args[1] 25334 if v_0_1.Op != OpConst64 { 25335 break 25336 } 25337 if v_0_1.AuxInt != 24 { 25338 break 25339 } 25340 v_1 := v.Args[1] 25341 if v_1.Op != OpConst64 { 25342 break 25343 } 25344 if v_1.AuxInt != 24 { 25345 break 25346 } 25347 v.reset(OpZeroExt8to32) 25348 v0 := b.NewValue0(v.Pos, OpTrunc32to8, typ.UInt8) 25349 v0.AddArg(x) 25350 v.AddArg(v0) 25351 return true 25352 } 25353 // match: (Rsh32Ux64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) 25354 // cond: 25355 // result: (ZeroExt16to32 (Trunc32to16 <typ.UInt16> x)) 25356 for { 25357 _ = v.Args[1] 25358 v_0 := v.Args[0] 25359 if v_0.Op != OpLsh32x64 { 25360 break 25361 } 25362 _ = v_0.Args[1] 25363 x := v_0.Args[0] 25364 v_0_1 := v_0.Args[1] 25365 if v_0_1.Op != OpConst64 { 25366 break 25367 } 25368 if v_0_1.AuxInt != 16 { 25369 break 25370 } 25371 v_1 := v.Args[1] 25372 if v_1.Op != OpConst64 { 25373 break 25374 } 25375 if v_1.AuxInt != 16 { 25376 break 25377 } 25378 v.reset(OpZeroExt16to32) 25379 v0 := b.NewValue0(v.Pos, OpTrunc32to16, typ.UInt16) 25380 v0.AddArg(x) 25381 v.AddArg(v0) 25382 return true 25383 } 25384 return false 25385 } 25386 func rewriteValuegeneric_OpRsh32Ux8_0(v *Value) bool { 25387 b := v.Block 25388 _ = b 25389 // match: (Rsh32Ux8 <t> x (Const8 [c])) 25390 // cond: 25391 // result: (Rsh32Ux64 x (Const64 <t> [int64(uint8(c))])) 25392 for { 25393 t := v.Type 25394 _ = v.Args[1] 25395 x := v.Args[0] 25396 v_1 := v.Args[1] 25397 if v_1.Op != OpConst8 { 25398 break 25399 } 25400 c := v_1.AuxInt 25401 v.reset(OpRsh32Ux64) 25402 v.AddArg(x) 25403 v0 := b.NewValue0(v.Pos, OpConst64, t) 25404 v0.AuxInt = int64(uint8(c)) 25405 v.AddArg(v0) 25406 return true 25407 } 25408 // match: (Rsh32Ux8 (Const32 [0]) _) 25409 // cond: 25410 // result: (Const32 [0]) 25411 for { 25412 _ = v.Args[1] 25413 v_0 := v.Args[0] 25414 if v_0.Op != OpConst32 { 25415 break 25416 } 25417 if v_0.AuxInt != 0 { 25418 break 25419 } 25420 v.reset(OpConst32) 25421 v.AuxInt = 0 25422 return true 25423 } 25424 return false 25425 } 25426 func rewriteValuegeneric_OpRsh32x16_0(v *Value) bool { 25427 b := v.Block 25428 _ = b 25429 // match: (Rsh32x16 <t> x (Const16 [c])) 25430 // cond: 25431 // result: (Rsh32x64 x (Const64 <t> [int64(uint16(c))])) 25432 for { 25433 t := v.Type 25434 _ = v.Args[1] 25435 x := v.Args[0] 25436 v_1 := v.Args[1] 25437 if v_1.Op != OpConst16 { 25438 break 25439 } 25440 c := v_1.AuxInt 25441 v.reset(OpRsh32x64) 25442 v.AddArg(x) 25443 v0 := b.NewValue0(v.Pos, OpConst64, t) 25444 v0.AuxInt = int64(uint16(c)) 25445 v.AddArg(v0) 25446 return true 25447 } 25448 // match: (Rsh32x16 (Const32 [0]) _) 25449 // cond: 25450 // result: (Const32 [0]) 25451 for { 25452 _ = v.Args[1] 25453 v_0 := v.Args[0] 25454 if v_0.Op != OpConst32 { 25455 break 25456 } 25457 if v_0.AuxInt != 0 { 25458 break 25459 } 25460 v.reset(OpConst32) 25461 v.AuxInt = 0 25462 return true 25463 } 25464 return false 25465 } 25466 func rewriteValuegeneric_OpRsh32x32_0(v *Value) bool { 25467 b := v.Block 25468 _ = b 25469 // match: (Rsh32x32 <t> x (Const32 [c])) 25470 // cond: 25471 // result: (Rsh32x64 x (Const64 <t> [int64(uint32(c))])) 25472 for { 25473 t := v.Type 25474 _ = v.Args[1] 25475 x := v.Args[0] 25476 v_1 := v.Args[1] 25477 if v_1.Op != OpConst32 { 25478 break 25479 } 25480 c := v_1.AuxInt 25481 v.reset(OpRsh32x64) 25482 v.AddArg(x) 25483 v0 := b.NewValue0(v.Pos, OpConst64, t) 25484 v0.AuxInt = int64(uint32(c)) 25485 v.AddArg(v0) 25486 return true 25487 } 25488 // match: (Rsh32x32 (Const32 [0]) _) 25489 // cond: 25490 // result: (Const32 [0]) 25491 for { 25492 _ = v.Args[1] 25493 v_0 := v.Args[0] 25494 if v_0.Op != OpConst32 { 25495 break 25496 } 25497 if v_0.AuxInt != 0 { 25498 break 25499 } 25500 v.reset(OpConst32) 25501 v.AuxInt = 0 25502 return true 25503 } 25504 return false 25505 } 25506 func rewriteValuegeneric_OpRsh32x64_0(v *Value) bool { 25507 b := v.Block 25508 _ = b 25509 typ := &b.Func.Config.Types 25510 _ = typ 25511 // match: (Rsh32x64 (Const32 [c]) (Const64 [d])) 25512 // cond: 25513 // result: (Const32 [int64(int32(c) >> uint64(d))]) 25514 for { 25515 _ = v.Args[1] 25516 v_0 := v.Args[0] 25517 if v_0.Op != OpConst32 { 25518 break 25519 } 25520 c := v_0.AuxInt 25521 v_1 := v.Args[1] 25522 if v_1.Op != OpConst64 { 25523 break 25524 } 25525 d := v_1.AuxInt 25526 v.reset(OpConst32) 25527 v.AuxInt = int64(int32(c) >> uint64(d)) 25528 return true 25529 } 25530 // match: (Rsh32x64 x (Const64 [0])) 25531 // cond: 25532 // result: x 25533 for { 25534 _ = v.Args[1] 25535 x := v.Args[0] 25536 v_1 := v.Args[1] 25537 if v_1.Op != OpConst64 { 25538 break 25539 } 25540 if v_1.AuxInt != 0 { 25541 break 25542 } 25543 v.reset(OpCopy) 25544 v.Type = x.Type 25545 v.AddArg(x) 25546 return true 25547 } 25548 // match: (Rsh32x64 (Const32 [0]) _) 25549 // cond: 25550 // result: (Const32 [0]) 25551 for { 25552 _ = v.Args[1] 25553 v_0 := v.Args[0] 25554 if v_0.Op != OpConst32 { 25555 break 25556 } 25557 if v_0.AuxInt != 0 { 25558 break 25559 } 25560 v.reset(OpConst32) 25561 v.AuxInt = 0 25562 return true 25563 } 25564 // match: (Rsh32x64 <t> (Rsh32x64 x (Const64 [c])) (Const64 [d])) 25565 // cond: !uaddOvf(c,d) 25566 // result: (Rsh32x64 x (Const64 <t> [c+d])) 25567 for { 25568 t := v.Type 25569 _ = v.Args[1] 25570 v_0 := v.Args[0] 25571 if v_0.Op != OpRsh32x64 { 25572 break 25573 } 25574 _ = v_0.Args[1] 25575 x := v_0.Args[0] 25576 v_0_1 := v_0.Args[1] 25577 if v_0_1.Op != OpConst64 { 25578 break 25579 } 25580 c := v_0_1.AuxInt 25581 v_1 := v.Args[1] 25582 if v_1.Op != OpConst64 { 25583 break 25584 } 25585 d := v_1.AuxInt 25586 if !(!uaddOvf(c, d)) { 25587 break 25588 } 25589 v.reset(OpRsh32x64) 25590 v.AddArg(x) 25591 v0 := b.NewValue0(v.Pos, OpConst64, t) 25592 v0.AuxInt = c + d 25593 v.AddArg(v0) 25594 return true 25595 } 25596 // match: (Rsh32x64 (Lsh32x64 x (Const64 [24])) (Const64 [24])) 25597 // cond: 25598 // result: (SignExt8to32 (Trunc32to8 <typ.Int8> x)) 25599 for { 25600 _ = v.Args[1] 25601 v_0 := v.Args[0] 25602 if v_0.Op != OpLsh32x64 { 25603 break 25604 } 25605 _ = v_0.Args[1] 25606 x := v_0.Args[0] 25607 v_0_1 := v_0.Args[1] 25608 if v_0_1.Op != OpConst64 { 25609 break 25610 } 25611 if v_0_1.AuxInt != 24 { 25612 break 25613 } 25614 v_1 := v.Args[1] 25615 if v_1.Op != OpConst64 { 25616 break 25617 } 25618 if v_1.AuxInt != 24 { 25619 break 25620 } 25621 v.reset(OpSignExt8to32) 25622 v0 := b.NewValue0(v.Pos, OpTrunc32to8, typ.Int8) 25623 v0.AddArg(x) 25624 v.AddArg(v0) 25625 return true 25626 } 25627 // match: (Rsh32x64 (Lsh32x64 x (Const64 [16])) (Const64 [16])) 25628 // cond: 25629 // result: (SignExt16to32 (Trunc32to16 <typ.Int16> x)) 25630 for { 25631 _ = v.Args[1] 25632 v_0 := v.Args[0] 25633 if v_0.Op != OpLsh32x64 { 25634 break 25635 } 25636 _ = v_0.Args[1] 25637 x := v_0.Args[0] 25638 v_0_1 := v_0.Args[1] 25639 if v_0_1.Op != OpConst64 { 25640 break 25641 } 25642 if v_0_1.AuxInt != 16 { 25643 break 25644 } 25645 v_1 := v.Args[1] 25646 if v_1.Op != OpConst64 { 25647 break 25648 } 25649 if v_1.AuxInt != 16 { 25650 break 25651 } 25652 v.reset(OpSignExt16to32) 25653 v0 := b.NewValue0(v.Pos, OpTrunc32to16, typ.Int16) 25654 v0.AddArg(x) 25655 v.AddArg(v0) 25656 return true 25657 } 25658 return false 25659 } 25660 func rewriteValuegeneric_OpRsh32x8_0(v *Value) bool { 25661 b := v.Block 25662 _ = b 25663 // match: (Rsh32x8 <t> x (Const8 [c])) 25664 // cond: 25665 // result: (Rsh32x64 x (Const64 <t> [int64(uint8(c))])) 25666 for { 25667 t := v.Type 25668 _ = v.Args[1] 25669 x := v.Args[0] 25670 v_1 := v.Args[1] 25671 if v_1.Op != OpConst8 { 25672 break 25673 } 25674 c := v_1.AuxInt 25675 v.reset(OpRsh32x64) 25676 v.AddArg(x) 25677 v0 := b.NewValue0(v.Pos, OpConst64, t) 25678 v0.AuxInt = int64(uint8(c)) 25679 v.AddArg(v0) 25680 return true 25681 } 25682 // match: (Rsh32x8 (Const32 [0]) _) 25683 // cond: 25684 // result: (Const32 [0]) 25685 for { 25686 _ = v.Args[1] 25687 v_0 := v.Args[0] 25688 if v_0.Op != OpConst32 { 25689 break 25690 } 25691 if v_0.AuxInt != 0 { 25692 break 25693 } 25694 v.reset(OpConst32) 25695 v.AuxInt = 0 25696 return true 25697 } 25698 return false 25699 } 25700 func rewriteValuegeneric_OpRsh64Ux16_0(v *Value) bool { 25701 b := v.Block 25702 _ = b 25703 // match: (Rsh64Ux16 <t> x (Const16 [c])) 25704 // cond: 25705 // result: (Rsh64Ux64 x (Const64 <t> [int64(uint16(c))])) 25706 for { 25707 t := v.Type 25708 _ = v.Args[1] 25709 x := v.Args[0] 25710 v_1 := v.Args[1] 25711 if v_1.Op != OpConst16 { 25712 break 25713 } 25714 c := v_1.AuxInt 25715 v.reset(OpRsh64Ux64) 25716 v.AddArg(x) 25717 v0 := b.NewValue0(v.Pos, OpConst64, t) 25718 v0.AuxInt = int64(uint16(c)) 25719 v.AddArg(v0) 25720 return true 25721 } 25722 // match: (Rsh64Ux16 (Const64 [0]) _) 25723 // cond: 25724 // result: (Const64 [0]) 25725 for { 25726 _ = v.Args[1] 25727 v_0 := v.Args[0] 25728 if v_0.Op != OpConst64 { 25729 break 25730 } 25731 if v_0.AuxInt != 0 { 25732 break 25733 } 25734 v.reset(OpConst64) 25735 v.AuxInt = 0 25736 return true 25737 } 25738 return false 25739 } 25740 func rewriteValuegeneric_OpRsh64Ux32_0(v *Value) bool { 25741 b := v.Block 25742 _ = b 25743 // match: (Rsh64Ux32 <t> x (Const32 [c])) 25744 // cond: 25745 // result: (Rsh64Ux64 x (Const64 <t> [int64(uint32(c))])) 25746 for { 25747 t := v.Type 25748 _ = v.Args[1] 25749 x := v.Args[0] 25750 v_1 := v.Args[1] 25751 if v_1.Op != OpConst32 { 25752 break 25753 } 25754 c := v_1.AuxInt 25755 v.reset(OpRsh64Ux64) 25756 v.AddArg(x) 25757 v0 := b.NewValue0(v.Pos, OpConst64, t) 25758 v0.AuxInt = int64(uint32(c)) 25759 v.AddArg(v0) 25760 return true 25761 } 25762 // match: (Rsh64Ux32 (Const64 [0]) _) 25763 // cond: 25764 // result: (Const64 [0]) 25765 for { 25766 _ = v.Args[1] 25767 v_0 := v.Args[0] 25768 if v_0.Op != OpConst64 { 25769 break 25770 } 25771 if v_0.AuxInt != 0 { 25772 break 25773 } 25774 v.reset(OpConst64) 25775 v.AuxInt = 0 25776 return true 25777 } 25778 return false 25779 } 25780 func rewriteValuegeneric_OpRsh64Ux64_0(v *Value) bool { 25781 b := v.Block 25782 _ = b 25783 typ := &b.Func.Config.Types 25784 _ = typ 25785 // match: (Rsh64Ux64 (Const64 [c]) (Const64 [d])) 25786 // cond: 25787 // result: (Const64 [int64(uint64(c) >> uint64(d))]) 25788 for { 25789 _ = v.Args[1] 25790 v_0 := v.Args[0] 25791 if v_0.Op != OpConst64 { 25792 break 25793 } 25794 c := v_0.AuxInt 25795 v_1 := v.Args[1] 25796 if v_1.Op != OpConst64 { 25797 break 25798 } 25799 d := v_1.AuxInt 25800 v.reset(OpConst64) 25801 v.AuxInt = int64(uint64(c) >> uint64(d)) 25802 return true 25803 } 25804 // match: (Rsh64Ux64 x (Const64 [0])) 25805 // cond: 25806 // result: x 25807 for { 25808 _ = v.Args[1] 25809 x := v.Args[0] 25810 v_1 := v.Args[1] 25811 if v_1.Op != OpConst64 { 25812 break 25813 } 25814 if v_1.AuxInt != 0 { 25815 break 25816 } 25817 v.reset(OpCopy) 25818 v.Type = x.Type 25819 v.AddArg(x) 25820 return true 25821 } 25822 // match: (Rsh64Ux64 (Const64 [0]) _) 25823 // cond: 25824 // result: (Const64 [0]) 25825 for { 25826 _ = v.Args[1] 25827 v_0 := v.Args[0] 25828 if v_0.Op != OpConst64 { 25829 break 25830 } 25831 if v_0.AuxInt != 0 { 25832 break 25833 } 25834 v.reset(OpConst64) 25835 v.AuxInt = 0 25836 return true 25837 } 25838 // match: (Rsh64Ux64 _ (Const64 [c])) 25839 // cond: uint64(c) >= 64 25840 // result: (Const64 [0]) 25841 for { 25842 _ = v.Args[1] 25843 v_1 := v.Args[1] 25844 if v_1.Op != OpConst64 { 25845 break 25846 } 25847 c := v_1.AuxInt 25848 if !(uint64(c) >= 64) { 25849 break 25850 } 25851 v.reset(OpConst64) 25852 v.AuxInt = 0 25853 return true 25854 } 25855 // match: (Rsh64Ux64 <t> (Rsh64Ux64 x (Const64 [c])) (Const64 [d])) 25856 // cond: !uaddOvf(c,d) 25857 // result: (Rsh64Ux64 x (Const64 <t> [c+d])) 25858 for { 25859 t := v.Type 25860 _ = v.Args[1] 25861 v_0 := v.Args[0] 25862 if v_0.Op != OpRsh64Ux64 { 25863 break 25864 } 25865 _ = v_0.Args[1] 25866 x := v_0.Args[0] 25867 v_0_1 := v_0.Args[1] 25868 if v_0_1.Op != OpConst64 { 25869 break 25870 } 25871 c := v_0_1.AuxInt 25872 v_1 := v.Args[1] 25873 if v_1.Op != OpConst64 { 25874 break 25875 } 25876 d := v_1.AuxInt 25877 if !(!uaddOvf(c, d)) { 25878 break 25879 } 25880 v.reset(OpRsh64Ux64) 25881 v.AddArg(x) 25882 v0 := b.NewValue0(v.Pos, OpConst64, t) 25883 v0.AuxInt = c + d 25884 v.AddArg(v0) 25885 return true 25886 } 25887 // match: (Rsh64Ux64 (Rsh64x64 x _) (Const64 <t> [63])) 25888 // cond: 25889 // result: (Rsh64Ux64 x (Const64 <t> [63])) 25890 for { 25891 _ = v.Args[1] 25892 v_0 := v.Args[0] 25893 if v_0.Op != OpRsh64x64 { 25894 break 25895 } 25896 _ = v_0.Args[1] 25897 x := v_0.Args[0] 25898 v_1 := v.Args[1] 25899 if v_1.Op != OpConst64 { 25900 break 25901 } 25902 t := v_1.Type 25903 if v_1.AuxInt != 63 { 25904 break 25905 } 25906 v.reset(OpRsh64Ux64) 25907 v.AddArg(x) 25908 v0 := b.NewValue0(v.Pos, OpConst64, t) 25909 v0.AuxInt = 63 25910 v.AddArg(v0) 25911 return true 25912 } 25913 // match: (Rsh64Ux64 (Lsh64x64 (Rsh64Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) 25914 // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) 25915 // result: (Rsh64Ux64 x (Const64 <typ.UInt64> [c1-c2+c3])) 25916 for { 25917 _ = v.Args[1] 25918 v_0 := v.Args[0] 25919 if v_0.Op != OpLsh64x64 { 25920 break 25921 } 25922 _ = v_0.Args[1] 25923 v_0_0 := v_0.Args[0] 25924 if v_0_0.Op != OpRsh64Ux64 { 25925 break 25926 } 25927 _ = v_0_0.Args[1] 25928 x := v_0_0.Args[0] 25929 v_0_0_1 := v_0_0.Args[1] 25930 if v_0_0_1.Op != OpConst64 { 25931 break 25932 } 25933 c1 := v_0_0_1.AuxInt 25934 v_0_1 := v_0.Args[1] 25935 if v_0_1.Op != OpConst64 { 25936 break 25937 } 25938 c2 := v_0_1.AuxInt 25939 v_1 := v.Args[1] 25940 if v_1.Op != OpConst64 { 25941 break 25942 } 25943 c3 := v_1.AuxInt 25944 if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { 25945 break 25946 } 25947 v.reset(OpRsh64Ux64) 25948 v.AddArg(x) 25949 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 25950 v0.AuxInt = c1 - c2 + c3 25951 v.AddArg(v0) 25952 return true 25953 } 25954 // match: (Rsh64Ux64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) 25955 // cond: 25956 // result: (ZeroExt8to64 (Trunc64to8 <typ.UInt8> x)) 25957 for { 25958 _ = v.Args[1] 25959 v_0 := v.Args[0] 25960 if v_0.Op != OpLsh64x64 { 25961 break 25962 } 25963 _ = v_0.Args[1] 25964 x := v_0.Args[0] 25965 v_0_1 := v_0.Args[1] 25966 if v_0_1.Op != OpConst64 { 25967 break 25968 } 25969 if v_0_1.AuxInt != 56 { 25970 break 25971 } 25972 v_1 := v.Args[1] 25973 if v_1.Op != OpConst64 { 25974 break 25975 } 25976 if v_1.AuxInt != 56 { 25977 break 25978 } 25979 v.reset(OpZeroExt8to64) 25980 v0 := b.NewValue0(v.Pos, OpTrunc64to8, typ.UInt8) 25981 v0.AddArg(x) 25982 v.AddArg(v0) 25983 return true 25984 } 25985 // match: (Rsh64Ux64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) 25986 // cond: 25987 // result: (ZeroExt16to64 (Trunc64to16 <typ.UInt16> x)) 25988 for { 25989 _ = v.Args[1] 25990 v_0 := v.Args[0] 25991 if v_0.Op != OpLsh64x64 { 25992 break 25993 } 25994 _ = v_0.Args[1] 25995 x := v_0.Args[0] 25996 v_0_1 := v_0.Args[1] 25997 if v_0_1.Op != OpConst64 { 25998 break 25999 } 26000 if v_0_1.AuxInt != 48 { 26001 break 26002 } 26003 v_1 := v.Args[1] 26004 if v_1.Op != OpConst64 { 26005 break 26006 } 26007 if v_1.AuxInt != 48 { 26008 break 26009 } 26010 v.reset(OpZeroExt16to64) 26011 v0 := b.NewValue0(v.Pos, OpTrunc64to16, typ.UInt16) 26012 v0.AddArg(x) 26013 v.AddArg(v0) 26014 return true 26015 } 26016 // match: (Rsh64Ux64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) 26017 // cond: 26018 // result: (ZeroExt32to64 (Trunc64to32 <typ.UInt32> x)) 26019 for { 26020 _ = v.Args[1] 26021 v_0 := v.Args[0] 26022 if v_0.Op != OpLsh64x64 { 26023 break 26024 } 26025 _ = v_0.Args[1] 26026 x := v_0.Args[0] 26027 v_0_1 := v_0.Args[1] 26028 if v_0_1.Op != OpConst64 { 26029 break 26030 } 26031 if v_0_1.AuxInt != 32 { 26032 break 26033 } 26034 v_1 := v.Args[1] 26035 if v_1.Op != OpConst64 { 26036 break 26037 } 26038 if v_1.AuxInt != 32 { 26039 break 26040 } 26041 v.reset(OpZeroExt32to64) 26042 v0 := b.NewValue0(v.Pos, OpTrunc64to32, typ.UInt32) 26043 v0.AddArg(x) 26044 v.AddArg(v0) 26045 return true 26046 } 26047 return false 26048 } 26049 func rewriteValuegeneric_OpRsh64Ux8_0(v *Value) bool { 26050 b := v.Block 26051 _ = b 26052 // match: (Rsh64Ux8 <t> x (Const8 [c])) 26053 // cond: 26054 // result: (Rsh64Ux64 x (Const64 <t> [int64(uint8(c))])) 26055 for { 26056 t := v.Type 26057 _ = v.Args[1] 26058 x := v.Args[0] 26059 v_1 := v.Args[1] 26060 if v_1.Op != OpConst8 { 26061 break 26062 } 26063 c := v_1.AuxInt 26064 v.reset(OpRsh64Ux64) 26065 v.AddArg(x) 26066 v0 := b.NewValue0(v.Pos, OpConst64, t) 26067 v0.AuxInt = int64(uint8(c)) 26068 v.AddArg(v0) 26069 return true 26070 } 26071 // match: (Rsh64Ux8 (Const64 [0]) _) 26072 // cond: 26073 // result: (Const64 [0]) 26074 for { 26075 _ = v.Args[1] 26076 v_0 := v.Args[0] 26077 if v_0.Op != OpConst64 { 26078 break 26079 } 26080 if v_0.AuxInt != 0 { 26081 break 26082 } 26083 v.reset(OpConst64) 26084 v.AuxInt = 0 26085 return true 26086 } 26087 return false 26088 } 26089 func rewriteValuegeneric_OpRsh64x16_0(v *Value) bool { 26090 b := v.Block 26091 _ = b 26092 // match: (Rsh64x16 <t> x (Const16 [c])) 26093 // cond: 26094 // result: (Rsh64x64 x (Const64 <t> [int64(uint16(c))])) 26095 for { 26096 t := v.Type 26097 _ = v.Args[1] 26098 x := v.Args[0] 26099 v_1 := v.Args[1] 26100 if v_1.Op != OpConst16 { 26101 break 26102 } 26103 c := v_1.AuxInt 26104 v.reset(OpRsh64x64) 26105 v.AddArg(x) 26106 v0 := b.NewValue0(v.Pos, OpConst64, t) 26107 v0.AuxInt = int64(uint16(c)) 26108 v.AddArg(v0) 26109 return true 26110 } 26111 // match: (Rsh64x16 (Const64 [0]) _) 26112 // cond: 26113 // result: (Const64 [0]) 26114 for { 26115 _ = v.Args[1] 26116 v_0 := v.Args[0] 26117 if v_0.Op != OpConst64 { 26118 break 26119 } 26120 if v_0.AuxInt != 0 { 26121 break 26122 } 26123 v.reset(OpConst64) 26124 v.AuxInt = 0 26125 return true 26126 } 26127 return false 26128 } 26129 func rewriteValuegeneric_OpRsh64x32_0(v *Value) bool { 26130 b := v.Block 26131 _ = b 26132 // match: (Rsh64x32 <t> x (Const32 [c])) 26133 // cond: 26134 // result: (Rsh64x64 x (Const64 <t> [int64(uint32(c))])) 26135 for { 26136 t := v.Type 26137 _ = v.Args[1] 26138 x := v.Args[0] 26139 v_1 := v.Args[1] 26140 if v_1.Op != OpConst32 { 26141 break 26142 } 26143 c := v_1.AuxInt 26144 v.reset(OpRsh64x64) 26145 v.AddArg(x) 26146 v0 := b.NewValue0(v.Pos, OpConst64, t) 26147 v0.AuxInt = int64(uint32(c)) 26148 v.AddArg(v0) 26149 return true 26150 } 26151 // match: (Rsh64x32 (Const64 [0]) _) 26152 // cond: 26153 // result: (Const64 [0]) 26154 for { 26155 _ = v.Args[1] 26156 v_0 := v.Args[0] 26157 if v_0.Op != OpConst64 { 26158 break 26159 } 26160 if v_0.AuxInt != 0 { 26161 break 26162 } 26163 v.reset(OpConst64) 26164 v.AuxInt = 0 26165 return true 26166 } 26167 return false 26168 } 26169 func rewriteValuegeneric_OpRsh64x64_0(v *Value) bool { 26170 b := v.Block 26171 _ = b 26172 typ := &b.Func.Config.Types 26173 _ = typ 26174 // match: (Rsh64x64 (Const64 [c]) (Const64 [d])) 26175 // cond: 26176 // result: (Const64 [c >> uint64(d)]) 26177 for { 26178 _ = v.Args[1] 26179 v_0 := v.Args[0] 26180 if v_0.Op != OpConst64 { 26181 break 26182 } 26183 c := v_0.AuxInt 26184 v_1 := v.Args[1] 26185 if v_1.Op != OpConst64 { 26186 break 26187 } 26188 d := v_1.AuxInt 26189 v.reset(OpConst64) 26190 v.AuxInt = c >> uint64(d) 26191 return true 26192 } 26193 // match: (Rsh64x64 x (Const64 [0])) 26194 // cond: 26195 // result: x 26196 for { 26197 _ = v.Args[1] 26198 x := v.Args[0] 26199 v_1 := v.Args[1] 26200 if v_1.Op != OpConst64 { 26201 break 26202 } 26203 if v_1.AuxInt != 0 { 26204 break 26205 } 26206 v.reset(OpCopy) 26207 v.Type = x.Type 26208 v.AddArg(x) 26209 return true 26210 } 26211 // match: (Rsh64x64 (Const64 [0]) _) 26212 // cond: 26213 // result: (Const64 [0]) 26214 for { 26215 _ = v.Args[1] 26216 v_0 := v.Args[0] 26217 if v_0.Op != OpConst64 { 26218 break 26219 } 26220 if v_0.AuxInt != 0 { 26221 break 26222 } 26223 v.reset(OpConst64) 26224 v.AuxInt = 0 26225 return true 26226 } 26227 // match: (Rsh64x64 <t> (Rsh64x64 x (Const64 [c])) (Const64 [d])) 26228 // cond: !uaddOvf(c,d) 26229 // result: (Rsh64x64 x (Const64 <t> [c+d])) 26230 for { 26231 t := v.Type 26232 _ = v.Args[1] 26233 v_0 := v.Args[0] 26234 if v_0.Op != OpRsh64x64 { 26235 break 26236 } 26237 _ = v_0.Args[1] 26238 x := v_0.Args[0] 26239 v_0_1 := v_0.Args[1] 26240 if v_0_1.Op != OpConst64 { 26241 break 26242 } 26243 c := v_0_1.AuxInt 26244 v_1 := v.Args[1] 26245 if v_1.Op != OpConst64 { 26246 break 26247 } 26248 d := v_1.AuxInt 26249 if !(!uaddOvf(c, d)) { 26250 break 26251 } 26252 v.reset(OpRsh64x64) 26253 v.AddArg(x) 26254 v0 := b.NewValue0(v.Pos, OpConst64, t) 26255 v0.AuxInt = c + d 26256 v.AddArg(v0) 26257 return true 26258 } 26259 // match: (Rsh64x64 (Lsh64x64 x (Const64 [56])) (Const64 [56])) 26260 // cond: 26261 // result: (SignExt8to64 (Trunc64to8 <typ.Int8> x)) 26262 for { 26263 _ = v.Args[1] 26264 v_0 := v.Args[0] 26265 if v_0.Op != OpLsh64x64 { 26266 break 26267 } 26268 _ = v_0.Args[1] 26269 x := v_0.Args[0] 26270 v_0_1 := v_0.Args[1] 26271 if v_0_1.Op != OpConst64 { 26272 break 26273 } 26274 if v_0_1.AuxInt != 56 { 26275 break 26276 } 26277 v_1 := v.Args[1] 26278 if v_1.Op != OpConst64 { 26279 break 26280 } 26281 if v_1.AuxInt != 56 { 26282 break 26283 } 26284 v.reset(OpSignExt8to64) 26285 v0 := b.NewValue0(v.Pos, OpTrunc64to8, typ.Int8) 26286 v0.AddArg(x) 26287 v.AddArg(v0) 26288 return true 26289 } 26290 // match: (Rsh64x64 (Lsh64x64 x (Const64 [48])) (Const64 [48])) 26291 // cond: 26292 // result: (SignExt16to64 (Trunc64to16 <typ.Int16> x)) 26293 for { 26294 _ = v.Args[1] 26295 v_0 := v.Args[0] 26296 if v_0.Op != OpLsh64x64 { 26297 break 26298 } 26299 _ = v_0.Args[1] 26300 x := v_0.Args[0] 26301 v_0_1 := v_0.Args[1] 26302 if v_0_1.Op != OpConst64 { 26303 break 26304 } 26305 if v_0_1.AuxInt != 48 { 26306 break 26307 } 26308 v_1 := v.Args[1] 26309 if v_1.Op != OpConst64 { 26310 break 26311 } 26312 if v_1.AuxInt != 48 { 26313 break 26314 } 26315 v.reset(OpSignExt16to64) 26316 v0 := b.NewValue0(v.Pos, OpTrunc64to16, typ.Int16) 26317 v0.AddArg(x) 26318 v.AddArg(v0) 26319 return true 26320 } 26321 // match: (Rsh64x64 (Lsh64x64 x (Const64 [32])) (Const64 [32])) 26322 // cond: 26323 // result: (SignExt32to64 (Trunc64to32 <typ.Int32> x)) 26324 for { 26325 _ = v.Args[1] 26326 v_0 := v.Args[0] 26327 if v_0.Op != OpLsh64x64 { 26328 break 26329 } 26330 _ = v_0.Args[1] 26331 x := v_0.Args[0] 26332 v_0_1 := v_0.Args[1] 26333 if v_0_1.Op != OpConst64 { 26334 break 26335 } 26336 if v_0_1.AuxInt != 32 { 26337 break 26338 } 26339 v_1 := v.Args[1] 26340 if v_1.Op != OpConst64 { 26341 break 26342 } 26343 if v_1.AuxInt != 32 { 26344 break 26345 } 26346 v.reset(OpSignExt32to64) 26347 v0 := b.NewValue0(v.Pos, OpTrunc64to32, typ.Int32) 26348 v0.AddArg(x) 26349 v.AddArg(v0) 26350 return true 26351 } 26352 return false 26353 } 26354 func rewriteValuegeneric_OpRsh64x8_0(v *Value) bool { 26355 b := v.Block 26356 _ = b 26357 // match: (Rsh64x8 <t> x (Const8 [c])) 26358 // cond: 26359 // result: (Rsh64x64 x (Const64 <t> [int64(uint8(c))])) 26360 for { 26361 t := v.Type 26362 _ = v.Args[1] 26363 x := v.Args[0] 26364 v_1 := v.Args[1] 26365 if v_1.Op != OpConst8 { 26366 break 26367 } 26368 c := v_1.AuxInt 26369 v.reset(OpRsh64x64) 26370 v.AddArg(x) 26371 v0 := b.NewValue0(v.Pos, OpConst64, t) 26372 v0.AuxInt = int64(uint8(c)) 26373 v.AddArg(v0) 26374 return true 26375 } 26376 // match: (Rsh64x8 (Const64 [0]) _) 26377 // cond: 26378 // result: (Const64 [0]) 26379 for { 26380 _ = v.Args[1] 26381 v_0 := v.Args[0] 26382 if v_0.Op != OpConst64 { 26383 break 26384 } 26385 if v_0.AuxInt != 0 { 26386 break 26387 } 26388 v.reset(OpConst64) 26389 v.AuxInt = 0 26390 return true 26391 } 26392 return false 26393 } 26394 func rewriteValuegeneric_OpRsh8Ux16_0(v *Value) bool { 26395 b := v.Block 26396 _ = b 26397 // match: (Rsh8Ux16 <t> x (Const16 [c])) 26398 // cond: 26399 // result: (Rsh8Ux64 x (Const64 <t> [int64(uint16(c))])) 26400 for { 26401 t := v.Type 26402 _ = v.Args[1] 26403 x := v.Args[0] 26404 v_1 := v.Args[1] 26405 if v_1.Op != OpConst16 { 26406 break 26407 } 26408 c := v_1.AuxInt 26409 v.reset(OpRsh8Ux64) 26410 v.AddArg(x) 26411 v0 := b.NewValue0(v.Pos, OpConst64, t) 26412 v0.AuxInt = int64(uint16(c)) 26413 v.AddArg(v0) 26414 return true 26415 } 26416 // match: (Rsh8Ux16 (Const8 [0]) _) 26417 // cond: 26418 // result: (Const8 [0]) 26419 for { 26420 _ = v.Args[1] 26421 v_0 := v.Args[0] 26422 if v_0.Op != OpConst8 { 26423 break 26424 } 26425 if v_0.AuxInt != 0 { 26426 break 26427 } 26428 v.reset(OpConst8) 26429 v.AuxInt = 0 26430 return true 26431 } 26432 return false 26433 } 26434 func rewriteValuegeneric_OpRsh8Ux32_0(v *Value) bool { 26435 b := v.Block 26436 _ = b 26437 // match: (Rsh8Ux32 <t> x (Const32 [c])) 26438 // cond: 26439 // result: (Rsh8Ux64 x (Const64 <t> [int64(uint32(c))])) 26440 for { 26441 t := v.Type 26442 _ = v.Args[1] 26443 x := v.Args[0] 26444 v_1 := v.Args[1] 26445 if v_1.Op != OpConst32 { 26446 break 26447 } 26448 c := v_1.AuxInt 26449 v.reset(OpRsh8Ux64) 26450 v.AddArg(x) 26451 v0 := b.NewValue0(v.Pos, OpConst64, t) 26452 v0.AuxInt = int64(uint32(c)) 26453 v.AddArg(v0) 26454 return true 26455 } 26456 // match: (Rsh8Ux32 (Const8 [0]) _) 26457 // cond: 26458 // result: (Const8 [0]) 26459 for { 26460 _ = v.Args[1] 26461 v_0 := v.Args[0] 26462 if v_0.Op != OpConst8 { 26463 break 26464 } 26465 if v_0.AuxInt != 0 { 26466 break 26467 } 26468 v.reset(OpConst8) 26469 v.AuxInt = 0 26470 return true 26471 } 26472 return false 26473 } 26474 func rewriteValuegeneric_OpRsh8Ux64_0(v *Value) bool { 26475 b := v.Block 26476 _ = b 26477 typ := &b.Func.Config.Types 26478 _ = typ 26479 // match: (Rsh8Ux64 (Const8 [c]) (Const64 [d])) 26480 // cond: 26481 // result: (Const8 [int64(int8(uint8(c) >> uint64(d)))]) 26482 for { 26483 _ = v.Args[1] 26484 v_0 := v.Args[0] 26485 if v_0.Op != OpConst8 { 26486 break 26487 } 26488 c := v_0.AuxInt 26489 v_1 := v.Args[1] 26490 if v_1.Op != OpConst64 { 26491 break 26492 } 26493 d := v_1.AuxInt 26494 v.reset(OpConst8) 26495 v.AuxInt = int64(int8(uint8(c) >> uint64(d))) 26496 return true 26497 } 26498 // match: (Rsh8Ux64 x (Const64 [0])) 26499 // cond: 26500 // result: x 26501 for { 26502 _ = v.Args[1] 26503 x := v.Args[0] 26504 v_1 := v.Args[1] 26505 if v_1.Op != OpConst64 { 26506 break 26507 } 26508 if v_1.AuxInt != 0 { 26509 break 26510 } 26511 v.reset(OpCopy) 26512 v.Type = x.Type 26513 v.AddArg(x) 26514 return true 26515 } 26516 // match: (Rsh8Ux64 (Const8 [0]) _) 26517 // cond: 26518 // result: (Const8 [0]) 26519 for { 26520 _ = v.Args[1] 26521 v_0 := v.Args[0] 26522 if v_0.Op != OpConst8 { 26523 break 26524 } 26525 if v_0.AuxInt != 0 { 26526 break 26527 } 26528 v.reset(OpConst8) 26529 v.AuxInt = 0 26530 return true 26531 } 26532 // match: (Rsh8Ux64 _ (Const64 [c])) 26533 // cond: uint64(c) >= 8 26534 // result: (Const8 [0]) 26535 for { 26536 _ = v.Args[1] 26537 v_1 := v.Args[1] 26538 if v_1.Op != OpConst64 { 26539 break 26540 } 26541 c := v_1.AuxInt 26542 if !(uint64(c) >= 8) { 26543 break 26544 } 26545 v.reset(OpConst8) 26546 v.AuxInt = 0 26547 return true 26548 } 26549 // match: (Rsh8Ux64 <t> (Rsh8Ux64 x (Const64 [c])) (Const64 [d])) 26550 // cond: !uaddOvf(c,d) 26551 // result: (Rsh8Ux64 x (Const64 <t> [c+d])) 26552 for { 26553 t := v.Type 26554 _ = v.Args[1] 26555 v_0 := v.Args[0] 26556 if v_0.Op != OpRsh8Ux64 { 26557 break 26558 } 26559 _ = v_0.Args[1] 26560 x := v_0.Args[0] 26561 v_0_1 := v_0.Args[1] 26562 if v_0_1.Op != OpConst64 { 26563 break 26564 } 26565 c := v_0_1.AuxInt 26566 v_1 := v.Args[1] 26567 if v_1.Op != OpConst64 { 26568 break 26569 } 26570 d := v_1.AuxInt 26571 if !(!uaddOvf(c, d)) { 26572 break 26573 } 26574 v.reset(OpRsh8Ux64) 26575 v.AddArg(x) 26576 v0 := b.NewValue0(v.Pos, OpConst64, t) 26577 v0.AuxInt = c + d 26578 v.AddArg(v0) 26579 return true 26580 } 26581 // match: (Rsh8Ux64 (Rsh8x64 x _) (Const64 <t> [7])) 26582 // cond: 26583 // result: (Rsh8Ux64 x (Const64 <t> [7] )) 26584 for { 26585 _ = v.Args[1] 26586 v_0 := v.Args[0] 26587 if v_0.Op != OpRsh8x64 { 26588 break 26589 } 26590 _ = v_0.Args[1] 26591 x := v_0.Args[0] 26592 v_1 := v.Args[1] 26593 if v_1.Op != OpConst64 { 26594 break 26595 } 26596 t := v_1.Type 26597 if v_1.AuxInt != 7 { 26598 break 26599 } 26600 v.reset(OpRsh8Ux64) 26601 v.AddArg(x) 26602 v0 := b.NewValue0(v.Pos, OpConst64, t) 26603 v0.AuxInt = 7 26604 v.AddArg(v0) 26605 return true 26606 } 26607 // match: (Rsh8Ux64 (Lsh8x64 (Rsh8Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3])) 26608 // cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3) 26609 // result: (Rsh8Ux64 x (Const64 <typ.UInt64> [c1-c2+c3])) 26610 for { 26611 _ = v.Args[1] 26612 v_0 := v.Args[0] 26613 if v_0.Op != OpLsh8x64 { 26614 break 26615 } 26616 _ = v_0.Args[1] 26617 v_0_0 := v_0.Args[0] 26618 if v_0_0.Op != OpRsh8Ux64 { 26619 break 26620 } 26621 _ = v_0_0.Args[1] 26622 x := v_0_0.Args[0] 26623 v_0_0_1 := v_0_0.Args[1] 26624 if v_0_0_1.Op != OpConst64 { 26625 break 26626 } 26627 c1 := v_0_0_1.AuxInt 26628 v_0_1 := v_0.Args[1] 26629 if v_0_1.Op != OpConst64 { 26630 break 26631 } 26632 c2 := v_0_1.AuxInt 26633 v_1 := v.Args[1] 26634 if v_1.Op != OpConst64 { 26635 break 26636 } 26637 c3 := v_1.AuxInt 26638 if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) { 26639 break 26640 } 26641 v.reset(OpRsh8Ux64) 26642 v.AddArg(x) 26643 v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64) 26644 v0.AuxInt = c1 - c2 + c3 26645 v.AddArg(v0) 26646 return true 26647 } 26648 return false 26649 } 26650 func rewriteValuegeneric_OpRsh8Ux8_0(v *Value) bool { 26651 b := v.Block 26652 _ = b 26653 // match: (Rsh8Ux8 <t> x (Const8 [c])) 26654 // cond: 26655 // result: (Rsh8Ux64 x (Const64 <t> [int64(uint8(c))])) 26656 for { 26657 t := v.Type 26658 _ = v.Args[1] 26659 x := v.Args[0] 26660 v_1 := v.Args[1] 26661 if v_1.Op != OpConst8 { 26662 break 26663 } 26664 c := v_1.AuxInt 26665 v.reset(OpRsh8Ux64) 26666 v.AddArg(x) 26667 v0 := b.NewValue0(v.Pos, OpConst64, t) 26668 v0.AuxInt = int64(uint8(c)) 26669 v.AddArg(v0) 26670 return true 26671 } 26672 // match: (Rsh8Ux8 (Const8 [0]) _) 26673 // cond: 26674 // result: (Const8 [0]) 26675 for { 26676 _ = v.Args[1] 26677 v_0 := v.Args[0] 26678 if v_0.Op != OpConst8 { 26679 break 26680 } 26681 if v_0.AuxInt != 0 { 26682 break 26683 } 26684 v.reset(OpConst8) 26685 v.AuxInt = 0 26686 return true 26687 } 26688 return false 26689 } 26690 func rewriteValuegeneric_OpRsh8x16_0(v *Value) bool { 26691 b := v.Block 26692 _ = b 26693 // match: (Rsh8x16 <t> x (Const16 [c])) 26694 // cond: 26695 // result: (Rsh8x64 x (Const64 <t> [int64(uint16(c))])) 26696 for { 26697 t := v.Type 26698 _ = v.Args[1] 26699 x := v.Args[0] 26700 v_1 := v.Args[1] 26701 if v_1.Op != OpConst16 { 26702 break 26703 } 26704 c := v_1.AuxInt 26705 v.reset(OpRsh8x64) 26706 v.AddArg(x) 26707 v0 := b.NewValue0(v.Pos, OpConst64, t) 26708 v0.AuxInt = int64(uint16(c)) 26709 v.AddArg(v0) 26710 return true 26711 } 26712 // match: (Rsh8x16 (Const8 [0]) _) 26713 // cond: 26714 // result: (Const8 [0]) 26715 for { 26716 _ = v.Args[1] 26717 v_0 := v.Args[0] 26718 if v_0.Op != OpConst8 { 26719 break 26720 } 26721 if v_0.AuxInt != 0 { 26722 break 26723 } 26724 v.reset(OpConst8) 26725 v.AuxInt = 0 26726 return true 26727 } 26728 return false 26729 } 26730 func rewriteValuegeneric_OpRsh8x32_0(v *Value) bool { 26731 b := v.Block 26732 _ = b 26733 // match: (Rsh8x32 <t> x (Const32 [c])) 26734 // cond: 26735 // result: (Rsh8x64 x (Const64 <t> [int64(uint32(c))])) 26736 for { 26737 t := v.Type 26738 _ = v.Args[1] 26739 x := v.Args[0] 26740 v_1 := v.Args[1] 26741 if v_1.Op != OpConst32 { 26742 break 26743 } 26744 c := v_1.AuxInt 26745 v.reset(OpRsh8x64) 26746 v.AddArg(x) 26747 v0 := b.NewValue0(v.Pos, OpConst64, t) 26748 v0.AuxInt = int64(uint32(c)) 26749 v.AddArg(v0) 26750 return true 26751 } 26752 // match: (Rsh8x32 (Const8 [0]) _) 26753 // cond: 26754 // result: (Const8 [0]) 26755 for { 26756 _ = v.Args[1] 26757 v_0 := v.Args[0] 26758 if v_0.Op != OpConst8 { 26759 break 26760 } 26761 if v_0.AuxInt != 0 { 26762 break 26763 } 26764 v.reset(OpConst8) 26765 v.AuxInt = 0 26766 return true 26767 } 26768 return false 26769 } 26770 func rewriteValuegeneric_OpRsh8x64_0(v *Value) bool { 26771 b := v.Block 26772 _ = b 26773 // match: (Rsh8x64 (Const8 [c]) (Const64 [d])) 26774 // cond: 26775 // result: (Const8 [int64(int8(c) >> uint64(d))]) 26776 for { 26777 _ = v.Args[1] 26778 v_0 := v.Args[0] 26779 if v_0.Op != OpConst8 { 26780 break 26781 } 26782 c := v_0.AuxInt 26783 v_1 := v.Args[1] 26784 if v_1.Op != OpConst64 { 26785 break 26786 } 26787 d := v_1.AuxInt 26788 v.reset(OpConst8) 26789 v.AuxInt = int64(int8(c) >> uint64(d)) 26790 return true 26791 } 26792 // match: (Rsh8x64 x (Const64 [0])) 26793 // cond: 26794 // result: x 26795 for { 26796 _ = v.Args[1] 26797 x := v.Args[0] 26798 v_1 := v.Args[1] 26799 if v_1.Op != OpConst64 { 26800 break 26801 } 26802 if v_1.AuxInt != 0 { 26803 break 26804 } 26805 v.reset(OpCopy) 26806 v.Type = x.Type 26807 v.AddArg(x) 26808 return true 26809 } 26810 // match: (Rsh8x64 (Const8 [0]) _) 26811 // cond: 26812 // result: (Const8 [0]) 26813 for { 26814 _ = v.Args[1] 26815 v_0 := v.Args[0] 26816 if v_0.Op != OpConst8 { 26817 break 26818 } 26819 if v_0.AuxInt != 0 { 26820 break 26821 } 26822 v.reset(OpConst8) 26823 v.AuxInt = 0 26824 return true 26825 } 26826 // match: (Rsh8x64 <t> (Rsh8x64 x (Const64 [c])) (Const64 [d])) 26827 // cond: !uaddOvf(c,d) 26828 // result: (Rsh8x64 x (Const64 <t> [c+d])) 26829 for { 26830 t := v.Type 26831 _ = v.Args[1] 26832 v_0 := v.Args[0] 26833 if v_0.Op != OpRsh8x64 { 26834 break 26835 } 26836 _ = v_0.Args[1] 26837 x := v_0.Args[0] 26838 v_0_1 := v_0.Args[1] 26839 if v_0_1.Op != OpConst64 { 26840 break 26841 } 26842 c := v_0_1.AuxInt 26843 v_1 := v.Args[1] 26844 if v_1.Op != OpConst64 { 26845 break 26846 } 26847 d := v_1.AuxInt 26848 if !(!uaddOvf(c, d)) { 26849 break 26850 } 26851 v.reset(OpRsh8x64) 26852 v.AddArg(x) 26853 v0 := b.NewValue0(v.Pos, OpConst64, t) 26854 v0.AuxInt = c + d 26855 v.AddArg(v0) 26856 return true 26857 } 26858 return false 26859 } 26860 func rewriteValuegeneric_OpRsh8x8_0(v *Value) bool { 26861 b := v.Block 26862 _ = b 26863 // match: (Rsh8x8 <t> x (Const8 [c])) 26864 // cond: 26865 // result: (Rsh8x64 x (Const64 <t> [int64(uint8(c))])) 26866 for { 26867 t := v.Type 26868 _ = v.Args[1] 26869 x := v.Args[0] 26870 v_1 := v.Args[1] 26871 if v_1.Op != OpConst8 { 26872 break 26873 } 26874 c := v_1.AuxInt 26875 v.reset(OpRsh8x64) 26876 v.AddArg(x) 26877 v0 := b.NewValue0(v.Pos, OpConst64, t) 26878 v0.AuxInt = int64(uint8(c)) 26879 v.AddArg(v0) 26880 return true 26881 } 26882 // match: (Rsh8x8 (Const8 [0]) _) 26883 // cond: 26884 // result: (Const8 [0]) 26885 for { 26886 _ = v.Args[1] 26887 v_0 := v.Args[0] 26888 if v_0.Op != OpConst8 { 26889 break 26890 } 26891 if v_0.AuxInt != 0 { 26892 break 26893 } 26894 v.reset(OpConst8) 26895 v.AuxInt = 0 26896 return true 26897 } 26898 return false 26899 } 26900 func rewriteValuegeneric_OpSignExt16to32_0(v *Value) bool { 26901 // match: (SignExt16to32 (Const16 [c])) 26902 // cond: 26903 // result: (Const32 [int64( int16(c))]) 26904 for { 26905 v_0 := v.Args[0] 26906 if v_0.Op != OpConst16 { 26907 break 26908 } 26909 c := v_0.AuxInt 26910 v.reset(OpConst32) 26911 v.AuxInt = int64(int16(c)) 26912 return true 26913 } 26914 // match: (SignExt16to32 (Trunc32to16 x:(Rsh32x64 _ (Const64 [s])))) 26915 // cond: s >= 16 26916 // result: x 26917 for { 26918 v_0 := v.Args[0] 26919 if v_0.Op != OpTrunc32to16 { 26920 break 26921 } 26922 x := v_0.Args[0] 26923 if x.Op != OpRsh32x64 { 26924 break 26925 } 26926 _ = x.Args[1] 26927 x_1 := x.Args[1] 26928 if x_1.Op != OpConst64 { 26929 break 26930 } 26931 s := x_1.AuxInt 26932 if !(s >= 16) { 26933 break 26934 } 26935 v.reset(OpCopy) 26936 v.Type = x.Type 26937 v.AddArg(x) 26938 return true 26939 } 26940 return false 26941 } 26942 func rewriteValuegeneric_OpSignExt16to64_0(v *Value) bool { 26943 // match: (SignExt16to64 (Const16 [c])) 26944 // cond: 26945 // result: (Const64 [int64( int16(c))]) 26946 for { 26947 v_0 := v.Args[0] 26948 if v_0.Op != OpConst16 { 26949 break 26950 } 26951 c := v_0.AuxInt 26952 v.reset(OpConst64) 26953 v.AuxInt = int64(int16(c)) 26954 return true 26955 } 26956 // match: (SignExt16to64 (Trunc64to16 x:(Rsh64x64 _ (Const64 [s])))) 26957 // cond: s >= 48 26958 // result: x 26959 for { 26960 v_0 := v.Args[0] 26961 if v_0.Op != OpTrunc64to16 { 26962 break 26963 } 26964 x := v_0.Args[0] 26965 if x.Op != OpRsh64x64 { 26966 break 26967 } 26968 _ = x.Args[1] 26969 x_1 := x.Args[1] 26970 if x_1.Op != OpConst64 { 26971 break 26972 } 26973 s := x_1.AuxInt 26974 if !(s >= 48) { 26975 break 26976 } 26977 v.reset(OpCopy) 26978 v.Type = x.Type 26979 v.AddArg(x) 26980 return true 26981 } 26982 return false 26983 } 26984 func rewriteValuegeneric_OpSignExt32to64_0(v *Value) bool { 26985 // match: (SignExt32to64 (Const32 [c])) 26986 // cond: 26987 // result: (Const64 [int64( int32(c))]) 26988 for { 26989 v_0 := v.Args[0] 26990 if v_0.Op != OpConst32 { 26991 break 26992 } 26993 c := v_0.AuxInt 26994 v.reset(OpConst64) 26995 v.AuxInt = int64(int32(c)) 26996 return true 26997 } 26998 // match: (SignExt32to64 (Trunc64to32 x:(Rsh64x64 _ (Const64 [s])))) 26999 // cond: s >= 32 27000 // result: x 27001 for { 27002 v_0 := v.Args[0] 27003 if v_0.Op != OpTrunc64to32 { 27004 break 27005 } 27006 x := v_0.Args[0] 27007 if x.Op != OpRsh64x64 { 27008 break 27009 } 27010 _ = x.Args[1] 27011 x_1 := x.Args[1] 27012 if x_1.Op != OpConst64 { 27013 break 27014 } 27015 s := x_1.AuxInt 27016 if !(s >= 32) { 27017 break 27018 } 27019 v.reset(OpCopy) 27020 v.Type = x.Type 27021 v.AddArg(x) 27022 return true 27023 } 27024 return false 27025 } 27026 func rewriteValuegeneric_OpSignExt8to16_0(v *Value) bool { 27027 // match: (SignExt8to16 (Const8 [c])) 27028 // cond: 27029 // result: (Const16 [int64( int8(c))]) 27030 for { 27031 v_0 := v.Args[0] 27032 if v_0.Op != OpConst8 { 27033 break 27034 } 27035 c := v_0.AuxInt 27036 v.reset(OpConst16) 27037 v.AuxInt = int64(int8(c)) 27038 return true 27039 } 27040 // match: (SignExt8to16 (Trunc16to8 x:(Rsh16x64 _ (Const64 [s])))) 27041 // cond: s >= 8 27042 // result: x 27043 for { 27044 v_0 := v.Args[0] 27045 if v_0.Op != OpTrunc16to8 { 27046 break 27047 } 27048 x := v_0.Args[0] 27049 if x.Op != OpRsh16x64 { 27050 break 27051 } 27052 _ = x.Args[1] 27053 x_1 := x.Args[1] 27054 if x_1.Op != OpConst64 { 27055 break 27056 } 27057 s := x_1.AuxInt 27058 if !(s >= 8) { 27059 break 27060 } 27061 v.reset(OpCopy) 27062 v.Type = x.Type 27063 v.AddArg(x) 27064 return true 27065 } 27066 return false 27067 } 27068 func rewriteValuegeneric_OpSignExt8to32_0(v *Value) bool { 27069 // match: (SignExt8to32 (Const8 [c])) 27070 // cond: 27071 // result: (Const32 [int64( int8(c))]) 27072 for { 27073 v_0 := v.Args[0] 27074 if v_0.Op != OpConst8 { 27075 break 27076 } 27077 c := v_0.AuxInt 27078 v.reset(OpConst32) 27079 v.AuxInt = int64(int8(c)) 27080 return true 27081 } 27082 // match: (SignExt8to32 (Trunc32to8 x:(Rsh32x64 _ (Const64 [s])))) 27083 // cond: s >= 24 27084 // result: x 27085 for { 27086 v_0 := v.Args[0] 27087 if v_0.Op != OpTrunc32to8 { 27088 break 27089 } 27090 x := v_0.Args[0] 27091 if x.Op != OpRsh32x64 { 27092 break 27093 } 27094 _ = x.Args[1] 27095 x_1 := x.Args[1] 27096 if x_1.Op != OpConst64 { 27097 break 27098 } 27099 s := x_1.AuxInt 27100 if !(s >= 24) { 27101 break 27102 } 27103 v.reset(OpCopy) 27104 v.Type = x.Type 27105 v.AddArg(x) 27106 return true 27107 } 27108 return false 27109 } 27110 func rewriteValuegeneric_OpSignExt8to64_0(v *Value) bool { 27111 // match: (SignExt8to64 (Const8 [c])) 27112 // cond: 27113 // result: (Const64 [int64( int8(c))]) 27114 for { 27115 v_0 := v.Args[0] 27116 if v_0.Op != OpConst8 { 27117 break 27118 } 27119 c := v_0.AuxInt 27120 v.reset(OpConst64) 27121 v.AuxInt = int64(int8(c)) 27122 return true 27123 } 27124 // match: (SignExt8to64 (Trunc64to8 x:(Rsh64x64 _ (Const64 [s])))) 27125 // cond: s >= 56 27126 // result: x 27127 for { 27128 v_0 := v.Args[0] 27129 if v_0.Op != OpTrunc64to8 { 27130 break 27131 } 27132 x := v_0.Args[0] 27133 if x.Op != OpRsh64x64 { 27134 break 27135 } 27136 _ = x.Args[1] 27137 x_1 := x.Args[1] 27138 if x_1.Op != OpConst64 { 27139 break 27140 } 27141 s := x_1.AuxInt 27142 if !(s >= 56) { 27143 break 27144 } 27145 v.reset(OpCopy) 27146 v.Type = x.Type 27147 v.AddArg(x) 27148 return true 27149 } 27150 return false 27151 } 27152 func rewriteValuegeneric_OpSliceCap_0(v *Value) bool { 27153 // match: (SliceCap (SliceMake _ _ (Const64 <t> [c]))) 27154 // cond: 27155 // result: (Const64 <t> [c]) 27156 for { 27157 v_0 := v.Args[0] 27158 if v_0.Op != OpSliceMake { 27159 break 27160 } 27161 _ = v_0.Args[2] 27162 v_0_2 := v_0.Args[2] 27163 if v_0_2.Op != OpConst64 { 27164 break 27165 } 27166 t := v_0_2.Type 27167 c := v_0_2.AuxInt 27168 v.reset(OpConst64) 27169 v.Type = t 27170 v.AuxInt = c 27171 return true 27172 } 27173 // match: (SliceCap (SliceMake _ _ (Const32 <t> [c]))) 27174 // cond: 27175 // result: (Const32 <t> [c]) 27176 for { 27177 v_0 := v.Args[0] 27178 if v_0.Op != OpSliceMake { 27179 break 27180 } 27181 _ = v_0.Args[2] 27182 v_0_2 := v_0.Args[2] 27183 if v_0_2.Op != OpConst32 { 27184 break 27185 } 27186 t := v_0_2.Type 27187 c := v_0_2.AuxInt 27188 v.reset(OpConst32) 27189 v.Type = t 27190 v.AuxInt = c 27191 return true 27192 } 27193 // match: (SliceCap (SliceMake _ _ (SliceCap x))) 27194 // cond: 27195 // result: (SliceCap x) 27196 for { 27197 v_0 := v.Args[0] 27198 if v_0.Op != OpSliceMake { 27199 break 27200 } 27201 _ = v_0.Args[2] 27202 v_0_2 := v_0.Args[2] 27203 if v_0_2.Op != OpSliceCap { 27204 break 27205 } 27206 x := v_0_2.Args[0] 27207 v.reset(OpSliceCap) 27208 v.AddArg(x) 27209 return true 27210 } 27211 // match: (SliceCap (SliceMake _ _ (SliceLen x))) 27212 // cond: 27213 // result: (SliceLen x) 27214 for { 27215 v_0 := v.Args[0] 27216 if v_0.Op != OpSliceMake { 27217 break 27218 } 27219 _ = v_0.Args[2] 27220 v_0_2 := v_0.Args[2] 27221 if v_0_2.Op != OpSliceLen { 27222 break 27223 } 27224 x := v_0_2.Args[0] 27225 v.reset(OpSliceLen) 27226 v.AddArg(x) 27227 return true 27228 } 27229 return false 27230 } 27231 func rewriteValuegeneric_OpSliceLen_0(v *Value) bool { 27232 // match: (SliceLen (SliceMake _ (Const64 <t> [c]) _)) 27233 // cond: 27234 // result: (Const64 <t> [c]) 27235 for { 27236 v_0 := v.Args[0] 27237 if v_0.Op != OpSliceMake { 27238 break 27239 } 27240 _ = v_0.Args[2] 27241 v_0_1 := v_0.Args[1] 27242 if v_0_1.Op != OpConst64 { 27243 break 27244 } 27245 t := v_0_1.Type 27246 c := v_0_1.AuxInt 27247 v.reset(OpConst64) 27248 v.Type = t 27249 v.AuxInt = c 27250 return true 27251 } 27252 // match: (SliceLen (SliceMake _ (Const32 <t> [c]) _)) 27253 // cond: 27254 // result: (Const32 <t> [c]) 27255 for { 27256 v_0 := v.Args[0] 27257 if v_0.Op != OpSliceMake { 27258 break 27259 } 27260 _ = v_0.Args[2] 27261 v_0_1 := v_0.Args[1] 27262 if v_0_1.Op != OpConst32 { 27263 break 27264 } 27265 t := v_0_1.Type 27266 c := v_0_1.AuxInt 27267 v.reset(OpConst32) 27268 v.Type = t 27269 v.AuxInt = c 27270 return true 27271 } 27272 // match: (SliceLen (SliceMake _ (SliceLen x) _)) 27273 // cond: 27274 // result: (SliceLen x) 27275 for { 27276 v_0 := v.Args[0] 27277 if v_0.Op != OpSliceMake { 27278 break 27279 } 27280 _ = v_0.Args[2] 27281 v_0_1 := v_0.Args[1] 27282 if v_0_1.Op != OpSliceLen { 27283 break 27284 } 27285 x := v_0_1.Args[0] 27286 v.reset(OpSliceLen) 27287 v.AddArg(x) 27288 return true 27289 } 27290 return false 27291 } 27292 func rewriteValuegeneric_OpSlicePtr_0(v *Value) bool { 27293 // match: (SlicePtr (SliceMake (SlicePtr x) _ _)) 27294 // cond: 27295 // result: (SlicePtr x) 27296 for { 27297 v_0 := v.Args[0] 27298 if v_0.Op != OpSliceMake { 27299 break 27300 } 27301 _ = v_0.Args[2] 27302 v_0_0 := v_0.Args[0] 27303 if v_0_0.Op != OpSlicePtr { 27304 break 27305 } 27306 x := v_0_0.Args[0] 27307 v.reset(OpSlicePtr) 27308 v.AddArg(x) 27309 return true 27310 } 27311 return false 27312 } 27313 func rewriteValuegeneric_OpSlicemask_0(v *Value) bool { 27314 // match: (Slicemask (Const32 [x])) 27315 // cond: x > 0 27316 // result: (Const32 [-1]) 27317 for { 27318 v_0 := v.Args[0] 27319 if v_0.Op != OpConst32 { 27320 break 27321 } 27322 x := v_0.AuxInt 27323 if !(x > 0) { 27324 break 27325 } 27326 v.reset(OpConst32) 27327 v.AuxInt = -1 27328 return true 27329 } 27330 // match: (Slicemask (Const32 [0])) 27331 // cond: 27332 // result: (Const32 [0]) 27333 for { 27334 v_0 := v.Args[0] 27335 if v_0.Op != OpConst32 { 27336 break 27337 } 27338 if v_0.AuxInt != 0 { 27339 break 27340 } 27341 v.reset(OpConst32) 27342 v.AuxInt = 0 27343 return true 27344 } 27345 // match: (Slicemask (Const64 [x])) 27346 // cond: x > 0 27347 // result: (Const64 [-1]) 27348 for { 27349 v_0 := v.Args[0] 27350 if v_0.Op != OpConst64 { 27351 break 27352 } 27353 x := v_0.AuxInt 27354 if !(x > 0) { 27355 break 27356 } 27357 v.reset(OpConst64) 27358 v.AuxInt = -1 27359 return true 27360 } 27361 // match: (Slicemask (Const64 [0])) 27362 // cond: 27363 // result: (Const64 [0]) 27364 for { 27365 v_0 := v.Args[0] 27366 if v_0.Op != OpConst64 { 27367 break 27368 } 27369 if v_0.AuxInt != 0 { 27370 break 27371 } 27372 v.reset(OpConst64) 27373 v.AuxInt = 0 27374 return true 27375 } 27376 return false 27377 } 27378 func rewriteValuegeneric_OpSqrt_0(v *Value) bool { 27379 // match: (Sqrt (Const64F [c])) 27380 // cond: 27381 // result: (Const64F [auxFrom64F(math.Sqrt(auxTo64F(c)))]) 27382 for { 27383 v_0 := v.Args[0] 27384 if v_0.Op != OpConst64F { 27385 break 27386 } 27387 c := v_0.AuxInt 27388 v.reset(OpConst64F) 27389 v.AuxInt = auxFrom64F(math.Sqrt(auxTo64F(c))) 27390 return true 27391 } 27392 return false 27393 } 27394 func rewriteValuegeneric_OpStaticCall_0(v *Value) bool { 27395 b := v.Block 27396 _ = b 27397 config := b.Func.Config 27398 _ = config 27399 // match: (StaticCall {sym} s1:(Store _ (Const64 [sz]) s2:(Store _ src s3:(Store {t} _ dst mem)))) 27400 // cond: isSameSym(sym,"runtime.memmove") && t.(*types.Type).IsPtr() && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst,src,sz,config) && clobber(s1) && clobber(s2) && clobber(s3) 27401 // result: (Move {t.(*types.Type).Elem()} [sz] dst src mem) 27402 for { 27403 sym := v.Aux 27404 s1 := v.Args[0] 27405 if s1.Op != OpStore { 27406 break 27407 } 27408 _ = s1.Args[2] 27409 s1_1 := s1.Args[1] 27410 if s1_1.Op != OpConst64 { 27411 break 27412 } 27413 sz := s1_1.AuxInt 27414 s2 := s1.Args[2] 27415 if s2.Op != OpStore { 27416 break 27417 } 27418 _ = s2.Args[2] 27419 src := s2.Args[1] 27420 s3 := s2.Args[2] 27421 if s3.Op != OpStore { 27422 break 27423 } 27424 t := s3.Aux 27425 _ = s3.Args[2] 27426 dst := s3.Args[1] 27427 mem := s3.Args[2] 27428 if !(isSameSym(sym, "runtime.memmove") && t.(*types.Type).IsPtr() && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, sz, config) && clobber(s1) && clobber(s2) && clobber(s3)) { 27429 break 27430 } 27431 v.reset(OpMove) 27432 v.AuxInt = sz 27433 v.Aux = t.(*types.Type).Elem() 27434 v.AddArg(dst) 27435 v.AddArg(src) 27436 v.AddArg(mem) 27437 return true 27438 } 27439 // match: (StaticCall {sym} s1:(Store _ (Const32 [sz]) s2:(Store _ src s3:(Store {t} _ dst mem)))) 27440 // cond: isSameSym(sym,"runtime.memmove") && t.(*types.Type).IsPtr() && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst,src,sz,config) && clobber(s1) && clobber(s2) && clobber(s3) 27441 // result: (Move {t.(*types.Type).Elem()} [sz] dst src mem) 27442 for { 27443 sym := v.Aux 27444 s1 := v.Args[0] 27445 if s1.Op != OpStore { 27446 break 27447 } 27448 _ = s1.Args[2] 27449 s1_1 := s1.Args[1] 27450 if s1_1.Op != OpConst32 { 27451 break 27452 } 27453 sz := s1_1.AuxInt 27454 s2 := s1.Args[2] 27455 if s2.Op != OpStore { 27456 break 27457 } 27458 _ = s2.Args[2] 27459 src := s2.Args[1] 27460 s3 := s2.Args[2] 27461 if s3.Op != OpStore { 27462 break 27463 } 27464 t := s3.Aux 27465 _ = s3.Args[2] 27466 dst := s3.Args[1] 27467 mem := s3.Args[2] 27468 if !(isSameSym(sym, "runtime.memmove") && t.(*types.Type).IsPtr() && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, sz, config) && clobber(s1) && clobber(s2) && clobber(s3)) { 27469 break 27470 } 27471 v.reset(OpMove) 27472 v.AuxInt = sz 27473 v.Aux = t.(*types.Type).Elem() 27474 v.AddArg(dst) 27475 v.AddArg(src) 27476 v.AddArg(mem) 27477 return true 27478 } 27479 // match: (StaticCall {sym} x) 27480 // cond: needRaceCleanup(sym,v) 27481 // result: x 27482 for { 27483 sym := v.Aux 27484 x := v.Args[0] 27485 if !(needRaceCleanup(sym, v)) { 27486 break 27487 } 27488 v.reset(OpCopy) 27489 v.Type = x.Type 27490 v.AddArg(x) 27491 return true 27492 } 27493 return false 27494 } 27495 func rewriteValuegeneric_OpStore_0(v *Value) bool { 27496 b := v.Block 27497 _ = b 27498 // match: (Store {t1} p1 (Load <t2> p2 mem) mem) 27499 // cond: isSamePtr(p1, p2) && t2.Size() == sizeof(t1) 27500 // result: mem 27501 for { 27502 t1 := v.Aux 27503 _ = v.Args[2] 27504 p1 := v.Args[0] 27505 v_1 := v.Args[1] 27506 if v_1.Op != OpLoad { 27507 break 27508 } 27509 t2 := v_1.Type 27510 _ = v_1.Args[1] 27511 p2 := v_1.Args[0] 27512 mem := v_1.Args[1] 27513 if mem != v.Args[2] { 27514 break 27515 } 27516 if !(isSamePtr(p1, p2) && t2.Size() == sizeof(t1)) { 27517 break 27518 } 27519 v.reset(OpCopy) 27520 v.Type = mem.Type 27521 v.AddArg(mem) 27522 return true 27523 } 27524 // match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ oldmem)) 27525 // cond: isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3)) 27526 // result: mem 27527 for { 27528 t1 := v.Aux 27529 _ = v.Args[2] 27530 p1 := v.Args[0] 27531 v_1 := v.Args[1] 27532 if v_1.Op != OpLoad { 27533 break 27534 } 27535 t2 := v_1.Type 27536 _ = v_1.Args[1] 27537 p2 := v_1.Args[0] 27538 oldmem := v_1.Args[1] 27539 mem := v.Args[2] 27540 if mem.Op != OpStore { 27541 break 27542 } 27543 t3 := mem.Aux 27544 _ = mem.Args[2] 27545 p3 := mem.Args[0] 27546 if oldmem != mem.Args[2] { 27547 break 27548 } 27549 if !(isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3))) { 27550 break 27551 } 27552 v.reset(OpCopy) 27553 v.Type = mem.Type 27554 v.AddArg(mem) 27555 return true 27556 } 27557 // match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ (Store {t4} p4 _ oldmem))) 27558 // cond: isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3)) && disjoint(p1, sizeof(t1), p4, sizeof(t4)) 27559 // result: mem 27560 for { 27561 t1 := v.Aux 27562 _ = v.Args[2] 27563 p1 := v.Args[0] 27564 v_1 := v.Args[1] 27565 if v_1.Op != OpLoad { 27566 break 27567 } 27568 t2 := v_1.Type 27569 _ = v_1.Args[1] 27570 p2 := v_1.Args[0] 27571 oldmem := v_1.Args[1] 27572 mem := v.Args[2] 27573 if mem.Op != OpStore { 27574 break 27575 } 27576 t3 := mem.Aux 27577 _ = mem.Args[2] 27578 p3 := mem.Args[0] 27579 mem_2 := mem.Args[2] 27580 if mem_2.Op != OpStore { 27581 break 27582 } 27583 t4 := mem_2.Aux 27584 _ = mem_2.Args[2] 27585 p4 := mem_2.Args[0] 27586 if oldmem != mem_2.Args[2] { 27587 break 27588 } 27589 if !(isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3)) && disjoint(p1, sizeof(t1), p4, sizeof(t4))) { 27590 break 27591 } 27592 v.reset(OpCopy) 27593 v.Type = mem.Type 27594 v.AddArg(mem) 27595 return true 27596 } 27597 // match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 _ oldmem)))) 27598 // cond: isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3)) && disjoint(p1, sizeof(t1), p4, sizeof(t4)) && disjoint(p1, sizeof(t1), p5, sizeof(t5)) 27599 // result: mem 27600 for { 27601 t1 := v.Aux 27602 _ = v.Args[2] 27603 p1 := v.Args[0] 27604 v_1 := v.Args[1] 27605 if v_1.Op != OpLoad { 27606 break 27607 } 27608 t2 := v_1.Type 27609 _ = v_1.Args[1] 27610 p2 := v_1.Args[0] 27611 oldmem := v_1.Args[1] 27612 mem := v.Args[2] 27613 if mem.Op != OpStore { 27614 break 27615 } 27616 t3 := mem.Aux 27617 _ = mem.Args[2] 27618 p3 := mem.Args[0] 27619 mem_2 := mem.Args[2] 27620 if mem_2.Op != OpStore { 27621 break 27622 } 27623 t4 := mem_2.Aux 27624 _ = mem_2.Args[2] 27625 p4 := mem_2.Args[0] 27626 mem_2_2 := mem_2.Args[2] 27627 if mem_2_2.Op != OpStore { 27628 break 27629 } 27630 t5 := mem_2_2.Aux 27631 _ = mem_2_2.Args[2] 27632 p5 := mem_2_2.Args[0] 27633 if oldmem != mem_2_2.Args[2] { 27634 break 27635 } 27636 if !(isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3)) && disjoint(p1, sizeof(t1), p4, sizeof(t4)) && disjoint(p1, sizeof(t1), p5, sizeof(t5))) { 27637 break 27638 } 27639 v.reset(OpCopy) 27640 v.Type = mem.Type 27641 v.AddArg(mem) 27642 return true 27643 } 27644 // match: (Store {t} (OffPtr [o] p1) x mem:(Zero [n] p2 _)) 27645 // cond: isConstZero(x) && o >= 0 && sizeof(t) + o <= n && isSamePtr(p1, p2) 27646 // result: mem 27647 for { 27648 t := v.Aux 27649 _ = v.Args[2] 27650 v_0 := v.Args[0] 27651 if v_0.Op != OpOffPtr { 27652 break 27653 } 27654 o := v_0.AuxInt 27655 p1 := v_0.Args[0] 27656 x := v.Args[1] 27657 mem := v.Args[2] 27658 if mem.Op != OpZero { 27659 break 27660 } 27661 n := mem.AuxInt 27662 _ = mem.Args[1] 27663 p2 := mem.Args[0] 27664 if !(isConstZero(x) && o >= 0 && sizeof(t)+o <= n && isSamePtr(p1, p2)) { 27665 break 27666 } 27667 v.reset(OpCopy) 27668 v.Type = mem.Type 27669 v.AddArg(mem) 27670 return true 27671 } 27672 // match: (Store {t1} op:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Zero [n] p3 _))) 27673 // cond: isConstZero(x) && o1 >= 0 && sizeof(t1) + o1 <= n && isSamePtr(p1, p3) && disjoint(op, sizeof(t1), p2, sizeof(t2)) 27674 // result: mem 27675 for { 27676 t1 := v.Aux 27677 _ = v.Args[2] 27678 op := v.Args[0] 27679 if op.Op != OpOffPtr { 27680 break 27681 } 27682 o1 := op.AuxInt 27683 p1 := op.Args[0] 27684 x := v.Args[1] 27685 mem := v.Args[2] 27686 if mem.Op != OpStore { 27687 break 27688 } 27689 t2 := mem.Aux 27690 _ = mem.Args[2] 27691 p2 := mem.Args[0] 27692 mem_2 := mem.Args[2] 27693 if mem_2.Op != OpZero { 27694 break 27695 } 27696 n := mem_2.AuxInt 27697 _ = mem_2.Args[1] 27698 p3 := mem_2.Args[0] 27699 if !(isConstZero(x) && o1 >= 0 && sizeof(t1)+o1 <= n && isSamePtr(p1, p3) && disjoint(op, sizeof(t1), p2, sizeof(t2))) { 27700 break 27701 } 27702 v.reset(OpCopy) 27703 v.Type = mem.Type 27704 v.AddArg(mem) 27705 return true 27706 } 27707 // match: (Store {t1} op:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Store {t3} p3 _ (Zero [n] p4 _)))) 27708 // cond: isConstZero(x) && o1 >= 0 && sizeof(t1) + o1 <= n && isSamePtr(p1, p4) && disjoint(op, sizeof(t1), p2, sizeof(t2)) && disjoint(op, sizeof(t1), p3, sizeof(t3)) 27709 // result: mem 27710 for { 27711 t1 := v.Aux 27712 _ = v.Args[2] 27713 op := v.Args[0] 27714 if op.Op != OpOffPtr { 27715 break 27716 } 27717 o1 := op.AuxInt 27718 p1 := op.Args[0] 27719 x := v.Args[1] 27720 mem := v.Args[2] 27721 if mem.Op != OpStore { 27722 break 27723 } 27724 t2 := mem.Aux 27725 _ = mem.Args[2] 27726 p2 := mem.Args[0] 27727 mem_2 := mem.Args[2] 27728 if mem_2.Op != OpStore { 27729 break 27730 } 27731 t3 := mem_2.Aux 27732 _ = mem_2.Args[2] 27733 p3 := mem_2.Args[0] 27734 mem_2_2 := mem_2.Args[2] 27735 if mem_2_2.Op != OpZero { 27736 break 27737 } 27738 n := mem_2_2.AuxInt 27739 _ = mem_2_2.Args[1] 27740 p4 := mem_2_2.Args[0] 27741 if !(isConstZero(x) && o1 >= 0 && sizeof(t1)+o1 <= n && isSamePtr(p1, p4) && disjoint(op, sizeof(t1), p2, sizeof(t2)) && disjoint(op, sizeof(t1), p3, sizeof(t3))) { 27742 break 27743 } 27744 v.reset(OpCopy) 27745 v.Type = mem.Type 27746 v.AddArg(mem) 27747 return true 27748 } 27749 // match: (Store {t1} op:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Zero [n] p5 _))))) 27750 // cond: isConstZero(x) && o1 >= 0 && sizeof(t1) + o1 <= n && isSamePtr(p1, p5) && disjoint(op, sizeof(t1), p2, sizeof(t2)) && disjoint(op, sizeof(t1), p3, sizeof(t3)) && disjoint(op, sizeof(t1), p4, sizeof(t4)) 27751 // result: mem 27752 for { 27753 t1 := v.Aux 27754 _ = v.Args[2] 27755 op := v.Args[0] 27756 if op.Op != OpOffPtr { 27757 break 27758 } 27759 o1 := op.AuxInt 27760 p1 := op.Args[0] 27761 x := v.Args[1] 27762 mem := v.Args[2] 27763 if mem.Op != OpStore { 27764 break 27765 } 27766 t2 := mem.Aux 27767 _ = mem.Args[2] 27768 p2 := mem.Args[0] 27769 mem_2 := mem.Args[2] 27770 if mem_2.Op != OpStore { 27771 break 27772 } 27773 t3 := mem_2.Aux 27774 _ = mem_2.Args[2] 27775 p3 := mem_2.Args[0] 27776 mem_2_2 := mem_2.Args[2] 27777 if mem_2_2.Op != OpStore { 27778 break 27779 } 27780 t4 := mem_2_2.Aux 27781 _ = mem_2_2.Args[2] 27782 p4 := mem_2_2.Args[0] 27783 mem_2_2_2 := mem_2_2.Args[2] 27784 if mem_2_2_2.Op != OpZero { 27785 break 27786 } 27787 n := mem_2_2_2.AuxInt 27788 _ = mem_2_2_2.Args[1] 27789 p5 := mem_2_2_2.Args[0] 27790 if !(isConstZero(x) && o1 >= 0 && sizeof(t1)+o1 <= n && isSamePtr(p1, p5) && disjoint(op, sizeof(t1), p2, sizeof(t2)) && disjoint(op, sizeof(t1), p3, sizeof(t3)) && disjoint(op, sizeof(t1), p4, sizeof(t4))) { 27791 break 27792 } 27793 v.reset(OpCopy) 27794 v.Type = mem.Type 27795 v.AddArg(mem) 27796 return true 27797 } 27798 // match: (Store _ (StructMake0) mem) 27799 // cond: 27800 // result: mem 27801 for { 27802 _ = v.Args[2] 27803 v_1 := v.Args[1] 27804 if v_1.Op != OpStructMake0 { 27805 break 27806 } 27807 mem := v.Args[2] 27808 v.reset(OpCopy) 27809 v.Type = mem.Type 27810 v.AddArg(mem) 27811 return true 27812 } 27813 // match: (Store dst (StructMake1 <t> f0) mem) 27814 // cond: 27815 // result: (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem) 27816 for { 27817 _ = v.Args[2] 27818 dst := v.Args[0] 27819 v_1 := v.Args[1] 27820 if v_1.Op != OpStructMake1 { 27821 break 27822 } 27823 t := v_1.Type 27824 f0 := v_1.Args[0] 27825 mem := v.Args[2] 27826 v.reset(OpStore) 27827 v.Aux = t.FieldType(0) 27828 v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo()) 27829 v0.AuxInt = 0 27830 v0.AddArg(dst) 27831 v.AddArg(v0) 27832 v.AddArg(f0) 27833 v.AddArg(mem) 27834 return true 27835 } 27836 return false 27837 } 27838 func rewriteValuegeneric_OpStore_10(v *Value) bool { 27839 b := v.Block 27840 _ = b 27841 config := b.Func.Config 27842 _ = config 27843 fe := b.Func.fe 27844 _ = fe 27845 // match: (Store dst (StructMake2 <t> f0 f1) mem) 27846 // cond: 27847 // 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)) 27848 for { 27849 _ = v.Args[2] 27850 dst := v.Args[0] 27851 v_1 := v.Args[1] 27852 if v_1.Op != OpStructMake2 { 27853 break 27854 } 27855 t := v_1.Type 27856 _ = v_1.Args[1] 27857 f0 := v_1.Args[0] 27858 f1 := v_1.Args[1] 27859 mem := v.Args[2] 27860 v.reset(OpStore) 27861 v.Aux = t.FieldType(1) 27862 v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo()) 27863 v0.AuxInt = t.FieldOff(1) 27864 v0.AddArg(dst) 27865 v.AddArg(v0) 27866 v.AddArg(f1) 27867 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 27868 v1.Aux = t.FieldType(0) 27869 v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo()) 27870 v2.AuxInt = 0 27871 v2.AddArg(dst) 27872 v1.AddArg(v2) 27873 v1.AddArg(f0) 27874 v1.AddArg(mem) 27875 v.AddArg(v1) 27876 return true 27877 } 27878 // match: (Store dst (StructMake3 <t> f0 f1 f2) mem) 27879 // cond: 27880 // 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))) 27881 for { 27882 _ = v.Args[2] 27883 dst := v.Args[0] 27884 v_1 := v.Args[1] 27885 if v_1.Op != OpStructMake3 { 27886 break 27887 } 27888 t := v_1.Type 27889 _ = v_1.Args[2] 27890 f0 := v_1.Args[0] 27891 f1 := v_1.Args[1] 27892 f2 := v_1.Args[2] 27893 mem := v.Args[2] 27894 v.reset(OpStore) 27895 v.Aux = t.FieldType(2) 27896 v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo()) 27897 v0.AuxInt = t.FieldOff(2) 27898 v0.AddArg(dst) 27899 v.AddArg(v0) 27900 v.AddArg(f2) 27901 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 27902 v1.Aux = t.FieldType(1) 27903 v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo()) 27904 v2.AuxInt = t.FieldOff(1) 27905 v2.AddArg(dst) 27906 v1.AddArg(v2) 27907 v1.AddArg(f1) 27908 v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 27909 v3.Aux = t.FieldType(0) 27910 v4 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo()) 27911 v4.AuxInt = 0 27912 v4.AddArg(dst) 27913 v3.AddArg(v4) 27914 v3.AddArg(f0) 27915 v3.AddArg(mem) 27916 v1.AddArg(v3) 27917 v.AddArg(v1) 27918 return true 27919 } 27920 // match: (Store dst (StructMake4 <t> f0 f1 f2 f3) mem) 27921 // cond: 27922 // 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)))) 27923 for { 27924 _ = v.Args[2] 27925 dst := v.Args[0] 27926 v_1 := v.Args[1] 27927 if v_1.Op != OpStructMake4 { 27928 break 27929 } 27930 t := v_1.Type 27931 _ = v_1.Args[3] 27932 f0 := v_1.Args[0] 27933 f1 := v_1.Args[1] 27934 f2 := v_1.Args[2] 27935 f3 := v_1.Args[3] 27936 mem := v.Args[2] 27937 v.reset(OpStore) 27938 v.Aux = t.FieldType(3) 27939 v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(3).PtrTo()) 27940 v0.AuxInt = t.FieldOff(3) 27941 v0.AddArg(dst) 27942 v.AddArg(v0) 27943 v.AddArg(f3) 27944 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 27945 v1.Aux = t.FieldType(2) 27946 v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo()) 27947 v2.AuxInt = t.FieldOff(2) 27948 v2.AddArg(dst) 27949 v1.AddArg(v2) 27950 v1.AddArg(f2) 27951 v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 27952 v3.Aux = t.FieldType(1) 27953 v4 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo()) 27954 v4.AuxInt = t.FieldOff(1) 27955 v4.AddArg(dst) 27956 v3.AddArg(v4) 27957 v3.AddArg(f1) 27958 v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 27959 v5.Aux = t.FieldType(0) 27960 v6 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo()) 27961 v6.AuxInt = 0 27962 v6.AddArg(dst) 27963 v5.AddArg(v6) 27964 v5.AddArg(f0) 27965 v5.AddArg(mem) 27966 v3.AddArg(v5) 27967 v1.AddArg(v3) 27968 v.AddArg(v1) 27969 return true 27970 } 27971 // match: (Store {t} dst (Load src mem) mem) 27972 // cond: !fe.CanSSA(t.(*types.Type)) 27973 // result: (Move {t} [sizeof(t)] dst src mem) 27974 for { 27975 t := v.Aux 27976 _ = v.Args[2] 27977 dst := v.Args[0] 27978 v_1 := v.Args[1] 27979 if v_1.Op != OpLoad { 27980 break 27981 } 27982 _ = v_1.Args[1] 27983 src := v_1.Args[0] 27984 mem := v_1.Args[1] 27985 if mem != v.Args[2] { 27986 break 27987 } 27988 if !(!fe.CanSSA(t.(*types.Type))) { 27989 break 27990 } 27991 v.reset(OpMove) 27992 v.AuxInt = sizeof(t) 27993 v.Aux = t 27994 v.AddArg(dst) 27995 v.AddArg(src) 27996 v.AddArg(mem) 27997 return true 27998 } 27999 // match: (Store {t} dst (Load src mem) (VarDef {x} mem)) 28000 // cond: !fe.CanSSA(t.(*types.Type)) 28001 // result: (Move {t} [sizeof(t)] dst src (VarDef {x} mem)) 28002 for { 28003 t := v.Aux 28004 _ = v.Args[2] 28005 dst := v.Args[0] 28006 v_1 := v.Args[1] 28007 if v_1.Op != OpLoad { 28008 break 28009 } 28010 _ = v_1.Args[1] 28011 src := v_1.Args[0] 28012 mem := v_1.Args[1] 28013 v_2 := v.Args[2] 28014 if v_2.Op != OpVarDef { 28015 break 28016 } 28017 x := v_2.Aux 28018 if mem != v_2.Args[0] { 28019 break 28020 } 28021 if !(!fe.CanSSA(t.(*types.Type))) { 28022 break 28023 } 28024 v.reset(OpMove) 28025 v.AuxInt = sizeof(t) 28026 v.Aux = t 28027 v.AddArg(dst) 28028 v.AddArg(src) 28029 v0 := b.NewValue0(v.Pos, OpVarDef, types.TypeMem) 28030 v0.Aux = x 28031 v0.AddArg(mem) 28032 v.AddArg(v0) 28033 return true 28034 } 28035 // match: (Store _ (ArrayMake0) mem) 28036 // cond: 28037 // result: mem 28038 for { 28039 _ = v.Args[2] 28040 v_1 := v.Args[1] 28041 if v_1.Op != OpArrayMake0 { 28042 break 28043 } 28044 mem := v.Args[2] 28045 v.reset(OpCopy) 28046 v.Type = mem.Type 28047 v.AddArg(mem) 28048 return true 28049 } 28050 // match: (Store dst (ArrayMake1 e) mem) 28051 // cond: 28052 // result: (Store {e.Type} dst e mem) 28053 for { 28054 _ = v.Args[2] 28055 dst := v.Args[0] 28056 v_1 := v.Args[1] 28057 if v_1.Op != OpArrayMake1 { 28058 break 28059 } 28060 e := v_1.Args[0] 28061 mem := v.Args[2] 28062 v.reset(OpStore) 28063 v.Aux = e.Type 28064 v.AddArg(dst) 28065 v.AddArg(e) 28066 v.AddArg(mem) 28067 return true 28068 } 28069 // match: (Store (Load (OffPtr [c] (SP)) mem) x mem) 28070 // cond: isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize 28071 // result: mem 28072 for { 28073 _ = v.Args[2] 28074 v_0 := v.Args[0] 28075 if v_0.Op != OpLoad { 28076 break 28077 } 28078 _ = v_0.Args[1] 28079 v_0_0 := v_0.Args[0] 28080 if v_0_0.Op != OpOffPtr { 28081 break 28082 } 28083 c := v_0_0.AuxInt 28084 v_0_0_0 := v_0_0.Args[0] 28085 if v_0_0_0.Op != OpSP { 28086 break 28087 } 28088 mem := v_0.Args[1] 28089 x := v.Args[1] 28090 if mem != v.Args[2] { 28091 break 28092 } 28093 if !(isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) { 28094 break 28095 } 28096 v.reset(OpCopy) 28097 v.Type = mem.Type 28098 v.AddArg(mem) 28099 return true 28100 } 28101 // match: (Store (OffPtr (Load (OffPtr [c] (SP)) mem)) x mem) 28102 // cond: isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize 28103 // result: mem 28104 for { 28105 _ = v.Args[2] 28106 v_0 := v.Args[0] 28107 if v_0.Op != OpOffPtr { 28108 break 28109 } 28110 v_0_0 := v_0.Args[0] 28111 if v_0_0.Op != OpLoad { 28112 break 28113 } 28114 _ = v_0_0.Args[1] 28115 v_0_0_0 := v_0_0.Args[0] 28116 if v_0_0_0.Op != OpOffPtr { 28117 break 28118 } 28119 c := v_0_0_0.AuxInt 28120 v_0_0_0_0 := v_0_0_0.Args[0] 28121 if v_0_0_0_0.Op != OpSP { 28122 break 28123 } 28124 mem := v_0_0.Args[1] 28125 x := v.Args[1] 28126 if mem != v.Args[2] { 28127 break 28128 } 28129 if !(isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) { 28130 break 28131 } 28132 v.reset(OpCopy) 28133 v.Type = mem.Type 28134 v.AddArg(mem) 28135 return true 28136 } 28137 // match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [0] p2) d2 m3:(Move [n] p3 _ mem))) 28138 // cond: m2.Uses == 1 && m3.Uses == 1 && o1 == sizeof(t2) && n == sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && clobber(m2) && clobber(m3) 28139 // result: (Store {t1} op1 d1 (Store {t2} op2 d2 mem)) 28140 for { 28141 t1 := v.Aux 28142 _ = v.Args[2] 28143 op1 := v.Args[0] 28144 if op1.Op != OpOffPtr { 28145 break 28146 } 28147 o1 := op1.AuxInt 28148 p1 := op1.Args[0] 28149 d1 := v.Args[1] 28150 m2 := v.Args[2] 28151 if m2.Op != OpStore { 28152 break 28153 } 28154 t2 := m2.Aux 28155 _ = m2.Args[2] 28156 op2 := m2.Args[0] 28157 if op2.Op != OpOffPtr { 28158 break 28159 } 28160 if op2.AuxInt != 0 { 28161 break 28162 } 28163 p2 := op2.Args[0] 28164 d2 := m2.Args[1] 28165 m3 := m2.Args[2] 28166 if m3.Op != OpMove { 28167 break 28168 } 28169 n := m3.AuxInt 28170 _ = m3.Args[2] 28171 p3 := m3.Args[0] 28172 mem := m3.Args[2] 28173 if !(m2.Uses == 1 && m3.Uses == 1 && o1 == sizeof(t2) && n == sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && clobber(m2) && clobber(m3)) { 28174 break 28175 } 28176 v.reset(OpStore) 28177 v.Aux = t1 28178 v.AddArg(op1) 28179 v.AddArg(d1) 28180 v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 28181 v0.Aux = t2 28182 v0.AddArg(op2) 28183 v0.AddArg(d2) 28184 v0.AddArg(mem) 28185 v.AddArg(v0) 28186 return true 28187 } 28188 return false 28189 } 28190 func rewriteValuegeneric_OpStore_20(v *Value) bool { 28191 b := v.Block 28192 _ = b 28193 // match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [0] p3) d3 m4:(Move [n] p4 _ mem)))) 28194 // cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t3) + sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && clobber(m2) && clobber(m3) && clobber(m4) 28195 // result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 mem))) 28196 for { 28197 t1 := v.Aux 28198 _ = v.Args[2] 28199 op1 := v.Args[0] 28200 if op1.Op != OpOffPtr { 28201 break 28202 } 28203 o1 := op1.AuxInt 28204 p1 := op1.Args[0] 28205 d1 := v.Args[1] 28206 m2 := v.Args[2] 28207 if m2.Op != OpStore { 28208 break 28209 } 28210 t2 := m2.Aux 28211 _ = m2.Args[2] 28212 op2 := m2.Args[0] 28213 if op2.Op != OpOffPtr { 28214 break 28215 } 28216 o2 := op2.AuxInt 28217 p2 := op2.Args[0] 28218 d2 := m2.Args[1] 28219 m3 := m2.Args[2] 28220 if m3.Op != OpStore { 28221 break 28222 } 28223 t3 := m3.Aux 28224 _ = m3.Args[2] 28225 op3 := m3.Args[0] 28226 if op3.Op != OpOffPtr { 28227 break 28228 } 28229 if op3.AuxInt != 0 { 28230 break 28231 } 28232 p3 := op3.Args[0] 28233 d3 := m3.Args[1] 28234 m4 := m3.Args[2] 28235 if m4.Op != OpMove { 28236 break 28237 } 28238 n := m4.AuxInt 28239 _ = m4.Args[2] 28240 p4 := m4.Args[0] 28241 mem := m4.Args[2] 28242 if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t3)+sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && clobber(m2) && clobber(m3) && clobber(m4)) { 28243 break 28244 } 28245 v.reset(OpStore) 28246 v.Aux = t1 28247 v.AddArg(op1) 28248 v.AddArg(d1) 28249 v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 28250 v0.Aux = t2 28251 v0.AddArg(op2) 28252 v0.AddArg(d2) 28253 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 28254 v1.Aux = t3 28255 v1.AddArg(op3) 28256 v1.AddArg(d3) 28257 v1.AddArg(mem) 28258 v0.AddArg(v1) 28259 v.AddArg(v0) 28260 return true 28261 } 28262 // match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [o3] p3) d3 m4:(Store {t4} op4:(OffPtr [0] p4) d4 m5:(Move [n] p5 _ mem))))) 28263 // cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t4) + sizeof(t3) + sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && clobber(m2) && clobber(m3) && clobber(m4) && clobber(m5) 28264 // result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 (Store {t4} op4 d4 mem)))) 28265 for { 28266 t1 := v.Aux 28267 _ = v.Args[2] 28268 op1 := v.Args[0] 28269 if op1.Op != OpOffPtr { 28270 break 28271 } 28272 o1 := op1.AuxInt 28273 p1 := op1.Args[0] 28274 d1 := v.Args[1] 28275 m2 := v.Args[2] 28276 if m2.Op != OpStore { 28277 break 28278 } 28279 t2 := m2.Aux 28280 _ = m2.Args[2] 28281 op2 := m2.Args[0] 28282 if op2.Op != OpOffPtr { 28283 break 28284 } 28285 o2 := op2.AuxInt 28286 p2 := op2.Args[0] 28287 d2 := m2.Args[1] 28288 m3 := m2.Args[2] 28289 if m3.Op != OpStore { 28290 break 28291 } 28292 t3 := m3.Aux 28293 _ = m3.Args[2] 28294 op3 := m3.Args[0] 28295 if op3.Op != OpOffPtr { 28296 break 28297 } 28298 o3 := op3.AuxInt 28299 p3 := op3.Args[0] 28300 d3 := m3.Args[1] 28301 m4 := m3.Args[2] 28302 if m4.Op != OpStore { 28303 break 28304 } 28305 t4 := m4.Aux 28306 _ = m4.Args[2] 28307 op4 := m4.Args[0] 28308 if op4.Op != OpOffPtr { 28309 break 28310 } 28311 if op4.AuxInt != 0 { 28312 break 28313 } 28314 p4 := op4.Args[0] 28315 d4 := m4.Args[1] 28316 m5 := m4.Args[2] 28317 if m5.Op != OpMove { 28318 break 28319 } 28320 n := m5.AuxInt 28321 _ = m5.Args[2] 28322 p5 := m5.Args[0] 28323 mem := m5.Args[2] 28324 if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t4)+sizeof(t3)+sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && clobber(m2) && clobber(m3) && clobber(m4) && clobber(m5)) { 28325 break 28326 } 28327 v.reset(OpStore) 28328 v.Aux = t1 28329 v.AddArg(op1) 28330 v.AddArg(d1) 28331 v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 28332 v0.Aux = t2 28333 v0.AddArg(op2) 28334 v0.AddArg(d2) 28335 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 28336 v1.Aux = t3 28337 v1.AddArg(op3) 28338 v1.AddArg(d3) 28339 v2 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 28340 v2.Aux = t4 28341 v2.AddArg(op4) 28342 v2.AddArg(d4) 28343 v2.AddArg(mem) 28344 v1.AddArg(v2) 28345 v0.AddArg(v1) 28346 v.AddArg(v0) 28347 return true 28348 } 28349 // match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [0] p2) d2 m3:(Zero [n] p3 mem))) 28350 // cond: m2.Uses == 1 && m3.Uses == 1 && o1 == sizeof(t2) && n == sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && clobber(m2) && clobber(m3) 28351 // result: (Store {t1} op1 d1 (Store {t2} op2 d2 mem)) 28352 for { 28353 t1 := v.Aux 28354 _ = v.Args[2] 28355 op1 := v.Args[0] 28356 if op1.Op != OpOffPtr { 28357 break 28358 } 28359 o1 := op1.AuxInt 28360 p1 := op1.Args[0] 28361 d1 := v.Args[1] 28362 m2 := v.Args[2] 28363 if m2.Op != OpStore { 28364 break 28365 } 28366 t2 := m2.Aux 28367 _ = m2.Args[2] 28368 op2 := m2.Args[0] 28369 if op2.Op != OpOffPtr { 28370 break 28371 } 28372 if op2.AuxInt != 0 { 28373 break 28374 } 28375 p2 := op2.Args[0] 28376 d2 := m2.Args[1] 28377 m3 := m2.Args[2] 28378 if m3.Op != OpZero { 28379 break 28380 } 28381 n := m3.AuxInt 28382 _ = m3.Args[1] 28383 p3 := m3.Args[0] 28384 mem := m3.Args[1] 28385 if !(m2.Uses == 1 && m3.Uses == 1 && o1 == sizeof(t2) && n == sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && clobber(m2) && clobber(m3)) { 28386 break 28387 } 28388 v.reset(OpStore) 28389 v.Aux = t1 28390 v.AddArg(op1) 28391 v.AddArg(d1) 28392 v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 28393 v0.Aux = t2 28394 v0.AddArg(op2) 28395 v0.AddArg(d2) 28396 v0.AddArg(mem) 28397 v.AddArg(v0) 28398 return true 28399 } 28400 // match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [0] p3) d3 m4:(Zero [n] p4 mem)))) 28401 // cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t3) + sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && clobber(m2) && clobber(m3) && clobber(m4) 28402 // result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 mem))) 28403 for { 28404 t1 := v.Aux 28405 _ = v.Args[2] 28406 op1 := v.Args[0] 28407 if op1.Op != OpOffPtr { 28408 break 28409 } 28410 o1 := op1.AuxInt 28411 p1 := op1.Args[0] 28412 d1 := v.Args[1] 28413 m2 := v.Args[2] 28414 if m2.Op != OpStore { 28415 break 28416 } 28417 t2 := m2.Aux 28418 _ = m2.Args[2] 28419 op2 := m2.Args[0] 28420 if op2.Op != OpOffPtr { 28421 break 28422 } 28423 o2 := op2.AuxInt 28424 p2 := op2.Args[0] 28425 d2 := m2.Args[1] 28426 m3 := m2.Args[2] 28427 if m3.Op != OpStore { 28428 break 28429 } 28430 t3 := m3.Aux 28431 _ = m3.Args[2] 28432 op3 := m3.Args[0] 28433 if op3.Op != OpOffPtr { 28434 break 28435 } 28436 if op3.AuxInt != 0 { 28437 break 28438 } 28439 p3 := op3.Args[0] 28440 d3 := m3.Args[1] 28441 m4 := m3.Args[2] 28442 if m4.Op != OpZero { 28443 break 28444 } 28445 n := m4.AuxInt 28446 _ = m4.Args[1] 28447 p4 := m4.Args[0] 28448 mem := m4.Args[1] 28449 if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t3)+sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && clobber(m2) && clobber(m3) && clobber(m4)) { 28450 break 28451 } 28452 v.reset(OpStore) 28453 v.Aux = t1 28454 v.AddArg(op1) 28455 v.AddArg(d1) 28456 v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 28457 v0.Aux = t2 28458 v0.AddArg(op2) 28459 v0.AddArg(d2) 28460 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 28461 v1.Aux = t3 28462 v1.AddArg(op3) 28463 v1.AddArg(d3) 28464 v1.AddArg(mem) 28465 v0.AddArg(v1) 28466 v.AddArg(v0) 28467 return true 28468 } 28469 // match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [o3] p3) d3 m4:(Store {t4} op4:(OffPtr [0] p4) d4 m5:(Zero [n] p5 mem))))) 28470 // cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t4) + sizeof(t3) + sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && clobber(m2) && clobber(m3) && clobber(m4) && clobber(m5) 28471 // result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 (Store {t4} op4 d4 mem)))) 28472 for { 28473 t1 := v.Aux 28474 _ = v.Args[2] 28475 op1 := v.Args[0] 28476 if op1.Op != OpOffPtr { 28477 break 28478 } 28479 o1 := op1.AuxInt 28480 p1 := op1.Args[0] 28481 d1 := v.Args[1] 28482 m2 := v.Args[2] 28483 if m2.Op != OpStore { 28484 break 28485 } 28486 t2 := m2.Aux 28487 _ = m2.Args[2] 28488 op2 := m2.Args[0] 28489 if op2.Op != OpOffPtr { 28490 break 28491 } 28492 o2 := op2.AuxInt 28493 p2 := op2.Args[0] 28494 d2 := m2.Args[1] 28495 m3 := m2.Args[2] 28496 if m3.Op != OpStore { 28497 break 28498 } 28499 t3 := m3.Aux 28500 _ = m3.Args[2] 28501 op3 := m3.Args[0] 28502 if op3.Op != OpOffPtr { 28503 break 28504 } 28505 o3 := op3.AuxInt 28506 p3 := op3.Args[0] 28507 d3 := m3.Args[1] 28508 m4 := m3.Args[2] 28509 if m4.Op != OpStore { 28510 break 28511 } 28512 t4 := m4.Aux 28513 _ = m4.Args[2] 28514 op4 := m4.Args[0] 28515 if op4.Op != OpOffPtr { 28516 break 28517 } 28518 if op4.AuxInt != 0 { 28519 break 28520 } 28521 p4 := op4.Args[0] 28522 d4 := m4.Args[1] 28523 m5 := m4.Args[2] 28524 if m5.Op != OpZero { 28525 break 28526 } 28527 n := m5.AuxInt 28528 _ = m5.Args[1] 28529 p5 := m5.Args[0] 28530 mem := m5.Args[1] 28531 if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t4)+sizeof(t3)+sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && clobber(m2) && clobber(m3) && clobber(m4) && clobber(m5)) { 28532 break 28533 } 28534 v.reset(OpStore) 28535 v.Aux = t1 28536 v.AddArg(op1) 28537 v.AddArg(d1) 28538 v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 28539 v0.Aux = t2 28540 v0.AddArg(op2) 28541 v0.AddArg(d2) 28542 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 28543 v1.Aux = t3 28544 v1.AddArg(op3) 28545 v1.AddArg(d3) 28546 v2 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 28547 v2.Aux = t4 28548 v2.AddArg(op4) 28549 v2.AddArg(d4) 28550 v2.AddArg(mem) 28551 v1.AddArg(v2) 28552 v0.AddArg(v1) 28553 v.AddArg(v0) 28554 return true 28555 } 28556 return false 28557 } 28558 func rewriteValuegeneric_OpStringLen_0(v *Value) bool { 28559 // match: (StringLen (StringMake _ (Const64 <t> [c]))) 28560 // cond: 28561 // result: (Const64 <t> [c]) 28562 for { 28563 v_0 := v.Args[0] 28564 if v_0.Op != OpStringMake { 28565 break 28566 } 28567 _ = v_0.Args[1] 28568 v_0_1 := v_0.Args[1] 28569 if v_0_1.Op != OpConst64 { 28570 break 28571 } 28572 t := v_0_1.Type 28573 c := v_0_1.AuxInt 28574 v.reset(OpConst64) 28575 v.Type = t 28576 v.AuxInt = c 28577 return true 28578 } 28579 return false 28580 } 28581 func rewriteValuegeneric_OpStringPtr_0(v *Value) bool { 28582 // match: (StringPtr (StringMake (Addr <t> {s} base) _)) 28583 // cond: 28584 // result: (Addr <t> {s} base) 28585 for { 28586 v_0 := v.Args[0] 28587 if v_0.Op != OpStringMake { 28588 break 28589 } 28590 _ = v_0.Args[1] 28591 v_0_0 := v_0.Args[0] 28592 if v_0_0.Op != OpAddr { 28593 break 28594 } 28595 t := v_0_0.Type 28596 s := v_0_0.Aux 28597 base := v_0_0.Args[0] 28598 v.reset(OpAddr) 28599 v.Type = t 28600 v.Aux = s 28601 v.AddArg(base) 28602 return true 28603 } 28604 return false 28605 } 28606 func rewriteValuegeneric_OpStructSelect_0(v *Value) bool { 28607 // match: (StructSelect (StructMake1 x)) 28608 // cond: 28609 // result: x 28610 for { 28611 v_0 := v.Args[0] 28612 if v_0.Op != OpStructMake1 { 28613 break 28614 } 28615 x := v_0.Args[0] 28616 v.reset(OpCopy) 28617 v.Type = x.Type 28618 v.AddArg(x) 28619 return true 28620 } 28621 // match: (StructSelect [0] (StructMake2 x _)) 28622 // cond: 28623 // result: x 28624 for { 28625 if v.AuxInt != 0 { 28626 break 28627 } 28628 v_0 := v.Args[0] 28629 if v_0.Op != OpStructMake2 { 28630 break 28631 } 28632 _ = v_0.Args[1] 28633 x := v_0.Args[0] 28634 v.reset(OpCopy) 28635 v.Type = x.Type 28636 v.AddArg(x) 28637 return true 28638 } 28639 // match: (StructSelect [1] (StructMake2 _ x)) 28640 // cond: 28641 // result: x 28642 for { 28643 if v.AuxInt != 1 { 28644 break 28645 } 28646 v_0 := v.Args[0] 28647 if v_0.Op != OpStructMake2 { 28648 break 28649 } 28650 _ = v_0.Args[1] 28651 x := v_0.Args[1] 28652 v.reset(OpCopy) 28653 v.Type = x.Type 28654 v.AddArg(x) 28655 return true 28656 } 28657 // match: (StructSelect [0] (StructMake3 x _ _)) 28658 // cond: 28659 // result: x 28660 for { 28661 if v.AuxInt != 0 { 28662 break 28663 } 28664 v_0 := v.Args[0] 28665 if v_0.Op != OpStructMake3 { 28666 break 28667 } 28668 _ = v_0.Args[2] 28669 x := v_0.Args[0] 28670 v.reset(OpCopy) 28671 v.Type = x.Type 28672 v.AddArg(x) 28673 return true 28674 } 28675 // match: (StructSelect [1] (StructMake3 _ x _)) 28676 // cond: 28677 // result: x 28678 for { 28679 if v.AuxInt != 1 { 28680 break 28681 } 28682 v_0 := v.Args[0] 28683 if v_0.Op != OpStructMake3 { 28684 break 28685 } 28686 _ = v_0.Args[2] 28687 x := v_0.Args[1] 28688 v.reset(OpCopy) 28689 v.Type = x.Type 28690 v.AddArg(x) 28691 return true 28692 } 28693 // match: (StructSelect [2] (StructMake3 _ _ x)) 28694 // cond: 28695 // result: x 28696 for { 28697 if v.AuxInt != 2 { 28698 break 28699 } 28700 v_0 := v.Args[0] 28701 if v_0.Op != OpStructMake3 { 28702 break 28703 } 28704 _ = v_0.Args[2] 28705 x := v_0.Args[2] 28706 v.reset(OpCopy) 28707 v.Type = x.Type 28708 v.AddArg(x) 28709 return true 28710 } 28711 // match: (StructSelect [0] (StructMake4 x _ _ _)) 28712 // cond: 28713 // result: x 28714 for { 28715 if v.AuxInt != 0 { 28716 break 28717 } 28718 v_0 := v.Args[0] 28719 if v_0.Op != OpStructMake4 { 28720 break 28721 } 28722 _ = v_0.Args[3] 28723 x := v_0.Args[0] 28724 v.reset(OpCopy) 28725 v.Type = x.Type 28726 v.AddArg(x) 28727 return true 28728 } 28729 // match: (StructSelect [1] (StructMake4 _ x _ _)) 28730 // cond: 28731 // result: x 28732 for { 28733 if v.AuxInt != 1 { 28734 break 28735 } 28736 v_0 := v.Args[0] 28737 if v_0.Op != OpStructMake4 { 28738 break 28739 } 28740 _ = v_0.Args[3] 28741 x := v_0.Args[1] 28742 v.reset(OpCopy) 28743 v.Type = x.Type 28744 v.AddArg(x) 28745 return true 28746 } 28747 // match: (StructSelect [2] (StructMake4 _ _ x _)) 28748 // cond: 28749 // result: x 28750 for { 28751 if v.AuxInt != 2 { 28752 break 28753 } 28754 v_0 := v.Args[0] 28755 if v_0.Op != OpStructMake4 { 28756 break 28757 } 28758 _ = v_0.Args[3] 28759 x := v_0.Args[2] 28760 v.reset(OpCopy) 28761 v.Type = x.Type 28762 v.AddArg(x) 28763 return true 28764 } 28765 // match: (StructSelect [3] (StructMake4 _ _ _ x)) 28766 // cond: 28767 // result: x 28768 for { 28769 if v.AuxInt != 3 { 28770 break 28771 } 28772 v_0 := v.Args[0] 28773 if v_0.Op != OpStructMake4 { 28774 break 28775 } 28776 _ = v_0.Args[3] 28777 x := v_0.Args[3] 28778 v.reset(OpCopy) 28779 v.Type = x.Type 28780 v.AddArg(x) 28781 return true 28782 } 28783 return false 28784 } 28785 func rewriteValuegeneric_OpStructSelect_10(v *Value) bool { 28786 b := v.Block 28787 _ = b 28788 fe := b.Func.fe 28789 _ = fe 28790 // match: (StructSelect [i] x:(Load <t> ptr mem)) 28791 // cond: !fe.CanSSA(t) 28792 // result: @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(int(i))] ptr) mem) 28793 for { 28794 i := v.AuxInt 28795 x := v.Args[0] 28796 if x.Op != OpLoad { 28797 break 28798 } 28799 t := x.Type 28800 _ = x.Args[1] 28801 ptr := x.Args[0] 28802 mem := x.Args[1] 28803 if !(!fe.CanSSA(t)) { 28804 break 28805 } 28806 b = x.Block 28807 v0 := b.NewValue0(v.Pos, OpLoad, v.Type) 28808 v.reset(OpCopy) 28809 v.AddArg(v0) 28810 v1 := b.NewValue0(v.Pos, OpOffPtr, v.Type.PtrTo()) 28811 v1.AuxInt = t.FieldOff(int(i)) 28812 v1.AddArg(ptr) 28813 v0.AddArg(v1) 28814 v0.AddArg(mem) 28815 return true 28816 } 28817 // match: (StructSelect [0] x:(IData _)) 28818 // cond: 28819 // result: x 28820 for { 28821 if v.AuxInt != 0 { 28822 break 28823 } 28824 x := v.Args[0] 28825 if x.Op != OpIData { 28826 break 28827 } 28828 v.reset(OpCopy) 28829 v.Type = x.Type 28830 v.AddArg(x) 28831 return true 28832 } 28833 return false 28834 } 28835 func rewriteValuegeneric_OpSub16_0(v *Value) bool { 28836 b := v.Block 28837 _ = b 28838 // match: (Sub16 (Const16 [c]) (Const16 [d])) 28839 // cond: 28840 // result: (Const16 [int64(int16(c-d))]) 28841 for { 28842 _ = v.Args[1] 28843 v_0 := v.Args[0] 28844 if v_0.Op != OpConst16 { 28845 break 28846 } 28847 c := v_0.AuxInt 28848 v_1 := v.Args[1] 28849 if v_1.Op != OpConst16 { 28850 break 28851 } 28852 d := v_1.AuxInt 28853 v.reset(OpConst16) 28854 v.AuxInt = int64(int16(c - d)) 28855 return true 28856 } 28857 // match: (Sub16 x (Const16 <t> [c])) 28858 // cond: x.Op != OpConst16 28859 // result: (Add16 (Const16 <t> [int64(int16(-c))]) x) 28860 for { 28861 _ = v.Args[1] 28862 x := v.Args[0] 28863 v_1 := v.Args[1] 28864 if v_1.Op != OpConst16 { 28865 break 28866 } 28867 t := v_1.Type 28868 c := v_1.AuxInt 28869 if !(x.Op != OpConst16) { 28870 break 28871 } 28872 v.reset(OpAdd16) 28873 v0 := b.NewValue0(v.Pos, OpConst16, t) 28874 v0.AuxInt = int64(int16(-c)) 28875 v.AddArg(v0) 28876 v.AddArg(x) 28877 return true 28878 } 28879 // match: (Sub16 <t> (Mul16 x y) (Mul16 x z)) 28880 // cond: 28881 // result: (Mul16 x (Sub16 <t> y z)) 28882 for { 28883 t := v.Type 28884 _ = v.Args[1] 28885 v_0 := v.Args[0] 28886 if v_0.Op != OpMul16 { 28887 break 28888 } 28889 _ = v_0.Args[1] 28890 x := v_0.Args[0] 28891 y := v_0.Args[1] 28892 v_1 := v.Args[1] 28893 if v_1.Op != OpMul16 { 28894 break 28895 } 28896 _ = v_1.Args[1] 28897 if x != v_1.Args[0] { 28898 break 28899 } 28900 z := v_1.Args[1] 28901 v.reset(OpMul16) 28902 v.AddArg(x) 28903 v0 := b.NewValue0(v.Pos, OpSub16, t) 28904 v0.AddArg(y) 28905 v0.AddArg(z) 28906 v.AddArg(v0) 28907 return true 28908 } 28909 // match: (Sub16 <t> (Mul16 y x) (Mul16 x z)) 28910 // cond: 28911 // result: (Mul16 x (Sub16 <t> y z)) 28912 for { 28913 t := v.Type 28914 _ = v.Args[1] 28915 v_0 := v.Args[0] 28916 if v_0.Op != OpMul16 { 28917 break 28918 } 28919 _ = v_0.Args[1] 28920 y := v_0.Args[0] 28921 x := v_0.Args[1] 28922 v_1 := v.Args[1] 28923 if v_1.Op != OpMul16 { 28924 break 28925 } 28926 _ = v_1.Args[1] 28927 if x != v_1.Args[0] { 28928 break 28929 } 28930 z := v_1.Args[1] 28931 v.reset(OpMul16) 28932 v.AddArg(x) 28933 v0 := b.NewValue0(v.Pos, OpSub16, t) 28934 v0.AddArg(y) 28935 v0.AddArg(z) 28936 v.AddArg(v0) 28937 return true 28938 } 28939 // match: (Sub16 <t> (Mul16 x y) (Mul16 z x)) 28940 // cond: 28941 // result: (Mul16 x (Sub16 <t> y z)) 28942 for { 28943 t := v.Type 28944 _ = v.Args[1] 28945 v_0 := v.Args[0] 28946 if v_0.Op != OpMul16 { 28947 break 28948 } 28949 _ = v_0.Args[1] 28950 x := v_0.Args[0] 28951 y := v_0.Args[1] 28952 v_1 := v.Args[1] 28953 if v_1.Op != OpMul16 { 28954 break 28955 } 28956 _ = v_1.Args[1] 28957 z := v_1.Args[0] 28958 if x != v_1.Args[1] { 28959 break 28960 } 28961 v.reset(OpMul16) 28962 v.AddArg(x) 28963 v0 := b.NewValue0(v.Pos, OpSub16, t) 28964 v0.AddArg(y) 28965 v0.AddArg(z) 28966 v.AddArg(v0) 28967 return true 28968 } 28969 // match: (Sub16 <t> (Mul16 y x) (Mul16 z x)) 28970 // cond: 28971 // result: (Mul16 x (Sub16 <t> y z)) 28972 for { 28973 t := v.Type 28974 _ = v.Args[1] 28975 v_0 := v.Args[0] 28976 if v_0.Op != OpMul16 { 28977 break 28978 } 28979 _ = v_0.Args[1] 28980 y := v_0.Args[0] 28981 x := v_0.Args[1] 28982 v_1 := v.Args[1] 28983 if v_1.Op != OpMul16 { 28984 break 28985 } 28986 _ = v_1.Args[1] 28987 z := v_1.Args[0] 28988 if x != v_1.Args[1] { 28989 break 28990 } 28991 v.reset(OpMul16) 28992 v.AddArg(x) 28993 v0 := b.NewValue0(v.Pos, OpSub16, t) 28994 v0.AddArg(y) 28995 v0.AddArg(z) 28996 v.AddArg(v0) 28997 return true 28998 } 28999 // match: (Sub16 x x) 29000 // cond: 29001 // result: (Const16 [0]) 29002 for { 29003 _ = v.Args[1] 29004 x := v.Args[0] 29005 if x != v.Args[1] { 29006 break 29007 } 29008 v.reset(OpConst16) 29009 v.AuxInt = 0 29010 return true 29011 } 29012 // match: (Sub16 (Add16 x y) x) 29013 // cond: 29014 // result: y 29015 for { 29016 _ = v.Args[1] 29017 v_0 := v.Args[0] 29018 if v_0.Op != OpAdd16 { 29019 break 29020 } 29021 _ = v_0.Args[1] 29022 x := v_0.Args[0] 29023 y := v_0.Args[1] 29024 if x != v.Args[1] { 29025 break 29026 } 29027 v.reset(OpCopy) 29028 v.Type = y.Type 29029 v.AddArg(y) 29030 return true 29031 } 29032 // match: (Sub16 (Add16 y x) x) 29033 // cond: 29034 // result: y 29035 for { 29036 _ = v.Args[1] 29037 v_0 := v.Args[0] 29038 if v_0.Op != OpAdd16 { 29039 break 29040 } 29041 _ = v_0.Args[1] 29042 y := v_0.Args[0] 29043 x := v_0.Args[1] 29044 if x != v.Args[1] { 29045 break 29046 } 29047 v.reset(OpCopy) 29048 v.Type = y.Type 29049 v.AddArg(y) 29050 return true 29051 } 29052 // match: (Sub16 (Add16 x y) y) 29053 // cond: 29054 // result: x 29055 for { 29056 _ = v.Args[1] 29057 v_0 := v.Args[0] 29058 if v_0.Op != OpAdd16 { 29059 break 29060 } 29061 _ = v_0.Args[1] 29062 x := v_0.Args[0] 29063 y := v_0.Args[1] 29064 if y != v.Args[1] { 29065 break 29066 } 29067 v.reset(OpCopy) 29068 v.Type = x.Type 29069 v.AddArg(x) 29070 return true 29071 } 29072 return false 29073 } 29074 func rewriteValuegeneric_OpSub16_10(v *Value) bool { 29075 b := v.Block 29076 _ = b 29077 // match: (Sub16 (Add16 y x) y) 29078 // cond: 29079 // result: x 29080 for { 29081 _ = v.Args[1] 29082 v_0 := v.Args[0] 29083 if v_0.Op != OpAdd16 { 29084 break 29085 } 29086 _ = v_0.Args[1] 29087 y := v_0.Args[0] 29088 x := v_0.Args[1] 29089 if y != v.Args[1] { 29090 break 29091 } 29092 v.reset(OpCopy) 29093 v.Type = x.Type 29094 v.AddArg(x) 29095 return true 29096 } 29097 // match: (Sub16 x (Sub16 i:(Const16 <t>) z)) 29098 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 29099 // result: (Sub16 (Add16 <t> x z) i) 29100 for { 29101 _ = v.Args[1] 29102 x := v.Args[0] 29103 v_1 := v.Args[1] 29104 if v_1.Op != OpSub16 { 29105 break 29106 } 29107 _ = v_1.Args[1] 29108 i := v_1.Args[0] 29109 if i.Op != OpConst16 { 29110 break 29111 } 29112 t := i.Type 29113 z := v_1.Args[1] 29114 if !(z.Op != OpConst16 && x.Op != OpConst16) { 29115 break 29116 } 29117 v.reset(OpSub16) 29118 v0 := b.NewValue0(v.Pos, OpAdd16, t) 29119 v0.AddArg(x) 29120 v0.AddArg(z) 29121 v.AddArg(v0) 29122 v.AddArg(i) 29123 return true 29124 } 29125 // match: (Sub16 x (Sub16 z i:(Const16 <t>))) 29126 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 29127 // result: (Add16 i (Sub16 <t> x z)) 29128 for { 29129 _ = v.Args[1] 29130 x := v.Args[0] 29131 v_1 := v.Args[1] 29132 if v_1.Op != OpSub16 { 29133 break 29134 } 29135 _ = v_1.Args[1] 29136 z := v_1.Args[0] 29137 i := v_1.Args[1] 29138 if i.Op != OpConst16 { 29139 break 29140 } 29141 t := i.Type 29142 if !(z.Op != OpConst16 && x.Op != OpConst16) { 29143 break 29144 } 29145 v.reset(OpAdd16) 29146 v.AddArg(i) 29147 v0 := b.NewValue0(v.Pos, OpSub16, t) 29148 v0.AddArg(x) 29149 v0.AddArg(z) 29150 v.AddArg(v0) 29151 return true 29152 } 29153 // match: (Sub16 (Const16 <t> [c]) (Sub16 x (Const16 <t> [d]))) 29154 // cond: 29155 // result: (Sub16 (Const16 <t> [int64(int16(c+d))]) x) 29156 for { 29157 _ = v.Args[1] 29158 v_0 := v.Args[0] 29159 if v_0.Op != OpConst16 { 29160 break 29161 } 29162 t := v_0.Type 29163 c := v_0.AuxInt 29164 v_1 := v.Args[1] 29165 if v_1.Op != OpSub16 { 29166 break 29167 } 29168 _ = v_1.Args[1] 29169 x := v_1.Args[0] 29170 v_1_1 := v_1.Args[1] 29171 if v_1_1.Op != OpConst16 { 29172 break 29173 } 29174 if v_1_1.Type != t { 29175 break 29176 } 29177 d := v_1_1.AuxInt 29178 v.reset(OpSub16) 29179 v0 := b.NewValue0(v.Pos, OpConst16, t) 29180 v0.AuxInt = int64(int16(c + d)) 29181 v.AddArg(v0) 29182 v.AddArg(x) 29183 return true 29184 } 29185 // match: (Sub16 (Const16 <t> [c]) (Sub16 (Const16 <t> [d]) x)) 29186 // cond: 29187 // result: (Add16 (Const16 <t> [int64(int16(c-d))]) x) 29188 for { 29189 _ = v.Args[1] 29190 v_0 := v.Args[0] 29191 if v_0.Op != OpConst16 { 29192 break 29193 } 29194 t := v_0.Type 29195 c := v_0.AuxInt 29196 v_1 := v.Args[1] 29197 if v_1.Op != OpSub16 { 29198 break 29199 } 29200 _ = v_1.Args[1] 29201 v_1_0 := v_1.Args[0] 29202 if v_1_0.Op != OpConst16 { 29203 break 29204 } 29205 if v_1_0.Type != t { 29206 break 29207 } 29208 d := v_1_0.AuxInt 29209 x := v_1.Args[1] 29210 v.reset(OpAdd16) 29211 v0 := b.NewValue0(v.Pos, OpConst16, t) 29212 v0.AuxInt = int64(int16(c - d)) 29213 v.AddArg(v0) 29214 v.AddArg(x) 29215 return true 29216 } 29217 return false 29218 } 29219 func rewriteValuegeneric_OpSub32_0(v *Value) bool { 29220 b := v.Block 29221 _ = b 29222 // match: (Sub32 (Const32 [c]) (Const32 [d])) 29223 // cond: 29224 // result: (Const32 [int64(int32(c-d))]) 29225 for { 29226 _ = v.Args[1] 29227 v_0 := v.Args[0] 29228 if v_0.Op != OpConst32 { 29229 break 29230 } 29231 c := v_0.AuxInt 29232 v_1 := v.Args[1] 29233 if v_1.Op != OpConst32 { 29234 break 29235 } 29236 d := v_1.AuxInt 29237 v.reset(OpConst32) 29238 v.AuxInt = int64(int32(c - d)) 29239 return true 29240 } 29241 // match: (Sub32 x (Const32 <t> [c])) 29242 // cond: x.Op != OpConst32 29243 // result: (Add32 (Const32 <t> [int64(int32(-c))]) x) 29244 for { 29245 _ = v.Args[1] 29246 x := v.Args[0] 29247 v_1 := v.Args[1] 29248 if v_1.Op != OpConst32 { 29249 break 29250 } 29251 t := v_1.Type 29252 c := v_1.AuxInt 29253 if !(x.Op != OpConst32) { 29254 break 29255 } 29256 v.reset(OpAdd32) 29257 v0 := b.NewValue0(v.Pos, OpConst32, t) 29258 v0.AuxInt = int64(int32(-c)) 29259 v.AddArg(v0) 29260 v.AddArg(x) 29261 return true 29262 } 29263 // match: (Sub32 <t> (Mul32 x y) (Mul32 x z)) 29264 // cond: 29265 // result: (Mul32 x (Sub32 <t> y z)) 29266 for { 29267 t := v.Type 29268 _ = v.Args[1] 29269 v_0 := v.Args[0] 29270 if v_0.Op != OpMul32 { 29271 break 29272 } 29273 _ = v_0.Args[1] 29274 x := v_0.Args[0] 29275 y := v_0.Args[1] 29276 v_1 := v.Args[1] 29277 if v_1.Op != OpMul32 { 29278 break 29279 } 29280 _ = v_1.Args[1] 29281 if x != v_1.Args[0] { 29282 break 29283 } 29284 z := v_1.Args[1] 29285 v.reset(OpMul32) 29286 v.AddArg(x) 29287 v0 := b.NewValue0(v.Pos, OpSub32, t) 29288 v0.AddArg(y) 29289 v0.AddArg(z) 29290 v.AddArg(v0) 29291 return true 29292 } 29293 // match: (Sub32 <t> (Mul32 y x) (Mul32 x z)) 29294 // cond: 29295 // result: (Mul32 x (Sub32 <t> y z)) 29296 for { 29297 t := v.Type 29298 _ = v.Args[1] 29299 v_0 := v.Args[0] 29300 if v_0.Op != OpMul32 { 29301 break 29302 } 29303 _ = v_0.Args[1] 29304 y := v_0.Args[0] 29305 x := v_0.Args[1] 29306 v_1 := v.Args[1] 29307 if v_1.Op != OpMul32 { 29308 break 29309 } 29310 _ = v_1.Args[1] 29311 if x != v_1.Args[0] { 29312 break 29313 } 29314 z := v_1.Args[1] 29315 v.reset(OpMul32) 29316 v.AddArg(x) 29317 v0 := b.NewValue0(v.Pos, OpSub32, t) 29318 v0.AddArg(y) 29319 v0.AddArg(z) 29320 v.AddArg(v0) 29321 return true 29322 } 29323 // match: (Sub32 <t> (Mul32 x y) (Mul32 z x)) 29324 // cond: 29325 // result: (Mul32 x (Sub32 <t> y z)) 29326 for { 29327 t := v.Type 29328 _ = v.Args[1] 29329 v_0 := v.Args[0] 29330 if v_0.Op != OpMul32 { 29331 break 29332 } 29333 _ = v_0.Args[1] 29334 x := v_0.Args[0] 29335 y := v_0.Args[1] 29336 v_1 := v.Args[1] 29337 if v_1.Op != OpMul32 { 29338 break 29339 } 29340 _ = v_1.Args[1] 29341 z := v_1.Args[0] 29342 if x != v_1.Args[1] { 29343 break 29344 } 29345 v.reset(OpMul32) 29346 v.AddArg(x) 29347 v0 := b.NewValue0(v.Pos, OpSub32, t) 29348 v0.AddArg(y) 29349 v0.AddArg(z) 29350 v.AddArg(v0) 29351 return true 29352 } 29353 // match: (Sub32 <t> (Mul32 y x) (Mul32 z x)) 29354 // cond: 29355 // result: (Mul32 x (Sub32 <t> y z)) 29356 for { 29357 t := v.Type 29358 _ = v.Args[1] 29359 v_0 := v.Args[0] 29360 if v_0.Op != OpMul32 { 29361 break 29362 } 29363 _ = v_0.Args[1] 29364 y := v_0.Args[0] 29365 x := v_0.Args[1] 29366 v_1 := v.Args[1] 29367 if v_1.Op != OpMul32 { 29368 break 29369 } 29370 _ = v_1.Args[1] 29371 z := v_1.Args[0] 29372 if x != v_1.Args[1] { 29373 break 29374 } 29375 v.reset(OpMul32) 29376 v.AddArg(x) 29377 v0 := b.NewValue0(v.Pos, OpSub32, t) 29378 v0.AddArg(y) 29379 v0.AddArg(z) 29380 v.AddArg(v0) 29381 return true 29382 } 29383 // match: (Sub32 x x) 29384 // cond: 29385 // result: (Const32 [0]) 29386 for { 29387 _ = v.Args[1] 29388 x := v.Args[0] 29389 if x != v.Args[1] { 29390 break 29391 } 29392 v.reset(OpConst32) 29393 v.AuxInt = 0 29394 return true 29395 } 29396 // match: (Sub32 (Add32 x y) x) 29397 // cond: 29398 // result: y 29399 for { 29400 _ = v.Args[1] 29401 v_0 := v.Args[0] 29402 if v_0.Op != OpAdd32 { 29403 break 29404 } 29405 _ = v_0.Args[1] 29406 x := v_0.Args[0] 29407 y := v_0.Args[1] 29408 if x != v.Args[1] { 29409 break 29410 } 29411 v.reset(OpCopy) 29412 v.Type = y.Type 29413 v.AddArg(y) 29414 return true 29415 } 29416 // match: (Sub32 (Add32 y x) x) 29417 // cond: 29418 // result: y 29419 for { 29420 _ = v.Args[1] 29421 v_0 := v.Args[0] 29422 if v_0.Op != OpAdd32 { 29423 break 29424 } 29425 _ = v_0.Args[1] 29426 y := v_0.Args[0] 29427 x := v_0.Args[1] 29428 if x != v.Args[1] { 29429 break 29430 } 29431 v.reset(OpCopy) 29432 v.Type = y.Type 29433 v.AddArg(y) 29434 return true 29435 } 29436 // match: (Sub32 (Add32 x y) y) 29437 // cond: 29438 // result: x 29439 for { 29440 _ = v.Args[1] 29441 v_0 := v.Args[0] 29442 if v_0.Op != OpAdd32 { 29443 break 29444 } 29445 _ = v_0.Args[1] 29446 x := v_0.Args[0] 29447 y := v_0.Args[1] 29448 if y != v.Args[1] { 29449 break 29450 } 29451 v.reset(OpCopy) 29452 v.Type = x.Type 29453 v.AddArg(x) 29454 return true 29455 } 29456 return false 29457 } 29458 func rewriteValuegeneric_OpSub32_10(v *Value) bool { 29459 b := v.Block 29460 _ = b 29461 // match: (Sub32 (Add32 y x) y) 29462 // cond: 29463 // result: x 29464 for { 29465 _ = v.Args[1] 29466 v_0 := v.Args[0] 29467 if v_0.Op != OpAdd32 { 29468 break 29469 } 29470 _ = v_0.Args[1] 29471 y := v_0.Args[0] 29472 x := v_0.Args[1] 29473 if y != v.Args[1] { 29474 break 29475 } 29476 v.reset(OpCopy) 29477 v.Type = x.Type 29478 v.AddArg(x) 29479 return true 29480 } 29481 // match: (Sub32 x (Sub32 i:(Const32 <t>) z)) 29482 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 29483 // result: (Sub32 (Add32 <t> x z) i) 29484 for { 29485 _ = v.Args[1] 29486 x := v.Args[0] 29487 v_1 := v.Args[1] 29488 if v_1.Op != OpSub32 { 29489 break 29490 } 29491 _ = v_1.Args[1] 29492 i := v_1.Args[0] 29493 if i.Op != OpConst32 { 29494 break 29495 } 29496 t := i.Type 29497 z := v_1.Args[1] 29498 if !(z.Op != OpConst32 && x.Op != OpConst32) { 29499 break 29500 } 29501 v.reset(OpSub32) 29502 v0 := b.NewValue0(v.Pos, OpAdd32, t) 29503 v0.AddArg(x) 29504 v0.AddArg(z) 29505 v.AddArg(v0) 29506 v.AddArg(i) 29507 return true 29508 } 29509 // match: (Sub32 x (Sub32 z i:(Const32 <t>))) 29510 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 29511 // result: (Add32 i (Sub32 <t> x z)) 29512 for { 29513 _ = v.Args[1] 29514 x := v.Args[0] 29515 v_1 := v.Args[1] 29516 if v_1.Op != OpSub32 { 29517 break 29518 } 29519 _ = v_1.Args[1] 29520 z := v_1.Args[0] 29521 i := v_1.Args[1] 29522 if i.Op != OpConst32 { 29523 break 29524 } 29525 t := i.Type 29526 if !(z.Op != OpConst32 && x.Op != OpConst32) { 29527 break 29528 } 29529 v.reset(OpAdd32) 29530 v.AddArg(i) 29531 v0 := b.NewValue0(v.Pos, OpSub32, t) 29532 v0.AddArg(x) 29533 v0.AddArg(z) 29534 v.AddArg(v0) 29535 return true 29536 } 29537 // match: (Sub32 (Const32 <t> [c]) (Sub32 x (Const32 <t> [d]))) 29538 // cond: 29539 // result: (Sub32 (Const32 <t> [int64(int32(c+d))]) x) 29540 for { 29541 _ = v.Args[1] 29542 v_0 := v.Args[0] 29543 if v_0.Op != OpConst32 { 29544 break 29545 } 29546 t := v_0.Type 29547 c := v_0.AuxInt 29548 v_1 := v.Args[1] 29549 if v_1.Op != OpSub32 { 29550 break 29551 } 29552 _ = v_1.Args[1] 29553 x := v_1.Args[0] 29554 v_1_1 := v_1.Args[1] 29555 if v_1_1.Op != OpConst32 { 29556 break 29557 } 29558 if v_1_1.Type != t { 29559 break 29560 } 29561 d := v_1_1.AuxInt 29562 v.reset(OpSub32) 29563 v0 := b.NewValue0(v.Pos, OpConst32, t) 29564 v0.AuxInt = int64(int32(c + d)) 29565 v.AddArg(v0) 29566 v.AddArg(x) 29567 return true 29568 } 29569 // match: (Sub32 (Const32 <t> [c]) (Sub32 (Const32 <t> [d]) x)) 29570 // cond: 29571 // result: (Add32 (Const32 <t> [int64(int32(c-d))]) x) 29572 for { 29573 _ = v.Args[1] 29574 v_0 := v.Args[0] 29575 if v_0.Op != OpConst32 { 29576 break 29577 } 29578 t := v_0.Type 29579 c := v_0.AuxInt 29580 v_1 := v.Args[1] 29581 if v_1.Op != OpSub32 { 29582 break 29583 } 29584 _ = v_1.Args[1] 29585 v_1_0 := v_1.Args[0] 29586 if v_1_0.Op != OpConst32 { 29587 break 29588 } 29589 if v_1_0.Type != t { 29590 break 29591 } 29592 d := v_1_0.AuxInt 29593 x := v_1.Args[1] 29594 v.reset(OpAdd32) 29595 v0 := b.NewValue0(v.Pos, OpConst32, t) 29596 v0.AuxInt = int64(int32(c - d)) 29597 v.AddArg(v0) 29598 v.AddArg(x) 29599 return true 29600 } 29601 return false 29602 } 29603 func rewriteValuegeneric_OpSub32F_0(v *Value) bool { 29604 // match: (Sub32F (Const32F [c]) (Const32F [d])) 29605 // cond: 29606 // result: (Const32F [auxFrom32F(auxTo32F(c) - auxTo32F(d))]) 29607 for { 29608 _ = v.Args[1] 29609 v_0 := v.Args[0] 29610 if v_0.Op != OpConst32F { 29611 break 29612 } 29613 c := v_0.AuxInt 29614 v_1 := v.Args[1] 29615 if v_1.Op != OpConst32F { 29616 break 29617 } 29618 d := v_1.AuxInt 29619 v.reset(OpConst32F) 29620 v.AuxInt = auxFrom32F(auxTo32F(c) - auxTo32F(d)) 29621 return true 29622 } 29623 return false 29624 } 29625 func rewriteValuegeneric_OpSub64_0(v *Value) bool { 29626 b := v.Block 29627 _ = b 29628 // match: (Sub64 (Const64 [c]) (Const64 [d])) 29629 // cond: 29630 // result: (Const64 [c-d]) 29631 for { 29632 _ = v.Args[1] 29633 v_0 := v.Args[0] 29634 if v_0.Op != OpConst64 { 29635 break 29636 } 29637 c := v_0.AuxInt 29638 v_1 := v.Args[1] 29639 if v_1.Op != OpConst64 { 29640 break 29641 } 29642 d := v_1.AuxInt 29643 v.reset(OpConst64) 29644 v.AuxInt = c - d 29645 return true 29646 } 29647 // match: (Sub64 x (Const64 <t> [c])) 29648 // cond: x.Op != OpConst64 29649 // result: (Add64 (Const64 <t> [-c]) x) 29650 for { 29651 _ = v.Args[1] 29652 x := v.Args[0] 29653 v_1 := v.Args[1] 29654 if v_1.Op != OpConst64 { 29655 break 29656 } 29657 t := v_1.Type 29658 c := v_1.AuxInt 29659 if !(x.Op != OpConst64) { 29660 break 29661 } 29662 v.reset(OpAdd64) 29663 v0 := b.NewValue0(v.Pos, OpConst64, t) 29664 v0.AuxInt = -c 29665 v.AddArg(v0) 29666 v.AddArg(x) 29667 return true 29668 } 29669 // match: (Sub64 <t> (Mul64 x y) (Mul64 x z)) 29670 // cond: 29671 // result: (Mul64 x (Sub64 <t> y z)) 29672 for { 29673 t := v.Type 29674 _ = v.Args[1] 29675 v_0 := v.Args[0] 29676 if v_0.Op != OpMul64 { 29677 break 29678 } 29679 _ = v_0.Args[1] 29680 x := v_0.Args[0] 29681 y := v_0.Args[1] 29682 v_1 := v.Args[1] 29683 if v_1.Op != OpMul64 { 29684 break 29685 } 29686 _ = v_1.Args[1] 29687 if x != v_1.Args[0] { 29688 break 29689 } 29690 z := v_1.Args[1] 29691 v.reset(OpMul64) 29692 v.AddArg(x) 29693 v0 := b.NewValue0(v.Pos, OpSub64, t) 29694 v0.AddArg(y) 29695 v0.AddArg(z) 29696 v.AddArg(v0) 29697 return true 29698 } 29699 // match: (Sub64 <t> (Mul64 y x) (Mul64 x z)) 29700 // cond: 29701 // result: (Mul64 x (Sub64 <t> y z)) 29702 for { 29703 t := v.Type 29704 _ = v.Args[1] 29705 v_0 := v.Args[0] 29706 if v_0.Op != OpMul64 { 29707 break 29708 } 29709 _ = v_0.Args[1] 29710 y := v_0.Args[0] 29711 x := v_0.Args[1] 29712 v_1 := v.Args[1] 29713 if v_1.Op != OpMul64 { 29714 break 29715 } 29716 _ = v_1.Args[1] 29717 if x != v_1.Args[0] { 29718 break 29719 } 29720 z := v_1.Args[1] 29721 v.reset(OpMul64) 29722 v.AddArg(x) 29723 v0 := b.NewValue0(v.Pos, OpSub64, t) 29724 v0.AddArg(y) 29725 v0.AddArg(z) 29726 v.AddArg(v0) 29727 return true 29728 } 29729 // match: (Sub64 <t> (Mul64 x y) (Mul64 z x)) 29730 // cond: 29731 // result: (Mul64 x (Sub64 <t> y z)) 29732 for { 29733 t := v.Type 29734 _ = v.Args[1] 29735 v_0 := v.Args[0] 29736 if v_0.Op != OpMul64 { 29737 break 29738 } 29739 _ = v_0.Args[1] 29740 x := v_0.Args[0] 29741 y := v_0.Args[1] 29742 v_1 := v.Args[1] 29743 if v_1.Op != OpMul64 { 29744 break 29745 } 29746 _ = v_1.Args[1] 29747 z := v_1.Args[0] 29748 if x != v_1.Args[1] { 29749 break 29750 } 29751 v.reset(OpMul64) 29752 v.AddArg(x) 29753 v0 := b.NewValue0(v.Pos, OpSub64, t) 29754 v0.AddArg(y) 29755 v0.AddArg(z) 29756 v.AddArg(v0) 29757 return true 29758 } 29759 // match: (Sub64 <t> (Mul64 y x) (Mul64 z x)) 29760 // cond: 29761 // result: (Mul64 x (Sub64 <t> y z)) 29762 for { 29763 t := v.Type 29764 _ = v.Args[1] 29765 v_0 := v.Args[0] 29766 if v_0.Op != OpMul64 { 29767 break 29768 } 29769 _ = v_0.Args[1] 29770 y := v_0.Args[0] 29771 x := v_0.Args[1] 29772 v_1 := v.Args[1] 29773 if v_1.Op != OpMul64 { 29774 break 29775 } 29776 _ = v_1.Args[1] 29777 z := v_1.Args[0] 29778 if x != v_1.Args[1] { 29779 break 29780 } 29781 v.reset(OpMul64) 29782 v.AddArg(x) 29783 v0 := b.NewValue0(v.Pos, OpSub64, t) 29784 v0.AddArg(y) 29785 v0.AddArg(z) 29786 v.AddArg(v0) 29787 return true 29788 } 29789 // match: (Sub64 x x) 29790 // cond: 29791 // result: (Const64 [0]) 29792 for { 29793 _ = v.Args[1] 29794 x := v.Args[0] 29795 if x != v.Args[1] { 29796 break 29797 } 29798 v.reset(OpConst64) 29799 v.AuxInt = 0 29800 return true 29801 } 29802 // match: (Sub64 (Add64 x y) x) 29803 // cond: 29804 // result: y 29805 for { 29806 _ = v.Args[1] 29807 v_0 := v.Args[0] 29808 if v_0.Op != OpAdd64 { 29809 break 29810 } 29811 _ = v_0.Args[1] 29812 x := v_0.Args[0] 29813 y := v_0.Args[1] 29814 if x != v.Args[1] { 29815 break 29816 } 29817 v.reset(OpCopy) 29818 v.Type = y.Type 29819 v.AddArg(y) 29820 return true 29821 } 29822 // match: (Sub64 (Add64 y x) x) 29823 // cond: 29824 // result: y 29825 for { 29826 _ = v.Args[1] 29827 v_0 := v.Args[0] 29828 if v_0.Op != OpAdd64 { 29829 break 29830 } 29831 _ = v_0.Args[1] 29832 y := v_0.Args[0] 29833 x := v_0.Args[1] 29834 if x != v.Args[1] { 29835 break 29836 } 29837 v.reset(OpCopy) 29838 v.Type = y.Type 29839 v.AddArg(y) 29840 return true 29841 } 29842 // match: (Sub64 (Add64 x y) y) 29843 // cond: 29844 // result: x 29845 for { 29846 _ = v.Args[1] 29847 v_0 := v.Args[0] 29848 if v_0.Op != OpAdd64 { 29849 break 29850 } 29851 _ = v_0.Args[1] 29852 x := v_0.Args[0] 29853 y := v_0.Args[1] 29854 if y != v.Args[1] { 29855 break 29856 } 29857 v.reset(OpCopy) 29858 v.Type = x.Type 29859 v.AddArg(x) 29860 return true 29861 } 29862 return false 29863 } 29864 func rewriteValuegeneric_OpSub64_10(v *Value) bool { 29865 b := v.Block 29866 _ = b 29867 // match: (Sub64 (Add64 y x) y) 29868 // cond: 29869 // result: x 29870 for { 29871 _ = v.Args[1] 29872 v_0 := v.Args[0] 29873 if v_0.Op != OpAdd64 { 29874 break 29875 } 29876 _ = v_0.Args[1] 29877 y := v_0.Args[0] 29878 x := v_0.Args[1] 29879 if y != v.Args[1] { 29880 break 29881 } 29882 v.reset(OpCopy) 29883 v.Type = x.Type 29884 v.AddArg(x) 29885 return true 29886 } 29887 // match: (Sub64 x (Sub64 i:(Const64 <t>) z)) 29888 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 29889 // result: (Sub64 (Add64 <t> x z) i) 29890 for { 29891 _ = v.Args[1] 29892 x := v.Args[0] 29893 v_1 := v.Args[1] 29894 if v_1.Op != OpSub64 { 29895 break 29896 } 29897 _ = v_1.Args[1] 29898 i := v_1.Args[0] 29899 if i.Op != OpConst64 { 29900 break 29901 } 29902 t := i.Type 29903 z := v_1.Args[1] 29904 if !(z.Op != OpConst64 && x.Op != OpConst64) { 29905 break 29906 } 29907 v.reset(OpSub64) 29908 v0 := b.NewValue0(v.Pos, OpAdd64, t) 29909 v0.AddArg(x) 29910 v0.AddArg(z) 29911 v.AddArg(v0) 29912 v.AddArg(i) 29913 return true 29914 } 29915 // match: (Sub64 x (Sub64 z i:(Const64 <t>))) 29916 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 29917 // result: (Add64 i (Sub64 <t> x z)) 29918 for { 29919 _ = v.Args[1] 29920 x := v.Args[0] 29921 v_1 := v.Args[1] 29922 if v_1.Op != OpSub64 { 29923 break 29924 } 29925 _ = v_1.Args[1] 29926 z := v_1.Args[0] 29927 i := v_1.Args[1] 29928 if i.Op != OpConst64 { 29929 break 29930 } 29931 t := i.Type 29932 if !(z.Op != OpConst64 && x.Op != OpConst64) { 29933 break 29934 } 29935 v.reset(OpAdd64) 29936 v.AddArg(i) 29937 v0 := b.NewValue0(v.Pos, OpSub64, t) 29938 v0.AddArg(x) 29939 v0.AddArg(z) 29940 v.AddArg(v0) 29941 return true 29942 } 29943 // match: (Sub64 (Const64 <t> [c]) (Sub64 x (Const64 <t> [d]))) 29944 // cond: 29945 // result: (Sub64 (Const64 <t> [c+d]) x) 29946 for { 29947 _ = v.Args[1] 29948 v_0 := v.Args[0] 29949 if v_0.Op != OpConst64 { 29950 break 29951 } 29952 t := v_0.Type 29953 c := v_0.AuxInt 29954 v_1 := v.Args[1] 29955 if v_1.Op != OpSub64 { 29956 break 29957 } 29958 _ = v_1.Args[1] 29959 x := v_1.Args[0] 29960 v_1_1 := v_1.Args[1] 29961 if v_1_1.Op != OpConst64 { 29962 break 29963 } 29964 if v_1_1.Type != t { 29965 break 29966 } 29967 d := v_1_1.AuxInt 29968 v.reset(OpSub64) 29969 v0 := b.NewValue0(v.Pos, OpConst64, t) 29970 v0.AuxInt = c + d 29971 v.AddArg(v0) 29972 v.AddArg(x) 29973 return true 29974 } 29975 // match: (Sub64 (Const64 <t> [c]) (Sub64 (Const64 <t> [d]) x)) 29976 // cond: 29977 // result: (Add64 (Const64 <t> [c-d]) x) 29978 for { 29979 _ = v.Args[1] 29980 v_0 := v.Args[0] 29981 if v_0.Op != OpConst64 { 29982 break 29983 } 29984 t := v_0.Type 29985 c := v_0.AuxInt 29986 v_1 := v.Args[1] 29987 if v_1.Op != OpSub64 { 29988 break 29989 } 29990 _ = v_1.Args[1] 29991 v_1_0 := v_1.Args[0] 29992 if v_1_0.Op != OpConst64 { 29993 break 29994 } 29995 if v_1_0.Type != t { 29996 break 29997 } 29998 d := v_1_0.AuxInt 29999 x := v_1.Args[1] 30000 v.reset(OpAdd64) 30001 v0 := b.NewValue0(v.Pos, OpConst64, t) 30002 v0.AuxInt = c - d 30003 v.AddArg(v0) 30004 v.AddArg(x) 30005 return true 30006 } 30007 return false 30008 } 30009 func rewriteValuegeneric_OpSub64F_0(v *Value) bool { 30010 // match: (Sub64F (Const64F [c]) (Const64F [d])) 30011 // cond: 30012 // result: (Const64F [auxFrom64F(auxTo64F(c) - auxTo64F(d))]) 30013 for { 30014 _ = v.Args[1] 30015 v_0 := v.Args[0] 30016 if v_0.Op != OpConst64F { 30017 break 30018 } 30019 c := v_0.AuxInt 30020 v_1 := v.Args[1] 30021 if v_1.Op != OpConst64F { 30022 break 30023 } 30024 d := v_1.AuxInt 30025 v.reset(OpConst64F) 30026 v.AuxInt = auxFrom64F(auxTo64F(c) - auxTo64F(d)) 30027 return true 30028 } 30029 return false 30030 } 30031 func rewriteValuegeneric_OpSub8_0(v *Value) bool { 30032 b := v.Block 30033 _ = b 30034 // match: (Sub8 (Const8 [c]) (Const8 [d])) 30035 // cond: 30036 // result: (Const8 [int64(int8(c-d))]) 30037 for { 30038 _ = v.Args[1] 30039 v_0 := v.Args[0] 30040 if v_0.Op != OpConst8 { 30041 break 30042 } 30043 c := v_0.AuxInt 30044 v_1 := v.Args[1] 30045 if v_1.Op != OpConst8 { 30046 break 30047 } 30048 d := v_1.AuxInt 30049 v.reset(OpConst8) 30050 v.AuxInt = int64(int8(c - d)) 30051 return true 30052 } 30053 // match: (Sub8 x (Const8 <t> [c])) 30054 // cond: x.Op != OpConst8 30055 // result: (Add8 (Const8 <t> [int64(int8(-c))]) x) 30056 for { 30057 _ = v.Args[1] 30058 x := v.Args[0] 30059 v_1 := v.Args[1] 30060 if v_1.Op != OpConst8 { 30061 break 30062 } 30063 t := v_1.Type 30064 c := v_1.AuxInt 30065 if !(x.Op != OpConst8) { 30066 break 30067 } 30068 v.reset(OpAdd8) 30069 v0 := b.NewValue0(v.Pos, OpConst8, t) 30070 v0.AuxInt = int64(int8(-c)) 30071 v.AddArg(v0) 30072 v.AddArg(x) 30073 return true 30074 } 30075 // match: (Sub8 <t> (Mul8 x y) (Mul8 x z)) 30076 // cond: 30077 // result: (Mul8 x (Sub8 <t> y z)) 30078 for { 30079 t := v.Type 30080 _ = v.Args[1] 30081 v_0 := v.Args[0] 30082 if v_0.Op != OpMul8 { 30083 break 30084 } 30085 _ = v_0.Args[1] 30086 x := v_0.Args[0] 30087 y := v_0.Args[1] 30088 v_1 := v.Args[1] 30089 if v_1.Op != OpMul8 { 30090 break 30091 } 30092 _ = v_1.Args[1] 30093 if x != v_1.Args[0] { 30094 break 30095 } 30096 z := v_1.Args[1] 30097 v.reset(OpMul8) 30098 v.AddArg(x) 30099 v0 := b.NewValue0(v.Pos, OpSub8, t) 30100 v0.AddArg(y) 30101 v0.AddArg(z) 30102 v.AddArg(v0) 30103 return true 30104 } 30105 // match: (Sub8 <t> (Mul8 y x) (Mul8 x z)) 30106 // cond: 30107 // result: (Mul8 x (Sub8 <t> y z)) 30108 for { 30109 t := v.Type 30110 _ = v.Args[1] 30111 v_0 := v.Args[0] 30112 if v_0.Op != OpMul8 { 30113 break 30114 } 30115 _ = v_0.Args[1] 30116 y := v_0.Args[0] 30117 x := v_0.Args[1] 30118 v_1 := v.Args[1] 30119 if v_1.Op != OpMul8 { 30120 break 30121 } 30122 _ = v_1.Args[1] 30123 if x != v_1.Args[0] { 30124 break 30125 } 30126 z := v_1.Args[1] 30127 v.reset(OpMul8) 30128 v.AddArg(x) 30129 v0 := b.NewValue0(v.Pos, OpSub8, t) 30130 v0.AddArg(y) 30131 v0.AddArg(z) 30132 v.AddArg(v0) 30133 return true 30134 } 30135 // match: (Sub8 <t> (Mul8 x y) (Mul8 z x)) 30136 // cond: 30137 // result: (Mul8 x (Sub8 <t> y z)) 30138 for { 30139 t := v.Type 30140 _ = v.Args[1] 30141 v_0 := v.Args[0] 30142 if v_0.Op != OpMul8 { 30143 break 30144 } 30145 _ = v_0.Args[1] 30146 x := v_0.Args[0] 30147 y := v_0.Args[1] 30148 v_1 := v.Args[1] 30149 if v_1.Op != OpMul8 { 30150 break 30151 } 30152 _ = v_1.Args[1] 30153 z := v_1.Args[0] 30154 if x != v_1.Args[1] { 30155 break 30156 } 30157 v.reset(OpMul8) 30158 v.AddArg(x) 30159 v0 := b.NewValue0(v.Pos, OpSub8, t) 30160 v0.AddArg(y) 30161 v0.AddArg(z) 30162 v.AddArg(v0) 30163 return true 30164 } 30165 // match: (Sub8 <t> (Mul8 y x) (Mul8 z x)) 30166 // cond: 30167 // result: (Mul8 x (Sub8 <t> y z)) 30168 for { 30169 t := v.Type 30170 _ = v.Args[1] 30171 v_0 := v.Args[0] 30172 if v_0.Op != OpMul8 { 30173 break 30174 } 30175 _ = v_0.Args[1] 30176 y := v_0.Args[0] 30177 x := v_0.Args[1] 30178 v_1 := v.Args[1] 30179 if v_1.Op != OpMul8 { 30180 break 30181 } 30182 _ = v_1.Args[1] 30183 z := v_1.Args[0] 30184 if x != v_1.Args[1] { 30185 break 30186 } 30187 v.reset(OpMul8) 30188 v.AddArg(x) 30189 v0 := b.NewValue0(v.Pos, OpSub8, t) 30190 v0.AddArg(y) 30191 v0.AddArg(z) 30192 v.AddArg(v0) 30193 return true 30194 } 30195 // match: (Sub8 x x) 30196 // cond: 30197 // result: (Const8 [0]) 30198 for { 30199 _ = v.Args[1] 30200 x := v.Args[0] 30201 if x != v.Args[1] { 30202 break 30203 } 30204 v.reset(OpConst8) 30205 v.AuxInt = 0 30206 return true 30207 } 30208 // match: (Sub8 (Add8 x y) x) 30209 // cond: 30210 // result: y 30211 for { 30212 _ = v.Args[1] 30213 v_0 := v.Args[0] 30214 if v_0.Op != OpAdd8 { 30215 break 30216 } 30217 _ = v_0.Args[1] 30218 x := v_0.Args[0] 30219 y := v_0.Args[1] 30220 if x != v.Args[1] { 30221 break 30222 } 30223 v.reset(OpCopy) 30224 v.Type = y.Type 30225 v.AddArg(y) 30226 return true 30227 } 30228 // match: (Sub8 (Add8 y x) x) 30229 // cond: 30230 // result: y 30231 for { 30232 _ = v.Args[1] 30233 v_0 := v.Args[0] 30234 if v_0.Op != OpAdd8 { 30235 break 30236 } 30237 _ = v_0.Args[1] 30238 y := v_0.Args[0] 30239 x := v_0.Args[1] 30240 if x != v.Args[1] { 30241 break 30242 } 30243 v.reset(OpCopy) 30244 v.Type = y.Type 30245 v.AddArg(y) 30246 return true 30247 } 30248 // match: (Sub8 (Add8 x y) y) 30249 // cond: 30250 // result: x 30251 for { 30252 _ = v.Args[1] 30253 v_0 := v.Args[0] 30254 if v_0.Op != OpAdd8 { 30255 break 30256 } 30257 _ = v_0.Args[1] 30258 x := v_0.Args[0] 30259 y := v_0.Args[1] 30260 if y != v.Args[1] { 30261 break 30262 } 30263 v.reset(OpCopy) 30264 v.Type = x.Type 30265 v.AddArg(x) 30266 return true 30267 } 30268 return false 30269 } 30270 func rewriteValuegeneric_OpSub8_10(v *Value) bool { 30271 b := v.Block 30272 _ = b 30273 // match: (Sub8 (Add8 y x) y) 30274 // cond: 30275 // result: x 30276 for { 30277 _ = v.Args[1] 30278 v_0 := v.Args[0] 30279 if v_0.Op != OpAdd8 { 30280 break 30281 } 30282 _ = v_0.Args[1] 30283 y := v_0.Args[0] 30284 x := v_0.Args[1] 30285 if y != v.Args[1] { 30286 break 30287 } 30288 v.reset(OpCopy) 30289 v.Type = x.Type 30290 v.AddArg(x) 30291 return true 30292 } 30293 // match: (Sub8 x (Sub8 i:(Const8 <t>) z)) 30294 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 30295 // result: (Sub8 (Add8 <t> x z) i) 30296 for { 30297 _ = v.Args[1] 30298 x := v.Args[0] 30299 v_1 := v.Args[1] 30300 if v_1.Op != OpSub8 { 30301 break 30302 } 30303 _ = v_1.Args[1] 30304 i := v_1.Args[0] 30305 if i.Op != OpConst8 { 30306 break 30307 } 30308 t := i.Type 30309 z := v_1.Args[1] 30310 if !(z.Op != OpConst8 && x.Op != OpConst8) { 30311 break 30312 } 30313 v.reset(OpSub8) 30314 v0 := b.NewValue0(v.Pos, OpAdd8, t) 30315 v0.AddArg(x) 30316 v0.AddArg(z) 30317 v.AddArg(v0) 30318 v.AddArg(i) 30319 return true 30320 } 30321 // match: (Sub8 x (Sub8 z i:(Const8 <t>))) 30322 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 30323 // result: (Add8 i (Sub8 <t> x z)) 30324 for { 30325 _ = v.Args[1] 30326 x := v.Args[0] 30327 v_1 := v.Args[1] 30328 if v_1.Op != OpSub8 { 30329 break 30330 } 30331 _ = v_1.Args[1] 30332 z := v_1.Args[0] 30333 i := v_1.Args[1] 30334 if i.Op != OpConst8 { 30335 break 30336 } 30337 t := i.Type 30338 if !(z.Op != OpConst8 && x.Op != OpConst8) { 30339 break 30340 } 30341 v.reset(OpAdd8) 30342 v.AddArg(i) 30343 v0 := b.NewValue0(v.Pos, OpSub8, t) 30344 v0.AddArg(x) 30345 v0.AddArg(z) 30346 v.AddArg(v0) 30347 return true 30348 } 30349 // match: (Sub8 (Const8 <t> [c]) (Sub8 x (Const8 <t> [d]))) 30350 // cond: 30351 // result: (Sub8 (Const8 <t> [int64(int8(c+d))]) x) 30352 for { 30353 _ = v.Args[1] 30354 v_0 := v.Args[0] 30355 if v_0.Op != OpConst8 { 30356 break 30357 } 30358 t := v_0.Type 30359 c := v_0.AuxInt 30360 v_1 := v.Args[1] 30361 if v_1.Op != OpSub8 { 30362 break 30363 } 30364 _ = v_1.Args[1] 30365 x := v_1.Args[0] 30366 v_1_1 := v_1.Args[1] 30367 if v_1_1.Op != OpConst8 { 30368 break 30369 } 30370 if v_1_1.Type != t { 30371 break 30372 } 30373 d := v_1_1.AuxInt 30374 v.reset(OpSub8) 30375 v0 := b.NewValue0(v.Pos, OpConst8, t) 30376 v0.AuxInt = int64(int8(c + d)) 30377 v.AddArg(v0) 30378 v.AddArg(x) 30379 return true 30380 } 30381 // match: (Sub8 (Const8 <t> [c]) (Sub8 (Const8 <t> [d]) x)) 30382 // cond: 30383 // result: (Add8 (Const8 <t> [int64(int8(c-d))]) x) 30384 for { 30385 _ = v.Args[1] 30386 v_0 := v.Args[0] 30387 if v_0.Op != OpConst8 { 30388 break 30389 } 30390 t := v_0.Type 30391 c := v_0.AuxInt 30392 v_1 := v.Args[1] 30393 if v_1.Op != OpSub8 { 30394 break 30395 } 30396 _ = v_1.Args[1] 30397 v_1_0 := v_1.Args[0] 30398 if v_1_0.Op != OpConst8 { 30399 break 30400 } 30401 if v_1_0.Type != t { 30402 break 30403 } 30404 d := v_1_0.AuxInt 30405 x := v_1.Args[1] 30406 v.reset(OpAdd8) 30407 v0 := b.NewValue0(v.Pos, OpConst8, t) 30408 v0.AuxInt = int64(int8(c - d)) 30409 v.AddArg(v0) 30410 v.AddArg(x) 30411 return true 30412 } 30413 return false 30414 } 30415 func rewriteValuegeneric_OpTrunc16to8_0(v *Value) bool { 30416 // match: (Trunc16to8 (Const16 [c])) 30417 // cond: 30418 // result: (Const8 [int64(int8(c))]) 30419 for { 30420 v_0 := v.Args[0] 30421 if v_0.Op != OpConst16 { 30422 break 30423 } 30424 c := v_0.AuxInt 30425 v.reset(OpConst8) 30426 v.AuxInt = int64(int8(c)) 30427 return true 30428 } 30429 // match: (Trunc16to8 (ZeroExt8to16 x)) 30430 // cond: 30431 // result: x 30432 for { 30433 v_0 := v.Args[0] 30434 if v_0.Op != OpZeroExt8to16 { 30435 break 30436 } 30437 x := v_0.Args[0] 30438 v.reset(OpCopy) 30439 v.Type = x.Type 30440 v.AddArg(x) 30441 return true 30442 } 30443 // match: (Trunc16to8 (SignExt8to16 x)) 30444 // cond: 30445 // result: x 30446 for { 30447 v_0 := v.Args[0] 30448 if v_0.Op != OpSignExt8to16 { 30449 break 30450 } 30451 x := v_0.Args[0] 30452 v.reset(OpCopy) 30453 v.Type = x.Type 30454 v.AddArg(x) 30455 return true 30456 } 30457 // match: (Trunc16to8 (And16 (Const16 [y]) x)) 30458 // cond: y&0xFF == 0xFF 30459 // result: (Trunc16to8 x) 30460 for { 30461 v_0 := v.Args[0] 30462 if v_0.Op != OpAnd16 { 30463 break 30464 } 30465 _ = v_0.Args[1] 30466 v_0_0 := v_0.Args[0] 30467 if v_0_0.Op != OpConst16 { 30468 break 30469 } 30470 y := v_0_0.AuxInt 30471 x := v_0.Args[1] 30472 if !(y&0xFF == 0xFF) { 30473 break 30474 } 30475 v.reset(OpTrunc16to8) 30476 v.AddArg(x) 30477 return true 30478 } 30479 // match: (Trunc16to8 (And16 x (Const16 [y]))) 30480 // cond: y&0xFF == 0xFF 30481 // result: (Trunc16to8 x) 30482 for { 30483 v_0 := v.Args[0] 30484 if v_0.Op != OpAnd16 { 30485 break 30486 } 30487 _ = v_0.Args[1] 30488 x := v_0.Args[0] 30489 v_0_1 := v_0.Args[1] 30490 if v_0_1.Op != OpConst16 { 30491 break 30492 } 30493 y := v_0_1.AuxInt 30494 if !(y&0xFF == 0xFF) { 30495 break 30496 } 30497 v.reset(OpTrunc16to8) 30498 v.AddArg(x) 30499 return true 30500 } 30501 return false 30502 } 30503 func rewriteValuegeneric_OpTrunc32to16_0(v *Value) bool { 30504 // match: (Trunc32to16 (Const32 [c])) 30505 // cond: 30506 // result: (Const16 [int64(int16(c))]) 30507 for { 30508 v_0 := v.Args[0] 30509 if v_0.Op != OpConst32 { 30510 break 30511 } 30512 c := v_0.AuxInt 30513 v.reset(OpConst16) 30514 v.AuxInt = int64(int16(c)) 30515 return true 30516 } 30517 // match: (Trunc32to16 (ZeroExt8to32 x)) 30518 // cond: 30519 // result: (ZeroExt8to16 x) 30520 for { 30521 v_0 := v.Args[0] 30522 if v_0.Op != OpZeroExt8to32 { 30523 break 30524 } 30525 x := v_0.Args[0] 30526 v.reset(OpZeroExt8to16) 30527 v.AddArg(x) 30528 return true 30529 } 30530 // match: (Trunc32to16 (ZeroExt16to32 x)) 30531 // cond: 30532 // result: x 30533 for { 30534 v_0 := v.Args[0] 30535 if v_0.Op != OpZeroExt16to32 { 30536 break 30537 } 30538 x := v_0.Args[0] 30539 v.reset(OpCopy) 30540 v.Type = x.Type 30541 v.AddArg(x) 30542 return true 30543 } 30544 // match: (Trunc32to16 (SignExt8to32 x)) 30545 // cond: 30546 // result: (SignExt8to16 x) 30547 for { 30548 v_0 := v.Args[0] 30549 if v_0.Op != OpSignExt8to32 { 30550 break 30551 } 30552 x := v_0.Args[0] 30553 v.reset(OpSignExt8to16) 30554 v.AddArg(x) 30555 return true 30556 } 30557 // match: (Trunc32to16 (SignExt16to32 x)) 30558 // cond: 30559 // result: x 30560 for { 30561 v_0 := v.Args[0] 30562 if v_0.Op != OpSignExt16to32 { 30563 break 30564 } 30565 x := v_0.Args[0] 30566 v.reset(OpCopy) 30567 v.Type = x.Type 30568 v.AddArg(x) 30569 return true 30570 } 30571 // match: (Trunc32to16 (And32 (Const32 [y]) x)) 30572 // cond: y&0xFFFF == 0xFFFF 30573 // result: (Trunc32to16 x) 30574 for { 30575 v_0 := v.Args[0] 30576 if v_0.Op != OpAnd32 { 30577 break 30578 } 30579 _ = v_0.Args[1] 30580 v_0_0 := v_0.Args[0] 30581 if v_0_0.Op != OpConst32 { 30582 break 30583 } 30584 y := v_0_0.AuxInt 30585 x := v_0.Args[1] 30586 if !(y&0xFFFF == 0xFFFF) { 30587 break 30588 } 30589 v.reset(OpTrunc32to16) 30590 v.AddArg(x) 30591 return true 30592 } 30593 // match: (Trunc32to16 (And32 x (Const32 [y]))) 30594 // cond: y&0xFFFF == 0xFFFF 30595 // result: (Trunc32to16 x) 30596 for { 30597 v_0 := v.Args[0] 30598 if v_0.Op != OpAnd32 { 30599 break 30600 } 30601 _ = v_0.Args[1] 30602 x := v_0.Args[0] 30603 v_0_1 := v_0.Args[1] 30604 if v_0_1.Op != OpConst32 { 30605 break 30606 } 30607 y := v_0_1.AuxInt 30608 if !(y&0xFFFF == 0xFFFF) { 30609 break 30610 } 30611 v.reset(OpTrunc32to16) 30612 v.AddArg(x) 30613 return true 30614 } 30615 return false 30616 } 30617 func rewriteValuegeneric_OpTrunc32to8_0(v *Value) bool { 30618 // match: (Trunc32to8 (Const32 [c])) 30619 // cond: 30620 // result: (Const8 [int64(int8(c))]) 30621 for { 30622 v_0 := v.Args[0] 30623 if v_0.Op != OpConst32 { 30624 break 30625 } 30626 c := v_0.AuxInt 30627 v.reset(OpConst8) 30628 v.AuxInt = int64(int8(c)) 30629 return true 30630 } 30631 // match: (Trunc32to8 (ZeroExt8to32 x)) 30632 // cond: 30633 // result: x 30634 for { 30635 v_0 := v.Args[0] 30636 if v_0.Op != OpZeroExt8to32 { 30637 break 30638 } 30639 x := v_0.Args[0] 30640 v.reset(OpCopy) 30641 v.Type = x.Type 30642 v.AddArg(x) 30643 return true 30644 } 30645 // match: (Trunc32to8 (SignExt8to32 x)) 30646 // cond: 30647 // result: x 30648 for { 30649 v_0 := v.Args[0] 30650 if v_0.Op != OpSignExt8to32 { 30651 break 30652 } 30653 x := v_0.Args[0] 30654 v.reset(OpCopy) 30655 v.Type = x.Type 30656 v.AddArg(x) 30657 return true 30658 } 30659 // match: (Trunc32to8 (And32 (Const32 [y]) x)) 30660 // cond: y&0xFF == 0xFF 30661 // result: (Trunc32to8 x) 30662 for { 30663 v_0 := v.Args[0] 30664 if v_0.Op != OpAnd32 { 30665 break 30666 } 30667 _ = v_0.Args[1] 30668 v_0_0 := v_0.Args[0] 30669 if v_0_0.Op != OpConst32 { 30670 break 30671 } 30672 y := v_0_0.AuxInt 30673 x := v_0.Args[1] 30674 if !(y&0xFF == 0xFF) { 30675 break 30676 } 30677 v.reset(OpTrunc32to8) 30678 v.AddArg(x) 30679 return true 30680 } 30681 // match: (Trunc32to8 (And32 x (Const32 [y]))) 30682 // cond: y&0xFF == 0xFF 30683 // result: (Trunc32to8 x) 30684 for { 30685 v_0 := v.Args[0] 30686 if v_0.Op != OpAnd32 { 30687 break 30688 } 30689 _ = v_0.Args[1] 30690 x := v_0.Args[0] 30691 v_0_1 := v_0.Args[1] 30692 if v_0_1.Op != OpConst32 { 30693 break 30694 } 30695 y := v_0_1.AuxInt 30696 if !(y&0xFF == 0xFF) { 30697 break 30698 } 30699 v.reset(OpTrunc32to8) 30700 v.AddArg(x) 30701 return true 30702 } 30703 return false 30704 } 30705 func rewriteValuegeneric_OpTrunc64to16_0(v *Value) bool { 30706 // match: (Trunc64to16 (Const64 [c])) 30707 // cond: 30708 // result: (Const16 [int64(int16(c))]) 30709 for { 30710 v_0 := v.Args[0] 30711 if v_0.Op != OpConst64 { 30712 break 30713 } 30714 c := v_0.AuxInt 30715 v.reset(OpConst16) 30716 v.AuxInt = int64(int16(c)) 30717 return true 30718 } 30719 // match: (Trunc64to16 (ZeroExt8to64 x)) 30720 // cond: 30721 // result: (ZeroExt8to16 x) 30722 for { 30723 v_0 := v.Args[0] 30724 if v_0.Op != OpZeroExt8to64 { 30725 break 30726 } 30727 x := v_0.Args[0] 30728 v.reset(OpZeroExt8to16) 30729 v.AddArg(x) 30730 return true 30731 } 30732 // match: (Trunc64to16 (ZeroExt16to64 x)) 30733 // cond: 30734 // result: x 30735 for { 30736 v_0 := v.Args[0] 30737 if v_0.Op != OpZeroExt16to64 { 30738 break 30739 } 30740 x := v_0.Args[0] 30741 v.reset(OpCopy) 30742 v.Type = x.Type 30743 v.AddArg(x) 30744 return true 30745 } 30746 // match: (Trunc64to16 (SignExt8to64 x)) 30747 // cond: 30748 // result: (SignExt8to16 x) 30749 for { 30750 v_0 := v.Args[0] 30751 if v_0.Op != OpSignExt8to64 { 30752 break 30753 } 30754 x := v_0.Args[0] 30755 v.reset(OpSignExt8to16) 30756 v.AddArg(x) 30757 return true 30758 } 30759 // match: (Trunc64to16 (SignExt16to64 x)) 30760 // cond: 30761 // result: x 30762 for { 30763 v_0 := v.Args[0] 30764 if v_0.Op != OpSignExt16to64 { 30765 break 30766 } 30767 x := v_0.Args[0] 30768 v.reset(OpCopy) 30769 v.Type = x.Type 30770 v.AddArg(x) 30771 return true 30772 } 30773 // match: (Trunc64to16 (And64 (Const64 [y]) x)) 30774 // cond: y&0xFFFF == 0xFFFF 30775 // result: (Trunc64to16 x) 30776 for { 30777 v_0 := v.Args[0] 30778 if v_0.Op != OpAnd64 { 30779 break 30780 } 30781 _ = v_0.Args[1] 30782 v_0_0 := v_0.Args[0] 30783 if v_0_0.Op != OpConst64 { 30784 break 30785 } 30786 y := v_0_0.AuxInt 30787 x := v_0.Args[1] 30788 if !(y&0xFFFF == 0xFFFF) { 30789 break 30790 } 30791 v.reset(OpTrunc64to16) 30792 v.AddArg(x) 30793 return true 30794 } 30795 // match: (Trunc64to16 (And64 x (Const64 [y]))) 30796 // cond: y&0xFFFF == 0xFFFF 30797 // result: (Trunc64to16 x) 30798 for { 30799 v_0 := v.Args[0] 30800 if v_0.Op != OpAnd64 { 30801 break 30802 } 30803 _ = v_0.Args[1] 30804 x := v_0.Args[0] 30805 v_0_1 := v_0.Args[1] 30806 if v_0_1.Op != OpConst64 { 30807 break 30808 } 30809 y := v_0_1.AuxInt 30810 if !(y&0xFFFF == 0xFFFF) { 30811 break 30812 } 30813 v.reset(OpTrunc64to16) 30814 v.AddArg(x) 30815 return true 30816 } 30817 return false 30818 } 30819 func rewriteValuegeneric_OpTrunc64to32_0(v *Value) bool { 30820 // match: (Trunc64to32 (Const64 [c])) 30821 // cond: 30822 // result: (Const32 [int64(int32(c))]) 30823 for { 30824 v_0 := v.Args[0] 30825 if v_0.Op != OpConst64 { 30826 break 30827 } 30828 c := v_0.AuxInt 30829 v.reset(OpConst32) 30830 v.AuxInt = int64(int32(c)) 30831 return true 30832 } 30833 // match: (Trunc64to32 (ZeroExt8to64 x)) 30834 // cond: 30835 // result: (ZeroExt8to32 x) 30836 for { 30837 v_0 := v.Args[0] 30838 if v_0.Op != OpZeroExt8to64 { 30839 break 30840 } 30841 x := v_0.Args[0] 30842 v.reset(OpZeroExt8to32) 30843 v.AddArg(x) 30844 return true 30845 } 30846 // match: (Trunc64to32 (ZeroExt16to64 x)) 30847 // cond: 30848 // result: (ZeroExt16to32 x) 30849 for { 30850 v_0 := v.Args[0] 30851 if v_0.Op != OpZeroExt16to64 { 30852 break 30853 } 30854 x := v_0.Args[0] 30855 v.reset(OpZeroExt16to32) 30856 v.AddArg(x) 30857 return true 30858 } 30859 // match: (Trunc64to32 (ZeroExt32to64 x)) 30860 // cond: 30861 // result: x 30862 for { 30863 v_0 := v.Args[0] 30864 if v_0.Op != OpZeroExt32to64 { 30865 break 30866 } 30867 x := v_0.Args[0] 30868 v.reset(OpCopy) 30869 v.Type = x.Type 30870 v.AddArg(x) 30871 return true 30872 } 30873 // match: (Trunc64to32 (SignExt8to64 x)) 30874 // cond: 30875 // result: (SignExt8to32 x) 30876 for { 30877 v_0 := v.Args[0] 30878 if v_0.Op != OpSignExt8to64 { 30879 break 30880 } 30881 x := v_0.Args[0] 30882 v.reset(OpSignExt8to32) 30883 v.AddArg(x) 30884 return true 30885 } 30886 // match: (Trunc64to32 (SignExt16to64 x)) 30887 // cond: 30888 // result: (SignExt16to32 x) 30889 for { 30890 v_0 := v.Args[0] 30891 if v_0.Op != OpSignExt16to64 { 30892 break 30893 } 30894 x := v_0.Args[0] 30895 v.reset(OpSignExt16to32) 30896 v.AddArg(x) 30897 return true 30898 } 30899 // match: (Trunc64to32 (SignExt32to64 x)) 30900 // cond: 30901 // result: x 30902 for { 30903 v_0 := v.Args[0] 30904 if v_0.Op != OpSignExt32to64 { 30905 break 30906 } 30907 x := v_0.Args[0] 30908 v.reset(OpCopy) 30909 v.Type = x.Type 30910 v.AddArg(x) 30911 return true 30912 } 30913 // match: (Trunc64to32 (And64 (Const64 [y]) x)) 30914 // cond: y&0xFFFFFFFF == 0xFFFFFFFF 30915 // result: (Trunc64to32 x) 30916 for { 30917 v_0 := v.Args[0] 30918 if v_0.Op != OpAnd64 { 30919 break 30920 } 30921 _ = v_0.Args[1] 30922 v_0_0 := v_0.Args[0] 30923 if v_0_0.Op != OpConst64 { 30924 break 30925 } 30926 y := v_0_0.AuxInt 30927 x := v_0.Args[1] 30928 if !(y&0xFFFFFFFF == 0xFFFFFFFF) { 30929 break 30930 } 30931 v.reset(OpTrunc64to32) 30932 v.AddArg(x) 30933 return true 30934 } 30935 // match: (Trunc64to32 (And64 x (Const64 [y]))) 30936 // cond: y&0xFFFFFFFF == 0xFFFFFFFF 30937 // result: (Trunc64to32 x) 30938 for { 30939 v_0 := v.Args[0] 30940 if v_0.Op != OpAnd64 { 30941 break 30942 } 30943 _ = v_0.Args[1] 30944 x := v_0.Args[0] 30945 v_0_1 := v_0.Args[1] 30946 if v_0_1.Op != OpConst64 { 30947 break 30948 } 30949 y := v_0_1.AuxInt 30950 if !(y&0xFFFFFFFF == 0xFFFFFFFF) { 30951 break 30952 } 30953 v.reset(OpTrunc64to32) 30954 v.AddArg(x) 30955 return true 30956 } 30957 return false 30958 } 30959 func rewriteValuegeneric_OpTrunc64to8_0(v *Value) bool { 30960 // match: (Trunc64to8 (Const64 [c])) 30961 // cond: 30962 // result: (Const8 [int64(int8(c))]) 30963 for { 30964 v_0 := v.Args[0] 30965 if v_0.Op != OpConst64 { 30966 break 30967 } 30968 c := v_0.AuxInt 30969 v.reset(OpConst8) 30970 v.AuxInt = int64(int8(c)) 30971 return true 30972 } 30973 // match: (Trunc64to8 (ZeroExt8to64 x)) 30974 // cond: 30975 // result: x 30976 for { 30977 v_0 := v.Args[0] 30978 if v_0.Op != OpZeroExt8to64 { 30979 break 30980 } 30981 x := v_0.Args[0] 30982 v.reset(OpCopy) 30983 v.Type = x.Type 30984 v.AddArg(x) 30985 return true 30986 } 30987 // match: (Trunc64to8 (SignExt8to64 x)) 30988 // cond: 30989 // result: x 30990 for { 30991 v_0 := v.Args[0] 30992 if v_0.Op != OpSignExt8to64 { 30993 break 30994 } 30995 x := v_0.Args[0] 30996 v.reset(OpCopy) 30997 v.Type = x.Type 30998 v.AddArg(x) 30999 return true 31000 } 31001 // match: (Trunc64to8 (And64 (Const64 [y]) x)) 31002 // cond: y&0xFF == 0xFF 31003 // result: (Trunc64to8 x) 31004 for { 31005 v_0 := v.Args[0] 31006 if v_0.Op != OpAnd64 { 31007 break 31008 } 31009 _ = v_0.Args[1] 31010 v_0_0 := v_0.Args[0] 31011 if v_0_0.Op != OpConst64 { 31012 break 31013 } 31014 y := v_0_0.AuxInt 31015 x := v_0.Args[1] 31016 if !(y&0xFF == 0xFF) { 31017 break 31018 } 31019 v.reset(OpTrunc64to8) 31020 v.AddArg(x) 31021 return true 31022 } 31023 // match: (Trunc64to8 (And64 x (Const64 [y]))) 31024 // cond: y&0xFF == 0xFF 31025 // result: (Trunc64to8 x) 31026 for { 31027 v_0 := v.Args[0] 31028 if v_0.Op != OpAnd64 { 31029 break 31030 } 31031 _ = v_0.Args[1] 31032 x := v_0.Args[0] 31033 v_0_1 := v_0.Args[1] 31034 if v_0_1.Op != OpConst64 { 31035 break 31036 } 31037 y := v_0_1.AuxInt 31038 if !(y&0xFF == 0xFF) { 31039 break 31040 } 31041 v.reset(OpTrunc64to8) 31042 v.AddArg(x) 31043 return true 31044 } 31045 return false 31046 } 31047 func rewriteValuegeneric_OpXor16_0(v *Value) bool { 31048 b := v.Block 31049 _ = b 31050 // match: (Xor16 (Const16 [c]) (Const16 [d])) 31051 // cond: 31052 // result: (Const16 [int64(int16(c^d))]) 31053 for { 31054 _ = v.Args[1] 31055 v_0 := v.Args[0] 31056 if v_0.Op != OpConst16 { 31057 break 31058 } 31059 c := v_0.AuxInt 31060 v_1 := v.Args[1] 31061 if v_1.Op != OpConst16 { 31062 break 31063 } 31064 d := v_1.AuxInt 31065 v.reset(OpConst16) 31066 v.AuxInt = int64(int16(c ^ d)) 31067 return true 31068 } 31069 // match: (Xor16 (Const16 [d]) (Const16 [c])) 31070 // cond: 31071 // result: (Const16 [int64(int16(c^d))]) 31072 for { 31073 _ = v.Args[1] 31074 v_0 := v.Args[0] 31075 if v_0.Op != OpConst16 { 31076 break 31077 } 31078 d := v_0.AuxInt 31079 v_1 := v.Args[1] 31080 if v_1.Op != OpConst16 { 31081 break 31082 } 31083 c := v_1.AuxInt 31084 v.reset(OpConst16) 31085 v.AuxInt = int64(int16(c ^ d)) 31086 return true 31087 } 31088 // match: (Xor16 x x) 31089 // cond: 31090 // result: (Const16 [0]) 31091 for { 31092 _ = v.Args[1] 31093 x := v.Args[0] 31094 if x != v.Args[1] { 31095 break 31096 } 31097 v.reset(OpConst16) 31098 v.AuxInt = 0 31099 return true 31100 } 31101 // match: (Xor16 (Const16 [0]) x) 31102 // cond: 31103 // result: x 31104 for { 31105 _ = v.Args[1] 31106 v_0 := v.Args[0] 31107 if v_0.Op != OpConst16 { 31108 break 31109 } 31110 if v_0.AuxInt != 0 { 31111 break 31112 } 31113 x := v.Args[1] 31114 v.reset(OpCopy) 31115 v.Type = x.Type 31116 v.AddArg(x) 31117 return true 31118 } 31119 // match: (Xor16 x (Const16 [0])) 31120 // cond: 31121 // result: x 31122 for { 31123 _ = v.Args[1] 31124 x := v.Args[0] 31125 v_1 := v.Args[1] 31126 if v_1.Op != OpConst16 { 31127 break 31128 } 31129 if v_1.AuxInt != 0 { 31130 break 31131 } 31132 v.reset(OpCopy) 31133 v.Type = x.Type 31134 v.AddArg(x) 31135 return true 31136 } 31137 // match: (Xor16 x (Xor16 x y)) 31138 // cond: 31139 // result: y 31140 for { 31141 _ = v.Args[1] 31142 x := v.Args[0] 31143 v_1 := v.Args[1] 31144 if v_1.Op != OpXor16 { 31145 break 31146 } 31147 _ = v_1.Args[1] 31148 if x != v_1.Args[0] { 31149 break 31150 } 31151 y := v_1.Args[1] 31152 v.reset(OpCopy) 31153 v.Type = y.Type 31154 v.AddArg(y) 31155 return true 31156 } 31157 // match: (Xor16 x (Xor16 y x)) 31158 // cond: 31159 // result: y 31160 for { 31161 _ = v.Args[1] 31162 x := v.Args[0] 31163 v_1 := v.Args[1] 31164 if v_1.Op != OpXor16 { 31165 break 31166 } 31167 _ = v_1.Args[1] 31168 y := v_1.Args[0] 31169 if x != v_1.Args[1] { 31170 break 31171 } 31172 v.reset(OpCopy) 31173 v.Type = y.Type 31174 v.AddArg(y) 31175 return true 31176 } 31177 // match: (Xor16 (Xor16 x y) x) 31178 // cond: 31179 // result: y 31180 for { 31181 _ = v.Args[1] 31182 v_0 := v.Args[0] 31183 if v_0.Op != OpXor16 { 31184 break 31185 } 31186 _ = v_0.Args[1] 31187 x := v_0.Args[0] 31188 y := v_0.Args[1] 31189 if x != v.Args[1] { 31190 break 31191 } 31192 v.reset(OpCopy) 31193 v.Type = y.Type 31194 v.AddArg(y) 31195 return true 31196 } 31197 // match: (Xor16 (Xor16 y x) x) 31198 // cond: 31199 // result: y 31200 for { 31201 _ = v.Args[1] 31202 v_0 := v.Args[0] 31203 if v_0.Op != OpXor16 { 31204 break 31205 } 31206 _ = v_0.Args[1] 31207 y := v_0.Args[0] 31208 x := v_0.Args[1] 31209 if x != v.Args[1] { 31210 break 31211 } 31212 v.reset(OpCopy) 31213 v.Type = y.Type 31214 v.AddArg(y) 31215 return true 31216 } 31217 // match: (Xor16 (Xor16 i:(Const16 <t>) z) x) 31218 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 31219 // result: (Xor16 i (Xor16 <t> z x)) 31220 for { 31221 _ = v.Args[1] 31222 v_0 := v.Args[0] 31223 if v_0.Op != OpXor16 { 31224 break 31225 } 31226 _ = v_0.Args[1] 31227 i := v_0.Args[0] 31228 if i.Op != OpConst16 { 31229 break 31230 } 31231 t := i.Type 31232 z := v_0.Args[1] 31233 x := v.Args[1] 31234 if !(z.Op != OpConst16 && x.Op != OpConst16) { 31235 break 31236 } 31237 v.reset(OpXor16) 31238 v.AddArg(i) 31239 v0 := b.NewValue0(v.Pos, OpXor16, t) 31240 v0.AddArg(z) 31241 v0.AddArg(x) 31242 v.AddArg(v0) 31243 return true 31244 } 31245 return false 31246 } 31247 func rewriteValuegeneric_OpXor16_10(v *Value) bool { 31248 b := v.Block 31249 _ = b 31250 // match: (Xor16 (Xor16 z i:(Const16 <t>)) x) 31251 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 31252 // result: (Xor16 i (Xor16 <t> z x)) 31253 for { 31254 _ = v.Args[1] 31255 v_0 := v.Args[0] 31256 if v_0.Op != OpXor16 { 31257 break 31258 } 31259 _ = v_0.Args[1] 31260 z := v_0.Args[0] 31261 i := v_0.Args[1] 31262 if i.Op != OpConst16 { 31263 break 31264 } 31265 t := i.Type 31266 x := v.Args[1] 31267 if !(z.Op != OpConst16 && x.Op != OpConst16) { 31268 break 31269 } 31270 v.reset(OpXor16) 31271 v.AddArg(i) 31272 v0 := b.NewValue0(v.Pos, OpXor16, t) 31273 v0.AddArg(z) 31274 v0.AddArg(x) 31275 v.AddArg(v0) 31276 return true 31277 } 31278 // match: (Xor16 x (Xor16 i:(Const16 <t>) z)) 31279 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 31280 // result: (Xor16 i (Xor16 <t> z x)) 31281 for { 31282 _ = v.Args[1] 31283 x := v.Args[0] 31284 v_1 := v.Args[1] 31285 if v_1.Op != OpXor16 { 31286 break 31287 } 31288 _ = v_1.Args[1] 31289 i := v_1.Args[0] 31290 if i.Op != OpConst16 { 31291 break 31292 } 31293 t := i.Type 31294 z := v_1.Args[1] 31295 if !(z.Op != OpConst16 && x.Op != OpConst16) { 31296 break 31297 } 31298 v.reset(OpXor16) 31299 v.AddArg(i) 31300 v0 := b.NewValue0(v.Pos, OpXor16, t) 31301 v0.AddArg(z) 31302 v0.AddArg(x) 31303 v.AddArg(v0) 31304 return true 31305 } 31306 // match: (Xor16 x (Xor16 z i:(Const16 <t>))) 31307 // cond: (z.Op != OpConst16 && x.Op != OpConst16) 31308 // result: (Xor16 i (Xor16 <t> z x)) 31309 for { 31310 _ = v.Args[1] 31311 x := v.Args[0] 31312 v_1 := v.Args[1] 31313 if v_1.Op != OpXor16 { 31314 break 31315 } 31316 _ = v_1.Args[1] 31317 z := v_1.Args[0] 31318 i := v_1.Args[1] 31319 if i.Op != OpConst16 { 31320 break 31321 } 31322 t := i.Type 31323 if !(z.Op != OpConst16 && x.Op != OpConst16) { 31324 break 31325 } 31326 v.reset(OpXor16) 31327 v.AddArg(i) 31328 v0 := b.NewValue0(v.Pos, OpXor16, t) 31329 v0.AddArg(z) 31330 v0.AddArg(x) 31331 v.AddArg(v0) 31332 return true 31333 } 31334 // match: (Xor16 (Const16 <t> [c]) (Xor16 (Const16 <t> [d]) x)) 31335 // cond: 31336 // result: (Xor16 (Const16 <t> [int64(int16(c^d))]) x) 31337 for { 31338 _ = v.Args[1] 31339 v_0 := v.Args[0] 31340 if v_0.Op != OpConst16 { 31341 break 31342 } 31343 t := v_0.Type 31344 c := v_0.AuxInt 31345 v_1 := v.Args[1] 31346 if v_1.Op != OpXor16 { 31347 break 31348 } 31349 _ = v_1.Args[1] 31350 v_1_0 := v_1.Args[0] 31351 if v_1_0.Op != OpConst16 { 31352 break 31353 } 31354 if v_1_0.Type != t { 31355 break 31356 } 31357 d := v_1_0.AuxInt 31358 x := v_1.Args[1] 31359 v.reset(OpXor16) 31360 v0 := b.NewValue0(v.Pos, OpConst16, t) 31361 v0.AuxInt = int64(int16(c ^ d)) 31362 v.AddArg(v0) 31363 v.AddArg(x) 31364 return true 31365 } 31366 // match: (Xor16 (Const16 <t> [c]) (Xor16 x (Const16 <t> [d]))) 31367 // cond: 31368 // result: (Xor16 (Const16 <t> [int64(int16(c^d))]) x) 31369 for { 31370 _ = v.Args[1] 31371 v_0 := v.Args[0] 31372 if v_0.Op != OpConst16 { 31373 break 31374 } 31375 t := v_0.Type 31376 c := v_0.AuxInt 31377 v_1 := v.Args[1] 31378 if v_1.Op != OpXor16 { 31379 break 31380 } 31381 _ = v_1.Args[1] 31382 x := v_1.Args[0] 31383 v_1_1 := v_1.Args[1] 31384 if v_1_1.Op != OpConst16 { 31385 break 31386 } 31387 if v_1_1.Type != t { 31388 break 31389 } 31390 d := v_1_1.AuxInt 31391 v.reset(OpXor16) 31392 v0 := b.NewValue0(v.Pos, OpConst16, t) 31393 v0.AuxInt = int64(int16(c ^ d)) 31394 v.AddArg(v0) 31395 v.AddArg(x) 31396 return true 31397 } 31398 // match: (Xor16 (Xor16 (Const16 <t> [d]) x) (Const16 <t> [c])) 31399 // cond: 31400 // result: (Xor16 (Const16 <t> [int64(int16(c^d))]) x) 31401 for { 31402 _ = v.Args[1] 31403 v_0 := v.Args[0] 31404 if v_0.Op != OpXor16 { 31405 break 31406 } 31407 _ = v_0.Args[1] 31408 v_0_0 := v_0.Args[0] 31409 if v_0_0.Op != OpConst16 { 31410 break 31411 } 31412 t := v_0_0.Type 31413 d := v_0_0.AuxInt 31414 x := v_0.Args[1] 31415 v_1 := v.Args[1] 31416 if v_1.Op != OpConst16 { 31417 break 31418 } 31419 if v_1.Type != t { 31420 break 31421 } 31422 c := v_1.AuxInt 31423 v.reset(OpXor16) 31424 v0 := b.NewValue0(v.Pos, OpConst16, t) 31425 v0.AuxInt = int64(int16(c ^ d)) 31426 v.AddArg(v0) 31427 v.AddArg(x) 31428 return true 31429 } 31430 // match: (Xor16 (Xor16 x (Const16 <t> [d])) (Const16 <t> [c])) 31431 // cond: 31432 // result: (Xor16 (Const16 <t> [int64(int16(c^d))]) x) 31433 for { 31434 _ = v.Args[1] 31435 v_0 := v.Args[0] 31436 if v_0.Op != OpXor16 { 31437 break 31438 } 31439 _ = v_0.Args[1] 31440 x := v_0.Args[0] 31441 v_0_1 := v_0.Args[1] 31442 if v_0_1.Op != OpConst16 { 31443 break 31444 } 31445 t := v_0_1.Type 31446 d := v_0_1.AuxInt 31447 v_1 := v.Args[1] 31448 if v_1.Op != OpConst16 { 31449 break 31450 } 31451 if v_1.Type != t { 31452 break 31453 } 31454 c := v_1.AuxInt 31455 v.reset(OpXor16) 31456 v0 := b.NewValue0(v.Pos, OpConst16, t) 31457 v0.AuxInt = int64(int16(c ^ d)) 31458 v.AddArg(v0) 31459 v.AddArg(x) 31460 return true 31461 } 31462 return false 31463 } 31464 func rewriteValuegeneric_OpXor32_0(v *Value) bool { 31465 b := v.Block 31466 _ = b 31467 // match: (Xor32 (Const32 [c]) (Const32 [d])) 31468 // cond: 31469 // result: (Const32 [int64(int32(c^d))]) 31470 for { 31471 _ = v.Args[1] 31472 v_0 := v.Args[0] 31473 if v_0.Op != OpConst32 { 31474 break 31475 } 31476 c := v_0.AuxInt 31477 v_1 := v.Args[1] 31478 if v_1.Op != OpConst32 { 31479 break 31480 } 31481 d := v_1.AuxInt 31482 v.reset(OpConst32) 31483 v.AuxInt = int64(int32(c ^ d)) 31484 return true 31485 } 31486 // match: (Xor32 (Const32 [d]) (Const32 [c])) 31487 // cond: 31488 // result: (Const32 [int64(int32(c^d))]) 31489 for { 31490 _ = v.Args[1] 31491 v_0 := v.Args[0] 31492 if v_0.Op != OpConst32 { 31493 break 31494 } 31495 d := v_0.AuxInt 31496 v_1 := v.Args[1] 31497 if v_1.Op != OpConst32 { 31498 break 31499 } 31500 c := v_1.AuxInt 31501 v.reset(OpConst32) 31502 v.AuxInt = int64(int32(c ^ d)) 31503 return true 31504 } 31505 // match: (Xor32 x x) 31506 // cond: 31507 // result: (Const32 [0]) 31508 for { 31509 _ = v.Args[1] 31510 x := v.Args[0] 31511 if x != v.Args[1] { 31512 break 31513 } 31514 v.reset(OpConst32) 31515 v.AuxInt = 0 31516 return true 31517 } 31518 // match: (Xor32 (Const32 [0]) x) 31519 // cond: 31520 // result: x 31521 for { 31522 _ = v.Args[1] 31523 v_0 := v.Args[0] 31524 if v_0.Op != OpConst32 { 31525 break 31526 } 31527 if v_0.AuxInt != 0 { 31528 break 31529 } 31530 x := v.Args[1] 31531 v.reset(OpCopy) 31532 v.Type = x.Type 31533 v.AddArg(x) 31534 return true 31535 } 31536 // match: (Xor32 x (Const32 [0])) 31537 // cond: 31538 // result: x 31539 for { 31540 _ = v.Args[1] 31541 x := v.Args[0] 31542 v_1 := v.Args[1] 31543 if v_1.Op != OpConst32 { 31544 break 31545 } 31546 if v_1.AuxInt != 0 { 31547 break 31548 } 31549 v.reset(OpCopy) 31550 v.Type = x.Type 31551 v.AddArg(x) 31552 return true 31553 } 31554 // match: (Xor32 x (Xor32 x y)) 31555 // cond: 31556 // result: y 31557 for { 31558 _ = v.Args[1] 31559 x := v.Args[0] 31560 v_1 := v.Args[1] 31561 if v_1.Op != OpXor32 { 31562 break 31563 } 31564 _ = v_1.Args[1] 31565 if x != v_1.Args[0] { 31566 break 31567 } 31568 y := v_1.Args[1] 31569 v.reset(OpCopy) 31570 v.Type = y.Type 31571 v.AddArg(y) 31572 return true 31573 } 31574 // match: (Xor32 x (Xor32 y x)) 31575 // cond: 31576 // result: y 31577 for { 31578 _ = v.Args[1] 31579 x := v.Args[0] 31580 v_1 := v.Args[1] 31581 if v_1.Op != OpXor32 { 31582 break 31583 } 31584 _ = v_1.Args[1] 31585 y := v_1.Args[0] 31586 if x != v_1.Args[1] { 31587 break 31588 } 31589 v.reset(OpCopy) 31590 v.Type = y.Type 31591 v.AddArg(y) 31592 return true 31593 } 31594 // match: (Xor32 (Xor32 x y) x) 31595 // cond: 31596 // result: y 31597 for { 31598 _ = v.Args[1] 31599 v_0 := v.Args[0] 31600 if v_0.Op != OpXor32 { 31601 break 31602 } 31603 _ = v_0.Args[1] 31604 x := v_0.Args[0] 31605 y := v_0.Args[1] 31606 if x != v.Args[1] { 31607 break 31608 } 31609 v.reset(OpCopy) 31610 v.Type = y.Type 31611 v.AddArg(y) 31612 return true 31613 } 31614 // match: (Xor32 (Xor32 y x) x) 31615 // cond: 31616 // result: y 31617 for { 31618 _ = v.Args[1] 31619 v_0 := v.Args[0] 31620 if v_0.Op != OpXor32 { 31621 break 31622 } 31623 _ = v_0.Args[1] 31624 y := v_0.Args[0] 31625 x := v_0.Args[1] 31626 if x != v.Args[1] { 31627 break 31628 } 31629 v.reset(OpCopy) 31630 v.Type = y.Type 31631 v.AddArg(y) 31632 return true 31633 } 31634 // match: (Xor32 (Xor32 i:(Const32 <t>) z) x) 31635 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 31636 // result: (Xor32 i (Xor32 <t> z x)) 31637 for { 31638 _ = v.Args[1] 31639 v_0 := v.Args[0] 31640 if v_0.Op != OpXor32 { 31641 break 31642 } 31643 _ = v_0.Args[1] 31644 i := v_0.Args[0] 31645 if i.Op != OpConst32 { 31646 break 31647 } 31648 t := i.Type 31649 z := v_0.Args[1] 31650 x := v.Args[1] 31651 if !(z.Op != OpConst32 && x.Op != OpConst32) { 31652 break 31653 } 31654 v.reset(OpXor32) 31655 v.AddArg(i) 31656 v0 := b.NewValue0(v.Pos, OpXor32, t) 31657 v0.AddArg(z) 31658 v0.AddArg(x) 31659 v.AddArg(v0) 31660 return true 31661 } 31662 return false 31663 } 31664 func rewriteValuegeneric_OpXor32_10(v *Value) bool { 31665 b := v.Block 31666 _ = b 31667 // match: (Xor32 (Xor32 z i:(Const32 <t>)) x) 31668 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 31669 // result: (Xor32 i (Xor32 <t> z x)) 31670 for { 31671 _ = v.Args[1] 31672 v_0 := v.Args[0] 31673 if v_0.Op != OpXor32 { 31674 break 31675 } 31676 _ = v_0.Args[1] 31677 z := v_0.Args[0] 31678 i := v_0.Args[1] 31679 if i.Op != OpConst32 { 31680 break 31681 } 31682 t := i.Type 31683 x := v.Args[1] 31684 if !(z.Op != OpConst32 && x.Op != OpConst32) { 31685 break 31686 } 31687 v.reset(OpXor32) 31688 v.AddArg(i) 31689 v0 := b.NewValue0(v.Pos, OpXor32, t) 31690 v0.AddArg(z) 31691 v0.AddArg(x) 31692 v.AddArg(v0) 31693 return true 31694 } 31695 // match: (Xor32 x (Xor32 i:(Const32 <t>) z)) 31696 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 31697 // result: (Xor32 i (Xor32 <t> z x)) 31698 for { 31699 _ = v.Args[1] 31700 x := v.Args[0] 31701 v_1 := v.Args[1] 31702 if v_1.Op != OpXor32 { 31703 break 31704 } 31705 _ = v_1.Args[1] 31706 i := v_1.Args[0] 31707 if i.Op != OpConst32 { 31708 break 31709 } 31710 t := i.Type 31711 z := v_1.Args[1] 31712 if !(z.Op != OpConst32 && x.Op != OpConst32) { 31713 break 31714 } 31715 v.reset(OpXor32) 31716 v.AddArg(i) 31717 v0 := b.NewValue0(v.Pos, OpXor32, t) 31718 v0.AddArg(z) 31719 v0.AddArg(x) 31720 v.AddArg(v0) 31721 return true 31722 } 31723 // match: (Xor32 x (Xor32 z i:(Const32 <t>))) 31724 // cond: (z.Op != OpConst32 && x.Op != OpConst32) 31725 // result: (Xor32 i (Xor32 <t> z x)) 31726 for { 31727 _ = v.Args[1] 31728 x := v.Args[0] 31729 v_1 := v.Args[1] 31730 if v_1.Op != OpXor32 { 31731 break 31732 } 31733 _ = v_1.Args[1] 31734 z := v_1.Args[0] 31735 i := v_1.Args[1] 31736 if i.Op != OpConst32 { 31737 break 31738 } 31739 t := i.Type 31740 if !(z.Op != OpConst32 && x.Op != OpConst32) { 31741 break 31742 } 31743 v.reset(OpXor32) 31744 v.AddArg(i) 31745 v0 := b.NewValue0(v.Pos, OpXor32, t) 31746 v0.AddArg(z) 31747 v0.AddArg(x) 31748 v.AddArg(v0) 31749 return true 31750 } 31751 // match: (Xor32 (Const32 <t> [c]) (Xor32 (Const32 <t> [d]) x)) 31752 // cond: 31753 // result: (Xor32 (Const32 <t> [int64(int32(c^d))]) x) 31754 for { 31755 _ = v.Args[1] 31756 v_0 := v.Args[0] 31757 if v_0.Op != OpConst32 { 31758 break 31759 } 31760 t := v_0.Type 31761 c := v_0.AuxInt 31762 v_1 := v.Args[1] 31763 if v_1.Op != OpXor32 { 31764 break 31765 } 31766 _ = v_1.Args[1] 31767 v_1_0 := v_1.Args[0] 31768 if v_1_0.Op != OpConst32 { 31769 break 31770 } 31771 if v_1_0.Type != t { 31772 break 31773 } 31774 d := v_1_0.AuxInt 31775 x := v_1.Args[1] 31776 v.reset(OpXor32) 31777 v0 := b.NewValue0(v.Pos, OpConst32, t) 31778 v0.AuxInt = int64(int32(c ^ d)) 31779 v.AddArg(v0) 31780 v.AddArg(x) 31781 return true 31782 } 31783 // match: (Xor32 (Const32 <t> [c]) (Xor32 x (Const32 <t> [d]))) 31784 // cond: 31785 // result: (Xor32 (Const32 <t> [int64(int32(c^d))]) x) 31786 for { 31787 _ = v.Args[1] 31788 v_0 := v.Args[0] 31789 if v_0.Op != OpConst32 { 31790 break 31791 } 31792 t := v_0.Type 31793 c := v_0.AuxInt 31794 v_1 := v.Args[1] 31795 if v_1.Op != OpXor32 { 31796 break 31797 } 31798 _ = v_1.Args[1] 31799 x := v_1.Args[0] 31800 v_1_1 := v_1.Args[1] 31801 if v_1_1.Op != OpConst32 { 31802 break 31803 } 31804 if v_1_1.Type != t { 31805 break 31806 } 31807 d := v_1_1.AuxInt 31808 v.reset(OpXor32) 31809 v0 := b.NewValue0(v.Pos, OpConst32, t) 31810 v0.AuxInt = int64(int32(c ^ d)) 31811 v.AddArg(v0) 31812 v.AddArg(x) 31813 return true 31814 } 31815 // match: (Xor32 (Xor32 (Const32 <t> [d]) x) (Const32 <t> [c])) 31816 // cond: 31817 // result: (Xor32 (Const32 <t> [int64(int32(c^d))]) x) 31818 for { 31819 _ = v.Args[1] 31820 v_0 := v.Args[0] 31821 if v_0.Op != OpXor32 { 31822 break 31823 } 31824 _ = v_0.Args[1] 31825 v_0_0 := v_0.Args[0] 31826 if v_0_0.Op != OpConst32 { 31827 break 31828 } 31829 t := v_0_0.Type 31830 d := v_0_0.AuxInt 31831 x := v_0.Args[1] 31832 v_1 := v.Args[1] 31833 if v_1.Op != OpConst32 { 31834 break 31835 } 31836 if v_1.Type != t { 31837 break 31838 } 31839 c := v_1.AuxInt 31840 v.reset(OpXor32) 31841 v0 := b.NewValue0(v.Pos, OpConst32, t) 31842 v0.AuxInt = int64(int32(c ^ d)) 31843 v.AddArg(v0) 31844 v.AddArg(x) 31845 return true 31846 } 31847 // match: (Xor32 (Xor32 x (Const32 <t> [d])) (Const32 <t> [c])) 31848 // cond: 31849 // result: (Xor32 (Const32 <t> [int64(int32(c^d))]) x) 31850 for { 31851 _ = v.Args[1] 31852 v_0 := v.Args[0] 31853 if v_0.Op != OpXor32 { 31854 break 31855 } 31856 _ = v_0.Args[1] 31857 x := v_0.Args[0] 31858 v_0_1 := v_0.Args[1] 31859 if v_0_1.Op != OpConst32 { 31860 break 31861 } 31862 t := v_0_1.Type 31863 d := v_0_1.AuxInt 31864 v_1 := v.Args[1] 31865 if v_1.Op != OpConst32 { 31866 break 31867 } 31868 if v_1.Type != t { 31869 break 31870 } 31871 c := v_1.AuxInt 31872 v.reset(OpXor32) 31873 v0 := b.NewValue0(v.Pos, OpConst32, t) 31874 v0.AuxInt = int64(int32(c ^ d)) 31875 v.AddArg(v0) 31876 v.AddArg(x) 31877 return true 31878 } 31879 return false 31880 } 31881 func rewriteValuegeneric_OpXor64_0(v *Value) bool { 31882 b := v.Block 31883 _ = b 31884 // match: (Xor64 (Const64 [c]) (Const64 [d])) 31885 // cond: 31886 // result: (Const64 [c^d]) 31887 for { 31888 _ = v.Args[1] 31889 v_0 := v.Args[0] 31890 if v_0.Op != OpConst64 { 31891 break 31892 } 31893 c := v_0.AuxInt 31894 v_1 := v.Args[1] 31895 if v_1.Op != OpConst64 { 31896 break 31897 } 31898 d := v_1.AuxInt 31899 v.reset(OpConst64) 31900 v.AuxInt = c ^ d 31901 return true 31902 } 31903 // match: (Xor64 (Const64 [d]) (Const64 [c])) 31904 // cond: 31905 // result: (Const64 [c^d]) 31906 for { 31907 _ = v.Args[1] 31908 v_0 := v.Args[0] 31909 if v_0.Op != OpConst64 { 31910 break 31911 } 31912 d := v_0.AuxInt 31913 v_1 := v.Args[1] 31914 if v_1.Op != OpConst64 { 31915 break 31916 } 31917 c := v_1.AuxInt 31918 v.reset(OpConst64) 31919 v.AuxInt = c ^ d 31920 return true 31921 } 31922 // match: (Xor64 x x) 31923 // cond: 31924 // result: (Const64 [0]) 31925 for { 31926 _ = v.Args[1] 31927 x := v.Args[0] 31928 if x != v.Args[1] { 31929 break 31930 } 31931 v.reset(OpConst64) 31932 v.AuxInt = 0 31933 return true 31934 } 31935 // match: (Xor64 (Const64 [0]) x) 31936 // cond: 31937 // result: x 31938 for { 31939 _ = v.Args[1] 31940 v_0 := v.Args[0] 31941 if v_0.Op != OpConst64 { 31942 break 31943 } 31944 if v_0.AuxInt != 0 { 31945 break 31946 } 31947 x := v.Args[1] 31948 v.reset(OpCopy) 31949 v.Type = x.Type 31950 v.AddArg(x) 31951 return true 31952 } 31953 // match: (Xor64 x (Const64 [0])) 31954 // cond: 31955 // result: x 31956 for { 31957 _ = v.Args[1] 31958 x := v.Args[0] 31959 v_1 := v.Args[1] 31960 if v_1.Op != OpConst64 { 31961 break 31962 } 31963 if v_1.AuxInt != 0 { 31964 break 31965 } 31966 v.reset(OpCopy) 31967 v.Type = x.Type 31968 v.AddArg(x) 31969 return true 31970 } 31971 // match: (Xor64 x (Xor64 x y)) 31972 // cond: 31973 // result: y 31974 for { 31975 _ = v.Args[1] 31976 x := v.Args[0] 31977 v_1 := v.Args[1] 31978 if v_1.Op != OpXor64 { 31979 break 31980 } 31981 _ = v_1.Args[1] 31982 if x != v_1.Args[0] { 31983 break 31984 } 31985 y := v_1.Args[1] 31986 v.reset(OpCopy) 31987 v.Type = y.Type 31988 v.AddArg(y) 31989 return true 31990 } 31991 // match: (Xor64 x (Xor64 y x)) 31992 // cond: 31993 // result: y 31994 for { 31995 _ = v.Args[1] 31996 x := v.Args[0] 31997 v_1 := v.Args[1] 31998 if v_1.Op != OpXor64 { 31999 break 32000 } 32001 _ = v_1.Args[1] 32002 y := v_1.Args[0] 32003 if x != v_1.Args[1] { 32004 break 32005 } 32006 v.reset(OpCopy) 32007 v.Type = y.Type 32008 v.AddArg(y) 32009 return true 32010 } 32011 // match: (Xor64 (Xor64 x y) x) 32012 // cond: 32013 // result: y 32014 for { 32015 _ = v.Args[1] 32016 v_0 := v.Args[0] 32017 if v_0.Op != OpXor64 { 32018 break 32019 } 32020 _ = v_0.Args[1] 32021 x := v_0.Args[0] 32022 y := v_0.Args[1] 32023 if x != v.Args[1] { 32024 break 32025 } 32026 v.reset(OpCopy) 32027 v.Type = y.Type 32028 v.AddArg(y) 32029 return true 32030 } 32031 // match: (Xor64 (Xor64 y x) x) 32032 // cond: 32033 // result: y 32034 for { 32035 _ = v.Args[1] 32036 v_0 := v.Args[0] 32037 if v_0.Op != OpXor64 { 32038 break 32039 } 32040 _ = v_0.Args[1] 32041 y := v_0.Args[0] 32042 x := v_0.Args[1] 32043 if x != v.Args[1] { 32044 break 32045 } 32046 v.reset(OpCopy) 32047 v.Type = y.Type 32048 v.AddArg(y) 32049 return true 32050 } 32051 // match: (Xor64 (Xor64 i:(Const64 <t>) z) x) 32052 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 32053 // result: (Xor64 i (Xor64 <t> z x)) 32054 for { 32055 _ = v.Args[1] 32056 v_0 := v.Args[0] 32057 if v_0.Op != OpXor64 { 32058 break 32059 } 32060 _ = v_0.Args[1] 32061 i := v_0.Args[0] 32062 if i.Op != OpConst64 { 32063 break 32064 } 32065 t := i.Type 32066 z := v_0.Args[1] 32067 x := v.Args[1] 32068 if !(z.Op != OpConst64 && x.Op != OpConst64) { 32069 break 32070 } 32071 v.reset(OpXor64) 32072 v.AddArg(i) 32073 v0 := b.NewValue0(v.Pos, OpXor64, t) 32074 v0.AddArg(z) 32075 v0.AddArg(x) 32076 v.AddArg(v0) 32077 return true 32078 } 32079 return false 32080 } 32081 func rewriteValuegeneric_OpXor64_10(v *Value) bool { 32082 b := v.Block 32083 _ = b 32084 // match: (Xor64 (Xor64 z i:(Const64 <t>)) x) 32085 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 32086 // result: (Xor64 i (Xor64 <t> z x)) 32087 for { 32088 _ = v.Args[1] 32089 v_0 := v.Args[0] 32090 if v_0.Op != OpXor64 { 32091 break 32092 } 32093 _ = v_0.Args[1] 32094 z := v_0.Args[0] 32095 i := v_0.Args[1] 32096 if i.Op != OpConst64 { 32097 break 32098 } 32099 t := i.Type 32100 x := v.Args[1] 32101 if !(z.Op != OpConst64 && x.Op != OpConst64) { 32102 break 32103 } 32104 v.reset(OpXor64) 32105 v.AddArg(i) 32106 v0 := b.NewValue0(v.Pos, OpXor64, t) 32107 v0.AddArg(z) 32108 v0.AddArg(x) 32109 v.AddArg(v0) 32110 return true 32111 } 32112 // match: (Xor64 x (Xor64 i:(Const64 <t>) z)) 32113 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 32114 // result: (Xor64 i (Xor64 <t> z x)) 32115 for { 32116 _ = v.Args[1] 32117 x := v.Args[0] 32118 v_1 := v.Args[1] 32119 if v_1.Op != OpXor64 { 32120 break 32121 } 32122 _ = v_1.Args[1] 32123 i := v_1.Args[0] 32124 if i.Op != OpConst64 { 32125 break 32126 } 32127 t := i.Type 32128 z := v_1.Args[1] 32129 if !(z.Op != OpConst64 && x.Op != OpConst64) { 32130 break 32131 } 32132 v.reset(OpXor64) 32133 v.AddArg(i) 32134 v0 := b.NewValue0(v.Pos, OpXor64, t) 32135 v0.AddArg(z) 32136 v0.AddArg(x) 32137 v.AddArg(v0) 32138 return true 32139 } 32140 // match: (Xor64 x (Xor64 z i:(Const64 <t>))) 32141 // cond: (z.Op != OpConst64 && x.Op != OpConst64) 32142 // result: (Xor64 i (Xor64 <t> z x)) 32143 for { 32144 _ = v.Args[1] 32145 x := v.Args[0] 32146 v_1 := v.Args[1] 32147 if v_1.Op != OpXor64 { 32148 break 32149 } 32150 _ = v_1.Args[1] 32151 z := v_1.Args[0] 32152 i := v_1.Args[1] 32153 if i.Op != OpConst64 { 32154 break 32155 } 32156 t := i.Type 32157 if !(z.Op != OpConst64 && x.Op != OpConst64) { 32158 break 32159 } 32160 v.reset(OpXor64) 32161 v.AddArg(i) 32162 v0 := b.NewValue0(v.Pos, OpXor64, t) 32163 v0.AddArg(z) 32164 v0.AddArg(x) 32165 v.AddArg(v0) 32166 return true 32167 } 32168 // match: (Xor64 (Const64 <t> [c]) (Xor64 (Const64 <t> [d]) x)) 32169 // cond: 32170 // result: (Xor64 (Const64 <t> [c^d]) x) 32171 for { 32172 _ = v.Args[1] 32173 v_0 := v.Args[0] 32174 if v_0.Op != OpConst64 { 32175 break 32176 } 32177 t := v_0.Type 32178 c := v_0.AuxInt 32179 v_1 := v.Args[1] 32180 if v_1.Op != OpXor64 { 32181 break 32182 } 32183 _ = v_1.Args[1] 32184 v_1_0 := v_1.Args[0] 32185 if v_1_0.Op != OpConst64 { 32186 break 32187 } 32188 if v_1_0.Type != t { 32189 break 32190 } 32191 d := v_1_0.AuxInt 32192 x := v_1.Args[1] 32193 v.reset(OpXor64) 32194 v0 := b.NewValue0(v.Pos, OpConst64, t) 32195 v0.AuxInt = c ^ d 32196 v.AddArg(v0) 32197 v.AddArg(x) 32198 return true 32199 } 32200 // match: (Xor64 (Const64 <t> [c]) (Xor64 x (Const64 <t> [d]))) 32201 // cond: 32202 // result: (Xor64 (Const64 <t> [c^d]) x) 32203 for { 32204 _ = v.Args[1] 32205 v_0 := v.Args[0] 32206 if v_0.Op != OpConst64 { 32207 break 32208 } 32209 t := v_0.Type 32210 c := v_0.AuxInt 32211 v_1 := v.Args[1] 32212 if v_1.Op != OpXor64 { 32213 break 32214 } 32215 _ = v_1.Args[1] 32216 x := v_1.Args[0] 32217 v_1_1 := v_1.Args[1] 32218 if v_1_1.Op != OpConst64 { 32219 break 32220 } 32221 if v_1_1.Type != t { 32222 break 32223 } 32224 d := v_1_1.AuxInt 32225 v.reset(OpXor64) 32226 v0 := b.NewValue0(v.Pos, OpConst64, t) 32227 v0.AuxInt = c ^ d 32228 v.AddArg(v0) 32229 v.AddArg(x) 32230 return true 32231 } 32232 // match: (Xor64 (Xor64 (Const64 <t> [d]) x) (Const64 <t> [c])) 32233 // cond: 32234 // result: (Xor64 (Const64 <t> [c^d]) x) 32235 for { 32236 _ = v.Args[1] 32237 v_0 := v.Args[0] 32238 if v_0.Op != OpXor64 { 32239 break 32240 } 32241 _ = v_0.Args[1] 32242 v_0_0 := v_0.Args[0] 32243 if v_0_0.Op != OpConst64 { 32244 break 32245 } 32246 t := v_0_0.Type 32247 d := v_0_0.AuxInt 32248 x := v_0.Args[1] 32249 v_1 := v.Args[1] 32250 if v_1.Op != OpConst64 { 32251 break 32252 } 32253 if v_1.Type != t { 32254 break 32255 } 32256 c := v_1.AuxInt 32257 v.reset(OpXor64) 32258 v0 := b.NewValue0(v.Pos, OpConst64, t) 32259 v0.AuxInt = c ^ d 32260 v.AddArg(v0) 32261 v.AddArg(x) 32262 return true 32263 } 32264 // match: (Xor64 (Xor64 x (Const64 <t> [d])) (Const64 <t> [c])) 32265 // cond: 32266 // result: (Xor64 (Const64 <t> [c^d]) x) 32267 for { 32268 _ = v.Args[1] 32269 v_0 := v.Args[0] 32270 if v_0.Op != OpXor64 { 32271 break 32272 } 32273 _ = v_0.Args[1] 32274 x := v_0.Args[0] 32275 v_0_1 := v_0.Args[1] 32276 if v_0_1.Op != OpConst64 { 32277 break 32278 } 32279 t := v_0_1.Type 32280 d := v_0_1.AuxInt 32281 v_1 := v.Args[1] 32282 if v_1.Op != OpConst64 { 32283 break 32284 } 32285 if v_1.Type != t { 32286 break 32287 } 32288 c := v_1.AuxInt 32289 v.reset(OpXor64) 32290 v0 := b.NewValue0(v.Pos, OpConst64, t) 32291 v0.AuxInt = c ^ d 32292 v.AddArg(v0) 32293 v.AddArg(x) 32294 return true 32295 } 32296 return false 32297 } 32298 func rewriteValuegeneric_OpXor8_0(v *Value) bool { 32299 b := v.Block 32300 _ = b 32301 // match: (Xor8 (Const8 [c]) (Const8 [d])) 32302 // cond: 32303 // result: (Const8 [int64(int8(c^d))]) 32304 for { 32305 _ = v.Args[1] 32306 v_0 := v.Args[0] 32307 if v_0.Op != OpConst8 { 32308 break 32309 } 32310 c := v_0.AuxInt 32311 v_1 := v.Args[1] 32312 if v_1.Op != OpConst8 { 32313 break 32314 } 32315 d := v_1.AuxInt 32316 v.reset(OpConst8) 32317 v.AuxInt = int64(int8(c ^ d)) 32318 return true 32319 } 32320 // match: (Xor8 (Const8 [d]) (Const8 [c])) 32321 // cond: 32322 // result: (Const8 [int64(int8(c^d))]) 32323 for { 32324 _ = v.Args[1] 32325 v_0 := v.Args[0] 32326 if v_0.Op != OpConst8 { 32327 break 32328 } 32329 d := v_0.AuxInt 32330 v_1 := v.Args[1] 32331 if v_1.Op != OpConst8 { 32332 break 32333 } 32334 c := v_1.AuxInt 32335 v.reset(OpConst8) 32336 v.AuxInt = int64(int8(c ^ d)) 32337 return true 32338 } 32339 // match: (Xor8 x x) 32340 // cond: 32341 // result: (Const8 [0]) 32342 for { 32343 _ = v.Args[1] 32344 x := v.Args[0] 32345 if x != v.Args[1] { 32346 break 32347 } 32348 v.reset(OpConst8) 32349 v.AuxInt = 0 32350 return true 32351 } 32352 // match: (Xor8 (Const8 [0]) x) 32353 // cond: 32354 // result: x 32355 for { 32356 _ = v.Args[1] 32357 v_0 := v.Args[0] 32358 if v_0.Op != OpConst8 { 32359 break 32360 } 32361 if v_0.AuxInt != 0 { 32362 break 32363 } 32364 x := v.Args[1] 32365 v.reset(OpCopy) 32366 v.Type = x.Type 32367 v.AddArg(x) 32368 return true 32369 } 32370 // match: (Xor8 x (Const8 [0])) 32371 // cond: 32372 // result: x 32373 for { 32374 _ = v.Args[1] 32375 x := v.Args[0] 32376 v_1 := v.Args[1] 32377 if v_1.Op != OpConst8 { 32378 break 32379 } 32380 if v_1.AuxInt != 0 { 32381 break 32382 } 32383 v.reset(OpCopy) 32384 v.Type = x.Type 32385 v.AddArg(x) 32386 return true 32387 } 32388 // match: (Xor8 x (Xor8 x y)) 32389 // cond: 32390 // result: y 32391 for { 32392 _ = v.Args[1] 32393 x := v.Args[0] 32394 v_1 := v.Args[1] 32395 if v_1.Op != OpXor8 { 32396 break 32397 } 32398 _ = v_1.Args[1] 32399 if x != v_1.Args[0] { 32400 break 32401 } 32402 y := v_1.Args[1] 32403 v.reset(OpCopy) 32404 v.Type = y.Type 32405 v.AddArg(y) 32406 return true 32407 } 32408 // match: (Xor8 x (Xor8 y x)) 32409 // cond: 32410 // result: y 32411 for { 32412 _ = v.Args[1] 32413 x := v.Args[0] 32414 v_1 := v.Args[1] 32415 if v_1.Op != OpXor8 { 32416 break 32417 } 32418 _ = v_1.Args[1] 32419 y := v_1.Args[0] 32420 if x != v_1.Args[1] { 32421 break 32422 } 32423 v.reset(OpCopy) 32424 v.Type = y.Type 32425 v.AddArg(y) 32426 return true 32427 } 32428 // match: (Xor8 (Xor8 x y) x) 32429 // cond: 32430 // result: y 32431 for { 32432 _ = v.Args[1] 32433 v_0 := v.Args[0] 32434 if v_0.Op != OpXor8 { 32435 break 32436 } 32437 _ = v_0.Args[1] 32438 x := v_0.Args[0] 32439 y := v_0.Args[1] 32440 if x != v.Args[1] { 32441 break 32442 } 32443 v.reset(OpCopy) 32444 v.Type = y.Type 32445 v.AddArg(y) 32446 return true 32447 } 32448 // match: (Xor8 (Xor8 y x) x) 32449 // cond: 32450 // result: y 32451 for { 32452 _ = v.Args[1] 32453 v_0 := v.Args[0] 32454 if v_0.Op != OpXor8 { 32455 break 32456 } 32457 _ = v_0.Args[1] 32458 y := v_0.Args[0] 32459 x := v_0.Args[1] 32460 if x != v.Args[1] { 32461 break 32462 } 32463 v.reset(OpCopy) 32464 v.Type = y.Type 32465 v.AddArg(y) 32466 return true 32467 } 32468 // match: (Xor8 (Xor8 i:(Const8 <t>) z) x) 32469 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 32470 // result: (Xor8 i (Xor8 <t> z x)) 32471 for { 32472 _ = v.Args[1] 32473 v_0 := v.Args[0] 32474 if v_0.Op != OpXor8 { 32475 break 32476 } 32477 _ = v_0.Args[1] 32478 i := v_0.Args[0] 32479 if i.Op != OpConst8 { 32480 break 32481 } 32482 t := i.Type 32483 z := v_0.Args[1] 32484 x := v.Args[1] 32485 if !(z.Op != OpConst8 && x.Op != OpConst8) { 32486 break 32487 } 32488 v.reset(OpXor8) 32489 v.AddArg(i) 32490 v0 := b.NewValue0(v.Pos, OpXor8, t) 32491 v0.AddArg(z) 32492 v0.AddArg(x) 32493 v.AddArg(v0) 32494 return true 32495 } 32496 return false 32497 } 32498 func rewriteValuegeneric_OpXor8_10(v *Value) bool { 32499 b := v.Block 32500 _ = b 32501 // match: (Xor8 (Xor8 z i:(Const8 <t>)) x) 32502 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 32503 // result: (Xor8 i (Xor8 <t> z x)) 32504 for { 32505 _ = v.Args[1] 32506 v_0 := v.Args[0] 32507 if v_0.Op != OpXor8 { 32508 break 32509 } 32510 _ = v_0.Args[1] 32511 z := v_0.Args[0] 32512 i := v_0.Args[1] 32513 if i.Op != OpConst8 { 32514 break 32515 } 32516 t := i.Type 32517 x := v.Args[1] 32518 if !(z.Op != OpConst8 && x.Op != OpConst8) { 32519 break 32520 } 32521 v.reset(OpXor8) 32522 v.AddArg(i) 32523 v0 := b.NewValue0(v.Pos, OpXor8, t) 32524 v0.AddArg(z) 32525 v0.AddArg(x) 32526 v.AddArg(v0) 32527 return true 32528 } 32529 // match: (Xor8 x (Xor8 i:(Const8 <t>) z)) 32530 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 32531 // result: (Xor8 i (Xor8 <t> z x)) 32532 for { 32533 _ = v.Args[1] 32534 x := v.Args[0] 32535 v_1 := v.Args[1] 32536 if v_1.Op != OpXor8 { 32537 break 32538 } 32539 _ = v_1.Args[1] 32540 i := v_1.Args[0] 32541 if i.Op != OpConst8 { 32542 break 32543 } 32544 t := i.Type 32545 z := v_1.Args[1] 32546 if !(z.Op != OpConst8 && x.Op != OpConst8) { 32547 break 32548 } 32549 v.reset(OpXor8) 32550 v.AddArg(i) 32551 v0 := b.NewValue0(v.Pos, OpXor8, t) 32552 v0.AddArg(z) 32553 v0.AddArg(x) 32554 v.AddArg(v0) 32555 return true 32556 } 32557 // match: (Xor8 x (Xor8 z i:(Const8 <t>))) 32558 // cond: (z.Op != OpConst8 && x.Op != OpConst8) 32559 // result: (Xor8 i (Xor8 <t> z x)) 32560 for { 32561 _ = v.Args[1] 32562 x := v.Args[0] 32563 v_1 := v.Args[1] 32564 if v_1.Op != OpXor8 { 32565 break 32566 } 32567 _ = v_1.Args[1] 32568 z := v_1.Args[0] 32569 i := v_1.Args[1] 32570 if i.Op != OpConst8 { 32571 break 32572 } 32573 t := i.Type 32574 if !(z.Op != OpConst8 && x.Op != OpConst8) { 32575 break 32576 } 32577 v.reset(OpXor8) 32578 v.AddArg(i) 32579 v0 := b.NewValue0(v.Pos, OpXor8, t) 32580 v0.AddArg(z) 32581 v0.AddArg(x) 32582 v.AddArg(v0) 32583 return true 32584 } 32585 // match: (Xor8 (Const8 <t> [c]) (Xor8 (Const8 <t> [d]) x)) 32586 // cond: 32587 // result: (Xor8 (Const8 <t> [int64(int8(c^d))]) x) 32588 for { 32589 _ = v.Args[1] 32590 v_0 := v.Args[0] 32591 if v_0.Op != OpConst8 { 32592 break 32593 } 32594 t := v_0.Type 32595 c := v_0.AuxInt 32596 v_1 := v.Args[1] 32597 if v_1.Op != OpXor8 { 32598 break 32599 } 32600 _ = v_1.Args[1] 32601 v_1_0 := v_1.Args[0] 32602 if v_1_0.Op != OpConst8 { 32603 break 32604 } 32605 if v_1_0.Type != t { 32606 break 32607 } 32608 d := v_1_0.AuxInt 32609 x := v_1.Args[1] 32610 v.reset(OpXor8) 32611 v0 := b.NewValue0(v.Pos, OpConst8, t) 32612 v0.AuxInt = int64(int8(c ^ d)) 32613 v.AddArg(v0) 32614 v.AddArg(x) 32615 return true 32616 } 32617 // match: (Xor8 (Const8 <t> [c]) (Xor8 x (Const8 <t> [d]))) 32618 // cond: 32619 // result: (Xor8 (Const8 <t> [int64(int8(c^d))]) x) 32620 for { 32621 _ = v.Args[1] 32622 v_0 := v.Args[0] 32623 if v_0.Op != OpConst8 { 32624 break 32625 } 32626 t := v_0.Type 32627 c := v_0.AuxInt 32628 v_1 := v.Args[1] 32629 if v_1.Op != OpXor8 { 32630 break 32631 } 32632 _ = v_1.Args[1] 32633 x := v_1.Args[0] 32634 v_1_1 := v_1.Args[1] 32635 if v_1_1.Op != OpConst8 { 32636 break 32637 } 32638 if v_1_1.Type != t { 32639 break 32640 } 32641 d := v_1_1.AuxInt 32642 v.reset(OpXor8) 32643 v0 := b.NewValue0(v.Pos, OpConst8, t) 32644 v0.AuxInt = int64(int8(c ^ d)) 32645 v.AddArg(v0) 32646 v.AddArg(x) 32647 return true 32648 } 32649 // match: (Xor8 (Xor8 (Const8 <t> [d]) x) (Const8 <t> [c])) 32650 // cond: 32651 // result: (Xor8 (Const8 <t> [int64(int8(c^d))]) x) 32652 for { 32653 _ = v.Args[1] 32654 v_0 := v.Args[0] 32655 if v_0.Op != OpXor8 { 32656 break 32657 } 32658 _ = v_0.Args[1] 32659 v_0_0 := v_0.Args[0] 32660 if v_0_0.Op != OpConst8 { 32661 break 32662 } 32663 t := v_0_0.Type 32664 d := v_0_0.AuxInt 32665 x := v_0.Args[1] 32666 v_1 := v.Args[1] 32667 if v_1.Op != OpConst8 { 32668 break 32669 } 32670 if v_1.Type != t { 32671 break 32672 } 32673 c := v_1.AuxInt 32674 v.reset(OpXor8) 32675 v0 := b.NewValue0(v.Pos, OpConst8, t) 32676 v0.AuxInt = int64(int8(c ^ d)) 32677 v.AddArg(v0) 32678 v.AddArg(x) 32679 return true 32680 } 32681 // match: (Xor8 (Xor8 x (Const8 <t> [d])) (Const8 <t> [c])) 32682 // cond: 32683 // result: (Xor8 (Const8 <t> [int64(int8(c^d))]) x) 32684 for { 32685 _ = v.Args[1] 32686 v_0 := v.Args[0] 32687 if v_0.Op != OpXor8 { 32688 break 32689 } 32690 _ = v_0.Args[1] 32691 x := v_0.Args[0] 32692 v_0_1 := v_0.Args[1] 32693 if v_0_1.Op != OpConst8 { 32694 break 32695 } 32696 t := v_0_1.Type 32697 d := v_0_1.AuxInt 32698 v_1 := v.Args[1] 32699 if v_1.Op != OpConst8 { 32700 break 32701 } 32702 if v_1.Type != t { 32703 break 32704 } 32705 c := v_1.AuxInt 32706 v.reset(OpXor8) 32707 v0 := b.NewValue0(v.Pos, OpConst8, t) 32708 v0.AuxInt = int64(int8(c ^ d)) 32709 v.AddArg(v0) 32710 v.AddArg(x) 32711 return true 32712 } 32713 return false 32714 } 32715 func rewriteValuegeneric_OpZero_0(v *Value) bool { 32716 b := v.Block 32717 _ = b 32718 config := b.Func.Config 32719 _ = config 32720 // match: (Zero (Load (OffPtr [c] (SP)) mem) mem) 32721 // cond: mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize 32722 // result: mem 32723 for { 32724 _ = v.Args[1] 32725 v_0 := v.Args[0] 32726 if v_0.Op != OpLoad { 32727 break 32728 } 32729 _ = v_0.Args[1] 32730 v_0_0 := v_0.Args[0] 32731 if v_0_0.Op != OpOffPtr { 32732 break 32733 } 32734 c := v_0_0.AuxInt 32735 v_0_0_0 := v_0_0.Args[0] 32736 if v_0_0_0.Op != OpSP { 32737 break 32738 } 32739 mem := v_0.Args[1] 32740 if mem != v.Args[1] { 32741 break 32742 } 32743 if !(mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) { 32744 break 32745 } 32746 v.reset(OpCopy) 32747 v.Type = mem.Type 32748 v.AddArg(mem) 32749 return true 32750 } 32751 // match: (Zero {t1} [n] p1 store:(Store {t2} (OffPtr [o2] p2) _ mem)) 32752 // cond: isSamePtr(p1, p2) && store.Uses == 1 && n >= o2 + sizeof(t2) && clobber(store) 32753 // result: (Zero {t1} [n] p1 mem) 32754 for { 32755 n := v.AuxInt 32756 t1 := v.Aux 32757 _ = v.Args[1] 32758 p1 := v.Args[0] 32759 store := v.Args[1] 32760 if store.Op != OpStore { 32761 break 32762 } 32763 t2 := store.Aux 32764 _ = store.Args[2] 32765 store_0 := store.Args[0] 32766 if store_0.Op != OpOffPtr { 32767 break 32768 } 32769 o2 := store_0.AuxInt 32770 p2 := store_0.Args[0] 32771 mem := store.Args[2] 32772 if !(isSamePtr(p1, p2) && store.Uses == 1 && n >= o2+sizeof(t2) && clobber(store)) { 32773 break 32774 } 32775 v.reset(OpZero) 32776 v.AuxInt = n 32777 v.Aux = t1 32778 v.AddArg(p1) 32779 v.AddArg(mem) 32780 return true 32781 } 32782 // match: (Zero {t} [n] dst1 move:(Move {t} [n] dst2 _ mem)) 32783 // cond: move.Uses == 1 && isSamePtr(dst1, dst2) && clobber(move) 32784 // result: (Zero {t} [n] dst1 mem) 32785 for { 32786 n := v.AuxInt 32787 t := v.Aux 32788 _ = v.Args[1] 32789 dst1 := v.Args[0] 32790 move := v.Args[1] 32791 if move.Op != OpMove { 32792 break 32793 } 32794 if move.AuxInt != n { 32795 break 32796 } 32797 if move.Aux != t { 32798 break 32799 } 32800 _ = move.Args[2] 32801 dst2 := move.Args[0] 32802 mem := move.Args[2] 32803 if !(move.Uses == 1 && isSamePtr(dst1, dst2) && clobber(move)) { 32804 break 32805 } 32806 v.reset(OpZero) 32807 v.AuxInt = n 32808 v.Aux = t 32809 v.AddArg(dst1) 32810 v.AddArg(mem) 32811 return true 32812 } 32813 // match: (Zero {t} [n] dst1 vardef:(VarDef {x} move:(Move {t} [n] dst2 _ mem))) 32814 // cond: move.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && clobber(move) && clobber(vardef) 32815 // result: (Zero {t} [n] dst1 (VarDef {x} mem)) 32816 for { 32817 n := v.AuxInt 32818 t := v.Aux 32819 _ = v.Args[1] 32820 dst1 := v.Args[0] 32821 vardef := v.Args[1] 32822 if vardef.Op != OpVarDef { 32823 break 32824 } 32825 x := vardef.Aux 32826 move := vardef.Args[0] 32827 if move.Op != OpMove { 32828 break 32829 } 32830 if move.AuxInt != n { 32831 break 32832 } 32833 if move.Aux != t { 32834 break 32835 } 32836 _ = move.Args[2] 32837 dst2 := move.Args[0] 32838 mem := move.Args[2] 32839 if !(move.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && clobber(move) && clobber(vardef)) { 32840 break 32841 } 32842 v.reset(OpZero) 32843 v.AuxInt = n 32844 v.Aux = t 32845 v.AddArg(dst1) 32846 v0 := b.NewValue0(v.Pos, OpVarDef, types.TypeMem) 32847 v0.Aux = x 32848 v0.AddArg(mem) 32849 v.AddArg(v0) 32850 return true 32851 } 32852 return false 32853 } 32854 func rewriteValuegeneric_OpZeroExt16to32_0(v *Value) bool { 32855 // match: (ZeroExt16to32 (Const16 [c])) 32856 // cond: 32857 // result: (Const32 [int64(uint16(c))]) 32858 for { 32859 v_0 := v.Args[0] 32860 if v_0.Op != OpConst16 { 32861 break 32862 } 32863 c := v_0.AuxInt 32864 v.reset(OpConst32) 32865 v.AuxInt = int64(uint16(c)) 32866 return true 32867 } 32868 // match: (ZeroExt16to32 (Trunc32to16 x:(Rsh32Ux64 _ (Const64 [s])))) 32869 // cond: s >= 16 32870 // result: x 32871 for { 32872 v_0 := v.Args[0] 32873 if v_0.Op != OpTrunc32to16 { 32874 break 32875 } 32876 x := v_0.Args[0] 32877 if x.Op != OpRsh32Ux64 { 32878 break 32879 } 32880 _ = x.Args[1] 32881 x_1 := x.Args[1] 32882 if x_1.Op != OpConst64 { 32883 break 32884 } 32885 s := x_1.AuxInt 32886 if !(s >= 16) { 32887 break 32888 } 32889 v.reset(OpCopy) 32890 v.Type = x.Type 32891 v.AddArg(x) 32892 return true 32893 } 32894 return false 32895 } 32896 func rewriteValuegeneric_OpZeroExt16to64_0(v *Value) bool { 32897 // match: (ZeroExt16to64 (Const16 [c])) 32898 // cond: 32899 // result: (Const64 [int64(uint16(c))]) 32900 for { 32901 v_0 := v.Args[0] 32902 if v_0.Op != OpConst16 { 32903 break 32904 } 32905 c := v_0.AuxInt 32906 v.reset(OpConst64) 32907 v.AuxInt = int64(uint16(c)) 32908 return true 32909 } 32910 // match: (ZeroExt16to64 (Trunc64to16 x:(Rsh64Ux64 _ (Const64 [s])))) 32911 // cond: s >= 48 32912 // result: x 32913 for { 32914 v_0 := v.Args[0] 32915 if v_0.Op != OpTrunc64to16 { 32916 break 32917 } 32918 x := v_0.Args[0] 32919 if x.Op != OpRsh64Ux64 { 32920 break 32921 } 32922 _ = x.Args[1] 32923 x_1 := x.Args[1] 32924 if x_1.Op != OpConst64 { 32925 break 32926 } 32927 s := x_1.AuxInt 32928 if !(s >= 48) { 32929 break 32930 } 32931 v.reset(OpCopy) 32932 v.Type = x.Type 32933 v.AddArg(x) 32934 return true 32935 } 32936 return false 32937 } 32938 func rewriteValuegeneric_OpZeroExt32to64_0(v *Value) bool { 32939 // match: (ZeroExt32to64 (Const32 [c])) 32940 // cond: 32941 // result: (Const64 [int64(uint32(c))]) 32942 for { 32943 v_0 := v.Args[0] 32944 if v_0.Op != OpConst32 { 32945 break 32946 } 32947 c := v_0.AuxInt 32948 v.reset(OpConst64) 32949 v.AuxInt = int64(uint32(c)) 32950 return true 32951 } 32952 // match: (ZeroExt32to64 (Trunc64to32 x:(Rsh64Ux64 _ (Const64 [s])))) 32953 // cond: s >= 32 32954 // result: x 32955 for { 32956 v_0 := v.Args[0] 32957 if v_0.Op != OpTrunc64to32 { 32958 break 32959 } 32960 x := v_0.Args[0] 32961 if x.Op != OpRsh64Ux64 { 32962 break 32963 } 32964 _ = x.Args[1] 32965 x_1 := x.Args[1] 32966 if x_1.Op != OpConst64 { 32967 break 32968 } 32969 s := x_1.AuxInt 32970 if !(s >= 32) { 32971 break 32972 } 32973 v.reset(OpCopy) 32974 v.Type = x.Type 32975 v.AddArg(x) 32976 return true 32977 } 32978 return false 32979 } 32980 func rewriteValuegeneric_OpZeroExt8to16_0(v *Value) bool { 32981 // match: (ZeroExt8to16 (Const8 [c])) 32982 // cond: 32983 // result: (Const16 [int64( uint8(c))]) 32984 for { 32985 v_0 := v.Args[0] 32986 if v_0.Op != OpConst8 { 32987 break 32988 } 32989 c := v_0.AuxInt 32990 v.reset(OpConst16) 32991 v.AuxInt = int64(uint8(c)) 32992 return true 32993 } 32994 // match: (ZeroExt8to16 (Trunc16to8 x:(Rsh16Ux64 _ (Const64 [s])))) 32995 // cond: s >= 8 32996 // result: x 32997 for { 32998 v_0 := v.Args[0] 32999 if v_0.Op != OpTrunc16to8 { 33000 break 33001 } 33002 x := v_0.Args[0] 33003 if x.Op != OpRsh16Ux64 { 33004 break 33005 } 33006 _ = x.Args[1] 33007 x_1 := x.Args[1] 33008 if x_1.Op != OpConst64 { 33009 break 33010 } 33011 s := x_1.AuxInt 33012 if !(s >= 8) { 33013 break 33014 } 33015 v.reset(OpCopy) 33016 v.Type = x.Type 33017 v.AddArg(x) 33018 return true 33019 } 33020 return false 33021 } 33022 func rewriteValuegeneric_OpZeroExt8to32_0(v *Value) bool { 33023 // match: (ZeroExt8to32 (Const8 [c])) 33024 // cond: 33025 // result: (Const32 [int64( uint8(c))]) 33026 for { 33027 v_0 := v.Args[0] 33028 if v_0.Op != OpConst8 { 33029 break 33030 } 33031 c := v_0.AuxInt 33032 v.reset(OpConst32) 33033 v.AuxInt = int64(uint8(c)) 33034 return true 33035 } 33036 // match: (ZeroExt8to32 (Trunc32to8 x:(Rsh32Ux64 _ (Const64 [s])))) 33037 // cond: s >= 24 33038 // result: x 33039 for { 33040 v_0 := v.Args[0] 33041 if v_0.Op != OpTrunc32to8 { 33042 break 33043 } 33044 x := v_0.Args[0] 33045 if x.Op != OpRsh32Ux64 { 33046 break 33047 } 33048 _ = x.Args[1] 33049 x_1 := x.Args[1] 33050 if x_1.Op != OpConst64 { 33051 break 33052 } 33053 s := x_1.AuxInt 33054 if !(s >= 24) { 33055 break 33056 } 33057 v.reset(OpCopy) 33058 v.Type = x.Type 33059 v.AddArg(x) 33060 return true 33061 } 33062 return false 33063 } 33064 func rewriteValuegeneric_OpZeroExt8to64_0(v *Value) bool { 33065 // match: (ZeroExt8to64 (Const8 [c])) 33066 // cond: 33067 // result: (Const64 [int64( uint8(c))]) 33068 for { 33069 v_0 := v.Args[0] 33070 if v_0.Op != OpConst8 { 33071 break 33072 } 33073 c := v_0.AuxInt 33074 v.reset(OpConst64) 33075 v.AuxInt = int64(uint8(c)) 33076 return true 33077 } 33078 // match: (ZeroExt8to64 (Trunc64to8 x:(Rsh64Ux64 _ (Const64 [s])))) 33079 // cond: s >= 56 33080 // result: x 33081 for { 33082 v_0 := v.Args[0] 33083 if v_0.Op != OpTrunc64to8 { 33084 break 33085 } 33086 x := v_0.Args[0] 33087 if x.Op != OpRsh64Ux64 { 33088 break 33089 } 33090 _ = x.Args[1] 33091 x_1 := x.Args[1] 33092 if x_1.Op != OpConst64 { 33093 break 33094 } 33095 s := x_1.AuxInt 33096 if !(s >= 56) { 33097 break 33098 } 33099 v.reset(OpCopy) 33100 v.Type = x.Type 33101 v.AddArg(x) 33102 return true 33103 } 33104 return false 33105 } 33106 func rewriteBlockgeneric(b *Block) bool { 33107 config := b.Func.Config 33108 _ = config 33109 fe := b.Func.fe 33110 _ = fe 33111 typ := &config.Types 33112 _ = typ 33113 switch b.Kind { 33114 case BlockIf: 33115 // match: (If (Not cond) yes no) 33116 // cond: 33117 // result: (If cond no yes) 33118 for { 33119 v := b.Control 33120 if v.Op != OpNot { 33121 break 33122 } 33123 cond := v.Args[0] 33124 b.Kind = BlockIf 33125 b.SetControl(cond) 33126 b.Aux = nil 33127 b.swapSuccessors() 33128 return true 33129 } 33130 // match: (If (ConstBool [c]) yes no) 33131 // cond: c == 1 33132 // result: (First nil yes no) 33133 for { 33134 v := b.Control 33135 if v.Op != OpConstBool { 33136 break 33137 } 33138 c := v.AuxInt 33139 if !(c == 1) { 33140 break 33141 } 33142 b.Kind = BlockFirst 33143 b.SetControl(nil) 33144 b.Aux = nil 33145 return true 33146 } 33147 // match: (If (ConstBool [c]) yes no) 33148 // cond: c == 0 33149 // result: (First nil no yes) 33150 for { 33151 v := b.Control 33152 if v.Op != OpConstBool { 33153 break 33154 } 33155 c := v.AuxInt 33156 if !(c == 0) { 33157 break 33158 } 33159 b.Kind = BlockFirst 33160 b.SetControl(nil) 33161 b.Aux = nil 33162 b.swapSuccessors() 33163 return true 33164 } 33165 } 33166 return false 33167 }