github.com/megatontech/mynoteforgo@v0.0.0-20200507084910-5d0c6ea6e890/源码/cmd/compile/internal/ssa/rewrite386.go (about) 1 // Code generated from gen/386.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 rewriteValue386(v *Value) bool { 19 switch v.Op { 20 case Op386ADCL: 21 return rewriteValue386_Op386ADCL_0(v) 22 case Op386ADDL: 23 return rewriteValue386_Op386ADDL_0(v) || rewriteValue386_Op386ADDL_10(v) || rewriteValue386_Op386ADDL_20(v) 24 case Op386ADDLcarry: 25 return rewriteValue386_Op386ADDLcarry_0(v) 26 case Op386ADDLconst: 27 return rewriteValue386_Op386ADDLconst_0(v) 28 case Op386ADDLconstmodify: 29 return rewriteValue386_Op386ADDLconstmodify_0(v) 30 case Op386ADDLconstmodifyidx4: 31 return rewriteValue386_Op386ADDLconstmodifyidx4_0(v) 32 case Op386ADDLload: 33 return rewriteValue386_Op386ADDLload_0(v) 34 case Op386ADDLloadidx4: 35 return rewriteValue386_Op386ADDLloadidx4_0(v) 36 case Op386ADDLmodify: 37 return rewriteValue386_Op386ADDLmodify_0(v) 38 case Op386ADDLmodifyidx4: 39 return rewriteValue386_Op386ADDLmodifyidx4_0(v) 40 case Op386ADDSD: 41 return rewriteValue386_Op386ADDSD_0(v) 42 case Op386ADDSDload: 43 return rewriteValue386_Op386ADDSDload_0(v) 44 case Op386ADDSS: 45 return rewriteValue386_Op386ADDSS_0(v) 46 case Op386ADDSSload: 47 return rewriteValue386_Op386ADDSSload_0(v) 48 case Op386ANDL: 49 return rewriteValue386_Op386ANDL_0(v) 50 case Op386ANDLconst: 51 return rewriteValue386_Op386ANDLconst_0(v) 52 case Op386ANDLconstmodify: 53 return rewriteValue386_Op386ANDLconstmodify_0(v) 54 case Op386ANDLconstmodifyidx4: 55 return rewriteValue386_Op386ANDLconstmodifyidx4_0(v) 56 case Op386ANDLload: 57 return rewriteValue386_Op386ANDLload_0(v) 58 case Op386ANDLloadidx4: 59 return rewriteValue386_Op386ANDLloadidx4_0(v) 60 case Op386ANDLmodify: 61 return rewriteValue386_Op386ANDLmodify_0(v) 62 case Op386ANDLmodifyidx4: 63 return rewriteValue386_Op386ANDLmodifyidx4_0(v) 64 case Op386CMPB: 65 return rewriteValue386_Op386CMPB_0(v) 66 case Op386CMPBconst: 67 return rewriteValue386_Op386CMPBconst_0(v) 68 case Op386CMPBload: 69 return rewriteValue386_Op386CMPBload_0(v) 70 case Op386CMPL: 71 return rewriteValue386_Op386CMPL_0(v) 72 case Op386CMPLconst: 73 return rewriteValue386_Op386CMPLconst_0(v) || rewriteValue386_Op386CMPLconst_10(v) 74 case Op386CMPLload: 75 return rewriteValue386_Op386CMPLload_0(v) 76 case Op386CMPW: 77 return rewriteValue386_Op386CMPW_0(v) 78 case Op386CMPWconst: 79 return rewriteValue386_Op386CMPWconst_0(v) 80 case Op386CMPWload: 81 return rewriteValue386_Op386CMPWload_0(v) 82 case Op386DIVSD: 83 return rewriteValue386_Op386DIVSD_0(v) 84 case Op386DIVSDload: 85 return rewriteValue386_Op386DIVSDload_0(v) 86 case Op386DIVSS: 87 return rewriteValue386_Op386DIVSS_0(v) 88 case Op386DIVSSload: 89 return rewriteValue386_Op386DIVSSload_0(v) 90 case Op386LEAL: 91 return rewriteValue386_Op386LEAL_0(v) 92 case Op386LEAL1: 93 return rewriteValue386_Op386LEAL1_0(v) 94 case Op386LEAL2: 95 return rewriteValue386_Op386LEAL2_0(v) 96 case Op386LEAL4: 97 return rewriteValue386_Op386LEAL4_0(v) 98 case Op386LEAL8: 99 return rewriteValue386_Op386LEAL8_0(v) 100 case Op386MOVBLSX: 101 return rewriteValue386_Op386MOVBLSX_0(v) 102 case Op386MOVBLSXload: 103 return rewriteValue386_Op386MOVBLSXload_0(v) 104 case Op386MOVBLZX: 105 return rewriteValue386_Op386MOVBLZX_0(v) 106 case Op386MOVBload: 107 return rewriteValue386_Op386MOVBload_0(v) 108 case Op386MOVBloadidx1: 109 return rewriteValue386_Op386MOVBloadidx1_0(v) 110 case Op386MOVBstore: 111 return rewriteValue386_Op386MOVBstore_0(v) || rewriteValue386_Op386MOVBstore_10(v) 112 case Op386MOVBstoreconst: 113 return rewriteValue386_Op386MOVBstoreconst_0(v) 114 case Op386MOVBstoreconstidx1: 115 return rewriteValue386_Op386MOVBstoreconstidx1_0(v) 116 case Op386MOVBstoreidx1: 117 return rewriteValue386_Op386MOVBstoreidx1_0(v) || rewriteValue386_Op386MOVBstoreidx1_10(v) || rewriteValue386_Op386MOVBstoreidx1_20(v) 118 case Op386MOVLload: 119 return rewriteValue386_Op386MOVLload_0(v) 120 case Op386MOVLloadidx1: 121 return rewriteValue386_Op386MOVLloadidx1_0(v) 122 case Op386MOVLloadidx4: 123 return rewriteValue386_Op386MOVLloadidx4_0(v) 124 case Op386MOVLstore: 125 return rewriteValue386_Op386MOVLstore_0(v) || rewriteValue386_Op386MOVLstore_10(v) || rewriteValue386_Op386MOVLstore_20(v) 126 case Op386MOVLstoreconst: 127 return rewriteValue386_Op386MOVLstoreconst_0(v) 128 case Op386MOVLstoreconstidx1: 129 return rewriteValue386_Op386MOVLstoreconstidx1_0(v) 130 case Op386MOVLstoreconstidx4: 131 return rewriteValue386_Op386MOVLstoreconstidx4_0(v) 132 case Op386MOVLstoreidx1: 133 return rewriteValue386_Op386MOVLstoreidx1_0(v) 134 case Op386MOVLstoreidx4: 135 return rewriteValue386_Op386MOVLstoreidx4_0(v) || rewriteValue386_Op386MOVLstoreidx4_10(v) 136 case Op386MOVSDconst: 137 return rewriteValue386_Op386MOVSDconst_0(v) 138 case Op386MOVSDload: 139 return rewriteValue386_Op386MOVSDload_0(v) 140 case Op386MOVSDloadidx1: 141 return rewriteValue386_Op386MOVSDloadidx1_0(v) 142 case Op386MOVSDloadidx8: 143 return rewriteValue386_Op386MOVSDloadidx8_0(v) 144 case Op386MOVSDstore: 145 return rewriteValue386_Op386MOVSDstore_0(v) 146 case Op386MOVSDstoreidx1: 147 return rewriteValue386_Op386MOVSDstoreidx1_0(v) 148 case Op386MOVSDstoreidx8: 149 return rewriteValue386_Op386MOVSDstoreidx8_0(v) 150 case Op386MOVSSconst: 151 return rewriteValue386_Op386MOVSSconst_0(v) 152 case Op386MOVSSload: 153 return rewriteValue386_Op386MOVSSload_0(v) 154 case Op386MOVSSloadidx1: 155 return rewriteValue386_Op386MOVSSloadidx1_0(v) 156 case Op386MOVSSloadidx4: 157 return rewriteValue386_Op386MOVSSloadidx4_0(v) 158 case Op386MOVSSstore: 159 return rewriteValue386_Op386MOVSSstore_0(v) 160 case Op386MOVSSstoreidx1: 161 return rewriteValue386_Op386MOVSSstoreidx1_0(v) 162 case Op386MOVSSstoreidx4: 163 return rewriteValue386_Op386MOVSSstoreidx4_0(v) 164 case Op386MOVWLSX: 165 return rewriteValue386_Op386MOVWLSX_0(v) 166 case Op386MOVWLSXload: 167 return rewriteValue386_Op386MOVWLSXload_0(v) 168 case Op386MOVWLZX: 169 return rewriteValue386_Op386MOVWLZX_0(v) 170 case Op386MOVWload: 171 return rewriteValue386_Op386MOVWload_0(v) 172 case Op386MOVWloadidx1: 173 return rewriteValue386_Op386MOVWloadidx1_0(v) 174 case Op386MOVWloadidx2: 175 return rewriteValue386_Op386MOVWloadidx2_0(v) 176 case Op386MOVWstore: 177 return rewriteValue386_Op386MOVWstore_0(v) 178 case Op386MOVWstoreconst: 179 return rewriteValue386_Op386MOVWstoreconst_0(v) 180 case Op386MOVWstoreconstidx1: 181 return rewriteValue386_Op386MOVWstoreconstidx1_0(v) 182 case Op386MOVWstoreconstidx2: 183 return rewriteValue386_Op386MOVWstoreconstidx2_0(v) 184 case Op386MOVWstoreidx1: 185 return rewriteValue386_Op386MOVWstoreidx1_0(v) || rewriteValue386_Op386MOVWstoreidx1_10(v) 186 case Op386MOVWstoreidx2: 187 return rewriteValue386_Op386MOVWstoreidx2_0(v) 188 case Op386MULL: 189 return rewriteValue386_Op386MULL_0(v) 190 case Op386MULLconst: 191 return rewriteValue386_Op386MULLconst_0(v) || rewriteValue386_Op386MULLconst_10(v) || rewriteValue386_Op386MULLconst_20(v) || rewriteValue386_Op386MULLconst_30(v) 192 case Op386MULLload: 193 return rewriteValue386_Op386MULLload_0(v) 194 case Op386MULLloadidx4: 195 return rewriteValue386_Op386MULLloadidx4_0(v) 196 case Op386MULSD: 197 return rewriteValue386_Op386MULSD_0(v) 198 case Op386MULSDload: 199 return rewriteValue386_Op386MULSDload_0(v) 200 case Op386MULSS: 201 return rewriteValue386_Op386MULSS_0(v) 202 case Op386MULSSload: 203 return rewriteValue386_Op386MULSSload_0(v) 204 case Op386NEGL: 205 return rewriteValue386_Op386NEGL_0(v) 206 case Op386NOTL: 207 return rewriteValue386_Op386NOTL_0(v) 208 case Op386ORL: 209 return rewriteValue386_Op386ORL_0(v) || rewriteValue386_Op386ORL_10(v) || rewriteValue386_Op386ORL_20(v) || rewriteValue386_Op386ORL_30(v) || rewriteValue386_Op386ORL_40(v) || rewriteValue386_Op386ORL_50(v) 210 case Op386ORLconst: 211 return rewriteValue386_Op386ORLconst_0(v) 212 case Op386ORLconstmodify: 213 return rewriteValue386_Op386ORLconstmodify_0(v) 214 case Op386ORLconstmodifyidx4: 215 return rewriteValue386_Op386ORLconstmodifyidx4_0(v) 216 case Op386ORLload: 217 return rewriteValue386_Op386ORLload_0(v) 218 case Op386ORLloadidx4: 219 return rewriteValue386_Op386ORLloadidx4_0(v) 220 case Op386ORLmodify: 221 return rewriteValue386_Op386ORLmodify_0(v) 222 case Op386ORLmodifyidx4: 223 return rewriteValue386_Op386ORLmodifyidx4_0(v) 224 case Op386ROLBconst: 225 return rewriteValue386_Op386ROLBconst_0(v) 226 case Op386ROLLconst: 227 return rewriteValue386_Op386ROLLconst_0(v) 228 case Op386ROLWconst: 229 return rewriteValue386_Op386ROLWconst_0(v) 230 case Op386SARB: 231 return rewriteValue386_Op386SARB_0(v) 232 case Op386SARBconst: 233 return rewriteValue386_Op386SARBconst_0(v) 234 case Op386SARL: 235 return rewriteValue386_Op386SARL_0(v) 236 case Op386SARLconst: 237 return rewriteValue386_Op386SARLconst_0(v) 238 case Op386SARW: 239 return rewriteValue386_Op386SARW_0(v) 240 case Op386SARWconst: 241 return rewriteValue386_Op386SARWconst_0(v) 242 case Op386SBBL: 243 return rewriteValue386_Op386SBBL_0(v) 244 case Op386SBBLcarrymask: 245 return rewriteValue386_Op386SBBLcarrymask_0(v) 246 case Op386SETA: 247 return rewriteValue386_Op386SETA_0(v) 248 case Op386SETAE: 249 return rewriteValue386_Op386SETAE_0(v) 250 case Op386SETB: 251 return rewriteValue386_Op386SETB_0(v) 252 case Op386SETBE: 253 return rewriteValue386_Op386SETBE_0(v) 254 case Op386SETEQ: 255 return rewriteValue386_Op386SETEQ_0(v) 256 case Op386SETG: 257 return rewriteValue386_Op386SETG_0(v) 258 case Op386SETGE: 259 return rewriteValue386_Op386SETGE_0(v) 260 case Op386SETL: 261 return rewriteValue386_Op386SETL_0(v) 262 case Op386SETLE: 263 return rewriteValue386_Op386SETLE_0(v) 264 case Op386SETNE: 265 return rewriteValue386_Op386SETNE_0(v) 266 case Op386SHLL: 267 return rewriteValue386_Op386SHLL_0(v) 268 case Op386SHLLconst: 269 return rewriteValue386_Op386SHLLconst_0(v) 270 case Op386SHRB: 271 return rewriteValue386_Op386SHRB_0(v) 272 case Op386SHRBconst: 273 return rewriteValue386_Op386SHRBconst_0(v) 274 case Op386SHRL: 275 return rewriteValue386_Op386SHRL_0(v) 276 case Op386SHRLconst: 277 return rewriteValue386_Op386SHRLconst_0(v) 278 case Op386SHRW: 279 return rewriteValue386_Op386SHRW_0(v) 280 case Op386SHRWconst: 281 return rewriteValue386_Op386SHRWconst_0(v) 282 case Op386SUBL: 283 return rewriteValue386_Op386SUBL_0(v) 284 case Op386SUBLcarry: 285 return rewriteValue386_Op386SUBLcarry_0(v) 286 case Op386SUBLconst: 287 return rewriteValue386_Op386SUBLconst_0(v) 288 case Op386SUBLload: 289 return rewriteValue386_Op386SUBLload_0(v) 290 case Op386SUBLloadidx4: 291 return rewriteValue386_Op386SUBLloadidx4_0(v) 292 case Op386SUBLmodify: 293 return rewriteValue386_Op386SUBLmodify_0(v) 294 case Op386SUBLmodifyidx4: 295 return rewriteValue386_Op386SUBLmodifyidx4_0(v) 296 case Op386SUBSD: 297 return rewriteValue386_Op386SUBSD_0(v) 298 case Op386SUBSDload: 299 return rewriteValue386_Op386SUBSDload_0(v) 300 case Op386SUBSS: 301 return rewriteValue386_Op386SUBSS_0(v) 302 case Op386SUBSSload: 303 return rewriteValue386_Op386SUBSSload_0(v) 304 case Op386XORL: 305 return rewriteValue386_Op386XORL_0(v) || rewriteValue386_Op386XORL_10(v) 306 case Op386XORLconst: 307 return rewriteValue386_Op386XORLconst_0(v) 308 case Op386XORLconstmodify: 309 return rewriteValue386_Op386XORLconstmodify_0(v) 310 case Op386XORLconstmodifyidx4: 311 return rewriteValue386_Op386XORLconstmodifyidx4_0(v) 312 case Op386XORLload: 313 return rewriteValue386_Op386XORLload_0(v) 314 case Op386XORLloadidx4: 315 return rewriteValue386_Op386XORLloadidx4_0(v) 316 case Op386XORLmodify: 317 return rewriteValue386_Op386XORLmodify_0(v) 318 case Op386XORLmodifyidx4: 319 return rewriteValue386_Op386XORLmodifyidx4_0(v) 320 case OpAdd16: 321 return rewriteValue386_OpAdd16_0(v) 322 case OpAdd32: 323 return rewriteValue386_OpAdd32_0(v) 324 case OpAdd32F: 325 return rewriteValue386_OpAdd32F_0(v) 326 case OpAdd32carry: 327 return rewriteValue386_OpAdd32carry_0(v) 328 case OpAdd32withcarry: 329 return rewriteValue386_OpAdd32withcarry_0(v) 330 case OpAdd64F: 331 return rewriteValue386_OpAdd64F_0(v) 332 case OpAdd8: 333 return rewriteValue386_OpAdd8_0(v) 334 case OpAddPtr: 335 return rewriteValue386_OpAddPtr_0(v) 336 case OpAddr: 337 return rewriteValue386_OpAddr_0(v) 338 case OpAnd16: 339 return rewriteValue386_OpAnd16_0(v) 340 case OpAnd32: 341 return rewriteValue386_OpAnd32_0(v) 342 case OpAnd8: 343 return rewriteValue386_OpAnd8_0(v) 344 case OpAndB: 345 return rewriteValue386_OpAndB_0(v) 346 case OpAvg32u: 347 return rewriteValue386_OpAvg32u_0(v) 348 case OpBswap32: 349 return rewriteValue386_OpBswap32_0(v) 350 case OpClosureCall: 351 return rewriteValue386_OpClosureCall_0(v) 352 case OpCom16: 353 return rewriteValue386_OpCom16_0(v) 354 case OpCom32: 355 return rewriteValue386_OpCom32_0(v) 356 case OpCom8: 357 return rewriteValue386_OpCom8_0(v) 358 case OpConst16: 359 return rewriteValue386_OpConst16_0(v) 360 case OpConst32: 361 return rewriteValue386_OpConst32_0(v) 362 case OpConst32F: 363 return rewriteValue386_OpConst32F_0(v) 364 case OpConst64F: 365 return rewriteValue386_OpConst64F_0(v) 366 case OpConst8: 367 return rewriteValue386_OpConst8_0(v) 368 case OpConstBool: 369 return rewriteValue386_OpConstBool_0(v) 370 case OpConstNil: 371 return rewriteValue386_OpConstNil_0(v) 372 case OpCvt32Fto32: 373 return rewriteValue386_OpCvt32Fto32_0(v) 374 case OpCvt32Fto64F: 375 return rewriteValue386_OpCvt32Fto64F_0(v) 376 case OpCvt32to32F: 377 return rewriteValue386_OpCvt32to32F_0(v) 378 case OpCvt32to64F: 379 return rewriteValue386_OpCvt32to64F_0(v) 380 case OpCvt64Fto32: 381 return rewriteValue386_OpCvt64Fto32_0(v) 382 case OpCvt64Fto32F: 383 return rewriteValue386_OpCvt64Fto32F_0(v) 384 case OpDiv16: 385 return rewriteValue386_OpDiv16_0(v) 386 case OpDiv16u: 387 return rewriteValue386_OpDiv16u_0(v) 388 case OpDiv32: 389 return rewriteValue386_OpDiv32_0(v) 390 case OpDiv32F: 391 return rewriteValue386_OpDiv32F_0(v) 392 case OpDiv32u: 393 return rewriteValue386_OpDiv32u_0(v) 394 case OpDiv64F: 395 return rewriteValue386_OpDiv64F_0(v) 396 case OpDiv8: 397 return rewriteValue386_OpDiv8_0(v) 398 case OpDiv8u: 399 return rewriteValue386_OpDiv8u_0(v) 400 case OpEq16: 401 return rewriteValue386_OpEq16_0(v) 402 case OpEq32: 403 return rewriteValue386_OpEq32_0(v) 404 case OpEq32F: 405 return rewriteValue386_OpEq32F_0(v) 406 case OpEq64F: 407 return rewriteValue386_OpEq64F_0(v) 408 case OpEq8: 409 return rewriteValue386_OpEq8_0(v) 410 case OpEqB: 411 return rewriteValue386_OpEqB_0(v) 412 case OpEqPtr: 413 return rewriteValue386_OpEqPtr_0(v) 414 case OpGeq16: 415 return rewriteValue386_OpGeq16_0(v) 416 case OpGeq16U: 417 return rewriteValue386_OpGeq16U_0(v) 418 case OpGeq32: 419 return rewriteValue386_OpGeq32_0(v) 420 case OpGeq32F: 421 return rewriteValue386_OpGeq32F_0(v) 422 case OpGeq32U: 423 return rewriteValue386_OpGeq32U_0(v) 424 case OpGeq64F: 425 return rewriteValue386_OpGeq64F_0(v) 426 case OpGeq8: 427 return rewriteValue386_OpGeq8_0(v) 428 case OpGeq8U: 429 return rewriteValue386_OpGeq8U_0(v) 430 case OpGetCallerPC: 431 return rewriteValue386_OpGetCallerPC_0(v) 432 case OpGetCallerSP: 433 return rewriteValue386_OpGetCallerSP_0(v) 434 case OpGetClosurePtr: 435 return rewriteValue386_OpGetClosurePtr_0(v) 436 case OpGetG: 437 return rewriteValue386_OpGetG_0(v) 438 case OpGreater16: 439 return rewriteValue386_OpGreater16_0(v) 440 case OpGreater16U: 441 return rewriteValue386_OpGreater16U_0(v) 442 case OpGreater32: 443 return rewriteValue386_OpGreater32_0(v) 444 case OpGreater32F: 445 return rewriteValue386_OpGreater32F_0(v) 446 case OpGreater32U: 447 return rewriteValue386_OpGreater32U_0(v) 448 case OpGreater64F: 449 return rewriteValue386_OpGreater64F_0(v) 450 case OpGreater8: 451 return rewriteValue386_OpGreater8_0(v) 452 case OpGreater8U: 453 return rewriteValue386_OpGreater8U_0(v) 454 case OpHmul32: 455 return rewriteValue386_OpHmul32_0(v) 456 case OpHmul32u: 457 return rewriteValue386_OpHmul32u_0(v) 458 case OpInterCall: 459 return rewriteValue386_OpInterCall_0(v) 460 case OpIsInBounds: 461 return rewriteValue386_OpIsInBounds_0(v) 462 case OpIsNonNil: 463 return rewriteValue386_OpIsNonNil_0(v) 464 case OpIsSliceInBounds: 465 return rewriteValue386_OpIsSliceInBounds_0(v) 466 case OpLeq16: 467 return rewriteValue386_OpLeq16_0(v) 468 case OpLeq16U: 469 return rewriteValue386_OpLeq16U_0(v) 470 case OpLeq32: 471 return rewriteValue386_OpLeq32_0(v) 472 case OpLeq32F: 473 return rewriteValue386_OpLeq32F_0(v) 474 case OpLeq32U: 475 return rewriteValue386_OpLeq32U_0(v) 476 case OpLeq64F: 477 return rewriteValue386_OpLeq64F_0(v) 478 case OpLeq8: 479 return rewriteValue386_OpLeq8_0(v) 480 case OpLeq8U: 481 return rewriteValue386_OpLeq8U_0(v) 482 case OpLess16: 483 return rewriteValue386_OpLess16_0(v) 484 case OpLess16U: 485 return rewriteValue386_OpLess16U_0(v) 486 case OpLess32: 487 return rewriteValue386_OpLess32_0(v) 488 case OpLess32F: 489 return rewriteValue386_OpLess32F_0(v) 490 case OpLess32U: 491 return rewriteValue386_OpLess32U_0(v) 492 case OpLess64F: 493 return rewriteValue386_OpLess64F_0(v) 494 case OpLess8: 495 return rewriteValue386_OpLess8_0(v) 496 case OpLess8U: 497 return rewriteValue386_OpLess8U_0(v) 498 case OpLoad: 499 return rewriteValue386_OpLoad_0(v) 500 case OpLocalAddr: 501 return rewriteValue386_OpLocalAddr_0(v) 502 case OpLsh16x16: 503 return rewriteValue386_OpLsh16x16_0(v) 504 case OpLsh16x32: 505 return rewriteValue386_OpLsh16x32_0(v) 506 case OpLsh16x64: 507 return rewriteValue386_OpLsh16x64_0(v) 508 case OpLsh16x8: 509 return rewriteValue386_OpLsh16x8_0(v) 510 case OpLsh32x16: 511 return rewriteValue386_OpLsh32x16_0(v) 512 case OpLsh32x32: 513 return rewriteValue386_OpLsh32x32_0(v) 514 case OpLsh32x64: 515 return rewriteValue386_OpLsh32x64_0(v) 516 case OpLsh32x8: 517 return rewriteValue386_OpLsh32x8_0(v) 518 case OpLsh8x16: 519 return rewriteValue386_OpLsh8x16_0(v) 520 case OpLsh8x32: 521 return rewriteValue386_OpLsh8x32_0(v) 522 case OpLsh8x64: 523 return rewriteValue386_OpLsh8x64_0(v) 524 case OpLsh8x8: 525 return rewriteValue386_OpLsh8x8_0(v) 526 case OpMod16: 527 return rewriteValue386_OpMod16_0(v) 528 case OpMod16u: 529 return rewriteValue386_OpMod16u_0(v) 530 case OpMod32: 531 return rewriteValue386_OpMod32_0(v) 532 case OpMod32u: 533 return rewriteValue386_OpMod32u_0(v) 534 case OpMod8: 535 return rewriteValue386_OpMod8_0(v) 536 case OpMod8u: 537 return rewriteValue386_OpMod8u_0(v) 538 case OpMove: 539 return rewriteValue386_OpMove_0(v) || rewriteValue386_OpMove_10(v) 540 case OpMul16: 541 return rewriteValue386_OpMul16_0(v) 542 case OpMul32: 543 return rewriteValue386_OpMul32_0(v) 544 case OpMul32F: 545 return rewriteValue386_OpMul32F_0(v) 546 case OpMul32uhilo: 547 return rewriteValue386_OpMul32uhilo_0(v) 548 case OpMul64F: 549 return rewriteValue386_OpMul64F_0(v) 550 case OpMul8: 551 return rewriteValue386_OpMul8_0(v) 552 case OpNeg16: 553 return rewriteValue386_OpNeg16_0(v) 554 case OpNeg32: 555 return rewriteValue386_OpNeg32_0(v) 556 case OpNeg32F: 557 return rewriteValue386_OpNeg32F_0(v) 558 case OpNeg64F: 559 return rewriteValue386_OpNeg64F_0(v) 560 case OpNeg8: 561 return rewriteValue386_OpNeg8_0(v) 562 case OpNeq16: 563 return rewriteValue386_OpNeq16_0(v) 564 case OpNeq32: 565 return rewriteValue386_OpNeq32_0(v) 566 case OpNeq32F: 567 return rewriteValue386_OpNeq32F_0(v) 568 case OpNeq64F: 569 return rewriteValue386_OpNeq64F_0(v) 570 case OpNeq8: 571 return rewriteValue386_OpNeq8_0(v) 572 case OpNeqB: 573 return rewriteValue386_OpNeqB_0(v) 574 case OpNeqPtr: 575 return rewriteValue386_OpNeqPtr_0(v) 576 case OpNilCheck: 577 return rewriteValue386_OpNilCheck_0(v) 578 case OpNot: 579 return rewriteValue386_OpNot_0(v) 580 case OpOffPtr: 581 return rewriteValue386_OpOffPtr_0(v) 582 case OpOr16: 583 return rewriteValue386_OpOr16_0(v) 584 case OpOr32: 585 return rewriteValue386_OpOr32_0(v) 586 case OpOr8: 587 return rewriteValue386_OpOr8_0(v) 588 case OpOrB: 589 return rewriteValue386_OpOrB_0(v) 590 case OpRound32F: 591 return rewriteValue386_OpRound32F_0(v) 592 case OpRound64F: 593 return rewriteValue386_OpRound64F_0(v) 594 case OpRsh16Ux16: 595 return rewriteValue386_OpRsh16Ux16_0(v) 596 case OpRsh16Ux32: 597 return rewriteValue386_OpRsh16Ux32_0(v) 598 case OpRsh16Ux64: 599 return rewriteValue386_OpRsh16Ux64_0(v) 600 case OpRsh16Ux8: 601 return rewriteValue386_OpRsh16Ux8_0(v) 602 case OpRsh16x16: 603 return rewriteValue386_OpRsh16x16_0(v) 604 case OpRsh16x32: 605 return rewriteValue386_OpRsh16x32_0(v) 606 case OpRsh16x64: 607 return rewriteValue386_OpRsh16x64_0(v) 608 case OpRsh16x8: 609 return rewriteValue386_OpRsh16x8_0(v) 610 case OpRsh32Ux16: 611 return rewriteValue386_OpRsh32Ux16_0(v) 612 case OpRsh32Ux32: 613 return rewriteValue386_OpRsh32Ux32_0(v) 614 case OpRsh32Ux64: 615 return rewriteValue386_OpRsh32Ux64_0(v) 616 case OpRsh32Ux8: 617 return rewriteValue386_OpRsh32Ux8_0(v) 618 case OpRsh32x16: 619 return rewriteValue386_OpRsh32x16_0(v) 620 case OpRsh32x32: 621 return rewriteValue386_OpRsh32x32_0(v) 622 case OpRsh32x64: 623 return rewriteValue386_OpRsh32x64_0(v) 624 case OpRsh32x8: 625 return rewriteValue386_OpRsh32x8_0(v) 626 case OpRsh8Ux16: 627 return rewriteValue386_OpRsh8Ux16_0(v) 628 case OpRsh8Ux32: 629 return rewriteValue386_OpRsh8Ux32_0(v) 630 case OpRsh8Ux64: 631 return rewriteValue386_OpRsh8Ux64_0(v) 632 case OpRsh8Ux8: 633 return rewriteValue386_OpRsh8Ux8_0(v) 634 case OpRsh8x16: 635 return rewriteValue386_OpRsh8x16_0(v) 636 case OpRsh8x32: 637 return rewriteValue386_OpRsh8x32_0(v) 638 case OpRsh8x64: 639 return rewriteValue386_OpRsh8x64_0(v) 640 case OpRsh8x8: 641 return rewriteValue386_OpRsh8x8_0(v) 642 case OpSelect0: 643 return rewriteValue386_OpSelect0_0(v) 644 case OpSelect1: 645 return rewriteValue386_OpSelect1_0(v) 646 case OpSignExt16to32: 647 return rewriteValue386_OpSignExt16to32_0(v) 648 case OpSignExt8to16: 649 return rewriteValue386_OpSignExt8to16_0(v) 650 case OpSignExt8to32: 651 return rewriteValue386_OpSignExt8to32_0(v) 652 case OpSignmask: 653 return rewriteValue386_OpSignmask_0(v) 654 case OpSlicemask: 655 return rewriteValue386_OpSlicemask_0(v) 656 case OpSqrt: 657 return rewriteValue386_OpSqrt_0(v) 658 case OpStaticCall: 659 return rewriteValue386_OpStaticCall_0(v) 660 case OpStore: 661 return rewriteValue386_OpStore_0(v) 662 case OpSub16: 663 return rewriteValue386_OpSub16_0(v) 664 case OpSub32: 665 return rewriteValue386_OpSub32_0(v) 666 case OpSub32F: 667 return rewriteValue386_OpSub32F_0(v) 668 case OpSub32carry: 669 return rewriteValue386_OpSub32carry_0(v) 670 case OpSub32withcarry: 671 return rewriteValue386_OpSub32withcarry_0(v) 672 case OpSub64F: 673 return rewriteValue386_OpSub64F_0(v) 674 case OpSub8: 675 return rewriteValue386_OpSub8_0(v) 676 case OpSubPtr: 677 return rewriteValue386_OpSubPtr_0(v) 678 case OpTrunc16to8: 679 return rewriteValue386_OpTrunc16to8_0(v) 680 case OpTrunc32to16: 681 return rewriteValue386_OpTrunc32to16_0(v) 682 case OpTrunc32to8: 683 return rewriteValue386_OpTrunc32to8_0(v) 684 case OpWB: 685 return rewriteValue386_OpWB_0(v) 686 case OpXor16: 687 return rewriteValue386_OpXor16_0(v) 688 case OpXor32: 689 return rewriteValue386_OpXor32_0(v) 690 case OpXor8: 691 return rewriteValue386_OpXor8_0(v) 692 case OpZero: 693 return rewriteValue386_OpZero_0(v) || rewriteValue386_OpZero_10(v) 694 case OpZeroExt16to32: 695 return rewriteValue386_OpZeroExt16to32_0(v) 696 case OpZeroExt8to16: 697 return rewriteValue386_OpZeroExt8to16_0(v) 698 case OpZeroExt8to32: 699 return rewriteValue386_OpZeroExt8to32_0(v) 700 case OpZeromask: 701 return rewriteValue386_OpZeromask_0(v) 702 } 703 return false 704 } 705 func rewriteValue386_Op386ADCL_0(v *Value) bool { 706 // match: (ADCL x (MOVLconst [c]) f) 707 // cond: 708 // result: (ADCLconst [c] x f) 709 for { 710 _ = v.Args[2] 711 x := v.Args[0] 712 v_1 := v.Args[1] 713 if v_1.Op != Op386MOVLconst { 714 break 715 } 716 c := v_1.AuxInt 717 f := v.Args[2] 718 v.reset(Op386ADCLconst) 719 v.AuxInt = c 720 v.AddArg(x) 721 v.AddArg(f) 722 return true 723 } 724 // match: (ADCL (MOVLconst [c]) x f) 725 // cond: 726 // result: (ADCLconst [c] x f) 727 for { 728 _ = v.Args[2] 729 v_0 := v.Args[0] 730 if v_0.Op != Op386MOVLconst { 731 break 732 } 733 c := v_0.AuxInt 734 x := v.Args[1] 735 f := v.Args[2] 736 v.reset(Op386ADCLconst) 737 v.AuxInt = c 738 v.AddArg(x) 739 v.AddArg(f) 740 return true 741 } 742 // match: (ADCL (MOVLconst [c]) x f) 743 // cond: 744 // result: (ADCLconst [c] x f) 745 for { 746 _ = v.Args[2] 747 v_0 := v.Args[0] 748 if v_0.Op != Op386MOVLconst { 749 break 750 } 751 c := v_0.AuxInt 752 x := v.Args[1] 753 f := v.Args[2] 754 v.reset(Op386ADCLconst) 755 v.AuxInt = c 756 v.AddArg(x) 757 v.AddArg(f) 758 return true 759 } 760 // match: (ADCL x (MOVLconst [c]) f) 761 // cond: 762 // result: (ADCLconst [c] x f) 763 for { 764 _ = v.Args[2] 765 x := v.Args[0] 766 v_1 := v.Args[1] 767 if v_1.Op != Op386MOVLconst { 768 break 769 } 770 c := v_1.AuxInt 771 f := v.Args[2] 772 v.reset(Op386ADCLconst) 773 v.AuxInt = c 774 v.AddArg(x) 775 v.AddArg(f) 776 return true 777 } 778 return false 779 } 780 func rewriteValue386_Op386ADDL_0(v *Value) bool { 781 // match: (ADDL x (MOVLconst [c])) 782 // cond: 783 // result: (ADDLconst [c] x) 784 for { 785 _ = v.Args[1] 786 x := v.Args[0] 787 v_1 := v.Args[1] 788 if v_1.Op != Op386MOVLconst { 789 break 790 } 791 c := v_1.AuxInt 792 v.reset(Op386ADDLconst) 793 v.AuxInt = c 794 v.AddArg(x) 795 return true 796 } 797 // match: (ADDL (MOVLconst [c]) x) 798 // cond: 799 // result: (ADDLconst [c] x) 800 for { 801 _ = v.Args[1] 802 v_0 := v.Args[0] 803 if v_0.Op != Op386MOVLconst { 804 break 805 } 806 c := v_0.AuxInt 807 x := v.Args[1] 808 v.reset(Op386ADDLconst) 809 v.AuxInt = c 810 v.AddArg(x) 811 return true 812 } 813 // match: (ADDL (SHLLconst [c] x) (SHRLconst [d] x)) 814 // cond: d == 32-c 815 // result: (ROLLconst [c] x) 816 for { 817 _ = v.Args[1] 818 v_0 := v.Args[0] 819 if v_0.Op != Op386SHLLconst { 820 break 821 } 822 c := v_0.AuxInt 823 x := v_0.Args[0] 824 v_1 := v.Args[1] 825 if v_1.Op != Op386SHRLconst { 826 break 827 } 828 d := v_1.AuxInt 829 if x != v_1.Args[0] { 830 break 831 } 832 if !(d == 32-c) { 833 break 834 } 835 v.reset(Op386ROLLconst) 836 v.AuxInt = c 837 v.AddArg(x) 838 return true 839 } 840 // match: (ADDL (SHRLconst [d] x) (SHLLconst [c] x)) 841 // cond: d == 32-c 842 // result: (ROLLconst [c] x) 843 for { 844 _ = v.Args[1] 845 v_0 := v.Args[0] 846 if v_0.Op != Op386SHRLconst { 847 break 848 } 849 d := v_0.AuxInt 850 x := v_0.Args[0] 851 v_1 := v.Args[1] 852 if v_1.Op != Op386SHLLconst { 853 break 854 } 855 c := v_1.AuxInt 856 if x != v_1.Args[0] { 857 break 858 } 859 if !(d == 32-c) { 860 break 861 } 862 v.reset(Op386ROLLconst) 863 v.AuxInt = c 864 v.AddArg(x) 865 return true 866 } 867 // match: (ADDL <t> (SHLLconst x [c]) (SHRWconst x [d])) 868 // cond: c < 16 && d == 16-c && t.Size() == 2 869 // result: (ROLWconst x [c]) 870 for { 871 t := v.Type 872 _ = v.Args[1] 873 v_0 := v.Args[0] 874 if v_0.Op != Op386SHLLconst { 875 break 876 } 877 c := v_0.AuxInt 878 x := v_0.Args[0] 879 v_1 := v.Args[1] 880 if v_1.Op != Op386SHRWconst { 881 break 882 } 883 d := v_1.AuxInt 884 if x != v_1.Args[0] { 885 break 886 } 887 if !(c < 16 && d == 16-c && t.Size() == 2) { 888 break 889 } 890 v.reset(Op386ROLWconst) 891 v.AuxInt = c 892 v.AddArg(x) 893 return true 894 } 895 // match: (ADDL <t> (SHRWconst x [d]) (SHLLconst x [c])) 896 // cond: c < 16 && d == 16-c && t.Size() == 2 897 // result: (ROLWconst x [c]) 898 for { 899 t := v.Type 900 _ = v.Args[1] 901 v_0 := v.Args[0] 902 if v_0.Op != Op386SHRWconst { 903 break 904 } 905 d := v_0.AuxInt 906 x := v_0.Args[0] 907 v_1 := v.Args[1] 908 if v_1.Op != Op386SHLLconst { 909 break 910 } 911 c := v_1.AuxInt 912 if x != v_1.Args[0] { 913 break 914 } 915 if !(c < 16 && d == 16-c && t.Size() == 2) { 916 break 917 } 918 v.reset(Op386ROLWconst) 919 v.AuxInt = c 920 v.AddArg(x) 921 return true 922 } 923 // match: (ADDL <t> (SHLLconst x [c]) (SHRBconst x [d])) 924 // cond: c < 8 && d == 8-c && t.Size() == 1 925 // result: (ROLBconst x [c]) 926 for { 927 t := v.Type 928 _ = v.Args[1] 929 v_0 := v.Args[0] 930 if v_0.Op != Op386SHLLconst { 931 break 932 } 933 c := v_0.AuxInt 934 x := v_0.Args[0] 935 v_1 := v.Args[1] 936 if v_1.Op != Op386SHRBconst { 937 break 938 } 939 d := v_1.AuxInt 940 if x != v_1.Args[0] { 941 break 942 } 943 if !(c < 8 && d == 8-c && t.Size() == 1) { 944 break 945 } 946 v.reset(Op386ROLBconst) 947 v.AuxInt = c 948 v.AddArg(x) 949 return true 950 } 951 // match: (ADDL <t> (SHRBconst x [d]) (SHLLconst x [c])) 952 // cond: c < 8 && d == 8-c && t.Size() == 1 953 // result: (ROLBconst x [c]) 954 for { 955 t := v.Type 956 _ = v.Args[1] 957 v_0 := v.Args[0] 958 if v_0.Op != Op386SHRBconst { 959 break 960 } 961 d := v_0.AuxInt 962 x := v_0.Args[0] 963 v_1 := v.Args[1] 964 if v_1.Op != Op386SHLLconst { 965 break 966 } 967 c := v_1.AuxInt 968 if x != v_1.Args[0] { 969 break 970 } 971 if !(c < 8 && d == 8-c && t.Size() == 1) { 972 break 973 } 974 v.reset(Op386ROLBconst) 975 v.AuxInt = c 976 v.AddArg(x) 977 return true 978 } 979 // match: (ADDL x (SHLLconst [3] y)) 980 // cond: 981 // result: (LEAL8 x y) 982 for { 983 _ = v.Args[1] 984 x := v.Args[0] 985 v_1 := v.Args[1] 986 if v_1.Op != Op386SHLLconst { 987 break 988 } 989 if v_1.AuxInt != 3 { 990 break 991 } 992 y := v_1.Args[0] 993 v.reset(Op386LEAL8) 994 v.AddArg(x) 995 v.AddArg(y) 996 return true 997 } 998 // match: (ADDL (SHLLconst [3] y) x) 999 // cond: 1000 // result: (LEAL8 x y) 1001 for { 1002 _ = v.Args[1] 1003 v_0 := v.Args[0] 1004 if v_0.Op != Op386SHLLconst { 1005 break 1006 } 1007 if v_0.AuxInt != 3 { 1008 break 1009 } 1010 y := v_0.Args[0] 1011 x := v.Args[1] 1012 v.reset(Op386LEAL8) 1013 v.AddArg(x) 1014 v.AddArg(y) 1015 return true 1016 } 1017 return false 1018 } 1019 func rewriteValue386_Op386ADDL_10(v *Value) bool { 1020 // match: (ADDL x (SHLLconst [2] y)) 1021 // cond: 1022 // result: (LEAL4 x y) 1023 for { 1024 _ = v.Args[1] 1025 x := v.Args[0] 1026 v_1 := v.Args[1] 1027 if v_1.Op != Op386SHLLconst { 1028 break 1029 } 1030 if v_1.AuxInt != 2 { 1031 break 1032 } 1033 y := v_1.Args[0] 1034 v.reset(Op386LEAL4) 1035 v.AddArg(x) 1036 v.AddArg(y) 1037 return true 1038 } 1039 // match: (ADDL (SHLLconst [2] y) x) 1040 // cond: 1041 // result: (LEAL4 x y) 1042 for { 1043 _ = v.Args[1] 1044 v_0 := v.Args[0] 1045 if v_0.Op != Op386SHLLconst { 1046 break 1047 } 1048 if v_0.AuxInt != 2 { 1049 break 1050 } 1051 y := v_0.Args[0] 1052 x := v.Args[1] 1053 v.reset(Op386LEAL4) 1054 v.AddArg(x) 1055 v.AddArg(y) 1056 return true 1057 } 1058 // match: (ADDL x (SHLLconst [1] y)) 1059 // cond: 1060 // result: (LEAL2 x y) 1061 for { 1062 _ = v.Args[1] 1063 x := v.Args[0] 1064 v_1 := v.Args[1] 1065 if v_1.Op != Op386SHLLconst { 1066 break 1067 } 1068 if v_1.AuxInt != 1 { 1069 break 1070 } 1071 y := v_1.Args[0] 1072 v.reset(Op386LEAL2) 1073 v.AddArg(x) 1074 v.AddArg(y) 1075 return true 1076 } 1077 // match: (ADDL (SHLLconst [1] y) x) 1078 // cond: 1079 // result: (LEAL2 x y) 1080 for { 1081 _ = v.Args[1] 1082 v_0 := v.Args[0] 1083 if v_0.Op != Op386SHLLconst { 1084 break 1085 } 1086 if v_0.AuxInt != 1 { 1087 break 1088 } 1089 y := v_0.Args[0] 1090 x := v.Args[1] 1091 v.reset(Op386LEAL2) 1092 v.AddArg(x) 1093 v.AddArg(y) 1094 return true 1095 } 1096 // match: (ADDL x (ADDL y y)) 1097 // cond: 1098 // result: (LEAL2 x y) 1099 for { 1100 _ = v.Args[1] 1101 x := v.Args[0] 1102 v_1 := v.Args[1] 1103 if v_1.Op != Op386ADDL { 1104 break 1105 } 1106 _ = v_1.Args[1] 1107 y := v_1.Args[0] 1108 if y != v_1.Args[1] { 1109 break 1110 } 1111 v.reset(Op386LEAL2) 1112 v.AddArg(x) 1113 v.AddArg(y) 1114 return true 1115 } 1116 // match: (ADDL (ADDL y y) x) 1117 // cond: 1118 // result: (LEAL2 x y) 1119 for { 1120 _ = v.Args[1] 1121 v_0 := v.Args[0] 1122 if v_0.Op != Op386ADDL { 1123 break 1124 } 1125 _ = v_0.Args[1] 1126 y := v_0.Args[0] 1127 if y != v_0.Args[1] { 1128 break 1129 } 1130 x := v.Args[1] 1131 v.reset(Op386LEAL2) 1132 v.AddArg(x) 1133 v.AddArg(y) 1134 return true 1135 } 1136 // match: (ADDL x (ADDL x y)) 1137 // cond: 1138 // result: (LEAL2 y x) 1139 for { 1140 _ = v.Args[1] 1141 x := v.Args[0] 1142 v_1 := v.Args[1] 1143 if v_1.Op != Op386ADDL { 1144 break 1145 } 1146 _ = v_1.Args[1] 1147 if x != v_1.Args[0] { 1148 break 1149 } 1150 y := v_1.Args[1] 1151 v.reset(Op386LEAL2) 1152 v.AddArg(y) 1153 v.AddArg(x) 1154 return true 1155 } 1156 // match: (ADDL x (ADDL y x)) 1157 // cond: 1158 // result: (LEAL2 y x) 1159 for { 1160 _ = v.Args[1] 1161 x := v.Args[0] 1162 v_1 := v.Args[1] 1163 if v_1.Op != Op386ADDL { 1164 break 1165 } 1166 _ = v_1.Args[1] 1167 y := v_1.Args[0] 1168 if x != v_1.Args[1] { 1169 break 1170 } 1171 v.reset(Op386LEAL2) 1172 v.AddArg(y) 1173 v.AddArg(x) 1174 return true 1175 } 1176 // match: (ADDL (ADDL x y) x) 1177 // cond: 1178 // result: (LEAL2 y x) 1179 for { 1180 _ = v.Args[1] 1181 v_0 := v.Args[0] 1182 if v_0.Op != Op386ADDL { 1183 break 1184 } 1185 _ = v_0.Args[1] 1186 x := v_0.Args[0] 1187 y := v_0.Args[1] 1188 if x != v.Args[1] { 1189 break 1190 } 1191 v.reset(Op386LEAL2) 1192 v.AddArg(y) 1193 v.AddArg(x) 1194 return true 1195 } 1196 // match: (ADDL (ADDL y x) x) 1197 // cond: 1198 // result: (LEAL2 y x) 1199 for { 1200 _ = v.Args[1] 1201 v_0 := v.Args[0] 1202 if v_0.Op != Op386ADDL { 1203 break 1204 } 1205 _ = v_0.Args[1] 1206 y := v_0.Args[0] 1207 x := v_0.Args[1] 1208 if x != v.Args[1] { 1209 break 1210 } 1211 v.reset(Op386LEAL2) 1212 v.AddArg(y) 1213 v.AddArg(x) 1214 return true 1215 } 1216 return false 1217 } 1218 func rewriteValue386_Op386ADDL_20(v *Value) bool { 1219 // match: (ADDL (ADDLconst [c] x) y) 1220 // cond: 1221 // result: (LEAL1 [c] x y) 1222 for { 1223 _ = v.Args[1] 1224 v_0 := v.Args[0] 1225 if v_0.Op != Op386ADDLconst { 1226 break 1227 } 1228 c := v_0.AuxInt 1229 x := v_0.Args[0] 1230 y := v.Args[1] 1231 v.reset(Op386LEAL1) 1232 v.AuxInt = c 1233 v.AddArg(x) 1234 v.AddArg(y) 1235 return true 1236 } 1237 // match: (ADDL y (ADDLconst [c] x)) 1238 // cond: 1239 // result: (LEAL1 [c] x y) 1240 for { 1241 _ = v.Args[1] 1242 y := v.Args[0] 1243 v_1 := v.Args[1] 1244 if v_1.Op != Op386ADDLconst { 1245 break 1246 } 1247 c := v_1.AuxInt 1248 x := v_1.Args[0] 1249 v.reset(Op386LEAL1) 1250 v.AuxInt = c 1251 v.AddArg(x) 1252 v.AddArg(y) 1253 return true 1254 } 1255 // match: (ADDL x (LEAL [c] {s} y)) 1256 // cond: x.Op != OpSB && y.Op != OpSB 1257 // result: (LEAL1 [c] {s} x y) 1258 for { 1259 _ = v.Args[1] 1260 x := v.Args[0] 1261 v_1 := v.Args[1] 1262 if v_1.Op != Op386LEAL { 1263 break 1264 } 1265 c := v_1.AuxInt 1266 s := v_1.Aux 1267 y := v_1.Args[0] 1268 if !(x.Op != OpSB && y.Op != OpSB) { 1269 break 1270 } 1271 v.reset(Op386LEAL1) 1272 v.AuxInt = c 1273 v.Aux = s 1274 v.AddArg(x) 1275 v.AddArg(y) 1276 return true 1277 } 1278 // match: (ADDL (LEAL [c] {s} y) x) 1279 // cond: x.Op != OpSB && y.Op != OpSB 1280 // result: (LEAL1 [c] {s} x y) 1281 for { 1282 _ = v.Args[1] 1283 v_0 := v.Args[0] 1284 if v_0.Op != Op386LEAL { 1285 break 1286 } 1287 c := v_0.AuxInt 1288 s := v_0.Aux 1289 y := v_0.Args[0] 1290 x := v.Args[1] 1291 if !(x.Op != OpSB && y.Op != OpSB) { 1292 break 1293 } 1294 v.reset(Op386LEAL1) 1295 v.AuxInt = c 1296 v.Aux = s 1297 v.AddArg(x) 1298 v.AddArg(y) 1299 return true 1300 } 1301 // match: (ADDL x l:(MOVLload [off] {sym} ptr mem)) 1302 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 1303 // result: (ADDLload x [off] {sym} ptr mem) 1304 for { 1305 _ = v.Args[1] 1306 x := v.Args[0] 1307 l := v.Args[1] 1308 if l.Op != Op386MOVLload { 1309 break 1310 } 1311 off := l.AuxInt 1312 sym := l.Aux 1313 _ = l.Args[1] 1314 ptr := l.Args[0] 1315 mem := l.Args[1] 1316 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 1317 break 1318 } 1319 v.reset(Op386ADDLload) 1320 v.AuxInt = off 1321 v.Aux = sym 1322 v.AddArg(x) 1323 v.AddArg(ptr) 1324 v.AddArg(mem) 1325 return true 1326 } 1327 // match: (ADDL l:(MOVLload [off] {sym} ptr mem) x) 1328 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 1329 // result: (ADDLload x [off] {sym} ptr mem) 1330 for { 1331 _ = v.Args[1] 1332 l := v.Args[0] 1333 if l.Op != Op386MOVLload { 1334 break 1335 } 1336 off := l.AuxInt 1337 sym := l.Aux 1338 _ = l.Args[1] 1339 ptr := l.Args[0] 1340 mem := l.Args[1] 1341 x := v.Args[1] 1342 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 1343 break 1344 } 1345 v.reset(Op386ADDLload) 1346 v.AuxInt = off 1347 v.Aux = sym 1348 v.AddArg(x) 1349 v.AddArg(ptr) 1350 v.AddArg(mem) 1351 return true 1352 } 1353 // match: (ADDL x l:(MOVLloadidx4 [off] {sym} ptr idx mem)) 1354 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 1355 // result: (ADDLloadidx4 x [off] {sym} ptr idx mem) 1356 for { 1357 _ = v.Args[1] 1358 x := v.Args[0] 1359 l := v.Args[1] 1360 if l.Op != Op386MOVLloadidx4 { 1361 break 1362 } 1363 off := l.AuxInt 1364 sym := l.Aux 1365 _ = l.Args[2] 1366 ptr := l.Args[0] 1367 idx := l.Args[1] 1368 mem := l.Args[2] 1369 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 1370 break 1371 } 1372 v.reset(Op386ADDLloadidx4) 1373 v.AuxInt = off 1374 v.Aux = sym 1375 v.AddArg(x) 1376 v.AddArg(ptr) 1377 v.AddArg(idx) 1378 v.AddArg(mem) 1379 return true 1380 } 1381 // match: (ADDL l:(MOVLloadidx4 [off] {sym} ptr idx mem) x) 1382 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 1383 // result: (ADDLloadidx4 x [off] {sym} ptr idx mem) 1384 for { 1385 _ = v.Args[1] 1386 l := v.Args[0] 1387 if l.Op != Op386MOVLloadidx4 { 1388 break 1389 } 1390 off := l.AuxInt 1391 sym := l.Aux 1392 _ = l.Args[2] 1393 ptr := l.Args[0] 1394 idx := l.Args[1] 1395 mem := l.Args[2] 1396 x := v.Args[1] 1397 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 1398 break 1399 } 1400 v.reset(Op386ADDLloadidx4) 1401 v.AuxInt = off 1402 v.Aux = sym 1403 v.AddArg(x) 1404 v.AddArg(ptr) 1405 v.AddArg(idx) 1406 v.AddArg(mem) 1407 return true 1408 } 1409 // match: (ADDL x (NEGL y)) 1410 // cond: 1411 // result: (SUBL x y) 1412 for { 1413 _ = v.Args[1] 1414 x := v.Args[0] 1415 v_1 := v.Args[1] 1416 if v_1.Op != Op386NEGL { 1417 break 1418 } 1419 y := v_1.Args[0] 1420 v.reset(Op386SUBL) 1421 v.AddArg(x) 1422 v.AddArg(y) 1423 return true 1424 } 1425 // match: (ADDL (NEGL y) x) 1426 // cond: 1427 // result: (SUBL x y) 1428 for { 1429 _ = v.Args[1] 1430 v_0 := v.Args[0] 1431 if v_0.Op != Op386NEGL { 1432 break 1433 } 1434 y := v_0.Args[0] 1435 x := v.Args[1] 1436 v.reset(Op386SUBL) 1437 v.AddArg(x) 1438 v.AddArg(y) 1439 return true 1440 } 1441 return false 1442 } 1443 func rewriteValue386_Op386ADDLcarry_0(v *Value) bool { 1444 // match: (ADDLcarry x (MOVLconst [c])) 1445 // cond: 1446 // result: (ADDLconstcarry [c] x) 1447 for { 1448 _ = v.Args[1] 1449 x := v.Args[0] 1450 v_1 := v.Args[1] 1451 if v_1.Op != Op386MOVLconst { 1452 break 1453 } 1454 c := v_1.AuxInt 1455 v.reset(Op386ADDLconstcarry) 1456 v.AuxInt = c 1457 v.AddArg(x) 1458 return true 1459 } 1460 // match: (ADDLcarry (MOVLconst [c]) x) 1461 // cond: 1462 // result: (ADDLconstcarry [c] x) 1463 for { 1464 _ = v.Args[1] 1465 v_0 := v.Args[0] 1466 if v_0.Op != Op386MOVLconst { 1467 break 1468 } 1469 c := v_0.AuxInt 1470 x := v.Args[1] 1471 v.reset(Op386ADDLconstcarry) 1472 v.AuxInt = c 1473 v.AddArg(x) 1474 return true 1475 } 1476 return false 1477 } 1478 func rewriteValue386_Op386ADDLconst_0(v *Value) bool { 1479 // match: (ADDLconst [c] (ADDL x y)) 1480 // cond: 1481 // result: (LEAL1 [c] x y) 1482 for { 1483 c := v.AuxInt 1484 v_0 := v.Args[0] 1485 if v_0.Op != Op386ADDL { 1486 break 1487 } 1488 _ = v_0.Args[1] 1489 x := v_0.Args[0] 1490 y := v_0.Args[1] 1491 v.reset(Op386LEAL1) 1492 v.AuxInt = c 1493 v.AddArg(x) 1494 v.AddArg(y) 1495 return true 1496 } 1497 // match: (ADDLconst [c] (LEAL [d] {s} x)) 1498 // cond: is32Bit(c+d) 1499 // result: (LEAL [c+d] {s} x) 1500 for { 1501 c := v.AuxInt 1502 v_0 := v.Args[0] 1503 if v_0.Op != Op386LEAL { 1504 break 1505 } 1506 d := v_0.AuxInt 1507 s := v_0.Aux 1508 x := v_0.Args[0] 1509 if !(is32Bit(c + d)) { 1510 break 1511 } 1512 v.reset(Op386LEAL) 1513 v.AuxInt = c + d 1514 v.Aux = s 1515 v.AddArg(x) 1516 return true 1517 } 1518 // match: (ADDLconst [c] (LEAL1 [d] {s} x y)) 1519 // cond: is32Bit(c+d) 1520 // result: (LEAL1 [c+d] {s} x y) 1521 for { 1522 c := v.AuxInt 1523 v_0 := v.Args[0] 1524 if v_0.Op != Op386LEAL1 { 1525 break 1526 } 1527 d := v_0.AuxInt 1528 s := v_0.Aux 1529 _ = v_0.Args[1] 1530 x := v_0.Args[0] 1531 y := v_0.Args[1] 1532 if !(is32Bit(c + d)) { 1533 break 1534 } 1535 v.reset(Op386LEAL1) 1536 v.AuxInt = c + d 1537 v.Aux = s 1538 v.AddArg(x) 1539 v.AddArg(y) 1540 return true 1541 } 1542 // match: (ADDLconst [c] (LEAL2 [d] {s} x y)) 1543 // cond: is32Bit(c+d) 1544 // result: (LEAL2 [c+d] {s} x y) 1545 for { 1546 c := v.AuxInt 1547 v_0 := v.Args[0] 1548 if v_0.Op != Op386LEAL2 { 1549 break 1550 } 1551 d := v_0.AuxInt 1552 s := v_0.Aux 1553 _ = v_0.Args[1] 1554 x := v_0.Args[0] 1555 y := v_0.Args[1] 1556 if !(is32Bit(c + d)) { 1557 break 1558 } 1559 v.reset(Op386LEAL2) 1560 v.AuxInt = c + d 1561 v.Aux = s 1562 v.AddArg(x) 1563 v.AddArg(y) 1564 return true 1565 } 1566 // match: (ADDLconst [c] (LEAL4 [d] {s} x y)) 1567 // cond: is32Bit(c+d) 1568 // result: (LEAL4 [c+d] {s} x y) 1569 for { 1570 c := v.AuxInt 1571 v_0 := v.Args[0] 1572 if v_0.Op != Op386LEAL4 { 1573 break 1574 } 1575 d := v_0.AuxInt 1576 s := v_0.Aux 1577 _ = v_0.Args[1] 1578 x := v_0.Args[0] 1579 y := v_0.Args[1] 1580 if !(is32Bit(c + d)) { 1581 break 1582 } 1583 v.reset(Op386LEAL4) 1584 v.AuxInt = c + d 1585 v.Aux = s 1586 v.AddArg(x) 1587 v.AddArg(y) 1588 return true 1589 } 1590 // match: (ADDLconst [c] (LEAL8 [d] {s} x y)) 1591 // cond: is32Bit(c+d) 1592 // result: (LEAL8 [c+d] {s} x y) 1593 for { 1594 c := v.AuxInt 1595 v_0 := v.Args[0] 1596 if v_0.Op != Op386LEAL8 { 1597 break 1598 } 1599 d := v_0.AuxInt 1600 s := v_0.Aux 1601 _ = v_0.Args[1] 1602 x := v_0.Args[0] 1603 y := v_0.Args[1] 1604 if !(is32Bit(c + d)) { 1605 break 1606 } 1607 v.reset(Op386LEAL8) 1608 v.AuxInt = c + d 1609 v.Aux = s 1610 v.AddArg(x) 1611 v.AddArg(y) 1612 return true 1613 } 1614 // match: (ADDLconst [c] x) 1615 // cond: int32(c)==0 1616 // result: x 1617 for { 1618 c := v.AuxInt 1619 x := v.Args[0] 1620 if !(int32(c) == 0) { 1621 break 1622 } 1623 v.reset(OpCopy) 1624 v.Type = x.Type 1625 v.AddArg(x) 1626 return true 1627 } 1628 // match: (ADDLconst [c] (MOVLconst [d])) 1629 // cond: 1630 // result: (MOVLconst [int64(int32(c+d))]) 1631 for { 1632 c := v.AuxInt 1633 v_0 := v.Args[0] 1634 if v_0.Op != Op386MOVLconst { 1635 break 1636 } 1637 d := v_0.AuxInt 1638 v.reset(Op386MOVLconst) 1639 v.AuxInt = int64(int32(c + d)) 1640 return true 1641 } 1642 // match: (ADDLconst [c] (ADDLconst [d] x)) 1643 // cond: 1644 // result: (ADDLconst [int64(int32(c+d))] x) 1645 for { 1646 c := v.AuxInt 1647 v_0 := v.Args[0] 1648 if v_0.Op != Op386ADDLconst { 1649 break 1650 } 1651 d := v_0.AuxInt 1652 x := v_0.Args[0] 1653 v.reset(Op386ADDLconst) 1654 v.AuxInt = int64(int32(c + d)) 1655 v.AddArg(x) 1656 return true 1657 } 1658 return false 1659 } 1660 func rewriteValue386_Op386ADDLconstmodify_0(v *Value) bool { 1661 b := v.Block 1662 _ = b 1663 config := b.Func.Config 1664 _ = config 1665 // match: (ADDLconstmodify [valoff1] {sym} (ADDLconst [off2] base) mem) 1666 // cond: ValAndOff(valoff1).canAdd(off2) 1667 // result: (ADDLconstmodify [ValAndOff(valoff1).add(off2)] {sym} base mem) 1668 for { 1669 valoff1 := v.AuxInt 1670 sym := v.Aux 1671 _ = v.Args[1] 1672 v_0 := v.Args[0] 1673 if v_0.Op != Op386ADDLconst { 1674 break 1675 } 1676 off2 := v_0.AuxInt 1677 base := v_0.Args[0] 1678 mem := v.Args[1] 1679 if !(ValAndOff(valoff1).canAdd(off2)) { 1680 break 1681 } 1682 v.reset(Op386ADDLconstmodify) 1683 v.AuxInt = ValAndOff(valoff1).add(off2) 1684 v.Aux = sym 1685 v.AddArg(base) 1686 v.AddArg(mem) 1687 return true 1688 } 1689 // match: (ADDLconstmodify [valoff1] {sym1} (LEAL [off2] {sym2} base) mem) 1690 // cond: ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 1691 // result: (ADDLconstmodify [ValAndOff(valoff1).add(off2)] {mergeSym(sym1,sym2)} base mem) 1692 for { 1693 valoff1 := v.AuxInt 1694 sym1 := v.Aux 1695 _ = v.Args[1] 1696 v_0 := v.Args[0] 1697 if v_0.Op != Op386LEAL { 1698 break 1699 } 1700 off2 := v_0.AuxInt 1701 sym2 := v_0.Aux 1702 base := v_0.Args[0] 1703 mem := v.Args[1] 1704 if !(ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 1705 break 1706 } 1707 v.reset(Op386ADDLconstmodify) 1708 v.AuxInt = ValAndOff(valoff1).add(off2) 1709 v.Aux = mergeSym(sym1, sym2) 1710 v.AddArg(base) 1711 v.AddArg(mem) 1712 return true 1713 } 1714 return false 1715 } 1716 func rewriteValue386_Op386ADDLconstmodifyidx4_0(v *Value) bool { 1717 b := v.Block 1718 _ = b 1719 config := b.Func.Config 1720 _ = config 1721 // match: (ADDLconstmodifyidx4 [valoff1] {sym} (ADDLconst [off2] base) idx mem) 1722 // cond: ValAndOff(valoff1).canAdd(off2) 1723 // result: (ADDLconstmodifyidx4 [ValAndOff(valoff1).add(off2)] {sym} base idx mem) 1724 for { 1725 valoff1 := v.AuxInt 1726 sym := v.Aux 1727 _ = v.Args[2] 1728 v_0 := v.Args[0] 1729 if v_0.Op != Op386ADDLconst { 1730 break 1731 } 1732 off2 := v_0.AuxInt 1733 base := v_0.Args[0] 1734 idx := v.Args[1] 1735 mem := v.Args[2] 1736 if !(ValAndOff(valoff1).canAdd(off2)) { 1737 break 1738 } 1739 v.reset(Op386ADDLconstmodifyidx4) 1740 v.AuxInt = ValAndOff(valoff1).add(off2) 1741 v.Aux = sym 1742 v.AddArg(base) 1743 v.AddArg(idx) 1744 v.AddArg(mem) 1745 return true 1746 } 1747 // match: (ADDLconstmodifyidx4 [valoff1] {sym} base (ADDLconst [off2] idx) mem) 1748 // cond: ValAndOff(valoff1).canAdd(off2*4) 1749 // result: (ADDLconstmodifyidx4 [ValAndOff(valoff1).add(off2*4)] {sym} base idx mem) 1750 for { 1751 valoff1 := v.AuxInt 1752 sym := v.Aux 1753 _ = v.Args[2] 1754 base := v.Args[0] 1755 v_1 := v.Args[1] 1756 if v_1.Op != Op386ADDLconst { 1757 break 1758 } 1759 off2 := v_1.AuxInt 1760 idx := v_1.Args[0] 1761 mem := v.Args[2] 1762 if !(ValAndOff(valoff1).canAdd(off2 * 4)) { 1763 break 1764 } 1765 v.reset(Op386ADDLconstmodifyidx4) 1766 v.AuxInt = ValAndOff(valoff1).add(off2 * 4) 1767 v.Aux = sym 1768 v.AddArg(base) 1769 v.AddArg(idx) 1770 v.AddArg(mem) 1771 return true 1772 } 1773 // match: (ADDLconstmodifyidx4 [valoff1] {sym1} (LEAL [off2] {sym2} base) idx mem) 1774 // cond: ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 1775 // result: (ADDLconstmodifyidx4 [ValAndOff(valoff1).add(off2)] {mergeSym(sym1,sym2)} base idx mem) 1776 for { 1777 valoff1 := v.AuxInt 1778 sym1 := v.Aux 1779 _ = v.Args[2] 1780 v_0 := v.Args[0] 1781 if v_0.Op != Op386LEAL { 1782 break 1783 } 1784 off2 := v_0.AuxInt 1785 sym2 := v_0.Aux 1786 base := v_0.Args[0] 1787 idx := v.Args[1] 1788 mem := v.Args[2] 1789 if !(ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 1790 break 1791 } 1792 v.reset(Op386ADDLconstmodifyidx4) 1793 v.AuxInt = ValAndOff(valoff1).add(off2) 1794 v.Aux = mergeSym(sym1, sym2) 1795 v.AddArg(base) 1796 v.AddArg(idx) 1797 v.AddArg(mem) 1798 return true 1799 } 1800 return false 1801 } 1802 func rewriteValue386_Op386ADDLload_0(v *Value) bool { 1803 b := v.Block 1804 _ = b 1805 config := b.Func.Config 1806 _ = config 1807 // match: (ADDLload [off1] {sym} val (ADDLconst [off2] base) mem) 1808 // cond: is32Bit(off1+off2) 1809 // result: (ADDLload [off1+off2] {sym} val base mem) 1810 for { 1811 off1 := v.AuxInt 1812 sym := v.Aux 1813 _ = v.Args[2] 1814 val := v.Args[0] 1815 v_1 := v.Args[1] 1816 if v_1.Op != Op386ADDLconst { 1817 break 1818 } 1819 off2 := v_1.AuxInt 1820 base := v_1.Args[0] 1821 mem := v.Args[2] 1822 if !(is32Bit(off1 + off2)) { 1823 break 1824 } 1825 v.reset(Op386ADDLload) 1826 v.AuxInt = off1 + off2 1827 v.Aux = sym 1828 v.AddArg(val) 1829 v.AddArg(base) 1830 v.AddArg(mem) 1831 return true 1832 } 1833 // match: (ADDLload [off1] {sym1} val (LEAL [off2] {sym2} base) mem) 1834 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 1835 // result: (ADDLload [off1+off2] {mergeSym(sym1,sym2)} val base mem) 1836 for { 1837 off1 := v.AuxInt 1838 sym1 := v.Aux 1839 _ = v.Args[2] 1840 val := v.Args[0] 1841 v_1 := v.Args[1] 1842 if v_1.Op != Op386LEAL { 1843 break 1844 } 1845 off2 := v_1.AuxInt 1846 sym2 := v_1.Aux 1847 base := v_1.Args[0] 1848 mem := v.Args[2] 1849 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 1850 break 1851 } 1852 v.reset(Op386ADDLload) 1853 v.AuxInt = off1 + off2 1854 v.Aux = mergeSym(sym1, sym2) 1855 v.AddArg(val) 1856 v.AddArg(base) 1857 v.AddArg(mem) 1858 return true 1859 } 1860 // match: (ADDLload [off1] {sym1} val (LEAL4 [off2] {sym2} ptr idx) mem) 1861 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 1862 // result: (ADDLloadidx4 [off1+off2] {mergeSym(sym1,sym2)} val ptr idx mem) 1863 for { 1864 off1 := v.AuxInt 1865 sym1 := v.Aux 1866 _ = v.Args[2] 1867 val := v.Args[0] 1868 v_1 := v.Args[1] 1869 if v_1.Op != Op386LEAL4 { 1870 break 1871 } 1872 off2 := v_1.AuxInt 1873 sym2 := v_1.Aux 1874 _ = v_1.Args[1] 1875 ptr := v_1.Args[0] 1876 idx := v_1.Args[1] 1877 mem := v.Args[2] 1878 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 1879 break 1880 } 1881 v.reset(Op386ADDLloadidx4) 1882 v.AuxInt = off1 + off2 1883 v.Aux = mergeSym(sym1, sym2) 1884 v.AddArg(val) 1885 v.AddArg(ptr) 1886 v.AddArg(idx) 1887 v.AddArg(mem) 1888 return true 1889 } 1890 return false 1891 } 1892 func rewriteValue386_Op386ADDLloadidx4_0(v *Value) bool { 1893 b := v.Block 1894 _ = b 1895 config := b.Func.Config 1896 _ = config 1897 // match: (ADDLloadidx4 [off1] {sym} val (ADDLconst [off2] base) idx mem) 1898 // cond: is32Bit(off1+off2) 1899 // result: (ADDLloadidx4 [off1+off2] {sym} val base idx mem) 1900 for { 1901 off1 := v.AuxInt 1902 sym := v.Aux 1903 _ = v.Args[3] 1904 val := v.Args[0] 1905 v_1 := v.Args[1] 1906 if v_1.Op != Op386ADDLconst { 1907 break 1908 } 1909 off2 := v_1.AuxInt 1910 base := v_1.Args[0] 1911 idx := v.Args[2] 1912 mem := v.Args[3] 1913 if !(is32Bit(off1 + off2)) { 1914 break 1915 } 1916 v.reset(Op386ADDLloadidx4) 1917 v.AuxInt = off1 + off2 1918 v.Aux = sym 1919 v.AddArg(val) 1920 v.AddArg(base) 1921 v.AddArg(idx) 1922 v.AddArg(mem) 1923 return true 1924 } 1925 // match: (ADDLloadidx4 [off1] {sym} val base (ADDLconst [off2] idx) mem) 1926 // cond: is32Bit(off1+off2*4) 1927 // result: (ADDLloadidx4 [off1+off2*4] {sym} val base idx mem) 1928 for { 1929 off1 := v.AuxInt 1930 sym := v.Aux 1931 _ = v.Args[3] 1932 val := v.Args[0] 1933 base := v.Args[1] 1934 v_2 := v.Args[2] 1935 if v_2.Op != Op386ADDLconst { 1936 break 1937 } 1938 off2 := v_2.AuxInt 1939 idx := v_2.Args[0] 1940 mem := v.Args[3] 1941 if !(is32Bit(off1 + off2*4)) { 1942 break 1943 } 1944 v.reset(Op386ADDLloadidx4) 1945 v.AuxInt = off1 + off2*4 1946 v.Aux = sym 1947 v.AddArg(val) 1948 v.AddArg(base) 1949 v.AddArg(idx) 1950 v.AddArg(mem) 1951 return true 1952 } 1953 // match: (ADDLloadidx4 [off1] {sym1} val (LEAL [off2] {sym2} base) idx mem) 1954 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 1955 // result: (ADDLloadidx4 [off1+off2] {mergeSym(sym1,sym2)} val base idx mem) 1956 for { 1957 off1 := v.AuxInt 1958 sym1 := v.Aux 1959 _ = v.Args[3] 1960 val := v.Args[0] 1961 v_1 := v.Args[1] 1962 if v_1.Op != Op386LEAL { 1963 break 1964 } 1965 off2 := v_1.AuxInt 1966 sym2 := v_1.Aux 1967 base := v_1.Args[0] 1968 idx := v.Args[2] 1969 mem := v.Args[3] 1970 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 1971 break 1972 } 1973 v.reset(Op386ADDLloadidx4) 1974 v.AuxInt = off1 + off2 1975 v.Aux = mergeSym(sym1, sym2) 1976 v.AddArg(val) 1977 v.AddArg(base) 1978 v.AddArg(idx) 1979 v.AddArg(mem) 1980 return true 1981 } 1982 return false 1983 } 1984 func rewriteValue386_Op386ADDLmodify_0(v *Value) bool { 1985 b := v.Block 1986 _ = b 1987 config := b.Func.Config 1988 _ = config 1989 // match: (ADDLmodify [off1] {sym} (ADDLconst [off2] base) val mem) 1990 // cond: is32Bit(off1+off2) 1991 // result: (ADDLmodify [off1+off2] {sym} base val mem) 1992 for { 1993 off1 := v.AuxInt 1994 sym := v.Aux 1995 _ = v.Args[2] 1996 v_0 := v.Args[0] 1997 if v_0.Op != Op386ADDLconst { 1998 break 1999 } 2000 off2 := v_0.AuxInt 2001 base := v_0.Args[0] 2002 val := v.Args[1] 2003 mem := v.Args[2] 2004 if !(is32Bit(off1 + off2)) { 2005 break 2006 } 2007 v.reset(Op386ADDLmodify) 2008 v.AuxInt = off1 + off2 2009 v.Aux = sym 2010 v.AddArg(base) 2011 v.AddArg(val) 2012 v.AddArg(mem) 2013 return true 2014 } 2015 // match: (ADDLmodify [off1] {sym1} (LEAL [off2] {sym2} base) val mem) 2016 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 2017 // result: (ADDLmodify [off1+off2] {mergeSym(sym1,sym2)} base val mem) 2018 for { 2019 off1 := v.AuxInt 2020 sym1 := v.Aux 2021 _ = v.Args[2] 2022 v_0 := v.Args[0] 2023 if v_0.Op != Op386LEAL { 2024 break 2025 } 2026 off2 := v_0.AuxInt 2027 sym2 := v_0.Aux 2028 base := v_0.Args[0] 2029 val := v.Args[1] 2030 mem := v.Args[2] 2031 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 2032 break 2033 } 2034 v.reset(Op386ADDLmodify) 2035 v.AuxInt = off1 + off2 2036 v.Aux = mergeSym(sym1, sym2) 2037 v.AddArg(base) 2038 v.AddArg(val) 2039 v.AddArg(mem) 2040 return true 2041 } 2042 return false 2043 } 2044 func rewriteValue386_Op386ADDLmodifyidx4_0(v *Value) bool { 2045 b := v.Block 2046 _ = b 2047 config := b.Func.Config 2048 _ = config 2049 // match: (ADDLmodifyidx4 [off1] {sym} (ADDLconst [off2] base) idx val mem) 2050 // cond: is32Bit(off1+off2) 2051 // result: (ADDLmodifyidx4 [off1+off2] {sym} base idx val mem) 2052 for { 2053 off1 := v.AuxInt 2054 sym := v.Aux 2055 _ = v.Args[3] 2056 v_0 := v.Args[0] 2057 if v_0.Op != Op386ADDLconst { 2058 break 2059 } 2060 off2 := v_0.AuxInt 2061 base := v_0.Args[0] 2062 idx := v.Args[1] 2063 val := v.Args[2] 2064 mem := v.Args[3] 2065 if !(is32Bit(off1 + off2)) { 2066 break 2067 } 2068 v.reset(Op386ADDLmodifyidx4) 2069 v.AuxInt = off1 + off2 2070 v.Aux = sym 2071 v.AddArg(base) 2072 v.AddArg(idx) 2073 v.AddArg(val) 2074 v.AddArg(mem) 2075 return true 2076 } 2077 // match: (ADDLmodifyidx4 [off1] {sym} base (ADDLconst [off2] idx) val mem) 2078 // cond: is32Bit(off1+off2*4) 2079 // result: (ADDLmodifyidx4 [off1+off2*4] {sym} base idx val mem) 2080 for { 2081 off1 := v.AuxInt 2082 sym := v.Aux 2083 _ = v.Args[3] 2084 base := v.Args[0] 2085 v_1 := v.Args[1] 2086 if v_1.Op != Op386ADDLconst { 2087 break 2088 } 2089 off2 := v_1.AuxInt 2090 idx := v_1.Args[0] 2091 val := v.Args[2] 2092 mem := v.Args[3] 2093 if !(is32Bit(off1 + off2*4)) { 2094 break 2095 } 2096 v.reset(Op386ADDLmodifyidx4) 2097 v.AuxInt = off1 + off2*4 2098 v.Aux = sym 2099 v.AddArg(base) 2100 v.AddArg(idx) 2101 v.AddArg(val) 2102 v.AddArg(mem) 2103 return true 2104 } 2105 // match: (ADDLmodifyidx4 [off1] {sym1} (LEAL [off2] {sym2} base) idx val mem) 2106 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 2107 // result: (ADDLmodifyidx4 [off1+off2] {mergeSym(sym1,sym2)} base idx val mem) 2108 for { 2109 off1 := v.AuxInt 2110 sym1 := v.Aux 2111 _ = v.Args[3] 2112 v_0 := v.Args[0] 2113 if v_0.Op != Op386LEAL { 2114 break 2115 } 2116 off2 := v_0.AuxInt 2117 sym2 := v_0.Aux 2118 base := v_0.Args[0] 2119 idx := v.Args[1] 2120 val := v.Args[2] 2121 mem := v.Args[3] 2122 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 2123 break 2124 } 2125 v.reset(Op386ADDLmodifyidx4) 2126 v.AuxInt = off1 + off2 2127 v.Aux = mergeSym(sym1, sym2) 2128 v.AddArg(base) 2129 v.AddArg(idx) 2130 v.AddArg(val) 2131 v.AddArg(mem) 2132 return true 2133 } 2134 // match: (ADDLmodifyidx4 [off] {sym} ptr idx (MOVLconst [c]) mem) 2135 // cond: validValAndOff(c,off) 2136 // result: (ADDLconstmodifyidx4 [makeValAndOff(c,off)] {sym} ptr idx mem) 2137 for { 2138 off := v.AuxInt 2139 sym := v.Aux 2140 _ = v.Args[3] 2141 ptr := v.Args[0] 2142 idx := v.Args[1] 2143 v_2 := v.Args[2] 2144 if v_2.Op != Op386MOVLconst { 2145 break 2146 } 2147 c := v_2.AuxInt 2148 mem := v.Args[3] 2149 if !(validValAndOff(c, off)) { 2150 break 2151 } 2152 v.reset(Op386ADDLconstmodifyidx4) 2153 v.AuxInt = makeValAndOff(c, off) 2154 v.Aux = sym 2155 v.AddArg(ptr) 2156 v.AddArg(idx) 2157 v.AddArg(mem) 2158 return true 2159 } 2160 return false 2161 } 2162 func rewriteValue386_Op386ADDSD_0(v *Value) bool { 2163 b := v.Block 2164 _ = b 2165 config := b.Func.Config 2166 _ = config 2167 // match: (ADDSD x l:(MOVSDload [off] {sym} ptr mem)) 2168 // cond: canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l) 2169 // result: (ADDSDload x [off] {sym} ptr mem) 2170 for { 2171 _ = v.Args[1] 2172 x := v.Args[0] 2173 l := v.Args[1] 2174 if l.Op != Op386MOVSDload { 2175 break 2176 } 2177 off := l.AuxInt 2178 sym := l.Aux 2179 _ = l.Args[1] 2180 ptr := l.Args[0] 2181 mem := l.Args[1] 2182 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) { 2183 break 2184 } 2185 v.reset(Op386ADDSDload) 2186 v.AuxInt = off 2187 v.Aux = sym 2188 v.AddArg(x) 2189 v.AddArg(ptr) 2190 v.AddArg(mem) 2191 return true 2192 } 2193 // match: (ADDSD l:(MOVSDload [off] {sym} ptr mem) x) 2194 // cond: canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l) 2195 // result: (ADDSDload x [off] {sym} ptr mem) 2196 for { 2197 _ = v.Args[1] 2198 l := v.Args[0] 2199 if l.Op != Op386MOVSDload { 2200 break 2201 } 2202 off := l.AuxInt 2203 sym := l.Aux 2204 _ = l.Args[1] 2205 ptr := l.Args[0] 2206 mem := l.Args[1] 2207 x := v.Args[1] 2208 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) { 2209 break 2210 } 2211 v.reset(Op386ADDSDload) 2212 v.AuxInt = off 2213 v.Aux = sym 2214 v.AddArg(x) 2215 v.AddArg(ptr) 2216 v.AddArg(mem) 2217 return true 2218 } 2219 return false 2220 } 2221 func rewriteValue386_Op386ADDSDload_0(v *Value) bool { 2222 b := v.Block 2223 _ = b 2224 config := b.Func.Config 2225 _ = config 2226 // match: (ADDSDload [off1] {sym} val (ADDLconst [off2] base) mem) 2227 // cond: is32Bit(off1+off2) 2228 // result: (ADDSDload [off1+off2] {sym} val base mem) 2229 for { 2230 off1 := v.AuxInt 2231 sym := v.Aux 2232 _ = v.Args[2] 2233 val := v.Args[0] 2234 v_1 := v.Args[1] 2235 if v_1.Op != Op386ADDLconst { 2236 break 2237 } 2238 off2 := v_1.AuxInt 2239 base := v_1.Args[0] 2240 mem := v.Args[2] 2241 if !(is32Bit(off1 + off2)) { 2242 break 2243 } 2244 v.reset(Op386ADDSDload) 2245 v.AuxInt = off1 + off2 2246 v.Aux = sym 2247 v.AddArg(val) 2248 v.AddArg(base) 2249 v.AddArg(mem) 2250 return true 2251 } 2252 // match: (ADDSDload [off1] {sym1} val (LEAL [off2] {sym2} base) mem) 2253 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 2254 // result: (ADDSDload [off1+off2] {mergeSym(sym1,sym2)} val base mem) 2255 for { 2256 off1 := v.AuxInt 2257 sym1 := v.Aux 2258 _ = v.Args[2] 2259 val := v.Args[0] 2260 v_1 := v.Args[1] 2261 if v_1.Op != Op386LEAL { 2262 break 2263 } 2264 off2 := v_1.AuxInt 2265 sym2 := v_1.Aux 2266 base := v_1.Args[0] 2267 mem := v.Args[2] 2268 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 2269 break 2270 } 2271 v.reset(Op386ADDSDload) 2272 v.AuxInt = off1 + off2 2273 v.Aux = mergeSym(sym1, sym2) 2274 v.AddArg(val) 2275 v.AddArg(base) 2276 v.AddArg(mem) 2277 return true 2278 } 2279 return false 2280 } 2281 func rewriteValue386_Op386ADDSS_0(v *Value) bool { 2282 b := v.Block 2283 _ = b 2284 config := b.Func.Config 2285 _ = config 2286 // match: (ADDSS x l:(MOVSSload [off] {sym} ptr mem)) 2287 // cond: canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l) 2288 // result: (ADDSSload x [off] {sym} ptr mem) 2289 for { 2290 _ = v.Args[1] 2291 x := v.Args[0] 2292 l := v.Args[1] 2293 if l.Op != Op386MOVSSload { 2294 break 2295 } 2296 off := l.AuxInt 2297 sym := l.Aux 2298 _ = l.Args[1] 2299 ptr := l.Args[0] 2300 mem := l.Args[1] 2301 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) { 2302 break 2303 } 2304 v.reset(Op386ADDSSload) 2305 v.AuxInt = off 2306 v.Aux = sym 2307 v.AddArg(x) 2308 v.AddArg(ptr) 2309 v.AddArg(mem) 2310 return true 2311 } 2312 // match: (ADDSS l:(MOVSSload [off] {sym} ptr mem) x) 2313 // cond: canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l) 2314 // result: (ADDSSload x [off] {sym} ptr mem) 2315 for { 2316 _ = v.Args[1] 2317 l := v.Args[0] 2318 if l.Op != Op386MOVSSload { 2319 break 2320 } 2321 off := l.AuxInt 2322 sym := l.Aux 2323 _ = l.Args[1] 2324 ptr := l.Args[0] 2325 mem := l.Args[1] 2326 x := v.Args[1] 2327 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) { 2328 break 2329 } 2330 v.reset(Op386ADDSSload) 2331 v.AuxInt = off 2332 v.Aux = sym 2333 v.AddArg(x) 2334 v.AddArg(ptr) 2335 v.AddArg(mem) 2336 return true 2337 } 2338 return false 2339 } 2340 func rewriteValue386_Op386ADDSSload_0(v *Value) bool { 2341 b := v.Block 2342 _ = b 2343 config := b.Func.Config 2344 _ = config 2345 // match: (ADDSSload [off1] {sym} val (ADDLconst [off2] base) mem) 2346 // cond: is32Bit(off1+off2) 2347 // result: (ADDSSload [off1+off2] {sym} val base mem) 2348 for { 2349 off1 := v.AuxInt 2350 sym := v.Aux 2351 _ = v.Args[2] 2352 val := v.Args[0] 2353 v_1 := v.Args[1] 2354 if v_1.Op != Op386ADDLconst { 2355 break 2356 } 2357 off2 := v_1.AuxInt 2358 base := v_1.Args[0] 2359 mem := v.Args[2] 2360 if !(is32Bit(off1 + off2)) { 2361 break 2362 } 2363 v.reset(Op386ADDSSload) 2364 v.AuxInt = off1 + off2 2365 v.Aux = sym 2366 v.AddArg(val) 2367 v.AddArg(base) 2368 v.AddArg(mem) 2369 return true 2370 } 2371 // match: (ADDSSload [off1] {sym1} val (LEAL [off2] {sym2} base) mem) 2372 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 2373 // result: (ADDSSload [off1+off2] {mergeSym(sym1,sym2)} val base mem) 2374 for { 2375 off1 := v.AuxInt 2376 sym1 := v.Aux 2377 _ = v.Args[2] 2378 val := v.Args[0] 2379 v_1 := v.Args[1] 2380 if v_1.Op != Op386LEAL { 2381 break 2382 } 2383 off2 := v_1.AuxInt 2384 sym2 := v_1.Aux 2385 base := v_1.Args[0] 2386 mem := v.Args[2] 2387 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 2388 break 2389 } 2390 v.reset(Op386ADDSSload) 2391 v.AuxInt = off1 + off2 2392 v.Aux = mergeSym(sym1, sym2) 2393 v.AddArg(val) 2394 v.AddArg(base) 2395 v.AddArg(mem) 2396 return true 2397 } 2398 return false 2399 } 2400 func rewriteValue386_Op386ANDL_0(v *Value) bool { 2401 // match: (ANDL x (MOVLconst [c])) 2402 // cond: 2403 // result: (ANDLconst [c] x) 2404 for { 2405 _ = v.Args[1] 2406 x := v.Args[0] 2407 v_1 := v.Args[1] 2408 if v_1.Op != Op386MOVLconst { 2409 break 2410 } 2411 c := v_1.AuxInt 2412 v.reset(Op386ANDLconst) 2413 v.AuxInt = c 2414 v.AddArg(x) 2415 return true 2416 } 2417 // match: (ANDL (MOVLconst [c]) x) 2418 // cond: 2419 // result: (ANDLconst [c] x) 2420 for { 2421 _ = v.Args[1] 2422 v_0 := v.Args[0] 2423 if v_0.Op != Op386MOVLconst { 2424 break 2425 } 2426 c := v_0.AuxInt 2427 x := v.Args[1] 2428 v.reset(Op386ANDLconst) 2429 v.AuxInt = c 2430 v.AddArg(x) 2431 return true 2432 } 2433 // match: (ANDL x l:(MOVLload [off] {sym} ptr mem)) 2434 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 2435 // result: (ANDLload x [off] {sym} ptr mem) 2436 for { 2437 _ = v.Args[1] 2438 x := v.Args[0] 2439 l := v.Args[1] 2440 if l.Op != Op386MOVLload { 2441 break 2442 } 2443 off := l.AuxInt 2444 sym := l.Aux 2445 _ = l.Args[1] 2446 ptr := l.Args[0] 2447 mem := l.Args[1] 2448 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 2449 break 2450 } 2451 v.reset(Op386ANDLload) 2452 v.AuxInt = off 2453 v.Aux = sym 2454 v.AddArg(x) 2455 v.AddArg(ptr) 2456 v.AddArg(mem) 2457 return true 2458 } 2459 // match: (ANDL l:(MOVLload [off] {sym} ptr mem) x) 2460 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 2461 // result: (ANDLload x [off] {sym} ptr mem) 2462 for { 2463 _ = v.Args[1] 2464 l := v.Args[0] 2465 if l.Op != Op386MOVLload { 2466 break 2467 } 2468 off := l.AuxInt 2469 sym := l.Aux 2470 _ = l.Args[1] 2471 ptr := l.Args[0] 2472 mem := l.Args[1] 2473 x := v.Args[1] 2474 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 2475 break 2476 } 2477 v.reset(Op386ANDLload) 2478 v.AuxInt = off 2479 v.Aux = sym 2480 v.AddArg(x) 2481 v.AddArg(ptr) 2482 v.AddArg(mem) 2483 return true 2484 } 2485 // match: (ANDL x l:(MOVLloadidx4 [off] {sym} ptr idx mem)) 2486 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 2487 // result: (ANDLloadidx4 x [off] {sym} ptr idx mem) 2488 for { 2489 _ = v.Args[1] 2490 x := v.Args[0] 2491 l := v.Args[1] 2492 if l.Op != Op386MOVLloadidx4 { 2493 break 2494 } 2495 off := l.AuxInt 2496 sym := l.Aux 2497 _ = l.Args[2] 2498 ptr := l.Args[0] 2499 idx := l.Args[1] 2500 mem := l.Args[2] 2501 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 2502 break 2503 } 2504 v.reset(Op386ANDLloadidx4) 2505 v.AuxInt = off 2506 v.Aux = sym 2507 v.AddArg(x) 2508 v.AddArg(ptr) 2509 v.AddArg(idx) 2510 v.AddArg(mem) 2511 return true 2512 } 2513 // match: (ANDL l:(MOVLloadidx4 [off] {sym} ptr idx mem) x) 2514 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 2515 // result: (ANDLloadidx4 x [off] {sym} ptr idx mem) 2516 for { 2517 _ = v.Args[1] 2518 l := v.Args[0] 2519 if l.Op != Op386MOVLloadidx4 { 2520 break 2521 } 2522 off := l.AuxInt 2523 sym := l.Aux 2524 _ = l.Args[2] 2525 ptr := l.Args[0] 2526 idx := l.Args[1] 2527 mem := l.Args[2] 2528 x := v.Args[1] 2529 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 2530 break 2531 } 2532 v.reset(Op386ANDLloadidx4) 2533 v.AuxInt = off 2534 v.Aux = sym 2535 v.AddArg(x) 2536 v.AddArg(ptr) 2537 v.AddArg(idx) 2538 v.AddArg(mem) 2539 return true 2540 } 2541 // match: (ANDL x x) 2542 // cond: 2543 // result: x 2544 for { 2545 _ = v.Args[1] 2546 x := v.Args[0] 2547 if x != v.Args[1] { 2548 break 2549 } 2550 v.reset(OpCopy) 2551 v.Type = x.Type 2552 v.AddArg(x) 2553 return true 2554 } 2555 return false 2556 } 2557 func rewriteValue386_Op386ANDLconst_0(v *Value) bool { 2558 // match: (ANDLconst [c] (ANDLconst [d] x)) 2559 // cond: 2560 // result: (ANDLconst [c & d] x) 2561 for { 2562 c := v.AuxInt 2563 v_0 := v.Args[0] 2564 if v_0.Op != Op386ANDLconst { 2565 break 2566 } 2567 d := v_0.AuxInt 2568 x := v_0.Args[0] 2569 v.reset(Op386ANDLconst) 2570 v.AuxInt = c & d 2571 v.AddArg(x) 2572 return true 2573 } 2574 // match: (ANDLconst [c] _) 2575 // cond: int32(c)==0 2576 // result: (MOVLconst [0]) 2577 for { 2578 c := v.AuxInt 2579 if !(int32(c) == 0) { 2580 break 2581 } 2582 v.reset(Op386MOVLconst) 2583 v.AuxInt = 0 2584 return true 2585 } 2586 // match: (ANDLconst [c] x) 2587 // cond: int32(c)==-1 2588 // result: x 2589 for { 2590 c := v.AuxInt 2591 x := v.Args[0] 2592 if !(int32(c) == -1) { 2593 break 2594 } 2595 v.reset(OpCopy) 2596 v.Type = x.Type 2597 v.AddArg(x) 2598 return true 2599 } 2600 // match: (ANDLconst [c] (MOVLconst [d])) 2601 // cond: 2602 // result: (MOVLconst [c&d]) 2603 for { 2604 c := v.AuxInt 2605 v_0 := v.Args[0] 2606 if v_0.Op != Op386MOVLconst { 2607 break 2608 } 2609 d := v_0.AuxInt 2610 v.reset(Op386MOVLconst) 2611 v.AuxInt = c & d 2612 return true 2613 } 2614 return false 2615 } 2616 func rewriteValue386_Op386ANDLconstmodify_0(v *Value) bool { 2617 b := v.Block 2618 _ = b 2619 config := b.Func.Config 2620 _ = config 2621 // match: (ANDLconstmodify [valoff1] {sym} (ADDLconst [off2] base) mem) 2622 // cond: ValAndOff(valoff1).canAdd(off2) 2623 // result: (ANDLconstmodify [ValAndOff(valoff1).add(off2)] {sym} base mem) 2624 for { 2625 valoff1 := v.AuxInt 2626 sym := v.Aux 2627 _ = v.Args[1] 2628 v_0 := v.Args[0] 2629 if v_0.Op != Op386ADDLconst { 2630 break 2631 } 2632 off2 := v_0.AuxInt 2633 base := v_0.Args[0] 2634 mem := v.Args[1] 2635 if !(ValAndOff(valoff1).canAdd(off2)) { 2636 break 2637 } 2638 v.reset(Op386ANDLconstmodify) 2639 v.AuxInt = ValAndOff(valoff1).add(off2) 2640 v.Aux = sym 2641 v.AddArg(base) 2642 v.AddArg(mem) 2643 return true 2644 } 2645 // match: (ANDLconstmodify [valoff1] {sym1} (LEAL [off2] {sym2} base) mem) 2646 // cond: ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 2647 // result: (ANDLconstmodify [ValAndOff(valoff1).add(off2)] {mergeSym(sym1,sym2)} base mem) 2648 for { 2649 valoff1 := v.AuxInt 2650 sym1 := v.Aux 2651 _ = v.Args[1] 2652 v_0 := v.Args[0] 2653 if v_0.Op != Op386LEAL { 2654 break 2655 } 2656 off2 := v_0.AuxInt 2657 sym2 := v_0.Aux 2658 base := v_0.Args[0] 2659 mem := v.Args[1] 2660 if !(ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 2661 break 2662 } 2663 v.reset(Op386ANDLconstmodify) 2664 v.AuxInt = ValAndOff(valoff1).add(off2) 2665 v.Aux = mergeSym(sym1, sym2) 2666 v.AddArg(base) 2667 v.AddArg(mem) 2668 return true 2669 } 2670 return false 2671 } 2672 func rewriteValue386_Op386ANDLconstmodifyidx4_0(v *Value) bool { 2673 b := v.Block 2674 _ = b 2675 config := b.Func.Config 2676 _ = config 2677 // match: (ANDLconstmodifyidx4 [valoff1] {sym} (ADDLconst [off2] base) idx mem) 2678 // cond: ValAndOff(valoff1).canAdd(off2) 2679 // result: (ANDLconstmodifyidx4 [ValAndOff(valoff1).add(off2)] {sym} base idx mem) 2680 for { 2681 valoff1 := v.AuxInt 2682 sym := v.Aux 2683 _ = v.Args[2] 2684 v_0 := v.Args[0] 2685 if v_0.Op != Op386ADDLconst { 2686 break 2687 } 2688 off2 := v_0.AuxInt 2689 base := v_0.Args[0] 2690 idx := v.Args[1] 2691 mem := v.Args[2] 2692 if !(ValAndOff(valoff1).canAdd(off2)) { 2693 break 2694 } 2695 v.reset(Op386ANDLconstmodifyidx4) 2696 v.AuxInt = ValAndOff(valoff1).add(off2) 2697 v.Aux = sym 2698 v.AddArg(base) 2699 v.AddArg(idx) 2700 v.AddArg(mem) 2701 return true 2702 } 2703 // match: (ANDLconstmodifyidx4 [valoff1] {sym} base (ADDLconst [off2] idx) mem) 2704 // cond: ValAndOff(valoff1).canAdd(off2*4) 2705 // result: (ANDLconstmodifyidx4 [ValAndOff(valoff1).add(off2*4)] {sym} base idx mem) 2706 for { 2707 valoff1 := v.AuxInt 2708 sym := v.Aux 2709 _ = v.Args[2] 2710 base := v.Args[0] 2711 v_1 := v.Args[1] 2712 if v_1.Op != Op386ADDLconst { 2713 break 2714 } 2715 off2 := v_1.AuxInt 2716 idx := v_1.Args[0] 2717 mem := v.Args[2] 2718 if !(ValAndOff(valoff1).canAdd(off2 * 4)) { 2719 break 2720 } 2721 v.reset(Op386ANDLconstmodifyidx4) 2722 v.AuxInt = ValAndOff(valoff1).add(off2 * 4) 2723 v.Aux = sym 2724 v.AddArg(base) 2725 v.AddArg(idx) 2726 v.AddArg(mem) 2727 return true 2728 } 2729 // match: (ANDLconstmodifyidx4 [valoff1] {sym1} (LEAL [off2] {sym2} base) idx mem) 2730 // cond: ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 2731 // result: (ANDLconstmodifyidx4 [ValAndOff(valoff1).add(off2)] {mergeSym(sym1,sym2)} base idx mem) 2732 for { 2733 valoff1 := v.AuxInt 2734 sym1 := v.Aux 2735 _ = v.Args[2] 2736 v_0 := v.Args[0] 2737 if v_0.Op != Op386LEAL { 2738 break 2739 } 2740 off2 := v_0.AuxInt 2741 sym2 := v_0.Aux 2742 base := v_0.Args[0] 2743 idx := v.Args[1] 2744 mem := v.Args[2] 2745 if !(ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 2746 break 2747 } 2748 v.reset(Op386ANDLconstmodifyidx4) 2749 v.AuxInt = ValAndOff(valoff1).add(off2) 2750 v.Aux = mergeSym(sym1, sym2) 2751 v.AddArg(base) 2752 v.AddArg(idx) 2753 v.AddArg(mem) 2754 return true 2755 } 2756 return false 2757 } 2758 func rewriteValue386_Op386ANDLload_0(v *Value) bool { 2759 b := v.Block 2760 _ = b 2761 config := b.Func.Config 2762 _ = config 2763 // match: (ANDLload [off1] {sym} val (ADDLconst [off2] base) mem) 2764 // cond: is32Bit(off1+off2) 2765 // result: (ANDLload [off1+off2] {sym} val base mem) 2766 for { 2767 off1 := v.AuxInt 2768 sym := v.Aux 2769 _ = v.Args[2] 2770 val := v.Args[0] 2771 v_1 := v.Args[1] 2772 if v_1.Op != Op386ADDLconst { 2773 break 2774 } 2775 off2 := v_1.AuxInt 2776 base := v_1.Args[0] 2777 mem := v.Args[2] 2778 if !(is32Bit(off1 + off2)) { 2779 break 2780 } 2781 v.reset(Op386ANDLload) 2782 v.AuxInt = off1 + off2 2783 v.Aux = sym 2784 v.AddArg(val) 2785 v.AddArg(base) 2786 v.AddArg(mem) 2787 return true 2788 } 2789 // match: (ANDLload [off1] {sym1} val (LEAL [off2] {sym2} base) mem) 2790 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 2791 // result: (ANDLload [off1+off2] {mergeSym(sym1,sym2)} val base mem) 2792 for { 2793 off1 := v.AuxInt 2794 sym1 := v.Aux 2795 _ = v.Args[2] 2796 val := v.Args[0] 2797 v_1 := v.Args[1] 2798 if v_1.Op != Op386LEAL { 2799 break 2800 } 2801 off2 := v_1.AuxInt 2802 sym2 := v_1.Aux 2803 base := v_1.Args[0] 2804 mem := v.Args[2] 2805 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 2806 break 2807 } 2808 v.reset(Op386ANDLload) 2809 v.AuxInt = off1 + off2 2810 v.Aux = mergeSym(sym1, sym2) 2811 v.AddArg(val) 2812 v.AddArg(base) 2813 v.AddArg(mem) 2814 return true 2815 } 2816 // match: (ANDLload [off1] {sym1} val (LEAL4 [off2] {sym2} ptr idx) mem) 2817 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 2818 // result: (ANDLloadidx4 [off1+off2] {mergeSym(sym1,sym2)} val ptr idx mem) 2819 for { 2820 off1 := v.AuxInt 2821 sym1 := v.Aux 2822 _ = v.Args[2] 2823 val := v.Args[0] 2824 v_1 := v.Args[1] 2825 if v_1.Op != Op386LEAL4 { 2826 break 2827 } 2828 off2 := v_1.AuxInt 2829 sym2 := v_1.Aux 2830 _ = v_1.Args[1] 2831 ptr := v_1.Args[0] 2832 idx := v_1.Args[1] 2833 mem := v.Args[2] 2834 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 2835 break 2836 } 2837 v.reset(Op386ANDLloadidx4) 2838 v.AuxInt = off1 + off2 2839 v.Aux = mergeSym(sym1, sym2) 2840 v.AddArg(val) 2841 v.AddArg(ptr) 2842 v.AddArg(idx) 2843 v.AddArg(mem) 2844 return true 2845 } 2846 return false 2847 } 2848 func rewriteValue386_Op386ANDLloadidx4_0(v *Value) bool { 2849 b := v.Block 2850 _ = b 2851 config := b.Func.Config 2852 _ = config 2853 // match: (ANDLloadidx4 [off1] {sym} val (ADDLconst [off2] base) idx mem) 2854 // cond: is32Bit(off1+off2) 2855 // result: (ANDLloadidx4 [off1+off2] {sym} val base idx mem) 2856 for { 2857 off1 := v.AuxInt 2858 sym := v.Aux 2859 _ = v.Args[3] 2860 val := v.Args[0] 2861 v_1 := v.Args[1] 2862 if v_1.Op != Op386ADDLconst { 2863 break 2864 } 2865 off2 := v_1.AuxInt 2866 base := v_1.Args[0] 2867 idx := v.Args[2] 2868 mem := v.Args[3] 2869 if !(is32Bit(off1 + off2)) { 2870 break 2871 } 2872 v.reset(Op386ANDLloadidx4) 2873 v.AuxInt = off1 + off2 2874 v.Aux = sym 2875 v.AddArg(val) 2876 v.AddArg(base) 2877 v.AddArg(idx) 2878 v.AddArg(mem) 2879 return true 2880 } 2881 // match: (ANDLloadidx4 [off1] {sym} val base (ADDLconst [off2] idx) mem) 2882 // cond: is32Bit(off1+off2*4) 2883 // result: (ANDLloadidx4 [off1+off2*4] {sym} val base idx mem) 2884 for { 2885 off1 := v.AuxInt 2886 sym := v.Aux 2887 _ = v.Args[3] 2888 val := v.Args[0] 2889 base := v.Args[1] 2890 v_2 := v.Args[2] 2891 if v_2.Op != Op386ADDLconst { 2892 break 2893 } 2894 off2 := v_2.AuxInt 2895 idx := v_2.Args[0] 2896 mem := v.Args[3] 2897 if !(is32Bit(off1 + off2*4)) { 2898 break 2899 } 2900 v.reset(Op386ANDLloadidx4) 2901 v.AuxInt = off1 + off2*4 2902 v.Aux = sym 2903 v.AddArg(val) 2904 v.AddArg(base) 2905 v.AddArg(idx) 2906 v.AddArg(mem) 2907 return true 2908 } 2909 // match: (ANDLloadidx4 [off1] {sym1} val (LEAL [off2] {sym2} base) idx mem) 2910 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 2911 // result: (ANDLloadidx4 [off1+off2] {mergeSym(sym1,sym2)} val base idx mem) 2912 for { 2913 off1 := v.AuxInt 2914 sym1 := v.Aux 2915 _ = v.Args[3] 2916 val := v.Args[0] 2917 v_1 := v.Args[1] 2918 if v_1.Op != Op386LEAL { 2919 break 2920 } 2921 off2 := v_1.AuxInt 2922 sym2 := v_1.Aux 2923 base := v_1.Args[0] 2924 idx := v.Args[2] 2925 mem := v.Args[3] 2926 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 2927 break 2928 } 2929 v.reset(Op386ANDLloadidx4) 2930 v.AuxInt = off1 + off2 2931 v.Aux = mergeSym(sym1, sym2) 2932 v.AddArg(val) 2933 v.AddArg(base) 2934 v.AddArg(idx) 2935 v.AddArg(mem) 2936 return true 2937 } 2938 return false 2939 } 2940 func rewriteValue386_Op386ANDLmodify_0(v *Value) bool { 2941 b := v.Block 2942 _ = b 2943 config := b.Func.Config 2944 _ = config 2945 // match: (ANDLmodify [off1] {sym} (ADDLconst [off2] base) val mem) 2946 // cond: is32Bit(off1+off2) 2947 // result: (ANDLmodify [off1+off2] {sym} base val mem) 2948 for { 2949 off1 := v.AuxInt 2950 sym := v.Aux 2951 _ = v.Args[2] 2952 v_0 := v.Args[0] 2953 if v_0.Op != Op386ADDLconst { 2954 break 2955 } 2956 off2 := v_0.AuxInt 2957 base := v_0.Args[0] 2958 val := v.Args[1] 2959 mem := v.Args[2] 2960 if !(is32Bit(off1 + off2)) { 2961 break 2962 } 2963 v.reset(Op386ANDLmodify) 2964 v.AuxInt = off1 + off2 2965 v.Aux = sym 2966 v.AddArg(base) 2967 v.AddArg(val) 2968 v.AddArg(mem) 2969 return true 2970 } 2971 // match: (ANDLmodify [off1] {sym1} (LEAL [off2] {sym2} base) val mem) 2972 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 2973 // result: (ANDLmodify [off1+off2] {mergeSym(sym1,sym2)} base val mem) 2974 for { 2975 off1 := v.AuxInt 2976 sym1 := v.Aux 2977 _ = v.Args[2] 2978 v_0 := v.Args[0] 2979 if v_0.Op != Op386LEAL { 2980 break 2981 } 2982 off2 := v_0.AuxInt 2983 sym2 := v_0.Aux 2984 base := v_0.Args[0] 2985 val := v.Args[1] 2986 mem := v.Args[2] 2987 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 2988 break 2989 } 2990 v.reset(Op386ANDLmodify) 2991 v.AuxInt = off1 + off2 2992 v.Aux = mergeSym(sym1, sym2) 2993 v.AddArg(base) 2994 v.AddArg(val) 2995 v.AddArg(mem) 2996 return true 2997 } 2998 return false 2999 } 3000 func rewriteValue386_Op386ANDLmodifyidx4_0(v *Value) bool { 3001 b := v.Block 3002 _ = b 3003 config := b.Func.Config 3004 _ = config 3005 // match: (ANDLmodifyidx4 [off1] {sym} (ADDLconst [off2] base) idx val mem) 3006 // cond: is32Bit(off1+off2) 3007 // result: (ANDLmodifyidx4 [off1+off2] {sym} base idx val mem) 3008 for { 3009 off1 := v.AuxInt 3010 sym := v.Aux 3011 _ = v.Args[3] 3012 v_0 := v.Args[0] 3013 if v_0.Op != Op386ADDLconst { 3014 break 3015 } 3016 off2 := v_0.AuxInt 3017 base := v_0.Args[0] 3018 idx := v.Args[1] 3019 val := v.Args[2] 3020 mem := v.Args[3] 3021 if !(is32Bit(off1 + off2)) { 3022 break 3023 } 3024 v.reset(Op386ANDLmodifyidx4) 3025 v.AuxInt = off1 + off2 3026 v.Aux = sym 3027 v.AddArg(base) 3028 v.AddArg(idx) 3029 v.AddArg(val) 3030 v.AddArg(mem) 3031 return true 3032 } 3033 // match: (ANDLmodifyidx4 [off1] {sym} base (ADDLconst [off2] idx) val mem) 3034 // cond: is32Bit(off1+off2*4) 3035 // result: (ANDLmodifyidx4 [off1+off2*4] {sym} base idx val mem) 3036 for { 3037 off1 := v.AuxInt 3038 sym := v.Aux 3039 _ = v.Args[3] 3040 base := v.Args[0] 3041 v_1 := v.Args[1] 3042 if v_1.Op != Op386ADDLconst { 3043 break 3044 } 3045 off2 := v_1.AuxInt 3046 idx := v_1.Args[0] 3047 val := v.Args[2] 3048 mem := v.Args[3] 3049 if !(is32Bit(off1 + off2*4)) { 3050 break 3051 } 3052 v.reset(Op386ANDLmodifyidx4) 3053 v.AuxInt = off1 + off2*4 3054 v.Aux = sym 3055 v.AddArg(base) 3056 v.AddArg(idx) 3057 v.AddArg(val) 3058 v.AddArg(mem) 3059 return true 3060 } 3061 // match: (ANDLmodifyidx4 [off1] {sym1} (LEAL [off2] {sym2} base) idx val mem) 3062 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 3063 // result: (ANDLmodifyidx4 [off1+off2] {mergeSym(sym1,sym2)} base idx val mem) 3064 for { 3065 off1 := v.AuxInt 3066 sym1 := v.Aux 3067 _ = v.Args[3] 3068 v_0 := v.Args[0] 3069 if v_0.Op != Op386LEAL { 3070 break 3071 } 3072 off2 := v_0.AuxInt 3073 sym2 := v_0.Aux 3074 base := v_0.Args[0] 3075 idx := v.Args[1] 3076 val := v.Args[2] 3077 mem := v.Args[3] 3078 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 3079 break 3080 } 3081 v.reset(Op386ANDLmodifyidx4) 3082 v.AuxInt = off1 + off2 3083 v.Aux = mergeSym(sym1, sym2) 3084 v.AddArg(base) 3085 v.AddArg(idx) 3086 v.AddArg(val) 3087 v.AddArg(mem) 3088 return true 3089 } 3090 // match: (ANDLmodifyidx4 [off] {sym} ptr idx (MOVLconst [c]) mem) 3091 // cond: validValAndOff(c,off) 3092 // result: (ANDLconstmodifyidx4 [makeValAndOff(c,off)] {sym} ptr idx mem) 3093 for { 3094 off := v.AuxInt 3095 sym := v.Aux 3096 _ = v.Args[3] 3097 ptr := v.Args[0] 3098 idx := v.Args[1] 3099 v_2 := v.Args[2] 3100 if v_2.Op != Op386MOVLconst { 3101 break 3102 } 3103 c := v_2.AuxInt 3104 mem := v.Args[3] 3105 if !(validValAndOff(c, off)) { 3106 break 3107 } 3108 v.reset(Op386ANDLconstmodifyidx4) 3109 v.AuxInt = makeValAndOff(c, off) 3110 v.Aux = sym 3111 v.AddArg(ptr) 3112 v.AddArg(idx) 3113 v.AddArg(mem) 3114 return true 3115 } 3116 return false 3117 } 3118 func rewriteValue386_Op386CMPB_0(v *Value) bool { 3119 b := v.Block 3120 _ = b 3121 // match: (CMPB x (MOVLconst [c])) 3122 // cond: 3123 // result: (CMPBconst x [int64(int8(c))]) 3124 for { 3125 _ = v.Args[1] 3126 x := v.Args[0] 3127 v_1 := v.Args[1] 3128 if v_1.Op != Op386MOVLconst { 3129 break 3130 } 3131 c := v_1.AuxInt 3132 v.reset(Op386CMPBconst) 3133 v.AuxInt = int64(int8(c)) 3134 v.AddArg(x) 3135 return true 3136 } 3137 // match: (CMPB (MOVLconst [c]) x) 3138 // cond: 3139 // result: (InvertFlags (CMPBconst x [int64(int8(c))])) 3140 for { 3141 _ = v.Args[1] 3142 v_0 := v.Args[0] 3143 if v_0.Op != Op386MOVLconst { 3144 break 3145 } 3146 c := v_0.AuxInt 3147 x := v.Args[1] 3148 v.reset(Op386InvertFlags) 3149 v0 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags) 3150 v0.AuxInt = int64(int8(c)) 3151 v0.AddArg(x) 3152 v.AddArg(v0) 3153 return true 3154 } 3155 // match: (CMPB l:(MOVBload {sym} [off] ptr mem) x) 3156 // cond: canMergeLoad(v, l) && clobber(l) 3157 // result: (CMPBload {sym} [off] ptr x mem) 3158 for { 3159 _ = v.Args[1] 3160 l := v.Args[0] 3161 if l.Op != Op386MOVBload { 3162 break 3163 } 3164 off := l.AuxInt 3165 sym := l.Aux 3166 _ = l.Args[1] 3167 ptr := l.Args[0] 3168 mem := l.Args[1] 3169 x := v.Args[1] 3170 if !(canMergeLoad(v, l) && clobber(l)) { 3171 break 3172 } 3173 v.reset(Op386CMPBload) 3174 v.AuxInt = off 3175 v.Aux = sym 3176 v.AddArg(ptr) 3177 v.AddArg(x) 3178 v.AddArg(mem) 3179 return true 3180 } 3181 // match: (CMPB x l:(MOVBload {sym} [off] ptr mem)) 3182 // cond: canMergeLoad(v, l) && clobber(l) 3183 // result: (InvertFlags (CMPBload {sym} [off] ptr x mem)) 3184 for { 3185 _ = v.Args[1] 3186 x := v.Args[0] 3187 l := v.Args[1] 3188 if l.Op != Op386MOVBload { 3189 break 3190 } 3191 off := l.AuxInt 3192 sym := l.Aux 3193 _ = l.Args[1] 3194 ptr := l.Args[0] 3195 mem := l.Args[1] 3196 if !(canMergeLoad(v, l) && clobber(l)) { 3197 break 3198 } 3199 v.reset(Op386InvertFlags) 3200 v0 := b.NewValue0(l.Pos, Op386CMPBload, types.TypeFlags) 3201 v0.AuxInt = off 3202 v0.Aux = sym 3203 v0.AddArg(ptr) 3204 v0.AddArg(x) 3205 v0.AddArg(mem) 3206 v.AddArg(v0) 3207 return true 3208 } 3209 return false 3210 } 3211 func rewriteValue386_Op386CMPBconst_0(v *Value) bool { 3212 b := v.Block 3213 _ = b 3214 // match: (CMPBconst (MOVLconst [x]) [y]) 3215 // cond: int8(x)==int8(y) 3216 // result: (FlagEQ) 3217 for { 3218 y := v.AuxInt 3219 v_0 := v.Args[0] 3220 if v_0.Op != Op386MOVLconst { 3221 break 3222 } 3223 x := v_0.AuxInt 3224 if !(int8(x) == int8(y)) { 3225 break 3226 } 3227 v.reset(Op386FlagEQ) 3228 return true 3229 } 3230 // match: (CMPBconst (MOVLconst [x]) [y]) 3231 // cond: int8(x)<int8(y) && uint8(x)<uint8(y) 3232 // result: (FlagLT_ULT) 3233 for { 3234 y := v.AuxInt 3235 v_0 := v.Args[0] 3236 if v_0.Op != Op386MOVLconst { 3237 break 3238 } 3239 x := v_0.AuxInt 3240 if !(int8(x) < int8(y) && uint8(x) < uint8(y)) { 3241 break 3242 } 3243 v.reset(Op386FlagLT_ULT) 3244 return true 3245 } 3246 // match: (CMPBconst (MOVLconst [x]) [y]) 3247 // cond: int8(x)<int8(y) && uint8(x)>uint8(y) 3248 // result: (FlagLT_UGT) 3249 for { 3250 y := v.AuxInt 3251 v_0 := v.Args[0] 3252 if v_0.Op != Op386MOVLconst { 3253 break 3254 } 3255 x := v_0.AuxInt 3256 if !(int8(x) < int8(y) && uint8(x) > uint8(y)) { 3257 break 3258 } 3259 v.reset(Op386FlagLT_UGT) 3260 return true 3261 } 3262 // match: (CMPBconst (MOVLconst [x]) [y]) 3263 // cond: int8(x)>int8(y) && uint8(x)<uint8(y) 3264 // result: (FlagGT_ULT) 3265 for { 3266 y := v.AuxInt 3267 v_0 := v.Args[0] 3268 if v_0.Op != Op386MOVLconst { 3269 break 3270 } 3271 x := v_0.AuxInt 3272 if !(int8(x) > int8(y) && uint8(x) < uint8(y)) { 3273 break 3274 } 3275 v.reset(Op386FlagGT_ULT) 3276 return true 3277 } 3278 // match: (CMPBconst (MOVLconst [x]) [y]) 3279 // cond: int8(x)>int8(y) && uint8(x)>uint8(y) 3280 // result: (FlagGT_UGT) 3281 for { 3282 y := v.AuxInt 3283 v_0 := v.Args[0] 3284 if v_0.Op != Op386MOVLconst { 3285 break 3286 } 3287 x := v_0.AuxInt 3288 if !(int8(x) > int8(y) && uint8(x) > uint8(y)) { 3289 break 3290 } 3291 v.reset(Op386FlagGT_UGT) 3292 return true 3293 } 3294 // match: (CMPBconst (ANDLconst _ [m]) [n]) 3295 // cond: 0 <= int8(m) && int8(m) < int8(n) 3296 // result: (FlagLT_ULT) 3297 for { 3298 n := v.AuxInt 3299 v_0 := v.Args[0] 3300 if v_0.Op != Op386ANDLconst { 3301 break 3302 } 3303 m := v_0.AuxInt 3304 if !(0 <= int8(m) && int8(m) < int8(n)) { 3305 break 3306 } 3307 v.reset(Op386FlagLT_ULT) 3308 return true 3309 } 3310 // match: (CMPBconst l:(ANDL x y) [0]) 3311 // cond: l.Uses==1 3312 // result: (TESTB x y) 3313 for { 3314 if v.AuxInt != 0 { 3315 break 3316 } 3317 l := v.Args[0] 3318 if l.Op != Op386ANDL { 3319 break 3320 } 3321 _ = l.Args[1] 3322 x := l.Args[0] 3323 y := l.Args[1] 3324 if !(l.Uses == 1) { 3325 break 3326 } 3327 v.reset(Op386TESTB) 3328 v.AddArg(x) 3329 v.AddArg(y) 3330 return true 3331 } 3332 // match: (CMPBconst l:(ANDLconst [c] x) [0]) 3333 // cond: l.Uses==1 3334 // result: (TESTBconst [int64(int8(c))] x) 3335 for { 3336 if v.AuxInt != 0 { 3337 break 3338 } 3339 l := v.Args[0] 3340 if l.Op != Op386ANDLconst { 3341 break 3342 } 3343 c := l.AuxInt 3344 x := l.Args[0] 3345 if !(l.Uses == 1) { 3346 break 3347 } 3348 v.reset(Op386TESTBconst) 3349 v.AuxInt = int64(int8(c)) 3350 v.AddArg(x) 3351 return true 3352 } 3353 // match: (CMPBconst x [0]) 3354 // cond: 3355 // result: (TESTB x x) 3356 for { 3357 if v.AuxInt != 0 { 3358 break 3359 } 3360 x := v.Args[0] 3361 v.reset(Op386TESTB) 3362 v.AddArg(x) 3363 v.AddArg(x) 3364 return true 3365 } 3366 // match: (CMPBconst l:(MOVBload {sym} [off] ptr mem) [c]) 3367 // cond: l.Uses == 1 && validValAndOff(c, off) && clobber(l) 3368 // result: @l.Block (CMPBconstload {sym} [makeValAndOff(c,off)] ptr mem) 3369 for { 3370 c := v.AuxInt 3371 l := v.Args[0] 3372 if l.Op != Op386MOVBload { 3373 break 3374 } 3375 off := l.AuxInt 3376 sym := l.Aux 3377 _ = l.Args[1] 3378 ptr := l.Args[0] 3379 mem := l.Args[1] 3380 if !(l.Uses == 1 && validValAndOff(c, off) && clobber(l)) { 3381 break 3382 } 3383 b = l.Block 3384 v0 := b.NewValue0(l.Pos, Op386CMPBconstload, types.TypeFlags) 3385 v.reset(OpCopy) 3386 v.AddArg(v0) 3387 v0.AuxInt = makeValAndOff(c, off) 3388 v0.Aux = sym 3389 v0.AddArg(ptr) 3390 v0.AddArg(mem) 3391 return true 3392 } 3393 return false 3394 } 3395 func rewriteValue386_Op386CMPBload_0(v *Value) bool { 3396 // match: (CMPBload {sym} [off] ptr (MOVLconst [c]) mem) 3397 // cond: validValAndOff(int64(int8(c)),off) 3398 // result: (CMPBconstload {sym} [makeValAndOff(int64(int8(c)),off)] ptr mem) 3399 for { 3400 off := v.AuxInt 3401 sym := v.Aux 3402 _ = v.Args[2] 3403 ptr := v.Args[0] 3404 v_1 := v.Args[1] 3405 if v_1.Op != Op386MOVLconst { 3406 break 3407 } 3408 c := v_1.AuxInt 3409 mem := v.Args[2] 3410 if !(validValAndOff(int64(int8(c)), off)) { 3411 break 3412 } 3413 v.reset(Op386CMPBconstload) 3414 v.AuxInt = makeValAndOff(int64(int8(c)), off) 3415 v.Aux = sym 3416 v.AddArg(ptr) 3417 v.AddArg(mem) 3418 return true 3419 } 3420 return false 3421 } 3422 func rewriteValue386_Op386CMPL_0(v *Value) bool { 3423 b := v.Block 3424 _ = b 3425 // match: (CMPL x (MOVLconst [c])) 3426 // cond: 3427 // result: (CMPLconst x [c]) 3428 for { 3429 _ = v.Args[1] 3430 x := v.Args[0] 3431 v_1 := v.Args[1] 3432 if v_1.Op != Op386MOVLconst { 3433 break 3434 } 3435 c := v_1.AuxInt 3436 v.reset(Op386CMPLconst) 3437 v.AuxInt = c 3438 v.AddArg(x) 3439 return true 3440 } 3441 // match: (CMPL (MOVLconst [c]) x) 3442 // cond: 3443 // result: (InvertFlags (CMPLconst x [c])) 3444 for { 3445 _ = v.Args[1] 3446 v_0 := v.Args[0] 3447 if v_0.Op != Op386MOVLconst { 3448 break 3449 } 3450 c := v_0.AuxInt 3451 x := v.Args[1] 3452 v.reset(Op386InvertFlags) 3453 v0 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags) 3454 v0.AuxInt = c 3455 v0.AddArg(x) 3456 v.AddArg(v0) 3457 return true 3458 } 3459 // match: (CMPL l:(MOVLload {sym} [off] ptr mem) x) 3460 // cond: canMergeLoad(v, l) && clobber(l) 3461 // result: (CMPLload {sym} [off] ptr x mem) 3462 for { 3463 _ = v.Args[1] 3464 l := v.Args[0] 3465 if l.Op != Op386MOVLload { 3466 break 3467 } 3468 off := l.AuxInt 3469 sym := l.Aux 3470 _ = l.Args[1] 3471 ptr := l.Args[0] 3472 mem := l.Args[1] 3473 x := v.Args[1] 3474 if !(canMergeLoad(v, l) && clobber(l)) { 3475 break 3476 } 3477 v.reset(Op386CMPLload) 3478 v.AuxInt = off 3479 v.Aux = sym 3480 v.AddArg(ptr) 3481 v.AddArg(x) 3482 v.AddArg(mem) 3483 return true 3484 } 3485 // match: (CMPL x l:(MOVLload {sym} [off] ptr mem)) 3486 // cond: canMergeLoad(v, l) && clobber(l) 3487 // result: (InvertFlags (CMPLload {sym} [off] ptr x mem)) 3488 for { 3489 _ = v.Args[1] 3490 x := v.Args[0] 3491 l := v.Args[1] 3492 if l.Op != Op386MOVLload { 3493 break 3494 } 3495 off := l.AuxInt 3496 sym := l.Aux 3497 _ = l.Args[1] 3498 ptr := l.Args[0] 3499 mem := l.Args[1] 3500 if !(canMergeLoad(v, l) && clobber(l)) { 3501 break 3502 } 3503 v.reset(Op386InvertFlags) 3504 v0 := b.NewValue0(l.Pos, Op386CMPLload, types.TypeFlags) 3505 v0.AuxInt = off 3506 v0.Aux = sym 3507 v0.AddArg(ptr) 3508 v0.AddArg(x) 3509 v0.AddArg(mem) 3510 v.AddArg(v0) 3511 return true 3512 } 3513 return false 3514 } 3515 func rewriteValue386_Op386CMPLconst_0(v *Value) bool { 3516 // match: (CMPLconst (MOVLconst [x]) [y]) 3517 // cond: int32(x)==int32(y) 3518 // result: (FlagEQ) 3519 for { 3520 y := v.AuxInt 3521 v_0 := v.Args[0] 3522 if v_0.Op != Op386MOVLconst { 3523 break 3524 } 3525 x := v_0.AuxInt 3526 if !(int32(x) == int32(y)) { 3527 break 3528 } 3529 v.reset(Op386FlagEQ) 3530 return true 3531 } 3532 // match: (CMPLconst (MOVLconst [x]) [y]) 3533 // cond: int32(x)<int32(y) && uint32(x)<uint32(y) 3534 // result: (FlagLT_ULT) 3535 for { 3536 y := v.AuxInt 3537 v_0 := v.Args[0] 3538 if v_0.Op != Op386MOVLconst { 3539 break 3540 } 3541 x := v_0.AuxInt 3542 if !(int32(x) < int32(y) && uint32(x) < uint32(y)) { 3543 break 3544 } 3545 v.reset(Op386FlagLT_ULT) 3546 return true 3547 } 3548 // match: (CMPLconst (MOVLconst [x]) [y]) 3549 // cond: int32(x)<int32(y) && uint32(x)>uint32(y) 3550 // result: (FlagLT_UGT) 3551 for { 3552 y := v.AuxInt 3553 v_0 := v.Args[0] 3554 if v_0.Op != Op386MOVLconst { 3555 break 3556 } 3557 x := v_0.AuxInt 3558 if !(int32(x) < int32(y) && uint32(x) > uint32(y)) { 3559 break 3560 } 3561 v.reset(Op386FlagLT_UGT) 3562 return true 3563 } 3564 // match: (CMPLconst (MOVLconst [x]) [y]) 3565 // cond: int32(x)>int32(y) && uint32(x)<uint32(y) 3566 // result: (FlagGT_ULT) 3567 for { 3568 y := v.AuxInt 3569 v_0 := v.Args[0] 3570 if v_0.Op != Op386MOVLconst { 3571 break 3572 } 3573 x := v_0.AuxInt 3574 if !(int32(x) > int32(y) && uint32(x) < uint32(y)) { 3575 break 3576 } 3577 v.reset(Op386FlagGT_ULT) 3578 return true 3579 } 3580 // match: (CMPLconst (MOVLconst [x]) [y]) 3581 // cond: int32(x)>int32(y) && uint32(x)>uint32(y) 3582 // result: (FlagGT_UGT) 3583 for { 3584 y := v.AuxInt 3585 v_0 := v.Args[0] 3586 if v_0.Op != Op386MOVLconst { 3587 break 3588 } 3589 x := v_0.AuxInt 3590 if !(int32(x) > int32(y) && uint32(x) > uint32(y)) { 3591 break 3592 } 3593 v.reset(Op386FlagGT_UGT) 3594 return true 3595 } 3596 // match: (CMPLconst (SHRLconst _ [c]) [n]) 3597 // cond: 0 <= n && 0 < c && c <= 32 && (1<<uint64(32-c)) <= uint64(n) 3598 // result: (FlagLT_ULT) 3599 for { 3600 n := v.AuxInt 3601 v_0 := v.Args[0] 3602 if v_0.Op != Op386SHRLconst { 3603 break 3604 } 3605 c := v_0.AuxInt 3606 if !(0 <= n && 0 < c && c <= 32 && (1<<uint64(32-c)) <= uint64(n)) { 3607 break 3608 } 3609 v.reset(Op386FlagLT_ULT) 3610 return true 3611 } 3612 // match: (CMPLconst (ANDLconst _ [m]) [n]) 3613 // cond: 0 <= int32(m) && int32(m) < int32(n) 3614 // result: (FlagLT_ULT) 3615 for { 3616 n := v.AuxInt 3617 v_0 := v.Args[0] 3618 if v_0.Op != Op386ANDLconst { 3619 break 3620 } 3621 m := v_0.AuxInt 3622 if !(0 <= int32(m) && int32(m) < int32(n)) { 3623 break 3624 } 3625 v.reset(Op386FlagLT_ULT) 3626 return true 3627 } 3628 // match: (CMPLconst l:(ANDL x y) [0]) 3629 // cond: l.Uses==1 3630 // result: (TESTL x y) 3631 for { 3632 if v.AuxInt != 0 { 3633 break 3634 } 3635 l := v.Args[0] 3636 if l.Op != Op386ANDL { 3637 break 3638 } 3639 _ = l.Args[1] 3640 x := l.Args[0] 3641 y := l.Args[1] 3642 if !(l.Uses == 1) { 3643 break 3644 } 3645 v.reset(Op386TESTL) 3646 v.AddArg(x) 3647 v.AddArg(y) 3648 return true 3649 } 3650 // match: (CMPLconst l:(ANDLconst [c] x) [0]) 3651 // cond: l.Uses==1 3652 // result: (TESTLconst [c] x) 3653 for { 3654 if v.AuxInt != 0 { 3655 break 3656 } 3657 l := v.Args[0] 3658 if l.Op != Op386ANDLconst { 3659 break 3660 } 3661 c := l.AuxInt 3662 x := l.Args[0] 3663 if !(l.Uses == 1) { 3664 break 3665 } 3666 v.reset(Op386TESTLconst) 3667 v.AuxInt = c 3668 v.AddArg(x) 3669 return true 3670 } 3671 // match: (CMPLconst x [0]) 3672 // cond: 3673 // result: (TESTL x x) 3674 for { 3675 if v.AuxInt != 0 { 3676 break 3677 } 3678 x := v.Args[0] 3679 v.reset(Op386TESTL) 3680 v.AddArg(x) 3681 v.AddArg(x) 3682 return true 3683 } 3684 return false 3685 } 3686 func rewriteValue386_Op386CMPLconst_10(v *Value) bool { 3687 b := v.Block 3688 _ = b 3689 // match: (CMPLconst l:(MOVLload {sym} [off] ptr mem) [c]) 3690 // cond: l.Uses == 1 && validValAndOff(c, off) && clobber(l) 3691 // result: @l.Block (CMPLconstload {sym} [makeValAndOff(c,off)] ptr mem) 3692 for { 3693 c := v.AuxInt 3694 l := v.Args[0] 3695 if l.Op != Op386MOVLload { 3696 break 3697 } 3698 off := l.AuxInt 3699 sym := l.Aux 3700 _ = l.Args[1] 3701 ptr := l.Args[0] 3702 mem := l.Args[1] 3703 if !(l.Uses == 1 && validValAndOff(c, off) && clobber(l)) { 3704 break 3705 } 3706 b = l.Block 3707 v0 := b.NewValue0(l.Pos, Op386CMPLconstload, types.TypeFlags) 3708 v.reset(OpCopy) 3709 v.AddArg(v0) 3710 v0.AuxInt = makeValAndOff(c, off) 3711 v0.Aux = sym 3712 v0.AddArg(ptr) 3713 v0.AddArg(mem) 3714 return true 3715 } 3716 return false 3717 } 3718 func rewriteValue386_Op386CMPLload_0(v *Value) bool { 3719 // match: (CMPLload {sym} [off] ptr (MOVLconst [c]) mem) 3720 // cond: validValAndOff(int64(int32(c)),off) 3721 // result: (CMPLconstload {sym} [makeValAndOff(int64(int32(c)),off)] ptr mem) 3722 for { 3723 off := v.AuxInt 3724 sym := v.Aux 3725 _ = v.Args[2] 3726 ptr := v.Args[0] 3727 v_1 := v.Args[1] 3728 if v_1.Op != Op386MOVLconst { 3729 break 3730 } 3731 c := v_1.AuxInt 3732 mem := v.Args[2] 3733 if !(validValAndOff(int64(int32(c)), off)) { 3734 break 3735 } 3736 v.reset(Op386CMPLconstload) 3737 v.AuxInt = makeValAndOff(int64(int32(c)), off) 3738 v.Aux = sym 3739 v.AddArg(ptr) 3740 v.AddArg(mem) 3741 return true 3742 } 3743 return false 3744 } 3745 func rewriteValue386_Op386CMPW_0(v *Value) bool { 3746 b := v.Block 3747 _ = b 3748 // match: (CMPW x (MOVLconst [c])) 3749 // cond: 3750 // result: (CMPWconst x [int64(int16(c))]) 3751 for { 3752 _ = v.Args[1] 3753 x := v.Args[0] 3754 v_1 := v.Args[1] 3755 if v_1.Op != Op386MOVLconst { 3756 break 3757 } 3758 c := v_1.AuxInt 3759 v.reset(Op386CMPWconst) 3760 v.AuxInt = int64(int16(c)) 3761 v.AddArg(x) 3762 return true 3763 } 3764 // match: (CMPW (MOVLconst [c]) x) 3765 // cond: 3766 // result: (InvertFlags (CMPWconst x [int64(int16(c))])) 3767 for { 3768 _ = v.Args[1] 3769 v_0 := v.Args[0] 3770 if v_0.Op != Op386MOVLconst { 3771 break 3772 } 3773 c := v_0.AuxInt 3774 x := v.Args[1] 3775 v.reset(Op386InvertFlags) 3776 v0 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags) 3777 v0.AuxInt = int64(int16(c)) 3778 v0.AddArg(x) 3779 v.AddArg(v0) 3780 return true 3781 } 3782 // match: (CMPW l:(MOVWload {sym} [off] ptr mem) x) 3783 // cond: canMergeLoad(v, l) && clobber(l) 3784 // result: (CMPWload {sym} [off] ptr x mem) 3785 for { 3786 _ = v.Args[1] 3787 l := v.Args[0] 3788 if l.Op != Op386MOVWload { 3789 break 3790 } 3791 off := l.AuxInt 3792 sym := l.Aux 3793 _ = l.Args[1] 3794 ptr := l.Args[0] 3795 mem := l.Args[1] 3796 x := v.Args[1] 3797 if !(canMergeLoad(v, l) && clobber(l)) { 3798 break 3799 } 3800 v.reset(Op386CMPWload) 3801 v.AuxInt = off 3802 v.Aux = sym 3803 v.AddArg(ptr) 3804 v.AddArg(x) 3805 v.AddArg(mem) 3806 return true 3807 } 3808 // match: (CMPW x l:(MOVWload {sym} [off] ptr mem)) 3809 // cond: canMergeLoad(v, l) && clobber(l) 3810 // result: (InvertFlags (CMPWload {sym} [off] ptr x mem)) 3811 for { 3812 _ = v.Args[1] 3813 x := v.Args[0] 3814 l := v.Args[1] 3815 if l.Op != Op386MOVWload { 3816 break 3817 } 3818 off := l.AuxInt 3819 sym := l.Aux 3820 _ = l.Args[1] 3821 ptr := l.Args[0] 3822 mem := l.Args[1] 3823 if !(canMergeLoad(v, l) && clobber(l)) { 3824 break 3825 } 3826 v.reset(Op386InvertFlags) 3827 v0 := b.NewValue0(l.Pos, Op386CMPWload, types.TypeFlags) 3828 v0.AuxInt = off 3829 v0.Aux = sym 3830 v0.AddArg(ptr) 3831 v0.AddArg(x) 3832 v0.AddArg(mem) 3833 v.AddArg(v0) 3834 return true 3835 } 3836 return false 3837 } 3838 func rewriteValue386_Op386CMPWconst_0(v *Value) bool { 3839 b := v.Block 3840 _ = b 3841 // match: (CMPWconst (MOVLconst [x]) [y]) 3842 // cond: int16(x)==int16(y) 3843 // result: (FlagEQ) 3844 for { 3845 y := v.AuxInt 3846 v_0 := v.Args[0] 3847 if v_0.Op != Op386MOVLconst { 3848 break 3849 } 3850 x := v_0.AuxInt 3851 if !(int16(x) == int16(y)) { 3852 break 3853 } 3854 v.reset(Op386FlagEQ) 3855 return true 3856 } 3857 // match: (CMPWconst (MOVLconst [x]) [y]) 3858 // cond: int16(x)<int16(y) && uint16(x)<uint16(y) 3859 // result: (FlagLT_ULT) 3860 for { 3861 y := v.AuxInt 3862 v_0 := v.Args[0] 3863 if v_0.Op != Op386MOVLconst { 3864 break 3865 } 3866 x := v_0.AuxInt 3867 if !(int16(x) < int16(y) && uint16(x) < uint16(y)) { 3868 break 3869 } 3870 v.reset(Op386FlagLT_ULT) 3871 return true 3872 } 3873 // match: (CMPWconst (MOVLconst [x]) [y]) 3874 // cond: int16(x)<int16(y) && uint16(x)>uint16(y) 3875 // result: (FlagLT_UGT) 3876 for { 3877 y := v.AuxInt 3878 v_0 := v.Args[0] 3879 if v_0.Op != Op386MOVLconst { 3880 break 3881 } 3882 x := v_0.AuxInt 3883 if !(int16(x) < int16(y) && uint16(x) > uint16(y)) { 3884 break 3885 } 3886 v.reset(Op386FlagLT_UGT) 3887 return true 3888 } 3889 // match: (CMPWconst (MOVLconst [x]) [y]) 3890 // cond: int16(x)>int16(y) && uint16(x)<uint16(y) 3891 // result: (FlagGT_ULT) 3892 for { 3893 y := v.AuxInt 3894 v_0 := v.Args[0] 3895 if v_0.Op != Op386MOVLconst { 3896 break 3897 } 3898 x := v_0.AuxInt 3899 if !(int16(x) > int16(y) && uint16(x) < uint16(y)) { 3900 break 3901 } 3902 v.reset(Op386FlagGT_ULT) 3903 return true 3904 } 3905 // match: (CMPWconst (MOVLconst [x]) [y]) 3906 // cond: int16(x)>int16(y) && uint16(x)>uint16(y) 3907 // result: (FlagGT_UGT) 3908 for { 3909 y := v.AuxInt 3910 v_0 := v.Args[0] 3911 if v_0.Op != Op386MOVLconst { 3912 break 3913 } 3914 x := v_0.AuxInt 3915 if !(int16(x) > int16(y) && uint16(x) > uint16(y)) { 3916 break 3917 } 3918 v.reset(Op386FlagGT_UGT) 3919 return true 3920 } 3921 // match: (CMPWconst (ANDLconst _ [m]) [n]) 3922 // cond: 0 <= int16(m) && int16(m) < int16(n) 3923 // result: (FlagLT_ULT) 3924 for { 3925 n := v.AuxInt 3926 v_0 := v.Args[0] 3927 if v_0.Op != Op386ANDLconst { 3928 break 3929 } 3930 m := v_0.AuxInt 3931 if !(0 <= int16(m) && int16(m) < int16(n)) { 3932 break 3933 } 3934 v.reset(Op386FlagLT_ULT) 3935 return true 3936 } 3937 // match: (CMPWconst l:(ANDL x y) [0]) 3938 // cond: l.Uses==1 3939 // result: (TESTW x y) 3940 for { 3941 if v.AuxInt != 0 { 3942 break 3943 } 3944 l := v.Args[0] 3945 if l.Op != Op386ANDL { 3946 break 3947 } 3948 _ = l.Args[1] 3949 x := l.Args[0] 3950 y := l.Args[1] 3951 if !(l.Uses == 1) { 3952 break 3953 } 3954 v.reset(Op386TESTW) 3955 v.AddArg(x) 3956 v.AddArg(y) 3957 return true 3958 } 3959 // match: (CMPWconst l:(ANDLconst [c] x) [0]) 3960 // cond: l.Uses==1 3961 // result: (TESTWconst [int64(int16(c))] x) 3962 for { 3963 if v.AuxInt != 0 { 3964 break 3965 } 3966 l := v.Args[0] 3967 if l.Op != Op386ANDLconst { 3968 break 3969 } 3970 c := l.AuxInt 3971 x := l.Args[0] 3972 if !(l.Uses == 1) { 3973 break 3974 } 3975 v.reset(Op386TESTWconst) 3976 v.AuxInt = int64(int16(c)) 3977 v.AddArg(x) 3978 return true 3979 } 3980 // match: (CMPWconst x [0]) 3981 // cond: 3982 // result: (TESTW x x) 3983 for { 3984 if v.AuxInt != 0 { 3985 break 3986 } 3987 x := v.Args[0] 3988 v.reset(Op386TESTW) 3989 v.AddArg(x) 3990 v.AddArg(x) 3991 return true 3992 } 3993 // match: (CMPWconst l:(MOVWload {sym} [off] ptr mem) [c]) 3994 // cond: l.Uses == 1 && validValAndOff(c, off) && clobber(l) 3995 // result: @l.Block (CMPWconstload {sym} [makeValAndOff(c,off)] ptr mem) 3996 for { 3997 c := v.AuxInt 3998 l := v.Args[0] 3999 if l.Op != Op386MOVWload { 4000 break 4001 } 4002 off := l.AuxInt 4003 sym := l.Aux 4004 _ = l.Args[1] 4005 ptr := l.Args[0] 4006 mem := l.Args[1] 4007 if !(l.Uses == 1 && validValAndOff(c, off) && clobber(l)) { 4008 break 4009 } 4010 b = l.Block 4011 v0 := b.NewValue0(l.Pos, Op386CMPWconstload, types.TypeFlags) 4012 v.reset(OpCopy) 4013 v.AddArg(v0) 4014 v0.AuxInt = makeValAndOff(c, off) 4015 v0.Aux = sym 4016 v0.AddArg(ptr) 4017 v0.AddArg(mem) 4018 return true 4019 } 4020 return false 4021 } 4022 func rewriteValue386_Op386CMPWload_0(v *Value) bool { 4023 // match: (CMPWload {sym} [off] ptr (MOVLconst [c]) mem) 4024 // cond: validValAndOff(int64(int16(c)),off) 4025 // result: (CMPWconstload {sym} [makeValAndOff(int64(int16(c)),off)] ptr mem) 4026 for { 4027 off := v.AuxInt 4028 sym := v.Aux 4029 _ = v.Args[2] 4030 ptr := v.Args[0] 4031 v_1 := v.Args[1] 4032 if v_1.Op != Op386MOVLconst { 4033 break 4034 } 4035 c := v_1.AuxInt 4036 mem := v.Args[2] 4037 if !(validValAndOff(int64(int16(c)), off)) { 4038 break 4039 } 4040 v.reset(Op386CMPWconstload) 4041 v.AuxInt = makeValAndOff(int64(int16(c)), off) 4042 v.Aux = sym 4043 v.AddArg(ptr) 4044 v.AddArg(mem) 4045 return true 4046 } 4047 return false 4048 } 4049 func rewriteValue386_Op386DIVSD_0(v *Value) bool { 4050 b := v.Block 4051 _ = b 4052 config := b.Func.Config 4053 _ = config 4054 // match: (DIVSD x l:(MOVSDload [off] {sym} ptr mem)) 4055 // cond: canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l) 4056 // result: (DIVSDload x [off] {sym} ptr mem) 4057 for { 4058 _ = v.Args[1] 4059 x := v.Args[0] 4060 l := v.Args[1] 4061 if l.Op != Op386MOVSDload { 4062 break 4063 } 4064 off := l.AuxInt 4065 sym := l.Aux 4066 _ = l.Args[1] 4067 ptr := l.Args[0] 4068 mem := l.Args[1] 4069 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) { 4070 break 4071 } 4072 v.reset(Op386DIVSDload) 4073 v.AuxInt = off 4074 v.Aux = sym 4075 v.AddArg(x) 4076 v.AddArg(ptr) 4077 v.AddArg(mem) 4078 return true 4079 } 4080 return false 4081 } 4082 func rewriteValue386_Op386DIVSDload_0(v *Value) bool { 4083 b := v.Block 4084 _ = b 4085 config := b.Func.Config 4086 _ = config 4087 // match: (DIVSDload [off1] {sym} val (ADDLconst [off2] base) mem) 4088 // cond: is32Bit(off1+off2) 4089 // result: (DIVSDload [off1+off2] {sym} val base mem) 4090 for { 4091 off1 := v.AuxInt 4092 sym := v.Aux 4093 _ = v.Args[2] 4094 val := v.Args[0] 4095 v_1 := v.Args[1] 4096 if v_1.Op != Op386ADDLconst { 4097 break 4098 } 4099 off2 := v_1.AuxInt 4100 base := v_1.Args[0] 4101 mem := v.Args[2] 4102 if !(is32Bit(off1 + off2)) { 4103 break 4104 } 4105 v.reset(Op386DIVSDload) 4106 v.AuxInt = off1 + off2 4107 v.Aux = sym 4108 v.AddArg(val) 4109 v.AddArg(base) 4110 v.AddArg(mem) 4111 return true 4112 } 4113 // match: (DIVSDload [off1] {sym1} val (LEAL [off2] {sym2} base) mem) 4114 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 4115 // result: (DIVSDload [off1+off2] {mergeSym(sym1,sym2)} val base mem) 4116 for { 4117 off1 := v.AuxInt 4118 sym1 := v.Aux 4119 _ = v.Args[2] 4120 val := v.Args[0] 4121 v_1 := v.Args[1] 4122 if v_1.Op != Op386LEAL { 4123 break 4124 } 4125 off2 := v_1.AuxInt 4126 sym2 := v_1.Aux 4127 base := v_1.Args[0] 4128 mem := v.Args[2] 4129 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 4130 break 4131 } 4132 v.reset(Op386DIVSDload) 4133 v.AuxInt = off1 + off2 4134 v.Aux = mergeSym(sym1, sym2) 4135 v.AddArg(val) 4136 v.AddArg(base) 4137 v.AddArg(mem) 4138 return true 4139 } 4140 return false 4141 } 4142 func rewriteValue386_Op386DIVSS_0(v *Value) bool { 4143 b := v.Block 4144 _ = b 4145 config := b.Func.Config 4146 _ = config 4147 // match: (DIVSS x l:(MOVSSload [off] {sym} ptr mem)) 4148 // cond: canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l) 4149 // result: (DIVSSload x [off] {sym} ptr mem) 4150 for { 4151 _ = v.Args[1] 4152 x := v.Args[0] 4153 l := v.Args[1] 4154 if l.Op != Op386MOVSSload { 4155 break 4156 } 4157 off := l.AuxInt 4158 sym := l.Aux 4159 _ = l.Args[1] 4160 ptr := l.Args[0] 4161 mem := l.Args[1] 4162 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) { 4163 break 4164 } 4165 v.reset(Op386DIVSSload) 4166 v.AuxInt = off 4167 v.Aux = sym 4168 v.AddArg(x) 4169 v.AddArg(ptr) 4170 v.AddArg(mem) 4171 return true 4172 } 4173 return false 4174 } 4175 func rewriteValue386_Op386DIVSSload_0(v *Value) bool { 4176 b := v.Block 4177 _ = b 4178 config := b.Func.Config 4179 _ = config 4180 // match: (DIVSSload [off1] {sym} val (ADDLconst [off2] base) mem) 4181 // cond: is32Bit(off1+off2) 4182 // result: (DIVSSload [off1+off2] {sym} val base mem) 4183 for { 4184 off1 := v.AuxInt 4185 sym := v.Aux 4186 _ = v.Args[2] 4187 val := v.Args[0] 4188 v_1 := v.Args[1] 4189 if v_1.Op != Op386ADDLconst { 4190 break 4191 } 4192 off2 := v_1.AuxInt 4193 base := v_1.Args[0] 4194 mem := v.Args[2] 4195 if !(is32Bit(off1 + off2)) { 4196 break 4197 } 4198 v.reset(Op386DIVSSload) 4199 v.AuxInt = off1 + off2 4200 v.Aux = sym 4201 v.AddArg(val) 4202 v.AddArg(base) 4203 v.AddArg(mem) 4204 return true 4205 } 4206 // match: (DIVSSload [off1] {sym1} val (LEAL [off2] {sym2} base) mem) 4207 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 4208 // result: (DIVSSload [off1+off2] {mergeSym(sym1,sym2)} val base mem) 4209 for { 4210 off1 := v.AuxInt 4211 sym1 := v.Aux 4212 _ = v.Args[2] 4213 val := v.Args[0] 4214 v_1 := v.Args[1] 4215 if v_1.Op != Op386LEAL { 4216 break 4217 } 4218 off2 := v_1.AuxInt 4219 sym2 := v_1.Aux 4220 base := v_1.Args[0] 4221 mem := v.Args[2] 4222 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 4223 break 4224 } 4225 v.reset(Op386DIVSSload) 4226 v.AuxInt = off1 + off2 4227 v.Aux = mergeSym(sym1, sym2) 4228 v.AddArg(val) 4229 v.AddArg(base) 4230 v.AddArg(mem) 4231 return true 4232 } 4233 return false 4234 } 4235 func rewriteValue386_Op386LEAL_0(v *Value) bool { 4236 // match: (LEAL [c] {s} (ADDLconst [d] x)) 4237 // cond: is32Bit(c+d) 4238 // result: (LEAL [c+d] {s} x) 4239 for { 4240 c := v.AuxInt 4241 s := v.Aux 4242 v_0 := v.Args[0] 4243 if v_0.Op != Op386ADDLconst { 4244 break 4245 } 4246 d := v_0.AuxInt 4247 x := v_0.Args[0] 4248 if !(is32Bit(c + d)) { 4249 break 4250 } 4251 v.reset(Op386LEAL) 4252 v.AuxInt = c + d 4253 v.Aux = s 4254 v.AddArg(x) 4255 return true 4256 } 4257 // match: (LEAL [c] {s} (ADDL x y)) 4258 // cond: x.Op != OpSB && y.Op != OpSB 4259 // result: (LEAL1 [c] {s} x y) 4260 for { 4261 c := v.AuxInt 4262 s := v.Aux 4263 v_0 := v.Args[0] 4264 if v_0.Op != Op386ADDL { 4265 break 4266 } 4267 _ = v_0.Args[1] 4268 x := v_0.Args[0] 4269 y := v_0.Args[1] 4270 if !(x.Op != OpSB && y.Op != OpSB) { 4271 break 4272 } 4273 v.reset(Op386LEAL1) 4274 v.AuxInt = c 4275 v.Aux = s 4276 v.AddArg(x) 4277 v.AddArg(y) 4278 return true 4279 } 4280 // match: (LEAL [off1] {sym1} (LEAL [off2] {sym2} x)) 4281 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 4282 // result: (LEAL [off1+off2] {mergeSym(sym1,sym2)} x) 4283 for { 4284 off1 := v.AuxInt 4285 sym1 := v.Aux 4286 v_0 := v.Args[0] 4287 if v_0.Op != Op386LEAL { 4288 break 4289 } 4290 off2 := v_0.AuxInt 4291 sym2 := v_0.Aux 4292 x := v_0.Args[0] 4293 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 4294 break 4295 } 4296 v.reset(Op386LEAL) 4297 v.AuxInt = off1 + off2 4298 v.Aux = mergeSym(sym1, sym2) 4299 v.AddArg(x) 4300 return true 4301 } 4302 // match: (LEAL [off1] {sym1} (LEAL1 [off2] {sym2} x y)) 4303 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 4304 // result: (LEAL1 [off1+off2] {mergeSym(sym1,sym2)} x y) 4305 for { 4306 off1 := v.AuxInt 4307 sym1 := v.Aux 4308 v_0 := v.Args[0] 4309 if v_0.Op != Op386LEAL1 { 4310 break 4311 } 4312 off2 := v_0.AuxInt 4313 sym2 := v_0.Aux 4314 _ = v_0.Args[1] 4315 x := v_0.Args[0] 4316 y := v_0.Args[1] 4317 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 4318 break 4319 } 4320 v.reset(Op386LEAL1) 4321 v.AuxInt = off1 + off2 4322 v.Aux = mergeSym(sym1, sym2) 4323 v.AddArg(x) 4324 v.AddArg(y) 4325 return true 4326 } 4327 // match: (LEAL [off1] {sym1} (LEAL2 [off2] {sym2} x y)) 4328 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 4329 // result: (LEAL2 [off1+off2] {mergeSym(sym1,sym2)} x y) 4330 for { 4331 off1 := v.AuxInt 4332 sym1 := v.Aux 4333 v_0 := v.Args[0] 4334 if v_0.Op != Op386LEAL2 { 4335 break 4336 } 4337 off2 := v_0.AuxInt 4338 sym2 := v_0.Aux 4339 _ = v_0.Args[1] 4340 x := v_0.Args[0] 4341 y := v_0.Args[1] 4342 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 4343 break 4344 } 4345 v.reset(Op386LEAL2) 4346 v.AuxInt = off1 + off2 4347 v.Aux = mergeSym(sym1, sym2) 4348 v.AddArg(x) 4349 v.AddArg(y) 4350 return true 4351 } 4352 // match: (LEAL [off1] {sym1} (LEAL4 [off2] {sym2} x y)) 4353 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 4354 // result: (LEAL4 [off1+off2] {mergeSym(sym1,sym2)} x y) 4355 for { 4356 off1 := v.AuxInt 4357 sym1 := v.Aux 4358 v_0 := v.Args[0] 4359 if v_0.Op != Op386LEAL4 { 4360 break 4361 } 4362 off2 := v_0.AuxInt 4363 sym2 := v_0.Aux 4364 _ = v_0.Args[1] 4365 x := v_0.Args[0] 4366 y := v_0.Args[1] 4367 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 4368 break 4369 } 4370 v.reset(Op386LEAL4) 4371 v.AuxInt = off1 + off2 4372 v.Aux = mergeSym(sym1, sym2) 4373 v.AddArg(x) 4374 v.AddArg(y) 4375 return true 4376 } 4377 // match: (LEAL [off1] {sym1} (LEAL8 [off2] {sym2} x y)) 4378 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 4379 // result: (LEAL8 [off1+off2] {mergeSym(sym1,sym2)} x y) 4380 for { 4381 off1 := v.AuxInt 4382 sym1 := v.Aux 4383 v_0 := v.Args[0] 4384 if v_0.Op != Op386LEAL8 { 4385 break 4386 } 4387 off2 := v_0.AuxInt 4388 sym2 := v_0.Aux 4389 _ = v_0.Args[1] 4390 x := v_0.Args[0] 4391 y := v_0.Args[1] 4392 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 4393 break 4394 } 4395 v.reset(Op386LEAL8) 4396 v.AuxInt = off1 + off2 4397 v.Aux = mergeSym(sym1, sym2) 4398 v.AddArg(x) 4399 v.AddArg(y) 4400 return true 4401 } 4402 return false 4403 } 4404 func rewriteValue386_Op386LEAL1_0(v *Value) bool { 4405 // match: (LEAL1 [c] {s} (ADDLconst [d] x) y) 4406 // cond: is32Bit(c+d) && x.Op != OpSB 4407 // result: (LEAL1 [c+d] {s} x y) 4408 for { 4409 c := v.AuxInt 4410 s := v.Aux 4411 _ = v.Args[1] 4412 v_0 := v.Args[0] 4413 if v_0.Op != Op386ADDLconst { 4414 break 4415 } 4416 d := v_0.AuxInt 4417 x := v_0.Args[0] 4418 y := v.Args[1] 4419 if !(is32Bit(c+d) && x.Op != OpSB) { 4420 break 4421 } 4422 v.reset(Op386LEAL1) 4423 v.AuxInt = c + d 4424 v.Aux = s 4425 v.AddArg(x) 4426 v.AddArg(y) 4427 return true 4428 } 4429 // match: (LEAL1 [c] {s} y (ADDLconst [d] x)) 4430 // cond: is32Bit(c+d) && x.Op != OpSB 4431 // result: (LEAL1 [c+d] {s} x y) 4432 for { 4433 c := v.AuxInt 4434 s := v.Aux 4435 _ = v.Args[1] 4436 y := v.Args[0] 4437 v_1 := v.Args[1] 4438 if v_1.Op != Op386ADDLconst { 4439 break 4440 } 4441 d := v_1.AuxInt 4442 x := v_1.Args[0] 4443 if !(is32Bit(c+d) && x.Op != OpSB) { 4444 break 4445 } 4446 v.reset(Op386LEAL1) 4447 v.AuxInt = c + d 4448 v.Aux = s 4449 v.AddArg(x) 4450 v.AddArg(y) 4451 return true 4452 } 4453 // match: (LEAL1 [c] {s} x (SHLLconst [1] y)) 4454 // cond: 4455 // result: (LEAL2 [c] {s} x y) 4456 for { 4457 c := v.AuxInt 4458 s := v.Aux 4459 _ = v.Args[1] 4460 x := v.Args[0] 4461 v_1 := v.Args[1] 4462 if v_1.Op != Op386SHLLconst { 4463 break 4464 } 4465 if v_1.AuxInt != 1 { 4466 break 4467 } 4468 y := v_1.Args[0] 4469 v.reset(Op386LEAL2) 4470 v.AuxInt = c 4471 v.Aux = s 4472 v.AddArg(x) 4473 v.AddArg(y) 4474 return true 4475 } 4476 // match: (LEAL1 [c] {s} (SHLLconst [1] y) x) 4477 // cond: 4478 // result: (LEAL2 [c] {s} x y) 4479 for { 4480 c := v.AuxInt 4481 s := v.Aux 4482 _ = v.Args[1] 4483 v_0 := v.Args[0] 4484 if v_0.Op != Op386SHLLconst { 4485 break 4486 } 4487 if v_0.AuxInt != 1 { 4488 break 4489 } 4490 y := v_0.Args[0] 4491 x := v.Args[1] 4492 v.reset(Op386LEAL2) 4493 v.AuxInt = c 4494 v.Aux = s 4495 v.AddArg(x) 4496 v.AddArg(y) 4497 return true 4498 } 4499 // match: (LEAL1 [c] {s} x (SHLLconst [2] y)) 4500 // cond: 4501 // result: (LEAL4 [c] {s} x y) 4502 for { 4503 c := v.AuxInt 4504 s := v.Aux 4505 _ = v.Args[1] 4506 x := v.Args[0] 4507 v_1 := v.Args[1] 4508 if v_1.Op != Op386SHLLconst { 4509 break 4510 } 4511 if v_1.AuxInt != 2 { 4512 break 4513 } 4514 y := v_1.Args[0] 4515 v.reset(Op386LEAL4) 4516 v.AuxInt = c 4517 v.Aux = s 4518 v.AddArg(x) 4519 v.AddArg(y) 4520 return true 4521 } 4522 // match: (LEAL1 [c] {s} (SHLLconst [2] y) x) 4523 // cond: 4524 // result: (LEAL4 [c] {s} x y) 4525 for { 4526 c := v.AuxInt 4527 s := v.Aux 4528 _ = v.Args[1] 4529 v_0 := v.Args[0] 4530 if v_0.Op != Op386SHLLconst { 4531 break 4532 } 4533 if v_0.AuxInt != 2 { 4534 break 4535 } 4536 y := v_0.Args[0] 4537 x := v.Args[1] 4538 v.reset(Op386LEAL4) 4539 v.AuxInt = c 4540 v.Aux = s 4541 v.AddArg(x) 4542 v.AddArg(y) 4543 return true 4544 } 4545 // match: (LEAL1 [c] {s} x (SHLLconst [3] y)) 4546 // cond: 4547 // result: (LEAL8 [c] {s} x y) 4548 for { 4549 c := v.AuxInt 4550 s := v.Aux 4551 _ = v.Args[1] 4552 x := v.Args[0] 4553 v_1 := v.Args[1] 4554 if v_1.Op != Op386SHLLconst { 4555 break 4556 } 4557 if v_1.AuxInt != 3 { 4558 break 4559 } 4560 y := v_1.Args[0] 4561 v.reset(Op386LEAL8) 4562 v.AuxInt = c 4563 v.Aux = s 4564 v.AddArg(x) 4565 v.AddArg(y) 4566 return true 4567 } 4568 // match: (LEAL1 [c] {s} (SHLLconst [3] y) x) 4569 // cond: 4570 // result: (LEAL8 [c] {s} x y) 4571 for { 4572 c := v.AuxInt 4573 s := v.Aux 4574 _ = v.Args[1] 4575 v_0 := v.Args[0] 4576 if v_0.Op != Op386SHLLconst { 4577 break 4578 } 4579 if v_0.AuxInt != 3 { 4580 break 4581 } 4582 y := v_0.Args[0] 4583 x := v.Args[1] 4584 v.reset(Op386LEAL8) 4585 v.AuxInt = c 4586 v.Aux = s 4587 v.AddArg(x) 4588 v.AddArg(y) 4589 return true 4590 } 4591 // match: (LEAL1 [off1] {sym1} (LEAL [off2] {sym2} x) y) 4592 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB 4593 // result: (LEAL1 [off1+off2] {mergeSym(sym1,sym2)} x y) 4594 for { 4595 off1 := v.AuxInt 4596 sym1 := v.Aux 4597 _ = v.Args[1] 4598 v_0 := v.Args[0] 4599 if v_0.Op != Op386LEAL { 4600 break 4601 } 4602 off2 := v_0.AuxInt 4603 sym2 := v_0.Aux 4604 x := v_0.Args[0] 4605 y := v.Args[1] 4606 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) { 4607 break 4608 } 4609 v.reset(Op386LEAL1) 4610 v.AuxInt = off1 + off2 4611 v.Aux = mergeSym(sym1, sym2) 4612 v.AddArg(x) 4613 v.AddArg(y) 4614 return true 4615 } 4616 // match: (LEAL1 [off1] {sym1} y (LEAL [off2] {sym2} x)) 4617 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB 4618 // result: (LEAL1 [off1+off2] {mergeSym(sym1,sym2)} x y) 4619 for { 4620 off1 := v.AuxInt 4621 sym1 := v.Aux 4622 _ = v.Args[1] 4623 y := v.Args[0] 4624 v_1 := v.Args[1] 4625 if v_1.Op != Op386LEAL { 4626 break 4627 } 4628 off2 := v_1.AuxInt 4629 sym2 := v_1.Aux 4630 x := v_1.Args[0] 4631 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) { 4632 break 4633 } 4634 v.reset(Op386LEAL1) 4635 v.AuxInt = off1 + off2 4636 v.Aux = mergeSym(sym1, sym2) 4637 v.AddArg(x) 4638 v.AddArg(y) 4639 return true 4640 } 4641 return false 4642 } 4643 func rewriteValue386_Op386LEAL2_0(v *Value) bool { 4644 // match: (LEAL2 [c] {s} (ADDLconst [d] x) y) 4645 // cond: is32Bit(c+d) && x.Op != OpSB 4646 // result: (LEAL2 [c+d] {s} x y) 4647 for { 4648 c := v.AuxInt 4649 s := v.Aux 4650 _ = v.Args[1] 4651 v_0 := v.Args[0] 4652 if v_0.Op != Op386ADDLconst { 4653 break 4654 } 4655 d := v_0.AuxInt 4656 x := v_0.Args[0] 4657 y := v.Args[1] 4658 if !(is32Bit(c+d) && x.Op != OpSB) { 4659 break 4660 } 4661 v.reset(Op386LEAL2) 4662 v.AuxInt = c + d 4663 v.Aux = s 4664 v.AddArg(x) 4665 v.AddArg(y) 4666 return true 4667 } 4668 // match: (LEAL2 [c] {s} x (ADDLconst [d] y)) 4669 // cond: is32Bit(c+2*d) && y.Op != OpSB 4670 // result: (LEAL2 [c+2*d] {s} x y) 4671 for { 4672 c := v.AuxInt 4673 s := v.Aux 4674 _ = v.Args[1] 4675 x := v.Args[0] 4676 v_1 := v.Args[1] 4677 if v_1.Op != Op386ADDLconst { 4678 break 4679 } 4680 d := v_1.AuxInt 4681 y := v_1.Args[0] 4682 if !(is32Bit(c+2*d) && y.Op != OpSB) { 4683 break 4684 } 4685 v.reset(Op386LEAL2) 4686 v.AuxInt = c + 2*d 4687 v.Aux = s 4688 v.AddArg(x) 4689 v.AddArg(y) 4690 return true 4691 } 4692 // match: (LEAL2 [c] {s} x (SHLLconst [1] y)) 4693 // cond: 4694 // result: (LEAL4 [c] {s} x y) 4695 for { 4696 c := v.AuxInt 4697 s := v.Aux 4698 _ = v.Args[1] 4699 x := v.Args[0] 4700 v_1 := v.Args[1] 4701 if v_1.Op != Op386SHLLconst { 4702 break 4703 } 4704 if v_1.AuxInt != 1 { 4705 break 4706 } 4707 y := v_1.Args[0] 4708 v.reset(Op386LEAL4) 4709 v.AuxInt = c 4710 v.Aux = s 4711 v.AddArg(x) 4712 v.AddArg(y) 4713 return true 4714 } 4715 // match: (LEAL2 [c] {s} x (SHLLconst [2] y)) 4716 // cond: 4717 // result: (LEAL8 [c] {s} x y) 4718 for { 4719 c := v.AuxInt 4720 s := v.Aux 4721 _ = v.Args[1] 4722 x := v.Args[0] 4723 v_1 := v.Args[1] 4724 if v_1.Op != Op386SHLLconst { 4725 break 4726 } 4727 if v_1.AuxInt != 2 { 4728 break 4729 } 4730 y := v_1.Args[0] 4731 v.reset(Op386LEAL8) 4732 v.AuxInt = c 4733 v.Aux = s 4734 v.AddArg(x) 4735 v.AddArg(y) 4736 return true 4737 } 4738 // match: (LEAL2 [off1] {sym1} (LEAL [off2] {sym2} x) y) 4739 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB 4740 // result: (LEAL2 [off1+off2] {mergeSym(sym1,sym2)} x y) 4741 for { 4742 off1 := v.AuxInt 4743 sym1 := v.Aux 4744 _ = v.Args[1] 4745 v_0 := v.Args[0] 4746 if v_0.Op != Op386LEAL { 4747 break 4748 } 4749 off2 := v_0.AuxInt 4750 sym2 := v_0.Aux 4751 x := v_0.Args[0] 4752 y := v.Args[1] 4753 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) { 4754 break 4755 } 4756 v.reset(Op386LEAL2) 4757 v.AuxInt = off1 + off2 4758 v.Aux = mergeSym(sym1, sym2) 4759 v.AddArg(x) 4760 v.AddArg(y) 4761 return true 4762 } 4763 return false 4764 } 4765 func rewriteValue386_Op386LEAL4_0(v *Value) bool { 4766 // match: (LEAL4 [c] {s} (ADDLconst [d] x) y) 4767 // cond: is32Bit(c+d) && x.Op != OpSB 4768 // result: (LEAL4 [c+d] {s} x y) 4769 for { 4770 c := v.AuxInt 4771 s := v.Aux 4772 _ = v.Args[1] 4773 v_0 := v.Args[0] 4774 if v_0.Op != Op386ADDLconst { 4775 break 4776 } 4777 d := v_0.AuxInt 4778 x := v_0.Args[0] 4779 y := v.Args[1] 4780 if !(is32Bit(c+d) && x.Op != OpSB) { 4781 break 4782 } 4783 v.reset(Op386LEAL4) 4784 v.AuxInt = c + d 4785 v.Aux = s 4786 v.AddArg(x) 4787 v.AddArg(y) 4788 return true 4789 } 4790 // match: (LEAL4 [c] {s} x (ADDLconst [d] y)) 4791 // cond: is32Bit(c+4*d) && y.Op != OpSB 4792 // result: (LEAL4 [c+4*d] {s} x y) 4793 for { 4794 c := v.AuxInt 4795 s := v.Aux 4796 _ = v.Args[1] 4797 x := v.Args[0] 4798 v_1 := v.Args[1] 4799 if v_1.Op != Op386ADDLconst { 4800 break 4801 } 4802 d := v_1.AuxInt 4803 y := v_1.Args[0] 4804 if !(is32Bit(c+4*d) && y.Op != OpSB) { 4805 break 4806 } 4807 v.reset(Op386LEAL4) 4808 v.AuxInt = c + 4*d 4809 v.Aux = s 4810 v.AddArg(x) 4811 v.AddArg(y) 4812 return true 4813 } 4814 // match: (LEAL4 [c] {s} x (SHLLconst [1] y)) 4815 // cond: 4816 // result: (LEAL8 [c] {s} x y) 4817 for { 4818 c := v.AuxInt 4819 s := v.Aux 4820 _ = v.Args[1] 4821 x := v.Args[0] 4822 v_1 := v.Args[1] 4823 if v_1.Op != Op386SHLLconst { 4824 break 4825 } 4826 if v_1.AuxInt != 1 { 4827 break 4828 } 4829 y := v_1.Args[0] 4830 v.reset(Op386LEAL8) 4831 v.AuxInt = c 4832 v.Aux = s 4833 v.AddArg(x) 4834 v.AddArg(y) 4835 return true 4836 } 4837 // match: (LEAL4 [off1] {sym1} (LEAL [off2] {sym2} x) y) 4838 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB 4839 // result: (LEAL4 [off1+off2] {mergeSym(sym1,sym2)} x y) 4840 for { 4841 off1 := v.AuxInt 4842 sym1 := v.Aux 4843 _ = v.Args[1] 4844 v_0 := v.Args[0] 4845 if v_0.Op != Op386LEAL { 4846 break 4847 } 4848 off2 := v_0.AuxInt 4849 sym2 := v_0.Aux 4850 x := v_0.Args[0] 4851 y := v.Args[1] 4852 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) { 4853 break 4854 } 4855 v.reset(Op386LEAL4) 4856 v.AuxInt = off1 + off2 4857 v.Aux = mergeSym(sym1, sym2) 4858 v.AddArg(x) 4859 v.AddArg(y) 4860 return true 4861 } 4862 return false 4863 } 4864 func rewriteValue386_Op386LEAL8_0(v *Value) bool { 4865 // match: (LEAL8 [c] {s} (ADDLconst [d] x) y) 4866 // cond: is32Bit(c+d) && x.Op != OpSB 4867 // result: (LEAL8 [c+d] {s} x y) 4868 for { 4869 c := v.AuxInt 4870 s := v.Aux 4871 _ = v.Args[1] 4872 v_0 := v.Args[0] 4873 if v_0.Op != Op386ADDLconst { 4874 break 4875 } 4876 d := v_0.AuxInt 4877 x := v_0.Args[0] 4878 y := v.Args[1] 4879 if !(is32Bit(c+d) && x.Op != OpSB) { 4880 break 4881 } 4882 v.reset(Op386LEAL8) 4883 v.AuxInt = c + d 4884 v.Aux = s 4885 v.AddArg(x) 4886 v.AddArg(y) 4887 return true 4888 } 4889 // match: (LEAL8 [c] {s} x (ADDLconst [d] y)) 4890 // cond: is32Bit(c+8*d) && y.Op != OpSB 4891 // result: (LEAL8 [c+8*d] {s} x y) 4892 for { 4893 c := v.AuxInt 4894 s := v.Aux 4895 _ = v.Args[1] 4896 x := v.Args[0] 4897 v_1 := v.Args[1] 4898 if v_1.Op != Op386ADDLconst { 4899 break 4900 } 4901 d := v_1.AuxInt 4902 y := v_1.Args[0] 4903 if !(is32Bit(c+8*d) && y.Op != OpSB) { 4904 break 4905 } 4906 v.reset(Op386LEAL8) 4907 v.AuxInt = c + 8*d 4908 v.Aux = s 4909 v.AddArg(x) 4910 v.AddArg(y) 4911 return true 4912 } 4913 // match: (LEAL8 [off1] {sym1} (LEAL [off2] {sym2} x) y) 4914 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB 4915 // result: (LEAL8 [off1+off2] {mergeSym(sym1,sym2)} x y) 4916 for { 4917 off1 := v.AuxInt 4918 sym1 := v.Aux 4919 _ = v.Args[1] 4920 v_0 := v.Args[0] 4921 if v_0.Op != Op386LEAL { 4922 break 4923 } 4924 off2 := v_0.AuxInt 4925 sym2 := v_0.Aux 4926 x := v_0.Args[0] 4927 y := v.Args[1] 4928 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) { 4929 break 4930 } 4931 v.reset(Op386LEAL8) 4932 v.AuxInt = off1 + off2 4933 v.Aux = mergeSym(sym1, sym2) 4934 v.AddArg(x) 4935 v.AddArg(y) 4936 return true 4937 } 4938 return false 4939 } 4940 func rewriteValue386_Op386MOVBLSX_0(v *Value) bool { 4941 b := v.Block 4942 _ = b 4943 // match: (MOVBLSX x:(MOVBload [off] {sym} ptr mem)) 4944 // cond: x.Uses == 1 && clobber(x) 4945 // result: @x.Block (MOVBLSXload <v.Type> [off] {sym} ptr mem) 4946 for { 4947 x := v.Args[0] 4948 if x.Op != Op386MOVBload { 4949 break 4950 } 4951 off := x.AuxInt 4952 sym := x.Aux 4953 _ = x.Args[1] 4954 ptr := x.Args[0] 4955 mem := x.Args[1] 4956 if !(x.Uses == 1 && clobber(x)) { 4957 break 4958 } 4959 b = x.Block 4960 v0 := b.NewValue0(x.Pos, Op386MOVBLSXload, v.Type) 4961 v.reset(OpCopy) 4962 v.AddArg(v0) 4963 v0.AuxInt = off 4964 v0.Aux = sym 4965 v0.AddArg(ptr) 4966 v0.AddArg(mem) 4967 return true 4968 } 4969 // match: (MOVBLSX (ANDLconst [c] x)) 4970 // cond: c & 0x80 == 0 4971 // result: (ANDLconst [c & 0x7f] x) 4972 for { 4973 v_0 := v.Args[0] 4974 if v_0.Op != Op386ANDLconst { 4975 break 4976 } 4977 c := v_0.AuxInt 4978 x := v_0.Args[0] 4979 if !(c&0x80 == 0) { 4980 break 4981 } 4982 v.reset(Op386ANDLconst) 4983 v.AuxInt = c & 0x7f 4984 v.AddArg(x) 4985 return true 4986 } 4987 return false 4988 } 4989 func rewriteValue386_Op386MOVBLSXload_0(v *Value) bool { 4990 b := v.Block 4991 _ = b 4992 config := b.Func.Config 4993 _ = config 4994 // match: (MOVBLSXload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _)) 4995 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 4996 // result: (MOVBLSX x) 4997 for { 4998 off := v.AuxInt 4999 sym := v.Aux 5000 _ = v.Args[1] 5001 ptr := v.Args[0] 5002 v_1 := v.Args[1] 5003 if v_1.Op != Op386MOVBstore { 5004 break 5005 } 5006 off2 := v_1.AuxInt 5007 sym2 := v_1.Aux 5008 _ = v_1.Args[2] 5009 ptr2 := v_1.Args[0] 5010 x := v_1.Args[1] 5011 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 5012 break 5013 } 5014 v.reset(Op386MOVBLSX) 5015 v.AddArg(x) 5016 return true 5017 } 5018 // match: (MOVBLSXload [off1] {sym1} (LEAL [off2] {sym2} base) mem) 5019 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 5020 // result: (MOVBLSXload [off1+off2] {mergeSym(sym1,sym2)} base mem) 5021 for { 5022 off1 := v.AuxInt 5023 sym1 := v.Aux 5024 _ = v.Args[1] 5025 v_0 := v.Args[0] 5026 if v_0.Op != Op386LEAL { 5027 break 5028 } 5029 off2 := v_0.AuxInt 5030 sym2 := v_0.Aux 5031 base := v_0.Args[0] 5032 mem := v.Args[1] 5033 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 5034 break 5035 } 5036 v.reset(Op386MOVBLSXload) 5037 v.AuxInt = off1 + off2 5038 v.Aux = mergeSym(sym1, sym2) 5039 v.AddArg(base) 5040 v.AddArg(mem) 5041 return true 5042 } 5043 return false 5044 } 5045 func rewriteValue386_Op386MOVBLZX_0(v *Value) bool { 5046 b := v.Block 5047 _ = b 5048 // match: (MOVBLZX x:(MOVBload [off] {sym} ptr mem)) 5049 // cond: x.Uses == 1 && clobber(x) 5050 // result: @x.Block (MOVBload <v.Type> [off] {sym} ptr mem) 5051 for { 5052 x := v.Args[0] 5053 if x.Op != Op386MOVBload { 5054 break 5055 } 5056 off := x.AuxInt 5057 sym := x.Aux 5058 _ = x.Args[1] 5059 ptr := x.Args[0] 5060 mem := x.Args[1] 5061 if !(x.Uses == 1 && clobber(x)) { 5062 break 5063 } 5064 b = x.Block 5065 v0 := b.NewValue0(x.Pos, Op386MOVBload, v.Type) 5066 v.reset(OpCopy) 5067 v.AddArg(v0) 5068 v0.AuxInt = off 5069 v0.Aux = sym 5070 v0.AddArg(ptr) 5071 v0.AddArg(mem) 5072 return true 5073 } 5074 // match: (MOVBLZX x:(MOVBloadidx1 [off] {sym} ptr idx mem)) 5075 // cond: x.Uses == 1 && clobber(x) 5076 // result: @x.Block (MOVBloadidx1 <v.Type> [off] {sym} ptr idx mem) 5077 for { 5078 x := v.Args[0] 5079 if x.Op != Op386MOVBloadidx1 { 5080 break 5081 } 5082 off := x.AuxInt 5083 sym := x.Aux 5084 _ = x.Args[2] 5085 ptr := x.Args[0] 5086 idx := x.Args[1] 5087 mem := x.Args[2] 5088 if !(x.Uses == 1 && clobber(x)) { 5089 break 5090 } 5091 b = x.Block 5092 v0 := b.NewValue0(v.Pos, Op386MOVBloadidx1, v.Type) 5093 v.reset(OpCopy) 5094 v.AddArg(v0) 5095 v0.AuxInt = off 5096 v0.Aux = sym 5097 v0.AddArg(ptr) 5098 v0.AddArg(idx) 5099 v0.AddArg(mem) 5100 return true 5101 } 5102 // match: (MOVBLZX (ANDLconst [c] x)) 5103 // cond: 5104 // result: (ANDLconst [c & 0xff] x) 5105 for { 5106 v_0 := v.Args[0] 5107 if v_0.Op != Op386ANDLconst { 5108 break 5109 } 5110 c := v_0.AuxInt 5111 x := v_0.Args[0] 5112 v.reset(Op386ANDLconst) 5113 v.AuxInt = c & 0xff 5114 v.AddArg(x) 5115 return true 5116 } 5117 return false 5118 } 5119 func rewriteValue386_Op386MOVBload_0(v *Value) bool { 5120 b := v.Block 5121 _ = b 5122 config := b.Func.Config 5123 _ = config 5124 // match: (MOVBload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _)) 5125 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 5126 // result: (MOVBLZX x) 5127 for { 5128 off := v.AuxInt 5129 sym := v.Aux 5130 _ = v.Args[1] 5131 ptr := v.Args[0] 5132 v_1 := v.Args[1] 5133 if v_1.Op != Op386MOVBstore { 5134 break 5135 } 5136 off2 := v_1.AuxInt 5137 sym2 := v_1.Aux 5138 _ = v_1.Args[2] 5139 ptr2 := v_1.Args[0] 5140 x := v_1.Args[1] 5141 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 5142 break 5143 } 5144 v.reset(Op386MOVBLZX) 5145 v.AddArg(x) 5146 return true 5147 } 5148 // match: (MOVBload [off1] {sym} (ADDLconst [off2] ptr) mem) 5149 // cond: is32Bit(off1+off2) 5150 // result: (MOVBload [off1+off2] {sym} ptr mem) 5151 for { 5152 off1 := v.AuxInt 5153 sym := v.Aux 5154 _ = v.Args[1] 5155 v_0 := v.Args[0] 5156 if v_0.Op != Op386ADDLconst { 5157 break 5158 } 5159 off2 := v_0.AuxInt 5160 ptr := v_0.Args[0] 5161 mem := v.Args[1] 5162 if !(is32Bit(off1 + off2)) { 5163 break 5164 } 5165 v.reset(Op386MOVBload) 5166 v.AuxInt = off1 + off2 5167 v.Aux = sym 5168 v.AddArg(ptr) 5169 v.AddArg(mem) 5170 return true 5171 } 5172 // match: (MOVBload [off1] {sym1} (LEAL [off2] {sym2} base) mem) 5173 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 5174 // result: (MOVBload [off1+off2] {mergeSym(sym1,sym2)} base mem) 5175 for { 5176 off1 := v.AuxInt 5177 sym1 := v.Aux 5178 _ = v.Args[1] 5179 v_0 := v.Args[0] 5180 if v_0.Op != Op386LEAL { 5181 break 5182 } 5183 off2 := v_0.AuxInt 5184 sym2 := v_0.Aux 5185 base := v_0.Args[0] 5186 mem := v.Args[1] 5187 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 5188 break 5189 } 5190 v.reset(Op386MOVBload) 5191 v.AuxInt = off1 + off2 5192 v.Aux = mergeSym(sym1, sym2) 5193 v.AddArg(base) 5194 v.AddArg(mem) 5195 return true 5196 } 5197 // match: (MOVBload [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) mem) 5198 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 5199 // result: (MOVBloadidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem) 5200 for { 5201 off1 := v.AuxInt 5202 sym1 := v.Aux 5203 _ = v.Args[1] 5204 v_0 := v.Args[0] 5205 if v_0.Op != Op386LEAL1 { 5206 break 5207 } 5208 off2 := v_0.AuxInt 5209 sym2 := v_0.Aux 5210 _ = v_0.Args[1] 5211 ptr := v_0.Args[0] 5212 idx := v_0.Args[1] 5213 mem := v.Args[1] 5214 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 5215 break 5216 } 5217 v.reset(Op386MOVBloadidx1) 5218 v.AuxInt = off1 + off2 5219 v.Aux = mergeSym(sym1, sym2) 5220 v.AddArg(ptr) 5221 v.AddArg(idx) 5222 v.AddArg(mem) 5223 return true 5224 } 5225 // match: (MOVBload [off] {sym} (ADDL ptr idx) mem) 5226 // cond: ptr.Op != OpSB 5227 // result: (MOVBloadidx1 [off] {sym} ptr idx mem) 5228 for { 5229 off := v.AuxInt 5230 sym := v.Aux 5231 _ = v.Args[1] 5232 v_0 := v.Args[0] 5233 if v_0.Op != Op386ADDL { 5234 break 5235 } 5236 _ = v_0.Args[1] 5237 ptr := v_0.Args[0] 5238 idx := v_0.Args[1] 5239 mem := v.Args[1] 5240 if !(ptr.Op != OpSB) { 5241 break 5242 } 5243 v.reset(Op386MOVBloadidx1) 5244 v.AuxInt = off 5245 v.Aux = sym 5246 v.AddArg(ptr) 5247 v.AddArg(idx) 5248 v.AddArg(mem) 5249 return true 5250 } 5251 // match: (MOVBload [off] {sym} (SB) _) 5252 // cond: symIsRO(sym) 5253 // result: (MOVLconst [int64(read8(sym, off))]) 5254 for { 5255 off := v.AuxInt 5256 sym := v.Aux 5257 _ = v.Args[1] 5258 v_0 := v.Args[0] 5259 if v_0.Op != OpSB { 5260 break 5261 } 5262 if !(symIsRO(sym)) { 5263 break 5264 } 5265 v.reset(Op386MOVLconst) 5266 v.AuxInt = int64(read8(sym, off)) 5267 return true 5268 } 5269 return false 5270 } 5271 func rewriteValue386_Op386MOVBloadidx1_0(v *Value) bool { 5272 // match: (MOVBloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem) 5273 // cond: 5274 // result: (MOVBloadidx1 [int64(int32(c+d))] {sym} ptr idx mem) 5275 for { 5276 c := v.AuxInt 5277 sym := v.Aux 5278 _ = v.Args[2] 5279 v_0 := v.Args[0] 5280 if v_0.Op != Op386ADDLconst { 5281 break 5282 } 5283 d := v_0.AuxInt 5284 ptr := v_0.Args[0] 5285 idx := v.Args[1] 5286 mem := v.Args[2] 5287 v.reset(Op386MOVBloadidx1) 5288 v.AuxInt = int64(int32(c + d)) 5289 v.Aux = sym 5290 v.AddArg(ptr) 5291 v.AddArg(idx) 5292 v.AddArg(mem) 5293 return true 5294 } 5295 // match: (MOVBloadidx1 [c] {sym} idx (ADDLconst [d] ptr) mem) 5296 // cond: 5297 // result: (MOVBloadidx1 [int64(int32(c+d))] {sym} ptr idx mem) 5298 for { 5299 c := v.AuxInt 5300 sym := v.Aux 5301 _ = v.Args[2] 5302 idx := v.Args[0] 5303 v_1 := v.Args[1] 5304 if v_1.Op != Op386ADDLconst { 5305 break 5306 } 5307 d := v_1.AuxInt 5308 ptr := v_1.Args[0] 5309 mem := v.Args[2] 5310 v.reset(Op386MOVBloadidx1) 5311 v.AuxInt = int64(int32(c + d)) 5312 v.Aux = sym 5313 v.AddArg(ptr) 5314 v.AddArg(idx) 5315 v.AddArg(mem) 5316 return true 5317 } 5318 // match: (MOVBloadidx1 [c] {sym} ptr (ADDLconst [d] idx) mem) 5319 // cond: 5320 // result: (MOVBloadidx1 [int64(int32(c+d))] {sym} ptr idx mem) 5321 for { 5322 c := v.AuxInt 5323 sym := v.Aux 5324 _ = v.Args[2] 5325 ptr := v.Args[0] 5326 v_1 := v.Args[1] 5327 if v_1.Op != Op386ADDLconst { 5328 break 5329 } 5330 d := v_1.AuxInt 5331 idx := v_1.Args[0] 5332 mem := v.Args[2] 5333 v.reset(Op386MOVBloadidx1) 5334 v.AuxInt = int64(int32(c + d)) 5335 v.Aux = sym 5336 v.AddArg(ptr) 5337 v.AddArg(idx) 5338 v.AddArg(mem) 5339 return true 5340 } 5341 // match: (MOVBloadidx1 [c] {sym} (ADDLconst [d] idx) ptr mem) 5342 // cond: 5343 // result: (MOVBloadidx1 [int64(int32(c+d))] {sym} ptr idx mem) 5344 for { 5345 c := v.AuxInt 5346 sym := v.Aux 5347 _ = v.Args[2] 5348 v_0 := v.Args[0] 5349 if v_0.Op != Op386ADDLconst { 5350 break 5351 } 5352 d := v_0.AuxInt 5353 idx := v_0.Args[0] 5354 ptr := v.Args[1] 5355 mem := v.Args[2] 5356 v.reset(Op386MOVBloadidx1) 5357 v.AuxInt = int64(int32(c + d)) 5358 v.Aux = sym 5359 v.AddArg(ptr) 5360 v.AddArg(idx) 5361 v.AddArg(mem) 5362 return true 5363 } 5364 return false 5365 } 5366 func rewriteValue386_Op386MOVBstore_0(v *Value) bool { 5367 b := v.Block 5368 _ = b 5369 config := b.Func.Config 5370 _ = config 5371 // match: (MOVBstore [off] {sym} ptr (MOVBLSX x) mem) 5372 // cond: 5373 // result: (MOVBstore [off] {sym} ptr x mem) 5374 for { 5375 off := v.AuxInt 5376 sym := v.Aux 5377 _ = v.Args[2] 5378 ptr := v.Args[0] 5379 v_1 := v.Args[1] 5380 if v_1.Op != Op386MOVBLSX { 5381 break 5382 } 5383 x := v_1.Args[0] 5384 mem := v.Args[2] 5385 v.reset(Op386MOVBstore) 5386 v.AuxInt = off 5387 v.Aux = sym 5388 v.AddArg(ptr) 5389 v.AddArg(x) 5390 v.AddArg(mem) 5391 return true 5392 } 5393 // match: (MOVBstore [off] {sym} ptr (MOVBLZX x) mem) 5394 // cond: 5395 // result: (MOVBstore [off] {sym} ptr x mem) 5396 for { 5397 off := v.AuxInt 5398 sym := v.Aux 5399 _ = v.Args[2] 5400 ptr := v.Args[0] 5401 v_1 := v.Args[1] 5402 if v_1.Op != Op386MOVBLZX { 5403 break 5404 } 5405 x := v_1.Args[0] 5406 mem := v.Args[2] 5407 v.reset(Op386MOVBstore) 5408 v.AuxInt = off 5409 v.Aux = sym 5410 v.AddArg(ptr) 5411 v.AddArg(x) 5412 v.AddArg(mem) 5413 return true 5414 } 5415 // match: (MOVBstore [off1] {sym} (ADDLconst [off2] ptr) val mem) 5416 // cond: is32Bit(off1+off2) 5417 // result: (MOVBstore [off1+off2] {sym} ptr val mem) 5418 for { 5419 off1 := v.AuxInt 5420 sym := v.Aux 5421 _ = v.Args[2] 5422 v_0 := v.Args[0] 5423 if v_0.Op != Op386ADDLconst { 5424 break 5425 } 5426 off2 := v_0.AuxInt 5427 ptr := v_0.Args[0] 5428 val := v.Args[1] 5429 mem := v.Args[2] 5430 if !(is32Bit(off1 + off2)) { 5431 break 5432 } 5433 v.reset(Op386MOVBstore) 5434 v.AuxInt = off1 + off2 5435 v.Aux = sym 5436 v.AddArg(ptr) 5437 v.AddArg(val) 5438 v.AddArg(mem) 5439 return true 5440 } 5441 // match: (MOVBstore [off] {sym} ptr (MOVLconst [c]) mem) 5442 // cond: validOff(off) 5443 // result: (MOVBstoreconst [makeValAndOff(int64(int8(c)),off)] {sym} ptr mem) 5444 for { 5445 off := v.AuxInt 5446 sym := v.Aux 5447 _ = v.Args[2] 5448 ptr := v.Args[0] 5449 v_1 := v.Args[1] 5450 if v_1.Op != Op386MOVLconst { 5451 break 5452 } 5453 c := v_1.AuxInt 5454 mem := v.Args[2] 5455 if !(validOff(off)) { 5456 break 5457 } 5458 v.reset(Op386MOVBstoreconst) 5459 v.AuxInt = makeValAndOff(int64(int8(c)), off) 5460 v.Aux = sym 5461 v.AddArg(ptr) 5462 v.AddArg(mem) 5463 return true 5464 } 5465 // match: (MOVBstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem) 5466 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 5467 // result: (MOVBstore [off1+off2] {mergeSym(sym1,sym2)} base val mem) 5468 for { 5469 off1 := v.AuxInt 5470 sym1 := v.Aux 5471 _ = v.Args[2] 5472 v_0 := v.Args[0] 5473 if v_0.Op != Op386LEAL { 5474 break 5475 } 5476 off2 := v_0.AuxInt 5477 sym2 := v_0.Aux 5478 base := v_0.Args[0] 5479 val := v.Args[1] 5480 mem := v.Args[2] 5481 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 5482 break 5483 } 5484 v.reset(Op386MOVBstore) 5485 v.AuxInt = off1 + off2 5486 v.Aux = mergeSym(sym1, sym2) 5487 v.AddArg(base) 5488 v.AddArg(val) 5489 v.AddArg(mem) 5490 return true 5491 } 5492 // match: (MOVBstore [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) val mem) 5493 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 5494 // result: (MOVBstoreidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem) 5495 for { 5496 off1 := v.AuxInt 5497 sym1 := v.Aux 5498 _ = v.Args[2] 5499 v_0 := v.Args[0] 5500 if v_0.Op != Op386LEAL1 { 5501 break 5502 } 5503 off2 := v_0.AuxInt 5504 sym2 := v_0.Aux 5505 _ = v_0.Args[1] 5506 ptr := v_0.Args[0] 5507 idx := v_0.Args[1] 5508 val := v.Args[1] 5509 mem := v.Args[2] 5510 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 5511 break 5512 } 5513 v.reset(Op386MOVBstoreidx1) 5514 v.AuxInt = off1 + off2 5515 v.Aux = mergeSym(sym1, sym2) 5516 v.AddArg(ptr) 5517 v.AddArg(idx) 5518 v.AddArg(val) 5519 v.AddArg(mem) 5520 return true 5521 } 5522 // match: (MOVBstore [off] {sym} (ADDL ptr idx) val mem) 5523 // cond: ptr.Op != OpSB 5524 // result: (MOVBstoreidx1 [off] {sym} ptr idx val mem) 5525 for { 5526 off := v.AuxInt 5527 sym := v.Aux 5528 _ = v.Args[2] 5529 v_0 := v.Args[0] 5530 if v_0.Op != Op386ADDL { 5531 break 5532 } 5533 _ = v_0.Args[1] 5534 ptr := v_0.Args[0] 5535 idx := v_0.Args[1] 5536 val := v.Args[1] 5537 mem := v.Args[2] 5538 if !(ptr.Op != OpSB) { 5539 break 5540 } 5541 v.reset(Op386MOVBstoreidx1) 5542 v.AuxInt = off 5543 v.Aux = sym 5544 v.AddArg(ptr) 5545 v.AddArg(idx) 5546 v.AddArg(val) 5547 v.AddArg(mem) 5548 return true 5549 } 5550 // match: (MOVBstore [i] {s} p (SHRWconst [8] w) x:(MOVBstore [i-1] {s} p w mem)) 5551 // cond: x.Uses == 1 && clobber(x) 5552 // result: (MOVWstore [i-1] {s} p w mem) 5553 for { 5554 i := v.AuxInt 5555 s := v.Aux 5556 _ = v.Args[2] 5557 p := v.Args[0] 5558 v_1 := v.Args[1] 5559 if v_1.Op != Op386SHRWconst { 5560 break 5561 } 5562 if v_1.AuxInt != 8 { 5563 break 5564 } 5565 w := v_1.Args[0] 5566 x := v.Args[2] 5567 if x.Op != Op386MOVBstore { 5568 break 5569 } 5570 if x.AuxInt != i-1 { 5571 break 5572 } 5573 if x.Aux != s { 5574 break 5575 } 5576 _ = x.Args[2] 5577 if p != x.Args[0] { 5578 break 5579 } 5580 if w != x.Args[1] { 5581 break 5582 } 5583 mem := x.Args[2] 5584 if !(x.Uses == 1 && clobber(x)) { 5585 break 5586 } 5587 v.reset(Op386MOVWstore) 5588 v.AuxInt = i - 1 5589 v.Aux = s 5590 v.AddArg(p) 5591 v.AddArg(w) 5592 v.AddArg(mem) 5593 return true 5594 } 5595 // match: (MOVBstore [i] {s} p (SHRLconst [8] w) x:(MOVBstore [i-1] {s} p w mem)) 5596 // cond: x.Uses == 1 && clobber(x) 5597 // result: (MOVWstore [i-1] {s} p w mem) 5598 for { 5599 i := v.AuxInt 5600 s := v.Aux 5601 _ = v.Args[2] 5602 p := v.Args[0] 5603 v_1 := v.Args[1] 5604 if v_1.Op != Op386SHRLconst { 5605 break 5606 } 5607 if v_1.AuxInt != 8 { 5608 break 5609 } 5610 w := v_1.Args[0] 5611 x := v.Args[2] 5612 if x.Op != Op386MOVBstore { 5613 break 5614 } 5615 if x.AuxInt != i-1 { 5616 break 5617 } 5618 if x.Aux != s { 5619 break 5620 } 5621 _ = x.Args[2] 5622 if p != x.Args[0] { 5623 break 5624 } 5625 if w != x.Args[1] { 5626 break 5627 } 5628 mem := x.Args[2] 5629 if !(x.Uses == 1 && clobber(x)) { 5630 break 5631 } 5632 v.reset(Op386MOVWstore) 5633 v.AuxInt = i - 1 5634 v.Aux = s 5635 v.AddArg(p) 5636 v.AddArg(w) 5637 v.AddArg(mem) 5638 return true 5639 } 5640 // match: (MOVBstore [i] {s} p w x:(MOVBstore {s} [i+1] p (SHRWconst [8] w) mem)) 5641 // cond: x.Uses == 1 && clobber(x) 5642 // result: (MOVWstore [i] {s} p w mem) 5643 for { 5644 i := v.AuxInt 5645 s := v.Aux 5646 _ = v.Args[2] 5647 p := v.Args[0] 5648 w := v.Args[1] 5649 x := v.Args[2] 5650 if x.Op != Op386MOVBstore { 5651 break 5652 } 5653 if x.AuxInt != i+1 { 5654 break 5655 } 5656 if x.Aux != s { 5657 break 5658 } 5659 _ = x.Args[2] 5660 if p != x.Args[0] { 5661 break 5662 } 5663 x_1 := x.Args[1] 5664 if x_1.Op != Op386SHRWconst { 5665 break 5666 } 5667 if x_1.AuxInt != 8 { 5668 break 5669 } 5670 if w != x_1.Args[0] { 5671 break 5672 } 5673 mem := x.Args[2] 5674 if !(x.Uses == 1 && clobber(x)) { 5675 break 5676 } 5677 v.reset(Op386MOVWstore) 5678 v.AuxInt = i 5679 v.Aux = s 5680 v.AddArg(p) 5681 v.AddArg(w) 5682 v.AddArg(mem) 5683 return true 5684 } 5685 return false 5686 } 5687 func rewriteValue386_Op386MOVBstore_10(v *Value) bool { 5688 // match: (MOVBstore [i] {s} p w x:(MOVBstore {s} [i+1] p (SHRLconst [8] w) mem)) 5689 // cond: x.Uses == 1 && clobber(x) 5690 // result: (MOVWstore [i] {s} p w mem) 5691 for { 5692 i := v.AuxInt 5693 s := v.Aux 5694 _ = v.Args[2] 5695 p := v.Args[0] 5696 w := v.Args[1] 5697 x := v.Args[2] 5698 if x.Op != Op386MOVBstore { 5699 break 5700 } 5701 if x.AuxInt != i+1 { 5702 break 5703 } 5704 if x.Aux != s { 5705 break 5706 } 5707 _ = x.Args[2] 5708 if p != x.Args[0] { 5709 break 5710 } 5711 x_1 := x.Args[1] 5712 if x_1.Op != Op386SHRLconst { 5713 break 5714 } 5715 if x_1.AuxInt != 8 { 5716 break 5717 } 5718 if w != x_1.Args[0] { 5719 break 5720 } 5721 mem := x.Args[2] 5722 if !(x.Uses == 1 && clobber(x)) { 5723 break 5724 } 5725 v.reset(Op386MOVWstore) 5726 v.AuxInt = i 5727 v.Aux = s 5728 v.AddArg(p) 5729 v.AddArg(w) 5730 v.AddArg(mem) 5731 return true 5732 } 5733 // match: (MOVBstore [i] {s} p (SHRLconst [j] w) x:(MOVBstore [i-1] {s} p w0:(SHRLconst [j-8] w) mem)) 5734 // cond: x.Uses == 1 && clobber(x) 5735 // result: (MOVWstore [i-1] {s} p w0 mem) 5736 for { 5737 i := v.AuxInt 5738 s := v.Aux 5739 _ = v.Args[2] 5740 p := v.Args[0] 5741 v_1 := v.Args[1] 5742 if v_1.Op != Op386SHRLconst { 5743 break 5744 } 5745 j := v_1.AuxInt 5746 w := v_1.Args[0] 5747 x := v.Args[2] 5748 if x.Op != Op386MOVBstore { 5749 break 5750 } 5751 if x.AuxInt != i-1 { 5752 break 5753 } 5754 if x.Aux != s { 5755 break 5756 } 5757 _ = x.Args[2] 5758 if p != x.Args[0] { 5759 break 5760 } 5761 w0 := x.Args[1] 5762 if w0.Op != Op386SHRLconst { 5763 break 5764 } 5765 if w0.AuxInt != j-8 { 5766 break 5767 } 5768 if w != w0.Args[0] { 5769 break 5770 } 5771 mem := x.Args[2] 5772 if !(x.Uses == 1 && clobber(x)) { 5773 break 5774 } 5775 v.reset(Op386MOVWstore) 5776 v.AuxInt = i - 1 5777 v.Aux = s 5778 v.AddArg(p) 5779 v.AddArg(w0) 5780 v.AddArg(mem) 5781 return true 5782 } 5783 return false 5784 } 5785 func rewriteValue386_Op386MOVBstoreconst_0(v *Value) bool { 5786 b := v.Block 5787 _ = b 5788 config := b.Func.Config 5789 _ = config 5790 // match: (MOVBstoreconst [sc] {s} (ADDLconst [off] ptr) mem) 5791 // cond: ValAndOff(sc).canAdd(off) 5792 // result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) 5793 for { 5794 sc := v.AuxInt 5795 s := v.Aux 5796 _ = v.Args[1] 5797 v_0 := v.Args[0] 5798 if v_0.Op != Op386ADDLconst { 5799 break 5800 } 5801 off := v_0.AuxInt 5802 ptr := v_0.Args[0] 5803 mem := v.Args[1] 5804 if !(ValAndOff(sc).canAdd(off)) { 5805 break 5806 } 5807 v.reset(Op386MOVBstoreconst) 5808 v.AuxInt = ValAndOff(sc).add(off) 5809 v.Aux = s 5810 v.AddArg(ptr) 5811 v.AddArg(mem) 5812 return true 5813 } 5814 // match: (MOVBstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem) 5815 // cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) && (ptr.Op != OpSB || !config.ctxt.Flag_shared) 5816 // result: (MOVBstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) 5817 for { 5818 sc := v.AuxInt 5819 sym1 := v.Aux 5820 _ = v.Args[1] 5821 v_0 := v.Args[0] 5822 if v_0.Op != Op386LEAL { 5823 break 5824 } 5825 off := v_0.AuxInt 5826 sym2 := v_0.Aux 5827 ptr := v_0.Args[0] 5828 mem := v.Args[1] 5829 if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) && (ptr.Op != OpSB || !config.ctxt.Flag_shared)) { 5830 break 5831 } 5832 v.reset(Op386MOVBstoreconst) 5833 v.AuxInt = ValAndOff(sc).add(off) 5834 v.Aux = mergeSym(sym1, sym2) 5835 v.AddArg(ptr) 5836 v.AddArg(mem) 5837 return true 5838 } 5839 // match: (MOVBstoreconst [x] {sym1} (LEAL1 [off] {sym2} ptr idx) mem) 5840 // cond: canMergeSym(sym1, sym2) 5841 // result: (MOVBstoreconstidx1 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem) 5842 for { 5843 x := v.AuxInt 5844 sym1 := v.Aux 5845 _ = v.Args[1] 5846 v_0 := v.Args[0] 5847 if v_0.Op != Op386LEAL1 { 5848 break 5849 } 5850 off := v_0.AuxInt 5851 sym2 := v_0.Aux 5852 _ = v_0.Args[1] 5853 ptr := v_0.Args[0] 5854 idx := v_0.Args[1] 5855 mem := v.Args[1] 5856 if !(canMergeSym(sym1, sym2)) { 5857 break 5858 } 5859 v.reset(Op386MOVBstoreconstidx1) 5860 v.AuxInt = ValAndOff(x).add(off) 5861 v.Aux = mergeSym(sym1, sym2) 5862 v.AddArg(ptr) 5863 v.AddArg(idx) 5864 v.AddArg(mem) 5865 return true 5866 } 5867 // match: (MOVBstoreconst [x] {sym} (ADDL ptr idx) mem) 5868 // cond: 5869 // result: (MOVBstoreconstidx1 [x] {sym} ptr idx mem) 5870 for { 5871 x := v.AuxInt 5872 sym := v.Aux 5873 _ = v.Args[1] 5874 v_0 := v.Args[0] 5875 if v_0.Op != Op386ADDL { 5876 break 5877 } 5878 _ = v_0.Args[1] 5879 ptr := v_0.Args[0] 5880 idx := v_0.Args[1] 5881 mem := v.Args[1] 5882 v.reset(Op386MOVBstoreconstidx1) 5883 v.AuxInt = x 5884 v.Aux = sym 5885 v.AddArg(ptr) 5886 v.AddArg(idx) 5887 v.AddArg(mem) 5888 return true 5889 } 5890 // match: (MOVBstoreconst [c] {s} p x:(MOVBstoreconst [a] {s} p mem)) 5891 // cond: x.Uses == 1 && ValAndOff(a).Off() + 1 == ValAndOff(c).Off() && clobber(x) 5892 // result: (MOVWstoreconst [makeValAndOff(ValAndOff(a).Val()&0xff | ValAndOff(c).Val()<<8, ValAndOff(a).Off())] {s} p mem) 5893 for { 5894 c := v.AuxInt 5895 s := v.Aux 5896 _ = v.Args[1] 5897 p := v.Args[0] 5898 x := v.Args[1] 5899 if x.Op != Op386MOVBstoreconst { 5900 break 5901 } 5902 a := x.AuxInt 5903 if x.Aux != s { 5904 break 5905 } 5906 _ = x.Args[1] 5907 if p != x.Args[0] { 5908 break 5909 } 5910 mem := x.Args[1] 5911 if !(x.Uses == 1 && ValAndOff(a).Off()+1 == ValAndOff(c).Off() && clobber(x)) { 5912 break 5913 } 5914 v.reset(Op386MOVWstoreconst) 5915 v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xff|ValAndOff(c).Val()<<8, ValAndOff(a).Off()) 5916 v.Aux = s 5917 v.AddArg(p) 5918 v.AddArg(mem) 5919 return true 5920 } 5921 // match: (MOVBstoreconst [a] {s} p x:(MOVBstoreconst [c] {s} p mem)) 5922 // cond: x.Uses == 1 && ValAndOff(a).Off() + 1 == ValAndOff(c).Off() && clobber(x) 5923 // result: (MOVWstoreconst [makeValAndOff(ValAndOff(a).Val()&0xff | ValAndOff(c).Val()<<8, ValAndOff(a).Off())] {s} p mem) 5924 for { 5925 a := v.AuxInt 5926 s := v.Aux 5927 _ = v.Args[1] 5928 p := v.Args[0] 5929 x := v.Args[1] 5930 if x.Op != Op386MOVBstoreconst { 5931 break 5932 } 5933 c := x.AuxInt 5934 if x.Aux != s { 5935 break 5936 } 5937 _ = x.Args[1] 5938 if p != x.Args[0] { 5939 break 5940 } 5941 mem := x.Args[1] 5942 if !(x.Uses == 1 && ValAndOff(a).Off()+1 == ValAndOff(c).Off() && clobber(x)) { 5943 break 5944 } 5945 v.reset(Op386MOVWstoreconst) 5946 v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xff|ValAndOff(c).Val()<<8, ValAndOff(a).Off()) 5947 v.Aux = s 5948 v.AddArg(p) 5949 v.AddArg(mem) 5950 return true 5951 } 5952 return false 5953 } 5954 func rewriteValue386_Op386MOVBstoreconstidx1_0(v *Value) bool { 5955 // match: (MOVBstoreconstidx1 [x] {sym} (ADDLconst [c] ptr) idx mem) 5956 // cond: 5957 // result: (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem) 5958 for { 5959 x := v.AuxInt 5960 sym := v.Aux 5961 _ = v.Args[2] 5962 v_0 := v.Args[0] 5963 if v_0.Op != Op386ADDLconst { 5964 break 5965 } 5966 c := v_0.AuxInt 5967 ptr := v_0.Args[0] 5968 idx := v.Args[1] 5969 mem := v.Args[2] 5970 v.reset(Op386MOVBstoreconstidx1) 5971 v.AuxInt = ValAndOff(x).add(c) 5972 v.Aux = sym 5973 v.AddArg(ptr) 5974 v.AddArg(idx) 5975 v.AddArg(mem) 5976 return true 5977 } 5978 // match: (MOVBstoreconstidx1 [x] {sym} ptr (ADDLconst [c] idx) mem) 5979 // cond: 5980 // result: (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem) 5981 for { 5982 x := v.AuxInt 5983 sym := v.Aux 5984 _ = v.Args[2] 5985 ptr := v.Args[0] 5986 v_1 := v.Args[1] 5987 if v_1.Op != Op386ADDLconst { 5988 break 5989 } 5990 c := v_1.AuxInt 5991 idx := v_1.Args[0] 5992 mem := v.Args[2] 5993 v.reset(Op386MOVBstoreconstidx1) 5994 v.AuxInt = ValAndOff(x).add(c) 5995 v.Aux = sym 5996 v.AddArg(ptr) 5997 v.AddArg(idx) 5998 v.AddArg(mem) 5999 return true 6000 } 6001 // match: (MOVBstoreconstidx1 [c] {s} p i x:(MOVBstoreconstidx1 [a] {s} p i mem)) 6002 // cond: x.Uses == 1 && ValAndOff(a).Off() + 1 == ValAndOff(c).Off() && clobber(x) 6003 // result: (MOVWstoreconstidx1 [makeValAndOff(ValAndOff(a).Val()&0xff | ValAndOff(c).Val()<<8, ValAndOff(a).Off())] {s} p i mem) 6004 for { 6005 c := v.AuxInt 6006 s := v.Aux 6007 _ = v.Args[2] 6008 p := v.Args[0] 6009 i := v.Args[1] 6010 x := v.Args[2] 6011 if x.Op != Op386MOVBstoreconstidx1 { 6012 break 6013 } 6014 a := x.AuxInt 6015 if x.Aux != s { 6016 break 6017 } 6018 _ = x.Args[2] 6019 if p != x.Args[0] { 6020 break 6021 } 6022 if i != x.Args[1] { 6023 break 6024 } 6025 mem := x.Args[2] 6026 if !(x.Uses == 1 && ValAndOff(a).Off()+1 == ValAndOff(c).Off() && clobber(x)) { 6027 break 6028 } 6029 v.reset(Op386MOVWstoreconstidx1) 6030 v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xff|ValAndOff(c).Val()<<8, ValAndOff(a).Off()) 6031 v.Aux = s 6032 v.AddArg(p) 6033 v.AddArg(i) 6034 v.AddArg(mem) 6035 return true 6036 } 6037 return false 6038 } 6039 func rewriteValue386_Op386MOVBstoreidx1_0(v *Value) bool { 6040 // match: (MOVBstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem) 6041 // cond: 6042 // result: (MOVBstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem) 6043 for { 6044 c := v.AuxInt 6045 sym := v.Aux 6046 _ = v.Args[3] 6047 v_0 := v.Args[0] 6048 if v_0.Op != Op386ADDLconst { 6049 break 6050 } 6051 d := v_0.AuxInt 6052 ptr := v_0.Args[0] 6053 idx := v.Args[1] 6054 val := v.Args[2] 6055 mem := v.Args[3] 6056 v.reset(Op386MOVBstoreidx1) 6057 v.AuxInt = int64(int32(c + d)) 6058 v.Aux = sym 6059 v.AddArg(ptr) 6060 v.AddArg(idx) 6061 v.AddArg(val) 6062 v.AddArg(mem) 6063 return true 6064 } 6065 // match: (MOVBstoreidx1 [c] {sym} idx (ADDLconst [d] ptr) val mem) 6066 // cond: 6067 // result: (MOVBstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem) 6068 for { 6069 c := v.AuxInt 6070 sym := v.Aux 6071 _ = v.Args[3] 6072 idx := v.Args[0] 6073 v_1 := v.Args[1] 6074 if v_1.Op != Op386ADDLconst { 6075 break 6076 } 6077 d := v_1.AuxInt 6078 ptr := v_1.Args[0] 6079 val := v.Args[2] 6080 mem := v.Args[3] 6081 v.reset(Op386MOVBstoreidx1) 6082 v.AuxInt = int64(int32(c + d)) 6083 v.Aux = sym 6084 v.AddArg(ptr) 6085 v.AddArg(idx) 6086 v.AddArg(val) 6087 v.AddArg(mem) 6088 return true 6089 } 6090 // match: (MOVBstoreidx1 [c] {sym} ptr (ADDLconst [d] idx) val mem) 6091 // cond: 6092 // result: (MOVBstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem) 6093 for { 6094 c := v.AuxInt 6095 sym := v.Aux 6096 _ = v.Args[3] 6097 ptr := v.Args[0] 6098 v_1 := v.Args[1] 6099 if v_1.Op != Op386ADDLconst { 6100 break 6101 } 6102 d := v_1.AuxInt 6103 idx := v_1.Args[0] 6104 val := v.Args[2] 6105 mem := v.Args[3] 6106 v.reset(Op386MOVBstoreidx1) 6107 v.AuxInt = int64(int32(c + d)) 6108 v.Aux = sym 6109 v.AddArg(ptr) 6110 v.AddArg(idx) 6111 v.AddArg(val) 6112 v.AddArg(mem) 6113 return true 6114 } 6115 // match: (MOVBstoreidx1 [c] {sym} (ADDLconst [d] idx) ptr val mem) 6116 // cond: 6117 // result: (MOVBstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem) 6118 for { 6119 c := v.AuxInt 6120 sym := v.Aux 6121 _ = v.Args[3] 6122 v_0 := v.Args[0] 6123 if v_0.Op != Op386ADDLconst { 6124 break 6125 } 6126 d := v_0.AuxInt 6127 idx := v_0.Args[0] 6128 ptr := v.Args[1] 6129 val := v.Args[2] 6130 mem := v.Args[3] 6131 v.reset(Op386MOVBstoreidx1) 6132 v.AuxInt = int64(int32(c + d)) 6133 v.Aux = sym 6134 v.AddArg(ptr) 6135 v.AddArg(idx) 6136 v.AddArg(val) 6137 v.AddArg(mem) 6138 return true 6139 } 6140 // match: (MOVBstoreidx1 [i] {s} p idx (SHRLconst [8] w) x:(MOVBstoreidx1 [i-1] {s} p idx w mem)) 6141 // cond: x.Uses == 1 && clobber(x) 6142 // result: (MOVWstoreidx1 [i-1] {s} p idx w mem) 6143 for { 6144 i := v.AuxInt 6145 s := v.Aux 6146 _ = v.Args[3] 6147 p := v.Args[0] 6148 idx := v.Args[1] 6149 v_2 := v.Args[2] 6150 if v_2.Op != Op386SHRLconst { 6151 break 6152 } 6153 if v_2.AuxInt != 8 { 6154 break 6155 } 6156 w := v_2.Args[0] 6157 x := v.Args[3] 6158 if x.Op != Op386MOVBstoreidx1 { 6159 break 6160 } 6161 if x.AuxInt != i-1 { 6162 break 6163 } 6164 if x.Aux != s { 6165 break 6166 } 6167 _ = x.Args[3] 6168 if p != x.Args[0] { 6169 break 6170 } 6171 if idx != x.Args[1] { 6172 break 6173 } 6174 if w != x.Args[2] { 6175 break 6176 } 6177 mem := x.Args[3] 6178 if !(x.Uses == 1 && clobber(x)) { 6179 break 6180 } 6181 v.reset(Op386MOVWstoreidx1) 6182 v.AuxInt = i - 1 6183 v.Aux = s 6184 v.AddArg(p) 6185 v.AddArg(idx) 6186 v.AddArg(w) 6187 v.AddArg(mem) 6188 return true 6189 } 6190 // match: (MOVBstoreidx1 [i] {s} p idx (SHRLconst [8] w) x:(MOVBstoreidx1 [i-1] {s} idx p w mem)) 6191 // cond: x.Uses == 1 && clobber(x) 6192 // result: (MOVWstoreidx1 [i-1] {s} p idx w mem) 6193 for { 6194 i := v.AuxInt 6195 s := v.Aux 6196 _ = v.Args[3] 6197 p := v.Args[0] 6198 idx := v.Args[1] 6199 v_2 := v.Args[2] 6200 if v_2.Op != Op386SHRLconst { 6201 break 6202 } 6203 if v_2.AuxInt != 8 { 6204 break 6205 } 6206 w := v_2.Args[0] 6207 x := v.Args[3] 6208 if x.Op != Op386MOVBstoreidx1 { 6209 break 6210 } 6211 if x.AuxInt != i-1 { 6212 break 6213 } 6214 if x.Aux != s { 6215 break 6216 } 6217 _ = x.Args[3] 6218 if idx != x.Args[0] { 6219 break 6220 } 6221 if p != x.Args[1] { 6222 break 6223 } 6224 if w != x.Args[2] { 6225 break 6226 } 6227 mem := x.Args[3] 6228 if !(x.Uses == 1 && clobber(x)) { 6229 break 6230 } 6231 v.reset(Op386MOVWstoreidx1) 6232 v.AuxInt = i - 1 6233 v.Aux = s 6234 v.AddArg(p) 6235 v.AddArg(idx) 6236 v.AddArg(w) 6237 v.AddArg(mem) 6238 return true 6239 } 6240 // match: (MOVBstoreidx1 [i] {s} idx p (SHRLconst [8] w) x:(MOVBstoreidx1 [i-1] {s} p idx w mem)) 6241 // cond: x.Uses == 1 && clobber(x) 6242 // result: (MOVWstoreidx1 [i-1] {s} p idx w mem) 6243 for { 6244 i := v.AuxInt 6245 s := v.Aux 6246 _ = v.Args[3] 6247 idx := v.Args[0] 6248 p := v.Args[1] 6249 v_2 := v.Args[2] 6250 if v_2.Op != Op386SHRLconst { 6251 break 6252 } 6253 if v_2.AuxInt != 8 { 6254 break 6255 } 6256 w := v_2.Args[0] 6257 x := v.Args[3] 6258 if x.Op != Op386MOVBstoreidx1 { 6259 break 6260 } 6261 if x.AuxInt != i-1 { 6262 break 6263 } 6264 if x.Aux != s { 6265 break 6266 } 6267 _ = x.Args[3] 6268 if p != x.Args[0] { 6269 break 6270 } 6271 if idx != x.Args[1] { 6272 break 6273 } 6274 if w != x.Args[2] { 6275 break 6276 } 6277 mem := x.Args[3] 6278 if !(x.Uses == 1 && clobber(x)) { 6279 break 6280 } 6281 v.reset(Op386MOVWstoreidx1) 6282 v.AuxInt = i - 1 6283 v.Aux = s 6284 v.AddArg(p) 6285 v.AddArg(idx) 6286 v.AddArg(w) 6287 v.AddArg(mem) 6288 return true 6289 } 6290 // match: (MOVBstoreidx1 [i] {s} idx p (SHRLconst [8] w) x:(MOVBstoreidx1 [i-1] {s} idx p w mem)) 6291 // cond: x.Uses == 1 && clobber(x) 6292 // result: (MOVWstoreidx1 [i-1] {s} p idx w mem) 6293 for { 6294 i := v.AuxInt 6295 s := v.Aux 6296 _ = v.Args[3] 6297 idx := v.Args[0] 6298 p := v.Args[1] 6299 v_2 := v.Args[2] 6300 if v_2.Op != Op386SHRLconst { 6301 break 6302 } 6303 if v_2.AuxInt != 8 { 6304 break 6305 } 6306 w := v_2.Args[0] 6307 x := v.Args[3] 6308 if x.Op != Op386MOVBstoreidx1 { 6309 break 6310 } 6311 if x.AuxInt != i-1 { 6312 break 6313 } 6314 if x.Aux != s { 6315 break 6316 } 6317 _ = x.Args[3] 6318 if idx != x.Args[0] { 6319 break 6320 } 6321 if p != x.Args[1] { 6322 break 6323 } 6324 if w != x.Args[2] { 6325 break 6326 } 6327 mem := x.Args[3] 6328 if !(x.Uses == 1 && clobber(x)) { 6329 break 6330 } 6331 v.reset(Op386MOVWstoreidx1) 6332 v.AuxInt = i - 1 6333 v.Aux = s 6334 v.AddArg(p) 6335 v.AddArg(idx) 6336 v.AddArg(w) 6337 v.AddArg(mem) 6338 return true 6339 } 6340 // match: (MOVBstoreidx1 [i] {s} p idx (SHRWconst [8] w) x:(MOVBstoreidx1 [i-1] {s} p idx w mem)) 6341 // cond: x.Uses == 1 && clobber(x) 6342 // result: (MOVWstoreidx1 [i-1] {s} p idx w mem) 6343 for { 6344 i := v.AuxInt 6345 s := v.Aux 6346 _ = v.Args[3] 6347 p := v.Args[0] 6348 idx := v.Args[1] 6349 v_2 := v.Args[2] 6350 if v_2.Op != Op386SHRWconst { 6351 break 6352 } 6353 if v_2.AuxInt != 8 { 6354 break 6355 } 6356 w := v_2.Args[0] 6357 x := v.Args[3] 6358 if x.Op != Op386MOVBstoreidx1 { 6359 break 6360 } 6361 if x.AuxInt != i-1 { 6362 break 6363 } 6364 if x.Aux != s { 6365 break 6366 } 6367 _ = x.Args[3] 6368 if p != x.Args[0] { 6369 break 6370 } 6371 if idx != x.Args[1] { 6372 break 6373 } 6374 if w != x.Args[2] { 6375 break 6376 } 6377 mem := x.Args[3] 6378 if !(x.Uses == 1 && clobber(x)) { 6379 break 6380 } 6381 v.reset(Op386MOVWstoreidx1) 6382 v.AuxInt = i - 1 6383 v.Aux = s 6384 v.AddArg(p) 6385 v.AddArg(idx) 6386 v.AddArg(w) 6387 v.AddArg(mem) 6388 return true 6389 } 6390 // match: (MOVBstoreidx1 [i] {s} p idx (SHRWconst [8] w) x:(MOVBstoreidx1 [i-1] {s} idx p w mem)) 6391 // cond: x.Uses == 1 && clobber(x) 6392 // result: (MOVWstoreidx1 [i-1] {s} p idx w mem) 6393 for { 6394 i := v.AuxInt 6395 s := v.Aux 6396 _ = v.Args[3] 6397 p := v.Args[0] 6398 idx := v.Args[1] 6399 v_2 := v.Args[2] 6400 if v_2.Op != Op386SHRWconst { 6401 break 6402 } 6403 if v_2.AuxInt != 8 { 6404 break 6405 } 6406 w := v_2.Args[0] 6407 x := v.Args[3] 6408 if x.Op != Op386MOVBstoreidx1 { 6409 break 6410 } 6411 if x.AuxInt != i-1 { 6412 break 6413 } 6414 if x.Aux != s { 6415 break 6416 } 6417 _ = x.Args[3] 6418 if idx != x.Args[0] { 6419 break 6420 } 6421 if p != x.Args[1] { 6422 break 6423 } 6424 if w != x.Args[2] { 6425 break 6426 } 6427 mem := x.Args[3] 6428 if !(x.Uses == 1 && clobber(x)) { 6429 break 6430 } 6431 v.reset(Op386MOVWstoreidx1) 6432 v.AuxInt = i - 1 6433 v.Aux = s 6434 v.AddArg(p) 6435 v.AddArg(idx) 6436 v.AddArg(w) 6437 v.AddArg(mem) 6438 return true 6439 } 6440 return false 6441 } 6442 func rewriteValue386_Op386MOVBstoreidx1_10(v *Value) bool { 6443 // match: (MOVBstoreidx1 [i] {s} idx p (SHRWconst [8] w) x:(MOVBstoreidx1 [i-1] {s} p idx w mem)) 6444 // cond: x.Uses == 1 && clobber(x) 6445 // result: (MOVWstoreidx1 [i-1] {s} p idx w mem) 6446 for { 6447 i := v.AuxInt 6448 s := v.Aux 6449 _ = v.Args[3] 6450 idx := v.Args[0] 6451 p := v.Args[1] 6452 v_2 := v.Args[2] 6453 if v_2.Op != Op386SHRWconst { 6454 break 6455 } 6456 if v_2.AuxInt != 8 { 6457 break 6458 } 6459 w := v_2.Args[0] 6460 x := v.Args[3] 6461 if x.Op != Op386MOVBstoreidx1 { 6462 break 6463 } 6464 if x.AuxInt != i-1 { 6465 break 6466 } 6467 if x.Aux != s { 6468 break 6469 } 6470 _ = x.Args[3] 6471 if p != x.Args[0] { 6472 break 6473 } 6474 if idx != x.Args[1] { 6475 break 6476 } 6477 if w != x.Args[2] { 6478 break 6479 } 6480 mem := x.Args[3] 6481 if !(x.Uses == 1 && clobber(x)) { 6482 break 6483 } 6484 v.reset(Op386MOVWstoreidx1) 6485 v.AuxInt = i - 1 6486 v.Aux = s 6487 v.AddArg(p) 6488 v.AddArg(idx) 6489 v.AddArg(w) 6490 v.AddArg(mem) 6491 return true 6492 } 6493 // match: (MOVBstoreidx1 [i] {s} idx p (SHRWconst [8] w) x:(MOVBstoreidx1 [i-1] {s} idx p w mem)) 6494 // cond: x.Uses == 1 && clobber(x) 6495 // result: (MOVWstoreidx1 [i-1] {s} p idx w mem) 6496 for { 6497 i := v.AuxInt 6498 s := v.Aux 6499 _ = v.Args[3] 6500 idx := v.Args[0] 6501 p := v.Args[1] 6502 v_2 := v.Args[2] 6503 if v_2.Op != Op386SHRWconst { 6504 break 6505 } 6506 if v_2.AuxInt != 8 { 6507 break 6508 } 6509 w := v_2.Args[0] 6510 x := v.Args[3] 6511 if x.Op != Op386MOVBstoreidx1 { 6512 break 6513 } 6514 if x.AuxInt != i-1 { 6515 break 6516 } 6517 if x.Aux != s { 6518 break 6519 } 6520 _ = x.Args[3] 6521 if idx != x.Args[0] { 6522 break 6523 } 6524 if p != x.Args[1] { 6525 break 6526 } 6527 if w != x.Args[2] { 6528 break 6529 } 6530 mem := x.Args[3] 6531 if !(x.Uses == 1 && clobber(x)) { 6532 break 6533 } 6534 v.reset(Op386MOVWstoreidx1) 6535 v.AuxInt = i - 1 6536 v.Aux = s 6537 v.AddArg(p) 6538 v.AddArg(idx) 6539 v.AddArg(w) 6540 v.AddArg(mem) 6541 return true 6542 } 6543 // match: (MOVBstoreidx1 [i] {s} p idx w x:(MOVBstoreidx1 [i+1] {s} p idx (SHRLconst [8] w) mem)) 6544 // cond: x.Uses == 1 && clobber(x) 6545 // result: (MOVWstoreidx1 [i] {s} p idx w mem) 6546 for { 6547 i := v.AuxInt 6548 s := v.Aux 6549 _ = v.Args[3] 6550 p := v.Args[0] 6551 idx := v.Args[1] 6552 w := v.Args[2] 6553 x := v.Args[3] 6554 if x.Op != Op386MOVBstoreidx1 { 6555 break 6556 } 6557 if x.AuxInt != i+1 { 6558 break 6559 } 6560 if x.Aux != s { 6561 break 6562 } 6563 _ = x.Args[3] 6564 if p != x.Args[0] { 6565 break 6566 } 6567 if idx != x.Args[1] { 6568 break 6569 } 6570 x_2 := x.Args[2] 6571 if x_2.Op != Op386SHRLconst { 6572 break 6573 } 6574 if x_2.AuxInt != 8 { 6575 break 6576 } 6577 if w != x_2.Args[0] { 6578 break 6579 } 6580 mem := x.Args[3] 6581 if !(x.Uses == 1 && clobber(x)) { 6582 break 6583 } 6584 v.reset(Op386MOVWstoreidx1) 6585 v.AuxInt = i 6586 v.Aux = s 6587 v.AddArg(p) 6588 v.AddArg(idx) 6589 v.AddArg(w) 6590 v.AddArg(mem) 6591 return true 6592 } 6593 // match: (MOVBstoreidx1 [i] {s} p idx w x:(MOVBstoreidx1 [i+1] {s} idx p (SHRLconst [8] w) mem)) 6594 // cond: x.Uses == 1 && clobber(x) 6595 // result: (MOVWstoreidx1 [i] {s} p idx w mem) 6596 for { 6597 i := v.AuxInt 6598 s := v.Aux 6599 _ = v.Args[3] 6600 p := v.Args[0] 6601 idx := v.Args[1] 6602 w := v.Args[2] 6603 x := v.Args[3] 6604 if x.Op != Op386MOVBstoreidx1 { 6605 break 6606 } 6607 if x.AuxInt != i+1 { 6608 break 6609 } 6610 if x.Aux != s { 6611 break 6612 } 6613 _ = x.Args[3] 6614 if idx != x.Args[0] { 6615 break 6616 } 6617 if p != x.Args[1] { 6618 break 6619 } 6620 x_2 := x.Args[2] 6621 if x_2.Op != Op386SHRLconst { 6622 break 6623 } 6624 if x_2.AuxInt != 8 { 6625 break 6626 } 6627 if w != x_2.Args[0] { 6628 break 6629 } 6630 mem := x.Args[3] 6631 if !(x.Uses == 1 && clobber(x)) { 6632 break 6633 } 6634 v.reset(Op386MOVWstoreidx1) 6635 v.AuxInt = i 6636 v.Aux = s 6637 v.AddArg(p) 6638 v.AddArg(idx) 6639 v.AddArg(w) 6640 v.AddArg(mem) 6641 return true 6642 } 6643 // match: (MOVBstoreidx1 [i] {s} idx p w x:(MOVBstoreidx1 [i+1] {s} p idx (SHRLconst [8] w) mem)) 6644 // cond: x.Uses == 1 && clobber(x) 6645 // result: (MOVWstoreidx1 [i] {s} p idx w mem) 6646 for { 6647 i := v.AuxInt 6648 s := v.Aux 6649 _ = v.Args[3] 6650 idx := v.Args[0] 6651 p := v.Args[1] 6652 w := v.Args[2] 6653 x := v.Args[3] 6654 if x.Op != Op386MOVBstoreidx1 { 6655 break 6656 } 6657 if x.AuxInt != i+1 { 6658 break 6659 } 6660 if x.Aux != s { 6661 break 6662 } 6663 _ = x.Args[3] 6664 if p != x.Args[0] { 6665 break 6666 } 6667 if idx != x.Args[1] { 6668 break 6669 } 6670 x_2 := x.Args[2] 6671 if x_2.Op != Op386SHRLconst { 6672 break 6673 } 6674 if x_2.AuxInt != 8 { 6675 break 6676 } 6677 if w != x_2.Args[0] { 6678 break 6679 } 6680 mem := x.Args[3] 6681 if !(x.Uses == 1 && clobber(x)) { 6682 break 6683 } 6684 v.reset(Op386MOVWstoreidx1) 6685 v.AuxInt = i 6686 v.Aux = s 6687 v.AddArg(p) 6688 v.AddArg(idx) 6689 v.AddArg(w) 6690 v.AddArg(mem) 6691 return true 6692 } 6693 // match: (MOVBstoreidx1 [i] {s} idx p w x:(MOVBstoreidx1 [i+1] {s} idx p (SHRLconst [8] w) mem)) 6694 // cond: x.Uses == 1 && clobber(x) 6695 // result: (MOVWstoreidx1 [i] {s} p idx w mem) 6696 for { 6697 i := v.AuxInt 6698 s := v.Aux 6699 _ = v.Args[3] 6700 idx := v.Args[0] 6701 p := v.Args[1] 6702 w := v.Args[2] 6703 x := v.Args[3] 6704 if x.Op != Op386MOVBstoreidx1 { 6705 break 6706 } 6707 if x.AuxInt != i+1 { 6708 break 6709 } 6710 if x.Aux != s { 6711 break 6712 } 6713 _ = x.Args[3] 6714 if idx != x.Args[0] { 6715 break 6716 } 6717 if p != x.Args[1] { 6718 break 6719 } 6720 x_2 := x.Args[2] 6721 if x_2.Op != Op386SHRLconst { 6722 break 6723 } 6724 if x_2.AuxInt != 8 { 6725 break 6726 } 6727 if w != x_2.Args[0] { 6728 break 6729 } 6730 mem := x.Args[3] 6731 if !(x.Uses == 1 && clobber(x)) { 6732 break 6733 } 6734 v.reset(Op386MOVWstoreidx1) 6735 v.AuxInt = i 6736 v.Aux = s 6737 v.AddArg(p) 6738 v.AddArg(idx) 6739 v.AddArg(w) 6740 v.AddArg(mem) 6741 return true 6742 } 6743 // match: (MOVBstoreidx1 [i] {s} p idx w x:(MOVBstoreidx1 [i+1] {s} p idx (SHRWconst [8] w) mem)) 6744 // cond: x.Uses == 1 && clobber(x) 6745 // result: (MOVWstoreidx1 [i] {s} p idx w mem) 6746 for { 6747 i := v.AuxInt 6748 s := v.Aux 6749 _ = v.Args[3] 6750 p := v.Args[0] 6751 idx := v.Args[1] 6752 w := v.Args[2] 6753 x := v.Args[3] 6754 if x.Op != Op386MOVBstoreidx1 { 6755 break 6756 } 6757 if x.AuxInt != i+1 { 6758 break 6759 } 6760 if x.Aux != s { 6761 break 6762 } 6763 _ = x.Args[3] 6764 if p != x.Args[0] { 6765 break 6766 } 6767 if idx != x.Args[1] { 6768 break 6769 } 6770 x_2 := x.Args[2] 6771 if x_2.Op != Op386SHRWconst { 6772 break 6773 } 6774 if x_2.AuxInt != 8 { 6775 break 6776 } 6777 if w != x_2.Args[0] { 6778 break 6779 } 6780 mem := x.Args[3] 6781 if !(x.Uses == 1 && clobber(x)) { 6782 break 6783 } 6784 v.reset(Op386MOVWstoreidx1) 6785 v.AuxInt = i 6786 v.Aux = s 6787 v.AddArg(p) 6788 v.AddArg(idx) 6789 v.AddArg(w) 6790 v.AddArg(mem) 6791 return true 6792 } 6793 // match: (MOVBstoreidx1 [i] {s} p idx w x:(MOVBstoreidx1 [i+1] {s} idx p (SHRWconst [8] w) mem)) 6794 // cond: x.Uses == 1 && clobber(x) 6795 // result: (MOVWstoreidx1 [i] {s} p idx w mem) 6796 for { 6797 i := v.AuxInt 6798 s := v.Aux 6799 _ = v.Args[3] 6800 p := v.Args[0] 6801 idx := v.Args[1] 6802 w := v.Args[2] 6803 x := v.Args[3] 6804 if x.Op != Op386MOVBstoreidx1 { 6805 break 6806 } 6807 if x.AuxInt != i+1 { 6808 break 6809 } 6810 if x.Aux != s { 6811 break 6812 } 6813 _ = x.Args[3] 6814 if idx != x.Args[0] { 6815 break 6816 } 6817 if p != x.Args[1] { 6818 break 6819 } 6820 x_2 := x.Args[2] 6821 if x_2.Op != Op386SHRWconst { 6822 break 6823 } 6824 if x_2.AuxInt != 8 { 6825 break 6826 } 6827 if w != x_2.Args[0] { 6828 break 6829 } 6830 mem := x.Args[3] 6831 if !(x.Uses == 1 && clobber(x)) { 6832 break 6833 } 6834 v.reset(Op386MOVWstoreidx1) 6835 v.AuxInt = i 6836 v.Aux = s 6837 v.AddArg(p) 6838 v.AddArg(idx) 6839 v.AddArg(w) 6840 v.AddArg(mem) 6841 return true 6842 } 6843 // match: (MOVBstoreidx1 [i] {s} idx p w x:(MOVBstoreidx1 [i+1] {s} p idx (SHRWconst [8] w) mem)) 6844 // cond: x.Uses == 1 && clobber(x) 6845 // result: (MOVWstoreidx1 [i] {s} p idx w mem) 6846 for { 6847 i := v.AuxInt 6848 s := v.Aux 6849 _ = v.Args[3] 6850 idx := v.Args[0] 6851 p := v.Args[1] 6852 w := v.Args[2] 6853 x := v.Args[3] 6854 if x.Op != Op386MOVBstoreidx1 { 6855 break 6856 } 6857 if x.AuxInt != i+1 { 6858 break 6859 } 6860 if x.Aux != s { 6861 break 6862 } 6863 _ = x.Args[3] 6864 if p != x.Args[0] { 6865 break 6866 } 6867 if idx != x.Args[1] { 6868 break 6869 } 6870 x_2 := x.Args[2] 6871 if x_2.Op != Op386SHRWconst { 6872 break 6873 } 6874 if x_2.AuxInt != 8 { 6875 break 6876 } 6877 if w != x_2.Args[0] { 6878 break 6879 } 6880 mem := x.Args[3] 6881 if !(x.Uses == 1 && clobber(x)) { 6882 break 6883 } 6884 v.reset(Op386MOVWstoreidx1) 6885 v.AuxInt = i 6886 v.Aux = s 6887 v.AddArg(p) 6888 v.AddArg(idx) 6889 v.AddArg(w) 6890 v.AddArg(mem) 6891 return true 6892 } 6893 // match: (MOVBstoreidx1 [i] {s} idx p w x:(MOVBstoreidx1 [i+1] {s} idx p (SHRWconst [8] w) mem)) 6894 // cond: x.Uses == 1 && clobber(x) 6895 // result: (MOVWstoreidx1 [i] {s} p idx w mem) 6896 for { 6897 i := v.AuxInt 6898 s := v.Aux 6899 _ = v.Args[3] 6900 idx := v.Args[0] 6901 p := v.Args[1] 6902 w := v.Args[2] 6903 x := v.Args[3] 6904 if x.Op != Op386MOVBstoreidx1 { 6905 break 6906 } 6907 if x.AuxInt != i+1 { 6908 break 6909 } 6910 if x.Aux != s { 6911 break 6912 } 6913 _ = x.Args[3] 6914 if idx != x.Args[0] { 6915 break 6916 } 6917 if p != x.Args[1] { 6918 break 6919 } 6920 x_2 := x.Args[2] 6921 if x_2.Op != Op386SHRWconst { 6922 break 6923 } 6924 if x_2.AuxInt != 8 { 6925 break 6926 } 6927 if w != x_2.Args[0] { 6928 break 6929 } 6930 mem := x.Args[3] 6931 if !(x.Uses == 1 && clobber(x)) { 6932 break 6933 } 6934 v.reset(Op386MOVWstoreidx1) 6935 v.AuxInt = i 6936 v.Aux = s 6937 v.AddArg(p) 6938 v.AddArg(idx) 6939 v.AddArg(w) 6940 v.AddArg(mem) 6941 return true 6942 } 6943 return false 6944 } 6945 func rewriteValue386_Op386MOVBstoreidx1_20(v *Value) bool { 6946 // match: (MOVBstoreidx1 [i] {s} p idx (SHRLconst [j] w) x:(MOVBstoreidx1 [i-1] {s} p idx w0:(SHRLconst [j-8] w) mem)) 6947 // cond: x.Uses == 1 && clobber(x) 6948 // result: (MOVWstoreidx1 [i-1] {s} p idx w0 mem) 6949 for { 6950 i := v.AuxInt 6951 s := v.Aux 6952 _ = v.Args[3] 6953 p := v.Args[0] 6954 idx := v.Args[1] 6955 v_2 := v.Args[2] 6956 if v_2.Op != Op386SHRLconst { 6957 break 6958 } 6959 j := v_2.AuxInt 6960 w := v_2.Args[0] 6961 x := v.Args[3] 6962 if x.Op != Op386MOVBstoreidx1 { 6963 break 6964 } 6965 if x.AuxInt != i-1 { 6966 break 6967 } 6968 if x.Aux != s { 6969 break 6970 } 6971 _ = x.Args[3] 6972 if p != x.Args[0] { 6973 break 6974 } 6975 if idx != x.Args[1] { 6976 break 6977 } 6978 w0 := x.Args[2] 6979 if w0.Op != Op386SHRLconst { 6980 break 6981 } 6982 if w0.AuxInt != j-8 { 6983 break 6984 } 6985 if w != w0.Args[0] { 6986 break 6987 } 6988 mem := x.Args[3] 6989 if !(x.Uses == 1 && clobber(x)) { 6990 break 6991 } 6992 v.reset(Op386MOVWstoreidx1) 6993 v.AuxInt = i - 1 6994 v.Aux = s 6995 v.AddArg(p) 6996 v.AddArg(idx) 6997 v.AddArg(w0) 6998 v.AddArg(mem) 6999 return true 7000 } 7001 // match: (MOVBstoreidx1 [i] {s} p idx (SHRLconst [j] w) x:(MOVBstoreidx1 [i-1] {s} idx p w0:(SHRLconst [j-8] w) mem)) 7002 // cond: x.Uses == 1 && clobber(x) 7003 // result: (MOVWstoreidx1 [i-1] {s} p idx w0 mem) 7004 for { 7005 i := v.AuxInt 7006 s := v.Aux 7007 _ = v.Args[3] 7008 p := v.Args[0] 7009 idx := v.Args[1] 7010 v_2 := v.Args[2] 7011 if v_2.Op != Op386SHRLconst { 7012 break 7013 } 7014 j := v_2.AuxInt 7015 w := v_2.Args[0] 7016 x := v.Args[3] 7017 if x.Op != Op386MOVBstoreidx1 { 7018 break 7019 } 7020 if x.AuxInt != i-1 { 7021 break 7022 } 7023 if x.Aux != s { 7024 break 7025 } 7026 _ = x.Args[3] 7027 if idx != x.Args[0] { 7028 break 7029 } 7030 if p != x.Args[1] { 7031 break 7032 } 7033 w0 := x.Args[2] 7034 if w0.Op != Op386SHRLconst { 7035 break 7036 } 7037 if w0.AuxInt != j-8 { 7038 break 7039 } 7040 if w != w0.Args[0] { 7041 break 7042 } 7043 mem := x.Args[3] 7044 if !(x.Uses == 1 && clobber(x)) { 7045 break 7046 } 7047 v.reset(Op386MOVWstoreidx1) 7048 v.AuxInt = i - 1 7049 v.Aux = s 7050 v.AddArg(p) 7051 v.AddArg(idx) 7052 v.AddArg(w0) 7053 v.AddArg(mem) 7054 return true 7055 } 7056 // match: (MOVBstoreidx1 [i] {s} idx p (SHRLconst [j] w) x:(MOVBstoreidx1 [i-1] {s} p idx w0:(SHRLconst [j-8] w) mem)) 7057 // cond: x.Uses == 1 && clobber(x) 7058 // result: (MOVWstoreidx1 [i-1] {s} p idx w0 mem) 7059 for { 7060 i := v.AuxInt 7061 s := v.Aux 7062 _ = v.Args[3] 7063 idx := v.Args[0] 7064 p := v.Args[1] 7065 v_2 := v.Args[2] 7066 if v_2.Op != Op386SHRLconst { 7067 break 7068 } 7069 j := v_2.AuxInt 7070 w := v_2.Args[0] 7071 x := v.Args[3] 7072 if x.Op != Op386MOVBstoreidx1 { 7073 break 7074 } 7075 if x.AuxInt != i-1 { 7076 break 7077 } 7078 if x.Aux != s { 7079 break 7080 } 7081 _ = x.Args[3] 7082 if p != x.Args[0] { 7083 break 7084 } 7085 if idx != x.Args[1] { 7086 break 7087 } 7088 w0 := x.Args[2] 7089 if w0.Op != Op386SHRLconst { 7090 break 7091 } 7092 if w0.AuxInt != j-8 { 7093 break 7094 } 7095 if w != w0.Args[0] { 7096 break 7097 } 7098 mem := x.Args[3] 7099 if !(x.Uses == 1 && clobber(x)) { 7100 break 7101 } 7102 v.reset(Op386MOVWstoreidx1) 7103 v.AuxInt = i - 1 7104 v.Aux = s 7105 v.AddArg(p) 7106 v.AddArg(idx) 7107 v.AddArg(w0) 7108 v.AddArg(mem) 7109 return true 7110 } 7111 // match: (MOVBstoreidx1 [i] {s} idx p (SHRLconst [j] w) x:(MOVBstoreidx1 [i-1] {s} idx p w0:(SHRLconst [j-8] w) mem)) 7112 // cond: x.Uses == 1 && clobber(x) 7113 // result: (MOVWstoreidx1 [i-1] {s} p idx w0 mem) 7114 for { 7115 i := v.AuxInt 7116 s := v.Aux 7117 _ = v.Args[3] 7118 idx := v.Args[0] 7119 p := v.Args[1] 7120 v_2 := v.Args[2] 7121 if v_2.Op != Op386SHRLconst { 7122 break 7123 } 7124 j := v_2.AuxInt 7125 w := v_2.Args[0] 7126 x := v.Args[3] 7127 if x.Op != Op386MOVBstoreidx1 { 7128 break 7129 } 7130 if x.AuxInt != i-1 { 7131 break 7132 } 7133 if x.Aux != s { 7134 break 7135 } 7136 _ = x.Args[3] 7137 if idx != x.Args[0] { 7138 break 7139 } 7140 if p != x.Args[1] { 7141 break 7142 } 7143 w0 := x.Args[2] 7144 if w0.Op != Op386SHRLconst { 7145 break 7146 } 7147 if w0.AuxInt != j-8 { 7148 break 7149 } 7150 if w != w0.Args[0] { 7151 break 7152 } 7153 mem := x.Args[3] 7154 if !(x.Uses == 1 && clobber(x)) { 7155 break 7156 } 7157 v.reset(Op386MOVWstoreidx1) 7158 v.AuxInt = i - 1 7159 v.Aux = s 7160 v.AddArg(p) 7161 v.AddArg(idx) 7162 v.AddArg(w0) 7163 v.AddArg(mem) 7164 return true 7165 } 7166 return false 7167 } 7168 func rewriteValue386_Op386MOVLload_0(v *Value) bool { 7169 b := v.Block 7170 _ = b 7171 config := b.Func.Config 7172 _ = config 7173 // match: (MOVLload [off] {sym} ptr (MOVLstore [off2] {sym2} ptr2 x _)) 7174 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 7175 // result: x 7176 for { 7177 off := v.AuxInt 7178 sym := v.Aux 7179 _ = v.Args[1] 7180 ptr := v.Args[0] 7181 v_1 := v.Args[1] 7182 if v_1.Op != Op386MOVLstore { 7183 break 7184 } 7185 off2 := v_1.AuxInt 7186 sym2 := v_1.Aux 7187 _ = v_1.Args[2] 7188 ptr2 := v_1.Args[0] 7189 x := v_1.Args[1] 7190 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 7191 break 7192 } 7193 v.reset(OpCopy) 7194 v.Type = x.Type 7195 v.AddArg(x) 7196 return true 7197 } 7198 // match: (MOVLload [off1] {sym} (ADDLconst [off2] ptr) mem) 7199 // cond: is32Bit(off1+off2) 7200 // result: (MOVLload [off1+off2] {sym} ptr mem) 7201 for { 7202 off1 := v.AuxInt 7203 sym := v.Aux 7204 _ = v.Args[1] 7205 v_0 := v.Args[0] 7206 if v_0.Op != Op386ADDLconst { 7207 break 7208 } 7209 off2 := v_0.AuxInt 7210 ptr := v_0.Args[0] 7211 mem := v.Args[1] 7212 if !(is32Bit(off1 + off2)) { 7213 break 7214 } 7215 v.reset(Op386MOVLload) 7216 v.AuxInt = off1 + off2 7217 v.Aux = sym 7218 v.AddArg(ptr) 7219 v.AddArg(mem) 7220 return true 7221 } 7222 // match: (MOVLload [off1] {sym1} (LEAL [off2] {sym2} base) mem) 7223 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 7224 // result: (MOVLload [off1+off2] {mergeSym(sym1,sym2)} base mem) 7225 for { 7226 off1 := v.AuxInt 7227 sym1 := v.Aux 7228 _ = v.Args[1] 7229 v_0 := v.Args[0] 7230 if v_0.Op != Op386LEAL { 7231 break 7232 } 7233 off2 := v_0.AuxInt 7234 sym2 := v_0.Aux 7235 base := v_0.Args[0] 7236 mem := v.Args[1] 7237 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 7238 break 7239 } 7240 v.reset(Op386MOVLload) 7241 v.AuxInt = off1 + off2 7242 v.Aux = mergeSym(sym1, sym2) 7243 v.AddArg(base) 7244 v.AddArg(mem) 7245 return true 7246 } 7247 // match: (MOVLload [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) mem) 7248 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 7249 // result: (MOVLloadidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem) 7250 for { 7251 off1 := v.AuxInt 7252 sym1 := v.Aux 7253 _ = v.Args[1] 7254 v_0 := v.Args[0] 7255 if v_0.Op != Op386LEAL1 { 7256 break 7257 } 7258 off2 := v_0.AuxInt 7259 sym2 := v_0.Aux 7260 _ = v_0.Args[1] 7261 ptr := v_0.Args[0] 7262 idx := v_0.Args[1] 7263 mem := v.Args[1] 7264 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 7265 break 7266 } 7267 v.reset(Op386MOVLloadidx1) 7268 v.AuxInt = off1 + off2 7269 v.Aux = mergeSym(sym1, sym2) 7270 v.AddArg(ptr) 7271 v.AddArg(idx) 7272 v.AddArg(mem) 7273 return true 7274 } 7275 // match: (MOVLload [off1] {sym1} (LEAL4 [off2] {sym2} ptr idx) mem) 7276 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 7277 // result: (MOVLloadidx4 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem) 7278 for { 7279 off1 := v.AuxInt 7280 sym1 := v.Aux 7281 _ = v.Args[1] 7282 v_0 := v.Args[0] 7283 if v_0.Op != Op386LEAL4 { 7284 break 7285 } 7286 off2 := v_0.AuxInt 7287 sym2 := v_0.Aux 7288 _ = v_0.Args[1] 7289 ptr := v_0.Args[0] 7290 idx := v_0.Args[1] 7291 mem := v.Args[1] 7292 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 7293 break 7294 } 7295 v.reset(Op386MOVLloadidx4) 7296 v.AuxInt = off1 + off2 7297 v.Aux = mergeSym(sym1, sym2) 7298 v.AddArg(ptr) 7299 v.AddArg(idx) 7300 v.AddArg(mem) 7301 return true 7302 } 7303 // match: (MOVLload [off] {sym} (ADDL ptr idx) mem) 7304 // cond: ptr.Op != OpSB 7305 // result: (MOVLloadidx1 [off] {sym} ptr idx mem) 7306 for { 7307 off := v.AuxInt 7308 sym := v.Aux 7309 _ = v.Args[1] 7310 v_0 := v.Args[0] 7311 if v_0.Op != Op386ADDL { 7312 break 7313 } 7314 _ = v_0.Args[1] 7315 ptr := v_0.Args[0] 7316 idx := v_0.Args[1] 7317 mem := v.Args[1] 7318 if !(ptr.Op != OpSB) { 7319 break 7320 } 7321 v.reset(Op386MOVLloadidx1) 7322 v.AuxInt = off 7323 v.Aux = sym 7324 v.AddArg(ptr) 7325 v.AddArg(idx) 7326 v.AddArg(mem) 7327 return true 7328 } 7329 // match: (MOVLload [off] {sym} (SB) _) 7330 // cond: symIsRO(sym) 7331 // result: (MOVLconst [int64(int32(read32(sym, off, config.BigEndian)))]) 7332 for { 7333 off := v.AuxInt 7334 sym := v.Aux 7335 _ = v.Args[1] 7336 v_0 := v.Args[0] 7337 if v_0.Op != OpSB { 7338 break 7339 } 7340 if !(symIsRO(sym)) { 7341 break 7342 } 7343 v.reset(Op386MOVLconst) 7344 v.AuxInt = int64(int32(read32(sym, off, config.BigEndian))) 7345 return true 7346 } 7347 return false 7348 } 7349 func rewriteValue386_Op386MOVLloadidx1_0(v *Value) bool { 7350 // match: (MOVLloadidx1 [c] {sym} ptr (SHLLconst [2] idx) mem) 7351 // cond: 7352 // result: (MOVLloadidx4 [c] {sym} ptr idx mem) 7353 for { 7354 c := v.AuxInt 7355 sym := v.Aux 7356 _ = v.Args[2] 7357 ptr := v.Args[0] 7358 v_1 := v.Args[1] 7359 if v_1.Op != Op386SHLLconst { 7360 break 7361 } 7362 if v_1.AuxInt != 2 { 7363 break 7364 } 7365 idx := v_1.Args[0] 7366 mem := v.Args[2] 7367 v.reset(Op386MOVLloadidx4) 7368 v.AuxInt = c 7369 v.Aux = sym 7370 v.AddArg(ptr) 7371 v.AddArg(idx) 7372 v.AddArg(mem) 7373 return true 7374 } 7375 // match: (MOVLloadidx1 [c] {sym} (SHLLconst [2] idx) ptr mem) 7376 // cond: 7377 // result: (MOVLloadidx4 [c] {sym} ptr idx mem) 7378 for { 7379 c := v.AuxInt 7380 sym := v.Aux 7381 _ = v.Args[2] 7382 v_0 := v.Args[0] 7383 if v_0.Op != Op386SHLLconst { 7384 break 7385 } 7386 if v_0.AuxInt != 2 { 7387 break 7388 } 7389 idx := v_0.Args[0] 7390 ptr := v.Args[1] 7391 mem := v.Args[2] 7392 v.reset(Op386MOVLloadidx4) 7393 v.AuxInt = c 7394 v.Aux = sym 7395 v.AddArg(ptr) 7396 v.AddArg(idx) 7397 v.AddArg(mem) 7398 return true 7399 } 7400 // match: (MOVLloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem) 7401 // cond: 7402 // result: (MOVLloadidx1 [int64(int32(c+d))] {sym} ptr idx mem) 7403 for { 7404 c := v.AuxInt 7405 sym := v.Aux 7406 _ = v.Args[2] 7407 v_0 := v.Args[0] 7408 if v_0.Op != Op386ADDLconst { 7409 break 7410 } 7411 d := v_0.AuxInt 7412 ptr := v_0.Args[0] 7413 idx := v.Args[1] 7414 mem := v.Args[2] 7415 v.reset(Op386MOVLloadidx1) 7416 v.AuxInt = int64(int32(c + d)) 7417 v.Aux = sym 7418 v.AddArg(ptr) 7419 v.AddArg(idx) 7420 v.AddArg(mem) 7421 return true 7422 } 7423 // match: (MOVLloadidx1 [c] {sym} idx (ADDLconst [d] ptr) mem) 7424 // cond: 7425 // result: (MOVLloadidx1 [int64(int32(c+d))] {sym} ptr idx mem) 7426 for { 7427 c := v.AuxInt 7428 sym := v.Aux 7429 _ = v.Args[2] 7430 idx := v.Args[0] 7431 v_1 := v.Args[1] 7432 if v_1.Op != Op386ADDLconst { 7433 break 7434 } 7435 d := v_1.AuxInt 7436 ptr := v_1.Args[0] 7437 mem := v.Args[2] 7438 v.reset(Op386MOVLloadidx1) 7439 v.AuxInt = int64(int32(c + d)) 7440 v.Aux = sym 7441 v.AddArg(ptr) 7442 v.AddArg(idx) 7443 v.AddArg(mem) 7444 return true 7445 } 7446 // match: (MOVLloadidx1 [c] {sym} ptr (ADDLconst [d] idx) mem) 7447 // cond: 7448 // result: (MOVLloadidx1 [int64(int32(c+d))] {sym} ptr idx mem) 7449 for { 7450 c := v.AuxInt 7451 sym := v.Aux 7452 _ = v.Args[2] 7453 ptr := v.Args[0] 7454 v_1 := v.Args[1] 7455 if v_1.Op != Op386ADDLconst { 7456 break 7457 } 7458 d := v_1.AuxInt 7459 idx := v_1.Args[0] 7460 mem := v.Args[2] 7461 v.reset(Op386MOVLloadidx1) 7462 v.AuxInt = int64(int32(c + d)) 7463 v.Aux = sym 7464 v.AddArg(ptr) 7465 v.AddArg(idx) 7466 v.AddArg(mem) 7467 return true 7468 } 7469 // match: (MOVLloadidx1 [c] {sym} (ADDLconst [d] idx) ptr mem) 7470 // cond: 7471 // result: (MOVLloadidx1 [int64(int32(c+d))] {sym} ptr idx mem) 7472 for { 7473 c := v.AuxInt 7474 sym := v.Aux 7475 _ = v.Args[2] 7476 v_0 := v.Args[0] 7477 if v_0.Op != Op386ADDLconst { 7478 break 7479 } 7480 d := v_0.AuxInt 7481 idx := v_0.Args[0] 7482 ptr := v.Args[1] 7483 mem := v.Args[2] 7484 v.reset(Op386MOVLloadidx1) 7485 v.AuxInt = int64(int32(c + d)) 7486 v.Aux = sym 7487 v.AddArg(ptr) 7488 v.AddArg(idx) 7489 v.AddArg(mem) 7490 return true 7491 } 7492 return false 7493 } 7494 func rewriteValue386_Op386MOVLloadidx4_0(v *Value) bool { 7495 // match: (MOVLloadidx4 [c] {sym} (ADDLconst [d] ptr) idx mem) 7496 // cond: 7497 // result: (MOVLloadidx4 [int64(int32(c+d))] {sym} ptr idx mem) 7498 for { 7499 c := v.AuxInt 7500 sym := v.Aux 7501 _ = v.Args[2] 7502 v_0 := v.Args[0] 7503 if v_0.Op != Op386ADDLconst { 7504 break 7505 } 7506 d := v_0.AuxInt 7507 ptr := v_0.Args[0] 7508 idx := v.Args[1] 7509 mem := v.Args[2] 7510 v.reset(Op386MOVLloadidx4) 7511 v.AuxInt = int64(int32(c + d)) 7512 v.Aux = sym 7513 v.AddArg(ptr) 7514 v.AddArg(idx) 7515 v.AddArg(mem) 7516 return true 7517 } 7518 // match: (MOVLloadidx4 [c] {sym} ptr (ADDLconst [d] idx) mem) 7519 // cond: 7520 // result: (MOVLloadidx4 [int64(int32(c+4*d))] {sym} ptr idx mem) 7521 for { 7522 c := v.AuxInt 7523 sym := v.Aux 7524 _ = v.Args[2] 7525 ptr := v.Args[0] 7526 v_1 := v.Args[1] 7527 if v_1.Op != Op386ADDLconst { 7528 break 7529 } 7530 d := v_1.AuxInt 7531 idx := v_1.Args[0] 7532 mem := v.Args[2] 7533 v.reset(Op386MOVLloadidx4) 7534 v.AuxInt = int64(int32(c + 4*d)) 7535 v.Aux = sym 7536 v.AddArg(ptr) 7537 v.AddArg(idx) 7538 v.AddArg(mem) 7539 return true 7540 } 7541 return false 7542 } 7543 func rewriteValue386_Op386MOVLstore_0(v *Value) bool { 7544 b := v.Block 7545 _ = b 7546 config := b.Func.Config 7547 _ = config 7548 // match: (MOVLstore [off1] {sym} (ADDLconst [off2] ptr) val mem) 7549 // cond: is32Bit(off1+off2) 7550 // result: (MOVLstore [off1+off2] {sym} ptr val mem) 7551 for { 7552 off1 := v.AuxInt 7553 sym := v.Aux 7554 _ = v.Args[2] 7555 v_0 := v.Args[0] 7556 if v_0.Op != Op386ADDLconst { 7557 break 7558 } 7559 off2 := v_0.AuxInt 7560 ptr := v_0.Args[0] 7561 val := v.Args[1] 7562 mem := v.Args[2] 7563 if !(is32Bit(off1 + off2)) { 7564 break 7565 } 7566 v.reset(Op386MOVLstore) 7567 v.AuxInt = off1 + off2 7568 v.Aux = sym 7569 v.AddArg(ptr) 7570 v.AddArg(val) 7571 v.AddArg(mem) 7572 return true 7573 } 7574 // match: (MOVLstore [off] {sym} ptr (MOVLconst [c]) mem) 7575 // cond: validOff(off) 7576 // result: (MOVLstoreconst [makeValAndOff(int64(int32(c)),off)] {sym} ptr mem) 7577 for { 7578 off := v.AuxInt 7579 sym := v.Aux 7580 _ = v.Args[2] 7581 ptr := v.Args[0] 7582 v_1 := v.Args[1] 7583 if v_1.Op != Op386MOVLconst { 7584 break 7585 } 7586 c := v_1.AuxInt 7587 mem := v.Args[2] 7588 if !(validOff(off)) { 7589 break 7590 } 7591 v.reset(Op386MOVLstoreconst) 7592 v.AuxInt = makeValAndOff(int64(int32(c)), off) 7593 v.Aux = sym 7594 v.AddArg(ptr) 7595 v.AddArg(mem) 7596 return true 7597 } 7598 // match: (MOVLstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem) 7599 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 7600 // result: (MOVLstore [off1+off2] {mergeSym(sym1,sym2)} base val mem) 7601 for { 7602 off1 := v.AuxInt 7603 sym1 := v.Aux 7604 _ = v.Args[2] 7605 v_0 := v.Args[0] 7606 if v_0.Op != Op386LEAL { 7607 break 7608 } 7609 off2 := v_0.AuxInt 7610 sym2 := v_0.Aux 7611 base := v_0.Args[0] 7612 val := v.Args[1] 7613 mem := v.Args[2] 7614 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 7615 break 7616 } 7617 v.reset(Op386MOVLstore) 7618 v.AuxInt = off1 + off2 7619 v.Aux = mergeSym(sym1, sym2) 7620 v.AddArg(base) 7621 v.AddArg(val) 7622 v.AddArg(mem) 7623 return true 7624 } 7625 // match: (MOVLstore [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) val mem) 7626 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 7627 // result: (MOVLstoreidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem) 7628 for { 7629 off1 := v.AuxInt 7630 sym1 := v.Aux 7631 _ = v.Args[2] 7632 v_0 := v.Args[0] 7633 if v_0.Op != Op386LEAL1 { 7634 break 7635 } 7636 off2 := v_0.AuxInt 7637 sym2 := v_0.Aux 7638 _ = v_0.Args[1] 7639 ptr := v_0.Args[0] 7640 idx := v_0.Args[1] 7641 val := v.Args[1] 7642 mem := v.Args[2] 7643 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 7644 break 7645 } 7646 v.reset(Op386MOVLstoreidx1) 7647 v.AuxInt = off1 + off2 7648 v.Aux = mergeSym(sym1, sym2) 7649 v.AddArg(ptr) 7650 v.AddArg(idx) 7651 v.AddArg(val) 7652 v.AddArg(mem) 7653 return true 7654 } 7655 // match: (MOVLstore [off1] {sym1} (LEAL4 [off2] {sym2} ptr idx) val mem) 7656 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 7657 // result: (MOVLstoreidx4 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem) 7658 for { 7659 off1 := v.AuxInt 7660 sym1 := v.Aux 7661 _ = v.Args[2] 7662 v_0 := v.Args[0] 7663 if v_0.Op != Op386LEAL4 { 7664 break 7665 } 7666 off2 := v_0.AuxInt 7667 sym2 := v_0.Aux 7668 _ = v_0.Args[1] 7669 ptr := v_0.Args[0] 7670 idx := v_0.Args[1] 7671 val := v.Args[1] 7672 mem := v.Args[2] 7673 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 7674 break 7675 } 7676 v.reset(Op386MOVLstoreidx4) 7677 v.AuxInt = off1 + off2 7678 v.Aux = mergeSym(sym1, sym2) 7679 v.AddArg(ptr) 7680 v.AddArg(idx) 7681 v.AddArg(val) 7682 v.AddArg(mem) 7683 return true 7684 } 7685 // match: (MOVLstore [off] {sym} (ADDL ptr idx) val mem) 7686 // cond: ptr.Op != OpSB 7687 // result: (MOVLstoreidx1 [off] {sym} ptr idx val mem) 7688 for { 7689 off := v.AuxInt 7690 sym := v.Aux 7691 _ = v.Args[2] 7692 v_0 := v.Args[0] 7693 if v_0.Op != Op386ADDL { 7694 break 7695 } 7696 _ = v_0.Args[1] 7697 ptr := v_0.Args[0] 7698 idx := v_0.Args[1] 7699 val := v.Args[1] 7700 mem := v.Args[2] 7701 if !(ptr.Op != OpSB) { 7702 break 7703 } 7704 v.reset(Op386MOVLstoreidx1) 7705 v.AuxInt = off 7706 v.Aux = sym 7707 v.AddArg(ptr) 7708 v.AddArg(idx) 7709 v.AddArg(val) 7710 v.AddArg(mem) 7711 return true 7712 } 7713 // match: (MOVLstore {sym} [off] ptr y:(ADDLload x [off] {sym} ptr mem) mem) 7714 // cond: y.Uses==1 && clobber(y) 7715 // result: (ADDLmodify [off] {sym} ptr x mem) 7716 for { 7717 off := v.AuxInt 7718 sym := v.Aux 7719 _ = v.Args[2] 7720 ptr := v.Args[0] 7721 y := v.Args[1] 7722 if y.Op != Op386ADDLload { 7723 break 7724 } 7725 if y.AuxInt != off { 7726 break 7727 } 7728 if y.Aux != sym { 7729 break 7730 } 7731 _ = y.Args[2] 7732 x := y.Args[0] 7733 if ptr != y.Args[1] { 7734 break 7735 } 7736 mem := y.Args[2] 7737 if mem != v.Args[2] { 7738 break 7739 } 7740 if !(y.Uses == 1 && clobber(y)) { 7741 break 7742 } 7743 v.reset(Op386ADDLmodify) 7744 v.AuxInt = off 7745 v.Aux = sym 7746 v.AddArg(ptr) 7747 v.AddArg(x) 7748 v.AddArg(mem) 7749 return true 7750 } 7751 // match: (MOVLstore {sym} [off] ptr y:(ANDLload x [off] {sym} ptr mem) mem) 7752 // cond: y.Uses==1 && clobber(y) 7753 // result: (ANDLmodify [off] {sym} ptr x mem) 7754 for { 7755 off := v.AuxInt 7756 sym := v.Aux 7757 _ = v.Args[2] 7758 ptr := v.Args[0] 7759 y := v.Args[1] 7760 if y.Op != Op386ANDLload { 7761 break 7762 } 7763 if y.AuxInt != off { 7764 break 7765 } 7766 if y.Aux != sym { 7767 break 7768 } 7769 _ = y.Args[2] 7770 x := y.Args[0] 7771 if ptr != y.Args[1] { 7772 break 7773 } 7774 mem := y.Args[2] 7775 if mem != v.Args[2] { 7776 break 7777 } 7778 if !(y.Uses == 1 && clobber(y)) { 7779 break 7780 } 7781 v.reset(Op386ANDLmodify) 7782 v.AuxInt = off 7783 v.Aux = sym 7784 v.AddArg(ptr) 7785 v.AddArg(x) 7786 v.AddArg(mem) 7787 return true 7788 } 7789 // match: (MOVLstore {sym} [off] ptr y:(ORLload x [off] {sym} ptr mem) mem) 7790 // cond: y.Uses==1 && clobber(y) 7791 // result: (ORLmodify [off] {sym} ptr x mem) 7792 for { 7793 off := v.AuxInt 7794 sym := v.Aux 7795 _ = v.Args[2] 7796 ptr := v.Args[0] 7797 y := v.Args[1] 7798 if y.Op != Op386ORLload { 7799 break 7800 } 7801 if y.AuxInt != off { 7802 break 7803 } 7804 if y.Aux != sym { 7805 break 7806 } 7807 _ = y.Args[2] 7808 x := y.Args[0] 7809 if ptr != y.Args[1] { 7810 break 7811 } 7812 mem := y.Args[2] 7813 if mem != v.Args[2] { 7814 break 7815 } 7816 if !(y.Uses == 1 && clobber(y)) { 7817 break 7818 } 7819 v.reset(Op386ORLmodify) 7820 v.AuxInt = off 7821 v.Aux = sym 7822 v.AddArg(ptr) 7823 v.AddArg(x) 7824 v.AddArg(mem) 7825 return true 7826 } 7827 // match: (MOVLstore {sym} [off] ptr y:(XORLload x [off] {sym} ptr mem) mem) 7828 // cond: y.Uses==1 && clobber(y) 7829 // result: (XORLmodify [off] {sym} ptr x mem) 7830 for { 7831 off := v.AuxInt 7832 sym := v.Aux 7833 _ = v.Args[2] 7834 ptr := v.Args[0] 7835 y := v.Args[1] 7836 if y.Op != Op386XORLload { 7837 break 7838 } 7839 if y.AuxInt != off { 7840 break 7841 } 7842 if y.Aux != sym { 7843 break 7844 } 7845 _ = y.Args[2] 7846 x := y.Args[0] 7847 if ptr != y.Args[1] { 7848 break 7849 } 7850 mem := y.Args[2] 7851 if mem != v.Args[2] { 7852 break 7853 } 7854 if !(y.Uses == 1 && clobber(y)) { 7855 break 7856 } 7857 v.reset(Op386XORLmodify) 7858 v.AuxInt = off 7859 v.Aux = sym 7860 v.AddArg(ptr) 7861 v.AddArg(x) 7862 v.AddArg(mem) 7863 return true 7864 } 7865 return false 7866 } 7867 func rewriteValue386_Op386MOVLstore_10(v *Value) bool { 7868 // match: (MOVLstore {sym} [off] ptr y:(ADDL l:(MOVLload [off] {sym} ptr mem) x) mem) 7869 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 7870 // result: (ADDLmodify [off] {sym} ptr x mem) 7871 for { 7872 off := v.AuxInt 7873 sym := v.Aux 7874 _ = v.Args[2] 7875 ptr := v.Args[0] 7876 y := v.Args[1] 7877 if y.Op != Op386ADDL { 7878 break 7879 } 7880 _ = y.Args[1] 7881 l := y.Args[0] 7882 if l.Op != Op386MOVLload { 7883 break 7884 } 7885 if l.AuxInt != off { 7886 break 7887 } 7888 if l.Aux != sym { 7889 break 7890 } 7891 _ = l.Args[1] 7892 if ptr != l.Args[0] { 7893 break 7894 } 7895 mem := l.Args[1] 7896 x := y.Args[1] 7897 if mem != v.Args[2] { 7898 break 7899 } 7900 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 7901 break 7902 } 7903 v.reset(Op386ADDLmodify) 7904 v.AuxInt = off 7905 v.Aux = sym 7906 v.AddArg(ptr) 7907 v.AddArg(x) 7908 v.AddArg(mem) 7909 return true 7910 } 7911 // match: (MOVLstore {sym} [off] ptr y:(ADDL x l:(MOVLload [off] {sym} ptr mem)) mem) 7912 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 7913 // result: (ADDLmodify [off] {sym} ptr x mem) 7914 for { 7915 off := v.AuxInt 7916 sym := v.Aux 7917 _ = v.Args[2] 7918 ptr := v.Args[0] 7919 y := v.Args[1] 7920 if y.Op != Op386ADDL { 7921 break 7922 } 7923 _ = y.Args[1] 7924 x := y.Args[0] 7925 l := y.Args[1] 7926 if l.Op != Op386MOVLload { 7927 break 7928 } 7929 if l.AuxInt != off { 7930 break 7931 } 7932 if l.Aux != sym { 7933 break 7934 } 7935 _ = l.Args[1] 7936 if ptr != l.Args[0] { 7937 break 7938 } 7939 mem := l.Args[1] 7940 if mem != v.Args[2] { 7941 break 7942 } 7943 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 7944 break 7945 } 7946 v.reset(Op386ADDLmodify) 7947 v.AuxInt = off 7948 v.Aux = sym 7949 v.AddArg(ptr) 7950 v.AddArg(x) 7951 v.AddArg(mem) 7952 return true 7953 } 7954 // match: (MOVLstore {sym} [off] ptr y:(SUBL l:(MOVLload [off] {sym} ptr mem) x) mem) 7955 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 7956 // result: (SUBLmodify [off] {sym} ptr x mem) 7957 for { 7958 off := v.AuxInt 7959 sym := v.Aux 7960 _ = v.Args[2] 7961 ptr := v.Args[0] 7962 y := v.Args[1] 7963 if y.Op != Op386SUBL { 7964 break 7965 } 7966 _ = y.Args[1] 7967 l := y.Args[0] 7968 if l.Op != Op386MOVLload { 7969 break 7970 } 7971 if l.AuxInt != off { 7972 break 7973 } 7974 if l.Aux != sym { 7975 break 7976 } 7977 _ = l.Args[1] 7978 if ptr != l.Args[0] { 7979 break 7980 } 7981 mem := l.Args[1] 7982 x := y.Args[1] 7983 if mem != v.Args[2] { 7984 break 7985 } 7986 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 7987 break 7988 } 7989 v.reset(Op386SUBLmodify) 7990 v.AuxInt = off 7991 v.Aux = sym 7992 v.AddArg(ptr) 7993 v.AddArg(x) 7994 v.AddArg(mem) 7995 return true 7996 } 7997 // match: (MOVLstore {sym} [off] ptr y:(ANDL l:(MOVLload [off] {sym} ptr mem) x) mem) 7998 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 7999 // result: (ANDLmodify [off] {sym} ptr x mem) 8000 for { 8001 off := v.AuxInt 8002 sym := v.Aux 8003 _ = v.Args[2] 8004 ptr := v.Args[0] 8005 y := v.Args[1] 8006 if y.Op != Op386ANDL { 8007 break 8008 } 8009 _ = y.Args[1] 8010 l := y.Args[0] 8011 if l.Op != Op386MOVLload { 8012 break 8013 } 8014 if l.AuxInt != off { 8015 break 8016 } 8017 if l.Aux != sym { 8018 break 8019 } 8020 _ = l.Args[1] 8021 if ptr != l.Args[0] { 8022 break 8023 } 8024 mem := l.Args[1] 8025 x := y.Args[1] 8026 if mem != v.Args[2] { 8027 break 8028 } 8029 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 8030 break 8031 } 8032 v.reset(Op386ANDLmodify) 8033 v.AuxInt = off 8034 v.Aux = sym 8035 v.AddArg(ptr) 8036 v.AddArg(x) 8037 v.AddArg(mem) 8038 return true 8039 } 8040 // match: (MOVLstore {sym} [off] ptr y:(ANDL x l:(MOVLload [off] {sym} ptr mem)) mem) 8041 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 8042 // result: (ANDLmodify [off] {sym} ptr x mem) 8043 for { 8044 off := v.AuxInt 8045 sym := v.Aux 8046 _ = v.Args[2] 8047 ptr := v.Args[0] 8048 y := v.Args[1] 8049 if y.Op != Op386ANDL { 8050 break 8051 } 8052 _ = y.Args[1] 8053 x := y.Args[0] 8054 l := y.Args[1] 8055 if l.Op != Op386MOVLload { 8056 break 8057 } 8058 if l.AuxInt != off { 8059 break 8060 } 8061 if l.Aux != sym { 8062 break 8063 } 8064 _ = l.Args[1] 8065 if ptr != l.Args[0] { 8066 break 8067 } 8068 mem := l.Args[1] 8069 if mem != v.Args[2] { 8070 break 8071 } 8072 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 8073 break 8074 } 8075 v.reset(Op386ANDLmodify) 8076 v.AuxInt = off 8077 v.Aux = sym 8078 v.AddArg(ptr) 8079 v.AddArg(x) 8080 v.AddArg(mem) 8081 return true 8082 } 8083 // match: (MOVLstore {sym} [off] ptr y:(ORL l:(MOVLload [off] {sym} ptr mem) x) mem) 8084 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 8085 // result: (ORLmodify [off] {sym} ptr x mem) 8086 for { 8087 off := v.AuxInt 8088 sym := v.Aux 8089 _ = v.Args[2] 8090 ptr := v.Args[0] 8091 y := v.Args[1] 8092 if y.Op != Op386ORL { 8093 break 8094 } 8095 _ = y.Args[1] 8096 l := y.Args[0] 8097 if l.Op != Op386MOVLload { 8098 break 8099 } 8100 if l.AuxInt != off { 8101 break 8102 } 8103 if l.Aux != sym { 8104 break 8105 } 8106 _ = l.Args[1] 8107 if ptr != l.Args[0] { 8108 break 8109 } 8110 mem := l.Args[1] 8111 x := y.Args[1] 8112 if mem != v.Args[2] { 8113 break 8114 } 8115 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 8116 break 8117 } 8118 v.reset(Op386ORLmodify) 8119 v.AuxInt = off 8120 v.Aux = sym 8121 v.AddArg(ptr) 8122 v.AddArg(x) 8123 v.AddArg(mem) 8124 return true 8125 } 8126 // match: (MOVLstore {sym} [off] ptr y:(ORL x l:(MOVLload [off] {sym} ptr mem)) mem) 8127 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 8128 // result: (ORLmodify [off] {sym} ptr x mem) 8129 for { 8130 off := v.AuxInt 8131 sym := v.Aux 8132 _ = v.Args[2] 8133 ptr := v.Args[0] 8134 y := v.Args[1] 8135 if y.Op != Op386ORL { 8136 break 8137 } 8138 _ = y.Args[1] 8139 x := y.Args[0] 8140 l := y.Args[1] 8141 if l.Op != Op386MOVLload { 8142 break 8143 } 8144 if l.AuxInt != off { 8145 break 8146 } 8147 if l.Aux != sym { 8148 break 8149 } 8150 _ = l.Args[1] 8151 if ptr != l.Args[0] { 8152 break 8153 } 8154 mem := l.Args[1] 8155 if mem != v.Args[2] { 8156 break 8157 } 8158 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 8159 break 8160 } 8161 v.reset(Op386ORLmodify) 8162 v.AuxInt = off 8163 v.Aux = sym 8164 v.AddArg(ptr) 8165 v.AddArg(x) 8166 v.AddArg(mem) 8167 return true 8168 } 8169 // match: (MOVLstore {sym} [off] ptr y:(XORL l:(MOVLload [off] {sym} ptr mem) x) mem) 8170 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 8171 // result: (XORLmodify [off] {sym} ptr x mem) 8172 for { 8173 off := v.AuxInt 8174 sym := v.Aux 8175 _ = v.Args[2] 8176 ptr := v.Args[0] 8177 y := v.Args[1] 8178 if y.Op != Op386XORL { 8179 break 8180 } 8181 _ = y.Args[1] 8182 l := y.Args[0] 8183 if l.Op != Op386MOVLload { 8184 break 8185 } 8186 if l.AuxInt != off { 8187 break 8188 } 8189 if l.Aux != sym { 8190 break 8191 } 8192 _ = l.Args[1] 8193 if ptr != l.Args[0] { 8194 break 8195 } 8196 mem := l.Args[1] 8197 x := y.Args[1] 8198 if mem != v.Args[2] { 8199 break 8200 } 8201 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 8202 break 8203 } 8204 v.reset(Op386XORLmodify) 8205 v.AuxInt = off 8206 v.Aux = sym 8207 v.AddArg(ptr) 8208 v.AddArg(x) 8209 v.AddArg(mem) 8210 return true 8211 } 8212 // match: (MOVLstore {sym} [off] ptr y:(XORL x l:(MOVLload [off] {sym} ptr mem)) mem) 8213 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 8214 // result: (XORLmodify [off] {sym} ptr x mem) 8215 for { 8216 off := v.AuxInt 8217 sym := v.Aux 8218 _ = v.Args[2] 8219 ptr := v.Args[0] 8220 y := v.Args[1] 8221 if y.Op != Op386XORL { 8222 break 8223 } 8224 _ = y.Args[1] 8225 x := y.Args[0] 8226 l := y.Args[1] 8227 if l.Op != Op386MOVLload { 8228 break 8229 } 8230 if l.AuxInt != off { 8231 break 8232 } 8233 if l.Aux != sym { 8234 break 8235 } 8236 _ = l.Args[1] 8237 if ptr != l.Args[0] { 8238 break 8239 } 8240 mem := l.Args[1] 8241 if mem != v.Args[2] { 8242 break 8243 } 8244 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 8245 break 8246 } 8247 v.reset(Op386XORLmodify) 8248 v.AuxInt = off 8249 v.Aux = sym 8250 v.AddArg(ptr) 8251 v.AddArg(x) 8252 v.AddArg(mem) 8253 return true 8254 } 8255 // match: (MOVLstore {sym} [off] ptr y:(ADDLconst [c] l:(MOVLload [off] {sym} ptr mem)) mem) 8256 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) && validValAndOff(c,off) 8257 // result: (ADDLconstmodify [makeValAndOff(c,off)] {sym} ptr mem) 8258 for { 8259 off := v.AuxInt 8260 sym := v.Aux 8261 _ = v.Args[2] 8262 ptr := v.Args[0] 8263 y := v.Args[1] 8264 if y.Op != Op386ADDLconst { 8265 break 8266 } 8267 c := y.AuxInt 8268 l := y.Args[0] 8269 if l.Op != Op386MOVLload { 8270 break 8271 } 8272 if l.AuxInt != off { 8273 break 8274 } 8275 if l.Aux != sym { 8276 break 8277 } 8278 _ = l.Args[1] 8279 if ptr != l.Args[0] { 8280 break 8281 } 8282 mem := l.Args[1] 8283 if mem != v.Args[2] { 8284 break 8285 } 8286 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l) && validValAndOff(c, off)) { 8287 break 8288 } 8289 v.reset(Op386ADDLconstmodify) 8290 v.AuxInt = makeValAndOff(c, off) 8291 v.Aux = sym 8292 v.AddArg(ptr) 8293 v.AddArg(mem) 8294 return true 8295 } 8296 return false 8297 } 8298 func rewriteValue386_Op386MOVLstore_20(v *Value) bool { 8299 // match: (MOVLstore {sym} [off] ptr y:(ANDLconst [c] l:(MOVLload [off] {sym} ptr mem)) mem) 8300 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) && validValAndOff(c,off) 8301 // result: (ANDLconstmodify [makeValAndOff(c,off)] {sym} ptr mem) 8302 for { 8303 off := v.AuxInt 8304 sym := v.Aux 8305 _ = v.Args[2] 8306 ptr := v.Args[0] 8307 y := v.Args[1] 8308 if y.Op != Op386ANDLconst { 8309 break 8310 } 8311 c := y.AuxInt 8312 l := y.Args[0] 8313 if l.Op != Op386MOVLload { 8314 break 8315 } 8316 if l.AuxInt != off { 8317 break 8318 } 8319 if l.Aux != sym { 8320 break 8321 } 8322 _ = l.Args[1] 8323 if ptr != l.Args[0] { 8324 break 8325 } 8326 mem := l.Args[1] 8327 if mem != v.Args[2] { 8328 break 8329 } 8330 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l) && validValAndOff(c, off)) { 8331 break 8332 } 8333 v.reset(Op386ANDLconstmodify) 8334 v.AuxInt = makeValAndOff(c, off) 8335 v.Aux = sym 8336 v.AddArg(ptr) 8337 v.AddArg(mem) 8338 return true 8339 } 8340 // match: (MOVLstore {sym} [off] ptr y:(ORLconst [c] l:(MOVLload [off] {sym} ptr mem)) mem) 8341 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) && validValAndOff(c,off) 8342 // result: (ORLconstmodify [makeValAndOff(c,off)] {sym} ptr mem) 8343 for { 8344 off := v.AuxInt 8345 sym := v.Aux 8346 _ = v.Args[2] 8347 ptr := v.Args[0] 8348 y := v.Args[1] 8349 if y.Op != Op386ORLconst { 8350 break 8351 } 8352 c := y.AuxInt 8353 l := y.Args[0] 8354 if l.Op != Op386MOVLload { 8355 break 8356 } 8357 if l.AuxInt != off { 8358 break 8359 } 8360 if l.Aux != sym { 8361 break 8362 } 8363 _ = l.Args[1] 8364 if ptr != l.Args[0] { 8365 break 8366 } 8367 mem := l.Args[1] 8368 if mem != v.Args[2] { 8369 break 8370 } 8371 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l) && validValAndOff(c, off)) { 8372 break 8373 } 8374 v.reset(Op386ORLconstmodify) 8375 v.AuxInt = makeValAndOff(c, off) 8376 v.Aux = sym 8377 v.AddArg(ptr) 8378 v.AddArg(mem) 8379 return true 8380 } 8381 // match: (MOVLstore {sym} [off] ptr y:(XORLconst [c] l:(MOVLload [off] {sym} ptr mem)) mem) 8382 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) && validValAndOff(c,off) 8383 // result: (XORLconstmodify [makeValAndOff(c,off)] {sym} ptr mem) 8384 for { 8385 off := v.AuxInt 8386 sym := v.Aux 8387 _ = v.Args[2] 8388 ptr := v.Args[0] 8389 y := v.Args[1] 8390 if y.Op != Op386XORLconst { 8391 break 8392 } 8393 c := y.AuxInt 8394 l := y.Args[0] 8395 if l.Op != Op386MOVLload { 8396 break 8397 } 8398 if l.AuxInt != off { 8399 break 8400 } 8401 if l.Aux != sym { 8402 break 8403 } 8404 _ = l.Args[1] 8405 if ptr != l.Args[0] { 8406 break 8407 } 8408 mem := l.Args[1] 8409 if mem != v.Args[2] { 8410 break 8411 } 8412 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l) && validValAndOff(c, off)) { 8413 break 8414 } 8415 v.reset(Op386XORLconstmodify) 8416 v.AuxInt = makeValAndOff(c, off) 8417 v.Aux = sym 8418 v.AddArg(ptr) 8419 v.AddArg(mem) 8420 return true 8421 } 8422 return false 8423 } 8424 func rewriteValue386_Op386MOVLstoreconst_0(v *Value) bool { 8425 b := v.Block 8426 _ = b 8427 config := b.Func.Config 8428 _ = config 8429 // match: (MOVLstoreconst [sc] {s} (ADDLconst [off] ptr) mem) 8430 // cond: ValAndOff(sc).canAdd(off) 8431 // result: (MOVLstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) 8432 for { 8433 sc := v.AuxInt 8434 s := v.Aux 8435 _ = v.Args[1] 8436 v_0 := v.Args[0] 8437 if v_0.Op != Op386ADDLconst { 8438 break 8439 } 8440 off := v_0.AuxInt 8441 ptr := v_0.Args[0] 8442 mem := v.Args[1] 8443 if !(ValAndOff(sc).canAdd(off)) { 8444 break 8445 } 8446 v.reset(Op386MOVLstoreconst) 8447 v.AuxInt = ValAndOff(sc).add(off) 8448 v.Aux = s 8449 v.AddArg(ptr) 8450 v.AddArg(mem) 8451 return true 8452 } 8453 // match: (MOVLstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem) 8454 // cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) && (ptr.Op != OpSB || !config.ctxt.Flag_shared) 8455 // result: (MOVLstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) 8456 for { 8457 sc := v.AuxInt 8458 sym1 := v.Aux 8459 _ = v.Args[1] 8460 v_0 := v.Args[0] 8461 if v_0.Op != Op386LEAL { 8462 break 8463 } 8464 off := v_0.AuxInt 8465 sym2 := v_0.Aux 8466 ptr := v_0.Args[0] 8467 mem := v.Args[1] 8468 if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) && (ptr.Op != OpSB || !config.ctxt.Flag_shared)) { 8469 break 8470 } 8471 v.reset(Op386MOVLstoreconst) 8472 v.AuxInt = ValAndOff(sc).add(off) 8473 v.Aux = mergeSym(sym1, sym2) 8474 v.AddArg(ptr) 8475 v.AddArg(mem) 8476 return true 8477 } 8478 // match: (MOVLstoreconst [x] {sym1} (LEAL1 [off] {sym2} ptr idx) mem) 8479 // cond: canMergeSym(sym1, sym2) 8480 // result: (MOVLstoreconstidx1 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem) 8481 for { 8482 x := v.AuxInt 8483 sym1 := v.Aux 8484 _ = v.Args[1] 8485 v_0 := v.Args[0] 8486 if v_0.Op != Op386LEAL1 { 8487 break 8488 } 8489 off := v_0.AuxInt 8490 sym2 := v_0.Aux 8491 _ = v_0.Args[1] 8492 ptr := v_0.Args[0] 8493 idx := v_0.Args[1] 8494 mem := v.Args[1] 8495 if !(canMergeSym(sym1, sym2)) { 8496 break 8497 } 8498 v.reset(Op386MOVLstoreconstidx1) 8499 v.AuxInt = ValAndOff(x).add(off) 8500 v.Aux = mergeSym(sym1, sym2) 8501 v.AddArg(ptr) 8502 v.AddArg(idx) 8503 v.AddArg(mem) 8504 return true 8505 } 8506 // match: (MOVLstoreconst [x] {sym1} (LEAL4 [off] {sym2} ptr idx) mem) 8507 // cond: canMergeSym(sym1, sym2) 8508 // result: (MOVLstoreconstidx4 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem) 8509 for { 8510 x := v.AuxInt 8511 sym1 := v.Aux 8512 _ = v.Args[1] 8513 v_0 := v.Args[0] 8514 if v_0.Op != Op386LEAL4 { 8515 break 8516 } 8517 off := v_0.AuxInt 8518 sym2 := v_0.Aux 8519 _ = v_0.Args[1] 8520 ptr := v_0.Args[0] 8521 idx := v_0.Args[1] 8522 mem := v.Args[1] 8523 if !(canMergeSym(sym1, sym2)) { 8524 break 8525 } 8526 v.reset(Op386MOVLstoreconstidx4) 8527 v.AuxInt = ValAndOff(x).add(off) 8528 v.Aux = mergeSym(sym1, sym2) 8529 v.AddArg(ptr) 8530 v.AddArg(idx) 8531 v.AddArg(mem) 8532 return true 8533 } 8534 // match: (MOVLstoreconst [x] {sym} (ADDL ptr idx) mem) 8535 // cond: 8536 // result: (MOVLstoreconstidx1 [x] {sym} ptr idx mem) 8537 for { 8538 x := v.AuxInt 8539 sym := v.Aux 8540 _ = v.Args[1] 8541 v_0 := v.Args[0] 8542 if v_0.Op != Op386ADDL { 8543 break 8544 } 8545 _ = v_0.Args[1] 8546 ptr := v_0.Args[0] 8547 idx := v_0.Args[1] 8548 mem := v.Args[1] 8549 v.reset(Op386MOVLstoreconstidx1) 8550 v.AuxInt = x 8551 v.Aux = sym 8552 v.AddArg(ptr) 8553 v.AddArg(idx) 8554 v.AddArg(mem) 8555 return true 8556 } 8557 return false 8558 } 8559 func rewriteValue386_Op386MOVLstoreconstidx1_0(v *Value) bool { 8560 // match: (MOVLstoreconstidx1 [c] {sym} ptr (SHLLconst [2] idx) mem) 8561 // cond: 8562 // result: (MOVLstoreconstidx4 [c] {sym} ptr idx mem) 8563 for { 8564 c := v.AuxInt 8565 sym := v.Aux 8566 _ = v.Args[2] 8567 ptr := v.Args[0] 8568 v_1 := v.Args[1] 8569 if v_1.Op != Op386SHLLconst { 8570 break 8571 } 8572 if v_1.AuxInt != 2 { 8573 break 8574 } 8575 idx := v_1.Args[0] 8576 mem := v.Args[2] 8577 v.reset(Op386MOVLstoreconstidx4) 8578 v.AuxInt = c 8579 v.Aux = sym 8580 v.AddArg(ptr) 8581 v.AddArg(idx) 8582 v.AddArg(mem) 8583 return true 8584 } 8585 // match: (MOVLstoreconstidx1 [x] {sym} (ADDLconst [c] ptr) idx mem) 8586 // cond: 8587 // result: (MOVLstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem) 8588 for { 8589 x := v.AuxInt 8590 sym := v.Aux 8591 _ = v.Args[2] 8592 v_0 := v.Args[0] 8593 if v_0.Op != Op386ADDLconst { 8594 break 8595 } 8596 c := v_0.AuxInt 8597 ptr := v_0.Args[0] 8598 idx := v.Args[1] 8599 mem := v.Args[2] 8600 v.reset(Op386MOVLstoreconstidx1) 8601 v.AuxInt = ValAndOff(x).add(c) 8602 v.Aux = sym 8603 v.AddArg(ptr) 8604 v.AddArg(idx) 8605 v.AddArg(mem) 8606 return true 8607 } 8608 // match: (MOVLstoreconstidx1 [x] {sym} ptr (ADDLconst [c] idx) mem) 8609 // cond: 8610 // result: (MOVLstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem) 8611 for { 8612 x := v.AuxInt 8613 sym := v.Aux 8614 _ = v.Args[2] 8615 ptr := v.Args[0] 8616 v_1 := v.Args[1] 8617 if v_1.Op != Op386ADDLconst { 8618 break 8619 } 8620 c := v_1.AuxInt 8621 idx := v_1.Args[0] 8622 mem := v.Args[2] 8623 v.reset(Op386MOVLstoreconstidx1) 8624 v.AuxInt = ValAndOff(x).add(c) 8625 v.Aux = sym 8626 v.AddArg(ptr) 8627 v.AddArg(idx) 8628 v.AddArg(mem) 8629 return true 8630 } 8631 return false 8632 } 8633 func rewriteValue386_Op386MOVLstoreconstidx4_0(v *Value) bool { 8634 // match: (MOVLstoreconstidx4 [x] {sym} (ADDLconst [c] ptr) idx mem) 8635 // cond: 8636 // result: (MOVLstoreconstidx4 [ValAndOff(x).add(c)] {sym} ptr idx mem) 8637 for { 8638 x := v.AuxInt 8639 sym := v.Aux 8640 _ = v.Args[2] 8641 v_0 := v.Args[0] 8642 if v_0.Op != Op386ADDLconst { 8643 break 8644 } 8645 c := v_0.AuxInt 8646 ptr := v_0.Args[0] 8647 idx := v.Args[1] 8648 mem := v.Args[2] 8649 v.reset(Op386MOVLstoreconstidx4) 8650 v.AuxInt = ValAndOff(x).add(c) 8651 v.Aux = sym 8652 v.AddArg(ptr) 8653 v.AddArg(idx) 8654 v.AddArg(mem) 8655 return true 8656 } 8657 // match: (MOVLstoreconstidx4 [x] {sym} ptr (ADDLconst [c] idx) mem) 8658 // cond: 8659 // result: (MOVLstoreconstidx4 [ValAndOff(x).add(4*c)] {sym} ptr idx mem) 8660 for { 8661 x := v.AuxInt 8662 sym := v.Aux 8663 _ = v.Args[2] 8664 ptr := v.Args[0] 8665 v_1 := v.Args[1] 8666 if v_1.Op != Op386ADDLconst { 8667 break 8668 } 8669 c := v_1.AuxInt 8670 idx := v_1.Args[0] 8671 mem := v.Args[2] 8672 v.reset(Op386MOVLstoreconstidx4) 8673 v.AuxInt = ValAndOff(x).add(4 * c) 8674 v.Aux = sym 8675 v.AddArg(ptr) 8676 v.AddArg(idx) 8677 v.AddArg(mem) 8678 return true 8679 } 8680 return false 8681 } 8682 func rewriteValue386_Op386MOVLstoreidx1_0(v *Value) bool { 8683 // match: (MOVLstoreidx1 [c] {sym} ptr (SHLLconst [2] idx) val mem) 8684 // cond: 8685 // result: (MOVLstoreidx4 [c] {sym} ptr idx val mem) 8686 for { 8687 c := v.AuxInt 8688 sym := v.Aux 8689 _ = v.Args[3] 8690 ptr := v.Args[0] 8691 v_1 := v.Args[1] 8692 if v_1.Op != Op386SHLLconst { 8693 break 8694 } 8695 if v_1.AuxInt != 2 { 8696 break 8697 } 8698 idx := v_1.Args[0] 8699 val := v.Args[2] 8700 mem := v.Args[3] 8701 v.reset(Op386MOVLstoreidx4) 8702 v.AuxInt = c 8703 v.Aux = sym 8704 v.AddArg(ptr) 8705 v.AddArg(idx) 8706 v.AddArg(val) 8707 v.AddArg(mem) 8708 return true 8709 } 8710 // match: (MOVLstoreidx1 [c] {sym} (SHLLconst [2] idx) ptr val mem) 8711 // cond: 8712 // result: (MOVLstoreidx4 [c] {sym} ptr idx val mem) 8713 for { 8714 c := v.AuxInt 8715 sym := v.Aux 8716 _ = v.Args[3] 8717 v_0 := v.Args[0] 8718 if v_0.Op != Op386SHLLconst { 8719 break 8720 } 8721 if v_0.AuxInt != 2 { 8722 break 8723 } 8724 idx := v_0.Args[0] 8725 ptr := v.Args[1] 8726 val := v.Args[2] 8727 mem := v.Args[3] 8728 v.reset(Op386MOVLstoreidx4) 8729 v.AuxInt = c 8730 v.Aux = sym 8731 v.AddArg(ptr) 8732 v.AddArg(idx) 8733 v.AddArg(val) 8734 v.AddArg(mem) 8735 return true 8736 } 8737 // match: (MOVLstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem) 8738 // cond: 8739 // result: (MOVLstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem) 8740 for { 8741 c := v.AuxInt 8742 sym := v.Aux 8743 _ = v.Args[3] 8744 v_0 := v.Args[0] 8745 if v_0.Op != Op386ADDLconst { 8746 break 8747 } 8748 d := v_0.AuxInt 8749 ptr := v_0.Args[0] 8750 idx := v.Args[1] 8751 val := v.Args[2] 8752 mem := v.Args[3] 8753 v.reset(Op386MOVLstoreidx1) 8754 v.AuxInt = int64(int32(c + d)) 8755 v.Aux = sym 8756 v.AddArg(ptr) 8757 v.AddArg(idx) 8758 v.AddArg(val) 8759 v.AddArg(mem) 8760 return true 8761 } 8762 // match: (MOVLstoreidx1 [c] {sym} idx (ADDLconst [d] ptr) val mem) 8763 // cond: 8764 // result: (MOVLstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem) 8765 for { 8766 c := v.AuxInt 8767 sym := v.Aux 8768 _ = v.Args[3] 8769 idx := v.Args[0] 8770 v_1 := v.Args[1] 8771 if v_1.Op != Op386ADDLconst { 8772 break 8773 } 8774 d := v_1.AuxInt 8775 ptr := v_1.Args[0] 8776 val := v.Args[2] 8777 mem := v.Args[3] 8778 v.reset(Op386MOVLstoreidx1) 8779 v.AuxInt = int64(int32(c + d)) 8780 v.Aux = sym 8781 v.AddArg(ptr) 8782 v.AddArg(idx) 8783 v.AddArg(val) 8784 v.AddArg(mem) 8785 return true 8786 } 8787 // match: (MOVLstoreidx1 [c] {sym} ptr (ADDLconst [d] idx) val mem) 8788 // cond: 8789 // result: (MOVLstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem) 8790 for { 8791 c := v.AuxInt 8792 sym := v.Aux 8793 _ = v.Args[3] 8794 ptr := v.Args[0] 8795 v_1 := v.Args[1] 8796 if v_1.Op != Op386ADDLconst { 8797 break 8798 } 8799 d := v_1.AuxInt 8800 idx := v_1.Args[0] 8801 val := v.Args[2] 8802 mem := v.Args[3] 8803 v.reset(Op386MOVLstoreidx1) 8804 v.AuxInt = int64(int32(c + d)) 8805 v.Aux = sym 8806 v.AddArg(ptr) 8807 v.AddArg(idx) 8808 v.AddArg(val) 8809 v.AddArg(mem) 8810 return true 8811 } 8812 // match: (MOVLstoreidx1 [c] {sym} (ADDLconst [d] idx) ptr val mem) 8813 // cond: 8814 // result: (MOVLstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem) 8815 for { 8816 c := v.AuxInt 8817 sym := v.Aux 8818 _ = v.Args[3] 8819 v_0 := v.Args[0] 8820 if v_0.Op != Op386ADDLconst { 8821 break 8822 } 8823 d := v_0.AuxInt 8824 idx := v_0.Args[0] 8825 ptr := v.Args[1] 8826 val := v.Args[2] 8827 mem := v.Args[3] 8828 v.reset(Op386MOVLstoreidx1) 8829 v.AuxInt = int64(int32(c + d)) 8830 v.Aux = sym 8831 v.AddArg(ptr) 8832 v.AddArg(idx) 8833 v.AddArg(val) 8834 v.AddArg(mem) 8835 return true 8836 } 8837 return false 8838 } 8839 func rewriteValue386_Op386MOVLstoreidx4_0(v *Value) bool { 8840 // match: (MOVLstoreidx4 [c] {sym} (ADDLconst [d] ptr) idx val mem) 8841 // cond: 8842 // result: (MOVLstoreidx4 [int64(int32(c+d))] {sym} ptr idx val mem) 8843 for { 8844 c := v.AuxInt 8845 sym := v.Aux 8846 _ = v.Args[3] 8847 v_0 := v.Args[0] 8848 if v_0.Op != Op386ADDLconst { 8849 break 8850 } 8851 d := v_0.AuxInt 8852 ptr := v_0.Args[0] 8853 idx := v.Args[1] 8854 val := v.Args[2] 8855 mem := v.Args[3] 8856 v.reset(Op386MOVLstoreidx4) 8857 v.AuxInt = int64(int32(c + d)) 8858 v.Aux = sym 8859 v.AddArg(ptr) 8860 v.AddArg(idx) 8861 v.AddArg(val) 8862 v.AddArg(mem) 8863 return true 8864 } 8865 // match: (MOVLstoreidx4 [c] {sym} ptr (ADDLconst [d] idx) val mem) 8866 // cond: 8867 // result: (MOVLstoreidx4 [int64(int32(c+4*d))] {sym} ptr idx val mem) 8868 for { 8869 c := v.AuxInt 8870 sym := v.Aux 8871 _ = v.Args[3] 8872 ptr := v.Args[0] 8873 v_1 := v.Args[1] 8874 if v_1.Op != Op386ADDLconst { 8875 break 8876 } 8877 d := v_1.AuxInt 8878 idx := v_1.Args[0] 8879 val := v.Args[2] 8880 mem := v.Args[3] 8881 v.reset(Op386MOVLstoreidx4) 8882 v.AuxInt = int64(int32(c + 4*d)) 8883 v.Aux = sym 8884 v.AddArg(ptr) 8885 v.AddArg(idx) 8886 v.AddArg(val) 8887 v.AddArg(mem) 8888 return true 8889 } 8890 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(ADDLloadidx4 x [off] {sym} ptr idx mem) mem) 8891 // cond: y.Uses==1 && clobber(y) 8892 // result: (ADDLmodifyidx4 [off] {sym} ptr idx x mem) 8893 for { 8894 off := v.AuxInt 8895 sym := v.Aux 8896 _ = v.Args[3] 8897 ptr := v.Args[0] 8898 idx := v.Args[1] 8899 y := v.Args[2] 8900 if y.Op != Op386ADDLloadidx4 { 8901 break 8902 } 8903 if y.AuxInt != off { 8904 break 8905 } 8906 if y.Aux != sym { 8907 break 8908 } 8909 _ = y.Args[3] 8910 x := y.Args[0] 8911 if ptr != y.Args[1] { 8912 break 8913 } 8914 if idx != y.Args[2] { 8915 break 8916 } 8917 mem := y.Args[3] 8918 if mem != v.Args[3] { 8919 break 8920 } 8921 if !(y.Uses == 1 && clobber(y)) { 8922 break 8923 } 8924 v.reset(Op386ADDLmodifyidx4) 8925 v.AuxInt = off 8926 v.Aux = sym 8927 v.AddArg(ptr) 8928 v.AddArg(idx) 8929 v.AddArg(x) 8930 v.AddArg(mem) 8931 return true 8932 } 8933 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(ANDLloadidx4 x [off] {sym} ptr idx mem) mem) 8934 // cond: y.Uses==1 && clobber(y) 8935 // result: (ANDLmodifyidx4 [off] {sym} ptr idx x mem) 8936 for { 8937 off := v.AuxInt 8938 sym := v.Aux 8939 _ = v.Args[3] 8940 ptr := v.Args[0] 8941 idx := v.Args[1] 8942 y := v.Args[2] 8943 if y.Op != Op386ANDLloadidx4 { 8944 break 8945 } 8946 if y.AuxInt != off { 8947 break 8948 } 8949 if y.Aux != sym { 8950 break 8951 } 8952 _ = y.Args[3] 8953 x := y.Args[0] 8954 if ptr != y.Args[1] { 8955 break 8956 } 8957 if idx != y.Args[2] { 8958 break 8959 } 8960 mem := y.Args[3] 8961 if mem != v.Args[3] { 8962 break 8963 } 8964 if !(y.Uses == 1 && clobber(y)) { 8965 break 8966 } 8967 v.reset(Op386ANDLmodifyidx4) 8968 v.AuxInt = off 8969 v.Aux = sym 8970 v.AddArg(ptr) 8971 v.AddArg(idx) 8972 v.AddArg(x) 8973 v.AddArg(mem) 8974 return true 8975 } 8976 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(ORLloadidx4 x [off] {sym} ptr idx mem) mem) 8977 // cond: y.Uses==1 && clobber(y) 8978 // result: (ORLmodifyidx4 [off] {sym} ptr idx x mem) 8979 for { 8980 off := v.AuxInt 8981 sym := v.Aux 8982 _ = v.Args[3] 8983 ptr := v.Args[0] 8984 idx := v.Args[1] 8985 y := v.Args[2] 8986 if y.Op != Op386ORLloadidx4 { 8987 break 8988 } 8989 if y.AuxInt != off { 8990 break 8991 } 8992 if y.Aux != sym { 8993 break 8994 } 8995 _ = y.Args[3] 8996 x := y.Args[0] 8997 if ptr != y.Args[1] { 8998 break 8999 } 9000 if idx != y.Args[2] { 9001 break 9002 } 9003 mem := y.Args[3] 9004 if mem != v.Args[3] { 9005 break 9006 } 9007 if !(y.Uses == 1 && clobber(y)) { 9008 break 9009 } 9010 v.reset(Op386ORLmodifyidx4) 9011 v.AuxInt = off 9012 v.Aux = sym 9013 v.AddArg(ptr) 9014 v.AddArg(idx) 9015 v.AddArg(x) 9016 v.AddArg(mem) 9017 return true 9018 } 9019 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(XORLloadidx4 x [off] {sym} ptr idx mem) mem) 9020 // cond: y.Uses==1 && clobber(y) 9021 // result: (XORLmodifyidx4 [off] {sym} ptr idx x mem) 9022 for { 9023 off := v.AuxInt 9024 sym := v.Aux 9025 _ = v.Args[3] 9026 ptr := v.Args[0] 9027 idx := v.Args[1] 9028 y := v.Args[2] 9029 if y.Op != Op386XORLloadidx4 { 9030 break 9031 } 9032 if y.AuxInt != off { 9033 break 9034 } 9035 if y.Aux != sym { 9036 break 9037 } 9038 _ = y.Args[3] 9039 x := y.Args[0] 9040 if ptr != y.Args[1] { 9041 break 9042 } 9043 if idx != y.Args[2] { 9044 break 9045 } 9046 mem := y.Args[3] 9047 if mem != v.Args[3] { 9048 break 9049 } 9050 if !(y.Uses == 1 && clobber(y)) { 9051 break 9052 } 9053 v.reset(Op386XORLmodifyidx4) 9054 v.AuxInt = off 9055 v.Aux = sym 9056 v.AddArg(ptr) 9057 v.AddArg(idx) 9058 v.AddArg(x) 9059 v.AddArg(mem) 9060 return true 9061 } 9062 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(ADDL l:(MOVLloadidx4 [off] {sym} ptr idx mem) x) mem) 9063 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 9064 // result: (ADDLmodifyidx4 [off] {sym} ptr idx x mem) 9065 for { 9066 off := v.AuxInt 9067 sym := v.Aux 9068 _ = v.Args[3] 9069 ptr := v.Args[0] 9070 idx := v.Args[1] 9071 y := v.Args[2] 9072 if y.Op != Op386ADDL { 9073 break 9074 } 9075 _ = y.Args[1] 9076 l := y.Args[0] 9077 if l.Op != Op386MOVLloadidx4 { 9078 break 9079 } 9080 if l.AuxInt != off { 9081 break 9082 } 9083 if l.Aux != sym { 9084 break 9085 } 9086 _ = l.Args[2] 9087 if ptr != l.Args[0] { 9088 break 9089 } 9090 if idx != l.Args[1] { 9091 break 9092 } 9093 mem := l.Args[2] 9094 x := y.Args[1] 9095 if mem != v.Args[3] { 9096 break 9097 } 9098 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 9099 break 9100 } 9101 v.reset(Op386ADDLmodifyidx4) 9102 v.AuxInt = off 9103 v.Aux = sym 9104 v.AddArg(ptr) 9105 v.AddArg(idx) 9106 v.AddArg(x) 9107 v.AddArg(mem) 9108 return true 9109 } 9110 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(ADDL x l:(MOVLloadidx4 [off] {sym} ptr idx mem)) mem) 9111 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 9112 // result: (ADDLmodifyidx4 [off] {sym} ptr idx x mem) 9113 for { 9114 off := v.AuxInt 9115 sym := v.Aux 9116 _ = v.Args[3] 9117 ptr := v.Args[0] 9118 idx := v.Args[1] 9119 y := v.Args[2] 9120 if y.Op != Op386ADDL { 9121 break 9122 } 9123 _ = y.Args[1] 9124 x := y.Args[0] 9125 l := y.Args[1] 9126 if l.Op != Op386MOVLloadidx4 { 9127 break 9128 } 9129 if l.AuxInt != off { 9130 break 9131 } 9132 if l.Aux != sym { 9133 break 9134 } 9135 _ = l.Args[2] 9136 if ptr != l.Args[0] { 9137 break 9138 } 9139 if idx != l.Args[1] { 9140 break 9141 } 9142 mem := l.Args[2] 9143 if mem != v.Args[3] { 9144 break 9145 } 9146 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 9147 break 9148 } 9149 v.reset(Op386ADDLmodifyidx4) 9150 v.AuxInt = off 9151 v.Aux = sym 9152 v.AddArg(ptr) 9153 v.AddArg(idx) 9154 v.AddArg(x) 9155 v.AddArg(mem) 9156 return true 9157 } 9158 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(SUBL l:(MOVLloadidx4 [off] {sym} ptr idx mem) x) mem) 9159 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 9160 // result: (SUBLmodifyidx4 [off] {sym} ptr idx x mem) 9161 for { 9162 off := v.AuxInt 9163 sym := v.Aux 9164 _ = v.Args[3] 9165 ptr := v.Args[0] 9166 idx := v.Args[1] 9167 y := v.Args[2] 9168 if y.Op != Op386SUBL { 9169 break 9170 } 9171 _ = y.Args[1] 9172 l := y.Args[0] 9173 if l.Op != Op386MOVLloadidx4 { 9174 break 9175 } 9176 if l.AuxInt != off { 9177 break 9178 } 9179 if l.Aux != sym { 9180 break 9181 } 9182 _ = l.Args[2] 9183 if ptr != l.Args[0] { 9184 break 9185 } 9186 if idx != l.Args[1] { 9187 break 9188 } 9189 mem := l.Args[2] 9190 x := y.Args[1] 9191 if mem != v.Args[3] { 9192 break 9193 } 9194 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 9195 break 9196 } 9197 v.reset(Op386SUBLmodifyidx4) 9198 v.AuxInt = off 9199 v.Aux = sym 9200 v.AddArg(ptr) 9201 v.AddArg(idx) 9202 v.AddArg(x) 9203 v.AddArg(mem) 9204 return true 9205 } 9206 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(ANDL l:(MOVLloadidx4 [off] {sym} ptr idx mem) x) mem) 9207 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 9208 // result: (ANDLmodifyidx4 [off] {sym} ptr idx x mem) 9209 for { 9210 off := v.AuxInt 9211 sym := v.Aux 9212 _ = v.Args[3] 9213 ptr := v.Args[0] 9214 idx := v.Args[1] 9215 y := v.Args[2] 9216 if y.Op != Op386ANDL { 9217 break 9218 } 9219 _ = y.Args[1] 9220 l := y.Args[0] 9221 if l.Op != Op386MOVLloadidx4 { 9222 break 9223 } 9224 if l.AuxInt != off { 9225 break 9226 } 9227 if l.Aux != sym { 9228 break 9229 } 9230 _ = l.Args[2] 9231 if ptr != l.Args[0] { 9232 break 9233 } 9234 if idx != l.Args[1] { 9235 break 9236 } 9237 mem := l.Args[2] 9238 x := y.Args[1] 9239 if mem != v.Args[3] { 9240 break 9241 } 9242 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 9243 break 9244 } 9245 v.reset(Op386ANDLmodifyidx4) 9246 v.AuxInt = off 9247 v.Aux = sym 9248 v.AddArg(ptr) 9249 v.AddArg(idx) 9250 v.AddArg(x) 9251 v.AddArg(mem) 9252 return true 9253 } 9254 return false 9255 } 9256 func rewriteValue386_Op386MOVLstoreidx4_10(v *Value) bool { 9257 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(ANDL x l:(MOVLloadidx4 [off] {sym} ptr idx mem)) mem) 9258 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 9259 // result: (ANDLmodifyidx4 [off] {sym} ptr idx x mem) 9260 for { 9261 off := v.AuxInt 9262 sym := v.Aux 9263 _ = v.Args[3] 9264 ptr := v.Args[0] 9265 idx := v.Args[1] 9266 y := v.Args[2] 9267 if y.Op != Op386ANDL { 9268 break 9269 } 9270 _ = y.Args[1] 9271 x := y.Args[0] 9272 l := y.Args[1] 9273 if l.Op != Op386MOVLloadidx4 { 9274 break 9275 } 9276 if l.AuxInt != off { 9277 break 9278 } 9279 if l.Aux != sym { 9280 break 9281 } 9282 _ = l.Args[2] 9283 if ptr != l.Args[0] { 9284 break 9285 } 9286 if idx != l.Args[1] { 9287 break 9288 } 9289 mem := l.Args[2] 9290 if mem != v.Args[3] { 9291 break 9292 } 9293 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 9294 break 9295 } 9296 v.reset(Op386ANDLmodifyidx4) 9297 v.AuxInt = off 9298 v.Aux = sym 9299 v.AddArg(ptr) 9300 v.AddArg(idx) 9301 v.AddArg(x) 9302 v.AddArg(mem) 9303 return true 9304 } 9305 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(ORL l:(MOVLloadidx4 [off] {sym} ptr idx mem) x) mem) 9306 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 9307 // result: (ORLmodifyidx4 [off] {sym} ptr idx x mem) 9308 for { 9309 off := v.AuxInt 9310 sym := v.Aux 9311 _ = v.Args[3] 9312 ptr := v.Args[0] 9313 idx := v.Args[1] 9314 y := v.Args[2] 9315 if y.Op != Op386ORL { 9316 break 9317 } 9318 _ = y.Args[1] 9319 l := y.Args[0] 9320 if l.Op != Op386MOVLloadidx4 { 9321 break 9322 } 9323 if l.AuxInt != off { 9324 break 9325 } 9326 if l.Aux != sym { 9327 break 9328 } 9329 _ = l.Args[2] 9330 if ptr != l.Args[0] { 9331 break 9332 } 9333 if idx != l.Args[1] { 9334 break 9335 } 9336 mem := l.Args[2] 9337 x := y.Args[1] 9338 if mem != v.Args[3] { 9339 break 9340 } 9341 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 9342 break 9343 } 9344 v.reset(Op386ORLmodifyidx4) 9345 v.AuxInt = off 9346 v.Aux = sym 9347 v.AddArg(ptr) 9348 v.AddArg(idx) 9349 v.AddArg(x) 9350 v.AddArg(mem) 9351 return true 9352 } 9353 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(ORL x l:(MOVLloadidx4 [off] {sym} ptr idx mem)) mem) 9354 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 9355 // result: (ORLmodifyidx4 [off] {sym} ptr idx x mem) 9356 for { 9357 off := v.AuxInt 9358 sym := v.Aux 9359 _ = v.Args[3] 9360 ptr := v.Args[0] 9361 idx := v.Args[1] 9362 y := v.Args[2] 9363 if y.Op != Op386ORL { 9364 break 9365 } 9366 _ = y.Args[1] 9367 x := y.Args[0] 9368 l := y.Args[1] 9369 if l.Op != Op386MOVLloadidx4 { 9370 break 9371 } 9372 if l.AuxInt != off { 9373 break 9374 } 9375 if l.Aux != sym { 9376 break 9377 } 9378 _ = l.Args[2] 9379 if ptr != l.Args[0] { 9380 break 9381 } 9382 if idx != l.Args[1] { 9383 break 9384 } 9385 mem := l.Args[2] 9386 if mem != v.Args[3] { 9387 break 9388 } 9389 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 9390 break 9391 } 9392 v.reset(Op386ORLmodifyidx4) 9393 v.AuxInt = off 9394 v.Aux = sym 9395 v.AddArg(ptr) 9396 v.AddArg(idx) 9397 v.AddArg(x) 9398 v.AddArg(mem) 9399 return true 9400 } 9401 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(XORL l:(MOVLloadidx4 [off] {sym} ptr idx mem) x) mem) 9402 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 9403 // result: (XORLmodifyidx4 [off] {sym} ptr idx x mem) 9404 for { 9405 off := v.AuxInt 9406 sym := v.Aux 9407 _ = v.Args[3] 9408 ptr := v.Args[0] 9409 idx := v.Args[1] 9410 y := v.Args[2] 9411 if y.Op != Op386XORL { 9412 break 9413 } 9414 _ = y.Args[1] 9415 l := y.Args[0] 9416 if l.Op != Op386MOVLloadidx4 { 9417 break 9418 } 9419 if l.AuxInt != off { 9420 break 9421 } 9422 if l.Aux != sym { 9423 break 9424 } 9425 _ = l.Args[2] 9426 if ptr != l.Args[0] { 9427 break 9428 } 9429 if idx != l.Args[1] { 9430 break 9431 } 9432 mem := l.Args[2] 9433 x := y.Args[1] 9434 if mem != v.Args[3] { 9435 break 9436 } 9437 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 9438 break 9439 } 9440 v.reset(Op386XORLmodifyidx4) 9441 v.AuxInt = off 9442 v.Aux = sym 9443 v.AddArg(ptr) 9444 v.AddArg(idx) 9445 v.AddArg(x) 9446 v.AddArg(mem) 9447 return true 9448 } 9449 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(XORL x l:(MOVLloadidx4 [off] {sym} ptr idx mem)) mem) 9450 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) 9451 // result: (XORLmodifyidx4 [off] {sym} ptr idx x mem) 9452 for { 9453 off := v.AuxInt 9454 sym := v.Aux 9455 _ = v.Args[3] 9456 ptr := v.Args[0] 9457 idx := v.Args[1] 9458 y := v.Args[2] 9459 if y.Op != Op386XORL { 9460 break 9461 } 9462 _ = y.Args[1] 9463 x := y.Args[0] 9464 l := y.Args[1] 9465 if l.Op != Op386MOVLloadidx4 { 9466 break 9467 } 9468 if l.AuxInt != off { 9469 break 9470 } 9471 if l.Aux != sym { 9472 break 9473 } 9474 _ = l.Args[2] 9475 if ptr != l.Args[0] { 9476 break 9477 } 9478 if idx != l.Args[1] { 9479 break 9480 } 9481 mem := l.Args[2] 9482 if mem != v.Args[3] { 9483 break 9484 } 9485 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) { 9486 break 9487 } 9488 v.reset(Op386XORLmodifyidx4) 9489 v.AuxInt = off 9490 v.Aux = sym 9491 v.AddArg(ptr) 9492 v.AddArg(idx) 9493 v.AddArg(x) 9494 v.AddArg(mem) 9495 return true 9496 } 9497 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(ADDLconst [c] l:(MOVLloadidx4 [off] {sym} ptr idx mem)) mem) 9498 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) && validValAndOff(c,off) 9499 // result: (ADDLconstmodifyidx4 [makeValAndOff(c,off)] {sym} ptr idx mem) 9500 for { 9501 off := v.AuxInt 9502 sym := v.Aux 9503 _ = v.Args[3] 9504 ptr := v.Args[0] 9505 idx := v.Args[1] 9506 y := v.Args[2] 9507 if y.Op != Op386ADDLconst { 9508 break 9509 } 9510 c := y.AuxInt 9511 l := y.Args[0] 9512 if l.Op != Op386MOVLloadidx4 { 9513 break 9514 } 9515 if l.AuxInt != off { 9516 break 9517 } 9518 if l.Aux != sym { 9519 break 9520 } 9521 _ = l.Args[2] 9522 if ptr != l.Args[0] { 9523 break 9524 } 9525 if idx != l.Args[1] { 9526 break 9527 } 9528 mem := l.Args[2] 9529 if mem != v.Args[3] { 9530 break 9531 } 9532 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l) && validValAndOff(c, off)) { 9533 break 9534 } 9535 v.reset(Op386ADDLconstmodifyidx4) 9536 v.AuxInt = makeValAndOff(c, off) 9537 v.Aux = sym 9538 v.AddArg(ptr) 9539 v.AddArg(idx) 9540 v.AddArg(mem) 9541 return true 9542 } 9543 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(ANDLconst [c] l:(MOVLloadidx4 [off] {sym} ptr idx mem)) mem) 9544 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) && validValAndOff(c,off) 9545 // result: (ANDLconstmodifyidx4 [makeValAndOff(c,off)] {sym} ptr idx mem) 9546 for { 9547 off := v.AuxInt 9548 sym := v.Aux 9549 _ = v.Args[3] 9550 ptr := v.Args[0] 9551 idx := v.Args[1] 9552 y := v.Args[2] 9553 if y.Op != Op386ANDLconst { 9554 break 9555 } 9556 c := y.AuxInt 9557 l := y.Args[0] 9558 if l.Op != Op386MOVLloadidx4 { 9559 break 9560 } 9561 if l.AuxInt != off { 9562 break 9563 } 9564 if l.Aux != sym { 9565 break 9566 } 9567 _ = l.Args[2] 9568 if ptr != l.Args[0] { 9569 break 9570 } 9571 if idx != l.Args[1] { 9572 break 9573 } 9574 mem := l.Args[2] 9575 if mem != v.Args[3] { 9576 break 9577 } 9578 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l) && validValAndOff(c, off)) { 9579 break 9580 } 9581 v.reset(Op386ANDLconstmodifyidx4) 9582 v.AuxInt = makeValAndOff(c, off) 9583 v.Aux = sym 9584 v.AddArg(ptr) 9585 v.AddArg(idx) 9586 v.AddArg(mem) 9587 return true 9588 } 9589 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(ORLconst [c] l:(MOVLloadidx4 [off] {sym} ptr idx mem)) mem) 9590 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) && validValAndOff(c,off) 9591 // result: (ORLconstmodifyidx4 [makeValAndOff(c,off)] {sym} ptr idx mem) 9592 for { 9593 off := v.AuxInt 9594 sym := v.Aux 9595 _ = v.Args[3] 9596 ptr := v.Args[0] 9597 idx := v.Args[1] 9598 y := v.Args[2] 9599 if y.Op != Op386ORLconst { 9600 break 9601 } 9602 c := y.AuxInt 9603 l := y.Args[0] 9604 if l.Op != Op386MOVLloadidx4 { 9605 break 9606 } 9607 if l.AuxInt != off { 9608 break 9609 } 9610 if l.Aux != sym { 9611 break 9612 } 9613 _ = l.Args[2] 9614 if ptr != l.Args[0] { 9615 break 9616 } 9617 if idx != l.Args[1] { 9618 break 9619 } 9620 mem := l.Args[2] 9621 if mem != v.Args[3] { 9622 break 9623 } 9624 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l) && validValAndOff(c, off)) { 9625 break 9626 } 9627 v.reset(Op386ORLconstmodifyidx4) 9628 v.AuxInt = makeValAndOff(c, off) 9629 v.Aux = sym 9630 v.AddArg(ptr) 9631 v.AddArg(idx) 9632 v.AddArg(mem) 9633 return true 9634 } 9635 // match: (MOVLstoreidx4 {sym} [off] ptr idx y:(XORLconst [c] l:(MOVLloadidx4 [off] {sym} ptr idx mem)) mem) 9636 // cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l) && validValAndOff(c,off) 9637 // result: (XORLconstmodifyidx4 [makeValAndOff(c,off)] {sym} ptr idx mem) 9638 for { 9639 off := v.AuxInt 9640 sym := v.Aux 9641 _ = v.Args[3] 9642 ptr := v.Args[0] 9643 idx := v.Args[1] 9644 y := v.Args[2] 9645 if y.Op != Op386XORLconst { 9646 break 9647 } 9648 c := y.AuxInt 9649 l := y.Args[0] 9650 if l.Op != Op386MOVLloadidx4 { 9651 break 9652 } 9653 if l.AuxInt != off { 9654 break 9655 } 9656 if l.Aux != sym { 9657 break 9658 } 9659 _ = l.Args[2] 9660 if ptr != l.Args[0] { 9661 break 9662 } 9663 if idx != l.Args[1] { 9664 break 9665 } 9666 mem := l.Args[2] 9667 if mem != v.Args[3] { 9668 break 9669 } 9670 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l) && validValAndOff(c, off)) { 9671 break 9672 } 9673 v.reset(Op386XORLconstmodifyidx4) 9674 v.AuxInt = makeValAndOff(c, off) 9675 v.Aux = sym 9676 v.AddArg(ptr) 9677 v.AddArg(idx) 9678 v.AddArg(mem) 9679 return true 9680 } 9681 return false 9682 } 9683 func rewriteValue386_Op386MOVSDconst_0(v *Value) bool { 9684 b := v.Block 9685 _ = b 9686 config := b.Func.Config 9687 _ = config 9688 typ := &b.Func.Config.Types 9689 _ = typ 9690 // match: (MOVSDconst [c]) 9691 // cond: config.ctxt.Flag_shared 9692 // result: (MOVSDconst2 (MOVSDconst1 [c])) 9693 for { 9694 c := v.AuxInt 9695 if !(config.ctxt.Flag_shared) { 9696 break 9697 } 9698 v.reset(Op386MOVSDconst2) 9699 v0 := b.NewValue0(v.Pos, Op386MOVSDconst1, typ.UInt32) 9700 v0.AuxInt = c 9701 v.AddArg(v0) 9702 return true 9703 } 9704 return false 9705 } 9706 func rewriteValue386_Op386MOVSDload_0(v *Value) bool { 9707 b := v.Block 9708 _ = b 9709 config := b.Func.Config 9710 _ = config 9711 // match: (MOVSDload [off1] {sym} (ADDLconst [off2] ptr) mem) 9712 // cond: is32Bit(off1+off2) 9713 // result: (MOVSDload [off1+off2] {sym} ptr mem) 9714 for { 9715 off1 := v.AuxInt 9716 sym := v.Aux 9717 _ = v.Args[1] 9718 v_0 := v.Args[0] 9719 if v_0.Op != Op386ADDLconst { 9720 break 9721 } 9722 off2 := v_0.AuxInt 9723 ptr := v_0.Args[0] 9724 mem := v.Args[1] 9725 if !(is32Bit(off1 + off2)) { 9726 break 9727 } 9728 v.reset(Op386MOVSDload) 9729 v.AuxInt = off1 + off2 9730 v.Aux = sym 9731 v.AddArg(ptr) 9732 v.AddArg(mem) 9733 return true 9734 } 9735 // match: (MOVSDload [off1] {sym1} (LEAL [off2] {sym2} base) mem) 9736 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 9737 // result: (MOVSDload [off1+off2] {mergeSym(sym1,sym2)} base mem) 9738 for { 9739 off1 := v.AuxInt 9740 sym1 := v.Aux 9741 _ = v.Args[1] 9742 v_0 := v.Args[0] 9743 if v_0.Op != Op386LEAL { 9744 break 9745 } 9746 off2 := v_0.AuxInt 9747 sym2 := v_0.Aux 9748 base := v_0.Args[0] 9749 mem := v.Args[1] 9750 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 9751 break 9752 } 9753 v.reset(Op386MOVSDload) 9754 v.AuxInt = off1 + off2 9755 v.Aux = mergeSym(sym1, sym2) 9756 v.AddArg(base) 9757 v.AddArg(mem) 9758 return true 9759 } 9760 // match: (MOVSDload [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) mem) 9761 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 9762 // result: (MOVSDloadidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem) 9763 for { 9764 off1 := v.AuxInt 9765 sym1 := v.Aux 9766 _ = v.Args[1] 9767 v_0 := v.Args[0] 9768 if v_0.Op != Op386LEAL1 { 9769 break 9770 } 9771 off2 := v_0.AuxInt 9772 sym2 := v_0.Aux 9773 _ = v_0.Args[1] 9774 ptr := v_0.Args[0] 9775 idx := v_0.Args[1] 9776 mem := v.Args[1] 9777 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 9778 break 9779 } 9780 v.reset(Op386MOVSDloadidx1) 9781 v.AuxInt = off1 + off2 9782 v.Aux = mergeSym(sym1, sym2) 9783 v.AddArg(ptr) 9784 v.AddArg(idx) 9785 v.AddArg(mem) 9786 return true 9787 } 9788 // match: (MOVSDload [off1] {sym1} (LEAL8 [off2] {sym2} ptr idx) mem) 9789 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 9790 // result: (MOVSDloadidx8 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem) 9791 for { 9792 off1 := v.AuxInt 9793 sym1 := v.Aux 9794 _ = v.Args[1] 9795 v_0 := v.Args[0] 9796 if v_0.Op != Op386LEAL8 { 9797 break 9798 } 9799 off2 := v_0.AuxInt 9800 sym2 := v_0.Aux 9801 _ = v_0.Args[1] 9802 ptr := v_0.Args[0] 9803 idx := v_0.Args[1] 9804 mem := v.Args[1] 9805 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 9806 break 9807 } 9808 v.reset(Op386MOVSDloadidx8) 9809 v.AuxInt = off1 + off2 9810 v.Aux = mergeSym(sym1, sym2) 9811 v.AddArg(ptr) 9812 v.AddArg(idx) 9813 v.AddArg(mem) 9814 return true 9815 } 9816 // match: (MOVSDload [off] {sym} (ADDL ptr idx) mem) 9817 // cond: ptr.Op != OpSB 9818 // result: (MOVSDloadidx1 [off] {sym} ptr idx mem) 9819 for { 9820 off := v.AuxInt 9821 sym := v.Aux 9822 _ = v.Args[1] 9823 v_0 := v.Args[0] 9824 if v_0.Op != Op386ADDL { 9825 break 9826 } 9827 _ = v_0.Args[1] 9828 ptr := v_0.Args[0] 9829 idx := v_0.Args[1] 9830 mem := v.Args[1] 9831 if !(ptr.Op != OpSB) { 9832 break 9833 } 9834 v.reset(Op386MOVSDloadidx1) 9835 v.AuxInt = off 9836 v.Aux = sym 9837 v.AddArg(ptr) 9838 v.AddArg(idx) 9839 v.AddArg(mem) 9840 return true 9841 } 9842 return false 9843 } 9844 func rewriteValue386_Op386MOVSDloadidx1_0(v *Value) bool { 9845 // match: (MOVSDloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem) 9846 // cond: 9847 // result: (MOVSDloadidx1 [int64(int32(c+d))] {sym} ptr idx mem) 9848 for { 9849 c := v.AuxInt 9850 sym := v.Aux 9851 _ = v.Args[2] 9852 v_0 := v.Args[0] 9853 if v_0.Op != Op386ADDLconst { 9854 break 9855 } 9856 d := v_0.AuxInt 9857 ptr := v_0.Args[0] 9858 idx := v.Args[1] 9859 mem := v.Args[2] 9860 v.reset(Op386MOVSDloadidx1) 9861 v.AuxInt = int64(int32(c + d)) 9862 v.Aux = sym 9863 v.AddArg(ptr) 9864 v.AddArg(idx) 9865 v.AddArg(mem) 9866 return true 9867 } 9868 // match: (MOVSDloadidx1 [c] {sym} ptr (ADDLconst [d] idx) mem) 9869 // cond: 9870 // result: (MOVSDloadidx1 [int64(int32(c+d))] {sym} ptr idx mem) 9871 for { 9872 c := v.AuxInt 9873 sym := v.Aux 9874 _ = v.Args[2] 9875 ptr := v.Args[0] 9876 v_1 := v.Args[1] 9877 if v_1.Op != Op386ADDLconst { 9878 break 9879 } 9880 d := v_1.AuxInt 9881 idx := v_1.Args[0] 9882 mem := v.Args[2] 9883 v.reset(Op386MOVSDloadidx1) 9884 v.AuxInt = int64(int32(c + d)) 9885 v.Aux = sym 9886 v.AddArg(ptr) 9887 v.AddArg(idx) 9888 v.AddArg(mem) 9889 return true 9890 } 9891 return false 9892 } 9893 func rewriteValue386_Op386MOVSDloadidx8_0(v *Value) bool { 9894 // match: (MOVSDloadidx8 [c] {sym} (ADDLconst [d] ptr) idx mem) 9895 // cond: 9896 // result: (MOVSDloadidx8 [int64(int32(c+d))] {sym} ptr idx mem) 9897 for { 9898 c := v.AuxInt 9899 sym := v.Aux 9900 _ = v.Args[2] 9901 v_0 := v.Args[0] 9902 if v_0.Op != Op386ADDLconst { 9903 break 9904 } 9905 d := v_0.AuxInt 9906 ptr := v_0.Args[0] 9907 idx := v.Args[1] 9908 mem := v.Args[2] 9909 v.reset(Op386MOVSDloadidx8) 9910 v.AuxInt = int64(int32(c + d)) 9911 v.Aux = sym 9912 v.AddArg(ptr) 9913 v.AddArg(idx) 9914 v.AddArg(mem) 9915 return true 9916 } 9917 // match: (MOVSDloadidx8 [c] {sym} ptr (ADDLconst [d] idx) mem) 9918 // cond: 9919 // result: (MOVSDloadidx8 [int64(int32(c+8*d))] {sym} ptr idx mem) 9920 for { 9921 c := v.AuxInt 9922 sym := v.Aux 9923 _ = v.Args[2] 9924 ptr := v.Args[0] 9925 v_1 := v.Args[1] 9926 if v_1.Op != Op386ADDLconst { 9927 break 9928 } 9929 d := v_1.AuxInt 9930 idx := v_1.Args[0] 9931 mem := v.Args[2] 9932 v.reset(Op386MOVSDloadidx8) 9933 v.AuxInt = int64(int32(c + 8*d)) 9934 v.Aux = sym 9935 v.AddArg(ptr) 9936 v.AddArg(idx) 9937 v.AddArg(mem) 9938 return true 9939 } 9940 return false 9941 } 9942 func rewriteValue386_Op386MOVSDstore_0(v *Value) bool { 9943 b := v.Block 9944 _ = b 9945 config := b.Func.Config 9946 _ = config 9947 // match: (MOVSDstore [off1] {sym} (ADDLconst [off2] ptr) val mem) 9948 // cond: is32Bit(off1+off2) 9949 // result: (MOVSDstore [off1+off2] {sym} ptr val mem) 9950 for { 9951 off1 := v.AuxInt 9952 sym := v.Aux 9953 _ = v.Args[2] 9954 v_0 := v.Args[0] 9955 if v_0.Op != Op386ADDLconst { 9956 break 9957 } 9958 off2 := v_0.AuxInt 9959 ptr := v_0.Args[0] 9960 val := v.Args[1] 9961 mem := v.Args[2] 9962 if !(is32Bit(off1 + off2)) { 9963 break 9964 } 9965 v.reset(Op386MOVSDstore) 9966 v.AuxInt = off1 + off2 9967 v.Aux = sym 9968 v.AddArg(ptr) 9969 v.AddArg(val) 9970 v.AddArg(mem) 9971 return true 9972 } 9973 // match: (MOVSDstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem) 9974 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 9975 // result: (MOVSDstore [off1+off2] {mergeSym(sym1,sym2)} base val mem) 9976 for { 9977 off1 := v.AuxInt 9978 sym1 := v.Aux 9979 _ = v.Args[2] 9980 v_0 := v.Args[0] 9981 if v_0.Op != Op386LEAL { 9982 break 9983 } 9984 off2 := v_0.AuxInt 9985 sym2 := v_0.Aux 9986 base := v_0.Args[0] 9987 val := v.Args[1] 9988 mem := v.Args[2] 9989 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 9990 break 9991 } 9992 v.reset(Op386MOVSDstore) 9993 v.AuxInt = off1 + off2 9994 v.Aux = mergeSym(sym1, sym2) 9995 v.AddArg(base) 9996 v.AddArg(val) 9997 v.AddArg(mem) 9998 return true 9999 } 10000 // match: (MOVSDstore [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) val mem) 10001 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 10002 // result: (MOVSDstoreidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem) 10003 for { 10004 off1 := v.AuxInt 10005 sym1 := v.Aux 10006 _ = v.Args[2] 10007 v_0 := v.Args[0] 10008 if v_0.Op != Op386LEAL1 { 10009 break 10010 } 10011 off2 := v_0.AuxInt 10012 sym2 := v_0.Aux 10013 _ = v_0.Args[1] 10014 ptr := v_0.Args[0] 10015 idx := v_0.Args[1] 10016 val := v.Args[1] 10017 mem := v.Args[2] 10018 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 10019 break 10020 } 10021 v.reset(Op386MOVSDstoreidx1) 10022 v.AuxInt = off1 + off2 10023 v.Aux = mergeSym(sym1, sym2) 10024 v.AddArg(ptr) 10025 v.AddArg(idx) 10026 v.AddArg(val) 10027 v.AddArg(mem) 10028 return true 10029 } 10030 // match: (MOVSDstore [off1] {sym1} (LEAL8 [off2] {sym2} ptr idx) val mem) 10031 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 10032 // result: (MOVSDstoreidx8 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem) 10033 for { 10034 off1 := v.AuxInt 10035 sym1 := v.Aux 10036 _ = v.Args[2] 10037 v_0 := v.Args[0] 10038 if v_0.Op != Op386LEAL8 { 10039 break 10040 } 10041 off2 := v_0.AuxInt 10042 sym2 := v_0.Aux 10043 _ = v_0.Args[1] 10044 ptr := v_0.Args[0] 10045 idx := v_0.Args[1] 10046 val := v.Args[1] 10047 mem := v.Args[2] 10048 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 10049 break 10050 } 10051 v.reset(Op386MOVSDstoreidx8) 10052 v.AuxInt = off1 + off2 10053 v.Aux = mergeSym(sym1, sym2) 10054 v.AddArg(ptr) 10055 v.AddArg(idx) 10056 v.AddArg(val) 10057 v.AddArg(mem) 10058 return true 10059 } 10060 // match: (MOVSDstore [off] {sym} (ADDL ptr idx) val mem) 10061 // cond: ptr.Op != OpSB 10062 // result: (MOVSDstoreidx1 [off] {sym} ptr idx val mem) 10063 for { 10064 off := v.AuxInt 10065 sym := v.Aux 10066 _ = v.Args[2] 10067 v_0 := v.Args[0] 10068 if v_0.Op != Op386ADDL { 10069 break 10070 } 10071 _ = v_0.Args[1] 10072 ptr := v_0.Args[0] 10073 idx := v_0.Args[1] 10074 val := v.Args[1] 10075 mem := v.Args[2] 10076 if !(ptr.Op != OpSB) { 10077 break 10078 } 10079 v.reset(Op386MOVSDstoreidx1) 10080 v.AuxInt = off 10081 v.Aux = sym 10082 v.AddArg(ptr) 10083 v.AddArg(idx) 10084 v.AddArg(val) 10085 v.AddArg(mem) 10086 return true 10087 } 10088 return false 10089 } 10090 func rewriteValue386_Op386MOVSDstoreidx1_0(v *Value) bool { 10091 // match: (MOVSDstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem) 10092 // cond: 10093 // result: (MOVSDstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem) 10094 for { 10095 c := v.AuxInt 10096 sym := v.Aux 10097 _ = v.Args[3] 10098 v_0 := v.Args[0] 10099 if v_0.Op != Op386ADDLconst { 10100 break 10101 } 10102 d := v_0.AuxInt 10103 ptr := v_0.Args[0] 10104 idx := v.Args[1] 10105 val := v.Args[2] 10106 mem := v.Args[3] 10107 v.reset(Op386MOVSDstoreidx1) 10108 v.AuxInt = int64(int32(c + d)) 10109 v.Aux = sym 10110 v.AddArg(ptr) 10111 v.AddArg(idx) 10112 v.AddArg(val) 10113 v.AddArg(mem) 10114 return true 10115 } 10116 // match: (MOVSDstoreidx1 [c] {sym} ptr (ADDLconst [d] idx) val mem) 10117 // cond: 10118 // result: (MOVSDstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem) 10119 for { 10120 c := v.AuxInt 10121 sym := v.Aux 10122 _ = v.Args[3] 10123 ptr := v.Args[0] 10124 v_1 := v.Args[1] 10125 if v_1.Op != Op386ADDLconst { 10126 break 10127 } 10128 d := v_1.AuxInt 10129 idx := v_1.Args[0] 10130 val := v.Args[2] 10131 mem := v.Args[3] 10132 v.reset(Op386MOVSDstoreidx1) 10133 v.AuxInt = int64(int32(c + d)) 10134 v.Aux = sym 10135 v.AddArg(ptr) 10136 v.AddArg(idx) 10137 v.AddArg(val) 10138 v.AddArg(mem) 10139 return true 10140 } 10141 return false 10142 } 10143 func rewriteValue386_Op386MOVSDstoreidx8_0(v *Value) bool { 10144 // match: (MOVSDstoreidx8 [c] {sym} (ADDLconst [d] ptr) idx val mem) 10145 // cond: 10146 // result: (MOVSDstoreidx8 [int64(int32(c+d))] {sym} ptr idx val mem) 10147 for { 10148 c := v.AuxInt 10149 sym := v.Aux 10150 _ = v.Args[3] 10151 v_0 := v.Args[0] 10152 if v_0.Op != Op386ADDLconst { 10153 break 10154 } 10155 d := v_0.AuxInt 10156 ptr := v_0.Args[0] 10157 idx := v.Args[1] 10158 val := v.Args[2] 10159 mem := v.Args[3] 10160 v.reset(Op386MOVSDstoreidx8) 10161 v.AuxInt = int64(int32(c + d)) 10162 v.Aux = sym 10163 v.AddArg(ptr) 10164 v.AddArg(idx) 10165 v.AddArg(val) 10166 v.AddArg(mem) 10167 return true 10168 } 10169 // match: (MOVSDstoreidx8 [c] {sym} ptr (ADDLconst [d] idx) val mem) 10170 // cond: 10171 // result: (MOVSDstoreidx8 [int64(int32(c+8*d))] {sym} ptr idx val mem) 10172 for { 10173 c := v.AuxInt 10174 sym := v.Aux 10175 _ = v.Args[3] 10176 ptr := v.Args[0] 10177 v_1 := v.Args[1] 10178 if v_1.Op != Op386ADDLconst { 10179 break 10180 } 10181 d := v_1.AuxInt 10182 idx := v_1.Args[0] 10183 val := v.Args[2] 10184 mem := v.Args[3] 10185 v.reset(Op386MOVSDstoreidx8) 10186 v.AuxInt = int64(int32(c + 8*d)) 10187 v.Aux = sym 10188 v.AddArg(ptr) 10189 v.AddArg(idx) 10190 v.AddArg(val) 10191 v.AddArg(mem) 10192 return true 10193 } 10194 return false 10195 } 10196 func rewriteValue386_Op386MOVSSconst_0(v *Value) bool { 10197 b := v.Block 10198 _ = b 10199 config := b.Func.Config 10200 _ = config 10201 typ := &b.Func.Config.Types 10202 _ = typ 10203 // match: (MOVSSconst [c]) 10204 // cond: config.ctxt.Flag_shared 10205 // result: (MOVSSconst2 (MOVSSconst1 [c])) 10206 for { 10207 c := v.AuxInt 10208 if !(config.ctxt.Flag_shared) { 10209 break 10210 } 10211 v.reset(Op386MOVSSconst2) 10212 v0 := b.NewValue0(v.Pos, Op386MOVSSconst1, typ.UInt32) 10213 v0.AuxInt = c 10214 v.AddArg(v0) 10215 return true 10216 } 10217 return false 10218 } 10219 func rewriteValue386_Op386MOVSSload_0(v *Value) bool { 10220 b := v.Block 10221 _ = b 10222 config := b.Func.Config 10223 _ = config 10224 // match: (MOVSSload [off1] {sym} (ADDLconst [off2] ptr) mem) 10225 // cond: is32Bit(off1+off2) 10226 // result: (MOVSSload [off1+off2] {sym} ptr mem) 10227 for { 10228 off1 := v.AuxInt 10229 sym := v.Aux 10230 _ = v.Args[1] 10231 v_0 := v.Args[0] 10232 if v_0.Op != Op386ADDLconst { 10233 break 10234 } 10235 off2 := v_0.AuxInt 10236 ptr := v_0.Args[0] 10237 mem := v.Args[1] 10238 if !(is32Bit(off1 + off2)) { 10239 break 10240 } 10241 v.reset(Op386MOVSSload) 10242 v.AuxInt = off1 + off2 10243 v.Aux = sym 10244 v.AddArg(ptr) 10245 v.AddArg(mem) 10246 return true 10247 } 10248 // match: (MOVSSload [off1] {sym1} (LEAL [off2] {sym2} base) mem) 10249 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 10250 // result: (MOVSSload [off1+off2] {mergeSym(sym1,sym2)} base mem) 10251 for { 10252 off1 := v.AuxInt 10253 sym1 := v.Aux 10254 _ = v.Args[1] 10255 v_0 := v.Args[0] 10256 if v_0.Op != Op386LEAL { 10257 break 10258 } 10259 off2 := v_0.AuxInt 10260 sym2 := v_0.Aux 10261 base := v_0.Args[0] 10262 mem := v.Args[1] 10263 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 10264 break 10265 } 10266 v.reset(Op386MOVSSload) 10267 v.AuxInt = off1 + off2 10268 v.Aux = mergeSym(sym1, sym2) 10269 v.AddArg(base) 10270 v.AddArg(mem) 10271 return true 10272 } 10273 // match: (MOVSSload [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) mem) 10274 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 10275 // result: (MOVSSloadidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem) 10276 for { 10277 off1 := v.AuxInt 10278 sym1 := v.Aux 10279 _ = v.Args[1] 10280 v_0 := v.Args[0] 10281 if v_0.Op != Op386LEAL1 { 10282 break 10283 } 10284 off2 := v_0.AuxInt 10285 sym2 := v_0.Aux 10286 _ = v_0.Args[1] 10287 ptr := v_0.Args[0] 10288 idx := v_0.Args[1] 10289 mem := v.Args[1] 10290 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 10291 break 10292 } 10293 v.reset(Op386MOVSSloadidx1) 10294 v.AuxInt = off1 + off2 10295 v.Aux = mergeSym(sym1, sym2) 10296 v.AddArg(ptr) 10297 v.AddArg(idx) 10298 v.AddArg(mem) 10299 return true 10300 } 10301 // match: (MOVSSload [off1] {sym1} (LEAL4 [off2] {sym2} ptr idx) mem) 10302 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 10303 // result: (MOVSSloadidx4 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem) 10304 for { 10305 off1 := v.AuxInt 10306 sym1 := v.Aux 10307 _ = v.Args[1] 10308 v_0 := v.Args[0] 10309 if v_0.Op != Op386LEAL4 { 10310 break 10311 } 10312 off2 := v_0.AuxInt 10313 sym2 := v_0.Aux 10314 _ = v_0.Args[1] 10315 ptr := v_0.Args[0] 10316 idx := v_0.Args[1] 10317 mem := v.Args[1] 10318 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 10319 break 10320 } 10321 v.reset(Op386MOVSSloadidx4) 10322 v.AuxInt = off1 + off2 10323 v.Aux = mergeSym(sym1, sym2) 10324 v.AddArg(ptr) 10325 v.AddArg(idx) 10326 v.AddArg(mem) 10327 return true 10328 } 10329 // match: (MOVSSload [off] {sym} (ADDL ptr idx) mem) 10330 // cond: ptr.Op != OpSB 10331 // result: (MOVSSloadidx1 [off] {sym} ptr idx mem) 10332 for { 10333 off := v.AuxInt 10334 sym := v.Aux 10335 _ = v.Args[1] 10336 v_0 := v.Args[0] 10337 if v_0.Op != Op386ADDL { 10338 break 10339 } 10340 _ = v_0.Args[1] 10341 ptr := v_0.Args[0] 10342 idx := v_0.Args[1] 10343 mem := v.Args[1] 10344 if !(ptr.Op != OpSB) { 10345 break 10346 } 10347 v.reset(Op386MOVSSloadidx1) 10348 v.AuxInt = off 10349 v.Aux = sym 10350 v.AddArg(ptr) 10351 v.AddArg(idx) 10352 v.AddArg(mem) 10353 return true 10354 } 10355 return false 10356 } 10357 func rewriteValue386_Op386MOVSSloadidx1_0(v *Value) bool { 10358 // match: (MOVSSloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem) 10359 // cond: 10360 // result: (MOVSSloadidx1 [int64(int32(c+d))] {sym} ptr idx mem) 10361 for { 10362 c := v.AuxInt 10363 sym := v.Aux 10364 _ = v.Args[2] 10365 v_0 := v.Args[0] 10366 if v_0.Op != Op386ADDLconst { 10367 break 10368 } 10369 d := v_0.AuxInt 10370 ptr := v_0.Args[0] 10371 idx := v.Args[1] 10372 mem := v.Args[2] 10373 v.reset(Op386MOVSSloadidx1) 10374 v.AuxInt = int64(int32(c + d)) 10375 v.Aux = sym 10376 v.AddArg(ptr) 10377 v.AddArg(idx) 10378 v.AddArg(mem) 10379 return true 10380 } 10381 // match: (MOVSSloadidx1 [c] {sym} ptr (ADDLconst [d] idx) mem) 10382 // cond: 10383 // result: (MOVSSloadidx1 [int64(int32(c+d))] {sym} ptr idx mem) 10384 for { 10385 c := v.AuxInt 10386 sym := v.Aux 10387 _ = v.Args[2] 10388 ptr := v.Args[0] 10389 v_1 := v.Args[1] 10390 if v_1.Op != Op386ADDLconst { 10391 break 10392 } 10393 d := v_1.AuxInt 10394 idx := v_1.Args[0] 10395 mem := v.Args[2] 10396 v.reset(Op386MOVSSloadidx1) 10397 v.AuxInt = int64(int32(c + d)) 10398 v.Aux = sym 10399 v.AddArg(ptr) 10400 v.AddArg(idx) 10401 v.AddArg(mem) 10402 return true 10403 } 10404 return false 10405 } 10406 func rewriteValue386_Op386MOVSSloadidx4_0(v *Value) bool { 10407 // match: (MOVSSloadidx4 [c] {sym} (ADDLconst [d] ptr) idx mem) 10408 // cond: 10409 // result: (MOVSSloadidx4 [int64(int32(c+d))] {sym} ptr idx mem) 10410 for { 10411 c := v.AuxInt 10412 sym := v.Aux 10413 _ = v.Args[2] 10414 v_0 := v.Args[0] 10415 if v_0.Op != Op386ADDLconst { 10416 break 10417 } 10418 d := v_0.AuxInt 10419 ptr := v_0.Args[0] 10420 idx := v.Args[1] 10421 mem := v.Args[2] 10422 v.reset(Op386MOVSSloadidx4) 10423 v.AuxInt = int64(int32(c + d)) 10424 v.Aux = sym 10425 v.AddArg(ptr) 10426 v.AddArg(idx) 10427 v.AddArg(mem) 10428 return true 10429 } 10430 // match: (MOVSSloadidx4 [c] {sym} ptr (ADDLconst [d] idx) mem) 10431 // cond: 10432 // result: (MOVSSloadidx4 [int64(int32(c+4*d))] {sym} ptr idx mem) 10433 for { 10434 c := v.AuxInt 10435 sym := v.Aux 10436 _ = v.Args[2] 10437 ptr := v.Args[0] 10438 v_1 := v.Args[1] 10439 if v_1.Op != Op386ADDLconst { 10440 break 10441 } 10442 d := v_1.AuxInt 10443 idx := v_1.Args[0] 10444 mem := v.Args[2] 10445 v.reset(Op386MOVSSloadidx4) 10446 v.AuxInt = int64(int32(c + 4*d)) 10447 v.Aux = sym 10448 v.AddArg(ptr) 10449 v.AddArg(idx) 10450 v.AddArg(mem) 10451 return true 10452 } 10453 return false 10454 } 10455 func rewriteValue386_Op386MOVSSstore_0(v *Value) bool { 10456 b := v.Block 10457 _ = b 10458 config := b.Func.Config 10459 _ = config 10460 // match: (MOVSSstore [off1] {sym} (ADDLconst [off2] ptr) val mem) 10461 // cond: is32Bit(off1+off2) 10462 // result: (MOVSSstore [off1+off2] {sym} ptr val mem) 10463 for { 10464 off1 := v.AuxInt 10465 sym := v.Aux 10466 _ = v.Args[2] 10467 v_0 := v.Args[0] 10468 if v_0.Op != Op386ADDLconst { 10469 break 10470 } 10471 off2 := v_0.AuxInt 10472 ptr := v_0.Args[0] 10473 val := v.Args[1] 10474 mem := v.Args[2] 10475 if !(is32Bit(off1 + off2)) { 10476 break 10477 } 10478 v.reset(Op386MOVSSstore) 10479 v.AuxInt = off1 + off2 10480 v.Aux = sym 10481 v.AddArg(ptr) 10482 v.AddArg(val) 10483 v.AddArg(mem) 10484 return true 10485 } 10486 // match: (MOVSSstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem) 10487 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 10488 // result: (MOVSSstore [off1+off2] {mergeSym(sym1,sym2)} base val mem) 10489 for { 10490 off1 := v.AuxInt 10491 sym1 := v.Aux 10492 _ = v.Args[2] 10493 v_0 := v.Args[0] 10494 if v_0.Op != Op386LEAL { 10495 break 10496 } 10497 off2 := v_0.AuxInt 10498 sym2 := v_0.Aux 10499 base := v_0.Args[0] 10500 val := v.Args[1] 10501 mem := v.Args[2] 10502 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 10503 break 10504 } 10505 v.reset(Op386MOVSSstore) 10506 v.AuxInt = off1 + off2 10507 v.Aux = mergeSym(sym1, sym2) 10508 v.AddArg(base) 10509 v.AddArg(val) 10510 v.AddArg(mem) 10511 return true 10512 } 10513 // match: (MOVSSstore [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) val mem) 10514 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 10515 // result: (MOVSSstoreidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem) 10516 for { 10517 off1 := v.AuxInt 10518 sym1 := v.Aux 10519 _ = v.Args[2] 10520 v_0 := v.Args[0] 10521 if v_0.Op != Op386LEAL1 { 10522 break 10523 } 10524 off2 := v_0.AuxInt 10525 sym2 := v_0.Aux 10526 _ = v_0.Args[1] 10527 ptr := v_0.Args[0] 10528 idx := v_0.Args[1] 10529 val := v.Args[1] 10530 mem := v.Args[2] 10531 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 10532 break 10533 } 10534 v.reset(Op386MOVSSstoreidx1) 10535 v.AuxInt = off1 + off2 10536 v.Aux = mergeSym(sym1, sym2) 10537 v.AddArg(ptr) 10538 v.AddArg(idx) 10539 v.AddArg(val) 10540 v.AddArg(mem) 10541 return true 10542 } 10543 // match: (MOVSSstore [off1] {sym1} (LEAL4 [off2] {sym2} ptr idx) val mem) 10544 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 10545 // result: (MOVSSstoreidx4 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem) 10546 for { 10547 off1 := v.AuxInt 10548 sym1 := v.Aux 10549 _ = v.Args[2] 10550 v_0 := v.Args[0] 10551 if v_0.Op != Op386LEAL4 { 10552 break 10553 } 10554 off2 := v_0.AuxInt 10555 sym2 := v_0.Aux 10556 _ = v_0.Args[1] 10557 ptr := v_0.Args[0] 10558 idx := v_0.Args[1] 10559 val := v.Args[1] 10560 mem := v.Args[2] 10561 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 10562 break 10563 } 10564 v.reset(Op386MOVSSstoreidx4) 10565 v.AuxInt = off1 + off2 10566 v.Aux = mergeSym(sym1, sym2) 10567 v.AddArg(ptr) 10568 v.AddArg(idx) 10569 v.AddArg(val) 10570 v.AddArg(mem) 10571 return true 10572 } 10573 // match: (MOVSSstore [off] {sym} (ADDL ptr idx) val mem) 10574 // cond: ptr.Op != OpSB 10575 // result: (MOVSSstoreidx1 [off] {sym} ptr idx val mem) 10576 for { 10577 off := v.AuxInt 10578 sym := v.Aux 10579 _ = v.Args[2] 10580 v_0 := v.Args[0] 10581 if v_0.Op != Op386ADDL { 10582 break 10583 } 10584 _ = v_0.Args[1] 10585 ptr := v_0.Args[0] 10586 idx := v_0.Args[1] 10587 val := v.Args[1] 10588 mem := v.Args[2] 10589 if !(ptr.Op != OpSB) { 10590 break 10591 } 10592 v.reset(Op386MOVSSstoreidx1) 10593 v.AuxInt = off 10594 v.Aux = sym 10595 v.AddArg(ptr) 10596 v.AddArg(idx) 10597 v.AddArg(val) 10598 v.AddArg(mem) 10599 return true 10600 } 10601 return false 10602 } 10603 func rewriteValue386_Op386MOVSSstoreidx1_0(v *Value) bool { 10604 // match: (MOVSSstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem) 10605 // cond: 10606 // result: (MOVSSstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem) 10607 for { 10608 c := v.AuxInt 10609 sym := v.Aux 10610 _ = v.Args[3] 10611 v_0 := v.Args[0] 10612 if v_0.Op != Op386ADDLconst { 10613 break 10614 } 10615 d := v_0.AuxInt 10616 ptr := v_0.Args[0] 10617 idx := v.Args[1] 10618 val := v.Args[2] 10619 mem := v.Args[3] 10620 v.reset(Op386MOVSSstoreidx1) 10621 v.AuxInt = int64(int32(c + d)) 10622 v.Aux = sym 10623 v.AddArg(ptr) 10624 v.AddArg(idx) 10625 v.AddArg(val) 10626 v.AddArg(mem) 10627 return true 10628 } 10629 // match: (MOVSSstoreidx1 [c] {sym} ptr (ADDLconst [d] idx) val mem) 10630 // cond: 10631 // result: (MOVSSstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem) 10632 for { 10633 c := v.AuxInt 10634 sym := v.Aux 10635 _ = v.Args[3] 10636 ptr := v.Args[0] 10637 v_1 := v.Args[1] 10638 if v_1.Op != Op386ADDLconst { 10639 break 10640 } 10641 d := v_1.AuxInt 10642 idx := v_1.Args[0] 10643 val := v.Args[2] 10644 mem := v.Args[3] 10645 v.reset(Op386MOVSSstoreidx1) 10646 v.AuxInt = int64(int32(c + d)) 10647 v.Aux = sym 10648 v.AddArg(ptr) 10649 v.AddArg(idx) 10650 v.AddArg(val) 10651 v.AddArg(mem) 10652 return true 10653 } 10654 return false 10655 } 10656 func rewriteValue386_Op386MOVSSstoreidx4_0(v *Value) bool { 10657 // match: (MOVSSstoreidx4 [c] {sym} (ADDLconst [d] ptr) idx val mem) 10658 // cond: 10659 // result: (MOVSSstoreidx4 [int64(int32(c+d))] {sym} ptr idx val mem) 10660 for { 10661 c := v.AuxInt 10662 sym := v.Aux 10663 _ = v.Args[3] 10664 v_0 := v.Args[0] 10665 if v_0.Op != Op386ADDLconst { 10666 break 10667 } 10668 d := v_0.AuxInt 10669 ptr := v_0.Args[0] 10670 idx := v.Args[1] 10671 val := v.Args[2] 10672 mem := v.Args[3] 10673 v.reset(Op386MOVSSstoreidx4) 10674 v.AuxInt = int64(int32(c + d)) 10675 v.Aux = sym 10676 v.AddArg(ptr) 10677 v.AddArg(idx) 10678 v.AddArg(val) 10679 v.AddArg(mem) 10680 return true 10681 } 10682 // match: (MOVSSstoreidx4 [c] {sym} ptr (ADDLconst [d] idx) val mem) 10683 // cond: 10684 // result: (MOVSSstoreidx4 [int64(int32(c+4*d))] {sym} ptr idx val mem) 10685 for { 10686 c := v.AuxInt 10687 sym := v.Aux 10688 _ = v.Args[3] 10689 ptr := v.Args[0] 10690 v_1 := v.Args[1] 10691 if v_1.Op != Op386ADDLconst { 10692 break 10693 } 10694 d := v_1.AuxInt 10695 idx := v_1.Args[0] 10696 val := v.Args[2] 10697 mem := v.Args[3] 10698 v.reset(Op386MOVSSstoreidx4) 10699 v.AuxInt = int64(int32(c + 4*d)) 10700 v.Aux = sym 10701 v.AddArg(ptr) 10702 v.AddArg(idx) 10703 v.AddArg(val) 10704 v.AddArg(mem) 10705 return true 10706 } 10707 return false 10708 } 10709 func rewriteValue386_Op386MOVWLSX_0(v *Value) bool { 10710 b := v.Block 10711 _ = b 10712 // match: (MOVWLSX x:(MOVWload [off] {sym} ptr mem)) 10713 // cond: x.Uses == 1 && clobber(x) 10714 // result: @x.Block (MOVWLSXload <v.Type> [off] {sym} ptr mem) 10715 for { 10716 x := v.Args[0] 10717 if x.Op != Op386MOVWload { 10718 break 10719 } 10720 off := x.AuxInt 10721 sym := x.Aux 10722 _ = x.Args[1] 10723 ptr := x.Args[0] 10724 mem := x.Args[1] 10725 if !(x.Uses == 1 && clobber(x)) { 10726 break 10727 } 10728 b = x.Block 10729 v0 := b.NewValue0(x.Pos, Op386MOVWLSXload, v.Type) 10730 v.reset(OpCopy) 10731 v.AddArg(v0) 10732 v0.AuxInt = off 10733 v0.Aux = sym 10734 v0.AddArg(ptr) 10735 v0.AddArg(mem) 10736 return true 10737 } 10738 // match: (MOVWLSX (ANDLconst [c] x)) 10739 // cond: c & 0x8000 == 0 10740 // result: (ANDLconst [c & 0x7fff] x) 10741 for { 10742 v_0 := v.Args[0] 10743 if v_0.Op != Op386ANDLconst { 10744 break 10745 } 10746 c := v_0.AuxInt 10747 x := v_0.Args[0] 10748 if !(c&0x8000 == 0) { 10749 break 10750 } 10751 v.reset(Op386ANDLconst) 10752 v.AuxInt = c & 0x7fff 10753 v.AddArg(x) 10754 return true 10755 } 10756 return false 10757 } 10758 func rewriteValue386_Op386MOVWLSXload_0(v *Value) bool { 10759 b := v.Block 10760 _ = b 10761 config := b.Func.Config 10762 _ = config 10763 // match: (MOVWLSXload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _)) 10764 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 10765 // result: (MOVWLSX x) 10766 for { 10767 off := v.AuxInt 10768 sym := v.Aux 10769 _ = v.Args[1] 10770 ptr := v.Args[0] 10771 v_1 := v.Args[1] 10772 if v_1.Op != Op386MOVWstore { 10773 break 10774 } 10775 off2 := v_1.AuxInt 10776 sym2 := v_1.Aux 10777 _ = v_1.Args[2] 10778 ptr2 := v_1.Args[0] 10779 x := v_1.Args[1] 10780 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 10781 break 10782 } 10783 v.reset(Op386MOVWLSX) 10784 v.AddArg(x) 10785 return true 10786 } 10787 // match: (MOVWLSXload [off1] {sym1} (LEAL [off2] {sym2} base) mem) 10788 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 10789 // result: (MOVWLSXload [off1+off2] {mergeSym(sym1,sym2)} base mem) 10790 for { 10791 off1 := v.AuxInt 10792 sym1 := v.Aux 10793 _ = v.Args[1] 10794 v_0 := v.Args[0] 10795 if v_0.Op != Op386LEAL { 10796 break 10797 } 10798 off2 := v_0.AuxInt 10799 sym2 := v_0.Aux 10800 base := v_0.Args[0] 10801 mem := v.Args[1] 10802 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 10803 break 10804 } 10805 v.reset(Op386MOVWLSXload) 10806 v.AuxInt = off1 + off2 10807 v.Aux = mergeSym(sym1, sym2) 10808 v.AddArg(base) 10809 v.AddArg(mem) 10810 return true 10811 } 10812 return false 10813 } 10814 func rewriteValue386_Op386MOVWLZX_0(v *Value) bool { 10815 b := v.Block 10816 _ = b 10817 // match: (MOVWLZX x:(MOVWload [off] {sym} ptr mem)) 10818 // cond: x.Uses == 1 && clobber(x) 10819 // result: @x.Block (MOVWload <v.Type> [off] {sym} ptr mem) 10820 for { 10821 x := v.Args[0] 10822 if x.Op != Op386MOVWload { 10823 break 10824 } 10825 off := x.AuxInt 10826 sym := x.Aux 10827 _ = x.Args[1] 10828 ptr := x.Args[0] 10829 mem := x.Args[1] 10830 if !(x.Uses == 1 && clobber(x)) { 10831 break 10832 } 10833 b = x.Block 10834 v0 := b.NewValue0(x.Pos, Op386MOVWload, v.Type) 10835 v.reset(OpCopy) 10836 v.AddArg(v0) 10837 v0.AuxInt = off 10838 v0.Aux = sym 10839 v0.AddArg(ptr) 10840 v0.AddArg(mem) 10841 return true 10842 } 10843 // match: (MOVWLZX x:(MOVWloadidx1 [off] {sym} ptr idx mem)) 10844 // cond: x.Uses == 1 && clobber(x) 10845 // result: @x.Block (MOVWloadidx1 <v.Type> [off] {sym} ptr idx mem) 10846 for { 10847 x := v.Args[0] 10848 if x.Op != Op386MOVWloadidx1 { 10849 break 10850 } 10851 off := x.AuxInt 10852 sym := x.Aux 10853 _ = x.Args[2] 10854 ptr := x.Args[0] 10855 idx := x.Args[1] 10856 mem := x.Args[2] 10857 if !(x.Uses == 1 && clobber(x)) { 10858 break 10859 } 10860 b = x.Block 10861 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type) 10862 v.reset(OpCopy) 10863 v.AddArg(v0) 10864 v0.AuxInt = off 10865 v0.Aux = sym 10866 v0.AddArg(ptr) 10867 v0.AddArg(idx) 10868 v0.AddArg(mem) 10869 return true 10870 } 10871 // match: (MOVWLZX x:(MOVWloadidx2 [off] {sym} ptr idx mem)) 10872 // cond: x.Uses == 1 && clobber(x) 10873 // result: @x.Block (MOVWloadidx2 <v.Type> [off] {sym} ptr idx mem) 10874 for { 10875 x := v.Args[0] 10876 if x.Op != Op386MOVWloadidx2 { 10877 break 10878 } 10879 off := x.AuxInt 10880 sym := x.Aux 10881 _ = x.Args[2] 10882 ptr := x.Args[0] 10883 idx := x.Args[1] 10884 mem := x.Args[2] 10885 if !(x.Uses == 1 && clobber(x)) { 10886 break 10887 } 10888 b = x.Block 10889 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx2, v.Type) 10890 v.reset(OpCopy) 10891 v.AddArg(v0) 10892 v0.AuxInt = off 10893 v0.Aux = sym 10894 v0.AddArg(ptr) 10895 v0.AddArg(idx) 10896 v0.AddArg(mem) 10897 return true 10898 } 10899 // match: (MOVWLZX (ANDLconst [c] x)) 10900 // cond: 10901 // result: (ANDLconst [c & 0xffff] x) 10902 for { 10903 v_0 := v.Args[0] 10904 if v_0.Op != Op386ANDLconst { 10905 break 10906 } 10907 c := v_0.AuxInt 10908 x := v_0.Args[0] 10909 v.reset(Op386ANDLconst) 10910 v.AuxInt = c & 0xffff 10911 v.AddArg(x) 10912 return true 10913 } 10914 return false 10915 } 10916 func rewriteValue386_Op386MOVWload_0(v *Value) bool { 10917 b := v.Block 10918 _ = b 10919 config := b.Func.Config 10920 _ = config 10921 // match: (MOVWload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _)) 10922 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 10923 // result: (MOVWLZX x) 10924 for { 10925 off := v.AuxInt 10926 sym := v.Aux 10927 _ = v.Args[1] 10928 ptr := v.Args[0] 10929 v_1 := v.Args[1] 10930 if v_1.Op != Op386MOVWstore { 10931 break 10932 } 10933 off2 := v_1.AuxInt 10934 sym2 := v_1.Aux 10935 _ = v_1.Args[2] 10936 ptr2 := v_1.Args[0] 10937 x := v_1.Args[1] 10938 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 10939 break 10940 } 10941 v.reset(Op386MOVWLZX) 10942 v.AddArg(x) 10943 return true 10944 } 10945 // match: (MOVWload [off1] {sym} (ADDLconst [off2] ptr) mem) 10946 // cond: is32Bit(off1+off2) 10947 // result: (MOVWload [off1+off2] {sym} ptr mem) 10948 for { 10949 off1 := v.AuxInt 10950 sym := v.Aux 10951 _ = v.Args[1] 10952 v_0 := v.Args[0] 10953 if v_0.Op != Op386ADDLconst { 10954 break 10955 } 10956 off2 := v_0.AuxInt 10957 ptr := v_0.Args[0] 10958 mem := v.Args[1] 10959 if !(is32Bit(off1 + off2)) { 10960 break 10961 } 10962 v.reset(Op386MOVWload) 10963 v.AuxInt = off1 + off2 10964 v.Aux = sym 10965 v.AddArg(ptr) 10966 v.AddArg(mem) 10967 return true 10968 } 10969 // match: (MOVWload [off1] {sym1} (LEAL [off2] {sym2} base) mem) 10970 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 10971 // result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} base mem) 10972 for { 10973 off1 := v.AuxInt 10974 sym1 := v.Aux 10975 _ = v.Args[1] 10976 v_0 := v.Args[0] 10977 if v_0.Op != Op386LEAL { 10978 break 10979 } 10980 off2 := v_0.AuxInt 10981 sym2 := v_0.Aux 10982 base := v_0.Args[0] 10983 mem := v.Args[1] 10984 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 10985 break 10986 } 10987 v.reset(Op386MOVWload) 10988 v.AuxInt = off1 + off2 10989 v.Aux = mergeSym(sym1, sym2) 10990 v.AddArg(base) 10991 v.AddArg(mem) 10992 return true 10993 } 10994 // match: (MOVWload [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) mem) 10995 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 10996 // result: (MOVWloadidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem) 10997 for { 10998 off1 := v.AuxInt 10999 sym1 := v.Aux 11000 _ = v.Args[1] 11001 v_0 := v.Args[0] 11002 if v_0.Op != Op386LEAL1 { 11003 break 11004 } 11005 off2 := v_0.AuxInt 11006 sym2 := v_0.Aux 11007 _ = v_0.Args[1] 11008 ptr := v_0.Args[0] 11009 idx := v_0.Args[1] 11010 mem := v.Args[1] 11011 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 11012 break 11013 } 11014 v.reset(Op386MOVWloadidx1) 11015 v.AuxInt = off1 + off2 11016 v.Aux = mergeSym(sym1, sym2) 11017 v.AddArg(ptr) 11018 v.AddArg(idx) 11019 v.AddArg(mem) 11020 return true 11021 } 11022 // match: (MOVWload [off1] {sym1} (LEAL2 [off2] {sym2} ptr idx) mem) 11023 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 11024 // result: (MOVWloadidx2 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem) 11025 for { 11026 off1 := v.AuxInt 11027 sym1 := v.Aux 11028 _ = v.Args[1] 11029 v_0 := v.Args[0] 11030 if v_0.Op != Op386LEAL2 { 11031 break 11032 } 11033 off2 := v_0.AuxInt 11034 sym2 := v_0.Aux 11035 _ = v_0.Args[1] 11036 ptr := v_0.Args[0] 11037 idx := v_0.Args[1] 11038 mem := v.Args[1] 11039 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 11040 break 11041 } 11042 v.reset(Op386MOVWloadidx2) 11043 v.AuxInt = off1 + off2 11044 v.Aux = mergeSym(sym1, sym2) 11045 v.AddArg(ptr) 11046 v.AddArg(idx) 11047 v.AddArg(mem) 11048 return true 11049 } 11050 // match: (MOVWload [off] {sym} (ADDL ptr idx) mem) 11051 // cond: ptr.Op != OpSB 11052 // result: (MOVWloadidx1 [off] {sym} ptr idx mem) 11053 for { 11054 off := v.AuxInt 11055 sym := v.Aux 11056 _ = v.Args[1] 11057 v_0 := v.Args[0] 11058 if v_0.Op != Op386ADDL { 11059 break 11060 } 11061 _ = v_0.Args[1] 11062 ptr := v_0.Args[0] 11063 idx := v_0.Args[1] 11064 mem := v.Args[1] 11065 if !(ptr.Op != OpSB) { 11066 break 11067 } 11068 v.reset(Op386MOVWloadidx1) 11069 v.AuxInt = off 11070 v.Aux = sym 11071 v.AddArg(ptr) 11072 v.AddArg(idx) 11073 v.AddArg(mem) 11074 return true 11075 } 11076 // match: (MOVWload [off] {sym} (SB) _) 11077 // cond: symIsRO(sym) 11078 // result: (MOVLconst [int64(read16(sym, off, config.BigEndian))]) 11079 for { 11080 off := v.AuxInt 11081 sym := v.Aux 11082 _ = v.Args[1] 11083 v_0 := v.Args[0] 11084 if v_0.Op != OpSB { 11085 break 11086 } 11087 if !(symIsRO(sym)) { 11088 break 11089 } 11090 v.reset(Op386MOVLconst) 11091 v.AuxInt = int64(read16(sym, off, config.BigEndian)) 11092 return true 11093 } 11094 return false 11095 } 11096 func rewriteValue386_Op386MOVWloadidx1_0(v *Value) bool { 11097 // match: (MOVWloadidx1 [c] {sym} ptr (SHLLconst [1] idx) mem) 11098 // cond: 11099 // result: (MOVWloadidx2 [c] {sym} ptr idx mem) 11100 for { 11101 c := v.AuxInt 11102 sym := v.Aux 11103 _ = v.Args[2] 11104 ptr := v.Args[0] 11105 v_1 := v.Args[1] 11106 if v_1.Op != Op386SHLLconst { 11107 break 11108 } 11109 if v_1.AuxInt != 1 { 11110 break 11111 } 11112 idx := v_1.Args[0] 11113 mem := v.Args[2] 11114 v.reset(Op386MOVWloadidx2) 11115 v.AuxInt = c 11116 v.Aux = sym 11117 v.AddArg(ptr) 11118 v.AddArg(idx) 11119 v.AddArg(mem) 11120 return true 11121 } 11122 // match: (MOVWloadidx1 [c] {sym} (SHLLconst [1] idx) ptr mem) 11123 // cond: 11124 // result: (MOVWloadidx2 [c] {sym} ptr idx mem) 11125 for { 11126 c := v.AuxInt 11127 sym := v.Aux 11128 _ = v.Args[2] 11129 v_0 := v.Args[0] 11130 if v_0.Op != Op386SHLLconst { 11131 break 11132 } 11133 if v_0.AuxInt != 1 { 11134 break 11135 } 11136 idx := v_0.Args[0] 11137 ptr := v.Args[1] 11138 mem := v.Args[2] 11139 v.reset(Op386MOVWloadidx2) 11140 v.AuxInt = c 11141 v.Aux = sym 11142 v.AddArg(ptr) 11143 v.AddArg(idx) 11144 v.AddArg(mem) 11145 return true 11146 } 11147 // match: (MOVWloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem) 11148 // cond: 11149 // result: (MOVWloadidx1 [int64(int32(c+d))] {sym} ptr idx mem) 11150 for { 11151 c := v.AuxInt 11152 sym := v.Aux 11153 _ = v.Args[2] 11154 v_0 := v.Args[0] 11155 if v_0.Op != Op386ADDLconst { 11156 break 11157 } 11158 d := v_0.AuxInt 11159 ptr := v_0.Args[0] 11160 idx := v.Args[1] 11161 mem := v.Args[2] 11162 v.reset(Op386MOVWloadidx1) 11163 v.AuxInt = int64(int32(c + d)) 11164 v.Aux = sym 11165 v.AddArg(ptr) 11166 v.AddArg(idx) 11167 v.AddArg(mem) 11168 return true 11169 } 11170 // match: (MOVWloadidx1 [c] {sym} idx (ADDLconst [d] ptr) mem) 11171 // cond: 11172 // result: (MOVWloadidx1 [int64(int32(c+d))] {sym} ptr idx mem) 11173 for { 11174 c := v.AuxInt 11175 sym := v.Aux 11176 _ = v.Args[2] 11177 idx := v.Args[0] 11178 v_1 := v.Args[1] 11179 if v_1.Op != Op386ADDLconst { 11180 break 11181 } 11182 d := v_1.AuxInt 11183 ptr := v_1.Args[0] 11184 mem := v.Args[2] 11185 v.reset(Op386MOVWloadidx1) 11186 v.AuxInt = int64(int32(c + d)) 11187 v.Aux = sym 11188 v.AddArg(ptr) 11189 v.AddArg(idx) 11190 v.AddArg(mem) 11191 return true 11192 } 11193 // match: (MOVWloadidx1 [c] {sym} ptr (ADDLconst [d] idx) mem) 11194 // cond: 11195 // result: (MOVWloadidx1 [int64(int32(c+d))] {sym} ptr idx mem) 11196 for { 11197 c := v.AuxInt 11198 sym := v.Aux 11199 _ = v.Args[2] 11200 ptr := v.Args[0] 11201 v_1 := v.Args[1] 11202 if v_1.Op != Op386ADDLconst { 11203 break 11204 } 11205 d := v_1.AuxInt 11206 idx := v_1.Args[0] 11207 mem := v.Args[2] 11208 v.reset(Op386MOVWloadidx1) 11209 v.AuxInt = int64(int32(c + d)) 11210 v.Aux = sym 11211 v.AddArg(ptr) 11212 v.AddArg(idx) 11213 v.AddArg(mem) 11214 return true 11215 } 11216 // match: (MOVWloadidx1 [c] {sym} (ADDLconst [d] idx) ptr mem) 11217 // cond: 11218 // result: (MOVWloadidx1 [int64(int32(c+d))] {sym} ptr idx mem) 11219 for { 11220 c := v.AuxInt 11221 sym := v.Aux 11222 _ = v.Args[2] 11223 v_0 := v.Args[0] 11224 if v_0.Op != Op386ADDLconst { 11225 break 11226 } 11227 d := v_0.AuxInt 11228 idx := v_0.Args[0] 11229 ptr := v.Args[1] 11230 mem := v.Args[2] 11231 v.reset(Op386MOVWloadidx1) 11232 v.AuxInt = int64(int32(c + d)) 11233 v.Aux = sym 11234 v.AddArg(ptr) 11235 v.AddArg(idx) 11236 v.AddArg(mem) 11237 return true 11238 } 11239 return false 11240 } 11241 func rewriteValue386_Op386MOVWloadidx2_0(v *Value) bool { 11242 // match: (MOVWloadidx2 [c] {sym} (ADDLconst [d] ptr) idx mem) 11243 // cond: 11244 // result: (MOVWloadidx2 [int64(int32(c+d))] {sym} ptr idx mem) 11245 for { 11246 c := v.AuxInt 11247 sym := v.Aux 11248 _ = v.Args[2] 11249 v_0 := v.Args[0] 11250 if v_0.Op != Op386ADDLconst { 11251 break 11252 } 11253 d := v_0.AuxInt 11254 ptr := v_0.Args[0] 11255 idx := v.Args[1] 11256 mem := v.Args[2] 11257 v.reset(Op386MOVWloadidx2) 11258 v.AuxInt = int64(int32(c + d)) 11259 v.Aux = sym 11260 v.AddArg(ptr) 11261 v.AddArg(idx) 11262 v.AddArg(mem) 11263 return true 11264 } 11265 // match: (MOVWloadidx2 [c] {sym} ptr (ADDLconst [d] idx) mem) 11266 // cond: 11267 // result: (MOVWloadidx2 [int64(int32(c+2*d))] {sym} ptr idx mem) 11268 for { 11269 c := v.AuxInt 11270 sym := v.Aux 11271 _ = v.Args[2] 11272 ptr := v.Args[0] 11273 v_1 := v.Args[1] 11274 if v_1.Op != Op386ADDLconst { 11275 break 11276 } 11277 d := v_1.AuxInt 11278 idx := v_1.Args[0] 11279 mem := v.Args[2] 11280 v.reset(Op386MOVWloadidx2) 11281 v.AuxInt = int64(int32(c + 2*d)) 11282 v.Aux = sym 11283 v.AddArg(ptr) 11284 v.AddArg(idx) 11285 v.AddArg(mem) 11286 return true 11287 } 11288 return false 11289 } 11290 func rewriteValue386_Op386MOVWstore_0(v *Value) bool { 11291 b := v.Block 11292 _ = b 11293 config := b.Func.Config 11294 _ = config 11295 // match: (MOVWstore [off] {sym} ptr (MOVWLSX x) mem) 11296 // cond: 11297 // result: (MOVWstore [off] {sym} ptr x mem) 11298 for { 11299 off := v.AuxInt 11300 sym := v.Aux 11301 _ = v.Args[2] 11302 ptr := v.Args[0] 11303 v_1 := v.Args[1] 11304 if v_1.Op != Op386MOVWLSX { 11305 break 11306 } 11307 x := v_1.Args[0] 11308 mem := v.Args[2] 11309 v.reset(Op386MOVWstore) 11310 v.AuxInt = off 11311 v.Aux = sym 11312 v.AddArg(ptr) 11313 v.AddArg(x) 11314 v.AddArg(mem) 11315 return true 11316 } 11317 // match: (MOVWstore [off] {sym} ptr (MOVWLZX x) mem) 11318 // cond: 11319 // result: (MOVWstore [off] {sym} ptr x mem) 11320 for { 11321 off := v.AuxInt 11322 sym := v.Aux 11323 _ = v.Args[2] 11324 ptr := v.Args[0] 11325 v_1 := v.Args[1] 11326 if v_1.Op != Op386MOVWLZX { 11327 break 11328 } 11329 x := v_1.Args[0] 11330 mem := v.Args[2] 11331 v.reset(Op386MOVWstore) 11332 v.AuxInt = off 11333 v.Aux = sym 11334 v.AddArg(ptr) 11335 v.AddArg(x) 11336 v.AddArg(mem) 11337 return true 11338 } 11339 // match: (MOVWstore [off1] {sym} (ADDLconst [off2] ptr) val mem) 11340 // cond: is32Bit(off1+off2) 11341 // result: (MOVWstore [off1+off2] {sym} ptr val mem) 11342 for { 11343 off1 := v.AuxInt 11344 sym := v.Aux 11345 _ = v.Args[2] 11346 v_0 := v.Args[0] 11347 if v_0.Op != Op386ADDLconst { 11348 break 11349 } 11350 off2 := v_0.AuxInt 11351 ptr := v_0.Args[0] 11352 val := v.Args[1] 11353 mem := v.Args[2] 11354 if !(is32Bit(off1 + off2)) { 11355 break 11356 } 11357 v.reset(Op386MOVWstore) 11358 v.AuxInt = off1 + off2 11359 v.Aux = sym 11360 v.AddArg(ptr) 11361 v.AddArg(val) 11362 v.AddArg(mem) 11363 return true 11364 } 11365 // match: (MOVWstore [off] {sym} ptr (MOVLconst [c]) mem) 11366 // cond: validOff(off) 11367 // result: (MOVWstoreconst [makeValAndOff(int64(int16(c)),off)] {sym} ptr mem) 11368 for { 11369 off := v.AuxInt 11370 sym := v.Aux 11371 _ = v.Args[2] 11372 ptr := v.Args[0] 11373 v_1 := v.Args[1] 11374 if v_1.Op != Op386MOVLconst { 11375 break 11376 } 11377 c := v_1.AuxInt 11378 mem := v.Args[2] 11379 if !(validOff(off)) { 11380 break 11381 } 11382 v.reset(Op386MOVWstoreconst) 11383 v.AuxInt = makeValAndOff(int64(int16(c)), off) 11384 v.Aux = sym 11385 v.AddArg(ptr) 11386 v.AddArg(mem) 11387 return true 11388 } 11389 // match: (MOVWstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem) 11390 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 11391 // result: (MOVWstore [off1+off2] {mergeSym(sym1,sym2)} base val mem) 11392 for { 11393 off1 := v.AuxInt 11394 sym1 := v.Aux 11395 _ = v.Args[2] 11396 v_0 := v.Args[0] 11397 if v_0.Op != Op386LEAL { 11398 break 11399 } 11400 off2 := v_0.AuxInt 11401 sym2 := v_0.Aux 11402 base := v_0.Args[0] 11403 val := v.Args[1] 11404 mem := v.Args[2] 11405 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 11406 break 11407 } 11408 v.reset(Op386MOVWstore) 11409 v.AuxInt = off1 + off2 11410 v.Aux = mergeSym(sym1, sym2) 11411 v.AddArg(base) 11412 v.AddArg(val) 11413 v.AddArg(mem) 11414 return true 11415 } 11416 // match: (MOVWstore [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) val mem) 11417 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 11418 // result: (MOVWstoreidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem) 11419 for { 11420 off1 := v.AuxInt 11421 sym1 := v.Aux 11422 _ = v.Args[2] 11423 v_0 := v.Args[0] 11424 if v_0.Op != Op386LEAL1 { 11425 break 11426 } 11427 off2 := v_0.AuxInt 11428 sym2 := v_0.Aux 11429 _ = v_0.Args[1] 11430 ptr := v_0.Args[0] 11431 idx := v_0.Args[1] 11432 val := v.Args[1] 11433 mem := v.Args[2] 11434 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 11435 break 11436 } 11437 v.reset(Op386MOVWstoreidx1) 11438 v.AuxInt = off1 + off2 11439 v.Aux = mergeSym(sym1, sym2) 11440 v.AddArg(ptr) 11441 v.AddArg(idx) 11442 v.AddArg(val) 11443 v.AddArg(mem) 11444 return true 11445 } 11446 // match: (MOVWstore [off1] {sym1} (LEAL2 [off2] {sym2} ptr idx) val mem) 11447 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 11448 // result: (MOVWstoreidx2 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem) 11449 for { 11450 off1 := v.AuxInt 11451 sym1 := v.Aux 11452 _ = v.Args[2] 11453 v_0 := v.Args[0] 11454 if v_0.Op != Op386LEAL2 { 11455 break 11456 } 11457 off2 := v_0.AuxInt 11458 sym2 := v_0.Aux 11459 _ = v_0.Args[1] 11460 ptr := v_0.Args[0] 11461 idx := v_0.Args[1] 11462 val := v.Args[1] 11463 mem := v.Args[2] 11464 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 11465 break 11466 } 11467 v.reset(Op386MOVWstoreidx2) 11468 v.AuxInt = off1 + off2 11469 v.Aux = mergeSym(sym1, sym2) 11470 v.AddArg(ptr) 11471 v.AddArg(idx) 11472 v.AddArg(val) 11473 v.AddArg(mem) 11474 return true 11475 } 11476 // match: (MOVWstore [off] {sym} (ADDL ptr idx) val mem) 11477 // cond: ptr.Op != OpSB 11478 // result: (MOVWstoreidx1 [off] {sym} ptr idx val mem) 11479 for { 11480 off := v.AuxInt 11481 sym := v.Aux 11482 _ = v.Args[2] 11483 v_0 := v.Args[0] 11484 if v_0.Op != Op386ADDL { 11485 break 11486 } 11487 _ = v_0.Args[1] 11488 ptr := v_0.Args[0] 11489 idx := v_0.Args[1] 11490 val := v.Args[1] 11491 mem := v.Args[2] 11492 if !(ptr.Op != OpSB) { 11493 break 11494 } 11495 v.reset(Op386MOVWstoreidx1) 11496 v.AuxInt = off 11497 v.Aux = sym 11498 v.AddArg(ptr) 11499 v.AddArg(idx) 11500 v.AddArg(val) 11501 v.AddArg(mem) 11502 return true 11503 } 11504 // match: (MOVWstore [i] {s} p (SHRLconst [16] w) x:(MOVWstore [i-2] {s} p w mem)) 11505 // cond: x.Uses == 1 && clobber(x) 11506 // result: (MOVLstore [i-2] {s} p w mem) 11507 for { 11508 i := v.AuxInt 11509 s := v.Aux 11510 _ = v.Args[2] 11511 p := v.Args[0] 11512 v_1 := v.Args[1] 11513 if v_1.Op != Op386SHRLconst { 11514 break 11515 } 11516 if v_1.AuxInt != 16 { 11517 break 11518 } 11519 w := v_1.Args[0] 11520 x := v.Args[2] 11521 if x.Op != Op386MOVWstore { 11522 break 11523 } 11524 if x.AuxInt != i-2 { 11525 break 11526 } 11527 if x.Aux != s { 11528 break 11529 } 11530 _ = x.Args[2] 11531 if p != x.Args[0] { 11532 break 11533 } 11534 if w != x.Args[1] { 11535 break 11536 } 11537 mem := x.Args[2] 11538 if !(x.Uses == 1 && clobber(x)) { 11539 break 11540 } 11541 v.reset(Op386MOVLstore) 11542 v.AuxInt = i - 2 11543 v.Aux = s 11544 v.AddArg(p) 11545 v.AddArg(w) 11546 v.AddArg(mem) 11547 return true 11548 } 11549 // match: (MOVWstore [i] {s} p (SHRLconst [j] w) x:(MOVWstore [i-2] {s} p w0:(SHRLconst [j-16] w) mem)) 11550 // cond: x.Uses == 1 && clobber(x) 11551 // result: (MOVLstore [i-2] {s} p w0 mem) 11552 for { 11553 i := v.AuxInt 11554 s := v.Aux 11555 _ = v.Args[2] 11556 p := v.Args[0] 11557 v_1 := v.Args[1] 11558 if v_1.Op != Op386SHRLconst { 11559 break 11560 } 11561 j := v_1.AuxInt 11562 w := v_1.Args[0] 11563 x := v.Args[2] 11564 if x.Op != Op386MOVWstore { 11565 break 11566 } 11567 if x.AuxInt != i-2 { 11568 break 11569 } 11570 if x.Aux != s { 11571 break 11572 } 11573 _ = x.Args[2] 11574 if p != x.Args[0] { 11575 break 11576 } 11577 w0 := x.Args[1] 11578 if w0.Op != Op386SHRLconst { 11579 break 11580 } 11581 if w0.AuxInt != j-16 { 11582 break 11583 } 11584 if w != w0.Args[0] { 11585 break 11586 } 11587 mem := x.Args[2] 11588 if !(x.Uses == 1 && clobber(x)) { 11589 break 11590 } 11591 v.reset(Op386MOVLstore) 11592 v.AuxInt = i - 2 11593 v.Aux = s 11594 v.AddArg(p) 11595 v.AddArg(w0) 11596 v.AddArg(mem) 11597 return true 11598 } 11599 return false 11600 } 11601 func rewriteValue386_Op386MOVWstoreconst_0(v *Value) bool { 11602 b := v.Block 11603 _ = b 11604 config := b.Func.Config 11605 _ = config 11606 // match: (MOVWstoreconst [sc] {s} (ADDLconst [off] ptr) mem) 11607 // cond: ValAndOff(sc).canAdd(off) 11608 // result: (MOVWstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) 11609 for { 11610 sc := v.AuxInt 11611 s := v.Aux 11612 _ = v.Args[1] 11613 v_0 := v.Args[0] 11614 if v_0.Op != Op386ADDLconst { 11615 break 11616 } 11617 off := v_0.AuxInt 11618 ptr := v_0.Args[0] 11619 mem := v.Args[1] 11620 if !(ValAndOff(sc).canAdd(off)) { 11621 break 11622 } 11623 v.reset(Op386MOVWstoreconst) 11624 v.AuxInt = ValAndOff(sc).add(off) 11625 v.Aux = s 11626 v.AddArg(ptr) 11627 v.AddArg(mem) 11628 return true 11629 } 11630 // match: (MOVWstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem) 11631 // cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) && (ptr.Op != OpSB || !config.ctxt.Flag_shared) 11632 // result: (MOVWstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem) 11633 for { 11634 sc := v.AuxInt 11635 sym1 := v.Aux 11636 _ = v.Args[1] 11637 v_0 := v.Args[0] 11638 if v_0.Op != Op386LEAL { 11639 break 11640 } 11641 off := v_0.AuxInt 11642 sym2 := v_0.Aux 11643 ptr := v_0.Args[0] 11644 mem := v.Args[1] 11645 if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) && (ptr.Op != OpSB || !config.ctxt.Flag_shared)) { 11646 break 11647 } 11648 v.reset(Op386MOVWstoreconst) 11649 v.AuxInt = ValAndOff(sc).add(off) 11650 v.Aux = mergeSym(sym1, sym2) 11651 v.AddArg(ptr) 11652 v.AddArg(mem) 11653 return true 11654 } 11655 // match: (MOVWstoreconst [x] {sym1} (LEAL1 [off] {sym2} ptr idx) mem) 11656 // cond: canMergeSym(sym1, sym2) 11657 // result: (MOVWstoreconstidx1 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem) 11658 for { 11659 x := v.AuxInt 11660 sym1 := v.Aux 11661 _ = v.Args[1] 11662 v_0 := v.Args[0] 11663 if v_0.Op != Op386LEAL1 { 11664 break 11665 } 11666 off := v_0.AuxInt 11667 sym2 := v_0.Aux 11668 _ = v_0.Args[1] 11669 ptr := v_0.Args[0] 11670 idx := v_0.Args[1] 11671 mem := v.Args[1] 11672 if !(canMergeSym(sym1, sym2)) { 11673 break 11674 } 11675 v.reset(Op386MOVWstoreconstidx1) 11676 v.AuxInt = ValAndOff(x).add(off) 11677 v.Aux = mergeSym(sym1, sym2) 11678 v.AddArg(ptr) 11679 v.AddArg(idx) 11680 v.AddArg(mem) 11681 return true 11682 } 11683 // match: (MOVWstoreconst [x] {sym1} (LEAL2 [off] {sym2} ptr idx) mem) 11684 // cond: canMergeSym(sym1, sym2) 11685 // result: (MOVWstoreconstidx2 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem) 11686 for { 11687 x := v.AuxInt 11688 sym1 := v.Aux 11689 _ = v.Args[1] 11690 v_0 := v.Args[0] 11691 if v_0.Op != Op386LEAL2 { 11692 break 11693 } 11694 off := v_0.AuxInt 11695 sym2 := v_0.Aux 11696 _ = v_0.Args[1] 11697 ptr := v_0.Args[0] 11698 idx := v_0.Args[1] 11699 mem := v.Args[1] 11700 if !(canMergeSym(sym1, sym2)) { 11701 break 11702 } 11703 v.reset(Op386MOVWstoreconstidx2) 11704 v.AuxInt = ValAndOff(x).add(off) 11705 v.Aux = mergeSym(sym1, sym2) 11706 v.AddArg(ptr) 11707 v.AddArg(idx) 11708 v.AddArg(mem) 11709 return true 11710 } 11711 // match: (MOVWstoreconst [x] {sym} (ADDL ptr idx) mem) 11712 // cond: 11713 // result: (MOVWstoreconstidx1 [x] {sym} ptr idx mem) 11714 for { 11715 x := v.AuxInt 11716 sym := v.Aux 11717 _ = v.Args[1] 11718 v_0 := v.Args[0] 11719 if v_0.Op != Op386ADDL { 11720 break 11721 } 11722 _ = v_0.Args[1] 11723 ptr := v_0.Args[0] 11724 idx := v_0.Args[1] 11725 mem := v.Args[1] 11726 v.reset(Op386MOVWstoreconstidx1) 11727 v.AuxInt = x 11728 v.Aux = sym 11729 v.AddArg(ptr) 11730 v.AddArg(idx) 11731 v.AddArg(mem) 11732 return true 11733 } 11734 // match: (MOVWstoreconst [c] {s} p x:(MOVWstoreconst [a] {s} p mem)) 11735 // cond: x.Uses == 1 && ValAndOff(a).Off() + 2 == ValAndOff(c).Off() && clobber(x) 11736 // result: (MOVLstoreconst [makeValAndOff(ValAndOff(a).Val()&0xffff | ValAndOff(c).Val()<<16, ValAndOff(a).Off())] {s} p mem) 11737 for { 11738 c := v.AuxInt 11739 s := v.Aux 11740 _ = v.Args[1] 11741 p := v.Args[0] 11742 x := v.Args[1] 11743 if x.Op != Op386MOVWstoreconst { 11744 break 11745 } 11746 a := x.AuxInt 11747 if x.Aux != s { 11748 break 11749 } 11750 _ = x.Args[1] 11751 if p != x.Args[0] { 11752 break 11753 } 11754 mem := x.Args[1] 11755 if !(x.Uses == 1 && ValAndOff(a).Off()+2 == ValAndOff(c).Off() && clobber(x)) { 11756 break 11757 } 11758 v.reset(Op386MOVLstoreconst) 11759 v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xffff|ValAndOff(c).Val()<<16, ValAndOff(a).Off()) 11760 v.Aux = s 11761 v.AddArg(p) 11762 v.AddArg(mem) 11763 return true 11764 } 11765 // match: (MOVWstoreconst [a] {s} p x:(MOVWstoreconst [c] {s} p mem)) 11766 // cond: x.Uses == 1 && ValAndOff(a).Off() + 2 == ValAndOff(c).Off() && clobber(x) 11767 // result: (MOVLstoreconst [makeValAndOff(ValAndOff(a).Val()&0xffff | ValAndOff(c).Val()<<16, ValAndOff(a).Off())] {s} p mem) 11768 for { 11769 a := v.AuxInt 11770 s := v.Aux 11771 _ = v.Args[1] 11772 p := v.Args[0] 11773 x := v.Args[1] 11774 if x.Op != Op386MOVWstoreconst { 11775 break 11776 } 11777 c := x.AuxInt 11778 if x.Aux != s { 11779 break 11780 } 11781 _ = x.Args[1] 11782 if p != x.Args[0] { 11783 break 11784 } 11785 mem := x.Args[1] 11786 if !(x.Uses == 1 && ValAndOff(a).Off()+2 == ValAndOff(c).Off() && clobber(x)) { 11787 break 11788 } 11789 v.reset(Op386MOVLstoreconst) 11790 v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xffff|ValAndOff(c).Val()<<16, ValAndOff(a).Off()) 11791 v.Aux = s 11792 v.AddArg(p) 11793 v.AddArg(mem) 11794 return true 11795 } 11796 return false 11797 } 11798 func rewriteValue386_Op386MOVWstoreconstidx1_0(v *Value) bool { 11799 // match: (MOVWstoreconstidx1 [c] {sym} ptr (SHLLconst [1] idx) mem) 11800 // cond: 11801 // result: (MOVWstoreconstidx2 [c] {sym} ptr idx mem) 11802 for { 11803 c := v.AuxInt 11804 sym := v.Aux 11805 _ = v.Args[2] 11806 ptr := v.Args[0] 11807 v_1 := v.Args[1] 11808 if v_1.Op != Op386SHLLconst { 11809 break 11810 } 11811 if v_1.AuxInt != 1 { 11812 break 11813 } 11814 idx := v_1.Args[0] 11815 mem := v.Args[2] 11816 v.reset(Op386MOVWstoreconstidx2) 11817 v.AuxInt = c 11818 v.Aux = sym 11819 v.AddArg(ptr) 11820 v.AddArg(idx) 11821 v.AddArg(mem) 11822 return true 11823 } 11824 // match: (MOVWstoreconstidx1 [x] {sym} (ADDLconst [c] ptr) idx mem) 11825 // cond: 11826 // result: (MOVWstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem) 11827 for { 11828 x := v.AuxInt 11829 sym := v.Aux 11830 _ = v.Args[2] 11831 v_0 := v.Args[0] 11832 if v_0.Op != Op386ADDLconst { 11833 break 11834 } 11835 c := v_0.AuxInt 11836 ptr := v_0.Args[0] 11837 idx := v.Args[1] 11838 mem := v.Args[2] 11839 v.reset(Op386MOVWstoreconstidx1) 11840 v.AuxInt = ValAndOff(x).add(c) 11841 v.Aux = sym 11842 v.AddArg(ptr) 11843 v.AddArg(idx) 11844 v.AddArg(mem) 11845 return true 11846 } 11847 // match: (MOVWstoreconstidx1 [x] {sym} ptr (ADDLconst [c] idx) mem) 11848 // cond: 11849 // result: (MOVWstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem) 11850 for { 11851 x := v.AuxInt 11852 sym := v.Aux 11853 _ = v.Args[2] 11854 ptr := v.Args[0] 11855 v_1 := v.Args[1] 11856 if v_1.Op != Op386ADDLconst { 11857 break 11858 } 11859 c := v_1.AuxInt 11860 idx := v_1.Args[0] 11861 mem := v.Args[2] 11862 v.reset(Op386MOVWstoreconstidx1) 11863 v.AuxInt = ValAndOff(x).add(c) 11864 v.Aux = sym 11865 v.AddArg(ptr) 11866 v.AddArg(idx) 11867 v.AddArg(mem) 11868 return true 11869 } 11870 // match: (MOVWstoreconstidx1 [c] {s} p i x:(MOVWstoreconstidx1 [a] {s} p i mem)) 11871 // cond: x.Uses == 1 && ValAndOff(a).Off() + 2 == ValAndOff(c).Off() && clobber(x) 11872 // result: (MOVLstoreconstidx1 [makeValAndOff(ValAndOff(a).Val()&0xffff | ValAndOff(c).Val()<<16, ValAndOff(a).Off())] {s} p i mem) 11873 for { 11874 c := v.AuxInt 11875 s := v.Aux 11876 _ = v.Args[2] 11877 p := v.Args[0] 11878 i := v.Args[1] 11879 x := v.Args[2] 11880 if x.Op != Op386MOVWstoreconstidx1 { 11881 break 11882 } 11883 a := x.AuxInt 11884 if x.Aux != s { 11885 break 11886 } 11887 _ = x.Args[2] 11888 if p != x.Args[0] { 11889 break 11890 } 11891 if i != x.Args[1] { 11892 break 11893 } 11894 mem := x.Args[2] 11895 if !(x.Uses == 1 && ValAndOff(a).Off()+2 == ValAndOff(c).Off() && clobber(x)) { 11896 break 11897 } 11898 v.reset(Op386MOVLstoreconstidx1) 11899 v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xffff|ValAndOff(c).Val()<<16, ValAndOff(a).Off()) 11900 v.Aux = s 11901 v.AddArg(p) 11902 v.AddArg(i) 11903 v.AddArg(mem) 11904 return true 11905 } 11906 return false 11907 } 11908 func rewriteValue386_Op386MOVWstoreconstidx2_0(v *Value) bool { 11909 b := v.Block 11910 _ = b 11911 // match: (MOVWstoreconstidx2 [x] {sym} (ADDLconst [c] ptr) idx mem) 11912 // cond: 11913 // result: (MOVWstoreconstidx2 [ValAndOff(x).add(c)] {sym} ptr idx mem) 11914 for { 11915 x := v.AuxInt 11916 sym := v.Aux 11917 _ = v.Args[2] 11918 v_0 := v.Args[0] 11919 if v_0.Op != Op386ADDLconst { 11920 break 11921 } 11922 c := v_0.AuxInt 11923 ptr := v_0.Args[0] 11924 idx := v.Args[1] 11925 mem := v.Args[2] 11926 v.reset(Op386MOVWstoreconstidx2) 11927 v.AuxInt = ValAndOff(x).add(c) 11928 v.Aux = sym 11929 v.AddArg(ptr) 11930 v.AddArg(idx) 11931 v.AddArg(mem) 11932 return true 11933 } 11934 // match: (MOVWstoreconstidx2 [x] {sym} ptr (ADDLconst [c] idx) mem) 11935 // cond: 11936 // result: (MOVWstoreconstidx2 [ValAndOff(x).add(2*c)] {sym} ptr idx mem) 11937 for { 11938 x := v.AuxInt 11939 sym := v.Aux 11940 _ = v.Args[2] 11941 ptr := v.Args[0] 11942 v_1 := v.Args[1] 11943 if v_1.Op != Op386ADDLconst { 11944 break 11945 } 11946 c := v_1.AuxInt 11947 idx := v_1.Args[0] 11948 mem := v.Args[2] 11949 v.reset(Op386MOVWstoreconstidx2) 11950 v.AuxInt = ValAndOff(x).add(2 * c) 11951 v.Aux = sym 11952 v.AddArg(ptr) 11953 v.AddArg(idx) 11954 v.AddArg(mem) 11955 return true 11956 } 11957 // match: (MOVWstoreconstidx2 [c] {s} p i x:(MOVWstoreconstidx2 [a] {s} p i mem)) 11958 // cond: x.Uses == 1 && ValAndOff(a).Off() + 2 == ValAndOff(c).Off() && clobber(x) 11959 // result: (MOVLstoreconstidx1 [makeValAndOff(ValAndOff(a).Val()&0xffff | ValAndOff(c).Val()<<16, ValAndOff(a).Off())] {s} p (SHLLconst <i.Type> [1] i) mem) 11960 for { 11961 c := v.AuxInt 11962 s := v.Aux 11963 _ = v.Args[2] 11964 p := v.Args[0] 11965 i := v.Args[1] 11966 x := v.Args[2] 11967 if x.Op != Op386MOVWstoreconstidx2 { 11968 break 11969 } 11970 a := x.AuxInt 11971 if x.Aux != s { 11972 break 11973 } 11974 _ = x.Args[2] 11975 if p != x.Args[0] { 11976 break 11977 } 11978 if i != x.Args[1] { 11979 break 11980 } 11981 mem := x.Args[2] 11982 if !(x.Uses == 1 && ValAndOff(a).Off()+2 == ValAndOff(c).Off() && clobber(x)) { 11983 break 11984 } 11985 v.reset(Op386MOVLstoreconstidx1) 11986 v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xffff|ValAndOff(c).Val()<<16, ValAndOff(a).Off()) 11987 v.Aux = s 11988 v.AddArg(p) 11989 v0 := b.NewValue0(v.Pos, Op386SHLLconst, i.Type) 11990 v0.AuxInt = 1 11991 v0.AddArg(i) 11992 v.AddArg(v0) 11993 v.AddArg(mem) 11994 return true 11995 } 11996 return false 11997 } 11998 func rewriteValue386_Op386MOVWstoreidx1_0(v *Value) bool { 11999 // match: (MOVWstoreidx1 [c] {sym} ptr (SHLLconst [1] idx) val mem) 12000 // cond: 12001 // result: (MOVWstoreidx2 [c] {sym} ptr idx val mem) 12002 for { 12003 c := v.AuxInt 12004 sym := v.Aux 12005 _ = v.Args[3] 12006 ptr := v.Args[0] 12007 v_1 := v.Args[1] 12008 if v_1.Op != Op386SHLLconst { 12009 break 12010 } 12011 if v_1.AuxInt != 1 { 12012 break 12013 } 12014 idx := v_1.Args[0] 12015 val := v.Args[2] 12016 mem := v.Args[3] 12017 v.reset(Op386MOVWstoreidx2) 12018 v.AuxInt = c 12019 v.Aux = sym 12020 v.AddArg(ptr) 12021 v.AddArg(idx) 12022 v.AddArg(val) 12023 v.AddArg(mem) 12024 return true 12025 } 12026 // match: (MOVWstoreidx1 [c] {sym} (SHLLconst [1] idx) ptr val mem) 12027 // cond: 12028 // result: (MOVWstoreidx2 [c] {sym} ptr idx val mem) 12029 for { 12030 c := v.AuxInt 12031 sym := v.Aux 12032 _ = v.Args[3] 12033 v_0 := v.Args[0] 12034 if v_0.Op != Op386SHLLconst { 12035 break 12036 } 12037 if v_0.AuxInt != 1 { 12038 break 12039 } 12040 idx := v_0.Args[0] 12041 ptr := v.Args[1] 12042 val := v.Args[2] 12043 mem := v.Args[3] 12044 v.reset(Op386MOVWstoreidx2) 12045 v.AuxInt = c 12046 v.Aux = sym 12047 v.AddArg(ptr) 12048 v.AddArg(idx) 12049 v.AddArg(val) 12050 v.AddArg(mem) 12051 return true 12052 } 12053 // match: (MOVWstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem) 12054 // cond: 12055 // result: (MOVWstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem) 12056 for { 12057 c := v.AuxInt 12058 sym := v.Aux 12059 _ = v.Args[3] 12060 v_0 := v.Args[0] 12061 if v_0.Op != Op386ADDLconst { 12062 break 12063 } 12064 d := v_0.AuxInt 12065 ptr := v_0.Args[0] 12066 idx := v.Args[1] 12067 val := v.Args[2] 12068 mem := v.Args[3] 12069 v.reset(Op386MOVWstoreidx1) 12070 v.AuxInt = int64(int32(c + d)) 12071 v.Aux = sym 12072 v.AddArg(ptr) 12073 v.AddArg(idx) 12074 v.AddArg(val) 12075 v.AddArg(mem) 12076 return true 12077 } 12078 // match: (MOVWstoreidx1 [c] {sym} idx (ADDLconst [d] ptr) val mem) 12079 // cond: 12080 // result: (MOVWstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem) 12081 for { 12082 c := v.AuxInt 12083 sym := v.Aux 12084 _ = v.Args[3] 12085 idx := v.Args[0] 12086 v_1 := v.Args[1] 12087 if v_1.Op != Op386ADDLconst { 12088 break 12089 } 12090 d := v_1.AuxInt 12091 ptr := v_1.Args[0] 12092 val := v.Args[2] 12093 mem := v.Args[3] 12094 v.reset(Op386MOVWstoreidx1) 12095 v.AuxInt = int64(int32(c + d)) 12096 v.Aux = sym 12097 v.AddArg(ptr) 12098 v.AddArg(idx) 12099 v.AddArg(val) 12100 v.AddArg(mem) 12101 return true 12102 } 12103 // match: (MOVWstoreidx1 [c] {sym} ptr (ADDLconst [d] idx) val mem) 12104 // cond: 12105 // result: (MOVWstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem) 12106 for { 12107 c := v.AuxInt 12108 sym := v.Aux 12109 _ = v.Args[3] 12110 ptr := v.Args[0] 12111 v_1 := v.Args[1] 12112 if v_1.Op != Op386ADDLconst { 12113 break 12114 } 12115 d := v_1.AuxInt 12116 idx := v_1.Args[0] 12117 val := v.Args[2] 12118 mem := v.Args[3] 12119 v.reset(Op386MOVWstoreidx1) 12120 v.AuxInt = int64(int32(c + d)) 12121 v.Aux = sym 12122 v.AddArg(ptr) 12123 v.AddArg(idx) 12124 v.AddArg(val) 12125 v.AddArg(mem) 12126 return true 12127 } 12128 // match: (MOVWstoreidx1 [c] {sym} (ADDLconst [d] idx) ptr val mem) 12129 // cond: 12130 // result: (MOVWstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem) 12131 for { 12132 c := v.AuxInt 12133 sym := v.Aux 12134 _ = v.Args[3] 12135 v_0 := v.Args[0] 12136 if v_0.Op != Op386ADDLconst { 12137 break 12138 } 12139 d := v_0.AuxInt 12140 idx := v_0.Args[0] 12141 ptr := v.Args[1] 12142 val := v.Args[2] 12143 mem := v.Args[3] 12144 v.reset(Op386MOVWstoreidx1) 12145 v.AuxInt = int64(int32(c + d)) 12146 v.Aux = sym 12147 v.AddArg(ptr) 12148 v.AddArg(idx) 12149 v.AddArg(val) 12150 v.AddArg(mem) 12151 return true 12152 } 12153 // match: (MOVWstoreidx1 [i] {s} p idx (SHRLconst [16] w) x:(MOVWstoreidx1 [i-2] {s} p idx w mem)) 12154 // cond: x.Uses == 1 && clobber(x) 12155 // result: (MOVLstoreidx1 [i-2] {s} p idx w mem) 12156 for { 12157 i := v.AuxInt 12158 s := v.Aux 12159 _ = v.Args[3] 12160 p := v.Args[0] 12161 idx := v.Args[1] 12162 v_2 := v.Args[2] 12163 if v_2.Op != Op386SHRLconst { 12164 break 12165 } 12166 if v_2.AuxInt != 16 { 12167 break 12168 } 12169 w := v_2.Args[0] 12170 x := v.Args[3] 12171 if x.Op != Op386MOVWstoreidx1 { 12172 break 12173 } 12174 if x.AuxInt != i-2 { 12175 break 12176 } 12177 if x.Aux != s { 12178 break 12179 } 12180 _ = x.Args[3] 12181 if p != x.Args[0] { 12182 break 12183 } 12184 if idx != x.Args[1] { 12185 break 12186 } 12187 if w != x.Args[2] { 12188 break 12189 } 12190 mem := x.Args[3] 12191 if !(x.Uses == 1 && clobber(x)) { 12192 break 12193 } 12194 v.reset(Op386MOVLstoreidx1) 12195 v.AuxInt = i - 2 12196 v.Aux = s 12197 v.AddArg(p) 12198 v.AddArg(idx) 12199 v.AddArg(w) 12200 v.AddArg(mem) 12201 return true 12202 } 12203 // match: (MOVWstoreidx1 [i] {s} p idx (SHRLconst [16] w) x:(MOVWstoreidx1 [i-2] {s} idx p w mem)) 12204 // cond: x.Uses == 1 && clobber(x) 12205 // result: (MOVLstoreidx1 [i-2] {s} p idx w mem) 12206 for { 12207 i := v.AuxInt 12208 s := v.Aux 12209 _ = v.Args[3] 12210 p := v.Args[0] 12211 idx := v.Args[1] 12212 v_2 := v.Args[2] 12213 if v_2.Op != Op386SHRLconst { 12214 break 12215 } 12216 if v_2.AuxInt != 16 { 12217 break 12218 } 12219 w := v_2.Args[0] 12220 x := v.Args[3] 12221 if x.Op != Op386MOVWstoreidx1 { 12222 break 12223 } 12224 if x.AuxInt != i-2 { 12225 break 12226 } 12227 if x.Aux != s { 12228 break 12229 } 12230 _ = x.Args[3] 12231 if idx != x.Args[0] { 12232 break 12233 } 12234 if p != x.Args[1] { 12235 break 12236 } 12237 if w != x.Args[2] { 12238 break 12239 } 12240 mem := x.Args[3] 12241 if !(x.Uses == 1 && clobber(x)) { 12242 break 12243 } 12244 v.reset(Op386MOVLstoreidx1) 12245 v.AuxInt = i - 2 12246 v.Aux = s 12247 v.AddArg(p) 12248 v.AddArg(idx) 12249 v.AddArg(w) 12250 v.AddArg(mem) 12251 return true 12252 } 12253 // match: (MOVWstoreidx1 [i] {s} idx p (SHRLconst [16] w) x:(MOVWstoreidx1 [i-2] {s} p idx w mem)) 12254 // cond: x.Uses == 1 && clobber(x) 12255 // result: (MOVLstoreidx1 [i-2] {s} p idx w mem) 12256 for { 12257 i := v.AuxInt 12258 s := v.Aux 12259 _ = v.Args[3] 12260 idx := v.Args[0] 12261 p := v.Args[1] 12262 v_2 := v.Args[2] 12263 if v_2.Op != Op386SHRLconst { 12264 break 12265 } 12266 if v_2.AuxInt != 16 { 12267 break 12268 } 12269 w := v_2.Args[0] 12270 x := v.Args[3] 12271 if x.Op != Op386MOVWstoreidx1 { 12272 break 12273 } 12274 if x.AuxInt != i-2 { 12275 break 12276 } 12277 if x.Aux != s { 12278 break 12279 } 12280 _ = x.Args[3] 12281 if p != x.Args[0] { 12282 break 12283 } 12284 if idx != x.Args[1] { 12285 break 12286 } 12287 if w != x.Args[2] { 12288 break 12289 } 12290 mem := x.Args[3] 12291 if !(x.Uses == 1 && clobber(x)) { 12292 break 12293 } 12294 v.reset(Op386MOVLstoreidx1) 12295 v.AuxInt = i - 2 12296 v.Aux = s 12297 v.AddArg(p) 12298 v.AddArg(idx) 12299 v.AddArg(w) 12300 v.AddArg(mem) 12301 return true 12302 } 12303 // match: (MOVWstoreidx1 [i] {s} idx p (SHRLconst [16] w) x:(MOVWstoreidx1 [i-2] {s} idx p w mem)) 12304 // cond: x.Uses == 1 && clobber(x) 12305 // result: (MOVLstoreidx1 [i-2] {s} p idx w mem) 12306 for { 12307 i := v.AuxInt 12308 s := v.Aux 12309 _ = v.Args[3] 12310 idx := v.Args[0] 12311 p := v.Args[1] 12312 v_2 := v.Args[2] 12313 if v_2.Op != Op386SHRLconst { 12314 break 12315 } 12316 if v_2.AuxInt != 16 { 12317 break 12318 } 12319 w := v_2.Args[0] 12320 x := v.Args[3] 12321 if x.Op != Op386MOVWstoreidx1 { 12322 break 12323 } 12324 if x.AuxInt != i-2 { 12325 break 12326 } 12327 if x.Aux != s { 12328 break 12329 } 12330 _ = x.Args[3] 12331 if idx != x.Args[0] { 12332 break 12333 } 12334 if p != x.Args[1] { 12335 break 12336 } 12337 if w != x.Args[2] { 12338 break 12339 } 12340 mem := x.Args[3] 12341 if !(x.Uses == 1 && clobber(x)) { 12342 break 12343 } 12344 v.reset(Op386MOVLstoreidx1) 12345 v.AuxInt = i - 2 12346 v.Aux = s 12347 v.AddArg(p) 12348 v.AddArg(idx) 12349 v.AddArg(w) 12350 v.AddArg(mem) 12351 return true 12352 } 12353 return false 12354 } 12355 func rewriteValue386_Op386MOVWstoreidx1_10(v *Value) bool { 12356 // match: (MOVWstoreidx1 [i] {s} p idx (SHRLconst [j] w) x:(MOVWstoreidx1 [i-2] {s} p idx w0:(SHRLconst [j-16] w) mem)) 12357 // cond: x.Uses == 1 && clobber(x) 12358 // result: (MOVLstoreidx1 [i-2] {s} p idx w0 mem) 12359 for { 12360 i := v.AuxInt 12361 s := v.Aux 12362 _ = v.Args[3] 12363 p := v.Args[0] 12364 idx := v.Args[1] 12365 v_2 := v.Args[2] 12366 if v_2.Op != Op386SHRLconst { 12367 break 12368 } 12369 j := v_2.AuxInt 12370 w := v_2.Args[0] 12371 x := v.Args[3] 12372 if x.Op != Op386MOVWstoreidx1 { 12373 break 12374 } 12375 if x.AuxInt != i-2 { 12376 break 12377 } 12378 if x.Aux != s { 12379 break 12380 } 12381 _ = x.Args[3] 12382 if p != x.Args[0] { 12383 break 12384 } 12385 if idx != x.Args[1] { 12386 break 12387 } 12388 w0 := x.Args[2] 12389 if w0.Op != Op386SHRLconst { 12390 break 12391 } 12392 if w0.AuxInt != j-16 { 12393 break 12394 } 12395 if w != w0.Args[0] { 12396 break 12397 } 12398 mem := x.Args[3] 12399 if !(x.Uses == 1 && clobber(x)) { 12400 break 12401 } 12402 v.reset(Op386MOVLstoreidx1) 12403 v.AuxInt = i - 2 12404 v.Aux = s 12405 v.AddArg(p) 12406 v.AddArg(idx) 12407 v.AddArg(w0) 12408 v.AddArg(mem) 12409 return true 12410 } 12411 // match: (MOVWstoreidx1 [i] {s} p idx (SHRLconst [j] w) x:(MOVWstoreidx1 [i-2] {s} idx p w0:(SHRLconst [j-16] w) mem)) 12412 // cond: x.Uses == 1 && clobber(x) 12413 // result: (MOVLstoreidx1 [i-2] {s} p idx w0 mem) 12414 for { 12415 i := v.AuxInt 12416 s := v.Aux 12417 _ = v.Args[3] 12418 p := v.Args[0] 12419 idx := v.Args[1] 12420 v_2 := v.Args[2] 12421 if v_2.Op != Op386SHRLconst { 12422 break 12423 } 12424 j := v_2.AuxInt 12425 w := v_2.Args[0] 12426 x := v.Args[3] 12427 if x.Op != Op386MOVWstoreidx1 { 12428 break 12429 } 12430 if x.AuxInt != i-2 { 12431 break 12432 } 12433 if x.Aux != s { 12434 break 12435 } 12436 _ = x.Args[3] 12437 if idx != x.Args[0] { 12438 break 12439 } 12440 if p != x.Args[1] { 12441 break 12442 } 12443 w0 := x.Args[2] 12444 if w0.Op != Op386SHRLconst { 12445 break 12446 } 12447 if w0.AuxInt != j-16 { 12448 break 12449 } 12450 if w != w0.Args[0] { 12451 break 12452 } 12453 mem := x.Args[3] 12454 if !(x.Uses == 1 && clobber(x)) { 12455 break 12456 } 12457 v.reset(Op386MOVLstoreidx1) 12458 v.AuxInt = i - 2 12459 v.Aux = s 12460 v.AddArg(p) 12461 v.AddArg(idx) 12462 v.AddArg(w0) 12463 v.AddArg(mem) 12464 return true 12465 } 12466 // match: (MOVWstoreidx1 [i] {s} idx p (SHRLconst [j] w) x:(MOVWstoreidx1 [i-2] {s} p idx w0:(SHRLconst [j-16] w) mem)) 12467 // cond: x.Uses == 1 && clobber(x) 12468 // result: (MOVLstoreidx1 [i-2] {s} p idx w0 mem) 12469 for { 12470 i := v.AuxInt 12471 s := v.Aux 12472 _ = v.Args[3] 12473 idx := v.Args[0] 12474 p := v.Args[1] 12475 v_2 := v.Args[2] 12476 if v_2.Op != Op386SHRLconst { 12477 break 12478 } 12479 j := v_2.AuxInt 12480 w := v_2.Args[0] 12481 x := v.Args[3] 12482 if x.Op != Op386MOVWstoreidx1 { 12483 break 12484 } 12485 if x.AuxInt != i-2 { 12486 break 12487 } 12488 if x.Aux != s { 12489 break 12490 } 12491 _ = x.Args[3] 12492 if p != x.Args[0] { 12493 break 12494 } 12495 if idx != x.Args[1] { 12496 break 12497 } 12498 w0 := x.Args[2] 12499 if w0.Op != Op386SHRLconst { 12500 break 12501 } 12502 if w0.AuxInt != j-16 { 12503 break 12504 } 12505 if w != w0.Args[0] { 12506 break 12507 } 12508 mem := x.Args[3] 12509 if !(x.Uses == 1 && clobber(x)) { 12510 break 12511 } 12512 v.reset(Op386MOVLstoreidx1) 12513 v.AuxInt = i - 2 12514 v.Aux = s 12515 v.AddArg(p) 12516 v.AddArg(idx) 12517 v.AddArg(w0) 12518 v.AddArg(mem) 12519 return true 12520 } 12521 // match: (MOVWstoreidx1 [i] {s} idx p (SHRLconst [j] w) x:(MOVWstoreidx1 [i-2] {s} idx p w0:(SHRLconst [j-16] w) mem)) 12522 // cond: x.Uses == 1 && clobber(x) 12523 // result: (MOVLstoreidx1 [i-2] {s} p idx w0 mem) 12524 for { 12525 i := v.AuxInt 12526 s := v.Aux 12527 _ = v.Args[3] 12528 idx := v.Args[0] 12529 p := v.Args[1] 12530 v_2 := v.Args[2] 12531 if v_2.Op != Op386SHRLconst { 12532 break 12533 } 12534 j := v_2.AuxInt 12535 w := v_2.Args[0] 12536 x := v.Args[3] 12537 if x.Op != Op386MOVWstoreidx1 { 12538 break 12539 } 12540 if x.AuxInt != i-2 { 12541 break 12542 } 12543 if x.Aux != s { 12544 break 12545 } 12546 _ = x.Args[3] 12547 if idx != x.Args[0] { 12548 break 12549 } 12550 if p != x.Args[1] { 12551 break 12552 } 12553 w0 := x.Args[2] 12554 if w0.Op != Op386SHRLconst { 12555 break 12556 } 12557 if w0.AuxInt != j-16 { 12558 break 12559 } 12560 if w != w0.Args[0] { 12561 break 12562 } 12563 mem := x.Args[3] 12564 if !(x.Uses == 1 && clobber(x)) { 12565 break 12566 } 12567 v.reset(Op386MOVLstoreidx1) 12568 v.AuxInt = i - 2 12569 v.Aux = s 12570 v.AddArg(p) 12571 v.AddArg(idx) 12572 v.AddArg(w0) 12573 v.AddArg(mem) 12574 return true 12575 } 12576 return false 12577 } 12578 func rewriteValue386_Op386MOVWstoreidx2_0(v *Value) bool { 12579 b := v.Block 12580 _ = b 12581 // match: (MOVWstoreidx2 [c] {sym} (ADDLconst [d] ptr) idx val mem) 12582 // cond: 12583 // result: (MOVWstoreidx2 [int64(int32(c+d))] {sym} ptr idx val mem) 12584 for { 12585 c := v.AuxInt 12586 sym := v.Aux 12587 _ = v.Args[3] 12588 v_0 := v.Args[0] 12589 if v_0.Op != Op386ADDLconst { 12590 break 12591 } 12592 d := v_0.AuxInt 12593 ptr := v_0.Args[0] 12594 idx := v.Args[1] 12595 val := v.Args[2] 12596 mem := v.Args[3] 12597 v.reset(Op386MOVWstoreidx2) 12598 v.AuxInt = int64(int32(c + d)) 12599 v.Aux = sym 12600 v.AddArg(ptr) 12601 v.AddArg(idx) 12602 v.AddArg(val) 12603 v.AddArg(mem) 12604 return true 12605 } 12606 // match: (MOVWstoreidx2 [c] {sym} ptr (ADDLconst [d] idx) val mem) 12607 // cond: 12608 // result: (MOVWstoreidx2 [int64(int32(c+2*d))] {sym} ptr idx val mem) 12609 for { 12610 c := v.AuxInt 12611 sym := v.Aux 12612 _ = v.Args[3] 12613 ptr := v.Args[0] 12614 v_1 := v.Args[1] 12615 if v_1.Op != Op386ADDLconst { 12616 break 12617 } 12618 d := v_1.AuxInt 12619 idx := v_1.Args[0] 12620 val := v.Args[2] 12621 mem := v.Args[3] 12622 v.reset(Op386MOVWstoreidx2) 12623 v.AuxInt = int64(int32(c + 2*d)) 12624 v.Aux = sym 12625 v.AddArg(ptr) 12626 v.AddArg(idx) 12627 v.AddArg(val) 12628 v.AddArg(mem) 12629 return true 12630 } 12631 // match: (MOVWstoreidx2 [i] {s} p idx (SHRLconst [16] w) x:(MOVWstoreidx2 [i-2] {s} p idx w mem)) 12632 // cond: x.Uses == 1 && clobber(x) 12633 // result: (MOVLstoreidx1 [i-2] {s} p (SHLLconst <idx.Type> [1] idx) w mem) 12634 for { 12635 i := v.AuxInt 12636 s := v.Aux 12637 _ = v.Args[3] 12638 p := v.Args[0] 12639 idx := v.Args[1] 12640 v_2 := v.Args[2] 12641 if v_2.Op != Op386SHRLconst { 12642 break 12643 } 12644 if v_2.AuxInt != 16 { 12645 break 12646 } 12647 w := v_2.Args[0] 12648 x := v.Args[3] 12649 if x.Op != Op386MOVWstoreidx2 { 12650 break 12651 } 12652 if x.AuxInt != i-2 { 12653 break 12654 } 12655 if x.Aux != s { 12656 break 12657 } 12658 _ = x.Args[3] 12659 if p != x.Args[0] { 12660 break 12661 } 12662 if idx != x.Args[1] { 12663 break 12664 } 12665 if w != x.Args[2] { 12666 break 12667 } 12668 mem := x.Args[3] 12669 if !(x.Uses == 1 && clobber(x)) { 12670 break 12671 } 12672 v.reset(Op386MOVLstoreidx1) 12673 v.AuxInt = i - 2 12674 v.Aux = s 12675 v.AddArg(p) 12676 v0 := b.NewValue0(v.Pos, Op386SHLLconst, idx.Type) 12677 v0.AuxInt = 1 12678 v0.AddArg(idx) 12679 v.AddArg(v0) 12680 v.AddArg(w) 12681 v.AddArg(mem) 12682 return true 12683 } 12684 // match: (MOVWstoreidx2 [i] {s} p idx (SHRLconst [j] w) x:(MOVWstoreidx2 [i-2] {s} p idx w0:(SHRLconst [j-16] w) mem)) 12685 // cond: x.Uses == 1 && clobber(x) 12686 // result: (MOVLstoreidx1 [i-2] {s} p (SHLLconst <idx.Type> [1] idx) w0 mem) 12687 for { 12688 i := v.AuxInt 12689 s := v.Aux 12690 _ = v.Args[3] 12691 p := v.Args[0] 12692 idx := v.Args[1] 12693 v_2 := v.Args[2] 12694 if v_2.Op != Op386SHRLconst { 12695 break 12696 } 12697 j := v_2.AuxInt 12698 w := v_2.Args[0] 12699 x := v.Args[3] 12700 if x.Op != Op386MOVWstoreidx2 { 12701 break 12702 } 12703 if x.AuxInt != i-2 { 12704 break 12705 } 12706 if x.Aux != s { 12707 break 12708 } 12709 _ = x.Args[3] 12710 if p != x.Args[0] { 12711 break 12712 } 12713 if idx != x.Args[1] { 12714 break 12715 } 12716 w0 := x.Args[2] 12717 if w0.Op != Op386SHRLconst { 12718 break 12719 } 12720 if w0.AuxInt != j-16 { 12721 break 12722 } 12723 if w != w0.Args[0] { 12724 break 12725 } 12726 mem := x.Args[3] 12727 if !(x.Uses == 1 && clobber(x)) { 12728 break 12729 } 12730 v.reset(Op386MOVLstoreidx1) 12731 v.AuxInt = i - 2 12732 v.Aux = s 12733 v.AddArg(p) 12734 v0 := b.NewValue0(v.Pos, Op386SHLLconst, idx.Type) 12735 v0.AuxInt = 1 12736 v0.AddArg(idx) 12737 v.AddArg(v0) 12738 v.AddArg(w0) 12739 v.AddArg(mem) 12740 return true 12741 } 12742 return false 12743 } 12744 func rewriteValue386_Op386MULL_0(v *Value) bool { 12745 // match: (MULL x (MOVLconst [c])) 12746 // cond: 12747 // result: (MULLconst [c] x) 12748 for { 12749 _ = v.Args[1] 12750 x := v.Args[0] 12751 v_1 := v.Args[1] 12752 if v_1.Op != Op386MOVLconst { 12753 break 12754 } 12755 c := v_1.AuxInt 12756 v.reset(Op386MULLconst) 12757 v.AuxInt = c 12758 v.AddArg(x) 12759 return true 12760 } 12761 // match: (MULL (MOVLconst [c]) x) 12762 // cond: 12763 // result: (MULLconst [c] x) 12764 for { 12765 _ = v.Args[1] 12766 v_0 := v.Args[0] 12767 if v_0.Op != Op386MOVLconst { 12768 break 12769 } 12770 c := v_0.AuxInt 12771 x := v.Args[1] 12772 v.reset(Op386MULLconst) 12773 v.AuxInt = c 12774 v.AddArg(x) 12775 return true 12776 } 12777 // match: (MULL x l:(MOVLload [off] {sym} ptr mem)) 12778 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 12779 // result: (MULLload x [off] {sym} ptr mem) 12780 for { 12781 _ = v.Args[1] 12782 x := v.Args[0] 12783 l := v.Args[1] 12784 if l.Op != Op386MOVLload { 12785 break 12786 } 12787 off := l.AuxInt 12788 sym := l.Aux 12789 _ = l.Args[1] 12790 ptr := l.Args[0] 12791 mem := l.Args[1] 12792 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 12793 break 12794 } 12795 v.reset(Op386MULLload) 12796 v.AuxInt = off 12797 v.Aux = sym 12798 v.AddArg(x) 12799 v.AddArg(ptr) 12800 v.AddArg(mem) 12801 return true 12802 } 12803 // match: (MULL l:(MOVLload [off] {sym} ptr mem) x) 12804 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 12805 // result: (MULLload x [off] {sym} ptr mem) 12806 for { 12807 _ = v.Args[1] 12808 l := v.Args[0] 12809 if l.Op != Op386MOVLload { 12810 break 12811 } 12812 off := l.AuxInt 12813 sym := l.Aux 12814 _ = l.Args[1] 12815 ptr := l.Args[0] 12816 mem := l.Args[1] 12817 x := v.Args[1] 12818 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 12819 break 12820 } 12821 v.reset(Op386MULLload) 12822 v.AuxInt = off 12823 v.Aux = sym 12824 v.AddArg(x) 12825 v.AddArg(ptr) 12826 v.AddArg(mem) 12827 return true 12828 } 12829 // match: (MULL x l:(MOVLloadidx4 [off] {sym} ptr idx mem)) 12830 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 12831 // result: (MULLloadidx4 x [off] {sym} ptr idx mem) 12832 for { 12833 _ = v.Args[1] 12834 x := v.Args[0] 12835 l := v.Args[1] 12836 if l.Op != Op386MOVLloadidx4 { 12837 break 12838 } 12839 off := l.AuxInt 12840 sym := l.Aux 12841 _ = l.Args[2] 12842 ptr := l.Args[0] 12843 idx := l.Args[1] 12844 mem := l.Args[2] 12845 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 12846 break 12847 } 12848 v.reset(Op386MULLloadidx4) 12849 v.AuxInt = off 12850 v.Aux = sym 12851 v.AddArg(x) 12852 v.AddArg(ptr) 12853 v.AddArg(idx) 12854 v.AddArg(mem) 12855 return true 12856 } 12857 // match: (MULL l:(MOVLloadidx4 [off] {sym} ptr idx mem) x) 12858 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 12859 // result: (MULLloadidx4 x [off] {sym} ptr idx mem) 12860 for { 12861 _ = v.Args[1] 12862 l := v.Args[0] 12863 if l.Op != Op386MOVLloadidx4 { 12864 break 12865 } 12866 off := l.AuxInt 12867 sym := l.Aux 12868 _ = l.Args[2] 12869 ptr := l.Args[0] 12870 idx := l.Args[1] 12871 mem := l.Args[2] 12872 x := v.Args[1] 12873 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 12874 break 12875 } 12876 v.reset(Op386MULLloadidx4) 12877 v.AuxInt = off 12878 v.Aux = sym 12879 v.AddArg(x) 12880 v.AddArg(ptr) 12881 v.AddArg(idx) 12882 v.AddArg(mem) 12883 return true 12884 } 12885 return false 12886 } 12887 func rewriteValue386_Op386MULLconst_0(v *Value) bool { 12888 b := v.Block 12889 _ = b 12890 // match: (MULLconst [c] (MULLconst [d] x)) 12891 // cond: 12892 // result: (MULLconst [int64(int32(c * d))] x) 12893 for { 12894 c := v.AuxInt 12895 v_0 := v.Args[0] 12896 if v_0.Op != Op386MULLconst { 12897 break 12898 } 12899 d := v_0.AuxInt 12900 x := v_0.Args[0] 12901 v.reset(Op386MULLconst) 12902 v.AuxInt = int64(int32(c * d)) 12903 v.AddArg(x) 12904 return true 12905 } 12906 // match: (MULLconst [-9] x) 12907 // cond: 12908 // result: (NEGL (LEAL8 <v.Type> x x)) 12909 for { 12910 if v.AuxInt != -9 { 12911 break 12912 } 12913 x := v.Args[0] 12914 v.reset(Op386NEGL) 12915 v0 := b.NewValue0(v.Pos, Op386LEAL8, v.Type) 12916 v0.AddArg(x) 12917 v0.AddArg(x) 12918 v.AddArg(v0) 12919 return true 12920 } 12921 // match: (MULLconst [-5] x) 12922 // cond: 12923 // result: (NEGL (LEAL4 <v.Type> x x)) 12924 for { 12925 if v.AuxInt != -5 { 12926 break 12927 } 12928 x := v.Args[0] 12929 v.reset(Op386NEGL) 12930 v0 := b.NewValue0(v.Pos, Op386LEAL4, v.Type) 12931 v0.AddArg(x) 12932 v0.AddArg(x) 12933 v.AddArg(v0) 12934 return true 12935 } 12936 // match: (MULLconst [-3] x) 12937 // cond: 12938 // result: (NEGL (LEAL2 <v.Type> x x)) 12939 for { 12940 if v.AuxInt != -3 { 12941 break 12942 } 12943 x := v.Args[0] 12944 v.reset(Op386NEGL) 12945 v0 := b.NewValue0(v.Pos, Op386LEAL2, v.Type) 12946 v0.AddArg(x) 12947 v0.AddArg(x) 12948 v.AddArg(v0) 12949 return true 12950 } 12951 // match: (MULLconst [-1] x) 12952 // cond: 12953 // result: (NEGL x) 12954 for { 12955 if v.AuxInt != -1 { 12956 break 12957 } 12958 x := v.Args[0] 12959 v.reset(Op386NEGL) 12960 v.AddArg(x) 12961 return true 12962 } 12963 // match: (MULLconst [0] _) 12964 // cond: 12965 // result: (MOVLconst [0]) 12966 for { 12967 if v.AuxInt != 0 { 12968 break 12969 } 12970 v.reset(Op386MOVLconst) 12971 v.AuxInt = 0 12972 return true 12973 } 12974 // match: (MULLconst [1] x) 12975 // cond: 12976 // result: x 12977 for { 12978 if v.AuxInt != 1 { 12979 break 12980 } 12981 x := v.Args[0] 12982 v.reset(OpCopy) 12983 v.Type = x.Type 12984 v.AddArg(x) 12985 return true 12986 } 12987 // match: (MULLconst [3] x) 12988 // cond: 12989 // result: (LEAL2 x x) 12990 for { 12991 if v.AuxInt != 3 { 12992 break 12993 } 12994 x := v.Args[0] 12995 v.reset(Op386LEAL2) 12996 v.AddArg(x) 12997 v.AddArg(x) 12998 return true 12999 } 13000 // match: (MULLconst [5] x) 13001 // cond: 13002 // result: (LEAL4 x x) 13003 for { 13004 if v.AuxInt != 5 { 13005 break 13006 } 13007 x := v.Args[0] 13008 v.reset(Op386LEAL4) 13009 v.AddArg(x) 13010 v.AddArg(x) 13011 return true 13012 } 13013 // match: (MULLconst [7] x) 13014 // cond: 13015 // result: (LEAL2 x (LEAL2 <v.Type> x x)) 13016 for { 13017 if v.AuxInt != 7 { 13018 break 13019 } 13020 x := v.Args[0] 13021 v.reset(Op386LEAL2) 13022 v.AddArg(x) 13023 v0 := b.NewValue0(v.Pos, Op386LEAL2, v.Type) 13024 v0.AddArg(x) 13025 v0.AddArg(x) 13026 v.AddArg(v0) 13027 return true 13028 } 13029 return false 13030 } 13031 func rewriteValue386_Op386MULLconst_10(v *Value) bool { 13032 b := v.Block 13033 _ = b 13034 // match: (MULLconst [9] x) 13035 // cond: 13036 // result: (LEAL8 x x) 13037 for { 13038 if v.AuxInt != 9 { 13039 break 13040 } 13041 x := v.Args[0] 13042 v.reset(Op386LEAL8) 13043 v.AddArg(x) 13044 v.AddArg(x) 13045 return true 13046 } 13047 // match: (MULLconst [11] x) 13048 // cond: 13049 // result: (LEAL2 x (LEAL4 <v.Type> x x)) 13050 for { 13051 if v.AuxInt != 11 { 13052 break 13053 } 13054 x := v.Args[0] 13055 v.reset(Op386LEAL2) 13056 v.AddArg(x) 13057 v0 := b.NewValue0(v.Pos, Op386LEAL4, v.Type) 13058 v0.AddArg(x) 13059 v0.AddArg(x) 13060 v.AddArg(v0) 13061 return true 13062 } 13063 // match: (MULLconst [13] x) 13064 // cond: 13065 // result: (LEAL4 x (LEAL2 <v.Type> x x)) 13066 for { 13067 if v.AuxInt != 13 { 13068 break 13069 } 13070 x := v.Args[0] 13071 v.reset(Op386LEAL4) 13072 v.AddArg(x) 13073 v0 := b.NewValue0(v.Pos, Op386LEAL2, v.Type) 13074 v0.AddArg(x) 13075 v0.AddArg(x) 13076 v.AddArg(v0) 13077 return true 13078 } 13079 // match: (MULLconst [19] x) 13080 // cond: 13081 // result: (LEAL2 x (LEAL8 <v.Type> x x)) 13082 for { 13083 if v.AuxInt != 19 { 13084 break 13085 } 13086 x := v.Args[0] 13087 v.reset(Op386LEAL2) 13088 v.AddArg(x) 13089 v0 := b.NewValue0(v.Pos, Op386LEAL8, v.Type) 13090 v0.AddArg(x) 13091 v0.AddArg(x) 13092 v.AddArg(v0) 13093 return true 13094 } 13095 // match: (MULLconst [21] x) 13096 // cond: 13097 // result: (LEAL4 x (LEAL4 <v.Type> x x)) 13098 for { 13099 if v.AuxInt != 21 { 13100 break 13101 } 13102 x := v.Args[0] 13103 v.reset(Op386LEAL4) 13104 v.AddArg(x) 13105 v0 := b.NewValue0(v.Pos, Op386LEAL4, v.Type) 13106 v0.AddArg(x) 13107 v0.AddArg(x) 13108 v.AddArg(v0) 13109 return true 13110 } 13111 // match: (MULLconst [25] x) 13112 // cond: 13113 // result: (LEAL8 x (LEAL2 <v.Type> x x)) 13114 for { 13115 if v.AuxInt != 25 { 13116 break 13117 } 13118 x := v.Args[0] 13119 v.reset(Op386LEAL8) 13120 v.AddArg(x) 13121 v0 := b.NewValue0(v.Pos, Op386LEAL2, v.Type) 13122 v0.AddArg(x) 13123 v0.AddArg(x) 13124 v.AddArg(v0) 13125 return true 13126 } 13127 // match: (MULLconst [27] x) 13128 // cond: 13129 // result: (LEAL8 (LEAL2 <v.Type> x x) (LEAL2 <v.Type> x x)) 13130 for { 13131 if v.AuxInt != 27 { 13132 break 13133 } 13134 x := v.Args[0] 13135 v.reset(Op386LEAL8) 13136 v0 := b.NewValue0(v.Pos, Op386LEAL2, v.Type) 13137 v0.AddArg(x) 13138 v0.AddArg(x) 13139 v.AddArg(v0) 13140 v1 := b.NewValue0(v.Pos, Op386LEAL2, v.Type) 13141 v1.AddArg(x) 13142 v1.AddArg(x) 13143 v.AddArg(v1) 13144 return true 13145 } 13146 // match: (MULLconst [37] x) 13147 // cond: 13148 // result: (LEAL4 x (LEAL8 <v.Type> x x)) 13149 for { 13150 if v.AuxInt != 37 { 13151 break 13152 } 13153 x := v.Args[0] 13154 v.reset(Op386LEAL4) 13155 v.AddArg(x) 13156 v0 := b.NewValue0(v.Pos, Op386LEAL8, v.Type) 13157 v0.AddArg(x) 13158 v0.AddArg(x) 13159 v.AddArg(v0) 13160 return true 13161 } 13162 // match: (MULLconst [41] x) 13163 // cond: 13164 // result: (LEAL8 x (LEAL4 <v.Type> x x)) 13165 for { 13166 if v.AuxInt != 41 { 13167 break 13168 } 13169 x := v.Args[0] 13170 v.reset(Op386LEAL8) 13171 v.AddArg(x) 13172 v0 := b.NewValue0(v.Pos, Op386LEAL4, v.Type) 13173 v0.AddArg(x) 13174 v0.AddArg(x) 13175 v.AddArg(v0) 13176 return true 13177 } 13178 // match: (MULLconst [45] x) 13179 // cond: 13180 // result: (LEAL8 (LEAL4 <v.Type> x x) (LEAL4 <v.Type> x x)) 13181 for { 13182 if v.AuxInt != 45 { 13183 break 13184 } 13185 x := v.Args[0] 13186 v.reset(Op386LEAL8) 13187 v0 := b.NewValue0(v.Pos, Op386LEAL4, v.Type) 13188 v0.AddArg(x) 13189 v0.AddArg(x) 13190 v.AddArg(v0) 13191 v1 := b.NewValue0(v.Pos, Op386LEAL4, v.Type) 13192 v1.AddArg(x) 13193 v1.AddArg(x) 13194 v.AddArg(v1) 13195 return true 13196 } 13197 return false 13198 } 13199 func rewriteValue386_Op386MULLconst_20(v *Value) bool { 13200 b := v.Block 13201 _ = b 13202 // match: (MULLconst [73] x) 13203 // cond: 13204 // result: (LEAL8 x (LEAL8 <v.Type> x x)) 13205 for { 13206 if v.AuxInt != 73 { 13207 break 13208 } 13209 x := v.Args[0] 13210 v.reset(Op386LEAL8) 13211 v.AddArg(x) 13212 v0 := b.NewValue0(v.Pos, Op386LEAL8, v.Type) 13213 v0.AddArg(x) 13214 v0.AddArg(x) 13215 v.AddArg(v0) 13216 return true 13217 } 13218 // match: (MULLconst [81] x) 13219 // cond: 13220 // result: (LEAL8 (LEAL8 <v.Type> x x) (LEAL8 <v.Type> x x)) 13221 for { 13222 if v.AuxInt != 81 { 13223 break 13224 } 13225 x := v.Args[0] 13226 v.reset(Op386LEAL8) 13227 v0 := b.NewValue0(v.Pos, Op386LEAL8, v.Type) 13228 v0.AddArg(x) 13229 v0.AddArg(x) 13230 v.AddArg(v0) 13231 v1 := b.NewValue0(v.Pos, Op386LEAL8, v.Type) 13232 v1.AddArg(x) 13233 v1.AddArg(x) 13234 v.AddArg(v1) 13235 return true 13236 } 13237 // match: (MULLconst [c] x) 13238 // cond: isPowerOfTwo(c+1) && c >= 15 13239 // result: (SUBL (SHLLconst <v.Type> [log2(c+1)] x) x) 13240 for { 13241 c := v.AuxInt 13242 x := v.Args[0] 13243 if !(isPowerOfTwo(c+1) && c >= 15) { 13244 break 13245 } 13246 v.reset(Op386SUBL) 13247 v0 := b.NewValue0(v.Pos, Op386SHLLconst, v.Type) 13248 v0.AuxInt = log2(c + 1) 13249 v0.AddArg(x) 13250 v.AddArg(v0) 13251 v.AddArg(x) 13252 return true 13253 } 13254 // match: (MULLconst [c] x) 13255 // cond: isPowerOfTwo(c-1) && c >= 17 13256 // result: (LEAL1 (SHLLconst <v.Type> [log2(c-1)] x) x) 13257 for { 13258 c := v.AuxInt 13259 x := v.Args[0] 13260 if !(isPowerOfTwo(c-1) && c >= 17) { 13261 break 13262 } 13263 v.reset(Op386LEAL1) 13264 v0 := b.NewValue0(v.Pos, Op386SHLLconst, v.Type) 13265 v0.AuxInt = log2(c - 1) 13266 v0.AddArg(x) 13267 v.AddArg(v0) 13268 v.AddArg(x) 13269 return true 13270 } 13271 // match: (MULLconst [c] x) 13272 // cond: isPowerOfTwo(c-2) && c >= 34 13273 // result: (LEAL2 (SHLLconst <v.Type> [log2(c-2)] x) x) 13274 for { 13275 c := v.AuxInt 13276 x := v.Args[0] 13277 if !(isPowerOfTwo(c-2) && c >= 34) { 13278 break 13279 } 13280 v.reset(Op386LEAL2) 13281 v0 := b.NewValue0(v.Pos, Op386SHLLconst, v.Type) 13282 v0.AuxInt = log2(c - 2) 13283 v0.AddArg(x) 13284 v.AddArg(v0) 13285 v.AddArg(x) 13286 return true 13287 } 13288 // match: (MULLconst [c] x) 13289 // cond: isPowerOfTwo(c-4) && c >= 68 13290 // result: (LEAL4 (SHLLconst <v.Type> [log2(c-4)] x) x) 13291 for { 13292 c := v.AuxInt 13293 x := v.Args[0] 13294 if !(isPowerOfTwo(c-4) && c >= 68) { 13295 break 13296 } 13297 v.reset(Op386LEAL4) 13298 v0 := b.NewValue0(v.Pos, Op386SHLLconst, v.Type) 13299 v0.AuxInt = log2(c - 4) 13300 v0.AddArg(x) 13301 v.AddArg(v0) 13302 v.AddArg(x) 13303 return true 13304 } 13305 // match: (MULLconst [c] x) 13306 // cond: isPowerOfTwo(c-8) && c >= 136 13307 // result: (LEAL8 (SHLLconst <v.Type> [log2(c-8)] x) x) 13308 for { 13309 c := v.AuxInt 13310 x := v.Args[0] 13311 if !(isPowerOfTwo(c-8) && c >= 136) { 13312 break 13313 } 13314 v.reset(Op386LEAL8) 13315 v0 := b.NewValue0(v.Pos, Op386SHLLconst, v.Type) 13316 v0.AuxInt = log2(c - 8) 13317 v0.AddArg(x) 13318 v.AddArg(v0) 13319 v.AddArg(x) 13320 return true 13321 } 13322 // match: (MULLconst [c] x) 13323 // cond: c%3 == 0 && isPowerOfTwo(c/3) 13324 // result: (SHLLconst [log2(c/3)] (LEAL2 <v.Type> x x)) 13325 for { 13326 c := v.AuxInt 13327 x := v.Args[0] 13328 if !(c%3 == 0 && isPowerOfTwo(c/3)) { 13329 break 13330 } 13331 v.reset(Op386SHLLconst) 13332 v.AuxInt = log2(c / 3) 13333 v0 := b.NewValue0(v.Pos, Op386LEAL2, v.Type) 13334 v0.AddArg(x) 13335 v0.AddArg(x) 13336 v.AddArg(v0) 13337 return true 13338 } 13339 // match: (MULLconst [c] x) 13340 // cond: c%5 == 0 && isPowerOfTwo(c/5) 13341 // result: (SHLLconst [log2(c/5)] (LEAL4 <v.Type> x x)) 13342 for { 13343 c := v.AuxInt 13344 x := v.Args[0] 13345 if !(c%5 == 0 && isPowerOfTwo(c/5)) { 13346 break 13347 } 13348 v.reset(Op386SHLLconst) 13349 v.AuxInt = log2(c / 5) 13350 v0 := b.NewValue0(v.Pos, Op386LEAL4, v.Type) 13351 v0.AddArg(x) 13352 v0.AddArg(x) 13353 v.AddArg(v0) 13354 return true 13355 } 13356 // match: (MULLconst [c] x) 13357 // cond: c%9 == 0 && isPowerOfTwo(c/9) 13358 // result: (SHLLconst [log2(c/9)] (LEAL8 <v.Type> x x)) 13359 for { 13360 c := v.AuxInt 13361 x := v.Args[0] 13362 if !(c%9 == 0 && isPowerOfTwo(c/9)) { 13363 break 13364 } 13365 v.reset(Op386SHLLconst) 13366 v.AuxInt = log2(c / 9) 13367 v0 := b.NewValue0(v.Pos, Op386LEAL8, v.Type) 13368 v0.AddArg(x) 13369 v0.AddArg(x) 13370 v.AddArg(v0) 13371 return true 13372 } 13373 return false 13374 } 13375 func rewriteValue386_Op386MULLconst_30(v *Value) bool { 13376 // match: (MULLconst [c] (MOVLconst [d])) 13377 // cond: 13378 // result: (MOVLconst [int64(int32(c*d))]) 13379 for { 13380 c := v.AuxInt 13381 v_0 := v.Args[0] 13382 if v_0.Op != Op386MOVLconst { 13383 break 13384 } 13385 d := v_0.AuxInt 13386 v.reset(Op386MOVLconst) 13387 v.AuxInt = int64(int32(c * d)) 13388 return true 13389 } 13390 return false 13391 } 13392 func rewriteValue386_Op386MULLload_0(v *Value) bool { 13393 b := v.Block 13394 _ = b 13395 config := b.Func.Config 13396 _ = config 13397 // match: (MULLload [off1] {sym} val (ADDLconst [off2] base) mem) 13398 // cond: is32Bit(off1+off2) 13399 // result: (MULLload [off1+off2] {sym} val base mem) 13400 for { 13401 off1 := v.AuxInt 13402 sym := v.Aux 13403 _ = v.Args[2] 13404 val := v.Args[0] 13405 v_1 := v.Args[1] 13406 if v_1.Op != Op386ADDLconst { 13407 break 13408 } 13409 off2 := v_1.AuxInt 13410 base := v_1.Args[0] 13411 mem := v.Args[2] 13412 if !(is32Bit(off1 + off2)) { 13413 break 13414 } 13415 v.reset(Op386MULLload) 13416 v.AuxInt = off1 + off2 13417 v.Aux = sym 13418 v.AddArg(val) 13419 v.AddArg(base) 13420 v.AddArg(mem) 13421 return true 13422 } 13423 // match: (MULLload [off1] {sym1} val (LEAL [off2] {sym2} base) mem) 13424 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 13425 // result: (MULLload [off1+off2] {mergeSym(sym1,sym2)} val base mem) 13426 for { 13427 off1 := v.AuxInt 13428 sym1 := v.Aux 13429 _ = v.Args[2] 13430 val := v.Args[0] 13431 v_1 := v.Args[1] 13432 if v_1.Op != Op386LEAL { 13433 break 13434 } 13435 off2 := v_1.AuxInt 13436 sym2 := v_1.Aux 13437 base := v_1.Args[0] 13438 mem := v.Args[2] 13439 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 13440 break 13441 } 13442 v.reset(Op386MULLload) 13443 v.AuxInt = off1 + off2 13444 v.Aux = mergeSym(sym1, sym2) 13445 v.AddArg(val) 13446 v.AddArg(base) 13447 v.AddArg(mem) 13448 return true 13449 } 13450 // match: (MULLload [off1] {sym1} val (LEAL4 [off2] {sym2} ptr idx) mem) 13451 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 13452 // result: (MULLloadidx4 [off1+off2] {mergeSym(sym1,sym2)} val ptr idx mem) 13453 for { 13454 off1 := v.AuxInt 13455 sym1 := v.Aux 13456 _ = v.Args[2] 13457 val := v.Args[0] 13458 v_1 := v.Args[1] 13459 if v_1.Op != Op386LEAL4 { 13460 break 13461 } 13462 off2 := v_1.AuxInt 13463 sym2 := v_1.Aux 13464 _ = v_1.Args[1] 13465 ptr := v_1.Args[0] 13466 idx := v_1.Args[1] 13467 mem := v.Args[2] 13468 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 13469 break 13470 } 13471 v.reset(Op386MULLloadidx4) 13472 v.AuxInt = off1 + off2 13473 v.Aux = mergeSym(sym1, sym2) 13474 v.AddArg(val) 13475 v.AddArg(ptr) 13476 v.AddArg(idx) 13477 v.AddArg(mem) 13478 return true 13479 } 13480 return false 13481 } 13482 func rewriteValue386_Op386MULLloadidx4_0(v *Value) bool { 13483 b := v.Block 13484 _ = b 13485 config := b.Func.Config 13486 _ = config 13487 // match: (MULLloadidx4 [off1] {sym} val (ADDLconst [off2] base) idx mem) 13488 // cond: is32Bit(off1+off2) 13489 // result: (MULLloadidx4 [off1+off2] {sym} val base idx mem) 13490 for { 13491 off1 := v.AuxInt 13492 sym := v.Aux 13493 _ = v.Args[3] 13494 val := v.Args[0] 13495 v_1 := v.Args[1] 13496 if v_1.Op != Op386ADDLconst { 13497 break 13498 } 13499 off2 := v_1.AuxInt 13500 base := v_1.Args[0] 13501 idx := v.Args[2] 13502 mem := v.Args[3] 13503 if !(is32Bit(off1 + off2)) { 13504 break 13505 } 13506 v.reset(Op386MULLloadidx4) 13507 v.AuxInt = off1 + off2 13508 v.Aux = sym 13509 v.AddArg(val) 13510 v.AddArg(base) 13511 v.AddArg(idx) 13512 v.AddArg(mem) 13513 return true 13514 } 13515 // match: (MULLloadidx4 [off1] {sym} val base (ADDLconst [off2] idx) mem) 13516 // cond: is32Bit(off1+off2*4) 13517 // result: (MULLloadidx4 [off1+off2*4] {sym} val base idx mem) 13518 for { 13519 off1 := v.AuxInt 13520 sym := v.Aux 13521 _ = v.Args[3] 13522 val := v.Args[0] 13523 base := v.Args[1] 13524 v_2 := v.Args[2] 13525 if v_2.Op != Op386ADDLconst { 13526 break 13527 } 13528 off2 := v_2.AuxInt 13529 idx := v_2.Args[0] 13530 mem := v.Args[3] 13531 if !(is32Bit(off1 + off2*4)) { 13532 break 13533 } 13534 v.reset(Op386MULLloadidx4) 13535 v.AuxInt = off1 + off2*4 13536 v.Aux = sym 13537 v.AddArg(val) 13538 v.AddArg(base) 13539 v.AddArg(idx) 13540 v.AddArg(mem) 13541 return true 13542 } 13543 // match: (MULLloadidx4 [off1] {sym1} val (LEAL [off2] {sym2} base) idx mem) 13544 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 13545 // result: (MULLloadidx4 [off1+off2] {mergeSym(sym1,sym2)} val base idx mem) 13546 for { 13547 off1 := v.AuxInt 13548 sym1 := v.Aux 13549 _ = v.Args[3] 13550 val := v.Args[0] 13551 v_1 := v.Args[1] 13552 if v_1.Op != Op386LEAL { 13553 break 13554 } 13555 off2 := v_1.AuxInt 13556 sym2 := v_1.Aux 13557 base := v_1.Args[0] 13558 idx := v.Args[2] 13559 mem := v.Args[3] 13560 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 13561 break 13562 } 13563 v.reset(Op386MULLloadidx4) 13564 v.AuxInt = off1 + off2 13565 v.Aux = mergeSym(sym1, sym2) 13566 v.AddArg(val) 13567 v.AddArg(base) 13568 v.AddArg(idx) 13569 v.AddArg(mem) 13570 return true 13571 } 13572 return false 13573 } 13574 func rewriteValue386_Op386MULSD_0(v *Value) bool { 13575 b := v.Block 13576 _ = b 13577 config := b.Func.Config 13578 _ = config 13579 // match: (MULSD x l:(MOVSDload [off] {sym} ptr mem)) 13580 // cond: canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l) 13581 // result: (MULSDload x [off] {sym} ptr mem) 13582 for { 13583 _ = v.Args[1] 13584 x := v.Args[0] 13585 l := v.Args[1] 13586 if l.Op != Op386MOVSDload { 13587 break 13588 } 13589 off := l.AuxInt 13590 sym := l.Aux 13591 _ = l.Args[1] 13592 ptr := l.Args[0] 13593 mem := l.Args[1] 13594 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) { 13595 break 13596 } 13597 v.reset(Op386MULSDload) 13598 v.AuxInt = off 13599 v.Aux = sym 13600 v.AddArg(x) 13601 v.AddArg(ptr) 13602 v.AddArg(mem) 13603 return true 13604 } 13605 // match: (MULSD l:(MOVSDload [off] {sym} ptr mem) x) 13606 // cond: canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l) 13607 // result: (MULSDload x [off] {sym} ptr mem) 13608 for { 13609 _ = v.Args[1] 13610 l := v.Args[0] 13611 if l.Op != Op386MOVSDload { 13612 break 13613 } 13614 off := l.AuxInt 13615 sym := l.Aux 13616 _ = l.Args[1] 13617 ptr := l.Args[0] 13618 mem := l.Args[1] 13619 x := v.Args[1] 13620 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) { 13621 break 13622 } 13623 v.reset(Op386MULSDload) 13624 v.AuxInt = off 13625 v.Aux = sym 13626 v.AddArg(x) 13627 v.AddArg(ptr) 13628 v.AddArg(mem) 13629 return true 13630 } 13631 return false 13632 } 13633 func rewriteValue386_Op386MULSDload_0(v *Value) bool { 13634 b := v.Block 13635 _ = b 13636 config := b.Func.Config 13637 _ = config 13638 // match: (MULSDload [off1] {sym} val (ADDLconst [off2] base) mem) 13639 // cond: is32Bit(off1+off2) 13640 // result: (MULSDload [off1+off2] {sym} val base mem) 13641 for { 13642 off1 := v.AuxInt 13643 sym := v.Aux 13644 _ = v.Args[2] 13645 val := v.Args[0] 13646 v_1 := v.Args[1] 13647 if v_1.Op != Op386ADDLconst { 13648 break 13649 } 13650 off2 := v_1.AuxInt 13651 base := v_1.Args[0] 13652 mem := v.Args[2] 13653 if !(is32Bit(off1 + off2)) { 13654 break 13655 } 13656 v.reset(Op386MULSDload) 13657 v.AuxInt = off1 + off2 13658 v.Aux = sym 13659 v.AddArg(val) 13660 v.AddArg(base) 13661 v.AddArg(mem) 13662 return true 13663 } 13664 // match: (MULSDload [off1] {sym1} val (LEAL [off2] {sym2} base) mem) 13665 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 13666 // result: (MULSDload [off1+off2] {mergeSym(sym1,sym2)} val base mem) 13667 for { 13668 off1 := v.AuxInt 13669 sym1 := v.Aux 13670 _ = v.Args[2] 13671 val := v.Args[0] 13672 v_1 := v.Args[1] 13673 if v_1.Op != Op386LEAL { 13674 break 13675 } 13676 off2 := v_1.AuxInt 13677 sym2 := v_1.Aux 13678 base := v_1.Args[0] 13679 mem := v.Args[2] 13680 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 13681 break 13682 } 13683 v.reset(Op386MULSDload) 13684 v.AuxInt = off1 + off2 13685 v.Aux = mergeSym(sym1, sym2) 13686 v.AddArg(val) 13687 v.AddArg(base) 13688 v.AddArg(mem) 13689 return true 13690 } 13691 return false 13692 } 13693 func rewriteValue386_Op386MULSS_0(v *Value) bool { 13694 b := v.Block 13695 _ = b 13696 config := b.Func.Config 13697 _ = config 13698 // match: (MULSS x l:(MOVSSload [off] {sym} ptr mem)) 13699 // cond: canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l) 13700 // result: (MULSSload x [off] {sym} ptr mem) 13701 for { 13702 _ = v.Args[1] 13703 x := v.Args[0] 13704 l := v.Args[1] 13705 if l.Op != Op386MOVSSload { 13706 break 13707 } 13708 off := l.AuxInt 13709 sym := l.Aux 13710 _ = l.Args[1] 13711 ptr := l.Args[0] 13712 mem := l.Args[1] 13713 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) { 13714 break 13715 } 13716 v.reset(Op386MULSSload) 13717 v.AuxInt = off 13718 v.Aux = sym 13719 v.AddArg(x) 13720 v.AddArg(ptr) 13721 v.AddArg(mem) 13722 return true 13723 } 13724 // match: (MULSS l:(MOVSSload [off] {sym} ptr mem) x) 13725 // cond: canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l) 13726 // result: (MULSSload x [off] {sym} ptr mem) 13727 for { 13728 _ = v.Args[1] 13729 l := v.Args[0] 13730 if l.Op != Op386MOVSSload { 13731 break 13732 } 13733 off := l.AuxInt 13734 sym := l.Aux 13735 _ = l.Args[1] 13736 ptr := l.Args[0] 13737 mem := l.Args[1] 13738 x := v.Args[1] 13739 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) { 13740 break 13741 } 13742 v.reset(Op386MULSSload) 13743 v.AuxInt = off 13744 v.Aux = sym 13745 v.AddArg(x) 13746 v.AddArg(ptr) 13747 v.AddArg(mem) 13748 return true 13749 } 13750 return false 13751 } 13752 func rewriteValue386_Op386MULSSload_0(v *Value) bool { 13753 b := v.Block 13754 _ = b 13755 config := b.Func.Config 13756 _ = config 13757 // match: (MULSSload [off1] {sym} val (ADDLconst [off2] base) mem) 13758 // cond: is32Bit(off1+off2) 13759 // result: (MULSSload [off1+off2] {sym} val base mem) 13760 for { 13761 off1 := v.AuxInt 13762 sym := v.Aux 13763 _ = v.Args[2] 13764 val := v.Args[0] 13765 v_1 := v.Args[1] 13766 if v_1.Op != Op386ADDLconst { 13767 break 13768 } 13769 off2 := v_1.AuxInt 13770 base := v_1.Args[0] 13771 mem := v.Args[2] 13772 if !(is32Bit(off1 + off2)) { 13773 break 13774 } 13775 v.reset(Op386MULSSload) 13776 v.AuxInt = off1 + off2 13777 v.Aux = sym 13778 v.AddArg(val) 13779 v.AddArg(base) 13780 v.AddArg(mem) 13781 return true 13782 } 13783 // match: (MULSSload [off1] {sym1} val (LEAL [off2] {sym2} base) mem) 13784 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 13785 // result: (MULSSload [off1+off2] {mergeSym(sym1,sym2)} val base mem) 13786 for { 13787 off1 := v.AuxInt 13788 sym1 := v.Aux 13789 _ = v.Args[2] 13790 val := v.Args[0] 13791 v_1 := v.Args[1] 13792 if v_1.Op != Op386LEAL { 13793 break 13794 } 13795 off2 := v_1.AuxInt 13796 sym2 := v_1.Aux 13797 base := v_1.Args[0] 13798 mem := v.Args[2] 13799 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 13800 break 13801 } 13802 v.reset(Op386MULSSload) 13803 v.AuxInt = off1 + off2 13804 v.Aux = mergeSym(sym1, sym2) 13805 v.AddArg(val) 13806 v.AddArg(base) 13807 v.AddArg(mem) 13808 return true 13809 } 13810 return false 13811 } 13812 func rewriteValue386_Op386NEGL_0(v *Value) bool { 13813 // match: (NEGL (MOVLconst [c])) 13814 // cond: 13815 // result: (MOVLconst [int64(int32(-c))]) 13816 for { 13817 v_0 := v.Args[0] 13818 if v_0.Op != Op386MOVLconst { 13819 break 13820 } 13821 c := v_0.AuxInt 13822 v.reset(Op386MOVLconst) 13823 v.AuxInt = int64(int32(-c)) 13824 return true 13825 } 13826 return false 13827 } 13828 func rewriteValue386_Op386NOTL_0(v *Value) bool { 13829 // match: (NOTL (MOVLconst [c])) 13830 // cond: 13831 // result: (MOVLconst [^c]) 13832 for { 13833 v_0 := v.Args[0] 13834 if v_0.Op != Op386MOVLconst { 13835 break 13836 } 13837 c := v_0.AuxInt 13838 v.reset(Op386MOVLconst) 13839 v.AuxInt = ^c 13840 return true 13841 } 13842 return false 13843 } 13844 func rewriteValue386_Op386ORL_0(v *Value) bool { 13845 // match: (ORL x (MOVLconst [c])) 13846 // cond: 13847 // result: (ORLconst [c] x) 13848 for { 13849 _ = v.Args[1] 13850 x := v.Args[0] 13851 v_1 := v.Args[1] 13852 if v_1.Op != Op386MOVLconst { 13853 break 13854 } 13855 c := v_1.AuxInt 13856 v.reset(Op386ORLconst) 13857 v.AuxInt = c 13858 v.AddArg(x) 13859 return true 13860 } 13861 // match: (ORL (MOVLconst [c]) x) 13862 // cond: 13863 // result: (ORLconst [c] x) 13864 for { 13865 _ = v.Args[1] 13866 v_0 := v.Args[0] 13867 if v_0.Op != Op386MOVLconst { 13868 break 13869 } 13870 c := v_0.AuxInt 13871 x := v.Args[1] 13872 v.reset(Op386ORLconst) 13873 v.AuxInt = c 13874 v.AddArg(x) 13875 return true 13876 } 13877 // match: (ORL (SHLLconst [c] x) (SHRLconst [d] x)) 13878 // cond: d == 32-c 13879 // result: (ROLLconst [c] x) 13880 for { 13881 _ = v.Args[1] 13882 v_0 := v.Args[0] 13883 if v_0.Op != Op386SHLLconst { 13884 break 13885 } 13886 c := v_0.AuxInt 13887 x := v_0.Args[0] 13888 v_1 := v.Args[1] 13889 if v_1.Op != Op386SHRLconst { 13890 break 13891 } 13892 d := v_1.AuxInt 13893 if x != v_1.Args[0] { 13894 break 13895 } 13896 if !(d == 32-c) { 13897 break 13898 } 13899 v.reset(Op386ROLLconst) 13900 v.AuxInt = c 13901 v.AddArg(x) 13902 return true 13903 } 13904 // match: (ORL (SHRLconst [d] x) (SHLLconst [c] x)) 13905 // cond: d == 32-c 13906 // result: (ROLLconst [c] x) 13907 for { 13908 _ = v.Args[1] 13909 v_0 := v.Args[0] 13910 if v_0.Op != Op386SHRLconst { 13911 break 13912 } 13913 d := v_0.AuxInt 13914 x := v_0.Args[0] 13915 v_1 := v.Args[1] 13916 if v_1.Op != Op386SHLLconst { 13917 break 13918 } 13919 c := v_1.AuxInt 13920 if x != v_1.Args[0] { 13921 break 13922 } 13923 if !(d == 32-c) { 13924 break 13925 } 13926 v.reset(Op386ROLLconst) 13927 v.AuxInt = c 13928 v.AddArg(x) 13929 return true 13930 } 13931 // match: (ORL <t> (SHLLconst x [c]) (SHRWconst x [d])) 13932 // cond: c < 16 && d == 16-c && t.Size() == 2 13933 // result: (ROLWconst x [c]) 13934 for { 13935 t := v.Type 13936 _ = v.Args[1] 13937 v_0 := v.Args[0] 13938 if v_0.Op != Op386SHLLconst { 13939 break 13940 } 13941 c := v_0.AuxInt 13942 x := v_0.Args[0] 13943 v_1 := v.Args[1] 13944 if v_1.Op != Op386SHRWconst { 13945 break 13946 } 13947 d := v_1.AuxInt 13948 if x != v_1.Args[0] { 13949 break 13950 } 13951 if !(c < 16 && d == 16-c && t.Size() == 2) { 13952 break 13953 } 13954 v.reset(Op386ROLWconst) 13955 v.AuxInt = c 13956 v.AddArg(x) 13957 return true 13958 } 13959 // match: (ORL <t> (SHRWconst x [d]) (SHLLconst x [c])) 13960 // cond: c < 16 && d == 16-c && t.Size() == 2 13961 // result: (ROLWconst x [c]) 13962 for { 13963 t := v.Type 13964 _ = v.Args[1] 13965 v_0 := v.Args[0] 13966 if v_0.Op != Op386SHRWconst { 13967 break 13968 } 13969 d := v_0.AuxInt 13970 x := v_0.Args[0] 13971 v_1 := v.Args[1] 13972 if v_1.Op != Op386SHLLconst { 13973 break 13974 } 13975 c := v_1.AuxInt 13976 if x != v_1.Args[0] { 13977 break 13978 } 13979 if !(c < 16 && d == 16-c && t.Size() == 2) { 13980 break 13981 } 13982 v.reset(Op386ROLWconst) 13983 v.AuxInt = c 13984 v.AddArg(x) 13985 return true 13986 } 13987 // match: (ORL <t> (SHLLconst x [c]) (SHRBconst x [d])) 13988 // cond: c < 8 && d == 8-c && t.Size() == 1 13989 // result: (ROLBconst x [c]) 13990 for { 13991 t := v.Type 13992 _ = v.Args[1] 13993 v_0 := v.Args[0] 13994 if v_0.Op != Op386SHLLconst { 13995 break 13996 } 13997 c := v_0.AuxInt 13998 x := v_0.Args[0] 13999 v_1 := v.Args[1] 14000 if v_1.Op != Op386SHRBconst { 14001 break 14002 } 14003 d := v_1.AuxInt 14004 if x != v_1.Args[0] { 14005 break 14006 } 14007 if !(c < 8 && d == 8-c && t.Size() == 1) { 14008 break 14009 } 14010 v.reset(Op386ROLBconst) 14011 v.AuxInt = c 14012 v.AddArg(x) 14013 return true 14014 } 14015 // match: (ORL <t> (SHRBconst x [d]) (SHLLconst x [c])) 14016 // cond: c < 8 && d == 8-c && t.Size() == 1 14017 // result: (ROLBconst x [c]) 14018 for { 14019 t := v.Type 14020 _ = v.Args[1] 14021 v_0 := v.Args[0] 14022 if v_0.Op != Op386SHRBconst { 14023 break 14024 } 14025 d := v_0.AuxInt 14026 x := v_0.Args[0] 14027 v_1 := v.Args[1] 14028 if v_1.Op != Op386SHLLconst { 14029 break 14030 } 14031 c := v_1.AuxInt 14032 if x != v_1.Args[0] { 14033 break 14034 } 14035 if !(c < 8 && d == 8-c && t.Size() == 1) { 14036 break 14037 } 14038 v.reset(Op386ROLBconst) 14039 v.AuxInt = c 14040 v.AddArg(x) 14041 return true 14042 } 14043 // match: (ORL x l:(MOVLload [off] {sym} ptr mem)) 14044 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 14045 // result: (ORLload x [off] {sym} ptr mem) 14046 for { 14047 _ = v.Args[1] 14048 x := v.Args[0] 14049 l := v.Args[1] 14050 if l.Op != Op386MOVLload { 14051 break 14052 } 14053 off := l.AuxInt 14054 sym := l.Aux 14055 _ = l.Args[1] 14056 ptr := l.Args[0] 14057 mem := l.Args[1] 14058 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 14059 break 14060 } 14061 v.reset(Op386ORLload) 14062 v.AuxInt = off 14063 v.Aux = sym 14064 v.AddArg(x) 14065 v.AddArg(ptr) 14066 v.AddArg(mem) 14067 return true 14068 } 14069 // match: (ORL l:(MOVLload [off] {sym} ptr mem) x) 14070 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 14071 // result: (ORLload x [off] {sym} ptr mem) 14072 for { 14073 _ = v.Args[1] 14074 l := v.Args[0] 14075 if l.Op != Op386MOVLload { 14076 break 14077 } 14078 off := l.AuxInt 14079 sym := l.Aux 14080 _ = l.Args[1] 14081 ptr := l.Args[0] 14082 mem := l.Args[1] 14083 x := v.Args[1] 14084 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 14085 break 14086 } 14087 v.reset(Op386ORLload) 14088 v.AuxInt = off 14089 v.Aux = sym 14090 v.AddArg(x) 14091 v.AddArg(ptr) 14092 v.AddArg(mem) 14093 return true 14094 } 14095 return false 14096 } 14097 func rewriteValue386_Op386ORL_10(v *Value) bool { 14098 b := v.Block 14099 _ = b 14100 typ := &b.Func.Config.Types 14101 _ = typ 14102 // match: (ORL x l:(MOVLloadidx4 [off] {sym} ptr idx mem)) 14103 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 14104 // result: (ORLloadidx4 x [off] {sym} ptr idx mem) 14105 for { 14106 _ = v.Args[1] 14107 x := v.Args[0] 14108 l := v.Args[1] 14109 if l.Op != Op386MOVLloadidx4 { 14110 break 14111 } 14112 off := l.AuxInt 14113 sym := l.Aux 14114 _ = l.Args[2] 14115 ptr := l.Args[0] 14116 idx := l.Args[1] 14117 mem := l.Args[2] 14118 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 14119 break 14120 } 14121 v.reset(Op386ORLloadidx4) 14122 v.AuxInt = off 14123 v.Aux = sym 14124 v.AddArg(x) 14125 v.AddArg(ptr) 14126 v.AddArg(idx) 14127 v.AddArg(mem) 14128 return true 14129 } 14130 // match: (ORL l:(MOVLloadidx4 [off] {sym} ptr idx mem) x) 14131 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 14132 // result: (ORLloadidx4 x [off] {sym} ptr idx mem) 14133 for { 14134 _ = v.Args[1] 14135 l := v.Args[0] 14136 if l.Op != Op386MOVLloadidx4 { 14137 break 14138 } 14139 off := l.AuxInt 14140 sym := l.Aux 14141 _ = l.Args[2] 14142 ptr := l.Args[0] 14143 idx := l.Args[1] 14144 mem := l.Args[2] 14145 x := v.Args[1] 14146 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 14147 break 14148 } 14149 v.reset(Op386ORLloadidx4) 14150 v.AuxInt = off 14151 v.Aux = sym 14152 v.AddArg(x) 14153 v.AddArg(ptr) 14154 v.AddArg(idx) 14155 v.AddArg(mem) 14156 return true 14157 } 14158 // match: (ORL x x) 14159 // cond: 14160 // result: x 14161 for { 14162 _ = v.Args[1] 14163 x := v.Args[0] 14164 if x != v.Args[1] { 14165 break 14166 } 14167 v.reset(OpCopy) 14168 v.Type = x.Type 14169 v.AddArg(x) 14170 return true 14171 } 14172 // match: (ORL x0:(MOVBload [i0] {s} p mem) s0:(SHLLconst [8] x1:(MOVBload [i1] {s} p mem))) 14173 // cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) 14174 // result: @mergePoint(b,x0,x1) (MOVWload [i0] {s} p mem) 14175 for { 14176 _ = v.Args[1] 14177 x0 := v.Args[0] 14178 if x0.Op != Op386MOVBload { 14179 break 14180 } 14181 i0 := x0.AuxInt 14182 s := x0.Aux 14183 _ = x0.Args[1] 14184 p := x0.Args[0] 14185 mem := x0.Args[1] 14186 s0 := v.Args[1] 14187 if s0.Op != Op386SHLLconst { 14188 break 14189 } 14190 if s0.AuxInt != 8 { 14191 break 14192 } 14193 x1 := s0.Args[0] 14194 if x1.Op != Op386MOVBload { 14195 break 14196 } 14197 i1 := x1.AuxInt 14198 if x1.Aux != s { 14199 break 14200 } 14201 _ = x1.Args[1] 14202 if p != x1.Args[0] { 14203 break 14204 } 14205 if mem != x1.Args[1] { 14206 break 14207 } 14208 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) { 14209 break 14210 } 14211 b = mergePoint(b, x0, x1) 14212 v0 := b.NewValue0(x1.Pos, Op386MOVWload, typ.UInt16) 14213 v.reset(OpCopy) 14214 v.AddArg(v0) 14215 v0.AuxInt = i0 14216 v0.Aux = s 14217 v0.AddArg(p) 14218 v0.AddArg(mem) 14219 return true 14220 } 14221 // match: (ORL s0:(SHLLconst [8] x1:(MOVBload [i1] {s} p mem)) x0:(MOVBload [i0] {s} p mem)) 14222 // cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) 14223 // result: @mergePoint(b,x0,x1) (MOVWload [i0] {s} p mem) 14224 for { 14225 _ = v.Args[1] 14226 s0 := v.Args[0] 14227 if s0.Op != Op386SHLLconst { 14228 break 14229 } 14230 if s0.AuxInt != 8 { 14231 break 14232 } 14233 x1 := s0.Args[0] 14234 if x1.Op != Op386MOVBload { 14235 break 14236 } 14237 i1 := x1.AuxInt 14238 s := x1.Aux 14239 _ = x1.Args[1] 14240 p := x1.Args[0] 14241 mem := x1.Args[1] 14242 x0 := v.Args[1] 14243 if x0.Op != Op386MOVBload { 14244 break 14245 } 14246 i0 := x0.AuxInt 14247 if x0.Aux != s { 14248 break 14249 } 14250 _ = x0.Args[1] 14251 if p != x0.Args[0] { 14252 break 14253 } 14254 if mem != x0.Args[1] { 14255 break 14256 } 14257 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) { 14258 break 14259 } 14260 b = mergePoint(b, x0, x1) 14261 v0 := b.NewValue0(x0.Pos, Op386MOVWload, typ.UInt16) 14262 v.reset(OpCopy) 14263 v.AddArg(v0) 14264 v0.AuxInt = i0 14265 v0.Aux = s 14266 v0.AddArg(p) 14267 v0.AddArg(mem) 14268 return true 14269 } 14270 // match: (ORL o0:(ORL x0:(MOVWload [i0] {s} p mem) s0:(SHLLconst [16] x1:(MOVBload [i2] {s} p mem))) s1:(SHLLconst [24] x2:(MOVBload [i3] {s} p mem))) 14271 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 14272 // result: @mergePoint(b,x0,x1,x2) (MOVLload [i0] {s} p mem) 14273 for { 14274 _ = v.Args[1] 14275 o0 := v.Args[0] 14276 if o0.Op != Op386ORL { 14277 break 14278 } 14279 _ = o0.Args[1] 14280 x0 := o0.Args[0] 14281 if x0.Op != Op386MOVWload { 14282 break 14283 } 14284 i0 := x0.AuxInt 14285 s := x0.Aux 14286 _ = x0.Args[1] 14287 p := x0.Args[0] 14288 mem := x0.Args[1] 14289 s0 := o0.Args[1] 14290 if s0.Op != Op386SHLLconst { 14291 break 14292 } 14293 if s0.AuxInt != 16 { 14294 break 14295 } 14296 x1 := s0.Args[0] 14297 if x1.Op != Op386MOVBload { 14298 break 14299 } 14300 i2 := x1.AuxInt 14301 if x1.Aux != s { 14302 break 14303 } 14304 _ = x1.Args[1] 14305 if p != x1.Args[0] { 14306 break 14307 } 14308 if mem != x1.Args[1] { 14309 break 14310 } 14311 s1 := v.Args[1] 14312 if s1.Op != Op386SHLLconst { 14313 break 14314 } 14315 if s1.AuxInt != 24 { 14316 break 14317 } 14318 x2 := s1.Args[0] 14319 if x2.Op != Op386MOVBload { 14320 break 14321 } 14322 i3 := x2.AuxInt 14323 if x2.Aux != s { 14324 break 14325 } 14326 _ = x2.Args[1] 14327 if p != x2.Args[0] { 14328 break 14329 } 14330 if mem != x2.Args[1] { 14331 break 14332 } 14333 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 14334 break 14335 } 14336 b = mergePoint(b, x0, x1, x2) 14337 v0 := b.NewValue0(x2.Pos, Op386MOVLload, typ.UInt32) 14338 v.reset(OpCopy) 14339 v.AddArg(v0) 14340 v0.AuxInt = i0 14341 v0.Aux = s 14342 v0.AddArg(p) 14343 v0.AddArg(mem) 14344 return true 14345 } 14346 // match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBload [i2] {s} p mem)) x0:(MOVWload [i0] {s} p mem)) s1:(SHLLconst [24] x2:(MOVBload [i3] {s} p mem))) 14347 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 14348 // result: @mergePoint(b,x0,x1,x2) (MOVLload [i0] {s} p mem) 14349 for { 14350 _ = v.Args[1] 14351 o0 := v.Args[0] 14352 if o0.Op != Op386ORL { 14353 break 14354 } 14355 _ = o0.Args[1] 14356 s0 := o0.Args[0] 14357 if s0.Op != Op386SHLLconst { 14358 break 14359 } 14360 if s0.AuxInt != 16 { 14361 break 14362 } 14363 x1 := s0.Args[0] 14364 if x1.Op != Op386MOVBload { 14365 break 14366 } 14367 i2 := x1.AuxInt 14368 s := x1.Aux 14369 _ = x1.Args[1] 14370 p := x1.Args[0] 14371 mem := x1.Args[1] 14372 x0 := o0.Args[1] 14373 if x0.Op != Op386MOVWload { 14374 break 14375 } 14376 i0 := x0.AuxInt 14377 if x0.Aux != s { 14378 break 14379 } 14380 _ = x0.Args[1] 14381 if p != x0.Args[0] { 14382 break 14383 } 14384 if mem != x0.Args[1] { 14385 break 14386 } 14387 s1 := v.Args[1] 14388 if s1.Op != Op386SHLLconst { 14389 break 14390 } 14391 if s1.AuxInt != 24 { 14392 break 14393 } 14394 x2 := s1.Args[0] 14395 if x2.Op != Op386MOVBload { 14396 break 14397 } 14398 i3 := x2.AuxInt 14399 if x2.Aux != s { 14400 break 14401 } 14402 _ = x2.Args[1] 14403 if p != x2.Args[0] { 14404 break 14405 } 14406 if mem != x2.Args[1] { 14407 break 14408 } 14409 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 14410 break 14411 } 14412 b = mergePoint(b, x0, x1, x2) 14413 v0 := b.NewValue0(x2.Pos, Op386MOVLload, typ.UInt32) 14414 v.reset(OpCopy) 14415 v.AddArg(v0) 14416 v0.AuxInt = i0 14417 v0.Aux = s 14418 v0.AddArg(p) 14419 v0.AddArg(mem) 14420 return true 14421 } 14422 // match: (ORL s1:(SHLLconst [24] x2:(MOVBload [i3] {s} p mem)) o0:(ORL x0:(MOVWload [i0] {s} p mem) s0:(SHLLconst [16] x1:(MOVBload [i2] {s} p mem)))) 14423 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 14424 // result: @mergePoint(b,x0,x1,x2) (MOVLload [i0] {s} p mem) 14425 for { 14426 _ = v.Args[1] 14427 s1 := v.Args[0] 14428 if s1.Op != Op386SHLLconst { 14429 break 14430 } 14431 if s1.AuxInt != 24 { 14432 break 14433 } 14434 x2 := s1.Args[0] 14435 if x2.Op != Op386MOVBload { 14436 break 14437 } 14438 i3 := x2.AuxInt 14439 s := x2.Aux 14440 _ = x2.Args[1] 14441 p := x2.Args[0] 14442 mem := x2.Args[1] 14443 o0 := v.Args[1] 14444 if o0.Op != Op386ORL { 14445 break 14446 } 14447 _ = o0.Args[1] 14448 x0 := o0.Args[0] 14449 if x0.Op != Op386MOVWload { 14450 break 14451 } 14452 i0 := x0.AuxInt 14453 if x0.Aux != s { 14454 break 14455 } 14456 _ = x0.Args[1] 14457 if p != x0.Args[0] { 14458 break 14459 } 14460 if mem != x0.Args[1] { 14461 break 14462 } 14463 s0 := o0.Args[1] 14464 if s0.Op != Op386SHLLconst { 14465 break 14466 } 14467 if s0.AuxInt != 16 { 14468 break 14469 } 14470 x1 := s0.Args[0] 14471 if x1.Op != Op386MOVBload { 14472 break 14473 } 14474 i2 := x1.AuxInt 14475 if x1.Aux != s { 14476 break 14477 } 14478 _ = x1.Args[1] 14479 if p != x1.Args[0] { 14480 break 14481 } 14482 if mem != x1.Args[1] { 14483 break 14484 } 14485 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 14486 break 14487 } 14488 b = mergePoint(b, x0, x1, x2) 14489 v0 := b.NewValue0(x1.Pos, Op386MOVLload, typ.UInt32) 14490 v.reset(OpCopy) 14491 v.AddArg(v0) 14492 v0.AuxInt = i0 14493 v0.Aux = s 14494 v0.AddArg(p) 14495 v0.AddArg(mem) 14496 return true 14497 } 14498 // match: (ORL s1:(SHLLconst [24] x2:(MOVBload [i3] {s} p mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBload [i2] {s} p mem)) x0:(MOVWload [i0] {s} p mem))) 14499 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 14500 // result: @mergePoint(b,x0,x1,x2) (MOVLload [i0] {s} p mem) 14501 for { 14502 _ = v.Args[1] 14503 s1 := v.Args[0] 14504 if s1.Op != Op386SHLLconst { 14505 break 14506 } 14507 if s1.AuxInt != 24 { 14508 break 14509 } 14510 x2 := s1.Args[0] 14511 if x2.Op != Op386MOVBload { 14512 break 14513 } 14514 i3 := x2.AuxInt 14515 s := x2.Aux 14516 _ = x2.Args[1] 14517 p := x2.Args[0] 14518 mem := x2.Args[1] 14519 o0 := v.Args[1] 14520 if o0.Op != Op386ORL { 14521 break 14522 } 14523 _ = o0.Args[1] 14524 s0 := o0.Args[0] 14525 if s0.Op != Op386SHLLconst { 14526 break 14527 } 14528 if s0.AuxInt != 16 { 14529 break 14530 } 14531 x1 := s0.Args[0] 14532 if x1.Op != Op386MOVBload { 14533 break 14534 } 14535 i2 := x1.AuxInt 14536 if x1.Aux != s { 14537 break 14538 } 14539 _ = x1.Args[1] 14540 if p != x1.Args[0] { 14541 break 14542 } 14543 if mem != x1.Args[1] { 14544 break 14545 } 14546 x0 := o0.Args[1] 14547 if x0.Op != Op386MOVWload { 14548 break 14549 } 14550 i0 := x0.AuxInt 14551 if x0.Aux != s { 14552 break 14553 } 14554 _ = x0.Args[1] 14555 if p != x0.Args[0] { 14556 break 14557 } 14558 if mem != x0.Args[1] { 14559 break 14560 } 14561 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 14562 break 14563 } 14564 b = mergePoint(b, x0, x1, x2) 14565 v0 := b.NewValue0(x0.Pos, Op386MOVLload, typ.UInt32) 14566 v.reset(OpCopy) 14567 v.AddArg(v0) 14568 v0.AuxInt = i0 14569 v0.Aux = s 14570 v0.AddArg(p) 14571 v0.AddArg(mem) 14572 return true 14573 } 14574 // match: (ORL x0:(MOVBloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} p idx mem))) 14575 // cond: i1==i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) 14576 // result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem) 14577 for { 14578 _ = v.Args[1] 14579 x0 := v.Args[0] 14580 if x0.Op != Op386MOVBloadidx1 { 14581 break 14582 } 14583 i0 := x0.AuxInt 14584 s := x0.Aux 14585 _ = x0.Args[2] 14586 p := x0.Args[0] 14587 idx := x0.Args[1] 14588 mem := x0.Args[2] 14589 s0 := v.Args[1] 14590 if s0.Op != Op386SHLLconst { 14591 break 14592 } 14593 if s0.AuxInt != 8 { 14594 break 14595 } 14596 x1 := s0.Args[0] 14597 if x1.Op != Op386MOVBloadidx1 { 14598 break 14599 } 14600 i1 := x1.AuxInt 14601 if x1.Aux != s { 14602 break 14603 } 14604 _ = x1.Args[2] 14605 if p != x1.Args[0] { 14606 break 14607 } 14608 if idx != x1.Args[1] { 14609 break 14610 } 14611 if mem != x1.Args[2] { 14612 break 14613 } 14614 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) { 14615 break 14616 } 14617 b = mergePoint(b, x0, x1) 14618 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type) 14619 v.reset(OpCopy) 14620 v.AddArg(v0) 14621 v0.AuxInt = i0 14622 v0.Aux = s 14623 v0.AddArg(p) 14624 v0.AddArg(idx) 14625 v0.AddArg(mem) 14626 return true 14627 } 14628 return false 14629 } 14630 func rewriteValue386_Op386ORL_20(v *Value) bool { 14631 b := v.Block 14632 _ = b 14633 // match: (ORL x0:(MOVBloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} p idx mem))) 14634 // cond: i1==i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) 14635 // result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem) 14636 for { 14637 _ = v.Args[1] 14638 x0 := v.Args[0] 14639 if x0.Op != Op386MOVBloadidx1 { 14640 break 14641 } 14642 i0 := x0.AuxInt 14643 s := x0.Aux 14644 _ = x0.Args[2] 14645 idx := x0.Args[0] 14646 p := x0.Args[1] 14647 mem := x0.Args[2] 14648 s0 := v.Args[1] 14649 if s0.Op != Op386SHLLconst { 14650 break 14651 } 14652 if s0.AuxInt != 8 { 14653 break 14654 } 14655 x1 := s0.Args[0] 14656 if x1.Op != Op386MOVBloadidx1 { 14657 break 14658 } 14659 i1 := x1.AuxInt 14660 if x1.Aux != s { 14661 break 14662 } 14663 _ = x1.Args[2] 14664 if p != x1.Args[0] { 14665 break 14666 } 14667 if idx != x1.Args[1] { 14668 break 14669 } 14670 if mem != x1.Args[2] { 14671 break 14672 } 14673 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) { 14674 break 14675 } 14676 b = mergePoint(b, x0, x1) 14677 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type) 14678 v.reset(OpCopy) 14679 v.AddArg(v0) 14680 v0.AuxInt = i0 14681 v0.Aux = s 14682 v0.AddArg(p) 14683 v0.AddArg(idx) 14684 v0.AddArg(mem) 14685 return true 14686 } 14687 // match: (ORL x0:(MOVBloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem))) 14688 // cond: i1==i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) 14689 // result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem) 14690 for { 14691 _ = v.Args[1] 14692 x0 := v.Args[0] 14693 if x0.Op != Op386MOVBloadidx1 { 14694 break 14695 } 14696 i0 := x0.AuxInt 14697 s := x0.Aux 14698 _ = x0.Args[2] 14699 p := x0.Args[0] 14700 idx := x0.Args[1] 14701 mem := x0.Args[2] 14702 s0 := v.Args[1] 14703 if s0.Op != Op386SHLLconst { 14704 break 14705 } 14706 if s0.AuxInt != 8 { 14707 break 14708 } 14709 x1 := s0.Args[0] 14710 if x1.Op != Op386MOVBloadidx1 { 14711 break 14712 } 14713 i1 := x1.AuxInt 14714 if x1.Aux != s { 14715 break 14716 } 14717 _ = x1.Args[2] 14718 if idx != x1.Args[0] { 14719 break 14720 } 14721 if p != x1.Args[1] { 14722 break 14723 } 14724 if mem != x1.Args[2] { 14725 break 14726 } 14727 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) { 14728 break 14729 } 14730 b = mergePoint(b, x0, x1) 14731 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type) 14732 v.reset(OpCopy) 14733 v.AddArg(v0) 14734 v0.AuxInt = i0 14735 v0.Aux = s 14736 v0.AddArg(p) 14737 v0.AddArg(idx) 14738 v0.AddArg(mem) 14739 return true 14740 } 14741 // match: (ORL x0:(MOVBloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem))) 14742 // cond: i1==i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) 14743 // result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem) 14744 for { 14745 _ = v.Args[1] 14746 x0 := v.Args[0] 14747 if x0.Op != Op386MOVBloadidx1 { 14748 break 14749 } 14750 i0 := x0.AuxInt 14751 s := x0.Aux 14752 _ = x0.Args[2] 14753 idx := x0.Args[0] 14754 p := x0.Args[1] 14755 mem := x0.Args[2] 14756 s0 := v.Args[1] 14757 if s0.Op != Op386SHLLconst { 14758 break 14759 } 14760 if s0.AuxInt != 8 { 14761 break 14762 } 14763 x1 := s0.Args[0] 14764 if x1.Op != Op386MOVBloadidx1 { 14765 break 14766 } 14767 i1 := x1.AuxInt 14768 if x1.Aux != s { 14769 break 14770 } 14771 _ = x1.Args[2] 14772 if idx != x1.Args[0] { 14773 break 14774 } 14775 if p != x1.Args[1] { 14776 break 14777 } 14778 if mem != x1.Args[2] { 14779 break 14780 } 14781 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) { 14782 break 14783 } 14784 b = mergePoint(b, x0, x1) 14785 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type) 14786 v.reset(OpCopy) 14787 v.AddArg(v0) 14788 v0.AuxInt = i0 14789 v0.Aux = s 14790 v0.AddArg(p) 14791 v0.AddArg(idx) 14792 v0.AddArg(mem) 14793 return true 14794 } 14795 // match: (ORL s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} p idx mem)) x0:(MOVBloadidx1 [i0] {s} p idx mem)) 14796 // cond: i1==i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) 14797 // result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem) 14798 for { 14799 _ = v.Args[1] 14800 s0 := v.Args[0] 14801 if s0.Op != Op386SHLLconst { 14802 break 14803 } 14804 if s0.AuxInt != 8 { 14805 break 14806 } 14807 x1 := s0.Args[0] 14808 if x1.Op != Op386MOVBloadidx1 { 14809 break 14810 } 14811 i1 := x1.AuxInt 14812 s := x1.Aux 14813 _ = x1.Args[2] 14814 p := x1.Args[0] 14815 idx := x1.Args[1] 14816 mem := x1.Args[2] 14817 x0 := v.Args[1] 14818 if x0.Op != Op386MOVBloadidx1 { 14819 break 14820 } 14821 i0 := x0.AuxInt 14822 if x0.Aux != s { 14823 break 14824 } 14825 _ = x0.Args[2] 14826 if p != x0.Args[0] { 14827 break 14828 } 14829 if idx != x0.Args[1] { 14830 break 14831 } 14832 if mem != x0.Args[2] { 14833 break 14834 } 14835 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) { 14836 break 14837 } 14838 b = mergePoint(b, x0, x1) 14839 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type) 14840 v.reset(OpCopy) 14841 v.AddArg(v0) 14842 v0.AuxInt = i0 14843 v0.Aux = s 14844 v0.AddArg(p) 14845 v0.AddArg(idx) 14846 v0.AddArg(mem) 14847 return true 14848 } 14849 // match: (ORL s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem)) x0:(MOVBloadidx1 [i0] {s} p idx mem)) 14850 // cond: i1==i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) 14851 // result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem) 14852 for { 14853 _ = v.Args[1] 14854 s0 := v.Args[0] 14855 if s0.Op != Op386SHLLconst { 14856 break 14857 } 14858 if s0.AuxInt != 8 { 14859 break 14860 } 14861 x1 := s0.Args[0] 14862 if x1.Op != Op386MOVBloadidx1 { 14863 break 14864 } 14865 i1 := x1.AuxInt 14866 s := x1.Aux 14867 _ = x1.Args[2] 14868 idx := x1.Args[0] 14869 p := x1.Args[1] 14870 mem := x1.Args[2] 14871 x0 := v.Args[1] 14872 if x0.Op != Op386MOVBloadidx1 { 14873 break 14874 } 14875 i0 := x0.AuxInt 14876 if x0.Aux != s { 14877 break 14878 } 14879 _ = x0.Args[2] 14880 if p != x0.Args[0] { 14881 break 14882 } 14883 if idx != x0.Args[1] { 14884 break 14885 } 14886 if mem != x0.Args[2] { 14887 break 14888 } 14889 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) { 14890 break 14891 } 14892 b = mergePoint(b, x0, x1) 14893 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type) 14894 v.reset(OpCopy) 14895 v.AddArg(v0) 14896 v0.AuxInt = i0 14897 v0.Aux = s 14898 v0.AddArg(p) 14899 v0.AddArg(idx) 14900 v0.AddArg(mem) 14901 return true 14902 } 14903 // match: (ORL s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} p idx mem)) x0:(MOVBloadidx1 [i0] {s} idx p mem)) 14904 // cond: i1==i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) 14905 // result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem) 14906 for { 14907 _ = v.Args[1] 14908 s0 := v.Args[0] 14909 if s0.Op != Op386SHLLconst { 14910 break 14911 } 14912 if s0.AuxInt != 8 { 14913 break 14914 } 14915 x1 := s0.Args[0] 14916 if x1.Op != Op386MOVBloadidx1 { 14917 break 14918 } 14919 i1 := x1.AuxInt 14920 s := x1.Aux 14921 _ = x1.Args[2] 14922 p := x1.Args[0] 14923 idx := x1.Args[1] 14924 mem := x1.Args[2] 14925 x0 := v.Args[1] 14926 if x0.Op != Op386MOVBloadidx1 { 14927 break 14928 } 14929 i0 := x0.AuxInt 14930 if x0.Aux != s { 14931 break 14932 } 14933 _ = x0.Args[2] 14934 if idx != x0.Args[0] { 14935 break 14936 } 14937 if p != x0.Args[1] { 14938 break 14939 } 14940 if mem != x0.Args[2] { 14941 break 14942 } 14943 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) { 14944 break 14945 } 14946 b = mergePoint(b, x0, x1) 14947 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type) 14948 v.reset(OpCopy) 14949 v.AddArg(v0) 14950 v0.AuxInt = i0 14951 v0.Aux = s 14952 v0.AddArg(p) 14953 v0.AddArg(idx) 14954 v0.AddArg(mem) 14955 return true 14956 } 14957 // match: (ORL s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem)) x0:(MOVBloadidx1 [i0] {s} idx p mem)) 14958 // cond: i1==i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) 14959 // result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem) 14960 for { 14961 _ = v.Args[1] 14962 s0 := v.Args[0] 14963 if s0.Op != Op386SHLLconst { 14964 break 14965 } 14966 if s0.AuxInt != 8 { 14967 break 14968 } 14969 x1 := s0.Args[0] 14970 if x1.Op != Op386MOVBloadidx1 { 14971 break 14972 } 14973 i1 := x1.AuxInt 14974 s := x1.Aux 14975 _ = x1.Args[2] 14976 idx := x1.Args[0] 14977 p := x1.Args[1] 14978 mem := x1.Args[2] 14979 x0 := v.Args[1] 14980 if x0.Op != Op386MOVBloadidx1 { 14981 break 14982 } 14983 i0 := x0.AuxInt 14984 if x0.Aux != s { 14985 break 14986 } 14987 _ = x0.Args[2] 14988 if idx != x0.Args[0] { 14989 break 14990 } 14991 if p != x0.Args[1] { 14992 break 14993 } 14994 if mem != x0.Args[2] { 14995 break 14996 } 14997 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) { 14998 break 14999 } 15000 b = mergePoint(b, x0, x1) 15001 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type) 15002 v.reset(OpCopy) 15003 v.AddArg(v0) 15004 v0.AuxInt = i0 15005 v0.Aux = s 15006 v0.AddArg(p) 15007 v0.AddArg(idx) 15008 v0.AddArg(mem) 15009 return true 15010 } 15011 // match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem))) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem))) 15012 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 15013 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 15014 for { 15015 _ = v.Args[1] 15016 o0 := v.Args[0] 15017 if o0.Op != Op386ORL { 15018 break 15019 } 15020 _ = o0.Args[1] 15021 x0 := o0.Args[0] 15022 if x0.Op != Op386MOVWloadidx1 { 15023 break 15024 } 15025 i0 := x0.AuxInt 15026 s := x0.Aux 15027 _ = x0.Args[2] 15028 p := x0.Args[0] 15029 idx := x0.Args[1] 15030 mem := x0.Args[2] 15031 s0 := o0.Args[1] 15032 if s0.Op != Op386SHLLconst { 15033 break 15034 } 15035 if s0.AuxInt != 16 { 15036 break 15037 } 15038 x1 := s0.Args[0] 15039 if x1.Op != Op386MOVBloadidx1 { 15040 break 15041 } 15042 i2 := x1.AuxInt 15043 if x1.Aux != s { 15044 break 15045 } 15046 _ = x1.Args[2] 15047 if p != x1.Args[0] { 15048 break 15049 } 15050 if idx != x1.Args[1] { 15051 break 15052 } 15053 if mem != x1.Args[2] { 15054 break 15055 } 15056 s1 := v.Args[1] 15057 if s1.Op != Op386SHLLconst { 15058 break 15059 } 15060 if s1.AuxInt != 24 { 15061 break 15062 } 15063 x2 := s1.Args[0] 15064 if x2.Op != Op386MOVBloadidx1 { 15065 break 15066 } 15067 i3 := x2.AuxInt 15068 if x2.Aux != s { 15069 break 15070 } 15071 _ = x2.Args[2] 15072 if p != x2.Args[0] { 15073 break 15074 } 15075 if idx != x2.Args[1] { 15076 break 15077 } 15078 if mem != x2.Args[2] { 15079 break 15080 } 15081 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 15082 break 15083 } 15084 b = mergePoint(b, x0, x1, x2) 15085 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 15086 v.reset(OpCopy) 15087 v.AddArg(v0) 15088 v0.AuxInt = i0 15089 v0.Aux = s 15090 v0.AddArg(p) 15091 v0.AddArg(idx) 15092 v0.AddArg(mem) 15093 return true 15094 } 15095 // match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem))) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem))) 15096 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 15097 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 15098 for { 15099 _ = v.Args[1] 15100 o0 := v.Args[0] 15101 if o0.Op != Op386ORL { 15102 break 15103 } 15104 _ = o0.Args[1] 15105 x0 := o0.Args[0] 15106 if x0.Op != Op386MOVWloadidx1 { 15107 break 15108 } 15109 i0 := x0.AuxInt 15110 s := x0.Aux 15111 _ = x0.Args[2] 15112 idx := x0.Args[0] 15113 p := x0.Args[1] 15114 mem := x0.Args[2] 15115 s0 := o0.Args[1] 15116 if s0.Op != Op386SHLLconst { 15117 break 15118 } 15119 if s0.AuxInt != 16 { 15120 break 15121 } 15122 x1 := s0.Args[0] 15123 if x1.Op != Op386MOVBloadidx1 { 15124 break 15125 } 15126 i2 := x1.AuxInt 15127 if x1.Aux != s { 15128 break 15129 } 15130 _ = x1.Args[2] 15131 if p != x1.Args[0] { 15132 break 15133 } 15134 if idx != x1.Args[1] { 15135 break 15136 } 15137 if mem != x1.Args[2] { 15138 break 15139 } 15140 s1 := v.Args[1] 15141 if s1.Op != Op386SHLLconst { 15142 break 15143 } 15144 if s1.AuxInt != 24 { 15145 break 15146 } 15147 x2 := s1.Args[0] 15148 if x2.Op != Op386MOVBloadidx1 { 15149 break 15150 } 15151 i3 := x2.AuxInt 15152 if x2.Aux != s { 15153 break 15154 } 15155 _ = x2.Args[2] 15156 if p != x2.Args[0] { 15157 break 15158 } 15159 if idx != x2.Args[1] { 15160 break 15161 } 15162 if mem != x2.Args[2] { 15163 break 15164 } 15165 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 15166 break 15167 } 15168 b = mergePoint(b, x0, x1, x2) 15169 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 15170 v.reset(OpCopy) 15171 v.AddArg(v0) 15172 v0.AuxInt = i0 15173 v0.Aux = s 15174 v0.AddArg(p) 15175 v0.AddArg(idx) 15176 v0.AddArg(mem) 15177 return true 15178 } 15179 // match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem))) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem))) 15180 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 15181 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 15182 for { 15183 _ = v.Args[1] 15184 o0 := v.Args[0] 15185 if o0.Op != Op386ORL { 15186 break 15187 } 15188 _ = o0.Args[1] 15189 x0 := o0.Args[0] 15190 if x0.Op != Op386MOVWloadidx1 { 15191 break 15192 } 15193 i0 := x0.AuxInt 15194 s := x0.Aux 15195 _ = x0.Args[2] 15196 p := x0.Args[0] 15197 idx := x0.Args[1] 15198 mem := x0.Args[2] 15199 s0 := o0.Args[1] 15200 if s0.Op != Op386SHLLconst { 15201 break 15202 } 15203 if s0.AuxInt != 16 { 15204 break 15205 } 15206 x1 := s0.Args[0] 15207 if x1.Op != Op386MOVBloadidx1 { 15208 break 15209 } 15210 i2 := x1.AuxInt 15211 if x1.Aux != s { 15212 break 15213 } 15214 _ = x1.Args[2] 15215 if idx != x1.Args[0] { 15216 break 15217 } 15218 if p != x1.Args[1] { 15219 break 15220 } 15221 if mem != x1.Args[2] { 15222 break 15223 } 15224 s1 := v.Args[1] 15225 if s1.Op != Op386SHLLconst { 15226 break 15227 } 15228 if s1.AuxInt != 24 { 15229 break 15230 } 15231 x2 := s1.Args[0] 15232 if x2.Op != Op386MOVBloadidx1 { 15233 break 15234 } 15235 i3 := x2.AuxInt 15236 if x2.Aux != s { 15237 break 15238 } 15239 _ = x2.Args[2] 15240 if p != x2.Args[0] { 15241 break 15242 } 15243 if idx != x2.Args[1] { 15244 break 15245 } 15246 if mem != x2.Args[2] { 15247 break 15248 } 15249 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 15250 break 15251 } 15252 b = mergePoint(b, x0, x1, x2) 15253 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 15254 v.reset(OpCopy) 15255 v.AddArg(v0) 15256 v0.AuxInt = i0 15257 v0.Aux = s 15258 v0.AddArg(p) 15259 v0.AddArg(idx) 15260 v0.AddArg(mem) 15261 return true 15262 } 15263 return false 15264 } 15265 func rewriteValue386_Op386ORL_30(v *Value) bool { 15266 b := v.Block 15267 _ = b 15268 // match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem))) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem))) 15269 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 15270 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 15271 for { 15272 _ = v.Args[1] 15273 o0 := v.Args[0] 15274 if o0.Op != Op386ORL { 15275 break 15276 } 15277 _ = o0.Args[1] 15278 x0 := o0.Args[0] 15279 if x0.Op != Op386MOVWloadidx1 { 15280 break 15281 } 15282 i0 := x0.AuxInt 15283 s := x0.Aux 15284 _ = x0.Args[2] 15285 idx := x0.Args[0] 15286 p := x0.Args[1] 15287 mem := x0.Args[2] 15288 s0 := o0.Args[1] 15289 if s0.Op != Op386SHLLconst { 15290 break 15291 } 15292 if s0.AuxInt != 16 { 15293 break 15294 } 15295 x1 := s0.Args[0] 15296 if x1.Op != Op386MOVBloadidx1 { 15297 break 15298 } 15299 i2 := x1.AuxInt 15300 if x1.Aux != s { 15301 break 15302 } 15303 _ = x1.Args[2] 15304 if idx != x1.Args[0] { 15305 break 15306 } 15307 if p != x1.Args[1] { 15308 break 15309 } 15310 if mem != x1.Args[2] { 15311 break 15312 } 15313 s1 := v.Args[1] 15314 if s1.Op != Op386SHLLconst { 15315 break 15316 } 15317 if s1.AuxInt != 24 { 15318 break 15319 } 15320 x2 := s1.Args[0] 15321 if x2.Op != Op386MOVBloadidx1 { 15322 break 15323 } 15324 i3 := x2.AuxInt 15325 if x2.Aux != s { 15326 break 15327 } 15328 _ = x2.Args[2] 15329 if p != x2.Args[0] { 15330 break 15331 } 15332 if idx != x2.Args[1] { 15333 break 15334 } 15335 if mem != x2.Args[2] { 15336 break 15337 } 15338 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 15339 break 15340 } 15341 b = mergePoint(b, x0, x1, x2) 15342 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 15343 v.reset(OpCopy) 15344 v.AddArg(v0) 15345 v0.AuxInt = i0 15346 v0.Aux = s 15347 v0.AddArg(p) 15348 v0.AddArg(idx) 15349 v0.AddArg(mem) 15350 return true 15351 } 15352 // match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem))) 15353 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 15354 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 15355 for { 15356 _ = v.Args[1] 15357 o0 := v.Args[0] 15358 if o0.Op != Op386ORL { 15359 break 15360 } 15361 _ = o0.Args[1] 15362 s0 := o0.Args[0] 15363 if s0.Op != Op386SHLLconst { 15364 break 15365 } 15366 if s0.AuxInt != 16 { 15367 break 15368 } 15369 x1 := s0.Args[0] 15370 if x1.Op != Op386MOVBloadidx1 { 15371 break 15372 } 15373 i2 := x1.AuxInt 15374 s := x1.Aux 15375 _ = x1.Args[2] 15376 p := x1.Args[0] 15377 idx := x1.Args[1] 15378 mem := x1.Args[2] 15379 x0 := o0.Args[1] 15380 if x0.Op != Op386MOVWloadidx1 { 15381 break 15382 } 15383 i0 := x0.AuxInt 15384 if x0.Aux != s { 15385 break 15386 } 15387 _ = x0.Args[2] 15388 if p != x0.Args[0] { 15389 break 15390 } 15391 if idx != x0.Args[1] { 15392 break 15393 } 15394 if mem != x0.Args[2] { 15395 break 15396 } 15397 s1 := v.Args[1] 15398 if s1.Op != Op386SHLLconst { 15399 break 15400 } 15401 if s1.AuxInt != 24 { 15402 break 15403 } 15404 x2 := s1.Args[0] 15405 if x2.Op != Op386MOVBloadidx1 { 15406 break 15407 } 15408 i3 := x2.AuxInt 15409 if x2.Aux != s { 15410 break 15411 } 15412 _ = x2.Args[2] 15413 if p != x2.Args[0] { 15414 break 15415 } 15416 if idx != x2.Args[1] { 15417 break 15418 } 15419 if mem != x2.Args[2] { 15420 break 15421 } 15422 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 15423 break 15424 } 15425 b = mergePoint(b, x0, x1, x2) 15426 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 15427 v.reset(OpCopy) 15428 v.AddArg(v0) 15429 v0.AuxInt = i0 15430 v0.Aux = s 15431 v0.AddArg(p) 15432 v0.AddArg(idx) 15433 v0.AddArg(mem) 15434 return true 15435 } 15436 // match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem))) 15437 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 15438 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 15439 for { 15440 _ = v.Args[1] 15441 o0 := v.Args[0] 15442 if o0.Op != Op386ORL { 15443 break 15444 } 15445 _ = o0.Args[1] 15446 s0 := o0.Args[0] 15447 if s0.Op != Op386SHLLconst { 15448 break 15449 } 15450 if s0.AuxInt != 16 { 15451 break 15452 } 15453 x1 := s0.Args[0] 15454 if x1.Op != Op386MOVBloadidx1 { 15455 break 15456 } 15457 i2 := x1.AuxInt 15458 s := x1.Aux 15459 _ = x1.Args[2] 15460 idx := x1.Args[0] 15461 p := x1.Args[1] 15462 mem := x1.Args[2] 15463 x0 := o0.Args[1] 15464 if x0.Op != Op386MOVWloadidx1 { 15465 break 15466 } 15467 i0 := x0.AuxInt 15468 if x0.Aux != s { 15469 break 15470 } 15471 _ = x0.Args[2] 15472 if p != x0.Args[0] { 15473 break 15474 } 15475 if idx != x0.Args[1] { 15476 break 15477 } 15478 if mem != x0.Args[2] { 15479 break 15480 } 15481 s1 := v.Args[1] 15482 if s1.Op != Op386SHLLconst { 15483 break 15484 } 15485 if s1.AuxInt != 24 { 15486 break 15487 } 15488 x2 := s1.Args[0] 15489 if x2.Op != Op386MOVBloadidx1 { 15490 break 15491 } 15492 i3 := x2.AuxInt 15493 if x2.Aux != s { 15494 break 15495 } 15496 _ = x2.Args[2] 15497 if p != x2.Args[0] { 15498 break 15499 } 15500 if idx != x2.Args[1] { 15501 break 15502 } 15503 if mem != x2.Args[2] { 15504 break 15505 } 15506 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 15507 break 15508 } 15509 b = mergePoint(b, x0, x1, x2) 15510 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 15511 v.reset(OpCopy) 15512 v.AddArg(v0) 15513 v0.AuxInt = i0 15514 v0.Aux = s 15515 v0.AddArg(p) 15516 v0.AddArg(idx) 15517 v0.AddArg(mem) 15518 return true 15519 } 15520 // match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem))) 15521 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 15522 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 15523 for { 15524 _ = v.Args[1] 15525 o0 := v.Args[0] 15526 if o0.Op != Op386ORL { 15527 break 15528 } 15529 _ = o0.Args[1] 15530 s0 := o0.Args[0] 15531 if s0.Op != Op386SHLLconst { 15532 break 15533 } 15534 if s0.AuxInt != 16 { 15535 break 15536 } 15537 x1 := s0.Args[0] 15538 if x1.Op != Op386MOVBloadidx1 { 15539 break 15540 } 15541 i2 := x1.AuxInt 15542 s := x1.Aux 15543 _ = x1.Args[2] 15544 p := x1.Args[0] 15545 idx := x1.Args[1] 15546 mem := x1.Args[2] 15547 x0 := o0.Args[1] 15548 if x0.Op != Op386MOVWloadidx1 { 15549 break 15550 } 15551 i0 := x0.AuxInt 15552 if x0.Aux != s { 15553 break 15554 } 15555 _ = x0.Args[2] 15556 if idx != x0.Args[0] { 15557 break 15558 } 15559 if p != x0.Args[1] { 15560 break 15561 } 15562 if mem != x0.Args[2] { 15563 break 15564 } 15565 s1 := v.Args[1] 15566 if s1.Op != Op386SHLLconst { 15567 break 15568 } 15569 if s1.AuxInt != 24 { 15570 break 15571 } 15572 x2 := s1.Args[0] 15573 if x2.Op != Op386MOVBloadidx1 { 15574 break 15575 } 15576 i3 := x2.AuxInt 15577 if x2.Aux != s { 15578 break 15579 } 15580 _ = x2.Args[2] 15581 if p != x2.Args[0] { 15582 break 15583 } 15584 if idx != x2.Args[1] { 15585 break 15586 } 15587 if mem != x2.Args[2] { 15588 break 15589 } 15590 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 15591 break 15592 } 15593 b = mergePoint(b, x0, x1, x2) 15594 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 15595 v.reset(OpCopy) 15596 v.AddArg(v0) 15597 v0.AuxInt = i0 15598 v0.Aux = s 15599 v0.AddArg(p) 15600 v0.AddArg(idx) 15601 v0.AddArg(mem) 15602 return true 15603 } 15604 // match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem))) 15605 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 15606 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 15607 for { 15608 _ = v.Args[1] 15609 o0 := v.Args[0] 15610 if o0.Op != Op386ORL { 15611 break 15612 } 15613 _ = o0.Args[1] 15614 s0 := o0.Args[0] 15615 if s0.Op != Op386SHLLconst { 15616 break 15617 } 15618 if s0.AuxInt != 16 { 15619 break 15620 } 15621 x1 := s0.Args[0] 15622 if x1.Op != Op386MOVBloadidx1 { 15623 break 15624 } 15625 i2 := x1.AuxInt 15626 s := x1.Aux 15627 _ = x1.Args[2] 15628 idx := x1.Args[0] 15629 p := x1.Args[1] 15630 mem := x1.Args[2] 15631 x0 := o0.Args[1] 15632 if x0.Op != Op386MOVWloadidx1 { 15633 break 15634 } 15635 i0 := x0.AuxInt 15636 if x0.Aux != s { 15637 break 15638 } 15639 _ = x0.Args[2] 15640 if idx != x0.Args[0] { 15641 break 15642 } 15643 if p != x0.Args[1] { 15644 break 15645 } 15646 if mem != x0.Args[2] { 15647 break 15648 } 15649 s1 := v.Args[1] 15650 if s1.Op != Op386SHLLconst { 15651 break 15652 } 15653 if s1.AuxInt != 24 { 15654 break 15655 } 15656 x2 := s1.Args[0] 15657 if x2.Op != Op386MOVBloadidx1 { 15658 break 15659 } 15660 i3 := x2.AuxInt 15661 if x2.Aux != s { 15662 break 15663 } 15664 _ = x2.Args[2] 15665 if p != x2.Args[0] { 15666 break 15667 } 15668 if idx != x2.Args[1] { 15669 break 15670 } 15671 if mem != x2.Args[2] { 15672 break 15673 } 15674 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 15675 break 15676 } 15677 b = mergePoint(b, x0, x1, x2) 15678 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 15679 v.reset(OpCopy) 15680 v.AddArg(v0) 15681 v0.AuxInt = i0 15682 v0.Aux = s 15683 v0.AddArg(p) 15684 v0.AddArg(idx) 15685 v0.AddArg(mem) 15686 return true 15687 } 15688 // match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem))) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem))) 15689 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 15690 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 15691 for { 15692 _ = v.Args[1] 15693 o0 := v.Args[0] 15694 if o0.Op != Op386ORL { 15695 break 15696 } 15697 _ = o0.Args[1] 15698 x0 := o0.Args[0] 15699 if x0.Op != Op386MOVWloadidx1 { 15700 break 15701 } 15702 i0 := x0.AuxInt 15703 s := x0.Aux 15704 _ = x0.Args[2] 15705 p := x0.Args[0] 15706 idx := x0.Args[1] 15707 mem := x0.Args[2] 15708 s0 := o0.Args[1] 15709 if s0.Op != Op386SHLLconst { 15710 break 15711 } 15712 if s0.AuxInt != 16 { 15713 break 15714 } 15715 x1 := s0.Args[0] 15716 if x1.Op != Op386MOVBloadidx1 { 15717 break 15718 } 15719 i2 := x1.AuxInt 15720 if x1.Aux != s { 15721 break 15722 } 15723 _ = x1.Args[2] 15724 if p != x1.Args[0] { 15725 break 15726 } 15727 if idx != x1.Args[1] { 15728 break 15729 } 15730 if mem != x1.Args[2] { 15731 break 15732 } 15733 s1 := v.Args[1] 15734 if s1.Op != Op386SHLLconst { 15735 break 15736 } 15737 if s1.AuxInt != 24 { 15738 break 15739 } 15740 x2 := s1.Args[0] 15741 if x2.Op != Op386MOVBloadidx1 { 15742 break 15743 } 15744 i3 := x2.AuxInt 15745 if x2.Aux != s { 15746 break 15747 } 15748 _ = x2.Args[2] 15749 if idx != x2.Args[0] { 15750 break 15751 } 15752 if p != x2.Args[1] { 15753 break 15754 } 15755 if mem != x2.Args[2] { 15756 break 15757 } 15758 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 15759 break 15760 } 15761 b = mergePoint(b, x0, x1, x2) 15762 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 15763 v.reset(OpCopy) 15764 v.AddArg(v0) 15765 v0.AuxInt = i0 15766 v0.Aux = s 15767 v0.AddArg(p) 15768 v0.AddArg(idx) 15769 v0.AddArg(mem) 15770 return true 15771 } 15772 // match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem))) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem))) 15773 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 15774 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 15775 for { 15776 _ = v.Args[1] 15777 o0 := v.Args[0] 15778 if o0.Op != Op386ORL { 15779 break 15780 } 15781 _ = o0.Args[1] 15782 x0 := o0.Args[0] 15783 if x0.Op != Op386MOVWloadidx1 { 15784 break 15785 } 15786 i0 := x0.AuxInt 15787 s := x0.Aux 15788 _ = x0.Args[2] 15789 idx := x0.Args[0] 15790 p := x0.Args[1] 15791 mem := x0.Args[2] 15792 s0 := o0.Args[1] 15793 if s0.Op != Op386SHLLconst { 15794 break 15795 } 15796 if s0.AuxInt != 16 { 15797 break 15798 } 15799 x1 := s0.Args[0] 15800 if x1.Op != Op386MOVBloadidx1 { 15801 break 15802 } 15803 i2 := x1.AuxInt 15804 if x1.Aux != s { 15805 break 15806 } 15807 _ = x1.Args[2] 15808 if p != x1.Args[0] { 15809 break 15810 } 15811 if idx != x1.Args[1] { 15812 break 15813 } 15814 if mem != x1.Args[2] { 15815 break 15816 } 15817 s1 := v.Args[1] 15818 if s1.Op != Op386SHLLconst { 15819 break 15820 } 15821 if s1.AuxInt != 24 { 15822 break 15823 } 15824 x2 := s1.Args[0] 15825 if x2.Op != Op386MOVBloadidx1 { 15826 break 15827 } 15828 i3 := x2.AuxInt 15829 if x2.Aux != s { 15830 break 15831 } 15832 _ = x2.Args[2] 15833 if idx != x2.Args[0] { 15834 break 15835 } 15836 if p != x2.Args[1] { 15837 break 15838 } 15839 if mem != x2.Args[2] { 15840 break 15841 } 15842 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 15843 break 15844 } 15845 b = mergePoint(b, x0, x1, x2) 15846 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 15847 v.reset(OpCopy) 15848 v.AddArg(v0) 15849 v0.AuxInt = i0 15850 v0.Aux = s 15851 v0.AddArg(p) 15852 v0.AddArg(idx) 15853 v0.AddArg(mem) 15854 return true 15855 } 15856 // match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem))) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem))) 15857 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 15858 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 15859 for { 15860 _ = v.Args[1] 15861 o0 := v.Args[0] 15862 if o0.Op != Op386ORL { 15863 break 15864 } 15865 _ = o0.Args[1] 15866 x0 := o0.Args[0] 15867 if x0.Op != Op386MOVWloadidx1 { 15868 break 15869 } 15870 i0 := x0.AuxInt 15871 s := x0.Aux 15872 _ = x0.Args[2] 15873 p := x0.Args[0] 15874 idx := x0.Args[1] 15875 mem := x0.Args[2] 15876 s0 := o0.Args[1] 15877 if s0.Op != Op386SHLLconst { 15878 break 15879 } 15880 if s0.AuxInt != 16 { 15881 break 15882 } 15883 x1 := s0.Args[0] 15884 if x1.Op != Op386MOVBloadidx1 { 15885 break 15886 } 15887 i2 := x1.AuxInt 15888 if x1.Aux != s { 15889 break 15890 } 15891 _ = x1.Args[2] 15892 if idx != x1.Args[0] { 15893 break 15894 } 15895 if p != x1.Args[1] { 15896 break 15897 } 15898 if mem != x1.Args[2] { 15899 break 15900 } 15901 s1 := v.Args[1] 15902 if s1.Op != Op386SHLLconst { 15903 break 15904 } 15905 if s1.AuxInt != 24 { 15906 break 15907 } 15908 x2 := s1.Args[0] 15909 if x2.Op != Op386MOVBloadidx1 { 15910 break 15911 } 15912 i3 := x2.AuxInt 15913 if x2.Aux != s { 15914 break 15915 } 15916 _ = x2.Args[2] 15917 if idx != x2.Args[0] { 15918 break 15919 } 15920 if p != x2.Args[1] { 15921 break 15922 } 15923 if mem != x2.Args[2] { 15924 break 15925 } 15926 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 15927 break 15928 } 15929 b = mergePoint(b, x0, x1, x2) 15930 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 15931 v.reset(OpCopy) 15932 v.AddArg(v0) 15933 v0.AuxInt = i0 15934 v0.Aux = s 15935 v0.AddArg(p) 15936 v0.AddArg(idx) 15937 v0.AddArg(mem) 15938 return true 15939 } 15940 // match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem))) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem))) 15941 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 15942 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 15943 for { 15944 _ = v.Args[1] 15945 o0 := v.Args[0] 15946 if o0.Op != Op386ORL { 15947 break 15948 } 15949 _ = o0.Args[1] 15950 x0 := o0.Args[0] 15951 if x0.Op != Op386MOVWloadidx1 { 15952 break 15953 } 15954 i0 := x0.AuxInt 15955 s := x0.Aux 15956 _ = x0.Args[2] 15957 idx := x0.Args[0] 15958 p := x0.Args[1] 15959 mem := x0.Args[2] 15960 s0 := o0.Args[1] 15961 if s0.Op != Op386SHLLconst { 15962 break 15963 } 15964 if s0.AuxInt != 16 { 15965 break 15966 } 15967 x1 := s0.Args[0] 15968 if x1.Op != Op386MOVBloadidx1 { 15969 break 15970 } 15971 i2 := x1.AuxInt 15972 if x1.Aux != s { 15973 break 15974 } 15975 _ = x1.Args[2] 15976 if idx != x1.Args[0] { 15977 break 15978 } 15979 if p != x1.Args[1] { 15980 break 15981 } 15982 if mem != x1.Args[2] { 15983 break 15984 } 15985 s1 := v.Args[1] 15986 if s1.Op != Op386SHLLconst { 15987 break 15988 } 15989 if s1.AuxInt != 24 { 15990 break 15991 } 15992 x2 := s1.Args[0] 15993 if x2.Op != Op386MOVBloadidx1 { 15994 break 15995 } 15996 i3 := x2.AuxInt 15997 if x2.Aux != s { 15998 break 15999 } 16000 _ = x2.Args[2] 16001 if idx != x2.Args[0] { 16002 break 16003 } 16004 if p != x2.Args[1] { 16005 break 16006 } 16007 if mem != x2.Args[2] { 16008 break 16009 } 16010 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 16011 break 16012 } 16013 b = mergePoint(b, x0, x1, x2) 16014 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 16015 v.reset(OpCopy) 16016 v.AddArg(v0) 16017 v0.AuxInt = i0 16018 v0.Aux = s 16019 v0.AddArg(p) 16020 v0.AddArg(idx) 16021 v0.AddArg(mem) 16022 return true 16023 } 16024 // match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem))) 16025 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 16026 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 16027 for { 16028 _ = v.Args[1] 16029 o0 := v.Args[0] 16030 if o0.Op != Op386ORL { 16031 break 16032 } 16033 _ = o0.Args[1] 16034 s0 := o0.Args[0] 16035 if s0.Op != Op386SHLLconst { 16036 break 16037 } 16038 if s0.AuxInt != 16 { 16039 break 16040 } 16041 x1 := s0.Args[0] 16042 if x1.Op != Op386MOVBloadidx1 { 16043 break 16044 } 16045 i2 := x1.AuxInt 16046 s := x1.Aux 16047 _ = x1.Args[2] 16048 p := x1.Args[0] 16049 idx := x1.Args[1] 16050 mem := x1.Args[2] 16051 x0 := o0.Args[1] 16052 if x0.Op != Op386MOVWloadidx1 { 16053 break 16054 } 16055 i0 := x0.AuxInt 16056 if x0.Aux != s { 16057 break 16058 } 16059 _ = x0.Args[2] 16060 if p != x0.Args[0] { 16061 break 16062 } 16063 if idx != x0.Args[1] { 16064 break 16065 } 16066 if mem != x0.Args[2] { 16067 break 16068 } 16069 s1 := v.Args[1] 16070 if s1.Op != Op386SHLLconst { 16071 break 16072 } 16073 if s1.AuxInt != 24 { 16074 break 16075 } 16076 x2 := s1.Args[0] 16077 if x2.Op != Op386MOVBloadidx1 { 16078 break 16079 } 16080 i3 := x2.AuxInt 16081 if x2.Aux != s { 16082 break 16083 } 16084 _ = x2.Args[2] 16085 if idx != x2.Args[0] { 16086 break 16087 } 16088 if p != x2.Args[1] { 16089 break 16090 } 16091 if mem != x2.Args[2] { 16092 break 16093 } 16094 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 16095 break 16096 } 16097 b = mergePoint(b, x0, x1, x2) 16098 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 16099 v.reset(OpCopy) 16100 v.AddArg(v0) 16101 v0.AuxInt = i0 16102 v0.Aux = s 16103 v0.AddArg(p) 16104 v0.AddArg(idx) 16105 v0.AddArg(mem) 16106 return true 16107 } 16108 return false 16109 } 16110 func rewriteValue386_Op386ORL_40(v *Value) bool { 16111 b := v.Block 16112 _ = b 16113 // match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem))) 16114 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 16115 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 16116 for { 16117 _ = v.Args[1] 16118 o0 := v.Args[0] 16119 if o0.Op != Op386ORL { 16120 break 16121 } 16122 _ = o0.Args[1] 16123 s0 := o0.Args[0] 16124 if s0.Op != Op386SHLLconst { 16125 break 16126 } 16127 if s0.AuxInt != 16 { 16128 break 16129 } 16130 x1 := s0.Args[0] 16131 if x1.Op != Op386MOVBloadidx1 { 16132 break 16133 } 16134 i2 := x1.AuxInt 16135 s := x1.Aux 16136 _ = x1.Args[2] 16137 idx := x1.Args[0] 16138 p := x1.Args[1] 16139 mem := x1.Args[2] 16140 x0 := o0.Args[1] 16141 if x0.Op != Op386MOVWloadidx1 { 16142 break 16143 } 16144 i0 := x0.AuxInt 16145 if x0.Aux != s { 16146 break 16147 } 16148 _ = x0.Args[2] 16149 if p != x0.Args[0] { 16150 break 16151 } 16152 if idx != x0.Args[1] { 16153 break 16154 } 16155 if mem != x0.Args[2] { 16156 break 16157 } 16158 s1 := v.Args[1] 16159 if s1.Op != Op386SHLLconst { 16160 break 16161 } 16162 if s1.AuxInt != 24 { 16163 break 16164 } 16165 x2 := s1.Args[0] 16166 if x2.Op != Op386MOVBloadidx1 { 16167 break 16168 } 16169 i3 := x2.AuxInt 16170 if x2.Aux != s { 16171 break 16172 } 16173 _ = x2.Args[2] 16174 if idx != x2.Args[0] { 16175 break 16176 } 16177 if p != x2.Args[1] { 16178 break 16179 } 16180 if mem != x2.Args[2] { 16181 break 16182 } 16183 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 16184 break 16185 } 16186 b = mergePoint(b, x0, x1, x2) 16187 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 16188 v.reset(OpCopy) 16189 v.AddArg(v0) 16190 v0.AuxInt = i0 16191 v0.Aux = s 16192 v0.AddArg(p) 16193 v0.AddArg(idx) 16194 v0.AddArg(mem) 16195 return true 16196 } 16197 // match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem))) 16198 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 16199 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 16200 for { 16201 _ = v.Args[1] 16202 o0 := v.Args[0] 16203 if o0.Op != Op386ORL { 16204 break 16205 } 16206 _ = o0.Args[1] 16207 s0 := o0.Args[0] 16208 if s0.Op != Op386SHLLconst { 16209 break 16210 } 16211 if s0.AuxInt != 16 { 16212 break 16213 } 16214 x1 := s0.Args[0] 16215 if x1.Op != Op386MOVBloadidx1 { 16216 break 16217 } 16218 i2 := x1.AuxInt 16219 s := x1.Aux 16220 _ = x1.Args[2] 16221 p := x1.Args[0] 16222 idx := x1.Args[1] 16223 mem := x1.Args[2] 16224 x0 := o0.Args[1] 16225 if x0.Op != Op386MOVWloadidx1 { 16226 break 16227 } 16228 i0 := x0.AuxInt 16229 if x0.Aux != s { 16230 break 16231 } 16232 _ = x0.Args[2] 16233 if idx != x0.Args[0] { 16234 break 16235 } 16236 if p != x0.Args[1] { 16237 break 16238 } 16239 if mem != x0.Args[2] { 16240 break 16241 } 16242 s1 := v.Args[1] 16243 if s1.Op != Op386SHLLconst { 16244 break 16245 } 16246 if s1.AuxInt != 24 { 16247 break 16248 } 16249 x2 := s1.Args[0] 16250 if x2.Op != Op386MOVBloadidx1 { 16251 break 16252 } 16253 i3 := x2.AuxInt 16254 if x2.Aux != s { 16255 break 16256 } 16257 _ = x2.Args[2] 16258 if idx != x2.Args[0] { 16259 break 16260 } 16261 if p != x2.Args[1] { 16262 break 16263 } 16264 if mem != x2.Args[2] { 16265 break 16266 } 16267 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 16268 break 16269 } 16270 b = mergePoint(b, x0, x1, x2) 16271 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 16272 v.reset(OpCopy) 16273 v.AddArg(v0) 16274 v0.AuxInt = i0 16275 v0.Aux = s 16276 v0.AddArg(p) 16277 v0.AddArg(idx) 16278 v0.AddArg(mem) 16279 return true 16280 } 16281 // match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem))) 16282 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 16283 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 16284 for { 16285 _ = v.Args[1] 16286 o0 := v.Args[0] 16287 if o0.Op != Op386ORL { 16288 break 16289 } 16290 _ = o0.Args[1] 16291 s0 := o0.Args[0] 16292 if s0.Op != Op386SHLLconst { 16293 break 16294 } 16295 if s0.AuxInt != 16 { 16296 break 16297 } 16298 x1 := s0.Args[0] 16299 if x1.Op != Op386MOVBloadidx1 { 16300 break 16301 } 16302 i2 := x1.AuxInt 16303 s := x1.Aux 16304 _ = x1.Args[2] 16305 idx := x1.Args[0] 16306 p := x1.Args[1] 16307 mem := x1.Args[2] 16308 x0 := o0.Args[1] 16309 if x0.Op != Op386MOVWloadidx1 { 16310 break 16311 } 16312 i0 := x0.AuxInt 16313 if x0.Aux != s { 16314 break 16315 } 16316 _ = x0.Args[2] 16317 if idx != x0.Args[0] { 16318 break 16319 } 16320 if p != x0.Args[1] { 16321 break 16322 } 16323 if mem != x0.Args[2] { 16324 break 16325 } 16326 s1 := v.Args[1] 16327 if s1.Op != Op386SHLLconst { 16328 break 16329 } 16330 if s1.AuxInt != 24 { 16331 break 16332 } 16333 x2 := s1.Args[0] 16334 if x2.Op != Op386MOVBloadidx1 { 16335 break 16336 } 16337 i3 := x2.AuxInt 16338 if x2.Aux != s { 16339 break 16340 } 16341 _ = x2.Args[2] 16342 if idx != x2.Args[0] { 16343 break 16344 } 16345 if p != x2.Args[1] { 16346 break 16347 } 16348 if mem != x2.Args[2] { 16349 break 16350 } 16351 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 16352 break 16353 } 16354 b = mergePoint(b, x0, x1, x2) 16355 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 16356 v.reset(OpCopy) 16357 v.AddArg(v0) 16358 v0.AuxInt = i0 16359 v0.Aux = s 16360 v0.AddArg(p) 16361 v0.AddArg(idx) 16362 v0.AddArg(mem) 16363 return true 16364 } 16365 // match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)))) 16366 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 16367 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 16368 for { 16369 _ = v.Args[1] 16370 s1 := v.Args[0] 16371 if s1.Op != Op386SHLLconst { 16372 break 16373 } 16374 if s1.AuxInt != 24 { 16375 break 16376 } 16377 x2 := s1.Args[0] 16378 if x2.Op != Op386MOVBloadidx1 { 16379 break 16380 } 16381 i3 := x2.AuxInt 16382 s := x2.Aux 16383 _ = x2.Args[2] 16384 p := x2.Args[0] 16385 idx := x2.Args[1] 16386 mem := x2.Args[2] 16387 o0 := v.Args[1] 16388 if o0.Op != Op386ORL { 16389 break 16390 } 16391 _ = o0.Args[1] 16392 x0 := o0.Args[0] 16393 if x0.Op != Op386MOVWloadidx1 { 16394 break 16395 } 16396 i0 := x0.AuxInt 16397 if x0.Aux != s { 16398 break 16399 } 16400 _ = x0.Args[2] 16401 if p != x0.Args[0] { 16402 break 16403 } 16404 if idx != x0.Args[1] { 16405 break 16406 } 16407 if mem != x0.Args[2] { 16408 break 16409 } 16410 s0 := o0.Args[1] 16411 if s0.Op != Op386SHLLconst { 16412 break 16413 } 16414 if s0.AuxInt != 16 { 16415 break 16416 } 16417 x1 := s0.Args[0] 16418 if x1.Op != Op386MOVBloadidx1 { 16419 break 16420 } 16421 i2 := x1.AuxInt 16422 if x1.Aux != s { 16423 break 16424 } 16425 _ = x1.Args[2] 16426 if p != x1.Args[0] { 16427 break 16428 } 16429 if idx != x1.Args[1] { 16430 break 16431 } 16432 if mem != x1.Args[2] { 16433 break 16434 } 16435 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 16436 break 16437 } 16438 b = mergePoint(b, x0, x1, x2) 16439 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 16440 v.reset(OpCopy) 16441 v.AddArg(v0) 16442 v0.AuxInt = i0 16443 v0.Aux = s 16444 v0.AddArg(p) 16445 v0.AddArg(idx) 16446 v0.AddArg(mem) 16447 return true 16448 } 16449 // match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)))) 16450 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 16451 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 16452 for { 16453 _ = v.Args[1] 16454 s1 := v.Args[0] 16455 if s1.Op != Op386SHLLconst { 16456 break 16457 } 16458 if s1.AuxInt != 24 { 16459 break 16460 } 16461 x2 := s1.Args[0] 16462 if x2.Op != Op386MOVBloadidx1 { 16463 break 16464 } 16465 i3 := x2.AuxInt 16466 s := x2.Aux 16467 _ = x2.Args[2] 16468 idx := x2.Args[0] 16469 p := x2.Args[1] 16470 mem := x2.Args[2] 16471 o0 := v.Args[1] 16472 if o0.Op != Op386ORL { 16473 break 16474 } 16475 _ = o0.Args[1] 16476 x0 := o0.Args[0] 16477 if x0.Op != Op386MOVWloadidx1 { 16478 break 16479 } 16480 i0 := x0.AuxInt 16481 if x0.Aux != s { 16482 break 16483 } 16484 _ = x0.Args[2] 16485 if p != x0.Args[0] { 16486 break 16487 } 16488 if idx != x0.Args[1] { 16489 break 16490 } 16491 if mem != x0.Args[2] { 16492 break 16493 } 16494 s0 := o0.Args[1] 16495 if s0.Op != Op386SHLLconst { 16496 break 16497 } 16498 if s0.AuxInt != 16 { 16499 break 16500 } 16501 x1 := s0.Args[0] 16502 if x1.Op != Op386MOVBloadidx1 { 16503 break 16504 } 16505 i2 := x1.AuxInt 16506 if x1.Aux != s { 16507 break 16508 } 16509 _ = x1.Args[2] 16510 if p != x1.Args[0] { 16511 break 16512 } 16513 if idx != x1.Args[1] { 16514 break 16515 } 16516 if mem != x1.Args[2] { 16517 break 16518 } 16519 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 16520 break 16521 } 16522 b = mergePoint(b, x0, x1, x2) 16523 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 16524 v.reset(OpCopy) 16525 v.AddArg(v0) 16526 v0.AuxInt = i0 16527 v0.Aux = s 16528 v0.AddArg(p) 16529 v0.AddArg(idx) 16530 v0.AddArg(mem) 16531 return true 16532 } 16533 // match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)))) 16534 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 16535 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 16536 for { 16537 _ = v.Args[1] 16538 s1 := v.Args[0] 16539 if s1.Op != Op386SHLLconst { 16540 break 16541 } 16542 if s1.AuxInt != 24 { 16543 break 16544 } 16545 x2 := s1.Args[0] 16546 if x2.Op != Op386MOVBloadidx1 { 16547 break 16548 } 16549 i3 := x2.AuxInt 16550 s := x2.Aux 16551 _ = x2.Args[2] 16552 p := x2.Args[0] 16553 idx := x2.Args[1] 16554 mem := x2.Args[2] 16555 o0 := v.Args[1] 16556 if o0.Op != Op386ORL { 16557 break 16558 } 16559 _ = o0.Args[1] 16560 x0 := o0.Args[0] 16561 if x0.Op != Op386MOVWloadidx1 { 16562 break 16563 } 16564 i0 := x0.AuxInt 16565 if x0.Aux != s { 16566 break 16567 } 16568 _ = x0.Args[2] 16569 if idx != x0.Args[0] { 16570 break 16571 } 16572 if p != x0.Args[1] { 16573 break 16574 } 16575 if mem != x0.Args[2] { 16576 break 16577 } 16578 s0 := o0.Args[1] 16579 if s0.Op != Op386SHLLconst { 16580 break 16581 } 16582 if s0.AuxInt != 16 { 16583 break 16584 } 16585 x1 := s0.Args[0] 16586 if x1.Op != Op386MOVBloadidx1 { 16587 break 16588 } 16589 i2 := x1.AuxInt 16590 if x1.Aux != s { 16591 break 16592 } 16593 _ = x1.Args[2] 16594 if p != x1.Args[0] { 16595 break 16596 } 16597 if idx != x1.Args[1] { 16598 break 16599 } 16600 if mem != x1.Args[2] { 16601 break 16602 } 16603 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 16604 break 16605 } 16606 b = mergePoint(b, x0, x1, x2) 16607 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 16608 v.reset(OpCopy) 16609 v.AddArg(v0) 16610 v0.AuxInt = i0 16611 v0.Aux = s 16612 v0.AddArg(p) 16613 v0.AddArg(idx) 16614 v0.AddArg(mem) 16615 return true 16616 } 16617 // match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)))) 16618 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 16619 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 16620 for { 16621 _ = v.Args[1] 16622 s1 := v.Args[0] 16623 if s1.Op != Op386SHLLconst { 16624 break 16625 } 16626 if s1.AuxInt != 24 { 16627 break 16628 } 16629 x2 := s1.Args[0] 16630 if x2.Op != Op386MOVBloadidx1 { 16631 break 16632 } 16633 i3 := x2.AuxInt 16634 s := x2.Aux 16635 _ = x2.Args[2] 16636 idx := x2.Args[0] 16637 p := x2.Args[1] 16638 mem := x2.Args[2] 16639 o0 := v.Args[1] 16640 if o0.Op != Op386ORL { 16641 break 16642 } 16643 _ = o0.Args[1] 16644 x0 := o0.Args[0] 16645 if x0.Op != Op386MOVWloadidx1 { 16646 break 16647 } 16648 i0 := x0.AuxInt 16649 if x0.Aux != s { 16650 break 16651 } 16652 _ = x0.Args[2] 16653 if idx != x0.Args[0] { 16654 break 16655 } 16656 if p != x0.Args[1] { 16657 break 16658 } 16659 if mem != x0.Args[2] { 16660 break 16661 } 16662 s0 := o0.Args[1] 16663 if s0.Op != Op386SHLLconst { 16664 break 16665 } 16666 if s0.AuxInt != 16 { 16667 break 16668 } 16669 x1 := s0.Args[0] 16670 if x1.Op != Op386MOVBloadidx1 { 16671 break 16672 } 16673 i2 := x1.AuxInt 16674 if x1.Aux != s { 16675 break 16676 } 16677 _ = x1.Args[2] 16678 if p != x1.Args[0] { 16679 break 16680 } 16681 if idx != x1.Args[1] { 16682 break 16683 } 16684 if mem != x1.Args[2] { 16685 break 16686 } 16687 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 16688 break 16689 } 16690 b = mergePoint(b, x0, x1, x2) 16691 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 16692 v.reset(OpCopy) 16693 v.AddArg(v0) 16694 v0.AuxInt = i0 16695 v0.Aux = s 16696 v0.AddArg(p) 16697 v0.AddArg(idx) 16698 v0.AddArg(mem) 16699 return true 16700 } 16701 // match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)))) 16702 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 16703 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 16704 for { 16705 _ = v.Args[1] 16706 s1 := v.Args[0] 16707 if s1.Op != Op386SHLLconst { 16708 break 16709 } 16710 if s1.AuxInt != 24 { 16711 break 16712 } 16713 x2 := s1.Args[0] 16714 if x2.Op != Op386MOVBloadidx1 { 16715 break 16716 } 16717 i3 := x2.AuxInt 16718 s := x2.Aux 16719 _ = x2.Args[2] 16720 p := x2.Args[0] 16721 idx := x2.Args[1] 16722 mem := x2.Args[2] 16723 o0 := v.Args[1] 16724 if o0.Op != Op386ORL { 16725 break 16726 } 16727 _ = o0.Args[1] 16728 x0 := o0.Args[0] 16729 if x0.Op != Op386MOVWloadidx1 { 16730 break 16731 } 16732 i0 := x0.AuxInt 16733 if x0.Aux != s { 16734 break 16735 } 16736 _ = x0.Args[2] 16737 if p != x0.Args[0] { 16738 break 16739 } 16740 if idx != x0.Args[1] { 16741 break 16742 } 16743 if mem != x0.Args[2] { 16744 break 16745 } 16746 s0 := o0.Args[1] 16747 if s0.Op != Op386SHLLconst { 16748 break 16749 } 16750 if s0.AuxInt != 16 { 16751 break 16752 } 16753 x1 := s0.Args[0] 16754 if x1.Op != Op386MOVBloadidx1 { 16755 break 16756 } 16757 i2 := x1.AuxInt 16758 if x1.Aux != s { 16759 break 16760 } 16761 _ = x1.Args[2] 16762 if idx != x1.Args[0] { 16763 break 16764 } 16765 if p != x1.Args[1] { 16766 break 16767 } 16768 if mem != x1.Args[2] { 16769 break 16770 } 16771 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 16772 break 16773 } 16774 b = mergePoint(b, x0, x1, x2) 16775 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 16776 v.reset(OpCopy) 16777 v.AddArg(v0) 16778 v0.AuxInt = i0 16779 v0.Aux = s 16780 v0.AddArg(p) 16781 v0.AddArg(idx) 16782 v0.AddArg(mem) 16783 return true 16784 } 16785 // match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)))) 16786 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 16787 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 16788 for { 16789 _ = v.Args[1] 16790 s1 := v.Args[0] 16791 if s1.Op != Op386SHLLconst { 16792 break 16793 } 16794 if s1.AuxInt != 24 { 16795 break 16796 } 16797 x2 := s1.Args[0] 16798 if x2.Op != Op386MOVBloadidx1 { 16799 break 16800 } 16801 i3 := x2.AuxInt 16802 s := x2.Aux 16803 _ = x2.Args[2] 16804 idx := x2.Args[0] 16805 p := x2.Args[1] 16806 mem := x2.Args[2] 16807 o0 := v.Args[1] 16808 if o0.Op != Op386ORL { 16809 break 16810 } 16811 _ = o0.Args[1] 16812 x0 := o0.Args[0] 16813 if x0.Op != Op386MOVWloadidx1 { 16814 break 16815 } 16816 i0 := x0.AuxInt 16817 if x0.Aux != s { 16818 break 16819 } 16820 _ = x0.Args[2] 16821 if p != x0.Args[0] { 16822 break 16823 } 16824 if idx != x0.Args[1] { 16825 break 16826 } 16827 if mem != x0.Args[2] { 16828 break 16829 } 16830 s0 := o0.Args[1] 16831 if s0.Op != Op386SHLLconst { 16832 break 16833 } 16834 if s0.AuxInt != 16 { 16835 break 16836 } 16837 x1 := s0.Args[0] 16838 if x1.Op != Op386MOVBloadidx1 { 16839 break 16840 } 16841 i2 := x1.AuxInt 16842 if x1.Aux != s { 16843 break 16844 } 16845 _ = x1.Args[2] 16846 if idx != x1.Args[0] { 16847 break 16848 } 16849 if p != x1.Args[1] { 16850 break 16851 } 16852 if mem != x1.Args[2] { 16853 break 16854 } 16855 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 16856 break 16857 } 16858 b = mergePoint(b, x0, x1, x2) 16859 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 16860 v.reset(OpCopy) 16861 v.AddArg(v0) 16862 v0.AuxInt = i0 16863 v0.Aux = s 16864 v0.AddArg(p) 16865 v0.AddArg(idx) 16866 v0.AddArg(mem) 16867 return true 16868 } 16869 // match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)))) 16870 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 16871 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 16872 for { 16873 _ = v.Args[1] 16874 s1 := v.Args[0] 16875 if s1.Op != Op386SHLLconst { 16876 break 16877 } 16878 if s1.AuxInt != 24 { 16879 break 16880 } 16881 x2 := s1.Args[0] 16882 if x2.Op != Op386MOVBloadidx1 { 16883 break 16884 } 16885 i3 := x2.AuxInt 16886 s := x2.Aux 16887 _ = x2.Args[2] 16888 p := x2.Args[0] 16889 idx := x2.Args[1] 16890 mem := x2.Args[2] 16891 o0 := v.Args[1] 16892 if o0.Op != Op386ORL { 16893 break 16894 } 16895 _ = o0.Args[1] 16896 x0 := o0.Args[0] 16897 if x0.Op != Op386MOVWloadidx1 { 16898 break 16899 } 16900 i0 := x0.AuxInt 16901 if x0.Aux != s { 16902 break 16903 } 16904 _ = x0.Args[2] 16905 if idx != x0.Args[0] { 16906 break 16907 } 16908 if p != x0.Args[1] { 16909 break 16910 } 16911 if mem != x0.Args[2] { 16912 break 16913 } 16914 s0 := o0.Args[1] 16915 if s0.Op != Op386SHLLconst { 16916 break 16917 } 16918 if s0.AuxInt != 16 { 16919 break 16920 } 16921 x1 := s0.Args[0] 16922 if x1.Op != Op386MOVBloadidx1 { 16923 break 16924 } 16925 i2 := x1.AuxInt 16926 if x1.Aux != s { 16927 break 16928 } 16929 _ = x1.Args[2] 16930 if idx != x1.Args[0] { 16931 break 16932 } 16933 if p != x1.Args[1] { 16934 break 16935 } 16936 if mem != x1.Args[2] { 16937 break 16938 } 16939 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 16940 break 16941 } 16942 b = mergePoint(b, x0, x1, x2) 16943 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 16944 v.reset(OpCopy) 16945 v.AddArg(v0) 16946 v0.AuxInt = i0 16947 v0.Aux = s 16948 v0.AddArg(p) 16949 v0.AddArg(idx) 16950 v0.AddArg(mem) 16951 return true 16952 } 16953 return false 16954 } 16955 func rewriteValue386_Op386ORL_50(v *Value) bool { 16956 b := v.Block 16957 _ = b 16958 // match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)))) 16959 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 16960 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 16961 for { 16962 _ = v.Args[1] 16963 s1 := v.Args[0] 16964 if s1.Op != Op386SHLLconst { 16965 break 16966 } 16967 if s1.AuxInt != 24 { 16968 break 16969 } 16970 x2 := s1.Args[0] 16971 if x2.Op != Op386MOVBloadidx1 { 16972 break 16973 } 16974 i3 := x2.AuxInt 16975 s := x2.Aux 16976 _ = x2.Args[2] 16977 idx := x2.Args[0] 16978 p := x2.Args[1] 16979 mem := x2.Args[2] 16980 o0 := v.Args[1] 16981 if o0.Op != Op386ORL { 16982 break 16983 } 16984 _ = o0.Args[1] 16985 x0 := o0.Args[0] 16986 if x0.Op != Op386MOVWloadidx1 { 16987 break 16988 } 16989 i0 := x0.AuxInt 16990 if x0.Aux != s { 16991 break 16992 } 16993 _ = x0.Args[2] 16994 if idx != x0.Args[0] { 16995 break 16996 } 16997 if p != x0.Args[1] { 16998 break 16999 } 17000 if mem != x0.Args[2] { 17001 break 17002 } 17003 s0 := o0.Args[1] 17004 if s0.Op != Op386SHLLconst { 17005 break 17006 } 17007 if s0.AuxInt != 16 { 17008 break 17009 } 17010 x1 := s0.Args[0] 17011 if x1.Op != Op386MOVBloadidx1 { 17012 break 17013 } 17014 i2 := x1.AuxInt 17015 if x1.Aux != s { 17016 break 17017 } 17018 _ = x1.Args[2] 17019 if idx != x1.Args[0] { 17020 break 17021 } 17022 if p != x1.Args[1] { 17023 break 17024 } 17025 if mem != x1.Args[2] { 17026 break 17027 } 17028 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 17029 break 17030 } 17031 b = mergePoint(b, x0, x1, x2) 17032 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 17033 v.reset(OpCopy) 17034 v.AddArg(v0) 17035 v0.AuxInt = i0 17036 v0.Aux = s 17037 v0.AddArg(p) 17038 v0.AddArg(idx) 17039 v0.AddArg(mem) 17040 return true 17041 } 17042 // match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem))) 17043 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 17044 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 17045 for { 17046 _ = v.Args[1] 17047 s1 := v.Args[0] 17048 if s1.Op != Op386SHLLconst { 17049 break 17050 } 17051 if s1.AuxInt != 24 { 17052 break 17053 } 17054 x2 := s1.Args[0] 17055 if x2.Op != Op386MOVBloadidx1 { 17056 break 17057 } 17058 i3 := x2.AuxInt 17059 s := x2.Aux 17060 _ = x2.Args[2] 17061 p := x2.Args[0] 17062 idx := x2.Args[1] 17063 mem := x2.Args[2] 17064 o0 := v.Args[1] 17065 if o0.Op != Op386ORL { 17066 break 17067 } 17068 _ = o0.Args[1] 17069 s0 := o0.Args[0] 17070 if s0.Op != Op386SHLLconst { 17071 break 17072 } 17073 if s0.AuxInt != 16 { 17074 break 17075 } 17076 x1 := s0.Args[0] 17077 if x1.Op != Op386MOVBloadidx1 { 17078 break 17079 } 17080 i2 := x1.AuxInt 17081 if x1.Aux != s { 17082 break 17083 } 17084 _ = x1.Args[2] 17085 if p != x1.Args[0] { 17086 break 17087 } 17088 if idx != x1.Args[1] { 17089 break 17090 } 17091 if mem != x1.Args[2] { 17092 break 17093 } 17094 x0 := o0.Args[1] 17095 if x0.Op != Op386MOVWloadidx1 { 17096 break 17097 } 17098 i0 := x0.AuxInt 17099 if x0.Aux != s { 17100 break 17101 } 17102 _ = x0.Args[2] 17103 if p != x0.Args[0] { 17104 break 17105 } 17106 if idx != x0.Args[1] { 17107 break 17108 } 17109 if mem != x0.Args[2] { 17110 break 17111 } 17112 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 17113 break 17114 } 17115 b = mergePoint(b, x0, x1, x2) 17116 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 17117 v.reset(OpCopy) 17118 v.AddArg(v0) 17119 v0.AuxInt = i0 17120 v0.Aux = s 17121 v0.AddArg(p) 17122 v0.AddArg(idx) 17123 v0.AddArg(mem) 17124 return true 17125 } 17126 // match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem))) 17127 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 17128 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 17129 for { 17130 _ = v.Args[1] 17131 s1 := v.Args[0] 17132 if s1.Op != Op386SHLLconst { 17133 break 17134 } 17135 if s1.AuxInt != 24 { 17136 break 17137 } 17138 x2 := s1.Args[0] 17139 if x2.Op != Op386MOVBloadidx1 { 17140 break 17141 } 17142 i3 := x2.AuxInt 17143 s := x2.Aux 17144 _ = x2.Args[2] 17145 idx := x2.Args[0] 17146 p := x2.Args[1] 17147 mem := x2.Args[2] 17148 o0 := v.Args[1] 17149 if o0.Op != Op386ORL { 17150 break 17151 } 17152 _ = o0.Args[1] 17153 s0 := o0.Args[0] 17154 if s0.Op != Op386SHLLconst { 17155 break 17156 } 17157 if s0.AuxInt != 16 { 17158 break 17159 } 17160 x1 := s0.Args[0] 17161 if x1.Op != Op386MOVBloadidx1 { 17162 break 17163 } 17164 i2 := x1.AuxInt 17165 if x1.Aux != s { 17166 break 17167 } 17168 _ = x1.Args[2] 17169 if p != x1.Args[0] { 17170 break 17171 } 17172 if idx != x1.Args[1] { 17173 break 17174 } 17175 if mem != x1.Args[2] { 17176 break 17177 } 17178 x0 := o0.Args[1] 17179 if x0.Op != Op386MOVWloadidx1 { 17180 break 17181 } 17182 i0 := x0.AuxInt 17183 if x0.Aux != s { 17184 break 17185 } 17186 _ = x0.Args[2] 17187 if p != x0.Args[0] { 17188 break 17189 } 17190 if idx != x0.Args[1] { 17191 break 17192 } 17193 if mem != x0.Args[2] { 17194 break 17195 } 17196 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 17197 break 17198 } 17199 b = mergePoint(b, x0, x1, x2) 17200 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 17201 v.reset(OpCopy) 17202 v.AddArg(v0) 17203 v0.AuxInt = i0 17204 v0.Aux = s 17205 v0.AddArg(p) 17206 v0.AddArg(idx) 17207 v0.AddArg(mem) 17208 return true 17209 } 17210 // match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem))) 17211 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 17212 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 17213 for { 17214 _ = v.Args[1] 17215 s1 := v.Args[0] 17216 if s1.Op != Op386SHLLconst { 17217 break 17218 } 17219 if s1.AuxInt != 24 { 17220 break 17221 } 17222 x2 := s1.Args[0] 17223 if x2.Op != Op386MOVBloadidx1 { 17224 break 17225 } 17226 i3 := x2.AuxInt 17227 s := x2.Aux 17228 _ = x2.Args[2] 17229 p := x2.Args[0] 17230 idx := x2.Args[1] 17231 mem := x2.Args[2] 17232 o0 := v.Args[1] 17233 if o0.Op != Op386ORL { 17234 break 17235 } 17236 _ = o0.Args[1] 17237 s0 := o0.Args[0] 17238 if s0.Op != Op386SHLLconst { 17239 break 17240 } 17241 if s0.AuxInt != 16 { 17242 break 17243 } 17244 x1 := s0.Args[0] 17245 if x1.Op != Op386MOVBloadidx1 { 17246 break 17247 } 17248 i2 := x1.AuxInt 17249 if x1.Aux != s { 17250 break 17251 } 17252 _ = x1.Args[2] 17253 if idx != x1.Args[0] { 17254 break 17255 } 17256 if p != x1.Args[1] { 17257 break 17258 } 17259 if mem != x1.Args[2] { 17260 break 17261 } 17262 x0 := o0.Args[1] 17263 if x0.Op != Op386MOVWloadidx1 { 17264 break 17265 } 17266 i0 := x0.AuxInt 17267 if x0.Aux != s { 17268 break 17269 } 17270 _ = x0.Args[2] 17271 if p != x0.Args[0] { 17272 break 17273 } 17274 if idx != x0.Args[1] { 17275 break 17276 } 17277 if mem != x0.Args[2] { 17278 break 17279 } 17280 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 17281 break 17282 } 17283 b = mergePoint(b, x0, x1, x2) 17284 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 17285 v.reset(OpCopy) 17286 v.AddArg(v0) 17287 v0.AuxInt = i0 17288 v0.Aux = s 17289 v0.AddArg(p) 17290 v0.AddArg(idx) 17291 v0.AddArg(mem) 17292 return true 17293 } 17294 // match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem))) 17295 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 17296 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 17297 for { 17298 _ = v.Args[1] 17299 s1 := v.Args[0] 17300 if s1.Op != Op386SHLLconst { 17301 break 17302 } 17303 if s1.AuxInt != 24 { 17304 break 17305 } 17306 x2 := s1.Args[0] 17307 if x2.Op != Op386MOVBloadidx1 { 17308 break 17309 } 17310 i3 := x2.AuxInt 17311 s := x2.Aux 17312 _ = x2.Args[2] 17313 idx := x2.Args[0] 17314 p := x2.Args[1] 17315 mem := x2.Args[2] 17316 o0 := v.Args[1] 17317 if o0.Op != Op386ORL { 17318 break 17319 } 17320 _ = o0.Args[1] 17321 s0 := o0.Args[0] 17322 if s0.Op != Op386SHLLconst { 17323 break 17324 } 17325 if s0.AuxInt != 16 { 17326 break 17327 } 17328 x1 := s0.Args[0] 17329 if x1.Op != Op386MOVBloadidx1 { 17330 break 17331 } 17332 i2 := x1.AuxInt 17333 if x1.Aux != s { 17334 break 17335 } 17336 _ = x1.Args[2] 17337 if idx != x1.Args[0] { 17338 break 17339 } 17340 if p != x1.Args[1] { 17341 break 17342 } 17343 if mem != x1.Args[2] { 17344 break 17345 } 17346 x0 := o0.Args[1] 17347 if x0.Op != Op386MOVWloadidx1 { 17348 break 17349 } 17350 i0 := x0.AuxInt 17351 if x0.Aux != s { 17352 break 17353 } 17354 _ = x0.Args[2] 17355 if p != x0.Args[0] { 17356 break 17357 } 17358 if idx != x0.Args[1] { 17359 break 17360 } 17361 if mem != x0.Args[2] { 17362 break 17363 } 17364 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 17365 break 17366 } 17367 b = mergePoint(b, x0, x1, x2) 17368 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 17369 v.reset(OpCopy) 17370 v.AddArg(v0) 17371 v0.AuxInt = i0 17372 v0.Aux = s 17373 v0.AddArg(p) 17374 v0.AddArg(idx) 17375 v0.AddArg(mem) 17376 return true 17377 } 17378 // match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem))) 17379 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 17380 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 17381 for { 17382 _ = v.Args[1] 17383 s1 := v.Args[0] 17384 if s1.Op != Op386SHLLconst { 17385 break 17386 } 17387 if s1.AuxInt != 24 { 17388 break 17389 } 17390 x2 := s1.Args[0] 17391 if x2.Op != Op386MOVBloadidx1 { 17392 break 17393 } 17394 i3 := x2.AuxInt 17395 s := x2.Aux 17396 _ = x2.Args[2] 17397 p := x2.Args[0] 17398 idx := x2.Args[1] 17399 mem := x2.Args[2] 17400 o0 := v.Args[1] 17401 if o0.Op != Op386ORL { 17402 break 17403 } 17404 _ = o0.Args[1] 17405 s0 := o0.Args[0] 17406 if s0.Op != Op386SHLLconst { 17407 break 17408 } 17409 if s0.AuxInt != 16 { 17410 break 17411 } 17412 x1 := s0.Args[0] 17413 if x1.Op != Op386MOVBloadidx1 { 17414 break 17415 } 17416 i2 := x1.AuxInt 17417 if x1.Aux != s { 17418 break 17419 } 17420 _ = x1.Args[2] 17421 if p != x1.Args[0] { 17422 break 17423 } 17424 if idx != x1.Args[1] { 17425 break 17426 } 17427 if mem != x1.Args[2] { 17428 break 17429 } 17430 x0 := o0.Args[1] 17431 if x0.Op != Op386MOVWloadidx1 { 17432 break 17433 } 17434 i0 := x0.AuxInt 17435 if x0.Aux != s { 17436 break 17437 } 17438 _ = x0.Args[2] 17439 if idx != x0.Args[0] { 17440 break 17441 } 17442 if p != x0.Args[1] { 17443 break 17444 } 17445 if mem != x0.Args[2] { 17446 break 17447 } 17448 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 17449 break 17450 } 17451 b = mergePoint(b, x0, x1, x2) 17452 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 17453 v.reset(OpCopy) 17454 v.AddArg(v0) 17455 v0.AuxInt = i0 17456 v0.Aux = s 17457 v0.AddArg(p) 17458 v0.AddArg(idx) 17459 v0.AddArg(mem) 17460 return true 17461 } 17462 // match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem))) 17463 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 17464 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 17465 for { 17466 _ = v.Args[1] 17467 s1 := v.Args[0] 17468 if s1.Op != Op386SHLLconst { 17469 break 17470 } 17471 if s1.AuxInt != 24 { 17472 break 17473 } 17474 x2 := s1.Args[0] 17475 if x2.Op != Op386MOVBloadidx1 { 17476 break 17477 } 17478 i3 := x2.AuxInt 17479 s := x2.Aux 17480 _ = x2.Args[2] 17481 idx := x2.Args[0] 17482 p := x2.Args[1] 17483 mem := x2.Args[2] 17484 o0 := v.Args[1] 17485 if o0.Op != Op386ORL { 17486 break 17487 } 17488 _ = o0.Args[1] 17489 s0 := o0.Args[0] 17490 if s0.Op != Op386SHLLconst { 17491 break 17492 } 17493 if s0.AuxInt != 16 { 17494 break 17495 } 17496 x1 := s0.Args[0] 17497 if x1.Op != Op386MOVBloadidx1 { 17498 break 17499 } 17500 i2 := x1.AuxInt 17501 if x1.Aux != s { 17502 break 17503 } 17504 _ = x1.Args[2] 17505 if p != x1.Args[0] { 17506 break 17507 } 17508 if idx != x1.Args[1] { 17509 break 17510 } 17511 if mem != x1.Args[2] { 17512 break 17513 } 17514 x0 := o0.Args[1] 17515 if x0.Op != Op386MOVWloadidx1 { 17516 break 17517 } 17518 i0 := x0.AuxInt 17519 if x0.Aux != s { 17520 break 17521 } 17522 _ = x0.Args[2] 17523 if idx != x0.Args[0] { 17524 break 17525 } 17526 if p != x0.Args[1] { 17527 break 17528 } 17529 if mem != x0.Args[2] { 17530 break 17531 } 17532 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 17533 break 17534 } 17535 b = mergePoint(b, x0, x1, x2) 17536 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 17537 v.reset(OpCopy) 17538 v.AddArg(v0) 17539 v0.AuxInt = i0 17540 v0.Aux = s 17541 v0.AddArg(p) 17542 v0.AddArg(idx) 17543 v0.AddArg(mem) 17544 return true 17545 } 17546 // match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem))) 17547 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 17548 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 17549 for { 17550 _ = v.Args[1] 17551 s1 := v.Args[0] 17552 if s1.Op != Op386SHLLconst { 17553 break 17554 } 17555 if s1.AuxInt != 24 { 17556 break 17557 } 17558 x2 := s1.Args[0] 17559 if x2.Op != Op386MOVBloadidx1 { 17560 break 17561 } 17562 i3 := x2.AuxInt 17563 s := x2.Aux 17564 _ = x2.Args[2] 17565 p := x2.Args[0] 17566 idx := x2.Args[1] 17567 mem := x2.Args[2] 17568 o0 := v.Args[1] 17569 if o0.Op != Op386ORL { 17570 break 17571 } 17572 _ = o0.Args[1] 17573 s0 := o0.Args[0] 17574 if s0.Op != Op386SHLLconst { 17575 break 17576 } 17577 if s0.AuxInt != 16 { 17578 break 17579 } 17580 x1 := s0.Args[0] 17581 if x1.Op != Op386MOVBloadidx1 { 17582 break 17583 } 17584 i2 := x1.AuxInt 17585 if x1.Aux != s { 17586 break 17587 } 17588 _ = x1.Args[2] 17589 if idx != x1.Args[0] { 17590 break 17591 } 17592 if p != x1.Args[1] { 17593 break 17594 } 17595 if mem != x1.Args[2] { 17596 break 17597 } 17598 x0 := o0.Args[1] 17599 if x0.Op != Op386MOVWloadidx1 { 17600 break 17601 } 17602 i0 := x0.AuxInt 17603 if x0.Aux != s { 17604 break 17605 } 17606 _ = x0.Args[2] 17607 if idx != x0.Args[0] { 17608 break 17609 } 17610 if p != x0.Args[1] { 17611 break 17612 } 17613 if mem != x0.Args[2] { 17614 break 17615 } 17616 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 17617 break 17618 } 17619 b = mergePoint(b, x0, x1, x2) 17620 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 17621 v.reset(OpCopy) 17622 v.AddArg(v0) 17623 v0.AuxInt = i0 17624 v0.Aux = s 17625 v0.AddArg(p) 17626 v0.AddArg(idx) 17627 v0.AddArg(mem) 17628 return true 17629 } 17630 // match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem))) 17631 // cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0) 17632 // result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem) 17633 for { 17634 _ = v.Args[1] 17635 s1 := v.Args[0] 17636 if s1.Op != Op386SHLLconst { 17637 break 17638 } 17639 if s1.AuxInt != 24 { 17640 break 17641 } 17642 x2 := s1.Args[0] 17643 if x2.Op != Op386MOVBloadidx1 { 17644 break 17645 } 17646 i3 := x2.AuxInt 17647 s := x2.Aux 17648 _ = x2.Args[2] 17649 idx := x2.Args[0] 17650 p := x2.Args[1] 17651 mem := x2.Args[2] 17652 o0 := v.Args[1] 17653 if o0.Op != Op386ORL { 17654 break 17655 } 17656 _ = o0.Args[1] 17657 s0 := o0.Args[0] 17658 if s0.Op != Op386SHLLconst { 17659 break 17660 } 17661 if s0.AuxInt != 16 { 17662 break 17663 } 17664 x1 := s0.Args[0] 17665 if x1.Op != Op386MOVBloadidx1 { 17666 break 17667 } 17668 i2 := x1.AuxInt 17669 if x1.Aux != s { 17670 break 17671 } 17672 _ = x1.Args[2] 17673 if idx != x1.Args[0] { 17674 break 17675 } 17676 if p != x1.Args[1] { 17677 break 17678 } 17679 if mem != x1.Args[2] { 17680 break 17681 } 17682 x0 := o0.Args[1] 17683 if x0.Op != Op386MOVWloadidx1 { 17684 break 17685 } 17686 i0 := x0.AuxInt 17687 if x0.Aux != s { 17688 break 17689 } 17690 _ = x0.Args[2] 17691 if idx != x0.Args[0] { 17692 break 17693 } 17694 if p != x0.Args[1] { 17695 break 17696 } 17697 if mem != x0.Args[2] { 17698 break 17699 } 17700 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) { 17701 break 17702 } 17703 b = mergePoint(b, x0, x1, x2) 17704 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type) 17705 v.reset(OpCopy) 17706 v.AddArg(v0) 17707 v0.AuxInt = i0 17708 v0.Aux = s 17709 v0.AddArg(p) 17710 v0.AddArg(idx) 17711 v0.AddArg(mem) 17712 return true 17713 } 17714 return false 17715 } 17716 func rewriteValue386_Op386ORLconst_0(v *Value) bool { 17717 // match: (ORLconst [c] x) 17718 // cond: int32(c)==0 17719 // result: x 17720 for { 17721 c := v.AuxInt 17722 x := v.Args[0] 17723 if !(int32(c) == 0) { 17724 break 17725 } 17726 v.reset(OpCopy) 17727 v.Type = x.Type 17728 v.AddArg(x) 17729 return true 17730 } 17731 // match: (ORLconst [c] _) 17732 // cond: int32(c)==-1 17733 // result: (MOVLconst [-1]) 17734 for { 17735 c := v.AuxInt 17736 if !(int32(c) == -1) { 17737 break 17738 } 17739 v.reset(Op386MOVLconst) 17740 v.AuxInt = -1 17741 return true 17742 } 17743 // match: (ORLconst [c] (MOVLconst [d])) 17744 // cond: 17745 // result: (MOVLconst [c|d]) 17746 for { 17747 c := v.AuxInt 17748 v_0 := v.Args[0] 17749 if v_0.Op != Op386MOVLconst { 17750 break 17751 } 17752 d := v_0.AuxInt 17753 v.reset(Op386MOVLconst) 17754 v.AuxInt = c | d 17755 return true 17756 } 17757 return false 17758 } 17759 func rewriteValue386_Op386ORLconstmodify_0(v *Value) bool { 17760 b := v.Block 17761 _ = b 17762 config := b.Func.Config 17763 _ = config 17764 // match: (ORLconstmodify [valoff1] {sym} (ADDLconst [off2] base) mem) 17765 // cond: ValAndOff(valoff1).canAdd(off2) 17766 // result: (ORLconstmodify [ValAndOff(valoff1).add(off2)] {sym} base mem) 17767 for { 17768 valoff1 := v.AuxInt 17769 sym := v.Aux 17770 _ = v.Args[1] 17771 v_0 := v.Args[0] 17772 if v_0.Op != Op386ADDLconst { 17773 break 17774 } 17775 off2 := v_0.AuxInt 17776 base := v_0.Args[0] 17777 mem := v.Args[1] 17778 if !(ValAndOff(valoff1).canAdd(off2)) { 17779 break 17780 } 17781 v.reset(Op386ORLconstmodify) 17782 v.AuxInt = ValAndOff(valoff1).add(off2) 17783 v.Aux = sym 17784 v.AddArg(base) 17785 v.AddArg(mem) 17786 return true 17787 } 17788 // match: (ORLconstmodify [valoff1] {sym1} (LEAL [off2] {sym2} base) mem) 17789 // cond: ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 17790 // result: (ORLconstmodify [ValAndOff(valoff1).add(off2)] {mergeSym(sym1,sym2)} base mem) 17791 for { 17792 valoff1 := v.AuxInt 17793 sym1 := v.Aux 17794 _ = v.Args[1] 17795 v_0 := v.Args[0] 17796 if v_0.Op != Op386LEAL { 17797 break 17798 } 17799 off2 := v_0.AuxInt 17800 sym2 := v_0.Aux 17801 base := v_0.Args[0] 17802 mem := v.Args[1] 17803 if !(ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 17804 break 17805 } 17806 v.reset(Op386ORLconstmodify) 17807 v.AuxInt = ValAndOff(valoff1).add(off2) 17808 v.Aux = mergeSym(sym1, sym2) 17809 v.AddArg(base) 17810 v.AddArg(mem) 17811 return true 17812 } 17813 return false 17814 } 17815 func rewriteValue386_Op386ORLconstmodifyidx4_0(v *Value) bool { 17816 b := v.Block 17817 _ = b 17818 config := b.Func.Config 17819 _ = config 17820 // match: (ORLconstmodifyidx4 [valoff1] {sym} (ADDLconst [off2] base) idx mem) 17821 // cond: ValAndOff(valoff1).canAdd(off2) 17822 // result: (ORLconstmodifyidx4 [ValAndOff(valoff1).add(off2)] {sym} base idx mem) 17823 for { 17824 valoff1 := v.AuxInt 17825 sym := v.Aux 17826 _ = v.Args[2] 17827 v_0 := v.Args[0] 17828 if v_0.Op != Op386ADDLconst { 17829 break 17830 } 17831 off2 := v_0.AuxInt 17832 base := v_0.Args[0] 17833 idx := v.Args[1] 17834 mem := v.Args[2] 17835 if !(ValAndOff(valoff1).canAdd(off2)) { 17836 break 17837 } 17838 v.reset(Op386ORLconstmodifyidx4) 17839 v.AuxInt = ValAndOff(valoff1).add(off2) 17840 v.Aux = sym 17841 v.AddArg(base) 17842 v.AddArg(idx) 17843 v.AddArg(mem) 17844 return true 17845 } 17846 // match: (ORLconstmodifyidx4 [valoff1] {sym} base (ADDLconst [off2] idx) mem) 17847 // cond: ValAndOff(valoff1).canAdd(off2*4) 17848 // result: (ORLconstmodifyidx4 [ValAndOff(valoff1).add(off2*4)] {sym} base idx mem) 17849 for { 17850 valoff1 := v.AuxInt 17851 sym := v.Aux 17852 _ = v.Args[2] 17853 base := v.Args[0] 17854 v_1 := v.Args[1] 17855 if v_1.Op != Op386ADDLconst { 17856 break 17857 } 17858 off2 := v_1.AuxInt 17859 idx := v_1.Args[0] 17860 mem := v.Args[2] 17861 if !(ValAndOff(valoff1).canAdd(off2 * 4)) { 17862 break 17863 } 17864 v.reset(Op386ORLconstmodifyidx4) 17865 v.AuxInt = ValAndOff(valoff1).add(off2 * 4) 17866 v.Aux = sym 17867 v.AddArg(base) 17868 v.AddArg(idx) 17869 v.AddArg(mem) 17870 return true 17871 } 17872 // match: (ORLconstmodifyidx4 [valoff1] {sym1} (LEAL [off2] {sym2} base) idx mem) 17873 // cond: ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 17874 // result: (ORLconstmodifyidx4 [ValAndOff(valoff1).add(off2)] {mergeSym(sym1,sym2)} base idx mem) 17875 for { 17876 valoff1 := v.AuxInt 17877 sym1 := v.Aux 17878 _ = v.Args[2] 17879 v_0 := v.Args[0] 17880 if v_0.Op != Op386LEAL { 17881 break 17882 } 17883 off2 := v_0.AuxInt 17884 sym2 := v_0.Aux 17885 base := v_0.Args[0] 17886 idx := v.Args[1] 17887 mem := v.Args[2] 17888 if !(ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 17889 break 17890 } 17891 v.reset(Op386ORLconstmodifyidx4) 17892 v.AuxInt = ValAndOff(valoff1).add(off2) 17893 v.Aux = mergeSym(sym1, sym2) 17894 v.AddArg(base) 17895 v.AddArg(idx) 17896 v.AddArg(mem) 17897 return true 17898 } 17899 return false 17900 } 17901 func rewriteValue386_Op386ORLload_0(v *Value) bool { 17902 b := v.Block 17903 _ = b 17904 config := b.Func.Config 17905 _ = config 17906 // match: (ORLload [off1] {sym} val (ADDLconst [off2] base) mem) 17907 // cond: is32Bit(off1+off2) 17908 // result: (ORLload [off1+off2] {sym} val base mem) 17909 for { 17910 off1 := v.AuxInt 17911 sym := v.Aux 17912 _ = v.Args[2] 17913 val := v.Args[0] 17914 v_1 := v.Args[1] 17915 if v_1.Op != Op386ADDLconst { 17916 break 17917 } 17918 off2 := v_1.AuxInt 17919 base := v_1.Args[0] 17920 mem := v.Args[2] 17921 if !(is32Bit(off1 + off2)) { 17922 break 17923 } 17924 v.reset(Op386ORLload) 17925 v.AuxInt = off1 + off2 17926 v.Aux = sym 17927 v.AddArg(val) 17928 v.AddArg(base) 17929 v.AddArg(mem) 17930 return true 17931 } 17932 // match: (ORLload [off1] {sym1} val (LEAL [off2] {sym2} base) mem) 17933 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 17934 // result: (ORLload [off1+off2] {mergeSym(sym1,sym2)} val base mem) 17935 for { 17936 off1 := v.AuxInt 17937 sym1 := v.Aux 17938 _ = v.Args[2] 17939 val := v.Args[0] 17940 v_1 := v.Args[1] 17941 if v_1.Op != Op386LEAL { 17942 break 17943 } 17944 off2 := v_1.AuxInt 17945 sym2 := v_1.Aux 17946 base := v_1.Args[0] 17947 mem := v.Args[2] 17948 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 17949 break 17950 } 17951 v.reset(Op386ORLload) 17952 v.AuxInt = off1 + off2 17953 v.Aux = mergeSym(sym1, sym2) 17954 v.AddArg(val) 17955 v.AddArg(base) 17956 v.AddArg(mem) 17957 return true 17958 } 17959 // match: (ORLload [off1] {sym1} val (LEAL4 [off2] {sym2} ptr idx) mem) 17960 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 17961 // result: (ORLloadidx4 [off1+off2] {mergeSym(sym1,sym2)} val ptr idx mem) 17962 for { 17963 off1 := v.AuxInt 17964 sym1 := v.Aux 17965 _ = v.Args[2] 17966 val := v.Args[0] 17967 v_1 := v.Args[1] 17968 if v_1.Op != Op386LEAL4 { 17969 break 17970 } 17971 off2 := v_1.AuxInt 17972 sym2 := v_1.Aux 17973 _ = v_1.Args[1] 17974 ptr := v_1.Args[0] 17975 idx := v_1.Args[1] 17976 mem := v.Args[2] 17977 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 17978 break 17979 } 17980 v.reset(Op386ORLloadidx4) 17981 v.AuxInt = off1 + off2 17982 v.Aux = mergeSym(sym1, sym2) 17983 v.AddArg(val) 17984 v.AddArg(ptr) 17985 v.AddArg(idx) 17986 v.AddArg(mem) 17987 return true 17988 } 17989 return false 17990 } 17991 func rewriteValue386_Op386ORLloadidx4_0(v *Value) bool { 17992 b := v.Block 17993 _ = b 17994 config := b.Func.Config 17995 _ = config 17996 // match: (ORLloadidx4 [off1] {sym} val (ADDLconst [off2] base) idx mem) 17997 // cond: is32Bit(off1+off2) 17998 // result: (ORLloadidx4 [off1+off2] {sym} val base idx mem) 17999 for { 18000 off1 := v.AuxInt 18001 sym := v.Aux 18002 _ = v.Args[3] 18003 val := v.Args[0] 18004 v_1 := v.Args[1] 18005 if v_1.Op != Op386ADDLconst { 18006 break 18007 } 18008 off2 := v_1.AuxInt 18009 base := v_1.Args[0] 18010 idx := v.Args[2] 18011 mem := v.Args[3] 18012 if !(is32Bit(off1 + off2)) { 18013 break 18014 } 18015 v.reset(Op386ORLloadidx4) 18016 v.AuxInt = off1 + off2 18017 v.Aux = sym 18018 v.AddArg(val) 18019 v.AddArg(base) 18020 v.AddArg(idx) 18021 v.AddArg(mem) 18022 return true 18023 } 18024 // match: (ORLloadidx4 [off1] {sym} val base (ADDLconst [off2] idx) mem) 18025 // cond: is32Bit(off1+off2*4) 18026 // result: (ORLloadidx4 [off1+off2*4] {sym} val base idx mem) 18027 for { 18028 off1 := v.AuxInt 18029 sym := v.Aux 18030 _ = v.Args[3] 18031 val := v.Args[0] 18032 base := v.Args[1] 18033 v_2 := v.Args[2] 18034 if v_2.Op != Op386ADDLconst { 18035 break 18036 } 18037 off2 := v_2.AuxInt 18038 idx := v_2.Args[0] 18039 mem := v.Args[3] 18040 if !(is32Bit(off1 + off2*4)) { 18041 break 18042 } 18043 v.reset(Op386ORLloadidx4) 18044 v.AuxInt = off1 + off2*4 18045 v.Aux = sym 18046 v.AddArg(val) 18047 v.AddArg(base) 18048 v.AddArg(idx) 18049 v.AddArg(mem) 18050 return true 18051 } 18052 // match: (ORLloadidx4 [off1] {sym1} val (LEAL [off2] {sym2} base) idx mem) 18053 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 18054 // result: (ORLloadidx4 [off1+off2] {mergeSym(sym1,sym2)} val base idx mem) 18055 for { 18056 off1 := v.AuxInt 18057 sym1 := v.Aux 18058 _ = v.Args[3] 18059 val := v.Args[0] 18060 v_1 := v.Args[1] 18061 if v_1.Op != Op386LEAL { 18062 break 18063 } 18064 off2 := v_1.AuxInt 18065 sym2 := v_1.Aux 18066 base := v_1.Args[0] 18067 idx := v.Args[2] 18068 mem := v.Args[3] 18069 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 18070 break 18071 } 18072 v.reset(Op386ORLloadidx4) 18073 v.AuxInt = off1 + off2 18074 v.Aux = mergeSym(sym1, sym2) 18075 v.AddArg(val) 18076 v.AddArg(base) 18077 v.AddArg(idx) 18078 v.AddArg(mem) 18079 return true 18080 } 18081 return false 18082 } 18083 func rewriteValue386_Op386ORLmodify_0(v *Value) bool { 18084 b := v.Block 18085 _ = b 18086 config := b.Func.Config 18087 _ = config 18088 // match: (ORLmodify [off1] {sym} (ADDLconst [off2] base) val mem) 18089 // cond: is32Bit(off1+off2) 18090 // result: (ORLmodify [off1+off2] {sym} base val mem) 18091 for { 18092 off1 := v.AuxInt 18093 sym := v.Aux 18094 _ = v.Args[2] 18095 v_0 := v.Args[0] 18096 if v_0.Op != Op386ADDLconst { 18097 break 18098 } 18099 off2 := v_0.AuxInt 18100 base := v_0.Args[0] 18101 val := v.Args[1] 18102 mem := v.Args[2] 18103 if !(is32Bit(off1 + off2)) { 18104 break 18105 } 18106 v.reset(Op386ORLmodify) 18107 v.AuxInt = off1 + off2 18108 v.Aux = sym 18109 v.AddArg(base) 18110 v.AddArg(val) 18111 v.AddArg(mem) 18112 return true 18113 } 18114 // match: (ORLmodify [off1] {sym1} (LEAL [off2] {sym2} base) val mem) 18115 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 18116 // result: (ORLmodify [off1+off2] {mergeSym(sym1,sym2)} base val mem) 18117 for { 18118 off1 := v.AuxInt 18119 sym1 := v.Aux 18120 _ = v.Args[2] 18121 v_0 := v.Args[0] 18122 if v_0.Op != Op386LEAL { 18123 break 18124 } 18125 off2 := v_0.AuxInt 18126 sym2 := v_0.Aux 18127 base := v_0.Args[0] 18128 val := v.Args[1] 18129 mem := v.Args[2] 18130 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 18131 break 18132 } 18133 v.reset(Op386ORLmodify) 18134 v.AuxInt = off1 + off2 18135 v.Aux = mergeSym(sym1, sym2) 18136 v.AddArg(base) 18137 v.AddArg(val) 18138 v.AddArg(mem) 18139 return true 18140 } 18141 return false 18142 } 18143 func rewriteValue386_Op386ORLmodifyidx4_0(v *Value) bool { 18144 b := v.Block 18145 _ = b 18146 config := b.Func.Config 18147 _ = config 18148 // match: (ORLmodifyidx4 [off1] {sym} (ADDLconst [off2] base) idx val mem) 18149 // cond: is32Bit(off1+off2) 18150 // result: (ORLmodifyidx4 [off1+off2] {sym} base idx val mem) 18151 for { 18152 off1 := v.AuxInt 18153 sym := v.Aux 18154 _ = v.Args[3] 18155 v_0 := v.Args[0] 18156 if v_0.Op != Op386ADDLconst { 18157 break 18158 } 18159 off2 := v_0.AuxInt 18160 base := v_0.Args[0] 18161 idx := v.Args[1] 18162 val := v.Args[2] 18163 mem := v.Args[3] 18164 if !(is32Bit(off1 + off2)) { 18165 break 18166 } 18167 v.reset(Op386ORLmodifyidx4) 18168 v.AuxInt = off1 + off2 18169 v.Aux = sym 18170 v.AddArg(base) 18171 v.AddArg(idx) 18172 v.AddArg(val) 18173 v.AddArg(mem) 18174 return true 18175 } 18176 // match: (ORLmodifyidx4 [off1] {sym} base (ADDLconst [off2] idx) val mem) 18177 // cond: is32Bit(off1+off2*4) 18178 // result: (ORLmodifyidx4 [off1+off2*4] {sym} base idx val mem) 18179 for { 18180 off1 := v.AuxInt 18181 sym := v.Aux 18182 _ = v.Args[3] 18183 base := v.Args[0] 18184 v_1 := v.Args[1] 18185 if v_1.Op != Op386ADDLconst { 18186 break 18187 } 18188 off2 := v_1.AuxInt 18189 idx := v_1.Args[0] 18190 val := v.Args[2] 18191 mem := v.Args[3] 18192 if !(is32Bit(off1 + off2*4)) { 18193 break 18194 } 18195 v.reset(Op386ORLmodifyidx4) 18196 v.AuxInt = off1 + off2*4 18197 v.Aux = sym 18198 v.AddArg(base) 18199 v.AddArg(idx) 18200 v.AddArg(val) 18201 v.AddArg(mem) 18202 return true 18203 } 18204 // match: (ORLmodifyidx4 [off1] {sym1} (LEAL [off2] {sym2} base) idx val mem) 18205 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 18206 // result: (ORLmodifyidx4 [off1+off2] {mergeSym(sym1,sym2)} base idx val mem) 18207 for { 18208 off1 := v.AuxInt 18209 sym1 := v.Aux 18210 _ = v.Args[3] 18211 v_0 := v.Args[0] 18212 if v_0.Op != Op386LEAL { 18213 break 18214 } 18215 off2 := v_0.AuxInt 18216 sym2 := v_0.Aux 18217 base := v_0.Args[0] 18218 idx := v.Args[1] 18219 val := v.Args[2] 18220 mem := v.Args[3] 18221 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 18222 break 18223 } 18224 v.reset(Op386ORLmodifyidx4) 18225 v.AuxInt = off1 + off2 18226 v.Aux = mergeSym(sym1, sym2) 18227 v.AddArg(base) 18228 v.AddArg(idx) 18229 v.AddArg(val) 18230 v.AddArg(mem) 18231 return true 18232 } 18233 // match: (ORLmodifyidx4 [off] {sym} ptr idx (MOVLconst [c]) mem) 18234 // cond: validValAndOff(c,off) 18235 // result: (ORLconstmodifyidx4 [makeValAndOff(c,off)] {sym} ptr idx mem) 18236 for { 18237 off := v.AuxInt 18238 sym := v.Aux 18239 _ = v.Args[3] 18240 ptr := v.Args[0] 18241 idx := v.Args[1] 18242 v_2 := v.Args[2] 18243 if v_2.Op != Op386MOVLconst { 18244 break 18245 } 18246 c := v_2.AuxInt 18247 mem := v.Args[3] 18248 if !(validValAndOff(c, off)) { 18249 break 18250 } 18251 v.reset(Op386ORLconstmodifyidx4) 18252 v.AuxInt = makeValAndOff(c, off) 18253 v.Aux = sym 18254 v.AddArg(ptr) 18255 v.AddArg(idx) 18256 v.AddArg(mem) 18257 return true 18258 } 18259 return false 18260 } 18261 func rewriteValue386_Op386ROLBconst_0(v *Value) bool { 18262 // match: (ROLBconst [c] (ROLBconst [d] x)) 18263 // cond: 18264 // result: (ROLBconst [(c+d)& 7] x) 18265 for { 18266 c := v.AuxInt 18267 v_0 := v.Args[0] 18268 if v_0.Op != Op386ROLBconst { 18269 break 18270 } 18271 d := v_0.AuxInt 18272 x := v_0.Args[0] 18273 v.reset(Op386ROLBconst) 18274 v.AuxInt = (c + d) & 7 18275 v.AddArg(x) 18276 return true 18277 } 18278 // match: (ROLBconst [0] x) 18279 // cond: 18280 // result: x 18281 for { 18282 if v.AuxInt != 0 { 18283 break 18284 } 18285 x := v.Args[0] 18286 v.reset(OpCopy) 18287 v.Type = x.Type 18288 v.AddArg(x) 18289 return true 18290 } 18291 return false 18292 } 18293 func rewriteValue386_Op386ROLLconst_0(v *Value) bool { 18294 // match: (ROLLconst [c] (ROLLconst [d] x)) 18295 // cond: 18296 // result: (ROLLconst [(c+d)&31] x) 18297 for { 18298 c := v.AuxInt 18299 v_0 := v.Args[0] 18300 if v_0.Op != Op386ROLLconst { 18301 break 18302 } 18303 d := v_0.AuxInt 18304 x := v_0.Args[0] 18305 v.reset(Op386ROLLconst) 18306 v.AuxInt = (c + d) & 31 18307 v.AddArg(x) 18308 return true 18309 } 18310 // match: (ROLLconst [0] x) 18311 // cond: 18312 // result: x 18313 for { 18314 if v.AuxInt != 0 { 18315 break 18316 } 18317 x := v.Args[0] 18318 v.reset(OpCopy) 18319 v.Type = x.Type 18320 v.AddArg(x) 18321 return true 18322 } 18323 return false 18324 } 18325 func rewriteValue386_Op386ROLWconst_0(v *Value) bool { 18326 // match: (ROLWconst [c] (ROLWconst [d] x)) 18327 // cond: 18328 // result: (ROLWconst [(c+d)&15] x) 18329 for { 18330 c := v.AuxInt 18331 v_0 := v.Args[0] 18332 if v_0.Op != Op386ROLWconst { 18333 break 18334 } 18335 d := v_0.AuxInt 18336 x := v_0.Args[0] 18337 v.reset(Op386ROLWconst) 18338 v.AuxInt = (c + d) & 15 18339 v.AddArg(x) 18340 return true 18341 } 18342 // match: (ROLWconst [0] x) 18343 // cond: 18344 // result: x 18345 for { 18346 if v.AuxInt != 0 { 18347 break 18348 } 18349 x := v.Args[0] 18350 v.reset(OpCopy) 18351 v.Type = x.Type 18352 v.AddArg(x) 18353 return true 18354 } 18355 return false 18356 } 18357 func rewriteValue386_Op386SARB_0(v *Value) bool { 18358 // match: (SARB x (MOVLconst [c])) 18359 // cond: 18360 // result: (SARBconst [min(c&31,7)] x) 18361 for { 18362 _ = v.Args[1] 18363 x := v.Args[0] 18364 v_1 := v.Args[1] 18365 if v_1.Op != Op386MOVLconst { 18366 break 18367 } 18368 c := v_1.AuxInt 18369 v.reset(Op386SARBconst) 18370 v.AuxInt = min(c&31, 7) 18371 v.AddArg(x) 18372 return true 18373 } 18374 return false 18375 } 18376 func rewriteValue386_Op386SARBconst_0(v *Value) bool { 18377 // match: (SARBconst x [0]) 18378 // cond: 18379 // result: x 18380 for { 18381 if v.AuxInt != 0 { 18382 break 18383 } 18384 x := v.Args[0] 18385 v.reset(OpCopy) 18386 v.Type = x.Type 18387 v.AddArg(x) 18388 return true 18389 } 18390 // match: (SARBconst [c] (MOVLconst [d])) 18391 // cond: 18392 // result: (MOVLconst [d>>uint64(c)]) 18393 for { 18394 c := v.AuxInt 18395 v_0 := v.Args[0] 18396 if v_0.Op != Op386MOVLconst { 18397 break 18398 } 18399 d := v_0.AuxInt 18400 v.reset(Op386MOVLconst) 18401 v.AuxInt = d >> uint64(c) 18402 return true 18403 } 18404 return false 18405 } 18406 func rewriteValue386_Op386SARL_0(v *Value) bool { 18407 // match: (SARL x (MOVLconst [c])) 18408 // cond: 18409 // result: (SARLconst [c&31] x) 18410 for { 18411 _ = v.Args[1] 18412 x := v.Args[0] 18413 v_1 := v.Args[1] 18414 if v_1.Op != Op386MOVLconst { 18415 break 18416 } 18417 c := v_1.AuxInt 18418 v.reset(Op386SARLconst) 18419 v.AuxInt = c & 31 18420 v.AddArg(x) 18421 return true 18422 } 18423 // match: (SARL x (ANDLconst [31] y)) 18424 // cond: 18425 // result: (SARL x y) 18426 for { 18427 _ = v.Args[1] 18428 x := v.Args[0] 18429 v_1 := v.Args[1] 18430 if v_1.Op != Op386ANDLconst { 18431 break 18432 } 18433 if v_1.AuxInt != 31 { 18434 break 18435 } 18436 y := v_1.Args[0] 18437 v.reset(Op386SARL) 18438 v.AddArg(x) 18439 v.AddArg(y) 18440 return true 18441 } 18442 return false 18443 } 18444 func rewriteValue386_Op386SARLconst_0(v *Value) bool { 18445 // match: (SARLconst x [0]) 18446 // cond: 18447 // result: x 18448 for { 18449 if v.AuxInt != 0 { 18450 break 18451 } 18452 x := v.Args[0] 18453 v.reset(OpCopy) 18454 v.Type = x.Type 18455 v.AddArg(x) 18456 return true 18457 } 18458 // match: (SARLconst [c] (MOVLconst [d])) 18459 // cond: 18460 // result: (MOVLconst [d>>uint64(c)]) 18461 for { 18462 c := v.AuxInt 18463 v_0 := v.Args[0] 18464 if v_0.Op != Op386MOVLconst { 18465 break 18466 } 18467 d := v_0.AuxInt 18468 v.reset(Op386MOVLconst) 18469 v.AuxInt = d >> uint64(c) 18470 return true 18471 } 18472 return false 18473 } 18474 func rewriteValue386_Op386SARW_0(v *Value) bool { 18475 // match: (SARW x (MOVLconst [c])) 18476 // cond: 18477 // result: (SARWconst [min(c&31,15)] x) 18478 for { 18479 _ = v.Args[1] 18480 x := v.Args[0] 18481 v_1 := v.Args[1] 18482 if v_1.Op != Op386MOVLconst { 18483 break 18484 } 18485 c := v_1.AuxInt 18486 v.reset(Op386SARWconst) 18487 v.AuxInt = min(c&31, 15) 18488 v.AddArg(x) 18489 return true 18490 } 18491 return false 18492 } 18493 func rewriteValue386_Op386SARWconst_0(v *Value) bool { 18494 // match: (SARWconst x [0]) 18495 // cond: 18496 // result: x 18497 for { 18498 if v.AuxInt != 0 { 18499 break 18500 } 18501 x := v.Args[0] 18502 v.reset(OpCopy) 18503 v.Type = x.Type 18504 v.AddArg(x) 18505 return true 18506 } 18507 // match: (SARWconst [c] (MOVLconst [d])) 18508 // cond: 18509 // result: (MOVLconst [d>>uint64(c)]) 18510 for { 18511 c := v.AuxInt 18512 v_0 := v.Args[0] 18513 if v_0.Op != Op386MOVLconst { 18514 break 18515 } 18516 d := v_0.AuxInt 18517 v.reset(Op386MOVLconst) 18518 v.AuxInt = d >> uint64(c) 18519 return true 18520 } 18521 return false 18522 } 18523 func rewriteValue386_Op386SBBL_0(v *Value) bool { 18524 // match: (SBBL x (MOVLconst [c]) f) 18525 // cond: 18526 // result: (SBBLconst [c] x f) 18527 for { 18528 _ = v.Args[2] 18529 x := v.Args[0] 18530 v_1 := v.Args[1] 18531 if v_1.Op != Op386MOVLconst { 18532 break 18533 } 18534 c := v_1.AuxInt 18535 f := v.Args[2] 18536 v.reset(Op386SBBLconst) 18537 v.AuxInt = c 18538 v.AddArg(x) 18539 v.AddArg(f) 18540 return true 18541 } 18542 return false 18543 } 18544 func rewriteValue386_Op386SBBLcarrymask_0(v *Value) bool { 18545 // match: (SBBLcarrymask (FlagEQ)) 18546 // cond: 18547 // result: (MOVLconst [0]) 18548 for { 18549 v_0 := v.Args[0] 18550 if v_0.Op != Op386FlagEQ { 18551 break 18552 } 18553 v.reset(Op386MOVLconst) 18554 v.AuxInt = 0 18555 return true 18556 } 18557 // match: (SBBLcarrymask (FlagLT_ULT)) 18558 // cond: 18559 // result: (MOVLconst [-1]) 18560 for { 18561 v_0 := v.Args[0] 18562 if v_0.Op != Op386FlagLT_ULT { 18563 break 18564 } 18565 v.reset(Op386MOVLconst) 18566 v.AuxInt = -1 18567 return true 18568 } 18569 // match: (SBBLcarrymask (FlagLT_UGT)) 18570 // cond: 18571 // result: (MOVLconst [0]) 18572 for { 18573 v_0 := v.Args[0] 18574 if v_0.Op != Op386FlagLT_UGT { 18575 break 18576 } 18577 v.reset(Op386MOVLconst) 18578 v.AuxInt = 0 18579 return true 18580 } 18581 // match: (SBBLcarrymask (FlagGT_ULT)) 18582 // cond: 18583 // result: (MOVLconst [-1]) 18584 for { 18585 v_0 := v.Args[0] 18586 if v_0.Op != Op386FlagGT_ULT { 18587 break 18588 } 18589 v.reset(Op386MOVLconst) 18590 v.AuxInt = -1 18591 return true 18592 } 18593 // match: (SBBLcarrymask (FlagGT_UGT)) 18594 // cond: 18595 // result: (MOVLconst [0]) 18596 for { 18597 v_0 := v.Args[0] 18598 if v_0.Op != Op386FlagGT_UGT { 18599 break 18600 } 18601 v.reset(Op386MOVLconst) 18602 v.AuxInt = 0 18603 return true 18604 } 18605 return false 18606 } 18607 func rewriteValue386_Op386SETA_0(v *Value) bool { 18608 // match: (SETA (InvertFlags x)) 18609 // cond: 18610 // result: (SETB x) 18611 for { 18612 v_0 := v.Args[0] 18613 if v_0.Op != Op386InvertFlags { 18614 break 18615 } 18616 x := v_0.Args[0] 18617 v.reset(Op386SETB) 18618 v.AddArg(x) 18619 return true 18620 } 18621 // match: (SETA (FlagEQ)) 18622 // cond: 18623 // result: (MOVLconst [0]) 18624 for { 18625 v_0 := v.Args[0] 18626 if v_0.Op != Op386FlagEQ { 18627 break 18628 } 18629 v.reset(Op386MOVLconst) 18630 v.AuxInt = 0 18631 return true 18632 } 18633 // match: (SETA (FlagLT_ULT)) 18634 // cond: 18635 // result: (MOVLconst [0]) 18636 for { 18637 v_0 := v.Args[0] 18638 if v_0.Op != Op386FlagLT_ULT { 18639 break 18640 } 18641 v.reset(Op386MOVLconst) 18642 v.AuxInt = 0 18643 return true 18644 } 18645 // match: (SETA (FlagLT_UGT)) 18646 // cond: 18647 // result: (MOVLconst [1]) 18648 for { 18649 v_0 := v.Args[0] 18650 if v_0.Op != Op386FlagLT_UGT { 18651 break 18652 } 18653 v.reset(Op386MOVLconst) 18654 v.AuxInt = 1 18655 return true 18656 } 18657 // match: (SETA (FlagGT_ULT)) 18658 // cond: 18659 // result: (MOVLconst [0]) 18660 for { 18661 v_0 := v.Args[0] 18662 if v_0.Op != Op386FlagGT_ULT { 18663 break 18664 } 18665 v.reset(Op386MOVLconst) 18666 v.AuxInt = 0 18667 return true 18668 } 18669 // match: (SETA (FlagGT_UGT)) 18670 // cond: 18671 // result: (MOVLconst [1]) 18672 for { 18673 v_0 := v.Args[0] 18674 if v_0.Op != Op386FlagGT_UGT { 18675 break 18676 } 18677 v.reset(Op386MOVLconst) 18678 v.AuxInt = 1 18679 return true 18680 } 18681 return false 18682 } 18683 func rewriteValue386_Op386SETAE_0(v *Value) bool { 18684 // match: (SETAE (InvertFlags x)) 18685 // cond: 18686 // result: (SETBE x) 18687 for { 18688 v_0 := v.Args[0] 18689 if v_0.Op != Op386InvertFlags { 18690 break 18691 } 18692 x := v_0.Args[0] 18693 v.reset(Op386SETBE) 18694 v.AddArg(x) 18695 return true 18696 } 18697 // match: (SETAE (FlagEQ)) 18698 // cond: 18699 // result: (MOVLconst [1]) 18700 for { 18701 v_0 := v.Args[0] 18702 if v_0.Op != Op386FlagEQ { 18703 break 18704 } 18705 v.reset(Op386MOVLconst) 18706 v.AuxInt = 1 18707 return true 18708 } 18709 // match: (SETAE (FlagLT_ULT)) 18710 // cond: 18711 // result: (MOVLconst [0]) 18712 for { 18713 v_0 := v.Args[0] 18714 if v_0.Op != Op386FlagLT_ULT { 18715 break 18716 } 18717 v.reset(Op386MOVLconst) 18718 v.AuxInt = 0 18719 return true 18720 } 18721 // match: (SETAE (FlagLT_UGT)) 18722 // cond: 18723 // result: (MOVLconst [1]) 18724 for { 18725 v_0 := v.Args[0] 18726 if v_0.Op != Op386FlagLT_UGT { 18727 break 18728 } 18729 v.reset(Op386MOVLconst) 18730 v.AuxInt = 1 18731 return true 18732 } 18733 // match: (SETAE (FlagGT_ULT)) 18734 // cond: 18735 // result: (MOVLconst [0]) 18736 for { 18737 v_0 := v.Args[0] 18738 if v_0.Op != Op386FlagGT_ULT { 18739 break 18740 } 18741 v.reset(Op386MOVLconst) 18742 v.AuxInt = 0 18743 return true 18744 } 18745 // match: (SETAE (FlagGT_UGT)) 18746 // cond: 18747 // result: (MOVLconst [1]) 18748 for { 18749 v_0 := v.Args[0] 18750 if v_0.Op != Op386FlagGT_UGT { 18751 break 18752 } 18753 v.reset(Op386MOVLconst) 18754 v.AuxInt = 1 18755 return true 18756 } 18757 return false 18758 } 18759 func rewriteValue386_Op386SETB_0(v *Value) bool { 18760 // match: (SETB (InvertFlags x)) 18761 // cond: 18762 // result: (SETA x) 18763 for { 18764 v_0 := v.Args[0] 18765 if v_0.Op != Op386InvertFlags { 18766 break 18767 } 18768 x := v_0.Args[0] 18769 v.reset(Op386SETA) 18770 v.AddArg(x) 18771 return true 18772 } 18773 // match: (SETB (FlagEQ)) 18774 // cond: 18775 // result: (MOVLconst [0]) 18776 for { 18777 v_0 := v.Args[0] 18778 if v_0.Op != Op386FlagEQ { 18779 break 18780 } 18781 v.reset(Op386MOVLconst) 18782 v.AuxInt = 0 18783 return true 18784 } 18785 // match: (SETB (FlagLT_ULT)) 18786 // cond: 18787 // result: (MOVLconst [1]) 18788 for { 18789 v_0 := v.Args[0] 18790 if v_0.Op != Op386FlagLT_ULT { 18791 break 18792 } 18793 v.reset(Op386MOVLconst) 18794 v.AuxInt = 1 18795 return true 18796 } 18797 // match: (SETB (FlagLT_UGT)) 18798 // cond: 18799 // result: (MOVLconst [0]) 18800 for { 18801 v_0 := v.Args[0] 18802 if v_0.Op != Op386FlagLT_UGT { 18803 break 18804 } 18805 v.reset(Op386MOVLconst) 18806 v.AuxInt = 0 18807 return true 18808 } 18809 // match: (SETB (FlagGT_ULT)) 18810 // cond: 18811 // result: (MOVLconst [1]) 18812 for { 18813 v_0 := v.Args[0] 18814 if v_0.Op != Op386FlagGT_ULT { 18815 break 18816 } 18817 v.reset(Op386MOVLconst) 18818 v.AuxInt = 1 18819 return true 18820 } 18821 // match: (SETB (FlagGT_UGT)) 18822 // cond: 18823 // result: (MOVLconst [0]) 18824 for { 18825 v_0 := v.Args[0] 18826 if v_0.Op != Op386FlagGT_UGT { 18827 break 18828 } 18829 v.reset(Op386MOVLconst) 18830 v.AuxInt = 0 18831 return true 18832 } 18833 return false 18834 } 18835 func rewriteValue386_Op386SETBE_0(v *Value) bool { 18836 // match: (SETBE (InvertFlags x)) 18837 // cond: 18838 // result: (SETAE x) 18839 for { 18840 v_0 := v.Args[0] 18841 if v_0.Op != Op386InvertFlags { 18842 break 18843 } 18844 x := v_0.Args[0] 18845 v.reset(Op386SETAE) 18846 v.AddArg(x) 18847 return true 18848 } 18849 // match: (SETBE (FlagEQ)) 18850 // cond: 18851 // result: (MOVLconst [1]) 18852 for { 18853 v_0 := v.Args[0] 18854 if v_0.Op != Op386FlagEQ { 18855 break 18856 } 18857 v.reset(Op386MOVLconst) 18858 v.AuxInt = 1 18859 return true 18860 } 18861 // match: (SETBE (FlagLT_ULT)) 18862 // cond: 18863 // result: (MOVLconst [1]) 18864 for { 18865 v_0 := v.Args[0] 18866 if v_0.Op != Op386FlagLT_ULT { 18867 break 18868 } 18869 v.reset(Op386MOVLconst) 18870 v.AuxInt = 1 18871 return true 18872 } 18873 // match: (SETBE (FlagLT_UGT)) 18874 // cond: 18875 // result: (MOVLconst [0]) 18876 for { 18877 v_0 := v.Args[0] 18878 if v_0.Op != Op386FlagLT_UGT { 18879 break 18880 } 18881 v.reset(Op386MOVLconst) 18882 v.AuxInt = 0 18883 return true 18884 } 18885 // match: (SETBE (FlagGT_ULT)) 18886 // cond: 18887 // result: (MOVLconst [1]) 18888 for { 18889 v_0 := v.Args[0] 18890 if v_0.Op != Op386FlagGT_ULT { 18891 break 18892 } 18893 v.reset(Op386MOVLconst) 18894 v.AuxInt = 1 18895 return true 18896 } 18897 // match: (SETBE (FlagGT_UGT)) 18898 // cond: 18899 // result: (MOVLconst [0]) 18900 for { 18901 v_0 := v.Args[0] 18902 if v_0.Op != Op386FlagGT_UGT { 18903 break 18904 } 18905 v.reset(Op386MOVLconst) 18906 v.AuxInt = 0 18907 return true 18908 } 18909 return false 18910 } 18911 func rewriteValue386_Op386SETEQ_0(v *Value) bool { 18912 // match: (SETEQ (InvertFlags x)) 18913 // cond: 18914 // result: (SETEQ x) 18915 for { 18916 v_0 := v.Args[0] 18917 if v_0.Op != Op386InvertFlags { 18918 break 18919 } 18920 x := v_0.Args[0] 18921 v.reset(Op386SETEQ) 18922 v.AddArg(x) 18923 return true 18924 } 18925 // match: (SETEQ (FlagEQ)) 18926 // cond: 18927 // result: (MOVLconst [1]) 18928 for { 18929 v_0 := v.Args[0] 18930 if v_0.Op != Op386FlagEQ { 18931 break 18932 } 18933 v.reset(Op386MOVLconst) 18934 v.AuxInt = 1 18935 return true 18936 } 18937 // match: (SETEQ (FlagLT_ULT)) 18938 // cond: 18939 // result: (MOVLconst [0]) 18940 for { 18941 v_0 := v.Args[0] 18942 if v_0.Op != Op386FlagLT_ULT { 18943 break 18944 } 18945 v.reset(Op386MOVLconst) 18946 v.AuxInt = 0 18947 return true 18948 } 18949 // match: (SETEQ (FlagLT_UGT)) 18950 // cond: 18951 // result: (MOVLconst [0]) 18952 for { 18953 v_0 := v.Args[0] 18954 if v_0.Op != Op386FlagLT_UGT { 18955 break 18956 } 18957 v.reset(Op386MOVLconst) 18958 v.AuxInt = 0 18959 return true 18960 } 18961 // match: (SETEQ (FlagGT_ULT)) 18962 // cond: 18963 // result: (MOVLconst [0]) 18964 for { 18965 v_0 := v.Args[0] 18966 if v_0.Op != Op386FlagGT_ULT { 18967 break 18968 } 18969 v.reset(Op386MOVLconst) 18970 v.AuxInt = 0 18971 return true 18972 } 18973 // match: (SETEQ (FlagGT_UGT)) 18974 // cond: 18975 // result: (MOVLconst [0]) 18976 for { 18977 v_0 := v.Args[0] 18978 if v_0.Op != Op386FlagGT_UGT { 18979 break 18980 } 18981 v.reset(Op386MOVLconst) 18982 v.AuxInt = 0 18983 return true 18984 } 18985 return false 18986 } 18987 func rewriteValue386_Op386SETG_0(v *Value) bool { 18988 // match: (SETG (InvertFlags x)) 18989 // cond: 18990 // result: (SETL x) 18991 for { 18992 v_0 := v.Args[0] 18993 if v_0.Op != Op386InvertFlags { 18994 break 18995 } 18996 x := v_0.Args[0] 18997 v.reset(Op386SETL) 18998 v.AddArg(x) 18999 return true 19000 } 19001 // match: (SETG (FlagEQ)) 19002 // cond: 19003 // result: (MOVLconst [0]) 19004 for { 19005 v_0 := v.Args[0] 19006 if v_0.Op != Op386FlagEQ { 19007 break 19008 } 19009 v.reset(Op386MOVLconst) 19010 v.AuxInt = 0 19011 return true 19012 } 19013 // match: (SETG (FlagLT_ULT)) 19014 // cond: 19015 // result: (MOVLconst [0]) 19016 for { 19017 v_0 := v.Args[0] 19018 if v_0.Op != Op386FlagLT_ULT { 19019 break 19020 } 19021 v.reset(Op386MOVLconst) 19022 v.AuxInt = 0 19023 return true 19024 } 19025 // match: (SETG (FlagLT_UGT)) 19026 // cond: 19027 // result: (MOVLconst [0]) 19028 for { 19029 v_0 := v.Args[0] 19030 if v_0.Op != Op386FlagLT_UGT { 19031 break 19032 } 19033 v.reset(Op386MOVLconst) 19034 v.AuxInt = 0 19035 return true 19036 } 19037 // match: (SETG (FlagGT_ULT)) 19038 // cond: 19039 // result: (MOVLconst [1]) 19040 for { 19041 v_0 := v.Args[0] 19042 if v_0.Op != Op386FlagGT_ULT { 19043 break 19044 } 19045 v.reset(Op386MOVLconst) 19046 v.AuxInt = 1 19047 return true 19048 } 19049 // match: (SETG (FlagGT_UGT)) 19050 // cond: 19051 // result: (MOVLconst [1]) 19052 for { 19053 v_0 := v.Args[0] 19054 if v_0.Op != Op386FlagGT_UGT { 19055 break 19056 } 19057 v.reset(Op386MOVLconst) 19058 v.AuxInt = 1 19059 return true 19060 } 19061 return false 19062 } 19063 func rewriteValue386_Op386SETGE_0(v *Value) bool { 19064 // match: (SETGE (InvertFlags x)) 19065 // cond: 19066 // result: (SETLE x) 19067 for { 19068 v_0 := v.Args[0] 19069 if v_0.Op != Op386InvertFlags { 19070 break 19071 } 19072 x := v_0.Args[0] 19073 v.reset(Op386SETLE) 19074 v.AddArg(x) 19075 return true 19076 } 19077 // match: (SETGE (FlagEQ)) 19078 // cond: 19079 // result: (MOVLconst [1]) 19080 for { 19081 v_0 := v.Args[0] 19082 if v_0.Op != Op386FlagEQ { 19083 break 19084 } 19085 v.reset(Op386MOVLconst) 19086 v.AuxInt = 1 19087 return true 19088 } 19089 // match: (SETGE (FlagLT_ULT)) 19090 // cond: 19091 // result: (MOVLconst [0]) 19092 for { 19093 v_0 := v.Args[0] 19094 if v_0.Op != Op386FlagLT_ULT { 19095 break 19096 } 19097 v.reset(Op386MOVLconst) 19098 v.AuxInt = 0 19099 return true 19100 } 19101 // match: (SETGE (FlagLT_UGT)) 19102 // cond: 19103 // result: (MOVLconst [0]) 19104 for { 19105 v_0 := v.Args[0] 19106 if v_0.Op != Op386FlagLT_UGT { 19107 break 19108 } 19109 v.reset(Op386MOVLconst) 19110 v.AuxInt = 0 19111 return true 19112 } 19113 // match: (SETGE (FlagGT_ULT)) 19114 // cond: 19115 // result: (MOVLconst [1]) 19116 for { 19117 v_0 := v.Args[0] 19118 if v_0.Op != Op386FlagGT_ULT { 19119 break 19120 } 19121 v.reset(Op386MOVLconst) 19122 v.AuxInt = 1 19123 return true 19124 } 19125 // match: (SETGE (FlagGT_UGT)) 19126 // cond: 19127 // result: (MOVLconst [1]) 19128 for { 19129 v_0 := v.Args[0] 19130 if v_0.Op != Op386FlagGT_UGT { 19131 break 19132 } 19133 v.reset(Op386MOVLconst) 19134 v.AuxInt = 1 19135 return true 19136 } 19137 return false 19138 } 19139 func rewriteValue386_Op386SETL_0(v *Value) bool { 19140 // match: (SETL (InvertFlags x)) 19141 // cond: 19142 // result: (SETG x) 19143 for { 19144 v_0 := v.Args[0] 19145 if v_0.Op != Op386InvertFlags { 19146 break 19147 } 19148 x := v_0.Args[0] 19149 v.reset(Op386SETG) 19150 v.AddArg(x) 19151 return true 19152 } 19153 // match: (SETL (FlagEQ)) 19154 // cond: 19155 // result: (MOVLconst [0]) 19156 for { 19157 v_0 := v.Args[0] 19158 if v_0.Op != Op386FlagEQ { 19159 break 19160 } 19161 v.reset(Op386MOVLconst) 19162 v.AuxInt = 0 19163 return true 19164 } 19165 // match: (SETL (FlagLT_ULT)) 19166 // cond: 19167 // result: (MOVLconst [1]) 19168 for { 19169 v_0 := v.Args[0] 19170 if v_0.Op != Op386FlagLT_ULT { 19171 break 19172 } 19173 v.reset(Op386MOVLconst) 19174 v.AuxInt = 1 19175 return true 19176 } 19177 // match: (SETL (FlagLT_UGT)) 19178 // cond: 19179 // result: (MOVLconst [1]) 19180 for { 19181 v_0 := v.Args[0] 19182 if v_0.Op != Op386FlagLT_UGT { 19183 break 19184 } 19185 v.reset(Op386MOVLconst) 19186 v.AuxInt = 1 19187 return true 19188 } 19189 // match: (SETL (FlagGT_ULT)) 19190 // cond: 19191 // result: (MOVLconst [0]) 19192 for { 19193 v_0 := v.Args[0] 19194 if v_0.Op != Op386FlagGT_ULT { 19195 break 19196 } 19197 v.reset(Op386MOVLconst) 19198 v.AuxInt = 0 19199 return true 19200 } 19201 // match: (SETL (FlagGT_UGT)) 19202 // cond: 19203 // result: (MOVLconst [0]) 19204 for { 19205 v_0 := v.Args[0] 19206 if v_0.Op != Op386FlagGT_UGT { 19207 break 19208 } 19209 v.reset(Op386MOVLconst) 19210 v.AuxInt = 0 19211 return true 19212 } 19213 return false 19214 } 19215 func rewriteValue386_Op386SETLE_0(v *Value) bool { 19216 // match: (SETLE (InvertFlags x)) 19217 // cond: 19218 // result: (SETGE x) 19219 for { 19220 v_0 := v.Args[0] 19221 if v_0.Op != Op386InvertFlags { 19222 break 19223 } 19224 x := v_0.Args[0] 19225 v.reset(Op386SETGE) 19226 v.AddArg(x) 19227 return true 19228 } 19229 // match: (SETLE (FlagEQ)) 19230 // cond: 19231 // result: (MOVLconst [1]) 19232 for { 19233 v_0 := v.Args[0] 19234 if v_0.Op != Op386FlagEQ { 19235 break 19236 } 19237 v.reset(Op386MOVLconst) 19238 v.AuxInt = 1 19239 return true 19240 } 19241 // match: (SETLE (FlagLT_ULT)) 19242 // cond: 19243 // result: (MOVLconst [1]) 19244 for { 19245 v_0 := v.Args[0] 19246 if v_0.Op != Op386FlagLT_ULT { 19247 break 19248 } 19249 v.reset(Op386MOVLconst) 19250 v.AuxInt = 1 19251 return true 19252 } 19253 // match: (SETLE (FlagLT_UGT)) 19254 // cond: 19255 // result: (MOVLconst [1]) 19256 for { 19257 v_0 := v.Args[0] 19258 if v_0.Op != Op386FlagLT_UGT { 19259 break 19260 } 19261 v.reset(Op386MOVLconst) 19262 v.AuxInt = 1 19263 return true 19264 } 19265 // match: (SETLE (FlagGT_ULT)) 19266 // cond: 19267 // result: (MOVLconst [0]) 19268 for { 19269 v_0 := v.Args[0] 19270 if v_0.Op != Op386FlagGT_ULT { 19271 break 19272 } 19273 v.reset(Op386MOVLconst) 19274 v.AuxInt = 0 19275 return true 19276 } 19277 // match: (SETLE (FlagGT_UGT)) 19278 // cond: 19279 // result: (MOVLconst [0]) 19280 for { 19281 v_0 := v.Args[0] 19282 if v_0.Op != Op386FlagGT_UGT { 19283 break 19284 } 19285 v.reset(Op386MOVLconst) 19286 v.AuxInt = 0 19287 return true 19288 } 19289 return false 19290 } 19291 func rewriteValue386_Op386SETNE_0(v *Value) bool { 19292 // match: (SETNE (InvertFlags x)) 19293 // cond: 19294 // result: (SETNE x) 19295 for { 19296 v_0 := v.Args[0] 19297 if v_0.Op != Op386InvertFlags { 19298 break 19299 } 19300 x := v_0.Args[0] 19301 v.reset(Op386SETNE) 19302 v.AddArg(x) 19303 return true 19304 } 19305 // match: (SETNE (FlagEQ)) 19306 // cond: 19307 // result: (MOVLconst [0]) 19308 for { 19309 v_0 := v.Args[0] 19310 if v_0.Op != Op386FlagEQ { 19311 break 19312 } 19313 v.reset(Op386MOVLconst) 19314 v.AuxInt = 0 19315 return true 19316 } 19317 // match: (SETNE (FlagLT_ULT)) 19318 // cond: 19319 // result: (MOVLconst [1]) 19320 for { 19321 v_0 := v.Args[0] 19322 if v_0.Op != Op386FlagLT_ULT { 19323 break 19324 } 19325 v.reset(Op386MOVLconst) 19326 v.AuxInt = 1 19327 return true 19328 } 19329 // match: (SETNE (FlagLT_UGT)) 19330 // cond: 19331 // result: (MOVLconst [1]) 19332 for { 19333 v_0 := v.Args[0] 19334 if v_0.Op != Op386FlagLT_UGT { 19335 break 19336 } 19337 v.reset(Op386MOVLconst) 19338 v.AuxInt = 1 19339 return true 19340 } 19341 // match: (SETNE (FlagGT_ULT)) 19342 // cond: 19343 // result: (MOVLconst [1]) 19344 for { 19345 v_0 := v.Args[0] 19346 if v_0.Op != Op386FlagGT_ULT { 19347 break 19348 } 19349 v.reset(Op386MOVLconst) 19350 v.AuxInt = 1 19351 return true 19352 } 19353 // match: (SETNE (FlagGT_UGT)) 19354 // cond: 19355 // result: (MOVLconst [1]) 19356 for { 19357 v_0 := v.Args[0] 19358 if v_0.Op != Op386FlagGT_UGT { 19359 break 19360 } 19361 v.reset(Op386MOVLconst) 19362 v.AuxInt = 1 19363 return true 19364 } 19365 return false 19366 } 19367 func rewriteValue386_Op386SHLL_0(v *Value) bool { 19368 // match: (SHLL x (MOVLconst [c])) 19369 // cond: 19370 // result: (SHLLconst [c&31] x) 19371 for { 19372 _ = v.Args[1] 19373 x := v.Args[0] 19374 v_1 := v.Args[1] 19375 if v_1.Op != Op386MOVLconst { 19376 break 19377 } 19378 c := v_1.AuxInt 19379 v.reset(Op386SHLLconst) 19380 v.AuxInt = c & 31 19381 v.AddArg(x) 19382 return true 19383 } 19384 // match: (SHLL x (ANDLconst [31] y)) 19385 // cond: 19386 // result: (SHLL x y) 19387 for { 19388 _ = v.Args[1] 19389 x := v.Args[0] 19390 v_1 := v.Args[1] 19391 if v_1.Op != Op386ANDLconst { 19392 break 19393 } 19394 if v_1.AuxInt != 31 { 19395 break 19396 } 19397 y := v_1.Args[0] 19398 v.reset(Op386SHLL) 19399 v.AddArg(x) 19400 v.AddArg(y) 19401 return true 19402 } 19403 return false 19404 } 19405 func rewriteValue386_Op386SHLLconst_0(v *Value) bool { 19406 // match: (SHLLconst x [0]) 19407 // cond: 19408 // result: x 19409 for { 19410 if v.AuxInt != 0 { 19411 break 19412 } 19413 x := v.Args[0] 19414 v.reset(OpCopy) 19415 v.Type = x.Type 19416 v.AddArg(x) 19417 return true 19418 } 19419 return false 19420 } 19421 func rewriteValue386_Op386SHRB_0(v *Value) bool { 19422 // match: (SHRB x (MOVLconst [c])) 19423 // cond: c&31 < 8 19424 // result: (SHRBconst [c&31] x) 19425 for { 19426 _ = v.Args[1] 19427 x := v.Args[0] 19428 v_1 := v.Args[1] 19429 if v_1.Op != Op386MOVLconst { 19430 break 19431 } 19432 c := v_1.AuxInt 19433 if !(c&31 < 8) { 19434 break 19435 } 19436 v.reset(Op386SHRBconst) 19437 v.AuxInt = c & 31 19438 v.AddArg(x) 19439 return true 19440 } 19441 // match: (SHRB _ (MOVLconst [c])) 19442 // cond: c&31 >= 8 19443 // result: (MOVLconst [0]) 19444 for { 19445 _ = v.Args[1] 19446 v_1 := v.Args[1] 19447 if v_1.Op != Op386MOVLconst { 19448 break 19449 } 19450 c := v_1.AuxInt 19451 if !(c&31 >= 8) { 19452 break 19453 } 19454 v.reset(Op386MOVLconst) 19455 v.AuxInt = 0 19456 return true 19457 } 19458 return false 19459 } 19460 func rewriteValue386_Op386SHRBconst_0(v *Value) bool { 19461 // match: (SHRBconst x [0]) 19462 // cond: 19463 // result: x 19464 for { 19465 if v.AuxInt != 0 { 19466 break 19467 } 19468 x := v.Args[0] 19469 v.reset(OpCopy) 19470 v.Type = x.Type 19471 v.AddArg(x) 19472 return true 19473 } 19474 return false 19475 } 19476 func rewriteValue386_Op386SHRL_0(v *Value) bool { 19477 // match: (SHRL x (MOVLconst [c])) 19478 // cond: 19479 // result: (SHRLconst [c&31] x) 19480 for { 19481 _ = v.Args[1] 19482 x := v.Args[0] 19483 v_1 := v.Args[1] 19484 if v_1.Op != Op386MOVLconst { 19485 break 19486 } 19487 c := v_1.AuxInt 19488 v.reset(Op386SHRLconst) 19489 v.AuxInt = c & 31 19490 v.AddArg(x) 19491 return true 19492 } 19493 // match: (SHRL x (ANDLconst [31] y)) 19494 // cond: 19495 // result: (SHRL x y) 19496 for { 19497 _ = v.Args[1] 19498 x := v.Args[0] 19499 v_1 := v.Args[1] 19500 if v_1.Op != Op386ANDLconst { 19501 break 19502 } 19503 if v_1.AuxInt != 31 { 19504 break 19505 } 19506 y := v_1.Args[0] 19507 v.reset(Op386SHRL) 19508 v.AddArg(x) 19509 v.AddArg(y) 19510 return true 19511 } 19512 return false 19513 } 19514 func rewriteValue386_Op386SHRLconst_0(v *Value) bool { 19515 // match: (SHRLconst x [0]) 19516 // cond: 19517 // result: x 19518 for { 19519 if v.AuxInt != 0 { 19520 break 19521 } 19522 x := v.Args[0] 19523 v.reset(OpCopy) 19524 v.Type = x.Type 19525 v.AddArg(x) 19526 return true 19527 } 19528 return false 19529 } 19530 func rewriteValue386_Op386SHRW_0(v *Value) bool { 19531 // match: (SHRW x (MOVLconst [c])) 19532 // cond: c&31 < 16 19533 // result: (SHRWconst [c&31] x) 19534 for { 19535 _ = v.Args[1] 19536 x := v.Args[0] 19537 v_1 := v.Args[1] 19538 if v_1.Op != Op386MOVLconst { 19539 break 19540 } 19541 c := v_1.AuxInt 19542 if !(c&31 < 16) { 19543 break 19544 } 19545 v.reset(Op386SHRWconst) 19546 v.AuxInt = c & 31 19547 v.AddArg(x) 19548 return true 19549 } 19550 // match: (SHRW _ (MOVLconst [c])) 19551 // cond: c&31 >= 16 19552 // result: (MOVLconst [0]) 19553 for { 19554 _ = v.Args[1] 19555 v_1 := v.Args[1] 19556 if v_1.Op != Op386MOVLconst { 19557 break 19558 } 19559 c := v_1.AuxInt 19560 if !(c&31 >= 16) { 19561 break 19562 } 19563 v.reset(Op386MOVLconst) 19564 v.AuxInt = 0 19565 return true 19566 } 19567 return false 19568 } 19569 func rewriteValue386_Op386SHRWconst_0(v *Value) bool { 19570 // match: (SHRWconst x [0]) 19571 // cond: 19572 // result: x 19573 for { 19574 if v.AuxInt != 0 { 19575 break 19576 } 19577 x := v.Args[0] 19578 v.reset(OpCopy) 19579 v.Type = x.Type 19580 v.AddArg(x) 19581 return true 19582 } 19583 return false 19584 } 19585 func rewriteValue386_Op386SUBL_0(v *Value) bool { 19586 b := v.Block 19587 _ = b 19588 // match: (SUBL x (MOVLconst [c])) 19589 // cond: 19590 // result: (SUBLconst x [c]) 19591 for { 19592 _ = v.Args[1] 19593 x := v.Args[0] 19594 v_1 := v.Args[1] 19595 if v_1.Op != Op386MOVLconst { 19596 break 19597 } 19598 c := v_1.AuxInt 19599 v.reset(Op386SUBLconst) 19600 v.AuxInt = c 19601 v.AddArg(x) 19602 return true 19603 } 19604 // match: (SUBL (MOVLconst [c]) x) 19605 // cond: 19606 // result: (NEGL (SUBLconst <v.Type> x [c])) 19607 for { 19608 _ = v.Args[1] 19609 v_0 := v.Args[0] 19610 if v_0.Op != Op386MOVLconst { 19611 break 19612 } 19613 c := v_0.AuxInt 19614 x := v.Args[1] 19615 v.reset(Op386NEGL) 19616 v0 := b.NewValue0(v.Pos, Op386SUBLconst, v.Type) 19617 v0.AuxInt = c 19618 v0.AddArg(x) 19619 v.AddArg(v0) 19620 return true 19621 } 19622 // match: (SUBL x l:(MOVLload [off] {sym} ptr mem)) 19623 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 19624 // result: (SUBLload x [off] {sym} ptr mem) 19625 for { 19626 _ = v.Args[1] 19627 x := v.Args[0] 19628 l := v.Args[1] 19629 if l.Op != Op386MOVLload { 19630 break 19631 } 19632 off := l.AuxInt 19633 sym := l.Aux 19634 _ = l.Args[1] 19635 ptr := l.Args[0] 19636 mem := l.Args[1] 19637 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 19638 break 19639 } 19640 v.reset(Op386SUBLload) 19641 v.AuxInt = off 19642 v.Aux = sym 19643 v.AddArg(x) 19644 v.AddArg(ptr) 19645 v.AddArg(mem) 19646 return true 19647 } 19648 // match: (SUBL x l:(MOVLloadidx4 [off] {sym} ptr idx mem)) 19649 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 19650 // result: (SUBLloadidx4 x [off] {sym} ptr idx mem) 19651 for { 19652 _ = v.Args[1] 19653 x := v.Args[0] 19654 l := v.Args[1] 19655 if l.Op != Op386MOVLloadidx4 { 19656 break 19657 } 19658 off := l.AuxInt 19659 sym := l.Aux 19660 _ = l.Args[2] 19661 ptr := l.Args[0] 19662 idx := l.Args[1] 19663 mem := l.Args[2] 19664 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 19665 break 19666 } 19667 v.reset(Op386SUBLloadidx4) 19668 v.AuxInt = off 19669 v.Aux = sym 19670 v.AddArg(x) 19671 v.AddArg(ptr) 19672 v.AddArg(idx) 19673 v.AddArg(mem) 19674 return true 19675 } 19676 // match: (SUBL x x) 19677 // cond: 19678 // result: (MOVLconst [0]) 19679 for { 19680 _ = v.Args[1] 19681 x := v.Args[0] 19682 if x != v.Args[1] { 19683 break 19684 } 19685 v.reset(Op386MOVLconst) 19686 v.AuxInt = 0 19687 return true 19688 } 19689 return false 19690 } 19691 func rewriteValue386_Op386SUBLcarry_0(v *Value) bool { 19692 // match: (SUBLcarry x (MOVLconst [c])) 19693 // cond: 19694 // result: (SUBLconstcarry [c] x) 19695 for { 19696 _ = v.Args[1] 19697 x := v.Args[0] 19698 v_1 := v.Args[1] 19699 if v_1.Op != Op386MOVLconst { 19700 break 19701 } 19702 c := v_1.AuxInt 19703 v.reset(Op386SUBLconstcarry) 19704 v.AuxInt = c 19705 v.AddArg(x) 19706 return true 19707 } 19708 return false 19709 } 19710 func rewriteValue386_Op386SUBLconst_0(v *Value) bool { 19711 // match: (SUBLconst [c] x) 19712 // cond: int32(c) == 0 19713 // result: x 19714 for { 19715 c := v.AuxInt 19716 x := v.Args[0] 19717 if !(int32(c) == 0) { 19718 break 19719 } 19720 v.reset(OpCopy) 19721 v.Type = x.Type 19722 v.AddArg(x) 19723 return true 19724 } 19725 // match: (SUBLconst [c] x) 19726 // cond: 19727 // result: (ADDLconst [int64(int32(-c))] x) 19728 for { 19729 c := v.AuxInt 19730 x := v.Args[0] 19731 v.reset(Op386ADDLconst) 19732 v.AuxInt = int64(int32(-c)) 19733 v.AddArg(x) 19734 return true 19735 } 19736 } 19737 func rewriteValue386_Op386SUBLload_0(v *Value) bool { 19738 b := v.Block 19739 _ = b 19740 config := b.Func.Config 19741 _ = config 19742 // match: (SUBLload [off1] {sym} val (ADDLconst [off2] base) mem) 19743 // cond: is32Bit(off1+off2) 19744 // result: (SUBLload [off1+off2] {sym} val base mem) 19745 for { 19746 off1 := v.AuxInt 19747 sym := v.Aux 19748 _ = v.Args[2] 19749 val := v.Args[0] 19750 v_1 := v.Args[1] 19751 if v_1.Op != Op386ADDLconst { 19752 break 19753 } 19754 off2 := v_1.AuxInt 19755 base := v_1.Args[0] 19756 mem := v.Args[2] 19757 if !(is32Bit(off1 + off2)) { 19758 break 19759 } 19760 v.reset(Op386SUBLload) 19761 v.AuxInt = off1 + off2 19762 v.Aux = sym 19763 v.AddArg(val) 19764 v.AddArg(base) 19765 v.AddArg(mem) 19766 return true 19767 } 19768 // match: (SUBLload [off1] {sym1} val (LEAL [off2] {sym2} base) mem) 19769 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 19770 // result: (SUBLload [off1+off2] {mergeSym(sym1,sym2)} val base mem) 19771 for { 19772 off1 := v.AuxInt 19773 sym1 := v.Aux 19774 _ = v.Args[2] 19775 val := v.Args[0] 19776 v_1 := v.Args[1] 19777 if v_1.Op != Op386LEAL { 19778 break 19779 } 19780 off2 := v_1.AuxInt 19781 sym2 := v_1.Aux 19782 base := v_1.Args[0] 19783 mem := v.Args[2] 19784 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 19785 break 19786 } 19787 v.reset(Op386SUBLload) 19788 v.AuxInt = off1 + off2 19789 v.Aux = mergeSym(sym1, sym2) 19790 v.AddArg(val) 19791 v.AddArg(base) 19792 v.AddArg(mem) 19793 return true 19794 } 19795 // match: (SUBLload [off1] {sym1} val (LEAL4 [off2] {sym2} ptr idx) mem) 19796 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 19797 // result: (SUBLloadidx4 [off1+off2] {mergeSym(sym1,sym2)} val ptr idx mem) 19798 for { 19799 off1 := v.AuxInt 19800 sym1 := v.Aux 19801 _ = v.Args[2] 19802 val := v.Args[0] 19803 v_1 := v.Args[1] 19804 if v_1.Op != Op386LEAL4 { 19805 break 19806 } 19807 off2 := v_1.AuxInt 19808 sym2 := v_1.Aux 19809 _ = v_1.Args[1] 19810 ptr := v_1.Args[0] 19811 idx := v_1.Args[1] 19812 mem := v.Args[2] 19813 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 19814 break 19815 } 19816 v.reset(Op386SUBLloadidx4) 19817 v.AuxInt = off1 + off2 19818 v.Aux = mergeSym(sym1, sym2) 19819 v.AddArg(val) 19820 v.AddArg(ptr) 19821 v.AddArg(idx) 19822 v.AddArg(mem) 19823 return true 19824 } 19825 return false 19826 } 19827 func rewriteValue386_Op386SUBLloadidx4_0(v *Value) bool { 19828 b := v.Block 19829 _ = b 19830 config := b.Func.Config 19831 _ = config 19832 // match: (SUBLloadidx4 [off1] {sym} val (ADDLconst [off2] base) idx mem) 19833 // cond: is32Bit(off1+off2) 19834 // result: (SUBLloadidx4 [off1+off2] {sym} val base idx mem) 19835 for { 19836 off1 := v.AuxInt 19837 sym := v.Aux 19838 _ = v.Args[3] 19839 val := v.Args[0] 19840 v_1 := v.Args[1] 19841 if v_1.Op != Op386ADDLconst { 19842 break 19843 } 19844 off2 := v_1.AuxInt 19845 base := v_1.Args[0] 19846 idx := v.Args[2] 19847 mem := v.Args[3] 19848 if !(is32Bit(off1 + off2)) { 19849 break 19850 } 19851 v.reset(Op386SUBLloadidx4) 19852 v.AuxInt = off1 + off2 19853 v.Aux = sym 19854 v.AddArg(val) 19855 v.AddArg(base) 19856 v.AddArg(idx) 19857 v.AddArg(mem) 19858 return true 19859 } 19860 // match: (SUBLloadidx4 [off1] {sym} val base (ADDLconst [off2] idx) mem) 19861 // cond: is32Bit(off1+off2*4) 19862 // result: (SUBLloadidx4 [off1+off2*4] {sym} val base idx mem) 19863 for { 19864 off1 := v.AuxInt 19865 sym := v.Aux 19866 _ = v.Args[3] 19867 val := v.Args[0] 19868 base := v.Args[1] 19869 v_2 := v.Args[2] 19870 if v_2.Op != Op386ADDLconst { 19871 break 19872 } 19873 off2 := v_2.AuxInt 19874 idx := v_2.Args[0] 19875 mem := v.Args[3] 19876 if !(is32Bit(off1 + off2*4)) { 19877 break 19878 } 19879 v.reset(Op386SUBLloadidx4) 19880 v.AuxInt = off1 + off2*4 19881 v.Aux = sym 19882 v.AddArg(val) 19883 v.AddArg(base) 19884 v.AddArg(idx) 19885 v.AddArg(mem) 19886 return true 19887 } 19888 // match: (SUBLloadidx4 [off1] {sym1} val (LEAL [off2] {sym2} base) idx mem) 19889 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 19890 // result: (SUBLloadidx4 [off1+off2] {mergeSym(sym1,sym2)} val base idx mem) 19891 for { 19892 off1 := v.AuxInt 19893 sym1 := v.Aux 19894 _ = v.Args[3] 19895 val := v.Args[0] 19896 v_1 := v.Args[1] 19897 if v_1.Op != Op386LEAL { 19898 break 19899 } 19900 off2 := v_1.AuxInt 19901 sym2 := v_1.Aux 19902 base := v_1.Args[0] 19903 idx := v.Args[2] 19904 mem := v.Args[3] 19905 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 19906 break 19907 } 19908 v.reset(Op386SUBLloadidx4) 19909 v.AuxInt = off1 + off2 19910 v.Aux = mergeSym(sym1, sym2) 19911 v.AddArg(val) 19912 v.AddArg(base) 19913 v.AddArg(idx) 19914 v.AddArg(mem) 19915 return true 19916 } 19917 return false 19918 } 19919 func rewriteValue386_Op386SUBLmodify_0(v *Value) bool { 19920 b := v.Block 19921 _ = b 19922 config := b.Func.Config 19923 _ = config 19924 // match: (SUBLmodify [off1] {sym} (ADDLconst [off2] base) val mem) 19925 // cond: is32Bit(off1+off2) 19926 // result: (SUBLmodify [off1+off2] {sym} base val mem) 19927 for { 19928 off1 := v.AuxInt 19929 sym := v.Aux 19930 _ = v.Args[2] 19931 v_0 := v.Args[0] 19932 if v_0.Op != Op386ADDLconst { 19933 break 19934 } 19935 off2 := v_0.AuxInt 19936 base := v_0.Args[0] 19937 val := v.Args[1] 19938 mem := v.Args[2] 19939 if !(is32Bit(off1 + off2)) { 19940 break 19941 } 19942 v.reset(Op386SUBLmodify) 19943 v.AuxInt = off1 + off2 19944 v.Aux = sym 19945 v.AddArg(base) 19946 v.AddArg(val) 19947 v.AddArg(mem) 19948 return true 19949 } 19950 // match: (SUBLmodify [off1] {sym1} (LEAL [off2] {sym2} base) val mem) 19951 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 19952 // result: (SUBLmodify [off1+off2] {mergeSym(sym1,sym2)} base val mem) 19953 for { 19954 off1 := v.AuxInt 19955 sym1 := v.Aux 19956 _ = v.Args[2] 19957 v_0 := v.Args[0] 19958 if v_0.Op != Op386LEAL { 19959 break 19960 } 19961 off2 := v_0.AuxInt 19962 sym2 := v_0.Aux 19963 base := v_0.Args[0] 19964 val := v.Args[1] 19965 mem := v.Args[2] 19966 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 19967 break 19968 } 19969 v.reset(Op386SUBLmodify) 19970 v.AuxInt = off1 + off2 19971 v.Aux = mergeSym(sym1, sym2) 19972 v.AddArg(base) 19973 v.AddArg(val) 19974 v.AddArg(mem) 19975 return true 19976 } 19977 return false 19978 } 19979 func rewriteValue386_Op386SUBLmodifyidx4_0(v *Value) bool { 19980 b := v.Block 19981 _ = b 19982 config := b.Func.Config 19983 _ = config 19984 // match: (SUBLmodifyidx4 [off1] {sym} (ADDLconst [off2] base) idx val mem) 19985 // cond: is32Bit(off1+off2) 19986 // result: (SUBLmodifyidx4 [off1+off2] {sym} base idx val mem) 19987 for { 19988 off1 := v.AuxInt 19989 sym := v.Aux 19990 _ = v.Args[3] 19991 v_0 := v.Args[0] 19992 if v_0.Op != Op386ADDLconst { 19993 break 19994 } 19995 off2 := v_0.AuxInt 19996 base := v_0.Args[0] 19997 idx := v.Args[1] 19998 val := v.Args[2] 19999 mem := v.Args[3] 20000 if !(is32Bit(off1 + off2)) { 20001 break 20002 } 20003 v.reset(Op386SUBLmodifyidx4) 20004 v.AuxInt = off1 + off2 20005 v.Aux = sym 20006 v.AddArg(base) 20007 v.AddArg(idx) 20008 v.AddArg(val) 20009 v.AddArg(mem) 20010 return true 20011 } 20012 // match: (SUBLmodifyidx4 [off1] {sym} base (ADDLconst [off2] idx) val mem) 20013 // cond: is32Bit(off1+off2*4) 20014 // result: (SUBLmodifyidx4 [off1+off2*4] {sym} base idx val mem) 20015 for { 20016 off1 := v.AuxInt 20017 sym := v.Aux 20018 _ = v.Args[3] 20019 base := v.Args[0] 20020 v_1 := v.Args[1] 20021 if v_1.Op != Op386ADDLconst { 20022 break 20023 } 20024 off2 := v_1.AuxInt 20025 idx := v_1.Args[0] 20026 val := v.Args[2] 20027 mem := v.Args[3] 20028 if !(is32Bit(off1 + off2*4)) { 20029 break 20030 } 20031 v.reset(Op386SUBLmodifyidx4) 20032 v.AuxInt = off1 + off2*4 20033 v.Aux = sym 20034 v.AddArg(base) 20035 v.AddArg(idx) 20036 v.AddArg(val) 20037 v.AddArg(mem) 20038 return true 20039 } 20040 // match: (SUBLmodifyidx4 [off1] {sym1} (LEAL [off2] {sym2} base) idx val mem) 20041 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 20042 // result: (SUBLmodifyidx4 [off1+off2] {mergeSym(sym1,sym2)} base idx val mem) 20043 for { 20044 off1 := v.AuxInt 20045 sym1 := v.Aux 20046 _ = v.Args[3] 20047 v_0 := v.Args[0] 20048 if v_0.Op != Op386LEAL { 20049 break 20050 } 20051 off2 := v_0.AuxInt 20052 sym2 := v_0.Aux 20053 base := v_0.Args[0] 20054 idx := v.Args[1] 20055 val := v.Args[2] 20056 mem := v.Args[3] 20057 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 20058 break 20059 } 20060 v.reset(Op386SUBLmodifyidx4) 20061 v.AuxInt = off1 + off2 20062 v.Aux = mergeSym(sym1, sym2) 20063 v.AddArg(base) 20064 v.AddArg(idx) 20065 v.AddArg(val) 20066 v.AddArg(mem) 20067 return true 20068 } 20069 // match: (SUBLmodifyidx4 [off] {sym} ptr idx (MOVLconst [c]) mem) 20070 // cond: validValAndOff(-c,off) 20071 // result: (ADDLconstmodifyidx4 [makeValAndOff(-c,off)] {sym} ptr idx mem) 20072 for { 20073 off := v.AuxInt 20074 sym := v.Aux 20075 _ = v.Args[3] 20076 ptr := v.Args[0] 20077 idx := v.Args[1] 20078 v_2 := v.Args[2] 20079 if v_2.Op != Op386MOVLconst { 20080 break 20081 } 20082 c := v_2.AuxInt 20083 mem := v.Args[3] 20084 if !(validValAndOff(-c, off)) { 20085 break 20086 } 20087 v.reset(Op386ADDLconstmodifyidx4) 20088 v.AuxInt = makeValAndOff(-c, off) 20089 v.Aux = sym 20090 v.AddArg(ptr) 20091 v.AddArg(idx) 20092 v.AddArg(mem) 20093 return true 20094 } 20095 return false 20096 } 20097 func rewriteValue386_Op386SUBSD_0(v *Value) bool { 20098 b := v.Block 20099 _ = b 20100 config := b.Func.Config 20101 _ = config 20102 // match: (SUBSD x l:(MOVSDload [off] {sym} ptr mem)) 20103 // cond: canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l) 20104 // result: (SUBSDload x [off] {sym} ptr mem) 20105 for { 20106 _ = v.Args[1] 20107 x := v.Args[0] 20108 l := v.Args[1] 20109 if l.Op != Op386MOVSDload { 20110 break 20111 } 20112 off := l.AuxInt 20113 sym := l.Aux 20114 _ = l.Args[1] 20115 ptr := l.Args[0] 20116 mem := l.Args[1] 20117 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) { 20118 break 20119 } 20120 v.reset(Op386SUBSDload) 20121 v.AuxInt = off 20122 v.Aux = sym 20123 v.AddArg(x) 20124 v.AddArg(ptr) 20125 v.AddArg(mem) 20126 return true 20127 } 20128 return false 20129 } 20130 func rewriteValue386_Op386SUBSDload_0(v *Value) bool { 20131 b := v.Block 20132 _ = b 20133 config := b.Func.Config 20134 _ = config 20135 // match: (SUBSDload [off1] {sym} val (ADDLconst [off2] base) mem) 20136 // cond: is32Bit(off1+off2) 20137 // result: (SUBSDload [off1+off2] {sym} val base mem) 20138 for { 20139 off1 := v.AuxInt 20140 sym := v.Aux 20141 _ = v.Args[2] 20142 val := v.Args[0] 20143 v_1 := v.Args[1] 20144 if v_1.Op != Op386ADDLconst { 20145 break 20146 } 20147 off2 := v_1.AuxInt 20148 base := v_1.Args[0] 20149 mem := v.Args[2] 20150 if !(is32Bit(off1 + off2)) { 20151 break 20152 } 20153 v.reset(Op386SUBSDload) 20154 v.AuxInt = off1 + off2 20155 v.Aux = sym 20156 v.AddArg(val) 20157 v.AddArg(base) 20158 v.AddArg(mem) 20159 return true 20160 } 20161 // match: (SUBSDload [off1] {sym1} val (LEAL [off2] {sym2} base) mem) 20162 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 20163 // result: (SUBSDload [off1+off2] {mergeSym(sym1,sym2)} val base mem) 20164 for { 20165 off1 := v.AuxInt 20166 sym1 := v.Aux 20167 _ = v.Args[2] 20168 val := v.Args[0] 20169 v_1 := v.Args[1] 20170 if v_1.Op != Op386LEAL { 20171 break 20172 } 20173 off2 := v_1.AuxInt 20174 sym2 := v_1.Aux 20175 base := v_1.Args[0] 20176 mem := v.Args[2] 20177 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 20178 break 20179 } 20180 v.reset(Op386SUBSDload) 20181 v.AuxInt = off1 + off2 20182 v.Aux = mergeSym(sym1, sym2) 20183 v.AddArg(val) 20184 v.AddArg(base) 20185 v.AddArg(mem) 20186 return true 20187 } 20188 return false 20189 } 20190 func rewriteValue386_Op386SUBSS_0(v *Value) bool { 20191 b := v.Block 20192 _ = b 20193 config := b.Func.Config 20194 _ = config 20195 // match: (SUBSS x l:(MOVSSload [off] {sym} ptr mem)) 20196 // cond: canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l) 20197 // result: (SUBSSload x [off] {sym} ptr mem) 20198 for { 20199 _ = v.Args[1] 20200 x := v.Args[0] 20201 l := v.Args[1] 20202 if l.Op != Op386MOVSSload { 20203 break 20204 } 20205 off := l.AuxInt 20206 sym := l.Aux 20207 _ = l.Args[1] 20208 ptr := l.Args[0] 20209 mem := l.Args[1] 20210 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) { 20211 break 20212 } 20213 v.reset(Op386SUBSSload) 20214 v.AuxInt = off 20215 v.Aux = sym 20216 v.AddArg(x) 20217 v.AddArg(ptr) 20218 v.AddArg(mem) 20219 return true 20220 } 20221 return false 20222 } 20223 func rewriteValue386_Op386SUBSSload_0(v *Value) bool { 20224 b := v.Block 20225 _ = b 20226 config := b.Func.Config 20227 _ = config 20228 // match: (SUBSSload [off1] {sym} val (ADDLconst [off2] base) mem) 20229 // cond: is32Bit(off1+off2) 20230 // result: (SUBSSload [off1+off2] {sym} val base mem) 20231 for { 20232 off1 := v.AuxInt 20233 sym := v.Aux 20234 _ = v.Args[2] 20235 val := v.Args[0] 20236 v_1 := v.Args[1] 20237 if v_1.Op != Op386ADDLconst { 20238 break 20239 } 20240 off2 := v_1.AuxInt 20241 base := v_1.Args[0] 20242 mem := v.Args[2] 20243 if !(is32Bit(off1 + off2)) { 20244 break 20245 } 20246 v.reset(Op386SUBSSload) 20247 v.AuxInt = off1 + off2 20248 v.Aux = sym 20249 v.AddArg(val) 20250 v.AddArg(base) 20251 v.AddArg(mem) 20252 return true 20253 } 20254 // match: (SUBSSload [off1] {sym1} val (LEAL [off2] {sym2} base) mem) 20255 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 20256 // result: (SUBSSload [off1+off2] {mergeSym(sym1,sym2)} val base mem) 20257 for { 20258 off1 := v.AuxInt 20259 sym1 := v.Aux 20260 _ = v.Args[2] 20261 val := v.Args[0] 20262 v_1 := v.Args[1] 20263 if v_1.Op != Op386LEAL { 20264 break 20265 } 20266 off2 := v_1.AuxInt 20267 sym2 := v_1.Aux 20268 base := v_1.Args[0] 20269 mem := v.Args[2] 20270 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 20271 break 20272 } 20273 v.reset(Op386SUBSSload) 20274 v.AuxInt = off1 + off2 20275 v.Aux = mergeSym(sym1, sym2) 20276 v.AddArg(val) 20277 v.AddArg(base) 20278 v.AddArg(mem) 20279 return true 20280 } 20281 return false 20282 } 20283 func rewriteValue386_Op386XORL_0(v *Value) bool { 20284 // match: (XORL x (MOVLconst [c])) 20285 // cond: 20286 // result: (XORLconst [c] x) 20287 for { 20288 _ = v.Args[1] 20289 x := v.Args[0] 20290 v_1 := v.Args[1] 20291 if v_1.Op != Op386MOVLconst { 20292 break 20293 } 20294 c := v_1.AuxInt 20295 v.reset(Op386XORLconst) 20296 v.AuxInt = c 20297 v.AddArg(x) 20298 return true 20299 } 20300 // match: (XORL (MOVLconst [c]) x) 20301 // cond: 20302 // result: (XORLconst [c] x) 20303 for { 20304 _ = v.Args[1] 20305 v_0 := v.Args[0] 20306 if v_0.Op != Op386MOVLconst { 20307 break 20308 } 20309 c := v_0.AuxInt 20310 x := v.Args[1] 20311 v.reset(Op386XORLconst) 20312 v.AuxInt = c 20313 v.AddArg(x) 20314 return true 20315 } 20316 // match: (XORL (SHLLconst [c] x) (SHRLconst [d] x)) 20317 // cond: d == 32-c 20318 // result: (ROLLconst [c] x) 20319 for { 20320 _ = v.Args[1] 20321 v_0 := v.Args[0] 20322 if v_0.Op != Op386SHLLconst { 20323 break 20324 } 20325 c := v_0.AuxInt 20326 x := v_0.Args[0] 20327 v_1 := v.Args[1] 20328 if v_1.Op != Op386SHRLconst { 20329 break 20330 } 20331 d := v_1.AuxInt 20332 if x != v_1.Args[0] { 20333 break 20334 } 20335 if !(d == 32-c) { 20336 break 20337 } 20338 v.reset(Op386ROLLconst) 20339 v.AuxInt = c 20340 v.AddArg(x) 20341 return true 20342 } 20343 // match: (XORL (SHRLconst [d] x) (SHLLconst [c] x)) 20344 // cond: d == 32-c 20345 // result: (ROLLconst [c] x) 20346 for { 20347 _ = v.Args[1] 20348 v_0 := v.Args[0] 20349 if v_0.Op != Op386SHRLconst { 20350 break 20351 } 20352 d := v_0.AuxInt 20353 x := v_0.Args[0] 20354 v_1 := v.Args[1] 20355 if v_1.Op != Op386SHLLconst { 20356 break 20357 } 20358 c := v_1.AuxInt 20359 if x != v_1.Args[0] { 20360 break 20361 } 20362 if !(d == 32-c) { 20363 break 20364 } 20365 v.reset(Op386ROLLconst) 20366 v.AuxInt = c 20367 v.AddArg(x) 20368 return true 20369 } 20370 // match: (XORL <t> (SHLLconst x [c]) (SHRWconst x [d])) 20371 // cond: c < 16 && d == 16-c && t.Size() == 2 20372 // result: (ROLWconst x [c]) 20373 for { 20374 t := v.Type 20375 _ = v.Args[1] 20376 v_0 := v.Args[0] 20377 if v_0.Op != Op386SHLLconst { 20378 break 20379 } 20380 c := v_0.AuxInt 20381 x := v_0.Args[0] 20382 v_1 := v.Args[1] 20383 if v_1.Op != Op386SHRWconst { 20384 break 20385 } 20386 d := v_1.AuxInt 20387 if x != v_1.Args[0] { 20388 break 20389 } 20390 if !(c < 16 && d == 16-c && t.Size() == 2) { 20391 break 20392 } 20393 v.reset(Op386ROLWconst) 20394 v.AuxInt = c 20395 v.AddArg(x) 20396 return true 20397 } 20398 // match: (XORL <t> (SHRWconst x [d]) (SHLLconst x [c])) 20399 // cond: c < 16 && d == 16-c && t.Size() == 2 20400 // result: (ROLWconst x [c]) 20401 for { 20402 t := v.Type 20403 _ = v.Args[1] 20404 v_0 := v.Args[0] 20405 if v_0.Op != Op386SHRWconst { 20406 break 20407 } 20408 d := v_0.AuxInt 20409 x := v_0.Args[0] 20410 v_1 := v.Args[1] 20411 if v_1.Op != Op386SHLLconst { 20412 break 20413 } 20414 c := v_1.AuxInt 20415 if x != v_1.Args[0] { 20416 break 20417 } 20418 if !(c < 16 && d == 16-c && t.Size() == 2) { 20419 break 20420 } 20421 v.reset(Op386ROLWconst) 20422 v.AuxInt = c 20423 v.AddArg(x) 20424 return true 20425 } 20426 // match: (XORL <t> (SHLLconst x [c]) (SHRBconst x [d])) 20427 // cond: c < 8 && d == 8-c && t.Size() == 1 20428 // result: (ROLBconst x [c]) 20429 for { 20430 t := v.Type 20431 _ = v.Args[1] 20432 v_0 := v.Args[0] 20433 if v_0.Op != Op386SHLLconst { 20434 break 20435 } 20436 c := v_0.AuxInt 20437 x := v_0.Args[0] 20438 v_1 := v.Args[1] 20439 if v_1.Op != Op386SHRBconst { 20440 break 20441 } 20442 d := v_1.AuxInt 20443 if x != v_1.Args[0] { 20444 break 20445 } 20446 if !(c < 8 && d == 8-c && t.Size() == 1) { 20447 break 20448 } 20449 v.reset(Op386ROLBconst) 20450 v.AuxInt = c 20451 v.AddArg(x) 20452 return true 20453 } 20454 // match: (XORL <t> (SHRBconst x [d]) (SHLLconst x [c])) 20455 // cond: c < 8 && d == 8-c && t.Size() == 1 20456 // result: (ROLBconst x [c]) 20457 for { 20458 t := v.Type 20459 _ = v.Args[1] 20460 v_0 := v.Args[0] 20461 if v_0.Op != Op386SHRBconst { 20462 break 20463 } 20464 d := v_0.AuxInt 20465 x := v_0.Args[0] 20466 v_1 := v.Args[1] 20467 if v_1.Op != Op386SHLLconst { 20468 break 20469 } 20470 c := v_1.AuxInt 20471 if x != v_1.Args[0] { 20472 break 20473 } 20474 if !(c < 8 && d == 8-c && t.Size() == 1) { 20475 break 20476 } 20477 v.reset(Op386ROLBconst) 20478 v.AuxInt = c 20479 v.AddArg(x) 20480 return true 20481 } 20482 // match: (XORL x l:(MOVLload [off] {sym} ptr mem)) 20483 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 20484 // result: (XORLload x [off] {sym} ptr mem) 20485 for { 20486 _ = v.Args[1] 20487 x := v.Args[0] 20488 l := v.Args[1] 20489 if l.Op != Op386MOVLload { 20490 break 20491 } 20492 off := l.AuxInt 20493 sym := l.Aux 20494 _ = l.Args[1] 20495 ptr := l.Args[0] 20496 mem := l.Args[1] 20497 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 20498 break 20499 } 20500 v.reset(Op386XORLload) 20501 v.AuxInt = off 20502 v.Aux = sym 20503 v.AddArg(x) 20504 v.AddArg(ptr) 20505 v.AddArg(mem) 20506 return true 20507 } 20508 // match: (XORL l:(MOVLload [off] {sym} ptr mem) x) 20509 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 20510 // result: (XORLload x [off] {sym} ptr mem) 20511 for { 20512 _ = v.Args[1] 20513 l := v.Args[0] 20514 if l.Op != Op386MOVLload { 20515 break 20516 } 20517 off := l.AuxInt 20518 sym := l.Aux 20519 _ = l.Args[1] 20520 ptr := l.Args[0] 20521 mem := l.Args[1] 20522 x := v.Args[1] 20523 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 20524 break 20525 } 20526 v.reset(Op386XORLload) 20527 v.AuxInt = off 20528 v.Aux = sym 20529 v.AddArg(x) 20530 v.AddArg(ptr) 20531 v.AddArg(mem) 20532 return true 20533 } 20534 return false 20535 } 20536 func rewriteValue386_Op386XORL_10(v *Value) bool { 20537 // match: (XORL x l:(MOVLloadidx4 [off] {sym} ptr idx mem)) 20538 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 20539 // result: (XORLloadidx4 x [off] {sym} ptr idx mem) 20540 for { 20541 _ = v.Args[1] 20542 x := v.Args[0] 20543 l := v.Args[1] 20544 if l.Op != Op386MOVLloadidx4 { 20545 break 20546 } 20547 off := l.AuxInt 20548 sym := l.Aux 20549 _ = l.Args[2] 20550 ptr := l.Args[0] 20551 idx := l.Args[1] 20552 mem := l.Args[2] 20553 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 20554 break 20555 } 20556 v.reset(Op386XORLloadidx4) 20557 v.AuxInt = off 20558 v.Aux = sym 20559 v.AddArg(x) 20560 v.AddArg(ptr) 20561 v.AddArg(idx) 20562 v.AddArg(mem) 20563 return true 20564 } 20565 // match: (XORL l:(MOVLloadidx4 [off] {sym} ptr idx mem) x) 20566 // cond: canMergeLoadClobber(v, l, x) && clobber(l) 20567 // result: (XORLloadidx4 x [off] {sym} ptr idx mem) 20568 for { 20569 _ = v.Args[1] 20570 l := v.Args[0] 20571 if l.Op != Op386MOVLloadidx4 { 20572 break 20573 } 20574 off := l.AuxInt 20575 sym := l.Aux 20576 _ = l.Args[2] 20577 ptr := l.Args[0] 20578 idx := l.Args[1] 20579 mem := l.Args[2] 20580 x := v.Args[1] 20581 if !(canMergeLoadClobber(v, l, x) && clobber(l)) { 20582 break 20583 } 20584 v.reset(Op386XORLloadidx4) 20585 v.AuxInt = off 20586 v.Aux = sym 20587 v.AddArg(x) 20588 v.AddArg(ptr) 20589 v.AddArg(idx) 20590 v.AddArg(mem) 20591 return true 20592 } 20593 // match: (XORL x x) 20594 // cond: 20595 // result: (MOVLconst [0]) 20596 for { 20597 _ = v.Args[1] 20598 x := v.Args[0] 20599 if x != v.Args[1] { 20600 break 20601 } 20602 v.reset(Op386MOVLconst) 20603 v.AuxInt = 0 20604 return true 20605 } 20606 return false 20607 } 20608 func rewriteValue386_Op386XORLconst_0(v *Value) bool { 20609 // match: (XORLconst [c] (XORLconst [d] x)) 20610 // cond: 20611 // result: (XORLconst [c ^ d] x) 20612 for { 20613 c := v.AuxInt 20614 v_0 := v.Args[0] 20615 if v_0.Op != Op386XORLconst { 20616 break 20617 } 20618 d := v_0.AuxInt 20619 x := v_0.Args[0] 20620 v.reset(Op386XORLconst) 20621 v.AuxInt = c ^ d 20622 v.AddArg(x) 20623 return true 20624 } 20625 // match: (XORLconst [c] x) 20626 // cond: int32(c)==0 20627 // result: x 20628 for { 20629 c := v.AuxInt 20630 x := v.Args[0] 20631 if !(int32(c) == 0) { 20632 break 20633 } 20634 v.reset(OpCopy) 20635 v.Type = x.Type 20636 v.AddArg(x) 20637 return true 20638 } 20639 // match: (XORLconst [c] (MOVLconst [d])) 20640 // cond: 20641 // result: (MOVLconst [c^d]) 20642 for { 20643 c := v.AuxInt 20644 v_0 := v.Args[0] 20645 if v_0.Op != Op386MOVLconst { 20646 break 20647 } 20648 d := v_0.AuxInt 20649 v.reset(Op386MOVLconst) 20650 v.AuxInt = c ^ d 20651 return true 20652 } 20653 return false 20654 } 20655 func rewriteValue386_Op386XORLconstmodify_0(v *Value) bool { 20656 b := v.Block 20657 _ = b 20658 config := b.Func.Config 20659 _ = config 20660 // match: (XORLconstmodify [valoff1] {sym} (ADDLconst [off2] base) mem) 20661 // cond: ValAndOff(valoff1).canAdd(off2) 20662 // result: (XORLconstmodify [ValAndOff(valoff1).add(off2)] {sym} base mem) 20663 for { 20664 valoff1 := v.AuxInt 20665 sym := v.Aux 20666 _ = v.Args[1] 20667 v_0 := v.Args[0] 20668 if v_0.Op != Op386ADDLconst { 20669 break 20670 } 20671 off2 := v_0.AuxInt 20672 base := v_0.Args[0] 20673 mem := v.Args[1] 20674 if !(ValAndOff(valoff1).canAdd(off2)) { 20675 break 20676 } 20677 v.reset(Op386XORLconstmodify) 20678 v.AuxInt = ValAndOff(valoff1).add(off2) 20679 v.Aux = sym 20680 v.AddArg(base) 20681 v.AddArg(mem) 20682 return true 20683 } 20684 // match: (XORLconstmodify [valoff1] {sym1} (LEAL [off2] {sym2} base) mem) 20685 // cond: ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 20686 // result: (XORLconstmodify [ValAndOff(valoff1).add(off2)] {mergeSym(sym1,sym2)} base mem) 20687 for { 20688 valoff1 := v.AuxInt 20689 sym1 := v.Aux 20690 _ = v.Args[1] 20691 v_0 := v.Args[0] 20692 if v_0.Op != Op386LEAL { 20693 break 20694 } 20695 off2 := v_0.AuxInt 20696 sym2 := v_0.Aux 20697 base := v_0.Args[0] 20698 mem := v.Args[1] 20699 if !(ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 20700 break 20701 } 20702 v.reset(Op386XORLconstmodify) 20703 v.AuxInt = ValAndOff(valoff1).add(off2) 20704 v.Aux = mergeSym(sym1, sym2) 20705 v.AddArg(base) 20706 v.AddArg(mem) 20707 return true 20708 } 20709 return false 20710 } 20711 func rewriteValue386_Op386XORLconstmodifyidx4_0(v *Value) bool { 20712 b := v.Block 20713 _ = b 20714 config := b.Func.Config 20715 _ = config 20716 // match: (XORLconstmodifyidx4 [valoff1] {sym} (ADDLconst [off2] base) idx mem) 20717 // cond: ValAndOff(valoff1).canAdd(off2) 20718 // result: (XORLconstmodifyidx4 [ValAndOff(valoff1).add(off2)] {sym} base idx mem) 20719 for { 20720 valoff1 := v.AuxInt 20721 sym := v.Aux 20722 _ = v.Args[2] 20723 v_0 := v.Args[0] 20724 if v_0.Op != Op386ADDLconst { 20725 break 20726 } 20727 off2 := v_0.AuxInt 20728 base := v_0.Args[0] 20729 idx := v.Args[1] 20730 mem := v.Args[2] 20731 if !(ValAndOff(valoff1).canAdd(off2)) { 20732 break 20733 } 20734 v.reset(Op386XORLconstmodifyidx4) 20735 v.AuxInt = ValAndOff(valoff1).add(off2) 20736 v.Aux = sym 20737 v.AddArg(base) 20738 v.AddArg(idx) 20739 v.AddArg(mem) 20740 return true 20741 } 20742 // match: (XORLconstmodifyidx4 [valoff1] {sym} base (ADDLconst [off2] idx) mem) 20743 // cond: ValAndOff(valoff1).canAdd(off2*4) 20744 // result: (XORLconstmodifyidx4 [ValAndOff(valoff1).add(off2*4)] {sym} base idx mem) 20745 for { 20746 valoff1 := v.AuxInt 20747 sym := v.Aux 20748 _ = v.Args[2] 20749 base := v.Args[0] 20750 v_1 := v.Args[1] 20751 if v_1.Op != Op386ADDLconst { 20752 break 20753 } 20754 off2 := v_1.AuxInt 20755 idx := v_1.Args[0] 20756 mem := v.Args[2] 20757 if !(ValAndOff(valoff1).canAdd(off2 * 4)) { 20758 break 20759 } 20760 v.reset(Op386XORLconstmodifyidx4) 20761 v.AuxInt = ValAndOff(valoff1).add(off2 * 4) 20762 v.Aux = sym 20763 v.AddArg(base) 20764 v.AddArg(idx) 20765 v.AddArg(mem) 20766 return true 20767 } 20768 // match: (XORLconstmodifyidx4 [valoff1] {sym1} (LEAL [off2] {sym2} base) idx mem) 20769 // cond: ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 20770 // result: (XORLconstmodifyidx4 [ValAndOff(valoff1).add(off2)] {mergeSym(sym1,sym2)} base idx mem) 20771 for { 20772 valoff1 := v.AuxInt 20773 sym1 := v.Aux 20774 _ = v.Args[2] 20775 v_0 := v.Args[0] 20776 if v_0.Op != Op386LEAL { 20777 break 20778 } 20779 off2 := v_0.AuxInt 20780 sym2 := v_0.Aux 20781 base := v_0.Args[0] 20782 idx := v.Args[1] 20783 mem := v.Args[2] 20784 if !(ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 20785 break 20786 } 20787 v.reset(Op386XORLconstmodifyidx4) 20788 v.AuxInt = ValAndOff(valoff1).add(off2) 20789 v.Aux = mergeSym(sym1, sym2) 20790 v.AddArg(base) 20791 v.AddArg(idx) 20792 v.AddArg(mem) 20793 return true 20794 } 20795 return false 20796 } 20797 func rewriteValue386_Op386XORLload_0(v *Value) bool { 20798 b := v.Block 20799 _ = b 20800 config := b.Func.Config 20801 _ = config 20802 // match: (XORLload [off1] {sym} val (ADDLconst [off2] base) mem) 20803 // cond: is32Bit(off1+off2) 20804 // result: (XORLload [off1+off2] {sym} val base mem) 20805 for { 20806 off1 := v.AuxInt 20807 sym := v.Aux 20808 _ = v.Args[2] 20809 val := v.Args[0] 20810 v_1 := v.Args[1] 20811 if v_1.Op != Op386ADDLconst { 20812 break 20813 } 20814 off2 := v_1.AuxInt 20815 base := v_1.Args[0] 20816 mem := v.Args[2] 20817 if !(is32Bit(off1 + off2)) { 20818 break 20819 } 20820 v.reset(Op386XORLload) 20821 v.AuxInt = off1 + off2 20822 v.Aux = sym 20823 v.AddArg(val) 20824 v.AddArg(base) 20825 v.AddArg(mem) 20826 return true 20827 } 20828 // match: (XORLload [off1] {sym1} val (LEAL [off2] {sym2} base) mem) 20829 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 20830 // result: (XORLload [off1+off2] {mergeSym(sym1,sym2)} val base mem) 20831 for { 20832 off1 := v.AuxInt 20833 sym1 := v.Aux 20834 _ = v.Args[2] 20835 val := v.Args[0] 20836 v_1 := v.Args[1] 20837 if v_1.Op != Op386LEAL { 20838 break 20839 } 20840 off2 := v_1.AuxInt 20841 sym2 := v_1.Aux 20842 base := v_1.Args[0] 20843 mem := v.Args[2] 20844 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 20845 break 20846 } 20847 v.reset(Op386XORLload) 20848 v.AuxInt = off1 + off2 20849 v.Aux = mergeSym(sym1, sym2) 20850 v.AddArg(val) 20851 v.AddArg(base) 20852 v.AddArg(mem) 20853 return true 20854 } 20855 // match: (XORLload [off1] {sym1} val (LEAL4 [off2] {sym2} ptr idx) mem) 20856 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) 20857 // result: (XORLloadidx4 [off1+off2] {mergeSym(sym1,sym2)} val ptr idx mem) 20858 for { 20859 off1 := v.AuxInt 20860 sym1 := v.Aux 20861 _ = v.Args[2] 20862 val := v.Args[0] 20863 v_1 := v.Args[1] 20864 if v_1.Op != Op386LEAL4 { 20865 break 20866 } 20867 off2 := v_1.AuxInt 20868 sym2 := v_1.Aux 20869 _ = v_1.Args[1] 20870 ptr := v_1.Args[0] 20871 idx := v_1.Args[1] 20872 mem := v.Args[2] 20873 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) { 20874 break 20875 } 20876 v.reset(Op386XORLloadidx4) 20877 v.AuxInt = off1 + off2 20878 v.Aux = mergeSym(sym1, sym2) 20879 v.AddArg(val) 20880 v.AddArg(ptr) 20881 v.AddArg(idx) 20882 v.AddArg(mem) 20883 return true 20884 } 20885 return false 20886 } 20887 func rewriteValue386_Op386XORLloadidx4_0(v *Value) bool { 20888 b := v.Block 20889 _ = b 20890 config := b.Func.Config 20891 _ = config 20892 // match: (XORLloadidx4 [off1] {sym} val (ADDLconst [off2] base) idx mem) 20893 // cond: is32Bit(off1+off2) 20894 // result: (XORLloadidx4 [off1+off2] {sym} val base idx mem) 20895 for { 20896 off1 := v.AuxInt 20897 sym := v.Aux 20898 _ = v.Args[3] 20899 val := v.Args[0] 20900 v_1 := v.Args[1] 20901 if v_1.Op != Op386ADDLconst { 20902 break 20903 } 20904 off2 := v_1.AuxInt 20905 base := v_1.Args[0] 20906 idx := v.Args[2] 20907 mem := v.Args[3] 20908 if !(is32Bit(off1 + off2)) { 20909 break 20910 } 20911 v.reset(Op386XORLloadidx4) 20912 v.AuxInt = off1 + off2 20913 v.Aux = sym 20914 v.AddArg(val) 20915 v.AddArg(base) 20916 v.AddArg(idx) 20917 v.AddArg(mem) 20918 return true 20919 } 20920 // match: (XORLloadidx4 [off1] {sym} val base (ADDLconst [off2] idx) mem) 20921 // cond: is32Bit(off1+off2*4) 20922 // result: (XORLloadidx4 [off1+off2*4] {sym} val base idx mem) 20923 for { 20924 off1 := v.AuxInt 20925 sym := v.Aux 20926 _ = v.Args[3] 20927 val := v.Args[0] 20928 base := v.Args[1] 20929 v_2 := v.Args[2] 20930 if v_2.Op != Op386ADDLconst { 20931 break 20932 } 20933 off2 := v_2.AuxInt 20934 idx := v_2.Args[0] 20935 mem := v.Args[3] 20936 if !(is32Bit(off1 + off2*4)) { 20937 break 20938 } 20939 v.reset(Op386XORLloadidx4) 20940 v.AuxInt = off1 + off2*4 20941 v.Aux = sym 20942 v.AddArg(val) 20943 v.AddArg(base) 20944 v.AddArg(idx) 20945 v.AddArg(mem) 20946 return true 20947 } 20948 // match: (XORLloadidx4 [off1] {sym1} val (LEAL [off2] {sym2} base) idx mem) 20949 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 20950 // result: (XORLloadidx4 [off1+off2] {mergeSym(sym1,sym2)} val base idx mem) 20951 for { 20952 off1 := v.AuxInt 20953 sym1 := v.Aux 20954 _ = v.Args[3] 20955 val := v.Args[0] 20956 v_1 := v.Args[1] 20957 if v_1.Op != Op386LEAL { 20958 break 20959 } 20960 off2 := v_1.AuxInt 20961 sym2 := v_1.Aux 20962 base := v_1.Args[0] 20963 idx := v.Args[2] 20964 mem := v.Args[3] 20965 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 20966 break 20967 } 20968 v.reset(Op386XORLloadidx4) 20969 v.AuxInt = off1 + off2 20970 v.Aux = mergeSym(sym1, sym2) 20971 v.AddArg(val) 20972 v.AddArg(base) 20973 v.AddArg(idx) 20974 v.AddArg(mem) 20975 return true 20976 } 20977 return false 20978 } 20979 func rewriteValue386_Op386XORLmodify_0(v *Value) bool { 20980 b := v.Block 20981 _ = b 20982 config := b.Func.Config 20983 _ = config 20984 // match: (XORLmodify [off1] {sym} (ADDLconst [off2] base) val mem) 20985 // cond: is32Bit(off1+off2) 20986 // result: (XORLmodify [off1+off2] {sym} base val mem) 20987 for { 20988 off1 := v.AuxInt 20989 sym := v.Aux 20990 _ = v.Args[2] 20991 v_0 := v.Args[0] 20992 if v_0.Op != Op386ADDLconst { 20993 break 20994 } 20995 off2 := v_0.AuxInt 20996 base := v_0.Args[0] 20997 val := v.Args[1] 20998 mem := v.Args[2] 20999 if !(is32Bit(off1 + off2)) { 21000 break 21001 } 21002 v.reset(Op386XORLmodify) 21003 v.AuxInt = off1 + off2 21004 v.Aux = sym 21005 v.AddArg(base) 21006 v.AddArg(val) 21007 v.AddArg(mem) 21008 return true 21009 } 21010 // match: (XORLmodify [off1] {sym1} (LEAL [off2] {sym2} base) val mem) 21011 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 21012 // result: (XORLmodify [off1+off2] {mergeSym(sym1,sym2)} base val mem) 21013 for { 21014 off1 := v.AuxInt 21015 sym1 := v.Aux 21016 _ = v.Args[2] 21017 v_0 := v.Args[0] 21018 if v_0.Op != Op386LEAL { 21019 break 21020 } 21021 off2 := v_0.AuxInt 21022 sym2 := v_0.Aux 21023 base := v_0.Args[0] 21024 val := v.Args[1] 21025 mem := v.Args[2] 21026 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 21027 break 21028 } 21029 v.reset(Op386XORLmodify) 21030 v.AuxInt = off1 + off2 21031 v.Aux = mergeSym(sym1, sym2) 21032 v.AddArg(base) 21033 v.AddArg(val) 21034 v.AddArg(mem) 21035 return true 21036 } 21037 return false 21038 } 21039 func rewriteValue386_Op386XORLmodifyidx4_0(v *Value) bool { 21040 b := v.Block 21041 _ = b 21042 config := b.Func.Config 21043 _ = config 21044 // match: (XORLmodifyidx4 [off1] {sym} (ADDLconst [off2] base) idx val mem) 21045 // cond: is32Bit(off1+off2) 21046 // result: (XORLmodifyidx4 [off1+off2] {sym} base idx val mem) 21047 for { 21048 off1 := v.AuxInt 21049 sym := v.Aux 21050 _ = v.Args[3] 21051 v_0 := v.Args[0] 21052 if v_0.Op != Op386ADDLconst { 21053 break 21054 } 21055 off2 := v_0.AuxInt 21056 base := v_0.Args[0] 21057 idx := v.Args[1] 21058 val := v.Args[2] 21059 mem := v.Args[3] 21060 if !(is32Bit(off1 + off2)) { 21061 break 21062 } 21063 v.reset(Op386XORLmodifyidx4) 21064 v.AuxInt = off1 + off2 21065 v.Aux = sym 21066 v.AddArg(base) 21067 v.AddArg(idx) 21068 v.AddArg(val) 21069 v.AddArg(mem) 21070 return true 21071 } 21072 // match: (XORLmodifyidx4 [off1] {sym} base (ADDLconst [off2] idx) val mem) 21073 // cond: is32Bit(off1+off2*4) 21074 // result: (XORLmodifyidx4 [off1+off2*4] {sym} base idx val mem) 21075 for { 21076 off1 := v.AuxInt 21077 sym := v.Aux 21078 _ = v.Args[3] 21079 base := v.Args[0] 21080 v_1 := v.Args[1] 21081 if v_1.Op != Op386ADDLconst { 21082 break 21083 } 21084 off2 := v_1.AuxInt 21085 idx := v_1.Args[0] 21086 val := v.Args[2] 21087 mem := v.Args[3] 21088 if !(is32Bit(off1 + off2*4)) { 21089 break 21090 } 21091 v.reset(Op386XORLmodifyidx4) 21092 v.AuxInt = off1 + off2*4 21093 v.Aux = sym 21094 v.AddArg(base) 21095 v.AddArg(idx) 21096 v.AddArg(val) 21097 v.AddArg(mem) 21098 return true 21099 } 21100 // match: (XORLmodifyidx4 [off1] {sym1} (LEAL [off2] {sym2} base) idx val mem) 21101 // cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared) 21102 // result: (XORLmodifyidx4 [off1+off2] {mergeSym(sym1,sym2)} base idx val mem) 21103 for { 21104 off1 := v.AuxInt 21105 sym1 := v.Aux 21106 _ = v.Args[3] 21107 v_0 := v.Args[0] 21108 if v_0.Op != Op386LEAL { 21109 break 21110 } 21111 off2 := v_0.AuxInt 21112 sym2 := v_0.Aux 21113 base := v_0.Args[0] 21114 idx := v.Args[1] 21115 val := v.Args[2] 21116 mem := v.Args[3] 21117 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) { 21118 break 21119 } 21120 v.reset(Op386XORLmodifyidx4) 21121 v.AuxInt = off1 + off2 21122 v.Aux = mergeSym(sym1, sym2) 21123 v.AddArg(base) 21124 v.AddArg(idx) 21125 v.AddArg(val) 21126 v.AddArg(mem) 21127 return true 21128 } 21129 // match: (XORLmodifyidx4 [off] {sym} ptr idx (MOVLconst [c]) mem) 21130 // cond: validValAndOff(c,off) 21131 // result: (XORLconstmodifyidx4 [makeValAndOff(c,off)] {sym} ptr idx mem) 21132 for { 21133 off := v.AuxInt 21134 sym := v.Aux 21135 _ = v.Args[3] 21136 ptr := v.Args[0] 21137 idx := v.Args[1] 21138 v_2 := v.Args[2] 21139 if v_2.Op != Op386MOVLconst { 21140 break 21141 } 21142 c := v_2.AuxInt 21143 mem := v.Args[3] 21144 if !(validValAndOff(c, off)) { 21145 break 21146 } 21147 v.reset(Op386XORLconstmodifyidx4) 21148 v.AuxInt = makeValAndOff(c, off) 21149 v.Aux = sym 21150 v.AddArg(ptr) 21151 v.AddArg(idx) 21152 v.AddArg(mem) 21153 return true 21154 } 21155 return false 21156 } 21157 func rewriteValue386_OpAdd16_0(v *Value) bool { 21158 // match: (Add16 x y) 21159 // cond: 21160 // result: (ADDL x y) 21161 for { 21162 _ = v.Args[1] 21163 x := v.Args[0] 21164 y := v.Args[1] 21165 v.reset(Op386ADDL) 21166 v.AddArg(x) 21167 v.AddArg(y) 21168 return true 21169 } 21170 } 21171 func rewriteValue386_OpAdd32_0(v *Value) bool { 21172 // match: (Add32 x y) 21173 // cond: 21174 // result: (ADDL x y) 21175 for { 21176 _ = v.Args[1] 21177 x := v.Args[0] 21178 y := v.Args[1] 21179 v.reset(Op386ADDL) 21180 v.AddArg(x) 21181 v.AddArg(y) 21182 return true 21183 } 21184 } 21185 func rewriteValue386_OpAdd32F_0(v *Value) bool { 21186 // match: (Add32F x y) 21187 // cond: 21188 // result: (ADDSS x y) 21189 for { 21190 _ = v.Args[1] 21191 x := v.Args[0] 21192 y := v.Args[1] 21193 v.reset(Op386ADDSS) 21194 v.AddArg(x) 21195 v.AddArg(y) 21196 return true 21197 } 21198 } 21199 func rewriteValue386_OpAdd32carry_0(v *Value) bool { 21200 // match: (Add32carry x y) 21201 // cond: 21202 // result: (ADDLcarry x y) 21203 for { 21204 _ = v.Args[1] 21205 x := v.Args[0] 21206 y := v.Args[1] 21207 v.reset(Op386ADDLcarry) 21208 v.AddArg(x) 21209 v.AddArg(y) 21210 return true 21211 } 21212 } 21213 func rewriteValue386_OpAdd32withcarry_0(v *Value) bool { 21214 // match: (Add32withcarry x y c) 21215 // cond: 21216 // result: (ADCL x y c) 21217 for { 21218 _ = v.Args[2] 21219 x := v.Args[0] 21220 y := v.Args[1] 21221 c := v.Args[2] 21222 v.reset(Op386ADCL) 21223 v.AddArg(x) 21224 v.AddArg(y) 21225 v.AddArg(c) 21226 return true 21227 } 21228 } 21229 func rewriteValue386_OpAdd64F_0(v *Value) bool { 21230 // match: (Add64F x y) 21231 // cond: 21232 // result: (ADDSD x y) 21233 for { 21234 _ = v.Args[1] 21235 x := v.Args[0] 21236 y := v.Args[1] 21237 v.reset(Op386ADDSD) 21238 v.AddArg(x) 21239 v.AddArg(y) 21240 return true 21241 } 21242 } 21243 func rewriteValue386_OpAdd8_0(v *Value) bool { 21244 // match: (Add8 x y) 21245 // cond: 21246 // result: (ADDL x y) 21247 for { 21248 _ = v.Args[1] 21249 x := v.Args[0] 21250 y := v.Args[1] 21251 v.reset(Op386ADDL) 21252 v.AddArg(x) 21253 v.AddArg(y) 21254 return true 21255 } 21256 } 21257 func rewriteValue386_OpAddPtr_0(v *Value) bool { 21258 // match: (AddPtr x y) 21259 // cond: 21260 // result: (ADDL x y) 21261 for { 21262 _ = v.Args[1] 21263 x := v.Args[0] 21264 y := v.Args[1] 21265 v.reset(Op386ADDL) 21266 v.AddArg(x) 21267 v.AddArg(y) 21268 return true 21269 } 21270 } 21271 func rewriteValue386_OpAddr_0(v *Value) bool { 21272 // match: (Addr {sym} base) 21273 // cond: 21274 // result: (LEAL {sym} base) 21275 for { 21276 sym := v.Aux 21277 base := v.Args[0] 21278 v.reset(Op386LEAL) 21279 v.Aux = sym 21280 v.AddArg(base) 21281 return true 21282 } 21283 } 21284 func rewriteValue386_OpAnd16_0(v *Value) bool { 21285 // match: (And16 x y) 21286 // cond: 21287 // result: (ANDL x y) 21288 for { 21289 _ = v.Args[1] 21290 x := v.Args[0] 21291 y := v.Args[1] 21292 v.reset(Op386ANDL) 21293 v.AddArg(x) 21294 v.AddArg(y) 21295 return true 21296 } 21297 } 21298 func rewriteValue386_OpAnd32_0(v *Value) bool { 21299 // match: (And32 x y) 21300 // cond: 21301 // result: (ANDL x y) 21302 for { 21303 _ = v.Args[1] 21304 x := v.Args[0] 21305 y := v.Args[1] 21306 v.reset(Op386ANDL) 21307 v.AddArg(x) 21308 v.AddArg(y) 21309 return true 21310 } 21311 } 21312 func rewriteValue386_OpAnd8_0(v *Value) bool { 21313 // match: (And8 x y) 21314 // cond: 21315 // result: (ANDL x y) 21316 for { 21317 _ = v.Args[1] 21318 x := v.Args[0] 21319 y := v.Args[1] 21320 v.reset(Op386ANDL) 21321 v.AddArg(x) 21322 v.AddArg(y) 21323 return true 21324 } 21325 } 21326 func rewriteValue386_OpAndB_0(v *Value) bool { 21327 // match: (AndB x y) 21328 // cond: 21329 // result: (ANDL x y) 21330 for { 21331 _ = v.Args[1] 21332 x := v.Args[0] 21333 y := v.Args[1] 21334 v.reset(Op386ANDL) 21335 v.AddArg(x) 21336 v.AddArg(y) 21337 return true 21338 } 21339 } 21340 func rewriteValue386_OpAvg32u_0(v *Value) bool { 21341 // match: (Avg32u x y) 21342 // cond: 21343 // result: (AVGLU x y) 21344 for { 21345 _ = v.Args[1] 21346 x := v.Args[0] 21347 y := v.Args[1] 21348 v.reset(Op386AVGLU) 21349 v.AddArg(x) 21350 v.AddArg(y) 21351 return true 21352 } 21353 } 21354 func rewriteValue386_OpBswap32_0(v *Value) bool { 21355 // match: (Bswap32 x) 21356 // cond: 21357 // result: (BSWAPL x) 21358 for { 21359 x := v.Args[0] 21360 v.reset(Op386BSWAPL) 21361 v.AddArg(x) 21362 return true 21363 } 21364 } 21365 func rewriteValue386_OpClosureCall_0(v *Value) bool { 21366 // match: (ClosureCall [argwid] entry closure mem) 21367 // cond: 21368 // result: (CALLclosure [argwid] entry closure mem) 21369 for { 21370 argwid := v.AuxInt 21371 _ = v.Args[2] 21372 entry := v.Args[0] 21373 closure := v.Args[1] 21374 mem := v.Args[2] 21375 v.reset(Op386CALLclosure) 21376 v.AuxInt = argwid 21377 v.AddArg(entry) 21378 v.AddArg(closure) 21379 v.AddArg(mem) 21380 return true 21381 } 21382 } 21383 func rewriteValue386_OpCom16_0(v *Value) bool { 21384 // match: (Com16 x) 21385 // cond: 21386 // result: (NOTL x) 21387 for { 21388 x := v.Args[0] 21389 v.reset(Op386NOTL) 21390 v.AddArg(x) 21391 return true 21392 } 21393 } 21394 func rewriteValue386_OpCom32_0(v *Value) bool { 21395 // match: (Com32 x) 21396 // cond: 21397 // result: (NOTL x) 21398 for { 21399 x := v.Args[0] 21400 v.reset(Op386NOTL) 21401 v.AddArg(x) 21402 return true 21403 } 21404 } 21405 func rewriteValue386_OpCom8_0(v *Value) bool { 21406 // match: (Com8 x) 21407 // cond: 21408 // result: (NOTL x) 21409 for { 21410 x := v.Args[0] 21411 v.reset(Op386NOTL) 21412 v.AddArg(x) 21413 return true 21414 } 21415 } 21416 func rewriteValue386_OpConst16_0(v *Value) bool { 21417 // match: (Const16 [val]) 21418 // cond: 21419 // result: (MOVLconst [val]) 21420 for { 21421 val := v.AuxInt 21422 v.reset(Op386MOVLconst) 21423 v.AuxInt = val 21424 return true 21425 } 21426 } 21427 func rewriteValue386_OpConst32_0(v *Value) bool { 21428 // match: (Const32 [val]) 21429 // cond: 21430 // result: (MOVLconst [val]) 21431 for { 21432 val := v.AuxInt 21433 v.reset(Op386MOVLconst) 21434 v.AuxInt = val 21435 return true 21436 } 21437 } 21438 func rewriteValue386_OpConst32F_0(v *Value) bool { 21439 // match: (Const32F [val]) 21440 // cond: 21441 // result: (MOVSSconst [val]) 21442 for { 21443 val := v.AuxInt 21444 v.reset(Op386MOVSSconst) 21445 v.AuxInt = val 21446 return true 21447 } 21448 } 21449 func rewriteValue386_OpConst64F_0(v *Value) bool { 21450 // match: (Const64F [val]) 21451 // cond: 21452 // result: (MOVSDconst [val]) 21453 for { 21454 val := v.AuxInt 21455 v.reset(Op386MOVSDconst) 21456 v.AuxInt = val 21457 return true 21458 } 21459 } 21460 func rewriteValue386_OpConst8_0(v *Value) bool { 21461 // match: (Const8 [val]) 21462 // cond: 21463 // result: (MOVLconst [val]) 21464 for { 21465 val := v.AuxInt 21466 v.reset(Op386MOVLconst) 21467 v.AuxInt = val 21468 return true 21469 } 21470 } 21471 func rewriteValue386_OpConstBool_0(v *Value) bool { 21472 // match: (ConstBool [b]) 21473 // cond: 21474 // result: (MOVLconst [b]) 21475 for { 21476 b := v.AuxInt 21477 v.reset(Op386MOVLconst) 21478 v.AuxInt = b 21479 return true 21480 } 21481 } 21482 func rewriteValue386_OpConstNil_0(v *Value) bool { 21483 // match: (ConstNil) 21484 // cond: 21485 // result: (MOVLconst [0]) 21486 for { 21487 v.reset(Op386MOVLconst) 21488 v.AuxInt = 0 21489 return true 21490 } 21491 } 21492 func rewriteValue386_OpCvt32Fto32_0(v *Value) bool { 21493 // match: (Cvt32Fto32 x) 21494 // cond: 21495 // result: (CVTTSS2SL x) 21496 for { 21497 x := v.Args[0] 21498 v.reset(Op386CVTTSS2SL) 21499 v.AddArg(x) 21500 return true 21501 } 21502 } 21503 func rewriteValue386_OpCvt32Fto64F_0(v *Value) bool { 21504 // match: (Cvt32Fto64F x) 21505 // cond: 21506 // result: (CVTSS2SD x) 21507 for { 21508 x := v.Args[0] 21509 v.reset(Op386CVTSS2SD) 21510 v.AddArg(x) 21511 return true 21512 } 21513 } 21514 func rewriteValue386_OpCvt32to32F_0(v *Value) bool { 21515 // match: (Cvt32to32F x) 21516 // cond: 21517 // result: (CVTSL2SS x) 21518 for { 21519 x := v.Args[0] 21520 v.reset(Op386CVTSL2SS) 21521 v.AddArg(x) 21522 return true 21523 } 21524 } 21525 func rewriteValue386_OpCvt32to64F_0(v *Value) bool { 21526 // match: (Cvt32to64F x) 21527 // cond: 21528 // result: (CVTSL2SD x) 21529 for { 21530 x := v.Args[0] 21531 v.reset(Op386CVTSL2SD) 21532 v.AddArg(x) 21533 return true 21534 } 21535 } 21536 func rewriteValue386_OpCvt64Fto32_0(v *Value) bool { 21537 // match: (Cvt64Fto32 x) 21538 // cond: 21539 // result: (CVTTSD2SL x) 21540 for { 21541 x := v.Args[0] 21542 v.reset(Op386CVTTSD2SL) 21543 v.AddArg(x) 21544 return true 21545 } 21546 } 21547 func rewriteValue386_OpCvt64Fto32F_0(v *Value) bool { 21548 // match: (Cvt64Fto32F x) 21549 // cond: 21550 // result: (CVTSD2SS x) 21551 for { 21552 x := v.Args[0] 21553 v.reset(Op386CVTSD2SS) 21554 v.AddArg(x) 21555 return true 21556 } 21557 } 21558 func rewriteValue386_OpDiv16_0(v *Value) bool { 21559 // match: (Div16 [a] x y) 21560 // cond: 21561 // result: (DIVW [a] x y) 21562 for { 21563 a := v.AuxInt 21564 _ = v.Args[1] 21565 x := v.Args[0] 21566 y := v.Args[1] 21567 v.reset(Op386DIVW) 21568 v.AuxInt = a 21569 v.AddArg(x) 21570 v.AddArg(y) 21571 return true 21572 } 21573 } 21574 func rewriteValue386_OpDiv16u_0(v *Value) bool { 21575 // match: (Div16u x y) 21576 // cond: 21577 // result: (DIVWU x y) 21578 for { 21579 _ = v.Args[1] 21580 x := v.Args[0] 21581 y := v.Args[1] 21582 v.reset(Op386DIVWU) 21583 v.AddArg(x) 21584 v.AddArg(y) 21585 return true 21586 } 21587 } 21588 func rewriteValue386_OpDiv32_0(v *Value) bool { 21589 // match: (Div32 [a] x y) 21590 // cond: 21591 // result: (DIVL [a] x y) 21592 for { 21593 a := v.AuxInt 21594 _ = v.Args[1] 21595 x := v.Args[0] 21596 y := v.Args[1] 21597 v.reset(Op386DIVL) 21598 v.AuxInt = a 21599 v.AddArg(x) 21600 v.AddArg(y) 21601 return true 21602 } 21603 } 21604 func rewriteValue386_OpDiv32F_0(v *Value) bool { 21605 // match: (Div32F x y) 21606 // cond: 21607 // result: (DIVSS x y) 21608 for { 21609 _ = v.Args[1] 21610 x := v.Args[0] 21611 y := v.Args[1] 21612 v.reset(Op386DIVSS) 21613 v.AddArg(x) 21614 v.AddArg(y) 21615 return true 21616 } 21617 } 21618 func rewriteValue386_OpDiv32u_0(v *Value) bool { 21619 // match: (Div32u x y) 21620 // cond: 21621 // result: (DIVLU x y) 21622 for { 21623 _ = v.Args[1] 21624 x := v.Args[0] 21625 y := v.Args[1] 21626 v.reset(Op386DIVLU) 21627 v.AddArg(x) 21628 v.AddArg(y) 21629 return true 21630 } 21631 } 21632 func rewriteValue386_OpDiv64F_0(v *Value) bool { 21633 // match: (Div64F x y) 21634 // cond: 21635 // result: (DIVSD x y) 21636 for { 21637 _ = v.Args[1] 21638 x := v.Args[0] 21639 y := v.Args[1] 21640 v.reset(Op386DIVSD) 21641 v.AddArg(x) 21642 v.AddArg(y) 21643 return true 21644 } 21645 } 21646 func rewriteValue386_OpDiv8_0(v *Value) bool { 21647 b := v.Block 21648 _ = b 21649 typ := &b.Func.Config.Types 21650 _ = typ 21651 // match: (Div8 x y) 21652 // cond: 21653 // result: (DIVW (SignExt8to16 x) (SignExt8to16 y)) 21654 for { 21655 _ = v.Args[1] 21656 x := v.Args[0] 21657 y := v.Args[1] 21658 v.reset(Op386DIVW) 21659 v0 := b.NewValue0(v.Pos, OpSignExt8to16, typ.Int16) 21660 v0.AddArg(x) 21661 v.AddArg(v0) 21662 v1 := b.NewValue0(v.Pos, OpSignExt8to16, typ.Int16) 21663 v1.AddArg(y) 21664 v.AddArg(v1) 21665 return true 21666 } 21667 } 21668 func rewriteValue386_OpDiv8u_0(v *Value) bool { 21669 b := v.Block 21670 _ = b 21671 typ := &b.Func.Config.Types 21672 _ = typ 21673 // match: (Div8u x y) 21674 // cond: 21675 // result: (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y)) 21676 for { 21677 _ = v.Args[1] 21678 x := v.Args[0] 21679 y := v.Args[1] 21680 v.reset(Op386DIVWU) 21681 v0 := b.NewValue0(v.Pos, OpZeroExt8to16, typ.UInt16) 21682 v0.AddArg(x) 21683 v.AddArg(v0) 21684 v1 := b.NewValue0(v.Pos, OpZeroExt8to16, typ.UInt16) 21685 v1.AddArg(y) 21686 v.AddArg(v1) 21687 return true 21688 } 21689 } 21690 func rewriteValue386_OpEq16_0(v *Value) bool { 21691 b := v.Block 21692 _ = b 21693 // match: (Eq16 x y) 21694 // cond: 21695 // result: (SETEQ (CMPW x y)) 21696 for { 21697 _ = v.Args[1] 21698 x := v.Args[0] 21699 y := v.Args[1] 21700 v.reset(Op386SETEQ) 21701 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags) 21702 v0.AddArg(x) 21703 v0.AddArg(y) 21704 v.AddArg(v0) 21705 return true 21706 } 21707 } 21708 func rewriteValue386_OpEq32_0(v *Value) bool { 21709 b := v.Block 21710 _ = b 21711 // match: (Eq32 x y) 21712 // cond: 21713 // result: (SETEQ (CMPL x y)) 21714 for { 21715 _ = v.Args[1] 21716 x := v.Args[0] 21717 y := v.Args[1] 21718 v.reset(Op386SETEQ) 21719 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) 21720 v0.AddArg(x) 21721 v0.AddArg(y) 21722 v.AddArg(v0) 21723 return true 21724 } 21725 } 21726 func rewriteValue386_OpEq32F_0(v *Value) bool { 21727 b := v.Block 21728 _ = b 21729 // match: (Eq32F x y) 21730 // cond: 21731 // result: (SETEQF (UCOMISS x y)) 21732 for { 21733 _ = v.Args[1] 21734 x := v.Args[0] 21735 y := v.Args[1] 21736 v.reset(Op386SETEQF) 21737 v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags) 21738 v0.AddArg(x) 21739 v0.AddArg(y) 21740 v.AddArg(v0) 21741 return true 21742 } 21743 } 21744 func rewriteValue386_OpEq64F_0(v *Value) bool { 21745 b := v.Block 21746 _ = b 21747 // match: (Eq64F x y) 21748 // cond: 21749 // result: (SETEQF (UCOMISD x y)) 21750 for { 21751 _ = v.Args[1] 21752 x := v.Args[0] 21753 y := v.Args[1] 21754 v.reset(Op386SETEQF) 21755 v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags) 21756 v0.AddArg(x) 21757 v0.AddArg(y) 21758 v.AddArg(v0) 21759 return true 21760 } 21761 } 21762 func rewriteValue386_OpEq8_0(v *Value) bool { 21763 b := v.Block 21764 _ = b 21765 // match: (Eq8 x y) 21766 // cond: 21767 // result: (SETEQ (CMPB x y)) 21768 for { 21769 _ = v.Args[1] 21770 x := v.Args[0] 21771 y := v.Args[1] 21772 v.reset(Op386SETEQ) 21773 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags) 21774 v0.AddArg(x) 21775 v0.AddArg(y) 21776 v.AddArg(v0) 21777 return true 21778 } 21779 } 21780 func rewriteValue386_OpEqB_0(v *Value) bool { 21781 b := v.Block 21782 _ = b 21783 // match: (EqB x y) 21784 // cond: 21785 // result: (SETEQ (CMPB x y)) 21786 for { 21787 _ = v.Args[1] 21788 x := v.Args[0] 21789 y := v.Args[1] 21790 v.reset(Op386SETEQ) 21791 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags) 21792 v0.AddArg(x) 21793 v0.AddArg(y) 21794 v.AddArg(v0) 21795 return true 21796 } 21797 } 21798 func rewriteValue386_OpEqPtr_0(v *Value) bool { 21799 b := v.Block 21800 _ = b 21801 // match: (EqPtr x y) 21802 // cond: 21803 // result: (SETEQ (CMPL x y)) 21804 for { 21805 _ = v.Args[1] 21806 x := v.Args[0] 21807 y := v.Args[1] 21808 v.reset(Op386SETEQ) 21809 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) 21810 v0.AddArg(x) 21811 v0.AddArg(y) 21812 v.AddArg(v0) 21813 return true 21814 } 21815 } 21816 func rewriteValue386_OpGeq16_0(v *Value) bool { 21817 b := v.Block 21818 _ = b 21819 // match: (Geq16 x y) 21820 // cond: 21821 // result: (SETGE (CMPW x y)) 21822 for { 21823 _ = v.Args[1] 21824 x := v.Args[0] 21825 y := v.Args[1] 21826 v.reset(Op386SETGE) 21827 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags) 21828 v0.AddArg(x) 21829 v0.AddArg(y) 21830 v.AddArg(v0) 21831 return true 21832 } 21833 } 21834 func rewriteValue386_OpGeq16U_0(v *Value) bool { 21835 b := v.Block 21836 _ = b 21837 // match: (Geq16U x y) 21838 // cond: 21839 // result: (SETAE (CMPW x y)) 21840 for { 21841 _ = v.Args[1] 21842 x := v.Args[0] 21843 y := v.Args[1] 21844 v.reset(Op386SETAE) 21845 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags) 21846 v0.AddArg(x) 21847 v0.AddArg(y) 21848 v.AddArg(v0) 21849 return true 21850 } 21851 } 21852 func rewriteValue386_OpGeq32_0(v *Value) bool { 21853 b := v.Block 21854 _ = b 21855 // match: (Geq32 x y) 21856 // cond: 21857 // result: (SETGE (CMPL x y)) 21858 for { 21859 _ = v.Args[1] 21860 x := v.Args[0] 21861 y := v.Args[1] 21862 v.reset(Op386SETGE) 21863 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) 21864 v0.AddArg(x) 21865 v0.AddArg(y) 21866 v.AddArg(v0) 21867 return true 21868 } 21869 } 21870 func rewriteValue386_OpGeq32F_0(v *Value) bool { 21871 b := v.Block 21872 _ = b 21873 // match: (Geq32F x y) 21874 // cond: 21875 // result: (SETGEF (UCOMISS x y)) 21876 for { 21877 _ = v.Args[1] 21878 x := v.Args[0] 21879 y := v.Args[1] 21880 v.reset(Op386SETGEF) 21881 v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags) 21882 v0.AddArg(x) 21883 v0.AddArg(y) 21884 v.AddArg(v0) 21885 return true 21886 } 21887 } 21888 func rewriteValue386_OpGeq32U_0(v *Value) bool { 21889 b := v.Block 21890 _ = b 21891 // match: (Geq32U x y) 21892 // cond: 21893 // result: (SETAE (CMPL x y)) 21894 for { 21895 _ = v.Args[1] 21896 x := v.Args[0] 21897 y := v.Args[1] 21898 v.reset(Op386SETAE) 21899 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) 21900 v0.AddArg(x) 21901 v0.AddArg(y) 21902 v.AddArg(v0) 21903 return true 21904 } 21905 } 21906 func rewriteValue386_OpGeq64F_0(v *Value) bool { 21907 b := v.Block 21908 _ = b 21909 // match: (Geq64F x y) 21910 // cond: 21911 // result: (SETGEF (UCOMISD x y)) 21912 for { 21913 _ = v.Args[1] 21914 x := v.Args[0] 21915 y := v.Args[1] 21916 v.reset(Op386SETGEF) 21917 v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags) 21918 v0.AddArg(x) 21919 v0.AddArg(y) 21920 v.AddArg(v0) 21921 return true 21922 } 21923 } 21924 func rewriteValue386_OpGeq8_0(v *Value) bool { 21925 b := v.Block 21926 _ = b 21927 // match: (Geq8 x y) 21928 // cond: 21929 // result: (SETGE (CMPB x y)) 21930 for { 21931 _ = v.Args[1] 21932 x := v.Args[0] 21933 y := v.Args[1] 21934 v.reset(Op386SETGE) 21935 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags) 21936 v0.AddArg(x) 21937 v0.AddArg(y) 21938 v.AddArg(v0) 21939 return true 21940 } 21941 } 21942 func rewriteValue386_OpGeq8U_0(v *Value) bool { 21943 b := v.Block 21944 _ = b 21945 // match: (Geq8U x y) 21946 // cond: 21947 // result: (SETAE (CMPB x y)) 21948 for { 21949 _ = v.Args[1] 21950 x := v.Args[0] 21951 y := v.Args[1] 21952 v.reset(Op386SETAE) 21953 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags) 21954 v0.AddArg(x) 21955 v0.AddArg(y) 21956 v.AddArg(v0) 21957 return true 21958 } 21959 } 21960 func rewriteValue386_OpGetCallerPC_0(v *Value) bool { 21961 // match: (GetCallerPC) 21962 // cond: 21963 // result: (LoweredGetCallerPC) 21964 for { 21965 v.reset(Op386LoweredGetCallerPC) 21966 return true 21967 } 21968 } 21969 func rewriteValue386_OpGetCallerSP_0(v *Value) bool { 21970 // match: (GetCallerSP) 21971 // cond: 21972 // result: (LoweredGetCallerSP) 21973 for { 21974 v.reset(Op386LoweredGetCallerSP) 21975 return true 21976 } 21977 } 21978 func rewriteValue386_OpGetClosurePtr_0(v *Value) bool { 21979 // match: (GetClosurePtr) 21980 // cond: 21981 // result: (LoweredGetClosurePtr) 21982 for { 21983 v.reset(Op386LoweredGetClosurePtr) 21984 return true 21985 } 21986 } 21987 func rewriteValue386_OpGetG_0(v *Value) bool { 21988 // match: (GetG mem) 21989 // cond: 21990 // result: (LoweredGetG mem) 21991 for { 21992 mem := v.Args[0] 21993 v.reset(Op386LoweredGetG) 21994 v.AddArg(mem) 21995 return true 21996 } 21997 } 21998 func rewriteValue386_OpGreater16_0(v *Value) bool { 21999 b := v.Block 22000 _ = b 22001 // match: (Greater16 x y) 22002 // cond: 22003 // result: (SETG (CMPW x y)) 22004 for { 22005 _ = v.Args[1] 22006 x := v.Args[0] 22007 y := v.Args[1] 22008 v.reset(Op386SETG) 22009 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags) 22010 v0.AddArg(x) 22011 v0.AddArg(y) 22012 v.AddArg(v0) 22013 return true 22014 } 22015 } 22016 func rewriteValue386_OpGreater16U_0(v *Value) bool { 22017 b := v.Block 22018 _ = b 22019 // match: (Greater16U x y) 22020 // cond: 22021 // result: (SETA (CMPW x y)) 22022 for { 22023 _ = v.Args[1] 22024 x := v.Args[0] 22025 y := v.Args[1] 22026 v.reset(Op386SETA) 22027 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags) 22028 v0.AddArg(x) 22029 v0.AddArg(y) 22030 v.AddArg(v0) 22031 return true 22032 } 22033 } 22034 func rewriteValue386_OpGreater32_0(v *Value) bool { 22035 b := v.Block 22036 _ = b 22037 // match: (Greater32 x y) 22038 // cond: 22039 // result: (SETG (CMPL x y)) 22040 for { 22041 _ = v.Args[1] 22042 x := v.Args[0] 22043 y := v.Args[1] 22044 v.reset(Op386SETG) 22045 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) 22046 v0.AddArg(x) 22047 v0.AddArg(y) 22048 v.AddArg(v0) 22049 return true 22050 } 22051 } 22052 func rewriteValue386_OpGreater32F_0(v *Value) bool { 22053 b := v.Block 22054 _ = b 22055 // match: (Greater32F x y) 22056 // cond: 22057 // result: (SETGF (UCOMISS x y)) 22058 for { 22059 _ = v.Args[1] 22060 x := v.Args[0] 22061 y := v.Args[1] 22062 v.reset(Op386SETGF) 22063 v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags) 22064 v0.AddArg(x) 22065 v0.AddArg(y) 22066 v.AddArg(v0) 22067 return true 22068 } 22069 } 22070 func rewriteValue386_OpGreater32U_0(v *Value) bool { 22071 b := v.Block 22072 _ = b 22073 // match: (Greater32U x y) 22074 // cond: 22075 // result: (SETA (CMPL x y)) 22076 for { 22077 _ = v.Args[1] 22078 x := v.Args[0] 22079 y := v.Args[1] 22080 v.reset(Op386SETA) 22081 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) 22082 v0.AddArg(x) 22083 v0.AddArg(y) 22084 v.AddArg(v0) 22085 return true 22086 } 22087 } 22088 func rewriteValue386_OpGreater64F_0(v *Value) bool { 22089 b := v.Block 22090 _ = b 22091 // match: (Greater64F x y) 22092 // cond: 22093 // result: (SETGF (UCOMISD x y)) 22094 for { 22095 _ = v.Args[1] 22096 x := v.Args[0] 22097 y := v.Args[1] 22098 v.reset(Op386SETGF) 22099 v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags) 22100 v0.AddArg(x) 22101 v0.AddArg(y) 22102 v.AddArg(v0) 22103 return true 22104 } 22105 } 22106 func rewriteValue386_OpGreater8_0(v *Value) bool { 22107 b := v.Block 22108 _ = b 22109 // match: (Greater8 x y) 22110 // cond: 22111 // result: (SETG (CMPB x y)) 22112 for { 22113 _ = v.Args[1] 22114 x := v.Args[0] 22115 y := v.Args[1] 22116 v.reset(Op386SETG) 22117 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags) 22118 v0.AddArg(x) 22119 v0.AddArg(y) 22120 v.AddArg(v0) 22121 return true 22122 } 22123 } 22124 func rewriteValue386_OpGreater8U_0(v *Value) bool { 22125 b := v.Block 22126 _ = b 22127 // match: (Greater8U x y) 22128 // cond: 22129 // result: (SETA (CMPB x y)) 22130 for { 22131 _ = v.Args[1] 22132 x := v.Args[0] 22133 y := v.Args[1] 22134 v.reset(Op386SETA) 22135 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags) 22136 v0.AddArg(x) 22137 v0.AddArg(y) 22138 v.AddArg(v0) 22139 return true 22140 } 22141 } 22142 func rewriteValue386_OpHmul32_0(v *Value) bool { 22143 // match: (Hmul32 x y) 22144 // cond: 22145 // result: (HMULL x y) 22146 for { 22147 _ = v.Args[1] 22148 x := v.Args[0] 22149 y := v.Args[1] 22150 v.reset(Op386HMULL) 22151 v.AddArg(x) 22152 v.AddArg(y) 22153 return true 22154 } 22155 } 22156 func rewriteValue386_OpHmul32u_0(v *Value) bool { 22157 // match: (Hmul32u x y) 22158 // cond: 22159 // result: (HMULLU x y) 22160 for { 22161 _ = v.Args[1] 22162 x := v.Args[0] 22163 y := v.Args[1] 22164 v.reset(Op386HMULLU) 22165 v.AddArg(x) 22166 v.AddArg(y) 22167 return true 22168 } 22169 } 22170 func rewriteValue386_OpInterCall_0(v *Value) bool { 22171 // match: (InterCall [argwid] entry mem) 22172 // cond: 22173 // result: (CALLinter [argwid] entry mem) 22174 for { 22175 argwid := v.AuxInt 22176 _ = v.Args[1] 22177 entry := v.Args[0] 22178 mem := v.Args[1] 22179 v.reset(Op386CALLinter) 22180 v.AuxInt = argwid 22181 v.AddArg(entry) 22182 v.AddArg(mem) 22183 return true 22184 } 22185 } 22186 func rewriteValue386_OpIsInBounds_0(v *Value) bool { 22187 b := v.Block 22188 _ = b 22189 // match: (IsInBounds idx len) 22190 // cond: 22191 // result: (SETB (CMPL idx len)) 22192 for { 22193 _ = v.Args[1] 22194 idx := v.Args[0] 22195 len := v.Args[1] 22196 v.reset(Op386SETB) 22197 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) 22198 v0.AddArg(idx) 22199 v0.AddArg(len) 22200 v.AddArg(v0) 22201 return true 22202 } 22203 } 22204 func rewriteValue386_OpIsNonNil_0(v *Value) bool { 22205 b := v.Block 22206 _ = b 22207 // match: (IsNonNil p) 22208 // cond: 22209 // result: (SETNE (TESTL p p)) 22210 for { 22211 p := v.Args[0] 22212 v.reset(Op386SETNE) 22213 v0 := b.NewValue0(v.Pos, Op386TESTL, types.TypeFlags) 22214 v0.AddArg(p) 22215 v0.AddArg(p) 22216 v.AddArg(v0) 22217 return true 22218 } 22219 } 22220 func rewriteValue386_OpIsSliceInBounds_0(v *Value) bool { 22221 b := v.Block 22222 _ = b 22223 // match: (IsSliceInBounds idx len) 22224 // cond: 22225 // result: (SETBE (CMPL idx len)) 22226 for { 22227 _ = v.Args[1] 22228 idx := v.Args[0] 22229 len := v.Args[1] 22230 v.reset(Op386SETBE) 22231 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) 22232 v0.AddArg(idx) 22233 v0.AddArg(len) 22234 v.AddArg(v0) 22235 return true 22236 } 22237 } 22238 func rewriteValue386_OpLeq16_0(v *Value) bool { 22239 b := v.Block 22240 _ = b 22241 // match: (Leq16 x y) 22242 // cond: 22243 // result: (SETLE (CMPW x y)) 22244 for { 22245 _ = v.Args[1] 22246 x := v.Args[0] 22247 y := v.Args[1] 22248 v.reset(Op386SETLE) 22249 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags) 22250 v0.AddArg(x) 22251 v0.AddArg(y) 22252 v.AddArg(v0) 22253 return true 22254 } 22255 } 22256 func rewriteValue386_OpLeq16U_0(v *Value) bool { 22257 b := v.Block 22258 _ = b 22259 // match: (Leq16U x y) 22260 // cond: 22261 // result: (SETBE (CMPW x y)) 22262 for { 22263 _ = v.Args[1] 22264 x := v.Args[0] 22265 y := v.Args[1] 22266 v.reset(Op386SETBE) 22267 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags) 22268 v0.AddArg(x) 22269 v0.AddArg(y) 22270 v.AddArg(v0) 22271 return true 22272 } 22273 } 22274 func rewriteValue386_OpLeq32_0(v *Value) bool { 22275 b := v.Block 22276 _ = b 22277 // match: (Leq32 x y) 22278 // cond: 22279 // result: (SETLE (CMPL x y)) 22280 for { 22281 _ = v.Args[1] 22282 x := v.Args[0] 22283 y := v.Args[1] 22284 v.reset(Op386SETLE) 22285 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) 22286 v0.AddArg(x) 22287 v0.AddArg(y) 22288 v.AddArg(v0) 22289 return true 22290 } 22291 } 22292 func rewriteValue386_OpLeq32F_0(v *Value) bool { 22293 b := v.Block 22294 _ = b 22295 // match: (Leq32F x y) 22296 // cond: 22297 // result: (SETGEF (UCOMISS y x)) 22298 for { 22299 _ = v.Args[1] 22300 x := v.Args[0] 22301 y := v.Args[1] 22302 v.reset(Op386SETGEF) 22303 v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags) 22304 v0.AddArg(y) 22305 v0.AddArg(x) 22306 v.AddArg(v0) 22307 return true 22308 } 22309 } 22310 func rewriteValue386_OpLeq32U_0(v *Value) bool { 22311 b := v.Block 22312 _ = b 22313 // match: (Leq32U x y) 22314 // cond: 22315 // result: (SETBE (CMPL x y)) 22316 for { 22317 _ = v.Args[1] 22318 x := v.Args[0] 22319 y := v.Args[1] 22320 v.reset(Op386SETBE) 22321 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) 22322 v0.AddArg(x) 22323 v0.AddArg(y) 22324 v.AddArg(v0) 22325 return true 22326 } 22327 } 22328 func rewriteValue386_OpLeq64F_0(v *Value) bool { 22329 b := v.Block 22330 _ = b 22331 // match: (Leq64F x y) 22332 // cond: 22333 // result: (SETGEF (UCOMISD y x)) 22334 for { 22335 _ = v.Args[1] 22336 x := v.Args[0] 22337 y := v.Args[1] 22338 v.reset(Op386SETGEF) 22339 v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags) 22340 v0.AddArg(y) 22341 v0.AddArg(x) 22342 v.AddArg(v0) 22343 return true 22344 } 22345 } 22346 func rewriteValue386_OpLeq8_0(v *Value) bool { 22347 b := v.Block 22348 _ = b 22349 // match: (Leq8 x y) 22350 // cond: 22351 // result: (SETLE (CMPB x y)) 22352 for { 22353 _ = v.Args[1] 22354 x := v.Args[0] 22355 y := v.Args[1] 22356 v.reset(Op386SETLE) 22357 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags) 22358 v0.AddArg(x) 22359 v0.AddArg(y) 22360 v.AddArg(v0) 22361 return true 22362 } 22363 } 22364 func rewriteValue386_OpLeq8U_0(v *Value) bool { 22365 b := v.Block 22366 _ = b 22367 // match: (Leq8U x y) 22368 // cond: 22369 // result: (SETBE (CMPB x y)) 22370 for { 22371 _ = v.Args[1] 22372 x := v.Args[0] 22373 y := v.Args[1] 22374 v.reset(Op386SETBE) 22375 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags) 22376 v0.AddArg(x) 22377 v0.AddArg(y) 22378 v.AddArg(v0) 22379 return true 22380 } 22381 } 22382 func rewriteValue386_OpLess16_0(v *Value) bool { 22383 b := v.Block 22384 _ = b 22385 // match: (Less16 x y) 22386 // cond: 22387 // result: (SETL (CMPW x y)) 22388 for { 22389 _ = v.Args[1] 22390 x := v.Args[0] 22391 y := v.Args[1] 22392 v.reset(Op386SETL) 22393 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags) 22394 v0.AddArg(x) 22395 v0.AddArg(y) 22396 v.AddArg(v0) 22397 return true 22398 } 22399 } 22400 func rewriteValue386_OpLess16U_0(v *Value) bool { 22401 b := v.Block 22402 _ = b 22403 // match: (Less16U x y) 22404 // cond: 22405 // result: (SETB (CMPW x y)) 22406 for { 22407 _ = v.Args[1] 22408 x := v.Args[0] 22409 y := v.Args[1] 22410 v.reset(Op386SETB) 22411 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags) 22412 v0.AddArg(x) 22413 v0.AddArg(y) 22414 v.AddArg(v0) 22415 return true 22416 } 22417 } 22418 func rewriteValue386_OpLess32_0(v *Value) bool { 22419 b := v.Block 22420 _ = b 22421 // match: (Less32 x y) 22422 // cond: 22423 // result: (SETL (CMPL x y)) 22424 for { 22425 _ = v.Args[1] 22426 x := v.Args[0] 22427 y := v.Args[1] 22428 v.reset(Op386SETL) 22429 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) 22430 v0.AddArg(x) 22431 v0.AddArg(y) 22432 v.AddArg(v0) 22433 return true 22434 } 22435 } 22436 func rewriteValue386_OpLess32F_0(v *Value) bool { 22437 b := v.Block 22438 _ = b 22439 // match: (Less32F x y) 22440 // cond: 22441 // result: (SETGF (UCOMISS y x)) 22442 for { 22443 _ = v.Args[1] 22444 x := v.Args[0] 22445 y := v.Args[1] 22446 v.reset(Op386SETGF) 22447 v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags) 22448 v0.AddArg(y) 22449 v0.AddArg(x) 22450 v.AddArg(v0) 22451 return true 22452 } 22453 } 22454 func rewriteValue386_OpLess32U_0(v *Value) bool { 22455 b := v.Block 22456 _ = b 22457 // match: (Less32U x y) 22458 // cond: 22459 // result: (SETB (CMPL x y)) 22460 for { 22461 _ = v.Args[1] 22462 x := v.Args[0] 22463 y := v.Args[1] 22464 v.reset(Op386SETB) 22465 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) 22466 v0.AddArg(x) 22467 v0.AddArg(y) 22468 v.AddArg(v0) 22469 return true 22470 } 22471 } 22472 func rewriteValue386_OpLess64F_0(v *Value) bool { 22473 b := v.Block 22474 _ = b 22475 // match: (Less64F x y) 22476 // cond: 22477 // result: (SETGF (UCOMISD y x)) 22478 for { 22479 _ = v.Args[1] 22480 x := v.Args[0] 22481 y := v.Args[1] 22482 v.reset(Op386SETGF) 22483 v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags) 22484 v0.AddArg(y) 22485 v0.AddArg(x) 22486 v.AddArg(v0) 22487 return true 22488 } 22489 } 22490 func rewriteValue386_OpLess8_0(v *Value) bool { 22491 b := v.Block 22492 _ = b 22493 // match: (Less8 x y) 22494 // cond: 22495 // result: (SETL (CMPB x y)) 22496 for { 22497 _ = v.Args[1] 22498 x := v.Args[0] 22499 y := v.Args[1] 22500 v.reset(Op386SETL) 22501 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags) 22502 v0.AddArg(x) 22503 v0.AddArg(y) 22504 v.AddArg(v0) 22505 return true 22506 } 22507 } 22508 func rewriteValue386_OpLess8U_0(v *Value) bool { 22509 b := v.Block 22510 _ = b 22511 // match: (Less8U x y) 22512 // cond: 22513 // result: (SETB (CMPB x y)) 22514 for { 22515 _ = v.Args[1] 22516 x := v.Args[0] 22517 y := v.Args[1] 22518 v.reset(Op386SETB) 22519 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags) 22520 v0.AddArg(x) 22521 v0.AddArg(y) 22522 v.AddArg(v0) 22523 return true 22524 } 22525 } 22526 func rewriteValue386_OpLoad_0(v *Value) bool { 22527 // match: (Load <t> ptr mem) 22528 // cond: (is32BitInt(t) || isPtr(t)) 22529 // result: (MOVLload ptr mem) 22530 for { 22531 t := v.Type 22532 _ = v.Args[1] 22533 ptr := v.Args[0] 22534 mem := v.Args[1] 22535 if !(is32BitInt(t) || isPtr(t)) { 22536 break 22537 } 22538 v.reset(Op386MOVLload) 22539 v.AddArg(ptr) 22540 v.AddArg(mem) 22541 return true 22542 } 22543 // match: (Load <t> ptr mem) 22544 // cond: is16BitInt(t) 22545 // result: (MOVWload ptr mem) 22546 for { 22547 t := v.Type 22548 _ = v.Args[1] 22549 ptr := v.Args[0] 22550 mem := v.Args[1] 22551 if !(is16BitInt(t)) { 22552 break 22553 } 22554 v.reset(Op386MOVWload) 22555 v.AddArg(ptr) 22556 v.AddArg(mem) 22557 return true 22558 } 22559 // match: (Load <t> ptr mem) 22560 // cond: (t.IsBoolean() || is8BitInt(t)) 22561 // result: (MOVBload ptr mem) 22562 for { 22563 t := v.Type 22564 _ = v.Args[1] 22565 ptr := v.Args[0] 22566 mem := v.Args[1] 22567 if !(t.IsBoolean() || is8BitInt(t)) { 22568 break 22569 } 22570 v.reset(Op386MOVBload) 22571 v.AddArg(ptr) 22572 v.AddArg(mem) 22573 return true 22574 } 22575 // match: (Load <t> ptr mem) 22576 // cond: is32BitFloat(t) 22577 // result: (MOVSSload ptr mem) 22578 for { 22579 t := v.Type 22580 _ = v.Args[1] 22581 ptr := v.Args[0] 22582 mem := v.Args[1] 22583 if !(is32BitFloat(t)) { 22584 break 22585 } 22586 v.reset(Op386MOVSSload) 22587 v.AddArg(ptr) 22588 v.AddArg(mem) 22589 return true 22590 } 22591 // match: (Load <t> ptr mem) 22592 // cond: is64BitFloat(t) 22593 // result: (MOVSDload ptr mem) 22594 for { 22595 t := v.Type 22596 _ = v.Args[1] 22597 ptr := v.Args[0] 22598 mem := v.Args[1] 22599 if !(is64BitFloat(t)) { 22600 break 22601 } 22602 v.reset(Op386MOVSDload) 22603 v.AddArg(ptr) 22604 v.AddArg(mem) 22605 return true 22606 } 22607 return false 22608 } 22609 func rewriteValue386_OpLocalAddr_0(v *Value) bool { 22610 // match: (LocalAddr {sym} base _) 22611 // cond: 22612 // result: (LEAL {sym} base) 22613 for { 22614 sym := v.Aux 22615 _ = v.Args[1] 22616 base := v.Args[0] 22617 v.reset(Op386LEAL) 22618 v.Aux = sym 22619 v.AddArg(base) 22620 return true 22621 } 22622 } 22623 func rewriteValue386_OpLsh16x16_0(v *Value) bool { 22624 b := v.Block 22625 _ = b 22626 // match: (Lsh16x16 <t> x y) 22627 // cond: 22628 // result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPWconst y [32]))) 22629 for { 22630 t := v.Type 22631 _ = v.Args[1] 22632 x := v.Args[0] 22633 y := v.Args[1] 22634 v.reset(Op386ANDL) 22635 v0 := b.NewValue0(v.Pos, Op386SHLL, t) 22636 v0.AddArg(x) 22637 v0.AddArg(y) 22638 v.AddArg(v0) 22639 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 22640 v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags) 22641 v2.AuxInt = 32 22642 v2.AddArg(y) 22643 v1.AddArg(v2) 22644 v.AddArg(v1) 22645 return true 22646 } 22647 } 22648 func rewriteValue386_OpLsh16x32_0(v *Value) bool { 22649 b := v.Block 22650 _ = b 22651 // match: (Lsh16x32 <t> x y) 22652 // cond: 22653 // result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPLconst y [32]))) 22654 for { 22655 t := v.Type 22656 _ = v.Args[1] 22657 x := v.Args[0] 22658 y := v.Args[1] 22659 v.reset(Op386ANDL) 22660 v0 := b.NewValue0(v.Pos, Op386SHLL, t) 22661 v0.AddArg(x) 22662 v0.AddArg(y) 22663 v.AddArg(v0) 22664 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 22665 v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags) 22666 v2.AuxInt = 32 22667 v2.AddArg(y) 22668 v1.AddArg(v2) 22669 v.AddArg(v1) 22670 return true 22671 } 22672 } 22673 func rewriteValue386_OpLsh16x64_0(v *Value) bool { 22674 // match: (Lsh16x64 x (Const64 [c])) 22675 // cond: uint64(c) < 16 22676 // result: (SHLLconst x [c]) 22677 for { 22678 _ = v.Args[1] 22679 x := v.Args[0] 22680 v_1 := v.Args[1] 22681 if v_1.Op != OpConst64 { 22682 break 22683 } 22684 c := v_1.AuxInt 22685 if !(uint64(c) < 16) { 22686 break 22687 } 22688 v.reset(Op386SHLLconst) 22689 v.AuxInt = c 22690 v.AddArg(x) 22691 return true 22692 } 22693 // match: (Lsh16x64 _ (Const64 [c])) 22694 // cond: uint64(c) >= 16 22695 // result: (Const16 [0]) 22696 for { 22697 _ = v.Args[1] 22698 v_1 := v.Args[1] 22699 if v_1.Op != OpConst64 { 22700 break 22701 } 22702 c := v_1.AuxInt 22703 if !(uint64(c) >= 16) { 22704 break 22705 } 22706 v.reset(OpConst16) 22707 v.AuxInt = 0 22708 return true 22709 } 22710 return false 22711 } 22712 func rewriteValue386_OpLsh16x8_0(v *Value) bool { 22713 b := v.Block 22714 _ = b 22715 // match: (Lsh16x8 <t> x y) 22716 // cond: 22717 // result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPBconst y [32]))) 22718 for { 22719 t := v.Type 22720 _ = v.Args[1] 22721 x := v.Args[0] 22722 y := v.Args[1] 22723 v.reset(Op386ANDL) 22724 v0 := b.NewValue0(v.Pos, Op386SHLL, t) 22725 v0.AddArg(x) 22726 v0.AddArg(y) 22727 v.AddArg(v0) 22728 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 22729 v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags) 22730 v2.AuxInt = 32 22731 v2.AddArg(y) 22732 v1.AddArg(v2) 22733 v.AddArg(v1) 22734 return true 22735 } 22736 } 22737 func rewriteValue386_OpLsh32x16_0(v *Value) bool { 22738 b := v.Block 22739 _ = b 22740 // match: (Lsh32x16 <t> x y) 22741 // cond: 22742 // result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPWconst y [32]))) 22743 for { 22744 t := v.Type 22745 _ = v.Args[1] 22746 x := v.Args[0] 22747 y := v.Args[1] 22748 v.reset(Op386ANDL) 22749 v0 := b.NewValue0(v.Pos, Op386SHLL, t) 22750 v0.AddArg(x) 22751 v0.AddArg(y) 22752 v.AddArg(v0) 22753 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 22754 v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags) 22755 v2.AuxInt = 32 22756 v2.AddArg(y) 22757 v1.AddArg(v2) 22758 v.AddArg(v1) 22759 return true 22760 } 22761 } 22762 func rewriteValue386_OpLsh32x32_0(v *Value) bool { 22763 b := v.Block 22764 _ = b 22765 // match: (Lsh32x32 <t> x y) 22766 // cond: 22767 // result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPLconst y [32]))) 22768 for { 22769 t := v.Type 22770 _ = v.Args[1] 22771 x := v.Args[0] 22772 y := v.Args[1] 22773 v.reset(Op386ANDL) 22774 v0 := b.NewValue0(v.Pos, Op386SHLL, t) 22775 v0.AddArg(x) 22776 v0.AddArg(y) 22777 v.AddArg(v0) 22778 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 22779 v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags) 22780 v2.AuxInt = 32 22781 v2.AddArg(y) 22782 v1.AddArg(v2) 22783 v.AddArg(v1) 22784 return true 22785 } 22786 } 22787 func rewriteValue386_OpLsh32x64_0(v *Value) bool { 22788 // match: (Lsh32x64 x (Const64 [c])) 22789 // cond: uint64(c) < 32 22790 // result: (SHLLconst x [c]) 22791 for { 22792 _ = v.Args[1] 22793 x := v.Args[0] 22794 v_1 := v.Args[1] 22795 if v_1.Op != OpConst64 { 22796 break 22797 } 22798 c := v_1.AuxInt 22799 if !(uint64(c) < 32) { 22800 break 22801 } 22802 v.reset(Op386SHLLconst) 22803 v.AuxInt = c 22804 v.AddArg(x) 22805 return true 22806 } 22807 // match: (Lsh32x64 _ (Const64 [c])) 22808 // cond: uint64(c) >= 32 22809 // result: (Const32 [0]) 22810 for { 22811 _ = v.Args[1] 22812 v_1 := v.Args[1] 22813 if v_1.Op != OpConst64 { 22814 break 22815 } 22816 c := v_1.AuxInt 22817 if !(uint64(c) >= 32) { 22818 break 22819 } 22820 v.reset(OpConst32) 22821 v.AuxInt = 0 22822 return true 22823 } 22824 return false 22825 } 22826 func rewriteValue386_OpLsh32x8_0(v *Value) bool { 22827 b := v.Block 22828 _ = b 22829 // match: (Lsh32x8 <t> x y) 22830 // cond: 22831 // result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPBconst y [32]))) 22832 for { 22833 t := v.Type 22834 _ = v.Args[1] 22835 x := v.Args[0] 22836 y := v.Args[1] 22837 v.reset(Op386ANDL) 22838 v0 := b.NewValue0(v.Pos, Op386SHLL, t) 22839 v0.AddArg(x) 22840 v0.AddArg(y) 22841 v.AddArg(v0) 22842 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 22843 v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags) 22844 v2.AuxInt = 32 22845 v2.AddArg(y) 22846 v1.AddArg(v2) 22847 v.AddArg(v1) 22848 return true 22849 } 22850 } 22851 func rewriteValue386_OpLsh8x16_0(v *Value) bool { 22852 b := v.Block 22853 _ = b 22854 // match: (Lsh8x16 <t> x y) 22855 // cond: 22856 // result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPWconst y [32]))) 22857 for { 22858 t := v.Type 22859 _ = v.Args[1] 22860 x := v.Args[0] 22861 y := v.Args[1] 22862 v.reset(Op386ANDL) 22863 v0 := b.NewValue0(v.Pos, Op386SHLL, t) 22864 v0.AddArg(x) 22865 v0.AddArg(y) 22866 v.AddArg(v0) 22867 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 22868 v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags) 22869 v2.AuxInt = 32 22870 v2.AddArg(y) 22871 v1.AddArg(v2) 22872 v.AddArg(v1) 22873 return true 22874 } 22875 } 22876 func rewriteValue386_OpLsh8x32_0(v *Value) bool { 22877 b := v.Block 22878 _ = b 22879 // match: (Lsh8x32 <t> x y) 22880 // cond: 22881 // result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPLconst y [32]))) 22882 for { 22883 t := v.Type 22884 _ = v.Args[1] 22885 x := v.Args[0] 22886 y := v.Args[1] 22887 v.reset(Op386ANDL) 22888 v0 := b.NewValue0(v.Pos, Op386SHLL, t) 22889 v0.AddArg(x) 22890 v0.AddArg(y) 22891 v.AddArg(v0) 22892 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 22893 v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags) 22894 v2.AuxInt = 32 22895 v2.AddArg(y) 22896 v1.AddArg(v2) 22897 v.AddArg(v1) 22898 return true 22899 } 22900 } 22901 func rewriteValue386_OpLsh8x64_0(v *Value) bool { 22902 // match: (Lsh8x64 x (Const64 [c])) 22903 // cond: uint64(c) < 8 22904 // result: (SHLLconst x [c]) 22905 for { 22906 _ = v.Args[1] 22907 x := v.Args[0] 22908 v_1 := v.Args[1] 22909 if v_1.Op != OpConst64 { 22910 break 22911 } 22912 c := v_1.AuxInt 22913 if !(uint64(c) < 8) { 22914 break 22915 } 22916 v.reset(Op386SHLLconst) 22917 v.AuxInt = c 22918 v.AddArg(x) 22919 return true 22920 } 22921 // match: (Lsh8x64 _ (Const64 [c])) 22922 // cond: uint64(c) >= 8 22923 // result: (Const8 [0]) 22924 for { 22925 _ = v.Args[1] 22926 v_1 := v.Args[1] 22927 if v_1.Op != OpConst64 { 22928 break 22929 } 22930 c := v_1.AuxInt 22931 if !(uint64(c) >= 8) { 22932 break 22933 } 22934 v.reset(OpConst8) 22935 v.AuxInt = 0 22936 return true 22937 } 22938 return false 22939 } 22940 func rewriteValue386_OpLsh8x8_0(v *Value) bool { 22941 b := v.Block 22942 _ = b 22943 // match: (Lsh8x8 <t> x y) 22944 // cond: 22945 // result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPBconst y [32]))) 22946 for { 22947 t := v.Type 22948 _ = v.Args[1] 22949 x := v.Args[0] 22950 y := v.Args[1] 22951 v.reset(Op386ANDL) 22952 v0 := b.NewValue0(v.Pos, Op386SHLL, t) 22953 v0.AddArg(x) 22954 v0.AddArg(y) 22955 v.AddArg(v0) 22956 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 22957 v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags) 22958 v2.AuxInt = 32 22959 v2.AddArg(y) 22960 v1.AddArg(v2) 22961 v.AddArg(v1) 22962 return true 22963 } 22964 } 22965 func rewriteValue386_OpMod16_0(v *Value) bool { 22966 // match: (Mod16 [a] x y) 22967 // cond: 22968 // result: (MODW [a] x y) 22969 for { 22970 a := v.AuxInt 22971 _ = v.Args[1] 22972 x := v.Args[0] 22973 y := v.Args[1] 22974 v.reset(Op386MODW) 22975 v.AuxInt = a 22976 v.AddArg(x) 22977 v.AddArg(y) 22978 return true 22979 } 22980 } 22981 func rewriteValue386_OpMod16u_0(v *Value) bool { 22982 // match: (Mod16u x y) 22983 // cond: 22984 // result: (MODWU x y) 22985 for { 22986 _ = v.Args[1] 22987 x := v.Args[0] 22988 y := v.Args[1] 22989 v.reset(Op386MODWU) 22990 v.AddArg(x) 22991 v.AddArg(y) 22992 return true 22993 } 22994 } 22995 func rewriteValue386_OpMod32_0(v *Value) bool { 22996 // match: (Mod32 [a] x y) 22997 // cond: 22998 // result: (MODL [a] x y) 22999 for { 23000 a := v.AuxInt 23001 _ = v.Args[1] 23002 x := v.Args[0] 23003 y := v.Args[1] 23004 v.reset(Op386MODL) 23005 v.AuxInt = a 23006 v.AddArg(x) 23007 v.AddArg(y) 23008 return true 23009 } 23010 } 23011 func rewriteValue386_OpMod32u_0(v *Value) bool { 23012 // match: (Mod32u x y) 23013 // cond: 23014 // result: (MODLU x y) 23015 for { 23016 _ = v.Args[1] 23017 x := v.Args[0] 23018 y := v.Args[1] 23019 v.reset(Op386MODLU) 23020 v.AddArg(x) 23021 v.AddArg(y) 23022 return true 23023 } 23024 } 23025 func rewriteValue386_OpMod8_0(v *Value) bool { 23026 b := v.Block 23027 _ = b 23028 typ := &b.Func.Config.Types 23029 _ = typ 23030 // match: (Mod8 x y) 23031 // cond: 23032 // result: (MODW (SignExt8to16 x) (SignExt8to16 y)) 23033 for { 23034 _ = v.Args[1] 23035 x := v.Args[0] 23036 y := v.Args[1] 23037 v.reset(Op386MODW) 23038 v0 := b.NewValue0(v.Pos, OpSignExt8to16, typ.Int16) 23039 v0.AddArg(x) 23040 v.AddArg(v0) 23041 v1 := b.NewValue0(v.Pos, OpSignExt8to16, typ.Int16) 23042 v1.AddArg(y) 23043 v.AddArg(v1) 23044 return true 23045 } 23046 } 23047 func rewriteValue386_OpMod8u_0(v *Value) bool { 23048 b := v.Block 23049 _ = b 23050 typ := &b.Func.Config.Types 23051 _ = typ 23052 // match: (Mod8u x y) 23053 // cond: 23054 // result: (MODWU (ZeroExt8to16 x) (ZeroExt8to16 y)) 23055 for { 23056 _ = v.Args[1] 23057 x := v.Args[0] 23058 y := v.Args[1] 23059 v.reset(Op386MODWU) 23060 v0 := b.NewValue0(v.Pos, OpZeroExt8to16, typ.UInt16) 23061 v0.AddArg(x) 23062 v.AddArg(v0) 23063 v1 := b.NewValue0(v.Pos, OpZeroExt8to16, typ.UInt16) 23064 v1.AddArg(y) 23065 v.AddArg(v1) 23066 return true 23067 } 23068 } 23069 func rewriteValue386_OpMove_0(v *Value) bool { 23070 b := v.Block 23071 _ = b 23072 typ := &b.Func.Config.Types 23073 _ = typ 23074 // match: (Move [0] _ _ mem) 23075 // cond: 23076 // result: mem 23077 for { 23078 if v.AuxInt != 0 { 23079 break 23080 } 23081 _ = v.Args[2] 23082 mem := v.Args[2] 23083 v.reset(OpCopy) 23084 v.Type = mem.Type 23085 v.AddArg(mem) 23086 return true 23087 } 23088 // match: (Move [1] dst src mem) 23089 // cond: 23090 // result: (MOVBstore dst (MOVBload src mem) mem) 23091 for { 23092 if v.AuxInt != 1 { 23093 break 23094 } 23095 _ = v.Args[2] 23096 dst := v.Args[0] 23097 src := v.Args[1] 23098 mem := v.Args[2] 23099 v.reset(Op386MOVBstore) 23100 v.AddArg(dst) 23101 v0 := b.NewValue0(v.Pos, Op386MOVBload, typ.UInt8) 23102 v0.AddArg(src) 23103 v0.AddArg(mem) 23104 v.AddArg(v0) 23105 v.AddArg(mem) 23106 return true 23107 } 23108 // match: (Move [2] dst src mem) 23109 // cond: 23110 // result: (MOVWstore dst (MOVWload src mem) mem) 23111 for { 23112 if v.AuxInt != 2 { 23113 break 23114 } 23115 _ = v.Args[2] 23116 dst := v.Args[0] 23117 src := v.Args[1] 23118 mem := v.Args[2] 23119 v.reset(Op386MOVWstore) 23120 v.AddArg(dst) 23121 v0 := b.NewValue0(v.Pos, Op386MOVWload, typ.UInt16) 23122 v0.AddArg(src) 23123 v0.AddArg(mem) 23124 v.AddArg(v0) 23125 v.AddArg(mem) 23126 return true 23127 } 23128 // match: (Move [4] dst src mem) 23129 // cond: 23130 // result: (MOVLstore dst (MOVLload src mem) mem) 23131 for { 23132 if v.AuxInt != 4 { 23133 break 23134 } 23135 _ = v.Args[2] 23136 dst := v.Args[0] 23137 src := v.Args[1] 23138 mem := v.Args[2] 23139 v.reset(Op386MOVLstore) 23140 v.AddArg(dst) 23141 v0 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32) 23142 v0.AddArg(src) 23143 v0.AddArg(mem) 23144 v.AddArg(v0) 23145 v.AddArg(mem) 23146 return true 23147 } 23148 // match: (Move [3] dst src mem) 23149 // cond: 23150 // result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVWstore dst (MOVWload src mem) mem)) 23151 for { 23152 if v.AuxInt != 3 { 23153 break 23154 } 23155 _ = v.Args[2] 23156 dst := v.Args[0] 23157 src := v.Args[1] 23158 mem := v.Args[2] 23159 v.reset(Op386MOVBstore) 23160 v.AuxInt = 2 23161 v.AddArg(dst) 23162 v0 := b.NewValue0(v.Pos, Op386MOVBload, typ.UInt8) 23163 v0.AuxInt = 2 23164 v0.AddArg(src) 23165 v0.AddArg(mem) 23166 v.AddArg(v0) 23167 v1 := b.NewValue0(v.Pos, Op386MOVWstore, types.TypeMem) 23168 v1.AddArg(dst) 23169 v2 := b.NewValue0(v.Pos, Op386MOVWload, typ.UInt16) 23170 v2.AddArg(src) 23171 v2.AddArg(mem) 23172 v1.AddArg(v2) 23173 v1.AddArg(mem) 23174 v.AddArg(v1) 23175 return true 23176 } 23177 // match: (Move [5] dst src mem) 23178 // cond: 23179 // result: (MOVBstore [4] dst (MOVBload [4] src mem) (MOVLstore dst (MOVLload src mem) mem)) 23180 for { 23181 if v.AuxInt != 5 { 23182 break 23183 } 23184 _ = v.Args[2] 23185 dst := v.Args[0] 23186 src := v.Args[1] 23187 mem := v.Args[2] 23188 v.reset(Op386MOVBstore) 23189 v.AuxInt = 4 23190 v.AddArg(dst) 23191 v0 := b.NewValue0(v.Pos, Op386MOVBload, typ.UInt8) 23192 v0.AuxInt = 4 23193 v0.AddArg(src) 23194 v0.AddArg(mem) 23195 v.AddArg(v0) 23196 v1 := b.NewValue0(v.Pos, Op386MOVLstore, types.TypeMem) 23197 v1.AddArg(dst) 23198 v2 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32) 23199 v2.AddArg(src) 23200 v2.AddArg(mem) 23201 v1.AddArg(v2) 23202 v1.AddArg(mem) 23203 v.AddArg(v1) 23204 return true 23205 } 23206 // match: (Move [6] dst src mem) 23207 // cond: 23208 // result: (MOVWstore [4] dst (MOVWload [4] src mem) (MOVLstore dst (MOVLload src mem) mem)) 23209 for { 23210 if v.AuxInt != 6 { 23211 break 23212 } 23213 _ = v.Args[2] 23214 dst := v.Args[0] 23215 src := v.Args[1] 23216 mem := v.Args[2] 23217 v.reset(Op386MOVWstore) 23218 v.AuxInt = 4 23219 v.AddArg(dst) 23220 v0 := b.NewValue0(v.Pos, Op386MOVWload, typ.UInt16) 23221 v0.AuxInt = 4 23222 v0.AddArg(src) 23223 v0.AddArg(mem) 23224 v.AddArg(v0) 23225 v1 := b.NewValue0(v.Pos, Op386MOVLstore, types.TypeMem) 23226 v1.AddArg(dst) 23227 v2 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32) 23228 v2.AddArg(src) 23229 v2.AddArg(mem) 23230 v1.AddArg(v2) 23231 v1.AddArg(mem) 23232 v.AddArg(v1) 23233 return true 23234 } 23235 // match: (Move [7] dst src mem) 23236 // cond: 23237 // result: (MOVLstore [3] dst (MOVLload [3] src mem) (MOVLstore dst (MOVLload src mem) mem)) 23238 for { 23239 if v.AuxInt != 7 { 23240 break 23241 } 23242 _ = v.Args[2] 23243 dst := v.Args[0] 23244 src := v.Args[1] 23245 mem := v.Args[2] 23246 v.reset(Op386MOVLstore) 23247 v.AuxInt = 3 23248 v.AddArg(dst) 23249 v0 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32) 23250 v0.AuxInt = 3 23251 v0.AddArg(src) 23252 v0.AddArg(mem) 23253 v.AddArg(v0) 23254 v1 := b.NewValue0(v.Pos, Op386MOVLstore, types.TypeMem) 23255 v1.AddArg(dst) 23256 v2 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32) 23257 v2.AddArg(src) 23258 v2.AddArg(mem) 23259 v1.AddArg(v2) 23260 v1.AddArg(mem) 23261 v.AddArg(v1) 23262 return true 23263 } 23264 // match: (Move [8] dst src mem) 23265 // cond: 23266 // result: (MOVLstore [4] dst (MOVLload [4] src mem) (MOVLstore dst (MOVLload src mem) mem)) 23267 for { 23268 if v.AuxInt != 8 { 23269 break 23270 } 23271 _ = v.Args[2] 23272 dst := v.Args[0] 23273 src := v.Args[1] 23274 mem := v.Args[2] 23275 v.reset(Op386MOVLstore) 23276 v.AuxInt = 4 23277 v.AddArg(dst) 23278 v0 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32) 23279 v0.AuxInt = 4 23280 v0.AddArg(src) 23281 v0.AddArg(mem) 23282 v.AddArg(v0) 23283 v1 := b.NewValue0(v.Pos, Op386MOVLstore, types.TypeMem) 23284 v1.AddArg(dst) 23285 v2 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32) 23286 v2.AddArg(src) 23287 v2.AddArg(mem) 23288 v1.AddArg(v2) 23289 v1.AddArg(mem) 23290 v.AddArg(v1) 23291 return true 23292 } 23293 // match: (Move [s] dst src mem) 23294 // cond: s > 8 && s%4 != 0 23295 // result: (Move [s-s%4] (ADDLconst <dst.Type> dst [s%4]) (ADDLconst <src.Type> src [s%4]) (MOVLstore dst (MOVLload src mem) mem)) 23296 for { 23297 s := v.AuxInt 23298 _ = v.Args[2] 23299 dst := v.Args[0] 23300 src := v.Args[1] 23301 mem := v.Args[2] 23302 if !(s > 8 && s%4 != 0) { 23303 break 23304 } 23305 v.reset(OpMove) 23306 v.AuxInt = s - s%4 23307 v0 := b.NewValue0(v.Pos, Op386ADDLconst, dst.Type) 23308 v0.AuxInt = s % 4 23309 v0.AddArg(dst) 23310 v.AddArg(v0) 23311 v1 := b.NewValue0(v.Pos, Op386ADDLconst, src.Type) 23312 v1.AuxInt = s % 4 23313 v1.AddArg(src) 23314 v.AddArg(v1) 23315 v2 := b.NewValue0(v.Pos, Op386MOVLstore, types.TypeMem) 23316 v2.AddArg(dst) 23317 v3 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32) 23318 v3.AddArg(src) 23319 v3.AddArg(mem) 23320 v2.AddArg(v3) 23321 v2.AddArg(mem) 23322 v.AddArg(v2) 23323 return true 23324 } 23325 return false 23326 } 23327 func rewriteValue386_OpMove_10(v *Value) bool { 23328 b := v.Block 23329 _ = b 23330 config := b.Func.Config 23331 _ = config 23332 typ := &b.Func.Config.Types 23333 _ = typ 23334 // match: (Move [s] dst src mem) 23335 // cond: s > 8 && s <= 4*128 && s%4 == 0 && !config.noDuffDevice 23336 // result: (DUFFCOPY [10*(128-s/4)] dst src mem) 23337 for { 23338 s := v.AuxInt 23339 _ = v.Args[2] 23340 dst := v.Args[0] 23341 src := v.Args[1] 23342 mem := v.Args[2] 23343 if !(s > 8 && s <= 4*128 && s%4 == 0 && !config.noDuffDevice) { 23344 break 23345 } 23346 v.reset(Op386DUFFCOPY) 23347 v.AuxInt = 10 * (128 - s/4) 23348 v.AddArg(dst) 23349 v.AddArg(src) 23350 v.AddArg(mem) 23351 return true 23352 } 23353 // match: (Move [s] dst src mem) 23354 // cond: (s > 4*128 || config.noDuffDevice) && s%4 == 0 23355 // result: (REPMOVSL dst src (MOVLconst [s/4]) mem) 23356 for { 23357 s := v.AuxInt 23358 _ = v.Args[2] 23359 dst := v.Args[0] 23360 src := v.Args[1] 23361 mem := v.Args[2] 23362 if !((s > 4*128 || config.noDuffDevice) && s%4 == 0) { 23363 break 23364 } 23365 v.reset(Op386REPMOVSL) 23366 v.AddArg(dst) 23367 v.AddArg(src) 23368 v0 := b.NewValue0(v.Pos, Op386MOVLconst, typ.UInt32) 23369 v0.AuxInt = s / 4 23370 v.AddArg(v0) 23371 v.AddArg(mem) 23372 return true 23373 } 23374 return false 23375 } 23376 func rewriteValue386_OpMul16_0(v *Value) bool { 23377 // match: (Mul16 x y) 23378 // cond: 23379 // result: (MULL x y) 23380 for { 23381 _ = v.Args[1] 23382 x := v.Args[0] 23383 y := v.Args[1] 23384 v.reset(Op386MULL) 23385 v.AddArg(x) 23386 v.AddArg(y) 23387 return true 23388 } 23389 } 23390 func rewriteValue386_OpMul32_0(v *Value) bool { 23391 // match: (Mul32 x y) 23392 // cond: 23393 // result: (MULL x y) 23394 for { 23395 _ = v.Args[1] 23396 x := v.Args[0] 23397 y := v.Args[1] 23398 v.reset(Op386MULL) 23399 v.AddArg(x) 23400 v.AddArg(y) 23401 return true 23402 } 23403 } 23404 func rewriteValue386_OpMul32F_0(v *Value) bool { 23405 // match: (Mul32F x y) 23406 // cond: 23407 // result: (MULSS x y) 23408 for { 23409 _ = v.Args[1] 23410 x := v.Args[0] 23411 y := v.Args[1] 23412 v.reset(Op386MULSS) 23413 v.AddArg(x) 23414 v.AddArg(y) 23415 return true 23416 } 23417 } 23418 func rewriteValue386_OpMul32uhilo_0(v *Value) bool { 23419 // match: (Mul32uhilo x y) 23420 // cond: 23421 // result: (MULLQU x y) 23422 for { 23423 _ = v.Args[1] 23424 x := v.Args[0] 23425 y := v.Args[1] 23426 v.reset(Op386MULLQU) 23427 v.AddArg(x) 23428 v.AddArg(y) 23429 return true 23430 } 23431 } 23432 func rewriteValue386_OpMul64F_0(v *Value) bool { 23433 // match: (Mul64F x y) 23434 // cond: 23435 // result: (MULSD x y) 23436 for { 23437 _ = v.Args[1] 23438 x := v.Args[0] 23439 y := v.Args[1] 23440 v.reset(Op386MULSD) 23441 v.AddArg(x) 23442 v.AddArg(y) 23443 return true 23444 } 23445 } 23446 func rewriteValue386_OpMul8_0(v *Value) bool { 23447 // match: (Mul8 x y) 23448 // cond: 23449 // result: (MULL x y) 23450 for { 23451 _ = v.Args[1] 23452 x := v.Args[0] 23453 y := v.Args[1] 23454 v.reset(Op386MULL) 23455 v.AddArg(x) 23456 v.AddArg(y) 23457 return true 23458 } 23459 } 23460 func rewriteValue386_OpNeg16_0(v *Value) bool { 23461 // match: (Neg16 x) 23462 // cond: 23463 // result: (NEGL x) 23464 for { 23465 x := v.Args[0] 23466 v.reset(Op386NEGL) 23467 v.AddArg(x) 23468 return true 23469 } 23470 } 23471 func rewriteValue386_OpNeg32_0(v *Value) bool { 23472 // match: (Neg32 x) 23473 // cond: 23474 // result: (NEGL x) 23475 for { 23476 x := v.Args[0] 23477 v.reset(Op386NEGL) 23478 v.AddArg(x) 23479 return true 23480 } 23481 } 23482 func rewriteValue386_OpNeg32F_0(v *Value) bool { 23483 b := v.Block 23484 _ = b 23485 config := b.Func.Config 23486 _ = config 23487 typ := &b.Func.Config.Types 23488 _ = typ 23489 // match: (Neg32F x) 23490 // cond: !config.use387 23491 // result: (PXOR x (MOVSSconst <typ.Float32> [auxFrom32F(float32(math.Copysign(0, -1)))])) 23492 for { 23493 x := v.Args[0] 23494 if !(!config.use387) { 23495 break 23496 } 23497 v.reset(Op386PXOR) 23498 v.AddArg(x) 23499 v0 := b.NewValue0(v.Pos, Op386MOVSSconst, typ.Float32) 23500 v0.AuxInt = auxFrom32F(float32(math.Copysign(0, -1))) 23501 v.AddArg(v0) 23502 return true 23503 } 23504 // match: (Neg32F x) 23505 // cond: config.use387 23506 // result: (FCHS x) 23507 for { 23508 x := v.Args[0] 23509 if !(config.use387) { 23510 break 23511 } 23512 v.reset(Op386FCHS) 23513 v.AddArg(x) 23514 return true 23515 } 23516 return false 23517 } 23518 func rewriteValue386_OpNeg64F_0(v *Value) bool { 23519 b := v.Block 23520 _ = b 23521 config := b.Func.Config 23522 _ = config 23523 typ := &b.Func.Config.Types 23524 _ = typ 23525 // match: (Neg64F x) 23526 // cond: !config.use387 23527 // result: (PXOR x (MOVSDconst <typ.Float64> [auxFrom64F(math.Copysign(0, -1))])) 23528 for { 23529 x := v.Args[0] 23530 if !(!config.use387) { 23531 break 23532 } 23533 v.reset(Op386PXOR) 23534 v.AddArg(x) 23535 v0 := b.NewValue0(v.Pos, Op386MOVSDconst, typ.Float64) 23536 v0.AuxInt = auxFrom64F(math.Copysign(0, -1)) 23537 v.AddArg(v0) 23538 return true 23539 } 23540 // match: (Neg64F x) 23541 // cond: config.use387 23542 // result: (FCHS x) 23543 for { 23544 x := v.Args[0] 23545 if !(config.use387) { 23546 break 23547 } 23548 v.reset(Op386FCHS) 23549 v.AddArg(x) 23550 return true 23551 } 23552 return false 23553 } 23554 func rewriteValue386_OpNeg8_0(v *Value) bool { 23555 // match: (Neg8 x) 23556 // cond: 23557 // result: (NEGL x) 23558 for { 23559 x := v.Args[0] 23560 v.reset(Op386NEGL) 23561 v.AddArg(x) 23562 return true 23563 } 23564 } 23565 func rewriteValue386_OpNeq16_0(v *Value) bool { 23566 b := v.Block 23567 _ = b 23568 // match: (Neq16 x y) 23569 // cond: 23570 // result: (SETNE (CMPW x y)) 23571 for { 23572 _ = v.Args[1] 23573 x := v.Args[0] 23574 y := v.Args[1] 23575 v.reset(Op386SETNE) 23576 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags) 23577 v0.AddArg(x) 23578 v0.AddArg(y) 23579 v.AddArg(v0) 23580 return true 23581 } 23582 } 23583 func rewriteValue386_OpNeq32_0(v *Value) bool { 23584 b := v.Block 23585 _ = b 23586 // match: (Neq32 x y) 23587 // cond: 23588 // result: (SETNE (CMPL x y)) 23589 for { 23590 _ = v.Args[1] 23591 x := v.Args[0] 23592 y := v.Args[1] 23593 v.reset(Op386SETNE) 23594 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) 23595 v0.AddArg(x) 23596 v0.AddArg(y) 23597 v.AddArg(v0) 23598 return true 23599 } 23600 } 23601 func rewriteValue386_OpNeq32F_0(v *Value) bool { 23602 b := v.Block 23603 _ = b 23604 // match: (Neq32F x y) 23605 // cond: 23606 // result: (SETNEF (UCOMISS x y)) 23607 for { 23608 _ = v.Args[1] 23609 x := v.Args[0] 23610 y := v.Args[1] 23611 v.reset(Op386SETNEF) 23612 v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags) 23613 v0.AddArg(x) 23614 v0.AddArg(y) 23615 v.AddArg(v0) 23616 return true 23617 } 23618 } 23619 func rewriteValue386_OpNeq64F_0(v *Value) bool { 23620 b := v.Block 23621 _ = b 23622 // match: (Neq64F x y) 23623 // cond: 23624 // result: (SETNEF (UCOMISD x y)) 23625 for { 23626 _ = v.Args[1] 23627 x := v.Args[0] 23628 y := v.Args[1] 23629 v.reset(Op386SETNEF) 23630 v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags) 23631 v0.AddArg(x) 23632 v0.AddArg(y) 23633 v.AddArg(v0) 23634 return true 23635 } 23636 } 23637 func rewriteValue386_OpNeq8_0(v *Value) bool { 23638 b := v.Block 23639 _ = b 23640 // match: (Neq8 x y) 23641 // cond: 23642 // result: (SETNE (CMPB x y)) 23643 for { 23644 _ = v.Args[1] 23645 x := v.Args[0] 23646 y := v.Args[1] 23647 v.reset(Op386SETNE) 23648 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags) 23649 v0.AddArg(x) 23650 v0.AddArg(y) 23651 v.AddArg(v0) 23652 return true 23653 } 23654 } 23655 func rewriteValue386_OpNeqB_0(v *Value) bool { 23656 b := v.Block 23657 _ = b 23658 // match: (NeqB x y) 23659 // cond: 23660 // result: (SETNE (CMPB x y)) 23661 for { 23662 _ = v.Args[1] 23663 x := v.Args[0] 23664 y := v.Args[1] 23665 v.reset(Op386SETNE) 23666 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags) 23667 v0.AddArg(x) 23668 v0.AddArg(y) 23669 v.AddArg(v0) 23670 return true 23671 } 23672 } 23673 func rewriteValue386_OpNeqPtr_0(v *Value) bool { 23674 b := v.Block 23675 _ = b 23676 // match: (NeqPtr x y) 23677 // cond: 23678 // result: (SETNE (CMPL x y)) 23679 for { 23680 _ = v.Args[1] 23681 x := v.Args[0] 23682 y := v.Args[1] 23683 v.reset(Op386SETNE) 23684 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags) 23685 v0.AddArg(x) 23686 v0.AddArg(y) 23687 v.AddArg(v0) 23688 return true 23689 } 23690 } 23691 func rewriteValue386_OpNilCheck_0(v *Value) bool { 23692 // match: (NilCheck ptr mem) 23693 // cond: 23694 // result: (LoweredNilCheck ptr mem) 23695 for { 23696 _ = v.Args[1] 23697 ptr := v.Args[0] 23698 mem := v.Args[1] 23699 v.reset(Op386LoweredNilCheck) 23700 v.AddArg(ptr) 23701 v.AddArg(mem) 23702 return true 23703 } 23704 } 23705 func rewriteValue386_OpNot_0(v *Value) bool { 23706 // match: (Not x) 23707 // cond: 23708 // result: (XORLconst [1] x) 23709 for { 23710 x := v.Args[0] 23711 v.reset(Op386XORLconst) 23712 v.AuxInt = 1 23713 v.AddArg(x) 23714 return true 23715 } 23716 } 23717 func rewriteValue386_OpOffPtr_0(v *Value) bool { 23718 // match: (OffPtr [off] ptr) 23719 // cond: 23720 // result: (ADDLconst [off] ptr) 23721 for { 23722 off := v.AuxInt 23723 ptr := v.Args[0] 23724 v.reset(Op386ADDLconst) 23725 v.AuxInt = off 23726 v.AddArg(ptr) 23727 return true 23728 } 23729 } 23730 func rewriteValue386_OpOr16_0(v *Value) bool { 23731 // match: (Or16 x y) 23732 // cond: 23733 // result: (ORL x y) 23734 for { 23735 _ = v.Args[1] 23736 x := v.Args[0] 23737 y := v.Args[1] 23738 v.reset(Op386ORL) 23739 v.AddArg(x) 23740 v.AddArg(y) 23741 return true 23742 } 23743 } 23744 func rewriteValue386_OpOr32_0(v *Value) bool { 23745 // match: (Or32 x y) 23746 // cond: 23747 // result: (ORL x y) 23748 for { 23749 _ = v.Args[1] 23750 x := v.Args[0] 23751 y := v.Args[1] 23752 v.reset(Op386ORL) 23753 v.AddArg(x) 23754 v.AddArg(y) 23755 return true 23756 } 23757 } 23758 func rewriteValue386_OpOr8_0(v *Value) bool { 23759 // match: (Or8 x y) 23760 // cond: 23761 // result: (ORL x y) 23762 for { 23763 _ = v.Args[1] 23764 x := v.Args[0] 23765 y := v.Args[1] 23766 v.reset(Op386ORL) 23767 v.AddArg(x) 23768 v.AddArg(y) 23769 return true 23770 } 23771 } 23772 func rewriteValue386_OpOrB_0(v *Value) bool { 23773 // match: (OrB x y) 23774 // cond: 23775 // result: (ORL x y) 23776 for { 23777 _ = v.Args[1] 23778 x := v.Args[0] 23779 y := v.Args[1] 23780 v.reset(Op386ORL) 23781 v.AddArg(x) 23782 v.AddArg(y) 23783 return true 23784 } 23785 } 23786 func rewriteValue386_OpRound32F_0(v *Value) bool { 23787 // match: (Round32F x) 23788 // cond: 23789 // result: x 23790 for { 23791 x := v.Args[0] 23792 v.reset(OpCopy) 23793 v.Type = x.Type 23794 v.AddArg(x) 23795 return true 23796 } 23797 } 23798 func rewriteValue386_OpRound64F_0(v *Value) bool { 23799 // match: (Round64F x) 23800 // cond: 23801 // result: x 23802 for { 23803 x := v.Args[0] 23804 v.reset(OpCopy) 23805 v.Type = x.Type 23806 v.AddArg(x) 23807 return true 23808 } 23809 } 23810 func rewriteValue386_OpRsh16Ux16_0(v *Value) bool { 23811 b := v.Block 23812 _ = b 23813 // match: (Rsh16Ux16 <t> x y) 23814 // cond: 23815 // result: (ANDL (SHRW <t> x y) (SBBLcarrymask <t> (CMPWconst y [16]))) 23816 for { 23817 t := v.Type 23818 _ = v.Args[1] 23819 x := v.Args[0] 23820 y := v.Args[1] 23821 v.reset(Op386ANDL) 23822 v0 := b.NewValue0(v.Pos, Op386SHRW, t) 23823 v0.AddArg(x) 23824 v0.AddArg(y) 23825 v.AddArg(v0) 23826 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 23827 v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags) 23828 v2.AuxInt = 16 23829 v2.AddArg(y) 23830 v1.AddArg(v2) 23831 v.AddArg(v1) 23832 return true 23833 } 23834 } 23835 func rewriteValue386_OpRsh16Ux32_0(v *Value) bool { 23836 b := v.Block 23837 _ = b 23838 // match: (Rsh16Ux32 <t> x y) 23839 // cond: 23840 // result: (ANDL (SHRW <t> x y) (SBBLcarrymask <t> (CMPLconst y [16]))) 23841 for { 23842 t := v.Type 23843 _ = v.Args[1] 23844 x := v.Args[0] 23845 y := v.Args[1] 23846 v.reset(Op386ANDL) 23847 v0 := b.NewValue0(v.Pos, Op386SHRW, t) 23848 v0.AddArg(x) 23849 v0.AddArg(y) 23850 v.AddArg(v0) 23851 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 23852 v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags) 23853 v2.AuxInt = 16 23854 v2.AddArg(y) 23855 v1.AddArg(v2) 23856 v.AddArg(v1) 23857 return true 23858 } 23859 } 23860 func rewriteValue386_OpRsh16Ux64_0(v *Value) bool { 23861 // match: (Rsh16Ux64 x (Const64 [c])) 23862 // cond: uint64(c) < 16 23863 // result: (SHRWconst x [c]) 23864 for { 23865 _ = v.Args[1] 23866 x := v.Args[0] 23867 v_1 := v.Args[1] 23868 if v_1.Op != OpConst64 { 23869 break 23870 } 23871 c := v_1.AuxInt 23872 if !(uint64(c) < 16) { 23873 break 23874 } 23875 v.reset(Op386SHRWconst) 23876 v.AuxInt = c 23877 v.AddArg(x) 23878 return true 23879 } 23880 // match: (Rsh16Ux64 _ (Const64 [c])) 23881 // cond: uint64(c) >= 16 23882 // result: (Const16 [0]) 23883 for { 23884 _ = v.Args[1] 23885 v_1 := v.Args[1] 23886 if v_1.Op != OpConst64 { 23887 break 23888 } 23889 c := v_1.AuxInt 23890 if !(uint64(c) >= 16) { 23891 break 23892 } 23893 v.reset(OpConst16) 23894 v.AuxInt = 0 23895 return true 23896 } 23897 return false 23898 } 23899 func rewriteValue386_OpRsh16Ux8_0(v *Value) bool { 23900 b := v.Block 23901 _ = b 23902 // match: (Rsh16Ux8 <t> x y) 23903 // cond: 23904 // result: (ANDL (SHRW <t> x y) (SBBLcarrymask <t> (CMPBconst y [16]))) 23905 for { 23906 t := v.Type 23907 _ = v.Args[1] 23908 x := v.Args[0] 23909 y := v.Args[1] 23910 v.reset(Op386ANDL) 23911 v0 := b.NewValue0(v.Pos, Op386SHRW, t) 23912 v0.AddArg(x) 23913 v0.AddArg(y) 23914 v.AddArg(v0) 23915 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 23916 v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags) 23917 v2.AuxInt = 16 23918 v2.AddArg(y) 23919 v1.AddArg(v2) 23920 v.AddArg(v1) 23921 return true 23922 } 23923 } 23924 func rewriteValue386_OpRsh16x16_0(v *Value) bool { 23925 b := v.Block 23926 _ = b 23927 // match: (Rsh16x16 <t> x y) 23928 // cond: 23929 // result: (SARW <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [16]))))) 23930 for { 23931 t := v.Type 23932 _ = v.Args[1] 23933 x := v.Args[0] 23934 y := v.Args[1] 23935 v.reset(Op386SARW) 23936 v.Type = t 23937 v.AddArg(x) 23938 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type) 23939 v0.AddArg(y) 23940 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type) 23941 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type) 23942 v3 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags) 23943 v3.AuxInt = 16 23944 v3.AddArg(y) 23945 v2.AddArg(v3) 23946 v1.AddArg(v2) 23947 v0.AddArg(v1) 23948 v.AddArg(v0) 23949 return true 23950 } 23951 } 23952 func rewriteValue386_OpRsh16x32_0(v *Value) bool { 23953 b := v.Block 23954 _ = b 23955 // match: (Rsh16x32 <t> x y) 23956 // cond: 23957 // result: (SARW <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [16]))))) 23958 for { 23959 t := v.Type 23960 _ = v.Args[1] 23961 x := v.Args[0] 23962 y := v.Args[1] 23963 v.reset(Op386SARW) 23964 v.Type = t 23965 v.AddArg(x) 23966 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type) 23967 v0.AddArg(y) 23968 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type) 23969 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type) 23970 v3 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags) 23971 v3.AuxInt = 16 23972 v3.AddArg(y) 23973 v2.AddArg(v3) 23974 v1.AddArg(v2) 23975 v0.AddArg(v1) 23976 v.AddArg(v0) 23977 return true 23978 } 23979 } 23980 func rewriteValue386_OpRsh16x64_0(v *Value) bool { 23981 // match: (Rsh16x64 x (Const64 [c])) 23982 // cond: uint64(c) < 16 23983 // result: (SARWconst x [c]) 23984 for { 23985 _ = v.Args[1] 23986 x := v.Args[0] 23987 v_1 := v.Args[1] 23988 if v_1.Op != OpConst64 { 23989 break 23990 } 23991 c := v_1.AuxInt 23992 if !(uint64(c) < 16) { 23993 break 23994 } 23995 v.reset(Op386SARWconst) 23996 v.AuxInt = c 23997 v.AddArg(x) 23998 return true 23999 } 24000 // match: (Rsh16x64 x (Const64 [c])) 24001 // cond: uint64(c) >= 16 24002 // result: (SARWconst x [15]) 24003 for { 24004 _ = v.Args[1] 24005 x := v.Args[0] 24006 v_1 := v.Args[1] 24007 if v_1.Op != OpConst64 { 24008 break 24009 } 24010 c := v_1.AuxInt 24011 if !(uint64(c) >= 16) { 24012 break 24013 } 24014 v.reset(Op386SARWconst) 24015 v.AuxInt = 15 24016 v.AddArg(x) 24017 return true 24018 } 24019 return false 24020 } 24021 func rewriteValue386_OpRsh16x8_0(v *Value) bool { 24022 b := v.Block 24023 _ = b 24024 // match: (Rsh16x8 <t> x y) 24025 // cond: 24026 // result: (SARW <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [16]))))) 24027 for { 24028 t := v.Type 24029 _ = v.Args[1] 24030 x := v.Args[0] 24031 y := v.Args[1] 24032 v.reset(Op386SARW) 24033 v.Type = t 24034 v.AddArg(x) 24035 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type) 24036 v0.AddArg(y) 24037 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type) 24038 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type) 24039 v3 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags) 24040 v3.AuxInt = 16 24041 v3.AddArg(y) 24042 v2.AddArg(v3) 24043 v1.AddArg(v2) 24044 v0.AddArg(v1) 24045 v.AddArg(v0) 24046 return true 24047 } 24048 } 24049 func rewriteValue386_OpRsh32Ux16_0(v *Value) bool { 24050 b := v.Block 24051 _ = b 24052 // match: (Rsh32Ux16 <t> x y) 24053 // cond: 24054 // result: (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPWconst y [32]))) 24055 for { 24056 t := v.Type 24057 _ = v.Args[1] 24058 x := v.Args[0] 24059 y := v.Args[1] 24060 v.reset(Op386ANDL) 24061 v0 := b.NewValue0(v.Pos, Op386SHRL, t) 24062 v0.AddArg(x) 24063 v0.AddArg(y) 24064 v.AddArg(v0) 24065 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 24066 v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags) 24067 v2.AuxInt = 32 24068 v2.AddArg(y) 24069 v1.AddArg(v2) 24070 v.AddArg(v1) 24071 return true 24072 } 24073 } 24074 func rewriteValue386_OpRsh32Ux32_0(v *Value) bool { 24075 b := v.Block 24076 _ = b 24077 // match: (Rsh32Ux32 <t> x y) 24078 // cond: 24079 // result: (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPLconst y [32]))) 24080 for { 24081 t := v.Type 24082 _ = v.Args[1] 24083 x := v.Args[0] 24084 y := v.Args[1] 24085 v.reset(Op386ANDL) 24086 v0 := b.NewValue0(v.Pos, Op386SHRL, t) 24087 v0.AddArg(x) 24088 v0.AddArg(y) 24089 v.AddArg(v0) 24090 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 24091 v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags) 24092 v2.AuxInt = 32 24093 v2.AddArg(y) 24094 v1.AddArg(v2) 24095 v.AddArg(v1) 24096 return true 24097 } 24098 } 24099 func rewriteValue386_OpRsh32Ux64_0(v *Value) bool { 24100 // match: (Rsh32Ux64 x (Const64 [c])) 24101 // cond: uint64(c) < 32 24102 // result: (SHRLconst x [c]) 24103 for { 24104 _ = v.Args[1] 24105 x := v.Args[0] 24106 v_1 := v.Args[1] 24107 if v_1.Op != OpConst64 { 24108 break 24109 } 24110 c := v_1.AuxInt 24111 if !(uint64(c) < 32) { 24112 break 24113 } 24114 v.reset(Op386SHRLconst) 24115 v.AuxInt = c 24116 v.AddArg(x) 24117 return true 24118 } 24119 // match: (Rsh32Ux64 _ (Const64 [c])) 24120 // cond: uint64(c) >= 32 24121 // result: (Const32 [0]) 24122 for { 24123 _ = v.Args[1] 24124 v_1 := v.Args[1] 24125 if v_1.Op != OpConst64 { 24126 break 24127 } 24128 c := v_1.AuxInt 24129 if !(uint64(c) >= 32) { 24130 break 24131 } 24132 v.reset(OpConst32) 24133 v.AuxInt = 0 24134 return true 24135 } 24136 return false 24137 } 24138 func rewriteValue386_OpRsh32Ux8_0(v *Value) bool { 24139 b := v.Block 24140 _ = b 24141 // match: (Rsh32Ux8 <t> x y) 24142 // cond: 24143 // result: (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPBconst y [32]))) 24144 for { 24145 t := v.Type 24146 _ = v.Args[1] 24147 x := v.Args[0] 24148 y := v.Args[1] 24149 v.reset(Op386ANDL) 24150 v0 := b.NewValue0(v.Pos, Op386SHRL, t) 24151 v0.AddArg(x) 24152 v0.AddArg(y) 24153 v.AddArg(v0) 24154 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 24155 v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags) 24156 v2.AuxInt = 32 24157 v2.AddArg(y) 24158 v1.AddArg(v2) 24159 v.AddArg(v1) 24160 return true 24161 } 24162 } 24163 func rewriteValue386_OpRsh32x16_0(v *Value) bool { 24164 b := v.Block 24165 _ = b 24166 // match: (Rsh32x16 <t> x y) 24167 // cond: 24168 // result: (SARL <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [32]))))) 24169 for { 24170 t := v.Type 24171 _ = v.Args[1] 24172 x := v.Args[0] 24173 y := v.Args[1] 24174 v.reset(Op386SARL) 24175 v.Type = t 24176 v.AddArg(x) 24177 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type) 24178 v0.AddArg(y) 24179 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type) 24180 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type) 24181 v3 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags) 24182 v3.AuxInt = 32 24183 v3.AddArg(y) 24184 v2.AddArg(v3) 24185 v1.AddArg(v2) 24186 v0.AddArg(v1) 24187 v.AddArg(v0) 24188 return true 24189 } 24190 } 24191 func rewriteValue386_OpRsh32x32_0(v *Value) bool { 24192 b := v.Block 24193 _ = b 24194 // match: (Rsh32x32 <t> x y) 24195 // cond: 24196 // result: (SARL <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [32]))))) 24197 for { 24198 t := v.Type 24199 _ = v.Args[1] 24200 x := v.Args[0] 24201 y := v.Args[1] 24202 v.reset(Op386SARL) 24203 v.Type = t 24204 v.AddArg(x) 24205 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type) 24206 v0.AddArg(y) 24207 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type) 24208 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type) 24209 v3 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags) 24210 v3.AuxInt = 32 24211 v3.AddArg(y) 24212 v2.AddArg(v3) 24213 v1.AddArg(v2) 24214 v0.AddArg(v1) 24215 v.AddArg(v0) 24216 return true 24217 } 24218 } 24219 func rewriteValue386_OpRsh32x64_0(v *Value) bool { 24220 // match: (Rsh32x64 x (Const64 [c])) 24221 // cond: uint64(c) < 32 24222 // result: (SARLconst x [c]) 24223 for { 24224 _ = v.Args[1] 24225 x := v.Args[0] 24226 v_1 := v.Args[1] 24227 if v_1.Op != OpConst64 { 24228 break 24229 } 24230 c := v_1.AuxInt 24231 if !(uint64(c) < 32) { 24232 break 24233 } 24234 v.reset(Op386SARLconst) 24235 v.AuxInt = c 24236 v.AddArg(x) 24237 return true 24238 } 24239 // match: (Rsh32x64 x (Const64 [c])) 24240 // cond: uint64(c) >= 32 24241 // result: (SARLconst x [31]) 24242 for { 24243 _ = v.Args[1] 24244 x := v.Args[0] 24245 v_1 := v.Args[1] 24246 if v_1.Op != OpConst64 { 24247 break 24248 } 24249 c := v_1.AuxInt 24250 if !(uint64(c) >= 32) { 24251 break 24252 } 24253 v.reset(Op386SARLconst) 24254 v.AuxInt = 31 24255 v.AddArg(x) 24256 return true 24257 } 24258 return false 24259 } 24260 func rewriteValue386_OpRsh32x8_0(v *Value) bool { 24261 b := v.Block 24262 _ = b 24263 // match: (Rsh32x8 <t> x y) 24264 // cond: 24265 // result: (SARL <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [32]))))) 24266 for { 24267 t := v.Type 24268 _ = v.Args[1] 24269 x := v.Args[0] 24270 y := v.Args[1] 24271 v.reset(Op386SARL) 24272 v.Type = t 24273 v.AddArg(x) 24274 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type) 24275 v0.AddArg(y) 24276 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type) 24277 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type) 24278 v3 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags) 24279 v3.AuxInt = 32 24280 v3.AddArg(y) 24281 v2.AddArg(v3) 24282 v1.AddArg(v2) 24283 v0.AddArg(v1) 24284 v.AddArg(v0) 24285 return true 24286 } 24287 } 24288 func rewriteValue386_OpRsh8Ux16_0(v *Value) bool { 24289 b := v.Block 24290 _ = b 24291 // match: (Rsh8Ux16 <t> x y) 24292 // cond: 24293 // result: (ANDL (SHRB <t> x y) (SBBLcarrymask <t> (CMPWconst y [8]))) 24294 for { 24295 t := v.Type 24296 _ = v.Args[1] 24297 x := v.Args[0] 24298 y := v.Args[1] 24299 v.reset(Op386ANDL) 24300 v0 := b.NewValue0(v.Pos, Op386SHRB, t) 24301 v0.AddArg(x) 24302 v0.AddArg(y) 24303 v.AddArg(v0) 24304 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 24305 v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags) 24306 v2.AuxInt = 8 24307 v2.AddArg(y) 24308 v1.AddArg(v2) 24309 v.AddArg(v1) 24310 return true 24311 } 24312 } 24313 func rewriteValue386_OpRsh8Ux32_0(v *Value) bool { 24314 b := v.Block 24315 _ = b 24316 // match: (Rsh8Ux32 <t> x y) 24317 // cond: 24318 // result: (ANDL (SHRB <t> x y) (SBBLcarrymask <t> (CMPLconst y [8]))) 24319 for { 24320 t := v.Type 24321 _ = v.Args[1] 24322 x := v.Args[0] 24323 y := v.Args[1] 24324 v.reset(Op386ANDL) 24325 v0 := b.NewValue0(v.Pos, Op386SHRB, t) 24326 v0.AddArg(x) 24327 v0.AddArg(y) 24328 v.AddArg(v0) 24329 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 24330 v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags) 24331 v2.AuxInt = 8 24332 v2.AddArg(y) 24333 v1.AddArg(v2) 24334 v.AddArg(v1) 24335 return true 24336 } 24337 } 24338 func rewriteValue386_OpRsh8Ux64_0(v *Value) bool { 24339 // match: (Rsh8Ux64 x (Const64 [c])) 24340 // cond: uint64(c) < 8 24341 // result: (SHRBconst x [c]) 24342 for { 24343 _ = v.Args[1] 24344 x := v.Args[0] 24345 v_1 := v.Args[1] 24346 if v_1.Op != OpConst64 { 24347 break 24348 } 24349 c := v_1.AuxInt 24350 if !(uint64(c) < 8) { 24351 break 24352 } 24353 v.reset(Op386SHRBconst) 24354 v.AuxInt = c 24355 v.AddArg(x) 24356 return true 24357 } 24358 // match: (Rsh8Ux64 _ (Const64 [c])) 24359 // cond: uint64(c) >= 8 24360 // result: (Const8 [0]) 24361 for { 24362 _ = v.Args[1] 24363 v_1 := v.Args[1] 24364 if v_1.Op != OpConst64 { 24365 break 24366 } 24367 c := v_1.AuxInt 24368 if !(uint64(c) >= 8) { 24369 break 24370 } 24371 v.reset(OpConst8) 24372 v.AuxInt = 0 24373 return true 24374 } 24375 return false 24376 } 24377 func rewriteValue386_OpRsh8Ux8_0(v *Value) bool { 24378 b := v.Block 24379 _ = b 24380 // match: (Rsh8Ux8 <t> x y) 24381 // cond: 24382 // result: (ANDL (SHRB <t> x y) (SBBLcarrymask <t> (CMPBconst y [8]))) 24383 for { 24384 t := v.Type 24385 _ = v.Args[1] 24386 x := v.Args[0] 24387 y := v.Args[1] 24388 v.reset(Op386ANDL) 24389 v0 := b.NewValue0(v.Pos, Op386SHRB, t) 24390 v0.AddArg(x) 24391 v0.AddArg(y) 24392 v.AddArg(v0) 24393 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 24394 v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags) 24395 v2.AuxInt = 8 24396 v2.AddArg(y) 24397 v1.AddArg(v2) 24398 v.AddArg(v1) 24399 return true 24400 } 24401 } 24402 func rewriteValue386_OpRsh8x16_0(v *Value) bool { 24403 b := v.Block 24404 _ = b 24405 // match: (Rsh8x16 <t> x y) 24406 // cond: 24407 // result: (SARB <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [8]))))) 24408 for { 24409 t := v.Type 24410 _ = v.Args[1] 24411 x := v.Args[0] 24412 y := v.Args[1] 24413 v.reset(Op386SARB) 24414 v.Type = t 24415 v.AddArg(x) 24416 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type) 24417 v0.AddArg(y) 24418 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type) 24419 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type) 24420 v3 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags) 24421 v3.AuxInt = 8 24422 v3.AddArg(y) 24423 v2.AddArg(v3) 24424 v1.AddArg(v2) 24425 v0.AddArg(v1) 24426 v.AddArg(v0) 24427 return true 24428 } 24429 } 24430 func rewriteValue386_OpRsh8x32_0(v *Value) bool { 24431 b := v.Block 24432 _ = b 24433 // match: (Rsh8x32 <t> x y) 24434 // cond: 24435 // result: (SARB <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [8]))))) 24436 for { 24437 t := v.Type 24438 _ = v.Args[1] 24439 x := v.Args[0] 24440 y := v.Args[1] 24441 v.reset(Op386SARB) 24442 v.Type = t 24443 v.AddArg(x) 24444 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type) 24445 v0.AddArg(y) 24446 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type) 24447 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type) 24448 v3 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags) 24449 v3.AuxInt = 8 24450 v3.AddArg(y) 24451 v2.AddArg(v3) 24452 v1.AddArg(v2) 24453 v0.AddArg(v1) 24454 v.AddArg(v0) 24455 return true 24456 } 24457 } 24458 func rewriteValue386_OpRsh8x64_0(v *Value) bool { 24459 // match: (Rsh8x64 x (Const64 [c])) 24460 // cond: uint64(c) < 8 24461 // result: (SARBconst x [c]) 24462 for { 24463 _ = v.Args[1] 24464 x := v.Args[0] 24465 v_1 := v.Args[1] 24466 if v_1.Op != OpConst64 { 24467 break 24468 } 24469 c := v_1.AuxInt 24470 if !(uint64(c) < 8) { 24471 break 24472 } 24473 v.reset(Op386SARBconst) 24474 v.AuxInt = c 24475 v.AddArg(x) 24476 return true 24477 } 24478 // match: (Rsh8x64 x (Const64 [c])) 24479 // cond: uint64(c) >= 8 24480 // result: (SARBconst x [7]) 24481 for { 24482 _ = v.Args[1] 24483 x := v.Args[0] 24484 v_1 := v.Args[1] 24485 if v_1.Op != OpConst64 { 24486 break 24487 } 24488 c := v_1.AuxInt 24489 if !(uint64(c) >= 8) { 24490 break 24491 } 24492 v.reset(Op386SARBconst) 24493 v.AuxInt = 7 24494 v.AddArg(x) 24495 return true 24496 } 24497 return false 24498 } 24499 func rewriteValue386_OpRsh8x8_0(v *Value) bool { 24500 b := v.Block 24501 _ = b 24502 // match: (Rsh8x8 <t> x y) 24503 // cond: 24504 // result: (SARB <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [8]))))) 24505 for { 24506 t := v.Type 24507 _ = v.Args[1] 24508 x := v.Args[0] 24509 y := v.Args[1] 24510 v.reset(Op386SARB) 24511 v.Type = t 24512 v.AddArg(x) 24513 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type) 24514 v0.AddArg(y) 24515 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type) 24516 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type) 24517 v3 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags) 24518 v3.AuxInt = 8 24519 v3.AddArg(y) 24520 v2.AddArg(v3) 24521 v1.AddArg(v2) 24522 v0.AddArg(v1) 24523 v.AddArg(v0) 24524 return true 24525 } 24526 } 24527 func rewriteValue386_OpSelect0_0(v *Value) bool { 24528 b := v.Block 24529 _ = b 24530 typ := &b.Func.Config.Types 24531 _ = typ 24532 // match: (Select0 (Mul32uover x y)) 24533 // cond: 24534 // result: (Select0 <typ.UInt32> (MULLU x y)) 24535 for { 24536 v_0 := v.Args[0] 24537 if v_0.Op != OpMul32uover { 24538 break 24539 } 24540 _ = v_0.Args[1] 24541 x := v_0.Args[0] 24542 y := v_0.Args[1] 24543 v.reset(OpSelect0) 24544 v.Type = typ.UInt32 24545 v0 := b.NewValue0(v.Pos, Op386MULLU, types.NewTuple(typ.UInt32, types.TypeFlags)) 24546 v0.AddArg(x) 24547 v0.AddArg(y) 24548 v.AddArg(v0) 24549 return true 24550 } 24551 return false 24552 } 24553 func rewriteValue386_OpSelect1_0(v *Value) bool { 24554 b := v.Block 24555 _ = b 24556 typ := &b.Func.Config.Types 24557 _ = typ 24558 // match: (Select1 (Mul32uover x y)) 24559 // cond: 24560 // result: (SETO (Select1 <types.TypeFlags> (MULLU x y))) 24561 for { 24562 v_0 := v.Args[0] 24563 if v_0.Op != OpMul32uover { 24564 break 24565 } 24566 _ = v_0.Args[1] 24567 x := v_0.Args[0] 24568 y := v_0.Args[1] 24569 v.reset(Op386SETO) 24570 v0 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags) 24571 v1 := b.NewValue0(v.Pos, Op386MULLU, types.NewTuple(typ.UInt32, types.TypeFlags)) 24572 v1.AddArg(x) 24573 v1.AddArg(y) 24574 v0.AddArg(v1) 24575 v.AddArg(v0) 24576 return true 24577 } 24578 return false 24579 } 24580 func rewriteValue386_OpSignExt16to32_0(v *Value) bool { 24581 // match: (SignExt16to32 x) 24582 // cond: 24583 // result: (MOVWLSX x) 24584 for { 24585 x := v.Args[0] 24586 v.reset(Op386MOVWLSX) 24587 v.AddArg(x) 24588 return true 24589 } 24590 } 24591 func rewriteValue386_OpSignExt8to16_0(v *Value) bool { 24592 // match: (SignExt8to16 x) 24593 // cond: 24594 // result: (MOVBLSX x) 24595 for { 24596 x := v.Args[0] 24597 v.reset(Op386MOVBLSX) 24598 v.AddArg(x) 24599 return true 24600 } 24601 } 24602 func rewriteValue386_OpSignExt8to32_0(v *Value) bool { 24603 // match: (SignExt8to32 x) 24604 // cond: 24605 // result: (MOVBLSX x) 24606 for { 24607 x := v.Args[0] 24608 v.reset(Op386MOVBLSX) 24609 v.AddArg(x) 24610 return true 24611 } 24612 } 24613 func rewriteValue386_OpSignmask_0(v *Value) bool { 24614 // match: (Signmask x) 24615 // cond: 24616 // result: (SARLconst x [31]) 24617 for { 24618 x := v.Args[0] 24619 v.reset(Op386SARLconst) 24620 v.AuxInt = 31 24621 v.AddArg(x) 24622 return true 24623 } 24624 } 24625 func rewriteValue386_OpSlicemask_0(v *Value) bool { 24626 b := v.Block 24627 _ = b 24628 // match: (Slicemask <t> x) 24629 // cond: 24630 // result: (SARLconst (NEGL <t> x) [31]) 24631 for { 24632 t := v.Type 24633 x := v.Args[0] 24634 v.reset(Op386SARLconst) 24635 v.AuxInt = 31 24636 v0 := b.NewValue0(v.Pos, Op386NEGL, t) 24637 v0.AddArg(x) 24638 v.AddArg(v0) 24639 return true 24640 } 24641 } 24642 func rewriteValue386_OpSqrt_0(v *Value) bool { 24643 // match: (Sqrt x) 24644 // cond: 24645 // result: (SQRTSD x) 24646 for { 24647 x := v.Args[0] 24648 v.reset(Op386SQRTSD) 24649 v.AddArg(x) 24650 return true 24651 } 24652 } 24653 func rewriteValue386_OpStaticCall_0(v *Value) bool { 24654 // match: (StaticCall [argwid] {target} mem) 24655 // cond: 24656 // result: (CALLstatic [argwid] {target} mem) 24657 for { 24658 argwid := v.AuxInt 24659 target := v.Aux 24660 mem := v.Args[0] 24661 v.reset(Op386CALLstatic) 24662 v.AuxInt = argwid 24663 v.Aux = target 24664 v.AddArg(mem) 24665 return true 24666 } 24667 } 24668 func rewriteValue386_OpStore_0(v *Value) bool { 24669 // match: (Store {t} ptr val mem) 24670 // cond: t.(*types.Type).Size() == 8 && is64BitFloat(val.Type) 24671 // result: (MOVSDstore ptr val mem) 24672 for { 24673 t := v.Aux 24674 _ = v.Args[2] 24675 ptr := v.Args[0] 24676 val := v.Args[1] 24677 mem := v.Args[2] 24678 if !(t.(*types.Type).Size() == 8 && is64BitFloat(val.Type)) { 24679 break 24680 } 24681 v.reset(Op386MOVSDstore) 24682 v.AddArg(ptr) 24683 v.AddArg(val) 24684 v.AddArg(mem) 24685 return true 24686 } 24687 // match: (Store {t} ptr val mem) 24688 // cond: t.(*types.Type).Size() == 4 && is32BitFloat(val.Type) 24689 // result: (MOVSSstore ptr val mem) 24690 for { 24691 t := v.Aux 24692 _ = v.Args[2] 24693 ptr := v.Args[0] 24694 val := v.Args[1] 24695 mem := v.Args[2] 24696 if !(t.(*types.Type).Size() == 4 && is32BitFloat(val.Type)) { 24697 break 24698 } 24699 v.reset(Op386MOVSSstore) 24700 v.AddArg(ptr) 24701 v.AddArg(val) 24702 v.AddArg(mem) 24703 return true 24704 } 24705 // match: (Store {t} ptr val mem) 24706 // cond: t.(*types.Type).Size() == 4 24707 // result: (MOVLstore ptr val mem) 24708 for { 24709 t := v.Aux 24710 _ = v.Args[2] 24711 ptr := v.Args[0] 24712 val := v.Args[1] 24713 mem := v.Args[2] 24714 if !(t.(*types.Type).Size() == 4) { 24715 break 24716 } 24717 v.reset(Op386MOVLstore) 24718 v.AddArg(ptr) 24719 v.AddArg(val) 24720 v.AddArg(mem) 24721 return true 24722 } 24723 // match: (Store {t} ptr val mem) 24724 // cond: t.(*types.Type).Size() == 2 24725 // result: (MOVWstore ptr val mem) 24726 for { 24727 t := v.Aux 24728 _ = v.Args[2] 24729 ptr := v.Args[0] 24730 val := v.Args[1] 24731 mem := v.Args[2] 24732 if !(t.(*types.Type).Size() == 2) { 24733 break 24734 } 24735 v.reset(Op386MOVWstore) 24736 v.AddArg(ptr) 24737 v.AddArg(val) 24738 v.AddArg(mem) 24739 return true 24740 } 24741 // match: (Store {t} ptr val mem) 24742 // cond: t.(*types.Type).Size() == 1 24743 // result: (MOVBstore ptr val mem) 24744 for { 24745 t := v.Aux 24746 _ = v.Args[2] 24747 ptr := v.Args[0] 24748 val := v.Args[1] 24749 mem := v.Args[2] 24750 if !(t.(*types.Type).Size() == 1) { 24751 break 24752 } 24753 v.reset(Op386MOVBstore) 24754 v.AddArg(ptr) 24755 v.AddArg(val) 24756 v.AddArg(mem) 24757 return true 24758 } 24759 return false 24760 } 24761 func rewriteValue386_OpSub16_0(v *Value) bool { 24762 // match: (Sub16 x y) 24763 // cond: 24764 // result: (SUBL x y) 24765 for { 24766 _ = v.Args[1] 24767 x := v.Args[0] 24768 y := v.Args[1] 24769 v.reset(Op386SUBL) 24770 v.AddArg(x) 24771 v.AddArg(y) 24772 return true 24773 } 24774 } 24775 func rewriteValue386_OpSub32_0(v *Value) bool { 24776 // match: (Sub32 x y) 24777 // cond: 24778 // result: (SUBL x y) 24779 for { 24780 _ = v.Args[1] 24781 x := v.Args[0] 24782 y := v.Args[1] 24783 v.reset(Op386SUBL) 24784 v.AddArg(x) 24785 v.AddArg(y) 24786 return true 24787 } 24788 } 24789 func rewriteValue386_OpSub32F_0(v *Value) bool { 24790 // match: (Sub32F x y) 24791 // cond: 24792 // result: (SUBSS x y) 24793 for { 24794 _ = v.Args[1] 24795 x := v.Args[0] 24796 y := v.Args[1] 24797 v.reset(Op386SUBSS) 24798 v.AddArg(x) 24799 v.AddArg(y) 24800 return true 24801 } 24802 } 24803 func rewriteValue386_OpSub32carry_0(v *Value) bool { 24804 // match: (Sub32carry x y) 24805 // cond: 24806 // result: (SUBLcarry x y) 24807 for { 24808 _ = v.Args[1] 24809 x := v.Args[0] 24810 y := v.Args[1] 24811 v.reset(Op386SUBLcarry) 24812 v.AddArg(x) 24813 v.AddArg(y) 24814 return true 24815 } 24816 } 24817 func rewriteValue386_OpSub32withcarry_0(v *Value) bool { 24818 // match: (Sub32withcarry x y c) 24819 // cond: 24820 // result: (SBBL x y c) 24821 for { 24822 _ = v.Args[2] 24823 x := v.Args[0] 24824 y := v.Args[1] 24825 c := v.Args[2] 24826 v.reset(Op386SBBL) 24827 v.AddArg(x) 24828 v.AddArg(y) 24829 v.AddArg(c) 24830 return true 24831 } 24832 } 24833 func rewriteValue386_OpSub64F_0(v *Value) bool { 24834 // match: (Sub64F x y) 24835 // cond: 24836 // result: (SUBSD x y) 24837 for { 24838 _ = v.Args[1] 24839 x := v.Args[0] 24840 y := v.Args[1] 24841 v.reset(Op386SUBSD) 24842 v.AddArg(x) 24843 v.AddArg(y) 24844 return true 24845 } 24846 } 24847 func rewriteValue386_OpSub8_0(v *Value) bool { 24848 // match: (Sub8 x y) 24849 // cond: 24850 // result: (SUBL x y) 24851 for { 24852 _ = v.Args[1] 24853 x := v.Args[0] 24854 y := v.Args[1] 24855 v.reset(Op386SUBL) 24856 v.AddArg(x) 24857 v.AddArg(y) 24858 return true 24859 } 24860 } 24861 func rewriteValue386_OpSubPtr_0(v *Value) bool { 24862 // match: (SubPtr x y) 24863 // cond: 24864 // result: (SUBL x y) 24865 for { 24866 _ = v.Args[1] 24867 x := v.Args[0] 24868 y := v.Args[1] 24869 v.reset(Op386SUBL) 24870 v.AddArg(x) 24871 v.AddArg(y) 24872 return true 24873 } 24874 } 24875 func rewriteValue386_OpTrunc16to8_0(v *Value) bool { 24876 // match: (Trunc16to8 x) 24877 // cond: 24878 // result: x 24879 for { 24880 x := v.Args[0] 24881 v.reset(OpCopy) 24882 v.Type = x.Type 24883 v.AddArg(x) 24884 return true 24885 } 24886 } 24887 func rewriteValue386_OpTrunc32to16_0(v *Value) bool { 24888 // match: (Trunc32to16 x) 24889 // cond: 24890 // result: x 24891 for { 24892 x := v.Args[0] 24893 v.reset(OpCopy) 24894 v.Type = x.Type 24895 v.AddArg(x) 24896 return true 24897 } 24898 } 24899 func rewriteValue386_OpTrunc32to8_0(v *Value) bool { 24900 // match: (Trunc32to8 x) 24901 // cond: 24902 // result: x 24903 for { 24904 x := v.Args[0] 24905 v.reset(OpCopy) 24906 v.Type = x.Type 24907 v.AddArg(x) 24908 return true 24909 } 24910 } 24911 func rewriteValue386_OpWB_0(v *Value) bool { 24912 // match: (WB {fn} destptr srcptr mem) 24913 // cond: 24914 // result: (LoweredWB {fn} destptr srcptr mem) 24915 for { 24916 fn := v.Aux 24917 _ = v.Args[2] 24918 destptr := v.Args[0] 24919 srcptr := v.Args[1] 24920 mem := v.Args[2] 24921 v.reset(Op386LoweredWB) 24922 v.Aux = fn 24923 v.AddArg(destptr) 24924 v.AddArg(srcptr) 24925 v.AddArg(mem) 24926 return true 24927 } 24928 } 24929 func rewriteValue386_OpXor16_0(v *Value) bool { 24930 // match: (Xor16 x y) 24931 // cond: 24932 // result: (XORL x y) 24933 for { 24934 _ = v.Args[1] 24935 x := v.Args[0] 24936 y := v.Args[1] 24937 v.reset(Op386XORL) 24938 v.AddArg(x) 24939 v.AddArg(y) 24940 return true 24941 } 24942 } 24943 func rewriteValue386_OpXor32_0(v *Value) bool { 24944 // match: (Xor32 x y) 24945 // cond: 24946 // result: (XORL x y) 24947 for { 24948 _ = v.Args[1] 24949 x := v.Args[0] 24950 y := v.Args[1] 24951 v.reset(Op386XORL) 24952 v.AddArg(x) 24953 v.AddArg(y) 24954 return true 24955 } 24956 } 24957 func rewriteValue386_OpXor8_0(v *Value) bool { 24958 // match: (Xor8 x y) 24959 // cond: 24960 // result: (XORL x y) 24961 for { 24962 _ = v.Args[1] 24963 x := v.Args[0] 24964 y := v.Args[1] 24965 v.reset(Op386XORL) 24966 v.AddArg(x) 24967 v.AddArg(y) 24968 return true 24969 } 24970 } 24971 func rewriteValue386_OpZero_0(v *Value) bool { 24972 b := v.Block 24973 _ = b 24974 typ := &b.Func.Config.Types 24975 _ = typ 24976 // match: (Zero [0] _ mem) 24977 // cond: 24978 // result: mem 24979 for { 24980 if v.AuxInt != 0 { 24981 break 24982 } 24983 _ = v.Args[1] 24984 mem := v.Args[1] 24985 v.reset(OpCopy) 24986 v.Type = mem.Type 24987 v.AddArg(mem) 24988 return true 24989 } 24990 // match: (Zero [1] destptr mem) 24991 // cond: 24992 // result: (MOVBstoreconst [0] destptr mem) 24993 for { 24994 if v.AuxInt != 1 { 24995 break 24996 } 24997 _ = v.Args[1] 24998 destptr := v.Args[0] 24999 mem := v.Args[1] 25000 v.reset(Op386MOVBstoreconst) 25001 v.AuxInt = 0 25002 v.AddArg(destptr) 25003 v.AddArg(mem) 25004 return true 25005 } 25006 // match: (Zero [2] destptr mem) 25007 // cond: 25008 // result: (MOVWstoreconst [0] destptr mem) 25009 for { 25010 if v.AuxInt != 2 { 25011 break 25012 } 25013 _ = v.Args[1] 25014 destptr := v.Args[0] 25015 mem := v.Args[1] 25016 v.reset(Op386MOVWstoreconst) 25017 v.AuxInt = 0 25018 v.AddArg(destptr) 25019 v.AddArg(mem) 25020 return true 25021 } 25022 // match: (Zero [4] destptr mem) 25023 // cond: 25024 // result: (MOVLstoreconst [0] destptr mem) 25025 for { 25026 if v.AuxInt != 4 { 25027 break 25028 } 25029 _ = v.Args[1] 25030 destptr := v.Args[0] 25031 mem := v.Args[1] 25032 v.reset(Op386MOVLstoreconst) 25033 v.AuxInt = 0 25034 v.AddArg(destptr) 25035 v.AddArg(mem) 25036 return true 25037 } 25038 // match: (Zero [3] destptr mem) 25039 // cond: 25040 // result: (MOVBstoreconst [makeValAndOff(0,2)] destptr (MOVWstoreconst [0] destptr mem)) 25041 for { 25042 if v.AuxInt != 3 { 25043 break 25044 } 25045 _ = v.Args[1] 25046 destptr := v.Args[0] 25047 mem := v.Args[1] 25048 v.reset(Op386MOVBstoreconst) 25049 v.AuxInt = makeValAndOff(0, 2) 25050 v.AddArg(destptr) 25051 v0 := b.NewValue0(v.Pos, Op386MOVWstoreconst, types.TypeMem) 25052 v0.AuxInt = 0 25053 v0.AddArg(destptr) 25054 v0.AddArg(mem) 25055 v.AddArg(v0) 25056 return true 25057 } 25058 // match: (Zero [5] destptr mem) 25059 // cond: 25060 // result: (MOVBstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem)) 25061 for { 25062 if v.AuxInt != 5 { 25063 break 25064 } 25065 _ = v.Args[1] 25066 destptr := v.Args[0] 25067 mem := v.Args[1] 25068 v.reset(Op386MOVBstoreconst) 25069 v.AuxInt = makeValAndOff(0, 4) 25070 v.AddArg(destptr) 25071 v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem) 25072 v0.AuxInt = 0 25073 v0.AddArg(destptr) 25074 v0.AddArg(mem) 25075 v.AddArg(v0) 25076 return true 25077 } 25078 // match: (Zero [6] destptr mem) 25079 // cond: 25080 // result: (MOVWstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem)) 25081 for { 25082 if v.AuxInt != 6 { 25083 break 25084 } 25085 _ = v.Args[1] 25086 destptr := v.Args[0] 25087 mem := v.Args[1] 25088 v.reset(Op386MOVWstoreconst) 25089 v.AuxInt = makeValAndOff(0, 4) 25090 v.AddArg(destptr) 25091 v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem) 25092 v0.AuxInt = 0 25093 v0.AddArg(destptr) 25094 v0.AddArg(mem) 25095 v.AddArg(v0) 25096 return true 25097 } 25098 // match: (Zero [7] destptr mem) 25099 // cond: 25100 // result: (MOVLstoreconst [makeValAndOff(0,3)] destptr (MOVLstoreconst [0] destptr mem)) 25101 for { 25102 if v.AuxInt != 7 { 25103 break 25104 } 25105 _ = v.Args[1] 25106 destptr := v.Args[0] 25107 mem := v.Args[1] 25108 v.reset(Op386MOVLstoreconst) 25109 v.AuxInt = makeValAndOff(0, 3) 25110 v.AddArg(destptr) 25111 v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem) 25112 v0.AuxInt = 0 25113 v0.AddArg(destptr) 25114 v0.AddArg(mem) 25115 v.AddArg(v0) 25116 return true 25117 } 25118 // match: (Zero [s] destptr mem) 25119 // cond: s%4 != 0 && s > 4 25120 // result: (Zero [s-s%4] (ADDLconst destptr [s%4]) (MOVLstoreconst [0] destptr mem)) 25121 for { 25122 s := v.AuxInt 25123 _ = v.Args[1] 25124 destptr := v.Args[0] 25125 mem := v.Args[1] 25126 if !(s%4 != 0 && s > 4) { 25127 break 25128 } 25129 v.reset(OpZero) 25130 v.AuxInt = s - s%4 25131 v0 := b.NewValue0(v.Pos, Op386ADDLconst, typ.UInt32) 25132 v0.AuxInt = s % 4 25133 v0.AddArg(destptr) 25134 v.AddArg(v0) 25135 v1 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem) 25136 v1.AuxInt = 0 25137 v1.AddArg(destptr) 25138 v1.AddArg(mem) 25139 v.AddArg(v1) 25140 return true 25141 } 25142 // match: (Zero [8] destptr mem) 25143 // cond: 25144 // result: (MOVLstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem)) 25145 for { 25146 if v.AuxInt != 8 { 25147 break 25148 } 25149 _ = v.Args[1] 25150 destptr := v.Args[0] 25151 mem := v.Args[1] 25152 v.reset(Op386MOVLstoreconst) 25153 v.AuxInt = makeValAndOff(0, 4) 25154 v.AddArg(destptr) 25155 v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem) 25156 v0.AuxInt = 0 25157 v0.AddArg(destptr) 25158 v0.AddArg(mem) 25159 v.AddArg(v0) 25160 return true 25161 } 25162 return false 25163 } 25164 func rewriteValue386_OpZero_10(v *Value) bool { 25165 b := v.Block 25166 _ = b 25167 config := b.Func.Config 25168 _ = config 25169 typ := &b.Func.Config.Types 25170 _ = typ 25171 // match: (Zero [12] destptr mem) 25172 // cond: 25173 // result: (MOVLstoreconst [makeValAndOff(0,8)] destptr (MOVLstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem))) 25174 for { 25175 if v.AuxInt != 12 { 25176 break 25177 } 25178 _ = v.Args[1] 25179 destptr := v.Args[0] 25180 mem := v.Args[1] 25181 v.reset(Op386MOVLstoreconst) 25182 v.AuxInt = makeValAndOff(0, 8) 25183 v.AddArg(destptr) 25184 v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem) 25185 v0.AuxInt = makeValAndOff(0, 4) 25186 v0.AddArg(destptr) 25187 v1 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem) 25188 v1.AuxInt = 0 25189 v1.AddArg(destptr) 25190 v1.AddArg(mem) 25191 v0.AddArg(v1) 25192 v.AddArg(v0) 25193 return true 25194 } 25195 // match: (Zero [16] destptr mem) 25196 // cond: 25197 // result: (MOVLstoreconst [makeValAndOff(0,12)] destptr (MOVLstoreconst [makeValAndOff(0,8)] destptr (MOVLstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem)))) 25198 for { 25199 if v.AuxInt != 16 { 25200 break 25201 } 25202 _ = v.Args[1] 25203 destptr := v.Args[0] 25204 mem := v.Args[1] 25205 v.reset(Op386MOVLstoreconst) 25206 v.AuxInt = makeValAndOff(0, 12) 25207 v.AddArg(destptr) 25208 v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem) 25209 v0.AuxInt = makeValAndOff(0, 8) 25210 v0.AddArg(destptr) 25211 v1 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem) 25212 v1.AuxInt = makeValAndOff(0, 4) 25213 v1.AddArg(destptr) 25214 v2 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem) 25215 v2.AuxInt = 0 25216 v2.AddArg(destptr) 25217 v2.AddArg(mem) 25218 v1.AddArg(v2) 25219 v0.AddArg(v1) 25220 v.AddArg(v0) 25221 return true 25222 } 25223 // match: (Zero [s] destptr mem) 25224 // cond: s > 16 && s <= 4*128 && s%4 == 0 && !config.noDuffDevice 25225 // result: (DUFFZERO [1*(128-s/4)] destptr (MOVLconst [0]) mem) 25226 for { 25227 s := v.AuxInt 25228 _ = v.Args[1] 25229 destptr := v.Args[0] 25230 mem := v.Args[1] 25231 if !(s > 16 && s <= 4*128 && s%4 == 0 && !config.noDuffDevice) { 25232 break 25233 } 25234 v.reset(Op386DUFFZERO) 25235 v.AuxInt = 1 * (128 - s/4) 25236 v.AddArg(destptr) 25237 v0 := b.NewValue0(v.Pos, Op386MOVLconst, typ.UInt32) 25238 v0.AuxInt = 0 25239 v.AddArg(v0) 25240 v.AddArg(mem) 25241 return true 25242 } 25243 // match: (Zero [s] destptr mem) 25244 // cond: (s > 4*128 || (config.noDuffDevice && s > 16)) && s%4 == 0 25245 // result: (REPSTOSL destptr (MOVLconst [s/4]) (MOVLconst [0]) mem) 25246 for { 25247 s := v.AuxInt 25248 _ = v.Args[1] 25249 destptr := v.Args[0] 25250 mem := v.Args[1] 25251 if !((s > 4*128 || (config.noDuffDevice && s > 16)) && s%4 == 0) { 25252 break 25253 } 25254 v.reset(Op386REPSTOSL) 25255 v.AddArg(destptr) 25256 v0 := b.NewValue0(v.Pos, Op386MOVLconst, typ.UInt32) 25257 v0.AuxInt = s / 4 25258 v.AddArg(v0) 25259 v1 := b.NewValue0(v.Pos, Op386MOVLconst, typ.UInt32) 25260 v1.AuxInt = 0 25261 v.AddArg(v1) 25262 v.AddArg(mem) 25263 return true 25264 } 25265 return false 25266 } 25267 func rewriteValue386_OpZeroExt16to32_0(v *Value) bool { 25268 // match: (ZeroExt16to32 x) 25269 // cond: 25270 // result: (MOVWLZX x) 25271 for { 25272 x := v.Args[0] 25273 v.reset(Op386MOVWLZX) 25274 v.AddArg(x) 25275 return true 25276 } 25277 } 25278 func rewriteValue386_OpZeroExt8to16_0(v *Value) bool { 25279 // match: (ZeroExt8to16 x) 25280 // cond: 25281 // result: (MOVBLZX x) 25282 for { 25283 x := v.Args[0] 25284 v.reset(Op386MOVBLZX) 25285 v.AddArg(x) 25286 return true 25287 } 25288 } 25289 func rewriteValue386_OpZeroExt8to32_0(v *Value) bool { 25290 // match: (ZeroExt8to32 x) 25291 // cond: 25292 // result: (MOVBLZX x) 25293 for { 25294 x := v.Args[0] 25295 v.reset(Op386MOVBLZX) 25296 v.AddArg(x) 25297 return true 25298 } 25299 } 25300 func rewriteValue386_OpZeromask_0(v *Value) bool { 25301 b := v.Block 25302 _ = b 25303 // match: (Zeromask <t> x) 25304 // cond: 25305 // result: (XORLconst [-1] (SBBLcarrymask <t> (CMPLconst x [1]))) 25306 for { 25307 t := v.Type 25308 x := v.Args[0] 25309 v.reset(Op386XORLconst) 25310 v.AuxInt = -1 25311 v0 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t) 25312 v1 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags) 25313 v1.AuxInt = 1 25314 v1.AddArg(x) 25315 v0.AddArg(v1) 25316 v.AddArg(v0) 25317 return true 25318 } 25319 } 25320 func rewriteBlock386(b *Block) bool { 25321 config := b.Func.Config 25322 _ = config 25323 fe := b.Func.fe 25324 _ = fe 25325 typ := &config.Types 25326 _ = typ 25327 switch b.Kind { 25328 case Block386EQ: 25329 // match: (EQ (InvertFlags cmp) yes no) 25330 // cond: 25331 // result: (EQ cmp yes no) 25332 for { 25333 v := b.Control 25334 if v.Op != Op386InvertFlags { 25335 break 25336 } 25337 cmp := v.Args[0] 25338 b.Kind = Block386EQ 25339 b.SetControl(cmp) 25340 b.Aux = nil 25341 return true 25342 } 25343 // match: (EQ (FlagEQ) yes no) 25344 // cond: 25345 // result: (First nil yes no) 25346 for { 25347 v := b.Control 25348 if v.Op != Op386FlagEQ { 25349 break 25350 } 25351 b.Kind = BlockFirst 25352 b.SetControl(nil) 25353 b.Aux = nil 25354 return true 25355 } 25356 // match: (EQ (FlagLT_ULT) yes no) 25357 // cond: 25358 // result: (First nil no yes) 25359 for { 25360 v := b.Control 25361 if v.Op != Op386FlagLT_ULT { 25362 break 25363 } 25364 b.Kind = BlockFirst 25365 b.SetControl(nil) 25366 b.Aux = nil 25367 b.swapSuccessors() 25368 return true 25369 } 25370 // match: (EQ (FlagLT_UGT) yes no) 25371 // cond: 25372 // result: (First nil no yes) 25373 for { 25374 v := b.Control 25375 if v.Op != Op386FlagLT_UGT { 25376 break 25377 } 25378 b.Kind = BlockFirst 25379 b.SetControl(nil) 25380 b.Aux = nil 25381 b.swapSuccessors() 25382 return true 25383 } 25384 // match: (EQ (FlagGT_ULT) yes no) 25385 // cond: 25386 // result: (First nil no yes) 25387 for { 25388 v := b.Control 25389 if v.Op != Op386FlagGT_ULT { 25390 break 25391 } 25392 b.Kind = BlockFirst 25393 b.SetControl(nil) 25394 b.Aux = nil 25395 b.swapSuccessors() 25396 return true 25397 } 25398 // match: (EQ (FlagGT_UGT) yes no) 25399 // cond: 25400 // result: (First nil no yes) 25401 for { 25402 v := b.Control 25403 if v.Op != Op386FlagGT_UGT { 25404 break 25405 } 25406 b.Kind = BlockFirst 25407 b.SetControl(nil) 25408 b.Aux = nil 25409 b.swapSuccessors() 25410 return true 25411 } 25412 case Block386GE: 25413 // match: (GE (InvertFlags cmp) yes no) 25414 // cond: 25415 // result: (LE cmp yes no) 25416 for { 25417 v := b.Control 25418 if v.Op != Op386InvertFlags { 25419 break 25420 } 25421 cmp := v.Args[0] 25422 b.Kind = Block386LE 25423 b.SetControl(cmp) 25424 b.Aux = nil 25425 return true 25426 } 25427 // match: (GE (FlagEQ) yes no) 25428 // cond: 25429 // result: (First nil yes no) 25430 for { 25431 v := b.Control 25432 if v.Op != Op386FlagEQ { 25433 break 25434 } 25435 b.Kind = BlockFirst 25436 b.SetControl(nil) 25437 b.Aux = nil 25438 return true 25439 } 25440 // match: (GE (FlagLT_ULT) yes no) 25441 // cond: 25442 // result: (First nil no yes) 25443 for { 25444 v := b.Control 25445 if v.Op != Op386FlagLT_ULT { 25446 break 25447 } 25448 b.Kind = BlockFirst 25449 b.SetControl(nil) 25450 b.Aux = nil 25451 b.swapSuccessors() 25452 return true 25453 } 25454 // match: (GE (FlagLT_UGT) yes no) 25455 // cond: 25456 // result: (First nil no yes) 25457 for { 25458 v := b.Control 25459 if v.Op != Op386FlagLT_UGT { 25460 break 25461 } 25462 b.Kind = BlockFirst 25463 b.SetControl(nil) 25464 b.Aux = nil 25465 b.swapSuccessors() 25466 return true 25467 } 25468 // match: (GE (FlagGT_ULT) yes no) 25469 // cond: 25470 // result: (First nil yes no) 25471 for { 25472 v := b.Control 25473 if v.Op != Op386FlagGT_ULT { 25474 break 25475 } 25476 b.Kind = BlockFirst 25477 b.SetControl(nil) 25478 b.Aux = nil 25479 return true 25480 } 25481 // match: (GE (FlagGT_UGT) yes no) 25482 // cond: 25483 // result: (First nil yes no) 25484 for { 25485 v := b.Control 25486 if v.Op != Op386FlagGT_UGT { 25487 break 25488 } 25489 b.Kind = BlockFirst 25490 b.SetControl(nil) 25491 b.Aux = nil 25492 return true 25493 } 25494 case Block386GT: 25495 // match: (GT (InvertFlags cmp) yes no) 25496 // cond: 25497 // result: (LT cmp yes no) 25498 for { 25499 v := b.Control 25500 if v.Op != Op386InvertFlags { 25501 break 25502 } 25503 cmp := v.Args[0] 25504 b.Kind = Block386LT 25505 b.SetControl(cmp) 25506 b.Aux = nil 25507 return true 25508 } 25509 // match: (GT (FlagEQ) yes no) 25510 // cond: 25511 // result: (First nil no yes) 25512 for { 25513 v := b.Control 25514 if v.Op != Op386FlagEQ { 25515 break 25516 } 25517 b.Kind = BlockFirst 25518 b.SetControl(nil) 25519 b.Aux = nil 25520 b.swapSuccessors() 25521 return true 25522 } 25523 // match: (GT (FlagLT_ULT) yes no) 25524 // cond: 25525 // result: (First nil no yes) 25526 for { 25527 v := b.Control 25528 if v.Op != Op386FlagLT_ULT { 25529 break 25530 } 25531 b.Kind = BlockFirst 25532 b.SetControl(nil) 25533 b.Aux = nil 25534 b.swapSuccessors() 25535 return true 25536 } 25537 // match: (GT (FlagLT_UGT) yes no) 25538 // cond: 25539 // result: (First nil no yes) 25540 for { 25541 v := b.Control 25542 if v.Op != Op386FlagLT_UGT { 25543 break 25544 } 25545 b.Kind = BlockFirst 25546 b.SetControl(nil) 25547 b.Aux = nil 25548 b.swapSuccessors() 25549 return true 25550 } 25551 // match: (GT (FlagGT_ULT) yes no) 25552 // cond: 25553 // result: (First nil yes no) 25554 for { 25555 v := b.Control 25556 if v.Op != Op386FlagGT_ULT { 25557 break 25558 } 25559 b.Kind = BlockFirst 25560 b.SetControl(nil) 25561 b.Aux = nil 25562 return true 25563 } 25564 // match: (GT (FlagGT_UGT) yes no) 25565 // cond: 25566 // result: (First nil yes no) 25567 for { 25568 v := b.Control 25569 if v.Op != Op386FlagGT_UGT { 25570 break 25571 } 25572 b.Kind = BlockFirst 25573 b.SetControl(nil) 25574 b.Aux = nil 25575 return true 25576 } 25577 case BlockIf: 25578 // match: (If (SETL cmp) yes no) 25579 // cond: 25580 // result: (LT cmp yes no) 25581 for { 25582 v := b.Control 25583 if v.Op != Op386SETL { 25584 break 25585 } 25586 cmp := v.Args[0] 25587 b.Kind = Block386LT 25588 b.SetControl(cmp) 25589 b.Aux = nil 25590 return true 25591 } 25592 // match: (If (SETLE cmp) yes no) 25593 // cond: 25594 // result: (LE cmp yes no) 25595 for { 25596 v := b.Control 25597 if v.Op != Op386SETLE { 25598 break 25599 } 25600 cmp := v.Args[0] 25601 b.Kind = Block386LE 25602 b.SetControl(cmp) 25603 b.Aux = nil 25604 return true 25605 } 25606 // match: (If (SETG cmp) yes no) 25607 // cond: 25608 // result: (GT cmp yes no) 25609 for { 25610 v := b.Control 25611 if v.Op != Op386SETG { 25612 break 25613 } 25614 cmp := v.Args[0] 25615 b.Kind = Block386GT 25616 b.SetControl(cmp) 25617 b.Aux = nil 25618 return true 25619 } 25620 // match: (If (SETGE cmp) yes no) 25621 // cond: 25622 // result: (GE cmp yes no) 25623 for { 25624 v := b.Control 25625 if v.Op != Op386SETGE { 25626 break 25627 } 25628 cmp := v.Args[0] 25629 b.Kind = Block386GE 25630 b.SetControl(cmp) 25631 b.Aux = nil 25632 return true 25633 } 25634 // match: (If (SETEQ cmp) yes no) 25635 // cond: 25636 // result: (EQ cmp yes no) 25637 for { 25638 v := b.Control 25639 if v.Op != Op386SETEQ { 25640 break 25641 } 25642 cmp := v.Args[0] 25643 b.Kind = Block386EQ 25644 b.SetControl(cmp) 25645 b.Aux = nil 25646 return true 25647 } 25648 // match: (If (SETNE cmp) yes no) 25649 // cond: 25650 // result: (NE cmp yes no) 25651 for { 25652 v := b.Control 25653 if v.Op != Op386SETNE { 25654 break 25655 } 25656 cmp := v.Args[0] 25657 b.Kind = Block386NE 25658 b.SetControl(cmp) 25659 b.Aux = nil 25660 return true 25661 } 25662 // match: (If (SETB cmp) yes no) 25663 // cond: 25664 // result: (ULT cmp yes no) 25665 for { 25666 v := b.Control 25667 if v.Op != Op386SETB { 25668 break 25669 } 25670 cmp := v.Args[0] 25671 b.Kind = Block386ULT 25672 b.SetControl(cmp) 25673 b.Aux = nil 25674 return true 25675 } 25676 // match: (If (SETBE cmp) yes no) 25677 // cond: 25678 // result: (ULE cmp yes no) 25679 for { 25680 v := b.Control 25681 if v.Op != Op386SETBE { 25682 break 25683 } 25684 cmp := v.Args[0] 25685 b.Kind = Block386ULE 25686 b.SetControl(cmp) 25687 b.Aux = nil 25688 return true 25689 } 25690 // match: (If (SETA cmp) yes no) 25691 // cond: 25692 // result: (UGT cmp yes no) 25693 for { 25694 v := b.Control 25695 if v.Op != Op386SETA { 25696 break 25697 } 25698 cmp := v.Args[0] 25699 b.Kind = Block386UGT 25700 b.SetControl(cmp) 25701 b.Aux = nil 25702 return true 25703 } 25704 // match: (If (SETAE cmp) yes no) 25705 // cond: 25706 // result: (UGE cmp yes no) 25707 for { 25708 v := b.Control 25709 if v.Op != Op386SETAE { 25710 break 25711 } 25712 cmp := v.Args[0] 25713 b.Kind = Block386UGE 25714 b.SetControl(cmp) 25715 b.Aux = nil 25716 return true 25717 } 25718 // match: (If (SETO cmp) yes no) 25719 // cond: 25720 // result: (OS cmp yes no) 25721 for { 25722 v := b.Control 25723 if v.Op != Op386SETO { 25724 break 25725 } 25726 cmp := v.Args[0] 25727 b.Kind = Block386OS 25728 b.SetControl(cmp) 25729 b.Aux = nil 25730 return true 25731 } 25732 // match: (If (SETGF cmp) yes no) 25733 // cond: 25734 // result: (UGT cmp yes no) 25735 for { 25736 v := b.Control 25737 if v.Op != Op386SETGF { 25738 break 25739 } 25740 cmp := v.Args[0] 25741 b.Kind = Block386UGT 25742 b.SetControl(cmp) 25743 b.Aux = nil 25744 return true 25745 } 25746 // match: (If (SETGEF cmp) yes no) 25747 // cond: 25748 // result: (UGE cmp yes no) 25749 for { 25750 v := b.Control 25751 if v.Op != Op386SETGEF { 25752 break 25753 } 25754 cmp := v.Args[0] 25755 b.Kind = Block386UGE 25756 b.SetControl(cmp) 25757 b.Aux = nil 25758 return true 25759 } 25760 // match: (If (SETEQF cmp) yes no) 25761 // cond: 25762 // result: (EQF cmp yes no) 25763 for { 25764 v := b.Control 25765 if v.Op != Op386SETEQF { 25766 break 25767 } 25768 cmp := v.Args[0] 25769 b.Kind = Block386EQF 25770 b.SetControl(cmp) 25771 b.Aux = nil 25772 return true 25773 } 25774 // match: (If (SETNEF cmp) yes no) 25775 // cond: 25776 // result: (NEF cmp yes no) 25777 for { 25778 v := b.Control 25779 if v.Op != Op386SETNEF { 25780 break 25781 } 25782 cmp := v.Args[0] 25783 b.Kind = Block386NEF 25784 b.SetControl(cmp) 25785 b.Aux = nil 25786 return true 25787 } 25788 // match: (If cond yes no) 25789 // cond: 25790 // result: (NE (TESTB cond cond) yes no) 25791 for { 25792 v := b.Control 25793 _ = v 25794 cond := b.Control 25795 b.Kind = Block386NE 25796 v0 := b.NewValue0(v.Pos, Op386TESTB, types.TypeFlags) 25797 v0.AddArg(cond) 25798 v0.AddArg(cond) 25799 b.SetControl(v0) 25800 b.Aux = nil 25801 return true 25802 } 25803 case Block386LE: 25804 // match: (LE (InvertFlags cmp) yes no) 25805 // cond: 25806 // result: (GE cmp yes no) 25807 for { 25808 v := b.Control 25809 if v.Op != Op386InvertFlags { 25810 break 25811 } 25812 cmp := v.Args[0] 25813 b.Kind = Block386GE 25814 b.SetControl(cmp) 25815 b.Aux = nil 25816 return true 25817 } 25818 // match: (LE (FlagEQ) yes no) 25819 // cond: 25820 // result: (First nil yes no) 25821 for { 25822 v := b.Control 25823 if v.Op != Op386FlagEQ { 25824 break 25825 } 25826 b.Kind = BlockFirst 25827 b.SetControl(nil) 25828 b.Aux = nil 25829 return true 25830 } 25831 // match: (LE (FlagLT_ULT) yes no) 25832 // cond: 25833 // result: (First nil yes no) 25834 for { 25835 v := b.Control 25836 if v.Op != Op386FlagLT_ULT { 25837 break 25838 } 25839 b.Kind = BlockFirst 25840 b.SetControl(nil) 25841 b.Aux = nil 25842 return true 25843 } 25844 // match: (LE (FlagLT_UGT) yes no) 25845 // cond: 25846 // result: (First nil yes no) 25847 for { 25848 v := b.Control 25849 if v.Op != Op386FlagLT_UGT { 25850 break 25851 } 25852 b.Kind = BlockFirst 25853 b.SetControl(nil) 25854 b.Aux = nil 25855 return true 25856 } 25857 // match: (LE (FlagGT_ULT) yes no) 25858 // cond: 25859 // result: (First nil no yes) 25860 for { 25861 v := b.Control 25862 if v.Op != Op386FlagGT_ULT { 25863 break 25864 } 25865 b.Kind = BlockFirst 25866 b.SetControl(nil) 25867 b.Aux = nil 25868 b.swapSuccessors() 25869 return true 25870 } 25871 // match: (LE (FlagGT_UGT) yes no) 25872 // cond: 25873 // result: (First nil no yes) 25874 for { 25875 v := b.Control 25876 if v.Op != Op386FlagGT_UGT { 25877 break 25878 } 25879 b.Kind = BlockFirst 25880 b.SetControl(nil) 25881 b.Aux = nil 25882 b.swapSuccessors() 25883 return true 25884 } 25885 case Block386LT: 25886 // match: (LT (InvertFlags cmp) yes no) 25887 // cond: 25888 // result: (GT cmp yes no) 25889 for { 25890 v := b.Control 25891 if v.Op != Op386InvertFlags { 25892 break 25893 } 25894 cmp := v.Args[0] 25895 b.Kind = Block386GT 25896 b.SetControl(cmp) 25897 b.Aux = nil 25898 return true 25899 } 25900 // match: (LT (FlagEQ) yes no) 25901 // cond: 25902 // result: (First nil no yes) 25903 for { 25904 v := b.Control 25905 if v.Op != Op386FlagEQ { 25906 break 25907 } 25908 b.Kind = BlockFirst 25909 b.SetControl(nil) 25910 b.Aux = nil 25911 b.swapSuccessors() 25912 return true 25913 } 25914 // match: (LT (FlagLT_ULT) yes no) 25915 // cond: 25916 // result: (First nil yes no) 25917 for { 25918 v := b.Control 25919 if v.Op != Op386FlagLT_ULT { 25920 break 25921 } 25922 b.Kind = BlockFirst 25923 b.SetControl(nil) 25924 b.Aux = nil 25925 return true 25926 } 25927 // match: (LT (FlagLT_UGT) yes no) 25928 // cond: 25929 // result: (First nil yes no) 25930 for { 25931 v := b.Control 25932 if v.Op != Op386FlagLT_UGT { 25933 break 25934 } 25935 b.Kind = BlockFirst 25936 b.SetControl(nil) 25937 b.Aux = nil 25938 return true 25939 } 25940 // match: (LT (FlagGT_ULT) yes no) 25941 // cond: 25942 // result: (First nil no yes) 25943 for { 25944 v := b.Control 25945 if v.Op != Op386FlagGT_ULT { 25946 break 25947 } 25948 b.Kind = BlockFirst 25949 b.SetControl(nil) 25950 b.Aux = nil 25951 b.swapSuccessors() 25952 return true 25953 } 25954 // match: (LT (FlagGT_UGT) yes no) 25955 // cond: 25956 // result: (First nil no yes) 25957 for { 25958 v := b.Control 25959 if v.Op != Op386FlagGT_UGT { 25960 break 25961 } 25962 b.Kind = BlockFirst 25963 b.SetControl(nil) 25964 b.Aux = nil 25965 b.swapSuccessors() 25966 return true 25967 } 25968 case Block386NE: 25969 // match: (NE (TESTB (SETL cmp) (SETL cmp)) yes no) 25970 // cond: 25971 // result: (LT cmp yes no) 25972 for { 25973 v := b.Control 25974 if v.Op != Op386TESTB { 25975 break 25976 } 25977 _ = v.Args[1] 25978 v_0 := v.Args[0] 25979 if v_0.Op != Op386SETL { 25980 break 25981 } 25982 cmp := v_0.Args[0] 25983 v_1 := v.Args[1] 25984 if v_1.Op != Op386SETL { 25985 break 25986 } 25987 if cmp != v_1.Args[0] { 25988 break 25989 } 25990 b.Kind = Block386LT 25991 b.SetControl(cmp) 25992 b.Aux = nil 25993 return true 25994 } 25995 // match: (NE (TESTB (SETL cmp) (SETL cmp)) yes no) 25996 // cond: 25997 // result: (LT cmp yes no) 25998 for { 25999 v := b.Control 26000 if v.Op != Op386TESTB { 26001 break 26002 } 26003 _ = v.Args[1] 26004 v_0 := v.Args[0] 26005 if v_0.Op != Op386SETL { 26006 break 26007 } 26008 cmp := v_0.Args[0] 26009 v_1 := v.Args[1] 26010 if v_1.Op != Op386SETL { 26011 break 26012 } 26013 if cmp != v_1.Args[0] { 26014 break 26015 } 26016 b.Kind = Block386LT 26017 b.SetControl(cmp) 26018 b.Aux = nil 26019 return true 26020 } 26021 // match: (NE (TESTB (SETLE cmp) (SETLE cmp)) yes no) 26022 // cond: 26023 // result: (LE cmp yes no) 26024 for { 26025 v := b.Control 26026 if v.Op != Op386TESTB { 26027 break 26028 } 26029 _ = v.Args[1] 26030 v_0 := v.Args[0] 26031 if v_0.Op != Op386SETLE { 26032 break 26033 } 26034 cmp := v_0.Args[0] 26035 v_1 := v.Args[1] 26036 if v_1.Op != Op386SETLE { 26037 break 26038 } 26039 if cmp != v_1.Args[0] { 26040 break 26041 } 26042 b.Kind = Block386LE 26043 b.SetControl(cmp) 26044 b.Aux = nil 26045 return true 26046 } 26047 // match: (NE (TESTB (SETLE cmp) (SETLE cmp)) yes no) 26048 // cond: 26049 // result: (LE cmp yes no) 26050 for { 26051 v := b.Control 26052 if v.Op != Op386TESTB { 26053 break 26054 } 26055 _ = v.Args[1] 26056 v_0 := v.Args[0] 26057 if v_0.Op != Op386SETLE { 26058 break 26059 } 26060 cmp := v_0.Args[0] 26061 v_1 := v.Args[1] 26062 if v_1.Op != Op386SETLE { 26063 break 26064 } 26065 if cmp != v_1.Args[0] { 26066 break 26067 } 26068 b.Kind = Block386LE 26069 b.SetControl(cmp) 26070 b.Aux = nil 26071 return true 26072 } 26073 // match: (NE (TESTB (SETG cmp) (SETG cmp)) yes no) 26074 // cond: 26075 // result: (GT cmp yes no) 26076 for { 26077 v := b.Control 26078 if v.Op != Op386TESTB { 26079 break 26080 } 26081 _ = v.Args[1] 26082 v_0 := v.Args[0] 26083 if v_0.Op != Op386SETG { 26084 break 26085 } 26086 cmp := v_0.Args[0] 26087 v_1 := v.Args[1] 26088 if v_1.Op != Op386SETG { 26089 break 26090 } 26091 if cmp != v_1.Args[0] { 26092 break 26093 } 26094 b.Kind = Block386GT 26095 b.SetControl(cmp) 26096 b.Aux = nil 26097 return true 26098 } 26099 // match: (NE (TESTB (SETG cmp) (SETG cmp)) yes no) 26100 // cond: 26101 // result: (GT cmp yes no) 26102 for { 26103 v := b.Control 26104 if v.Op != Op386TESTB { 26105 break 26106 } 26107 _ = v.Args[1] 26108 v_0 := v.Args[0] 26109 if v_0.Op != Op386SETG { 26110 break 26111 } 26112 cmp := v_0.Args[0] 26113 v_1 := v.Args[1] 26114 if v_1.Op != Op386SETG { 26115 break 26116 } 26117 if cmp != v_1.Args[0] { 26118 break 26119 } 26120 b.Kind = Block386GT 26121 b.SetControl(cmp) 26122 b.Aux = nil 26123 return true 26124 } 26125 // match: (NE (TESTB (SETGE cmp) (SETGE cmp)) yes no) 26126 // cond: 26127 // result: (GE cmp yes no) 26128 for { 26129 v := b.Control 26130 if v.Op != Op386TESTB { 26131 break 26132 } 26133 _ = v.Args[1] 26134 v_0 := v.Args[0] 26135 if v_0.Op != Op386SETGE { 26136 break 26137 } 26138 cmp := v_0.Args[0] 26139 v_1 := v.Args[1] 26140 if v_1.Op != Op386SETGE { 26141 break 26142 } 26143 if cmp != v_1.Args[0] { 26144 break 26145 } 26146 b.Kind = Block386GE 26147 b.SetControl(cmp) 26148 b.Aux = nil 26149 return true 26150 } 26151 // match: (NE (TESTB (SETGE cmp) (SETGE cmp)) yes no) 26152 // cond: 26153 // result: (GE cmp yes no) 26154 for { 26155 v := b.Control 26156 if v.Op != Op386TESTB { 26157 break 26158 } 26159 _ = v.Args[1] 26160 v_0 := v.Args[0] 26161 if v_0.Op != Op386SETGE { 26162 break 26163 } 26164 cmp := v_0.Args[0] 26165 v_1 := v.Args[1] 26166 if v_1.Op != Op386SETGE { 26167 break 26168 } 26169 if cmp != v_1.Args[0] { 26170 break 26171 } 26172 b.Kind = Block386GE 26173 b.SetControl(cmp) 26174 b.Aux = nil 26175 return true 26176 } 26177 // match: (NE (TESTB (SETEQ cmp) (SETEQ cmp)) yes no) 26178 // cond: 26179 // result: (EQ cmp yes no) 26180 for { 26181 v := b.Control 26182 if v.Op != Op386TESTB { 26183 break 26184 } 26185 _ = v.Args[1] 26186 v_0 := v.Args[0] 26187 if v_0.Op != Op386SETEQ { 26188 break 26189 } 26190 cmp := v_0.Args[0] 26191 v_1 := v.Args[1] 26192 if v_1.Op != Op386SETEQ { 26193 break 26194 } 26195 if cmp != v_1.Args[0] { 26196 break 26197 } 26198 b.Kind = Block386EQ 26199 b.SetControl(cmp) 26200 b.Aux = nil 26201 return true 26202 } 26203 // match: (NE (TESTB (SETEQ cmp) (SETEQ cmp)) yes no) 26204 // cond: 26205 // result: (EQ cmp yes no) 26206 for { 26207 v := b.Control 26208 if v.Op != Op386TESTB { 26209 break 26210 } 26211 _ = v.Args[1] 26212 v_0 := v.Args[0] 26213 if v_0.Op != Op386SETEQ { 26214 break 26215 } 26216 cmp := v_0.Args[0] 26217 v_1 := v.Args[1] 26218 if v_1.Op != Op386SETEQ { 26219 break 26220 } 26221 if cmp != v_1.Args[0] { 26222 break 26223 } 26224 b.Kind = Block386EQ 26225 b.SetControl(cmp) 26226 b.Aux = nil 26227 return true 26228 } 26229 // match: (NE (TESTB (SETNE cmp) (SETNE cmp)) yes no) 26230 // cond: 26231 // result: (NE cmp yes no) 26232 for { 26233 v := b.Control 26234 if v.Op != Op386TESTB { 26235 break 26236 } 26237 _ = v.Args[1] 26238 v_0 := v.Args[0] 26239 if v_0.Op != Op386SETNE { 26240 break 26241 } 26242 cmp := v_0.Args[0] 26243 v_1 := v.Args[1] 26244 if v_1.Op != Op386SETNE { 26245 break 26246 } 26247 if cmp != v_1.Args[0] { 26248 break 26249 } 26250 b.Kind = Block386NE 26251 b.SetControl(cmp) 26252 b.Aux = nil 26253 return true 26254 } 26255 // match: (NE (TESTB (SETNE cmp) (SETNE cmp)) yes no) 26256 // cond: 26257 // result: (NE cmp yes no) 26258 for { 26259 v := b.Control 26260 if v.Op != Op386TESTB { 26261 break 26262 } 26263 _ = v.Args[1] 26264 v_0 := v.Args[0] 26265 if v_0.Op != Op386SETNE { 26266 break 26267 } 26268 cmp := v_0.Args[0] 26269 v_1 := v.Args[1] 26270 if v_1.Op != Op386SETNE { 26271 break 26272 } 26273 if cmp != v_1.Args[0] { 26274 break 26275 } 26276 b.Kind = Block386NE 26277 b.SetControl(cmp) 26278 b.Aux = nil 26279 return true 26280 } 26281 // match: (NE (TESTB (SETB cmp) (SETB cmp)) yes no) 26282 // cond: 26283 // result: (ULT cmp yes no) 26284 for { 26285 v := b.Control 26286 if v.Op != Op386TESTB { 26287 break 26288 } 26289 _ = v.Args[1] 26290 v_0 := v.Args[0] 26291 if v_0.Op != Op386SETB { 26292 break 26293 } 26294 cmp := v_0.Args[0] 26295 v_1 := v.Args[1] 26296 if v_1.Op != Op386SETB { 26297 break 26298 } 26299 if cmp != v_1.Args[0] { 26300 break 26301 } 26302 b.Kind = Block386ULT 26303 b.SetControl(cmp) 26304 b.Aux = nil 26305 return true 26306 } 26307 // match: (NE (TESTB (SETB cmp) (SETB cmp)) yes no) 26308 // cond: 26309 // result: (ULT cmp yes no) 26310 for { 26311 v := b.Control 26312 if v.Op != Op386TESTB { 26313 break 26314 } 26315 _ = v.Args[1] 26316 v_0 := v.Args[0] 26317 if v_0.Op != Op386SETB { 26318 break 26319 } 26320 cmp := v_0.Args[0] 26321 v_1 := v.Args[1] 26322 if v_1.Op != Op386SETB { 26323 break 26324 } 26325 if cmp != v_1.Args[0] { 26326 break 26327 } 26328 b.Kind = Block386ULT 26329 b.SetControl(cmp) 26330 b.Aux = nil 26331 return true 26332 } 26333 // match: (NE (TESTB (SETBE cmp) (SETBE cmp)) yes no) 26334 // cond: 26335 // result: (ULE cmp yes no) 26336 for { 26337 v := b.Control 26338 if v.Op != Op386TESTB { 26339 break 26340 } 26341 _ = v.Args[1] 26342 v_0 := v.Args[0] 26343 if v_0.Op != Op386SETBE { 26344 break 26345 } 26346 cmp := v_0.Args[0] 26347 v_1 := v.Args[1] 26348 if v_1.Op != Op386SETBE { 26349 break 26350 } 26351 if cmp != v_1.Args[0] { 26352 break 26353 } 26354 b.Kind = Block386ULE 26355 b.SetControl(cmp) 26356 b.Aux = nil 26357 return true 26358 } 26359 // match: (NE (TESTB (SETBE cmp) (SETBE cmp)) yes no) 26360 // cond: 26361 // result: (ULE cmp yes no) 26362 for { 26363 v := b.Control 26364 if v.Op != Op386TESTB { 26365 break 26366 } 26367 _ = v.Args[1] 26368 v_0 := v.Args[0] 26369 if v_0.Op != Op386SETBE { 26370 break 26371 } 26372 cmp := v_0.Args[0] 26373 v_1 := v.Args[1] 26374 if v_1.Op != Op386SETBE { 26375 break 26376 } 26377 if cmp != v_1.Args[0] { 26378 break 26379 } 26380 b.Kind = Block386ULE 26381 b.SetControl(cmp) 26382 b.Aux = nil 26383 return true 26384 } 26385 // match: (NE (TESTB (SETA cmp) (SETA cmp)) yes no) 26386 // cond: 26387 // result: (UGT cmp yes no) 26388 for { 26389 v := b.Control 26390 if v.Op != Op386TESTB { 26391 break 26392 } 26393 _ = v.Args[1] 26394 v_0 := v.Args[0] 26395 if v_0.Op != Op386SETA { 26396 break 26397 } 26398 cmp := v_0.Args[0] 26399 v_1 := v.Args[1] 26400 if v_1.Op != Op386SETA { 26401 break 26402 } 26403 if cmp != v_1.Args[0] { 26404 break 26405 } 26406 b.Kind = Block386UGT 26407 b.SetControl(cmp) 26408 b.Aux = nil 26409 return true 26410 } 26411 // match: (NE (TESTB (SETA cmp) (SETA cmp)) yes no) 26412 // cond: 26413 // result: (UGT cmp yes no) 26414 for { 26415 v := b.Control 26416 if v.Op != Op386TESTB { 26417 break 26418 } 26419 _ = v.Args[1] 26420 v_0 := v.Args[0] 26421 if v_0.Op != Op386SETA { 26422 break 26423 } 26424 cmp := v_0.Args[0] 26425 v_1 := v.Args[1] 26426 if v_1.Op != Op386SETA { 26427 break 26428 } 26429 if cmp != v_1.Args[0] { 26430 break 26431 } 26432 b.Kind = Block386UGT 26433 b.SetControl(cmp) 26434 b.Aux = nil 26435 return true 26436 } 26437 // match: (NE (TESTB (SETAE cmp) (SETAE cmp)) yes no) 26438 // cond: 26439 // result: (UGE cmp yes no) 26440 for { 26441 v := b.Control 26442 if v.Op != Op386TESTB { 26443 break 26444 } 26445 _ = v.Args[1] 26446 v_0 := v.Args[0] 26447 if v_0.Op != Op386SETAE { 26448 break 26449 } 26450 cmp := v_0.Args[0] 26451 v_1 := v.Args[1] 26452 if v_1.Op != Op386SETAE { 26453 break 26454 } 26455 if cmp != v_1.Args[0] { 26456 break 26457 } 26458 b.Kind = Block386UGE 26459 b.SetControl(cmp) 26460 b.Aux = nil 26461 return true 26462 } 26463 // match: (NE (TESTB (SETAE cmp) (SETAE cmp)) yes no) 26464 // cond: 26465 // result: (UGE cmp yes no) 26466 for { 26467 v := b.Control 26468 if v.Op != Op386TESTB { 26469 break 26470 } 26471 _ = v.Args[1] 26472 v_0 := v.Args[0] 26473 if v_0.Op != Op386SETAE { 26474 break 26475 } 26476 cmp := v_0.Args[0] 26477 v_1 := v.Args[1] 26478 if v_1.Op != Op386SETAE { 26479 break 26480 } 26481 if cmp != v_1.Args[0] { 26482 break 26483 } 26484 b.Kind = Block386UGE 26485 b.SetControl(cmp) 26486 b.Aux = nil 26487 return true 26488 } 26489 // match: (NE (TESTB (SETO cmp) (SETO cmp)) yes no) 26490 // cond: 26491 // result: (OS cmp yes no) 26492 for { 26493 v := b.Control 26494 if v.Op != Op386TESTB { 26495 break 26496 } 26497 _ = v.Args[1] 26498 v_0 := v.Args[0] 26499 if v_0.Op != Op386SETO { 26500 break 26501 } 26502 cmp := v_0.Args[0] 26503 v_1 := v.Args[1] 26504 if v_1.Op != Op386SETO { 26505 break 26506 } 26507 if cmp != v_1.Args[0] { 26508 break 26509 } 26510 b.Kind = Block386OS 26511 b.SetControl(cmp) 26512 b.Aux = nil 26513 return true 26514 } 26515 // match: (NE (TESTB (SETO cmp) (SETO cmp)) yes no) 26516 // cond: 26517 // result: (OS cmp yes no) 26518 for { 26519 v := b.Control 26520 if v.Op != Op386TESTB { 26521 break 26522 } 26523 _ = v.Args[1] 26524 v_0 := v.Args[0] 26525 if v_0.Op != Op386SETO { 26526 break 26527 } 26528 cmp := v_0.Args[0] 26529 v_1 := v.Args[1] 26530 if v_1.Op != Op386SETO { 26531 break 26532 } 26533 if cmp != v_1.Args[0] { 26534 break 26535 } 26536 b.Kind = Block386OS 26537 b.SetControl(cmp) 26538 b.Aux = nil 26539 return true 26540 } 26541 // match: (NE (TESTB (SETGF cmp) (SETGF cmp)) yes no) 26542 // cond: 26543 // result: (UGT cmp yes no) 26544 for { 26545 v := b.Control 26546 if v.Op != Op386TESTB { 26547 break 26548 } 26549 _ = v.Args[1] 26550 v_0 := v.Args[0] 26551 if v_0.Op != Op386SETGF { 26552 break 26553 } 26554 cmp := v_0.Args[0] 26555 v_1 := v.Args[1] 26556 if v_1.Op != Op386SETGF { 26557 break 26558 } 26559 if cmp != v_1.Args[0] { 26560 break 26561 } 26562 b.Kind = Block386UGT 26563 b.SetControl(cmp) 26564 b.Aux = nil 26565 return true 26566 } 26567 // match: (NE (TESTB (SETGF cmp) (SETGF cmp)) yes no) 26568 // cond: 26569 // result: (UGT cmp yes no) 26570 for { 26571 v := b.Control 26572 if v.Op != Op386TESTB { 26573 break 26574 } 26575 _ = v.Args[1] 26576 v_0 := v.Args[0] 26577 if v_0.Op != Op386SETGF { 26578 break 26579 } 26580 cmp := v_0.Args[0] 26581 v_1 := v.Args[1] 26582 if v_1.Op != Op386SETGF { 26583 break 26584 } 26585 if cmp != v_1.Args[0] { 26586 break 26587 } 26588 b.Kind = Block386UGT 26589 b.SetControl(cmp) 26590 b.Aux = nil 26591 return true 26592 } 26593 // match: (NE (TESTB (SETGEF cmp) (SETGEF cmp)) yes no) 26594 // cond: 26595 // result: (UGE cmp yes no) 26596 for { 26597 v := b.Control 26598 if v.Op != Op386TESTB { 26599 break 26600 } 26601 _ = v.Args[1] 26602 v_0 := v.Args[0] 26603 if v_0.Op != Op386SETGEF { 26604 break 26605 } 26606 cmp := v_0.Args[0] 26607 v_1 := v.Args[1] 26608 if v_1.Op != Op386SETGEF { 26609 break 26610 } 26611 if cmp != v_1.Args[0] { 26612 break 26613 } 26614 b.Kind = Block386UGE 26615 b.SetControl(cmp) 26616 b.Aux = nil 26617 return true 26618 } 26619 // match: (NE (TESTB (SETGEF cmp) (SETGEF cmp)) yes no) 26620 // cond: 26621 // result: (UGE cmp yes no) 26622 for { 26623 v := b.Control 26624 if v.Op != Op386TESTB { 26625 break 26626 } 26627 _ = v.Args[1] 26628 v_0 := v.Args[0] 26629 if v_0.Op != Op386SETGEF { 26630 break 26631 } 26632 cmp := v_0.Args[0] 26633 v_1 := v.Args[1] 26634 if v_1.Op != Op386SETGEF { 26635 break 26636 } 26637 if cmp != v_1.Args[0] { 26638 break 26639 } 26640 b.Kind = Block386UGE 26641 b.SetControl(cmp) 26642 b.Aux = nil 26643 return true 26644 } 26645 // match: (NE (TESTB (SETEQF cmp) (SETEQF cmp)) yes no) 26646 // cond: 26647 // result: (EQF cmp yes no) 26648 for { 26649 v := b.Control 26650 if v.Op != Op386TESTB { 26651 break 26652 } 26653 _ = v.Args[1] 26654 v_0 := v.Args[0] 26655 if v_0.Op != Op386SETEQF { 26656 break 26657 } 26658 cmp := v_0.Args[0] 26659 v_1 := v.Args[1] 26660 if v_1.Op != Op386SETEQF { 26661 break 26662 } 26663 if cmp != v_1.Args[0] { 26664 break 26665 } 26666 b.Kind = Block386EQF 26667 b.SetControl(cmp) 26668 b.Aux = nil 26669 return true 26670 } 26671 // match: (NE (TESTB (SETEQF cmp) (SETEQF cmp)) yes no) 26672 // cond: 26673 // result: (EQF cmp yes no) 26674 for { 26675 v := b.Control 26676 if v.Op != Op386TESTB { 26677 break 26678 } 26679 _ = v.Args[1] 26680 v_0 := v.Args[0] 26681 if v_0.Op != Op386SETEQF { 26682 break 26683 } 26684 cmp := v_0.Args[0] 26685 v_1 := v.Args[1] 26686 if v_1.Op != Op386SETEQF { 26687 break 26688 } 26689 if cmp != v_1.Args[0] { 26690 break 26691 } 26692 b.Kind = Block386EQF 26693 b.SetControl(cmp) 26694 b.Aux = nil 26695 return true 26696 } 26697 // match: (NE (TESTB (SETNEF cmp) (SETNEF cmp)) yes no) 26698 // cond: 26699 // result: (NEF cmp yes no) 26700 for { 26701 v := b.Control 26702 if v.Op != Op386TESTB { 26703 break 26704 } 26705 _ = v.Args[1] 26706 v_0 := v.Args[0] 26707 if v_0.Op != Op386SETNEF { 26708 break 26709 } 26710 cmp := v_0.Args[0] 26711 v_1 := v.Args[1] 26712 if v_1.Op != Op386SETNEF { 26713 break 26714 } 26715 if cmp != v_1.Args[0] { 26716 break 26717 } 26718 b.Kind = Block386NEF 26719 b.SetControl(cmp) 26720 b.Aux = nil 26721 return true 26722 } 26723 // match: (NE (TESTB (SETNEF cmp) (SETNEF cmp)) yes no) 26724 // cond: 26725 // result: (NEF cmp yes no) 26726 for { 26727 v := b.Control 26728 if v.Op != Op386TESTB { 26729 break 26730 } 26731 _ = v.Args[1] 26732 v_0 := v.Args[0] 26733 if v_0.Op != Op386SETNEF { 26734 break 26735 } 26736 cmp := v_0.Args[0] 26737 v_1 := v.Args[1] 26738 if v_1.Op != Op386SETNEF { 26739 break 26740 } 26741 if cmp != v_1.Args[0] { 26742 break 26743 } 26744 b.Kind = Block386NEF 26745 b.SetControl(cmp) 26746 b.Aux = nil 26747 return true 26748 } 26749 // match: (NE (InvertFlags cmp) yes no) 26750 // cond: 26751 // result: (NE cmp yes no) 26752 for { 26753 v := b.Control 26754 if v.Op != Op386InvertFlags { 26755 break 26756 } 26757 cmp := v.Args[0] 26758 b.Kind = Block386NE 26759 b.SetControl(cmp) 26760 b.Aux = nil 26761 return true 26762 } 26763 // match: (NE (FlagEQ) yes no) 26764 // cond: 26765 // result: (First nil no yes) 26766 for { 26767 v := b.Control 26768 if v.Op != Op386FlagEQ { 26769 break 26770 } 26771 b.Kind = BlockFirst 26772 b.SetControl(nil) 26773 b.Aux = nil 26774 b.swapSuccessors() 26775 return true 26776 } 26777 // match: (NE (FlagLT_ULT) yes no) 26778 // cond: 26779 // result: (First nil yes no) 26780 for { 26781 v := b.Control 26782 if v.Op != Op386FlagLT_ULT { 26783 break 26784 } 26785 b.Kind = BlockFirst 26786 b.SetControl(nil) 26787 b.Aux = nil 26788 return true 26789 } 26790 // match: (NE (FlagLT_UGT) yes no) 26791 // cond: 26792 // result: (First nil yes no) 26793 for { 26794 v := b.Control 26795 if v.Op != Op386FlagLT_UGT { 26796 break 26797 } 26798 b.Kind = BlockFirst 26799 b.SetControl(nil) 26800 b.Aux = nil 26801 return true 26802 } 26803 // match: (NE (FlagGT_ULT) yes no) 26804 // cond: 26805 // result: (First nil yes no) 26806 for { 26807 v := b.Control 26808 if v.Op != Op386FlagGT_ULT { 26809 break 26810 } 26811 b.Kind = BlockFirst 26812 b.SetControl(nil) 26813 b.Aux = nil 26814 return true 26815 } 26816 // match: (NE (FlagGT_UGT) yes no) 26817 // cond: 26818 // result: (First nil yes no) 26819 for { 26820 v := b.Control 26821 if v.Op != Op386FlagGT_UGT { 26822 break 26823 } 26824 b.Kind = BlockFirst 26825 b.SetControl(nil) 26826 b.Aux = nil 26827 return true 26828 } 26829 case Block386UGE: 26830 // match: (UGE (InvertFlags cmp) yes no) 26831 // cond: 26832 // result: (ULE cmp yes no) 26833 for { 26834 v := b.Control 26835 if v.Op != Op386InvertFlags { 26836 break 26837 } 26838 cmp := v.Args[0] 26839 b.Kind = Block386ULE 26840 b.SetControl(cmp) 26841 b.Aux = nil 26842 return true 26843 } 26844 // match: (UGE (FlagEQ) yes no) 26845 // cond: 26846 // result: (First nil yes no) 26847 for { 26848 v := b.Control 26849 if v.Op != Op386FlagEQ { 26850 break 26851 } 26852 b.Kind = BlockFirst 26853 b.SetControl(nil) 26854 b.Aux = nil 26855 return true 26856 } 26857 // match: (UGE (FlagLT_ULT) yes no) 26858 // cond: 26859 // result: (First nil no yes) 26860 for { 26861 v := b.Control 26862 if v.Op != Op386FlagLT_ULT { 26863 break 26864 } 26865 b.Kind = BlockFirst 26866 b.SetControl(nil) 26867 b.Aux = nil 26868 b.swapSuccessors() 26869 return true 26870 } 26871 // match: (UGE (FlagLT_UGT) yes no) 26872 // cond: 26873 // result: (First nil yes no) 26874 for { 26875 v := b.Control 26876 if v.Op != Op386FlagLT_UGT { 26877 break 26878 } 26879 b.Kind = BlockFirst 26880 b.SetControl(nil) 26881 b.Aux = nil 26882 return true 26883 } 26884 // match: (UGE (FlagGT_ULT) yes no) 26885 // cond: 26886 // result: (First nil no yes) 26887 for { 26888 v := b.Control 26889 if v.Op != Op386FlagGT_ULT { 26890 break 26891 } 26892 b.Kind = BlockFirst 26893 b.SetControl(nil) 26894 b.Aux = nil 26895 b.swapSuccessors() 26896 return true 26897 } 26898 // match: (UGE (FlagGT_UGT) yes no) 26899 // cond: 26900 // result: (First nil yes no) 26901 for { 26902 v := b.Control 26903 if v.Op != Op386FlagGT_UGT { 26904 break 26905 } 26906 b.Kind = BlockFirst 26907 b.SetControl(nil) 26908 b.Aux = nil 26909 return true 26910 } 26911 case Block386UGT: 26912 // match: (UGT (InvertFlags cmp) yes no) 26913 // cond: 26914 // result: (ULT cmp yes no) 26915 for { 26916 v := b.Control 26917 if v.Op != Op386InvertFlags { 26918 break 26919 } 26920 cmp := v.Args[0] 26921 b.Kind = Block386ULT 26922 b.SetControl(cmp) 26923 b.Aux = nil 26924 return true 26925 } 26926 // match: (UGT (FlagEQ) yes no) 26927 // cond: 26928 // result: (First nil no yes) 26929 for { 26930 v := b.Control 26931 if v.Op != Op386FlagEQ { 26932 break 26933 } 26934 b.Kind = BlockFirst 26935 b.SetControl(nil) 26936 b.Aux = nil 26937 b.swapSuccessors() 26938 return true 26939 } 26940 // match: (UGT (FlagLT_ULT) yes no) 26941 // cond: 26942 // result: (First nil no yes) 26943 for { 26944 v := b.Control 26945 if v.Op != Op386FlagLT_ULT { 26946 break 26947 } 26948 b.Kind = BlockFirst 26949 b.SetControl(nil) 26950 b.Aux = nil 26951 b.swapSuccessors() 26952 return true 26953 } 26954 // match: (UGT (FlagLT_UGT) yes no) 26955 // cond: 26956 // result: (First nil yes no) 26957 for { 26958 v := b.Control 26959 if v.Op != Op386FlagLT_UGT { 26960 break 26961 } 26962 b.Kind = BlockFirst 26963 b.SetControl(nil) 26964 b.Aux = nil 26965 return true 26966 } 26967 // match: (UGT (FlagGT_ULT) yes no) 26968 // cond: 26969 // result: (First nil no yes) 26970 for { 26971 v := b.Control 26972 if v.Op != Op386FlagGT_ULT { 26973 break 26974 } 26975 b.Kind = BlockFirst 26976 b.SetControl(nil) 26977 b.Aux = nil 26978 b.swapSuccessors() 26979 return true 26980 } 26981 // match: (UGT (FlagGT_UGT) yes no) 26982 // cond: 26983 // result: (First nil yes no) 26984 for { 26985 v := b.Control 26986 if v.Op != Op386FlagGT_UGT { 26987 break 26988 } 26989 b.Kind = BlockFirst 26990 b.SetControl(nil) 26991 b.Aux = nil 26992 return true 26993 } 26994 case Block386ULE: 26995 // match: (ULE (InvertFlags cmp) yes no) 26996 // cond: 26997 // result: (UGE cmp yes no) 26998 for { 26999 v := b.Control 27000 if v.Op != Op386InvertFlags { 27001 break 27002 } 27003 cmp := v.Args[0] 27004 b.Kind = Block386UGE 27005 b.SetControl(cmp) 27006 b.Aux = nil 27007 return true 27008 } 27009 // match: (ULE (FlagEQ) yes no) 27010 // cond: 27011 // result: (First nil yes no) 27012 for { 27013 v := b.Control 27014 if v.Op != Op386FlagEQ { 27015 break 27016 } 27017 b.Kind = BlockFirst 27018 b.SetControl(nil) 27019 b.Aux = nil 27020 return true 27021 } 27022 // match: (ULE (FlagLT_ULT) yes no) 27023 // cond: 27024 // result: (First nil yes no) 27025 for { 27026 v := b.Control 27027 if v.Op != Op386FlagLT_ULT { 27028 break 27029 } 27030 b.Kind = BlockFirst 27031 b.SetControl(nil) 27032 b.Aux = nil 27033 return true 27034 } 27035 // match: (ULE (FlagLT_UGT) yes no) 27036 // cond: 27037 // result: (First nil no yes) 27038 for { 27039 v := b.Control 27040 if v.Op != Op386FlagLT_UGT { 27041 break 27042 } 27043 b.Kind = BlockFirst 27044 b.SetControl(nil) 27045 b.Aux = nil 27046 b.swapSuccessors() 27047 return true 27048 } 27049 // match: (ULE (FlagGT_ULT) yes no) 27050 // cond: 27051 // result: (First nil yes no) 27052 for { 27053 v := b.Control 27054 if v.Op != Op386FlagGT_ULT { 27055 break 27056 } 27057 b.Kind = BlockFirst 27058 b.SetControl(nil) 27059 b.Aux = nil 27060 return true 27061 } 27062 // match: (ULE (FlagGT_UGT) yes no) 27063 // cond: 27064 // result: (First nil no yes) 27065 for { 27066 v := b.Control 27067 if v.Op != Op386FlagGT_UGT { 27068 break 27069 } 27070 b.Kind = BlockFirst 27071 b.SetControl(nil) 27072 b.Aux = nil 27073 b.swapSuccessors() 27074 return true 27075 } 27076 case Block386ULT: 27077 // match: (ULT (InvertFlags cmp) yes no) 27078 // cond: 27079 // result: (UGT cmp yes no) 27080 for { 27081 v := b.Control 27082 if v.Op != Op386InvertFlags { 27083 break 27084 } 27085 cmp := v.Args[0] 27086 b.Kind = Block386UGT 27087 b.SetControl(cmp) 27088 b.Aux = nil 27089 return true 27090 } 27091 // match: (ULT (FlagEQ) yes no) 27092 // cond: 27093 // result: (First nil no yes) 27094 for { 27095 v := b.Control 27096 if v.Op != Op386FlagEQ { 27097 break 27098 } 27099 b.Kind = BlockFirst 27100 b.SetControl(nil) 27101 b.Aux = nil 27102 b.swapSuccessors() 27103 return true 27104 } 27105 // match: (ULT (FlagLT_ULT) yes no) 27106 // cond: 27107 // result: (First nil yes no) 27108 for { 27109 v := b.Control 27110 if v.Op != Op386FlagLT_ULT { 27111 break 27112 } 27113 b.Kind = BlockFirst 27114 b.SetControl(nil) 27115 b.Aux = nil 27116 return true 27117 } 27118 // match: (ULT (FlagLT_UGT) yes no) 27119 // cond: 27120 // result: (First nil no yes) 27121 for { 27122 v := b.Control 27123 if v.Op != Op386FlagLT_UGT { 27124 break 27125 } 27126 b.Kind = BlockFirst 27127 b.SetControl(nil) 27128 b.Aux = nil 27129 b.swapSuccessors() 27130 return true 27131 } 27132 // match: (ULT (FlagGT_ULT) yes no) 27133 // cond: 27134 // result: (First nil yes no) 27135 for { 27136 v := b.Control 27137 if v.Op != Op386FlagGT_ULT { 27138 break 27139 } 27140 b.Kind = BlockFirst 27141 b.SetControl(nil) 27142 b.Aux = nil 27143 return true 27144 } 27145 // match: (ULT (FlagGT_UGT) yes no) 27146 // cond: 27147 // result: (First nil no yes) 27148 for { 27149 v := b.Control 27150 if v.Op != Op386FlagGT_UGT { 27151 break 27152 } 27153 b.Kind = BlockFirst 27154 b.SetControl(nil) 27155 b.Aux = nil 27156 b.swapSuccessors() 27157 return true 27158 } 27159 } 27160 return false 27161 }