github.com/mattn/go@v0.0.0-20171011075504-07f7db3ea99f/src/cmd/compile/internal/ssa/rewriteARM.go (about) 1 // Code generated from gen/ARM.rules; DO NOT EDIT. 2 // generated with: cd gen; go run *.go 3 4 package ssa 5 6 import "math" 7 import "cmd/internal/obj" 8 import "cmd/internal/objabi" 9 import "cmd/compile/internal/types" 10 11 var _ = math.MinInt8 // in case not otherwise used 12 var _ = obj.ANOP // in case not otherwise used 13 var _ = objabi.GOROOT // in case not otherwise used 14 var _ = types.TypeMem // in case not otherwise used 15 16 func rewriteValueARM(v *Value) bool { 17 switch v.Op { 18 case OpARMADC: 19 return rewriteValueARM_OpARMADC_0(v) || rewriteValueARM_OpARMADC_10(v) || rewriteValueARM_OpARMADC_20(v) 20 case OpARMADCconst: 21 return rewriteValueARM_OpARMADCconst_0(v) 22 case OpARMADCshiftLL: 23 return rewriteValueARM_OpARMADCshiftLL_0(v) 24 case OpARMADCshiftLLreg: 25 return rewriteValueARM_OpARMADCshiftLLreg_0(v) 26 case OpARMADCshiftRA: 27 return rewriteValueARM_OpARMADCshiftRA_0(v) 28 case OpARMADCshiftRAreg: 29 return rewriteValueARM_OpARMADCshiftRAreg_0(v) 30 case OpARMADCshiftRL: 31 return rewriteValueARM_OpARMADCshiftRL_0(v) 32 case OpARMADCshiftRLreg: 33 return rewriteValueARM_OpARMADCshiftRLreg_0(v) 34 case OpARMADD: 35 return rewriteValueARM_OpARMADD_0(v) || rewriteValueARM_OpARMADD_10(v) 36 case OpARMADDD: 37 return rewriteValueARM_OpARMADDD_0(v) 38 case OpARMADDF: 39 return rewriteValueARM_OpARMADDF_0(v) 40 case OpARMADDS: 41 return rewriteValueARM_OpARMADDS_0(v) || rewriteValueARM_OpARMADDS_10(v) 42 case OpARMADDSshiftLL: 43 return rewriteValueARM_OpARMADDSshiftLL_0(v) 44 case OpARMADDSshiftLLreg: 45 return rewriteValueARM_OpARMADDSshiftLLreg_0(v) 46 case OpARMADDSshiftRA: 47 return rewriteValueARM_OpARMADDSshiftRA_0(v) 48 case OpARMADDSshiftRAreg: 49 return rewriteValueARM_OpARMADDSshiftRAreg_0(v) 50 case OpARMADDSshiftRL: 51 return rewriteValueARM_OpARMADDSshiftRL_0(v) 52 case OpARMADDSshiftRLreg: 53 return rewriteValueARM_OpARMADDSshiftRLreg_0(v) 54 case OpARMADDconst: 55 return rewriteValueARM_OpARMADDconst_0(v) 56 case OpARMADDshiftLL: 57 return rewriteValueARM_OpARMADDshiftLL_0(v) 58 case OpARMADDshiftLLreg: 59 return rewriteValueARM_OpARMADDshiftLLreg_0(v) 60 case OpARMADDshiftRA: 61 return rewriteValueARM_OpARMADDshiftRA_0(v) 62 case OpARMADDshiftRAreg: 63 return rewriteValueARM_OpARMADDshiftRAreg_0(v) 64 case OpARMADDshiftRL: 65 return rewriteValueARM_OpARMADDshiftRL_0(v) 66 case OpARMADDshiftRLreg: 67 return rewriteValueARM_OpARMADDshiftRLreg_0(v) 68 case OpARMAND: 69 return rewriteValueARM_OpARMAND_0(v) || rewriteValueARM_OpARMAND_10(v) || rewriteValueARM_OpARMAND_20(v) 70 case OpARMANDconst: 71 return rewriteValueARM_OpARMANDconst_0(v) 72 case OpARMANDshiftLL: 73 return rewriteValueARM_OpARMANDshiftLL_0(v) 74 case OpARMANDshiftLLreg: 75 return rewriteValueARM_OpARMANDshiftLLreg_0(v) 76 case OpARMANDshiftRA: 77 return rewriteValueARM_OpARMANDshiftRA_0(v) 78 case OpARMANDshiftRAreg: 79 return rewriteValueARM_OpARMANDshiftRAreg_0(v) 80 case OpARMANDshiftRL: 81 return rewriteValueARM_OpARMANDshiftRL_0(v) 82 case OpARMANDshiftRLreg: 83 return rewriteValueARM_OpARMANDshiftRLreg_0(v) 84 case OpARMBFX: 85 return rewriteValueARM_OpARMBFX_0(v) 86 case OpARMBFXU: 87 return rewriteValueARM_OpARMBFXU_0(v) 88 case OpARMBIC: 89 return rewriteValueARM_OpARMBIC_0(v) 90 case OpARMBICconst: 91 return rewriteValueARM_OpARMBICconst_0(v) 92 case OpARMBICshiftLL: 93 return rewriteValueARM_OpARMBICshiftLL_0(v) 94 case OpARMBICshiftLLreg: 95 return rewriteValueARM_OpARMBICshiftLLreg_0(v) 96 case OpARMBICshiftRA: 97 return rewriteValueARM_OpARMBICshiftRA_0(v) 98 case OpARMBICshiftRAreg: 99 return rewriteValueARM_OpARMBICshiftRAreg_0(v) 100 case OpARMBICshiftRL: 101 return rewriteValueARM_OpARMBICshiftRL_0(v) 102 case OpARMBICshiftRLreg: 103 return rewriteValueARM_OpARMBICshiftRLreg_0(v) 104 case OpARMCMOVWHSconst: 105 return rewriteValueARM_OpARMCMOVWHSconst_0(v) 106 case OpARMCMOVWLSconst: 107 return rewriteValueARM_OpARMCMOVWLSconst_0(v) 108 case OpARMCMP: 109 return rewriteValueARM_OpARMCMP_0(v) || rewriteValueARM_OpARMCMP_10(v) 110 case OpARMCMPD: 111 return rewriteValueARM_OpARMCMPD_0(v) 112 case OpARMCMPF: 113 return rewriteValueARM_OpARMCMPF_0(v) 114 case OpARMCMPconst: 115 return rewriteValueARM_OpARMCMPconst_0(v) 116 case OpARMCMPshiftLL: 117 return rewriteValueARM_OpARMCMPshiftLL_0(v) 118 case OpARMCMPshiftLLreg: 119 return rewriteValueARM_OpARMCMPshiftLLreg_0(v) 120 case OpARMCMPshiftRA: 121 return rewriteValueARM_OpARMCMPshiftRA_0(v) 122 case OpARMCMPshiftRAreg: 123 return rewriteValueARM_OpARMCMPshiftRAreg_0(v) 124 case OpARMCMPshiftRL: 125 return rewriteValueARM_OpARMCMPshiftRL_0(v) 126 case OpARMCMPshiftRLreg: 127 return rewriteValueARM_OpARMCMPshiftRLreg_0(v) 128 case OpARMEqual: 129 return rewriteValueARM_OpARMEqual_0(v) 130 case OpARMGreaterEqual: 131 return rewriteValueARM_OpARMGreaterEqual_0(v) 132 case OpARMGreaterEqualU: 133 return rewriteValueARM_OpARMGreaterEqualU_0(v) 134 case OpARMGreaterThan: 135 return rewriteValueARM_OpARMGreaterThan_0(v) 136 case OpARMGreaterThanU: 137 return rewriteValueARM_OpARMGreaterThanU_0(v) 138 case OpARMLessEqual: 139 return rewriteValueARM_OpARMLessEqual_0(v) 140 case OpARMLessEqualU: 141 return rewriteValueARM_OpARMLessEqualU_0(v) 142 case OpARMLessThan: 143 return rewriteValueARM_OpARMLessThan_0(v) 144 case OpARMLessThanU: 145 return rewriteValueARM_OpARMLessThanU_0(v) 146 case OpARMMOVBUload: 147 return rewriteValueARM_OpARMMOVBUload_0(v) 148 case OpARMMOVBUloadidx: 149 return rewriteValueARM_OpARMMOVBUloadidx_0(v) 150 case OpARMMOVBUreg: 151 return rewriteValueARM_OpARMMOVBUreg_0(v) 152 case OpARMMOVBload: 153 return rewriteValueARM_OpARMMOVBload_0(v) 154 case OpARMMOVBloadidx: 155 return rewriteValueARM_OpARMMOVBloadidx_0(v) 156 case OpARMMOVBreg: 157 return rewriteValueARM_OpARMMOVBreg_0(v) 158 case OpARMMOVBstore: 159 return rewriteValueARM_OpARMMOVBstore_0(v) 160 case OpARMMOVBstoreidx: 161 return rewriteValueARM_OpARMMOVBstoreidx_0(v) 162 case OpARMMOVDload: 163 return rewriteValueARM_OpARMMOVDload_0(v) 164 case OpARMMOVDstore: 165 return rewriteValueARM_OpARMMOVDstore_0(v) 166 case OpARMMOVFload: 167 return rewriteValueARM_OpARMMOVFload_0(v) 168 case OpARMMOVFstore: 169 return rewriteValueARM_OpARMMOVFstore_0(v) 170 case OpARMMOVHUload: 171 return rewriteValueARM_OpARMMOVHUload_0(v) 172 case OpARMMOVHUloadidx: 173 return rewriteValueARM_OpARMMOVHUloadidx_0(v) 174 case OpARMMOVHUreg: 175 return rewriteValueARM_OpARMMOVHUreg_0(v) 176 case OpARMMOVHload: 177 return rewriteValueARM_OpARMMOVHload_0(v) 178 case OpARMMOVHloadidx: 179 return rewriteValueARM_OpARMMOVHloadidx_0(v) 180 case OpARMMOVHreg: 181 return rewriteValueARM_OpARMMOVHreg_0(v) 182 case OpARMMOVHstore: 183 return rewriteValueARM_OpARMMOVHstore_0(v) 184 case OpARMMOVHstoreidx: 185 return rewriteValueARM_OpARMMOVHstoreidx_0(v) 186 case OpARMMOVWload: 187 return rewriteValueARM_OpARMMOVWload_0(v) 188 case OpARMMOVWloadidx: 189 return rewriteValueARM_OpARMMOVWloadidx_0(v) 190 case OpARMMOVWloadshiftLL: 191 return rewriteValueARM_OpARMMOVWloadshiftLL_0(v) 192 case OpARMMOVWloadshiftRA: 193 return rewriteValueARM_OpARMMOVWloadshiftRA_0(v) 194 case OpARMMOVWloadshiftRL: 195 return rewriteValueARM_OpARMMOVWloadshiftRL_0(v) 196 case OpARMMOVWreg: 197 return rewriteValueARM_OpARMMOVWreg_0(v) 198 case OpARMMOVWstore: 199 return rewriteValueARM_OpARMMOVWstore_0(v) 200 case OpARMMOVWstoreidx: 201 return rewriteValueARM_OpARMMOVWstoreidx_0(v) 202 case OpARMMOVWstoreshiftLL: 203 return rewriteValueARM_OpARMMOVWstoreshiftLL_0(v) 204 case OpARMMOVWstoreshiftRA: 205 return rewriteValueARM_OpARMMOVWstoreshiftRA_0(v) 206 case OpARMMOVWstoreshiftRL: 207 return rewriteValueARM_OpARMMOVWstoreshiftRL_0(v) 208 case OpARMMUL: 209 return rewriteValueARM_OpARMMUL_0(v) || rewriteValueARM_OpARMMUL_10(v) || rewriteValueARM_OpARMMUL_20(v) 210 case OpARMMULA: 211 return rewriteValueARM_OpARMMULA_0(v) || rewriteValueARM_OpARMMULA_10(v) || rewriteValueARM_OpARMMULA_20(v) 212 case OpARMMULD: 213 return rewriteValueARM_OpARMMULD_0(v) 214 case OpARMMULF: 215 return rewriteValueARM_OpARMMULF_0(v) 216 case OpARMMULS: 217 return rewriteValueARM_OpARMMULS_0(v) || rewriteValueARM_OpARMMULS_10(v) || rewriteValueARM_OpARMMULS_20(v) 218 case OpARMMVN: 219 return rewriteValueARM_OpARMMVN_0(v) 220 case OpARMMVNshiftLL: 221 return rewriteValueARM_OpARMMVNshiftLL_0(v) 222 case OpARMMVNshiftLLreg: 223 return rewriteValueARM_OpARMMVNshiftLLreg_0(v) 224 case OpARMMVNshiftRA: 225 return rewriteValueARM_OpARMMVNshiftRA_0(v) 226 case OpARMMVNshiftRAreg: 227 return rewriteValueARM_OpARMMVNshiftRAreg_0(v) 228 case OpARMMVNshiftRL: 229 return rewriteValueARM_OpARMMVNshiftRL_0(v) 230 case OpARMMVNshiftRLreg: 231 return rewriteValueARM_OpARMMVNshiftRLreg_0(v) 232 case OpARMNEGD: 233 return rewriteValueARM_OpARMNEGD_0(v) 234 case OpARMNEGF: 235 return rewriteValueARM_OpARMNEGF_0(v) 236 case OpARMNMULD: 237 return rewriteValueARM_OpARMNMULD_0(v) 238 case OpARMNMULF: 239 return rewriteValueARM_OpARMNMULF_0(v) 240 case OpARMNotEqual: 241 return rewriteValueARM_OpARMNotEqual_0(v) 242 case OpARMOR: 243 return rewriteValueARM_OpARMOR_0(v) || rewriteValueARM_OpARMOR_10(v) 244 case OpARMORconst: 245 return rewriteValueARM_OpARMORconst_0(v) 246 case OpARMORshiftLL: 247 return rewriteValueARM_OpARMORshiftLL_0(v) 248 case OpARMORshiftLLreg: 249 return rewriteValueARM_OpARMORshiftLLreg_0(v) 250 case OpARMORshiftRA: 251 return rewriteValueARM_OpARMORshiftRA_0(v) 252 case OpARMORshiftRAreg: 253 return rewriteValueARM_OpARMORshiftRAreg_0(v) 254 case OpARMORshiftRL: 255 return rewriteValueARM_OpARMORshiftRL_0(v) 256 case OpARMORshiftRLreg: 257 return rewriteValueARM_OpARMORshiftRLreg_0(v) 258 case OpARMRSB: 259 return rewriteValueARM_OpARMRSB_0(v) || rewriteValueARM_OpARMRSB_10(v) 260 case OpARMRSBSshiftLL: 261 return rewriteValueARM_OpARMRSBSshiftLL_0(v) 262 case OpARMRSBSshiftLLreg: 263 return rewriteValueARM_OpARMRSBSshiftLLreg_0(v) 264 case OpARMRSBSshiftRA: 265 return rewriteValueARM_OpARMRSBSshiftRA_0(v) 266 case OpARMRSBSshiftRAreg: 267 return rewriteValueARM_OpARMRSBSshiftRAreg_0(v) 268 case OpARMRSBSshiftRL: 269 return rewriteValueARM_OpARMRSBSshiftRL_0(v) 270 case OpARMRSBSshiftRLreg: 271 return rewriteValueARM_OpARMRSBSshiftRLreg_0(v) 272 case OpARMRSBconst: 273 return rewriteValueARM_OpARMRSBconst_0(v) 274 case OpARMRSBshiftLL: 275 return rewriteValueARM_OpARMRSBshiftLL_0(v) 276 case OpARMRSBshiftLLreg: 277 return rewriteValueARM_OpARMRSBshiftLLreg_0(v) 278 case OpARMRSBshiftRA: 279 return rewriteValueARM_OpARMRSBshiftRA_0(v) 280 case OpARMRSBshiftRAreg: 281 return rewriteValueARM_OpARMRSBshiftRAreg_0(v) 282 case OpARMRSBshiftRL: 283 return rewriteValueARM_OpARMRSBshiftRL_0(v) 284 case OpARMRSBshiftRLreg: 285 return rewriteValueARM_OpARMRSBshiftRLreg_0(v) 286 case OpARMRSCconst: 287 return rewriteValueARM_OpARMRSCconst_0(v) 288 case OpARMRSCshiftLL: 289 return rewriteValueARM_OpARMRSCshiftLL_0(v) 290 case OpARMRSCshiftLLreg: 291 return rewriteValueARM_OpARMRSCshiftLLreg_0(v) 292 case OpARMRSCshiftRA: 293 return rewriteValueARM_OpARMRSCshiftRA_0(v) 294 case OpARMRSCshiftRAreg: 295 return rewriteValueARM_OpARMRSCshiftRAreg_0(v) 296 case OpARMRSCshiftRL: 297 return rewriteValueARM_OpARMRSCshiftRL_0(v) 298 case OpARMRSCshiftRLreg: 299 return rewriteValueARM_OpARMRSCshiftRLreg_0(v) 300 case OpARMSBC: 301 return rewriteValueARM_OpARMSBC_0(v) || rewriteValueARM_OpARMSBC_10(v) 302 case OpARMSBCconst: 303 return rewriteValueARM_OpARMSBCconst_0(v) 304 case OpARMSBCshiftLL: 305 return rewriteValueARM_OpARMSBCshiftLL_0(v) 306 case OpARMSBCshiftLLreg: 307 return rewriteValueARM_OpARMSBCshiftLLreg_0(v) 308 case OpARMSBCshiftRA: 309 return rewriteValueARM_OpARMSBCshiftRA_0(v) 310 case OpARMSBCshiftRAreg: 311 return rewriteValueARM_OpARMSBCshiftRAreg_0(v) 312 case OpARMSBCshiftRL: 313 return rewriteValueARM_OpARMSBCshiftRL_0(v) 314 case OpARMSBCshiftRLreg: 315 return rewriteValueARM_OpARMSBCshiftRLreg_0(v) 316 case OpARMSLL: 317 return rewriteValueARM_OpARMSLL_0(v) 318 case OpARMSLLconst: 319 return rewriteValueARM_OpARMSLLconst_0(v) 320 case OpARMSRA: 321 return rewriteValueARM_OpARMSRA_0(v) 322 case OpARMSRAcond: 323 return rewriteValueARM_OpARMSRAcond_0(v) 324 case OpARMSRAconst: 325 return rewriteValueARM_OpARMSRAconst_0(v) 326 case OpARMSRL: 327 return rewriteValueARM_OpARMSRL_0(v) 328 case OpARMSRLconst: 329 return rewriteValueARM_OpARMSRLconst_0(v) 330 case OpARMSUB: 331 return rewriteValueARM_OpARMSUB_0(v) || rewriteValueARM_OpARMSUB_10(v) 332 case OpARMSUBD: 333 return rewriteValueARM_OpARMSUBD_0(v) 334 case OpARMSUBF: 335 return rewriteValueARM_OpARMSUBF_0(v) 336 case OpARMSUBS: 337 return rewriteValueARM_OpARMSUBS_0(v) || rewriteValueARM_OpARMSUBS_10(v) 338 case OpARMSUBSshiftLL: 339 return rewriteValueARM_OpARMSUBSshiftLL_0(v) 340 case OpARMSUBSshiftLLreg: 341 return rewriteValueARM_OpARMSUBSshiftLLreg_0(v) 342 case OpARMSUBSshiftRA: 343 return rewriteValueARM_OpARMSUBSshiftRA_0(v) 344 case OpARMSUBSshiftRAreg: 345 return rewriteValueARM_OpARMSUBSshiftRAreg_0(v) 346 case OpARMSUBSshiftRL: 347 return rewriteValueARM_OpARMSUBSshiftRL_0(v) 348 case OpARMSUBSshiftRLreg: 349 return rewriteValueARM_OpARMSUBSshiftRLreg_0(v) 350 case OpARMSUBconst: 351 return rewriteValueARM_OpARMSUBconst_0(v) 352 case OpARMSUBshiftLL: 353 return rewriteValueARM_OpARMSUBshiftLL_0(v) 354 case OpARMSUBshiftLLreg: 355 return rewriteValueARM_OpARMSUBshiftLLreg_0(v) 356 case OpARMSUBshiftRA: 357 return rewriteValueARM_OpARMSUBshiftRA_0(v) 358 case OpARMSUBshiftRAreg: 359 return rewriteValueARM_OpARMSUBshiftRAreg_0(v) 360 case OpARMSUBshiftRL: 361 return rewriteValueARM_OpARMSUBshiftRL_0(v) 362 case OpARMSUBshiftRLreg: 363 return rewriteValueARM_OpARMSUBshiftRLreg_0(v) 364 case OpARMXOR: 365 return rewriteValueARM_OpARMXOR_0(v) || rewriteValueARM_OpARMXOR_10(v) 366 case OpARMXORconst: 367 return rewriteValueARM_OpARMXORconst_0(v) 368 case OpARMXORshiftLL: 369 return rewriteValueARM_OpARMXORshiftLL_0(v) 370 case OpARMXORshiftLLreg: 371 return rewriteValueARM_OpARMXORshiftLLreg_0(v) 372 case OpARMXORshiftRA: 373 return rewriteValueARM_OpARMXORshiftRA_0(v) 374 case OpARMXORshiftRAreg: 375 return rewriteValueARM_OpARMXORshiftRAreg_0(v) 376 case OpARMXORshiftRL: 377 return rewriteValueARM_OpARMXORshiftRL_0(v) 378 case OpARMXORshiftRLreg: 379 return rewriteValueARM_OpARMXORshiftRLreg_0(v) 380 case OpARMXORshiftRR: 381 return rewriteValueARM_OpARMXORshiftRR_0(v) 382 case OpAdd16: 383 return rewriteValueARM_OpAdd16_0(v) 384 case OpAdd32: 385 return rewriteValueARM_OpAdd32_0(v) 386 case OpAdd32F: 387 return rewriteValueARM_OpAdd32F_0(v) 388 case OpAdd32carry: 389 return rewriteValueARM_OpAdd32carry_0(v) 390 case OpAdd32withcarry: 391 return rewriteValueARM_OpAdd32withcarry_0(v) 392 case OpAdd64F: 393 return rewriteValueARM_OpAdd64F_0(v) 394 case OpAdd8: 395 return rewriteValueARM_OpAdd8_0(v) 396 case OpAddPtr: 397 return rewriteValueARM_OpAddPtr_0(v) 398 case OpAddr: 399 return rewriteValueARM_OpAddr_0(v) 400 case OpAnd16: 401 return rewriteValueARM_OpAnd16_0(v) 402 case OpAnd32: 403 return rewriteValueARM_OpAnd32_0(v) 404 case OpAnd8: 405 return rewriteValueARM_OpAnd8_0(v) 406 case OpAndB: 407 return rewriteValueARM_OpAndB_0(v) 408 case OpAvg32u: 409 return rewriteValueARM_OpAvg32u_0(v) 410 case OpBitLen32: 411 return rewriteValueARM_OpBitLen32_0(v) 412 case OpBswap32: 413 return rewriteValueARM_OpBswap32_0(v) 414 case OpClosureCall: 415 return rewriteValueARM_OpClosureCall_0(v) 416 case OpCom16: 417 return rewriteValueARM_OpCom16_0(v) 418 case OpCom32: 419 return rewriteValueARM_OpCom32_0(v) 420 case OpCom8: 421 return rewriteValueARM_OpCom8_0(v) 422 case OpConst16: 423 return rewriteValueARM_OpConst16_0(v) 424 case OpConst32: 425 return rewriteValueARM_OpConst32_0(v) 426 case OpConst32F: 427 return rewriteValueARM_OpConst32F_0(v) 428 case OpConst64F: 429 return rewriteValueARM_OpConst64F_0(v) 430 case OpConst8: 431 return rewriteValueARM_OpConst8_0(v) 432 case OpConstBool: 433 return rewriteValueARM_OpConstBool_0(v) 434 case OpConstNil: 435 return rewriteValueARM_OpConstNil_0(v) 436 case OpConvert: 437 return rewriteValueARM_OpConvert_0(v) 438 case OpCtz32: 439 return rewriteValueARM_OpCtz32_0(v) 440 case OpCvt32Fto32: 441 return rewriteValueARM_OpCvt32Fto32_0(v) 442 case OpCvt32Fto32U: 443 return rewriteValueARM_OpCvt32Fto32U_0(v) 444 case OpCvt32Fto64F: 445 return rewriteValueARM_OpCvt32Fto64F_0(v) 446 case OpCvt32Uto32F: 447 return rewriteValueARM_OpCvt32Uto32F_0(v) 448 case OpCvt32Uto64F: 449 return rewriteValueARM_OpCvt32Uto64F_0(v) 450 case OpCvt32to32F: 451 return rewriteValueARM_OpCvt32to32F_0(v) 452 case OpCvt32to64F: 453 return rewriteValueARM_OpCvt32to64F_0(v) 454 case OpCvt64Fto32: 455 return rewriteValueARM_OpCvt64Fto32_0(v) 456 case OpCvt64Fto32F: 457 return rewriteValueARM_OpCvt64Fto32F_0(v) 458 case OpCvt64Fto32U: 459 return rewriteValueARM_OpCvt64Fto32U_0(v) 460 case OpDiv16: 461 return rewriteValueARM_OpDiv16_0(v) 462 case OpDiv16u: 463 return rewriteValueARM_OpDiv16u_0(v) 464 case OpDiv32: 465 return rewriteValueARM_OpDiv32_0(v) 466 case OpDiv32F: 467 return rewriteValueARM_OpDiv32F_0(v) 468 case OpDiv32u: 469 return rewriteValueARM_OpDiv32u_0(v) 470 case OpDiv64F: 471 return rewriteValueARM_OpDiv64F_0(v) 472 case OpDiv8: 473 return rewriteValueARM_OpDiv8_0(v) 474 case OpDiv8u: 475 return rewriteValueARM_OpDiv8u_0(v) 476 case OpEq16: 477 return rewriteValueARM_OpEq16_0(v) 478 case OpEq32: 479 return rewriteValueARM_OpEq32_0(v) 480 case OpEq32F: 481 return rewriteValueARM_OpEq32F_0(v) 482 case OpEq64F: 483 return rewriteValueARM_OpEq64F_0(v) 484 case OpEq8: 485 return rewriteValueARM_OpEq8_0(v) 486 case OpEqB: 487 return rewriteValueARM_OpEqB_0(v) 488 case OpEqPtr: 489 return rewriteValueARM_OpEqPtr_0(v) 490 case OpGeq16: 491 return rewriteValueARM_OpGeq16_0(v) 492 case OpGeq16U: 493 return rewriteValueARM_OpGeq16U_0(v) 494 case OpGeq32: 495 return rewriteValueARM_OpGeq32_0(v) 496 case OpGeq32F: 497 return rewriteValueARM_OpGeq32F_0(v) 498 case OpGeq32U: 499 return rewriteValueARM_OpGeq32U_0(v) 500 case OpGeq64F: 501 return rewriteValueARM_OpGeq64F_0(v) 502 case OpGeq8: 503 return rewriteValueARM_OpGeq8_0(v) 504 case OpGeq8U: 505 return rewriteValueARM_OpGeq8U_0(v) 506 case OpGetCallerSP: 507 return rewriteValueARM_OpGetCallerSP_0(v) 508 case OpGetClosurePtr: 509 return rewriteValueARM_OpGetClosurePtr_0(v) 510 case OpGreater16: 511 return rewriteValueARM_OpGreater16_0(v) 512 case OpGreater16U: 513 return rewriteValueARM_OpGreater16U_0(v) 514 case OpGreater32: 515 return rewriteValueARM_OpGreater32_0(v) 516 case OpGreater32F: 517 return rewriteValueARM_OpGreater32F_0(v) 518 case OpGreater32U: 519 return rewriteValueARM_OpGreater32U_0(v) 520 case OpGreater64F: 521 return rewriteValueARM_OpGreater64F_0(v) 522 case OpGreater8: 523 return rewriteValueARM_OpGreater8_0(v) 524 case OpGreater8U: 525 return rewriteValueARM_OpGreater8U_0(v) 526 case OpHmul32: 527 return rewriteValueARM_OpHmul32_0(v) 528 case OpHmul32u: 529 return rewriteValueARM_OpHmul32u_0(v) 530 case OpInterCall: 531 return rewriteValueARM_OpInterCall_0(v) 532 case OpIsInBounds: 533 return rewriteValueARM_OpIsInBounds_0(v) 534 case OpIsNonNil: 535 return rewriteValueARM_OpIsNonNil_0(v) 536 case OpIsSliceInBounds: 537 return rewriteValueARM_OpIsSliceInBounds_0(v) 538 case OpLeq16: 539 return rewriteValueARM_OpLeq16_0(v) 540 case OpLeq16U: 541 return rewriteValueARM_OpLeq16U_0(v) 542 case OpLeq32: 543 return rewriteValueARM_OpLeq32_0(v) 544 case OpLeq32F: 545 return rewriteValueARM_OpLeq32F_0(v) 546 case OpLeq32U: 547 return rewriteValueARM_OpLeq32U_0(v) 548 case OpLeq64F: 549 return rewriteValueARM_OpLeq64F_0(v) 550 case OpLeq8: 551 return rewriteValueARM_OpLeq8_0(v) 552 case OpLeq8U: 553 return rewriteValueARM_OpLeq8U_0(v) 554 case OpLess16: 555 return rewriteValueARM_OpLess16_0(v) 556 case OpLess16U: 557 return rewriteValueARM_OpLess16U_0(v) 558 case OpLess32: 559 return rewriteValueARM_OpLess32_0(v) 560 case OpLess32F: 561 return rewriteValueARM_OpLess32F_0(v) 562 case OpLess32U: 563 return rewriteValueARM_OpLess32U_0(v) 564 case OpLess64F: 565 return rewriteValueARM_OpLess64F_0(v) 566 case OpLess8: 567 return rewriteValueARM_OpLess8_0(v) 568 case OpLess8U: 569 return rewriteValueARM_OpLess8U_0(v) 570 case OpLoad: 571 return rewriteValueARM_OpLoad_0(v) 572 case OpLsh16x16: 573 return rewriteValueARM_OpLsh16x16_0(v) 574 case OpLsh16x32: 575 return rewriteValueARM_OpLsh16x32_0(v) 576 case OpLsh16x64: 577 return rewriteValueARM_OpLsh16x64_0(v) 578 case OpLsh16x8: 579 return rewriteValueARM_OpLsh16x8_0(v) 580 case OpLsh32x16: 581 return rewriteValueARM_OpLsh32x16_0(v) 582 case OpLsh32x32: 583 return rewriteValueARM_OpLsh32x32_0(v) 584 case OpLsh32x64: 585 return rewriteValueARM_OpLsh32x64_0(v) 586 case OpLsh32x8: 587 return rewriteValueARM_OpLsh32x8_0(v) 588 case OpLsh8x16: 589 return rewriteValueARM_OpLsh8x16_0(v) 590 case OpLsh8x32: 591 return rewriteValueARM_OpLsh8x32_0(v) 592 case OpLsh8x64: 593 return rewriteValueARM_OpLsh8x64_0(v) 594 case OpLsh8x8: 595 return rewriteValueARM_OpLsh8x8_0(v) 596 case OpMod16: 597 return rewriteValueARM_OpMod16_0(v) 598 case OpMod16u: 599 return rewriteValueARM_OpMod16u_0(v) 600 case OpMod32: 601 return rewriteValueARM_OpMod32_0(v) 602 case OpMod32u: 603 return rewriteValueARM_OpMod32u_0(v) 604 case OpMod8: 605 return rewriteValueARM_OpMod8_0(v) 606 case OpMod8u: 607 return rewriteValueARM_OpMod8u_0(v) 608 case OpMove: 609 return rewriteValueARM_OpMove_0(v) 610 case OpMul16: 611 return rewriteValueARM_OpMul16_0(v) 612 case OpMul32: 613 return rewriteValueARM_OpMul32_0(v) 614 case OpMul32F: 615 return rewriteValueARM_OpMul32F_0(v) 616 case OpMul32uhilo: 617 return rewriteValueARM_OpMul32uhilo_0(v) 618 case OpMul64F: 619 return rewriteValueARM_OpMul64F_0(v) 620 case OpMul8: 621 return rewriteValueARM_OpMul8_0(v) 622 case OpNeg16: 623 return rewriteValueARM_OpNeg16_0(v) 624 case OpNeg32: 625 return rewriteValueARM_OpNeg32_0(v) 626 case OpNeg32F: 627 return rewriteValueARM_OpNeg32F_0(v) 628 case OpNeg64F: 629 return rewriteValueARM_OpNeg64F_0(v) 630 case OpNeg8: 631 return rewriteValueARM_OpNeg8_0(v) 632 case OpNeq16: 633 return rewriteValueARM_OpNeq16_0(v) 634 case OpNeq32: 635 return rewriteValueARM_OpNeq32_0(v) 636 case OpNeq32F: 637 return rewriteValueARM_OpNeq32F_0(v) 638 case OpNeq64F: 639 return rewriteValueARM_OpNeq64F_0(v) 640 case OpNeq8: 641 return rewriteValueARM_OpNeq8_0(v) 642 case OpNeqB: 643 return rewriteValueARM_OpNeqB_0(v) 644 case OpNeqPtr: 645 return rewriteValueARM_OpNeqPtr_0(v) 646 case OpNilCheck: 647 return rewriteValueARM_OpNilCheck_0(v) 648 case OpNot: 649 return rewriteValueARM_OpNot_0(v) 650 case OpOffPtr: 651 return rewriteValueARM_OpOffPtr_0(v) 652 case OpOr16: 653 return rewriteValueARM_OpOr16_0(v) 654 case OpOr32: 655 return rewriteValueARM_OpOr32_0(v) 656 case OpOr8: 657 return rewriteValueARM_OpOr8_0(v) 658 case OpOrB: 659 return rewriteValueARM_OpOrB_0(v) 660 case OpRound32F: 661 return rewriteValueARM_OpRound32F_0(v) 662 case OpRound64F: 663 return rewriteValueARM_OpRound64F_0(v) 664 case OpRsh16Ux16: 665 return rewriteValueARM_OpRsh16Ux16_0(v) 666 case OpRsh16Ux32: 667 return rewriteValueARM_OpRsh16Ux32_0(v) 668 case OpRsh16Ux64: 669 return rewriteValueARM_OpRsh16Ux64_0(v) 670 case OpRsh16Ux8: 671 return rewriteValueARM_OpRsh16Ux8_0(v) 672 case OpRsh16x16: 673 return rewriteValueARM_OpRsh16x16_0(v) 674 case OpRsh16x32: 675 return rewriteValueARM_OpRsh16x32_0(v) 676 case OpRsh16x64: 677 return rewriteValueARM_OpRsh16x64_0(v) 678 case OpRsh16x8: 679 return rewriteValueARM_OpRsh16x8_0(v) 680 case OpRsh32Ux16: 681 return rewriteValueARM_OpRsh32Ux16_0(v) 682 case OpRsh32Ux32: 683 return rewriteValueARM_OpRsh32Ux32_0(v) 684 case OpRsh32Ux64: 685 return rewriteValueARM_OpRsh32Ux64_0(v) 686 case OpRsh32Ux8: 687 return rewriteValueARM_OpRsh32Ux8_0(v) 688 case OpRsh32x16: 689 return rewriteValueARM_OpRsh32x16_0(v) 690 case OpRsh32x32: 691 return rewriteValueARM_OpRsh32x32_0(v) 692 case OpRsh32x64: 693 return rewriteValueARM_OpRsh32x64_0(v) 694 case OpRsh32x8: 695 return rewriteValueARM_OpRsh32x8_0(v) 696 case OpRsh8Ux16: 697 return rewriteValueARM_OpRsh8Ux16_0(v) 698 case OpRsh8Ux32: 699 return rewriteValueARM_OpRsh8Ux32_0(v) 700 case OpRsh8Ux64: 701 return rewriteValueARM_OpRsh8Ux64_0(v) 702 case OpRsh8Ux8: 703 return rewriteValueARM_OpRsh8Ux8_0(v) 704 case OpRsh8x16: 705 return rewriteValueARM_OpRsh8x16_0(v) 706 case OpRsh8x32: 707 return rewriteValueARM_OpRsh8x32_0(v) 708 case OpRsh8x64: 709 return rewriteValueARM_OpRsh8x64_0(v) 710 case OpRsh8x8: 711 return rewriteValueARM_OpRsh8x8_0(v) 712 case OpSelect0: 713 return rewriteValueARM_OpSelect0_0(v) 714 case OpSelect1: 715 return rewriteValueARM_OpSelect1_0(v) 716 case OpSignExt16to32: 717 return rewriteValueARM_OpSignExt16to32_0(v) 718 case OpSignExt8to16: 719 return rewriteValueARM_OpSignExt8to16_0(v) 720 case OpSignExt8to32: 721 return rewriteValueARM_OpSignExt8to32_0(v) 722 case OpSignmask: 723 return rewriteValueARM_OpSignmask_0(v) 724 case OpSlicemask: 725 return rewriteValueARM_OpSlicemask_0(v) 726 case OpSqrt: 727 return rewriteValueARM_OpSqrt_0(v) 728 case OpStaticCall: 729 return rewriteValueARM_OpStaticCall_0(v) 730 case OpStore: 731 return rewriteValueARM_OpStore_0(v) 732 case OpSub16: 733 return rewriteValueARM_OpSub16_0(v) 734 case OpSub32: 735 return rewriteValueARM_OpSub32_0(v) 736 case OpSub32F: 737 return rewriteValueARM_OpSub32F_0(v) 738 case OpSub32carry: 739 return rewriteValueARM_OpSub32carry_0(v) 740 case OpSub32withcarry: 741 return rewriteValueARM_OpSub32withcarry_0(v) 742 case OpSub64F: 743 return rewriteValueARM_OpSub64F_0(v) 744 case OpSub8: 745 return rewriteValueARM_OpSub8_0(v) 746 case OpSubPtr: 747 return rewriteValueARM_OpSubPtr_0(v) 748 case OpTrunc16to8: 749 return rewriteValueARM_OpTrunc16to8_0(v) 750 case OpTrunc32to16: 751 return rewriteValueARM_OpTrunc32to16_0(v) 752 case OpTrunc32to8: 753 return rewriteValueARM_OpTrunc32to8_0(v) 754 case OpXor16: 755 return rewriteValueARM_OpXor16_0(v) 756 case OpXor32: 757 return rewriteValueARM_OpXor32_0(v) 758 case OpXor8: 759 return rewriteValueARM_OpXor8_0(v) 760 case OpZero: 761 return rewriteValueARM_OpZero_0(v) 762 case OpZeroExt16to32: 763 return rewriteValueARM_OpZeroExt16to32_0(v) 764 case OpZeroExt8to16: 765 return rewriteValueARM_OpZeroExt8to16_0(v) 766 case OpZeroExt8to32: 767 return rewriteValueARM_OpZeroExt8to32_0(v) 768 case OpZeromask: 769 return rewriteValueARM_OpZeromask_0(v) 770 } 771 return false 772 } 773 func rewriteValueARM_OpARMADC_0(v *Value) bool { 774 // match: (ADC (MOVWconst [c]) x flags) 775 // cond: 776 // result: (ADCconst [c] x flags) 777 for { 778 _ = v.Args[2] 779 v_0 := v.Args[0] 780 if v_0.Op != OpARMMOVWconst { 781 break 782 } 783 c := v_0.AuxInt 784 x := v.Args[1] 785 flags := v.Args[2] 786 v.reset(OpARMADCconst) 787 v.AuxInt = c 788 v.AddArg(x) 789 v.AddArg(flags) 790 return true 791 } 792 // match: (ADC x (MOVWconst [c]) flags) 793 // cond: 794 // result: (ADCconst [c] x flags) 795 for { 796 _ = v.Args[2] 797 x := v.Args[0] 798 v_1 := v.Args[1] 799 if v_1.Op != OpARMMOVWconst { 800 break 801 } 802 c := v_1.AuxInt 803 flags := v.Args[2] 804 v.reset(OpARMADCconst) 805 v.AuxInt = c 806 v.AddArg(x) 807 v.AddArg(flags) 808 return true 809 } 810 // match: (ADC x (MOVWconst [c]) flags) 811 // cond: 812 // result: (ADCconst [c] x flags) 813 for { 814 _ = v.Args[2] 815 x := v.Args[0] 816 v_1 := v.Args[1] 817 if v_1.Op != OpARMMOVWconst { 818 break 819 } 820 c := v_1.AuxInt 821 flags := v.Args[2] 822 v.reset(OpARMADCconst) 823 v.AuxInt = c 824 v.AddArg(x) 825 v.AddArg(flags) 826 return true 827 } 828 // match: (ADC (MOVWconst [c]) x flags) 829 // cond: 830 // result: (ADCconst [c] x flags) 831 for { 832 _ = v.Args[2] 833 v_0 := v.Args[0] 834 if v_0.Op != OpARMMOVWconst { 835 break 836 } 837 c := v_0.AuxInt 838 x := v.Args[1] 839 flags := v.Args[2] 840 v.reset(OpARMADCconst) 841 v.AuxInt = c 842 v.AddArg(x) 843 v.AddArg(flags) 844 return true 845 } 846 // match: (ADC x (SLLconst [c] y) flags) 847 // cond: 848 // result: (ADCshiftLL x y [c] flags) 849 for { 850 _ = v.Args[2] 851 x := v.Args[0] 852 v_1 := v.Args[1] 853 if v_1.Op != OpARMSLLconst { 854 break 855 } 856 c := v_1.AuxInt 857 y := v_1.Args[0] 858 flags := v.Args[2] 859 v.reset(OpARMADCshiftLL) 860 v.AuxInt = c 861 v.AddArg(x) 862 v.AddArg(y) 863 v.AddArg(flags) 864 return true 865 } 866 // match: (ADC (SLLconst [c] y) x flags) 867 // cond: 868 // result: (ADCshiftLL x y [c] flags) 869 for { 870 _ = v.Args[2] 871 v_0 := v.Args[0] 872 if v_0.Op != OpARMSLLconst { 873 break 874 } 875 c := v_0.AuxInt 876 y := v_0.Args[0] 877 x := v.Args[1] 878 flags := v.Args[2] 879 v.reset(OpARMADCshiftLL) 880 v.AuxInt = c 881 v.AddArg(x) 882 v.AddArg(y) 883 v.AddArg(flags) 884 return true 885 } 886 // match: (ADC (SLLconst [c] y) x flags) 887 // cond: 888 // result: (ADCshiftLL x y [c] flags) 889 for { 890 _ = v.Args[2] 891 v_0 := v.Args[0] 892 if v_0.Op != OpARMSLLconst { 893 break 894 } 895 c := v_0.AuxInt 896 y := v_0.Args[0] 897 x := v.Args[1] 898 flags := v.Args[2] 899 v.reset(OpARMADCshiftLL) 900 v.AuxInt = c 901 v.AddArg(x) 902 v.AddArg(y) 903 v.AddArg(flags) 904 return true 905 } 906 // match: (ADC x (SLLconst [c] y) flags) 907 // cond: 908 // result: (ADCshiftLL x y [c] flags) 909 for { 910 _ = v.Args[2] 911 x := v.Args[0] 912 v_1 := v.Args[1] 913 if v_1.Op != OpARMSLLconst { 914 break 915 } 916 c := v_1.AuxInt 917 y := v_1.Args[0] 918 flags := v.Args[2] 919 v.reset(OpARMADCshiftLL) 920 v.AuxInt = c 921 v.AddArg(x) 922 v.AddArg(y) 923 v.AddArg(flags) 924 return true 925 } 926 // match: (ADC x (SRLconst [c] y) flags) 927 // cond: 928 // result: (ADCshiftRL x y [c] flags) 929 for { 930 _ = v.Args[2] 931 x := v.Args[0] 932 v_1 := v.Args[1] 933 if v_1.Op != OpARMSRLconst { 934 break 935 } 936 c := v_1.AuxInt 937 y := v_1.Args[0] 938 flags := v.Args[2] 939 v.reset(OpARMADCshiftRL) 940 v.AuxInt = c 941 v.AddArg(x) 942 v.AddArg(y) 943 v.AddArg(flags) 944 return true 945 } 946 // match: (ADC (SRLconst [c] y) x flags) 947 // cond: 948 // result: (ADCshiftRL x y [c] flags) 949 for { 950 _ = v.Args[2] 951 v_0 := v.Args[0] 952 if v_0.Op != OpARMSRLconst { 953 break 954 } 955 c := v_0.AuxInt 956 y := v_0.Args[0] 957 x := v.Args[1] 958 flags := v.Args[2] 959 v.reset(OpARMADCshiftRL) 960 v.AuxInt = c 961 v.AddArg(x) 962 v.AddArg(y) 963 v.AddArg(flags) 964 return true 965 } 966 return false 967 } 968 func rewriteValueARM_OpARMADC_10(v *Value) bool { 969 // match: (ADC (SRLconst [c] y) x flags) 970 // cond: 971 // result: (ADCshiftRL x y [c] flags) 972 for { 973 _ = v.Args[2] 974 v_0 := v.Args[0] 975 if v_0.Op != OpARMSRLconst { 976 break 977 } 978 c := v_0.AuxInt 979 y := v_0.Args[0] 980 x := v.Args[1] 981 flags := v.Args[2] 982 v.reset(OpARMADCshiftRL) 983 v.AuxInt = c 984 v.AddArg(x) 985 v.AddArg(y) 986 v.AddArg(flags) 987 return true 988 } 989 // match: (ADC x (SRLconst [c] y) flags) 990 // cond: 991 // result: (ADCshiftRL x y [c] flags) 992 for { 993 _ = v.Args[2] 994 x := v.Args[0] 995 v_1 := v.Args[1] 996 if v_1.Op != OpARMSRLconst { 997 break 998 } 999 c := v_1.AuxInt 1000 y := v_1.Args[0] 1001 flags := v.Args[2] 1002 v.reset(OpARMADCshiftRL) 1003 v.AuxInt = c 1004 v.AddArg(x) 1005 v.AddArg(y) 1006 v.AddArg(flags) 1007 return true 1008 } 1009 // match: (ADC x (SRAconst [c] y) flags) 1010 // cond: 1011 // result: (ADCshiftRA x y [c] flags) 1012 for { 1013 _ = v.Args[2] 1014 x := v.Args[0] 1015 v_1 := v.Args[1] 1016 if v_1.Op != OpARMSRAconst { 1017 break 1018 } 1019 c := v_1.AuxInt 1020 y := v_1.Args[0] 1021 flags := v.Args[2] 1022 v.reset(OpARMADCshiftRA) 1023 v.AuxInt = c 1024 v.AddArg(x) 1025 v.AddArg(y) 1026 v.AddArg(flags) 1027 return true 1028 } 1029 // match: (ADC (SRAconst [c] y) x flags) 1030 // cond: 1031 // result: (ADCshiftRA x y [c] flags) 1032 for { 1033 _ = v.Args[2] 1034 v_0 := v.Args[0] 1035 if v_0.Op != OpARMSRAconst { 1036 break 1037 } 1038 c := v_0.AuxInt 1039 y := v_0.Args[0] 1040 x := v.Args[1] 1041 flags := v.Args[2] 1042 v.reset(OpARMADCshiftRA) 1043 v.AuxInt = c 1044 v.AddArg(x) 1045 v.AddArg(y) 1046 v.AddArg(flags) 1047 return true 1048 } 1049 // match: (ADC (SRAconst [c] y) x flags) 1050 // cond: 1051 // result: (ADCshiftRA x y [c] flags) 1052 for { 1053 _ = v.Args[2] 1054 v_0 := v.Args[0] 1055 if v_0.Op != OpARMSRAconst { 1056 break 1057 } 1058 c := v_0.AuxInt 1059 y := v_0.Args[0] 1060 x := v.Args[1] 1061 flags := v.Args[2] 1062 v.reset(OpARMADCshiftRA) 1063 v.AuxInt = c 1064 v.AddArg(x) 1065 v.AddArg(y) 1066 v.AddArg(flags) 1067 return true 1068 } 1069 // match: (ADC x (SRAconst [c] y) flags) 1070 // cond: 1071 // result: (ADCshiftRA x y [c] flags) 1072 for { 1073 _ = v.Args[2] 1074 x := v.Args[0] 1075 v_1 := v.Args[1] 1076 if v_1.Op != OpARMSRAconst { 1077 break 1078 } 1079 c := v_1.AuxInt 1080 y := v_1.Args[0] 1081 flags := v.Args[2] 1082 v.reset(OpARMADCshiftRA) 1083 v.AuxInt = c 1084 v.AddArg(x) 1085 v.AddArg(y) 1086 v.AddArg(flags) 1087 return true 1088 } 1089 // match: (ADC x (SLL y z) flags) 1090 // cond: 1091 // result: (ADCshiftLLreg x y z flags) 1092 for { 1093 _ = v.Args[2] 1094 x := v.Args[0] 1095 v_1 := v.Args[1] 1096 if v_1.Op != OpARMSLL { 1097 break 1098 } 1099 _ = v_1.Args[1] 1100 y := v_1.Args[0] 1101 z := v_1.Args[1] 1102 flags := v.Args[2] 1103 v.reset(OpARMADCshiftLLreg) 1104 v.AddArg(x) 1105 v.AddArg(y) 1106 v.AddArg(z) 1107 v.AddArg(flags) 1108 return true 1109 } 1110 // match: (ADC (SLL y z) x flags) 1111 // cond: 1112 // result: (ADCshiftLLreg x y z flags) 1113 for { 1114 _ = v.Args[2] 1115 v_0 := v.Args[0] 1116 if v_0.Op != OpARMSLL { 1117 break 1118 } 1119 _ = v_0.Args[1] 1120 y := v_0.Args[0] 1121 z := v_0.Args[1] 1122 x := v.Args[1] 1123 flags := v.Args[2] 1124 v.reset(OpARMADCshiftLLreg) 1125 v.AddArg(x) 1126 v.AddArg(y) 1127 v.AddArg(z) 1128 v.AddArg(flags) 1129 return true 1130 } 1131 // match: (ADC (SLL y z) x flags) 1132 // cond: 1133 // result: (ADCshiftLLreg x y z flags) 1134 for { 1135 _ = v.Args[2] 1136 v_0 := v.Args[0] 1137 if v_0.Op != OpARMSLL { 1138 break 1139 } 1140 _ = v_0.Args[1] 1141 y := v_0.Args[0] 1142 z := v_0.Args[1] 1143 x := v.Args[1] 1144 flags := v.Args[2] 1145 v.reset(OpARMADCshiftLLreg) 1146 v.AddArg(x) 1147 v.AddArg(y) 1148 v.AddArg(z) 1149 v.AddArg(flags) 1150 return true 1151 } 1152 // match: (ADC x (SLL y z) flags) 1153 // cond: 1154 // result: (ADCshiftLLreg x y z flags) 1155 for { 1156 _ = v.Args[2] 1157 x := v.Args[0] 1158 v_1 := v.Args[1] 1159 if v_1.Op != OpARMSLL { 1160 break 1161 } 1162 _ = v_1.Args[1] 1163 y := v_1.Args[0] 1164 z := v_1.Args[1] 1165 flags := v.Args[2] 1166 v.reset(OpARMADCshiftLLreg) 1167 v.AddArg(x) 1168 v.AddArg(y) 1169 v.AddArg(z) 1170 v.AddArg(flags) 1171 return true 1172 } 1173 return false 1174 } 1175 func rewriteValueARM_OpARMADC_20(v *Value) bool { 1176 // match: (ADC x (SRL y z) flags) 1177 // cond: 1178 // result: (ADCshiftRLreg x y z flags) 1179 for { 1180 _ = v.Args[2] 1181 x := v.Args[0] 1182 v_1 := v.Args[1] 1183 if v_1.Op != OpARMSRL { 1184 break 1185 } 1186 _ = v_1.Args[1] 1187 y := v_1.Args[0] 1188 z := v_1.Args[1] 1189 flags := v.Args[2] 1190 v.reset(OpARMADCshiftRLreg) 1191 v.AddArg(x) 1192 v.AddArg(y) 1193 v.AddArg(z) 1194 v.AddArg(flags) 1195 return true 1196 } 1197 // match: (ADC (SRL y z) x flags) 1198 // cond: 1199 // result: (ADCshiftRLreg x y z flags) 1200 for { 1201 _ = v.Args[2] 1202 v_0 := v.Args[0] 1203 if v_0.Op != OpARMSRL { 1204 break 1205 } 1206 _ = v_0.Args[1] 1207 y := v_0.Args[0] 1208 z := v_0.Args[1] 1209 x := v.Args[1] 1210 flags := v.Args[2] 1211 v.reset(OpARMADCshiftRLreg) 1212 v.AddArg(x) 1213 v.AddArg(y) 1214 v.AddArg(z) 1215 v.AddArg(flags) 1216 return true 1217 } 1218 // match: (ADC (SRL y z) x flags) 1219 // cond: 1220 // result: (ADCshiftRLreg x y z flags) 1221 for { 1222 _ = v.Args[2] 1223 v_0 := v.Args[0] 1224 if v_0.Op != OpARMSRL { 1225 break 1226 } 1227 _ = v_0.Args[1] 1228 y := v_0.Args[0] 1229 z := v_0.Args[1] 1230 x := v.Args[1] 1231 flags := v.Args[2] 1232 v.reset(OpARMADCshiftRLreg) 1233 v.AddArg(x) 1234 v.AddArg(y) 1235 v.AddArg(z) 1236 v.AddArg(flags) 1237 return true 1238 } 1239 // match: (ADC x (SRL y z) flags) 1240 // cond: 1241 // result: (ADCshiftRLreg x y z flags) 1242 for { 1243 _ = v.Args[2] 1244 x := v.Args[0] 1245 v_1 := v.Args[1] 1246 if v_1.Op != OpARMSRL { 1247 break 1248 } 1249 _ = v_1.Args[1] 1250 y := v_1.Args[0] 1251 z := v_1.Args[1] 1252 flags := v.Args[2] 1253 v.reset(OpARMADCshiftRLreg) 1254 v.AddArg(x) 1255 v.AddArg(y) 1256 v.AddArg(z) 1257 v.AddArg(flags) 1258 return true 1259 } 1260 // match: (ADC x (SRA y z) flags) 1261 // cond: 1262 // result: (ADCshiftRAreg x y z flags) 1263 for { 1264 _ = v.Args[2] 1265 x := v.Args[0] 1266 v_1 := v.Args[1] 1267 if v_1.Op != OpARMSRA { 1268 break 1269 } 1270 _ = v_1.Args[1] 1271 y := v_1.Args[0] 1272 z := v_1.Args[1] 1273 flags := v.Args[2] 1274 v.reset(OpARMADCshiftRAreg) 1275 v.AddArg(x) 1276 v.AddArg(y) 1277 v.AddArg(z) 1278 v.AddArg(flags) 1279 return true 1280 } 1281 // match: (ADC (SRA y z) x flags) 1282 // cond: 1283 // result: (ADCshiftRAreg x y z flags) 1284 for { 1285 _ = v.Args[2] 1286 v_0 := v.Args[0] 1287 if v_0.Op != OpARMSRA { 1288 break 1289 } 1290 _ = v_0.Args[1] 1291 y := v_0.Args[0] 1292 z := v_0.Args[1] 1293 x := v.Args[1] 1294 flags := v.Args[2] 1295 v.reset(OpARMADCshiftRAreg) 1296 v.AddArg(x) 1297 v.AddArg(y) 1298 v.AddArg(z) 1299 v.AddArg(flags) 1300 return true 1301 } 1302 // match: (ADC (SRA y z) x flags) 1303 // cond: 1304 // result: (ADCshiftRAreg x y z flags) 1305 for { 1306 _ = v.Args[2] 1307 v_0 := v.Args[0] 1308 if v_0.Op != OpARMSRA { 1309 break 1310 } 1311 _ = v_0.Args[1] 1312 y := v_0.Args[0] 1313 z := v_0.Args[1] 1314 x := v.Args[1] 1315 flags := v.Args[2] 1316 v.reset(OpARMADCshiftRAreg) 1317 v.AddArg(x) 1318 v.AddArg(y) 1319 v.AddArg(z) 1320 v.AddArg(flags) 1321 return true 1322 } 1323 // match: (ADC x (SRA y z) flags) 1324 // cond: 1325 // result: (ADCshiftRAreg x y z flags) 1326 for { 1327 _ = v.Args[2] 1328 x := v.Args[0] 1329 v_1 := v.Args[1] 1330 if v_1.Op != OpARMSRA { 1331 break 1332 } 1333 _ = v_1.Args[1] 1334 y := v_1.Args[0] 1335 z := v_1.Args[1] 1336 flags := v.Args[2] 1337 v.reset(OpARMADCshiftRAreg) 1338 v.AddArg(x) 1339 v.AddArg(y) 1340 v.AddArg(z) 1341 v.AddArg(flags) 1342 return true 1343 } 1344 return false 1345 } 1346 func rewriteValueARM_OpARMADCconst_0(v *Value) bool { 1347 // match: (ADCconst [c] (ADDconst [d] x) flags) 1348 // cond: 1349 // result: (ADCconst [int64(int32(c+d))] x flags) 1350 for { 1351 c := v.AuxInt 1352 _ = v.Args[1] 1353 v_0 := v.Args[0] 1354 if v_0.Op != OpARMADDconst { 1355 break 1356 } 1357 d := v_0.AuxInt 1358 x := v_0.Args[0] 1359 flags := v.Args[1] 1360 v.reset(OpARMADCconst) 1361 v.AuxInt = int64(int32(c + d)) 1362 v.AddArg(x) 1363 v.AddArg(flags) 1364 return true 1365 } 1366 // match: (ADCconst [c] (SUBconst [d] x) flags) 1367 // cond: 1368 // result: (ADCconst [int64(int32(c-d))] x flags) 1369 for { 1370 c := v.AuxInt 1371 _ = v.Args[1] 1372 v_0 := v.Args[0] 1373 if v_0.Op != OpARMSUBconst { 1374 break 1375 } 1376 d := v_0.AuxInt 1377 x := v_0.Args[0] 1378 flags := v.Args[1] 1379 v.reset(OpARMADCconst) 1380 v.AuxInt = int64(int32(c - d)) 1381 v.AddArg(x) 1382 v.AddArg(flags) 1383 return true 1384 } 1385 return false 1386 } 1387 func rewriteValueARM_OpARMADCshiftLL_0(v *Value) bool { 1388 b := v.Block 1389 _ = b 1390 // match: (ADCshiftLL (MOVWconst [c]) x [d] flags) 1391 // cond: 1392 // result: (ADCconst [c] (SLLconst <x.Type> x [d]) flags) 1393 for { 1394 d := v.AuxInt 1395 _ = v.Args[2] 1396 v_0 := v.Args[0] 1397 if v_0.Op != OpARMMOVWconst { 1398 break 1399 } 1400 c := v_0.AuxInt 1401 x := v.Args[1] 1402 flags := v.Args[2] 1403 v.reset(OpARMADCconst) 1404 v.AuxInt = c 1405 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 1406 v0.AuxInt = d 1407 v0.AddArg(x) 1408 v.AddArg(v0) 1409 v.AddArg(flags) 1410 return true 1411 } 1412 // match: (ADCshiftLL x (MOVWconst [c]) [d] flags) 1413 // cond: 1414 // result: (ADCconst x [int64(uint32(c)<<uint64(d))] flags) 1415 for { 1416 d := v.AuxInt 1417 _ = v.Args[2] 1418 x := v.Args[0] 1419 v_1 := v.Args[1] 1420 if v_1.Op != OpARMMOVWconst { 1421 break 1422 } 1423 c := v_1.AuxInt 1424 flags := v.Args[2] 1425 v.reset(OpARMADCconst) 1426 v.AuxInt = int64(uint32(c) << uint64(d)) 1427 v.AddArg(x) 1428 v.AddArg(flags) 1429 return true 1430 } 1431 return false 1432 } 1433 func rewriteValueARM_OpARMADCshiftLLreg_0(v *Value) bool { 1434 b := v.Block 1435 _ = b 1436 // match: (ADCshiftLLreg (MOVWconst [c]) x y flags) 1437 // cond: 1438 // result: (ADCconst [c] (SLL <x.Type> x y) flags) 1439 for { 1440 _ = v.Args[3] 1441 v_0 := v.Args[0] 1442 if v_0.Op != OpARMMOVWconst { 1443 break 1444 } 1445 c := v_0.AuxInt 1446 x := v.Args[1] 1447 y := v.Args[2] 1448 flags := v.Args[3] 1449 v.reset(OpARMADCconst) 1450 v.AuxInt = c 1451 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 1452 v0.AddArg(x) 1453 v0.AddArg(y) 1454 v.AddArg(v0) 1455 v.AddArg(flags) 1456 return true 1457 } 1458 // match: (ADCshiftLLreg x y (MOVWconst [c]) flags) 1459 // cond: 1460 // result: (ADCshiftLL x y [c] flags) 1461 for { 1462 _ = v.Args[3] 1463 x := v.Args[0] 1464 y := v.Args[1] 1465 v_2 := v.Args[2] 1466 if v_2.Op != OpARMMOVWconst { 1467 break 1468 } 1469 c := v_2.AuxInt 1470 flags := v.Args[3] 1471 v.reset(OpARMADCshiftLL) 1472 v.AuxInt = c 1473 v.AddArg(x) 1474 v.AddArg(y) 1475 v.AddArg(flags) 1476 return true 1477 } 1478 return false 1479 } 1480 func rewriteValueARM_OpARMADCshiftRA_0(v *Value) bool { 1481 b := v.Block 1482 _ = b 1483 // match: (ADCshiftRA (MOVWconst [c]) x [d] flags) 1484 // cond: 1485 // result: (ADCconst [c] (SRAconst <x.Type> x [d]) flags) 1486 for { 1487 d := v.AuxInt 1488 _ = v.Args[2] 1489 v_0 := v.Args[0] 1490 if v_0.Op != OpARMMOVWconst { 1491 break 1492 } 1493 c := v_0.AuxInt 1494 x := v.Args[1] 1495 flags := v.Args[2] 1496 v.reset(OpARMADCconst) 1497 v.AuxInt = c 1498 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 1499 v0.AuxInt = d 1500 v0.AddArg(x) 1501 v.AddArg(v0) 1502 v.AddArg(flags) 1503 return true 1504 } 1505 // match: (ADCshiftRA x (MOVWconst [c]) [d] flags) 1506 // cond: 1507 // result: (ADCconst x [int64(int32(c)>>uint64(d))] flags) 1508 for { 1509 d := v.AuxInt 1510 _ = v.Args[2] 1511 x := v.Args[0] 1512 v_1 := v.Args[1] 1513 if v_1.Op != OpARMMOVWconst { 1514 break 1515 } 1516 c := v_1.AuxInt 1517 flags := v.Args[2] 1518 v.reset(OpARMADCconst) 1519 v.AuxInt = int64(int32(c) >> uint64(d)) 1520 v.AddArg(x) 1521 v.AddArg(flags) 1522 return true 1523 } 1524 return false 1525 } 1526 func rewriteValueARM_OpARMADCshiftRAreg_0(v *Value) bool { 1527 b := v.Block 1528 _ = b 1529 // match: (ADCshiftRAreg (MOVWconst [c]) x y flags) 1530 // cond: 1531 // result: (ADCconst [c] (SRA <x.Type> x y) flags) 1532 for { 1533 _ = v.Args[3] 1534 v_0 := v.Args[0] 1535 if v_0.Op != OpARMMOVWconst { 1536 break 1537 } 1538 c := v_0.AuxInt 1539 x := v.Args[1] 1540 y := v.Args[2] 1541 flags := v.Args[3] 1542 v.reset(OpARMADCconst) 1543 v.AuxInt = c 1544 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 1545 v0.AddArg(x) 1546 v0.AddArg(y) 1547 v.AddArg(v0) 1548 v.AddArg(flags) 1549 return true 1550 } 1551 // match: (ADCshiftRAreg x y (MOVWconst [c]) flags) 1552 // cond: 1553 // result: (ADCshiftRA x y [c] flags) 1554 for { 1555 _ = v.Args[3] 1556 x := v.Args[0] 1557 y := v.Args[1] 1558 v_2 := v.Args[2] 1559 if v_2.Op != OpARMMOVWconst { 1560 break 1561 } 1562 c := v_2.AuxInt 1563 flags := v.Args[3] 1564 v.reset(OpARMADCshiftRA) 1565 v.AuxInt = c 1566 v.AddArg(x) 1567 v.AddArg(y) 1568 v.AddArg(flags) 1569 return true 1570 } 1571 return false 1572 } 1573 func rewriteValueARM_OpARMADCshiftRL_0(v *Value) bool { 1574 b := v.Block 1575 _ = b 1576 // match: (ADCshiftRL (MOVWconst [c]) x [d] flags) 1577 // cond: 1578 // result: (ADCconst [c] (SRLconst <x.Type> x [d]) flags) 1579 for { 1580 d := v.AuxInt 1581 _ = v.Args[2] 1582 v_0 := v.Args[0] 1583 if v_0.Op != OpARMMOVWconst { 1584 break 1585 } 1586 c := v_0.AuxInt 1587 x := v.Args[1] 1588 flags := v.Args[2] 1589 v.reset(OpARMADCconst) 1590 v.AuxInt = c 1591 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 1592 v0.AuxInt = d 1593 v0.AddArg(x) 1594 v.AddArg(v0) 1595 v.AddArg(flags) 1596 return true 1597 } 1598 // match: (ADCshiftRL x (MOVWconst [c]) [d] flags) 1599 // cond: 1600 // result: (ADCconst x [int64(uint32(c)>>uint64(d))] flags) 1601 for { 1602 d := v.AuxInt 1603 _ = v.Args[2] 1604 x := v.Args[0] 1605 v_1 := v.Args[1] 1606 if v_1.Op != OpARMMOVWconst { 1607 break 1608 } 1609 c := v_1.AuxInt 1610 flags := v.Args[2] 1611 v.reset(OpARMADCconst) 1612 v.AuxInt = int64(uint32(c) >> uint64(d)) 1613 v.AddArg(x) 1614 v.AddArg(flags) 1615 return true 1616 } 1617 return false 1618 } 1619 func rewriteValueARM_OpARMADCshiftRLreg_0(v *Value) bool { 1620 b := v.Block 1621 _ = b 1622 // match: (ADCshiftRLreg (MOVWconst [c]) x y flags) 1623 // cond: 1624 // result: (ADCconst [c] (SRL <x.Type> x y) flags) 1625 for { 1626 _ = v.Args[3] 1627 v_0 := v.Args[0] 1628 if v_0.Op != OpARMMOVWconst { 1629 break 1630 } 1631 c := v_0.AuxInt 1632 x := v.Args[1] 1633 y := v.Args[2] 1634 flags := v.Args[3] 1635 v.reset(OpARMADCconst) 1636 v.AuxInt = c 1637 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 1638 v0.AddArg(x) 1639 v0.AddArg(y) 1640 v.AddArg(v0) 1641 v.AddArg(flags) 1642 return true 1643 } 1644 // match: (ADCshiftRLreg x y (MOVWconst [c]) flags) 1645 // cond: 1646 // result: (ADCshiftRL x y [c] flags) 1647 for { 1648 _ = v.Args[3] 1649 x := v.Args[0] 1650 y := v.Args[1] 1651 v_2 := v.Args[2] 1652 if v_2.Op != OpARMMOVWconst { 1653 break 1654 } 1655 c := v_2.AuxInt 1656 flags := v.Args[3] 1657 v.reset(OpARMADCshiftRL) 1658 v.AuxInt = c 1659 v.AddArg(x) 1660 v.AddArg(y) 1661 v.AddArg(flags) 1662 return true 1663 } 1664 return false 1665 } 1666 func rewriteValueARM_OpARMADD_0(v *Value) bool { 1667 // match: (ADD x (MOVWconst [c])) 1668 // cond: 1669 // result: (ADDconst [c] x) 1670 for { 1671 _ = v.Args[1] 1672 x := v.Args[0] 1673 v_1 := v.Args[1] 1674 if v_1.Op != OpARMMOVWconst { 1675 break 1676 } 1677 c := v_1.AuxInt 1678 v.reset(OpARMADDconst) 1679 v.AuxInt = c 1680 v.AddArg(x) 1681 return true 1682 } 1683 // match: (ADD (MOVWconst [c]) x) 1684 // cond: 1685 // result: (ADDconst [c] x) 1686 for { 1687 _ = v.Args[1] 1688 v_0 := v.Args[0] 1689 if v_0.Op != OpARMMOVWconst { 1690 break 1691 } 1692 c := v_0.AuxInt 1693 x := v.Args[1] 1694 v.reset(OpARMADDconst) 1695 v.AuxInt = c 1696 v.AddArg(x) 1697 return true 1698 } 1699 // match: (ADD x (SLLconst [c] y)) 1700 // cond: 1701 // result: (ADDshiftLL x y [c]) 1702 for { 1703 _ = v.Args[1] 1704 x := v.Args[0] 1705 v_1 := v.Args[1] 1706 if v_1.Op != OpARMSLLconst { 1707 break 1708 } 1709 c := v_1.AuxInt 1710 y := v_1.Args[0] 1711 v.reset(OpARMADDshiftLL) 1712 v.AuxInt = c 1713 v.AddArg(x) 1714 v.AddArg(y) 1715 return true 1716 } 1717 // match: (ADD (SLLconst [c] y) x) 1718 // cond: 1719 // result: (ADDshiftLL x y [c]) 1720 for { 1721 _ = v.Args[1] 1722 v_0 := v.Args[0] 1723 if v_0.Op != OpARMSLLconst { 1724 break 1725 } 1726 c := v_0.AuxInt 1727 y := v_0.Args[0] 1728 x := v.Args[1] 1729 v.reset(OpARMADDshiftLL) 1730 v.AuxInt = c 1731 v.AddArg(x) 1732 v.AddArg(y) 1733 return true 1734 } 1735 // match: (ADD x (SRLconst [c] y)) 1736 // cond: 1737 // result: (ADDshiftRL x y [c]) 1738 for { 1739 _ = v.Args[1] 1740 x := v.Args[0] 1741 v_1 := v.Args[1] 1742 if v_1.Op != OpARMSRLconst { 1743 break 1744 } 1745 c := v_1.AuxInt 1746 y := v_1.Args[0] 1747 v.reset(OpARMADDshiftRL) 1748 v.AuxInt = c 1749 v.AddArg(x) 1750 v.AddArg(y) 1751 return true 1752 } 1753 // match: (ADD (SRLconst [c] y) x) 1754 // cond: 1755 // result: (ADDshiftRL x y [c]) 1756 for { 1757 _ = v.Args[1] 1758 v_0 := v.Args[0] 1759 if v_0.Op != OpARMSRLconst { 1760 break 1761 } 1762 c := v_0.AuxInt 1763 y := v_0.Args[0] 1764 x := v.Args[1] 1765 v.reset(OpARMADDshiftRL) 1766 v.AuxInt = c 1767 v.AddArg(x) 1768 v.AddArg(y) 1769 return true 1770 } 1771 // match: (ADD x (SRAconst [c] y)) 1772 // cond: 1773 // result: (ADDshiftRA x y [c]) 1774 for { 1775 _ = v.Args[1] 1776 x := v.Args[0] 1777 v_1 := v.Args[1] 1778 if v_1.Op != OpARMSRAconst { 1779 break 1780 } 1781 c := v_1.AuxInt 1782 y := v_1.Args[0] 1783 v.reset(OpARMADDshiftRA) 1784 v.AuxInt = c 1785 v.AddArg(x) 1786 v.AddArg(y) 1787 return true 1788 } 1789 // match: (ADD (SRAconst [c] y) x) 1790 // cond: 1791 // result: (ADDshiftRA x y [c]) 1792 for { 1793 _ = v.Args[1] 1794 v_0 := v.Args[0] 1795 if v_0.Op != OpARMSRAconst { 1796 break 1797 } 1798 c := v_0.AuxInt 1799 y := v_0.Args[0] 1800 x := v.Args[1] 1801 v.reset(OpARMADDshiftRA) 1802 v.AuxInt = c 1803 v.AddArg(x) 1804 v.AddArg(y) 1805 return true 1806 } 1807 // match: (ADD x (SLL y z)) 1808 // cond: 1809 // result: (ADDshiftLLreg x y z) 1810 for { 1811 _ = v.Args[1] 1812 x := v.Args[0] 1813 v_1 := v.Args[1] 1814 if v_1.Op != OpARMSLL { 1815 break 1816 } 1817 _ = v_1.Args[1] 1818 y := v_1.Args[0] 1819 z := v_1.Args[1] 1820 v.reset(OpARMADDshiftLLreg) 1821 v.AddArg(x) 1822 v.AddArg(y) 1823 v.AddArg(z) 1824 return true 1825 } 1826 // match: (ADD (SLL y z) x) 1827 // cond: 1828 // result: (ADDshiftLLreg x y z) 1829 for { 1830 _ = v.Args[1] 1831 v_0 := v.Args[0] 1832 if v_0.Op != OpARMSLL { 1833 break 1834 } 1835 _ = v_0.Args[1] 1836 y := v_0.Args[0] 1837 z := v_0.Args[1] 1838 x := v.Args[1] 1839 v.reset(OpARMADDshiftLLreg) 1840 v.AddArg(x) 1841 v.AddArg(y) 1842 v.AddArg(z) 1843 return true 1844 } 1845 return false 1846 } 1847 func rewriteValueARM_OpARMADD_10(v *Value) bool { 1848 b := v.Block 1849 _ = b 1850 // match: (ADD x (SRL y z)) 1851 // cond: 1852 // result: (ADDshiftRLreg x y z) 1853 for { 1854 _ = v.Args[1] 1855 x := v.Args[0] 1856 v_1 := v.Args[1] 1857 if v_1.Op != OpARMSRL { 1858 break 1859 } 1860 _ = v_1.Args[1] 1861 y := v_1.Args[0] 1862 z := v_1.Args[1] 1863 v.reset(OpARMADDshiftRLreg) 1864 v.AddArg(x) 1865 v.AddArg(y) 1866 v.AddArg(z) 1867 return true 1868 } 1869 // match: (ADD (SRL y z) x) 1870 // cond: 1871 // result: (ADDshiftRLreg x y z) 1872 for { 1873 _ = v.Args[1] 1874 v_0 := v.Args[0] 1875 if v_0.Op != OpARMSRL { 1876 break 1877 } 1878 _ = v_0.Args[1] 1879 y := v_0.Args[0] 1880 z := v_0.Args[1] 1881 x := v.Args[1] 1882 v.reset(OpARMADDshiftRLreg) 1883 v.AddArg(x) 1884 v.AddArg(y) 1885 v.AddArg(z) 1886 return true 1887 } 1888 // match: (ADD x (SRA y z)) 1889 // cond: 1890 // result: (ADDshiftRAreg x y z) 1891 for { 1892 _ = v.Args[1] 1893 x := v.Args[0] 1894 v_1 := v.Args[1] 1895 if v_1.Op != OpARMSRA { 1896 break 1897 } 1898 _ = v_1.Args[1] 1899 y := v_1.Args[0] 1900 z := v_1.Args[1] 1901 v.reset(OpARMADDshiftRAreg) 1902 v.AddArg(x) 1903 v.AddArg(y) 1904 v.AddArg(z) 1905 return true 1906 } 1907 // match: (ADD (SRA y z) x) 1908 // cond: 1909 // result: (ADDshiftRAreg x y z) 1910 for { 1911 _ = v.Args[1] 1912 v_0 := v.Args[0] 1913 if v_0.Op != OpARMSRA { 1914 break 1915 } 1916 _ = v_0.Args[1] 1917 y := v_0.Args[0] 1918 z := v_0.Args[1] 1919 x := v.Args[1] 1920 v.reset(OpARMADDshiftRAreg) 1921 v.AddArg(x) 1922 v.AddArg(y) 1923 v.AddArg(z) 1924 return true 1925 } 1926 // match: (ADD x (RSBconst [0] y)) 1927 // cond: 1928 // result: (SUB x y) 1929 for { 1930 _ = v.Args[1] 1931 x := v.Args[0] 1932 v_1 := v.Args[1] 1933 if v_1.Op != OpARMRSBconst { 1934 break 1935 } 1936 if v_1.AuxInt != 0 { 1937 break 1938 } 1939 y := v_1.Args[0] 1940 v.reset(OpARMSUB) 1941 v.AddArg(x) 1942 v.AddArg(y) 1943 return true 1944 } 1945 // match: (ADD (RSBconst [0] y) x) 1946 // cond: 1947 // result: (SUB x y) 1948 for { 1949 _ = v.Args[1] 1950 v_0 := v.Args[0] 1951 if v_0.Op != OpARMRSBconst { 1952 break 1953 } 1954 if v_0.AuxInt != 0 { 1955 break 1956 } 1957 y := v_0.Args[0] 1958 x := v.Args[1] 1959 v.reset(OpARMSUB) 1960 v.AddArg(x) 1961 v.AddArg(y) 1962 return true 1963 } 1964 // match: (ADD <t> (RSBconst [c] x) (RSBconst [d] y)) 1965 // cond: 1966 // result: (RSBconst [c+d] (ADD <t> x y)) 1967 for { 1968 t := v.Type 1969 _ = v.Args[1] 1970 v_0 := v.Args[0] 1971 if v_0.Op != OpARMRSBconst { 1972 break 1973 } 1974 c := v_0.AuxInt 1975 x := v_0.Args[0] 1976 v_1 := v.Args[1] 1977 if v_1.Op != OpARMRSBconst { 1978 break 1979 } 1980 d := v_1.AuxInt 1981 y := v_1.Args[0] 1982 v.reset(OpARMRSBconst) 1983 v.AuxInt = c + d 1984 v0 := b.NewValue0(v.Pos, OpARMADD, t) 1985 v0.AddArg(x) 1986 v0.AddArg(y) 1987 v.AddArg(v0) 1988 return true 1989 } 1990 // match: (ADD <t> (RSBconst [d] y) (RSBconst [c] x)) 1991 // cond: 1992 // result: (RSBconst [c+d] (ADD <t> x y)) 1993 for { 1994 t := v.Type 1995 _ = v.Args[1] 1996 v_0 := v.Args[0] 1997 if v_0.Op != OpARMRSBconst { 1998 break 1999 } 2000 d := v_0.AuxInt 2001 y := v_0.Args[0] 2002 v_1 := v.Args[1] 2003 if v_1.Op != OpARMRSBconst { 2004 break 2005 } 2006 c := v_1.AuxInt 2007 x := v_1.Args[0] 2008 v.reset(OpARMRSBconst) 2009 v.AuxInt = c + d 2010 v0 := b.NewValue0(v.Pos, OpARMADD, t) 2011 v0.AddArg(x) 2012 v0.AddArg(y) 2013 v.AddArg(v0) 2014 return true 2015 } 2016 // match: (ADD (MUL x y) a) 2017 // cond: 2018 // result: (MULA x y a) 2019 for { 2020 _ = v.Args[1] 2021 v_0 := v.Args[0] 2022 if v_0.Op != OpARMMUL { 2023 break 2024 } 2025 _ = v_0.Args[1] 2026 x := v_0.Args[0] 2027 y := v_0.Args[1] 2028 a := v.Args[1] 2029 v.reset(OpARMMULA) 2030 v.AddArg(x) 2031 v.AddArg(y) 2032 v.AddArg(a) 2033 return true 2034 } 2035 // match: (ADD a (MUL x y)) 2036 // cond: 2037 // result: (MULA x y a) 2038 for { 2039 _ = v.Args[1] 2040 a := v.Args[0] 2041 v_1 := v.Args[1] 2042 if v_1.Op != OpARMMUL { 2043 break 2044 } 2045 _ = v_1.Args[1] 2046 x := v_1.Args[0] 2047 y := v_1.Args[1] 2048 v.reset(OpARMMULA) 2049 v.AddArg(x) 2050 v.AddArg(y) 2051 v.AddArg(a) 2052 return true 2053 } 2054 return false 2055 } 2056 func rewriteValueARM_OpARMADDD_0(v *Value) bool { 2057 // match: (ADDD a (MULD x y)) 2058 // cond: a.Uses == 1 && objabi.GOARM >= 6 2059 // result: (MULAD a x y) 2060 for { 2061 _ = v.Args[1] 2062 a := v.Args[0] 2063 v_1 := v.Args[1] 2064 if v_1.Op != OpARMMULD { 2065 break 2066 } 2067 _ = v_1.Args[1] 2068 x := v_1.Args[0] 2069 y := v_1.Args[1] 2070 if !(a.Uses == 1 && objabi.GOARM >= 6) { 2071 break 2072 } 2073 v.reset(OpARMMULAD) 2074 v.AddArg(a) 2075 v.AddArg(x) 2076 v.AddArg(y) 2077 return true 2078 } 2079 // match: (ADDD (MULD x y) a) 2080 // cond: a.Uses == 1 && objabi.GOARM >= 6 2081 // result: (MULAD a x y) 2082 for { 2083 _ = v.Args[1] 2084 v_0 := v.Args[0] 2085 if v_0.Op != OpARMMULD { 2086 break 2087 } 2088 _ = v_0.Args[1] 2089 x := v_0.Args[0] 2090 y := v_0.Args[1] 2091 a := v.Args[1] 2092 if !(a.Uses == 1 && objabi.GOARM >= 6) { 2093 break 2094 } 2095 v.reset(OpARMMULAD) 2096 v.AddArg(a) 2097 v.AddArg(x) 2098 v.AddArg(y) 2099 return true 2100 } 2101 // match: (ADDD a (NMULD x y)) 2102 // cond: a.Uses == 1 && objabi.GOARM >= 6 2103 // result: (MULSD a x y) 2104 for { 2105 _ = v.Args[1] 2106 a := v.Args[0] 2107 v_1 := v.Args[1] 2108 if v_1.Op != OpARMNMULD { 2109 break 2110 } 2111 _ = v_1.Args[1] 2112 x := v_1.Args[0] 2113 y := v_1.Args[1] 2114 if !(a.Uses == 1 && objabi.GOARM >= 6) { 2115 break 2116 } 2117 v.reset(OpARMMULSD) 2118 v.AddArg(a) 2119 v.AddArg(x) 2120 v.AddArg(y) 2121 return true 2122 } 2123 // match: (ADDD (NMULD x y) a) 2124 // cond: a.Uses == 1 && objabi.GOARM >= 6 2125 // result: (MULSD a x y) 2126 for { 2127 _ = v.Args[1] 2128 v_0 := v.Args[0] 2129 if v_0.Op != OpARMNMULD { 2130 break 2131 } 2132 _ = v_0.Args[1] 2133 x := v_0.Args[0] 2134 y := v_0.Args[1] 2135 a := v.Args[1] 2136 if !(a.Uses == 1 && objabi.GOARM >= 6) { 2137 break 2138 } 2139 v.reset(OpARMMULSD) 2140 v.AddArg(a) 2141 v.AddArg(x) 2142 v.AddArg(y) 2143 return true 2144 } 2145 return false 2146 } 2147 func rewriteValueARM_OpARMADDF_0(v *Value) bool { 2148 // match: (ADDF a (MULF x y)) 2149 // cond: a.Uses == 1 && objabi.GOARM >= 6 2150 // result: (MULAF a x y) 2151 for { 2152 _ = v.Args[1] 2153 a := v.Args[0] 2154 v_1 := v.Args[1] 2155 if v_1.Op != OpARMMULF { 2156 break 2157 } 2158 _ = v_1.Args[1] 2159 x := v_1.Args[0] 2160 y := v_1.Args[1] 2161 if !(a.Uses == 1 && objabi.GOARM >= 6) { 2162 break 2163 } 2164 v.reset(OpARMMULAF) 2165 v.AddArg(a) 2166 v.AddArg(x) 2167 v.AddArg(y) 2168 return true 2169 } 2170 // match: (ADDF (MULF x y) a) 2171 // cond: a.Uses == 1 && objabi.GOARM >= 6 2172 // result: (MULAF a x y) 2173 for { 2174 _ = v.Args[1] 2175 v_0 := v.Args[0] 2176 if v_0.Op != OpARMMULF { 2177 break 2178 } 2179 _ = v_0.Args[1] 2180 x := v_0.Args[0] 2181 y := v_0.Args[1] 2182 a := v.Args[1] 2183 if !(a.Uses == 1 && objabi.GOARM >= 6) { 2184 break 2185 } 2186 v.reset(OpARMMULAF) 2187 v.AddArg(a) 2188 v.AddArg(x) 2189 v.AddArg(y) 2190 return true 2191 } 2192 // match: (ADDF a (NMULF x y)) 2193 // cond: a.Uses == 1 && objabi.GOARM >= 6 2194 // result: (MULSF a x y) 2195 for { 2196 _ = v.Args[1] 2197 a := v.Args[0] 2198 v_1 := v.Args[1] 2199 if v_1.Op != OpARMNMULF { 2200 break 2201 } 2202 _ = v_1.Args[1] 2203 x := v_1.Args[0] 2204 y := v_1.Args[1] 2205 if !(a.Uses == 1 && objabi.GOARM >= 6) { 2206 break 2207 } 2208 v.reset(OpARMMULSF) 2209 v.AddArg(a) 2210 v.AddArg(x) 2211 v.AddArg(y) 2212 return true 2213 } 2214 // match: (ADDF (NMULF x y) a) 2215 // cond: a.Uses == 1 && objabi.GOARM >= 6 2216 // result: (MULSF a x y) 2217 for { 2218 _ = v.Args[1] 2219 v_0 := v.Args[0] 2220 if v_0.Op != OpARMNMULF { 2221 break 2222 } 2223 _ = v_0.Args[1] 2224 x := v_0.Args[0] 2225 y := v_0.Args[1] 2226 a := v.Args[1] 2227 if !(a.Uses == 1 && objabi.GOARM >= 6) { 2228 break 2229 } 2230 v.reset(OpARMMULSF) 2231 v.AddArg(a) 2232 v.AddArg(x) 2233 v.AddArg(y) 2234 return true 2235 } 2236 return false 2237 } 2238 func rewriteValueARM_OpARMADDS_0(v *Value) bool { 2239 // match: (ADDS x (MOVWconst [c])) 2240 // cond: 2241 // result: (ADDSconst [c] x) 2242 for { 2243 _ = v.Args[1] 2244 x := v.Args[0] 2245 v_1 := v.Args[1] 2246 if v_1.Op != OpARMMOVWconst { 2247 break 2248 } 2249 c := v_1.AuxInt 2250 v.reset(OpARMADDSconst) 2251 v.AuxInt = c 2252 v.AddArg(x) 2253 return true 2254 } 2255 // match: (ADDS (MOVWconst [c]) x) 2256 // cond: 2257 // result: (ADDSconst [c] x) 2258 for { 2259 _ = v.Args[1] 2260 v_0 := v.Args[0] 2261 if v_0.Op != OpARMMOVWconst { 2262 break 2263 } 2264 c := v_0.AuxInt 2265 x := v.Args[1] 2266 v.reset(OpARMADDSconst) 2267 v.AuxInt = c 2268 v.AddArg(x) 2269 return true 2270 } 2271 // match: (ADDS x (SLLconst [c] y)) 2272 // cond: 2273 // result: (ADDSshiftLL x y [c]) 2274 for { 2275 _ = v.Args[1] 2276 x := v.Args[0] 2277 v_1 := v.Args[1] 2278 if v_1.Op != OpARMSLLconst { 2279 break 2280 } 2281 c := v_1.AuxInt 2282 y := v_1.Args[0] 2283 v.reset(OpARMADDSshiftLL) 2284 v.AuxInt = c 2285 v.AddArg(x) 2286 v.AddArg(y) 2287 return true 2288 } 2289 // match: (ADDS (SLLconst [c] y) x) 2290 // cond: 2291 // result: (ADDSshiftLL x y [c]) 2292 for { 2293 _ = v.Args[1] 2294 v_0 := v.Args[0] 2295 if v_0.Op != OpARMSLLconst { 2296 break 2297 } 2298 c := v_0.AuxInt 2299 y := v_0.Args[0] 2300 x := v.Args[1] 2301 v.reset(OpARMADDSshiftLL) 2302 v.AuxInt = c 2303 v.AddArg(x) 2304 v.AddArg(y) 2305 return true 2306 } 2307 // match: (ADDS x (SRLconst [c] y)) 2308 // cond: 2309 // result: (ADDSshiftRL x y [c]) 2310 for { 2311 _ = v.Args[1] 2312 x := v.Args[0] 2313 v_1 := v.Args[1] 2314 if v_1.Op != OpARMSRLconst { 2315 break 2316 } 2317 c := v_1.AuxInt 2318 y := v_1.Args[0] 2319 v.reset(OpARMADDSshiftRL) 2320 v.AuxInt = c 2321 v.AddArg(x) 2322 v.AddArg(y) 2323 return true 2324 } 2325 // match: (ADDS (SRLconst [c] y) x) 2326 // cond: 2327 // result: (ADDSshiftRL x y [c]) 2328 for { 2329 _ = v.Args[1] 2330 v_0 := v.Args[0] 2331 if v_0.Op != OpARMSRLconst { 2332 break 2333 } 2334 c := v_0.AuxInt 2335 y := v_0.Args[0] 2336 x := v.Args[1] 2337 v.reset(OpARMADDSshiftRL) 2338 v.AuxInt = c 2339 v.AddArg(x) 2340 v.AddArg(y) 2341 return true 2342 } 2343 // match: (ADDS x (SRAconst [c] y)) 2344 // cond: 2345 // result: (ADDSshiftRA x y [c]) 2346 for { 2347 _ = v.Args[1] 2348 x := v.Args[0] 2349 v_1 := v.Args[1] 2350 if v_1.Op != OpARMSRAconst { 2351 break 2352 } 2353 c := v_1.AuxInt 2354 y := v_1.Args[0] 2355 v.reset(OpARMADDSshiftRA) 2356 v.AuxInt = c 2357 v.AddArg(x) 2358 v.AddArg(y) 2359 return true 2360 } 2361 // match: (ADDS (SRAconst [c] y) x) 2362 // cond: 2363 // result: (ADDSshiftRA x y [c]) 2364 for { 2365 _ = v.Args[1] 2366 v_0 := v.Args[0] 2367 if v_0.Op != OpARMSRAconst { 2368 break 2369 } 2370 c := v_0.AuxInt 2371 y := v_0.Args[0] 2372 x := v.Args[1] 2373 v.reset(OpARMADDSshiftRA) 2374 v.AuxInt = c 2375 v.AddArg(x) 2376 v.AddArg(y) 2377 return true 2378 } 2379 // match: (ADDS x (SLL y z)) 2380 // cond: 2381 // result: (ADDSshiftLLreg x y z) 2382 for { 2383 _ = v.Args[1] 2384 x := v.Args[0] 2385 v_1 := v.Args[1] 2386 if v_1.Op != OpARMSLL { 2387 break 2388 } 2389 _ = v_1.Args[1] 2390 y := v_1.Args[0] 2391 z := v_1.Args[1] 2392 v.reset(OpARMADDSshiftLLreg) 2393 v.AddArg(x) 2394 v.AddArg(y) 2395 v.AddArg(z) 2396 return true 2397 } 2398 // match: (ADDS (SLL y z) x) 2399 // cond: 2400 // result: (ADDSshiftLLreg x y z) 2401 for { 2402 _ = v.Args[1] 2403 v_0 := v.Args[0] 2404 if v_0.Op != OpARMSLL { 2405 break 2406 } 2407 _ = v_0.Args[1] 2408 y := v_0.Args[0] 2409 z := v_0.Args[1] 2410 x := v.Args[1] 2411 v.reset(OpARMADDSshiftLLreg) 2412 v.AddArg(x) 2413 v.AddArg(y) 2414 v.AddArg(z) 2415 return true 2416 } 2417 return false 2418 } 2419 func rewriteValueARM_OpARMADDS_10(v *Value) bool { 2420 // match: (ADDS x (SRL y z)) 2421 // cond: 2422 // result: (ADDSshiftRLreg x y z) 2423 for { 2424 _ = v.Args[1] 2425 x := v.Args[0] 2426 v_1 := v.Args[1] 2427 if v_1.Op != OpARMSRL { 2428 break 2429 } 2430 _ = v_1.Args[1] 2431 y := v_1.Args[0] 2432 z := v_1.Args[1] 2433 v.reset(OpARMADDSshiftRLreg) 2434 v.AddArg(x) 2435 v.AddArg(y) 2436 v.AddArg(z) 2437 return true 2438 } 2439 // match: (ADDS (SRL y z) x) 2440 // cond: 2441 // result: (ADDSshiftRLreg x y z) 2442 for { 2443 _ = v.Args[1] 2444 v_0 := v.Args[0] 2445 if v_0.Op != OpARMSRL { 2446 break 2447 } 2448 _ = v_0.Args[1] 2449 y := v_0.Args[0] 2450 z := v_0.Args[1] 2451 x := v.Args[1] 2452 v.reset(OpARMADDSshiftRLreg) 2453 v.AddArg(x) 2454 v.AddArg(y) 2455 v.AddArg(z) 2456 return true 2457 } 2458 // match: (ADDS x (SRA y z)) 2459 // cond: 2460 // result: (ADDSshiftRAreg x y z) 2461 for { 2462 _ = v.Args[1] 2463 x := v.Args[0] 2464 v_1 := v.Args[1] 2465 if v_1.Op != OpARMSRA { 2466 break 2467 } 2468 _ = v_1.Args[1] 2469 y := v_1.Args[0] 2470 z := v_1.Args[1] 2471 v.reset(OpARMADDSshiftRAreg) 2472 v.AddArg(x) 2473 v.AddArg(y) 2474 v.AddArg(z) 2475 return true 2476 } 2477 // match: (ADDS (SRA y z) x) 2478 // cond: 2479 // result: (ADDSshiftRAreg x y z) 2480 for { 2481 _ = v.Args[1] 2482 v_0 := v.Args[0] 2483 if v_0.Op != OpARMSRA { 2484 break 2485 } 2486 _ = v_0.Args[1] 2487 y := v_0.Args[0] 2488 z := v_0.Args[1] 2489 x := v.Args[1] 2490 v.reset(OpARMADDSshiftRAreg) 2491 v.AddArg(x) 2492 v.AddArg(y) 2493 v.AddArg(z) 2494 return true 2495 } 2496 return false 2497 } 2498 func rewriteValueARM_OpARMADDSshiftLL_0(v *Value) bool { 2499 b := v.Block 2500 _ = b 2501 // match: (ADDSshiftLL (MOVWconst [c]) x [d]) 2502 // cond: 2503 // result: (ADDSconst [c] (SLLconst <x.Type> x [d])) 2504 for { 2505 d := v.AuxInt 2506 _ = v.Args[1] 2507 v_0 := v.Args[0] 2508 if v_0.Op != OpARMMOVWconst { 2509 break 2510 } 2511 c := v_0.AuxInt 2512 x := v.Args[1] 2513 v.reset(OpARMADDSconst) 2514 v.AuxInt = c 2515 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 2516 v0.AuxInt = d 2517 v0.AddArg(x) 2518 v.AddArg(v0) 2519 return true 2520 } 2521 // match: (ADDSshiftLL x (MOVWconst [c]) [d]) 2522 // cond: 2523 // result: (ADDSconst x [int64(uint32(c)<<uint64(d))]) 2524 for { 2525 d := v.AuxInt 2526 _ = v.Args[1] 2527 x := v.Args[0] 2528 v_1 := v.Args[1] 2529 if v_1.Op != OpARMMOVWconst { 2530 break 2531 } 2532 c := v_1.AuxInt 2533 v.reset(OpARMADDSconst) 2534 v.AuxInt = int64(uint32(c) << uint64(d)) 2535 v.AddArg(x) 2536 return true 2537 } 2538 return false 2539 } 2540 func rewriteValueARM_OpARMADDSshiftLLreg_0(v *Value) bool { 2541 b := v.Block 2542 _ = b 2543 // match: (ADDSshiftLLreg (MOVWconst [c]) x y) 2544 // cond: 2545 // result: (ADDSconst [c] (SLL <x.Type> x y)) 2546 for { 2547 _ = v.Args[2] 2548 v_0 := v.Args[0] 2549 if v_0.Op != OpARMMOVWconst { 2550 break 2551 } 2552 c := v_0.AuxInt 2553 x := v.Args[1] 2554 y := v.Args[2] 2555 v.reset(OpARMADDSconst) 2556 v.AuxInt = c 2557 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 2558 v0.AddArg(x) 2559 v0.AddArg(y) 2560 v.AddArg(v0) 2561 return true 2562 } 2563 // match: (ADDSshiftLLreg x y (MOVWconst [c])) 2564 // cond: 2565 // result: (ADDSshiftLL x y [c]) 2566 for { 2567 _ = v.Args[2] 2568 x := v.Args[0] 2569 y := v.Args[1] 2570 v_2 := v.Args[2] 2571 if v_2.Op != OpARMMOVWconst { 2572 break 2573 } 2574 c := v_2.AuxInt 2575 v.reset(OpARMADDSshiftLL) 2576 v.AuxInt = c 2577 v.AddArg(x) 2578 v.AddArg(y) 2579 return true 2580 } 2581 return false 2582 } 2583 func rewriteValueARM_OpARMADDSshiftRA_0(v *Value) bool { 2584 b := v.Block 2585 _ = b 2586 // match: (ADDSshiftRA (MOVWconst [c]) x [d]) 2587 // cond: 2588 // result: (ADDSconst [c] (SRAconst <x.Type> x [d])) 2589 for { 2590 d := v.AuxInt 2591 _ = v.Args[1] 2592 v_0 := v.Args[0] 2593 if v_0.Op != OpARMMOVWconst { 2594 break 2595 } 2596 c := v_0.AuxInt 2597 x := v.Args[1] 2598 v.reset(OpARMADDSconst) 2599 v.AuxInt = c 2600 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 2601 v0.AuxInt = d 2602 v0.AddArg(x) 2603 v.AddArg(v0) 2604 return true 2605 } 2606 // match: (ADDSshiftRA x (MOVWconst [c]) [d]) 2607 // cond: 2608 // result: (ADDSconst x [int64(int32(c)>>uint64(d))]) 2609 for { 2610 d := v.AuxInt 2611 _ = v.Args[1] 2612 x := v.Args[0] 2613 v_1 := v.Args[1] 2614 if v_1.Op != OpARMMOVWconst { 2615 break 2616 } 2617 c := v_1.AuxInt 2618 v.reset(OpARMADDSconst) 2619 v.AuxInt = int64(int32(c) >> uint64(d)) 2620 v.AddArg(x) 2621 return true 2622 } 2623 return false 2624 } 2625 func rewriteValueARM_OpARMADDSshiftRAreg_0(v *Value) bool { 2626 b := v.Block 2627 _ = b 2628 // match: (ADDSshiftRAreg (MOVWconst [c]) x y) 2629 // cond: 2630 // result: (ADDSconst [c] (SRA <x.Type> x y)) 2631 for { 2632 _ = v.Args[2] 2633 v_0 := v.Args[0] 2634 if v_0.Op != OpARMMOVWconst { 2635 break 2636 } 2637 c := v_0.AuxInt 2638 x := v.Args[1] 2639 y := v.Args[2] 2640 v.reset(OpARMADDSconst) 2641 v.AuxInt = c 2642 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 2643 v0.AddArg(x) 2644 v0.AddArg(y) 2645 v.AddArg(v0) 2646 return true 2647 } 2648 // match: (ADDSshiftRAreg x y (MOVWconst [c])) 2649 // cond: 2650 // result: (ADDSshiftRA x y [c]) 2651 for { 2652 _ = v.Args[2] 2653 x := v.Args[0] 2654 y := v.Args[1] 2655 v_2 := v.Args[2] 2656 if v_2.Op != OpARMMOVWconst { 2657 break 2658 } 2659 c := v_2.AuxInt 2660 v.reset(OpARMADDSshiftRA) 2661 v.AuxInt = c 2662 v.AddArg(x) 2663 v.AddArg(y) 2664 return true 2665 } 2666 return false 2667 } 2668 func rewriteValueARM_OpARMADDSshiftRL_0(v *Value) bool { 2669 b := v.Block 2670 _ = b 2671 // match: (ADDSshiftRL (MOVWconst [c]) x [d]) 2672 // cond: 2673 // result: (ADDSconst [c] (SRLconst <x.Type> x [d])) 2674 for { 2675 d := v.AuxInt 2676 _ = v.Args[1] 2677 v_0 := v.Args[0] 2678 if v_0.Op != OpARMMOVWconst { 2679 break 2680 } 2681 c := v_0.AuxInt 2682 x := v.Args[1] 2683 v.reset(OpARMADDSconst) 2684 v.AuxInt = c 2685 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 2686 v0.AuxInt = d 2687 v0.AddArg(x) 2688 v.AddArg(v0) 2689 return true 2690 } 2691 // match: (ADDSshiftRL x (MOVWconst [c]) [d]) 2692 // cond: 2693 // result: (ADDSconst x [int64(uint32(c)>>uint64(d))]) 2694 for { 2695 d := v.AuxInt 2696 _ = v.Args[1] 2697 x := v.Args[0] 2698 v_1 := v.Args[1] 2699 if v_1.Op != OpARMMOVWconst { 2700 break 2701 } 2702 c := v_1.AuxInt 2703 v.reset(OpARMADDSconst) 2704 v.AuxInt = int64(uint32(c) >> uint64(d)) 2705 v.AddArg(x) 2706 return true 2707 } 2708 return false 2709 } 2710 func rewriteValueARM_OpARMADDSshiftRLreg_0(v *Value) bool { 2711 b := v.Block 2712 _ = b 2713 // match: (ADDSshiftRLreg (MOVWconst [c]) x y) 2714 // cond: 2715 // result: (ADDSconst [c] (SRL <x.Type> x y)) 2716 for { 2717 _ = v.Args[2] 2718 v_0 := v.Args[0] 2719 if v_0.Op != OpARMMOVWconst { 2720 break 2721 } 2722 c := v_0.AuxInt 2723 x := v.Args[1] 2724 y := v.Args[2] 2725 v.reset(OpARMADDSconst) 2726 v.AuxInt = c 2727 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 2728 v0.AddArg(x) 2729 v0.AddArg(y) 2730 v.AddArg(v0) 2731 return true 2732 } 2733 // match: (ADDSshiftRLreg x y (MOVWconst [c])) 2734 // cond: 2735 // result: (ADDSshiftRL x y [c]) 2736 for { 2737 _ = v.Args[2] 2738 x := v.Args[0] 2739 y := v.Args[1] 2740 v_2 := v.Args[2] 2741 if v_2.Op != OpARMMOVWconst { 2742 break 2743 } 2744 c := v_2.AuxInt 2745 v.reset(OpARMADDSshiftRL) 2746 v.AuxInt = c 2747 v.AddArg(x) 2748 v.AddArg(y) 2749 return true 2750 } 2751 return false 2752 } 2753 func rewriteValueARM_OpARMADDconst_0(v *Value) bool { 2754 // match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr)) 2755 // cond: 2756 // result: (MOVWaddr [off1+off2] {sym} ptr) 2757 for { 2758 off1 := v.AuxInt 2759 v_0 := v.Args[0] 2760 if v_0.Op != OpARMMOVWaddr { 2761 break 2762 } 2763 off2 := v_0.AuxInt 2764 sym := v_0.Aux 2765 ptr := v_0.Args[0] 2766 v.reset(OpARMMOVWaddr) 2767 v.AuxInt = off1 + off2 2768 v.Aux = sym 2769 v.AddArg(ptr) 2770 return true 2771 } 2772 // match: (ADDconst [0] x) 2773 // cond: 2774 // result: x 2775 for { 2776 if v.AuxInt != 0 { 2777 break 2778 } 2779 x := v.Args[0] 2780 v.reset(OpCopy) 2781 v.Type = x.Type 2782 v.AddArg(x) 2783 return true 2784 } 2785 // match: (ADDconst [c] x) 2786 // cond: !isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c)) 2787 // result: (SUBconst [int64(int32(-c))] x) 2788 for { 2789 c := v.AuxInt 2790 x := v.Args[0] 2791 if !(!isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c))) { 2792 break 2793 } 2794 v.reset(OpARMSUBconst) 2795 v.AuxInt = int64(int32(-c)) 2796 v.AddArg(x) 2797 return true 2798 } 2799 // match: (ADDconst [c] (MOVWconst [d])) 2800 // cond: 2801 // result: (MOVWconst [int64(int32(c+d))]) 2802 for { 2803 c := v.AuxInt 2804 v_0 := v.Args[0] 2805 if v_0.Op != OpARMMOVWconst { 2806 break 2807 } 2808 d := v_0.AuxInt 2809 v.reset(OpARMMOVWconst) 2810 v.AuxInt = int64(int32(c + d)) 2811 return true 2812 } 2813 // match: (ADDconst [c] (ADDconst [d] x)) 2814 // cond: 2815 // result: (ADDconst [int64(int32(c+d))] x) 2816 for { 2817 c := v.AuxInt 2818 v_0 := v.Args[0] 2819 if v_0.Op != OpARMADDconst { 2820 break 2821 } 2822 d := v_0.AuxInt 2823 x := v_0.Args[0] 2824 v.reset(OpARMADDconst) 2825 v.AuxInt = int64(int32(c + d)) 2826 v.AddArg(x) 2827 return true 2828 } 2829 // match: (ADDconst [c] (SUBconst [d] x)) 2830 // cond: 2831 // result: (ADDconst [int64(int32(c-d))] x) 2832 for { 2833 c := v.AuxInt 2834 v_0 := v.Args[0] 2835 if v_0.Op != OpARMSUBconst { 2836 break 2837 } 2838 d := v_0.AuxInt 2839 x := v_0.Args[0] 2840 v.reset(OpARMADDconst) 2841 v.AuxInt = int64(int32(c - d)) 2842 v.AddArg(x) 2843 return true 2844 } 2845 // match: (ADDconst [c] (RSBconst [d] x)) 2846 // cond: 2847 // result: (RSBconst [int64(int32(c+d))] x) 2848 for { 2849 c := v.AuxInt 2850 v_0 := v.Args[0] 2851 if v_0.Op != OpARMRSBconst { 2852 break 2853 } 2854 d := v_0.AuxInt 2855 x := v_0.Args[0] 2856 v.reset(OpARMRSBconst) 2857 v.AuxInt = int64(int32(c + d)) 2858 v.AddArg(x) 2859 return true 2860 } 2861 return false 2862 } 2863 func rewriteValueARM_OpARMADDshiftLL_0(v *Value) bool { 2864 b := v.Block 2865 _ = b 2866 // match: (ADDshiftLL (MOVWconst [c]) x [d]) 2867 // cond: 2868 // result: (ADDconst [c] (SLLconst <x.Type> x [d])) 2869 for { 2870 d := v.AuxInt 2871 _ = v.Args[1] 2872 v_0 := v.Args[0] 2873 if v_0.Op != OpARMMOVWconst { 2874 break 2875 } 2876 c := v_0.AuxInt 2877 x := v.Args[1] 2878 v.reset(OpARMADDconst) 2879 v.AuxInt = c 2880 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 2881 v0.AuxInt = d 2882 v0.AddArg(x) 2883 v.AddArg(v0) 2884 return true 2885 } 2886 // match: (ADDshiftLL x (MOVWconst [c]) [d]) 2887 // cond: 2888 // result: (ADDconst x [int64(uint32(c)<<uint64(d))]) 2889 for { 2890 d := v.AuxInt 2891 _ = v.Args[1] 2892 x := v.Args[0] 2893 v_1 := v.Args[1] 2894 if v_1.Op != OpARMMOVWconst { 2895 break 2896 } 2897 c := v_1.AuxInt 2898 v.reset(OpARMADDconst) 2899 v.AuxInt = int64(uint32(c) << uint64(d)) 2900 v.AddArg(x) 2901 return true 2902 } 2903 // match: (ADDshiftLL [c] (SRLconst x [32-c]) x) 2904 // cond: 2905 // result: (SRRconst [32-c] x) 2906 for { 2907 c := v.AuxInt 2908 _ = v.Args[1] 2909 v_0 := v.Args[0] 2910 if v_0.Op != OpARMSRLconst { 2911 break 2912 } 2913 if v_0.AuxInt != 32-c { 2914 break 2915 } 2916 x := v_0.Args[0] 2917 if x != v.Args[1] { 2918 break 2919 } 2920 v.reset(OpARMSRRconst) 2921 v.AuxInt = 32 - c 2922 v.AddArg(x) 2923 return true 2924 } 2925 return false 2926 } 2927 func rewriteValueARM_OpARMADDshiftLLreg_0(v *Value) bool { 2928 b := v.Block 2929 _ = b 2930 // match: (ADDshiftLLreg (MOVWconst [c]) x y) 2931 // cond: 2932 // result: (ADDconst [c] (SLL <x.Type> x y)) 2933 for { 2934 _ = v.Args[2] 2935 v_0 := v.Args[0] 2936 if v_0.Op != OpARMMOVWconst { 2937 break 2938 } 2939 c := v_0.AuxInt 2940 x := v.Args[1] 2941 y := v.Args[2] 2942 v.reset(OpARMADDconst) 2943 v.AuxInt = c 2944 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 2945 v0.AddArg(x) 2946 v0.AddArg(y) 2947 v.AddArg(v0) 2948 return true 2949 } 2950 // match: (ADDshiftLLreg x y (MOVWconst [c])) 2951 // cond: 2952 // result: (ADDshiftLL x y [c]) 2953 for { 2954 _ = v.Args[2] 2955 x := v.Args[0] 2956 y := v.Args[1] 2957 v_2 := v.Args[2] 2958 if v_2.Op != OpARMMOVWconst { 2959 break 2960 } 2961 c := v_2.AuxInt 2962 v.reset(OpARMADDshiftLL) 2963 v.AuxInt = c 2964 v.AddArg(x) 2965 v.AddArg(y) 2966 return true 2967 } 2968 return false 2969 } 2970 func rewriteValueARM_OpARMADDshiftRA_0(v *Value) bool { 2971 b := v.Block 2972 _ = b 2973 // match: (ADDshiftRA (MOVWconst [c]) x [d]) 2974 // cond: 2975 // result: (ADDconst [c] (SRAconst <x.Type> x [d])) 2976 for { 2977 d := v.AuxInt 2978 _ = v.Args[1] 2979 v_0 := v.Args[0] 2980 if v_0.Op != OpARMMOVWconst { 2981 break 2982 } 2983 c := v_0.AuxInt 2984 x := v.Args[1] 2985 v.reset(OpARMADDconst) 2986 v.AuxInt = c 2987 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 2988 v0.AuxInt = d 2989 v0.AddArg(x) 2990 v.AddArg(v0) 2991 return true 2992 } 2993 // match: (ADDshiftRA x (MOVWconst [c]) [d]) 2994 // cond: 2995 // result: (ADDconst x [int64(int32(c)>>uint64(d))]) 2996 for { 2997 d := v.AuxInt 2998 _ = v.Args[1] 2999 x := v.Args[0] 3000 v_1 := v.Args[1] 3001 if v_1.Op != OpARMMOVWconst { 3002 break 3003 } 3004 c := v_1.AuxInt 3005 v.reset(OpARMADDconst) 3006 v.AuxInt = int64(int32(c) >> uint64(d)) 3007 v.AddArg(x) 3008 return true 3009 } 3010 return false 3011 } 3012 func rewriteValueARM_OpARMADDshiftRAreg_0(v *Value) bool { 3013 b := v.Block 3014 _ = b 3015 // match: (ADDshiftRAreg (MOVWconst [c]) x y) 3016 // cond: 3017 // result: (ADDconst [c] (SRA <x.Type> x y)) 3018 for { 3019 _ = v.Args[2] 3020 v_0 := v.Args[0] 3021 if v_0.Op != OpARMMOVWconst { 3022 break 3023 } 3024 c := v_0.AuxInt 3025 x := v.Args[1] 3026 y := v.Args[2] 3027 v.reset(OpARMADDconst) 3028 v.AuxInt = c 3029 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 3030 v0.AddArg(x) 3031 v0.AddArg(y) 3032 v.AddArg(v0) 3033 return true 3034 } 3035 // match: (ADDshiftRAreg x y (MOVWconst [c])) 3036 // cond: 3037 // result: (ADDshiftRA x y [c]) 3038 for { 3039 _ = v.Args[2] 3040 x := v.Args[0] 3041 y := v.Args[1] 3042 v_2 := v.Args[2] 3043 if v_2.Op != OpARMMOVWconst { 3044 break 3045 } 3046 c := v_2.AuxInt 3047 v.reset(OpARMADDshiftRA) 3048 v.AuxInt = c 3049 v.AddArg(x) 3050 v.AddArg(y) 3051 return true 3052 } 3053 return false 3054 } 3055 func rewriteValueARM_OpARMADDshiftRL_0(v *Value) bool { 3056 b := v.Block 3057 _ = b 3058 // match: (ADDshiftRL (MOVWconst [c]) x [d]) 3059 // cond: 3060 // result: (ADDconst [c] (SRLconst <x.Type> x [d])) 3061 for { 3062 d := v.AuxInt 3063 _ = v.Args[1] 3064 v_0 := v.Args[0] 3065 if v_0.Op != OpARMMOVWconst { 3066 break 3067 } 3068 c := v_0.AuxInt 3069 x := v.Args[1] 3070 v.reset(OpARMADDconst) 3071 v.AuxInt = c 3072 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 3073 v0.AuxInt = d 3074 v0.AddArg(x) 3075 v.AddArg(v0) 3076 return true 3077 } 3078 // match: (ADDshiftRL x (MOVWconst [c]) [d]) 3079 // cond: 3080 // result: (ADDconst x [int64(uint32(c)>>uint64(d))]) 3081 for { 3082 d := v.AuxInt 3083 _ = v.Args[1] 3084 x := v.Args[0] 3085 v_1 := v.Args[1] 3086 if v_1.Op != OpARMMOVWconst { 3087 break 3088 } 3089 c := v_1.AuxInt 3090 v.reset(OpARMADDconst) 3091 v.AuxInt = int64(uint32(c) >> uint64(d)) 3092 v.AddArg(x) 3093 return true 3094 } 3095 // match: (ADDshiftRL [c] (SLLconst x [32-c]) x) 3096 // cond: 3097 // result: (SRRconst [ c] x) 3098 for { 3099 c := v.AuxInt 3100 _ = v.Args[1] 3101 v_0 := v.Args[0] 3102 if v_0.Op != OpARMSLLconst { 3103 break 3104 } 3105 if v_0.AuxInt != 32-c { 3106 break 3107 } 3108 x := v_0.Args[0] 3109 if x != v.Args[1] { 3110 break 3111 } 3112 v.reset(OpARMSRRconst) 3113 v.AuxInt = c 3114 v.AddArg(x) 3115 return true 3116 } 3117 return false 3118 } 3119 func rewriteValueARM_OpARMADDshiftRLreg_0(v *Value) bool { 3120 b := v.Block 3121 _ = b 3122 // match: (ADDshiftRLreg (MOVWconst [c]) x y) 3123 // cond: 3124 // result: (ADDconst [c] (SRL <x.Type> x y)) 3125 for { 3126 _ = v.Args[2] 3127 v_0 := v.Args[0] 3128 if v_0.Op != OpARMMOVWconst { 3129 break 3130 } 3131 c := v_0.AuxInt 3132 x := v.Args[1] 3133 y := v.Args[2] 3134 v.reset(OpARMADDconst) 3135 v.AuxInt = c 3136 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 3137 v0.AddArg(x) 3138 v0.AddArg(y) 3139 v.AddArg(v0) 3140 return true 3141 } 3142 // match: (ADDshiftRLreg x y (MOVWconst [c])) 3143 // cond: 3144 // result: (ADDshiftRL x y [c]) 3145 for { 3146 _ = v.Args[2] 3147 x := v.Args[0] 3148 y := v.Args[1] 3149 v_2 := v.Args[2] 3150 if v_2.Op != OpARMMOVWconst { 3151 break 3152 } 3153 c := v_2.AuxInt 3154 v.reset(OpARMADDshiftRL) 3155 v.AuxInt = c 3156 v.AddArg(x) 3157 v.AddArg(y) 3158 return true 3159 } 3160 return false 3161 } 3162 func rewriteValueARM_OpARMAND_0(v *Value) bool { 3163 // match: (AND x (MOVWconst [c])) 3164 // cond: 3165 // result: (ANDconst [c] x) 3166 for { 3167 _ = v.Args[1] 3168 x := v.Args[0] 3169 v_1 := v.Args[1] 3170 if v_1.Op != OpARMMOVWconst { 3171 break 3172 } 3173 c := v_1.AuxInt 3174 v.reset(OpARMANDconst) 3175 v.AuxInt = c 3176 v.AddArg(x) 3177 return true 3178 } 3179 // match: (AND (MOVWconst [c]) x) 3180 // cond: 3181 // result: (ANDconst [c] x) 3182 for { 3183 _ = v.Args[1] 3184 v_0 := v.Args[0] 3185 if v_0.Op != OpARMMOVWconst { 3186 break 3187 } 3188 c := v_0.AuxInt 3189 x := v.Args[1] 3190 v.reset(OpARMANDconst) 3191 v.AuxInt = c 3192 v.AddArg(x) 3193 return true 3194 } 3195 // match: (AND x (SLLconst [c] y)) 3196 // cond: 3197 // result: (ANDshiftLL x y [c]) 3198 for { 3199 _ = v.Args[1] 3200 x := v.Args[0] 3201 v_1 := v.Args[1] 3202 if v_1.Op != OpARMSLLconst { 3203 break 3204 } 3205 c := v_1.AuxInt 3206 y := v_1.Args[0] 3207 v.reset(OpARMANDshiftLL) 3208 v.AuxInt = c 3209 v.AddArg(x) 3210 v.AddArg(y) 3211 return true 3212 } 3213 // match: (AND (SLLconst [c] y) x) 3214 // cond: 3215 // result: (ANDshiftLL x y [c]) 3216 for { 3217 _ = v.Args[1] 3218 v_0 := v.Args[0] 3219 if v_0.Op != OpARMSLLconst { 3220 break 3221 } 3222 c := v_0.AuxInt 3223 y := v_0.Args[0] 3224 x := v.Args[1] 3225 v.reset(OpARMANDshiftLL) 3226 v.AuxInt = c 3227 v.AddArg(x) 3228 v.AddArg(y) 3229 return true 3230 } 3231 // match: (AND x (SRLconst [c] y)) 3232 // cond: 3233 // result: (ANDshiftRL x y [c]) 3234 for { 3235 _ = v.Args[1] 3236 x := v.Args[0] 3237 v_1 := v.Args[1] 3238 if v_1.Op != OpARMSRLconst { 3239 break 3240 } 3241 c := v_1.AuxInt 3242 y := v_1.Args[0] 3243 v.reset(OpARMANDshiftRL) 3244 v.AuxInt = c 3245 v.AddArg(x) 3246 v.AddArg(y) 3247 return true 3248 } 3249 // match: (AND (SRLconst [c] y) x) 3250 // cond: 3251 // result: (ANDshiftRL x y [c]) 3252 for { 3253 _ = v.Args[1] 3254 v_0 := v.Args[0] 3255 if v_0.Op != OpARMSRLconst { 3256 break 3257 } 3258 c := v_0.AuxInt 3259 y := v_0.Args[0] 3260 x := v.Args[1] 3261 v.reset(OpARMANDshiftRL) 3262 v.AuxInt = c 3263 v.AddArg(x) 3264 v.AddArg(y) 3265 return true 3266 } 3267 // match: (AND x (SRAconst [c] y)) 3268 // cond: 3269 // result: (ANDshiftRA x y [c]) 3270 for { 3271 _ = v.Args[1] 3272 x := v.Args[0] 3273 v_1 := v.Args[1] 3274 if v_1.Op != OpARMSRAconst { 3275 break 3276 } 3277 c := v_1.AuxInt 3278 y := v_1.Args[0] 3279 v.reset(OpARMANDshiftRA) 3280 v.AuxInt = c 3281 v.AddArg(x) 3282 v.AddArg(y) 3283 return true 3284 } 3285 // match: (AND (SRAconst [c] y) x) 3286 // cond: 3287 // result: (ANDshiftRA x y [c]) 3288 for { 3289 _ = v.Args[1] 3290 v_0 := v.Args[0] 3291 if v_0.Op != OpARMSRAconst { 3292 break 3293 } 3294 c := v_0.AuxInt 3295 y := v_0.Args[0] 3296 x := v.Args[1] 3297 v.reset(OpARMANDshiftRA) 3298 v.AuxInt = c 3299 v.AddArg(x) 3300 v.AddArg(y) 3301 return true 3302 } 3303 // match: (AND x (SLL y z)) 3304 // cond: 3305 // result: (ANDshiftLLreg x y z) 3306 for { 3307 _ = v.Args[1] 3308 x := v.Args[0] 3309 v_1 := v.Args[1] 3310 if v_1.Op != OpARMSLL { 3311 break 3312 } 3313 _ = v_1.Args[1] 3314 y := v_1.Args[0] 3315 z := v_1.Args[1] 3316 v.reset(OpARMANDshiftLLreg) 3317 v.AddArg(x) 3318 v.AddArg(y) 3319 v.AddArg(z) 3320 return true 3321 } 3322 // match: (AND (SLL y z) x) 3323 // cond: 3324 // result: (ANDshiftLLreg x y z) 3325 for { 3326 _ = v.Args[1] 3327 v_0 := v.Args[0] 3328 if v_0.Op != OpARMSLL { 3329 break 3330 } 3331 _ = v_0.Args[1] 3332 y := v_0.Args[0] 3333 z := v_0.Args[1] 3334 x := v.Args[1] 3335 v.reset(OpARMANDshiftLLreg) 3336 v.AddArg(x) 3337 v.AddArg(y) 3338 v.AddArg(z) 3339 return true 3340 } 3341 return false 3342 } 3343 func rewriteValueARM_OpARMAND_10(v *Value) bool { 3344 // match: (AND x (SRL y z)) 3345 // cond: 3346 // result: (ANDshiftRLreg x y z) 3347 for { 3348 _ = v.Args[1] 3349 x := v.Args[0] 3350 v_1 := v.Args[1] 3351 if v_1.Op != OpARMSRL { 3352 break 3353 } 3354 _ = v_1.Args[1] 3355 y := v_1.Args[0] 3356 z := v_1.Args[1] 3357 v.reset(OpARMANDshiftRLreg) 3358 v.AddArg(x) 3359 v.AddArg(y) 3360 v.AddArg(z) 3361 return true 3362 } 3363 // match: (AND (SRL y z) x) 3364 // cond: 3365 // result: (ANDshiftRLreg x y z) 3366 for { 3367 _ = v.Args[1] 3368 v_0 := v.Args[0] 3369 if v_0.Op != OpARMSRL { 3370 break 3371 } 3372 _ = v_0.Args[1] 3373 y := v_0.Args[0] 3374 z := v_0.Args[1] 3375 x := v.Args[1] 3376 v.reset(OpARMANDshiftRLreg) 3377 v.AddArg(x) 3378 v.AddArg(y) 3379 v.AddArg(z) 3380 return true 3381 } 3382 // match: (AND x (SRA y z)) 3383 // cond: 3384 // result: (ANDshiftRAreg x y z) 3385 for { 3386 _ = v.Args[1] 3387 x := v.Args[0] 3388 v_1 := v.Args[1] 3389 if v_1.Op != OpARMSRA { 3390 break 3391 } 3392 _ = v_1.Args[1] 3393 y := v_1.Args[0] 3394 z := v_1.Args[1] 3395 v.reset(OpARMANDshiftRAreg) 3396 v.AddArg(x) 3397 v.AddArg(y) 3398 v.AddArg(z) 3399 return true 3400 } 3401 // match: (AND (SRA y z) x) 3402 // cond: 3403 // result: (ANDshiftRAreg x y z) 3404 for { 3405 _ = v.Args[1] 3406 v_0 := v.Args[0] 3407 if v_0.Op != OpARMSRA { 3408 break 3409 } 3410 _ = v_0.Args[1] 3411 y := v_0.Args[0] 3412 z := v_0.Args[1] 3413 x := v.Args[1] 3414 v.reset(OpARMANDshiftRAreg) 3415 v.AddArg(x) 3416 v.AddArg(y) 3417 v.AddArg(z) 3418 return true 3419 } 3420 // match: (AND x x) 3421 // cond: 3422 // result: x 3423 for { 3424 _ = v.Args[1] 3425 x := v.Args[0] 3426 if x != v.Args[1] { 3427 break 3428 } 3429 v.reset(OpCopy) 3430 v.Type = x.Type 3431 v.AddArg(x) 3432 return true 3433 } 3434 // match: (AND x (MVN y)) 3435 // cond: 3436 // result: (BIC x y) 3437 for { 3438 _ = v.Args[1] 3439 x := v.Args[0] 3440 v_1 := v.Args[1] 3441 if v_1.Op != OpARMMVN { 3442 break 3443 } 3444 y := v_1.Args[0] 3445 v.reset(OpARMBIC) 3446 v.AddArg(x) 3447 v.AddArg(y) 3448 return true 3449 } 3450 // match: (AND (MVN y) x) 3451 // cond: 3452 // result: (BIC x y) 3453 for { 3454 _ = v.Args[1] 3455 v_0 := v.Args[0] 3456 if v_0.Op != OpARMMVN { 3457 break 3458 } 3459 y := v_0.Args[0] 3460 x := v.Args[1] 3461 v.reset(OpARMBIC) 3462 v.AddArg(x) 3463 v.AddArg(y) 3464 return true 3465 } 3466 // match: (AND x (MVNshiftLL y [c])) 3467 // cond: 3468 // result: (BICshiftLL x y [c]) 3469 for { 3470 _ = v.Args[1] 3471 x := v.Args[0] 3472 v_1 := v.Args[1] 3473 if v_1.Op != OpARMMVNshiftLL { 3474 break 3475 } 3476 c := v_1.AuxInt 3477 y := v_1.Args[0] 3478 v.reset(OpARMBICshiftLL) 3479 v.AuxInt = c 3480 v.AddArg(x) 3481 v.AddArg(y) 3482 return true 3483 } 3484 // match: (AND (MVNshiftLL y [c]) x) 3485 // cond: 3486 // result: (BICshiftLL x y [c]) 3487 for { 3488 _ = v.Args[1] 3489 v_0 := v.Args[0] 3490 if v_0.Op != OpARMMVNshiftLL { 3491 break 3492 } 3493 c := v_0.AuxInt 3494 y := v_0.Args[0] 3495 x := v.Args[1] 3496 v.reset(OpARMBICshiftLL) 3497 v.AuxInt = c 3498 v.AddArg(x) 3499 v.AddArg(y) 3500 return true 3501 } 3502 // match: (AND x (MVNshiftRL y [c])) 3503 // cond: 3504 // result: (BICshiftRL x y [c]) 3505 for { 3506 _ = v.Args[1] 3507 x := v.Args[0] 3508 v_1 := v.Args[1] 3509 if v_1.Op != OpARMMVNshiftRL { 3510 break 3511 } 3512 c := v_1.AuxInt 3513 y := v_1.Args[0] 3514 v.reset(OpARMBICshiftRL) 3515 v.AuxInt = c 3516 v.AddArg(x) 3517 v.AddArg(y) 3518 return true 3519 } 3520 return false 3521 } 3522 func rewriteValueARM_OpARMAND_20(v *Value) bool { 3523 // match: (AND (MVNshiftRL y [c]) x) 3524 // cond: 3525 // result: (BICshiftRL x y [c]) 3526 for { 3527 _ = v.Args[1] 3528 v_0 := v.Args[0] 3529 if v_0.Op != OpARMMVNshiftRL { 3530 break 3531 } 3532 c := v_0.AuxInt 3533 y := v_0.Args[0] 3534 x := v.Args[1] 3535 v.reset(OpARMBICshiftRL) 3536 v.AuxInt = c 3537 v.AddArg(x) 3538 v.AddArg(y) 3539 return true 3540 } 3541 // match: (AND x (MVNshiftRA y [c])) 3542 // cond: 3543 // result: (BICshiftRA x y [c]) 3544 for { 3545 _ = v.Args[1] 3546 x := v.Args[0] 3547 v_1 := v.Args[1] 3548 if v_1.Op != OpARMMVNshiftRA { 3549 break 3550 } 3551 c := v_1.AuxInt 3552 y := v_1.Args[0] 3553 v.reset(OpARMBICshiftRA) 3554 v.AuxInt = c 3555 v.AddArg(x) 3556 v.AddArg(y) 3557 return true 3558 } 3559 // match: (AND (MVNshiftRA y [c]) x) 3560 // cond: 3561 // result: (BICshiftRA x y [c]) 3562 for { 3563 _ = v.Args[1] 3564 v_0 := v.Args[0] 3565 if v_0.Op != OpARMMVNshiftRA { 3566 break 3567 } 3568 c := v_0.AuxInt 3569 y := v_0.Args[0] 3570 x := v.Args[1] 3571 v.reset(OpARMBICshiftRA) 3572 v.AuxInt = c 3573 v.AddArg(x) 3574 v.AddArg(y) 3575 return true 3576 } 3577 return false 3578 } 3579 func rewriteValueARM_OpARMANDconst_0(v *Value) bool { 3580 // match: (ANDconst [0] _) 3581 // cond: 3582 // result: (MOVWconst [0]) 3583 for { 3584 if v.AuxInt != 0 { 3585 break 3586 } 3587 v.reset(OpARMMOVWconst) 3588 v.AuxInt = 0 3589 return true 3590 } 3591 // match: (ANDconst [c] x) 3592 // cond: int32(c)==-1 3593 // result: x 3594 for { 3595 c := v.AuxInt 3596 x := v.Args[0] 3597 if !(int32(c) == -1) { 3598 break 3599 } 3600 v.reset(OpCopy) 3601 v.Type = x.Type 3602 v.AddArg(x) 3603 return true 3604 } 3605 // match: (ANDconst [c] x) 3606 // cond: !isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c)) 3607 // result: (BICconst [int64(^uint32(c))] x) 3608 for { 3609 c := v.AuxInt 3610 x := v.Args[0] 3611 if !(!isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c))) { 3612 break 3613 } 3614 v.reset(OpARMBICconst) 3615 v.AuxInt = int64(^uint32(c)) 3616 v.AddArg(x) 3617 return true 3618 } 3619 // match: (ANDconst [c] (MOVWconst [d])) 3620 // cond: 3621 // result: (MOVWconst [c&d]) 3622 for { 3623 c := v.AuxInt 3624 v_0 := v.Args[0] 3625 if v_0.Op != OpARMMOVWconst { 3626 break 3627 } 3628 d := v_0.AuxInt 3629 v.reset(OpARMMOVWconst) 3630 v.AuxInt = c & d 3631 return true 3632 } 3633 // match: (ANDconst [c] (ANDconst [d] x)) 3634 // cond: 3635 // result: (ANDconst [c&d] x) 3636 for { 3637 c := v.AuxInt 3638 v_0 := v.Args[0] 3639 if v_0.Op != OpARMANDconst { 3640 break 3641 } 3642 d := v_0.AuxInt 3643 x := v_0.Args[0] 3644 v.reset(OpARMANDconst) 3645 v.AuxInt = c & d 3646 v.AddArg(x) 3647 return true 3648 } 3649 return false 3650 } 3651 func rewriteValueARM_OpARMANDshiftLL_0(v *Value) bool { 3652 b := v.Block 3653 _ = b 3654 // match: (ANDshiftLL (MOVWconst [c]) x [d]) 3655 // cond: 3656 // result: (ANDconst [c] (SLLconst <x.Type> x [d])) 3657 for { 3658 d := v.AuxInt 3659 _ = v.Args[1] 3660 v_0 := v.Args[0] 3661 if v_0.Op != OpARMMOVWconst { 3662 break 3663 } 3664 c := v_0.AuxInt 3665 x := v.Args[1] 3666 v.reset(OpARMANDconst) 3667 v.AuxInt = c 3668 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 3669 v0.AuxInt = d 3670 v0.AddArg(x) 3671 v.AddArg(v0) 3672 return true 3673 } 3674 // match: (ANDshiftLL x (MOVWconst [c]) [d]) 3675 // cond: 3676 // result: (ANDconst x [int64(uint32(c)<<uint64(d))]) 3677 for { 3678 d := v.AuxInt 3679 _ = v.Args[1] 3680 x := v.Args[0] 3681 v_1 := v.Args[1] 3682 if v_1.Op != OpARMMOVWconst { 3683 break 3684 } 3685 c := v_1.AuxInt 3686 v.reset(OpARMANDconst) 3687 v.AuxInt = int64(uint32(c) << uint64(d)) 3688 v.AddArg(x) 3689 return true 3690 } 3691 // match: (ANDshiftLL x y:(SLLconst x [c]) [d]) 3692 // cond: c==d 3693 // result: y 3694 for { 3695 d := v.AuxInt 3696 _ = v.Args[1] 3697 x := v.Args[0] 3698 y := v.Args[1] 3699 if y.Op != OpARMSLLconst { 3700 break 3701 } 3702 c := y.AuxInt 3703 if x != y.Args[0] { 3704 break 3705 } 3706 if !(c == d) { 3707 break 3708 } 3709 v.reset(OpCopy) 3710 v.Type = y.Type 3711 v.AddArg(y) 3712 return true 3713 } 3714 return false 3715 } 3716 func rewriteValueARM_OpARMANDshiftLLreg_0(v *Value) bool { 3717 b := v.Block 3718 _ = b 3719 // match: (ANDshiftLLreg (MOVWconst [c]) x y) 3720 // cond: 3721 // result: (ANDconst [c] (SLL <x.Type> x y)) 3722 for { 3723 _ = v.Args[2] 3724 v_0 := v.Args[0] 3725 if v_0.Op != OpARMMOVWconst { 3726 break 3727 } 3728 c := v_0.AuxInt 3729 x := v.Args[1] 3730 y := v.Args[2] 3731 v.reset(OpARMANDconst) 3732 v.AuxInt = c 3733 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 3734 v0.AddArg(x) 3735 v0.AddArg(y) 3736 v.AddArg(v0) 3737 return true 3738 } 3739 // match: (ANDshiftLLreg x y (MOVWconst [c])) 3740 // cond: 3741 // result: (ANDshiftLL x y [c]) 3742 for { 3743 _ = v.Args[2] 3744 x := v.Args[0] 3745 y := v.Args[1] 3746 v_2 := v.Args[2] 3747 if v_2.Op != OpARMMOVWconst { 3748 break 3749 } 3750 c := v_2.AuxInt 3751 v.reset(OpARMANDshiftLL) 3752 v.AuxInt = c 3753 v.AddArg(x) 3754 v.AddArg(y) 3755 return true 3756 } 3757 return false 3758 } 3759 func rewriteValueARM_OpARMANDshiftRA_0(v *Value) bool { 3760 b := v.Block 3761 _ = b 3762 // match: (ANDshiftRA (MOVWconst [c]) x [d]) 3763 // cond: 3764 // result: (ANDconst [c] (SRAconst <x.Type> x [d])) 3765 for { 3766 d := v.AuxInt 3767 _ = v.Args[1] 3768 v_0 := v.Args[0] 3769 if v_0.Op != OpARMMOVWconst { 3770 break 3771 } 3772 c := v_0.AuxInt 3773 x := v.Args[1] 3774 v.reset(OpARMANDconst) 3775 v.AuxInt = c 3776 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 3777 v0.AuxInt = d 3778 v0.AddArg(x) 3779 v.AddArg(v0) 3780 return true 3781 } 3782 // match: (ANDshiftRA x (MOVWconst [c]) [d]) 3783 // cond: 3784 // result: (ANDconst x [int64(int32(c)>>uint64(d))]) 3785 for { 3786 d := v.AuxInt 3787 _ = v.Args[1] 3788 x := v.Args[0] 3789 v_1 := v.Args[1] 3790 if v_1.Op != OpARMMOVWconst { 3791 break 3792 } 3793 c := v_1.AuxInt 3794 v.reset(OpARMANDconst) 3795 v.AuxInt = int64(int32(c) >> uint64(d)) 3796 v.AddArg(x) 3797 return true 3798 } 3799 // match: (ANDshiftRA x y:(SRAconst x [c]) [d]) 3800 // cond: c==d 3801 // result: y 3802 for { 3803 d := v.AuxInt 3804 _ = v.Args[1] 3805 x := v.Args[0] 3806 y := v.Args[1] 3807 if y.Op != OpARMSRAconst { 3808 break 3809 } 3810 c := y.AuxInt 3811 if x != y.Args[0] { 3812 break 3813 } 3814 if !(c == d) { 3815 break 3816 } 3817 v.reset(OpCopy) 3818 v.Type = y.Type 3819 v.AddArg(y) 3820 return true 3821 } 3822 return false 3823 } 3824 func rewriteValueARM_OpARMANDshiftRAreg_0(v *Value) bool { 3825 b := v.Block 3826 _ = b 3827 // match: (ANDshiftRAreg (MOVWconst [c]) x y) 3828 // cond: 3829 // result: (ANDconst [c] (SRA <x.Type> x y)) 3830 for { 3831 _ = v.Args[2] 3832 v_0 := v.Args[0] 3833 if v_0.Op != OpARMMOVWconst { 3834 break 3835 } 3836 c := v_0.AuxInt 3837 x := v.Args[1] 3838 y := v.Args[2] 3839 v.reset(OpARMANDconst) 3840 v.AuxInt = c 3841 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 3842 v0.AddArg(x) 3843 v0.AddArg(y) 3844 v.AddArg(v0) 3845 return true 3846 } 3847 // match: (ANDshiftRAreg x y (MOVWconst [c])) 3848 // cond: 3849 // result: (ANDshiftRA x y [c]) 3850 for { 3851 _ = v.Args[2] 3852 x := v.Args[0] 3853 y := v.Args[1] 3854 v_2 := v.Args[2] 3855 if v_2.Op != OpARMMOVWconst { 3856 break 3857 } 3858 c := v_2.AuxInt 3859 v.reset(OpARMANDshiftRA) 3860 v.AuxInt = c 3861 v.AddArg(x) 3862 v.AddArg(y) 3863 return true 3864 } 3865 return false 3866 } 3867 func rewriteValueARM_OpARMANDshiftRL_0(v *Value) bool { 3868 b := v.Block 3869 _ = b 3870 // match: (ANDshiftRL (MOVWconst [c]) x [d]) 3871 // cond: 3872 // result: (ANDconst [c] (SRLconst <x.Type> x [d])) 3873 for { 3874 d := v.AuxInt 3875 _ = v.Args[1] 3876 v_0 := v.Args[0] 3877 if v_0.Op != OpARMMOVWconst { 3878 break 3879 } 3880 c := v_0.AuxInt 3881 x := v.Args[1] 3882 v.reset(OpARMANDconst) 3883 v.AuxInt = c 3884 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 3885 v0.AuxInt = d 3886 v0.AddArg(x) 3887 v.AddArg(v0) 3888 return true 3889 } 3890 // match: (ANDshiftRL x (MOVWconst [c]) [d]) 3891 // cond: 3892 // result: (ANDconst x [int64(uint32(c)>>uint64(d))]) 3893 for { 3894 d := v.AuxInt 3895 _ = v.Args[1] 3896 x := v.Args[0] 3897 v_1 := v.Args[1] 3898 if v_1.Op != OpARMMOVWconst { 3899 break 3900 } 3901 c := v_1.AuxInt 3902 v.reset(OpARMANDconst) 3903 v.AuxInt = int64(uint32(c) >> uint64(d)) 3904 v.AddArg(x) 3905 return true 3906 } 3907 // match: (ANDshiftRL x y:(SRLconst x [c]) [d]) 3908 // cond: c==d 3909 // result: y 3910 for { 3911 d := v.AuxInt 3912 _ = v.Args[1] 3913 x := v.Args[0] 3914 y := v.Args[1] 3915 if y.Op != OpARMSRLconst { 3916 break 3917 } 3918 c := y.AuxInt 3919 if x != y.Args[0] { 3920 break 3921 } 3922 if !(c == d) { 3923 break 3924 } 3925 v.reset(OpCopy) 3926 v.Type = y.Type 3927 v.AddArg(y) 3928 return true 3929 } 3930 return false 3931 } 3932 func rewriteValueARM_OpARMANDshiftRLreg_0(v *Value) bool { 3933 b := v.Block 3934 _ = b 3935 // match: (ANDshiftRLreg (MOVWconst [c]) x y) 3936 // cond: 3937 // result: (ANDconst [c] (SRL <x.Type> x y)) 3938 for { 3939 _ = v.Args[2] 3940 v_0 := v.Args[0] 3941 if v_0.Op != OpARMMOVWconst { 3942 break 3943 } 3944 c := v_0.AuxInt 3945 x := v.Args[1] 3946 y := v.Args[2] 3947 v.reset(OpARMANDconst) 3948 v.AuxInt = c 3949 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 3950 v0.AddArg(x) 3951 v0.AddArg(y) 3952 v.AddArg(v0) 3953 return true 3954 } 3955 // match: (ANDshiftRLreg x y (MOVWconst [c])) 3956 // cond: 3957 // result: (ANDshiftRL x y [c]) 3958 for { 3959 _ = v.Args[2] 3960 x := v.Args[0] 3961 y := v.Args[1] 3962 v_2 := v.Args[2] 3963 if v_2.Op != OpARMMOVWconst { 3964 break 3965 } 3966 c := v_2.AuxInt 3967 v.reset(OpARMANDshiftRL) 3968 v.AuxInt = c 3969 v.AddArg(x) 3970 v.AddArg(y) 3971 return true 3972 } 3973 return false 3974 } 3975 func rewriteValueARM_OpARMBFX_0(v *Value) bool { 3976 // match: (BFX [c] (MOVWconst [d])) 3977 // cond: 3978 // result: (MOVWconst [int64(int32(d)<<(32-uint32(c&0xff)-uint32(c>>8))>>(32-uint32(c>>8)))]) 3979 for { 3980 c := v.AuxInt 3981 v_0 := v.Args[0] 3982 if v_0.Op != OpARMMOVWconst { 3983 break 3984 } 3985 d := v_0.AuxInt 3986 v.reset(OpARMMOVWconst) 3987 v.AuxInt = int64(int32(d) << (32 - uint32(c&0xff) - uint32(c>>8)) >> (32 - uint32(c>>8))) 3988 return true 3989 } 3990 return false 3991 } 3992 func rewriteValueARM_OpARMBFXU_0(v *Value) bool { 3993 // match: (BFXU [c] (MOVWconst [d])) 3994 // cond: 3995 // result: (MOVWconst [int64(uint32(d)<<(32-uint32(c&0xff)-uint32(c>>8))>>(32-uint32(c>>8)))]) 3996 for { 3997 c := v.AuxInt 3998 v_0 := v.Args[0] 3999 if v_0.Op != OpARMMOVWconst { 4000 break 4001 } 4002 d := v_0.AuxInt 4003 v.reset(OpARMMOVWconst) 4004 v.AuxInt = int64(uint32(d) << (32 - uint32(c&0xff) - uint32(c>>8)) >> (32 - uint32(c>>8))) 4005 return true 4006 } 4007 return false 4008 } 4009 func rewriteValueARM_OpARMBIC_0(v *Value) bool { 4010 // match: (BIC x (MOVWconst [c])) 4011 // cond: 4012 // result: (BICconst [c] x) 4013 for { 4014 _ = v.Args[1] 4015 x := v.Args[0] 4016 v_1 := v.Args[1] 4017 if v_1.Op != OpARMMOVWconst { 4018 break 4019 } 4020 c := v_1.AuxInt 4021 v.reset(OpARMBICconst) 4022 v.AuxInt = c 4023 v.AddArg(x) 4024 return true 4025 } 4026 // match: (BIC x (SLLconst [c] y)) 4027 // cond: 4028 // result: (BICshiftLL x y [c]) 4029 for { 4030 _ = v.Args[1] 4031 x := v.Args[0] 4032 v_1 := v.Args[1] 4033 if v_1.Op != OpARMSLLconst { 4034 break 4035 } 4036 c := v_1.AuxInt 4037 y := v_1.Args[0] 4038 v.reset(OpARMBICshiftLL) 4039 v.AuxInt = c 4040 v.AddArg(x) 4041 v.AddArg(y) 4042 return true 4043 } 4044 // match: (BIC x (SRLconst [c] y)) 4045 // cond: 4046 // result: (BICshiftRL x y [c]) 4047 for { 4048 _ = v.Args[1] 4049 x := v.Args[0] 4050 v_1 := v.Args[1] 4051 if v_1.Op != OpARMSRLconst { 4052 break 4053 } 4054 c := v_1.AuxInt 4055 y := v_1.Args[0] 4056 v.reset(OpARMBICshiftRL) 4057 v.AuxInt = c 4058 v.AddArg(x) 4059 v.AddArg(y) 4060 return true 4061 } 4062 // match: (BIC x (SRAconst [c] y)) 4063 // cond: 4064 // result: (BICshiftRA x y [c]) 4065 for { 4066 _ = v.Args[1] 4067 x := v.Args[0] 4068 v_1 := v.Args[1] 4069 if v_1.Op != OpARMSRAconst { 4070 break 4071 } 4072 c := v_1.AuxInt 4073 y := v_1.Args[0] 4074 v.reset(OpARMBICshiftRA) 4075 v.AuxInt = c 4076 v.AddArg(x) 4077 v.AddArg(y) 4078 return true 4079 } 4080 // match: (BIC x (SLL y z)) 4081 // cond: 4082 // result: (BICshiftLLreg x y z) 4083 for { 4084 _ = v.Args[1] 4085 x := v.Args[0] 4086 v_1 := v.Args[1] 4087 if v_1.Op != OpARMSLL { 4088 break 4089 } 4090 _ = v_1.Args[1] 4091 y := v_1.Args[0] 4092 z := v_1.Args[1] 4093 v.reset(OpARMBICshiftLLreg) 4094 v.AddArg(x) 4095 v.AddArg(y) 4096 v.AddArg(z) 4097 return true 4098 } 4099 // match: (BIC x (SRL y z)) 4100 // cond: 4101 // result: (BICshiftRLreg x y z) 4102 for { 4103 _ = v.Args[1] 4104 x := v.Args[0] 4105 v_1 := v.Args[1] 4106 if v_1.Op != OpARMSRL { 4107 break 4108 } 4109 _ = v_1.Args[1] 4110 y := v_1.Args[0] 4111 z := v_1.Args[1] 4112 v.reset(OpARMBICshiftRLreg) 4113 v.AddArg(x) 4114 v.AddArg(y) 4115 v.AddArg(z) 4116 return true 4117 } 4118 // match: (BIC x (SRA y z)) 4119 // cond: 4120 // result: (BICshiftRAreg x y z) 4121 for { 4122 _ = v.Args[1] 4123 x := v.Args[0] 4124 v_1 := v.Args[1] 4125 if v_1.Op != OpARMSRA { 4126 break 4127 } 4128 _ = v_1.Args[1] 4129 y := v_1.Args[0] 4130 z := v_1.Args[1] 4131 v.reset(OpARMBICshiftRAreg) 4132 v.AddArg(x) 4133 v.AddArg(y) 4134 v.AddArg(z) 4135 return true 4136 } 4137 // match: (BIC x x) 4138 // cond: 4139 // result: (MOVWconst [0]) 4140 for { 4141 _ = v.Args[1] 4142 x := v.Args[0] 4143 if x != v.Args[1] { 4144 break 4145 } 4146 v.reset(OpARMMOVWconst) 4147 v.AuxInt = 0 4148 return true 4149 } 4150 return false 4151 } 4152 func rewriteValueARM_OpARMBICconst_0(v *Value) bool { 4153 // match: (BICconst [0] x) 4154 // cond: 4155 // result: x 4156 for { 4157 if v.AuxInt != 0 { 4158 break 4159 } 4160 x := v.Args[0] 4161 v.reset(OpCopy) 4162 v.Type = x.Type 4163 v.AddArg(x) 4164 return true 4165 } 4166 // match: (BICconst [c] _) 4167 // cond: int32(c)==-1 4168 // result: (MOVWconst [0]) 4169 for { 4170 c := v.AuxInt 4171 if !(int32(c) == -1) { 4172 break 4173 } 4174 v.reset(OpARMMOVWconst) 4175 v.AuxInt = 0 4176 return true 4177 } 4178 // match: (BICconst [c] x) 4179 // cond: !isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c)) 4180 // result: (ANDconst [int64(^uint32(c))] x) 4181 for { 4182 c := v.AuxInt 4183 x := v.Args[0] 4184 if !(!isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c))) { 4185 break 4186 } 4187 v.reset(OpARMANDconst) 4188 v.AuxInt = int64(^uint32(c)) 4189 v.AddArg(x) 4190 return true 4191 } 4192 // match: (BICconst [c] (MOVWconst [d])) 4193 // cond: 4194 // result: (MOVWconst [d&^c]) 4195 for { 4196 c := v.AuxInt 4197 v_0 := v.Args[0] 4198 if v_0.Op != OpARMMOVWconst { 4199 break 4200 } 4201 d := v_0.AuxInt 4202 v.reset(OpARMMOVWconst) 4203 v.AuxInt = d &^ c 4204 return true 4205 } 4206 // match: (BICconst [c] (BICconst [d] x)) 4207 // cond: 4208 // result: (BICconst [int64(int32(c|d))] x) 4209 for { 4210 c := v.AuxInt 4211 v_0 := v.Args[0] 4212 if v_0.Op != OpARMBICconst { 4213 break 4214 } 4215 d := v_0.AuxInt 4216 x := v_0.Args[0] 4217 v.reset(OpARMBICconst) 4218 v.AuxInt = int64(int32(c | d)) 4219 v.AddArg(x) 4220 return true 4221 } 4222 return false 4223 } 4224 func rewriteValueARM_OpARMBICshiftLL_0(v *Value) bool { 4225 // match: (BICshiftLL x (MOVWconst [c]) [d]) 4226 // cond: 4227 // result: (BICconst x [int64(uint32(c)<<uint64(d))]) 4228 for { 4229 d := v.AuxInt 4230 _ = v.Args[1] 4231 x := v.Args[0] 4232 v_1 := v.Args[1] 4233 if v_1.Op != OpARMMOVWconst { 4234 break 4235 } 4236 c := v_1.AuxInt 4237 v.reset(OpARMBICconst) 4238 v.AuxInt = int64(uint32(c) << uint64(d)) 4239 v.AddArg(x) 4240 return true 4241 } 4242 // match: (BICshiftLL x (SLLconst x [c]) [d]) 4243 // cond: c==d 4244 // result: (MOVWconst [0]) 4245 for { 4246 d := v.AuxInt 4247 _ = v.Args[1] 4248 x := v.Args[0] 4249 v_1 := v.Args[1] 4250 if v_1.Op != OpARMSLLconst { 4251 break 4252 } 4253 c := v_1.AuxInt 4254 if x != v_1.Args[0] { 4255 break 4256 } 4257 if !(c == d) { 4258 break 4259 } 4260 v.reset(OpARMMOVWconst) 4261 v.AuxInt = 0 4262 return true 4263 } 4264 return false 4265 } 4266 func rewriteValueARM_OpARMBICshiftLLreg_0(v *Value) bool { 4267 // match: (BICshiftLLreg x y (MOVWconst [c])) 4268 // cond: 4269 // result: (BICshiftLL x y [c]) 4270 for { 4271 _ = v.Args[2] 4272 x := v.Args[0] 4273 y := v.Args[1] 4274 v_2 := v.Args[2] 4275 if v_2.Op != OpARMMOVWconst { 4276 break 4277 } 4278 c := v_2.AuxInt 4279 v.reset(OpARMBICshiftLL) 4280 v.AuxInt = c 4281 v.AddArg(x) 4282 v.AddArg(y) 4283 return true 4284 } 4285 return false 4286 } 4287 func rewriteValueARM_OpARMBICshiftRA_0(v *Value) bool { 4288 // match: (BICshiftRA x (MOVWconst [c]) [d]) 4289 // cond: 4290 // result: (BICconst x [int64(int32(c)>>uint64(d))]) 4291 for { 4292 d := v.AuxInt 4293 _ = v.Args[1] 4294 x := v.Args[0] 4295 v_1 := v.Args[1] 4296 if v_1.Op != OpARMMOVWconst { 4297 break 4298 } 4299 c := v_1.AuxInt 4300 v.reset(OpARMBICconst) 4301 v.AuxInt = int64(int32(c) >> uint64(d)) 4302 v.AddArg(x) 4303 return true 4304 } 4305 // match: (BICshiftRA x (SRAconst x [c]) [d]) 4306 // cond: c==d 4307 // result: (MOVWconst [0]) 4308 for { 4309 d := v.AuxInt 4310 _ = v.Args[1] 4311 x := v.Args[0] 4312 v_1 := v.Args[1] 4313 if v_1.Op != OpARMSRAconst { 4314 break 4315 } 4316 c := v_1.AuxInt 4317 if x != v_1.Args[0] { 4318 break 4319 } 4320 if !(c == d) { 4321 break 4322 } 4323 v.reset(OpARMMOVWconst) 4324 v.AuxInt = 0 4325 return true 4326 } 4327 return false 4328 } 4329 func rewriteValueARM_OpARMBICshiftRAreg_0(v *Value) bool { 4330 // match: (BICshiftRAreg x y (MOVWconst [c])) 4331 // cond: 4332 // result: (BICshiftRA x y [c]) 4333 for { 4334 _ = v.Args[2] 4335 x := v.Args[0] 4336 y := v.Args[1] 4337 v_2 := v.Args[2] 4338 if v_2.Op != OpARMMOVWconst { 4339 break 4340 } 4341 c := v_2.AuxInt 4342 v.reset(OpARMBICshiftRA) 4343 v.AuxInt = c 4344 v.AddArg(x) 4345 v.AddArg(y) 4346 return true 4347 } 4348 return false 4349 } 4350 func rewriteValueARM_OpARMBICshiftRL_0(v *Value) bool { 4351 // match: (BICshiftRL x (MOVWconst [c]) [d]) 4352 // cond: 4353 // result: (BICconst x [int64(uint32(c)>>uint64(d))]) 4354 for { 4355 d := v.AuxInt 4356 _ = v.Args[1] 4357 x := v.Args[0] 4358 v_1 := v.Args[1] 4359 if v_1.Op != OpARMMOVWconst { 4360 break 4361 } 4362 c := v_1.AuxInt 4363 v.reset(OpARMBICconst) 4364 v.AuxInt = int64(uint32(c) >> uint64(d)) 4365 v.AddArg(x) 4366 return true 4367 } 4368 // match: (BICshiftRL x (SRLconst x [c]) [d]) 4369 // cond: c==d 4370 // result: (MOVWconst [0]) 4371 for { 4372 d := v.AuxInt 4373 _ = v.Args[1] 4374 x := v.Args[0] 4375 v_1 := v.Args[1] 4376 if v_1.Op != OpARMSRLconst { 4377 break 4378 } 4379 c := v_1.AuxInt 4380 if x != v_1.Args[0] { 4381 break 4382 } 4383 if !(c == d) { 4384 break 4385 } 4386 v.reset(OpARMMOVWconst) 4387 v.AuxInt = 0 4388 return true 4389 } 4390 return false 4391 } 4392 func rewriteValueARM_OpARMBICshiftRLreg_0(v *Value) bool { 4393 // match: (BICshiftRLreg x y (MOVWconst [c])) 4394 // cond: 4395 // result: (BICshiftRL x y [c]) 4396 for { 4397 _ = v.Args[2] 4398 x := v.Args[0] 4399 y := v.Args[1] 4400 v_2 := v.Args[2] 4401 if v_2.Op != OpARMMOVWconst { 4402 break 4403 } 4404 c := v_2.AuxInt 4405 v.reset(OpARMBICshiftRL) 4406 v.AuxInt = c 4407 v.AddArg(x) 4408 v.AddArg(y) 4409 return true 4410 } 4411 return false 4412 } 4413 func rewriteValueARM_OpARMCMOVWHSconst_0(v *Value) bool { 4414 // match: (CMOVWHSconst _ (FlagEQ) [c]) 4415 // cond: 4416 // result: (MOVWconst [c]) 4417 for { 4418 c := v.AuxInt 4419 _ = v.Args[1] 4420 v_1 := v.Args[1] 4421 if v_1.Op != OpARMFlagEQ { 4422 break 4423 } 4424 v.reset(OpARMMOVWconst) 4425 v.AuxInt = c 4426 return true 4427 } 4428 // match: (CMOVWHSconst x (FlagLT_ULT)) 4429 // cond: 4430 // result: x 4431 for { 4432 _ = v.Args[1] 4433 x := v.Args[0] 4434 v_1 := v.Args[1] 4435 if v_1.Op != OpARMFlagLT_ULT { 4436 break 4437 } 4438 v.reset(OpCopy) 4439 v.Type = x.Type 4440 v.AddArg(x) 4441 return true 4442 } 4443 // match: (CMOVWHSconst _ (FlagLT_UGT) [c]) 4444 // cond: 4445 // result: (MOVWconst [c]) 4446 for { 4447 c := v.AuxInt 4448 _ = v.Args[1] 4449 v_1 := v.Args[1] 4450 if v_1.Op != OpARMFlagLT_UGT { 4451 break 4452 } 4453 v.reset(OpARMMOVWconst) 4454 v.AuxInt = c 4455 return true 4456 } 4457 // match: (CMOVWHSconst x (FlagGT_ULT)) 4458 // cond: 4459 // result: x 4460 for { 4461 _ = v.Args[1] 4462 x := v.Args[0] 4463 v_1 := v.Args[1] 4464 if v_1.Op != OpARMFlagGT_ULT { 4465 break 4466 } 4467 v.reset(OpCopy) 4468 v.Type = x.Type 4469 v.AddArg(x) 4470 return true 4471 } 4472 // match: (CMOVWHSconst _ (FlagGT_UGT) [c]) 4473 // cond: 4474 // result: (MOVWconst [c]) 4475 for { 4476 c := v.AuxInt 4477 _ = v.Args[1] 4478 v_1 := v.Args[1] 4479 if v_1.Op != OpARMFlagGT_UGT { 4480 break 4481 } 4482 v.reset(OpARMMOVWconst) 4483 v.AuxInt = c 4484 return true 4485 } 4486 // match: (CMOVWHSconst x (InvertFlags flags) [c]) 4487 // cond: 4488 // result: (CMOVWLSconst x flags [c]) 4489 for { 4490 c := v.AuxInt 4491 _ = v.Args[1] 4492 x := v.Args[0] 4493 v_1 := v.Args[1] 4494 if v_1.Op != OpARMInvertFlags { 4495 break 4496 } 4497 flags := v_1.Args[0] 4498 v.reset(OpARMCMOVWLSconst) 4499 v.AuxInt = c 4500 v.AddArg(x) 4501 v.AddArg(flags) 4502 return true 4503 } 4504 return false 4505 } 4506 func rewriteValueARM_OpARMCMOVWLSconst_0(v *Value) bool { 4507 // match: (CMOVWLSconst _ (FlagEQ) [c]) 4508 // cond: 4509 // result: (MOVWconst [c]) 4510 for { 4511 c := v.AuxInt 4512 _ = v.Args[1] 4513 v_1 := v.Args[1] 4514 if v_1.Op != OpARMFlagEQ { 4515 break 4516 } 4517 v.reset(OpARMMOVWconst) 4518 v.AuxInt = c 4519 return true 4520 } 4521 // match: (CMOVWLSconst _ (FlagLT_ULT) [c]) 4522 // cond: 4523 // result: (MOVWconst [c]) 4524 for { 4525 c := v.AuxInt 4526 _ = v.Args[1] 4527 v_1 := v.Args[1] 4528 if v_1.Op != OpARMFlagLT_ULT { 4529 break 4530 } 4531 v.reset(OpARMMOVWconst) 4532 v.AuxInt = c 4533 return true 4534 } 4535 // match: (CMOVWLSconst x (FlagLT_UGT)) 4536 // cond: 4537 // result: x 4538 for { 4539 _ = v.Args[1] 4540 x := v.Args[0] 4541 v_1 := v.Args[1] 4542 if v_1.Op != OpARMFlagLT_UGT { 4543 break 4544 } 4545 v.reset(OpCopy) 4546 v.Type = x.Type 4547 v.AddArg(x) 4548 return true 4549 } 4550 // match: (CMOVWLSconst _ (FlagGT_ULT) [c]) 4551 // cond: 4552 // result: (MOVWconst [c]) 4553 for { 4554 c := v.AuxInt 4555 _ = v.Args[1] 4556 v_1 := v.Args[1] 4557 if v_1.Op != OpARMFlagGT_ULT { 4558 break 4559 } 4560 v.reset(OpARMMOVWconst) 4561 v.AuxInt = c 4562 return true 4563 } 4564 // match: (CMOVWLSconst x (FlagGT_UGT)) 4565 // cond: 4566 // result: x 4567 for { 4568 _ = v.Args[1] 4569 x := v.Args[0] 4570 v_1 := v.Args[1] 4571 if v_1.Op != OpARMFlagGT_UGT { 4572 break 4573 } 4574 v.reset(OpCopy) 4575 v.Type = x.Type 4576 v.AddArg(x) 4577 return true 4578 } 4579 // match: (CMOVWLSconst x (InvertFlags flags) [c]) 4580 // cond: 4581 // result: (CMOVWHSconst x flags [c]) 4582 for { 4583 c := v.AuxInt 4584 _ = v.Args[1] 4585 x := v.Args[0] 4586 v_1 := v.Args[1] 4587 if v_1.Op != OpARMInvertFlags { 4588 break 4589 } 4590 flags := v_1.Args[0] 4591 v.reset(OpARMCMOVWHSconst) 4592 v.AuxInt = c 4593 v.AddArg(x) 4594 v.AddArg(flags) 4595 return true 4596 } 4597 return false 4598 } 4599 func rewriteValueARM_OpARMCMP_0(v *Value) bool { 4600 b := v.Block 4601 _ = b 4602 // match: (CMP x (MOVWconst [c])) 4603 // cond: 4604 // result: (CMPconst [c] x) 4605 for { 4606 _ = v.Args[1] 4607 x := v.Args[0] 4608 v_1 := v.Args[1] 4609 if v_1.Op != OpARMMOVWconst { 4610 break 4611 } 4612 c := v_1.AuxInt 4613 v.reset(OpARMCMPconst) 4614 v.AuxInt = c 4615 v.AddArg(x) 4616 return true 4617 } 4618 // match: (CMP (MOVWconst [c]) x) 4619 // cond: 4620 // result: (InvertFlags (CMPconst [c] x)) 4621 for { 4622 _ = v.Args[1] 4623 v_0 := v.Args[0] 4624 if v_0.Op != OpARMMOVWconst { 4625 break 4626 } 4627 c := v_0.AuxInt 4628 x := v.Args[1] 4629 v.reset(OpARMInvertFlags) 4630 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 4631 v0.AuxInt = c 4632 v0.AddArg(x) 4633 v.AddArg(v0) 4634 return true 4635 } 4636 // match: (CMP x (SLLconst [c] y)) 4637 // cond: 4638 // result: (CMPshiftLL x y [c]) 4639 for { 4640 _ = v.Args[1] 4641 x := v.Args[0] 4642 v_1 := v.Args[1] 4643 if v_1.Op != OpARMSLLconst { 4644 break 4645 } 4646 c := v_1.AuxInt 4647 y := v_1.Args[0] 4648 v.reset(OpARMCMPshiftLL) 4649 v.AuxInt = c 4650 v.AddArg(x) 4651 v.AddArg(y) 4652 return true 4653 } 4654 // match: (CMP (SLLconst [c] y) x) 4655 // cond: 4656 // result: (InvertFlags (CMPshiftLL x y [c])) 4657 for { 4658 _ = v.Args[1] 4659 v_0 := v.Args[0] 4660 if v_0.Op != OpARMSLLconst { 4661 break 4662 } 4663 c := v_0.AuxInt 4664 y := v_0.Args[0] 4665 x := v.Args[1] 4666 v.reset(OpARMInvertFlags) 4667 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags) 4668 v0.AuxInt = c 4669 v0.AddArg(x) 4670 v0.AddArg(y) 4671 v.AddArg(v0) 4672 return true 4673 } 4674 // match: (CMP x (SRLconst [c] y)) 4675 // cond: 4676 // result: (CMPshiftRL x y [c]) 4677 for { 4678 _ = v.Args[1] 4679 x := v.Args[0] 4680 v_1 := v.Args[1] 4681 if v_1.Op != OpARMSRLconst { 4682 break 4683 } 4684 c := v_1.AuxInt 4685 y := v_1.Args[0] 4686 v.reset(OpARMCMPshiftRL) 4687 v.AuxInt = c 4688 v.AddArg(x) 4689 v.AddArg(y) 4690 return true 4691 } 4692 // match: (CMP (SRLconst [c] y) x) 4693 // cond: 4694 // result: (InvertFlags (CMPshiftRL x y [c])) 4695 for { 4696 _ = v.Args[1] 4697 v_0 := v.Args[0] 4698 if v_0.Op != OpARMSRLconst { 4699 break 4700 } 4701 c := v_0.AuxInt 4702 y := v_0.Args[0] 4703 x := v.Args[1] 4704 v.reset(OpARMInvertFlags) 4705 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags) 4706 v0.AuxInt = c 4707 v0.AddArg(x) 4708 v0.AddArg(y) 4709 v.AddArg(v0) 4710 return true 4711 } 4712 // match: (CMP x (SRAconst [c] y)) 4713 // cond: 4714 // result: (CMPshiftRA x y [c]) 4715 for { 4716 _ = v.Args[1] 4717 x := v.Args[0] 4718 v_1 := v.Args[1] 4719 if v_1.Op != OpARMSRAconst { 4720 break 4721 } 4722 c := v_1.AuxInt 4723 y := v_1.Args[0] 4724 v.reset(OpARMCMPshiftRA) 4725 v.AuxInt = c 4726 v.AddArg(x) 4727 v.AddArg(y) 4728 return true 4729 } 4730 // match: (CMP (SRAconst [c] y) x) 4731 // cond: 4732 // result: (InvertFlags (CMPshiftRA x y [c])) 4733 for { 4734 _ = v.Args[1] 4735 v_0 := v.Args[0] 4736 if v_0.Op != OpARMSRAconst { 4737 break 4738 } 4739 c := v_0.AuxInt 4740 y := v_0.Args[0] 4741 x := v.Args[1] 4742 v.reset(OpARMInvertFlags) 4743 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags) 4744 v0.AuxInt = c 4745 v0.AddArg(x) 4746 v0.AddArg(y) 4747 v.AddArg(v0) 4748 return true 4749 } 4750 // match: (CMP x (SLL y z)) 4751 // cond: 4752 // result: (CMPshiftLLreg x y z) 4753 for { 4754 _ = v.Args[1] 4755 x := v.Args[0] 4756 v_1 := v.Args[1] 4757 if v_1.Op != OpARMSLL { 4758 break 4759 } 4760 _ = v_1.Args[1] 4761 y := v_1.Args[0] 4762 z := v_1.Args[1] 4763 v.reset(OpARMCMPshiftLLreg) 4764 v.AddArg(x) 4765 v.AddArg(y) 4766 v.AddArg(z) 4767 return true 4768 } 4769 // match: (CMP (SLL y z) x) 4770 // cond: 4771 // result: (InvertFlags (CMPshiftLLreg x y z)) 4772 for { 4773 _ = v.Args[1] 4774 v_0 := v.Args[0] 4775 if v_0.Op != OpARMSLL { 4776 break 4777 } 4778 _ = v_0.Args[1] 4779 y := v_0.Args[0] 4780 z := v_0.Args[1] 4781 x := v.Args[1] 4782 v.reset(OpARMInvertFlags) 4783 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags) 4784 v0.AddArg(x) 4785 v0.AddArg(y) 4786 v0.AddArg(z) 4787 v.AddArg(v0) 4788 return true 4789 } 4790 return false 4791 } 4792 func rewriteValueARM_OpARMCMP_10(v *Value) bool { 4793 b := v.Block 4794 _ = b 4795 // match: (CMP x (SRL y z)) 4796 // cond: 4797 // result: (CMPshiftRLreg x y z) 4798 for { 4799 _ = v.Args[1] 4800 x := v.Args[0] 4801 v_1 := v.Args[1] 4802 if v_1.Op != OpARMSRL { 4803 break 4804 } 4805 _ = v_1.Args[1] 4806 y := v_1.Args[0] 4807 z := v_1.Args[1] 4808 v.reset(OpARMCMPshiftRLreg) 4809 v.AddArg(x) 4810 v.AddArg(y) 4811 v.AddArg(z) 4812 return true 4813 } 4814 // match: (CMP (SRL y z) x) 4815 // cond: 4816 // result: (InvertFlags (CMPshiftRLreg x y z)) 4817 for { 4818 _ = v.Args[1] 4819 v_0 := v.Args[0] 4820 if v_0.Op != OpARMSRL { 4821 break 4822 } 4823 _ = v_0.Args[1] 4824 y := v_0.Args[0] 4825 z := v_0.Args[1] 4826 x := v.Args[1] 4827 v.reset(OpARMInvertFlags) 4828 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags) 4829 v0.AddArg(x) 4830 v0.AddArg(y) 4831 v0.AddArg(z) 4832 v.AddArg(v0) 4833 return true 4834 } 4835 // match: (CMP x (SRA y z)) 4836 // cond: 4837 // result: (CMPshiftRAreg x y z) 4838 for { 4839 _ = v.Args[1] 4840 x := v.Args[0] 4841 v_1 := v.Args[1] 4842 if v_1.Op != OpARMSRA { 4843 break 4844 } 4845 _ = v_1.Args[1] 4846 y := v_1.Args[0] 4847 z := v_1.Args[1] 4848 v.reset(OpARMCMPshiftRAreg) 4849 v.AddArg(x) 4850 v.AddArg(y) 4851 v.AddArg(z) 4852 return true 4853 } 4854 // match: (CMP (SRA y z) x) 4855 // cond: 4856 // result: (InvertFlags (CMPshiftRAreg x y z)) 4857 for { 4858 _ = v.Args[1] 4859 v_0 := v.Args[0] 4860 if v_0.Op != OpARMSRA { 4861 break 4862 } 4863 _ = v_0.Args[1] 4864 y := v_0.Args[0] 4865 z := v_0.Args[1] 4866 x := v.Args[1] 4867 v.reset(OpARMInvertFlags) 4868 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags) 4869 v0.AddArg(x) 4870 v0.AddArg(y) 4871 v0.AddArg(z) 4872 v.AddArg(v0) 4873 return true 4874 } 4875 return false 4876 } 4877 func rewriteValueARM_OpARMCMPD_0(v *Value) bool { 4878 // match: (CMPD x (MOVDconst [0])) 4879 // cond: 4880 // result: (CMPD0 x) 4881 for { 4882 _ = v.Args[1] 4883 x := v.Args[0] 4884 v_1 := v.Args[1] 4885 if v_1.Op != OpARMMOVDconst { 4886 break 4887 } 4888 if v_1.AuxInt != 0 { 4889 break 4890 } 4891 v.reset(OpARMCMPD0) 4892 v.AddArg(x) 4893 return true 4894 } 4895 return false 4896 } 4897 func rewriteValueARM_OpARMCMPF_0(v *Value) bool { 4898 // match: (CMPF x (MOVFconst [0])) 4899 // cond: 4900 // result: (CMPF0 x) 4901 for { 4902 _ = v.Args[1] 4903 x := v.Args[0] 4904 v_1 := v.Args[1] 4905 if v_1.Op != OpARMMOVFconst { 4906 break 4907 } 4908 if v_1.AuxInt != 0 { 4909 break 4910 } 4911 v.reset(OpARMCMPF0) 4912 v.AddArg(x) 4913 return true 4914 } 4915 return false 4916 } 4917 func rewriteValueARM_OpARMCMPconst_0(v *Value) bool { 4918 // match: (CMPconst (MOVWconst [x]) [y]) 4919 // cond: int32(x)==int32(y) 4920 // result: (FlagEQ) 4921 for { 4922 y := v.AuxInt 4923 v_0 := v.Args[0] 4924 if v_0.Op != OpARMMOVWconst { 4925 break 4926 } 4927 x := v_0.AuxInt 4928 if !(int32(x) == int32(y)) { 4929 break 4930 } 4931 v.reset(OpARMFlagEQ) 4932 return true 4933 } 4934 // match: (CMPconst (MOVWconst [x]) [y]) 4935 // cond: int32(x)<int32(y) && uint32(x)<uint32(y) 4936 // result: (FlagLT_ULT) 4937 for { 4938 y := v.AuxInt 4939 v_0 := v.Args[0] 4940 if v_0.Op != OpARMMOVWconst { 4941 break 4942 } 4943 x := v_0.AuxInt 4944 if !(int32(x) < int32(y) && uint32(x) < uint32(y)) { 4945 break 4946 } 4947 v.reset(OpARMFlagLT_ULT) 4948 return true 4949 } 4950 // match: (CMPconst (MOVWconst [x]) [y]) 4951 // cond: int32(x)<int32(y) && uint32(x)>uint32(y) 4952 // result: (FlagLT_UGT) 4953 for { 4954 y := v.AuxInt 4955 v_0 := v.Args[0] 4956 if v_0.Op != OpARMMOVWconst { 4957 break 4958 } 4959 x := v_0.AuxInt 4960 if !(int32(x) < int32(y) && uint32(x) > uint32(y)) { 4961 break 4962 } 4963 v.reset(OpARMFlagLT_UGT) 4964 return true 4965 } 4966 // match: (CMPconst (MOVWconst [x]) [y]) 4967 // cond: int32(x)>int32(y) && uint32(x)<uint32(y) 4968 // result: (FlagGT_ULT) 4969 for { 4970 y := v.AuxInt 4971 v_0 := v.Args[0] 4972 if v_0.Op != OpARMMOVWconst { 4973 break 4974 } 4975 x := v_0.AuxInt 4976 if !(int32(x) > int32(y) && uint32(x) < uint32(y)) { 4977 break 4978 } 4979 v.reset(OpARMFlagGT_ULT) 4980 return true 4981 } 4982 // match: (CMPconst (MOVWconst [x]) [y]) 4983 // cond: int32(x)>int32(y) && uint32(x)>uint32(y) 4984 // result: (FlagGT_UGT) 4985 for { 4986 y := v.AuxInt 4987 v_0 := v.Args[0] 4988 if v_0.Op != OpARMMOVWconst { 4989 break 4990 } 4991 x := v_0.AuxInt 4992 if !(int32(x) > int32(y) && uint32(x) > uint32(y)) { 4993 break 4994 } 4995 v.reset(OpARMFlagGT_UGT) 4996 return true 4997 } 4998 // match: (CMPconst (MOVBUreg _) [c]) 4999 // cond: 0xff < c 5000 // result: (FlagLT_ULT) 5001 for { 5002 c := v.AuxInt 5003 v_0 := v.Args[0] 5004 if v_0.Op != OpARMMOVBUreg { 5005 break 5006 } 5007 if !(0xff < c) { 5008 break 5009 } 5010 v.reset(OpARMFlagLT_ULT) 5011 return true 5012 } 5013 // match: (CMPconst (MOVHUreg _) [c]) 5014 // cond: 0xffff < c 5015 // result: (FlagLT_ULT) 5016 for { 5017 c := v.AuxInt 5018 v_0 := v.Args[0] 5019 if v_0.Op != OpARMMOVHUreg { 5020 break 5021 } 5022 if !(0xffff < c) { 5023 break 5024 } 5025 v.reset(OpARMFlagLT_ULT) 5026 return true 5027 } 5028 // match: (CMPconst (ANDconst _ [m]) [n]) 5029 // cond: 0 <= int32(m) && int32(m) < int32(n) 5030 // result: (FlagLT_ULT) 5031 for { 5032 n := v.AuxInt 5033 v_0 := v.Args[0] 5034 if v_0.Op != OpARMANDconst { 5035 break 5036 } 5037 m := v_0.AuxInt 5038 if !(0 <= int32(m) && int32(m) < int32(n)) { 5039 break 5040 } 5041 v.reset(OpARMFlagLT_ULT) 5042 return true 5043 } 5044 // match: (CMPconst (SRLconst _ [c]) [n]) 5045 // cond: 0 <= n && 0 < c && c <= 32 && (1<<uint32(32-c)) <= uint32(n) 5046 // result: (FlagLT_ULT) 5047 for { 5048 n := v.AuxInt 5049 v_0 := v.Args[0] 5050 if v_0.Op != OpARMSRLconst { 5051 break 5052 } 5053 c := v_0.AuxInt 5054 if !(0 <= n && 0 < c && c <= 32 && (1<<uint32(32-c)) <= uint32(n)) { 5055 break 5056 } 5057 v.reset(OpARMFlagLT_ULT) 5058 return true 5059 } 5060 return false 5061 } 5062 func rewriteValueARM_OpARMCMPshiftLL_0(v *Value) bool { 5063 b := v.Block 5064 _ = b 5065 // match: (CMPshiftLL (MOVWconst [c]) x [d]) 5066 // cond: 5067 // result: (InvertFlags (CMPconst [c] (SLLconst <x.Type> x [d]))) 5068 for { 5069 d := v.AuxInt 5070 _ = v.Args[1] 5071 v_0 := v.Args[0] 5072 if v_0.Op != OpARMMOVWconst { 5073 break 5074 } 5075 c := v_0.AuxInt 5076 x := v.Args[1] 5077 v.reset(OpARMInvertFlags) 5078 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 5079 v0.AuxInt = c 5080 v1 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 5081 v1.AuxInt = d 5082 v1.AddArg(x) 5083 v0.AddArg(v1) 5084 v.AddArg(v0) 5085 return true 5086 } 5087 // match: (CMPshiftLL x (MOVWconst [c]) [d]) 5088 // cond: 5089 // result: (CMPconst x [int64(uint32(c)<<uint64(d))]) 5090 for { 5091 d := v.AuxInt 5092 _ = v.Args[1] 5093 x := v.Args[0] 5094 v_1 := v.Args[1] 5095 if v_1.Op != OpARMMOVWconst { 5096 break 5097 } 5098 c := v_1.AuxInt 5099 v.reset(OpARMCMPconst) 5100 v.AuxInt = int64(uint32(c) << uint64(d)) 5101 v.AddArg(x) 5102 return true 5103 } 5104 return false 5105 } 5106 func rewriteValueARM_OpARMCMPshiftLLreg_0(v *Value) bool { 5107 b := v.Block 5108 _ = b 5109 // match: (CMPshiftLLreg (MOVWconst [c]) x y) 5110 // cond: 5111 // result: (InvertFlags (CMPconst [c] (SLL <x.Type> x y))) 5112 for { 5113 _ = v.Args[2] 5114 v_0 := v.Args[0] 5115 if v_0.Op != OpARMMOVWconst { 5116 break 5117 } 5118 c := v_0.AuxInt 5119 x := v.Args[1] 5120 y := v.Args[2] 5121 v.reset(OpARMInvertFlags) 5122 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 5123 v0.AuxInt = c 5124 v1 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 5125 v1.AddArg(x) 5126 v1.AddArg(y) 5127 v0.AddArg(v1) 5128 v.AddArg(v0) 5129 return true 5130 } 5131 // match: (CMPshiftLLreg x y (MOVWconst [c])) 5132 // cond: 5133 // result: (CMPshiftLL x y [c]) 5134 for { 5135 _ = v.Args[2] 5136 x := v.Args[0] 5137 y := v.Args[1] 5138 v_2 := v.Args[2] 5139 if v_2.Op != OpARMMOVWconst { 5140 break 5141 } 5142 c := v_2.AuxInt 5143 v.reset(OpARMCMPshiftLL) 5144 v.AuxInt = c 5145 v.AddArg(x) 5146 v.AddArg(y) 5147 return true 5148 } 5149 return false 5150 } 5151 func rewriteValueARM_OpARMCMPshiftRA_0(v *Value) bool { 5152 b := v.Block 5153 _ = b 5154 // match: (CMPshiftRA (MOVWconst [c]) x [d]) 5155 // cond: 5156 // result: (InvertFlags (CMPconst [c] (SRAconst <x.Type> x [d]))) 5157 for { 5158 d := v.AuxInt 5159 _ = v.Args[1] 5160 v_0 := v.Args[0] 5161 if v_0.Op != OpARMMOVWconst { 5162 break 5163 } 5164 c := v_0.AuxInt 5165 x := v.Args[1] 5166 v.reset(OpARMInvertFlags) 5167 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 5168 v0.AuxInt = c 5169 v1 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 5170 v1.AuxInt = d 5171 v1.AddArg(x) 5172 v0.AddArg(v1) 5173 v.AddArg(v0) 5174 return true 5175 } 5176 // match: (CMPshiftRA x (MOVWconst [c]) [d]) 5177 // cond: 5178 // result: (CMPconst x [int64(int32(c)>>uint64(d))]) 5179 for { 5180 d := v.AuxInt 5181 _ = v.Args[1] 5182 x := v.Args[0] 5183 v_1 := v.Args[1] 5184 if v_1.Op != OpARMMOVWconst { 5185 break 5186 } 5187 c := v_1.AuxInt 5188 v.reset(OpARMCMPconst) 5189 v.AuxInt = int64(int32(c) >> uint64(d)) 5190 v.AddArg(x) 5191 return true 5192 } 5193 return false 5194 } 5195 func rewriteValueARM_OpARMCMPshiftRAreg_0(v *Value) bool { 5196 b := v.Block 5197 _ = b 5198 // match: (CMPshiftRAreg (MOVWconst [c]) x y) 5199 // cond: 5200 // result: (InvertFlags (CMPconst [c] (SRA <x.Type> x y))) 5201 for { 5202 _ = v.Args[2] 5203 v_0 := v.Args[0] 5204 if v_0.Op != OpARMMOVWconst { 5205 break 5206 } 5207 c := v_0.AuxInt 5208 x := v.Args[1] 5209 y := v.Args[2] 5210 v.reset(OpARMInvertFlags) 5211 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 5212 v0.AuxInt = c 5213 v1 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 5214 v1.AddArg(x) 5215 v1.AddArg(y) 5216 v0.AddArg(v1) 5217 v.AddArg(v0) 5218 return true 5219 } 5220 // match: (CMPshiftRAreg x y (MOVWconst [c])) 5221 // cond: 5222 // result: (CMPshiftRA x y [c]) 5223 for { 5224 _ = v.Args[2] 5225 x := v.Args[0] 5226 y := v.Args[1] 5227 v_2 := v.Args[2] 5228 if v_2.Op != OpARMMOVWconst { 5229 break 5230 } 5231 c := v_2.AuxInt 5232 v.reset(OpARMCMPshiftRA) 5233 v.AuxInt = c 5234 v.AddArg(x) 5235 v.AddArg(y) 5236 return true 5237 } 5238 return false 5239 } 5240 func rewriteValueARM_OpARMCMPshiftRL_0(v *Value) bool { 5241 b := v.Block 5242 _ = b 5243 // match: (CMPshiftRL (MOVWconst [c]) x [d]) 5244 // cond: 5245 // result: (InvertFlags (CMPconst [c] (SRLconst <x.Type> x [d]))) 5246 for { 5247 d := v.AuxInt 5248 _ = v.Args[1] 5249 v_0 := v.Args[0] 5250 if v_0.Op != OpARMMOVWconst { 5251 break 5252 } 5253 c := v_0.AuxInt 5254 x := v.Args[1] 5255 v.reset(OpARMInvertFlags) 5256 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 5257 v0.AuxInt = c 5258 v1 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 5259 v1.AuxInt = d 5260 v1.AddArg(x) 5261 v0.AddArg(v1) 5262 v.AddArg(v0) 5263 return true 5264 } 5265 // match: (CMPshiftRL x (MOVWconst [c]) [d]) 5266 // cond: 5267 // result: (CMPconst x [int64(uint32(c)>>uint64(d))]) 5268 for { 5269 d := v.AuxInt 5270 _ = v.Args[1] 5271 x := v.Args[0] 5272 v_1 := v.Args[1] 5273 if v_1.Op != OpARMMOVWconst { 5274 break 5275 } 5276 c := v_1.AuxInt 5277 v.reset(OpARMCMPconst) 5278 v.AuxInt = int64(uint32(c) >> uint64(d)) 5279 v.AddArg(x) 5280 return true 5281 } 5282 return false 5283 } 5284 func rewriteValueARM_OpARMCMPshiftRLreg_0(v *Value) bool { 5285 b := v.Block 5286 _ = b 5287 // match: (CMPshiftRLreg (MOVWconst [c]) x y) 5288 // cond: 5289 // result: (InvertFlags (CMPconst [c] (SRL <x.Type> x y))) 5290 for { 5291 _ = v.Args[2] 5292 v_0 := v.Args[0] 5293 if v_0.Op != OpARMMOVWconst { 5294 break 5295 } 5296 c := v_0.AuxInt 5297 x := v.Args[1] 5298 y := v.Args[2] 5299 v.reset(OpARMInvertFlags) 5300 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 5301 v0.AuxInt = c 5302 v1 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 5303 v1.AddArg(x) 5304 v1.AddArg(y) 5305 v0.AddArg(v1) 5306 v.AddArg(v0) 5307 return true 5308 } 5309 // match: (CMPshiftRLreg x y (MOVWconst [c])) 5310 // cond: 5311 // result: (CMPshiftRL x y [c]) 5312 for { 5313 _ = v.Args[2] 5314 x := v.Args[0] 5315 y := v.Args[1] 5316 v_2 := v.Args[2] 5317 if v_2.Op != OpARMMOVWconst { 5318 break 5319 } 5320 c := v_2.AuxInt 5321 v.reset(OpARMCMPshiftRL) 5322 v.AuxInt = c 5323 v.AddArg(x) 5324 v.AddArg(y) 5325 return true 5326 } 5327 return false 5328 } 5329 func rewriteValueARM_OpARMEqual_0(v *Value) bool { 5330 // match: (Equal (FlagEQ)) 5331 // cond: 5332 // result: (MOVWconst [1]) 5333 for { 5334 v_0 := v.Args[0] 5335 if v_0.Op != OpARMFlagEQ { 5336 break 5337 } 5338 v.reset(OpARMMOVWconst) 5339 v.AuxInt = 1 5340 return true 5341 } 5342 // match: (Equal (FlagLT_ULT)) 5343 // cond: 5344 // result: (MOVWconst [0]) 5345 for { 5346 v_0 := v.Args[0] 5347 if v_0.Op != OpARMFlagLT_ULT { 5348 break 5349 } 5350 v.reset(OpARMMOVWconst) 5351 v.AuxInt = 0 5352 return true 5353 } 5354 // match: (Equal (FlagLT_UGT)) 5355 // cond: 5356 // result: (MOVWconst [0]) 5357 for { 5358 v_0 := v.Args[0] 5359 if v_0.Op != OpARMFlagLT_UGT { 5360 break 5361 } 5362 v.reset(OpARMMOVWconst) 5363 v.AuxInt = 0 5364 return true 5365 } 5366 // match: (Equal (FlagGT_ULT)) 5367 // cond: 5368 // result: (MOVWconst [0]) 5369 for { 5370 v_0 := v.Args[0] 5371 if v_0.Op != OpARMFlagGT_ULT { 5372 break 5373 } 5374 v.reset(OpARMMOVWconst) 5375 v.AuxInt = 0 5376 return true 5377 } 5378 // match: (Equal (FlagGT_UGT)) 5379 // cond: 5380 // result: (MOVWconst [0]) 5381 for { 5382 v_0 := v.Args[0] 5383 if v_0.Op != OpARMFlagGT_UGT { 5384 break 5385 } 5386 v.reset(OpARMMOVWconst) 5387 v.AuxInt = 0 5388 return true 5389 } 5390 // match: (Equal (InvertFlags x)) 5391 // cond: 5392 // result: (Equal x) 5393 for { 5394 v_0 := v.Args[0] 5395 if v_0.Op != OpARMInvertFlags { 5396 break 5397 } 5398 x := v_0.Args[0] 5399 v.reset(OpARMEqual) 5400 v.AddArg(x) 5401 return true 5402 } 5403 return false 5404 } 5405 func rewriteValueARM_OpARMGreaterEqual_0(v *Value) bool { 5406 // match: (GreaterEqual (FlagEQ)) 5407 // cond: 5408 // result: (MOVWconst [1]) 5409 for { 5410 v_0 := v.Args[0] 5411 if v_0.Op != OpARMFlagEQ { 5412 break 5413 } 5414 v.reset(OpARMMOVWconst) 5415 v.AuxInt = 1 5416 return true 5417 } 5418 // match: (GreaterEqual (FlagLT_ULT)) 5419 // cond: 5420 // result: (MOVWconst [0]) 5421 for { 5422 v_0 := v.Args[0] 5423 if v_0.Op != OpARMFlagLT_ULT { 5424 break 5425 } 5426 v.reset(OpARMMOVWconst) 5427 v.AuxInt = 0 5428 return true 5429 } 5430 // match: (GreaterEqual (FlagLT_UGT)) 5431 // cond: 5432 // result: (MOVWconst [0]) 5433 for { 5434 v_0 := v.Args[0] 5435 if v_0.Op != OpARMFlagLT_UGT { 5436 break 5437 } 5438 v.reset(OpARMMOVWconst) 5439 v.AuxInt = 0 5440 return true 5441 } 5442 // match: (GreaterEqual (FlagGT_ULT)) 5443 // cond: 5444 // result: (MOVWconst [1]) 5445 for { 5446 v_0 := v.Args[0] 5447 if v_0.Op != OpARMFlagGT_ULT { 5448 break 5449 } 5450 v.reset(OpARMMOVWconst) 5451 v.AuxInt = 1 5452 return true 5453 } 5454 // match: (GreaterEqual (FlagGT_UGT)) 5455 // cond: 5456 // result: (MOVWconst [1]) 5457 for { 5458 v_0 := v.Args[0] 5459 if v_0.Op != OpARMFlagGT_UGT { 5460 break 5461 } 5462 v.reset(OpARMMOVWconst) 5463 v.AuxInt = 1 5464 return true 5465 } 5466 // match: (GreaterEqual (InvertFlags x)) 5467 // cond: 5468 // result: (LessEqual x) 5469 for { 5470 v_0 := v.Args[0] 5471 if v_0.Op != OpARMInvertFlags { 5472 break 5473 } 5474 x := v_0.Args[0] 5475 v.reset(OpARMLessEqual) 5476 v.AddArg(x) 5477 return true 5478 } 5479 return false 5480 } 5481 func rewriteValueARM_OpARMGreaterEqualU_0(v *Value) bool { 5482 // match: (GreaterEqualU (FlagEQ)) 5483 // cond: 5484 // result: (MOVWconst [1]) 5485 for { 5486 v_0 := v.Args[0] 5487 if v_0.Op != OpARMFlagEQ { 5488 break 5489 } 5490 v.reset(OpARMMOVWconst) 5491 v.AuxInt = 1 5492 return true 5493 } 5494 // match: (GreaterEqualU (FlagLT_ULT)) 5495 // cond: 5496 // result: (MOVWconst [0]) 5497 for { 5498 v_0 := v.Args[0] 5499 if v_0.Op != OpARMFlagLT_ULT { 5500 break 5501 } 5502 v.reset(OpARMMOVWconst) 5503 v.AuxInt = 0 5504 return true 5505 } 5506 // match: (GreaterEqualU (FlagLT_UGT)) 5507 // cond: 5508 // result: (MOVWconst [1]) 5509 for { 5510 v_0 := v.Args[0] 5511 if v_0.Op != OpARMFlagLT_UGT { 5512 break 5513 } 5514 v.reset(OpARMMOVWconst) 5515 v.AuxInt = 1 5516 return true 5517 } 5518 // match: (GreaterEqualU (FlagGT_ULT)) 5519 // cond: 5520 // result: (MOVWconst [0]) 5521 for { 5522 v_0 := v.Args[0] 5523 if v_0.Op != OpARMFlagGT_ULT { 5524 break 5525 } 5526 v.reset(OpARMMOVWconst) 5527 v.AuxInt = 0 5528 return true 5529 } 5530 // match: (GreaterEqualU (FlagGT_UGT)) 5531 // cond: 5532 // result: (MOVWconst [1]) 5533 for { 5534 v_0 := v.Args[0] 5535 if v_0.Op != OpARMFlagGT_UGT { 5536 break 5537 } 5538 v.reset(OpARMMOVWconst) 5539 v.AuxInt = 1 5540 return true 5541 } 5542 // match: (GreaterEqualU (InvertFlags x)) 5543 // cond: 5544 // result: (LessEqualU x) 5545 for { 5546 v_0 := v.Args[0] 5547 if v_0.Op != OpARMInvertFlags { 5548 break 5549 } 5550 x := v_0.Args[0] 5551 v.reset(OpARMLessEqualU) 5552 v.AddArg(x) 5553 return true 5554 } 5555 return false 5556 } 5557 func rewriteValueARM_OpARMGreaterThan_0(v *Value) bool { 5558 // match: (GreaterThan (FlagEQ)) 5559 // cond: 5560 // result: (MOVWconst [0]) 5561 for { 5562 v_0 := v.Args[0] 5563 if v_0.Op != OpARMFlagEQ { 5564 break 5565 } 5566 v.reset(OpARMMOVWconst) 5567 v.AuxInt = 0 5568 return true 5569 } 5570 // match: (GreaterThan (FlagLT_ULT)) 5571 // cond: 5572 // result: (MOVWconst [0]) 5573 for { 5574 v_0 := v.Args[0] 5575 if v_0.Op != OpARMFlagLT_ULT { 5576 break 5577 } 5578 v.reset(OpARMMOVWconst) 5579 v.AuxInt = 0 5580 return true 5581 } 5582 // match: (GreaterThan (FlagLT_UGT)) 5583 // cond: 5584 // result: (MOVWconst [0]) 5585 for { 5586 v_0 := v.Args[0] 5587 if v_0.Op != OpARMFlagLT_UGT { 5588 break 5589 } 5590 v.reset(OpARMMOVWconst) 5591 v.AuxInt = 0 5592 return true 5593 } 5594 // match: (GreaterThan (FlagGT_ULT)) 5595 // cond: 5596 // result: (MOVWconst [1]) 5597 for { 5598 v_0 := v.Args[0] 5599 if v_0.Op != OpARMFlagGT_ULT { 5600 break 5601 } 5602 v.reset(OpARMMOVWconst) 5603 v.AuxInt = 1 5604 return true 5605 } 5606 // match: (GreaterThan (FlagGT_UGT)) 5607 // cond: 5608 // result: (MOVWconst [1]) 5609 for { 5610 v_0 := v.Args[0] 5611 if v_0.Op != OpARMFlagGT_UGT { 5612 break 5613 } 5614 v.reset(OpARMMOVWconst) 5615 v.AuxInt = 1 5616 return true 5617 } 5618 // match: (GreaterThan (InvertFlags x)) 5619 // cond: 5620 // result: (LessThan x) 5621 for { 5622 v_0 := v.Args[0] 5623 if v_0.Op != OpARMInvertFlags { 5624 break 5625 } 5626 x := v_0.Args[0] 5627 v.reset(OpARMLessThan) 5628 v.AddArg(x) 5629 return true 5630 } 5631 return false 5632 } 5633 func rewriteValueARM_OpARMGreaterThanU_0(v *Value) bool { 5634 // match: (GreaterThanU (FlagEQ)) 5635 // cond: 5636 // result: (MOVWconst [0]) 5637 for { 5638 v_0 := v.Args[0] 5639 if v_0.Op != OpARMFlagEQ { 5640 break 5641 } 5642 v.reset(OpARMMOVWconst) 5643 v.AuxInt = 0 5644 return true 5645 } 5646 // match: (GreaterThanU (FlagLT_ULT)) 5647 // cond: 5648 // result: (MOVWconst [0]) 5649 for { 5650 v_0 := v.Args[0] 5651 if v_0.Op != OpARMFlagLT_ULT { 5652 break 5653 } 5654 v.reset(OpARMMOVWconst) 5655 v.AuxInt = 0 5656 return true 5657 } 5658 // match: (GreaterThanU (FlagLT_UGT)) 5659 // cond: 5660 // result: (MOVWconst [1]) 5661 for { 5662 v_0 := v.Args[0] 5663 if v_0.Op != OpARMFlagLT_UGT { 5664 break 5665 } 5666 v.reset(OpARMMOVWconst) 5667 v.AuxInt = 1 5668 return true 5669 } 5670 // match: (GreaterThanU (FlagGT_ULT)) 5671 // cond: 5672 // result: (MOVWconst [0]) 5673 for { 5674 v_0 := v.Args[0] 5675 if v_0.Op != OpARMFlagGT_ULT { 5676 break 5677 } 5678 v.reset(OpARMMOVWconst) 5679 v.AuxInt = 0 5680 return true 5681 } 5682 // match: (GreaterThanU (FlagGT_UGT)) 5683 // cond: 5684 // result: (MOVWconst [1]) 5685 for { 5686 v_0 := v.Args[0] 5687 if v_0.Op != OpARMFlagGT_UGT { 5688 break 5689 } 5690 v.reset(OpARMMOVWconst) 5691 v.AuxInt = 1 5692 return true 5693 } 5694 // match: (GreaterThanU (InvertFlags x)) 5695 // cond: 5696 // result: (LessThanU x) 5697 for { 5698 v_0 := v.Args[0] 5699 if v_0.Op != OpARMInvertFlags { 5700 break 5701 } 5702 x := v_0.Args[0] 5703 v.reset(OpARMLessThanU) 5704 v.AddArg(x) 5705 return true 5706 } 5707 return false 5708 } 5709 func rewriteValueARM_OpARMLessEqual_0(v *Value) bool { 5710 // match: (LessEqual (FlagEQ)) 5711 // cond: 5712 // result: (MOVWconst [1]) 5713 for { 5714 v_0 := v.Args[0] 5715 if v_0.Op != OpARMFlagEQ { 5716 break 5717 } 5718 v.reset(OpARMMOVWconst) 5719 v.AuxInt = 1 5720 return true 5721 } 5722 // match: (LessEqual (FlagLT_ULT)) 5723 // cond: 5724 // result: (MOVWconst [1]) 5725 for { 5726 v_0 := v.Args[0] 5727 if v_0.Op != OpARMFlagLT_ULT { 5728 break 5729 } 5730 v.reset(OpARMMOVWconst) 5731 v.AuxInt = 1 5732 return true 5733 } 5734 // match: (LessEqual (FlagLT_UGT)) 5735 // cond: 5736 // result: (MOVWconst [1]) 5737 for { 5738 v_0 := v.Args[0] 5739 if v_0.Op != OpARMFlagLT_UGT { 5740 break 5741 } 5742 v.reset(OpARMMOVWconst) 5743 v.AuxInt = 1 5744 return true 5745 } 5746 // match: (LessEqual (FlagGT_ULT)) 5747 // cond: 5748 // result: (MOVWconst [0]) 5749 for { 5750 v_0 := v.Args[0] 5751 if v_0.Op != OpARMFlagGT_ULT { 5752 break 5753 } 5754 v.reset(OpARMMOVWconst) 5755 v.AuxInt = 0 5756 return true 5757 } 5758 // match: (LessEqual (FlagGT_UGT)) 5759 // cond: 5760 // result: (MOVWconst [0]) 5761 for { 5762 v_0 := v.Args[0] 5763 if v_0.Op != OpARMFlagGT_UGT { 5764 break 5765 } 5766 v.reset(OpARMMOVWconst) 5767 v.AuxInt = 0 5768 return true 5769 } 5770 // match: (LessEqual (InvertFlags x)) 5771 // cond: 5772 // result: (GreaterEqual x) 5773 for { 5774 v_0 := v.Args[0] 5775 if v_0.Op != OpARMInvertFlags { 5776 break 5777 } 5778 x := v_0.Args[0] 5779 v.reset(OpARMGreaterEqual) 5780 v.AddArg(x) 5781 return true 5782 } 5783 return false 5784 } 5785 func rewriteValueARM_OpARMLessEqualU_0(v *Value) bool { 5786 // match: (LessEqualU (FlagEQ)) 5787 // cond: 5788 // result: (MOVWconst [1]) 5789 for { 5790 v_0 := v.Args[0] 5791 if v_0.Op != OpARMFlagEQ { 5792 break 5793 } 5794 v.reset(OpARMMOVWconst) 5795 v.AuxInt = 1 5796 return true 5797 } 5798 // match: (LessEqualU (FlagLT_ULT)) 5799 // cond: 5800 // result: (MOVWconst [1]) 5801 for { 5802 v_0 := v.Args[0] 5803 if v_0.Op != OpARMFlagLT_ULT { 5804 break 5805 } 5806 v.reset(OpARMMOVWconst) 5807 v.AuxInt = 1 5808 return true 5809 } 5810 // match: (LessEqualU (FlagLT_UGT)) 5811 // cond: 5812 // result: (MOVWconst [0]) 5813 for { 5814 v_0 := v.Args[0] 5815 if v_0.Op != OpARMFlagLT_UGT { 5816 break 5817 } 5818 v.reset(OpARMMOVWconst) 5819 v.AuxInt = 0 5820 return true 5821 } 5822 // match: (LessEqualU (FlagGT_ULT)) 5823 // cond: 5824 // result: (MOVWconst [1]) 5825 for { 5826 v_0 := v.Args[0] 5827 if v_0.Op != OpARMFlagGT_ULT { 5828 break 5829 } 5830 v.reset(OpARMMOVWconst) 5831 v.AuxInt = 1 5832 return true 5833 } 5834 // match: (LessEqualU (FlagGT_UGT)) 5835 // cond: 5836 // result: (MOVWconst [0]) 5837 for { 5838 v_0 := v.Args[0] 5839 if v_0.Op != OpARMFlagGT_UGT { 5840 break 5841 } 5842 v.reset(OpARMMOVWconst) 5843 v.AuxInt = 0 5844 return true 5845 } 5846 // match: (LessEqualU (InvertFlags x)) 5847 // cond: 5848 // result: (GreaterEqualU x) 5849 for { 5850 v_0 := v.Args[0] 5851 if v_0.Op != OpARMInvertFlags { 5852 break 5853 } 5854 x := v_0.Args[0] 5855 v.reset(OpARMGreaterEqualU) 5856 v.AddArg(x) 5857 return true 5858 } 5859 return false 5860 } 5861 func rewriteValueARM_OpARMLessThan_0(v *Value) bool { 5862 // match: (LessThan (FlagEQ)) 5863 // cond: 5864 // result: (MOVWconst [0]) 5865 for { 5866 v_0 := v.Args[0] 5867 if v_0.Op != OpARMFlagEQ { 5868 break 5869 } 5870 v.reset(OpARMMOVWconst) 5871 v.AuxInt = 0 5872 return true 5873 } 5874 // match: (LessThan (FlagLT_ULT)) 5875 // cond: 5876 // result: (MOVWconst [1]) 5877 for { 5878 v_0 := v.Args[0] 5879 if v_0.Op != OpARMFlagLT_ULT { 5880 break 5881 } 5882 v.reset(OpARMMOVWconst) 5883 v.AuxInt = 1 5884 return true 5885 } 5886 // match: (LessThan (FlagLT_UGT)) 5887 // cond: 5888 // result: (MOVWconst [1]) 5889 for { 5890 v_0 := v.Args[0] 5891 if v_0.Op != OpARMFlagLT_UGT { 5892 break 5893 } 5894 v.reset(OpARMMOVWconst) 5895 v.AuxInt = 1 5896 return true 5897 } 5898 // match: (LessThan (FlagGT_ULT)) 5899 // cond: 5900 // result: (MOVWconst [0]) 5901 for { 5902 v_0 := v.Args[0] 5903 if v_0.Op != OpARMFlagGT_ULT { 5904 break 5905 } 5906 v.reset(OpARMMOVWconst) 5907 v.AuxInt = 0 5908 return true 5909 } 5910 // match: (LessThan (FlagGT_UGT)) 5911 // cond: 5912 // result: (MOVWconst [0]) 5913 for { 5914 v_0 := v.Args[0] 5915 if v_0.Op != OpARMFlagGT_UGT { 5916 break 5917 } 5918 v.reset(OpARMMOVWconst) 5919 v.AuxInt = 0 5920 return true 5921 } 5922 // match: (LessThan (InvertFlags x)) 5923 // cond: 5924 // result: (GreaterThan x) 5925 for { 5926 v_0 := v.Args[0] 5927 if v_0.Op != OpARMInvertFlags { 5928 break 5929 } 5930 x := v_0.Args[0] 5931 v.reset(OpARMGreaterThan) 5932 v.AddArg(x) 5933 return true 5934 } 5935 return false 5936 } 5937 func rewriteValueARM_OpARMLessThanU_0(v *Value) bool { 5938 // match: (LessThanU (FlagEQ)) 5939 // cond: 5940 // result: (MOVWconst [0]) 5941 for { 5942 v_0 := v.Args[0] 5943 if v_0.Op != OpARMFlagEQ { 5944 break 5945 } 5946 v.reset(OpARMMOVWconst) 5947 v.AuxInt = 0 5948 return true 5949 } 5950 // match: (LessThanU (FlagLT_ULT)) 5951 // cond: 5952 // result: (MOVWconst [1]) 5953 for { 5954 v_0 := v.Args[0] 5955 if v_0.Op != OpARMFlagLT_ULT { 5956 break 5957 } 5958 v.reset(OpARMMOVWconst) 5959 v.AuxInt = 1 5960 return true 5961 } 5962 // match: (LessThanU (FlagLT_UGT)) 5963 // cond: 5964 // result: (MOVWconst [0]) 5965 for { 5966 v_0 := v.Args[0] 5967 if v_0.Op != OpARMFlagLT_UGT { 5968 break 5969 } 5970 v.reset(OpARMMOVWconst) 5971 v.AuxInt = 0 5972 return true 5973 } 5974 // match: (LessThanU (FlagGT_ULT)) 5975 // cond: 5976 // result: (MOVWconst [1]) 5977 for { 5978 v_0 := v.Args[0] 5979 if v_0.Op != OpARMFlagGT_ULT { 5980 break 5981 } 5982 v.reset(OpARMMOVWconst) 5983 v.AuxInt = 1 5984 return true 5985 } 5986 // match: (LessThanU (FlagGT_UGT)) 5987 // cond: 5988 // result: (MOVWconst [0]) 5989 for { 5990 v_0 := v.Args[0] 5991 if v_0.Op != OpARMFlagGT_UGT { 5992 break 5993 } 5994 v.reset(OpARMMOVWconst) 5995 v.AuxInt = 0 5996 return true 5997 } 5998 // match: (LessThanU (InvertFlags x)) 5999 // cond: 6000 // result: (GreaterThanU x) 6001 for { 6002 v_0 := v.Args[0] 6003 if v_0.Op != OpARMInvertFlags { 6004 break 6005 } 6006 x := v_0.Args[0] 6007 v.reset(OpARMGreaterThanU) 6008 v.AddArg(x) 6009 return true 6010 } 6011 return false 6012 } 6013 func rewriteValueARM_OpARMMOVBUload_0(v *Value) bool { 6014 b := v.Block 6015 _ = b 6016 config := b.Func.Config 6017 _ = config 6018 // match: (MOVBUload [off1] {sym} (ADDconst [off2] ptr) mem) 6019 // cond: 6020 // result: (MOVBUload [off1+off2] {sym} ptr mem) 6021 for { 6022 off1 := v.AuxInt 6023 sym := v.Aux 6024 _ = v.Args[1] 6025 v_0 := v.Args[0] 6026 if v_0.Op != OpARMADDconst { 6027 break 6028 } 6029 off2 := v_0.AuxInt 6030 ptr := v_0.Args[0] 6031 mem := v.Args[1] 6032 v.reset(OpARMMOVBUload) 6033 v.AuxInt = off1 + off2 6034 v.Aux = sym 6035 v.AddArg(ptr) 6036 v.AddArg(mem) 6037 return true 6038 } 6039 // match: (MOVBUload [off1] {sym} (SUBconst [off2] ptr) mem) 6040 // cond: 6041 // result: (MOVBUload [off1-off2] {sym} ptr mem) 6042 for { 6043 off1 := v.AuxInt 6044 sym := v.Aux 6045 _ = v.Args[1] 6046 v_0 := v.Args[0] 6047 if v_0.Op != OpARMSUBconst { 6048 break 6049 } 6050 off2 := v_0.AuxInt 6051 ptr := v_0.Args[0] 6052 mem := v.Args[1] 6053 v.reset(OpARMMOVBUload) 6054 v.AuxInt = off1 - off2 6055 v.Aux = sym 6056 v.AddArg(ptr) 6057 v.AddArg(mem) 6058 return true 6059 } 6060 // match: (MOVBUload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 6061 // cond: canMergeSym(sym1,sym2) 6062 // result: (MOVBUload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 6063 for { 6064 off1 := v.AuxInt 6065 sym1 := v.Aux 6066 _ = v.Args[1] 6067 v_0 := v.Args[0] 6068 if v_0.Op != OpARMMOVWaddr { 6069 break 6070 } 6071 off2 := v_0.AuxInt 6072 sym2 := v_0.Aux 6073 ptr := v_0.Args[0] 6074 mem := v.Args[1] 6075 if !(canMergeSym(sym1, sym2)) { 6076 break 6077 } 6078 v.reset(OpARMMOVBUload) 6079 v.AuxInt = off1 + off2 6080 v.Aux = mergeSym(sym1, sym2) 6081 v.AddArg(ptr) 6082 v.AddArg(mem) 6083 return true 6084 } 6085 // match: (MOVBUload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _)) 6086 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 6087 // result: (MOVBUreg x) 6088 for { 6089 off := v.AuxInt 6090 sym := v.Aux 6091 _ = v.Args[1] 6092 ptr := v.Args[0] 6093 v_1 := v.Args[1] 6094 if v_1.Op != OpARMMOVBstore { 6095 break 6096 } 6097 off2 := v_1.AuxInt 6098 sym2 := v_1.Aux 6099 _ = v_1.Args[2] 6100 ptr2 := v_1.Args[0] 6101 x := v_1.Args[1] 6102 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 6103 break 6104 } 6105 v.reset(OpARMMOVBUreg) 6106 v.AddArg(x) 6107 return true 6108 } 6109 // match: (MOVBUload [0] {sym} (ADD ptr idx) mem) 6110 // cond: sym == nil && !config.nacl 6111 // result: (MOVBUloadidx ptr idx mem) 6112 for { 6113 if v.AuxInt != 0 { 6114 break 6115 } 6116 sym := v.Aux 6117 _ = v.Args[1] 6118 v_0 := v.Args[0] 6119 if v_0.Op != OpARMADD { 6120 break 6121 } 6122 _ = v_0.Args[1] 6123 ptr := v_0.Args[0] 6124 idx := v_0.Args[1] 6125 mem := v.Args[1] 6126 if !(sym == nil && !config.nacl) { 6127 break 6128 } 6129 v.reset(OpARMMOVBUloadidx) 6130 v.AddArg(ptr) 6131 v.AddArg(idx) 6132 v.AddArg(mem) 6133 return true 6134 } 6135 return false 6136 } 6137 func rewriteValueARM_OpARMMOVBUloadidx_0(v *Value) bool { 6138 // match: (MOVBUloadidx ptr idx (MOVBstoreidx ptr2 idx x _)) 6139 // cond: isSamePtr(ptr, ptr2) 6140 // result: (MOVBUreg x) 6141 for { 6142 _ = v.Args[2] 6143 ptr := v.Args[0] 6144 idx := v.Args[1] 6145 v_2 := v.Args[2] 6146 if v_2.Op != OpARMMOVBstoreidx { 6147 break 6148 } 6149 _ = v_2.Args[3] 6150 ptr2 := v_2.Args[0] 6151 if idx != v_2.Args[1] { 6152 break 6153 } 6154 x := v_2.Args[2] 6155 if !(isSamePtr(ptr, ptr2)) { 6156 break 6157 } 6158 v.reset(OpARMMOVBUreg) 6159 v.AddArg(x) 6160 return true 6161 } 6162 // match: (MOVBUloadidx ptr (MOVWconst [c]) mem) 6163 // cond: 6164 // result: (MOVBUload [c] ptr mem) 6165 for { 6166 _ = v.Args[2] 6167 ptr := v.Args[0] 6168 v_1 := v.Args[1] 6169 if v_1.Op != OpARMMOVWconst { 6170 break 6171 } 6172 c := v_1.AuxInt 6173 mem := v.Args[2] 6174 v.reset(OpARMMOVBUload) 6175 v.AuxInt = c 6176 v.AddArg(ptr) 6177 v.AddArg(mem) 6178 return true 6179 } 6180 // match: (MOVBUloadidx (MOVWconst [c]) ptr mem) 6181 // cond: 6182 // result: (MOVBUload [c] ptr mem) 6183 for { 6184 _ = v.Args[2] 6185 v_0 := v.Args[0] 6186 if v_0.Op != OpARMMOVWconst { 6187 break 6188 } 6189 c := v_0.AuxInt 6190 ptr := v.Args[1] 6191 mem := v.Args[2] 6192 v.reset(OpARMMOVBUload) 6193 v.AuxInt = c 6194 v.AddArg(ptr) 6195 v.AddArg(mem) 6196 return true 6197 } 6198 return false 6199 } 6200 func rewriteValueARM_OpARMMOVBUreg_0(v *Value) bool { 6201 // match: (MOVBUreg x:(MOVBUload _ _)) 6202 // cond: 6203 // result: (MOVWreg x) 6204 for { 6205 x := v.Args[0] 6206 if x.Op != OpARMMOVBUload { 6207 break 6208 } 6209 _ = x.Args[1] 6210 v.reset(OpARMMOVWreg) 6211 v.AddArg(x) 6212 return true 6213 } 6214 // match: (MOVBUreg (ANDconst [c] x)) 6215 // cond: 6216 // result: (ANDconst [c&0xff] x) 6217 for { 6218 v_0 := v.Args[0] 6219 if v_0.Op != OpARMANDconst { 6220 break 6221 } 6222 c := v_0.AuxInt 6223 x := v_0.Args[0] 6224 v.reset(OpARMANDconst) 6225 v.AuxInt = c & 0xff 6226 v.AddArg(x) 6227 return true 6228 } 6229 // match: (MOVBUreg x:(MOVBUreg _)) 6230 // cond: 6231 // result: (MOVWreg x) 6232 for { 6233 x := v.Args[0] 6234 if x.Op != OpARMMOVBUreg { 6235 break 6236 } 6237 v.reset(OpARMMOVWreg) 6238 v.AddArg(x) 6239 return true 6240 } 6241 // match: (MOVBUreg (MOVWconst [c])) 6242 // cond: 6243 // result: (MOVWconst [int64(uint8(c))]) 6244 for { 6245 v_0 := v.Args[0] 6246 if v_0.Op != OpARMMOVWconst { 6247 break 6248 } 6249 c := v_0.AuxInt 6250 v.reset(OpARMMOVWconst) 6251 v.AuxInt = int64(uint8(c)) 6252 return true 6253 } 6254 return false 6255 } 6256 func rewriteValueARM_OpARMMOVBload_0(v *Value) bool { 6257 b := v.Block 6258 _ = b 6259 config := b.Func.Config 6260 _ = config 6261 // match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem) 6262 // cond: 6263 // result: (MOVBload [off1+off2] {sym} ptr mem) 6264 for { 6265 off1 := v.AuxInt 6266 sym := v.Aux 6267 _ = v.Args[1] 6268 v_0 := v.Args[0] 6269 if v_0.Op != OpARMADDconst { 6270 break 6271 } 6272 off2 := v_0.AuxInt 6273 ptr := v_0.Args[0] 6274 mem := v.Args[1] 6275 v.reset(OpARMMOVBload) 6276 v.AuxInt = off1 + off2 6277 v.Aux = sym 6278 v.AddArg(ptr) 6279 v.AddArg(mem) 6280 return true 6281 } 6282 // match: (MOVBload [off1] {sym} (SUBconst [off2] ptr) mem) 6283 // cond: 6284 // result: (MOVBload [off1-off2] {sym} ptr mem) 6285 for { 6286 off1 := v.AuxInt 6287 sym := v.Aux 6288 _ = v.Args[1] 6289 v_0 := v.Args[0] 6290 if v_0.Op != OpARMSUBconst { 6291 break 6292 } 6293 off2 := v_0.AuxInt 6294 ptr := v_0.Args[0] 6295 mem := v.Args[1] 6296 v.reset(OpARMMOVBload) 6297 v.AuxInt = off1 - off2 6298 v.Aux = sym 6299 v.AddArg(ptr) 6300 v.AddArg(mem) 6301 return true 6302 } 6303 // match: (MOVBload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 6304 // cond: canMergeSym(sym1,sym2) 6305 // result: (MOVBload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 6306 for { 6307 off1 := v.AuxInt 6308 sym1 := v.Aux 6309 _ = v.Args[1] 6310 v_0 := v.Args[0] 6311 if v_0.Op != OpARMMOVWaddr { 6312 break 6313 } 6314 off2 := v_0.AuxInt 6315 sym2 := v_0.Aux 6316 ptr := v_0.Args[0] 6317 mem := v.Args[1] 6318 if !(canMergeSym(sym1, sym2)) { 6319 break 6320 } 6321 v.reset(OpARMMOVBload) 6322 v.AuxInt = off1 + off2 6323 v.Aux = mergeSym(sym1, sym2) 6324 v.AddArg(ptr) 6325 v.AddArg(mem) 6326 return true 6327 } 6328 // match: (MOVBload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _)) 6329 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 6330 // result: (MOVBreg x) 6331 for { 6332 off := v.AuxInt 6333 sym := v.Aux 6334 _ = v.Args[1] 6335 ptr := v.Args[0] 6336 v_1 := v.Args[1] 6337 if v_1.Op != OpARMMOVBstore { 6338 break 6339 } 6340 off2 := v_1.AuxInt 6341 sym2 := v_1.Aux 6342 _ = v_1.Args[2] 6343 ptr2 := v_1.Args[0] 6344 x := v_1.Args[1] 6345 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 6346 break 6347 } 6348 v.reset(OpARMMOVBreg) 6349 v.AddArg(x) 6350 return true 6351 } 6352 // match: (MOVBload [0] {sym} (ADD ptr idx) mem) 6353 // cond: sym == nil && !config.nacl 6354 // result: (MOVBloadidx ptr idx mem) 6355 for { 6356 if v.AuxInt != 0 { 6357 break 6358 } 6359 sym := v.Aux 6360 _ = v.Args[1] 6361 v_0 := v.Args[0] 6362 if v_0.Op != OpARMADD { 6363 break 6364 } 6365 _ = v_0.Args[1] 6366 ptr := v_0.Args[0] 6367 idx := v_0.Args[1] 6368 mem := v.Args[1] 6369 if !(sym == nil && !config.nacl) { 6370 break 6371 } 6372 v.reset(OpARMMOVBloadidx) 6373 v.AddArg(ptr) 6374 v.AddArg(idx) 6375 v.AddArg(mem) 6376 return true 6377 } 6378 return false 6379 } 6380 func rewriteValueARM_OpARMMOVBloadidx_0(v *Value) bool { 6381 // match: (MOVBloadidx ptr idx (MOVBstoreidx ptr2 idx x _)) 6382 // cond: isSamePtr(ptr, ptr2) 6383 // result: (MOVBreg x) 6384 for { 6385 _ = v.Args[2] 6386 ptr := v.Args[0] 6387 idx := v.Args[1] 6388 v_2 := v.Args[2] 6389 if v_2.Op != OpARMMOVBstoreidx { 6390 break 6391 } 6392 _ = v_2.Args[3] 6393 ptr2 := v_2.Args[0] 6394 if idx != v_2.Args[1] { 6395 break 6396 } 6397 x := v_2.Args[2] 6398 if !(isSamePtr(ptr, ptr2)) { 6399 break 6400 } 6401 v.reset(OpARMMOVBreg) 6402 v.AddArg(x) 6403 return true 6404 } 6405 // match: (MOVBloadidx ptr (MOVWconst [c]) mem) 6406 // cond: 6407 // result: (MOVBload [c] ptr mem) 6408 for { 6409 _ = v.Args[2] 6410 ptr := v.Args[0] 6411 v_1 := v.Args[1] 6412 if v_1.Op != OpARMMOVWconst { 6413 break 6414 } 6415 c := v_1.AuxInt 6416 mem := v.Args[2] 6417 v.reset(OpARMMOVBload) 6418 v.AuxInt = c 6419 v.AddArg(ptr) 6420 v.AddArg(mem) 6421 return true 6422 } 6423 // match: (MOVBloadidx (MOVWconst [c]) ptr mem) 6424 // cond: 6425 // result: (MOVBload [c] ptr mem) 6426 for { 6427 _ = v.Args[2] 6428 v_0 := v.Args[0] 6429 if v_0.Op != OpARMMOVWconst { 6430 break 6431 } 6432 c := v_0.AuxInt 6433 ptr := v.Args[1] 6434 mem := v.Args[2] 6435 v.reset(OpARMMOVBload) 6436 v.AuxInt = c 6437 v.AddArg(ptr) 6438 v.AddArg(mem) 6439 return true 6440 } 6441 return false 6442 } 6443 func rewriteValueARM_OpARMMOVBreg_0(v *Value) bool { 6444 // match: (MOVBreg x:(MOVBload _ _)) 6445 // cond: 6446 // result: (MOVWreg x) 6447 for { 6448 x := v.Args[0] 6449 if x.Op != OpARMMOVBload { 6450 break 6451 } 6452 _ = x.Args[1] 6453 v.reset(OpARMMOVWreg) 6454 v.AddArg(x) 6455 return true 6456 } 6457 // match: (MOVBreg (ANDconst [c] x)) 6458 // cond: c & 0x80 == 0 6459 // result: (ANDconst [c&0x7f] x) 6460 for { 6461 v_0 := v.Args[0] 6462 if v_0.Op != OpARMANDconst { 6463 break 6464 } 6465 c := v_0.AuxInt 6466 x := v_0.Args[0] 6467 if !(c&0x80 == 0) { 6468 break 6469 } 6470 v.reset(OpARMANDconst) 6471 v.AuxInt = c & 0x7f 6472 v.AddArg(x) 6473 return true 6474 } 6475 // match: (MOVBreg x:(MOVBreg _)) 6476 // cond: 6477 // result: (MOVWreg x) 6478 for { 6479 x := v.Args[0] 6480 if x.Op != OpARMMOVBreg { 6481 break 6482 } 6483 v.reset(OpARMMOVWreg) 6484 v.AddArg(x) 6485 return true 6486 } 6487 // match: (MOVBreg (MOVWconst [c])) 6488 // cond: 6489 // result: (MOVWconst [int64(int8(c))]) 6490 for { 6491 v_0 := v.Args[0] 6492 if v_0.Op != OpARMMOVWconst { 6493 break 6494 } 6495 c := v_0.AuxInt 6496 v.reset(OpARMMOVWconst) 6497 v.AuxInt = int64(int8(c)) 6498 return true 6499 } 6500 return false 6501 } 6502 func rewriteValueARM_OpARMMOVBstore_0(v *Value) bool { 6503 b := v.Block 6504 _ = b 6505 config := b.Func.Config 6506 _ = config 6507 // match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem) 6508 // cond: 6509 // result: (MOVBstore [off1+off2] {sym} ptr val mem) 6510 for { 6511 off1 := v.AuxInt 6512 sym := v.Aux 6513 _ = v.Args[2] 6514 v_0 := v.Args[0] 6515 if v_0.Op != OpARMADDconst { 6516 break 6517 } 6518 off2 := v_0.AuxInt 6519 ptr := v_0.Args[0] 6520 val := v.Args[1] 6521 mem := v.Args[2] 6522 v.reset(OpARMMOVBstore) 6523 v.AuxInt = off1 + off2 6524 v.Aux = sym 6525 v.AddArg(ptr) 6526 v.AddArg(val) 6527 v.AddArg(mem) 6528 return true 6529 } 6530 // match: (MOVBstore [off1] {sym} (SUBconst [off2] ptr) val mem) 6531 // cond: 6532 // result: (MOVBstore [off1-off2] {sym} ptr val mem) 6533 for { 6534 off1 := v.AuxInt 6535 sym := v.Aux 6536 _ = v.Args[2] 6537 v_0 := v.Args[0] 6538 if v_0.Op != OpARMSUBconst { 6539 break 6540 } 6541 off2 := v_0.AuxInt 6542 ptr := v_0.Args[0] 6543 val := v.Args[1] 6544 mem := v.Args[2] 6545 v.reset(OpARMMOVBstore) 6546 v.AuxInt = off1 - off2 6547 v.Aux = sym 6548 v.AddArg(ptr) 6549 v.AddArg(val) 6550 v.AddArg(mem) 6551 return true 6552 } 6553 // match: (MOVBstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem) 6554 // cond: canMergeSym(sym1,sym2) 6555 // result: (MOVBstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem) 6556 for { 6557 off1 := v.AuxInt 6558 sym1 := v.Aux 6559 _ = v.Args[2] 6560 v_0 := v.Args[0] 6561 if v_0.Op != OpARMMOVWaddr { 6562 break 6563 } 6564 off2 := v_0.AuxInt 6565 sym2 := v_0.Aux 6566 ptr := v_0.Args[0] 6567 val := v.Args[1] 6568 mem := v.Args[2] 6569 if !(canMergeSym(sym1, sym2)) { 6570 break 6571 } 6572 v.reset(OpARMMOVBstore) 6573 v.AuxInt = off1 + off2 6574 v.Aux = mergeSym(sym1, sym2) 6575 v.AddArg(ptr) 6576 v.AddArg(val) 6577 v.AddArg(mem) 6578 return true 6579 } 6580 // match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem) 6581 // cond: 6582 // result: (MOVBstore [off] {sym} ptr x mem) 6583 for { 6584 off := v.AuxInt 6585 sym := v.Aux 6586 _ = v.Args[2] 6587 ptr := v.Args[0] 6588 v_1 := v.Args[1] 6589 if v_1.Op != OpARMMOVBreg { 6590 break 6591 } 6592 x := v_1.Args[0] 6593 mem := v.Args[2] 6594 v.reset(OpARMMOVBstore) 6595 v.AuxInt = off 6596 v.Aux = sym 6597 v.AddArg(ptr) 6598 v.AddArg(x) 6599 v.AddArg(mem) 6600 return true 6601 } 6602 // match: (MOVBstore [off] {sym} ptr (MOVBUreg x) mem) 6603 // cond: 6604 // result: (MOVBstore [off] {sym} ptr x mem) 6605 for { 6606 off := v.AuxInt 6607 sym := v.Aux 6608 _ = v.Args[2] 6609 ptr := v.Args[0] 6610 v_1 := v.Args[1] 6611 if v_1.Op != OpARMMOVBUreg { 6612 break 6613 } 6614 x := v_1.Args[0] 6615 mem := v.Args[2] 6616 v.reset(OpARMMOVBstore) 6617 v.AuxInt = off 6618 v.Aux = sym 6619 v.AddArg(ptr) 6620 v.AddArg(x) 6621 v.AddArg(mem) 6622 return true 6623 } 6624 // match: (MOVBstore [off] {sym} ptr (MOVHreg x) mem) 6625 // cond: 6626 // result: (MOVBstore [off] {sym} ptr x mem) 6627 for { 6628 off := v.AuxInt 6629 sym := v.Aux 6630 _ = v.Args[2] 6631 ptr := v.Args[0] 6632 v_1 := v.Args[1] 6633 if v_1.Op != OpARMMOVHreg { 6634 break 6635 } 6636 x := v_1.Args[0] 6637 mem := v.Args[2] 6638 v.reset(OpARMMOVBstore) 6639 v.AuxInt = off 6640 v.Aux = sym 6641 v.AddArg(ptr) 6642 v.AddArg(x) 6643 v.AddArg(mem) 6644 return true 6645 } 6646 // match: (MOVBstore [off] {sym} ptr (MOVHUreg x) mem) 6647 // cond: 6648 // result: (MOVBstore [off] {sym} ptr x mem) 6649 for { 6650 off := v.AuxInt 6651 sym := v.Aux 6652 _ = v.Args[2] 6653 ptr := v.Args[0] 6654 v_1 := v.Args[1] 6655 if v_1.Op != OpARMMOVHUreg { 6656 break 6657 } 6658 x := v_1.Args[0] 6659 mem := v.Args[2] 6660 v.reset(OpARMMOVBstore) 6661 v.AuxInt = off 6662 v.Aux = sym 6663 v.AddArg(ptr) 6664 v.AddArg(x) 6665 v.AddArg(mem) 6666 return true 6667 } 6668 // match: (MOVBstore [0] {sym} (ADD ptr idx) val mem) 6669 // cond: sym == nil && !config.nacl 6670 // result: (MOVBstoreidx ptr idx val mem) 6671 for { 6672 if v.AuxInt != 0 { 6673 break 6674 } 6675 sym := v.Aux 6676 _ = v.Args[2] 6677 v_0 := v.Args[0] 6678 if v_0.Op != OpARMADD { 6679 break 6680 } 6681 _ = v_0.Args[1] 6682 ptr := v_0.Args[0] 6683 idx := v_0.Args[1] 6684 val := v.Args[1] 6685 mem := v.Args[2] 6686 if !(sym == nil && !config.nacl) { 6687 break 6688 } 6689 v.reset(OpARMMOVBstoreidx) 6690 v.AddArg(ptr) 6691 v.AddArg(idx) 6692 v.AddArg(val) 6693 v.AddArg(mem) 6694 return true 6695 } 6696 return false 6697 } 6698 func rewriteValueARM_OpARMMOVBstoreidx_0(v *Value) bool { 6699 // match: (MOVBstoreidx ptr (MOVWconst [c]) val mem) 6700 // cond: 6701 // result: (MOVBstore [c] ptr val mem) 6702 for { 6703 _ = v.Args[3] 6704 ptr := v.Args[0] 6705 v_1 := v.Args[1] 6706 if v_1.Op != OpARMMOVWconst { 6707 break 6708 } 6709 c := v_1.AuxInt 6710 val := v.Args[2] 6711 mem := v.Args[3] 6712 v.reset(OpARMMOVBstore) 6713 v.AuxInt = c 6714 v.AddArg(ptr) 6715 v.AddArg(val) 6716 v.AddArg(mem) 6717 return true 6718 } 6719 // match: (MOVBstoreidx (MOVWconst [c]) ptr val mem) 6720 // cond: 6721 // result: (MOVBstore [c] ptr val mem) 6722 for { 6723 _ = v.Args[3] 6724 v_0 := v.Args[0] 6725 if v_0.Op != OpARMMOVWconst { 6726 break 6727 } 6728 c := v_0.AuxInt 6729 ptr := v.Args[1] 6730 val := v.Args[2] 6731 mem := v.Args[3] 6732 v.reset(OpARMMOVBstore) 6733 v.AuxInt = c 6734 v.AddArg(ptr) 6735 v.AddArg(val) 6736 v.AddArg(mem) 6737 return true 6738 } 6739 return false 6740 } 6741 func rewriteValueARM_OpARMMOVDload_0(v *Value) bool { 6742 // match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem) 6743 // cond: 6744 // result: (MOVDload [off1+off2] {sym} ptr mem) 6745 for { 6746 off1 := v.AuxInt 6747 sym := v.Aux 6748 _ = v.Args[1] 6749 v_0 := v.Args[0] 6750 if v_0.Op != OpARMADDconst { 6751 break 6752 } 6753 off2 := v_0.AuxInt 6754 ptr := v_0.Args[0] 6755 mem := v.Args[1] 6756 v.reset(OpARMMOVDload) 6757 v.AuxInt = off1 + off2 6758 v.Aux = sym 6759 v.AddArg(ptr) 6760 v.AddArg(mem) 6761 return true 6762 } 6763 // match: (MOVDload [off1] {sym} (SUBconst [off2] ptr) mem) 6764 // cond: 6765 // result: (MOVDload [off1-off2] {sym} ptr mem) 6766 for { 6767 off1 := v.AuxInt 6768 sym := v.Aux 6769 _ = v.Args[1] 6770 v_0 := v.Args[0] 6771 if v_0.Op != OpARMSUBconst { 6772 break 6773 } 6774 off2 := v_0.AuxInt 6775 ptr := v_0.Args[0] 6776 mem := v.Args[1] 6777 v.reset(OpARMMOVDload) 6778 v.AuxInt = off1 - off2 6779 v.Aux = sym 6780 v.AddArg(ptr) 6781 v.AddArg(mem) 6782 return true 6783 } 6784 // match: (MOVDload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 6785 // cond: canMergeSym(sym1,sym2) 6786 // result: (MOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 6787 for { 6788 off1 := v.AuxInt 6789 sym1 := v.Aux 6790 _ = v.Args[1] 6791 v_0 := v.Args[0] 6792 if v_0.Op != OpARMMOVWaddr { 6793 break 6794 } 6795 off2 := v_0.AuxInt 6796 sym2 := v_0.Aux 6797 ptr := v_0.Args[0] 6798 mem := v.Args[1] 6799 if !(canMergeSym(sym1, sym2)) { 6800 break 6801 } 6802 v.reset(OpARMMOVDload) 6803 v.AuxInt = off1 + off2 6804 v.Aux = mergeSym(sym1, sym2) 6805 v.AddArg(ptr) 6806 v.AddArg(mem) 6807 return true 6808 } 6809 // match: (MOVDload [off] {sym} ptr (MOVDstore [off2] {sym2} ptr2 x _)) 6810 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 6811 // result: x 6812 for { 6813 off := v.AuxInt 6814 sym := v.Aux 6815 _ = v.Args[1] 6816 ptr := v.Args[0] 6817 v_1 := v.Args[1] 6818 if v_1.Op != OpARMMOVDstore { 6819 break 6820 } 6821 off2 := v_1.AuxInt 6822 sym2 := v_1.Aux 6823 _ = v_1.Args[2] 6824 ptr2 := v_1.Args[0] 6825 x := v_1.Args[1] 6826 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 6827 break 6828 } 6829 v.reset(OpCopy) 6830 v.Type = x.Type 6831 v.AddArg(x) 6832 return true 6833 } 6834 return false 6835 } 6836 func rewriteValueARM_OpARMMOVDstore_0(v *Value) bool { 6837 // match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem) 6838 // cond: 6839 // result: (MOVDstore [off1+off2] {sym} ptr val mem) 6840 for { 6841 off1 := v.AuxInt 6842 sym := v.Aux 6843 _ = v.Args[2] 6844 v_0 := v.Args[0] 6845 if v_0.Op != OpARMADDconst { 6846 break 6847 } 6848 off2 := v_0.AuxInt 6849 ptr := v_0.Args[0] 6850 val := v.Args[1] 6851 mem := v.Args[2] 6852 v.reset(OpARMMOVDstore) 6853 v.AuxInt = off1 + off2 6854 v.Aux = sym 6855 v.AddArg(ptr) 6856 v.AddArg(val) 6857 v.AddArg(mem) 6858 return true 6859 } 6860 // match: (MOVDstore [off1] {sym} (SUBconst [off2] ptr) val mem) 6861 // cond: 6862 // result: (MOVDstore [off1-off2] {sym} ptr val mem) 6863 for { 6864 off1 := v.AuxInt 6865 sym := v.Aux 6866 _ = v.Args[2] 6867 v_0 := v.Args[0] 6868 if v_0.Op != OpARMSUBconst { 6869 break 6870 } 6871 off2 := v_0.AuxInt 6872 ptr := v_0.Args[0] 6873 val := v.Args[1] 6874 mem := v.Args[2] 6875 v.reset(OpARMMOVDstore) 6876 v.AuxInt = off1 - off2 6877 v.Aux = sym 6878 v.AddArg(ptr) 6879 v.AddArg(val) 6880 v.AddArg(mem) 6881 return true 6882 } 6883 // match: (MOVDstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem) 6884 // cond: canMergeSym(sym1,sym2) 6885 // result: (MOVDstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem) 6886 for { 6887 off1 := v.AuxInt 6888 sym1 := v.Aux 6889 _ = v.Args[2] 6890 v_0 := v.Args[0] 6891 if v_0.Op != OpARMMOVWaddr { 6892 break 6893 } 6894 off2 := v_0.AuxInt 6895 sym2 := v_0.Aux 6896 ptr := v_0.Args[0] 6897 val := v.Args[1] 6898 mem := v.Args[2] 6899 if !(canMergeSym(sym1, sym2)) { 6900 break 6901 } 6902 v.reset(OpARMMOVDstore) 6903 v.AuxInt = off1 + off2 6904 v.Aux = mergeSym(sym1, sym2) 6905 v.AddArg(ptr) 6906 v.AddArg(val) 6907 v.AddArg(mem) 6908 return true 6909 } 6910 return false 6911 } 6912 func rewriteValueARM_OpARMMOVFload_0(v *Value) bool { 6913 // match: (MOVFload [off1] {sym} (ADDconst [off2] ptr) mem) 6914 // cond: 6915 // result: (MOVFload [off1+off2] {sym} ptr mem) 6916 for { 6917 off1 := v.AuxInt 6918 sym := v.Aux 6919 _ = v.Args[1] 6920 v_0 := v.Args[0] 6921 if v_0.Op != OpARMADDconst { 6922 break 6923 } 6924 off2 := v_0.AuxInt 6925 ptr := v_0.Args[0] 6926 mem := v.Args[1] 6927 v.reset(OpARMMOVFload) 6928 v.AuxInt = off1 + off2 6929 v.Aux = sym 6930 v.AddArg(ptr) 6931 v.AddArg(mem) 6932 return true 6933 } 6934 // match: (MOVFload [off1] {sym} (SUBconst [off2] ptr) mem) 6935 // cond: 6936 // result: (MOVFload [off1-off2] {sym} ptr mem) 6937 for { 6938 off1 := v.AuxInt 6939 sym := v.Aux 6940 _ = v.Args[1] 6941 v_0 := v.Args[0] 6942 if v_0.Op != OpARMSUBconst { 6943 break 6944 } 6945 off2 := v_0.AuxInt 6946 ptr := v_0.Args[0] 6947 mem := v.Args[1] 6948 v.reset(OpARMMOVFload) 6949 v.AuxInt = off1 - off2 6950 v.Aux = sym 6951 v.AddArg(ptr) 6952 v.AddArg(mem) 6953 return true 6954 } 6955 // match: (MOVFload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 6956 // cond: canMergeSym(sym1,sym2) 6957 // result: (MOVFload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 6958 for { 6959 off1 := v.AuxInt 6960 sym1 := v.Aux 6961 _ = v.Args[1] 6962 v_0 := v.Args[0] 6963 if v_0.Op != OpARMMOVWaddr { 6964 break 6965 } 6966 off2 := v_0.AuxInt 6967 sym2 := v_0.Aux 6968 ptr := v_0.Args[0] 6969 mem := v.Args[1] 6970 if !(canMergeSym(sym1, sym2)) { 6971 break 6972 } 6973 v.reset(OpARMMOVFload) 6974 v.AuxInt = off1 + off2 6975 v.Aux = mergeSym(sym1, sym2) 6976 v.AddArg(ptr) 6977 v.AddArg(mem) 6978 return true 6979 } 6980 // match: (MOVFload [off] {sym} ptr (MOVFstore [off2] {sym2} ptr2 x _)) 6981 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 6982 // result: x 6983 for { 6984 off := v.AuxInt 6985 sym := v.Aux 6986 _ = v.Args[1] 6987 ptr := v.Args[0] 6988 v_1 := v.Args[1] 6989 if v_1.Op != OpARMMOVFstore { 6990 break 6991 } 6992 off2 := v_1.AuxInt 6993 sym2 := v_1.Aux 6994 _ = v_1.Args[2] 6995 ptr2 := v_1.Args[0] 6996 x := v_1.Args[1] 6997 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 6998 break 6999 } 7000 v.reset(OpCopy) 7001 v.Type = x.Type 7002 v.AddArg(x) 7003 return true 7004 } 7005 return false 7006 } 7007 func rewriteValueARM_OpARMMOVFstore_0(v *Value) bool { 7008 // match: (MOVFstore [off1] {sym} (ADDconst [off2] ptr) val mem) 7009 // cond: 7010 // result: (MOVFstore [off1+off2] {sym} ptr val mem) 7011 for { 7012 off1 := v.AuxInt 7013 sym := v.Aux 7014 _ = v.Args[2] 7015 v_0 := v.Args[0] 7016 if v_0.Op != OpARMADDconst { 7017 break 7018 } 7019 off2 := v_0.AuxInt 7020 ptr := v_0.Args[0] 7021 val := v.Args[1] 7022 mem := v.Args[2] 7023 v.reset(OpARMMOVFstore) 7024 v.AuxInt = off1 + off2 7025 v.Aux = sym 7026 v.AddArg(ptr) 7027 v.AddArg(val) 7028 v.AddArg(mem) 7029 return true 7030 } 7031 // match: (MOVFstore [off1] {sym} (SUBconst [off2] ptr) val mem) 7032 // cond: 7033 // result: (MOVFstore [off1-off2] {sym} ptr val mem) 7034 for { 7035 off1 := v.AuxInt 7036 sym := v.Aux 7037 _ = v.Args[2] 7038 v_0 := v.Args[0] 7039 if v_0.Op != OpARMSUBconst { 7040 break 7041 } 7042 off2 := v_0.AuxInt 7043 ptr := v_0.Args[0] 7044 val := v.Args[1] 7045 mem := v.Args[2] 7046 v.reset(OpARMMOVFstore) 7047 v.AuxInt = off1 - off2 7048 v.Aux = sym 7049 v.AddArg(ptr) 7050 v.AddArg(val) 7051 v.AddArg(mem) 7052 return true 7053 } 7054 // match: (MOVFstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem) 7055 // cond: canMergeSym(sym1,sym2) 7056 // result: (MOVFstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem) 7057 for { 7058 off1 := v.AuxInt 7059 sym1 := v.Aux 7060 _ = v.Args[2] 7061 v_0 := v.Args[0] 7062 if v_0.Op != OpARMMOVWaddr { 7063 break 7064 } 7065 off2 := v_0.AuxInt 7066 sym2 := v_0.Aux 7067 ptr := v_0.Args[0] 7068 val := v.Args[1] 7069 mem := v.Args[2] 7070 if !(canMergeSym(sym1, sym2)) { 7071 break 7072 } 7073 v.reset(OpARMMOVFstore) 7074 v.AuxInt = off1 + off2 7075 v.Aux = mergeSym(sym1, sym2) 7076 v.AddArg(ptr) 7077 v.AddArg(val) 7078 v.AddArg(mem) 7079 return true 7080 } 7081 return false 7082 } 7083 func rewriteValueARM_OpARMMOVHUload_0(v *Value) bool { 7084 b := v.Block 7085 _ = b 7086 config := b.Func.Config 7087 _ = config 7088 // match: (MOVHUload [off1] {sym} (ADDconst [off2] ptr) mem) 7089 // cond: 7090 // result: (MOVHUload [off1+off2] {sym} ptr mem) 7091 for { 7092 off1 := v.AuxInt 7093 sym := v.Aux 7094 _ = v.Args[1] 7095 v_0 := v.Args[0] 7096 if v_0.Op != OpARMADDconst { 7097 break 7098 } 7099 off2 := v_0.AuxInt 7100 ptr := v_0.Args[0] 7101 mem := v.Args[1] 7102 v.reset(OpARMMOVHUload) 7103 v.AuxInt = off1 + off2 7104 v.Aux = sym 7105 v.AddArg(ptr) 7106 v.AddArg(mem) 7107 return true 7108 } 7109 // match: (MOVHUload [off1] {sym} (SUBconst [off2] ptr) mem) 7110 // cond: 7111 // result: (MOVHUload [off1-off2] {sym} ptr mem) 7112 for { 7113 off1 := v.AuxInt 7114 sym := v.Aux 7115 _ = v.Args[1] 7116 v_0 := v.Args[0] 7117 if v_0.Op != OpARMSUBconst { 7118 break 7119 } 7120 off2 := v_0.AuxInt 7121 ptr := v_0.Args[0] 7122 mem := v.Args[1] 7123 v.reset(OpARMMOVHUload) 7124 v.AuxInt = off1 - off2 7125 v.Aux = sym 7126 v.AddArg(ptr) 7127 v.AddArg(mem) 7128 return true 7129 } 7130 // match: (MOVHUload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 7131 // cond: canMergeSym(sym1,sym2) 7132 // result: (MOVHUload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 7133 for { 7134 off1 := v.AuxInt 7135 sym1 := v.Aux 7136 _ = v.Args[1] 7137 v_0 := v.Args[0] 7138 if v_0.Op != OpARMMOVWaddr { 7139 break 7140 } 7141 off2 := v_0.AuxInt 7142 sym2 := v_0.Aux 7143 ptr := v_0.Args[0] 7144 mem := v.Args[1] 7145 if !(canMergeSym(sym1, sym2)) { 7146 break 7147 } 7148 v.reset(OpARMMOVHUload) 7149 v.AuxInt = off1 + off2 7150 v.Aux = mergeSym(sym1, sym2) 7151 v.AddArg(ptr) 7152 v.AddArg(mem) 7153 return true 7154 } 7155 // match: (MOVHUload [off] {sym} ptr (MOVHstore [off2] {sym2} ptr2 x _)) 7156 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 7157 // result: (MOVHUreg x) 7158 for { 7159 off := v.AuxInt 7160 sym := v.Aux 7161 _ = v.Args[1] 7162 ptr := v.Args[0] 7163 v_1 := v.Args[1] 7164 if v_1.Op != OpARMMOVHstore { 7165 break 7166 } 7167 off2 := v_1.AuxInt 7168 sym2 := v_1.Aux 7169 _ = v_1.Args[2] 7170 ptr2 := v_1.Args[0] 7171 x := v_1.Args[1] 7172 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 7173 break 7174 } 7175 v.reset(OpARMMOVHUreg) 7176 v.AddArg(x) 7177 return true 7178 } 7179 // match: (MOVHUload [0] {sym} (ADD ptr idx) mem) 7180 // cond: sym == nil && !config.nacl 7181 // result: (MOVHUloadidx ptr idx mem) 7182 for { 7183 if v.AuxInt != 0 { 7184 break 7185 } 7186 sym := v.Aux 7187 _ = v.Args[1] 7188 v_0 := v.Args[0] 7189 if v_0.Op != OpARMADD { 7190 break 7191 } 7192 _ = v_0.Args[1] 7193 ptr := v_0.Args[0] 7194 idx := v_0.Args[1] 7195 mem := v.Args[1] 7196 if !(sym == nil && !config.nacl) { 7197 break 7198 } 7199 v.reset(OpARMMOVHUloadidx) 7200 v.AddArg(ptr) 7201 v.AddArg(idx) 7202 v.AddArg(mem) 7203 return true 7204 } 7205 return false 7206 } 7207 func rewriteValueARM_OpARMMOVHUloadidx_0(v *Value) bool { 7208 // match: (MOVHUloadidx ptr idx (MOVHstoreidx ptr2 idx x _)) 7209 // cond: isSamePtr(ptr, ptr2) 7210 // result: (MOVHUreg x) 7211 for { 7212 _ = v.Args[2] 7213 ptr := v.Args[0] 7214 idx := v.Args[1] 7215 v_2 := v.Args[2] 7216 if v_2.Op != OpARMMOVHstoreidx { 7217 break 7218 } 7219 _ = v_2.Args[3] 7220 ptr2 := v_2.Args[0] 7221 if idx != v_2.Args[1] { 7222 break 7223 } 7224 x := v_2.Args[2] 7225 if !(isSamePtr(ptr, ptr2)) { 7226 break 7227 } 7228 v.reset(OpARMMOVHUreg) 7229 v.AddArg(x) 7230 return true 7231 } 7232 // match: (MOVHUloadidx ptr (MOVWconst [c]) mem) 7233 // cond: 7234 // result: (MOVHUload [c] ptr mem) 7235 for { 7236 _ = v.Args[2] 7237 ptr := v.Args[0] 7238 v_1 := v.Args[1] 7239 if v_1.Op != OpARMMOVWconst { 7240 break 7241 } 7242 c := v_1.AuxInt 7243 mem := v.Args[2] 7244 v.reset(OpARMMOVHUload) 7245 v.AuxInt = c 7246 v.AddArg(ptr) 7247 v.AddArg(mem) 7248 return true 7249 } 7250 // match: (MOVHUloadidx (MOVWconst [c]) ptr mem) 7251 // cond: 7252 // result: (MOVHUload [c] ptr mem) 7253 for { 7254 _ = v.Args[2] 7255 v_0 := v.Args[0] 7256 if v_0.Op != OpARMMOVWconst { 7257 break 7258 } 7259 c := v_0.AuxInt 7260 ptr := v.Args[1] 7261 mem := v.Args[2] 7262 v.reset(OpARMMOVHUload) 7263 v.AuxInt = c 7264 v.AddArg(ptr) 7265 v.AddArg(mem) 7266 return true 7267 } 7268 return false 7269 } 7270 func rewriteValueARM_OpARMMOVHUreg_0(v *Value) bool { 7271 // match: (MOVHUreg x:(MOVBUload _ _)) 7272 // cond: 7273 // result: (MOVWreg x) 7274 for { 7275 x := v.Args[0] 7276 if x.Op != OpARMMOVBUload { 7277 break 7278 } 7279 _ = x.Args[1] 7280 v.reset(OpARMMOVWreg) 7281 v.AddArg(x) 7282 return true 7283 } 7284 // match: (MOVHUreg x:(MOVHUload _ _)) 7285 // cond: 7286 // result: (MOVWreg x) 7287 for { 7288 x := v.Args[0] 7289 if x.Op != OpARMMOVHUload { 7290 break 7291 } 7292 _ = x.Args[1] 7293 v.reset(OpARMMOVWreg) 7294 v.AddArg(x) 7295 return true 7296 } 7297 // match: (MOVHUreg (ANDconst [c] x)) 7298 // cond: 7299 // result: (ANDconst [c&0xffff] x) 7300 for { 7301 v_0 := v.Args[0] 7302 if v_0.Op != OpARMANDconst { 7303 break 7304 } 7305 c := v_0.AuxInt 7306 x := v_0.Args[0] 7307 v.reset(OpARMANDconst) 7308 v.AuxInt = c & 0xffff 7309 v.AddArg(x) 7310 return true 7311 } 7312 // match: (MOVHUreg x:(MOVBUreg _)) 7313 // cond: 7314 // result: (MOVWreg x) 7315 for { 7316 x := v.Args[0] 7317 if x.Op != OpARMMOVBUreg { 7318 break 7319 } 7320 v.reset(OpARMMOVWreg) 7321 v.AddArg(x) 7322 return true 7323 } 7324 // match: (MOVHUreg x:(MOVHUreg _)) 7325 // cond: 7326 // result: (MOVWreg x) 7327 for { 7328 x := v.Args[0] 7329 if x.Op != OpARMMOVHUreg { 7330 break 7331 } 7332 v.reset(OpARMMOVWreg) 7333 v.AddArg(x) 7334 return true 7335 } 7336 // match: (MOVHUreg (MOVWconst [c])) 7337 // cond: 7338 // result: (MOVWconst [int64(uint16(c))]) 7339 for { 7340 v_0 := v.Args[0] 7341 if v_0.Op != OpARMMOVWconst { 7342 break 7343 } 7344 c := v_0.AuxInt 7345 v.reset(OpARMMOVWconst) 7346 v.AuxInt = int64(uint16(c)) 7347 return true 7348 } 7349 return false 7350 } 7351 func rewriteValueARM_OpARMMOVHload_0(v *Value) bool { 7352 b := v.Block 7353 _ = b 7354 config := b.Func.Config 7355 _ = config 7356 // match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem) 7357 // cond: 7358 // result: (MOVHload [off1+off2] {sym} ptr mem) 7359 for { 7360 off1 := v.AuxInt 7361 sym := v.Aux 7362 _ = v.Args[1] 7363 v_0 := v.Args[0] 7364 if v_0.Op != OpARMADDconst { 7365 break 7366 } 7367 off2 := v_0.AuxInt 7368 ptr := v_0.Args[0] 7369 mem := v.Args[1] 7370 v.reset(OpARMMOVHload) 7371 v.AuxInt = off1 + off2 7372 v.Aux = sym 7373 v.AddArg(ptr) 7374 v.AddArg(mem) 7375 return true 7376 } 7377 // match: (MOVHload [off1] {sym} (SUBconst [off2] ptr) mem) 7378 // cond: 7379 // result: (MOVHload [off1-off2] {sym} ptr mem) 7380 for { 7381 off1 := v.AuxInt 7382 sym := v.Aux 7383 _ = v.Args[1] 7384 v_0 := v.Args[0] 7385 if v_0.Op != OpARMSUBconst { 7386 break 7387 } 7388 off2 := v_0.AuxInt 7389 ptr := v_0.Args[0] 7390 mem := v.Args[1] 7391 v.reset(OpARMMOVHload) 7392 v.AuxInt = off1 - off2 7393 v.Aux = sym 7394 v.AddArg(ptr) 7395 v.AddArg(mem) 7396 return true 7397 } 7398 // match: (MOVHload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 7399 // cond: canMergeSym(sym1,sym2) 7400 // result: (MOVHload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 7401 for { 7402 off1 := v.AuxInt 7403 sym1 := v.Aux 7404 _ = v.Args[1] 7405 v_0 := v.Args[0] 7406 if v_0.Op != OpARMMOVWaddr { 7407 break 7408 } 7409 off2 := v_0.AuxInt 7410 sym2 := v_0.Aux 7411 ptr := v_0.Args[0] 7412 mem := v.Args[1] 7413 if !(canMergeSym(sym1, sym2)) { 7414 break 7415 } 7416 v.reset(OpARMMOVHload) 7417 v.AuxInt = off1 + off2 7418 v.Aux = mergeSym(sym1, sym2) 7419 v.AddArg(ptr) 7420 v.AddArg(mem) 7421 return true 7422 } 7423 // match: (MOVHload [off] {sym} ptr (MOVHstore [off2] {sym2} ptr2 x _)) 7424 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 7425 // result: (MOVHreg x) 7426 for { 7427 off := v.AuxInt 7428 sym := v.Aux 7429 _ = v.Args[1] 7430 ptr := v.Args[0] 7431 v_1 := v.Args[1] 7432 if v_1.Op != OpARMMOVHstore { 7433 break 7434 } 7435 off2 := v_1.AuxInt 7436 sym2 := v_1.Aux 7437 _ = v_1.Args[2] 7438 ptr2 := v_1.Args[0] 7439 x := v_1.Args[1] 7440 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 7441 break 7442 } 7443 v.reset(OpARMMOVHreg) 7444 v.AddArg(x) 7445 return true 7446 } 7447 // match: (MOVHload [0] {sym} (ADD ptr idx) mem) 7448 // cond: sym == nil && !config.nacl 7449 // result: (MOVHloadidx ptr idx mem) 7450 for { 7451 if v.AuxInt != 0 { 7452 break 7453 } 7454 sym := v.Aux 7455 _ = v.Args[1] 7456 v_0 := v.Args[0] 7457 if v_0.Op != OpARMADD { 7458 break 7459 } 7460 _ = v_0.Args[1] 7461 ptr := v_0.Args[0] 7462 idx := v_0.Args[1] 7463 mem := v.Args[1] 7464 if !(sym == nil && !config.nacl) { 7465 break 7466 } 7467 v.reset(OpARMMOVHloadidx) 7468 v.AddArg(ptr) 7469 v.AddArg(idx) 7470 v.AddArg(mem) 7471 return true 7472 } 7473 return false 7474 } 7475 func rewriteValueARM_OpARMMOVHloadidx_0(v *Value) bool { 7476 // match: (MOVHloadidx ptr idx (MOVHstoreidx ptr2 idx x _)) 7477 // cond: isSamePtr(ptr, ptr2) 7478 // result: (MOVHreg x) 7479 for { 7480 _ = v.Args[2] 7481 ptr := v.Args[0] 7482 idx := v.Args[1] 7483 v_2 := v.Args[2] 7484 if v_2.Op != OpARMMOVHstoreidx { 7485 break 7486 } 7487 _ = v_2.Args[3] 7488 ptr2 := v_2.Args[0] 7489 if idx != v_2.Args[1] { 7490 break 7491 } 7492 x := v_2.Args[2] 7493 if !(isSamePtr(ptr, ptr2)) { 7494 break 7495 } 7496 v.reset(OpARMMOVHreg) 7497 v.AddArg(x) 7498 return true 7499 } 7500 // match: (MOVHloadidx ptr (MOVWconst [c]) mem) 7501 // cond: 7502 // result: (MOVHload [c] ptr mem) 7503 for { 7504 _ = v.Args[2] 7505 ptr := v.Args[0] 7506 v_1 := v.Args[1] 7507 if v_1.Op != OpARMMOVWconst { 7508 break 7509 } 7510 c := v_1.AuxInt 7511 mem := v.Args[2] 7512 v.reset(OpARMMOVHload) 7513 v.AuxInt = c 7514 v.AddArg(ptr) 7515 v.AddArg(mem) 7516 return true 7517 } 7518 // match: (MOVHloadidx (MOVWconst [c]) ptr mem) 7519 // cond: 7520 // result: (MOVHload [c] ptr mem) 7521 for { 7522 _ = v.Args[2] 7523 v_0 := v.Args[0] 7524 if v_0.Op != OpARMMOVWconst { 7525 break 7526 } 7527 c := v_0.AuxInt 7528 ptr := v.Args[1] 7529 mem := v.Args[2] 7530 v.reset(OpARMMOVHload) 7531 v.AuxInt = c 7532 v.AddArg(ptr) 7533 v.AddArg(mem) 7534 return true 7535 } 7536 return false 7537 } 7538 func rewriteValueARM_OpARMMOVHreg_0(v *Value) bool { 7539 // match: (MOVHreg x:(MOVBload _ _)) 7540 // cond: 7541 // result: (MOVWreg x) 7542 for { 7543 x := v.Args[0] 7544 if x.Op != OpARMMOVBload { 7545 break 7546 } 7547 _ = x.Args[1] 7548 v.reset(OpARMMOVWreg) 7549 v.AddArg(x) 7550 return true 7551 } 7552 // match: (MOVHreg x:(MOVBUload _ _)) 7553 // cond: 7554 // result: (MOVWreg x) 7555 for { 7556 x := v.Args[0] 7557 if x.Op != OpARMMOVBUload { 7558 break 7559 } 7560 _ = x.Args[1] 7561 v.reset(OpARMMOVWreg) 7562 v.AddArg(x) 7563 return true 7564 } 7565 // match: (MOVHreg x:(MOVHload _ _)) 7566 // cond: 7567 // result: (MOVWreg x) 7568 for { 7569 x := v.Args[0] 7570 if x.Op != OpARMMOVHload { 7571 break 7572 } 7573 _ = x.Args[1] 7574 v.reset(OpARMMOVWreg) 7575 v.AddArg(x) 7576 return true 7577 } 7578 // match: (MOVHreg (ANDconst [c] x)) 7579 // cond: c & 0x8000 == 0 7580 // result: (ANDconst [c&0x7fff] x) 7581 for { 7582 v_0 := v.Args[0] 7583 if v_0.Op != OpARMANDconst { 7584 break 7585 } 7586 c := v_0.AuxInt 7587 x := v_0.Args[0] 7588 if !(c&0x8000 == 0) { 7589 break 7590 } 7591 v.reset(OpARMANDconst) 7592 v.AuxInt = c & 0x7fff 7593 v.AddArg(x) 7594 return true 7595 } 7596 // match: (MOVHreg x:(MOVBreg _)) 7597 // cond: 7598 // result: (MOVWreg x) 7599 for { 7600 x := v.Args[0] 7601 if x.Op != OpARMMOVBreg { 7602 break 7603 } 7604 v.reset(OpARMMOVWreg) 7605 v.AddArg(x) 7606 return true 7607 } 7608 // match: (MOVHreg x:(MOVBUreg _)) 7609 // cond: 7610 // result: (MOVWreg x) 7611 for { 7612 x := v.Args[0] 7613 if x.Op != OpARMMOVBUreg { 7614 break 7615 } 7616 v.reset(OpARMMOVWreg) 7617 v.AddArg(x) 7618 return true 7619 } 7620 // match: (MOVHreg x:(MOVHreg _)) 7621 // cond: 7622 // result: (MOVWreg x) 7623 for { 7624 x := v.Args[0] 7625 if x.Op != OpARMMOVHreg { 7626 break 7627 } 7628 v.reset(OpARMMOVWreg) 7629 v.AddArg(x) 7630 return true 7631 } 7632 // match: (MOVHreg (MOVWconst [c])) 7633 // cond: 7634 // result: (MOVWconst [int64(int16(c))]) 7635 for { 7636 v_0 := v.Args[0] 7637 if v_0.Op != OpARMMOVWconst { 7638 break 7639 } 7640 c := v_0.AuxInt 7641 v.reset(OpARMMOVWconst) 7642 v.AuxInt = int64(int16(c)) 7643 return true 7644 } 7645 return false 7646 } 7647 func rewriteValueARM_OpARMMOVHstore_0(v *Value) bool { 7648 b := v.Block 7649 _ = b 7650 config := b.Func.Config 7651 _ = config 7652 // match: (MOVHstore [off1] {sym} (ADDconst [off2] ptr) val mem) 7653 // cond: 7654 // result: (MOVHstore [off1+off2] {sym} ptr val mem) 7655 for { 7656 off1 := v.AuxInt 7657 sym := v.Aux 7658 _ = v.Args[2] 7659 v_0 := v.Args[0] 7660 if v_0.Op != OpARMADDconst { 7661 break 7662 } 7663 off2 := v_0.AuxInt 7664 ptr := v_0.Args[0] 7665 val := v.Args[1] 7666 mem := v.Args[2] 7667 v.reset(OpARMMOVHstore) 7668 v.AuxInt = off1 + off2 7669 v.Aux = sym 7670 v.AddArg(ptr) 7671 v.AddArg(val) 7672 v.AddArg(mem) 7673 return true 7674 } 7675 // match: (MOVHstore [off1] {sym} (SUBconst [off2] ptr) val mem) 7676 // cond: 7677 // result: (MOVHstore [off1-off2] {sym} ptr val mem) 7678 for { 7679 off1 := v.AuxInt 7680 sym := v.Aux 7681 _ = v.Args[2] 7682 v_0 := v.Args[0] 7683 if v_0.Op != OpARMSUBconst { 7684 break 7685 } 7686 off2 := v_0.AuxInt 7687 ptr := v_0.Args[0] 7688 val := v.Args[1] 7689 mem := v.Args[2] 7690 v.reset(OpARMMOVHstore) 7691 v.AuxInt = off1 - off2 7692 v.Aux = sym 7693 v.AddArg(ptr) 7694 v.AddArg(val) 7695 v.AddArg(mem) 7696 return true 7697 } 7698 // match: (MOVHstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem) 7699 // cond: canMergeSym(sym1,sym2) 7700 // result: (MOVHstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem) 7701 for { 7702 off1 := v.AuxInt 7703 sym1 := v.Aux 7704 _ = v.Args[2] 7705 v_0 := v.Args[0] 7706 if v_0.Op != OpARMMOVWaddr { 7707 break 7708 } 7709 off2 := v_0.AuxInt 7710 sym2 := v_0.Aux 7711 ptr := v_0.Args[0] 7712 val := v.Args[1] 7713 mem := v.Args[2] 7714 if !(canMergeSym(sym1, sym2)) { 7715 break 7716 } 7717 v.reset(OpARMMOVHstore) 7718 v.AuxInt = off1 + off2 7719 v.Aux = mergeSym(sym1, sym2) 7720 v.AddArg(ptr) 7721 v.AddArg(val) 7722 v.AddArg(mem) 7723 return true 7724 } 7725 // match: (MOVHstore [off] {sym} ptr (MOVHreg x) mem) 7726 // cond: 7727 // result: (MOVHstore [off] {sym} ptr x mem) 7728 for { 7729 off := v.AuxInt 7730 sym := v.Aux 7731 _ = v.Args[2] 7732 ptr := v.Args[0] 7733 v_1 := v.Args[1] 7734 if v_1.Op != OpARMMOVHreg { 7735 break 7736 } 7737 x := v_1.Args[0] 7738 mem := v.Args[2] 7739 v.reset(OpARMMOVHstore) 7740 v.AuxInt = off 7741 v.Aux = sym 7742 v.AddArg(ptr) 7743 v.AddArg(x) 7744 v.AddArg(mem) 7745 return true 7746 } 7747 // match: (MOVHstore [off] {sym} ptr (MOVHUreg x) mem) 7748 // cond: 7749 // result: (MOVHstore [off] {sym} ptr x mem) 7750 for { 7751 off := v.AuxInt 7752 sym := v.Aux 7753 _ = v.Args[2] 7754 ptr := v.Args[0] 7755 v_1 := v.Args[1] 7756 if v_1.Op != OpARMMOVHUreg { 7757 break 7758 } 7759 x := v_1.Args[0] 7760 mem := v.Args[2] 7761 v.reset(OpARMMOVHstore) 7762 v.AuxInt = off 7763 v.Aux = sym 7764 v.AddArg(ptr) 7765 v.AddArg(x) 7766 v.AddArg(mem) 7767 return true 7768 } 7769 // match: (MOVHstore [0] {sym} (ADD ptr idx) val mem) 7770 // cond: sym == nil && !config.nacl 7771 // result: (MOVHstoreidx ptr idx val mem) 7772 for { 7773 if v.AuxInt != 0 { 7774 break 7775 } 7776 sym := v.Aux 7777 _ = v.Args[2] 7778 v_0 := v.Args[0] 7779 if v_0.Op != OpARMADD { 7780 break 7781 } 7782 _ = v_0.Args[1] 7783 ptr := v_0.Args[0] 7784 idx := v_0.Args[1] 7785 val := v.Args[1] 7786 mem := v.Args[2] 7787 if !(sym == nil && !config.nacl) { 7788 break 7789 } 7790 v.reset(OpARMMOVHstoreidx) 7791 v.AddArg(ptr) 7792 v.AddArg(idx) 7793 v.AddArg(val) 7794 v.AddArg(mem) 7795 return true 7796 } 7797 return false 7798 } 7799 func rewriteValueARM_OpARMMOVHstoreidx_0(v *Value) bool { 7800 // match: (MOVHstoreidx ptr (MOVWconst [c]) val mem) 7801 // cond: 7802 // result: (MOVHstore [c] ptr val mem) 7803 for { 7804 _ = v.Args[3] 7805 ptr := v.Args[0] 7806 v_1 := v.Args[1] 7807 if v_1.Op != OpARMMOVWconst { 7808 break 7809 } 7810 c := v_1.AuxInt 7811 val := v.Args[2] 7812 mem := v.Args[3] 7813 v.reset(OpARMMOVHstore) 7814 v.AuxInt = c 7815 v.AddArg(ptr) 7816 v.AddArg(val) 7817 v.AddArg(mem) 7818 return true 7819 } 7820 // match: (MOVHstoreidx (MOVWconst [c]) ptr val mem) 7821 // cond: 7822 // result: (MOVHstore [c] ptr val mem) 7823 for { 7824 _ = v.Args[3] 7825 v_0 := v.Args[0] 7826 if v_0.Op != OpARMMOVWconst { 7827 break 7828 } 7829 c := v_0.AuxInt 7830 ptr := v.Args[1] 7831 val := v.Args[2] 7832 mem := v.Args[3] 7833 v.reset(OpARMMOVHstore) 7834 v.AuxInt = c 7835 v.AddArg(ptr) 7836 v.AddArg(val) 7837 v.AddArg(mem) 7838 return true 7839 } 7840 return false 7841 } 7842 func rewriteValueARM_OpARMMOVWload_0(v *Value) bool { 7843 b := v.Block 7844 _ = b 7845 config := b.Func.Config 7846 _ = config 7847 // match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem) 7848 // cond: 7849 // result: (MOVWload [off1+off2] {sym} ptr mem) 7850 for { 7851 off1 := v.AuxInt 7852 sym := v.Aux 7853 _ = v.Args[1] 7854 v_0 := v.Args[0] 7855 if v_0.Op != OpARMADDconst { 7856 break 7857 } 7858 off2 := v_0.AuxInt 7859 ptr := v_0.Args[0] 7860 mem := v.Args[1] 7861 v.reset(OpARMMOVWload) 7862 v.AuxInt = off1 + off2 7863 v.Aux = sym 7864 v.AddArg(ptr) 7865 v.AddArg(mem) 7866 return true 7867 } 7868 // match: (MOVWload [off1] {sym} (SUBconst [off2] ptr) mem) 7869 // cond: 7870 // result: (MOVWload [off1-off2] {sym} ptr mem) 7871 for { 7872 off1 := v.AuxInt 7873 sym := v.Aux 7874 _ = v.Args[1] 7875 v_0 := v.Args[0] 7876 if v_0.Op != OpARMSUBconst { 7877 break 7878 } 7879 off2 := v_0.AuxInt 7880 ptr := v_0.Args[0] 7881 mem := v.Args[1] 7882 v.reset(OpARMMOVWload) 7883 v.AuxInt = off1 - off2 7884 v.Aux = sym 7885 v.AddArg(ptr) 7886 v.AddArg(mem) 7887 return true 7888 } 7889 // match: (MOVWload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 7890 // cond: canMergeSym(sym1,sym2) 7891 // result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 7892 for { 7893 off1 := v.AuxInt 7894 sym1 := v.Aux 7895 _ = v.Args[1] 7896 v_0 := v.Args[0] 7897 if v_0.Op != OpARMMOVWaddr { 7898 break 7899 } 7900 off2 := v_0.AuxInt 7901 sym2 := v_0.Aux 7902 ptr := v_0.Args[0] 7903 mem := v.Args[1] 7904 if !(canMergeSym(sym1, sym2)) { 7905 break 7906 } 7907 v.reset(OpARMMOVWload) 7908 v.AuxInt = off1 + off2 7909 v.Aux = mergeSym(sym1, sym2) 7910 v.AddArg(ptr) 7911 v.AddArg(mem) 7912 return true 7913 } 7914 // match: (MOVWload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _)) 7915 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 7916 // result: x 7917 for { 7918 off := v.AuxInt 7919 sym := v.Aux 7920 _ = v.Args[1] 7921 ptr := v.Args[0] 7922 v_1 := v.Args[1] 7923 if v_1.Op != OpARMMOVWstore { 7924 break 7925 } 7926 off2 := v_1.AuxInt 7927 sym2 := v_1.Aux 7928 _ = v_1.Args[2] 7929 ptr2 := v_1.Args[0] 7930 x := v_1.Args[1] 7931 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 7932 break 7933 } 7934 v.reset(OpCopy) 7935 v.Type = x.Type 7936 v.AddArg(x) 7937 return true 7938 } 7939 // match: (MOVWload [0] {sym} (ADD ptr idx) mem) 7940 // cond: sym == nil && !config.nacl 7941 // result: (MOVWloadidx ptr idx mem) 7942 for { 7943 if v.AuxInt != 0 { 7944 break 7945 } 7946 sym := v.Aux 7947 _ = v.Args[1] 7948 v_0 := v.Args[0] 7949 if v_0.Op != OpARMADD { 7950 break 7951 } 7952 _ = v_0.Args[1] 7953 ptr := v_0.Args[0] 7954 idx := v_0.Args[1] 7955 mem := v.Args[1] 7956 if !(sym == nil && !config.nacl) { 7957 break 7958 } 7959 v.reset(OpARMMOVWloadidx) 7960 v.AddArg(ptr) 7961 v.AddArg(idx) 7962 v.AddArg(mem) 7963 return true 7964 } 7965 // match: (MOVWload [0] {sym} (ADDshiftLL ptr idx [c]) mem) 7966 // cond: sym == nil && !config.nacl 7967 // result: (MOVWloadshiftLL ptr idx [c] mem) 7968 for { 7969 if v.AuxInt != 0 { 7970 break 7971 } 7972 sym := v.Aux 7973 _ = v.Args[1] 7974 v_0 := v.Args[0] 7975 if v_0.Op != OpARMADDshiftLL { 7976 break 7977 } 7978 c := v_0.AuxInt 7979 _ = v_0.Args[1] 7980 ptr := v_0.Args[0] 7981 idx := v_0.Args[1] 7982 mem := v.Args[1] 7983 if !(sym == nil && !config.nacl) { 7984 break 7985 } 7986 v.reset(OpARMMOVWloadshiftLL) 7987 v.AuxInt = c 7988 v.AddArg(ptr) 7989 v.AddArg(idx) 7990 v.AddArg(mem) 7991 return true 7992 } 7993 // match: (MOVWload [0] {sym} (ADDshiftRL ptr idx [c]) mem) 7994 // cond: sym == nil && !config.nacl 7995 // result: (MOVWloadshiftRL ptr idx [c] mem) 7996 for { 7997 if v.AuxInt != 0 { 7998 break 7999 } 8000 sym := v.Aux 8001 _ = v.Args[1] 8002 v_0 := v.Args[0] 8003 if v_0.Op != OpARMADDshiftRL { 8004 break 8005 } 8006 c := v_0.AuxInt 8007 _ = v_0.Args[1] 8008 ptr := v_0.Args[0] 8009 idx := v_0.Args[1] 8010 mem := v.Args[1] 8011 if !(sym == nil && !config.nacl) { 8012 break 8013 } 8014 v.reset(OpARMMOVWloadshiftRL) 8015 v.AuxInt = c 8016 v.AddArg(ptr) 8017 v.AddArg(idx) 8018 v.AddArg(mem) 8019 return true 8020 } 8021 // match: (MOVWload [0] {sym} (ADDshiftRA ptr idx [c]) mem) 8022 // cond: sym == nil && !config.nacl 8023 // result: (MOVWloadshiftRA ptr idx [c] mem) 8024 for { 8025 if v.AuxInt != 0 { 8026 break 8027 } 8028 sym := v.Aux 8029 _ = v.Args[1] 8030 v_0 := v.Args[0] 8031 if v_0.Op != OpARMADDshiftRA { 8032 break 8033 } 8034 c := v_0.AuxInt 8035 _ = v_0.Args[1] 8036 ptr := v_0.Args[0] 8037 idx := v_0.Args[1] 8038 mem := v.Args[1] 8039 if !(sym == nil && !config.nacl) { 8040 break 8041 } 8042 v.reset(OpARMMOVWloadshiftRA) 8043 v.AuxInt = c 8044 v.AddArg(ptr) 8045 v.AddArg(idx) 8046 v.AddArg(mem) 8047 return true 8048 } 8049 return false 8050 } 8051 func rewriteValueARM_OpARMMOVWloadidx_0(v *Value) bool { 8052 // match: (MOVWloadidx ptr idx (MOVWstoreidx ptr2 idx x _)) 8053 // cond: isSamePtr(ptr, ptr2) 8054 // result: x 8055 for { 8056 _ = v.Args[2] 8057 ptr := v.Args[0] 8058 idx := v.Args[1] 8059 v_2 := v.Args[2] 8060 if v_2.Op != OpARMMOVWstoreidx { 8061 break 8062 } 8063 _ = v_2.Args[3] 8064 ptr2 := v_2.Args[0] 8065 if idx != v_2.Args[1] { 8066 break 8067 } 8068 x := v_2.Args[2] 8069 if !(isSamePtr(ptr, ptr2)) { 8070 break 8071 } 8072 v.reset(OpCopy) 8073 v.Type = x.Type 8074 v.AddArg(x) 8075 return true 8076 } 8077 // match: (MOVWloadidx ptr (MOVWconst [c]) mem) 8078 // cond: 8079 // result: (MOVWload [c] ptr mem) 8080 for { 8081 _ = v.Args[2] 8082 ptr := v.Args[0] 8083 v_1 := v.Args[1] 8084 if v_1.Op != OpARMMOVWconst { 8085 break 8086 } 8087 c := v_1.AuxInt 8088 mem := v.Args[2] 8089 v.reset(OpARMMOVWload) 8090 v.AuxInt = c 8091 v.AddArg(ptr) 8092 v.AddArg(mem) 8093 return true 8094 } 8095 // match: (MOVWloadidx (MOVWconst [c]) ptr mem) 8096 // cond: 8097 // result: (MOVWload [c] ptr mem) 8098 for { 8099 _ = v.Args[2] 8100 v_0 := v.Args[0] 8101 if v_0.Op != OpARMMOVWconst { 8102 break 8103 } 8104 c := v_0.AuxInt 8105 ptr := v.Args[1] 8106 mem := v.Args[2] 8107 v.reset(OpARMMOVWload) 8108 v.AuxInt = c 8109 v.AddArg(ptr) 8110 v.AddArg(mem) 8111 return true 8112 } 8113 // match: (MOVWloadidx ptr (SLLconst idx [c]) mem) 8114 // cond: 8115 // result: (MOVWloadshiftLL ptr idx [c] mem) 8116 for { 8117 _ = v.Args[2] 8118 ptr := v.Args[0] 8119 v_1 := v.Args[1] 8120 if v_1.Op != OpARMSLLconst { 8121 break 8122 } 8123 c := v_1.AuxInt 8124 idx := v_1.Args[0] 8125 mem := v.Args[2] 8126 v.reset(OpARMMOVWloadshiftLL) 8127 v.AuxInt = c 8128 v.AddArg(ptr) 8129 v.AddArg(idx) 8130 v.AddArg(mem) 8131 return true 8132 } 8133 // match: (MOVWloadidx (SLLconst idx [c]) ptr mem) 8134 // cond: 8135 // result: (MOVWloadshiftLL ptr idx [c] mem) 8136 for { 8137 _ = v.Args[2] 8138 v_0 := v.Args[0] 8139 if v_0.Op != OpARMSLLconst { 8140 break 8141 } 8142 c := v_0.AuxInt 8143 idx := v_0.Args[0] 8144 ptr := v.Args[1] 8145 mem := v.Args[2] 8146 v.reset(OpARMMOVWloadshiftLL) 8147 v.AuxInt = c 8148 v.AddArg(ptr) 8149 v.AddArg(idx) 8150 v.AddArg(mem) 8151 return true 8152 } 8153 // match: (MOVWloadidx ptr (SRLconst idx [c]) mem) 8154 // cond: 8155 // result: (MOVWloadshiftRL ptr idx [c] mem) 8156 for { 8157 _ = v.Args[2] 8158 ptr := v.Args[0] 8159 v_1 := v.Args[1] 8160 if v_1.Op != OpARMSRLconst { 8161 break 8162 } 8163 c := v_1.AuxInt 8164 idx := v_1.Args[0] 8165 mem := v.Args[2] 8166 v.reset(OpARMMOVWloadshiftRL) 8167 v.AuxInt = c 8168 v.AddArg(ptr) 8169 v.AddArg(idx) 8170 v.AddArg(mem) 8171 return true 8172 } 8173 // match: (MOVWloadidx (SRLconst idx [c]) ptr mem) 8174 // cond: 8175 // result: (MOVWloadshiftRL ptr idx [c] mem) 8176 for { 8177 _ = v.Args[2] 8178 v_0 := v.Args[0] 8179 if v_0.Op != OpARMSRLconst { 8180 break 8181 } 8182 c := v_0.AuxInt 8183 idx := v_0.Args[0] 8184 ptr := v.Args[1] 8185 mem := v.Args[2] 8186 v.reset(OpARMMOVWloadshiftRL) 8187 v.AuxInt = c 8188 v.AddArg(ptr) 8189 v.AddArg(idx) 8190 v.AddArg(mem) 8191 return true 8192 } 8193 // match: (MOVWloadidx ptr (SRAconst idx [c]) mem) 8194 // cond: 8195 // result: (MOVWloadshiftRA ptr idx [c] mem) 8196 for { 8197 _ = v.Args[2] 8198 ptr := v.Args[0] 8199 v_1 := v.Args[1] 8200 if v_1.Op != OpARMSRAconst { 8201 break 8202 } 8203 c := v_1.AuxInt 8204 idx := v_1.Args[0] 8205 mem := v.Args[2] 8206 v.reset(OpARMMOVWloadshiftRA) 8207 v.AuxInt = c 8208 v.AddArg(ptr) 8209 v.AddArg(idx) 8210 v.AddArg(mem) 8211 return true 8212 } 8213 // match: (MOVWloadidx (SRAconst idx [c]) ptr mem) 8214 // cond: 8215 // result: (MOVWloadshiftRA ptr idx [c] mem) 8216 for { 8217 _ = v.Args[2] 8218 v_0 := v.Args[0] 8219 if v_0.Op != OpARMSRAconst { 8220 break 8221 } 8222 c := v_0.AuxInt 8223 idx := v_0.Args[0] 8224 ptr := v.Args[1] 8225 mem := v.Args[2] 8226 v.reset(OpARMMOVWloadshiftRA) 8227 v.AuxInt = c 8228 v.AddArg(ptr) 8229 v.AddArg(idx) 8230 v.AddArg(mem) 8231 return true 8232 } 8233 return false 8234 } 8235 func rewriteValueARM_OpARMMOVWloadshiftLL_0(v *Value) bool { 8236 // match: (MOVWloadshiftLL ptr idx [c] (MOVWstoreshiftLL ptr2 idx [d] x _)) 8237 // cond: c==d && isSamePtr(ptr, ptr2) 8238 // result: x 8239 for { 8240 c := v.AuxInt 8241 _ = v.Args[2] 8242 ptr := v.Args[0] 8243 idx := v.Args[1] 8244 v_2 := v.Args[2] 8245 if v_2.Op != OpARMMOVWstoreshiftLL { 8246 break 8247 } 8248 d := v_2.AuxInt 8249 _ = v_2.Args[3] 8250 ptr2 := v_2.Args[0] 8251 if idx != v_2.Args[1] { 8252 break 8253 } 8254 x := v_2.Args[2] 8255 if !(c == d && isSamePtr(ptr, ptr2)) { 8256 break 8257 } 8258 v.reset(OpCopy) 8259 v.Type = x.Type 8260 v.AddArg(x) 8261 return true 8262 } 8263 // match: (MOVWloadshiftLL ptr (MOVWconst [c]) [d] mem) 8264 // cond: 8265 // result: (MOVWload [int64(uint32(c)<<uint64(d))] ptr mem) 8266 for { 8267 d := v.AuxInt 8268 _ = v.Args[2] 8269 ptr := v.Args[0] 8270 v_1 := v.Args[1] 8271 if v_1.Op != OpARMMOVWconst { 8272 break 8273 } 8274 c := v_1.AuxInt 8275 mem := v.Args[2] 8276 v.reset(OpARMMOVWload) 8277 v.AuxInt = int64(uint32(c) << uint64(d)) 8278 v.AddArg(ptr) 8279 v.AddArg(mem) 8280 return true 8281 } 8282 return false 8283 } 8284 func rewriteValueARM_OpARMMOVWloadshiftRA_0(v *Value) bool { 8285 // match: (MOVWloadshiftRA ptr idx [c] (MOVWstoreshiftRA ptr2 idx [d] x _)) 8286 // cond: c==d && isSamePtr(ptr, ptr2) 8287 // result: x 8288 for { 8289 c := v.AuxInt 8290 _ = v.Args[2] 8291 ptr := v.Args[0] 8292 idx := v.Args[1] 8293 v_2 := v.Args[2] 8294 if v_2.Op != OpARMMOVWstoreshiftRA { 8295 break 8296 } 8297 d := v_2.AuxInt 8298 _ = v_2.Args[3] 8299 ptr2 := v_2.Args[0] 8300 if idx != v_2.Args[1] { 8301 break 8302 } 8303 x := v_2.Args[2] 8304 if !(c == d && isSamePtr(ptr, ptr2)) { 8305 break 8306 } 8307 v.reset(OpCopy) 8308 v.Type = x.Type 8309 v.AddArg(x) 8310 return true 8311 } 8312 // match: (MOVWloadshiftRA ptr (MOVWconst [c]) [d] mem) 8313 // cond: 8314 // result: (MOVWload [int64(int32(c)>>uint64(d))] ptr mem) 8315 for { 8316 d := v.AuxInt 8317 _ = v.Args[2] 8318 ptr := v.Args[0] 8319 v_1 := v.Args[1] 8320 if v_1.Op != OpARMMOVWconst { 8321 break 8322 } 8323 c := v_1.AuxInt 8324 mem := v.Args[2] 8325 v.reset(OpARMMOVWload) 8326 v.AuxInt = int64(int32(c) >> uint64(d)) 8327 v.AddArg(ptr) 8328 v.AddArg(mem) 8329 return true 8330 } 8331 return false 8332 } 8333 func rewriteValueARM_OpARMMOVWloadshiftRL_0(v *Value) bool { 8334 // match: (MOVWloadshiftRL ptr idx [c] (MOVWstoreshiftRL ptr2 idx [d] x _)) 8335 // cond: c==d && isSamePtr(ptr, ptr2) 8336 // result: x 8337 for { 8338 c := v.AuxInt 8339 _ = v.Args[2] 8340 ptr := v.Args[0] 8341 idx := v.Args[1] 8342 v_2 := v.Args[2] 8343 if v_2.Op != OpARMMOVWstoreshiftRL { 8344 break 8345 } 8346 d := v_2.AuxInt 8347 _ = v_2.Args[3] 8348 ptr2 := v_2.Args[0] 8349 if idx != v_2.Args[1] { 8350 break 8351 } 8352 x := v_2.Args[2] 8353 if !(c == d && isSamePtr(ptr, ptr2)) { 8354 break 8355 } 8356 v.reset(OpCopy) 8357 v.Type = x.Type 8358 v.AddArg(x) 8359 return true 8360 } 8361 // match: (MOVWloadshiftRL ptr (MOVWconst [c]) [d] mem) 8362 // cond: 8363 // result: (MOVWload [int64(uint32(c)>>uint64(d))] ptr mem) 8364 for { 8365 d := v.AuxInt 8366 _ = v.Args[2] 8367 ptr := v.Args[0] 8368 v_1 := v.Args[1] 8369 if v_1.Op != OpARMMOVWconst { 8370 break 8371 } 8372 c := v_1.AuxInt 8373 mem := v.Args[2] 8374 v.reset(OpARMMOVWload) 8375 v.AuxInt = int64(uint32(c) >> uint64(d)) 8376 v.AddArg(ptr) 8377 v.AddArg(mem) 8378 return true 8379 } 8380 return false 8381 } 8382 func rewriteValueARM_OpARMMOVWreg_0(v *Value) bool { 8383 // match: (MOVWreg x) 8384 // cond: x.Uses == 1 8385 // result: (MOVWnop x) 8386 for { 8387 x := v.Args[0] 8388 if !(x.Uses == 1) { 8389 break 8390 } 8391 v.reset(OpARMMOVWnop) 8392 v.AddArg(x) 8393 return true 8394 } 8395 // match: (MOVWreg (MOVWconst [c])) 8396 // cond: 8397 // result: (MOVWconst [c]) 8398 for { 8399 v_0 := v.Args[0] 8400 if v_0.Op != OpARMMOVWconst { 8401 break 8402 } 8403 c := v_0.AuxInt 8404 v.reset(OpARMMOVWconst) 8405 v.AuxInt = c 8406 return true 8407 } 8408 return false 8409 } 8410 func rewriteValueARM_OpARMMOVWstore_0(v *Value) bool { 8411 b := v.Block 8412 _ = b 8413 config := b.Func.Config 8414 _ = config 8415 // match: (MOVWstore [off1] {sym} (ADDconst [off2] ptr) val mem) 8416 // cond: 8417 // result: (MOVWstore [off1+off2] {sym} ptr val mem) 8418 for { 8419 off1 := v.AuxInt 8420 sym := v.Aux 8421 _ = v.Args[2] 8422 v_0 := v.Args[0] 8423 if v_0.Op != OpARMADDconst { 8424 break 8425 } 8426 off2 := v_0.AuxInt 8427 ptr := v_0.Args[0] 8428 val := v.Args[1] 8429 mem := v.Args[2] 8430 v.reset(OpARMMOVWstore) 8431 v.AuxInt = off1 + off2 8432 v.Aux = sym 8433 v.AddArg(ptr) 8434 v.AddArg(val) 8435 v.AddArg(mem) 8436 return true 8437 } 8438 // match: (MOVWstore [off1] {sym} (SUBconst [off2] ptr) val mem) 8439 // cond: 8440 // result: (MOVWstore [off1-off2] {sym} ptr val mem) 8441 for { 8442 off1 := v.AuxInt 8443 sym := v.Aux 8444 _ = v.Args[2] 8445 v_0 := v.Args[0] 8446 if v_0.Op != OpARMSUBconst { 8447 break 8448 } 8449 off2 := v_0.AuxInt 8450 ptr := v_0.Args[0] 8451 val := v.Args[1] 8452 mem := v.Args[2] 8453 v.reset(OpARMMOVWstore) 8454 v.AuxInt = off1 - off2 8455 v.Aux = sym 8456 v.AddArg(ptr) 8457 v.AddArg(val) 8458 v.AddArg(mem) 8459 return true 8460 } 8461 // match: (MOVWstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem) 8462 // cond: canMergeSym(sym1,sym2) 8463 // result: (MOVWstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem) 8464 for { 8465 off1 := v.AuxInt 8466 sym1 := v.Aux 8467 _ = v.Args[2] 8468 v_0 := v.Args[0] 8469 if v_0.Op != OpARMMOVWaddr { 8470 break 8471 } 8472 off2 := v_0.AuxInt 8473 sym2 := v_0.Aux 8474 ptr := v_0.Args[0] 8475 val := v.Args[1] 8476 mem := v.Args[2] 8477 if !(canMergeSym(sym1, sym2)) { 8478 break 8479 } 8480 v.reset(OpARMMOVWstore) 8481 v.AuxInt = off1 + off2 8482 v.Aux = mergeSym(sym1, sym2) 8483 v.AddArg(ptr) 8484 v.AddArg(val) 8485 v.AddArg(mem) 8486 return true 8487 } 8488 // match: (MOVWstore [0] {sym} (ADD ptr idx) val mem) 8489 // cond: sym == nil && !config.nacl 8490 // result: (MOVWstoreidx ptr idx val mem) 8491 for { 8492 if v.AuxInt != 0 { 8493 break 8494 } 8495 sym := v.Aux 8496 _ = v.Args[2] 8497 v_0 := v.Args[0] 8498 if v_0.Op != OpARMADD { 8499 break 8500 } 8501 _ = v_0.Args[1] 8502 ptr := v_0.Args[0] 8503 idx := v_0.Args[1] 8504 val := v.Args[1] 8505 mem := v.Args[2] 8506 if !(sym == nil && !config.nacl) { 8507 break 8508 } 8509 v.reset(OpARMMOVWstoreidx) 8510 v.AddArg(ptr) 8511 v.AddArg(idx) 8512 v.AddArg(val) 8513 v.AddArg(mem) 8514 return true 8515 } 8516 // match: (MOVWstore [0] {sym} (ADDshiftLL ptr idx [c]) val mem) 8517 // cond: sym == nil && !config.nacl 8518 // result: (MOVWstoreshiftLL ptr idx [c] val mem) 8519 for { 8520 if v.AuxInt != 0 { 8521 break 8522 } 8523 sym := v.Aux 8524 _ = v.Args[2] 8525 v_0 := v.Args[0] 8526 if v_0.Op != OpARMADDshiftLL { 8527 break 8528 } 8529 c := v_0.AuxInt 8530 _ = v_0.Args[1] 8531 ptr := v_0.Args[0] 8532 idx := v_0.Args[1] 8533 val := v.Args[1] 8534 mem := v.Args[2] 8535 if !(sym == nil && !config.nacl) { 8536 break 8537 } 8538 v.reset(OpARMMOVWstoreshiftLL) 8539 v.AuxInt = c 8540 v.AddArg(ptr) 8541 v.AddArg(idx) 8542 v.AddArg(val) 8543 v.AddArg(mem) 8544 return true 8545 } 8546 // match: (MOVWstore [0] {sym} (ADDshiftRL ptr idx [c]) val mem) 8547 // cond: sym == nil && !config.nacl 8548 // result: (MOVWstoreshiftRL ptr idx [c] val mem) 8549 for { 8550 if v.AuxInt != 0 { 8551 break 8552 } 8553 sym := v.Aux 8554 _ = v.Args[2] 8555 v_0 := v.Args[0] 8556 if v_0.Op != OpARMADDshiftRL { 8557 break 8558 } 8559 c := v_0.AuxInt 8560 _ = v_0.Args[1] 8561 ptr := v_0.Args[0] 8562 idx := v_0.Args[1] 8563 val := v.Args[1] 8564 mem := v.Args[2] 8565 if !(sym == nil && !config.nacl) { 8566 break 8567 } 8568 v.reset(OpARMMOVWstoreshiftRL) 8569 v.AuxInt = c 8570 v.AddArg(ptr) 8571 v.AddArg(idx) 8572 v.AddArg(val) 8573 v.AddArg(mem) 8574 return true 8575 } 8576 // match: (MOVWstore [0] {sym} (ADDshiftRA ptr idx [c]) val mem) 8577 // cond: sym == nil && !config.nacl 8578 // result: (MOVWstoreshiftRA ptr idx [c] val mem) 8579 for { 8580 if v.AuxInt != 0 { 8581 break 8582 } 8583 sym := v.Aux 8584 _ = v.Args[2] 8585 v_0 := v.Args[0] 8586 if v_0.Op != OpARMADDshiftRA { 8587 break 8588 } 8589 c := v_0.AuxInt 8590 _ = v_0.Args[1] 8591 ptr := v_0.Args[0] 8592 idx := v_0.Args[1] 8593 val := v.Args[1] 8594 mem := v.Args[2] 8595 if !(sym == nil && !config.nacl) { 8596 break 8597 } 8598 v.reset(OpARMMOVWstoreshiftRA) 8599 v.AuxInt = c 8600 v.AddArg(ptr) 8601 v.AddArg(idx) 8602 v.AddArg(val) 8603 v.AddArg(mem) 8604 return true 8605 } 8606 return false 8607 } 8608 func rewriteValueARM_OpARMMOVWstoreidx_0(v *Value) bool { 8609 // match: (MOVWstoreidx ptr (MOVWconst [c]) val mem) 8610 // cond: 8611 // result: (MOVWstore [c] ptr val mem) 8612 for { 8613 _ = v.Args[3] 8614 ptr := v.Args[0] 8615 v_1 := v.Args[1] 8616 if v_1.Op != OpARMMOVWconst { 8617 break 8618 } 8619 c := v_1.AuxInt 8620 val := v.Args[2] 8621 mem := v.Args[3] 8622 v.reset(OpARMMOVWstore) 8623 v.AuxInt = c 8624 v.AddArg(ptr) 8625 v.AddArg(val) 8626 v.AddArg(mem) 8627 return true 8628 } 8629 // match: (MOVWstoreidx (MOVWconst [c]) ptr val mem) 8630 // cond: 8631 // result: (MOVWstore [c] ptr val mem) 8632 for { 8633 _ = v.Args[3] 8634 v_0 := v.Args[0] 8635 if v_0.Op != OpARMMOVWconst { 8636 break 8637 } 8638 c := v_0.AuxInt 8639 ptr := v.Args[1] 8640 val := v.Args[2] 8641 mem := v.Args[3] 8642 v.reset(OpARMMOVWstore) 8643 v.AuxInt = c 8644 v.AddArg(ptr) 8645 v.AddArg(val) 8646 v.AddArg(mem) 8647 return true 8648 } 8649 // match: (MOVWstoreidx ptr (SLLconst idx [c]) val mem) 8650 // cond: 8651 // result: (MOVWstoreshiftLL ptr idx [c] val mem) 8652 for { 8653 _ = v.Args[3] 8654 ptr := v.Args[0] 8655 v_1 := v.Args[1] 8656 if v_1.Op != OpARMSLLconst { 8657 break 8658 } 8659 c := v_1.AuxInt 8660 idx := v_1.Args[0] 8661 val := v.Args[2] 8662 mem := v.Args[3] 8663 v.reset(OpARMMOVWstoreshiftLL) 8664 v.AuxInt = c 8665 v.AddArg(ptr) 8666 v.AddArg(idx) 8667 v.AddArg(val) 8668 v.AddArg(mem) 8669 return true 8670 } 8671 // match: (MOVWstoreidx (SLLconst idx [c]) ptr val mem) 8672 // cond: 8673 // result: (MOVWstoreshiftLL ptr idx [c] val mem) 8674 for { 8675 _ = v.Args[3] 8676 v_0 := v.Args[0] 8677 if v_0.Op != OpARMSLLconst { 8678 break 8679 } 8680 c := v_0.AuxInt 8681 idx := v_0.Args[0] 8682 ptr := v.Args[1] 8683 val := v.Args[2] 8684 mem := v.Args[3] 8685 v.reset(OpARMMOVWstoreshiftLL) 8686 v.AuxInt = c 8687 v.AddArg(ptr) 8688 v.AddArg(idx) 8689 v.AddArg(val) 8690 v.AddArg(mem) 8691 return true 8692 } 8693 // match: (MOVWstoreidx ptr (SRLconst idx [c]) val mem) 8694 // cond: 8695 // result: (MOVWstoreshiftRL ptr idx [c] val mem) 8696 for { 8697 _ = v.Args[3] 8698 ptr := v.Args[0] 8699 v_1 := v.Args[1] 8700 if v_1.Op != OpARMSRLconst { 8701 break 8702 } 8703 c := v_1.AuxInt 8704 idx := v_1.Args[0] 8705 val := v.Args[2] 8706 mem := v.Args[3] 8707 v.reset(OpARMMOVWstoreshiftRL) 8708 v.AuxInt = c 8709 v.AddArg(ptr) 8710 v.AddArg(idx) 8711 v.AddArg(val) 8712 v.AddArg(mem) 8713 return true 8714 } 8715 // match: (MOVWstoreidx (SRLconst idx [c]) ptr val mem) 8716 // cond: 8717 // result: (MOVWstoreshiftRL ptr idx [c] val mem) 8718 for { 8719 _ = v.Args[3] 8720 v_0 := v.Args[0] 8721 if v_0.Op != OpARMSRLconst { 8722 break 8723 } 8724 c := v_0.AuxInt 8725 idx := v_0.Args[0] 8726 ptr := v.Args[1] 8727 val := v.Args[2] 8728 mem := v.Args[3] 8729 v.reset(OpARMMOVWstoreshiftRL) 8730 v.AuxInt = c 8731 v.AddArg(ptr) 8732 v.AddArg(idx) 8733 v.AddArg(val) 8734 v.AddArg(mem) 8735 return true 8736 } 8737 // match: (MOVWstoreidx ptr (SRAconst idx [c]) val mem) 8738 // cond: 8739 // result: (MOVWstoreshiftRA ptr idx [c] val mem) 8740 for { 8741 _ = v.Args[3] 8742 ptr := v.Args[0] 8743 v_1 := v.Args[1] 8744 if v_1.Op != OpARMSRAconst { 8745 break 8746 } 8747 c := v_1.AuxInt 8748 idx := v_1.Args[0] 8749 val := v.Args[2] 8750 mem := v.Args[3] 8751 v.reset(OpARMMOVWstoreshiftRA) 8752 v.AuxInt = c 8753 v.AddArg(ptr) 8754 v.AddArg(idx) 8755 v.AddArg(val) 8756 v.AddArg(mem) 8757 return true 8758 } 8759 // match: (MOVWstoreidx (SRAconst idx [c]) ptr val mem) 8760 // cond: 8761 // result: (MOVWstoreshiftRA ptr idx [c] val mem) 8762 for { 8763 _ = v.Args[3] 8764 v_0 := v.Args[0] 8765 if v_0.Op != OpARMSRAconst { 8766 break 8767 } 8768 c := v_0.AuxInt 8769 idx := v_0.Args[0] 8770 ptr := v.Args[1] 8771 val := v.Args[2] 8772 mem := v.Args[3] 8773 v.reset(OpARMMOVWstoreshiftRA) 8774 v.AuxInt = c 8775 v.AddArg(ptr) 8776 v.AddArg(idx) 8777 v.AddArg(val) 8778 v.AddArg(mem) 8779 return true 8780 } 8781 return false 8782 } 8783 func rewriteValueARM_OpARMMOVWstoreshiftLL_0(v *Value) bool { 8784 // match: (MOVWstoreshiftLL ptr (MOVWconst [c]) [d] val mem) 8785 // cond: 8786 // result: (MOVWstore [int64(uint32(c)<<uint64(d))] ptr val mem) 8787 for { 8788 d := v.AuxInt 8789 _ = v.Args[3] 8790 ptr := v.Args[0] 8791 v_1 := v.Args[1] 8792 if v_1.Op != OpARMMOVWconst { 8793 break 8794 } 8795 c := v_1.AuxInt 8796 val := v.Args[2] 8797 mem := v.Args[3] 8798 v.reset(OpARMMOVWstore) 8799 v.AuxInt = int64(uint32(c) << uint64(d)) 8800 v.AddArg(ptr) 8801 v.AddArg(val) 8802 v.AddArg(mem) 8803 return true 8804 } 8805 return false 8806 } 8807 func rewriteValueARM_OpARMMOVWstoreshiftRA_0(v *Value) bool { 8808 // match: (MOVWstoreshiftRA ptr (MOVWconst [c]) [d] val mem) 8809 // cond: 8810 // result: (MOVWstore [int64(int32(c)>>uint64(d))] ptr val mem) 8811 for { 8812 d := v.AuxInt 8813 _ = v.Args[3] 8814 ptr := v.Args[0] 8815 v_1 := v.Args[1] 8816 if v_1.Op != OpARMMOVWconst { 8817 break 8818 } 8819 c := v_1.AuxInt 8820 val := v.Args[2] 8821 mem := v.Args[3] 8822 v.reset(OpARMMOVWstore) 8823 v.AuxInt = int64(int32(c) >> uint64(d)) 8824 v.AddArg(ptr) 8825 v.AddArg(val) 8826 v.AddArg(mem) 8827 return true 8828 } 8829 return false 8830 } 8831 func rewriteValueARM_OpARMMOVWstoreshiftRL_0(v *Value) bool { 8832 // match: (MOVWstoreshiftRL ptr (MOVWconst [c]) [d] val mem) 8833 // cond: 8834 // result: (MOVWstore [int64(uint32(c)>>uint64(d))] ptr val mem) 8835 for { 8836 d := v.AuxInt 8837 _ = v.Args[3] 8838 ptr := v.Args[0] 8839 v_1 := v.Args[1] 8840 if v_1.Op != OpARMMOVWconst { 8841 break 8842 } 8843 c := v_1.AuxInt 8844 val := v.Args[2] 8845 mem := v.Args[3] 8846 v.reset(OpARMMOVWstore) 8847 v.AuxInt = int64(uint32(c) >> uint64(d)) 8848 v.AddArg(ptr) 8849 v.AddArg(val) 8850 v.AddArg(mem) 8851 return true 8852 } 8853 return false 8854 } 8855 func rewriteValueARM_OpARMMUL_0(v *Value) bool { 8856 // match: (MUL x (MOVWconst [c])) 8857 // cond: int32(c) == -1 8858 // result: (RSBconst [0] x) 8859 for { 8860 _ = v.Args[1] 8861 x := v.Args[0] 8862 v_1 := v.Args[1] 8863 if v_1.Op != OpARMMOVWconst { 8864 break 8865 } 8866 c := v_1.AuxInt 8867 if !(int32(c) == -1) { 8868 break 8869 } 8870 v.reset(OpARMRSBconst) 8871 v.AuxInt = 0 8872 v.AddArg(x) 8873 return true 8874 } 8875 // match: (MUL (MOVWconst [c]) x) 8876 // cond: int32(c) == -1 8877 // result: (RSBconst [0] x) 8878 for { 8879 _ = v.Args[1] 8880 v_0 := v.Args[0] 8881 if v_0.Op != OpARMMOVWconst { 8882 break 8883 } 8884 c := v_0.AuxInt 8885 x := v.Args[1] 8886 if !(int32(c) == -1) { 8887 break 8888 } 8889 v.reset(OpARMRSBconst) 8890 v.AuxInt = 0 8891 v.AddArg(x) 8892 return true 8893 } 8894 // match: (MUL _ (MOVWconst [0])) 8895 // cond: 8896 // result: (MOVWconst [0]) 8897 for { 8898 _ = v.Args[1] 8899 v_1 := v.Args[1] 8900 if v_1.Op != OpARMMOVWconst { 8901 break 8902 } 8903 if v_1.AuxInt != 0 { 8904 break 8905 } 8906 v.reset(OpARMMOVWconst) 8907 v.AuxInt = 0 8908 return true 8909 } 8910 // match: (MUL (MOVWconst [0]) _) 8911 // cond: 8912 // result: (MOVWconst [0]) 8913 for { 8914 _ = v.Args[1] 8915 v_0 := v.Args[0] 8916 if v_0.Op != OpARMMOVWconst { 8917 break 8918 } 8919 if v_0.AuxInt != 0 { 8920 break 8921 } 8922 v.reset(OpARMMOVWconst) 8923 v.AuxInt = 0 8924 return true 8925 } 8926 // match: (MUL x (MOVWconst [1])) 8927 // cond: 8928 // result: x 8929 for { 8930 _ = v.Args[1] 8931 x := v.Args[0] 8932 v_1 := v.Args[1] 8933 if v_1.Op != OpARMMOVWconst { 8934 break 8935 } 8936 if v_1.AuxInt != 1 { 8937 break 8938 } 8939 v.reset(OpCopy) 8940 v.Type = x.Type 8941 v.AddArg(x) 8942 return true 8943 } 8944 // match: (MUL (MOVWconst [1]) x) 8945 // cond: 8946 // result: x 8947 for { 8948 _ = v.Args[1] 8949 v_0 := v.Args[0] 8950 if v_0.Op != OpARMMOVWconst { 8951 break 8952 } 8953 if v_0.AuxInt != 1 { 8954 break 8955 } 8956 x := v.Args[1] 8957 v.reset(OpCopy) 8958 v.Type = x.Type 8959 v.AddArg(x) 8960 return true 8961 } 8962 // match: (MUL x (MOVWconst [c])) 8963 // cond: isPowerOfTwo(c) 8964 // result: (SLLconst [log2(c)] x) 8965 for { 8966 _ = v.Args[1] 8967 x := v.Args[0] 8968 v_1 := v.Args[1] 8969 if v_1.Op != OpARMMOVWconst { 8970 break 8971 } 8972 c := v_1.AuxInt 8973 if !(isPowerOfTwo(c)) { 8974 break 8975 } 8976 v.reset(OpARMSLLconst) 8977 v.AuxInt = log2(c) 8978 v.AddArg(x) 8979 return true 8980 } 8981 // match: (MUL (MOVWconst [c]) x) 8982 // cond: isPowerOfTwo(c) 8983 // result: (SLLconst [log2(c)] x) 8984 for { 8985 _ = v.Args[1] 8986 v_0 := v.Args[0] 8987 if v_0.Op != OpARMMOVWconst { 8988 break 8989 } 8990 c := v_0.AuxInt 8991 x := v.Args[1] 8992 if !(isPowerOfTwo(c)) { 8993 break 8994 } 8995 v.reset(OpARMSLLconst) 8996 v.AuxInt = log2(c) 8997 v.AddArg(x) 8998 return true 8999 } 9000 // match: (MUL x (MOVWconst [c])) 9001 // cond: isPowerOfTwo(c-1) && int32(c) >= 3 9002 // result: (ADDshiftLL x x [log2(c-1)]) 9003 for { 9004 _ = v.Args[1] 9005 x := v.Args[0] 9006 v_1 := v.Args[1] 9007 if v_1.Op != OpARMMOVWconst { 9008 break 9009 } 9010 c := v_1.AuxInt 9011 if !(isPowerOfTwo(c-1) && int32(c) >= 3) { 9012 break 9013 } 9014 v.reset(OpARMADDshiftLL) 9015 v.AuxInt = log2(c - 1) 9016 v.AddArg(x) 9017 v.AddArg(x) 9018 return true 9019 } 9020 // match: (MUL (MOVWconst [c]) x) 9021 // cond: isPowerOfTwo(c-1) && int32(c) >= 3 9022 // result: (ADDshiftLL x x [log2(c-1)]) 9023 for { 9024 _ = v.Args[1] 9025 v_0 := v.Args[0] 9026 if v_0.Op != OpARMMOVWconst { 9027 break 9028 } 9029 c := v_0.AuxInt 9030 x := v.Args[1] 9031 if !(isPowerOfTwo(c-1) && int32(c) >= 3) { 9032 break 9033 } 9034 v.reset(OpARMADDshiftLL) 9035 v.AuxInt = log2(c - 1) 9036 v.AddArg(x) 9037 v.AddArg(x) 9038 return true 9039 } 9040 return false 9041 } 9042 func rewriteValueARM_OpARMMUL_10(v *Value) bool { 9043 b := v.Block 9044 _ = b 9045 // match: (MUL x (MOVWconst [c])) 9046 // cond: isPowerOfTwo(c+1) && int32(c) >= 7 9047 // result: (RSBshiftLL x x [log2(c+1)]) 9048 for { 9049 _ = v.Args[1] 9050 x := v.Args[0] 9051 v_1 := v.Args[1] 9052 if v_1.Op != OpARMMOVWconst { 9053 break 9054 } 9055 c := v_1.AuxInt 9056 if !(isPowerOfTwo(c+1) && int32(c) >= 7) { 9057 break 9058 } 9059 v.reset(OpARMRSBshiftLL) 9060 v.AuxInt = log2(c + 1) 9061 v.AddArg(x) 9062 v.AddArg(x) 9063 return true 9064 } 9065 // match: (MUL (MOVWconst [c]) x) 9066 // cond: isPowerOfTwo(c+1) && int32(c) >= 7 9067 // result: (RSBshiftLL x x [log2(c+1)]) 9068 for { 9069 _ = v.Args[1] 9070 v_0 := v.Args[0] 9071 if v_0.Op != OpARMMOVWconst { 9072 break 9073 } 9074 c := v_0.AuxInt 9075 x := v.Args[1] 9076 if !(isPowerOfTwo(c+1) && int32(c) >= 7) { 9077 break 9078 } 9079 v.reset(OpARMRSBshiftLL) 9080 v.AuxInt = log2(c + 1) 9081 v.AddArg(x) 9082 v.AddArg(x) 9083 return true 9084 } 9085 // match: (MUL x (MOVWconst [c])) 9086 // cond: c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c) 9087 // result: (SLLconst [log2(c/3)] (ADDshiftLL <x.Type> x x [1])) 9088 for { 9089 _ = v.Args[1] 9090 x := v.Args[0] 9091 v_1 := v.Args[1] 9092 if v_1.Op != OpARMMOVWconst { 9093 break 9094 } 9095 c := v_1.AuxInt 9096 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) { 9097 break 9098 } 9099 v.reset(OpARMSLLconst) 9100 v.AuxInt = log2(c / 3) 9101 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9102 v0.AuxInt = 1 9103 v0.AddArg(x) 9104 v0.AddArg(x) 9105 v.AddArg(v0) 9106 return true 9107 } 9108 // match: (MUL (MOVWconst [c]) x) 9109 // cond: c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c) 9110 // result: (SLLconst [log2(c/3)] (ADDshiftLL <x.Type> x x [1])) 9111 for { 9112 _ = v.Args[1] 9113 v_0 := v.Args[0] 9114 if v_0.Op != OpARMMOVWconst { 9115 break 9116 } 9117 c := v_0.AuxInt 9118 x := v.Args[1] 9119 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) { 9120 break 9121 } 9122 v.reset(OpARMSLLconst) 9123 v.AuxInt = log2(c / 3) 9124 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9125 v0.AuxInt = 1 9126 v0.AddArg(x) 9127 v0.AddArg(x) 9128 v.AddArg(v0) 9129 return true 9130 } 9131 // match: (MUL x (MOVWconst [c])) 9132 // cond: c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c) 9133 // result: (SLLconst [log2(c/5)] (ADDshiftLL <x.Type> x x [2])) 9134 for { 9135 _ = v.Args[1] 9136 x := v.Args[0] 9137 v_1 := v.Args[1] 9138 if v_1.Op != OpARMMOVWconst { 9139 break 9140 } 9141 c := v_1.AuxInt 9142 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) { 9143 break 9144 } 9145 v.reset(OpARMSLLconst) 9146 v.AuxInt = log2(c / 5) 9147 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9148 v0.AuxInt = 2 9149 v0.AddArg(x) 9150 v0.AddArg(x) 9151 v.AddArg(v0) 9152 return true 9153 } 9154 // match: (MUL (MOVWconst [c]) x) 9155 // cond: c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c) 9156 // result: (SLLconst [log2(c/5)] (ADDshiftLL <x.Type> x x [2])) 9157 for { 9158 _ = v.Args[1] 9159 v_0 := v.Args[0] 9160 if v_0.Op != OpARMMOVWconst { 9161 break 9162 } 9163 c := v_0.AuxInt 9164 x := v.Args[1] 9165 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) { 9166 break 9167 } 9168 v.reset(OpARMSLLconst) 9169 v.AuxInt = log2(c / 5) 9170 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9171 v0.AuxInt = 2 9172 v0.AddArg(x) 9173 v0.AddArg(x) 9174 v.AddArg(v0) 9175 return true 9176 } 9177 // match: (MUL x (MOVWconst [c])) 9178 // cond: c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c) 9179 // result: (SLLconst [log2(c/7)] (RSBshiftLL <x.Type> x x [3])) 9180 for { 9181 _ = v.Args[1] 9182 x := v.Args[0] 9183 v_1 := v.Args[1] 9184 if v_1.Op != OpARMMOVWconst { 9185 break 9186 } 9187 c := v_1.AuxInt 9188 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) { 9189 break 9190 } 9191 v.reset(OpARMSLLconst) 9192 v.AuxInt = log2(c / 7) 9193 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 9194 v0.AuxInt = 3 9195 v0.AddArg(x) 9196 v0.AddArg(x) 9197 v.AddArg(v0) 9198 return true 9199 } 9200 // match: (MUL (MOVWconst [c]) x) 9201 // cond: c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c) 9202 // result: (SLLconst [log2(c/7)] (RSBshiftLL <x.Type> x x [3])) 9203 for { 9204 _ = v.Args[1] 9205 v_0 := v.Args[0] 9206 if v_0.Op != OpARMMOVWconst { 9207 break 9208 } 9209 c := v_0.AuxInt 9210 x := v.Args[1] 9211 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) { 9212 break 9213 } 9214 v.reset(OpARMSLLconst) 9215 v.AuxInt = log2(c / 7) 9216 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 9217 v0.AuxInt = 3 9218 v0.AddArg(x) 9219 v0.AddArg(x) 9220 v.AddArg(v0) 9221 return true 9222 } 9223 // match: (MUL x (MOVWconst [c])) 9224 // cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c) 9225 // result: (SLLconst [log2(c/9)] (ADDshiftLL <x.Type> x x [3])) 9226 for { 9227 _ = v.Args[1] 9228 x := v.Args[0] 9229 v_1 := v.Args[1] 9230 if v_1.Op != OpARMMOVWconst { 9231 break 9232 } 9233 c := v_1.AuxInt 9234 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) { 9235 break 9236 } 9237 v.reset(OpARMSLLconst) 9238 v.AuxInt = log2(c / 9) 9239 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9240 v0.AuxInt = 3 9241 v0.AddArg(x) 9242 v0.AddArg(x) 9243 v.AddArg(v0) 9244 return true 9245 } 9246 // match: (MUL (MOVWconst [c]) x) 9247 // cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c) 9248 // result: (SLLconst [log2(c/9)] (ADDshiftLL <x.Type> x x [3])) 9249 for { 9250 _ = v.Args[1] 9251 v_0 := v.Args[0] 9252 if v_0.Op != OpARMMOVWconst { 9253 break 9254 } 9255 c := v_0.AuxInt 9256 x := v.Args[1] 9257 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) { 9258 break 9259 } 9260 v.reset(OpARMSLLconst) 9261 v.AuxInt = log2(c / 9) 9262 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9263 v0.AuxInt = 3 9264 v0.AddArg(x) 9265 v0.AddArg(x) 9266 v.AddArg(v0) 9267 return true 9268 } 9269 return false 9270 } 9271 func rewriteValueARM_OpARMMUL_20(v *Value) bool { 9272 // match: (MUL (MOVWconst [c]) (MOVWconst [d])) 9273 // cond: 9274 // result: (MOVWconst [int64(int32(c*d))]) 9275 for { 9276 _ = v.Args[1] 9277 v_0 := v.Args[0] 9278 if v_0.Op != OpARMMOVWconst { 9279 break 9280 } 9281 c := v_0.AuxInt 9282 v_1 := v.Args[1] 9283 if v_1.Op != OpARMMOVWconst { 9284 break 9285 } 9286 d := v_1.AuxInt 9287 v.reset(OpARMMOVWconst) 9288 v.AuxInt = int64(int32(c * d)) 9289 return true 9290 } 9291 // match: (MUL (MOVWconst [d]) (MOVWconst [c])) 9292 // cond: 9293 // result: (MOVWconst [int64(int32(c*d))]) 9294 for { 9295 _ = v.Args[1] 9296 v_0 := v.Args[0] 9297 if v_0.Op != OpARMMOVWconst { 9298 break 9299 } 9300 d := v_0.AuxInt 9301 v_1 := v.Args[1] 9302 if v_1.Op != OpARMMOVWconst { 9303 break 9304 } 9305 c := v_1.AuxInt 9306 v.reset(OpARMMOVWconst) 9307 v.AuxInt = int64(int32(c * d)) 9308 return true 9309 } 9310 return false 9311 } 9312 func rewriteValueARM_OpARMMULA_0(v *Value) bool { 9313 b := v.Block 9314 _ = b 9315 // match: (MULA x (MOVWconst [c]) a) 9316 // cond: int32(c) == -1 9317 // result: (SUB a x) 9318 for { 9319 _ = v.Args[2] 9320 x := v.Args[0] 9321 v_1 := v.Args[1] 9322 if v_1.Op != OpARMMOVWconst { 9323 break 9324 } 9325 c := v_1.AuxInt 9326 a := v.Args[2] 9327 if !(int32(c) == -1) { 9328 break 9329 } 9330 v.reset(OpARMSUB) 9331 v.AddArg(a) 9332 v.AddArg(x) 9333 return true 9334 } 9335 // match: (MULA _ (MOVWconst [0]) a) 9336 // cond: 9337 // result: a 9338 for { 9339 _ = v.Args[2] 9340 v_1 := v.Args[1] 9341 if v_1.Op != OpARMMOVWconst { 9342 break 9343 } 9344 if v_1.AuxInt != 0 { 9345 break 9346 } 9347 a := v.Args[2] 9348 v.reset(OpCopy) 9349 v.Type = a.Type 9350 v.AddArg(a) 9351 return true 9352 } 9353 // match: (MULA x (MOVWconst [1]) a) 9354 // cond: 9355 // result: (ADD x a) 9356 for { 9357 _ = v.Args[2] 9358 x := v.Args[0] 9359 v_1 := v.Args[1] 9360 if v_1.Op != OpARMMOVWconst { 9361 break 9362 } 9363 if v_1.AuxInt != 1 { 9364 break 9365 } 9366 a := v.Args[2] 9367 v.reset(OpARMADD) 9368 v.AddArg(x) 9369 v.AddArg(a) 9370 return true 9371 } 9372 // match: (MULA x (MOVWconst [c]) a) 9373 // cond: isPowerOfTwo(c) 9374 // result: (ADD (SLLconst <x.Type> [log2(c)] x) a) 9375 for { 9376 _ = v.Args[2] 9377 x := v.Args[0] 9378 v_1 := v.Args[1] 9379 if v_1.Op != OpARMMOVWconst { 9380 break 9381 } 9382 c := v_1.AuxInt 9383 a := v.Args[2] 9384 if !(isPowerOfTwo(c)) { 9385 break 9386 } 9387 v.reset(OpARMADD) 9388 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 9389 v0.AuxInt = log2(c) 9390 v0.AddArg(x) 9391 v.AddArg(v0) 9392 v.AddArg(a) 9393 return true 9394 } 9395 // match: (MULA x (MOVWconst [c]) a) 9396 // cond: isPowerOfTwo(c-1) && int32(c) >= 3 9397 // result: (ADD (ADDshiftLL <x.Type> x x [log2(c-1)]) a) 9398 for { 9399 _ = v.Args[2] 9400 x := v.Args[0] 9401 v_1 := v.Args[1] 9402 if v_1.Op != OpARMMOVWconst { 9403 break 9404 } 9405 c := v_1.AuxInt 9406 a := v.Args[2] 9407 if !(isPowerOfTwo(c-1) && int32(c) >= 3) { 9408 break 9409 } 9410 v.reset(OpARMADD) 9411 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9412 v0.AuxInt = log2(c - 1) 9413 v0.AddArg(x) 9414 v0.AddArg(x) 9415 v.AddArg(v0) 9416 v.AddArg(a) 9417 return true 9418 } 9419 // match: (MULA x (MOVWconst [c]) a) 9420 // cond: isPowerOfTwo(c+1) && int32(c) >= 7 9421 // result: (ADD (RSBshiftLL <x.Type> x x [log2(c+1)]) a) 9422 for { 9423 _ = v.Args[2] 9424 x := v.Args[0] 9425 v_1 := v.Args[1] 9426 if v_1.Op != OpARMMOVWconst { 9427 break 9428 } 9429 c := v_1.AuxInt 9430 a := v.Args[2] 9431 if !(isPowerOfTwo(c+1) && int32(c) >= 7) { 9432 break 9433 } 9434 v.reset(OpARMADD) 9435 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 9436 v0.AuxInt = log2(c + 1) 9437 v0.AddArg(x) 9438 v0.AddArg(x) 9439 v.AddArg(v0) 9440 v.AddArg(a) 9441 return true 9442 } 9443 // match: (MULA x (MOVWconst [c]) a) 9444 // cond: c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c) 9445 // result: (ADD (SLLconst <x.Type> [log2(c/3)] (ADDshiftLL <x.Type> x x [1])) a) 9446 for { 9447 _ = v.Args[2] 9448 x := v.Args[0] 9449 v_1 := v.Args[1] 9450 if v_1.Op != OpARMMOVWconst { 9451 break 9452 } 9453 c := v_1.AuxInt 9454 a := v.Args[2] 9455 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) { 9456 break 9457 } 9458 v.reset(OpARMADD) 9459 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 9460 v0.AuxInt = log2(c / 3) 9461 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9462 v1.AuxInt = 1 9463 v1.AddArg(x) 9464 v1.AddArg(x) 9465 v0.AddArg(v1) 9466 v.AddArg(v0) 9467 v.AddArg(a) 9468 return true 9469 } 9470 // match: (MULA x (MOVWconst [c]) a) 9471 // cond: c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c) 9472 // result: (ADD (SLLconst <x.Type> [log2(c/5)] (ADDshiftLL <x.Type> x x [2])) a) 9473 for { 9474 _ = v.Args[2] 9475 x := v.Args[0] 9476 v_1 := v.Args[1] 9477 if v_1.Op != OpARMMOVWconst { 9478 break 9479 } 9480 c := v_1.AuxInt 9481 a := v.Args[2] 9482 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) { 9483 break 9484 } 9485 v.reset(OpARMADD) 9486 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 9487 v0.AuxInt = log2(c / 5) 9488 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9489 v1.AuxInt = 2 9490 v1.AddArg(x) 9491 v1.AddArg(x) 9492 v0.AddArg(v1) 9493 v.AddArg(v0) 9494 v.AddArg(a) 9495 return true 9496 } 9497 // match: (MULA x (MOVWconst [c]) a) 9498 // cond: c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c) 9499 // result: (ADD (SLLconst <x.Type> [log2(c/7)] (RSBshiftLL <x.Type> x x [3])) a) 9500 for { 9501 _ = v.Args[2] 9502 x := v.Args[0] 9503 v_1 := v.Args[1] 9504 if v_1.Op != OpARMMOVWconst { 9505 break 9506 } 9507 c := v_1.AuxInt 9508 a := v.Args[2] 9509 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) { 9510 break 9511 } 9512 v.reset(OpARMADD) 9513 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 9514 v0.AuxInt = log2(c / 7) 9515 v1 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 9516 v1.AuxInt = 3 9517 v1.AddArg(x) 9518 v1.AddArg(x) 9519 v0.AddArg(v1) 9520 v.AddArg(v0) 9521 v.AddArg(a) 9522 return true 9523 } 9524 // match: (MULA x (MOVWconst [c]) a) 9525 // cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c) 9526 // result: (ADD (SLLconst <x.Type> [log2(c/9)] (ADDshiftLL <x.Type> x x [3])) a) 9527 for { 9528 _ = v.Args[2] 9529 x := v.Args[0] 9530 v_1 := v.Args[1] 9531 if v_1.Op != OpARMMOVWconst { 9532 break 9533 } 9534 c := v_1.AuxInt 9535 a := v.Args[2] 9536 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) { 9537 break 9538 } 9539 v.reset(OpARMADD) 9540 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 9541 v0.AuxInt = log2(c / 9) 9542 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9543 v1.AuxInt = 3 9544 v1.AddArg(x) 9545 v1.AddArg(x) 9546 v0.AddArg(v1) 9547 v.AddArg(v0) 9548 v.AddArg(a) 9549 return true 9550 } 9551 return false 9552 } 9553 func rewriteValueARM_OpARMMULA_10(v *Value) bool { 9554 b := v.Block 9555 _ = b 9556 // match: (MULA (MOVWconst [c]) x a) 9557 // cond: int32(c) == -1 9558 // result: (SUB a x) 9559 for { 9560 _ = v.Args[2] 9561 v_0 := v.Args[0] 9562 if v_0.Op != OpARMMOVWconst { 9563 break 9564 } 9565 c := v_0.AuxInt 9566 x := v.Args[1] 9567 a := v.Args[2] 9568 if !(int32(c) == -1) { 9569 break 9570 } 9571 v.reset(OpARMSUB) 9572 v.AddArg(a) 9573 v.AddArg(x) 9574 return true 9575 } 9576 // match: (MULA (MOVWconst [0]) _ a) 9577 // cond: 9578 // result: a 9579 for { 9580 _ = v.Args[2] 9581 v_0 := v.Args[0] 9582 if v_0.Op != OpARMMOVWconst { 9583 break 9584 } 9585 if v_0.AuxInt != 0 { 9586 break 9587 } 9588 a := v.Args[2] 9589 v.reset(OpCopy) 9590 v.Type = a.Type 9591 v.AddArg(a) 9592 return true 9593 } 9594 // match: (MULA (MOVWconst [1]) x a) 9595 // cond: 9596 // result: (ADD x a) 9597 for { 9598 _ = v.Args[2] 9599 v_0 := v.Args[0] 9600 if v_0.Op != OpARMMOVWconst { 9601 break 9602 } 9603 if v_0.AuxInt != 1 { 9604 break 9605 } 9606 x := v.Args[1] 9607 a := v.Args[2] 9608 v.reset(OpARMADD) 9609 v.AddArg(x) 9610 v.AddArg(a) 9611 return true 9612 } 9613 // match: (MULA (MOVWconst [c]) x a) 9614 // cond: isPowerOfTwo(c) 9615 // result: (ADD (SLLconst <x.Type> [log2(c)] x) a) 9616 for { 9617 _ = v.Args[2] 9618 v_0 := v.Args[0] 9619 if v_0.Op != OpARMMOVWconst { 9620 break 9621 } 9622 c := v_0.AuxInt 9623 x := v.Args[1] 9624 a := v.Args[2] 9625 if !(isPowerOfTwo(c)) { 9626 break 9627 } 9628 v.reset(OpARMADD) 9629 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 9630 v0.AuxInt = log2(c) 9631 v0.AddArg(x) 9632 v.AddArg(v0) 9633 v.AddArg(a) 9634 return true 9635 } 9636 // match: (MULA (MOVWconst [c]) x a) 9637 // cond: isPowerOfTwo(c-1) && int32(c) >= 3 9638 // result: (ADD (ADDshiftLL <x.Type> x x [log2(c-1)]) a) 9639 for { 9640 _ = v.Args[2] 9641 v_0 := v.Args[0] 9642 if v_0.Op != OpARMMOVWconst { 9643 break 9644 } 9645 c := v_0.AuxInt 9646 x := v.Args[1] 9647 a := v.Args[2] 9648 if !(isPowerOfTwo(c-1) && int32(c) >= 3) { 9649 break 9650 } 9651 v.reset(OpARMADD) 9652 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9653 v0.AuxInt = log2(c - 1) 9654 v0.AddArg(x) 9655 v0.AddArg(x) 9656 v.AddArg(v0) 9657 v.AddArg(a) 9658 return true 9659 } 9660 // match: (MULA (MOVWconst [c]) x a) 9661 // cond: isPowerOfTwo(c+1) && int32(c) >= 7 9662 // result: (ADD (RSBshiftLL <x.Type> x x [log2(c+1)]) a) 9663 for { 9664 _ = v.Args[2] 9665 v_0 := v.Args[0] 9666 if v_0.Op != OpARMMOVWconst { 9667 break 9668 } 9669 c := v_0.AuxInt 9670 x := v.Args[1] 9671 a := v.Args[2] 9672 if !(isPowerOfTwo(c+1) && int32(c) >= 7) { 9673 break 9674 } 9675 v.reset(OpARMADD) 9676 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 9677 v0.AuxInt = log2(c + 1) 9678 v0.AddArg(x) 9679 v0.AddArg(x) 9680 v.AddArg(v0) 9681 v.AddArg(a) 9682 return true 9683 } 9684 // match: (MULA (MOVWconst [c]) x a) 9685 // cond: c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c) 9686 // result: (ADD (SLLconst <x.Type> [log2(c/3)] (ADDshiftLL <x.Type> x x [1])) a) 9687 for { 9688 _ = v.Args[2] 9689 v_0 := v.Args[0] 9690 if v_0.Op != OpARMMOVWconst { 9691 break 9692 } 9693 c := v_0.AuxInt 9694 x := v.Args[1] 9695 a := v.Args[2] 9696 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) { 9697 break 9698 } 9699 v.reset(OpARMADD) 9700 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 9701 v0.AuxInt = log2(c / 3) 9702 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9703 v1.AuxInt = 1 9704 v1.AddArg(x) 9705 v1.AddArg(x) 9706 v0.AddArg(v1) 9707 v.AddArg(v0) 9708 v.AddArg(a) 9709 return true 9710 } 9711 // match: (MULA (MOVWconst [c]) x a) 9712 // cond: c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c) 9713 // result: (ADD (SLLconst <x.Type> [log2(c/5)] (ADDshiftLL <x.Type> x x [2])) a) 9714 for { 9715 _ = v.Args[2] 9716 v_0 := v.Args[0] 9717 if v_0.Op != OpARMMOVWconst { 9718 break 9719 } 9720 c := v_0.AuxInt 9721 x := v.Args[1] 9722 a := v.Args[2] 9723 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) { 9724 break 9725 } 9726 v.reset(OpARMADD) 9727 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 9728 v0.AuxInt = log2(c / 5) 9729 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9730 v1.AuxInt = 2 9731 v1.AddArg(x) 9732 v1.AddArg(x) 9733 v0.AddArg(v1) 9734 v.AddArg(v0) 9735 v.AddArg(a) 9736 return true 9737 } 9738 // match: (MULA (MOVWconst [c]) x a) 9739 // cond: c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c) 9740 // result: (ADD (SLLconst <x.Type> [log2(c/7)] (RSBshiftLL <x.Type> x x [3])) a) 9741 for { 9742 _ = v.Args[2] 9743 v_0 := v.Args[0] 9744 if v_0.Op != OpARMMOVWconst { 9745 break 9746 } 9747 c := v_0.AuxInt 9748 x := v.Args[1] 9749 a := v.Args[2] 9750 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) { 9751 break 9752 } 9753 v.reset(OpARMADD) 9754 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 9755 v0.AuxInt = log2(c / 7) 9756 v1 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 9757 v1.AuxInt = 3 9758 v1.AddArg(x) 9759 v1.AddArg(x) 9760 v0.AddArg(v1) 9761 v.AddArg(v0) 9762 v.AddArg(a) 9763 return true 9764 } 9765 // match: (MULA (MOVWconst [c]) x a) 9766 // cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c) 9767 // result: (ADD (SLLconst <x.Type> [log2(c/9)] (ADDshiftLL <x.Type> x x [3])) a) 9768 for { 9769 _ = v.Args[2] 9770 v_0 := v.Args[0] 9771 if v_0.Op != OpARMMOVWconst { 9772 break 9773 } 9774 c := v_0.AuxInt 9775 x := v.Args[1] 9776 a := v.Args[2] 9777 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) { 9778 break 9779 } 9780 v.reset(OpARMADD) 9781 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 9782 v0.AuxInt = log2(c / 9) 9783 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9784 v1.AuxInt = 3 9785 v1.AddArg(x) 9786 v1.AddArg(x) 9787 v0.AddArg(v1) 9788 v.AddArg(v0) 9789 v.AddArg(a) 9790 return true 9791 } 9792 return false 9793 } 9794 func rewriteValueARM_OpARMMULA_20(v *Value) bool { 9795 // match: (MULA (MOVWconst [c]) (MOVWconst [d]) a) 9796 // cond: 9797 // result: (ADDconst [int64(int32(c*d))] a) 9798 for { 9799 _ = v.Args[2] 9800 v_0 := v.Args[0] 9801 if v_0.Op != OpARMMOVWconst { 9802 break 9803 } 9804 c := v_0.AuxInt 9805 v_1 := v.Args[1] 9806 if v_1.Op != OpARMMOVWconst { 9807 break 9808 } 9809 d := v_1.AuxInt 9810 a := v.Args[2] 9811 v.reset(OpARMADDconst) 9812 v.AuxInt = int64(int32(c * d)) 9813 v.AddArg(a) 9814 return true 9815 } 9816 return false 9817 } 9818 func rewriteValueARM_OpARMMULD_0(v *Value) bool { 9819 // match: (MULD (NEGD x) y) 9820 // cond: objabi.GOARM >= 6 9821 // result: (NMULD x y) 9822 for { 9823 _ = v.Args[1] 9824 v_0 := v.Args[0] 9825 if v_0.Op != OpARMNEGD { 9826 break 9827 } 9828 x := v_0.Args[0] 9829 y := v.Args[1] 9830 if !(objabi.GOARM >= 6) { 9831 break 9832 } 9833 v.reset(OpARMNMULD) 9834 v.AddArg(x) 9835 v.AddArg(y) 9836 return true 9837 } 9838 // match: (MULD y (NEGD x)) 9839 // cond: objabi.GOARM >= 6 9840 // result: (NMULD x y) 9841 for { 9842 _ = v.Args[1] 9843 y := v.Args[0] 9844 v_1 := v.Args[1] 9845 if v_1.Op != OpARMNEGD { 9846 break 9847 } 9848 x := v_1.Args[0] 9849 if !(objabi.GOARM >= 6) { 9850 break 9851 } 9852 v.reset(OpARMNMULD) 9853 v.AddArg(x) 9854 v.AddArg(y) 9855 return true 9856 } 9857 return false 9858 } 9859 func rewriteValueARM_OpARMMULF_0(v *Value) bool { 9860 // match: (MULF (NEGF x) y) 9861 // cond: objabi.GOARM >= 6 9862 // result: (NMULF x y) 9863 for { 9864 _ = v.Args[1] 9865 v_0 := v.Args[0] 9866 if v_0.Op != OpARMNEGF { 9867 break 9868 } 9869 x := v_0.Args[0] 9870 y := v.Args[1] 9871 if !(objabi.GOARM >= 6) { 9872 break 9873 } 9874 v.reset(OpARMNMULF) 9875 v.AddArg(x) 9876 v.AddArg(y) 9877 return true 9878 } 9879 // match: (MULF y (NEGF x)) 9880 // cond: objabi.GOARM >= 6 9881 // result: (NMULF x y) 9882 for { 9883 _ = v.Args[1] 9884 y := v.Args[0] 9885 v_1 := v.Args[1] 9886 if v_1.Op != OpARMNEGF { 9887 break 9888 } 9889 x := v_1.Args[0] 9890 if !(objabi.GOARM >= 6) { 9891 break 9892 } 9893 v.reset(OpARMNMULF) 9894 v.AddArg(x) 9895 v.AddArg(y) 9896 return true 9897 } 9898 return false 9899 } 9900 func rewriteValueARM_OpARMMULS_0(v *Value) bool { 9901 b := v.Block 9902 _ = b 9903 // match: (MULS x (MOVWconst [c]) a) 9904 // cond: int32(c) == -1 9905 // result: (ADD a x) 9906 for { 9907 _ = v.Args[2] 9908 x := v.Args[0] 9909 v_1 := v.Args[1] 9910 if v_1.Op != OpARMMOVWconst { 9911 break 9912 } 9913 c := v_1.AuxInt 9914 a := v.Args[2] 9915 if !(int32(c) == -1) { 9916 break 9917 } 9918 v.reset(OpARMADD) 9919 v.AddArg(a) 9920 v.AddArg(x) 9921 return true 9922 } 9923 // match: (MULS _ (MOVWconst [0]) a) 9924 // cond: 9925 // result: a 9926 for { 9927 _ = v.Args[2] 9928 v_1 := v.Args[1] 9929 if v_1.Op != OpARMMOVWconst { 9930 break 9931 } 9932 if v_1.AuxInt != 0 { 9933 break 9934 } 9935 a := v.Args[2] 9936 v.reset(OpCopy) 9937 v.Type = a.Type 9938 v.AddArg(a) 9939 return true 9940 } 9941 // match: (MULS x (MOVWconst [1]) a) 9942 // cond: 9943 // result: (RSB x a) 9944 for { 9945 _ = v.Args[2] 9946 x := v.Args[0] 9947 v_1 := v.Args[1] 9948 if v_1.Op != OpARMMOVWconst { 9949 break 9950 } 9951 if v_1.AuxInt != 1 { 9952 break 9953 } 9954 a := v.Args[2] 9955 v.reset(OpARMRSB) 9956 v.AddArg(x) 9957 v.AddArg(a) 9958 return true 9959 } 9960 // match: (MULS x (MOVWconst [c]) a) 9961 // cond: isPowerOfTwo(c) 9962 // result: (RSB (SLLconst <x.Type> [log2(c)] x) a) 9963 for { 9964 _ = v.Args[2] 9965 x := v.Args[0] 9966 v_1 := v.Args[1] 9967 if v_1.Op != OpARMMOVWconst { 9968 break 9969 } 9970 c := v_1.AuxInt 9971 a := v.Args[2] 9972 if !(isPowerOfTwo(c)) { 9973 break 9974 } 9975 v.reset(OpARMRSB) 9976 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 9977 v0.AuxInt = log2(c) 9978 v0.AddArg(x) 9979 v.AddArg(v0) 9980 v.AddArg(a) 9981 return true 9982 } 9983 // match: (MULS x (MOVWconst [c]) a) 9984 // cond: isPowerOfTwo(c-1) && int32(c) >= 3 9985 // result: (RSB (ADDshiftLL <x.Type> x x [log2(c-1)]) a) 9986 for { 9987 _ = v.Args[2] 9988 x := v.Args[0] 9989 v_1 := v.Args[1] 9990 if v_1.Op != OpARMMOVWconst { 9991 break 9992 } 9993 c := v_1.AuxInt 9994 a := v.Args[2] 9995 if !(isPowerOfTwo(c-1) && int32(c) >= 3) { 9996 break 9997 } 9998 v.reset(OpARMRSB) 9999 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10000 v0.AuxInt = log2(c - 1) 10001 v0.AddArg(x) 10002 v0.AddArg(x) 10003 v.AddArg(v0) 10004 v.AddArg(a) 10005 return true 10006 } 10007 // match: (MULS x (MOVWconst [c]) a) 10008 // cond: isPowerOfTwo(c+1) && int32(c) >= 7 10009 // result: (RSB (RSBshiftLL <x.Type> x x [log2(c+1)]) a) 10010 for { 10011 _ = v.Args[2] 10012 x := v.Args[0] 10013 v_1 := v.Args[1] 10014 if v_1.Op != OpARMMOVWconst { 10015 break 10016 } 10017 c := v_1.AuxInt 10018 a := v.Args[2] 10019 if !(isPowerOfTwo(c+1) && int32(c) >= 7) { 10020 break 10021 } 10022 v.reset(OpARMRSB) 10023 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 10024 v0.AuxInt = log2(c + 1) 10025 v0.AddArg(x) 10026 v0.AddArg(x) 10027 v.AddArg(v0) 10028 v.AddArg(a) 10029 return true 10030 } 10031 // match: (MULS x (MOVWconst [c]) a) 10032 // cond: c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c) 10033 // result: (RSB (SLLconst <x.Type> [log2(c/3)] (ADDshiftLL <x.Type> x x [1])) a) 10034 for { 10035 _ = v.Args[2] 10036 x := v.Args[0] 10037 v_1 := v.Args[1] 10038 if v_1.Op != OpARMMOVWconst { 10039 break 10040 } 10041 c := v_1.AuxInt 10042 a := v.Args[2] 10043 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) { 10044 break 10045 } 10046 v.reset(OpARMRSB) 10047 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10048 v0.AuxInt = log2(c / 3) 10049 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10050 v1.AuxInt = 1 10051 v1.AddArg(x) 10052 v1.AddArg(x) 10053 v0.AddArg(v1) 10054 v.AddArg(v0) 10055 v.AddArg(a) 10056 return true 10057 } 10058 // match: (MULS x (MOVWconst [c]) a) 10059 // cond: c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c) 10060 // result: (RSB (SLLconst <x.Type> [log2(c/5)] (ADDshiftLL <x.Type> x x [2])) a) 10061 for { 10062 _ = v.Args[2] 10063 x := v.Args[0] 10064 v_1 := v.Args[1] 10065 if v_1.Op != OpARMMOVWconst { 10066 break 10067 } 10068 c := v_1.AuxInt 10069 a := v.Args[2] 10070 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) { 10071 break 10072 } 10073 v.reset(OpARMRSB) 10074 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10075 v0.AuxInt = log2(c / 5) 10076 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10077 v1.AuxInt = 2 10078 v1.AddArg(x) 10079 v1.AddArg(x) 10080 v0.AddArg(v1) 10081 v.AddArg(v0) 10082 v.AddArg(a) 10083 return true 10084 } 10085 // match: (MULS x (MOVWconst [c]) a) 10086 // cond: c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c) 10087 // result: (RSB (SLLconst <x.Type> [log2(c/7)] (RSBshiftLL <x.Type> x x [3])) a) 10088 for { 10089 _ = v.Args[2] 10090 x := v.Args[0] 10091 v_1 := v.Args[1] 10092 if v_1.Op != OpARMMOVWconst { 10093 break 10094 } 10095 c := v_1.AuxInt 10096 a := v.Args[2] 10097 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) { 10098 break 10099 } 10100 v.reset(OpARMRSB) 10101 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10102 v0.AuxInt = log2(c / 7) 10103 v1 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 10104 v1.AuxInt = 3 10105 v1.AddArg(x) 10106 v1.AddArg(x) 10107 v0.AddArg(v1) 10108 v.AddArg(v0) 10109 v.AddArg(a) 10110 return true 10111 } 10112 // match: (MULS x (MOVWconst [c]) a) 10113 // cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c) 10114 // result: (RSB (SLLconst <x.Type> [log2(c/9)] (ADDshiftLL <x.Type> x x [3])) a) 10115 for { 10116 _ = v.Args[2] 10117 x := v.Args[0] 10118 v_1 := v.Args[1] 10119 if v_1.Op != OpARMMOVWconst { 10120 break 10121 } 10122 c := v_1.AuxInt 10123 a := v.Args[2] 10124 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) { 10125 break 10126 } 10127 v.reset(OpARMRSB) 10128 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10129 v0.AuxInt = log2(c / 9) 10130 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10131 v1.AuxInt = 3 10132 v1.AddArg(x) 10133 v1.AddArg(x) 10134 v0.AddArg(v1) 10135 v.AddArg(v0) 10136 v.AddArg(a) 10137 return true 10138 } 10139 return false 10140 } 10141 func rewriteValueARM_OpARMMULS_10(v *Value) bool { 10142 b := v.Block 10143 _ = b 10144 // match: (MULS (MOVWconst [c]) x a) 10145 // cond: int32(c) == -1 10146 // result: (ADD a x) 10147 for { 10148 _ = v.Args[2] 10149 v_0 := v.Args[0] 10150 if v_0.Op != OpARMMOVWconst { 10151 break 10152 } 10153 c := v_0.AuxInt 10154 x := v.Args[1] 10155 a := v.Args[2] 10156 if !(int32(c) == -1) { 10157 break 10158 } 10159 v.reset(OpARMADD) 10160 v.AddArg(a) 10161 v.AddArg(x) 10162 return true 10163 } 10164 // match: (MULS (MOVWconst [0]) _ a) 10165 // cond: 10166 // result: a 10167 for { 10168 _ = v.Args[2] 10169 v_0 := v.Args[0] 10170 if v_0.Op != OpARMMOVWconst { 10171 break 10172 } 10173 if v_0.AuxInt != 0 { 10174 break 10175 } 10176 a := v.Args[2] 10177 v.reset(OpCopy) 10178 v.Type = a.Type 10179 v.AddArg(a) 10180 return true 10181 } 10182 // match: (MULS (MOVWconst [1]) x a) 10183 // cond: 10184 // result: (RSB x a) 10185 for { 10186 _ = v.Args[2] 10187 v_0 := v.Args[0] 10188 if v_0.Op != OpARMMOVWconst { 10189 break 10190 } 10191 if v_0.AuxInt != 1 { 10192 break 10193 } 10194 x := v.Args[1] 10195 a := v.Args[2] 10196 v.reset(OpARMRSB) 10197 v.AddArg(x) 10198 v.AddArg(a) 10199 return true 10200 } 10201 // match: (MULS (MOVWconst [c]) x a) 10202 // cond: isPowerOfTwo(c) 10203 // result: (RSB (SLLconst <x.Type> [log2(c)] x) a) 10204 for { 10205 _ = v.Args[2] 10206 v_0 := v.Args[0] 10207 if v_0.Op != OpARMMOVWconst { 10208 break 10209 } 10210 c := v_0.AuxInt 10211 x := v.Args[1] 10212 a := v.Args[2] 10213 if !(isPowerOfTwo(c)) { 10214 break 10215 } 10216 v.reset(OpARMRSB) 10217 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10218 v0.AuxInt = log2(c) 10219 v0.AddArg(x) 10220 v.AddArg(v0) 10221 v.AddArg(a) 10222 return true 10223 } 10224 // match: (MULS (MOVWconst [c]) x a) 10225 // cond: isPowerOfTwo(c-1) && int32(c) >= 3 10226 // result: (RSB (ADDshiftLL <x.Type> x x [log2(c-1)]) a) 10227 for { 10228 _ = v.Args[2] 10229 v_0 := v.Args[0] 10230 if v_0.Op != OpARMMOVWconst { 10231 break 10232 } 10233 c := v_0.AuxInt 10234 x := v.Args[1] 10235 a := v.Args[2] 10236 if !(isPowerOfTwo(c-1) && int32(c) >= 3) { 10237 break 10238 } 10239 v.reset(OpARMRSB) 10240 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10241 v0.AuxInt = log2(c - 1) 10242 v0.AddArg(x) 10243 v0.AddArg(x) 10244 v.AddArg(v0) 10245 v.AddArg(a) 10246 return true 10247 } 10248 // match: (MULS (MOVWconst [c]) x a) 10249 // cond: isPowerOfTwo(c+1) && int32(c) >= 7 10250 // result: (RSB (RSBshiftLL <x.Type> x x [log2(c+1)]) a) 10251 for { 10252 _ = v.Args[2] 10253 v_0 := v.Args[0] 10254 if v_0.Op != OpARMMOVWconst { 10255 break 10256 } 10257 c := v_0.AuxInt 10258 x := v.Args[1] 10259 a := v.Args[2] 10260 if !(isPowerOfTwo(c+1) && int32(c) >= 7) { 10261 break 10262 } 10263 v.reset(OpARMRSB) 10264 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 10265 v0.AuxInt = log2(c + 1) 10266 v0.AddArg(x) 10267 v0.AddArg(x) 10268 v.AddArg(v0) 10269 v.AddArg(a) 10270 return true 10271 } 10272 // match: (MULS (MOVWconst [c]) x a) 10273 // cond: c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c) 10274 // result: (RSB (SLLconst <x.Type> [log2(c/3)] (ADDshiftLL <x.Type> x x [1])) a) 10275 for { 10276 _ = v.Args[2] 10277 v_0 := v.Args[0] 10278 if v_0.Op != OpARMMOVWconst { 10279 break 10280 } 10281 c := v_0.AuxInt 10282 x := v.Args[1] 10283 a := v.Args[2] 10284 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) { 10285 break 10286 } 10287 v.reset(OpARMRSB) 10288 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10289 v0.AuxInt = log2(c / 3) 10290 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10291 v1.AuxInt = 1 10292 v1.AddArg(x) 10293 v1.AddArg(x) 10294 v0.AddArg(v1) 10295 v.AddArg(v0) 10296 v.AddArg(a) 10297 return true 10298 } 10299 // match: (MULS (MOVWconst [c]) x a) 10300 // cond: c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c) 10301 // result: (RSB (SLLconst <x.Type> [log2(c/5)] (ADDshiftLL <x.Type> x x [2])) a) 10302 for { 10303 _ = v.Args[2] 10304 v_0 := v.Args[0] 10305 if v_0.Op != OpARMMOVWconst { 10306 break 10307 } 10308 c := v_0.AuxInt 10309 x := v.Args[1] 10310 a := v.Args[2] 10311 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) { 10312 break 10313 } 10314 v.reset(OpARMRSB) 10315 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10316 v0.AuxInt = log2(c / 5) 10317 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10318 v1.AuxInt = 2 10319 v1.AddArg(x) 10320 v1.AddArg(x) 10321 v0.AddArg(v1) 10322 v.AddArg(v0) 10323 v.AddArg(a) 10324 return true 10325 } 10326 // match: (MULS (MOVWconst [c]) x a) 10327 // cond: c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c) 10328 // result: (RSB (SLLconst <x.Type> [log2(c/7)] (RSBshiftLL <x.Type> x x [3])) a) 10329 for { 10330 _ = v.Args[2] 10331 v_0 := v.Args[0] 10332 if v_0.Op != OpARMMOVWconst { 10333 break 10334 } 10335 c := v_0.AuxInt 10336 x := v.Args[1] 10337 a := v.Args[2] 10338 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) { 10339 break 10340 } 10341 v.reset(OpARMRSB) 10342 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10343 v0.AuxInt = log2(c / 7) 10344 v1 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 10345 v1.AuxInt = 3 10346 v1.AddArg(x) 10347 v1.AddArg(x) 10348 v0.AddArg(v1) 10349 v.AddArg(v0) 10350 v.AddArg(a) 10351 return true 10352 } 10353 // match: (MULS (MOVWconst [c]) x a) 10354 // cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c) 10355 // result: (RSB (SLLconst <x.Type> [log2(c/9)] (ADDshiftLL <x.Type> x x [3])) a) 10356 for { 10357 _ = v.Args[2] 10358 v_0 := v.Args[0] 10359 if v_0.Op != OpARMMOVWconst { 10360 break 10361 } 10362 c := v_0.AuxInt 10363 x := v.Args[1] 10364 a := v.Args[2] 10365 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) { 10366 break 10367 } 10368 v.reset(OpARMRSB) 10369 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10370 v0.AuxInt = log2(c / 9) 10371 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10372 v1.AuxInt = 3 10373 v1.AddArg(x) 10374 v1.AddArg(x) 10375 v0.AddArg(v1) 10376 v.AddArg(v0) 10377 v.AddArg(a) 10378 return true 10379 } 10380 return false 10381 } 10382 func rewriteValueARM_OpARMMULS_20(v *Value) bool { 10383 // match: (MULS (MOVWconst [c]) (MOVWconst [d]) a) 10384 // cond: 10385 // result: (SUBconst [int64(int32(c*d))] a) 10386 for { 10387 _ = v.Args[2] 10388 v_0 := v.Args[0] 10389 if v_0.Op != OpARMMOVWconst { 10390 break 10391 } 10392 c := v_0.AuxInt 10393 v_1 := v.Args[1] 10394 if v_1.Op != OpARMMOVWconst { 10395 break 10396 } 10397 d := v_1.AuxInt 10398 a := v.Args[2] 10399 v.reset(OpARMSUBconst) 10400 v.AuxInt = int64(int32(c * d)) 10401 v.AddArg(a) 10402 return true 10403 } 10404 return false 10405 } 10406 func rewriteValueARM_OpARMMVN_0(v *Value) bool { 10407 // match: (MVN (MOVWconst [c])) 10408 // cond: 10409 // result: (MOVWconst [^c]) 10410 for { 10411 v_0 := v.Args[0] 10412 if v_0.Op != OpARMMOVWconst { 10413 break 10414 } 10415 c := v_0.AuxInt 10416 v.reset(OpARMMOVWconst) 10417 v.AuxInt = ^c 10418 return true 10419 } 10420 // match: (MVN (SLLconst [c] x)) 10421 // cond: 10422 // result: (MVNshiftLL x [c]) 10423 for { 10424 v_0 := v.Args[0] 10425 if v_0.Op != OpARMSLLconst { 10426 break 10427 } 10428 c := v_0.AuxInt 10429 x := v_0.Args[0] 10430 v.reset(OpARMMVNshiftLL) 10431 v.AuxInt = c 10432 v.AddArg(x) 10433 return true 10434 } 10435 // match: (MVN (SRLconst [c] x)) 10436 // cond: 10437 // result: (MVNshiftRL x [c]) 10438 for { 10439 v_0 := v.Args[0] 10440 if v_0.Op != OpARMSRLconst { 10441 break 10442 } 10443 c := v_0.AuxInt 10444 x := v_0.Args[0] 10445 v.reset(OpARMMVNshiftRL) 10446 v.AuxInt = c 10447 v.AddArg(x) 10448 return true 10449 } 10450 // match: (MVN (SRAconst [c] x)) 10451 // cond: 10452 // result: (MVNshiftRA x [c]) 10453 for { 10454 v_0 := v.Args[0] 10455 if v_0.Op != OpARMSRAconst { 10456 break 10457 } 10458 c := v_0.AuxInt 10459 x := v_0.Args[0] 10460 v.reset(OpARMMVNshiftRA) 10461 v.AuxInt = c 10462 v.AddArg(x) 10463 return true 10464 } 10465 // match: (MVN (SLL x y)) 10466 // cond: 10467 // result: (MVNshiftLLreg x y) 10468 for { 10469 v_0 := v.Args[0] 10470 if v_0.Op != OpARMSLL { 10471 break 10472 } 10473 _ = v_0.Args[1] 10474 x := v_0.Args[0] 10475 y := v_0.Args[1] 10476 v.reset(OpARMMVNshiftLLreg) 10477 v.AddArg(x) 10478 v.AddArg(y) 10479 return true 10480 } 10481 // match: (MVN (SRL x y)) 10482 // cond: 10483 // result: (MVNshiftRLreg x y) 10484 for { 10485 v_0 := v.Args[0] 10486 if v_0.Op != OpARMSRL { 10487 break 10488 } 10489 _ = v_0.Args[1] 10490 x := v_0.Args[0] 10491 y := v_0.Args[1] 10492 v.reset(OpARMMVNshiftRLreg) 10493 v.AddArg(x) 10494 v.AddArg(y) 10495 return true 10496 } 10497 // match: (MVN (SRA x y)) 10498 // cond: 10499 // result: (MVNshiftRAreg x y) 10500 for { 10501 v_0 := v.Args[0] 10502 if v_0.Op != OpARMSRA { 10503 break 10504 } 10505 _ = v_0.Args[1] 10506 x := v_0.Args[0] 10507 y := v_0.Args[1] 10508 v.reset(OpARMMVNshiftRAreg) 10509 v.AddArg(x) 10510 v.AddArg(y) 10511 return true 10512 } 10513 return false 10514 } 10515 func rewriteValueARM_OpARMMVNshiftLL_0(v *Value) bool { 10516 // match: (MVNshiftLL (MOVWconst [c]) [d]) 10517 // cond: 10518 // result: (MOVWconst [^int64(uint32(c)<<uint64(d))]) 10519 for { 10520 d := v.AuxInt 10521 v_0 := v.Args[0] 10522 if v_0.Op != OpARMMOVWconst { 10523 break 10524 } 10525 c := v_0.AuxInt 10526 v.reset(OpARMMOVWconst) 10527 v.AuxInt = ^int64(uint32(c) << uint64(d)) 10528 return true 10529 } 10530 return false 10531 } 10532 func rewriteValueARM_OpARMMVNshiftLLreg_0(v *Value) bool { 10533 // match: (MVNshiftLLreg x (MOVWconst [c])) 10534 // cond: 10535 // result: (MVNshiftLL x [c]) 10536 for { 10537 _ = v.Args[1] 10538 x := v.Args[0] 10539 v_1 := v.Args[1] 10540 if v_1.Op != OpARMMOVWconst { 10541 break 10542 } 10543 c := v_1.AuxInt 10544 v.reset(OpARMMVNshiftLL) 10545 v.AuxInt = c 10546 v.AddArg(x) 10547 return true 10548 } 10549 return false 10550 } 10551 func rewriteValueARM_OpARMMVNshiftRA_0(v *Value) bool { 10552 // match: (MVNshiftRA (MOVWconst [c]) [d]) 10553 // cond: 10554 // result: (MOVWconst [^int64(int32(c)>>uint64(d))]) 10555 for { 10556 d := v.AuxInt 10557 v_0 := v.Args[0] 10558 if v_0.Op != OpARMMOVWconst { 10559 break 10560 } 10561 c := v_0.AuxInt 10562 v.reset(OpARMMOVWconst) 10563 v.AuxInt = ^int64(int32(c) >> uint64(d)) 10564 return true 10565 } 10566 return false 10567 } 10568 func rewriteValueARM_OpARMMVNshiftRAreg_0(v *Value) bool { 10569 // match: (MVNshiftRAreg x (MOVWconst [c])) 10570 // cond: 10571 // result: (MVNshiftRA x [c]) 10572 for { 10573 _ = v.Args[1] 10574 x := v.Args[0] 10575 v_1 := v.Args[1] 10576 if v_1.Op != OpARMMOVWconst { 10577 break 10578 } 10579 c := v_1.AuxInt 10580 v.reset(OpARMMVNshiftRA) 10581 v.AuxInt = c 10582 v.AddArg(x) 10583 return true 10584 } 10585 return false 10586 } 10587 func rewriteValueARM_OpARMMVNshiftRL_0(v *Value) bool { 10588 // match: (MVNshiftRL (MOVWconst [c]) [d]) 10589 // cond: 10590 // result: (MOVWconst [^int64(uint32(c)>>uint64(d))]) 10591 for { 10592 d := v.AuxInt 10593 v_0 := v.Args[0] 10594 if v_0.Op != OpARMMOVWconst { 10595 break 10596 } 10597 c := v_0.AuxInt 10598 v.reset(OpARMMOVWconst) 10599 v.AuxInt = ^int64(uint32(c) >> uint64(d)) 10600 return true 10601 } 10602 return false 10603 } 10604 func rewriteValueARM_OpARMMVNshiftRLreg_0(v *Value) bool { 10605 // match: (MVNshiftRLreg x (MOVWconst [c])) 10606 // cond: 10607 // result: (MVNshiftRL x [c]) 10608 for { 10609 _ = v.Args[1] 10610 x := v.Args[0] 10611 v_1 := v.Args[1] 10612 if v_1.Op != OpARMMOVWconst { 10613 break 10614 } 10615 c := v_1.AuxInt 10616 v.reset(OpARMMVNshiftRL) 10617 v.AuxInt = c 10618 v.AddArg(x) 10619 return true 10620 } 10621 return false 10622 } 10623 func rewriteValueARM_OpARMNEGD_0(v *Value) bool { 10624 // match: (NEGD (MULD x y)) 10625 // cond: objabi.GOARM >= 6 10626 // result: (NMULD x y) 10627 for { 10628 v_0 := v.Args[0] 10629 if v_0.Op != OpARMMULD { 10630 break 10631 } 10632 _ = v_0.Args[1] 10633 x := v_0.Args[0] 10634 y := v_0.Args[1] 10635 if !(objabi.GOARM >= 6) { 10636 break 10637 } 10638 v.reset(OpARMNMULD) 10639 v.AddArg(x) 10640 v.AddArg(y) 10641 return true 10642 } 10643 return false 10644 } 10645 func rewriteValueARM_OpARMNEGF_0(v *Value) bool { 10646 // match: (NEGF (MULF x y)) 10647 // cond: objabi.GOARM >= 6 10648 // result: (NMULF x y) 10649 for { 10650 v_0 := v.Args[0] 10651 if v_0.Op != OpARMMULF { 10652 break 10653 } 10654 _ = v_0.Args[1] 10655 x := v_0.Args[0] 10656 y := v_0.Args[1] 10657 if !(objabi.GOARM >= 6) { 10658 break 10659 } 10660 v.reset(OpARMNMULF) 10661 v.AddArg(x) 10662 v.AddArg(y) 10663 return true 10664 } 10665 return false 10666 } 10667 func rewriteValueARM_OpARMNMULD_0(v *Value) bool { 10668 // match: (NMULD (NEGD x) y) 10669 // cond: 10670 // result: (MULD x y) 10671 for { 10672 _ = v.Args[1] 10673 v_0 := v.Args[0] 10674 if v_0.Op != OpARMNEGD { 10675 break 10676 } 10677 x := v_0.Args[0] 10678 y := v.Args[1] 10679 v.reset(OpARMMULD) 10680 v.AddArg(x) 10681 v.AddArg(y) 10682 return true 10683 } 10684 // match: (NMULD y (NEGD x)) 10685 // cond: 10686 // result: (MULD x y) 10687 for { 10688 _ = v.Args[1] 10689 y := v.Args[0] 10690 v_1 := v.Args[1] 10691 if v_1.Op != OpARMNEGD { 10692 break 10693 } 10694 x := v_1.Args[0] 10695 v.reset(OpARMMULD) 10696 v.AddArg(x) 10697 v.AddArg(y) 10698 return true 10699 } 10700 return false 10701 } 10702 func rewriteValueARM_OpARMNMULF_0(v *Value) bool { 10703 // match: (NMULF (NEGF x) y) 10704 // cond: 10705 // result: (MULF x y) 10706 for { 10707 _ = v.Args[1] 10708 v_0 := v.Args[0] 10709 if v_0.Op != OpARMNEGF { 10710 break 10711 } 10712 x := v_0.Args[0] 10713 y := v.Args[1] 10714 v.reset(OpARMMULF) 10715 v.AddArg(x) 10716 v.AddArg(y) 10717 return true 10718 } 10719 // match: (NMULF y (NEGF x)) 10720 // cond: 10721 // result: (MULF x y) 10722 for { 10723 _ = v.Args[1] 10724 y := v.Args[0] 10725 v_1 := v.Args[1] 10726 if v_1.Op != OpARMNEGF { 10727 break 10728 } 10729 x := v_1.Args[0] 10730 v.reset(OpARMMULF) 10731 v.AddArg(x) 10732 v.AddArg(y) 10733 return true 10734 } 10735 return false 10736 } 10737 func rewriteValueARM_OpARMNotEqual_0(v *Value) bool { 10738 // match: (NotEqual (FlagEQ)) 10739 // cond: 10740 // result: (MOVWconst [0]) 10741 for { 10742 v_0 := v.Args[0] 10743 if v_0.Op != OpARMFlagEQ { 10744 break 10745 } 10746 v.reset(OpARMMOVWconst) 10747 v.AuxInt = 0 10748 return true 10749 } 10750 // match: (NotEqual (FlagLT_ULT)) 10751 // cond: 10752 // result: (MOVWconst [1]) 10753 for { 10754 v_0 := v.Args[0] 10755 if v_0.Op != OpARMFlagLT_ULT { 10756 break 10757 } 10758 v.reset(OpARMMOVWconst) 10759 v.AuxInt = 1 10760 return true 10761 } 10762 // match: (NotEqual (FlagLT_UGT)) 10763 // cond: 10764 // result: (MOVWconst [1]) 10765 for { 10766 v_0 := v.Args[0] 10767 if v_0.Op != OpARMFlagLT_UGT { 10768 break 10769 } 10770 v.reset(OpARMMOVWconst) 10771 v.AuxInt = 1 10772 return true 10773 } 10774 // match: (NotEqual (FlagGT_ULT)) 10775 // cond: 10776 // result: (MOVWconst [1]) 10777 for { 10778 v_0 := v.Args[0] 10779 if v_0.Op != OpARMFlagGT_ULT { 10780 break 10781 } 10782 v.reset(OpARMMOVWconst) 10783 v.AuxInt = 1 10784 return true 10785 } 10786 // match: (NotEqual (FlagGT_UGT)) 10787 // cond: 10788 // result: (MOVWconst [1]) 10789 for { 10790 v_0 := v.Args[0] 10791 if v_0.Op != OpARMFlagGT_UGT { 10792 break 10793 } 10794 v.reset(OpARMMOVWconst) 10795 v.AuxInt = 1 10796 return true 10797 } 10798 // match: (NotEqual (InvertFlags x)) 10799 // cond: 10800 // result: (NotEqual x) 10801 for { 10802 v_0 := v.Args[0] 10803 if v_0.Op != OpARMInvertFlags { 10804 break 10805 } 10806 x := v_0.Args[0] 10807 v.reset(OpARMNotEqual) 10808 v.AddArg(x) 10809 return true 10810 } 10811 return false 10812 } 10813 func rewriteValueARM_OpARMOR_0(v *Value) bool { 10814 // match: (OR x (MOVWconst [c])) 10815 // cond: 10816 // result: (ORconst [c] x) 10817 for { 10818 _ = v.Args[1] 10819 x := v.Args[0] 10820 v_1 := v.Args[1] 10821 if v_1.Op != OpARMMOVWconst { 10822 break 10823 } 10824 c := v_1.AuxInt 10825 v.reset(OpARMORconst) 10826 v.AuxInt = c 10827 v.AddArg(x) 10828 return true 10829 } 10830 // match: (OR (MOVWconst [c]) x) 10831 // cond: 10832 // result: (ORconst [c] x) 10833 for { 10834 _ = v.Args[1] 10835 v_0 := v.Args[0] 10836 if v_0.Op != OpARMMOVWconst { 10837 break 10838 } 10839 c := v_0.AuxInt 10840 x := v.Args[1] 10841 v.reset(OpARMORconst) 10842 v.AuxInt = c 10843 v.AddArg(x) 10844 return true 10845 } 10846 // match: (OR x (SLLconst [c] y)) 10847 // cond: 10848 // result: (ORshiftLL x y [c]) 10849 for { 10850 _ = v.Args[1] 10851 x := v.Args[0] 10852 v_1 := v.Args[1] 10853 if v_1.Op != OpARMSLLconst { 10854 break 10855 } 10856 c := v_1.AuxInt 10857 y := v_1.Args[0] 10858 v.reset(OpARMORshiftLL) 10859 v.AuxInt = c 10860 v.AddArg(x) 10861 v.AddArg(y) 10862 return true 10863 } 10864 // match: (OR (SLLconst [c] y) x) 10865 // cond: 10866 // result: (ORshiftLL x y [c]) 10867 for { 10868 _ = v.Args[1] 10869 v_0 := v.Args[0] 10870 if v_0.Op != OpARMSLLconst { 10871 break 10872 } 10873 c := v_0.AuxInt 10874 y := v_0.Args[0] 10875 x := v.Args[1] 10876 v.reset(OpARMORshiftLL) 10877 v.AuxInt = c 10878 v.AddArg(x) 10879 v.AddArg(y) 10880 return true 10881 } 10882 // match: (OR x (SRLconst [c] y)) 10883 // cond: 10884 // result: (ORshiftRL x y [c]) 10885 for { 10886 _ = v.Args[1] 10887 x := v.Args[0] 10888 v_1 := v.Args[1] 10889 if v_1.Op != OpARMSRLconst { 10890 break 10891 } 10892 c := v_1.AuxInt 10893 y := v_1.Args[0] 10894 v.reset(OpARMORshiftRL) 10895 v.AuxInt = c 10896 v.AddArg(x) 10897 v.AddArg(y) 10898 return true 10899 } 10900 // match: (OR (SRLconst [c] y) x) 10901 // cond: 10902 // result: (ORshiftRL x y [c]) 10903 for { 10904 _ = v.Args[1] 10905 v_0 := v.Args[0] 10906 if v_0.Op != OpARMSRLconst { 10907 break 10908 } 10909 c := v_0.AuxInt 10910 y := v_0.Args[0] 10911 x := v.Args[1] 10912 v.reset(OpARMORshiftRL) 10913 v.AuxInt = c 10914 v.AddArg(x) 10915 v.AddArg(y) 10916 return true 10917 } 10918 // match: (OR x (SRAconst [c] y)) 10919 // cond: 10920 // result: (ORshiftRA x y [c]) 10921 for { 10922 _ = v.Args[1] 10923 x := v.Args[0] 10924 v_1 := v.Args[1] 10925 if v_1.Op != OpARMSRAconst { 10926 break 10927 } 10928 c := v_1.AuxInt 10929 y := v_1.Args[0] 10930 v.reset(OpARMORshiftRA) 10931 v.AuxInt = c 10932 v.AddArg(x) 10933 v.AddArg(y) 10934 return true 10935 } 10936 // match: (OR (SRAconst [c] y) x) 10937 // cond: 10938 // result: (ORshiftRA x y [c]) 10939 for { 10940 _ = v.Args[1] 10941 v_0 := v.Args[0] 10942 if v_0.Op != OpARMSRAconst { 10943 break 10944 } 10945 c := v_0.AuxInt 10946 y := v_0.Args[0] 10947 x := v.Args[1] 10948 v.reset(OpARMORshiftRA) 10949 v.AuxInt = c 10950 v.AddArg(x) 10951 v.AddArg(y) 10952 return true 10953 } 10954 // match: (OR x (SLL y z)) 10955 // cond: 10956 // result: (ORshiftLLreg x y z) 10957 for { 10958 _ = v.Args[1] 10959 x := v.Args[0] 10960 v_1 := v.Args[1] 10961 if v_1.Op != OpARMSLL { 10962 break 10963 } 10964 _ = v_1.Args[1] 10965 y := v_1.Args[0] 10966 z := v_1.Args[1] 10967 v.reset(OpARMORshiftLLreg) 10968 v.AddArg(x) 10969 v.AddArg(y) 10970 v.AddArg(z) 10971 return true 10972 } 10973 // match: (OR (SLL y z) x) 10974 // cond: 10975 // result: (ORshiftLLreg x y z) 10976 for { 10977 _ = v.Args[1] 10978 v_0 := v.Args[0] 10979 if v_0.Op != OpARMSLL { 10980 break 10981 } 10982 _ = v_0.Args[1] 10983 y := v_0.Args[0] 10984 z := v_0.Args[1] 10985 x := v.Args[1] 10986 v.reset(OpARMORshiftLLreg) 10987 v.AddArg(x) 10988 v.AddArg(y) 10989 v.AddArg(z) 10990 return true 10991 } 10992 return false 10993 } 10994 func rewriteValueARM_OpARMOR_10(v *Value) bool { 10995 // match: (OR x (SRL y z)) 10996 // cond: 10997 // result: (ORshiftRLreg x y z) 10998 for { 10999 _ = v.Args[1] 11000 x := v.Args[0] 11001 v_1 := v.Args[1] 11002 if v_1.Op != OpARMSRL { 11003 break 11004 } 11005 _ = v_1.Args[1] 11006 y := v_1.Args[0] 11007 z := v_1.Args[1] 11008 v.reset(OpARMORshiftRLreg) 11009 v.AddArg(x) 11010 v.AddArg(y) 11011 v.AddArg(z) 11012 return true 11013 } 11014 // match: (OR (SRL y z) x) 11015 // cond: 11016 // result: (ORshiftRLreg x y z) 11017 for { 11018 _ = v.Args[1] 11019 v_0 := v.Args[0] 11020 if v_0.Op != OpARMSRL { 11021 break 11022 } 11023 _ = v_0.Args[1] 11024 y := v_0.Args[0] 11025 z := v_0.Args[1] 11026 x := v.Args[1] 11027 v.reset(OpARMORshiftRLreg) 11028 v.AddArg(x) 11029 v.AddArg(y) 11030 v.AddArg(z) 11031 return true 11032 } 11033 // match: (OR x (SRA y z)) 11034 // cond: 11035 // result: (ORshiftRAreg x y z) 11036 for { 11037 _ = v.Args[1] 11038 x := v.Args[0] 11039 v_1 := v.Args[1] 11040 if v_1.Op != OpARMSRA { 11041 break 11042 } 11043 _ = v_1.Args[1] 11044 y := v_1.Args[0] 11045 z := v_1.Args[1] 11046 v.reset(OpARMORshiftRAreg) 11047 v.AddArg(x) 11048 v.AddArg(y) 11049 v.AddArg(z) 11050 return true 11051 } 11052 // match: (OR (SRA y z) x) 11053 // cond: 11054 // result: (ORshiftRAreg x y z) 11055 for { 11056 _ = v.Args[1] 11057 v_0 := v.Args[0] 11058 if v_0.Op != OpARMSRA { 11059 break 11060 } 11061 _ = v_0.Args[1] 11062 y := v_0.Args[0] 11063 z := v_0.Args[1] 11064 x := v.Args[1] 11065 v.reset(OpARMORshiftRAreg) 11066 v.AddArg(x) 11067 v.AddArg(y) 11068 v.AddArg(z) 11069 return true 11070 } 11071 // match: (OR x x) 11072 // cond: 11073 // result: x 11074 for { 11075 _ = v.Args[1] 11076 x := v.Args[0] 11077 if x != v.Args[1] { 11078 break 11079 } 11080 v.reset(OpCopy) 11081 v.Type = x.Type 11082 v.AddArg(x) 11083 return true 11084 } 11085 return false 11086 } 11087 func rewriteValueARM_OpARMORconst_0(v *Value) bool { 11088 // match: (ORconst [0] x) 11089 // cond: 11090 // result: x 11091 for { 11092 if v.AuxInt != 0 { 11093 break 11094 } 11095 x := v.Args[0] 11096 v.reset(OpCopy) 11097 v.Type = x.Type 11098 v.AddArg(x) 11099 return true 11100 } 11101 // match: (ORconst [c] _) 11102 // cond: int32(c)==-1 11103 // result: (MOVWconst [-1]) 11104 for { 11105 c := v.AuxInt 11106 if !(int32(c) == -1) { 11107 break 11108 } 11109 v.reset(OpARMMOVWconst) 11110 v.AuxInt = -1 11111 return true 11112 } 11113 // match: (ORconst [c] (MOVWconst [d])) 11114 // cond: 11115 // result: (MOVWconst [c|d]) 11116 for { 11117 c := v.AuxInt 11118 v_0 := v.Args[0] 11119 if v_0.Op != OpARMMOVWconst { 11120 break 11121 } 11122 d := v_0.AuxInt 11123 v.reset(OpARMMOVWconst) 11124 v.AuxInt = c | d 11125 return true 11126 } 11127 // match: (ORconst [c] (ORconst [d] x)) 11128 // cond: 11129 // result: (ORconst [c|d] x) 11130 for { 11131 c := v.AuxInt 11132 v_0 := v.Args[0] 11133 if v_0.Op != OpARMORconst { 11134 break 11135 } 11136 d := v_0.AuxInt 11137 x := v_0.Args[0] 11138 v.reset(OpARMORconst) 11139 v.AuxInt = c | d 11140 v.AddArg(x) 11141 return true 11142 } 11143 return false 11144 } 11145 func rewriteValueARM_OpARMORshiftLL_0(v *Value) bool { 11146 b := v.Block 11147 _ = b 11148 // match: (ORshiftLL (MOVWconst [c]) x [d]) 11149 // cond: 11150 // result: (ORconst [c] (SLLconst <x.Type> x [d])) 11151 for { 11152 d := v.AuxInt 11153 _ = v.Args[1] 11154 v_0 := v.Args[0] 11155 if v_0.Op != OpARMMOVWconst { 11156 break 11157 } 11158 c := v_0.AuxInt 11159 x := v.Args[1] 11160 v.reset(OpARMORconst) 11161 v.AuxInt = c 11162 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 11163 v0.AuxInt = d 11164 v0.AddArg(x) 11165 v.AddArg(v0) 11166 return true 11167 } 11168 // match: (ORshiftLL x (MOVWconst [c]) [d]) 11169 // cond: 11170 // result: (ORconst x [int64(uint32(c)<<uint64(d))]) 11171 for { 11172 d := v.AuxInt 11173 _ = v.Args[1] 11174 x := v.Args[0] 11175 v_1 := v.Args[1] 11176 if v_1.Op != OpARMMOVWconst { 11177 break 11178 } 11179 c := v_1.AuxInt 11180 v.reset(OpARMORconst) 11181 v.AuxInt = int64(uint32(c) << uint64(d)) 11182 v.AddArg(x) 11183 return true 11184 } 11185 // match: (ORshiftLL [c] (SRLconst x [32-c]) x) 11186 // cond: 11187 // result: (SRRconst [32-c] x) 11188 for { 11189 c := v.AuxInt 11190 _ = v.Args[1] 11191 v_0 := v.Args[0] 11192 if v_0.Op != OpARMSRLconst { 11193 break 11194 } 11195 if v_0.AuxInt != 32-c { 11196 break 11197 } 11198 x := v_0.Args[0] 11199 if x != v.Args[1] { 11200 break 11201 } 11202 v.reset(OpARMSRRconst) 11203 v.AuxInt = 32 - c 11204 v.AddArg(x) 11205 return true 11206 } 11207 // match: (ORshiftLL x y:(SLLconst x [c]) [d]) 11208 // cond: c==d 11209 // result: y 11210 for { 11211 d := v.AuxInt 11212 _ = v.Args[1] 11213 x := v.Args[0] 11214 y := v.Args[1] 11215 if y.Op != OpARMSLLconst { 11216 break 11217 } 11218 c := y.AuxInt 11219 if x != y.Args[0] { 11220 break 11221 } 11222 if !(c == d) { 11223 break 11224 } 11225 v.reset(OpCopy) 11226 v.Type = y.Type 11227 v.AddArg(y) 11228 return true 11229 } 11230 return false 11231 } 11232 func rewriteValueARM_OpARMORshiftLLreg_0(v *Value) bool { 11233 b := v.Block 11234 _ = b 11235 // match: (ORshiftLLreg (MOVWconst [c]) x y) 11236 // cond: 11237 // result: (ORconst [c] (SLL <x.Type> x y)) 11238 for { 11239 _ = v.Args[2] 11240 v_0 := v.Args[0] 11241 if v_0.Op != OpARMMOVWconst { 11242 break 11243 } 11244 c := v_0.AuxInt 11245 x := v.Args[1] 11246 y := v.Args[2] 11247 v.reset(OpARMORconst) 11248 v.AuxInt = c 11249 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 11250 v0.AddArg(x) 11251 v0.AddArg(y) 11252 v.AddArg(v0) 11253 return true 11254 } 11255 // match: (ORshiftLLreg x y (MOVWconst [c])) 11256 // cond: 11257 // result: (ORshiftLL x y [c]) 11258 for { 11259 _ = v.Args[2] 11260 x := v.Args[0] 11261 y := v.Args[1] 11262 v_2 := v.Args[2] 11263 if v_2.Op != OpARMMOVWconst { 11264 break 11265 } 11266 c := v_2.AuxInt 11267 v.reset(OpARMORshiftLL) 11268 v.AuxInt = c 11269 v.AddArg(x) 11270 v.AddArg(y) 11271 return true 11272 } 11273 return false 11274 } 11275 func rewriteValueARM_OpARMORshiftRA_0(v *Value) bool { 11276 b := v.Block 11277 _ = b 11278 // match: (ORshiftRA (MOVWconst [c]) x [d]) 11279 // cond: 11280 // result: (ORconst [c] (SRAconst <x.Type> x [d])) 11281 for { 11282 d := v.AuxInt 11283 _ = v.Args[1] 11284 v_0 := v.Args[0] 11285 if v_0.Op != OpARMMOVWconst { 11286 break 11287 } 11288 c := v_0.AuxInt 11289 x := v.Args[1] 11290 v.reset(OpARMORconst) 11291 v.AuxInt = c 11292 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 11293 v0.AuxInt = d 11294 v0.AddArg(x) 11295 v.AddArg(v0) 11296 return true 11297 } 11298 // match: (ORshiftRA x (MOVWconst [c]) [d]) 11299 // cond: 11300 // result: (ORconst x [int64(int32(c)>>uint64(d))]) 11301 for { 11302 d := v.AuxInt 11303 _ = v.Args[1] 11304 x := v.Args[0] 11305 v_1 := v.Args[1] 11306 if v_1.Op != OpARMMOVWconst { 11307 break 11308 } 11309 c := v_1.AuxInt 11310 v.reset(OpARMORconst) 11311 v.AuxInt = int64(int32(c) >> uint64(d)) 11312 v.AddArg(x) 11313 return true 11314 } 11315 // match: (ORshiftRA x y:(SRAconst x [c]) [d]) 11316 // cond: c==d 11317 // result: y 11318 for { 11319 d := v.AuxInt 11320 _ = v.Args[1] 11321 x := v.Args[0] 11322 y := v.Args[1] 11323 if y.Op != OpARMSRAconst { 11324 break 11325 } 11326 c := y.AuxInt 11327 if x != y.Args[0] { 11328 break 11329 } 11330 if !(c == d) { 11331 break 11332 } 11333 v.reset(OpCopy) 11334 v.Type = y.Type 11335 v.AddArg(y) 11336 return true 11337 } 11338 return false 11339 } 11340 func rewriteValueARM_OpARMORshiftRAreg_0(v *Value) bool { 11341 b := v.Block 11342 _ = b 11343 // match: (ORshiftRAreg (MOVWconst [c]) x y) 11344 // cond: 11345 // result: (ORconst [c] (SRA <x.Type> x y)) 11346 for { 11347 _ = v.Args[2] 11348 v_0 := v.Args[0] 11349 if v_0.Op != OpARMMOVWconst { 11350 break 11351 } 11352 c := v_0.AuxInt 11353 x := v.Args[1] 11354 y := v.Args[2] 11355 v.reset(OpARMORconst) 11356 v.AuxInt = c 11357 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 11358 v0.AddArg(x) 11359 v0.AddArg(y) 11360 v.AddArg(v0) 11361 return true 11362 } 11363 // match: (ORshiftRAreg x y (MOVWconst [c])) 11364 // cond: 11365 // result: (ORshiftRA x y [c]) 11366 for { 11367 _ = v.Args[2] 11368 x := v.Args[0] 11369 y := v.Args[1] 11370 v_2 := v.Args[2] 11371 if v_2.Op != OpARMMOVWconst { 11372 break 11373 } 11374 c := v_2.AuxInt 11375 v.reset(OpARMORshiftRA) 11376 v.AuxInt = c 11377 v.AddArg(x) 11378 v.AddArg(y) 11379 return true 11380 } 11381 return false 11382 } 11383 func rewriteValueARM_OpARMORshiftRL_0(v *Value) bool { 11384 b := v.Block 11385 _ = b 11386 // match: (ORshiftRL (MOVWconst [c]) x [d]) 11387 // cond: 11388 // result: (ORconst [c] (SRLconst <x.Type> x [d])) 11389 for { 11390 d := v.AuxInt 11391 _ = v.Args[1] 11392 v_0 := v.Args[0] 11393 if v_0.Op != OpARMMOVWconst { 11394 break 11395 } 11396 c := v_0.AuxInt 11397 x := v.Args[1] 11398 v.reset(OpARMORconst) 11399 v.AuxInt = c 11400 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 11401 v0.AuxInt = d 11402 v0.AddArg(x) 11403 v.AddArg(v0) 11404 return true 11405 } 11406 // match: (ORshiftRL x (MOVWconst [c]) [d]) 11407 // cond: 11408 // result: (ORconst x [int64(uint32(c)>>uint64(d))]) 11409 for { 11410 d := v.AuxInt 11411 _ = v.Args[1] 11412 x := v.Args[0] 11413 v_1 := v.Args[1] 11414 if v_1.Op != OpARMMOVWconst { 11415 break 11416 } 11417 c := v_1.AuxInt 11418 v.reset(OpARMORconst) 11419 v.AuxInt = int64(uint32(c) >> uint64(d)) 11420 v.AddArg(x) 11421 return true 11422 } 11423 // match: (ORshiftRL [c] (SLLconst x [32-c]) x) 11424 // cond: 11425 // result: (SRRconst [ c] x) 11426 for { 11427 c := v.AuxInt 11428 _ = v.Args[1] 11429 v_0 := v.Args[0] 11430 if v_0.Op != OpARMSLLconst { 11431 break 11432 } 11433 if v_0.AuxInt != 32-c { 11434 break 11435 } 11436 x := v_0.Args[0] 11437 if x != v.Args[1] { 11438 break 11439 } 11440 v.reset(OpARMSRRconst) 11441 v.AuxInt = c 11442 v.AddArg(x) 11443 return true 11444 } 11445 // match: (ORshiftRL x y:(SRLconst x [c]) [d]) 11446 // cond: c==d 11447 // result: y 11448 for { 11449 d := v.AuxInt 11450 _ = v.Args[1] 11451 x := v.Args[0] 11452 y := v.Args[1] 11453 if y.Op != OpARMSRLconst { 11454 break 11455 } 11456 c := y.AuxInt 11457 if x != y.Args[0] { 11458 break 11459 } 11460 if !(c == d) { 11461 break 11462 } 11463 v.reset(OpCopy) 11464 v.Type = y.Type 11465 v.AddArg(y) 11466 return true 11467 } 11468 return false 11469 } 11470 func rewriteValueARM_OpARMORshiftRLreg_0(v *Value) bool { 11471 b := v.Block 11472 _ = b 11473 // match: (ORshiftRLreg (MOVWconst [c]) x y) 11474 // cond: 11475 // result: (ORconst [c] (SRL <x.Type> x y)) 11476 for { 11477 _ = v.Args[2] 11478 v_0 := v.Args[0] 11479 if v_0.Op != OpARMMOVWconst { 11480 break 11481 } 11482 c := v_0.AuxInt 11483 x := v.Args[1] 11484 y := v.Args[2] 11485 v.reset(OpARMORconst) 11486 v.AuxInt = c 11487 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 11488 v0.AddArg(x) 11489 v0.AddArg(y) 11490 v.AddArg(v0) 11491 return true 11492 } 11493 // match: (ORshiftRLreg x y (MOVWconst [c])) 11494 // cond: 11495 // result: (ORshiftRL x y [c]) 11496 for { 11497 _ = v.Args[2] 11498 x := v.Args[0] 11499 y := v.Args[1] 11500 v_2 := v.Args[2] 11501 if v_2.Op != OpARMMOVWconst { 11502 break 11503 } 11504 c := v_2.AuxInt 11505 v.reset(OpARMORshiftRL) 11506 v.AuxInt = c 11507 v.AddArg(x) 11508 v.AddArg(y) 11509 return true 11510 } 11511 return false 11512 } 11513 func rewriteValueARM_OpARMRSB_0(v *Value) bool { 11514 // match: (RSB (MOVWconst [c]) x) 11515 // cond: 11516 // result: (SUBconst [c] x) 11517 for { 11518 _ = v.Args[1] 11519 v_0 := v.Args[0] 11520 if v_0.Op != OpARMMOVWconst { 11521 break 11522 } 11523 c := v_0.AuxInt 11524 x := v.Args[1] 11525 v.reset(OpARMSUBconst) 11526 v.AuxInt = c 11527 v.AddArg(x) 11528 return true 11529 } 11530 // match: (RSB x (MOVWconst [c])) 11531 // cond: 11532 // result: (RSBconst [c] x) 11533 for { 11534 _ = v.Args[1] 11535 x := v.Args[0] 11536 v_1 := v.Args[1] 11537 if v_1.Op != OpARMMOVWconst { 11538 break 11539 } 11540 c := v_1.AuxInt 11541 v.reset(OpARMRSBconst) 11542 v.AuxInt = c 11543 v.AddArg(x) 11544 return true 11545 } 11546 // match: (RSB x (SLLconst [c] y)) 11547 // cond: 11548 // result: (RSBshiftLL x y [c]) 11549 for { 11550 _ = v.Args[1] 11551 x := v.Args[0] 11552 v_1 := v.Args[1] 11553 if v_1.Op != OpARMSLLconst { 11554 break 11555 } 11556 c := v_1.AuxInt 11557 y := v_1.Args[0] 11558 v.reset(OpARMRSBshiftLL) 11559 v.AuxInt = c 11560 v.AddArg(x) 11561 v.AddArg(y) 11562 return true 11563 } 11564 // match: (RSB (SLLconst [c] y) x) 11565 // cond: 11566 // result: (SUBshiftLL x y [c]) 11567 for { 11568 _ = v.Args[1] 11569 v_0 := v.Args[0] 11570 if v_0.Op != OpARMSLLconst { 11571 break 11572 } 11573 c := v_0.AuxInt 11574 y := v_0.Args[0] 11575 x := v.Args[1] 11576 v.reset(OpARMSUBshiftLL) 11577 v.AuxInt = c 11578 v.AddArg(x) 11579 v.AddArg(y) 11580 return true 11581 } 11582 // match: (RSB x (SRLconst [c] y)) 11583 // cond: 11584 // result: (RSBshiftRL x y [c]) 11585 for { 11586 _ = v.Args[1] 11587 x := v.Args[0] 11588 v_1 := v.Args[1] 11589 if v_1.Op != OpARMSRLconst { 11590 break 11591 } 11592 c := v_1.AuxInt 11593 y := v_1.Args[0] 11594 v.reset(OpARMRSBshiftRL) 11595 v.AuxInt = c 11596 v.AddArg(x) 11597 v.AddArg(y) 11598 return true 11599 } 11600 // match: (RSB (SRLconst [c] y) x) 11601 // cond: 11602 // result: (SUBshiftRL x y [c]) 11603 for { 11604 _ = v.Args[1] 11605 v_0 := v.Args[0] 11606 if v_0.Op != OpARMSRLconst { 11607 break 11608 } 11609 c := v_0.AuxInt 11610 y := v_0.Args[0] 11611 x := v.Args[1] 11612 v.reset(OpARMSUBshiftRL) 11613 v.AuxInt = c 11614 v.AddArg(x) 11615 v.AddArg(y) 11616 return true 11617 } 11618 // match: (RSB x (SRAconst [c] y)) 11619 // cond: 11620 // result: (RSBshiftRA x y [c]) 11621 for { 11622 _ = v.Args[1] 11623 x := v.Args[0] 11624 v_1 := v.Args[1] 11625 if v_1.Op != OpARMSRAconst { 11626 break 11627 } 11628 c := v_1.AuxInt 11629 y := v_1.Args[0] 11630 v.reset(OpARMRSBshiftRA) 11631 v.AuxInt = c 11632 v.AddArg(x) 11633 v.AddArg(y) 11634 return true 11635 } 11636 // match: (RSB (SRAconst [c] y) x) 11637 // cond: 11638 // result: (SUBshiftRA x y [c]) 11639 for { 11640 _ = v.Args[1] 11641 v_0 := v.Args[0] 11642 if v_0.Op != OpARMSRAconst { 11643 break 11644 } 11645 c := v_0.AuxInt 11646 y := v_0.Args[0] 11647 x := v.Args[1] 11648 v.reset(OpARMSUBshiftRA) 11649 v.AuxInt = c 11650 v.AddArg(x) 11651 v.AddArg(y) 11652 return true 11653 } 11654 // match: (RSB x (SLL y z)) 11655 // cond: 11656 // result: (RSBshiftLLreg x y z) 11657 for { 11658 _ = v.Args[1] 11659 x := v.Args[0] 11660 v_1 := v.Args[1] 11661 if v_1.Op != OpARMSLL { 11662 break 11663 } 11664 _ = v_1.Args[1] 11665 y := v_1.Args[0] 11666 z := v_1.Args[1] 11667 v.reset(OpARMRSBshiftLLreg) 11668 v.AddArg(x) 11669 v.AddArg(y) 11670 v.AddArg(z) 11671 return true 11672 } 11673 // match: (RSB (SLL y z) x) 11674 // cond: 11675 // result: (SUBshiftLLreg x y z) 11676 for { 11677 _ = v.Args[1] 11678 v_0 := v.Args[0] 11679 if v_0.Op != OpARMSLL { 11680 break 11681 } 11682 _ = v_0.Args[1] 11683 y := v_0.Args[0] 11684 z := v_0.Args[1] 11685 x := v.Args[1] 11686 v.reset(OpARMSUBshiftLLreg) 11687 v.AddArg(x) 11688 v.AddArg(y) 11689 v.AddArg(z) 11690 return true 11691 } 11692 return false 11693 } 11694 func rewriteValueARM_OpARMRSB_10(v *Value) bool { 11695 // match: (RSB x (SRL y z)) 11696 // cond: 11697 // result: (RSBshiftRLreg x y z) 11698 for { 11699 _ = v.Args[1] 11700 x := v.Args[0] 11701 v_1 := v.Args[1] 11702 if v_1.Op != OpARMSRL { 11703 break 11704 } 11705 _ = v_1.Args[1] 11706 y := v_1.Args[0] 11707 z := v_1.Args[1] 11708 v.reset(OpARMRSBshiftRLreg) 11709 v.AddArg(x) 11710 v.AddArg(y) 11711 v.AddArg(z) 11712 return true 11713 } 11714 // match: (RSB (SRL y z) x) 11715 // cond: 11716 // result: (SUBshiftRLreg x y z) 11717 for { 11718 _ = v.Args[1] 11719 v_0 := v.Args[0] 11720 if v_0.Op != OpARMSRL { 11721 break 11722 } 11723 _ = v_0.Args[1] 11724 y := v_0.Args[0] 11725 z := v_0.Args[1] 11726 x := v.Args[1] 11727 v.reset(OpARMSUBshiftRLreg) 11728 v.AddArg(x) 11729 v.AddArg(y) 11730 v.AddArg(z) 11731 return true 11732 } 11733 // match: (RSB x (SRA y z)) 11734 // cond: 11735 // result: (RSBshiftRAreg x y z) 11736 for { 11737 _ = v.Args[1] 11738 x := v.Args[0] 11739 v_1 := v.Args[1] 11740 if v_1.Op != OpARMSRA { 11741 break 11742 } 11743 _ = v_1.Args[1] 11744 y := v_1.Args[0] 11745 z := v_1.Args[1] 11746 v.reset(OpARMRSBshiftRAreg) 11747 v.AddArg(x) 11748 v.AddArg(y) 11749 v.AddArg(z) 11750 return true 11751 } 11752 // match: (RSB (SRA y z) x) 11753 // cond: 11754 // result: (SUBshiftRAreg x y z) 11755 for { 11756 _ = v.Args[1] 11757 v_0 := v.Args[0] 11758 if v_0.Op != OpARMSRA { 11759 break 11760 } 11761 _ = v_0.Args[1] 11762 y := v_0.Args[0] 11763 z := v_0.Args[1] 11764 x := v.Args[1] 11765 v.reset(OpARMSUBshiftRAreg) 11766 v.AddArg(x) 11767 v.AddArg(y) 11768 v.AddArg(z) 11769 return true 11770 } 11771 // match: (RSB x x) 11772 // cond: 11773 // result: (MOVWconst [0]) 11774 for { 11775 _ = v.Args[1] 11776 x := v.Args[0] 11777 if x != v.Args[1] { 11778 break 11779 } 11780 v.reset(OpARMMOVWconst) 11781 v.AuxInt = 0 11782 return true 11783 } 11784 // match: (RSB (MUL x y) a) 11785 // cond: objabi.GOARM == 7 11786 // result: (MULS x y a) 11787 for { 11788 _ = v.Args[1] 11789 v_0 := v.Args[0] 11790 if v_0.Op != OpARMMUL { 11791 break 11792 } 11793 _ = v_0.Args[1] 11794 x := v_0.Args[0] 11795 y := v_0.Args[1] 11796 a := v.Args[1] 11797 if !(objabi.GOARM == 7) { 11798 break 11799 } 11800 v.reset(OpARMMULS) 11801 v.AddArg(x) 11802 v.AddArg(y) 11803 v.AddArg(a) 11804 return true 11805 } 11806 return false 11807 } 11808 func rewriteValueARM_OpARMRSBSshiftLL_0(v *Value) bool { 11809 b := v.Block 11810 _ = b 11811 // match: (RSBSshiftLL (MOVWconst [c]) x [d]) 11812 // cond: 11813 // result: (SUBSconst [c] (SLLconst <x.Type> x [d])) 11814 for { 11815 d := v.AuxInt 11816 _ = v.Args[1] 11817 v_0 := v.Args[0] 11818 if v_0.Op != OpARMMOVWconst { 11819 break 11820 } 11821 c := v_0.AuxInt 11822 x := v.Args[1] 11823 v.reset(OpARMSUBSconst) 11824 v.AuxInt = c 11825 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 11826 v0.AuxInt = d 11827 v0.AddArg(x) 11828 v.AddArg(v0) 11829 return true 11830 } 11831 // match: (RSBSshiftLL x (MOVWconst [c]) [d]) 11832 // cond: 11833 // result: (RSBSconst x [int64(uint32(c)<<uint64(d))]) 11834 for { 11835 d := v.AuxInt 11836 _ = v.Args[1] 11837 x := v.Args[0] 11838 v_1 := v.Args[1] 11839 if v_1.Op != OpARMMOVWconst { 11840 break 11841 } 11842 c := v_1.AuxInt 11843 v.reset(OpARMRSBSconst) 11844 v.AuxInt = int64(uint32(c) << uint64(d)) 11845 v.AddArg(x) 11846 return true 11847 } 11848 return false 11849 } 11850 func rewriteValueARM_OpARMRSBSshiftLLreg_0(v *Value) bool { 11851 b := v.Block 11852 _ = b 11853 // match: (RSBSshiftLLreg (MOVWconst [c]) x y) 11854 // cond: 11855 // result: (SUBSconst [c] (SLL <x.Type> x y)) 11856 for { 11857 _ = v.Args[2] 11858 v_0 := v.Args[0] 11859 if v_0.Op != OpARMMOVWconst { 11860 break 11861 } 11862 c := v_0.AuxInt 11863 x := v.Args[1] 11864 y := v.Args[2] 11865 v.reset(OpARMSUBSconst) 11866 v.AuxInt = c 11867 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 11868 v0.AddArg(x) 11869 v0.AddArg(y) 11870 v.AddArg(v0) 11871 return true 11872 } 11873 // match: (RSBSshiftLLreg x y (MOVWconst [c])) 11874 // cond: 11875 // result: (RSBSshiftLL x y [c]) 11876 for { 11877 _ = v.Args[2] 11878 x := v.Args[0] 11879 y := v.Args[1] 11880 v_2 := v.Args[2] 11881 if v_2.Op != OpARMMOVWconst { 11882 break 11883 } 11884 c := v_2.AuxInt 11885 v.reset(OpARMRSBSshiftLL) 11886 v.AuxInt = c 11887 v.AddArg(x) 11888 v.AddArg(y) 11889 return true 11890 } 11891 return false 11892 } 11893 func rewriteValueARM_OpARMRSBSshiftRA_0(v *Value) bool { 11894 b := v.Block 11895 _ = b 11896 // match: (RSBSshiftRA (MOVWconst [c]) x [d]) 11897 // cond: 11898 // result: (SUBSconst [c] (SRAconst <x.Type> x [d])) 11899 for { 11900 d := v.AuxInt 11901 _ = v.Args[1] 11902 v_0 := v.Args[0] 11903 if v_0.Op != OpARMMOVWconst { 11904 break 11905 } 11906 c := v_0.AuxInt 11907 x := v.Args[1] 11908 v.reset(OpARMSUBSconst) 11909 v.AuxInt = c 11910 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 11911 v0.AuxInt = d 11912 v0.AddArg(x) 11913 v.AddArg(v0) 11914 return true 11915 } 11916 // match: (RSBSshiftRA x (MOVWconst [c]) [d]) 11917 // cond: 11918 // result: (RSBSconst x [int64(int32(c)>>uint64(d))]) 11919 for { 11920 d := v.AuxInt 11921 _ = v.Args[1] 11922 x := v.Args[0] 11923 v_1 := v.Args[1] 11924 if v_1.Op != OpARMMOVWconst { 11925 break 11926 } 11927 c := v_1.AuxInt 11928 v.reset(OpARMRSBSconst) 11929 v.AuxInt = int64(int32(c) >> uint64(d)) 11930 v.AddArg(x) 11931 return true 11932 } 11933 return false 11934 } 11935 func rewriteValueARM_OpARMRSBSshiftRAreg_0(v *Value) bool { 11936 b := v.Block 11937 _ = b 11938 // match: (RSBSshiftRAreg (MOVWconst [c]) x y) 11939 // cond: 11940 // result: (SUBSconst [c] (SRA <x.Type> x y)) 11941 for { 11942 _ = v.Args[2] 11943 v_0 := v.Args[0] 11944 if v_0.Op != OpARMMOVWconst { 11945 break 11946 } 11947 c := v_0.AuxInt 11948 x := v.Args[1] 11949 y := v.Args[2] 11950 v.reset(OpARMSUBSconst) 11951 v.AuxInt = c 11952 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 11953 v0.AddArg(x) 11954 v0.AddArg(y) 11955 v.AddArg(v0) 11956 return true 11957 } 11958 // match: (RSBSshiftRAreg x y (MOVWconst [c])) 11959 // cond: 11960 // result: (RSBSshiftRA x y [c]) 11961 for { 11962 _ = v.Args[2] 11963 x := v.Args[0] 11964 y := v.Args[1] 11965 v_2 := v.Args[2] 11966 if v_2.Op != OpARMMOVWconst { 11967 break 11968 } 11969 c := v_2.AuxInt 11970 v.reset(OpARMRSBSshiftRA) 11971 v.AuxInt = c 11972 v.AddArg(x) 11973 v.AddArg(y) 11974 return true 11975 } 11976 return false 11977 } 11978 func rewriteValueARM_OpARMRSBSshiftRL_0(v *Value) bool { 11979 b := v.Block 11980 _ = b 11981 // match: (RSBSshiftRL (MOVWconst [c]) x [d]) 11982 // cond: 11983 // result: (SUBSconst [c] (SRLconst <x.Type> x [d])) 11984 for { 11985 d := v.AuxInt 11986 _ = v.Args[1] 11987 v_0 := v.Args[0] 11988 if v_0.Op != OpARMMOVWconst { 11989 break 11990 } 11991 c := v_0.AuxInt 11992 x := v.Args[1] 11993 v.reset(OpARMSUBSconst) 11994 v.AuxInt = c 11995 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 11996 v0.AuxInt = d 11997 v0.AddArg(x) 11998 v.AddArg(v0) 11999 return true 12000 } 12001 // match: (RSBSshiftRL x (MOVWconst [c]) [d]) 12002 // cond: 12003 // result: (RSBSconst x [int64(uint32(c)>>uint64(d))]) 12004 for { 12005 d := v.AuxInt 12006 _ = v.Args[1] 12007 x := v.Args[0] 12008 v_1 := v.Args[1] 12009 if v_1.Op != OpARMMOVWconst { 12010 break 12011 } 12012 c := v_1.AuxInt 12013 v.reset(OpARMRSBSconst) 12014 v.AuxInt = int64(uint32(c) >> uint64(d)) 12015 v.AddArg(x) 12016 return true 12017 } 12018 return false 12019 } 12020 func rewriteValueARM_OpARMRSBSshiftRLreg_0(v *Value) bool { 12021 b := v.Block 12022 _ = b 12023 // match: (RSBSshiftRLreg (MOVWconst [c]) x y) 12024 // cond: 12025 // result: (SUBSconst [c] (SRL <x.Type> x y)) 12026 for { 12027 _ = v.Args[2] 12028 v_0 := v.Args[0] 12029 if v_0.Op != OpARMMOVWconst { 12030 break 12031 } 12032 c := v_0.AuxInt 12033 x := v.Args[1] 12034 y := v.Args[2] 12035 v.reset(OpARMSUBSconst) 12036 v.AuxInt = c 12037 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 12038 v0.AddArg(x) 12039 v0.AddArg(y) 12040 v.AddArg(v0) 12041 return true 12042 } 12043 // match: (RSBSshiftRLreg x y (MOVWconst [c])) 12044 // cond: 12045 // result: (RSBSshiftRL x y [c]) 12046 for { 12047 _ = v.Args[2] 12048 x := v.Args[0] 12049 y := v.Args[1] 12050 v_2 := v.Args[2] 12051 if v_2.Op != OpARMMOVWconst { 12052 break 12053 } 12054 c := v_2.AuxInt 12055 v.reset(OpARMRSBSshiftRL) 12056 v.AuxInt = c 12057 v.AddArg(x) 12058 v.AddArg(y) 12059 return true 12060 } 12061 return false 12062 } 12063 func rewriteValueARM_OpARMRSBconst_0(v *Value) bool { 12064 // match: (RSBconst [c] (MOVWconst [d])) 12065 // cond: 12066 // result: (MOVWconst [int64(int32(c-d))]) 12067 for { 12068 c := v.AuxInt 12069 v_0 := v.Args[0] 12070 if v_0.Op != OpARMMOVWconst { 12071 break 12072 } 12073 d := v_0.AuxInt 12074 v.reset(OpARMMOVWconst) 12075 v.AuxInt = int64(int32(c - d)) 12076 return true 12077 } 12078 // match: (RSBconst [c] (RSBconst [d] x)) 12079 // cond: 12080 // result: (ADDconst [int64(int32(c-d))] x) 12081 for { 12082 c := v.AuxInt 12083 v_0 := v.Args[0] 12084 if v_0.Op != OpARMRSBconst { 12085 break 12086 } 12087 d := v_0.AuxInt 12088 x := v_0.Args[0] 12089 v.reset(OpARMADDconst) 12090 v.AuxInt = int64(int32(c - d)) 12091 v.AddArg(x) 12092 return true 12093 } 12094 // match: (RSBconst [c] (ADDconst [d] x)) 12095 // cond: 12096 // result: (RSBconst [int64(int32(c-d))] x) 12097 for { 12098 c := v.AuxInt 12099 v_0 := v.Args[0] 12100 if v_0.Op != OpARMADDconst { 12101 break 12102 } 12103 d := v_0.AuxInt 12104 x := v_0.Args[0] 12105 v.reset(OpARMRSBconst) 12106 v.AuxInt = int64(int32(c - d)) 12107 v.AddArg(x) 12108 return true 12109 } 12110 // match: (RSBconst [c] (SUBconst [d] x)) 12111 // cond: 12112 // result: (RSBconst [int64(int32(c+d))] x) 12113 for { 12114 c := v.AuxInt 12115 v_0 := v.Args[0] 12116 if v_0.Op != OpARMSUBconst { 12117 break 12118 } 12119 d := v_0.AuxInt 12120 x := v_0.Args[0] 12121 v.reset(OpARMRSBconst) 12122 v.AuxInt = int64(int32(c + d)) 12123 v.AddArg(x) 12124 return true 12125 } 12126 return false 12127 } 12128 func rewriteValueARM_OpARMRSBshiftLL_0(v *Value) bool { 12129 b := v.Block 12130 _ = b 12131 // match: (RSBshiftLL (MOVWconst [c]) x [d]) 12132 // cond: 12133 // result: (SUBconst [c] (SLLconst <x.Type> x [d])) 12134 for { 12135 d := v.AuxInt 12136 _ = v.Args[1] 12137 v_0 := v.Args[0] 12138 if v_0.Op != OpARMMOVWconst { 12139 break 12140 } 12141 c := v_0.AuxInt 12142 x := v.Args[1] 12143 v.reset(OpARMSUBconst) 12144 v.AuxInt = c 12145 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 12146 v0.AuxInt = d 12147 v0.AddArg(x) 12148 v.AddArg(v0) 12149 return true 12150 } 12151 // match: (RSBshiftLL x (MOVWconst [c]) [d]) 12152 // cond: 12153 // result: (RSBconst x [int64(uint32(c)<<uint64(d))]) 12154 for { 12155 d := v.AuxInt 12156 _ = v.Args[1] 12157 x := v.Args[0] 12158 v_1 := v.Args[1] 12159 if v_1.Op != OpARMMOVWconst { 12160 break 12161 } 12162 c := v_1.AuxInt 12163 v.reset(OpARMRSBconst) 12164 v.AuxInt = int64(uint32(c) << uint64(d)) 12165 v.AddArg(x) 12166 return true 12167 } 12168 // match: (RSBshiftLL x (SLLconst x [c]) [d]) 12169 // cond: c==d 12170 // result: (MOVWconst [0]) 12171 for { 12172 d := v.AuxInt 12173 _ = v.Args[1] 12174 x := v.Args[0] 12175 v_1 := v.Args[1] 12176 if v_1.Op != OpARMSLLconst { 12177 break 12178 } 12179 c := v_1.AuxInt 12180 if x != v_1.Args[0] { 12181 break 12182 } 12183 if !(c == d) { 12184 break 12185 } 12186 v.reset(OpARMMOVWconst) 12187 v.AuxInt = 0 12188 return true 12189 } 12190 return false 12191 } 12192 func rewriteValueARM_OpARMRSBshiftLLreg_0(v *Value) bool { 12193 b := v.Block 12194 _ = b 12195 // match: (RSBshiftLLreg (MOVWconst [c]) x y) 12196 // cond: 12197 // result: (SUBconst [c] (SLL <x.Type> x y)) 12198 for { 12199 _ = v.Args[2] 12200 v_0 := v.Args[0] 12201 if v_0.Op != OpARMMOVWconst { 12202 break 12203 } 12204 c := v_0.AuxInt 12205 x := v.Args[1] 12206 y := v.Args[2] 12207 v.reset(OpARMSUBconst) 12208 v.AuxInt = c 12209 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 12210 v0.AddArg(x) 12211 v0.AddArg(y) 12212 v.AddArg(v0) 12213 return true 12214 } 12215 // match: (RSBshiftLLreg x y (MOVWconst [c])) 12216 // cond: 12217 // result: (RSBshiftLL x y [c]) 12218 for { 12219 _ = v.Args[2] 12220 x := v.Args[0] 12221 y := v.Args[1] 12222 v_2 := v.Args[2] 12223 if v_2.Op != OpARMMOVWconst { 12224 break 12225 } 12226 c := v_2.AuxInt 12227 v.reset(OpARMRSBshiftLL) 12228 v.AuxInt = c 12229 v.AddArg(x) 12230 v.AddArg(y) 12231 return true 12232 } 12233 return false 12234 } 12235 func rewriteValueARM_OpARMRSBshiftRA_0(v *Value) bool { 12236 b := v.Block 12237 _ = b 12238 // match: (RSBshiftRA (MOVWconst [c]) x [d]) 12239 // cond: 12240 // result: (SUBconst [c] (SRAconst <x.Type> x [d])) 12241 for { 12242 d := v.AuxInt 12243 _ = v.Args[1] 12244 v_0 := v.Args[0] 12245 if v_0.Op != OpARMMOVWconst { 12246 break 12247 } 12248 c := v_0.AuxInt 12249 x := v.Args[1] 12250 v.reset(OpARMSUBconst) 12251 v.AuxInt = c 12252 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 12253 v0.AuxInt = d 12254 v0.AddArg(x) 12255 v.AddArg(v0) 12256 return true 12257 } 12258 // match: (RSBshiftRA x (MOVWconst [c]) [d]) 12259 // cond: 12260 // result: (RSBconst x [int64(int32(c)>>uint64(d))]) 12261 for { 12262 d := v.AuxInt 12263 _ = v.Args[1] 12264 x := v.Args[0] 12265 v_1 := v.Args[1] 12266 if v_1.Op != OpARMMOVWconst { 12267 break 12268 } 12269 c := v_1.AuxInt 12270 v.reset(OpARMRSBconst) 12271 v.AuxInt = int64(int32(c) >> uint64(d)) 12272 v.AddArg(x) 12273 return true 12274 } 12275 // match: (RSBshiftRA x (SRAconst x [c]) [d]) 12276 // cond: c==d 12277 // result: (MOVWconst [0]) 12278 for { 12279 d := v.AuxInt 12280 _ = v.Args[1] 12281 x := v.Args[0] 12282 v_1 := v.Args[1] 12283 if v_1.Op != OpARMSRAconst { 12284 break 12285 } 12286 c := v_1.AuxInt 12287 if x != v_1.Args[0] { 12288 break 12289 } 12290 if !(c == d) { 12291 break 12292 } 12293 v.reset(OpARMMOVWconst) 12294 v.AuxInt = 0 12295 return true 12296 } 12297 return false 12298 } 12299 func rewriteValueARM_OpARMRSBshiftRAreg_0(v *Value) bool { 12300 b := v.Block 12301 _ = b 12302 // match: (RSBshiftRAreg (MOVWconst [c]) x y) 12303 // cond: 12304 // result: (SUBconst [c] (SRA <x.Type> x y)) 12305 for { 12306 _ = v.Args[2] 12307 v_0 := v.Args[0] 12308 if v_0.Op != OpARMMOVWconst { 12309 break 12310 } 12311 c := v_0.AuxInt 12312 x := v.Args[1] 12313 y := v.Args[2] 12314 v.reset(OpARMSUBconst) 12315 v.AuxInt = c 12316 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 12317 v0.AddArg(x) 12318 v0.AddArg(y) 12319 v.AddArg(v0) 12320 return true 12321 } 12322 // match: (RSBshiftRAreg x y (MOVWconst [c])) 12323 // cond: 12324 // result: (RSBshiftRA x y [c]) 12325 for { 12326 _ = v.Args[2] 12327 x := v.Args[0] 12328 y := v.Args[1] 12329 v_2 := v.Args[2] 12330 if v_2.Op != OpARMMOVWconst { 12331 break 12332 } 12333 c := v_2.AuxInt 12334 v.reset(OpARMRSBshiftRA) 12335 v.AuxInt = c 12336 v.AddArg(x) 12337 v.AddArg(y) 12338 return true 12339 } 12340 return false 12341 } 12342 func rewriteValueARM_OpARMRSBshiftRL_0(v *Value) bool { 12343 b := v.Block 12344 _ = b 12345 // match: (RSBshiftRL (MOVWconst [c]) x [d]) 12346 // cond: 12347 // result: (SUBconst [c] (SRLconst <x.Type> x [d])) 12348 for { 12349 d := v.AuxInt 12350 _ = v.Args[1] 12351 v_0 := v.Args[0] 12352 if v_0.Op != OpARMMOVWconst { 12353 break 12354 } 12355 c := v_0.AuxInt 12356 x := v.Args[1] 12357 v.reset(OpARMSUBconst) 12358 v.AuxInt = c 12359 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 12360 v0.AuxInt = d 12361 v0.AddArg(x) 12362 v.AddArg(v0) 12363 return true 12364 } 12365 // match: (RSBshiftRL x (MOVWconst [c]) [d]) 12366 // cond: 12367 // result: (RSBconst x [int64(uint32(c)>>uint64(d))]) 12368 for { 12369 d := v.AuxInt 12370 _ = v.Args[1] 12371 x := v.Args[0] 12372 v_1 := v.Args[1] 12373 if v_1.Op != OpARMMOVWconst { 12374 break 12375 } 12376 c := v_1.AuxInt 12377 v.reset(OpARMRSBconst) 12378 v.AuxInt = int64(uint32(c) >> uint64(d)) 12379 v.AddArg(x) 12380 return true 12381 } 12382 // match: (RSBshiftRL x (SRLconst x [c]) [d]) 12383 // cond: c==d 12384 // result: (MOVWconst [0]) 12385 for { 12386 d := v.AuxInt 12387 _ = v.Args[1] 12388 x := v.Args[0] 12389 v_1 := v.Args[1] 12390 if v_1.Op != OpARMSRLconst { 12391 break 12392 } 12393 c := v_1.AuxInt 12394 if x != v_1.Args[0] { 12395 break 12396 } 12397 if !(c == d) { 12398 break 12399 } 12400 v.reset(OpARMMOVWconst) 12401 v.AuxInt = 0 12402 return true 12403 } 12404 return false 12405 } 12406 func rewriteValueARM_OpARMRSBshiftRLreg_0(v *Value) bool { 12407 b := v.Block 12408 _ = b 12409 // match: (RSBshiftRLreg (MOVWconst [c]) x y) 12410 // cond: 12411 // result: (SUBconst [c] (SRL <x.Type> x y)) 12412 for { 12413 _ = v.Args[2] 12414 v_0 := v.Args[0] 12415 if v_0.Op != OpARMMOVWconst { 12416 break 12417 } 12418 c := v_0.AuxInt 12419 x := v.Args[1] 12420 y := v.Args[2] 12421 v.reset(OpARMSUBconst) 12422 v.AuxInt = c 12423 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 12424 v0.AddArg(x) 12425 v0.AddArg(y) 12426 v.AddArg(v0) 12427 return true 12428 } 12429 // match: (RSBshiftRLreg x y (MOVWconst [c])) 12430 // cond: 12431 // result: (RSBshiftRL x y [c]) 12432 for { 12433 _ = v.Args[2] 12434 x := v.Args[0] 12435 y := v.Args[1] 12436 v_2 := v.Args[2] 12437 if v_2.Op != OpARMMOVWconst { 12438 break 12439 } 12440 c := v_2.AuxInt 12441 v.reset(OpARMRSBshiftRL) 12442 v.AuxInt = c 12443 v.AddArg(x) 12444 v.AddArg(y) 12445 return true 12446 } 12447 return false 12448 } 12449 func rewriteValueARM_OpARMRSCconst_0(v *Value) bool { 12450 // match: (RSCconst [c] (ADDconst [d] x) flags) 12451 // cond: 12452 // result: (RSCconst [int64(int32(c-d))] x flags) 12453 for { 12454 c := v.AuxInt 12455 _ = v.Args[1] 12456 v_0 := v.Args[0] 12457 if v_0.Op != OpARMADDconst { 12458 break 12459 } 12460 d := v_0.AuxInt 12461 x := v_0.Args[0] 12462 flags := v.Args[1] 12463 v.reset(OpARMRSCconst) 12464 v.AuxInt = int64(int32(c - d)) 12465 v.AddArg(x) 12466 v.AddArg(flags) 12467 return true 12468 } 12469 // match: (RSCconst [c] (SUBconst [d] x) flags) 12470 // cond: 12471 // result: (RSCconst [int64(int32(c+d))] x flags) 12472 for { 12473 c := v.AuxInt 12474 _ = v.Args[1] 12475 v_0 := v.Args[0] 12476 if v_0.Op != OpARMSUBconst { 12477 break 12478 } 12479 d := v_0.AuxInt 12480 x := v_0.Args[0] 12481 flags := v.Args[1] 12482 v.reset(OpARMRSCconst) 12483 v.AuxInt = int64(int32(c + d)) 12484 v.AddArg(x) 12485 v.AddArg(flags) 12486 return true 12487 } 12488 return false 12489 } 12490 func rewriteValueARM_OpARMRSCshiftLL_0(v *Value) bool { 12491 b := v.Block 12492 _ = b 12493 // match: (RSCshiftLL (MOVWconst [c]) x [d] flags) 12494 // cond: 12495 // result: (SBCconst [c] (SLLconst <x.Type> x [d]) flags) 12496 for { 12497 d := v.AuxInt 12498 _ = v.Args[2] 12499 v_0 := v.Args[0] 12500 if v_0.Op != OpARMMOVWconst { 12501 break 12502 } 12503 c := v_0.AuxInt 12504 x := v.Args[1] 12505 flags := v.Args[2] 12506 v.reset(OpARMSBCconst) 12507 v.AuxInt = c 12508 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 12509 v0.AuxInt = d 12510 v0.AddArg(x) 12511 v.AddArg(v0) 12512 v.AddArg(flags) 12513 return true 12514 } 12515 // match: (RSCshiftLL x (MOVWconst [c]) [d] flags) 12516 // cond: 12517 // result: (RSCconst x [int64(uint32(c)<<uint64(d))] flags) 12518 for { 12519 d := v.AuxInt 12520 _ = v.Args[2] 12521 x := v.Args[0] 12522 v_1 := v.Args[1] 12523 if v_1.Op != OpARMMOVWconst { 12524 break 12525 } 12526 c := v_1.AuxInt 12527 flags := v.Args[2] 12528 v.reset(OpARMRSCconst) 12529 v.AuxInt = int64(uint32(c) << uint64(d)) 12530 v.AddArg(x) 12531 v.AddArg(flags) 12532 return true 12533 } 12534 return false 12535 } 12536 func rewriteValueARM_OpARMRSCshiftLLreg_0(v *Value) bool { 12537 b := v.Block 12538 _ = b 12539 // match: (RSCshiftLLreg (MOVWconst [c]) x y flags) 12540 // cond: 12541 // result: (SBCconst [c] (SLL <x.Type> x y) flags) 12542 for { 12543 _ = v.Args[3] 12544 v_0 := v.Args[0] 12545 if v_0.Op != OpARMMOVWconst { 12546 break 12547 } 12548 c := v_0.AuxInt 12549 x := v.Args[1] 12550 y := v.Args[2] 12551 flags := v.Args[3] 12552 v.reset(OpARMSBCconst) 12553 v.AuxInt = c 12554 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 12555 v0.AddArg(x) 12556 v0.AddArg(y) 12557 v.AddArg(v0) 12558 v.AddArg(flags) 12559 return true 12560 } 12561 // match: (RSCshiftLLreg x y (MOVWconst [c]) flags) 12562 // cond: 12563 // result: (RSCshiftLL x y [c] flags) 12564 for { 12565 _ = v.Args[3] 12566 x := v.Args[0] 12567 y := v.Args[1] 12568 v_2 := v.Args[2] 12569 if v_2.Op != OpARMMOVWconst { 12570 break 12571 } 12572 c := v_2.AuxInt 12573 flags := v.Args[3] 12574 v.reset(OpARMRSCshiftLL) 12575 v.AuxInt = c 12576 v.AddArg(x) 12577 v.AddArg(y) 12578 v.AddArg(flags) 12579 return true 12580 } 12581 return false 12582 } 12583 func rewriteValueARM_OpARMRSCshiftRA_0(v *Value) bool { 12584 b := v.Block 12585 _ = b 12586 // match: (RSCshiftRA (MOVWconst [c]) x [d] flags) 12587 // cond: 12588 // result: (SBCconst [c] (SRAconst <x.Type> x [d]) flags) 12589 for { 12590 d := v.AuxInt 12591 _ = v.Args[2] 12592 v_0 := v.Args[0] 12593 if v_0.Op != OpARMMOVWconst { 12594 break 12595 } 12596 c := v_0.AuxInt 12597 x := v.Args[1] 12598 flags := v.Args[2] 12599 v.reset(OpARMSBCconst) 12600 v.AuxInt = c 12601 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 12602 v0.AuxInt = d 12603 v0.AddArg(x) 12604 v.AddArg(v0) 12605 v.AddArg(flags) 12606 return true 12607 } 12608 // match: (RSCshiftRA x (MOVWconst [c]) [d] flags) 12609 // cond: 12610 // result: (RSCconst x [int64(int32(c)>>uint64(d))] flags) 12611 for { 12612 d := v.AuxInt 12613 _ = v.Args[2] 12614 x := v.Args[0] 12615 v_1 := v.Args[1] 12616 if v_1.Op != OpARMMOVWconst { 12617 break 12618 } 12619 c := v_1.AuxInt 12620 flags := v.Args[2] 12621 v.reset(OpARMRSCconst) 12622 v.AuxInt = int64(int32(c) >> uint64(d)) 12623 v.AddArg(x) 12624 v.AddArg(flags) 12625 return true 12626 } 12627 return false 12628 } 12629 func rewriteValueARM_OpARMRSCshiftRAreg_0(v *Value) bool { 12630 b := v.Block 12631 _ = b 12632 // match: (RSCshiftRAreg (MOVWconst [c]) x y flags) 12633 // cond: 12634 // result: (SBCconst [c] (SRA <x.Type> x y) flags) 12635 for { 12636 _ = v.Args[3] 12637 v_0 := v.Args[0] 12638 if v_0.Op != OpARMMOVWconst { 12639 break 12640 } 12641 c := v_0.AuxInt 12642 x := v.Args[1] 12643 y := v.Args[2] 12644 flags := v.Args[3] 12645 v.reset(OpARMSBCconst) 12646 v.AuxInt = c 12647 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 12648 v0.AddArg(x) 12649 v0.AddArg(y) 12650 v.AddArg(v0) 12651 v.AddArg(flags) 12652 return true 12653 } 12654 // match: (RSCshiftRAreg x y (MOVWconst [c]) flags) 12655 // cond: 12656 // result: (RSCshiftRA x y [c] flags) 12657 for { 12658 _ = v.Args[3] 12659 x := v.Args[0] 12660 y := v.Args[1] 12661 v_2 := v.Args[2] 12662 if v_2.Op != OpARMMOVWconst { 12663 break 12664 } 12665 c := v_2.AuxInt 12666 flags := v.Args[3] 12667 v.reset(OpARMRSCshiftRA) 12668 v.AuxInt = c 12669 v.AddArg(x) 12670 v.AddArg(y) 12671 v.AddArg(flags) 12672 return true 12673 } 12674 return false 12675 } 12676 func rewriteValueARM_OpARMRSCshiftRL_0(v *Value) bool { 12677 b := v.Block 12678 _ = b 12679 // match: (RSCshiftRL (MOVWconst [c]) x [d] flags) 12680 // cond: 12681 // result: (SBCconst [c] (SRLconst <x.Type> x [d]) flags) 12682 for { 12683 d := v.AuxInt 12684 _ = v.Args[2] 12685 v_0 := v.Args[0] 12686 if v_0.Op != OpARMMOVWconst { 12687 break 12688 } 12689 c := v_0.AuxInt 12690 x := v.Args[1] 12691 flags := v.Args[2] 12692 v.reset(OpARMSBCconst) 12693 v.AuxInt = c 12694 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 12695 v0.AuxInt = d 12696 v0.AddArg(x) 12697 v.AddArg(v0) 12698 v.AddArg(flags) 12699 return true 12700 } 12701 // match: (RSCshiftRL x (MOVWconst [c]) [d] flags) 12702 // cond: 12703 // result: (RSCconst x [int64(uint32(c)>>uint64(d))] flags) 12704 for { 12705 d := v.AuxInt 12706 _ = v.Args[2] 12707 x := v.Args[0] 12708 v_1 := v.Args[1] 12709 if v_1.Op != OpARMMOVWconst { 12710 break 12711 } 12712 c := v_1.AuxInt 12713 flags := v.Args[2] 12714 v.reset(OpARMRSCconst) 12715 v.AuxInt = int64(uint32(c) >> uint64(d)) 12716 v.AddArg(x) 12717 v.AddArg(flags) 12718 return true 12719 } 12720 return false 12721 } 12722 func rewriteValueARM_OpARMRSCshiftRLreg_0(v *Value) bool { 12723 b := v.Block 12724 _ = b 12725 // match: (RSCshiftRLreg (MOVWconst [c]) x y flags) 12726 // cond: 12727 // result: (SBCconst [c] (SRL <x.Type> x y) flags) 12728 for { 12729 _ = v.Args[3] 12730 v_0 := v.Args[0] 12731 if v_0.Op != OpARMMOVWconst { 12732 break 12733 } 12734 c := v_0.AuxInt 12735 x := v.Args[1] 12736 y := v.Args[2] 12737 flags := v.Args[3] 12738 v.reset(OpARMSBCconst) 12739 v.AuxInt = c 12740 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 12741 v0.AddArg(x) 12742 v0.AddArg(y) 12743 v.AddArg(v0) 12744 v.AddArg(flags) 12745 return true 12746 } 12747 // match: (RSCshiftRLreg x y (MOVWconst [c]) flags) 12748 // cond: 12749 // result: (RSCshiftRL x y [c] flags) 12750 for { 12751 _ = v.Args[3] 12752 x := v.Args[0] 12753 y := v.Args[1] 12754 v_2 := v.Args[2] 12755 if v_2.Op != OpARMMOVWconst { 12756 break 12757 } 12758 c := v_2.AuxInt 12759 flags := v.Args[3] 12760 v.reset(OpARMRSCshiftRL) 12761 v.AuxInt = c 12762 v.AddArg(x) 12763 v.AddArg(y) 12764 v.AddArg(flags) 12765 return true 12766 } 12767 return false 12768 } 12769 func rewriteValueARM_OpARMSBC_0(v *Value) bool { 12770 // match: (SBC (MOVWconst [c]) x flags) 12771 // cond: 12772 // result: (RSCconst [c] x flags) 12773 for { 12774 _ = v.Args[2] 12775 v_0 := v.Args[0] 12776 if v_0.Op != OpARMMOVWconst { 12777 break 12778 } 12779 c := v_0.AuxInt 12780 x := v.Args[1] 12781 flags := v.Args[2] 12782 v.reset(OpARMRSCconst) 12783 v.AuxInt = c 12784 v.AddArg(x) 12785 v.AddArg(flags) 12786 return true 12787 } 12788 // match: (SBC x (MOVWconst [c]) flags) 12789 // cond: 12790 // result: (SBCconst [c] x flags) 12791 for { 12792 _ = v.Args[2] 12793 x := v.Args[0] 12794 v_1 := v.Args[1] 12795 if v_1.Op != OpARMMOVWconst { 12796 break 12797 } 12798 c := v_1.AuxInt 12799 flags := v.Args[2] 12800 v.reset(OpARMSBCconst) 12801 v.AuxInt = c 12802 v.AddArg(x) 12803 v.AddArg(flags) 12804 return true 12805 } 12806 // match: (SBC x (SLLconst [c] y) flags) 12807 // cond: 12808 // result: (SBCshiftLL x y [c] flags) 12809 for { 12810 _ = v.Args[2] 12811 x := v.Args[0] 12812 v_1 := v.Args[1] 12813 if v_1.Op != OpARMSLLconst { 12814 break 12815 } 12816 c := v_1.AuxInt 12817 y := v_1.Args[0] 12818 flags := v.Args[2] 12819 v.reset(OpARMSBCshiftLL) 12820 v.AuxInt = c 12821 v.AddArg(x) 12822 v.AddArg(y) 12823 v.AddArg(flags) 12824 return true 12825 } 12826 // match: (SBC (SLLconst [c] y) x flags) 12827 // cond: 12828 // result: (RSCshiftLL x y [c] flags) 12829 for { 12830 _ = v.Args[2] 12831 v_0 := v.Args[0] 12832 if v_0.Op != OpARMSLLconst { 12833 break 12834 } 12835 c := v_0.AuxInt 12836 y := v_0.Args[0] 12837 x := v.Args[1] 12838 flags := v.Args[2] 12839 v.reset(OpARMRSCshiftLL) 12840 v.AuxInt = c 12841 v.AddArg(x) 12842 v.AddArg(y) 12843 v.AddArg(flags) 12844 return true 12845 } 12846 // match: (SBC x (SRLconst [c] y) flags) 12847 // cond: 12848 // result: (SBCshiftRL x y [c] flags) 12849 for { 12850 _ = v.Args[2] 12851 x := v.Args[0] 12852 v_1 := v.Args[1] 12853 if v_1.Op != OpARMSRLconst { 12854 break 12855 } 12856 c := v_1.AuxInt 12857 y := v_1.Args[0] 12858 flags := v.Args[2] 12859 v.reset(OpARMSBCshiftRL) 12860 v.AuxInt = c 12861 v.AddArg(x) 12862 v.AddArg(y) 12863 v.AddArg(flags) 12864 return true 12865 } 12866 // match: (SBC (SRLconst [c] y) x flags) 12867 // cond: 12868 // result: (RSCshiftRL x y [c] flags) 12869 for { 12870 _ = v.Args[2] 12871 v_0 := v.Args[0] 12872 if v_0.Op != OpARMSRLconst { 12873 break 12874 } 12875 c := v_0.AuxInt 12876 y := v_0.Args[0] 12877 x := v.Args[1] 12878 flags := v.Args[2] 12879 v.reset(OpARMRSCshiftRL) 12880 v.AuxInt = c 12881 v.AddArg(x) 12882 v.AddArg(y) 12883 v.AddArg(flags) 12884 return true 12885 } 12886 // match: (SBC x (SRAconst [c] y) flags) 12887 // cond: 12888 // result: (SBCshiftRA x y [c] flags) 12889 for { 12890 _ = v.Args[2] 12891 x := v.Args[0] 12892 v_1 := v.Args[1] 12893 if v_1.Op != OpARMSRAconst { 12894 break 12895 } 12896 c := v_1.AuxInt 12897 y := v_1.Args[0] 12898 flags := v.Args[2] 12899 v.reset(OpARMSBCshiftRA) 12900 v.AuxInt = c 12901 v.AddArg(x) 12902 v.AddArg(y) 12903 v.AddArg(flags) 12904 return true 12905 } 12906 // match: (SBC (SRAconst [c] y) x flags) 12907 // cond: 12908 // result: (RSCshiftRA x y [c] flags) 12909 for { 12910 _ = v.Args[2] 12911 v_0 := v.Args[0] 12912 if v_0.Op != OpARMSRAconst { 12913 break 12914 } 12915 c := v_0.AuxInt 12916 y := v_0.Args[0] 12917 x := v.Args[1] 12918 flags := v.Args[2] 12919 v.reset(OpARMRSCshiftRA) 12920 v.AuxInt = c 12921 v.AddArg(x) 12922 v.AddArg(y) 12923 v.AddArg(flags) 12924 return true 12925 } 12926 // match: (SBC x (SLL y z) flags) 12927 // cond: 12928 // result: (SBCshiftLLreg x y z flags) 12929 for { 12930 _ = v.Args[2] 12931 x := v.Args[0] 12932 v_1 := v.Args[1] 12933 if v_1.Op != OpARMSLL { 12934 break 12935 } 12936 _ = v_1.Args[1] 12937 y := v_1.Args[0] 12938 z := v_1.Args[1] 12939 flags := v.Args[2] 12940 v.reset(OpARMSBCshiftLLreg) 12941 v.AddArg(x) 12942 v.AddArg(y) 12943 v.AddArg(z) 12944 v.AddArg(flags) 12945 return true 12946 } 12947 // match: (SBC (SLL y z) x flags) 12948 // cond: 12949 // result: (RSCshiftLLreg x y z flags) 12950 for { 12951 _ = v.Args[2] 12952 v_0 := v.Args[0] 12953 if v_0.Op != OpARMSLL { 12954 break 12955 } 12956 _ = v_0.Args[1] 12957 y := v_0.Args[0] 12958 z := v_0.Args[1] 12959 x := v.Args[1] 12960 flags := v.Args[2] 12961 v.reset(OpARMRSCshiftLLreg) 12962 v.AddArg(x) 12963 v.AddArg(y) 12964 v.AddArg(z) 12965 v.AddArg(flags) 12966 return true 12967 } 12968 return false 12969 } 12970 func rewriteValueARM_OpARMSBC_10(v *Value) bool { 12971 // match: (SBC x (SRL y z) flags) 12972 // cond: 12973 // result: (SBCshiftRLreg x y z flags) 12974 for { 12975 _ = v.Args[2] 12976 x := v.Args[0] 12977 v_1 := v.Args[1] 12978 if v_1.Op != OpARMSRL { 12979 break 12980 } 12981 _ = v_1.Args[1] 12982 y := v_1.Args[0] 12983 z := v_1.Args[1] 12984 flags := v.Args[2] 12985 v.reset(OpARMSBCshiftRLreg) 12986 v.AddArg(x) 12987 v.AddArg(y) 12988 v.AddArg(z) 12989 v.AddArg(flags) 12990 return true 12991 } 12992 // match: (SBC (SRL y z) x flags) 12993 // cond: 12994 // result: (RSCshiftRLreg x y z flags) 12995 for { 12996 _ = v.Args[2] 12997 v_0 := v.Args[0] 12998 if v_0.Op != OpARMSRL { 12999 break 13000 } 13001 _ = v_0.Args[1] 13002 y := v_0.Args[0] 13003 z := v_0.Args[1] 13004 x := v.Args[1] 13005 flags := v.Args[2] 13006 v.reset(OpARMRSCshiftRLreg) 13007 v.AddArg(x) 13008 v.AddArg(y) 13009 v.AddArg(z) 13010 v.AddArg(flags) 13011 return true 13012 } 13013 // match: (SBC x (SRA y z) flags) 13014 // cond: 13015 // result: (SBCshiftRAreg x y z flags) 13016 for { 13017 _ = v.Args[2] 13018 x := v.Args[0] 13019 v_1 := v.Args[1] 13020 if v_1.Op != OpARMSRA { 13021 break 13022 } 13023 _ = v_1.Args[1] 13024 y := v_1.Args[0] 13025 z := v_1.Args[1] 13026 flags := v.Args[2] 13027 v.reset(OpARMSBCshiftRAreg) 13028 v.AddArg(x) 13029 v.AddArg(y) 13030 v.AddArg(z) 13031 v.AddArg(flags) 13032 return true 13033 } 13034 // match: (SBC (SRA y z) x flags) 13035 // cond: 13036 // result: (RSCshiftRAreg x y z flags) 13037 for { 13038 _ = v.Args[2] 13039 v_0 := v.Args[0] 13040 if v_0.Op != OpARMSRA { 13041 break 13042 } 13043 _ = v_0.Args[1] 13044 y := v_0.Args[0] 13045 z := v_0.Args[1] 13046 x := v.Args[1] 13047 flags := v.Args[2] 13048 v.reset(OpARMRSCshiftRAreg) 13049 v.AddArg(x) 13050 v.AddArg(y) 13051 v.AddArg(z) 13052 v.AddArg(flags) 13053 return true 13054 } 13055 return false 13056 } 13057 func rewriteValueARM_OpARMSBCconst_0(v *Value) bool { 13058 // match: (SBCconst [c] (ADDconst [d] x) flags) 13059 // cond: 13060 // result: (SBCconst [int64(int32(c-d))] x flags) 13061 for { 13062 c := v.AuxInt 13063 _ = v.Args[1] 13064 v_0 := v.Args[0] 13065 if v_0.Op != OpARMADDconst { 13066 break 13067 } 13068 d := v_0.AuxInt 13069 x := v_0.Args[0] 13070 flags := v.Args[1] 13071 v.reset(OpARMSBCconst) 13072 v.AuxInt = int64(int32(c - d)) 13073 v.AddArg(x) 13074 v.AddArg(flags) 13075 return true 13076 } 13077 // match: (SBCconst [c] (SUBconst [d] x) flags) 13078 // cond: 13079 // result: (SBCconst [int64(int32(c+d))] x flags) 13080 for { 13081 c := v.AuxInt 13082 _ = v.Args[1] 13083 v_0 := v.Args[0] 13084 if v_0.Op != OpARMSUBconst { 13085 break 13086 } 13087 d := v_0.AuxInt 13088 x := v_0.Args[0] 13089 flags := v.Args[1] 13090 v.reset(OpARMSBCconst) 13091 v.AuxInt = int64(int32(c + d)) 13092 v.AddArg(x) 13093 v.AddArg(flags) 13094 return true 13095 } 13096 return false 13097 } 13098 func rewriteValueARM_OpARMSBCshiftLL_0(v *Value) bool { 13099 b := v.Block 13100 _ = b 13101 // match: (SBCshiftLL (MOVWconst [c]) x [d] flags) 13102 // cond: 13103 // result: (RSCconst [c] (SLLconst <x.Type> x [d]) flags) 13104 for { 13105 d := v.AuxInt 13106 _ = v.Args[2] 13107 v_0 := v.Args[0] 13108 if v_0.Op != OpARMMOVWconst { 13109 break 13110 } 13111 c := v_0.AuxInt 13112 x := v.Args[1] 13113 flags := v.Args[2] 13114 v.reset(OpARMRSCconst) 13115 v.AuxInt = c 13116 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 13117 v0.AuxInt = d 13118 v0.AddArg(x) 13119 v.AddArg(v0) 13120 v.AddArg(flags) 13121 return true 13122 } 13123 // match: (SBCshiftLL x (MOVWconst [c]) [d] flags) 13124 // cond: 13125 // result: (SBCconst x [int64(uint32(c)<<uint64(d))] flags) 13126 for { 13127 d := v.AuxInt 13128 _ = v.Args[2] 13129 x := v.Args[0] 13130 v_1 := v.Args[1] 13131 if v_1.Op != OpARMMOVWconst { 13132 break 13133 } 13134 c := v_1.AuxInt 13135 flags := v.Args[2] 13136 v.reset(OpARMSBCconst) 13137 v.AuxInt = int64(uint32(c) << uint64(d)) 13138 v.AddArg(x) 13139 v.AddArg(flags) 13140 return true 13141 } 13142 return false 13143 } 13144 func rewriteValueARM_OpARMSBCshiftLLreg_0(v *Value) bool { 13145 b := v.Block 13146 _ = b 13147 // match: (SBCshiftLLreg (MOVWconst [c]) x y flags) 13148 // cond: 13149 // result: (RSCconst [c] (SLL <x.Type> x y) flags) 13150 for { 13151 _ = v.Args[3] 13152 v_0 := v.Args[0] 13153 if v_0.Op != OpARMMOVWconst { 13154 break 13155 } 13156 c := v_0.AuxInt 13157 x := v.Args[1] 13158 y := v.Args[2] 13159 flags := v.Args[3] 13160 v.reset(OpARMRSCconst) 13161 v.AuxInt = c 13162 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 13163 v0.AddArg(x) 13164 v0.AddArg(y) 13165 v.AddArg(v0) 13166 v.AddArg(flags) 13167 return true 13168 } 13169 // match: (SBCshiftLLreg x y (MOVWconst [c]) flags) 13170 // cond: 13171 // result: (SBCshiftLL x y [c] flags) 13172 for { 13173 _ = v.Args[3] 13174 x := v.Args[0] 13175 y := v.Args[1] 13176 v_2 := v.Args[2] 13177 if v_2.Op != OpARMMOVWconst { 13178 break 13179 } 13180 c := v_2.AuxInt 13181 flags := v.Args[3] 13182 v.reset(OpARMSBCshiftLL) 13183 v.AuxInt = c 13184 v.AddArg(x) 13185 v.AddArg(y) 13186 v.AddArg(flags) 13187 return true 13188 } 13189 return false 13190 } 13191 func rewriteValueARM_OpARMSBCshiftRA_0(v *Value) bool { 13192 b := v.Block 13193 _ = b 13194 // match: (SBCshiftRA (MOVWconst [c]) x [d] flags) 13195 // cond: 13196 // result: (RSCconst [c] (SRAconst <x.Type> x [d]) flags) 13197 for { 13198 d := v.AuxInt 13199 _ = v.Args[2] 13200 v_0 := v.Args[0] 13201 if v_0.Op != OpARMMOVWconst { 13202 break 13203 } 13204 c := v_0.AuxInt 13205 x := v.Args[1] 13206 flags := v.Args[2] 13207 v.reset(OpARMRSCconst) 13208 v.AuxInt = c 13209 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 13210 v0.AuxInt = d 13211 v0.AddArg(x) 13212 v.AddArg(v0) 13213 v.AddArg(flags) 13214 return true 13215 } 13216 // match: (SBCshiftRA x (MOVWconst [c]) [d] flags) 13217 // cond: 13218 // result: (SBCconst x [int64(int32(c)>>uint64(d))] flags) 13219 for { 13220 d := v.AuxInt 13221 _ = v.Args[2] 13222 x := v.Args[0] 13223 v_1 := v.Args[1] 13224 if v_1.Op != OpARMMOVWconst { 13225 break 13226 } 13227 c := v_1.AuxInt 13228 flags := v.Args[2] 13229 v.reset(OpARMSBCconst) 13230 v.AuxInt = int64(int32(c) >> uint64(d)) 13231 v.AddArg(x) 13232 v.AddArg(flags) 13233 return true 13234 } 13235 return false 13236 } 13237 func rewriteValueARM_OpARMSBCshiftRAreg_0(v *Value) bool { 13238 b := v.Block 13239 _ = b 13240 // match: (SBCshiftRAreg (MOVWconst [c]) x y flags) 13241 // cond: 13242 // result: (RSCconst [c] (SRA <x.Type> x y) flags) 13243 for { 13244 _ = v.Args[3] 13245 v_0 := v.Args[0] 13246 if v_0.Op != OpARMMOVWconst { 13247 break 13248 } 13249 c := v_0.AuxInt 13250 x := v.Args[1] 13251 y := v.Args[2] 13252 flags := v.Args[3] 13253 v.reset(OpARMRSCconst) 13254 v.AuxInt = c 13255 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 13256 v0.AddArg(x) 13257 v0.AddArg(y) 13258 v.AddArg(v0) 13259 v.AddArg(flags) 13260 return true 13261 } 13262 // match: (SBCshiftRAreg x y (MOVWconst [c]) flags) 13263 // cond: 13264 // result: (SBCshiftRA x y [c] flags) 13265 for { 13266 _ = v.Args[3] 13267 x := v.Args[0] 13268 y := v.Args[1] 13269 v_2 := v.Args[2] 13270 if v_2.Op != OpARMMOVWconst { 13271 break 13272 } 13273 c := v_2.AuxInt 13274 flags := v.Args[3] 13275 v.reset(OpARMSBCshiftRA) 13276 v.AuxInt = c 13277 v.AddArg(x) 13278 v.AddArg(y) 13279 v.AddArg(flags) 13280 return true 13281 } 13282 return false 13283 } 13284 func rewriteValueARM_OpARMSBCshiftRL_0(v *Value) bool { 13285 b := v.Block 13286 _ = b 13287 // match: (SBCshiftRL (MOVWconst [c]) x [d] flags) 13288 // cond: 13289 // result: (RSCconst [c] (SRLconst <x.Type> x [d]) flags) 13290 for { 13291 d := v.AuxInt 13292 _ = v.Args[2] 13293 v_0 := v.Args[0] 13294 if v_0.Op != OpARMMOVWconst { 13295 break 13296 } 13297 c := v_0.AuxInt 13298 x := v.Args[1] 13299 flags := v.Args[2] 13300 v.reset(OpARMRSCconst) 13301 v.AuxInt = c 13302 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 13303 v0.AuxInt = d 13304 v0.AddArg(x) 13305 v.AddArg(v0) 13306 v.AddArg(flags) 13307 return true 13308 } 13309 // match: (SBCshiftRL x (MOVWconst [c]) [d] flags) 13310 // cond: 13311 // result: (SBCconst x [int64(uint32(c)>>uint64(d))] flags) 13312 for { 13313 d := v.AuxInt 13314 _ = v.Args[2] 13315 x := v.Args[0] 13316 v_1 := v.Args[1] 13317 if v_1.Op != OpARMMOVWconst { 13318 break 13319 } 13320 c := v_1.AuxInt 13321 flags := v.Args[2] 13322 v.reset(OpARMSBCconst) 13323 v.AuxInt = int64(uint32(c) >> uint64(d)) 13324 v.AddArg(x) 13325 v.AddArg(flags) 13326 return true 13327 } 13328 return false 13329 } 13330 func rewriteValueARM_OpARMSBCshiftRLreg_0(v *Value) bool { 13331 b := v.Block 13332 _ = b 13333 // match: (SBCshiftRLreg (MOVWconst [c]) x y flags) 13334 // cond: 13335 // result: (RSCconst [c] (SRL <x.Type> x y) flags) 13336 for { 13337 _ = v.Args[3] 13338 v_0 := v.Args[0] 13339 if v_0.Op != OpARMMOVWconst { 13340 break 13341 } 13342 c := v_0.AuxInt 13343 x := v.Args[1] 13344 y := v.Args[2] 13345 flags := v.Args[3] 13346 v.reset(OpARMRSCconst) 13347 v.AuxInt = c 13348 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 13349 v0.AddArg(x) 13350 v0.AddArg(y) 13351 v.AddArg(v0) 13352 v.AddArg(flags) 13353 return true 13354 } 13355 // match: (SBCshiftRLreg x y (MOVWconst [c]) flags) 13356 // cond: 13357 // result: (SBCshiftRL x y [c] flags) 13358 for { 13359 _ = v.Args[3] 13360 x := v.Args[0] 13361 y := v.Args[1] 13362 v_2 := v.Args[2] 13363 if v_2.Op != OpARMMOVWconst { 13364 break 13365 } 13366 c := v_2.AuxInt 13367 flags := v.Args[3] 13368 v.reset(OpARMSBCshiftRL) 13369 v.AuxInt = c 13370 v.AddArg(x) 13371 v.AddArg(y) 13372 v.AddArg(flags) 13373 return true 13374 } 13375 return false 13376 } 13377 func rewriteValueARM_OpARMSLL_0(v *Value) bool { 13378 // match: (SLL x (MOVWconst [c])) 13379 // cond: 13380 // result: (SLLconst x [c&31]) 13381 for { 13382 _ = v.Args[1] 13383 x := v.Args[0] 13384 v_1 := v.Args[1] 13385 if v_1.Op != OpARMMOVWconst { 13386 break 13387 } 13388 c := v_1.AuxInt 13389 v.reset(OpARMSLLconst) 13390 v.AuxInt = c & 31 13391 v.AddArg(x) 13392 return true 13393 } 13394 return false 13395 } 13396 func rewriteValueARM_OpARMSLLconst_0(v *Value) bool { 13397 // match: (SLLconst [c] (MOVWconst [d])) 13398 // cond: 13399 // result: (MOVWconst [int64(uint32(d)<<uint64(c))]) 13400 for { 13401 c := v.AuxInt 13402 v_0 := v.Args[0] 13403 if v_0.Op != OpARMMOVWconst { 13404 break 13405 } 13406 d := v_0.AuxInt 13407 v.reset(OpARMMOVWconst) 13408 v.AuxInt = int64(uint32(d) << uint64(c)) 13409 return true 13410 } 13411 return false 13412 } 13413 func rewriteValueARM_OpARMSRA_0(v *Value) bool { 13414 // match: (SRA x (MOVWconst [c])) 13415 // cond: 13416 // result: (SRAconst x [c&31]) 13417 for { 13418 _ = v.Args[1] 13419 x := v.Args[0] 13420 v_1 := v.Args[1] 13421 if v_1.Op != OpARMMOVWconst { 13422 break 13423 } 13424 c := v_1.AuxInt 13425 v.reset(OpARMSRAconst) 13426 v.AuxInt = c & 31 13427 v.AddArg(x) 13428 return true 13429 } 13430 return false 13431 } 13432 func rewriteValueARM_OpARMSRAcond_0(v *Value) bool { 13433 // match: (SRAcond x _ (FlagEQ)) 13434 // cond: 13435 // result: (SRAconst x [31]) 13436 for { 13437 _ = v.Args[2] 13438 x := v.Args[0] 13439 v_2 := v.Args[2] 13440 if v_2.Op != OpARMFlagEQ { 13441 break 13442 } 13443 v.reset(OpARMSRAconst) 13444 v.AuxInt = 31 13445 v.AddArg(x) 13446 return true 13447 } 13448 // match: (SRAcond x y (FlagLT_ULT)) 13449 // cond: 13450 // result: (SRA x y) 13451 for { 13452 _ = v.Args[2] 13453 x := v.Args[0] 13454 y := v.Args[1] 13455 v_2 := v.Args[2] 13456 if v_2.Op != OpARMFlagLT_ULT { 13457 break 13458 } 13459 v.reset(OpARMSRA) 13460 v.AddArg(x) 13461 v.AddArg(y) 13462 return true 13463 } 13464 // match: (SRAcond x _ (FlagLT_UGT)) 13465 // cond: 13466 // result: (SRAconst x [31]) 13467 for { 13468 _ = v.Args[2] 13469 x := v.Args[0] 13470 v_2 := v.Args[2] 13471 if v_2.Op != OpARMFlagLT_UGT { 13472 break 13473 } 13474 v.reset(OpARMSRAconst) 13475 v.AuxInt = 31 13476 v.AddArg(x) 13477 return true 13478 } 13479 // match: (SRAcond x y (FlagGT_ULT)) 13480 // cond: 13481 // result: (SRA x y) 13482 for { 13483 _ = v.Args[2] 13484 x := v.Args[0] 13485 y := v.Args[1] 13486 v_2 := v.Args[2] 13487 if v_2.Op != OpARMFlagGT_ULT { 13488 break 13489 } 13490 v.reset(OpARMSRA) 13491 v.AddArg(x) 13492 v.AddArg(y) 13493 return true 13494 } 13495 // match: (SRAcond x _ (FlagGT_UGT)) 13496 // cond: 13497 // result: (SRAconst x [31]) 13498 for { 13499 _ = v.Args[2] 13500 x := v.Args[0] 13501 v_2 := v.Args[2] 13502 if v_2.Op != OpARMFlagGT_UGT { 13503 break 13504 } 13505 v.reset(OpARMSRAconst) 13506 v.AuxInt = 31 13507 v.AddArg(x) 13508 return true 13509 } 13510 return false 13511 } 13512 func rewriteValueARM_OpARMSRAconst_0(v *Value) bool { 13513 // match: (SRAconst [c] (MOVWconst [d])) 13514 // cond: 13515 // result: (MOVWconst [int64(int32(d)>>uint64(c))]) 13516 for { 13517 c := v.AuxInt 13518 v_0 := v.Args[0] 13519 if v_0.Op != OpARMMOVWconst { 13520 break 13521 } 13522 d := v_0.AuxInt 13523 v.reset(OpARMMOVWconst) 13524 v.AuxInt = int64(int32(d) >> uint64(c)) 13525 return true 13526 } 13527 // match: (SRAconst (SLLconst x [c]) [d]) 13528 // cond: objabi.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31 13529 // result: (BFX [(d-c)|(32-d)<<8] x) 13530 for { 13531 d := v.AuxInt 13532 v_0 := v.Args[0] 13533 if v_0.Op != OpARMSLLconst { 13534 break 13535 } 13536 c := v_0.AuxInt 13537 x := v_0.Args[0] 13538 if !(objabi.GOARM == 7 && uint64(d) >= uint64(c) && uint64(d) <= 31) { 13539 break 13540 } 13541 v.reset(OpARMBFX) 13542 v.AuxInt = (d - c) | (32-d)<<8 13543 v.AddArg(x) 13544 return true 13545 } 13546 return false 13547 } 13548 func rewriteValueARM_OpARMSRL_0(v *Value) bool { 13549 // match: (SRL x (MOVWconst [c])) 13550 // cond: 13551 // result: (SRLconst x [c&31]) 13552 for { 13553 _ = v.Args[1] 13554 x := v.Args[0] 13555 v_1 := v.Args[1] 13556 if v_1.Op != OpARMMOVWconst { 13557 break 13558 } 13559 c := v_1.AuxInt 13560 v.reset(OpARMSRLconst) 13561 v.AuxInt = c & 31 13562 v.AddArg(x) 13563 return true 13564 } 13565 return false 13566 } 13567 func rewriteValueARM_OpARMSRLconst_0(v *Value) bool { 13568 // match: (SRLconst [c] (MOVWconst [d])) 13569 // cond: 13570 // result: (MOVWconst [int64(uint32(d)>>uint64(c))]) 13571 for { 13572 c := v.AuxInt 13573 v_0 := v.Args[0] 13574 if v_0.Op != OpARMMOVWconst { 13575 break 13576 } 13577 d := v_0.AuxInt 13578 v.reset(OpARMMOVWconst) 13579 v.AuxInt = int64(uint32(d) >> uint64(c)) 13580 return true 13581 } 13582 // match: (SRLconst (SLLconst x [c]) [d]) 13583 // cond: objabi.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31 13584 // result: (BFXU [(d-c)|(32-d)<<8] x) 13585 for { 13586 d := v.AuxInt 13587 v_0 := v.Args[0] 13588 if v_0.Op != OpARMSLLconst { 13589 break 13590 } 13591 c := v_0.AuxInt 13592 x := v_0.Args[0] 13593 if !(objabi.GOARM == 7 && uint64(d) >= uint64(c) && uint64(d) <= 31) { 13594 break 13595 } 13596 v.reset(OpARMBFXU) 13597 v.AuxInt = (d - c) | (32-d)<<8 13598 v.AddArg(x) 13599 return true 13600 } 13601 return false 13602 } 13603 func rewriteValueARM_OpARMSUB_0(v *Value) bool { 13604 // match: (SUB (MOVWconst [c]) x) 13605 // cond: 13606 // result: (RSBconst [c] x) 13607 for { 13608 _ = v.Args[1] 13609 v_0 := v.Args[0] 13610 if v_0.Op != OpARMMOVWconst { 13611 break 13612 } 13613 c := v_0.AuxInt 13614 x := v.Args[1] 13615 v.reset(OpARMRSBconst) 13616 v.AuxInt = c 13617 v.AddArg(x) 13618 return true 13619 } 13620 // match: (SUB x (MOVWconst [c])) 13621 // cond: 13622 // result: (SUBconst [c] x) 13623 for { 13624 _ = v.Args[1] 13625 x := v.Args[0] 13626 v_1 := v.Args[1] 13627 if v_1.Op != OpARMMOVWconst { 13628 break 13629 } 13630 c := v_1.AuxInt 13631 v.reset(OpARMSUBconst) 13632 v.AuxInt = c 13633 v.AddArg(x) 13634 return true 13635 } 13636 // match: (SUB x (SLLconst [c] y)) 13637 // cond: 13638 // result: (SUBshiftLL x y [c]) 13639 for { 13640 _ = v.Args[1] 13641 x := v.Args[0] 13642 v_1 := v.Args[1] 13643 if v_1.Op != OpARMSLLconst { 13644 break 13645 } 13646 c := v_1.AuxInt 13647 y := v_1.Args[0] 13648 v.reset(OpARMSUBshiftLL) 13649 v.AuxInt = c 13650 v.AddArg(x) 13651 v.AddArg(y) 13652 return true 13653 } 13654 // match: (SUB (SLLconst [c] y) x) 13655 // cond: 13656 // result: (RSBshiftLL x y [c]) 13657 for { 13658 _ = v.Args[1] 13659 v_0 := v.Args[0] 13660 if v_0.Op != OpARMSLLconst { 13661 break 13662 } 13663 c := v_0.AuxInt 13664 y := v_0.Args[0] 13665 x := v.Args[1] 13666 v.reset(OpARMRSBshiftLL) 13667 v.AuxInt = c 13668 v.AddArg(x) 13669 v.AddArg(y) 13670 return true 13671 } 13672 // match: (SUB x (SRLconst [c] y)) 13673 // cond: 13674 // result: (SUBshiftRL x y [c]) 13675 for { 13676 _ = v.Args[1] 13677 x := v.Args[0] 13678 v_1 := v.Args[1] 13679 if v_1.Op != OpARMSRLconst { 13680 break 13681 } 13682 c := v_1.AuxInt 13683 y := v_1.Args[0] 13684 v.reset(OpARMSUBshiftRL) 13685 v.AuxInt = c 13686 v.AddArg(x) 13687 v.AddArg(y) 13688 return true 13689 } 13690 // match: (SUB (SRLconst [c] y) x) 13691 // cond: 13692 // result: (RSBshiftRL x y [c]) 13693 for { 13694 _ = v.Args[1] 13695 v_0 := v.Args[0] 13696 if v_0.Op != OpARMSRLconst { 13697 break 13698 } 13699 c := v_0.AuxInt 13700 y := v_0.Args[0] 13701 x := v.Args[1] 13702 v.reset(OpARMRSBshiftRL) 13703 v.AuxInt = c 13704 v.AddArg(x) 13705 v.AddArg(y) 13706 return true 13707 } 13708 // match: (SUB x (SRAconst [c] y)) 13709 // cond: 13710 // result: (SUBshiftRA x y [c]) 13711 for { 13712 _ = v.Args[1] 13713 x := v.Args[0] 13714 v_1 := v.Args[1] 13715 if v_1.Op != OpARMSRAconst { 13716 break 13717 } 13718 c := v_1.AuxInt 13719 y := v_1.Args[0] 13720 v.reset(OpARMSUBshiftRA) 13721 v.AuxInt = c 13722 v.AddArg(x) 13723 v.AddArg(y) 13724 return true 13725 } 13726 // match: (SUB (SRAconst [c] y) x) 13727 // cond: 13728 // result: (RSBshiftRA x y [c]) 13729 for { 13730 _ = v.Args[1] 13731 v_0 := v.Args[0] 13732 if v_0.Op != OpARMSRAconst { 13733 break 13734 } 13735 c := v_0.AuxInt 13736 y := v_0.Args[0] 13737 x := v.Args[1] 13738 v.reset(OpARMRSBshiftRA) 13739 v.AuxInt = c 13740 v.AddArg(x) 13741 v.AddArg(y) 13742 return true 13743 } 13744 // match: (SUB x (SLL y z)) 13745 // cond: 13746 // result: (SUBshiftLLreg x y z) 13747 for { 13748 _ = v.Args[1] 13749 x := v.Args[0] 13750 v_1 := v.Args[1] 13751 if v_1.Op != OpARMSLL { 13752 break 13753 } 13754 _ = v_1.Args[1] 13755 y := v_1.Args[0] 13756 z := v_1.Args[1] 13757 v.reset(OpARMSUBshiftLLreg) 13758 v.AddArg(x) 13759 v.AddArg(y) 13760 v.AddArg(z) 13761 return true 13762 } 13763 // match: (SUB (SLL y z) x) 13764 // cond: 13765 // result: (RSBshiftLLreg x y z) 13766 for { 13767 _ = v.Args[1] 13768 v_0 := v.Args[0] 13769 if v_0.Op != OpARMSLL { 13770 break 13771 } 13772 _ = v_0.Args[1] 13773 y := v_0.Args[0] 13774 z := v_0.Args[1] 13775 x := v.Args[1] 13776 v.reset(OpARMRSBshiftLLreg) 13777 v.AddArg(x) 13778 v.AddArg(y) 13779 v.AddArg(z) 13780 return true 13781 } 13782 return false 13783 } 13784 func rewriteValueARM_OpARMSUB_10(v *Value) bool { 13785 // match: (SUB x (SRL y z)) 13786 // cond: 13787 // result: (SUBshiftRLreg x y z) 13788 for { 13789 _ = v.Args[1] 13790 x := v.Args[0] 13791 v_1 := v.Args[1] 13792 if v_1.Op != OpARMSRL { 13793 break 13794 } 13795 _ = v_1.Args[1] 13796 y := v_1.Args[0] 13797 z := v_1.Args[1] 13798 v.reset(OpARMSUBshiftRLreg) 13799 v.AddArg(x) 13800 v.AddArg(y) 13801 v.AddArg(z) 13802 return true 13803 } 13804 // match: (SUB (SRL y z) x) 13805 // cond: 13806 // result: (RSBshiftRLreg x y z) 13807 for { 13808 _ = v.Args[1] 13809 v_0 := v.Args[0] 13810 if v_0.Op != OpARMSRL { 13811 break 13812 } 13813 _ = v_0.Args[1] 13814 y := v_0.Args[0] 13815 z := v_0.Args[1] 13816 x := v.Args[1] 13817 v.reset(OpARMRSBshiftRLreg) 13818 v.AddArg(x) 13819 v.AddArg(y) 13820 v.AddArg(z) 13821 return true 13822 } 13823 // match: (SUB x (SRA y z)) 13824 // cond: 13825 // result: (SUBshiftRAreg x y z) 13826 for { 13827 _ = v.Args[1] 13828 x := v.Args[0] 13829 v_1 := v.Args[1] 13830 if v_1.Op != OpARMSRA { 13831 break 13832 } 13833 _ = v_1.Args[1] 13834 y := v_1.Args[0] 13835 z := v_1.Args[1] 13836 v.reset(OpARMSUBshiftRAreg) 13837 v.AddArg(x) 13838 v.AddArg(y) 13839 v.AddArg(z) 13840 return true 13841 } 13842 // match: (SUB (SRA y z) x) 13843 // cond: 13844 // result: (RSBshiftRAreg x y z) 13845 for { 13846 _ = v.Args[1] 13847 v_0 := v.Args[0] 13848 if v_0.Op != OpARMSRA { 13849 break 13850 } 13851 _ = v_0.Args[1] 13852 y := v_0.Args[0] 13853 z := v_0.Args[1] 13854 x := v.Args[1] 13855 v.reset(OpARMRSBshiftRAreg) 13856 v.AddArg(x) 13857 v.AddArg(y) 13858 v.AddArg(z) 13859 return true 13860 } 13861 // match: (SUB x x) 13862 // cond: 13863 // result: (MOVWconst [0]) 13864 for { 13865 _ = v.Args[1] 13866 x := v.Args[0] 13867 if x != v.Args[1] { 13868 break 13869 } 13870 v.reset(OpARMMOVWconst) 13871 v.AuxInt = 0 13872 return true 13873 } 13874 // match: (SUB a (MUL x y)) 13875 // cond: objabi.GOARM == 7 13876 // result: (MULS x y a) 13877 for { 13878 _ = v.Args[1] 13879 a := v.Args[0] 13880 v_1 := v.Args[1] 13881 if v_1.Op != OpARMMUL { 13882 break 13883 } 13884 _ = v_1.Args[1] 13885 x := v_1.Args[0] 13886 y := v_1.Args[1] 13887 if !(objabi.GOARM == 7) { 13888 break 13889 } 13890 v.reset(OpARMMULS) 13891 v.AddArg(x) 13892 v.AddArg(y) 13893 v.AddArg(a) 13894 return true 13895 } 13896 return false 13897 } 13898 func rewriteValueARM_OpARMSUBD_0(v *Value) bool { 13899 // match: (SUBD a (MULD x y)) 13900 // cond: a.Uses == 1 && objabi.GOARM >= 6 13901 // result: (MULSD a x y) 13902 for { 13903 _ = v.Args[1] 13904 a := v.Args[0] 13905 v_1 := v.Args[1] 13906 if v_1.Op != OpARMMULD { 13907 break 13908 } 13909 _ = v_1.Args[1] 13910 x := v_1.Args[0] 13911 y := v_1.Args[1] 13912 if !(a.Uses == 1 && objabi.GOARM >= 6) { 13913 break 13914 } 13915 v.reset(OpARMMULSD) 13916 v.AddArg(a) 13917 v.AddArg(x) 13918 v.AddArg(y) 13919 return true 13920 } 13921 // match: (SUBD a (NMULD x y)) 13922 // cond: a.Uses == 1 && objabi.GOARM >= 6 13923 // result: (MULAD a x y) 13924 for { 13925 _ = v.Args[1] 13926 a := v.Args[0] 13927 v_1 := v.Args[1] 13928 if v_1.Op != OpARMNMULD { 13929 break 13930 } 13931 _ = v_1.Args[1] 13932 x := v_1.Args[0] 13933 y := v_1.Args[1] 13934 if !(a.Uses == 1 && objabi.GOARM >= 6) { 13935 break 13936 } 13937 v.reset(OpARMMULAD) 13938 v.AddArg(a) 13939 v.AddArg(x) 13940 v.AddArg(y) 13941 return true 13942 } 13943 return false 13944 } 13945 func rewriteValueARM_OpARMSUBF_0(v *Value) bool { 13946 // match: (SUBF a (MULF x y)) 13947 // cond: a.Uses == 1 && objabi.GOARM >= 6 13948 // result: (MULSF a x y) 13949 for { 13950 _ = v.Args[1] 13951 a := v.Args[0] 13952 v_1 := v.Args[1] 13953 if v_1.Op != OpARMMULF { 13954 break 13955 } 13956 _ = v_1.Args[1] 13957 x := v_1.Args[0] 13958 y := v_1.Args[1] 13959 if !(a.Uses == 1 && objabi.GOARM >= 6) { 13960 break 13961 } 13962 v.reset(OpARMMULSF) 13963 v.AddArg(a) 13964 v.AddArg(x) 13965 v.AddArg(y) 13966 return true 13967 } 13968 // match: (SUBF a (NMULF x y)) 13969 // cond: a.Uses == 1 && objabi.GOARM >= 6 13970 // result: (MULAF a x y) 13971 for { 13972 _ = v.Args[1] 13973 a := v.Args[0] 13974 v_1 := v.Args[1] 13975 if v_1.Op != OpARMNMULF { 13976 break 13977 } 13978 _ = v_1.Args[1] 13979 x := v_1.Args[0] 13980 y := v_1.Args[1] 13981 if !(a.Uses == 1 && objabi.GOARM >= 6) { 13982 break 13983 } 13984 v.reset(OpARMMULAF) 13985 v.AddArg(a) 13986 v.AddArg(x) 13987 v.AddArg(y) 13988 return true 13989 } 13990 return false 13991 } 13992 func rewriteValueARM_OpARMSUBS_0(v *Value) bool { 13993 // match: (SUBS x (MOVWconst [c])) 13994 // cond: 13995 // result: (SUBSconst [c] x) 13996 for { 13997 _ = v.Args[1] 13998 x := v.Args[0] 13999 v_1 := v.Args[1] 14000 if v_1.Op != OpARMMOVWconst { 14001 break 14002 } 14003 c := v_1.AuxInt 14004 v.reset(OpARMSUBSconst) 14005 v.AuxInt = c 14006 v.AddArg(x) 14007 return true 14008 } 14009 // match: (SUBS x (SLLconst [c] y)) 14010 // cond: 14011 // result: (SUBSshiftLL x y [c]) 14012 for { 14013 _ = v.Args[1] 14014 x := v.Args[0] 14015 v_1 := v.Args[1] 14016 if v_1.Op != OpARMSLLconst { 14017 break 14018 } 14019 c := v_1.AuxInt 14020 y := v_1.Args[0] 14021 v.reset(OpARMSUBSshiftLL) 14022 v.AuxInt = c 14023 v.AddArg(x) 14024 v.AddArg(y) 14025 return true 14026 } 14027 // match: (SUBS (SLLconst [c] y) x) 14028 // cond: 14029 // result: (RSBSshiftLL x y [c]) 14030 for { 14031 _ = v.Args[1] 14032 v_0 := v.Args[0] 14033 if v_0.Op != OpARMSLLconst { 14034 break 14035 } 14036 c := v_0.AuxInt 14037 y := v_0.Args[0] 14038 x := v.Args[1] 14039 v.reset(OpARMRSBSshiftLL) 14040 v.AuxInt = c 14041 v.AddArg(x) 14042 v.AddArg(y) 14043 return true 14044 } 14045 // match: (SUBS x (SRLconst [c] y)) 14046 // cond: 14047 // result: (SUBSshiftRL x y [c]) 14048 for { 14049 _ = v.Args[1] 14050 x := v.Args[0] 14051 v_1 := v.Args[1] 14052 if v_1.Op != OpARMSRLconst { 14053 break 14054 } 14055 c := v_1.AuxInt 14056 y := v_1.Args[0] 14057 v.reset(OpARMSUBSshiftRL) 14058 v.AuxInt = c 14059 v.AddArg(x) 14060 v.AddArg(y) 14061 return true 14062 } 14063 // match: (SUBS (SRLconst [c] y) x) 14064 // cond: 14065 // result: (RSBSshiftRL x y [c]) 14066 for { 14067 _ = v.Args[1] 14068 v_0 := v.Args[0] 14069 if v_0.Op != OpARMSRLconst { 14070 break 14071 } 14072 c := v_0.AuxInt 14073 y := v_0.Args[0] 14074 x := v.Args[1] 14075 v.reset(OpARMRSBSshiftRL) 14076 v.AuxInt = c 14077 v.AddArg(x) 14078 v.AddArg(y) 14079 return true 14080 } 14081 // match: (SUBS x (SRAconst [c] y)) 14082 // cond: 14083 // result: (SUBSshiftRA x y [c]) 14084 for { 14085 _ = v.Args[1] 14086 x := v.Args[0] 14087 v_1 := v.Args[1] 14088 if v_1.Op != OpARMSRAconst { 14089 break 14090 } 14091 c := v_1.AuxInt 14092 y := v_1.Args[0] 14093 v.reset(OpARMSUBSshiftRA) 14094 v.AuxInt = c 14095 v.AddArg(x) 14096 v.AddArg(y) 14097 return true 14098 } 14099 // match: (SUBS (SRAconst [c] y) x) 14100 // cond: 14101 // result: (RSBSshiftRA x y [c]) 14102 for { 14103 _ = v.Args[1] 14104 v_0 := v.Args[0] 14105 if v_0.Op != OpARMSRAconst { 14106 break 14107 } 14108 c := v_0.AuxInt 14109 y := v_0.Args[0] 14110 x := v.Args[1] 14111 v.reset(OpARMRSBSshiftRA) 14112 v.AuxInt = c 14113 v.AddArg(x) 14114 v.AddArg(y) 14115 return true 14116 } 14117 // match: (SUBS x (SLL y z)) 14118 // cond: 14119 // result: (SUBSshiftLLreg x y z) 14120 for { 14121 _ = v.Args[1] 14122 x := v.Args[0] 14123 v_1 := v.Args[1] 14124 if v_1.Op != OpARMSLL { 14125 break 14126 } 14127 _ = v_1.Args[1] 14128 y := v_1.Args[0] 14129 z := v_1.Args[1] 14130 v.reset(OpARMSUBSshiftLLreg) 14131 v.AddArg(x) 14132 v.AddArg(y) 14133 v.AddArg(z) 14134 return true 14135 } 14136 // match: (SUBS (SLL y z) x) 14137 // cond: 14138 // result: (RSBSshiftLLreg x y z) 14139 for { 14140 _ = v.Args[1] 14141 v_0 := v.Args[0] 14142 if v_0.Op != OpARMSLL { 14143 break 14144 } 14145 _ = v_0.Args[1] 14146 y := v_0.Args[0] 14147 z := v_0.Args[1] 14148 x := v.Args[1] 14149 v.reset(OpARMRSBSshiftLLreg) 14150 v.AddArg(x) 14151 v.AddArg(y) 14152 v.AddArg(z) 14153 return true 14154 } 14155 // match: (SUBS x (SRL y z)) 14156 // cond: 14157 // result: (SUBSshiftRLreg x y z) 14158 for { 14159 _ = v.Args[1] 14160 x := v.Args[0] 14161 v_1 := v.Args[1] 14162 if v_1.Op != OpARMSRL { 14163 break 14164 } 14165 _ = v_1.Args[1] 14166 y := v_1.Args[0] 14167 z := v_1.Args[1] 14168 v.reset(OpARMSUBSshiftRLreg) 14169 v.AddArg(x) 14170 v.AddArg(y) 14171 v.AddArg(z) 14172 return true 14173 } 14174 return false 14175 } 14176 func rewriteValueARM_OpARMSUBS_10(v *Value) bool { 14177 // match: (SUBS (SRL y z) x) 14178 // cond: 14179 // result: (RSBSshiftRLreg x y z) 14180 for { 14181 _ = v.Args[1] 14182 v_0 := v.Args[0] 14183 if v_0.Op != OpARMSRL { 14184 break 14185 } 14186 _ = v_0.Args[1] 14187 y := v_0.Args[0] 14188 z := v_0.Args[1] 14189 x := v.Args[1] 14190 v.reset(OpARMRSBSshiftRLreg) 14191 v.AddArg(x) 14192 v.AddArg(y) 14193 v.AddArg(z) 14194 return true 14195 } 14196 // match: (SUBS x (SRA y z)) 14197 // cond: 14198 // result: (SUBSshiftRAreg x y z) 14199 for { 14200 _ = v.Args[1] 14201 x := v.Args[0] 14202 v_1 := v.Args[1] 14203 if v_1.Op != OpARMSRA { 14204 break 14205 } 14206 _ = v_1.Args[1] 14207 y := v_1.Args[0] 14208 z := v_1.Args[1] 14209 v.reset(OpARMSUBSshiftRAreg) 14210 v.AddArg(x) 14211 v.AddArg(y) 14212 v.AddArg(z) 14213 return true 14214 } 14215 // match: (SUBS (SRA y z) x) 14216 // cond: 14217 // result: (RSBSshiftRAreg x y z) 14218 for { 14219 _ = v.Args[1] 14220 v_0 := v.Args[0] 14221 if v_0.Op != OpARMSRA { 14222 break 14223 } 14224 _ = v_0.Args[1] 14225 y := v_0.Args[0] 14226 z := v_0.Args[1] 14227 x := v.Args[1] 14228 v.reset(OpARMRSBSshiftRAreg) 14229 v.AddArg(x) 14230 v.AddArg(y) 14231 v.AddArg(z) 14232 return true 14233 } 14234 return false 14235 } 14236 func rewriteValueARM_OpARMSUBSshiftLL_0(v *Value) bool { 14237 b := v.Block 14238 _ = b 14239 // match: (SUBSshiftLL (MOVWconst [c]) x [d]) 14240 // cond: 14241 // result: (RSBSconst [c] (SLLconst <x.Type> x [d])) 14242 for { 14243 d := v.AuxInt 14244 _ = v.Args[1] 14245 v_0 := v.Args[0] 14246 if v_0.Op != OpARMMOVWconst { 14247 break 14248 } 14249 c := v_0.AuxInt 14250 x := v.Args[1] 14251 v.reset(OpARMRSBSconst) 14252 v.AuxInt = c 14253 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 14254 v0.AuxInt = d 14255 v0.AddArg(x) 14256 v.AddArg(v0) 14257 return true 14258 } 14259 // match: (SUBSshiftLL x (MOVWconst [c]) [d]) 14260 // cond: 14261 // result: (SUBSconst x [int64(uint32(c)<<uint64(d))]) 14262 for { 14263 d := v.AuxInt 14264 _ = v.Args[1] 14265 x := v.Args[0] 14266 v_1 := v.Args[1] 14267 if v_1.Op != OpARMMOVWconst { 14268 break 14269 } 14270 c := v_1.AuxInt 14271 v.reset(OpARMSUBSconst) 14272 v.AuxInt = int64(uint32(c) << uint64(d)) 14273 v.AddArg(x) 14274 return true 14275 } 14276 return false 14277 } 14278 func rewriteValueARM_OpARMSUBSshiftLLreg_0(v *Value) bool { 14279 b := v.Block 14280 _ = b 14281 // match: (SUBSshiftLLreg (MOVWconst [c]) x y) 14282 // cond: 14283 // result: (RSBSconst [c] (SLL <x.Type> x y)) 14284 for { 14285 _ = v.Args[2] 14286 v_0 := v.Args[0] 14287 if v_0.Op != OpARMMOVWconst { 14288 break 14289 } 14290 c := v_0.AuxInt 14291 x := v.Args[1] 14292 y := v.Args[2] 14293 v.reset(OpARMRSBSconst) 14294 v.AuxInt = c 14295 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 14296 v0.AddArg(x) 14297 v0.AddArg(y) 14298 v.AddArg(v0) 14299 return true 14300 } 14301 // match: (SUBSshiftLLreg x y (MOVWconst [c])) 14302 // cond: 14303 // result: (SUBSshiftLL x y [c]) 14304 for { 14305 _ = v.Args[2] 14306 x := v.Args[0] 14307 y := v.Args[1] 14308 v_2 := v.Args[2] 14309 if v_2.Op != OpARMMOVWconst { 14310 break 14311 } 14312 c := v_2.AuxInt 14313 v.reset(OpARMSUBSshiftLL) 14314 v.AuxInt = c 14315 v.AddArg(x) 14316 v.AddArg(y) 14317 return true 14318 } 14319 return false 14320 } 14321 func rewriteValueARM_OpARMSUBSshiftRA_0(v *Value) bool { 14322 b := v.Block 14323 _ = b 14324 // match: (SUBSshiftRA (MOVWconst [c]) x [d]) 14325 // cond: 14326 // result: (RSBSconst [c] (SRAconst <x.Type> x [d])) 14327 for { 14328 d := v.AuxInt 14329 _ = v.Args[1] 14330 v_0 := v.Args[0] 14331 if v_0.Op != OpARMMOVWconst { 14332 break 14333 } 14334 c := v_0.AuxInt 14335 x := v.Args[1] 14336 v.reset(OpARMRSBSconst) 14337 v.AuxInt = c 14338 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 14339 v0.AuxInt = d 14340 v0.AddArg(x) 14341 v.AddArg(v0) 14342 return true 14343 } 14344 // match: (SUBSshiftRA x (MOVWconst [c]) [d]) 14345 // cond: 14346 // result: (SUBSconst x [int64(int32(c)>>uint64(d))]) 14347 for { 14348 d := v.AuxInt 14349 _ = v.Args[1] 14350 x := v.Args[0] 14351 v_1 := v.Args[1] 14352 if v_1.Op != OpARMMOVWconst { 14353 break 14354 } 14355 c := v_1.AuxInt 14356 v.reset(OpARMSUBSconst) 14357 v.AuxInt = int64(int32(c) >> uint64(d)) 14358 v.AddArg(x) 14359 return true 14360 } 14361 return false 14362 } 14363 func rewriteValueARM_OpARMSUBSshiftRAreg_0(v *Value) bool { 14364 b := v.Block 14365 _ = b 14366 // match: (SUBSshiftRAreg (MOVWconst [c]) x y) 14367 // cond: 14368 // result: (RSBSconst [c] (SRA <x.Type> x y)) 14369 for { 14370 _ = v.Args[2] 14371 v_0 := v.Args[0] 14372 if v_0.Op != OpARMMOVWconst { 14373 break 14374 } 14375 c := v_0.AuxInt 14376 x := v.Args[1] 14377 y := v.Args[2] 14378 v.reset(OpARMRSBSconst) 14379 v.AuxInt = c 14380 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 14381 v0.AddArg(x) 14382 v0.AddArg(y) 14383 v.AddArg(v0) 14384 return true 14385 } 14386 // match: (SUBSshiftRAreg x y (MOVWconst [c])) 14387 // cond: 14388 // result: (SUBSshiftRA x y [c]) 14389 for { 14390 _ = v.Args[2] 14391 x := v.Args[0] 14392 y := v.Args[1] 14393 v_2 := v.Args[2] 14394 if v_2.Op != OpARMMOVWconst { 14395 break 14396 } 14397 c := v_2.AuxInt 14398 v.reset(OpARMSUBSshiftRA) 14399 v.AuxInt = c 14400 v.AddArg(x) 14401 v.AddArg(y) 14402 return true 14403 } 14404 return false 14405 } 14406 func rewriteValueARM_OpARMSUBSshiftRL_0(v *Value) bool { 14407 b := v.Block 14408 _ = b 14409 // match: (SUBSshiftRL (MOVWconst [c]) x [d]) 14410 // cond: 14411 // result: (RSBSconst [c] (SRLconst <x.Type> x [d])) 14412 for { 14413 d := v.AuxInt 14414 _ = v.Args[1] 14415 v_0 := v.Args[0] 14416 if v_0.Op != OpARMMOVWconst { 14417 break 14418 } 14419 c := v_0.AuxInt 14420 x := v.Args[1] 14421 v.reset(OpARMRSBSconst) 14422 v.AuxInt = c 14423 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 14424 v0.AuxInt = d 14425 v0.AddArg(x) 14426 v.AddArg(v0) 14427 return true 14428 } 14429 // match: (SUBSshiftRL x (MOVWconst [c]) [d]) 14430 // cond: 14431 // result: (SUBSconst x [int64(uint32(c)>>uint64(d))]) 14432 for { 14433 d := v.AuxInt 14434 _ = v.Args[1] 14435 x := v.Args[0] 14436 v_1 := v.Args[1] 14437 if v_1.Op != OpARMMOVWconst { 14438 break 14439 } 14440 c := v_1.AuxInt 14441 v.reset(OpARMSUBSconst) 14442 v.AuxInt = int64(uint32(c) >> uint64(d)) 14443 v.AddArg(x) 14444 return true 14445 } 14446 return false 14447 } 14448 func rewriteValueARM_OpARMSUBSshiftRLreg_0(v *Value) bool { 14449 b := v.Block 14450 _ = b 14451 // match: (SUBSshiftRLreg (MOVWconst [c]) x y) 14452 // cond: 14453 // result: (RSBSconst [c] (SRL <x.Type> x y)) 14454 for { 14455 _ = v.Args[2] 14456 v_0 := v.Args[0] 14457 if v_0.Op != OpARMMOVWconst { 14458 break 14459 } 14460 c := v_0.AuxInt 14461 x := v.Args[1] 14462 y := v.Args[2] 14463 v.reset(OpARMRSBSconst) 14464 v.AuxInt = c 14465 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 14466 v0.AddArg(x) 14467 v0.AddArg(y) 14468 v.AddArg(v0) 14469 return true 14470 } 14471 // match: (SUBSshiftRLreg x y (MOVWconst [c])) 14472 // cond: 14473 // result: (SUBSshiftRL x y [c]) 14474 for { 14475 _ = v.Args[2] 14476 x := v.Args[0] 14477 y := v.Args[1] 14478 v_2 := v.Args[2] 14479 if v_2.Op != OpARMMOVWconst { 14480 break 14481 } 14482 c := v_2.AuxInt 14483 v.reset(OpARMSUBSshiftRL) 14484 v.AuxInt = c 14485 v.AddArg(x) 14486 v.AddArg(y) 14487 return true 14488 } 14489 return false 14490 } 14491 func rewriteValueARM_OpARMSUBconst_0(v *Value) bool { 14492 // match: (SUBconst [off1] (MOVWaddr [off2] {sym} ptr)) 14493 // cond: 14494 // result: (MOVWaddr [off2-off1] {sym} ptr) 14495 for { 14496 off1 := v.AuxInt 14497 v_0 := v.Args[0] 14498 if v_0.Op != OpARMMOVWaddr { 14499 break 14500 } 14501 off2 := v_0.AuxInt 14502 sym := v_0.Aux 14503 ptr := v_0.Args[0] 14504 v.reset(OpARMMOVWaddr) 14505 v.AuxInt = off2 - off1 14506 v.Aux = sym 14507 v.AddArg(ptr) 14508 return true 14509 } 14510 // match: (SUBconst [0] x) 14511 // cond: 14512 // result: x 14513 for { 14514 if v.AuxInt != 0 { 14515 break 14516 } 14517 x := v.Args[0] 14518 v.reset(OpCopy) 14519 v.Type = x.Type 14520 v.AddArg(x) 14521 return true 14522 } 14523 // match: (SUBconst [c] x) 14524 // cond: !isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c)) 14525 // result: (ADDconst [int64(int32(-c))] x) 14526 for { 14527 c := v.AuxInt 14528 x := v.Args[0] 14529 if !(!isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c))) { 14530 break 14531 } 14532 v.reset(OpARMADDconst) 14533 v.AuxInt = int64(int32(-c)) 14534 v.AddArg(x) 14535 return true 14536 } 14537 // match: (SUBconst [c] (MOVWconst [d])) 14538 // cond: 14539 // result: (MOVWconst [int64(int32(d-c))]) 14540 for { 14541 c := v.AuxInt 14542 v_0 := v.Args[0] 14543 if v_0.Op != OpARMMOVWconst { 14544 break 14545 } 14546 d := v_0.AuxInt 14547 v.reset(OpARMMOVWconst) 14548 v.AuxInt = int64(int32(d - c)) 14549 return true 14550 } 14551 // match: (SUBconst [c] (SUBconst [d] x)) 14552 // cond: 14553 // result: (ADDconst [int64(int32(-c-d))] x) 14554 for { 14555 c := v.AuxInt 14556 v_0 := v.Args[0] 14557 if v_0.Op != OpARMSUBconst { 14558 break 14559 } 14560 d := v_0.AuxInt 14561 x := v_0.Args[0] 14562 v.reset(OpARMADDconst) 14563 v.AuxInt = int64(int32(-c - d)) 14564 v.AddArg(x) 14565 return true 14566 } 14567 // match: (SUBconst [c] (ADDconst [d] x)) 14568 // cond: 14569 // result: (ADDconst [int64(int32(-c+d))] x) 14570 for { 14571 c := v.AuxInt 14572 v_0 := v.Args[0] 14573 if v_0.Op != OpARMADDconst { 14574 break 14575 } 14576 d := v_0.AuxInt 14577 x := v_0.Args[0] 14578 v.reset(OpARMADDconst) 14579 v.AuxInt = int64(int32(-c + d)) 14580 v.AddArg(x) 14581 return true 14582 } 14583 // match: (SUBconst [c] (RSBconst [d] x)) 14584 // cond: 14585 // result: (RSBconst [int64(int32(-c+d))] x) 14586 for { 14587 c := v.AuxInt 14588 v_0 := v.Args[0] 14589 if v_0.Op != OpARMRSBconst { 14590 break 14591 } 14592 d := v_0.AuxInt 14593 x := v_0.Args[0] 14594 v.reset(OpARMRSBconst) 14595 v.AuxInt = int64(int32(-c + d)) 14596 v.AddArg(x) 14597 return true 14598 } 14599 return false 14600 } 14601 func rewriteValueARM_OpARMSUBshiftLL_0(v *Value) bool { 14602 b := v.Block 14603 _ = b 14604 // match: (SUBshiftLL (MOVWconst [c]) x [d]) 14605 // cond: 14606 // result: (RSBconst [c] (SLLconst <x.Type> x [d])) 14607 for { 14608 d := v.AuxInt 14609 _ = v.Args[1] 14610 v_0 := v.Args[0] 14611 if v_0.Op != OpARMMOVWconst { 14612 break 14613 } 14614 c := v_0.AuxInt 14615 x := v.Args[1] 14616 v.reset(OpARMRSBconst) 14617 v.AuxInt = c 14618 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 14619 v0.AuxInt = d 14620 v0.AddArg(x) 14621 v.AddArg(v0) 14622 return true 14623 } 14624 // match: (SUBshiftLL x (MOVWconst [c]) [d]) 14625 // cond: 14626 // result: (SUBconst x [int64(uint32(c)<<uint64(d))]) 14627 for { 14628 d := v.AuxInt 14629 _ = v.Args[1] 14630 x := v.Args[0] 14631 v_1 := v.Args[1] 14632 if v_1.Op != OpARMMOVWconst { 14633 break 14634 } 14635 c := v_1.AuxInt 14636 v.reset(OpARMSUBconst) 14637 v.AuxInt = int64(uint32(c) << uint64(d)) 14638 v.AddArg(x) 14639 return true 14640 } 14641 // match: (SUBshiftLL x (SLLconst x [c]) [d]) 14642 // cond: c==d 14643 // result: (MOVWconst [0]) 14644 for { 14645 d := v.AuxInt 14646 _ = v.Args[1] 14647 x := v.Args[0] 14648 v_1 := v.Args[1] 14649 if v_1.Op != OpARMSLLconst { 14650 break 14651 } 14652 c := v_1.AuxInt 14653 if x != v_1.Args[0] { 14654 break 14655 } 14656 if !(c == d) { 14657 break 14658 } 14659 v.reset(OpARMMOVWconst) 14660 v.AuxInt = 0 14661 return true 14662 } 14663 return false 14664 } 14665 func rewriteValueARM_OpARMSUBshiftLLreg_0(v *Value) bool { 14666 b := v.Block 14667 _ = b 14668 // match: (SUBshiftLLreg (MOVWconst [c]) x y) 14669 // cond: 14670 // result: (RSBconst [c] (SLL <x.Type> x y)) 14671 for { 14672 _ = v.Args[2] 14673 v_0 := v.Args[0] 14674 if v_0.Op != OpARMMOVWconst { 14675 break 14676 } 14677 c := v_0.AuxInt 14678 x := v.Args[1] 14679 y := v.Args[2] 14680 v.reset(OpARMRSBconst) 14681 v.AuxInt = c 14682 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 14683 v0.AddArg(x) 14684 v0.AddArg(y) 14685 v.AddArg(v0) 14686 return true 14687 } 14688 // match: (SUBshiftLLreg x y (MOVWconst [c])) 14689 // cond: 14690 // result: (SUBshiftLL x y [c]) 14691 for { 14692 _ = v.Args[2] 14693 x := v.Args[0] 14694 y := v.Args[1] 14695 v_2 := v.Args[2] 14696 if v_2.Op != OpARMMOVWconst { 14697 break 14698 } 14699 c := v_2.AuxInt 14700 v.reset(OpARMSUBshiftLL) 14701 v.AuxInt = c 14702 v.AddArg(x) 14703 v.AddArg(y) 14704 return true 14705 } 14706 return false 14707 } 14708 func rewriteValueARM_OpARMSUBshiftRA_0(v *Value) bool { 14709 b := v.Block 14710 _ = b 14711 // match: (SUBshiftRA (MOVWconst [c]) x [d]) 14712 // cond: 14713 // result: (RSBconst [c] (SRAconst <x.Type> x [d])) 14714 for { 14715 d := v.AuxInt 14716 _ = v.Args[1] 14717 v_0 := v.Args[0] 14718 if v_0.Op != OpARMMOVWconst { 14719 break 14720 } 14721 c := v_0.AuxInt 14722 x := v.Args[1] 14723 v.reset(OpARMRSBconst) 14724 v.AuxInt = c 14725 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 14726 v0.AuxInt = d 14727 v0.AddArg(x) 14728 v.AddArg(v0) 14729 return true 14730 } 14731 // match: (SUBshiftRA x (MOVWconst [c]) [d]) 14732 // cond: 14733 // result: (SUBconst x [int64(int32(c)>>uint64(d))]) 14734 for { 14735 d := v.AuxInt 14736 _ = v.Args[1] 14737 x := v.Args[0] 14738 v_1 := v.Args[1] 14739 if v_1.Op != OpARMMOVWconst { 14740 break 14741 } 14742 c := v_1.AuxInt 14743 v.reset(OpARMSUBconst) 14744 v.AuxInt = int64(int32(c) >> uint64(d)) 14745 v.AddArg(x) 14746 return true 14747 } 14748 // match: (SUBshiftRA x (SRAconst x [c]) [d]) 14749 // cond: c==d 14750 // result: (MOVWconst [0]) 14751 for { 14752 d := v.AuxInt 14753 _ = v.Args[1] 14754 x := v.Args[0] 14755 v_1 := v.Args[1] 14756 if v_1.Op != OpARMSRAconst { 14757 break 14758 } 14759 c := v_1.AuxInt 14760 if x != v_1.Args[0] { 14761 break 14762 } 14763 if !(c == d) { 14764 break 14765 } 14766 v.reset(OpARMMOVWconst) 14767 v.AuxInt = 0 14768 return true 14769 } 14770 return false 14771 } 14772 func rewriteValueARM_OpARMSUBshiftRAreg_0(v *Value) bool { 14773 b := v.Block 14774 _ = b 14775 // match: (SUBshiftRAreg (MOVWconst [c]) x y) 14776 // cond: 14777 // result: (RSBconst [c] (SRA <x.Type> x y)) 14778 for { 14779 _ = v.Args[2] 14780 v_0 := v.Args[0] 14781 if v_0.Op != OpARMMOVWconst { 14782 break 14783 } 14784 c := v_0.AuxInt 14785 x := v.Args[1] 14786 y := v.Args[2] 14787 v.reset(OpARMRSBconst) 14788 v.AuxInt = c 14789 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 14790 v0.AddArg(x) 14791 v0.AddArg(y) 14792 v.AddArg(v0) 14793 return true 14794 } 14795 // match: (SUBshiftRAreg x y (MOVWconst [c])) 14796 // cond: 14797 // result: (SUBshiftRA x y [c]) 14798 for { 14799 _ = v.Args[2] 14800 x := v.Args[0] 14801 y := v.Args[1] 14802 v_2 := v.Args[2] 14803 if v_2.Op != OpARMMOVWconst { 14804 break 14805 } 14806 c := v_2.AuxInt 14807 v.reset(OpARMSUBshiftRA) 14808 v.AuxInt = c 14809 v.AddArg(x) 14810 v.AddArg(y) 14811 return true 14812 } 14813 return false 14814 } 14815 func rewriteValueARM_OpARMSUBshiftRL_0(v *Value) bool { 14816 b := v.Block 14817 _ = b 14818 // match: (SUBshiftRL (MOVWconst [c]) x [d]) 14819 // cond: 14820 // result: (RSBconst [c] (SRLconst <x.Type> x [d])) 14821 for { 14822 d := v.AuxInt 14823 _ = v.Args[1] 14824 v_0 := v.Args[0] 14825 if v_0.Op != OpARMMOVWconst { 14826 break 14827 } 14828 c := v_0.AuxInt 14829 x := v.Args[1] 14830 v.reset(OpARMRSBconst) 14831 v.AuxInt = c 14832 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 14833 v0.AuxInt = d 14834 v0.AddArg(x) 14835 v.AddArg(v0) 14836 return true 14837 } 14838 // match: (SUBshiftRL x (MOVWconst [c]) [d]) 14839 // cond: 14840 // result: (SUBconst x [int64(uint32(c)>>uint64(d))]) 14841 for { 14842 d := v.AuxInt 14843 _ = v.Args[1] 14844 x := v.Args[0] 14845 v_1 := v.Args[1] 14846 if v_1.Op != OpARMMOVWconst { 14847 break 14848 } 14849 c := v_1.AuxInt 14850 v.reset(OpARMSUBconst) 14851 v.AuxInt = int64(uint32(c) >> uint64(d)) 14852 v.AddArg(x) 14853 return true 14854 } 14855 // match: (SUBshiftRL x (SRLconst x [c]) [d]) 14856 // cond: c==d 14857 // result: (MOVWconst [0]) 14858 for { 14859 d := v.AuxInt 14860 _ = v.Args[1] 14861 x := v.Args[0] 14862 v_1 := v.Args[1] 14863 if v_1.Op != OpARMSRLconst { 14864 break 14865 } 14866 c := v_1.AuxInt 14867 if x != v_1.Args[0] { 14868 break 14869 } 14870 if !(c == d) { 14871 break 14872 } 14873 v.reset(OpARMMOVWconst) 14874 v.AuxInt = 0 14875 return true 14876 } 14877 return false 14878 } 14879 func rewriteValueARM_OpARMSUBshiftRLreg_0(v *Value) bool { 14880 b := v.Block 14881 _ = b 14882 // match: (SUBshiftRLreg (MOVWconst [c]) x y) 14883 // cond: 14884 // result: (RSBconst [c] (SRL <x.Type> x y)) 14885 for { 14886 _ = v.Args[2] 14887 v_0 := v.Args[0] 14888 if v_0.Op != OpARMMOVWconst { 14889 break 14890 } 14891 c := v_0.AuxInt 14892 x := v.Args[1] 14893 y := v.Args[2] 14894 v.reset(OpARMRSBconst) 14895 v.AuxInt = c 14896 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 14897 v0.AddArg(x) 14898 v0.AddArg(y) 14899 v.AddArg(v0) 14900 return true 14901 } 14902 // match: (SUBshiftRLreg x y (MOVWconst [c])) 14903 // cond: 14904 // result: (SUBshiftRL x y [c]) 14905 for { 14906 _ = v.Args[2] 14907 x := v.Args[0] 14908 y := v.Args[1] 14909 v_2 := v.Args[2] 14910 if v_2.Op != OpARMMOVWconst { 14911 break 14912 } 14913 c := v_2.AuxInt 14914 v.reset(OpARMSUBshiftRL) 14915 v.AuxInt = c 14916 v.AddArg(x) 14917 v.AddArg(y) 14918 return true 14919 } 14920 return false 14921 } 14922 func rewriteValueARM_OpARMXOR_0(v *Value) bool { 14923 // match: (XOR x (MOVWconst [c])) 14924 // cond: 14925 // result: (XORconst [c] x) 14926 for { 14927 _ = v.Args[1] 14928 x := v.Args[0] 14929 v_1 := v.Args[1] 14930 if v_1.Op != OpARMMOVWconst { 14931 break 14932 } 14933 c := v_1.AuxInt 14934 v.reset(OpARMXORconst) 14935 v.AuxInt = c 14936 v.AddArg(x) 14937 return true 14938 } 14939 // match: (XOR (MOVWconst [c]) x) 14940 // cond: 14941 // result: (XORconst [c] x) 14942 for { 14943 _ = v.Args[1] 14944 v_0 := v.Args[0] 14945 if v_0.Op != OpARMMOVWconst { 14946 break 14947 } 14948 c := v_0.AuxInt 14949 x := v.Args[1] 14950 v.reset(OpARMXORconst) 14951 v.AuxInt = c 14952 v.AddArg(x) 14953 return true 14954 } 14955 // match: (XOR x (SLLconst [c] y)) 14956 // cond: 14957 // result: (XORshiftLL x y [c]) 14958 for { 14959 _ = v.Args[1] 14960 x := v.Args[0] 14961 v_1 := v.Args[1] 14962 if v_1.Op != OpARMSLLconst { 14963 break 14964 } 14965 c := v_1.AuxInt 14966 y := v_1.Args[0] 14967 v.reset(OpARMXORshiftLL) 14968 v.AuxInt = c 14969 v.AddArg(x) 14970 v.AddArg(y) 14971 return true 14972 } 14973 // match: (XOR (SLLconst [c] y) x) 14974 // cond: 14975 // result: (XORshiftLL x y [c]) 14976 for { 14977 _ = v.Args[1] 14978 v_0 := v.Args[0] 14979 if v_0.Op != OpARMSLLconst { 14980 break 14981 } 14982 c := v_0.AuxInt 14983 y := v_0.Args[0] 14984 x := v.Args[1] 14985 v.reset(OpARMXORshiftLL) 14986 v.AuxInt = c 14987 v.AddArg(x) 14988 v.AddArg(y) 14989 return true 14990 } 14991 // match: (XOR x (SRLconst [c] y)) 14992 // cond: 14993 // result: (XORshiftRL x y [c]) 14994 for { 14995 _ = v.Args[1] 14996 x := v.Args[0] 14997 v_1 := v.Args[1] 14998 if v_1.Op != OpARMSRLconst { 14999 break 15000 } 15001 c := v_1.AuxInt 15002 y := v_1.Args[0] 15003 v.reset(OpARMXORshiftRL) 15004 v.AuxInt = c 15005 v.AddArg(x) 15006 v.AddArg(y) 15007 return true 15008 } 15009 // match: (XOR (SRLconst [c] y) x) 15010 // cond: 15011 // result: (XORshiftRL x y [c]) 15012 for { 15013 _ = v.Args[1] 15014 v_0 := v.Args[0] 15015 if v_0.Op != OpARMSRLconst { 15016 break 15017 } 15018 c := v_0.AuxInt 15019 y := v_0.Args[0] 15020 x := v.Args[1] 15021 v.reset(OpARMXORshiftRL) 15022 v.AuxInt = c 15023 v.AddArg(x) 15024 v.AddArg(y) 15025 return true 15026 } 15027 // match: (XOR x (SRAconst [c] y)) 15028 // cond: 15029 // result: (XORshiftRA x y [c]) 15030 for { 15031 _ = v.Args[1] 15032 x := v.Args[0] 15033 v_1 := v.Args[1] 15034 if v_1.Op != OpARMSRAconst { 15035 break 15036 } 15037 c := v_1.AuxInt 15038 y := v_1.Args[0] 15039 v.reset(OpARMXORshiftRA) 15040 v.AuxInt = c 15041 v.AddArg(x) 15042 v.AddArg(y) 15043 return true 15044 } 15045 // match: (XOR (SRAconst [c] y) x) 15046 // cond: 15047 // result: (XORshiftRA x y [c]) 15048 for { 15049 _ = v.Args[1] 15050 v_0 := v.Args[0] 15051 if v_0.Op != OpARMSRAconst { 15052 break 15053 } 15054 c := v_0.AuxInt 15055 y := v_0.Args[0] 15056 x := v.Args[1] 15057 v.reset(OpARMXORshiftRA) 15058 v.AuxInt = c 15059 v.AddArg(x) 15060 v.AddArg(y) 15061 return true 15062 } 15063 // match: (XOR x (SRRconst [c] y)) 15064 // cond: 15065 // result: (XORshiftRR x y [c]) 15066 for { 15067 _ = v.Args[1] 15068 x := v.Args[0] 15069 v_1 := v.Args[1] 15070 if v_1.Op != OpARMSRRconst { 15071 break 15072 } 15073 c := v_1.AuxInt 15074 y := v_1.Args[0] 15075 v.reset(OpARMXORshiftRR) 15076 v.AuxInt = c 15077 v.AddArg(x) 15078 v.AddArg(y) 15079 return true 15080 } 15081 // match: (XOR (SRRconst [c] y) x) 15082 // cond: 15083 // result: (XORshiftRR x y [c]) 15084 for { 15085 _ = v.Args[1] 15086 v_0 := v.Args[0] 15087 if v_0.Op != OpARMSRRconst { 15088 break 15089 } 15090 c := v_0.AuxInt 15091 y := v_0.Args[0] 15092 x := v.Args[1] 15093 v.reset(OpARMXORshiftRR) 15094 v.AuxInt = c 15095 v.AddArg(x) 15096 v.AddArg(y) 15097 return true 15098 } 15099 return false 15100 } 15101 func rewriteValueARM_OpARMXOR_10(v *Value) bool { 15102 // match: (XOR x (SLL y z)) 15103 // cond: 15104 // result: (XORshiftLLreg x y z) 15105 for { 15106 _ = v.Args[1] 15107 x := v.Args[0] 15108 v_1 := v.Args[1] 15109 if v_1.Op != OpARMSLL { 15110 break 15111 } 15112 _ = v_1.Args[1] 15113 y := v_1.Args[0] 15114 z := v_1.Args[1] 15115 v.reset(OpARMXORshiftLLreg) 15116 v.AddArg(x) 15117 v.AddArg(y) 15118 v.AddArg(z) 15119 return true 15120 } 15121 // match: (XOR (SLL y z) x) 15122 // cond: 15123 // result: (XORshiftLLreg x y z) 15124 for { 15125 _ = v.Args[1] 15126 v_0 := v.Args[0] 15127 if v_0.Op != OpARMSLL { 15128 break 15129 } 15130 _ = v_0.Args[1] 15131 y := v_0.Args[0] 15132 z := v_0.Args[1] 15133 x := v.Args[1] 15134 v.reset(OpARMXORshiftLLreg) 15135 v.AddArg(x) 15136 v.AddArg(y) 15137 v.AddArg(z) 15138 return true 15139 } 15140 // match: (XOR x (SRL y z)) 15141 // cond: 15142 // result: (XORshiftRLreg x y z) 15143 for { 15144 _ = v.Args[1] 15145 x := v.Args[0] 15146 v_1 := v.Args[1] 15147 if v_1.Op != OpARMSRL { 15148 break 15149 } 15150 _ = v_1.Args[1] 15151 y := v_1.Args[0] 15152 z := v_1.Args[1] 15153 v.reset(OpARMXORshiftRLreg) 15154 v.AddArg(x) 15155 v.AddArg(y) 15156 v.AddArg(z) 15157 return true 15158 } 15159 // match: (XOR (SRL y z) x) 15160 // cond: 15161 // result: (XORshiftRLreg x y z) 15162 for { 15163 _ = v.Args[1] 15164 v_0 := v.Args[0] 15165 if v_0.Op != OpARMSRL { 15166 break 15167 } 15168 _ = v_0.Args[1] 15169 y := v_0.Args[0] 15170 z := v_0.Args[1] 15171 x := v.Args[1] 15172 v.reset(OpARMXORshiftRLreg) 15173 v.AddArg(x) 15174 v.AddArg(y) 15175 v.AddArg(z) 15176 return true 15177 } 15178 // match: (XOR x (SRA y z)) 15179 // cond: 15180 // result: (XORshiftRAreg x y z) 15181 for { 15182 _ = v.Args[1] 15183 x := v.Args[0] 15184 v_1 := v.Args[1] 15185 if v_1.Op != OpARMSRA { 15186 break 15187 } 15188 _ = v_1.Args[1] 15189 y := v_1.Args[0] 15190 z := v_1.Args[1] 15191 v.reset(OpARMXORshiftRAreg) 15192 v.AddArg(x) 15193 v.AddArg(y) 15194 v.AddArg(z) 15195 return true 15196 } 15197 // match: (XOR (SRA y z) x) 15198 // cond: 15199 // result: (XORshiftRAreg x y z) 15200 for { 15201 _ = v.Args[1] 15202 v_0 := v.Args[0] 15203 if v_0.Op != OpARMSRA { 15204 break 15205 } 15206 _ = v_0.Args[1] 15207 y := v_0.Args[0] 15208 z := v_0.Args[1] 15209 x := v.Args[1] 15210 v.reset(OpARMXORshiftRAreg) 15211 v.AddArg(x) 15212 v.AddArg(y) 15213 v.AddArg(z) 15214 return true 15215 } 15216 // match: (XOR x x) 15217 // cond: 15218 // result: (MOVWconst [0]) 15219 for { 15220 _ = v.Args[1] 15221 x := v.Args[0] 15222 if x != v.Args[1] { 15223 break 15224 } 15225 v.reset(OpARMMOVWconst) 15226 v.AuxInt = 0 15227 return true 15228 } 15229 return false 15230 } 15231 func rewriteValueARM_OpARMXORconst_0(v *Value) bool { 15232 // match: (XORconst [0] x) 15233 // cond: 15234 // result: x 15235 for { 15236 if v.AuxInt != 0 { 15237 break 15238 } 15239 x := v.Args[0] 15240 v.reset(OpCopy) 15241 v.Type = x.Type 15242 v.AddArg(x) 15243 return true 15244 } 15245 // match: (XORconst [c] (MOVWconst [d])) 15246 // cond: 15247 // result: (MOVWconst [c^d]) 15248 for { 15249 c := v.AuxInt 15250 v_0 := v.Args[0] 15251 if v_0.Op != OpARMMOVWconst { 15252 break 15253 } 15254 d := v_0.AuxInt 15255 v.reset(OpARMMOVWconst) 15256 v.AuxInt = c ^ d 15257 return true 15258 } 15259 // match: (XORconst [c] (XORconst [d] x)) 15260 // cond: 15261 // result: (XORconst [c^d] x) 15262 for { 15263 c := v.AuxInt 15264 v_0 := v.Args[0] 15265 if v_0.Op != OpARMXORconst { 15266 break 15267 } 15268 d := v_0.AuxInt 15269 x := v_0.Args[0] 15270 v.reset(OpARMXORconst) 15271 v.AuxInt = c ^ d 15272 v.AddArg(x) 15273 return true 15274 } 15275 return false 15276 } 15277 func rewriteValueARM_OpARMXORshiftLL_0(v *Value) bool { 15278 b := v.Block 15279 _ = b 15280 // match: (XORshiftLL (MOVWconst [c]) x [d]) 15281 // cond: 15282 // result: (XORconst [c] (SLLconst <x.Type> x [d])) 15283 for { 15284 d := v.AuxInt 15285 _ = v.Args[1] 15286 v_0 := v.Args[0] 15287 if v_0.Op != OpARMMOVWconst { 15288 break 15289 } 15290 c := v_0.AuxInt 15291 x := v.Args[1] 15292 v.reset(OpARMXORconst) 15293 v.AuxInt = c 15294 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 15295 v0.AuxInt = d 15296 v0.AddArg(x) 15297 v.AddArg(v0) 15298 return true 15299 } 15300 // match: (XORshiftLL x (MOVWconst [c]) [d]) 15301 // cond: 15302 // result: (XORconst x [int64(uint32(c)<<uint64(d))]) 15303 for { 15304 d := v.AuxInt 15305 _ = v.Args[1] 15306 x := v.Args[0] 15307 v_1 := v.Args[1] 15308 if v_1.Op != OpARMMOVWconst { 15309 break 15310 } 15311 c := v_1.AuxInt 15312 v.reset(OpARMXORconst) 15313 v.AuxInt = int64(uint32(c) << uint64(d)) 15314 v.AddArg(x) 15315 return true 15316 } 15317 // match: (XORshiftLL [c] (SRLconst x [32-c]) x) 15318 // cond: 15319 // result: (SRRconst [32-c] x) 15320 for { 15321 c := v.AuxInt 15322 _ = v.Args[1] 15323 v_0 := v.Args[0] 15324 if v_0.Op != OpARMSRLconst { 15325 break 15326 } 15327 if v_0.AuxInt != 32-c { 15328 break 15329 } 15330 x := v_0.Args[0] 15331 if x != v.Args[1] { 15332 break 15333 } 15334 v.reset(OpARMSRRconst) 15335 v.AuxInt = 32 - c 15336 v.AddArg(x) 15337 return true 15338 } 15339 // match: (XORshiftLL x (SLLconst x [c]) [d]) 15340 // cond: c==d 15341 // result: (MOVWconst [0]) 15342 for { 15343 d := v.AuxInt 15344 _ = v.Args[1] 15345 x := v.Args[0] 15346 v_1 := v.Args[1] 15347 if v_1.Op != OpARMSLLconst { 15348 break 15349 } 15350 c := v_1.AuxInt 15351 if x != v_1.Args[0] { 15352 break 15353 } 15354 if !(c == d) { 15355 break 15356 } 15357 v.reset(OpARMMOVWconst) 15358 v.AuxInt = 0 15359 return true 15360 } 15361 return false 15362 } 15363 func rewriteValueARM_OpARMXORshiftLLreg_0(v *Value) bool { 15364 b := v.Block 15365 _ = b 15366 // match: (XORshiftLLreg (MOVWconst [c]) x y) 15367 // cond: 15368 // result: (XORconst [c] (SLL <x.Type> x y)) 15369 for { 15370 _ = v.Args[2] 15371 v_0 := v.Args[0] 15372 if v_0.Op != OpARMMOVWconst { 15373 break 15374 } 15375 c := v_0.AuxInt 15376 x := v.Args[1] 15377 y := v.Args[2] 15378 v.reset(OpARMXORconst) 15379 v.AuxInt = c 15380 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 15381 v0.AddArg(x) 15382 v0.AddArg(y) 15383 v.AddArg(v0) 15384 return true 15385 } 15386 // match: (XORshiftLLreg x y (MOVWconst [c])) 15387 // cond: 15388 // result: (XORshiftLL x y [c]) 15389 for { 15390 _ = v.Args[2] 15391 x := v.Args[0] 15392 y := v.Args[1] 15393 v_2 := v.Args[2] 15394 if v_2.Op != OpARMMOVWconst { 15395 break 15396 } 15397 c := v_2.AuxInt 15398 v.reset(OpARMXORshiftLL) 15399 v.AuxInt = c 15400 v.AddArg(x) 15401 v.AddArg(y) 15402 return true 15403 } 15404 return false 15405 } 15406 func rewriteValueARM_OpARMXORshiftRA_0(v *Value) bool { 15407 b := v.Block 15408 _ = b 15409 // match: (XORshiftRA (MOVWconst [c]) x [d]) 15410 // cond: 15411 // result: (XORconst [c] (SRAconst <x.Type> x [d])) 15412 for { 15413 d := v.AuxInt 15414 _ = v.Args[1] 15415 v_0 := v.Args[0] 15416 if v_0.Op != OpARMMOVWconst { 15417 break 15418 } 15419 c := v_0.AuxInt 15420 x := v.Args[1] 15421 v.reset(OpARMXORconst) 15422 v.AuxInt = c 15423 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 15424 v0.AuxInt = d 15425 v0.AddArg(x) 15426 v.AddArg(v0) 15427 return true 15428 } 15429 // match: (XORshiftRA x (MOVWconst [c]) [d]) 15430 // cond: 15431 // result: (XORconst x [int64(int32(c)>>uint64(d))]) 15432 for { 15433 d := v.AuxInt 15434 _ = v.Args[1] 15435 x := v.Args[0] 15436 v_1 := v.Args[1] 15437 if v_1.Op != OpARMMOVWconst { 15438 break 15439 } 15440 c := v_1.AuxInt 15441 v.reset(OpARMXORconst) 15442 v.AuxInt = int64(int32(c) >> uint64(d)) 15443 v.AddArg(x) 15444 return true 15445 } 15446 // match: (XORshiftRA x (SRAconst x [c]) [d]) 15447 // cond: c==d 15448 // result: (MOVWconst [0]) 15449 for { 15450 d := v.AuxInt 15451 _ = v.Args[1] 15452 x := v.Args[0] 15453 v_1 := v.Args[1] 15454 if v_1.Op != OpARMSRAconst { 15455 break 15456 } 15457 c := v_1.AuxInt 15458 if x != v_1.Args[0] { 15459 break 15460 } 15461 if !(c == d) { 15462 break 15463 } 15464 v.reset(OpARMMOVWconst) 15465 v.AuxInt = 0 15466 return true 15467 } 15468 return false 15469 } 15470 func rewriteValueARM_OpARMXORshiftRAreg_0(v *Value) bool { 15471 b := v.Block 15472 _ = b 15473 // match: (XORshiftRAreg (MOVWconst [c]) x y) 15474 // cond: 15475 // result: (XORconst [c] (SRA <x.Type> x y)) 15476 for { 15477 _ = v.Args[2] 15478 v_0 := v.Args[0] 15479 if v_0.Op != OpARMMOVWconst { 15480 break 15481 } 15482 c := v_0.AuxInt 15483 x := v.Args[1] 15484 y := v.Args[2] 15485 v.reset(OpARMXORconst) 15486 v.AuxInt = c 15487 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 15488 v0.AddArg(x) 15489 v0.AddArg(y) 15490 v.AddArg(v0) 15491 return true 15492 } 15493 // match: (XORshiftRAreg x y (MOVWconst [c])) 15494 // cond: 15495 // result: (XORshiftRA x y [c]) 15496 for { 15497 _ = v.Args[2] 15498 x := v.Args[0] 15499 y := v.Args[1] 15500 v_2 := v.Args[2] 15501 if v_2.Op != OpARMMOVWconst { 15502 break 15503 } 15504 c := v_2.AuxInt 15505 v.reset(OpARMXORshiftRA) 15506 v.AuxInt = c 15507 v.AddArg(x) 15508 v.AddArg(y) 15509 return true 15510 } 15511 return false 15512 } 15513 func rewriteValueARM_OpARMXORshiftRL_0(v *Value) bool { 15514 b := v.Block 15515 _ = b 15516 // match: (XORshiftRL (MOVWconst [c]) x [d]) 15517 // cond: 15518 // result: (XORconst [c] (SRLconst <x.Type> x [d])) 15519 for { 15520 d := v.AuxInt 15521 _ = v.Args[1] 15522 v_0 := v.Args[0] 15523 if v_0.Op != OpARMMOVWconst { 15524 break 15525 } 15526 c := v_0.AuxInt 15527 x := v.Args[1] 15528 v.reset(OpARMXORconst) 15529 v.AuxInt = c 15530 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 15531 v0.AuxInt = d 15532 v0.AddArg(x) 15533 v.AddArg(v0) 15534 return true 15535 } 15536 // match: (XORshiftRL x (MOVWconst [c]) [d]) 15537 // cond: 15538 // result: (XORconst x [int64(uint32(c)>>uint64(d))]) 15539 for { 15540 d := v.AuxInt 15541 _ = v.Args[1] 15542 x := v.Args[0] 15543 v_1 := v.Args[1] 15544 if v_1.Op != OpARMMOVWconst { 15545 break 15546 } 15547 c := v_1.AuxInt 15548 v.reset(OpARMXORconst) 15549 v.AuxInt = int64(uint32(c) >> uint64(d)) 15550 v.AddArg(x) 15551 return true 15552 } 15553 // match: (XORshiftRL [c] (SLLconst x [32-c]) x) 15554 // cond: 15555 // result: (SRRconst [ c] x) 15556 for { 15557 c := v.AuxInt 15558 _ = v.Args[1] 15559 v_0 := v.Args[0] 15560 if v_0.Op != OpARMSLLconst { 15561 break 15562 } 15563 if v_0.AuxInt != 32-c { 15564 break 15565 } 15566 x := v_0.Args[0] 15567 if x != v.Args[1] { 15568 break 15569 } 15570 v.reset(OpARMSRRconst) 15571 v.AuxInt = c 15572 v.AddArg(x) 15573 return true 15574 } 15575 // match: (XORshiftRL x (SRLconst x [c]) [d]) 15576 // cond: c==d 15577 // result: (MOVWconst [0]) 15578 for { 15579 d := v.AuxInt 15580 _ = v.Args[1] 15581 x := v.Args[0] 15582 v_1 := v.Args[1] 15583 if v_1.Op != OpARMSRLconst { 15584 break 15585 } 15586 c := v_1.AuxInt 15587 if x != v_1.Args[0] { 15588 break 15589 } 15590 if !(c == d) { 15591 break 15592 } 15593 v.reset(OpARMMOVWconst) 15594 v.AuxInt = 0 15595 return true 15596 } 15597 return false 15598 } 15599 func rewriteValueARM_OpARMXORshiftRLreg_0(v *Value) bool { 15600 b := v.Block 15601 _ = b 15602 // match: (XORshiftRLreg (MOVWconst [c]) x y) 15603 // cond: 15604 // result: (XORconst [c] (SRL <x.Type> x y)) 15605 for { 15606 _ = v.Args[2] 15607 v_0 := v.Args[0] 15608 if v_0.Op != OpARMMOVWconst { 15609 break 15610 } 15611 c := v_0.AuxInt 15612 x := v.Args[1] 15613 y := v.Args[2] 15614 v.reset(OpARMXORconst) 15615 v.AuxInt = c 15616 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 15617 v0.AddArg(x) 15618 v0.AddArg(y) 15619 v.AddArg(v0) 15620 return true 15621 } 15622 // match: (XORshiftRLreg x y (MOVWconst [c])) 15623 // cond: 15624 // result: (XORshiftRL x y [c]) 15625 for { 15626 _ = v.Args[2] 15627 x := v.Args[0] 15628 y := v.Args[1] 15629 v_2 := v.Args[2] 15630 if v_2.Op != OpARMMOVWconst { 15631 break 15632 } 15633 c := v_2.AuxInt 15634 v.reset(OpARMXORshiftRL) 15635 v.AuxInt = c 15636 v.AddArg(x) 15637 v.AddArg(y) 15638 return true 15639 } 15640 return false 15641 } 15642 func rewriteValueARM_OpARMXORshiftRR_0(v *Value) bool { 15643 b := v.Block 15644 _ = b 15645 // match: (XORshiftRR (MOVWconst [c]) x [d]) 15646 // cond: 15647 // result: (XORconst [c] (SRRconst <x.Type> x [d])) 15648 for { 15649 d := v.AuxInt 15650 _ = v.Args[1] 15651 v_0 := v.Args[0] 15652 if v_0.Op != OpARMMOVWconst { 15653 break 15654 } 15655 c := v_0.AuxInt 15656 x := v.Args[1] 15657 v.reset(OpARMXORconst) 15658 v.AuxInt = c 15659 v0 := b.NewValue0(v.Pos, OpARMSRRconst, x.Type) 15660 v0.AuxInt = d 15661 v0.AddArg(x) 15662 v.AddArg(v0) 15663 return true 15664 } 15665 // match: (XORshiftRR x (MOVWconst [c]) [d]) 15666 // cond: 15667 // result: (XORconst x [int64(uint32(c)>>uint64(d)|uint32(c)<<uint64(32-d))]) 15668 for { 15669 d := v.AuxInt 15670 _ = v.Args[1] 15671 x := v.Args[0] 15672 v_1 := v.Args[1] 15673 if v_1.Op != OpARMMOVWconst { 15674 break 15675 } 15676 c := v_1.AuxInt 15677 v.reset(OpARMXORconst) 15678 v.AuxInt = int64(uint32(c)>>uint64(d) | uint32(c)<<uint64(32-d)) 15679 v.AddArg(x) 15680 return true 15681 } 15682 return false 15683 } 15684 func rewriteValueARM_OpAdd16_0(v *Value) bool { 15685 // match: (Add16 x y) 15686 // cond: 15687 // result: (ADD x y) 15688 for { 15689 _ = v.Args[1] 15690 x := v.Args[0] 15691 y := v.Args[1] 15692 v.reset(OpARMADD) 15693 v.AddArg(x) 15694 v.AddArg(y) 15695 return true 15696 } 15697 } 15698 func rewriteValueARM_OpAdd32_0(v *Value) bool { 15699 // match: (Add32 x y) 15700 // cond: 15701 // result: (ADD x y) 15702 for { 15703 _ = v.Args[1] 15704 x := v.Args[0] 15705 y := v.Args[1] 15706 v.reset(OpARMADD) 15707 v.AddArg(x) 15708 v.AddArg(y) 15709 return true 15710 } 15711 } 15712 func rewriteValueARM_OpAdd32F_0(v *Value) bool { 15713 // match: (Add32F x y) 15714 // cond: 15715 // result: (ADDF x y) 15716 for { 15717 _ = v.Args[1] 15718 x := v.Args[0] 15719 y := v.Args[1] 15720 v.reset(OpARMADDF) 15721 v.AddArg(x) 15722 v.AddArg(y) 15723 return true 15724 } 15725 } 15726 func rewriteValueARM_OpAdd32carry_0(v *Value) bool { 15727 // match: (Add32carry x y) 15728 // cond: 15729 // result: (ADDS x y) 15730 for { 15731 _ = v.Args[1] 15732 x := v.Args[0] 15733 y := v.Args[1] 15734 v.reset(OpARMADDS) 15735 v.AddArg(x) 15736 v.AddArg(y) 15737 return true 15738 } 15739 } 15740 func rewriteValueARM_OpAdd32withcarry_0(v *Value) bool { 15741 // match: (Add32withcarry x y c) 15742 // cond: 15743 // result: (ADC x y c) 15744 for { 15745 _ = v.Args[2] 15746 x := v.Args[0] 15747 y := v.Args[1] 15748 c := v.Args[2] 15749 v.reset(OpARMADC) 15750 v.AddArg(x) 15751 v.AddArg(y) 15752 v.AddArg(c) 15753 return true 15754 } 15755 } 15756 func rewriteValueARM_OpAdd64F_0(v *Value) bool { 15757 // match: (Add64F x y) 15758 // cond: 15759 // result: (ADDD x y) 15760 for { 15761 _ = v.Args[1] 15762 x := v.Args[0] 15763 y := v.Args[1] 15764 v.reset(OpARMADDD) 15765 v.AddArg(x) 15766 v.AddArg(y) 15767 return true 15768 } 15769 } 15770 func rewriteValueARM_OpAdd8_0(v *Value) bool { 15771 // match: (Add8 x y) 15772 // cond: 15773 // result: (ADD x y) 15774 for { 15775 _ = v.Args[1] 15776 x := v.Args[0] 15777 y := v.Args[1] 15778 v.reset(OpARMADD) 15779 v.AddArg(x) 15780 v.AddArg(y) 15781 return true 15782 } 15783 } 15784 func rewriteValueARM_OpAddPtr_0(v *Value) bool { 15785 // match: (AddPtr x y) 15786 // cond: 15787 // result: (ADD x y) 15788 for { 15789 _ = v.Args[1] 15790 x := v.Args[0] 15791 y := v.Args[1] 15792 v.reset(OpARMADD) 15793 v.AddArg(x) 15794 v.AddArg(y) 15795 return true 15796 } 15797 } 15798 func rewriteValueARM_OpAddr_0(v *Value) bool { 15799 // match: (Addr {sym} base) 15800 // cond: 15801 // result: (MOVWaddr {sym} base) 15802 for { 15803 sym := v.Aux 15804 base := v.Args[0] 15805 v.reset(OpARMMOVWaddr) 15806 v.Aux = sym 15807 v.AddArg(base) 15808 return true 15809 } 15810 } 15811 func rewriteValueARM_OpAnd16_0(v *Value) bool { 15812 // match: (And16 x y) 15813 // cond: 15814 // result: (AND x y) 15815 for { 15816 _ = v.Args[1] 15817 x := v.Args[0] 15818 y := v.Args[1] 15819 v.reset(OpARMAND) 15820 v.AddArg(x) 15821 v.AddArg(y) 15822 return true 15823 } 15824 } 15825 func rewriteValueARM_OpAnd32_0(v *Value) bool { 15826 // match: (And32 x y) 15827 // cond: 15828 // result: (AND x y) 15829 for { 15830 _ = v.Args[1] 15831 x := v.Args[0] 15832 y := v.Args[1] 15833 v.reset(OpARMAND) 15834 v.AddArg(x) 15835 v.AddArg(y) 15836 return true 15837 } 15838 } 15839 func rewriteValueARM_OpAnd8_0(v *Value) bool { 15840 // match: (And8 x y) 15841 // cond: 15842 // result: (AND x y) 15843 for { 15844 _ = v.Args[1] 15845 x := v.Args[0] 15846 y := v.Args[1] 15847 v.reset(OpARMAND) 15848 v.AddArg(x) 15849 v.AddArg(y) 15850 return true 15851 } 15852 } 15853 func rewriteValueARM_OpAndB_0(v *Value) bool { 15854 // match: (AndB x y) 15855 // cond: 15856 // result: (AND x y) 15857 for { 15858 _ = v.Args[1] 15859 x := v.Args[0] 15860 y := v.Args[1] 15861 v.reset(OpARMAND) 15862 v.AddArg(x) 15863 v.AddArg(y) 15864 return true 15865 } 15866 } 15867 func rewriteValueARM_OpAvg32u_0(v *Value) bool { 15868 b := v.Block 15869 _ = b 15870 // match: (Avg32u <t> x y) 15871 // cond: 15872 // result: (ADD (SRLconst <t> (SUB <t> x y) [1]) y) 15873 for { 15874 t := v.Type 15875 _ = v.Args[1] 15876 x := v.Args[0] 15877 y := v.Args[1] 15878 v.reset(OpARMADD) 15879 v0 := b.NewValue0(v.Pos, OpARMSRLconst, t) 15880 v0.AuxInt = 1 15881 v1 := b.NewValue0(v.Pos, OpARMSUB, t) 15882 v1.AddArg(x) 15883 v1.AddArg(y) 15884 v0.AddArg(v1) 15885 v.AddArg(v0) 15886 v.AddArg(y) 15887 return true 15888 } 15889 } 15890 func rewriteValueARM_OpBitLen32_0(v *Value) bool { 15891 b := v.Block 15892 _ = b 15893 // match: (BitLen32 <t> x) 15894 // cond: 15895 // result: (RSBconst [32] (CLZ <t> x)) 15896 for { 15897 t := v.Type 15898 x := v.Args[0] 15899 v.reset(OpARMRSBconst) 15900 v.AuxInt = 32 15901 v0 := b.NewValue0(v.Pos, OpARMCLZ, t) 15902 v0.AddArg(x) 15903 v.AddArg(v0) 15904 return true 15905 } 15906 } 15907 func rewriteValueARM_OpBswap32_0(v *Value) bool { 15908 b := v.Block 15909 _ = b 15910 // match: (Bswap32 <t> x) 15911 // cond: objabi.GOARM==5 15912 // result: (XOR <t> (SRLconst <t> (BICconst <t> (XOR <t> x (SRRconst <t> [16] x)) [0xff0000]) [8]) (SRRconst <t> x [8])) 15913 for { 15914 t := v.Type 15915 x := v.Args[0] 15916 if !(objabi.GOARM == 5) { 15917 break 15918 } 15919 v.reset(OpARMXOR) 15920 v.Type = t 15921 v0 := b.NewValue0(v.Pos, OpARMSRLconst, t) 15922 v0.AuxInt = 8 15923 v1 := b.NewValue0(v.Pos, OpARMBICconst, t) 15924 v1.AuxInt = 0xff0000 15925 v2 := b.NewValue0(v.Pos, OpARMXOR, t) 15926 v2.AddArg(x) 15927 v3 := b.NewValue0(v.Pos, OpARMSRRconst, t) 15928 v3.AuxInt = 16 15929 v3.AddArg(x) 15930 v2.AddArg(v3) 15931 v1.AddArg(v2) 15932 v0.AddArg(v1) 15933 v.AddArg(v0) 15934 v4 := b.NewValue0(v.Pos, OpARMSRRconst, t) 15935 v4.AuxInt = 8 15936 v4.AddArg(x) 15937 v.AddArg(v4) 15938 return true 15939 } 15940 // match: (Bswap32 x) 15941 // cond: objabi.GOARM>=6 15942 // result: (REV x) 15943 for { 15944 x := v.Args[0] 15945 if !(objabi.GOARM >= 6) { 15946 break 15947 } 15948 v.reset(OpARMREV) 15949 v.AddArg(x) 15950 return true 15951 } 15952 return false 15953 } 15954 func rewriteValueARM_OpClosureCall_0(v *Value) bool { 15955 // match: (ClosureCall [argwid] entry closure mem) 15956 // cond: 15957 // result: (CALLclosure [argwid] entry closure mem) 15958 for { 15959 argwid := v.AuxInt 15960 _ = v.Args[2] 15961 entry := v.Args[0] 15962 closure := v.Args[1] 15963 mem := v.Args[2] 15964 v.reset(OpARMCALLclosure) 15965 v.AuxInt = argwid 15966 v.AddArg(entry) 15967 v.AddArg(closure) 15968 v.AddArg(mem) 15969 return true 15970 } 15971 } 15972 func rewriteValueARM_OpCom16_0(v *Value) bool { 15973 // match: (Com16 x) 15974 // cond: 15975 // result: (MVN x) 15976 for { 15977 x := v.Args[0] 15978 v.reset(OpARMMVN) 15979 v.AddArg(x) 15980 return true 15981 } 15982 } 15983 func rewriteValueARM_OpCom32_0(v *Value) bool { 15984 // match: (Com32 x) 15985 // cond: 15986 // result: (MVN x) 15987 for { 15988 x := v.Args[0] 15989 v.reset(OpARMMVN) 15990 v.AddArg(x) 15991 return true 15992 } 15993 } 15994 func rewriteValueARM_OpCom8_0(v *Value) bool { 15995 // match: (Com8 x) 15996 // cond: 15997 // result: (MVN x) 15998 for { 15999 x := v.Args[0] 16000 v.reset(OpARMMVN) 16001 v.AddArg(x) 16002 return true 16003 } 16004 } 16005 func rewriteValueARM_OpConst16_0(v *Value) bool { 16006 // match: (Const16 [val]) 16007 // cond: 16008 // result: (MOVWconst [val]) 16009 for { 16010 val := v.AuxInt 16011 v.reset(OpARMMOVWconst) 16012 v.AuxInt = val 16013 return true 16014 } 16015 } 16016 func rewriteValueARM_OpConst32_0(v *Value) bool { 16017 // match: (Const32 [val]) 16018 // cond: 16019 // result: (MOVWconst [val]) 16020 for { 16021 val := v.AuxInt 16022 v.reset(OpARMMOVWconst) 16023 v.AuxInt = val 16024 return true 16025 } 16026 } 16027 func rewriteValueARM_OpConst32F_0(v *Value) bool { 16028 // match: (Const32F [val]) 16029 // cond: 16030 // result: (MOVFconst [val]) 16031 for { 16032 val := v.AuxInt 16033 v.reset(OpARMMOVFconst) 16034 v.AuxInt = val 16035 return true 16036 } 16037 } 16038 func rewriteValueARM_OpConst64F_0(v *Value) bool { 16039 // match: (Const64F [val]) 16040 // cond: 16041 // result: (MOVDconst [val]) 16042 for { 16043 val := v.AuxInt 16044 v.reset(OpARMMOVDconst) 16045 v.AuxInt = val 16046 return true 16047 } 16048 } 16049 func rewriteValueARM_OpConst8_0(v *Value) bool { 16050 // match: (Const8 [val]) 16051 // cond: 16052 // result: (MOVWconst [val]) 16053 for { 16054 val := v.AuxInt 16055 v.reset(OpARMMOVWconst) 16056 v.AuxInt = val 16057 return true 16058 } 16059 } 16060 func rewriteValueARM_OpConstBool_0(v *Value) bool { 16061 // match: (ConstBool [b]) 16062 // cond: 16063 // result: (MOVWconst [b]) 16064 for { 16065 b := v.AuxInt 16066 v.reset(OpARMMOVWconst) 16067 v.AuxInt = b 16068 return true 16069 } 16070 } 16071 func rewriteValueARM_OpConstNil_0(v *Value) bool { 16072 // match: (ConstNil) 16073 // cond: 16074 // result: (MOVWconst [0]) 16075 for { 16076 v.reset(OpARMMOVWconst) 16077 v.AuxInt = 0 16078 return true 16079 } 16080 } 16081 func rewriteValueARM_OpConvert_0(v *Value) bool { 16082 // match: (Convert x mem) 16083 // cond: 16084 // result: (MOVWconvert x mem) 16085 for { 16086 _ = v.Args[1] 16087 x := v.Args[0] 16088 mem := v.Args[1] 16089 v.reset(OpARMMOVWconvert) 16090 v.AddArg(x) 16091 v.AddArg(mem) 16092 return true 16093 } 16094 } 16095 func rewriteValueARM_OpCtz32_0(v *Value) bool { 16096 b := v.Block 16097 _ = b 16098 // match: (Ctz32 <t> x) 16099 // cond: objabi.GOARM<=6 16100 // result: (RSBconst [32] (CLZ <t> (SUBconst <t> (AND <t> x (RSBconst <t> [0] x)) [1]))) 16101 for { 16102 t := v.Type 16103 x := v.Args[0] 16104 if !(objabi.GOARM <= 6) { 16105 break 16106 } 16107 v.reset(OpARMRSBconst) 16108 v.AuxInt = 32 16109 v0 := b.NewValue0(v.Pos, OpARMCLZ, t) 16110 v1 := b.NewValue0(v.Pos, OpARMSUBconst, t) 16111 v1.AuxInt = 1 16112 v2 := b.NewValue0(v.Pos, OpARMAND, t) 16113 v2.AddArg(x) 16114 v3 := b.NewValue0(v.Pos, OpARMRSBconst, t) 16115 v3.AuxInt = 0 16116 v3.AddArg(x) 16117 v2.AddArg(v3) 16118 v1.AddArg(v2) 16119 v0.AddArg(v1) 16120 v.AddArg(v0) 16121 return true 16122 } 16123 // match: (Ctz32 <t> x) 16124 // cond: objabi.GOARM==7 16125 // result: (CLZ <t> (RBIT <t> x)) 16126 for { 16127 t := v.Type 16128 x := v.Args[0] 16129 if !(objabi.GOARM == 7) { 16130 break 16131 } 16132 v.reset(OpARMCLZ) 16133 v.Type = t 16134 v0 := b.NewValue0(v.Pos, OpARMRBIT, t) 16135 v0.AddArg(x) 16136 v.AddArg(v0) 16137 return true 16138 } 16139 return false 16140 } 16141 func rewriteValueARM_OpCvt32Fto32_0(v *Value) bool { 16142 // match: (Cvt32Fto32 x) 16143 // cond: 16144 // result: (MOVFW x) 16145 for { 16146 x := v.Args[0] 16147 v.reset(OpARMMOVFW) 16148 v.AddArg(x) 16149 return true 16150 } 16151 } 16152 func rewriteValueARM_OpCvt32Fto32U_0(v *Value) bool { 16153 // match: (Cvt32Fto32U x) 16154 // cond: 16155 // result: (MOVFWU x) 16156 for { 16157 x := v.Args[0] 16158 v.reset(OpARMMOVFWU) 16159 v.AddArg(x) 16160 return true 16161 } 16162 } 16163 func rewriteValueARM_OpCvt32Fto64F_0(v *Value) bool { 16164 // match: (Cvt32Fto64F x) 16165 // cond: 16166 // result: (MOVFD x) 16167 for { 16168 x := v.Args[0] 16169 v.reset(OpARMMOVFD) 16170 v.AddArg(x) 16171 return true 16172 } 16173 } 16174 func rewriteValueARM_OpCvt32Uto32F_0(v *Value) bool { 16175 // match: (Cvt32Uto32F x) 16176 // cond: 16177 // result: (MOVWUF x) 16178 for { 16179 x := v.Args[0] 16180 v.reset(OpARMMOVWUF) 16181 v.AddArg(x) 16182 return true 16183 } 16184 } 16185 func rewriteValueARM_OpCvt32Uto64F_0(v *Value) bool { 16186 // match: (Cvt32Uto64F x) 16187 // cond: 16188 // result: (MOVWUD x) 16189 for { 16190 x := v.Args[0] 16191 v.reset(OpARMMOVWUD) 16192 v.AddArg(x) 16193 return true 16194 } 16195 } 16196 func rewriteValueARM_OpCvt32to32F_0(v *Value) bool { 16197 // match: (Cvt32to32F x) 16198 // cond: 16199 // result: (MOVWF x) 16200 for { 16201 x := v.Args[0] 16202 v.reset(OpARMMOVWF) 16203 v.AddArg(x) 16204 return true 16205 } 16206 } 16207 func rewriteValueARM_OpCvt32to64F_0(v *Value) bool { 16208 // match: (Cvt32to64F x) 16209 // cond: 16210 // result: (MOVWD x) 16211 for { 16212 x := v.Args[0] 16213 v.reset(OpARMMOVWD) 16214 v.AddArg(x) 16215 return true 16216 } 16217 } 16218 func rewriteValueARM_OpCvt64Fto32_0(v *Value) bool { 16219 // match: (Cvt64Fto32 x) 16220 // cond: 16221 // result: (MOVDW x) 16222 for { 16223 x := v.Args[0] 16224 v.reset(OpARMMOVDW) 16225 v.AddArg(x) 16226 return true 16227 } 16228 } 16229 func rewriteValueARM_OpCvt64Fto32F_0(v *Value) bool { 16230 // match: (Cvt64Fto32F x) 16231 // cond: 16232 // result: (MOVDF x) 16233 for { 16234 x := v.Args[0] 16235 v.reset(OpARMMOVDF) 16236 v.AddArg(x) 16237 return true 16238 } 16239 } 16240 func rewriteValueARM_OpCvt64Fto32U_0(v *Value) bool { 16241 // match: (Cvt64Fto32U x) 16242 // cond: 16243 // result: (MOVDWU x) 16244 for { 16245 x := v.Args[0] 16246 v.reset(OpARMMOVDWU) 16247 v.AddArg(x) 16248 return true 16249 } 16250 } 16251 func rewriteValueARM_OpDiv16_0(v *Value) bool { 16252 b := v.Block 16253 _ = b 16254 typ := &b.Func.Config.Types 16255 _ = typ 16256 // match: (Div16 x y) 16257 // cond: 16258 // result: (Div32 (SignExt16to32 x) (SignExt16to32 y)) 16259 for { 16260 _ = v.Args[1] 16261 x := v.Args[0] 16262 y := v.Args[1] 16263 v.reset(OpDiv32) 16264 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 16265 v0.AddArg(x) 16266 v.AddArg(v0) 16267 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 16268 v1.AddArg(y) 16269 v.AddArg(v1) 16270 return true 16271 } 16272 } 16273 func rewriteValueARM_OpDiv16u_0(v *Value) bool { 16274 b := v.Block 16275 _ = b 16276 typ := &b.Func.Config.Types 16277 _ = typ 16278 // match: (Div16u x y) 16279 // cond: 16280 // result: (Div32u (ZeroExt16to32 x) (ZeroExt16to32 y)) 16281 for { 16282 _ = v.Args[1] 16283 x := v.Args[0] 16284 y := v.Args[1] 16285 v.reset(OpDiv32u) 16286 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 16287 v0.AddArg(x) 16288 v.AddArg(v0) 16289 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 16290 v1.AddArg(y) 16291 v.AddArg(v1) 16292 return true 16293 } 16294 } 16295 func rewriteValueARM_OpDiv32_0(v *Value) bool { 16296 b := v.Block 16297 _ = b 16298 typ := &b.Func.Config.Types 16299 _ = typ 16300 // match: (Div32 x y) 16301 // cond: 16302 // result: (SUB (XOR <typ.UInt32> (Select0 <typ.UInt32> (CALLudiv (SUB <typ.UInt32> (XOR x <typ.UInt32> (Signmask x)) (Signmask x)) (SUB <typ.UInt32> (XOR y <typ.UInt32> (Signmask y)) (Signmask y)))) (Signmask (XOR <typ.UInt32> x y))) (Signmask (XOR <typ.UInt32> x y))) 16303 for { 16304 _ = v.Args[1] 16305 x := v.Args[0] 16306 y := v.Args[1] 16307 v.reset(OpARMSUB) 16308 v0 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32) 16309 v1 := b.NewValue0(v.Pos, OpSelect0, typ.UInt32) 16310 v2 := b.NewValue0(v.Pos, OpARMCALLudiv, types.NewTuple(typ.UInt32, typ.UInt32)) 16311 v3 := b.NewValue0(v.Pos, OpARMSUB, typ.UInt32) 16312 v4 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32) 16313 v4.AddArg(x) 16314 v5 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 16315 v5.AddArg(x) 16316 v4.AddArg(v5) 16317 v3.AddArg(v4) 16318 v6 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 16319 v6.AddArg(x) 16320 v3.AddArg(v6) 16321 v2.AddArg(v3) 16322 v7 := b.NewValue0(v.Pos, OpARMSUB, typ.UInt32) 16323 v8 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32) 16324 v8.AddArg(y) 16325 v9 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 16326 v9.AddArg(y) 16327 v8.AddArg(v9) 16328 v7.AddArg(v8) 16329 v10 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 16330 v10.AddArg(y) 16331 v7.AddArg(v10) 16332 v2.AddArg(v7) 16333 v1.AddArg(v2) 16334 v0.AddArg(v1) 16335 v11 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 16336 v12 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32) 16337 v12.AddArg(x) 16338 v12.AddArg(y) 16339 v11.AddArg(v12) 16340 v0.AddArg(v11) 16341 v.AddArg(v0) 16342 v13 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 16343 v14 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32) 16344 v14.AddArg(x) 16345 v14.AddArg(y) 16346 v13.AddArg(v14) 16347 v.AddArg(v13) 16348 return true 16349 } 16350 } 16351 func rewriteValueARM_OpDiv32F_0(v *Value) bool { 16352 // match: (Div32F x y) 16353 // cond: 16354 // result: (DIVF x y) 16355 for { 16356 _ = v.Args[1] 16357 x := v.Args[0] 16358 y := v.Args[1] 16359 v.reset(OpARMDIVF) 16360 v.AddArg(x) 16361 v.AddArg(y) 16362 return true 16363 } 16364 } 16365 func rewriteValueARM_OpDiv32u_0(v *Value) bool { 16366 b := v.Block 16367 _ = b 16368 typ := &b.Func.Config.Types 16369 _ = typ 16370 // match: (Div32u x y) 16371 // cond: 16372 // result: (Select0 <typ.UInt32> (CALLudiv x y)) 16373 for { 16374 _ = v.Args[1] 16375 x := v.Args[0] 16376 y := v.Args[1] 16377 v.reset(OpSelect0) 16378 v.Type = typ.UInt32 16379 v0 := b.NewValue0(v.Pos, OpARMCALLudiv, types.NewTuple(typ.UInt32, typ.UInt32)) 16380 v0.AddArg(x) 16381 v0.AddArg(y) 16382 v.AddArg(v0) 16383 return true 16384 } 16385 } 16386 func rewriteValueARM_OpDiv64F_0(v *Value) bool { 16387 // match: (Div64F x y) 16388 // cond: 16389 // result: (DIVD x y) 16390 for { 16391 _ = v.Args[1] 16392 x := v.Args[0] 16393 y := v.Args[1] 16394 v.reset(OpARMDIVD) 16395 v.AddArg(x) 16396 v.AddArg(y) 16397 return true 16398 } 16399 } 16400 func rewriteValueARM_OpDiv8_0(v *Value) bool { 16401 b := v.Block 16402 _ = b 16403 typ := &b.Func.Config.Types 16404 _ = typ 16405 // match: (Div8 x y) 16406 // cond: 16407 // result: (Div32 (SignExt8to32 x) (SignExt8to32 y)) 16408 for { 16409 _ = v.Args[1] 16410 x := v.Args[0] 16411 y := v.Args[1] 16412 v.reset(OpDiv32) 16413 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 16414 v0.AddArg(x) 16415 v.AddArg(v0) 16416 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 16417 v1.AddArg(y) 16418 v.AddArg(v1) 16419 return true 16420 } 16421 } 16422 func rewriteValueARM_OpDiv8u_0(v *Value) bool { 16423 b := v.Block 16424 _ = b 16425 typ := &b.Func.Config.Types 16426 _ = typ 16427 // match: (Div8u x y) 16428 // cond: 16429 // result: (Div32u (ZeroExt8to32 x) (ZeroExt8to32 y)) 16430 for { 16431 _ = v.Args[1] 16432 x := v.Args[0] 16433 y := v.Args[1] 16434 v.reset(OpDiv32u) 16435 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 16436 v0.AddArg(x) 16437 v.AddArg(v0) 16438 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 16439 v1.AddArg(y) 16440 v.AddArg(v1) 16441 return true 16442 } 16443 } 16444 func rewriteValueARM_OpEq16_0(v *Value) bool { 16445 b := v.Block 16446 _ = b 16447 typ := &b.Func.Config.Types 16448 _ = typ 16449 // match: (Eq16 x y) 16450 // cond: 16451 // result: (Equal (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 16452 for { 16453 _ = v.Args[1] 16454 x := v.Args[0] 16455 y := v.Args[1] 16456 v.reset(OpARMEqual) 16457 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16458 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 16459 v1.AddArg(x) 16460 v0.AddArg(v1) 16461 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 16462 v2.AddArg(y) 16463 v0.AddArg(v2) 16464 v.AddArg(v0) 16465 return true 16466 } 16467 } 16468 func rewriteValueARM_OpEq32_0(v *Value) bool { 16469 b := v.Block 16470 _ = b 16471 // match: (Eq32 x y) 16472 // cond: 16473 // result: (Equal (CMP x y)) 16474 for { 16475 _ = v.Args[1] 16476 x := v.Args[0] 16477 y := v.Args[1] 16478 v.reset(OpARMEqual) 16479 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16480 v0.AddArg(x) 16481 v0.AddArg(y) 16482 v.AddArg(v0) 16483 return true 16484 } 16485 } 16486 func rewriteValueARM_OpEq32F_0(v *Value) bool { 16487 b := v.Block 16488 _ = b 16489 // match: (Eq32F x y) 16490 // cond: 16491 // result: (Equal (CMPF x y)) 16492 for { 16493 _ = v.Args[1] 16494 x := v.Args[0] 16495 y := v.Args[1] 16496 v.reset(OpARMEqual) 16497 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags) 16498 v0.AddArg(x) 16499 v0.AddArg(y) 16500 v.AddArg(v0) 16501 return true 16502 } 16503 } 16504 func rewriteValueARM_OpEq64F_0(v *Value) bool { 16505 b := v.Block 16506 _ = b 16507 // match: (Eq64F x y) 16508 // cond: 16509 // result: (Equal (CMPD x y)) 16510 for { 16511 _ = v.Args[1] 16512 x := v.Args[0] 16513 y := v.Args[1] 16514 v.reset(OpARMEqual) 16515 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags) 16516 v0.AddArg(x) 16517 v0.AddArg(y) 16518 v.AddArg(v0) 16519 return true 16520 } 16521 } 16522 func rewriteValueARM_OpEq8_0(v *Value) bool { 16523 b := v.Block 16524 _ = b 16525 typ := &b.Func.Config.Types 16526 _ = typ 16527 // match: (Eq8 x y) 16528 // cond: 16529 // result: (Equal (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 16530 for { 16531 _ = v.Args[1] 16532 x := v.Args[0] 16533 y := v.Args[1] 16534 v.reset(OpARMEqual) 16535 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16536 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 16537 v1.AddArg(x) 16538 v0.AddArg(v1) 16539 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 16540 v2.AddArg(y) 16541 v0.AddArg(v2) 16542 v.AddArg(v0) 16543 return true 16544 } 16545 } 16546 func rewriteValueARM_OpEqB_0(v *Value) bool { 16547 b := v.Block 16548 _ = b 16549 typ := &b.Func.Config.Types 16550 _ = typ 16551 // match: (EqB x y) 16552 // cond: 16553 // result: (XORconst [1] (XOR <typ.Bool> x y)) 16554 for { 16555 _ = v.Args[1] 16556 x := v.Args[0] 16557 y := v.Args[1] 16558 v.reset(OpARMXORconst) 16559 v.AuxInt = 1 16560 v0 := b.NewValue0(v.Pos, OpARMXOR, typ.Bool) 16561 v0.AddArg(x) 16562 v0.AddArg(y) 16563 v.AddArg(v0) 16564 return true 16565 } 16566 } 16567 func rewriteValueARM_OpEqPtr_0(v *Value) bool { 16568 b := v.Block 16569 _ = b 16570 // match: (EqPtr x y) 16571 // cond: 16572 // result: (Equal (CMP x y)) 16573 for { 16574 _ = v.Args[1] 16575 x := v.Args[0] 16576 y := v.Args[1] 16577 v.reset(OpARMEqual) 16578 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16579 v0.AddArg(x) 16580 v0.AddArg(y) 16581 v.AddArg(v0) 16582 return true 16583 } 16584 } 16585 func rewriteValueARM_OpGeq16_0(v *Value) bool { 16586 b := v.Block 16587 _ = b 16588 typ := &b.Func.Config.Types 16589 _ = typ 16590 // match: (Geq16 x y) 16591 // cond: 16592 // result: (GreaterEqual (CMP (SignExt16to32 x) (SignExt16to32 y))) 16593 for { 16594 _ = v.Args[1] 16595 x := v.Args[0] 16596 y := v.Args[1] 16597 v.reset(OpARMGreaterEqual) 16598 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16599 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 16600 v1.AddArg(x) 16601 v0.AddArg(v1) 16602 v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 16603 v2.AddArg(y) 16604 v0.AddArg(v2) 16605 v.AddArg(v0) 16606 return true 16607 } 16608 } 16609 func rewriteValueARM_OpGeq16U_0(v *Value) bool { 16610 b := v.Block 16611 _ = b 16612 typ := &b.Func.Config.Types 16613 _ = typ 16614 // match: (Geq16U x y) 16615 // cond: 16616 // result: (GreaterEqualU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 16617 for { 16618 _ = v.Args[1] 16619 x := v.Args[0] 16620 y := v.Args[1] 16621 v.reset(OpARMGreaterEqualU) 16622 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16623 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 16624 v1.AddArg(x) 16625 v0.AddArg(v1) 16626 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 16627 v2.AddArg(y) 16628 v0.AddArg(v2) 16629 v.AddArg(v0) 16630 return true 16631 } 16632 } 16633 func rewriteValueARM_OpGeq32_0(v *Value) bool { 16634 b := v.Block 16635 _ = b 16636 // match: (Geq32 x y) 16637 // cond: 16638 // result: (GreaterEqual (CMP x y)) 16639 for { 16640 _ = v.Args[1] 16641 x := v.Args[0] 16642 y := v.Args[1] 16643 v.reset(OpARMGreaterEqual) 16644 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16645 v0.AddArg(x) 16646 v0.AddArg(y) 16647 v.AddArg(v0) 16648 return true 16649 } 16650 } 16651 func rewriteValueARM_OpGeq32F_0(v *Value) bool { 16652 b := v.Block 16653 _ = b 16654 // match: (Geq32F x y) 16655 // cond: 16656 // result: (GreaterEqual (CMPF x y)) 16657 for { 16658 _ = v.Args[1] 16659 x := v.Args[0] 16660 y := v.Args[1] 16661 v.reset(OpARMGreaterEqual) 16662 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags) 16663 v0.AddArg(x) 16664 v0.AddArg(y) 16665 v.AddArg(v0) 16666 return true 16667 } 16668 } 16669 func rewriteValueARM_OpGeq32U_0(v *Value) bool { 16670 b := v.Block 16671 _ = b 16672 // match: (Geq32U x y) 16673 // cond: 16674 // result: (GreaterEqualU (CMP x y)) 16675 for { 16676 _ = v.Args[1] 16677 x := v.Args[0] 16678 y := v.Args[1] 16679 v.reset(OpARMGreaterEqualU) 16680 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16681 v0.AddArg(x) 16682 v0.AddArg(y) 16683 v.AddArg(v0) 16684 return true 16685 } 16686 } 16687 func rewriteValueARM_OpGeq64F_0(v *Value) bool { 16688 b := v.Block 16689 _ = b 16690 // match: (Geq64F x y) 16691 // cond: 16692 // result: (GreaterEqual (CMPD x y)) 16693 for { 16694 _ = v.Args[1] 16695 x := v.Args[0] 16696 y := v.Args[1] 16697 v.reset(OpARMGreaterEqual) 16698 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags) 16699 v0.AddArg(x) 16700 v0.AddArg(y) 16701 v.AddArg(v0) 16702 return true 16703 } 16704 } 16705 func rewriteValueARM_OpGeq8_0(v *Value) bool { 16706 b := v.Block 16707 _ = b 16708 typ := &b.Func.Config.Types 16709 _ = typ 16710 // match: (Geq8 x y) 16711 // cond: 16712 // result: (GreaterEqual (CMP (SignExt8to32 x) (SignExt8to32 y))) 16713 for { 16714 _ = v.Args[1] 16715 x := v.Args[0] 16716 y := v.Args[1] 16717 v.reset(OpARMGreaterEqual) 16718 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16719 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 16720 v1.AddArg(x) 16721 v0.AddArg(v1) 16722 v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 16723 v2.AddArg(y) 16724 v0.AddArg(v2) 16725 v.AddArg(v0) 16726 return true 16727 } 16728 } 16729 func rewriteValueARM_OpGeq8U_0(v *Value) bool { 16730 b := v.Block 16731 _ = b 16732 typ := &b.Func.Config.Types 16733 _ = typ 16734 // match: (Geq8U x y) 16735 // cond: 16736 // result: (GreaterEqualU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 16737 for { 16738 _ = v.Args[1] 16739 x := v.Args[0] 16740 y := v.Args[1] 16741 v.reset(OpARMGreaterEqualU) 16742 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16743 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 16744 v1.AddArg(x) 16745 v0.AddArg(v1) 16746 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 16747 v2.AddArg(y) 16748 v0.AddArg(v2) 16749 v.AddArg(v0) 16750 return true 16751 } 16752 } 16753 func rewriteValueARM_OpGetCallerSP_0(v *Value) bool { 16754 // match: (GetCallerSP) 16755 // cond: 16756 // result: (LoweredGetCallerSP) 16757 for { 16758 v.reset(OpARMLoweredGetCallerSP) 16759 return true 16760 } 16761 } 16762 func rewriteValueARM_OpGetClosurePtr_0(v *Value) bool { 16763 // match: (GetClosurePtr) 16764 // cond: 16765 // result: (LoweredGetClosurePtr) 16766 for { 16767 v.reset(OpARMLoweredGetClosurePtr) 16768 return true 16769 } 16770 } 16771 func rewriteValueARM_OpGreater16_0(v *Value) bool { 16772 b := v.Block 16773 _ = b 16774 typ := &b.Func.Config.Types 16775 _ = typ 16776 // match: (Greater16 x y) 16777 // cond: 16778 // result: (GreaterThan (CMP (SignExt16to32 x) (SignExt16to32 y))) 16779 for { 16780 _ = v.Args[1] 16781 x := v.Args[0] 16782 y := v.Args[1] 16783 v.reset(OpARMGreaterThan) 16784 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16785 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 16786 v1.AddArg(x) 16787 v0.AddArg(v1) 16788 v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 16789 v2.AddArg(y) 16790 v0.AddArg(v2) 16791 v.AddArg(v0) 16792 return true 16793 } 16794 } 16795 func rewriteValueARM_OpGreater16U_0(v *Value) bool { 16796 b := v.Block 16797 _ = b 16798 typ := &b.Func.Config.Types 16799 _ = typ 16800 // match: (Greater16U x y) 16801 // cond: 16802 // result: (GreaterThanU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 16803 for { 16804 _ = v.Args[1] 16805 x := v.Args[0] 16806 y := v.Args[1] 16807 v.reset(OpARMGreaterThanU) 16808 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16809 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 16810 v1.AddArg(x) 16811 v0.AddArg(v1) 16812 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 16813 v2.AddArg(y) 16814 v0.AddArg(v2) 16815 v.AddArg(v0) 16816 return true 16817 } 16818 } 16819 func rewriteValueARM_OpGreater32_0(v *Value) bool { 16820 b := v.Block 16821 _ = b 16822 // match: (Greater32 x y) 16823 // cond: 16824 // result: (GreaterThan (CMP x y)) 16825 for { 16826 _ = v.Args[1] 16827 x := v.Args[0] 16828 y := v.Args[1] 16829 v.reset(OpARMGreaterThan) 16830 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16831 v0.AddArg(x) 16832 v0.AddArg(y) 16833 v.AddArg(v0) 16834 return true 16835 } 16836 } 16837 func rewriteValueARM_OpGreater32F_0(v *Value) bool { 16838 b := v.Block 16839 _ = b 16840 // match: (Greater32F x y) 16841 // cond: 16842 // result: (GreaterThan (CMPF x y)) 16843 for { 16844 _ = v.Args[1] 16845 x := v.Args[0] 16846 y := v.Args[1] 16847 v.reset(OpARMGreaterThan) 16848 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags) 16849 v0.AddArg(x) 16850 v0.AddArg(y) 16851 v.AddArg(v0) 16852 return true 16853 } 16854 } 16855 func rewriteValueARM_OpGreater32U_0(v *Value) bool { 16856 b := v.Block 16857 _ = b 16858 // match: (Greater32U x y) 16859 // cond: 16860 // result: (GreaterThanU (CMP x y)) 16861 for { 16862 _ = v.Args[1] 16863 x := v.Args[0] 16864 y := v.Args[1] 16865 v.reset(OpARMGreaterThanU) 16866 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16867 v0.AddArg(x) 16868 v0.AddArg(y) 16869 v.AddArg(v0) 16870 return true 16871 } 16872 } 16873 func rewriteValueARM_OpGreater64F_0(v *Value) bool { 16874 b := v.Block 16875 _ = b 16876 // match: (Greater64F x y) 16877 // cond: 16878 // result: (GreaterThan (CMPD x y)) 16879 for { 16880 _ = v.Args[1] 16881 x := v.Args[0] 16882 y := v.Args[1] 16883 v.reset(OpARMGreaterThan) 16884 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags) 16885 v0.AddArg(x) 16886 v0.AddArg(y) 16887 v.AddArg(v0) 16888 return true 16889 } 16890 } 16891 func rewriteValueARM_OpGreater8_0(v *Value) bool { 16892 b := v.Block 16893 _ = b 16894 typ := &b.Func.Config.Types 16895 _ = typ 16896 // match: (Greater8 x y) 16897 // cond: 16898 // result: (GreaterThan (CMP (SignExt8to32 x) (SignExt8to32 y))) 16899 for { 16900 _ = v.Args[1] 16901 x := v.Args[0] 16902 y := v.Args[1] 16903 v.reset(OpARMGreaterThan) 16904 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16905 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 16906 v1.AddArg(x) 16907 v0.AddArg(v1) 16908 v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 16909 v2.AddArg(y) 16910 v0.AddArg(v2) 16911 v.AddArg(v0) 16912 return true 16913 } 16914 } 16915 func rewriteValueARM_OpGreater8U_0(v *Value) bool { 16916 b := v.Block 16917 _ = b 16918 typ := &b.Func.Config.Types 16919 _ = typ 16920 // match: (Greater8U x y) 16921 // cond: 16922 // result: (GreaterThanU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 16923 for { 16924 _ = v.Args[1] 16925 x := v.Args[0] 16926 y := v.Args[1] 16927 v.reset(OpARMGreaterThanU) 16928 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16929 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 16930 v1.AddArg(x) 16931 v0.AddArg(v1) 16932 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 16933 v2.AddArg(y) 16934 v0.AddArg(v2) 16935 v.AddArg(v0) 16936 return true 16937 } 16938 } 16939 func rewriteValueARM_OpHmul32_0(v *Value) bool { 16940 // match: (Hmul32 x y) 16941 // cond: 16942 // result: (HMUL x y) 16943 for { 16944 _ = v.Args[1] 16945 x := v.Args[0] 16946 y := v.Args[1] 16947 v.reset(OpARMHMUL) 16948 v.AddArg(x) 16949 v.AddArg(y) 16950 return true 16951 } 16952 } 16953 func rewriteValueARM_OpHmul32u_0(v *Value) bool { 16954 // match: (Hmul32u x y) 16955 // cond: 16956 // result: (HMULU x y) 16957 for { 16958 _ = v.Args[1] 16959 x := v.Args[0] 16960 y := v.Args[1] 16961 v.reset(OpARMHMULU) 16962 v.AddArg(x) 16963 v.AddArg(y) 16964 return true 16965 } 16966 } 16967 func rewriteValueARM_OpInterCall_0(v *Value) bool { 16968 // match: (InterCall [argwid] entry mem) 16969 // cond: 16970 // result: (CALLinter [argwid] entry mem) 16971 for { 16972 argwid := v.AuxInt 16973 _ = v.Args[1] 16974 entry := v.Args[0] 16975 mem := v.Args[1] 16976 v.reset(OpARMCALLinter) 16977 v.AuxInt = argwid 16978 v.AddArg(entry) 16979 v.AddArg(mem) 16980 return true 16981 } 16982 } 16983 func rewriteValueARM_OpIsInBounds_0(v *Value) bool { 16984 b := v.Block 16985 _ = b 16986 // match: (IsInBounds idx len) 16987 // cond: 16988 // result: (LessThanU (CMP idx len)) 16989 for { 16990 _ = v.Args[1] 16991 idx := v.Args[0] 16992 len := v.Args[1] 16993 v.reset(OpARMLessThanU) 16994 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 16995 v0.AddArg(idx) 16996 v0.AddArg(len) 16997 v.AddArg(v0) 16998 return true 16999 } 17000 } 17001 func rewriteValueARM_OpIsNonNil_0(v *Value) bool { 17002 b := v.Block 17003 _ = b 17004 // match: (IsNonNil ptr) 17005 // cond: 17006 // result: (NotEqual (CMPconst [0] ptr)) 17007 for { 17008 ptr := v.Args[0] 17009 v.reset(OpARMNotEqual) 17010 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 17011 v0.AuxInt = 0 17012 v0.AddArg(ptr) 17013 v.AddArg(v0) 17014 return true 17015 } 17016 } 17017 func rewriteValueARM_OpIsSliceInBounds_0(v *Value) bool { 17018 b := v.Block 17019 _ = b 17020 // match: (IsSliceInBounds idx len) 17021 // cond: 17022 // result: (LessEqualU (CMP idx len)) 17023 for { 17024 _ = v.Args[1] 17025 idx := v.Args[0] 17026 len := v.Args[1] 17027 v.reset(OpARMLessEqualU) 17028 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 17029 v0.AddArg(idx) 17030 v0.AddArg(len) 17031 v.AddArg(v0) 17032 return true 17033 } 17034 } 17035 func rewriteValueARM_OpLeq16_0(v *Value) bool { 17036 b := v.Block 17037 _ = b 17038 typ := &b.Func.Config.Types 17039 _ = typ 17040 // match: (Leq16 x y) 17041 // cond: 17042 // result: (LessEqual (CMP (SignExt16to32 x) (SignExt16to32 y))) 17043 for { 17044 _ = v.Args[1] 17045 x := v.Args[0] 17046 y := v.Args[1] 17047 v.reset(OpARMLessEqual) 17048 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 17049 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 17050 v1.AddArg(x) 17051 v0.AddArg(v1) 17052 v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 17053 v2.AddArg(y) 17054 v0.AddArg(v2) 17055 v.AddArg(v0) 17056 return true 17057 } 17058 } 17059 func rewriteValueARM_OpLeq16U_0(v *Value) bool { 17060 b := v.Block 17061 _ = b 17062 typ := &b.Func.Config.Types 17063 _ = typ 17064 // match: (Leq16U x y) 17065 // cond: 17066 // result: (LessEqualU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 17067 for { 17068 _ = v.Args[1] 17069 x := v.Args[0] 17070 y := v.Args[1] 17071 v.reset(OpARMLessEqualU) 17072 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 17073 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 17074 v1.AddArg(x) 17075 v0.AddArg(v1) 17076 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 17077 v2.AddArg(y) 17078 v0.AddArg(v2) 17079 v.AddArg(v0) 17080 return true 17081 } 17082 } 17083 func rewriteValueARM_OpLeq32_0(v *Value) bool { 17084 b := v.Block 17085 _ = b 17086 // match: (Leq32 x y) 17087 // cond: 17088 // result: (LessEqual (CMP x y)) 17089 for { 17090 _ = v.Args[1] 17091 x := v.Args[0] 17092 y := v.Args[1] 17093 v.reset(OpARMLessEqual) 17094 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 17095 v0.AddArg(x) 17096 v0.AddArg(y) 17097 v.AddArg(v0) 17098 return true 17099 } 17100 } 17101 func rewriteValueARM_OpLeq32F_0(v *Value) bool { 17102 b := v.Block 17103 _ = b 17104 // match: (Leq32F x y) 17105 // cond: 17106 // result: (GreaterEqual (CMPF y x)) 17107 for { 17108 _ = v.Args[1] 17109 x := v.Args[0] 17110 y := v.Args[1] 17111 v.reset(OpARMGreaterEqual) 17112 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags) 17113 v0.AddArg(y) 17114 v0.AddArg(x) 17115 v.AddArg(v0) 17116 return true 17117 } 17118 } 17119 func rewriteValueARM_OpLeq32U_0(v *Value) bool { 17120 b := v.Block 17121 _ = b 17122 // match: (Leq32U x y) 17123 // cond: 17124 // result: (LessEqualU (CMP x y)) 17125 for { 17126 _ = v.Args[1] 17127 x := v.Args[0] 17128 y := v.Args[1] 17129 v.reset(OpARMLessEqualU) 17130 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 17131 v0.AddArg(x) 17132 v0.AddArg(y) 17133 v.AddArg(v0) 17134 return true 17135 } 17136 } 17137 func rewriteValueARM_OpLeq64F_0(v *Value) bool { 17138 b := v.Block 17139 _ = b 17140 // match: (Leq64F x y) 17141 // cond: 17142 // result: (GreaterEqual (CMPD y x)) 17143 for { 17144 _ = v.Args[1] 17145 x := v.Args[0] 17146 y := v.Args[1] 17147 v.reset(OpARMGreaterEqual) 17148 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags) 17149 v0.AddArg(y) 17150 v0.AddArg(x) 17151 v.AddArg(v0) 17152 return true 17153 } 17154 } 17155 func rewriteValueARM_OpLeq8_0(v *Value) bool { 17156 b := v.Block 17157 _ = b 17158 typ := &b.Func.Config.Types 17159 _ = typ 17160 // match: (Leq8 x y) 17161 // cond: 17162 // result: (LessEqual (CMP (SignExt8to32 x) (SignExt8to32 y))) 17163 for { 17164 _ = v.Args[1] 17165 x := v.Args[0] 17166 y := v.Args[1] 17167 v.reset(OpARMLessEqual) 17168 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 17169 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 17170 v1.AddArg(x) 17171 v0.AddArg(v1) 17172 v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 17173 v2.AddArg(y) 17174 v0.AddArg(v2) 17175 v.AddArg(v0) 17176 return true 17177 } 17178 } 17179 func rewriteValueARM_OpLeq8U_0(v *Value) bool { 17180 b := v.Block 17181 _ = b 17182 typ := &b.Func.Config.Types 17183 _ = typ 17184 // match: (Leq8U x y) 17185 // cond: 17186 // result: (LessEqualU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 17187 for { 17188 _ = v.Args[1] 17189 x := v.Args[0] 17190 y := v.Args[1] 17191 v.reset(OpARMLessEqualU) 17192 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 17193 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 17194 v1.AddArg(x) 17195 v0.AddArg(v1) 17196 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 17197 v2.AddArg(y) 17198 v0.AddArg(v2) 17199 v.AddArg(v0) 17200 return true 17201 } 17202 } 17203 func rewriteValueARM_OpLess16_0(v *Value) bool { 17204 b := v.Block 17205 _ = b 17206 typ := &b.Func.Config.Types 17207 _ = typ 17208 // match: (Less16 x y) 17209 // cond: 17210 // result: (LessThan (CMP (SignExt16to32 x) (SignExt16to32 y))) 17211 for { 17212 _ = v.Args[1] 17213 x := v.Args[0] 17214 y := v.Args[1] 17215 v.reset(OpARMLessThan) 17216 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 17217 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 17218 v1.AddArg(x) 17219 v0.AddArg(v1) 17220 v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 17221 v2.AddArg(y) 17222 v0.AddArg(v2) 17223 v.AddArg(v0) 17224 return true 17225 } 17226 } 17227 func rewriteValueARM_OpLess16U_0(v *Value) bool { 17228 b := v.Block 17229 _ = b 17230 typ := &b.Func.Config.Types 17231 _ = typ 17232 // match: (Less16U x y) 17233 // cond: 17234 // result: (LessThanU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 17235 for { 17236 _ = v.Args[1] 17237 x := v.Args[0] 17238 y := v.Args[1] 17239 v.reset(OpARMLessThanU) 17240 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 17241 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 17242 v1.AddArg(x) 17243 v0.AddArg(v1) 17244 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 17245 v2.AddArg(y) 17246 v0.AddArg(v2) 17247 v.AddArg(v0) 17248 return true 17249 } 17250 } 17251 func rewriteValueARM_OpLess32_0(v *Value) bool { 17252 b := v.Block 17253 _ = b 17254 // match: (Less32 x y) 17255 // cond: 17256 // result: (LessThan (CMP x y)) 17257 for { 17258 _ = v.Args[1] 17259 x := v.Args[0] 17260 y := v.Args[1] 17261 v.reset(OpARMLessThan) 17262 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 17263 v0.AddArg(x) 17264 v0.AddArg(y) 17265 v.AddArg(v0) 17266 return true 17267 } 17268 } 17269 func rewriteValueARM_OpLess32F_0(v *Value) bool { 17270 b := v.Block 17271 _ = b 17272 // match: (Less32F x y) 17273 // cond: 17274 // result: (GreaterThan (CMPF y x)) 17275 for { 17276 _ = v.Args[1] 17277 x := v.Args[0] 17278 y := v.Args[1] 17279 v.reset(OpARMGreaterThan) 17280 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags) 17281 v0.AddArg(y) 17282 v0.AddArg(x) 17283 v.AddArg(v0) 17284 return true 17285 } 17286 } 17287 func rewriteValueARM_OpLess32U_0(v *Value) bool { 17288 b := v.Block 17289 _ = b 17290 // match: (Less32U x y) 17291 // cond: 17292 // result: (LessThanU (CMP x y)) 17293 for { 17294 _ = v.Args[1] 17295 x := v.Args[0] 17296 y := v.Args[1] 17297 v.reset(OpARMLessThanU) 17298 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 17299 v0.AddArg(x) 17300 v0.AddArg(y) 17301 v.AddArg(v0) 17302 return true 17303 } 17304 } 17305 func rewriteValueARM_OpLess64F_0(v *Value) bool { 17306 b := v.Block 17307 _ = b 17308 // match: (Less64F x y) 17309 // cond: 17310 // result: (GreaterThan (CMPD y x)) 17311 for { 17312 _ = v.Args[1] 17313 x := v.Args[0] 17314 y := v.Args[1] 17315 v.reset(OpARMGreaterThan) 17316 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags) 17317 v0.AddArg(y) 17318 v0.AddArg(x) 17319 v.AddArg(v0) 17320 return true 17321 } 17322 } 17323 func rewriteValueARM_OpLess8_0(v *Value) bool { 17324 b := v.Block 17325 _ = b 17326 typ := &b.Func.Config.Types 17327 _ = typ 17328 // match: (Less8 x y) 17329 // cond: 17330 // result: (LessThan (CMP (SignExt8to32 x) (SignExt8to32 y))) 17331 for { 17332 _ = v.Args[1] 17333 x := v.Args[0] 17334 y := v.Args[1] 17335 v.reset(OpARMLessThan) 17336 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 17337 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 17338 v1.AddArg(x) 17339 v0.AddArg(v1) 17340 v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 17341 v2.AddArg(y) 17342 v0.AddArg(v2) 17343 v.AddArg(v0) 17344 return true 17345 } 17346 } 17347 func rewriteValueARM_OpLess8U_0(v *Value) bool { 17348 b := v.Block 17349 _ = b 17350 typ := &b.Func.Config.Types 17351 _ = typ 17352 // match: (Less8U x y) 17353 // cond: 17354 // result: (LessThanU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 17355 for { 17356 _ = v.Args[1] 17357 x := v.Args[0] 17358 y := v.Args[1] 17359 v.reset(OpARMLessThanU) 17360 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 17361 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 17362 v1.AddArg(x) 17363 v0.AddArg(v1) 17364 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 17365 v2.AddArg(y) 17366 v0.AddArg(v2) 17367 v.AddArg(v0) 17368 return true 17369 } 17370 } 17371 func rewriteValueARM_OpLoad_0(v *Value) bool { 17372 // match: (Load <t> ptr mem) 17373 // cond: t.IsBoolean() 17374 // result: (MOVBUload ptr mem) 17375 for { 17376 t := v.Type 17377 _ = v.Args[1] 17378 ptr := v.Args[0] 17379 mem := v.Args[1] 17380 if !(t.IsBoolean()) { 17381 break 17382 } 17383 v.reset(OpARMMOVBUload) 17384 v.AddArg(ptr) 17385 v.AddArg(mem) 17386 return true 17387 } 17388 // match: (Load <t> ptr mem) 17389 // cond: (is8BitInt(t) && isSigned(t)) 17390 // result: (MOVBload ptr mem) 17391 for { 17392 t := v.Type 17393 _ = v.Args[1] 17394 ptr := v.Args[0] 17395 mem := v.Args[1] 17396 if !(is8BitInt(t) && isSigned(t)) { 17397 break 17398 } 17399 v.reset(OpARMMOVBload) 17400 v.AddArg(ptr) 17401 v.AddArg(mem) 17402 return true 17403 } 17404 // match: (Load <t> ptr mem) 17405 // cond: (is8BitInt(t) && !isSigned(t)) 17406 // result: (MOVBUload ptr mem) 17407 for { 17408 t := v.Type 17409 _ = v.Args[1] 17410 ptr := v.Args[0] 17411 mem := v.Args[1] 17412 if !(is8BitInt(t) && !isSigned(t)) { 17413 break 17414 } 17415 v.reset(OpARMMOVBUload) 17416 v.AddArg(ptr) 17417 v.AddArg(mem) 17418 return true 17419 } 17420 // match: (Load <t> ptr mem) 17421 // cond: (is16BitInt(t) && isSigned(t)) 17422 // result: (MOVHload ptr mem) 17423 for { 17424 t := v.Type 17425 _ = v.Args[1] 17426 ptr := v.Args[0] 17427 mem := v.Args[1] 17428 if !(is16BitInt(t) && isSigned(t)) { 17429 break 17430 } 17431 v.reset(OpARMMOVHload) 17432 v.AddArg(ptr) 17433 v.AddArg(mem) 17434 return true 17435 } 17436 // match: (Load <t> ptr mem) 17437 // cond: (is16BitInt(t) && !isSigned(t)) 17438 // result: (MOVHUload ptr mem) 17439 for { 17440 t := v.Type 17441 _ = v.Args[1] 17442 ptr := v.Args[0] 17443 mem := v.Args[1] 17444 if !(is16BitInt(t) && !isSigned(t)) { 17445 break 17446 } 17447 v.reset(OpARMMOVHUload) 17448 v.AddArg(ptr) 17449 v.AddArg(mem) 17450 return true 17451 } 17452 // match: (Load <t> ptr mem) 17453 // cond: (is32BitInt(t) || isPtr(t)) 17454 // result: (MOVWload ptr mem) 17455 for { 17456 t := v.Type 17457 _ = v.Args[1] 17458 ptr := v.Args[0] 17459 mem := v.Args[1] 17460 if !(is32BitInt(t) || isPtr(t)) { 17461 break 17462 } 17463 v.reset(OpARMMOVWload) 17464 v.AddArg(ptr) 17465 v.AddArg(mem) 17466 return true 17467 } 17468 // match: (Load <t> ptr mem) 17469 // cond: is32BitFloat(t) 17470 // result: (MOVFload ptr mem) 17471 for { 17472 t := v.Type 17473 _ = v.Args[1] 17474 ptr := v.Args[0] 17475 mem := v.Args[1] 17476 if !(is32BitFloat(t)) { 17477 break 17478 } 17479 v.reset(OpARMMOVFload) 17480 v.AddArg(ptr) 17481 v.AddArg(mem) 17482 return true 17483 } 17484 // match: (Load <t> ptr mem) 17485 // cond: is64BitFloat(t) 17486 // result: (MOVDload ptr mem) 17487 for { 17488 t := v.Type 17489 _ = v.Args[1] 17490 ptr := v.Args[0] 17491 mem := v.Args[1] 17492 if !(is64BitFloat(t)) { 17493 break 17494 } 17495 v.reset(OpARMMOVDload) 17496 v.AddArg(ptr) 17497 v.AddArg(mem) 17498 return true 17499 } 17500 return false 17501 } 17502 func rewriteValueARM_OpLsh16x16_0(v *Value) bool { 17503 b := v.Block 17504 _ = b 17505 typ := &b.Func.Config.Types 17506 _ = typ 17507 // match: (Lsh16x16 x y) 17508 // cond: 17509 // result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 17510 for { 17511 _ = v.Args[1] 17512 x := v.Args[0] 17513 y := v.Args[1] 17514 v.reset(OpARMCMOVWHSconst) 17515 v.AuxInt = 0 17516 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 17517 v0.AddArg(x) 17518 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 17519 v1.AddArg(y) 17520 v0.AddArg(v1) 17521 v.AddArg(v0) 17522 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 17523 v2.AuxInt = 256 17524 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 17525 v3.AddArg(y) 17526 v2.AddArg(v3) 17527 v.AddArg(v2) 17528 return true 17529 } 17530 } 17531 func rewriteValueARM_OpLsh16x32_0(v *Value) bool { 17532 b := v.Block 17533 _ = b 17534 // match: (Lsh16x32 x y) 17535 // cond: 17536 // result: (CMOVWHSconst (SLL <x.Type> x y) (CMPconst [256] y) [0]) 17537 for { 17538 _ = v.Args[1] 17539 x := v.Args[0] 17540 y := v.Args[1] 17541 v.reset(OpARMCMOVWHSconst) 17542 v.AuxInt = 0 17543 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 17544 v0.AddArg(x) 17545 v0.AddArg(y) 17546 v.AddArg(v0) 17547 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 17548 v1.AuxInt = 256 17549 v1.AddArg(y) 17550 v.AddArg(v1) 17551 return true 17552 } 17553 } 17554 func rewriteValueARM_OpLsh16x64_0(v *Value) bool { 17555 // match: (Lsh16x64 x (Const64 [c])) 17556 // cond: uint64(c) < 16 17557 // result: (SLLconst x [c]) 17558 for { 17559 _ = v.Args[1] 17560 x := v.Args[0] 17561 v_1 := v.Args[1] 17562 if v_1.Op != OpConst64 { 17563 break 17564 } 17565 c := v_1.AuxInt 17566 if !(uint64(c) < 16) { 17567 break 17568 } 17569 v.reset(OpARMSLLconst) 17570 v.AuxInt = c 17571 v.AddArg(x) 17572 return true 17573 } 17574 // match: (Lsh16x64 _ (Const64 [c])) 17575 // cond: uint64(c) >= 16 17576 // result: (Const16 [0]) 17577 for { 17578 _ = v.Args[1] 17579 v_1 := v.Args[1] 17580 if v_1.Op != OpConst64 { 17581 break 17582 } 17583 c := v_1.AuxInt 17584 if !(uint64(c) >= 16) { 17585 break 17586 } 17587 v.reset(OpConst16) 17588 v.AuxInt = 0 17589 return true 17590 } 17591 return false 17592 } 17593 func rewriteValueARM_OpLsh16x8_0(v *Value) bool { 17594 b := v.Block 17595 _ = b 17596 typ := &b.Func.Config.Types 17597 _ = typ 17598 // match: (Lsh16x8 x y) 17599 // cond: 17600 // result: (SLL x (ZeroExt8to32 y)) 17601 for { 17602 _ = v.Args[1] 17603 x := v.Args[0] 17604 y := v.Args[1] 17605 v.reset(OpARMSLL) 17606 v.AddArg(x) 17607 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 17608 v0.AddArg(y) 17609 v.AddArg(v0) 17610 return true 17611 } 17612 } 17613 func rewriteValueARM_OpLsh32x16_0(v *Value) bool { 17614 b := v.Block 17615 _ = b 17616 typ := &b.Func.Config.Types 17617 _ = typ 17618 // match: (Lsh32x16 x y) 17619 // cond: 17620 // result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 17621 for { 17622 _ = v.Args[1] 17623 x := v.Args[0] 17624 y := v.Args[1] 17625 v.reset(OpARMCMOVWHSconst) 17626 v.AuxInt = 0 17627 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 17628 v0.AddArg(x) 17629 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 17630 v1.AddArg(y) 17631 v0.AddArg(v1) 17632 v.AddArg(v0) 17633 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 17634 v2.AuxInt = 256 17635 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 17636 v3.AddArg(y) 17637 v2.AddArg(v3) 17638 v.AddArg(v2) 17639 return true 17640 } 17641 } 17642 func rewriteValueARM_OpLsh32x32_0(v *Value) bool { 17643 b := v.Block 17644 _ = b 17645 // match: (Lsh32x32 x y) 17646 // cond: 17647 // result: (CMOVWHSconst (SLL <x.Type> x y) (CMPconst [256] y) [0]) 17648 for { 17649 _ = v.Args[1] 17650 x := v.Args[0] 17651 y := v.Args[1] 17652 v.reset(OpARMCMOVWHSconst) 17653 v.AuxInt = 0 17654 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 17655 v0.AddArg(x) 17656 v0.AddArg(y) 17657 v.AddArg(v0) 17658 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 17659 v1.AuxInt = 256 17660 v1.AddArg(y) 17661 v.AddArg(v1) 17662 return true 17663 } 17664 } 17665 func rewriteValueARM_OpLsh32x64_0(v *Value) bool { 17666 // match: (Lsh32x64 x (Const64 [c])) 17667 // cond: uint64(c) < 32 17668 // result: (SLLconst x [c]) 17669 for { 17670 _ = v.Args[1] 17671 x := v.Args[0] 17672 v_1 := v.Args[1] 17673 if v_1.Op != OpConst64 { 17674 break 17675 } 17676 c := v_1.AuxInt 17677 if !(uint64(c) < 32) { 17678 break 17679 } 17680 v.reset(OpARMSLLconst) 17681 v.AuxInt = c 17682 v.AddArg(x) 17683 return true 17684 } 17685 // match: (Lsh32x64 _ (Const64 [c])) 17686 // cond: uint64(c) >= 32 17687 // result: (Const32 [0]) 17688 for { 17689 _ = v.Args[1] 17690 v_1 := v.Args[1] 17691 if v_1.Op != OpConst64 { 17692 break 17693 } 17694 c := v_1.AuxInt 17695 if !(uint64(c) >= 32) { 17696 break 17697 } 17698 v.reset(OpConst32) 17699 v.AuxInt = 0 17700 return true 17701 } 17702 return false 17703 } 17704 func rewriteValueARM_OpLsh32x8_0(v *Value) bool { 17705 b := v.Block 17706 _ = b 17707 typ := &b.Func.Config.Types 17708 _ = typ 17709 // match: (Lsh32x8 x y) 17710 // cond: 17711 // result: (SLL x (ZeroExt8to32 y)) 17712 for { 17713 _ = v.Args[1] 17714 x := v.Args[0] 17715 y := v.Args[1] 17716 v.reset(OpARMSLL) 17717 v.AddArg(x) 17718 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 17719 v0.AddArg(y) 17720 v.AddArg(v0) 17721 return true 17722 } 17723 } 17724 func rewriteValueARM_OpLsh8x16_0(v *Value) bool { 17725 b := v.Block 17726 _ = b 17727 typ := &b.Func.Config.Types 17728 _ = typ 17729 // match: (Lsh8x16 x y) 17730 // cond: 17731 // result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 17732 for { 17733 _ = v.Args[1] 17734 x := v.Args[0] 17735 y := v.Args[1] 17736 v.reset(OpARMCMOVWHSconst) 17737 v.AuxInt = 0 17738 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 17739 v0.AddArg(x) 17740 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 17741 v1.AddArg(y) 17742 v0.AddArg(v1) 17743 v.AddArg(v0) 17744 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 17745 v2.AuxInt = 256 17746 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 17747 v3.AddArg(y) 17748 v2.AddArg(v3) 17749 v.AddArg(v2) 17750 return true 17751 } 17752 } 17753 func rewriteValueARM_OpLsh8x32_0(v *Value) bool { 17754 b := v.Block 17755 _ = b 17756 // match: (Lsh8x32 x y) 17757 // cond: 17758 // result: (CMOVWHSconst (SLL <x.Type> x y) (CMPconst [256] y) [0]) 17759 for { 17760 _ = v.Args[1] 17761 x := v.Args[0] 17762 y := v.Args[1] 17763 v.reset(OpARMCMOVWHSconst) 17764 v.AuxInt = 0 17765 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 17766 v0.AddArg(x) 17767 v0.AddArg(y) 17768 v.AddArg(v0) 17769 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 17770 v1.AuxInt = 256 17771 v1.AddArg(y) 17772 v.AddArg(v1) 17773 return true 17774 } 17775 } 17776 func rewriteValueARM_OpLsh8x64_0(v *Value) bool { 17777 // match: (Lsh8x64 x (Const64 [c])) 17778 // cond: uint64(c) < 8 17779 // result: (SLLconst x [c]) 17780 for { 17781 _ = v.Args[1] 17782 x := v.Args[0] 17783 v_1 := v.Args[1] 17784 if v_1.Op != OpConst64 { 17785 break 17786 } 17787 c := v_1.AuxInt 17788 if !(uint64(c) < 8) { 17789 break 17790 } 17791 v.reset(OpARMSLLconst) 17792 v.AuxInt = c 17793 v.AddArg(x) 17794 return true 17795 } 17796 // match: (Lsh8x64 _ (Const64 [c])) 17797 // cond: uint64(c) >= 8 17798 // result: (Const8 [0]) 17799 for { 17800 _ = v.Args[1] 17801 v_1 := v.Args[1] 17802 if v_1.Op != OpConst64 { 17803 break 17804 } 17805 c := v_1.AuxInt 17806 if !(uint64(c) >= 8) { 17807 break 17808 } 17809 v.reset(OpConst8) 17810 v.AuxInt = 0 17811 return true 17812 } 17813 return false 17814 } 17815 func rewriteValueARM_OpLsh8x8_0(v *Value) bool { 17816 b := v.Block 17817 _ = b 17818 typ := &b.Func.Config.Types 17819 _ = typ 17820 // match: (Lsh8x8 x y) 17821 // cond: 17822 // result: (SLL x (ZeroExt8to32 y)) 17823 for { 17824 _ = v.Args[1] 17825 x := v.Args[0] 17826 y := v.Args[1] 17827 v.reset(OpARMSLL) 17828 v.AddArg(x) 17829 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 17830 v0.AddArg(y) 17831 v.AddArg(v0) 17832 return true 17833 } 17834 } 17835 func rewriteValueARM_OpMod16_0(v *Value) bool { 17836 b := v.Block 17837 _ = b 17838 typ := &b.Func.Config.Types 17839 _ = typ 17840 // match: (Mod16 x y) 17841 // cond: 17842 // result: (Mod32 (SignExt16to32 x) (SignExt16to32 y)) 17843 for { 17844 _ = v.Args[1] 17845 x := v.Args[0] 17846 y := v.Args[1] 17847 v.reset(OpMod32) 17848 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 17849 v0.AddArg(x) 17850 v.AddArg(v0) 17851 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 17852 v1.AddArg(y) 17853 v.AddArg(v1) 17854 return true 17855 } 17856 } 17857 func rewriteValueARM_OpMod16u_0(v *Value) bool { 17858 b := v.Block 17859 _ = b 17860 typ := &b.Func.Config.Types 17861 _ = typ 17862 // match: (Mod16u x y) 17863 // cond: 17864 // result: (Mod32u (ZeroExt16to32 x) (ZeroExt16to32 y)) 17865 for { 17866 _ = v.Args[1] 17867 x := v.Args[0] 17868 y := v.Args[1] 17869 v.reset(OpMod32u) 17870 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 17871 v0.AddArg(x) 17872 v.AddArg(v0) 17873 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 17874 v1.AddArg(y) 17875 v.AddArg(v1) 17876 return true 17877 } 17878 } 17879 func rewriteValueARM_OpMod32_0(v *Value) bool { 17880 b := v.Block 17881 _ = b 17882 typ := &b.Func.Config.Types 17883 _ = typ 17884 // match: (Mod32 x y) 17885 // cond: 17886 // result: (SUB (XOR <typ.UInt32> (Select1 <typ.UInt32> (CALLudiv (SUB <typ.UInt32> (XOR <typ.UInt32> x (Signmask x)) (Signmask x)) (SUB <typ.UInt32> (XOR <typ.UInt32> y (Signmask y)) (Signmask y)))) (Signmask x)) (Signmask x)) 17887 for { 17888 _ = v.Args[1] 17889 x := v.Args[0] 17890 y := v.Args[1] 17891 v.reset(OpARMSUB) 17892 v0 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32) 17893 v1 := b.NewValue0(v.Pos, OpSelect1, typ.UInt32) 17894 v2 := b.NewValue0(v.Pos, OpARMCALLudiv, types.NewTuple(typ.UInt32, typ.UInt32)) 17895 v3 := b.NewValue0(v.Pos, OpARMSUB, typ.UInt32) 17896 v4 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32) 17897 v4.AddArg(x) 17898 v5 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 17899 v5.AddArg(x) 17900 v4.AddArg(v5) 17901 v3.AddArg(v4) 17902 v6 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 17903 v6.AddArg(x) 17904 v3.AddArg(v6) 17905 v2.AddArg(v3) 17906 v7 := b.NewValue0(v.Pos, OpARMSUB, typ.UInt32) 17907 v8 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32) 17908 v8.AddArg(y) 17909 v9 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 17910 v9.AddArg(y) 17911 v8.AddArg(v9) 17912 v7.AddArg(v8) 17913 v10 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 17914 v10.AddArg(y) 17915 v7.AddArg(v10) 17916 v2.AddArg(v7) 17917 v1.AddArg(v2) 17918 v0.AddArg(v1) 17919 v11 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 17920 v11.AddArg(x) 17921 v0.AddArg(v11) 17922 v.AddArg(v0) 17923 v12 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 17924 v12.AddArg(x) 17925 v.AddArg(v12) 17926 return true 17927 } 17928 } 17929 func rewriteValueARM_OpMod32u_0(v *Value) bool { 17930 b := v.Block 17931 _ = b 17932 typ := &b.Func.Config.Types 17933 _ = typ 17934 // match: (Mod32u x y) 17935 // cond: 17936 // result: (Select1 <typ.UInt32> (CALLudiv x y)) 17937 for { 17938 _ = v.Args[1] 17939 x := v.Args[0] 17940 y := v.Args[1] 17941 v.reset(OpSelect1) 17942 v.Type = typ.UInt32 17943 v0 := b.NewValue0(v.Pos, OpARMCALLudiv, types.NewTuple(typ.UInt32, typ.UInt32)) 17944 v0.AddArg(x) 17945 v0.AddArg(y) 17946 v.AddArg(v0) 17947 return true 17948 } 17949 } 17950 func rewriteValueARM_OpMod8_0(v *Value) bool { 17951 b := v.Block 17952 _ = b 17953 typ := &b.Func.Config.Types 17954 _ = typ 17955 // match: (Mod8 x y) 17956 // cond: 17957 // result: (Mod32 (SignExt8to32 x) (SignExt8to32 y)) 17958 for { 17959 _ = v.Args[1] 17960 x := v.Args[0] 17961 y := v.Args[1] 17962 v.reset(OpMod32) 17963 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 17964 v0.AddArg(x) 17965 v.AddArg(v0) 17966 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 17967 v1.AddArg(y) 17968 v.AddArg(v1) 17969 return true 17970 } 17971 } 17972 func rewriteValueARM_OpMod8u_0(v *Value) bool { 17973 b := v.Block 17974 _ = b 17975 typ := &b.Func.Config.Types 17976 _ = typ 17977 // match: (Mod8u x y) 17978 // cond: 17979 // result: (Mod32u (ZeroExt8to32 x) (ZeroExt8to32 y)) 17980 for { 17981 _ = v.Args[1] 17982 x := v.Args[0] 17983 y := v.Args[1] 17984 v.reset(OpMod32u) 17985 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 17986 v0.AddArg(x) 17987 v.AddArg(v0) 17988 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 17989 v1.AddArg(y) 17990 v.AddArg(v1) 17991 return true 17992 } 17993 } 17994 func rewriteValueARM_OpMove_0(v *Value) bool { 17995 b := v.Block 17996 _ = b 17997 config := b.Func.Config 17998 _ = config 17999 typ := &b.Func.Config.Types 18000 _ = typ 18001 // match: (Move [0] _ _ mem) 18002 // cond: 18003 // result: mem 18004 for { 18005 if v.AuxInt != 0 { 18006 break 18007 } 18008 _ = v.Args[2] 18009 mem := v.Args[2] 18010 v.reset(OpCopy) 18011 v.Type = mem.Type 18012 v.AddArg(mem) 18013 return true 18014 } 18015 // match: (Move [1] dst src mem) 18016 // cond: 18017 // result: (MOVBstore dst (MOVBUload src mem) mem) 18018 for { 18019 if v.AuxInt != 1 { 18020 break 18021 } 18022 _ = v.Args[2] 18023 dst := v.Args[0] 18024 src := v.Args[1] 18025 mem := v.Args[2] 18026 v.reset(OpARMMOVBstore) 18027 v.AddArg(dst) 18028 v0 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 18029 v0.AddArg(src) 18030 v0.AddArg(mem) 18031 v.AddArg(v0) 18032 v.AddArg(mem) 18033 return true 18034 } 18035 // match: (Move [2] {t} dst src mem) 18036 // cond: t.(*types.Type).Alignment()%2 == 0 18037 // result: (MOVHstore dst (MOVHUload src mem) mem) 18038 for { 18039 if v.AuxInt != 2 { 18040 break 18041 } 18042 t := v.Aux 18043 _ = v.Args[2] 18044 dst := v.Args[0] 18045 src := v.Args[1] 18046 mem := v.Args[2] 18047 if !(t.(*types.Type).Alignment()%2 == 0) { 18048 break 18049 } 18050 v.reset(OpARMMOVHstore) 18051 v.AddArg(dst) 18052 v0 := b.NewValue0(v.Pos, OpARMMOVHUload, typ.UInt16) 18053 v0.AddArg(src) 18054 v0.AddArg(mem) 18055 v.AddArg(v0) 18056 v.AddArg(mem) 18057 return true 18058 } 18059 // match: (Move [2] dst src mem) 18060 // cond: 18061 // result: (MOVBstore [1] dst (MOVBUload [1] src mem) (MOVBstore dst (MOVBUload src mem) mem)) 18062 for { 18063 if v.AuxInt != 2 { 18064 break 18065 } 18066 _ = v.Args[2] 18067 dst := v.Args[0] 18068 src := v.Args[1] 18069 mem := v.Args[2] 18070 v.reset(OpARMMOVBstore) 18071 v.AuxInt = 1 18072 v.AddArg(dst) 18073 v0 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 18074 v0.AuxInt = 1 18075 v0.AddArg(src) 18076 v0.AddArg(mem) 18077 v.AddArg(v0) 18078 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 18079 v1.AddArg(dst) 18080 v2 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 18081 v2.AddArg(src) 18082 v2.AddArg(mem) 18083 v1.AddArg(v2) 18084 v1.AddArg(mem) 18085 v.AddArg(v1) 18086 return true 18087 } 18088 // match: (Move [4] {t} dst src mem) 18089 // cond: t.(*types.Type).Alignment()%4 == 0 18090 // result: (MOVWstore dst (MOVWload src mem) mem) 18091 for { 18092 if v.AuxInt != 4 { 18093 break 18094 } 18095 t := v.Aux 18096 _ = v.Args[2] 18097 dst := v.Args[0] 18098 src := v.Args[1] 18099 mem := v.Args[2] 18100 if !(t.(*types.Type).Alignment()%4 == 0) { 18101 break 18102 } 18103 v.reset(OpARMMOVWstore) 18104 v.AddArg(dst) 18105 v0 := b.NewValue0(v.Pos, OpARMMOVWload, typ.UInt32) 18106 v0.AddArg(src) 18107 v0.AddArg(mem) 18108 v.AddArg(v0) 18109 v.AddArg(mem) 18110 return true 18111 } 18112 // match: (Move [4] {t} dst src mem) 18113 // cond: t.(*types.Type).Alignment()%2 == 0 18114 // result: (MOVHstore [2] dst (MOVHUload [2] src mem) (MOVHstore dst (MOVHUload src mem) mem)) 18115 for { 18116 if v.AuxInt != 4 { 18117 break 18118 } 18119 t := v.Aux 18120 _ = v.Args[2] 18121 dst := v.Args[0] 18122 src := v.Args[1] 18123 mem := v.Args[2] 18124 if !(t.(*types.Type).Alignment()%2 == 0) { 18125 break 18126 } 18127 v.reset(OpARMMOVHstore) 18128 v.AuxInt = 2 18129 v.AddArg(dst) 18130 v0 := b.NewValue0(v.Pos, OpARMMOVHUload, typ.UInt16) 18131 v0.AuxInt = 2 18132 v0.AddArg(src) 18133 v0.AddArg(mem) 18134 v.AddArg(v0) 18135 v1 := b.NewValue0(v.Pos, OpARMMOVHstore, types.TypeMem) 18136 v1.AddArg(dst) 18137 v2 := b.NewValue0(v.Pos, OpARMMOVHUload, typ.UInt16) 18138 v2.AddArg(src) 18139 v2.AddArg(mem) 18140 v1.AddArg(v2) 18141 v1.AddArg(mem) 18142 v.AddArg(v1) 18143 return true 18144 } 18145 // match: (Move [4] dst src mem) 18146 // cond: 18147 // 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)))) 18148 for { 18149 if v.AuxInt != 4 { 18150 break 18151 } 18152 _ = v.Args[2] 18153 dst := v.Args[0] 18154 src := v.Args[1] 18155 mem := v.Args[2] 18156 v.reset(OpARMMOVBstore) 18157 v.AuxInt = 3 18158 v.AddArg(dst) 18159 v0 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 18160 v0.AuxInt = 3 18161 v0.AddArg(src) 18162 v0.AddArg(mem) 18163 v.AddArg(v0) 18164 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 18165 v1.AuxInt = 2 18166 v1.AddArg(dst) 18167 v2 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 18168 v2.AuxInt = 2 18169 v2.AddArg(src) 18170 v2.AddArg(mem) 18171 v1.AddArg(v2) 18172 v3 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 18173 v3.AuxInt = 1 18174 v3.AddArg(dst) 18175 v4 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 18176 v4.AuxInt = 1 18177 v4.AddArg(src) 18178 v4.AddArg(mem) 18179 v3.AddArg(v4) 18180 v5 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 18181 v5.AddArg(dst) 18182 v6 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 18183 v6.AddArg(src) 18184 v6.AddArg(mem) 18185 v5.AddArg(v6) 18186 v5.AddArg(mem) 18187 v3.AddArg(v5) 18188 v1.AddArg(v3) 18189 v.AddArg(v1) 18190 return true 18191 } 18192 // match: (Move [3] dst src mem) 18193 // cond: 18194 // result: (MOVBstore [2] dst (MOVBUload [2] src mem) (MOVBstore [1] dst (MOVBUload [1] src mem) (MOVBstore dst (MOVBUload src mem) mem))) 18195 for { 18196 if v.AuxInt != 3 { 18197 break 18198 } 18199 _ = v.Args[2] 18200 dst := v.Args[0] 18201 src := v.Args[1] 18202 mem := v.Args[2] 18203 v.reset(OpARMMOVBstore) 18204 v.AuxInt = 2 18205 v.AddArg(dst) 18206 v0 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 18207 v0.AuxInt = 2 18208 v0.AddArg(src) 18209 v0.AddArg(mem) 18210 v.AddArg(v0) 18211 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 18212 v1.AuxInt = 1 18213 v1.AddArg(dst) 18214 v2 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 18215 v2.AuxInt = 1 18216 v2.AddArg(src) 18217 v2.AddArg(mem) 18218 v1.AddArg(v2) 18219 v3 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 18220 v3.AddArg(dst) 18221 v4 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 18222 v4.AddArg(src) 18223 v4.AddArg(mem) 18224 v3.AddArg(v4) 18225 v3.AddArg(mem) 18226 v1.AddArg(v3) 18227 v.AddArg(v1) 18228 return true 18229 } 18230 // match: (Move [s] {t} dst src mem) 18231 // cond: s%4 == 0 && s > 4 && s <= 512 && t.(*types.Type).Alignment()%4 == 0 && !config.noDuffDevice 18232 // result: (DUFFCOPY [8 * (128 - int64(s/4))] dst src mem) 18233 for { 18234 s := v.AuxInt 18235 t := v.Aux 18236 _ = v.Args[2] 18237 dst := v.Args[0] 18238 src := v.Args[1] 18239 mem := v.Args[2] 18240 if !(s%4 == 0 && s > 4 && s <= 512 && t.(*types.Type).Alignment()%4 == 0 && !config.noDuffDevice) { 18241 break 18242 } 18243 v.reset(OpARMDUFFCOPY) 18244 v.AuxInt = 8 * (128 - int64(s/4)) 18245 v.AddArg(dst) 18246 v.AddArg(src) 18247 v.AddArg(mem) 18248 return true 18249 } 18250 // match: (Move [s] {t} dst src mem) 18251 // cond: (s > 512 || config.noDuffDevice) || t.(*types.Type).Alignment()%4 != 0 18252 // result: (LoweredMove [t.(*types.Type).Alignment()] dst src (ADDconst <src.Type> src [s-moveSize(t.(*types.Type).Alignment(), config)]) mem) 18253 for { 18254 s := v.AuxInt 18255 t := v.Aux 18256 _ = v.Args[2] 18257 dst := v.Args[0] 18258 src := v.Args[1] 18259 mem := v.Args[2] 18260 if !((s > 512 || config.noDuffDevice) || t.(*types.Type).Alignment()%4 != 0) { 18261 break 18262 } 18263 v.reset(OpARMLoweredMove) 18264 v.AuxInt = t.(*types.Type).Alignment() 18265 v.AddArg(dst) 18266 v.AddArg(src) 18267 v0 := b.NewValue0(v.Pos, OpARMADDconst, src.Type) 18268 v0.AuxInt = s - moveSize(t.(*types.Type).Alignment(), config) 18269 v0.AddArg(src) 18270 v.AddArg(v0) 18271 v.AddArg(mem) 18272 return true 18273 } 18274 return false 18275 } 18276 func rewriteValueARM_OpMul16_0(v *Value) bool { 18277 // match: (Mul16 x y) 18278 // cond: 18279 // result: (MUL x y) 18280 for { 18281 _ = v.Args[1] 18282 x := v.Args[0] 18283 y := v.Args[1] 18284 v.reset(OpARMMUL) 18285 v.AddArg(x) 18286 v.AddArg(y) 18287 return true 18288 } 18289 } 18290 func rewriteValueARM_OpMul32_0(v *Value) bool { 18291 // match: (Mul32 x y) 18292 // cond: 18293 // result: (MUL x y) 18294 for { 18295 _ = v.Args[1] 18296 x := v.Args[0] 18297 y := v.Args[1] 18298 v.reset(OpARMMUL) 18299 v.AddArg(x) 18300 v.AddArg(y) 18301 return true 18302 } 18303 } 18304 func rewriteValueARM_OpMul32F_0(v *Value) bool { 18305 // match: (Mul32F x y) 18306 // cond: 18307 // result: (MULF x y) 18308 for { 18309 _ = v.Args[1] 18310 x := v.Args[0] 18311 y := v.Args[1] 18312 v.reset(OpARMMULF) 18313 v.AddArg(x) 18314 v.AddArg(y) 18315 return true 18316 } 18317 } 18318 func rewriteValueARM_OpMul32uhilo_0(v *Value) bool { 18319 // match: (Mul32uhilo x y) 18320 // cond: 18321 // result: (MULLU x y) 18322 for { 18323 _ = v.Args[1] 18324 x := v.Args[0] 18325 y := v.Args[1] 18326 v.reset(OpARMMULLU) 18327 v.AddArg(x) 18328 v.AddArg(y) 18329 return true 18330 } 18331 } 18332 func rewriteValueARM_OpMul64F_0(v *Value) bool { 18333 // match: (Mul64F x y) 18334 // cond: 18335 // result: (MULD x y) 18336 for { 18337 _ = v.Args[1] 18338 x := v.Args[0] 18339 y := v.Args[1] 18340 v.reset(OpARMMULD) 18341 v.AddArg(x) 18342 v.AddArg(y) 18343 return true 18344 } 18345 } 18346 func rewriteValueARM_OpMul8_0(v *Value) bool { 18347 // match: (Mul8 x y) 18348 // cond: 18349 // result: (MUL x y) 18350 for { 18351 _ = v.Args[1] 18352 x := v.Args[0] 18353 y := v.Args[1] 18354 v.reset(OpARMMUL) 18355 v.AddArg(x) 18356 v.AddArg(y) 18357 return true 18358 } 18359 } 18360 func rewriteValueARM_OpNeg16_0(v *Value) bool { 18361 // match: (Neg16 x) 18362 // cond: 18363 // result: (RSBconst [0] x) 18364 for { 18365 x := v.Args[0] 18366 v.reset(OpARMRSBconst) 18367 v.AuxInt = 0 18368 v.AddArg(x) 18369 return true 18370 } 18371 } 18372 func rewriteValueARM_OpNeg32_0(v *Value) bool { 18373 // match: (Neg32 x) 18374 // cond: 18375 // result: (RSBconst [0] x) 18376 for { 18377 x := v.Args[0] 18378 v.reset(OpARMRSBconst) 18379 v.AuxInt = 0 18380 v.AddArg(x) 18381 return true 18382 } 18383 } 18384 func rewriteValueARM_OpNeg32F_0(v *Value) bool { 18385 // match: (Neg32F x) 18386 // cond: 18387 // result: (NEGF x) 18388 for { 18389 x := v.Args[0] 18390 v.reset(OpARMNEGF) 18391 v.AddArg(x) 18392 return true 18393 } 18394 } 18395 func rewriteValueARM_OpNeg64F_0(v *Value) bool { 18396 // match: (Neg64F x) 18397 // cond: 18398 // result: (NEGD x) 18399 for { 18400 x := v.Args[0] 18401 v.reset(OpARMNEGD) 18402 v.AddArg(x) 18403 return true 18404 } 18405 } 18406 func rewriteValueARM_OpNeg8_0(v *Value) bool { 18407 // match: (Neg8 x) 18408 // cond: 18409 // result: (RSBconst [0] x) 18410 for { 18411 x := v.Args[0] 18412 v.reset(OpARMRSBconst) 18413 v.AuxInt = 0 18414 v.AddArg(x) 18415 return true 18416 } 18417 } 18418 func rewriteValueARM_OpNeq16_0(v *Value) bool { 18419 b := v.Block 18420 _ = b 18421 typ := &b.Func.Config.Types 18422 _ = typ 18423 // match: (Neq16 x y) 18424 // cond: 18425 // result: (NotEqual (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 18426 for { 18427 _ = v.Args[1] 18428 x := v.Args[0] 18429 y := v.Args[1] 18430 v.reset(OpARMNotEqual) 18431 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18432 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18433 v1.AddArg(x) 18434 v0.AddArg(v1) 18435 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18436 v2.AddArg(y) 18437 v0.AddArg(v2) 18438 v.AddArg(v0) 18439 return true 18440 } 18441 } 18442 func rewriteValueARM_OpNeq32_0(v *Value) bool { 18443 b := v.Block 18444 _ = b 18445 // match: (Neq32 x y) 18446 // cond: 18447 // result: (NotEqual (CMP x y)) 18448 for { 18449 _ = v.Args[1] 18450 x := v.Args[0] 18451 y := v.Args[1] 18452 v.reset(OpARMNotEqual) 18453 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18454 v0.AddArg(x) 18455 v0.AddArg(y) 18456 v.AddArg(v0) 18457 return true 18458 } 18459 } 18460 func rewriteValueARM_OpNeq32F_0(v *Value) bool { 18461 b := v.Block 18462 _ = b 18463 // match: (Neq32F x y) 18464 // cond: 18465 // result: (NotEqual (CMPF x y)) 18466 for { 18467 _ = v.Args[1] 18468 x := v.Args[0] 18469 y := v.Args[1] 18470 v.reset(OpARMNotEqual) 18471 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags) 18472 v0.AddArg(x) 18473 v0.AddArg(y) 18474 v.AddArg(v0) 18475 return true 18476 } 18477 } 18478 func rewriteValueARM_OpNeq64F_0(v *Value) bool { 18479 b := v.Block 18480 _ = b 18481 // match: (Neq64F x y) 18482 // cond: 18483 // result: (NotEqual (CMPD x y)) 18484 for { 18485 _ = v.Args[1] 18486 x := v.Args[0] 18487 y := v.Args[1] 18488 v.reset(OpARMNotEqual) 18489 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags) 18490 v0.AddArg(x) 18491 v0.AddArg(y) 18492 v.AddArg(v0) 18493 return true 18494 } 18495 } 18496 func rewriteValueARM_OpNeq8_0(v *Value) bool { 18497 b := v.Block 18498 _ = b 18499 typ := &b.Func.Config.Types 18500 _ = typ 18501 // match: (Neq8 x y) 18502 // cond: 18503 // result: (NotEqual (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 18504 for { 18505 _ = v.Args[1] 18506 x := v.Args[0] 18507 y := v.Args[1] 18508 v.reset(OpARMNotEqual) 18509 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18510 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 18511 v1.AddArg(x) 18512 v0.AddArg(v1) 18513 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 18514 v2.AddArg(y) 18515 v0.AddArg(v2) 18516 v.AddArg(v0) 18517 return true 18518 } 18519 } 18520 func rewriteValueARM_OpNeqB_0(v *Value) bool { 18521 // match: (NeqB x y) 18522 // cond: 18523 // result: (XOR x y) 18524 for { 18525 _ = v.Args[1] 18526 x := v.Args[0] 18527 y := v.Args[1] 18528 v.reset(OpARMXOR) 18529 v.AddArg(x) 18530 v.AddArg(y) 18531 return true 18532 } 18533 } 18534 func rewriteValueARM_OpNeqPtr_0(v *Value) bool { 18535 b := v.Block 18536 _ = b 18537 // match: (NeqPtr x y) 18538 // cond: 18539 // result: (NotEqual (CMP x y)) 18540 for { 18541 _ = v.Args[1] 18542 x := v.Args[0] 18543 y := v.Args[1] 18544 v.reset(OpARMNotEqual) 18545 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18546 v0.AddArg(x) 18547 v0.AddArg(y) 18548 v.AddArg(v0) 18549 return true 18550 } 18551 } 18552 func rewriteValueARM_OpNilCheck_0(v *Value) bool { 18553 // match: (NilCheck ptr mem) 18554 // cond: 18555 // result: (LoweredNilCheck ptr mem) 18556 for { 18557 _ = v.Args[1] 18558 ptr := v.Args[0] 18559 mem := v.Args[1] 18560 v.reset(OpARMLoweredNilCheck) 18561 v.AddArg(ptr) 18562 v.AddArg(mem) 18563 return true 18564 } 18565 } 18566 func rewriteValueARM_OpNot_0(v *Value) bool { 18567 // match: (Not x) 18568 // cond: 18569 // result: (XORconst [1] x) 18570 for { 18571 x := v.Args[0] 18572 v.reset(OpARMXORconst) 18573 v.AuxInt = 1 18574 v.AddArg(x) 18575 return true 18576 } 18577 } 18578 func rewriteValueARM_OpOffPtr_0(v *Value) bool { 18579 // match: (OffPtr [off] ptr:(SP)) 18580 // cond: 18581 // result: (MOVWaddr [off] ptr) 18582 for { 18583 off := v.AuxInt 18584 ptr := v.Args[0] 18585 if ptr.Op != OpSP { 18586 break 18587 } 18588 v.reset(OpARMMOVWaddr) 18589 v.AuxInt = off 18590 v.AddArg(ptr) 18591 return true 18592 } 18593 // match: (OffPtr [off] ptr) 18594 // cond: 18595 // result: (ADDconst [off] ptr) 18596 for { 18597 off := v.AuxInt 18598 ptr := v.Args[0] 18599 v.reset(OpARMADDconst) 18600 v.AuxInt = off 18601 v.AddArg(ptr) 18602 return true 18603 } 18604 } 18605 func rewriteValueARM_OpOr16_0(v *Value) bool { 18606 // match: (Or16 x y) 18607 // cond: 18608 // result: (OR x y) 18609 for { 18610 _ = v.Args[1] 18611 x := v.Args[0] 18612 y := v.Args[1] 18613 v.reset(OpARMOR) 18614 v.AddArg(x) 18615 v.AddArg(y) 18616 return true 18617 } 18618 } 18619 func rewriteValueARM_OpOr32_0(v *Value) bool { 18620 // match: (Or32 x y) 18621 // cond: 18622 // result: (OR x y) 18623 for { 18624 _ = v.Args[1] 18625 x := v.Args[0] 18626 y := v.Args[1] 18627 v.reset(OpARMOR) 18628 v.AddArg(x) 18629 v.AddArg(y) 18630 return true 18631 } 18632 } 18633 func rewriteValueARM_OpOr8_0(v *Value) bool { 18634 // match: (Or8 x y) 18635 // cond: 18636 // result: (OR x y) 18637 for { 18638 _ = v.Args[1] 18639 x := v.Args[0] 18640 y := v.Args[1] 18641 v.reset(OpARMOR) 18642 v.AddArg(x) 18643 v.AddArg(y) 18644 return true 18645 } 18646 } 18647 func rewriteValueARM_OpOrB_0(v *Value) bool { 18648 // match: (OrB x y) 18649 // cond: 18650 // result: (OR x y) 18651 for { 18652 _ = v.Args[1] 18653 x := v.Args[0] 18654 y := v.Args[1] 18655 v.reset(OpARMOR) 18656 v.AddArg(x) 18657 v.AddArg(y) 18658 return true 18659 } 18660 } 18661 func rewriteValueARM_OpRound32F_0(v *Value) bool { 18662 // match: (Round32F x) 18663 // cond: 18664 // result: x 18665 for { 18666 x := v.Args[0] 18667 v.reset(OpCopy) 18668 v.Type = x.Type 18669 v.AddArg(x) 18670 return true 18671 } 18672 } 18673 func rewriteValueARM_OpRound64F_0(v *Value) bool { 18674 // match: (Round64F x) 18675 // cond: 18676 // result: x 18677 for { 18678 x := v.Args[0] 18679 v.reset(OpCopy) 18680 v.Type = x.Type 18681 v.AddArg(x) 18682 return true 18683 } 18684 } 18685 func rewriteValueARM_OpRsh16Ux16_0(v *Value) bool { 18686 b := v.Block 18687 _ = b 18688 typ := &b.Func.Config.Types 18689 _ = typ 18690 // match: (Rsh16Ux16 x y) 18691 // cond: 18692 // result: (CMOVWHSconst (SRL <x.Type> (ZeroExt16to32 x) (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 18693 for { 18694 _ = v.Args[1] 18695 x := v.Args[0] 18696 y := v.Args[1] 18697 v.reset(OpARMCMOVWHSconst) 18698 v.AuxInt = 0 18699 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 18700 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18701 v1.AddArg(x) 18702 v0.AddArg(v1) 18703 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18704 v2.AddArg(y) 18705 v0.AddArg(v2) 18706 v.AddArg(v0) 18707 v3 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 18708 v3.AuxInt = 256 18709 v4 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18710 v4.AddArg(y) 18711 v3.AddArg(v4) 18712 v.AddArg(v3) 18713 return true 18714 } 18715 } 18716 func rewriteValueARM_OpRsh16Ux32_0(v *Value) bool { 18717 b := v.Block 18718 _ = b 18719 typ := &b.Func.Config.Types 18720 _ = typ 18721 // match: (Rsh16Ux32 x y) 18722 // cond: 18723 // result: (CMOVWHSconst (SRL <x.Type> (ZeroExt16to32 x) y) (CMPconst [256] y) [0]) 18724 for { 18725 _ = v.Args[1] 18726 x := v.Args[0] 18727 y := v.Args[1] 18728 v.reset(OpARMCMOVWHSconst) 18729 v.AuxInt = 0 18730 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 18731 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18732 v1.AddArg(x) 18733 v0.AddArg(v1) 18734 v0.AddArg(y) 18735 v.AddArg(v0) 18736 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 18737 v2.AuxInt = 256 18738 v2.AddArg(y) 18739 v.AddArg(v2) 18740 return true 18741 } 18742 } 18743 func rewriteValueARM_OpRsh16Ux64_0(v *Value) bool { 18744 b := v.Block 18745 _ = b 18746 typ := &b.Func.Config.Types 18747 _ = typ 18748 // match: (Rsh16Ux64 x (Const64 [c])) 18749 // cond: uint64(c) < 16 18750 // result: (SRLconst (SLLconst <typ.UInt32> x [16]) [c+16]) 18751 for { 18752 _ = v.Args[1] 18753 x := v.Args[0] 18754 v_1 := v.Args[1] 18755 if v_1.Op != OpConst64 { 18756 break 18757 } 18758 c := v_1.AuxInt 18759 if !(uint64(c) < 16) { 18760 break 18761 } 18762 v.reset(OpARMSRLconst) 18763 v.AuxInt = c + 16 18764 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32) 18765 v0.AuxInt = 16 18766 v0.AddArg(x) 18767 v.AddArg(v0) 18768 return true 18769 } 18770 // match: (Rsh16Ux64 _ (Const64 [c])) 18771 // cond: uint64(c) >= 16 18772 // result: (Const16 [0]) 18773 for { 18774 _ = v.Args[1] 18775 v_1 := v.Args[1] 18776 if v_1.Op != OpConst64 { 18777 break 18778 } 18779 c := v_1.AuxInt 18780 if !(uint64(c) >= 16) { 18781 break 18782 } 18783 v.reset(OpConst16) 18784 v.AuxInt = 0 18785 return true 18786 } 18787 return false 18788 } 18789 func rewriteValueARM_OpRsh16Ux8_0(v *Value) bool { 18790 b := v.Block 18791 _ = b 18792 typ := &b.Func.Config.Types 18793 _ = typ 18794 // match: (Rsh16Ux8 x y) 18795 // cond: 18796 // result: (SRL (ZeroExt16to32 x) (ZeroExt8to32 y)) 18797 for { 18798 _ = v.Args[1] 18799 x := v.Args[0] 18800 y := v.Args[1] 18801 v.reset(OpARMSRL) 18802 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18803 v0.AddArg(x) 18804 v.AddArg(v0) 18805 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 18806 v1.AddArg(y) 18807 v.AddArg(v1) 18808 return true 18809 } 18810 } 18811 func rewriteValueARM_OpRsh16x16_0(v *Value) bool { 18812 b := v.Block 18813 _ = b 18814 typ := &b.Func.Config.Types 18815 _ = typ 18816 // match: (Rsh16x16 x y) 18817 // cond: 18818 // result: (SRAcond (SignExt16to32 x) (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y))) 18819 for { 18820 _ = v.Args[1] 18821 x := v.Args[0] 18822 y := v.Args[1] 18823 v.reset(OpARMSRAcond) 18824 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 18825 v0.AddArg(x) 18826 v.AddArg(v0) 18827 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18828 v1.AddArg(y) 18829 v.AddArg(v1) 18830 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 18831 v2.AuxInt = 256 18832 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18833 v3.AddArg(y) 18834 v2.AddArg(v3) 18835 v.AddArg(v2) 18836 return true 18837 } 18838 } 18839 func rewriteValueARM_OpRsh16x32_0(v *Value) bool { 18840 b := v.Block 18841 _ = b 18842 typ := &b.Func.Config.Types 18843 _ = typ 18844 // match: (Rsh16x32 x y) 18845 // cond: 18846 // result: (SRAcond (SignExt16to32 x) y (CMPconst [256] y)) 18847 for { 18848 _ = v.Args[1] 18849 x := v.Args[0] 18850 y := v.Args[1] 18851 v.reset(OpARMSRAcond) 18852 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 18853 v0.AddArg(x) 18854 v.AddArg(v0) 18855 v.AddArg(y) 18856 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 18857 v1.AuxInt = 256 18858 v1.AddArg(y) 18859 v.AddArg(v1) 18860 return true 18861 } 18862 } 18863 func rewriteValueARM_OpRsh16x64_0(v *Value) bool { 18864 b := v.Block 18865 _ = b 18866 typ := &b.Func.Config.Types 18867 _ = typ 18868 // match: (Rsh16x64 x (Const64 [c])) 18869 // cond: uint64(c) < 16 18870 // result: (SRAconst (SLLconst <typ.UInt32> x [16]) [c+16]) 18871 for { 18872 _ = v.Args[1] 18873 x := v.Args[0] 18874 v_1 := v.Args[1] 18875 if v_1.Op != OpConst64 { 18876 break 18877 } 18878 c := v_1.AuxInt 18879 if !(uint64(c) < 16) { 18880 break 18881 } 18882 v.reset(OpARMSRAconst) 18883 v.AuxInt = c + 16 18884 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32) 18885 v0.AuxInt = 16 18886 v0.AddArg(x) 18887 v.AddArg(v0) 18888 return true 18889 } 18890 // match: (Rsh16x64 x (Const64 [c])) 18891 // cond: uint64(c) >= 16 18892 // result: (SRAconst (SLLconst <typ.UInt32> x [16]) [31]) 18893 for { 18894 _ = v.Args[1] 18895 x := v.Args[0] 18896 v_1 := v.Args[1] 18897 if v_1.Op != OpConst64 { 18898 break 18899 } 18900 c := v_1.AuxInt 18901 if !(uint64(c) >= 16) { 18902 break 18903 } 18904 v.reset(OpARMSRAconst) 18905 v.AuxInt = 31 18906 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32) 18907 v0.AuxInt = 16 18908 v0.AddArg(x) 18909 v.AddArg(v0) 18910 return true 18911 } 18912 return false 18913 } 18914 func rewriteValueARM_OpRsh16x8_0(v *Value) bool { 18915 b := v.Block 18916 _ = b 18917 typ := &b.Func.Config.Types 18918 _ = typ 18919 // match: (Rsh16x8 x y) 18920 // cond: 18921 // result: (SRA (SignExt16to32 x) (ZeroExt8to32 y)) 18922 for { 18923 _ = v.Args[1] 18924 x := v.Args[0] 18925 y := v.Args[1] 18926 v.reset(OpARMSRA) 18927 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 18928 v0.AddArg(x) 18929 v.AddArg(v0) 18930 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 18931 v1.AddArg(y) 18932 v.AddArg(v1) 18933 return true 18934 } 18935 } 18936 func rewriteValueARM_OpRsh32Ux16_0(v *Value) bool { 18937 b := v.Block 18938 _ = b 18939 typ := &b.Func.Config.Types 18940 _ = typ 18941 // match: (Rsh32Ux16 x y) 18942 // cond: 18943 // result: (CMOVWHSconst (SRL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 18944 for { 18945 _ = v.Args[1] 18946 x := v.Args[0] 18947 y := v.Args[1] 18948 v.reset(OpARMCMOVWHSconst) 18949 v.AuxInt = 0 18950 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 18951 v0.AddArg(x) 18952 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18953 v1.AddArg(y) 18954 v0.AddArg(v1) 18955 v.AddArg(v0) 18956 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 18957 v2.AuxInt = 256 18958 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18959 v3.AddArg(y) 18960 v2.AddArg(v3) 18961 v.AddArg(v2) 18962 return true 18963 } 18964 } 18965 func rewriteValueARM_OpRsh32Ux32_0(v *Value) bool { 18966 b := v.Block 18967 _ = b 18968 // match: (Rsh32Ux32 x y) 18969 // cond: 18970 // result: (CMOVWHSconst (SRL <x.Type> x y) (CMPconst [256] y) [0]) 18971 for { 18972 _ = v.Args[1] 18973 x := v.Args[0] 18974 y := v.Args[1] 18975 v.reset(OpARMCMOVWHSconst) 18976 v.AuxInt = 0 18977 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 18978 v0.AddArg(x) 18979 v0.AddArg(y) 18980 v.AddArg(v0) 18981 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 18982 v1.AuxInt = 256 18983 v1.AddArg(y) 18984 v.AddArg(v1) 18985 return true 18986 } 18987 } 18988 func rewriteValueARM_OpRsh32Ux64_0(v *Value) bool { 18989 // match: (Rsh32Ux64 x (Const64 [c])) 18990 // cond: uint64(c) < 32 18991 // result: (SRLconst x [c]) 18992 for { 18993 _ = v.Args[1] 18994 x := v.Args[0] 18995 v_1 := v.Args[1] 18996 if v_1.Op != OpConst64 { 18997 break 18998 } 18999 c := v_1.AuxInt 19000 if !(uint64(c) < 32) { 19001 break 19002 } 19003 v.reset(OpARMSRLconst) 19004 v.AuxInt = c 19005 v.AddArg(x) 19006 return true 19007 } 19008 // match: (Rsh32Ux64 _ (Const64 [c])) 19009 // cond: uint64(c) >= 32 19010 // result: (Const32 [0]) 19011 for { 19012 _ = v.Args[1] 19013 v_1 := v.Args[1] 19014 if v_1.Op != OpConst64 { 19015 break 19016 } 19017 c := v_1.AuxInt 19018 if !(uint64(c) >= 32) { 19019 break 19020 } 19021 v.reset(OpConst32) 19022 v.AuxInt = 0 19023 return true 19024 } 19025 return false 19026 } 19027 func rewriteValueARM_OpRsh32Ux8_0(v *Value) bool { 19028 b := v.Block 19029 _ = b 19030 typ := &b.Func.Config.Types 19031 _ = typ 19032 // match: (Rsh32Ux8 x y) 19033 // cond: 19034 // result: (SRL x (ZeroExt8to32 y)) 19035 for { 19036 _ = v.Args[1] 19037 x := v.Args[0] 19038 y := v.Args[1] 19039 v.reset(OpARMSRL) 19040 v.AddArg(x) 19041 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 19042 v0.AddArg(y) 19043 v.AddArg(v0) 19044 return true 19045 } 19046 } 19047 func rewriteValueARM_OpRsh32x16_0(v *Value) bool { 19048 b := v.Block 19049 _ = b 19050 typ := &b.Func.Config.Types 19051 _ = typ 19052 // match: (Rsh32x16 x y) 19053 // cond: 19054 // result: (SRAcond x (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y))) 19055 for { 19056 _ = v.Args[1] 19057 x := v.Args[0] 19058 y := v.Args[1] 19059 v.reset(OpARMSRAcond) 19060 v.AddArg(x) 19061 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19062 v0.AddArg(y) 19063 v.AddArg(v0) 19064 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 19065 v1.AuxInt = 256 19066 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19067 v2.AddArg(y) 19068 v1.AddArg(v2) 19069 v.AddArg(v1) 19070 return true 19071 } 19072 } 19073 func rewriteValueARM_OpRsh32x32_0(v *Value) bool { 19074 b := v.Block 19075 _ = b 19076 // match: (Rsh32x32 x y) 19077 // cond: 19078 // result: (SRAcond x y (CMPconst [256] y)) 19079 for { 19080 _ = v.Args[1] 19081 x := v.Args[0] 19082 y := v.Args[1] 19083 v.reset(OpARMSRAcond) 19084 v.AddArg(x) 19085 v.AddArg(y) 19086 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 19087 v0.AuxInt = 256 19088 v0.AddArg(y) 19089 v.AddArg(v0) 19090 return true 19091 } 19092 } 19093 func rewriteValueARM_OpRsh32x64_0(v *Value) bool { 19094 // match: (Rsh32x64 x (Const64 [c])) 19095 // cond: uint64(c) < 32 19096 // result: (SRAconst x [c]) 19097 for { 19098 _ = v.Args[1] 19099 x := v.Args[0] 19100 v_1 := v.Args[1] 19101 if v_1.Op != OpConst64 { 19102 break 19103 } 19104 c := v_1.AuxInt 19105 if !(uint64(c) < 32) { 19106 break 19107 } 19108 v.reset(OpARMSRAconst) 19109 v.AuxInt = c 19110 v.AddArg(x) 19111 return true 19112 } 19113 // match: (Rsh32x64 x (Const64 [c])) 19114 // cond: uint64(c) >= 32 19115 // result: (SRAconst x [31]) 19116 for { 19117 _ = v.Args[1] 19118 x := v.Args[0] 19119 v_1 := v.Args[1] 19120 if v_1.Op != OpConst64 { 19121 break 19122 } 19123 c := v_1.AuxInt 19124 if !(uint64(c) >= 32) { 19125 break 19126 } 19127 v.reset(OpARMSRAconst) 19128 v.AuxInt = 31 19129 v.AddArg(x) 19130 return true 19131 } 19132 return false 19133 } 19134 func rewriteValueARM_OpRsh32x8_0(v *Value) bool { 19135 b := v.Block 19136 _ = b 19137 typ := &b.Func.Config.Types 19138 _ = typ 19139 // match: (Rsh32x8 x y) 19140 // cond: 19141 // result: (SRA x (ZeroExt8to32 y)) 19142 for { 19143 _ = v.Args[1] 19144 x := v.Args[0] 19145 y := v.Args[1] 19146 v.reset(OpARMSRA) 19147 v.AddArg(x) 19148 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 19149 v0.AddArg(y) 19150 v.AddArg(v0) 19151 return true 19152 } 19153 } 19154 func rewriteValueARM_OpRsh8Ux16_0(v *Value) bool { 19155 b := v.Block 19156 _ = b 19157 typ := &b.Func.Config.Types 19158 _ = typ 19159 // match: (Rsh8Ux16 x y) 19160 // cond: 19161 // result: (CMOVWHSconst (SRL <x.Type> (ZeroExt8to32 x) (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 19162 for { 19163 _ = v.Args[1] 19164 x := v.Args[0] 19165 y := v.Args[1] 19166 v.reset(OpARMCMOVWHSconst) 19167 v.AuxInt = 0 19168 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 19169 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 19170 v1.AddArg(x) 19171 v0.AddArg(v1) 19172 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19173 v2.AddArg(y) 19174 v0.AddArg(v2) 19175 v.AddArg(v0) 19176 v3 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 19177 v3.AuxInt = 256 19178 v4 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19179 v4.AddArg(y) 19180 v3.AddArg(v4) 19181 v.AddArg(v3) 19182 return true 19183 } 19184 } 19185 func rewriteValueARM_OpRsh8Ux32_0(v *Value) bool { 19186 b := v.Block 19187 _ = b 19188 typ := &b.Func.Config.Types 19189 _ = typ 19190 // match: (Rsh8Ux32 x y) 19191 // cond: 19192 // result: (CMOVWHSconst (SRL <x.Type> (ZeroExt8to32 x) y) (CMPconst [256] y) [0]) 19193 for { 19194 _ = v.Args[1] 19195 x := v.Args[0] 19196 y := v.Args[1] 19197 v.reset(OpARMCMOVWHSconst) 19198 v.AuxInt = 0 19199 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 19200 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 19201 v1.AddArg(x) 19202 v0.AddArg(v1) 19203 v0.AddArg(y) 19204 v.AddArg(v0) 19205 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 19206 v2.AuxInt = 256 19207 v2.AddArg(y) 19208 v.AddArg(v2) 19209 return true 19210 } 19211 } 19212 func rewriteValueARM_OpRsh8Ux64_0(v *Value) bool { 19213 b := v.Block 19214 _ = b 19215 typ := &b.Func.Config.Types 19216 _ = typ 19217 // match: (Rsh8Ux64 x (Const64 [c])) 19218 // cond: uint64(c) < 8 19219 // result: (SRLconst (SLLconst <typ.UInt32> x [24]) [c+24]) 19220 for { 19221 _ = v.Args[1] 19222 x := v.Args[0] 19223 v_1 := v.Args[1] 19224 if v_1.Op != OpConst64 { 19225 break 19226 } 19227 c := v_1.AuxInt 19228 if !(uint64(c) < 8) { 19229 break 19230 } 19231 v.reset(OpARMSRLconst) 19232 v.AuxInt = c + 24 19233 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32) 19234 v0.AuxInt = 24 19235 v0.AddArg(x) 19236 v.AddArg(v0) 19237 return true 19238 } 19239 // match: (Rsh8Ux64 _ (Const64 [c])) 19240 // cond: uint64(c) >= 8 19241 // result: (Const8 [0]) 19242 for { 19243 _ = v.Args[1] 19244 v_1 := v.Args[1] 19245 if v_1.Op != OpConst64 { 19246 break 19247 } 19248 c := v_1.AuxInt 19249 if !(uint64(c) >= 8) { 19250 break 19251 } 19252 v.reset(OpConst8) 19253 v.AuxInt = 0 19254 return true 19255 } 19256 return false 19257 } 19258 func rewriteValueARM_OpRsh8Ux8_0(v *Value) bool { 19259 b := v.Block 19260 _ = b 19261 typ := &b.Func.Config.Types 19262 _ = typ 19263 // match: (Rsh8Ux8 x y) 19264 // cond: 19265 // result: (SRL (ZeroExt8to32 x) (ZeroExt8to32 y)) 19266 for { 19267 _ = v.Args[1] 19268 x := v.Args[0] 19269 y := v.Args[1] 19270 v.reset(OpARMSRL) 19271 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 19272 v0.AddArg(x) 19273 v.AddArg(v0) 19274 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 19275 v1.AddArg(y) 19276 v.AddArg(v1) 19277 return true 19278 } 19279 } 19280 func rewriteValueARM_OpRsh8x16_0(v *Value) bool { 19281 b := v.Block 19282 _ = b 19283 typ := &b.Func.Config.Types 19284 _ = typ 19285 // match: (Rsh8x16 x y) 19286 // cond: 19287 // result: (SRAcond (SignExt8to32 x) (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y))) 19288 for { 19289 _ = v.Args[1] 19290 x := v.Args[0] 19291 y := v.Args[1] 19292 v.reset(OpARMSRAcond) 19293 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 19294 v0.AddArg(x) 19295 v.AddArg(v0) 19296 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19297 v1.AddArg(y) 19298 v.AddArg(v1) 19299 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 19300 v2.AuxInt = 256 19301 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19302 v3.AddArg(y) 19303 v2.AddArg(v3) 19304 v.AddArg(v2) 19305 return true 19306 } 19307 } 19308 func rewriteValueARM_OpRsh8x32_0(v *Value) bool { 19309 b := v.Block 19310 _ = b 19311 typ := &b.Func.Config.Types 19312 _ = typ 19313 // match: (Rsh8x32 x y) 19314 // cond: 19315 // result: (SRAcond (SignExt8to32 x) y (CMPconst [256] y)) 19316 for { 19317 _ = v.Args[1] 19318 x := v.Args[0] 19319 y := v.Args[1] 19320 v.reset(OpARMSRAcond) 19321 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 19322 v0.AddArg(x) 19323 v.AddArg(v0) 19324 v.AddArg(y) 19325 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 19326 v1.AuxInt = 256 19327 v1.AddArg(y) 19328 v.AddArg(v1) 19329 return true 19330 } 19331 } 19332 func rewriteValueARM_OpRsh8x64_0(v *Value) bool { 19333 b := v.Block 19334 _ = b 19335 typ := &b.Func.Config.Types 19336 _ = typ 19337 // match: (Rsh8x64 x (Const64 [c])) 19338 // cond: uint64(c) < 8 19339 // result: (SRAconst (SLLconst <typ.UInt32> x [24]) [c+24]) 19340 for { 19341 _ = v.Args[1] 19342 x := v.Args[0] 19343 v_1 := v.Args[1] 19344 if v_1.Op != OpConst64 { 19345 break 19346 } 19347 c := v_1.AuxInt 19348 if !(uint64(c) < 8) { 19349 break 19350 } 19351 v.reset(OpARMSRAconst) 19352 v.AuxInt = c + 24 19353 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32) 19354 v0.AuxInt = 24 19355 v0.AddArg(x) 19356 v.AddArg(v0) 19357 return true 19358 } 19359 // match: (Rsh8x64 x (Const64 [c])) 19360 // cond: uint64(c) >= 8 19361 // result: (SRAconst (SLLconst <typ.UInt32> x [24]) [31]) 19362 for { 19363 _ = v.Args[1] 19364 x := v.Args[0] 19365 v_1 := v.Args[1] 19366 if v_1.Op != OpConst64 { 19367 break 19368 } 19369 c := v_1.AuxInt 19370 if !(uint64(c) >= 8) { 19371 break 19372 } 19373 v.reset(OpARMSRAconst) 19374 v.AuxInt = 31 19375 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32) 19376 v0.AuxInt = 24 19377 v0.AddArg(x) 19378 v.AddArg(v0) 19379 return true 19380 } 19381 return false 19382 } 19383 func rewriteValueARM_OpRsh8x8_0(v *Value) bool { 19384 b := v.Block 19385 _ = b 19386 typ := &b.Func.Config.Types 19387 _ = typ 19388 // match: (Rsh8x8 x y) 19389 // cond: 19390 // result: (SRA (SignExt8to32 x) (ZeroExt8to32 y)) 19391 for { 19392 _ = v.Args[1] 19393 x := v.Args[0] 19394 y := v.Args[1] 19395 v.reset(OpARMSRA) 19396 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 19397 v0.AddArg(x) 19398 v.AddArg(v0) 19399 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 19400 v1.AddArg(y) 19401 v.AddArg(v1) 19402 return true 19403 } 19404 } 19405 func rewriteValueARM_OpSelect0_0(v *Value) bool { 19406 // match: (Select0 (CALLudiv x (MOVWconst [1]))) 19407 // cond: 19408 // result: x 19409 for { 19410 v_0 := v.Args[0] 19411 if v_0.Op != OpARMCALLudiv { 19412 break 19413 } 19414 _ = v_0.Args[1] 19415 x := v_0.Args[0] 19416 v_0_1 := v_0.Args[1] 19417 if v_0_1.Op != OpARMMOVWconst { 19418 break 19419 } 19420 if v_0_1.AuxInt != 1 { 19421 break 19422 } 19423 v.reset(OpCopy) 19424 v.Type = x.Type 19425 v.AddArg(x) 19426 return true 19427 } 19428 // match: (Select0 (CALLudiv x (MOVWconst [c]))) 19429 // cond: isPowerOfTwo(c) 19430 // result: (SRLconst [log2(c)] x) 19431 for { 19432 v_0 := v.Args[0] 19433 if v_0.Op != OpARMCALLudiv { 19434 break 19435 } 19436 _ = v_0.Args[1] 19437 x := v_0.Args[0] 19438 v_0_1 := v_0.Args[1] 19439 if v_0_1.Op != OpARMMOVWconst { 19440 break 19441 } 19442 c := v_0_1.AuxInt 19443 if !(isPowerOfTwo(c)) { 19444 break 19445 } 19446 v.reset(OpARMSRLconst) 19447 v.AuxInt = log2(c) 19448 v.AddArg(x) 19449 return true 19450 } 19451 // match: (Select0 (CALLudiv (MOVWconst [c]) (MOVWconst [d]))) 19452 // cond: 19453 // result: (MOVWconst [int64(uint32(c)/uint32(d))]) 19454 for { 19455 v_0 := v.Args[0] 19456 if v_0.Op != OpARMCALLudiv { 19457 break 19458 } 19459 _ = v_0.Args[1] 19460 v_0_0 := v_0.Args[0] 19461 if v_0_0.Op != OpARMMOVWconst { 19462 break 19463 } 19464 c := v_0_0.AuxInt 19465 v_0_1 := v_0.Args[1] 19466 if v_0_1.Op != OpARMMOVWconst { 19467 break 19468 } 19469 d := v_0_1.AuxInt 19470 v.reset(OpARMMOVWconst) 19471 v.AuxInt = int64(uint32(c) / uint32(d)) 19472 return true 19473 } 19474 return false 19475 } 19476 func rewriteValueARM_OpSelect1_0(v *Value) bool { 19477 // match: (Select1 (CALLudiv _ (MOVWconst [1]))) 19478 // cond: 19479 // result: (MOVWconst [0]) 19480 for { 19481 v_0 := v.Args[0] 19482 if v_0.Op != OpARMCALLudiv { 19483 break 19484 } 19485 _ = v_0.Args[1] 19486 v_0_1 := v_0.Args[1] 19487 if v_0_1.Op != OpARMMOVWconst { 19488 break 19489 } 19490 if v_0_1.AuxInt != 1 { 19491 break 19492 } 19493 v.reset(OpARMMOVWconst) 19494 v.AuxInt = 0 19495 return true 19496 } 19497 // match: (Select1 (CALLudiv x (MOVWconst [c]))) 19498 // cond: isPowerOfTwo(c) 19499 // result: (ANDconst [c-1] x) 19500 for { 19501 v_0 := v.Args[0] 19502 if v_0.Op != OpARMCALLudiv { 19503 break 19504 } 19505 _ = v_0.Args[1] 19506 x := v_0.Args[0] 19507 v_0_1 := v_0.Args[1] 19508 if v_0_1.Op != OpARMMOVWconst { 19509 break 19510 } 19511 c := v_0_1.AuxInt 19512 if !(isPowerOfTwo(c)) { 19513 break 19514 } 19515 v.reset(OpARMANDconst) 19516 v.AuxInt = c - 1 19517 v.AddArg(x) 19518 return true 19519 } 19520 // match: (Select1 (CALLudiv (MOVWconst [c]) (MOVWconst [d]))) 19521 // cond: 19522 // result: (MOVWconst [int64(uint32(c)%uint32(d))]) 19523 for { 19524 v_0 := v.Args[0] 19525 if v_0.Op != OpARMCALLudiv { 19526 break 19527 } 19528 _ = v_0.Args[1] 19529 v_0_0 := v_0.Args[0] 19530 if v_0_0.Op != OpARMMOVWconst { 19531 break 19532 } 19533 c := v_0_0.AuxInt 19534 v_0_1 := v_0.Args[1] 19535 if v_0_1.Op != OpARMMOVWconst { 19536 break 19537 } 19538 d := v_0_1.AuxInt 19539 v.reset(OpARMMOVWconst) 19540 v.AuxInt = int64(uint32(c) % uint32(d)) 19541 return true 19542 } 19543 return false 19544 } 19545 func rewriteValueARM_OpSignExt16to32_0(v *Value) bool { 19546 // match: (SignExt16to32 x) 19547 // cond: 19548 // result: (MOVHreg x) 19549 for { 19550 x := v.Args[0] 19551 v.reset(OpARMMOVHreg) 19552 v.AddArg(x) 19553 return true 19554 } 19555 } 19556 func rewriteValueARM_OpSignExt8to16_0(v *Value) bool { 19557 // match: (SignExt8to16 x) 19558 // cond: 19559 // result: (MOVBreg x) 19560 for { 19561 x := v.Args[0] 19562 v.reset(OpARMMOVBreg) 19563 v.AddArg(x) 19564 return true 19565 } 19566 } 19567 func rewriteValueARM_OpSignExt8to32_0(v *Value) bool { 19568 // match: (SignExt8to32 x) 19569 // cond: 19570 // result: (MOVBreg x) 19571 for { 19572 x := v.Args[0] 19573 v.reset(OpARMMOVBreg) 19574 v.AddArg(x) 19575 return true 19576 } 19577 } 19578 func rewriteValueARM_OpSignmask_0(v *Value) bool { 19579 // match: (Signmask x) 19580 // cond: 19581 // result: (SRAconst x [31]) 19582 for { 19583 x := v.Args[0] 19584 v.reset(OpARMSRAconst) 19585 v.AuxInt = 31 19586 v.AddArg(x) 19587 return true 19588 } 19589 } 19590 func rewriteValueARM_OpSlicemask_0(v *Value) bool { 19591 b := v.Block 19592 _ = b 19593 // match: (Slicemask <t> x) 19594 // cond: 19595 // result: (SRAconst (RSBconst <t> [0] x) [31]) 19596 for { 19597 t := v.Type 19598 x := v.Args[0] 19599 v.reset(OpARMSRAconst) 19600 v.AuxInt = 31 19601 v0 := b.NewValue0(v.Pos, OpARMRSBconst, t) 19602 v0.AuxInt = 0 19603 v0.AddArg(x) 19604 v.AddArg(v0) 19605 return true 19606 } 19607 } 19608 func rewriteValueARM_OpSqrt_0(v *Value) bool { 19609 // match: (Sqrt x) 19610 // cond: 19611 // result: (SQRTD x) 19612 for { 19613 x := v.Args[0] 19614 v.reset(OpARMSQRTD) 19615 v.AddArg(x) 19616 return true 19617 } 19618 } 19619 func rewriteValueARM_OpStaticCall_0(v *Value) bool { 19620 // match: (StaticCall [argwid] {target} mem) 19621 // cond: 19622 // result: (CALLstatic [argwid] {target} mem) 19623 for { 19624 argwid := v.AuxInt 19625 target := v.Aux 19626 mem := v.Args[0] 19627 v.reset(OpARMCALLstatic) 19628 v.AuxInt = argwid 19629 v.Aux = target 19630 v.AddArg(mem) 19631 return true 19632 } 19633 } 19634 func rewriteValueARM_OpStore_0(v *Value) bool { 19635 // match: (Store {t} ptr val mem) 19636 // cond: t.(*types.Type).Size() == 1 19637 // result: (MOVBstore ptr val mem) 19638 for { 19639 t := v.Aux 19640 _ = v.Args[2] 19641 ptr := v.Args[0] 19642 val := v.Args[1] 19643 mem := v.Args[2] 19644 if !(t.(*types.Type).Size() == 1) { 19645 break 19646 } 19647 v.reset(OpARMMOVBstore) 19648 v.AddArg(ptr) 19649 v.AddArg(val) 19650 v.AddArg(mem) 19651 return true 19652 } 19653 // match: (Store {t} ptr val mem) 19654 // cond: t.(*types.Type).Size() == 2 19655 // result: (MOVHstore ptr val mem) 19656 for { 19657 t := v.Aux 19658 _ = v.Args[2] 19659 ptr := v.Args[0] 19660 val := v.Args[1] 19661 mem := v.Args[2] 19662 if !(t.(*types.Type).Size() == 2) { 19663 break 19664 } 19665 v.reset(OpARMMOVHstore) 19666 v.AddArg(ptr) 19667 v.AddArg(val) 19668 v.AddArg(mem) 19669 return true 19670 } 19671 // match: (Store {t} ptr val mem) 19672 // cond: t.(*types.Type).Size() == 4 && !is32BitFloat(val.Type) 19673 // result: (MOVWstore ptr val mem) 19674 for { 19675 t := v.Aux 19676 _ = v.Args[2] 19677 ptr := v.Args[0] 19678 val := v.Args[1] 19679 mem := v.Args[2] 19680 if !(t.(*types.Type).Size() == 4 && !is32BitFloat(val.Type)) { 19681 break 19682 } 19683 v.reset(OpARMMOVWstore) 19684 v.AddArg(ptr) 19685 v.AddArg(val) 19686 v.AddArg(mem) 19687 return true 19688 } 19689 // match: (Store {t} ptr val mem) 19690 // cond: t.(*types.Type).Size() == 4 && is32BitFloat(val.Type) 19691 // result: (MOVFstore ptr val mem) 19692 for { 19693 t := v.Aux 19694 _ = v.Args[2] 19695 ptr := v.Args[0] 19696 val := v.Args[1] 19697 mem := v.Args[2] 19698 if !(t.(*types.Type).Size() == 4 && is32BitFloat(val.Type)) { 19699 break 19700 } 19701 v.reset(OpARMMOVFstore) 19702 v.AddArg(ptr) 19703 v.AddArg(val) 19704 v.AddArg(mem) 19705 return true 19706 } 19707 // match: (Store {t} ptr val mem) 19708 // cond: t.(*types.Type).Size() == 8 && is64BitFloat(val.Type) 19709 // result: (MOVDstore ptr val mem) 19710 for { 19711 t := v.Aux 19712 _ = v.Args[2] 19713 ptr := v.Args[0] 19714 val := v.Args[1] 19715 mem := v.Args[2] 19716 if !(t.(*types.Type).Size() == 8 && is64BitFloat(val.Type)) { 19717 break 19718 } 19719 v.reset(OpARMMOVDstore) 19720 v.AddArg(ptr) 19721 v.AddArg(val) 19722 v.AddArg(mem) 19723 return true 19724 } 19725 return false 19726 } 19727 func rewriteValueARM_OpSub16_0(v *Value) bool { 19728 // match: (Sub16 x y) 19729 // cond: 19730 // result: (SUB x y) 19731 for { 19732 _ = v.Args[1] 19733 x := v.Args[0] 19734 y := v.Args[1] 19735 v.reset(OpARMSUB) 19736 v.AddArg(x) 19737 v.AddArg(y) 19738 return true 19739 } 19740 } 19741 func rewriteValueARM_OpSub32_0(v *Value) bool { 19742 // match: (Sub32 x y) 19743 // cond: 19744 // result: (SUB x y) 19745 for { 19746 _ = v.Args[1] 19747 x := v.Args[0] 19748 y := v.Args[1] 19749 v.reset(OpARMSUB) 19750 v.AddArg(x) 19751 v.AddArg(y) 19752 return true 19753 } 19754 } 19755 func rewriteValueARM_OpSub32F_0(v *Value) bool { 19756 // match: (Sub32F x y) 19757 // cond: 19758 // result: (SUBF x y) 19759 for { 19760 _ = v.Args[1] 19761 x := v.Args[0] 19762 y := v.Args[1] 19763 v.reset(OpARMSUBF) 19764 v.AddArg(x) 19765 v.AddArg(y) 19766 return true 19767 } 19768 } 19769 func rewriteValueARM_OpSub32carry_0(v *Value) bool { 19770 // match: (Sub32carry x y) 19771 // cond: 19772 // result: (SUBS x y) 19773 for { 19774 _ = v.Args[1] 19775 x := v.Args[0] 19776 y := v.Args[1] 19777 v.reset(OpARMSUBS) 19778 v.AddArg(x) 19779 v.AddArg(y) 19780 return true 19781 } 19782 } 19783 func rewriteValueARM_OpSub32withcarry_0(v *Value) bool { 19784 // match: (Sub32withcarry x y c) 19785 // cond: 19786 // result: (SBC x y c) 19787 for { 19788 _ = v.Args[2] 19789 x := v.Args[0] 19790 y := v.Args[1] 19791 c := v.Args[2] 19792 v.reset(OpARMSBC) 19793 v.AddArg(x) 19794 v.AddArg(y) 19795 v.AddArg(c) 19796 return true 19797 } 19798 } 19799 func rewriteValueARM_OpSub64F_0(v *Value) bool { 19800 // match: (Sub64F x y) 19801 // cond: 19802 // result: (SUBD x y) 19803 for { 19804 _ = v.Args[1] 19805 x := v.Args[0] 19806 y := v.Args[1] 19807 v.reset(OpARMSUBD) 19808 v.AddArg(x) 19809 v.AddArg(y) 19810 return true 19811 } 19812 } 19813 func rewriteValueARM_OpSub8_0(v *Value) bool { 19814 // match: (Sub8 x y) 19815 // cond: 19816 // result: (SUB x y) 19817 for { 19818 _ = v.Args[1] 19819 x := v.Args[0] 19820 y := v.Args[1] 19821 v.reset(OpARMSUB) 19822 v.AddArg(x) 19823 v.AddArg(y) 19824 return true 19825 } 19826 } 19827 func rewriteValueARM_OpSubPtr_0(v *Value) bool { 19828 // match: (SubPtr x y) 19829 // cond: 19830 // result: (SUB x y) 19831 for { 19832 _ = v.Args[1] 19833 x := v.Args[0] 19834 y := v.Args[1] 19835 v.reset(OpARMSUB) 19836 v.AddArg(x) 19837 v.AddArg(y) 19838 return true 19839 } 19840 } 19841 func rewriteValueARM_OpTrunc16to8_0(v *Value) bool { 19842 // match: (Trunc16to8 x) 19843 // cond: 19844 // result: x 19845 for { 19846 x := v.Args[0] 19847 v.reset(OpCopy) 19848 v.Type = x.Type 19849 v.AddArg(x) 19850 return true 19851 } 19852 } 19853 func rewriteValueARM_OpTrunc32to16_0(v *Value) bool { 19854 // match: (Trunc32to16 x) 19855 // cond: 19856 // result: x 19857 for { 19858 x := v.Args[0] 19859 v.reset(OpCopy) 19860 v.Type = x.Type 19861 v.AddArg(x) 19862 return true 19863 } 19864 } 19865 func rewriteValueARM_OpTrunc32to8_0(v *Value) bool { 19866 // match: (Trunc32to8 x) 19867 // cond: 19868 // result: x 19869 for { 19870 x := v.Args[0] 19871 v.reset(OpCopy) 19872 v.Type = x.Type 19873 v.AddArg(x) 19874 return true 19875 } 19876 } 19877 func rewriteValueARM_OpXor16_0(v *Value) bool { 19878 // match: (Xor16 x y) 19879 // cond: 19880 // result: (XOR x y) 19881 for { 19882 _ = v.Args[1] 19883 x := v.Args[0] 19884 y := v.Args[1] 19885 v.reset(OpARMXOR) 19886 v.AddArg(x) 19887 v.AddArg(y) 19888 return true 19889 } 19890 } 19891 func rewriteValueARM_OpXor32_0(v *Value) bool { 19892 // match: (Xor32 x y) 19893 // cond: 19894 // result: (XOR x y) 19895 for { 19896 _ = v.Args[1] 19897 x := v.Args[0] 19898 y := v.Args[1] 19899 v.reset(OpARMXOR) 19900 v.AddArg(x) 19901 v.AddArg(y) 19902 return true 19903 } 19904 } 19905 func rewriteValueARM_OpXor8_0(v *Value) bool { 19906 // match: (Xor8 x y) 19907 // cond: 19908 // result: (XOR x y) 19909 for { 19910 _ = v.Args[1] 19911 x := v.Args[0] 19912 y := v.Args[1] 19913 v.reset(OpARMXOR) 19914 v.AddArg(x) 19915 v.AddArg(y) 19916 return true 19917 } 19918 } 19919 func rewriteValueARM_OpZero_0(v *Value) bool { 19920 b := v.Block 19921 _ = b 19922 config := b.Func.Config 19923 _ = config 19924 typ := &b.Func.Config.Types 19925 _ = typ 19926 // match: (Zero [0] _ mem) 19927 // cond: 19928 // result: mem 19929 for { 19930 if v.AuxInt != 0 { 19931 break 19932 } 19933 _ = v.Args[1] 19934 mem := v.Args[1] 19935 v.reset(OpCopy) 19936 v.Type = mem.Type 19937 v.AddArg(mem) 19938 return true 19939 } 19940 // match: (Zero [1] ptr mem) 19941 // cond: 19942 // result: (MOVBstore ptr (MOVWconst [0]) mem) 19943 for { 19944 if v.AuxInt != 1 { 19945 break 19946 } 19947 _ = v.Args[1] 19948 ptr := v.Args[0] 19949 mem := v.Args[1] 19950 v.reset(OpARMMOVBstore) 19951 v.AddArg(ptr) 19952 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 19953 v0.AuxInt = 0 19954 v.AddArg(v0) 19955 v.AddArg(mem) 19956 return true 19957 } 19958 // match: (Zero [2] {t} ptr mem) 19959 // cond: t.(*types.Type).Alignment()%2 == 0 19960 // result: (MOVHstore ptr (MOVWconst [0]) mem) 19961 for { 19962 if v.AuxInt != 2 { 19963 break 19964 } 19965 t := v.Aux 19966 _ = v.Args[1] 19967 ptr := v.Args[0] 19968 mem := v.Args[1] 19969 if !(t.(*types.Type).Alignment()%2 == 0) { 19970 break 19971 } 19972 v.reset(OpARMMOVHstore) 19973 v.AddArg(ptr) 19974 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 19975 v0.AuxInt = 0 19976 v.AddArg(v0) 19977 v.AddArg(mem) 19978 return true 19979 } 19980 // match: (Zero [2] ptr mem) 19981 // cond: 19982 // result: (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem)) 19983 for { 19984 if v.AuxInt != 2 { 19985 break 19986 } 19987 _ = v.Args[1] 19988 ptr := v.Args[0] 19989 mem := v.Args[1] 19990 v.reset(OpARMMOVBstore) 19991 v.AuxInt = 1 19992 v.AddArg(ptr) 19993 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 19994 v0.AuxInt = 0 19995 v.AddArg(v0) 19996 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 19997 v1.AuxInt = 0 19998 v1.AddArg(ptr) 19999 v2 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 20000 v2.AuxInt = 0 20001 v1.AddArg(v2) 20002 v1.AddArg(mem) 20003 v.AddArg(v1) 20004 return true 20005 } 20006 // match: (Zero [4] {t} ptr mem) 20007 // cond: t.(*types.Type).Alignment()%4 == 0 20008 // result: (MOVWstore ptr (MOVWconst [0]) mem) 20009 for { 20010 if v.AuxInt != 4 { 20011 break 20012 } 20013 t := v.Aux 20014 _ = v.Args[1] 20015 ptr := v.Args[0] 20016 mem := v.Args[1] 20017 if !(t.(*types.Type).Alignment()%4 == 0) { 20018 break 20019 } 20020 v.reset(OpARMMOVWstore) 20021 v.AddArg(ptr) 20022 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 20023 v0.AuxInt = 0 20024 v.AddArg(v0) 20025 v.AddArg(mem) 20026 return true 20027 } 20028 // match: (Zero [4] {t} ptr mem) 20029 // cond: t.(*types.Type).Alignment()%2 == 0 20030 // result: (MOVHstore [2] ptr (MOVWconst [0]) (MOVHstore [0] ptr (MOVWconst [0]) mem)) 20031 for { 20032 if v.AuxInt != 4 { 20033 break 20034 } 20035 t := v.Aux 20036 _ = v.Args[1] 20037 ptr := v.Args[0] 20038 mem := v.Args[1] 20039 if !(t.(*types.Type).Alignment()%2 == 0) { 20040 break 20041 } 20042 v.reset(OpARMMOVHstore) 20043 v.AuxInt = 2 20044 v.AddArg(ptr) 20045 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 20046 v0.AuxInt = 0 20047 v.AddArg(v0) 20048 v1 := b.NewValue0(v.Pos, OpARMMOVHstore, types.TypeMem) 20049 v1.AuxInt = 0 20050 v1.AddArg(ptr) 20051 v2 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 20052 v2.AuxInt = 0 20053 v1.AddArg(v2) 20054 v1.AddArg(mem) 20055 v.AddArg(v1) 20056 return true 20057 } 20058 // match: (Zero [4] ptr mem) 20059 // cond: 20060 // result: (MOVBstore [3] ptr (MOVWconst [0]) (MOVBstore [2] ptr (MOVWconst [0]) (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem)))) 20061 for { 20062 if v.AuxInt != 4 { 20063 break 20064 } 20065 _ = v.Args[1] 20066 ptr := v.Args[0] 20067 mem := v.Args[1] 20068 v.reset(OpARMMOVBstore) 20069 v.AuxInt = 3 20070 v.AddArg(ptr) 20071 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 20072 v0.AuxInt = 0 20073 v.AddArg(v0) 20074 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 20075 v1.AuxInt = 2 20076 v1.AddArg(ptr) 20077 v2 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 20078 v2.AuxInt = 0 20079 v1.AddArg(v2) 20080 v3 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 20081 v3.AuxInt = 1 20082 v3.AddArg(ptr) 20083 v4 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 20084 v4.AuxInt = 0 20085 v3.AddArg(v4) 20086 v5 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 20087 v5.AuxInt = 0 20088 v5.AddArg(ptr) 20089 v6 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 20090 v6.AuxInt = 0 20091 v5.AddArg(v6) 20092 v5.AddArg(mem) 20093 v3.AddArg(v5) 20094 v1.AddArg(v3) 20095 v.AddArg(v1) 20096 return true 20097 } 20098 // match: (Zero [3] ptr mem) 20099 // cond: 20100 // result: (MOVBstore [2] ptr (MOVWconst [0]) (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem))) 20101 for { 20102 if v.AuxInt != 3 { 20103 break 20104 } 20105 _ = v.Args[1] 20106 ptr := v.Args[0] 20107 mem := v.Args[1] 20108 v.reset(OpARMMOVBstore) 20109 v.AuxInt = 2 20110 v.AddArg(ptr) 20111 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 20112 v0.AuxInt = 0 20113 v.AddArg(v0) 20114 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 20115 v1.AuxInt = 1 20116 v1.AddArg(ptr) 20117 v2 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 20118 v2.AuxInt = 0 20119 v1.AddArg(v2) 20120 v3 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 20121 v3.AuxInt = 0 20122 v3.AddArg(ptr) 20123 v4 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 20124 v4.AuxInt = 0 20125 v3.AddArg(v4) 20126 v3.AddArg(mem) 20127 v1.AddArg(v3) 20128 v.AddArg(v1) 20129 return true 20130 } 20131 // match: (Zero [s] {t} ptr mem) 20132 // cond: s%4 == 0 && s > 4 && s <= 512 && t.(*types.Type).Alignment()%4 == 0 && !config.noDuffDevice 20133 // result: (DUFFZERO [4 * (128 - int64(s/4))] ptr (MOVWconst [0]) mem) 20134 for { 20135 s := v.AuxInt 20136 t := v.Aux 20137 _ = v.Args[1] 20138 ptr := v.Args[0] 20139 mem := v.Args[1] 20140 if !(s%4 == 0 && s > 4 && s <= 512 && t.(*types.Type).Alignment()%4 == 0 && !config.noDuffDevice) { 20141 break 20142 } 20143 v.reset(OpARMDUFFZERO) 20144 v.AuxInt = 4 * (128 - int64(s/4)) 20145 v.AddArg(ptr) 20146 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 20147 v0.AuxInt = 0 20148 v.AddArg(v0) 20149 v.AddArg(mem) 20150 return true 20151 } 20152 // match: (Zero [s] {t} ptr mem) 20153 // cond: (s > 512 || config.noDuffDevice) || t.(*types.Type).Alignment()%4 != 0 20154 // result: (LoweredZero [t.(*types.Type).Alignment()] ptr (ADDconst <ptr.Type> ptr [s-moveSize(t.(*types.Type).Alignment(), config)]) (MOVWconst [0]) mem) 20155 for { 20156 s := v.AuxInt 20157 t := v.Aux 20158 _ = v.Args[1] 20159 ptr := v.Args[0] 20160 mem := v.Args[1] 20161 if !((s > 512 || config.noDuffDevice) || t.(*types.Type).Alignment()%4 != 0) { 20162 break 20163 } 20164 v.reset(OpARMLoweredZero) 20165 v.AuxInt = t.(*types.Type).Alignment() 20166 v.AddArg(ptr) 20167 v0 := b.NewValue0(v.Pos, OpARMADDconst, ptr.Type) 20168 v0.AuxInt = s - moveSize(t.(*types.Type).Alignment(), config) 20169 v0.AddArg(ptr) 20170 v.AddArg(v0) 20171 v1 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 20172 v1.AuxInt = 0 20173 v.AddArg(v1) 20174 v.AddArg(mem) 20175 return true 20176 } 20177 return false 20178 } 20179 func rewriteValueARM_OpZeroExt16to32_0(v *Value) bool { 20180 // match: (ZeroExt16to32 x) 20181 // cond: 20182 // result: (MOVHUreg x) 20183 for { 20184 x := v.Args[0] 20185 v.reset(OpARMMOVHUreg) 20186 v.AddArg(x) 20187 return true 20188 } 20189 } 20190 func rewriteValueARM_OpZeroExt8to16_0(v *Value) bool { 20191 // match: (ZeroExt8to16 x) 20192 // cond: 20193 // result: (MOVBUreg x) 20194 for { 20195 x := v.Args[0] 20196 v.reset(OpARMMOVBUreg) 20197 v.AddArg(x) 20198 return true 20199 } 20200 } 20201 func rewriteValueARM_OpZeroExt8to32_0(v *Value) bool { 20202 // match: (ZeroExt8to32 x) 20203 // cond: 20204 // result: (MOVBUreg x) 20205 for { 20206 x := v.Args[0] 20207 v.reset(OpARMMOVBUreg) 20208 v.AddArg(x) 20209 return true 20210 } 20211 } 20212 func rewriteValueARM_OpZeromask_0(v *Value) bool { 20213 b := v.Block 20214 _ = b 20215 typ := &b.Func.Config.Types 20216 _ = typ 20217 // match: (Zeromask x) 20218 // cond: 20219 // result: (SRAconst (RSBshiftRL <typ.Int32> x x [1]) [31]) 20220 for { 20221 x := v.Args[0] 20222 v.reset(OpARMSRAconst) 20223 v.AuxInt = 31 20224 v0 := b.NewValue0(v.Pos, OpARMRSBshiftRL, typ.Int32) 20225 v0.AuxInt = 1 20226 v0.AddArg(x) 20227 v0.AddArg(x) 20228 v.AddArg(v0) 20229 return true 20230 } 20231 } 20232 func rewriteBlockARM(b *Block) bool { 20233 config := b.Func.Config 20234 _ = config 20235 fe := b.Func.fe 20236 _ = fe 20237 typ := &config.Types 20238 _ = typ 20239 switch b.Kind { 20240 case BlockARMEQ: 20241 // match: (EQ (FlagEQ) yes no) 20242 // cond: 20243 // result: (First nil yes no) 20244 for { 20245 v := b.Control 20246 if v.Op != OpARMFlagEQ { 20247 break 20248 } 20249 b.Kind = BlockFirst 20250 b.SetControl(nil) 20251 b.Aux = nil 20252 return true 20253 } 20254 // match: (EQ (FlagLT_ULT) yes no) 20255 // cond: 20256 // result: (First nil no yes) 20257 for { 20258 v := b.Control 20259 if v.Op != OpARMFlagLT_ULT { 20260 break 20261 } 20262 b.Kind = BlockFirst 20263 b.SetControl(nil) 20264 b.Aux = nil 20265 b.swapSuccessors() 20266 return true 20267 } 20268 // match: (EQ (FlagLT_UGT) yes no) 20269 // cond: 20270 // result: (First nil no yes) 20271 for { 20272 v := b.Control 20273 if v.Op != OpARMFlagLT_UGT { 20274 break 20275 } 20276 b.Kind = BlockFirst 20277 b.SetControl(nil) 20278 b.Aux = nil 20279 b.swapSuccessors() 20280 return true 20281 } 20282 // match: (EQ (FlagGT_ULT) yes no) 20283 // cond: 20284 // result: (First nil no yes) 20285 for { 20286 v := b.Control 20287 if v.Op != OpARMFlagGT_ULT { 20288 break 20289 } 20290 b.Kind = BlockFirst 20291 b.SetControl(nil) 20292 b.Aux = nil 20293 b.swapSuccessors() 20294 return true 20295 } 20296 // match: (EQ (FlagGT_UGT) yes no) 20297 // cond: 20298 // result: (First nil no yes) 20299 for { 20300 v := b.Control 20301 if v.Op != OpARMFlagGT_UGT { 20302 break 20303 } 20304 b.Kind = BlockFirst 20305 b.SetControl(nil) 20306 b.Aux = nil 20307 b.swapSuccessors() 20308 return true 20309 } 20310 // match: (EQ (InvertFlags cmp) yes no) 20311 // cond: 20312 // result: (EQ cmp yes no) 20313 for { 20314 v := b.Control 20315 if v.Op != OpARMInvertFlags { 20316 break 20317 } 20318 cmp := v.Args[0] 20319 b.Kind = BlockARMEQ 20320 b.SetControl(cmp) 20321 b.Aux = nil 20322 return true 20323 } 20324 case BlockARMGE: 20325 // match: (GE (FlagEQ) yes no) 20326 // cond: 20327 // result: (First nil yes no) 20328 for { 20329 v := b.Control 20330 if v.Op != OpARMFlagEQ { 20331 break 20332 } 20333 b.Kind = BlockFirst 20334 b.SetControl(nil) 20335 b.Aux = nil 20336 return true 20337 } 20338 // match: (GE (FlagLT_ULT) yes no) 20339 // cond: 20340 // result: (First nil no yes) 20341 for { 20342 v := b.Control 20343 if v.Op != OpARMFlagLT_ULT { 20344 break 20345 } 20346 b.Kind = BlockFirst 20347 b.SetControl(nil) 20348 b.Aux = nil 20349 b.swapSuccessors() 20350 return true 20351 } 20352 // match: (GE (FlagLT_UGT) yes no) 20353 // cond: 20354 // result: (First nil no yes) 20355 for { 20356 v := b.Control 20357 if v.Op != OpARMFlagLT_UGT { 20358 break 20359 } 20360 b.Kind = BlockFirst 20361 b.SetControl(nil) 20362 b.Aux = nil 20363 b.swapSuccessors() 20364 return true 20365 } 20366 // match: (GE (FlagGT_ULT) yes no) 20367 // cond: 20368 // result: (First nil yes no) 20369 for { 20370 v := b.Control 20371 if v.Op != OpARMFlagGT_ULT { 20372 break 20373 } 20374 b.Kind = BlockFirst 20375 b.SetControl(nil) 20376 b.Aux = nil 20377 return true 20378 } 20379 // match: (GE (FlagGT_UGT) yes no) 20380 // cond: 20381 // result: (First nil yes no) 20382 for { 20383 v := b.Control 20384 if v.Op != OpARMFlagGT_UGT { 20385 break 20386 } 20387 b.Kind = BlockFirst 20388 b.SetControl(nil) 20389 b.Aux = nil 20390 return true 20391 } 20392 // match: (GE (InvertFlags cmp) yes no) 20393 // cond: 20394 // result: (LE cmp yes no) 20395 for { 20396 v := b.Control 20397 if v.Op != OpARMInvertFlags { 20398 break 20399 } 20400 cmp := v.Args[0] 20401 b.Kind = BlockARMLE 20402 b.SetControl(cmp) 20403 b.Aux = nil 20404 return true 20405 } 20406 case BlockARMGT: 20407 // match: (GT (FlagEQ) yes no) 20408 // cond: 20409 // result: (First nil no yes) 20410 for { 20411 v := b.Control 20412 if v.Op != OpARMFlagEQ { 20413 break 20414 } 20415 b.Kind = BlockFirst 20416 b.SetControl(nil) 20417 b.Aux = nil 20418 b.swapSuccessors() 20419 return true 20420 } 20421 // match: (GT (FlagLT_ULT) yes no) 20422 // cond: 20423 // result: (First nil no yes) 20424 for { 20425 v := b.Control 20426 if v.Op != OpARMFlagLT_ULT { 20427 break 20428 } 20429 b.Kind = BlockFirst 20430 b.SetControl(nil) 20431 b.Aux = nil 20432 b.swapSuccessors() 20433 return true 20434 } 20435 // match: (GT (FlagLT_UGT) yes no) 20436 // cond: 20437 // result: (First nil no yes) 20438 for { 20439 v := b.Control 20440 if v.Op != OpARMFlagLT_UGT { 20441 break 20442 } 20443 b.Kind = BlockFirst 20444 b.SetControl(nil) 20445 b.Aux = nil 20446 b.swapSuccessors() 20447 return true 20448 } 20449 // match: (GT (FlagGT_ULT) yes no) 20450 // cond: 20451 // result: (First nil yes no) 20452 for { 20453 v := b.Control 20454 if v.Op != OpARMFlagGT_ULT { 20455 break 20456 } 20457 b.Kind = BlockFirst 20458 b.SetControl(nil) 20459 b.Aux = nil 20460 return true 20461 } 20462 // match: (GT (FlagGT_UGT) yes no) 20463 // cond: 20464 // result: (First nil yes no) 20465 for { 20466 v := b.Control 20467 if v.Op != OpARMFlagGT_UGT { 20468 break 20469 } 20470 b.Kind = BlockFirst 20471 b.SetControl(nil) 20472 b.Aux = nil 20473 return true 20474 } 20475 // match: (GT (InvertFlags cmp) yes no) 20476 // cond: 20477 // result: (LT cmp yes no) 20478 for { 20479 v := b.Control 20480 if v.Op != OpARMInvertFlags { 20481 break 20482 } 20483 cmp := v.Args[0] 20484 b.Kind = BlockARMLT 20485 b.SetControl(cmp) 20486 b.Aux = nil 20487 return true 20488 } 20489 case BlockIf: 20490 // match: (If (Equal cc) yes no) 20491 // cond: 20492 // result: (EQ cc yes no) 20493 for { 20494 v := b.Control 20495 if v.Op != OpARMEqual { 20496 break 20497 } 20498 cc := v.Args[0] 20499 b.Kind = BlockARMEQ 20500 b.SetControl(cc) 20501 b.Aux = nil 20502 return true 20503 } 20504 // match: (If (NotEqual cc) yes no) 20505 // cond: 20506 // result: (NE cc yes no) 20507 for { 20508 v := b.Control 20509 if v.Op != OpARMNotEqual { 20510 break 20511 } 20512 cc := v.Args[0] 20513 b.Kind = BlockARMNE 20514 b.SetControl(cc) 20515 b.Aux = nil 20516 return true 20517 } 20518 // match: (If (LessThan cc) yes no) 20519 // cond: 20520 // result: (LT cc yes no) 20521 for { 20522 v := b.Control 20523 if v.Op != OpARMLessThan { 20524 break 20525 } 20526 cc := v.Args[0] 20527 b.Kind = BlockARMLT 20528 b.SetControl(cc) 20529 b.Aux = nil 20530 return true 20531 } 20532 // match: (If (LessThanU cc) yes no) 20533 // cond: 20534 // result: (ULT cc yes no) 20535 for { 20536 v := b.Control 20537 if v.Op != OpARMLessThanU { 20538 break 20539 } 20540 cc := v.Args[0] 20541 b.Kind = BlockARMULT 20542 b.SetControl(cc) 20543 b.Aux = nil 20544 return true 20545 } 20546 // match: (If (LessEqual cc) yes no) 20547 // cond: 20548 // result: (LE cc yes no) 20549 for { 20550 v := b.Control 20551 if v.Op != OpARMLessEqual { 20552 break 20553 } 20554 cc := v.Args[0] 20555 b.Kind = BlockARMLE 20556 b.SetControl(cc) 20557 b.Aux = nil 20558 return true 20559 } 20560 // match: (If (LessEqualU cc) yes no) 20561 // cond: 20562 // result: (ULE cc yes no) 20563 for { 20564 v := b.Control 20565 if v.Op != OpARMLessEqualU { 20566 break 20567 } 20568 cc := v.Args[0] 20569 b.Kind = BlockARMULE 20570 b.SetControl(cc) 20571 b.Aux = nil 20572 return true 20573 } 20574 // match: (If (GreaterThan cc) yes no) 20575 // cond: 20576 // result: (GT cc yes no) 20577 for { 20578 v := b.Control 20579 if v.Op != OpARMGreaterThan { 20580 break 20581 } 20582 cc := v.Args[0] 20583 b.Kind = BlockARMGT 20584 b.SetControl(cc) 20585 b.Aux = nil 20586 return true 20587 } 20588 // match: (If (GreaterThanU cc) yes no) 20589 // cond: 20590 // result: (UGT cc yes no) 20591 for { 20592 v := b.Control 20593 if v.Op != OpARMGreaterThanU { 20594 break 20595 } 20596 cc := v.Args[0] 20597 b.Kind = BlockARMUGT 20598 b.SetControl(cc) 20599 b.Aux = nil 20600 return true 20601 } 20602 // match: (If (GreaterEqual cc) yes no) 20603 // cond: 20604 // result: (GE cc yes no) 20605 for { 20606 v := b.Control 20607 if v.Op != OpARMGreaterEqual { 20608 break 20609 } 20610 cc := v.Args[0] 20611 b.Kind = BlockARMGE 20612 b.SetControl(cc) 20613 b.Aux = nil 20614 return true 20615 } 20616 // match: (If (GreaterEqualU cc) yes no) 20617 // cond: 20618 // result: (UGE cc yes no) 20619 for { 20620 v := b.Control 20621 if v.Op != OpARMGreaterEqualU { 20622 break 20623 } 20624 cc := v.Args[0] 20625 b.Kind = BlockARMUGE 20626 b.SetControl(cc) 20627 b.Aux = nil 20628 return true 20629 } 20630 // match: (If cond yes no) 20631 // cond: 20632 // result: (NE (CMPconst [0] cond) yes no) 20633 for { 20634 v := b.Control 20635 _ = v 20636 cond := b.Control 20637 b.Kind = BlockARMNE 20638 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 20639 v0.AuxInt = 0 20640 v0.AddArg(cond) 20641 b.SetControl(v0) 20642 b.Aux = nil 20643 return true 20644 } 20645 case BlockARMLE: 20646 // match: (LE (FlagEQ) yes no) 20647 // cond: 20648 // result: (First nil yes no) 20649 for { 20650 v := b.Control 20651 if v.Op != OpARMFlagEQ { 20652 break 20653 } 20654 b.Kind = BlockFirst 20655 b.SetControl(nil) 20656 b.Aux = nil 20657 return true 20658 } 20659 // match: (LE (FlagLT_ULT) yes no) 20660 // cond: 20661 // result: (First nil yes no) 20662 for { 20663 v := b.Control 20664 if v.Op != OpARMFlagLT_ULT { 20665 break 20666 } 20667 b.Kind = BlockFirst 20668 b.SetControl(nil) 20669 b.Aux = nil 20670 return true 20671 } 20672 // match: (LE (FlagLT_UGT) yes no) 20673 // cond: 20674 // result: (First nil yes no) 20675 for { 20676 v := b.Control 20677 if v.Op != OpARMFlagLT_UGT { 20678 break 20679 } 20680 b.Kind = BlockFirst 20681 b.SetControl(nil) 20682 b.Aux = nil 20683 return true 20684 } 20685 // match: (LE (FlagGT_ULT) yes no) 20686 // cond: 20687 // result: (First nil no yes) 20688 for { 20689 v := b.Control 20690 if v.Op != OpARMFlagGT_ULT { 20691 break 20692 } 20693 b.Kind = BlockFirst 20694 b.SetControl(nil) 20695 b.Aux = nil 20696 b.swapSuccessors() 20697 return true 20698 } 20699 // match: (LE (FlagGT_UGT) yes no) 20700 // cond: 20701 // result: (First nil no yes) 20702 for { 20703 v := b.Control 20704 if v.Op != OpARMFlagGT_UGT { 20705 break 20706 } 20707 b.Kind = BlockFirst 20708 b.SetControl(nil) 20709 b.Aux = nil 20710 b.swapSuccessors() 20711 return true 20712 } 20713 // match: (LE (InvertFlags cmp) yes no) 20714 // cond: 20715 // result: (GE cmp yes no) 20716 for { 20717 v := b.Control 20718 if v.Op != OpARMInvertFlags { 20719 break 20720 } 20721 cmp := v.Args[0] 20722 b.Kind = BlockARMGE 20723 b.SetControl(cmp) 20724 b.Aux = nil 20725 return true 20726 } 20727 case BlockARMLT: 20728 // match: (LT (FlagEQ) yes no) 20729 // cond: 20730 // result: (First nil no yes) 20731 for { 20732 v := b.Control 20733 if v.Op != OpARMFlagEQ { 20734 break 20735 } 20736 b.Kind = BlockFirst 20737 b.SetControl(nil) 20738 b.Aux = nil 20739 b.swapSuccessors() 20740 return true 20741 } 20742 // match: (LT (FlagLT_ULT) yes no) 20743 // cond: 20744 // result: (First nil yes no) 20745 for { 20746 v := b.Control 20747 if v.Op != OpARMFlagLT_ULT { 20748 break 20749 } 20750 b.Kind = BlockFirst 20751 b.SetControl(nil) 20752 b.Aux = nil 20753 return true 20754 } 20755 // match: (LT (FlagLT_UGT) yes no) 20756 // cond: 20757 // result: (First nil yes no) 20758 for { 20759 v := b.Control 20760 if v.Op != OpARMFlagLT_UGT { 20761 break 20762 } 20763 b.Kind = BlockFirst 20764 b.SetControl(nil) 20765 b.Aux = nil 20766 return true 20767 } 20768 // match: (LT (FlagGT_ULT) yes no) 20769 // cond: 20770 // result: (First nil no yes) 20771 for { 20772 v := b.Control 20773 if v.Op != OpARMFlagGT_ULT { 20774 break 20775 } 20776 b.Kind = BlockFirst 20777 b.SetControl(nil) 20778 b.Aux = nil 20779 b.swapSuccessors() 20780 return true 20781 } 20782 // match: (LT (FlagGT_UGT) yes no) 20783 // cond: 20784 // result: (First nil no yes) 20785 for { 20786 v := b.Control 20787 if v.Op != OpARMFlagGT_UGT { 20788 break 20789 } 20790 b.Kind = BlockFirst 20791 b.SetControl(nil) 20792 b.Aux = nil 20793 b.swapSuccessors() 20794 return true 20795 } 20796 // match: (LT (InvertFlags cmp) yes no) 20797 // cond: 20798 // result: (GT cmp yes no) 20799 for { 20800 v := b.Control 20801 if v.Op != OpARMInvertFlags { 20802 break 20803 } 20804 cmp := v.Args[0] 20805 b.Kind = BlockARMGT 20806 b.SetControl(cmp) 20807 b.Aux = nil 20808 return true 20809 } 20810 case BlockARMNE: 20811 // match: (NE (CMPconst [0] (Equal cc)) yes no) 20812 // cond: 20813 // result: (EQ cc yes no) 20814 for { 20815 v := b.Control 20816 if v.Op != OpARMCMPconst { 20817 break 20818 } 20819 if v.AuxInt != 0 { 20820 break 20821 } 20822 v_0 := v.Args[0] 20823 if v_0.Op != OpARMEqual { 20824 break 20825 } 20826 cc := v_0.Args[0] 20827 b.Kind = BlockARMEQ 20828 b.SetControl(cc) 20829 b.Aux = nil 20830 return true 20831 } 20832 // match: (NE (CMPconst [0] (NotEqual cc)) yes no) 20833 // cond: 20834 // result: (NE cc yes no) 20835 for { 20836 v := b.Control 20837 if v.Op != OpARMCMPconst { 20838 break 20839 } 20840 if v.AuxInt != 0 { 20841 break 20842 } 20843 v_0 := v.Args[0] 20844 if v_0.Op != OpARMNotEqual { 20845 break 20846 } 20847 cc := v_0.Args[0] 20848 b.Kind = BlockARMNE 20849 b.SetControl(cc) 20850 b.Aux = nil 20851 return true 20852 } 20853 // match: (NE (CMPconst [0] (LessThan cc)) yes no) 20854 // cond: 20855 // result: (LT cc yes no) 20856 for { 20857 v := b.Control 20858 if v.Op != OpARMCMPconst { 20859 break 20860 } 20861 if v.AuxInt != 0 { 20862 break 20863 } 20864 v_0 := v.Args[0] 20865 if v_0.Op != OpARMLessThan { 20866 break 20867 } 20868 cc := v_0.Args[0] 20869 b.Kind = BlockARMLT 20870 b.SetControl(cc) 20871 b.Aux = nil 20872 return true 20873 } 20874 // match: (NE (CMPconst [0] (LessThanU cc)) yes no) 20875 // cond: 20876 // result: (ULT cc yes no) 20877 for { 20878 v := b.Control 20879 if v.Op != OpARMCMPconst { 20880 break 20881 } 20882 if v.AuxInt != 0 { 20883 break 20884 } 20885 v_0 := v.Args[0] 20886 if v_0.Op != OpARMLessThanU { 20887 break 20888 } 20889 cc := v_0.Args[0] 20890 b.Kind = BlockARMULT 20891 b.SetControl(cc) 20892 b.Aux = nil 20893 return true 20894 } 20895 // match: (NE (CMPconst [0] (LessEqual cc)) yes no) 20896 // cond: 20897 // result: (LE cc yes no) 20898 for { 20899 v := b.Control 20900 if v.Op != OpARMCMPconst { 20901 break 20902 } 20903 if v.AuxInt != 0 { 20904 break 20905 } 20906 v_0 := v.Args[0] 20907 if v_0.Op != OpARMLessEqual { 20908 break 20909 } 20910 cc := v_0.Args[0] 20911 b.Kind = BlockARMLE 20912 b.SetControl(cc) 20913 b.Aux = nil 20914 return true 20915 } 20916 // match: (NE (CMPconst [0] (LessEqualU cc)) yes no) 20917 // cond: 20918 // result: (ULE cc yes no) 20919 for { 20920 v := b.Control 20921 if v.Op != OpARMCMPconst { 20922 break 20923 } 20924 if v.AuxInt != 0 { 20925 break 20926 } 20927 v_0 := v.Args[0] 20928 if v_0.Op != OpARMLessEqualU { 20929 break 20930 } 20931 cc := v_0.Args[0] 20932 b.Kind = BlockARMULE 20933 b.SetControl(cc) 20934 b.Aux = nil 20935 return true 20936 } 20937 // match: (NE (CMPconst [0] (GreaterThan cc)) yes no) 20938 // cond: 20939 // result: (GT cc yes no) 20940 for { 20941 v := b.Control 20942 if v.Op != OpARMCMPconst { 20943 break 20944 } 20945 if v.AuxInt != 0 { 20946 break 20947 } 20948 v_0 := v.Args[0] 20949 if v_0.Op != OpARMGreaterThan { 20950 break 20951 } 20952 cc := v_0.Args[0] 20953 b.Kind = BlockARMGT 20954 b.SetControl(cc) 20955 b.Aux = nil 20956 return true 20957 } 20958 // match: (NE (CMPconst [0] (GreaterThanU cc)) yes no) 20959 // cond: 20960 // result: (UGT cc yes no) 20961 for { 20962 v := b.Control 20963 if v.Op != OpARMCMPconst { 20964 break 20965 } 20966 if v.AuxInt != 0 { 20967 break 20968 } 20969 v_0 := v.Args[0] 20970 if v_0.Op != OpARMGreaterThanU { 20971 break 20972 } 20973 cc := v_0.Args[0] 20974 b.Kind = BlockARMUGT 20975 b.SetControl(cc) 20976 b.Aux = nil 20977 return true 20978 } 20979 // match: (NE (CMPconst [0] (GreaterEqual cc)) yes no) 20980 // cond: 20981 // result: (GE cc yes no) 20982 for { 20983 v := b.Control 20984 if v.Op != OpARMCMPconst { 20985 break 20986 } 20987 if v.AuxInt != 0 { 20988 break 20989 } 20990 v_0 := v.Args[0] 20991 if v_0.Op != OpARMGreaterEqual { 20992 break 20993 } 20994 cc := v_0.Args[0] 20995 b.Kind = BlockARMGE 20996 b.SetControl(cc) 20997 b.Aux = nil 20998 return true 20999 } 21000 // match: (NE (CMPconst [0] (GreaterEqualU cc)) yes no) 21001 // cond: 21002 // result: (UGE cc yes no) 21003 for { 21004 v := b.Control 21005 if v.Op != OpARMCMPconst { 21006 break 21007 } 21008 if v.AuxInt != 0 { 21009 break 21010 } 21011 v_0 := v.Args[0] 21012 if v_0.Op != OpARMGreaterEqualU { 21013 break 21014 } 21015 cc := v_0.Args[0] 21016 b.Kind = BlockARMUGE 21017 b.SetControl(cc) 21018 b.Aux = nil 21019 return true 21020 } 21021 // match: (NE (FlagEQ) yes no) 21022 // cond: 21023 // result: (First nil no yes) 21024 for { 21025 v := b.Control 21026 if v.Op != OpARMFlagEQ { 21027 break 21028 } 21029 b.Kind = BlockFirst 21030 b.SetControl(nil) 21031 b.Aux = nil 21032 b.swapSuccessors() 21033 return true 21034 } 21035 // match: (NE (FlagLT_ULT) yes no) 21036 // cond: 21037 // result: (First nil yes no) 21038 for { 21039 v := b.Control 21040 if v.Op != OpARMFlagLT_ULT { 21041 break 21042 } 21043 b.Kind = BlockFirst 21044 b.SetControl(nil) 21045 b.Aux = nil 21046 return true 21047 } 21048 // match: (NE (FlagLT_UGT) yes no) 21049 // cond: 21050 // result: (First nil yes no) 21051 for { 21052 v := b.Control 21053 if v.Op != OpARMFlagLT_UGT { 21054 break 21055 } 21056 b.Kind = BlockFirst 21057 b.SetControl(nil) 21058 b.Aux = nil 21059 return true 21060 } 21061 // match: (NE (FlagGT_ULT) yes no) 21062 // cond: 21063 // result: (First nil yes no) 21064 for { 21065 v := b.Control 21066 if v.Op != OpARMFlagGT_ULT { 21067 break 21068 } 21069 b.Kind = BlockFirst 21070 b.SetControl(nil) 21071 b.Aux = nil 21072 return true 21073 } 21074 // match: (NE (FlagGT_UGT) yes no) 21075 // cond: 21076 // result: (First nil yes no) 21077 for { 21078 v := b.Control 21079 if v.Op != OpARMFlagGT_UGT { 21080 break 21081 } 21082 b.Kind = BlockFirst 21083 b.SetControl(nil) 21084 b.Aux = nil 21085 return true 21086 } 21087 // match: (NE (InvertFlags cmp) yes no) 21088 // cond: 21089 // result: (NE cmp yes no) 21090 for { 21091 v := b.Control 21092 if v.Op != OpARMInvertFlags { 21093 break 21094 } 21095 cmp := v.Args[0] 21096 b.Kind = BlockARMNE 21097 b.SetControl(cmp) 21098 b.Aux = nil 21099 return true 21100 } 21101 case BlockARMUGE: 21102 // match: (UGE (FlagEQ) yes no) 21103 // cond: 21104 // result: (First nil yes no) 21105 for { 21106 v := b.Control 21107 if v.Op != OpARMFlagEQ { 21108 break 21109 } 21110 b.Kind = BlockFirst 21111 b.SetControl(nil) 21112 b.Aux = nil 21113 return true 21114 } 21115 // match: (UGE (FlagLT_ULT) yes no) 21116 // cond: 21117 // result: (First nil no yes) 21118 for { 21119 v := b.Control 21120 if v.Op != OpARMFlagLT_ULT { 21121 break 21122 } 21123 b.Kind = BlockFirst 21124 b.SetControl(nil) 21125 b.Aux = nil 21126 b.swapSuccessors() 21127 return true 21128 } 21129 // match: (UGE (FlagLT_UGT) yes no) 21130 // cond: 21131 // result: (First nil yes no) 21132 for { 21133 v := b.Control 21134 if v.Op != OpARMFlagLT_UGT { 21135 break 21136 } 21137 b.Kind = BlockFirst 21138 b.SetControl(nil) 21139 b.Aux = nil 21140 return true 21141 } 21142 // match: (UGE (FlagGT_ULT) yes no) 21143 // cond: 21144 // result: (First nil no yes) 21145 for { 21146 v := b.Control 21147 if v.Op != OpARMFlagGT_ULT { 21148 break 21149 } 21150 b.Kind = BlockFirst 21151 b.SetControl(nil) 21152 b.Aux = nil 21153 b.swapSuccessors() 21154 return true 21155 } 21156 // match: (UGE (FlagGT_UGT) yes no) 21157 // cond: 21158 // result: (First nil yes no) 21159 for { 21160 v := b.Control 21161 if v.Op != OpARMFlagGT_UGT { 21162 break 21163 } 21164 b.Kind = BlockFirst 21165 b.SetControl(nil) 21166 b.Aux = nil 21167 return true 21168 } 21169 // match: (UGE (InvertFlags cmp) yes no) 21170 // cond: 21171 // result: (ULE cmp yes no) 21172 for { 21173 v := b.Control 21174 if v.Op != OpARMInvertFlags { 21175 break 21176 } 21177 cmp := v.Args[0] 21178 b.Kind = BlockARMULE 21179 b.SetControl(cmp) 21180 b.Aux = nil 21181 return true 21182 } 21183 case BlockARMUGT: 21184 // match: (UGT (FlagEQ) yes no) 21185 // cond: 21186 // result: (First nil no yes) 21187 for { 21188 v := b.Control 21189 if v.Op != OpARMFlagEQ { 21190 break 21191 } 21192 b.Kind = BlockFirst 21193 b.SetControl(nil) 21194 b.Aux = nil 21195 b.swapSuccessors() 21196 return true 21197 } 21198 // match: (UGT (FlagLT_ULT) yes no) 21199 // cond: 21200 // result: (First nil no yes) 21201 for { 21202 v := b.Control 21203 if v.Op != OpARMFlagLT_ULT { 21204 break 21205 } 21206 b.Kind = BlockFirst 21207 b.SetControl(nil) 21208 b.Aux = nil 21209 b.swapSuccessors() 21210 return true 21211 } 21212 // match: (UGT (FlagLT_UGT) yes no) 21213 // cond: 21214 // result: (First nil yes no) 21215 for { 21216 v := b.Control 21217 if v.Op != OpARMFlagLT_UGT { 21218 break 21219 } 21220 b.Kind = BlockFirst 21221 b.SetControl(nil) 21222 b.Aux = nil 21223 return true 21224 } 21225 // match: (UGT (FlagGT_ULT) yes no) 21226 // cond: 21227 // result: (First nil no yes) 21228 for { 21229 v := b.Control 21230 if v.Op != OpARMFlagGT_ULT { 21231 break 21232 } 21233 b.Kind = BlockFirst 21234 b.SetControl(nil) 21235 b.Aux = nil 21236 b.swapSuccessors() 21237 return true 21238 } 21239 // match: (UGT (FlagGT_UGT) yes no) 21240 // cond: 21241 // result: (First nil yes no) 21242 for { 21243 v := b.Control 21244 if v.Op != OpARMFlagGT_UGT { 21245 break 21246 } 21247 b.Kind = BlockFirst 21248 b.SetControl(nil) 21249 b.Aux = nil 21250 return true 21251 } 21252 // match: (UGT (InvertFlags cmp) yes no) 21253 // cond: 21254 // result: (ULT cmp yes no) 21255 for { 21256 v := b.Control 21257 if v.Op != OpARMInvertFlags { 21258 break 21259 } 21260 cmp := v.Args[0] 21261 b.Kind = BlockARMULT 21262 b.SetControl(cmp) 21263 b.Aux = nil 21264 return true 21265 } 21266 case BlockARMULE: 21267 // match: (ULE (FlagEQ) yes no) 21268 // cond: 21269 // result: (First nil yes no) 21270 for { 21271 v := b.Control 21272 if v.Op != OpARMFlagEQ { 21273 break 21274 } 21275 b.Kind = BlockFirst 21276 b.SetControl(nil) 21277 b.Aux = nil 21278 return true 21279 } 21280 // match: (ULE (FlagLT_ULT) yes no) 21281 // cond: 21282 // result: (First nil yes no) 21283 for { 21284 v := b.Control 21285 if v.Op != OpARMFlagLT_ULT { 21286 break 21287 } 21288 b.Kind = BlockFirst 21289 b.SetControl(nil) 21290 b.Aux = nil 21291 return true 21292 } 21293 // match: (ULE (FlagLT_UGT) yes no) 21294 // cond: 21295 // result: (First nil no yes) 21296 for { 21297 v := b.Control 21298 if v.Op != OpARMFlagLT_UGT { 21299 break 21300 } 21301 b.Kind = BlockFirst 21302 b.SetControl(nil) 21303 b.Aux = nil 21304 b.swapSuccessors() 21305 return true 21306 } 21307 // match: (ULE (FlagGT_ULT) yes no) 21308 // cond: 21309 // result: (First nil yes no) 21310 for { 21311 v := b.Control 21312 if v.Op != OpARMFlagGT_ULT { 21313 break 21314 } 21315 b.Kind = BlockFirst 21316 b.SetControl(nil) 21317 b.Aux = nil 21318 return true 21319 } 21320 // match: (ULE (FlagGT_UGT) yes no) 21321 // cond: 21322 // result: (First nil no yes) 21323 for { 21324 v := b.Control 21325 if v.Op != OpARMFlagGT_UGT { 21326 break 21327 } 21328 b.Kind = BlockFirst 21329 b.SetControl(nil) 21330 b.Aux = nil 21331 b.swapSuccessors() 21332 return true 21333 } 21334 // match: (ULE (InvertFlags cmp) yes no) 21335 // cond: 21336 // result: (UGE cmp yes no) 21337 for { 21338 v := b.Control 21339 if v.Op != OpARMInvertFlags { 21340 break 21341 } 21342 cmp := v.Args[0] 21343 b.Kind = BlockARMUGE 21344 b.SetControl(cmp) 21345 b.Aux = nil 21346 return true 21347 } 21348 case BlockARMULT: 21349 // match: (ULT (FlagEQ) yes no) 21350 // cond: 21351 // result: (First nil no yes) 21352 for { 21353 v := b.Control 21354 if v.Op != OpARMFlagEQ { 21355 break 21356 } 21357 b.Kind = BlockFirst 21358 b.SetControl(nil) 21359 b.Aux = nil 21360 b.swapSuccessors() 21361 return true 21362 } 21363 // match: (ULT (FlagLT_ULT) yes no) 21364 // cond: 21365 // result: (First nil yes no) 21366 for { 21367 v := b.Control 21368 if v.Op != OpARMFlagLT_ULT { 21369 break 21370 } 21371 b.Kind = BlockFirst 21372 b.SetControl(nil) 21373 b.Aux = nil 21374 return true 21375 } 21376 // match: (ULT (FlagLT_UGT) yes no) 21377 // cond: 21378 // result: (First nil no yes) 21379 for { 21380 v := b.Control 21381 if v.Op != OpARMFlagLT_UGT { 21382 break 21383 } 21384 b.Kind = BlockFirst 21385 b.SetControl(nil) 21386 b.Aux = nil 21387 b.swapSuccessors() 21388 return true 21389 } 21390 // match: (ULT (FlagGT_ULT) yes no) 21391 // cond: 21392 // result: (First nil yes no) 21393 for { 21394 v := b.Control 21395 if v.Op != OpARMFlagGT_ULT { 21396 break 21397 } 21398 b.Kind = BlockFirst 21399 b.SetControl(nil) 21400 b.Aux = nil 21401 return true 21402 } 21403 // match: (ULT (FlagGT_UGT) yes no) 21404 // cond: 21405 // result: (First nil no yes) 21406 for { 21407 v := b.Control 21408 if v.Op != OpARMFlagGT_UGT { 21409 break 21410 } 21411 b.Kind = BlockFirst 21412 b.SetControl(nil) 21413 b.Aux = nil 21414 b.swapSuccessors() 21415 return true 21416 } 21417 // match: (ULT (InvertFlags cmp) yes no) 21418 // cond: 21419 // result: (UGT cmp yes no) 21420 for { 21421 v := b.Control 21422 if v.Op != OpARMInvertFlags { 21423 break 21424 } 21425 cmp := v.Args[0] 21426 b.Kind = BlockARMUGT 21427 b.SetControl(cmp) 21428 b.Aux = nil 21429 return true 21430 } 21431 } 21432 return false 21433 }