github.com/euank/go@v0.0.0-20160829210321-495514729181/src/cmd/compile/internal/ssa/rewriteARM.go (about) 1 // autogenerated from gen/ARM.rules: do not edit! 2 // generated with: cd gen; go run *.go 3 4 package ssa 5 6 import "math" 7 8 var _ = math.MinInt8 // in case not otherwise used 9 func rewriteValueARM(v *Value, config *Config) bool { 10 switch v.Op { 11 case OpARMADC: 12 return rewriteValueARM_OpARMADC(v, config) 13 case OpARMADCconst: 14 return rewriteValueARM_OpARMADCconst(v, config) 15 case OpARMADCshiftLL: 16 return rewriteValueARM_OpARMADCshiftLL(v, config) 17 case OpARMADCshiftLLreg: 18 return rewriteValueARM_OpARMADCshiftLLreg(v, config) 19 case OpARMADCshiftRA: 20 return rewriteValueARM_OpARMADCshiftRA(v, config) 21 case OpARMADCshiftRAreg: 22 return rewriteValueARM_OpARMADCshiftRAreg(v, config) 23 case OpARMADCshiftRL: 24 return rewriteValueARM_OpARMADCshiftRL(v, config) 25 case OpARMADCshiftRLreg: 26 return rewriteValueARM_OpARMADCshiftRLreg(v, config) 27 case OpARMADD: 28 return rewriteValueARM_OpARMADD(v, config) 29 case OpARMADDS: 30 return rewriteValueARM_OpARMADDS(v, config) 31 case OpARMADDSshiftLL: 32 return rewriteValueARM_OpARMADDSshiftLL(v, config) 33 case OpARMADDSshiftLLreg: 34 return rewriteValueARM_OpARMADDSshiftLLreg(v, config) 35 case OpARMADDSshiftRA: 36 return rewriteValueARM_OpARMADDSshiftRA(v, config) 37 case OpARMADDSshiftRAreg: 38 return rewriteValueARM_OpARMADDSshiftRAreg(v, config) 39 case OpARMADDSshiftRL: 40 return rewriteValueARM_OpARMADDSshiftRL(v, config) 41 case OpARMADDSshiftRLreg: 42 return rewriteValueARM_OpARMADDSshiftRLreg(v, config) 43 case OpARMADDconst: 44 return rewriteValueARM_OpARMADDconst(v, config) 45 case OpARMADDshiftLL: 46 return rewriteValueARM_OpARMADDshiftLL(v, config) 47 case OpARMADDshiftLLreg: 48 return rewriteValueARM_OpARMADDshiftLLreg(v, config) 49 case OpARMADDshiftRA: 50 return rewriteValueARM_OpARMADDshiftRA(v, config) 51 case OpARMADDshiftRAreg: 52 return rewriteValueARM_OpARMADDshiftRAreg(v, config) 53 case OpARMADDshiftRL: 54 return rewriteValueARM_OpARMADDshiftRL(v, config) 55 case OpARMADDshiftRLreg: 56 return rewriteValueARM_OpARMADDshiftRLreg(v, config) 57 case OpARMAND: 58 return rewriteValueARM_OpARMAND(v, config) 59 case OpARMANDconst: 60 return rewriteValueARM_OpARMANDconst(v, config) 61 case OpARMANDshiftLL: 62 return rewriteValueARM_OpARMANDshiftLL(v, config) 63 case OpARMANDshiftLLreg: 64 return rewriteValueARM_OpARMANDshiftLLreg(v, config) 65 case OpARMANDshiftRA: 66 return rewriteValueARM_OpARMANDshiftRA(v, config) 67 case OpARMANDshiftRAreg: 68 return rewriteValueARM_OpARMANDshiftRAreg(v, config) 69 case OpARMANDshiftRL: 70 return rewriteValueARM_OpARMANDshiftRL(v, config) 71 case OpARMANDshiftRLreg: 72 return rewriteValueARM_OpARMANDshiftRLreg(v, config) 73 case OpARMBIC: 74 return rewriteValueARM_OpARMBIC(v, config) 75 case OpARMBICconst: 76 return rewriteValueARM_OpARMBICconst(v, config) 77 case OpARMBICshiftLL: 78 return rewriteValueARM_OpARMBICshiftLL(v, config) 79 case OpARMBICshiftLLreg: 80 return rewriteValueARM_OpARMBICshiftLLreg(v, config) 81 case OpARMBICshiftRA: 82 return rewriteValueARM_OpARMBICshiftRA(v, config) 83 case OpARMBICshiftRAreg: 84 return rewriteValueARM_OpARMBICshiftRAreg(v, config) 85 case OpARMBICshiftRL: 86 return rewriteValueARM_OpARMBICshiftRL(v, config) 87 case OpARMBICshiftRLreg: 88 return rewriteValueARM_OpARMBICshiftRLreg(v, config) 89 case OpARMCMOVWHSconst: 90 return rewriteValueARM_OpARMCMOVWHSconst(v, config) 91 case OpARMCMOVWLSconst: 92 return rewriteValueARM_OpARMCMOVWLSconst(v, config) 93 case OpARMCMP: 94 return rewriteValueARM_OpARMCMP(v, config) 95 case OpARMCMPD: 96 return rewriteValueARM_OpARMCMPD(v, config) 97 case OpARMCMPF: 98 return rewriteValueARM_OpARMCMPF(v, config) 99 case OpARMCMPconst: 100 return rewriteValueARM_OpARMCMPconst(v, config) 101 case OpARMCMPshiftLL: 102 return rewriteValueARM_OpARMCMPshiftLL(v, config) 103 case OpARMCMPshiftLLreg: 104 return rewriteValueARM_OpARMCMPshiftLLreg(v, config) 105 case OpARMCMPshiftRA: 106 return rewriteValueARM_OpARMCMPshiftRA(v, config) 107 case OpARMCMPshiftRAreg: 108 return rewriteValueARM_OpARMCMPshiftRAreg(v, config) 109 case OpARMCMPshiftRL: 110 return rewriteValueARM_OpARMCMPshiftRL(v, config) 111 case OpARMCMPshiftRLreg: 112 return rewriteValueARM_OpARMCMPshiftRLreg(v, config) 113 case OpARMDIV: 114 return rewriteValueARM_OpARMDIV(v, config) 115 case OpARMDIVU: 116 return rewriteValueARM_OpARMDIVU(v, config) 117 case OpARMEqual: 118 return rewriteValueARM_OpARMEqual(v, config) 119 case OpARMGreaterEqual: 120 return rewriteValueARM_OpARMGreaterEqual(v, config) 121 case OpARMGreaterEqualU: 122 return rewriteValueARM_OpARMGreaterEqualU(v, config) 123 case OpARMGreaterThan: 124 return rewriteValueARM_OpARMGreaterThan(v, config) 125 case OpARMGreaterThanU: 126 return rewriteValueARM_OpARMGreaterThanU(v, config) 127 case OpARMLessEqual: 128 return rewriteValueARM_OpARMLessEqual(v, config) 129 case OpARMLessEqualU: 130 return rewriteValueARM_OpARMLessEqualU(v, config) 131 case OpARMLessThan: 132 return rewriteValueARM_OpARMLessThan(v, config) 133 case OpARMLessThanU: 134 return rewriteValueARM_OpARMLessThanU(v, config) 135 case OpARMMOVBUload: 136 return rewriteValueARM_OpARMMOVBUload(v, config) 137 case OpARMMOVBUreg: 138 return rewriteValueARM_OpARMMOVBUreg(v, config) 139 case OpARMMOVBload: 140 return rewriteValueARM_OpARMMOVBload(v, config) 141 case OpARMMOVBreg: 142 return rewriteValueARM_OpARMMOVBreg(v, config) 143 case OpARMMOVBstore: 144 return rewriteValueARM_OpARMMOVBstore(v, config) 145 case OpARMMOVDload: 146 return rewriteValueARM_OpARMMOVDload(v, config) 147 case OpARMMOVDstore: 148 return rewriteValueARM_OpARMMOVDstore(v, config) 149 case OpARMMOVFload: 150 return rewriteValueARM_OpARMMOVFload(v, config) 151 case OpARMMOVFstore: 152 return rewriteValueARM_OpARMMOVFstore(v, config) 153 case OpARMMOVHUload: 154 return rewriteValueARM_OpARMMOVHUload(v, config) 155 case OpARMMOVHUreg: 156 return rewriteValueARM_OpARMMOVHUreg(v, config) 157 case OpARMMOVHload: 158 return rewriteValueARM_OpARMMOVHload(v, config) 159 case OpARMMOVHreg: 160 return rewriteValueARM_OpARMMOVHreg(v, config) 161 case OpARMMOVHstore: 162 return rewriteValueARM_OpARMMOVHstore(v, config) 163 case OpARMMOVWload: 164 return rewriteValueARM_OpARMMOVWload(v, config) 165 case OpARMMOVWloadidx: 166 return rewriteValueARM_OpARMMOVWloadidx(v, config) 167 case OpARMMOVWloadshiftLL: 168 return rewriteValueARM_OpARMMOVWloadshiftLL(v, config) 169 case OpARMMOVWloadshiftRA: 170 return rewriteValueARM_OpARMMOVWloadshiftRA(v, config) 171 case OpARMMOVWloadshiftRL: 172 return rewriteValueARM_OpARMMOVWloadshiftRL(v, config) 173 case OpARMMOVWreg: 174 return rewriteValueARM_OpARMMOVWreg(v, config) 175 case OpARMMOVWstore: 176 return rewriteValueARM_OpARMMOVWstore(v, config) 177 case OpARMMOVWstoreidx: 178 return rewriteValueARM_OpARMMOVWstoreidx(v, config) 179 case OpARMMOVWstoreshiftLL: 180 return rewriteValueARM_OpARMMOVWstoreshiftLL(v, config) 181 case OpARMMOVWstoreshiftRA: 182 return rewriteValueARM_OpARMMOVWstoreshiftRA(v, config) 183 case OpARMMOVWstoreshiftRL: 184 return rewriteValueARM_OpARMMOVWstoreshiftRL(v, config) 185 case OpARMMUL: 186 return rewriteValueARM_OpARMMUL(v, config) 187 case OpARMMULA: 188 return rewriteValueARM_OpARMMULA(v, config) 189 case OpARMMVN: 190 return rewriteValueARM_OpARMMVN(v, config) 191 case OpARMMVNshiftLL: 192 return rewriteValueARM_OpARMMVNshiftLL(v, config) 193 case OpARMMVNshiftLLreg: 194 return rewriteValueARM_OpARMMVNshiftLLreg(v, config) 195 case OpARMMVNshiftRA: 196 return rewriteValueARM_OpARMMVNshiftRA(v, config) 197 case OpARMMVNshiftRAreg: 198 return rewriteValueARM_OpARMMVNshiftRAreg(v, config) 199 case OpARMMVNshiftRL: 200 return rewriteValueARM_OpARMMVNshiftRL(v, config) 201 case OpARMMVNshiftRLreg: 202 return rewriteValueARM_OpARMMVNshiftRLreg(v, config) 203 case OpARMNotEqual: 204 return rewriteValueARM_OpARMNotEqual(v, config) 205 case OpARMOR: 206 return rewriteValueARM_OpARMOR(v, config) 207 case OpARMORconst: 208 return rewriteValueARM_OpARMORconst(v, config) 209 case OpARMORshiftLL: 210 return rewriteValueARM_OpARMORshiftLL(v, config) 211 case OpARMORshiftLLreg: 212 return rewriteValueARM_OpARMORshiftLLreg(v, config) 213 case OpARMORshiftRA: 214 return rewriteValueARM_OpARMORshiftRA(v, config) 215 case OpARMORshiftRAreg: 216 return rewriteValueARM_OpARMORshiftRAreg(v, config) 217 case OpARMORshiftRL: 218 return rewriteValueARM_OpARMORshiftRL(v, config) 219 case OpARMORshiftRLreg: 220 return rewriteValueARM_OpARMORshiftRLreg(v, config) 221 case OpARMRSB: 222 return rewriteValueARM_OpARMRSB(v, config) 223 case OpARMRSBSshiftLL: 224 return rewriteValueARM_OpARMRSBSshiftLL(v, config) 225 case OpARMRSBSshiftLLreg: 226 return rewriteValueARM_OpARMRSBSshiftLLreg(v, config) 227 case OpARMRSBSshiftRA: 228 return rewriteValueARM_OpARMRSBSshiftRA(v, config) 229 case OpARMRSBSshiftRAreg: 230 return rewriteValueARM_OpARMRSBSshiftRAreg(v, config) 231 case OpARMRSBSshiftRL: 232 return rewriteValueARM_OpARMRSBSshiftRL(v, config) 233 case OpARMRSBSshiftRLreg: 234 return rewriteValueARM_OpARMRSBSshiftRLreg(v, config) 235 case OpARMRSBconst: 236 return rewriteValueARM_OpARMRSBconst(v, config) 237 case OpARMRSBshiftLL: 238 return rewriteValueARM_OpARMRSBshiftLL(v, config) 239 case OpARMRSBshiftLLreg: 240 return rewriteValueARM_OpARMRSBshiftLLreg(v, config) 241 case OpARMRSBshiftRA: 242 return rewriteValueARM_OpARMRSBshiftRA(v, config) 243 case OpARMRSBshiftRAreg: 244 return rewriteValueARM_OpARMRSBshiftRAreg(v, config) 245 case OpARMRSBshiftRL: 246 return rewriteValueARM_OpARMRSBshiftRL(v, config) 247 case OpARMRSBshiftRLreg: 248 return rewriteValueARM_OpARMRSBshiftRLreg(v, config) 249 case OpARMRSCconst: 250 return rewriteValueARM_OpARMRSCconst(v, config) 251 case OpARMRSCshiftLL: 252 return rewriteValueARM_OpARMRSCshiftLL(v, config) 253 case OpARMRSCshiftLLreg: 254 return rewriteValueARM_OpARMRSCshiftLLreg(v, config) 255 case OpARMRSCshiftRA: 256 return rewriteValueARM_OpARMRSCshiftRA(v, config) 257 case OpARMRSCshiftRAreg: 258 return rewriteValueARM_OpARMRSCshiftRAreg(v, config) 259 case OpARMRSCshiftRL: 260 return rewriteValueARM_OpARMRSCshiftRL(v, config) 261 case OpARMRSCshiftRLreg: 262 return rewriteValueARM_OpARMRSCshiftRLreg(v, config) 263 case OpARMSBC: 264 return rewriteValueARM_OpARMSBC(v, config) 265 case OpARMSBCconst: 266 return rewriteValueARM_OpARMSBCconst(v, config) 267 case OpARMSBCshiftLL: 268 return rewriteValueARM_OpARMSBCshiftLL(v, config) 269 case OpARMSBCshiftLLreg: 270 return rewriteValueARM_OpARMSBCshiftLLreg(v, config) 271 case OpARMSBCshiftRA: 272 return rewriteValueARM_OpARMSBCshiftRA(v, config) 273 case OpARMSBCshiftRAreg: 274 return rewriteValueARM_OpARMSBCshiftRAreg(v, config) 275 case OpARMSBCshiftRL: 276 return rewriteValueARM_OpARMSBCshiftRL(v, config) 277 case OpARMSBCshiftRLreg: 278 return rewriteValueARM_OpARMSBCshiftRLreg(v, config) 279 case OpARMSLL: 280 return rewriteValueARM_OpARMSLL(v, config) 281 case OpARMSLLconst: 282 return rewriteValueARM_OpARMSLLconst(v, config) 283 case OpARMSRA: 284 return rewriteValueARM_OpARMSRA(v, config) 285 case OpARMSRAcond: 286 return rewriteValueARM_OpARMSRAcond(v, config) 287 case OpARMSRAconst: 288 return rewriteValueARM_OpARMSRAconst(v, config) 289 case OpARMSRL: 290 return rewriteValueARM_OpARMSRL(v, config) 291 case OpARMSRLconst: 292 return rewriteValueARM_OpARMSRLconst(v, config) 293 case OpARMSUB: 294 return rewriteValueARM_OpARMSUB(v, config) 295 case OpARMSUBS: 296 return rewriteValueARM_OpARMSUBS(v, config) 297 case OpARMSUBSshiftLL: 298 return rewriteValueARM_OpARMSUBSshiftLL(v, config) 299 case OpARMSUBSshiftLLreg: 300 return rewriteValueARM_OpARMSUBSshiftLLreg(v, config) 301 case OpARMSUBSshiftRA: 302 return rewriteValueARM_OpARMSUBSshiftRA(v, config) 303 case OpARMSUBSshiftRAreg: 304 return rewriteValueARM_OpARMSUBSshiftRAreg(v, config) 305 case OpARMSUBSshiftRL: 306 return rewriteValueARM_OpARMSUBSshiftRL(v, config) 307 case OpARMSUBSshiftRLreg: 308 return rewriteValueARM_OpARMSUBSshiftRLreg(v, config) 309 case OpARMSUBconst: 310 return rewriteValueARM_OpARMSUBconst(v, config) 311 case OpARMSUBshiftLL: 312 return rewriteValueARM_OpARMSUBshiftLL(v, config) 313 case OpARMSUBshiftLLreg: 314 return rewriteValueARM_OpARMSUBshiftLLreg(v, config) 315 case OpARMSUBshiftRA: 316 return rewriteValueARM_OpARMSUBshiftRA(v, config) 317 case OpARMSUBshiftRAreg: 318 return rewriteValueARM_OpARMSUBshiftRAreg(v, config) 319 case OpARMSUBshiftRL: 320 return rewriteValueARM_OpARMSUBshiftRL(v, config) 321 case OpARMSUBshiftRLreg: 322 return rewriteValueARM_OpARMSUBshiftRLreg(v, config) 323 case OpARMXOR: 324 return rewriteValueARM_OpARMXOR(v, config) 325 case OpARMXORconst: 326 return rewriteValueARM_OpARMXORconst(v, config) 327 case OpARMXORshiftLL: 328 return rewriteValueARM_OpARMXORshiftLL(v, config) 329 case OpARMXORshiftLLreg: 330 return rewriteValueARM_OpARMXORshiftLLreg(v, config) 331 case OpARMXORshiftRA: 332 return rewriteValueARM_OpARMXORshiftRA(v, config) 333 case OpARMXORshiftRAreg: 334 return rewriteValueARM_OpARMXORshiftRAreg(v, config) 335 case OpARMXORshiftRL: 336 return rewriteValueARM_OpARMXORshiftRL(v, config) 337 case OpARMXORshiftRLreg: 338 return rewriteValueARM_OpARMXORshiftRLreg(v, config) 339 case OpAdd16: 340 return rewriteValueARM_OpAdd16(v, config) 341 case OpAdd32: 342 return rewriteValueARM_OpAdd32(v, config) 343 case OpAdd32F: 344 return rewriteValueARM_OpAdd32F(v, config) 345 case OpAdd32carry: 346 return rewriteValueARM_OpAdd32carry(v, config) 347 case OpAdd32withcarry: 348 return rewriteValueARM_OpAdd32withcarry(v, config) 349 case OpAdd64F: 350 return rewriteValueARM_OpAdd64F(v, config) 351 case OpAdd8: 352 return rewriteValueARM_OpAdd8(v, config) 353 case OpAddPtr: 354 return rewriteValueARM_OpAddPtr(v, config) 355 case OpAddr: 356 return rewriteValueARM_OpAddr(v, config) 357 case OpAnd16: 358 return rewriteValueARM_OpAnd16(v, config) 359 case OpAnd32: 360 return rewriteValueARM_OpAnd32(v, config) 361 case OpAnd8: 362 return rewriteValueARM_OpAnd8(v, config) 363 case OpAndB: 364 return rewriteValueARM_OpAndB(v, config) 365 case OpClosureCall: 366 return rewriteValueARM_OpClosureCall(v, config) 367 case OpCom16: 368 return rewriteValueARM_OpCom16(v, config) 369 case OpCom32: 370 return rewriteValueARM_OpCom32(v, config) 371 case OpCom8: 372 return rewriteValueARM_OpCom8(v, config) 373 case OpConst16: 374 return rewriteValueARM_OpConst16(v, config) 375 case OpConst32: 376 return rewriteValueARM_OpConst32(v, config) 377 case OpConst32F: 378 return rewriteValueARM_OpConst32F(v, config) 379 case OpConst64F: 380 return rewriteValueARM_OpConst64F(v, config) 381 case OpConst8: 382 return rewriteValueARM_OpConst8(v, config) 383 case OpConstBool: 384 return rewriteValueARM_OpConstBool(v, config) 385 case OpConstNil: 386 return rewriteValueARM_OpConstNil(v, config) 387 case OpConvert: 388 return rewriteValueARM_OpConvert(v, config) 389 case OpCvt32Fto32: 390 return rewriteValueARM_OpCvt32Fto32(v, config) 391 case OpCvt32Fto32U: 392 return rewriteValueARM_OpCvt32Fto32U(v, config) 393 case OpCvt32Fto64F: 394 return rewriteValueARM_OpCvt32Fto64F(v, config) 395 case OpCvt32Uto32F: 396 return rewriteValueARM_OpCvt32Uto32F(v, config) 397 case OpCvt32Uto64F: 398 return rewriteValueARM_OpCvt32Uto64F(v, config) 399 case OpCvt32to32F: 400 return rewriteValueARM_OpCvt32to32F(v, config) 401 case OpCvt32to64F: 402 return rewriteValueARM_OpCvt32to64F(v, config) 403 case OpCvt64Fto32: 404 return rewriteValueARM_OpCvt64Fto32(v, config) 405 case OpCvt64Fto32F: 406 return rewriteValueARM_OpCvt64Fto32F(v, config) 407 case OpCvt64Fto32U: 408 return rewriteValueARM_OpCvt64Fto32U(v, config) 409 case OpDeferCall: 410 return rewriteValueARM_OpDeferCall(v, config) 411 case OpDiv16: 412 return rewriteValueARM_OpDiv16(v, config) 413 case OpDiv16u: 414 return rewriteValueARM_OpDiv16u(v, config) 415 case OpDiv32: 416 return rewriteValueARM_OpDiv32(v, config) 417 case OpDiv32F: 418 return rewriteValueARM_OpDiv32F(v, config) 419 case OpDiv32u: 420 return rewriteValueARM_OpDiv32u(v, config) 421 case OpDiv64F: 422 return rewriteValueARM_OpDiv64F(v, config) 423 case OpDiv8: 424 return rewriteValueARM_OpDiv8(v, config) 425 case OpDiv8u: 426 return rewriteValueARM_OpDiv8u(v, config) 427 case OpEq16: 428 return rewriteValueARM_OpEq16(v, config) 429 case OpEq32: 430 return rewriteValueARM_OpEq32(v, config) 431 case OpEq32F: 432 return rewriteValueARM_OpEq32F(v, config) 433 case OpEq64F: 434 return rewriteValueARM_OpEq64F(v, config) 435 case OpEq8: 436 return rewriteValueARM_OpEq8(v, config) 437 case OpEqB: 438 return rewriteValueARM_OpEqB(v, config) 439 case OpEqPtr: 440 return rewriteValueARM_OpEqPtr(v, config) 441 case OpGeq16: 442 return rewriteValueARM_OpGeq16(v, config) 443 case OpGeq16U: 444 return rewriteValueARM_OpGeq16U(v, config) 445 case OpGeq32: 446 return rewriteValueARM_OpGeq32(v, config) 447 case OpGeq32F: 448 return rewriteValueARM_OpGeq32F(v, config) 449 case OpGeq32U: 450 return rewriteValueARM_OpGeq32U(v, config) 451 case OpGeq64F: 452 return rewriteValueARM_OpGeq64F(v, config) 453 case OpGeq8: 454 return rewriteValueARM_OpGeq8(v, config) 455 case OpGeq8U: 456 return rewriteValueARM_OpGeq8U(v, config) 457 case OpGetClosurePtr: 458 return rewriteValueARM_OpGetClosurePtr(v, config) 459 case OpGoCall: 460 return rewriteValueARM_OpGoCall(v, config) 461 case OpGreater16: 462 return rewriteValueARM_OpGreater16(v, config) 463 case OpGreater16U: 464 return rewriteValueARM_OpGreater16U(v, config) 465 case OpGreater32: 466 return rewriteValueARM_OpGreater32(v, config) 467 case OpGreater32F: 468 return rewriteValueARM_OpGreater32F(v, config) 469 case OpGreater32U: 470 return rewriteValueARM_OpGreater32U(v, config) 471 case OpGreater64F: 472 return rewriteValueARM_OpGreater64F(v, config) 473 case OpGreater8: 474 return rewriteValueARM_OpGreater8(v, config) 475 case OpGreater8U: 476 return rewriteValueARM_OpGreater8U(v, config) 477 case OpHmul16: 478 return rewriteValueARM_OpHmul16(v, config) 479 case OpHmul16u: 480 return rewriteValueARM_OpHmul16u(v, config) 481 case OpHmul32: 482 return rewriteValueARM_OpHmul32(v, config) 483 case OpHmul32u: 484 return rewriteValueARM_OpHmul32u(v, config) 485 case OpHmul8: 486 return rewriteValueARM_OpHmul8(v, config) 487 case OpHmul8u: 488 return rewriteValueARM_OpHmul8u(v, config) 489 case OpInterCall: 490 return rewriteValueARM_OpInterCall(v, config) 491 case OpIsInBounds: 492 return rewriteValueARM_OpIsInBounds(v, config) 493 case OpIsNonNil: 494 return rewriteValueARM_OpIsNonNil(v, config) 495 case OpIsSliceInBounds: 496 return rewriteValueARM_OpIsSliceInBounds(v, config) 497 case OpLeq16: 498 return rewriteValueARM_OpLeq16(v, config) 499 case OpLeq16U: 500 return rewriteValueARM_OpLeq16U(v, config) 501 case OpLeq32: 502 return rewriteValueARM_OpLeq32(v, config) 503 case OpLeq32F: 504 return rewriteValueARM_OpLeq32F(v, config) 505 case OpLeq32U: 506 return rewriteValueARM_OpLeq32U(v, config) 507 case OpLeq64F: 508 return rewriteValueARM_OpLeq64F(v, config) 509 case OpLeq8: 510 return rewriteValueARM_OpLeq8(v, config) 511 case OpLeq8U: 512 return rewriteValueARM_OpLeq8U(v, config) 513 case OpLess16: 514 return rewriteValueARM_OpLess16(v, config) 515 case OpLess16U: 516 return rewriteValueARM_OpLess16U(v, config) 517 case OpLess32: 518 return rewriteValueARM_OpLess32(v, config) 519 case OpLess32F: 520 return rewriteValueARM_OpLess32F(v, config) 521 case OpLess32U: 522 return rewriteValueARM_OpLess32U(v, config) 523 case OpLess64F: 524 return rewriteValueARM_OpLess64F(v, config) 525 case OpLess8: 526 return rewriteValueARM_OpLess8(v, config) 527 case OpLess8U: 528 return rewriteValueARM_OpLess8U(v, config) 529 case OpLoad: 530 return rewriteValueARM_OpLoad(v, config) 531 case OpLrot16: 532 return rewriteValueARM_OpLrot16(v, config) 533 case OpLrot32: 534 return rewriteValueARM_OpLrot32(v, config) 535 case OpLrot8: 536 return rewriteValueARM_OpLrot8(v, config) 537 case OpLsh16x16: 538 return rewriteValueARM_OpLsh16x16(v, config) 539 case OpLsh16x32: 540 return rewriteValueARM_OpLsh16x32(v, config) 541 case OpLsh16x64: 542 return rewriteValueARM_OpLsh16x64(v, config) 543 case OpLsh16x8: 544 return rewriteValueARM_OpLsh16x8(v, config) 545 case OpLsh32x16: 546 return rewriteValueARM_OpLsh32x16(v, config) 547 case OpLsh32x32: 548 return rewriteValueARM_OpLsh32x32(v, config) 549 case OpLsh32x64: 550 return rewriteValueARM_OpLsh32x64(v, config) 551 case OpLsh32x8: 552 return rewriteValueARM_OpLsh32x8(v, config) 553 case OpLsh8x16: 554 return rewriteValueARM_OpLsh8x16(v, config) 555 case OpLsh8x32: 556 return rewriteValueARM_OpLsh8x32(v, config) 557 case OpLsh8x64: 558 return rewriteValueARM_OpLsh8x64(v, config) 559 case OpLsh8x8: 560 return rewriteValueARM_OpLsh8x8(v, config) 561 case OpMod16: 562 return rewriteValueARM_OpMod16(v, config) 563 case OpMod16u: 564 return rewriteValueARM_OpMod16u(v, config) 565 case OpMod32: 566 return rewriteValueARM_OpMod32(v, config) 567 case OpMod32u: 568 return rewriteValueARM_OpMod32u(v, config) 569 case OpMod8: 570 return rewriteValueARM_OpMod8(v, config) 571 case OpMod8u: 572 return rewriteValueARM_OpMod8u(v, config) 573 case OpMove: 574 return rewriteValueARM_OpMove(v, config) 575 case OpMul16: 576 return rewriteValueARM_OpMul16(v, config) 577 case OpMul32: 578 return rewriteValueARM_OpMul32(v, config) 579 case OpMul32F: 580 return rewriteValueARM_OpMul32F(v, config) 581 case OpMul32uhilo: 582 return rewriteValueARM_OpMul32uhilo(v, config) 583 case OpMul64F: 584 return rewriteValueARM_OpMul64F(v, config) 585 case OpMul8: 586 return rewriteValueARM_OpMul8(v, config) 587 case OpNeg16: 588 return rewriteValueARM_OpNeg16(v, config) 589 case OpNeg32: 590 return rewriteValueARM_OpNeg32(v, config) 591 case OpNeg32F: 592 return rewriteValueARM_OpNeg32F(v, config) 593 case OpNeg64F: 594 return rewriteValueARM_OpNeg64F(v, config) 595 case OpNeg8: 596 return rewriteValueARM_OpNeg8(v, config) 597 case OpNeq16: 598 return rewriteValueARM_OpNeq16(v, config) 599 case OpNeq32: 600 return rewriteValueARM_OpNeq32(v, config) 601 case OpNeq32F: 602 return rewriteValueARM_OpNeq32F(v, config) 603 case OpNeq64F: 604 return rewriteValueARM_OpNeq64F(v, config) 605 case OpNeq8: 606 return rewriteValueARM_OpNeq8(v, config) 607 case OpNeqB: 608 return rewriteValueARM_OpNeqB(v, config) 609 case OpNeqPtr: 610 return rewriteValueARM_OpNeqPtr(v, config) 611 case OpNilCheck: 612 return rewriteValueARM_OpNilCheck(v, config) 613 case OpNot: 614 return rewriteValueARM_OpNot(v, config) 615 case OpOffPtr: 616 return rewriteValueARM_OpOffPtr(v, config) 617 case OpOr16: 618 return rewriteValueARM_OpOr16(v, config) 619 case OpOr32: 620 return rewriteValueARM_OpOr32(v, config) 621 case OpOr8: 622 return rewriteValueARM_OpOr8(v, config) 623 case OpOrB: 624 return rewriteValueARM_OpOrB(v, config) 625 case OpRsh16Ux16: 626 return rewriteValueARM_OpRsh16Ux16(v, config) 627 case OpRsh16Ux32: 628 return rewriteValueARM_OpRsh16Ux32(v, config) 629 case OpRsh16Ux64: 630 return rewriteValueARM_OpRsh16Ux64(v, config) 631 case OpRsh16Ux8: 632 return rewriteValueARM_OpRsh16Ux8(v, config) 633 case OpRsh16x16: 634 return rewriteValueARM_OpRsh16x16(v, config) 635 case OpRsh16x32: 636 return rewriteValueARM_OpRsh16x32(v, config) 637 case OpRsh16x64: 638 return rewriteValueARM_OpRsh16x64(v, config) 639 case OpRsh16x8: 640 return rewriteValueARM_OpRsh16x8(v, config) 641 case OpRsh32Ux16: 642 return rewriteValueARM_OpRsh32Ux16(v, config) 643 case OpRsh32Ux32: 644 return rewriteValueARM_OpRsh32Ux32(v, config) 645 case OpRsh32Ux64: 646 return rewriteValueARM_OpRsh32Ux64(v, config) 647 case OpRsh32Ux8: 648 return rewriteValueARM_OpRsh32Ux8(v, config) 649 case OpRsh32x16: 650 return rewriteValueARM_OpRsh32x16(v, config) 651 case OpRsh32x32: 652 return rewriteValueARM_OpRsh32x32(v, config) 653 case OpRsh32x64: 654 return rewriteValueARM_OpRsh32x64(v, config) 655 case OpRsh32x8: 656 return rewriteValueARM_OpRsh32x8(v, config) 657 case OpRsh8Ux16: 658 return rewriteValueARM_OpRsh8Ux16(v, config) 659 case OpRsh8Ux32: 660 return rewriteValueARM_OpRsh8Ux32(v, config) 661 case OpRsh8Ux64: 662 return rewriteValueARM_OpRsh8Ux64(v, config) 663 case OpRsh8Ux8: 664 return rewriteValueARM_OpRsh8Ux8(v, config) 665 case OpRsh8x16: 666 return rewriteValueARM_OpRsh8x16(v, config) 667 case OpRsh8x32: 668 return rewriteValueARM_OpRsh8x32(v, config) 669 case OpRsh8x64: 670 return rewriteValueARM_OpRsh8x64(v, config) 671 case OpRsh8x8: 672 return rewriteValueARM_OpRsh8x8(v, config) 673 case OpSignExt16to32: 674 return rewriteValueARM_OpSignExt16to32(v, config) 675 case OpSignExt8to16: 676 return rewriteValueARM_OpSignExt8to16(v, config) 677 case OpSignExt8to32: 678 return rewriteValueARM_OpSignExt8to32(v, config) 679 case OpSignmask: 680 return rewriteValueARM_OpSignmask(v, config) 681 case OpSqrt: 682 return rewriteValueARM_OpSqrt(v, config) 683 case OpStaticCall: 684 return rewriteValueARM_OpStaticCall(v, config) 685 case OpStore: 686 return rewriteValueARM_OpStore(v, config) 687 case OpSub16: 688 return rewriteValueARM_OpSub16(v, config) 689 case OpSub32: 690 return rewriteValueARM_OpSub32(v, config) 691 case OpSub32F: 692 return rewriteValueARM_OpSub32F(v, config) 693 case OpSub32carry: 694 return rewriteValueARM_OpSub32carry(v, config) 695 case OpSub32withcarry: 696 return rewriteValueARM_OpSub32withcarry(v, config) 697 case OpSub64F: 698 return rewriteValueARM_OpSub64F(v, config) 699 case OpSub8: 700 return rewriteValueARM_OpSub8(v, config) 701 case OpSubPtr: 702 return rewriteValueARM_OpSubPtr(v, config) 703 case OpTrunc16to8: 704 return rewriteValueARM_OpTrunc16to8(v, config) 705 case OpTrunc32to16: 706 return rewriteValueARM_OpTrunc32to16(v, config) 707 case OpTrunc32to8: 708 return rewriteValueARM_OpTrunc32to8(v, config) 709 case OpXor16: 710 return rewriteValueARM_OpXor16(v, config) 711 case OpXor32: 712 return rewriteValueARM_OpXor32(v, config) 713 case OpXor8: 714 return rewriteValueARM_OpXor8(v, config) 715 case OpZero: 716 return rewriteValueARM_OpZero(v, config) 717 case OpZeroExt16to32: 718 return rewriteValueARM_OpZeroExt16to32(v, config) 719 case OpZeroExt8to16: 720 return rewriteValueARM_OpZeroExt8to16(v, config) 721 case OpZeroExt8to32: 722 return rewriteValueARM_OpZeroExt8to32(v, config) 723 case OpZeromask: 724 return rewriteValueARM_OpZeromask(v, config) 725 } 726 return false 727 } 728 func rewriteValueARM_OpARMADC(v *Value, config *Config) bool { 729 b := v.Block 730 _ = b 731 // match: (ADC (MOVWconst [c]) x flags) 732 // cond: 733 // result: (ADCconst [c] x flags) 734 for { 735 v_0 := v.Args[0] 736 if v_0.Op != OpARMMOVWconst { 737 break 738 } 739 c := v_0.AuxInt 740 x := v.Args[1] 741 flags := v.Args[2] 742 v.reset(OpARMADCconst) 743 v.AuxInt = c 744 v.AddArg(x) 745 v.AddArg(flags) 746 return true 747 } 748 // match: (ADC x (MOVWconst [c]) flags) 749 // cond: 750 // result: (ADCconst [c] x flags) 751 for { 752 x := v.Args[0] 753 v_1 := v.Args[1] 754 if v_1.Op != OpARMMOVWconst { 755 break 756 } 757 c := v_1.AuxInt 758 flags := v.Args[2] 759 v.reset(OpARMADCconst) 760 v.AuxInt = c 761 v.AddArg(x) 762 v.AddArg(flags) 763 return true 764 } 765 // match: (ADC x (SLLconst [c] y) flags) 766 // cond: 767 // result: (ADCshiftLL x y [c] flags) 768 for { 769 x := v.Args[0] 770 v_1 := v.Args[1] 771 if v_1.Op != OpARMSLLconst { 772 break 773 } 774 c := v_1.AuxInt 775 y := v_1.Args[0] 776 flags := v.Args[2] 777 v.reset(OpARMADCshiftLL) 778 v.AuxInt = c 779 v.AddArg(x) 780 v.AddArg(y) 781 v.AddArg(flags) 782 return true 783 } 784 // match: (ADC (SLLconst [c] y) x flags) 785 // cond: 786 // result: (ADCshiftLL x y [c] flags) 787 for { 788 v_0 := v.Args[0] 789 if v_0.Op != OpARMSLLconst { 790 break 791 } 792 c := v_0.AuxInt 793 y := v_0.Args[0] 794 x := v.Args[1] 795 flags := v.Args[2] 796 v.reset(OpARMADCshiftLL) 797 v.AuxInt = c 798 v.AddArg(x) 799 v.AddArg(y) 800 v.AddArg(flags) 801 return true 802 } 803 // match: (ADC x (SRLconst [c] y) flags) 804 // cond: 805 // result: (ADCshiftRL x y [c] flags) 806 for { 807 x := v.Args[0] 808 v_1 := v.Args[1] 809 if v_1.Op != OpARMSRLconst { 810 break 811 } 812 c := v_1.AuxInt 813 y := v_1.Args[0] 814 flags := v.Args[2] 815 v.reset(OpARMADCshiftRL) 816 v.AuxInt = c 817 v.AddArg(x) 818 v.AddArg(y) 819 v.AddArg(flags) 820 return true 821 } 822 // match: (ADC (SRLconst [c] y) x flags) 823 // cond: 824 // result: (ADCshiftRL x y [c] flags) 825 for { 826 v_0 := v.Args[0] 827 if v_0.Op != OpARMSRLconst { 828 break 829 } 830 c := v_0.AuxInt 831 y := v_0.Args[0] 832 x := v.Args[1] 833 flags := v.Args[2] 834 v.reset(OpARMADCshiftRL) 835 v.AuxInt = c 836 v.AddArg(x) 837 v.AddArg(y) 838 v.AddArg(flags) 839 return true 840 } 841 // match: (ADC x (SRAconst [c] y) flags) 842 // cond: 843 // result: (ADCshiftRA x y [c] flags) 844 for { 845 x := v.Args[0] 846 v_1 := v.Args[1] 847 if v_1.Op != OpARMSRAconst { 848 break 849 } 850 c := v_1.AuxInt 851 y := v_1.Args[0] 852 flags := v.Args[2] 853 v.reset(OpARMADCshiftRA) 854 v.AuxInt = c 855 v.AddArg(x) 856 v.AddArg(y) 857 v.AddArg(flags) 858 return true 859 } 860 // match: (ADC (SRAconst [c] y) x flags) 861 // cond: 862 // result: (ADCshiftRA x y [c] flags) 863 for { 864 v_0 := v.Args[0] 865 if v_0.Op != OpARMSRAconst { 866 break 867 } 868 c := v_0.AuxInt 869 y := v_0.Args[0] 870 x := v.Args[1] 871 flags := v.Args[2] 872 v.reset(OpARMADCshiftRA) 873 v.AuxInt = c 874 v.AddArg(x) 875 v.AddArg(y) 876 v.AddArg(flags) 877 return true 878 } 879 // match: (ADC x (SLL y z) flags) 880 // cond: 881 // result: (ADCshiftLLreg x y z flags) 882 for { 883 x := v.Args[0] 884 v_1 := v.Args[1] 885 if v_1.Op != OpARMSLL { 886 break 887 } 888 y := v_1.Args[0] 889 z := v_1.Args[1] 890 flags := v.Args[2] 891 v.reset(OpARMADCshiftLLreg) 892 v.AddArg(x) 893 v.AddArg(y) 894 v.AddArg(z) 895 v.AddArg(flags) 896 return true 897 } 898 // match: (ADC (SLL y z) x flags) 899 // cond: 900 // result: (ADCshiftLLreg x y z flags) 901 for { 902 v_0 := v.Args[0] 903 if v_0.Op != OpARMSLL { 904 break 905 } 906 y := v_0.Args[0] 907 z := v_0.Args[1] 908 x := v.Args[1] 909 flags := v.Args[2] 910 v.reset(OpARMADCshiftLLreg) 911 v.AddArg(x) 912 v.AddArg(y) 913 v.AddArg(z) 914 v.AddArg(flags) 915 return true 916 } 917 // match: (ADC x (SRL y z) flags) 918 // cond: 919 // result: (ADCshiftRLreg x y z flags) 920 for { 921 x := v.Args[0] 922 v_1 := v.Args[1] 923 if v_1.Op != OpARMSRL { 924 break 925 } 926 y := v_1.Args[0] 927 z := v_1.Args[1] 928 flags := v.Args[2] 929 v.reset(OpARMADCshiftRLreg) 930 v.AddArg(x) 931 v.AddArg(y) 932 v.AddArg(z) 933 v.AddArg(flags) 934 return true 935 } 936 // match: (ADC (SRL y z) x flags) 937 // cond: 938 // result: (ADCshiftRLreg x y z flags) 939 for { 940 v_0 := v.Args[0] 941 if v_0.Op != OpARMSRL { 942 break 943 } 944 y := v_0.Args[0] 945 z := v_0.Args[1] 946 x := v.Args[1] 947 flags := v.Args[2] 948 v.reset(OpARMADCshiftRLreg) 949 v.AddArg(x) 950 v.AddArg(y) 951 v.AddArg(z) 952 v.AddArg(flags) 953 return true 954 } 955 // match: (ADC x (SRA y z) flags) 956 // cond: 957 // result: (ADCshiftRAreg x y z flags) 958 for { 959 x := v.Args[0] 960 v_1 := v.Args[1] 961 if v_1.Op != OpARMSRA { 962 break 963 } 964 y := v_1.Args[0] 965 z := v_1.Args[1] 966 flags := v.Args[2] 967 v.reset(OpARMADCshiftRAreg) 968 v.AddArg(x) 969 v.AddArg(y) 970 v.AddArg(z) 971 v.AddArg(flags) 972 return true 973 } 974 // match: (ADC (SRA y z) x flags) 975 // cond: 976 // result: (ADCshiftRAreg x y z flags) 977 for { 978 v_0 := v.Args[0] 979 if v_0.Op != OpARMSRA { 980 break 981 } 982 y := v_0.Args[0] 983 z := v_0.Args[1] 984 x := v.Args[1] 985 flags := v.Args[2] 986 v.reset(OpARMADCshiftRAreg) 987 v.AddArg(x) 988 v.AddArg(y) 989 v.AddArg(z) 990 v.AddArg(flags) 991 return true 992 } 993 return false 994 } 995 func rewriteValueARM_OpARMADCconst(v *Value, config *Config) bool { 996 b := v.Block 997 _ = b 998 // match: (ADCconst [c] (ADDconst [d] x) flags) 999 // cond: 1000 // result: (ADCconst [int64(int32(c+d))] x flags) 1001 for { 1002 c := v.AuxInt 1003 v_0 := v.Args[0] 1004 if v_0.Op != OpARMADDconst { 1005 break 1006 } 1007 d := v_0.AuxInt 1008 x := v_0.Args[0] 1009 flags := v.Args[1] 1010 v.reset(OpARMADCconst) 1011 v.AuxInt = int64(int32(c + d)) 1012 v.AddArg(x) 1013 v.AddArg(flags) 1014 return true 1015 } 1016 // match: (ADCconst [c] (SUBconst [d] x) flags) 1017 // cond: 1018 // result: (ADCconst [int64(int32(c-d))] x flags) 1019 for { 1020 c := v.AuxInt 1021 v_0 := v.Args[0] 1022 if v_0.Op != OpARMSUBconst { 1023 break 1024 } 1025 d := v_0.AuxInt 1026 x := v_0.Args[0] 1027 flags := v.Args[1] 1028 v.reset(OpARMADCconst) 1029 v.AuxInt = int64(int32(c - d)) 1030 v.AddArg(x) 1031 v.AddArg(flags) 1032 return true 1033 } 1034 return false 1035 } 1036 func rewriteValueARM_OpARMADCshiftLL(v *Value, config *Config) bool { 1037 b := v.Block 1038 _ = b 1039 // match: (ADCshiftLL (MOVWconst [c]) x [d] flags) 1040 // cond: 1041 // result: (ADCconst [c] (SLLconst <x.Type> x [d]) flags) 1042 for { 1043 d := v.AuxInt 1044 v_0 := v.Args[0] 1045 if v_0.Op != OpARMMOVWconst { 1046 break 1047 } 1048 c := v_0.AuxInt 1049 x := v.Args[1] 1050 flags := v.Args[2] 1051 v.reset(OpARMADCconst) 1052 v.AuxInt = c 1053 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 1054 v0.AuxInt = d 1055 v0.AddArg(x) 1056 v.AddArg(v0) 1057 v.AddArg(flags) 1058 return true 1059 } 1060 // match: (ADCshiftLL x (MOVWconst [c]) [d] flags) 1061 // cond: 1062 // result: (ADCconst x [int64(uint32(c)<<uint64(d))] flags) 1063 for { 1064 d := v.AuxInt 1065 x := v.Args[0] 1066 v_1 := v.Args[1] 1067 if v_1.Op != OpARMMOVWconst { 1068 break 1069 } 1070 c := v_1.AuxInt 1071 flags := v.Args[2] 1072 v.reset(OpARMADCconst) 1073 v.AuxInt = int64(uint32(c) << uint64(d)) 1074 v.AddArg(x) 1075 v.AddArg(flags) 1076 return true 1077 } 1078 return false 1079 } 1080 func rewriteValueARM_OpARMADCshiftLLreg(v *Value, config *Config) bool { 1081 b := v.Block 1082 _ = b 1083 // match: (ADCshiftLLreg (MOVWconst [c]) x y flags) 1084 // cond: 1085 // result: (ADCconst [c] (SLL <x.Type> x y) flags) 1086 for { 1087 v_0 := v.Args[0] 1088 if v_0.Op != OpARMMOVWconst { 1089 break 1090 } 1091 c := v_0.AuxInt 1092 x := v.Args[1] 1093 y := v.Args[2] 1094 flags := v.Args[3] 1095 v.reset(OpARMADCconst) 1096 v.AuxInt = c 1097 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 1098 v0.AddArg(x) 1099 v0.AddArg(y) 1100 v.AddArg(v0) 1101 v.AddArg(flags) 1102 return true 1103 } 1104 // match: (ADCshiftLLreg x y (MOVWconst [c]) flags) 1105 // cond: 1106 // result: (ADCshiftLL x y [c] flags) 1107 for { 1108 x := v.Args[0] 1109 y := v.Args[1] 1110 v_2 := v.Args[2] 1111 if v_2.Op != OpARMMOVWconst { 1112 break 1113 } 1114 c := v_2.AuxInt 1115 flags := v.Args[3] 1116 v.reset(OpARMADCshiftLL) 1117 v.AuxInt = c 1118 v.AddArg(x) 1119 v.AddArg(y) 1120 v.AddArg(flags) 1121 return true 1122 } 1123 return false 1124 } 1125 func rewriteValueARM_OpARMADCshiftRA(v *Value, config *Config) bool { 1126 b := v.Block 1127 _ = b 1128 // match: (ADCshiftRA (MOVWconst [c]) x [d] flags) 1129 // cond: 1130 // result: (ADCconst [c] (SRAconst <x.Type> x [d]) flags) 1131 for { 1132 d := v.AuxInt 1133 v_0 := v.Args[0] 1134 if v_0.Op != OpARMMOVWconst { 1135 break 1136 } 1137 c := v_0.AuxInt 1138 x := v.Args[1] 1139 flags := v.Args[2] 1140 v.reset(OpARMADCconst) 1141 v.AuxInt = c 1142 v0 := b.NewValue0(v.Line, OpARMSRAconst, x.Type) 1143 v0.AuxInt = d 1144 v0.AddArg(x) 1145 v.AddArg(v0) 1146 v.AddArg(flags) 1147 return true 1148 } 1149 // match: (ADCshiftRA x (MOVWconst [c]) [d] flags) 1150 // cond: 1151 // result: (ADCconst x [int64(int32(c)>>uint64(d))] flags) 1152 for { 1153 d := v.AuxInt 1154 x := v.Args[0] 1155 v_1 := v.Args[1] 1156 if v_1.Op != OpARMMOVWconst { 1157 break 1158 } 1159 c := v_1.AuxInt 1160 flags := v.Args[2] 1161 v.reset(OpARMADCconst) 1162 v.AuxInt = int64(int32(c) >> uint64(d)) 1163 v.AddArg(x) 1164 v.AddArg(flags) 1165 return true 1166 } 1167 return false 1168 } 1169 func rewriteValueARM_OpARMADCshiftRAreg(v *Value, config *Config) bool { 1170 b := v.Block 1171 _ = b 1172 // match: (ADCshiftRAreg (MOVWconst [c]) x y flags) 1173 // cond: 1174 // result: (ADCconst [c] (SRA <x.Type> x y) flags) 1175 for { 1176 v_0 := v.Args[0] 1177 if v_0.Op != OpARMMOVWconst { 1178 break 1179 } 1180 c := v_0.AuxInt 1181 x := v.Args[1] 1182 y := v.Args[2] 1183 flags := v.Args[3] 1184 v.reset(OpARMADCconst) 1185 v.AuxInt = c 1186 v0 := b.NewValue0(v.Line, OpARMSRA, x.Type) 1187 v0.AddArg(x) 1188 v0.AddArg(y) 1189 v.AddArg(v0) 1190 v.AddArg(flags) 1191 return true 1192 } 1193 // match: (ADCshiftRAreg x y (MOVWconst [c]) flags) 1194 // cond: 1195 // result: (ADCshiftRA x y [c] flags) 1196 for { 1197 x := v.Args[0] 1198 y := v.Args[1] 1199 v_2 := v.Args[2] 1200 if v_2.Op != OpARMMOVWconst { 1201 break 1202 } 1203 c := v_2.AuxInt 1204 flags := v.Args[3] 1205 v.reset(OpARMADCshiftRA) 1206 v.AuxInt = c 1207 v.AddArg(x) 1208 v.AddArg(y) 1209 v.AddArg(flags) 1210 return true 1211 } 1212 return false 1213 } 1214 func rewriteValueARM_OpARMADCshiftRL(v *Value, config *Config) bool { 1215 b := v.Block 1216 _ = b 1217 // match: (ADCshiftRL (MOVWconst [c]) x [d] flags) 1218 // cond: 1219 // result: (ADCconst [c] (SRLconst <x.Type> x [d]) flags) 1220 for { 1221 d := v.AuxInt 1222 v_0 := v.Args[0] 1223 if v_0.Op != OpARMMOVWconst { 1224 break 1225 } 1226 c := v_0.AuxInt 1227 x := v.Args[1] 1228 flags := v.Args[2] 1229 v.reset(OpARMADCconst) 1230 v.AuxInt = c 1231 v0 := b.NewValue0(v.Line, OpARMSRLconst, x.Type) 1232 v0.AuxInt = d 1233 v0.AddArg(x) 1234 v.AddArg(v0) 1235 v.AddArg(flags) 1236 return true 1237 } 1238 // match: (ADCshiftRL x (MOVWconst [c]) [d] flags) 1239 // cond: 1240 // result: (ADCconst x [int64(uint32(c)>>uint64(d))] flags) 1241 for { 1242 d := v.AuxInt 1243 x := v.Args[0] 1244 v_1 := v.Args[1] 1245 if v_1.Op != OpARMMOVWconst { 1246 break 1247 } 1248 c := v_1.AuxInt 1249 flags := v.Args[2] 1250 v.reset(OpARMADCconst) 1251 v.AuxInt = int64(uint32(c) >> uint64(d)) 1252 v.AddArg(x) 1253 v.AddArg(flags) 1254 return true 1255 } 1256 return false 1257 } 1258 func rewriteValueARM_OpARMADCshiftRLreg(v *Value, config *Config) bool { 1259 b := v.Block 1260 _ = b 1261 // match: (ADCshiftRLreg (MOVWconst [c]) x y flags) 1262 // cond: 1263 // result: (ADCconst [c] (SRL <x.Type> x y) flags) 1264 for { 1265 v_0 := v.Args[0] 1266 if v_0.Op != OpARMMOVWconst { 1267 break 1268 } 1269 c := v_0.AuxInt 1270 x := v.Args[1] 1271 y := v.Args[2] 1272 flags := v.Args[3] 1273 v.reset(OpARMADCconst) 1274 v.AuxInt = c 1275 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 1276 v0.AddArg(x) 1277 v0.AddArg(y) 1278 v.AddArg(v0) 1279 v.AddArg(flags) 1280 return true 1281 } 1282 // match: (ADCshiftRLreg x y (MOVWconst [c]) flags) 1283 // cond: 1284 // result: (ADCshiftRL x y [c] flags) 1285 for { 1286 x := v.Args[0] 1287 y := v.Args[1] 1288 v_2 := v.Args[2] 1289 if v_2.Op != OpARMMOVWconst { 1290 break 1291 } 1292 c := v_2.AuxInt 1293 flags := v.Args[3] 1294 v.reset(OpARMADCshiftRL) 1295 v.AuxInt = c 1296 v.AddArg(x) 1297 v.AddArg(y) 1298 v.AddArg(flags) 1299 return true 1300 } 1301 return false 1302 } 1303 func rewriteValueARM_OpARMADD(v *Value, config *Config) bool { 1304 b := v.Block 1305 _ = b 1306 // match: (ADD (MOVWconst [c]) x) 1307 // cond: 1308 // result: (ADDconst [c] x) 1309 for { 1310 v_0 := v.Args[0] 1311 if v_0.Op != OpARMMOVWconst { 1312 break 1313 } 1314 c := v_0.AuxInt 1315 x := v.Args[1] 1316 v.reset(OpARMADDconst) 1317 v.AuxInt = c 1318 v.AddArg(x) 1319 return true 1320 } 1321 // match: (ADD x (MOVWconst [c])) 1322 // cond: 1323 // result: (ADDconst [c] x) 1324 for { 1325 x := v.Args[0] 1326 v_1 := v.Args[1] 1327 if v_1.Op != OpARMMOVWconst { 1328 break 1329 } 1330 c := v_1.AuxInt 1331 v.reset(OpARMADDconst) 1332 v.AuxInt = c 1333 v.AddArg(x) 1334 return true 1335 } 1336 // match: (ADD x (SLLconst [c] y)) 1337 // cond: 1338 // result: (ADDshiftLL x y [c]) 1339 for { 1340 x := v.Args[0] 1341 v_1 := v.Args[1] 1342 if v_1.Op != OpARMSLLconst { 1343 break 1344 } 1345 c := v_1.AuxInt 1346 y := v_1.Args[0] 1347 v.reset(OpARMADDshiftLL) 1348 v.AuxInt = c 1349 v.AddArg(x) 1350 v.AddArg(y) 1351 return true 1352 } 1353 // match: (ADD (SLLconst [c] y) x) 1354 // cond: 1355 // result: (ADDshiftLL x y [c]) 1356 for { 1357 v_0 := v.Args[0] 1358 if v_0.Op != OpARMSLLconst { 1359 break 1360 } 1361 c := v_0.AuxInt 1362 y := v_0.Args[0] 1363 x := v.Args[1] 1364 v.reset(OpARMADDshiftLL) 1365 v.AuxInt = c 1366 v.AddArg(x) 1367 v.AddArg(y) 1368 return true 1369 } 1370 // match: (ADD x (SRLconst [c] y)) 1371 // cond: 1372 // result: (ADDshiftRL x y [c]) 1373 for { 1374 x := v.Args[0] 1375 v_1 := v.Args[1] 1376 if v_1.Op != OpARMSRLconst { 1377 break 1378 } 1379 c := v_1.AuxInt 1380 y := v_1.Args[0] 1381 v.reset(OpARMADDshiftRL) 1382 v.AuxInt = c 1383 v.AddArg(x) 1384 v.AddArg(y) 1385 return true 1386 } 1387 // match: (ADD (SRLconst [c] y) x) 1388 // cond: 1389 // result: (ADDshiftRL x y [c]) 1390 for { 1391 v_0 := v.Args[0] 1392 if v_0.Op != OpARMSRLconst { 1393 break 1394 } 1395 c := v_0.AuxInt 1396 y := v_0.Args[0] 1397 x := v.Args[1] 1398 v.reset(OpARMADDshiftRL) 1399 v.AuxInt = c 1400 v.AddArg(x) 1401 v.AddArg(y) 1402 return true 1403 } 1404 // match: (ADD x (SRAconst [c] y)) 1405 // cond: 1406 // result: (ADDshiftRA x y [c]) 1407 for { 1408 x := v.Args[0] 1409 v_1 := v.Args[1] 1410 if v_1.Op != OpARMSRAconst { 1411 break 1412 } 1413 c := v_1.AuxInt 1414 y := v_1.Args[0] 1415 v.reset(OpARMADDshiftRA) 1416 v.AuxInt = c 1417 v.AddArg(x) 1418 v.AddArg(y) 1419 return true 1420 } 1421 // match: (ADD (SRAconst [c] y) x) 1422 // cond: 1423 // result: (ADDshiftRA x y [c]) 1424 for { 1425 v_0 := v.Args[0] 1426 if v_0.Op != OpARMSRAconst { 1427 break 1428 } 1429 c := v_0.AuxInt 1430 y := v_0.Args[0] 1431 x := v.Args[1] 1432 v.reset(OpARMADDshiftRA) 1433 v.AuxInt = c 1434 v.AddArg(x) 1435 v.AddArg(y) 1436 return true 1437 } 1438 // match: (ADD x (SLL y z)) 1439 // cond: 1440 // result: (ADDshiftLLreg x y z) 1441 for { 1442 x := v.Args[0] 1443 v_1 := v.Args[1] 1444 if v_1.Op != OpARMSLL { 1445 break 1446 } 1447 y := v_1.Args[0] 1448 z := v_1.Args[1] 1449 v.reset(OpARMADDshiftLLreg) 1450 v.AddArg(x) 1451 v.AddArg(y) 1452 v.AddArg(z) 1453 return true 1454 } 1455 // match: (ADD (SLL y z) x) 1456 // cond: 1457 // result: (ADDshiftLLreg x y z) 1458 for { 1459 v_0 := v.Args[0] 1460 if v_0.Op != OpARMSLL { 1461 break 1462 } 1463 y := v_0.Args[0] 1464 z := v_0.Args[1] 1465 x := v.Args[1] 1466 v.reset(OpARMADDshiftLLreg) 1467 v.AddArg(x) 1468 v.AddArg(y) 1469 v.AddArg(z) 1470 return true 1471 } 1472 // match: (ADD x (SRL y z)) 1473 // cond: 1474 // result: (ADDshiftRLreg x y z) 1475 for { 1476 x := v.Args[0] 1477 v_1 := v.Args[1] 1478 if v_1.Op != OpARMSRL { 1479 break 1480 } 1481 y := v_1.Args[0] 1482 z := v_1.Args[1] 1483 v.reset(OpARMADDshiftRLreg) 1484 v.AddArg(x) 1485 v.AddArg(y) 1486 v.AddArg(z) 1487 return true 1488 } 1489 // match: (ADD (SRL y z) x) 1490 // cond: 1491 // result: (ADDshiftRLreg x y z) 1492 for { 1493 v_0 := v.Args[0] 1494 if v_0.Op != OpARMSRL { 1495 break 1496 } 1497 y := v_0.Args[0] 1498 z := v_0.Args[1] 1499 x := v.Args[1] 1500 v.reset(OpARMADDshiftRLreg) 1501 v.AddArg(x) 1502 v.AddArg(y) 1503 v.AddArg(z) 1504 return true 1505 } 1506 // match: (ADD x (SRA y z)) 1507 // cond: 1508 // result: (ADDshiftRAreg x y z) 1509 for { 1510 x := v.Args[0] 1511 v_1 := v.Args[1] 1512 if v_1.Op != OpARMSRA { 1513 break 1514 } 1515 y := v_1.Args[0] 1516 z := v_1.Args[1] 1517 v.reset(OpARMADDshiftRAreg) 1518 v.AddArg(x) 1519 v.AddArg(y) 1520 v.AddArg(z) 1521 return true 1522 } 1523 // match: (ADD (SRA y z) x) 1524 // cond: 1525 // result: (ADDshiftRAreg x y z) 1526 for { 1527 v_0 := v.Args[0] 1528 if v_0.Op != OpARMSRA { 1529 break 1530 } 1531 y := v_0.Args[0] 1532 z := v_0.Args[1] 1533 x := v.Args[1] 1534 v.reset(OpARMADDshiftRAreg) 1535 v.AddArg(x) 1536 v.AddArg(y) 1537 v.AddArg(z) 1538 return true 1539 } 1540 // match: (ADD x (RSBconst [0] y)) 1541 // cond: 1542 // result: (SUB x y) 1543 for { 1544 x := v.Args[0] 1545 v_1 := v.Args[1] 1546 if v_1.Op != OpARMRSBconst { 1547 break 1548 } 1549 if v_1.AuxInt != 0 { 1550 break 1551 } 1552 y := v_1.Args[0] 1553 v.reset(OpARMSUB) 1554 v.AddArg(x) 1555 v.AddArg(y) 1556 return true 1557 } 1558 // match: (ADD (RSBconst [0] y) x) 1559 // cond: 1560 // result: (SUB x y) 1561 for { 1562 v_0 := v.Args[0] 1563 if v_0.Op != OpARMRSBconst { 1564 break 1565 } 1566 if v_0.AuxInt != 0 { 1567 break 1568 } 1569 y := v_0.Args[0] 1570 x := v.Args[1] 1571 v.reset(OpARMSUB) 1572 v.AddArg(x) 1573 v.AddArg(y) 1574 return true 1575 } 1576 // match: (ADD (MUL x y) a) 1577 // cond: 1578 // result: (MULA x y a) 1579 for { 1580 v_0 := v.Args[0] 1581 if v_0.Op != OpARMMUL { 1582 break 1583 } 1584 x := v_0.Args[0] 1585 y := v_0.Args[1] 1586 a := v.Args[1] 1587 v.reset(OpARMMULA) 1588 v.AddArg(x) 1589 v.AddArg(y) 1590 v.AddArg(a) 1591 return true 1592 } 1593 // match: (ADD a (MUL x y)) 1594 // cond: 1595 // result: (MULA x y a) 1596 for { 1597 a := v.Args[0] 1598 v_1 := v.Args[1] 1599 if v_1.Op != OpARMMUL { 1600 break 1601 } 1602 x := v_1.Args[0] 1603 y := v_1.Args[1] 1604 v.reset(OpARMMULA) 1605 v.AddArg(x) 1606 v.AddArg(y) 1607 v.AddArg(a) 1608 return true 1609 } 1610 return false 1611 } 1612 func rewriteValueARM_OpARMADDS(v *Value, config *Config) bool { 1613 b := v.Block 1614 _ = b 1615 // match: (ADDS (MOVWconst [c]) x) 1616 // cond: 1617 // result: (ADDSconst [c] x) 1618 for { 1619 v_0 := v.Args[0] 1620 if v_0.Op != OpARMMOVWconst { 1621 break 1622 } 1623 c := v_0.AuxInt 1624 x := v.Args[1] 1625 v.reset(OpARMADDSconst) 1626 v.AuxInt = c 1627 v.AddArg(x) 1628 return true 1629 } 1630 // match: (ADDS x (MOVWconst [c])) 1631 // cond: 1632 // result: (ADDSconst [c] x) 1633 for { 1634 x := v.Args[0] 1635 v_1 := v.Args[1] 1636 if v_1.Op != OpARMMOVWconst { 1637 break 1638 } 1639 c := v_1.AuxInt 1640 v.reset(OpARMADDSconst) 1641 v.AuxInt = c 1642 v.AddArg(x) 1643 return true 1644 } 1645 // match: (ADDS x (SLLconst [c] y)) 1646 // cond: 1647 // result: (ADDSshiftLL x y [c]) 1648 for { 1649 x := v.Args[0] 1650 v_1 := v.Args[1] 1651 if v_1.Op != OpARMSLLconst { 1652 break 1653 } 1654 c := v_1.AuxInt 1655 y := v_1.Args[0] 1656 v.reset(OpARMADDSshiftLL) 1657 v.AuxInt = c 1658 v.AddArg(x) 1659 v.AddArg(y) 1660 return true 1661 } 1662 // match: (ADDS (SLLconst [c] y) x) 1663 // cond: 1664 // result: (ADDSshiftLL x y [c]) 1665 for { 1666 v_0 := v.Args[0] 1667 if v_0.Op != OpARMSLLconst { 1668 break 1669 } 1670 c := v_0.AuxInt 1671 y := v_0.Args[0] 1672 x := v.Args[1] 1673 v.reset(OpARMADDSshiftLL) 1674 v.AuxInt = c 1675 v.AddArg(x) 1676 v.AddArg(y) 1677 return true 1678 } 1679 // match: (ADDS x (SRLconst [c] y)) 1680 // cond: 1681 // result: (ADDSshiftRL x y [c]) 1682 for { 1683 x := v.Args[0] 1684 v_1 := v.Args[1] 1685 if v_1.Op != OpARMSRLconst { 1686 break 1687 } 1688 c := v_1.AuxInt 1689 y := v_1.Args[0] 1690 v.reset(OpARMADDSshiftRL) 1691 v.AuxInt = c 1692 v.AddArg(x) 1693 v.AddArg(y) 1694 return true 1695 } 1696 // match: (ADDS (SRLconst [c] y) x) 1697 // cond: 1698 // result: (ADDSshiftRL x y [c]) 1699 for { 1700 v_0 := v.Args[0] 1701 if v_0.Op != OpARMSRLconst { 1702 break 1703 } 1704 c := v_0.AuxInt 1705 y := v_0.Args[0] 1706 x := v.Args[1] 1707 v.reset(OpARMADDSshiftRL) 1708 v.AuxInt = c 1709 v.AddArg(x) 1710 v.AddArg(y) 1711 return true 1712 } 1713 // match: (ADDS x (SRAconst [c] y)) 1714 // cond: 1715 // result: (ADDSshiftRA x y [c]) 1716 for { 1717 x := v.Args[0] 1718 v_1 := v.Args[1] 1719 if v_1.Op != OpARMSRAconst { 1720 break 1721 } 1722 c := v_1.AuxInt 1723 y := v_1.Args[0] 1724 v.reset(OpARMADDSshiftRA) 1725 v.AuxInt = c 1726 v.AddArg(x) 1727 v.AddArg(y) 1728 return true 1729 } 1730 // match: (ADDS (SRAconst [c] y) x) 1731 // cond: 1732 // result: (ADDSshiftRA x y [c]) 1733 for { 1734 v_0 := v.Args[0] 1735 if v_0.Op != OpARMSRAconst { 1736 break 1737 } 1738 c := v_0.AuxInt 1739 y := v_0.Args[0] 1740 x := v.Args[1] 1741 v.reset(OpARMADDSshiftRA) 1742 v.AuxInt = c 1743 v.AddArg(x) 1744 v.AddArg(y) 1745 return true 1746 } 1747 // match: (ADDS x (SLL y z)) 1748 // cond: 1749 // result: (ADDSshiftLLreg x y z) 1750 for { 1751 x := v.Args[0] 1752 v_1 := v.Args[1] 1753 if v_1.Op != OpARMSLL { 1754 break 1755 } 1756 y := v_1.Args[0] 1757 z := v_1.Args[1] 1758 v.reset(OpARMADDSshiftLLreg) 1759 v.AddArg(x) 1760 v.AddArg(y) 1761 v.AddArg(z) 1762 return true 1763 } 1764 // match: (ADDS (SLL y z) x) 1765 // cond: 1766 // result: (ADDSshiftLLreg x y z) 1767 for { 1768 v_0 := v.Args[0] 1769 if v_0.Op != OpARMSLL { 1770 break 1771 } 1772 y := v_0.Args[0] 1773 z := v_0.Args[1] 1774 x := v.Args[1] 1775 v.reset(OpARMADDSshiftLLreg) 1776 v.AddArg(x) 1777 v.AddArg(y) 1778 v.AddArg(z) 1779 return true 1780 } 1781 // match: (ADDS x (SRL y z)) 1782 // cond: 1783 // result: (ADDSshiftRLreg x y z) 1784 for { 1785 x := v.Args[0] 1786 v_1 := v.Args[1] 1787 if v_1.Op != OpARMSRL { 1788 break 1789 } 1790 y := v_1.Args[0] 1791 z := v_1.Args[1] 1792 v.reset(OpARMADDSshiftRLreg) 1793 v.AddArg(x) 1794 v.AddArg(y) 1795 v.AddArg(z) 1796 return true 1797 } 1798 // match: (ADDS (SRL y z) x) 1799 // cond: 1800 // result: (ADDSshiftRLreg x y z) 1801 for { 1802 v_0 := v.Args[0] 1803 if v_0.Op != OpARMSRL { 1804 break 1805 } 1806 y := v_0.Args[0] 1807 z := v_0.Args[1] 1808 x := v.Args[1] 1809 v.reset(OpARMADDSshiftRLreg) 1810 v.AddArg(x) 1811 v.AddArg(y) 1812 v.AddArg(z) 1813 return true 1814 } 1815 // match: (ADDS x (SRA y z)) 1816 // cond: 1817 // result: (ADDSshiftRAreg x y z) 1818 for { 1819 x := v.Args[0] 1820 v_1 := v.Args[1] 1821 if v_1.Op != OpARMSRA { 1822 break 1823 } 1824 y := v_1.Args[0] 1825 z := v_1.Args[1] 1826 v.reset(OpARMADDSshiftRAreg) 1827 v.AddArg(x) 1828 v.AddArg(y) 1829 v.AddArg(z) 1830 return true 1831 } 1832 // match: (ADDS (SRA y z) x) 1833 // cond: 1834 // result: (ADDSshiftRAreg x y z) 1835 for { 1836 v_0 := v.Args[0] 1837 if v_0.Op != OpARMSRA { 1838 break 1839 } 1840 y := v_0.Args[0] 1841 z := v_0.Args[1] 1842 x := v.Args[1] 1843 v.reset(OpARMADDSshiftRAreg) 1844 v.AddArg(x) 1845 v.AddArg(y) 1846 v.AddArg(z) 1847 return true 1848 } 1849 return false 1850 } 1851 func rewriteValueARM_OpARMADDSshiftLL(v *Value, config *Config) bool { 1852 b := v.Block 1853 _ = b 1854 // match: (ADDSshiftLL (MOVWconst [c]) x [d]) 1855 // cond: 1856 // result: (ADDSconst [c] (SLLconst <x.Type> x [d])) 1857 for { 1858 d := v.AuxInt 1859 v_0 := v.Args[0] 1860 if v_0.Op != OpARMMOVWconst { 1861 break 1862 } 1863 c := v_0.AuxInt 1864 x := v.Args[1] 1865 v.reset(OpARMADDSconst) 1866 v.AuxInt = c 1867 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 1868 v0.AuxInt = d 1869 v0.AddArg(x) 1870 v.AddArg(v0) 1871 return true 1872 } 1873 // match: (ADDSshiftLL x (MOVWconst [c]) [d]) 1874 // cond: 1875 // result: (ADDSconst x [int64(uint32(c)<<uint64(d))]) 1876 for { 1877 d := v.AuxInt 1878 x := v.Args[0] 1879 v_1 := v.Args[1] 1880 if v_1.Op != OpARMMOVWconst { 1881 break 1882 } 1883 c := v_1.AuxInt 1884 v.reset(OpARMADDSconst) 1885 v.AuxInt = int64(uint32(c) << uint64(d)) 1886 v.AddArg(x) 1887 return true 1888 } 1889 return false 1890 } 1891 func rewriteValueARM_OpARMADDSshiftLLreg(v *Value, config *Config) bool { 1892 b := v.Block 1893 _ = b 1894 // match: (ADDSshiftLLreg (MOVWconst [c]) x y) 1895 // cond: 1896 // result: (ADDSconst [c] (SLL <x.Type> x y)) 1897 for { 1898 v_0 := v.Args[0] 1899 if v_0.Op != OpARMMOVWconst { 1900 break 1901 } 1902 c := v_0.AuxInt 1903 x := v.Args[1] 1904 y := v.Args[2] 1905 v.reset(OpARMADDSconst) 1906 v.AuxInt = c 1907 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 1908 v0.AddArg(x) 1909 v0.AddArg(y) 1910 v.AddArg(v0) 1911 return true 1912 } 1913 // match: (ADDSshiftLLreg x y (MOVWconst [c])) 1914 // cond: 1915 // result: (ADDSshiftLL x y [c]) 1916 for { 1917 x := v.Args[0] 1918 y := v.Args[1] 1919 v_2 := v.Args[2] 1920 if v_2.Op != OpARMMOVWconst { 1921 break 1922 } 1923 c := v_2.AuxInt 1924 v.reset(OpARMADDSshiftLL) 1925 v.AuxInt = c 1926 v.AddArg(x) 1927 v.AddArg(y) 1928 return true 1929 } 1930 return false 1931 } 1932 func rewriteValueARM_OpARMADDSshiftRA(v *Value, config *Config) bool { 1933 b := v.Block 1934 _ = b 1935 // match: (ADDSshiftRA (MOVWconst [c]) x [d]) 1936 // cond: 1937 // result: (ADDSconst [c] (SRAconst <x.Type> x [d])) 1938 for { 1939 d := v.AuxInt 1940 v_0 := v.Args[0] 1941 if v_0.Op != OpARMMOVWconst { 1942 break 1943 } 1944 c := v_0.AuxInt 1945 x := v.Args[1] 1946 v.reset(OpARMADDSconst) 1947 v.AuxInt = c 1948 v0 := b.NewValue0(v.Line, OpARMSRAconst, x.Type) 1949 v0.AuxInt = d 1950 v0.AddArg(x) 1951 v.AddArg(v0) 1952 return true 1953 } 1954 // match: (ADDSshiftRA x (MOVWconst [c]) [d]) 1955 // cond: 1956 // result: (ADDSconst x [int64(int32(c)>>uint64(d))]) 1957 for { 1958 d := v.AuxInt 1959 x := v.Args[0] 1960 v_1 := v.Args[1] 1961 if v_1.Op != OpARMMOVWconst { 1962 break 1963 } 1964 c := v_1.AuxInt 1965 v.reset(OpARMADDSconst) 1966 v.AuxInt = int64(int32(c) >> uint64(d)) 1967 v.AddArg(x) 1968 return true 1969 } 1970 return false 1971 } 1972 func rewriteValueARM_OpARMADDSshiftRAreg(v *Value, config *Config) bool { 1973 b := v.Block 1974 _ = b 1975 // match: (ADDSshiftRAreg (MOVWconst [c]) x y) 1976 // cond: 1977 // result: (ADDSconst [c] (SRA <x.Type> x y)) 1978 for { 1979 v_0 := v.Args[0] 1980 if v_0.Op != OpARMMOVWconst { 1981 break 1982 } 1983 c := v_0.AuxInt 1984 x := v.Args[1] 1985 y := v.Args[2] 1986 v.reset(OpARMADDSconst) 1987 v.AuxInt = c 1988 v0 := b.NewValue0(v.Line, OpARMSRA, x.Type) 1989 v0.AddArg(x) 1990 v0.AddArg(y) 1991 v.AddArg(v0) 1992 return true 1993 } 1994 // match: (ADDSshiftRAreg x y (MOVWconst [c])) 1995 // cond: 1996 // result: (ADDSshiftRA x y [c]) 1997 for { 1998 x := v.Args[0] 1999 y := v.Args[1] 2000 v_2 := v.Args[2] 2001 if v_2.Op != OpARMMOVWconst { 2002 break 2003 } 2004 c := v_2.AuxInt 2005 v.reset(OpARMADDSshiftRA) 2006 v.AuxInt = c 2007 v.AddArg(x) 2008 v.AddArg(y) 2009 return true 2010 } 2011 return false 2012 } 2013 func rewriteValueARM_OpARMADDSshiftRL(v *Value, config *Config) bool { 2014 b := v.Block 2015 _ = b 2016 // match: (ADDSshiftRL (MOVWconst [c]) x [d]) 2017 // cond: 2018 // result: (ADDSconst [c] (SRLconst <x.Type> x [d])) 2019 for { 2020 d := v.AuxInt 2021 v_0 := v.Args[0] 2022 if v_0.Op != OpARMMOVWconst { 2023 break 2024 } 2025 c := v_0.AuxInt 2026 x := v.Args[1] 2027 v.reset(OpARMADDSconst) 2028 v.AuxInt = c 2029 v0 := b.NewValue0(v.Line, OpARMSRLconst, x.Type) 2030 v0.AuxInt = d 2031 v0.AddArg(x) 2032 v.AddArg(v0) 2033 return true 2034 } 2035 // match: (ADDSshiftRL x (MOVWconst [c]) [d]) 2036 // cond: 2037 // result: (ADDSconst x [int64(uint32(c)>>uint64(d))]) 2038 for { 2039 d := v.AuxInt 2040 x := v.Args[0] 2041 v_1 := v.Args[1] 2042 if v_1.Op != OpARMMOVWconst { 2043 break 2044 } 2045 c := v_1.AuxInt 2046 v.reset(OpARMADDSconst) 2047 v.AuxInt = int64(uint32(c) >> uint64(d)) 2048 v.AddArg(x) 2049 return true 2050 } 2051 return false 2052 } 2053 func rewriteValueARM_OpARMADDSshiftRLreg(v *Value, config *Config) bool { 2054 b := v.Block 2055 _ = b 2056 // match: (ADDSshiftRLreg (MOVWconst [c]) x y) 2057 // cond: 2058 // result: (ADDSconst [c] (SRL <x.Type> x y)) 2059 for { 2060 v_0 := v.Args[0] 2061 if v_0.Op != OpARMMOVWconst { 2062 break 2063 } 2064 c := v_0.AuxInt 2065 x := v.Args[1] 2066 y := v.Args[2] 2067 v.reset(OpARMADDSconst) 2068 v.AuxInt = c 2069 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 2070 v0.AddArg(x) 2071 v0.AddArg(y) 2072 v.AddArg(v0) 2073 return true 2074 } 2075 // match: (ADDSshiftRLreg x y (MOVWconst [c])) 2076 // cond: 2077 // result: (ADDSshiftRL x y [c]) 2078 for { 2079 x := v.Args[0] 2080 y := v.Args[1] 2081 v_2 := v.Args[2] 2082 if v_2.Op != OpARMMOVWconst { 2083 break 2084 } 2085 c := v_2.AuxInt 2086 v.reset(OpARMADDSshiftRL) 2087 v.AuxInt = c 2088 v.AddArg(x) 2089 v.AddArg(y) 2090 return true 2091 } 2092 return false 2093 } 2094 func rewriteValueARM_OpARMADDconst(v *Value, config *Config) bool { 2095 b := v.Block 2096 _ = b 2097 // match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr)) 2098 // cond: 2099 // result: (MOVWaddr [off1+off2] {sym} ptr) 2100 for { 2101 off1 := v.AuxInt 2102 v_0 := v.Args[0] 2103 if v_0.Op != OpARMMOVWaddr { 2104 break 2105 } 2106 off2 := v_0.AuxInt 2107 sym := v_0.Aux 2108 ptr := v_0.Args[0] 2109 v.reset(OpARMMOVWaddr) 2110 v.AuxInt = off1 + off2 2111 v.Aux = sym 2112 v.AddArg(ptr) 2113 return true 2114 } 2115 // match: (ADDconst [0] x) 2116 // cond: 2117 // result: x 2118 for { 2119 if v.AuxInt != 0 { 2120 break 2121 } 2122 x := v.Args[0] 2123 v.reset(OpCopy) 2124 v.Type = x.Type 2125 v.AddArg(x) 2126 return true 2127 } 2128 // match: (ADDconst [c] (MOVWconst [d])) 2129 // cond: 2130 // result: (MOVWconst [int64(int32(c+d))]) 2131 for { 2132 c := v.AuxInt 2133 v_0 := v.Args[0] 2134 if v_0.Op != OpARMMOVWconst { 2135 break 2136 } 2137 d := v_0.AuxInt 2138 v.reset(OpARMMOVWconst) 2139 v.AuxInt = int64(int32(c + d)) 2140 return true 2141 } 2142 // match: (ADDconst [c] (ADDconst [d] x)) 2143 // cond: 2144 // result: (ADDconst [int64(int32(c+d))] x) 2145 for { 2146 c := v.AuxInt 2147 v_0 := v.Args[0] 2148 if v_0.Op != OpARMADDconst { 2149 break 2150 } 2151 d := v_0.AuxInt 2152 x := v_0.Args[0] 2153 v.reset(OpARMADDconst) 2154 v.AuxInt = int64(int32(c + d)) 2155 v.AddArg(x) 2156 return true 2157 } 2158 // match: (ADDconst [c] (SUBconst [d] x)) 2159 // cond: 2160 // result: (ADDconst [int64(int32(c-d))] x) 2161 for { 2162 c := v.AuxInt 2163 v_0 := v.Args[0] 2164 if v_0.Op != OpARMSUBconst { 2165 break 2166 } 2167 d := v_0.AuxInt 2168 x := v_0.Args[0] 2169 v.reset(OpARMADDconst) 2170 v.AuxInt = int64(int32(c - d)) 2171 v.AddArg(x) 2172 return true 2173 } 2174 // match: (ADDconst [c] (RSBconst [d] x)) 2175 // cond: 2176 // result: (RSBconst [int64(int32(c+d))] x) 2177 for { 2178 c := v.AuxInt 2179 v_0 := v.Args[0] 2180 if v_0.Op != OpARMRSBconst { 2181 break 2182 } 2183 d := v_0.AuxInt 2184 x := v_0.Args[0] 2185 v.reset(OpARMRSBconst) 2186 v.AuxInt = int64(int32(c + d)) 2187 v.AddArg(x) 2188 return true 2189 } 2190 return false 2191 } 2192 func rewriteValueARM_OpARMADDshiftLL(v *Value, config *Config) bool { 2193 b := v.Block 2194 _ = b 2195 // match: (ADDshiftLL (MOVWconst [c]) x [d]) 2196 // cond: 2197 // result: (ADDconst [c] (SLLconst <x.Type> x [d])) 2198 for { 2199 d := v.AuxInt 2200 v_0 := v.Args[0] 2201 if v_0.Op != OpARMMOVWconst { 2202 break 2203 } 2204 c := v_0.AuxInt 2205 x := v.Args[1] 2206 v.reset(OpARMADDconst) 2207 v.AuxInt = c 2208 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 2209 v0.AuxInt = d 2210 v0.AddArg(x) 2211 v.AddArg(v0) 2212 return true 2213 } 2214 // match: (ADDshiftLL x (MOVWconst [c]) [d]) 2215 // cond: 2216 // result: (ADDconst x [int64(uint32(c)<<uint64(d))]) 2217 for { 2218 d := v.AuxInt 2219 x := v.Args[0] 2220 v_1 := v.Args[1] 2221 if v_1.Op != OpARMMOVWconst { 2222 break 2223 } 2224 c := v_1.AuxInt 2225 v.reset(OpARMADDconst) 2226 v.AuxInt = int64(uint32(c) << uint64(d)) 2227 v.AddArg(x) 2228 return true 2229 } 2230 return false 2231 } 2232 func rewriteValueARM_OpARMADDshiftLLreg(v *Value, config *Config) bool { 2233 b := v.Block 2234 _ = b 2235 // match: (ADDshiftLLreg (MOVWconst [c]) x y) 2236 // cond: 2237 // result: (ADDconst [c] (SLL <x.Type> x y)) 2238 for { 2239 v_0 := v.Args[0] 2240 if v_0.Op != OpARMMOVWconst { 2241 break 2242 } 2243 c := v_0.AuxInt 2244 x := v.Args[1] 2245 y := v.Args[2] 2246 v.reset(OpARMADDconst) 2247 v.AuxInt = c 2248 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 2249 v0.AddArg(x) 2250 v0.AddArg(y) 2251 v.AddArg(v0) 2252 return true 2253 } 2254 // match: (ADDshiftLLreg x y (MOVWconst [c])) 2255 // cond: 2256 // result: (ADDshiftLL x y [c]) 2257 for { 2258 x := v.Args[0] 2259 y := v.Args[1] 2260 v_2 := v.Args[2] 2261 if v_2.Op != OpARMMOVWconst { 2262 break 2263 } 2264 c := v_2.AuxInt 2265 v.reset(OpARMADDshiftLL) 2266 v.AuxInt = c 2267 v.AddArg(x) 2268 v.AddArg(y) 2269 return true 2270 } 2271 return false 2272 } 2273 func rewriteValueARM_OpARMADDshiftRA(v *Value, config *Config) bool { 2274 b := v.Block 2275 _ = b 2276 // match: (ADDshiftRA (MOVWconst [c]) x [d]) 2277 // cond: 2278 // result: (ADDconst [c] (SRAconst <x.Type> x [d])) 2279 for { 2280 d := v.AuxInt 2281 v_0 := v.Args[0] 2282 if v_0.Op != OpARMMOVWconst { 2283 break 2284 } 2285 c := v_0.AuxInt 2286 x := v.Args[1] 2287 v.reset(OpARMADDconst) 2288 v.AuxInt = c 2289 v0 := b.NewValue0(v.Line, OpARMSRAconst, x.Type) 2290 v0.AuxInt = d 2291 v0.AddArg(x) 2292 v.AddArg(v0) 2293 return true 2294 } 2295 // match: (ADDshiftRA x (MOVWconst [c]) [d]) 2296 // cond: 2297 // result: (ADDconst x [int64(int32(c)>>uint64(d))]) 2298 for { 2299 d := v.AuxInt 2300 x := v.Args[0] 2301 v_1 := v.Args[1] 2302 if v_1.Op != OpARMMOVWconst { 2303 break 2304 } 2305 c := v_1.AuxInt 2306 v.reset(OpARMADDconst) 2307 v.AuxInt = int64(int32(c) >> uint64(d)) 2308 v.AddArg(x) 2309 return true 2310 } 2311 return false 2312 } 2313 func rewriteValueARM_OpARMADDshiftRAreg(v *Value, config *Config) bool { 2314 b := v.Block 2315 _ = b 2316 // match: (ADDshiftRAreg (MOVWconst [c]) x y) 2317 // cond: 2318 // result: (ADDconst [c] (SRA <x.Type> x y)) 2319 for { 2320 v_0 := v.Args[0] 2321 if v_0.Op != OpARMMOVWconst { 2322 break 2323 } 2324 c := v_0.AuxInt 2325 x := v.Args[1] 2326 y := v.Args[2] 2327 v.reset(OpARMADDconst) 2328 v.AuxInt = c 2329 v0 := b.NewValue0(v.Line, OpARMSRA, x.Type) 2330 v0.AddArg(x) 2331 v0.AddArg(y) 2332 v.AddArg(v0) 2333 return true 2334 } 2335 // match: (ADDshiftRAreg x y (MOVWconst [c])) 2336 // cond: 2337 // result: (ADDshiftRA x y [c]) 2338 for { 2339 x := v.Args[0] 2340 y := v.Args[1] 2341 v_2 := v.Args[2] 2342 if v_2.Op != OpARMMOVWconst { 2343 break 2344 } 2345 c := v_2.AuxInt 2346 v.reset(OpARMADDshiftRA) 2347 v.AuxInt = c 2348 v.AddArg(x) 2349 v.AddArg(y) 2350 return true 2351 } 2352 return false 2353 } 2354 func rewriteValueARM_OpARMADDshiftRL(v *Value, config *Config) bool { 2355 b := v.Block 2356 _ = b 2357 // match: (ADDshiftRL (MOVWconst [c]) x [d]) 2358 // cond: 2359 // result: (ADDconst [c] (SRLconst <x.Type> x [d])) 2360 for { 2361 d := v.AuxInt 2362 v_0 := v.Args[0] 2363 if v_0.Op != OpARMMOVWconst { 2364 break 2365 } 2366 c := v_0.AuxInt 2367 x := v.Args[1] 2368 v.reset(OpARMADDconst) 2369 v.AuxInt = c 2370 v0 := b.NewValue0(v.Line, OpARMSRLconst, x.Type) 2371 v0.AuxInt = d 2372 v0.AddArg(x) 2373 v.AddArg(v0) 2374 return true 2375 } 2376 // match: (ADDshiftRL x (MOVWconst [c]) [d]) 2377 // cond: 2378 // result: (ADDconst x [int64(uint32(c)>>uint64(d))]) 2379 for { 2380 d := v.AuxInt 2381 x := v.Args[0] 2382 v_1 := v.Args[1] 2383 if v_1.Op != OpARMMOVWconst { 2384 break 2385 } 2386 c := v_1.AuxInt 2387 v.reset(OpARMADDconst) 2388 v.AuxInt = int64(uint32(c) >> uint64(d)) 2389 v.AddArg(x) 2390 return true 2391 } 2392 return false 2393 } 2394 func rewriteValueARM_OpARMADDshiftRLreg(v *Value, config *Config) bool { 2395 b := v.Block 2396 _ = b 2397 // match: (ADDshiftRLreg (MOVWconst [c]) x y) 2398 // cond: 2399 // result: (ADDconst [c] (SRL <x.Type> x y)) 2400 for { 2401 v_0 := v.Args[0] 2402 if v_0.Op != OpARMMOVWconst { 2403 break 2404 } 2405 c := v_0.AuxInt 2406 x := v.Args[1] 2407 y := v.Args[2] 2408 v.reset(OpARMADDconst) 2409 v.AuxInt = c 2410 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 2411 v0.AddArg(x) 2412 v0.AddArg(y) 2413 v.AddArg(v0) 2414 return true 2415 } 2416 // match: (ADDshiftRLreg x y (MOVWconst [c])) 2417 // cond: 2418 // result: (ADDshiftRL x y [c]) 2419 for { 2420 x := v.Args[0] 2421 y := v.Args[1] 2422 v_2 := v.Args[2] 2423 if v_2.Op != OpARMMOVWconst { 2424 break 2425 } 2426 c := v_2.AuxInt 2427 v.reset(OpARMADDshiftRL) 2428 v.AuxInt = c 2429 v.AddArg(x) 2430 v.AddArg(y) 2431 return true 2432 } 2433 return false 2434 } 2435 func rewriteValueARM_OpARMAND(v *Value, config *Config) bool { 2436 b := v.Block 2437 _ = b 2438 // match: (AND (MOVWconst [c]) x) 2439 // cond: 2440 // result: (ANDconst [c] x) 2441 for { 2442 v_0 := v.Args[0] 2443 if v_0.Op != OpARMMOVWconst { 2444 break 2445 } 2446 c := v_0.AuxInt 2447 x := v.Args[1] 2448 v.reset(OpARMANDconst) 2449 v.AuxInt = c 2450 v.AddArg(x) 2451 return true 2452 } 2453 // match: (AND x (MOVWconst [c])) 2454 // cond: 2455 // result: (ANDconst [c] x) 2456 for { 2457 x := v.Args[0] 2458 v_1 := v.Args[1] 2459 if v_1.Op != OpARMMOVWconst { 2460 break 2461 } 2462 c := v_1.AuxInt 2463 v.reset(OpARMANDconst) 2464 v.AuxInt = c 2465 v.AddArg(x) 2466 return true 2467 } 2468 // match: (AND x (SLLconst [c] y)) 2469 // cond: 2470 // result: (ANDshiftLL x y [c]) 2471 for { 2472 x := v.Args[0] 2473 v_1 := v.Args[1] 2474 if v_1.Op != OpARMSLLconst { 2475 break 2476 } 2477 c := v_1.AuxInt 2478 y := v_1.Args[0] 2479 v.reset(OpARMANDshiftLL) 2480 v.AuxInt = c 2481 v.AddArg(x) 2482 v.AddArg(y) 2483 return true 2484 } 2485 // match: (AND (SLLconst [c] y) x) 2486 // cond: 2487 // result: (ANDshiftLL x y [c]) 2488 for { 2489 v_0 := v.Args[0] 2490 if v_0.Op != OpARMSLLconst { 2491 break 2492 } 2493 c := v_0.AuxInt 2494 y := v_0.Args[0] 2495 x := v.Args[1] 2496 v.reset(OpARMANDshiftLL) 2497 v.AuxInt = c 2498 v.AddArg(x) 2499 v.AddArg(y) 2500 return true 2501 } 2502 // match: (AND x (SRLconst [c] y)) 2503 // cond: 2504 // result: (ANDshiftRL x y [c]) 2505 for { 2506 x := v.Args[0] 2507 v_1 := v.Args[1] 2508 if v_1.Op != OpARMSRLconst { 2509 break 2510 } 2511 c := v_1.AuxInt 2512 y := v_1.Args[0] 2513 v.reset(OpARMANDshiftRL) 2514 v.AuxInt = c 2515 v.AddArg(x) 2516 v.AddArg(y) 2517 return true 2518 } 2519 // match: (AND (SRLconst [c] y) x) 2520 // cond: 2521 // result: (ANDshiftRL x y [c]) 2522 for { 2523 v_0 := v.Args[0] 2524 if v_0.Op != OpARMSRLconst { 2525 break 2526 } 2527 c := v_0.AuxInt 2528 y := v_0.Args[0] 2529 x := v.Args[1] 2530 v.reset(OpARMANDshiftRL) 2531 v.AuxInt = c 2532 v.AddArg(x) 2533 v.AddArg(y) 2534 return true 2535 } 2536 // match: (AND x (SRAconst [c] y)) 2537 // cond: 2538 // result: (ANDshiftRA x y [c]) 2539 for { 2540 x := v.Args[0] 2541 v_1 := v.Args[1] 2542 if v_1.Op != OpARMSRAconst { 2543 break 2544 } 2545 c := v_1.AuxInt 2546 y := v_1.Args[0] 2547 v.reset(OpARMANDshiftRA) 2548 v.AuxInt = c 2549 v.AddArg(x) 2550 v.AddArg(y) 2551 return true 2552 } 2553 // match: (AND (SRAconst [c] y) x) 2554 // cond: 2555 // result: (ANDshiftRA x y [c]) 2556 for { 2557 v_0 := v.Args[0] 2558 if v_0.Op != OpARMSRAconst { 2559 break 2560 } 2561 c := v_0.AuxInt 2562 y := v_0.Args[0] 2563 x := v.Args[1] 2564 v.reset(OpARMANDshiftRA) 2565 v.AuxInt = c 2566 v.AddArg(x) 2567 v.AddArg(y) 2568 return true 2569 } 2570 // match: (AND x (SLL y z)) 2571 // cond: 2572 // result: (ANDshiftLLreg x y z) 2573 for { 2574 x := v.Args[0] 2575 v_1 := v.Args[1] 2576 if v_1.Op != OpARMSLL { 2577 break 2578 } 2579 y := v_1.Args[0] 2580 z := v_1.Args[1] 2581 v.reset(OpARMANDshiftLLreg) 2582 v.AddArg(x) 2583 v.AddArg(y) 2584 v.AddArg(z) 2585 return true 2586 } 2587 // match: (AND (SLL y z) x) 2588 // cond: 2589 // result: (ANDshiftLLreg x y z) 2590 for { 2591 v_0 := v.Args[0] 2592 if v_0.Op != OpARMSLL { 2593 break 2594 } 2595 y := v_0.Args[0] 2596 z := v_0.Args[1] 2597 x := v.Args[1] 2598 v.reset(OpARMANDshiftLLreg) 2599 v.AddArg(x) 2600 v.AddArg(y) 2601 v.AddArg(z) 2602 return true 2603 } 2604 // match: (AND x (SRL y z)) 2605 // cond: 2606 // result: (ANDshiftRLreg x y z) 2607 for { 2608 x := v.Args[0] 2609 v_1 := v.Args[1] 2610 if v_1.Op != OpARMSRL { 2611 break 2612 } 2613 y := v_1.Args[0] 2614 z := v_1.Args[1] 2615 v.reset(OpARMANDshiftRLreg) 2616 v.AddArg(x) 2617 v.AddArg(y) 2618 v.AddArg(z) 2619 return true 2620 } 2621 // match: (AND (SRL y z) x) 2622 // cond: 2623 // result: (ANDshiftRLreg x y z) 2624 for { 2625 v_0 := v.Args[0] 2626 if v_0.Op != OpARMSRL { 2627 break 2628 } 2629 y := v_0.Args[0] 2630 z := v_0.Args[1] 2631 x := v.Args[1] 2632 v.reset(OpARMANDshiftRLreg) 2633 v.AddArg(x) 2634 v.AddArg(y) 2635 v.AddArg(z) 2636 return true 2637 } 2638 // match: (AND x (SRA y z)) 2639 // cond: 2640 // result: (ANDshiftRAreg x y z) 2641 for { 2642 x := v.Args[0] 2643 v_1 := v.Args[1] 2644 if v_1.Op != OpARMSRA { 2645 break 2646 } 2647 y := v_1.Args[0] 2648 z := v_1.Args[1] 2649 v.reset(OpARMANDshiftRAreg) 2650 v.AddArg(x) 2651 v.AddArg(y) 2652 v.AddArg(z) 2653 return true 2654 } 2655 // match: (AND (SRA y z) x) 2656 // cond: 2657 // result: (ANDshiftRAreg x y z) 2658 for { 2659 v_0 := v.Args[0] 2660 if v_0.Op != OpARMSRA { 2661 break 2662 } 2663 y := v_0.Args[0] 2664 z := v_0.Args[1] 2665 x := v.Args[1] 2666 v.reset(OpARMANDshiftRAreg) 2667 v.AddArg(x) 2668 v.AddArg(y) 2669 v.AddArg(z) 2670 return true 2671 } 2672 // match: (AND x x) 2673 // cond: 2674 // result: x 2675 for { 2676 x := v.Args[0] 2677 if x != v.Args[1] { 2678 break 2679 } 2680 v.reset(OpCopy) 2681 v.Type = x.Type 2682 v.AddArg(x) 2683 return true 2684 } 2685 // match: (AND x (MVN y)) 2686 // cond: 2687 // result: (BIC x y) 2688 for { 2689 x := v.Args[0] 2690 v_1 := v.Args[1] 2691 if v_1.Op != OpARMMVN { 2692 break 2693 } 2694 y := v_1.Args[0] 2695 v.reset(OpARMBIC) 2696 v.AddArg(x) 2697 v.AddArg(y) 2698 return true 2699 } 2700 // match: (AND x (MVNshiftLL y [c])) 2701 // cond: 2702 // result: (BICshiftLL x y [c]) 2703 for { 2704 x := v.Args[0] 2705 v_1 := v.Args[1] 2706 if v_1.Op != OpARMMVNshiftLL { 2707 break 2708 } 2709 c := v_1.AuxInt 2710 y := v_1.Args[0] 2711 v.reset(OpARMBICshiftLL) 2712 v.AuxInt = c 2713 v.AddArg(x) 2714 v.AddArg(y) 2715 return true 2716 } 2717 // match: (AND x (MVNshiftRL y [c])) 2718 // cond: 2719 // result: (BICshiftRL x y [c]) 2720 for { 2721 x := v.Args[0] 2722 v_1 := v.Args[1] 2723 if v_1.Op != OpARMMVNshiftRL { 2724 break 2725 } 2726 c := v_1.AuxInt 2727 y := v_1.Args[0] 2728 v.reset(OpARMBICshiftRL) 2729 v.AuxInt = c 2730 v.AddArg(x) 2731 v.AddArg(y) 2732 return true 2733 } 2734 // match: (AND x (MVNshiftRA y [c])) 2735 // cond: 2736 // result: (BICshiftRA x y [c]) 2737 for { 2738 x := v.Args[0] 2739 v_1 := v.Args[1] 2740 if v_1.Op != OpARMMVNshiftRA { 2741 break 2742 } 2743 c := v_1.AuxInt 2744 y := v_1.Args[0] 2745 v.reset(OpARMBICshiftRA) 2746 v.AuxInt = c 2747 v.AddArg(x) 2748 v.AddArg(y) 2749 return true 2750 } 2751 return false 2752 } 2753 func rewriteValueARM_OpARMANDconst(v *Value, config *Config) bool { 2754 b := v.Block 2755 _ = b 2756 // match: (ANDconst [0] _) 2757 // cond: 2758 // result: (MOVWconst [0]) 2759 for { 2760 if v.AuxInt != 0 { 2761 break 2762 } 2763 v.reset(OpARMMOVWconst) 2764 v.AuxInt = 0 2765 return true 2766 } 2767 // match: (ANDconst [c] x) 2768 // cond: int32(c)==-1 2769 // result: x 2770 for { 2771 c := v.AuxInt 2772 x := v.Args[0] 2773 if !(int32(c) == -1) { 2774 break 2775 } 2776 v.reset(OpCopy) 2777 v.Type = x.Type 2778 v.AddArg(x) 2779 return true 2780 } 2781 // match: (ANDconst [c] (MOVWconst [d])) 2782 // cond: 2783 // result: (MOVWconst [c&d]) 2784 for { 2785 c := v.AuxInt 2786 v_0 := v.Args[0] 2787 if v_0.Op != OpARMMOVWconst { 2788 break 2789 } 2790 d := v_0.AuxInt 2791 v.reset(OpARMMOVWconst) 2792 v.AuxInt = c & d 2793 return true 2794 } 2795 // match: (ANDconst [c] (ANDconst [d] x)) 2796 // cond: 2797 // result: (ANDconst [c&d] x) 2798 for { 2799 c := v.AuxInt 2800 v_0 := v.Args[0] 2801 if v_0.Op != OpARMANDconst { 2802 break 2803 } 2804 d := v_0.AuxInt 2805 x := v_0.Args[0] 2806 v.reset(OpARMANDconst) 2807 v.AuxInt = c & d 2808 v.AddArg(x) 2809 return true 2810 } 2811 return false 2812 } 2813 func rewriteValueARM_OpARMANDshiftLL(v *Value, config *Config) bool { 2814 b := v.Block 2815 _ = b 2816 // match: (ANDshiftLL (MOVWconst [c]) x [d]) 2817 // cond: 2818 // result: (ANDconst [c] (SLLconst <x.Type> x [d])) 2819 for { 2820 d := v.AuxInt 2821 v_0 := v.Args[0] 2822 if v_0.Op != OpARMMOVWconst { 2823 break 2824 } 2825 c := v_0.AuxInt 2826 x := v.Args[1] 2827 v.reset(OpARMANDconst) 2828 v.AuxInt = c 2829 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 2830 v0.AuxInt = d 2831 v0.AddArg(x) 2832 v.AddArg(v0) 2833 return true 2834 } 2835 // match: (ANDshiftLL x (MOVWconst [c]) [d]) 2836 // cond: 2837 // result: (ANDconst x [int64(uint32(c)<<uint64(d))]) 2838 for { 2839 d := v.AuxInt 2840 x := v.Args[0] 2841 v_1 := v.Args[1] 2842 if v_1.Op != OpARMMOVWconst { 2843 break 2844 } 2845 c := v_1.AuxInt 2846 v.reset(OpARMANDconst) 2847 v.AuxInt = int64(uint32(c) << uint64(d)) 2848 v.AddArg(x) 2849 return true 2850 } 2851 // match: (ANDshiftLL x y:(SLLconst x [c]) [d]) 2852 // cond: c==d 2853 // result: y 2854 for { 2855 d := v.AuxInt 2856 x := v.Args[0] 2857 y := v.Args[1] 2858 if y.Op != OpARMSLLconst { 2859 break 2860 } 2861 c := y.AuxInt 2862 if x != y.Args[0] { 2863 break 2864 } 2865 if !(c == d) { 2866 break 2867 } 2868 v.reset(OpCopy) 2869 v.Type = y.Type 2870 v.AddArg(y) 2871 return true 2872 } 2873 return false 2874 } 2875 func rewriteValueARM_OpARMANDshiftLLreg(v *Value, config *Config) bool { 2876 b := v.Block 2877 _ = b 2878 // match: (ANDshiftLLreg (MOVWconst [c]) x y) 2879 // cond: 2880 // result: (ANDconst [c] (SLL <x.Type> x y)) 2881 for { 2882 v_0 := v.Args[0] 2883 if v_0.Op != OpARMMOVWconst { 2884 break 2885 } 2886 c := v_0.AuxInt 2887 x := v.Args[1] 2888 y := v.Args[2] 2889 v.reset(OpARMANDconst) 2890 v.AuxInt = c 2891 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 2892 v0.AddArg(x) 2893 v0.AddArg(y) 2894 v.AddArg(v0) 2895 return true 2896 } 2897 // match: (ANDshiftLLreg x y (MOVWconst [c])) 2898 // cond: 2899 // result: (ANDshiftLL x y [c]) 2900 for { 2901 x := v.Args[0] 2902 y := v.Args[1] 2903 v_2 := v.Args[2] 2904 if v_2.Op != OpARMMOVWconst { 2905 break 2906 } 2907 c := v_2.AuxInt 2908 v.reset(OpARMANDshiftLL) 2909 v.AuxInt = c 2910 v.AddArg(x) 2911 v.AddArg(y) 2912 return true 2913 } 2914 return false 2915 } 2916 func rewriteValueARM_OpARMANDshiftRA(v *Value, config *Config) bool { 2917 b := v.Block 2918 _ = b 2919 // match: (ANDshiftRA (MOVWconst [c]) x [d]) 2920 // cond: 2921 // result: (ANDconst [c] (SRAconst <x.Type> x [d])) 2922 for { 2923 d := v.AuxInt 2924 v_0 := v.Args[0] 2925 if v_0.Op != OpARMMOVWconst { 2926 break 2927 } 2928 c := v_0.AuxInt 2929 x := v.Args[1] 2930 v.reset(OpARMANDconst) 2931 v.AuxInt = c 2932 v0 := b.NewValue0(v.Line, OpARMSRAconst, x.Type) 2933 v0.AuxInt = d 2934 v0.AddArg(x) 2935 v.AddArg(v0) 2936 return true 2937 } 2938 // match: (ANDshiftRA x (MOVWconst [c]) [d]) 2939 // cond: 2940 // result: (ANDconst x [int64(int32(c)>>uint64(d))]) 2941 for { 2942 d := v.AuxInt 2943 x := v.Args[0] 2944 v_1 := v.Args[1] 2945 if v_1.Op != OpARMMOVWconst { 2946 break 2947 } 2948 c := v_1.AuxInt 2949 v.reset(OpARMANDconst) 2950 v.AuxInt = int64(int32(c) >> uint64(d)) 2951 v.AddArg(x) 2952 return true 2953 } 2954 // match: (ANDshiftRA x y:(SRAconst x [c]) [d]) 2955 // cond: c==d 2956 // result: y 2957 for { 2958 d := v.AuxInt 2959 x := v.Args[0] 2960 y := v.Args[1] 2961 if y.Op != OpARMSRAconst { 2962 break 2963 } 2964 c := y.AuxInt 2965 if x != y.Args[0] { 2966 break 2967 } 2968 if !(c == d) { 2969 break 2970 } 2971 v.reset(OpCopy) 2972 v.Type = y.Type 2973 v.AddArg(y) 2974 return true 2975 } 2976 return false 2977 } 2978 func rewriteValueARM_OpARMANDshiftRAreg(v *Value, config *Config) bool { 2979 b := v.Block 2980 _ = b 2981 // match: (ANDshiftRAreg (MOVWconst [c]) x y) 2982 // cond: 2983 // result: (ANDconst [c] (SRA <x.Type> x y)) 2984 for { 2985 v_0 := v.Args[0] 2986 if v_0.Op != OpARMMOVWconst { 2987 break 2988 } 2989 c := v_0.AuxInt 2990 x := v.Args[1] 2991 y := v.Args[2] 2992 v.reset(OpARMANDconst) 2993 v.AuxInt = c 2994 v0 := b.NewValue0(v.Line, OpARMSRA, x.Type) 2995 v0.AddArg(x) 2996 v0.AddArg(y) 2997 v.AddArg(v0) 2998 return true 2999 } 3000 // match: (ANDshiftRAreg x y (MOVWconst [c])) 3001 // cond: 3002 // result: (ANDshiftRA x y [c]) 3003 for { 3004 x := v.Args[0] 3005 y := v.Args[1] 3006 v_2 := v.Args[2] 3007 if v_2.Op != OpARMMOVWconst { 3008 break 3009 } 3010 c := v_2.AuxInt 3011 v.reset(OpARMANDshiftRA) 3012 v.AuxInt = c 3013 v.AddArg(x) 3014 v.AddArg(y) 3015 return true 3016 } 3017 return false 3018 } 3019 func rewriteValueARM_OpARMANDshiftRL(v *Value, config *Config) bool { 3020 b := v.Block 3021 _ = b 3022 // match: (ANDshiftRL (MOVWconst [c]) x [d]) 3023 // cond: 3024 // result: (ANDconst [c] (SRLconst <x.Type> x [d])) 3025 for { 3026 d := v.AuxInt 3027 v_0 := v.Args[0] 3028 if v_0.Op != OpARMMOVWconst { 3029 break 3030 } 3031 c := v_0.AuxInt 3032 x := v.Args[1] 3033 v.reset(OpARMANDconst) 3034 v.AuxInt = c 3035 v0 := b.NewValue0(v.Line, OpARMSRLconst, x.Type) 3036 v0.AuxInt = d 3037 v0.AddArg(x) 3038 v.AddArg(v0) 3039 return true 3040 } 3041 // match: (ANDshiftRL x (MOVWconst [c]) [d]) 3042 // cond: 3043 // result: (ANDconst x [int64(uint32(c)>>uint64(d))]) 3044 for { 3045 d := v.AuxInt 3046 x := v.Args[0] 3047 v_1 := v.Args[1] 3048 if v_1.Op != OpARMMOVWconst { 3049 break 3050 } 3051 c := v_1.AuxInt 3052 v.reset(OpARMANDconst) 3053 v.AuxInt = int64(uint32(c) >> uint64(d)) 3054 v.AddArg(x) 3055 return true 3056 } 3057 // match: (ANDshiftRL x y:(SRLconst x [c]) [d]) 3058 // cond: c==d 3059 // result: y 3060 for { 3061 d := v.AuxInt 3062 x := v.Args[0] 3063 y := v.Args[1] 3064 if y.Op != OpARMSRLconst { 3065 break 3066 } 3067 c := y.AuxInt 3068 if x != y.Args[0] { 3069 break 3070 } 3071 if !(c == d) { 3072 break 3073 } 3074 v.reset(OpCopy) 3075 v.Type = y.Type 3076 v.AddArg(y) 3077 return true 3078 } 3079 return false 3080 } 3081 func rewriteValueARM_OpARMANDshiftRLreg(v *Value, config *Config) bool { 3082 b := v.Block 3083 _ = b 3084 // match: (ANDshiftRLreg (MOVWconst [c]) x y) 3085 // cond: 3086 // result: (ANDconst [c] (SRL <x.Type> x y)) 3087 for { 3088 v_0 := v.Args[0] 3089 if v_0.Op != OpARMMOVWconst { 3090 break 3091 } 3092 c := v_0.AuxInt 3093 x := v.Args[1] 3094 y := v.Args[2] 3095 v.reset(OpARMANDconst) 3096 v.AuxInt = c 3097 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 3098 v0.AddArg(x) 3099 v0.AddArg(y) 3100 v.AddArg(v0) 3101 return true 3102 } 3103 // match: (ANDshiftRLreg x y (MOVWconst [c])) 3104 // cond: 3105 // result: (ANDshiftRL x y [c]) 3106 for { 3107 x := v.Args[0] 3108 y := v.Args[1] 3109 v_2 := v.Args[2] 3110 if v_2.Op != OpARMMOVWconst { 3111 break 3112 } 3113 c := v_2.AuxInt 3114 v.reset(OpARMANDshiftRL) 3115 v.AuxInt = c 3116 v.AddArg(x) 3117 v.AddArg(y) 3118 return true 3119 } 3120 return false 3121 } 3122 func rewriteValueARM_OpARMBIC(v *Value, config *Config) bool { 3123 b := v.Block 3124 _ = b 3125 // match: (BIC x (MOVWconst [c])) 3126 // cond: 3127 // result: (BICconst [c] x) 3128 for { 3129 x := v.Args[0] 3130 v_1 := v.Args[1] 3131 if v_1.Op != OpARMMOVWconst { 3132 break 3133 } 3134 c := v_1.AuxInt 3135 v.reset(OpARMBICconst) 3136 v.AuxInt = c 3137 v.AddArg(x) 3138 return true 3139 } 3140 // match: (BIC x (SLLconst [c] y)) 3141 // cond: 3142 // result: (BICshiftLL x y [c]) 3143 for { 3144 x := v.Args[0] 3145 v_1 := v.Args[1] 3146 if v_1.Op != OpARMSLLconst { 3147 break 3148 } 3149 c := v_1.AuxInt 3150 y := v_1.Args[0] 3151 v.reset(OpARMBICshiftLL) 3152 v.AuxInt = c 3153 v.AddArg(x) 3154 v.AddArg(y) 3155 return true 3156 } 3157 // match: (BIC x (SRLconst [c] y)) 3158 // cond: 3159 // result: (BICshiftRL x y [c]) 3160 for { 3161 x := v.Args[0] 3162 v_1 := v.Args[1] 3163 if v_1.Op != OpARMSRLconst { 3164 break 3165 } 3166 c := v_1.AuxInt 3167 y := v_1.Args[0] 3168 v.reset(OpARMBICshiftRL) 3169 v.AuxInt = c 3170 v.AddArg(x) 3171 v.AddArg(y) 3172 return true 3173 } 3174 // match: (BIC x (SRAconst [c] y)) 3175 // cond: 3176 // result: (BICshiftRA x y [c]) 3177 for { 3178 x := v.Args[0] 3179 v_1 := v.Args[1] 3180 if v_1.Op != OpARMSRAconst { 3181 break 3182 } 3183 c := v_1.AuxInt 3184 y := v_1.Args[0] 3185 v.reset(OpARMBICshiftRA) 3186 v.AuxInt = c 3187 v.AddArg(x) 3188 v.AddArg(y) 3189 return true 3190 } 3191 // match: (BIC x (SLL y z)) 3192 // cond: 3193 // result: (BICshiftLLreg x y z) 3194 for { 3195 x := v.Args[0] 3196 v_1 := v.Args[1] 3197 if v_1.Op != OpARMSLL { 3198 break 3199 } 3200 y := v_1.Args[0] 3201 z := v_1.Args[1] 3202 v.reset(OpARMBICshiftLLreg) 3203 v.AddArg(x) 3204 v.AddArg(y) 3205 v.AddArg(z) 3206 return true 3207 } 3208 // match: (BIC x (SRL y z)) 3209 // cond: 3210 // result: (BICshiftRLreg x y z) 3211 for { 3212 x := v.Args[0] 3213 v_1 := v.Args[1] 3214 if v_1.Op != OpARMSRL { 3215 break 3216 } 3217 y := v_1.Args[0] 3218 z := v_1.Args[1] 3219 v.reset(OpARMBICshiftRLreg) 3220 v.AddArg(x) 3221 v.AddArg(y) 3222 v.AddArg(z) 3223 return true 3224 } 3225 // match: (BIC x (SRA y z)) 3226 // cond: 3227 // result: (BICshiftRAreg x y z) 3228 for { 3229 x := v.Args[0] 3230 v_1 := v.Args[1] 3231 if v_1.Op != OpARMSRA { 3232 break 3233 } 3234 y := v_1.Args[0] 3235 z := v_1.Args[1] 3236 v.reset(OpARMBICshiftRAreg) 3237 v.AddArg(x) 3238 v.AddArg(y) 3239 v.AddArg(z) 3240 return true 3241 } 3242 // match: (BIC x x) 3243 // cond: 3244 // result: (MOVWconst [0]) 3245 for { 3246 x := v.Args[0] 3247 if x != v.Args[1] { 3248 break 3249 } 3250 v.reset(OpARMMOVWconst) 3251 v.AuxInt = 0 3252 return true 3253 } 3254 return false 3255 } 3256 func rewriteValueARM_OpARMBICconst(v *Value, config *Config) bool { 3257 b := v.Block 3258 _ = b 3259 // match: (BICconst [0] x) 3260 // cond: 3261 // result: x 3262 for { 3263 if v.AuxInt != 0 { 3264 break 3265 } 3266 x := v.Args[0] 3267 v.reset(OpCopy) 3268 v.Type = x.Type 3269 v.AddArg(x) 3270 return true 3271 } 3272 // match: (BICconst [c] _) 3273 // cond: int32(c)==-1 3274 // result: (MOVWconst [0]) 3275 for { 3276 c := v.AuxInt 3277 if !(int32(c) == -1) { 3278 break 3279 } 3280 v.reset(OpARMMOVWconst) 3281 v.AuxInt = 0 3282 return true 3283 } 3284 // match: (BICconst [c] (MOVWconst [d])) 3285 // cond: 3286 // result: (MOVWconst [d&^c]) 3287 for { 3288 c := v.AuxInt 3289 v_0 := v.Args[0] 3290 if v_0.Op != OpARMMOVWconst { 3291 break 3292 } 3293 d := v_0.AuxInt 3294 v.reset(OpARMMOVWconst) 3295 v.AuxInt = d &^ c 3296 return true 3297 } 3298 return false 3299 } 3300 func rewriteValueARM_OpARMBICshiftLL(v *Value, config *Config) bool { 3301 b := v.Block 3302 _ = b 3303 // match: (BICshiftLL x (MOVWconst [c]) [d]) 3304 // cond: 3305 // result: (BICconst x [int64(uint32(c)<<uint64(d))]) 3306 for { 3307 d := v.AuxInt 3308 x := v.Args[0] 3309 v_1 := v.Args[1] 3310 if v_1.Op != OpARMMOVWconst { 3311 break 3312 } 3313 c := v_1.AuxInt 3314 v.reset(OpARMBICconst) 3315 v.AuxInt = int64(uint32(c) << uint64(d)) 3316 v.AddArg(x) 3317 return true 3318 } 3319 // match: (BICshiftLL x (SLLconst x [c]) [d]) 3320 // cond: c==d 3321 // result: (MOVWconst [0]) 3322 for { 3323 d := v.AuxInt 3324 x := v.Args[0] 3325 v_1 := v.Args[1] 3326 if v_1.Op != OpARMSLLconst { 3327 break 3328 } 3329 c := v_1.AuxInt 3330 if x != v_1.Args[0] { 3331 break 3332 } 3333 if !(c == d) { 3334 break 3335 } 3336 v.reset(OpARMMOVWconst) 3337 v.AuxInt = 0 3338 return true 3339 } 3340 return false 3341 } 3342 func rewriteValueARM_OpARMBICshiftLLreg(v *Value, config *Config) bool { 3343 b := v.Block 3344 _ = b 3345 // match: (BICshiftLLreg x y (MOVWconst [c])) 3346 // cond: 3347 // result: (BICshiftLL x y [c]) 3348 for { 3349 x := v.Args[0] 3350 y := v.Args[1] 3351 v_2 := v.Args[2] 3352 if v_2.Op != OpARMMOVWconst { 3353 break 3354 } 3355 c := v_2.AuxInt 3356 v.reset(OpARMBICshiftLL) 3357 v.AuxInt = c 3358 v.AddArg(x) 3359 v.AddArg(y) 3360 return true 3361 } 3362 return false 3363 } 3364 func rewriteValueARM_OpARMBICshiftRA(v *Value, config *Config) bool { 3365 b := v.Block 3366 _ = b 3367 // match: (BICshiftRA x (MOVWconst [c]) [d]) 3368 // cond: 3369 // result: (BICconst x [int64(int32(c)>>uint64(d))]) 3370 for { 3371 d := v.AuxInt 3372 x := v.Args[0] 3373 v_1 := v.Args[1] 3374 if v_1.Op != OpARMMOVWconst { 3375 break 3376 } 3377 c := v_1.AuxInt 3378 v.reset(OpARMBICconst) 3379 v.AuxInt = int64(int32(c) >> uint64(d)) 3380 v.AddArg(x) 3381 return true 3382 } 3383 // match: (BICshiftRA x (SRAconst x [c]) [d]) 3384 // cond: c==d 3385 // result: (MOVWconst [0]) 3386 for { 3387 d := v.AuxInt 3388 x := v.Args[0] 3389 v_1 := v.Args[1] 3390 if v_1.Op != OpARMSRAconst { 3391 break 3392 } 3393 c := v_1.AuxInt 3394 if x != v_1.Args[0] { 3395 break 3396 } 3397 if !(c == d) { 3398 break 3399 } 3400 v.reset(OpARMMOVWconst) 3401 v.AuxInt = 0 3402 return true 3403 } 3404 return false 3405 } 3406 func rewriteValueARM_OpARMBICshiftRAreg(v *Value, config *Config) bool { 3407 b := v.Block 3408 _ = b 3409 // match: (BICshiftRAreg x y (MOVWconst [c])) 3410 // cond: 3411 // result: (BICshiftRA x y [c]) 3412 for { 3413 x := v.Args[0] 3414 y := v.Args[1] 3415 v_2 := v.Args[2] 3416 if v_2.Op != OpARMMOVWconst { 3417 break 3418 } 3419 c := v_2.AuxInt 3420 v.reset(OpARMBICshiftRA) 3421 v.AuxInt = c 3422 v.AddArg(x) 3423 v.AddArg(y) 3424 return true 3425 } 3426 return false 3427 } 3428 func rewriteValueARM_OpARMBICshiftRL(v *Value, config *Config) bool { 3429 b := v.Block 3430 _ = b 3431 // match: (BICshiftRL x (MOVWconst [c]) [d]) 3432 // cond: 3433 // result: (BICconst x [int64(uint32(c)>>uint64(d))]) 3434 for { 3435 d := v.AuxInt 3436 x := v.Args[0] 3437 v_1 := v.Args[1] 3438 if v_1.Op != OpARMMOVWconst { 3439 break 3440 } 3441 c := v_1.AuxInt 3442 v.reset(OpARMBICconst) 3443 v.AuxInt = int64(uint32(c) >> uint64(d)) 3444 v.AddArg(x) 3445 return true 3446 } 3447 // match: (BICshiftRL x (SRLconst x [c]) [d]) 3448 // cond: c==d 3449 // result: (MOVWconst [0]) 3450 for { 3451 d := v.AuxInt 3452 x := v.Args[0] 3453 v_1 := v.Args[1] 3454 if v_1.Op != OpARMSRLconst { 3455 break 3456 } 3457 c := v_1.AuxInt 3458 if x != v_1.Args[0] { 3459 break 3460 } 3461 if !(c == d) { 3462 break 3463 } 3464 v.reset(OpARMMOVWconst) 3465 v.AuxInt = 0 3466 return true 3467 } 3468 return false 3469 } 3470 func rewriteValueARM_OpARMBICshiftRLreg(v *Value, config *Config) bool { 3471 b := v.Block 3472 _ = b 3473 // match: (BICshiftRLreg x y (MOVWconst [c])) 3474 // cond: 3475 // result: (BICshiftRL x y [c]) 3476 for { 3477 x := v.Args[0] 3478 y := v.Args[1] 3479 v_2 := v.Args[2] 3480 if v_2.Op != OpARMMOVWconst { 3481 break 3482 } 3483 c := v_2.AuxInt 3484 v.reset(OpARMBICshiftRL) 3485 v.AuxInt = c 3486 v.AddArg(x) 3487 v.AddArg(y) 3488 return true 3489 } 3490 return false 3491 } 3492 func rewriteValueARM_OpARMCMOVWHSconst(v *Value, config *Config) bool { 3493 b := v.Block 3494 _ = b 3495 // match: (CMOVWHSconst _ (FlagEQ) [c]) 3496 // cond: 3497 // result: (MOVWconst [c]) 3498 for { 3499 c := v.AuxInt 3500 v_1 := v.Args[1] 3501 if v_1.Op != OpARMFlagEQ { 3502 break 3503 } 3504 v.reset(OpARMMOVWconst) 3505 v.AuxInt = c 3506 return true 3507 } 3508 // match: (CMOVWHSconst x (FlagLT_ULT)) 3509 // cond: 3510 // result: x 3511 for { 3512 x := v.Args[0] 3513 v_1 := v.Args[1] 3514 if v_1.Op != OpARMFlagLT_ULT { 3515 break 3516 } 3517 v.reset(OpCopy) 3518 v.Type = x.Type 3519 v.AddArg(x) 3520 return true 3521 } 3522 // match: (CMOVWHSconst _ (FlagLT_UGT) [c]) 3523 // cond: 3524 // result: (MOVWconst [c]) 3525 for { 3526 c := v.AuxInt 3527 v_1 := v.Args[1] 3528 if v_1.Op != OpARMFlagLT_UGT { 3529 break 3530 } 3531 v.reset(OpARMMOVWconst) 3532 v.AuxInt = c 3533 return true 3534 } 3535 // match: (CMOVWHSconst x (FlagGT_ULT)) 3536 // cond: 3537 // result: x 3538 for { 3539 x := v.Args[0] 3540 v_1 := v.Args[1] 3541 if v_1.Op != OpARMFlagGT_ULT { 3542 break 3543 } 3544 v.reset(OpCopy) 3545 v.Type = x.Type 3546 v.AddArg(x) 3547 return true 3548 } 3549 // match: (CMOVWHSconst _ (FlagGT_UGT) [c]) 3550 // cond: 3551 // result: (MOVWconst [c]) 3552 for { 3553 c := v.AuxInt 3554 v_1 := v.Args[1] 3555 if v_1.Op != OpARMFlagGT_UGT { 3556 break 3557 } 3558 v.reset(OpARMMOVWconst) 3559 v.AuxInt = c 3560 return true 3561 } 3562 // match: (CMOVWHSconst x (InvertFlags flags) [c]) 3563 // cond: 3564 // result: (CMOVWLSconst x flags [c]) 3565 for { 3566 c := v.AuxInt 3567 x := v.Args[0] 3568 v_1 := v.Args[1] 3569 if v_1.Op != OpARMInvertFlags { 3570 break 3571 } 3572 flags := v_1.Args[0] 3573 v.reset(OpARMCMOVWLSconst) 3574 v.AuxInt = c 3575 v.AddArg(x) 3576 v.AddArg(flags) 3577 return true 3578 } 3579 return false 3580 } 3581 func rewriteValueARM_OpARMCMOVWLSconst(v *Value, config *Config) bool { 3582 b := v.Block 3583 _ = b 3584 // match: (CMOVWLSconst _ (FlagEQ) [c]) 3585 // cond: 3586 // result: (MOVWconst [c]) 3587 for { 3588 c := v.AuxInt 3589 v_1 := v.Args[1] 3590 if v_1.Op != OpARMFlagEQ { 3591 break 3592 } 3593 v.reset(OpARMMOVWconst) 3594 v.AuxInt = c 3595 return true 3596 } 3597 // match: (CMOVWLSconst _ (FlagLT_ULT) [c]) 3598 // cond: 3599 // result: (MOVWconst [c]) 3600 for { 3601 c := v.AuxInt 3602 v_1 := v.Args[1] 3603 if v_1.Op != OpARMFlagLT_ULT { 3604 break 3605 } 3606 v.reset(OpARMMOVWconst) 3607 v.AuxInt = c 3608 return true 3609 } 3610 // match: (CMOVWLSconst x (FlagLT_UGT)) 3611 // cond: 3612 // result: x 3613 for { 3614 x := v.Args[0] 3615 v_1 := v.Args[1] 3616 if v_1.Op != OpARMFlagLT_UGT { 3617 break 3618 } 3619 v.reset(OpCopy) 3620 v.Type = x.Type 3621 v.AddArg(x) 3622 return true 3623 } 3624 // match: (CMOVWLSconst _ (FlagGT_ULT) [c]) 3625 // cond: 3626 // result: (MOVWconst [c]) 3627 for { 3628 c := v.AuxInt 3629 v_1 := v.Args[1] 3630 if v_1.Op != OpARMFlagGT_ULT { 3631 break 3632 } 3633 v.reset(OpARMMOVWconst) 3634 v.AuxInt = c 3635 return true 3636 } 3637 // match: (CMOVWLSconst x (FlagGT_UGT)) 3638 // cond: 3639 // result: x 3640 for { 3641 x := v.Args[0] 3642 v_1 := v.Args[1] 3643 if v_1.Op != OpARMFlagGT_UGT { 3644 break 3645 } 3646 v.reset(OpCopy) 3647 v.Type = x.Type 3648 v.AddArg(x) 3649 return true 3650 } 3651 // match: (CMOVWLSconst x (InvertFlags flags) [c]) 3652 // cond: 3653 // result: (CMOVWHSconst x flags [c]) 3654 for { 3655 c := v.AuxInt 3656 x := v.Args[0] 3657 v_1 := v.Args[1] 3658 if v_1.Op != OpARMInvertFlags { 3659 break 3660 } 3661 flags := v_1.Args[0] 3662 v.reset(OpARMCMOVWHSconst) 3663 v.AuxInt = c 3664 v.AddArg(x) 3665 v.AddArg(flags) 3666 return true 3667 } 3668 return false 3669 } 3670 func rewriteValueARM_OpARMCMP(v *Value, config *Config) bool { 3671 b := v.Block 3672 _ = b 3673 // match: (CMP x (MOVWconst [c])) 3674 // cond: 3675 // result: (CMPconst [c] x) 3676 for { 3677 x := v.Args[0] 3678 v_1 := v.Args[1] 3679 if v_1.Op != OpARMMOVWconst { 3680 break 3681 } 3682 c := v_1.AuxInt 3683 v.reset(OpARMCMPconst) 3684 v.AuxInt = c 3685 v.AddArg(x) 3686 return true 3687 } 3688 // match: (CMP (MOVWconst [c]) x) 3689 // cond: 3690 // result: (InvertFlags (CMPconst [c] x)) 3691 for { 3692 v_0 := v.Args[0] 3693 if v_0.Op != OpARMMOVWconst { 3694 break 3695 } 3696 c := v_0.AuxInt 3697 x := v.Args[1] 3698 v.reset(OpARMInvertFlags) 3699 v0 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 3700 v0.AuxInt = c 3701 v0.AddArg(x) 3702 v.AddArg(v0) 3703 return true 3704 } 3705 // match: (CMP x (SLLconst [c] y)) 3706 // cond: 3707 // result: (CMPshiftLL x y [c]) 3708 for { 3709 x := v.Args[0] 3710 v_1 := v.Args[1] 3711 if v_1.Op != OpARMSLLconst { 3712 break 3713 } 3714 c := v_1.AuxInt 3715 y := v_1.Args[0] 3716 v.reset(OpARMCMPshiftLL) 3717 v.AuxInt = c 3718 v.AddArg(x) 3719 v.AddArg(y) 3720 return true 3721 } 3722 // match: (CMP (SLLconst [c] y) x) 3723 // cond: 3724 // result: (InvertFlags (CMPshiftLL x y [c])) 3725 for { 3726 v_0 := v.Args[0] 3727 if v_0.Op != OpARMSLLconst { 3728 break 3729 } 3730 c := v_0.AuxInt 3731 y := v_0.Args[0] 3732 x := v.Args[1] 3733 v.reset(OpARMInvertFlags) 3734 v0 := b.NewValue0(v.Line, OpARMCMPshiftLL, TypeFlags) 3735 v0.AuxInt = c 3736 v0.AddArg(x) 3737 v0.AddArg(y) 3738 v.AddArg(v0) 3739 return true 3740 } 3741 // match: (CMP x (SRLconst [c] y)) 3742 // cond: 3743 // result: (CMPshiftRL x y [c]) 3744 for { 3745 x := v.Args[0] 3746 v_1 := v.Args[1] 3747 if v_1.Op != OpARMSRLconst { 3748 break 3749 } 3750 c := v_1.AuxInt 3751 y := v_1.Args[0] 3752 v.reset(OpARMCMPshiftRL) 3753 v.AuxInt = c 3754 v.AddArg(x) 3755 v.AddArg(y) 3756 return true 3757 } 3758 // match: (CMP (SRLconst [c] y) x) 3759 // cond: 3760 // result: (InvertFlags (CMPshiftRL x y [c])) 3761 for { 3762 v_0 := v.Args[0] 3763 if v_0.Op != OpARMSRLconst { 3764 break 3765 } 3766 c := v_0.AuxInt 3767 y := v_0.Args[0] 3768 x := v.Args[1] 3769 v.reset(OpARMInvertFlags) 3770 v0 := b.NewValue0(v.Line, OpARMCMPshiftRL, TypeFlags) 3771 v0.AuxInt = c 3772 v0.AddArg(x) 3773 v0.AddArg(y) 3774 v.AddArg(v0) 3775 return true 3776 } 3777 // match: (CMP x (SRAconst [c] y)) 3778 // cond: 3779 // result: (CMPshiftRA x y [c]) 3780 for { 3781 x := v.Args[0] 3782 v_1 := v.Args[1] 3783 if v_1.Op != OpARMSRAconst { 3784 break 3785 } 3786 c := v_1.AuxInt 3787 y := v_1.Args[0] 3788 v.reset(OpARMCMPshiftRA) 3789 v.AuxInt = c 3790 v.AddArg(x) 3791 v.AddArg(y) 3792 return true 3793 } 3794 // match: (CMP (SRAconst [c] y) x) 3795 // cond: 3796 // result: (InvertFlags (CMPshiftRA x y [c])) 3797 for { 3798 v_0 := v.Args[0] 3799 if v_0.Op != OpARMSRAconst { 3800 break 3801 } 3802 c := v_0.AuxInt 3803 y := v_0.Args[0] 3804 x := v.Args[1] 3805 v.reset(OpARMInvertFlags) 3806 v0 := b.NewValue0(v.Line, OpARMCMPshiftRA, TypeFlags) 3807 v0.AuxInt = c 3808 v0.AddArg(x) 3809 v0.AddArg(y) 3810 v.AddArg(v0) 3811 return true 3812 } 3813 // match: (CMP x (SLL y z)) 3814 // cond: 3815 // result: (CMPshiftLLreg x y z) 3816 for { 3817 x := v.Args[0] 3818 v_1 := v.Args[1] 3819 if v_1.Op != OpARMSLL { 3820 break 3821 } 3822 y := v_1.Args[0] 3823 z := v_1.Args[1] 3824 v.reset(OpARMCMPshiftLLreg) 3825 v.AddArg(x) 3826 v.AddArg(y) 3827 v.AddArg(z) 3828 return true 3829 } 3830 // match: (CMP (SLL y z) x) 3831 // cond: 3832 // result: (InvertFlags (CMPshiftLLreg x y z)) 3833 for { 3834 v_0 := v.Args[0] 3835 if v_0.Op != OpARMSLL { 3836 break 3837 } 3838 y := v_0.Args[0] 3839 z := v_0.Args[1] 3840 x := v.Args[1] 3841 v.reset(OpARMInvertFlags) 3842 v0 := b.NewValue0(v.Line, OpARMCMPshiftLLreg, TypeFlags) 3843 v0.AddArg(x) 3844 v0.AddArg(y) 3845 v0.AddArg(z) 3846 v.AddArg(v0) 3847 return true 3848 } 3849 // match: (CMP x (SRL y z)) 3850 // cond: 3851 // result: (CMPshiftRLreg x y z) 3852 for { 3853 x := v.Args[0] 3854 v_1 := v.Args[1] 3855 if v_1.Op != OpARMSRL { 3856 break 3857 } 3858 y := v_1.Args[0] 3859 z := v_1.Args[1] 3860 v.reset(OpARMCMPshiftRLreg) 3861 v.AddArg(x) 3862 v.AddArg(y) 3863 v.AddArg(z) 3864 return true 3865 } 3866 // match: (CMP (SRL y z) x) 3867 // cond: 3868 // result: (InvertFlags (CMPshiftRLreg x y z)) 3869 for { 3870 v_0 := v.Args[0] 3871 if v_0.Op != OpARMSRL { 3872 break 3873 } 3874 y := v_0.Args[0] 3875 z := v_0.Args[1] 3876 x := v.Args[1] 3877 v.reset(OpARMInvertFlags) 3878 v0 := b.NewValue0(v.Line, OpARMCMPshiftRLreg, TypeFlags) 3879 v0.AddArg(x) 3880 v0.AddArg(y) 3881 v0.AddArg(z) 3882 v.AddArg(v0) 3883 return true 3884 } 3885 // match: (CMP x (SRA y z)) 3886 // cond: 3887 // result: (CMPshiftRAreg x y z) 3888 for { 3889 x := v.Args[0] 3890 v_1 := v.Args[1] 3891 if v_1.Op != OpARMSRA { 3892 break 3893 } 3894 y := v_1.Args[0] 3895 z := v_1.Args[1] 3896 v.reset(OpARMCMPshiftRAreg) 3897 v.AddArg(x) 3898 v.AddArg(y) 3899 v.AddArg(z) 3900 return true 3901 } 3902 // match: (CMP (SRA y z) x) 3903 // cond: 3904 // result: (InvertFlags (CMPshiftRAreg x y z)) 3905 for { 3906 v_0 := v.Args[0] 3907 if v_0.Op != OpARMSRA { 3908 break 3909 } 3910 y := v_0.Args[0] 3911 z := v_0.Args[1] 3912 x := v.Args[1] 3913 v.reset(OpARMInvertFlags) 3914 v0 := b.NewValue0(v.Line, OpARMCMPshiftRAreg, TypeFlags) 3915 v0.AddArg(x) 3916 v0.AddArg(y) 3917 v0.AddArg(z) 3918 v.AddArg(v0) 3919 return true 3920 } 3921 return false 3922 } 3923 func rewriteValueARM_OpARMCMPD(v *Value, config *Config) bool { 3924 b := v.Block 3925 _ = b 3926 // match: (CMPD x (MOVDconst [0])) 3927 // cond: 3928 // result: (CMPD0 x) 3929 for { 3930 x := v.Args[0] 3931 v_1 := v.Args[1] 3932 if v_1.Op != OpARMMOVDconst { 3933 break 3934 } 3935 if v_1.AuxInt != 0 { 3936 break 3937 } 3938 v.reset(OpARMCMPD0) 3939 v.AddArg(x) 3940 return true 3941 } 3942 return false 3943 } 3944 func rewriteValueARM_OpARMCMPF(v *Value, config *Config) bool { 3945 b := v.Block 3946 _ = b 3947 // match: (CMPF x (MOVFconst [0])) 3948 // cond: 3949 // result: (CMPF0 x) 3950 for { 3951 x := v.Args[0] 3952 v_1 := v.Args[1] 3953 if v_1.Op != OpARMMOVFconst { 3954 break 3955 } 3956 if v_1.AuxInt != 0 { 3957 break 3958 } 3959 v.reset(OpARMCMPF0) 3960 v.AddArg(x) 3961 return true 3962 } 3963 return false 3964 } 3965 func rewriteValueARM_OpARMCMPconst(v *Value, config *Config) bool { 3966 b := v.Block 3967 _ = b 3968 // match: (CMPconst (MOVWconst [x]) [y]) 3969 // cond: int32(x)==int32(y) 3970 // result: (FlagEQ) 3971 for { 3972 y := v.AuxInt 3973 v_0 := v.Args[0] 3974 if v_0.Op != OpARMMOVWconst { 3975 break 3976 } 3977 x := v_0.AuxInt 3978 if !(int32(x) == int32(y)) { 3979 break 3980 } 3981 v.reset(OpARMFlagEQ) 3982 return true 3983 } 3984 // match: (CMPconst (MOVWconst [x]) [y]) 3985 // cond: int32(x)<int32(y) && uint32(x)<uint32(y) 3986 // result: (FlagLT_ULT) 3987 for { 3988 y := v.AuxInt 3989 v_0 := v.Args[0] 3990 if v_0.Op != OpARMMOVWconst { 3991 break 3992 } 3993 x := v_0.AuxInt 3994 if !(int32(x) < int32(y) && uint32(x) < uint32(y)) { 3995 break 3996 } 3997 v.reset(OpARMFlagLT_ULT) 3998 return true 3999 } 4000 // match: (CMPconst (MOVWconst [x]) [y]) 4001 // cond: int32(x)<int32(y) && uint32(x)>uint32(y) 4002 // result: (FlagLT_UGT) 4003 for { 4004 y := v.AuxInt 4005 v_0 := v.Args[0] 4006 if v_0.Op != OpARMMOVWconst { 4007 break 4008 } 4009 x := v_0.AuxInt 4010 if !(int32(x) < int32(y) && uint32(x) > uint32(y)) { 4011 break 4012 } 4013 v.reset(OpARMFlagLT_UGT) 4014 return true 4015 } 4016 // match: (CMPconst (MOVWconst [x]) [y]) 4017 // cond: int32(x)>int32(y) && uint32(x)<uint32(y) 4018 // result: (FlagGT_ULT) 4019 for { 4020 y := v.AuxInt 4021 v_0 := v.Args[0] 4022 if v_0.Op != OpARMMOVWconst { 4023 break 4024 } 4025 x := v_0.AuxInt 4026 if !(int32(x) > int32(y) && uint32(x) < uint32(y)) { 4027 break 4028 } 4029 v.reset(OpARMFlagGT_ULT) 4030 return true 4031 } 4032 // match: (CMPconst (MOVWconst [x]) [y]) 4033 // cond: int32(x)>int32(y) && uint32(x)>uint32(y) 4034 // result: (FlagGT_UGT) 4035 for { 4036 y := v.AuxInt 4037 v_0 := v.Args[0] 4038 if v_0.Op != OpARMMOVWconst { 4039 break 4040 } 4041 x := v_0.AuxInt 4042 if !(int32(x) > int32(y) && uint32(x) > uint32(y)) { 4043 break 4044 } 4045 v.reset(OpARMFlagGT_UGT) 4046 return true 4047 } 4048 // match: (CMPconst (MOVBUreg _) [c]) 4049 // cond: 0xff < c 4050 // result: (FlagLT_ULT) 4051 for { 4052 c := v.AuxInt 4053 v_0 := v.Args[0] 4054 if v_0.Op != OpARMMOVBUreg { 4055 break 4056 } 4057 if !(0xff < c) { 4058 break 4059 } 4060 v.reset(OpARMFlagLT_ULT) 4061 return true 4062 } 4063 // match: (CMPconst (MOVHUreg _) [c]) 4064 // cond: 0xffff < c 4065 // result: (FlagLT_ULT) 4066 for { 4067 c := v.AuxInt 4068 v_0 := v.Args[0] 4069 if v_0.Op != OpARMMOVHUreg { 4070 break 4071 } 4072 if !(0xffff < c) { 4073 break 4074 } 4075 v.reset(OpARMFlagLT_ULT) 4076 return true 4077 } 4078 // match: (CMPconst (ANDconst _ [m]) [n]) 4079 // cond: 0 <= int32(m) && int32(m) < int32(n) 4080 // result: (FlagLT_ULT) 4081 for { 4082 n := v.AuxInt 4083 v_0 := v.Args[0] 4084 if v_0.Op != OpARMANDconst { 4085 break 4086 } 4087 m := v_0.AuxInt 4088 if !(0 <= int32(m) && int32(m) < int32(n)) { 4089 break 4090 } 4091 v.reset(OpARMFlagLT_ULT) 4092 return true 4093 } 4094 // match: (CMPconst (SRLconst _ [c]) [n]) 4095 // cond: 0 <= n && 0 < c && c <= 32 && (1<<uint32(32-c)) <= uint32(n) 4096 // result: (FlagLT_ULT) 4097 for { 4098 n := v.AuxInt 4099 v_0 := v.Args[0] 4100 if v_0.Op != OpARMSRLconst { 4101 break 4102 } 4103 c := v_0.AuxInt 4104 if !(0 <= n && 0 < c && c <= 32 && (1<<uint32(32-c)) <= uint32(n)) { 4105 break 4106 } 4107 v.reset(OpARMFlagLT_ULT) 4108 return true 4109 } 4110 return false 4111 } 4112 func rewriteValueARM_OpARMCMPshiftLL(v *Value, config *Config) bool { 4113 b := v.Block 4114 _ = b 4115 // match: (CMPshiftLL (MOVWconst [c]) x [d]) 4116 // cond: 4117 // result: (InvertFlags (CMPconst [c] (SLLconst <x.Type> x [d]))) 4118 for { 4119 d := v.AuxInt 4120 v_0 := v.Args[0] 4121 if v_0.Op != OpARMMOVWconst { 4122 break 4123 } 4124 c := v_0.AuxInt 4125 x := v.Args[1] 4126 v.reset(OpARMInvertFlags) 4127 v0 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 4128 v0.AuxInt = c 4129 v1 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 4130 v1.AuxInt = d 4131 v1.AddArg(x) 4132 v0.AddArg(v1) 4133 v.AddArg(v0) 4134 return true 4135 } 4136 // match: (CMPshiftLL x (MOVWconst [c]) [d]) 4137 // cond: 4138 // result: (CMPconst x [int64(uint32(c)<<uint64(d))]) 4139 for { 4140 d := v.AuxInt 4141 x := v.Args[0] 4142 v_1 := v.Args[1] 4143 if v_1.Op != OpARMMOVWconst { 4144 break 4145 } 4146 c := v_1.AuxInt 4147 v.reset(OpARMCMPconst) 4148 v.AuxInt = int64(uint32(c) << uint64(d)) 4149 v.AddArg(x) 4150 return true 4151 } 4152 return false 4153 } 4154 func rewriteValueARM_OpARMCMPshiftLLreg(v *Value, config *Config) bool { 4155 b := v.Block 4156 _ = b 4157 // match: (CMPshiftLLreg (MOVWconst [c]) x y) 4158 // cond: 4159 // result: (InvertFlags (CMPconst [c] (SLL <x.Type> x y))) 4160 for { 4161 v_0 := v.Args[0] 4162 if v_0.Op != OpARMMOVWconst { 4163 break 4164 } 4165 c := v_0.AuxInt 4166 x := v.Args[1] 4167 y := v.Args[2] 4168 v.reset(OpARMInvertFlags) 4169 v0 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 4170 v0.AuxInt = c 4171 v1 := b.NewValue0(v.Line, OpARMSLL, x.Type) 4172 v1.AddArg(x) 4173 v1.AddArg(y) 4174 v0.AddArg(v1) 4175 v.AddArg(v0) 4176 return true 4177 } 4178 // match: (CMPshiftLLreg x y (MOVWconst [c])) 4179 // cond: 4180 // result: (CMPshiftLL x y [c]) 4181 for { 4182 x := v.Args[0] 4183 y := v.Args[1] 4184 v_2 := v.Args[2] 4185 if v_2.Op != OpARMMOVWconst { 4186 break 4187 } 4188 c := v_2.AuxInt 4189 v.reset(OpARMCMPshiftLL) 4190 v.AuxInt = c 4191 v.AddArg(x) 4192 v.AddArg(y) 4193 return true 4194 } 4195 return false 4196 } 4197 func rewriteValueARM_OpARMCMPshiftRA(v *Value, config *Config) bool { 4198 b := v.Block 4199 _ = b 4200 // match: (CMPshiftRA (MOVWconst [c]) x [d]) 4201 // cond: 4202 // result: (InvertFlags (CMPconst [c] (SRAconst <x.Type> x [d]))) 4203 for { 4204 d := v.AuxInt 4205 v_0 := v.Args[0] 4206 if v_0.Op != OpARMMOVWconst { 4207 break 4208 } 4209 c := v_0.AuxInt 4210 x := v.Args[1] 4211 v.reset(OpARMInvertFlags) 4212 v0 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 4213 v0.AuxInt = c 4214 v1 := b.NewValue0(v.Line, OpARMSRAconst, x.Type) 4215 v1.AuxInt = d 4216 v1.AddArg(x) 4217 v0.AddArg(v1) 4218 v.AddArg(v0) 4219 return true 4220 } 4221 // match: (CMPshiftRA x (MOVWconst [c]) [d]) 4222 // cond: 4223 // result: (CMPconst x [int64(int32(c)>>uint64(d))]) 4224 for { 4225 d := v.AuxInt 4226 x := v.Args[0] 4227 v_1 := v.Args[1] 4228 if v_1.Op != OpARMMOVWconst { 4229 break 4230 } 4231 c := v_1.AuxInt 4232 v.reset(OpARMCMPconst) 4233 v.AuxInt = int64(int32(c) >> uint64(d)) 4234 v.AddArg(x) 4235 return true 4236 } 4237 return false 4238 } 4239 func rewriteValueARM_OpARMCMPshiftRAreg(v *Value, config *Config) bool { 4240 b := v.Block 4241 _ = b 4242 // match: (CMPshiftRAreg (MOVWconst [c]) x y) 4243 // cond: 4244 // result: (InvertFlags (CMPconst [c] (SRA <x.Type> x y))) 4245 for { 4246 v_0 := v.Args[0] 4247 if v_0.Op != OpARMMOVWconst { 4248 break 4249 } 4250 c := v_0.AuxInt 4251 x := v.Args[1] 4252 y := v.Args[2] 4253 v.reset(OpARMInvertFlags) 4254 v0 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 4255 v0.AuxInt = c 4256 v1 := b.NewValue0(v.Line, OpARMSRA, x.Type) 4257 v1.AddArg(x) 4258 v1.AddArg(y) 4259 v0.AddArg(v1) 4260 v.AddArg(v0) 4261 return true 4262 } 4263 // match: (CMPshiftRAreg x y (MOVWconst [c])) 4264 // cond: 4265 // result: (CMPshiftRA x y [c]) 4266 for { 4267 x := v.Args[0] 4268 y := v.Args[1] 4269 v_2 := v.Args[2] 4270 if v_2.Op != OpARMMOVWconst { 4271 break 4272 } 4273 c := v_2.AuxInt 4274 v.reset(OpARMCMPshiftRA) 4275 v.AuxInt = c 4276 v.AddArg(x) 4277 v.AddArg(y) 4278 return true 4279 } 4280 return false 4281 } 4282 func rewriteValueARM_OpARMCMPshiftRL(v *Value, config *Config) bool { 4283 b := v.Block 4284 _ = b 4285 // match: (CMPshiftRL (MOVWconst [c]) x [d]) 4286 // cond: 4287 // result: (InvertFlags (CMPconst [c] (SRLconst <x.Type> x [d]))) 4288 for { 4289 d := v.AuxInt 4290 v_0 := v.Args[0] 4291 if v_0.Op != OpARMMOVWconst { 4292 break 4293 } 4294 c := v_0.AuxInt 4295 x := v.Args[1] 4296 v.reset(OpARMInvertFlags) 4297 v0 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 4298 v0.AuxInt = c 4299 v1 := b.NewValue0(v.Line, OpARMSRLconst, x.Type) 4300 v1.AuxInt = d 4301 v1.AddArg(x) 4302 v0.AddArg(v1) 4303 v.AddArg(v0) 4304 return true 4305 } 4306 // match: (CMPshiftRL x (MOVWconst [c]) [d]) 4307 // cond: 4308 // result: (CMPconst x [int64(uint32(c)>>uint64(d))]) 4309 for { 4310 d := v.AuxInt 4311 x := v.Args[0] 4312 v_1 := v.Args[1] 4313 if v_1.Op != OpARMMOVWconst { 4314 break 4315 } 4316 c := v_1.AuxInt 4317 v.reset(OpARMCMPconst) 4318 v.AuxInt = int64(uint32(c) >> uint64(d)) 4319 v.AddArg(x) 4320 return true 4321 } 4322 return false 4323 } 4324 func rewriteValueARM_OpARMCMPshiftRLreg(v *Value, config *Config) bool { 4325 b := v.Block 4326 _ = b 4327 // match: (CMPshiftRLreg (MOVWconst [c]) x y) 4328 // cond: 4329 // result: (InvertFlags (CMPconst [c] (SRL <x.Type> x y))) 4330 for { 4331 v_0 := v.Args[0] 4332 if v_0.Op != OpARMMOVWconst { 4333 break 4334 } 4335 c := v_0.AuxInt 4336 x := v.Args[1] 4337 y := v.Args[2] 4338 v.reset(OpARMInvertFlags) 4339 v0 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 4340 v0.AuxInt = c 4341 v1 := b.NewValue0(v.Line, OpARMSRL, x.Type) 4342 v1.AddArg(x) 4343 v1.AddArg(y) 4344 v0.AddArg(v1) 4345 v.AddArg(v0) 4346 return true 4347 } 4348 // match: (CMPshiftRLreg x y (MOVWconst [c])) 4349 // cond: 4350 // result: (CMPshiftRL x y [c]) 4351 for { 4352 x := v.Args[0] 4353 y := v.Args[1] 4354 v_2 := v.Args[2] 4355 if v_2.Op != OpARMMOVWconst { 4356 break 4357 } 4358 c := v_2.AuxInt 4359 v.reset(OpARMCMPshiftRL) 4360 v.AuxInt = c 4361 v.AddArg(x) 4362 v.AddArg(y) 4363 return true 4364 } 4365 return false 4366 } 4367 func rewriteValueARM_OpARMDIV(v *Value, config *Config) bool { 4368 b := v.Block 4369 _ = b 4370 // match: (DIV (MOVWconst [c]) (MOVWconst [d])) 4371 // cond: 4372 // result: (MOVWconst [int64(int32(c)/int32(d))]) 4373 for { 4374 v_0 := v.Args[0] 4375 if v_0.Op != OpARMMOVWconst { 4376 break 4377 } 4378 c := v_0.AuxInt 4379 v_1 := v.Args[1] 4380 if v_1.Op != OpARMMOVWconst { 4381 break 4382 } 4383 d := v_1.AuxInt 4384 v.reset(OpARMMOVWconst) 4385 v.AuxInt = int64(int32(c) / int32(d)) 4386 return true 4387 } 4388 return false 4389 } 4390 func rewriteValueARM_OpARMDIVU(v *Value, config *Config) bool { 4391 b := v.Block 4392 _ = b 4393 // match: (DIVU x (MOVWconst [1])) 4394 // cond: 4395 // result: x 4396 for { 4397 x := v.Args[0] 4398 v_1 := v.Args[1] 4399 if v_1.Op != OpARMMOVWconst { 4400 break 4401 } 4402 if v_1.AuxInt != 1 { 4403 break 4404 } 4405 v.reset(OpCopy) 4406 v.Type = x.Type 4407 v.AddArg(x) 4408 return true 4409 } 4410 // match: (DIVU x (MOVWconst [c])) 4411 // cond: isPowerOfTwo(c) 4412 // result: (SRLconst [log2(c)] x) 4413 for { 4414 x := v.Args[0] 4415 v_1 := v.Args[1] 4416 if v_1.Op != OpARMMOVWconst { 4417 break 4418 } 4419 c := v_1.AuxInt 4420 if !(isPowerOfTwo(c)) { 4421 break 4422 } 4423 v.reset(OpARMSRLconst) 4424 v.AuxInt = log2(c) 4425 v.AddArg(x) 4426 return true 4427 } 4428 // match: (DIVU (MOVWconst [c]) (MOVWconst [d])) 4429 // cond: 4430 // result: (MOVWconst [int64(uint32(c)/uint32(d))]) 4431 for { 4432 v_0 := v.Args[0] 4433 if v_0.Op != OpARMMOVWconst { 4434 break 4435 } 4436 c := v_0.AuxInt 4437 v_1 := v.Args[1] 4438 if v_1.Op != OpARMMOVWconst { 4439 break 4440 } 4441 d := v_1.AuxInt 4442 v.reset(OpARMMOVWconst) 4443 v.AuxInt = int64(uint32(c) / uint32(d)) 4444 return true 4445 } 4446 return false 4447 } 4448 func rewriteValueARM_OpARMEqual(v *Value, config *Config) bool { 4449 b := v.Block 4450 _ = b 4451 // match: (Equal (FlagEQ)) 4452 // cond: 4453 // result: (MOVWconst [1]) 4454 for { 4455 v_0 := v.Args[0] 4456 if v_0.Op != OpARMFlagEQ { 4457 break 4458 } 4459 v.reset(OpARMMOVWconst) 4460 v.AuxInt = 1 4461 return true 4462 } 4463 // match: (Equal (FlagLT_ULT)) 4464 // cond: 4465 // result: (MOVWconst [0]) 4466 for { 4467 v_0 := v.Args[0] 4468 if v_0.Op != OpARMFlagLT_ULT { 4469 break 4470 } 4471 v.reset(OpARMMOVWconst) 4472 v.AuxInt = 0 4473 return true 4474 } 4475 // match: (Equal (FlagLT_UGT)) 4476 // cond: 4477 // result: (MOVWconst [0]) 4478 for { 4479 v_0 := v.Args[0] 4480 if v_0.Op != OpARMFlagLT_UGT { 4481 break 4482 } 4483 v.reset(OpARMMOVWconst) 4484 v.AuxInt = 0 4485 return true 4486 } 4487 // match: (Equal (FlagGT_ULT)) 4488 // cond: 4489 // result: (MOVWconst [0]) 4490 for { 4491 v_0 := v.Args[0] 4492 if v_0.Op != OpARMFlagGT_ULT { 4493 break 4494 } 4495 v.reset(OpARMMOVWconst) 4496 v.AuxInt = 0 4497 return true 4498 } 4499 // match: (Equal (FlagGT_UGT)) 4500 // cond: 4501 // result: (MOVWconst [0]) 4502 for { 4503 v_0 := v.Args[0] 4504 if v_0.Op != OpARMFlagGT_UGT { 4505 break 4506 } 4507 v.reset(OpARMMOVWconst) 4508 v.AuxInt = 0 4509 return true 4510 } 4511 // match: (Equal (InvertFlags x)) 4512 // cond: 4513 // result: (Equal x) 4514 for { 4515 v_0 := v.Args[0] 4516 if v_0.Op != OpARMInvertFlags { 4517 break 4518 } 4519 x := v_0.Args[0] 4520 v.reset(OpARMEqual) 4521 v.AddArg(x) 4522 return true 4523 } 4524 return false 4525 } 4526 func rewriteValueARM_OpARMGreaterEqual(v *Value, config *Config) bool { 4527 b := v.Block 4528 _ = b 4529 // match: (GreaterEqual (FlagEQ)) 4530 // cond: 4531 // result: (MOVWconst [1]) 4532 for { 4533 v_0 := v.Args[0] 4534 if v_0.Op != OpARMFlagEQ { 4535 break 4536 } 4537 v.reset(OpARMMOVWconst) 4538 v.AuxInt = 1 4539 return true 4540 } 4541 // match: (GreaterEqual (FlagLT_ULT)) 4542 // cond: 4543 // result: (MOVWconst [0]) 4544 for { 4545 v_0 := v.Args[0] 4546 if v_0.Op != OpARMFlagLT_ULT { 4547 break 4548 } 4549 v.reset(OpARMMOVWconst) 4550 v.AuxInt = 0 4551 return true 4552 } 4553 // match: (GreaterEqual (FlagLT_UGT)) 4554 // cond: 4555 // result: (MOVWconst [0]) 4556 for { 4557 v_0 := v.Args[0] 4558 if v_0.Op != OpARMFlagLT_UGT { 4559 break 4560 } 4561 v.reset(OpARMMOVWconst) 4562 v.AuxInt = 0 4563 return true 4564 } 4565 // match: (GreaterEqual (FlagGT_ULT)) 4566 // cond: 4567 // result: (MOVWconst [1]) 4568 for { 4569 v_0 := v.Args[0] 4570 if v_0.Op != OpARMFlagGT_ULT { 4571 break 4572 } 4573 v.reset(OpARMMOVWconst) 4574 v.AuxInt = 1 4575 return true 4576 } 4577 // match: (GreaterEqual (FlagGT_UGT)) 4578 // cond: 4579 // result: (MOVWconst [1]) 4580 for { 4581 v_0 := v.Args[0] 4582 if v_0.Op != OpARMFlagGT_UGT { 4583 break 4584 } 4585 v.reset(OpARMMOVWconst) 4586 v.AuxInt = 1 4587 return true 4588 } 4589 // match: (GreaterEqual (InvertFlags x)) 4590 // cond: 4591 // result: (LessEqual x) 4592 for { 4593 v_0 := v.Args[0] 4594 if v_0.Op != OpARMInvertFlags { 4595 break 4596 } 4597 x := v_0.Args[0] 4598 v.reset(OpARMLessEqual) 4599 v.AddArg(x) 4600 return true 4601 } 4602 return false 4603 } 4604 func rewriteValueARM_OpARMGreaterEqualU(v *Value, config *Config) bool { 4605 b := v.Block 4606 _ = b 4607 // match: (GreaterEqualU (FlagEQ)) 4608 // cond: 4609 // result: (MOVWconst [1]) 4610 for { 4611 v_0 := v.Args[0] 4612 if v_0.Op != OpARMFlagEQ { 4613 break 4614 } 4615 v.reset(OpARMMOVWconst) 4616 v.AuxInt = 1 4617 return true 4618 } 4619 // match: (GreaterEqualU (FlagLT_ULT)) 4620 // cond: 4621 // result: (MOVWconst [0]) 4622 for { 4623 v_0 := v.Args[0] 4624 if v_0.Op != OpARMFlagLT_ULT { 4625 break 4626 } 4627 v.reset(OpARMMOVWconst) 4628 v.AuxInt = 0 4629 return true 4630 } 4631 // match: (GreaterEqualU (FlagLT_UGT)) 4632 // cond: 4633 // result: (MOVWconst [1]) 4634 for { 4635 v_0 := v.Args[0] 4636 if v_0.Op != OpARMFlagLT_UGT { 4637 break 4638 } 4639 v.reset(OpARMMOVWconst) 4640 v.AuxInt = 1 4641 return true 4642 } 4643 // match: (GreaterEqualU (FlagGT_ULT)) 4644 // cond: 4645 // result: (MOVWconst [0]) 4646 for { 4647 v_0 := v.Args[0] 4648 if v_0.Op != OpARMFlagGT_ULT { 4649 break 4650 } 4651 v.reset(OpARMMOVWconst) 4652 v.AuxInt = 0 4653 return true 4654 } 4655 // match: (GreaterEqualU (FlagGT_UGT)) 4656 // cond: 4657 // result: (MOVWconst [1]) 4658 for { 4659 v_0 := v.Args[0] 4660 if v_0.Op != OpARMFlagGT_UGT { 4661 break 4662 } 4663 v.reset(OpARMMOVWconst) 4664 v.AuxInt = 1 4665 return true 4666 } 4667 // match: (GreaterEqualU (InvertFlags x)) 4668 // cond: 4669 // result: (LessEqualU x) 4670 for { 4671 v_0 := v.Args[0] 4672 if v_0.Op != OpARMInvertFlags { 4673 break 4674 } 4675 x := v_0.Args[0] 4676 v.reset(OpARMLessEqualU) 4677 v.AddArg(x) 4678 return true 4679 } 4680 return false 4681 } 4682 func rewriteValueARM_OpARMGreaterThan(v *Value, config *Config) bool { 4683 b := v.Block 4684 _ = b 4685 // match: (GreaterThan (FlagEQ)) 4686 // cond: 4687 // result: (MOVWconst [0]) 4688 for { 4689 v_0 := v.Args[0] 4690 if v_0.Op != OpARMFlagEQ { 4691 break 4692 } 4693 v.reset(OpARMMOVWconst) 4694 v.AuxInt = 0 4695 return true 4696 } 4697 // match: (GreaterThan (FlagLT_ULT)) 4698 // cond: 4699 // result: (MOVWconst [0]) 4700 for { 4701 v_0 := v.Args[0] 4702 if v_0.Op != OpARMFlagLT_ULT { 4703 break 4704 } 4705 v.reset(OpARMMOVWconst) 4706 v.AuxInt = 0 4707 return true 4708 } 4709 // match: (GreaterThan (FlagLT_UGT)) 4710 // cond: 4711 // result: (MOVWconst [0]) 4712 for { 4713 v_0 := v.Args[0] 4714 if v_0.Op != OpARMFlagLT_UGT { 4715 break 4716 } 4717 v.reset(OpARMMOVWconst) 4718 v.AuxInt = 0 4719 return true 4720 } 4721 // match: (GreaterThan (FlagGT_ULT)) 4722 // cond: 4723 // result: (MOVWconst [1]) 4724 for { 4725 v_0 := v.Args[0] 4726 if v_0.Op != OpARMFlagGT_ULT { 4727 break 4728 } 4729 v.reset(OpARMMOVWconst) 4730 v.AuxInt = 1 4731 return true 4732 } 4733 // match: (GreaterThan (FlagGT_UGT)) 4734 // cond: 4735 // result: (MOVWconst [1]) 4736 for { 4737 v_0 := v.Args[0] 4738 if v_0.Op != OpARMFlagGT_UGT { 4739 break 4740 } 4741 v.reset(OpARMMOVWconst) 4742 v.AuxInt = 1 4743 return true 4744 } 4745 // match: (GreaterThan (InvertFlags x)) 4746 // cond: 4747 // result: (LessThan x) 4748 for { 4749 v_0 := v.Args[0] 4750 if v_0.Op != OpARMInvertFlags { 4751 break 4752 } 4753 x := v_0.Args[0] 4754 v.reset(OpARMLessThan) 4755 v.AddArg(x) 4756 return true 4757 } 4758 return false 4759 } 4760 func rewriteValueARM_OpARMGreaterThanU(v *Value, config *Config) bool { 4761 b := v.Block 4762 _ = b 4763 // match: (GreaterThanU (FlagEQ)) 4764 // cond: 4765 // result: (MOVWconst [0]) 4766 for { 4767 v_0 := v.Args[0] 4768 if v_0.Op != OpARMFlagEQ { 4769 break 4770 } 4771 v.reset(OpARMMOVWconst) 4772 v.AuxInt = 0 4773 return true 4774 } 4775 // match: (GreaterThanU (FlagLT_ULT)) 4776 // cond: 4777 // result: (MOVWconst [0]) 4778 for { 4779 v_0 := v.Args[0] 4780 if v_0.Op != OpARMFlagLT_ULT { 4781 break 4782 } 4783 v.reset(OpARMMOVWconst) 4784 v.AuxInt = 0 4785 return true 4786 } 4787 // match: (GreaterThanU (FlagLT_UGT)) 4788 // cond: 4789 // result: (MOVWconst [1]) 4790 for { 4791 v_0 := v.Args[0] 4792 if v_0.Op != OpARMFlagLT_UGT { 4793 break 4794 } 4795 v.reset(OpARMMOVWconst) 4796 v.AuxInt = 1 4797 return true 4798 } 4799 // match: (GreaterThanU (FlagGT_ULT)) 4800 // cond: 4801 // result: (MOVWconst [0]) 4802 for { 4803 v_0 := v.Args[0] 4804 if v_0.Op != OpARMFlagGT_ULT { 4805 break 4806 } 4807 v.reset(OpARMMOVWconst) 4808 v.AuxInt = 0 4809 return true 4810 } 4811 // match: (GreaterThanU (FlagGT_UGT)) 4812 // cond: 4813 // result: (MOVWconst [1]) 4814 for { 4815 v_0 := v.Args[0] 4816 if v_0.Op != OpARMFlagGT_UGT { 4817 break 4818 } 4819 v.reset(OpARMMOVWconst) 4820 v.AuxInt = 1 4821 return true 4822 } 4823 // match: (GreaterThanU (InvertFlags x)) 4824 // cond: 4825 // result: (LessThanU x) 4826 for { 4827 v_0 := v.Args[0] 4828 if v_0.Op != OpARMInvertFlags { 4829 break 4830 } 4831 x := v_0.Args[0] 4832 v.reset(OpARMLessThanU) 4833 v.AddArg(x) 4834 return true 4835 } 4836 return false 4837 } 4838 func rewriteValueARM_OpARMLessEqual(v *Value, config *Config) bool { 4839 b := v.Block 4840 _ = b 4841 // match: (LessEqual (FlagEQ)) 4842 // cond: 4843 // result: (MOVWconst [1]) 4844 for { 4845 v_0 := v.Args[0] 4846 if v_0.Op != OpARMFlagEQ { 4847 break 4848 } 4849 v.reset(OpARMMOVWconst) 4850 v.AuxInt = 1 4851 return true 4852 } 4853 // match: (LessEqual (FlagLT_ULT)) 4854 // cond: 4855 // result: (MOVWconst [1]) 4856 for { 4857 v_0 := v.Args[0] 4858 if v_0.Op != OpARMFlagLT_ULT { 4859 break 4860 } 4861 v.reset(OpARMMOVWconst) 4862 v.AuxInt = 1 4863 return true 4864 } 4865 // match: (LessEqual (FlagLT_UGT)) 4866 // cond: 4867 // result: (MOVWconst [1]) 4868 for { 4869 v_0 := v.Args[0] 4870 if v_0.Op != OpARMFlagLT_UGT { 4871 break 4872 } 4873 v.reset(OpARMMOVWconst) 4874 v.AuxInt = 1 4875 return true 4876 } 4877 // match: (LessEqual (FlagGT_ULT)) 4878 // cond: 4879 // result: (MOVWconst [0]) 4880 for { 4881 v_0 := v.Args[0] 4882 if v_0.Op != OpARMFlagGT_ULT { 4883 break 4884 } 4885 v.reset(OpARMMOVWconst) 4886 v.AuxInt = 0 4887 return true 4888 } 4889 // match: (LessEqual (FlagGT_UGT)) 4890 // cond: 4891 // result: (MOVWconst [0]) 4892 for { 4893 v_0 := v.Args[0] 4894 if v_0.Op != OpARMFlagGT_UGT { 4895 break 4896 } 4897 v.reset(OpARMMOVWconst) 4898 v.AuxInt = 0 4899 return true 4900 } 4901 // match: (LessEqual (InvertFlags x)) 4902 // cond: 4903 // result: (GreaterEqual x) 4904 for { 4905 v_0 := v.Args[0] 4906 if v_0.Op != OpARMInvertFlags { 4907 break 4908 } 4909 x := v_0.Args[0] 4910 v.reset(OpARMGreaterEqual) 4911 v.AddArg(x) 4912 return true 4913 } 4914 return false 4915 } 4916 func rewriteValueARM_OpARMLessEqualU(v *Value, config *Config) bool { 4917 b := v.Block 4918 _ = b 4919 // match: (LessEqualU (FlagEQ)) 4920 // cond: 4921 // result: (MOVWconst [1]) 4922 for { 4923 v_0 := v.Args[0] 4924 if v_0.Op != OpARMFlagEQ { 4925 break 4926 } 4927 v.reset(OpARMMOVWconst) 4928 v.AuxInt = 1 4929 return true 4930 } 4931 // match: (LessEqualU (FlagLT_ULT)) 4932 // cond: 4933 // result: (MOVWconst [1]) 4934 for { 4935 v_0 := v.Args[0] 4936 if v_0.Op != OpARMFlagLT_ULT { 4937 break 4938 } 4939 v.reset(OpARMMOVWconst) 4940 v.AuxInt = 1 4941 return true 4942 } 4943 // match: (LessEqualU (FlagLT_UGT)) 4944 // cond: 4945 // result: (MOVWconst [0]) 4946 for { 4947 v_0 := v.Args[0] 4948 if v_0.Op != OpARMFlagLT_UGT { 4949 break 4950 } 4951 v.reset(OpARMMOVWconst) 4952 v.AuxInt = 0 4953 return true 4954 } 4955 // match: (LessEqualU (FlagGT_ULT)) 4956 // cond: 4957 // result: (MOVWconst [1]) 4958 for { 4959 v_0 := v.Args[0] 4960 if v_0.Op != OpARMFlagGT_ULT { 4961 break 4962 } 4963 v.reset(OpARMMOVWconst) 4964 v.AuxInt = 1 4965 return true 4966 } 4967 // match: (LessEqualU (FlagGT_UGT)) 4968 // cond: 4969 // result: (MOVWconst [0]) 4970 for { 4971 v_0 := v.Args[0] 4972 if v_0.Op != OpARMFlagGT_UGT { 4973 break 4974 } 4975 v.reset(OpARMMOVWconst) 4976 v.AuxInt = 0 4977 return true 4978 } 4979 // match: (LessEqualU (InvertFlags x)) 4980 // cond: 4981 // result: (GreaterEqualU x) 4982 for { 4983 v_0 := v.Args[0] 4984 if v_0.Op != OpARMInvertFlags { 4985 break 4986 } 4987 x := v_0.Args[0] 4988 v.reset(OpARMGreaterEqualU) 4989 v.AddArg(x) 4990 return true 4991 } 4992 return false 4993 } 4994 func rewriteValueARM_OpARMLessThan(v *Value, config *Config) bool { 4995 b := v.Block 4996 _ = b 4997 // match: (LessThan (FlagEQ)) 4998 // cond: 4999 // result: (MOVWconst [0]) 5000 for { 5001 v_0 := v.Args[0] 5002 if v_0.Op != OpARMFlagEQ { 5003 break 5004 } 5005 v.reset(OpARMMOVWconst) 5006 v.AuxInt = 0 5007 return true 5008 } 5009 // match: (LessThan (FlagLT_ULT)) 5010 // cond: 5011 // result: (MOVWconst [1]) 5012 for { 5013 v_0 := v.Args[0] 5014 if v_0.Op != OpARMFlagLT_ULT { 5015 break 5016 } 5017 v.reset(OpARMMOVWconst) 5018 v.AuxInt = 1 5019 return true 5020 } 5021 // match: (LessThan (FlagLT_UGT)) 5022 // cond: 5023 // result: (MOVWconst [1]) 5024 for { 5025 v_0 := v.Args[0] 5026 if v_0.Op != OpARMFlagLT_UGT { 5027 break 5028 } 5029 v.reset(OpARMMOVWconst) 5030 v.AuxInt = 1 5031 return true 5032 } 5033 // match: (LessThan (FlagGT_ULT)) 5034 // cond: 5035 // result: (MOVWconst [0]) 5036 for { 5037 v_0 := v.Args[0] 5038 if v_0.Op != OpARMFlagGT_ULT { 5039 break 5040 } 5041 v.reset(OpARMMOVWconst) 5042 v.AuxInt = 0 5043 return true 5044 } 5045 // match: (LessThan (FlagGT_UGT)) 5046 // cond: 5047 // result: (MOVWconst [0]) 5048 for { 5049 v_0 := v.Args[0] 5050 if v_0.Op != OpARMFlagGT_UGT { 5051 break 5052 } 5053 v.reset(OpARMMOVWconst) 5054 v.AuxInt = 0 5055 return true 5056 } 5057 // match: (LessThan (InvertFlags x)) 5058 // cond: 5059 // result: (GreaterThan x) 5060 for { 5061 v_0 := v.Args[0] 5062 if v_0.Op != OpARMInvertFlags { 5063 break 5064 } 5065 x := v_0.Args[0] 5066 v.reset(OpARMGreaterThan) 5067 v.AddArg(x) 5068 return true 5069 } 5070 return false 5071 } 5072 func rewriteValueARM_OpARMLessThanU(v *Value, config *Config) bool { 5073 b := v.Block 5074 _ = b 5075 // match: (LessThanU (FlagEQ)) 5076 // cond: 5077 // result: (MOVWconst [0]) 5078 for { 5079 v_0 := v.Args[0] 5080 if v_0.Op != OpARMFlagEQ { 5081 break 5082 } 5083 v.reset(OpARMMOVWconst) 5084 v.AuxInt = 0 5085 return true 5086 } 5087 // match: (LessThanU (FlagLT_ULT)) 5088 // cond: 5089 // result: (MOVWconst [1]) 5090 for { 5091 v_0 := v.Args[0] 5092 if v_0.Op != OpARMFlagLT_ULT { 5093 break 5094 } 5095 v.reset(OpARMMOVWconst) 5096 v.AuxInt = 1 5097 return true 5098 } 5099 // match: (LessThanU (FlagLT_UGT)) 5100 // cond: 5101 // result: (MOVWconst [0]) 5102 for { 5103 v_0 := v.Args[0] 5104 if v_0.Op != OpARMFlagLT_UGT { 5105 break 5106 } 5107 v.reset(OpARMMOVWconst) 5108 v.AuxInt = 0 5109 return true 5110 } 5111 // match: (LessThanU (FlagGT_ULT)) 5112 // cond: 5113 // result: (MOVWconst [1]) 5114 for { 5115 v_0 := v.Args[0] 5116 if v_0.Op != OpARMFlagGT_ULT { 5117 break 5118 } 5119 v.reset(OpARMMOVWconst) 5120 v.AuxInt = 1 5121 return true 5122 } 5123 // match: (LessThanU (FlagGT_UGT)) 5124 // cond: 5125 // result: (MOVWconst [0]) 5126 for { 5127 v_0 := v.Args[0] 5128 if v_0.Op != OpARMFlagGT_UGT { 5129 break 5130 } 5131 v.reset(OpARMMOVWconst) 5132 v.AuxInt = 0 5133 return true 5134 } 5135 // match: (LessThanU (InvertFlags x)) 5136 // cond: 5137 // result: (GreaterThanU x) 5138 for { 5139 v_0 := v.Args[0] 5140 if v_0.Op != OpARMInvertFlags { 5141 break 5142 } 5143 x := v_0.Args[0] 5144 v.reset(OpARMGreaterThanU) 5145 v.AddArg(x) 5146 return true 5147 } 5148 return false 5149 } 5150 func rewriteValueARM_OpARMMOVBUload(v *Value, config *Config) bool { 5151 b := v.Block 5152 _ = b 5153 // match: (MOVBUload [off1] {sym} (ADDconst [off2] ptr) mem) 5154 // cond: 5155 // result: (MOVBUload [off1+off2] {sym} ptr mem) 5156 for { 5157 off1 := v.AuxInt 5158 sym := v.Aux 5159 v_0 := v.Args[0] 5160 if v_0.Op != OpARMADDconst { 5161 break 5162 } 5163 off2 := v_0.AuxInt 5164 ptr := v_0.Args[0] 5165 mem := v.Args[1] 5166 v.reset(OpARMMOVBUload) 5167 v.AuxInt = off1 + off2 5168 v.Aux = sym 5169 v.AddArg(ptr) 5170 v.AddArg(mem) 5171 return true 5172 } 5173 // match: (MOVBUload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 5174 // cond: canMergeSym(sym1,sym2) 5175 // result: (MOVBUload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 5176 for { 5177 off1 := v.AuxInt 5178 sym1 := v.Aux 5179 v_0 := v.Args[0] 5180 if v_0.Op != OpARMMOVWaddr { 5181 break 5182 } 5183 off2 := v_0.AuxInt 5184 sym2 := v_0.Aux 5185 ptr := v_0.Args[0] 5186 mem := v.Args[1] 5187 if !(canMergeSym(sym1, sym2)) { 5188 break 5189 } 5190 v.reset(OpARMMOVBUload) 5191 v.AuxInt = off1 + off2 5192 v.Aux = mergeSym(sym1, sym2) 5193 v.AddArg(ptr) 5194 v.AddArg(mem) 5195 return true 5196 } 5197 // match: (MOVBUload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _)) 5198 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) && !isSigned(x.Type) 5199 // result: x 5200 for { 5201 off := v.AuxInt 5202 sym := v.Aux 5203 ptr := v.Args[0] 5204 v_1 := v.Args[1] 5205 if v_1.Op != OpARMMOVBstore { 5206 break 5207 } 5208 off2 := v_1.AuxInt 5209 sym2 := v_1.Aux 5210 ptr2 := v_1.Args[0] 5211 x := v_1.Args[1] 5212 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) && !isSigned(x.Type)) { 5213 break 5214 } 5215 v.reset(OpCopy) 5216 v.Type = x.Type 5217 v.AddArg(x) 5218 return true 5219 } 5220 return false 5221 } 5222 func rewriteValueARM_OpARMMOVBUreg(v *Value, config *Config) bool { 5223 b := v.Block 5224 _ = b 5225 // match: (MOVBUreg x:(MOVBUload _ _)) 5226 // cond: 5227 // result: (MOVWreg x) 5228 for { 5229 x := v.Args[0] 5230 if x.Op != OpARMMOVBUload { 5231 break 5232 } 5233 v.reset(OpARMMOVWreg) 5234 v.AddArg(x) 5235 return true 5236 } 5237 // match: (MOVBUreg (ANDconst [c] x)) 5238 // cond: 5239 // result: (ANDconst [c&0xff] x) 5240 for { 5241 v_0 := v.Args[0] 5242 if v_0.Op != OpARMANDconst { 5243 break 5244 } 5245 c := v_0.AuxInt 5246 x := v_0.Args[0] 5247 v.reset(OpARMANDconst) 5248 v.AuxInt = c & 0xff 5249 v.AddArg(x) 5250 return true 5251 } 5252 // match: (MOVBUreg x:(MOVBUreg _)) 5253 // cond: 5254 // result: (MOVWreg x) 5255 for { 5256 x := v.Args[0] 5257 if x.Op != OpARMMOVBUreg { 5258 break 5259 } 5260 v.reset(OpARMMOVWreg) 5261 v.AddArg(x) 5262 return true 5263 } 5264 // match: (MOVBUreg (MOVWconst [c])) 5265 // cond: 5266 // result: (MOVWconst [int64(uint8(c))]) 5267 for { 5268 v_0 := v.Args[0] 5269 if v_0.Op != OpARMMOVWconst { 5270 break 5271 } 5272 c := v_0.AuxInt 5273 v.reset(OpARMMOVWconst) 5274 v.AuxInt = int64(uint8(c)) 5275 return true 5276 } 5277 return false 5278 } 5279 func rewriteValueARM_OpARMMOVBload(v *Value, config *Config) bool { 5280 b := v.Block 5281 _ = b 5282 // match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem) 5283 // cond: 5284 // result: (MOVBload [off1+off2] {sym} ptr mem) 5285 for { 5286 off1 := v.AuxInt 5287 sym := v.Aux 5288 v_0 := v.Args[0] 5289 if v_0.Op != OpARMADDconst { 5290 break 5291 } 5292 off2 := v_0.AuxInt 5293 ptr := v_0.Args[0] 5294 mem := v.Args[1] 5295 v.reset(OpARMMOVBload) 5296 v.AuxInt = off1 + off2 5297 v.Aux = sym 5298 v.AddArg(ptr) 5299 v.AddArg(mem) 5300 return true 5301 } 5302 // match: (MOVBload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 5303 // cond: canMergeSym(sym1,sym2) 5304 // result: (MOVBload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 5305 for { 5306 off1 := v.AuxInt 5307 sym1 := v.Aux 5308 v_0 := v.Args[0] 5309 if v_0.Op != OpARMMOVWaddr { 5310 break 5311 } 5312 off2 := v_0.AuxInt 5313 sym2 := v_0.Aux 5314 ptr := v_0.Args[0] 5315 mem := v.Args[1] 5316 if !(canMergeSym(sym1, sym2)) { 5317 break 5318 } 5319 v.reset(OpARMMOVBload) 5320 v.AuxInt = off1 + off2 5321 v.Aux = mergeSym(sym1, sym2) 5322 v.AddArg(ptr) 5323 v.AddArg(mem) 5324 return true 5325 } 5326 // match: (MOVBload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _)) 5327 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) && isSigned(x.Type) 5328 // result: x 5329 for { 5330 off := v.AuxInt 5331 sym := v.Aux 5332 ptr := v.Args[0] 5333 v_1 := v.Args[1] 5334 if v_1.Op != OpARMMOVBstore { 5335 break 5336 } 5337 off2 := v_1.AuxInt 5338 sym2 := v_1.Aux 5339 ptr2 := v_1.Args[0] 5340 x := v_1.Args[1] 5341 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) && isSigned(x.Type)) { 5342 break 5343 } 5344 v.reset(OpCopy) 5345 v.Type = x.Type 5346 v.AddArg(x) 5347 return true 5348 } 5349 return false 5350 } 5351 func rewriteValueARM_OpARMMOVBreg(v *Value, config *Config) bool { 5352 b := v.Block 5353 _ = b 5354 // match: (MOVBreg x:(MOVBload _ _)) 5355 // cond: 5356 // result: (MOVWreg x) 5357 for { 5358 x := v.Args[0] 5359 if x.Op != OpARMMOVBload { 5360 break 5361 } 5362 v.reset(OpARMMOVWreg) 5363 v.AddArg(x) 5364 return true 5365 } 5366 // match: (MOVBreg (ANDconst [c] x)) 5367 // cond: c & 0x80 == 0 5368 // result: (ANDconst [c&0x7f] x) 5369 for { 5370 v_0 := v.Args[0] 5371 if v_0.Op != OpARMANDconst { 5372 break 5373 } 5374 c := v_0.AuxInt 5375 x := v_0.Args[0] 5376 if !(c&0x80 == 0) { 5377 break 5378 } 5379 v.reset(OpARMANDconst) 5380 v.AuxInt = c & 0x7f 5381 v.AddArg(x) 5382 return true 5383 } 5384 // match: (MOVBreg x:(MOVBreg _)) 5385 // cond: 5386 // result: (MOVWreg x) 5387 for { 5388 x := v.Args[0] 5389 if x.Op != OpARMMOVBreg { 5390 break 5391 } 5392 v.reset(OpARMMOVWreg) 5393 v.AddArg(x) 5394 return true 5395 } 5396 // match: (MOVBreg (MOVWconst [c])) 5397 // cond: 5398 // result: (MOVWconst [int64(int8(c))]) 5399 for { 5400 v_0 := v.Args[0] 5401 if v_0.Op != OpARMMOVWconst { 5402 break 5403 } 5404 c := v_0.AuxInt 5405 v.reset(OpARMMOVWconst) 5406 v.AuxInt = int64(int8(c)) 5407 return true 5408 } 5409 return false 5410 } 5411 func rewriteValueARM_OpARMMOVBstore(v *Value, config *Config) bool { 5412 b := v.Block 5413 _ = b 5414 // match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem) 5415 // cond: 5416 // result: (MOVBstore [off1+off2] {sym} ptr val mem) 5417 for { 5418 off1 := v.AuxInt 5419 sym := v.Aux 5420 v_0 := v.Args[0] 5421 if v_0.Op != OpARMADDconst { 5422 break 5423 } 5424 off2 := v_0.AuxInt 5425 ptr := v_0.Args[0] 5426 val := v.Args[1] 5427 mem := v.Args[2] 5428 v.reset(OpARMMOVBstore) 5429 v.AuxInt = off1 + off2 5430 v.Aux = sym 5431 v.AddArg(ptr) 5432 v.AddArg(val) 5433 v.AddArg(mem) 5434 return true 5435 } 5436 // match: (MOVBstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem) 5437 // cond: canMergeSym(sym1,sym2) 5438 // result: (MOVBstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem) 5439 for { 5440 off1 := v.AuxInt 5441 sym1 := v.Aux 5442 v_0 := v.Args[0] 5443 if v_0.Op != OpARMMOVWaddr { 5444 break 5445 } 5446 off2 := v_0.AuxInt 5447 sym2 := v_0.Aux 5448 ptr := v_0.Args[0] 5449 val := v.Args[1] 5450 mem := v.Args[2] 5451 if !(canMergeSym(sym1, sym2)) { 5452 break 5453 } 5454 v.reset(OpARMMOVBstore) 5455 v.AuxInt = off1 + off2 5456 v.Aux = mergeSym(sym1, sym2) 5457 v.AddArg(ptr) 5458 v.AddArg(val) 5459 v.AddArg(mem) 5460 return true 5461 } 5462 // match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem) 5463 // cond: 5464 // result: (MOVBstore [off] {sym} ptr x mem) 5465 for { 5466 off := v.AuxInt 5467 sym := v.Aux 5468 ptr := v.Args[0] 5469 v_1 := v.Args[1] 5470 if v_1.Op != OpARMMOVBreg { 5471 break 5472 } 5473 x := v_1.Args[0] 5474 mem := v.Args[2] 5475 v.reset(OpARMMOVBstore) 5476 v.AuxInt = off 5477 v.Aux = sym 5478 v.AddArg(ptr) 5479 v.AddArg(x) 5480 v.AddArg(mem) 5481 return true 5482 } 5483 // match: (MOVBstore [off] {sym} ptr (MOVBUreg x) mem) 5484 // cond: 5485 // result: (MOVBstore [off] {sym} ptr x mem) 5486 for { 5487 off := v.AuxInt 5488 sym := v.Aux 5489 ptr := v.Args[0] 5490 v_1 := v.Args[1] 5491 if v_1.Op != OpARMMOVBUreg { 5492 break 5493 } 5494 x := v_1.Args[0] 5495 mem := v.Args[2] 5496 v.reset(OpARMMOVBstore) 5497 v.AuxInt = off 5498 v.Aux = sym 5499 v.AddArg(ptr) 5500 v.AddArg(x) 5501 v.AddArg(mem) 5502 return true 5503 } 5504 // match: (MOVBstore [off] {sym} ptr (MOVHreg x) mem) 5505 // cond: 5506 // result: (MOVBstore [off] {sym} ptr x mem) 5507 for { 5508 off := v.AuxInt 5509 sym := v.Aux 5510 ptr := v.Args[0] 5511 v_1 := v.Args[1] 5512 if v_1.Op != OpARMMOVHreg { 5513 break 5514 } 5515 x := v_1.Args[0] 5516 mem := v.Args[2] 5517 v.reset(OpARMMOVBstore) 5518 v.AuxInt = off 5519 v.Aux = sym 5520 v.AddArg(ptr) 5521 v.AddArg(x) 5522 v.AddArg(mem) 5523 return true 5524 } 5525 // match: (MOVBstore [off] {sym} ptr (MOVHUreg x) mem) 5526 // cond: 5527 // result: (MOVBstore [off] {sym} ptr x mem) 5528 for { 5529 off := v.AuxInt 5530 sym := v.Aux 5531 ptr := v.Args[0] 5532 v_1 := v.Args[1] 5533 if v_1.Op != OpARMMOVHUreg { 5534 break 5535 } 5536 x := v_1.Args[0] 5537 mem := v.Args[2] 5538 v.reset(OpARMMOVBstore) 5539 v.AuxInt = off 5540 v.Aux = sym 5541 v.AddArg(ptr) 5542 v.AddArg(x) 5543 v.AddArg(mem) 5544 return true 5545 } 5546 return false 5547 } 5548 func rewriteValueARM_OpARMMOVDload(v *Value, config *Config) bool { 5549 b := v.Block 5550 _ = b 5551 // match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem) 5552 // cond: 5553 // result: (MOVDload [off1+off2] {sym} ptr mem) 5554 for { 5555 off1 := v.AuxInt 5556 sym := v.Aux 5557 v_0 := v.Args[0] 5558 if v_0.Op != OpARMADDconst { 5559 break 5560 } 5561 off2 := v_0.AuxInt 5562 ptr := v_0.Args[0] 5563 mem := v.Args[1] 5564 v.reset(OpARMMOVDload) 5565 v.AuxInt = off1 + off2 5566 v.Aux = sym 5567 v.AddArg(ptr) 5568 v.AddArg(mem) 5569 return true 5570 } 5571 // match: (MOVDload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 5572 // cond: canMergeSym(sym1,sym2) 5573 // result: (MOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 5574 for { 5575 off1 := v.AuxInt 5576 sym1 := v.Aux 5577 v_0 := v.Args[0] 5578 if v_0.Op != OpARMMOVWaddr { 5579 break 5580 } 5581 off2 := v_0.AuxInt 5582 sym2 := v_0.Aux 5583 ptr := v_0.Args[0] 5584 mem := v.Args[1] 5585 if !(canMergeSym(sym1, sym2)) { 5586 break 5587 } 5588 v.reset(OpARMMOVDload) 5589 v.AuxInt = off1 + off2 5590 v.Aux = mergeSym(sym1, sym2) 5591 v.AddArg(ptr) 5592 v.AddArg(mem) 5593 return true 5594 } 5595 // match: (MOVDload [off] {sym} ptr (MOVDstore [off2] {sym2} ptr2 x _)) 5596 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 5597 // result: x 5598 for { 5599 off := v.AuxInt 5600 sym := v.Aux 5601 ptr := v.Args[0] 5602 v_1 := v.Args[1] 5603 if v_1.Op != OpARMMOVDstore { 5604 break 5605 } 5606 off2 := v_1.AuxInt 5607 sym2 := v_1.Aux 5608 ptr2 := v_1.Args[0] 5609 x := v_1.Args[1] 5610 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 5611 break 5612 } 5613 v.reset(OpCopy) 5614 v.Type = x.Type 5615 v.AddArg(x) 5616 return true 5617 } 5618 return false 5619 } 5620 func rewriteValueARM_OpARMMOVDstore(v *Value, config *Config) bool { 5621 b := v.Block 5622 _ = b 5623 // match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem) 5624 // cond: 5625 // result: (MOVDstore [off1+off2] {sym} ptr val mem) 5626 for { 5627 off1 := v.AuxInt 5628 sym := v.Aux 5629 v_0 := v.Args[0] 5630 if v_0.Op != OpARMADDconst { 5631 break 5632 } 5633 off2 := v_0.AuxInt 5634 ptr := v_0.Args[0] 5635 val := v.Args[1] 5636 mem := v.Args[2] 5637 v.reset(OpARMMOVDstore) 5638 v.AuxInt = off1 + off2 5639 v.Aux = sym 5640 v.AddArg(ptr) 5641 v.AddArg(val) 5642 v.AddArg(mem) 5643 return true 5644 } 5645 // match: (MOVDstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem) 5646 // cond: canMergeSym(sym1,sym2) 5647 // result: (MOVDstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem) 5648 for { 5649 off1 := v.AuxInt 5650 sym1 := v.Aux 5651 v_0 := v.Args[0] 5652 if v_0.Op != OpARMMOVWaddr { 5653 break 5654 } 5655 off2 := v_0.AuxInt 5656 sym2 := v_0.Aux 5657 ptr := v_0.Args[0] 5658 val := v.Args[1] 5659 mem := v.Args[2] 5660 if !(canMergeSym(sym1, sym2)) { 5661 break 5662 } 5663 v.reset(OpARMMOVDstore) 5664 v.AuxInt = off1 + off2 5665 v.Aux = mergeSym(sym1, sym2) 5666 v.AddArg(ptr) 5667 v.AddArg(val) 5668 v.AddArg(mem) 5669 return true 5670 } 5671 return false 5672 } 5673 func rewriteValueARM_OpARMMOVFload(v *Value, config *Config) bool { 5674 b := v.Block 5675 _ = b 5676 // match: (MOVFload [off1] {sym} (ADDconst [off2] ptr) mem) 5677 // cond: 5678 // result: (MOVFload [off1+off2] {sym} ptr mem) 5679 for { 5680 off1 := v.AuxInt 5681 sym := v.Aux 5682 v_0 := v.Args[0] 5683 if v_0.Op != OpARMADDconst { 5684 break 5685 } 5686 off2 := v_0.AuxInt 5687 ptr := v_0.Args[0] 5688 mem := v.Args[1] 5689 v.reset(OpARMMOVFload) 5690 v.AuxInt = off1 + off2 5691 v.Aux = sym 5692 v.AddArg(ptr) 5693 v.AddArg(mem) 5694 return true 5695 } 5696 // match: (MOVFload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 5697 // cond: canMergeSym(sym1,sym2) 5698 // result: (MOVFload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 5699 for { 5700 off1 := v.AuxInt 5701 sym1 := v.Aux 5702 v_0 := v.Args[0] 5703 if v_0.Op != OpARMMOVWaddr { 5704 break 5705 } 5706 off2 := v_0.AuxInt 5707 sym2 := v_0.Aux 5708 ptr := v_0.Args[0] 5709 mem := v.Args[1] 5710 if !(canMergeSym(sym1, sym2)) { 5711 break 5712 } 5713 v.reset(OpARMMOVFload) 5714 v.AuxInt = off1 + off2 5715 v.Aux = mergeSym(sym1, sym2) 5716 v.AddArg(ptr) 5717 v.AddArg(mem) 5718 return true 5719 } 5720 // match: (MOVFload [off] {sym} ptr (MOVFstore [off2] {sym2} ptr2 x _)) 5721 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 5722 // result: x 5723 for { 5724 off := v.AuxInt 5725 sym := v.Aux 5726 ptr := v.Args[0] 5727 v_1 := v.Args[1] 5728 if v_1.Op != OpARMMOVFstore { 5729 break 5730 } 5731 off2 := v_1.AuxInt 5732 sym2 := v_1.Aux 5733 ptr2 := v_1.Args[0] 5734 x := v_1.Args[1] 5735 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 5736 break 5737 } 5738 v.reset(OpCopy) 5739 v.Type = x.Type 5740 v.AddArg(x) 5741 return true 5742 } 5743 return false 5744 } 5745 func rewriteValueARM_OpARMMOVFstore(v *Value, config *Config) bool { 5746 b := v.Block 5747 _ = b 5748 // match: (MOVFstore [off1] {sym} (ADDconst [off2] ptr) val mem) 5749 // cond: 5750 // result: (MOVFstore [off1+off2] {sym} ptr val mem) 5751 for { 5752 off1 := v.AuxInt 5753 sym := v.Aux 5754 v_0 := v.Args[0] 5755 if v_0.Op != OpARMADDconst { 5756 break 5757 } 5758 off2 := v_0.AuxInt 5759 ptr := v_0.Args[0] 5760 val := v.Args[1] 5761 mem := v.Args[2] 5762 v.reset(OpARMMOVFstore) 5763 v.AuxInt = off1 + off2 5764 v.Aux = sym 5765 v.AddArg(ptr) 5766 v.AddArg(val) 5767 v.AddArg(mem) 5768 return true 5769 } 5770 // match: (MOVFstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem) 5771 // cond: canMergeSym(sym1,sym2) 5772 // result: (MOVFstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem) 5773 for { 5774 off1 := v.AuxInt 5775 sym1 := v.Aux 5776 v_0 := v.Args[0] 5777 if v_0.Op != OpARMMOVWaddr { 5778 break 5779 } 5780 off2 := v_0.AuxInt 5781 sym2 := v_0.Aux 5782 ptr := v_0.Args[0] 5783 val := v.Args[1] 5784 mem := v.Args[2] 5785 if !(canMergeSym(sym1, sym2)) { 5786 break 5787 } 5788 v.reset(OpARMMOVFstore) 5789 v.AuxInt = off1 + off2 5790 v.Aux = mergeSym(sym1, sym2) 5791 v.AddArg(ptr) 5792 v.AddArg(val) 5793 v.AddArg(mem) 5794 return true 5795 } 5796 return false 5797 } 5798 func rewriteValueARM_OpARMMOVHUload(v *Value, config *Config) bool { 5799 b := v.Block 5800 _ = b 5801 // match: (MOVHUload [off1] {sym} (ADDconst [off2] ptr) mem) 5802 // cond: 5803 // result: (MOVHUload [off1+off2] {sym} ptr mem) 5804 for { 5805 off1 := v.AuxInt 5806 sym := v.Aux 5807 v_0 := v.Args[0] 5808 if v_0.Op != OpARMADDconst { 5809 break 5810 } 5811 off2 := v_0.AuxInt 5812 ptr := v_0.Args[0] 5813 mem := v.Args[1] 5814 v.reset(OpARMMOVHUload) 5815 v.AuxInt = off1 + off2 5816 v.Aux = sym 5817 v.AddArg(ptr) 5818 v.AddArg(mem) 5819 return true 5820 } 5821 // match: (MOVHUload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 5822 // cond: canMergeSym(sym1,sym2) 5823 // result: (MOVHUload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 5824 for { 5825 off1 := v.AuxInt 5826 sym1 := v.Aux 5827 v_0 := v.Args[0] 5828 if v_0.Op != OpARMMOVWaddr { 5829 break 5830 } 5831 off2 := v_0.AuxInt 5832 sym2 := v_0.Aux 5833 ptr := v_0.Args[0] 5834 mem := v.Args[1] 5835 if !(canMergeSym(sym1, sym2)) { 5836 break 5837 } 5838 v.reset(OpARMMOVHUload) 5839 v.AuxInt = off1 + off2 5840 v.Aux = mergeSym(sym1, sym2) 5841 v.AddArg(ptr) 5842 v.AddArg(mem) 5843 return true 5844 } 5845 // match: (MOVHUload [off] {sym} ptr (MOVHstore [off2] {sym2} ptr2 x _)) 5846 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) && !isSigned(x.Type) 5847 // result: x 5848 for { 5849 off := v.AuxInt 5850 sym := v.Aux 5851 ptr := v.Args[0] 5852 v_1 := v.Args[1] 5853 if v_1.Op != OpARMMOVHstore { 5854 break 5855 } 5856 off2 := v_1.AuxInt 5857 sym2 := v_1.Aux 5858 ptr2 := v_1.Args[0] 5859 x := v_1.Args[1] 5860 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) && !isSigned(x.Type)) { 5861 break 5862 } 5863 v.reset(OpCopy) 5864 v.Type = x.Type 5865 v.AddArg(x) 5866 return true 5867 } 5868 return false 5869 } 5870 func rewriteValueARM_OpARMMOVHUreg(v *Value, config *Config) bool { 5871 b := v.Block 5872 _ = b 5873 // match: (MOVHUreg x:(MOVBUload _ _)) 5874 // cond: 5875 // result: (MOVWreg x) 5876 for { 5877 x := v.Args[0] 5878 if x.Op != OpARMMOVBUload { 5879 break 5880 } 5881 v.reset(OpARMMOVWreg) 5882 v.AddArg(x) 5883 return true 5884 } 5885 // match: (MOVHUreg x:(MOVHUload _ _)) 5886 // cond: 5887 // result: (MOVWreg x) 5888 for { 5889 x := v.Args[0] 5890 if x.Op != OpARMMOVHUload { 5891 break 5892 } 5893 v.reset(OpARMMOVWreg) 5894 v.AddArg(x) 5895 return true 5896 } 5897 // match: (MOVHUreg (ANDconst [c] x)) 5898 // cond: 5899 // result: (ANDconst [c&0xffff] x) 5900 for { 5901 v_0 := v.Args[0] 5902 if v_0.Op != OpARMANDconst { 5903 break 5904 } 5905 c := v_0.AuxInt 5906 x := v_0.Args[0] 5907 v.reset(OpARMANDconst) 5908 v.AuxInt = c & 0xffff 5909 v.AddArg(x) 5910 return true 5911 } 5912 // match: (MOVHUreg x:(MOVBUreg _)) 5913 // cond: 5914 // result: (MOVWreg x) 5915 for { 5916 x := v.Args[0] 5917 if x.Op != OpARMMOVBUreg { 5918 break 5919 } 5920 v.reset(OpARMMOVWreg) 5921 v.AddArg(x) 5922 return true 5923 } 5924 // match: (MOVHUreg x:(MOVHUreg _)) 5925 // cond: 5926 // result: (MOVWreg x) 5927 for { 5928 x := v.Args[0] 5929 if x.Op != OpARMMOVHUreg { 5930 break 5931 } 5932 v.reset(OpARMMOVWreg) 5933 v.AddArg(x) 5934 return true 5935 } 5936 // match: (MOVHUreg (MOVWconst [c])) 5937 // cond: 5938 // result: (MOVWconst [int64(uint16(c))]) 5939 for { 5940 v_0 := v.Args[0] 5941 if v_0.Op != OpARMMOVWconst { 5942 break 5943 } 5944 c := v_0.AuxInt 5945 v.reset(OpARMMOVWconst) 5946 v.AuxInt = int64(uint16(c)) 5947 return true 5948 } 5949 return false 5950 } 5951 func rewriteValueARM_OpARMMOVHload(v *Value, config *Config) bool { 5952 b := v.Block 5953 _ = b 5954 // match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem) 5955 // cond: 5956 // result: (MOVHload [off1+off2] {sym} ptr mem) 5957 for { 5958 off1 := v.AuxInt 5959 sym := v.Aux 5960 v_0 := v.Args[0] 5961 if v_0.Op != OpARMADDconst { 5962 break 5963 } 5964 off2 := v_0.AuxInt 5965 ptr := v_0.Args[0] 5966 mem := v.Args[1] 5967 v.reset(OpARMMOVHload) 5968 v.AuxInt = off1 + off2 5969 v.Aux = sym 5970 v.AddArg(ptr) 5971 v.AddArg(mem) 5972 return true 5973 } 5974 // match: (MOVHload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 5975 // cond: canMergeSym(sym1,sym2) 5976 // result: (MOVHload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 5977 for { 5978 off1 := v.AuxInt 5979 sym1 := v.Aux 5980 v_0 := v.Args[0] 5981 if v_0.Op != OpARMMOVWaddr { 5982 break 5983 } 5984 off2 := v_0.AuxInt 5985 sym2 := v_0.Aux 5986 ptr := v_0.Args[0] 5987 mem := v.Args[1] 5988 if !(canMergeSym(sym1, sym2)) { 5989 break 5990 } 5991 v.reset(OpARMMOVHload) 5992 v.AuxInt = off1 + off2 5993 v.Aux = mergeSym(sym1, sym2) 5994 v.AddArg(ptr) 5995 v.AddArg(mem) 5996 return true 5997 } 5998 // match: (MOVHload [off] {sym} ptr (MOVHstore [off2] {sym2} ptr2 x _)) 5999 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) && isSigned(x.Type) 6000 // result: x 6001 for { 6002 off := v.AuxInt 6003 sym := v.Aux 6004 ptr := v.Args[0] 6005 v_1 := v.Args[1] 6006 if v_1.Op != OpARMMOVHstore { 6007 break 6008 } 6009 off2 := v_1.AuxInt 6010 sym2 := v_1.Aux 6011 ptr2 := v_1.Args[0] 6012 x := v_1.Args[1] 6013 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) && isSigned(x.Type)) { 6014 break 6015 } 6016 v.reset(OpCopy) 6017 v.Type = x.Type 6018 v.AddArg(x) 6019 return true 6020 } 6021 return false 6022 } 6023 func rewriteValueARM_OpARMMOVHreg(v *Value, config *Config) bool { 6024 b := v.Block 6025 _ = b 6026 // match: (MOVHreg x:(MOVBload _ _)) 6027 // cond: 6028 // result: (MOVWreg x) 6029 for { 6030 x := v.Args[0] 6031 if x.Op != OpARMMOVBload { 6032 break 6033 } 6034 v.reset(OpARMMOVWreg) 6035 v.AddArg(x) 6036 return true 6037 } 6038 // match: (MOVHreg x:(MOVBUload _ _)) 6039 // cond: 6040 // result: (MOVWreg x) 6041 for { 6042 x := v.Args[0] 6043 if x.Op != OpARMMOVBUload { 6044 break 6045 } 6046 v.reset(OpARMMOVWreg) 6047 v.AddArg(x) 6048 return true 6049 } 6050 // match: (MOVHreg x:(MOVHload _ _)) 6051 // cond: 6052 // result: (MOVWreg x) 6053 for { 6054 x := v.Args[0] 6055 if x.Op != OpARMMOVHload { 6056 break 6057 } 6058 v.reset(OpARMMOVWreg) 6059 v.AddArg(x) 6060 return true 6061 } 6062 // match: (MOVHreg (ANDconst [c] x)) 6063 // cond: c & 0x8000 == 0 6064 // result: (ANDconst [c&0x7fff] x) 6065 for { 6066 v_0 := v.Args[0] 6067 if v_0.Op != OpARMANDconst { 6068 break 6069 } 6070 c := v_0.AuxInt 6071 x := v_0.Args[0] 6072 if !(c&0x8000 == 0) { 6073 break 6074 } 6075 v.reset(OpARMANDconst) 6076 v.AuxInt = c & 0x7fff 6077 v.AddArg(x) 6078 return true 6079 } 6080 // match: (MOVHreg x:(MOVBreg _)) 6081 // cond: 6082 // result: (MOVWreg x) 6083 for { 6084 x := v.Args[0] 6085 if x.Op != OpARMMOVBreg { 6086 break 6087 } 6088 v.reset(OpARMMOVWreg) 6089 v.AddArg(x) 6090 return true 6091 } 6092 // match: (MOVHreg x:(MOVBUreg _)) 6093 // cond: 6094 // result: (MOVWreg x) 6095 for { 6096 x := v.Args[0] 6097 if x.Op != OpARMMOVBUreg { 6098 break 6099 } 6100 v.reset(OpARMMOVWreg) 6101 v.AddArg(x) 6102 return true 6103 } 6104 // match: (MOVHreg x:(MOVHreg _)) 6105 // cond: 6106 // result: (MOVWreg x) 6107 for { 6108 x := v.Args[0] 6109 if x.Op != OpARMMOVHreg { 6110 break 6111 } 6112 v.reset(OpARMMOVWreg) 6113 v.AddArg(x) 6114 return true 6115 } 6116 // match: (MOVHreg (MOVWconst [c])) 6117 // cond: 6118 // result: (MOVWconst [int64(int16(c))]) 6119 for { 6120 v_0 := v.Args[0] 6121 if v_0.Op != OpARMMOVWconst { 6122 break 6123 } 6124 c := v_0.AuxInt 6125 v.reset(OpARMMOVWconst) 6126 v.AuxInt = int64(int16(c)) 6127 return true 6128 } 6129 return false 6130 } 6131 func rewriteValueARM_OpARMMOVHstore(v *Value, config *Config) bool { 6132 b := v.Block 6133 _ = b 6134 // match: (MOVHstore [off1] {sym} (ADDconst [off2] ptr) val mem) 6135 // cond: 6136 // result: (MOVHstore [off1+off2] {sym} ptr val mem) 6137 for { 6138 off1 := v.AuxInt 6139 sym := v.Aux 6140 v_0 := v.Args[0] 6141 if v_0.Op != OpARMADDconst { 6142 break 6143 } 6144 off2 := v_0.AuxInt 6145 ptr := v_0.Args[0] 6146 val := v.Args[1] 6147 mem := v.Args[2] 6148 v.reset(OpARMMOVHstore) 6149 v.AuxInt = off1 + off2 6150 v.Aux = sym 6151 v.AddArg(ptr) 6152 v.AddArg(val) 6153 v.AddArg(mem) 6154 return true 6155 } 6156 // match: (MOVHstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem) 6157 // cond: canMergeSym(sym1,sym2) 6158 // result: (MOVHstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem) 6159 for { 6160 off1 := v.AuxInt 6161 sym1 := v.Aux 6162 v_0 := v.Args[0] 6163 if v_0.Op != OpARMMOVWaddr { 6164 break 6165 } 6166 off2 := v_0.AuxInt 6167 sym2 := v_0.Aux 6168 ptr := v_0.Args[0] 6169 val := v.Args[1] 6170 mem := v.Args[2] 6171 if !(canMergeSym(sym1, sym2)) { 6172 break 6173 } 6174 v.reset(OpARMMOVHstore) 6175 v.AuxInt = off1 + off2 6176 v.Aux = mergeSym(sym1, sym2) 6177 v.AddArg(ptr) 6178 v.AddArg(val) 6179 v.AddArg(mem) 6180 return true 6181 } 6182 // match: (MOVHstore [off] {sym} ptr (MOVHreg x) mem) 6183 // cond: 6184 // result: (MOVHstore [off] {sym} ptr x mem) 6185 for { 6186 off := v.AuxInt 6187 sym := v.Aux 6188 ptr := v.Args[0] 6189 v_1 := v.Args[1] 6190 if v_1.Op != OpARMMOVHreg { 6191 break 6192 } 6193 x := v_1.Args[0] 6194 mem := v.Args[2] 6195 v.reset(OpARMMOVHstore) 6196 v.AuxInt = off 6197 v.Aux = sym 6198 v.AddArg(ptr) 6199 v.AddArg(x) 6200 v.AddArg(mem) 6201 return true 6202 } 6203 // match: (MOVHstore [off] {sym} ptr (MOVHUreg x) mem) 6204 // cond: 6205 // result: (MOVHstore [off] {sym} ptr x mem) 6206 for { 6207 off := v.AuxInt 6208 sym := v.Aux 6209 ptr := v.Args[0] 6210 v_1 := v.Args[1] 6211 if v_1.Op != OpARMMOVHUreg { 6212 break 6213 } 6214 x := v_1.Args[0] 6215 mem := v.Args[2] 6216 v.reset(OpARMMOVHstore) 6217 v.AuxInt = off 6218 v.Aux = sym 6219 v.AddArg(ptr) 6220 v.AddArg(x) 6221 v.AddArg(mem) 6222 return true 6223 } 6224 return false 6225 } 6226 func rewriteValueARM_OpARMMOVWload(v *Value, config *Config) bool { 6227 b := v.Block 6228 _ = b 6229 // match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem) 6230 // cond: 6231 // result: (MOVWload [off1+off2] {sym} ptr mem) 6232 for { 6233 off1 := v.AuxInt 6234 sym := v.Aux 6235 v_0 := v.Args[0] 6236 if v_0.Op != OpARMADDconst { 6237 break 6238 } 6239 off2 := v_0.AuxInt 6240 ptr := v_0.Args[0] 6241 mem := v.Args[1] 6242 v.reset(OpARMMOVWload) 6243 v.AuxInt = off1 + off2 6244 v.Aux = sym 6245 v.AddArg(ptr) 6246 v.AddArg(mem) 6247 return true 6248 } 6249 // match: (MOVWload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 6250 // cond: canMergeSym(sym1,sym2) 6251 // result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 6252 for { 6253 off1 := v.AuxInt 6254 sym1 := v.Aux 6255 v_0 := v.Args[0] 6256 if v_0.Op != OpARMMOVWaddr { 6257 break 6258 } 6259 off2 := v_0.AuxInt 6260 sym2 := v_0.Aux 6261 ptr := v_0.Args[0] 6262 mem := v.Args[1] 6263 if !(canMergeSym(sym1, sym2)) { 6264 break 6265 } 6266 v.reset(OpARMMOVWload) 6267 v.AuxInt = off1 + off2 6268 v.Aux = mergeSym(sym1, sym2) 6269 v.AddArg(ptr) 6270 v.AddArg(mem) 6271 return true 6272 } 6273 // match: (MOVWload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _)) 6274 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 6275 // result: x 6276 for { 6277 off := v.AuxInt 6278 sym := v.Aux 6279 ptr := v.Args[0] 6280 v_1 := v.Args[1] 6281 if v_1.Op != OpARMMOVWstore { 6282 break 6283 } 6284 off2 := v_1.AuxInt 6285 sym2 := v_1.Aux 6286 ptr2 := v_1.Args[0] 6287 x := v_1.Args[1] 6288 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 6289 break 6290 } 6291 v.reset(OpCopy) 6292 v.Type = x.Type 6293 v.AddArg(x) 6294 return true 6295 } 6296 // match: (MOVWload [0] {sym} (ADD ptr idx) mem) 6297 // cond: sym == nil && !config.nacl 6298 // result: (MOVWloadidx ptr idx mem) 6299 for { 6300 if v.AuxInt != 0 { 6301 break 6302 } 6303 sym := v.Aux 6304 v_0 := v.Args[0] 6305 if v_0.Op != OpARMADD { 6306 break 6307 } 6308 ptr := v_0.Args[0] 6309 idx := v_0.Args[1] 6310 mem := v.Args[1] 6311 if !(sym == nil && !config.nacl) { 6312 break 6313 } 6314 v.reset(OpARMMOVWloadidx) 6315 v.AddArg(ptr) 6316 v.AddArg(idx) 6317 v.AddArg(mem) 6318 return true 6319 } 6320 // match: (MOVWload [0] {sym} (ADDshiftLL ptr idx [c]) mem) 6321 // cond: sym == nil && !config.nacl 6322 // result: (MOVWloadshiftLL ptr idx [c] mem) 6323 for { 6324 if v.AuxInt != 0 { 6325 break 6326 } 6327 sym := v.Aux 6328 v_0 := v.Args[0] 6329 if v_0.Op != OpARMADDshiftLL { 6330 break 6331 } 6332 c := v_0.AuxInt 6333 ptr := v_0.Args[0] 6334 idx := v_0.Args[1] 6335 mem := v.Args[1] 6336 if !(sym == nil && !config.nacl) { 6337 break 6338 } 6339 v.reset(OpARMMOVWloadshiftLL) 6340 v.AuxInt = c 6341 v.AddArg(ptr) 6342 v.AddArg(idx) 6343 v.AddArg(mem) 6344 return true 6345 } 6346 // match: (MOVWload [0] {sym} (ADDshiftRL ptr idx [c]) mem) 6347 // cond: sym == nil && !config.nacl 6348 // result: (MOVWloadshiftRL ptr idx [c] mem) 6349 for { 6350 if v.AuxInt != 0 { 6351 break 6352 } 6353 sym := v.Aux 6354 v_0 := v.Args[0] 6355 if v_0.Op != OpARMADDshiftRL { 6356 break 6357 } 6358 c := v_0.AuxInt 6359 ptr := v_0.Args[0] 6360 idx := v_0.Args[1] 6361 mem := v.Args[1] 6362 if !(sym == nil && !config.nacl) { 6363 break 6364 } 6365 v.reset(OpARMMOVWloadshiftRL) 6366 v.AuxInt = c 6367 v.AddArg(ptr) 6368 v.AddArg(idx) 6369 v.AddArg(mem) 6370 return true 6371 } 6372 // match: (MOVWload [0] {sym} (ADDshiftRA ptr idx [c]) mem) 6373 // cond: sym == nil && !config.nacl 6374 // result: (MOVWloadshiftRA ptr idx [c] mem) 6375 for { 6376 if v.AuxInt != 0 { 6377 break 6378 } 6379 sym := v.Aux 6380 v_0 := v.Args[0] 6381 if v_0.Op != OpARMADDshiftRA { 6382 break 6383 } 6384 c := v_0.AuxInt 6385 ptr := v_0.Args[0] 6386 idx := v_0.Args[1] 6387 mem := v.Args[1] 6388 if !(sym == nil && !config.nacl) { 6389 break 6390 } 6391 v.reset(OpARMMOVWloadshiftRA) 6392 v.AuxInt = c 6393 v.AddArg(ptr) 6394 v.AddArg(idx) 6395 v.AddArg(mem) 6396 return true 6397 } 6398 return false 6399 } 6400 func rewriteValueARM_OpARMMOVWloadidx(v *Value, config *Config) bool { 6401 b := v.Block 6402 _ = b 6403 // match: (MOVWloadidx ptr idx (MOVWstoreidx ptr2 idx x _)) 6404 // cond: isSamePtr(ptr, ptr2) 6405 // result: x 6406 for { 6407 ptr := v.Args[0] 6408 idx := v.Args[1] 6409 v_2 := v.Args[2] 6410 if v_2.Op != OpARMMOVWstoreidx { 6411 break 6412 } 6413 ptr2 := v_2.Args[0] 6414 if idx != v_2.Args[1] { 6415 break 6416 } 6417 x := v_2.Args[2] 6418 if !(isSamePtr(ptr, ptr2)) { 6419 break 6420 } 6421 v.reset(OpCopy) 6422 v.Type = x.Type 6423 v.AddArg(x) 6424 return true 6425 } 6426 // match: (MOVWloadidx ptr (MOVWconst [c]) mem) 6427 // cond: 6428 // result: (MOVWload [c] ptr mem) 6429 for { 6430 ptr := v.Args[0] 6431 v_1 := v.Args[1] 6432 if v_1.Op != OpARMMOVWconst { 6433 break 6434 } 6435 c := v_1.AuxInt 6436 mem := v.Args[2] 6437 v.reset(OpARMMOVWload) 6438 v.AuxInt = c 6439 v.AddArg(ptr) 6440 v.AddArg(mem) 6441 return true 6442 } 6443 // match: (MOVWloadidx (MOVWconst [c]) ptr mem) 6444 // cond: 6445 // result: (MOVWload [c] ptr mem) 6446 for { 6447 v_0 := v.Args[0] 6448 if v_0.Op != OpARMMOVWconst { 6449 break 6450 } 6451 c := v_0.AuxInt 6452 ptr := v.Args[1] 6453 mem := v.Args[2] 6454 v.reset(OpARMMOVWload) 6455 v.AuxInt = c 6456 v.AddArg(ptr) 6457 v.AddArg(mem) 6458 return true 6459 } 6460 // match: (MOVWloadidx ptr (SLLconst idx [c]) mem) 6461 // cond: 6462 // result: (MOVWloadshiftLL ptr idx [c] mem) 6463 for { 6464 ptr := v.Args[0] 6465 v_1 := v.Args[1] 6466 if v_1.Op != OpARMSLLconst { 6467 break 6468 } 6469 c := v_1.AuxInt 6470 idx := v_1.Args[0] 6471 mem := v.Args[2] 6472 v.reset(OpARMMOVWloadshiftLL) 6473 v.AuxInt = c 6474 v.AddArg(ptr) 6475 v.AddArg(idx) 6476 v.AddArg(mem) 6477 return true 6478 } 6479 // match: (MOVWloadidx (SLLconst idx [c]) ptr mem) 6480 // cond: 6481 // result: (MOVWloadshiftLL ptr idx [c] mem) 6482 for { 6483 v_0 := v.Args[0] 6484 if v_0.Op != OpARMSLLconst { 6485 break 6486 } 6487 c := v_0.AuxInt 6488 idx := v_0.Args[0] 6489 ptr := v.Args[1] 6490 mem := v.Args[2] 6491 v.reset(OpARMMOVWloadshiftLL) 6492 v.AuxInt = c 6493 v.AddArg(ptr) 6494 v.AddArg(idx) 6495 v.AddArg(mem) 6496 return true 6497 } 6498 // match: (MOVWloadidx ptr (SRLconst idx [c]) mem) 6499 // cond: 6500 // result: (MOVWloadshiftRL ptr idx [c] mem) 6501 for { 6502 ptr := v.Args[0] 6503 v_1 := v.Args[1] 6504 if v_1.Op != OpARMSRLconst { 6505 break 6506 } 6507 c := v_1.AuxInt 6508 idx := v_1.Args[0] 6509 mem := v.Args[2] 6510 v.reset(OpARMMOVWloadshiftRL) 6511 v.AuxInt = c 6512 v.AddArg(ptr) 6513 v.AddArg(idx) 6514 v.AddArg(mem) 6515 return true 6516 } 6517 // match: (MOVWloadidx (SRLconst idx [c]) ptr mem) 6518 // cond: 6519 // result: (MOVWloadshiftRL ptr idx [c] mem) 6520 for { 6521 v_0 := v.Args[0] 6522 if v_0.Op != OpARMSRLconst { 6523 break 6524 } 6525 c := v_0.AuxInt 6526 idx := v_0.Args[0] 6527 ptr := v.Args[1] 6528 mem := v.Args[2] 6529 v.reset(OpARMMOVWloadshiftRL) 6530 v.AuxInt = c 6531 v.AddArg(ptr) 6532 v.AddArg(idx) 6533 v.AddArg(mem) 6534 return true 6535 } 6536 // match: (MOVWloadidx ptr (SRAconst idx [c]) mem) 6537 // cond: 6538 // result: (MOVWloadshiftRA ptr idx [c] mem) 6539 for { 6540 ptr := v.Args[0] 6541 v_1 := v.Args[1] 6542 if v_1.Op != OpARMSRAconst { 6543 break 6544 } 6545 c := v_1.AuxInt 6546 idx := v_1.Args[0] 6547 mem := v.Args[2] 6548 v.reset(OpARMMOVWloadshiftRA) 6549 v.AuxInt = c 6550 v.AddArg(ptr) 6551 v.AddArg(idx) 6552 v.AddArg(mem) 6553 return true 6554 } 6555 // match: (MOVWloadidx (SRAconst idx [c]) ptr mem) 6556 // cond: 6557 // result: (MOVWloadshiftRA ptr idx [c] mem) 6558 for { 6559 v_0 := v.Args[0] 6560 if v_0.Op != OpARMSRAconst { 6561 break 6562 } 6563 c := v_0.AuxInt 6564 idx := v_0.Args[0] 6565 ptr := v.Args[1] 6566 mem := v.Args[2] 6567 v.reset(OpARMMOVWloadshiftRA) 6568 v.AuxInt = c 6569 v.AddArg(ptr) 6570 v.AddArg(idx) 6571 v.AddArg(mem) 6572 return true 6573 } 6574 return false 6575 } 6576 func rewriteValueARM_OpARMMOVWloadshiftLL(v *Value, config *Config) bool { 6577 b := v.Block 6578 _ = b 6579 // match: (MOVWloadshiftLL ptr idx [c] (MOVWstoreshiftLL ptr2 idx [d] x _)) 6580 // cond: c==d && isSamePtr(ptr, ptr2) 6581 // result: x 6582 for { 6583 c := v.AuxInt 6584 ptr := v.Args[0] 6585 idx := v.Args[1] 6586 v_2 := v.Args[2] 6587 if v_2.Op != OpARMMOVWstoreshiftLL { 6588 break 6589 } 6590 d := v_2.AuxInt 6591 ptr2 := v_2.Args[0] 6592 if idx != v_2.Args[1] { 6593 break 6594 } 6595 x := v_2.Args[2] 6596 if !(c == d && isSamePtr(ptr, ptr2)) { 6597 break 6598 } 6599 v.reset(OpCopy) 6600 v.Type = x.Type 6601 v.AddArg(x) 6602 return true 6603 } 6604 // match: (MOVWloadshiftLL ptr (MOVWconst [c]) [d] mem) 6605 // cond: 6606 // result: (MOVWload [int64(uint32(c)<<uint64(d))] ptr mem) 6607 for { 6608 d := v.AuxInt 6609 ptr := v.Args[0] 6610 v_1 := v.Args[1] 6611 if v_1.Op != OpARMMOVWconst { 6612 break 6613 } 6614 c := v_1.AuxInt 6615 mem := v.Args[2] 6616 v.reset(OpARMMOVWload) 6617 v.AuxInt = int64(uint32(c) << uint64(d)) 6618 v.AddArg(ptr) 6619 v.AddArg(mem) 6620 return true 6621 } 6622 return false 6623 } 6624 func rewriteValueARM_OpARMMOVWloadshiftRA(v *Value, config *Config) bool { 6625 b := v.Block 6626 _ = b 6627 // match: (MOVWloadshiftRA ptr idx [c] (MOVWstoreshiftRA ptr2 idx [d] x _)) 6628 // cond: c==d && isSamePtr(ptr, ptr2) 6629 // result: x 6630 for { 6631 c := v.AuxInt 6632 ptr := v.Args[0] 6633 idx := v.Args[1] 6634 v_2 := v.Args[2] 6635 if v_2.Op != OpARMMOVWstoreshiftRA { 6636 break 6637 } 6638 d := v_2.AuxInt 6639 ptr2 := v_2.Args[0] 6640 if idx != v_2.Args[1] { 6641 break 6642 } 6643 x := v_2.Args[2] 6644 if !(c == d && isSamePtr(ptr, ptr2)) { 6645 break 6646 } 6647 v.reset(OpCopy) 6648 v.Type = x.Type 6649 v.AddArg(x) 6650 return true 6651 } 6652 // match: (MOVWloadshiftRA ptr (MOVWconst [c]) [d] mem) 6653 // cond: 6654 // result: (MOVWload [int64(int32(c)>>uint64(d))] ptr mem) 6655 for { 6656 d := v.AuxInt 6657 ptr := v.Args[0] 6658 v_1 := v.Args[1] 6659 if v_1.Op != OpARMMOVWconst { 6660 break 6661 } 6662 c := v_1.AuxInt 6663 mem := v.Args[2] 6664 v.reset(OpARMMOVWload) 6665 v.AuxInt = int64(int32(c) >> uint64(d)) 6666 v.AddArg(ptr) 6667 v.AddArg(mem) 6668 return true 6669 } 6670 return false 6671 } 6672 func rewriteValueARM_OpARMMOVWloadshiftRL(v *Value, config *Config) bool { 6673 b := v.Block 6674 _ = b 6675 // match: (MOVWloadshiftRL ptr idx [c] (MOVWstoreshiftRL ptr2 idx [d] x _)) 6676 // cond: c==d && isSamePtr(ptr, ptr2) 6677 // result: x 6678 for { 6679 c := v.AuxInt 6680 ptr := v.Args[0] 6681 idx := v.Args[1] 6682 v_2 := v.Args[2] 6683 if v_2.Op != OpARMMOVWstoreshiftRL { 6684 break 6685 } 6686 d := v_2.AuxInt 6687 ptr2 := v_2.Args[0] 6688 if idx != v_2.Args[1] { 6689 break 6690 } 6691 x := v_2.Args[2] 6692 if !(c == d && isSamePtr(ptr, ptr2)) { 6693 break 6694 } 6695 v.reset(OpCopy) 6696 v.Type = x.Type 6697 v.AddArg(x) 6698 return true 6699 } 6700 // match: (MOVWloadshiftRL ptr (MOVWconst [c]) [d] mem) 6701 // cond: 6702 // result: (MOVWload [int64(uint32(c)>>uint64(d))] ptr mem) 6703 for { 6704 d := v.AuxInt 6705 ptr := v.Args[0] 6706 v_1 := v.Args[1] 6707 if v_1.Op != OpARMMOVWconst { 6708 break 6709 } 6710 c := v_1.AuxInt 6711 mem := v.Args[2] 6712 v.reset(OpARMMOVWload) 6713 v.AuxInt = int64(uint32(c) >> uint64(d)) 6714 v.AddArg(ptr) 6715 v.AddArg(mem) 6716 return true 6717 } 6718 return false 6719 } 6720 func rewriteValueARM_OpARMMOVWreg(v *Value, config *Config) bool { 6721 b := v.Block 6722 _ = b 6723 // match: (MOVWreg x) 6724 // cond: x.Uses == 1 6725 // result: (MOVWnop x) 6726 for { 6727 x := v.Args[0] 6728 if !(x.Uses == 1) { 6729 break 6730 } 6731 v.reset(OpARMMOVWnop) 6732 v.AddArg(x) 6733 return true 6734 } 6735 // match: (MOVWreg (MOVWconst [c])) 6736 // cond: 6737 // result: (MOVWconst [c]) 6738 for { 6739 v_0 := v.Args[0] 6740 if v_0.Op != OpARMMOVWconst { 6741 break 6742 } 6743 c := v_0.AuxInt 6744 v.reset(OpARMMOVWconst) 6745 v.AuxInt = c 6746 return true 6747 } 6748 return false 6749 } 6750 func rewriteValueARM_OpARMMOVWstore(v *Value, config *Config) bool { 6751 b := v.Block 6752 _ = b 6753 // match: (MOVWstore [off1] {sym} (ADDconst [off2] ptr) val mem) 6754 // cond: 6755 // result: (MOVWstore [off1+off2] {sym} ptr val mem) 6756 for { 6757 off1 := v.AuxInt 6758 sym := v.Aux 6759 v_0 := v.Args[0] 6760 if v_0.Op != OpARMADDconst { 6761 break 6762 } 6763 off2 := v_0.AuxInt 6764 ptr := v_0.Args[0] 6765 val := v.Args[1] 6766 mem := v.Args[2] 6767 v.reset(OpARMMOVWstore) 6768 v.AuxInt = off1 + off2 6769 v.Aux = sym 6770 v.AddArg(ptr) 6771 v.AddArg(val) 6772 v.AddArg(mem) 6773 return true 6774 } 6775 // match: (MOVWstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem) 6776 // cond: canMergeSym(sym1,sym2) 6777 // result: (MOVWstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem) 6778 for { 6779 off1 := v.AuxInt 6780 sym1 := v.Aux 6781 v_0 := v.Args[0] 6782 if v_0.Op != OpARMMOVWaddr { 6783 break 6784 } 6785 off2 := v_0.AuxInt 6786 sym2 := v_0.Aux 6787 ptr := v_0.Args[0] 6788 val := v.Args[1] 6789 mem := v.Args[2] 6790 if !(canMergeSym(sym1, sym2)) { 6791 break 6792 } 6793 v.reset(OpARMMOVWstore) 6794 v.AuxInt = off1 + off2 6795 v.Aux = mergeSym(sym1, sym2) 6796 v.AddArg(ptr) 6797 v.AddArg(val) 6798 v.AddArg(mem) 6799 return true 6800 } 6801 // match: (MOVWstore [0] {sym} (ADD ptr idx) val mem) 6802 // cond: sym == nil && !config.nacl 6803 // result: (MOVWstoreidx ptr idx val mem) 6804 for { 6805 if v.AuxInt != 0 { 6806 break 6807 } 6808 sym := v.Aux 6809 v_0 := v.Args[0] 6810 if v_0.Op != OpARMADD { 6811 break 6812 } 6813 ptr := v_0.Args[0] 6814 idx := v_0.Args[1] 6815 val := v.Args[1] 6816 mem := v.Args[2] 6817 if !(sym == nil && !config.nacl) { 6818 break 6819 } 6820 v.reset(OpARMMOVWstoreidx) 6821 v.AddArg(ptr) 6822 v.AddArg(idx) 6823 v.AddArg(val) 6824 v.AddArg(mem) 6825 return true 6826 } 6827 // match: (MOVWstore [0] {sym} (ADDshiftLL ptr idx [c]) val mem) 6828 // cond: sym == nil && !config.nacl 6829 // result: (MOVWstoreshiftLL ptr idx [c] val mem) 6830 for { 6831 if v.AuxInt != 0 { 6832 break 6833 } 6834 sym := v.Aux 6835 v_0 := v.Args[0] 6836 if v_0.Op != OpARMADDshiftLL { 6837 break 6838 } 6839 c := v_0.AuxInt 6840 ptr := v_0.Args[0] 6841 idx := v_0.Args[1] 6842 val := v.Args[1] 6843 mem := v.Args[2] 6844 if !(sym == nil && !config.nacl) { 6845 break 6846 } 6847 v.reset(OpARMMOVWstoreshiftLL) 6848 v.AuxInt = c 6849 v.AddArg(ptr) 6850 v.AddArg(idx) 6851 v.AddArg(val) 6852 v.AddArg(mem) 6853 return true 6854 } 6855 // match: (MOVWstore [0] {sym} (ADDshiftRL ptr idx [c]) val mem) 6856 // cond: sym == nil && !config.nacl 6857 // result: (MOVWstoreshiftRL ptr idx [c] val mem) 6858 for { 6859 if v.AuxInt != 0 { 6860 break 6861 } 6862 sym := v.Aux 6863 v_0 := v.Args[0] 6864 if v_0.Op != OpARMADDshiftRL { 6865 break 6866 } 6867 c := v_0.AuxInt 6868 ptr := v_0.Args[0] 6869 idx := v_0.Args[1] 6870 val := v.Args[1] 6871 mem := v.Args[2] 6872 if !(sym == nil && !config.nacl) { 6873 break 6874 } 6875 v.reset(OpARMMOVWstoreshiftRL) 6876 v.AuxInt = c 6877 v.AddArg(ptr) 6878 v.AddArg(idx) 6879 v.AddArg(val) 6880 v.AddArg(mem) 6881 return true 6882 } 6883 // match: (MOVWstore [0] {sym} (ADDshiftRA ptr idx [c]) val mem) 6884 // cond: sym == nil && !config.nacl 6885 // result: (MOVWstoreshiftRA ptr idx [c] val mem) 6886 for { 6887 if v.AuxInt != 0 { 6888 break 6889 } 6890 sym := v.Aux 6891 v_0 := v.Args[0] 6892 if v_0.Op != OpARMADDshiftRA { 6893 break 6894 } 6895 c := v_0.AuxInt 6896 ptr := v_0.Args[0] 6897 idx := v_0.Args[1] 6898 val := v.Args[1] 6899 mem := v.Args[2] 6900 if !(sym == nil && !config.nacl) { 6901 break 6902 } 6903 v.reset(OpARMMOVWstoreshiftRA) 6904 v.AuxInt = c 6905 v.AddArg(ptr) 6906 v.AddArg(idx) 6907 v.AddArg(val) 6908 v.AddArg(mem) 6909 return true 6910 } 6911 return false 6912 } 6913 func rewriteValueARM_OpARMMOVWstoreidx(v *Value, config *Config) bool { 6914 b := v.Block 6915 _ = b 6916 // match: (MOVWstoreidx ptr (MOVWconst [c]) val mem) 6917 // cond: 6918 // result: (MOVWstore [c] ptr val mem) 6919 for { 6920 ptr := v.Args[0] 6921 v_1 := v.Args[1] 6922 if v_1.Op != OpARMMOVWconst { 6923 break 6924 } 6925 c := v_1.AuxInt 6926 val := v.Args[2] 6927 mem := v.Args[3] 6928 v.reset(OpARMMOVWstore) 6929 v.AuxInt = c 6930 v.AddArg(ptr) 6931 v.AddArg(val) 6932 v.AddArg(mem) 6933 return true 6934 } 6935 // match: (MOVWstoreidx (MOVWconst [c]) ptr val mem) 6936 // cond: 6937 // result: (MOVWstore [c] ptr val mem) 6938 for { 6939 v_0 := v.Args[0] 6940 if v_0.Op != OpARMMOVWconst { 6941 break 6942 } 6943 c := v_0.AuxInt 6944 ptr := v.Args[1] 6945 val := v.Args[2] 6946 mem := v.Args[3] 6947 v.reset(OpARMMOVWstore) 6948 v.AuxInt = c 6949 v.AddArg(ptr) 6950 v.AddArg(val) 6951 v.AddArg(mem) 6952 return true 6953 } 6954 // match: (MOVWstoreidx ptr (SLLconst idx [c]) val mem) 6955 // cond: 6956 // result: (MOVWstoreshiftLL ptr idx [c] val mem) 6957 for { 6958 ptr := v.Args[0] 6959 v_1 := v.Args[1] 6960 if v_1.Op != OpARMSLLconst { 6961 break 6962 } 6963 c := v_1.AuxInt 6964 idx := v_1.Args[0] 6965 val := v.Args[2] 6966 mem := v.Args[3] 6967 v.reset(OpARMMOVWstoreshiftLL) 6968 v.AuxInt = c 6969 v.AddArg(ptr) 6970 v.AddArg(idx) 6971 v.AddArg(val) 6972 v.AddArg(mem) 6973 return true 6974 } 6975 // match: (MOVWstoreidx (SLLconst idx [c]) ptr val mem) 6976 // cond: 6977 // result: (MOVWstoreshiftLL ptr idx [c] val mem) 6978 for { 6979 v_0 := v.Args[0] 6980 if v_0.Op != OpARMSLLconst { 6981 break 6982 } 6983 c := v_0.AuxInt 6984 idx := v_0.Args[0] 6985 ptr := v.Args[1] 6986 val := v.Args[2] 6987 mem := v.Args[3] 6988 v.reset(OpARMMOVWstoreshiftLL) 6989 v.AuxInt = c 6990 v.AddArg(ptr) 6991 v.AddArg(idx) 6992 v.AddArg(val) 6993 v.AddArg(mem) 6994 return true 6995 } 6996 // match: (MOVWstoreidx ptr (SRLconst idx [c]) val mem) 6997 // cond: 6998 // result: (MOVWstoreshiftRL ptr idx [c] val mem) 6999 for { 7000 ptr := v.Args[0] 7001 v_1 := v.Args[1] 7002 if v_1.Op != OpARMSRLconst { 7003 break 7004 } 7005 c := v_1.AuxInt 7006 idx := v_1.Args[0] 7007 val := v.Args[2] 7008 mem := v.Args[3] 7009 v.reset(OpARMMOVWstoreshiftRL) 7010 v.AuxInt = c 7011 v.AddArg(ptr) 7012 v.AddArg(idx) 7013 v.AddArg(val) 7014 v.AddArg(mem) 7015 return true 7016 } 7017 // match: (MOVWstoreidx (SRLconst idx [c]) ptr val mem) 7018 // cond: 7019 // result: (MOVWstoreshiftRL ptr idx [c] val mem) 7020 for { 7021 v_0 := v.Args[0] 7022 if v_0.Op != OpARMSRLconst { 7023 break 7024 } 7025 c := v_0.AuxInt 7026 idx := v_0.Args[0] 7027 ptr := v.Args[1] 7028 val := v.Args[2] 7029 mem := v.Args[3] 7030 v.reset(OpARMMOVWstoreshiftRL) 7031 v.AuxInt = c 7032 v.AddArg(ptr) 7033 v.AddArg(idx) 7034 v.AddArg(val) 7035 v.AddArg(mem) 7036 return true 7037 } 7038 // match: (MOVWstoreidx ptr (SRAconst idx [c]) val mem) 7039 // cond: 7040 // result: (MOVWstoreshiftRA ptr idx [c] val mem) 7041 for { 7042 ptr := v.Args[0] 7043 v_1 := v.Args[1] 7044 if v_1.Op != OpARMSRAconst { 7045 break 7046 } 7047 c := v_1.AuxInt 7048 idx := v_1.Args[0] 7049 val := v.Args[2] 7050 mem := v.Args[3] 7051 v.reset(OpARMMOVWstoreshiftRA) 7052 v.AuxInt = c 7053 v.AddArg(ptr) 7054 v.AddArg(idx) 7055 v.AddArg(val) 7056 v.AddArg(mem) 7057 return true 7058 } 7059 // match: (MOVWstoreidx (SRAconst idx [c]) ptr val mem) 7060 // cond: 7061 // result: (MOVWstoreshiftRA ptr idx [c] val mem) 7062 for { 7063 v_0 := v.Args[0] 7064 if v_0.Op != OpARMSRAconst { 7065 break 7066 } 7067 c := v_0.AuxInt 7068 idx := v_0.Args[0] 7069 ptr := v.Args[1] 7070 val := v.Args[2] 7071 mem := v.Args[3] 7072 v.reset(OpARMMOVWstoreshiftRA) 7073 v.AuxInt = c 7074 v.AddArg(ptr) 7075 v.AddArg(idx) 7076 v.AddArg(val) 7077 v.AddArg(mem) 7078 return true 7079 } 7080 return false 7081 } 7082 func rewriteValueARM_OpARMMOVWstoreshiftLL(v *Value, config *Config) bool { 7083 b := v.Block 7084 _ = b 7085 // match: (MOVWstoreshiftLL ptr (MOVWconst [c]) [d] val mem) 7086 // cond: 7087 // result: (MOVWstore [int64(uint32(c)<<uint64(d))] ptr val mem) 7088 for { 7089 d := v.AuxInt 7090 ptr := v.Args[0] 7091 v_1 := v.Args[1] 7092 if v_1.Op != OpARMMOVWconst { 7093 break 7094 } 7095 c := v_1.AuxInt 7096 val := v.Args[2] 7097 mem := v.Args[3] 7098 v.reset(OpARMMOVWstore) 7099 v.AuxInt = int64(uint32(c) << uint64(d)) 7100 v.AddArg(ptr) 7101 v.AddArg(val) 7102 v.AddArg(mem) 7103 return true 7104 } 7105 return false 7106 } 7107 func rewriteValueARM_OpARMMOVWstoreshiftRA(v *Value, config *Config) bool { 7108 b := v.Block 7109 _ = b 7110 // match: (MOVWstoreshiftRA ptr (MOVWconst [c]) [d] val mem) 7111 // cond: 7112 // result: (MOVWstore [int64(int32(c)>>uint64(d))] ptr val mem) 7113 for { 7114 d := v.AuxInt 7115 ptr := v.Args[0] 7116 v_1 := v.Args[1] 7117 if v_1.Op != OpARMMOVWconst { 7118 break 7119 } 7120 c := v_1.AuxInt 7121 val := v.Args[2] 7122 mem := v.Args[3] 7123 v.reset(OpARMMOVWstore) 7124 v.AuxInt = int64(int32(c) >> uint64(d)) 7125 v.AddArg(ptr) 7126 v.AddArg(val) 7127 v.AddArg(mem) 7128 return true 7129 } 7130 return false 7131 } 7132 func rewriteValueARM_OpARMMOVWstoreshiftRL(v *Value, config *Config) bool { 7133 b := v.Block 7134 _ = b 7135 // match: (MOVWstoreshiftRL ptr (MOVWconst [c]) [d] val mem) 7136 // cond: 7137 // result: (MOVWstore [int64(uint32(c)>>uint64(d))] ptr val mem) 7138 for { 7139 d := v.AuxInt 7140 ptr := v.Args[0] 7141 v_1 := v.Args[1] 7142 if v_1.Op != OpARMMOVWconst { 7143 break 7144 } 7145 c := v_1.AuxInt 7146 val := v.Args[2] 7147 mem := v.Args[3] 7148 v.reset(OpARMMOVWstore) 7149 v.AuxInt = int64(uint32(c) >> uint64(d)) 7150 v.AddArg(ptr) 7151 v.AddArg(val) 7152 v.AddArg(mem) 7153 return true 7154 } 7155 return false 7156 } 7157 func rewriteValueARM_OpARMMUL(v *Value, config *Config) bool { 7158 b := v.Block 7159 _ = b 7160 // match: (MUL x (MOVWconst [c])) 7161 // cond: int32(c) == -1 7162 // result: (RSBconst [0] x) 7163 for { 7164 x := v.Args[0] 7165 v_1 := v.Args[1] 7166 if v_1.Op != OpARMMOVWconst { 7167 break 7168 } 7169 c := v_1.AuxInt 7170 if !(int32(c) == -1) { 7171 break 7172 } 7173 v.reset(OpARMRSBconst) 7174 v.AuxInt = 0 7175 v.AddArg(x) 7176 return true 7177 } 7178 // match: (MUL _ (MOVWconst [0])) 7179 // cond: 7180 // result: (MOVWconst [0]) 7181 for { 7182 v_1 := v.Args[1] 7183 if v_1.Op != OpARMMOVWconst { 7184 break 7185 } 7186 if v_1.AuxInt != 0 { 7187 break 7188 } 7189 v.reset(OpARMMOVWconst) 7190 v.AuxInt = 0 7191 return true 7192 } 7193 // match: (MUL x (MOVWconst [1])) 7194 // cond: 7195 // result: x 7196 for { 7197 x := v.Args[0] 7198 v_1 := v.Args[1] 7199 if v_1.Op != OpARMMOVWconst { 7200 break 7201 } 7202 if v_1.AuxInt != 1 { 7203 break 7204 } 7205 v.reset(OpCopy) 7206 v.Type = x.Type 7207 v.AddArg(x) 7208 return true 7209 } 7210 // match: (MUL x (MOVWconst [c])) 7211 // cond: isPowerOfTwo(c) 7212 // result: (SLLconst [log2(c)] x) 7213 for { 7214 x := v.Args[0] 7215 v_1 := v.Args[1] 7216 if v_1.Op != OpARMMOVWconst { 7217 break 7218 } 7219 c := v_1.AuxInt 7220 if !(isPowerOfTwo(c)) { 7221 break 7222 } 7223 v.reset(OpARMSLLconst) 7224 v.AuxInt = log2(c) 7225 v.AddArg(x) 7226 return true 7227 } 7228 // match: (MUL x (MOVWconst [c])) 7229 // cond: isPowerOfTwo(c-1) && int32(c) >= 3 7230 // result: (ADDshiftLL x x [log2(c-1)]) 7231 for { 7232 x := v.Args[0] 7233 v_1 := v.Args[1] 7234 if v_1.Op != OpARMMOVWconst { 7235 break 7236 } 7237 c := v_1.AuxInt 7238 if !(isPowerOfTwo(c-1) && int32(c) >= 3) { 7239 break 7240 } 7241 v.reset(OpARMADDshiftLL) 7242 v.AuxInt = log2(c - 1) 7243 v.AddArg(x) 7244 v.AddArg(x) 7245 return true 7246 } 7247 // match: (MUL x (MOVWconst [c])) 7248 // cond: isPowerOfTwo(c+1) && int32(c) >= 7 7249 // result: (RSBshiftLL x x [log2(c+1)]) 7250 for { 7251 x := v.Args[0] 7252 v_1 := v.Args[1] 7253 if v_1.Op != OpARMMOVWconst { 7254 break 7255 } 7256 c := v_1.AuxInt 7257 if !(isPowerOfTwo(c+1) && int32(c) >= 7) { 7258 break 7259 } 7260 v.reset(OpARMRSBshiftLL) 7261 v.AuxInt = log2(c + 1) 7262 v.AddArg(x) 7263 v.AddArg(x) 7264 return true 7265 } 7266 // match: (MUL x (MOVWconst [c])) 7267 // cond: c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c) 7268 // result: (SLLconst [log2(c/3)] (ADDshiftLL <x.Type> x x [1])) 7269 for { 7270 x := v.Args[0] 7271 v_1 := v.Args[1] 7272 if v_1.Op != OpARMMOVWconst { 7273 break 7274 } 7275 c := v_1.AuxInt 7276 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) { 7277 break 7278 } 7279 v.reset(OpARMSLLconst) 7280 v.AuxInt = log2(c / 3) 7281 v0 := b.NewValue0(v.Line, OpARMADDshiftLL, x.Type) 7282 v0.AuxInt = 1 7283 v0.AddArg(x) 7284 v0.AddArg(x) 7285 v.AddArg(v0) 7286 return true 7287 } 7288 // match: (MUL x (MOVWconst [c])) 7289 // cond: c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c) 7290 // result: (SLLconst [log2(c/5)] (ADDshiftLL <x.Type> x x [2])) 7291 for { 7292 x := v.Args[0] 7293 v_1 := v.Args[1] 7294 if v_1.Op != OpARMMOVWconst { 7295 break 7296 } 7297 c := v_1.AuxInt 7298 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) { 7299 break 7300 } 7301 v.reset(OpARMSLLconst) 7302 v.AuxInt = log2(c / 5) 7303 v0 := b.NewValue0(v.Line, OpARMADDshiftLL, x.Type) 7304 v0.AuxInt = 2 7305 v0.AddArg(x) 7306 v0.AddArg(x) 7307 v.AddArg(v0) 7308 return true 7309 } 7310 // match: (MUL x (MOVWconst [c])) 7311 // cond: c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c) 7312 // result: (SLLconst [log2(c/7)] (RSBshiftLL <x.Type> x x [3])) 7313 for { 7314 x := v.Args[0] 7315 v_1 := v.Args[1] 7316 if v_1.Op != OpARMMOVWconst { 7317 break 7318 } 7319 c := v_1.AuxInt 7320 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) { 7321 break 7322 } 7323 v.reset(OpARMSLLconst) 7324 v.AuxInt = log2(c / 7) 7325 v0 := b.NewValue0(v.Line, OpARMRSBshiftLL, x.Type) 7326 v0.AuxInt = 3 7327 v0.AddArg(x) 7328 v0.AddArg(x) 7329 v.AddArg(v0) 7330 return true 7331 } 7332 // match: (MUL x (MOVWconst [c])) 7333 // cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c) 7334 // result: (SLLconst [log2(c/9)] (ADDshiftLL <x.Type> x x [3])) 7335 for { 7336 x := v.Args[0] 7337 v_1 := v.Args[1] 7338 if v_1.Op != OpARMMOVWconst { 7339 break 7340 } 7341 c := v_1.AuxInt 7342 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) { 7343 break 7344 } 7345 v.reset(OpARMSLLconst) 7346 v.AuxInt = log2(c / 9) 7347 v0 := b.NewValue0(v.Line, OpARMADDshiftLL, x.Type) 7348 v0.AuxInt = 3 7349 v0.AddArg(x) 7350 v0.AddArg(x) 7351 v.AddArg(v0) 7352 return true 7353 } 7354 // match: (MUL (MOVWconst [c]) x) 7355 // cond: int32(c) == -1 7356 // result: (RSBconst [0] x) 7357 for { 7358 v_0 := v.Args[0] 7359 if v_0.Op != OpARMMOVWconst { 7360 break 7361 } 7362 c := v_0.AuxInt 7363 x := v.Args[1] 7364 if !(int32(c) == -1) { 7365 break 7366 } 7367 v.reset(OpARMRSBconst) 7368 v.AuxInt = 0 7369 v.AddArg(x) 7370 return true 7371 } 7372 // match: (MUL (MOVWconst [0]) _) 7373 // cond: 7374 // result: (MOVWconst [0]) 7375 for { 7376 v_0 := v.Args[0] 7377 if v_0.Op != OpARMMOVWconst { 7378 break 7379 } 7380 if v_0.AuxInt != 0 { 7381 break 7382 } 7383 v.reset(OpARMMOVWconst) 7384 v.AuxInt = 0 7385 return true 7386 } 7387 // match: (MUL (MOVWconst [1]) x) 7388 // cond: 7389 // result: x 7390 for { 7391 v_0 := v.Args[0] 7392 if v_0.Op != OpARMMOVWconst { 7393 break 7394 } 7395 if v_0.AuxInt != 1 { 7396 break 7397 } 7398 x := v.Args[1] 7399 v.reset(OpCopy) 7400 v.Type = x.Type 7401 v.AddArg(x) 7402 return true 7403 } 7404 // match: (MUL (MOVWconst [c]) x) 7405 // cond: isPowerOfTwo(c) 7406 // result: (SLLconst [log2(c)] x) 7407 for { 7408 v_0 := v.Args[0] 7409 if v_0.Op != OpARMMOVWconst { 7410 break 7411 } 7412 c := v_0.AuxInt 7413 x := v.Args[1] 7414 if !(isPowerOfTwo(c)) { 7415 break 7416 } 7417 v.reset(OpARMSLLconst) 7418 v.AuxInt = log2(c) 7419 v.AddArg(x) 7420 return true 7421 } 7422 // match: (MUL (MOVWconst [c]) x) 7423 // cond: isPowerOfTwo(c-1) && int32(c) >= 3 7424 // result: (ADDshiftLL x x [log2(c-1)]) 7425 for { 7426 v_0 := v.Args[0] 7427 if v_0.Op != OpARMMOVWconst { 7428 break 7429 } 7430 c := v_0.AuxInt 7431 x := v.Args[1] 7432 if !(isPowerOfTwo(c-1) && int32(c) >= 3) { 7433 break 7434 } 7435 v.reset(OpARMADDshiftLL) 7436 v.AuxInt = log2(c - 1) 7437 v.AddArg(x) 7438 v.AddArg(x) 7439 return true 7440 } 7441 // match: (MUL (MOVWconst [c]) x) 7442 // cond: isPowerOfTwo(c+1) && int32(c) >= 7 7443 // result: (RSBshiftLL x x [log2(c+1)]) 7444 for { 7445 v_0 := v.Args[0] 7446 if v_0.Op != OpARMMOVWconst { 7447 break 7448 } 7449 c := v_0.AuxInt 7450 x := v.Args[1] 7451 if !(isPowerOfTwo(c+1) && int32(c) >= 7) { 7452 break 7453 } 7454 v.reset(OpARMRSBshiftLL) 7455 v.AuxInt = log2(c + 1) 7456 v.AddArg(x) 7457 v.AddArg(x) 7458 return true 7459 } 7460 // match: (MUL (MOVWconst [c]) x) 7461 // cond: c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c) 7462 // result: (SLLconst [log2(c/3)] (ADDshiftLL <x.Type> x x [1])) 7463 for { 7464 v_0 := v.Args[0] 7465 if v_0.Op != OpARMMOVWconst { 7466 break 7467 } 7468 c := v_0.AuxInt 7469 x := v.Args[1] 7470 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) { 7471 break 7472 } 7473 v.reset(OpARMSLLconst) 7474 v.AuxInt = log2(c / 3) 7475 v0 := b.NewValue0(v.Line, OpARMADDshiftLL, x.Type) 7476 v0.AuxInt = 1 7477 v0.AddArg(x) 7478 v0.AddArg(x) 7479 v.AddArg(v0) 7480 return true 7481 } 7482 // match: (MUL (MOVWconst [c]) x) 7483 // cond: c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c) 7484 // result: (SLLconst [log2(c/5)] (ADDshiftLL <x.Type> x x [2])) 7485 for { 7486 v_0 := v.Args[0] 7487 if v_0.Op != OpARMMOVWconst { 7488 break 7489 } 7490 c := v_0.AuxInt 7491 x := v.Args[1] 7492 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) { 7493 break 7494 } 7495 v.reset(OpARMSLLconst) 7496 v.AuxInt = log2(c / 5) 7497 v0 := b.NewValue0(v.Line, OpARMADDshiftLL, x.Type) 7498 v0.AuxInt = 2 7499 v0.AddArg(x) 7500 v0.AddArg(x) 7501 v.AddArg(v0) 7502 return true 7503 } 7504 // match: (MUL (MOVWconst [c]) x) 7505 // cond: c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c) 7506 // result: (SLLconst [log2(c/7)] (RSBshiftLL <x.Type> x x [3])) 7507 for { 7508 v_0 := v.Args[0] 7509 if v_0.Op != OpARMMOVWconst { 7510 break 7511 } 7512 c := v_0.AuxInt 7513 x := v.Args[1] 7514 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) { 7515 break 7516 } 7517 v.reset(OpARMSLLconst) 7518 v.AuxInt = log2(c / 7) 7519 v0 := b.NewValue0(v.Line, OpARMRSBshiftLL, x.Type) 7520 v0.AuxInt = 3 7521 v0.AddArg(x) 7522 v0.AddArg(x) 7523 v.AddArg(v0) 7524 return true 7525 } 7526 // match: (MUL (MOVWconst [c]) x) 7527 // cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c) 7528 // result: (SLLconst [log2(c/9)] (ADDshiftLL <x.Type> x x [3])) 7529 for { 7530 v_0 := v.Args[0] 7531 if v_0.Op != OpARMMOVWconst { 7532 break 7533 } 7534 c := v_0.AuxInt 7535 x := v.Args[1] 7536 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) { 7537 break 7538 } 7539 v.reset(OpARMSLLconst) 7540 v.AuxInt = log2(c / 9) 7541 v0 := b.NewValue0(v.Line, OpARMADDshiftLL, x.Type) 7542 v0.AuxInt = 3 7543 v0.AddArg(x) 7544 v0.AddArg(x) 7545 v.AddArg(v0) 7546 return true 7547 } 7548 // match: (MUL (MOVWconst [c]) (MOVWconst [d])) 7549 // cond: 7550 // result: (MOVWconst [int64(int32(c*d))]) 7551 for { 7552 v_0 := v.Args[0] 7553 if v_0.Op != OpARMMOVWconst { 7554 break 7555 } 7556 c := v_0.AuxInt 7557 v_1 := v.Args[1] 7558 if v_1.Op != OpARMMOVWconst { 7559 break 7560 } 7561 d := v_1.AuxInt 7562 v.reset(OpARMMOVWconst) 7563 v.AuxInt = int64(int32(c * d)) 7564 return true 7565 } 7566 return false 7567 } 7568 func rewriteValueARM_OpARMMULA(v *Value, config *Config) bool { 7569 b := v.Block 7570 _ = b 7571 // match: (MULA x (MOVWconst [c]) a) 7572 // cond: int32(c) == -1 7573 // result: (SUB a x) 7574 for { 7575 x := v.Args[0] 7576 v_1 := v.Args[1] 7577 if v_1.Op != OpARMMOVWconst { 7578 break 7579 } 7580 c := v_1.AuxInt 7581 a := v.Args[2] 7582 if !(int32(c) == -1) { 7583 break 7584 } 7585 v.reset(OpARMSUB) 7586 v.AddArg(a) 7587 v.AddArg(x) 7588 return true 7589 } 7590 // match: (MULA _ (MOVWconst [0]) a) 7591 // cond: 7592 // result: a 7593 for { 7594 v_1 := v.Args[1] 7595 if v_1.Op != OpARMMOVWconst { 7596 break 7597 } 7598 if v_1.AuxInt != 0 { 7599 break 7600 } 7601 a := v.Args[2] 7602 v.reset(OpCopy) 7603 v.Type = a.Type 7604 v.AddArg(a) 7605 return true 7606 } 7607 // match: (MULA x (MOVWconst [1]) a) 7608 // cond: 7609 // result: (ADD x a) 7610 for { 7611 x := v.Args[0] 7612 v_1 := v.Args[1] 7613 if v_1.Op != OpARMMOVWconst { 7614 break 7615 } 7616 if v_1.AuxInt != 1 { 7617 break 7618 } 7619 a := v.Args[2] 7620 v.reset(OpARMADD) 7621 v.AddArg(x) 7622 v.AddArg(a) 7623 return true 7624 } 7625 // match: (MULA x (MOVWconst [c]) a) 7626 // cond: isPowerOfTwo(c) 7627 // result: (ADD (SLLconst <x.Type> [log2(c)] x) a) 7628 for { 7629 x := v.Args[0] 7630 v_1 := v.Args[1] 7631 if v_1.Op != OpARMMOVWconst { 7632 break 7633 } 7634 c := v_1.AuxInt 7635 a := v.Args[2] 7636 if !(isPowerOfTwo(c)) { 7637 break 7638 } 7639 v.reset(OpARMADD) 7640 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 7641 v0.AuxInt = log2(c) 7642 v0.AddArg(x) 7643 v.AddArg(v0) 7644 v.AddArg(a) 7645 return true 7646 } 7647 // match: (MULA x (MOVWconst [c]) a) 7648 // cond: isPowerOfTwo(c-1) && int32(c) >= 3 7649 // result: (ADD (ADDshiftLL <x.Type> x x [log2(c-1)]) a) 7650 for { 7651 x := v.Args[0] 7652 v_1 := v.Args[1] 7653 if v_1.Op != OpARMMOVWconst { 7654 break 7655 } 7656 c := v_1.AuxInt 7657 a := v.Args[2] 7658 if !(isPowerOfTwo(c-1) && int32(c) >= 3) { 7659 break 7660 } 7661 v.reset(OpARMADD) 7662 v0 := b.NewValue0(v.Line, OpARMADDshiftLL, x.Type) 7663 v0.AuxInt = log2(c - 1) 7664 v0.AddArg(x) 7665 v0.AddArg(x) 7666 v.AddArg(v0) 7667 v.AddArg(a) 7668 return true 7669 } 7670 // match: (MULA x (MOVWconst [c]) a) 7671 // cond: isPowerOfTwo(c+1) && int32(c) >= 7 7672 // result: (ADD (RSBshiftLL <x.Type> x x [log2(c+1)]) a) 7673 for { 7674 x := v.Args[0] 7675 v_1 := v.Args[1] 7676 if v_1.Op != OpARMMOVWconst { 7677 break 7678 } 7679 c := v_1.AuxInt 7680 a := v.Args[2] 7681 if !(isPowerOfTwo(c+1) && int32(c) >= 7) { 7682 break 7683 } 7684 v.reset(OpARMADD) 7685 v0 := b.NewValue0(v.Line, OpARMRSBshiftLL, x.Type) 7686 v0.AuxInt = log2(c + 1) 7687 v0.AddArg(x) 7688 v0.AddArg(x) 7689 v.AddArg(v0) 7690 v.AddArg(a) 7691 return true 7692 } 7693 // match: (MULA x (MOVWconst [c]) a) 7694 // cond: c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c) 7695 // result: (ADD (SLLconst <x.Type> [log2(c/3)] (ADDshiftLL <x.Type> x x [1])) a) 7696 for { 7697 x := v.Args[0] 7698 v_1 := v.Args[1] 7699 if v_1.Op != OpARMMOVWconst { 7700 break 7701 } 7702 c := v_1.AuxInt 7703 a := v.Args[2] 7704 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) { 7705 break 7706 } 7707 v.reset(OpARMADD) 7708 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 7709 v0.AuxInt = log2(c / 3) 7710 v1 := b.NewValue0(v.Line, OpARMADDshiftLL, x.Type) 7711 v1.AuxInt = 1 7712 v1.AddArg(x) 7713 v1.AddArg(x) 7714 v0.AddArg(v1) 7715 v.AddArg(v0) 7716 v.AddArg(a) 7717 return true 7718 } 7719 // match: (MULA x (MOVWconst [c]) a) 7720 // cond: c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c) 7721 // result: (ADD (SLLconst <x.Type> [log2(c/5)] (ADDshiftLL <x.Type> x x [2])) a) 7722 for { 7723 x := v.Args[0] 7724 v_1 := v.Args[1] 7725 if v_1.Op != OpARMMOVWconst { 7726 break 7727 } 7728 c := v_1.AuxInt 7729 a := v.Args[2] 7730 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) { 7731 break 7732 } 7733 v.reset(OpARMADD) 7734 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 7735 v0.AuxInt = log2(c / 5) 7736 v1 := b.NewValue0(v.Line, OpARMADDshiftLL, x.Type) 7737 v1.AuxInt = 2 7738 v1.AddArg(x) 7739 v1.AddArg(x) 7740 v0.AddArg(v1) 7741 v.AddArg(v0) 7742 v.AddArg(a) 7743 return true 7744 } 7745 // match: (MULA x (MOVWconst [c]) a) 7746 // cond: c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c) 7747 // result: (ADD (SLLconst <x.Type> [log2(c/7)] (RSBshiftLL <x.Type> x x [3])) a) 7748 for { 7749 x := v.Args[0] 7750 v_1 := v.Args[1] 7751 if v_1.Op != OpARMMOVWconst { 7752 break 7753 } 7754 c := v_1.AuxInt 7755 a := v.Args[2] 7756 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) { 7757 break 7758 } 7759 v.reset(OpARMADD) 7760 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 7761 v0.AuxInt = log2(c / 7) 7762 v1 := b.NewValue0(v.Line, OpARMRSBshiftLL, x.Type) 7763 v1.AuxInt = 3 7764 v1.AddArg(x) 7765 v1.AddArg(x) 7766 v0.AddArg(v1) 7767 v.AddArg(v0) 7768 v.AddArg(a) 7769 return true 7770 } 7771 // match: (MULA x (MOVWconst [c]) a) 7772 // cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c) 7773 // result: (ADD (SLLconst <x.Type> [log2(c/9)] (ADDshiftLL <x.Type> x x [3])) a) 7774 for { 7775 x := v.Args[0] 7776 v_1 := v.Args[1] 7777 if v_1.Op != OpARMMOVWconst { 7778 break 7779 } 7780 c := v_1.AuxInt 7781 a := v.Args[2] 7782 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) { 7783 break 7784 } 7785 v.reset(OpARMADD) 7786 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 7787 v0.AuxInt = log2(c / 9) 7788 v1 := b.NewValue0(v.Line, OpARMADDshiftLL, x.Type) 7789 v1.AuxInt = 3 7790 v1.AddArg(x) 7791 v1.AddArg(x) 7792 v0.AddArg(v1) 7793 v.AddArg(v0) 7794 v.AddArg(a) 7795 return true 7796 } 7797 // match: (MULA (MOVWconst [c]) x a) 7798 // cond: int32(c) == -1 7799 // result: (SUB a x) 7800 for { 7801 v_0 := v.Args[0] 7802 if v_0.Op != OpARMMOVWconst { 7803 break 7804 } 7805 c := v_0.AuxInt 7806 x := v.Args[1] 7807 a := v.Args[2] 7808 if !(int32(c) == -1) { 7809 break 7810 } 7811 v.reset(OpARMSUB) 7812 v.AddArg(a) 7813 v.AddArg(x) 7814 return true 7815 } 7816 // match: (MULA (MOVWconst [0]) _ a) 7817 // cond: 7818 // result: a 7819 for { 7820 v_0 := v.Args[0] 7821 if v_0.Op != OpARMMOVWconst { 7822 break 7823 } 7824 if v_0.AuxInt != 0 { 7825 break 7826 } 7827 a := v.Args[2] 7828 v.reset(OpCopy) 7829 v.Type = a.Type 7830 v.AddArg(a) 7831 return true 7832 } 7833 // match: (MULA (MOVWconst [1]) x a) 7834 // cond: 7835 // result: (ADD x a) 7836 for { 7837 v_0 := v.Args[0] 7838 if v_0.Op != OpARMMOVWconst { 7839 break 7840 } 7841 if v_0.AuxInt != 1 { 7842 break 7843 } 7844 x := v.Args[1] 7845 a := v.Args[2] 7846 v.reset(OpARMADD) 7847 v.AddArg(x) 7848 v.AddArg(a) 7849 return true 7850 } 7851 // match: (MULA (MOVWconst [c]) x a) 7852 // cond: isPowerOfTwo(c) 7853 // result: (ADD (SLLconst <x.Type> [log2(c)] x) a) 7854 for { 7855 v_0 := v.Args[0] 7856 if v_0.Op != OpARMMOVWconst { 7857 break 7858 } 7859 c := v_0.AuxInt 7860 x := v.Args[1] 7861 a := v.Args[2] 7862 if !(isPowerOfTwo(c)) { 7863 break 7864 } 7865 v.reset(OpARMADD) 7866 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 7867 v0.AuxInt = log2(c) 7868 v0.AddArg(x) 7869 v.AddArg(v0) 7870 v.AddArg(a) 7871 return true 7872 } 7873 // match: (MULA (MOVWconst [c]) x a) 7874 // cond: isPowerOfTwo(c-1) && int32(c) >= 3 7875 // result: (ADD (ADDshiftLL <x.Type> x x [log2(c-1)]) a) 7876 for { 7877 v_0 := v.Args[0] 7878 if v_0.Op != OpARMMOVWconst { 7879 break 7880 } 7881 c := v_0.AuxInt 7882 x := v.Args[1] 7883 a := v.Args[2] 7884 if !(isPowerOfTwo(c-1) && int32(c) >= 3) { 7885 break 7886 } 7887 v.reset(OpARMADD) 7888 v0 := b.NewValue0(v.Line, OpARMADDshiftLL, x.Type) 7889 v0.AuxInt = log2(c - 1) 7890 v0.AddArg(x) 7891 v0.AddArg(x) 7892 v.AddArg(v0) 7893 v.AddArg(a) 7894 return true 7895 } 7896 // match: (MULA (MOVWconst [c]) x a) 7897 // cond: isPowerOfTwo(c+1) && int32(c) >= 7 7898 // result: (ADD (RSBshiftLL <x.Type> x x [log2(c+1)]) a) 7899 for { 7900 v_0 := v.Args[0] 7901 if v_0.Op != OpARMMOVWconst { 7902 break 7903 } 7904 c := v_0.AuxInt 7905 x := v.Args[1] 7906 a := v.Args[2] 7907 if !(isPowerOfTwo(c+1) && int32(c) >= 7) { 7908 break 7909 } 7910 v.reset(OpARMADD) 7911 v0 := b.NewValue0(v.Line, OpARMRSBshiftLL, x.Type) 7912 v0.AuxInt = log2(c + 1) 7913 v0.AddArg(x) 7914 v0.AddArg(x) 7915 v.AddArg(v0) 7916 v.AddArg(a) 7917 return true 7918 } 7919 // match: (MULA (MOVWconst [c]) x a) 7920 // cond: c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c) 7921 // result: (ADD (SLLconst <x.Type> [log2(c/3)] (ADDshiftLL <x.Type> x x [1])) a) 7922 for { 7923 v_0 := v.Args[0] 7924 if v_0.Op != OpARMMOVWconst { 7925 break 7926 } 7927 c := v_0.AuxInt 7928 x := v.Args[1] 7929 a := v.Args[2] 7930 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) { 7931 break 7932 } 7933 v.reset(OpARMADD) 7934 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 7935 v0.AuxInt = log2(c / 3) 7936 v1 := b.NewValue0(v.Line, OpARMADDshiftLL, x.Type) 7937 v1.AuxInt = 1 7938 v1.AddArg(x) 7939 v1.AddArg(x) 7940 v0.AddArg(v1) 7941 v.AddArg(v0) 7942 v.AddArg(a) 7943 return true 7944 } 7945 // match: (MULA (MOVWconst [c]) x a) 7946 // cond: c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c) 7947 // result: (ADD (SLLconst <x.Type> [log2(c/5)] (ADDshiftLL <x.Type> x x [2])) a) 7948 for { 7949 v_0 := v.Args[0] 7950 if v_0.Op != OpARMMOVWconst { 7951 break 7952 } 7953 c := v_0.AuxInt 7954 x := v.Args[1] 7955 a := v.Args[2] 7956 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) { 7957 break 7958 } 7959 v.reset(OpARMADD) 7960 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 7961 v0.AuxInt = log2(c / 5) 7962 v1 := b.NewValue0(v.Line, OpARMADDshiftLL, x.Type) 7963 v1.AuxInt = 2 7964 v1.AddArg(x) 7965 v1.AddArg(x) 7966 v0.AddArg(v1) 7967 v.AddArg(v0) 7968 v.AddArg(a) 7969 return true 7970 } 7971 // match: (MULA (MOVWconst [c]) x a) 7972 // cond: c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c) 7973 // result: (ADD (SLLconst <x.Type> [log2(c/7)] (RSBshiftLL <x.Type> x x [3])) a) 7974 for { 7975 v_0 := v.Args[0] 7976 if v_0.Op != OpARMMOVWconst { 7977 break 7978 } 7979 c := v_0.AuxInt 7980 x := v.Args[1] 7981 a := v.Args[2] 7982 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) { 7983 break 7984 } 7985 v.reset(OpARMADD) 7986 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 7987 v0.AuxInt = log2(c / 7) 7988 v1 := b.NewValue0(v.Line, OpARMRSBshiftLL, x.Type) 7989 v1.AuxInt = 3 7990 v1.AddArg(x) 7991 v1.AddArg(x) 7992 v0.AddArg(v1) 7993 v.AddArg(v0) 7994 v.AddArg(a) 7995 return true 7996 } 7997 // match: (MULA (MOVWconst [c]) x a) 7998 // cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c) 7999 // result: (ADD (SLLconst <x.Type> [log2(c/9)] (ADDshiftLL <x.Type> x x [3])) a) 8000 for { 8001 v_0 := v.Args[0] 8002 if v_0.Op != OpARMMOVWconst { 8003 break 8004 } 8005 c := v_0.AuxInt 8006 x := v.Args[1] 8007 a := v.Args[2] 8008 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) { 8009 break 8010 } 8011 v.reset(OpARMADD) 8012 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 8013 v0.AuxInt = log2(c / 9) 8014 v1 := b.NewValue0(v.Line, OpARMADDshiftLL, x.Type) 8015 v1.AuxInt = 3 8016 v1.AddArg(x) 8017 v1.AddArg(x) 8018 v0.AddArg(v1) 8019 v.AddArg(v0) 8020 v.AddArg(a) 8021 return true 8022 } 8023 // match: (MULA (MOVWconst [c]) (MOVWconst [d]) a) 8024 // cond: 8025 // result: (ADDconst [int64(int32(c*d))] a) 8026 for { 8027 v_0 := v.Args[0] 8028 if v_0.Op != OpARMMOVWconst { 8029 break 8030 } 8031 c := v_0.AuxInt 8032 v_1 := v.Args[1] 8033 if v_1.Op != OpARMMOVWconst { 8034 break 8035 } 8036 d := v_1.AuxInt 8037 a := v.Args[2] 8038 v.reset(OpARMADDconst) 8039 v.AuxInt = int64(int32(c * d)) 8040 v.AddArg(a) 8041 return true 8042 } 8043 return false 8044 } 8045 func rewriteValueARM_OpARMMVN(v *Value, config *Config) bool { 8046 b := v.Block 8047 _ = b 8048 // match: (MVN (MOVWconst [c])) 8049 // cond: 8050 // result: (MOVWconst [^c]) 8051 for { 8052 v_0 := v.Args[0] 8053 if v_0.Op != OpARMMOVWconst { 8054 break 8055 } 8056 c := v_0.AuxInt 8057 v.reset(OpARMMOVWconst) 8058 v.AuxInt = ^c 8059 return true 8060 } 8061 // match: (MVN (SLLconst [c] x)) 8062 // cond: 8063 // result: (MVNshiftLL x [c]) 8064 for { 8065 v_0 := v.Args[0] 8066 if v_0.Op != OpARMSLLconst { 8067 break 8068 } 8069 c := v_0.AuxInt 8070 x := v_0.Args[0] 8071 v.reset(OpARMMVNshiftLL) 8072 v.AuxInt = c 8073 v.AddArg(x) 8074 return true 8075 } 8076 // match: (MVN (SRLconst [c] x)) 8077 // cond: 8078 // result: (MVNshiftRL x [c]) 8079 for { 8080 v_0 := v.Args[0] 8081 if v_0.Op != OpARMSRLconst { 8082 break 8083 } 8084 c := v_0.AuxInt 8085 x := v_0.Args[0] 8086 v.reset(OpARMMVNshiftRL) 8087 v.AuxInt = c 8088 v.AddArg(x) 8089 return true 8090 } 8091 // match: (MVN (SRAconst [c] x)) 8092 // cond: 8093 // result: (MVNshiftRA x [c]) 8094 for { 8095 v_0 := v.Args[0] 8096 if v_0.Op != OpARMSRAconst { 8097 break 8098 } 8099 c := v_0.AuxInt 8100 x := v_0.Args[0] 8101 v.reset(OpARMMVNshiftRA) 8102 v.AuxInt = c 8103 v.AddArg(x) 8104 return true 8105 } 8106 // match: (MVN (SLL x y)) 8107 // cond: 8108 // result: (MVNshiftLLreg x y) 8109 for { 8110 v_0 := v.Args[0] 8111 if v_0.Op != OpARMSLL { 8112 break 8113 } 8114 x := v_0.Args[0] 8115 y := v_0.Args[1] 8116 v.reset(OpARMMVNshiftLLreg) 8117 v.AddArg(x) 8118 v.AddArg(y) 8119 return true 8120 } 8121 // match: (MVN (SRL x y)) 8122 // cond: 8123 // result: (MVNshiftRLreg x y) 8124 for { 8125 v_0 := v.Args[0] 8126 if v_0.Op != OpARMSRL { 8127 break 8128 } 8129 x := v_0.Args[0] 8130 y := v_0.Args[1] 8131 v.reset(OpARMMVNshiftRLreg) 8132 v.AddArg(x) 8133 v.AddArg(y) 8134 return true 8135 } 8136 // match: (MVN (SRA x y)) 8137 // cond: 8138 // result: (MVNshiftRAreg x y) 8139 for { 8140 v_0 := v.Args[0] 8141 if v_0.Op != OpARMSRA { 8142 break 8143 } 8144 x := v_0.Args[0] 8145 y := v_0.Args[1] 8146 v.reset(OpARMMVNshiftRAreg) 8147 v.AddArg(x) 8148 v.AddArg(y) 8149 return true 8150 } 8151 return false 8152 } 8153 func rewriteValueARM_OpARMMVNshiftLL(v *Value, config *Config) bool { 8154 b := v.Block 8155 _ = b 8156 // match: (MVNshiftLL (MOVWconst [c]) [d]) 8157 // cond: 8158 // result: (MOVWconst [^int64(uint32(c)<<uint64(d))]) 8159 for { 8160 d := v.AuxInt 8161 v_0 := v.Args[0] 8162 if v_0.Op != OpARMMOVWconst { 8163 break 8164 } 8165 c := v_0.AuxInt 8166 v.reset(OpARMMOVWconst) 8167 v.AuxInt = ^int64(uint32(c) << uint64(d)) 8168 return true 8169 } 8170 return false 8171 } 8172 func rewriteValueARM_OpARMMVNshiftLLreg(v *Value, config *Config) bool { 8173 b := v.Block 8174 _ = b 8175 // match: (MVNshiftLLreg x (MOVWconst [c])) 8176 // cond: 8177 // result: (MVNshiftLL x [c]) 8178 for { 8179 x := v.Args[0] 8180 v_1 := v.Args[1] 8181 if v_1.Op != OpARMMOVWconst { 8182 break 8183 } 8184 c := v_1.AuxInt 8185 v.reset(OpARMMVNshiftLL) 8186 v.AuxInt = c 8187 v.AddArg(x) 8188 return true 8189 } 8190 return false 8191 } 8192 func rewriteValueARM_OpARMMVNshiftRA(v *Value, config *Config) bool { 8193 b := v.Block 8194 _ = b 8195 // match: (MVNshiftRA (MOVWconst [c]) [d]) 8196 // cond: 8197 // result: (MOVWconst [^int64(int32(c)>>uint64(d))]) 8198 for { 8199 d := v.AuxInt 8200 v_0 := v.Args[0] 8201 if v_0.Op != OpARMMOVWconst { 8202 break 8203 } 8204 c := v_0.AuxInt 8205 v.reset(OpARMMOVWconst) 8206 v.AuxInt = ^int64(int32(c) >> uint64(d)) 8207 return true 8208 } 8209 return false 8210 } 8211 func rewriteValueARM_OpARMMVNshiftRAreg(v *Value, config *Config) bool { 8212 b := v.Block 8213 _ = b 8214 // match: (MVNshiftRAreg x (MOVWconst [c])) 8215 // cond: 8216 // result: (MVNshiftRA x [c]) 8217 for { 8218 x := v.Args[0] 8219 v_1 := v.Args[1] 8220 if v_1.Op != OpARMMOVWconst { 8221 break 8222 } 8223 c := v_1.AuxInt 8224 v.reset(OpARMMVNshiftRA) 8225 v.AuxInt = c 8226 v.AddArg(x) 8227 return true 8228 } 8229 return false 8230 } 8231 func rewriteValueARM_OpARMMVNshiftRL(v *Value, config *Config) bool { 8232 b := v.Block 8233 _ = b 8234 // match: (MVNshiftRL (MOVWconst [c]) [d]) 8235 // cond: 8236 // result: (MOVWconst [^int64(uint32(c)>>uint64(d))]) 8237 for { 8238 d := v.AuxInt 8239 v_0 := v.Args[0] 8240 if v_0.Op != OpARMMOVWconst { 8241 break 8242 } 8243 c := v_0.AuxInt 8244 v.reset(OpARMMOVWconst) 8245 v.AuxInt = ^int64(uint32(c) >> uint64(d)) 8246 return true 8247 } 8248 return false 8249 } 8250 func rewriteValueARM_OpARMMVNshiftRLreg(v *Value, config *Config) bool { 8251 b := v.Block 8252 _ = b 8253 // match: (MVNshiftRLreg x (MOVWconst [c])) 8254 // cond: 8255 // result: (MVNshiftRL x [c]) 8256 for { 8257 x := v.Args[0] 8258 v_1 := v.Args[1] 8259 if v_1.Op != OpARMMOVWconst { 8260 break 8261 } 8262 c := v_1.AuxInt 8263 v.reset(OpARMMVNshiftRL) 8264 v.AuxInt = c 8265 v.AddArg(x) 8266 return true 8267 } 8268 return false 8269 } 8270 func rewriteValueARM_OpARMNotEqual(v *Value, config *Config) bool { 8271 b := v.Block 8272 _ = b 8273 // match: (NotEqual (FlagEQ)) 8274 // cond: 8275 // result: (MOVWconst [0]) 8276 for { 8277 v_0 := v.Args[0] 8278 if v_0.Op != OpARMFlagEQ { 8279 break 8280 } 8281 v.reset(OpARMMOVWconst) 8282 v.AuxInt = 0 8283 return true 8284 } 8285 // match: (NotEqual (FlagLT_ULT)) 8286 // cond: 8287 // result: (MOVWconst [1]) 8288 for { 8289 v_0 := v.Args[0] 8290 if v_0.Op != OpARMFlagLT_ULT { 8291 break 8292 } 8293 v.reset(OpARMMOVWconst) 8294 v.AuxInt = 1 8295 return true 8296 } 8297 // match: (NotEqual (FlagLT_UGT)) 8298 // cond: 8299 // result: (MOVWconst [1]) 8300 for { 8301 v_0 := v.Args[0] 8302 if v_0.Op != OpARMFlagLT_UGT { 8303 break 8304 } 8305 v.reset(OpARMMOVWconst) 8306 v.AuxInt = 1 8307 return true 8308 } 8309 // match: (NotEqual (FlagGT_ULT)) 8310 // cond: 8311 // result: (MOVWconst [1]) 8312 for { 8313 v_0 := v.Args[0] 8314 if v_0.Op != OpARMFlagGT_ULT { 8315 break 8316 } 8317 v.reset(OpARMMOVWconst) 8318 v.AuxInt = 1 8319 return true 8320 } 8321 // match: (NotEqual (FlagGT_UGT)) 8322 // cond: 8323 // result: (MOVWconst [1]) 8324 for { 8325 v_0 := v.Args[0] 8326 if v_0.Op != OpARMFlagGT_UGT { 8327 break 8328 } 8329 v.reset(OpARMMOVWconst) 8330 v.AuxInt = 1 8331 return true 8332 } 8333 // match: (NotEqual (InvertFlags x)) 8334 // cond: 8335 // result: (NotEqual x) 8336 for { 8337 v_0 := v.Args[0] 8338 if v_0.Op != OpARMInvertFlags { 8339 break 8340 } 8341 x := v_0.Args[0] 8342 v.reset(OpARMNotEqual) 8343 v.AddArg(x) 8344 return true 8345 } 8346 return false 8347 } 8348 func rewriteValueARM_OpARMOR(v *Value, config *Config) bool { 8349 b := v.Block 8350 _ = b 8351 // match: (OR (MOVWconst [c]) x) 8352 // cond: 8353 // result: (ORconst [c] x) 8354 for { 8355 v_0 := v.Args[0] 8356 if v_0.Op != OpARMMOVWconst { 8357 break 8358 } 8359 c := v_0.AuxInt 8360 x := v.Args[1] 8361 v.reset(OpARMORconst) 8362 v.AuxInt = c 8363 v.AddArg(x) 8364 return true 8365 } 8366 // match: (OR x (MOVWconst [c])) 8367 // cond: 8368 // result: (ORconst [c] x) 8369 for { 8370 x := v.Args[0] 8371 v_1 := v.Args[1] 8372 if v_1.Op != OpARMMOVWconst { 8373 break 8374 } 8375 c := v_1.AuxInt 8376 v.reset(OpARMORconst) 8377 v.AuxInt = c 8378 v.AddArg(x) 8379 return true 8380 } 8381 // match: (OR x (SLLconst [c] y)) 8382 // cond: 8383 // result: (ORshiftLL x y [c]) 8384 for { 8385 x := v.Args[0] 8386 v_1 := v.Args[1] 8387 if v_1.Op != OpARMSLLconst { 8388 break 8389 } 8390 c := v_1.AuxInt 8391 y := v_1.Args[0] 8392 v.reset(OpARMORshiftLL) 8393 v.AuxInt = c 8394 v.AddArg(x) 8395 v.AddArg(y) 8396 return true 8397 } 8398 // match: (OR (SLLconst [c] y) x) 8399 // cond: 8400 // result: (ORshiftLL x y [c]) 8401 for { 8402 v_0 := v.Args[0] 8403 if v_0.Op != OpARMSLLconst { 8404 break 8405 } 8406 c := v_0.AuxInt 8407 y := v_0.Args[0] 8408 x := v.Args[1] 8409 v.reset(OpARMORshiftLL) 8410 v.AuxInt = c 8411 v.AddArg(x) 8412 v.AddArg(y) 8413 return true 8414 } 8415 // match: (OR x (SRLconst [c] y)) 8416 // cond: 8417 // result: (ORshiftRL x y [c]) 8418 for { 8419 x := v.Args[0] 8420 v_1 := v.Args[1] 8421 if v_1.Op != OpARMSRLconst { 8422 break 8423 } 8424 c := v_1.AuxInt 8425 y := v_1.Args[0] 8426 v.reset(OpARMORshiftRL) 8427 v.AuxInt = c 8428 v.AddArg(x) 8429 v.AddArg(y) 8430 return true 8431 } 8432 // match: (OR (SRLconst [c] y) x) 8433 // cond: 8434 // result: (ORshiftRL x y [c]) 8435 for { 8436 v_0 := v.Args[0] 8437 if v_0.Op != OpARMSRLconst { 8438 break 8439 } 8440 c := v_0.AuxInt 8441 y := v_0.Args[0] 8442 x := v.Args[1] 8443 v.reset(OpARMORshiftRL) 8444 v.AuxInt = c 8445 v.AddArg(x) 8446 v.AddArg(y) 8447 return true 8448 } 8449 // match: (OR x (SRAconst [c] y)) 8450 // cond: 8451 // result: (ORshiftRA x y [c]) 8452 for { 8453 x := v.Args[0] 8454 v_1 := v.Args[1] 8455 if v_1.Op != OpARMSRAconst { 8456 break 8457 } 8458 c := v_1.AuxInt 8459 y := v_1.Args[0] 8460 v.reset(OpARMORshiftRA) 8461 v.AuxInt = c 8462 v.AddArg(x) 8463 v.AddArg(y) 8464 return true 8465 } 8466 // match: (OR (SRAconst [c] y) x) 8467 // cond: 8468 // result: (ORshiftRA x y [c]) 8469 for { 8470 v_0 := v.Args[0] 8471 if v_0.Op != OpARMSRAconst { 8472 break 8473 } 8474 c := v_0.AuxInt 8475 y := v_0.Args[0] 8476 x := v.Args[1] 8477 v.reset(OpARMORshiftRA) 8478 v.AuxInt = c 8479 v.AddArg(x) 8480 v.AddArg(y) 8481 return true 8482 } 8483 // match: (OR x (SLL y z)) 8484 // cond: 8485 // result: (ORshiftLLreg x y z) 8486 for { 8487 x := v.Args[0] 8488 v_1 := v.Args[1] 8489 if v_1.Op != OpARMSLL { 8490 break 8491 } 8492 y := v_1.Args[0] 8493 z := v_1.Args[1] 8494 v.reset(OpARMORshiftLLreg) 8495 v.AddArg(x) 8496 v.AddArg(y) 8497 v.AddArg(z) 8498 return true 8499 } 8500 // match: (OR (SLL y z) x) 8501 // cond: 8502 // result: (ORshiftLLreg x y z) 8503 for { 8504 v_0 := v.Args[0] 8505 if v_0.Op != OpARMSLL { 8506 break 8507 } 8508 y := v_0.Args[0] 8509 z := v_0.Args[1] 8510 x := v.Args[1] 8511 v.reset(OpARMORshiftLLreg) 8512 v.AddArg(x) 8513 v.AddArg(y) 8514 v.AddArg(z) 8515 return true 8516 } 8517 // match: (OR x (SRL y z)) 8518 // cond: 8519 // result: (ORshiftRLreg x y z) 8520 for { 8521 x := v.Args[0] 8522 v_1 := v.Args[1] 8523 if v_1.Op != OpARMSRL { 8524 break 8525 } 8526 y := v_1.Args[0] 8527 z := v_1.Args[1] 8528 v.reset(OpARMORshiftRLreg) 8529 v.AddArg(x) 8530 v.AddArg(y) 8531 v.AddArg(z) 8532 return true 8533 } 8534 // match: (OR (SRL y z) x) 8535 // cond: 8536 // result: (ORshiftRLreg x y z) 8537 for { 8538 v_0 := v.Args[0] 8539 if v_0.Op != OpARMSRL { 8540 break 8541 } 8542 y := v_0.Args[0] 8543 z := v_0.Args[1] 8544 x := v.Args[1] 8545 v.reset(OpARMORshiftRLreg) 8546 v.AddArg(x) 8547 v.AddArg(y) 8548 v.AddArg(z) 8549 return true 8550 } 8551 // match: (OR x (SRA y z)) 8552 // cond: 8553 // result: (ORshiftRAreg x y z) 8554 for { 8555 x := v.Args[0] 8556 v_1 := v.Args[1] 8557 if v_1.Op != OpARMSRA { 8558 break 8559 } 8560 y := v_1.Args[0] 8561 z := v_1.Args[1] 8562 v.reset(OpARMORshiftRAreg) 8563 v.AddArg(x) 8564 v.AddArg(y) 8565 v.AddArg(z) 8566 return true 8567 } 8568 // match: (OR (SRA y z) x) 8569 // cond: 8570 // result: (ORshiftRAreg x y z) 8571 for { 8572 v_0 := v.Args[0] 8573 if v_0.Op != OpARMSRA { 8574 break 8575 } 8576 y := v_0.Args[0] 8577 z := v_0.Args[1] 8578 x := v.Args[1] 8579 v.reset(OpARMORshiftRAreg) 8580 v.AddArg(x) 8581 v.AddArg(y) 8582 v.AddArg(z) 8583 return true 8584 } 8585 // match: (OR x x) 8586 // cond: 8587 // result: x 8588 for { 8589 x := v.Args[0] 8590 if x != v.Args[1] { 8591 break 8592 } 8593 v.reset(OpCopy) 8594 v.Type = x.Type 8595 v.AddArg(x) 8596 return true 8597 } 8598 return false 8599 } 8600 func rewriteValueARM_OpARMORconst(v *Value, config *Config) bool { 8601 b := v.Block 8602 _ = b 8603 // match: (ORconst [0] x) 8604 // cond: 8605 // result: x 8606 for { 8607 if v.AuxInt != 0 { 8608 break 8609 } 8610 x := v.Args[0] 8611 v.reset(OpCopy) 8612 v.Type = x.Type 8613 v.AddArg(x) 8614 return true 8615 } 8616 // match: (ORconst [c] _) 8617 // cond: int32(c)==-1 8618 // result: (MOVWconst [-1]) 8619 for { 8620 c := v.AuxInt 8621 if !(int32(c) == -1) { 8622 break 8623 } 8624 v.reset(OpARMMOVWconst) 8625 v.AuxInt = -1 8626 return true 8627 } 8628 // match: (ORconst [c] (MOVWconst [d])) 8629 // cond: 8630 // result: (MOVWconst [c|d]) 8631 for { 8632 c := v.AuxInt 8633 v_0 := v.Args[0] 8634 if v_0.Op != OpARMMOVWconst { 8635 break 8636 } 8637 d := v_0.AuxInt 8638 v.reset(OpARMMOVWconst) 8639 v.AuxInt = c | d 8640 return true 8641 } 8642 // match: (ORconst [c] (ORconst [d] x)) 8643 // cond: 8644 // result: (ORconst [c|d] x) 8645 for { 8646 c := v.AuxInt 8647 v_0 := v.Args[0] 8648 if v_0.Op != OpARMORconst { 8649 break 8650 } 8651 d := v_0.AuxInt 8652 x := v_0.Args[0] 8653 v.reset(OpARMORconst) 8654 v.AuxInt = c | d 8655 v.AddArg(x) 8656 return true 8657 } 8658 return false 8659 } 8660 func rewriteValueARM_OpARMORshiftLL(v *Value, config *Config) bool { 8661 b := v.Block 8662 _ = b 8663 // match: (ORshiftLL (MOVWconst [c]) x [d]) 8664 // cond: 8665 // result: (ORconst [c] (SLLconst <x.Type> x [d])) 8666 for { 8667 d := v.AuxInt 8668 v_0 := v.Args[0] 8669 if v_0.Op != OpARMMOVWconst { 8670 break 8671 } 8672 c := v_0.AuxInt 8673 x := v.Args[1] 8674 v.reset(OpARMORconst) 8675 v.AuxInt = c 8676 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 8677 v0.AuxInt = d 8678 v0.AddArg(x) 8679 v.AddArg(v0) 8680 return true 8681 } 8682 // match: (ORshiftLL x (MOVWconst [c]) [d]) 8683 // cond: 8684 // result: (ORconst x [int64(uint32(c)<<uint64(d))]) 8685 for { 8686 d := v.AuxInt 8687 x := v.Args[0] 8688 v_1 := v.Args[1] 8689 if v_1.Op != OpARMMOVWconst { 8690 break 8691 } 8692 c := v_1.AuxInt 8693 v.reset(OpARMORconst) 8694 v.AuxInt = int64(uint32(c) << uint64(d)) 8695 v.AddArg(x) 8696 return true 8697 } 8698 // match: (ORshiftLL x y:(SLLconst x [c]) [d]) 8699 // cond: c==d 8700 // result: y 8701 for { 8702 d := v.AuxInt 8703 x := v.Args[0] 8704 y := v.Args[1] 8705 if y.Op != OpARMSLLconst { 8706 break 8707 } 8708 c := y.AuxInt 8709 if x != y.Args[0] { 8710 break 8711 } 8712 if !(c == d) { 8713 break 8714 } 8715 v.reset(OpCopy) 8716 v.Type = y.Type 8717 v.AddArg(y) 8718 return true 8719 } 8720 return false 8721 } 8722 func rewriteValueARM_OpARMORshiftLLreg(v *Value, config *Config) bool { 8723 b := v.Block 8724 _ = b 8725 // match: (ORshiftLLreg (MOVWconst [c]) x y) 8726 // cond: 8727 // result: (ORconst [c] (SLL <x.Type> x y)) 8728 for { 8729 v_0 := v.Args[0] 8730 if v_0.Op != OpARMMOVWconst { 8731 break 8732 } 8733 c := v_0.AuxInt 8734 x := v.Args[1] 8735 y := v.Args[2] 8736 v.reset(OpARMORconst) 8737 v.AuxInt = c 8738 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 8739 v0.AddArg(x) 8740 v0.AddArg(y) 8741 v.AddArg(v0) 8742 return true 8743 } 8744 // match: (ORshiftLLreg x y (MOVWconst [c])) 8745 // cond: 8746 // result: (ORshiftLL x y [c]) 8747 for { 8748 x := v.Args[0] 8749 y := v.Args[1] 8750 v_2 := v.Args[2] 8751 if v_2.Op != OpARMMOVWconst { 8752 break 8753 } 8754 c := v_2.AuxInt 8755 v.reset(OpARMORshiftLL) 8756 v.AuxInt = c 8757 v.AddArg(x) 8758 v.AddArg(y) 8759 return true 8760 } 8761 return false 8762 } 8763 func rewriteValueARM_OpARMORshiftRA(v *Value, config *Config) bool { 8764 b := v.Block 8765 _ = b 8766 // match: (ORshiftRA (MOVWconst [c]) x [d]) 8767 // cond: 8768 // result: (ORconst [c] (SRAconst <x.Type> x [d])) 8769 for { 8770 d := v.AuxInt 8771 v_0 := v.Args[0] 8772 if v_0.Op != OpARMMOVWconst { 8773 break 8774 } 8775 c := v_0.AuxInt 8776 x := v.Args[1] 8777 v.reset(OpARMORconst) 8778 v.AuxInt = c 8779 v0 := b.NewValue0(v.Line, OpARMSRAconst, x.Type) 8780 v0.AuxInt = d 8781 v0.AddArg(x) 8782 v.AddArg(v0) 8783 return true 8784 } 8785 // match: (ORshiftRA x (MOVWconst [c]) [d]) 8786 // cond: 8787 // result: (ORconst x [int64(int32(c)>>uint64(d))]) 8788 for { 8789 d := v.AuxInt 8790 x := v.Args[0] 8791 v_1 := v.Args[1] 8792 if v_1.Op != OpARMMOVWconst { 8793 break 8794 } 8795 c := v_1.AuxInt 8796 v.reset(OpARMORconst) 8797 v.AuxInt = int64(int32(c) >> uint64(d)) 8798 v.AddArg(x) 8799 return true 8800 } 8801 // match: (ORshiftRA x y:(SRAconst x [c]) [d]) 8802 // cond: c==d 8803 // result: y 8804 for { 8805 d := v.AuxInt 8806 x := v.Args[0] 8807 y := v.Args[1] 8808 if y.Op != OpARMSRAconst { 8809 break 8810 } 8811 c := y.AuxInt 8812 if x != y.Args[0] { 8813 break 8814 } 8815 if !(c == d) { 8816 break 8817 } 8818 v.reset(OpCopy) 8819 v.Type = y.Type 8820 v.AddArg(y) 8821 return true 8822 } 8823 return false 8824 } 8825 func rewriteValueARM_OpARMORshiftRAreg(v *Value, config *Config) bool { 8826 b := v.Block 8827 _ = b 8828 // match: (ORshiftRAreg (MOVWconst [c]) x y) 8829 // cond: 8830 // result: (ORconst [c] (SRA <x.Type> x y)) 8831 for { 8832 v_0 := v.Args[0] 8833 if v_0.Op != OpARMMOVWconst { 8834 break 8835 } 8836 c := v_0.AuxInt 8837 x := v.Args[1] 8838 y := v.Args[2] 8839 v.reset(OpARMORconst) 8840 v.AuxInt = c 8841 v0 := b.NewValue0(v.Line, OpARMSRA, x.Type) 8842 v0.AddArg(x) 8843 v0.AddArg(y) 8844 v.AddArg(v0) 8845 return true 8846 } 8847 // match: (ORshiftRAreg x y (MOVWconst [c])) 8848 // cond: 8849 // result: (ORshiftRA x y [c]) 8850 for { 8851 x := v.Args[0] 8852 y := v.Args[1] 8853 v_2 := v.Args[2] 8854 if v_2.Op != OpARMMOVWconst { 8855 break 8856 } 8857 c := v_2.AuxInt 8858 v.reset(OpARMORshiftRA) 8859 v.AuxInt = c 8860 v.AddArg(x) 8861 v.AddArg(y) 8862 return true 8863 } 8864 return false 8865 } 8866 func rewriteValueARM_OpARMORshiftRL(v *Value, config *Config) bool { 8867 b := v.Block 8868 _ = b 8869 // match: (ORshiftRL (MOVWconst [c]) x [d]) 8870 // cond: 8871 // result: (ORconst [c] (SRLconst <x.Type> x [d])) 8872 for { 8873 d := v.AuxInt 8874 v_0 := v.Args[0] 8875 if v_0.Op != OpARMMOVWconst { 8876 break 8877 } 8878 c := v_0.AuxInt 8879 x := v.Args[1] 8880 v.reset(OpARMORconst) 8881 v.AuxInt = c 8882 v0 := b.NewValue0(v.Line, OpARMSRLconst, x.Type) 8883 v0.AuxInt = d 8884 v0.AddArg(x) 8885 v.AddArg(v0) 8886 return true 8887 } 8888 // match: (ORshiftRL x (MOVWconst [c]) [d]) 8889 // cond: 8890 // result: (ORconst x [int64(uint32(c)>>uint64(d))]) 8891 for { 8892 d := v.AuxInt 8893 x := v.Args[0] 8894 v_1 := v.Args[1] 8895 if v_1.Op != OpARMMOVWconst { 8896 break 8897 } 8898 c := v_1.AuxInt 8899 v.reset(OpARMORconst) 8900 v.AuxInt = int64(uint32(c) >> uint64(d)) 8901 v.AddArg(x) 8902 return true 8903 } 8904 // match: (ORshiftRL x y:(SRLconst x [c]) [d]) 8905 // cond: c==d 8906 // result: y 8907 for { 8908 d := v.AuxInt 8909 x := v.Args[0] 8910 y := v.Args[1] 8911 if y.Op != OpARMSRLconst { 8912 break 8913 } 8914 c := y.AuxInt 8915 if x != y.Args[0] { 8916 break 8917 } 8918 if !(c == d) { 8919 break 8920 } 8921 v.reset(OpCopy) 8922 v.Type = y.Type 8923 v.AddArg(y) 8924 return true 8925 } 8926 return false 8927 } 8928 func rewriteValueARM_OpARMORshiftRLreg(v *Value, config *Config) bool { 8929 b := v.Block 8930 _ = b 8931 // match: (ORshiftRLreg (MOVWconst [c]) x y) 8932 // cond: 8933 // result: (ORconst [c] (SRL <x.Type> x y)) 8934 for { 8935 v_0 := v.Args[0] 8936 if v_0.Op != OpARMMOVWconst { 8937 break 8938 } 8939 c := v_0.AuxInt 8940 x := v.Args[1] 8941 y := v.Args[2] 8942 v.reset(OpARMORconst) 8943 v.AuxInt = c 8944 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 8945 v0.AddArg(x) 8946 v0.AddArg(y) 8947 v.AddArg(v0) 8948 return true 8949 } 8950 // match: (ORshiftRLreg x y (MOVWconst [c])) 8951 // cond: 8952 // result: (ORshiftRL x y [c]) 8953 for { 8954 x := v.Args[0] 8955 y := v.Args[1] 8956 v_2 := v.Args[2] 8957 if v_2.Op != OpARMMOVWconst { 8958 break 8959 } 8960 c := v_2.AuxInt 8961 v.reset(OpARMORshiftRL) 8962 v.AuxInt = c 8963 v.AddArg(x) 8964 v.AddArg(y) 8965 return true 8966 } 8967 return false 8968 } 8969 func rewriteValueARM_OpARMRSB(v *Value, config *Config) bool { 8970 b := v.Block 8971 _ = b 8972 // match: (RSB (MOVWconst [c]) x) 8973 // cond: 8974 // result: (SUBconst [c] x) 8975 for { 8976 v_0 := v.Args[0] 8977 if v_0.Op != OpARMMOVWconst { 8978 break 8979 } 8980 c := v_0.AuxInt 8981 x := v.Args[1] 8982 v.reset(OpARMSUBconst) 8983 v.AuxInt = c 8984 v.AddArg(x) 8985 return true 8986 } 8987 // match: (RSB x (MOVWconst [c])) 8988 // cond: 8989 // result: (RSBconst [c] x) 8990 for { 8991 x := v.Args[0] 8992 v_1 := v.Args[1] 8993 if v_1.Op != OpARMMOVWconst { 8994 break 8995 } 8996 c := v_1.AuxInt 8997 v.reset(OpARMRSBconst) 8998 v.AuxInt = c 8999 v.AddArg(x) 9000 return true 9001 } 9002 // match: (RSB x (SLLconst [c] y)) 9003 // cond: 9004 // result: (RSBshiftLL x y [c]) 9005 for { 9006 x := v.Args[0] 9007 v_1 := v.Args[1] 9008 if v_1.Op != OpARMSLLconst { 9009 break 9010 } 9011 c := v_1.AuxInt 9012 y := v_1.Args[0] 9013 v.reset(OpARMRSBshiftLL) 9014 v.AuxInt = c 9015 v.AddArg(x) 9016 v.AddArg(y) 9017 return true 9018 } 9019 // match: (RSB (SLLconst [c] y) x) 9020 // cond: 9021 // result: (SUBshiftLL x y [c]) 9022 for { 9023 v_0 := v.Args[0] 9024 if v_0.Op != OpARMSLLconst { 9025 break 9026 } 9027 c := v_0.AuxInt 9028 y := v_0.Args[0] 9029 x := v.Args[1] 9030 v.reset(OpARMSUBshiftLL) 9031 v.AuxInt = c 9032 v.AddArg(x) 9033 v.AddArg(y) 9034 return true 9035 } 9036 // match: (RSB x (SRLconst [c] y)) 9037 // cond: 9038 // result: (RSBshiftRL x y [c]) 9039 for { 9040 x := v.Args[0] 9041 v_1 := v.Args[1] 9042 if v_1.Op != OpARMSRLconst { 9043 break 9044 } 9045 c := v_1.AuxInt 9046 y := v_1.Args[0] 9047 v.reset(OpARMRSBshiftRL) 9048 v.AuxInt = c 9049 v.AddArg(x) 9050 v.AddArg(y) 9051 return true 9052 } 9053 // match: (RSB (SRLconst [c] y) x) 9054 // cond: 9055 // result: (SUBshiftRL x y [c]) 9056 for { 9057 v_0 := v.Args[0] 9058 if v_0.Op != OpARMSRLconst { 9059 break 9060 } 9061 c := v_0.AuxInt 9062 y := v_0.Args[0] 9063 x := v.Args[1] 9064 v.reset(OpARMSUBshiftRL) 9065 v.AuxInt = c 9066 v.AddArg(x) 9067 v.AddArg(y) 9068 return true 9069 } 9070 // match: (RSB x (SRAconst [c] y)) 9071 // cond: 9072 // result: (RSBshiftRA x y [c]) 9073 for { 9074 x := v.Args[0] 9075 v_1 := v.Args[1] 9076 if v_1.Op != OpARMSRAconst { 9077 break 9078 } 9079 c := v_1.AuxInt 9080 y := v_1.Args[0] 9081 v.reset(OpARMRSBshiftRA) 9082 v.AuxInt = c 9083 v.AddArg(x) 9084 v.AddArg(y) 9085 return true 9086 } 9087 // match: (RSB (SRAconst [c] y) x) 9088 // cond: 9089 // result: (SUBshiftRA x y [c]) 9090 for { 9091 v_0 := v.Args[0] 9092 if v_0.Op != OpARMSRAconst { 9093 break 9094 } 9095 c := v_0.AuxInt 9096 y := v_0.Args[0] 9097 x := v.Args[1] 9098 v.reset(OpARMSUBshiftRA) 9099 v.AuxInt = c 9100 v.AddArg(x) 9101 v.AddArg(y) 9102 return true 9103 } 9104 // match: (RSB x (SLL y z)) 9105 // cond: 9106 // result: (RSBshiftLLreg x y z) 9107 for { 9108 x := v.Args[0] 9109 v_1 := v.Args[1] 9110 if v_1.Op != OpARMSLL { 9111 break 9112 } 9113 y := v_1.Args[0] 9114 z := v_1.Args[1] 9115 v.reset(OpARMRSBshiftLLreg) 9116 v.AddArg(x) 9117 v.AddArg(y) 9118 v.AddArg(z) 9119 return true 9120 } 9121 // match: (RSB (SLL y z) x) 9122 // cond: 9123 // result: (SUBshiftLLreg x y z) 9124 for { 9125 v_0 := v.Args[0] 9126 if v_0.Op != OpARMSLL { 9127 break 9128 } 9129 y := v_0.Args[0] 9130 z := v_0.Args[1] 9131 x := v.Args[1] 9132 v.reset(OpARMSUBshiftLLreg) 9133 v.AddArg(x) 9134 v.AddArg(y) 9135 v.AddArg(z) 9136 return true 9137 } 9138 // match: (RSB x (SRL y z)) 9139 // cond: 9140 // result: (RSBshiftRLreg x y z) 9141 for { 9142 x := v.Args[0] 9143 v_1 := v.Args[1] 9144 if v_1.Op != OpARMSRL { 9145 break 9146 } 9147 y := v_1.Args[0] 9148 z := v_1.Args[1] 9149 v.reset(OpARMRSBshiftRLreg) 9150 v.AddArg(x) 9151 v.AddArg(y) 9152 v.AddArg(z) 9153 return true 9154 } 9155 // match: (RSB (SRL y z) x) 9156 // cond: 9157 // result: (SUBshiftRLreg x y z) 9158 for { 9159 v_0 := v.Args[0] 9160 if v_0.Op != OpARMSRL { 9161 break 9162 } 9163 y := v_0.Args[0] 9164 z := v_0.Args[1] 9165 x := v.Args[1] 9166 v.reset(OpARMSUBshiftRLreg) 9167 v.AddArg(x) 9168 v.AddArg(y) 9169 v.AddArg(z) 9170 return true 9171 } 9172 // match: (RSB x (SRA y z)) 9173 // cond: 9174 // result: (RSBshiftRAreg x y z) 9175 for { 9176 x := v.Args[0] 9177 v_1 := v.Args[1] 9178 if v_1.Op != OpARMSRA { 9179 break 9180 } 9181 y := v_1.Args[0] 9182 z := v_1.Args[1] 9183 v.reset(OpARMRSBshiftRAreg) 9184 v.AddArg(x) 9185 v.AddArg(y) 9186 v.AddArg(z) 9187 return true 9188 } 9189 // match: (RSB (SRA y z) x) 9190 // cond: 9191 // result: (SUBshiftRAreg x y z) 9192 for { 9193 v_0 := v.Args[0] 9194 if v_0.Op != OpARMSRA { 9195 break 9196 } 9197 y := v_0.Args[0] 9198 z := v_0.Args[1] 9199 x := v.Args[1] 9200 v.reset(OpARMSUBshiftRAreg) 9201 v.AddArg(x) 9202 v.AddArg(y) 9203 v.AddArg(z) 9204 return true 9205 } 9206 // match: (RSB x x) 9207 // cond: 9208 // result: (MOVWconst [0]) 9209 for { 9210 x := v.Args[0] 9211 if x != v.Args[1] { 9212 break 9213 } 9214 v.reset(OpARMMOVWconst) 9215 v.AuxInt = 0 9216 return true 9217 } 9218 return false 9219 } 9220 func rewriteValueARM_OpARMRSBSshiftLL(v *Value, config *Config) bool { 9221 b := v.Block 9222 _ = b 9223 // match: (RSBSshiftLL (MOVWconst [c]) x [d]) 9224 // cond: 9225 // result: (SUBSconst [c] (SLLconst <x.Type> x [d])) 9226 for { 9227 d := v.AuxInt 9228 v_0 := v.Args[0] 9229 if v_0.Op != OpARMMOVWconst { 9230 break 9231 } 9232 c := v_0.AuxInt 9233 x := v.Args[1] 9234 v.reset(OpARMSUBSconst) 9235 v.AuxInt = c 9236 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 9237 v0.AuxInt = d 9238 v0.AddArg(x) 9239 v.AddArg(v0) 9240 return true 9241 } 9242 // match: (RSBSshiftLL x (MOVWconst [c]) [d]) 9243 // cond: 9244 // result: (RSBSconst x [int64(uint32(c)<<uint64(d))]) 9245 for { 9246 d := v.AuxInt 9247 x := v.Args[0] 9248 v_1 := v.Args[1] 9249 if v_1.Op != OpARMMOVWconst { 9250 break 9251 } 9252 c := v_1.AuxInt 9253 v.reset(OpARMRSBSconst) 9254 v.AuxInt = int64(uint32(c) << uint64(d)) 9255 v.AddArg(x) 9256 return true 9257 } 9258 return false 9259 } 9260 func rewriteValueARM_OpARMRSBSshiftLLreg(v *Value, config *Config) bool { 9261 b := v.Block 9262 _ = b 9263 // match: (RSBSshiftLLreg (MOVWconst [c]) x y) 9264 // cond: 9265 // result: (SUBSconst [c] (SLL <x.Type> x y)) 9266 for { 9267 v_0 := v.Args[0] 9268 if v_0.Op != OpARMMOVWconst { 9269 break 9270 } 9271 c := v_0.AuxInt 9272 x := v.Args[1] 9273 y := v.Args[2] 9274 v.reset(OpARMSUBSconst) 9275 v.AuxInt = c 9276 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 9277 v0.AddArg(x) 9278 v0.AddArg(y) 9279 v.AddArg(v0) 9280 return true 9281 } 9282 // match: (RSBSshiftLLreg x y (MOVWconst [c])) 9283 // cond: 9284 // result: (RSBSshiftLL x y [c]) 9285 for { 9286 x := v.Args[0] 9287 y := v.Args[1] 9288 v_2 := v.Args[2] 9289 if v_2.Op != OpARMMOVWconst { 9290 break 9291 } 9292 c := v_2.AuxInt 9293 v.reset(OpARMRSBSshiftLL) 9294 v.AuxInt = c 9295 v.AddArg(x) 9296 v.AddArg(y) 9297 return true 9298 } 9299 return false 9300 } 9301 func rewriteValueARM_OpARMRSBSshiftRA(v *Value, config *Config) bool { 9302 b := v.Block 9303 _ = b 9304 // match: (RSBSshiftRA (MOVWconst [c]) x [d]) 9305 // cond: 9306 // result: (SUBSconst [c] (SRAconst <x.Type> x [d])) 9307 for { 9308 d := v.AuxInt 9309 v_0 := v.Args[0] 9310 if v_0.Op != OpARMMOVWconst { 9311 break 9312 } 9313 c := v_0.AuxInt 9314 x := v.Args[1] 9315 v.reset(OpARMSUBSconst) 9316 v.AuxInt = c 9317 v0 := b.NewValue0(v.Line, OpARMSRAconst, x.Type) 9318 v0.AuxInt = d 9319 v0.AddArg(x) 9320 v.AddArg(v0) 9321 return true 9322 } 9323 // match: (RSBSshiftRA x (MOVWconst [c]) [d]) 9324 // cond: 9325 // result: (RSBSconst x [int64(int32(c)>>uint64(d))]) 9326 for { 9327 d := v.AuxInt 9328 x := v.Args[0] 9329 v_1 := v.Args[1] 9330 if v_1.Op != OpARMMOVWconst { 9331 break 9332 } 9333 c := v_1.AuxInt 9334 v.reset(OpARMRSBSconst) 9335 v.AuxInt = int64(int32(c) >> uint64(d)) 9336 v.AddArg(x) 9337 return true 9338 } 9339 return false 9340 } 9341 func rewriteValueARM_OpARMRSBSshiftRAreg(v *Value, config *Config) bool { 9342 b := v.Block 9343 _ = b 9344 // match: (RSBSshiftRAreg (MOVWconst [c]) x y) 9345 // cond: 9346 // result: (SUBSconst [c] (SRA <x.Type> x y)) 9347 for { 9348 v_0 := v.Args[0] 9349 if v_0.Op != OpARMMOVWconst { 9350 break 9351 } 9352 c := v_0.AuxInt 9353 x := v.Args[1] 9354 y := v.Args[2] 9355 v.reset(OpARMSUBSconst) 9356 v.AuxInt = c 9357 v0 := b.NewValue0(v.Line, OpARMSRA, x.Type) 9358 v0.AddArg(x) 9359 v0.AddArg(y) 9360 v.AddArg(v0) 9361 return true 9362 } 9363 // match: (RSBSshiftRAreg x y (MOVWconst [c])) 9364 // cond: 9365 // result: (RSBSshiftRA x y [c]) 9366 for { 9367 x := v.Args[0] 9368 y := v.Args[1] 9369 v_2 := v.Args[2] 9370 if v_2.Op != OpARMMOVWconst { 9371 break 9372 } 9373 c := v_2.AuxInt 9374 v.reset(OpARMRSBSshiftRA) 9375 v.AuxInt = c 9376 v.AddArg(x) 9377 v.AddArg(y) 9378 return true 9379 } 9380 return false 9381 } 9382 func rewriteValueARM_OpARMRSBSshiftRL(v *Value, config *Config) bool { 9383 b := v.Block 9384 _ = b 9385 // match: (RSBSshiftRL (MOVWconst [c]) x [d]) 9386 // cond: 9387 // result: (SUBSconst [c] (SRLconst <x.Type> x [d])) 9388 for { 9389 d := v.AuxInt 9390 v_0 := v.Args[0] 9391 if v_0.Op != OpARMMOVWconst { 9392 break 9393 } 9394 c := v_0.AuxInt 9395 x := v.Args[1] 9396 v.reset(OpARMSUBSconst) 9397 v.AuxInt = c 9398 v0 := b.NewValue0(v.Line, OpARMSRLconst, x.Type) 9399 v0.AuxInt = d 9400 v0.AddArg(x) 9401 v.AddArg(v0) 9402 return true 9403 } 9404 // match: (RSBSshiftRL x (MOVWconst [c]) [d]) 9405 // cond: 9406 // result: (RSBSconst x [int64(uint32(c)>>uint64(d))]) 9407 for { 9408 d := v.AuxInt 9409 x := v.Args[0] 9410 v_1 := v.Args[1] 9411 if v_1.Op != OpARMMOVWconst { 9412 break 9413 } 9414 c := v_1.AuxInt 9415 v.reset(OpARMRSBSconst) 9416 v.AuxInt = int64(uint32(c) >> uint64(d)) 9417 v.AddArg(x) 9418 return true 9419 } 9420 return false 9421 } 9422 func rewriteValueARM_OpARMRSBSshiftRLreg(v *Value, config *Config) bool { 9423 b := v.Block 9424 _ = b 9425 // match: (RSBSshiftRLreg (MOVWconst [c]) x y) 9426 // cond: 9427 // result: (SUBSconst [c] (SRL <x.Type> x y)) 9428 for { 9429 v_0 := v.Args[0] 9430 if v_0.Op != OpARMMOVWconst { 9431 break 9432 } 9433 c := v_0.AuxInt 9434 x := v.Args[1] 9435 y := v.Args[2] 9436 v.reset(OpARMSUBSconst) 9437 v.AuxInt = c 9438 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 9439 v0.AddArg(x) 9440 v0.AddArg(y) 9441 v.AddArg(v0) 9442 return true 9443 } 9444 // match: (RSBSshiftRLreg x y (MOVWconst [c])) 9445 // cond: 9446 // result: (RSBSshiftRL x y [c]) 9447 for { 9448 x := v.Args[0] 9449 y := v.Args[1] 9450 v_2 := v.Args[2] 9451 if v_2.Op != OpARMMOVWconst { 9452 break 9453 } 9454 c := v_2.AuxInt 9455 v.reset(OpARMRSBSshiftRL) 9456 v.AuxInt = c 9457 v.AddArg(x) 9458 v.AddArg(y) 9459 return true 9460 } 9461 return false 9462 } 9463 func rewriteValueARM_OpARMRSBconst(v *Value, config *Config) bool { 9464 b := v.Block 9465 _ = b 9466 // match: (RSBconst [c] (MOVWconst [d])) 9467 // cond: 9468 // result: (MOVWconst [int64(int32(c-d))]) 9469 for { 9470 c := v.AuxInt 9471 v_0 := v.Args[0] 9472 if v_0.Op != OpARMMOVWconst { 9473 break 9474 } 9475 d := v_0.AuxInt 9476 v.reset(OpARMMOVWconst) 9477 v.AuxInt = int64(int32(c - d)) 9478 return true 9479 } 9480 // match: (RSBconst [c] (RSBconst [d] x)) 9481 // cond: 9482 // result: (ADDconst [int64(int32(c-d))] x) 9483 for { 9484 c := v.AuxInt 9485 v_0 := v.Args[0] 9486 if v_0.Op != OpARMRSBconst { 9487 break 9488 } 9489 d := v_0.AuxInt 9490 x := v_0.Args[0] 9491 v.reset(OpARMADDconst) 9492 v.AuxInt = int64(int32(c - d)) 9493 v.AddArg(x) 9494 return true 9495 } 9496 // match: (RSBconst [c] (ADDconst [d] x)) 9497 // cond: 9498 // result: (RSBconst [int64(int32(c-d))] x) 9499 for { 9500 c := v.AuxInt 9501 v_0 := v.Args[0] 9502 if v_0.Op != OpARMADDconst { 9503 break 9504 } 9505 d := v_0.AuxInt 9506 x := v_0.Args[0] 9507 v.reset(OpARMRSBconst) 9508 v.AuxInt = int64(int32(c - d)) 9509 v.AddArg(x) 9510 return true 9511 } 9512 // match: (RSBconst [c] (SUBconst [d] x)) 9513 // cond: 9514 // result: (RSBconst [int64(int32(c+d))] x) 9515 for { 9516 c := v.AuxInt 9517 v_0 := v.Args[0] 9518 if v_0.Op != OpARMSUBconst { 9519 break 9520 } 9521 d := v_0.AuxInt 9522 x := v_0.Args[0] 9523 v.reset(OpARMRSBconst) 9524 v.AuxInt = int64(int32(c + d)) 9525 v.AddArg(x) 9526 return true 9527 } 9528 return false 9529 } 9530 func rewriteValueARM_OpARMRSBshiftLL(v *Value, config *Config) bool { 9531 b := v.Block 9532 _ = b 9533 // match: (RSBshiftLL (MOVWconst [c]) x [d]) 9534 // cond: 9535 // result: (SUBconst [c] (SLLconst <x.Type> x [d])) 9536 for { 9537 d := v.AuxInt 9538 v_0 := v.Args[0] 9539 if v_0.Op != OpARMMOVWconst { 9540 break 9541 } 9542 c := v_0.AuxInt 9543 x := v.Args[1] 9544 v.reset(OpARMSUBconst) 9545 v.AuxInt = c 9546 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 9547 v0.AuxInt = d 9548 v0.AddArg(x) 9549 v.AddArg(v0) 9550 return true 9551 } 9552 // match: (RSBshiftLL x (MOVWconst [c]) [d]) 9553 // cond: 9554 // result: (RSBconst x [int64(uint32(c)<<uint64(d))]) 9555 for { 9556 d := v.AuxInt 9557 x := v.Args[0] 9558 v_1 := v.Args[1] 9559 if v_1.Op != OpARMMOVWconst { 9560 break 9561 } 9562 c := v_1.AuxInt 9563 v.reset(OpARMRSBconst) 9564 v.AuxInt = int64(uint32(c) << uint64(d)) 9565 v.AddArg(x) 9566 return true 9567 } 9568 // match: (RSBshiftLL x (SLLconst x [c]) [d]) 9569 // cond: c==d 9570 // result: (MOVWconst [0]) 9571 for { 9572 d := v.AuxInt 9573 x := v.Args[0] 9574 v_1 := v.Args[1] 9575 if v_1.Op != OpARMSLLconst { 9576 break 9577 } 9578 c := v_1.AuxInt 9579 if x != v_1.Args[0] { 9580 break 9581 } 9582 if !(c == d) { 9583 break 9584 } 9585 v.reset(OpARMMOVWconst) 9586 v.AuxInt = 0 9587 return true 9588 } 9589 return false 9590 } 9591 func rewriteValueARM_OpARMRSBshiftLLreg(v *Value, config *Config) bool { 9592 b := v.Block 9593 _ = b 9594 // match: (RSBshiftLLreg (MOVWconst [c]) x y) 9595 // cond: 9596 // result: (SUBconst [c] (SLL <x.Type> x y)) 9597 for { 9598 v_0 := v.Args[0] 9599 if v_0.Op != OpARMMOVWconst { 9600 break 9601 } 9602 c := v_0.AuxInt 9603 x := v.Args[1] 9604 y := v.Args[2] 9605 v.reset(OpARMSUBconst) 9606 v.AuxInt = c 9607 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 9608 v0.AddArg(x) 9609 v0.AddArg(y) 9610 v.AddArg(v0) 9611 return true 9612 } 9613 // match: (RSBshiftLLreg x y (MOVWconst [c])) 9614 // cond: 9615 // result: (RSBshiftLL x y [c]) 9616 for { 9617 x := v.Args[0] 9618 y := v.Args[1] 9619 v_2 := v.Args[2] 9620 if v_2.Op != OpARMMOVWconst { 9621 break 9622 } 9623 c := v_2.AuxInt 9624 v.reset(OpARMRSBshiftLL) 9625 v.AuxInt = c 9626 v.AddArg(x) 9627 v.AddArg(y) 9628 return true 9629 } 9630 return false 9631 } 9632 func rewriteValueARM_OpARMRSBshiftRA(v *Value, config *Config) bool { 9633 b := v.Block 9634 _ = b 9635 // match: (RSBshiftRA (MOVWconst [c]) x [d]) 9636 // cond: 9637 // result: (SUBconst [c] (SRAconst <x.Type> x [d])) 9638 for { 9639 d := v.AuxInt 9640 v_0 := v.Args[0] 9641 if v_0.Op != OpARMMOVWconst { 9642 break 9643 } 9644 c := v_0.AuxInt 9645 x := v.Args[1] 9646 v.reset(OpARMSUBconst) 9647 v.AuxInt = c 9648 v0 := b.NewValue0(v.Line, OpARMSRAconst, x.Type) 9649 v0.AuxInt = d 9650 v0.AddArg(x) 9651 v.AddArg(v0) 9652 return true 9653 } 9654 // match: (RSBshiftRA x (MOVWconst [c]) [d]) 9655 // cond: 9656 // result: (RSBconst x [int64(int32(c)>>uint64(d))]) 9657 for { 9658 d := v.AuxInt 9659 x := v.Args[0] 9660 v_1 := v.Args[1] 9661 if v_1.Op != OpARMMOVWconst { 9662 break 9663 } 9664 c := v_1.AuxInt 9665 v.reset(OpARMRSBconst) 9666 v.AuxInt = int64(int32(c) >> uint64(d)) 9667 v.AddArg(x) 9668 return true 9669 } 9670 // match: (RSBshiftRA x (SRAconst x [c]) [d]) 9671 // cond: c==d 9672 // result: (MOVWconst [0]) 9673 for { 9674 d := v.AuxInt 9675 x := v.Args[0] 9676 v_1 := v.Args[1] 9677 if v_1.Op != OpARMSRAconst { 9678 break 9679 } 9680 c := v_1.AuxInt 9681 if x != v_1.Args[0] { 9682 break 9683 } 9684 if !(c == d) { 9685 break 9686 } 9687 v.reset(OpARMMOVWconst) 9688 v.AuxInt = 0 9689 return true 9690 } 9691 return false 9692 } 9693 func rewriteValueARM_OpARMRSBshiftRAreg(v *Value, config *Config) bool { 9694 b := v.Block 9695 _ = b 9696 // match: (RSBshiftRAreg (MOVWconst [c]) x y) 9697 // cond: 9698 // result: (SUBconst [c] (SRA <x.Type> x y)) 9699 for { 9700 v_0 := v.Args[0] 9701 if v_0.Op != OpARMMOVWconst { 9702 break 9703 } 9704 c := v_0.AuxInt 9705 x := v.Args[1] 9706 y := v.Args[2] 9707 v.reset(OpARMSUBconst) 9708 v.AuxInt = c 9709 v0 := b.NewValue0(v.Line, OpARMSRA, x.Type) 9710 v0.AddArg(x) 9711 v0.AddArg(y) 9712 v.AddArg(v0) 9713 return true 9714 } 9715 // match: (RSBshiftRAreg x y (MOVWconst [c])) 9716 // cond: 9717 // result: (RSBshiftRA x y [c]) 9718 for { 9719 x := v.Args[0] 9720 y := v.Args[1] 9721 v_2 := v.Args[2] 9722 if v_2.Op != OpARMMOVWconst { 9723 break 9724 } 9725 c := v_2.AuxInt 9726 v.reset(OpARMRSBshiftRA) 9727 v.AuxInt = c 9728 v.AddArg(x) 9729 v.AddArg(y) 9730 return true 9731 } 9732 return false 9733 } 9734 func rewriteValueARM_OpARMRSBshiftRL(v *Value, config *Config) bool { 9735 b := v.Block 9736 _ = b 9737 // match: (RSBshiftRL (MOVWconst [c]) x [d]) 9738 // cond: 9739 // result: (SUBconst [c] (SRLconst <x.Type> x [d])) 9740 for { 9741 d := v.AuxInt 9742 v_0 := v.Args[0] 9743 if v_0.Op != OpARMMOVWconst { 9744 break 9745 } 9746 c := v_0.AuxInt 9747 x := v.Args[1] 9748 v.reset(OpARMSUBconst) 9749 v.AuxInt = c 9750 v0 := b.NewValue0(v.Line, OpARMSRLconst, x.Type) 9751 v0.AuxInt = d 9752 v0.AddArg(x) 9753 v.AddArg(v0) 9754 return true 9755 } 9756 // match: (RSBshiftRL x (MOVWconst [c]) [d]) 9757 // cond: 9758 // result: (RSBconst x [int64(uint32(c)>>uint64(d))]) 9759 for { 9760 d := v.AuxInt 9761 x := v.Args[0] 9762 v_1 := v.Args[1] 9763 if v_1.Op != OpARMMOVWconst { 9764 break 9765 } 9766 c := v_1.AuxInt 9767 v.reset(OpARMRSBconst) 9768 v.AuxInt = int64(uint32(c) >> uint64(d)) 9769 v.AddArg(x) 9770 return true 9771 } 9772 // match: (RSBshiftRL x (SRLconst x [c]) [d]) 9773 // cond: c==d 9774 // result: (MOVWconst [0]) 9775 for { 9776 d := v.AuxInt 9777 x := v.Args[0] 9778 v_1 := v.Args[1] 9779 if v_1.Op != OpARMSRLconst { 9780 break 9781 } 9782 c := v_1.AuxInt 9783 if x != v_1.Args[0] { 9784 break 9785 } 9786 if !(c == d) { 9787 break 9788 } 9789 v.reset(OpARMMOVWconst) 9790 v.AuxInt = 0 9791 return true 9792 } 9793 return false 9794 } 9795 func rewriteValueARM_OpARMRSBshiftRLreg(v *Value, config *Config) bool { 9796 b := v.Block 9797 _ = b 9798 // match: (RSBshiftRLreg (MOVWconst [c]) x y) 9799 // cond: 9800 // result: (SUBconst [c] (SRL <x.Type> x y)) 9801 for { 9802 v_0 := v.Args[0] 9803 if v_0.Op != OpARMMOVWconst { 9804 break 9805 } 9806 c := v_0.AuxInt 9807 x := v.Args[1] 9808 y := v.Args[2] 9809 v.reset(OpARMSUBconst) 9810 v.AuxInt = c 9811 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 9812 v0.AddArg(x) 9813 v0.AddArg(y) 9814 v.AddArg(v0) 9815 return true 9816 } 9817 // match: (RSBshiftRLreg x y (MOVWconst [c])) 9818 // cond: 9819 // result: (RSBshiftRL x y [c]) 9820 for { 9821 x := v.Args[0] 9822 y := v.Args[1] 9823 v_2 := v.Args[2] 9824 if v_2.Op != OpARMMOVWconst { 9825 break 9826 } 9827 c := v_2.AuxInt 9828 v.reset(OpARMRSBshiftRL) 9829 v.AuxInt = c 9830 v.AddArg(x) 9831 v.AddArg(y) 9832 return true 9833 } 9834 return false 9835 } 9836 func rewriteValueARM_OpARMRSCconst(v *Value, config *Config) bool { 9837 b := v.Block 9838 _ = b 9839 // match: (RSCconst [c] (ADDconst [d] x) flags) 9840 // cond: 9841 // result: (RSCconst [int64(int32(c-d))] x flags) 9842 for { 9843 c := v.AuxInt 9844 v_0 := v.Args[0] 9845 if v_0.Op != OpARMADDconst { 9846 break 9847 } 9848 d := v_0.AuxInt 9849 x := v_0.Args[0] 9850 flags := v.Args[1] 9851 v.reset(OpARMRSCconst) 9852 v.AuxInt = int64(int32(c - d)) 9853 v.AddArg(x) 9854 v.AddArg(flags) 9855 return true 9856 } 9857 // match: (RSCconst [c] (SUBconst [d] x) flags) 9858 // cond: 9859 // result: (RSCconst [int64(int32(c+d))] x flags) 9860 for { 9861 c := v.AuxInt 9862 v_0 := v.Args[0] 9863 if v_0.Op != OpARMSUBconst { 9864 break 9865 } 9866 d := v_0.AuxInt 9867 x := v_0.Args[0] 9868 flags := v.Args[1] 9869 v.reset(OpARMRSCconst) 9870 v.AuxInt = int64(int32(c + d)) 9871 v.AddArg(x) 9872 v.AddArg(flags) 9873 return true 9874 } 9875 return false 9876 } 9877 func rewriteValueARM_OpARMRSCshiftLL(v *Value, config *Config) bool { 9878 b := v.Block 9879 _ = b 9880 // match: (RSCshiftLL (MOVWconst [c]) x [d] flags) 9881 // cond: 9882 // result: (SBCconst [c] (SLLconst <x.Type> x [d]) flags) 9883 for { 9884 d := v.AuxInt 9885 v_0 := v.Args[0] 9886 if v_0.Op != OpARMMOVWconst { 9887 break 9888 } 9889 c := v_0.AuxInt 9890 x := v.Args[1] 9891 flags := v.Args[2] 9892 v.reset(OpARMSBCconst) 9893 v.AuxInt = c 9894 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 9895 v0.AuxInt = d 9896 v0.AddArg(x) 9897 v.AddArg(v0) 9898 v.AddArg(flags) 9899 return true 9900 } 9901 // match: (RSCshiftLL x (MOVWconst [c]) [d] flags) 9902 // cond: 9903 // result: (RSCconst x [int64(uint32(c)<<uint64(d))] flags) 9904 for { 9905 d := v.AuxInt 9906 x := v.Args[0] 9907 v_1 := v.Args[1] 9908 if v_1.Op != OpARMMOVWconst { 9909 break 9910 } 9911 c := v_1.AuxInt 9912 flags := v.Args[2] 9913 v.reset(OpARMRSCconst) 9914 v.AuxInt = int64(uint32(c) << uint64(d)) 9915 v.AddArg(x) 9916 v.AddArg(flags) 9917 return true 9918 } 9919 return false 9920 } 9921 func rewriteValueARM_OpARMRSCshiftLLreg(v *Value, config *Config) bool { 9922 b := v.Block 9923 _ = b 9924 // match: (RSCshiftLLreg (MOVWconst [c]) x y flags) 9925 // cond: 9926 // result: (SBCconst [c] (SLL <x.Type> x y) flags) 9927 for { 9928 v_0 := v.Args[0] 9929 if v_0.Op != OpARMMOVWconst { 9930 break 9931 } 9932 c := v_0.AuxInt 9933 x := v.Args[1] 9934 y := v.Args[2] 9935 flags := v.Args[3] 9936 v.reset(OpARMSBCconst) 9937 v.AuxInt = c 9938 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 9939 v0.AddArg(x) 9940 v0.AddArg(y) 9941 v.AddArg(v0) 9942 v.AddArg(flags) 9943 return true 9944 } 9945 // match: (RSCshiftLLreg x y (MOVWconst [c]) flags) 9946 // cond: 9947 // result: (RSCshiftLL x y [c] flags) 9948 for { 9949 x := v.Args[0] 9950 y := v.Args[1] 9951 v_2 := v.Args[2] 9952 if v_2.Op != OpARMMOVWconst { 9953 break 9954 } 9955 c := v_2.AuxInt 9956 flags := v.Args[3] 9957 v.reset(OpARMRSCshiftLL) 9958 v.AuxInt = c 9959 v.AddArg(x) 9960 v.AddArg(y) 9961 v.AddArg(flags) 9962 return true 9963 } 9964 return false 9965 } 9966 func rewriteValueARM_OpARMRSCshiftRA(v *Value, config *Config) bool { 9967 b := v.Block 9968 _ = b 9969 // match: (RSCshiftRA (MOVWconst [c]) x [d] flags) 9970 // cond: 9971 // result: (SBCconst [c] (SRAconst <x.Type> x [d]) flags) 9972 for { 9973 d := v.AuxInt 9974 v_0 := v.Args[0] 9975 if v_0.Op != OpARMMOVWconst { 9976 break 9977 } 9978 c := v_0.AuxInt 9979 x := v.Args[1] 9980 flags := v.Args[2] 9981 v.reset(OpARMSBCconst) 9982 v.AuxInt = c 9983 v0 := b.NewValue0(v.Line, OpARMSRAconst, x.Type) 9984 v0.AuxInt = d 9985 v0.AddArg(x) 9986 v.AddArg(v0) 9987 v.AddArg(flags) 9988 return true 9989 } 9990 // match: (RSCshiftRA x (MOVWconst [c]) [d] flags) 9991 // cond: 9992 // result: (RSCconst x [int64(int32(c)>>uint64(d))] flags) 9993 for { 9994 d := v.AuxInt 9995 x := v.Args[0] 9996 v_1 := v.Args[1] 9997 if v_1.Op != OpARMMOVWconst { 9998 break 9999 } 10000 c := v_1.AuxInt 10001 flags := v.Args[2] 10002 v.reset(OpARMRSCconst) 10003 v.AuxInt = int64(int32(c) >> uint64(d)) 10004 v.AddArg(x) 10005 v.AddArg(flags) 10006 return true 10007 } 10008 return false 10009 } 10010 func rewriteValueARM_OpARMRSCshiftRAreg(v *Value, config *Config) bool { 10011 b := v.Block 10012 _ = b 10013 // match: (RSCshiftRAreg (MOVWconst [c]) x y flags) 10014 // cond: 10015 // result: (SBCconst [c] (SRA <x.Type> x y) flags) 10016 for { 10017 v_0 := v.Args[0] 10018 if v_0.Op != OpARMMOVWconst { 10019 break 10020 } 10021 c := v_0.AuxInt 10022 x := v.Args[1] 10023 y := v.Args[2] 10024 flags := v.Args[3] 10025 v.reset(OpARMSBCconst) 10026 v.AuxInt = c 10027 v0 := b.NewValue0(v.Line, OpARMSRA, x.Type) 10028 v0.AddArg(x) 10029 v0.AddArg(y) 10030 v.AddArg(v0) 10031 v.AddArg(flags) 10032 return true 10033 } 10034 // match: (RSCshiftRAreg x y (MOVWconst [c]) flags) 10035 // cond: 10036 // result: (RSCshiftRA x y [c] flags) 10037 for { 10038 x := v.Args[0] 10039 y := v.Args[1] 10040 v_2 := v.Args[2] 10041 if v_2.Op != OpARMMOVWconst { 10042 break 10043 } 10044 c := v_2.AuxInt 10045 flags := v.Args[3] 10046 v.reset(OpARMRSCshiftRA) 10047 v.AuxInt = c 10048 v.AddArg(x) 10049 v.AddArg(y) 10050 v.AddArg(flags) 10051 return true 10052 } 10053 return false 10054 } 10055 func rewriteValueARM_OpARMRSCshiftRL(v *Value, config *Config) bool { 10056 b := v.Block 10057 _ = b 10058 // match: (RSCshiftRL (MOVWconst [c]) x [d] flags) 10059 // cond: 10060 // result: (SBCconst [c] (SRLconst <x.Type> x [d]) flags) 10061 for { 10062 d := v.AuxInt 10063 v_0 := v.Args[0] 10064 if v_0.Op != OpARMMOVWconst { 10065 break 10066 } 10067 c := v_0.AuxInt 10068 x := v.Args[1] 10069 flags := v.Args[2] 10070 v.reset(OpARMSBCconst) 10071 v.AuxInt = c 10072 v0 := b.NewValue0(v.Line, OpARMSRLconst, x.Type) 10073 v0.AuxInt = d 10074 v0.AddArg(x) 10075 v.AddArg(v0) 10076 v.AddArg(flags) 10077 return true 10078 } 10079 // match: (RSCshiftRL x (MOVWconst [c]) [d] flags) 10080 // cond: 10081 // result: (RSCconst x [int64(uint32(c)>>uint64(d))] flags) 10082 for { 10083 d := v.AuxInt 10084 x := v.Args[0] 10085 v_1 := v.Args[1] 10086 if v_1.Op != OpARMMOVWconst { 10087 break 10088 } 10089 c := v_1.AuxInt 10090 flags := v.Args[2] 10091 v.reset(OpARMRSCconst) 10092 v.AuxInt = int64(uint32(c) >> uint64(d)) 10093 v.AddArg(x) 10094 v.AddArg(flags) 10095 return true 10096 } 10097 return false 10098 } 10099 func rewriteValueARM_OpARMRSCshiftRLreg(v *Value, config *Config) bool { 10100 b := v.Block 10101 _ = b 10102 // match: (RSCshiftRLreg (MOVWconst [c]) x y flags) 10103 // cond: 10104 // result: (SBCconst [c] (SRL <x.Type> x y) flags) 10105 for { 10106 v_0 := v.Args[0] 10107 if v_0.Op != OpARMMOVWconst { 10108 break 10109 } 10110 c := v_0.AuxInt 10111 x := v.Args[1] 10112 y := v.Args[2] 10113 flags := v.Args[3] 10114 v.reset(OpARMSBCconst) 10115 v.AuxInt = c 10116 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 10117 v0.AddArg(x) 10118 v0.AddArg(y) 10119 v.AddArg(v0) 10120 v.AddArg(flags) 10121 return true 10122 } 10123 // match: (RSCshiftRLreg x y (MOVWconst [c]) flags) 10124 // cond: 10125 // result: (RSCshiftRL x y [c] flags) 10126 for { 10127 x := v.Args[0] 10128 y := v.Args[1] 10129 v_2 := v.Args[2] 10130 if v_2.Op != OpARMMOVWconst { 10131 break 10132 } 10133 c := v_2.AuxInt 10134 flags := v.Args[3] 10135 v.reset(OpARMRSCshiftRL) 10136 v.AuxInt = c 10137 v.AddArg(x) 10138 v.AddArg(y) 10139 v.AddArg(flags) 10140 return true 10141 } 10142 return false 10143 } 10144 func rewriteValueARM_OpARMSBC(v *Value, config *Config) bool { 10145 b := v.Block 10146 _ = b 10147 // match: (SBC (MOVWconst [c]) x flags) 10148 // cond: 10149 // result: (RSCconst [c] x flags) 10150 for { 10151 v_0 := v.Args[0] 10152 if v_0.Op != OpARMMOVWconst { 10153 break 10154 } 10155 c := v_0.AuxInt 10156 x := v.Args[1] 10157 flags := v.Args[2] 10158 v.reset(OpARMRSCconst) 10159 v.AuxInt = c 10160 v.AddArg(x) 10161 v.AddArg(flags) 10162 return true 10163 } 10164 // match: (SBC x (MOVWconst [c]) flags) 10165 // cond: 10166 // result: (SBCconst [c] x flags) 10167 for { 10168 x := v.Args[0] 10169 v_1 := v.Args[1] 10170 if v_1.Op != OpARMMOVWconst { 10171 break 10172 } 10173 c := v_1.AuxInt 10174 flags := v.Args[2] 10175 v.reset(OpARMSBCconst) 10176 v.AuxInt = c 10177 v.AddArg(x) 10178 v.AddArg(flags) 10179 return true 10180 } 10181 // match: (SBC x (SLLconst [c] y) flags) 10182 // cond: 10183 // result: (SBCshiftLL x y [c] flags) 10184 for { 10185 x := v.Args[0] 10186 v_1 := v.Args[1] 10187 if v_1.Op != OpARMSLLconst { 10188 break 10189 } 10190 c := v_1.AuxInt 10191 y := v_1.Args[0] 10192 flags := v.Args[2] 10193 v.reset(OpARMSBCshiftLL) 10194 v.AuxInt = c 10195 v.AddArg(x) 10196 v.AddArg(y) 10197 v.AddArg(flags) 10198 return true 10199 } 10200 // match: (SBC (SLLconst [c] y) x flags) 10201 // cond: 10202 // result: (RSCshiftLL x y [c] flags) 10203 for { 10204 v_0 := v.Args[0] 10205 if v_0.Op != OpARMSLLconst { 10206 break 10207 } 10208 c := v_0.AuxInt 10209 y := v_0.Args[0] 10210 x := v.Args[1] 10211 flags := v.Args[2] 10212 v.reset(OpARMRSCshiftLL) 10213 v.AuxInt = c 10214 v.AddArg(x) 10215 v.AddArg(y) 10216 v.AddArg(flags) 10217 return true 10218 } 10219 // match: (SBC x (SRLconst [c] y) flags) 10220 // cond: 10221 // result: (SBCshiftRL x y [c] flags) 10222 for { 10223 x := v.Args[0] 10224 v_1 := v.Args[1] 10225 if v_1.Op != OpARMSRLconst { 10226 break 10227 } 10228 c := v_1.AuxInt 10229 y := v_1.Args[0] 10230 flags := v.Args[2] 10231 v.reset(OpARMSBCshiftRL) 10232 v.AuxInt = c 10233 v.AddArg(x) 10234 v.AddArg(y) 10235 v.AddArg(flags) 10236 return true 10237 } 10238 // match: (SBC (SRLconst [c] y) x flags) 10239 // cond: 10240 // result: (RSCshiftRL x y [c] flags) 10241 for { 10242 v_0 := v.Args[0] 10243 if v_0.Op != OpARMSRLconst { 10244 break 10245 } 10246 c := v_0.AuxInt 10247 y := v_0.Args[0] 10248 x := v.Args[1] 10249 flags := v.Args[2] 10250 v.reset(OpARMRSCshiftRL) 10251 v.AuxInt = c 10252 v.AddArg(x) 10253 v.AddArg(y) 10254 v.AddArg(flags) 10255 return true 10256 } 10257 // match: (SBC x (SRAconst [c] y) flags) 10258 // cond: 10259 // result: (SBCshiftRA x y [c] flags) 10260 for { 10261 x := v.Args[0] 10262 v_1 := v.Args[1] 10263 if v_1.Op != OpARMSRAconst { 10264 break 10265 } 10266 c := v_1.AuxInt 10267 y := v_1.Args[0] 10268 flags := v.Args[2] 10269 v.reset(OpARMSBCshiftRA) 10270 v.AuxInt = c 10271 v.AddArg(x) 10272 v.AddArg(y) 10273 v.AddArg(flags) 10274 return true 10275 } 10276 // match: (SBC (SRAconst [c] y) x flags) 10277 // cond: 10278 // result: (RSCshiftRA x y [c] flags) 10279 for { 10280 v_0 := v.Args[0] 10281 if v_0.Op != OpARMSRAconst { 10282 break 10283 } 10284 c := v_0.AuxInt 10285 y := v_0.Args[0] 10286 x := v.Args[1] 10287 flags := v.Args[2] 10288 v.reset(OpARMRSCshiftRA) 10289 v.AuxInt = c 10290 v.AddArg(x) 10291 v.AddArg(y) 10292 v.AddArg(flags) 10293 return true 10294 } 10295 // match: (SBC x (SLL y z) flags) 10296 // cond: 10297 // result: (SBCshiftLLreg x y z flags) 10298 for { 10299 x := v.Args[0] 10300 v_1 := v.Args[1] 10301 if v_1.Op != OpARMSLL { 10302 break 10303 } 10304 y := v_1.Args[0] 10305 z := v_1.Args[1] 10306 flags := v.Args[2] 10307 v.reset(OpARMSBCshiftLLreg) 10308 v.AddArg(x) 10309 v.AddArg(y) 10310 v.AddArg(z) 10311 v.AddArg(flags) 10312 return true 10313 } 10314 // match: (SBC (SLL y z) x flags) 10315 // cond: 10316 // result: (RSCshiftLLreg x y z flags) 10317 for { 10318 v_0 := v.Args[0] 10319 if v_0.Op != OpARMSLL { 10320 break 10321 } 10322 y := v_0.Args[0] 10323 z := v_0.Args[1] 10324 x := v.Args[1] 10325 flags := v.Args[2] 10326 v.reset(OpARMRSCshiftLLreg) 10327 v.AddArg(x) 10328 v.AddArg(y) 10329 v.AddArg(z) 10330 v.AddArg(flags) 10331 return true 10332 } 10333 // match: (SBC x (SRL y z) flags) 10334 // cond: 10335 // result: (SBCshiftRLreg x y z flags) 10336 for { 10337 x := v.Args[0] 10338 v_1 := v.Args[1] 10339 if v_1.Op != OpARMSRL { 10340 break 10341 } 10342 y := v_1.Args[0] 10343 z := v_1.Args[1] 10344 flags := v.Args[2] 10345 v.reset(OpARMSBCshiftRLreg) 10346 v.AddArg(x) 10347 v.AddArg(y) 10348 v.AddArg(z) 10349 v.AddArg(flags) 10350 return true 10351 } 10352 // match: (SBC (SRL y z) x flags) 10353 // cond: 10354 // result: (RSCshiftRLreg x y z flags) 10355 for { 10356 v_0 := v.Args[0] 10357 if v_0.Op != OpARMSRL { 10358 break 10359 } 10360 y := v_0.Args[0] 10361 z := v_0.Args[1] 10362 x := v.Args[1] 10363 flags := v.Args[2] 10364 v.reset(OpARMRSCshiftRLreg) 10365 v.AddArg(x) 10366 v.AddArg(y) 10367 v.AddArg(z) 10368 v.AddArg(flags) 10369 return true 10370 } 10371 // match: (SBC x (SRA y z) flags) 10372 // cond: 10373 // result: (SBCshiftRAreg x y z flags) 10374 for { 10375 x := v.Args[0] 10376 v_1 := v.Args[1] 10377 if v_1.Op != OpARMSRA { 10378 break 10379 } 10380 y := v_1.Args[0] 10381 z := v_1.Args[1] 10382 flags := v.Args[2] 10383 v.reset(OpARMSBCshiftRAreg) 10384 v.AddArg(x) 10385 v.AddArg(y) 10386 v.AddArg(z) 10387 v.AddArg(flags) 10388 return true 10389 } 10390 // match: (SBC (SRA y z) x flags) 10391 // cond: 10392 // result: (RSCshiftRAreg x y z flags) 10393 for { 10394 v_0 := v.Args[0] 10395 if v_0.Op != OpARMSRA { 10396 break 10397 } 10398 y := v_0.Args[0] 10399 z := v_0.Args[1] 10400 x := v.Args[1] 10401 flags := v.Args[2] 10402 v.reset(OpARMRSCshiftRAreg) 10403 v.AddArg(x) 10404 v.AddArg(y) 10405 v.AddArg(z) 10406 v.AddArg(flags) 10407 return true 10408 } 10409 return false 10410 } 10411 func rewriteValueARM_OpARMSBCconst(v *Value, config *Config) bool { 10412 b := v.Block 10413 _ = b 10414 // match: (SBCconst [c] (ADDconst [d] x) flags) 10415 // cond: 10416 // result: (SBCconst [int64(int32(c-d))] x flags) 10417 for { 10418 c := v.AuxInt 10419 v_0 := v.Args[0] 10420 if v_0.Op != OpARMADDconst { 10421 break 10422 } 10423 d := v_0.AuxInt 10424 x := v_0.Args[0] 10425 flags := v.Args[1] 10426 v.reset(OpARMSBCconst) 10427 v.AuxInt = int64(int32(c - d)) 10428 v.AddArg(x) 10429 v.AddArg(flags) 10430 return true 10431 } 10432 // match: (SBCconst [c] (SUBconst [d] x) flags) 10433 // cond: 10434 // result: (SBCconst [int64(int32(c+d))] x flags) 10435 for { 10436 c := v.AuxInt 10437 v_0 := v.Args[0] 10438 if v_0.Op != OpARMSUBconst { 10439 break 10440 } 10441 d := v_0.AuxInt 10442 x := v_0.Args[0] 10443 flags := v.Args[1] 10444 v.reset(OpARMSBCconst) 10445 v.AuxInt = int64(int32(c + d)) 10446 v.AddArg(x) 10447 v.AddArg(flags) 10448 return true 10449 } 10450 return false 10451 } 10452 func rewriteValueARM_OpARMSBCshiftLL(v *Value, config *Config) bool { 10453 b := v.Block 10454 _ = b 10455 // match: (SBCshiftLL (MOVWconst [c]) x [d] flags) 10456 // cond: 10457 // result: (RSCconst [c] (SLLconst <x.Type> x [d]) flags) 10458 for { 10459 d := v.AuxInt 10460 v_0 := v.Args[0] 10461 if v_0.Op != OpARMMOVWconst { 10462 break 10463 } 10464 c := v_0.AuxInt 10465 x := v.Args[1] 10466 flags := v.Args[2] 10467 v.reset(OpARMRSCconst) 10468 v.AuxInt = c 10469 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 10470 v0.AuxInt = d 10471 v0.AddArg(x) 10472 v.AddArg(v0) 10473 v.AddArg(flags) 10474 return true 10475 } 10476 // match: (SBCshiftLL x (MOVWconst [c]) [d] flags) 10477 // cond: 10478 // result: (SBCconst x [int64(uint32(c)<<uint64(d))] flags) 10479 for { 10480 d := v.AuxInt 10481 x := v.Args[0] 10482 v_1 := v.Args[1] 10483 if v_1.Op != OpARMMOVWconst { 10484 break 10485 } 10486 c := v_1.AuxInt 10487 flags := v.Args[2] 10488 v.reset(OpARMSBCconst) 10489 v.AuxInt = int64(uint32(c) << uint64(d)) 10490 v.AddArg(x) 10491 v.AddArg(flags) 10492 return true 10493 } 10494 return false 10495 } 10496 func rewriteValueARM_OpARMSBCshiftLLreg(v *Value, config *Config) bool { 10497 b := v.Block 10498 _ = b 10499 // match: (SBCshiftLLreg (MOVWconst [c]) x y flags) 10500 // cond: 10501 // result: (RSCconst [c] (SLL <x.Type> x y) flags) 10502 for { 10503 v_0 := v.Args[0] 10504 if v_0.Op != OpARMMOVWconst { 10505 break 10506 } 10507 c := v_0.AuxInt 10508 x := v.Args[1] 10509 y := v.Args[2] 10510 flags := v.Args[3] 10511 v.reset(OpARMRSCconst) 10512 v.AuxInt = c 10513 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 10514 v0.AddArg(x) 10515 v0.AddArg(y) 10516 v.AddArg(v0) 10517 v.AddArg(flags) 10518 return true 10519 } 10520 // match: (SBCshiftLLreg x y (MOVWconst [c]) flags) 10521 // cond: 10522 // result: (SBCshiftLL x y [c] flags) 10523 for { 10524 x := v.Args[0] 10525 y := v.Args[1] 10526 v_2 := v.Args[2] 10527 if v_2.Op != OpARMMOVWconst { 10528 break 10529 } 10530 c := v_2.AuxInt 10531 flags := v.Args[3] 10532 v.reset(OpARMSBCshiftLL) 10533 v.AuxInt = c 10534 v.AddArg(x) 10535 v.AddArg(y) 10536 v.AddArg(flags) 10537 return true 10538 } 10539 return false 10540 } 10541 func rewriteValueARM_OpARMSBCshiftRA(v *Value, config *Config) bool { 10542 b := v.Block 10543 _ = b 10544 // match: (SBCshiftRA (MOVWconst [c]) x [d] flags) 10545 // cond: 10546 // result: (RSCconst [c] (SRAconst <x.Type> x [d]) flags) 10547 for { 10548 d := v.AuxInt 10549 v_0 := v.Args[0] 10550 if v_0.Op != OpARMMOVWconst { 10551 break 10552 } 10553 c := v_0.AuxInt 10554 x := v.Args[1] 10555 flags := v.Args[2] 10556 v.reset(OpARMRSCconst) 10557 v.AuxInt = c 10558 v0 := b.NewValue0(v.Line, OpARMSRAconst, x.Type) 10559 v0.AuxInt = d 10560 v0.AddArg(x) 10561 v.AddArg(v0) 10562 v.AddArg(flags) 10563 return true 10564 } 10565 // match: (SBCshiftRA x (MOVWconst [c]) [d] flags) 10566 // cond: 10567 // result: (SBCconst x [int64(int32(c)>>uint64(d))] flags) 10568 for { 10569 d := v.AuxInt 10570 x := v.Args[0] 10571 v_1 := v.Args[1] 10572 if v_1.Op != OpARMMOVWconst { 10573 break 10574 } 10575 c := v_1.AuxInt 10576 flags := v.Args[2] 10577 v.reset(OpARMSBCconst) 10578 v.AuxInt = int64(int32(c) >> uint64(d)) 10579 v.AddArg(x) 10580 v.AddArg(flags) 10581 return true 10582 } 10583 return false 10584 } 10585 func rewriteValueARM_OpARMSBCshiftRAreg(v *Value, config *Config) bool { 10586 b := v.Block 10587 _ = b 10588 // match: (SBCshiftRAreg (MOVWconst [c]) x y flags) 10589 // cond: 10590 // result: (RSCconst [c] (SRA <x.Type> x y) flags) 10591 for { 10592 v_0 := v.Args[0] 10593 if v_0.Op != OpARMMOVWconst { 10594 break 10595 } 10596 c := v_0.AuxInt 10597 x := v.Args[1] 10598 y := v.Args[2] 10599 flags := v.Args[3] 10600 v.reset(OpARMRSCconst) 10601 v.AuxInt = c 10602 v0 := b.NewValue0(v.Line, OpARMSRA, x.Type) 10603 v0.AddArg(x) 10604 v0.AddArg(y) 10605 v.AddArg(v0) 10606 v.AddArg(flags) 10607 return true 10608 } 10609 // match: (SBCshiftRAreg x y (MOVWconst [c]) flags) 10610 // cond: 10611 // result: (SBCshiftRA x y [c] flags) 10612 for { 10613 x := v.Args[0] 10614 y := v.Args[1] 10615 v_2 := v.Args[2] 10616 if v_2.Op != OpARMMOVWconst { 10617 break 10618 } 10619 c := v_2.AuxInt 10620 flags := v.Args[3] 10621 v.reset(OpARMSBCshiftRA) 10622 v.AuxInt = c 10623 v.AddArg(x) 10624 v.AddArg(y) 10625 v.AddArg(flags) 10626 return true 10627 } 10628 return false 10629 } 10630 func rewriteValueARM_OpARMSBCshiftRL(v *Value, config *Config) bool { 10631 b := v.Block 10632 _ = b 10633 // match: (SBCshiftRL (MOVWconst [c]) x [d] flags) 10634 // cond: 10635 // result: (RSCconst [c] (SRLconst <x.Type> x [d]) flags) 10636 for { 10637 d := v.AuxInt 10638 v_0 := v.Args[0] 10639 if v_0.Op != OpARMMOVWconst { 10640 break 10641 } 10642 c := v_0.AuxInt 10643 x := v.Args[1] 10644 flags := v.Args[2] 10645 v.reset(OpARMRSCconst) 10646 v.AuxInt = c 10647 v0 := b.NewValue0(v.Line, OpARMSRLconst, x.Type) 10648 v0.AuxInt = d 10649 v0.AddArg(x) 10650 v.AddArg(v0) 10651 v.AddArg(flags) 10652 return true 10653 } 10654 // match: (SBCshiftRL x (MOVWconst [c]) [d] flags) 10655 // cond: 10656 // result: (SBCconst x [int64(uint32(c)>>uint64(d))] flags) 10657 for { 10658 d := v.AuxInt 10659 x := v.Args[0] 10660 v_1 := v.Args[1] 10661 if v_1.Op != OpARMMOVWconst { 10662 break 10663 } 10664 c := v_1.AuxInt 10665 flags := v.Args[2] 10666 v.reset(OpARMSBCconst) 10667 v.AuxInt = int64(uint32(c) >> uint64(d)) 10668 v.AddArg(x) 10669 v.AddArg(flags) 10670 return true 10671 } 10672 return false 10673 } 10674 func rewriteValueARM_OpARMSBCshiftRLreg(v *Value, config *Config) bool { 10675 b := v.Block 10676 _ = b 10677 // match: (SBCshiftRLreg (MOVWconst [c]) x y flags) 10678 // cond: 10679 // result: (RSCconst [c] (SRL <x.Type> x y) flags) 10680 for { 10681 v_0 := v.Args[0] 10682 if v_0.Op != OpARMMOVWconst { 10683 break 10684 } 10685 c := v_0.AuxInt 10686 x := v.Args[1] 10687 y := v.Args[2] 10688 flags := v.Args[3] 10689 v.reset(OpARMRSCconst) 10690 v.AuxInt = c 10691 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 10692 v0.AddArg(x) 10693 v0.AddArg(y) 10694 v.AddArg(v0) 10695 v.AddArg(flags) 10696 return true 10697 } 10698 // match: (SBCshiftRLreg x y (MOVWconst [c]) flags) 10699 // cond: 10700 // result: (SBCshiftRL x y [c] flags) 10701 for { 10702 x := v.Args[0] 10703 y := v.Args[1] 10704 v_2 := v.Args[2] 10705 if v_2.Op != OpARMMOVWconst { 10706 break 10707 } 10708 c := v_2.AuxInt 10709 flags := v.Args[3] 10710 v.reset(OpARMSBCshiftRL) 10711 v.AuxInt = c 10712 v.AddArg(x) 10713 v.AddArg(y) 10714 v.AddArg(flags) 10715 return true 10716 } 10717 return false 10718 } 10719 func rewriteValueARM_OpARMSLL(v *Value, config *Config) bool { 10720 b := v.Block 10721 _ = b 10722 // match: (SLL x (MOVWconst [c])) 10723 // cond: 10724 // result: (SLLconst x [c&31]) 10725 for { 10726 x := v.Args[0] 10727 v_1 := v.Args[1] 10728 if v_1.Op != OpARMMOVWconst { 10729 break 10730 } 10731 c := v_1.AuxInt 10732 v.reset(OpARMSLLconst) 10733 v.AuxInt = c & 31 10734 v.AddArg(x) 10735 return true 10736 } 10737 return false 10738 } 10739 func rewriteValueARM_OpARMSLLconst(v *Value, config *Config) bool { 10740 b := v.Block 10741 _ = b 10742 // match: (SLLconst [c] (MOVWconst [d])) 10743 // cond: 10744 // result: (MOVWconst [int64(uint32(d)<<uint64(c))]) 10745 for { 10746 c := v.AuxInt 10747 v_0 := v.Args[0] 10748 if v_0.Op != OpARMMOVWconst { 10749 break 10750 } 10751 d := v_0.AuxInt 10752 v.reset(OpARMMOVWconst) 10753 v.AuxInt = int64(uint32(d) << uint64(c)) 10754 return true 10755 } 10756 return false 10757 } 10758 func rewriteValueARM_OpARMSRA(v *Value, config *Config) bool { 10759 b := v.Block 10760 _ = b 10761 // match: (SRA x (MOVWconst [c])) 10762 // cond: 10763 // result: (SRAconst x [c&31]) 10764 for { 10765 x := v.Args[0] 10766 v_1 := v.Args[1] 10767 if v_1.Op != OpARMMOVWconst { 10768 break 10769 } 10770 c := v_1.AuxInt 10771 v.reset(OpARMSRAconst) 10772 v.AuxInt = c & 31 10773 v.AddArg(x) 10774 return true 10775 } 10776 return false 10777 } 10778 func rewriteValueARM_OpARMSRAcond(v *Value, config *Config) bool { 10779 b := v.Block 10780 _ = b 10781 // match: (SRAcond x _ (FlagEQ)) 10782 // cond: 10783 // result: (SRAconst x [31]) 10784 for { 10785 x := v.Args[0] 10786 v_2 := v.Args[2] 10787 if v_2.Op != OpARMFlagEQ { 10788 break 10789 } 10790 v.reset(OpARMSRAconst) 10791 v.AuxInt = 31 10792 v.AddArg(x) 10793 return true 10794 } 10795 // match: (SRAcond x y (FlagLT_ULT)) 10796 // cond: 10797 // result: (SRA x y) 10798 for { 10799 x := v.Args[0] 10800 y := v.Args[1] 10801 v_2 := v.Args[2] 10802 if v_2.Op != OpARMFlagLT_ULT { 10803 break 10804 } 10805 v.reset(OpARMSRA) 10806 v.AddArg(x) 10807 v.AddArg(y) 10808 return true 10809 } 10810 // match: (SRAcond x _ (FlagLT_UGT)) 10811 // cond: 10812 // result: (SRAconst x [31]) 10813 for { 10814 x := v.Args[0] 10815 v_2 := v.Args[2] 10816 if v_2.Op != OpARMFlagLT_UGT { 10817 break 10818 } 10819 v.reset(OpARMSRAconst) 10820 v.AuxInt = 31 10821 v.AddArg(x) 10822 return true 10823 } 10824 // match: (SRAcond x y (FlagGT_ULT)) 10825 // cond: 10826 // result: (SRA x y) 10827 for { 10828 x := v.Args[0] 10829 y := v.Args[1] 10830 v_2 := v.Args[2] 10831 if v_2.Op != OpARMFlagGT_ULT { 10832 break 10833 } 10834 v.reset(OpARMSRA) 10835 v.AddArg(x) 10836 v.AddArg(y) 10837 return true 10838 } 10839 // match: (SRAcond x _ (FlagGT_UGT)) 10840 // cond: 10841 // result: (SRAconst x [31]) 10842 for { 10843 x := v.Args[0] 10844 v_2 := v.Args[2] 10845 if v_2.Op != OpARMFlagGT_UGT { 10846 break 10847 } 10848 v.reset(OpARMSRAconst) 10849 v.AuxInt = 31 10850 v.AddArg(x) 10851 return true 10852 } 10853 return false 10854 } 10855 func rewriteValueARM_OpARMSRAconst(v *Value, config *Config) bool { 10856 b := v.Block 10857 _ = b 10858 // match: (SRAconst [c] (MOVWconst [d])) 10859 // cond: 10860 // result: (MOVWconst [int64(int32(d)>>uint64(c))]) 10861 for { 10862 c := v.AuxInt 10863 v_0 := v.Args[0] 10864 if v_0.Op != OpARMMOVWconst { 10865 break 10866 } 10867 d := v_0.AuxInt 10868 v.reset(OpARMMOVWconst) 10869 v.AuxInt = int64(int32(d) >> uint64(c)) 10870 return true 10871 } 10872 return false 10873 } 10874 func rewriteValueARM_OpARMSRL(v *Value, config *Config) bool { 10875 b := v.Block 10876 _ = b 10877 // match: (SRL x (MOVWconst [c])) 10878 // cond: 10879 // result: (SRLconst x [c&31]) 10880 for { 10881 x := v.Args[0] 10882 v_1 := v.Args[1] 10883 if v_1.Op != OpARMMOVWconst { 10884 break 10885 } 10886 c := v_1.AuxInt 10887 v.reset(OpARMSRLconst) 10888 v.AuxInt = c & 31 10889 v.AddArg(x) 10890 return true 10891 } 10892 return false 10893 } 10894 func rewriteValueARM_OpARMSRLconst(v *Value, config *Config) bool { 10895 b := v.Block 10896 _ = b 10897 // match: (SRLconst [c] (MOVWconst [d])) 10898 // cond: 10899 // result: (MOVWconst [int64(uint32(d)>>uint64(c))]) 10900 for { 10901 c := v.AuxInt 10902 v_0 := v.Args[0] 10903 if v_0.Op != OpARMMOVWconst { 10904 break 10905 } 10906 d := v_0.AuxInt 10907 v.reset(OpARMMOVWconst) 10908 v.AuxInt = int64(uint32(d) >> uint64(c)) 10909 return true 10910 } 10911 return false 10912 } 10913 func rewriteValueARM_OpARMSUB(v *Value, config *Config) bool { 10914 b := v.Block 10915 _ = b 10916 // match: (SUB (MOVWconst [c]) x) 10917 // cond: 10918 // result: (RSBconst [c] x) 10919 for { 10920 v_0 := v.Args[0] 10921 if v_0.Op != OpARMMOVWconst { 10922 break 10923 } 10924 c := v_0.AuxInt 10925 x := v.Args[1] 10926 v.reset(OpARMRSBconst) 10927 v.AuxInt = c 10928 v.AddArg(x) 10929 return true 10930 } 10931 // match: (SUB x (MOVWconst [c])) 10932 // cond: 10933 // result: (SUBconst [c] x) 10934 for { 10935 x := v.Args[0] 10936 v_1 := v.Args[1] 10937 if v_1.Op != OpARMMOVWconst { 10938 break 10939 } 10940 c := v_1.AuxInt 10941 v.reset(OpARMSUBconst) 10942 v.AuxInt = c 10943 v.AddArg(x) 10944 return true 10945 } 10946 // match: (SUB x (SLLconst [c] y)) 10947 // cond: 10948 // result: (SUBshiftLL x y [c]) 10949 for { 10950 x := v.Args[0] 10951 v_1 := v.Args[1] 10952 if v_1.Op != OpARMSLLconst { 10953 break 10954 } 10955 c := v_1.AuxInt 10956 y := v_1.Args[0] 10957 v.reset(OpARMSUBshiftLL) 10958 v.AuxInt = c 10959 v.AddArg(x) 10960 v.AddArg(y) 10961 return true 10962 } 10963 // match: (SUB (SLLconst [c] y) x) 10964 // cond: 10965 // result: (RSBshiftLL x y [c]) 10966 for { 10967 v_0 := v.Args[0] 10968 if v_0.Op != OpARMSLLconst { 10969 break 10970 } 10971 c := v_0.AuxInt 10972 y := v_0.Args[0] 10973 x := v.Args[1] 10974 v.reset(OpARMRSBshiftLL) 10975 v.AuxInt = c 10976 v.AddArg(x) 10977 v.AddArg(y) 10978 return true 10979 } 10980 // match: (SUB x (SRLconst [c] y)) 10981 // cond: 10982 // result: (SUBshiftRL x y [c]) 10983 for { 10984 x := v.Args[0] 10985 v_1 := v.Args[1] 10986 if v_1.Op != OpARMSRLconst { 10987 break 10988 } 10989 c := v_1.AuxInt 10990 y := v_1.Args[0] 10991 v.reset(OpARMSUBshiftRL) 10992 v.AuxInt = c 10993 v.AddArg(x) 10994 v.AddArg(y) 10995 return true 10996 } 10997 // match: (SUB (SRLconst [c] y) x) 10998 // cond: 10999 // result: (RSBshiftRL x y [c]) 11000 for { 11001 v_0 := v.Args[0] 11002 if v_0.Op != OpARMSRLconst { 11003 break 11004 } 11005 c := v_0.AuxInt 11006 y := v_0.Args[0] 11007 x := v.Args[1] 11008 v.reset(OpARMRSBshiftRL) 11009 v.AuxInt = c 11010 v.AddArg(x) 11011 v.AddArg(y) 11012 return true 11013 } 11014 // match: (SUB x (SRAconst [c] y)) 11015 // cond: 11016 // result: (SUBshiftRA x y [c]) 11017 for { 11018 x := v.Args[0] 11019 v_1 := v.Args[1] 11020 if v_1.Op != OpARMSRAconst { 11021 break 11022 } 11023 c := v_1.AuxInt 11024 y := v_1.Args[0] 11025 v.reset(OpARMSUBshiftRA) 11026 v.AuxInt = c 11027 v.AddArg(x) 11028 v.AddArg(y) 11029 return true 11030 } 11031 // match: (SUB (SRAconst [c] y) x) 11032 // cond: 11033 // result: (RSBshiftRA x y [c]) 11034 for { 11035 v_0 := v.Args[0] 11036 if v_0.Op != OpARMSRAconst { 11037 break 11038 } 11039 c := v_0.AuxInt 11040 y := v_0.Args[0] 11041 x := v.Args[1] 11042 v.reset(OpARMRSBshiftRA) 11043 v.AuxInt = c 11044 v.AddArg(x) 11045 v.AddArg(y) 11046 return true 11047 } 11048 // match: (SUB x (SLL y z)) 11049 // cond: 11050 // result: (SUBshiftLLreg x y z) 11051 for { 11052 x := v.Args[0] 11053 v_1 := v.Args[1] 11054 if v_1.Op != OpARMSLL { 11055 break 11056 } 11057 y := v_1.Args[0] 11058 z := v_1.Args[1] 11059 v.reset(OpARMSUBshiftLLreg) 11060 v.AddArg(x) 11061 v.AddArg(y) 11062 v.AddArg(z) 11063 return true 11064 } 11065 // match: (SUB (SLL y z) x) 11066 // cond: 11067 // result: (RSBshiftLLreg x y z) 11068 for { 11069 v_0 := v.Args[0] 11070 if v_0.Op != OpARMSLL { 11071 break 11072 } 11073 y := v_0.Args[0] 11074 z := v_0.Args[1] 11075 x := v.Args[1] 11076 v.reset(OpARMRSBshiftLLreg) 11077 v.AddArg(x) 11078 v.AddArg(y) 11079 v.AddArg(z) 11080 return true 11081 } 11082 // match: (SUB x (SRL y z)) 11083 // cond: 11084 // result: (SUBshiftRLreg x y z) 11085 for { 11086 x := v.Args[0] 11087 v_1 := v.Args[1] 11088 if v_1.Op != OpARMSRL { 11089 break 11090 } 11091 y := v_1.Args[0] 11092 z := v_1.Args[1] 11093 v.reset(OpARMSUBshiftRLreg) 11094 v.AddArg(x) 11095 v.AddArg(y) 11096 v.AddArg(z) 11097 return true 11098 } 11099 // match: (SUB (SRL y z) x) 11100 // cond: 11101 // result: (RSBshiftRLreg x y z) 11102 for { 11103 v_0 := v.Args[0] 11104 if v_0.Op != OpARMSRL { 11105 break 11106 } 11107 y := v_0.Args[0] 11108 z := v_0.Args[1] 11109 x := v.Args[1] 11110 v.reset(OpARMRSBshiftRLreg) 11111 v.AddArg(x) 11112 v.AddArg(y) 11113 v.AddArg(z) 11114 return true 11115 } 11116 // match: (SUB x (SRA y z)) 11117 // cond: 11118 // result: (SUBshiftRAreg x y z) 11119 for { 11120 x := v.Args[0] 11121 v_1 := v.Args[1] 11122 if v_1.Op != OpARMSRA { 11123 break 11124 } 11125 y := v_1.Args[0] 11126 z := v_1.Args[1] 11127 v.reset(OpARMSUBshiftRAreg) 11128 v.AddArg(x) 11129 v.AddArg(y) 11130 v.AddArg(z) 11131 return true 11132 } 11133 // match: (SUB (SRA y z) x) 11134 // cond: 11135 // result: (RSBshiftRAreg x y z) 11136 for { 11137 v_0 := v.Args[0] 11138 if v_0.Op != OpARMSRA { 11139 break 11140 } 11141 y := v_0.Args[0] 11142 z := v_0.Args[1] 11143 x := v.Args[1] 11144 v.reset(OpARMRSBshiftRAreg) 11145 v.AddArg(x) 11146 v.AddArg(y) 11147 v.AddArg(z) 11148 return true 11149 } 11150 // match: (SUB x x) 11151 // cond: 11152 // result: (MOVWconst [0]) 11153 for { 11154 x := v.Args[0] 11155 if x != v.Args[1] { 11156 break 11157 } 11158 v.reset(OpARMMOVWconst) 11159 v.AuxInt = 0 11160 return true 11161 } 11162 return false 11163 } 11164 func rewriteValueARM_OpARMSUBS(v *Value, config *Config) bool { 11165 b := v.Block 11166 _ = b 11167 // match: (SUBS (MOVWconst [c]) x) 11168 // cond: 11169 // result: (RSBSconst [c] x) 11170 for { 11171 v_0 := v.Args[0] 11172 if v_0.Op != OpARMMOVWconst { 11173 break 11174 } 11175 c := v_0.AuxInt 11176 x := v.Args[1] 11177 v.reset(OpARMRSBSconst) 11178 v.AuxInt = c 11179 v.AddArg(x) 11180 return true 11181 } 11182 // match: (SUBS x (MOVWconst [c])) 11183 // cond: 11184 // result: (SUBSconst [c] x) 11185 for { 11186 x := v.Args[0] 11187 v_1 := v.Args[1] 11188 if v_1.Op != OpARMMOVWconst { 11189 break 11190 } 11191 c := v_1.AuxInt 11192 v.reset(OpARMSUBSconst) 11193 v.AuxInt = c 11194 v.AddArg(x) 11195 return true 11196 } 11197 // match: (SUBS x (SLLconst [c] y)) 11198 // cond: 11199 // result: (SUBSshiftLL x y [c]) 11200 for { 11201 x := v.Args[0] 11202 v_1 := v.Args[1] 11203 if v_1.Op != OpARMSLLconst { 11204 break 11205 } 11206 c := v_1.AuxInt 11207 y := v_1.Args[0] 11208 v.reset(OpARMSUBSshiftLL) 11209 v.AuxInt = c 11210 v.AddArg(x) 11211 v.AddArg(y) 11212 return true 11213 } 11214 // match: (SUBS (SLLconst [c] y) x) 11215 // cond: 11216 // result: (RSBSshiftLL x y [c]) 11217 for { 11218 v_0 := v.Args[0] 11219 if v_0.Op != OpARMSLLconst { 11220 break 11221 } 11222 c := v_0.AuxInt 11223 y := v_0.Args[0] 11224 x := v.Args[1] 11225 v.reset(OpARMRSBSshiftLL) 11226 v.AuxInt = c 11227 v.AddArg(x) 11228 v.AddArg(y) 11229 return true 11230 } 11231 // match: (SUBS x (SRLconst [c] y)) 11232 // cond: 11233 // result: (SUBSshiftRL x y [c]) 11234 for { 11235 x := v.Args[0] 11236 v_1 := v.Args[1] 11237 if v_1.Op != OpARMSRLconst { 11238 break 11239 } 11240 c := v_1.AuxInt 11241 y := v_1.Args[0] 11242 v.reset(OpARMSUBSshiftRL) 11243 v.AuxInt = c 11244 v.AddArg(x) 11245 v.AddArg(y) 11246 return true 11247 } 11248 // match: (SUBS (SRLconst [c] y) x) 11249 // cond: 11250 // result: (RSBSshiftRL x y [c]) 11251 for { 11252 v_0 := v.Args[0] 11253 if v_0.Op != OpARMSRLconst { 11254 break 11255 } 11256 c := v_0.AuxInt 11257 y := v_0.Args[0] 11258 x := v.Args[1] 11259 v.reset(OpARMRSBSshiftRL) 11260 v.AuxInt = c 11261 v.AddArg(x) 11262 v.AddArg(y) 11263 return true 11264 } 11265 // match: (SUBS x (SRAconst [c] y)) 11266 // cond: 11267 // result: (SUBSshiftRA x y [c]) 11268 for { 11269 x := v.Args[0] 11270 v_1 := v.Args[1] 11271 if v_1.Op != OpARMSRAconst { 11272 break 11273 } 11274 c := v_1.AuxInt 11275 y := v_1.Args[0] 11276 v.reset(OpARMSUBSshiftRA) 11277 v.AuxInt = c 11278 v.AddArg(x) 11279 v.AddArg(y) 11280 return true 11281 } 11282 // match: (SUBS (SRAconst [c] y) x) 11283 // cond: 11284 // result: (RSBSshiftRA x y [c]) 11285 for { 11286 v_0 := v.Args[0] 11287 if v_0.Op != OpARMSRAconst { 11288 break 11289 } 11290 c := v_0.AuxInt 11291 y := v_0.Args[0] 11292 x := v.Args[1] 11293 v.reset(OpARMRSBSshiftRA) 11294 v.AuxInt = c 11295 v.AddArg(x) 11296 v.AddArg(y) 11297 return true 11298 } 11299 // match: (SUBS x (SLL y z)) 11300 // cond: 11301 // result: (SUBSshiftLLreg x y z) 11302 for { 11303 x := v.Args[0] 11304 v_1 := v.Args[1] 11305 if v_1.Op != OpARMSLL { 11306 break 11307 } 11308 y := v_1.Args[0] 11309 z := v_1.Args[1] 11310 v.reset(OpARMSUBSshiftLLreg) 11311 v.AddArg(x) 11312 v.AddArg(y) 11313 v.AddArg(z) 11314 return true 11315 } 11316 // match: (SUBS (SLL y z) x) 11317 // cond: 11318 // result: (RSBSshiftLLreg x y z) 11319 for { 11320 v_0 := v.Args[0] 11321 if v_0.Op != OpARMSLL { 11322 break 11323 } 11324 y := v_0.Args[0] 11325 z := v_0.Args[1] 11326 x := v.Args[1] 11327 v.reset(OpARMRSBSshiftLLreg) 11328 v.AddArg(x) 11329 v.AddArg(y) 11330 v.AddArg(z) 11331 return true 11332 } 11333 // match: (SUBS x (SRL y z)) 11334 // cond: 11335 // result: (SUBSshiftRLreg x y z) 11336 for { 11337 x := v.Args[0] 11338 v_1 := v.Args[1] 11339 if v_1.Op != OpARMSRL { 11340 break 11341 } 11342 y := v_1.Args[0] 11343 z := v_1.Args[1] 11344 v.reset(OpARMSUBSshiftRLreg) 11345 v.AddArg(x) 11346 v.AddArg(y) 11347 v.AddArg(z) 11348 return true 11349 } 11350 // match: (SUBS (SRL y z) x) 11351 // cond: 11352 // result: (RSBSshiftRLreg x y z) 11353 for { 11354 v_0 := v.Args[0] 11355 if v_0.Op != OpARMSRL { 11356 break 11357 } 11358 y := v_0.Args[0] 11359 z := v_0.Args[1] 11360 x := v.Args[1] 11361 v.reset(OpARMRSBSshiftRLreg) 11362 v.AddArg(x) 11363 v.AddArg(y) 11364 v.AddArg(z) 11365 return true 11366 } 11367 // match: (SUBS x (SRA y z)) 11368 // cond: 11369 // result: (SUBSshiftRAreg x y z) 11370 for { 11371 x := v.Args[0] 11372 v_1 := v.Args[1] 11373 if v_1.Op != OpARMSRA { 11374 break 11375 } 11376 y := v_1.Args[0] 11377 z := v_1.Args[1] 11378 v.reset(OpARMSUBSshiftRAreg) 11379 v.AddArg(x) 11380 v.AddArg(y) 11381 v.AddArg(z) 11382 return true 11383 } 11384 // match: (SUBS (SRA y z) x) 11385 // cond: 11386 // result: (RSBSshiftRAreg x y z) 11387 for { 11388 v_0 := v.Args[0] 11389 if v_0.Op != OpARMSRA { 11390 break 11391 } 11392 y := v_0.Args[0] 11393 z := v_0.Args[1] 11394 x := v.Args[1] 11395 v.reset(OpARMRSBSshiftRAreg) 11396 v.AddArg(x) 11397 v.AddArg(y) 11398 v.AddArg(z) 11399 return true 11400 } 11401 return false 11402 } 11403 func rewriteValueARM_OpARMSUBSshiftLL(v *Value, config *Config) bool { 11404 b := v.Block 11405 _ = b 11406 // match: (SUBSshiftLL (MOVWconst [c]) x [d]) 11407 // cond: 11408 // result: (RSBSconst [c] (SLLconst <x.Type> x [d])) 11409 for { 11410 d := v.AuxInt 11411 v_0 := v.Args[0] 11412 if v_0.Op != OpARMMOVWconst { 11413 break 11414 } 11415 c := v_0.AuxInt 11416 x := v.Args[1] 11417 v.reset(OpARMRSBSconst) 11418 v.AuxInt = c 11419 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 11420 v0.AuxInt = d 11421 v0.AddArg(x) 11422 v.AddArg(v0) 11423 return true 11424 } 11425 // match: (SUBSshiftLL x (MOVWconst [c]) [d]) 11426 // cond: 11427 // result: (SUBSconst x [int64(uint32(c)<<uint64(d))]) 11428 for { 11429 d := v.AuxInt 11430 x := v.Args[0] 11431 v_1 := v.Args[1] 11432 if v_1.Op != OpARMMOVWconst { 11433 break 11434 } 11435 c := v_1.AuxInt 11436 v.reset(OpARMSUBSconst) 11437 v.AuxInt = int64(uint32(c) << uint64(d)) 11438 v.AddArg(x) 11439 return true 11440 } 11441 return false 11442 } 11443 func rewriteValueARM_OpARMSUBSshiftLLreg(v *Value, config *Config) bool { 11444 b := v.Block 11445 _ = b 11446 // match: (SUBSshiftLLreg (MOVWconst [c]) x y) 11447 // cond: 11448 // result: (RSBSconst [c] (SLL <x.Type> x y)) 11449 for { 11450 v_0 := v.Args[0] 11451 if v_0.Op != OpARMMOVWconst { 11452 break 11453 } 11454 c := v_0.AuxInt 11455 x := v.Args[1] 11456 y := v.Args[2] 11457 v.reset(OpARMRSBSconst) 11458 v.AuxInt = c 11459 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 11460 v0.AddArg(x) 11461 v0.AddArg(y) 11462 v.AddArg(v0) 11463 return true 11464 } 11465 // match: (SUBSshiftLLreg x y (MOVWconst [c])) 11466 // cond: 11467 // result: (SUBSshiftLL x y [c]) 11468 for { 11469 x := v.Args[0] 11470 y := v.Args[1] 11471 v_2 := v.Args[2] 11472 if v_2.Op != OpARMMOVWconst { 11473 break 11474 } 11475 c := v_2.AuxInt 11476 v.reset(OpARMSUBSshiftLL) 11477 v.AuxInt = c 11478 v.AddArg(x) 11479 v.AddArg(y) 11480 return true 11481 } 11482 return false 11483 } 11484 func rewriteValueARM_OpARMSUBSshiftRA(v *Value, config *Config) bool { 11485 b := v.Block 11486 _ = b 11487 // match: (SUBSshiftRA (MOVWconst [c]) x [d]) 11488 // cond: 11489 // result: (RSBSconst [c] (SRAconst <x.Type> x [d])) 11490 for { 11491 d := v.AuxInt 11492 v_0 := v.Args[0] 11493 if v_0.Op != OpARMMOVWconst { 11494 break 11495 } 11496 c := v_0.AuxInt 11497 x := v.Args[1] 11498 v.reset(OpARMRSBSconst) 11499 v.AuxInt = c 11500 v0 := b.NewValue0(v.Line, OpARMSRAconst, x.Type) 11501 v0.AuxInt = d 11502 v0.AddArg(x) 11503 v.AddArg(v0) 11504 return true 11505 } 11506 // match: (SUBSshiftRA x (MOVWconst [c]) [d]) 11507 // cond: 11508 // result: (SUBSconst x [int64(int32(c)>>uint64(d))]) 11509 for { 11510 d := v.AuxInt 11511 x := v.Args[0] 11512 v_1 := v.Args[1] 11513 if v_1.Op != OpARMMOVWconst { 11514 break 11515 } 11516 c := v_1.AuxInt 11517 v.reset(OpARMSUBSconst) 11518 v.AuxInt = int64(int32(c) >> uint64(d)) 11519 v.AddArg(x) 11520 return true 11521 } 11522 return false 11523 } 11524 func rewriteValueARM_OpARMSUBSshiftRAreg(v *Value, config *Config) bool { 11525 b := v.Block 11526 _ = b 11527 // match: (SUBSshiftRAreg (MOVWconst [c]) x y) 11528 // cond: 11529 // result: (RSBSconst [c] (SRA <x.Type> x y)) 11530 for { 11531 v_0 := v.Args[0] 11532 if v_0.Op != OpARMMOVWconst { 11533 break 11534 } 11535 c := v_0.AuxInt 11536 x := v.Args[1] 11537 y := v.Args[2] 11538 v.reset(OpARMRSBSconst) 11539 v.AuxInt = c 11540 v0 := b.NewValue0(v.Line, OpARMSRA, x.Type) 11541 v0.AddArg(x) 11542 v0.AddArg(y) 11543 v.AddArg(v0) 11544 return true 11545 } 11546 // match: (SUBSshiftRAreg x y (MOVWconst [c])) 11547 // cond: 11548 // result: (SUBSshiftRA x y [c]) 11549 for { 11550 x := v.Args[0] 11551 y := v.Args[1] 11552 v_2 := v.Args[2] 11553 if v_2.Op != OpARMMOVWconst { 11554 break 11555 } 11556 c := v_2.AuxInt 11557 v.reset(OpARMSUBSshiftRA) 11558 v.AuxInt = c 11559 v.AddArg(x) 11560 v.AddArg(y) 11561 return true 11562 } 11563 return false 11564 } 11565 func rewriteValueARM_OpARMSUBSshiftRL(v *Value, config *Config) bool { 11566 b := v.Block 11567 _ = b 11568 // match: (SUBSshiftRL (MOVWconst [c]) x [d]) 11569 // cond: 11570 // result: (RSBSconst [c] (SRLconst <x.Type> x [d])) 11571 for { 11572 d := v.AuxInt 11573 v_0 := v.Args[0] 11574 if v_0.Op != OpARMMOVWconst { 11575 break 11576 } 11577 c := v_0.AuxInt 11578 x := v.Args[1] 11579 v.reset(OpARMRSBSconst) 11580 v.AuxInt = c 11581 v0 := b.NewValue0(v.Line, OpARMSRLconst, x.Type) 11582 v0.AuxInt = d 11583 v0.AddArg(x) 11584 v.AddArg(v0) 11585 return true 11586 } 11587 // match: (SUBSshiftRL x (MOVWconst [c]) [d]) 11588 // cond: 11589 // result: (SUBSconst x [int64(uint32(c)>>uint64(d))]) 11590 for { 11591 d := v.AuxInt 11592 x := v.Args[0] 11593 v_1 := v.Args[1] 11594 if v_1.Op != OpARMMOVWconst { 11595 break 11596 } 11597 c := v_1.AuxInt 11598 v.reset(OpARMSUBSconst) 11599 v.AuxInt = int64(uint32(c) >> uint64(d)) 11600 v.AddArg(x) 11601 return true 11602 } 11603 return false 11604 } 11605 func rewriteValueARM_OpARMSUBSshiftRLreg(v *Value, config *Config) bool { 11606 b := v.Block 11607 _ = b 11608 // match: (SUBSshiftRLreg (MOVWconst [c]) x y) 11609 // cond: 11610 // result: (RSBSconst [c] (SRL <x.Type> x y)) 11611 for { 11612 v_0 := v.Args[0] 11613 if v_0.Op != OpARMMOVWconst { 11614 break 11615 } 11616 c := v_0.AuxInt 11617 x := v.Args[1] 11618 y := v.Args[2] 11619 v.reset(OpARMRSBSconst) 11620 v.AuxInt = c 11621 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 11622 v0.AddArg(x) 11623 v0.AddArg(y) 11624 v.AddArg(v0) 11625 return true 11626 } 11627 // match: (SUBSshiftRLreg x y (MOVWconst [c])) 11628 // cond: 11629 // result: (SUBSshiftRL x y [c]) 11630 for { 11631 x := v.Args[0] 11632 y := v.Args[1] 11633 v_2 := v.Args[2] 11634 if v_2.Op != OpARMMOVWconst { 11635 break 11636 } 11637 c := v_2.AuxInt 11638 v.reset(OpARMSUBSshiftRL) 11639 v.AuxInt = c 11640 v.AddArg(x) 11641 v.AddArg(y) 11642 return true 11643 } 11644 return false 11645 } 11646 func rewriteValueARM_OpARMSUBconst(v *Value, config *Config) bool { 11647 b := v.Block 11648 _ = b 11649 // match: (SUBconst [0] x) 11650 // cond: 11651 // result: x 11652 for { 11653 if v.AuxInt != 0 { 11654 break 11655 } 11656 x := v.Args[0] 11657 v.reset(OpCopy) 11658 v.Type = x.Type 11659 v.AddArg(x) 11660 return true 11661 } 11662 // match: (SUBconst [c] (MOVWconst [d])) 11663 // cond: 11664 // result: (MOVWconst [int64(int32(d-c))]) 11665 for { 11666 c := v.AuxInt 11667 v_0 := v.Args[0] 11668 if v_0.Op != OpARMMOVWconst { 11669 break 11670 } 11671 d := v_0.AuxInt 11672 v.reset(OpARMMOVWconst) 11673 v.AuxInt = int64(int32(d - c)) 11674 return true 11675 } 11676 // match: (SUBconst [c] (SUBconst [d] x)) 11677 // cond: 11678 // result: (ADDconst [int64(int32(-c-d))] x) 11679 for { 11680 c := v.AuxInt 11681 v_0 := v.Args[0] 11682 if v_0.Op != OpARMSUBconst { 11683 break 11684 } 11685 d := v_0.AuxInt 11686 x := v_0.Args[0] 11687 v.reset(OpARMADDconst) 11688 v.AuxInt = int64(int32(-c - d)) 11689 v.AddArg(x) 11690 return true 11691 } 11692 // match: (SUBconst [c] (ADDconst [d] x)) 11693 // cond: 11694 // result: (ADDconst [int64(int32(-c+d))] x) 11695 for { 11696 c := v.AuxInt 11697 v_0 := v.Args[0] 11698 if v_0.Op != OpARMADDconst { 11699 break 11700 } 11701 d := v_0.AuxInt 11702 x := v_0.Args[0] 11703 v.reset(OpARMADDconst) 11704 v.AuxInt = int64(int32(-c + d)) 11705 v.AddArg(x) 11706 return true 11707 } 11708 // match: (SUBconst [c] (RSBconst [d] x)) 11709 // cond: 11710 // result: (RSBconst [int64(int32(-c+d))] x) 11711 for { 11712 c := v.AuxInt 11713 v_0 := v.Args[0] 11714 if v_0.Op != OpARMRSBconst { 11715 break 11716 } 11717 d := v_0.AuxInt 11718 x := v_0.Args[0] 11719 v.reset(OpARMRSBconst) 11720 v.AuxInt = int64(int32(-c + d)) 11721 v.AddArg(x) 11722 return true 11723 } 11724 return false 11725 } 11726 func rewriteValueARM_OpARMSUBshiftLL(v *Value, config *Config) bool { 11727 b := v.Block 11728 _ = b 11729 // match: (SUBshiftLL (MOVWconst [c]) x [d]) 11730 // cond: 11731 // result: (RSBconst [c] (SLLconst <x.Type> x [d])) 11732 for { 11733 d := v.AuxInt 11734 v_0 := v.Args[0] 11735 if v_0.Op != OpARMMOVWconst { 11736 break 11737 } 11738 c := v_0.AuxInt 11739 x := v.Args[1] 11740 v.reset(OpARMRSBconst) 11741 v.AuxInt = c 11742 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 11743 v0.AuxInt = d 11744 v0.AddArg(x) 11745 v.AddArg(v0) 11746 return true 11747 } 11748 // match: (SUBshiftLL x (MOVWconst [c]) [d]) 11749 // cond: 11750 // result: (SUBconst x [int64(uint32(c)<<uint64(d))]) 11751 for { 11752 d := v.AuxInt 11753 x := v.Args[0] 11754 v_1 := v.Args[1] 11755 if v_1.Op != OpARMMOVWconst { 11756 break 11757 } 11758 c := v_1.AuxInt 11759 v.reset(OpARMSUBconst) 11760 v.AuxInt = int64(uint32(c) << uint64(d)) 11761 v.AddArg(x) 11762 return true 11763 } 11764 // match: (SUBshiftLL x (SLLconst x [c]) [d]) 11765 // cond: c==d 11766 // result: (MOVWconst [0]) 11767 for { 11768 d := v.AuxInt 11769 x := v.Args[0] 11770 v_1 := v.Args[1] 11771 if v_1.Op != OpARMSLLconst { 11772 break 11773 } 11774 c := v_1.AuxInt 11775 if x != v_1.Args[0] { 11776 break 11777 } 11778 if !(c == d) { 11779 break 11780 } 11781 v.reset(OpARMMOVWconst) 11782 v.AuxInt = 0 11783 return true 11784 } 11785 return false 11786 } 11787 func rewriteValueARM_OpARMSUBshiftLLreg(v *Value, config *Config) bool { 11788 b := v.Block 11789 _ = b 11790 // match: (SUBshiftLLreg (MOVWconst [c]) x y) 11791 // cond: 11792 // result: (RSBconst [c] (SLL <x.Type> x y)) 11793 for { 11794 v_0 := v.Args[0] 11795 if v_0.Op != OpARMMOVWconst { 11796 break 11797 } 11798 c := v_0.AuxInt 11799 x := v.Args[1] 11800 y := v.Args[2] 11801 v.reset(OpARMRSBconst) 11802 v.AuxInt = c 11803 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 11804 v0.AddArg(x) 11805 v0.AddArg(y) 11806 v.AddArg(v0) 11807 return true 11808 } 11809 // match: (SUBshiftLLreg x y (MOVWconst [c])) 11810 // cond: 11811 // result: (SUBshiftLL x y [c]) 11812 for { 11813 x := v.Args[0] 11814 y := v.Args[1] 11815 v_2 := v.Args[2] 11816 if v_2.Op != OpARMMOVWconst { 11817 break 11818 } 11819 c := v_2.AuxInt 11820 v.reset(OpARMSUBshiftLL) 11821 v.AuxInt = c 11822 v.AddArg(x) 11823 v.AddArg(y) 11824 return true 11825 } 11826 return false 11827 } 11828 func rewriteValueARM_OpARMSUBshiftRA(v *Value, config *Config) bool { 11829 b := v.Block 11830 _ = b 11831 // match: (SUBshiftRA (MOVWconst [c]) x [d]) 11832 // cond: 11833 // result: (RSBconst [c] (SRAconst <x.Type> x [d])) 11834 for { 11835 d := v.AuxInt 11836 v_0 := v.Args[0] 11837 if v_0.Op != OpARMMOVWconst { 11838 break 11839 } 11840 c := v_0.AuxInt 11841 x := v.Args[1] 11842 v.reset(OpARMRSBconst) 11843 v.AuxInt = c 11844 v0 := b.NewValue0(v.Line, OpARMSRAconst, x.Type) 11845 v0.AuxInt = d 11846 v0.AddArg(x) 11847 v.AddArg(v0) 11848 return true 11849 } 11850 // match: (SUBshiftRA x (MOVWconst [c]) [d]) 11851 // cond: 11852 // result: (SUBconst x [int64(int32(c)>>uint64(d))]) 11853 for { 11854 d := v.AuxInt 11855 x := v.Args[0] 11856 v_1 := v.Args[1] 11857 if v_1.Op != OpARMMOVWconst { 11858 break 11859 } 11860 c := v_1.AuxInt 11861 v.reset(OpARMSUBconst) 11862 v.AuxInt = int64(int32(c) >> uint64(d)) 11863 v.AddArg(x) 11864 return true 11865 } 11866 // match: (SUBshiftRA x (SRAconst x [c]) [d]) 11867 // cond: c==d 11868 // result: (MOVWconst [0]) 11869 for { 11870 d := v.AuxInt 11871 x := v.Args[0] 11872 v_1 := v.Args[1] 11873 if v_1.Op != OpARMSRAconst { 11874 break 11875 } 11876 c := v_1.AuxInt 11877 if x != v_1.Args[0] { 11878 break 11879 } 11880 if !(c == d) { 11881 break 11882 } 11883 v.reset(OpARMMOVWconst) 11884 v.AuxInt = 0 11885 return true 11886 } 11887 return false 11888 } 11889 func rewriteValueARM_OpARMSUBshiftRAreg(v *Value, config *Config) bool { 11890 b := v.Block 11891 _ = b 11892 // match: (SUBshiftRAreg (MOVWconst [c]) x y) 11893 // cond: 11894 // result: (RSBconst [c] (SRA <x.Type> x y)) 11895 for { 11896 v_0 := v.Args[0] 11897 if v_0.Op != OpARMMOVWconst { 11898 break 11899 } 11900 c := v_0.AuxInt 11901 x := v.Args[1] 11902 y := v.Args[2] 11903 v.reset(OpARMRSBconst) 11904 v.AuxInt = c 11905 v0 := b.NewValue0(v.Line, OpARMSRA, x.Type) 11906 v0.AddArg(x) 11907 v0.AddArg(y) 11908 v.AddArg(v0) 11909 return true 11910 } 11911 // match: (SUBshiftRAreg x y (MOVWconst [c])) 11912 // cond: 11913 // result: (SUBshiftRA x y [c]) 11914 for { 11915 x := v.Args[0] 11916 y := v.Args[1] 11917 v_2 := v.Args[2] 11918 if v_2.Op != OpARMMOVWconst { 11919 break 11920 } 11921 c := v_2.AuxInt 11922 v.reset(OpARMSUBshiftRA) 11923 v.AuxInt = c 11924 v.AddArg(x) 11925 v.AddArg(y) 11926 return true 11927 } 11928 return false 11929 } 11930 func rewriteValueARM_OpARMSUBshiftRL(v *Value, config *Config) bool { 11931 b := v.Block 11932 _ = b 11933 // match: (SUBshiftRL (MOVWconst [c]) x [d]) 11934 // cond: 11935 // result: (RSBconst [c] (SRLconst <x.Type> x [d])) 11936 for { 11937 d := v.AuxInt 11938 v_0 := v.Args[0] 11939 if v_0.Op != OpARMMOVWconst { 11940 break 11941 } 11942 c := v_0.AuxInt 11943 x := v.Args[1] 11944 v.reset(OpARMRSBconst) 11945 v.AuxInt = c 11946 v0 := b.NewValue0(v.Line, OpARMSRLconst, x.Type) 11947 v0.AuxInt = d 11948 v0.AddArg(x) 11949 v.AddArg(v0) 11950 return true 11951 } 11952 // match: (SUBshiftRL x (MOVWconst [c]) [d]) 11953 // cond: 11954 // result: (SUBconst x [int64(uint32(c)>>uint64(d))]) 11955 for { 11956 d := v.AuxInt 11957 x := v.Args[0] 11958 v_1 := v.Args[1] 11959 if v_1.Op != OpARMMOVWconst { 11960 break 11961 } 11962 c := v_1.AuxInt 11963 v.reset(OpARMSUBconst) 11964 v.AuxInt = int64(uint32(c) >> uint64(d)) 11965 v.AddArg(x) 11966 return true 11967 } 11968 // match: (SUBshiftRL x (SRLconst x [c]) [d]) 11969 // cond: c==d 11970 // result: (MOVWconst [0]) 11971 for { 11972 d := v.AuxInt 11973 x := v.Args[0] 11974 v_1 := v.Args[1] 11975 if v_1.Op != OpARMSRLconst { 11976 break 11977 } 11978 c := v_1.AuxInt 11979 if x != v_1.Args[0] { 11980 break 11981 } 11982 if !(c == d) { 11983 break 11984 } 11985 v.reset(OpARMMOVWconst) 11986 v.AuxInt = 0 11987 return true 11988 } 11989 return false 11990 } 11991 func rewriteValueARM_OpARMSUBshiftRLreg(v *Value, config *Config) bool { 11992 b := v.Block 11993 _ = b 11994 // match: (SUBshiftRLreg (MOVWconst [c]) x y) 11995 // cond: 11996 // result: (RSBconst [c] (SRL <x.Type> x y)) 11997 for { 11998 v_0 := v.Args[0] 11999 if v_0.Op != OpARMMOVWconst { 12000 break 12001 } 12002 c := v_0.AuxInt 12003 x := v.Args[1] 12004 y := v.Args[2] 12005 v.reset(OpARMRSBconst) 12006 v.AuxInt = c 12007 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 12008 v0.AddArg(x) 12009 v0.AddArg(y) 12010 v.AddArg(v0) 12011 return true 12012 } 12013 // match: (SUBshiftRLreg x y (MOVWconst [c])) 12014 // cond: 12015 // result: (SUBshiftRL x y [c]) 12016 for { 12017 x := v.Args[0] 12018 y := v.Args[1] 12019 v_2 := v.Args[2] 12020 if v_2.Op != OpARMMOVWconst { 12021 break 12022 } 12023 c := v_2.AuxInt 12024 v.reset(OpARMSUBshiftRL) 12025 v.AuxInt = c 12026 v.AddArg(x) 12027 v.AddArg(y) 12028 return true 12029 } 12030 return false 12031 } 12032 func rewriteValueARM_OpARMXOR(v *Value, config *Config) bool { 12033 b := v.Block 12034 _ = b 12035 // match: (XOR (MOVWconst [c]) x) 12036 // cond: 12037 // result: (XORconst [c] x) 12038 for { 12039 v_0 := v.Args[0] 12040 if v_0.Op != OpARMMOVWconst { 12041 break 12042 } 12043 c := v_0.AuxInt 12044 x := v.Args[1] 12045 v.reset(OpARMXORconst) 12046 v.AuxInt = c 12047 v.AddArg(x) 12048 return true 12049 } 12050 // match: (XOR x (MOVWconst [c])) 12051 // cond: 12052 // result: (XORconst [c] x) 12053 for { 12054 x := v.Args[0] 12055 v_1 := v.Args[1] 12056 if v_1.Op != OpARMMOVWconst { 12057 break 12058 } 12059 c := v_1.AuxInt 12060 v.reset(OpARMXORconst) 12061 v.AuxInt = c 12062 v.AddArg(x) 12063 return true 12064 } 12065 // match: (XOR x (SLLconst [c] y)) 12066 // cond: 12067 // result: (XORshiftLL x y [c]) 12068 for { 12069 x := v.Args[0] 12070 v_1 := v.Args[1] 12071 if v_1.Op != OpARMSLLconst { 12072 break 12073 } 12074 c := v_1.AuxInt 12075 y := v_1.Args[0] 12076 v.reset(OpARMXORshiftLL) 12077 v.AuxInt = c 12078 v.AddArg(x) 12079 v.AddArg(y) 12080 return true 12081 } 12082 // match: (XOR (SLLconst [c] y) x) 12083 // cond: 12084 // result: (XORshiftLL x y [c]) 12085 for { 12086 v_0 := v.Args[0] 12087 if v_0.Op != OpARMSLLconst { 12088 break 12089 } 12090 c := v_0.AuxInt 12091 y := v_0.Args[0] 12092 x := v.Args[1] 12093 v.reset(OpARMXORshiftLL) 12094 v.AuxInt = c 12095 v.AddArg(x) 12096 v.AddArg(y) 12097 return true 12098 } 12099 // match: (XOR x (SRLconst [c] y)) 12100 // cond: 12101 // result: (XORshiftRL x y [c]) 12102 for { 12103 x := v.Args[0] 12104 v_1 := v.Args[1] 12105 if v_1.Op != OpARMSRLconst { 12106 break 12107 } 12108 c := v_1.AuxInt 12109 y := v_1.Args[0] 12110 v.reset(OpARMXORshiftRL) 12111 v.AuxInt = c 12112 v.AddArg(x) 12113 v.AddArg(y) 12114 return true 12115 } 12116 // match: (XOR (SRLconst [c] y) x) 12117 // cond: 12118 // result: (XORshiftRL x y [c]) 12119 for { 12120 v_0 := v.Args[0] 12121 if v_0.Op != OpARMSRLconst { 12122 break 12123 } 12124 c := v_0.AuxInt 12125 y := v_0.Args[0] 12126 x := v.Args[1] 12127 v.reset(OpARMXORshiftRL) 12128 v.AuxInt = c 12129 v.AddArg(x) 12130 v.AddArg(y) 12131 return true 12132 } 12133 // match: (XOR x (SRAconst [c] y)) 12134 // cond: 12135 // result: (XORshiftRA x y [c]) 12136 for { 12137 x := v.Args[0] 12138 v_1 := v.Args[1] 12139 if v_1.Op != OpARMSRAconst { 12140 break 12141 } 12142 c := v_1.AuxInt 12143 y := v_1.Args[0] 12144 v.reset(OpARMXORshiftRA) 12145 v.AuxInt = c 12146 v.AddArg(x) 12147 v.AddArg(y) 12148 return true 12149 } 12150 // match: (XOR (SRAconst [c] y) x) 12151 // cond: 12152 // result: (XORshiftRA x y [c]) 12153 for { 12154 v_0 := v.Args[0] 12155 if v_0.Op != OpARMSRAconst { 12156 break 12157 } 12158 c := v_0.AuxInt 12159 y := v_0.Args[0] 12160 x := v.Args[1] 12161 v.reset(OpARMXORshiftRA) 12162 v.AuxInt = c 12163 v.AddArg(x) 12164 v.AddArg(y) 12165 return true 12166 } 12167 // match: (XOR x (SLL y z)) 12168 // cond: 12169 // result: (XORshiftLLreg x y z) 12170 for { 12171 x := v.Args[0] 12172 v_1 := v.Args[1] 12173 if v_1.Op != OpARMSLL { 12174 break 12175 } 12176 y := v_1.Args[0] 12177 z := v_1.Args[1] 12178 v.reset(OpARMXORshiftLLreg) 12179 v.AddArg(x) 12180 v.AddArg(y) 12181 v.AddArg(z) 12182 return true 12183 } 12184 // match: (XOR (SLL y z) x) 12185 // cond: 12186 // result: (XORshiftLLreg x y z) 12187 for { 12188 v_0 := v.Args[0] 12189 if v_0.Op != OpARMSLL { 12190 break 12191 } 12192 y := v_0.Args[0] 12193 z := v_0.Args[1] 12194 x := v.Args[1] 12195 v.reset(OpARMXORshiftLLreg) 12196 v.AddArg(x) 12197 v.AddArg(y) 12198 v.AddArg(z) 12199 return true 12200 } 12201 // match: (XOR x (SRL y z)) 12202 // cond: 12203 // result: (XORshiftRLreg x y z) 12204 for { 12205 x := v.Args[0] 12206 v_1 := v.Args[1] 12207 if v_1.Op != OpARMSRL { 12208 break 12209 } 12210 y := v_1.Args[0] 12211 z := v_1.Args[1] 12212 v.reset(OpARMXORshiftRLreg) 12213 v.AddArg(x) 12214 v.AddArg(y) 12215 v.AddArg(z) 12216 return true 12217 } 12218 // match: (XOR (SRL y z) x) 12219 // cond: 12220 // result: (XORshiftRLreg x y z) 12221 for { 12222 v_0 := v.Args[0] 12223 if v_0.Op != OpARMSRL { 12224 break 12225 } 12226 y := v_0.Args[0] 12227 z := v_0.Args[1] 12228 x := v.Args[1] 12229 v.reset(OpARMXORshiftRLreg) 12230 v.AddArg(x) 12231 v.AddArg(y) 12232 v.AddArg(z) 12233 return true 12234 } 12235 // match: (XOR x (SRA y z)) 12236 // cond: 12237 // result: (XORshiftRAreg x y z) 12238 for { 12239 x := v.Args[0] 12240 v_1 := v.Args[1] 12241 if v_1.Op != OpARMSRA { 12242 break 12243 } 12244 y := v_1.Args[0] 12245 z := v_1.Args[1] 12246 v.reset(OpARMXORshiftRAreg) 12247 v.AddArg(x) 12248 v.AddArg(y) 12249 v.AddArg(z) 12250 return true 12251 } 12252 // match: (XOR (SRA y z) x) 12253 // cond: 12254 // result: (XORshiftRAreg x y z) 12255 for { 12256 v_0 := v.Args[0] 12257 if v_0.Op != OpARMSRA { 12258 break 12259 } 12260 y := v_0.Args[0] 12261 z := v_0.Args[1] 12262 x := v.Args[1] 12263 v.reset(OpARMXORshiftRAreg) 12264 v.AddArg(x) 12265 v.AddArg(y) 12266 v.AddArg(z) 12267 return true 12268 } 12269 // match: (XOR x x) 12270 // cond: 12271 // result: (MOVWconst [0]) 12272 for { 12273 x := v.Args[0] 12274 if x != v.Args[1] { 12275 break 12276 } 12277 v.reset(OpARMMOVWconst) 12278 v.AuxInt = 0 12279 return true 12280 } 12281 return false 12282 } 12283 func rewriteValueARM_OpARMXORconst(v *Value, config *Config) bool { 12284 b := v.Block 12285 _ = b 12286 // match: (XORconst [0] x) 12287 // cond: 12288 // result: x 12289 for { 12290 if v.AuxInt != 0 { 12291 break 12292 } 12293 x := v.Args[0] 12294 v.reset(OpCopy) 12295 v.Type = x.Type 12296 v.AddArg(x) 12297 return true 12298 } 12299 // match: (XORconst [c] (MOVWconst [d])) 12300 // cond: 12301 // result: (MOVWconst [c^d]) 12302 for { 12303 c := v.AuxInt 12304 v_0 := v.Args[0] 12305 if v_0.Op != OpARMMOVWconst { 12306 break 12307 } 12308 d := v_0.AuxInt 12309 v.reset(OpARMMOVWconst) 12310 v.AuxInt = c ^ d 12311 return true 12312 } 12313 // match: (XORconst [c] (XORconst [d] x)) 12314 // cond: 12315 // result: (XORconst [c^d] x) 12316 for { 12317 c := v.AuxInt 12318 v_0 := v.Args[0] 12319 if v_0.Op != OpARMXORconst { 12320 break 12321 } 12322 d := v_0.AuxInt 12323 x := v_0.Args[0] 12324 v.reset(OpARMXORconst) 12325 v.AuxInt = c ^ d 12326 v.AddArg(x) 12327 return true 12328 } 12329 return false 12330 } 12331 func rewriteValueARM_OpARMXORshiftLL(v *Value, config *Config) bool { 12332 b := v.Block 12333 _ = b 12334 // match: (XORshiftLL (MOVWconst [c]) x [d]) 12335 // cond: 12336 // result: (XORconst [c] (SLLconst <x.Type> x [d])) 12337 for { 12338 d := v.AuxInt 12339 v_0 := v.Args[0] 12340 if v_0.Op != OpARMMOVWconst { 12341 break 12342 } 12343 c := v_0.AuxInt 12344 x := v.Args[1] 12345 v.reset(OpARMXORconst) 12346 v.AuxInt = c 12347 v0 := b.NewValue0(v.Line, OpARMSLLconst, x.Type) 12348 v0.AuxInt = d 12349 v0.AddArg(x) 12350 v.AddArg(v0) 12351 return true 12352 } 12353 // match: (XORshiftLL x (MOVWconst [c]) [d]) 12354 // cond: 12355 // result: (XORconst x [int64(uint32(c)<<uint64(d))]) 12356 for { 12357 d := v.AuxInt 12358 x := v.Args[0] 12359 v_1 := v.Args[1] 12360 if v_1.Op != OpARMMOVWconst { 12361 break 12362 } 12363 c := v_1.AuxInt 12364 v.reset(OpARMXORconst) 12365 v.AuxInt = int64(uint32(c) << uint64(d)) 12366 v.AddArg(x) 12367 return true 12368 } 12369 // match: (XORshiftLL x (SLLconst x [c]) [d]) 12370 // cond: c==d 12371 // result: (MOVWconst [0]) 12372 for { 12373 d := v.AuxInt 12374 x := v.Args[0] 12375 v_1 := v.Args[1] 12376 if v_1.Op != OpARMSLLconst { 12377 break 12378 } 12379 c := v_1.AuxInt 12380 if x != v_1.Args[0] { 12381 break 12382 } 12383 if !(c == d) { 12384 break 12385 } 12386 v.reset(OpARMMOVWconst) 12387 v.AuxInt = 0 12388 return true 12389 } 12390 return false 12391 } 12392 func rewriteValueARM_OpARMXORshiftLLreg(v *Value, config *Config) bool { 12393 b := v.Block 12394 _ = b 12395 // match: (XORshiftLLreg (MOVWconst [c]) x y) 12396 // cond: 12397 // result: (XORconst [c] (SLL <x.Type> x y)) 12398 for { 12399 v_0 := v.Args[0] 12400 if v_0.Op != OpARMMOVWconst { 12401 break 12402 } 12403 c := v_0.AuxInt 12404 x := v.Args[1] 12405 y := v.Args[2] 12406 v.reset(OpARMXORconst) 12407 v.AuxInt = c 12408 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 12409 v0.AddArg(x) 12410 v0.AddArg(y) 12411 v.AddArg(v0) 12412 return true 12413 } 12414 // match: (XORshiftLLreg x y (MOVWconst [c])) 12415 // cond: 12416 // result: (XORshiftLL x y [c]) 12417 for { 12418 x := v.Args[0] 12419 y := v.Args[1] 12420 v_2 := v.Args[2] 12421 if v_2.Op != OpARMMOVWconst { 12422 break 12423 } 12424 c := v_2.AuxInt 12425 v.reset(OpARMXORshiftLL) 12426 v.AuxInt = c 12427 v.AddArg(x) 12428 v.AddArg(y) 12429 return true 12430 } 12431 return false 12432 } 12433 func rewriteValueARM_OpARMXORshiftRA(v *Value, config *Config) bool { 12434 b := v.Block 12435 _ = b 12436 // match: (XORshiftRA (MOVWconst [c]) x [d]) 12437 // cond: 12438 // result: (XORconst [c] (SRAconst <x.Type> x [d])) 12439 for { 12440 d := v.AuxInt 12441 v_0 := v.Args[0] 12442 if v_0.Op != OpARMMOVWconst { 12443 break 12444 } 12445 c := v_0.AuxInt 12446 x := v.Args[1] 12447 v.reset(OpARMXORconst) 12448 v.AuxInt = c 12449 v0 := b.NewValue0(v.Line, OpARMSRAconst, x.Type) 12450 v0.AuxInt = d 12451 v0.AddArg(x) 12452 v.AddArg(v0) 12453 return true 12454 } 12455 // match: (XORshiftRA x (MOVWconst [c]) [d]) 12456 // cond: 12457 // result: (XORconst x [int64(int32(c)>>uint64(d))]) 12458 for { 12459 d := v.AuxInt 12460 x := v.Args[0] 12461 v_1 := v.Args[1] 12462 if v_1.Op != OpARMMOVWconst { 12463 break 12464 } 12465 c := v_1.AuxInt 12466 v.reset(OpARMXORconst) 12467 v.AuxInt = int64(int32(c) >> uint64(d)) 12468 v.AddArg(x) 12469 return true 12470 } 12471 // match: (XORshiftRA x (SRAconst x [c]) [d]) 12472 // cond: c==d 12473 // result: (MOVWconst [0]) 12474 for { 12475 d := v.AuxInt 12476 x := v.Args[0] 12477 v_1 := v.Args[1] 12478 if v_1.Op != OpARMSRAconst { 12479 break 12480 } 12481 c := v_1.AuxInt 12482 if x != v_1.Args[0] { 12483 break 12484 } 12485 if !(c == d) { 12486 break 12487 } 12488 v.reset(OpARMMOVWconst) 12489 v.AuxInt = 0 12490 return true 12491 } 12492 return false 12493 } 12494 func rewriteValueARM_OpARMXORshiftRAreg(v *Value, config *Config) bool { 12495 b := v.Block 12496 _ = b 12497 // match: (XORshiftRAreg (MOVWconst [c]) x y) 12498 // cond: 12499 // result: (XORconst [c] (SRA <x.Type> x y)) 12500 for { 12501 v_0 := v.Args[0] 12502 if v_0.Op != OpARMMOVWconst { 12503 break 12504 } 12505 c := v_0.AuxInt 12506 x := v.Args[1] 12507 y := v.Args[2] 12508 v.reset(OpARMXORconst) 12509 v.AuxInt = c 12510 v0 := b.NewValue0(v.Line, OpARMSRA, x.Type) 12511 v0.AddArg(x) 12512 v0.AddArg(y) 12513 v.AddArg(v0) 12514 return true 12515 } 12516 // match: (XORshiftRAreg x y (MOVWconst [c])) 12517 // cond: 12518 // result: (XORshiftRA x y [c]) 12519 for { 12520 x := v.Args[0] 12521 y := v.Args[1] 12522 v_2 := v.Args[2] 12523 if v_2.Op != OpARMMOVWconst { 12524 break 12525 } 12526 c := v_2.AuxInt 12527 v.reset(OpARMXORshiftRA) 12528 v.AuxInt = c 12529 v.AddArg(x) 12530 v.AddArg(y) 12531 return true 12532 } 12533 return false 12534 } 12535 func rewriteValueARM_OpARMXORshiftRL(v *Value, config *Config) bool { 12536 b := v.Block 12537 _ = b 12538 // match: (XORshiftRL (MOVWconst [c]) x [d]) 12539 // cond: 12540 // result: (XORconst [c] (SRLconst <x.Type> x [d])) 12541 for { 12542 d := v.AuxInt 12543 v_0 := v.Args[0] 12544 if v_0.Op != OpARMMOVWconst { 12545 break 12546 } 12547 c := v_0.AuxInt 12548 x := v.Args[1] 12549 v.reset(OpARMXORconst) 12550 v.AuxInt = c 12551 v0 := b.NewValue0(v.Line, OpARMSRLconst, x.Type) 12552 v0.AuxInt = d 12553 v0.AddArg(x) 12554 v.AddArg(v0) 12555 return true 12556 } 12557 // match: (XORshiftRL x (MOVWconst [c]) [d]) 12558 // cond: 12559 // result: (XORconst x [int64(uint32(c)>>uint64(d))]) 12560 for { 12561 d := v.AuxInt 12562 x := v.Args[0] 12563 v_1 := v.Args[1] 12564 if v_1.Op != OpARMMOVWconst { 12565 break 12566 } 12567 c := v_1.AuxInt 12568 v.reset(OpARMXORconst) 12569 v.AuxInt = int64(uint32(c) >> uint64(d)) 12570 v.AddArg(x) 12571 return true 12572 } 12573 // match: (XORshiftRL x (SRLconst x [c]) [d]) 12574 // cond: c==d 12575 // result: (MOVWconst [0]) 12576 for { 12577 d := v.AuxInt 12578 x := v.Args[0] 12579 v_1 := v.Args[1] 12580 if v_1.Op != OpARMSRLconst { 12581 break 12582 } 12583 c := v_1.AuxInt 12584 if x != v_1.Args[0] { 12585 break 12586 } 12587 if !(c == d) { 12588 break 12589 } 12590 v.reset(OpARMMOVWconst) 12591 v.AuxInt = 0 12592 return true 12593 } 12594 return false 12595 } 12596 func rewriteValueARM_OpARMXORshiftRLreg(v *Value, config *Config) bool { 12597 b := v.Block 12598 _ = b 12599 // match: (XORshiftRLreg (MOVWconst [c]) x y) 12600 // cond: 12601 // result: (XORconst [c] (SRL <x.Type> x y)) 12602 for { 12603 v_0 := v.Args[0] 12604 if v_0.Op != OpARMMOVWconst { 12605 break 12606 } 12607 c := v_0.AuxInt 12608 x := v.Args[1] 12609 y := v.Args[2] 12610 v.reset(OpARMXORconst) 12611 v.AuxInt = c 12612 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 12613 v0.AddArg(x) 12614 v0.AddArg(y) 12615 v.AddArg(v0) 12616 return true 12617 } 12618 // match: (XORshiftRLreg x y (MOVWconst [c])) 12619 // cond: 12620 // result: (XORshiftRL x y [c]) 12621 for { 12622 x := v.Args[0] 12623 y := v.Args[1] 12624 v_2 := v.Args[2] 12625 if v_2.Op != OpARMMOVWconst { 12626 break 12627 } 12628 c := v_2.AuxInt 12629 v.reset(OpARMXORshiftRL) 12630 v.AuxInt = c 12631 v.AddArg(x) 12632 v.AddArg(y) 12633 return true 12634 } 12635 return false 12636 } 12637 func rewriteValueARM_OpAdd16(v *Value, config *Config) bool { 12638 b := v.Block 12639 _ = b 12640 // match: (Add16 x y) 12641 // cond: 12642 // result: (ADD x y) 12643 for { 12644 x := v.Args[0] 12645 y := v.Args[1] 12646 v.reset(OpARMADD) 12647 v.AddArg(x) 12648 v.AddArg(y) 12649 return true 12650 } 12651 } 12652 func rewriteValueARM_OpAdd32(v *Value, config *Config) bool { 12653 b := v.Block 12654 _ = b 12655 // match: (Add32 x y) 12656 // cond: 12657 // result: (ADD x y) 12658 for { 12659 x := v.Args[0] 12660 y := v.Args[1] 12661 v.reset(OpARMADD) 12662 v.AddArg(x) 12663 v.AddArg(y) 12664 return true 12665 } 12666 } 12667 func rewriteValueARM_OpAdd32F(v *Value, config *Config) bool { 12668 b := v.Block 12669 _ = b 12670 // match: (Add32F x y) 12671 // cond: 12672 // result: (ADDF x y) 12673 for { 12674 x := v.Args[0] 12675 y := v.Args[1] 12676 v.reset(OpARMADDF) 12677 v.AddArg(x) 12678 v.AddArg(y) 12679 return true 12680 } 12681 } 12682 func rewriteValueARM_OpAdd32carry(v *Value, config *Config) bool { 12683 b := v.Block 12684 _ = b 12685 // match: (Add32carry x y) 12686 // cond: 12687 // result: (ADDS x y) 12688 for { 12689 x := v.Args[0] 12690 y := v.Args[1] 12691 v.reset(OpARMADDS) 12692 v.AddArg(x) 12693 v.AddArg(y) 12694 return true 12695 } 12696 } 12697 func rewriteValueARM_OpAdd32withcarry(v *Value, config *Config) bool { 12698 b := v.Block 12699 _ = b 12700 // match: (Add32withcarry x y c) 12701 // cond: 12702 // result: (ADC x y c) 12703 for { 12704 x := v.Args[0] 12705 y := v.Args[1] 12706 c := v.Args[2] 12707 v.reset(OpARMADC) 12708 v.AddArg(x) 12709 v.AddArg(y) 12710 v.AddArg(c) 12711 return true 12712 } 12713 } 12714 func rewriteValueARM_OpAdd64F(v *Value, config *Config) bool { 12715 b := v.Block 12716 _ = b 12717 // match: (Add64F x y) 12718 // cond: 12719 // result: (ADDD x y) 12720 for { 12721 x := v.Args[0] 12722 y := v.Args[1] 12723 v.reset(OpARMADDD) 12724 v.AddArg(x) 12725 v.AddArg(y) 12726 return true 12727 } 12728 } 12729 func rewriteValueARM_OpAdd8(v *Value, config *Config) bool { 12730 b := v.Block 12731 _ = b 12732 // match: (Add8 x y) 12733 // cond: 12734 // result: (ADD x y) 12735 for { 12736 x := v.Args[0] 12737 y := v.Args[1] 12738 v.reset(OpARMADD) 12739 v.AddArg(x) 12740 v.AddArg(y) 12741 return true 12742 } 12743 } 12744 func rewriteValueARM_OpAddPtr(v *Value, config *Config) bool { 12745 b := v.Block 12746 _ = b 12747 // match: (AddPtr x y) 12748 // cond: 12749 // result: (ADD x y) 12750 for { 12751 x := v.Args[0] 12752 y := v.Args[1] 12753 v.reset(OpARMADD) 12754 v.AddArg(x) 12755 v.AddArg(y) 12756 return true 12757 } 12758 } 12759 func rewriteValueARM_OpAddr(v *Value, config *Config) bool { 12760 b := v.Block 12761 _ = b 12762 // match: (Addr {sym} base) 12763 // cond: 12764 // result: (MOVWaddr {sym} base) 12765 for { 12766 sym := v.Aux 12767 base := v.Args[0] 12768 v.reset(OpARMMOVWaddr) 12769 v.Aux = sym 12770 v.AddArg(base) 12771 return true 12772 } 12773 } 12774 func rewriteValueARM_OpAnd16(v *Value, config *Config) bool { 12775 b := v.Block 12776 _ = b 12777 // match: (And16 x y) 12778 // cond: 12779 // result: (AND x y) 12780 for { 12781 x := v.Args[0] 12782 y := v.Args[1] 12783 v.reset(OpARMAND) 12784 v.AddArg(x) 12785 v.AddArg(y) 12786 return true 12787 } 12788 } 12789 func rewriteValueARM_OpAnd32(v *Value, config *Config) bool { 12790 b := v.Block 12791 _ = b 12792 // match: (And32 x y) 12793 // cond: 12794 // result: (AND x y) 12795 for { 12796 x := v.Args[0] 12797 y := v.Args[1] 12798 v.reset(OpARMAND) 12799 v.AddArg(x) 12800 v.AddArg(y) 12801 return true 12802 } 12803 } 12804 func rewriteValueARM_OpAnd8(v *Value, config *Config) bool { 12805 b := v.Block 12806 _ = b 12807 // match: (And8 x y) 12808 // cond: 12809 // result: (AND x y) 12810 for { 12811 x := v.Args[0] 12812 y := v.Args[1] 12813 v.reset(OpARMAND) 12814 v.AddArg(x) 12815 v.AddArg(y) 12816 return true 12817 } 12818 } 12819 func rewriteValueARM_OpAndB(v *Value, config *Config) bool { 12820 b := v.Block 12821 _ = b 12822 // match: (AndB x y) 12823 // cond: 12824 // result: (AND x y) 12825 for { 12826 x := v.Args[0] 12827 y := v.Args[1] 12828 v.reset(OpARMAND) 12829 v.AddArg(x) 12830 v.AddArg(y) 12831 return true 12832 } 12833 } 12834 func rewriteValueARM_OpClosureCall(v *Value, config *Config) bool { 12835 b := v.Block 12836 _ = b 12837 // match: (ClosureCall [argwid] entry closure mem) 12838 // cond: 12839 // result: (CALLclosure [argwid] entry closure mem) 12840 for { 12841 argwid := v.AuxInt 12842 entry := v.Args[0] 12843 closure := v.Args[1] 12844 mem := v.Args[2] 12845 v.reset(OpARMCALLclosure) 12846 v.AuxInt = argwid 12847 v.AddArg(entry) 12848 v.AddArg(closure) 12849 v.AddArg(mem) 12850 return true 12851 } 12852 } 12853 func rewriteValueARM_OpCom16(v *Value, config *Config) bool { 12854 b := v.Block 12855 _ = b 12856 // match: (Com16 x) 12857 // cond: 12858 // result: (MVN x) 12859 for { 12860 x := v.Args[0] 12861 v.reset(OpARMMVN) 12862 v.AddArg(x) 12863 return true 12864 } 12865 } 12866 func rewriteValueARM_OpCom32(v *Value, config *Config) bool { 12867 b := v.Block 12868 _ = b 12869 // match: (Com32 x) 12870 // cond: 12871 // result: (MVN x) 12872 for { 12873 x := v.Args[0] 12874 v.reset(OpARMMVN) 12875 v.AddArg(x) 12876 return true 12877 } 12878 } 12879 func rewriteValueARM_OpCom8(v *Value, config *Config) bool { 12880 b := v.Block 12881 _ = b 12882 // match: (Com8 x) 12883 // cond: 12884 // result: (MVN x) 12885 for { 12886 x := v.Args[0] 12887 v.reset(OpARMMVN) 12888 v.AddArg(x) 12889 return true 12890 } 12891 } 12892 func rewriteValueARM_OpConst16(v *Value, config *Config) bool { 12893 b := v.Block 12894 _ = b 12895 // match: (Const16 [val]) 12896 // cond: 12897 // result: (MOVWconst [val]) 12898 for { 12899 val := v.AuxInt 12900 v.reset(OpARMMOVWconst) 12901 v.AuxInt = val 12902 return true 12903 } 12904 } 12905 func rewriteValueARM_OpConst32(v *Value, config *Config) bool { 12906 b := v.Block 12907 _ = b 12908 // match: (Const32 [val]) 12909 // cond: 12910 // result: (MOVWconst [val]) 12911 for { 12912 val := v.AuxInt 12913 v.reset(OpARMMOVWconst) 12914 v.AuxInt = val 12915 return true 12916 } 12917 } 12918 func rewriteValueARM_OpConst32F(v *Value, config *Config) bool { 12919 b := v.Block 12920 _ = b 12921 // match: (Const32F [val]) 12922 // cond: 12923 // result: (MOVFconst [val]) 12924 for { 12925 val := v.AuxInt 12926 v.reset(OpARMMOVFconst) 12927 v.AuxInt = val 12928 return true 12929 } 12930 } 12931 func rewriteValueARM_OpConst64F(v *Value, config *Config) bool { 12932 b := v.Block 12933 _ = b 12934 // match: (Const64F [val]) 12935 // cond: 12936 // result: (MOVDconst [val]) 12937 for { 12938 val := v.AuxInt 12939 v.reset(OpARMMOVDconst) 12940 v.AuxInt = val 12941 return true 12942 } 12943 } 12944 func rewriteValueARM_OpConst8(v *Value, config *Config) bool { 12945 b := v.Block 12946 _ = b 12947 // match: (Const8 [val]) 12948 // cond: 12949 // result: (MOVWconst [val]) 12950 for { 12951 val := v.AuxInt 12952 v.reset(OpARMMOVWconst) 12953 v.AuxInt = val 12954 return true 12955 } 12956 } 12957 func rewriteValueARM_OpConstBool(v *Value, config *Config) bool { 12958 b := v.Block 12959 _ = b 12960 // match: (ConstBool [b]) 12961 // cond: 12962 // result: (MOVWconst [b]) 12963 for { 12964 b := v.AuxInt 12965 v.reset(OpARMMOVWconst) 12966 v.AuxInt = b 12967 return true 12968 } 12969 } 12970 func rewriteValueARM_OpConstNil(v *Value, config *Config) bool { 12971 b := v.Block 12972 _ = b 12973 // match: (ConstNil) 12974 // cond: 12975 // result: (MOVWconst [0]) 12976 for { 12977 v.reset(OpARMMOVWconst) 12978 v.AuxInt = 0 12979 return true 12980 } 12981 } 12982 func rewriteValueARM_OpConvert(v *Value, config *Config) bool { 12983 b := v.Block 12984 _ = b 12985 // match: (Convert x mem) 12986 // cond: 12987 // result: (MOVWconvert x mem) 12988 for { 12989 x := v.Args[0] 12990 mem := v.Args[1] 12991 v.reset(OpARMMOVWconvert) 12992 v.AddArg(x) 12993 v.AddArg(mem) 12994 return true 12995 } 12996 } 12997 func rewriteValueARM_OpCvt32Fto32(v *Value, config *Config) bool { 12998 b := v.Block 12999 _ = b 13000 // match: (Cvt32Fto32 x) 13001 // cond: 13002 // result: (MOVFW x) 13003 for { 13004 x := v.Args[0] 13005 v.reset(OpARMMOVFW) 13006 v.AddArg(x) 13007 return true 13008 } 13009 } 13010 func rewriteValueARM_OpCvt32Fto32U(v *Value, config *Config) bool { 13011 b := v.Block 13012 _ = b 13013 // match: (Cvt32Fto32U x) 13014 // cond: 13015 // result: (MOVFWU x) 13016 for { 13017 x := v.Args[0] 13018 v.reset(OpARMMOVFWU) 13019 v.AddArg(x) 13020 return true 13021 } 13022 } 13023 func rewriteValueARM_OpCvt32Fto64F(v *Value, config *Config) bool { 13024 b := v.Block 13025 _ = b 13026 // match: (Cvt32Fto64F x) 13027 // cond: 13028 // result: (MOVFD x) 13029 for { 13030 x := v.Args[0] 13031 v.reset(OpARMMOVFD) 13032 v.AddArg(x) 13033 return true 13034 } 13035 } 13036 func rewriteValueARM_OpCvt32Uto32F(v *Value, config *Config) bool { 13037 b := v.Block 13038 _ = b 13039 // match: (Cvt32Uto32F x) 13040 // cond: 13041 // result: (MOVWUF x) 13042 for { 13043 x := v.Args[0] 13044 v.reset(OpARMMOVWUF) 13045 v.AddArg(x) 13046 return true 13047 } 13048 } 13049 func rewriteValueARM_OpCvt32Uto64F(v *Value, config *Config) bool { 13050 b := v.Block 13051 _ = b 13052 // match: (Cvt32Uto64F x) 13053 // cond: 13054 // result: (MOVWUD x) 13055 for { 13056 x := v.Args[0] 13057 v.reset(OpARMMOVWUD) 13058 v.AddArg(x) 13059 return true 13060 } 13061 } 13062 func rewriteValueARM_OpCvt32to32F(v *Value, config *Config) bool { 13063 b := v.Block 13064 _ = b 13065 // match: (Cvt32to32F x) 13066 // cond: 13067 // result: (MOVWF x) 13068 for { 13069 x := v.Args[0] 13070 v.reset(OpARMMOVWF) 13071 v.AddArg(x) 13072 return true 13073 } 13074 } 13075 func rewriteValueARM_OpCvt32to64F(v *Value, config *Config) bool { 13076 b := v.Block 13077 _ = b 13078 // match: (Cvt32to64F x) 13079 // cond: 13080 // result: (MOVWD x) 13081 for { 13082 x := v.Args[0] 13083 v.reset(OpARMMOVWD) 13084 v.AddArg(x) 13085 return true 13086 } 13087 } 13088 func rewriteValueARM_OpCvt64Fto32(v *Value, config *Config) bool { 13089 b := v.Block 13090 _ = b 13091 // match: (Cvt64Fto32 x) 13092 // cond: 13093 // result: (MOVDW x) 13094 for { 13095 x := v.Args[0] 13096 v.reset(OpARMMOVDW) 13097 v.AddArg(x) 13098 return true 13099 } 13100 } 13101 func rewriteValueARM_OpCvt64Fto32F(v *Value, config *Config) bool { 13102 b := v.Block 13103 _ = b 13104 // match: (Cvt64Fto32F x) 13105 // cond: 13106 // result: (MOVDF x) 13107 for { 13108 x := v.Args[0] 13109 v.reset(OpARMMOVDF) 13110 v.AddArg(x) 13111 return true 13112 } 13113 } 13114 func rewriteValueARM_OpCvt64Fto32U(v *Value, config *Config) bool { 13115 b := v.Block 13116 _ = b 13117 // match: (Cvt64Fto32U x) 13118 // cond: 13119 // result: (MOVDWU x) 13120 for { 13121 x := v.Args[0] 13122 v.reset(OpARMMOVDWU) 13123 v.AddArg(x) 13124 return true 13125 } 13126 } 13127 func rewriteValueARM_OpDeferCall(v *Value, config *Config) bool { 13128 b := v.Block 13129 _ = b 13130 // match: (DeferCall [argwid] mem) 13131 // cond: 13132 // result: (CALLdefer [argwid] mem) 13133 for { 13134 argwid := v.AuxInt 13135 mem := v.Args[0] 13136 v.reset(OpARMCALLdefer) 13137 v.AuxInt = argwid 13138 v.AddArg(mem) 13139 return true 13140 } 13141 } 13142 func rewriteValueARM_OpDiv16(v *Value, config *Config) bool { 13143 b := v.Block 13144 _ = b 13145 // match: (Div16 x y) 13146 // cond: 13147 // result: (DIV (SignExt16to32 x) (SignExt16to32 y)) 13148 for { 13149 x := v.Args[0] 13150 y := v.Args[1] 13151 v.reset(OpARMDIV) 13152 v0 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 13153 v0.AddArg(x) 13154 v.AddArg(v0) 13155 v1 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 13156 v1.AddArg(y) 13157 v.AddArg(v1) 13158 return true 13159 } 13160 } 13161 func rewriteValueARM_OpDiv16u(v *Value, config *Config) bool { 13162 b := v.Block 13163 _ = b 13164 // match: (Div16u x y) 13165 // cond: 13166 // result: (DIVU (ZeroExt16to32 x) (ZeroExt16to32 y)) 13167 for { 13168 x := v.Args[0] 13169 y := v.Args[1] 13170 v.reset(OpARMDIVU) 13171 v0 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 13172 v0.AddArg(x) 13173 v.AddArg(v0) 13174 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 13175 v1.AddArg(y) 13176 v.AddArg(v1) 13177 return true 13178 } 13179 } 13180 func rewriteValueARM_OpDiv32(v *Value, config *Config) bool { 13181 b := v.Block 13182 _ = b 13183 // match: (Div32 x y) 13184 // cond: 13185 // result: (DIV x y) 13186 for { 13187 x := v.Args[0] 13188 y := v.Args[1] 13189 v.reset(OpARMDIV) 13190 v.AddArg(x) 13191 v.AddArg(y) 13192 return true 13193 } 13194 } 13195 func rewriteValueARM_OpDiv32F(v *Value, config *Config) bool { 13196 b := v.Block 13197 _ = b 13198 // match: (Div32F x y) 13199 // cond: 13200 // result: (DIVF x y) 13201 for { 13202 x := v.Args[0] 13203 y := v.Args[1] 13204 v.reset(OpARMDIVF) 13205 v.AddArg(x) 13206 v.AddArg(y) 13207 return true 13208 } 13209 } 13210 func rewriteValueARM_OpDiv32u(v *Value, config *Config) bool { 13211 b := v.Block 13212 _ = b 13213 // match: (Div32u x y) 13214 // cond: 13215 // result: (DIVU x y) 13216 for { 13217 x := v.Args[0] 13218 y := v.Args[1] 13219 v.reset(OpARMDIVU) 13220 v.AddArg(x) 13221 v.AddArg(y) 13222 return true 13223 } 13224 } 13225 func rewriteValueARM_OpDiv64F(v *Value, config *Config) bool { 13226 b := v.Block 13227 _ = b 13228 // match: (Div64F x y) 13229 // cond: 13230 // result: (DIVD x y) 13231 for { 13232 x := v.Args[0] 13233 y := v.Args[1] 13234 v.reset(OpARMDIVD) 13235 v.AddArg(x) 13236 v.AddArg(y) 13237 return true 13238 } 13239 } 13240 func rewriteValueARM_OpDiv8(v *Value, config *Config) bool { 13241 b := v.Block 13242 _ = b 13243 // match: (Div8 x y) 13244 // cond: 13245 // result: (DIV (SignExt8to32 x) (SignExt8to32 y)) 13246 for { 13247 x := v.Args[0] 13248 y := v.Args[1] 13249 v.reset(OpARMDIV) 13250 v0 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 13251 v0.AddArg(x) 13252 v.AddArg(v0) 13253 v1 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 13254 v1.AddArg(y) 13255 v.AddArg(v1) 13256 return true 13257 } 13258 } 13259 func rewriteValueARM_OpDiv8u(v *Value, config *Config) bool { 13260 b := v.Block 13261 _ = b 13262 // match: (Div8u x y) 13263 // cond: 13264 // result: (DIVU (ZeroExt8to32 x) (ZeroExt8to32 y)) 13265 for { 13266 x := v.Args[0] 13267 y := v.Args[1] 13268 v.reset(OpARMDIVU) 13269 v0 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 13270 v0.AddArg(x) 13271 v.AddArg(v0) 13272 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 13273 v1.AddArg(y) 13274 v.AddArg(v1) 13275 return true 13276 } 13277 } 13278 func rewriteValueARM_OpEq16(v *Value, config *Config) bool { 13279 b := v.Block 13280 _ = b 13281 // match: (Eq16 x y) 13282 // cond: 13283 // result: (Equal (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 13284 for { 13285 x := v.Args[0] 13286 y := v.Args[1] 13287 v.reset(OpARMEqual) 13288 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13289 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 13290 v1.AddArg(x) 13291 v0.AddArg(v1) 13292 v2 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 13293 v2.AddArg(y) 13294 v0.AddArg(v2) 13295 v.AddArg(v0) 13296 return true 13297 } 13298 } 13299 func rewriteValueARM_OpEq32(v *Value, config *Config) bool { 13300 b := v.Block 13301 _ = b 13302 // match: (Eq32 x y) 13303 // cond: 13304 // result: (Equal (CMP x y)) 13305 for { 13306 x := v.Args[0] 13307 y := v.Args[1] 13308 v.reset(OpARMEqual) 13309 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13310 v0.AddArg(x) 13311 v0.AddArg(y) 13312 v.AddArg(v0) 13313 return true 13314 } 13315 } 13316 func rewriteValueARM_OpEq32F(v *Value, config *Config) bool { 13317 b := v.Block 13318 _ = b 13319 // match: (Eq32F x y) 13320 // cond: 13321 // result: (Equal (CMPF x y)) 13322 for { 13323 x := v.Args[0] 13324 y := v.Args[1] 13325 v.reset(OpARMEqual) 13326 v0 := b.NewValue0(v.Line, OpARMCMPF, TypeFlags) 13327 v0.AddArg(x) 13328 v0.AddArg(y) 13329 v.AddArg(v0) 13330 return true 13331 } 13332 } 13333 func rewriteValueARM_OpEq64F(v *Value, config *Config) bool { 13334 b := v.Block 13335 _ = b 13336 // match: (Eq64F x y) 13337 // cond: 13338 // result: (Equal (CMPD x y)) 13339 for { 13340 x := v.Args[0] 13341 y := v.Args[1] 13342 v.reset(OpARMEqual) 13343 v0 := b.NewValue0(v.Line, OpARMCMPD, TypeFlags) 13344 v0.AddArg(x) 13345 v0.AddArg(y) 13346 v.AddArg(v0) 13347 return true 13348 } 13349 } 13350 func rewriteValueARM_OpEq8(v *Value, config *Config) bool { 13351 b := v.Block 13352 _ = b 13353 // match: (Eq8 x y) 13354 // cond: 13355 // result: (Equal (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 13356 for { 13357 x := v.Args[0] 13358 y := v.Args[1] 13359 v.reset(OpARMEqual) 13360 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13361 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 13362 v1.AddArg(x) 13363 v0.AddArg(v1) 13364 v2 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 13365 v2.AddArg(y) 13366 v0.AddArg(v2) 13367 v.AddArg(v0) 13368 return true 13369 } 13370 } 13371 func rewriteValueARM_OpEqB(v *Value, config *Config) bool { 13372 b := v.Block 13373 _ = b 13374 // match: (EqB x y) 13375 // cond: 13376 // result: (XORconst [1] (XOR <config.fe.TypeBool()> x y)) 13377 for { 13378 x := v.Args[0] 13379 y := v.Args[1] 13380 v.reset(OpARMXORconst) 13381 v.AuxInt = 1 13382 v0 := b.NewValue0(v.Line, OpARMXOR, config.fe.TypeBool()) 13383 v0.AddArg(x) 13384 v0.AddArg(y) 13385 v.AddArg(v0) 13386 return true 13387 } 13388 } 13389 func rewriteValueARM_OpEqPtr(v *Value, config *Config) bool { 13390 b := v.Block 13391 _ = b 13392 // match: (EqPtr x y) 13393 // cond: 13394 // result: (Equal (CMP x y)) 13395 for { 13396 x := v.Args[0] 13397 y := v.Args[1] 13398 v.reset(OpARMEqual) 13399 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13400 v0.AddArg(x) 13401 v0.AddArg(y) 13402 v.AddArg(v0) 13403 return true 13404 } 13405 } 13406 func rewriteValueARM_OpGeq16(v *Value, config *Config) bool { 13407 b := v.Block 13408 _ = b 13409 // match: (Geq16 x y) 13410 // cond: 13411 // result: (GreaterEqual (CMP (SignExt16to32 x) (SignExt16to32 y))) 13412 for { 13413 x := v.Args[0] 13414 y := v.Args[1] 13415 v.reset(OpARMGreaterEqual) 13416 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13417 v1 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 13418 v1.AddArg(x) 13419 v0.AddArg(v1) 13420 v2 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 13421 v2.AddArg(y) 13422 v0.AddArg(v2) 13423 v.AddArg(v0) 13424 return true 13425 } 13426 } 13427 func rewriteValueARM_OpGeq16U(v *Value, config *Config) bool { 13428 b := v.Block 13429 _ = b 13430 // match: (Geq16U x y) 13431 // cond: 13432 // result: (GreaterEqualU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 13433 for { 13434 x := v.Args[0] 13435 y := v.Args[1] 13436 v.reset(OpARMGreaterEqualU) 13437 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13438 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 13439 v1.AddArg(x) 13440 v0.AddArg(v1) 13441 v2 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 13442 v2.AddArg(y) 13443 v0.AddArg(v2) 13444 v.AddArg(v0) 13445 return true 13446 } 13447 } 13448 func rewriteValueARM_OpGeq32(v *Value, config *Config) bool { 13449 b := v.Block 13450 _ = b 13451 // match: (Geq32 x y) 13452 // cond: 13453 // result: (GreaterEqual (CMP x y)) 13454 for { 13455 x := v.Args[0] 13456 y := v.Args[1] 13457 v.reset(OpARMGreaterEqual) 13458 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13459 v0.AddArg(x) 13460 v0.AddArg(y) 13461 v.AddArg(v0) 13462 return true 13463 } 13464 } 13465 func rewriteValueARM_OpGeq32F(v *Value, config *Config) bool { 13466 b := v.Block 13467 _ = b 13468 // match: (Geq32F x y) 13469 // cond: 13470 // result: (GreaterEqual (CMPF x y)) 13471 for { 13472 x := v.Args[0] 13473 y := v.Args[1] 13474 v.reset(OpARMGreaterEqual) 13475 v0 := b.NewValue0(v.Line, OpARMCMPF, TypeFlags) 13476 v0.AddArg(x) 13477 v0.AddArg(y) 13478 v.AddArg(v0) 13479 return true 13480 } 13481 } 13482 func rewriteValueARM_OpGeq32U(v *Value, config *Config) bool { 13483 b := v.Block 13484 _ = b 13485 // match: (Geq32U x y) 13486 // cond: 13487 // result: (GreaterEqualU (CMP x y)) 13488 for { 13489 x := v.Args[0] 13490 y := v.Args[1] 13491 v.reset(OpARMGreaterEqualU) 13492 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13493 v0.AddArg(x) 13494 v0.AddArg(y) 13495 v.AddArg(v0) 13496 return true 13497 } 13498 } 13499 func rewriteValueARM_OpGeq64F(v *Value, config *Config) bool { 13500 b := v.Block 13501 _ = b 13502 // match: (Geq64F x y) 13503 // cond: 13504 // result: (GreaterEqual (CMPD x y)) 13505 for { 13506 x := v.Args[0] 13507 y := v.Args[1] 13508 v.reset(OpARMGreaterEqual) 13509 v0 := b.NewValue0(v.Line, OpARMCMPD, TypeFlags) 13510 v0.AddArg(x) 13511 v0.AddArg(y) 13512 v.AddArg(v0) 13513 return true 13514 } 13515 } 13516 func rewriteValueARM_OpGeq8(v *Value, config *Config) bool { 13517 b := v.Block 13518 _ = b 13519 // match: (Geq8 x y) 13520 // cond: 13521 // result: (GreaterEqual (CMP (SignExt8to32 x) (SignExt8to32 y))) 13522 for { 13523 x := v.Args[0] 13524 y := v.Args[1] 13525 v.reset(OpARMGreaterEqual) 13526 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13527 v1 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 13528 v1.AddArg(x) 13529 v0.AddArg(v1) 13530 v2 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 13531 v2.AddArg(y) 13532 v0.AddArg(v2) 13533 v.AddArg(v0) 13534 return true 13535 } 13536 } 13537 func rewriteValueARM_OpGeq8U(v *Value, config *Config) bool { 13538 b := v.Block 13539 _ = b 13540 // match: (Geq8U x y) 13541 // cond: 13542 // result: (GreaterEqualU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 13543 for { 13544 x := v.Args[0] 13545 y := v.Args[1] 13546 v.reset(OpARMGreaterEqualU) 13547 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13548 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 13549 v1.AddArg(x) 13550 v0.AddArg(v1) 13551 v2 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 13552 v2.AddArg(y) 13553 v0.AddArg(v2) 13554 v.AddArg(v0) 13555 return true 13556 } 13557 } 13558 func rewriteValueARM_OpGetClosurePtr(v *Value, config *Config) bool { 13559 b := v.Block 13560 _ = b 13561 // match: (GetClosurePtr) 13562 // cond: 13563 // result: (LoweredGetClosurePtr) 13564 for { 13565 v.reset(OpARMLoweredGetClosurePtr) 13566 return true 13567 } 13568 } 13569 func rewriteValueARM_OpGoCall(v *Value, config *Config) bool { 13570 b := v.Block 13571 _ = b 13572 // match: (GoCall [argwid] mem) 13573 // cond: 13574 // result: (CALLgo [argwid] mem) 13575 for { 13576 argwid := v.AuxInt 13577 mem := v.Args[0] 13578 v.reset(OpARMCALLgo) 13579 v.AuxInt = argwid 13580 v.AddArg(mem) 13581 return true 13582 } 13583 } 13584 func rewriteValueARM_OpGreater16(v *Value, config *Config) bool { 13585 b := v.Block 13586 _ = b 13587 // match: (Greater16 x y) 13588 // cond: 13589 // result: (GreaterThan (CMP (SignExt16to32 x) (SignExt16to32 y))) 13590 for { 13591 x := v.Args[0] 13592 y := v.Args[1] 13593 v.reset(OpARMGreaterThan) 13594 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13595 v1 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 13596 v1.AddArg(x) 13597 v0.AddArg(v1) 13598 v2 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 13599 v2.AddArg(y) 13600 v0.AddArg(v2) 13601 v.AddArg(v0) 13602 return true 13603 } 13604 } 13605 func rewriteValueARM_OpGreater16U(v *Value, config *Config) bool { 13606 b := v.Block 13607 _ = b 13608 // match: (Greater16U x y) 13609 // cond: 13610 // result: (GreaterThanU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 13611 for { 13612 x := v.Args[0] 13613 y := v.Args[1] 13614 v.reset(OpARMGreaterThanU) 13615 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13616 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 13617 v1.AddArg(x) 13618 v0.AddArg(v1) 13619 v2 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 13620 v2.AddArg(y) 13621 v0.AddArg(v2) 13622 v.AddArg(v0) 13623 return true 13624 } 13625 } 13626 func rewriteValueARM_OpGreater32(v *Value, config *Config) bool { 13627 b := v.Block 13628 _ = b 13629 // match: (Greater32 x y) 13630 // cond: 13631 // result: (GreaterThan (CMP x y)) 13632 for { 13633 x := v.Args[0] 13634 y := v.Args[1] 13635 v.reset(OpARMGreaterThan) 13636 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13637 v0.AddArg(x) 13638 v0.AddArg(y) 13639 v.AddArg(v0) 13640 return true 13641 } 13642 } 13643 func rewriteValueARM_OpGreater32F(v *Value, config *Config) bool { 13644 b := v.Block 13645 _ = b 13646 // match: (Greater32F x y) 13647 // cond: 13648 // result: (GreaterThan (CMPF x y)) 13649 for { 13650 x := v.Args[0] 13651 y := v.Args[1] 13652 v.reset(OpARMGreaterThan) 13653 v0 := b.NewValue0(v.Line, OpARMCMPF, TypeFlags) 13654 v0.AddArg(x) 13655 v0.AddArg(y) 13656 v.AddArg(v0) 13657 return true 13658 } 13659 } 13660 func rewriteValueARM_OpGreater32U(v *Value, config *Config) bool { 13661 b := v.Block 13662 _ = b 13663 // match: (Greater32U x y) 13664 // cond: 13665 // result: (GreaterThanU (CMP x y)) 13666 for { 13667 x := v.Args[0] 13668 y := v.Args[1] 13669 v.reset(OpARMGreaterThanU) 13670 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13671 v0.AddArg(x) 13672 v0.AddArg(y) 13673 v.AddArg(v0) 13674 return true 13675 } 13676 } 13677 func rewriteValueARM_OpGreater64F(v *Value, config *Config) bool { 13678 b := v.Block 13679 _ = b 13680 // match: (Greater64F x y) 13681 // cond: 13682 // result: (GreaterThan (CMPD x y)) 13683 for { 13684 x := v.Args[0] 13685 y := v.Args[1] 13686 v.reset(OpARMGreaterThan) 13687 v0 := b.NewValue0(v.Line, OpARMCMPD, TypeFlags) 13688 v0.AddArg(x) 13689 v0.AddArg(y) 13690 v.AddArg(v0) 13691 return true 13692 } 13693 } 13694 func rewriteValueARM_OpGreater8(v *Value, config *Config) bool { 13695 b := v.Block 13696 _ = b 13697 // match: (Greater8 x y) 13698 // cond: 13699 // result: (GreaterThan (CMP (SignExt8to32 x) (SignExt8to32 y))) 13700 for { 13701 x := v.Args[0] 13702 y := v.Args[1] 13703 v.reset(OpARMGreaterThan) 13704 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13705 v1 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 13706 v1.AddArg(x) 13707 v0.AddArg(v1) 13708 v2 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 13709 v2.AddArg(y) 13710 v0.AddArg(v2) 13711 v.AddArg(v0) 13712 return true 13713 } 13714 } 13715 func rewriteValueARM_OpGreater8U(v *Value, config *Config) bool { 13716 b := v.Block 13717 _ = b 13718 // match: (Greater8U x y) 13719 // cond: 13720 // result: (GreaterThanU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 13721 for { 13722 x := v.Args[0] 13723 y := v.Args[1] 13724 v.reset(OpARMGreaterThanU) 13725 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13726 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 13727 v1.AddArg(x) 13728 v0.AddArg(v1) 13729 v2 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 13730 v2.AddArg(y) 13731 v0.AddArg(v2) 13732 v.AddArg(v0) 13733 return true 13734 } 13735 } 13736 func rewriteValueARM_OpHmul16(v *Value, config *Config) bool { 13737 b := v.Block 13738 _ = b 13739 // match: (Hmul16 x y) 13740 // cond: 13741 // result: (SRAconst (MUL <config.fe.TypeInt32()> (SignExt16to32 x) (SignExt16to32 y)) [16]) 13742 for { 13743 x := v.Args[0] 13744 y := v.Args[1] 13745 v.reset(OpARMSRAconst) 13746 v.AuxInt = 16 13747 v0 := b.NewValue0(v.Line, OpARMMUL, config.fe.TypeInt32()) 13748 v1 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 13749 v1.AddArg(x) 13750 v0.AddArg(v1) 13751 v2 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 13752 v2.AddArg(y) 13753 v0.AddArg(v2) 13754 v.AddArg(v0) 13755 return true 13756 } 13757 } 13758 func rewriteValueARM_OpHmul16u(v *Value, config *Config) bool { 13759 b := v.Block 13760 _ = b 13761 // match: (Hmul16u x y) 13762 // cond: 13763 // result: (SRLconst (MUL <config.fe.TypeUInt32()> (ZeroExt16to32 x) (ZeroExt16to32 y)) [16]) 13764 for { 13765 x := v.Args[0] 13766 y := v.Args[1] 13767 v.reset(OpARMSRLconst) 13768 v.AuxInt = 16 13769 v0 := b.NewValue0(v.Line, OpARMMUL, config.fe.TypeUInt32()) 13770 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 13771 v1.AddArg(x) 13772 v0.AddArg(v1) 13773 v2 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 13774 v2.AddArg(y) 13775 v0.AddArg(v2) 13776 v.AddArg(v0) 13777 return true 13778 } 13779 } 13780 func rewriteValueARM_OpHmul32(v *Value, config *Config) bool { 13781 b := v.Block 13782 _ = b 13783 // match: (Hmul32 x y) 13784 // cond: 13785 // result: (HMUL x y) 13786 for { 13787 x := v.Args[0] 13788 y := v.Args[1] 13789 v.reset(OpARMHMUL) 13790 v.AddArg(x) 13791 v.AddArg(y) 13792 return true 13793 } 13794 } 13795 func rewriteValueARM_OpHmul32u(v *Value, config *Config) bool { 13796 b := v.Block 13797 _ = b 13798 // match: (Hmul32u x y) 13799 // cond: 13800 // result: (HMULU x y) 13801 for { 13802 x := v.Args[0] 13803 y := v.Args[1] 13804 v.reset(OpARMHMULU) 13805 v.AddArg(x) 13806 v.AddArg(y) 13807 return true 13808 } 13809 } 13810 func rewriteValueARM_OpHmul8(v *Value, config *Config) bool { 13811 b := v.Block 13812 _ = b 13813 // match: (Hmul8 x y) 13814 // cond: 13815 // result: (SRAconst (MUL <config.fe.TypeInt16()> (SignExt8to32 x) (SignExt8to32 y)) [8]) 13816 for { 13817 x := v.Args[0] 13818 y := v.Args[1] 13819 v.reset(OpARMSRAconst) 13820 v.AuxInt = 8 13821 v0 := b.NewValue0(v.Line, OpARMMUL, config.fe.TypeInt16()) 13822 v1 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 13823 v1.AddArg(x) 13824 v0.AddArg(v1) 13825 v2 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 13826 v2.AddArg(y) 13827 v0.AddArg(v2) 13828 v.AddArg(v0) 13829 return true 13830 } 13831 } 13832 func rewriteValueARM_OpHmul8u(v *Value, config *Config) bool { 13833 b := v.Block 13834 _ = b 13835 // match: (Hmul8u x y) 13836 // cond: 13837 // result: (SRLconst (MUL <config.fe.TypeUInt16()> (ZeroExt8to32 x) (ZeroExt8to32 y)) [8]) 13838 for { 13839 x := v.Args[0] 13840 y := v.Args[1] 13841 v.reset(OpARMSRLconst) 13842 v.AuxInt = 8 13843 v0 := b.NewValue0(v.Line, OpARMMUL, config.fe.TypeUInt16()) 13844 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 13845 v1.AddArg(x) 13846 v0.AddArg(v1) 13847 v2 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 13848 v2.AddArg(y) 13849 v0.AddArg(v2) 13850 v.AddArg(v0) 13851 return true 13852 } 13853 } 13854 func rewriteValueARM_OpInterCall(v *Value, config *Config) bool { 13855 b := v.Block 13856 _ = b 13857 // match: (InterCall [argwid] entry mem) 13858 // cond: 13859 // result: (CALLinter [argwid] entry mem) 13860 for { 13861 argwid := v.AuxInt 13862 entry := v.Args[0] 13863 mem := v.Args[1] 13864 v.reset(OpARMCALLinter) 13865 v.AuxInt = argwid 13866 v.AddArg(entry) 13867 v.AddArg(mem) 13868 return true 13869 } 13870 } 13871 func rewriteValueARM_OpIsInBounds(v *Value, config *Config) bool { 13872 b := v.Block 13873 _ = b 13874 // match: (IsInBounds idx len) 13875 // cond: 13876 // result: (LessThanU (CMP idx len)) 13877 for { 13878 idx := v.Args[0] 13879 len := v.Args[1] 13880 v.reset(OpARMLessThanU) 13881 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13882 v0.AddArg(idx) 13883 v0.AddArg(len) 13884 v.AddArg(v0) 13885 return true 13886 } 13887 } 13888 func rewriteValueARM_OpIsNonNil(v *Value, config *Config) bool { 13889 b := v.Block 13890 _ = b 13891 // match: (IsNonNil ptr) 13892 // cond: 13893 // result: (NotEqual (CMPconst [0] ptr)) 13894 for { 13895 ptr := v.Args[0] 13896 v.reset(OpARMNotEqual) 13897 v0 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 13898 v0.AuxInt = 0 13899 v0.AddArg(ptr) 13900 v.AddArg(v0) 13901 return true 13902 } 13903 } 13904 func rewriteValueARM_OpIsSliceInBounds(v *Value, config *Config) bool { 13905 b := v.Block 13906 _ = b 13907 // match: (IsSliceInBounds idx len) 13908 // cond: 13909 // result: (LessEqualU (CMP idx len)) 13910 for { 13911 idx := v.Args[0] 13912 len := v.Args[1] 13913 v.reset(OpARMLessEqualU) 13914 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13915 v0.AddArg(idx) 13916 v0.AddArg(len) 13917 v.AddArg(v0) 13918 return true 13919 } 13920 } 13921 func rewriteValueARM_OpLeq16(v *Value, config *Config) bool { 13922 b := v.Block 13923 _ = b 13924 // match: (Leq16 x y) 13925 // cond: 13926 // result: (LessEqual (CMP (SignExt16to32 x) (SignExt16to32 y))) 13927 for { 13928 x := v.Args[0] 13929 y := v.Args[1] 13930 v.reset(OpARMLessEqual) 13931 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13932 v1 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 13933 v1.AddArg(x) 13934 v0.AddArg(v1) 13935 v2 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 13936 v2.AddArg(y) 13937 v0.AddArg(v2) 13938 v.AddArg(v0) 13939 return true 13940 } 13941 } 13942 func rewriteValueARM_OpLeq16U(v *Value, config *Config) bool { 13943 b := v.Block 13944 _ = b 13945 // match: (Leq16U x y) 13946 // cond: 13947 // result: (LessEqualU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 13948 for { 13949 x := v.Args[0] 13950 y := v.Args[1] 13951 v.reset(OpARMLessEqualU) 13952 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13953 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 13954 v1.AddArg(x) 13955 v0.AddArg(v1) 13956 v2 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 13957 v2.AddArg(y) 13958 v0.AddArg(v2) 13959 v.AddArg(v0) 13960 return true 13961 } 13962 } 13963 func rewriteValueARM_OpLeq32(v *Value, config *Config) bool { 13964 b := v.Block 13965 _ = b 13966 // match: (Leq32 x y) 13967 // cond: 13968 // result: (LessEqual (CMP x y)) 13969 for { 13970 x := v.Args[0] 13971 y := v.Args[1] 13972 v.reset(OpARMLessEqual) 13973 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 13974 v0.AddArg(x) 13975 v0.AddArg(y) 13976 v.AddArg(v0) 13977 return true 13978 } 13979 } 13980 func rewriteValueARM_OpLeq32F(v *Value, config *Config) bool { 13981 b := v.Block 13982 _ = b 13983 // match: (Leq32F x y) 13984 // cond: 13985 // result: (GreaterEqual (CMPF y x)) 13986 for { 13987 x := v.Args[0] 13988 y := v.Args[1] 13989 v.reset(OpARMGreaterEqual) 13990 v0 := b.NewValue0(v.Line, OpARMCMPF, TypeFlags) 13991 v0.AddArg(y) 13992 v0.AddArg(x) 13993 v.AddArg(v0) 13994 return true 13995 } 13996 } 13997 func rewriteValueARM_OpLeq32U(v *Value, config *Config) bool { 13998 b := v.Block 13999 _ = b 14000 // match: (Leq32U x y) 14001 // cond: 14002 // result: (LessEqualU (CMP x y)) 14003 for { 14004 x := v.Args[0] 14005 y := v.Args[1] 14006 v.reset(OpARMLessEqualU) 14007 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 14008 v0.AddArg(x) 14009 v0.AddArg(y) 14010 v.AddArg(v0) 14011 return true 14012 } 14013 } 14014 func rewriteValueARM_OpLeq64F(v *Value, config *Config) bool { 14015 b := v.Block 14016 _ = b 14017 // match: (Leq64F x y) 14018 // cond: 14019 // result: (GreaterEqual (CMPD y x)) 14020 for { 14021 x := v.Args[0] 14022 y := v.Args[1] 14023 v.reset(OpARMGreaterEqual) 14024 v0 := b.NewValue0(v.Line, OpARMCMPD, TypeFlags) 14025 v0.AddArg(y) 14026 v0.AddArg(x) 14027 v.AddArg(v0) 14028 return true 14029 } 14030 } 14031 func rewriteValueARM_OpLeq8(v *Value, config *Config) bool { 14032 b := v.Block 14033 _ = b 14034 // match: (Leq8 x y) 14035 // cond: 14036 // result: (LessEqual (CMP (SignExt8to32 x) (SignExt8to32 y))) 14037 for { 14038 x := v.Args[0] 14039 y := v.Args[1] 14040 v.reset(OpARMLessEqual) 14041 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 14042 v1 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 14043 v1.AddArg(x) 14044 v0.AddArg(v1) 14045 v2 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 14046 v2.AddArg(y) 14047 v0.AddArg(v2) 14048 v.AddArg(v0) 14049 return true 14050 } 14051 } 14052 func rewriteValueARM_OpLeq8U(v *Value, config *Config) bool { 14053 b := v.Block 14054 _ = b 14055 // match: (Leq8U x y) 14056 // cond: 14057 // result: (LessEqualU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 14058 for { 14059 x := v.Args[0] 14060 y := v.Args[1] 14061 v.reset(OpARMLessEqualU) 14062 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 14063 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 14064 v1.AddArg(x) 14065 v0.AddArg(v1) 14066 v2 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 14067 v2.AddArg(y) 14068 v0.AddArg(v2) 14069 v.AddArg(v0) 14070 return true 14071 } 14072 } 14073 func rewriteValueARM_OpLess16(v *Value, config *Config) bool { 14074 b := v.Block 14075 _ = b 14076 // match: (Less16 x y) 14077 // cond: 14078 // result: (LessThan (CMP (SignExt16to32 x) (SignExt16to32 y))) 14079 for { 14080 x := v.Args[0] 14081 y := v.Args[1] 14082 v.reset(OpARMLessThan) 14083 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 14084 v1 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 14085 v1.AddArg(x) 14086 v0.AddArg(v1) 14087 v2 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 14088 v2.AddArg(y) 14089 v0.AddArg(v2) 14090 v.AddArg(v0) 14091 return true 14092 } 14093 } 14094 func rewriteValueARM_OpLess16U(v *Value, config *Config) bool { 14095 b := v.Block 14096 _ = b 14097 // match: (Less16U x y) 14098 // cond: 14099 // result: (LessThanU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 14100 for { 14101 x := v.Args[0] 14102 y := v.Args[1] 14103 v.reset(OpARMLessThanU) 14104 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 14105 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 14106 v1.AddArg(x) 14107 v0.AddArg(v1) 14108 v2 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 14109 v2.AddArg(y) 14110 v0.AddArg(v2) 14111 v.AddArg(v0) 14112 return true 14113 } 14114 } 14115 func rewriteValueARM_OpLess32(v *Value, config *Config) bool { 14116 b := v.Block 14117 _ = b 14118 // match: (Less32 x y) 14119 // cond: 14120 // result: (LessThan (CMP x y)) 14121 for { 14122 x := v.Args[0] 14123 y := v.Args[1] 14124 v.reset(OpARMLessThan) 14125 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 14126 v0.AddArg(x) 14127 v0.AddArg(y) 14128 v.AddArg(v0) 14129 return true 14130 } 14131 } 14132 func rewriteValueARM_OpLess32F(v *Value, config *Config) bool { 14133 b := v.Block 14134 _ = b 14135 // match: (Less32F x y) 14136 // cond: 14137 // result: (GreaterThan (CMPF y x)) 14138 for { 14139 x := v.Args[0] 14140 y := v.Args[1] 14141 v.reset(OpARMGreaterThan) 14142 v0 := b.NewValue0(v.Line, OpARMCMPF, TypeFlags) 14143 v0.AddArg(y) 14144 v0.AddArg(x) 14145 v.AddArg(v0) 14146 return true 14147 } 14148 } 14149 func rewriteValueARM_OpLess32U(v *Value, config *Config) bool { 14150 b := v.Block 14151 _ = b 14152 // match: (Less32U x y) 14153 // cond: 14154 // result: (LessThanU (CMP x y)) 14155 for { 14156 x := v.Args[0] 14157 y := v.Args[1] 14158 v.reset(OpARMLessThanU) 14159 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 14160 v0.AddArg(x) 14161 v0.AddArg(y) 14162 v.AddArg(v0) 14163 return true 14164 } 14165 } 14166 func rewriteValueARM_OpLess64F(v *Value, config *Config) bool { 14167 b := v.Block 14168 _ = b 14169 // match: (Less64F x y) 14170 // cond: 14171 // result: (GreaterThan (CMPD y x)) 14172 for { 14173 x := v.Args[0] 14174 y := v.Args[1] 14175 v.reset(OpARMGreaterThan) 14176 v0 := b.NewValue0(v.Line, OpARMCMPD, TypeFlags) 14177 v0.AddArg(y) 14178 v0.AddArg(x) 14179 v.AddArg(v0) 14180 return true 14181 } 14182 } 14183 func rewriteValueARM_OpLess8(v *Value, config *Config) bool { 14184 b := v.Block 14185 _ = b 14186 // match: (Less8 x y) 14187 // cond: 14188 // result: (LessThan (CMP (SignExt8to32 x) (SignExt8to32 y))) 14189 for { 14190 x := v.Args[0] 14191 y := v.Args[1] 14192 v.reset(OpARMLessThan) 14193 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 14194 v1 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 14195 v1.AddArg(x) 14196 v0.AddArg(v1) 14197 v2 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 14198 v2.AddArg(y) 14199 v0.AddArg(v2) 14200 v.AddArg(v0) 14201 return true 14202 } 14203 } 14204 func rewriteValueARM_OpLess8U(v *Value, config *Config) bool { 14205 b := v.Block 14206 _ = b 14207 // match: (Less8U x y) 14208 // cond: 14209 // result: (LessThanU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 14210 for { 14211 x := v.Args[0] 14212 y := v.Args[1] 14213 v.reset(OpARMLessThanU) 14214 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 14215 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 14216 v1.AddArg(x) 14217 v0.AddArg(v1) 14218 v2 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 14219 v2.AddArg(y) 14220 v0.AddArg(v2) 14221 v.AddArg(v0) 14222 return true 14223 } 14224 } 14225 func rewriteValueARM_OpLoad(v *Value, config *Config) bool { 14226 b := v.Block 14227 _ = b 14228 // match: (Load <t> ptr mem) 14229 // cond: t.IsBoolean() 14230 // result: (MOVBUload ptr mem) 14231 for { 14232 t := v.Type 14233 ptr := v.Args[0] 14234 mem := v.Args[1] 14235 if !(t.IsBoolean()) { 14236 break 14237 } 14238 v.reset(OpARMMOVBUload) 14239 v.AddArg(ptr) 14240 v.AddArg(mem) 14241 return true 14242 } 14243 // match: (Load <t> ptr mem) 14244 // cond: (is8BitInt(t) && isSigned(t)) 14245 // result: (MOVBload ptr mem) 14246 for { 14247 t := v.Type 14248 ptr := v.Args[0] 14249 mem := v.Args[1] 14250 if !(is8BitInt(t) && isSigned(t)) { 14251 break 14252 } 14253 v.reset(OpARMMOVBload) 14254 v.AddArg(ptr) 14255 v.AddArg(mem) 14256 return true 14257 } 14258 // match: (Load <t> ptr mem) 14259 // cond: (is8BitInt(t) && !isSigned(t)) 14260 // result: (MOVBUload ptr mem) 14261 for { 14262 t := v.Type 14263 ptr := v.Args[0] 14264 mem := v.Args[1] 14265 if !(is8BitInt(t) && !isSigned(t)) { 14266 break 14267 } 14268 v.reset(OpARMMOVBUload) 14269 v.AddArg(ptr) 14270 v.AddArg(mem) 14271 return true 14272 } 14273 // match: (Load <t> ptr mem) 14274 // cond: (is16BitInt(t) && isSigned(t)) 14275 // result: (MOVHload ptr mem) 14276 for { 14277 t := v.Type 14278 ptr := v.Args[0] 14279 mem := v.Args[1] 14280 if !(is16BitInt(t) && isSigned(t)) { 14281 break 14282 } 14283 v.reset(OpARMMOVHload) 14284 v.AddArg(ptr) 14285 v.AddArg(mem) 14286 return true 14287 } 14288 // match: (Load <t> ptr mem) 14289 // cond: (is16BitInt(t) && !isSigned(t)) 14290 // result: (MOVHUload ptr mem) 14291 for { 14292 t := v.Type 14293 ptr := v.Args[0] 14294 mem := v.Args[1] 14295 if !(is16BitInt(t) && !isSigned(t)) { 14296 break 14297 } 14298 v.reset(OpARMMOVHUload) 14299 v.AddArg(ptr) 14300 v.AddArg(mem) 14301 return true 14302 } 14303 // match: (Load <t> ptr mem) 14304 // cond: (is32BitInt(t) || isPtr(t)) 14305 // result: (MOVWload ptr mem) 14306 for { 14307 t := v.Type 14308 ptr := v.Args[0] 14309 mem := v.Args[1] 14310 if !(is32BitInt(t) || isPtr(t)) { 14311 break 14312 } 14313 v.reset(OpARMMOVWload) 14314 v.AddArg(ptr) 14315 v.AddArg(mem) 14316 return true 14317 } 14318 // match: (Load <t> ptr mem) 14319 // cond: is32BitFloat(t) 14320 // result: (MOVFload ptr mem) 14321 for { 14322 t := v.Type 14323 ptr := v.Args[0] 14324 mem := v.Args[1] 14325 if !(is32BitFloat(t)) { 14326 break 14327 } 14328 v.reset(OpARMMOVFload) 14329 v.AddArg(ptr) 14330 v.AddArg(mem) 14331 return true 14332 } 14333 // match: (Load <t> ptr mem) 14334 // cond: is64BitFloat(t) 14335 // result: (MOVDload ptr mem) 14336 for { 14337 t := v.Type 14338 ptr := v.Args[0] 14339 mem := v.Args[1] 14340 if !(is64BitFloat(t)) { 14341 break 14342 } 14343 v.reset(OpARMMOVDload) 14344 v.AddArg(ptr) 14345 v.AddArg(mem) 14346 return true 14347 } 14348 return false 14349 } 14350 func rewriteValueARM_OpLrot16(v *Value, config *Config) bool { 14351 b := v.Block 14352 _ = b 14353 // match: (Lrot16 <t> x [c]) 14354 // cond: 14355 // result: (OR (SLLconst <t> x [c&15]) (SRLconst <t> x [16-c&15])) 14356 for { 14357 t := v.Type 14358 c := v.AuxInt 14359 x := v.Args[0] 14360 v.reset(OpARMOR) 14361 v0 := b.NewValue0(v.Line, OpARMSLLconst, t) 14362 v0.AuxInt = c & 15 14363 v0.AddArg(x) 14364 v.AddArg(v0) 14365 v1 := b.NewValue0(v.Line, OpARMSRLconst, t) 14366 v1.AuxInt = 16 - c&15 14367 v1.AddArg(x) 14368 v.AddArg(v1) 14369 return true 14370 } 14371 } 14372 func rewriteValueARM_OpLrot32(v *Value, config *Config) bool { 14373 b := v.Block 14374 _ = b 14375 // match: (Lrot32 x [c]) 14376 // cond: 14377 // result: (SRRconst x [32-c&31]) 14378 for { 14379 c := v.AuxInt 14380 x := v.Args[0] 14381 v.reset(OpARMSRRconst) 14382 v.AuxInt = 32 - c&31 14383 v.AddArg(x) 14384 return true 14385 } 14386 } 14387 func rewriteValueARM_OpLrot8(v *Value, config *Config) bool { 14388 b := v.Block 14389 _ = b 14390 // match: (Lrot8 <t> x [c]) 14391 // cond: 14392 // result: (OR (SLLconst <t> x [c&7]) (SRLconst <t> x [8-c&7])) 14393 for { 14394 t := v.Type 14395 c := v.AuxInt 14396 x := v.Args[0] 14397 v.reset(OpARMOR) 14398 v0 := b.NewValue0(v.Line, OpARMSLLconst, t) 14399 v0.AuxInt = c & 7 14400 v0.AddArg(x) 14401 v.AddArg(v0) 14402 v1 := b.NewValue0(v.Line, OpARMSRLconst, t) 14403 v1.AuxInt = 8 - c&7 14404 v1.AddArg(x) 14405 v.AddArg(v1) 14406 return true 14407 } 14408 } 14409 func rewriteValueARM_OpLsh16x16(v *Value, config *Config) bool { 14410 b := v.Block 14411 _ = b 14412 // match: (Lsh16x16 x y) 14413 // cond: 14414 // result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 14415 for { 14416 x := v.Args[0] 14417 y := v.Args[1] 14418 v.reset(OpARMCMOVWHSconst) 14419 v.AuxInt = 0 14420 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 14421 v0.AddArg(x) 14422 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 14423 v1.AddArg(y) 14424 v0.AddArg(v1) 14425 v.AddArg(v0) 14426 v2 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 14427 v2.AuxInt = 256 14428 v3 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 14429 v3.AddArg(y) 14430 v2.AddArg(v3) 14431 v.AddArg(v2) 14432 return true 14433 } 14434 } 14435 func rewriteValueARM_OpLsh16x32(v *Value, config *Config) bool { 14436 b := v.Block 14437 _ = b 14438 // match: (Lsh16x32 x y) 14439 // cond: 14440 // result: (CMOVWHSconst (SLL <x.Type> x y) (CMPconst [256] y) [0]) 14441 for { 14442 x := v.Args[0] 14443 y := v.Args[1] 14444 v.reset(OpARMCMOVWHSconst) 14445 v.AuxInt = 0 14446 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 14447 v0.AddArg(x) 14448 v0.AddArg(y) 14449 v.AddArg(v0) 14450 v1 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 14451 v1.AuxInt = 256 14452 v1.AddArg(y) 14453 v.AddArg(v1) 14454 return true 14455 } 14456 } 14457 func rewriteValueARM_OpLsh16x64(v *Value, config *Config) bool { 14458 b := v.Block 14459 _ = b 14460 // match: (Lsh16x64 x (Const64 [c])) 14461 // cond: uint64(c) < 16 14462 // result: (SLLconst x [c]) 14463 for { 14464 x := v.Args[0] 14465 v_1 := v.Args[1] 14466 if v_1.Op != OpConst64 { 14467 break 14468 } 14469 c := v_1.AuxInt 14470 if !(uint64(c) < 16) { 14471 break 14472 } 14473 v.reset(OpARMSLLconst) 14474 v.AuxInt = c 14475 v.AddArg(x) 14476 return true 14477 } 14478 // match: (Lsh16x64 _ (Const64 [c])) 14479 // cond: uint64(c) >= 16 14480 // result: (Const16 [0]) 14481 for { 14482 v_1 := v.Args[1] 14483 if v_1.Op != OpConst64 { 14484 break 14485 } 14486 c := v_1.AuxInt 14487 if !(uint64(c) >= 16) { 14488 break 14489 } 14490 v.reset(OpConst16) 14491 v.AuxInt = 0 14492 return true 14493 } 14494 return false 14495 } 14496 func rewriteValueARM_OpLsh16x8(v *Value, config *Config) bool { 14497 b := v.Block 14498 _ = b 14499 // match: (Lsh16x8 x y) 14500 // cond: 14501 // result: (SLL x (ZeroExt8to32 y)) 14502 for { 14503 x := v.Args[0] 14504 y := v.Args[1] 14505 v.reset(OpARMSLL) 14506 v.AddArg(x) 14507 v0 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 14508 v0.AddArg(y) 14509 v.AddArg(v0) 14510 return true 14511 } 14512 } 14513 func rewriteValueARM_OpLsh32x16(v *Value, config *Config) bool { 14514 b := v.Block 14515 _ = b 14516 // match: (Lsh32x16 x y) 14517 // cond: 14518 // result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 14519 for { 14520 x := v.Args[0] 14521 y := v.Args[1] 14522 v.reset(OpARMCMOVWHSconst) 14523 v.AuxInt = 0 14524 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 14525 v0.AddArg(x) 14526 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 14527 v1.AddArg(y) 14528 v0.AddArg(v1) 14529 v.AddArg(v0) 14530 v2 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 14531 v2.AuxInt = 256 14532 v3 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 14533 v3.AddArg(y) 14534 v2.AddArg(v3) 14535 v.AddArg(v2) 14536 return true 14537 } 14538 } 14539 func rewriteValueARM_OpLsh32x32(v *Value, config *Config) bool { 14540 b := v.Block 14541 _ = b 14542 // match: (Lsh32x32 x y) 14543 // cond: 14544 // result: (CMOVWHSconst (SLL <x.Type> x y) (CMPconst [256] y) [0]) 14545 for { 14546 x := v.Args[0] 14547 y := v.Args[1] 14548 v.reset(OpARMCMOVWHSconst) 14549 v.AuxInt = 0 14550 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 14551 v0.AddArg(x) 14552 v0.AddArg(y) 14553 v.AddArg(v0) 14554 v1 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 14555 v1.AuxInt = 256 14556 v1.AddArg(y) 14557 v.AddArg(v1) 14558 return true 14559 } 14560 } 14561 func rewriteValueARM_OpLsh32x64(v *Value, config *Config) bool { 14562 b := v.Block 14563 _ = b 14564 // match: (Lsh32x64 x (Const64 [c])) 14565 // cond: uint64(c) < 32 14566 // result: (SLLconst x [c]) 14567 for { 14568 x := v.Args[0] 14569 v_1 := v.Args[1] 14570 if v_1.Op != OpConst64 { 14571 break 14572 } 14573 c := v_1.AuxInt 14574 if !(uint64(c) < 32) { 14575 break 14576 } 14577 v.reset(OpARMSLLconst) 14578 v.AuxInt = c 14579 v.AddArg(x) 14580 return true 14581 } 14582 // match: (Lsh32x64 _ (Const64 [c])) 14583 // cond: uint64(c) >= 32 14584 // result: (Const32 [0]) 14585 for { 14586 v_1 := v.Args[1] 14587 if v_1.Op != OpConst64 { 14588 break 14589 } 14590 c := v_1.AuxInt 14591 if !(uint64(c) >= 32) { 14592 break 14593 } 14594 v.reset(OpConst32) 14595 v.AuxInt = 0 14596 return true 14597 } 14598 return false 14599 } 14600 func rewriteValueARM_OpLsh32x8(v *Value, config *Config) bool { 14601 b := v.Block 14602 _ = b 14603 // match: (Lsh32x8 x y) 14604 // cond: 14605 // result: (SLL x (ZeroExt8to32 y)) 14606 for { 14607 x := v.Args[0] 14608 y := v.Args[1] 14609 v.reset(OpARMSLL) 14610 v.AddArg(x) 14611 v0 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 14612 v0.AddArg(y) 14613 v.AddArg(v0) 14614 return true 14615 } 14616 } 14617 func rewriteValueARM_OpLsh8x16(v *Value, config *Config) bool { 14618 b := v.Block 14619 _ = b 14620 // match: (Lsh8x16 x y) 14621 // cond: 14622 // result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 14623 for { 14624 x := v.Args[0] 14625 y := v.Args[1] 14626 v.reset(OpARMCMOVWHSconst) 14627 v.AuxInt = 0 14628 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 14629 v0.AddArg(x) 14630 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 14631 v1.AddArg(y) 14632 v0.AddArg(v1) 14633 v.AddArg(v0) 14634 v2 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 14635 v2.AuxInt = 256 14636 v3 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 14637 v3.AddArg(y) 14638 v2.AddArg(v3) 14639 v.AddArg(v2) 14640 return true 14641 } 14642 } 14643 func rewriteValueARM_OpLsh8x32(v *Value, config *Config) bool { 14644 b := v.Block 14645 _ = b 14646 // match: (Lsh8x32 x y) 14647 // cond: 14648 // result: (CMOVWHSconst (SLL <x.Type> x y) (CMPconst [256] y) [0]) 14649 for { 14650 x := v.Args[0] 14651 y := v.Args[1] 14652 v.reset(OpARMCMOVWHSconst) 14653 v.AuxInt = 0 14654 v0 := b.NewValue0(v.Line, OpARMSLL, x.Type) 14655 v0.AddArg(x) 14656 v0.AddArg(y) 14657 v.AddArg(v0) 14658 v1 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 14659 v1.AuxInt = 256 14660 v1.AddArg(y) 14661 v.AddArg(v1) 14662 return true 14663 } 14664 } 14665 func rewriteValueARM_OpLsh8x64(v *Value, config *Config) bool { 14666 b := v.Block 14667 _ = b 14668 // match: (Lsh8x64 x (Const64 [c])) 14669 // cond: uint64(c) < 8 14670 // result: (SLLconst x [c]) 14671 for { 14672 x := v.Args[0] 14673 v_1 := v.Args[1] 14674 if v_1.Op != OpConst64 { 14675 break 14676 } 14677 c := v_1.AuxInt 14678 if !(uint64(c) < 8) { 14679 break 14680 } 14681 v.reset(OpARMSLLconst) 14682 v.AuxInt = c 14683 v.AddArg(x) 14684 return true 14685 } 14686 // match: (Lsh8x64 _ (Const64 [c])) 14687 // cond: uint64(c) >= 8 14688 // result: (Const8 [0]) 14689 for { 14690 v_1 := v.Args[1] 14691 if v_1.Op != OpConst64 { 14692 break 14693 } 14694 c := v_1.AuxInt 14695 if !(uint64(c) >= 8) { 14696 break 14697 } 14698 v.reset(OpConst8) 14699 v.AuxInt = 0 14700 return true 14701 } 14702 return false 14703 } 14704 func rewriteValueARM_OpLsh8x8(v *Value, config *Config) bool { 14705 b := v.Block 14706 _ = b 14707 // match: (Lsh8x8 x y) 14708 // cond: 14709 // result: (SLL x (ZeroExt8to32 y)) 14710 for { 14711 x := v.Args[0] 14712 y := v.Args[1] 14713 v.reset(OpARMSLL) 14714 v.AddArg(x) 14715 v0 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 14716 v0.AddArg(y) 14717 v.AddArg(v0) 14718 return true 14719 } 14720 } 14721 func rewriteValueARM_OpMod16(v *Value, config *Config) bool { 14722 b := v.Block 14723 _ = b 14724 // match: (Mod16 x y) 14725 // cond: 14726 // result: (MOD (SignExt16to32 x) (SignExt16to32 y)) 14727 for { 14728 x := v.Args[0] 14729 y := v.Args[1] 14730 v.reset(OpARMMOD) 14731 v0 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 14732 v0.AddArg(x) 14733 v.AddArg(v0) 14734 v1 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 14735 v1.AddArg(y) 14736 v.AddArg(v1) 14737 return true 14738 } 14739 } 14740 func rewriteValueARM_OpMod16u(v *Value, config *Config) bool { 14741 b := v.Block 14742 _ = b 14743 // match: (Mod16u x y) 14744 // cond: 14745 // result: (MODU (ZeroExt16to32 x) (ZeroExt16to32 y)) 14746 for { 14747 x := v.Args[0] 14748 y := v.Args[1] 14749 v.reset(OpARMMODU) 14750 v0 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 14751 v0.AddArg(x) 14752 v.AddArg(v0) 14753 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 14754 v1.AddArg(y) 14755 v.AddArg(v1) 14756 return true 14757 } 14758 } 14759 func rewriteValueARM_OpMod32(v *Value, config *Config) bool { 14760 b := v.Block 14761 _ = b 14762 // match: (Mod32 x y) 14763 // cond: 14764 // result: (MOD x y) 14765 for { 14766 x := v.Args[0] 14767 y := v.Args[1] 14768 v.reset(OpARMMOD) 14769 v.AddArg(x) 14770 v.AddArg(y) 14771 return true 14772 } 14773 } 14774 func rewriteValueARM_OpMod32u(v *Value, config *Config) bool { 14775 b := v.Block 14776 _ = b 14777 // match: (Mod32u x y) 14778 // cond: 14779 // result: (MODU x y) 14780 for { 14781 x := v.Args[0] 14782 y := v.Args[1] 14783 v.reset(OpARMMODU) 14784 v.AddArg(x) 14785 v.AddArg(y) 14786 return true 14787 } 14788 } 14789 func rewriteValueARM_OpMod8(v *Value, config *Config) bool { 14790 b := v.Block 14791 _ = b 14792 // match: (Mod8 x y) 14793 // cond: 14794 // result: (MOD (SignExt8to32 x) (SignExt8to32 y)) 14795 for { 14796 x := v.Args[0] 14797 y := v.Args[1] 14798 v.reset(OpARMMOD) 14799 v0 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 14800 v0.AddArg(x) 14801 v.AddArg(v0) 14802 v1 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 14803 v1.AddArg(y) 14804 v.AddArg(v1) 14805 return true 14806 } 14807 } 14808 func rewriteValueARM_OpMod8u(v *Value, config *Config) bool { 14809 b := v.Block 14810 _ = b 14811 // match: (Mod8u x y) 14812 // cond: 14813 // result: (MODU (ZeroExt8to32 x) (ZeroExt8to32 y)) 14814 for { 14815 x := v.Args[0] 14816 y := v.Args[1] 14817 v.reset(OpARMMODU) 14818 v0 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 14819 v0.AddArg(x) 14820 v.AddArg(v0) 14821 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 14822 v1.AddArg(y) 14823 v.AddArg(v1) 14824 return true 14825 } 14826 } 14827 func rewriteValueARM_OpMove(v *Value, config *Config) bool { 14828 b := v.Block 14829 _ = b 14830 // match: (Move [s] _ _ mem) 14831 // cond: SizeAndAlign(s).Size() == 0 14832 // result: mem 14833 for { 14834 s := v.AuxInt 14835 mem := v.Args[2] 14836 if !(SizeAndAlign(s).Size() == 0) { 14837 break 14838 } 14839 v.reset(OpCopy) 14840 v.Type = mem.Type 14841 v.AddArg(mem) 14842 return true 14843 } 14844 // match: (Move [s] dst src mem) 14845 // cond: SizeAndAlign(s).Size() == 1 14846 // result: (MOVBstore dst (MOVBUload src mem) mem) 14847 for { 14848 s := v.AuxInt 14849 dst := v.Args[0] 14850 src := v.Args[1] 14851 mem := v.Args[2] 14852 if !(SizeAndAlign(s).Size() == 1) { 14853 break 14854 } 14855 v.reset(OpARMMOVBstore) 14856 v.AddArg(dst) 14857 v0 := b.NewValue0(v.Line, OpARMMOVBUload, config.fe.TypeUInt8()) 14858 v0.AddArg(src) 14859 v0.AddArg(mem) 14860 v.AddArg(v0) 14861 v.AddArg(mem) 14862 return true 14863 } 14864 // match: (Move [s] dst src mem) 14865 // cond: SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0 14866 // result: (MOVHstore dst (MOVHUload src mem) mem) 14867 for { 14868 s := v.AuxInt 14869 dst := v.Args[0] 14870 src := v.Args[1] 14871 mem := v.Args[2] 14872 if !(SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0) { 14873 break 14874 } 14875 v.reset(OpARMMOVHstore) 14876 v.AddArg(dst) 14877 v0 := b.NewValue0(v.Line, OpARMMOVHUload, config.fe.TypeUInt16()) 14878 v0.AddArg(src) 14879 v0.AddArg(mem) 14880 v.AddArg(v0) 14881 v.AddArg(mem) 14882 return true 14883 } 14884 // match: (Move [s] dst src mem) 14885 // cond: SizeAndAlign(s).Size() == 2 14886 // result: (MOVBstore [1] dst (MOVBUload [1] src mem) (MOVBstore dst (MOVBUload src mem) mem)) 14887 for { 14888 s := v.AuxInt 14889 dst := v.Args[0] 14890 src := v.Args[1] 14891 mem := v.Args[2] 14892 if !(SizeAndAlign(s).Size() == 2) { 14893 break 14894 } 14895 v.reset(OpARMMOVBstore) 14896 v.AuxInt = 1 14897 v.AddArg(dst) 14898 v0 := b.NewValue0(v.Line, OpARMMOVBUload, config.fe.TypeUInt8()) 14899 v0.AuxInt = 1 14900 v0.AddArg(src) 14901 v0.AddArg(mem) 14902 v.AddArg(v0) 14903 v1 := b.NewValue0(v.Line, OpARMMOVBstore, TypeMem) 14904 v1.AddArg(dst) 14905 v2 := b.NewValue0(v.Line, OpARMMOVBUload, config.fe.TypeUInt8()) 14906 v2.AddArg(src) 14907 v2.AddArg(mem) 14908 v1.AddArg(v2) 14909 v1.AddArg(mem) 14910 v.AddArg(v1) 14911 return true 14912 } 14913 // match: (Move [s] dst src mem) 14914 // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0 14915 // result: (MOVWstore dst (MOVWload src mem) mem) 14916 for { 14917 s := v.AuxInt 14918 dst := v.Args[0] 14919 src := v.Args[1] 14920 mem := v.Args[2] 14921 if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0) { 14922 break 14923 } 14924 v.reset(OpARMMOVWstore) 14925 v.AddArg(dst) 14926 v0 := b.NewValue0(v.Line, OpARMMOVWload, config.fe.TypeUInt32()) 14927 v0.AddArg(src) 14928 v0.AddArg(mem) 14929 v.AddArg(v0) 14930 v.AddArg(mem) 14931 return true 14932 } 14933 // match: (Move [s] dst src mem) 14934 // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0 14935 // result: (MOVHstore [2] dst (MOVHUload [2] src mem) (MOVHstore dst (MOVHUload src mem) mem)) 14936 for { 14937 s := v.AuxInt 14938 dst := v.Args[0] 14939 src := v.Args[1] 14940 mem := v.Args[2] 14941 if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0) { 14942 break 14943 } 14944 v.reset(OpARMMOVHstore) 14945 v.AuxInt = 2 14946 v.AddArg(dst) 14947 v0 := b.NewValue0(v.Line, OpARMMOVHUload, config.fe.TypeUInt16()) 14948 v0.AuxInt = 2 14949 v0.AddArg(src) 14950 v0.AddArg(mem) 14951 v.AddArg(v0) 14952 v1 := b.NewValue0(v.Line, OpARMMOVHstore, TypeMem) 14953 v1.AddArg(dst) 14954 v2 := b.NewValue0(v.Line, OpARMMOVHUload, config.fe.TypeUInt16()) 14955 v2.AddArg(src) 14956 v2.AddArg(mem) 14957 v1.AddArg(v2) 14958 v1.AddArg(mem) 14959 v.AddArg(v1) 14960 return true 14961 } 14962 // match: (Move [s] dst src mem) 14963 // cond: SizeAndAlign(s).Size() == 4 14964 // result: (MOVBstore [3] dst (MOVBUload [3] src mem) (MOVBstore [2] dst (MOVBUload [2] src mem) (MOVBstore [1] dst (MOVBUload [1] src mem) (MOVBstore dst (MOVBUload src mem) mem)))) 14965 for { 14966 s := v.AuxInt 14967 dst := v.Args[0] 14968 src := v.Args[1] 14969 mem := v.Args[2] 14970 if !(SizeAndAlign(s).Size() == 4) { 14971 break 14972 } 14973 v.reset(OpARMMOVBstore) 14974 v.AuxInt = 3 14975 v.AddArg(dst) 14976 v0 := b.NewValue0(v.Line, OpARMMOVBUload, config.fe.TypeUInt8()) 14977 v0.AuxInt = 3 14978 v0.AddArg(src) 14979 v0.AddArg(mem) 14980 v.AddArg(v0) 14981 v1 := b.NewValue0(v.Line, OpARMMOVBstore, TypeMem) 14982 v1.AuxInt = 2 14983 v1.AddArg(dst) 14984 v2 := b.NewValue0(v.Line, OpARMMOVBUload, config.fe.TypeUInt8()) 14985 v2.AuxInt = 2 14986 v2.AddArg(src) 14987 v2.AddArg(mem) 14988 v1.AddArg(v2) 14989 v3 := b.NewValue0(v.Line, OpARMMOVBstore, TypeMem) 14990 v3.AuxInt = 1 14991 v3.AddArg(dst) 14992 v4 := b.NewValue0(v.Line, OpARMMOVBUload, config.fe.TypeUInt8()) 14993 v4.AuxInt = 1 14994 v4.AddArg(src) 14995 v4.AddArg(mem) 14996 v3.AddArg(v4) 14997 v5 := b.NewValue0(v.Line, OpARMMOVBstore, TypeMem) 14998 v5.AddArg(dst) 14999 v6 := b.NewValue0(v.Line, OpARMMOVBUload, config.fe.TypeUInt8()) 15000 v6.AddArg(src) 15001 v6.AddArg(mem) 15002 v5.AddArg(v6) 15003 v5.AddArg(mem) 15004 v3.AddArg(v5) 15005 v1.AddArg(v3) 15006 v.AddArg(v1) 15007 return true 15008 } 15009 // match: (Move [s] dst src mem) 15010 // cond: SizeAndAlign(s).Size() == 3 15011 // result: (MOVBstore [2] dst (MOVBUload [2] src mem) (MOVBstore [1] dst (MOVBUload [1] src mem) (MOVBstore dst (MOVBUload src mem) mem))) 15012 for { 15013 s := v.AuxInt 15014 dst := v.Args[0] 15015 src := v.Args[1] 15016 mem := v.Args[2] 15017 if !(SizeAndAlign(s).Size() == 3) { 15018 break 15019 } 15020 v.reset(OpARMMOVBstore) 15021 v.AuxInt = 2 15022 v.AddArg(dst) 15023 v0 := b.NewValue0(v.Line, OpARMMOVBUload, config.fe.TypeUInt8()) 15024 v0.AuxInt = 2 15025 v0.AddArg(src) 15026 v0.AddArg(mem) 15027 v.AddArg(v0) 15028 v1 := b.NewValue0(v.Line, OpARMMOVBstore, TypeMem) 15029 v1.AuxInt = 1 15030 v1.AddArg(dst) 15031 v2 := b.NewValue0(v.Line, OpARMMOVBUload, config.fe.TypeUInt8()) 15032 v2.AuxInt = 1 15033 v2.AddArg(src) 15034 v2.AddArg(mem) 15035 v1.AddArg(v2) 15036 v3 := b.NewValue0(v.Line, OpARMMOVBstore, TypeMem) 15037 v3.AddArg(dst) 15038 v4 := b.NewValue0(v.Line, OpARMMOVBUload, config.fe.TypeUInt8()) 15039 v4.AddArg(src) 15040 v4.AddArg(mem) 15041 v3.AddArg(v4) 15042 v3.AddArg(mem) 15043 v1.AddArg(v3) 15044 v.AddArg(v1) 15045 return true 15046 } 15047 // match: (Move [s] dst src mem) 15048 // cond: SizeAndAlign(s).Size()%4 == 0 && SizeAndAlign(s).Size() > 4 && SizeAndAlign(s).Size() <= 512 && SizeAndAlign(s).Align()%4 == 0 && !config.noDuffDevice 15049 // result: (DUFFCOPY [8 * (128 - int64(SizeAndAlign(s).Size()/4))] dst src mem) 15050 for { 15051 s := v.AuxInt 15052 dst := v.Args[0] 15053 src := v.Args[1] 15054 mem := v.Args[2] 15055 if !(SizeAndAlign(s).Size()%4 == 0 && SizeAndAlign(s).Size() > 4 && SizeAndAlign(s).Size() <= 512 && SizeAndAlign(s).Align()%4 == 0 && !config.noDuffDevice) { 15056 break 15057 } 15058 v.reset(OpARMDUFFCOPY) 15059 v.AuxInt = 8 * (128 - int64(SizeAndAlign(s).Size()/4)) 15060 v.AddArg(dst) 15061 v.AddArg(src) 15062 v.AddArg(mem) 15063 return true 15064 } 15065 // match: (Move [s] dst src mem) 15066 // cond: (SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%4 != 0 15067 // result: (LoweredMove [SizeAndAlign(s).Align()] dst src (ADDconst <src.Type> src [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)]) mem) 15068 for { 15069 s := v.AuxInt 15070 dst := v.Args[0] 15071 src := v.Args[1] 15072 mem := v.Args[2] 15073 if !((SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%4 != 0) { 15074 break 15075 } 15076 v.reset(OpARMLoweredMove) 15077 v.AuxInt = SizeAndAlign(s).Align() 15078 v.AddArg(dst) 15079 v.AddArg(src) 15080 v0 := b.NewValue0(v.Line, OpARMADDconst, src.Type) 15081 v0.AuxInt = SizeAndAlign(s).Size() - moveSize(SizeAndAlign(s).Align(), config) 15082 v0.AddArg(src) 15083 v.AddArg(v0) 15084 v.AddArg(mem) 15085 return true 15086 } 15087 return false 15088 } 15089 func rewriteValueARM_OpMul16(v *Value, config *Config) bool { 15090 b := v.Block 15091 _ = b 15092 // match: (Mul16 x y) 15093 // cond: 15094 // result: (MUL x y) 15095 for { 15096 x := v.Args[0] 15097 y := v.Args[1] 15098 v.reset(OpARMMUL) 15099 v.AddArg(x) 15100 v.AddArg(y) 15101 return true 15102 } 15103 } 15104 func rewriteValueARM_OpMul32(v *Value, config *Config) bool { 15105 b := v.Block 15106 _ = b 15107 // match: (Mul32 x y) 15108 // cond: 15109 // result: (MUL x y) 15110 for { 15111 x := v.Args[0] 15112 y := v.Args[1] 15113 v.reset(OpARMMUL) 15114 v.AddArg(x) 15115 v.AddArg(y) 15116 return true 15117 } 15118 } 15119 func rewriteValueARM_OpMul32F(v *Value, config *Config) bool { 15120 b := v.Block 15121 _ = b 15122 // match: (Mul32F x y) 15123 // cond: 15124 // result: (MULF x y) 15125 for { 15126 x := v.Args[0] 15127 y := v.Args[1] 15128 v.reset(OpARMMULF) 15129 v.AddArg(x) 15130 v.AddArg(y) 15131 return true 15132 } 15133 } 15134 func rewriteValueARM_OpMul32uhilo(v *Value, config *Config) bool { 15135 b := v.Block 15136 _ = b 15137 // match: (Mul32uhilo x y) 15138 // cond: 15139 // result: (MULLU x y) 15140 for { 15141 x := v.Args[0] 15142 y := v.Args[1] 15143 v.reset(OpARMMULLU) 15144 v.AddArg(x) 15145 v.AddArg(y) 15146 return true 15147 } 15148 } 15149 func rewriteValueARM_OpMul64F(v *Value, config *Config) bool { 15150 b := v.Block 15151 _ = b 15152 // match: (Mul64F x y) 15153 // cond: 15154 // result: (MULD x y) 15155 for { 15156 x := v.Args[0] 15157 y := v.Args[1] 15158 v.reset(OpARMMULD) 15159 v.AddArg(x) 15160 v.AddArg(y) 15161 return true 15162 } 15163 } 15164 func rewriteValueARM_OpMul8(v *Value, config *Config) bool { 15165 b := v.Block 15166 _ = b 15167 // match: (Mul8 x y) 15168 // cond: 15169 // result: (MUL x y) 15170 for { 15171 x := v.Args[0] 15172 y := v.Args[1] 15173 v.reset(OpARMMUL) 15174 v.AddArg(x) 15175 v.AddArg(y) 15176 return true 15177 } 15178 } 15179 func rewriteValueARM_OpNeg16(v *Value, config *Config) bool { 15180 b := v.Block 15181 _ = b 15182 // match: (Neg16 x) 15183 // cond: 15184 // result: (RSBconst [0] x) 15185 for { 15186 x := v.Args[0] 15187 v.reset(OpARMRSBconst) 15188 v.AuxInt = 0 15189 v.AddArg(x) 15190 return true 15191 } 15192 } 15193 func rewriteValueARM_OpNeg32(v *Value, config *Config) bool { 15194 b := v.Block 15195 _ = b 15196 // match: (Neg32 x) 15197 // cond: 15198 // result: (RSBconst [0] x) 15199 for { 15200 x := v.Args[0] 15201 v.reset(OpARMRSBconst) 15202 v.AuxInt = 0 15203 v.AddArg(x) 15204 return true 15205 } 15206 } 15207 func rewriteValueARM_OpNeg32F(v *Value, config *Config) bool { 15208 b := v.Block 15209 _ = b 15210 // match: (Neg32F x) 15211 // cond: 15212 // result: (NEGF x) 15213 for { 15214 x := v.Args[0] 15215 v.reset(OpARMNEGF) 15216 v.AddArg(x) 15217 return true 15218 } 15219 } 15220 func rewriteValueARM_OpNeg64F(v *Value, config *Config) bool { 15221 b := v.Block 15222 _ = b 15223 // match: (Neg64F x) 15224 // cond: 15225 // result: (NEGD x) 15226 for { 15227 x := v.Args[0] 15228 v.reset(OpARMNEGD) 15229 v.AddArg(x) 15230 return true 15231 } 15232 } 15233 func rewriteValueARM_OpNeg8(v *Value, config *Config) bool { 15234 b := v.Block 15235 _ = b 15236 // match: (Neg8 x) 15237 // cond: 15238 // result: (RSBconst [0] x) 15239 for { 15240 x := v.Args[0] 15241 v.reset(OpARMRSBconst) 15242 v.AuxInt = 0 15243 v.AddArg(x) 15244 return true 15245 } 15246 } 15247 func rewriteValueARM_OpNeq16(v *Value, config *Config) bool { 15248 b := v.Block 15249 _ = b 15250 // match: (Neq16 x y) 15251 // cond: 15252 // result: (NotEqual (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 15253 for { 15254 x := v.Args[0] 15255 y := v.Args[1] 15256 v.reset(OpARMNotEqual) 15257 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 15258 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 15259 v1.AddArg(x) 15260 v0.AddArg(v1) 15261 v2 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 15262 v2.AddArg(y) 15263 v0.AddArg(v2) 15264 v.AddArg(v0) 15265 return true 15266 } 15267 } 15268 func rewriteValueARM_OpNeq32(v *Value, config *Config) bool { 15269 b := v.Block 15270 _ = b 15271 // match: (Neq32 x y) 15272 // cond: 15273 // result: (NotEqual (CMP x y)) 15274 for { 15275 x := v.Args[0] 15276 y := v.Args[1] 15277 v.reset(OpARMNotEqual) 15278 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 15279 v0.AddArg(x) 15280 v0.AddArg(y) 15281 v.AddArg(v0) 15282 return true 15283 } 15284 } 15285 func rewriteValueARM_OpNeq32F(v *Value, config *Config) bool { 15286 b := v.Block 15287 _ = b 15288 // match: (Neq32F x y) 15289 // cond: 15290 // result: (NotEqual (CMPF x y)) 15291 for { 15292 x := v.Args[0] 15293 y := v.Args[1] 15294 v.reset(OpARMNotEqual) 15295 v0 := b.NewValue0(v.Line, OpARMCMPF, TypeFlags) 15296 v0.AddArg(x) 15297 v0.AddArg(y) 15298 v.AddArg(v0) 15299 return true 15300 } 15301 } 15302 func rewriteValueARM_OpNeq64F(v *Value, config *Config) bool { 15303 b := v.Block 15304 _ = b 15305 // match: (Neq64F x y) 15306 // cond: 15307 // result: (NotEqual (CMPD x y)) 15308 for { 15309 x := v.Args[0] 15310 y := v.Args[1] 15311 v.reset(OpARMNotEqual) 15312 v0 := b.NewValue0(v.Line, OpARMCMPD, TypeFlags) 15313 v0.AddArg(x) 15314 v0.AddArg(y) 15315 v.AddArg(v0) 15316 return true 15317 } 15318 } 15319 func rewriteValueARM_OpNeq8(v *Value, config *Config) bool { 15320 b := v.Block 15321 _ = b 15322 // match: (Neq8 x y) 15323 // cond: 15324 // result: (NotEqual (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 15325 for { 15326 x := v.Args[0] 15327 y := v.Args[1] 15328 v.reset(OpARMNotEqual) 15329 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 15330 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 15331 v1.AddArg(x) 15332 v0.AddArg(v1) 15333 v2 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 15334 v2.AddArg(y) 15335 v0.AddArg(v2) 15336 v.AddArg(v0) 15337 return true 15338 } 15339 } 15340 func rewriteValueARM_OpNeqB(v *Value, config *Config) bool { 15341 b := v.Block 15342 _ = b 15343 // match: (NeqB x y) 15344 // cond: 15345 // result: (XOR x y) 15346 for { 15347 x := v.Args[0] 15348 y := v.Args[1] 15349 v.reset(OpARMXOR) 15350 v.AddArg(x) 15351 v.AddArg(y) 15352 return true 15353 } 15354 } 15355 func rewriteValueARM_OpNeqPtr(v *Value, config *Config) bool { 15356 b := v.Block 15357 _ = b 15358 // match: (NeqPtr x y) 15359 // cond: 15360 // result: (NotEqual (CMP x y)) 15361 for { 15362 x := v.Args[0] 15363 y := v.Args[1] 15364 v.reset(OpARMNotEqual) 15365 v0 := b.NewValue0(v.Line, OpARMCMP, TypeFlags) 15366 v0.AddArg(x) 15367 v0.AddArg(y) 15368 v.AddArg(v0) 15369 return true 15370 } 15371 } 15372 func rewriteValueARM_OpNilCheck(v *Value, config *Config) bool { 15373 b := v.Block 15374 _ = b 15375 // match: (NilCheck ptr mem) 15376 // cond: 15377 // result: (LoweredNilCheck ptr mem) 15378 for { 15379 ptr := v.Args[0] 15380 mem := v.Args[1] 15381 v.reset(OpARMLoweredNilCheck) 15382 v.AddArg(ptr) 15383 v.AddArg(mem) 15384 return true 15385 } 15386 } 15387 func rewriteValueARM_OpNot(v *Value, config *Config) bool { 15388 b := v.Block 15389 _ = b 15390 // match: (Not x) 15391 // cond: 15392 // result: (XORconst [1] x) 15393 for { 15394 x := v.Args[0] 15395 v.reset(OpARMXORconst) 15396 v.AuxInt = 1 15397 v.AddArg(x) 15398 return true 15399 } 15400 } 15401 func rewriteValueARM_OpOffPtr(v *Value, config *Config) bool { 15402 b := v.Block 15403 _ = b 15404 // match: (OffPtr [off] ptr:(SP)) 15405 // cond: 15406 // result: (MOVWaddr [off] ptr) 15407 for { 15408 off := v.AuxInt 15409 ptr := v.Args[0] 15410 if ptr.Op != OpSP { 15411 break 15412 } 15413 v.reset(OpARMMOVWaddr) 15414 v.AuxInt = off 15415 v.AddArg(ptr) 15416 return true 15417 } 15418 // match: (OffPtr [off] ptr) 15419 // cond: 15420 // result: (ADDconst [off] ptr) 15421 for { 15422 off := v.AuxInt 15423 ptr := v.Args[0] 15424 v.reset(OpARMADDconst) 15425 v.AuxInt = off 15426 v.AddArg(ptr) 15427 return true 15428 } 15429 } 15430 func rewriteValueARM_OpOr16(v *Value, config *Config) bool { 15431 b := v.Block 15432 _ = b 15433 // match: (Or16 x y) 15434 // cond: 15435 // result: (OR x y) 15436 for { 15437 x := v.Args[0] 15438 y := v.Args[1] 15439 v.reset(OpARMOR) 15440 v.AddArg(x) 15441 v.AddArg(y) 15442 return true 15443 } 15444 } 15445 func rewriteValueARM_OpOr32(v *Value, config *Config) bool { 15446 b := v.Block 15447 _ = b 15448 // match: (Or32 x y) 15449 // cond: 15450 // result: (OR x y) 15451 for { 15452 x := v.Args[0] 15453 y := v.Args[1] 15454 v.reset(OpARMOR) 15455 v.AddArg(x) 15456 v.AddArg(y) 15457 return true 15458 } 15459 } 15460 func rewriteValueARM_OpOr8(v *Value, config *Config) bool { 15461 b := v.Block 15462 _ = b 15463 // match: (Or8 x y) 15464 // cond: 15465 // result: (OR x y) 15466 for { 15467 x := v.Args[0] 15468 y := v.Args[1] 15469 v.reset(OpARMOR) 15470 v.AddArg(x) 15471 v.AddArg(y) 15472 return true 15473 } 15474 } 15475 func rewriteValueARM_OpOrB(v *Value, config *Config) bool { 15476 b := v.Block 15477 _ = b 15478 // match: (OrB x y) 15479 // cond: 15480 // result: (OR x y) 15481 for { 15482 x := v.Args[0] 15483 y := v.Args[1] 15484 v.reset(OpARMOR) 15485 v.AddArg(x) 15486 v.AddArg(y) 15487 return true 15488 } 15489 } 15490 func rewriteValueARM_OpRsh16Ux16(v *Value, config *Config) bool { 15491 b := v.Block 15492 _ = b 15493 // match: (Rsh16Ux16 x y) 15494 // cond: 15495 // result: (CMOVWHSconst (SRL <x.Type> (ZeroExt16to32 x) (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 15496 for { 15497 x := v.Args[0] 15498 y := v.Args[1] 15499 v.reset(OpARMCMOVWHSconst) 15500 v.AuxInt = 0 15501 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 15502 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 15503 v1.AddArg(x) 15504 v0.AddArg(v1) 15505 v2 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 15506 v2.AddArg(y) 15507 v0.AddArg(v2) 15508 v.AddArg(v0) 15509 v3 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 15510 v3.AuxInt = 256 15511 v4 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 15512 v4.AddArg(y) 15513 v3.AddArg(v4) 15514 v.AddArg(v3) 15515 return true 15516 } 15517 } 15518 func rewriteValueARM_OpRsh16Ux32(v *Value, config *Config) bool { 15519 b := v.Block 15520 _ = b 15521 // match: (Rsh16Ux32 x y) 15522 // cond: 15523 // result: (CMOVWHSconst (SRL <x.Type> (ZeroExt16to32 x) y) (CMPconst [256] y) [0]) 15524 for { 15525 x := v.Args[0] 15526 y := v.Args[1] 15527 v.reset(OpARMCMOVWHSconst) 15528 v.AuxInt = 0 15529 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 15530 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 15531 v1.AddArg(x) 15532 v0.AddArg(v1) 15533 v0.AddArg(y) 15534 v.AddArg(v0) 15535 v2 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 15536 v2.AuxInt = 256 15537 v2.AddArg(y) 15538 v.AddArg(v2) 15539 return true 15540 } 15541 } 15542 func rewriteValueARM_OpRsh16Ux64(v *Value, config *Config) bool { 15543 b := v.Block 15544 _ = b 15545 // match: (Rsh16Ux64 x (Const64 [c])) 15546 // cond: uint64(c) < 16 15547 // result: (SRLconst (SLLconst <config.fe.TypeUInt32()> x [16]) [c+16]) 15548 for { 15549 x := v.Args[0] 15550 v_1 := v.Args[1] 15551 if v_1.Op != OpConst64 { 15552 break 15553 } 15554 c := v_1.AuxInt 15555 if !(uint64(c) < 16) { 15556 break 15557 } 15558 v.reset(OpARMSRLconst) 15559 v.AuxInt = c + 16 15560 v0 := b.NewValue0(v.Line, OpARMSLLconst, config.fe.TypeUInt32()) 15561 v0.AuxInt = 16 15562 v0.AddArg(x) 15563 v.AddArg(v0) 15564 return true 15565 } 15566 // match: (Rsh16Ux64 _ (Const64 [c])) 15567 // cond: uint64(c) >= 16 15568 // result: (Const16 [0]) 15569 for { 15570 v_1 := v.Args[1] 15571 if v_1.Op != OpConst64 { 15572 break 15573 } 15574 c := v_1.AuxInt 15575 if !(uint64(c) >= 16) { 15576 break 15577 } 15578 v.reset(OpConst16) 15579 v.AuxInt = 0 15580 return true 15581 } 15582 return false 15583 } 15584 func rewriteValueARM_OpRsh16Ux8(v *Value, config *Config) bool { 15585 b := v.Block 15586 _ = b 15587 // match: (Rsh16Ux8 x y) 15588 // cond: 15589 // result: (SRL (ZeroExt16to32 x) (ZeroExt8to32 y)) 15590 for { 15591 x := v.Args[0] 15592 y := v.Args[1] 15593 v.reset(OpARMSRL) 15594 v0 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 15595 v0.AddArg(x) 15596 v.AddArg(v0) 15597 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 15598 v1.AddArg(y) 15599 v.AddArg(v1) 15600 return true 15601 } 15602 } 15603 func rewriteValueARM_OpRsh16x16(v *Value, config *Config) bool { 15604 b := v.Block 15605 _ = b 15606 // match: (Rsh16x16 x y) 15607 // cond: 15608 // result: (SRAcond (SignExt16to32 x) (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y))) 15609 for { 15610 x := v.Args[0] 15611 y := v.Args[1] 15612 v.reset(OpARMSRAcond) 15613 v0 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 15614 v0.AddArg(x) 15615 v.AddArg(v0) 15616 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 15617 v1.AddArg(y) 15618 v.AddArg(v1) 15619 v2 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 15620 v2.AuxInt = 256 15621 v3 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 15622 v3.AddArg(y) 15623 v2.AddArg(v3) 15624 v.AddArg(v2) 15625 return true 15626 } 15627 } 15628 func rewriteValueARM_OpRsh16x32(v *Value, config *Config) bool { 15629 b := v.Block 15630 _ = b 15631 // match: (Rsh16x32 x y) 15632 // cond: 15633 // result: (SRAcond (SignExt16to32 x) y (CMPconst [256] y)) 15634 for { 15635 x := v.Args[0] 15636 y := v.Args[1] 15637 v.reset(OpARMSRAcond) 15638 v0 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 15639 v0.AddArg(x) 15640 v.AddArg(v0) 15641 v.AddArg(y) 15642 v1 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 15643 v1.AuxInt = 256 15644 v1.AddArg(y) 15645 v.AddArg(v1) 15646 return true 15647 } 15648 } 15649 func rewriteValueARM_OpRsh16x64(v *Value, config *Config) bool { 15650 b := v.Block 15651 _ = b 15652 // match: (Rsh16x64 x (Const64 [c])) 15653 // cond: uint64(c) < 16 15654 // result: (SRAconst (SLLconst <config.fe.TypeUInt32()> x [16]) [c+16]) 15655 for { 15656 x := v.Args[0] 15657 v_1 := v.Args[1] 15658 if v_1.Op != OpConst64 { 15659 break 15660 } 15661 c := v_1.AuxInt 15662 if !(uint64(c) < 16) { 15663 break 15664 } 15665 v.reset(OpARMSRAconst) 15666 v.AuxInt = c + 16 15667 v0 := b.NewValue0(v.Line, OpARMSLLconst, config.fe.TypeUInt32()) 15668 v0.AuxInt = 16 15669 v0.AddArg(x) 15670 v.AddArg(v0) 15671 return true 15672 } 15673 // match: (Rsh16x64 x (Const64 [c])) 15674 // cond: uint64(c) >= 16 15675 // result: (SRAconst (SLLconst <config.fe.TypeUInt32()> x [16]) [31]) 15676 for { 15677 x := v.Args[0] 15678 v_1 := v.Args[1] 15679 if v_1.Op != OpConst64 { 15680 break 15681 } 15682 c := v_1.AuxInt 15683 if !(uint64(c) >= 16) { 15684 break 15685 } 15686 v.reset(OpARMSRAconst) 15687 v.AuxInt = 31 15688 v0 := b.NewValue0(v.Line, OpARMSLLconst, config.fe.TypeUInt32()) 15689 v0.AuxInt = 16 15690 v0.AddArg(x) 15691 v.AddArg(v0) 15692 return true 15693 } 15694 return false 15695 } 15696 func rewriteValueARM_OpRsh16x8(v *Value, config *Config) bool { 15697 b := v.Block 15698 _ = b 15699 // match: (Rsh16x8 x y) 15700 // cond: 15701 // result: (SRA (SignExt16to32 x) (ZeroExt8to32 y)) 15702 for { 15703 x := v.Args[0] 15704 y := v.Args[1] 15705 v.reset(OpARMSRA) 15706 v0 := b.NewValue0(v.Line, OpSignExt16to32, config.fe.TypeInt32()) 15707 v0.AddArg(x) 15708 v.AddArg(v0) 15709 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 15710 v1.AddArg(y) 15711 v.AddArg(v1) 15712 return true 15713 } 15714 } 15715 func rewriteValueARM_OpRsh32Ux16(v *Value, config *Config) bool { 15716 b := v.Block 15717 _ = b 15718 // match: (Rsh32Ux16 x y) 15719 // cond: 15720 // result: (CMOVWHSconst (SRL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 15721 for { 15722 x := v.Args[0] 15723 y := v.Args[1] 15724 v.reset(OpARMCMOVWHSconst) 15725 v.AuxInt = 0 15726 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 15727 v0.AddArg(x) 15728 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 15729 v1.AddArg(y) 15730 v0.AddArg(v1) 15731 v.AddArg(v0) 15732 v2 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 15733 v2.AuxInt = 256 15734 v3 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 15735 v3.AddArg(y) 15736 v2.AddArg(v3) 15737 v.AddArg(v2) 15738 return true 15739 } 15740 } 15741 func rewriteValueARM_OpRsh32Ux32(v *Value, config *Config) bool { 15742 b := v.Block 15743 _ = b 15744 // match: (Rsh32Ux32 x y) 15745 // cond: 15746 // result: (CMOVWHSconst (SRL <x.Type> x y) (CMPconst [256] y) [0]) 15747 for { 15748 x := v.Args[0] 15749 y := v.Args[1] 15750 v.reset(OpARMCMOVWHSconst) 15751 v.AuxInt = 0 15752 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 15753 v0.AddArg(x) 15754 v0.AddArg(y) 15755 v.AddArg(v0) 15756 v1 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 15757 v1.AuxInt = 256 15758 v1.AddArg(y) 15759 v.AddArg(v1) 15760 return true 15761 } 15762 } 15763 func rewriteValueARM_OpRsh32Ux64(v *Value, config *Config) bool { 15764 b := v.Block 15765 _ = b 15766 // match: (Rsh32Ux64 x (Const64 [c])) 15767 // cond: uint64(c) < 32 15768 // result: (SRLconst x [c]) 15769 for { 15770 x := v.Args[0] 15771 v_1 := v.Args[1] 15772 if v_1.Op != OpConst64 { 15773 break 15774 } 15775 c := v_1.AuxInt 15776 if !(uint64(c) < 32) { 15777 break 15778 } 15779 v.reset(OpARMSRLconst) 15780 v.AuxInt = c 15781 v.AddArg(x) 15782 return true 15783 } 15784 // match: (Rsh32Ux64 _ (Const64 [c])) 15785 // cond: uint64(c) >= 32 15786 // result: (Const32 [0]) 15787 for { 15788 v_1 := v.Args[1] 15789 if v_1.Op != OpConst64 { 15790 break 15791 } 15792 c := v_1.AuxInt 15793 if !(uint64(c) >= 32) { 15794 break 15795 } 15796 v.reset(OpConst32) 15797 v.AuxInt = 0 15798 return true 15799 } 15800 return false 15801 } 15802 func rewriteValueARM_OpRsh32Ux8(v *Value, config *Config) bool { 15803 b := v.Block 15804 _ = b 15805 // match: (Rsh32Ux8 x y) 15806 // cond: 15807 // result: (SRL x (ZeroExt8to32 y)) 15808 for { 15809 x := v.Args[0] 15810 y := v.Args[1] 15811 v.reset(OpARMSRL) 15812 v.AddArg(x) 15813 v0 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 15814 v0.AddArg(y) 15815 v.AddArg(v0) 15816 return true 15817 } 15818 } 15819 func rewriteValueARM_OpRsh32x16(v *Value, config *Config) bool { 15820 b := v.Block 15821 _ = b 15822 // match: (Rsh32x16 x y) 15823 // cond: 15824 // result: (SRAcond x (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y))) 15825 for { 15826 x := v.Args[0] 15827 y := v.Args[1] 15828 v.reset(OpARMSRAcond) 15829 v.AddArg(x) 15830 v0 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 15831 v0.AddArg(y) 15832 v.AddArg(v0) 15833 v1 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 15834 v1.AuxInt = 256 15835 v2 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 15836 v2.AddArg(y) 15837 v1.AddArg(v2) 15838 v.AddArg(v1) 15839 return true 15840 } 15841 } 15842 func rewriteValueARM_OpRsh32x32(v *Value, config *Config) bool { 15843 b := v.Block 15844 _ = b 15845 // match: (Rsh32x32 x y) 15846 // cond: 15847 // result: (SRAcond x y (CMPconst [256] y)) 15848 for { 15849 x := v.Args[0] 15850 y := v.Args[1] 15851 v.reset(OpARMSRAcond) 15852 v.AddArg(x) 15853 v.AddArg(y) 15854 v0 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 15855 v0.AuxInt = 256 15856 v0.AddArg(y) 15857 v.AddArg(v0) 15858 return true 15859 } 15860 } 15861 func rewriteValueARM_OpRsh32x64(v *Value, config *Config) bool { 15862 b := v.Block 15863 _ = b 15864 // match: (Rsh32x64 x (Const64 [c])) 15865 // cond: uint64(c) < 32 15866 // result: (SRAconst x [c]) 15867 for { 15868 x := v.Args[0] 15869 v_1 := v.Args[1] 15870 if v_1.Op != OpConst64 { 15871 break 15872 } 15873 c := v_1.AuxInt 15874 if !(uint64(c) < 32) { 15875 break 15876 } 15877 v.reset(OpARMSRAconst) 15878 v.AuxInt = c 15879 v.AddArg(x) 15880 return true 15881 } 15882 // match: (Rsh32x64 x (Const64 [c])) 15883 // cond: uint64(c) >= 32 15884 // result: (SRAconst x [31]) 15885 for { 15886 x := v.Args[0] 15887 v_1 := v.Args[1] 15888 if v_1.Op != OpConst64 { 15889 break 15890 } 15891 c := v_1.AuxInt 15892 if !(uint64(c) >= 32) { 15893 break 15894 } 15895 v.reset(OpARMSRAconst) 15896 v.AuxInt = 31 15897 v.AddArg(x) 15898 return true 15899 } 15900 return false 15901 } 15902 func rewriteValueARM_OpRsh32x8(v *Value, config *Config) bool { 15903 b := v.Block 15904 _ = b 15905 // match: (Rsh32x8 x y) 15906 // cond: 15907 // result: (SRA x (ZeroExt8to32 y)) 15908 for { 15909 x := v.Args[0] 15910 y := v.Args[1] 15911 v.reset(OpARMSRA) 15912 v.AddArg(x) 15913 v0 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 15914 v0.AddArg(y) 15915 v.AddArg(v0) 15916 return true 15917 } 15918 } 15919 func rewriteValueARM_OpRsh8Ux16(v *Value, config *Config) bool { 15920 b := v.Block 15921 _ = b 15922 // match: (Rsh8Ux16 x y) 15923 // cond: 15924 // result: (CMOVWHSconst (SRL <x.Type> (ZeroExt8to32 x) (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 15925 for { 15926 x := v.Args[0] 15927 y := v.Args[1] 15928 v.reset(OpARMCMOVWHSconst) 15929 v.AuxInt = 0 15930 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 15931 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 15932 v1.AddArg(x) 15933 v0.AddArg(v1) 15934 v2 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 15935 v2.AddArg(y) 15936 v0.AddArg(v2) 15937 v.AddArg(v0) 15938 v3 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 15939 v3.AuxInt = 256 15940 v4 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 15941 v4.AddArg(y) 15942 v3.AddArg(v4) 15943 v.AddArg(v3) 15944 return true 15945 } 15946 } 15947 func rewriteValueARM_OpRsh8Ux32(v *Value, config *Config) bool { 15948 b := v.Block 15949 _ = b 15950 // match: (Rsh8Ux32 x y) 15951 // cond: 15952 // result: (CMOVWHSconst (SRL <x.Type> (ZeroExt8to32 x) y) (CMPconst [256] y) [0]) 15953 for { 15954 x := v.Args[0] 15955 y := v.Args[1] 15956 v.reset(OpARMCMOVWHSconst) 15957 v.AuxInt = 0 15958 v0 := b.NewValue0(v.Line, OpARMSRL, x.Type) 15959 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 15960 v1.AddArg(x) 15961 v0.AddArg(v1) 15962 v0.AddArg(y) 15963 v.AddArg(v0) 15964 v2 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 15965 v2.AuxInt = 256 15966 v2.AddArg(y) 15967 v.AddArg(v2) 15968 return true 15969 } 15970 } 15971 func rewriteValueARM_OpRsh8Ux64(v *Value, config *Config) bool { 15972 b := v.Block 15973 _ = b 15974 // match: (Rsh8Ux64 x (Const64 [c])) 15975 // cond: uint64(c) < 8 15976 // result: (SRLconst (SLLconst <config.fe.TypeUInt32()> x [24]) [c+24]) 15977 for { 15978 x := v.Args[0] 15979 v_1 := v.Args[1] 15980 if v_1.Op != OpConst64 { 15981 break 15982 } 15983 c := v_1.AuxInt 15984 if !(uint64(c) < 8) { 15985 break 15986 } 15987 v.reset(OpARMSRLconst) 15988 v.AuxInt = c + 24 15989 v0 := b.NewValue0(v.Line, OpARMSLLconst, config.fe.TypeUInt32()) 15990 v0.AuxInt = 24 15991 v0.AddArg(x) 15992 v.AddArg(v0) 15993 return true 15994 } 15995 // match: (Rsh8Ux64 _ (Const64 [c])) 15996 // cond: uint64(c) >= 8 15997 // result: (Const8 [0]) 15998 for { 15999 v_1 := v.Args[1] 16000 if v_1.Op != OpConst64 { 16001 break 16002 } 16003 c := v_1.AuxInt 16004 if !(uint64(c) >= 8) { 16005 break 16006 } 16007 v.reset(OpConst8) 16008 v.AuxInt = 0 16009 return true 16010 } 16011 return false 16012 } 16013 func rewriteValueARM_OpRsh8Ux8(v *Value, config *Config) bool { 16014 b := v.Block 16015 _ = b 16016 // match: (Rsh8Ux8 x y) 16017 // cond: 16018 // result: (SRL (ZeroExt8to32 x) (ZeroExt8to32 y)) 16019 for { 16020 x := v.Args[0] 16021 y := v.Args[1] 16022 v.reset(OpARMSRL) 16023 v0 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 16024 v0.AddArg(x) 16025 v.AddArg(v0) 16026 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 16027 v1.AddArg(y) 16028 v.AddArg(v1) 16029 return true 16030 } 16031 } 16032 func rewriteValueARM_OpRsh8x16(v *Value, config *Config) bool { 16033 b := v.Block 16034 _ = b 16035 // match: (Rsh8x16 x y) 16036 // cond: 16037 // result: (SRAcond (SignExt8to32 x) (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y))) 16038 for { 16039 x := v.Args[0] 16040 y := v.Args[1] 16041 v.reset(OpARMSRAcond) 16042 v0 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 16043 v0.AddArg(x) 16044 v.AddArg(v0) 16045 v1 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 16046 v1.AddArg(y) 16047 v.AddArg(v1) 16048 v2 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 16049 v2.AuxInt = 256 16050 v3 := b.NewValue0(v.Line, OpZeroExt16to32, config.fe.TypeUInt32()) 16051 v3.AddArg(y) 16052 v2.AddArg(v3) 16053 v.AddArg(v2) 16054 return true 16055 } 16056 } 16057 func rewriteValueARM_OpRsh8x32(v *Value, config *Config) bool { 16058 b := v.Block 16059 _ = b 16060 // match: (Rsh8x32 x y) 16061 // cond: 16062 // result: (SRAcond (SignExt8to32 x) y (CMPconst [256] y)) 16063 for { 16064 x := v.Args[0] 16065 y := v.Args[1] 16066 v.reset(OpARMSRAcond) 16067 v0 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 16068 v0.AddArg(x) 16069 v.AddArg(v0) 16070 v.AddArg(y) 16071 v1 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 16072 v1.AuxInt = 256 16073 v1.AddArg(y) 16074 v.AddArg(v1) 16075 return true 16076 } 16077 } 16078 func rewriteValueARM_OpRsh8x64(v *Value, config *Config) bool { 16079 b := v.Block 16080 _ = b 16081 // match: (Rsh8x64 x (Const64 [c])) 16082 // cond: uint64(c) < 8 16083 // result: (SRAconst (SLLconst <config.fe.TypeUInt32()> x [24]) [c+24]) 16084 for { 16085 x := v.Args[0] 16086 v_1 := v.Args[1] 16087 if v_1.Op != OpConst64 { 16088 break 16089 } 16090 c := v_1.AuxInt 16091 if !(uint64(c) < 8) { 16092 break 16093 } 16094 v.reset(OpARMSRAconst) 16095 v.AuxInt = c + 24 16096 v0 := b.NewValue0(v.Line, OpARMSLLconst, config.fe.TypeUInt32()) 16097 v0.AuxInt = 24 16098 v0.AddArg(x) 16099 v.AddArg(v0) 16100 return true 16101 } 16102 // match: (Rsh8x64 x (Const64 [c])) 16103 // cond: uint64(c) >= 8 16104 // result: (SRAconst (SLLconst <config.fe.TypeUInt32()> x [24]) [31]) 16105 for { 16106 x := v.Args[0] 16107 v_1 := v.Args[1] 16108 if v_1.Op != OpConst64 { 16109 break 16110 } 16111 c := v_1.AuxInt 16112 if !(uint64(c) >= 8) { 16113 break 16114 } 16115 v.reset(OpARMSRAconst) 16116 v.AuxInt = 31 16117 v0 := b.NewValue0(v.Line, OpARMSLLconst, config.fe.TypeUInt32()) 16118 v0.AuxInt = 24 16119 v0.AddArg(x) 16120 v.AddArg(v0) 16121 return true 16122 } 16123 return false 16124 } 16125 func rewriteValueARM_OpRsh8x8(v *Value, config *Config) bool { 16126 b := v.Block 16127 _ = b 16128 // match: (Rsh8x8 x y) 16129 // cond: 16130 // result: (SRA (SignExt8to32 x) (ZeroExt8to32 y)) 16131 for { 16132 x := v.Args[0] 16133 y := v.Args[1] 16134 v.reset(OpARMSRA) 16135 v0 := b.NewValue0(v.Line, OpSignExt8to32, config.fe.TypeInt32()) 16136 v0.AddArg(x) 16137 v.AddArg(v0) 16138 v1 := b.NewValue0(v.Line, OpZeroExt8to32, config.fe.TypeUInt32()) 16139 v1.AddArg(y) 16140 v.AddArg(v1) 16141 return true 16142 } 16143 } 16144 func rewriteValueARM_OpSignExt16to32(v *Value, config *Config) bool { 16145 b := v.Block 16146 _ = b 16147 // match: (SignExt16to32 x) 16148 // cond: 16149 // result: (MOVHreg x) 16150 for { 16151 x := v.Args[0] 16152 v.reset(OpARMMOVHreg) 16153 v.AddArg(x) 16154 return true 16155 } 16156 } 16157 func rewriteValueARM_OpSignExt8to16(v *Value, config *Config) bool { 16158 b := v.Block 16159 _ = b 16160 // match: (SignExt8to16 x) 16161 // cond: 16162 // result: (MOVBreg x) 16163 for { 16164 x := v.Args[0] 16165 v.reset(OpARMMOVBreg) 16166 v.AddArg(x) 16167 return true 16168 } 16169 } 16170 func rewriteValueARM_OpSignExt8to32(v *Value, config *Config) bool { 16171 b := v.Block 16172 _ = b 16173 // match: (SignExt8to32 x) 16174 // cond: 16175 // result: (MOVBreg x) 16176 for { 16177 x := v.Args[0] 16178 v.reset(OpARMMOVBreg) 16179 v.AddArg(x) 16180 return true 16181 } 16182 } 16183 func rewriteValueARM_OpSignmask(v *Value, config *Config) bool { 16184 b := v.Block 16185 _ = b 16186 // match: (Signmask x) 16187 // cond: 16188 // result: (SRAconst x [31]) 16189 for { 16190 x := v.Args[0] 16191 v.reset(OpARMSRAconst) 16192 v.AuxInt = 31 16193 v.AddArg(x) 16194 return true 16195 } 16196 } 16197 func rewriteValueARM_OpSqrt(v *Value, config *Config) bool { 16198 b := v.Block 16199 _ = b 16200 // match: (Sqrt x) 16201 // cond: 16202 // result: (SQRTD x) 16203 for { 16204 x := v.Args[0] 16205 v.reset(OpARMSQRTD) 16206 v.AddArg(x) 16207 return true 16208 } 16209 } 16210 func rewriteValueARM_OpStaticCall(v *Value, config *Config) bool { 16211 b := v.Block 16212 _ = b 16213 // match: (StaticCall [argwid] {target} mem) 16214 // cond: 16215 // result: (CALLstatic [argwid] {target} mem) 16216 for { 16217 argwid := v.AuxInt 16218 target := v.Aux 16219 mem := v.Args[0] 16220 v.reset(OpARMCALLstatic) 16221 v.AuxInt = argwid 16222 v.Aux = target 16223 v.AddArg(mem) 16224 return true 16225 } 16226 } 16227 func rewriteValueARM_OpStore(v *Value, config *Config) bool { 16228 b := v.Block 16229 _ = b 16230 // match: (Store [1] ptr val mem) 16231 // cond: 16232 // result: (MOVBstore ptr val mem) 16233 for { 16234 if v.AuxInt != 1 { 16235 break 16236 } 16237 ptr := v.Args[0] 16238 val := v.Args[1] 16239 mem := v.Args[2] 16240 v.reset(OpARMMOVBstore) 16241 v.AddArg(ptr) 16242 v.AddArg(val) 16243 v.AddArg(mem) 16244 return true 16245 } 16246 // match: (Store [2] ptr val mem) 16247 // cond: 16248 // result: (MOVHstore ptr val mem) 16249 for { 16250 if v.AuxInt != 2 { 16251 break 16252 } 16253 ptr := v.Args[0] 16254 val := v.Args[1] 16255 mem := v.Args[2] 16256 v.reset(OpARMMOVHstore) 16257 v.AddArg(ptr) 16258 v.AddArg(val) 16259 v.AddArg(mem) 16260 return true 16261 } 16262 // match: (Store [4] ptr val mem) 16263 // cond: !is32BitFloat(val.Type) 16264 // result: (MOVWstore ptr val mem) 16265 for { 16266 if v.AuxInt != 4 { 16267 break 16268 } 16269 ptr := v.Args[0] 16270 val := v.Args[1] 16271 mem := v.Args[2] 16272 if !(!is32BitFloat(val.Type)) { 16273 break 16274 } 16275 v.reset(OpARMMOVWstore) 16276 v.AddArg(ptr) 16277 v.AddArg(val) 16278 v.AddArg(mem) 16279 return true 16280 } 16281 // match: (Store [4] ptr val mem) 16282 // cond: is32BitFloat(val.Type) 16283 // result: (MOVFstore ptr val mem) 16284 for { 16285 if v.AuxInt != 4 { 16286 break 16287 } 16288 ptr := v.Args[0] 16289 val := v.Args[1] 16290 mem := v.Args[2] 16291 if !(is32BitFloat(val.Type)) { 16292 break 16293 } 16294 v.reset(OpARMMOVFstore) 16295 v.AddArg(ptr) 16296 v.AddArg(val) 16297 v.AddArg(mem) 16298 return true 16299 } 16300 // match: (Store [8] ptr val mem) 16301 // cond: is64BitFloat(val.Type) 16302 // result: (MOVDstore ptr val mem) 16303 for { 16304 if v.AuxInt != 8 { 16305 break 16306 } 16307 ptr := v.Args[0] 16308 val := v.Args[1] 16309 mem := v.Args[2] 16310 if !(is64BitFloat(val.Type)) { 16311 break 16312 } 16313 v.reset(OpARMMOVDstore) 16314 v.AddArg(ptr) 16315 v.AddArg(val) 16316 v.AddArg(mem) 16317 return true 16318 } 16319 return false 16320 } 16321 func rewriteValueARM_OpSub16(v *Value, config *Config) bool { 16322 b := v.Block 16323 _ = b 16324 // match: (Sub16 x y) 16325 // cond: 16326 // result: (SUB x y) 16327 for { 16328 x := v.Args[0] 16329 y := v.Args[1] 16330 v.reset(OpARMSUB) 16331 v.AddArg(x) 16332 v.AddArg(y) 16333 return true 16334 } 16335 } 16336 func rewriteValueARM_OpSub32(v *Value, config *Config) bool { 16337 b := v.Block 16338 _ = b 16339 // match: (Sub32 x y) 16340 // cond: 16341 // result: (SUB x y) 16342 for { 16343 x := v.Args[0] 16344 y := v.Args[1] 16345 v.reset(OpARMSUB) 16346 v.AddArg(x) 16347 v.AddArg(y) 16348 return true 16349 } 16350 } 16351 func rewriteValueARM_OpSub32F(v *Value, config *Config) bool { 16352 b := v.Block 16353 _ = b 16354 // match: (Sub32F x y) 16355 // cond: 16356 // result: (SUBF x y) 16357 for { 16358 x := v.Args[0] 16359 y := v.Args[1] 16360 v.reset(OpARMSUBF) 16361 v.AddArg(x) 16362 v.AddArg(y) 16363 return true 16364 } 16365 } 16366 func rewriteValueARM_OpSub32carry(v *Value, config *Config) bool { 16367 b := v.Block 16368 _ = b 16369 // match: (Sub32carry x y) 16370 // cond: 16371 // result: (SUBS x y) 16372 for { 16373 x := v.Args[0] 16374 y := v.Args[1] 16375 v.reset(OpARMSUBS) 16376 v.AddArg(x) 16377 v.AddArg(y) 16378 return true 16379 } 16380 } 16381 func rewriteValueARM_OpSub32withcarry(v *Value, config *Config) bool { 16382 b := v.Block 16383 _ = b 16384 // match: (Sub32withcarry x y c) 16385 // cond: 16386 // result: (SBC x y c) 16387 for { 16388 x := v.Args[0] 16389 y := v.Args[1] 16390 c := v.Args[2] 16391 v.reset(OpARMSBC) 16392 v.AddArg(x) 16393 v.AddArg(y) 16394 v.AddArg(c) 16395 return true 16396 } 16397 } 16398 func rewriteValueARM_OpSub64F(v *Value, config *Config) bool { 16399 b := v.Block 16400 _ = b 16401 // match: (Sub64F x y) 16402 // cond: 16403 // result: (SUBD x y) 16404 for { 16405 x := v.Args[0] 16406 y := v.Args[1] 16407 v.reset(OpARMSUBD) 16408 v.AddArg(x) 16409 v.AddArg(y) 16410 return true 16411 } 16412 } 16413 func rewriteValueARM_OpSub8(v *Value, config *Config) bool { 16414 b := v.Block 16415 _ = b 16416 // match: (Sub8 x y) 16417 // cond: 16418 // result: (SUB x y) 16419 for { 16420 x := v.Args[0] 16421 y := v.Args[1] 16422 v.reset(OpARMSUB) 16423 v.AddArg(x) 16424 v.AddArg(y) 16425 return true 16426 } 16427 } 16428 func rewriteValueARM_OpSubPtr(v *Value, config *Config) bool { 16429 b := v.Block 16430 _ = b 16431 // match: (SubPtr x y) 16432 // cond: 16433 // result: (SUB x y) 16434 for { 16435 x := v.Args[0] 16436 y := v.Args[1] 16437 v.reset(OpARMSUB) 16438 v.AddArg(x) 16439 v.AddArg(y) 16440 return true 16441 } 16442 } 16443 func rewriteValueARM_OpTrunc16to8(v *Value, config *Config) bool { 16444 b := v.Block 16445 _ = b 16446 // match: (Trunc16to8 x) 16447 // cond: 16448 // result: x 16449 for { 16450 x := v.Args[0] 16451 v.reset(OpCopy) 16452 v.Type = x.Type 16453 v.AddArg(x) 16454 return true 16455 } 16456 } 16457 func rewriteValueARM_OpTrunc32to16(v *Value, config *Config) bool { 16458 b := v.Block 16459 _ = b 16460 // match: (Trunc32to16 x) 16461 // cond: 16462 // result: x 16463 for { 16464 x := v.Args[0] 16465 v.reset(OpCopy) 16466 v.Type = x.Type 16467 v.AddArg(x) 16468 return true 16469 } 16470 } 16471 func rewriteValueARM_OpTrunc32to8(v *Value, config *Config) bool { 16472 b := v.Block 16473 _ = b 16474 // match: (Trunc32to8 x) 16475 // cond: 16476 // result: x 16477 for { 16478 x := v.Args[0] 16479 v.reset(OpCopy) 16480 v.Type = x.Type 16481 v.AddArg(x) 16482 return true 16483 } 16484 } 16485 func rewriteValueARM_OpXor16(v *Value, config *Config) bool { 16486 b := v.Block 16487 _ = b 16488 // match: (Xor16 x y) 16489 // cond: 16490 // result: (XOR x y) 16491 for { 16492 x := v.Args[0] 16493 y := v.Args[1] 16494 v.reset(OpARMXOR) 16495 v.AddArg(x) 16496 v.AddArg(y) 16497 return true 16498 } 16499 } 16500 func rewriteValueARM_OpXor32(v *Value, config *Config) bool { 16501 b := v.Block 16502 _ = b 16503 // match: (Xor32 x y) 16504 // cond: 16505 // result: (XOR x y) 16506 for { 16507 x := v.Args[0] 16508 y := v.Args[1] 16509 v.reset(OpARMXOR) 16510 v.AddArg(x) 16511 v.AddArg(y) 16512 return true 16513 } 16514 } 16515 func rewriteValueARM_OpXor8(v *Value, config *Config) bool { 16516 b := v.Block 16517 _ = b 16518 // match: (Xor8 x y) 16519 // cond: 16520 // result: (XOR x y) 16521 for { 16522 x := v.Args[0] 16523 y := v.Args[1] 16524 v.reset(OpARMXOR) 16525 v.AddArg(x) 16526 v.AddArg(y) 16527 return true 16528 } 16529 } 16530 func rewriteValueARM_OpZero(v *Value, config *Config) bool { 16531 b := v.Block 16532 _ = b 16533 // match: (Zero [s] _ mem) 16534 // cond: SizeAndAlign(s).Size() == 0 16535 // result: mem 16536 for { 16537 s := v.AuxInt 16538 mem := v.Args[1] 16539 if !(SizeAndAlign(s).Size() == 0) { 16540 break 16541 } 16542 v.reset(OpCopy) 16543 v.Type = mem.Type 16544 v.AddArg(mem) 16545 return true 16546 } 16547 // match: (Zero [s] ptr mem) 16548 // cond: SizeAndAlign(s).Size() == 1 16549 // result: (MOVBstore ptr (MOVWconst [0]) mem) 16550 for { 16551 s := v.AuxInt 16552 ptr := v.Args[0] 16553 mem := v.Args[1] 16554 if !(SizeAndAlign(s).Size() == 1) { 16555 break 16556 } 16557 v.reset(OpARMMOVBstore) 16558 v.AddArg(ptr) 16559 v0 := b.NewValue0(v.Line, OpARMMOVWconst, config.fe.TypeUInt32()) 16560 v0.AuxInt = 0 16561 v.AddArg(v0) 16562 v.AddArg(mem) 16563 return true 16564 } 16565 // match: (Zero [s] ptr mem) 16566 // cond: SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0 16567 // result: (MOVHstore ptr (MOVWconst [0]) mem) 16568 for { 16569 s := v.AuxInt 16570 ptr := v.Args[0] 16571 mem := v.Args[1] 16572 if !(SizeAndAlign(s).Size() == 2 && SizeAndAlign(s).Align()%2 == 0) { 16573 break 16574 } 16575 v.reset(OpARMMOVHstore) 16576 v.AddArg(ptr) 16577 v0 := b.NewValue0(v.Line, OpARMMOVWconst, config.fe.TypeUInt32()) 16578 v0.AuxInt = 0 16579 v.AddArg(v0) 16580 v.AddArg(mem) 16581 return true 16582 } 16583 // match: (Zero [s] ptr mem) 16584 // cond: SizeAndAlign(s).Size() == 2 16585 // result: (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem)) 16586 for { 16587 s := v.AuxInt 16588 ptr := v.Args[0] 16589 mem := v.Args[1] 16590 if !(SizeAndAlign(s).Size() == 2) { 16591 break 16592 } 16593 v.reset(OpARMMOVBstore) 16594 v.AuxInt = 1 16595 v.AddArg(ptr) 16596 v0 := b.NewValue0(v.Line, OpARMMOVWconst, config.fe.TypeUInt32()) 16597 v0.AuxInt = 0 16598 v.AddArg(v0) 16599 v1 := b.NewValue0(v.Line, OpARMMOVBstore, TypeMem) 16600 v1.AuxInt = 0 16601 v1.AddArg(ptr) 16602 v2 := b.NewValue0(v.Line, OpARMMOVWconst, config.fe.TypeUInt32()) 16603 v2.AuxInt = 0 16604 v1.AddArg(v2) 16605 v1.AddArg(mem) 16606 v.AddArg(v1) 16607 return true 16608 } 16609 // match: (Zero [s] ptr mem) 16610 // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0 16611 // result: (MOVWstore ptr (MOVWconst [0]) mem) 16612 for { 16613 s := v.AuxInt 16614 ptr := v.Args[0] 16615 mem := v.Args[1] 16616 if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%4 == 0) { 16617 break 16618 } 16619 v.reset(OpARMMOVWstore) 16620 v.AddArg(ptr) 16621 v0 := b.NewValue0(v.Line, OpARMMOVWconst, config.fe.TypeUInt32()) 16622 v0.AuxInt = 0 16623 v.AddArg(v0) 16624 v.AddArg(mem) 16625 return true 16626 } 16627 // match: (Zero [s] ptr mem) 16628 // cond: SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0 16629 // result: (MOVHstore [2] ptr (MOVWconst [0]) (MOVHstore [0] ptr (MOVWconst [0]) mem)) 16630 for { 16631 s := v.AuxInt 16632 ptr := v.Args[0] 16633 mem := v.Args[1] 16634 if !(SizeAndAlign(s).Size() == 4 && SizeAndAlign(s).Align()%2 == 0) { 16635 break 16636 } 16637 v.reset(OpARMMOVHstore) 16638 v.AuxInt = 2 16639 v.AddArg(ptr) 16640 v0 := b.NewValue0(v.Line, OpARMMOVWconst, config.fe.TypeUInt32()) 16641 v0.AuxInt = 0 16642 v.AddArg(v0) 16643 v1 := b.NewValue0(v.Line, OpARMMOVHstore, TypeMem) 16644 v1.AuxInt = 0 16645 v1.AddArg(ptr) 16646 v2 := b.NewValue0(v.Line, OpARMMOVWconst, config.fe.TypeUInt32()) 16647 v2.AuxInt = 0 16648 v1.AddArg(v2) 16649 v1.AddArg(mem) 16650 v.AddArg(v1) 16651 return true 16652 } 16653 // match: (Zero [s] ptr mem) 16654 // cond: SizeAndAlign(s).Size() == 4 16655 // result: (MOVBstore [3] ptr (MOVWconst [0]) (MOVBstore [2] ptr (MOVWconst [0]) (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem)))) 16656 for { 16657 s := v.AuxInt 16658 ptr := v.Args[0] 16659 mem := v.Args[1] 16660 if !(SizeAndAlign(s).Size() == 4) { 16661 break 16662 } 16663 v.reset(OpARMMOVBstore) 16664 v.AuxInt = 3 16665 v.AddArg(ptr) 16666 v0 := b.NewValue0(v.Line, OpARMMOVWconst, config.fe.TypeUInt32()) 16667 v0.AuxInt = 0 16668 v.AddArg(v0) 16669 v1 := b.NewValue0(v.Line, OpARMMOVBstore, TypeMem) 16670 v1.AuxInt = 2 16671 v1.AddArg(ptr) 16672 v2 := b.NewValue0(v.Line, OpARMMOVWconst, config.fe.TypeUInt32()) 16673 v2.AuxInt = 0 16674 v1.AddArg(v2) 16675 v3 := b.NewValue0(v.Line, OpARMMOVBstore, TypeMem) 16676 v3.AuxInt = 1 16677 v3.AddArg(ptr) 16678 v4 := b.NewValue0(v.Line, OpARMMOVWconst, config.fe.TypeUInt32()) 16679 v4.AuxInt = 0 16680 v3.AddArg(v4) 16681 v5 := b.NewValue0(v.Line, OpARMMOVBstore, TypeMem) 16682 v5.AuxInt = 0 16683 v5.AddArg(ptr) 16684 v6 := b.NewValue0(v.Line, OpARMMOVWconst, config.fe.TypeUInt32()) 16685 v6.AuxInt = 0 16686 v5.AddArg(v6) 16687 v5.AddArg(mem) 16688 v3.AddArg(v5) 16689 v1.AddArg(v3) 16690 v.AddArg(v1) 16691 return true 16692 } 16693 // match: (Zero [s] ptr mem) 16694 // cond: SizeAndAlign(s).Size() == 3 16695 // result: (MOVBstore [2] ptr (MOVWconst [0]) (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem))) 16696 for { 16697 s := v.AuxInt 16698 ptr := v.Args[0] 16699 mem := v.Args[1] 16700 if !(SizeAndAlign(s).Size() == 3) { 16701 break 16702 } 16703 v.reset(OpARMMOVBstore) 16704 v.AuxInt = 2 16705 v.AddArg(ptr) 16706 v0 := b.NewValue0(v.Line, OpARMMOVWconst, config.fe.TypeUInt32()) 16707 v0.AuxInt = 0 16708 v.AddArg(v0) 16709 v1 := b.NewValue0(v.Line, OpARMMOVBstore, TypeMem) 16710 v1.AuxInt = 1 16711 v1.AddArg(ptr) 16712 v2 := b.NewValue0(v.Line, OpARMMOVWconst, config.fe.TypeUInt32()) 16713 v2.AuxInt = 0 16714 v1.AddArg(v2) 16715 v3 := b.NewValue0(v.Line, OpARMMOVBstore, TypeMem) 16716 v3.AuxInt = 0 16717 v3.AddArg(ptr) 16718 v4 := b.NewValue0(v.Line, OpARMMOVWconst, config.fe.TypeUInt32()) 16719 v4.AuxInt = 0 16720 v3.AddArg(v4) 16721 v3.AddArg(mem) 16722 v1.AddArg(v3) 16723 v.AddArg(v1) 16724 return true 16725 } 16726 // match: (Zero [s] ptr mem) 16727 // cond: SizeAndAlign(s).Size()%4 == 0 && SizeAndAlign(s).Size() > 4 && SizeAndAlign(s).Size() <= 512 && SizeAndAlign(s).Align()%4 == 0 && !config.noDuffDevice 16728 // result: (DUFFZERO [4 * (128 - int64(SizeAndAlign(s).Size()/4))] ptr (MOVWconst [0]) mem) 16729 for { 16730 s := v.AuxInt 16731 ptr := v.Args[0] 16732 mem := v.Args[1] 16733 if !(SizeAndAlign(s).Size()%4 == 0 && SizeAndAlign(s).Size() > 4 && SizeAndAlign(s).Size() <= 512 && SizeAndAlign(s).Align()%4 == 0 && !config.noDuffDevice) { 16734 break 16735 } 16736 v.reset(OpARMDUFFZERO) 16737 v.AuxInt = 4 * (128 - int64(SizeAndAlign(s).Size()/4)) 16738 v.AddArg(ptr) 16739 v0 := b.NewValue0(v.Line, OpARMMOVWconst, config.fe.TypeUInt32()) 16740 v0.AuxInt = 0 16741 v.AddArg(v0) 16742 v.AddArg(mem) 16743 return true 16744 } 16745 // match: (Zero [s] ptr mem) 16746 // cond: (SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%4 != 0 16747 // result: (LoweredZero [SizeAndAlign(s).Align()] ptr (ADDconst <ptr.Type> ptr [SizeAndAlign(s).Size()-moveSize(SizeAndAlign(s).Align(), config)]) (MOVWconst [0]) mem) 16748 for { 16749 s := v.AuxInt 16750 ptr := v.Args[0] 16751 mem := v.Args[1] 16752 if !((SizeAndAlign(s).Size() > 512 || config.noDuffDevice) || SizeAndAlign(s).Align()%4 != 0) { 16753 break 16754 } 16755 v.reset(OpARMLoweredZero) 16756 v.AuxInt = SizeAndAlign(s).Align() 16757 v.AddArg(ptr) 16758 v0 := b.NewValue0(v.Line, OpARMADDconst, ptr.Type) 16759 v0.AuxInt = SizeAndAlign(s).Size() - moveSize(SizeAndAlign(s).Align(), config) 16760 v0.AddArg(ptr) 16761 v.AddArg(v0) 16762 v1 := b.NewValue0(v.Line, OpARMMOVWconst, config.fe.TypeUInt32()) 16763 v1.AuxInt = 0 16764 v.AddArg(v1) 16765 v.AddArg(mem) 16766 return true 16767 } 16768 return false 16769 } 16770 func rewriteValueARM_OpZeroExt16to32(v *Value, config *Config) bool { 16771 b := v.Block 16772 _ = b 16773 // match: (ZeroExt16to32 x) 16774 // cond: 16775 // result: (MOVHUreg x) 16776 for { 16777 x := v.Args[0] 16778 v.reset(OpARMMOVHUreg) 16779 v.AddArg(x) 16780 return true 16781 } 16782 } 16783 func rewriteValueARM_OpZeroExt8to16(v *Value, config *Config) bool { 16784 b := v.Block 16785 _ = b 16786 // match: (ZeroExt8to16 x) 16787 // cond: 16788 // result: (MOVBUreg x) 16789 for { 16790 x := v.Args[0] 16791 v.reset(OpARMMOVBUreg) 16792 v.AddArg(x) 16793 return true 16794 } 16795 } 16796 func rewriteValueARM_OpZeroExt8to32(v *Value, config *Config) bool { 16797 b := v.Block 16798 _ = b 16799 // match: (ZeroExt8to32 x) 16800 // cond: 16801 // result: (MOVBUreg x) 16802 for { 16803 x := v.Args[0] 16804 v.reset(OpARMMOVBUreg) 16805 v.AddArg(x) 16806 return true 16807 } 16808 } 16809 func rewriteValueARM_OpZeromask(v *Value, config *Config) bool { 16810 b := v.Block 16811 _ = b 16812 // match: (Zeromask x) 16813 // cond: 16814 // result: (SRAconst (RSBshiftRL <config.fe.TypeInt32()> x x [1]) [31]) 16815 for { 16816 x := v.Args[0] 16817 v.reset(OpARMSRAconst) 16818 v.AuxInt = 31 16819 v0 := b.NewValue0(v.Line, OpARMRSBshiftRL, config.fe.TypeInt32()) 16820 v0.AuxInt = 1 16821 v0.AddArg(x) 16822 v0.AddArg(x) 16823 v.AddArg(v0) 16824 return true 16825 } 16826 } 16827 func rewriteBlockARM(b *Block) bool { 16828 switch b.Kind { 16829 case BlockARMEQ: 16830 // match: (EQ (FlagEQ) yes no) 16831 // cond: 16832 // result: (First nil yes no) 16833 for { 16834 v := b.Control 16835 if v.Op != OpARMFlagEQ { 16836 break 16837 } 16838 yes := b.Succs[0] 16839 no := b.Succs[1] 16840 b.Kind = BlockFirst 16841 b.SetControl(nil) 16842 _ = yes 16843 _ = no 16844 return true 16845 } 16846 // match: (EQ (FlagLT_ULT) yes no) 16847 // cond: 16848 // result: (First nil no yes) 16849 for { 16850 v := b.Control 16851 if v.Op != OpARMFlagLT_ULT { 16852 break 16853 } 16854 yes := b.Succs[0] 16855 no := b.Succs[1] 16856 b.Kind = BlockFirst 16857 b.SetControl(nil) 16858 b.swapSuccessors() 16859 _ = no 16860 _ = yes 16861 return true 16862 } 16863 // match: (EQ (FlagLT_UGT) yes no) 16864 // cond: 16865 // result: (First nil no yes) 16866 for { 16867 v := b.Control 16868 if v.Op != OpARMFlagLT_UGT { 16869 break 16870 } 16871 yes := b.Succs[0] 16872 no := b.Succs[1] 16873 b.Kind = BlockFirst 16874 b.SetControl(nil) 16875 b.swapSuccessors() 16876 _ = no 16877 _ = yes 16878 return true 16879 } 16880 // match: (EQ (FlagGT_ULT) yes no) 16881 // cond: 16882 // result: (First nil no yes) 16883 for { 16884 v := b.Control 16885 if v.Op != OpARMFlagGT_ULT { 16886 break 16887 } 16888 yes := b.Succs[0] 16889 no := b.Succs[1] 16890 b.Kind = BlockFirst 16891 b.SetControl(nil) 16892 b.swapSuccessors() 16893 _ = no 16894 _ = yes 16895 return true 16896 } 16897 // match: (EQ (FlagGT_UGT) yes no) 16898 // cond: 16899 // result: (First nil no yes) 16900 for { 16901 v := b.Control 16902 if v.Op != OpARMFlagGT_UGT { 16903 break 16904 } 16905 yes := b.Succs[0] 16906 no := b.Succs[1] 16907 b.Kind = BlockFirst 16908 b.SetControl(nil) 16909 b.swapSuccessors() 16910 _ = no 16911 _ = yes 16912 return true 16913 } 16914 // match: (EQ (InvertFlags cmp) yes no) 16915 // cond: 16916 // result: (EQ cmp yes no) 16917 for { 16918 v := b.Control 16919 if v.Op != OpARMInvertFlags { 16920 break 16921 } 16922 cmp := v.Args[0] 16923 yes := b.Succs[0] 16924 no := b.Succs[1] 16925 b.Kind = BlockARMEQ 16926 b.SetControl(cmp) 16927 _ = yes 16928 _ = no 16929 return true 16930 } 16931 case BlockARMGE: 16932 // match: (GE (FlagEQ) yes no) 16933 // cond: 16934 // result: (First nil yes no) 16935 for { 16936 v := b.Control 16937 if v.Op != OpARMFlagEQ { 16938 break 16939 } 16940 yes := b.Succs[0] 16941 no := b.Succs[1] 16942 b.Kind = BlockFirst 16943 b.SetControl(nil) 16944 _ = yes 16945 _ = no 16946 return true 16947 } 16948 // match: (GE (FlagLT_ULT) yes no) 16949 // cond: 16950 // result: (First nil no yes) 16951 for { 16952 v := b.Control 16953 if v.Op != OpARMFlagLT_ULT { 16954 break 16955 } 16956 yes := b.Succs[0] 16957 no := b.Succs[1] 16958 b.Kind = BlockFirst 16959 b.SetControl(nil) 16960 b.swapSuccessors() 16961 _ = no 16962 _ = yes 16963 return true 16964 } 16965 // match: (GE (FlagLT_UGT) yes no) 16966 // cond: 16967 // result: (First nil no yes) 16968 for { 16969 v := b.Control 16970 if v.Op != OpARMFlagLT_UGT { 16971 break 16972 } 16973 yes := b.Succs[0] 16974 no := b.Succs[1] 16975 b.Kind = BlockFirst 16976 b.SetControl(nil) 16977 b.swapSuccessors() 16978 _ = no 16979 _ = yes 16980 return true 16981 } 16982 // match: (GE (FlagGT_ULT) yes no) 16983 // cond: 16984 // result: (First nil yes no) 16985 for { 16986 v := b.Control 16987 if v.Op != OpARMFlagGT_ULT { 16988 break 16989 } 16990 yes := b.Succs[0] 16991 no := b.Succs[1] 16992 b.Kind = BlockFirst 16993 b.SetControl(nil) 16994 _ = yes 16995 _ = no 16996 return true 16997 } 16998 // match: (GE (FlagGT_UGT) yes no) 16999 // cond: 17000 // result: (First nil yes no) 17001 for { 17002 v := b.Control 17003 if v.Op != OpARMFlagGT_UGT { 17004 break 17005 } 17006 yes := b.Succs[0] 17007 no := b.Succs[1] 17008 b.Kind = BlockFirst 17009 b.SetControl(nil) 17010 _ = yes 17011 _ = no 17012 return true 17013 } 17014 // match: (GE (InvertFlags cmp) yes no) 17015 // cond: 17016 // result: (LE cmp yes no) 17017 for { 17018 v := b.Control 17019 if v.Op != OpARMInvertFlags { 17020 break 17021 } 17022 cmp := v.Args[0] 17023 yes := b.Succs[0] 17024 no := b.Succs[1] 17025 b.Kind = BlockARMLE 17026 b.SetControl(cmp) 17027 _ = yes 17028 _ = no 17029 return true 17030 } 17031 case BlockARMGT: 17032 // match: (GT (FlagEQ) yes no) 17033 // cond: 17034 // result: (First nil no yes) 17035 for { 17036 v := b.Control 17037 if v.Op != OpARMFlagEQ { 17038 break 17039 } 17040 yes := b.Succs[0] 17041 no := b.Succs[1] 17042 b.Kind = BlockFirst 17043 b.SetControl(nil) 17044 b.swapSuccessors() 17045 _ = no 17046 _ = yes 17047 return true 17048 } 17049 // match: (GT (FlagLT_ULT) yes no) 17050 // cond: 17051 // result: (First nil no yes) 17052 for { 17053 v := b.Control 17054 if v.Op != OpARMFlagLT_ULT { 17055 break 17056 } 17057 yes := b.Succs[0] 17058 no := b.Succs[1] 17059 b.Kind = BlockFirst 17060 b.SetControl(nil) 17061 b.swapSuccessors() 17062 _ = no 17063 _ = yes 17064 return true 17065 } 17066 // match: (GT (FlagLT_UGT) yes no) 17067 // cond: 17068 // result: (First nil no yes) 17069 for { 17070 v := b.Control 17071 if v.Op != OpARMFlagLT_UGT { 17072 break 17073 } 17074 yes := b.Succs[0] 17075 no := b.Succs[1] 17076 b.Kind = BlockFirst 17077 b.SetControl(nil) 17078 b.swapSuccessors() 17079 _ = no 17080 _ = yes 17081 return true 17082 } 17083 // match: (GT (FlagGT_ULT) yes no) 17084 // cond: 17085 // result: (First nil yes no) 17086 for { 17087 v := b.Control 17088 if v.Op != OpARMFlagGT_ULT { 17089 break 17090 } 17091 yes := b.Succs[0] 17092 no := b.Succs[1] 17093 b.Kind = BlockFirst 17094 b.SetControl(nil) 17095 _ = yes 17096 _ = no 17097 return true 17098 } 17099 // match: (GT (FlagGT_UGT) yes no) 17100 // cond: 17101 // result: (First nil yes no) 17102 for { 17103 v := b.Control 17104 if v.Op != OpARMFlagGT_UGT { 17105 break 17106 } 17107 yes := b.Succs[0] 17108 no := b.Succs[1] 17109 b.Kind = BlockFirst 17110 b.SetControl(nil) 17111 _ = yes 17112 _ = no 17113 return true 17114 } 17115 // match: (GT (InvertFlags cmp) yes no) 17116 // cond: 17117 // result: (LT cmp yes no) 17118 for { 17119 v := b.Control 17120 if v.Op != OpARMInvertFlags { 17121 break 17122 } 17123 cmp := v.Args[0] 17124 yes := b.Succs[0] 17125 no := b.Succs[1] 17126 b.Kind = BlockARMLT 17127 b.SetControl(cmp) 17128 _ = yes 17129 _ = no 17130 return true 17131 } 17132 case BlockIf: 17133 // match: (If (Equal cc) yes no) 17134 // cond: 17135 // result: (EQ cc yes no) 17136 for { 17137 v := b.Control 17138 if v.Op != OpARMEqual { 17139 break 17140 } 17141 cc := v.Args[0] 17142 yes := b.Succs[0] 17143 no := b.Succs[1] 17144 b.Kind = BlockARMEQ 17145 b.SetControl(cc) 17146 _ = yes 17147 _ = no 17148 return true 17149 } 17150 // match: (If (NotEqual cc) yes no) 17151 // cond: 17152 // result: (NE cc yes no) 17153 for { 17154 v := b.Control 17155 if v.Op != OpARMNotEqual { 17156 break 17157 } 17158 cc := v.Args[0] 17159 yes := b.Succs[0] 17160 no := b.Succs[1] 17161 b.Kind = BlockARMNE 17162 b.SetControl(cc) 17163 _ = yes 17164 _ = no 17165 return true 17166 } 17167 // match: (If (LessThan cc) yes no) 17168 // cond: 17169 // result: (LT cc yes no) 17170 for { 17171 v := b.Control 17172 if v.Op != OpARMLessThan { 17173 break 17174 } 17175 cc := v.Args[0] 17176 yes := b.Succs[0] 17177 no := b.Succs[1] 17178 b.Kind = BlockARMLT 17179 b.SetControl(cc) 17180 _ = yes 17181 _ = no 17182 return true 17183 } 17184 // match: (If (LessThanU cc) yes no) 17185 // cond: 17186 // result: (ULT cc yes no) 17187 for { 17188 v := b.Control 17189 if v.Op != OpARMLessThanU { 17190 break 17191 } 17192 cc := v.Args[0] 17193 yes := b.Succs[0] 17194 no := b.Succs[1] 17195 b.Kind = BlockARMULT 17196 b.SetControl(cc) 17197 _ = yes 17198 _ = no 17199 return true 17200 } 17201 // match: (If (LessEqual cc) yes no) 17202 // cond: 17203 // result: (LE cc yes no) 17204 for { 17205 v := b.Control 17206 if v.Op != OpARMLessEqual { 17207 break 17208 } 17209 cc := v.Args[0] 17210 yes := b.Succs[0] 17211 no := b.Succs[1] 17212 b.Kind = BlockARMLE 17213 b.SetControl(cc) 17214 _ = yes 17215 _ = no 17216 return true 17217 } 17218 // match: (If (LessEqualU cc) yes no) 17219 // cond: 17220 // result: (ULE cc yes no) 17221 for { 17222 v := b.Control 17223 if v.Op != OpARMLessEqualU { 17224 break 17225 } 17226 cc := v.Args[0] 17227 yes := b.Succs[0] 17228 no := b.Succs[1] 17229 b.Kind = BlockARMULE 17230 b.SetControl(cc) 17231 _ = yes 17232 _ = no 17233 return true 17234 } 17235 // match: (If (GreaterThan cc) yes no) 17236 // cond: 17237 // result: (GT cc yes no) 17238 for { 17239 v := b.Control 17240 if v.Op != OpARMGreaterThan { 17241 break 17242 } 17243 cc := v.Args[0] 17244 yes := b.Succs[0] 17245 no := b.Succs[1] 17246 b.Kind = BlockARMGT 17247 b.SetControl(cc) 17248 _ = yes 17249 _ = no 17250 return true 17251 } 17252 // match: (If (GreaterThanU cc) yes no) 17253 // cond: 17254 // result: (UGT cc yes no) 17255 for { 17256 v := b.Control 17257 if v.Op != OpARMGreaterThanU { 17258 break 17259 } 17260 cc := v.Args[0] 17261 yes := b.Succs[0] 17262 no := b.Succs[1] 17263 b.Kind = BlockARMUGT 17264 b.SetControl(cc) 17265 _ = yes 17266 _ = no 17267 return true 17268 } 17269 // match: (If (GreaterEqual cc) yes no) 17270 // cond: 17271 // result: (GE cc yes no) 17272 for { 17273 v := b.Control 17274 if v.Op != OpARMGreaterEqual { 17275 break 17276 } 17277 cc := v.Args[0] 17278 yes := b.Succs[0] 17279 no := b.Succs[1] 17280 b.Kind = BlockARMGE 17281 b.SetControl(cc) 17282 _ = yes 17283 _ = no 17284 return true 17285 } 17286 // match: (If (GreaterEqualU cc) yes no) 17287 // cond: 17288 // result: (UGE cc yes no) 17289 for { 17290 v := b.Control 17291 if v.Op != OpARMGreaterEqualU { 17292 break 17293 } 17294 cc := v.Args[0] 17295 yes := b.Succs[0] 17296 no := b.Succs[1] 17297 b.Kind = BlockARMUGE 17298 b.SetControl(cc) 17299 _ = yes 17300 _ = no 17301 return true 17302 } 17303 // match: (If cond yes no) 17304 // cond: 17305 // result: (NE (CMPconst [0] cond) yes no) 17306 for { 17307 v := b.Control 17308 _ = v 17309 cond := b.Control 17310 yes := b.Succs[0] 17311 no := b.Succs[1] 17312 b.Kind = BlockARMNE 17313 v0 := b.NewValue0(v.Line, OpARMCMPconst, TypeFlags) 17314 v0.AuxInt = 0 17315 v0.AddArg(cond) 17316 b.SetControl(v0) 17317 _ = yes 17318 _ = no 17319 return true 17320 } 17321 case BlockARMLE: 17322 // match: (LE (FlagEQ) yes no) 17323 // cond: 17324 // result: (First nil yes no) 17325 for { 17326 v := b.Control 17327 if v.Op != OpARMFlagEQ { 17328 break 17329 } 17330 yes := b.Succs[0] 17331 no := b.Succs[1] 17332 b.Kind = BlockFirst 17333 b.SetControl(nil) 17334 _ = yes 17335 _ = no 17336 return true 17337 } 17338 // match: (LE (FlagLT_ULT) yes no) 17339 // cond: 17340 // result: (First nil yes no) 17341 for { 17342 v := b.Control 17343 if v.Op != OpARMFlagLT_ULT { 17344 break 17345 } 17346 yes := b.Succs[0] 17347 no := b.Succs[1] 17348 b.Kind = BlockFirst 17349 b.SetControl(nil) 17350 _ = yes 17351 _ = no 17352 return true 17353 } 17354 // match: (LE (FlagLT_UGT) yes no) 17355 // cond: 17356 // result: (First nil yes no) 17357 for { 17358 v := b.Control 17359 if v.Op != OpARMFlagLT_UGT { 17360 break 17361 } 17362 yes := b.Succs[0] 17363 no := b.Succs[1] 17364 b.Kind = BlockFirst 17365 b.SetControl(nil) 17366 _ = yes 17367 _ = no 17368 return true 17369 } 17370 // match: (LE (FlagGT_ULT) yes no) 17371 // cond: 17372 // result: (First nil no yes) 17373 for { 17374 v := b.Control 17375 if v.Op != OpARMFlagGT_ULT { 17376 break 17377 } 17378 yes := b.Succs[0] 17379 no := b.Succs[1] 17380 b.Kind = BlockFirst 17381 b.SetControl(nil) 17382 b.swapSuccessors() 17383 _ = no 17384 _ = yes 17385 return true 17386 } 17387 // match: (LE (FlagGT_UGT) yes no) 17388 // cond: 17389 // result: (First nil no yes) 17390 for { 17391 v := b.Control 17392 if v.Op != OpARMFlagGT_UGT { 17393 break 17394 } 17395 yes := b.Succs[0] 17396 no := b.Succs[1] 17397 b.Kind = BlockFirst 17398 b.SetControl(nil) 17399 b.swapSuccessors() 17400 _ = no 17401 _ = yes 17402 return true 17403 } 17404 // match: (LE (InvertFlags cmp) yes no) 17405 // cond: 17406 // result: (GE cmp yes no) 17407 for { 17408 v := b.Control 17409 if v.Op != OpARMInvertFlags { 17410 break 17411 } 17412 cmp := v.Args[0] 17413 yes := b.Succs[0] 17414 no := b.Succs[1] 17415 b.Kind = BlockARMGE 17416 b.SetControl(cmp) 17417 _ = yes 17418 _ = no 17419 return true 17420 } 17421 case BlockARMLT: 17422 // match: (LT (FlagEQ) yes no) 17423 // cond: 17424 // result: (First nil no yes) 17425 for { 17426 v := b.Control 17427 if v.Op != OpARMFlagEQ { 17428 break 17429 } 17430 yes := b.Succs[0] 17431 no := b.Succs[1] 17432 b.Kind = BlockFirst 17433 b.SetControl(nil) 17434 b.swapSuccessors() 17435 _ = no 17436 _ = yes 17437 return true 17438 } 17439 // match: (LT (FlagLT_ULT) yes no) 17440 // cond: 17441 // result: (First nil yes no) 17442 for { 17443 v := b.Control 17444 if v.Op != OpARMFlagLT_ULT { 17445 break 17446 } 17447 yes := b.Succs[0] 17448 no := b.Succs[1] 17449 b.Kind = BlockFirst 17450 b.SetControl(nil) 17451 _ = yes 17452 _ = no 17453 return true 17454 } 17455 // match: (LT (FlagLT_UGT) yes no) 17456 // cond: 17457 // result: (First nil yes no) 17458 for { 17459 v := b.Control 17460 if v.Op != OpARMFlagLT_UGT { 17461 break 17462 } 17463 yes := b.Succs[0] 17464 no := b.Succs[1] 17465 b.Kind = BlockFirst 17466 b.SetControl(nil) 17467 _ = yes 17468 _ = no 17469 return true 17470 } 17471 // match: (LT (FlagGT_ULT) yes no) 17472 // cond: 17473 // result: (First nil no yes) 17474 for { 17475 v := b.Control 17476 if v.Op != OpARMFlagGT_ULT { 17477 break 17478 } 17479 yes := b.Succs[0] 17480 no := b.Succs[1] 17481 b.Kind = BlockFirst 17482 b.SetControl(nil) 17483 b.swapSuccessors() 17484 _ = no 17485 _ = yes 17486 return true 17487 } 17488 // match: (LT (FlagGT_UGT) yes no) 17489 // cond: 17490 // result: (First nil no yes) 17491 for { 17492 v := b.Control 17493 if v.Op != OpARMFlagGT_UGT { 17494 break 17495 } 17496 yes := b.Succs[0] 17497 no := b.Succs[1] 17498 b.Kind = BlockFirst 17499 b.SetControl(nil) 17500 b.swapSuccessors() 17501 _ = no 17502 _ = yes 17503 return true 17504 } 17505 // match: (LT (InvertFlags cmp) yes no) 17506 // cond: 17507 // result: (GT cmp yes no) 17508 for { 17509 v := b.Control 17510 if v.Op != OpARMInvertFlags { 17511 break 17512 } 17513 cmp := v.Args[0] 17514 yes := b.Succs[0] 17515 no := b.Succs[1] 17516 b.Kind = BlockARMGT 17517 b.SetControl(cmp) 17518 _ = yes 17519 _ = no 17520 return true 17521 } 17522 case BlockARMNE: 17523 // match: (NE (CMPconst [0] (Equal cc)) yes no) 17524 // cond: 17525 // result: (EQ cc yes no) 17526 for { 17527 v := b.Control 17528 if v.Op != OpARMCMPconst { 17529 break 17530 } 17531 if v.AuxInt != 0 { 17532 break 17533 } 17534 v_0 := v.Args[0] 17535 if v_0.Op != OpARMEqual { 17536 break 17537 } 17538 cc := v_0.Args[0] 17539 yes := b.Succs[0] 17540 no := b.Succs[1] 17541 b.Kind = BlockARMEQ 17542 b.SetControl(cc) 17543 _ = yes 17544 _ = no 17545 return true 17546 } 17547 // match: (NE (CMPconst [0] (NotEqual cc)) yes no) 17548 // cond: 17549 // result: (NE cc yes no) 17550 for { 17551 v := b.Control 17552 if v.Op != OpARMCMPconst { 17553 break 17554 } 17555 if v.AuxInt != 0 { 17556 break 17557 } 17558 v_0 := v.Args[0] 17559 if v_0.Op != OpARMNotEqual { 17560 break 17561 } 17562 cc := v_0.Args[0] 17563 yes := b.Succs[0] 17564 no := b.Succs[1] 17565 b.Kind = BlockARMNE 17566 b.SetControl(cc) 17567 _ = yes 17568 _ = no 17569 return true 17570 } 17571 // match: (NE (CMPconst [0] (LessThan cc)) yes no) 17572 // cond: 17573 // result: (LT cc yes no) 17574 for { 17575 v := b.Control 17576 if v.Op != OpARMCMPconst { 17577 break 17578 } 17579 if v.AuxInt != 0 { 17580 break 17581 } 17582 v_0 := v.Args[0] 17583 if v_0.Op != OpARMLessThan { 17584 break 17585 } 17586 cc := v_0.Args[0] 17587 yes := b.Succs[0] 17588 no := b.Succs[1] 17589 b.Kind = BlockARMLT 17590 b.SetControl(cc) 17591 _ = yes 17592 _ = no 17593 return true 17594 } 17595 // match: (NE (CMPconst [0] (LessThanU cc)) yes no) 17596 // cond: 17597 // result: (ULT cc yes no) 17598 for { 17599 v := b.Control 17600 if v.Op != OpARMCMPconst { 17601 break 17602 } 17603 if v.AuxInt != 0 { 17604 break 17605 } 17606 v_0 := v.Args[0] 17607 if v_0.Op != OpARMLessThanU { 17608 break 17609 } 17610 cc := v_0.Args[0] 17611 yes := b.Succs[0] 17612 no := b.Succs[1] 17613 b.Kind = BlockARMULT 17614 b.SetControl(cc) 17615 _ = yes 17616 _ = no 17617 return true 17618 } 17619 // match: (NE (CMPconst [0] (LessEqual cc)) yes no) 17620 // cond: 17621 // result: (LE cc yes no) 17622 for { 17623 v := b.Control 17624 if v.Op != OpARMCMPconst { 17625 break 17626 } 17627 if v.AuxInt != 0 { 17628 break 17629 } 17630 v_0 := v.Args[0] 17631 if v_0.Op != OpARMLessEqual { 17632 break 17633 } 17634 cc := v_0.Args[0] 17635 yes := b.Succs[0] 17636 no := b.Succs[1] 17637 b.Kind = BlockARMLE 17638 b.SetControl(cc) 17639 _ = yes 17640 _ = no 17641 return true 17642 } 17643 // match: (NE (CMPconst [0] (LessEqualU cc)) yes no) 17644 // cond: 17645 // result: (ULE cc yes no) 17646 for { 17647 v := b.Control 17648 if v.Op != OpARMCMPconst { 17649 break 17650 } 17651 if v.AuxInt != 0 { 17652 break 17653 } 17654 v_0 := v.Args[0] 17655 if v_0.Op != OpARMLessEqualU { 17656 break 17657 } 17658 cc := v_0.Args[0] 17659 yes := b.Succs[0] 17660 no := b.Succs[1] 17661 b.Kind = BlockARMULE 17662 b.SetControl(cc) 17663 _ = yes 17664 _ = no 17665 return true 17666 } 17667 // match: (NE (CMPconst [0] (GreaterThan cc)) yes no) 17668 // cond: 17669 // result: (GT cc yes no) 17670 for { 17671 v := b.Control 17672 if v.Op != OpARMCMPconst { 17673 break 17674 } 17675 if v.AuxInt != 0 { 17676 break 17677 } 17678 v_0 := v.Args[0] 17679 if v_0.Op != OpARMGreaterThan { 17680 break 17681 } 17682 cc := v_0.Args[0] 17683 yes := b.Succs[0] 17684 no := b.Succs[1] 17685 b.Kind = BlockARMGT 17686 b.SetControl(cc) 17687 _ = yes 17688 _ = no 17689 return true 17690 } 17691 // match: (NE (CMPconst [0] (GreaterThanU cc)) yes no) 17692 // cond: 17693 // result: (UGT cc yes no) 17694 for { 17695 v := b.Control 17696 if v.Op != OpARMCMPconst { 17697 break 17698 } 17699 if v.AuxInt != 0 { 17700 break 17701 } 17702 v_0 := v.Args[0] 17703 if v_0.Op != OpARMGreaterThanU { 17704 break 17705 } 17706 cc := v_0.Args[0] 17707 yes := b.Succs[0] 17708 no := b.Succs[1] 17709 b.Kind = BlockARMUGT 17710 b.SetControl(cc) 17711 _ = yes 17712 _ = no 17713 return true 17714 } 17715 // match: (NE (CMPconst [0] (GreaterEqual cc)) yes no) 17716 // cond: 17717 // result: (GE cc yes no) 17718 for { 17719 v := b.Control 17720 if v.Op != OpARMCMPconst { 17721 break 17722 } 17723 if v.AuxInt != 0 { 17724 break 17725 } 17726 v_0 := v.Args[0] 17727 if v_0.Op != OpARMGreaterEqual { 17728 break 17729 } 17730 cc := v_0.Args[0] 17731 yes := b.Succs[0] 17732 no := b.Succs[1] 17733 b.Kind = BlockARMGE 17734 b.SetControl(cc) 17735 _ = yes 17736 _ = no 17737 return true 17738 } 17739 // match: (NE (CMPconst [0] (GreaterEqualU cc)) yes no) 17740 // cond: 17741 // result: (UGE cc yes no) 17742 for { 17743 v := b.Control 17744 if v.Op != OpARMCMPconst { 17745 break 17746 } 17747 if v.AuxInt != 0 { 17748 break 17749 } 17750 v_0 := v.Args[0] 17751 if v_0.Op != OpARMGreaterEqualU { 17752 break 17753 } 17754 cc := v_0.Args[0] 17755 yes := b.Succs[0] 17756 no := b.Succs[1] 17757 b.Kind = BlockARMUGE 17758 b.SetControl(cc) 17759 _ = yes 17760 _ = no 17761 return true 17762 } 17763 // match: (NE (FlagEQ) yes no) 17764 // cond: 17765 // result: (First nil no yes) 17766 for { 17767 v := b.Control 17768 if v.Op != OpARMFlagEQ { 17769 break 17770 } 17771 yes := b.Succs[0] 17772 no := b.Succs[1] 17773 b.Kind = BlockFirst 17774 b.SetControl(nil) 17775 b.swapSuccessors() 17776 _ = no 17777 _ = yes 17778 return true 17779 } 17780 // match: (NE (FlagLT_ULT) yes no) 17781 // cond: 17782 // result: (First nil yes no) 17783 for { 17784 v := b.Control 17785 if v.Op != OpARMFlagLT_ULT { 17786 break 17787 } 17788 yes := b.Succs[0] 17789 no := b.Succs[1] 17790 b.Kind = BlockFirst 17791 b.SetControl(nil) 17792 _ = yes 17793 _ = no 17794 return true 17795 } 17796 // match: (NE (FlagLT_UGT) yes no) 17797 // cond: 17798 // result: (First nil yes no) 17799 for { 17800 v := b.Control 17801 if v.Op != OpARMFlagLT_UGT { 17802 break 17803 } 17804 yes := b.Succs[0] 17805 no := b.Succs[1] 17806 b.Kind = BlockFirst 17807 b.SetControl(nil) 17808 _ = yes 17809 _ = no 17810 return true 17811 } 17812 // match: (NE (FlagGT_ULT) yes no) 17813 // cond: 17814 // result: (First nil yes no) 17815 for { 17816 v := b.Control 17817 if v.Op != OpARMFlagGT_ULT { 17818 break 17819 } 17820 yes := b.Succs[0] 17821 no := b.Succs[1] 17822 b.Kind = BlockFirst 17823 b.SetControl(nil) 17824 _ = yes 17825 _ = no 17826 return true 17827 } 17828 // match: (NE (FlagGT_UGT) yes no) 17829 // cond: 17830 // result: (First nil yes no) 17831 for { 17832 v := b.Control 17833 if v.Op != OpARMFlagGT_UGT { 17834 break 17835 } 17836 yes := b.Succs[0] 17837 no := b.Succs[1] 17838 b.Kind = BlockFirst 17839 b.SetControl(nil) 17840 _ = yes 17841 _ = no 17842 return true 17843 } 17844 // match: (NE (InvertFlags cmp) yes no) 17845 // cond: 17846 // result: (NE cmp yes no) 17847 for { 17848 v := b.Control 17849 if v.Op != OpARMInvertFlags { 17850 break 17851 } 17852 cmp := v.Args[0] 17853 yes := b.Succs[0] 17854 no := b.Succs[1] 17855 b.Kind = BlockARMNE 17856 b.SetControl(cmp) 17857 _ = yes 17858 _ = no 17859 return true 17860 } 17861 case BlockARMUGE: 17862 // match: (UGE (FlagEQ) yes no) 17863 // cond: 17864 // result: (First nil yes no) 17865 for { 17866 v := b.Control 17867 if v.Op != OpARMFlagEQ { 17868 break 17869 } 17870 yes := b.Succs[0] 17871 no := b.Succs[1] 17872 b.Kind = BlockFirst 17873 b.SetControl(nil) 17874 _ = yes 17875 _ = no 17876 return true 17877 } 17878 // match: (UGE (FlagLT_ULT) yes no) 17879 // cond: 17880 // result: (First nil no yes) 17881 for { 17882 v := b.Control 17883 if v.Op != OpARMFlagLT_ULT { 17884 break 17885 } 17886 yes := b.Succs[0] 17887 no := b.Succs[1] 17888 b.Kind = BlockFirst 17889 b.SetControl(nil) 17890 b.swapSuccessors() 17891 _ = no 17892 _ = yes 17893 return true 17894 } 17895 // match: (UGE (FlagLT_UGT) yes no) 17896 // cond: 17897 // result: (First nil yes no) 17898 for { 17899 v := b.Control 17900 if v.Op != OpARMFlagLT_UGT { 17901 break 17902 } 17903 yes := b.Succs[0] 17904 no := b.Succs[1] 17905 b.Kind = BlockFirst 17906 b.SetControl(nil) 17907 _ = yes 17908 _ = no 17909 return true 17910 } 17911 // match: (UGE (FlagGT_ULT) yes no) 17912 // cond: 17913 // result: (First nil no yes) 17914 for { 17915 v := b.Control 17916 if v.Op != OpARMFlagGT_ULT { 17917 break 17918 } 17919 yes := b.Succs[0] 17920 no := b.Succs[1] 17921 b.Kind = BlockFirst 17922 b.SetControl(nil) 17923 b.swapSuccessors() 17924 _ = no 17925 _ = yes 17926 return true 17927 } 17928 // match: (UGE (FlagGT_UGT) yes no) 17929 // cond: 17930 // result: (First nil yes no) 17931 for { 17932 v := b.Control 17933 if v.Op != OpARMFlagGT_UGT { 17934 break 17935 } 17936 yes := b.Succs[0] 17937 no := b.Succs[1] 17938 b.Kind = BlockFirst 17939 b.SetControl(nil) 17940 _ = yes 17941 _ = no 17942 return true 17943 } 17944 // match: (UGE (InvertFlags cmp) yes no) 17945 // cond: 17946 // result: (ULE cmp yes no) 17947 for { 17948 v := b.Control 17949 if v.Op != OpARMInvertFlags { 17950 break 17951 } 17952 cmp := v.Args[0] 17953 yes := b.Succs[0] 17954 no := b.Succs[1] 17955 b.Kind = BlockARMULE 17956 b.SetControl(cmp) 17957 _ = yes 17958 _ = no 17959 return true 17960 } 17961 case BlockARMUGT: 17962 // match: (UGT (FlagEQ) yes no) 17963 // cond: 17964 // result: (First nil no yes) 17965 for { 17966 v := b.Control 17967 if v.Op != OpARMFlagEQ { 17968 break 17969 } 17970 yes := b.Succs[0] 17971 no := b.Succs[1] 17972 b.Kind = BlockFirst 17973 b.SetControl(nil) 17974 b.swapSuccessors() 17975 _ = no 17976 _ = yes 17977 return true 17978 } 17979 // match: (UGT (FlagLT_ULT) yes no) 17980 // cond: 17981 // result: (First nil no yes) 17982 for { 17983 v := b.Control 17984 if v.Op != OpARMFlagLT_ULT { 17985 break 17986 } 17987 yes := b.Succs[0] 17988 no := b.Succs[1] 17989 b.Kind = BlockFirst 17990 b.SetControl(nil) 17991 b.swapSuccessors() 17992 _ = no 17993 _ = yes 17994 return true 17995 } 17996 // match: (UGT (FlagLT_UGT) yes no) 17997 // cond: 17998 // result: (First nil yes no) 17999 for { 18000 v := b.Control 18001 if v.Op != OpARMFlagLT_UGT { 18002 break 18003 } 18004 yes := b.Succs[0] 18005 no := b.Succs[1] 18006 b.Kind = BlockFirst 18007 b.SetControl(nil) 18008 _ = yes 18009 _ = no 18010 return true 18011 } 18012 // match: (UGT (FlagGT_ULT) yes no) 18013 // cond: 18014 // result: (First nil no yes) 18015 for { 18016 v := b.Control 18017 if v.Op != OpARMFlagGT_ULT { 18018 break 18019 } 18020 yes := b.Succs[0] 18021 no := b.Succs[1] 18022 b.Kind = BlockFirst 18023 b.SetControl(nil) 18024 b.swapSuccessors() 18025 _ = no 18026 _ = yes 18027 return true 18028 } 18029 // match: (UGT (FlagGT_UGT) yes no) 18030 // cond: 18031 // result: (First nil yes no) 18032 for { 18033 v := b.Control 18034 if v.Op != OpARMFlagGT_UGT { 18035 break 18036 } 18037 yes := b.Succs[0] 18038 no := b.Succs[1] 18039 b.Kind = BlockFirst 18040 b.SetControl(nil) 18041 _ = yes 18042 _ = no 18043 return true 18044 } 18045 // match: (UGT (InvertFlags cmp) yes no) 18046 // cond: 18047 // result: (ULT cmp yes no) 18048 for { 18049 v := b.Control 18050 if v.Op != OpARMInvertFlags { 18051 break 18052 } 18053 cmp := v.Args[0] 18054 yes := b.Succs[0] 18055 no := b.Succs[1] 18056 b.Kind = BlockARMULT 18057 b.SetControl(cmp) 18058 _ = yes 18059 _ = no 18060 return true 18061 } 18062 case BlockARMULE: 18063 // match: (ULE (FlagEQ) yes no) 18064 // cond: 18065 // result: (First nil yes no) 18066 for { 18067 v := b.Control 18068 if v.Op != OpARMFlagEQ { 18069 break 18070 } 18071 yes := b.Succs[0] 18072 no := b.Succs[1] 18073 b.Kind = BlockFirst 18074 b.SetControl(nil) 18075 _ = yes 18076 _ = no 18077 return true 18078 } 18079 // match: (ULE (FlagLT_ULT) yes no) 18080 // cond: 18081 // result: (First nil yes no) 18082 for { 18083 v := b.Control 18084 if v.Op != OpARMFlagLT_ULT { 18085 break 18086 } 18087 yes := b.Succs[0] 18088 no := b.Succs[1] 18089 b.Kind = BlockFirst 18090 b.SetControl(nil) 18091 _ = yes 18092 _ = no 18093 return true 18094 } 18095 // match: (ULE (FlagLT_UGT) yes no) 18096 // cond: 18097 // result: (First nil no yes) 18098 for { 18099 v := b.Control 18100 if v.Op != OpARMFlagLT_UGT { 18101 break 18102 } 18103 yes := b.Succs[0] 18104 no := b.Succs[1] 18105 b.Kind = BlockFirst 18106 b.SetControl(nil) 18107 b.swapSuccessors() 18108 _ = no 18109 _ = yes 18110 return true 18111 } 18112 // match: (ULE (FlagGT_ULT) yes no) 18113 // cond: 18114 // result: (First nil yes no) 18115 for { 18116 v := b.Control 18117 if v.Op != OpARMFlagGT_ULT { 18118 break 18119 } 18120 yes := b.Succs[0] 18121 no := b.Succs[1] 18122 b.Kind = BlockFirst 18123 b.SetControl(nil) 18124 _ = yes 18125 _ = no 18126 return true 18127 } 18128 // match: (ULE (FlagGT_UGT) yes no) 18129 // cond: 18130 // result: (First nil no yes) 18131 for { 18132 v := b.Control 18133 if v.Op != OpARMFlagGT_UGT { 18134 break 18135 } 18136 yes := b.Succs[0] 18137 no := b.Succs[1] 18138 b.Kind = BlockFirst 18139 b.SetControl(nil) 18140 b.swapSuccessors() 18141 _ = no 18142 _ = yes 18143 return true 18144 } 18145 // match: (ULE (InvertFlags cmp) yes no) 18146 // cond: 18147 // result: (UGE cmp yes no) 18148 for { 18149 v := b.Control 18150 if v.Op != OpARMInvertFlags { 18151 break 18152 } 18153 cmp := v.Args[0] 18154 yes := b.Succs[0] 18155 no := b.Succs[1] 18156 b.Kind = BlockARMUGE 18157 b.SetControl(cmp) 18158 _ = yes 18159 _ = no 18160 return true 18161 } 18162 case BlockARMULT: 18163 // match: (ULT (FlagEQ) yes no) 18164 // cond: 18165 // result: (First nil no yes) 18166 for { 18167 v := b.Control 18168 if v.Op != OpARMFlagEQ { 18169 break 18170 } 18171 yes := b.Succs[0] 18172 no := b.Succs[1] 18173 b.Kind = BlockFirst 18174 b.SetControl(nil) 18175 b.swapSuccessors() 18176 _ = no 18177 _ = yes 18178 return true 18179 } 18180 // match: (ULT (FlagLT_ULT) yes no) 18181 // cond: 18182 // result: (First nil yes no) 18183 for { 18184 v := b.Control 18185 if v.Op != OpARMFlagLT_ULT { 18186 break 18187 } 18188 yes := b.Succs[0] 18189 no := b.Succs[1] 18190 b.Kind = BlockFirst 18191 b.SetControl(nil) 18192 _ = yes 18193 _ = no 18194 return true 18195 } 18196 // match: (ULT (FlagLT_UGT) yes no) 18197 // cond: 18198 // result: (First nil no yes) 18199 for { 18200 v := b.Control 18201 if v.Op != OpARMFlagLT_UGT { 18202 break 18203 } 18204 yes := b.Succs[0] 18205 no := b.Succs[1] 18206 b.Kind = BlockFirst 18207 b.SetControl(nil) 18208 b.swapSuccessors() 18209 _ = no 18210 _ = yes 18211 return true 18212 } 18213 // match: (ULT (FlagGT_ULT) yes no) 18214 // cond: 18215 // result: (First nil yes no) 18216 for { 18217 v := b.Control 18218 if v.Op != OpARMFlagGT_ULT { 18219 break 18220 } 18221 yes := b.Succs[0] 18222 no := b.Succs[1] 18223 b.Kind = BlockFirst 18224 b.SetControl(nil) 18225 _ = yes 18226 _ = no 18227 return true 18228 } 18229 // match: (ULT (FlagGT_UGT) yes no) 18230 // cond: 18231 // result: (First nil no yes) 18232 for { 18233 v := b.Control 18234 if v.Op != OpARMFlagGT_UGT { 18235 break 18236 } 18237 yes := b.Succs[0] 18238 no := b.Succs[1] 18239 b.Kind = BlockFirst 18240 b.SetControl(nil) 18241 b.swapSuccessors() 18242 _ = no 18243 _ = yes 18244 return true 18245 } 18246 // match: (ULT (InvertFlags cmp) yes no) 18247 // cond: 18248 // result: (UGT cmp yes no) 18249 for { 18250 v := b.Control 18251 if v.Op != OpARMInvertFlags { 18252 break 18253 } 18254 cmp := v.Args[0] 18255 yes := b.Succs[0] 18256 no := b.Succs[1] 18257 b.Kind = BlockARMUGT 18258 b.SetControl(cmp) 18259 _ = yes 18260 _ = no 18261 return true 18262 } 18263 } 18264 return false 18265 }