github.com/megatontech/mynoteforgo@v0.0.0-20200507084910-5d0c6ea6e890/源码/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 "fmt" 7 import "math" 8 import "cmd/internal/obj" 9 import "cmd/internal/objabi" 10 import "cmd/compile/internal/types" 11 12 var _ = fmt.Println // in case not otherwise used 13 var _ = math.MinInt8 // in case not otherwise used 14 var _ = obj.ANOP // in case not otherwise used 15 var _ = objabi.GOROOT // in case not otherwise used 16 var _ = types.TypeMem // in case not otherwise used 17 18 func rewriteValueARM(v *Value) bool { 19 switch v.Op { 20 case OpARMADC: 21 return rewriteValueARM_OpARMADC_0(v) || rewriteValueARM_OpARMADC_10(v) || rewriteValueARM_OpARMADC_20(v) 22 case OpARMADCconst: 23 return rewriteValueARM_OpARMADCconst_0(v) 24 case OpARMADCshiftLL: 25 return rewriteValueARM_OpARMADCshiftLL_0(v) 26 case OpARMADCshiftLLreg: 27 return rewriteValueARM_OpARMADCshiftLLreg_0(v) 28 case OpARMADCshiftRA: 29 return rewriteValueARM_OpARMADCshiftRA_0(v) 30 case OpARMADCshiftRAreg: 31 return rewriteValueARM_OpARMADCshiftRAreg_0(v) 32 case OpARMADCshiftRL: 33 return rewriteValueARM_OpARMADCshiftRL_0(v) 34 case OpARMADCshiftRLreg: 35 return rewriteValueARM_OpARMADCshiftRLreg_0(v) 36 case OpARMADD: 37 return rewriteValueARM_OpARMADD_0(v) || rewriteValueARM_OpARMADD_10(v) 38 case OpARMADDD: 39 return rewriteValueARM_OpARMADDD_0(v) 40 case OpARMADDF: 41 return rewriteValueARM_OpARMADDF_0(v) 42 case OpARMADDS: 43 return rewriteValueARM_OpARMADDS_0(v) || rewriteValueARM_OpARMADDS_10(v) 44 case OpARMADDSshiftLL: 45 return rewriteValueARM_OpARMADDSshiftLL_0(v) 46 case OpARMADDSshiftLLreg: 47 return rewriteValueARM_OpARMADDSshiftLLreg_0(v) 48 case OpARMADDSshiftRA: 49 return rewriteValueARM_OpARMADDSshiftRA_0(v) 50 case OpARMADDSshiftRAreg: 51 return rewriteValueARM_OpARMADDSshiftRAreg_0(v) 52 case OpARMADDSshiftRL: 53 return rewriteValueARM_OpARMADDSshiftRL_0(v) 54 case OpARMADDSshiftRLreg: 55 return rewriteValueARM_OpARMADDSshiftRLreg_0(v) 56 case OpARMADDconst: 57 return rewriteValueARM_OpARMADDconst_0(v) 58 case OpARMADDshiftLL: 59 return rewriteValueARM_OpARMADDshiftLL_0(v) 60 case OpARMADDshiftLLreg: 61 return rewriteValueARM_OpARMADDshiftLLreg_0(v) 62 case OpARMADDshiftRA: 63 return rewriteValueARM_OpARMADDshiftRA_0(v) 64 case OpARMADDshiftRAreg: 65 return rewriteValueARM_OpARMADDshiftRAreg_0(v) 66 case OpARMADDshiftRL: 67 return rewriteValueARM_OpARMADDshiftRL_0(v) 68 case OpARMADDshiftRLreg: 69 return rewriteValueARM_OpARMADDshiftRLreg_0(v) 70 case OpARMAND: 71 return rewriteValueARM_OpARMAND_0(v) || rewriteValueARM_OpARMAND_10(v) || rewriteValueARM_OpARMAND_20(v) 72 case OpARMANDconst: 73 return rewriteValueARM_OpARMANDconst_0(v) 74 case OpARMANDshiftLL: 75 return rewriteValueARM_OpARMANDshiftLL_0(v) 76 case OpARMANDshiftLLreg: 77 return rewriteValueARM_OpARMANDshiftLLreg_0(v) 78 case OpARMANDshiftRA: 79 return rewriteValueARM_OpARMANDshiftRA_0(v) 80 case OpARMANDshiftRAreg: 81 return rewriteValueARM_OpARMANDshiftRAreg_0(v) 82 case OpARMANDshiftRL: 83 return rewriteValueARM_OpARMANDshiftRL_0(v) 84 case OpARMANDshiftRLreg: 85 return rewriteValueARM_OpARMANDshiftRLreg_0(v) 86 case OpARMBFX: 87 return rewriteValueARM_OpARMBFX_0(v) 88 case OpARMBFXU: 89 return rewriteValueARM_OpARMBFXU_0(v) 90 case OpARMBIC: 91 return rewriteValueARM_OpARMBIC_0(v) 92 case OpARMBICconst: 93 return rewriteValueARM_OpARMBICconst_0(v) 94 case OpARMBICshiftLL: 95 return rewriteValueARM_OpARMBICshiftLL_0(v) 96 case OpARMBICshiftLLreg: 97 return rewriteValueARM_OpARMBICshiftLLreg_0(v) 98 case OpARMBICshiftRA: 99 return rewriteValueARM_OpARMBICshiftRA_0(v) 100 case OpARMBICshiftRAreg: 101 return rewriteValueARM_OpARMBICshiftRAreg_0(v) 102 case OpARMBICshiftRL: 103 return rewriteValueARM_OpARMBICshiftRL_0(v) 104 case OpARMBICshiftRLreg: 105 return rewriteValueARM_OpARMBICshiftRLreg_0(v) 106 case OpARMCMN: 107 return rewriteValueARM_OpARMCMN_0(v) || rewriteValueARM_OpARMCMN_10(v) 108 case OpARMCMNconst: 109 return rewriteValueARM_OpARMCMNconst_0(v) 110 case OpARMCMNshiftLL: 111 return rewriteValueARM_OpARMCMNshiftLL_0(v) 112 case OpARMCMNshiftLLreg: 113 return rewriteValueARM_OpARMCMNshiftLLreg_0(v) 114 case OpARMCMNshiftRA: 115 return rewriteValueARM_OpARMCMNshiftRA_0(v) 116 case OpARMCMNshiftRAreg: 117 return rewriteValueARM_OpARMCMNshiftRAreg_0(v) 118 case OpARMCMNshiftRL: 119 return rewriteValueARM_OpARMCMNshiftRL_0(v) 120 case OpARMCMNshiftRLreg: 121 return rewriteValueARM_OpARMCMNshiftRLreg_0(v) 122 case OpARMCMOVWHSconst: 123 return rewriteValueARM_OpARMCMOVWHSconst_0(v) 124 case OpARMCMOVWLSconst: 125 return rewriteValueARM_OpARMCMOVWLSconst_0(v) 126 case OpARMCMP: 127 return rewriteValueARM_OpARMCMP_0(v) || rewriteValueARM_OpARMCMP_10(v) 128 case OpARMCMPD: 129 return rewriteValueARM_OpARMCMPD_0(v) 130 case OpARMCMPF: 131 return rewriteValueARM_OpARMCMPF_0(v) 132 case OpARMCMPconst: 133 return rewriteValueARM_OpARMCMPconst_0(v) 134 case OpARMCMPshiftLL: 135 return rewriteValueARM_OpARMCMPshiftLL_0(v) 136 case OpARMCMPshiftLLreg: 137 return rewriteValueARM_OpARMCMPshiftLLreg_0(v) 138 case OpARMCMPshiftRA: 139 return rewriteValueARM_OpARMCMPshiftRA_0(v) 140 case OpARMCMPshiftRAreg: 141 return rewriteValueARM_OpARMCMPshiftRAreg_0(v) 142 case OpARMCMPshiftRL: 143 return rewriteValueARM_OpARMCMPshiftRL_0(v) 144 case OpARMCMPshiftRLreg: 145 return rewriteValueARM_OpARMCMPshiftRLreg_0(v) 146 case OpARMEqual: 147 return rewriteValueARM_OpARMEqual_0(v) 148 case OpARMGreaterEqual: 149 return rewriteValueARM_OpARMGreaterEqual_0(v) 150 case OpARMGreaterEqualU: 151 return rewriteValueARM_OpARMGreaterEqualU_0(v) 152 case OpARMGreaterThan: 153 return rewriteValueARM_OpARMGreaterThan_0(v) 154 case OpARMGreaterThanU: 155 return rewriteValueARM_OpARMGreaterThanU_0(v) 156 case OpARMLessEqual: 157 return rewriteValueARM_OpARMLessEqual_0(v) 158 case OpARMLessEqualU: 159 return rewriteValueARM_OpARMLessEqualU_0(v) 160 case OpARMLessThan: 161 return rewriteValueARM_OpARMLessThan_0(v) 162 case OpARMLessThanU: 163 return rewriteValueARM_OpARMLessThanU_0(v) 164 case OpARMMOVBUload: 165 return rewriteValueARM_OpARMMOVBUload_0(v) 166 case OpARMMOVBUloadidx: 167 return rewriteValueARM_OpARMMOVBUloadidx_0(v) 168 case OpARMMOVBUreg: 169 return rewriteValueARM_OpARMMOVBUreg_0(v) 170 case OpARMMOVBload: 171 return rewriteValueARM_OpARMMOVBload_0(v) 172 case OpARMMOVBloadidx: 173 return rewriteValueARM_OpARMMOVBloadidx_0(v) 174 case OpARMMOVBreg: 175 return rewriteValueARM_OpARMMOVBreg_0(v) 176 case OpARMMOVBstore: 177 return rewriteValueARM_OpARMMOVBstore_0(v) 178 case OpARMMOVBstoreidx: 179 return rewriteValueARM_OpARMMOVBstoreidx_0(v) 180 case OpARMMOVDload: 181 return rewriteValueARM_OpARMMOVDload_0(v) 182 case OpARMMOVDstore: 183 return rewriteValueARM_OpARMMOVDstore_0(v) 184 case OpARMMOVFload: 185 return rewriteValueARM_OpARMMOVFload_0(v) 186 case OpARMMOVFstore: 187 return rewriteValueARM_OpARMMOVFstore_0(v) 188 case OpARMMOVHUload: 189 return rewriteValueARM_OpARMMOVHUload_0(v) 190 case OpARMMOVHUloadidx: 191 return rewriteValueARM_OpARMMOVHUloadidx_0(v) 192 case OpARMMOVHUreg: 193 return rewriteValueARM_OpARMMOVHUreg_0(v) 194 case OpARMMOVHload: 195 return rewriteValueARM_OpARMMOVHload_0(v) 196 case OpARMMOVHloadidx: 197 return rewriteValueARM_OpARMMOVHloadidx_0(v) 198 case OpARMMOVHreg: 199 return rewriteValueARM_OpARMMOVHreg_0(v) 200 case OpARMMOVHstore: 201 return rewriteValueARM_OpARMMOVHstore_0(v) 202 case OpARMMOVHstoreidx: 203 return rewriteValueARM_OpARMMOVHstoreidx_0(v) 204 case OpARMMOVWload: 205 return rewriteValueARM_OpARMMOVWload_0(v) 206 case OpARMMOVWloadidx: 207 return rewriteValueARM_OpARMMOVWloadidx_0(v) 208 case OpARMMOVWloadshiftLL: 209 return rewriteValueARM_OpARMMOVWloadshiftLL_0(v) 210 case OpARMMOVWloadshiftRA: 211 return rewriteValueARM_OpARMMOVWloadshiftRA_0(v) 212 case OpARMMOVWloadshiftRL: 213 return rewriteValueARM_OpARMMOVWloadshiftRL_0(v) 214 case OpARMMOVWreg: 215 return rewriteValueARM_OpARMMOVWreg_0(v) 216 case OpARMMOVWstore: 217 return rewriteValueARM_OpARMMOVWstore_0(v) 218 case OpARMMOVWstoreidx: 219 return rewriteValueARM_OpARMMOVWstoreidx_0(v) 220 case OpARMMOVWstoreshiftLL: 221 return rewriteValueARM_OpARMMOVWstoreshiftLL_0(v) 222 case OpARMMOVWstoreshiftRA: 223 return rewriteValueARM_OpARMMOVWstoreshiftRA_0(v) 224 case OpARMMOVWstoreshiftRL: 225 return rewriteValueARM_OpARMMOVWstoreshiftRL_0(v) 226 case OpARMMUL: 227 return rewriteValueARM_OpARMMUL_0(v) || rewriteValueARM_OpARMMUL_10(v) || rewriteValueARM_OpARMMUL_20(v) 228 case OpARMMULA: 229 return rewriteValueARM_OpARMMULA_0(v) || rewriteValueARM_OpARMMULA_10(v) || rewriteValueARM_OpARMMULA_20(v) 230 case OpARMMULD: 231 return rewriteValueARM_OpARMMULD_0(v) 232 case OpARMMULF: 233 return rewriteValueARM_OpARMMULF_0(v) 234 case OpARMMULS: 235 return rewriteValueARM_OpARMMULS_0(v) || rewriteValueARM_OpARMMULS_10(v) || rewriteValueARM_OpARMMULS_20(v) 236 case OpARMMVN: 237 return rewriteValueARM_OpARMMVN_0(v) 238 case OpARMMVNshiftLL: 239 return rewriteValueARM_OpARMMVNshiftLL_0(v) 240 case OpARMMVNshiftLLreg: 241 return rewriteValueARM_OpARMMVNshiftLLreg_0(v) 242 case OpARMMVNshiftRA: 243 return rewriteValueARM_OpARMMVNshiftRA_0(v) 244 case OpARMMVNshiftRAreg: 245 return rewriteValueARM_OpARMMVNshiftRAreg_0(v) 246 case OpARMMVNshiftRL: 247 return rewriteValueARM_OpARMMVNshiftRL_0(v) 248 case OpARMMVNshiftRLreg: 249 return rewriteValueARM_OpARMMVNshiftRLreg_0(v) 250 case OpARMNEGD: 251 return rewriteValueARM_OpARMNEGD_0(v) 252 case OpARMNEGF: 253 return rewriteValueARM_OpARMNEGF_0(v) 254 case OpARMNMULD: 255 return rewriteValueARM_OpARMNMULD_0(v) 256 case OpARMNMULF: 257 return rewriteValueARM_OpARMNMULF_0(v) 258 case OpARMNotEqual: 259 return rewriteValueARM_OpARMNotEqual_0(v) 260 case OpARMOR: 261 return rewriteValueARM_OpARMOR_0(v) || rewriteValueARM_OpARMOR_10(v) 262 case OpARMORconst: 263 return rewriteValueARM_OpARMORconst_0(v) 264 case OpARMORshiftLL: 265 return rewriteValueARM_OpARMORshiftLL_0(v) 266 case OpARMORshiftLLreg: 267 return rewriteValueARM_OpARMORshiftLLreg_0(v) 268 case OpARMORshiftRA: 269 return rewriteValueARM_OpARMORshiftRA_0(v) 270 case OpARMORshiftRAreg: 271 return rewriteValueARM_OpARMORshiftRAreg_0(v) 272 case OpARMORshiftRL: 273 return rewriteValueARM_OpARMORshiftRL_0(v) 274 case OpARMORshiftRLreg: 275 return rewriteValueARM_OpARMORshiftRLreg_0(v) 276 case OpARMRSB: 277 return rewriteValueARM_OpARMRSB_0(v) || rewriteValueARM_OpARMRSB_10(v) 278 case OpARMRSBSshiftLL: 279 return rewriteValueARM_OpARMRSBSshiftLL_0(v) 280 case OpARMRSBSshiftLLreg: 281 return rewriteValueARM_OpARMRSBSshiftLLreg_0(v) 282 case OpARMRSBSshiftRA: 283 return rewriteValueARM_OpARMRSBSshiftRA_0(v) 284 case OpARMRSBSshiftRAreg: 285 return rewriteValueARM_OpARMRSBSshiftRAreg_0(v) 286 case OpARMRSBSshiftRL: 287 return rewriteValueARM_OpARMRSBSshiftRL_0(v) 288 case OpARMRSBSshiftRLreg: 289 return rewriteValueARM_OpARMRSBSshiftRLreg_0(v) 290 case OpARMRSBconst: 291 return rewriteValueARM_OpARMRSBconst_0(v) 292 case OpARMRSBshiftLL: 293 return rewriteValueARM_OpARMRSBshiftLL_0(v) 294 case OpARMRSBshiftLLreg: 295 return rewriteValueARM_OpARMRSBshiftLLreg_0(v) 296 case OpARMRSBshiftRA: 297 return rewriteValueARM_OpARMRSBshiftRA_0(v) 298 case OpARMRSBshiftRAreg: 299 return rewriteValueARM_OpARMRSBshiftRAreg_0(v) 300 case OpARMRSBshiftRL: 301 return rewriteValueARM_OpARMRSBshiftRL_0(v) 302 case OpARMRSBshiftRLreg: 303 return rewriteValueARM_OpARMRSBshiftRLreg_0(v) 304 case OpARMRSCconst: 305 return rewriteValueARM_OpARMRSCconst_0(v) 306 case OpARMRSCshiftLL: 307 return rewriteValueARM_OpARMRSCshiftLL_0(v) 308 case OpARMRSCshiftLLreg: 309 return rewriteValueARM_OpARMRSCshiftLLreg_0(v) 310 case OpARMRSCshiftRA: 311 return rewriteValueARM_OpARMRSCshiftRA_0(v) 312 case OpARMRSCshiftRAreg: 313 return rewriteValueARM_OpARMRSCshiftRAreg_0(v) 314 case OpARMRSCshiftRL: 315 return rewriteValueARM_OpARMRSCshiftRL_0(v) 316 case OpARMRSCshiftRLreg: 317 return rewriteValueARM_OpARMRSCshiftRLreg_0(v) 318 case OpARMSBC: 319 return rewriteValueARM_OpARMSBC_0(v) || rewriteValueARM_OpARMSBC_10(v) 320 case OpARMSBCconst: 321 return rewriteValueARM_OpARMSBCconst_0(v) 322 case OpARMSBCshiftLL: 323 return rewriteValueARM_OpARMSBCshiftLL_0(v) 324 case OpARMSBCshiftLLreg: 325 return rewriteValueARM_OpARMSBCshiftLLreg_0(v) 326 case OpARMSBCshiftRA: 327 return rewriteValueARM_OpARMSBCshiftRA_0(v) 328 case OpARMSBCshiftRAreg: 329 return rewriteValueARM_OpARMSBCshiftRAreg_0(v) 330 case OpARMSBCshiftRL: 331 return rewriteValueARM_OpARMSBCshiftRL_0(v) 332 case OpARMSBCshiftRLreg: 333 return rewriteValueARM_OpARMSBCshiftRLreg_0(v) 334 case OpARMSLL: 335 return rewriteValueARM_OpARMSLL_0(v) 336 case OpARMSLLconst: 337 return rewriteValueARM_OpARMSLLconst_0(v) 338 case OpARMSRA: 339 return rewriteValueARM_OpARMSRA_0(v) 340 case OpARMSRAcond: 341 return rewriteValueARM_OpARMSRAcond_0(v) 342 case OpARMSRAconst: 343 return rewriteValueARM_OpARMSRAconst_0(v) 344 case OpARMSRL: 345 return rewriteValueARM_OpARMSRL_0(v) 346 case OpARMSRLconst: 347 return rewriteValueARM_OpARMSRLconst_0(v) 348 case OpARMSUB: 349 return rewriteValueARM_OpARMSUB_0(v) || rewriteValueARM_OpARMSUB_10(v) 350 case OpARMSUBD: 351 return rewriteValueARM_OpARMSUBD_0(v) 352 case OpARMSUBF: 353 return rewriteValueARM_OpARMSUBF_0(v) 354 case OpARMSUBS: 355 return rewriteValueARM_OpARMSUBS_0(v) || rewriteValueARM_OpARMSUBS_10(v) 356 case OpARMSUBSshiftLL: 357 return rewriteValueARM_OpARMSUBSshiftLL_0(v) 358 case OpARMSUBSshiftLLreg: 359 return rewriteValueARM_OpARMSUBSshiftLLreg_0(v) 360 case OpARMSUBSshiftRA: 361 return rewriteValueARM_OpARMSUBSshiftRA_0(v) 362 case OpARMSUBSshiftRAreg: 363 return rewriteValueARM_OpARMSUBSshiftRAreg_0(v) 364 case OpARMSUBSshiftRL: 365 return rewriteValueARM_OpARMSUBSshiftRL_0(v) 366 case OpARMSUBSshiftRLreg: 367 return rewriteValueARM_OpARMSUBSshiftRLreg_0(v) 368 case OpARMSUBconst: 369 return rewriteValueARM_OpARMSUBconst_0(v) 370 case OpARMSUBshiftLL: 371 return rewriteValueARM_OpARMSUBshiftLL_0(v) 372 case OpARMSUBshiftLLreg: 373 return rewriteValueARM_OpARMSUBshiftLLreg_0(v) 374 case OpARMSUBshiftRA: 375 return rewriteValueARM_OpARMSUBshiftRA_0(v) 376 case OpARMSUBshiftRAreg: 377 return rewriteValueARM_OpARMSUBshiftRAreg_0(v) 378 case OpARMSUBshiftRL: 379 return rewriteValueARM_OpARMSUBshiftRL_0(v) 380 case OpARMSUBshiftRLreg: 381 return rewriteValueARM_OpARMSUBshiftRLreg_0(v) 382 case OpARMTEQ: 383 return rewriteValueARM_OpARMTEQ_0(v) || rewriteValueARM_OpARMTEQ_10(v) 384 case OpARMTEQconst: 385 return rewriteValueARM_OpARMTEQconst_0(v) 386 case OpARMTEQshiftLL: 387 return rewriteValueARM_OpARMTEQshiftLL_0(v) 388 case OpARMTEQshiftLLreg: 389 return rewriteValueARM_OpARMTEQshiftLLreg_0(v) 390 case OpARMTEQshiftRA: 391 return rewriteValueARM_OpARMTEQshiftRA_0(v) 392 case OpARMTEQshiftRAreg: 393 return rewriteValueARM_OpARMTEQshiftRAreg_0(v) 394 case OpARMTEQshiftRL: 395 return rewriteValueARM_OpARMTEQshiftRL_0(v) 396 case OpARMTEQshiftRLreg: 397 return rewriteValueARM_OpARMTEQshiftRLreg_0(v) 398 case OpARMTST: 399 return rewriteValueARM_OpARMTST_0(v) || rewriteValueARM_OpARMTST_10(v) 400 case OpARMTSTconst: 401 return rewriteValueARM_OpARMTSTconst_0(v) 402 case OpARMTSTshiftLL: 403 return rewriteValueARM_OpARMTSTshiftLL_0(v) 404 case OpARMTSTshiftLLreg: 405 return rewriteValueARM_OpARMTSTshiftLLreg_0(v) 406 case OpARMTSTshiftRA: 407 return rewriteValueARM_OpARMTSTshiftRA_0(v) 408 case OpARMTSTshiftRAreg: 409 return rewriteValueARM_OpARMTSTshiftRAreg_0(v) 410 case OpARMTSTshiftRL: 411 return rewriteValueARM_OpARMTSTshiftRL_0(v) 412 case OpARMTSTshiftRLreg: 413 return rewriteValueARM_OpARMTSTshiftRLreg_0(v) 414 case OpARMXOR: 415 return rewriteValueARM_OpARMXOR_0(v) || rewriteValueARM_OpARMXOR_10(v) 416 case OpARMXORconst: 417 return rewriteValueARM_OpARMXORconst_0(v) 418 case OpARMXORshiftLL: 419 return rewriteValueARM_OpARMXORshiftLL_0(v) 420 case OpARMXORshiftLLreg: 421 return rewriteValueARM_OpARMXORshiftLLreg_0(v) 422 case OpARMXORshiftRA: 423 return rewriteValueARM_OpARMXORshiftRA_0(v) 424 case OpARMXORshiftRAreg: 425 return rewriteValueARM_OpARMXORshiftRAreg_0(v) 426 case OpARMXORshiftRL: 427 return rewriteValueARM_OpARMXORshiftRL_0(v) 428 case OpARMXORshiftRLreg: 429 return rewriteValueARM_OpARMXORshiftRLreg_0(v) 430 case OpARMXORshiftRR: 431 return rewriteValueARM_OpARMXORshiftRR_0(v) 432 case OpAdd16: 433 return rewriteValueARM_OpAdd16_0(v) 434 case OpAdd32: 435 return rewriteValueARM_OpAdd32_0(v) 436 case OpAdd32F: 437 return rewriteValueARM_OpAdd32F_0(v) 438 case OpAdd32carry: 439 return rewriteValueARM_OpAdd32carry_0(v) 440 case OpAdd32withcarry: 441 return rewriteValueARM_OpAdd32withcarry_0(v) 442 case OpAdd64F: 443 return rewriteValueARM_OpAdd64F_0(v) 444 case OpAdd8: 445 return rewriteValueARM_OpAdd8_0(v) 446 case OpAddPtr: 447 return rewriteValueARM_OpAddPtr_0(v) 448 case OpAddr: 449 return rewriteValueARM_OpAddr_0(v) 450 case OpAnd16: 451 return rewriteValueARM_OpAnd16_0(v) 452 case OpAnd32: 453 return rewriteValueARM_OpAnd32_0(v) 454 case OpAnd8: 455 return rewriteValueARM_OpAnd8_0(v) 456 case OpAndB: 457 return rewriteValueARM_OpAndB_0(v) 458 case OpAvg32u: 459 return rewriteValueARM_OpAvg32u_0(v) 460 case OpBitLen32: 461 return rewriteValueARM_OpBitLen32_0(v) 462 case OpBswap32: 463 return rewriteValueARM_OpBswap32_0(v) 464 case OpClosureCall: 465 return rewriteValueARM_OpClosureCall_0(v) 466 case OpCom16: 467 return rewriteValueARM_OpCom16_0(v) 468 case OpCom32: 469 return rewriteValueARM_OpCom32_0(v) 470 case OpCom8: 471 return rewriteValueARM_OpCom8_0(v) 472 case OpConst16: 473 return rewriteValueARM_OpConst16_0(v) 474 case OpConst32: 475 return rewriteValueARM_OpConst32_0(v) 476 case OpConst32F: 477 return rewriteValueARM_OpConst32F_0(v) 478 case OpConst64F: 479 return rewriteValueARM_OpConst64F_0(v) 480 case OpConst8: 481 return rewriteValueARM_OpConst8_0(v) 482 case OpConstBool: 483 return rewriteValueARM_OpConstBool_0(v) 484 case OpConstNil: 485 return rewriteValueARM_OpConstNil_0(v) 486 case OpCtz32: 487 return rewriteValueARM_OpCtz32_0(v) 488 case OpCtz32NonZero: 489 return rewriteValueARM_OpCtz32NonZero_0(v) 490 case OpCvt32Fto32: 491 return rewriteValueARM_OpCvt32Fto32_0(v) 492 case OpCvt32Fto32U: 493 return rewriteValueARM_OpCvt32Fto32U_0(v) 494 case OpCvt32Fto64F: 495 return rewriteValueARM_OpCvt32Fto64F_0(v) 496 case OpCvt32Uto32F: 497 return rewriteValueARM_OpCvt32Uto32F_0(v) 498 case OpCvt32Uto64F: 499 return rewriteValueARM_OpCvt32Uto64F_0(v) 500 case OpCvt32to32F: 501 return rewriteValueARM_OpCvt32to32F_0(v) 502 case OpCvt32to64F: 503 return rewriteValueARM_OpCvt32to64F_0(v) 504 case OpCvt64Fto32: 505 return rewriteValueARM_OpCvt64Fto32_0(v) 506 case OpCvt64Fto32F: 507 return rewriteValueARM_OpCvt64Fto32F_0(v) 508 case OpCvt64Fto32U: 509 return rewriteValueARM_OpCvt64Fto32U_0(v) 510 case OpDiv16: 511 return rewriteValueARM_OpDiv16_0(v) 512 case OpDiv16u: 513 return rewriteValueARM_OpDiv16u_0(v) 514 case OpDiv32: 515 return rewriteValueARM_OpDiv32_0(v) 516 case OpDiv32F: 517 return rewriteValueARM_OpDiv32F_0(v) 518 case OpDiv32u: 519 return rewriteValueARM_OpDiv32u_0(v) 520 case OpDiv64F: 521 return rewriteValueARM_OpDiv64F_0(v) 522 case OpDiv8: 523 return rewriteValueARM_OpDiv8_0(v) 524 case OpDiv8u: 525 return rewriteValueARM_OpDiv8u_0(v) 526 case OpEq16: 527 return rewriteValueARM_OpEq16_0(v) 528 case OpEq32: 529 return rewriteValueARM_OpEq32_0(v) 530 case OpEq32F: 531 return rewriteValueARM_OpEq32F_0(v) 532 case OpEq64F: 533 return rewriteValueARM_OpEq64F_0(v) 534 case OpEq8: 535 return rewriteValueARM_OpEq8_0(v) 536 case OpEqB: 537 return rewriteValueARM_OpEqB_0(v) 538 case OpEqPtr: 539 return rewriteValueARM_OpEqPtr_0(v) 540 case OpGeq16: 541 return rewriteValueARM_OpGeq16_0(v) 542 case OpGeq16U: 543 return rewriteValueARM_OpGeq16U_0(v) 544 case OpGeq32: 545 return rewriteValueARM_OpGeq32_0(v) 546 case OpGeq32F: 547 return rewriteValueARM_OpGeq32F_0(v) 548 case OpGeq32U: 549 return rewriteValueARM_OpGeq32U_0(v) 550 case OpGeq64F: 551 return rewriteValueARM_OpGeq64F_0(v) 552 case OpGeq8: 553 return rewriteValueARM_OpGeq8_0(v) 554 case OpGeq8U: 555 return rewriteValueARM_OpGeq8U_0(v) 556 case OpGetCallerPC: 557 return rewriteValueARM_OpGetCallerPC_0(v) 558 case OpGetCallerSP: 559 return rewriteValueARM_OpGetCallerSP_0(v) 560 case OpGetClosurePtr: 561 return rewriteValueARM_OpGetClosurePtr_0(v) 562 case OpGreater16: 563 return rewriteValueARM_OpGreater16_0(v) 564 case OpGreater16U: 565 return rewriteValueARM_OpGreater16U_0(v) 566 case OpGreater32: 567 return rewriteValueARM_OpGreater32_0(v) 568 case OpGreater32F: 569 return rewriteValueARM_OpGreater32F_0(v) 570 case OpGreater32U: 571 return rewriteValueARM_OpGreater32U_0(v) 572 case OpGreater64F: 573 return rewriteValueARM_OpGreater64F_0(v) 574 case OpGreater8: 575 return rewriteValueARM_OpGreater8_0(v) 576 case OpGreater8U: 577 return rewriteValueARM_OpGreater8U_0(v) 578 case OpHmul32: 579 return rewriteValueARM_OpHmul32_0(v) 580 case OpHmul32u: 581 return rewriteValueARM_OpHmul32u_0(v) 582 case OpInterCall: 583 return rewriteValueARM_OpInterCall_0(v) 584 case OpIsInBounds: 585 return rewriteValueARM_OpIsInBounds_0(v) 586 case OpIsNonNil: 587 return rewriteValueARM_OpIsNonNil_0(v) 588 case OpIsSliceInBounds: 589 return rewriteValueARM_OpIsSliceInBounds_0(v) 590 case OpLeq16: 591 return rewriteValueARM_OpLeq16_0(v) 592 case OpLeq16U: 593 return rewriteValueARM_OpLeq16U_0(v) 594 case OpLeq32: 595 return rewriteValueARM_OpLeq32_0(v) 596 case OpLeq32F: 597 return rewriteValueARM_OpLeq32F_0(v) 598 case OpLeq32U: 599 return rewriteValueARM_OpLeq32U_0(v) 600 case OpLeq64F: 601 return rewriteValueARM_OpLeq64F_0(v) 602 case OpLeq8: 603 return rewriteValueARM_OpLeq8_0(v) 604 case OpLeq8U: 605 return rewriteValueARM_OpLeq8U_0(v) 606 case OpLess16: 607 return rewriteValueARM_OpLess16_0(v) 608 case OpLess16U: 609 return rewriteValueARM_OpLess16U_0(v) 610 case OpLess32: 611 return rewriteValueARM_OpLess32_0(v) 612 case OpLess32F: 613 return rewriteValueARM_OpLess32F_0(v) 614 case OpLess32U: 615 return rewriteValueARM_OpLess32U_0(v) 616 case OpLess64F: 617 return rewriteValueARM_OpLess64F_0(v) 618 case OpLess8: 619 return rewriteValueARM_OpLess8_0(v) 620 case OpLess8U: 621 return rewriteValueARM_OpLess8U_0(v) 622 case OpLoad: 623 return rewriteValueARM_OpLoad_0(v) 624 case OpLocalAddr: 625 return rewriteValueARM_OpLocalAddr_0(v) 626 case OpLsh16x16: 627 return rewriteValueARM_OpLsh16x16_0(v) 628 case OpLsh16x32: 629 return rewriteValueARM_OpLsh16x32_0(v) 630 case OpLsh16x64: 631 return rewriteValueARM_OpLsh16x64_0(v) 632 case OpLsh16x8: 633 return rewriteValueARM_OpLsh16x8_0(v) 634 case OpLsh32x16: 635 return rewriteValueARM_OpLsh32x16_0(v) 636 case OpLsh32x32: 637 return rewriteValueARM_OpLsh32x32_0(v) 638 case OpLsh32x64: 639 return rewriteValueARM_OpLsh32x64_0(v) 640 case OpLsh32x8: 641 return rewriteValueARM_OpLsh32x8_0(v) 642 case OpLsh8x16: 643 return rewriteValueARM_OpLsh8x16_0(v) 644 case OpLsh8x32: 645 return rewriteValueARM_OpLsh8x32_0(v) 646 case OpLsh8x64: 647 return rewriteValueARM_OpLsh8x64_0(v) 648 case OpLsh8x8: 649 return rewriteValueARM_OpLsh8x8_0(v) 650 case OpMod16: 651 return rewriteValueARM_OpMod16_0(v) 652 case OpMod16u: 653 return rewriteValueARM_OpMod16u_0(v) 654 case OpMod32: 655 return rewriteValueARM_OpMod32_0(v) 656 case OpMod32u: 657 return rewriteValueARM_OpMod32u_0(v) 658 case OpMod8: 659 return rewriteValueARM_OpMod8_0(v) 660 case OpMod8u: 661 return rewriteValueARM_OpMod8u_0(v) 662 case OpMove: 663 return rewriteValueARM_OpMove_0(v) 664 case OpMul16: 665 return rewriteValueARM_OpMul16_0(v) 666 case OpMul32: 667 return rewriteValueARM_OpMul32_0(v) 668 case OpMul32F: 669 return rewriteValueARM_OpMul32F_0(v) 670 case OpMul32uhilo: 671 return rewriteValueARM_OpMul32uhilo_0(v) 672 case OpMul64F: 673 return rewriteValueARM_OpMul64F_0(v) 674 case OpMul8: 675 return rewriteValueARM_OpMul8_0(v) 676 case OpNeg16: 677 return rewriteValueARM_OpNeg16_0(v) 678 case OpNeg32: 679 return rewriteValueARM_OpNeg32_0(v) 680 case OpNeg32F: 681 return rewriteValueARM_OpNeg32F_0(v) 682 case OpNeg64F: 683 return rewriteValueARM_OpNeg64F_0(v) 684 case OpNeg8: 685 return rewriteValueARM_OpNeg8_0(v) 686 case OpNeq16: 687 return rewriteValueARM_OpNeq16_0(v) 688 case OpNeq32: 689 return rewriteValueARM_OpNeq32_0(v) 690 case OpNeq32F: 691 return rewriteValueARM_OpNeq32F_0(v) 692 case OpNeq64F: 693 return rewriteValueARM_OpNeq64F_0(v) 694 case OpNeq8: 695 return rewriteValueARM_OpNeq8_0(v) 696 case OpNeqB: 697 return rewriteValueARM_OpNeqB_0(v) 698 case OpNeqPtr: 699 return rewriteValueARM_OpNeqPtr_0(v) 700 case OpNilCheck: 701 return rewriteValueARM_OpNilCheck_0(v) 702 case OpNot: 703 return rewriteValueARM_OpNot_0(v) 704 case OpOffPtr: 705 return rewriteValueARM_OpOffPtr_0(v) 706 case OpOr16: 707 return rewriteValueARM_OpOr16_0(v) 708 case OpOr32: 709 return rewriteValueARM_OpOr32_0(v) 710 case OpOr8: 711 return rewriteValueARM_OpOr8_0(v) 712 case OpOrB: 713 return rewriteValueARM_OpOrB_0(v) 714 case OpRound32F: 715 return rewriteValueARM_OpRound32F_0(v) 716 case OpRound64F: 717 return rewriteValueARM_OpRound64F_0(v) 718 case OpRsh16Ux16: 719 return rewriteValueARM_OpRsh16Ux16_0(v) 720 case OpRsh16Ux32: 721 return rewriteValueARM_OpRsh16Ux32_0(v) 722 case OpRsh16Ux64: 723 return rewriteValueARM_OpRsh16Ux64_0(v) 724 case OpRsh16Ux8: 725 return rewriteValueARM_OpRsh16Ux8_0(v) 726 case OpRsh16x16: 727 return rewriteValueARM_OpRsh16x16_0(v) 728 case OpRsh16x32: 729 return rewriteValueARM_OpRsh16x32_0(v) 730 case OpRsh16x64: 731 return rewriteValueARM_OpRsh16x64_0(v) 732 case OpRsh16x8: 733 return rewriteValueARM_OpRsh16x8_0(v) 734 case OpRsh32Ux16: 735 return rewriteValueARM_OpRsh32Ux16_0(v) 736 case OpRsh32Ux32: 737 return rewriteValueARM_OpRsh32Ux32_0(v) 738 case OpRsh32Ux64: 739 return rewriteValueARM_OpRsh32Ux64_0(v) 740 case OpRsh32Ux8: 741 return rewriteValueARM_OpRsh32Ux8_0(v) 742 case OpRsh32x16: 743 return rewriteValueARM_OpRsh32x16_0(v) 744 case OpRsh32x32: 745 return rewriteValueARM_OpRsh32x32_0(v) 746 case OpRsh32x64: 747 return rewriteValueARM_OpRsh32x64_0(v) 748 case OpRsh32x8: 749 return rewriteValueARM_OpRsh32x8_0(v) 750 case OpRsh8Ux16: 751 return rewriteValueARM_OpRsh8Ux16_0(v) 752 case OpRsh8Ux32: 753 return rewriteValueARM_OpRsh8Ux32_0(v) 754 case OpRsh8Ux64: 755 return rewriteValueARM_OpRsh8Ux64_0(v) 756 case OpRsh8Ux8: 757 return rewriteValueARM_OpRsh8Ux8_0(v) 758 case OpRsh8x16: 759 return rewriteValueARM_OpRsh8x16_0(v) 760 case OpRsh8x32: 761 return rewriteValueARM_OpRsh8x32_0(v) 762 case OpRsh8x64: 763 return rewriteValueARM_OpRsh8x64_0(v) 764 case OpRsh8x8: 765 return rewriteValueARM_OpRsh8x8_0(v) 766 case OpSelect0: 767 return rewriteValueARM_OpSelect0_0(v) 768 case OpSelect1: 769 return rewriteValueARM_OpSelect1_0(v) 770 case OpSignExt16to32: 771 return rewriteValueARM_OpSignExt16to32_0(v) 772 case OpSignExt8to16: 773 return rewriteValueARM_OpSignExt8to16_0(v) 774 case OpSignExt8to32: 775 return rewriteValueARM_OpSignExt8to32_0(v) 776 case OpSignmask: 777 return rewriteValueARM_OpSignmask_0(v) 778 case OpSlicemask: 779 return rewriteValueARM_OpSlicemask_0(v) 780 case OpSqrt: 781 return rewriteValueARM_OpSqrt_0(v) 782 case OpStaticCall: 783 return rewriteValueARM_OpStaticCall_0(v) 784 case OpStore: 785 return rewriteValueARM_OpStore_0(v) 786 case OpSub16: 787 return rewriteValueARM_OpSub16_0(v) 788 case OpSub32: 789 return rewriteValueARM_OpSub32_0(v) 790 case OpSub32F: 791 return rewriteValueARM_OpSub32F_0(v) 792 case OpSub32carry: 793 return rewriteValueARM_OpSub32carry_0(v) 794 case OpSub32withcarry: 795 return rewriteValueARM_OpSub32withcarry_0(v) 796 case OpSub64F: 797 return rewriteValueARM_OpSub64F_0(v) 798 case OpSub8: 799 return rewriteValueARM_OpSub8_0(v) 800 case OpSubPtr: 801 return rewriteValueARM_OpSubPtr_0(v) 802 case OpTrunc16to8: 803 return rewriteValueARM_OpTrunc16to8_0(v) 804 case OpTrunc32to16: 805 return rewriteValueARM_OpTrunc32to16_0(v) 806 case OpTrunc32to8: 807 return rewriteValueARM_OpTrunc32to8_0(v) 808 case OpWB: 809 return rewriteValueARM_OpWB_0(v) 810 case OpXor16: 811 return rewriteValueARM_OpXor16_0(v) 812 case OpXor32: 813 return rewriteValueARM_OpXor32_0(v) 814 case OpXor8: 815 return rewriteValueARM_OpXor8_0(v) 816 case OpZero: 817 return rewriteValueARM_OpZero_0(v) 818 case OpZeroExt16to32: 819 return rewriteValueARM_OpZeroExt16to32_0(v) 820 case OpZeroExt8to16: 821 return rewriteValueARM_OpZeroExt8to16_0(v) 822 case OpZeroExt8to32: 823 return rewriteValueARM_OpZeroExt8to32_0(v) 824 case OpZeromask: 825 return rewriteValueARM_OpZeromask_0(v) 826 } 827 return false 828 } 829 func rewriteValueARM_OpARMADC_0(v *Value) bool { 830 // match: (ADC (MOVWconst [c]) x flags) 831 // cond: 832 // result: (ADCconst [c] x flags) 833 for { 834 _ = v.Args[2] 835 v_0 := v.Args[0] 836 if v_0.Op != OpARMMOVWconst { 837 break 838 } 839 c := v_0.AuxInt 840 x := v.Args[1] 841 flags := v.Args[2] 842 v.reset(OpARMADCconst) 843 v.AuxInt = c 844 v.AddArg(x) 845 v.AddArg(flags) 846 return true 847 } 848 // match: (ADC x (MOVWconst [c]) flags) 849 // cond: 850 // result: (ADCconst [c] x flags) 851 for { 852 _ = v.Args[2] 853 x := v.Args[0] 854 v_1 := v.Args[1] 855 if v_1.Op != OpARMMOVWconst { 856 break 857 } 858 c := v_1.AuxInt 859 flags := v.Args[2] 860 v.reset(OpARMADCconst) 861 v.AuxInt = c 862 v.AddArg(x) 863 v.AddArg(flags) 864 return true 865 } 866 // match: (ADC x (MOVWconst [c]) flags) 867 // cond: 868 // result: (ADCconst [c] x flags) 869 for { 870 _ = v.Args[2] 871 x := v.Args[0] 872 v_1 := v.Args[1] 873 if v_1.Op != OpARMMOVWconst { 874 break 875 } 876 c := v_1.AuxInt 877 flags := v.Args[2] 878 v.reset(OpARMADCconst) 879 v.AuxInt = c 880 v.AddArg(x) 881 v.AddArg(flags) 882 return true 883 } 884 // match: (ADC (MOVWconst [c]) x flags) 885 // cond: 886 // result: (ADCconst [c] x flags) 887 for { 888 _ = v.Args[2] 889 v_0 := v.Args[0] 890 if v_0.Op != OpARMMOVWconst { 891 break 892 } 893 c := v_0.AuxInt 894 x := v.Args[1] 895 flags := v.Args[2] 896 v.reset(OpARMADCconst) 897 v.AuxInt = c 898 v.AddArg(x) 899 v.AddArg(flags) 900 return true 901 } 902 // match: (ADC x (SLLconst [c] y) flags) 903 // cond: 904 // result: (ADCshiftLL x y [c] flags) 905 for { 906 _ = v.Args[2] 907 x := v.Args[0] 908 v_1 := v.Args[1] 909 if v_1.Op != OpARMSLLconst { 910 break 911 } 912 c := v_1.AuxInt 913 y := v_1.Args[0] 914 flags := v.Args[2] 915 v.reset(OpARMADCshiftLL) 916 v.AuxInt = c 917 v.AddArg(x) 918 v.AddArg(y) 919 v.AddArg(flags) 920 return true 921 } 922 // match: (ADC (SLLconst [c] y) x flags) 923 // cond: 924 // result: (ADCshiftLL x y [c] flags) 925 for { 926 _ = v.Args[2] 927 v_0 := v.Args[0] 928 if v_0.Op != OpARMSLLconst { 929 break 930 } 931 c := v_0.AuxInt 932 y := v_0.Args[0] 933 x := v.Args[1] 934 flags := v.Args[2] 935 v.reset(OpARMADCshiftLL) 936 v.AuxInt = c 937 v.AddArg(x) 938 v.AddArg(y) 939 v.AddArg(flags) 940 return true 941 } 942 // match: (ADC (SLLconst [c] y) x flags) 943 // cond: 944 // result: (ADCshiftLL x y [c] flags) 945 for { 946 _ = v.Args[2] 947 v_0 := v.Args[0] 948 if v_0.Op != OpARMSLLconst { 949 break 950 } 951 c := v_0.AuxInt 952 y := v_0.Args[0] 953 x := v.Args[1] 954 flags := v.Args[2] 955 v.reset(OpARMADCshiftLL) 956 v.AuxInt = c 957 v.AddArg(x) 958 v.AddArg(y) 959 v.AddArg(flags) 960 return true 961 } 962 // match: (ADC x (SLLconst [c] y) flags) 963 // cond: 964 // result: (ADCshiftLL x y [c] flags) 965 for { 966 _ = v.Args[2] 967 x := v.Args[0] 968 v_1 := v.Args[1] 969 if v_1.Op != OpARMSLLconst { 970 break 971 } 972 c := v_1.AuxInt 973 y := v_1.Args[0] 974 flags := v.Args[2] 975 v.reset(OpARMADCshiftLL) 976 v.AuxInt = c 977 v.AddArg(x) 978 v.AddArg(y) 979 v.AddArg(flags) 980 return true 981 } 982 // match: (ADC x (SRLconst [c] y) flags) 983 // cond: 984 // result: (ADCshiftRL x y [c] flags) 985 for { 986 _ = v.Args[2] 987 x := v.Args[0] 988 v_1 := v.Args[1] 989 if v_1.Op != OpARMSRLconst { 990 break 991 } 992 c := v_1.AuxInt 993 y := v_1.Args[0] 994 flags := v.Args[2] 995 v.reset(OpARMADCshiftRL) 996 v.AuxInt = c 997 v.AddArg(x) 998 v.AddArg(y) 999 v.AddArg(flags) 1000 return true 1001 } 1002 // match: (ADC (SRLconst [c] y) x flags) 1003 // cond: 1004 // result: (ADCshiftRL x y [c] flags) 1005 for { 1006 _ = v.Args[2] 1007 v_0 := v.Args[0] 1008 if v_0.Op != OpARMSRLconst { 1009 break 1010 } 1011 c := v_0.AuxInt 1012 y := v_0.Args[0] 1013 x := v.Args[1] 1014 flags := v.Args[2] 1015 v.reset(OpARMADCshiftRL) 1016 v.AuxInt = c 1017 v.AddArg(x) 1018 v.AddArg(y) 1019 v.AddArg(flags) 1020 return true 1021 } 1022 return false 1023 } 1024 func rewriteValueARM_OpARMADC_10(v *Value) bool { 1025 // match: (ADC (SRLconst [c] y) x flags) 1026 // cond: 1027 // result: (ADCshiftRL x y [c] flags) 1028 for { 1029 _ = v.Args[2] 1030 v_0 := v.Args[0] 1031 if v_0.Op != OpARMSRLconst { 1032 break 1033 } 1034 c := v_0.AuxInt 1035 y := v_0.Args[0] 1036 x := v.Args[1] 1037 flags := v.Args[2] 1038 v.reset(OpARMADCshiftRL) 1039 v.AuxInt = c 1040 v.AddArg(x) 1041 v.AddArg(y) 1042 v.AddArg(flags) 1043 return true 1044 } 1045 // match: (ADC x (SRLconst [c] y) flags) 1046 // cond: 1047 // result: (ADCshiftRL x y [c] flags) 1048 for { 1049 _ = v.Args[2] 1050 x := v.Args[0] 1051 v_1 := v.Args[1] 1052 if v_1.Op != OpARMSRLconst { 1053 break 1054 } 1055 c := v_1.AuxInt 1056 y := v_1.Args[0] 1057 flags := v.Args[2] 1058 v.reset(OpARMADCshiftRL) 1059 v.AuxInt = c 1060 v.AddArg(x) 1061 v.AddArg(y) 1062 v.AddArg(flags) 1063 return true 1064 } 1065 // match: (ADC x (SRAconst [c] y) flags) 1066 // cond: 1067 // result: (ADCshiftRA x y [c] flags) 1068 for { 1069 _ = v.Args[2] 1070 x := v.Args[0] 1071 v_1 := v.Args[1] 1072 if v_1.Op != OpARMSRAconst { 1073 break 1074 } 1075 c := v_1.AuxInt 1076 y := v_1.Args[0] 1077 flags := v.Args[2] 1078 v.reset(OpARMADCshiftRA) 1079 v.AuxInt = c 1080 v.AddArg(x) 1081 v.AddArg(y) 1082 v.AddArg(flags) 1083 return true 1084 } 1085 // match: (ADC (SRAconst [c] y) x flags) 1086 // cond: 1087 // result: (ADCshiftRA x y [c] flags) 1088 for { 1089 _ = v.Args[2] 1090 v_0 := v.Args[0] 1091 if v_0.Op != OpARMSRAconst { 1092 break 1093 } 1094 c := v_0.AuxInt 1095 y := v_0.Args[0] 1096 x := v.Args[1] 1097 flags := v.Args[2] 1098 v.reset(OpARMADCshiftRA) 1099 v.AuxInt = c 1100 v.AddArg(x) 1101 v.AddArg(y) 1102 v.AddArg(flags) 1103 return true 1104 } 1105 // match: (ADC (SRAconst [c] y) x flags) 1106 // cond: 1107 // result: (ADCshiftRA x y [c] flags) 1108 for { 1109 _ = v.Args[2] 1110 v_0 := v.Args[0] 1111 if v_0.Op != OpARMSRAconst { 1112 break 1113 } 1114 c := v_0.AuxInt 1115 y := v_0.Args[0] 1116 x := v.Args[1] 1117 flags := v.Args[2] 1118 v.reset(OpARMADCshiftRA) 1119 v.AuxInt = c 1120 v.AddArg(x) 1121 v.AddArg(y) 1122 v.AddArg(flags) 1123 return true 1124 } 1125 // match: (ADC x (SRAconst [c] y) flags) 1126 // cond: 1127 // result: (ADCshiftRA x y [c] flags) 1128 for { 1129 _ = v.Args[2] 1130 x := v.Args[0] 1131 v_1 := v.Args[1] 1132 if v_1.Op != OpARMSRAconst { 1133 break 1134 } 1135 c := v_1.AuxInt 1136 y := v_1.Args[0] 1137 flags := v.Args[2] 1138 v.reset(OpARMADCshiftRA) 1139 v.AuxInt = c 1140 v.AddArg(x) 1141 v.AddArg(y) 1142 v.AddArg(flags) 1143 return true 1144 } 1145 // match: (ADC x (SLL y z) flags) 1146 // cond: 1147 // result: (ADCshiftLLreg x y z flags) 1148 for { 1149 _ = v.Args[2] 1150 x := v.Args[0] 1151 v_1 := v.Args[1] 1152 if v_1.Op != OpARMSLL { 1153 break 1154 } 1155 _ = v_1.Args[1] 1156 y := v_1.Args[0] 1157 z := v_1.Args[1] 1158 flags := v.Args[2] 1159 v.reset(OpARMADCshiftLLreg) 1160 v.AddArg(x) 1161 v.AddArg(y) 1162 v.AddArg(z) 1163 v.AddArg(flags) 1164 return true 1165 } 1166 // match: (ADC (SLL y z) x flags) 1167 // cond: 1168 // result: (ADCshiftLLreg x y z flags) 1169 for { 1170 _ = v.Args[2] 1171 v_0 := v.Args[0] 1172 if v_0.Op != OpARMSLL { 1173 break 1174 } 1175 _ = v_0.Args[1] 1176 y := v_0.Args[0] 1177 z := v_0.Args[1] 1178 x := v.Args[1] 1179 flags := v.Args[2] 1180 v.reset(OpARMADCshiftLLreg) 1181 v.AddArg(x) 1182 v.AddArg(y) 1183 v.AddArg(z) 1184 v.AddArg(flags) 1185 return true 1186 } 1187 // match: (ADC (SLL y z) x flags) 1188 // cond: 1189 // result: (ADCshiftLLreg x y z flags) 1190 for { 1191 _ = v.Args[2] 1192 v_0 := v.Args[0] 1193 if v_0.Op != OpARMSLL { 1194 break 1195 } 1196 _ = v_0.Args[1] 1197 y := v_0.Args[0] 1198 z := v_0.Args[1] 1199 x := v.Args[1] 1200 flags := v.Args[2] 1201 v.reset(OpARMADCshiftLLreg) 1202 v.AddArg(x) 1203 v.AddArg(y) 1204 v.AddArg(z) 1205 v.AddArg(flags) 1206 return true 1207 } 1208 // match: (ADC x (SLL y z) flags) 1209 // cond: 1210 // result: (ADCshiftLLreg x y z flags) 1211 for { 1212 _ = v.Args[2] 1213 x := v.Args[0] 1214 v_1 := v.Args[1] 1215 if v_1.Op != OpARMSLL { 1216 break 1217 } 1218 _ = v_1.Args[1] 1219 y := v_1.Args[0] 1220 z := v_1.Args[1] 1221 flags := v.Args[2] 1222 v.reset(OpARMADCshiftLLreg) 1223 v.AddArg(x) 1224 v.AddArg(y) 1225 v.AddArg(z) 1226 v.AddArg(flags) 1227 return true 1228 } 1229 return false 1230 } 1231 func rewriteValueARM_OpARMADC_20(v *Value) bool { 1232 // match: (ADC x (SRL y z) flags) 1233 // cond: 1234 // result: (ADCshiftRLreg x y z flags) 1235 for { 1236 _ = v.Args[2] 1237 x := v.Args[0] 1238 v_1 := v.Args[1] 1239 if v_1.Op != OpARMSRL { 1240 break 1241 } 1242 _ = v_1.Args[1] 1243 y := v_1.Args[0] 1244 z := v_1.Args[1] 1245 flags := v.Args[2] 1246 v.reset(OpARMADCshiftRLreg) 1247 v.AddArg(x) 1248 v.AddArg(y) 1249 v.AddArg(z) 1250 v.AddArg(flags) 1251 return true 1252 } 1253 // match: (ADC (SRL y z) x flags) 1254 // cond: 1255 // result: (ADCshiftRLreg x y z flags) 1256 for { 1257 _ = v.Args[2] 1258 v_0 := v.Args[0] 1259 if v_0.Op != OpARMSRL { 1260 break 1261 } 1262 _ = v_0.Args[1] 1263 y := v_0.Args[0] 1264 z := v_0.Args[1] 1265 x := v.Args[1] 1266 flags := v.Args[2] 1267 v.reset(OpARMADCshiftRLreg) 1268 v.AddArg(x) 1269 v.AddArg(y) 1270 v.AddArg(z) 1271 v.AddArg(flags) 1272 return true 1273 } 1274 // match: (ADC (SRL y z) x flags) 1275 // cond: 1276 // result: (ADCshiftRLreg x y z flags) 1277 for { 1278 _ = v.Args[2] 1279 v_0 := v.Args[0] 1280 if v_0.Op != OpARMSRL { 1281 break 1282 } 1283 _ = v_0.Args[1] 1284 y := v_0.Args[0] 1285 z := v_0.Args[1] 1286 x := v.Args[1] 1287 flags := v.Args[2] 1288 v.reset(OpARMADCshiftRLreg) 1289 v.AddArg(x) 1290 v.AddArg(y) 1291 v.AddArg(z) 1292 v.AddArg(flags) 1293 return true 1294 } 1295 // match: (ADC x (SRL y z) flags) 1296 // cond: 1297 // result: (ADCshiftRLreg x y z flags) 1298 for { 1299 _ = v.Args[2] 1300 x := v.Args[0] 1301 v_1 := v.Args[1] 1302 if v_1.Op != OpARMSRL { 1303 break 1304 } 1305 _ = v_1.Args[1] 1306 y := v_1.Args[0] 1307 z := v_1.Args[1] 1308 flags := v.Args[2] 1309 v.reset(OpARMADCshiftRLreg) 1310 v.AddArg(x) 1311 v.AddArg(y) 1312 v.AddArg(z) 1313 v.AddArg(flags) 1314 return true 1315 } 1316 // match: (ADC x (SRA y z) flags) 1317 // cond: 1318 // result: (ADCshiftRAreg x y z flags) 1319 for { 1320 _ = v.Args[2] 1321 x := v.Args[0] 1322 v_1 := v.Args[1] 1323 if v_1.Op != OpARMSRA { 1324 break 1325 } 1326 _ = v_1.Args[1] 1327 y := v_1.Args[0] 1328 z := v_1.Args[1] 1329 flags := v.Args[2] 1330 v.reset(OpARMADCshiftRAreg) 1331 v.AddArg(x) 1332 v.AddArg(y) 1333 v.AddArg(z) 1334 v.AddArg(flags) 1335 return true 1336 } 1337 // match: (ADC (SRA y z) x flags) 1338 // cond: 1339 // result: (ADCshiftRAreg x y z flags) 1340 for { 1341 _ = v.Args[2] 1342 v_0 := v.Args[0] 1343 if v_0.Op != OpARMSRA { 1344 break 1345 } 1346 _ = v_0.Args[1] 1347 y := v_0.Args[0] 1348 z := v_0.Args[1] 1349 x := v.Args[1] 1350 flags := v.Args[2] 1351 v.reset(OpARMADCshiftRAreg) 1352 v.AddArg(x) 1353 v.AddArg(y) 1354 v.AddArg(z) 1355 v.AddArg(flags) 1356 return true 1357 } 1358 // match: (ADC (SRA y z) x flags) 1359 // cond: 1360 // result: (ADCshiftRAreg x y z flags) 1361 for { 1362 _ = v.Args[2] 1363 v_0 := v.Args[0] 1364 if v_0.Op != OpARMSRA { 1365 break 1366 } 1367 _ = v_0.Args[1] 1368 y := v_0.Args[0] 1369 z := v_0.Args[1] 1370 x := v.Args[1] 1371 flags := v.Args[2] 1372 v.reset(OpARMADCshiftRAreg) 1373 v.AddArg(x) 1374 v.AddArg(y) 1375 v.AddArg(z) 1376 v.AddArg(flags) 1377 return true 1378 } 1379 // match: (ADC x (SRA y z) flags) 1380 // cond: 1381 // result: (ADCshiftRAreg x y z flags) 1382 for { 1383 _ = v.Args[2] 1384 x := v.Args[0] 1385 v_1 := v.Args[1] 1386 if v_1.Op != OpARMSRA { 1387 break 1388 } 1389 _ = v_1.Args[1] 1390 y := v_1.Args[0] 1391 z := v_1.Args[1] 1392 flags := v.Args[2] 1393 v.reset(OpARMADCshiftRAreg) 1394 v.AddArg(x) 1395 v.AddArg(y) 1396 v.AddArg(z) 1397 v.AddArg(flags) 1398 return true 1399 } 1400 return false 1401 } 1402 func rewriteValueARM_OpARMADCconst_0(v *Value) bool { 1403 // match: (ADCconst [c] (ADDconst [d] x) flags) 1404 // cond: 1405 // result: (ADCconst [int64(int32(c+d))] x flags) 1406 for { 1407 c := v.AuxInt 1408 _ = v.Args[1] 1409 v_0 := v.Args[0] 1410 if v_0.Op != OpARMADDconst { 1411 break 1412 } 1413 d := v_0.AuxInt 1414 x := v_0.Args[0] 1415 flags := v.Args[1] 1416 v.reset(OpARMADCconst) 1417 v.AuxInt = int64(int32(c + d)) 1418 v.AddArg(x) 1419 v.AddArg(flags) 1420 return true 1421 } 1422 // match: (ADCconst [c] (SUBconst [d] x) flags) 1423 // cond: 1424 // result: (ADCconst [int64(int32(c-d))] x flags) 1425 for { 1426 c := v.AuxInt 1427 _ = v.Args[1] 1428 v_0 := v.Args[0] 1429 if v_0.Op != OpARMSUBconst { 1430 break 1431 } 1432 d := v_0.AuxInt 1433 x := v_0.Args[0] 1434 flags := v.Args[1] 1435 v.reset(OpARMADCconst) 1436 v.AuxInt = int64(int32(c - d)) 1437 v.AddArg(x) 1438 v.AddArg(flags) 1439 return true 1440 } 1441 return false 1442 } 1443 func rewriteValueARM_OpARMADCshiftLL_0(v *Value) bool { 1444 b := v.Block 1445 _ = b 1446 // match: (ADCshiftLL (MOVWconst [c]) x [d] flags) 1447 // cond: 1448 // result: (ADCconst [c] (SLLconst <x.Type> x [d]) flags) 1449 for { 1450 d := v.AuxInt 1451 _ = v.Args[2] 1452 v_0 := v.Args[0] 1453 if v_0.Op != OpARMMOVWconst { 1454 break 1455 } 1456 c := v_0.AuxInt 1457 x := v.Args[1] 1458 flags := v.Args[2] 1459 v.reset(OpARMADCconst) 1460 v.AuxInt = c 1461 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 1462 v0.AuxInt = d 1463 v0.AddArg(x) 1464 v.AddArg(v0) 1465 v.AddArg(flags) 1466 return true 1467 } 1468 // match: (ADCshiftLL x (MOVWconst [c]) [d] flags) 1469 // cond: 1470 // result: (ADCconst x [int64(int32(uint32(c)<<uint64(d)))] flags) 1471 for { 1472 d := v.AuxInt 1473 _ = v.Args[2] 1474 x := v.Args[0] 1475 v_1 := v.Args[1] 1476 if v_1.Op != OpARMMOVWconst { 1477 break 1478 } 1479 c := v_1.AuxInt 1480 flags := v.Args[2] 1481 v.reset(OpARMADCconst) 1482 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 1483 v.AddArg(x) 1484 v.AddArg(flags) 1485 return true 1486 } 1487 return false 1488 } 1489 func rewriteValueARM_OpARMADCshiftLLreg_0(v *Value) bool { 1490 b := v.Block 1491 _ = b 1492 // match: (ADCshiftLLreg (MOVWconst [c]) x y flags) 1493 // cond: 1494 // result: (ADCconst [c] (SLL <x.Type> x y) flags) 1495 for { 1496 _ = v.Args[3] 1497 v_0 := v.Args[0] 1498 if v_0.Op != OpARMMOVWconst { 1499 break 1500 } 1501 c := v_0.AuxInt 1502 x := v.Args[1] 1503 y := v.Args[2] 1504 flags := v.Args[3] 1505 v.reset(OpARMADCconst) 1506 v.AuxInt = c 1507 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 1508 v0.AddArg(x) 1509 v0.AddArg(y) 1510 v.AddArg(v0) 1511 v.AddArg(flags) 1512 return true 1513 } 1514 // match: (ADCshiftLLreg x y (MOVWconst [c]) flags) 1515 // cond: 1516 // result: (ADCshiftLL x y [c] flags) 1517 for { 1518 _ = v.Args[3] 1519 x := v.Args[0] 1520 y := v.Args[1] 1521 v_2 := v.Args[2] 1522 if v_2.Op != OpARMMOVWconst { 1523 break 1524 } 1525 c := v_2.AuxInt 1526 flags := v.Args[3] 1527 v.reset(OpARMADCshiftLL) 1528 v.AuxInt = c 1529 v.AddArg(x) 1530 v.AddArg(y) 1531 v.AddArg(flags) 1532 return true 1533 } 1534 return false 1535 } 1536 func rewriteValueARM_OpARMADCshiftRA_0(v *Value) bool { 1537 b := v.Block 1538 _ = b 1539 // match: (ADCshiftRA (MOVWconst [c]) x [d] flags) 1540 // cond: 1541 // result: (ADCconst [c] (SRAconst <x.Type> x [d]) flags) 1542 for { 1543 d := v.AuxInt 1544 _ = v.Args[2] 1545 v_0 := v.Args[0] 1546 if v_0.Op != OpARMMOVWconst { 1547 break 1548 } 1549 c := v_0.AuxInt 1550 x := v.Args[1] 1551 flags := v.Args[2] 1552 v.reset(OpARMADCconst) 1553 v.AuxInt = c 1554 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 1555 v0.AuxInt = d 1556 v0.AddArg(x) 1557 v.AddArg(v0) 1558 v.AddArg(flags) 1559 return true 1560 } 1561 // match: (ADCshiftRA x (MOVWconst [c]) [d] flags) 1562 // cond: 1563 // result: (ADCconst x [int64(int32(c)>>uint64(d))] flags) 1564 for { 1565 d := v.AuxInt 1566 _ = v.Args[2] 1567 x := v.Args[0] 1568 v_1 := v.Args[1] 1569 if v_1.Op != OpARMMOVWconst { 1570 break 1571 } 1572 c := v_1.AuxInt 1573 flags := v.Args[2] 1574 v.reset(OpARMADCconst) 1575 v.AuxInt = int64(int32(c) >> uint64(d)) 1576 v.AddArg(x) 1577 v.AddArg(flags) 1578 return true 1579 } 1580 return false 1581 } 1582 func rewriteValueARM_OpARMADCshiftRAreg_0(v *Value) bool { 1583 b := v.Block 1584 _ = b 1585 // match: (ADCshiftRAreg (MOVWconst [c]) x y flags) 1586 // cond: 1587 // result: (ADCconst [c] (SRA <x.Type> x y) flags) 1588 for { 1589 _ = v.Args[3] 1590 v_0 := v.Args[0] 1591 if v_0.Op != OpARMMOVWconst { 1592 break 1593 } 1594 c := v_0.AuxInt 1595 x := v.Args[1] 1596 y := v.Args[2] 1597 flags := v.Args[3] 1598 v.reset(OpARMADCconst) 1599 v.AuxInt = c 1600 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 1601 v0.AddArg(x) 1602 v0.AddArg(y) 1603 v.AddArg(v0) 1604 v.AddArg(flags) 1605 return true 1606 } 1607 // match: (ADCshiftRAreg x y (MOVWconst [c]) flags) 1608 // cond: 1609 // result: (ADCshiftRA x y [c] flags) 1610 for { 1611 _ = v.Args[3] 1612 x := v.Args[0] 1613 y := v.Args[1] 1614 v_2 := v.Args[2] 1615 if v_2.Op != OpARMMOVWconst { 1616 break 1617 } 1618 c := v_2.AuxInt 1619 flags := v.Args[3] 1620 v.reset(OpARMADCshiftRA) 1621 v.AuxInt = c 1622 v.AddArg(x) 1623 v.AddArg(y) 1624 v.AddArg(flags) 1625 return true 1626 } 1627 return false 1628 } 1629 func rewriteValueARM_OpARMADCshiftRL_0(v *Value) bool { 1630 b := v.Block 1631 _ = b 1632 // match: (ADCshiftRL (MOVWconst [c]) x [d] flags) 1633 // cond: 1634 // result: (ADCconst [c] (SRLconst <x.Type> x [d]) flags) 1635 for { 1636 d := v.AuxInt 1637 _ = v.Args[2] 1638 v_0 := v.Args[0] 1639 if v_0.Op != OpARMMOVWconst { 1640 break 1641 } 1642 c := v_0.AuxInt 1643 x := v.Args[1] 1644 flags := v.Args[2] 1645 v.reset(OpARMADCconst) 1646 v.AuxInt = c 1647 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 1648 v0.AuxInt = d 1649 v0.AddArg(x) 1650 v.AddArg(v0) 1651 v.AddArg(flags) 1652 return true 1653 } 1654 // match: (ADCshiftRL x (MOVWconst [c]) [d] flags) 1655 // cond: 1656 // result: (ADCconst x [int64(int32(uint32(c)>>uint64(d)))] flags) 1657 for { 1658 d := v.AuxInt 1659 _ = v.Args[2] 1660 x := v.Args[0] 1661 v_1 := v.Args[1] 1662 if v_1.Op != OpARMMOVWconst { 1663 break 1664 } 1665 c := v_1.AuxInt 1666 flags := v.Args[2] 1667 v.reset(OpARMADCconst) 1668 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 1669 v.AddArg(x) 1670 v.AddArg(flags) 1671 return true 1672 } 1673 return false 1674 } 1675 func rewriteValueARM_OpARMADCshiftRLreg_0(v *Value) bool { 1676 b := v.Block 1677 _ = b 1678 // match: (ADCshiftRLreg (MOVWconst [c]) x y flags) 1679 // cond: 1680 // result: (ADCconst [c] (SRL <x.Type> x y) flags) 1681 for { 1682 _ = v.Args[3] 1683 v_0 := v.Args[0] 1684 if v_0.Op != OpARMMOVWconst { 1685 break 1686 } 1687 c := v_0.AuxInt 1688 x := v.Args[1] 1689 y := v.Args[2] 1690 flags := v.Args[3] 1691 v.reset(OpARMADCconst) 1692 v.AuxInt = c 1693 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 1694 v0.AddArg(x) 1695 v0.AddArg(y) 1696 v.AddArg(v0) 1697 v.AddArg(flags) 1698 return true 1699 } 1700 // match: (ADCshiftRLreg x y (MOVWconst [c]) flags) 1701 // cond: 1702 // result: (ADCshiftRL x y [c] flags) 1703 for { 1704 _ = v.Args[3] 1705 x := v.Args[0] 1706 y := v.Args[1] 1707 v_2 := v.Args[2] 1708 if v_2.Op != OpARMMOVWconst { 1709 break 1710 } 1711 c := v_2.AuxInt 1712 flags := v.Args[3] 1713 v.reset(OpARMADCshiftRL) 1714 v.AuxInt = c 1715 v.AddArg(x) 1716 v.AddArg(y) 1717 v.AddArg(flags) 1718 return true 1719 } 1720 return false 1721 } 1722 func rewriteValueARM_OpARMADD_0(v *Value) bool { 1723 // match: (ADD x (MOVWconst [c])) 1724 // cond: 1725 // result: (ADDconst [c] x) 1726 for { 1727 _ = v.Args[1] 1728 x := v.Args[0] 1729 v_1 := v.Args[1] 1730 if v_1.Op != OpARMMOVWconst { 1731 break 1732 } 1733 c := v_1.AuxInt 1734 v.reset(OpARMADDconst) 1735 v.AuxInt = c 1736 v.AddArg(x) 1737 return true 1738 } 1739 // match: (ADD (MOVWconst [c]) x) 1740 // cond: 1741 // result: (ADDconst [c] x) 1742 for { 1743 _ = v.Args[1] 1744 v_0 := v.Args[0] 1745 if v_0.Op != OpARMMOVWconst { 1746 break 1747 } 1748 c := v_0.AuxInt 1749 x := v.Args[1] 1750 v.reset(OpARMADDconst) 1751 v.AuxInt = c 1752 v.AddArg(x) 1753 return true 1754 } 1755 // match: (ADD x (SLLconst [c] y)) 1756 // cond: 1757 // result: (ADDshiftLL x y [c]) 1758 for { 1759 _ = v.Args[1] 1760 x := v.Args[0] 1761 v_1 := v.Args[1] 1762 if v_1.Op != OpARMSLLconst { 1763 break 1764 } 1765 c := v_1.AuxInt 1766 y := v_1.Args[0] 1767 v.reset(OpARMADDshiftLL) 1768 v.AuxInt = c 1769 v.AddArg(x) 1770 v.AddArg(y) 1771 return true 1772 } 1773 // match: (ADD (SLLconst [c] y) x) 1774 // cond: 1775 // result: (ADDshiftLL x y [c]) 1776 for { 1777 _ = v.Args[1] 1778 v_0 := v.Args[0] 1779 if v_0.Op != OpARMSLLconst { 1780 break 1781 } 1782 c := v_0.AuxInt 1783 y := v_0.Args[0] 1784 x := v.Args[1] 1785 v.reset(OpARMADDshiftLL) 1786 v.AuxInt = c 1787 v.AddArg(x) 1788 v.AddArg(y) 1789 return true 1790 } 1791 // match: (ADD x (SRLconst [c] y)) 1792 // cond: 1793 // result: (ADDshiftRL x y [c]) 1794 for { 1795 _ = v.Args[1] 1796 x := v.Args[0] 1797 v_1 := v.Args[1] 1798 if v_1.Op != OpARMSRLconst { 1799 break 1800 } 1801 c := v_1.AuxInt 1802 y := v_1.Args[0] 1803 v.reset(OpARMADDshiftRL) 1804 v.AuxInt = c 1805 v.AddArg(x) 1806 v.AddArg(y) 1807 return true 1808 } 1809 // match: (ADD (SRLconst [c] y) x) 1810 // cond: 1811 // result: (ADDshiftRL x y [c]) 1812 for { 1813 _ = v.Args[1] 1814 v_0 := v.Args[0] 1815 if v_0.Op != OpARMSRLconst { 1816 break 1817 } 1818 c := v_0.AuxInt 1819 y := v_0.Args[0] 1820 x := v.Args[1] 1821 v.reset(OpARMADDshiftRL) 1822 v.AuxInt = c 1823 v.AddArg(x) 1824 v.AddArg(y) 1825 return true 1826 } 1827 // match: (ADD x (SRAconst [c] y)) 1828 // cond: 1829 // result: (ADDshiftRA x y [c]) 1830 for { 1831 _ = v.Args[1] 1832 x := v.Args[0] 1833 v_1 := v.Args[1] 1834 if v_1.Op != OpARMSRAconst { 1835 break 1836 } 1837 c := v_1.AuxInt 1838 y := v_1.Args[0] 1839 v.reset(OpARMADDshiftRA) 1840 v.AuxInt = c 1841 v.AddArg(x) 1842 v.AddArg(y) 1843 return true 1844 } 1845 // match: (ADD (SRAconst [c] y) x) 1846 // cond: 1847 // result: (ADDshiftRA x y [c]) 1848 for { 1849 _ = v.Args[1] 1850 v_0 := v.Args[0] 1851 if v_0.Op != OpARMSRAconst { 1852 break 1853 } 1854 c := v_0.AuxInt 1855 y := v_0.Args[0] 1856 x := v.Args[1] 1857 v.reset(OpARMADDshiftRA) 1858 v.AuxInt = c 1859 v.AddArg(x) 1860 v.AddArg(y) 1861 return true 1862 } 1863 // match: (ADD x (SLL y z)) 1864 // cond: 1865 // result: (ADDshiftLLreg x y z) 1866 for { 1867 _ = v.Args[1] 1868 x := v.Args[0] 1869 v_1 := v.Args[1] 1870 if v_1.Op != OpARMSLL { 1871 break 1872 } 1873 _ = v_1.Args[1] 1874 y := v_1.Args[0] 1875 z := v_1.Args[1] 1876 v.reset(OpARMADDshiftLLreg) 1877 v.AddArg(x) 1878 v.AddArg(y) 1879 v.AddArg(z) 1880 return true 1881 } 1882 // match: (ADD (SLL y z) x) 1883 // cond: 1884 // result: (ADDshiftLLreg x y z) 1885 for { 1886 _ = v.Args[1] 1887 v_0 := v.Args[0] 1888 if v_0.Op != OpARMSLL { 1889 break 1890 } 1891 _ = v_0.Args[1] 1892 y := v_0.Args[0] 1893 z := v_0.Args[1] 1894 x := v.Args[1] 1895 v.reset(OpARMADDshiftLLreg) 1896 v.AddArg(x) 1897 v.AddArg(y) 1898 v.AddArg(z) 1899 return true 1900 } 1901 return false 1902 } 1903 func rewriteValueARM_OpARMADD_10(v *Value) bool { 1904 b := v.Block 1905 _ = b 1906 // match: (ADD x (SRL y z)) 1907 // cond: 1908 // result: (ADDshiftRLreg x y z) 1909 for { 1910 _ = v.Args[1] 1911 x := v.Args[0] 1912 v_1 := v.Args[1] 1913 if v_1.Op != OpARMSRL { 1914 break 1915 } 1916 _ = v_1.Args[1] 1917 y := v_1.Args[0] 1918 z := v_1.Args[1] 1919 v.reset(OpARMADDshiftRLreg) 1920 v.AddArg(x) 1921 v.AddArg(y) 1922 v.AddArg(z) 1923 return true 1924 } 1925 // match: (ADD (SRL y z) x) 1926 // cond: 1927 // result: (ADDshiftRLreg x y z) 1928 for { 1929 _ = v.Args[1] 1930 v_0 := v.Args[0] 1931 if v_0.Op != OpARMSRL { 1932 break 1933 } 1934 _ = v_0.Args[1] 1935 y := v_0.Args[0] 1936 z := v_0.Args[1] 1937 x := v.Args[1] 1938 v.reset(OpARMADDshiftRLreg) 1939 v.AddArg(x) 1940 v.AddArg(y) 1941 v.AddArg(z) 1942 return true 1943 } 1944 // match: (ADD x (SRA y z)) 1945 // cond: 1946 // result: (ADDshiftRAreg x y z) 1947 for { 1948 _ = v.Args[1] 1949 x := v.Args[0] 1950 v_1 := v.Args[1] 1951 if v_1.Op != OpARMSRA { 1952 break 1953 } 1954 _ = v_1.Args[1] 1955 y := v_1.Args[0] 1956 z := v_1.Args[1] 1957 v.reset(OpARMADDshiftRAreg) 1958 v.AddArg(x) 1959 v.AddArg(y) 1960 v.AddArg(z) 1961 return true 1962 } 1963 // match: (ADD (SRA y z) x) 1964 // cond: 1965 // result: (ADDshiftRAreg x y z) 1966 for { 1967 _ = v.Args[1] 1968 v_0 := v.Args[0] 1969 if v_0.Op != OpARMSRA { 1970 break 1971 } 1972 _ = v_0.Args[1] 1973 y := v_0.Args[0] 1974 z := v_0.Args[1] 1975 x := v.Args[1] 1976 v.reset(OpARMADDshiftRAreg) 1977 v.AddArg(x) 1978 v.AddArg(y) 1979 v.AddArg(z) 1980 return true 1981 } 1982 // match: (ADD x (RSBconst [0] y)) 1983 // cond: 1984 // result: (SUB x y) 1985 for { 1986 _ = v.Args[1] 1987 x := v.Args[0] 1988 v_1 := v.Args[1] 1989 if v_1.Op != OpARMRSBconst { 1990 break 1991 } 1992 if v_1.AuxInt != 0 { 1993 break 1994 } 1995 y := v_1.Args[0] 1996 v.reset(OpARMSUB) 1997 v.AddArg(x) 1998 v.AddArg(y) 1999 return true 2000 } 2001 // match: (ADD (RSBconst [0] y) x) 2002 // cond: 2003 // result: (SUB x y) 2004 for { 2005 _ = v.Args[1] 2006 v_0 := v.Args[0] 2007 if v_0.Op != OpARMRSBconst { 2008 break 2009 } 2010 if v_0.AuxInt != 0 { 2011 break 2012 } 2013 y := v_0.Args[0] 2014 x := v.Args[1] 2015 v.reset(OpARMSUB) 2016 v.AddArg(x) 2017 v.AddArg(y) 2018 return true 2019 } 2020 // match: (ADD <t> (RSBconst [c] x) (RSBconst [d] y)) 2021 // cond: 2022 // result: (RSBconst [c+d] (ADD <t> x y)) 2023 for { 2024 t := v.Type 2025 _ = v.Args[1] 2026 v_0 := v.Args[0] 2027 if v_0.Op != OpARMRSBconst { 2028 break 2029 } 2030 c := v_0.AuxInt 2031 x := v_0.Args[0] 2032 v_1 := v.Args[1] 2033 if v_1.Op != OpARMRSBconst { 2034 break 2035 } 2036 d := v_1.AuxInt 2037 y := v_1.Args[0] 2038 v.reset(OpARMRSBconst) 2039 v.AuxInt = c + d 2040 v0 := b.NewValue0(v.Pos, OpARMADD, t) 2041 v0.AddArg(x) 2042 v0.AddArg(y) 2043 v.AddArg(v0) 2044 return true 2045 } 2046 // match: (ADD <t> (RSBconst [d] y) (RSBconst [c] x)) 2047 // cond: 2048 // result: (RSBconst [c+d] (ADD <t> x y)) 2049 for { 2050 t := v.Type 2051 _ = v.Args[1] 2052 v_0 := v.Args[0] 2053 if v_0.Op != OpARMRSBconst { 2054 break 2055 } 2056 d := v_0.AuxInt 2057 y := v_0.Args[0] 2058 v_1 := v.Args[1] 2059 if v_1.Op != OpARMRSBconst { 2060 break 2061 } 2062 c := v_1.AuxInt 2063 x := v_1.Args[0] 2064 v.reset(OpARMRSBconst) 2065 v.AuxInt = c + d 2066 v0 := b.NewValue0(v.Pos, OpARMADD, t) 2067 v0.AddArg(x) 2068 v0.AddArg(y) 2069 v.AddArg(v0) 2070 return true 2071 } 2072 // match: (ADD (MUL x y) a) 2073 // cond: 2074 // result: (MULA x y a) 2075 for { 2076 _ = v.Args[1] 2077 v_0 := v.Args[0] 2078 if v_0.Op != OpARMMUL { 2079 break 2080 } 2081 _ = v_0.Args[1] 2082 x := v_0.Args[0] 2083 y := v_0.Args[1] 2084 a := v.Args[1] 2085 v.reset(OpARMMULA) 2086 v.AddArg(x) 2087 v.AddArg(y) 2088 v.AddArg(a) 2089 return true 2090 } 2091 // match: (ADD a (MUL x y)) 2092 // cond: 2093 // result: (MULA x y a) 2094 for { 2095 _ = v.Args[1] 2096 a := v.Args[0] 2097 v_1 := v.Args[1] 2098 if v_1.Op != OpARMMUL { 2099 break 2100 } 2101 _ = v_1.Args[1] 2102 x := v_1.Args[0] 2103 y := v_1.Args[1] 2104 v.reset(OpARMMULA) 2105 v.AddArg(x) 2106 v.AddArg(y) 2107 v.AddArg(a) 2108 return true 2109 } 2110 return false 2111 } 2112 func rewriteValueARM_OpARMADDD_0(v *Value) bool { 2113 // match: (ADDD a (MULD x y)) 2114 // cond: a.Uses == 1 && objabi.GOARM >= 6 2115 // result: (MULAD a x y) 2116 for { 2117 _ = v.Args[1] 2118 a := v.Args[0] 2119 v_1 := v.Args[1] 2120 if v_1.Op != OpARMMULD { 2121 break 2122 } 2123 _ = v_1.Args[1] 2124 x := v_1.Args[0] 2125 y := v_1.Args[1] 2126 if !(a.Uses == 1 && objabi.GOARM >= 6) { 2127 break 2128 } 2129 v.reset(OpARMMULAD) 2130 v.AddArg(a) 2131 v.AddArg(x) 2132 v.AddArg(y) 2133 return true 2134 } 2135 // match: (ADDD (MULD x y) a) 2136 // cond: a.Uses == 1 && objabi.GOARM >= 6 2137 // result: (MULAD a x y) 2138 for { 2139 _ = v.Args[1] 2140 v_0 := v.Args[0] 2141 if v_0.Op != OpARMMULD { 2142 break 2143 } 2144 _ = v_0.Args[1] 2145 x := v_0.Args[0] 2146 y := v_0.Args[1] 2147 a := v.Args[1] 2148 if !(a.Uses == 1 && objabi.GOARM >= 6) { 2149 break 2150 } 2151 v.reset(OpARMMULAD) 2152 v.AddArg(a) 2153 v.AddArg(x) 2154 v.AddArg(y) 2155 return true 2156 } 2157 // match: (ADDD a (NMULD x y)) 2158 // cond: a.Uses == 1 && objabi.GOARM >= 6 2159 // result: (MULSD a x y) 2160 for { 2161 _ = v.Args[1] 2162 a := v.Args[0] 2163 v_1 := v.Args[1] 2164 if v_1.Op != OpARMNMULD { 2165 break 2166 } 2167 _ = v_1.Args[1] 2168 x := v_1.Args[0] 2169 y := v_1.Args[1] 2170 if !(a.Uses == 1 && objabi.GOARM >= 6) { 2171 break 2172 } 2173 v.reset(OpARMMULSD) 2174 v.AddArg(a) 2175 v.AddArg(x) 2176 v.AddArg(y) 2177 return true 2178 } 2179 // match: (ADDD (NMULD x y) a) 2180 // cond: a.Uses == 1 && objabi.GOARM >= 6 2181 // result: (MULSD a x y) 2182 for { 2183 _ = v.Args[1] 2184 v_0 := v.Args[0] 2185 if v_0.Op != OpARMNMULD { 2186 break 2187 } 2188 _ = v_0.Args[1] 2189 x := v_0.Args[0] 2190 y := v_0.Args[1] 2191 a := v.Args[1] 2192 if !(a.Uses == 1 && objabi.GOARM >= 6) { 2193 break 2194 } 2195 v.reset(OpARMMULSD) 2196 v.AddArg(a) 2197 v.AddArg(x) 2198 v.AddArg(y) 2199 return true 2200 } 2201 return false 2202 } 2203 func rewriteValueARM_OpARMADDF_0(v *Value) bool { 2204 // match: (ADDF a (MULF x y)) 2205 // cond: a.Uses == 1 && objabi.GOARM >= 6 2206 // result: (MULAF a x y) 2207 for { 2208 _ = v.Args[1] 2209 a := v.Args[0] 2210 v_1 := v.Args[1] 2211 if v_1.Op != OpARMMULF { 2212 break 2213 } 2214 _ = v_1.Args[1] 2215 x := v_1.Args[0] 2216 y := v_1.Args[1] 2217 if !(a.Uses == 1 && objabi.GOARM >= 6) { 2218 break 2219 } 2220 v.reset(OpARMMULAF) 2221 v.AddArg(a) 2222 v.AddArg(x) 2223 v.AddArg(y) 2224 return true 2225 } 2226 // match: (ADDF (MULF x y) a) 2227 // cond: a.Uses == 1 && objabi.GOARM >= 6 2228 // result: (MULAF a x y) 2229 for { 2230 _ = v.Args[1] 2231 v_0 := v.Args[0] 2232 if v_0.Op != OpARMMULF { 2233 break 2234 } 2235 _ = v_0.Args[1] 2236 x := v_0.Args[0] 2237 y := v_0.Args[1] 2238 a := v.Args[1] 2239 if !(a.Uses == 1 && objabi.GOARM >= 6) { 2240 break 2241 } 2242 v.reset(OpARMMULAF) 2243 v.AddArg(a) 2244 v.AddArg(x) 2245 v.AddArg(y) 2246 return true 2247 } 2248 // match: (ADDF a (NMULF x y)) 2249 // cond: a.Uses == 1 && objabi.GOARM >= 6 2250 // result: (MULSF a x y) 2251 for { 2252 _ = v.Args[1] 2253 a := v.Args[0] 2254 v_1 := v.Args[1] 2255 if v_1.Op != OpARMNMULF { 2256 break 2257 } 2258 _ = v_1.Args[1] 2259 x := v_1.Args[0] 2260 y := v_1.Args[1] 2261 if !(a.Uses == 1 && objabi.GOARM >= 6) { 2262 break 2263 } 2264 v.reset(OpARMMULSF) 2265 v.AddArg(a) 2266 v.AddArg(x) 2267 v.AddArg(y) 2268 return true 2269 } 2270 // match: (ADDF (NMULF x y) a) 2271 // cond: a.Uses == 1 && objabi.GOARM >= 6 2272 // result: (MULSF a x y) 2273 for { 2274 _ = v.Args[1] 2275 v_0 := v.Args[0] 2276 if v_0.Op != OpARMNMULF { 2277 break 2278 } 2279 _ = v_0.Args[1] 2280 x := v_0.Args[0] 2281 y := v_0.Args[1] 2282 a := v.Args[1] 2283 if !(a.Uses == 1 && objabi.GOARM >= 6) { 2284 break 2285 } 2286 v.reset(OpARMMULSF) 2287 v.AddArg(a) 2288 v.AddArg(x) 2289 v.AddArg(y) 2290 return true 2291 } 2292 return false 2293 } 2294 func rewriteValueARM_OpARMADDS_0(v *Value) bool { 2295 // match: (ADDS x (MOVWconst [c])) 2296 // cond: 2297 // result: (ADDSconst [c] x) 2298 for { 2299 _ = v.Args[1] 2300 x := v.Args[0] 2301 v_1 := v.Args[1] 2302 if v_1.Op != OpARMMOVWconst { 2303 break 2304 } 2305 c := v_1.AuxInt 2306 v.reset(OpARMADDSconst) 2307 v.AuxInt = c 2308 v.AddArg(x) 2309 return true 2310 } 2311 // match: (ADDS (MOVWconst [c]) x) 2312 // cond: 2313 // result: (ADDSconst [c] x) 2314 for { 2315 _ = v.Args[1] 2316 v_0 := v.Args[0] 2317 if v_0.Op != OpARMMOVWconst { 2318 break 2319 } 2320 c := v_0.AuxInt 2321 x := v.Args[1] 2322 v.reset(OpARMADDSconst) 2323 v.AuxInt = c 2324 v.AddArg(x) 2325 return true 2326 } 2327 // match: (ADDS x (SLLconst [c] y)) 2328 // cond: 2329 // result: (ADDSshiftLL x y [c]) 2330 for { 2331 _ = v.Args[1] 2332 x := v.Args[0] 2333 v_1 := v.Args[1] 2334 if v_1.Op != OpARMSLLconst { 2335 break 2336 } 2337 c := v_1.AuxInt 2338 y := v_1.Args[0] 2339 v.reset(OpARMADDSshiftLL) 2340 v.AuxInt = c 2341 v.AddArg(x) 2342 v.AddArg(y) 2343 return true 2344 } 2345 // match: (ADDS (SLLconst [c] y) x) 2346 // cond: 2347 // result: (ADDSshiftLL x y [c]) 2348 for { 2349 _ = v.Args[1] 2350 v_0 := v.Args[0] 2351 if v_0.Op != OpARMSLLconst { 2352 break 2353 } 2354 c := v_0.AuxInt 2355 y := v_0.Args[0] 2356 x := v.Args[1] 2357 v.reset(OpARMADDSshiftLL) 2358 v.AuxInt = c 2359 v.AddArg(x) 2360 v.AddArg(y) 2361 return true 2362 } 2363 // match: (ADDS x (SRLconst [c] y)) 2364 // cond: 2365 // result: (ADDSshiftRL x y [c]) 2366 for { 2367 _ = v.Args[1] 2368 x := v.Args[0] 2369 v_1 := v.Args[1] 2370 if v_1.Op != OpARMSRLconst { 2371 break 2372 } 2373 c := v_1.AuxInt 2374 y := v_1.Args[0] 2375 v.reset(OpARMADDSshiftRL) 2376 v.AuxInt = c 2377 v.AddArg(x) 2378 v.AddArg(y) 2379 return true 2380 } 2381 // match: (ADDS (SRLconst [c] y) x) 2382 // cond: 2383 // result: (ADDSshiftRL x y [c]) 2384 for { 2385 _ = v.Args[1] 2386 v_0 := v.Args[0] 2387 if v_0.Op != OpARMSRLconst { 2388 break 2389 } 2390 c := v_0.AuxInt 2391 y := v_0.Args[0] 2392 x := v.Args[1] 2393 v.reset(OpARMADDSshiftRL) 2394 v.AuxInt = c 2395 v.AddArg(x) 2396 v.AddArg(y) 2397 return true 2398 } 2399 // match: (ADDS x (SRAconst [c] y)) 2400 // cond: 2401 // result: (ADDSshiftRA x y [c]) 2402 for { 2403 _ = v.Args[1] 2404 x := v.Args[0] 2405 v_1 := v.Args[1] 2406 if v_1.Op != OpARMSRAconst { 2407 break 2408 } 2409 c := v_1.AuxInt 2410 y := v_1.Args[0] 2411 v.reset(OpARMADDSshiftRA) 2412 v.AuxInt = c 2413 v.AddArg(x) 2414 v.AddArg(y) 2415 return true 2416 } 2417 // match: (ADDS (SRAconst [c] y) x) 2418 // cond: 2419 // result: (ADDSshiftRA x y [c]) 2420 for { 2421 _ = v.Args[1] 2422 v_0 := v.Args[0] 2423 if v_0.Op != OpARMSRAconst { 2424 break 2425 } 2426 c := v_0.AuxInt 2427 y := v_0.Args[0] 2428 x := v.Args[1] 2429 v.reset(OpARMADDSshiftRA) 2430 v.AuxInt = c 2431 v.AddArg(x) 2432 v.AddArg(y) 2433 return true 2434 } 2435 // match: (ADDS x (SLL y z)) 2436 // cond: 2437 // result: (ADDSshiftLLreg x y z) 2438 for { 2439 _ = v.Args[1] 2440 x := v.Args[0] 2441 v_1 := v.Args[1] 2442 if v_1.Op != OpARMSLL { 2443 break 2444 } 2445 _ = v_1.Args[1] 2446 y := v_1.Args[0] 2447 z := v_1.Args[1] 2448 v.reset(OpARMADDSshiftLLreg) 2449 v.AddArg(x) 2450 v.AddArg(y) 2451 v.AddArg(z) 2452 return true 2453 } 2454 // match: (ADDS (SLL y z) x) 2455 // cond: 2456 // result: (ADDSshiftLLreg x y z) 2457 for { 2458 _ = v.Args[1] 2459 v_0 := v.Args[0] 2460 if v_0.Op != OpARMSLL { 2461 break 2462 } 2463 _ = v_0.Args[1] 2464 y := v_0.Args[0] 2465 z := v_0.Args[1] 2466 x := v.Args[1] 2467 v.reset(OpARMADDSshiftLLreg) 2468 v.AddArg(x) 2469 v.AddArg(y) 2470 v.AddArg(z) 2471 return true 2472 } 2473 return false 2474 } 2475 func rewriteValueARM_OpARMADDS_10(v *Value) bool { 2476 // match: (ADDS x (SRL y z)) 2477 // cond: 2478 // result: (ADDSshiftRLreg x y z) 2479 for { 2480 _ = v.Args[1] 2481 x := v.Args[0] 2482 v_1 := v.Args[1] 2483 if v_1.Op != OpARMSRL { 2484 break 2485 } 2486 _ = v_1.Args[1] 2487 y := v_1.Args[0] 2488 z := v_1.Args[1] 2489 v.reset(OpARMADDSshiftRLreg) 2490 v.AddArg(x) 2491 v.AddArg(y) 2492 v.AddArg(z) 2493 return true 2494 } 2495 // match: (ADDS (SRL y z) x) 2496 // cond: 2497 // result: (ADDSshiftRLreg x y z) 2498 for { 2499 _ = v.Args[1] 2500 v_0 := v.Args[0] 2501 if v_0.Op != OpARMSRL { 2502 break 2503 } 2504 _ = v_0.Args[1] 2505 y := v_0.Args[0] 2506 z := v_0.Args[1] 2507 x := v.Args[1] 2508 v.reset(OpARMADDSshiftRLreg) 2509 v.AddArg(x) 2510 v.AddArg(y) 2511 v.AddArg(z) 2512 return true 2513 } 2514 // match: (ADDS x (SRA y z)) 2515 // cond: 2516 // result: (ADDSshiftRAreg x y z) 2517 for { 2518 _ = v.Args[1] 2519 x := v.Args[0] 2520 v_1 := v.Args[1] 2521 if v_1.Op != OpARMSRA { 2522 break 2523 } 2524 _ = v_1.Args[1] 2525 y := v_1.Args[0] 2526 z := v_1.Args[1] 2527 v.reset(OpARMADDSshiftRAreg) 2528 v.AddArg(x) 2529 v.AddArg(y) 2530 v.AddArg(z) 2531 return true 2532 } 2533 // match: (ADDS (SRA y z) x) 2534 // cond: 2535 // result: (ADDSshiftRAreg x y z) 2536 for { 2537 _ = v.Args[1] 2538 v_0 := v.Args[0] 2539 if v_0.Op != OpARMSRA { 2540 break 2541 } 2542 _ = v_0.Args[1] 2543 y := v_0.Args[0] 2544 z := v_0.Args[1] 2545 x := v.Args[1] 2546 v.reset(OpARMADDSshiftRAreg) 2547 v.AddArg(x) 2548 v.AddArg(y) 2549 v.AddArg(z) 2550 return true 2551 } 2552 return false 2553 } 2554 func rewriteValueARM_OpARMADDSshiftLL_0(v *Value) bool { 2555 b := v.Block 2556 _ = b 2557 // match: (ADDSshiftLL (MOVWconst [c]) x [d]) 2558 // cond: 2559 // result: (ADDSconst [c] (SLLconst <x.Type> x [d])) 2560 for { 2561 d := v.AuxInt 2562 _ = v.Args[1] 2563 v_0 := v.Args[0] 2564 if v_0.Op != OpARMMOVWconst { 2565 break 2566 } 2567 c := v_0.AuxInt 2568 x := v.Args[1] 2569 v.reset(OpARMADDSconst) 2570 v.AuxInt = c 2571 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 2572 v0.AuxInt = d 2573 v0.AddArg(x) 2574 v.AddArg(v0) 2575 return true 2576 } 2577 // match: (ADDSshiftLL x (MOVWconst [c]) [d]) 2578 // cond: 2579 // result: (ADDSconst x [int64(int32(uint32(c)<<uint64(d)))]) 2580 for { 2581 d := v.AuxInt 2582 _ = v.Args[1] 2583 x := v.Args[0] 2584 v_1 := v.Args[1] 2585 if v_1.Op != OpARMMOVWconst { 2586 break 2587 } 2588 c := v_1.AuxInt 2589 v.reset(OpARMADDSconst) 2590 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 2591 v.AddArg(x) 2592 return true 2593 } 2594 return false 2595 } 2596 func rewriteValueARM_OpARMADDSshiftLLreg_0(v *Value) bool { 2597 b := v.Block 2598 _ = b 2599 // match: (ADDSshiftLLreg (MOVWconst [c]) x y) 2600 // cond: 2601 // result: (ADDSconst [c] (SLL <x.Type> x y)) 2602 for { 2603 _ = v.Args[2] 2604 v_0 := v.Args[0] 2605 if v_0.Op != OpARMMOVWconst { 2606 break 2607 } 2608 c := v_0.AuxInt 2609 x := v.Args[1] 2610 y := v.Args[2] 2611 v.reset(OpARMADDSconst) 2612 v.AuxInt = c 2613 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 2614 v0.AddArg(x) 2615 v0.AddArg(y) 2616 v.AddArg(v0) 2617 return true 2618 } 2619 // match: (ADDSshiftLLreg x y (MOVWconst [c])) 2620 // cond: 2621 // result: (ADDSshiftLL x y [c]) 2622 for { 2623 _ = v.Args[2] 2624 x := v.Args[0] 2625 y := v.Args[1] 2626 v_2 := v.Args[2] 2627 if v_2.Op != OpARMMOVWconst { 2628 break 2629 } 2630 c := v_2.AuxInt 2631 v.reset(OpARMADDSshiftLL) 2632 v.AuxInt = c 2633 v.AddArg(x) 2634 v.AddArg(y) 2635 return true 2636 } 2637 return false 2638 } 2639 func rewriteValueARM_OpARMADDSshiftRA_0(v *Value) bool { 2640 b := v.Block 2641 _ = b 2642 // match: (ADDSshiftRA (MOVWconst [c]) x [d]) 2643 // cond: 2644 // result: (ADDSconst [c] (SRAconst <x.Type> x [d])) 2645 for { 2646 d := v.AuxInt 2647 _ = v.Args[1] 2648 v_0 := v.Args[0] 2649 if v_0.Op != OpARMMOVWconst { 2650 break 2651 } 2652 c := v_0.AuxInt 2653 x := v.Args[1] 2654 v.reset(OpARMADDSconst) 2655 v.AuxInt = c 2656 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 2657 v0.AuxInt = d 2658 v0.AddArg(x) 2659 v.AddArg(v0) 2660 return true 2661 } 2662 // match: (ADDSshiftRA x (MOVWconst [c]) [d]) 2663 // cond: 2664 // result: (ADDSconst x [int64(int32(c)>>uint64(d))]) 2665 for { 2666 d := v.AuxInt 2667 _ = v.Args[1] 2668 x := v.Args[0] 2669 v_1 := v.Args[1] 2670 if v_1.Op != OpARMMOVWconst { 2671 break 2672 } 2673 c := v_1.AuxInt 2674 v.reset(OpARMADDSconst) 2675 v.AuxInt = int64(int32(c) >> uint64(d)) 2676 v.AddArg(x) 2677 return true 2678 } 2679 return false 2680 } 2681 func rewriteValueARM_OpARMADDSshiftRAreg_0(v *Value) bool { 2682 b := v.Block 2683 _ = b 2684 // match: (ADDSshiftRAreg (MOVWconst [c]) x y) 2685 // cond: 2686 // result: (ADDSconst [c] (SRA <x.Type> x y)) 2687 for { 2688 _ = v.Args[2] 2689 v_0 := v.Args[0] 2690 if v_0.Op != OpARMMOVWconst { 2691 break 2692 } 2693 c := v_0.AuxInt 2694 x := v.Args[1] 2695 y := v.Args[2] 2696 v.reset(OpARMADDSconst) 2697 v.AuxInt = c 2698 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 2699 v0.AddArg(x) 2700 v0.AddArg(y) 2701 v.AddArg(v0) 2702 return true 2703 } 2704 // match: (ADDSshiftRAreg x y (MOVWconst [c])) 2705 // cond: 2706 // result: (ADDSshiftRA x y [c]) 2707 for { 2708 _ = v.Args[2] 2709 x := v.Args[0] 2710 y := v.Args[1] 2711 v_2 := v.Args[2] 2712 if v_2.Op != OpARMMOVWconst { 2713 break 2714 } 2715 c := v_2.AuxInt 2716 v.reset(OpARMADDSshiftRA) 2717 v.AuxInt = c 2718 v.AddArg(x) 2719 v.AddArg(y) 2720 return true 2721 } 2722 return false 2723 } 2724 func rewriteValueARM_OpARMADDSshiftRL_0(v *Value) bool { 2725 b := v.Block 2726 _ = b 2727 // match: (ADDSshiftRL (MOVWconst [c]) x [d]) 2728 // cond: 2729 // result: (ADDSconst [c] (SRLconst <x.Type> x [d])) 2730 for { 2731 d := v.AuxInt 2732 _ = v.Args[1] 2733 v_0 := v.Args[0] 2734 if v_0.Op != OpARMMOVWconst { 2735 break 2736 } 2737 c := v_0.AuxInt 2738 x := v.Args[1] 2739 v.reset(OpARMADDSconst) 2740 v.AuxInt = c 2741 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 2742 v0.AuxInt = d 2743 v0.AddArg(x) 2744 v.AddArg(v0) 2745 return true 2746 } 2747 // match: (ADDSshiftRL x (MOVWconst [c]) [d]) 2748 // cond: 2749 // result: (ADDSconst x [int64(int32(uint32(c)>>uint64(d)))]) 2750 for { 2751 d := v.AuxInt 2752 _ = v.Args[1] 2753 x := v.Args[0] 2754 v_1 := v.Args[1] 2755 if v_1.Op != OpARMMOVWconst { 2756 break 2757 } 2758 c := v_1.AuxInt 2759 v.reset(OpARMADDSconst) 2760 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 2761 v.AddArg(x) 2762 return true 2763 } 2764 return false 2765 } 2766 func rewriteValueARM_OpARMADDSshiftRLreg_0(v *Value) bool { 2767 b := v.Block 2768 _ = b 2769 // match: (ADDSshiftRLreg (MOVWconst [c]) x y) 2770 // cond: 2771 // result: (ADDSconst [c] (SRL <x.Type> x y)) 2772 for { 2773 _ = v.Args[2] 2774 v_0 := v.Args[0] 2775 if v_0.Op != OpARMMOVWconst { 2776 break 2777 } 2778 c := v_0.AuxInt 2779 x := v.Args[1] 2780 y := v.Args[2] 2781 v.reset(OpARMADDSconst) 2782 v.AuxInt = c 2783 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 2784 v0.AddArg(x) 2785 v0.AddArg(y) 2786 v.AddArg(v0) 2787 return true 2788 } 2789 // match: (ADDSshiftRLreg x y (MOVWconst [c])) 2790 // cond: 2791 // result: (ADDSshiftRL x y [c]) 2792 for { 2793 _ = v.Args[2] 2794 x := v.Args[0] 2795 y := v.Args[1] 2796 v_2 := v.Args[2] 2797 if v_2.Op != OpARMMOVWconst { 2798 break 2799 } 2800 c := v_2.AuxInt 2801 v.reset(OpARMADDSshiftRL) 2802 v.AuxInt = c 2803 v.AddArg(x) 2804 v.AddArg(y) 2805 return true 2806 } 2807 return false 2808 } 2809 func rewriteValueARM_OpARMADDconst_0(v *Value) bool { 2810 // match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr)) 2811 // cond: 2812 // result: (MOVWaddr [off1+off2] {sym} ptr) 2813 for { 2814 off1 := v.AuxInt 2815 v_0 := v.Args[0] 2816 if v_0.Op != OpARMMOVWaddr { 2817 break 2818 } 2819 off2 := v_0.AuxInt 2820 sym := v_0.Aux 2821 ptr := v_0.Args[0] 2822 v.reset(OpARMMOVWaddr) 2823 v.AuxInt = off1 + off2 2824 v.Aux = sym 2825 v.AddArg(ptr) 2826 return true 2827 } 2828 // match: (ADDconst [0] x) 2829 // cond: 2830 // result: x 2831 for { 2832 if v.AuxInt != 0 { 2833 break 2834 } 2835 x := v.Args[0] 2836 v.reset(OpCopy) 2837 v.Type = x.Type 2838 v.AddArg(x) 2839 return true 2840 } 2841 // match: (ADDconst [c] x) 2842 // cond: !isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c)) 2843 // result: (SUBconst [int64(int32(-c))] x) 2844 for { 2845 c := v.AuxInt 2846 x := v.Args[0] 2847 if !(!isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c))) { 2848 break 2849 } 2850 v.reset(OpARMSUBconst) 2851 v.AuxInt = int64(int32(-c)) 2852 v.AddArg(x) 2853 return true 2854 } 2855 // match: (ADDconst [c] x) 2856 // cond: objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff 2857 // result: (SUBconst [int64(int32(-c))] x) 2858 for { 2859 c := v.AuxInt 2860 x := v.Args[0] 2861 if !(objabi.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && uint32(-c) <= 0xffff) { 2862 break 2863 } 2864 v.reset(OpARMSUBconst) 2865 v.AuxInt = int64(int32(-c)) 2866 v.AddArg(x) 2867 return true 2868 } 2869 // match: (ADDconst [c] (MOVWconst [d])) 2870 // cond: 2871 // result: (MOVWconst [int64(int32(c+d))]) 2872 for { 2873 c := v.AuxInt 2874 v_0 := v.Args[0] 2875 if v_0.Op != OpARMMOVWconst { 2876 break 2877 } 2878 d := v_0.AuxInt 2879 v.reset(OpARMMOVWconst) 2880 v.AuxInt = int64(int32(c + d)) 2881 return true 2882 } 2883 // match: (ADDconst [c] (ADDconst [d] x)) 2884 // cond: 2885 // result: (ADDconst [int64(int32(c+d))] x) 2886 for { 2887 c := v.AuxInt 2888 v_0 := v.Args[0] 2889 if v_0.Op != OpARMADDconst { 2890 break 2891 } 2892 d := v_0.AuxInt 2893 x := v_0.Args[0] 2894 v.reset(OpARMADDconst) 2895 v.AuxInt = int64(int32(c + d)) 2896 v.AddArg(x) 2897 return true 2898 } 2899 // match: (ADDconst [c] (SUBconst [d] x)) 2900 // cond: 2901 // result: (ADDconst [int64(int32(c-d))] x) 2902 for { 2903 c := v.AuxInt 2904 v_0 := v.Args[0] 2905 if v_0.Op != OpARMSUBconst { 2906 break 2907 } 2908 d := v_0.AuxInt 2909 x := v_0.Args[0] 2910 v.reset(OpARMADDconst) 2911 v.AuxInt = int64(int32(c - d)) 2912 v.AddArg(x) 2913 return true 2914 } 2915 // match: (ADDconst [c] (RSBconst [d] x)) 2916 // cond: 2917 // result: (RSBconst [int64(int32(c+d))] x) 2918 for { 2919 c := v.AuxInt 2920 v_0 := v.Args[0] 2921 if v_0.Op != OpARMRSBconst { 2922 break 2923 } 2924 d := v_0.AuxInt 2925 x := v_0.Args[0] 2926 v.reset(OpARMRSBconst) 2927 v.AuxInt = int64(int32(c + d)) 2928 v.AddArg(x) 2929 return true 2930 } 2931 return false 2932 } 2933 func rewriteValueARM_OpARMADDshiftLL_0(v *Value) bool { 2934 b := v.Block 2935 _ = b 2936 // match: (ADDshiftLL (MOVWconst [c]) x [d]) 2937 // cond: 2938 // result: (ADDconst [c] (SLLconst <x.Type> x [d])) 2939 for { 2940 d := v.AuxInt 2941 _ = v.Args[1] 2942 v_0 := v.Args[0] 2943 if v_0.Op != OpARMMOVWconst { 2944 break 2945 } 2946 c := v_0.AuxInt 2947 x := v.Args[1] 2948 v.reset(OpARMADDconst) 2949 v.AuxInt = c 2950 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 2951 v0.AuxInt = d 2952 v0.AddArg(x) 2953 v.AddArg(v0) 2954 return true 2955 } 2956 // match: (ADDshiftLL x (MOVWconst [c]) [d]) 2957 // cond: 2958 // result: (ADDconst x [int64(int32(uint32(c)<<uint64(d)))]) 2959 for { 2960 d := v.AuxInt 2961 _ = v.Args[1] 2962 x := v.Args[0] 2963 v_1 := v.Args[1] 2964 if v_1.Op != OpARMMOVWconst { 2965 break 2966 } 2967 c := v_1.AuxInt 2968 v.reset(OpARMADDconst) 2969 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 2970 v.AddArg(x) 2971 return true 2972 } 2973 // match: (ADDshiftLL [c] (SRLconst x [32-c]) x) 2974 // cond: 2975 // result: (SRRconst [32-c] x) 2976 for { 2977 c := v.AuxInt 2978 _ = v.Args[1] 2979 v_0 := v.Args[0] 2980 if v_0.Op != OpARMSRLconst { 2981 break 2982 } 2983 if v_0.AuxInt != 32-c { 2984 break 2985 } 2986 x := v_0.Args[0] 2987 if x != v.Args[1] { 2988 break 2989 } 2990 v.reset(OpARMSRRconst) 2991 v.AuxInt = 32 - c 2992 v.AddArg(x) 2993 return true 2994 } 2995 return false 2996 } 2997 func rewriteValueARM_OpARMADDshiftLLreg_0(v *Value) bool { 2998 b := v.Block 2999 _ = b 3000 // match: (ADDshiftLLreg (MOVWconst [c]) x y) 3001 // cond: 3002 // result: (ADDconst [c] (SLL <x.Type> x y)) 3003 for { 3004 _ = v.Args[2] 3005 v_0 := v.Args[0] 3006 if v_0.Op != OpARMMOVWconst { 3007 break 3008 } 3009 c := v_0.AuxInt 3010 x := v.Args[1] 3011 y := v.Args[2] 3012 v.reset(OpARMADDconst) 3013 v.AuxInt = c 3014 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 3015 v0.AddArg(x) 3016 v0.AddArg(y) 3017 v.AddArg(v0) 3018 return true 3019 } 3020 // match: (ADDshiftLLreg x y (MOVWconst [c])) 3021 // cond: 3022 // result: (ADDshiftLL x y [c]) 3023 for { 3024 _ = v.Args[2] 3025 x := v.Args[0] 3026 y := v.Args[1] 3027 v_2 := v.Args[2] 3028 if v_2.Op != OpARMMOVWconst { 3029 break 3030 } 3031 c := v_2.AuxInt 3032 v.reset(OpARMADDshiftLL) 3033 v.AuxInt = c 3034 v.AddArg(x) 3035 v.AddArg(y) 3036 return true 3037 } 3038 return false 3039 } 3040 func rewriteValueARM_OpARMADDshiftRA_0(v *Value) bool { 3041 b := v.Block 3042 _ = b 3043 // match: (ADDshiftRA (MOVWconst [c]) x [d]) 3044 // cond: 3045 // result: (ADDconst [c] (SRAconst <x.Type> x [d])) 3046 for { 3047 d := v.AuxInt 3048 _ = v.Args[1] 3049 v_0 := v.Args[0] 3050 if v_0.Op != OpARMMOVWconst { 3051 break 3052 } 3053 c := v_0.AuxInt 3054 x := v.Args[1] 3055 v.reset(OpARMADDconst) 3056 v.AuxInt = c 3057 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 3058 v0.AuxInt = d 3059 v0.AddArg(x) 3060 v.AddArg(v0) 3061 return true 3062 } 3063 // match: (ADDshiftRA x (MOVWconst [c]) [d]) 3064 // cond: 3065 // result: (ADDconst x [int64(int32(c)>>uint64(d))]) 3066 for { 3067 d := v.AuxInt 3068 _ = v.Args[1] 3069 x := v.Args[0] 3070 v_1 := v.Args[1] 3071 if v_1.Op != OpARMMOVWconst { 3072 break 3073 } 3074 c := v_1.AuxInt 3075 v.reset(OpARMADDconst) 3076 v.AuxInt = int64(int32(c) >> uint64(d)) 3077 v.AddArg(x) 3078 return true 3079 } 3080 return false 3081 } 3082 func rewriteValueARM_OpARMADDshiftRAreg_0(v *Value) bool { 3083 b := v.Block 3084 _ = b 3085 // match: (ADDshiftRAreg (MOVWconst [c]) x y) 3086 // cond: 3087 // result: (ADDconst [c] (SRA <x.Type> x y)) 3088 for { 3089 _ = v.Args[2] 3090 v_0 := v.Args[0] 3091 if v_0.Op != OpARMMOVWconst { 3092 break 3093 } 3094 c := v_0.AuxInt 3095 x := v.Args[1] 3096 y := v.Args[2] 3097 v.reset(OpARMADDconst) 3098 v.AuxInt = c 3099 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 3100 v0.AddArg(x) 3101 v0.AddArg(y) 3102 v.AddArg(v0) 3103 return true 3104 } 3105 // match: (ADDshiftRAreg x y (MOVWconst [c])) 3106 // cond: 3107 // result: (ADDshiftRA x y [c]) 3108 for { 3109 _ = v.Args[2] 3110 x := v.Args[0] 3111 y := v.Args[1] 3112 v_2 := v.Args[2] 3113 if v_2.Op != OpARMMOVWconst { 3114 break 3115 } 3116 c := v_2.AuxInt 3117 v.reset(OpARMADDshiftRA) 3118 v.AuxInt = c 3119 v.AddArg(x) 3120 v.AddArg(y) 3121 return true 3122 } 3123 return false 3124 } 3125 func rewriteValueARM_OpARMADDshiftRL_0(v *Value) bool { 3126 b := v.Block 3127 _ = b 3128 // match: (ADDshiftRL (MOVWconst [c]) x [d]) 3129 // cond: 3130 // result: (ADDconst [c] (SRLconst <x.Type> x [d])) 3131 for { 3132 d := v.AuxInt 3133 _ = v.Args[1] 3134 v_0 := v.Args[0] 3135 if v_0.Op != OpARMMOVWconst { 3136 break 3137 } 3138 c := v_0.AuxInt 3139 x := v.Args[1] 3140 v.reset(OpARMADDconst) 3141 v.AuxInt = c 3142 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 3143 v0.AuxInt = d 3144 v0.AddArg(x) 3145 v.AddArg(v0) 3146 return true 3147 } 3148 // match: (ADDshiftRL x (MOVWconst [c]) [d]) 3149 // cond: 3150 // result: (ADDconst x [int64(int32(uint32(c)>>uint64(d)))]) 3151 for { 3152 d := v.AuxInt 3153 _ = v.Args[1] 3154 x := v.Args[0] 3155 v_1 := v.Args[1] 3156 if v_1.Op != OpARMMOVWconst { 3157 break 3158 } 3159 c := v_1.AuxInt 3160 v.reset(OpARMADDconst) 3161 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 3162 v.AddArg(x) 3163 return true 3164 } 3165 // match: (ADDshiftRL [c] (SLLconst x [32-c]) x) 3166 // cond: 3167 // result: (SRRconst [ c] x) 3168 for { 3169 c := v.AuxInt 3170 _ = v.Args[1] 3171 v_0 := v.Args[0] 3172 if v_0.Op != OpARMSLLconst { 3173 break 3174 } 3175 if v_0.AuxInt != 32-c { 3176 break 3177 } 3178 x := v_0.Args[0] 3179 if x != v.Args[1] { 3180 break 3181 } 3182 v.reset(OpARMSRRconst) 3183 v.AuxInt = c 3184 v.AddArg(x) 3185 return true 3186 } 3187 return false 3188 } 3189 func rewriteValueARM_OpARMADDshiftRLreg_0(v *Value) bool { 3190 b := v.Block 3191 _ = b 3192 // match: (ADDshiftRLreg (MOVWconst [c]) x y) 3193 // cond: 3194 // result: (ADDconst [c] (SRL <x.Type> x y)) 3195 for { 3196 _ = v.Args[2] 3197 v_0 := v.Args[0] 3198 if v_0.Op != OpARMMOVWconst { 3199 break 3200 } 3201 c := v_0.AuxInt 3202 x := v.Args[1] 3203 y := v.Args[2] 3204 v.reset(OpARMADDconst) 3205 v.AuxInt = c 3206 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 3207 v0.AddArg(x) 3208 v0.AddArg(y) 3209 v.AddArg(v0) 3210 return true 3211 } 3212 // match: (ADDshiftRLreg x y (MOVWconst [c])) 3213 // cond: 3214 // result: (ADDshiftRL x y [c]) 3215 for { 3216 _ = v.Args[2] 3217 x := v.Args[0] 3218 y := v.Args[1] 3219 v_2 := v.Args[2] 3220 if v_2.Op != OpARMMOVWconst { 3221 break 3222 } 3223 c := v_2.AuxInt 3224 v.reset(OpARMADDshiftRL) 3225 v.AuxInt = c 3226 v.AddArg(x) 3227 v.AddArg(y) 3228 return true 3229 } 3230 return false 3231 } 3232 func rewriteValueARM_OpARMAND_0(v *Value) bool { 3233 // match: (AND x (MOVWconst [c])) 3234 // cond: 3235 // result: (ANDconst [c] x) 3236 for { 3237 _ = v.Args[1] 3238 x := v.Args[0] 3239 v_1 := v.Args[1] 3240 if v_1.Op != OpARMMOVWconst { 3241 break 3242 } 3243 c := v_1.AuxInt 3244 v.reset(OpARMANDconst) 3245 v.AuxInt = c 3246 v.AddArg(x) 3247 return true 3248 } 3249 // match: (AND (MOVWconst [c]) x) 3250 // cond: 3251 // result: (ANDconst [c] x) 3252 for { 3253 _ = v.Args[1] 3254 v_0 := v.Args[0] 3255 if v_0.Op != OpARMMOVWconst { 3256 break 3257 } 3258 c := v_0.AuxInt 3259 x := v.Args[1] 3260 v.reset(OpARMANDconst) 3261 v.AuxInt = c 3262 v.AddArg(x) 3263 return true 3264 } 3265 // match: (AND x (SLLconst [c] y)) 3266 // cond: 3267 // result: (ANDshiftLL x y [c]) 3268 for { 3269 _ = v.Args[1] 3270 x := v.Args[0] 3271 v_1 := v.Args[1] 3272 if v_1.Op != OpARMSLLconst { 3273 break 3274 } 3275 c := v_1.AuxInt 3276 y := v_1.Args[0] 3277 v.reset(OpARMANDshiftLL) 3278 v.AuxInt = c 3279 v.AddArg(x) 3280 v.AddArg(y) 3281 return true 3282 } 3283 // match: (AND (SLLconst [c] y) x) 3284 // cond: 3285 // result: (ANDshiftLL x y [c]) 3286 for { 3287 _ = v.Args[1] 3288 v_0 := v.Args[0] 3289 if v_0.Op != OpARMSLLconst { 3290 break 3291 } 3292 c := v_0.AuxInt 3293 y := v_0.Args[0] 3294 x := v.Args[1] 3295 v.reset(OpARMANDshiftLL) 3296 v.AuxInt = c 3297 v.AddArg(x) 3298 v.AddArg(y) 3299 return true 3300 } 3301 // match: (AND x (SRLconst [c] y)) 3302 // cond: 3303 // result: (ANDshiftRL x y [c]) 3304 for { 3305 _ = v.Args[1] 3306 x := v.Args[0] 3307 v_1 := v.Args[1] 3308 if v_1.Op != OpARMSRLconst { 3309 break 3310 } 3311 c := v_1.AuxInt 3312 y := v_1.Args[0] 3313 v.reset(OpARMANDshiftRL) 3314 v.AuxInt = c 3315 v.AddArg(x) 3316 v.AddArg(y) 3317 return true 3318 } 3319 // match: (AND (SRLconst [c] y) x) 3320 // cond: 3321 // result: (ANDshiftRL x y [c]) 3322 for { 3323 _ = v.Args[1] 3324 v_0 := v.Args[0] 3325 if v_0.Op != OpARMSRLconst { 3326 break 3327 } 3328 c := v_0.AuxInt 3329 y := v_0.Args[0] 3330 x := v.Args[1] 3331 v.reset(OpARMANDshiftRL) 3332 v.AuxInt = c 3333 v.AddArg(x) 3334 v.AddArg(y) 3335 return true 3336 } 3337 // match: (AND x (SRAconst [c] y)) 3338 // cond: 3339 // result: (ANDshiftRA x y [c]) 3340 for { 3341 _ = v.Args[1] 3342 x := v.Args[0] 3343 v_1 := v.Args[1] 3344 if v_1.Op != OpARMSRAconst { 3345 break 3346 } 3347 c := v_1.AuxInt 3348 y := v_1.Args[0] 3349 v.reset(OpARMANDshiftRA) 3350 v.AuxInt = c 3351 v.AddArg(x) 3352 v.AddArg(y) 3353 return true 3354 } 3355 // match: (AND (SRAconst [c] y) x) 3356 // cond: 3357 // result: (ANDshiftRA x y [c]) 3358 for { 3359 _ = v.Args[1] 3360 v_0 := v.Args[0] 3361 if v_0.Op != OpARMSRAconst { 3362 break 3363 } 3364 c := v_0.AuxInt 3365 y := v_0.Args[0] 3366 x := v.Args[1] 3367 v.reset(OpARMANDshiftRA) 3368 v.AuxInt = c 3369 v.AddArg(x) 3370 v.AddArg(y) 3371 return true 3372 } 3373 // match: (AND x (SLL y z)) 3374 // cond: 3375 // result: (ANDshiftLLreg x y z) 3376 for { 3377 _ = v.Args[1] 3378 x := v.Args[0] 3379 v_1 := v.Args[1] 3380 if v_1.Op != OpARMSLL { 3381 break 3382 } 3383 _ = v_1.Args[1] 3384 y := v_1.Args[0] 3385 z := v_1.Args[1] 3386 v.reset(OpARMANDshiftLLreg) 3387 v.AddArg(x) 3388 v.AddArg(y) 3389 v.AddArg(z) 3390 return true 3391 } 3392 // match: (AND (SLL y z) x) 3393 // cond: 3394 // result: (ANDshiftLLreg x y z) 3395 for { 3396 _ = v.Args[1] 3397 v_0 := v.Args[0] 3398 if v_0.Op != OpARMSLL { 3399 break 3400 } 3401 _ = v_0.Args[1] 3402 y := v_0.Args[0] 3403 z := v_0.Args[1] 3404 x := v.Args[1] 3405 v.reset(OpARMANDshiftLLreg) 3406 v.AddArg(x) 3407 v.AddArg(y) 3408 v.AddArg(z) 3409 return true 3410 } 3411 return false 3412 } 3413 func rewriteValueARM_OpARMAND_10(v *Value) bool { 3414 // match: (AND x (SRL y z)) 3415 // cond: 3416 // result: (ANDshiftRLreg x y z) 3417 for { 3418 _ = v.Args[1] 3419 x := v.Args[0] 3420 v_1 := v.Args[1] 3421 if v_1.Op != OpARMSRL { 3422 break 3423 } 3424 _ = v_1.Args[1] 3425 y := v_1.Args[0] 3426 z := v_1.Args[1] 3427 v.reset(OpARMANDshiftRLreg) 3428 v.AddArg(x) 3429 v.AddArg(y) 3430 v.AddArg(z) 3431 return true 3432 } 3433 // match: (AND (SRL y z) x) 3434 // cond: 3435 // result: (ANDshiftRLreg x y z) 3436 for { 3437 _ = v.Args[1] 3438 v_0 := v.Args[0] 3439 if v_0.Op != OpARMSRL { 3440 break 3441 } 3442 _ = v_0.Args[1] 3443 y := v_0.Args[0] 3444 z := v_0.Args[1] 3445 x := v.Args[1] 3446 v.reset(OpARMANDshiftRLreg) 3447 v.AddArg(x) 3448 v.AddArg(y) 3449 v.AddArg(z) 3450 return true 3451 } 3452 // match: (AND x (SRA y z)) 3453 // cond: 3454 // result: (ANDshiftRAreg x y z) 3455 for { 3456 _ = v.Args[1] 3457 x := v.Args[0] 3458 v_1 := v.Args[1] 3459 if v_1.Op != OpARMSRA { 3460 break 3461 } 3462 _ = v_1.Args[1] 3463 y := v_1.Args[0] 3464 z := v_1.Args[1] 3465 v.reset(OpARMANDshiftRAreg) 3466 v.AddArg(x) 3467 v.AddArg(y) 3468 v.AddArg(z) 3469 return true 3470 } 3471 // match: (AND (SRA y z) x) 3472 // cond: 3473 // result: (ANDshiftRAreg x y z) 3474 for { 3475 _ = v.Args[1] 3476 v_0 := v.Args[0] 3477 if v_0.Op != OpARMSRA { 3478 break 3479 } 3480 _ = v_0.Args[1] 3481 y := v_0.Args[0] 3482 z := v_0.Args[1] 3483 x := v.Args[1] 3484 v.reset(OpARMANDshiftRAreg) 3485 v.AddArg(x) 3486 v.AddArg(y) 3487 v.AddArg(z) 3488 return true 3489 } 3490 // match: (AND x x) 3491 // cond: 3492 // result: x 3493 for { 3494 _ = v.Args[1] 3495 x := v.Args[0] 3496 if x != v.Args[1] { 3497 break 3498 } 3499 v.reset(OpCopy) 3500 v.Type = x.Type 3501 v.AddArg(x) 3502 return true 3503 } 3504 // match: (AND x (MVN y)) 3505 // cond: 3506 // result: (BIC x y) 3507 for { 3508 _ = v.Args[1] 3509 x := v.Args[0] 3510 v_1 := v.Args[1] 3511 if v_1.Op != OpARMMVN { 3512 break 3513 } 3514 y := v_1.Args[0] 3515 v.reset(OpARMBIC) 3516 v.AddArg(x) 3517 v.AddArg(y) 3518 return true 3519 } 3520 // match: (AND (MVN y) x) 3521 // cond: 3522 // result: (BIC x y) 3523 for { 3524 _ = v.Args[1] 3525 v_0 := v.Args[0] 3526 if v_0.Op != OpARMMVN { 3527 break 3528 } 3529 y := v_0.Args[0] 3530 x := v.Args[1] 3531 v.reset(OpARMBIC) 3532 v.AddArg(x) 3533 v.AddArg(y) 3534 return true 3535 } 3536 // match: (AND x (MVNshiftLL y [c])) 3537 // cond: 3538 // result: (BICshiftLL x y [c]) 3539 for { 3540 _ = v.Args[1] 3541 x := v.Args[0] 3542 v_1 := v.Args[1] 3543 if v_1.Op != OpARMMVNshiftLL { 3544 break 3545 } 3546 c := v_1.AuxInt 3547 y := v_1.Args[0] 3548 v.reset(OpARMBICshiftLL) 3549 v.AuxInt = c 3550 v.AddArg(x) 3551 v.AddArg(y) 3552 return true 3553 } 3554 // match: (AND (MVNshiftLL y [c]) x) 3555 // cond: 3556 // result: (BICshiftLL x y [c]) 3557 for { 3558 _ = v.Args[1] 3559 v_0 := v.Args[0] 3560 if v_0.Op != OpARMMVNshiftLL { 3561 break 3562 } 3563 c := v_0.AuxInt 3564 y := v_0.Args[0] 3565 x := v.Args[1] 3566 v.reset(OpARMBICshiftLL) 3567 v.AuxInt = c 3568 v.AddArg(x) 3569 v.AddArg(y) 3570 return true 3571 } 3572 // match: (AND x (MVNshiftRL y [c])) 3573 // cond: 3574 // result: (BICshiftRL x y [c]) 3575 for { 3576 _ = v.Args[1] 3577 x := v.Args[0] 3578 v_1 := v.Args[1] 3579 if v_1.Op != OpARMMVNshiftRL { 3580 break 3581 } 3582 c := v_1.AuxInt 3583 y := v_1.Args[0] 3584 v.reset(OpARMBICshiftRL) 3585 v.AuxInt = c 3586 v.AddArg(x) 3587 v.AddArg(y) 3588 return true 3589 } 3590 return false 3591 } 3592 func rewriteValueARM_OpARMAND_20(v *Value) bool { 3593 // match: (AND (MVNshiftRL y [c]) x) 3594 // cond: 3595 // result: (BICshiftRL x y [c]) 3596 for { 3597 _ = v.Args[1] 3598 v_0 := v.Args[0] 3599 if v_0.Op != OpARMMVNshiftRL { 3600 break 3601 } 3602 c := v_0.AuxInt 3603 y := v_0.Args[0] 3604 x := v.Args[1] 3605 v.reset(OpARMBICshiftRL) 3606 v.AuxInt = c 3607 v.AddArg(x) 3608 v.AddArg(y) 3609 return true 3610 } 3611 // match: (AND x (MVNshiftRA y [c])) 3612 // cond: 3613 // result: (BICshiftRA x y [c]) 3614 for { 3615 _ = v.Args[1] 3616 x := v.Args[0] 3617 v_1 := v.Args[1] 3618 if v_1.Op != OpARMMVNshiftRA { 3619 break 3620 } 3621 c := v_1.AuxInt 3622 y := v_1.Args[0] 3623 v.reset(OpARMBICshiftRA) 3624 v.AuxInt = c 3625 v.AddArg(x) 3626 v.AddArg(y) 3627 return true 3628 } 3629 // match: (AND (MVNshiftRA y [c]) x) 3630 // cond: 3631 // result: (BICshiftRA x y [c]) 3632 for { 3633 _ = v.Args[1] 3634 v_0 := v.Args[0] 3635 if v_0.Op != OpARMMVNshiftRA { 3636 break 3637 } 3638 c := v_0.AuxInt 3639 y := v_0.Args[0] 3640 x := v.Args[1] 3641 v.reset(OpARMBICshiftRA) 3642 v.AuxInt = c 3643 v.AddArg(x) 3644 v.AddArg(y) 3645 return true 3646 } 3647 return false 3648 } 3649 func rewriteValueARM_OpARMANDconst_0(v *Value) bool { 3650 // match: (ANDconst [0] _) 3651 // cond: 3652 // result: (MOVWconst [0]) 3653 for { 3654 if v.AuxInt != 0 { 3655 break 3656 } 3657 v.reset(OpARMMOVWconst) 3658 v.AuxInt = 0 3659 return true 3660 } 3661 // match: (ANDconst [c] x) 3662 // cond: int32(c)==-1 3663 // result: x 3664 for { 3665 c := v.AuxInt 3666 x := v.Args[0] 3667 if !(int32(c) == -1) { 3668 break 3669 } 3670 v.reset(OpCopy) 3671 v.Type = x.Type 3672 v.AddArg(x) 3673 return true 3674 } 3675 // match: (ANDconst [c] x) 3676 // cond: !isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c)) 3677 // result: (BICconst [int64(int32(^uint32(c)))] x) 3678 for { 3679 c := v.AuxInt 3680 x := v.Args[0] 3681 if !(!isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c))) { 3682 break 3683 } 3684 v.reset(OpARMBICconst) 3685 v.AuxInt = int64(int32(^uint32(c))) 3686 v.AddArg(x) 3687 return true 3688 } 3689 // match: (ANDconst [c] x) 3690 // cond: objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff 3691 // result: (BICconst [int64(int32(^uint32(c)))] x) 3692 for { 3693 c := v.AuxInt 3694 x := v.Args[0] 3695 if !(objabi.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && ^uint32(c) <= 0xffff) { 3696 break 3697 } 3698 v.reset(OpARMBICconst) 3699 v.AuxInt = int64(int32(^uint32(c))) 3700 v.AddArg(x) 3701 return true 3702 } 3703 // match: (ANDconst [c] (MOVWconst [d])) 3704 // cond: 3705 // result: (MOVWconst [c&d]) 3706 for { 3707 c := v.AuxInt 3708 v_0 := v.Args[0] 3709 if v_0.Op != OpARMMOVWconst { 3710 break 3711 } 3712 d := v_0.AuxInt 3713 v.reset(OpARMMOVWconst) 3714 v.AuxInt = c & d 3715 return true 3716 } 3717 // match: (ANDconst [c] (ANDconst [d] x)) 3718 // cond: 3719 // result: (ANDconst [c&d] x) 3720 for { 3721 c := v.AuxInt 3722 v_0 := v.Args[0] 3723 if v_0.Op != OpARMANDconst { 3724 break 3725 } 3726 d := v_0.AuxInt 3727 x := v_0.Args[0] 3728 v.reset(OpARMANDconst) 3729 v.AuxInt = c & d 3730 v.AddArg(x) 3731 return true 3732 } 3733 return false 3734 } 3735 func rewriteValueARM_OpARMANDshiftLL_0(v *Value) bool { 3736 b := v.Block 3737 _ = b 3738 // match: (ANDshiftLL (MOVWconst [c]) x [d]) 3739 // cond: 3740 // result: (ANDconst [c] (SLLconst <x.Type> x [d])) 3741 for { 3742 d := v.AuxInt 3743 _ = v.Args[1] 3744 v_0 := v.Args[0] 3745 if v_0.Op != OpARMMOVWconst { 3746 break 3747 } 3748 c := v_0.AuxInt 3749 x := v.Args[1] 3750 v.reset(OpARMANDconst) 3751 v.AuxInt = c 3752 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 3753 v0.AuxInt = d 3754 v0.AddArg(x) 3755 v.AddArg(v0) 3756 return true 3757 } 3758 // match: (ANDshiftLL x (MOVWconst [c]) [d]) 3759 // cond: 3760 // result: (ANDconst x [int64(int32(uint32(c)<<uint64(d)))]) 3761 for { 3762 d := v.AuxInt 3763 _ = v.Args[1] 3764 x := v.Args[0] 3765 v_1 := v.Args[1] 3766 if v_1.Op != OpARMMOVWconst { 3767 break 3768 } 3769 c := v_1.AuxInt 3770 v.reset(OpARMANDconst) 3771 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 3772 v.AddArg(x) 3773 return true 3774 } 3775 // match: (ANDshiftLL x y:(SLLconst x [c]) [d]) 3776 // cond: c==d 3777 // result: y 3778 for { 3779 d := v.AuxInt 3780 _ = v.Args[1] 3781 x := v.Args[0] 3782 y := v.Args[1] 3783 if y.Op != OpARMSLLconst { 3784 break 3785 } 3786 c := y.AuxInt 3787 if x != y.Args[0] { 3788 break 3789 } 3790 if !(c == d) { 3791 break 3792 } 3793 v.reset(OpCopy) 3794 v.Type = y.Type 3795 v.AddArg(y) 3796 return true 3797 } 3798 return false 3799 } 3800 func rewriteValueARM_OpARMANDshiftLLreg_0(v *Value) bool { 3801 b := v.Block 3802 _ = b 3803 // match: (ANDshiftLLreg (MOVWconst [c]) x y) 3804 // cond: 3805 // result: (ANDconst [c] (SLL <x.Type> x y)) 3806 for { 3807 _ = v.Args[2] 3808 v_0 := v.Args[0] 3809 if v_0.Op != OpARMMOVWconst { 3810 break 3811 } 3812 c := v_0.AuxInt 3813 x := v.Args[1] 3814 y := v.Args[2] 3815 v.reset(OpARMANDconst) 3816 v.AuxInt = c 3817 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 3818 v0.AddArg(x) 3819 v0.AddArg(y) 3820 v.AddArg(v0) 3821 return true 3822 } 3823 // match: (ANDshiftLLreg x y (MOVWconst [c])) 3824 // cond: 3825 // result: (ANDshiftLL x y [c]) 3826 for { 3827 _ = v.Args[2] 3828 x := v.Args[0] 3829 y := v.Args[1] 3830 v_2 := v.Args[2] 3831 if v_2.Op != OpARMMOVWconst { 3832 break 3833 } 3834 c := v_2.AuxInt 3835 v.reset(OpARMANDshiftLL) 3836 v.AuxInt = c 3837 v.AddArg(x) 3838 v.AddArg(y) 3839 return true 3840 } 3841 return false 3842 } 3843 func rewriteValueARM_OpARMANDshiftRA_0(v *Value) bool { 3844 b := v.Block 3845 _ = b 3846 // match: (ANDshiftRA (MOVWconst [c]) x [d]) 3847 // cond: 3848 // result: (ANDconst [c] (SRAconst <x.Type> x [d])) 3849 for { 3850 d := v.AuxInt 3851 _ = v.Args[1] 3852 v_0 := v.Args[0] 3853 if v_0.Op != OpARMMOVWconst { 3854 break 3855 } 3856 c := v_0.AuxInt 3857 x := v.Args[1] 3858 v.reset(OpARMANDconst) 3859 v.AuxInt = c 3860 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 3861 v0.AuxInt = d 3862 v0.AddArg(x) 3863 v.AddArg(v0) 3864 return true 3865 } 3866 // match: (ANDshiftRA x (MOVWconst [c]) [d]) 3867 // cond: 3868 // result: (ANDconst x [int64(int32(c)>>uint64(d))]) 3869 for { 3870 d := v.AuxInt 3871 _ = v.Args[1] 3872 x := v.Args[0] 3873 v_1 := v.Args[1] 3874 if v_1.Op != OpARMMOVWconst { 3875 break 3876 } 3877 c := v_1.AuxInt 3878 v.reset(OpARMANDconst) 3879 v.AuxInt = int64(int32(c) >> uint64(d)) 3880 v.AddArg(x) 3881 return true 3882 } 3883 // match: (ANDshiftRA x y:(SRAconst x [c]) [d]) 3884 // cond: c==d 3885 // result: y 3886 for { 3887 d := v.AuxInt 3888 _ = v.Args[1] 3889 x := v.Args[0] 3890 y := v.Args[1] 3891 if y.Op != OpARMSRAconst { 3892 break 3893 } 3894 c := y.AuxInt 3895 if x != y.Args[0] { 3896 break 3897 } 3898 if !(c == d) { 3899 break 3900 } 3901 v.reset(OpCopy) 3902 v.Type = y.Type 3903 v.AddArg(y) 3904 return true 3905 } 3906 return false 3907 } 3908 func rewriteValueARM_OpARMANDshiftRAreg_0(v *Value) bool { 3909 b := v.Block 3910 _ = b 3911 // match: (ANDshiftRAreg (MOVWconst [c]) x y) 3912 // cond: 3913 // result: (ANDconst [c] (SRA <x.Type> x y)) 3914 for { 3915 _ = v.Args[2] 3916 v_0 := v.Args[0] 3917 if v_0.Op != OpARMMOVWconst { 3918 break 3919 } 3920 c := v_0.AuxInt 3921 x := v.Args[1] 3922 y := v.Args[2] 3923 v.reset(OpARMANDconst) 3924 v.AuxInt = c 3925 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 3926 v0.AddArg(x) 3927 v0.AddArg(y) 3928 v.AddArg(v0) 3929 return true 3930 } 3931 // match: (ANDshiftRAreg x y (MOVWconst [c])) 3932 // cond: 3933 // result: (ANDshiftRA x y [c]) 3934 for { 3935 _ = v.Args[2] 3936 x := v.Args[0] 3937 y := v.Args[1] 3938 v_2 := v.Args[2] 3939 if v_2.Op != OpARMMOVWconst { 3940 break 3941 } 3942 c := v_2.AuxInt 3943 v.reset(OpARMANDshiftRA) 3944 v.AuxInt = c 3945 v.AddArg(x) 3946 v.AddArg(y) 3947 return true 3948 } 3949 return false 3950 } 3951 func rewriteValueARM_OpARMANDshiftRL_0(v *Value) bool { 3952 b := v.Block 3953 _ = b 3954 // match: (ANDshiftRL (MOVWconst [c]) x [d]) 3955 // cond: 3956 // result: (ANDconst [c] (SRLconst <x.Type> x [d])) 3957 for { 3958 d := v.AuxInt 3959 _ = v.Args[1] 3960 v_0 := v.Args[0] 3961 if v_0.Op != OpARMMOVWconst { 3962 break 3963 } 3964 c := v_0.AuxInt 3965 x := v.Args[1] 3966 v.reset(OpARMANDconst) 3967 v.AuxInt = c 3968 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 3969 v0.AuxInt = d 3970 v0.AddArg(x) 3971 v.AddArg(v0) 3972 return true 3973 } 3974 // match: (ANDshiftRL x (MOVWconst [c]) [d]) 3975 // cond: 3976 // result: (ANDconst x [int64(int32(uint32(c)>>uint64(d)))]) 3977 for { 3978 d := v.AuxInt 3979 _ = v.Args[1] 3980 x := v.Args[0] 3981 v_1 := v.Args[1] 3982 if v_1.Op != OpARMMOVWconst { 3983 break 3984 } 3985 c := v_1.AuxInt 3986 v.reset(OpARMANDconst) 3987 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 3988 v.AddArg(x) 3989 return true 3990 } 3991 // match: (ANDshiftRL x y:(SRLconst x [c]) [d]) 3992 // cond: c==d 3993 // result: y 3994 for { 3995 d := v.AuxInt 3996 _ = v.Args[1] 3997 x := v.Args[0] 3998 y := v.Args[1] 3999 if y.Op != OpARMSRLconst { 4000 break 4001 } 4002 c := y.AuxInt 4003 if x != y.Args[0] { 4004 break 4005 } 4006 if !(c == d) { 4007 break 4008 } 4009 v.reset(OpCopy) 4010 v.Type = y.Type 4011 v.AddArg(y) 4012 return true 4013 } 4014 return false 4015 } 4016 func rewriteValueARM_OpARMANDshiftRLreg_0(v *Value) bool { 4017 b := v.Block 4018 _ = b 4019 // match: (ANDshiftRLreg (MOVWconst [c]) x y) 4020 // cond: 4021 // result: (ANDconst [c] (SRL <x.Type> x y)) 4022 for { 4023 _ = v.Args[2] 4024 v_0 := v.Args[0] 4025 if v_0.Op != OpARMMOVWconst { 4026 break 4027 } 4028 c := v_0.AuxInt 4029 x := v.Args[1] 4030 y := v.Args[2] 4031 v.reset(OpARMANDconst) 4032 v.AuxInt = c 4033 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 4034 v0.AddArg(x) 4035 v0.AddArg(y) 4036 v.AddArg(v0) 4037 return true 4038 } 4039 // match: (ANDshiftRLreg x y (MOVWconst [c])) 4040 // cond: 4041 // result: (ANDshiftRL x y [c]) 4042 for { 4043 _ = v.Args[2] 4044 x := v.Args[0] 4045 y := v.Args[1] 4046 v_2 := v.Args[2] 4047 if v_2.Op != OpARMMOVWconst { 4048 break 4049 } 4050 c := v_2.AuxInt 4051 v.reset(OpARMANDshiftRL) 4052 v.AuxInt = c 4053 v.AddArg(x) 4054 v.AddArg(y) 4055 return true 4056 } 4057 return false 4058 } 4059 func rewriteValueARM_OpARMBFX_0(v *Value) bool { 4060 // match: (BFX [c] (MOVWconst [d])) 4061 // cond: 4062 // result: (MOVWconst [int64(int32(d)<<(32-uint32(c&0xff)-uint32(c>>8))>>(32-uint32(c>>8)))]) 4063 for { 4064 c := v.AuxInt 4065 v_0 := v.Args[0] 4066 if v_0.Op != OpARMMOVWconst { 4067 break 4068 } 4069 d := v_0.AuxInt 4070 v.reset(OpARMMOVWconst) 4071 v.AuxInt = int64(int32(d) << (32 - uint32(c&0xff) - uint32(c>>8)) >> (32 - uint32(c>>8))) 4072 return true 4073 } 4074 return false 4075 } 4076 func rewriteValueARM_OpARMBFXU_0(v *Value) bool { 4077 // match: (BFXU [c] (MOVWconst [d])) 4078 // cond: 4079 // result: (MOVWconst [int64(int32(uint32(d)<<(32-uint32(c&0xff)-uint32(c>>8))>>(32-uint32(c>>8))))]) 4080 for { 4081 c := v.AuxInt 4082 v_0 := v.Args[0] 4083 if v_0.Op != OpARMMOVWconst { 4084 break 4085 } 4086 d := v_0.AuxInt 4087 v.reset(OpARMMOVWconst) 4088 v.AuxInt = int64(int32(uint32(d) << (32 - uint32(c&0xff) - uint32(c>>8)) >> (32 - uint32(c>>8)))) 4089 return true 4090 } 4091 return false 4092 } 4093 func rewriteValueARM_OpARMBIC_0(v *Value) bool { 4094 // match: (BIC x (MOVWconst [c])) 4095 // cond: 4096 // result: (BICconst [c] x) 4097 for { 4098 _ = v.Args[1] 4099 x := v.Args[0] 4100 v_1 := v.Args[1] 4101 if v_1.Op != OpARMMOVWconst { 4102 break 4103 } 4104 c := v_1.AuxInt 4105 v.reset(OpARMBICconst) 4106 v.AuxInt = c 4107 v.AddArg(x) 4108 return true 4109 } 4110 // match: (BIC x (SLLconst [c] y)) 4111 // cond: 4112 // result: (BICshiftLL x y [c]) 4113 for { 4114 _ = v.Args[1] 4115 x := v.Args[0] 4116 v_1 := v.Args[1] 4117 if v_1.Op != OpARMSLLconst { 4118 break 4119 } 4120 c := v_1.AuxInt 4121 y := v_1.Args[0] 4122 v.reset(OpARMBICshiftLL) 4123 v.AuxInt = c 4124 v.AddArg(x) 4125 v.AddArg(y) 4126 return true 4127 } 4128 // match: (BIC x (SRLconst [c] y)) 4129 // cond: 4130 // result: (BICshiftRL x y [c]) 4131 for { 4132 _ = v.Args[1] 4133 x := v.Args[0] 4134 v_1 := v.Args[1] 4135 if v_1.Op != OpARMSRLconst { 4136 break 4137 } 4138 c := v_1.AuxInt 4139 y := v_1.Args[0] 4140 v.reset(OpARMBICshiftRL) 4141 v.AuxInt = c 4142 v.AddArg(x) 4143 v.AddArg(y) 4144 return true 4145 } 4146 // match: (BIC x (SRAconst [c] y)) 4147 // cond: 4148 // result: (BICshiftRA x y [c]) 4149 for { 4150 _ = v.Args[1] 4151 x := v.Args[0] 4152 v_1 := v.Args[1] 4153 if v_1.Op != OpARMSRAconst { 4154 break 4155 } 4156 c := v_1.AuxInt 4157 y := v_1.Args[0] 4158 v.reset(OpARMBICshiftRA) 4159 v.AuxInt = c 4160 v.AddArg(x) 4161 v.AddArg(y) 4162 return true 4163 } 4164 // match: (BIC x (SLL y z)) 4165 // cond: 4166 // result: (BICshiftLLreg x y z) 4167 for { 4168 _ = v.Args[1] 4169 x := v.Args[0] 4170 v_1 := v.Args[1] 4171 if v_1.Op != OpARMSLL { 4172 break 4173 } 4174 _ = v_1.Args[1] 4175 y := v_1.Args[0] 4176 z := v_1.Args[1] 4177 v.reset(OpARMBICshiftLLreg) 4178 v.AddArg(x) 4179 v.AddArg(y) 4180 v.AddArg(z) 4181 return true 4182 } 4183 // match: (BIC x (SRL y z)) 4184 // cond: 4185 // result: (BICshiftRLreg x y z) 4186 for { 4187 _ = v.Args[1] 4188 x := v.Args[0] 4189 v_1 := v.Args[1] 4190 if v_1.Op != OpARMSRL { 4191 break 4192 } 4193 _ = v_1.Args[1] 4194 y := v_1.Args[0] 4195 z := v_1.Args[1] 4196 v.reset(OpARMBICshiftRLreg) 4197 v.AddArg(x) 4198 v.AddArg(y) 4199 v.AddArg(z) 4200 return true 4201 } 4202 // match: (BIC x (SRA y z)) 4203 // cond: 4204 // result: (BICshiftRAreg x y z) 4205 for { 4206 _ = v.Args[1] 4207 x := v.Args[0] 4208 v_1 := v.Args[1] 4209 if v_1.Op != OpARMSRA { 4210 break 4211 } 4212 _ = v_1.Args[1] 4213 y := v_1.Args[0] 4214 z := v_1.Args[1] 4215 v.reset(OpARMBICshiftRAreg) 4216 v.AddArg(x) 4217 v.AddArg(y) 4218 v.AddArg(z) 4219 return true 4220 } 4221 // match: (BIC x x) 4222 // cond: 4223 // result: (MOVWconst [0]) 4224 for { 4225 _ = v.Args[1] 4226 x := v.Args[0] 4227 if x != v.Args[1] { 4228 break 4229 } 4230 v.reset(OpARMMOVWconst) 4231 v.AuxInt = 0 4232 return true 4233 } 4234 return false 4235 } 4236 func rewriteValueARM_OpARMBICconst_0(v *Value) bool { 4237 // match: (BICconst [0] x) 4238 // cond: 4239 // result: x 4240 for { 4241 if v.AuxInt != 0 { 4242 break 4243 } 4244 x := v.Args[0] 4245 v.reset(OpCopy) 4246 v.Type = x.Type 4247 v.AddArg(x) 4248 return true 4249 } 4250 // match: (BICconst [c] _) 4251 // cond: int32(c)==-1 4252 // result: (MOVWconst [0]) 4253 for { 4254 c := v.AuxInt 4255 if !(int32(c) == -1) { 4256 break 4257 } 4258 v.reset(OpARMMOVWconst) 4259 v.AuxInt = 0 4260 return true 4261 } 4262 // match: (BICconst [c] x) 4263 // cond: !isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c)) 4264 // result: (ANDconst [int64(int32(^uint32(c)))] x) 4265 for { 4266 c := v.AuxInt 4267 x := v.Args[0] 4268 if !(!isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c))) { 4269 break 4270 } 4271 v.reset(OpARMANDconst) 4272 v.AuxInt = int64(int32(^uint32(c))) 4273 v.AddArg(x) 4274 return true 4275 } 4276 // match: (BICconst [c] x) 4277 // cond: objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff 4278 // result: (ANDconst [int64(int32(^uint32(c)))] x) 4279 for { 4280 c := v.AuxInt 4281 x := v.Args[0] 4282 if !(objabi.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && ^uint32(c) <= 0xffff) { 4283 break 4284 } 4285 v.reset(OpARMANDconst) 4286 v.AuxInt = int64(int32(^uint32(c))) 4287 v.AddArg(x) 4288 return true 4289 } 4290 // match: (BICconst [c] (MOVWconst [d])) 4291 // cond: 4292 // result: (MOVWconst [d&^c]) 4293 for { 4294 c := v.AuxInt 4295 v_0 := v.Args[0] 4296 if v_0.Op != OpARMMOVWconst { 4297 break 4298 } 4299 d := v_0.AuxInt 4300 v.reset(OpARMMOVWconst) 4301 v.AuxInt = d &^ c 4302 return true 4303 } 4304 // match: (BICconst [c] (BICconst [d] x)) 4305 // cond: 4306 // result: (BICconst [int64(int32(c|d))] x) 4307 for { 4308 c := v.AuxInt 4309 v_0 := v.Args[0] 4310 if v_0.Op != OpARMBICconst { 4311 break 4312 } 4313 d := v_0.AuxInt 4314 x := v_0.Args[0] 4315 v.reset(OpARMBICconst) 4316 v.AuxInt = int64(int32(c | d)) 4317 v.AddArg(x) 4318 return true 4319 } 4320 return false 4321 } 4322 func rewriteValueARM_OpARMBICshiftLL_0(v *Value) bool { 4323 // match: (BICshiftLL x (MOVWconst [c]) [d]) 4324 // cond: 4325 // result: (BICconst x [int64(int32(uint32(c)<<uint64(d)))]) 4326 for { 4327 d := v.AuxInt 4328 _ = v.Args[1] 4329 x := v.Args[0] 4330 v_1 := v.Args[1] 4331 if v_1.Op != OpARMMOVWconst { 4332 break 4333 } 4334 c := v_1.AuxInt 4335 v.reset(OpARMBICconst) 4336 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 4337 v.AddArg(x) 4338 return true 4339 } 4340 // match: (BICshiftLL x (SLLconst x [c]) [d]) 4341 // cond: c==d 4342 // result: (MOVWconst [0]) 4343 for { 4344 d := v.AuxInt 4345 _ = v.Args[1] 4346 x := v.Args[0] 4347 v_1 := v.Args[1] 4348 if v_1.Op != OpARMSLLconst { 4349 break 4350 } 4351 c := v_1.AuxInt 4352 if x != v_1.Args[0] { 4353 break 4354 } 4355 if !(c == d) { 4356 break 4357 } 4358 v.reset(OpARMMOVWconst) 4359 v.AuxInt = 0 4360 return true 4361 } 4362 return false 4363 } 4364 func rewriteValueARM_OpARMBICshiftLLreg_0(v *Value) bool { 4365 // match: (BICshiftLLreg x y (MOVWconst [c])) 4366 // cond: 4367 // result: (BICshiftLL x y [c]) 4368 for { 4369 _ = v.Args[2] 4370 x := v.Args[0] 4371 y := v.Args[1] 4372 v_2 := v.Args[2] 4373 if v_2.Op != OpARMMOVWconst { 4374 break 4375 } 4376 c := v_2.AuxInt 4377 v.reset(OpARMBICshiftLL) 4378 v.AuxInt = c 4379 v.AddArg(x) 4380 v.AddArg(y) 4381 return true 4382 } 4383 return false 4384 } 4385 func rewriteValueARM_OpARMBICshiftRA_0(v *Value) bool { 4386 // match: (BICshiftRA x (MOVWconst [c]) [d]) 4387 // cond: 4388 // result: (BICconst x [int64(int32(c)>>uint64(d))]) 4389 for { 4390 d := v.AuxInt 4391 _ = v.Args[1] 4392 x := v.Args[0] 4393 v_1 := v.Args[1] 4394 if v_1.Op != OpARMMOVWconst { 4395 break 4396 } 4397 c := v_1.AuxInt 4398 v.reset(OpARMBICconst) 4399 v.AuxInt = int64(int32(c) >> uint64(d)) 4400 v.AddArg(x) 4401 return true 4402 } 4403 // match: (BICshiftRA x (SRAconst x [c]) [d]) 4404 // cond: c==d 4405 // result: (MOVWconst [0]) 4406 for { 4407 d := v.AuxInt 4408 _ = v.Args[1] 4409 x := v.Args[0] 4410 v_1 := v.Args[1] 4411 if v_1.Op != OpARMSRAconst { 4412 break 4413 } 4414 c := v_1.AuxInt 4415 if x != v_1.Args[0] { 4416 break 4417 } 4418 if !(c == d) { 4419 break 4420 } 4421 v.reset(OpARMMOVWconst) 4422 v.AuxInt = 0 4423 return true 4424 } 4425 return false 4426 } 4427 func rewriteValueARM_OpARMBICshiftRAreg_0(v *Value) bool { 4428 // match: (BICshiftRAreg x y (MOVWconst [c])) 4429 // cond: 4430 // result: (BICshiftRA x y [c]) 4431 for { 4432 _ = v.Args[2] 4433 x := v.Args[0] 4434 y := v.Args[1] 4435 v_2 := v.Args[2] 4436 if v_2.Op != OpARMMOVWconst { 4437 break 4438 } 4439 c := v_2.AuxInt 4440 v.reset(OpARMBICshiftRA) 4441 v.AuxInt = c 4442 v.AddArg(x) 4443 v.AddArg(y) 4444 return true 4445 } 4446 return false 4447 } 4448 func rewriteValueARM_OpARMBICshiftRL_0(v *Value) bool { 4449 // match: (BICshiftRL x (MOVWconst [c]) [d]) 4450 // cond: 4451 // result: (BICconst x [int64(int32(uint32(c)>>uint64(d)))]) 4452 for { 4453 d := v.AuxInt 4454 _ = v.Args[1] 4455 x := v.Args[0] 4456 v_1 := v.Args[1] 4457 if v_1.Op != OpARMMOVWconst { 4458 break 4459 } 4460 c := v_1.AuxInt 4461 v.reset(OpARMBICconst) 4462 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 4463 v.AddArg(x) 4464 return true 4465 } 4466 // match: (BICshiftRL x (SRLconst x [c]) [d]) 4467 // cond: c==d 4468 // result: (MOVWconst [0]) 4469 for { 4470 d := v.AuxInt 4471 _ = v.Args[1] 4472 x := v.Args[0] 4473 v_1 := v.Args[1] 4474 if v_1.Op != OpARMSRLconst { 4475 break 4476 } 4477 c := v_1.AuxInt 4478 if x != v_1.Args[0] { 4479 break 4480 } 4481 if !(c == d) { 4482 break 4483 } 4484 v.reset(OpARMMOVWconst) 4485 v.AuxInt = 0 4486 return true 4487 } 4488 return false 4489 } 4490 func rewriteValueARM_OpARMBICshiftRLreg_0(v *Value) bool { 4491 // match: (BICshiftRLreg x y (MOVWconst [c])) 4492 // cond: 4493 // result: (BICshiftRL x y [c]) 4494 for { 4495 _ = v.Args[2] 4496 x := v.Args[0] 4497 y := v.Args[1] 4498 v_2 := v.Args[2] 4499 if v_2.Op != OpARMMOVWconst { 4500 break 4501 } 4502 c := v_2.AuxInt 4503 v.reset(OpARMBICshiftRL) 4504 v.AuxInt = c 4505 v.AddArg(x) 4506 v.AddArg(y) 4507 return true 4508 } 4509 return false 4510 } 4511 func rewriteValueARM_OpARMCMN_0(v *Value) bool { 4512 // match: (CMN x (MOVWconst [c])) 4513 // cond: 4514 // result: (CMNconst [c] x) 4515 for { 4516 _ = v.Args[1] 4517 x := v.Args[0] 4518 v_1 := v.Args[1] 4519 if v_1.Op != OpARMMOVWconst { 4520 break 4521 } 4522 c := v_1.AuxInt 4523 v.reset(OpARMCMNconst) 4524 v.AuxInt = c 4525 v.AddArg(x) 4526 return true 4527 } 4528 // match: (CMN (MOVWconst [c]) x) 4529 // cond: 4530 // result: (CMNconst [c] x) 4531 for { 4532 _ = v.Args[1] 4533 v_0 := v.Args[0] 4534 if v_0.Op != OpARMMOVWconst { 4535 break 4536 } 4537 c := v_0.AuxInt 4538 x := v.Args[1] 4539 v.reset(OpARMCMNconst) 4540 v.AuxInt = c 4541 v.AddArg(x) 4542 return true 4543 } 4544 // match: (CMN x (SLLconst [c] y)) 4545 // cond: 4546 // result: (CMNshiftLL x y [c]) 4547 for { 4548 _ = v.Args[1] 4549 x := v.Args[0] 4550 v_1 := v.Args[1] 4551 if v_1.Op != OpARMSLLconst { 4552 break 4553 } 4554 c := v_1.AuxInt 4555 y := v_1.Args[0] 4556 v.reset(OpARMCMNshiftLL) 4557 v.AuxInt = c 4558 v.AddArg(x) 4559 v.AddArg(y) 4560 return true 4561 } 4562 // match: (CMN (SLLconst [c] y) x) 4563 // cond: 4564 // result: (CMNshiftLL x y [c]) 4565 for { 4566 _ = v.Args[1] 4567 v_0 := v.Args[0] 4568 if v_0.Op != OpARMSLLconst { 4569 break 4570 } 4571 c := v_0.AuxInt 4572 y := v_0.Args[0] 4573 x := v.Args[1] 4574 v.reset(OpARMCMNshiftLL) 4575 v.AuxInt = c 4576 v.AddArg(x) 4577 v.AddArg(y) 4578 return true 4579 } 4580 // match: (CMN x (SRLconst [c] y)) 4581 // cond: 4582 // result: (CMNshiftRL x y [c]) 4583 for { 4584 _ = v.Args[1] 4585 x := v.Args[0] 4586 v_1 := v.Args[1] 4587 if v_1.Op != OpARMSRLconst { 4588 break 4589 } 4590 c := v_1.AuxInt 4591 y := v_1.Args[0] 4592 v.reset(OpARMCMNshiftRL) 4593 v.AuxInt = c 4594 v.AddArg(x) 4595 v.AddArg(y) 4596 return true 4597 } 4598 // match: (CMN (SRLconst [c] y) x) 4599 // cond: 4600 // result: (CMNshiftRL x y [c]) 4601 for { 4602 _ = v.Args[1] 4603 v_0 := v.Args[0] 4604 if v_0.Op != OpARMSRLconst { 4605 break 4606 } 4607 c := v_0.AuxInt 4608 y := v_0.Args[0] 4609 x := v.Args[1] 4610 v.reset(OpARMCMNshiftRL) 4611 v.AuxInt = c 4612 v.AddArg(x) 4613 v.AddArg(y) 4614 return true 4615 } 4616 // match: (CMN x (SRAconst [c] y)) 4617 // cond: 4618 // result: (CMNshiftRA x y [c]) 4619 for { 4620 _ = v.Args[1] 4621 x := v.Args[0] 4622 v_1 := v.Args[1] 4623 if v_1.Op != OpARMSRAconst { 4624 break 4625 } 4626 c := v_1.AuxInt 4627 y := v_1.Args[0] 4628 v.reset(OpARMCMNshiftRA) 4629 v.AuxInt = c 4630 v.AddArg(x) 4631 v.AddArg(y) 4632 return true 4633 } 4634 // match: (CMN (SRAconst [c] y) x) 4635 // cond: 4636 // result: (CMNshiftRA x y [c]) 4637 for { 4638 _ = v.Args[1] 4639 v_0 := v.Args[0] 4640 if v_0.Op != OpARMSRAconst { 4641 break 4642 } 4643 c := v_0.AuxInt 4644 y := v_0.Args[0] 4645 x := v.Args[1] 4646 v.reset(OpARMCMNshiftRA) 4647 v.AuxInt = c 4648 v.AddArg(x) 4649 v.AddArg(y) 4650 return true 4651 } 4652 // match: (CMN x (SLL y z)) 4653 // cond: 4654 // result: (CMNshiftLLreg x y z) 4655 for { 4656 _ = v.Args[1] 4657 x := v.Args[0] 4658 v_1 := v.Args[1] 4659 if v_1.Op != OpARMSLL { 4660 break 4661 } 4662 _ = v_1.Args[1] 4663 y := v_1.Args[0] 4664 z := v_1.Args[1] 4665 v.reset(OpARMCMNshiftLLreg) 4666 v.AddArg(x) 4667 v.AddArg(y) 4668 v.AddArg(z) 4669 return true 4670 } 4671 // match: (CMN (SLL y z) x) 4672 // cond: 4673 // result: (CMNshiftLLreg x y z) 4674 for { 4675 _ = v.Args[1] 4676 v_0 := v.Args[0] 4677 if v_0.Op != OpARMSLL { 4678 break 4679 } 4680 _ = v_0.Args[1] 4681 y := v_0.Args[0] 4682 z := v_0.Args[1] 4683 x := v.Args[1] 4684 v.reset(OpARMCMNshiftLLreg) 4685 v.AddArg(x) 4686 v.AddArg(y) 4687 v.AddArg(z) 4688 return true 4689 } 4690 return false 4691 } 4692 func rewriteValueARM_OpARMCMN_10(v *Value) bool { 4693 // match: (CMN x (SRL y z)) 4694 // cond: 4695 // result: (CMNshiftRLreg x y z) 4696 for { 4697 _ = v.Args[1] 4698 x := v.Args[0] 4699 v_1 := v.Args[1] 4700 if v_1.Op != OpARMSRL { 4701 break 4702 } 4703 _ = v_1.Args[1] 4704 y := v_1.Args[0] 4705 z := v_1.Args[1] 4706 v.reset(OpARMCMNshiftRLreg) 4707 v.AddArg(x) 4708 v.AddArg(y) 4709 v.AddArg(z) 4710 return true 4711 } 4712 // match: (CMN (SRL y z) x) 4713 // cond: 4714 // result: (CMNshiftRLreg x y z) 4715 for { 4716 _ = v.Args[1] 4717 v_0 := v.Args[0] 4718 if v_0.Op != OpARMSRL { 4719 break 4720 } 4721 _ = v_0.Args[1] 4722 y := v_0.Args[0] 4723 z := v_0.Args[1] 4724 x := v.Args[1] 4725 v.reset(OpARMCMNshiftRLreg) 4726 v.AddArg(x) 4727 v.AddArg(y) 4728 v.AddArg(z) 4729 return true 4730 } 4731 // match: (CMN x (SRA y z)) 4732 // cond: 4733 // result: (CMNshiftRAreg x y z) 4734 for { 4735 _ = v.Args[1] 4736 x := v.Args[0] 4737 v_1 := v.Args[1] 4738 if v_1.Op != OpARMSRA { 4739 break 4740 } 4741 _ = v_1.Args[1] 4742 y := v_1.Args[0] 4743 z := v_1.Args[1] 4744 v.reset(OpARMCMNshiftRAreg) 4745 v.AddArg(x) 4746 v.AddArg(y) 4747 v.AddArg(z) 4748 return true 4749 } 4750 // match: (CMN (SRA y z) x) 4751 // cond: 4752 // result: (CMNshiftRAreg x y z) 4753 for { 4754 _ = v.Args[1] 4755 v_0 := v.Args[0] 4756 if v_0.Op != OpARMSRA { 4757 break 4758 } 4759 _ = v_0.Args[1] 4760 y := v_0.Args[0] 4761 z := v_0.Args[1] 4762 x := v.Args[1] 4763 v.reset(OpARMCMNshiftRAreg) 4764 v.AddArg(x) 4765 v.AddArg(y) 4766 v.AddArg(z) 4767 return true 4768 } 4769 // match: (CMN x (RSBconst [0] y)) 4770 // cond: 4771 // result: (CMP x y) 4772 for { 4773 _ = v.Args[1] 4774 x := v.Args[0] 4775 v_1 := v.Args[1] 4776 if v_1.Op != OpARMRSBconst { 4777 break 4778 } 4779 if v_1.AuxInt != 0 { 4780 break 4781 } 4782 y := v_1.Args[0] 4783 v.reset(OpARMCMP) 4784 v.AddArg(x) 4785 v.AddArg(y) 4786 return true 4787 } 4788 // match: (CMN (RSBconst [0] y) x) 4789 // cond: 4790 // result: (CMP x y) 4791 for { 4792 _ = v.Args[1] 4793 v_0 := v.Args[0] 4794 if v_0.Op != OpARMRSBconst { 4795 break 4796 } 4797 if v_0.AuxInt != 0 { 4798 break 4799 } 4800 y := v_0.Args[0] 4801 x := v.Args[1] 4802 v.reset(OpARMCMP) 4803 v.AddArg(x) 4804 v.AddArg(y) 4805 return true 4806 } 4807 return false 4808 } 4809 func rewriteValueARM_OpARMCMNconst_0(v *Value) bool { 4810 // match: (CMNconst (MOVWconst [x]) [y]) 4811 // cond: int32(x)==int32(-y) 4812 // result: (FlagEQ) 4813 for { 4814 y := v.AuxInt 4815 v_0 := v.Args[0] 4816 if v_0.Op != OpARMMOVWconst { 4817 break 4818 } 4819 x := v_0.AuxInt 4820 if !(int32(x) == int32(-y)) { 4821 break 4822 } 4823 v.reset(OpARMFlagEQ) 4824 return true 4825 } 4826 // match: (CMNconst (MOVWconst [x]) [y]) 4827 // cond: int32(x)<int32(-y) && uint32(x)<uint32(-y) 4828 // result: (FlagLT_ULT) 4829 for { 4830 y := v.AuxInt 4831 v_0 := v.Args[0] 4832 if v_0.Op != OpARMMOVWconst { 4833 break 4834 } 4835 x := v_0.AuxInt 4836 if !(int32(x) < int32(-y) && uint32(x) < uint32(-y)) { 4837 break 4838 } 4839 v.reset(OpARMFlagLT_ULT) 4840 return true 4841 } 4842 // match: (CMNconst (MOVWconst [x]) [y]) 4843 // cond: int32(x)<int32(-y) && uint32(x)>uint32(-y) 4844 // result: (FlagLT_UGT) 4845 for { 4846 y := v.AuxInt 4847 v_0 := v.Args[0] 4848 if v_0.Op != OpARMMOVWconst { 4849 break 4850 } 4851 x := v_0.AuxInt 4852 if !(int32(x) < int32(-y) && uint32(x) > uint32(-y)) { 4853 break 4854 } 4855 v.reset(OpARMFlagLT_UGT) 4856 return true 4857 } 4858 // match: (CMNconst (MOVWconst [x]) [y]) 4859 // cond: int32(x)>int32(-y) && uint32(x)<uint32(-y) 4860 // result: (FlagGT_ULT) 4861 for { 4862 y := v.AuxInt 4863 v_0 := v.Args[0] 4864 if v_0.Op != OpARMMOVWconst { 4865 break 4866 } 4867 x := v_0.AuxInt 4868 if !(int32(x) > int32(-y) && uint32(x) < uint32(-y)) { 4869 break 4870 } 4871 v.reset(OpARMFlagGT_ULT) 4872 return true 4873 } 4874 // match: (CMNconst (MOVWconst [x]) [y]) 4875 // cond: int32(x)>int32(-y) && uint32(x)>uint32(-y) 4876 // result: (FlagGT_UGT) 4877 for { 4878 y := v.AuxInt 4879 v_0 := v.Args[0] 4880 if v_0.Op != OpARMMOVWconst { 4881 break 4882 } 4883 x := v_0.AuxInt 4884 if !(int32(x) > int32(-y) && uint32(x) > uint32(-y)) { 4885 break 4886 } 4887 v.reset(OpARMFlagGT_UGT) 4888 return true 4889 } 4890 return false 4891 } 4892 func rewriteValueARM_OpARMCMNshiftLL_0(v *Value) bool { 4893 b := v.Block 4894 _ = b 4895 // match: (CMNshiftLL (MOVWconst [c]) x [d]) 4896 // cond: 4897 // result: (CMNconst [c] (SLLconst <x.Type> x [d])) 4898 for { 4899 d := v.AuxInt 4900 _ = v.Args[1] 4901 v_0 := v.Args[0] 4902 if v_0.Op != OpARMMOVWconst { 4903 break 4904 } 4905 c := v_0.AuxInt 4906 x := v.Args[1] 4907 v.reset(OpARMCMNconst) 4908 v.AuxInt = c 4909 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 4910 v0.AuxInt = d 4911 v0.AddArg(x) 4912 v.AddArg(v0) 4913 return true 4914 } 4915 // match: (CMNshiftLL x (MOVWconst [c]) [d]) 4916 // cond: 4917 // result: (CMNconst x [int64(int32(uint32(c)<<uint64(d)))]) 4918 for { 4919 d := v.AuxInt 4920 _ = v.Args[1] 4921 x := v.Args[0] 4922 v_1 := v.Args[1] 4923 if v_1.Op != OpARMMOVWconst { 4924 break 4925 } 4926 c := v_1.AuxInt 4927 v.reset(OpARMCMNconst) 4928 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 4929 v.AddArg(x) 4930 return true 4931 } 4932 return false 4933 } 4934 func rewriteValueARM_OpARMCMNshiftLLreg_0(v *Value) bool { 4935 b := v.Block 4936 _ = b 4937 // match: (CMNshiftLLreg (MOVWconst [c]) x y) 4938 // cond: 4939 // result: (CMNconst [c] (SLL <x.Type> x y)) 4940 for { 4941 _ = v.Args[2] 4942 v_0 := v.Args[0] 4943 if v_0.Op != OpARMMOVWconst { 4944 break 4945 } 4946 c := v_0.AuxInt 4947 x := v.Args[1] 4948 y := v.Args[2] 4949 v.reset(OpARMCMNconst) 4950 v.AuxInt = c 4951 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 4952 v0.AddArg(x) 4953 v0.AddArg(y) 4954 v.AddArg(v0) 4955 return true 4956 } 4957 // match: (CMNshiftLLreg x y (MOVWconst [c])) 4958 // cond: 4959 // result: (CMNshiftLL x y [c]) 4960 for { 4961 _ = v.Args[2] 4962 x := v.Args[0] 4963 y := v.Args[1] 4964 v_2 := v.Args[2] 4965 if v_2.Op != OpARMMOVWconst { 4966 break 4967 } 4968 c := v_2.AuxInt 4969 v.reset(OpARMCMNshiftLL) 4970 v.AuxInt = c 4971 v.AddArg(x) 4972 v.AddArg(y) 4973 return true 4974 } 4975 return false 4976 } 4977 func rewriteValueARM_OpARMCMNshiftRA_0(v *Value) bool { 4978 b := v.Block 4979 _ = b 4980 // match: (CMNshiftRA (MOVWconst [c]) x [d]) 4981 // cond: 4982 // result: (CMNconst [c] (SRAconst <x.Type> x [d])) 4983 for { 4984 d := v.AuxInt 4985 _ = v.Args[1] 4986 v_0 := v.Args[0] 4987 if v_0.Op != OpARMMOVWconst { 4988 break 4989 } 4990 c := v_0.AuxInt 4991 x := v.Args[1] 4992 v.reset(OpARMCMNconst) 4993 v.AuxInt = c 4994 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 4995 v0.AuxInt = d 4996 v0.AddArg(x) 4997 v.AddArg(v0) 4998 return true 4999 } 5000 // match: (CMNshiftRA x (MOVWconst [c]) [d]) 5001 // cond: 5002 // result: (CMNconst x [int64(int32(c)>>uint64(d))]) 5003 for { 5004 d := v.AuxInt 5005 _ = v.Args[1] 5006 x := v.Args[0] 5007 v_1 := v.Args[1] 5008 if v_1.Op != OpARMMOVWconst { 5009 break 5010 } 5011 c := v_1.AuxInt 5012 v.reset(OpARMCMNconst) 5013 v.AuxInt = int64(int32(c) >> uint64(d)) 5014 v.AddArg(x) 5015 return true 5016 } 5017 return false 5018 } 5019 func rewriteValueARM_OpARMCMNshiftRAreg_0(v *Value) bool { 5020 b := v.Block 5021 _ = b 5022 // match: (CMNshiftRAreg (MOVWconst [c]) x y) 5023 // cond: 5024 // result: (CMNconst [c] (SRA <x.Type> x y)) 5025 for { 5026 _ = v.Args[2] 5027 v_0 := v.Args[0] 5028 if v_0.Op != OpARMMOVWconst { 5029 break 5030 } 5031 c := v_0.AuxInt 5032 x := v.Args[1] 5033 y := v.Args[2] 5034 v.reset(OpARMCMNconst) 5035 v.AuxInt = c 5036 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 5037 v0.AddArg(x) 5038 v0.AddArg(y) 5039 v.AddArg(v0) 5040 return true 5041 } 5042 // match: (CMNshiftRAreg x y (MOVWconst [c])) 5043 // cond: 5044 // result: (CMNshiftRA x y [c]) 5045 for { 5046 _ = v.Args[2] 5047 x := v.Args[0] 5048 y := v.Args[1] 5049 v_2 := v.Args[2] 5050 if v_2.Op != OpARMMOVWconst { 5051 break 5052 } 5053 c := v_2.AuxInt 5054 v.reset(OpARMCMNshiftRA) 5055 v.AuxInt = c 5056 v.AddArg(x) 5057 v.AddArg(y) 5058 return true 5059 } 5060 return false 5061 } 5062 func rewriteValueARM_OpARMCMNshiftRL_0(v *Value) bool { 5063 b := v.Block 5064 _ = b 5065 // match: (CMNshiftRL (MOVWconst [c]) x [d]) 5066 // cond: 5067 // result: (CMNconst [c] (SRLconst <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(OpARMCMNconst) 5078 v.AuxInt = c 5079 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 5080 v0.AuxInt = d 5081 v0.AddArg(x) 5082 v.AddArg(v0) 5083 return true 5084 } 5085 // match: (CMNshiftRL x (MOVWconst [c]) [d]) 5086 // cond: 5087 // result: (CMNconst x [int64(int32(uint32(c)>>uint64(d)))]) 5088 for { 5089 d := v.AuxInt 5090 _ = v.Args[1] 5091 x := v.Args[0] 5092 v_1 := v.Args[1] 5093 if v_1.Op != OpARMMOVWconst { 5094 break 5095 } 5096 c := v_1.AuxInt 5097 v.reset(OpARMCMNconst) 5098 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 5099 v.AddArg(x) 5100 return true 5101 } 5102 return false 5103 } 5104 func rewriteValueARM_OpARMCMNshiftRLreg_0(v *Value) bool { 5105 b := v.Block 5106 _ = b 5107 // match: (CMNshiftRLreg (MOVWconst [c]) x y) 5108 // cond: 5109 // result: (CMNconst [c] (SRL <x.Type> x y)) 5110 for { 5111 _ = v.Args[2] 5112 v_0 := v.Args[0] 5113 if v_0.Op != OpARMMOVWconst { 5114 break 5115 } 5116 c := v_0.AuxInt 5117 x := v.Args[1] 5118 y := v.Args[2] 5119 v.reset(OpARMCMNconst) 5120 v.AuxInt = c 5121 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 5122 v0.AddArg(x) 5123 v0.AddArg(y) 5124 v.AddArg(v0) 5125 return true 5126 } 5127 // match: (CMNshiftRLreg x y (MOVWconst [c])) 5128 // cond: 5129 // result: (CMNshiftRL x y [c]) 5130 for { 5131 _ = v.Args[2] 5132 x := v.Args[0] 5133 y := v.Args[1] 5134 v_2 := v.Args[2] 5135 if v_2.Op != OpARMMOVWconst { 5136 break 5137 } 5138 c := v_2.AuxInt 5139 v.reset(OpARMCMNshiftRL) 5140 v.AuxInt = c 5141 v.AddArg(x) 5142 v.AddArg(y) 5143 return true 5144 } 5145 return false 5146 } 5147 func rewriteValueARM_OpARMCMOVWHSconst_0(v *Value) bool { 5148 // match: (CMOVWHSconst _ (FlagEQ) [c]) 5149 // cond: 5150 // result: (MOVWconst [c]) 5151 for { 5152 c := v.AuxInt 5153 _ = v.Args[1] 5154 v_1 := v.Args[1] 5155 if v_1.Op != OpARMFlagEQ { 5156 break 5157 } 5158 v.reset(OpARMMOVWconst) 5159 v.AuxInt = c 5160 return true 5161 } 5162 // match: (CMOVWHSconst x (FlagLT_ULT)) 5163 // cond: 5164 // result: x 5165 for { 5166 _ = v.Args[1] 5167 x := v.Args[0] 5168 v_1 := v.Args[1] 5169 if v_1.Op != OpARMFlagLT_ULT { 5170 break 5171 } 5172 v.reset(OpCopy) 5173 v.Type = x.Type 5174 v.AddArg(x) 5175 return true 5176 } 5177 // match: (CMOVWHSconst _ (FlagLT_UGT) [c]) 5178 // cond: 5179 // result: (MOVWconst [c]) 5180 for { 5181 c := v.AuxInt 5182 _ = v.Args[1] 5183 v_1 := v.Args[1] 5184 if v_1.Op != OpARMFlagLT_UGT { 5185 break 5186 } 5187 v.reset(OpARMMOVWconst) 5188 v.AuxInt = c 5189 return true 5190 } 5191 // match: (CMOVWHSconst x (FlagGT_ULT)) 5192 // cond: 5193 // result: x 5194 for { 5195 _ = v.Args[1] 5196 x := v.Args[0] 5197 v_1 := v.Args[1] 5198 if v_1.Op != OpARMFlagGT_ULT { 5199 break 5200 } 5201 v.reset(OpCopy) 5202 v.Type = x.Type 5203 v.AddArg(x) 5204 return true 5205 } 5206 // match: (CMOVWHSconst _ (FlagGT_UGT) [c]) 5207 // cond: 5208 // result: (MOVWconst [c]) 5209 for { 5210 c := v.AuxInt 5211 _ = v.Args[1] 5212 v_1 := v.Args[1] 5213 if v_1.Op != OpARMFlagGT_UGT { 5214 break 5215 } 5216 v.reset(OpARMMOVWconst) 5217 v.AuxInt = c 5218 return true 5219 } 5220 // match: (CMOVWHSconst x (InvertFlags flags) [c]) 5221 // cond: 5222 // result: (CMOVWLSconst x flags [c]) 5223 for { 5224 c := v.AuxInt 5225 _ = v.Args[1] 5226 x := v.Args[0] 5227 v_1 := v.Args[1] 5228 if v_1.Op != OpARMInvertFlags { 5229 break 5230 } 5231 flags := v_1.Args[0] 5232 v.reset(OpARMCMOVWLSconst) 5233 v.AuxInt = c 5234 v.AddArg(x) 5235 v.AddArg(flags) 5236 return true 5237 } 5238 return false 5239 } 5240 func rewriteValueARM_OpARMCMOVWLSconst_0(v *Value) bool { 5241 // match: (CMOVWLSconst _ (FlagEQ) [c]) 5242 // cond: 5243 // result: (MOVWconst [c]) 5244 for { 5245 c := v.AuxInt 5246 _ = v.Args[1] 5247 v_1 := v.Args[1] 5248 if v_1.Op != OpARMFlagEQ { 5249 break 5250 } 5251 v.reset(OpARMMOVWconst) 5252 v.AuxInt = c 5253 return true 5254 } 5255 // match: (CMOVWLSconst _ (FlagLT_ULT) [c]) 5256 // cond: 5257 // result: (MOVWconst [c]) 5258 for { 5259 c := v.AuxInt 5260 _ = v.Args[1] 5261 v_1 := v.Args[1] 5262 if v_1.Op != OpARMFlagLT_ULT { 5263 break 5264 } 5265 v.reset(OpARMMOVWconst) 5266 v.AuxInt = c 5267 return true 5268 } 5269 // match: (CMOVWLSconst x (FlagLT_UGT)) 5270 // cond: 5271 // result: x 5272 for { 5273 _ = v.Args[1] 5274 x := v.Args[0] 5275 v_1 := v.Args[1] 5276 if v_1.Op != OpARMFlagLT_UGT { 5277 break 5278 } 5279 v.reset(OpCopy) 5280 v.Type = x.Type 5281 v.AddArg(x) 5282 return true 5283 } 5284 // match: (CMOVWLSconst _ (FlagGT_ULT) [c]) 5285 // cond: 5286 // result: (MOVWconst [c]) 5287 for { 5288 c := v.AuxInt 5289 _ = v.Args[1] 5290 v_1 := v.Args[1] 5291 if v_1.Op != OpARMFlagGT_ULT { 5292 break 5293 } 5294 v.reset(OpARMMOVWconst) 5295 v.AuxInt = c 5296 return true 5297 } 5298 // match: (CMOVWLSconst x (FlagGT_UGT)) 5299 // cond: 5300 // result: x 5301 for { 5302 _ = v.Args[1] 5303 x := v.Args[0] 5304 v_1 := v.Args[1] 5305 if v_1.Op != OpARMFlagGT_UGT { 5306 break 5307 } 5308 v.reset(OpCopy) 5309 v.Type = x.Type 5310 v.AddArg(x) 5311 return true 5312 } 5313 // match: (CMOVWLSconst x (InvertFlags flags) [c]) 5314 // cond: 5315 // result: (CMOVWHSconst x flags [c]) 5316 for { 5317 c := v.AuxInt 5318 _ = v.Args[1] 5319 x := v.Args[0] 5320 v_1 := v.Args[1] 5321 if v_1.Op != OpARMInvertFlags { 5322 break 5323 } 5324 flags := v_1.Args[0] 5325 v.reset(OpARMCMOVWHSconst) 5326 v.AuxInt = c 5327 v.AddArg(x) 5328 v.AddArg(flags) 5329 return true 5330 } 5331 return false 5332 } 5333 func rewriteValueARM_OpARMCMP_0(v *Value) bool { 5334 b := v.Block 5335 _ = b 5336 // match: (CMP x (MOVWconst [c])) 5337 // cond: 5338 // result: (CMPconst [c] x) 5339 for { 5340 _ = v.Args[1] 5341 x := v.Args[0] 5342 v_1 := v.Args[1] 5343 if v_1.Op != OpARMMOVWconst { 5344 break 5345 } 5346 c := v_1.AuxInt 5347 v.reset(OpARMCMPconst) 5348 v.AuxInt = c 5349 v.AddArg(x) 5350 return true 5351 } 5352 // match: (CMP (MOVWconst [c]) x) 5353 // cond: 5354 // result: (InvertFlags (CMPconst [c] x)) 5355 for { 5356 _ = v.Args[1] 5357 v_0 := v.Args[0] 5358 if v_0.Op != OpARMMOVWconst { 5359 break 5360 } 5361 c := v_0.AuxInt 5362 x := v.Args[1] 5363 v.reset(OpARMInvertFlags) 5364 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 5365 v0.AuxInt = c 5366 v0.AddArg(x) 5367 v.AddArg(v0) 5368 return true 5369 } 5370 // match: (CMP x (SLLconst [c] y)) 5371 // cond: 5372 // result: (CMPshiftLL x y [c]) 5373 for { 5374 _ = v.Args[1] 5375 x := v.Args[0] 5376 v_1 := v.Args[1] 5377 if v_1.Op != OpARMSLLconst { 5378 break 5379 } 5380 c := v_1.AuxInt 5381 y := v_1.Args[0] 5382 v.reset(OpARMCMPshiftLL) 5383 v.AuxInt = c 5384 v.AddArg(x) 5385 v.AddArg(y) 5386 return true 5387 } 5388 // match: (CMP (SLLconst [c] y) x) 5389 // cond: 5390 // result: (InvertFlags (CMPshiftLL x y [c])) 5391 for { 5392 _ = v.Args[1] 5393 v_0 := v.Args[0] 5394 if v_0.Op != OpARMSLLconst { 5395 break 5396 } 5397 c := v_0.AuxInt 5398 y := v_0.Args[0] 5399 x := v.Args[1] 5400 v.reset(OpARMInvertFlags) 5401 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags) 5402 v0.AuxInt = c 5403 v0.AddArg(x) 5404 v0.AddArg(y) 5405 v.AddArg(v0) 5406 return true 5407 } 5408 // match: (CMP x (SRLconst [c] y)) 5409 // cond: 5410 // result: (CMPshiftRL x y [c]) 5411 for { 5412 _ = v.Args[1] 5413 x := v.Args[0] 5414 v_1 := v.Args[1] 5415 if v_1.Op != OpARMSRLconst { 5416 break 5417 } 5418 c := v_1.AuxInt 5419 y := v_1.Args[0] 5420 v.reset(OpARMCMPshiftRL) 5421 v.AuxInt = c 5422 v.AddArg(x) 5423 v.AddArg(y) 5424 return true 5425 } 5426 // match: (CMP (SRLconst [c] y) x) 5427 // cond: 5428 // result: (InvertFlags (CMPshiftRL x y [c])) 5429 for { 5430 _ = v.Args[1] 5431 v_0 := v.Args[0] 5432 if v_0.Op != OpARMSRLconst { 5433 break 5434 } 5435 c := v_0.AuxInt 5436 y := v_0.Args[0] 5437 x := v.Args[1] 5438 v.reset(OpARMInvertFlags) 5439 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags) 5440 v0.AuxInt = c 5441 v0.AddArg(x) 5442 v0.AddArg(y) 5443 v.AddArg(v0) 5444 return true 5445 } 5446 // match: (CMP x (SRAconst [c] y)) 5447 // cond: 5448 // result: (CMPshiftRA x y [c]) 5449 for { 5450 _ = v.Args[1] 5451 x := v.Args[0] 5452 v_1 := v.Args[1] 5453 if v_1.Op != OpARMSRAconst { 5454 break 5455 } 5456 c := v_1.AuxInt 5457 y := v_1.Args[0] 5458 v.reset(OpARMCMPshiftRA) 5459 v.AuxInt = c 5460 v.AddArg(x) 5461 v.AddArg(y) 5462 return true 5463 } 5464 // match: (CMP (SRAconst [c] y) x) 5465 // cond: 5466 // result: (InvertFlags (CMPshiftRA x y [c])) 5467 for { 5468 _ = v.Args[1] 5469 v_0 := v.Args[0] 5470 if v_0.Op != OpARMSRAconst { 5471 break 5472 } 5473 c := v_0.AuxInt 5474 y := v_0.Args[0] 5475 x := v.Args[1] 5476 v.reset(OpARMInvertFlags) 5477 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags) 5478 v0.AuxInt = c 5479 v0.AddArg(x) 5480 v0.AddArg(y) 5481 v.AddArg(v0) 5482 return true 5483 } 5484 // match: (CMP x (SLL y z)) 5485 // cond: 5486 // result: (CMPshiftLLreg x y z) 5487 for { 5488 _ = v.Args[1] 5489 x := v.Args[0] 5490 v_1 := v.Args[1] 5491 if v_1.Op != OpARMSLL { 5492 break 5493 } 5494 _ = v_1.Args[1] 5495 y := v_1.Args[0] 5496 z := v_1.Args[1] 5497 v.reset(OpARMCMPshiftLLreg) 5498 v.AddArg(x) 5499 v.AddArg(y) 5500 v.AddArg(z) 5501 return true 5502 } 5503 // match: (CMP (SLL y z) x) 5504 // cond: 5505 // result: (InvertFlags (CMPshiftLLreg x y z)) 5506 for { 5507 _ = v.Args[1] 5508 v_0 := v.Args[0] 5509 if v_0.Op != OpARMSLL { 5510 break 5511 } 5512 _ = v_0.Args[1] 5513 y := v_0.Args[0] 5514 z := v_0.Args[1] 5515 x := v.Args[1] 5516 v.reset(OpARMInvertFlags) 5517 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags) 5518 v0.AddArg(x) 5519 v0.AddArg(y) 5520 v0.AddArg(z) 5521 v.AddArg(v0) 5522 return true 5523 } 5524 return false 5525 } 5526 func rewriteValueARM_OpARMCMP_10(v *Value) bool { 5527 b := v.Block 5528 _ = b 5529 // match: (CMP x (SRL y z)) 5530 // cond: 5531 // result: (CMPshiftRLreg x y z) 5532 for { 5533 _ = v.Args[1] 5534 x := v.Args[0] 5535 v_1 := v.Args[1] 5536 if v_1.Op != OpARMSRL { 5537 break 5538 } 5539 _ = v_1.Args[1] 5540 y := v_1.Args[0] 5541 z := v_1.Args[1] 5542 v.reset(OpARMCMPshiftRLreg) 5543 v.AddArg(x) 5544 v.AddArg(y) 5545 v.AddArg(z) 5546 return true 5547 } 5548 // match: (CMP (SRL y z) x) 5549 // cond: 5550 // result: (InvertFlags (CMPshiftRLreg x y z)) 5551 for { 5552 _ = v.Args[1] 5553 v_0 := v.Args[0] 5554 if v_0.Op != OpARMSRL { 5555 break 5556 } 5557 _ = v_0.Args[1] 5558 y := v_0.Args[0] 5559 z := v_0.Args[1] 5560 x := v.Args[1] 5561 v.reset(OpARMInvertFlags) 5562 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags) 5563 v0.AddArg(x) 5564 v0.AddArg(y) 5565 v0.AddArg(z) 5566 v.AddArg(v0) 5567 return true 5568 } 5569 // match: (CMP x (SRA y z)) 5570 // cond: 5571 // result: (CMPshiftRAreg x y z) 5572 for { 5573 _ = v.Args[1] 5574 x := v.Args[0] 5575 v_1 := v.Args[1] 5576 if v_1.Op != OpARMSRA { 5577 break 5578 } 5579 _ = v_1.Args[1] 5580 y := v_1.Args[0] 5581 z := v_1.Args[1] 5582 v.reset(OpARMCMPshiftRAreg) 5583 v.AddArg(x) 5584 v.AddArg(y) 5585 v.AddArg(z) 5586 return true 5587 } 5588 // match: (CMP (SRA y z) x) 5589 // cond: 5590 // result: (InvertFlags (CMPshiftRAreg x y z)) 5591 for { 5592 _ = v.Args[1] 5593 v_0 := v.Args[0] 5594 if v_0.Op != OpARMSRA { 5595 break 5596 } 5597 _ = v_0.Args[1] 5598 y := v_0.Args[0] 5599 z := v_0.Args[1] 5600 x := v.Args[1] 5601 v.reset(OpARMInvertFlags) 5602 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags) 5603 v0.AddArg(x) 5604 v0.AddArg(y) 5605 v0.AddArg(z) 5606 v.AddArg(v0) 5607 return true 5608 } 5609 // match: (CMP x (RSBconst [0] y)) 5610 // cond: 5611 // result: (CMN x y) 5612 for { 5613 _ = v.Args[1] 5614 x := v.Args[0] 5615 v_1 := v.Args[1] 5616 if v_1.Op != OpARMRSBconst { 5617 break 5618 } 5619 if v_1.AuxInt != 0 { 5620 break 5621 } 5622 y := v_1.Args[0] 5623 v.reset(OpARMCMN) 5624 v.AddArg(x) 5625 v.AddArg(y) 5626 return true 5627 } 5628 return false 5629 } 5630 func rewriteValueARM_OpARMCMPD_0(v *Value) bool { 5631 // match: (CMPD x (MOVDconst [0])) 5632 // cond: 5633 // result: (CMPD0 x) 5634 for { 5635 _ = v.Args[1] 5636 x := v.Args[0] 5637 v_1 := v.Args[1] 5638 if v_1.Op != OpARMMOVDconst { 5639 break 5640 } 5641 if v_1.AuxInt != 0 { 5642 break 5643 } 5644 v.reset(OpARMCMPD0) 5645 v.AddArg(x) 5646 return true 5647 } 5648 return false 5649 } 5650 func rewriteValueARM_OpARMCMPF_0(v *Value) bool { 5651 // match: (CMPF x (MOVFconst [0])) 5652 // cond: 5653 // result: (CMPF0 x) 5654 for { 5655 _ = v.Args[1] 5656 x := v.Args[0] 5657 v_1 := v.Args[1] 5658 if v_1.Op != OpARMMOVFconst { 5659 break 5660 } 5661 if v_1.AuxInt != 0 { 5662 break 5663 } 5664 v.reset(OpARMCMPF0) 5665 v.AddArg(x) 5666 return true 5667 } 5668 return false 5669 } 5670 func rewriteValueARM_OpARMCMPconst_0(v *Value) bool { 5671 // match: (CMPconst (MOVWconst [x]) [y]) 5672 // cond: int32(x)==int32(y) 5673 // result: (FlagEQ) 5674 for { 5675 y := v.AuxInt 5676 v_0 := v.Args[0] 5677 if v_0.Op != OpARMMOVWconst { 5678 break 5679 } 5680 x := v_0.AuxInt 5681 if !(int32(x) == int32(y)) { 5682 break 5683 } 5684 v.reset(OpARMFlagEQ) 5685 return true 5686 } 5687 // match: (CMPconst (MOVWconst [x]) [y]) 5688 // cond: int32(x)<int32(y) && uint32(x)<uint32(y) 5689 // result: (FlagLT_ULT) 5690 for { 5691 y := v.AuxInt 5692 v_0 := v.Args[0] 5693 if v_0.Op != OpARMMOVWconst { 5694 break 5695 } 5696 x := v_0.AuxInt 5697 if !(int32(x) < int32(y) && uint32(x) < uint32(y)) { 5698 break 5699 } 5700 v.reset(OpARMFlagLT_ULT) 5701 return true 5702 } 5703 // match: (CMPconst (MOVWconst [x]) [y]) 5704 // cond: int32(x)<int32(y) && uint32(x)>uint32(y) 5705 // result: (FlagLT_UGT) 5706 for { 5707 y := v.AuxInt 5708 v_0 := v.Args[0] 5709 if v_0.Op != OpARMMOVWconst { 5710 break 5711 } 5712 x := v_0.AuxInt 5713 if !(int32(x) < int32(y) && uint32(x) > uint32(y)) { 5714 break 5715 } 5716 v.reset(OpARMFlagLT_UGT) 5717 return true 5718 } 5719 // match: (CMPconst (MOVWconst [x]) [y]) 5720 // cond: int32(x)>int32(y) && uint32(x)<uint32(y) 5721 // result: (FlagGT_ULT) 5722 for { 5723 y := v.AuxInt 5724 v_0 := v.Args[0] 5725 if v_0.Op != OpARMMOVWconst { 5726 break 5727 } 5728 x := v_0.AuxInt 5729 if !(int32(x) > int32(y) && uint32(x) < uint32(y)) { 5730 break 5731 } 5732 v.reset(OpARMFlagGT_ULT) 5733 return true 5734 } 5735 // match: (CMPconst (MOVWconst [x]) [y]) 5736 // cond: int32(x)>int32(y) && uint32(x)>uint32(y) 5737 // result: (FlagGT_UGT) 5738 for { 5739 y := v.AuxInt 5740 v_0 := v.Args[0] 5741 if v_0.Op != OpARMMOVWconst { 5742 break 5743 } 5744 x := v_0.AuxInt 5745 if !(int32(x) > int32(y) && uint32(x) > uint32(y)) { 5746 break 5747 } 5748 v.reset(OpARMFlagGT_UGT) 5749 return true 5750 } 5751 // match: (CMPconst (MOVBUreg _) [c]) 5752 // cond: 0xff < c 5753 // result: (FlagLT_ULT) 5754 for { 5755 c := v.AuxInt 5756 v_0 := v.Args[0] 5757 if v_0.Op != OpARMMOVBUreg { 5758 break 5759 } 5760 if !(0xff < c) { 5761 break 5762 } 5763 v.reset(OpARMFlagLT_ULT) 5764 return true 5765 } 5766 // match: (CMPconst (MOVHUreg _) [c]) 5767 // cond: 0xffff < c 5768 // result: (FlagLT_ULT) 5769 for { 5770 c := v.AuxInt 5771 v_0 := v.Args[0] 5772 if v_0.Op != OpARMMOVHUreg { 5773 break 5774 } 5775 if !(0xffff < c) { 5776 break 5777 } 5778 v.reset(OpARMFlagLT_ULT) 5779 return true 5780 } 5781 // match: (CMPconst (ANDconst _ [m]) [n]) 5782 // cond: 0 <= int32(m) && int32(m) < int32(n) 5783 // result: (FlagLT_ULT) 5784 for { 5785 n := v.AuxInt 5786 v_0 := v.Args[0] 5787 if v_0.Op != OpARMANDconst { 5788 break 5789 } 5790 m := v_0.AuxInt 5791 if !(0 <= int32(m) && int32(m) < int32(n)) { 5792 break 5793 } 5794 v.reset(OpARMFlagLT_ULT) 5795 return true 5796 } 5797 // match: (CMPconst (SRLconst _ [c]) [n]) 5798 // cond: 0 <= n && 0 < c && c <= 32 && (1<<uint32(32-c)) <= uint32(n) 5799 // result: (FlagLT_ULT) 5800 for { 5801 n := v.AuxInt 5802 v_0 := v.Args[0] 5803 if v_0.Op != OpARMSRLconst { 5804 break 5805 } 5806 c := v_0.AuxInt 5807 if !(0 <= n && 0 < c && c <= 32 && (1<<uint32(32-c)) <= uint32(n)) { 5808 break 5809 } 5810 v.reset(OpARMFlagLT_ULT) 5811 return true 5812 } 5813 return false 5814 } 5815 func rewriteValueARM_OpARMCMPshiftLL_0(v *Value) bool { 5816 b := v.Block 5817 _ = b 5818 // match: (CMPshiftLL (MOVWconst [c]) x [d]) 5819 // cond: 5820 // result: (InvertFlags (CMPconst [c] (SLLconst <x.Type> x [d]))) 5821 for { 5822 d := v.AuxInt 5823 _ = v.Args[1] 5824 v_0 := v.Args[0] 5825 if v_0.Op != OpARMMOVWconst { 5826 break 5827 } 5828 c := v_0.AuxInt 5829 x := v.Args[1] 5830 v.reset(OpARMInvertFlags) 5831 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 5832 v0.AuxInt = c 5833 v1 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 5834 v1.AuxInt = d 5835 v1.AddArg(x) 5836 v0.AddArg(v1) 5837 v.AddArg(v0) 5838 return true 5839 } 5840 // match: (CMPshiftLL x (MOVWconst [c]) [d]) 5841 // cond: 5842 // result: (CMPconst x [int64(int32(uint32(c)<<uint64(d)))]) 5843 for { 5844 d := v.AuxInt 5845 _ = v.Args[1] 5846 x := v.Args[0] 5847 v_1 := v.Args[1] 5848 if v_1.Op != OpARMMOVWconst { 5849 break 5850 } 5851 c := v_1.AuxInt 5852 v.reset(OpARMCMPconst) 5853 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 5854 v.AddArg(x) 5855 return true 5856 } 5857 return false 5858 } 5859 func rewriteValueARM_OpARMCMPshiftLLreg_0(v *Value) bool { 5860 b := v.Block 5861 _ = b 5862 // match: (CMPshiftLLreg (MOVWconst [c]) x y) 5863 // cond: 5864 // result: (InvertFlags (CMPconst [c] (SLL <x.Type> x y))) 5865 for { 5866 _ = v.Args[2] 5867 v_0 := v.Args[0] 5868 if v_0.Op != OpARMMOVWconst { 5869 break 5870 } 5871 c := v_0.AuxInt 5872 x := v.Args[1] 5873 y := v.Args[2] 5874 v.reset(OpARMInvertFlags) 5875 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 5876 v0.AuxInt = c 5877 v1 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 5878 v1.AddArg(x) 5879 v1.AddArg(y) 5880 v0.AddArg(v1) 5881 v.AddArg(v0) 5882 return true 5883 } 5884 // match: (CMPshiftLLreg x y (MOVWconst [c])) 5885 // cond: 5886 // result: (CMPshiftLL x y [c]) 5887 for { 5888 _ = v.Args[2] 5889 x := v.Args[0] 5890 y := v.Args[1] 5891 v_2 := v.Args[2] 5892 if v_2.Op != OpARMMOVWconst { 5893 break 5894 } 5895 c := v_2.AuxInt 5896 v.reset(OpARMCMPshiftLL) 5897 v.AuxInt = c 5898 v.AddArg(x) 5899 v.AddArg(y) 5900 return true 5901 } 5902 return false 5903 } 5904 func rewriteValueARM_OpARMCMPshiftRA_0(v *Value) bool { 5905 b := v.Block 5906 _ = b 5907 // match: (CMPshiftRA (MOVWconst [c]) x [d]) 5908 // cond: 5909 // result: (InvertFlags (CMPconst [c] (SRAconst <x.Type> x [d]))) 5910 for { 5911 d := v.AuxInt 5912 _ = v.Args[1] 5913 v_0 := v.Args[0] 5914 if v_0.Op != OpARMMOVWconst { 5915 break 5916 } 5917 c := v_0.AuxInt 5918 x := v.Args[1] 5919 v.reset(OpARMInvertFlags) 5920 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 5921 v0.AuxInt = c 5922 v1 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 5923 v1.AuxInt = d 5924 v1.AddArg(x) 5925 v0.AddArg(v1) 5926 v.AddArg(v0) 5927 return true 5928 } 5929 // match: (CMPshiftRA x (MOVWconst [c]) [d]) 5930 // cond: 5931 // result: (CMPconst x [int64(int32(c)>>uint64(d))]) 5932 for { 5933 d := v.AuxInt 5934 _ = v.Args[1] 5935 x := v.Args[0] 5936 v_1 := v.Args[1] 5937 if v_1.Op != OpARMMOVWconst { 5938 break 5939 } 5940 c := v_1.AuxInt 5941 v.reset(OpARMCMPconst) 5942 v.AuxInt = int64(int32(c) >> uint64(d)) 5943 v.AddArg(x) 5944 return true 5945 } 5946 return false 5947 } 5948 func rewriteValueARM_OpARMCMPshiftRAreg_0(v *Value) bool { 5949 b := v.Block 5950 _ = b 5951 // match: (CMPshiftRAreg (MOVWconst [c]) x y) 5952 // cond: 5953 // result: (InvertFlags (CMPconst [c] (SRA <x.Type> x y))) 5954 for { 5955 _ = v.Args[2] 5956 v_0 := v.Args[0] 5957 if v_0.Op != OpARMMOVWconst { 5958 break 5959 } 5960 c := v_0.AuxInt 5961 x := v.Args[1] 5962 y := v.Args[2] 5963 v.reset(OpARMInvertFlags) 5964 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 5965 v0.AuxInt = c 5966 v1 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 5967 v1.AddArg(x) 5968 v1.AddArg(y) 5969 v0.AddArg(v1) 5970 v.AddArg(v0) 5971 return true 5972 } 5973 // match: (CMPshiftRAreg x y (MOVWconst [c])) 5974 // cond: 5975 // result: (CMPshiftRA x y [c]) 5976 for { 5977 _ = v.Args[2] 5978 x := v.Args[0] 5979 y := v.Args[1] 5980 v_2 := v.Args[2] 5981 if v_2.Op != OpARMMOVWconst { 5982 break 5983 } 5984 c := v_2.AuxInt 5985 v.reset(OpARMCMPshiftRA) 5986 v.AuxInt = c 5987 v.AddArg(x) 5988 v.AddArg(y) 5989 return true 5990 } 5991 return false 5992 } 5993 func rewriteValueARM_OpARMCMPshiftRL_0(v *Value) bool { 5994 b := v.Block 5995 _ = b 5996 // match: (CMPshiftRL (MOVWconst [c]) x [d]) 5997 // cond: 5998 // result: (InvertFlags (CMPconst [c] (SRLconst <x.Type> x [d]))) 5999 for { 6000 d := v.AuxInt 6001 _ = v.Args[1] 6002 v_0 := v.Args[0] 6003 if v_0.Op != OpARMMOVWconst { 6004 break 6005 } 6006 c := v_0.AuxInt 6007 x := v.Args[1] 6008 v.reset(OpARMInvertFlags) 6009 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 6010 v0.AuxInt = c 6011 v1 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 6012 v1.AuxInt = d 6013 v1.AddArg(x) 6014 v0.AddArg(v1) 6015 v.AddArg(v0) 6016 return true 6017 } 6018 // match: (CMPshiftRL x (MOVWconst [c]) [d]) 6019 // cond: 6020 // result: (CMPconst x [int64(int32(uint32(c)>>uint64(d)))]) 6021 for { 6022 d := v.AuxInt 6023 _ = v.Args[1] 6024 x := v.Args[0] 6025 v_1 := v.Args[1] 6026 if v_1.Op != OpARMMOVWconst { 6027 break 6028 } 6029 c := v_1.AuxInt 6030 v.reset(OpARMCMPconst) 6031 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 6032 v.AddArg(x) 6033 return true 6034 } 6035 return false 6036 } 6037 func rewriteValueARM_OpARMCMPshiftRLreg_0(v *Value) bool { 6038 b := v.Block 6039 _ = b 6040 // match: (CMPshiftRLreg (MOVWconst [c]) x y) 6041 // cond: 6042 // result: (InvertFlags (CMPconst [c] (SRL <x.Type> x y))) 6043 for { 6044 _ = v.Args[2] 6045 v_0 := v.Args[0] 6046 if v_0.Op != OpARMMOVWconst { 6047 break 6048 } 6049 c := v_0.AuxInt 6050 x := v.Args[1] 6051 y := v.Args[2] 6052 v.reset(OpARMInvertFlags) 6053 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 6054 v0.AuxInt = c 6055 v1 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 6056 v1.AddArg(x) 6057 v1.AddArg(y) 6058 v0.AddArg(v1) 6059 v.AddArg(v0) 6060 return true 6061 } 6062 // match: (CMPshiftRLreg x y (MOVWconst [c])) 6063 // cond: 6064 // result: (CMPshiftRL x y [c]) 6065 for { 6066 _ = v.Args[2] 6067 x := v.Args[0] 6068 y := v.Args[1] 6069 v_2 := v.Args[2] 6070 if v_2.Op != OpARMMOVWconst { 6071 break 6072 } 6073 c := v_2.AuxInt 6074 v.reset(OpARMCMPshiftRL) 6075 v.AuxInt = c 6076 v.AddArg(x) 6077 v.AddArg(y) 6078 return true 6079 } 6080 return false 6081 } 6082 func rewriteValueARM_OpARMEqual_0(v *Value) bool { 6083 // match: (Equal (FlagEQ)) 6084 // cond: 6085 // result: (MOVWconst [1]) 6086 for { 6087 v_0 := v.Args[0] 6088 if v_0.Op != OpARMFlagEQ { 6089 break 6090 } 6091 v.reset(OpARMMOVWconst) 6092 v.AuxInt = 1 6093 return true 6094 } 6095 // match: (Equal (FlagLT_ULT)) 6096 // cond: 6097 // result: (MOVWconst [0]) 6098 for { 6099 v_0 := v.Args[0] 6100 if v_0.Op != OpARMFlagLT_ULT { 6101 break 6102 } 6103 v.reset(OpARMMOVWconst) 6104 v.AuxInt = 0 6105 return true 6106 } 6107 // match: (Equal (FlagLT_UGT)) 6108 // cond: 6109 // result: (MOVWconst [0]) 6110 for { 6111 v_0 := v.Args[0] 6112 if v_0.Op != OpARMFlagLT_UGT { 6113 break 6114 } 6115 v.reset(OpARMMOVWconst) 6116 v.AuxInt = 0 6117 return true 6118 } 6119 // match: (Equal (FlagGT_ULT)) 6120 // cond: 6121 // result: (MOVWconst [0]) 6122 for { 6123 v_0 := v.Args[0] 6124 if v_0.Op != OpARMFlagGT_ULT { 6125 break 6126 } 6127 v.reset(OpARMMOVWconst) 6128 v.AuxInt = 0 6129 return true 6130 } 6131 // match: (Equal (FlagGT_UGT)) 6132 // cond: 6133 // result: (MOVWconst [0]) 6134 for { 6135 v_0 := v.Args[0] 6136 if v_0.Op != OpARMFlagGT_UGT { 6137 break 6138 } 6139 v.reset(OpARMMOVWconst) 6140 v.AuxInt = 0 6141 return true 6142 } 6143 // match: (Equal (InvertFlags x)) 6144 // cond: 6145 // result: (Equal x) 6146 for { 6147 v_0 := v.Args[0] 6148 if v_0.Op != OpARMInvertFlags { 6149 break 6150 } 6151 x := v_0.Args[0] 6152 v.reset(OpARMEqual) 6153 v.AddArg(x) 6154 return true 6155 } 6156 return false 6157 } 6158 func rewriteValueARM_OpARMGreaterEqual_0(v *Value) bool { 6159 // match: (GreaterEqual (FlagEQ)) 6160 // cond: 6161 // result: (MOVWconst [1]) 6162 for { 6163 v_0 := v.Args[0] 6164 if v_0.Op != OpARMFlagEQ { 6165 break 6166 } 6167 v.reset(OpARMMOVWconst) 6168 v.AuxInt = 1 6169 return true 6170 } 6171 // match: (GreaterEqual (FlagLT_ULT)) 6172 // cond: 6173 // result: (MOVWconst [0]) 6174 for { 6175 v_0 := v.Args[0] 6176 if v_0.Op != OpARMFlagLT_ULT { 6177 break 6178 } 6179 v.reset(OpARMMOVWconst) 6180 v.AuxInt = 0 6181 return true 6182 } 6183 // match: (GreaterEqual (FlagLT_UGT)) 6184 // cond: 6185 // result: (MOVWconst [0]) 6186 for { 6187 v_0 := v.Args[0] 6188 if v_0.Op != OpARMFlagLT_UGT { 6189 break 6190 } 6191 v.reset(OpARMMOVWconst) 6192 v.AuxInt = 0 6193 return true 6194 } 6195 // match: (GreaterEqual (FlagGT_ULT)) 6196 // cond: 6197 // result: (MOVWconst [1]) 6198 for { 6199 v_0 := v.Args[0] 6200 if v_0.Op != OpARMFlagGT_ULT { 6201 break 6202 } 6203 v.reset(OpARMMOVWconst) 6204 v.AuxInt = 1 6205 return true 6206 } 6207 // match: (GreaterEqual (FlagGT_UGT)) 6208 // cond: 6209 // result: (MOVWconst [1]) 6210 for { 6211 v_0 := v.Args[0] 6212 if v_0.Op != OpARMFlagGT_UGT { 6213 break 6214 } 6215 v.reset(OpARMMOVWconst) 6216 v.AuxInt = 1 6217 return true 6218 } 6219 // match: (GreaterEqual (InvertFlags x)) 6220 // cond: 6221 // result: (LessEqual x) 6222 for { 6223 v_0 := v.Args[0] 6224 if v_0.Op != OpARMInvertFlags { 6225 break 6226 } 6227 x := v_0.Args[0] 6228 v.reset(OpARMLessEqual) 6229 v.AddArg(x) 6230 return true 6231 } 6232 return false 6233 } 6234 func rewriteValueARM_OpARMGreaterEqualU_0(v *Value) bool { 6235 // match: (GreaterEqualU (FlagEQ)) 6236 // cond: 6237 // result: (MOVWconst [1]) 6238 for { 6239 v_0 := v.Args[0] 6240 if v_0.Op != OpARMFlagEQ { 6241 break 6242 } 6243 v.reset(OpARMMOVWconst) 6244 v.AuxInt = 1 6245 return true 6246 } 6247 // match: (GreaterEqualU (FlagLT_ULT)) 6248 // cond: 6249 // result: (MOVWconst [0]) 6250 for { 6251 v_0 := v.Args[0] 6252 if v_0.Op != OpARMFlagLT_ULT { 6253 break 6254 } 6255 v.reset(OpARMMOVWconst) 6256 v.AuxInt = 0 6257 return true 6258 } 6259 // match: (GreaterEqualU (FlagLT_UGT)) 6260 // cond: 6261 // result: (MOVWconst [1]) 6262 for { 6263 v_0 := v.Args[0] 6264 if v_0.Op != OpARMFlagLT_UGT { 6265 break 6266 } 6267 v.reset(OpARMMOVWconst) 6268 v.AuxInt = 1 6269 return true 6270 } 6271 // match: (GreaterEqualU (FlagGT_ULT)) 6272 // cond: 6273 // result: (MOVWconst [0]) 6274 for { 6275 v_0 := v.Args[0] 6276 if v_0.Op != OpARMFlagGT_ULT { 6277 break 6278 } 6279 v.reset(OpARMMOVWconst) 6280 v.AuxInt = 0 6281 return true 6282 } 6283 // match: (GreaterEqualU (FlagGT_UGT)) 6284 // cond: 6285 // result: (MOVWconst [1]) 6286 for { 6287 v_0 := v.Args[0] 6288 if v_0.Op != OpARMFlagGT_UGT { 6289 break 6290 } 6291 v.reset(OpARMMOVWconst) 6292 v.AuxInt = 1 6293 return true 6294 } 6295 // match: (GreaterEqualU (InvertFlags x)) 6296 // cond: 6297 // result: (LessEqualU x) 6298 for { 6299 v_0 := v.Args[0] 6300 if v_0.Op != OpARMInvertFlags { 6301 break 6302 } 6303 x := v_0.Args[0] 6304 v.reset(OpARMLessEqualU) 6305 v.AddArg(x) 6306 return true 6307 } 6308 return false 6309 } 6310 func rewriteValueARM_OpARMGreaterThan_0(v *Value) bool { 6311 // match: (GreaterThan (FlagEQ)) 6312 // cond: 6313 // result: (MOVWconst [0]) 6314 for { 6315 v_0 := v.Args[0] 6316 if v_0.Op != OpARMFlagEQ { 6317 break 6318 } 6319 v.reset(OpARMMOVWconst) 6320 v.AuxInt = 0 6321 return true 6322 } 6323 // match: (GreaterThan (FlagLT_ULT)) 6324 // cond: 6325 // result: (MOVWconst [0]) 6326 for { 6327 v_0 := v.Args[0] 6328 if v_0.Op != OpARMFlagLT_ULT { 6329 break 6330 } 6331 v.reset(OpARMMOVWconst) 6332 v.AuxInt = 0 6333 return true 6334 } 6335 // match: (GreaterThan (FlagLT_UGT)) 6336 // cond: 6337 // result: (MOVWconst [0]) 6338 for { 6339 v_0 := v.Args[0] 6340 if v_0.Op != OpARMFlagLT_UGT { 6341 break 6342 } 6343 v.reset(OpARMMOVWconst) 6344 v.AuxInt = 0 6345 return true 6346 } 6347 // match: (GreaterThan (FlagGT_ULT)) 6348 // cond: 6349 // result: (MOVWconst [1]) 6350 for { 6351 v_0 := v.Args[0] 6352 if v_0.Op != OpARMFlagGT_ULT { 6353 break 6354 } 6355 v.reset(OpARMMOVWconst) 6356 v.AuxInt = 1 6357 return true 6358 } 6359 // match: (GreaterThan (FlagGT_UGT)) 6360 // cond: 6361 // result: (MOVWconst [1]) 6362 for { 6363 v_0 := v.Args[0] 6364 if v_0.Op != OpARMFlagGT_UGT { 6365 break 6366 } 6367 v.reset(OpARMMOVWconst) 6368 v.AuxInt = 1 6369 return true 6370 } 6371 // match: (GreaterThan (InvertFlags x)) 6372 // cond: 6373 // result: (LessThan x) 6374 for { 6375 v_0 := v.Args[0] 6376 if v_0.Op != OpARMInvertFlags { 6377 break 6378 } 6379 x := v_0.Args[0] 6380 v.reset(OpARMLessThan) 6381 v.AddArg(x) 6382 return true 6383 } 6384 return false 6385 } 6386 func rewriteValueARM_OpARMGreaterThanU_0(v *Value) bool { 6387 // match: (GreaterThanU (FlagEQ)) 6388 // cond: 6389 // result: (MOVWconst [0]) 6390 for { 6391 v_0 := v.Args[0] 6392 if v_0.Op != OpARMFlagEQ { 6393 break 6394 } 6395 v.reset(OpARMMOVWconst) 6396 v.AuxInt = 0 6397 return true 6398 } 6399 // match: (GreaterThanU (FlagLT_ULT)) 6400 // cond: 6401 // result: (MOVWconst [0]) 6402 for { 6403 v_0 := v.Args[0] 6404 if v_0.Op != OpARMFlagLT_ULT { 6405 break 6406 } 6407 v.reset(OpARMMOVWconst) 6408 v.AuxInt = 0 6409 return true 6410 } 6411 // match: (GreaterThanU (FlagLT_UGT)) 6412 // cond: 6413 // result: (MOVWconst [1]) 6414 for { 6415 v_0 := v.Args[0] 6416 if v_0.Op != OpARMFlagLT_UGT { 6417 break 6418 } 6419 v.reset(OpARMMOVWconst) 6420 v.AuxInt = 1 6421 return true 6422 } 6423 // match: (GreaterThanU (FlagGT_ULT)) 6424 // cond: 6425 // result: (MOVWconst [0]) 6426 for { 6427 v_0 := v.Args[0] 6428 if v_0.Op != OpARMFlagGT_ULT { 6429 break 6430 } 6431 v.reset(OpARMMOVWconst) 6432 v.AuxInt = 0 6433 return true 6434 } 6435 // match: (GreaterThanU (FlagGT_UGT)) 6436 // cond: 6437 // result: (MOVWconst [1]) 6438 for { 6439 v_0 := v.Args[0] 6440 if v_0.Op != OpARMFlagGT_UGT { 6441 break 6442 } 6443 v.reset(OpARMMOVWconst) 6444 v.AuxInt = 1 6445 return true 6446 } 6447 // match: (GreaterThanU (InvertFlags x)) 6448 // cond: 6449 // result: (LessThanU x) 6450 for { 6451 v_0 := v.Args[0] 6452 if v_0.Op != OpARMInvertFlags { 6453 break 6454 } 6455 x := v_0.Args[0] 6456 v.reset(OpARMLessThanU) 6457 v.AddArg(x) 6458 return true 6459 } 6460 return false 6461 } 6462 func rewriteValueARM_OpARMLessEqual_0(v *Value) bool { 6463 // match: (LessEqual (FlagEQ)) 6464 // cond: 6465 // result: (MOVWconst [1]) 6466 for { 6467 v_0 := v.Args[0] 6468 if v_0.Op != OpARMFlagEQ { 6469 break 6470 } 6471 v.reset(OpARMMOVWconst) 6472 v.AuxInt = 1 6473 return true 6474 } 6475 // match: (LessEqual (FlagLT_ULT)) 6476 // cond: 6477 // result: (MOVWconst [1]) 6478 for { 6479 v_0 := v.Args[0] 6480 if v_0.Op != OpARMFlagLT_ULT { 6481 break 6482 } 6483 v.reset(OpARMMOVWconst) 6484 v.AuxInt = 1 6485 return true 6486 } 6487 // match: (LessEqual (FlagLT_UGT)) 6488 // cond: 6489 // result: (MOVWconst [1]) 6490 for { 6491 v_0 := v.Args[0] 6492 if v_0.Op != OpARMFlagLT_UGT { 6493 break 6494 } 6495 v.reset(OpARMMOVWconst) 6496 v.AuxInt = 1 6497 return true 6498 } 6499 // match: (LessEqual (FlagGT_ULT)) 6500 // cond: 6501 // result: (MOVWconst [0]) 6502 for { 6503 v_0 := v.Args[0] 6504 if v_0.Op != OpARMFlagGT_ULT { 6505 break 6506 } 6507 v.reset(OpARMMOVWconst) 6508 v.AuxInt = 0 6509 return true 6510 } 6511 // match: (LessEqual (FlagGT_UGT)) 6512 // cond: 6513 // result: (MOVWconst [0]) 6514 for { 6515 v_0 := v.Args[0] 6516 if v_0.Op != OpARMFlagGT_UGT { 6517 break 6518 } 6519 v.reset(OpARMMOVWconst) 6520 v.AuxInt = 0 6521 return true 6522 } 6523 // match: (LessEqual (InvertFlags x)) 6524 // cond: 6525 // result: (GreaterEqual x) 6526 for { 6527 v_0 := v.Args[0] 6528 if v_0.Op != OpARMInvertFlags { 6529 break 6530 } 6531 x := v_0.Args[0] 6532 v.reset(OpARMGreaterEqual) 6533 v.AddArg(x) 6534 return true 6535 } 6536 return false 6537 } 6538 func rewriteValueARM_OpARMLessEqualU_0(v *Value) bool { 6539 // match: (LessEqualU (FlagEQ)) 6540 // cond: 6541 // result: (MOVWconst [1]) 6542 for { 6543 v_0 := v.Args[0] 6544 if v_0.Op != OpARMFlagEQ { 6545 break 6546 } 6547 v.reset(OpARMMOVWconst) 6548 v.AuxInt = 1 6549 return true 6550 } 6551 // match: (LessEqualU (FlagLT_ULT)) 6552 // cond: 6553 // result: (MOVWconst [1]) 6554 for { 6555 v_0 := v.Args[0] 6556 if v_0.Op != OpARMFlagLT_ULT { 6557 break 6558 } 6559 v.reset(OpARMMOVWconst) 6560 v.AuxInt = 1 6561 return true 6562 } 6563 // match: (LessEqualU (FlagLT_UGT)) 6564 // cond: 6565 // result: (MOVWconst [0]) 6566 for { 6567 v_0 := v.Args[0] 6568 if v_0.Op != OpARMFlagLT_UGT { 6569 break 6570 } 6571 v.reset(OpARMMOVWconst) 6572 v.AuxInt = 0 6573 return true 6574 } 6575 // match: (LessEqualU (FlagGT_ULT)) 6576 // cond: 6577 // result: (MOVWconst [1]) 6578 for { 6579 v_0 := v.Args[0] 6580 if v_0.Op != OpARMFlagGT_ULT { 6581 break 6582 } 6583 v.reset(OpARMMOVWconst) 6584 v.AuxInt = 1 6585 return true 6586 } 6587 // match: (LessEqualU (FlagGT_UGT)) 6588 // cond: 6589 // result: (MOVWconst [0]) 6590 for { 6591 v_0 := v.Args[0] 6592 if v_0.Op != OpARMFlagGT_UGT { 6593 break 6594 } 6595 v.reset(OpARMMOVWconst) 6596 v.AuxInt = 0 6597 return true 6598 } 6599 // match: (LessEqualU (InvertFlags x)) 6600 // cond: 6601 // result: (GreaterEqualU x) 6602 for { 6603 v_0 := v.Args[0] 6604 if v_0.Op != OpARMInvertFlags { 6605 break 6606 } 6607 x := v_0.Args[0] 6608 v.reset(OpARMGreaterEqualU) 6609 v.AddArg(x) 6610 return true 6611 } 6612 return false 6613 } 6614 func rewriteValueARM_OpARMLessThan_0(v *Value) bool { 6615 // match: (LessThan (FlagEQ)) 6616 // cond: 6617 // result: (MOVWconst [0]) 6618 for { 6619 v_0 := v.Args[0] 6620 if v_0.Op != OpARMFlagEQ { 6621 break 6622 } 6623 v.reset(OpARMMOVWconst) 6624 v.AuxInt = 0 6625 return true 6626 } 6627 // match: (LessThan (FlagLT_ULT)) 6628 // cond: 6629 // result: (MOVWconst [1]) 6630 for { 6631 v_0 := v.Args[0] 6632 if v_0.Op != OpARMFlagLT_ULT { 6633 break 6634 } 6635 v.reset(OpARMMOVWconst) 6636 v.AuxInt = 1 6637 return true 6638 } 6639 // match: (LessThan (FlagLT_UGT)) 6640 // cond: 6641 // result: (MOVWconst [1]) 6642 for { 6643 v_0 := v.Args[0] 6644 if v_0.Op != OpARMFlagLT_UGT { 6645 break 6646 } 6647 v.reset(OpARMMOVWconst) 6648 v.AuxInt = 1 6649 return true 6650 } 6651 // match: (LessThan (FlagGT_ULT)) 6652 // cond: 6653 // result: (MOVWconst [0]) 6654 for { 6655 v_0 := v.Args[0] 6656 if v_0.Op != OpARMFlagGT_ULT { 6657 break 6658 } 6659 v.reset(OpARMMOVWconst) 6660 v.AuxInt = 0 6661 return true 6662 } 6663 // match: (LessThan (FlagGT_UGT)) 6664 // cond: 6665 // result: (MOVWconst [0]) 6666 for { 6667 v_0 := v.Args[0] 6668 if v_0.Op != OpARMFlagGT_UGT { 6669 break 6670 } 6671 v.reset(OpARMMOVWconst) 6672 v.AuxInt = 0 6673 return true 6674 } 6675 // match: (LessThan (InvertFlags x)) 6676 // cond: 6677 // result: (GreaterThan x) 6678 for { 6679 v_0 := v.Args[0] 6680 if v_0.Op != OpARMInvertFlags { 6681 break 6682 } 6683 x := v_0.Args[0] 6684 v.reset(OpARMGreaterThan) 6685 v.AddArg(x) 6686 return true 6687 } 6688 return false 6689 } 6690 func rewriteValueARM_OpARMLessThanU_0(v *Value) bool { 6691 // match: (LessThanU (FlagEQ)) 6692 // cond: 6693 // result: (MOVWconst [0]) 6694 for { 6695 v_0 := v.Args[0] 6696 if v_0.Op != OpARMFlagEQ { 6697 break 6698 } 6699 v.reset(OpARMMOVWconst) 6700 v.AuxInt = 0 6701 return true 6702 } 6703 // match: (LessThanU (FlagLT_ULT)) 6704 // cond: 6705 // result: (MOVWconst [1]) 6706 for { 6707 v_0 := v.Args[0] 6708 if v_0.Op != OpARMFlagLT_ULT { 6709 break 6710 } 6711 v.reset(OpARMMOVWconst) 6712 v.AuxInt = 1 6713 return true 6714 } 6715 // match: (LessThanU (FlagLT_UGT)) 6716 // cond: 6717 // result: (MOVWconst [0]) 6718 for { 6719 v_0 := v.Args[0] 6720 if v_0.Op != OpARMFlagLT_UGT { 6721 break 6722 } 6723 v.reset(OpARMMOVWconst) 6724 v.AuxInt = 0 6725 return true 6726 } 6727 // match: (LessThanU (FlagGT_ULT)) 6728 // cond: 6729 // result: (MOVWconst [1]) 6730 for { 6731 v_0 := v.Args[0] 6732 if v_0.Op != OpARMFlagGT_ULT { 6733 break 6734 } 6735 v.reset(OpARMMOVWconst) 6736 v.AuxInt = 1 6737 return true 6738 } 6739 // match: (LessThanU (FlagGT_UGT)) 6740 // cond: 6741 // result: (MOVWconst [0]) 6742 for { 6743 v_0 := v.Args[0] 6744 if v_0.Op != OpARMFlagGT_UGT { 6745 break 6746 } 6747 v.reset(OpARMMOVWconst) 6748 v.AuxInt = 0 6749 return true 6750 } 6751 // match: (LessThanU (InvertFlags x)) 6752 // cond: 6753 // result: (GreaterThanU x) 6754 for { 6755 v_0 := v.Args[0] 6756 if v_0.Op != OpARMInvertFlags { 6757 break 6758 } 6759 x := v_0.Args[0] 6760 v.reset(OpARMGreaterThanU) 6761 v.AddArg(x) 6762 return true 6763 } 6764 return false 6765 } 6766 func rewriteValueARM_OpARMMOVBUload_0(v *Value) bool { 6767 b := v.Block 6768 _ = b 6769 config := b.Func.Config 6770 _ = config 6771 // match: (MOVBUload [off1] {sym} (ADDconst [off2] ptr) mem) 6772 // cond: 6773 // result: (MOVBUload [off1+off2] {sym} ptr mem) 6774 for { 6775 off1 := v.AuxInt 6776 sym := v.Aux 6777 _ = v.Args[1] 6778 v_0 := v.Args[0] 6779 if v_0.Op != OpARMADDconst { 6780 break 6781 } 6782 off2 := v_0.AuxInt 6783 ptr := v_0.Args[0] 6784 mem := v.Args[1] 6785 v.reset(OpARMMOVBUload) 6786 v.AuxInt = off1 + off2 6787 v.Aux = sym 6788 v.AddArg(ptr) 6789 v.AddArg(mem) 6790 return true 6791 } 6792 // match: (MOVBUload [off1] {sym} (SUBconst [off2] ptr) mem) 6793 // cond: 6794 // result: (MOVBUload [off1-off2] {sym} ptr mem) 6795 for { 6796 off1 := v.AuxInt 6797 sym := v.Aux 6798 _ = v.Args[1] 6799 v_0 := v.Args[0] 6800 if v_0.Op != OpARMSUBconst { 6801 break 6802 } 6803 off2 := v_0.AuxInt 6804 ptr := v_0.Args[0] 6805 mem := v.Args[1] 6806 v.reset(OpARMMOVBUload) 6807 v.AuxInt = off1 - off2 6808 v.Aux = sym 6809 v.AddArg(ptr) 6810 v.AddArg(mem) 6811 return true 6812 } 6813 // match: (MOVBUload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 6814 // cond: canMergeSym(sym1,sym2) 6815 // result: (MOVBUload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 6816 for { 6817 off1 := v.AuxInt 6818 sym1 := v.Aux 6819 _ = v.Args[1] 6820 v_0 := v.Args[0] 6821 if v_0.Op != OpARMMOVWaddr { 6822 break 6823 } 6824 off2 := v_0.AuxInt 6825 sym2 := v_0.Aux 6826 ptr := v_0.Args[0] 6827 mem := v.Args[1] 6828 if !(canMergeSym(sym1, sym2)) { 6829 break 6830 } 6831 v.reset(OpARMMOVBUload) 6832 v.AuxInt = off1 + off2 6833 v.Aux = mergeSym(sym1, sym2) 6834 v.AddArg(ptr) 6835 v.AddArg(mem) 6836 return true 6837 } 6838 // match: (MOVBUload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _)) 6839 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 6840 // result: (MOVBUreg x) 6841 for { 6842 off := v.AuxInt 6843 sym := v.Aux 6844 _ = v.Args[1] 6845 ptr := v.Args[0] 6846 v_1 := v.Args[1] 6847 if v_1.Op != OpARMMOVBstore { 6848 break 6849 } 6850 off2 := v_1.AuxInt 6851 sym2 := v_1.Aux 6852 _ = v_1.Args[2] 6853 ptr2 := v_1.Args[0] 6854 x := v_1.Args[1] 6855 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 6856 break 6857 } 6858 v.reset(OpARMMOVBUreg) 6859 v.AddArg(x) 6860 return true 6861 } 6862 // match: (MOVBUload [0] {sym} (ADD ptr idx) mem) 6863 // cond: sym == nil && !config.nacl 6864 // result: (MOVBUloadidx ptr idx mem) 6865 for { 6866 if v.AuxInt != 0 { 6867 break 6868 } 6869 sym := v.Aux 6870 _ = v.Args[1] 6871 v_0 := v.Args[0] 6872 if v_0.Op != OpARMADD { 6873 break 6874 } 6875 _ = v_0.Args[1] 6876 ptr := v_0.Args[0] 6877 idx := v_0.Args[1] 6878 mem := v.Args[1] 6879 if !(sym == nil && !config.nacl) { 6880 break 6881 } 6882 v.reset(OpARMMOVBUloadidx) 6883 v.AddArg(ptr) 6884 v.AddArg(idx) 6885 v.AddArg(mem) 6886 return true 6887 } 6888 // match: (MOVBUload [off] {sym} (SB) _) 6889 // cond: symIsRO(sym) 6890 // result: (MOVWconst [int64(read8(sym, off))]) 6891 for { 6892 off := v.AuxInt 6893 sym := v.Aux 6894 _ = v.Args[1] 6895 v_0 := v.Args[0] 6896 if v_0.Op != OpSB { 6897 break 6898 } 6899 if !(symIsRO(sym)) { 6900 break 6901 } 6902 v.reset(OpARMMOVWconst) 6903 v.AuxInt = int64(read8(sym, off)) 6904 return true 6905 } 6906 return false 6907 } 6908 func rewriteValueARM_OpARMMOVBUloadidx_0(v *Value) bool { 6909 // match: (MOVBUloadidx ptr idx (MOVBstoreidx ptr2 idx x _)) 6910 // cond: isSamePtr(ptr, ptr2) 6911 // result: (MOVBUreg x) 6912 for { 6913 _ = v.Args[2] 6914 ptr := v.Args[0] 6915 idx := v.Args[1] 6916 v_2 := v.Args[2] 6917 if v_2.Op != OpARMMOVBstoreidx { 6918 break 6919 } 6920 _ = v_2.Args[3] 6921 ptr2 := v_2.Args[0] 6922 if idx != v_2.Args[1] { 6923 break 6924 } 6925 x := v_2.Args[2] 6926 if !(isSamePtr(ptr, ptr2)) { 6927 break 6928 } 6929 v.reset(OpARMMOVBUreg) 6930 v.AddArg(x) 6931 return true 6932 } 6933 // match: (MOVBUloadidx ptr (MOVWconst [c]) mem) 6934 // cond: 6935 // result: (MOVBUload [c] ptr mem) 6936 for { 6937 _ = v.Args[2] 6938 ptr := v.Args[0] 6939 v_1 := v.Args[1] 6940 if v_1.Op != OpARMMOVWconst { 6941 break 6942 } 6943 c := v_1.AuxInt 6944 mem := v.Args[2] 6945 v.reset(OpARMMOVBUload) 6946 v.AuxInt = c 6947 v.AddArg(ptr) 6948 v.AddArg(mem) 6949 return true 6950 } 6951 // match: (MOVBUloadidx (MOVWconst [c]) ptr mem) 6952 // cond: 6953 // result: (MOVBUload [c] ptr mem) 6954 for { 6955 _ = v.Args[2] 6956 v_0 := v.Args[0] 6957 if v_0.Op != OpARMMOVWconst { 6958 break 6959 } 6960 c := v_0.AuxInt 6961 ptr := v.Args[1] 6962 mem := v.Args[2] 6963 v.reset(OpARMMOVBUload) 6964 v.AuxInt = c 6965 v.AddArg(ptr) 6966 v.AddArg(mem) 6967 return true 6968 } 6969 return false 6970 } 6971 func rewriteValueARM_OpARMMOVBUreg_0(v *Value) bool { 6972 // match: (MOVBUreg x:(MOVBUload _ _)) 6973 // cond: 6974 // result: (MOVWreg x) 6975 for { 6976 x := v.Args[0] 6977 if x.Op != OpARMMOVBUload { 6978 break 6979 } 6980 _ = x.Args[1] 6981 v.reset(OpARMMOVWreg) 6982 v.AddArg(x) 6983 return true 6984 } 6985 // match: (MOVBUreg (ANDconst [c] x)) 6986 // cond: 6987 // result: (ANDconst [c&0xff] x) 6988 for { 6989 v_0 := v.Args[0] 6990 if v_0.Op != OpARMANDconst { 6991 break 6992 } 6993 c := v_0.AuxInt 6994 x := v_0.Args[0] 6995 v.reset(OpARMANDconst) 6996 v.AuxInt = c & 0xff 6997 v.AddArg(x) 6998 return true 6999 } 7000 // match: (MOVBUreg x:(MOVBUreg _)) 7001 // cond: 7002 // result: (MOVWreg x) 7003 for { 7004 x := v.Args[0] 7005 if x.Op != OpARMMOVBUreg { 7006 break 7007 } 7008 v.reset(OpARMMOVWreg) 7009 v.AddArg(x) 7010 return true 7011 } 7012 // match: (MOVBUreg (MOVWconst [c])) 7013 // cond: 7014 // result: (MOVWconst [int64(uint8(c))]) 7015 for { 7016 v_0 := v.Args[0] 7017 if v_0.Op != OpARMMOVWconst { 7018 break 7019 } 7020 c := v_0.AuxInt 7021 v.reset(OpARMMOVWconst) 7022 v.AuxInt = int64(uint8(c)) 7023 return true 7024 } 7025 return false 7026 } 7027 func rewriteValueARM_OpARMMOVBload_0(v *Value) bool { 7028 b := v.Block 7029 _ = b 7030 config := b.Func.Config 7031 _ = config 7032 // match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem) 7033 // cond: 7034 // result: (MOVBload [off1+off2] {sym} ptr mem) 7035 for { 7036 off1 := v.AuxInt 7037 sym := v.Aux 7038 _ = v.Args[1] 7039 v_0 := v.Args[0] 7040 if v_0.Op != OpARMADDconst { 7041 break 7042 } 7043 off2 := v_0.AuxInt 7044 ptr := v_0.Args[0] 7045 mem := v.Args[1] 7046 v.reset(OpARMMOVBload) 7047 v.AuxInt = off1 + off2 7048 v.Aux = sym 7049 v.AddArg(ptr) 7050 v.AddArg(mem) 7051 return true 7052 } 7053 // match: (MOVBload [off1] {sym} (SUBconst [off2] ptr) mem) 7054 // cond: 7055 // result: (MOVBload [off1-off2] {sym} ptr mem) 7056 for { 7057 off1 := v.AuxInt 7058 sym := v.Aux 7059 _ = v.Args[1] 7060 v_0 := v.Args[0] 7061 if v_0.Op != OpARMSUBconst { 7062 break 7063 } 7064 off2 := v_0.AuxInt 7065 ptr := v_0.Args[0] 7066 mem := v.Args[1] 7067 v.reset(OpARMMOVBload) 7068 v.AuxInt = off1 - off2 7069 v.Aux = sym 7070 v.AddArg(ptr) 7071 v.AddArg(mem) 7072 return true 7073 } 7074 // match: (MOVBload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 7075 // cond: canMergeSym(sym1,sym2) 7076 // result: (MOVBload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 7077 for { 7078 off1 := v.AuxInt 7079 sym1 := v.Aux 7080 _ = v.Args[1] 7081 v_0 := v.Args[0] 7082 if v_0.Op != OpARMMOVWaddr { 7083 break 7084 } 7085 off2 := v_0.AuxInt 7086 sym2 := v_0.Aux 7087 ptr := v_0.Args[0] 7088 mem := v.Args[1] 7089 if !(canMergeSym(sym1, sym2)) { 7090 break 7091 } 7092 v.reset(OpARMMOVBload) 7093 v.AuxInt = off1 + off2 7094 v.Aux = mergeSym(sym1, sym2) 7095 v.AddArg(ptr) 7096 v.AddArg(mem) 7097 return true 7098 } 7099 // match: (MOVBload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _)) 7100 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 7101 // result: (MOVBreg x) 7102 for { 7103 off := v.AuxInt 7104 sym := v.Aux 7105 _ = v.Args[1] 7106 ptr := v.Args[0] 7107 v_1 := v.Args[1] 7108 if v_1.Op != OpARMMOVBstore { 7109 break 7110 } 7111 off2 := v_1.AuxInt 7112 sym2 := v_1.Aux 7113 _ = v_1.Args[2] 7114 ptr2 := v_1.Args[0] 7115 x := v_1.Args[1] 7116 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 7117 break 7118 } 7119 v.reset(OpARMMOVBreg) 7120 v.AddArg(x) 7121 return true 7122 } 7123 // match: (MOVBload [0] {sym} (ADD ptr idx) mem) 7124 // cond: sym == nil && !config.nacl 7125 // result: (MOVBloadidx ptr idx mem) 7126 for { 7127 if v.AuxInt != 0 { 7128 break 7129 } 7130 sym := v.Aux 7131 _ = v.Args[1] 7132 v_0 := v.Args[0] 7133 if v_0.Op != OpARMADD { 7134 break 7135 } 7136 _ = v_0.Args[1] 7137 ptr := v_0.Args[0] 7138 idx := v_0.Args[1] 7139 mem := v.Args[1] 7140 if !(sym == nil && !config.nacl) { 7141 break 7142 } 7143 v.reset(OpARMMOVBloadidx) 7144 v.AddArg(ptr) 7145 v.AddArg(idx) 7146 v.AddArg(mem) 7147 return true 7148 } 7149 return false 7150 } 7151 func rewriteValueARM_OpARMMOVBloadidx_0(v *Value) bool { 7152 // match: (MOVBloadidx ptr idx (MOVBstoreidx ptr2 idx x _)) 7153 // cond: isSamePtr(ptr, ptr2) 7154 // result: (MOVBreg x) 7155 for { 7156 _ = v.Args[2] 7157 ptr := v.Args[0] 7158 idx := v.Args[1] 7159 v_2 := v.Args[2] 7160 if v_2.Op != OpARMMOVBstoreidx { 7161 break 7162 } 7163 _ = v_2.Args[3] 7164 ptr2 := v_2.Args[0] 7165 if idx != v_2.Args[1] { 7166 break 7167 } 7168 x := v_2.Args[2] 7169 if !(isSamePtr(ptr, ptr2)) { 7170 break 7171 } 7172 v.reset(OpARMMOVBreg) 7173 v.AddArg(x) 7174 return true 7175 } 7176 // match: (MOVBloadidx ptr (MOVWconst [c]) mem) 7177 // cond: 7178 // result: (MOVBload [c] ptr mem) 7179 for { 7180 _ = v.Args[2] 7181 ptr := v.Args[0] 7182 v_1 := v.Args[1] 7183 if v_1.Op != OpARMMOVWconst { 7184 break 7185 } 7186 c := v_1.AuxInt 7187 mem := v.Args[2] 7188 v.reset(OpARMMOVBload) 7189 v.AuxInt = c 7190 v.AddArg(ptr) 7191 v.AddArg(mem) 7192 return true 7193 } 7194 // match: (MOVBloadidx (MOVWconst [c]) ptr mem) 7195 // cond: 7196 // result: (MOVBload [c] ptr mem) 7197 for { 7198 _ = v.Args[2] 7199 v_0 := v.Args[0] 7200 if v_0.Op != OpARMMOVWconst { 7201 break 7202 } 7203 c := v_0.AuxInt 7204 ptr := v.Args[1] 7205 mem := v.Args[2] 7206 v.reset(OpARMMOVBload) 7207 v.AuxInt = c 7208 v.AddArg(ptr) 7209 v.AddArg(mem) 7210 return true 7211 } 7212 return false 7213 } 7214 func rewriteValueARM_OpARMMOVBreg_0(v *Value) bool { 7215 // match: (MOVBreg x:(MOVBload _ _)) 7216 // cond: 7217 // result: (MOVWreg x) 7218 for { 7219 x := v.Args[0] 7220 if x.Op != OpARMMOVBload { 7221 break 7222 } 7223 _ = x.Args[1] 7224 v.reset(OpARMMOVWreg) 7225 v.AddArg(x) 7226 return true 7227 } 7228 // match: (MOVBreg (ANDconst [c] x)) 7229 // cond: c & 0x80 == 0 7230 // result: (ANDconst [c&0x7f] x) 7231 for { 7232 v_0 := v.Args[0] 7233 if v_0.Op != OpARMANDconst { 7234 break 7235 } 7236 c := v_0.AuxInt 7237 x := v_0.Args[0] 7238 if !(c&0x80 == 0) { 7239 break 7240 } 7241 v.reset(OpARMANDconst) 7242 v.AuxInt = c & 0x7f 7243 v.AddArg(x) 7244 return true 7245 } 7246 // match: (MOVBreg x:(MOVBreg _)) 7247 // cond: 7248 // result: (MOVWreg x) 7249 for { 7250 x := v.Args[0] 7251 if x.Op != OpARMMOVBreg { 7252 break 7253 } 7254 v.reset(OpARMMOVWreg) 7255 v.AddArg(x) 7256 return true 7257 } 7258 // match: (MOVBreg (MOVWconst [c])) 7259 // cond: 7260 // result: (MOVWconst [int64(int8(c))]) 7261 for { 7262 v_0 := v.Args[0] 7263 if v_0.Op != OpARMMOVWconst { 7264 break 7265 } 7266 c := v_0.AuxInt 7267 v.reset(OpARMMOVWconst) 7268 v.AuxInt = int64(int8(c)) 7269 return true 7270 } 7271 return false 7272 } 7273 func rewriteValueARM_OpARMMOVBstore_0(v *Value) bool { 7274 b := v.Block 7275 _ = b 7276 config := b.Func.Config 7277 _ = config 7278 // match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem) 7279 // cond: 7280 // result: (MOVBstore [off1+off2] {sym} ptr val mem) 7281 for { 7282 off1 := v.AuxInt 7283 sym := v.Aux 7284 _ = v.Args[2] 7285 v_0 := v.Args[0] 7286 if v_0.Op != OpARMADDconst { 7287 break 7288 } 7289 off2 := v_0.AuxInt 7290 ptr := v_0.Args[0] 7291 val := v.Args[1] 7292 mem := v.Args[2] 7293 v.reset(OpARMMOVBstore) 7294 v.AuxInt = off1 + off2 7295 v.Aux = sym 7296 v.AddArg(ptr) 7297 v.AddArg(val) 7298 v.AddArg(mem) 7299 return true 7300 } 7301 // match: (MOVBstore [off1] {sym} (SUBconst [off2] ptr) val mem) 7302 // cond: 7303 // result: (MOVBstore [off1-off2] {sym} ptr val mem) 7304 for { 7305 off1 := v.AuxInt 7306 sym := v.Aux 7307 _ = v.Args[2] 7308 v_0 := v.Args[0] 7309 if v_0.Op != OpARMSUBconst { 7310 break 7311 } 7312 off2 := v_0.AuxInt 7313 ptr := v_0.Args[0] 7314 val := v.Args[1] 7315 mem := v.Args[2] 7316 v.reset(OpARMMOVBstore) 7317 v.AuxInt = off1 - off2 7318 v.Aux = sym 7319 v.AddArg(ptr) 7320 v.AddArg(val) 7321 v.AddArg(mem) 7322 return true 7323 } 7324 // match: (MOVBstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem) 7325 // cond: canMergeSym(sym1,sym2) 7326 // result: (MOVBstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem) 7327 for { 7328 off1 := v.AuxInt 7329 sym1 := v.Aux 7330 _ = v.Args[2] 7331 v_0 := v.Args[0] 7332 if v_0.Op != OpARMMOVWaddr { 7333 break 7334 } 7335 off2 := v_0.AuxInt 7336 sym2 := v_0.Aux 7337 ptr := v_0.Args[0] 7338 val := v.Args[1] 7339 mem := v.Args[2] 7340 if !(canMergeSym(sym1, sym2)) { 7341 break 7342 } 7343 v.reset(OpARMMOVBstore) 7344 v.AuxInt = off1 + off2 7345 v.Aux = mergeSym(sym1, sym2) 7346 v.AddArg(ptr) 7347 v.AddArg(val) 7348 v.AddArg(mem) 7349 return true 7350 } 7351 // match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem) 7352 // cond: 7353 // result: (MOVBstore [off] {sym} ptr x mem) 7354 for { 7355 off := v.AuxInt 7356 sym := v.Aux 7357 _ = v.Args[2] 7358 ptr := v.Args[0] 7359 v_1 := v.Args[1] 7360 if v_1.Op != OpARMMOVBreg { 7361 break 7362 } 7363 x := v_1.Args[0] 7364 mem := v.Args[2] 7365 v.reset(OpARMMOVBstore) 7366 v.AuxInt = off 7367 v.Aux = sym 7368 v.AddArg(ptr) 7369 v.AddArg(x) 7370 v.AddArg(mem) 7371 return true 7372 } 7373 // match: (MOVBstore [off] {sym} ptr (MOVBUreg x) mem) 7374 // cond: 7375 // result: (MOVBstore [off] {sym} ptr x mem) 7376 for { 7377 off := v.AuxInt 7378 sym := v.Aux 7379 _ = v.Args[2] 7380 ptr := v.Args[0] 7381 v_1 := v.Args[1] 7382 if v_1.Op != OpARMMOVBUreg { 7383 break 7384 } 7385 x := v_1.Args[0] 7386 mem := v.Args[2] 7387 v.reset(OpARMMOVBstore) 7388 v.AuxInt = off 7389 v.Aux = sym 7390 v.AddArg(ptr) 7391 v.AddArg(x) 7392 v.AddArg(mem) 7393 return true 7394 } 7395 // match: (MOVBstore [off] {sym} ptr (MOVHreg x) mem) 7396 // cond: 7397 // result: (MOVBstore [off] {sym} ptr x mem) 7398 for { 7399 off := v.AuxInt 7400 sym := v.Aux 7401 _ = v.Args[2] 7402 ptr := v.Args[0] 7403 v_1 := v.Args[1] 7404 if v_1.Op != OpARMMOVHreg { 7405 break 7406 } 7407 x := v_1.Args[0] 7408 mem := v.Args[2] 7409 v.reset(OpARMMOVBstore) 7410 v.AuxInt = off 7411 v.Aux = sym 7412 v.AddArg(ptr) 7413 v.AddArg(x) 7414 v.AddArg(mem) 7415 return true 7416 } 7417 // match: (MOVBstore [off] {sym} ptr (MOVHUreg x) mem) 7418 // cond: 7419 // result: (MOVBstore [off] {sym} ptr x mem) 7420 for { 7421 off := v.AuxInt 7422 sym := v.Aux 7423 _ = v.Args[2] 7424 ptr := v.Args[0] 7425 v_1 := v.Args[1] 7426 if v_1.Op != OpARMMOVHUreg { 7427 break 7428 } 7429 x := v_1.Args[0] 7430 mem := v.Args[2] 7431 v.reset(OpARMMOVBstore) 7432 v.AuxInt = off 7433 v.Aux = sym 7434 v.AddArg(ptr) 7435 v.AddArg(x) 7436 v.AddArg(mem) 7437 return true 7438 } 7439 // match: (MOVBstore [0] {sym} (ADD ptr idx) val mem) 7440 // cond: sym == nil && !config.nacl 7441 // result: (MOVBstoreidx ptr idx val mem) 7442 for { 7443 if v.AuxInt != 0 { 7444 break 7445 } 7446 sym := v.Aux 7447 _ = v.Args[2] 7448 v_0 := v.Args[0] 7449 if v_0.Op != OpARMADD { 7450 break 7451 } 7452 _ = v_0.Args[1] 7453 ptr := v_0.Args[0] 7454 idx := v_0.Args[1] 7455 val := v.Args[1] 7456 mem := v.Args[2] 7457 if !(sym == nil && !config.nacl) { 7458 break 7459 } 7460 v.reset(OpARMMOVBstoreidx) 7461 v.AddArg(ptr) 7462 v.AddArg(idx) 7463 v.AddArg(val) 7464 v.AddArg(mem) 7465 return true 7466 } 7467 return false 7468 } 7469 func rewriteValueARM_OpARMMOVBstoreidx_0(v *Value) bool { 7470 // match: (MOVBstoreidx ptr (MOVWconst [c]) val mem) 7471 // cond: 7472 // result: (MOVBstore [c] ptr val mem) 7473 for { 7474 _ = v.Args[3] 7475 ptr := v.Args[0] 7476 v_1 := v.Args[1] 7477 if v_1.Op != OpARMMOVWconst { 7478 break 7479 } 7480 c := v_1.AuxInt 7481 val := v.Args[2] 7482 mem := v.Args[3] 7483 v.reset(OpARMMOVBstore) 7484 v.AuxInt = c 7485 v.AddArg(ptr) 7486 v.AddArg(val) 7487 v.AddArg(mem) 7488 return true 7489 } 7490 // match: (MOVBstoreidx (MOVWconst [c]) ptr val mem) 7491 // cond: 7492 // result: (MOVBstore [c] ptr val mem) 7493 for { 7494 _ = v.Args[3] 7495 v_0 := v.Args[0] 7496 if v_0.Op != OpARMMOVWconst { 7497 break 7498 } 7499 c := v_0.AuxInt 7500 ptr := v.Args[1] 7501 val := v.Args[2] 7502 mem := v.Args[3] 7503 v.reset(OpARMMOVBstore) 7504 v.AuxInt = c 7505 v.AddArg(ptr) 7506 v.AddArg(val) 7507 v.AddArg(mem) 7508 return true 7509 } 7510 return false 7511 } 7512 func rewriteValueARM_OpARMMOVDload_0(v *Value) bool { 7513 // match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem) 7514 // cond: 7515 // result: (MOVDload [off1+off2] {sym} ptr mem) 7516 for { 7517 off1 := v.AuxInt 7518 sym := v.Aux 7519 _ = v.Args[1] 7520 v_0 := v.Args[0] 7521 if v_0.Op != OpARMADDconst { 7522 break 7523 } 7524 off2 := v_0.AuxInt 7525 ptr := v_0.Args[0] 7526 mem := v.Args[1] 7527 v.reset(OpARMMOVDload) 7528 v.AuxInt = off1 + off2 7529 v.Aux = sym 7530 v.AddArg(ptr) 7531 v.AddArg(mem) 7532 return true 7533 } 7534 // match: (MOVDload [off1] {sym} (SUBconst [off2] ptr) mem) 7535 // cond: 7536 // result: (MOVDload [off1-off2] {sym} ptr mem) 7537 for { 7538 off1 := v.AuxInt 7539 sym := v.Aux 7540 _ = v.Args[1] 7541 v_0 := v.Args[0] 7542 if v_0.Op != OpARMSUBconst { 7543 break 7544 } 7545 off2 := v_0.AuxInt 7546 ptr := v_0.Args[0] 7547 mem := v.Args[1] 7548 v.reset(OpARMMOVDload) 7549 v.AuxInt = off1 - off2 7550 v.Aux = sym 7551 v.AddArg(ptr) 7552 v.AddArg(mem) 7553 return true 7554 } 7555 // match: (MOVDload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 7556 // cond: canMergeSym(sym1,sym2) 7557 // result: (MOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 7558 for { 7559 off1 := v.AuxInt 7560 sym1 := v.Aux 7561 _ = v.Args[1] 7562 v_0 := v.Args[0] 7563 if v_0.Op != OpARMMOVWaddr { 7564 break 7565 } 7566 off2 := v_0.AuxInt 7567 sym2 := v_0.Aux 7568 ptr := v_0.Args[0] 7569 mem := v.Args[1] 7570 if !(canMergeSym(sym1, sym2)) { 7571 break 7572 } 7573 v.reset(OpARMMOVDload) 7574 v.AuxInt = off1 + off2 7575 v.Aux = mergeSym(sym1, sym2) 7576 v.AddArg(ptr) 7577 v.AddArg(mem) 7578 return true 7579 } 7580 // match: (MOVDload [off] {sym} ptr (MOVDstore [off2] {sym2} ptr2 x _)) 7581 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 7582 // result: x 7583 for { 7584 off := v.AuxInt 7585 sym := v.Aux 7586 _ = v.Args[1] 7587 ptr := v.Args[0] 7588 v_1 := v.Args[1] 7589 if v_1.Op != OpARMMOVDstore { 7590 break 7591 } 7592 off2 := v_1.AuxInt 7593 sym2 := v_1.Aux 7594 _ = v_1.Args[2] 7595 ptr2 := v_1.Args[0] 7596 x := v_1.Args[1] 7597 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 7598 break 7599 } 7600 v.reset(OpCopy) 7601 v.Type = x.Type 7602 v.AddArg(x) 7603 return true 7604 } 7605 return false 7606 } 7607 func rewriteValueARM_OpARMMOVDstore_0(v *Value) bool { 7608 // match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem) 7609 // cond: 7610 // result: (MOVDstore [off1+off2] {sym} ptr val mem) 7611 for { 7612 off1 := v.AuxInt 7613 sym := v.Aux 7614 _ = v.Args[2] 7615 v_0 := v.Args[0] 7616 if v_0.Op != OpARMADDconst { 7617 break 7618 } 7619 off2 := v_0.AuxInt 7620 ptr := v_0.Args[0] 7621 val := v.Args[1] 7622 mem := v.Args[2] 7623 v.reset(OpARMMOVDstore) 7624 v.AuxInt = off1 + off2 7625 v.Aux = sym 7626 v.AddArg(ptr) 7627 v.AddArg(val) 7628 v.AddArg(mem) 7629 return true 7630 } 7631 // match: (MOVDstore [off1] {sym} (SUBconst [off2] ptr) val mem) 7632 // cond: 7633 // result: (MOVDstore [off1-off2] {sym} ptr val mem) 7634 for { 7635 off1 := v.AuxInt 7636 sym := v.Aux 7637 _ = v.Args[2] 7638 v_0 := v.Args[0] 7639 if v_0.Op != OpARMSUBconst { 7640 break 7641 } 7642 off2 := v_0.AuxInt 7643 ptr := v_0.Args[0] 7644 val := v.Args[1] 7645 mem := v.Args[2] 7646 v.reset(OpARMMOVDstore) 7647 v.AuxInt = off1 - off2 7648 v.Aux = sym 7649 v.AddArg(ptr) 7650 v.AddArg(val) 7651 v.AddArg(mem) 7652 return true 7653 } 7654 // match: (MOVDstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem) 7655 // cond: canMergeSym(sym1,sym2) 7656 // result: (MOVDstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem) 7657 for { 7658 off1 := v.AuxInt 7659 sym1 := v.Aux 7660 _ = v.Args[2] 7661 v_0 := v.Args[0] 7662 if v_0.Op != OpARMMOVWaddr { 7663 break 7664 } 7665 off2 := v_0.AuxInt 7666 sym2 := v_0.Aux 7667 ptr := v_0.Args[0] 7668 val := v.Args[1] 7669 mem := v.Args[2] 7670 if !(canMergeSym(sym1, sym2)) { 7671 break 7672 } 7673 v.reset(OpARMMOVDstore) 7674 v.AuxInt = off1 + off2 7675 v.Aux = mergeSym(sym1, sym2) 7676 v.AddArg(ptr) 7677 v.AddArg(val) 7678 v.AddArg(mem) 7679 return true 7680 } 7681 return false 7682 } 7683 func rewriteValueARM_OpARMMOVFload_0(v *Value) bool { 7684 // match: (MOVFload [off1] {sym} (ADDconst [off2] ptr) mem) 7685 // cond: 7686 // result: (MOVFload [off1+off2] {sym} ptr mem) 7687 for { 7688 off1 := v.AuxInt 7689 sym := v.Aux 7690 _ = v.Args[1] 7691 v_0 := v.Args[0] 7692 if v_0.Op != OpARMADDconst { 7693 break 7694 } 7695 off2 := v_0.AuxInt 7696 ptr := v_0.Args[0] 7697 mem := v.Args[1] 7698 v.reset(OpARMMOVFload) 7699 v.AuxInt = off1 + off2 7700 v.Aux = sym 7701 v.AddArg(ptr) 7702 v.AddArg(mem) 7703 return true 7704 } 7705 // match: (MOVFload [off1] {sym} (SUBconst [off2] ptr) mem) 7706 // cond: 7707 // result: (MOVFload [off1-off2] {sym} ptr mem) 7708 for { 7709 off1 := v.AuxInt 7710 sym := v.Aux 7711 _ = v.Args[1] 7712 v_0 := v.Args[0] 7713 if v_0.Op != OpARMSUBconst { 7714 break 7715 } 7716 off2 := v_0.AuxInt 7717 ptr := v_0.Args[0] 7718 mem := v.Args[1] 7719 v.reset(OpARMMOVFload) 7720 v.AuxInt = off1 - off2 7721 v.Aux = sym 7722 v.AddArg(ptr) 7723 v.AddArg(mem) 7724 return true 7725 } 7726 // match: (MOVFload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 7727 // cond: canMergeSym(sym1,sym2) 7728 // result: (MOVFload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 7729 for { 7730 off1 := v.AuxInt 7731 sym1 := v.Aux 7732 _ = v.Args[1] 7733 v_0 := v.Args[0] 7734 if v_0.Op != OpARMMOVWaddr { 7735 break 7736 } 7737 off2 := v_0.AuxInt 7738 sym2 := v_0.Aux 7739 ptr := v_0.Args[0] 7740 mem := v.Args[1] 7741 if !(canMergeSym(sym1, sym2)) { 7742 break 7743 } 7744 v.reset(OpARMMOVFload) 7745 v.AuxInt = off1 + off2 7746 v.Aux = mergeSym(sym1, sym2) 7747 v.AddArg(ptr) 7748 v.AddArg(mem) 7749 return true 7750 } 7751 // match: (MOVFload [off] {sym} ptr (MOVFstore [off2] {sym2} ptr2 x _)) 7752 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 7753 // result: x 7754 for { 7755 off := v.AuxInt 7756 sym := v.Aux 7757 _ = v.Args[1] 7758 ptr := v.Args[0] 7759 v_1 := v.Args[1] 7760 if v_1.Op != OpARMMOVFstore { 7761 break 7762 } 7763 off2 := v_1.AuxInt 7764 sym2 := v_1.Aux 7765 _ = v_1.Args[2] 7766 ptr2 := v_1.Args[0] 7767 x := v_1.Args[1] 7768 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 7769 break 7770 } 7771 v.reset(OpCopy) 7772 v.Type = x.Type 7773 v.AddArg(x) 7774 return true 7775 } 7776 return false 7777 } 7778 func rewriteValueARM_OpARMMOVFstore_0(v *Value) bool { 7779 // match: (MOVFstore [off1] {sym} (ADDconst [off2] ptr) val mem) 7780 // cond: 7781 // result: (MOVFstore [off1+off2] {sym} ptr val mem) 7782 for { 7783 off1 := v.AuxInt 7784 sym := v.Aux 7785 _ = v.Args[2] 7786 v_0 := v.Args[0] 7787 if v_0.Op != OpARMADDconst { 7788 break 7789 } 7790 off2 := v_0.AuxInt 7791 ptr := v_0.Args[0] 7792 val := v.Args[1] 7793 mem := v.Args[2] 7794 v.reset(OpARMMOVFstore) 7795 v.AuxInt = off1 + off2 7796 v.Aux = sym 7797 v.AddArg(ptr) 7798 v.AddArg(val) 7799 v.AddArg(mem) 7800 return true 7801 } 7802 // match: (MOVFstore [off1] {sym} (SUBconst [off2] ptr) val mem) 7803 // cond: 7804 // result: (MOVFstore [off1-off2] {sym} ptr val mem) 7805 for { 7806 off1 := v.AuxInt 7807 sym := v.Aux 7808 _ = v.Args[2] 7809 v_0 := v.Args[0] 7810 if v_0.Op != OpARMSUBconst { 7811 break 7812 } 7813 off2 := v_0.AuxInt 7814 ptr := v_0.Args[0] 7815 val := v.Args[1] 7816 mem := v.Args[2] 7817 v.reset(OpARMMOVFstore) 7818 v.AuxInt = off1 - off2 7819 v.Aux = sym 7820 v.AddArg(ptr) 7821 v.AddArg(val) 7822 v.AddArg(mem) 7823 return true 7824 } 7825 // match: (MOVFstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem) 7826 // cond: canMergeSym(sym1,sym2) 7827 // result: (MOVFstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem) 7828 for { 7829 off1 := v.AuxInt 7830 sym1 := v.Aux 7831 _ = v.Args[2] 7832 v_0 := v.Args[0] 7833 if v_0.Op != OpARMMOVWaddr { 7834 break 7835 } 7836 off2 := v_0.AuxInt 7837 sym2 := v_0.Aux 7838 ptr := v_0.Args[0] 7839 val := v.Args[1] 7840 mem := v.Args[2] 7841 if !(canMergeSym(sym1, sym2)) { 7842 break 7843 } 7844 v.reset(OpARMMOVFstore) 7845 v.AuxInt = off1 + off2 7846 v.Aux = mergeSym(sym1, sym2) 7847 v.AddArg(ptr) 7848 v.AddArg(val) 7849 v.AddArg(mem) 7850 return true 7851 } 7852 return false 7853 } 7854 func rewriteValueARM_OpARMMOVHUload_0(v *Value) bool { 7855 b := v.Block 7856 _ = b 7857 config := b.Func.Config 7858 _ = config 7859 // match: (MOVHUload [off1] {sym} (ADDconst [off2] ptr) mem) 7860 // cond: 7861 // result: (MOVHUload [off1+off2] {sym} ptr mem) 7862 for { 7863 off1 := v.AuxInt 7864 sym := v.Aux 7865 _ = v.Args[1] 7866 v_0 := v.Args[0] 7867 if v_0.Op != OpARMADDconst { 7868 break 7869 } 7870 off2 := v_0.AuxInt 7871 ptr := v_0.Args[0] 7872 mem := v.Args[1] 7873 v.reset(OpARMMOVHUload) 7874 v.AuxInt = off1 + off2 7875 v.Aux = sym 7876 v.AddArg(ptr) 7877 v.AddArg(mem) 7878 return true 7879 } 7880 // match: (MOVHUload [off1] {sym} (SUBconst [off2] ptr) mem) 7881 // cond: 7882 // result: (MOVHUload [off1-off2] {sym} ptr mem) 7883 for { 7884 off1 := v.AuxInt 7885 sym := v.Aux 7886 _ = v.Args[1] 7887 v_0 := v.Args[0] 7888 if v_0.Op != OpARMSUBconst { 7889 break 7890 } 7891 off2 := v_0.AuxInt 7892 ptr := v_0.Args[0] 7893 mem := v.Args[1] 7894 v.reset(OpARMMOVHUload) 7895 v.AuxInt = off1 - off2 7896 v.Aux = sym 7897 v.AddArg(ptr) 7898 v.AddArg(mem) 7899 return true 7900 } 7901 // match: (MOVHUload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 7902 // cond: canMergeSym(sym1,sym2) 7903 // result: (MOVHUload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 7904 for { 7905 off1 := v.AuxInt 7906 sym1 := v.Aux 7907 _ = v.Args[1] 7908 v_0 := v.Args[0] 7909 if v_0.Op != OpARMMOVWaddr { 7910 break 7911 } 7912 off2 := v_0.AuxInt 7913 sym2 := v_0.Aux 7914 ptr := v_0.Args[0] 7915 mem := v.Args[1] 7916 if !(canMergeSym(sym1, sym2)) { 7917 break 7918 } 7919 v.reset(OpARMMOVHUload) 7920 v.AuxInt = off1 + off2 7921 v.Aux = mergeSym(sym1, sym2) 7922 v.AddArg(ptr) 7923 v.AddArg(mem) 7924 return true 7925 } 7926 // match: (MOVHUload [off] {sym} ptr (MOVHstore [off2] {sym2} ptr2 x _)) 7927 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 7928 // result: (MOVHUreg x) 7929 for { 7930 off := v.AuxInt 7931 sym := v.Aux 7932 _ = v.Args[1] 7933 ptr := v.Args[0] 7934 v_1 := v.Args[1] 7935 if v_1.Op != OpARMMOVHstore { 7936 break 7937 } 7938 off2 := v_1.AuxInt 7939 sym2 := v_1.Aux 7940 _ = v_1.Args[2] 7941 ptr2 := v_1.Args[0] 7942 x := v_1.Args[1] 7943 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 7944 break 7945 } 7946 v.reset(OpARMMOVHUreg) 7947 v.AddArg(x) 7948 return true 7949 } 7950 // match: (MOVHUload [0] {sym} (ADD ptr idx) mem) 7951 // cond: sym == nil && !config.nacl 7952 // result: (MOVHUloadidx ptr idx mem) 7953 for { 7954 if v.AuxInt != 0 { 7955 break 7956 } 7957 sym := v.Aux 7958 _ = v.Args[1] 7959 v_0 := v.Args[0] 7960 if v_0.Op != OpARMADD { 7961 break 7962 } 7963 _ = v_0.Args[1] 7964 ptr := v_0.Args[0] 7965 idx := v_0.Args[1] 7966 mem := v.Args[1] 7967 if !(sym == nil && !config.nacl) { 7968 break 7969 } 7970 v.reset(OpARMMOVHUloadidx) 7971 v.AddArg(ptr) 7972 v.AddArg(idx) 7973 v.AddArg(mem) 7974 return true 7975 } 7976 // match: (MOVHUload [off] {sym} (SB) _) 7977 // cond: symIsRO(sym) 7978 // result: (MOVWconst [int64(read16(sym, off, config.BigEndian))]) 7979 for { 7980 off := v.AuxInt 7981 sym := v.Aux 7982 _ = v.Args[1] 7983 v_0 := v.Args[0] 7984 if v_0.Op != OpSB { 7985 break 7986 } 7987 if !(symIsRO(sym)) { 7988 break 7989 } 7990 v.reset(OpARMMOVWconst) 7991 v.AuxInt = int64(read16(sym, off, config.BigEndian)) 7992 return true 7993 } 7994 return false 7995 } 7996 func rewriteValueARM_OpARMMOVHUloadidx_0(v *Value) bool { 7997 // match: (MOVHUloadidx ptr idx (MOVHstoreidx ptr2 idx x _)) 7998 // cond: isSamePtr(ptr, ptr2) 7999 // result: (MOVHUreg x) 8000 for { 8001 _ = v.Args[2] 8002 ptr := v.Args[0] 8003 idx := v.Args[1] 8004 v_2 := v.Args[2] 8005 if v_2.Op != OpARMMOVHstoreidx { 8006 break 8007 } 8008 _ = v_2.Args[3] 8009 ptr2 := v_2.Args[0] 8010 if idx != v_2.Args[1] { 8011 break 8012 } 8013 x := v_2.Args[2] 8014 if !(isSamePtr(ptr, ptr2)) { 8015 break 8016 } 8017 v.reset(OpARMMOVHUreg) 8018 v.AddArg(x) 8019 return true 8020 } 8021 // match: (MOVHUloadidx ptr (MOVWconst [c]) mem) 8022 // cond: 8023 // result: (MOVHUload [c] ptr mem) 8024 for { 8025 _ = v.Args[2] 8026 ptr := v.Args[0] 8027 v_1 := v.Args[1] 8028 if v_1.Op != OpARMMOVWconst { 8029 break 8030 } 8031 c := v_1.AuxInt 8032 mem := v.Args[2] 8033 v.reset(OpARMMOVHUload) 8034 v.AuxInt = c 8035 v.AddArg(ptr) 8036 v.AddArg(mem) 8037 return true 8038 } 8039 // match: (MOVHUloadidx (MOVWconst [c]) ptr mem) 8040 // cond: 8041 // result: (MOVHUload [c] ptr mem) 8042 for { 8043 _ = v.Args[2] 8044 v_0 := v.Args[0] 8045 if v_0.Op != OpARMMOVWconst { 8046 break 8047 } 8048 c := v_0.AuxInt 8049 ptr := v.Args[1] 8050 mem := v.Args[2] 8051 v.reset(OpARMMOVHUload) 8052 v.AuxInt = c 8053 v.AddArg(ptr) 8054 v.AddArg(mem) 8055 return true 8056 } 8057 return false 8058 } 8059 func rewriteValueARM_OpARMMOVHUreg_0(v *Value) bool { 8060 // match: (MOVHUreg x:(MOVBUload _ _)) 8061 // cond: 8062 // result: (MOVWreg x) 8063 for { 8064 x := v.Args[0] 8065 if x.Op != OpARMMOVBUload { 8066 break 8067 } 8068 _ = x.Args[1] 8069 v.reset(OpARMMOVWreg) 8070 v.AddArg(x) 8071 return true 8072 } 8073 // match: (MOVHUreg x:(MOVHUload _ _)) 8074 // cond: 8075 // result: (MOVWreg x) 8076 for { 8077 x := v.Args[0] 8078 if x.Op != OpARMMOVHUload { 8079 break 8080 } 8081 _ = x.Args[1] 8082 v.reset(OpARMMOVWreg) 8083 v.AddArg(x) 8084 return true 8085 } 8086 // match: (MOVHUreg (ANDconst [c] x)) 8087 // cond: 8088 // result: (ANDconst [c&0xffff] x) 8089 for { 8090 v_0 := v.Args[0] 8091 if v_0.Op != OpARMANDconst { 8092 break 8093 } 8094 c := v_0.AuxInt 8095 x := v_0.Args[0] 8096 v.reset(OpARMANDconst) 8097 v.AuxInt = c & 0xffff 8098 v.AddArg(x) 8099 return true 8100 } 8101 // match: (MOVHUreg x:(MOVBUreg _)) 8102 // cond: 8103 // result: (MOVWreg x) 8104 for { 8105 x := v.Args[0] 8106 if x.Op != OpARMMOVBUreg { 8107 break 8108 } 8109 v.reset(OpARMMOVWreg) 8110 v.AddArg(x) 8111 return true 8112 } 8113 // match: (MOVHUreg x:(MOVHUreg _)) 8114 // cond: 8115 // result: (MOVWreg x) 8116 for { 8117 x := v.Args[0] 8118 if x.Op != OpARMMOVHUreg { 8119 break 8120 } 8121 v.reset(OpARMMOVWreg) 8122 v.AddArg(x) 8123 return true 8124 } 8125 // match: (MOVHUreg (MOVWconst [c])) 8126 // cond: 8127 // result: (MOVWconst [int64(uint16(c))]) 8128 for { 8129 v_0 := v.Args[0] 8130 if v_0.Op != OpARMMOVWconst { 8131 break 8132 } 8133 c := v_0.AuxInt 8134 v.reset(OpARMMOVWconst) 8135 v.AuxInt = int64(uint16(c)) 8136 return true 8137 } 8138 return false 8139 } 8140 func rewriteValueARM_OpARMMOVHload_0(v *Value) bool { 8141 b := v.Block 8142 _ = b 8143 config := b.Func.Config 8144 _ = config 8145 // match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem) 8146 // cond: 8147 // result: (MOVHload [off1+off2] {sym} ptr mem) 8148 for { 8149 off1 := v.AuxInt 8150 sym := v.Aux 8151 _ = v.Args[1] 8152 v_0 := v.Args[0] 8153 if v_0.Op != OpARMADDconst { 8154 break 8155 } 8156 off2 := v_0.AuxInt 8157 ptr := v_0.Args[0] 8158 mem := v.Args[1] 8159 v.reset(OpARMMOVHload) 8160 v.AuxInt = off1 + off2 8161 v.Aux = sym 8162 v.AddArg(ptr) 8163 v.AddArg(mem) 8164 return true 8165 } 8166 // match: (MOVHload [off1] {sym} (SUBconst [off2] ptr) mem) 8167 // cond: 8168 // result: (MOVHload [off1-off2] {sym} ptr mem) 8169 for { 8170 off1 := v.AuxInt 8171 sym := v.Aux 8172 _ = v.Args[1] 8173 v_0 := v.Args[0] 8174 if v_0.Op != OpARMSUBconst { 8175 break 8176 } 8177 off2 := v_0.AuxInt 8178 ptr := v_0.Args[0] 8179 mem := v.Args[1] 8180 v.reset(OpARMMOVHload) 8181 v.AuxInt = off1 - off2 8182 v.Aux = sym 8183 v.AddArg(ptr) 8184 v.AddArg(mem) 8185 return true 8186 } 8187 // match: (MOVHload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 8188 // cond: canMergeSym(sym1,sym2) 8189 // result: (MOVHload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 8190 for { 8191 off1 := v.AuxInt 8192 sym1 := v.Aux 8193 _ = v.Args[1] 8194 v_0 := v.Args[0] 8195 if v_0.Op != OpARMMOVWaddr { 8196 break 8197 } 8198 off2 := v_0.AuxInt 8199 sym2 := v_0.Aux 8200 ptr := v_0.Args[0] 8201 mem := v.Args[1] 8202 if !(canMergeSym(sym1, sym2)) { 8203 break 8204 } 8205 v.reset(OpARMMOVHload) 8206 v.AuxInt = off1 + off2 8207 v.Aux = mergeSym(sym1, sym2) 8208 v.AddArg(ptr) 8209 v.AddArg(mem) 8210 return true 8211 } 8212 // match: (MOVHload [off] {sym} ptr (MOVHstore [off2] {sym2} ptr2 x _)) 8213 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 8214 // result: (MOVHreg x) 8215 for { 8216 off := v.AuxInt 8217 sym := v.Aux 8218 _ = v.Args[1] 8219 ptr := v.Args[0] 8220 v_1 := v.Args[1] 8221 if v_1.Op != OpARMMOVHstore { 8222 break 8223 } 8224 off2 := v_1.AuxInt 8225 sym2 := v_1.Aux 8226 _ = v_1.Args[2] 8227 ptr2 := v_1.Args[0] 8228 x := v_1.Args[1] 8229 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 8230 break 8231 } 8232 v.reset(OpARMMOVHreg) 8233 v.AddArg(x) 8234 return true 8235 } 8236 // match: (MOVHload [0] {sym} (ADD ptr idx) mem) 8237 // cond: sym == nil && !config.nacl 8238 // result: (MOVHloadidx ptr idx mem) 8239 for { 8240 if v.AuxInt != 0 { 8241 break 8242 } 8243 sym := v.Aux 8244 _ = v.Args[1] 8245 v_0 := v.Args[0] 8246 if v_0.Op != OpARMADD { 8247 break 8248 } 8249 _ = v_0.Args[1] 8250 ptr := v_0.Args[0] 8251 idx := v_0.Args[1] 8252 mem := v.Args[1] 8253 if !(sym == nil && !config.nacl) { 8254 break 8255 } 8256 v.reset(OpARMMOVHloadidx) 8257 v.AddArg(ptr) 8258 v.AddArg(idx) 8259 v.AddArg(mem) 8260 return true 8261 } 8262 return false 8263 } 8264 func rewriteValueARM_OpARMMOVHloadidx_0(v *Value) bool { 8265 // match: (MOVHloadidx ptr idx (MOVHstoreidx ptr2 idx x _)) 8266 // cond: isSamePtr(ptr, ptr2) 8267 // result: (MOVHreg x) 8268 for { 8269 _ = v.Args[2] 8270 ptr := v.Args[0] 8271 idx := v.Args[1] 8272 v_2 := v.Args[2] 8273 if v_2.Op != OpARMMOVHstoreidx { 8274 break 8275 } 8276 _ = v_2.Args[3] 8277 ptr2 := v_2.Args[0] 8278 if idx != v_2.Args[1] { 8279 break 8280 } 8281 x := v_2.Args[2] 8282 if !(isSamePtr(ptr, ptr2)) { 8283 break 8284 } 8285 v.reset(OpARMMOVHreg) 8286 v.AddArg(x) 8287 return true 8288 } 8289 // match: (MOVHloadidx ptr (MOVWconst [c]) mem) 8290 // cond: 8291 // result: (MOVHload [c] ptr mem) 8292 for { 8293 _ = v.Args[2] 8294 ptr := v.Args[0] 8295 v_1 := v.Args[1] 8296 if v_1.Op != OpARMMOVWconst { 8297 break 8298 } 8299 c := v_1.AuxInt 8300 mem := v.Args[2] 8301 v.reset(OpARMMOVHload) 8302 v.AuxInt = c 8303 v.AddArg(ptr) 8304 v.AddArg(mem) 8305 return true 8306 } 8307 // match: (MOVHloadidx (MOVWconst [c]) ptr mem) 8308 // cond: 8309 // result: (MOVHload [c] ptr mem) 8310 for { 8311 _ = v.Args[2] 8312 v_0 := v.Args[0] 8313 if v_0.Op != OpARMMOVWconst { 8314 break 8315 } 8316 c := v_0.AuxInt 8317 ptr := v.Args[1] 8318 mem := v.Args[2] 8319 v.reset(OpARMMOVHload) 8320 v.AuxInt = c 8321 v.AddArg(ptr) 8322 v.AddArg(mem) 8323 return true 8324 } 8325 return false 8326 } 8327 func rewriteValueARM_OpARMMOVHreg_0(v *Value) bool { 8328 // match: (MOVHreg x:(MOVBload _ _)) 8329 // cond: 8330 // result: (MOVWreg x) 8331 for { 8332 x := v.Args[0] 8333 if x.Op != OpARMMOVBload { 8334 break 8335 } 8336 _ = x.Args[1] 8337 v.reset(OpARMMOVWreg) 8338 v.AddArg(x) 8339 return true 8340 } 8341 // match: (MOVHreg x:(MOVBUload _ _)) 8342 // cond: 8343 // result: (MOVWreg x) 8344 for { 8345 x := v.Args[0] 8346 if x.Op != OpARMMOVBUload { 8347 break 8348 } 8349 _ = x.Args[1] 8350 v.reset(OpARMMOVWreg) 8351 v.AddArg(x) 8352 return true 8353 } 8354 // match: (MOVHreg x:(MOVHload _ _)) 8355 // cond: 8356 // result: (MOVWreg x) 8357 for { 8358 x := v.Args[0] 8359 if x.Op != OpARMMOVHload { 8360 break 8361 } 8362 _ = x.Args[1] 8363 v.reset(OpARMMOVWreg) 8364 v.AddArg(x) 8365 return true 8366 } 8367 // match: (MOVHreg (ANDconst [c] x)) 8368 // cond: c & 0x8000 == 0 8369 // result: (ANDconst [c&0x7fff] x) 8370 for { 8371 v_0 := v.Args[0] 8372 if v_0.Op != OpARMANDconst { 8373 break 8374 } 8375 c := v_0.AuxInt 8376 x := v_0.Args[0] 8377 if !(c&0x8000 == 0) { 8378 break 8379 } 8380 v.reset(OpARMANDconst) 8381 v.AuxInt = c & 0x7fff 8382 v.AddArg(x) 8383 return true 8384 } 8385 // match: (MOVHreg x:(MOVBreg _)) 8386 // cond: 8387 // result: (MOVWreg x) 8388 for { 8389 x := v.Args[0] 8390 if x.Op != OpARMMOVBreg { 8391 break 8392 } 8393 v.reset(OpARMMOVWreg) 8394 v.AddArg(x) 8395 return true 8396 } 8397 // match: (MOVHreg x:(MOVBUreg _)) 8398 // cond: 8399 // result: (MOVWreg x) 8400 for { 8401 x := v.Args[0] 8402 if x.Op != OpARMMOVBUreg { 8403 break 8404 } 8405 v.reset(OpARMMOVWreg) 8406 v.AddArg(x) 8407 return true 8408 } 8409 // match: (MOVHreg x:(MOVHreg _)) 8410 // cond: 8411 // result: (MOVWreg x) 8412 for { 8413 x := v.Args[0] 8414 if x.Op != OpARMMOVHreg { 8415 break 8416 } 8417 v.reset(OpARMMOVWreg) 8418 v.AddArg(x) 8419 return true 8420 } 8421 // match: (MOVHreg (MOVWconst [c])) 8422 // cond: 8423 // result: (MOVWconst [int64(int16(c))]) 8424 for { 8425 v_0 := v.Args[0] 8426 if v_0.Op != OpARMMOVWconst { 8427 break 8428 } 8429 c := v_0.AuxInt 8430 v.reset(OpARMMOVWconst) 8431 v.AuxInt = int64(int16(c)) 8432 return true 8433 } 8434 return false 8435 } 8436 func rewriteValueARM_OpARMMOVHstore_0(v *Value) bool { 8437 b := v.Block 8438 _ = b 8439 config := b.Func.Config 8440 _ = config 8441 // match: (MOVHstore [off1] {sym} (ADDconst [off2] ptr) val mem) 8442 // cond: 8443 // result: (MOVHstore [off1+off2] {sym} ptr val mem) 8444 for { 8445 off1 := v.AuxInt 8446 sym := v.Aux 8447 _ = v.Args[2] 8448 v_0 := v.Args[0] 8449 if v_0.Op != OpARMADDconst { 8450 break 8451 } 8452 off2 := v_0.AuxInt 8453 ptr := v_0.Args[0] 8454 val := v.Args[1] 8455 mem := v.Args[2] 8456 v.reset(OpARMMOVHstore) 8457 v.AuxInt = off1 + off2 8458 v.Aux = sym 8459 v.AddArg(ptr) 8460 v.AddArg(val) 8461 v.AddArg(mem) 8462 return true 8463 } 8464 // match: (MOVHstore [off1] {sym} (SUBconst [off2] ptr) val mem) 8465 // cond: 8466 // result: (MOVHstore [off1-off2] {sym} ptr val mem) 8467 for { 8468 off1 := v.AuxInt 8469 sym := v.Aux 8470 _ = v.Args[2] 8471 v_0 := v.Args[0] 8472 if v_0.Op != OpARMSUBconst { 8473 break 8474 } 8475 off2 := v_0.AuxInt 8476 ptr := v_0.Args[0] 8477 val := v.Args[1] 8478 mem := v.Args[2] 8479 v.reset(OpARMMOVHstore) 8480 v.AuxInt = off1 - off2 8481 v.Aux = sym 8482 v.AddArg(ptr) 8483 v.AddArg(val) 8484 v.AddArg(mem) 8485 return true 8486 } 8487 // match: (MOVHstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem) 8488 // cond: canMergeSym(sym1,sym2) 8489 // result: (MOVHstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem) 8490 for { 8491 off1 := v.AuxInt 8492 sym1 := v.Aux 8493 _ = v.Args[2] 8494 v_0 := v.Args[0] 8495 if v_0.Op != OpARMMOVWaddr { 8496 break 8497 } 8498 off2 := v_0.AuxInt 8499 sym2 := v_0.Aux 8500 ptr := v_0.Args[0] 8501 val := v.Args[1] 8502 mem := v.Args[2] 8503 if !(canMergeSym(sym1, sym2)) { 8504 break 8505 } 8506 v.reset(OpARMMOVHstore) 8507 v.AuxInt = off1 + off2 8508 v.Aux = mergeSym(sym1, sym2) 8509 v.AddArg(ptr) 8510 v.AddArg(val) 8511 v.AddArg(mem) 8512 return true 8513 } 8514 // match: (MOVHstore [off] {sym} ptr (MOVHreg x) mem) 8515 // cond: 8516 // result: (MOVHstore [off] {sym} ptr x mem) 8517 for { 8518 off := v.AuxInt 8519 sym := v.Aux 8520 _ = v.Args[2] 8521 ptr := v.Args[0] 8522 v_1 := v.Args[1] 8523 if v_1.Op != OpARMMOVHreg { 8524 break 8525 } 8526 x := v_1.Args[0] 8527 mem := v.Args[2] 8528 v.reset(OpARMMOVHstore) 8529 v.AuxInt = off 8530 v.Aux = sym 8531 v.AddArg(ptr) 8532 v.AddArg(x) 8533 v.AddArg(mem) 8534 return true 8535 } 8536 // match: (MOVHstore [off] {sym} ptr (MOVHUreg x) mem) 8537 // cond: 8538 // result: (MOVHstore [off] {sym} ptr x mem) 8539 for { 8540 off := v.AuxInt 8541 sym := v.Aux 8542 _ = v.Args[2] 8543 ptr := v.Args[0] 8544 v_1 := v.Args[1] 8545 if v_1.Op != OpARMMOVHUreg { 8546 break 8547 } 8548 x := v_1.Args[0] 8549 mem := v.Args[2] 8550 v.reset(OpARMMOVHstore) 8551 v.AuxInt = off 8552 v.Aux = sym 8553 v.AddArg(ptr) 8554 v.AddArg(x) 8555 v.AddArg(mem) 8556 return true 8557 } 8558 // match: (MOVHstore [0] {sym} (ADD ptr idx) val mem) 8559 // cond: sym == nil && !config.nacl 8560 // result: (MOVHstoreidx ptr idx val mem) 8561 for { 8562 if v.AuxInt != 0 { 8563 break 8564 } 8565 sym := v.Aux 8566 _ = v.Args[2] 8567 v_0 := v.Args[0] 8568 if v_0.Op != OpARMADD { 8569 break 8570 } 8571 _ = v_0.Args[1] 8572 ptr := v_0.Args[0] 8573 idx := v_0.Args[1] 8574 val := v.Args[1] 8575 mem := v.Args[2] 8576 if !(sym == nil && !config.nacl) { 8577 break 8578 } 8579 v.reset(OpARMMOVHstoreidx) 8580 v.AddArg(ptr) 8581 v.AddArg(idx) 8582 v.AddArg(val) 8583 v.AddArg(mem) 8584 return true 8585 } 8586 return false 8587 } 8588 func rewriteValueARM_OpARMMOVHstoreidx_0(v *Value) bool { 8589 // match: (MOVHstoreidx ptr (MOVWconst [c]) val mem) 8590 // cond: 8591 // result: (MOVHstore [c] ptr val mem) 8592 for { 8593 _ = v.Args[3] 8594 ptr := v.Args[0] 8595 v_1 := v.Args[1] 8596 if v_1.Op != OpARMMOVWconst { 8597 break 8598 } 8599 c := v_1.AuxInt 8600 val := v.Args[2] 8601 mem := v.Args[3] 8602 v.reset(OpARMMOVHstore) 8603 v.AuxInt = c 8604 v.AddArg(ptr) 8605 v.AddArg(val) 8606 v.AddArg(mem) 8607 return true 8608 } 8609 // match: (MOVHstoreidx (MOVWconst [c]) ptr val mem) 8610 // cond: 8611 // result: (MOVHstore [c] ptr val mem) 8612 for { 8613 _ = v.Args[3] 8614 v_0 := v.Args[0] 8615 if v_0.Op != OpARMMOVWconst { 8616 break 8617 } 8618 c := v_0.AuxInt 8619 ptr := v.Args[1] 8620 val := v.Args[2] 8621 mem := v.Args[3] 8622 v.reset(OpARMMOVHstore) 8623 v.AuxInt = c 8624 v.AddArg(ptr) 8625 v.AddArg(val) 8626 v.AddArg(mem) 8627 return true 8628 } 8629 return false 8630 } 8631 func rewriteValueARM_OpARMMOVWload_0(v *Value) bool { 8632 b := v.Block 8633 _ = b 8634 config := b.Func.Config 8635 _ = config 8636 // match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem) 8637 // cond: 8638 // result: (MOVWload [off1+off2] {sym} ptr mem) 8639 for { 8640 off1 := v.AuxInt 8641 sym := v.Aux 8642 _ = v.Args[1] 8643 v_0 := v.Args[0] 8644 if v_0.Op != OpARMADDconst { 8645 break 8646 } 8647 off2 := v_0.AuxInt 8648 ptr := v_0.Args[0] 8649 mem := v.Args[1] 8650 v.reset(OpARMMOVWload) 8651 v.AuxInt = off1 + off2 8652 v.Aux = sym 8653 v.AddArg(ptr) 8654 v.AddArg(mem) 8655 return true 8656 } 8657 // match: (MOVWload [off1] {sym} (SUBconst [off2] ptr) mem) 8658 // cond: 8659 // result: (MOVWload [off1-off2] {sym} ptr mem) 8660 for { 8661 off1 := v.AuxInt 8662 sym := v.Aux 8663 _ = v.Args[1] 8664 v_0 := v.Args[0] 8665 if v_0.Op != OpARMSUBconst { 8666 break 8667 } 8668 off2 := v_0.AuxInt 8669 ptr := v_0.Args[0] 8670 mem := v.Args[1] 8671 v.reset(OpARMMOVWload) 8672 v.AuxInt = off1 - off2 8673 v.Aux = sym 8674 v.AddArg(ptr) 8675 v.AddArg(mem) 8676 return true 8677 } 8678 // match: (MOVWload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) 8679 // cond: canMergeSym(sym1,sym2) 8680 // result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) 8681 for { 8682 off1 := v.AuxInt 8683 sym1 := v.Aux 8684 _ = v.Args[1] 8685 v_0 := v.Args[0] 8686 if v_0.Op != OpARMMOVWaddr { 8687 break 8688 } 8689 off2 := v_0.AuxInt 8690 sym2 := v_0.Aux 8691 ptr := v_0.Args[0] 8692 mem := v.Args[1] 8693 if !(canMergeSym(sym1, sym2)) { 8694 break 8695 } 8696 v.reset(OpARMMOVWload) 8697 v.AuxInt = off1 + off2 8698 v.Aux = mergeSym(sym1, sym2) 8699 v.AddArg(ptr) 8700 v.AddArg(mem) 8701 return true 8702 } 8703 // match: (MOVWload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _)) 8704 // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) 8705 // result: x 8706 for { 8707 off := v.AuxInt 8708 sym := v.Aux 8709 _ = v.Args[1] 8710 ptr := v.Args[0] 8711 v_1 := v.Args[1] 8712 if v_1.Op != OpARMMOVWstore { 8713 break 8714 } 8715 off2 := v_1.AuxInt 8716 sym2 := v_1.Aux 8717 _ = v_1.Args[2] 8718 ptr2 := v_1.Args[0] 8719 x := v_1.Args[1] 8720 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) { 8721 break 8722 } 8723 v.reset(OpCopy) 8724 v.Type = x.Type 8725 v.AddArg(x) 8726 return true 8727 } 8728 // match: (MOVWload [0] {sym} (ADD ptr idx) mem) 8729 // cond: sym == nil && !config.nacl 8730 // result: (MOVWloadidx ptr idx mem) 8731 for { 8732 if v.AuxInt != 0 { 8733 break 8734 } 8735 sym := v.Aux 8736 _ = v.Args[1] 8737 v_0 := v.Args[0] 8738 if v_0.Op != OpARMADD { 8739 break 8740 } 8741 _ = v_0.Args[1] 8742 ptr := v_0.Args[0] 8743 idx := v_0.Args[1] 8744 mem := v.Args[1] 8745 if !(sym == nil && !config.nacl) { 8746 break 8747 } 8748 v.reset(OpARMMOVWloadidx) 8749 v.AddArg(ptr) 8750 v.AddArg(idx) 8751 v.AddArg(mem) 8752 return true 8753 } 8754 // match: (MOVWload [0] {sym} (ADDshiftLL ptr idx [c]) mem) 8755 // cond: sym == nil && !config.nacl 8756 // result: (MOVWloadshiftLL ptr idx [c] mem) 8757 for { 8758 if v.AuxInt != 0 { 8759 break 8760 } 8761 sym := v.Aux 8762 _ = v.Args[1] 8763 v_0 := v.Args[0] 8764 if v_0.Op != OpARMADDshiftLL { 8765 break 8766 } 8767 c := v_0.AuxInt 8768 _ = v_0.Args[1] 8769 ptr := v_0.Args[0] 8770 idx := v_0.Args[1] 8771 mem := v.Args[1] 8772 if !(sym == nil && !config.nacl) { 8773 break 8774 } 8775 v.reset(OpARMMOVWloadshiftLL) 8776 v.AuxInt = c 8777 v.AddArg(ptr) 8778 v.AddArg(idx) 8779 v.AddArg(mem) 8780 return true 8781 } 8782 // match: (MOVWload [0] {sym} (ADDshiftRL ptr idx [c]) mem) 8783 // cond: sym == nil && !config.nacl 8784 // result: (MOVWloadshiftRL ptr idx [c] mem) 8785 for { 8786 if v.AuxInt != 0 { 8787 break 8788 } 8789 sym := v.Aux 8790 _ = v.Args[1] 8791 v_0 := v.Args[0] 8792 if v_0.Op != OpARMADDshiftRL { 8793 break 8794 } 8795 c := v_0.AuxInt 8796 _ = v_0.Args[1] 8797 ptr := v_0.Args[0] 8798 idx := v_0.Args[1] 8799 mem := v.Args[1] 8800 if !(sym == nil && !config.nacl) { 8801 break 8802 } 8803 v.reset(OpARMMOVWloadshiftRL) 8804 v.AuxInt = c 8805 v.AddArg(ptr) 8806 v.AddArg(idx) 8807 v.AddArg(mem) 8808 return true 8809 } 8810 // match: (MOVWload [0] {sym} (ADDshiftRA ptr idx [c]) mem) 8811 // cond: sym == nil && !config.nacl 8812 // result: (MOVWloadshiftRA ptr idx [c] mem) 8813 for { 8814 if v.AuxInt != 0 { 8815 break 8816 } 8817 sym := v.Aux 8818 _ = v.Args[1] 8819 v_0 := v.Args[0] 8820 if v_0.Op != OpARMADDshiftRA { 8821 break 8822 } 8823 c := v_0.AuxInt 8824 _ = v_0.Args[1] 8825 ptr := v_0.Args[0] 8826 idx := v_0.Args[1] 8827 mem := v.Args[1] 8828 if !(sym == nil && !config.nacl) { 8829 break 8830 } 8831 v.reset(OpARMMOVWloadshiftRA) 8832 v.AuxInt = c 8833 v.AddArg(ptr) 8834 v.AddArg(idx) 8835 v.AddArg(mem) 8836 return true 8837 } 8838 // match: (MOVWload [off] {sym} (SB) _) 8839 // cond: symIsRO(sym) 8840 // result: (MOVWconst [int64(int32(read32(sym, off, config.BigEndian)))]) 8841 for { 8842 off := v.AuxInt 8843 sym := v.Aux 8844 _ = v.Args[1] 8845 v_0 := v.Args[0] 8846 if v_0.Op != OpSB { 8847 break 8848 } 8849 if !(symIsRO(sym)) { 8850 break 8851 } 8852 v.reset(OpARMMOVWconst) 8853 v.AuxInt = int64(int32(read32(sym, off, config.BigEndian))) 8854 return true 8855 } 8856 return false 8857 } 8858 func rewriteValueARM_OpARMMOVWloadidx_0(v *Value) bool { 8859 // match: (MOVWloadidx ptr idx (MOVWstoreidx ptr2 idx x _)) 8860 // cond: isSamePtr(ptr, ptr2) 8861 // result: x 8862 for { 8863 _ = v.Args[2] 8864 ptr := v.Args[0] 8865 idx := v.Args[1] 8866 v_2 := v.Args[2] 8867 if v_2.Op != OpARMMOVWstoreidx { 8868 break 8869 } 8870 _ = v_2.Args[3] 8871 ptr2 := v_2.Args[0] 8872 if idx != v_2.Args[1] { 8873 break 8874 } 8875 x := v_2.Args[2] 8876 if !(isSamePtr(ptr, ptr2)) { 8877 break 8878 } 8879 v.reset(OpCopy) 8880 v.Type = x.Type 8881 v.AddArg(x) 8882 return true 8883 } 8884 // match: (MOVWloadidx ptr (MOVWconst [c]) mem) 8885 // cond: 8886 // result: (MOVWload [c] ptr mem) 8887 for { 8888 _ = v.Args[2] 8889 ptr := v.Args[0] 8890 v_1 := v.Args[1] 8891 if v_1.Op != OpARMMOVWconst { 8892 break 8893 } 8894 c := v_1.AuxInt 8895 mem := v.Args[2] 8896 v.reset(OpARMMOVWload) 8897 v.AuxInt = c 8898 v.AddArg(ptr) 8899 v.AddArg(mem) 8900 return true 8901 } 8902 // match: (MOVWloadidx (MOVWconst [c]) ptr mem) 8903 // cond: 8904 // result: (MOVWload [c] ptr mem) 8905 for { 8906 _ = v.Args[2] 8907 v_0 := v.Args[0] 8908 if v_0.Op != OpARMMOVWconst { 8909 break 8910 } 8911 c := v_0.AuxInt 8912 ptr := v.Args[1] 8913 mem := v.Args[2] 8914 v.reset(OpARMMOVWload) 8915 v.AuxInt = c 8916 v.AddArg(ptr) 8917 v.AddArg(mem) 8918 return true 8919 } 8920 // match: (MOVWloadidx ptr (SLLconst idx [c]) mem) 8921 // cond: 8922 // result: (MOVWloadshiftLL ptr idx [c] mem) 8923 for { 8924 _ = v.Args[2] 8925 ptr := v.Args[0] 8926 v_1 := v.Args[1] 8927 if v_1.Op != OpARMSLLconst { 8928 break 8929 } 8930 c := v_1.AuxInt 8931 idx := v_1.Args[0] 8932 mem := v.Args[2] 8933 v.reset(OpARMMOVWloadshiftLL) 8934 v.AuxInt = c 8935 v.AddArg(ptr) 8936 v.AddArg(idx) 8937 v.AddArg(mem) 8938 return true 8939 } 8940 // match: (MOVWloadidx (SLLconst idx [c]) ptr mem) 8941 // cond: 8942 // result: (MOVWloadshiftLL ptr idx [c] mem) 8943 for { 8944 _ = v.Args[2] 8945 v_0 := v.Args[0] 8946 if v_0.Op != OpARMSLLconst { 8947 break 8948 } 8949 c := v_0.AuxInt 8950 idx := v_0.Args[0] 8951 ptr := v.Args[1] 8952 mem := v.Args[2] 8953 v.reset(OpARMMOVWloadshiftLL) 8954 v.AuxInt = c 8955 v.AddArg(ptr) 8956 v.AddArg(idx) 8957 v.AddArg(mem) 8958 return true 8959 } 8960 // match: (MOVWloadidx ptr (SRLconst idx [c]) mem) 8961 // cond: 8962 // result: (MOVWloadshiftRL ptr idx [c] mem) 8963 for { 8964 _ = v.Args[2] 8965 ptr := v.Args[0] 8966 v_1 := v.Args[1] 8967 if v_1.Op != OpARMSRLconst { 8968 break 8969 } 8970 c := v_1.AuxInt 8971 idx := v_1.Args[0] 8972 mem := v.Args[2] 8973 v.reset(OpARMMOVWloadshiftRL) 8974 v.AuxInt = c 8975 v.AddArg(ptr) 8976 v.AddArg(idx) 8977 v.AddArg(mem) 8978 return true 8979 } 8980 // match: (MOVWloadidx (SRLconst idx [c]) ptr mem) 8981 // cond: 8982 // result: (MOVWloadshiftRL ptr idx [c] mem) 8983 for { 8984 _ = v.Args[2] 8985 v_0 := v.Args[0] 8986 if v_0.Op != OpARMSRLconst { 8987 break 8988 } 8989 c := v_0.AuxInt 8990 idx := v_0.Args[0] 8991 ptr := v.Args[1] 8992 mem := v.Args[2] 8993 v.reset(OpARMMOVWloadshiftRL) 8994 v.AuxInt = c 8995 v.AddArg(ptr) 8996 v.AddArg(idx) 8997 v.AddArg(mem) 8998 return true 8999 } 9000 // match: (MOVWloadidx ptr (SRAconst idx [c]) mem) 9001 // cond: 9002 // result: (MOVWloadshiftRA ptr idx [c] mem) 9003 for { 9004 _ = v.Args[2] 9005 ptr := v.Args[0] 9006 v_1 := v.Args[1] 9007 if v_1.Op != OpARMSRAconst { 9008 break 9009 } 9010 c := v_1.AuxInt 9011 idx := v_1.Args[0] 9012 mem := v.Args[2] 9013 v.reset(OpARMMOVWloadshiftRA) 9014 v.AuxInt = c 9015 v.AddArg(ptr) 9016 v.AddArg(idx) 9017 v.AddArg(mem) 9018 return true 9019 } 9020 // match: (MOVWloadidx (SRAconst idx [c]) ptr mem) 9021 // cond: 9022 // result: (MOVWloadshiftRA ptr idx [c] mem) 9023 for { 9024 _ = v.Args[2] 9025 v_0 := v.Args[0] 9026 if v_0.Op != OpARMSRAconst { 9027 break 9028 } 9029 c := v_0.AuxInt 9030 idx := v_0.Args[0] 9031 ptr := v.Args[1] 9032 mem := v.Args[2] 9033 v.reset(OpARMMOVWloadshiftRA) 9034 v.AuxInt = c 9035 v.AddArg(ptr) 9036 v.AddArg(idx) 9037 v.AddArg(mem) 9038 return true 9039 } 9040 return false 9041 } 9042 func rewriteValueARM_OpARMMOVWloadshiftLL_0(v *Value) bool { 9043 // match: (MOVWloadshiftLL ptr idx [c] (MOVWstoreshiftLL ptr2 idx [d] x _)) 9044 // cond: c==d && isSamePtr(ptr, ptr2) 9045 // result: x 9046 for { 9047 c := v.AuxInt 9048 _ = v.Args[2] 9049 ptr := v.Args[0] 9050 idx := v.Args[1] 9051 v_2 := v.Args[2] 9052 if v_2.Op != OpARMMOVWstoreshiftLL { 9053 break 9054 } 9055 d := v_2.AuxInt 9056 _ = v_2.Args[3] 9057 ptr2 := v_2.Args[0] 9058 if idx != v_2.Args[1] { 9059 break 9060 } 9061 x := v_2.Args[2] 9062 if !(c == d && isSamePtr(ptr, ptr2)) { 9063 break 9064 } 9065 v.reset(OpCopy) 9066 v.Type = x.Type 9067 v.AddArg(x) 9068 return true 9069 } 9070 // match: (MOVWloadshiftLL ptr (MOVWconst [c]) [d] mem) 9071 // cond: 9072 // result: (MOVWload [int64(uint32(c)<<uint64(d))] ptr mem) 9073 for { 9074 d := v.AuxInt 9075 _ = v.Args[2] 9076 ptr := v.Args[0] 9077 v_1 := v.Args[1] 9078 if v_1.Op != OpARMMOVWconst { 9079 break 9080 } 9081 c := v_1.AuxInt 9082 mem := v.Args[2] 9083 v.reset(OpARMMOVWload) 9084 v.AuxInt = int64(uint32(c) << uint64(d)) 9085 v.AddArg(ptr) 9086 v.AddArg(mem) 9087 return true 9088 } 9089 return false 9090 } 9091 func rewriteValueARM_OpARMMOVWloadshiftRA_0(v *Value) bool { 9092 // match: (MOVWloadshiftRA ptr idx [c] (MOVWstoreshiftRA ptr2 idx [d] x _)) 9093 // cond: c==d && isSamePtr(ptr, ptr2) 9094 // result: x 9095 for { 9096 c := v.AuxInt 9097 _ = v.Args[2] 9098 ptr := v.Args[0] 9099 idx := v.Args[1] 9100 v_2 := v.Args[2] 9101 if v_2.Op != OpARMMOVWstoreshiftRA { 9102 break 9103 } 9104 d := v_2.AuxInt 9105 _ = v_2.Args[3] 9106 ptr2 := v_2.Args[0] 9107 if idx != v_2.Args[1] { 9108 break 9109 } 9110 x := v_2.Args[2] 9111 if !(c == d && isSamePtr(ptr, ptr2)) { 9112 break 9113 } 9114 v.reset(OpCopy) 9115 v.Type = x.Type 9116 v.AddArg(x) 9117 return true 9118 } 9119 // match: (MOVWloadshiftRA ptr (MOVWconst [c]) [d] mem) 9120 // cond: 9121 // result: (MOVWload [int64(int32(c)>>uint64(d))] ptr mem) 9122 for { 9123 d := v.AuxInt 9124 _ = v.Args[2] 9125 ptr := v.Args[0] 9126 v_1 := v.Args[1] 9127 if v_1.Op != OpARMMOVWconst { 9128 break 9129 } 9130 c := v_1.AuxInt 9131 mem := v.Args[2] 9132 v.reset(OpARMMOVWload) 9133 v.AuxInt = int64(int32(c) >> uint64(d)) 9134 v.AddArg(ptr) 9135 v.AddArg(mem) 9136 return true 9137 } 9138 return false 9139 } 9140 func rewriteValueARM_OpARMMOVWloadshiftRL_0(v *Value) bool { 9141 // match: (MOVWloadshiftRL ptr idx [c] (MOVWstoreshiftRL ptr2 idx [d] x _)) 9142 // cond: c==d && isSamePtr(ptr, ptr2) 9143 // result: x 9144 for { 9145 c := v.AuxInt 9146 _ = v.Args[2] 9147 ptr := v.Args[0] 9148 idx := v.Args[1] 9149 v_2 := v.Args[2] 9150 if v_2.Op != OpARMMOVWstoreshiftRL { 9151 break 9152 } 9153 d := v_2.AuxInt 9154 _ = v_2.Args[3] 9155 ptr2 := v_2.Args[0] 9156 if idx != v_2.Args[1] { 9157 break 9158 } 9159 x := v_2.Args[2] 9160 if !(c == d && isSamePtr(ptr, ptr2)) { 9161 break 9162 } 9163 v.reset(OpCopy) 9164 v.Type = x.Type 9165 v.AddArg(x) 9166 return true 9167 } 9168 // match: (MOVWloadshiftRL ptr (MOVWconst [c]) [d] mem) 9169 // cond: 9170 // result: (MOVWload [int64(uint32(c)>>uint64(d))] ptr mem) 9171 for { 9172 d := v.AuxInt 9173 _ = v.Args[2] 9174 ptr := v.Args[0] 9175 v_1 := v.Args[1] 9176 if v_1.Op != OpARMMOVWconst { 9177 break 9178 } 9179 c := v_1.AuxInt 9180 mem := v.Args[2] 9181 v.reset(OpARMMOVWload) 9182 v.AuxInt = int64(uint32(c) >> uint64(d)) 9183 v.AddArg(ptr) 9184 v.AddArg(mem) 9185 return true 9186 } 9187 return false 9188 } 9189 func rewriteValueARM_OpARMMOVWreg_0(v *Value) bool { 9190 // match: (MOVWreg x) 9191 // cond: x.Uses == 1 9192 // result: (MOVWnop x) 9193 for { 9194 x := v.Args[0] 9195 if !(x.Uses == 1) { 9196 break 9197 } 9198 v.reset(OpARMMOVWnop) 9199 v.AddArg(x) 9200 return true 9201 } 9202 // match: (MOVWreg (MOVWconst [c])) 9203 // cond: 9204 // result: (MOVWconst [c]) 9205 for { 9206 v_0 := v.Args[0] 9207 if v_0.Op != OpARMMOVWconst { 9208 break 9209 } 9210 c := v_0.AuxInt 9211 v.reset(OpARMMOVWconst) 9212 v.AuxInt = c 9213 return true 9214 } 9215 return false 9216 } 9217 func rewriteValueARM_OpARMMOVWstore_0(v *Value) bool { 9218 b := v.Block 9219 _ = b 9220 config := b.Func.Config 9221 _ = config 9222 // match: (MOVWstore [off1] {sym} (ADDconst [off2] ptr) val mem) 9223 // cond: 9224 // result: (MOVWstore [off1+off2] {sym} ptr val mem) 9225 for { 9226 off1 := v.AuxInt 9227 sym := v.Aux 9228 _ = v.Args[2] 9229 v_0 := v.Args[0] 9230 if v_0.Op != OpARMADDconst { 9231 break 9232 } 9233 off2 := v_0.AuxInt 9234 ptr := v_0.Args[0] 9235 val := v.Args[1] 9236 mem := v.Args[2] 9237 v.reset(OpARMMOVWstore) 9238 v.AuxInt = off1 + off2 9239 v.Aux = sym 9240 v.AddArg(ptr) 9241 v.AddArg(val) 9242 v.AddArg(mem) 9243 return true 9244 } 9245 // match: (MOVWstore [off1] {sym} (SUBconst [off2] ptr) val mem) 9246 // cond: 9247 // result: (MOVWstore [off1-off2] {sym} ptr val mem) 9248 for { 9249 off1 := v.AuxInt 9250 sym := v.Aux 9251 _ = v.Args[2] 9252 v_0 := v.Args[0] 9253 if v_0.Op != OpARMSUBconst { 9254 break 9255 } 9256 off2 := v_0.AuxInt 9257 ptr := v_0.Args[0] 9258 val := v.Args[1] 9259 mem := v.Args[2] 9260 v.reset(OpARMMOVWstore) 9261 v.AuxInt = off1 - off2 9262 v.Aux = sym 9263 v.AddArg(ptr) 9264 v.AddArg(val) 9265 v.AddArg(mem) 9266 return true 9267 } 9268 // match: (MOVWstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem) 9269 // cond: canMergeSym(sym1,sym2) 9270 // result: (MOVWstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem) 9271 for { 9272 off1 := v.AuxInt 9273 sym1 := v.Aux 9274 _ = v.Args[2] 9275 v_0 := v.Args[0] 9276 if v_0.Op != OpARMMOVWaddr { 9277 break 9278 } 9279 off2 := v_0.AuxInt 9280 sym2 := v_0.Aux 9281 ptr := v_0.Args[0] 9282 val := v.Args[1] 9283 mem := v.Args[2] 9284 if !(canMergeSym(sym1, sym2)) { 9285 break 9286 } 9287 v.reset(OpARMMOVWstore) 9288 v.AuxInt = off1 + off2 9289 v.Aux = mergeSym(sym1, sym2) 9290 v.AddArg(ptr) 9291 v.AddArg(val) 9292 v.AddArg(mem) 9293 return true 9294 } 9295 // match: (MOVWstore [0] {sym} (ADD ptr idx) val mem) 9296 // cond: sym == nil && !config.nacl 9297 // result: (MOVWstoreidx ptr idx val mem) 9298 for { 9299 if v.AuxInt != 0 { 9300 break 9301 } 9302 sym := v.Aux 9303 _ = v.Args[2] 9304 v_0 := v.Args[0] 9305 if v_0.Op != OpARMADD { 9306 break 9307 } 9308 _ = v_0.Args[1] 9309 ptr := v_0.Args[0] 9310 idx := v_0.Args[1] 9311 val := v.Args[1] 9312 mem := v.Args[2] 9313 if !(sym == nil && !config.nacl) { 9314 break 9315 } 9316 v.reset(OpARMMOVWstoreidx) 9317 v.AddArg(ptr) 9318 v.AddArg(idx) 9319 v.AddArg(val) 9320 v.AddArg(mem) 9321 return true 9322 } 9323 // match: (MOVWstore [0] {sym} (ADDshiftLL ptr idx [c]) val mem) 9324 // cond: sym == nil && !config.nacl 9325 // result: (MOVWstoreshiftLL ptr idx [c] val mem) 9326 for { 9327 if v.AuxInt != 0 { 9328 break 9329 } 9330 sym := v.Aux 9331 _ = v.Args[2] 9332 v_0 := v.Args[0] 9333 if v_0.Op != OpARMADDshiftLL { 9334 break 9335 } 9336 c := v_0.AuxInt 9337 _ = v_0.Args[1] 9338 ptr := v_0.Args[0] 9339 idx := v_0.Args[1] 9340 val := v.Args[1] 9341 mem := v.Args[2] 9342 if !(sym == nil && !config.nacl) { 9343 break 9344 } 9345 v.reset(OpARMMOVWstoreshiftLL) 9346 v.AuxInt = c 9347 v.AddArg(ptr) 9348 v.AddArg(idx) 9349 v.AddArg(val) 9350 v.AddArg(mem) 9351 return true 9352 } 9353 // match: (MOVWstore [0] {sym} (ADDshiftRL ptr idx [c]) val mem) 9354 // cond: sym == nil && !config.nacl 9355 // result: (MOVWstoreshiftRL ptr idx [c] val mem) 9356 for { 9357 if v.AuxInt != 0 { 9358 break 9359 } 9360 sym := v.Aux 9361 _ = v.Args[2] 9362 v_0 := v.Args[0] 9363 if v_0.Op != OpARMADDshiftRL { 9364 break 9365 } 9366 c := v_0.AuxInt 9367 _ = v_0.Args[1] 9368 ptr := v_0.Args[0] 9369 idx := v_0.Args[1] 9370 val := v.Args[1] 9371 mem := v.Args[2] 9372 if !(sym == nil && !config.nacl) { 9373 break 9374 } 9375 v.reset(OpARMMOVWstoreshiftRL) 9376 v.AuxInt = c 9377 v.AddArg(ptr) 9378 v.AddArg(idx) 9379 v.AddArg(val) 9380 v.AddArg(mem) 9381 return true 9382 } 9383 // match: (MOVWstore [0] {sym} (ADDshiftRA ptr idx [c]) val mem) 9384 // cond: sym == nil && !config.nacl 9385 // result: (MOVWstoreshiftRA ptr idx [c] val mem) 9386 for { 9387 if v.AuxInt != 0 { 9388 break 9389 } 9390 sym := v.Aux 9391 _ = v.Args[2] 9392 v_0 := v.Args[0] 9393 if v_0.Op != OpARMADDshiftRA { 9394 break 9395 } 9396 c := v_0.AuxInt 9397 _ = v_0.Args[1] 9398 ptr := v_0.Args[0] 9399 idx := v_0.Args[1] 9400 val := v.Args[1] 9401 mem := v.Args[2] 9402 if !(sym == nil && !config.nacl) { 9403 break 9404 } 9405 v.reset(OpARMMOVWstoreshiftRA) 9406 v.AuxInt = c 9407 v.AddArg(ptr) 9408 v.AddArg(idx) 9409 v.AddArg(val) 9410 v.AddArg(mem) 9411 return true 9412 } 9413 return false 9414 } 9415 func rewriteValueARM_OpARMMOVWstoreidx_0(v *Value) bool { 9416 // match: (MOVWstoreidx ptr (MOVWconst [c]) val mem) 9417 // cond: 9418 // result: (MOVWstore [c] ptr val mem) 9419 for { 9420 _ = v.Args[3] 9421 ptr := v.Args[0] 9422 v_1 := v.Args[1] 9423 if v_1.Op != OpARMMOVWconst { 9424 break 9425 } 9426 c := v_1.AuxInt 9427 val := v.Args[2] 9428 mem := v.Args[3] 9429 v.reset(OpARMMOVWstore) 9430 v.AuxInt = c 9431 v.AddArg(ptr) 9432 v.AddArg(val) 9433 v.AddArg(mem) 9434 return true 9435 } 9436 // match: (MOVWstoreidx (MOVWconst [c]) ptr val mem) 9437 // cond: 9438 // result: (MOVWstore [c] ptr val mem) 9439 for { 9440 _ = v.Args[3] 9441 v_0 := v.Args[0] 9442 if v_0.Op != OpARMMOVWconst { 9443 break 9444 } 9445 c := v_0.AuxInt 9446 ptr := v.Args[1] 9447 val := v.Args[2] 9448 mem := v.Args[3] 9449 v.reset(OpARMMOVWstore) 9450 v.AuxInt = c 9451 v.AddArg(ptr) 9452 v.AddArg(val) 9453 v.AddArg(mem) 9454 return true 9455 } 9456 // match: (MOVWstoreidx ptr (SLLconst idx [c]) val mem) 9457 // cond: 9458 // result: (MOVWstoreshiftLL ptr idx [c] val mem) 9459 for { 9460 _ = v.Args[3] 9461 ptr := v.Args[0] 9462 v_1 := v.Args[1] 9463 if v_1.Op != OpARMSLLconst { 9464 break 9465 } 9466 c := v_1.AuxInt 9467 idx := v_1.Args[0] 9468 val := v.Args[2] 9469 mem := v.Args[3] 9470 v.reset(OpARMMOVWstoreshiftLL) 9471 v.AuxInt = c 9472 v.AddArg(ptr) 9473 v.AddArg(idx) 9474 v.AddArg(val) 9475 v.AddArg(mem) 9476 return true 9477 } 9478 // match: (MOVWstoreidx (SLLconst idx [c]) ptr val mem) 9479 // cond: 9480 // result: (MOVWstoreshiftLL ptr idx [c] val mem) 9481 for { 9482 _ = v.Args[3] 9483 v_0 := v.Args[0] 9484 if v_0.Op != OpARMSLLconst { 9485 break 9486 } 9487 c := v_0.AuxInt 9488 idx := v_0.Args[0] 9489 ptr := v.Args[1] 9490 val := v.Args[2] 9491 mem := v.Args[3] 9492 v.reset(OpARMMOVWstoreshiftLL) 9493 v.AuxInt = c 9494 v.AddArg(ptr) 9495 v.AddArg(idx) 9496 v.AddArg(val) 9497 v.AddArg(mem) 9498 return true 9499 } 9500 // match: (MOVWstoreidx ptr (SRLconst idx [c]) val mem) 9501 // cond: 9502 // result: (MOVWstoreshiftRL ptr idx [c] val mem) 9503 for { 9504 _ = v.Args[3] 9505 ptr := v.Args[0] 9506 v_1 := v.Args[1] 9507 if v_1.Op != OpARMSRLconst { 9508 break 9509 } 9510 c := v_1.AuxInt 9511 idx := v_1.Args[0] 9512 val := v.Args[2] 9513 mem := v.Args[3] 9514 v.reset(OpARMMOVWstoreshiftRL) 9515 v.AuxInt = c 9516 v.AddArg(ptr) 9517 v.AddArg(idx) 9518 v.AddArg(val) 9519 v.AddArg(mem) 9520 return true 9521 } 9522 // match: (MOVWstoreidx (SRLconst idx [c]) ptr val mem) 9523 // cond: 9524 // result: (MOVWstoreshiftRL ptr idx [c] val mem) 9525 for { 9526 _ = v.Args[3] 9527 v_0 := v.Args[0] 9528 if v_0.Op != OpARMSRLconst { 9529 break 9530 } 9531 c := v_0.AuxInt 9532 idx := v_0.Args[0] 9533 ptr := v.Args[1] 9534 val := v.Args[2] 9535 mem := v.Args[3] 9536 v.reset(OpARMMOVWstoreshiftRL) 9537 v.AuxInt = c 9538 v.AddArg(ptr) 9539 v.AddArg(idx) 9540 v.AddArg(val) 9541 v.AddArg(mem) 9542 return true 9543 } 9544 // match: (MOVWstoreidx ptr (SRAconst idx [c]) val mem) 9545 // cond: 9546 // result: (MOVWstoreshiftRA ptr idx [c] val mem) 9547 for { 9548 _ = v.Args[3] 9549 ptr := v.Args[0] 9550 v_1 := v.Args[1] 9551 if v_1.Op != OpARMSRAconst { 9552 break 9553 } 9554 c := v_1.AuxInt 9555 idx := v_1.Args[0] 9556 val := v.Args[2] 9557 mem := v.Args[3] 9558 v.reset(OpARMMOVWstoreshiftRA) 9559 v.AuxInt = c 9560 v.AddArg(ptr) 9561 v.AddArg(idx) 9562 v.AddArg(val) 9563 v.AddArg(mem) 9564 return true 9565 } 9566 // match: (MOVWstoreidx (SRAconst idx [c]) ptr val mem) 9567 // cond: 9568 // result: (MOVWstoreshiftRA ptr idx [c] val mem) 9569 for { 9570 _ = v.Args[3] 9571 v_0 := v.Args[0] 9572 if v_0.Op != OpARMSRAconst { 9573 break 9574 } 9575 c := v_0.AuxInt 9576 idx := v_0.Args[0] 9577 ptr := v.Args[1] 9578 val := v.Args[2] 9579 mem := v.Args[3] 9580 v.reset(OpARMMOVWstoreshiftRA) 9581 v.AuxInt = c 9582 v.AddArg(ptr) 9583 v.AddArg(idx) 9584 v.AddArg(val) 9585 v.AddArg(mem) 9586 return true 9587 } 9588 return false 9589 } 9590 func rewriteValueARM_OpARMMOVWstoreshiftLL_0(v *Value) bool { 9591 // match: (MOVWstoreshiftLL ptr (MOVWconst [c]) [d] val mem) 9592 // cond: 9593 // result: (MOVWstore [int64(uint32(c)<<uint64(d))] ptr val mem) 9594 for { 9595 d := v.AuxInt 9596 _ = v.Args[3] 9597 ptr := v.Args[0] 9598 v_1 := v.Args[1] 9599 if v_1.Op != OpARMMOVWconst { 9600 break 9601 } 9602 c := v_1.AuxInt 9603 val := v.Args[2] 9604 mem := v.Args[3] 9605 v.reset(OpARMMOVWstore) 9606 v.AuxInt = int64(uint32(c) << uint64(d)) 9607 v.AddArg(ptr) 9608 v.AddArg(val) 9609 v.AddArg(mem) 9610 return true 9611 } 9612 return false 9613 } 9614 func rewriteValueARM_OpARMMOVWstoreshiftRA_0(v *Value) bool { 9615 // match: (MOVWstoreshiftRA ptr (MOVWconst [c]) [d] val mem) 9616 // cond: 9617 // result: (MOVWstore [int64(int32(c)>>uint64(d))] ptr val mem) 9618 for { 9619 d := v.AuxInt 9620 _ = v.Args[3] 9621 ptr := v.Args[0] 9622 v_1 := v.Args[1] 9623 if v_1.Op != OpARMMOVWconst { 9624 break 9625 } 9626 c := v_1.AuxInt 9627 val := v.Args[2] 9628 mem := v.Args[3] 9629 v.reset(OpARMMOVWstore) 9630 v.AuxInt = int64(int32(c) >> uint64(d)) 9631 v.AddArg(ptr) 9632 v.AddArg(val) 9633 v.AddArg(mem) 9634 return true 9635 } 9636 return false 9637 } 9638 func rewriteValueARM_OpARMMOVWstoreshiftRL_0(v *Value) bool { 9639 // match: (MOVWstoreshiftRL ptr (MOVWconst [c]) [d] val mem) 9640 // cond: 9641 // result: (MOVWstore [int64(uint32(c)>>uint64(d))] ptr val mem) 9642 for { 9643 d := v.AuxInt 9644 _ = v.Args[3] 9645 ptr := v.Args[0] 9646 v_1 := v.Args[1] 9647 if v_1.Op != OpARMMOVWconst { 9648 break 9649 } 9650 c := v_1.AuxInt 9651 val := v.Args[2] 9652 mem := v.Args[3] 9653 v.reset(OpARMMOVWstore) 9654 v.AuxInt = int64(uint32(c) >> uint64(d)) 9655 v.AddArg(ptr) 9656 v.AddArg(val) 9657 v.AddArg(mem) 9658 return true 9659 } 9660 return false 9661 } 9662 func rewriteValueARM_OpARMMUL_0(v *Value) bool { 9663 // match: (MUL x (MOVWconst [c])) 9664 // cond: int32(c) == -1 9665 // result: (RSBconst [0] x) 9666 for { 9667 _ = v.Args[1] 9668 x := v.Args[0] 9669 v_1 := v.Args[1] 9670 if v_1.Op != OpARMMOVWconst { 9671 break 9672 } 9673 c := v_1.AuxInt 9674 if !(int32(c) == -1) { 9675 break 9676 } 9677 v.reset(OpARMRSBconst) 9678 v.AuxInt = 0 9679 v.AddArg(x) 9680 return true 9681 } 9682 // match: (MUL (MOVWconst [c]) x) 9683 // cond: int32(c) == -1 9684 // result: (RSBconst [0] x) 9685 for { 9686 _ = v.Args[1] 9687 v_0 := v.Args[0] 9688 if v_0.Op != OpARMMOVWconst { 9689 break 9690 } 9691 c := v_0.AuxInt 9692 x := v.Args[1] 9693 if !(int32(c) == -1) { 9694 break 9695 } 9696 v.reset(OpARMRSBconst) 9697 v.AuxInt = 0 9698 v.AddArg(x) 9699 return true 9700 } 9701 // match: (MUL _ (MOVWconst [0])) 9702 // cond: 9703 // result: (MOVWconst [0]) 9704 for { 9705 _ = v.Args[1] 9706 v_1 := v.Args[1] 9707 if v_1.Op != OpARMMOVWconst { 9708 break 9709 } 9710 if v_1.AuxInt != 0 { 9711 break 9712 } 9713 v.reset(OpARMMOVWconst) 9714 v.AuxInt = 0 9715 return true 9716 } 9717 // match: (MUL (MOVWconst [0]) _) 9718 // cond: 9719 // result: (MOVWconst [0]) 9720 for { 9721 _ = v.Args[1] 9722 v_0 := v.Args[0] 9723 if v_0.Op != OpARMMOVWconst { 9724 break 9725 } 9726 if v_0.AuxInt != 0 { 9727 break 9728 } 9729 v.reset(OpARMMOVWconst) 9730 v.AuxInt = 0 9731 return true 9732 } 9733 // match: (MUL x (MOVWconst [1])) 9734 // cond: 9735 // result: x 9736 for { 9737 _ = v.Args[1] 9738 x := v.Args[0] 9739 v_1 := v.Args[1] 9740 if v_1.Op != OpARMMOVWconst { 9741 break 9742 } 9743 if v_1.AuxInt != 1 { 9744 break 9745 } 9746 v.reset(OpCopy) 9747 v.Type = x.Type 9748 v.AddArg(x) 9749 return true 9750 } 9751 // match: (MUL (MOVWconst [1]) x) 9752 // cond: 9753 // result: x 9754 for { 9755 _ = v.Args[1] 9756 v_0 := v.Args[0] 9757 if v_0.Op != OpARMMOVWconst { 9758 break 9759 } 9760 if v_0.AuxInt != 1 { 9761 break 9762 } 9763 x := v.Args[1] 9764 v.reset(OpCopy) 9765 v.Type = x.Type 9766 v.AddArg(x) 9767 return true 9768 } 9769 // match: (MUL x (MOVWconst [c])) 9770 // cond: isPowerOfTwo(c) 9771 // result: (SLLconst [log2(c)] x) 9772 for { 9773 _ = v.Args[1] 9774 x := v.Args[0] 9775 v_1 := v.Args[1] 9776 if v_1.Op != OpARMMOVWconst { 9777 break 9778 } 9779 c := v_1.AuxInt 9780 if !(isPowerOfTwo(c)) { 9781 break 9782 } 9783 v.reset(OpARMSLLconst) 9784 v.AuxInt = log2(c) 9785 v.AddArg(x) 9786 return true 9787 } 9788 // match: (MUL (MOVWconst [c]) x) 9789 // cond: isPowerOfTwo(c) 9790 // result: (SLLconst [log2(c)] x) 9791 for { 9792 _ = v.Args[1] 9793 v_0 := v.Args[0] 9794 if v_0.Op != OpARMMOVWconst { 9795 break 9796 } 9797 c := v_0.AuxInt 9798 x := v.Args[1] 9799 if !(isPowerOfTwo(c)) { 9800 break 9801 } 9802 v.reset(OpARMSLLconst) 9803 v.AuxInt = log2(c) 9804 v.AddArg(x) 9805 return true 9806 } 9807 // match: (MUL x (MOVWconst [c])) 9808 // cond: isPowerOfTwo(c-1) && int32(c) >= 3 9809 // result: (ADDshiftLL x x [log2(c-1)]) 9810 for { 9811 _ = v.Args[1] 9812 x := v.Args[0] 9813 v_1 := v.Args[1] 9814 if v_1.Op != OpARMMOVWconst { 9815 break 9816 } 9817 c := v_1.AuxInt 9818 if !(isPowerOfTwo(c-1) && int32(c) >= 3) { 9819 break 9820 } 9821 v.reset(OpARMADDshiftLL) 9822 v.AuxInt = log2(c - 1) 9823 v.AddArg(x) 9824 v.AddArg(x) 9825 return true 9826 } 9827 // match: (MUL (MOVWconst [c]) x) 9828 // cond: isPowerOfTwo(c-1) && int32(c) >= 3 9829 // result: (ADDshiftLL x x [log2(c-1)]) 9830 for { 9831 _ = v.Args[1] 9832 v_0 := v.Args[0] 9833 if v_0.Op != OpARMMOVWconst { 9834 break 9835 } 9836 c := v_0.AuxInt 9837 x := v.Args[1] 9838 if !(isPowerOfTwo(c-1) && int32(c) >= 3) { 9839 break 9840 } 9841 v.reset(OpARMADDshiftLL) 9842 v.AuxInt = log2(c - 1) 9843 v.AddArg(x) 9844 v.AddArg(x) 9845 return true 9846 } 9847 return false 9848 } 9849 func rewriteValueARM_OpARMMUL_10(v *Value) bool { 9850 b := v.Block 9851 _ = b 9852 // match: (MUL x (MOVWconst [c])) 9853 // cond: isPowerOfTwo(c+1) && int32(c) >= 7 9854 // result: (RSBshiftLL x x [log2(c+1)]) 9855 for { 9856 _ = v.Args[1] 9857 x := v.Args[0] 9858 v_1 := v.Args[1] 9859 if v_1.Op != OpARMMOVWconst { 9860 break 9861 } 9862 c := v_1.AuxInt 9863 if !(isPowerOfTwo(c+1) && int32(c) >= 7) { 9864 break 9865 } 9866 v.reset(OpARMRSBshiftLL) 9867 v.AuxInt = log2(c + 1) 9868 v.AddArg(x) 9869 v.AddArg(x) 9870 return true 9871 } 9872 // match: (MUL (MOVWconst [c]) x) 9873 // cond: isPowerOfTwo(c+1) && int32(c) >= 7 9874 // result: (RSBshiftLL x x [log2(c+1)]) 9875 for { 9876 _ = v.Args[1] 9877 v_0 := v.Args[0] 9878 if v_0.Op != OpARMMOVWconst { 9879 break 9880 } 9881 c := v_0.AuxInt 9882 x := v.Args[1] 9883 if !(isPowerOfTwo(c+1) && int32(c) >= 7) { 9884 break 9885 } 9886 v.reset(OpARMRSBshiftLL) 9887 v.AuxInt = log2(c + 1) 9888 v.AddArg(x) 9889 v.AddArg(x) 9890 return true 9891 } 9892 // match: (MUL x (MOVWconst [c])) 9893 // cond: c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c) 9894 // result: (SLLconst [log2(c/3)] (ADDshiftLL <x.Type> x x [1])) 9895 for { 9896 _ = v.Args[1] 9897 x := v.Args[0] 9898 v_1 := v.Args[1] 9899 if v_1.Op != OpARMMOVWconst { 9900 break 9901 } 9902 c := v_1.AuxInt 9903 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) { 9904 break 9905 } 9906 v.reset(OpARMSLLconst) 9907 v.AuxInt = log2(c / 3) 9908 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9909 v0.AuxInt = 1 9910 v0.AddArg(x) 9911 v0.AddArg(x) 9912 v.AddArg(v0) 9913 return true 9914 } 9915 // match: (MUL (MOVWconst [c]) x) 9916 // cond: c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c) 9917 // result: (SLLconst [log2(c/3)] (ADDshiftLL <x.Type> x x [1])) 9918 for { 9919 _ = v.Args[1] 9920 v_0 := v.Args[0] 9921 if v_0.Op != OpARMMOVWconst { 9922 break 9923 } 9924 c := v_0.AuxInt 9925 x := v.Args[1] 9926 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) { 9927 break 9928 } 9929 v.reset(OpARMSLLconst) 9930 v.AuxInt = log2(c / 3) 9931 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9932 v0.AuxInt = 1 9933 v0.AddArg(x) 9934 v0.AddArg(x) 9935 v.AddArg(v0) 9936 return true 9937 } 9938 // match: (MUL x (MOVWconst [c])) 9939 // cond: c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c) 9940 // result: (SLLconst [log2(c/5)] (ADDshiftLL <x.Type> x x [2])) 9941 for { 9942 _ = v.Args[1] 9943 x := v.Args[0] 9944 v_1 := v.Args[1] 9945 if v_1.Op != OpARMMOVWconst { 9946 break 9947 } 9948 c := v_1.AuxInt 9949 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) { 9950 break 9951 } 9952 v.reset(OpARMSLLconst) 9953 v.AuxInt = log2(c / 5) 9954 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9955 v0.AuxInt = 2 9956 v0.AddArg(x) 9957 v0.AddArg(x) 9958 v.AddArg(v0) 9959 return true 9960 } 9961 // match: (MUL (MOVWconst [c]) x) 9962 // cond: c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c) 9963 // result: (SLLconst [log2(c/5)] (ADDshiftLL <x.Type> x x [2])) 9964 for { 9965 _ = v.Args[1] 9966 v_0 := v.Args[0] 9967 if v_0.Op != OpARMMOVWconst { 9968 break 9969 } 9970 c := v_0.AuxInt 9971 x := v.Args[1] 9972 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) { 9973 break 9974 } 9975 v.reset(OpARMSLLconst) 9976 v.AuxInt = log2(c / 5) 9977 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 9978 v0.AuxInt = 2 9979 v0.AddArg(x) 9980 v0.AddArg(x) 9981 v.AddArg(v0) 9982 return true 9983 } 9984 // match: (MUL x (MOVWconst [c])) 9985 // cond: c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c) 9986 // result: (SLLconst [log2(c/7)] (RSBshiftLL <x.Type> x x [3])) 9987 for { 9988 _ = v.Args[1] 9989 x := v.Args[0] 9990 v_1 := v.Args[1] 9991 if v_1.Op != OpARMMOVWconst { 9992 break 9993 } 9994 c := v_1.AuxInt 9995 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) { 9996 break 9997 } 9998 v.reset(OpARMSLLconst) 9999 v.AuxInt = log2(c / 7) 10000 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 10001 v0.AuxInt = 3 10002 v0.AddArg(x) 10003 v0.AddArg(x) 10004 v.AddArg(v0) 10005 return true 10006 } 10007 // match: (MUL (MOVWconst [c]) x) 10008 // cond: c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c) 10009 // result: (SLLconst [log2(c/7)] (RSBshiftLL <x.Type> x x [3])) 10010 for { 10011 _ = v.Args[1] 10012 v_0 := v.Args[0] 10013 if v_0.Op != OpARMMOVWconst { 10014 break 10015 } 10016 c := v_0.AuxInt 10017 x := v.Args[1] 10018 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) { 10019 break 10020 } 10021 v.reset(OpARMSLLconst) 10022 v.AuxInt = log2(c / 7) 10023 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 10024 v0.AuxInt = 3 10025 v0.AddArg(x) 10026 v0.AddArg(x) 10027 v.AddArg(v0) 10028 return true 10029 } 10030 // match: (MUL x (MOVWconst [c])) 10031 // cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c) 10032 // result: (SLLconst [log2(c/9)] (ADDshiftLL <x.Type> x x [3])) 10033 for { 10034 _ = v.Args[1] 10035 x := v.Args[0] 10036 v_1 := v.Args[1] 10037 if v_1.Op != OpARMMOVWconst { 10038 break 10039 } 10040 c := v_1.AuxInt 10041 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) { 10042 break 10043 } 10044 v.reset(OpARMSLLconst) 10045 v.AuxInt = log2(c / 9) 10046 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10047 v0.AuxInt = 3 10048 v0.AddArg(x) 10049 v0.AddArg(x) 10050 v.AddArg(v0) 10051 return true 10052 } 10053 // match: (MUL (MOVWconst [c]) x) 10054 // cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c) 10055 // result: (SLLconst [log2(c/9)] (ADDshiftLL <x.Type> x x [3])) 10056 for { 10057 _ = v.Args[1] 10058 v_0 := v.Args[0] 10059 if v_0.Op != OpARMMOVWconst { 10060 break 10061 } 10062 c := v_0.AuxInt 10063 x := v.Args[1] 10064 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) { 10065 break 10066 } 10067 v.reset(OpARMSLLconst) 10068 v.AuxInt = log2(c / 9) 10069 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10070 v0.AuxInt = 3 10071 v0.AddArg(x) 10072 v0.AddArg(x) 10073 v.AddArg(v0) 10074 return true 10075 } 10076 return false 10077 } 10078 func rewriteValueARM_OpARMMUL_20(v *Value) bool { 10079 // match: (MUL (MOVWconst [c]) (MOVWconst [d])) 10080 // cond: 10081 // result: (MOVWconst [int64(int32(c*d))]) 10082 for { 10083 _ = v.Args[1] 10084 v_0 := v.Args[0] 10085 if v_0.Op != OpARMMOVWconst { 10086 break 10087 } 10088 c := v_0.AuxInt 10089 v_1 := v.Args[1] 10090 if v_1.Op != OpARMMOVWconst { 10091 break 10092 } 10093 d := v_1.AuxInt 10094 v.reset(OpARMMOVWconst) 10095 v.AuxInt = int64(int32(c * d)) 10096 return true 10097 } 10098 // match: (MUL (MOVWconst [d]) (MOVWconst [c])) 10099 // cond: 10100 // result: (MOVWconst [int64(int32(c*d))]) 10101 for { 10102 _ = v.Args[1] 10103 v_0 := v.Args[0] 10104 if v_0.Op != OpARMMOVWconst { 10105 break 10106 } 10107 d := v_0.AuxInt 10108 v_1 := v.Args[1] 10109 if v_1.Op != OpARMMOVWconst { 10110 break 10111 } 10112 c := v_1.AuxInt 10113 v.reset(OpARMMOVWconst) 10114 v.AuxInt = int64(int32(c * d)) 10115 return true 10116 } 10117 return false 10118 } 10119 func rewriteValueARM_OpARMMULA_0(v *Value) bool { 10120 b := v.Block 10121 _ = b 10122 // match: (MULA x (MOVWconst [c]) a) 10123 // cond: int32(c) == -1 10124 // result: (SUB a x) 10125 for { 10126 _ = v.Args[2] 10127 x := v.Args[0] 10128 v_1 := v.Args[1] 10129 if v_1.Op != OpARMMOVWconst { 10130 break 10131 } 10132 c := v_1.AuxInt 10133 a := v.Args[2] 10134 if !(int32(c) == -1) { 10135 break 10136 } 10137 v.reset(OpARMSUB) 10138 v.AddArg(a) 10139 v.AddArg(x) 10140 return true 10141 } 10142 // match: (MULA _ (MOVWconst [0]) a) 10143 // cond: 10144 // result: a 10145 for { 10146 _ = v.Args[2] 10147 v_1 := v.Args[1] 10148 if v_1.Op != OpARMMOVWconst { 10149 break 10150 } 10151 if v_1.AuxInt != 0 { 10152 break 10153 } 10154 a := v.Args[2] 10155 v.reset(OpCopy) 10156 v.Type = a.Type 10157 v.AddArg(a) 10158 return true 10159 } 10160 // match: (MULA x (MOVWconst [1]) a) 10161 // cond: 10162 // result: (ADD x a) 10163 for { 10164 _ = v.Args[2] 10165 x := v.Args[0] 10166 v_1 := v.Args[1] 10167 if v_1.Op != OpARMMOVWconst { 10168 break 10169 } 10170 if v_1.AuxInt != 1 { 10171 break 10172 } 10173 a := v.Args[2] 10174 v.reset(OpARMADD) 10175 v.AddArg(x) 10176 v.AddArg(a) 10177 return true 10178 } 10179 // match: (MULA x (MOVWconst [c]) a) 10180 // cond: isPowerOfTwo(c) 10181 // result: (ADD (SLLconst <x.Type> [log2(c)] x) a) 10182 for { 10183 _ = v.Args[2] 10184 x := v.Args[0] 10185 v_1 := v.Args[1] 10186 if v_1.Op != OpARMMOVWconst { 10187 break 10188 } 10189 c := v_1.AuxInt 10190 a := v.Args[2] 10191 if !(isPowerOfTwo(c)) { 10192 break 10193 } 10194 v.reset(OpARMADD) 10195 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10196 v0.AuxInt = log2(c) 10197 v0.AddArg(x) 10198 v.AddArg(v0) 10199 v.AddArg(a) 10200 return true 10201 } 10202 // match: (MULA x (MOVWconst [c]) a) 10203 // cond: isPowerOfTwo(c-1) && int32(c) >= 3 10204 // result: (ADD (ADDshiftLL <x.Type> x x [log2(c-1)]) a) 10205 for { 10206 _ = v.Args[2] 10207 x := v.Args[0] 10208 v_1 := v.Args[1] 10209 if v_1.Op != OpARMMOVWconst { 10210 break 10211 } 10212 c := v_1.AuxInt 10213 a := v.Args[2] 10214 if !(isPowerOfTwo(c-1) && int32(c) >= 3) { 10215 break 10216 } 10217 v.reset(OpARMADD) 10218 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10219 v0.AuxInt = log2(c - 1) 10220 v0.AddArg(x) 10221 v0.AddArg(x) 10222 v.AddArg(v0) 10223 v.AddArg(a) 10224 return true 10225 } 10226 // match: (MULA x (MOVWconst [c]) a) 10227 // cond: isPowerOfTwo(c+1) && int32(c) >= 7 10228 // result: (ADD (RSBshiftLL <x.Type> x x [log2(c+1)]) a) 10229 for { 10230 _ = v.Args[2] 10231 x := v.Args[0] 10232 v_1 := v.Args[1] 10233 if v_1.Op != OpARMMOVWconst { 10234 break 10235 } 10236 c := v_1.AuxInt 10237 a := v.Args[2] 10238 if !(isPowerOfTwo(c+1) && int32(c) >= 7) { 10239 break 10240 } 10241 v.reset(OpARMADD) 10242 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 10243 v0.AuxInt = log2(c + 1) 10244 v0.AddArg(x) 10245 v0.AddArg(x) 10246 v.AddArg(v0) 10247 v.AddArg(a) 10248 return true 10249 } 10250 // match: (MULA x (MOVWconst [c]) a) 10251 // cond: c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c) 10252 // result: (ADD (SLLconst <x.Type> [log2(c/3)] (ADDshiftLL <x.Type> x x [1])) a) 10253 for { 10254 _ = v.Args[2] 10255 x := v.Args[0] 10256 v_1 := v.Args[1] 10257 if v_1.Op != OpARMMOVWconst { 10258 break 10259 } 10260 c := v_1.AuxInt 10261 a := v.Args[2] 10262 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) { 10263 break 10264 } 10265 v.reset(OpARMADD) 10266 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10267 v0.AuxInt = log2(c / 3) 10268 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10269 v1.AuxInt = 1 10270 v1.AddArg(x) 10271 v1.AddArg(x) 10272 v0.AddArg(v1) 10273 v.AddArg(v0) 10274 v.AddArg(a) 10275 return true 10276 } 10277 // match: (MULA x (MOVWconst [c]) a) 10278 // cond: c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c) 10279 // result: (ADD (SLLconst <x.Type> [log2(c/5)] (ADDshiftLL <x.Type> x x [2])) a) 10280 for { 10281 _ = v.Args[2] 10282 x := v.Args[0] 10283 v_1 := v.Args[1] 10284 if v_1.Op != OpARMMOVWconst { 10285 break 10286 } 10287 c := v_1.AuxInt 10288 a := v.Args[2] 10289 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) { 10290 break 10291 } 10292 v.reset(OpARMADD) 10293 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10294 v0.AuxInt = log2(c / 5) 10295 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10296 v1.AuxInt = 2 10297 v1.AddArg(x) 10298 v1.AddArg(x) 10299 v0.AddArg(v1) 10300 v.AddArg(v0) 10301 v.AddArg(a) 10302 return true 10303 } 10304 // match: (MULA x (MOVWconst [c]) a) 10305 // cond: c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c) 10306 // result: (ADD (SLLconst <x.Type> [log2(c/7)] (RSBshiftLL <x.Type> x x [3])) a) 10307 for { 10308 _ = v.Args[2] 10309 x := v.Args[0] 10310 v_1 := v.Args[1] 10311 if v_1.Op != OpARMMOVWconst { 10312 break 10313 } 10314 c := v_1.AuxInt 10315 a := v.Args[2] 10316 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) { 10317 break 10318 } 10319 v.reset(OpARMADD) 10320 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10321 v0.AuxInt = log2(c / 7) 10322 v1 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 10323 v1.AuxInt = 3 10324 v1.AddArg(x) 10325 v1.AddArg(x) 10326 v0.AddArg(v1) 10327 v.AddArg(v0) 10328 v.AddArg(a) 10329 return true 10330 } 10331 // match: (MULA x (MOVWconst [c]) a) 10332 // cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c) 10333 // result: (ADD (SLLconst <x.Type> [log2(c/9)] (ADDshiftLL <x.Type> x x [3])) a) 10334 for { 10335 _ = v.Args[2] 10336 x := v.Args[0] 10337 v_1 := v.Args[1] 10338 if v_1.Op != OpARMMOVWconst { 10339 break 10340 } 10341 c := v_1.AuxInt 10342 a := v.Args[2] 10343 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) { 10344 break 10345 } 10346 v.reset(OpARMADD) 10347 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10348 v0.AuxInt = log2(c / 9) 10349 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10350 v1.AuxInt = 3 10351 v1.AddArg(x) 10352 v1.AddArg(x) 10353 v0.AddArg(v1) 10354 v.AddArg(v0) 10355 v.AddArg(a) 10356 return true 10357 } 10358 return false 10359 } 10360 func rewriteValueARM_OpARMMULA_10(v *Value) bool { 10361 b := v.Block 10362 _ = b 10363 // match: (MULA (MOVWconst [c]) x a) 10364 // cond: int32(c) == -1 10365 // result: (SUB a x) 10366 for { 10367 _ = v.Args[2] 10368 v_0 := v.Args[0] 10369 if v_0.Op != OpARMMOVWconst { 10370 break 10371 } 10372 c := v_0.AuxInt 10373 x := v.Args[1] 10374 a := v.Args[2] 10375 if !(int32(c) == -1) { 10376 break 10377 } 10378 v.reset(OpARMSUB) 10379 v.AddArg(a) 10380 v.AddArg(x) 10381 return true 10382 } 10383 // match: (MULA (MOVWconst [0]) _ a) 10384 // cond: 10385 // result: a 10386 for { 10387 _ = v.Args[2] 10388 v_0 := v.Args[0] 10389 if v_0.Op != OpARMMOVWconst { 10390 break 10391 } 10392 if v_0.AuxInt != 0 { 10393 break 10394 } 10395 a := v.Args[2] 10396 v.reset(OpCopy) 10397 v.Type = a.Type 10398 v.AddArg(a) 10399 return true 10400 } 10401 // match: (MULA (MOVWconst [1]) x a) 10402 // cond: 10403 // result: (ADD x a) 10404 for { 10405 _ = v.Args[2] 10406 v_0 := v.Args[0] 10407 if v_0.Op != OpARMMOVWconst { 10408 break 10409 } 10410 if v_0.AuxInt != 1 { 10411 break 10412 } 10413 x := v.Args[1] 10414 a := v.Args[2] 10415 v.reset(OpARMADD) 10416 v.AddArg(x) 10417 v.AddArg(a) 10418 return true 10419 } 10420 // match: (MULA (MOVWconst [c]) x a) 10421 // cond: isPowerOfTwo(c) 10422 // result: (ADD (SLLconst <x.Type> [log2(c)] x) a) 10423 for { 10424 _ = v.Args[2] 10425 v_0 := v.Args[0] 10426 if v_0.Op != OpARMMOVWconst { 10427 break 10428 } 10429 c := v_0.AuxInt 10430 x := v.Args[1] 10431 a := v.Args[2] 10432 if !(isPowerOfTwo(c)) { 10433 break 10434 } 10435 v.reset(OpARMADD) 10436 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10437 v0.AuxInt = log2(c) 10438 v0.AddArg(x) 10439 v.AddArg(v0) 10440 v.AddArg(a) 10441 return true 10442 } 10443 // match: (MULA (MOVWconst [c]) x a) 10444 // cond: isPowerOfTwo(c-1) && int32(c) >= 3 10445 // result: (ADD (ADDshiftLL <x.Type> x x [log2(c-1)]) a) 10446 for { 10447 _ = v.Args[2] 10448 v_0 := v.Args[0] 10449 if v_0.Op != OpARMMOVWconst { 10450 break 10451 } 10452 c := v_0.AuxInt 10453 x := v.Args[1] 10454 a := v.Args[2] 10455 if !(isPowerOfTwo(c-1) && int32(c) >= 3) { 10456 break 10457 } 10458 v.reset(OpARMADD) 10459 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10460 v0.AuxInt = log2(c - 1) 10461 v0.AddArg(x) 10462 v0.AddArg(x) 10463 v.AddArg(v0) 10464 v.AddArg(a) 10465 return true 10466 } 10467 // match: (MULA (MOVWconst [c]) x a) 10468 // cond: isPowerOfTwo(c+1) && int32(c) >= 7 10469 // result: (ADD (RSBshiftLL <x.Type> x x [log2(c+1)]) a) 10470 for { 10471 _ = v.Args[2] 10472 v_0 := v.Args[0] 10473 if v_0.Op != OpARMMOVWconst { 10474 break 10475 } 10476 c := v_0.AuxInt 10477 x := v.Args[1] 10478 a := v.Args[2] 10479 if !(isPowerOfTwo(c+1) && int32(c) >= 7) { 10480 break 10481 } 10482 v.reset(OpARMADD) 10483 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 10484 v0.AuxInt = log2(c + 1) 10485 v0.AddArg(x) 10486 v0.AddArg(x) 10487 v.AddArg(v0) 10488 v.AddArg(a) 10489 return true 10490 } 10491 // match: (MULA (MOVWconst [c]) x a) 10492 // cond: c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c) 10493 // result: (ADD (SLLconst <x.Type> [log2(c/3)] (ADDshiftLL <x.Type> x x [1])) a) 10494 for { 10495 _ = v.Args[2] 10496 v_0 := v.Args[0] 10497 if v_0.Op != OpARMMOVWconst { 10498 break 10499 } 10500 c := v_0.AuxInt 10501 x := v.Args[1] 10502 a := v.Args[2] 10503 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) { 10504 break 10505 } 10506 v.reset(OpARMADD) 10507 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10508 v0.AuxInt = log2(c / 3) 10509 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10510 v1.AuxInt = 1 10511 v1.AddArg(x) 10512 v1.AddArg(x) 10513 v0.AddArg(v1) 10514 v.AddArg(v0) 10515 v.AddArg(a) 10516 return true 10517 } 10518 // match: (MULA (MOVWconst [c]) x a) 10519 // cond: c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c) 10520 // result: (ADD (SLLconst <x.Type> [log2(c/5)] (ADDshiftLL <x.Type> x x [2])) a) 10521 for { 10522 _ = v.Args[2] 10523 v_0 := v.Args[0] 10524 if v_0.Op != OpARMMOVWconst { 10525 break 10526 } 10527 c := v_0.AuxInt 10528 x := v.Args[1] 10529 a := v.Args[2] 10530 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) { 10531 break 10532 } 10533 v.reset(OpARMADD) 10534 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10535 v0.AuxInt = log2(c / 5) 10536 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10537 v1.AuxInt = 2 10538 v1.AddArg(x) 10539 v1.AddArg(x) 10540 v0.AddArg(v1) 10541 v.AddArg(v0) 10542 v.AddArg(a) 10543 return true 10544 } 10545 // match: (MULA (MOVWconst [c]) x a) 10546 // cond: c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c) 10547 // result: (ADD (SLLconst <x.Type> [log2(c/7)] (RSBshiftLL <x.Type> x x [3])) a) 10548 for { 10549 _ = v.Args[2] 10550 v_0 := v.Args[0] 10551 if v_0.Op != OpARMMOVWconst { 10552 break 10553 } 10554 c := v_0.AuxInt 10555 x := v.Args[1] 10556 a := v.Args[2] 10557 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) { 10558 break 10559 } 10560 v.reset(OpARMADD) 10561 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10562 v0.AuxInt = log2(c / 7) 10563 v1 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 10564 v1.AuxInt = 3 10565 v1.AddArg(x) 10566 v1.AddArg(x) 10567 v0.AddArg(v1) 10568 v.AddArg(v0) 10569 v.AddArg(a) 10570 return true 10571 } 10572 // match: (MULA (MOVWconst [c]) x a) 10573 // cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c) 10574 // result: (ADD (SLLconst <x.Type> [log2(c/9)] (ADDshiftLL <x.Type> x x [3])) a) 10575 for { 10576 _ = v.Args[2] 10577 v_0 := v.Args[0] 10578 if v_0.Op != OpARMMOVWconst { 10579 break 10580 } 10581 c := v_0.AuxInt 10582 x := v.Args[1] 10583 a := v.Args[2] 10584 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) { 10585 break 10586 } 10587 v.reset(OpARMADD) 10588 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10589 v0.AuxInt = log2(c / 9) 10590 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10591 v1.AuxInt = 3 10592 v1.AddArg(x) 10593 v1.AddArg(x) 10594 v0.AddArg(v1) 10595 v.AddArg(v0) 10596 v.AddArg(a) 10597 return true 10598 } 10599 return false 10600 } 10601 func rewriteValueARM_OpARMMULA_20(v *Value) bool { 10602 // match: (MULA (MOVWconst [c]) (MOVWconst [d]) a) 10603 // cond: 10604 // result: (ADDconst [int64(int32(c*d))] a) 10605 for { 10606 _ = v.Args[2] 10607 v_0 := v.Args[0] 10608 if v_0.Op != OpARMMOVWconst { 10609 break 10610 } 10611 c := v_0.AuxInt 10612 v_1 := v.Args[1] 10613 if v_1.Op != OpARMMOVWconst { 10614 break 10615 } 10616 d := v_1.AuxInt 10617 a := v.Args[2] 10618 v.reset(OpARMADDconst) 10619 v.AuxInt = int64(int32(c * d)) 10620 v.AddArg(a) 10621 return true 10622 } 10623 return false 10624 } 10625 func rewriteValueARM_OpARMMULD_0(v *Value) bool { 10626 // match: (MULD (NEGD x) y) 10627 // cond: objabi.GOARM >= 6 10628 // result: (NMULD x y) 10629 for { 10630 _ = v.Args[1] 10631 v_0 := v.Args[0] 10632 if v_0.Op != OpARMNEGD { 10633 break 10634 } 10635 x := v_0.Args[0] 10636 y := v.Args[1] 10637 if !(objabi.GOARM >= 6) { 10638 break 10639 } 10640 v.reset(OpARMNMULD) 10641 v.AddArg(x) 10642 v.AddArg(y) 10643 return true 10644 } 10645 // match: (MULD y (NEGD x)) 10646 // cond: objabi.GOARM >= 6 10647 // result: (NMULD x y) 10648 for { 10649 _ = v.Args[1] 10650 y := v.Args[0] 10651 v_1 := v.Args[1] 10652 if v_1.Op != OpARMNEGD { 10653 break 10654 } 10655 x := v_1.Args[0] 10656 if !(objabi.GOARM >= 6) { 10657 break 10658 } 10659 v.reset(OpARMNMULD) 10660 v.AddArg(x) 10661 v.AddArg(y) 10662 return true 10663 } 10664 return false 10665 } 10666 func rewriteValueARM_OpARMMULF_0(v *Value) bool { 10667 // match: (MULF (NEGF x) y) 10668 // cond: objabi.GOARM >= 6 10669 // result: (NMULF x y) 10670 for { 10671 _ = v.Args[1] 10672 v_0 := v.Args[0] 10673 if v_0.Op != OpARMNEGF { 10674 break 10675 } 10676 x := v_0.Args[0] 10677 y := v.Args[1] 10678 if !(objabi.GOARM >= 6) { 10679 break 10680 } 10681 v.reset(OpARMNMULF) 10682 v.AddArg(x) 10683 v.AddArg(y) 10684 return true 10685 } 10686 // match: (MULF y (NEGF x)) 10687 // cond: objabi.GOARM >= 6 10688 // result: (NMULF x y) 10689 for { 10690 _ = v.Args[1] 10691 y := v.Args[0] 10692 v_1 := v.Args[1] 10693 if v_1.Op != OpARMNEGF { 10694 break 10695 } 10696 x := v_1.Args[0] 10697 if !(objabi.GOARM >= 6) { 10698 break 10699 } 10700 v.reset(OpARMNMULF) 10701 v.AddArg(x) 10702 v.AddArg(y) 10703 return true 10704 } 10705 return false 10706 } 10707 func rewriteValueARM_OpARMMULS_0(v *Value) bool { 10708 b := v.Block 10709 _ = b 10710 // match: (MULS x (MOVWconst [c]) a) 10711 // cond: int32(c) == -1 10712 // result: (ADD a x) 10713 for { 10714 _ = v.Args[2] 10715 x := v.Args[0] 10716 v_1 := v.Args[1] 10717 if v_1.Op != OpARMMOVWconst { 10718 break 10719 } 10720 c := v_1.AuxInt 10721 a := v.Args[2] 10722 if !(int32(c) == -1) { 10723 break 10724 } 10725 v.reset(OpARMADD) 10726 v.AddArg(a) 10727 v.AddArg(x) 10728 return true 10729 } 10730 // match: (MULS _ (MOVWconst [0]) a) 10731 // cond: 10732 // result: a 10733 for { 10734 _ = v.Args[2] 10735 v_1 := v.Args[1] 10736 if v_1.Op != OpARMMOVWconst { 10737 break 10738 } 10739 if v_1.AuxInt != 0 { 10740 break 10741 } 10742 a := v.Args[2] 10743 v.reset(OpCopy) 10744 v.Type = a.Type 10745 v.AddArg(a) 10746 return true 10747 } 10748 // match: (MULS x (MOVWconst [1]) a) 10749 // cond: 10750 // result: (RSB x a) 10751 for { 10752 _ = v.Args[2] 10753 x := v.Args[0] 10754 v_1 := v.Args[1] 10755 if v_1.Op != OpARMMOVWconst { 10756 break 10757 } 10758 if v_1.AuxInt != 1 { 10759 break 10760 } 10761 a := v.Args[2] 10762 v.reset(OpARMRSB) 10763 v.AddArg(x) 10764 v.AddArg(a) 10765 return true 10766 } 10767 // match: (MULS x (MOVWconst [c]) a) 10768 // cond: isPowerOfTwo(c) 10769 // result: (RSB (SLLconst <x.Type> [log2(c)] x) a) 10770 for { 10771 _ = v.Args[2] 10772 x := v.Args[0] 10773 v_1 := v.Args[1] 10774 if v_1.Op != OpARMMOVWconst { 10775 break 10776 } 10777 c := v_1.AuxInt 10778 a := v.Args[2] 10779 if !(isPowerOfTwo(c)) { 10780 break 10781 } 10782 v.reset(OpARMRSB) 10783 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10784 v0.AuxInt = log2(c) 10785 v0.AddArg(x) 10786 v.AddArg(v0) 10787 v.AddArg(a) 10788 return true 10789 } 10790 // match: (MULS x (MOVWconst [c]) a) 10791 // cond: isPowerOfTwo(c-1) && int32(c) >= 3 10792 // result: (RSB (ADDshiftLL <x.Type> x x [log2(c-1)]) a) 10793 for { 10794 _ = v.Args[2] 10795 x := v.Args[0] 10796 v_1 := v.Args[1] 10797 if v_1.Op != OpARMMOVWconst { 10798 break 10799 } 10800 c := v_1.AuxInt 10801 a := v.Args[2] 10802 if !(isPowerOfTwo(c-1) && int32(c) >= 3) { 10803 break 10804 } 10805 v.reset(OpARMRSB) 10806 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10807 v0.AuxInt = log2(c - 1) 10808 v0.AddArg(x) 10809 v0.AddArg(x) 10810 v.AddArg(v0) 10811 v.AddArg(a) 10812 return true 10813 } 10814 // match: (MULS x (MOVWconst [c]) a) 10815 // cond: isPowerOfTwo(c+1) && int32(c) >= 7 10816 // result: (RSB (RSBshiftLL <x.Type> x x [log2(c+1)]) a) 10817 for { 10818 _ = v.Args[2] 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 a := v.Args[2] 10826 if !(isPowerOfTwo(c+1) && int32(c) >= 7) { 10827 break 10828 } 10829 v.reset(OpARMRSB) 10830 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 10831 v0.AuxInt = log2(c + 1) 10832 v0.AddArg(x) 10833 v0.AddArg(x) 10834 v.AddArg(v0) 10835 v.AddArg(a) 10836 return true 10837 } 10838 // match: (MULS x (MOVWconst [c]) a) 10839 // cond: c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c) 10840 // result: (RSB (SLLconst <x.Type> [log2(c/3)] (ADDshiftLL <x.Type> x x [1])) a) 10841 for { 10842 _ = v.Args[2] 10843 x := v.Args[0] 10844 v_1 := v.Args[1] 10845 if v_1.Op != OpARMMOVWconst { 10846 break 10847 } 10848 c := v_1.AuxInt 10849 a := v.Args[2] 10850 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) { 10851 break 10852 } 10853 v.reset(OpARMRSB) 10854 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10855 v0.AuxInt = log2(c / 3) 10856 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10857 v1.AuxInt = 1 10858 v1.AddArg(x) 10859 v1.AddArg(x) 10860 v0.AddArg(v1) 10861 v.AddArg(v0) 10862 v.AddArg(a) 10863 return true 10864 } 10865 // match: (MULS x (MOVWconst [c]) a) 10866 // cond: c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c) 10867 // result: (RSB (SLLconst <x.Type> [log2(c/5)] (ADDshiftLL <x.Type> x x [2])) a) 10868 for { 10869 _ = v.Args[2] 10870 x := v.Args[0] 10871 v_1 := v.Args[1] 10872 if v_1.Op != OpARMMOVWconst { 10873 break 10874 } 10875 c := v_1.AuxInt 10876 a := v.Args[2] 10877 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) { 10878 break 10879 } 10880 v.reset(OpARMRSB) 10881 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10882 v0.AuxInt = log2(c / 5) 10883 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10884 v1.AuxInt = 2 10885 v1.AddArg(x) 10886 v1.AddArg(x) 10887 v0.AddArg(v1) 10888 v.AddArg(v0) 10889 v.AddArg(a) 10890 return true 10891 } 10892 // match: (MULS x (MOVWconst [c]) a) 10893 // cond: c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c) 10894 // result: (RSB (SLLconst <x.Type> [log2(c/7)] (RSBshiftLL <x.Type> x x [3])) a) 10895 for { 10896 _ = v.Args[2] 10897 x := v.Args[0] 10898 v_1 := v.Args[1] 10899 if v_1.Op != OpARMMOVWconst { 10900 break 10901 } 10902 c := v_1.AuxInt 10903 a := v.Args[2] 10904 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) { 10905 break 10906 } 10907 v.reset(OpARMRSB) 10908 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10909 v0.AuxInt = log2(c / 7) 10910 v1 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 10911 v1.AuxInt = 3 10912 v1.AddArg(x) 10913 v1.AddArg(x) 10914 v0.AddArg(v1) 10915 v.AddArg(v0) 10916 v.AddArg(a) 10917 return true 10918 } 10919 // match: (MULS x (MOVWconst [c]) a) 10920 // cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c) 10921 // result: (RSB (SLLconst <x.Type> [log2(c/9)] (ADDshiftLL <x.Type> x x [3])) a) 10922 for { 10923 _ = v.Args[2] 10924 x := v.Args[0] 10925 v_1 := v.Args[1] 10926 if v_1.Op != OpARMMOVWconst { 10927 break 10928 } 10929 c := v_1.AuxInt 10930 a := v.Args[2] 10931 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) { 10932 break 10933 } 10934 v.reset(OpARMRSB) 10935 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 10936 v0.AuxInt = log2(c / 9) 10937 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 10938 v1.AuxInt = 3 10939 v1.AddArg(x) 10940 v1.AddArg(x) 10941 v0.AddArg(v1) 10942 v.AddArg(v0) 10943 v.AddArg(a) 10944 return true 10945 } 10946 return false 10947 } 10948 func rewriteValueARM_OpARMMULS_10(v *Value) bool { 10949 b := v.Block 10950 _ = b 10951 // match: (MULS (MOVWconst [c]) x a) 10952 // cond: int32(c) == -1 10953 // result: (ADD a x) 10954 for { 10955 _ = v.Args[2] 10956 v_0 := v.Args[0] 10957 if v_0.Op != OpARMMOVWconst { 10958 break 10959 } 10960 c := v_0.AuxInt 10961 x := v.Args[1] 10962 a := v.Args[2] 10963 if !(int32(c) == -1) { 10964 break 10965 } 10966 v.reset(OpARMADD) 10967 v.AddArg(a) 10968 v.AddArg(x) 10969 return true 10970 } 10971 // match: (MULS (MOVWconst [0]) _ a) 10972 // cond: 10973 // result: a 10974 for { 10975 _ = v.Args[2] 10976 v_0 := v.Args[0] 10977 if v_0.Op != OpARMMOVWconst { 10978 break 10979 } 10980 if v_0.AuxInt != 0 { 10981 break 10982 } 10983 a := v.Args[2] 10984 v.reset(OpCopy) 10985 v.Type = a.Type 10986 v.AddArg(a) 10987 return true 10988 } 10989 // match: (MULS (MOVWconst [1]) x a) 10990 // cond: 10991 // result: (RSB x a) 10992 for { 10993 _ = v.Args[2] 10994 v_0 := v.Args[0] 10995 if v_0.Op != OpARMMOVWconst { 10996 break 10997 } 10998 if v_0.AuxInt != 1 { 10999 break 11000 } 11001 x := v.Args[1] 11002 a := v.Args[2] 11003 v.reset(OpARMRSB) 11004 v.AddArg(x) 11005 v.AddArg(a) 11006 return true 11007 } 11008 // match: (MULS (MOVWconst [c]) x a) 11009 // cond: isPowerOfTwo(c) 11010 // result: (RSB (SLLconst <x.Type> [log2(c)] x) a) 11011 for { 11012 _ = v.Args[2] 11013 v_0 := v.Args[0] 11014 if v_0.Op != OpARMMOVWconst { 11015 break 11016 } 11017 c := v_0.AuxInt 11018 x := v.Args[1] 11019 a := v.Args[2] 11020 if !(isPowerOfTwo(c)) { 11021 break 11022 } 11023 v.reset(OpARMRSB) 11024 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 11025 v0.AuxInt = log2(c) 11026 v0.AddArg(x) 11027 v.AddArg(v0) 11028 v.AddArg(a) 11029 return true 11030 } 11031 // match: (MULS (MOVWconst [c]) x a) 11032 // cond: isPowerOfTwo(c-1) && int32(c) >= 3 11033 // result: (RSB (ADDshiftLL <x.Type> x x [log2(c-1)]) a) 11034 for { 11035 _ = v.Args[2] 11036 v_0 := v.Args[0] 11037 if v_0.Op != OpARMMOVWconst { 11038 break 11039 } 11040 c := v_0.AuxInt 11041 x := v.Args[1] 11042 a := v.Args[2] 11043 if !(isPowerOfTwo(c-1) && int32(c) >= 3) { 11044 break 11045 } 11046 v.reset(OpARMRSB) 11047 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 11048 v0.AuxInt = log2(c - 1) 11049 v0.AddArg(x) 11050 v0.AddArg(x) 11051 v.AddArg(v0) 11052 v.AddArg(a) 11053 return true 11054 } 11055 // match: (MULS (MOVWconst [c]) x a) 11056 // cond: isPowerOfTwo(c+1) && int32(c) >= 7 11057 // result: (RSB (RSBshiftLL <x.Type> x x [log2(c+1)]) a) 11058 for { 11059 _ = v.Args[2] 11060 v_0 := v.Args[0] 11061 if v_0.Op != OpARMMOVWconst { 11062 break 11063 } 11064 c := v_0.AuxInt 11065 x := v.Args[1] 11066 a := v.Args[2] 11067 if !(isPowerOfTwo(c+1) && int32(c) >= 7) { 11068 break 11069 } 11070 v.reset(OpARMRSB) 11071 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 11072 v0.AuxInt = log2(c + 1) 11073 v0.AddArg(x) 11074 v0.AddArg(x) 11075 v.AddArg(v0) 11076 v.AddArg(a) 11077 return true 11078 } 11079 // match: (MULS (MOVWconst [c]) x a) 11080 // cond: c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c) 11081 // result: (RSB (SLLconst <x.Type> [log2(c/3)] (ADDshiftLL <x.Type> x x [1])) a) 11082 for { 11083 _ = v.Args[2] 11084 v_0 := v.Args[0] 11085 if v_0.Op != OpARMMOVWconst { 11086 break 11087 } 11088 c := v_0.AuxInt 11089 x := v.Args[1] 11090 a := v.Args[2] 11091 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) { 11092 break 11093 } 11094 v.reset(OpARMRSB) 11095 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 11096 v0.AuxInt = log2(c / 3) 11097 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 11098 v1.AuxInt = 1 11099 v1.AddArg(x) 11100 v1.AddArg(x) 11101 v0.AddArg(v1) 11102 v.AddArg(v0) 11103 v.AddArg(a) 11104 return true 11105 } 11106 // match: (MULS (MOVWconst [c]) x a) 11107 // cond: c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c) 11108 // result: (RSB (SLLconst <x.Type> [log2(c/5)] (ADDshiftLL <x.Type> x x [2])) a) 11109 for { 11110 _ = v.Args[2] 11111 v_0 := v.Args[0] 11112 if v_0.Op != OpARMMOVWconst { 11113 break 11114 } 11115 c := v_0.AuxInt 11116 x := v.Args[1] 11117 a := v.Args[2] 11118 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) { 11119 break 11120 } 11121 v.reset(OpARMRSB) 11122 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 11123 v0.AuxInt = log2(c / 5) 11124 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 11125 v1.AuxInt = 2 11126 v1.AddArg(x) 11127 v1.AddArg(x) 11128 v0.AddArg(v1) 11129 v.AddArg(v0) 11130 v.AddArg(a) 11131 return true 11132 } 11133 // match: (MULS (MOVWconst [c]) x a) 11134 // cond: c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c) 11135 // result: (RSB (SLLconst <x.Type> [log2(c/7)] (RSBshiftLL <x.Type> x x [3])) a) 11136 for { 11137 _ = v.Args[2] 11138 v_0 := v.Args[0] 11139 if v_0.Op != OpARMMOVWconst { 11140 break 11141 } 11142 c := v_0.AuxInt 11143 x := v.Args[1] 11144 a := v.Args[2] 11145 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) { 11146 break 11147 } 11148 v.reset(OpARMRSB) 11149 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 11150 v0.AuxInt = log2(c / 7) 11151 v1 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type) 11152 v1.AuxInt = 3 11153 v1.AddArg(x) 11154 v1.AddArg(x) 11155 v0.AddArg(v1) 11156 v.AddArg(v0) 11157 v.AddArg(a) 11158 return true 11159 } 11160 // match: (MULS (MOVWconst [c]) x a) 11161 // cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c) 11162 // result: (RSB (SLLconst <x.Type> [log2(c/9)] (ADDshiftLL <x.Type> x x [3])) a) 11163 for { 11164 _ = v.Args[2] 11165 v_0 := v.Args[0] 11166 if v_0.Op != OpARMMOVWconst { 11167 break 11168 } 11169 c := v_0.AuxInt 11170 x := v.Args[1] 11171 a := v.Args[2] 11172 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) { 11173 break 11174 } 11175 v.reset(OpARMRSB) 11176 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 11177 v0.AuxInt = log2(c / 9) 11178 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type) 11179 v1.AuxInt = 3 11180 v1.AddArg(x) 11181 v1.AddArg(x) 11182 v0.AddArg(v1) 11183 v.AddArg(v0) 11184 v.AddArg(a) 11185 return true 11186 } 11187 return false 11188 } 11189 func rewriteValueARM_OpARMMULS_20(v *Value) bool { 11190 // match: (MULS (MOVWconst [c]) (MOVWconst [d]) a) 11191 // cond: 11192 // result: (SUBconst [int64(int32(c*d))] a) 11193 for { 11194 _ = v.Args[2] 11195 v_0 := v.Args[0] 11196 if v_0.Op != OpARMMOVWconst { 11197 break 11198 } 11199 c := v_0.AuxInt 11200 v_1 := v.Args[1] 11201 if v_1.Op != OpARMMOVWconst { 11202 break 11203 } 11204 d := v_1.AuxInt 11205 a := v.Args[2] 11206 v.reset(OpARMSUBconst) 11207 v.AuxInt = int64(int32(c * d)) 11208 v.AddArg(a) 11209 return true 11210 } 11211 return false 11212 } 11213 func rewriteValueARM_OpARMMVN_0(v *Value) bool { 11214 // match: (MVN (MOVWconst [c])) 11215 // cond: 11216 // result: (MOVWconst [^c]) 11217 for { 11218 v_0 := v.Args[0] 11219 if v_0.Op != OpARMMOVWconst { 11220 break 11221 } 11222 c := v_0.AuxInt 11223 v.reset(OpARMMOVWconst) 11224 v.AuxInt = ^c 11225 return true 11226 } 11227 // match: (MVN (SLLconst [c] x)) 11228 // cond: 11229 // result: (MVNshiftLL x [c]) 11230 for { 11231 v_0 := v.Args[0] 11232 if v_0.Op != OpARMSLLconst { 11233 break 11234 } 11235 c := v_0.AuxInt 11236 x := v_0.Args[0] 11237 v.reset(OpARMMVNshiftLL) 11238 v.AuxInt = c 11239 v.AddArg(x) 11240 return true 11241 } 11242 // match: (MVN (SRLconst [c] x)) 11243 // cond: 11244 // result: (MVNshiftRL x [c]) 11245 for { 11246 v_0 := v.Args[0] 11247 if v_0.Op != OpARMSRLconst { 11248 break 11249 } 11250 c := v_0.AuxInt 11251 x := v_0.Args[0] 11252 v.reset(OpARMMVNshiftRL) 11253 v.AuxInt = c 11254 v.AddArg(x) 11255 return true 11256 } 11257 // match: (MVN (SRAconst [c] x)) 11258 // cond: 11259 // result: (MVNshiftRA x [c]) 11260 for { 11261 v_0 := v.Args[0] 11262 if v_0.Op != OpARMSRAconst { 11263 break 11264 } 11265 c := v_0.AuxInt 11266 x := v_0.Args[0] 11267 v.reset(OpARMMVNshiftRA) 11268 v.AuxInt = c 11269 v.AddArg(x) 11270 return true 11271 } 11272 // match: (MVN (SLL x y)) 11273 // cond: 11274 // result: (MVNshiftLLreg x y) 11275 for { 11276 v_0 := v.Args[0] 11277 if v_0.Op != OpARMSLL { 11278 break 11279 } 11280 _ = v_0.Args[1] 11281 x := v_0.Args[0] 11282 y := v_0.Args[1] 11283 v.reset(OpARMMVNshiftLLreg) 11284 v.AddArg(x) 11285 v.AddArg(y) 11286 return true 11287 } 11288 // match: (MVN (SRL x y)) 11289 // cond: 11290 // result: (MVNshiftRLreg x y) 11291 for { 11292 v_0 := v.Args[0] 11293 if v_0.Op != OpARMSRL { 11294 break 11295 } 11296 _ = v_0.Args[1] 11297 x := v_0.Args[0] 11298 y := v_0.Args[1] 11299 v.reset(OpARMMVNshiftRLreg) 11300 v.AddArg(x) 11301 v.AddArg(y) 11302 return true 11303 } 11304 // match: (MVN (SRA x y)) 11305 // cond: 11306 // result: (MVNshiftRAreg x y) 11307 for { 11308 v_0 := v.Args[0] 11309 if v_0.Op != OpARMSRA { 11310 break 11311 } 11312 _ = v_0.Args[1] 11313 x := v_0.Args[0] 11314 y := v_0.Args[1] 11315 v.reset(OpARMMVNshiftRAreg) 11316 v.AddArg(x) 11317 v.AddArg(y) 11318 return true 11319 } 11320 return false 11321 } 11322 func rewriteValueARM_OpARMMVNshiftLL_0(v *Value) bool { 11323 // match: (MVNshiftLL (MOVWconst [c]) [d]) 11324 // cond: 11325 // result: (MOVWconst [^int64(uint32(c)<<uint64(d))]) 11326 for { 11327 d := v.AuxInt 11328 v_0 := v.Args[0] 11329 if v_0.Op != OpARMMOVWconst { 11330 break 11331 } 11332 c := v_0.AuxInt 11333 v.reset(OpARMMOVWconst) 11334 v.AuxInt = ^int64(uint32(c) << uint64(d)) 11335 return true 11336 } 11337 return false 11338 } 11339 func rewriteValueARM_OpARMMVNshiftLLreg_0(v *Value) bool { 11340 // match: (MVNshiftLLreg x (MOVWconst [c])) 11341 // cond: 11342 // result: (MVNshiftLL x [c]) 11343 for { 11344 _ = v.Args[1] 11345 x := v.Args[0] 11346 v_1 := v.Args[1] 11347 if v_1.Op != OpARMMOVWconst { 11348 break 11349 } 11350 c := v_1.AuxInt 11351 v.reset(OpARMMVNshiftLL) 11352 v.AuxInt = c 11353 v.AddArg(x) 11354 return true 11355 } 11356 return false 11357 } 11358 func rewriteValueARM_OpARMMVNshiftRA_0(v *Value) bool { 11359 // match: (MVNshiftRA (MOVWconst [c]) [d]) 11360 // cond: 11361 // result: (MOVWconst [^int64(int32(c)>>uint64(d))]) 11362 for { 11363 d := v.AuxInt 11364 v_0 := v.Args[0] 11365 if v_0.Op != OpARMMOVWconst { 11366 break 11367 } 11368 c := v_0.AuxInt 11369 v.reset(OpARMMOVWconst) 11370 v.AuxInt = ^int64(int32(c) >> uint64(d)) 11371 return true 11372 } 11373 return false 11374 } 11375 func rewriteValueARM_OpARMMVNshiftRAreg_0(v *Value) bool { 11376 // match: (MVNshiftRAreg x (MOVWconst [c])) 11377 // cond: 11378 // result: (MVNshiftRA x [c]) 11379 for { 11380 _ = v.Args[1] 11381 x := v.Args[0] 11382 v_1 := v.Args[1] 11383 if v_1.Op != OpARMMOVWconst { 11384 break 11385 } 11386 c := v_1.AuxInt 11387 v.reset(OpARMMVNshiftRA) 11388 v.AuxInt = c 11389 v.AddArg(x) 11390 return true 11391 } 11392 return false 11393 } 11394 func rewriteValueARM_OpARMMVNshiftRL_0(v *Value) bool { 11395 // match: (MVNshiftRL (MOVWconst [c]) [d]) 11396 // cond: 11397 // result: (MOVWconst [^int64(uint32(c)>>uint64(d))]) 11398 for { 11399 d := v.AuxInt 11400 v_0 := v.Args[0] 11401 if v_0.Op != OpARMMOVWconst { 11402 break 11403 } 11404 c := v_0.AuxInt 11405 v.reset(OpARMMOVWconst) 11406 v.AuxInt = ^int64(uint32(c) >> uint64(d)) 11407 return true 11408 } 11409 return false 11410 } 11411 func rewriteValueARM_OpARMMVNshiftRLreg_0(v *Value) bool { 11412 // match: (MVNshiftRLreg x (MOVWconst [c])) 11413 // cond: 11414 // result: (MVNshiftRL x [c]) 11415 for { 11416 _ = v.Args[1] 11417 x := v.Args[0] 11418 v_1 := v.Args[1] 11419 if v_1.Op != OpARMMOVWconst { 11420 break 11421 } 11422 c := v_1.AuxInt 11423 v.reset(OpARMMVNshiftRL) 11424 v.AuxInt = c 11425 v.AddArg(x) 11426 return true 11427 } 11428 return false 11429 } 11430 func rewriteValueARM_OpARMNEGD_0(v *Value) bool { 11431 // match: (NEGD (MULD x y)) 11432 // cond: objabi.GOARM >= 6 11433 // result: (NMULD x y) 11434 for { 11435 v_0 := v.Args[0] 11436 if v_0.Op != OpARMMULD { 11437 break 11438 } 11439 _ = v_0.Args[1] 11440 x := v_0.Args[0] 11441 y := v_0.Args[1] 11442 if !(objabi.GOARM >= 6) { 11443 break 11444 } 11445 v.reset(OpARMNMULD) 11446 v.AddArg(x) 11447 v.AddArg(y) 11448 return true 11449 } 11450 return false 11451 } 11452 func rewriteValueARM_OpARMNEGF_0(v *Value) bool { 11453 // match: (NEGF (MULF x y)) 11454 // cond: objabi.GOARM >= 6 11455 // result: (NMULF x y) 11456 for { 11457 v_0 := v.Args[0] 11458 if v_0.Op != OpARMMULF { 11459 break 11460 } 11461 _ = v_0.Args[1] 11462 x := v_0.Args[0] 11463 y := v_0.Args[1] 11464 if !(objabi.GOARM >= 6) { 11465 break 11466 } 11467 v.reset(OpARMNMULF) 11468 v.AddArg(x) 11469 v.AddArg(y) 11470 return true 11471 } 11472 return false 11473 } 11474 func rewriteValueARM_OpARMNMULD_0(v *Value) bool { 11475 // match: (NMULD (NEGD x) y) 11476 // cond: 11477 // result: (MULD x y) 11478 for { 11479 _ = v.Args[1] 11480 v_0 := v.Args[0] 11481 if v_0.Op != OpARMNEGD { 11482 break 11483 } 11484 x := v_0.Args[0] 11485 y := v.Args[1] 11486 v.reset(OpARMMULD) 11487 v.AddArg(x) 11488 v.AddArg(y) 11489 return true 11490 } 11491 // match: (NMULD y (NEGD x)) 11492 // cond: 11493 // result: (MULD x y) 11494 for { 11495 _ = v.Args[1] 11496 y := v.Args[0] 11497 v_1 := v.Args[1] 11498 if v_1.Op != OpARMNEGD { 11499 break 11500 } 11501 x := v_1.Args[0] 11502 v.reset(OpARMMULD) 11503 v.AddArg(x) 11504 v.AddArg(y) 11505 return true 11506 } 11507 return false 11508 } 11509 func rewriteValueARM_OpARMNMULF_0(v *Value) bool { 11510 // match: (NMULF (NEGF x) y) 11511 // cond: 11512 // result: (MULF x y) 11513 for { 11514 _ = v.Args[1] 11515 v_0 := v.Args[0] 11516 if v_0.Op != OpARMNEGF { 11517 break 11518 } 11519 x := v_0.Args[0] 11520 y := v.Args[1] 11521 v.reset(OpARMMULF) 11522 v.AddArg(x) 11523 v.AddArg(y) 11524 return true 11525 } 11526 // match: (NMULF y (NEGF x)) 11527 // cond: 11528 // result: (MULF x y) 11529 for { 11530 _ = v.Args[1] 11531 y := v.Args[0] 11532 v_1 := v.Args[1] 11533 if v_1.Op != OpARMNEGF { 11534 break 11535 } 11536 x := v_1.Args[0] 11537 v.reset(OpARMMULF) 11538 v.AddArg(x) 11539 v.AddArg(y) 11540 return true 11541 } 11542 return false 11543 } 11544 func rewriteValueARM_OpARMNotEqual_0(v *Value) bool { 11545 // match: (NotEqual (FlagEQ)) 11546 // cond: 11547 // result: (MOVWconst [0]) 11548 for { 11549 v_0 := v.Args[0] 11550 if v_0.Op != OpARMFlagEQ { 11551 break 11552 } 11553 v.reset(OpARMMOVWconst) 11554 v.AuxInt = 0 11555 return true 11556 } 11557 // match: (NotEqual (FlagLT_ULT)) 11558 // cond: 11559 // result: (MOVWconst [1]) 11560 for { 11561 v_0 := v.Args[0] 11562 if v_0.Op != OpARMFlagLT_ULT { 11563 break 11564 } 11565 v.reset(OpARMMOVWconst) 11566 v.AuxInt = 1 11567 return true 11568 } 11569 // match: (NotEqual (FlagLT_UGT)) 11570 // cond: 11571 // result: (MOVWconst [1]) 11572 for { 11573 v_0 := v.Args[0] 11574 if v_0.Op != OpARMFlagLT_UGT { 11575 break 11576 } 11577 v.reset(OpARMMOVWconst) 11578 v.AuxInt = 1 11579 return true 11580 } 11581 // match: (NotEqual (FlagGT_ULT)) 11582 // cond: 11583 // result: (MOVWconst [1]) 11584 for { 11585 v_0 := v.Args[0] 11586 if v_0.Op != OpARMFlagGT_ULT { 11587 break 11588 } 11589 v.reset(OpARMMOVWconst) 11590 v.AuxInt = 1 11591 return true 11592 } 11593 // match: (NotEqual (FlagGT_UGT)) 11594 // cond: 11595 // result: (MOVWconst [1]) 11596 for { 11597 v_0 := v.Args[0] 11598 if v_0.Op != OpARMFlagGT_UGT { 11599 break 11600 } 11601 v.reset(OpARMMOVWconst) 11602 v.AuxInt = 1 11603 return true 11604 } 11605 // match: (NotEqual (InvertFlags x)) 11606 // cond: 11607 // result: (NotEqual x) 11608 for { 11609 v_0 := v.Args[0] 11610 if v_0.Op != OpARMInvertFlags { 11611 break 11612 } 11613 x := v_0.Args[0] 11614 v.reset(OpARMNotEqual) 11615 v.AddArg(x) 11616 return true 11617 } 11618 return false 11619 } 11620 func rewriteValueARM_OpARMOR_0(v *Value) bool { 11621 // match: (OR x (MOVWconst [c])) 11622 // cond: 11623 // result: (ORconst [c] x) 11624 for { 11625 _ = v.Args[1] 11626 x := v.Args[0] 11627 v_1 := v.Args[1] 11628 if v_1.Op != OpARMMOVWconst { 11629 break 11630 } 11631 c := v_1.AuxInt 11632 v.reset(OpARMORconst) 11633 v.AuxInt = c 11634 v.AddArg(x) 11635 return true 11636 } 11637 // match: (OR (MOVWconst [c]) x) 11638 // cond: 11639 // result: (ORconst [c] x) 11640 for { 11641 _ = v.Args[1] 11642 v_0 := v.Args[0] 11643 if v_0.Op != OpARMMOVWconst { 11644 break 11645 } 11646 c := v_0.AuxInt 11647 x := v.Args[1] 11648 v.reset(OpARMORconst) 11649 v.AuxInt = c 11650 v.AddArg(x) 11651 return true 11652 } 11653 // match: (OR x (SLLconst [c] y)) 11654 // cond: 11655 // result: (ORshiftLL x y [c]) 11656 for { 11657 _ = v.Args[1] 11658 x := v.Args[0] 11659 v_1 := v.Args[1] 11660 if v_1.Op != OpARMSLLconst { 11661 break 11662 } 11663 c := v_1.AuxInt 11664 y := v_1.Args[0] 11665 v.reset(OpARMORshiftLL) 11666 v.AuxInt = c 11667 v.AddArg(x) 11668 v.AddArg(y) 11669 return true 11670 } 11671 // match: (OR (SLLconst [c] y) x) 11672 // cond: 11673 // result: (ORshiftLL x y [c]) 11674 for { 11675 _ = v.Args[1] 11676 v_0 := v.Args[0] 11677 if v_0.Op != OpARMSLLconst { 11678 break 11679 } 11680 c := v_0.AuxInt 11681 y := v_0.Args[0] 11682 x := v.Args[1] 11683 v.reset(OpARMORshiftLL) 11684 v.AuxInt = c 11685 v.AddArg(x) 11686 v.AddArg(y) 11687 return true 11688 } 11689 // match: (OR x (SRLconst [c] y)) 11690 // cond: 11691 // result: (ORshiftRL x y [c]) 11692 for { 11693 _ = v.Args[1] 11694 x := v.Args[0] 11695 v_1 := v.Args[1] 11696 if v_1.Op != OpARMSRLconst { 11697 break 11698 } 11699 c := v_1.AuxInt 11700 y := v_1.Args[0] 11701 v.reset(OpARMORshiftRL) 11702 v.AuxInt = c 11703 v.AddArg(x) 11704 v.AddArg(y) 11705 return true 11706 } 11707 // match: (OR (SRLconst [c] y) x) 11708 // cond: 11709 // result: (ORshiftRL x y [c]) 11710 for { 11711 _ = v.Args[1] 11712 v_0 := v.Args[0] 11713 if v_0.Op != OpARMSRLconst { 11714 break 11715 } 11716 c := v_0.AuxInt 11717 y := v_0.Args[0] 11718 x := v.Args[1] 11719 v.reset(OpARMORshiftRL) 11720 v.AuxInt = c 11721 v.AddArg(x) 11722 v.AddArg(y) 11723 return true 11724 } 11725 // match: (OR x (SRAconst [c] y)) 11726 // cond: 11727 // result: (ORshiftRA x y [c]) 11728 for { 11729 _ = v.Args[1] 11730 x := v.Args[0] 11731 v_1 := v.Args[1] 11732 if v_1.Op != OpARMSRAconst { 11733 break 11734 } 11735 c := v_1.AuxInt 11736 y := v_1.Args[0] 11737 v.reset(OpARMORshiftRA) 11738 v.AuxInt = c 11739 v.AddArg(x) 11740 v.AddArg(y) 11741 return true 11742 } 11743 // match: (OR (SRAconst [c] y) x) 11744 // cond: 11745 // result: (ORshiftRA x y [c]) 11746 for { 11747 _ = v.Args[1] 11748 v_0 := v.Args[0] 11749 if v_0.Op != OpARMSRAconst { 11750 break 11751 } 11752 c := v_0.AuxInt 11753 y := v_0.Args[0] 11754 x := v.Args[1] 11755 v.reset(OpARMORshiftRA) 11756 v.AuxInt = c 11757 v.AddArg(x) 11758 v.AddArg(y) 11759 return true 11760 } 11761 // match: (OR x (SLL y z)) 11762 // cond: 11763 // result: (ORshiftLLreg x y z) 11764 for { 11765 _ = v.Args[1] 11766 x := v.Args[0] 11767 v_1 := v.Args[1] 11768 if v_1.Op != OpARMSLL { 11769 break 11770 } 11771 _ = v_1.Args[1] 11772 y := v_1.Args[0] 11773 z := v_1.Args[1] 11774 v.reset(OpARMORshiftLLreg) 11775 v.AddArg(x) 11776 v.AddArg(y) 11777 v.AddArg(z) 11778 return true 11779 } 11780 // match: (OR (SLL y z) x) 11781 // cond: 11782 // result: (ORshiftLLreg x y z) 11783 for { 11784 _ = v.Args[1] 11785 v_0 := v.Args[0] 11786 if v_0.Op != OpARMSLL { 11787 break 11788 } 11789 _ = v_0.Args[1] 11790 y := v_0.Args[0] 11791 z := v_0.Args[1] 11792 x := v.Args[1] 11793 v.reset(OpARMORshiftLLreg) 11794 v.AddArg(x) 11795 v.AddArg(y) 11796 v.AddArg(z) 11797 return true 11798 } 11799 return false 11800 } 11801 func rewriteValueARM_OpARMOR_10(v *Value) bool { 11802 // match: (OR x (SRL y z)) 11803 // cond: 11804 // result: (ORshiftRLreg x y z) 11805 for { 11806 _ = v.Args[1] 11807 x := v.Args[0] 11808 v_1 := v.Args[1] 11809 if v_1.Op != OpARMSRL { 11810 break 11811 } 11812 _ = v_1.Args[1] 11813 y := v_1.Args[0] 11814 z := v_1.Args[1] 11815 v.reset(OpARMORshiftRLreg) 11816 v.AddArg(x) 11817 v.AddArg(y) 11818 v.AddArg(z) 11819 return true 11820 } 11821 // match: (OR (SRL y z) x) 11822 // cond: 11823 // result: (ORshiftRLreg x y z) 11824 for { 11825 _ = v.Args[1] 11826 v_0 := v.Args[0] 11827 if v_0.Op != OpARMSRL { 11828 break 11829 } 11830 _ = v_0.Args[1] 11831 y := v_0.Args[0] 11832 z := v_0.Args[1] 11833 x := v.Args[1] 11834 v.reset(OpARMORshiftRLreg) 11835 v.AddArg(x) 11836 v.AddArg(y) 11837 v.AddArg(z) 11838 return true 11839 } 11840 // match: (OR x (SRA y z)) 11841 // cond: 11842 // result: (ORshiftRAreg x y z) 11843 for { 11844 _ = v.Args[1] 11845 x := v.Args[0] 11846 v_1 := v.Args[1] 11847 if v_1.Op != OpARMSRA { 11848 break 11849 } 11850 _ = v_1.Args[1] 11851 y := v_1.Args[0] 11852 z := v_1.Args[1] 11853 v.reset(OpARMORshiftRAreg) 11854 v.AddArg(x) 11855 v.AddArg(y) 11856 v.AddArg(z) 11857 return true 11858 } 11859 // match: (OR (SRA y z) x) 11860 // cond: 11861 // result: (ORshiftRAreg x y z) 11862 for { 11863 _ = v.Args[1] 11864 v_0 := v.Args[0] 11865 if v_0.Op != OpARMSRA { 11866 break 11867 } 11868 _ = v_0.Args[1] 11869 y := v_0.Args[0] 11870 z := v_0.Args[1] 11871 x := v.Args[1] 11872 v.reset(OpARMORshiftRAreg) 11873 v.AddArg(x) 11874 v.AddArg(y) 11875 v.AddArg(z) 11876 return true 11877 } 11878 // match: (OR x x) 11879 // cond: 11880 // result: x 11881 for { 11882 _ = v.Args[1] 11883 x := v.Args[0] 11884 if x != v.Args[1] { 11885 break 11886 } 11887 v.reset(OpCopy) 11888 v.Type = x.Type 11889 v.AddArg(x) 11890 return true 11891 } 11892 return false 11893 } 11894 func rewriteValueARM_OpARMORconst_0(v *Value) bool { 11895 // match: (ORconst [0] x) 11896 // cond: 11897 // result: x 11898 for { 11899 if v.AuxInt != 0 { 11900 break 11901 } 11902 x := v.Args[0] 11903 v.reset(OpCopy) 11904 v.Type = x.Type 11905 v.AddArg(x) 11906 return true 11907 } 11908 // match: (ORconst [c] _) 11909 // cond: int32(c)==-1 11910 // result: (MOVWconst [-1]) 11911 for { 11912 c := v.AuxInt 11913 if !(int32(c) == -1) { 11914 break 11915 } 11916 v.reset(OpARMMOVWconst) 11917 v.AuxInt = -1 11918 return true 11919 } 11920 // match: (ORconst [c] (MOVWconst [d])) 11921 // cond: 11922 // result: (MOVWconst [c|d]) 11923 for { 11924 c := v.AuxInt 11925 v_0 := v.Args[0] 11926 if v_0.Op != OpARMMOVWconst { 11927 break 11928 } 11929 d := v_0.AuxInt 11930 v.reset(OpARMMOVWconst) 11931 v.AuxInt = c | d 11932 return true 11933 } 11934 // match: (ORconst [c] (ORconst [d] x)) 11935 // cond: 11936 // result: (ORconst [c|d] x) 11937 for { 11938 c := v.AuxInt 11939 v_0 := v.Args[0] 11940 if v_0.Op != OpARMORconst { 11941 break 11942 } 11943 d := v_0.AuxInt 11944 x := v_0.Args[0] 11945 v.reset(OpARMORconst) 11946 v.AuxInt = c | d 11947 v.AddArg(x) 11948 return true 11949 } 11950 return false 11951 } 11952 func rewriteValueARM_OpARMORshiftLL_0(v *Value) bool { 11953 b := v.Block 11954 _ = b 11955 // match: (ORshiftLL (MOVWconst [c]) x [d]) 11956 // cond: 11957 // result: (ORconst [c] (SLLconst <x.Type> x [d])) 11958 for { 11959 d := v.AuxInt 11960 _ = v.Args[1] 11961 v_0 := v.Args[0] 11962 if v_0.Op != OpARMMOVWconst { 11963 break 11964 } 11965 c := v_0.AuxInt 11966 x := v.Args[1] 11967 v.reset(OpARMORconst) 11968 v.AuxInt = c 11969 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 11970 v0.AuxInt = d 11971 v0.AddArg(x) 11972 v.AddArg(v0) 11973 return true 11974 } 11975 // match: (ORshiftLL x (MOVWconst [c]) [d]) 11976 // cond: 11977 // result: (ORconst x [int64(int32(uint32(c)<<uint64(d)))]) 11978 for { 11979 d := v.AuxInt 11980 _ = v.Args[1] 11981 x := v.Args[0] 11982 v_1 := v.Args[1] 11983 if v_1.Op != OpARMMOVWconst { 11984 break 11985 } 11986 c := v_1.AuxInt 11987 v.reset(OpARMORconst) 11988 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 11989 v.AddArg(x) 11990 return true 11991 } 11992 // match: (ORshiftLL [c] (SRLconst x [32-c]) x) 11993 // cond: 11994 // result: (SRRconst [32-c] x) 11995 for { 11996 c := v.AuxInt 11997 _ = v.Args[1] 11998 v_0 := v.Args[0] 11999 if v_0.Op != OpARMSRLconst { 12000 break 12001 } 12002 if v_0.AuxInt != 32-c { 12003 break 12004 } 12005 x := v_0.Args[0] 12006 if x != v.Args[1] { 12007 break 12008 } 12009 v.reset(OpARMSRRconst) 12010 v.AuxInt = 32 - c 12011 v.AddArg(x) 12012 return true 12013 } 12014 // match: (ORshiftLL x y:(SLLconst x [c]) [d]) 12015 // cond: c==d 12016 // result: y 12017 for { 12018 d := v.AuxInt 12019 _ = v.Args[1] 12020 x := v.Args[0] 12021 y := v.Args[1] 12022 if y.Op != OpARMSLLconst { 12023 break 12024 } 12025 c := y.AuxInt 12026 if x != y.Args[0] { 12027 break 12028 } 12029 if !(c == d) { 12030 break 12031 } 12032 v.reset(OpCopy) 12033 v.Type = y.Type 12034 v.AddArg(y) 12035 return true 12036 } 12037 return false 12038 } 12039 func rewriteValueARM_OpARMORshiftLLreg_0(v *Value) bool { 12040 b := v.Block 12041 _ = b 12042 // match: (ORshiftLLreg (MOVWconst [c]) x y) 12043 // cond: 12044 // result: (ORconst [c] (SLL <x.Type> x y)) 12045 for { 12046 _ = v.Args[2] 12047 v_0 := v.Args[0] 12048 if v_0.Op != OpARMMOVWconst { 12049 break 12050 } 12051 c := v_0.AuxInt 12052 x := v.Args[1] 12053 y := v.Args[2] 12054 v.reset(OpARMORconst) 12055 v.AuxInt = c 12056 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 12057 v0.AddArg(x) 12058 v0.AddArg(y) 12059 v.AddArg(v0) 12060 return true 12061 } 12062 // match: (ORshiftLLreg x y (MOVWconst [c])) 12063 // cond: 12064 // result: (ORshiftLL x y [c]) 12065 for { 12066 _ = v.Args[2] 12067 x := v.Args[0] 12068 y := v.Args[1] 12069 v_2 := v.Args[2] 12070 if v_2.Op != OpARMMOVWconst { 12071 break 12072 } 12073 c := v_2.AuxInt 12074 v.reset(OpARMORshiftLL) 12075 v.AuxInt = c 12076 v.AddArg(x) 12077 v.AddArg(y) 12078 return true 12079 } 12080 return false 12081 } 12082 func rewriteValueARM_OpARMORshiftRA_0(v *Value) bool { 12083 b := v.Block 12084 _ = b 12085 // match: (ORshiftRA (MOVWconst [c]) x [d]) 12086 // cond: 12087 // result: (ORconst [c] (SRAconst <x.Type> x [d])) 12088 for { 12089 d := v.AuxInt 12090 _ = v.Args[1] 12091 v_0 := v.Args[0] 12092 if v_0.Op != OpARMMOVWconst { 12093 break 12094 } 12095 c := v_0.AuxInt 12096 x := v.Args[1] 12097 v.reset(OpARMORconst) 12098 v.AuxInt = c 12099 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 12100 v0.AuxInt = d 12101 v0.AddArg(x) 12102 v.AddArg(v0) 12103 return true 12104 } 12105 // match: (ORshiftRA x (MOVWconst [c]) [d]) 12106 // cond: 12107 // result: (ORconst x [int64(int32(c)>>uint64(d))]) 12108 for { 12109 d := v.AuxInt 12110 _ = v.Args[1] 12111 x := v.Args[0] 12112 v_1 := v.Args[1] 12113 if v_1.Op != OpARMMOVWconst { 12114 break 12115 } 12116 c := v_1.AuxInt 12117 v.reset(OpARMORconst) 12118 v.AuxInt = int64(int32(c) >> uint64(d)) 12119 v.AddArg(x) 12120 return true 12121 } 12122 // match: (ORshiftRA x y:(SRAconst x [c]) [d]) 12123 // cond: c==d 12124 // result: y 12125 for { 12126 d := v.AuxInt 12127 _ = v.Args[1] 12128 x := v.Args[0] 12129 y := v.Args[1] 12130 if y.Op != OpARMSRAconst { 12131 break 12132 } 12133 c := y.AuxInt 12134 if x != y.Args[0] { 12135 break 12136 } 12137 if !(c == d) { 12138 break 12139 } 12140 v.reset(OpCopy) 12141 v.Type = y.Type 12142 v.AddArg(y) 12143 return true 12144 } 12145 return false 12146 } 12147 func rewriteValueARM_OpARMORshiftRAreg_0(v *Value) bool { 12148 b := v.Block 12149 _ = b 12150 // match: (ORshiftRAreg (MOVWconst [c]) x y) 12151 // cond: 12152 // result: (ORconst [c] (SRA <x.Type> x y)) 12153 for { 12154 _ = v.Args[2] 12155 v_0 := v.Args[0] 12156 if v_0.Op != OpARMMOVWconst { 12157 break 12158 } 12159 c := v_0.AuxInt 12160 x := v.Args[1] 12161 y := v.Args[2] 12162 v.reset(OpARMORconst) 12163 v.AuxInt = c 12164 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 12165 v0.AddArg(x) 12166 v0.AddArg(y) 12167 v.AddArg(v0) 12168 return true 12169 } 12170 // match: (ORshiftRAreg x y (MOVWconst [c])) 12171 // cond: 12172 // result: (ORshiftRA x y [c]) 12173 for { 12174 _ = v.Args[2] 12175 x := v.Args[0] 12176 y := v.Args[1] 12177 v_2 := v.Args[2] 12178 if v_2.Op != OpARMMOVWconst { 12179 break 12180 } 12181 c := v_2.AuxInt 12182 v.reset(OpARMORshiftRA) 12183 v.AuxInt = c 12184 v.AddArg(x) 12185 v.AddArg(y) 12186 return true 12187 } 12188 return false 12189 } 12190 func rewriteValueARM_OpARMORshiftRL_0(v *Value) bool { 12191 b := v.Block 12192 _ = b 12193 // match: (ORshiftRL (MOVWconst [c]) x [d]) 12194 // cond: 12195 // result: (ORconst [c] (SRLconst <x.Type> x [d])) 12196 for { 12197 d := v.AuxInt 12198 _ = v.Args[1] 12199 v_0 := v.Args[0] 12200 if v_0.Op != OpARMMOVWconst { 12201 break 12202 } 12203 c := v_0.AuxInt 12204 x := v.Args[1] 12205 v.reset(OpARMORconst) 12206 v.AuxInt = c 12207 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 12208 v0.AuxInt = d 12209 v0.AddArg(x) 12210 v.AddArg(v0) 12211 return true 12212 } 12213 // match: (ORshiftRL x (MOVWconst [c]) [d]) 12214 // cond: 12215 // result: (ORconst x [int64(int32(uint32(c)>>uint64(d)))]) 12216 for { 12217 d := v.AuxInt 12218 _ = v.Args[1] 12219 x := v.Args[0] 12220 v_1 := v.Args[1] 12221 if v_1.Op != OpARMMOVWconst { 12222 break 12223 } 12224 c := v_1.AuxInt 12225 v.reset(OpARMORconst) 12226 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 12227 v.AddArg(x) 12228 return true 12229 } 12230 // match: (ORshiftRL [c] (SLLconst x [32-c]) x) 12231 // cond: 12232 // result: (SRRconst [ c] x) 12233 for { 12234 c := v.AuxInt 12235 _ = v.Args[1] 12236 v_0 := v.Args[0] 12237 if v_0.Op != OpARMSLLconst { 12238 break 12239 } 12240 if v_0.AuxInt != 32-c { 12241 break 12242 } 12243 x := v_0.Args[0] 12244 if x != v.Args[1] { 12245 break 12246 } 12247 v.reset(OpARMSRRconst) 12248 v.AuxInt = c 12249 v.AddArg(x) 12250 return true 12251 } 12252 // match: (ORshiftRL x y:(SRLconst x [c]) [d]) 12253 // cond: c==d 12254 // result: y 12255 for { 12256 d := v.AuxInt 12257 _ = v.Args[1] 12258 x := v.Args[0] 12259 y := v.Args[1] 12260 if y.Op != OpARMSRLconst { 12261 break 12262 } 12263 c := y.AuxInt 12264 if x != y.Args[0] { 12265 break 12266 } 12267 if !(c == d) { 12268 break 12269 } 12270 v.reset(OpCopy) 12271 v.Type = y.Type 12272 v.AddArg(y) 12273 return true 12274 } 12275 return false 12276 } 12277 func rewriteValueARM_OpARMORshiftRLreg_0(v *Value) bool { 12278 b := v.Block 12279 _ = b 12280 // match: (ORshiftRLreg (MOVWconst [c]) x y) 12281 // cond: 12282 // result: (ORconst [c] (SRL <x.Type> x y)) 12283 for { 12284 _ = v.Args[2] 12285 v_0 := v.Args[0] 12286 if v_0.Op != OpARMMOVWconst { 12287 break 12288 } 12289 c := v_0.AuxInt 12290 x := v.Args[1] 12291 y := v.Args[2] 12292 v.reset(OpARMORconst) 12293 v.AuxInt = c 12294 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 12295 v0.AddArg(x) 12296 v0.AddArg(y) 12297 v.AddArg(v0) 12298 return true 12299 } 12300 // match: (ORshiftRLreg x y (MOVWconst [c])) 12301 // cond: 12302 // result: (ORshiftRL x y [c]) 12303 for { 12304 _ = v.Args[2] 12305 x := v.Args[0] 12306 y := v.Args[1] 12307 v_2 := v.Args[2] 12308 if v_2.Op != OpARMMOVWconst { 12309 break 12310 } 12311 c := v_2.AuxInt 12312 v.reset(OpARMORshiftRL) 12313 v.AuxInt = c 12314 v.AddArg(x) 12315 v.AddArg(y) 12316 return true 12317 } 12318 return false 12319 } 12320 func rewriteValueARM_OpARMRSB_0(v *Value) bool { 12321 // match: (RSB (MOVWconst [c]) x) 12322 // cond: 12323 // result: (SUBconst [c] x) 12324 for { 12325 _ = v.Args[1] 12326 v_0 := v.Args[0] 12327 if v_0.Op != OpARMMOVWconst { 12328 break 12329 } 12330 c := v_0.AuxInt 12331 x := v.Args[1] 12332 v.reset(OpARMSUBconst) 12333 v.AuxInt = c 12334 v.AddArg(x) 12335 return true 12336 } 12337 // match: (RSB x (MOVWconst [c])) 12338 // cond: 12339 // result: (RSBconst [c] x) 12340 for { 12341 _ = v.Args[1] 12342 x := v.Args[0] 12343 v_1 := v.Args[1] 12344 if v_1.Op != OpARMMOVWconst { 12345 break 12346 } 12347 c := v_1.AuxInt 12348 v.reset(OpARMRSBconst) 12349 v.AuxInt = c 12350 v.AddArg(x) 12351 return true 12352 } 12353 // match: (RSB x (SLLconst [c] y)) 12354 // cond: 12355 // result: (RSBshiftLL x y [c]) 12356 for { 12357 _ = v.Args[1] 12358 x := v.Args[0] 12359 v_1 := v.Args[1] 12360 if v_1.Op != OpARMSLLconst { 12361 break 12362 } 12363 c := v_1.AuxInt 12364 y := v_1.Args[0] 12365 v.reset(OpARMRSBshiftLL) 12366 v.AuxInt = c 12367 v.AddArg(x) 12368 v.AddArg(y) 12369 return true 12370 } 12371 // match: (RSB (SLLconst [c] y) x) 12372 // cond: 12373 // result: (SUBshiftLL x y [c]) 12374 for { 12375 _ = v.Args[1] 12376 v_0 := v.Args[0] 12377 if v_0.Op != OpARMSLLconst { 12378 break 12379 } 12380 c := v_0.AuxInt 12381 y := v_0.Args[0] 12382 x := v.Args[1] 12383 v.reset(OpARMSUBshiftLL) 12384 v.AuxInt = c 12385 v.AddArg(x) 12386 v.AddArg(y) 12387 return true 12388 } 12389 // match: (RSB x (SRLconst [c] y)) 12390 // cond: 12391 // result: (RSBshiftRL x y [c]) 12392 for { 12393 _ = v.Args[1] 12394 x := v.Args[0] 12395 v_1 := v.Args[1] 12396 if v_1.Op != OpARMSRLconst { 12397 break 12398 } 12399 c := v_1.AuxInt 12400 y := v_1.Args[0] 12401 v.reset(OpARMRSBshiftRL) 12402 v.AuxInt = c 12403 v.AddArg(x) 12404 v.AddArg(y) 12405 return true 12406 } 12407 // match: (RSB (SRLconst [c] y) x) 12408 // cond: 12409 // result: (SUBshiftRL x y [c]) 12410 for { 12411 _ = v.Args[1] 12412 v_0 := v.Args[0] 12413 if v_0.Op != OpARMSRLconst { 12414 break 12415 } 12416 c := v_0.AuxInt 12417 y := v_0.Args[0] 12418 x := v.Args[1] 12419 v.reset(OpARMSUBshiftRL) 12420 v.AuxInt = c 12421 v.AddArg(x) 12422 v.AddArg(y) 12423 return true 12424 } 12425 // match: (RSB x (SRAconst [c] y)) 12426 // cond: 12427 // result: (RSBshiftRA x y [c]) 12428 for { 12429 _ = v.Args[1] 12430 x := v.Args[0] 12431 v_1 := v.Args[1] 12432 if v_1.Op != OpARMSRAconst { 12433 break 12434 } 12435 c := v_1.AuxInt 12436 y := v_1.Args[0] 12437 v.reset(OpARMRSBshiftRA) 12438 v.AuxInt = c 12439 v.AddArg(x) 12440 v.AddArg(y) 12441 return true 12442 } 12443 // match: (RSB (SRAconst [c] y) x) 12444 // cond: 12445 // result: (SUBshiftRA x y [c]) 12446 for { 12447 _ = v.Args[1] 12448 v_0 := v.Args[0] 12449 if v_0.Op != OpARMSRAconst { 12450 break 12451 } 12452 c := v_0.AuxInt 12453 y := v_0.Args[0] 12454 x := v.Args[1] 12455 v.reset(OpARMSUBshiftRA) 12456 v.AuxInt = c 12457 v.AddArg(x) 12458 v.AddArg(y) 12459 return true 12460 } 12461 // match: (RSB x (SLL y z)) 12462 // cond: 12463 // result: (RSBshiftLLreg x y z) 12464 for { 12465 _ = v.Args[1] 12466 x := v.Args[0] 12467 v_1 := v.Args[1] 12468 if v_1.Op != OpARMSLL { 12469 break 12470 } 12471 _ = v_1.Args[1] 12472 y := v_1.Args[0] 12473 z := v_1.Args[1] 12474 v.reset(OpARMRSBshiftLLreg) 12475 v.AddArg(x) 12476 v.AddArg(y) 12477 v.AddArg(z) 12478 return true 12479 } 12480 // match: (RSB (SLL y z) x) 12481 // cond: 12482 // result: (SUBshiftLLreg x y z) 12483 for { 12484 _ = v.Args[1] 12485 v_0 := v.Args[0] 12486 if v_0.Op != OpARMSLL { 12487 break 12488 } 12489 _ = v_0.Args[1] 12490 y := v_0.Args[0] 12491 z := v_0.Args[1] 12492 x := v.Args[1] 12493 v.reset(OpARMSUBshiftLLreg) 12494 v.AddArg(x) 12495 v.AddArg(y) 12496 v.AddArg(z) 12497 return true 12498 } 12499 return false 12500 } 12501 func rewriteValueARM_OpARMRSB_10(v *Value) bool { 12502 // match: (RSB x (SRL y z)) 12503 // cond: 12504 // result: (RSBshiftRLreg x y z) 12505 for { 12506 _ = v.Args[1] 12507 x := v.Args[0] 12508 v_1 := v.Args[1] 12509 if v_1.Op != OpARMSRL { 12510 break 12511 } 12512 _ = v_1.Args[1] 12513 y := v_1.Args[0] 12514 z := v_1.Args[1] 12515 v.reset(OpARMRSBshiftRLreg) 12516 v.AddArg(x) 12517 v.AddArg(y) 12518 v.AddArg(z) 12519 return true 12520 } 12521 // match: (RSB (SRL y z) x) 12522 // cond: 12523 // result: (SUBshiftRLreg x y z) 12524 for { 12525 _ = v.Args[1] 12526 v_0 := v.Args[0] 12527 if v_0.Op != OpARMSRL { 12528 break 12529 } 12530 _ = v_0.Args[1] 12531 y := v_0.Args[0] 12532 z := v_0.Args[1] 12533 x := v.Args[1] 12534 v.reset(OpARMSUBshiftRLreg) 12535 v.AddArg(x) 12536 v.AddArg(y) 12537 v.AddArg(z) 12538 return true 12539 } 12540 // match: (RSB x (SRA y z)) 12541 // cond: 12542 // result: (RSBshiftRAreg x y z) 12543 for { 12544 _ = v.Args[1] 12545 x := v.Args[0] 12546 v_1 := v.Args[1] 12547 if v_1.Op != OpARMSRA { 12548 break 12549 } 12550 _ = v_1.Args[1] 12551 y := v_1.Args[0] 12552 z := v_1.Args[1] 12553 v.reset(OpARMRSBshiftRAreg) 12554 v.AddArg(x) 12555 v.AddArg(y) 12556 v.AddArg(z) 12557 return true 12558 } 12559 // match: (RSB (SRA y z) x) 12560 // cond: 12561 // result: (SUBshiftRAreg x y z) 12562 for { 12563 _ = v.Args[1] 12564 v_0 := v.Args[0] 12565 if v_0.Op != OpARMSRA { 12566 break 12567 } 12568 _ = v_0.Args[1] 12569 y := v_0.Args[0] 12570 z := v_0.Args[1] 12571 x := v.Args[1] 12572 v.reset(OpARMSUBshiftRAreg) 12573 v.AddArg(x) 12574 v.AddArg(y) 12575 v.AddArg(z) 12576 return true 12577 } 12578 // match: (RSB x x) 12579 // cond: 12580 // result: (MOVWconst [0]) 12581 for { 12582 _ = v.Args[1] 12583 x := v.Args[0] 12584 if x != v.Args[1] { 12585 break 12586 } 12587 v.reset(OpARMMOVWconst) 12588 v.AuxInt = 0 12589 return true 12590 } 12591 // match: (RSB (MUL x y) a) 12592 // cond: objabi.GOARM == 7 12593 // result: (MULS x y a) 12594 for { 12595 _ = v.Args[1] 12596 v_0 := v.Args[0] 12597 if v_0.Op != OpARMMUL { 12598 break 12599 } 12600 _ = v_0.Args[1] 12601 x := v_0.Args[0] 12602 y := v_0.Args[1] 12603 a := v.Args[1] 12604 if !(objabi.GOARM == 7) { 12605 break 12606 } 12607 v.reset(OpARMMULS) 12608 v.AddArg(x) 12609 v.AddArg(y) 12610 v.AddArg(a) 12611 return true 12612 } 12613 return false 12614 } 12615 func rewriteValueARM_OpARMRSBSshiftLL_0(v *Value) bool { 12616 b := v.Block 12617 _ = b 12618 // match: (RSBSshiftLL (MOVWconst [c]) x [d]) 12619 // cond: 12620 // result: (SUBSconst [c] (SLLconst <x.Type> x [d])) 12621 for { 12622 d := v.AuxInt 12623 _ = v.Args[1] 12624 v_0 := v.Args[0] 12625 if v_0.Op != OpARMMOVWconst { 12626 break 12627 } 12628 c := v_0.AuxInt 12629 x := v.Args[1] 12630 v.reset(OpARMSUBSconst) 12631 v.AuxInt = c 12632 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 12633 v0.AuxInt = d 12634 v0.AddArg(x) 12635 v.AddArg(v0) 12636 return true 12637 } 12638 // match: (RSBSshiftLL x (MOVWconst [c]) [d]) 12639 // cond: 12640 // result: (RSBSconst x [int64(int32(uint32(c)<<uint64(d)))]) 12641 for { 12642 d := v.AuxInt 12643 _ = v.Args[1] 12644 x := v.Args[0] 12645 v_1 := v.Args[1] 12646 if v_1.Op != OpARMMOVWconst { 12647 break 12648 } 12649 c := v_1.AuxInt 12650 v.reset(OpARMRSBSconst) 12651 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 12652 v.AddArg(x) 12653 return true 12654 } 12655 return false 12656 } 12657 func rewriteValueARM_OpARMRSBSshiftLLreg_0(v *Value) bool { 12658 b := v.Block 12659 _ = b 12660 // match: (RSBSshiftLLreg (MOVWconst [c]) x y) 12661 // cond: 12662 // result: (SUBSconst [c] (SLL <x.Type> x y)) 12663 for { 12664 _ = v.Args[2] 12665 v_0 := v.Args[0] 12666 if v_0.Op != OpARMMOVWconst { 12667 break 12668 } 12669 c := v_0.AuxInt 12670 x := v.Args[1] 12671 y := v.Args[2] 12672 v.reset(OpARMSUBSconst) 12673 v.AuxInt = c 12674 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 12675 v0.AddArg(x) 12676 v0.AddArg(y) 12677 v.AddArg(v0) 12678 return true 12679 } 12680 // match: (RSBSshiftLLreg x y (MOVWconst [c])) 12681 // cond: 12682 // result: (RSBSshiftLL x y [c]) 12683 for { 12684 _ = v.Args[2] 12685 x := v.Args[0] 12686 y := v.Args[1] 12687 v_2 := v.Args[2] 12688 if v_2.Op != OpARMMOVWconst { 12689 break 12690 } 12691 c := v_2.AuxInt 12692 v.reset(OpARMRSBSshiftLL) 12693 v.AuxInt = c 12694 v.AddArg(x) 12695 v.AddArg(y) 12696 return true 12697 } 12698 return false 12699 } 12700 func rewriteValueARM_OpARMRSBSshiftRA_0(v *Value) bool { 12701 b := v.Block 12702 _ = b 12703 // match: (RSBSshiftRA (MOVWconst [c]) x [d]) 12704 // cond: 12705 // result: (SUBSconst [c] (SRAconst <x.Type> x [d])) 12706 for { 12707 d := v.AuxInt 12708 _ = v.Args[1] 12709 v_0 := v.Args[0] 12710 if v_0.Op != OpARMMOVWconst { 12711 break 12712 } 12713 c := v_0.AuxInt 12714 x := v.Args[1] 12715 v.reset(OpARMSUBSconst) 12716 v.AuxInt = c 12717 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 12718 v0.AuxInt = d 12719 v0.AddArg(x) 12720 v.AddArg(v0) 12721 return true 12722 } 12723 // match: (RSBSshiftRA x (MOVWconst [c]) [d]) 12724 // cond: 12725 // result: (RSBSconst x [int64(int32(c)>>uint64(d))]) 12726 for { 12727 d := v.AuxInt 12728 _ = v.Args[1] 12729 x := v.Args[0] 12730 v_1 := v.Args[1] 12731 if v_1.Op != OpARMMOVWconst { 12732 break 12733 } 12734 c := v_1.AuxInt 12735 v.reset(OpARMRSBSconst) 12736 v.AuxInt = int64(int32(c) >> uint64(d)) 12737 v.AddArg(x) 12738 return true 12739 } 12740 return false 12741 } 12742 func rewriteValueARM_OpARMRSBSshiftRAreg_0(v *Value) bool { 12743 b := v.Block 12744 _ = b 12745 // match: (RSBSshiftRAreg (MOVWconst [c]) x y) 12746 // cond: 12747 // result: (SUBSconst [c] (SRA <x.Type> x y)) 12748 for { 12749 _ = v.Args[2] 12750 v_0 := v.Args[0] 12751 if v_0.Op != OpARMMOVWconst { 12752 break 12753 } 12754 c := v_0.AuxInt 12755 x := v.Args[1] 12756 y := v.Args[2] 12757 v.reset(OpARMSUBSconst) 12758 v.AuxInt = c 12759 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 12760 v0.AddArg(x) 12761 v0.AddArg(y) 12762 v.AddArg(v0) 12763 return true 12764 } 12765 // match: (RSBSshiftRAreg x y (MOVWconst [c])) 12766 // cond: 12767 // result: (RSBSshiftRA x y [c]) 12768 for { 12769 _ = v.Args[2] 12770 x := v.Args[0] 12771 y := v.Args[1] 12772 v_2 := v.Args[2] 12773 if v_2.Op != OpARMMOVWconst { 12774 break 12775 } 12776 c := v_2.AuxInt 12777 v.reset(OpARMRSBSshiftRA) 12778 v.AuxInt = c 12779 v.AddArg(x) 12780 v.AddArg(y) 12781 return true 12782 } 12783 return false 12784 } 12785 func rewriteValueARM_OpARMRSBSshiftRL_0(v *Value) bool { 12786 b := v.Block 12787 _ = b 12788 // match: (RSBSshiftRL (MOVWconst [c]) x [d]) 12789 // cond: 12790 // result: (SUBSconst [c] (SRLconst <x.Type> x [d])) 12791 for { 12792 d := v.AuxInt 12793 _ = v.Args[1] 12794 v_0 := v.Args[0] 12795 if v_0.Op != OpARMMOVWconst { 12796 break 12797 } 12798 c := v_0.AuxInt 12799 x := v.Args[1] 12800 v.reset(OpARMSUBSconst) 12801 v.AuxInt = c 12802 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 12803 v0.AuxInt = d 12804 v0.AddArg(x) 12805 v.AddArg(v0) 12806 return true 12807 } 12808 // match: (RSBSshiftRL x (MOVWconst [c]) [d]) 12809 // cond: 12810 // result: (RSBSconst x [int64(int32(uint32(c)>>uint64(d)))]) 12811 for { 12812 d := v.AuxInt 12813 _ = v.Args[1] 12814 x := v.Args[0] 12815 v_1 := v.Args[1] 12816 if v_1.Op != OpARMMOVWconst { 12817 break 12818 } 12819 c := v_1.AuxInt 12820 v.reset(OpARMRSBSconst) 12821 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 12822 v.AddArg(x) 12823 return true 12824 } 12825 return false 12826 } 12827 func rewriteValueARM_OpARMRSBSshiftRLreg_0(v *Value) bool { 12828 b := v.Block 12829 _ = b 12830 // match: (RSBSshiftRLreg (MOVWconst [c]) x y) 12831 // cond: 12832 // result: (SUBSconst [c] (SRL <x.Type> x y)) 12833 for { 12834 _ = v.Args[2] 12835 v_0 := v.Args[0] 12836 if v_0.Op != OpARMMOVWconst { 12837 break 12838 } 12839 c := v_0.AuxInt 12840 x := v.Args[1] 12841 y := v.Args[2] 12842 v.reset(OpARMSUBSconst) 12843 v.AuxInt = c 12844 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 12845 v0.AddArg(x) 12846 v0.AddArg(y) 12847 v.AddArg(v0) 12848 return true 12849 } 12850 // match: (RSBSshiftRLreg x y (MOVWconst [c])) 12851 // cond: 12852 // result: (RSBSshiftRL x y [c]) 12853 for { 12854 _ = v.Args[2] 12855 x := v.Args[0] 12856 y := v.Args[1] 12857 v_2 := v.Args[2] 12858 if v_2.Op != OpARMMOVWconst { 12859 break 12860 } 12861 c := v_2.AuxInt 12862 v.reset(OpARMRSBSshiftRL) 12863 v.AuxInt = c 12864 v.AddArg(x) 12865 v.AddArg(y) 12866 return true 12867 } 12868 return false 12869 } 12870 func rewriteValueARM_OpARMRSBconst_0(v *Value) bool { 12871 // match: (RSBconst [c] (MOVWconst [d])) 12872 // cond: 12873 // result: (MOVWconst [int64(int32(c-d))]) 12874 for { 12875 c := v.AuxInt 12876 v_0 := v.Args[0] 12877 if v_0.Op != OpARMMOVWconst { 12878 break 12879 } 12880 d := v_0.AuxInt 12881 v.reset(OpARMMOVWconst) 12882 v.AuxInt = int64(int32(c - d)) 12883 return true 12884 } 12885 // match: (RSBconst [c] (RSBconst [d] x)) 12886 // cond: 12887 // result: (ADDconst [int64(int32(c-d))] x) 12888 for { 12889 c := v.AuxInt 12890 v_0 := v.Args[0] 12891 if v_0.Op != OpARMRSBconst { 12892 break 12893 } 12894 d := v_0.AuxInt 12895 x := v_0.Args[0] 12896 v.reset(OpARMADDconst) 12897 v.AuxInt = int64(int32(c - d)) 12898 v.AddArg(x) 12899 return true 12900 } 12901 // match: (RSBconst [c] (ADDconst [d] x)) 12902 // cond: 12903 // result: (RSBconst [int64(int32(c-d))] x) 12904 for { 12905 c := v.AuxInt 12906 v_0 := v.Args[0] 12907 if v_0.Op != OpARMADDconst { 12908 break 12909 } 12910 d := v_0.AuxInt 12911 x := v_0.Args[0] 12912 v.reset(OpARMRSBconst) 12913 v.AuxInt = int64(int32(c - d)) 12914 v.AddArg(x) 12915 return true 12916 } 12917 // match: (RSBconst [c] (SUBconst [d] x)) 12918 // cond: 12919 // result: (RSBconst [int64(int32(c+d))] x) 12920 for { 12921 c := v.AuxInt 12922 v_0 := v.Args[0] 12923 if v_0.Op != OpARMSUBconst { 12924 break 12925 } 12926 d := v_0.AuxInt 12927 x := v_0.Args[0] 12928 v.reset(OpARMRSBconst) 12929 v.AuxInt = int64(int32(c + d)) 12930 v.AddArg(x) 12931 return true 12932 } 12933 return false 12934 } 12935 func rewriteValueARM_OpARMRSBshiftLL_0(v *Value) bool { 12936 b := v.Block 12937 _ = b 12938 // match: (RSBshiftLL (MOVWconst [c]) x [d]) 12939 // cond: 12940 // result: (SUBconst [c] (SLLconst <x.Type> x [d])) 12941 for { 12942 d := v.AuxInt 12943 _ = v.Args[1] 12944 v_0 := v.Args[0] 12945 if v_0.Op != OpARMMOVWconst { 12946 break 12947 } 12948 c := v_0.AuxInt 12949 x := v.Args[1] 12950 v.reset(OpARMSUBconst) 12951 v.AuxInt = c 12952 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 12953 v0.AuxInt = d 12954 v0.AddArg(x) 12955 v.AddArg(v0) 12956 return true 12957 } 12958 // match: (RSBshiftLL x (MOVWconst [c]) [d]) 12959 // cond: 12960 // result: (RSBconst x [int64(int32(uint32(c)<<uint64(d)))]) 12961 for { 12962 d := v.AuxInt 12963 _ = v.Args[1] 12964 x := v.Args[0] 12965 v_1 := v.Args[1] 12966 if v_1.Op != OpARMMOVWconst { 12967 break 12968 } 12969 c := v_1.AuxInt 12970 v.reset(OpARMRSBconst) 12971 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 12972 v.AddArg(x) 12973 return true 12974 } 12975 // match: (RSBshiftLL x (SLLconst x [c]) [d]) 12976 // cond: c==d 12977 // result: (MOVWconst [0]) 12978 for { 12979 d := v.AuxInt 12980 _ = v.Args[1] 12981 x := v.Args[0] 12982 v_1 := v.Args[1] 12983 if v_1.Op != OpARMSLLconst { 12984 break 12985 } 12986 c := v_1.AuxInt 12987 if x != v_1.Args[0] { 12988 break 12989 } 12990 if !(c == d) { 12991 break 12992 } 12993 v.reset(OpARMMOVWconst) 12994 v.AuxInt = 0 12995 return true 12996 } 12997 return false 12998 } 12999 func rewriteValueARM_OpARMRSBshiftLLreg_0(v *Value) bool { 13000 b := v.Block 13001 _ = b 13002 // match: (RSBshiftLLreg (MOVWconst [c]) x y) 13003 // cond: 13004 // result: (SUBconst [c] (SLL <x.Type> x y)) 13005 for { 13006 _ = v.Args[2] 13007 v_0 := v.Args[0] 13008 if v_0.Op != OpARMMOVWconst { 13009 break 13010 } 13011 c := v_0.AuxInt 13012 x := v.Args[1] 13013 y := v.Args[2] 13014 v.reset(OpARMSUBconst) 13015 v.AuxInt = c 13016 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 13017 v0.AddArg(x) 13018 v0.AddArg(y) 13019 v.AddArg(v0) 13020 return true 13021 } 13022 // match: (RSBshiftLLreg x y (MOVWconst [c])) 13023 // cond: 13024 // result: (RSBshiftLL x y [c]) 13025 for { 13026 _ = v.Args[2] 13027 x := v.Args[0] 13028 y := v.Args[1] 13029 v_2 := v.Args[2] 13030 if v_2.Op != OpARMMOVWconst { 13031 break 13032 } 13033 c := v_2.AuxInt 13034 v.reset(OpARMRSBshiftLL) 13035 v.AuxInt = c 13036 v.AddArg(x) 13037 v.AddArg(y) 13038 return true 13039 } 13040 return false 13041 } 13042 func rewriteValueARM_OpARMRSBshiftRA_0(v *Value) bool { 13043 b := v.Block 13044 _ = b 13045 // match: (RSBshiftRA (MOVWconst [c]) x [d]) 13046 // cond: 13047 // result: (SUBconst [c] (SRAconst <x.Type> x [d])) 13048 for { 13049 d := v.AuxInt 13050 _ = v.Args[1] 13051 v_0 := v.Args[0] 13052 if v_0.Op != OpARMMOVWconst { 13053 break 13054 } 13055 c := v_0.AuxInt 13056 x := v.Args[1] 13057 v.reset(OpARMSUBconst) 13058 v.AuxInt = c 13059 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 13060 v0.AuxInt = d 13061 v0.AddArg(x) 13062 v.AddArg(v0) 13063 return true 13064 } 13065 // match: (RSBshiftRA x (MOVWconst [c]) [d]) 13066 // cond: 13067 // result: (RSBconst x [int64(int32(c)>>uint64(d))]) 13068 for { 13069 d := v.AuxInt 13070 _ = v.Args[1] 13071 x := v.Args[0] 13072 v_1 := v.Args[1] 13073 if v_1.Op != OpARMMOVWconst { 13074 break 13075 } 13076 c := v_1.AuxInt 13077 v.reset(OpARMRSBconst) 13078 v.AuxInt = int64(int32(c) >> uint64(d)) 13079 v.AddArg(x) 13080 return true 13081 } 13082 // match: (RSBshiftRA x (SRAconst x [c]) [d]) 13083 // cond: c==d 13084 // result: (MOVWconst [0]) 13085 for { 13086 d := v.AuxInt 13087 _ = v.Args[1] 13088 x := v.Args[0] 13089 v_1 := v.Args[1] 13090 if v_1.Op != OpARMSRAconst { 13091 break 13092 } 13093 c := v_1.AuxInt 13094 if x != v_1.Args[0] { 13095 break 13096 } 13097 if !(c == d) { 13098 break 13099 } 13100 v.reset(OpARMMOVWconst) 13101 v.AuxInt = 0 13102 return true 13103 } 13104 return false 13105 } 13106 func rewriteValueARM_OpARMRSBshiftRAreg_0(v *Value) bool { 13107 b := v.Block 13108 _ = b 13109 // match: (RSBshiftRAreg (MOVWconst [c]) x y) 13110 // cond: 13111 // result: (SUBconst [c] (SRA <x.Type> x y)) 13112 for { 13113 _ = v.Args[2] 13114 v_0 := v.Args[0] 13115 if v_0.Op != OpARMMOVWconst { 13116 break 13117 } 13118 c := v_0.AuxInt 13119 x := v.Args[1] 13120 y := v.Args[2] 13121 v.reset(OpARMSUBconst) 13122 v.AuxInt = c 13123 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 13124 v0.AddArg(x) 13125 v0.AddArg(y) 13126 v.AddArg(v0) 13127 return true 13128 } 13129 // match: (RSBshiftRAreg x y (MOVWconst [c])) 13130 // cond: 13131 // result: (RSBshiftRA x y [c]) 13132 for { 13133 _ = v.Args[2] 13134 x := v.Args[0] 13135 y := v.Args[1] 13136 v_2 := v.Args[2] 13137 if v_2.Op != OpARMMOVWconst { 13138 break 13139 } 13140 c := v_2.AuxInt 13141 v.reset(OpARMRSBshiftRA) 13142 v.AuxInt = c 13143 v.AddArg(x) 13144 v.AddArg(y) 13145 return true 13146 } 13147 return false 13148 } 13149 func rewriteValueARM_OpARMRSBshiftRL_0(v *Value) bool { 13150 b := v.Block 13151 _ = b 13152 // match: (RSBshiftRL (MOVWconst [c]) x [d]) 13153 // cond: 13154 // result: (SUBconst [c] (SRLconst <x.Type> x [d])) 13155 for { 13156 d := v.AuxInt 13157 _ = v.Args[1] 13158 v_0 := v.Args[0] 13159 if v_0.Op != OpARMMOVWconst { 13160 break 13161 } 13162 c := v_0.AuxInt 13163 x := v.Args[1] 13164 v.reset(OpARMSUBconst) 13165 v.AuxInt = c 13166 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 13167 v0.AuxInt = d 13168 v0.AddArg(x) 13169 v.AddArg(v0) 13170 return true 13171 } 13172 // match: (RSBshiftRL x (MOVWconst [c]) [d]) 13173 // cond: 13174 // result: (RSBconst x [int64(int32(uint32(c)>>uint64(d)))]) 13175 for { 13176 d := v.AuxInt 13177 _ = v.Args[1] 13178 x := v.Args[0] 13179 v_1 := v.Args[1] 13180 if v_1.Op != OpARMMOVWconst { 13181 break 13182 } 13183 c := v_1.AuxInt 13184 v.reset(OpARMRSBconst) 13185 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 13186 v.AddArg(x) 13187 return true 13188 } 13189 // match: (RSBshiftRL x (SRLconst x [c]) [d]) 13190 // cond: c==d 13191 // result: (MOVWconst [0]) 13192 for { 13193 d := v.AuxInt 13194 _ = v.Args[1] 13195 x := v.Args[0] 13196 v_1 := v.Args[1] 13197 if v_1.Op != OpARMSRLconst { 13198 break 13199 } 13200 c := v_1.AuxInt 13201 if x != v_1.Args[0] { 13202 break 13203 } 13204 if !(c == d) { 13205 break 13206 } 13207 v.reset(OpARMMOVWconst) 13208 v.AuxInt = 0 13209 return true 13210 } 13211 return false 13212 } 13213 func rewriteValueARM_OpARMRSBshiftRLreg_0(v *Value) bool { 13214 b := v.Block 13215 _ = b 13216 // match: (RSBshiftRLreg (MOVWconst [c]) x y) 13217 // cond: 13218 // result: (SUBconst [c] (SRL <x.Type> x y)) 13219 for { 13220 _ = v.Args[2] 13221 v_0 := v.Args[0] 13222 if v_0.Op != OpARMMOVWconst { 13223 break 13224 } 13225 c := v_0.AuxInt 13226 x := v.Args[1] 13227 y := v.Args[2] 13228 v.reset(OpARMSUBconst) 13229 v.AuxInt = c 13230 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 13231 v0.AddArg(x) 13232 v0.AddArg(y) 13233 v.AddArg(v0) 13234 return true 13235 } 13236 // match: (RSBshiftRLreg x y (MOVWconst [c])) 13237 // cond: 13238 // result: (RSBshiftRL x y [c]) 13239 for { 13240 _ = v.Args[2] 13241 x := v.Args[0] 13242 y := v.Args[1] 13243 v_2 := v.Args[2] 13244 if v_2.Op != OpARMMOVWconst { 13245 break 13246 } 13247 c := v_2.AuxInt 13248 v.reset(OpARMRSBshiftRL) 13249 v.AuxInt = c 13250 v.AddArg(x) 13251 v.AddArg(y) 13252 return true 13253 } 13254 return false 13255 } 13256 func rewriteValueARM_OpARMRSCconst_0(v *Value) bool { 13257 // match: (RSCconst [c] (ADDconst [d] x) flags) 13258 // cond: 13259 // result: (RSCconst [int64(int32(c-d))] x flags) 13260 for { 13261 c := v.AuxInt 13262 _ = v.Args[1] 13263 v_0 := v.Args[0] 13264 if v_0.Op != OpARMADDconst { 13265 break 13266 } 13267 d := v_0.AuxInt 13268 x := v_0.Args[0] 13269 flags := v.Args[1] 13270 v.reset(OpARMRSCconst) 13271 v.AuxInt = int64(int32(c - d)) 13272 v.AddArg(x) 13273 v.AddArg(flags) 13274 return true 13275 } 13276 // match: (RSCconst [c] (SUBconst [d] x) flags) 13277 // cond: 13278 // result: (RSCconst [int64(int32(c+d))] x flags) 13279 for { 13280 c := v.AuxInt 13281 _ = v.Args[1] 13282 v_0 := v.Args[0] 13283 if v_0.Op != OpARMSUBconst { 13284 break 13285 } 13286 d := v_0.AuxInt 13287 x := v_0.Args[0] 13288 flags := v.Args[1] 13289 v.reset(OpARMRSCconst) 13290 v.AuxInt = int64(int32(c + d)) 13291 v.AddArg(x) 13292 v.AddArg(flags) 13293 return true 13294 } 13295 return false 13296 } 13297 func rewriteValueARM_OpARMRSCshiftLL_0(v *Value) bool { 13298 b := v.Block 13299 _ = b 13300 // match: (RSCshiftLL (MOVWconst [c]) x [d] flags) 13301 // cond: 13302 // result: (SBCconst [c] (SLLconst <x.Type> x [d]) flags) 13303 for { 13304 d := v.AuxInt 13305 _ = v.Args[2] 13306 v_0 := v.Args[0] 13307 if v_0.Op != OpARMMOVWconst { 13308 break 13309 } 13310 c := v_0.AuxInt 13311 x := v.Args[1] 13312 flags := v.Args[2] 13313 v.reset(OpARMSBCconst) 13314 v.AuxInt = c 13315 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 13316 v0.AuxInt = d 13317 v0.AddArg(x) 13318 v.AddArg(v0) 13319 v.AddArg(flags) 13320 return true 13321 } 13322 // match: (RSCshiftLL x (MOVWconst [c]) [d] flags) 13323 // cond: 13324 // result: (RSCconst x [int64(int32(uint32(c)<<uint64(d)))] flags) 13325 for { 13326 d := v.AuxInt 13327 _ = v.Args[2] 13328 x := v.Args[0] 13329 v_1 := v.Args[1] 13330 if v_1.Op != OpARMMOVWconst { 13331 break 13332 } 13333 c := v_1.AuxInt 13334 flags := v.Args[2] 13335 v.reset(OpARMRSCconst) 13336 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 13337 v.AddArg(x) 13338 v.AddArg(flags) 13339 return true 13340 } 13341 return false 13342 } 13343 func rewriteValueARM_OpARMRSCshiftLLreg_0(v *Value) bool { 13344 b := v.Block 13345 _ = b 13346 // match: (RSCshiftLLreg (MOVWconst [c]) x y flags) 13347 // cond: 13348 // result: (SBCconst [c] (SLL <x.Type> x y) flags) 13349 for { 13350 _ = v.Args[3] 13351 v_0 := v.Args[0] 13352 if v_0.Op != OpARMMOVWconst { 13353 break 13354 } 13355 c := v_0.AuxInt 13356 x := v.Args[1] 13357 y := v.Args[2] 13358 flags := v.Args[3] 13359 v.reset(OpARMSBCconst) 13360 v.AuxInt = c 13361 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 13362 v0.AddArg(x) 13363 v0.AddArg(y) 13364 v.AddArg(v0) 13365 v.AddArg(flags) 13366 return true 13367 } 13368 // match: (RSCshiftLLreg x y (MOVWconst [c]) flags) 13369 // cond: 13370 // result: (RSCshiftLL x y [c] flags) 13371 for { 13372 _ = v.Args[3] 13373 x := v.Args[0] 13374 y := v.Args[1] 13375 v_2 := v.Args[2] 13376 if v_2.Op != OpARMMOVWconst { 13377 break 13378 } 13379 c := v_2.AuxInt 13380 flags := v.Args[3] 13381 v.reset(OpARMRSCshiftLL) 13382 v.AuxInt = c 13383 v.AddArg(x) 13384 v.AddArg(y) 13385 v.AddArg(flags) 13386 return true 13387 } 13388 return false 13389 } 13390 func rewriteValueARM_OpARMRSCshiftRA_0(v *Value) bool { 13391 b := v.Block 13392 _ = b 13393 // match: (RSCshiftRA (MOVWconst [c]) x [d] flags) 13394 // cond: 13395 // result: (SBCconst [c] (SRAconst <x.Type> x [d]) flags) 13396 for { 13397 d := v.AuxInt 13398 _ = v.Args[2] 13399 v_0 := v.Args[0] 13400 if v_0.Op != OpARMMOVWconst { 13401 break 13402 } 13403 c := v_0.AuxInt 13404 x := v.Args[1] 13405 flags := v.Args[2] 13406 v.reset(OpARMSBCconst) 13407 v.AuxInt = c 13408 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 13409 v0.AuxInt = d 13410 v0.AddArg(x) 13411 v.AddArg(v0) 13412 v.AddArg(flags) 13413 return true 13414 } 13415 // match: (RSCshiftRA x (MOVWconst [c]) [d] flags) 13416 // cond: 13417 // result: (RSCconst x [int64(int32(c)>>uint64(d))] flags) 13418 for { 13419 d := v.AuxInt 13420 _ = v.Args[2] 13421 x := v.Args[0] 13422 v_1 := v.Args[1] 13423 if v_1.Op != OpARMMOVWconst { 13424 break 13425 } 13426 c := v_1.AuxInt 13427 flags := v.Args[2] 13428 v.reset(OpARMRSCconst) 13429 v.AuxInt = int64(int32(c) >> uint64(d)) 13430 v.AddArg(x) 13431 v.AddArg(flags) 13432 return true 13433 } 13434 return false 13435 } 13436 func rewriteValueARM_OpARMRSCshiftRAreg_0(v *Value) bool { 13437 b := v.Block 13438 _ = b 13439 // match: (RSCshiftRAreg (MOVWconst [c]) x y flags) 13440 // cond: 13441 // result: (SBCconst [c] (SRA <x.Type> x y) flags) 13442 for { 13443 _ = v.Args[3] 13444 v_0 := v.Args[0] 13445 if v_0.Op != OpARMMOVWconst { 13446 break 13447 } 13448 c := v_0.AuxInt 13449 x := v.Args[1] 13450 y := v.Args[2] 13451 flags := v.Args[3] 13452 v.reset(OpARMSBCconst) 13453 v.AuxInt = c 13454 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 13455 v0.AddArg(x) 13456 v0.AddArg(y) 13457 v.AddArg(v0) 13458 v.AddArg(flags) 13459 return true 13460 } 13461 // match: (RSCshiftRAreg x y (MOVWconst [c]) flags) 13462 // cond: 13463 // result: (RSCshiftRA x y [c] flags) 13464 for { 13465 _ = v.Args[3] 13466 x := v.Args[0] 13467 y := v.Args[1] 13468 v_2 := v.Args[2] 13469 if v_2.Op != OpARMMOVWconst { 13470 break 13471 } 13472 c := v_2.AuxInt 13473 flags := v.Args[3] 13474 v.reset(OpARMRSCshiftRA) 13475 v.AuxInt = c 13476 v.AddArg(x) 13477 v.AddArg(y) 13478 v.AddArg(flags) 13479 return true 13480 } 13481 return false 13482 } 13483 func rewriteValueARM_OpARMRSCshiftRL_0(v *Value) bool { 13484 b := v.Block 13485 _ = b 13486 // match: (RSCshiftRL (MOVWconst [c]) x [d] flags) 13487 // cond: 13488 // result: (SBCconst [c] (SRLconst <x.Type> x [d]) flags) 13489 for { 13490 d := v.AuxInt 13491 _ = v.Args[2] 13492 v_0 := v.Args[0] 13493 if v_0.Op != OpARMMOVWconst { 13494 break 13495 } 13496 c := v_0.AuxInt 13497 x := v.Args[1] 13498 flags := v.Args[2] 13499 v.reset(OpARMSBCconst) 13500 v.AuxInt = c 13501 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 13502 v0.AuxInt = d 13503 v0.AddArg(x) 13504 v.AddArg(v0) 13505 v.AddArg(flags) 13506 return true 13507 } 13508 // match: (RSCshiftRL x (MOVWconst [c]) [d] flags) 13509 // cond: 13510 // result: (RSCconst x [int64(int32(uint32(c)>>uint64(d)))] flags) 13511 for { 13512 d := v.AuxInt 13513 _ = v.Args[2] 13514 x := v.Args[0] 13515 v_1 := v.Args[1] 13516 if v_1.Op != OpARMMOVWconst { 13517 break 13518 } 13519 c := v_1.AuxInt 13520 flags := v.Args[2] 13521 v.reset(OpARMRSCconst) 13522 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 13523 v.AddArg(x) 13524 v.AddArg(flags) 13525 return true 13526 } 13527 return false 13528 } 13529 func rewriteValueARM_OpARMRSCshiftRLreg_0(v *Value) bool { 13530 b := v.Block 13531 _ = b 13532 // match: (RSCshiftRLreg (MOVWconst [c]) x y flags) 13533 // cond: 13534 // result: (SBCconst [c] (SRL <x.Type> x y) flags) 13535 for { 13536 _ = v.Args[3] 13537 v_0 := v.Args[0] 13538 if v_0.Op != OpARMMOVWconst { 13539 break 13540 } 13541 c := v_0.AuxInt 13542 x := v.Args[1] 13543 y := v.Args[2] 13544 flags := v.Args[3] 13545 v.reset(OpARMSBCconst) 13546 v.AuxInt = c 13547 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 13548 v0.AddArg(x) 13549 v0.AddArg(y) 13550 v.AddArg(v0) 13551 v.AddArg(flags) 13552 return true 13553 } 13554 // match: (RSCshiftRLreg x y (MOVWconst [c]) flags) 13555 // cond: 13556 // result: (RSCshiftRL x y [c] flags) 13557 for { 13558 _ = v.Args[3] 13559 x := v.Args[0] 13560 y := v.Args[1] 13561 v_2 := v.Args[2] 13562 if v_2.Op != OpARMMOVWconst { 13563 break 13564 } 13565 c := v_2.AuxInt 13566 flags := v.Args[3] 13567 v.reset(OpARMRSCshiftRL) 13568 v.AuxInt = c 13569 v.AddArg(x) 13570 v.AddArg(y) 13571 v.AddArg(flags) 13572 return true 13573 } 13574 return false 13575 } 13576 func rewriteValueARM_OpARMSBC_0(v *Value) bool { 13577 // match: (SBC (MOVWconst [c]) x flags) 13578 // cond: 13579 // result: (RSCconst [c] x flags) 13580 for { 13581 _ = v.Args[2] 13582 v_0 := v.Args[0] 13583 if v_0.Op != OpARMMOVWconst { 13584 break 13585 } 13586 c := v_0.AuxInt 13587 x := v.Args[1] 13588 flags := v.Args[2] 13589 v.reset(OpARMRSCconst) 13590 v.AuxInt = c 13591 v.AddArg(x) 13592 v.AddArg(flags) 13593 return true 13594 } 13595 // match: (SBC x (MOVWconst [c]) flags) 13596 // cond: 13597 // result: (SBCconst [c] x flags) 13598 for { 13599 _ = v.Args[2] 13600 x := v.Args[0] 13601 v_1 := v.Args[1] 13602 if v_1.Op != OpARMMOVWconst { 13603 break 13604 } 13605 c := v_1.AuxInt 13606 flags := v.Args[2] 13607 v.reset(OpARMSBCconst) 13608 v.AuxInt = c 13609 v.AddArg(x) 13610 v.AddArg(flags) 13611 return true 13612 } 13613 // match: (SBC x (SLLconst [c] y) flags) 13614 // cond: 13615 // result: (SBCshiftLL x y [c] flags) 13616 for { 13617 _ = v.Args[2] 13618 x := v.Args[0] 13619 v_1 := v.Args[1] 13620 if v_1.Op != OpARMSLLconst { 13621 break 13622 } 13623 c := v_1.AuxInt 13624 y := v_1.Args[0] 13625 flags := v.Args[2] 13626 v.reset(OpARMSBCshiftLL) 13627 v.AuxInt = c 13628 v.AddArg(x) 13629 v.AddArg(y) 13630 v.AddArg(flags) 13631 return true 13632 } 13633 // match: (SBC (SLLconst [c] y) x flags) 13634 // cond: 13635 // result: (RSCshiftLL x y [c] flags) 13636 for { 13637 _ = v.Args[2] 13638 v_0 := v.Args[0] 13639 if v_0.Op != OpARMSLLconst { 13640 break 13641 } 13642 c := v_0.AuxInt 13643 y := v_0.Args[0] 13644 x := v.Args[1] 13645 flags := v.Args[2] 13646 v.reset(OpARMRSCshiftLL) 13647 v.AuxInt = c 13648 v.AddArg(x) 13649 v.AddArg(y) 13650 v.AddArg(flags) 13651 return true 13652 } 13653 // match: (SBC x (SRLconst [c] y) flags) 13654 // cond: 13655 // result: (SBCshiftRL x y [c] flags) 13656 for { 13657 _ = v.Args[2] 13658 x := v.Args[0] 13659 v_1 := v.Args[1] 13660 if v_1.Op != OpARMSRLconst { 13661 break 13662 } 13663 c := v_1.AuxInt 13664 y := v_1.Args[0] 13665 flags := v.Args[2] 13666 v.reset(OpARMSBCshiftRL) 13667 v.AuxInt = c 13668 v.AddArg(x) 13669 v.AddArg(y) 13670 v.AddArg(flags) 13671 return true 13672 } 13673 // match: (SBC (SRLconst [c] y) x flags) 13674 // cond: 13675 // result: (RSCshiftRL x y [c] flags) 13676 for { 13677 _ = v.Args[2] 13678 v_0 := v.Args[0] 13679 if v_0.Op != OpARMSRLconst { 13680 break 13681 } 13682 c := v_0.AuxInt 13683 y := v_0.Args[0] 13684 x := v.Args[1] 13685 flags := v.Args[2] 13686 v.reset(OpARMRSCshiftRL) 13687 v.AuxInt = c 13688 v.AddArg(x) 13689 v.AddArg(y) 13690 v.AddArg(flags) 13691 return true 13692 } 13693 // match: (SBC x (SRAconst [c] y) flags) 13694 // cond: 13695 // result: (SBCshiftRA x y [c] flags) 13696 for { 13697 _ = v.Args[2] 13698 x := v.Args[0] 13699 v_1 := v.Args[1] 13700 if v_1.Op != OpARMSRAconst { 13701 break 13702 } 13703 c := v_1.AuxInt 13704 y := v_1.Args[0] 13705 flags := v.Args[2] 13706 v.reset(OpARMSBCshiftRA) 13707 v.AuxInt = c 13708 v.AddArg(x) 13709 v.AddArg(y) 13710 v.AddArg(flags) 13711 return true 13712 } 13713 // match: (SBC (SRAconst [c] y) x flags) 13714 // cond: 13715 // result: (RSCshiftRA x y [c] flags) 13716 for { 13717 _ = v.Args[2] 13718 v_0 := v.Args[0] 13719 if v_0.Op != OpARMSRAconst { 13720 break 13721 } 13722 c := v_0.AuxInt 13723 y := v_0.Args[0] 13724 x := v.Args[1] 13725 flags := v.Args[2] 13726 v.reset(OpARMRSCshiftRA) 13727 v.AuxInt = c 13728 v.AddArg(x) 13729 v.AddArg(y) 13730 v.AddArg(flags) 13731 return true 13732 } 13733 // match: (SBC x (SLL y z) flags) 13734 // cond: 13735 // result: (SBCshiftLLreg x y z flags) 13736 for { 13737 _ = v.Args[2] 13738 x := v.Args[0] 13739 v_1 := v.Args[1] 13740 if v_1.Op != OpARMSLL { 13741 break 13742 } 13743 _ = v_1.Args[1] 13744 y := v_1.Args[0] 13745 z := v_1.Args[1] 13746 flags := v.Args[2] 13747 v.reset(OpARMSBCshiftLLreg) 13748 v.AddArg(x) 13749 v.AddArg(y) 13750 v.AddArg(z) 13751 v.AddArg(flags) 13752 return true 13753 } 13754 // match: (SBC (SLL y z) x flags) 13755 // cond: 13756 // result: (RSCshiftLLreg x y z flags) 13757 for { 13758 _ = v.Args[2] 13759 v_0 := v.Args[0] 13760 if v_0.Op != OpARMSLL { 13761 break 13762 } 13763 _ = v_0.Args[1] 13764 y := v_0.Args[0] 13765 z := v_0.Args[1] 13766 x := v.Args[1] 13767 flags := v.Args[2] 13768 v.reset(OpARMRSCshiftLLreg) 13769 v.AddArg(x) 13770 v.AddArg(y) 13771 v.AddArg(z) 13772 v.AddArg(flags) 13773 return true 13774 } 13775 return false 13776 } 13777 func rewriteValueARM_OpARMSBC_10(v *Value) bool { 13778 // match: (SBC x (SRL y z) flags) 13779 // cond: 13780 // result: (SBCshiftRLreg x y z flags) 13781 for { 13782 _ = v.Args[2] 13783 x := v.Args[0] 13784 v_1 := v.Args[1] 13785 if v_1.Op != OpARMSRL { 13786 break 13787 } 13788 _ = v_1.Args[1] 13789 y := v_1.Args[0] 13790 z := v_1.Args[1] 13791 flags := v.Args[2] 13792 v.reset(OpARMSBCshiftRLreg) 13793 v.AddArg(x) 13794 v.AddArg(y) 13795 v.AddArg(z) 13796 v.AddArg(flags) 13797 return true 13798 } 13799 // match: (SBC (SRL y z) x flags) 13800 // cond: 13801 // result: (RSCshiftRLreg x y z flags) 13802 for { 13803 _ = v.Args[2] 13804 v_0 := v.Args[0] 13805 if v_0.Op != OpARMSRL { 13806 break 13807 } 13808 _ = v_0.Args[1] 13809 y := v_0.Args[0] 13810 z := v_0.Args[1] 13811 x := v.Args[1] 13812 flags := v.Args[2] 13813 v.reset(OpARMRSCshiftRLreg) 13814 v.AddArg(x) 13815 v.AddArg(y) 13816 v.AddArg(z) 13817 v.AddArg(flags) 13818 return true 13819 } 13820 // match: (SBC x (SRA y z) flags) 13821 // cond: 13822 // result: (SBCshiftRAreg x y z flags) 13823 for { 13824 _ = v.Args[2] 13825 x := v.Args[0] 13826 v_1 := v.Args[1] 13827 if v_1.Op != OpARMSRA { 13828 break 13829 } 13830 _ = v_1.Args[1] 13831 y := v_1.Args[0] 13832 z := v_1.Args[1] 13833 flags := v.Args[2] 13834 v.reset(OpARMSBCshiftRAreg) 13835 v.AddArg(x) 13836 v.AddArg(y) 13837 v.AddArg(z) 13838 v.AddArg(flags) 13839 return true 13840 } 13841 // match: (SBC (SRA y z) x flags) 13842 // cond: 13843 // result: (RSCshiftRAreg x y z flags) 13844 for { 13845 _ = v.Args[2] 13846 v_0 := v.Args[0] 13847 if v_0.Op != OpARMSRA { 13848 break 13849 } 13850 _ = v_0.Args[1] 13851 y := v_0.Args[0] 13852 z := v_0.Args[1] 13853 x := v.Args[1] 13854 flags := v.Args[2] 13855 v.reset(OpARMRSCshiftRAreg) 13856 v.AddArg(x) 13857 v.AddArg(y) 13858 v.AddArg(z) 13859 v.AddArg(flags) 13860 return true 13861 } 13862 return false 13863 } 13864 func rewriteValueARM_OpARMSBCconst_0(v *Value) bool { 13865 // match: (SBCconst [c] (ADDconst [d] x) flags) 13866 // cond: 13867 // result: (SBCconst [int64(int32(c-d))] x flags) 13868 for { 13869 c := v.AuxInt 13870 _ = v.Args[1] 13871 v_0 := v.Args[0] 13872 if v_0.Op != OpARMADDconst { 13873 break 13874 } 13875 d := v_0.AuxInt 13876 x := v_0.Args[0] 13877 flags := v.Args[1] 13878 v.reset(OpARMSBCconst) 13879 v.AuxInt = int64(int32(c - d)) 13880 v.AddArg(x) 13881 v.AddArg(flags) 13882 return true 13883 } 13884 // match: (SBCconst [c] (SUBconst [d] x) flags) 13885 // cond: 13886 // result: (SBCconst [int64(int32(c+d))] x flags) 13887 for { 13888 c := v.AuxInt 13889 _ = v.Args[1] 13890 v_0 := v.Args[0] 13891 if v_0.Op != OpARMSUBconst { 13892 break 13893 } 13894 d := v_0.AuxInt 13895 x := v_0.Args[0] 13896 flags := v.Args[1] 13897 v.reset(OpARMSBCconst) 13898 v.AuxInt = int64(int32(c + d)) 13899 v.AddArg(x) 13900 v.AddArg(flags) 13901 return true 13902 } 13903 return false 13904 } 13905 func rewriteValueARM_OpARMSBCshiftLL_0(v *Value) bool { 13906 b := v.Block 13907 _ = b 13908 // match: (SBCshiftLL (MOVWconst [c]) x [d] flags) 13909 // cond: 13910 // result: (RSCconst [c] (SLLconst <x.Type> x [d]) flags) 13911 for { 13912 d := v.AuxInt 13913 _ = v.Args[2] 13914 v_0 := v.Args[0] 13915 if v_0.Op != OpARMMOVWconst { 13916 break 13917 } 13918 c := v_0.AuxInt 13919 x := v.Args[1] 13920 flags := v.Args[2] 13921 v.reset(OpARMRSCconst) 13922 v.AuxInt = c 13923 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 13924 v0.AuxInt = d 13925 v0.AddArg(x) 13926 v.AddArg(v0) 13927 v.AddArg(flags) 13928 return true 13929 } 13930 // match: (SBCshiftLL x (MOVWconst [c]) [d] flags) 13931 // cond: 13932 // result: (SBCconst x [int64(int32(uint32(c)<<uint64(d)))] flags) 13933 for { 13934 d := v.AuxInt 13935 _ = v.Args[2] 13936 x := v.Args[0] 13937 v_1 := v.Args[1] 13938 if v_1.Op != OpARMMOVWconst { 13939 break 13940 } 13941 c := v_1.AuxInt 13942 flags := v.Args[2] 13943 v.reset(OpARMSBCconst) 13944 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 13945 v.AddArg(x) 13946 v.AddArg(flags) 13947 return true 13948 } 13949 return false 13950 } 13951 func rewriteValueARM_OpARMSBCshiftLLreg_0(v *Value) bool { 13952 b := v.Block 13953 _ = b 13954 // match: (SBCshiftLLreg (MOVWconst [c]) x y flags) 13955 // cond: 13956 // result: (RSCconst [c] (SLL <x.Type> x y) flags) 13957 for { 13958 _ = v.Args[3] 13959 v_0 := v.Args[0] 13960 if v_0.Op != OpARMMOVWconst { 13961 break 13962 } 13963 c := v_0.AuxInt 13964 x := v.Args[1] 13965 y := v.Args[2] 13966 flags := v.Args[3] 13967 v.reset(OpARMRSCconst) 13968 v.AuxInt = c 13969 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 13970 v0.AddArg(x) 13971 v0.AddArg(y) 13972 v.AddArg(v0) 13973 v.AddArg(flags) 13974 return true 13975 } 13976 // match: (SBCshiftLLreg x y (MOVWconst [c]) flags) 13977 // cond: 13978 // result: (SBCshiftLL x y [c] flags) 13979 for { 13980 _ = v.Args[3] 13981 x := v.Args[0] 13982 y := v.Args[1] 13983 v_2 := v.Args[2] 13984 if v_2.Op != OpARMMOVWconst { 13985 break 13986 } 13987 c := v_2.AuxInt 13988 flags := v.Args[3] 13989 v.reset(OpARMSBCshiftLL) 13990 v.AuxInt = c 13991 v.AddArg(x) 13992 v.AddArg(y) 13993 v.AddArg(flags) 13994 return true 13995 } 13996 return false 13997 } 13998 func rewriteValueARM_OpARMSBCshiftRA_0(v *Value) bool { 13999 b := v.Block 14000 _ = b 14001 // match: (SBCshiftRA (MOVWconst [c]) x [d] flags) 14002 // cond: 14003 // result: (RSCconst [c] (SRAconst <x.Type> x [d]) flags) 14004 for { 14005 d := v.AuxInt 14006 _ = v.Args[2] 14007 v_0 := v.Args[0] 14008 if v_0.Op != OpARMMOVWconst { 14009 break 14010 } 14011 c := v_0.AuxInt 14012 x := v.Args[1] 14013 flags := v.Args[2] 14014 v.reset(OpARMRSCconst) 14015 v.AuxInt = c 14016 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 14017 v0.AuxInt = d 14018 v0.AddArg(x) 14019 v.AddArg(v0) 14020 v.AddArg(flags) 14021 return true 14022 } 14023 // match: (SBCshiftRA x (MOVWconst [c]) [d] flags) 14024 // cond: 14025 // result: (SBCconst x [int64(int32(c)>>uint64(d))] flags) 14026 for { 14027 d := v.AuxInt 14028 _ = v.Args[2] 14029 x := v.Args[0] 14030 v_1 := v.Args[1] 14031 if v_1.Op != OpARMMOVWconst { 14032 break 14033 } 14034 c := v_1.AuxInt 14035 flags := v.Args[2] 14036 v.reset(OpARMSBCconst) 14037 v.AuxInt = int64(int32(c) >> uint64(d)) 14038 v.AddArg(x) 14039 v.AddArg(flags) 14040 return true 14041 } 14042 return false 14043 } 14044 func rewriteValueARM_OpARMSBCshiftRAreg_0(v *Value) bool { 14045 b := v.Block 14046 _ = b 14047 // match: (SBCshiftRAreg (MOVWconst [c]) x y flags) 14048 // cond: 14049 // result: (RSCconst [c] (SRA <x.Type> x y) flags) 14050 for { 14051 _ = v.Args[3] 14052 v_0 := v.Args[0] 14053 if v_0.Op != OpARMMOVWconst { 14054 break 14055 } 14056 c := v_0.AuxInt 14057 x := v.Args[1] 14058 y := v.Args[2] 14059 flags := v.Args[3] 14060 v.reset(OpARMRSCconst) 14061 v.AuxInt = c 14062 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 14063 v0.AddArg(x) 14064 v0.AddArg(y) 14065 v.AddArg(v0) 14066 v.AddArg(flags) 14067 return true 14068 } 14069 // match: (SBCshiftRAreg x y (MOVWconst [c]) flags) 14070 // cond: 14071 // result: (SBCshiftRA x y [c] flags) 14072 for { 14073 _ = v.Args[3] 14074 x := v.Args[0] 14075 y := v.Args[1] 14076 v_2 := v.Args[2] 14077 if v_2.Op != OpARMMOVWconst { 14078 break 14079 } 14080 c := v_2.AuxInt 14081 flags := v.Args[3] 14082 v.reset(OpARMSBCshiftRA) 14083 v.AuxInt = c 14084 v.AddArg(x) 14085 v.AddArg(y) 14086 v.AddArg(flags) 14087 return true 14088 } 14089 return false 14090 } 14091 func rewriteValueARM_OpARMSBCshiftRL_0(v *Value) bool { 14092 b := v.Block 14093 _ = b 14094 // match: (SBCshiftRL (MOVWconst [c]) x [d] flags) 14095 // cond: 14096 // result: (RSCconst [c] (SRLconst <x.Type> x [d]) flags) 14097 for { 14098 d := v.AuxInt 14099 _ = v.Args[2] 14100 v_0 := v.Args[0] 14101 if v_0.Op != OpARMMOVWconst { 14102 break 14103 } 14104 c := v_0.AuxInt 14105 x := v.Args[1] 14106 flags := v.Args[2] 14107 v.reset(OpARMRSCconst) 14108 v.AuxInt = c 14109 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 14110 v0.AuxInt = d 14111 v0.AddArg(x) 14112 v.AddArg(v0) 14113 v.AddArg(flags) 14114 return true 14115 } 14116 // match: (SBCshiftRL x (MOVWconst [c]) [d] flags) 14117 // cond: 14118 // result: (SBCconst x [int64(int32(uint32(c)>>uint64(d)))] flags) 14119 for { 14120 d := v.AuxInt 14121 _ = v.Args[2] 14122 x := v.Args[0] 14123 v_1 := v.Args[1] 14124 if v_1.Op != OpARMMOVWconst { 14125 break 14126 } 14127 c := v_1.AuxInt 14128 flags := v.Args[2] 14129 v.reset(OpARMSBCconst) 14130 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 14131 v.AddArg(x) 14132 v.AddArg(flags) 14133 return true 14134 } 14135 return false 14136 } 14137 func rewriteValueARM_OpARMSBCshiftRLreg_0(v *Value) bool { 14138 b := v.Block 14139 _ = b 14140 // match: (SBCshiftRLreg (MOVWconst [c]) x y flags) 14141 // cond: 14142 // result: (RSCconst [c] (SRL <x.Type> x y) flags) 14143 for { 14144 _ = v.Args[3] 14145 v_0 := v.Args[0] 14146 if v_0.Op != OpARMMOVWconst { 14147 break 14148 } 14149 c := v_0.AuxInt 14150 x := v.Args[1] 14151 y := v.Args[2] 14152 flags := v.Args[3] 14153 v.reset(OpARMRSCconst) 14154 v.AuxInt = c 14155 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 14156 v0.AddArg(x) 14157 v0.AddArg(y) 14158 v.AddArg(v0) 14159 v.AddArg(flags) 14160 return true 14161 } 14162 // match: (SBCshiftRLreg x y (MOVWconst [c]) flags) 14163 // cond: 14164 // result: (SBCshiftRL x y [c] flags) 14165 for { 14166 _ = v.Args[3] 14167 x := v.Args[0] 14168 y := v.Args[1] 14169 v_2 := v.Args[2] 14170 if v_2.Op != OpARMMOVWconst { 14171 break 14172 } 14173 c := v_2.AuxInt 14174 flags := v.Args[3] 14175 v.reset(OpARMSBCshiftRL) 14176 v.AuxInt = c 14177 v.AddArg(x) 14178 v.AddArg(y) 14179 v.AddArg(flags) 14180 return true 14181 } 14182 return false 14183 } 14184 func rewriteValueARM_OpARMSLL_0(v *Value) bool { 14185 // match: (SLL x (MOVWconst [c])) 14186 // cond: 14187 // result: (SLLconst x [c&31]) 14188 for { 14189 _ = v.Args[1] 14190 x := v.Args[0] 14191 v_1 := v.Args[1] 14192 if v_1.Op != OpARMMOVWconst { 14193 break 14194 } 14195 c := v_1.AuxInt 14196 v.reset(OpARMSLLconst) 14197 v.AuxInt = c & 31 14198 v.AddArg(x) 14199 return true 14200 } 14201 return false 14202 } 14203 func rewriteValueARM_OpARMSLLconst_0(v *Value) bool { 14204 // match: (SLLconst [c] (MOVWconst [d])) 14205 // cond: 14206 // result: (MOVWconst [int64(int32(uint32(d)<<uint64(c)))]) 14207 for { 14208 c := v.AuxInt 14209 v_0 := v.Args[0] 14210 if v_0.Op != OpARMMOVWconst { 14211 break 14212 } 14213 d := v_0.AuxInt 14214 v.reset(OpARMMOVWconst) 14215 v.AuxInt = int64(int32(uint32(d) << uint64(c))) 14216 return true 14217 } 14218 return false 14219 } 14220 func rewriteValueARM_OpARMSRA_0(v *Value) bool { 14221 // match: (SRA x (MOVWconst [c])) 14222 // cond: 14223 // result: (SRAconst x [c&31]) 14224 for { 14225 _ = v.Args[1] 14226 x := v.Args[0] 14227 v_1 := v.Args[1] 14228 if v_1.Op != OpARMMOVWconst { 14229 break 14230 } 14231 c := v_1.AuxInt 14232 v.reset(OpARMSRAconst) 14233 v.AuxInt = c & 31 14234 v.AddArg(x) 14235 return true 14236 } 14237 return false 14238 } 14239 func rewriteValueARM_OpARMSRAcond_0(v *Value) bool { 14240 // match: (SRAcond x _ (FlagEQ)) 14241 // cond: 14242 // result: (SRAconst x [31]) 14243 for { 14244 _ = v.Args[2] 14245 x := v.Args[0] 14246 v_2 := v.Args[2] 14247 if v_2.Op != OpARMFlagEQ { 14248 break 14249 } 14250 v.reset(OpARMSRAconst) 14251 v.AuxInt = 31 14252 v.AddArg(x) 14253 return true 14254 } 14255 // match: (SRAcond x y (FlagLT_ULT)) 14256 // cond: 14257 // result: (SRA x y) 14258 for { 14259 _ = v.Args[2] 14260 x := v.Args[0] 14261 y := v.Args[1] 14262 v_2 := v.Args[2] 14263 if v_2.Op != OpARMFlagLT_ULT { 14264 break 14265 } 14266 v.reset(OpARMSRA) 14267 v.AddArg(x) 14268 v.AddArg(y) 14269 return true 14270 } 14271 // match: (SRAcond x _ (FlagLT_UGT)) 14272 // cond: 14273 // result: (SRAconst x [31]) 14274 for { 14275 _ = v.Args[2] 14276 x := v.Args[0] 14277 v_2 := v.Args[2] 14278 if v_2.Op != OpARMFlagLT_UGT { 14279 break 14280 } 14281 v.reset(OpARMSRAconst) 14282 v.AuxInt = 31 14283 v.AddArg(x) 14284 return true 14285 } 14286 // match: (SRAcond x y (FlagGT_ULT)) 14287 // cond: 14288 // result: (SRA x y) 14289 for { 14290 _ = v.Args[2] 14291 x := v.Args[0] 14292 y := v.Args[1] 14293 v_2 := v.Args[2] 14294 if v_2.Op != OpARMFlagGT_ULT { 14295 break 14296 } 14297 v.reset(OpARMSRA) 14298 v.AddArg(x) 14299 v.AddArg(y) 14300 return true 14301 } 14302 // match: (SRAcond x _ (FlagGT_UGT)) 14303 // cond: 14304 // result: (SRAconst x [31]) 14305 for { 14306 _ = v.Args[2] 14307 x := v.Args[0] 14308 v_2 := v.Args[2] 14309 if v_2.Op != OpARMFlagGT_UGT { 14310 break 14311 } 14312 v.reset(OpARMSRAconst) 14313 v.AuxInt = 31 14314 v.AddArg(x) 14315 return true 14316 } 14317 return false 14318 } 14319 func rewriteValueARM_OpARMSRAconst_0(v *Value) bool { 14320 // match: (SRAconst [c] (MOVWconst [d])) 14321 // cond: 14322 // result: (MOVWconst [int64(int32(d)>>uint64(c))]) 14323 for { 14324 c := v.AuxInt 14325 v_0 := v.Args[0] 14326 if v_0.Op != OpARMMOVWconst { 14327 break 14328 } 14329 d := v_0.AuxInt 14330 v.reset(OpARMMOVWconst) 14331 v.AuxInt = int64(int32(d) >> uint64(c)) 14332 return true 14333 } 14334 // match: (SRAconst (SLLconst x [c]) [d]) 14335 // cond: objabi.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31 14336 // result: (BFX [(d-c)|(32-d)<<8] x) 14337 for { 14338 d := v.AuxInt 14339 v_0 := v.Args[0] 14340 if v_0.Op != OpARMSLLconst { 14341 break 14342 } 14343 c := v_0.AuxInt 14344 x := v_0.Args[0] 14345 if !(objabi.GOARM == 7 && uint64(d) >= uint64(c) && uint64(d) <= 31) { 14346 break 14347 } 14348 v.reset(OpARMBFX) 14349 v.AuxInt = (d - c) | (32-d)<<8 14350 v.AddArg(x) 14351 return true 14352 } 14353 return false 14354 } 14355 func rewriteValueARM_OpARMSRL_0(v *Value) bool { 14356 // match: (SRL x (MOVWconst [c])) 14357 // cond: 14358 // result: (SRLconst x [c&31]) 14359 for { 14360 _ = v.Args[1] 14361 x := v.Args[0] 14362 v_1 := v.Args[1] 14363 if v_1.Op != OpARMMOVWconst { 14364 break 14365 } 14366 c := v_1.AuxInt 14367 v.reset(OpARMSRLconst) 14368 v.AuxInt = c & 31 14369 v.AddArg(x) 14370 return true 14371 } 14372 return false 14373 } 14374 func rewriteValueARM_OpARMSRLconst_0(v *Value) bool { 14375 // match: (SRLconst [c] (MOVWconst [d])) 14376 // cond: 14377 // result: (MOVWconst [int64(int32(uint32(d)>>uint64(c)))]) 14378 for { 14379 c := v.AuxInt 14380 v_0 := v.Args[0] 14381 if v_0.Op != OpARMMOVWconst { 14382 break 14383 } 14384 d := v_0.AuxInt 14385 v.reset(OpARMMOVWconst) 14386 v.AuxInt = int64(int32(uint32(d) >> uint64(c))) 14387 return true 14388 } 14389 // match: (SRLconst (SLLconst x [c]) [d]) 14390 // cond: objabi.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31 14391 // result: (BFXU [(d-c)|(32-d)<<8] x) 14392 for { 14393 d := v.AuxInt 14394 v_0 := v.Args[0] 14395 if v_0.Op != OpARMSLLconst { 14396 break 14397 } 14398 c := v_0.AuxInt 14399 x := v_0.Args[0] 14400 if !(objabi.GOARM == 7 && uint64(d) >= uint64(c) && uint64(d) <= 31) { 14401 break 14402 } 14403 v.reset(OpARMBFXU) 14404 v.AuxInt = (d - c) | (32-d)<<8 14405 v.AddArg(x) 14406 return true 14407 } 14408 return false 14409 } 14410 func rewriteValueARM_OpARMSUB_0(v *Value) bool { 14411 // match: (SUB (MOVWconst [c]) x) 14412 // cond: 14413 // result: (RSBconst [c] x) 14414 for { 14415 _ = v.Args[1] 14416 v_0 := v.Args[0] 14417 if v_0.Op != OpARMMOVWconst { 14418 break 14419 } 14420 c := v_0.AuxInt 14421 x := v.Args[1] 14422 v.reset(OpARMRSBconst) 14423 v.AuxInt = c 14424 v.AddArg(x) 14425 return true 14426 } 14427 // match: (SUB x (MOVWconst [c])) 14428 // cond: 14429 // result: (SUBconst [c] x) 14430 for { 14431 _ = v.Args[1] 14432 x := v.Args[0] 14433 v_1 := v.Args[1] 14434 if v_1.Op != OpARMMOVWconst { 14435 break 14436 } 14437 c := v_1.AuxInt 14438 v.reset(OpARMSUBconst) 14439 v.AuxInt = c 14440 v.AddArg(x) 14441 return true 14442 } 14443 // match: (SUB x (SLLconst [c] y)) 14444 // cond: 14445 // result: (SUBshiftLL x y [c]) 14446 for { 14447 _ = v.Args[1] 14448 x := v.Args[0] 14449 v_1 := v.Args[1] 14450 if v_1.Op != OpARMSLLconst { 14451 break 14452 } 14453 c := v_1.AuxInt 14454 y := v_1.Args[0] 14455 v.reset(OpARMSUBshiftLL) 14456 v.AuxInt = c 14457 v.AddArg(x) 14458 v.AddArg(y) 14459 return true 14460 } 14461 // match: (SUB (SLLconst [c] y) x) 14462 // cond: 14463 // result: (RSBshiftLL x y [c]) 14464 for { 14465 _ = v.Args[1] 14466 v_0 := v.Args[0] 14467 if v_0.Op != OpARMSLLconst { 14468 break 14469 } 14470 c := v_0.AuxInt 14471 y := v_0.Args[0] 14472 x := v.Args[1] 14473 v.reset(OpARMRSBshiftLL) 14474 v.AuxInt = c 14475 v.AddArg(x) 14476 v.AddArg(y) 14477 return true 14478 } 14479 // match: (SUB x (SRLconst [c] y)) 14480 // cond: 14481 // result: (SUBshiftRL x y [c]) 14482 for { 14483 _ = v.Args[1] 14484 x := v.Args[0] 14485 v_1 := v.Args[1] 14486 if v_1.Op != OpARMSRLconst { 14487 break 14488 } 14489 c := v_1.AuxInt 14490 y := v_1.Args[0] 14491 v.reset(OpARMSUBshiftRL) 14492 v.AuxInt = c 14493 v.AddArg(x) 14494 v.AddArg(y) 14495 return true 14496 } 14497 // match: (SUB (SRLconst [c] y) x) 14498 // cond: 14499 // result: (RSBshiftRL x y [c]) 14500 for { 14501 _ = v.Args[1] 14502 v_0 := v.Args[0] 14503 if v_0.Op != OpARMSRLconst { 14504 break 14505 } 14506 c := v_0.AuxInt 14507 y := v_0.Args[0] 14508 x := v.Args[1] 14509 v.reset(OpARMRSBshiftRL) 14510 v.AuxInt = c 14511 v.AddArg(x) 14512 v.AddArg(y) 14513 return true 14514 } 14515 // match: (SUB x (SRAconst [c] y)) 14516 // cond: 14517 // result: (SUBshiftRA x y [c]) 14518 for { 14519 _ = v.Args[1] 14520 x := v.Args[0] 14521 v_1 := v.Args[1] 14522 if v_1.Op != OpARMSRAconst { 14523 break 14524 } 14525 c := v_1.AuxInt 14526 y := v_1.Args[0] 14527 v.reset(OpARMSUBshiftRA) 14528 v.AuxInt = c 14529 v.AddArg(x) 14530 v.AddArg(y) 14531 return true 14532 } 14533 // match: (SUB (SRAconst [c] y) x) 14534 // cond: 14535 // result: (RSBshiftRA x y [c]) 14536 for { 14537 _ = v.Args[1] 14538 v_0 := v.Args[0] 14539 if v_0.Op != OpARMSRAconst { 14540 break 14541 } 14542 c := v_0.AuxInt 14543 y := v_0.Args[0] 14544 x := v.Args[1] 14545 v.reset(OpARMRSBshiftRA) 14546 v.AuxInt = c 14547 v.AddArg(x) 14548 v.AddArg(y) 14549 return true 14550 } 14551 // match: (SUB x (SLL y z)) 14552 // cond: 14553 // result: (SUBshiftLLreg x y z) 14554 for { 14555 _ = v.Args[1] 14556 x := v.Args[0] 14557 v_1 := v.Args[1] 14558 if v_1.Op != OpARMSLL { 14559 break 14560 } 14561 _ = v_1.Args[1] 14562 y := v_1.Args[0] 14563 z := v_1.Args[1] 14564 v.reset(OpARMSUBshiftLLreg) 14565 v.AddArg(x) 14566 v.AddArg(y) 14567 v.AddArg(z) 14568 return true 14569 } 14570 // match: (SUB (SLL y z) x) 14571 // cond: 14572 // result: (RSBshiftLLreg x y z) 14573 for { 14574 _ = v.Args[1] 14575 v_0 := v.Args[0] 14576 if v_0.Op != OpARMSLL { 14577 break 14578 } 14579 _ = v_0.Args[1] 14580 y := v_0.Args[0] 14581 z := v_0.Args[1] 14582 x := v.Args[1] 14583 v.reset(OpARMRSBshiftLLreg) 14584 v.AddArg(x) 14585 v.AddArg(y) 14586 v.AddArg(z) 14587 return true 14588 } 14589 return false 14590 } 14591 func rewriteValueARM_OpARMSUB_10(v *Value) bool { 14592 // match: (SUB x (SRL y z)) 14593 // cond: 14594 // result: (SUBshiftRLreg x y z) 14595 for { 14596 _ = v.Args[1] 14597 x := v.Args[0] 14598 v_1 := v.Args[1] 14599 if v_1.Op != OpARMSRL { 14600 break 14601 } 14602 _ = v_1.Args[1] 14603 y := v_1.Args[0] 14604 z := v_1.Args[1] 14605 v.reset(OpARMSUBshiftRLreg) 14606 v.AddArg(x) 14607 v.AddArg(y) 14608 v.AddArg(z) 14609 return true 14610 } 14611 // match: (SUB (SRL y z) x) 14612 // cond: 14613 // result: (RSBshiftRLreg x y z) 14614 for { 14615 _ = v.Args[1] 14616 v_0 := v.Args[0] 14617 if v_0.Op != OpARMSRL { 14618 break 14619 } 14620 _ = v_0.Args[1] 14621 y := v_0.Args[0] 14622 z := v_0.Args[1] 14623 x := v.Args[1] 14624 v.reset(OpARMRSBshiftRLreg) 14625 v.AddArg(x) 14626 v.AddArg(y) 14627 v.AddArg(z) 14628 return true 14629 } 14630 // match: (SUB x (SRA y z)) 14631 // cond: 14632 // result: (SUBshiftRAreg x y z) 14633 for { 14634 _ = v.Args[1] 14635 x := v.Args[0] 14636 v_1 := v.Args[1] 14637 if v_1.Op != OpARMSRA { 14638 break 14639 } 14640 _ = v_1.Args[1] 14641 y := v_1.Args[0] 14642 z := v_1.Args[1] 14643 v.reset(OpARMSUBshiftRAreg) 14644 v.AddArg(x) 14645 v.AddArg(y) 14646 v.AddArg(z) 14647 return true 14648 } 14649 // match: (SUB (SRA y z) x) 14650 // cond: 14651 // result: (RSBshiftRAreg x y z) 14652 for { 14653 _ = v.Args[1] 14654 v_0 := v.Args[0] 14655 if v_0.Op != OpARMSRA { 14656 break 14657 } 14658 _ = v_0.Args[1] 14659 y := v_0.Args[0] 14660 z := v_0.Args[1] 14661 x := v.Args[1] 14662 v.reset(OpARMRSBshiftRAreg) 14663 v.AddArg(x) 14664 v.AddArg(y) 14665 v.AddArg(z) 14666 return true 14667 } 14668 // match: (SUB x x) 14669 // cond: 14670 // result: (MOVWconst [0]) 14671 for { 14672 _ = v.Args[1] 14673 x := v.Args[0] 14674 if x != v.Args[1] { 14675 break 14676 } 14677 v.reset(OpARMMOVWconst) 14678 v.AuxInt = 0 14679 return true 14680 } 14681 // match: (SUB a (MUL x y)) 14682 // cond: objabi.GOARM == 7 14683 // result: (MULS x y a) 14684 for { 14685 _ = v.Args[1] 14686 a := v.Args[0] 14687 v_1 := v.Args[1] 14688 if v_1.Op != OpARMMUL { 14689 break 14690 } 14691 _ = v_1.Args[1] 14692 x := v_1.Args[0] 14693 y := v_1.Args[1] 14694 if !(objabi.GOARM == 7) { 14695 break 14696 } 14697 v.reset(OpARMMULS) 14698 v.AddArg(x) 14699 v.AddArg(y) 14700 v.AddArg(a) 14701 return true 14702 } 14703 return false 14704 } 14705 func rewriteValueARM_OpARMSUBD_0(v *Value) bool { 14706 // match: (SUBD a (MULD x y)) 14707 // cond: a.Uses == 1 && objabi.GOARM >= 6 14708 // result: (MULSD a x y) 14709 for { 14710 _ = v.Args[1] 14711 a := v.Args[0] 14712 v_1 := v.Args[1] 14713 if v_1.Op != OpARMMULD { 14714 break 14715 } 14716 _ = v_1.Args[1] 14717 x := v_1.Args[0] 14718 y := v_1.Args[1] 14719 if !(a.Uses == 1 && objabi.GOARM >= 6) { 14720 break 14721 } 14722 v.reset(OpARMMULSD) 14723 v.AddArg(a) 14724 v.AddArg(x) 14725 v.AddArg(y) 14726 return true 14727 } 14728 // match: (SUBD a (NMULD x y)) 14729 // cond: a.Uses == 1 && objabi.GOARM >= 6 14730 // result: (MULAD a x y) 14731 for { 14732 _ = v.Args[1] 14733 a := v.Args[0] 14734 v_1 := v.Args[1] 14735 if v_1.Op != OpARMNMULD { 14736 break 14737 } 14738 _ = v_1.Args[1] 14739 x := v_1.Args[0] 14740 y := v_1.Args[1] 14741 if !(a.Uses == 1 && objabi.GOARM >= 6) { 14742 break 14743 } 14744 v.reset(OpARMMULAD) 14745 v.AddArg(a) 14746 v.AddArg(x) 14747 v.AddArg(y) 14748 return true 14749 } 14750 return false 14751 } 14752 func rewriteValueARM_OpARMSUBF_0(v *Value) bool { 14753 // match: (SUBF a (MULF x y)) 14754 // cond: a.Uses == 1 && objabi.GOARM >= 6 14755 // result: (MULSF a x y) 14756 for { 14757 _ = v.Args[1] 14758 a := v.Args[0] 14759 v_1 := v.Args[1] 14760 if v_1.Op != OpARMMULF { 14761 break 14762 } 14763 _ = v_1.Args[1] 14764 x := v_1.Args[0] 14765 y := v_1.Args[1] 14766 if !(a.Uses == 1 && objabi.GOARM >= 6) { 14767 break 14768 } 14769 v.reset(OpARMMULSF) 14770 v.AddArg(a) 14771 v.AddArg(x) 14772 v.AddArg(y) 14773 return true 14774 } 14775 // match: (SUBF a (NMULF x y)) 14776 // cond: a.Uses == 1 && objabi.GOARM >= 6 14777 // result: (MULAF a x y) 14778 for { 14779 _ = v.Args[1] 14780 a := v.Args[0] 14781 v_1 := v.Args[1] 14782 if v_1.Op != OpARMNMULF { 14783 break 14784 } 14785 _ = v_1.Args[1] 14786 x := v_1.Args[0] 14787 y := v_1.Args[1] 14788 if !(a.Uses == 1 && objabi.GOARM >= 6) { 14789 break 14790 } 14791 v.reset(OpARMMULAF) 14792 v.AddArg(a) 14793 v.AddArg(x) 14794 v.AddArg(y) 14795 return true 14796 } 14797 return false 14798 } 14799 func rewriteValueARM_OpARMSUBS_0(v *Value) bool { 14800 // match: (SUBS x (MOVWconst [c])) 14801 // cond: 14802 // result: (SUBSconst [c] x) 14803 for { 14804 _ = v.Args[1] 14805 x := v.Args[0] 14806 v_1 := v.Args[1] 14807 if v_1.Op != OpARMMOVWconst { 14808 break 14809 } 14810 c := v_1.AuxInt 14811 v.reset(OpARMSUBSconst) 14812 v.AuxInt = c 14813 v.AddArg(x) 14814 return true 14815 } 14816 // match: (SUBS x (SLLconst [c] y)) 14817 // cond: 14818 // result: (SUBSshiftLL x y [c]) 14819 for { 14820 _ = v.Args[1] 14821 x := v.Args[0] 14822 v_1 := v.Args[1] 14823 if v_1.Op != OpARMSLLconst { 14824 break 14825 } 14826 c := v_1.AuxInt 14827 y := v_1.Args[0] 14828 v.reset(OpARMSUBSshiftLL) 14829 v.AuxInt = c 14830 v.AddArg(x) 14831 v.AddArg(y) 14832 return true 14833 } 14834 // match: (SUBS (SLLconst [c] y) x) 14835 // cond: 14836 // result: (RSBSshiftLL x y [c]) 14837 for { 14838 _ = v.Args[1] 14839 v_0 := v.Args[0] 14840 if v_0.Op != OpARMSLLconst { 14841 break 14842 } 14843 c := v_0.AuxInt 14844 y := v_0.Args[0] 14845 x := v.Args[1] 14846 v.reset(OpARMRSBSshiftLL) 14847 v.AuxInt = c 14848 v.AddArg(x) 14849 v.AddArg(y) 14850 return true 14851 } 14852 // match: (SUBS x (SRLconst [c] y)) 14853 // cond: 14854 // result: (SUBSshiftRL x y [c]) 14855 for { 14856 _ = v.Args[1] 14857 x := v.Args[0] 14858 v_1 := v.Args[1] 14859 if v_1.Op != OpARMSRLconst { 14860 break 14861 } 14862 c := v_1.AuxInt 14863 y := v_1.Args[0] 14864 v.reset(OpARMSUBSshiftRL) 14865 v.AuxInt = c 14866 v.AddArg(x) 14867 v.AddArg(y) 14868 return true 14869 } 14870 // match: (SUBS (SRLconst [c] y) x) 14871 // cond: 14872 // result: (RSBSshiftRL x y [c]) 14873 for { 14874 _ = v.Args[1] 14875 v_0 := v.Args[0] 14876 if v_0.Op != OpARMSRLconst { 14877 break 14878 } 14879 c := v_0.AuxInt 14880 y := v_0.Args[0] 14881 x := v.Args[1] 14882 v.reset(OpARMRSBSshiftRL) 14883 v.AuxInt = c 14884 v.AddArg(x) 14885 v.AddArg(y) 14886 return true 14887 } 14888 // match: (SUBS x (SRAconst [c] y)) 14889 // cond: 14890 // result: (SUBSshiftRA x y [c]) 14891 for { 14892 _ = v.Args[1] 14893 x := v.Args[0] 14894 v_1 := v.Args[1] 14895 if v_1.Op != OpARMSRAconst { 14896 break 14897 } 14898 c := v_1.AuxInt 14899 y := v_1.Args[0] 14900 v.reset(OpARMSUBSshiftRA) 14901 v.AuxInt = c 14902 v.AddArg(x) 14903 v.AddArg(y) 14904 return true 14905 } 14906 // match: (SUBS (SRAconst [c] y) x) 14907 // cond: 14908 // result: (RSBSshiftRA x y [c]) 14909 for { 14910 _ = v.Args[1] 14911 v_0 := v.Args[0] 14912 if v_0.Op != OpARMSRAconst { 14913 break 14914 } 14915 c := v_0.AuxInt 14916 y := v_0.Args[0] 14917 x := v.Args[1] 14918 v.reset(OpARMRSBSshiftRA) 14919 v.AuxInt = c 14920 v.AddArg(x) 14921 v.AddArg(y) 14922 return true 14923 } 14924 // match: (SUBS x (SLL y z)) 14925 // cond: 14926 // result: (SUBSshiftLLreg x y z) 14927 for { 14928 _ = v.Args[1] 14929 x := v.Args[0] 14930 v_1 := v.Args[1] 14931 if v_1.Op != OpARMSLL { 14932 break 14933 } 14934 _ = v_1.Args[1] 14935 y := v_1.Args[0] 14936 z := v_1.Args[1] 14937 v.reset(OpARMSUBSshiftLLreg) 14938 v.AddArg(x) 14939 v.AddArg(y) 14940 v.AddArg(z) 14941 return true 14942 } 14943 // match: (SUBS (SLL y z) x) 14944 // cond: 14945 // result: (RSBSshiftLLreg x y z) 14946 for { 14947 _ = v.Args[1] 14948 v_0 := v.Args[0] 14949 if v_0.Op != OpARMSLL { 14950 break 14951 } 14952 _ = v_0.Args[1] 14953 y := v_0.Args[0] 14954 z := v_0.Args[1] 14955 x := v.Args[1] 14956 v.reset(OpARMRSBSshiftLLreg) 14957 v.AddArg(x) 14958 v.AddArg(y) 14959 v.AddArg(z) 14960 return true 14961 } 14962 // match: (SUBS x (SRL y z)) 14963 // cond: 14964 // result: (SUBSshiftRLreg x y z) 14965 for { 14966 _ = v.Args[1] 14967 x := v.Args[0] 14968 v_1 := v.Args[1] 14969 if v_1.Op != OpARMSRL { 14970 break 14971 } 14972 _ = v_1.Args[1] 14973 y := v_1.Args[0] 14974 z := v_1.Args[1] 14975 v.reset(OpARMSUBSshiftRLreg) 14976 v.AddArg(x) 14977 v.AddArg(y) 14978 v.AddArg(z) 14979 return true 14980 } 14981 return false 14982 } 14983 func rewriteValueARM_OpARMSUBS_10(v *Value) bool { 14984 // match: (SUBS (SRL y z) x) 14985 // cond: 14986 // result: (RSBSshiftRLreg x y z) 14987 for { 14988 _ = v.Args[1] 14989 v_0 := v.Args[0] 14990 if v_0.Op != OpARMSRL { 14991 break 14992 } 14993 _ = v_0.Args[1] 14994 y := v_0.Args[0] 14995 z := v_0.Args[1] 14996 x := v.Args[1] 14997 v.reset(OpARMRSBSshiftRLreg) 14998 v.AddArg(x) 14999 v.AddArg(y) 15000 v.AddArg(z) 15001 return true 15002 } 15003 // match: (SUBS x (SRA y z)) 15004 // cond: 15005 // result: (SUBSshiftRAreg x y z) 15006 for { 15007 _ = v.Args[1] 15008 x := v.Args[0] 15009 v_1 := v.Args[1] 15010 if v_1.Op != OpARMSRA { 15011 break 15012 } 15013 _ = v_1.Args[1] 15014 y := v_1.Args[0] 15015 z := v_1.Args[1] 15016 v.reset(OpARMSUBSshiftRAreg) 15017 v.AddArg(x) 15018 v.AddArg(y) 15019 v.AddArg(z) 15020 return true 15021 } 15022 // match: (SUBS (SRA y z) x) 15023 // cond: 15024 // result: (RSBSshiftRAreg x y z) 15025 for { 15026 _ = v.Args[1] 15027 v_0 := v.Args[0] 15028 if v_0.Op != OpARMSRA { 15029 break 15030 } 15031 _ = v_0.Args[1] 15032 y := v_0.Args[0] 15033 z := v_0.Args[1] 15034 x := v.Args[1] 15035 v.reset(OpARMRSBSshiftRAreg) 15036 v.AddArg(x) 15037 v.AddArg(y) 15038 v.AddArg(z) 15039 return true 15040 } 15041 return false 15042 } 15043 func rewriteValueARM_OpARMSUBSshiftLL_0(v *Value) bool { 15044 b := v.Block 15045 _ = b 15046 // match: (SUBSshiftLL (MOVWconst [c]) x [d]) 15047 // cond: 15048 // result: (RSBSconst [c] (SLLconst <x.Type> x [d])) 15049 for { 15050 d := v.AuxInt 15051 _ = v.Args[1] 15052 v_0 := v.Args[0] 15053 if v_0.Op != OpARMMOVWconst { 15054 break 15055 } 15056 c := v_0.AuxInt 15057 x := v.Args[1] 15058 v.reset(OpARMRSBSconst) 15059 v.AuxInt = c 15060 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 15061 v0.AuxInt = d 15062 v0.AddArg(x) 15063 v.AddArg(v0) 15064 return true 15065 } 15066 // match: (SUBSshiftLL x (MOVWconst [c]) [d]) 15067 // cond: 15068 // result: (SUBSconst x [int64(int32(uint32(c)<<uint64(d)))]) 15069 for { 15070 d := v.AuxInt 15071 _ = v.Args[1] 15072 x := v.Args[0] 15073 v_1 := v.Args[1] 15074 if v_1.Op != OpARMMOVWconst { 15075 break 15076 } 15077 c := v_1.AuxInt 15078 v.reset(OpARMSUBSconst) 15079 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 15080 v.AddArg(x) 15081 return true 15082 } 15083 return false 15084 } 15085 func rewriteValueARM_OpARMSUBSshiftLLreg_0(v *Value) bool { 15086 b := v.Block 15087 _ = b 15088 // match: (SUBSshiftLLreg (MOVWconst [c]) x y) 15089 // cond: 15090 // result: (RSBSconst [c] (SLL <x.Type> x y)) 15091 for { 15092 _ = v.Args[2] 15093 v_0 := v.Args[0] 15094 if v_0.Op != OpARMMOVWconst { 15095 break 15096 } 15097 c := v_0.AuxInt 15098 x := v.Args[1] 15099 y := v.Args[2] 15100 v.reset(OpARMRSBSconst) 15101 v.AuxInt = c 15102 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 15103 v0.AddArg(x) 15104 v0.AddArg(y) 15105 v.AddArg(v0) 15106 return true 15107 } 15108 // match: (SUBSshiftLLreg x y (MOVWconst [c])) 15109 // cond: 15110 // result: (SUBSshiftLL x y [c]) 15111 for { 15112 _ = v.Args[2] 15113 x := v.Args[0] 15114 y := v.Args[1] 15115 v_2 := v.Args[2] 15116 if v_2.Op != OpARMMOVWconst { 15117 break 15118 } 15119 c := v_2.AuxInt 15120 v.reset(OpARMSUBSshiftLL) 15121 v.AuxInt = c 15122 v.AddArg(x) 15123 v.AddArg(y) 15124 return true 15125 } 15126 return false 15127 } 15128 func rewriteValueARM_OpARMSUBSshiftRA_0(v *Value) bool { 15129 b := v.Block 15130 _ = b 15131 // match: (SUBSshiftRA (MOVWconst [c]) x [d]) 15132 // cond: 15133 // result: (RSBSconst [c] (SRAconst <x.Type> x [d])) 15134 for { 15135 d := v.AuxInt 15136 _ = v.Args[1] 15137 v_0 := v.Args[0] 15138 if v_0.Op != OpARMMOVWconst { 15139 break 15140 } 15141 c := v_0.AuxInt 15142 x := v.Args[1] 15143 v.reset(OpARMRSBSconst) 15144 v.AuxInt = c 15145 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 15146 v0.AuxInt = d 15147 v0.AddArg(x) 15148 v.AddArg(v0) 15149 return true 15150 } 15151 // match: (SUBSshiftRA x (MOVWconst [c]) [d]) 15152 // cond: 15153 // result: (SUBSconst x [int64(int32(c)>>uint64(d))]) 15154 for { 15155 d := v.AuxInt 15156 _ = v.Args[1] 15157 x := v.Args[0] 15158 v_1 := v.Args[1] 15159 if v_1.Op != OpARMMOVWconst { 15160 break 15161 } 15162 c := v_1.AuxInt 15163 v.reset(OpARMSUBSconst) 15164 v.AuxInt = int64(int32(c) >> uint64(d)) 15165 v.AddArg(x) 15166 return true 15167 } 15168 return false 15169 } 15170 func rewriteValueARM_OpARMSUBSshiftRAreg_0(v *Value) bool { 15171 b := v.Block 15172 _ = b 15173 // match: (SUBSshiftRAreg (MOVWconst [c]) x y) 15174 // cond: 15175 // result: (RSBSconst [c] (SRA <x.Type> x y)) 15176 for { 15177 _ = v.Args[2] 15178 v_0 := v.Args[0] 15179 if v_0.Op != OpARMMOVWconst { 15180 break 15181 } 15182 c := v_0.AuxInt 15183 x := v.Args[1] 15184 y := v.Args[2] 15185 v.reset(OpARMRSBSconst) 15186 v.AuxInt = c 15187 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 15188 v0.AddArg(x) 15189 v0.AddArg(y) 15190 v.AddArg(v0) 15191 return true 15192 } 15193 // match: (SUBSshiftRAreg x y (MOVWconst [c])) 15194 // cond: 15195 // result: (SUBSshiftRA x y [c]) 15196 for { 15197 _ = v.Args[2] 15198 x := v.Args[0] 15199 y := v.Args[1] 15200 v_2 := v.Args[2] 15201 if v_2.Op != OpARMMOVWconst { 15202 break 15203 } 15204 c := v_2.AuxInt 15205 v.reset(OpARMSUBSshiftRA) 15206 v.AuxInt = c 15207 v.AddArg(x) 15208 v.AddArg(y) 15209 return true 15210 } 15211 return false 15212 } 15213 func rewriteValueARM_OpARMSUBSshiftRL_0(v *Value) bool { 15214 b := v.Block 15215 _ = b 15216 // match: (SUBSshiftRL (MOVWconst [c]) x [d]) 15217 // cond: 15218 // result: (RSBSconst [c] (SRLconst <x.Type> x [d])) 15219 for { 15220 d := v.AuxInt 15221 _ = v.Args[1] 15222 v_0 := v.Args[0] 15223 if v_0.Op != OpARMMOVWconst { 15224 break 15225 } 15226 c := v_0.AuxInt 15227 x := v.Args[1] 15228 v.reset(OpARMRSBSconst) 15229 v.AuxInt = c 15230 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 15231 v0.AuxInt = d 15232 v0.AddArg(x) 15233 v.AddArg(v0) 15234 return true 15235 } 15236 // match: (SUBSshiftRL x (MOVWconst [c]) [d]) 15237 // cond: 15238 // result: (SUBSconst x [int64(int32(uint32(c)>>uint64(d)))]) 15239 for { 15240 d := v.AuxInt 15241 _ = v.Args[1] 15242 x := v.Args[0] 15243 v_1 := v.Args[1] 15244 if v_1.Op != OpARMMOVWconst { 15245 break 15246 } 15247 c := v_1.AuxInt 15248 v.reset(OpARMSUBSconst) 15249 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 15250 v.AddArg(x) 15251 return true 15252 } 15253 return false 15254 } 15255 func rewriteValueARM_OpARMSUBSshiftRLreg_0(v *Value) bool { 15256 b := v.Block 15257 _ = b 15258 // match: (SUBSshiftRLreg (MOVWconst [c]) x y) 15259 // cond: 15260 // result: (RSBSconst [c] (SRL <x.Type> x y)) 15261 for { 15262 _ = v.Args[2] 15263 v_0 := v.Args[0] 15264 if v_0.Op != OpARMMOVWconst { 15265 break 15266 } 15267 c := v_0.AuxInt 15268 x := v.Args[1] 15269 y := v.Args[2] 15270 v.reset(OpARMRSBSconst) 15271 v.AuxInt = c 15272 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 15273 v0.AddArg(x) 15274 v0.AddArg(y) 15275 v.AddArg(v0) 15276 return true 15277 } 15278 // match: (SUBSshiftRLreg x y (MOVWconst [c])) 15279 // cond: 15280 // result: (SUBSshiftRL x y [c]) 15281 for { 15282 _ = v.Args[2] 15283 x := v.Args[0] 15284 y := v.Args[1] 15285 v_2 := v.Args[2] 15286 if v_2.Op != OpARMMOVWconst { 15287 break 15288 } 15289 c := v_2.AuxInt 15290 v.reset(OpARMSUBSshiftRL) 15291 v.AuxInt = c 15292 v.AddArg(x) 15293 v.AddArg(y) 15294 return true 15295 } 15296 return false 15297 } 15298 func rewriteValueARM_OpARMSUBconst_0(v *Value) bool { 15299 // match: (SUBconst [off1] (MOVWaddr [off2] {sym} ptr)) 15300 // cond: 15301 // result: (MOVWaddr [off2-off1] {sym} ptr) 15302 for { 15303 off1 := v.AuxInt 15304 v_0 := v.Args[0] 15305 if v_0.Op != OpARMMOVWaddr { 15306 break 15307 } 15308 off2 := v_0.AuxInt 15309 sym := v_0.Aux 15310 ptr := v_0.Args[0] 15311 v.reset(OpARMMOVWaddr) 15312 v.AuxInt = off2 - off1 15313 v.Aux = sym 15314 v.AddArg(ptr) 15315 return true 15316 } 15317 // match: (SUBconst [0] x) 15318 // cond: 15319 // result: x 15320 for { 15321 if v.AuxInt != 0 { 15322 break 15323 } 15324 x := v.Args[0] 15325 v.reset(OpCopy) 15326 v.Type = x.Type 15327 v.AddArg(x) 15328 return true 15329 } 15330 // match: (SUBconst [c] x) 15331 // cond: !isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c)) 15332 // result: (ADDconst [int64(int32(-c))] x) 15333 for { 15334 c := v.AuxInt 15335 x := v.Args[0] 15336 if !(!isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c))) { 15337 break 15338 } 15339 v.reset(OpARMADDconst) 15340 v.AuxInt = int64(int32(-c)) 15341 v.AddArg(x) 15342 return true 15343 } 15344 // match: (SUBconst [c] x) 15345 // cond: objabi.GOARM==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff 15346 // result: (ANDconst [int64(int32(-c))] x) 15347 for { 15348 c := v.AuxInt 15349 x := v.Args[0] 15350 if !(objabi.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && uint32(-c) <= 0xffff) { 15351 break 15352 } 15353 v.reset(OpARMANDconst) 15354 v.AuxInt = int64(int32(-c)) 15355 v.AddArg(x) 15356 return true 15357 } 15358 // match: (SUBconst [c] (MOVWconst [d])) 15359 // cond: 15360 // result: (MOVWconst [int64(int32(d-c))]) 15361 for { 15362 c := v.AuxInt 15363 v_0 := v.Args[0] 15364 if v_0.Op != OpARMMOVWconst { 15365 break 15366 } 15367 d := v_0.AuxInt 15368 v.reset(OpARMMOVWconst) 15369 v.AuxInt = int64(int32(d - c)) 15370 return true 15371 } 15372 // match: (SUBconst [c] (SUBconst [d] x)) 15373 // cond: 15374 // result: (ADDconst [int64(int32(-c-d))] x) 15375 for { 15376 c := v.AuxInt 15377 v_0 := v.Args[0] 15378 if v_0.Op != OpARMSUBconst { 15379 break 15380 } 15381 d := v_0.AuxInt 15382 x := v_0.Args[0] 15383 v.reset(OpARMADDconst) 15384 v.AuxInt = int64(int32(-c - d)) 15385 v.AddArg(x) 15386 return true 15387 } 15388 // match: (SUBconst [c] (ADDconst [d] x)) 15389 // cond: 15390 // result: (ADDconst [int64(int32(-c+d))] x) 15391 for { 15392 c := v.AuxInt 15393 v_0 := v.Args[0] 15394 if v_0.Op != OpARMADDconst { 15395 break 15396 } 15397 d := v_0.AuxInt 15398 x := v_0.Args[0] 15399 v.reset(OpARMADDconst) 15400 v.AuxInt = int64(int32(-c + d)) 15401 v.AddArg(x) 15402 return true 15403 } 15404 // match: (SUBconst [c] (RSBconst [d] x)) 15405 // cond: 15406 // result: (RSBconst [int64(int32(-c+d))] x) 15407 for { 15408 c := v.AuxInt 15409 v_0 := v.Args[0] 15410 if v_0.Op != OpARMRSBconst { 15411 break 15412 } 15413 d := v_0.AuxInt 15414 x := v_0.Args[0] 15415 v.reset(OpARMRSBconst) 15416 v.AuxInt = int64(int32(-c + d)) 15417 v.AddArg(x) 15418 return true 15419 } 15420 return false 15421 } 15422 func rewriteValueARM_OpARMSUBshiftLL_0(v *Value) bool { 15423 b := v.Block 15424 _ = b 15425 // match: (SUBshiftLL (MOVWconst [c]) x [d]) 15426 // cond: 15427 // result: (RSBconst [c] (SLLconst <x.Type> x [d])) 15428 for { 15429 d := v.AuxInt 15430 _ = v.Args[1] 15431 v_0 := v.Args[0] 15432 if v_0.Op != OpARMMOVWconst { 15433 break 15434 } 15435 c := v_0.AuxInt 15436 x := v.Args[1] 15437 v.reset(OpARMRSBconst) 15438 v.AuxInt = c 15439 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 15440 v0.AuxInt = d 15441 v0.AddArg(x) 15442 v.AddArg(v0) 15443 return true 15444 } 15445 // match: (SUBshiftLL x (MOVWconst [c]) [d]) 15446 // cond: 15447 // result: (SUBconst x [int64(int32(uint32(c)<<uint64(d)))]) 15448 for { 15449 d := v.AuxInt 15450 _ = v.Args[1] 15451 x := v.Args[0] 15452 v_1 := v.Args[1] 15453 if v_1.Op != OpARMMOVWconst { 15454 break 15455 } 15456 c := v_1.AuxInt 15457 v.reset(OpARMSUBconst) 15458 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 15459 v.AddArg(x) 15460 return true 15461 } 15462 // match: (SUBshiftLL x (SLLconst x [c]) [d]) 15463 // cond: c==d 15464 // result: (MOVWconst [0]) 15465 for { 15466 d := v.AuxInt 15467 _ = v.Args[1] 15468 x := v.Args[0] 15469 v_1 := v.Args[1] 15470 if v_1.Op != OpARMSLLconst { 15471 break 15472 } 15473 c := v_1.AuxInt 15474 if x != v_1.Args[0] { 15475 break 15476 } 15477 if !(c == d) { 15478 break 15479 } 15480 v.reset(OpARMMOVWconst) 15481 v.AuxInt = 0 15482 return true 15483 } 15484 return false 15485 } 15486 func rewriteValueARM_OpARMSUBshiftLLreg_0(v *Value) bool { 15487 b := v.Block 15488 _ = b 15489 // match: (SUBshiftLLreg (MOVWconst [c]) x y) 15490 // cond: 15491 // result: (RSBconst [c] (SLL <x.Type> x y)) 15492 for { 15493 _ = v.Args[2] 15494 v_0 := v.Args[0] 15495 if v_0.Op != OpARMMOVWconst { 15496 break 15497 } 15498 c := v_0.AuxInt 15499 x := v.Args[1] 15500 y := v.Args[2] 15501 v.reset(OpARMRSBconst) 15502 v.AuxInt = c 15503 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 15504 v0.AddArg(x) 15505 v0.AddArg(y) 15506 v.AddArg(v0) 15507 return true 15508 } 15509 // match: (SUBshiftLLreg x y (MOVWconst [c])) 15510 // cond: 15511 // result: (SUBshiftLL x y [c]) 15512 for { 15513 _ = v.Args[2] 15514 x := v.Args[0] 15515 y := v.Args[1] 15516 v_2 := v.Args[2] 15517 if v_2.Op != OpARMMOVWconst { 15518 break 15519 } 15520 c := v_2.AuxInt 15521 v.reset(OpARMSUBshiftLL) 15522 v.AuxInt = c 15523 v.AddArg(x) 15524 v.AddArg(y) 15525 return true 15526 } 15527 return false 15528 } 15529 func rewriteValueARM_OpARMSUBshiftRA_0(v *Value) bool { 15530 b := v.Block 15531 _ = b 15532 // match: (SUBshiftRA (MOVWconst [c]) x [d]) 15533 // cond: 15534 // result: (RSBconst [c] (SRAconst <x.Type> x [d])) 15535 for { 15536 d := v.AuxInt 15537 _ = v.Args[1] 15538 v_0 := v.Args[0] 15539 if v_0.Op != OpARMMOVWconst { 15540 break 15541 } 15542 c := v_0.AuxInt 15543 x := v.Args[1] 15544 v.reset(OpARMRSBconst) 15545 v.AuxInt = c 15546 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 15547 v0.AuxInt = d 15548 v0.AddArg(x) 15549 v.AddArg(v0) 15550 return true 15551 } 15552 // match: (SUBshiftRA x (MOVWconst [c]) [d]) 15553 // cond: 15554 // result: (SUBconst x [int64(int32(c)>>uint64(d))]) 15555 for { 15556 d := v.AuxInt 15557 _ = v.Args[1] 15558 x := v.Args[0] 15559 v_1 := v.Args[1] 15560 if v_1.Op != OpARMMOVWconst { 15561 break 15562 } 15563 c := v_1.AuxInt 15564 v.reset(OpARMSUBconst) 15565 v.AuxInt = int64(int32(c) >> uint64(d)) 15566 v.AddArg(x) 15567 return true 15568 } 15569 // match: (SUBshiftRA x (SRAconst x [c]) [d]) 15570 // cond: c==d 15571 // result: (MOVWconst [0]) 15572 for { 15573 d := v.AuxInt 15574 _ = v.Args[1] 15575 x := v.Args[0] 15576 v_1 := v.Args[1] 15577 if v_1.Op != OpARMSRAconst { 15578 break 15579 } 15580 c := v_1.AuxInt 15581 if x != v_1.Args[0] { 15582 break 15583 } 15584 if !(c == d) { 15585 break 15586 } 15587 v.reset(OpARMMOVWconst) 15588 v.AuxInt = 0 15589 return true 15590 } 15591 return false 15592 } 15593 func rewriteValueARM_OpARMSUBshiftRAreg_0(v *Value) bool { 15594 b := v.Block 15595 _ = b 15596 // match: (SUBshiftRAreg (MOVWconst [c]) x y) 15597 // cond: 15598 // result: (RSBconst [c] (SRA <x.Type> x y)) 15599 for { 15600 _ = v.Args[2] 15601 v_0 := v.Args[0] 15602 if v_0.Op != OpARMMOVWconst { 15603 break 15604 } 15605 c := v_0.AuxInt 15606 x := v.Args[1] 15607 y := v.Args[2] 15608 v.reset(OpARMRSBconst) 15609 v.AuxInt = c 15610 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 15611 v0.AddArg(x) 15612 v0.AddArg(y) 15613 v.AddArg(v0) 15614 return true 15615 } 15616 // match: (SUBshiftRAreg x y (MOVWconst [c])) 15617 // cond: 15618 // result: (SUBshiftRA x y [c]) 15619 for { 15620 _ = v.Args[2] 15621 x := v.Args[0] 15622 y := v.Args[1] 15623 v_2 := v.Args[2] 15624 if v_2.Op != OpARMMOVWconst { 15625 break 15626 } 15627 c := v_2.AuxInt 15628 v.reset(OpARMSUBshiftRA) 15629 v.AuxInt = c 15630 v.AddArg(x) 15631 v.AddArg(y) 15632 return true 15633 } 15634 return false 15635 } 15636 func rewriteValueARM_OpARMSUBshiftRL_0(v *Value) bool { 15637 b := v.Block 15638 _ = b 15639 // match: (SUBshiftRL (MOVWconst [c]) x [d]) 15640 // cond: 15641 // result: (RSBconst [c] (SRLconst <x.Type> x [d])) 15642 for { 15643 d := v.AuxInt 15644 _ = v.Args[1] 15645 v_0 := v.Args[0] 15646 if v_0.Op != OpARMMOVWconst { 15647 break 15648 } 15649 c := v_0.AuxInt 15650 x := v.Args[1] 15651 v.reset(OpARMRSBconst) 15652 v.AuxInt = c 15653 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 15654 v0.AuxInt = d 15655 v0.AddArg(x) 15656 v.AddArg(v0) 15657 return true 15658 } 15659 // match: (SUBshiftRL x (MOVWconst [c]) [d]) 15660 // cond: 15661 // result: (SUBconst x [int64(int32(uint32(c)>>uint64(d)))]) 15662 for { 15663 d := v.AuxInt 15664 _ = v.Args[1] 15665 x := v.Args[0] 15666 v_1 := v.Args[1] 15667 if v_1.Op != OpARMMOVWconst { 15668 break 15669 } 15670 c := v_1.AuxInt 15671 v.reset(OpARMSUBconst) 15672 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 15673 v.AddArg(x) 15674 return true 15675 } 15676 // match: (SUBshiftRL x (SRLconst x [c]) [d]) 15677 // cond: c==d 15678 // result: (MOVWconst [0]) 15679 for { 15680 d := v.AuxInt 15681 _ = v.Args[1] 15682 x := v.Args[0] 15683 v_1 := v.Args[1] 15684 if v_1.Op != OpARMSRLconst { 15685 break 15686 } 15687 c := v_1.AuxInt 15688 if x != v_1.Args[0] { 15689 break 15690 } 15691 if !(c == d) { 15692 break 15693 } 15694 v.reset(OpARMMOVWconst) 15695 v.AuxInt = 0 15696 return true 15697 } 15698 return false 15699 } 15700 func rewriteValueARM_OpARMSUBshiftRLreg_0(v *Value) bool { 15701 b := v.Block 15702 _ = b 15703 // match: (SUBshiftRLreg (MOVWconst [c]) x y) 15704 // cond: 15705 // result: (RSBconst [c] (SRL <x.Type> x y)) 15706 for { 15707 _ = v.Args[2] 15708 v_0 := v.Args[0] 15709 if v_0.Op != OpARMMOVWconst { 15710 break 15711 } 15712 c := v_0.AuxInt 15713 x := v.Args[1] 15714 y := v.Args[2] 15715 v.reset(OpARMRSBconst) 15716 v.AuxInt = c 15717 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 15718 v0.AddArg(x) 15719 v0.AddArg(y) 15720 v.AddArg(v0) 15721 return true 15722 } 15723 // match: (SUBshiftRLreg x y (MOVWconst [c])) 15724 // cond: 15725 // result: (SUBshiftRL x y [c]) 15726 for { 15727 _ = v.Args[2] 15728 x := v.Args[0] 15729 y := v.Args[1] 15730 v_2 := v.Args[2] 15731 if v_2.Op != OpARMMOVWconst { 15732 break 15733 } 15734 c := v_2.AuxInt 15735 v.reset(OpARMSUBshiftRL) 15736 v.AuxInt = c 15737 v.AddArg(x) 15738 v.AddArg(y) 15739 return true 15740 } 15741 return false 15742 } 15743 func rewriteValueARM_OpARMTEQ_0(v *Value) bool { 15744 // match: (TEQ x (MOVWconst [c])) 15745 // cond: 15746 // result: (TEQconst [c] x) 15747 for { 15748 _ = v.Args[1] 15749 x := v.Args[0] 15750 v_1 := v.Args[1] 15751 if v_1.Op != OpARMMOVWconst { 15752 break 15753 } 15754 c := v_1.AuxInt 15755 v.reset(OpARMTEQconst) 15756 v.AuxInt = c 15757 v.AddArg(x) 15758 return true 15759 } 15760 // match: (TEQ (MOVWconst [c]) x) 15761 // cond: 15762 // result: (TEQconst [c] x) 15763 for { 15764 _ = v.Args[1] 15765 v_0 := v.Args[0] 15766 if v_0.Op != OpARMMOVWconst { 15767 break 15768 } 15769 c := v_0.AuxInt 15770 x := v.Args[1] 15771 v.reset(OpARMTEQconst) 15772 v.AuxInt = c 15773 v.AddArg(x) 15774 return true 15775 } 15776 // match: (TEQ x (SLLconst [c] y)) 15777 // cond: 15778 // result: (TEQshiftLL x y [c]) 15779 for { 15780 _ = v.Args[1] 15781 x := v.Args[0] 15782 v_1 := v.Args[1] 15783 if v_1.Op != OpARMSLLconst { 15784 break 15785 } 15786 c := v_1.AuxInt 15787 y := v_1.Args[0] 15788 v.reset(OpARMTEQshiftLL) 15789 v.AuxInt = c 15790 v.AddArg(x) 15791 v.AddArg(y) 15792 return true 15793 } 15794 // match: (TEQ (SLLconst [c] y) x) 15795 // cond: 15796 // result: (TEQshiftLL x y [c]) 15797 for { 15798 _ = v.Args[1] 15799 v_0 := v.Args[0] 15800 if v_0.Op != OpARMSLLconst { 15801 break 15802 } 15803 c := v_0.AuxInt 15804 y := v_0.Args[0] 15805 x := v.Args[1] 15806 v.reset(OpARMTEQshiftLL) 15807 v.AuxInt = c 15808 v.AddArg(x) 15809 v.AddArg(y) 15810 return true 15811 } 15812 // match: (TEQ x (SRLconst [c] y)) 15813 // cond: 15814 // result: (TEQshiftRL x y [c]) 15815 for { 15816 _ = v.Args[1] 15817 x := v.Args[0] 15818 v_1 := v.Args[1] 15819 if v_1.Op != OpARMSRLconst { 15820 break 15821 } 15822 c := v_1.AuxInt 15823 y := v_1.Args[0] 15824 v.reset(OpARMTEQshiftRL) 15825 v.AuxInt = c 15826 v.AddArg(x) 15827 v.AddArg(y) 15828 return true 15829 } 15830 // match: (TEQ (SRLconst [c] y) x) 15831 // cond: 15832 // result: (TEQshiftRL x y [c]) 15833 for { 15834 _ = v.Args[1] 15835 v_0 := v.Args[0] 15836 if v_0.Op != OpARMSRLconst { 15837 break 15838 } 15839 c := v_0.AuxInt 15840 y := v_0.Args[0] 15841 x := v.Args[1] 15842 v.reset(OpARMTEQshiftRL) 15843 v.AuxInt = c 15844 v.AddArg(x) 15845 v.AddArg(y) 15846 return true 15847 } 15848 // match: (TEQ x (SRAconst [c] y)) 15849 // cond: 15850 // result: (TEQshiftRA x y [c]) 15851 for { 15852 _ = v.Args[1] 15853 x := v.Args[0] 15854 v_1 := v.Args[1] 15855 if v_1.Op != OpARMSRAconst { 15856 break 15857 } 15858 c := v_1.AuxInt 15859 y := v_1.Args[0] 15860 v.reset(OpARMTEQshiftRA) 15861 v.AuxInt = c 15862 v.AddArg(x) 15863 v.AddArg(y) 15864 return true 15865 } 15866 // match: (TEQ (SRAconst [c] y) x) 15867 // cond: 15868 // result: (TEQshiftRA x y [c]) 15869 for { 15870 _ = v.Args[1] 15871 v_0 := v.Args[0] 15872 if v_0.Op != OpARMSRAconst { 15873 break 15874 } 15875 c := v_0.AuxInt 15876 y := v_0.Args[0] 15877 x := v.Args[1] 15878 v.reset(OpARMTEQshiftRA) 15879 v.AuxInt = c 15880 v.AddArg(x) 15881 v.AddArg(y) 15882 return true 15883 } 15884 // match: (TEQ x (SLL y z)) 15885 // cond: 15886 // result: (TEQshiftLLreg x y z) 15887 for { 15888 _ = v.Args[1] 15889 x := v.Args[0] 15890 v_1 := v.Args[1] 15891 if v_1.Op != OpARMSLL { 15892 break 15893 } 15894 _ = v_1.Args[1] 15895 y := v_1.Args[0] 15896 z := v_1.Args[1] 15897 v.reset(OpARMTEQshiftLLreg) 15898 v.AddArg(x) 15899 v.AddArg(y) 15900 v.AddArg(z) 15901 return true 15902 } 15903 // match: (TEQ (SLL y z) x) 15904 // cond: 15905 // result: (TEQshiftLLreg x y z) 15906 for { 15907 _ = v.Args[1] 15908 v_0 := v.Args[0] 15909 if v_0.Op != OpARMSLL { 15910 break 15911 } 15912 _ = v_0.Args[1] 15913 y := v_0.Args[0] 15914 z := v_0.Args[1] 15915 x := v.Args[1] 15916 v.reset(OpARMTEQshiftLLreg) 15917 v.AddArg(x) 15918 v.AddArg(y) 15919 v.AddArg(z) 15920 return true 15921 } 15922 return false 15923 } 15924 func rewriteValueARM_OpARMTEQ_10(v *Value) bool { 15925 // match: (TEQ x (SRL y z)) 15926 // cond: 15927 // result: (TEQshiftRLreg x y z) 15928 for { 15929 _ = v.Args[1] 15930 x := v.Args[0] 15931 v_1 := v.Args[1] 15932 if v_1.Op != OpARMSRL { 15933 break 15934 } 15935 _ = v_1.Args[1] 15936 y := v_1.Args[0] 15937 z := v_1.Args[1] 15938 v.reset(OpARMTEQshiftRLreg) 15939 v.AddArg(x) 15940 v.AddArg(y) 15941 v.AddArg(z) 15942 return true 15943 } 15944 // match: (TEQ (SRL y z) x) 15945 // cond: 15946 // result: (TEQshiftRLreg x y z) 15947 for { 15948 _ = v.Args[1] 15949 v_0 := v.Args[0] 15950 if v_0.Op != OpARMSRL { 15951 break 15952 } 15953 _ = v_0.Args[1] 15954 y := v_0.Args[0] 15955 z := v_0.Args[1] 15956 x := v.Args[1] 15957 v.reset(OpARMTEQshiftRLreg) 15958 v.AddArg(x) 15959 v.AddArg(y) 15960 v.AddArg(z) 15961 return true 15962 } 15963 // match: (TEQ x (SRA y z)) 15964 // cond: 15965 // result: (TEQshiftRAreg x y z) 15966 for { 15967 _ = v.Args[1] 15968 x := v.Args[0] 15969 v_1 := v.Args[1] 15970 if v_1.Op != OpARMSRA { 15971 break 15972 } 15973 _ = v_1.Args[1] 15974 y := v_1.Args[0] 15975 z := v_1.Args[1] 15976 v.reset(OpARMTEQshiftRAreg) 15977 v.AddArg(x) 15978 v.AddArg(y) 15979 v.AddArg(z) 15980 return true 15981 } 15982 // match: (TEQ (SRA y z) x) 15983 // cond: 15984 // result: (TEQshiftRAreg x y z) 15985 for { 15986 _ = v.Args[1] 15987 v_0 := v.Args[0] 15988 if v_0.Op != OpARMSRA { 15989 break 15990 } 15991 _ = v_0.Args[1] 15992 y := v_0.Args[0] 15993 z := v_0.Args[1] 15994 x := v.Args[1] 15995 v.reset(OpARMTEQshiftRAreg) 15996 v.AddArg(x) 15997 v.AddArg(y) 15998 v.AddArg(z) 15999 return true 16000 } 16001 return false 16002 } 16003 func rewriteValueARM_OpARMTEQconst_0(v *Value) bool { 16004 // match: (TEQconst (MOVWconst [x]) [y]) 16005 // cond: int32(x^y)==0 16006 // result: (FlagEQ) 16007 for { 16008 y := v.AuxInt 16009 v_0 := v.Args[0] 16010 if v_0.Op != OpARMMOVWconst { 16011 break 16012 } 16013 x := v_0.AuxInt 16014 if !(int32(x^y) == 0) { 16015 break 16016 } 16017 v.reset(OpARMFlagEQ) 16018 return true 16019 } 16020 // match: (TEQconst (MOVWconst [x]) [y]) 16021 // cond: int32(x^y)<0 16022 // result: (FlagLT_UGT) 16023 for { 16024 y := v.AuxInt 16025 v_0 := v.Args[0] 16026 if v_0.Op != OpARMMOVWconst { 16027 break 16028 } 16029 x := v_0.AuxInt 16030 if !(int32(x^y) < 0) { 16031 break 16032 } 16033 v.reset(OpARMFlagLT_UGT) 16034 return true 16035 } 16036 // match: (TEQconst (MOVWconst [x]) [y]) 16037 // cond: int32(x^y)>0 16038 // result: (FlagGT_UGT) 16039 for { 16040 y := v.AuxInt 16041 v_0 := v.Args[0] 16042 if v_0.Op != OpARMMOVWconst { 16043 break 16044 } 16045 x := v_0.AuxInt 16046 if !(int32(x^y) > 0) { 16047 break 16048 } 16049 v.reset(OpARMFlagGT_UGT) 16050 return true 16051 } 16052 return false 16053 } 16054 func rewriteValueARM_OpARMTEQshiftLL_0(v *Value) bool { 16055 b := v.Block 16056 _ = b 16057 // match: (TEQshiftLL (MOVWconst [c]) x [d]) 16058 // cond: 16059 // result: (TEQconst [c] (SLLconst <x.Type> x [d])) 16060 for { 16061 d := v.AuxInt 16062 _ = v.Args[1] 16063 v_0 := v.Args[0] 16064 if v_0.Op != OpARMMOVWconst { 16065 break 16066 } 16067 c := v_0.AuxInt 16068 x := v.Args[1] 16069 v.reset(OpARMTEQconst) 16070 v.AuxInt = c 16071 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 16072 v0.AuxInt = d 16073 v0.AddArg(x) 16074 v.AddArg(v0) 16075 return true 16076 } 16077 // match: (TEQshiftLL x (MOVWconst [c]) [d]) 16078 // cond: 16079 // result: (TEQconst x [int64(int32(uint32(c)<<uint64(d)))]) 16080 for { 16081 d := v.AuxInt 16082 _ = v.Args[1] 16083 x := v.Args[0] 16084 v_1 := v.Args[1] 16085 if v_1.Op != OpARMMOVWconst { 16086 break 16087 } 16088 c := v_1.AuxInt 16089 v.reset(OpARMTEQconst) 16090 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 16091 v.AddArg(x) 16092 return true 16093 } 16094 return false 16095 } 16096 func rewriteValueARM_OpARMTEQshiftLLreg_0(v *Value) bool { 16097 b := v.Block 16098 _ = b 16099 // match: (TEQshiftLLreg (MOVWconst [c]) x y) 16100 // cond: 16101 // result: (TEQconst [c] (SLL <x.Type> x y)) 16102 for { 16103 _ = v.Args[2] 16104 v_0 := v.Args[0] 16105 if v_0.Op != OpARMMOVWconst { 16106 break 16107 } 16108 c := v_0.AuxInt 16109 x := v.Args[1] 16110 y := v.Args[2] 16111 v.reset(OpARMTEQconst) 16112 v.AuxInt = c 16113 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 16114 v0.AddArg(x) 16115 v0.AddArg(y) 16116 v.AddArg(v0) 16117 return true 16118 } 16119 // match: (TEQshiftLLreg x y (MOVWconst [c])) 16120 // cond: 16121 // result: (TEQshiftLL x y [c]) 16122 for { 16123 _ = v.Args[2] 16124 x := v.Args[0] 16125 y := v.Args[1] 16126 v_2 := v.Args[2] 16127 if v_2.Op != OpARMMOVWconst { 16128 break 16129 } 16130 c := v_2.AuxInt 16131 v.reset(OpARMTEQshiftLL) 16132 v.AuxInt = c 16133 v.AddArg(x) 16134 v.AddArg(y) 16135 return true 16136 } 16137 return false 16138 } 16139 func rewriteValueARM_OpARMTEQshiftRA_0(v *Value) bool { 16140 b := v.Block 16141 _ = b 16142 // match: (TEQshiftRA (MOVWconst [c]) x [d]) 16143 // cond: 16144 // result: (TEQconst [c] (SRAconst <x.Type> x [d])) 16145 for { 16146 d := v.AuxInt 16147 _ = v.Args[1] 16148 v_0 := v.Args[0] 16149 if v_0.Op != OpARMMOVWconst { 16150 break 16151 } 16152 c := v_0.AuxInt 16153 x := v.Args[1] 16154 v.reset(OpARMTEQconst) 16155 v.AuxInt = c 16156 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 16157 v0.AuxInt = d 16158 v0.AddArg(x) 16159 v.AddArg(v0) 16160 return true 16161 } 16162 // match: (TEQshiftRA x (MOVWconst [c]) [d]) 16163 // cond: 16164 // result: (TEQconst x [int64(int32(c)>>uint64(d))]) 16165 for { 16166 d := v.AuxInt 16167 _ = v.Args[1] 16168 x := v.Args[0] 16169 v_1 := v.Args[1] 16170 if v_1.Op != OpARMMOVWconst { 16171 break 16172 } 16173 c := v_1.AuxInt 16174 v.reset(OpARMTEQconst) 16175 v.AuxInt = int64(int32(c) >> uint64(d)) 16176 v.AddArg(x) 16177 return true 16178 } 16179 return false 16180 } 16181 func rewriteValueARM_OpARMTEQshiftRAreg_0(v *Value) bool { 16182 b := v.Block 16183 _ = b 16184 // match: (TEQshiftRAreg (MOVWconst [c]) x y) 16185 // cond: 16186 // result: (TEQconst [c] (SRA <x.Type> x y)) 16187 for { 16188 _ = v.Args[2] 16189 v_0 := v.Args[0] 16190 if v_0.Op != OpARMMOVWconst { 16191 break 16192 } 16193 c := v_0.AuxInt 16194 x := v.Args[1] 16195 y := v.Args[2] 16196 v.reset(OpARMTEQconst) 16197 v.AuxInt = c 16198 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 16199 v0.AddArg(x) 16200 v0.AddArg(y) 16201 v.AddArg(v0) 16202 return true 16203 } 16204 // match: (TEQshiftRAreg x y (MOVWconst [c])) 16205 // cond: 16206 // result: (TEQshiftRA x y [c]) 16207 for { 16208 _ = v.Args[2] 16209 x := v.Args[0] 16210 y := v.Args[1] 16211 v_2 := v.Args[2] 16212 if v_2.Op != OpARMMOVWconst { 16213 break 16214 } 16215 c := v_2.AuxInt 16216 v.reset(OpARMTEQshiftRA) 16217 v.AuxInt = c 16218 v.AddArg(x) 16219 v.AddArg(y) 16220 return true 16221 } 16222 return false 16223 } 16224 func rewriteValueARM_OpARMTEQshiftRL_0(v *Value) bool { 16225 b := v.Block 16226 _ = b 16227 // match: (TEQshiftRL (MOVWconst [c]) x [d]) 16228 // cond: 16229 // result: (TEQconst [c] (SRLconst <x.Type> x [d])) 16230 for { 16231 d := v.AuxInt 16232 _ = v.Args[1] 16233 v_0 := v.Args[0] 16234 if v_0.Op != OpARMMOVWconst { 16235 break 16236 } 16237 c := v_0.AuxInt 16238 x := v.Args[1] 16239 v.reset(OpARMTEQconst) 16240 v.AuxInt = c 16241 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 16242 v0.AuxInt = d 16243 v0.AddArg(x) 16244 v.AddArg(v0) 16245 return true 16246 } 16247 // match: (TEQshiftRL x (MOVWconst [c]) [d]) 16248 // cond: 16249 // result: (TEQconst x [int64(int32(uint32(c)>>uint64(d)))]) 16250 for { 16251 d := v.AuxInt 16252 _ = v.Args[1] 16253 x := v.Args[0] 16254 v_1 := v.Args[1] 16255 if v_1.Op != OpARMMOVWconst { 16256 break 16257 } 16258 c := v_1.AuxInt 16259 v.reset(OpARMTEQconst) 16260 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 16261 v.AddArg(x) 16262 return true 16263 } 16264 return false 16265 } 16266 func rewriteValueARM_OpARMTEQshiftRLreg_0(v *Value) bool { 16267 b := v.Block 16268 _ = b 16269 // match: (TEQshiftRLreg (MOVWconst [c]) x y) 16270 // cond: 16271 // result: (TEQconst [c] (SRL <x.Type> x y)) 16272 for { 16273 _ = v.Args[2] 16274 v_0 := v.Args[0] 16275 if v_0.Op != OpARMMOVWconst { 16276 break 16277 } 16278 c := v_0.AuxInt 16279 x := v.Args[1] 16280 y := v.Args[2] 16281 v.reset(OpARMTEQconst) 16282 v.AuxInt = c 16283 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 16284 v0.AddArg(x) 16285 v0.AddArg(y) 16286 v.AddArg(v0) 16287 return true 16288 } 16289 // match: (TEQshiftRLreg x y (MOVWconst [c])) 16290 // cond: 16291 // result: (TEQshiftRL x y [c]) 16292 for { 16293 _ = v.Args[2] 16294 x := v.Args[0] 16295 y := v.Args[1] 16296 v_2 := v.Args[2] 16297 if v_2.Op != OpARMMOVWconst { 16298 break 16299 } 16300 c := v_2.AuxInt 16301 v.reset(OpARMTEQshiftRL) 16302 v.AuxInt = c 16303 v.AddArg(x) 16304 v.AddArg(y) 16305 return true 16306 } 16307 return false 16308 } 16309 func rewriteValueARM_OpARMTST_0(v *Value) bool { 16310 // match: (TST x (MOVWconst [c])) 16311 // cond: 16312 // result: (TSTconst [c] x) 16313 for { 16314 _ = v.Args[1] 16315 x := v.Args[0] 16316 v_1 := v.Args[1] 16317 if v_1.Op != OpARMMOVWconst { 16318 break 16319 } 16320 c := v_1.AuxInt 16321 v.reset(OpARMTSTconst) 16322 v.AuxInt = c 16323 v.AddArg(x) 16324 return true 16325 } 16326 // match: (TST (MOVWconst [c]) x) 16327 // cond: 16328 // result: (TSTconst [c] x) 16329 for { 16330 _ = v.Args[1] 16331 v_0 := v.Args[0] 16332 if v_0.Op != OpARMMOVWconst { 16333 break 16334 } 16335 c := v_0.AuxInt 16336 x := v.Args[1] 16337 v.reset(OpARMTSTconst) 16338 v.AuxInt = c 16339 v.AddArg(x) 16340 return true 16341 } 16342 // match: (TST x (SLLconst [c] y)) 16343 // cond: 16344 // result: (TSTshiftLL x y [c]) 16345 for { 16346 _ = v.Args[1] 16347 x := v.Args[0] 16348 v_1 := v.Args[1] 16349 if v_1.Op != OpARMSLLconst { 16350 break 16351 } 16352 c := v_1.AuxInt 16353 y := v_1.Args[0] 16354 v.reset(OpARMTSTshiftLL) 16355 v.AuxInt = c 16356 v.AddArg(x) 16357 v.AddArg(y) 16358 return true 16359 } 16360 // match: (TST (SLLconst [c] y) x) 16361 // cond: 16362 // result: (TSTshiftLL x y [c]) 16363 for { 16364 _ = v.Args[1] 16365 v_0 := v.Args[0] 16366 if v_0.Op != OpARMSLLconst { 16367 break 16368 } 16369 c := v_0.AuxInt 16370 y := v_0.Args[0] 16371 x := v.Args[1] 16372 v.reset(OpARMTSTshiftLL) 16373 v.AuxInt = c 16374 v.AddArg(x) 16375 v.AddArg(y) 16376 return true 16377 } 16378 // match: (TST x (SRLconst [c] y)) 16379 // cond: 16380 // result: (TSTshiftRL x y [c]) 16381 for { 16382 _ = v.Args[1] 16383 x := v.Args[0] 16384 v_1 := v.Args[1] 16385 if v_1.Op != OpARMSRLconst { 16386 break 16387 } 16388 c := v_1.AuxInt 16389 y := v_1.Args[0] 16390 v.reset(OpARMTSTshiftRL) 16391 v.AuxInt = c 16392 v.AddArg(x) 16393 v.AddArg(y) 16394 return true 16395 } 16396 // match: (TST (SRLconst [c] y) x) 16397 // cond: 16398 // result: (TSTshiftRL x y [c]) 16399 for { 16400 _ = v.Args[1] 16401 v_0 := v.Args[0] 16402 if v_0.Op != OpARMSRLconst { 16403 break 16404 } 16405 c := v_0.AuxInt 16406 y := v_0.Args[0] 16407 x := v.Args[1] 16408 v.reset(OpARMTSTshiftRL) 16409 v.AuxInt = c 16410 v.AddArg(x) 16411 v.AddArg(y) 16412 return true 16413 } 16414 // match: (TST x (SRAconst [c] y)) 16415 // cond: 16416 // result: (TSTshiftRA x y [c]) 16417 for { 16418 _ = v.Args[1] 16419 x := v.Args[0] 16420 v_1 := v.Args[1] 16421 if v_1.Op != OpARMSRAconst { 16422 break 16423 } 16424 c := v_1.AuxInt 16425 y := v_1.Args[0] 16426 v.reset(OpARMTSTshiftRA) 16427 v.AuxInt = c 16428 v.AddArg(x) 16429 v.AddArg(y) 16430 return true 16431 } 16432 // match: (TST (SRAconst [c] y) x) 16433 // cond: 16434 // result: (TSTshiftRA x y [c]) 16435 for { 16436 _ = v.Args[1] 16437 v_0 := v.Args[0] 16438 if v_0.Op != OpARMSRAconst { 16439 break 16440 } 16441 c := v_0.AuxInt 16442 y := v_0.Args[0] 16443 x := v.Args[1] 16444 v.reset(OpARMTSTshiftRA) 16445 v.AuxInt = c 16446 v.AddArg(x) 16447 v.AddArg(y) 16448 return true 16449 } 16450 // match: (TST x (SLL y z)) 16451 // cond: 16452 // result: (TSTshiftLLreg x y z) 16453 for { 16454 _ = v.Args[1] 16455 x := v.Args[0] 16456 v_1 := v.Args[1] 16457 if v_1.Op != OpARMSLL { 16458 break 16459 } 16460 _ = v_1.Args[1] 16461 y := v_1.Args[0] 16462 z := v_1.Args[1] 16463 v.reset(OpARMTSTshiftLLreg) 16464 v.AddArg(x) 16465 v.AddArg(y) 16466 v.AddArg(z) 16467 return true 16468 } 16469 // match: (TST (SLL y z) x) 16470 // cond: 16471 // result: (TSTshiftLLreg x y z) 16472 for { 16473 _ = v.Args[1] 16474 v_0 := v.Args[0] 16475 if v_0.Op != OpARMSLL { 16476 break 16477 } 16478 _ = v_0.Args[1] 16479 y := v_0.Args[0] 16480 z := v_0.Args[1] 16481 x := v.Args[1] 16482 v.reset(OpARMTSTshiftLLreg) 16483 v.AddArg(x) 16484 v.AddArg(y) 16485 v.AddArg(z) 16486 return true 16487 } 16488 return false 16489 } 16490 func rewriteValueARM_OpARMTST_10(v *Value) bool { 16491 // match: (TST x (SRL y z)) 16492 // cond: 16493 // result: (TSTshiftRLreg x y z) 16494 for { 16495 _ = v.Args[1] 16496 x := v.Args[0] 16497 v_1 := v.Args[1] 16498 if v_1.Op != OpARMSRL { 16499 break 16500 } 16501 _ = v_1.Args[1] 16502 y := v_1.Args[0] 16503 z := v_1.Args[1] 16504 v.reset(OpARMTSTshiftRLreg) 16505 v.AddArg(x) 16506 v.AddArg(y) 16507 v.AddArg(z) 16508 return true 16509 } 16510 // match: (TST (SRL y z) x) 16511 // cond: 16512 // result: (TSTshiftRLreg x y z) 16513 for { 16514 _ = v.Args[1] 16515 v_0 := v.Args[0] 16516 if v_0.Op != OpARMSRL { 16517 break 16518 } 16519 _ = v_0.Args[1] 16520 y := v_0.Args[0] 16521 z := v_0.Args[1] 16522 x := v.Args[1] 16523 v.reset(OpARMTSTshiftRLreg) 16524 v.AddArg(x) 16525 v.AddArg(y) 16526 v.AddArg(z) 16527 return true 16528 } 16529 // match: (TST x (SRA y z)) 16530 // cond: 16531 // result: (TSTshiftRAreg x y z) 16532 for { 16533 _ = v.Args[1] 16534 x := v.Args[0] 16535 v_1 := v.Args[1] 16536 if v_1.Op != OpARMSRA { 16537 break 16538 } 16539 _ = v_1.Args[1] 16540 y := v_1.Args[0] 16541 z := v_1.Args[1] 16542 v.reset(OpARMTSTshiftRAreg) 16543 v.AddArg(x) 16544 v.AddArg(y) 16545 v.AddArg(z) 16546 return true 16547 } 16548 // match: (TST (SRA y z) x) 16549 // cond: 16550 // result: (TSTshiftRAreg x y z) 16551 for { 16552 _ = v.Args[1] 16553 v_0 := v.Args[0] 16554 if v_0.Op != OpARMSRA { 16555 break 16556 } 16557 _ = v_0.Args[1] 16558 y := v_0.Args[0] 16559 z := v_0.Args[1] 16560 x := v.Args[1] 16561 v.reset(OpARMTSTshiftRAreg) 16562 v.AddArg(x) 16563 v.AddArg(y) 16564 v.AddArg(z) 16565 return true 16566 } 16567 return false 16568 } 16569 func rewriteValueARM_OpARMTSTconst_0(v *Value) bool { 16570 // match: (TSTconst (MOVWconst [x]) [y]) 16571 // cond: int32(x&y)==0 16572 // result: (FlagEQ) 16573 for { 16574 y := v.AuxInt 16575 v_0 := v.Args[0] 16576 if v_0.Op != OpARMMOVWconst { 16577 break 16578 } 16579 x := v_0.AuxInt 16580 if !(int32(x&y) == 0) { 16581 break 16582 } 16583 v.reset(OpARMFlagEQ) 16584 return true 16585 } 16586 // match: (TSTconst (MOVWconst [x]) [y]) 16587 // cond: int32(x&y)<0 16588 // result: (FlagLT_UGT) 16589 for { 16590 y := v.AuxInt 16591 v_0 := v.Args[0] 16592 if v_0.Op != OpARMMOVWconst { 16593 break 16594 } 16595 x := v_0.AuxInt 16596 if !(int32(x&y) < 0) { 16597 break 16598 } 16599 v.reset(OpARMFlagLT_UGT) 16600 return true 16601 } 16602 // match: (TSTconst (MOVWconst [x]) [y]) 16603 // cond: int32(x&y)>0 16604 // result: (FlagGT_UGT) 16605 for { 16606 y := v.AuxInt 16607 v_0 := v.Args[0] 16608 if v_0.Op != OpARMMOVWconst { 16609 break 16610 } 16611 x := v_0.AuxInt 16612 if !(int32(x&y) > 0) { 16613 break 16614 } 16615 v.reset(OpARMFlagGT_UGT) 16616 return true 16617 } 16618 return false 16619 } 16620 func rewriteValueARM_OpARMTSTshiftLL_0(v *Value) bool { 16621 b := v.Block 16622 _ = b 16623 // match: (TSTshiftLL (MOVWconst [c]) x [d]) 16624 // cond: 16625 // result: (TSTconst [c] (SLLconst <x.Type> x [d])) 16626 for { 16627 d := v.AuxInt 16628 _ = v.Args[1] 16629 v_0 := v.Args[0] 16630 if v_0.Op != OpARMMOVWconst { 16631 break 16632 } 16633 c := v_0.AuxInt 16634 x := v.Args[1] 16635 v.reset(OpARMTSTconst) 16636 v.AuxInt = c 16637 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 16638 v0.AuxInt = d 16639 v0.AddArg(x) 16640 v.AddArg(v0) 16641 return true 16642 } 16643 // match: (TSTshiftLL x (MOVWconst [c]) [d]) 16644 // cond: 16645 // result: (TSTconst x [int64(int32(uint32(c)<<uint64(d)))]) 16646 for { 16647 d := v.AuxInt 16648 _ = v.Args[1] 16649 x := v.Args[0] 16650 v_1 := v.Args[1] 16651 if v_1.Op != OpARMMOVWconst { 16652 break 16653 } 16654 c := v_1.AuxInt 16655 v.reset(OpARMTSTconst) 16656 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 16657 v.AddArg(x) 16658 return true 16659 } 16660 return false 16661 } 16662 func rewriteValueARM_OpARMTSTshiftLLreg_0(v *Value) bool { 16663 b := v.Block 16664 _ = b 16665 // match: (TSTshiftLLreg (MOVWconst [c]) x y) 16666 // cond: 16667 // result: (TSTconst [c] (SLL <x.Type> x y)) 16668 for { 16669 _ = v.Args[2] 16670 v_0 := v.Args[0] 16671 if v_0.Op != OpARMMOVWconst { 16672 break 16673 } 16674 c := v_0.AuxInt 16675 x := v.Args[1] 16676 y := v.Args[2] 16677 v.reset(OpARMTSTconst) 16678 v.AuxInt = c 16679 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 16680 v0.AddArg(x) 16681 v0.AddArg(y) 16682 v.AddArg(v0) 16683 return true 16684 } 16685 // match: (TSTshiftLLreg x y (MOVWconst [c])) 16686 // cond: 16687 // result: (TSTshiftLL x y [c]) 16688 for { 16689 _ = v.Args[2] 16690 x := v.Args[0] 16691 y := v.Args[1] 16692 v_2 := v.Args[2] 16693 if v_2.Op != OpARMMOVWconst { 16694 break 16695 } 16696 c := v_2.AuxInt 16697 v.reset(OpARMTSTshiftLL) 16698 v.AuxInt = c 16699 v.AddArg(x) 16700 v.AddArg(y) 16701 return true 16702 } 16703 return false 16704 } 16705 func rewriteValueARM_OpARMTSTshiftRA_0(v *Value) bool { 16706 b := v.Block 16707 _ = b 16708 // match: (TSTshiftRA (MOVWconst [c]) x [d]) 16709 // cond: 16710 // result: (TSTconst [c] (SRAconst <x.Type> x [d])) 16711 for { 16712 d := v.AuxInt 16713 _ = v.Args[1] 16714 v_0 := v.Args[0] 16715 if v_0.Op != OpARMMOVWconst { 16716 break 16717 } 16718 c := v_0.AuxInt 16719 x := v.Args[1] 16720 v.reset(OpARMTSTconst) 16721 v.AuxInt = c 16722 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 16723 v0.AuxInt = d 16724 v0.AddArg(x) 16725 v.AddArg(v0) 16726 return true 16727 } 16728 // match: (TSTshiftRA x (MOVWconst [c]) [d]) 16729 // cond: 16730 // result: (TSTconst x [int64(int32(c)>>uint64(d))]) 16731 for { 16732 d := v.AuxInt 16733 _ = v.Args[1] 16734 x := v.Args[0] 16735 v_1 := v.Args[1] 16736 if v_1.Op != OpARMMOVWconst { 16737 break 16738 } 16739 c := v_1.AuxInt 16740 v.reset(OpARMTSTconst) 16741 v.AuxInt = int64(int32(c) >> uint64(d)) 16742 v.AddArg(x) 16743 return true 16744 } 16745 return false 16746 } 16747 func rewriteValueARM_OpARMTSTshiftRAreg_0(v *Value) bool { 16748 b := v.Block 16749 _ = b 16750 // match: (TSTshiftRAreg (MOVWconst [c]) x y) 16751 // cond: 16752 // result: (TSTconst [c] (SRA <x.Type> x y)) 16753 for { 16754 _ = v.Args[2] 16755 v_0 := v.Args[0] 16756 if v_0.Op != OpARMMOVWconst { 16757 break 16758 } 16759 c := v_0.AuxInt 16760 x := v.Args[1] 16761 y := v.Args[2] 16762 v.reset(OpARMTSTconst) 16763 v.AuxInt = c 16764 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 16765 v0.AddArg(x) 16766 v0.AddArg(y) 16767 v.AddArg(v0) 16768 return true 16769 } 16770 // match: (TSTshiftRAreg x y (MOVWconst [c])) 16771 // cond: 16772 // result: (TSTshiftRA x y [c]) 16773 for { 16774 _ = v.Args[2] 16775 x := v.Args[0] 16776 y := v.Args[1] 16777 v_2 := v.Args[2] 16778 if v_2.Op != OpARMMOVWconst { 16779 break 16780 } 16781 c := v_2.AuxInt 16782 v.reset(OpARMTSTshiftRA) 16783 v.AuxInt = c 16784 v.AddArg(x) 16785 v.AddArg(y) 16786 return true 16787 } 16788 return false 16789 } 16790 func rewriteValueARM_OpARMTSTshiftRL_0(v *Value) bool { 16791 b := v.Block 16792 _ = b 16793 // match: (TSTshiftRL (MOVWconst [c]) x [d]) 16794 // cond: 16795 // result: (TSTconst [c] (SRLconst <x.Type> x [d])) 16796 for { 16797 d := v.AuxInt 16798 _ = v.Args[1] 16799 v_0 := v.Args[0] 16800 if v_0.Op != OpARMMOVWconst { 16801 break 16802 } 16803 c := v_0.AuxInt 16804 x := v.Args[1] 16805 v.reset(OpARMTSTconst) 16806 v.AuxInt = c 16807 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 16808 v0.AuxInt = d 16809 v0.AddArg(x) 16810 v.AddArg(v0) 16811 return true 16812 } 16813 // match: (TSTshiftRL x (MOVWconst [c]) [d]) 16814 // cond: 16815 // result: (TSTconst x [int64(int32(uint32(c)>>uint64(d)))]) 16816 for { 16817 d := v.AuxInt 16818 _ = v.Args[1] 16819 x := v.Args[0] 16820 v_1 := v.Args[1] 16821 if v_1.Op != OpARMMOVWconst { 16822 break 16823 } 16824 c := v_1.AuxInt 16825 v.reset(OpARMTSTconst) 16826 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 16827 v.AddArg(x) 16828 return true 16829 } 16830 return false 16831 } 16832 func rewriteValueARM_OpARMTSTshiftRLreg_0(v *Value) bool { 16833 b := v.Block 16834 _ = b 16835 // match: (TSTshiftRLreg (MOVWconst [c]) x y) 16836 // cond: 16837 // result: (TSTconst [c] (SRL <x.Type> x y)) 16838 for { 16839 _ = v.Args[2] 16840 v_0 := v.Args[0] 16841 if v_0.Op != OpARMMOVWconst { 16842 break 16843 } 16844 c := v_0.AuxInt 16845 x := v.Args[1] 16846 y := v.Args[2] 16847 v.reset(OpARMTSTconst) 16848 v.AuxInt = c 16849 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 16850 v0.AddArg(x) 16851 v0.AddArg(y) 16852 v.AddArg(v0) 16853 return true 16854 } 16855 // match: (TSTshiftRLreg x y (MOVWconst [c])) 16856 // cond: 16857 // result: (TSTshiftRL x y [c]) 16858 for { 16859 _ = v.Args[2] 16860 x := v.Args[0] 16861 y := v.Args[1] 16862 v_2 := v.Args[2] 16863 if v_2.Op != OpARMMOVWconst { 16864 break 16865 } 16866 c := v_2.AuxInt 16867 v.reset(OpARMTSTshiftRL) 16868 v.AuxInt = c 16869 v.AddArg(x) 16870 v.AddArg(y) 16871 return true 16872 } 16873 return false 16874 } 16875 func rewriteValueARM_OpARMXOR_0(v *Value) bool { 16876 // match: (XOR x (MOVWconst [c])) 16877 // cond: 16878 // result: (XORconst [c] x) 16879 for { 16880 _ = v.Args[1] 16881 x := v.Args[0] 16882 v_1 := v.Args[1] 16883 if v_1.Op != OpARMMOVWconst { 16884 break 16885 } 16886 c := v_1.AuxInt 16887 v.reset(OpARMXORconst) 16888 v.AuxInt = c 16889 v.AddArg(x) 16890 return true 16891 } 16892 // match: (XOR (MOVWconst [c]) x) 16893 // cond: 16894 // result: (XORconst [c] x) 16895 for { 16896 _ = v.Args[1] 16897 v_0 := v.Args[0] 16898 if v_0.Op != OpARMMOVWconst { 16899 break 16900 } 16901 c := v_0.AuxInt 16902 x := v.Args[1] 16903 v.reset(OpARMXORconst) 16904 v.AuxInt = c 16905 v.AddArg(x) 16906 return true 16907 } 16908 // match: (XOR x (SLLconst [c] y)) 16909 // cond: 16910 // result: (XORshiftLL x y [c]) 16911 for { 16912 _ = v.Args[1] 16913 x := v.Args[0] 16914 v_1 := v.Args[1] 16915 if v_1.Op != OpARMSLLconst { 16916 break 16917 } 16918 c := v_1.AuxInt 16919 y := v_1.Args[0] 16920 v.reset(OpARMXORshiftLL) 16921 v.AuxInt = c 16922 v.AddArg(x) 16923 v.AddArg(y) 16924 return true 16925 } 16926 // match: (XOR (SLLconst [c] y) x) 16927 // cond: 16928 // result: (XORshiftLL x y [c]) 16929 for { 16930 _ = v.Args[1] 16931 v_0 := v.Args[0] 16932 if v_0.Op != OpARMSLLconst { 16933 break 16934 } 16935 c := v_0.AuxInt 16936 y := v_0.Args[0] 16937 x := v.Args[1] 16938 v.reset(OpARMXORshiftLL) 16939 v.AuxInt = c 16940 v.AddArg(x) 16941 v.AddArg(y) 16942 return true 16943 } 16944 // match: (XOR x (SRLconst [c] y)) 16945 // cond: 16946 // result: (XORshiftRL x y [c]) 16947 for { 16948 _ = v.Args[1] 16949 x := v.Args[0] 16950 v_1 := v.Args[1] 16951 if v_1.Op != OpARMSRLconst { 16952 break 16953 } 16954 c := v_1.AuxInt 16955 y := v_1.Args[0] 16956 v.reset(OpARMXORshiftRL) 16957 v.AuxInt = c 16958 v.AddArg(x) 16959 v.AddArg(y) 16960 return true 16961 } 16962 // match: (XOR (SRLconst [c] y) x) 16963 // cond: 16964 // result: (XORshiftRL x y [c]) 16965 for { 16966 _ = v.Args[1] 16967 v_0 := v.Args[0] 16968 if v_0.Op != OpARMSRLconst { 16969 break 16970 } 16971 c := v_0.AuxInt 16972 y := v_0.Args[0] 16973 x := v.Args[1] 16974 v.reset(OpARMXORshiftRL) 16975 v.AuxInt = c 16976 v.AddArg(x) 16977 v.AddArg(y) 16978 return true 16979 } 16980 // match: (XOR x (SRAconst [c] y)) 16981 // cond: 16982 // result: (XORshiftRA x y [c]) 16983 for { 16984 _ = v.Args[1] 16985 x := v.Args[0] 16986 v_1 := v.Args[1] 16987 if v_1.Op != OpARMSRAconst { 16988 break 16989 } 16990 c := v_1.AuxInt 16991 y := v_1.Args[0] 16992 v.reset(OpARMXORshiftRA) 16993 v.AuxInt = c 16994 v.AddArg(x) 16995 v.AddArg(y) 16996 return true 16997 } 16998 // match: (XOR (SRAconst [c] y) x) 16999 // cond: 17000 // result: (XORshiftRA x y [c]) 17001 for { 17002 _ = v.Args[1] 17003 v_0 := v.Args[0] 17004 if v_0.Op != OpARMSRAconst { 17005 break 17006 } 17007 c := v_0.AuxInt 17008 y := v_0.Args[0] 17009 x := v.Args[1] 17010 v.reset(OpARMXORshiftRA) 17011 v.AuxInt = c 17012 v.AddArg(x) 17013 v.AddArg(y) 17014 return true 17015 } 17016 // match: (XOR x (SRRconst [c] y)) 17017 // cond: 17018 // result: (XORshiftRR x y [c]) 17019 for { 17020 _ = v.Args[1] 17021 x := v.Args[0] 17022 v_1 := v.Args[1] 17023 if v_1.Op != OpARMSRRconst { 17024 break 17025 } 17026 c := v_1.AuxInt 17027 y := v_1.Args[0] 17028 v.reset(OpARMXORshiftRR) 17029 v.AuxInt = c 17030 v.AddArg(x) 17031 v.AddArg(y) 17032 return true 17033 } 17034 // match: (XOR (SRRconst [c] y) x) 17035 // cond: 17036 // result: (XORshiftRR x y [c]) 17037 for { 17038 _ = v.Args[1] 17039 v_0 := v.Args[0] 17040 if v_0.Op != OpARMSRRconst { 17041 break 17042 } 17043 c := v_0.AuxInt 17044 y := v_0.Args[0] 17045 x := v.Args[1] 17046 v.reset(OpARMXORshiftRR) 17047 v.AuxInt = c 17048 v.AddArg(x) 17049 v.AddArg(y) 17050 return true 17051 } 17052 return false 17053 } 17054 func rewriteValueARM_OpARMXOR_10(v *Value) bool { 17055 // match: (XOR x (SLL y z)) 17056 // cond: 17057 // result: (XORshiftLLreg x y z) 17058 for { 17059 _ = v.Args[1] 17060 x := v.Args[0] 17061 v_1 := v.Args[1] 17062 if v_1.Op != OpARMSLL { 17063 break 17064 } 17065 _ = v_1.Args[1] 17066 y := v_1.Args[0] 17067 z := v_1.Args[1] 17068 v.reset(OpARMXORshiftLLreg) 17069 v.AddArg(x) 17070 v.AddArg(y) 17071 v.AddArg(z) 17072 return true 17073 } 17074 // match: (XOR (SLL y z) x) 17075 // cond: 17076 // result: (XORshiftLLreg x y z) 17077 for { 17078 _ = v.Args[1] 17079 v_0 := v.Args[0] 17080 if v_0.Op != OpARMSLL { 17081 break 17082 } 17083 _ = v_0.Args[1] 17084 y := v_0.Args[0] 17085 z := v_0.Args[1] 17086 x := v.Args[1] 17087 v.reset(OpARMXORshiftLLreg) 17088 v.AddArg(x) 17089 v.AddArg(y) 17090 v.AddArg(z) 17091 return true 17092 } 17093 // match: (XOR x (SRL y z)) 17094 // cond: 17095 // result: (XORshiftRLreg x y z) 17096 for { 17097 _ = v.Args[1] 17098 x := v.Args[0] 17099 v_1 := v.Args[1] 17100 if v_1.Op != OpARMSRL { 17101 break 17102 } 17103 _ = v_1.Args[1] 17104 y := v_1.Args[0] 17105 z := v_1.Args[1] 17106 v.reset(OpARMXORshiftRLreg) 17107 v.AddArg(x) 17108 v.AddArg(y) 17109 v.AddArg(z) 17110 return true 17111 } 17112 // match: (XOR (SRL y z) x) 17113 // cond: 17114 // result: (XORshiftRLreg x y z) 17115 for { 17116 _ = v.Args[1] 17117 v_0 := v.Args[0] 17118 if v_0.Op != OpARMSRL { 17119 break 17120 } 17121 _ = v_0.Args[1] 17122 y := v_0.Args[0] 17123 z := v_0.Args[1] 17124 x := v.Args[1] 17125 v.reset(OpARMXORshiftRLreg) 17126 v.AddArg(x) 17127 v.AddArg(y) 17128 v.AddArg(z) 17129 return true 17130 } 17131 // match: (XOR x (SRA y z)) 17132 // cond: 17133 // result: (XORshiftRAreg x y z) 17134 for { 17135 _ = v.Args[1] 17136 x := v.Args[0] 17137 v_1 := v.Args[1] 17138 if v_1.Op != OpARMSRA { 17139 break 17140 } 17141 _ = v_1.Args[1] 17142 y := v_1.Args[0] 17143 z := v_1.Args[1] 17144 v.reset(OpARMXORshiftRAreg) 17145 v.AddArg(x) 17146 v.AddArg(y) 17147 v.AddArg(z) 17148 return true 17149 } 17150 // match: (XOR (SRA y z) x) 17151 // cond: 17152 // result: (XORshiftRAreg x y z) 17153 for { 17154 _ = v.Args[1] 17155 v_0 := v.Args[0] 17156 if v_0.Op != OpARMSRA { 17157 break 17158 } 17159 _ = v_0.Args[1] 17160 y := v_0.Args[0] 17161 z := v_0.Args[1] 17162 x := v.Args[1] 17163 v.reset(OpARMXORshiftRAreg) 17164 v.AddArg(x) 17165 v.AddArg(y) 17166 v.AddArg(z) 17167 return true 17168 } 17169 // match: (XOR x x) 17170 // cond: 17171 // result: (MOVWconst [0]) 17172 for { 17173 _ = v.Args[1] 17174 x := v.Args[0] 17175 if x != v.Args[1] { 17176 break 17177 } 17178 v.reset(OpARMMOVWconst) 17179 v.AuxInt = 0 17180 return true 17181 } 17182 return false 17183 } 17184 func rewriteValueARM_OpARMXORconst_0(v *Value) bool { 17185 // match: (XORconst [0] x) 17186 // cond: 17187 // result: x 17188 for { 17189 if v.AuxInt != 0 { 17190 break 17191 } 17192 x := v.Args[0] 17193 v.reset(OpCopy) 17194 v.Type = x.Type 17195 v.AddArg(x) 17196 return true 17197 } 17198 // match: (XORconst [c] (MOVWconst [d])) 17199 // cond: 17200 // result: (MOVWconst [c^d]) 17201 for { 17202 c := v.AuxInt 17203 v_0 := v.Args[0] 17204 if v_0.Op != OpARMMOVWconst { 17205 break 17206 } 17207 d := v_0.AuxInt 17208 v.reset(OpARMMOVWconst) 17209 v.AuxInt = c ^ d 17210 return true 17211 } 17212 // match: (XORconst [c] (XORconst [d] x)) 17213 // cond: 17214 // result: (XORconst [c^d] x) 17215 for { 17216 c := v.AuxInt 17217 v_0 := v.Args[0] 17218 if v_0.Op != OpARMXORconst { 17219 break 17220 } 17221 d := v_0.AuxInt 17222 x := v_0.Args[0] 17223 v.reset(OpARMXORconst) 17224 v.AuxInt = c ^ d 17225 v.AddArg(x) 17226 return true 17227 } 17228 return false 17229 } 17230 func rewriteValueARM_OpARMXORshiftLL_0(v *Value) bool { 17231 b := v.Block 17232 _ = b 17233 // match: (XORshiftLL (MOVWconst [c]) x [d]) 17234 // cond: 17235 // result: (XORconst [c] (SLLconst <x.Type> x [d])) 17236 for { 17237 d := v.AuxInt 17238 _ = v.Args[1] 17239 v_0 := v.Args[0] 17240 if v_0.Op != OpARMMOVWconst { 17241 break 17242 } 17243 c := v_0.AuxInt 17244 x := v.Args[1] 17245 v.reset(OpARMXORconst) 17246 v.AuxInt = c 17247 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type) 17248 v0.AuxInt = d 17249 v0.AddArg(x) 17250 v.AddArg(v0) 17251 return true 17252 } 17253 // match: (XORshiftLL x (MOVWconst [c]) [d]) 17254 // cond: 17255 // result: (XORconst x [int64(int32(uint32(c)<<uint64(d)))]) 17256 for { 17257 d := v.AuxInt 17258 _ = v.Args[1] 17259 x := v.Args[0] 17260 v_1 := v.Args[1] 17261 if v_1.Op != OpARMMOVWconst { 17262 break 17263 } 17264 c := v_1.AuxInt 17265 v.reset(OpARMXORconst) 17266 v.AuxInt = int64(int32(uint32(c) << uint64(d))) 17267 v.AddArg(x) 17268 return true 17269 } 17270 // match: (XORshiftLL [c] (SRLconst x [32-c]) x) 17271 // cond: 17272 // result: (SRRconst [32-c] x) 17273 for { 17274 c := v.AuxInt 17275 _ = v.Args[1] 17276 v_0 := v.Args[0] 17277 if v_0.Op != OpARMSRLconst { 17278 break 17279 } 17280 if v_0.AuxInt != 32-c { 17281 break 17282 } 17283 x := v_0.Args[0] 17284 if x != v.Args[1] { 17285 break 17286 } 17287 v.reset(OpARMSRRconst) 17288 v.AuxInt = 32 - c 17289 v.AddArg(x) 17290 return true 17291 } 17292 // match: (XORshiftLL x (SLLconst x [c]) [d]) 17293 // cond: c==d 17294 // result: (MOVWconst [0]) 17295 for { 17296 d := v.AuxInt 17297 _ = v.Args[1] 17298 x := v.Args[0] 17299 v_1 := v.Args[1] 17300 if v_1.Op != OpARMSLLconst { 17301 break 17302 } 17303 c := v_1.AuxInt 17304 if x != v_1.Args[0] { 17305 break 17306 } 17307 if !(c == d) { 17308 break 17309 } 17310 v.reset(OpARMMOVWconst) 17311 v.AuxInt = 0 17312 return true 17313 } 17314 return false 17315 } 17316 func rewriteValueARM_OpARMXORshiftLLreg_0(v *Value) bool { 17317 b := v.Block 17318 _ = b 17319 // match: (XORshiftLLreg (MOVWconst [c]) x y) 17320 // cond: 17321 // result: (XORconst [c] (SLL <x.Type> x y)) 17322 for { 17323 _ = v.Args[2] 17324 v_0 := v.Args[0] 17325 if v_0.Op != OpARMMOVWconst { 17326 break 17327 } 17328 c := v_0.AuxInt 17329 x := v.Args[1] 17330 y := v.Args[2] 17331 v.reset(OpARMXORconst) 17332 v.AuxInt = c 17333 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 17334 v0.AddArg(x) 17335 v0.AddArg(y) 17336 v.AddArg(v0) 17337 return true 17338 } 17339 // match: (XORshiftLLreg x y (MOVWconst [c])) 17340 // cond: 17341 // result: (XORshiftLL x y [c]) 17342 for { 17343 _ = v.Args[2] 17344 x := v.Args[0] 17345 y := v.Args[1] 17346 v_2 := v.Args[2] 17347 if v_2.Op != OpARMMOVWconst { 17348 break 17349 } 17350 c := v_2.AuxInt 17351 v.reset(OpARMXORshiftLL) 17352 v.AuxInt = c 17353 v.AddArg(x) 17354 v.AddArg(y) 17355 return true 17356 } 17357 return false 17358 } 17359 func rewriteValueARM_OpARMXORshiftRA_0(v *Value) bool { 17360 b := v.Block 17361 _ = b 17362 // match: (XORshiftRA (MOVWconst [c]) x [d]) 17363 // cond: 17364 // result: (XORconst [c] (SRAconst <x.Type> x [d])) 17365 for { 17366 d := v.AuxInt 17367 _ = v.Args[1] 17368 v_0 := v.Args[0] 17369 if v_0.Op != OpARMMOVWconst { 17370 break 17371 } 17372 c := v_0.AuxInt 17373 x := v.Args[1] 17374 v.reset(OpARMXORconst) 17375 v.AuxInt = c 17376 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type) 17377 v0.AuxInt = d 17378 v0.AddArg(x) 17379 v.AddArg(v0) 17380 return true 17381 } 17382 // match: (XORshiftRA x (MOVWconst [c]) [d]) 17383 // cond: 17384 // result: (XORconst x [int64(int32(c)>>uint64(d))]) 17385 for { 17386 d := v.AuxInt 17387 _ = v.Args[1] 17388 x := v.Args[0] 17389 v_1 := v.Args[1] 17390 if v_1.Op != OpARMMOVWconst { 17391 break 17392 } 17393 c := v_1.AuxInt 17394 v.reset(OpARMXORconst) 17395 v.AuxInt = int64(int32(c) >> uint64(d)) 17396 v.AddArg(x) 17397 return true 17398 } 17399 // match: (XORshiftRA x (SRAconst x [c]) [d]) 17400 // cond: c==d 17401 // result: (MOVWconst [0]) 17402 for { 17403 d := v.AuxInt 17404 _ = v.Args[1] 17405 x := v.Args[0] 17406 v_1 := v.Args[1] 17407 if v_1.Op != OpARMSRAconst { 17408 break 17409 } 17410 c := v_1.AuxInt 17411 if x != v_1.Args[0] { 17412 break 17413 } 17414 if !(c == d) { 17415 break 17416 } 17417 v.reset(OpARMMOVWconst) 17418 v.AuxInt = 0 17419 return true 17420 } 17421 return false 17422 } 17423 func rewriteValueARM_OpARMXORshiftRAreg_0(v *Value) bool { 17424 b := v.Block 17425 _ = b 17426 // match: (XORshiftRAreg (MOVWconst [c]) x y) 17427 // cond: 17428 // result: (XORconst [c] (SRA <x.Type> x y)) 17429 for { 17430 _ = v.Args[2] 17431 v_0 := v.Args[0] 17432 if v_0.Op != OpARMMOVWconst { 17433 break 17434 } 17435 c := v_0.AuxInt 17436 x := v.Args[1] 17437 y := v.Args[2] 17438 v.reset(OpARMXORconst) 17439 v.AuxInt = c 17440 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type) 17441 v0.AddArg(x) 17442 v0.AddArg(y) 17443 v.AddArg(v0) 17444 return true 17445 } 17446 // match: (XORshiftRAreg x y (MOVWconst [c])) 17447 // cond: 17448 // result: (XORshiftRA x y [c]) 17449 for { 17450 _ = v.Args[2] 17451 x := v.Args[0] 17452 y := v.Args[1] 17453 v_2 := v.Args[2] 17454 if v_2.Op != OpARMMOVWconst { 17455 break 17456 } 17457 c := v_2.AuxInt 17458 v.reset(OpARMXORshiftRA) 17459 v.AuxInt = c 17460 v.AddArg(x) 17461 v.AddArg(y) 17462 return true 17463 } 17464 return false 17465 } 17466 func rewriteValueARM_OpARMXORshiftRL_0(v *Value) bool { 17467 b := v.Block 17468 _ = b 17469 // match: (XORshiftRL (MOVWconst [c]) x [d]) 17470 // cond: 17471 // result: (XORconst [c] (SRLconst <x.Type> x [d])) 17472 for { 17473 d := v.AuxInt 17474 _ = v.Args[1] 17475 v_0 := v.Args[0] 17476 if v_0.Op != OpARMMOVWconst { 17477 break 17478 } 17479 c := v_0.AuxInt 17480 x := v.Args[1] 17481 v.reset(OpARMXORconst) 17482 v.AuxInt = c 17483 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type) 17484 v0.AuxInt = d 17485 v0.AddArg(x) 17486 v.AddArg(v0) 17487 return true 17488 } 17489 // match: (XORshiftRL x (MOVWconst [c]) [d]) 17490 // cond: 17491 // result: (XORconst x [int64(int32(uint32(c)>>uint64(d)))]) 17492 for { 17493 d := v.AuxInt 17494 _ = v.Args[1] 17495 x := v.Args[0] 17496 v_1 := v.Args[1] 17497 if v_1.Op != OpARMMOVWconst { 17498 break 17499 } 17500 c := v_1.AuxInt 17501 v.reset(OpARMXORconst) 17502 v.AuxInt = int64(int32(uint32(c) >> uint64(d))) 17503 v.AddArg(x) 17504 return true 17505 } 17506 // match: (XORshiftRL [c] (SLLconst x [32-c]) x) 17507 // cond: 17508 // result: (SRRconst [ c] x) 17509 for { 17510 c := v.AuxInt 17511 _ = v.Args[1] 17512 v_0 := v.Args[0] 17513 if v_0.Op != OpARMSLLconst { 17514 break 17515 } 17516 if v_0.AuxInt != 32-c { 17517 break 17518 } 17519 x := v_0.Args[0] 17520 if x != v.Args[1] { 17521 break 17522 } 17523 v.reset(OpARMSRRconst) 17524 v.AuxInt = c 17525 v.AddArg(x) 17526 return true 17527 } 17528 // match: (XORshiftRL x (SRLconst x [c]) [d]) 17529 // cond: c==d 17530 // result: (MOVWconst [0]) 17531 for { 17532 d := v.AuxInt 17533 _ = v.Args[1] 17534 x := v.Args[0] 17535 v_1 := v.Args[1] 17536 if v_1.Op != OpARMSRLconst { 17537 break 17538 } 17539 c := v_1.AuxInt 17540 if x != v_1.Args[0] { 17541 break 17542 } 17543 if !(c == d) { 17544 break 17545 } 17546 v.reset(OpARMMOVWconst) 17547 v.AuxInt = 0 17548 return true 17549 } 17550 return false 17551 } 17552 func rewriteValueARM_OpARMXORshiftRLreg_0(v *Value) bool { 17553 b := v.Block 17554 _ = b 17555 // match: (XORshiftRLreg (MOVWconst [c]) x y) 17556 // cond: 17557 // result: (XORconst [c] (SRL <x.Type> x y)) 17558 for { 17559 _ = v.Args[2] 17560 v_0 := v.Args[0] 17561 if v_0.Op != OpARMMOVWconst { 17562 break 17563 } 17564 c := v_0.AuxInt 17565 x := v.Args[1] 17566 y := v.Args[2] 17567 v.reset(OpARMXORconst) 17568 v.AuxInt = c 17569 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 17570 v0.AddArg(x) 17571 v0.AddArg(y) 17572 v.AddArg(v0) 17573 return true 17574 } 17575 // match: (XORshiftRLreg x y (MOVWconst [c])) 17576 // cond: 17577 // result: (XORshiftRL x y [c]) 17578 for { 17579 _ = v.Args[2] 17580 x := v.Args[0] 17581 y := v.Args[1] 17582 v_2 := v.Args[2] 17583 if v_2.Op != OpARMMOVWconst { 17584 break 17585 } 17586 c := v_2.AuxInt 17587 v.reset(OpARMXORshiftRL) 17588 v.AuxInt = c 17589 v.AddArg(x) 17590 v.AddArg(y) 17591 return true 17592 } 17593 return false 17594 } 17595 func rewriteValueARM_OpARMXORshiftRR_0(v *Value) bool { 17596 b := v.Block 17597 _ = b 17598 // match: (XORshiftRR (MOVWconst [c]) x [d]) 17599 // cond: 17600 // result: (XORconst [c] (SRRconst <x.Type> x [d])) 17601 for { 17602 d := v.AuxInt 17603 _ = v.Args[1] 17604 v_0 := v.Args[0] 17605 if v_0.Op != OpARMMOVWconst { 17606 break 17607 } 17608 c := v_0.AuxInt 17609 x := v.Args[1] 17610 v.reset(OpARMXORconst) 17611 v.AuxInt = c 17612 v0 := b.NewValue0(v.Pos, OpARMSRRconst, x.Type) 17613 v0.AuxInt = d 17614 v0.AddArg(x) 17615 v.AddArg(v0) 17616 return true 17617 } 17618 // match: (XORshiftRR x (MOVWconst [c]) [d]) 17619 // cond: 17620 // result: (XORconst x [int64(int32(uint32(c)>>uint64(d)|uint32(c)<<uint64(32-d)))]) 17621 for { 17622 d := v.AuxInt 17623 _ = v.Args[1] 17624 x := v.Args[0] 17625 v_1 := v.Args[1] 17626 if v_1.Op != OpARMMOVWconst { 17627 break 17628 } 17629 c := v_1.AuxInt 17630 v.reset(OpARMXORconst) 17631 v.AuxInt = int64(int32(uint32(c)>>uint64(d) | uint32(c)<<uint64(32-d))) 17632 v.AddArg(x) 17633 return true 17634 } 17635 return false 17636 } 17637 func rewriteValueARM_OpAdd16_0(v *Value) bool { 17638 // match: (Add16 x y) 17639 // cond: 17640 // result: (ADD x y) 17641 for { 17642 _ = v.Args[1] 17643 x := v.Args[0] 17644 y := v.Args[1] 17645 v.reset(OpARMADD) 17646 v.AddArg(x) 17647 v.AddArg(y) 17648 return true 17649 } 17650 } 17651 func rewriteValueARM_OpAdd32_0(v *Value) bool { 17652 // match: (Add32 x y) 17653 // cond: 17654 // result: (ADD x y) 17655 for { 17656 _ = v.Args[1] 17657 x := v.Args[0] 17658 y := v.Args[1] 17659 v.reset(OpARMADD) 17660 v.AddArg(x) 17661 v.AddArg(y) 17662 return true 17663 } 17664 } 17665 func rewriteValueARM_OpAdd32F_0(v *Value) bool { 17666 // match: (Add32F x y) 17667 // cond: 17668 // result: (ADDF x y) 17669 for { 17670 _ = v.Args[1] 17671 x := v.Args[0] 17672 y := v.Args[1] 17673 v.reset(OpARMADDF) 17674 v.AddArg(x) 17675 v.AddArg(y) 17676 return true 17677 } 17678 } 17679 func rewriteValueARM_OpAdd32carry_0(v *Value) bool { 17680 // match: (Add32carry x y) 17681 // cond: 17682 // result: (ADDS x y) 17683 for { 17684 _ = v.Args[1] 17685 x := v.Args[0] 17686 y := v.Args[1] 17687 v.reset(OpARMADDS) 17688 v.AddArg(x) 17689 v.AddArg(y) 17690 return true 17691 } 17692 } 17693 func rewriteValueARM_OpAdd32withcarry_0(v *Value) bool { 17694 // match: (Add32withcarry x y c) 17695 // cond: 17696 // result: (ADC x y c) 17697 for { 17698 _ = v.Args[2] 17699 x := v.Args[0] 17700 y := v.Args[1] 17701 c := v.Args[2] 17702 v.reset(OpARMADC) 17703 v.AddArg(x) 17704 v.AddArg(y) 17705 v.AddArg(c) 17706 return true 17707 } 17708 } 17709 func rewriteValueARM_OpAdd64F_0(v *Value) bool { 17710 // match: (Add64F x y) 17711 // cond: 17712 // result: (ADDD x y) 17713 for { 17714 _ = v.Args[1] 17715 x := v.Args[0] 17716 y := v.Args[1] 17717 v.reset(OpARMADDD) 17718 v.AddArg(x) 17719 v.AddArg(y) 17720 return true 17721 } 17722 } 17723 func rewriteValueARM_OpAdd8_0(v *Value) bool { 17724 // match: (Add8 x y) 17725 // cond: 17726 // result: (ADD x y) 17727 for { 17728 _ = v.Args[1] 17729 x := v.Args[0] 17730 y := v.Args[1] 17731 v.reset(OpARMADD) 17732 v.AddArg(x) 17733 v.AddArg(y) 17734 return true 17735 } 17736 } 17737 func rewriteValueARM_OpAddPtr_0(v *Value) bool { 17738 // match: (AddPtr x y) 17739 // cond: 17740 // result: (ADD x y) 17741 for { 17742 _ = v.Args[1] 17743 x := v.Args[0] 17744 y := v.Args[1] 17745 v.reset(OpARMADD) 17746 v.AddArg(x) 17747 v.AddArg(y) 17748 return true 17749 } 17750 } 17751 func rewriteValueARM_OpAddr_0(v *Value) bool { 17752 // match: (Addr {sym} base) 17753 // cond: 17754 // result: (MOVWaddr {sym} base) 17755 for { 17756 sym := v.Aux 17757 base := v.Args[0] 17758 v.reset(OpARMMOVWaddr) 17759 v.Aux = sym 17760 v.AddArg(base) 17761 return true 17762 } 17763 } 17764 func rewriteValueARM_OpAnd16_0(v *Value) bool { 17765 // match: (And16 x y) 17766 // cond: 17767 // result: (AND x y) 17768 for { 17769 _ = v.Args[1] 17770 x := v.Args[0] 17771 y := v.Args[1] 17772 v.reset(OpARMAND) 17773 v.AddArg(x) 17774 v.AddArg(y) 17775 return true 17776 } 17777 } 17778 func rewriteValueARM_OpAnd32_0(v *Value) bool { 17779 // match: (And32 x y) 17780 // cond: 17781 // result: (AND x y) 17782 for { 17783 _ = v.Args[1] 17784 x := v.Args[0] 17785 y := v.Args[1] 17786 v.reset(OpARMAND) 17787 v.AddArg(x) 17788 v.AddArg(y) 17789 return true 17790 } 17791 } 17792 func rewriteValueARM_OpAnd8_0(v *Value) bool { 17793 // match: (And8 x y) 17794 // cond: 17795 // result: (AND x y) 17796 for { 17797 _ = v.Args[1] 17798 x := v.Args[0] 17799 y := v.Args[1] 17800 v.reset(OpARMAND) 17801 v.AddArg(x) 17802 v.AddArg(y) 17803 return true 17804 } 17805 } 17806 func rewriteValueARM_OpAndB_0(v *Value) bool { 17807 // match: (AndB x y) 17808 // cond: 17809 // result: (AND x y) 17810 for { 17811 _ = v.Args[1] 17812 x := v.Args[0] 17813 y := v.Args[1] 17814 v.reset(OpARMAND) 17815 v.AddArg(x) 17816 v.AddArg(y) 17817 return true 17818 } 17819 } 17820 func rewriteValueARM_OpAvg32u_0(v *Value) bool { 17821 b := v.Block 17822 _ = b 17823 // match: (Avg32u <t> x y) 17824 // cond: 17825 // result: (ADD (SRLconst <t> (SUB <t> x y) [1]) y) 17826 for { 17827 t := v.Type 17828 _ = v.Args[1] 17829 x := v.Args[0] 17830 y := v.Args[1] 17831 v.reset(OpARMADD) 17832 v0 := b.NewValue0(v.Pos, OpARMSRLconst, t) 17833 v0.AuxInt = 1 17834 v1 := b.NewValue0(v.Pos, OpARMSUB, t) 17835 v1.AddArg(x) 17836 v1.AddArg(y) 17837 v0.AddArg(v1) 17838 v.AddArg(v0) 17839 v.AddArg(y) 17840 return true 17841 } 17842 } 17843 func rewriteValueARM_OpBitLen32_0(v *Value) bool { 17844 b := v.Block 17845 _ = b 17846 // match: (BitLen32 <t> x) 17847 // cond: 17848 // result: (RSBconst [32] (CLZ <t> x)) 17849 for { 17850 t := v.Type 17851 x := v.Args[0] 17852 v.reset(OpARMRSBconst) 17853 v.AuxInt = 32 17854 v0 := b.NewValue0(v.Pos, OpARMCLZ, t) 17855 v0.AddArg(x) 17856 v.AddArg(v0) 17857 return true 17858 } 17859 } 17860 func rewriteValueARM_OpBswap32_0(v *Value) bool { 17861 b := v.Block 17862 _ = b 17863 // match: (Bswap32 <t> x) 17864 // cond: objabi.GOARM==5 17865 // result: (XOR <t> (SRLconst <t> (BICconst <t> (XOR <t> x (SRRconst <t> [16] x)) [0xff0000]) [8]) (SRRconst <t> x [8])) 17866 for { 17867 t := v.Type 17868 x := v.Args[0] 17869 if !(objabi.GOARM == 5) { 17870 break 17871 } 17872 v.reset(OpARMXOR) 17873 v.Type = t 17874 v0 := b.NewValue0(v.Pos, OpARMSRLconst, t) 17875 v0.AuxInt = 8 17876 v1 := b.NewValue0(v.Pos, OpARMBICconst, t) 17877 v1.AuxInt = 0xff0000 17878 v2 := b.NewValue0(v.Pos, OpARMXOR, t) 17879 v2.AddArg(x) 17880 v3 := b.NewValue0(v.Pos, OpARMSRRconst, t) 17881 v3.AuxInt = 16 17882 v3.AddArg(x) 17883 v2.AddArg(v3) 17884 v1.AddArg(v2) 17885 v0.AddArg(v1) 17886 v.AddArg(v0) 17887 v4 := b.NewValue0(v.Pos, OpARMSRRconst, t) 17888 v4.AuxInt = 8 17889 v4.AddArg(x) 17890 v.AddArg(v4) 17891 return true 17892 } 17893 // match: (Bswap32 x) 17894 // cond: objabi.GOARM>=6 17895 // result: (REV x) 17896 for { 17897 x := v.Args[0] 17898 if !(objabi.GOARM >= 6) { 17899 break 17900 } 17901 v.reset(OpARMREV) 17902 v.AddArg(x) 17903 return true 17904 } 17905 return false 17906 } 17907 func rewriteValueARM_OpClosureCall_0(v *Value) bool { 17908 // match: (ClosureCall [argwid] entry closure mem) 17909 // cond: 17910 // result: (CALLclosure [argwid] entry closure mem) 17911 for { 17912 argwid := v.AuxInt 17913 _ = v.Args[2] 17914 entry := v.Args[0] 17915 closure := v.Args[1] 17916 mem := v.Args[2] 17917 v.reset(OpARMCALLclosure) 17918 v.AuxInt = argwid 17919 v.AddArg(entry) 17920 v.AddArg(closure) 17921 v.AddArg(mem) 17922 return true 17923 } 17924 } 17925 func rewriteValueARM_OpCom16_0(v *Value) bool { 17926 // match: (Com16 x) 17927 // cond: 17928 // result: (MVN x) 17929 for { 17930 x := v.Args[0] 17931 v.reset(OpARMMVN) 17932 v.AddArg(x) 17933 return true 17934 } 17935 } 17936 func rewriteValueARM_OpCom32_0(v *Value) bool { 17937 // match: (Com32 x) 17938 // cond: 17939 // result: (MVN x) 17940 for { 17941 x := v.Args[0] 17942 v.reset(OpARMMVN) 17943 v.AddArg(x) 17944 return true 17945 } 17946 } 17947 func rewriteValueARM_OpCom8_0(v *Value) bool { 17948 // match: (Com8 x) 17949 // cond: 17950 // result: (MVN x) 17951 for { 17952 x := v.Args[0] 17953 v.reset(OpARMMVN) 17954 v.AddArg(x) 17955 return true 17956 } 17957 } 17958 func rewriteValueARM_OpConst16_0(v *Value) bool { 17959 // match: (Const16 [val]) 17960 // cond: 17961 // result: (MOVWconst [val]) 17962 for { 17963 val := v.AuxInt 17964 v.reset(OpARMMOVWconst) 17965 v.AuxInt = val 17966 return true 17967 } 17968 } 17969 func rewriteValueARM_OpConst32_0(v *Value) bool { 17970 // match: (Const32 [val]) 17971 // cond: 17972 // result: (MOVWconst [val]) 17973 for { 17974 val := v.AuxInt 17975 v.reset(OpARMMOVWconst) 17976 v.AuxInt = val 17977 return true 17978 } 17979 } 17980 func rewriteValueARM_OpConst32F_0(v *Value) bool { 17981 // match: (Const32F [val]) 17982 // cond: 17983 // result: (MOVFconst [val]) 17984 for { 17985 val := v.AuxInt 17986 v.reset(OpARMMOVFconst) 17987 v.AuxInt = val 17988 return true 17989 } 17990 } 17991 func rewriteValueARM_OpConst64F_0(v *Value) bool { 17992 // match: (Const64F [val]) 17993 // cond: 17994 // result: (MOVDconst [val]) 17995 for { 17996 val := v.AuxInt 17997 v.reset(OpARMMOVDconst) 17998 v.AuxInt = val 17999 return true 18000 } 18001 } 18002 func rewriteValueARM_OpConst8_0(v *Value) bool { 18003 // match: (Const8 [val]) 18004 // cond: 18005 // result: (MOVWconst [val]) 18006 for { 18007 val := v.AuxInt 18008 v.reset(OpARMMOVWconst) 18009 v.AuxInt = val 18010 return true 18011 } 18012 } 18013 func rewriteValueARM_OpConstBool_0(v *Value) bool { 18014 // match: (ConstBool [b]) 18015 // cond: 18016 // result: (MOVWconst [b]) 18017 for { 18018 b := v.AuxInt 18019 v.reset(OpARMMOVWconst) 18020 v.AuxInt = b 18021 return true 18022 } 18023 } 18024 func rewriteValueARM_OpConstNil_0(v *Value) bool { 18025 // match: (ConstNil) 18026 // cond: 18027 // result: (MOVWconst [0]) 18028 for { 18029 v.reset(OpARMMOVWconst) 18030 v.AuxInt = 0 18031 return true 18032 } 18033 } 18034 func rewriteValueARM_OpCtz32_0(v *Value) bool { 18035 b := v.Block 18036 _ = b 18037 // match: (Ctz32 <t> x) 18038 // cond: objabi.GOARM<=6 18039 // result: (RSBconst [32] (CLZ <t> (SUBconst <t> (AND <t> x (RSBconst <t> [0] x)) [1]))) 18040 for { 18041 t := v.Type 18042 x := v.Args[0] 18043 if !(objabi.GOARM <= 6) { 18044 break 18045 } 18046 v.reset(OpARMRSBconst) 18047 v.AuxInt = 32 18048 v0 := b.NewValue0(v.Pos, OpARMCLZ, t) 18049 v1 := b.NewValue0(v.Pos, OpARMSUBconst, t) 18050 v1.AuxInt = 1 18051 v2 := b.NewValue0(v.Pos, OpARMAND, t) 18052 v2.AddArg(x) 18053 v3 := b.NewValue0(v.Pos, OpARMRSBconst, t) 18054 v3.AuxInt = 0 18055 v3.AddArg(x) 18056 v2.AddArg(v3) 18057 v1.AddArg(v2) 18058 v0.AddArg(v1) 18059 v.AddArg(v0) 18060 return true 18061 } 18062 // match: (Ctz32 <t> x) 18063 // cond: objabi.GOARM==7 18064 // result: (CLZ <t> (RBIT <t> x)) 18065 for { 18066 t := v.Type 18067 x := v.Args[0] 18068 if !(objabi.GOARM == 7) { 18069 break 18070 } 18071 v.reset(OpARMCLZ) 18072 v.Type = t 18073 v0 := b.NewValue0(v.Pos, OpARMRBIT, t) 18074 v0.AddArg(x) 18075 v.AddArg(v0) 18076 return true 18077 } 18078 return false 18079 } 18080 func rewriteValueARM_OpCtz32NonZero_0(v *Value) bool { 18081 // match: (Ctz32NonZero x) 18082 // cond: 18083 // result: (Ctz32 x) 18084 for { 18085 x := v.Args[0] 18086 v.reset(OpCtz32) 18087 v.AddArg(x) 18088 return true 18089 } 18090 } 18091 func rewriteValueARM_OpCvt32Fto32_0(v *Value) bool { 18092 // match: (Cvt32Fto32 x) 18093 // cond: 18094 // result: (MOVFW x) 18095 for { 18096 x := v.Args[0] 18097 v.reset(OpARMMOVFW) 18098 v.AddArg(x) 18099 return true 18100 } 18101 } 18102 func rewriteValueARM_OpCvt32Fto32U_0(v *Value) bool { 18103 // match: (Cvt32Fto32U x) 18104 // cond: 18105 // result: (MOVFWU x) 18106 for { 18107 x := v.Args[0] 18108 v.reset(OpARMMOVFWU) 18109 v.AddArg(x) 18110 return true 18111 } 18112 } 18113 func rewriteValueARM_OpCvt32Fto64F_0(v *Value) bool { 18114 // match: (Cvt32Fto64F x) 18115 // cond: 18116 // result: (MOVFD x) 18117 for { 18118 x := v.Args[0] 18119 v.reset(OpARMMOVFD) 18120 v.AddArg(x) 18121 return true 18122 } 18123 } 18124 func rewriteValueARM_OpCvt32Uto32F_0(v *Value) bool { 18125 // match: (Cvt32Uto32F x) 18126 // cond: 18127 // result: (MOVWUF x) 18128 for { 18129 x := v.Args[0] 18130 v.reset(OpARMMOVWUF) 18131 v.AddArg(x) 18132 return true 18133 } 18134 } 18135 func rewriteValueARM_OpCvt32Uto64F_0(v *Value) bool { 18136 // match: (Cvt32Uto64F x) 18137 // cond: 18138 // result: (MOVWUD x) 18139 for { 18140 x := v.Args[0] 18141 v.reset(OpARMMOVWUD) 18142 v.AddArg(x) 18143 return true 18144 } 18145 } 18146 func rewriteValueARM_OpCvt32to32F_0(v *Value) bool { 18147 // match: (Cvt32to32F x) 18148 // cond: 18149 // result: (MOVWF x) 18150 for { 18151 x := v.Args[0] 18152 v.reset(OpARMMOVWF) 18153 v.AddArg(x) 18154 return true 18155 } 18156 } 18157 func rewriteValueARM_OpCvt32to64F_0(v *Value) bool { 18158 // match: (Cvt32to64F x) 18159 // cond: 18160 // result: (MOVWD x) 18161 for { 18162 x := v.Args[0] 18163 v.reset(OpARMMOVWD) 18164 v.AddArg(x) 18165 return true 18166 } 18167 } 18168 func rewriteValueARM_OpCvt64Fto32_0(v *Value) bool { 18169 // match: (Cvt64Fto32 x) 18170 // cond: 18171 // result: (MOVDW x) 18172 for { 18173 x := v.Args[0] 18174 v.reset(OpARMMOVDW) 18175 v.AddArg(x) 18176 return true 18177 } 18178 } 18179 func rewriteValueARM_OpCvt64Fto32F_0(v *Value) bool { 18180 // match: (Cvt64Fto32F x) 18181 // cond: 18182 // result: (MOVDF x) 18183 for { 18184 x := v.Args[0] 18185 v.reset(OpARMMOVDF) 18186 v.AddArg(x) 18187 return true 18188 } 18189 } 18190 func rewriteValueARM_OpCvt64Fto32U_0(v *Value) bool { 18191 // match: (Cvt64Fto32U x) 18192 // cond: 18193 // result: (MOVDWU x) 18194 for { 18195 x := v.Args[0] 18196 v.reset(OpARMMOVDWU) 18197 v.AddArg(x) 18198 return true 18199 } 18200 } 18201 func rewriteValueARM_OpDiv16_0(v *Value) bool { 18202 b := v.Block 18203 _ = b 18204 typ := &b.Func.Config.Types 18205 _ = typ 18206 // match: (Div16 x y) 18207 // cond: 18208 // result: (Div32 (SignExt16to32 x) (SignExt16to32 y)) 18209 for { 18210 _ = v.Args[1] 18211 x := v.Args[0] 18212 y := v.Args[1] 18213 v.reset(OpDiv32) 18214 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 18215 v0.AddArg(x) 18216 v.AddArg(v0) 18217 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 18218 v1.AddArg(y) 18219 v.AddArg(v1) 18220 return true 18221 } 18222 } 18223 func rewriteValueARM_OpDiv16u_0(v *Value) bool { 18224 b := v.Block 18225 _ = b 18226 typ := &b.Func.Config.Types 18227 _ = typ 18228 // match: (Div16u x y) 18229 // cond: 18230 // result: (Div32u (ZeroExt16to32 x) (ZeroExt16to32 y)) 18231 for { 18232 _ = v.Args[1] 18233 x := v.Args[0] 18234 y := v.Args[1] 18235 v.reset(OpDiv32u) 18236 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18237 v0.AddArg(x) 18238 v.AddArg(v0) 18239 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18240 v1.AddArg(y) 18241 v.AddArg(v1) 18242 return true 18243 } 18244 } 18245 func rewriteValueARM_OpDiv32_0(v *Value) bool { 18246 b := v.Block 18247 _ = b 18248 typ := &b.Func.Config.Types 18249 _ = typ 18250 // match: (Div32 x y) 18251 // cond: 18252 // 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))) 18253 for { 18254 _ = v.Args[1] 18255 x := v.Args[0] 18256 y := v.Args[1] 18257 v.reset(OpARMSUB) 18258 v0 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32) 18259 v1 := b.NewValue0(v.Pos, OpSelect0, typ.UInt32) 18260 v2 := b.NewValue0(v.Pos, OpARMCALLudiv, types.NewTuple(typ.UInt32, typ.UInt32)) 18261 v3 := b.NewValue0(v.Pos, OpARMSUB, typ.UInt32) 18262 v4 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32) 18263 v4.AddArg(x) 18264 v5 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 18265 v5.AddArg(x) 18266 v4.AddArg(v5) 18267 v3.AddArg(v4) 18268 v6 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 18269 v6.AddArg(x) 18270 v3.AddArg(v6) 18271 v2.AddArg(v3) 18272 v7 := b.NewValue0(v.Pos, OpARMSUB, typ.UInt32) 18273 v8 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32) 18274 v8.AddArg(y) 18275 v9 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 18276 v9.AddArg(y) 18277 v8.AddArg(v9) 18278 v7.AddArg(v8) 18279 v10 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 18280 v10.AddArg(y) 18281 v7.AddArg(v10) 18282 v2.AddArg(v7) 18283 v1.AddArg(v2) 18284 v0.AddArg(v1) 18285 v11 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 18286 v12 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32) 18287 v12.AddArg(x) 18288 v12.AddArg(y) 18289 v11.AddArg(v12) 18290 v0.AddArg(v11) 18291 v.AddArg(v0) 18292 v13 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 18293 v14 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32) 18294 v14.AddArg(x) 18295 v14.AddArg(y) 18296 v13.AddArg(v14) 18297 v.AddArg(v13) 18298 return true 18299 } 18300 } 18301 func rewriteValueARM_OpDiv32F_0(v *Value) bool { 18302 // match: (Div32F x y) 18303 // cond: 18304 // result: (DIVF x y) 18305 for { 18306 _ = v.Args[1] 18307 x := v.Args[0] 18308 y := v.Args[1] 18309 v.reset(OpARMDIVF) 18310 v.AddArg(x) 18311 v.AddArg(y) 18312 return true 18313 } 18314 } 18315 func rewriteValueARM_OpDiv32u_0(v *Value) bool { 18316 b := v.Block 18317 _ = b 18318 typ := &b.Func.Config.Types 18319 _ = typ 18320 // match: (Div32u x y) 18321 // cond: 18322 // result: (Select0 <typ.UInt32> (CALLudiv x y)) 18323 for { 18324 _ = v.Args[1] 18325 x := v.Args[0] 18326 y := v.Args[1] 18327 v.reset(OpSelect0) 18328 v.Type = typ.UInt32 18329 v0 := b.NewValue0(v.Pos, OpARMCALLudiv, types.NewTuple(typ.UInt32, typ.UInt32)) 18330 v0.AddArg(x) 18331 v0.AddArg(y) 18332 v.AddArg(v0) 18333 return true 18334 } 18335 } 18336 func rewriteValueARM_OpDiv64F_0(v *Value) bool { 18337 // match: (Div64F x y) 18338 // cond: 18339 // result: (DIVD x y) 18340 for { 18341 _ = v.Args[1] 18342 x := v.Args[0] 18343 y := v.Args[1] 18344 v.reset(OpARMDIVD) 18345 v.AddArg(x) 18346 v.AddArg(y) 18347 return true 18348 } 18349 } 18350 func rewriteValueARM_OpDiv8_0(v *Value) bool { 18351 b := v.Block 18352 _ = b 18353 typ := &b.Func.Config.Types 18354 _ = typ 18355 // match: (Div8 x y) 18356 // cond: 18357 // result: (Div32 (SignExt8to32 x) (SignExt8to32 y)) 18358 for { 18359 _ = v.Args[1] 18360 x := v.Args[0] 18361 y := v.Args[1] 18362 v.reset(OpDiv32) 18363 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 18364 v0.AddArg(x) 18365 v.AddArg(v0) 18366 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 18367 v1.AddArg(y) 18368 v.AddArg(v1) 18369 return true 18370 } 18371 } 18372 func rewriteValueARM_OpDiv8u_0(v *Value) bool { 18373 b := v.Block 18374 _ = b 18375 typ := &b.Func.Config.Types 18376 _ = typ 18377 // match: (Div8u x y) 18378 // cond: 18379 // result: (Div32u (ZeroExt8to32 x) (ZeroExt8to32 y)) 18380 for { 18381 _ = v.Args[1] 18382 x := v.Args[0] 18383 y := v.Args[1] 18384 v.reset(OpDiv32u) 18385 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 18386 v0.AddArg(x) 18387 v.AddArg(v0) 18388 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 18389 v1.AddArg(y) 18390 v.AddArg(v1) 18391 return true 18392 } 18393 } 18394 func rewriteValueARM_OpEq16_0(v *Value) bool { 18395 b := v.Block 18396 _ = b 18397 typ := &b.Func.Config.Types 18398 _ = typ 18399 // match: (Eq16 x y) 18400 // cond: 18401 // result: (Equal (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 18402 for { 18403 _ = v.Args[1] 18404 x := v.Args[0] 18405 y := v.Args[1] 18406 v.reset(OpARMEqual) 18407 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18408 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18409 v1.AddArg(x) 18410 v0.AddArg(v1) 18411 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18412 v2.AddArg(y) 18413 v0.AddArg(v2) 18414 v.AddArg(v0) 18415 return true 18416 } 18417 } 18418 func rewriteValueARM_OpEq32_0(v *Value) bool { 18419 b := v.Block 18420 _ = b 18421 // match: (Eq32 x y) 18422 // cond: 18423 // result: (Equal (CMP x y)) 18424 for { 18425 _ = v.Args[1] 18426 x := v.Args[0] 18427 y := v.Args[1] 18428 v.reset(OpARMEqual) 18429 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18430 v0.AddArg(x) 18431 v0.AddArg(y) 18432 v.AddArg(v0) 18433 return true 18434 } 18435 } 18436 func rewriteValueARM_OpEq32F_0(v *Value) bool { 18437 b := v.Block 18438 _ = b 18439 // match: (Eq32F x y) 18440 // cond: 18441 // result: (Equal (CMPF x y)) 18442 for { 18443 _ = v.Args[1] 18444 x := v.Args[0] 18445 y := v.Args[1] 18446 v.reset(OpARMEqual) 18447 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags) 18448 v0.AddArg(x) 18449 v0.AddArg(y) 18450 v.AddArg(v0) 18451 return true 18452 } 18453 } 18454 func rewriteValueARM_OpEq64F_0(v *Value) bool { 18455 b := v.Block 18456 _ = b 18457 // match: (Eq64F x y) 18458 // cond: 18459 // result: (Equal (CMPD x y)) 18460 for { 18461 _ = v.Args[1] 18462 x := v.Args[0] 18463 y := v.Args[1] 18464 v.reset(OpARMEqual) 18465 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags) 18466 v0.AddArg(x) 18467 v0.AddArg(y) 18468 v.AddArg(v0) 18469 return true 18470 } 18471 } 18472 func rewriteValueARM_OpEq8_0(v *Value) bool { 18473 b := v.Block 18474 _ = b 18475 typ := &b.Func.Config.Types 18476 _ = typ 18477 // match: (Eq8 x y) 18478 // cond: 18479 // result: (Equal (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 18480 for { 18481 _ = v.Args[1] 18482 x := v.Args[0] 18483 y := v.Args[1] 18484 v.reset(OpARMEqual) 18485 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18486 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 18487 v1.AddArg(x) 18488 v0.AddArg(v1) 18489 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 18490 v2.AddArg(y) 18491 v0.AddArg(v2) 18492 v.AddArg(v0) 18493 return true 18494 } 18495 } 18496 func rewriteValueARM_OpEqB_0(v *Value) bool { 18497 b := v.Block 18498 _ = b 18499 typ := &b.Func.Config.Types 18500 _ = typ 18501 // match: (EqB x y) 18502 // cond: 18503 // result: (XORconst [1] (XOR <typ.Bool> x y)) 18504 for { 18505 _ = v.Args[1] 18506 x := v.Args[0] 18507 y := v.Args[1] 18508 v.reset(OpARMXORconst) 18509 v.AuxInt = 1 18510 v0 := b.NewValue0(v.Pos, OpARMXOR, typ.Bool) 18511 v0.AddArg(x) 18512 v0.AddArg(y) 18513 v.AddArg(v0) 18514 return true 18515 } 18516 } 18517 func rewriteValueARM_OpEqPtr_0(v *Value) bool { 18518 b := v.Block 18519 _ = b 18520 // match: (EqPtr x y) 18521 // cond: 18522 // result: (Equal (CMP x y)) 18523 for { 18524 _ = v.Args[1] 18525 x := v.Args[0] 18526 y := v.Args[1] 18527 v.reset(OpARMEqual) 18528 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18529 v0.AddArg(x) 18530 v0.AddArg(y) 18531 v.AddArg(v0) 18532 return true 18533 } 18534 } 18535 func rewriteValueARM_OpGeq16_0(v *Value) bool { 18536 b := v.Block 18537 _ = b 18538 typ := &b.Func.Config.Types 18539 _ = typ 18540 // match: (Geq16 x y) 18541 // cond: 18542 // result: (GreaterEqual (CMP (SignExt16to32 x) (SignExt16to32 y))) 18543 for { 18544 _ = v.Args[1] 18545 x := v.Args[0] 18546 y := v.Args[1] 18547 v.reset(OpARMGreaterEqual) 18548 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18549 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 18550 v1.AddArg(x) 18551 v0.AddArg(v1) 18552 v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 18553 v2.AddArg(y) 18554 v0.AddArg(v2) 18555 v.AddArg(v0) 18556 return true 18557 } 18558 } 18559 func rewriteValueARM_OpGeq16U_0(v *Value) bool { 18560 b := v.Block 18561 _ = b 18562 typ := &b.Func.Config.Types 18563 _ = typ 18564 // match: (Geq16U x y) 18565 // cond: 18566 // result: (GreaterEqualU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 18567 for { 18568 _ = v.Args[1] 18569 x := v.Args[0] 18570 y := v.Args[1] 18571 v.reset(OpARMGreaterEqualU) 18572 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18573 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18574 v1.AddArg(x) 18575 v0.AddArg(v1) 18576 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18577 v2.AddArg(y) 18578 v0.AddArg(v2) 18579 v.AddArg(v0) 18580 return true 18581 } 18582 } 18583 func rewriteValueARM_OpGeq32_0(v *Value) bool { 18584 b := v.Block 18585 _ = b 18586 // match: (Geq32 x y) 18587 // cond: 18588 // result: (GreaterEqual (CMP x y)) 18589 for { 18590 _ = v.Args[1] 18591 x := v.Args[0] 18592 y := v.Args[1] 18593 v.reset(OpARMGreaterEqual) 18594 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18595 v0.AddArg(x) 18596 v0.AddArg(y) 18597 v.AddArg(v0) 18598 return true 18599 } 18600 } 18601 func rewriteValueARM_OpGeq32F_0(v *Value) bool { 18602 b := v.Block 18603 _ = b 18604 // match: (Geq32F x y) 18605 // cond: 18606 // result: (GreaterEqual (CMPF x y)) 18607 for { 18608 _ = v.Args[1] 18609 x := v.Args[0] 18610 y := v.Args[1] 18611 v.reset(OpARMGreaterEqual) 18612 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags) 18613 v0.AddArg(x) 18614 v0.AddArg(y) 18615 v.AddArg(v0) 18616 return true 18617 } 18618 } 18619 func rewriteValueARM_OpGeq32U_0(v *Value) bool { 18620 b := v.Block 18621 _ = b 18622 // match: (Geq32U x y) 18623 // cond: 18624 // result: (GreaterEqualU (CMP x y)) 18625 for { 18626 _ = v.Args[1] 18627 x := v.Args[0] 18628 y := v.Args[1] 18629 v.reset(OpARMGreaterEqualU) 18630 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18631 v0.AddArg(x) 18632 v0.AddArg(y) 18633 v.AddArg(v0) 18634 return true 18635 } 18636 } 18637 func rewriteValueARM_OpGeq64F_0(v *Value) bool { 18638 b := v.Block 18639 _ = b 18640 // match: (Geq64F x y) 18641 // cond: 18642 // result: (GreaterEqual (CMPD x y)) 18643 for { 18644 _ = v.Args[1] 18645 x := v.Args[0] 18646 y := v.Args[1] 18647 v.reset(OpARMGreaterEqual) 18648 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags) 18649 v0.AddArg(x) 18650 v0.AddArg(y) 18651 v.AddArg(v0) 18652 return true 18653 } 18654 } 18655 func rewriteValueARM_OpGeq8_0(v *Value) bool { 18656 b := v.Block 18657 _ = b 18658 typ := &b.Func.Config.Types 18659 _ = typ 18660 // match: (Geq8 x y) 18661 // cond: 18662 // result: (GreaterEqual (CMP (SignExt8to32 x) (SignExt8to32 y))) 18663 for { 18664 _ = v.Args[1] 18665 x := v.Args[0] 18666 y := v.Args[1] 18667 v.reset(OpARMGreaterEqual) 18668 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18669 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 18670 v1.AddArg(x) 18671 v0.AddArg(v1) 18672 v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 18673 v2.AddArg(y) 18674 v0.AddArg(v2) 18675 v.AddArg(v0) 18676 return true 18677 } 18678 } 18679 func rewriteValueARM_OpGeq8U_0(v *Value) bool { 18680 b := v.Block 18681 _ = b 18682 typ := &b.Func.Config.Types 18683 _ = typ 18684 // match: (Geq8U x y) 18685 // cond: 18686 // result: (GreaterEqualU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 18687 for { 18688 _ = v.Args[1] 18689 x := v.Args[0] 18690 y := v.Args[1] 18691 v.reset(OpARMGreaterEqualU) 18692 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18693 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 18694 v1.AddArg(x) 18695 v0.AddArg(v1) 18696 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 18697 v2.AddArg(y) 18698 v0.AddArg(v2) 18699 v.AddArg(v0) 18700 return true 18701 } 18702 } 18703 func rewriteValueARM_OpGetCallerPC_0(v *Value) bool { 18704 // match: (GetCallerPC) 18705 // cond: 18706 // result: (LoweredGetCallerPC) 18707 for { 18708 v.reset(OpARMLoweredGetCallerPC) 18709 return true 18710 } 18711 } 18712 func rewriteValueARM_OpGetCallerSP_0(v *Value) bool { 18713 // match: (GetCallerSP) 18714 // cond: 18715 // result: (LoweredGetCallerSP) 18716 for { 18717 v.reset(OpARMLoweredGetCallerSP) 18718 return true 18719 } 18720 } 18721 func rewriteValueARM_OpGetClosurePtr_0(v *Value) bool { 18722 // match: (GetClosurePtr) 18723 // cond: 18724 // result: (LoweredGetClosurePtr) 18725 for { 18726 v.reset(OpARMLoweredGetClosurePtr) 18727 return true 18728 } 18729 } 18730 func rewriteValueARM_OpGreater16_0(v *Value) bool { 18731 b := v.Block 18732 _ = b 18733 typ := &b.Func.Config.Types 18734 _ = typ 18735 // match: (Greater16 x y) 18736 // cond: 18737 // result: (GreaterThan (CMP (SignExt16to32 x) (SignExt16to32 y))) 18738 for { 18739 _ = v.Args[1] 18740 x := v.Args[0] 18741 y := v.Args[1] 18742 v.reset(OpARMGreaterThan) 18743 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18744 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 18745 v1.AddArg(x) 18746 v0.AddArg(v1) 18747 v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 18748 v2.AddArg(y) 18749 v0.AddArg(v2) 18750 v.AddArg(v0) 18751 return true 18752 } 18753 } 18754 func rewriteValueARM_OpGreater16U_0(v *Value) bool { 18755 b := v.Block 18756 _ = b 18757 typ := &b.Func.Config.Types 18758 _ = typ 18759 // match: (Greater16U x y) 18760 // cond: 18761 // result: (GreaterThanU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 18762 for { 18763 _ = v.Args[1] 18764 x := v.Args[0] 18765 y := v.Args[1] 18766 v.reset(OpARMGreaterThanU) 18767 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18768 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18769 v1.AddArg(x) 18770 v0.AddArg(v1) 18771 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 18772 v2.AddArg(y) 18773 v0.AddArg(v2) 18774 v.AddArg(v0) 18775 return true 18776 } 18777 } 18778 func rewriteValueARM_OpGreater32_0(v *Value) bool { 18779 b := v.Block 18780 _ = b 18781 // match: (Greater32 x y) 18782 // cond: 18783 // result: (GreaterThan (CMP x y)) 18784 for { 18785 _ = v.Args[1] 18786 x := v.Args[0] 18787 y := v.Args[1] 18788 v.reset(OpARMGreaterThan) 18789 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18790 v0.AddArg(x) 18791 v0.AddArg(y) 18792 v.AddArg(v0) 18793 return true 18794 } 18795 } 18796 func rewriteValueARM_OpGreater32F_0(v *Value) bool { 18797 b := v.Block 18798 _ = b 18799 // match: (Greater32F x y) 18800 // cond: 18801 // result: (GreaterThan (CMPF x y)) 18802 for { 18803 _ = v.Args[1] 18804 x := v.Args[0] 18805 y := v.Args[1] 18806 v.reset(OpARMGreaterThan) 18807 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags) 18808 v0.AddArg(x) 18809 v0.AddArg(y) 18810 v.AddArg(v0) 18811 return true 18812 } 18813 } 18814 func rewriteValueARM_OpGreater32U_0(v *Value) bool { 18815 b := v.Block 18816 _ = b 18817 // match: (Greater32U x y) 18818 // cond: 18819 // result: (GreaterThanU (CMP x y)) 18820 for { 18821 _ = v.Args[1] 18822 x := v.Args[0] 18823 y := v.Args[1] 18824 v.reset(OpARMGreaterThanU) 18825 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18826 v0.AddArg(x) 18827 v0.AddArg(y) 18828 v.AddArg(v0) 18829 return true 18830 } 18831 } 18832 func rewriteValueARM_OpGreater64F_0(v *Value) bool { 18833 b := v.Block 18834 _ = b 18835 // match: (Greater64F x y) 18836 // cond: 18837 // result: (GreaterThan (CMPD x y)) 18838 for { 18839 _ = v.Args[1] 18840 x := v.Args[0] 18841 y := v.Args[1] 18842 v.reset(OpARMGreaterThan) 18843 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags) 18844 v0.AddArg(x) 18845 v0.AddArg(y) 18846 v.AddArg(v0) 18847 return true 18848 } 18849 } 18850 func rewriteValueARM_OpGreater8_0(v *Value) bool { 18851 b := v.Block 18852 _ = b 18853 typ := &b.Func.Config.Types 18854 _ = typ 18855 // match: (Greater8 x y) 18856 // cond: 18857 // result: (GreaterThan (CMP (SignExt8to32 x) (SignExt8to32 y))) 18858 for { 18859 _ = v.Args[1] 18860 x := v.Args[0] 18861 y := v.Args[1] 18862 v.reset(OpARMGreaterThan) 18863 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18864 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 18865 v1.AddArg(x) 18866 v0.AddArg(v1) 18867 v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 18868 v2.AddArg(y) 18869 v0.AddArg(v2) 18870 v.AddArg(v0) 18871 return true 18872 } 18873 } 18874 func rewriteValueARM_OpGreater8U_0(v *Value) bool { 18875 b := v.Block 18876 _ = b 18877 typ := &b.Func.Config.Types 18878 _ = typ 18879 // match: (Greater8U x y) 18880 // cond: 18881 // result: (GreaterThanU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 18882 for { 18883 _ = v.Args[1] 18884 x := v.Args[0] 18885 y := v.Args[1] 18886 v.reset(OpARMGreaterThanU) 18887 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18888 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 18889 v1.AddArg(x) 18890 v0.AddArg(v1) 18891 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 18892 v2.AddArg(y) 18893 v0.AddArg(v2) 18894 v.AddArg(v0) 18895 return true 18896 } 18897 } 18898 func rewriteValueARM_OpHmul32_0(v *Value) bool { 18899 // match: (Hmul32 x y) 18900 // cond: 18901 // result: (HMUL x y) 18902 for { 18903 _ = v.Args[1] 18904 x := v.Args[0] 18905 y := v.Args[1] 18906 v.reset(OpARMHMUL) 18907 v.AddArg(x) 18908 v.AddArg(y) 18909 return true 18910 } 18911 } 18912 func rewriteValueARM_OpHmul32u_0(v *Value) bool { 18913 // match: (Hmul32u x y) 18914 // cond: 18915 // result: (HMULU x y) 18916 for { 18917 _ = v.Args[1] 18918 x := v.Args[0] 18919 y := v.Args[1] 18920 v.reset(OpARMHMULU) 18921 v.AddArg(x) 18922 v.AddArg(y) 18923 return true 18924 } 18925 } 18926 func rewriteValueARM_OpInterCall_0(v *Value) bool { 18927 // match: (InterCall [argwid] entry mem) 18928 // cond: 18929 // result: (CALLinter [argwid] entry mem) 18930 for { 18931 argwid := v.AuxInt 18932 _ = v.Args[1] 18933 entry := v.Args[0] 18934 mem := v.Args[1] 18935 v.reset(OpARMCALLinter) 18936 v.AuxInt = argwid 18937 v.AddArg(entry) 18938 v.AddArg(mem) 18939 return true 18940 } 18941 } 18942 func rewriteValueARM_OpIsInBounds_0(v *Value) bool { 18943 b := v.Block 18944 _ = b 18945 // match: (IsInBounds idx len) 18946 // cond: 18947 // result: (LessThanU (CMP idx len)) 18948 for { 18949 _ = v.Args[1] 18950 idx := v.Args[0] 18951 len := v.Args[1] 18952 v.reset(OpARMLessThanU) 18953 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18954 v0.AddArg(idx) 18955 v0.AddArg(len) 18956 v.AddArg(v0) 18957 return true 18958 } 18959 } 18960 func rewriteValueARM_OpIsNonNil_0(v *Value) bool { 18961 b := v.Block 18962 _ = b 18963 // match: (IsNonNil ptr) 18964 // cond: 18965 // result: (NotEqual (CMPconst [0] ptr)) 18966 for { 18967 ptr := v.Args[0] 18968 v.reset(OpARMNotEqual) 18969 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 18970 v0.AuxInt = 0 18971 v0.AddArg(ptr) 18972 v.AddArg(v0) 18973 return true 18974 } 18975 } 18976 func rewriteValueARM_OpIsSliceInBounds_0(v *Value) bool { 18977 b := v.Block 18978 _ = b 18979 // match: (IsSliceInBounds idx len) 18980 // cond: 18981 // result: (LessEqualU (CMP idx len)) 18982 for { 18983 _ = v.Args[1] 18984 idx := v.Args[0] 18985 len := v.Args[1] 18986 v.reset(OpARMLessEqualU) 18987 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 18988 v0.AddArg(idx) 18989 v0.AddArg(len) 18990 v.AddArg(v0) 18991 return true 18992 } 18993 } 18994 func rewriteValueARM_OpLeq16_0(v *Value) bool { 18995 b := v.Block 18996 _ = b 18997 typ := &b.Func.Config.Types 18998 _ = typ 18999 // match: (Leq16 x y) 19000 // cond: 19001 // result: (LessEqual (CMP (SignExt16to32 x) (SignExt16to32 y))) 19002 for { 19003 _ = v.Args[1] 19004 x := v.Args[0] 19005 y := v.Args[1] 19006 v.reset(OpARMLessEqual) 19007 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 19008 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 19009 v1.AddArg(x) 19010 v0.AddArg(v1) 19011 v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 19012 v2.AddArg(y) 19013 v0.AddArg(v2) 19014 v.AddArg(v0) 19015 return true 19016 } 19017 } 19018 func rewriteValueARM_OpLeq16U_0(v *Value) bool { 19019 b := v.Block 19020 _ = b 19021 typ := &b.Func.Config.Types 19022 _ = typ 19023 // match: (Leq16U x y) 19024 // cond: 19025 // result: (LessEqualU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 19026 for { 19027 _ = v.Args[1] 19028 x := v.Args[0] 19029 y := v.Args[1] 19030 v.reset(OpARMLessEqualU) 19031 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 19032 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19033 v1.AddArg(x) 19034 v0.AddArg(v1) 19035 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19036 v2.AddArg(y) 19037 v0.AddArg(v2) 19038 v.AddArg(v0) 19039 return true 19040 } 19041 } 19042 func rewriteValueARM_OpLeq32_0(v *Value) bool { 19043 b := v.Block 19044 _ = b 19045 // match: (Leq32 x y) 19046 // cond: 19047 // result: (LessEqual (CMP x y)) 19048 for { 19049 _ = v.Args[1] 19050 x := v.Args[0] 19051 y := v.Args[1] 19052 v.reset(OpARMLessEqual) 19053 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 19054 v0.AddArg(x) 19055 v0.AddArg(y) 19056 v.AddArg(v0) 19057 return true 19058 } 19059 } 19060 func rewriteValueARM_OpLeq32F_0(v *Value) bool { 19061 b := v.Block 19062 _ = b 19063 // match: (Leq32F x y) 19064 // cond: 19065 // result: (GreaterEqual (CMPF y x)) 19066 for { 19067 _ = v.Args[1] 19068 x := v.Args[0] 19069 y := v.Args[1] 19070 v.reset(OpARMGreaterEqual) 19071 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags) 19072 v0.AddArg(y) 19073 v0.AddArg(x) 19074 v.AddArg(v0) 19075 return true 19076 } 19077 } 19078 func rewriteValueARM_OpLeq32U_0(v *Value) bool { 19079 b := v.Block 19080 _ = b 19081 // match: (Leq32U x y) 19082 // cond: 19083 // result: (LessEqualU (CMP x y)) 19084 for { 19085 _ = v.Args[1] 19086 x := v.Args[0] 19087 y := v.Args[1] 19088 v.reset(OpARMLessEqualU) 19089 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 19090 v0.AddArg(x) 19091 v0.AddArg(y) 19092 v.AddArg(v0) 19093 return true 19094 } 19095 } 19096 func rewriteValueARM_OpLeq64F_0(v *Value) bool { 19097 b := v.Block 19098 _ = b 19099 // match: (Leq64F x y) 19100 // cond: 19101 // result: (GreaterEqual (CMPD y x)) 19102 for { 19103 _ = v.Args[1] 19104 x := v.Args[0] 19105 y := v.Args[1] 19106 v.reset(OpARMGreaterEqual) 19107 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags) 19108 v0.AddArg(y) 19109 v0.AddArg(x) 19110 v.AddArg(v0) 19111 return true 19112 } 19113 } 19114 func rewriteValueARM_OpLeq8_0(v *Value) bool { 19115 b := v.Block 19116 _ = b 19117 typ := &b.Func.Config.Types 19118 _ = typ 19119 // match: (Leq8 x y) 19120 // cond: 19121 // result: (LessEqual (CMP (SignExt8to32 x) (SignExt8to32 y))) 19122 for { 19123 _ = v.Args[1] 19124 x := v.Args[0] 19125 y := v.Args[1] 19126 v.reset(OpARMLessEqual) 19127 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 19128 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 19129 v1.AddArg(x) 19130 v0.AddArg(v1) 19131 v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 19132 v2.AddArg(y) 19133 v0.AddArg(v2) 19134 v.AddArg(v0) 19135 return true 19136 } 19137 } 19138 func rewriteValueARM_OpLeq8U_0(v *Value) bool { 19139 b := v.Block 19140 _ = b 19141 typ := &b.Func.Config.Types 19142 _ = typ 19143 // match: (Leq8U x y) 19144 // cond: 19145 // result: (LessEqualU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 19146 for { 19147 _ = v.Args[1] 19148 x := v.Args[0] 19149 y := v.Args[1] 19150 v.reset(OpARMLessEqualU) 19151 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 19152 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 19153 v1.AddArg(x) 19154 v0.AddArg(v1) 19155 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 19156 v2.AddArg(y) 19157 v0.AddArg(v2) 19158 v.AddArg(v0) 19159 return true 19160 } 19161 } 19162 func rewriteValueARM_OpLess16_0(v *Value) bool { 19163 b := v.Block 19164 _ = b 19165 typ := &b.Func.Config.Types 19166 _ = typ 19167 // match: (Less16 x y) 19168 // cond: 19169 // result: (LessThan (CMP (SignExt16to32 x) (SignExt16to32 y))) 19170 for { 19171 _ = v.Args[1] 19172 x := v.Args[0] 19173 y := v.Args[1] 19174 v.reset(OpARMLessThan) 19175 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 19176 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 19177 v1.AddArg(x) 19178 v0.AddArg(v1) 19179 v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 19180 v2.AddArg(y) 19181 v0.AddArg(v2) 19182 v.AddArg(v0) 19183 return true 19184 } 19185 } 19186 func rewriteValueARM_OpLess16U_0(v *Value) bool { 19187 b := v.Block 19188 _ = b 19189 typ := &b.Func.Config.Types 19190 _ = typ 19191 // match: (Less16U x y) 19192 // cond: 19193 // result: (LessThanU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 19194 for { 19195 _ = v.Args[1] 19196 x := v.Args[0] 19197 y := v.Args[1] 19198 v.reset(OpARMLessThanU) 19199 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 19200 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19201 v1.AddArg(x) 19202 v0.AddArg(v1) 19203 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19204 v2.AddArg(y) 19205 v0.AddArg(v2) 19206 v.AddArg(v0) 19207 return true 19208 } 19209 } 19210 func rewriteValueARM_OpLess32_0(v *Value) bool { 19211 b := v.Block 19212 _ = b 19213 // match: (Less32 x y) 19214 // cond: 19215 // result: (LessThan (CMP x y)) 19216 for { 19217 _ = v.Args[1] 19218 x := v.Args[0] 19219 y := v.Args[1] 19220 v.reset(OpARMLessThan) 19221 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 19222 v0.AddArg(x) 19223 v0.AddArg(y) 19224 v.AddArg(v0) 19225 return true 19226 } 19227 } 19228 func rewriteValueARM_OpLess32F_0(v *Value) bool { 19229 b := v.Block 19230 _ = b 19231 // match: (Less32F x y) 19232 // cond: 19233 // result: (GreaterThan (CMPF y x)) 19234 for { 19235 _ = v.Args[1] 19236 x := v.Args[0] 19237 y := v.Args[1] 19238 v.reset(OpARMGreaterThan) 19239 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags) 19240 v0.AddArg(y) 19241 v0.AddArg(x) 19242 v.AddArg(v0) 19243 return true 19244 } 19245 } 19246 func rewriteValueARM_OpLess32U_0(v *Value) bool { 19247 b := v.Block 19248 _ = b 19249 // match: (Less32U x y) 19250 // cond: 19251 // result: (LessThanU (CMP x y)) 19252 for { 19253 _ = v.Args[1] 19254 x := v.Args[0] 19255 y := v.Args[1] 19256 v.reset(OpARMLessThanU) 19257 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 19258 v0.AddArg(x) 19259 v0.AddArg(y) 19260 v.AddArg(v0) 19261 return true 19262 } 19263 } 19264 func rewriteValueARM_OpLess64F_0(v *Value) bool { 19265 b := v.Block 19266 _ = b 19267 // match: (Less64F x y) 19268 // cond: 19269 // result: (GreaterThan (CMPD y x)) 19270 for { 19271 _ = v.Args[1] 19272 x := v.Args[0] 19273 y := v.Args[1] 19274 v.reset(OpARMGreaterThan) 19275 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags) 19276 v0.AddArg(y) 19277 v0.AddArg(x) 19278 v.AddArg(v0) 19279 return true 19280 } 19281 } 19282 func rewriteValueARM_OpLess8_0(v *Value) bool { 19283 b := v.Block 19284 _ = b 19285 typ := &b.Func.Config.Types 19286 _ = typ 19287 // match: (Less8 x y) 19288 // cond: 19289 // result: (LessThan (CMP (SignExt8to32 x) (SignExt8to32 y))) 19290 for { 19291 _ = v.Args[1] 19292 x := v.Args[0] 19293 y := v.Args[1] 19294 v.reset(OpARMLessThan) 19295 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 19296 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 19297 v1.AddArg(x) 19298 v0.AddArg(v1) 19299 v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 19300 v2.AddArg(y) 19301 v0.AddArg(v2) 19302 v.AddArg(v0) 19303 return true 19304 } 19305 } 19306 func rewriteValueARM_OpLess8U_0(v *Value) bool { 19307 b := v.Block 19308 _ = b 19309 typ := &b.Func.Config.Types 19310 _ = typ 19311 // match: (Less8U x y) 19312 // cond: 19313 // result: (LessThanU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 19314 for { 19315 _ = v.Args[1] 19316 x := v.Args[0] 19317 y := v.Args[1] 19318 v.reset(OpARMLessThanU) 19319 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 19320 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 19321 v1.AddArg(x) 19322 v0.AddArg(v1) 19323 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 19324 v2.AddArg(y) 19325 v0.AddArg(v2) 19326 v.AddArg(v0) 19327 return true 19328 } 19329 } 19330 func rewriteValueARM_OpLoad_0(v *Value) bool { 19331 // match: (Load <t> ptr mem) 19332 // cond: t.IsBoolean() 19333 // result: (MOVBUload ptr mem) 19334 for { 19335 t := v.Type 19336 _ = v.Args[1] 19337 ptr := v.Args[0] 19338 mem := v.Args[1] 19339 if !(t.IsBoolean()) { 19340 break 19341 } 19342 v.reset(OpARMMOVBUload) 19343 v.AddArg(ptr) 19344 v.AddArg(mem) 19345 return true 19346 } 19347 // match: (Load <t> ptr mem) 19348 // cond: (is8BitInt(t) && isSigned(t)) 19349 // result: (MOVBload ptr mem) 19350 for { 19351 t := v.Type 19352 _ = v.Args[1] 19353 ptr := v.Args[0] 19354 mem := v.Args[1] 19355 if !(is8BitInt(t) && isSigned(t)) { 19356 break 19357 } 19358 v.reset(OpARMMOVBload) 19359 v.AddArg(ptr) 19360 v.AddArg(mem) 19361 return true 19362 } 19363 // match: (Load <t> ptr mem) 19364 // cond: (is8BitInt(t) && !isSigned(t)) 19365 // result: (MOVBUload ptr mem) 19366 for { 19367 t := v.Type 19368 _ = v.Args[1] 19369 ptr := v.Args[0] 19370 mem := v.Args[1] 19371 if !(is8BitInt(t) && !isSigned(t)) { 19372 break 19373 } 19374 v.reset(OpARMMOVBUload) 19375 v.AddArg(ptr) 19376 v.AddArg(mem) 19377 return true 19378 } 19379 // match: (Load <t> ptr mem) 19380 // cond: (is16BitInt(t) && isSigned(t)) 19381 // result: (MOVHload ptr mem) 19382 for { 19383 t := v.Type 19384 _ = v.Args[1] 19385 ptr := v.Args[0] 19386 mem := v.Args[1] 19387 if !(is16BitInt(t) && isSigned(t)) { 19388 break 19389 } 19390 v.reset(OpARMMOVHload) 19391 v.AddArg(ptr) 19392 v.AddArg(mem) 19393 return true 19394 } 19395 // match: (Load <t> ptr mem) 19396 // cond: (is16BitInt(t) && !isSigned(t)) 19397 // result: (MOVHUload ptr mem) 19398 for { 19399 t := v.Type 19400 _ = v.Args[1] 19401 ptr := v.Args[0] 19402 mem := v.Args[1] 19403 if !(is16BitInt(t) && !isSigned(t)) { 19404 break 19405 } 19406 v.reset(OpARMMOVHUload) 19407 v.AddArg(ptr) 19408 v.AddArg(mem) 19409 return true 19410 } 19411 // match: (Load <t> ptr mem) 19412 // cond: (is32BitInt(t) || isPtr(t)) 19413 // result: (MOVWload ptr mem) 19414 for { 19415 t := v.Type 19416 _ = v.Args[1] 19417 ptr := v.Args[0] 19418 mem := v.Args[1] 19419 if !(is32BitInt(t) || isPtr(t)) { 19420 break 19421 } 19422 v.reset(OpARMMOVWload) 19423 v.AddArg(ptr) 19424 v.AddArg(mem) 19425 return true 19426 } 19427 // match: (Load <t> ptr mem) 19428 // cond: is32BitFloat(t) 19429 // result: (MOVFload ptr mem) 19430 for { 19431 t := v.Type 19432 _ = v.Args[1] 19433 ptr := v.Args[0] 19434 mem := v.Args[1] 19435 if !(is32BitFloat(t)) { 19436 break 19437 } 19438 v.reset(OpARMMOVFload) 19439 v.AddArg(ptr) 19440 v.AddArg(mem) 19441 return true 19442 } 19443 // match: (Load <t> ptr mem) 19444 // cond: is64BitFloat(t) 19445 // result: (MOVDload ptr mem) 19446 for { 19447 t := v.Type 19448 _ = v.Args[1] 19449 ptr := v.Args[0] 19450 mem := v.Args[1] 19451 if !(is64BitFloat(t)) { 19452 break 19453 } 19454 v.reset(OpARMMOVDload) 19455 v.AddArg(ptr) 19456 v.AddArg(mem) 19457 return true 19458 } 19459 return false 19460 } 19461 func rewriteValueARM_OpLocalAddr_0(v *Value) bool { 19462 // match: (LocalAddr {sym} base _) 19463 // cond: 19464 // result: (MOVWaddr {sym} base) 19465 for { 19466 sym := v.Aux 19467 _ = v.Args[1] 19468 base := v.Args[0] 19469 v.reset(OpARMMOVWaddr) 19470 v.Aux = sym 19471 v.AddArg(base) 19472 return true 19473 } 19474 } 19475 func rewriteValueARM_OpLsh16x16_0(v *Value) bool { 19476 b := v.Block 19477 _ = b 19478 typ := &b.Func.Config.Types 19479 _ = typ 19480 // match: (Lsh16x16 x y) 19481 // cond: 19482 // result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 19483 for { 19484 _ = v.Args[1] 19485 x := v.Args[0] 19486 y := v.Args[1] 19487 v.reset(OpARMCMOVWHSconst) 19488 v.AuxInt = 0 19489 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 19490 v0.AddArg(x) 19491 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19492 v1.AddArg(y) 19493 v0.AddArg(v1) 19494 v.AddArg(v0) 19495 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 19496 v2.AuxInt = 256 19497 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19498 v3.AddArg(y) 19499 v2.AddArg(v3) 19500 v.AddArg(v2) 19501 return true 19502 } 19503 } 19504 func rewriteValueARM_OpLsh16x32_0(v *Value) bool { 19505 b := v.Block 19506 _ = b 19507 // match: (Lsh16x32 x y) 19508 // cond: 19509 // result: (CMOVWHSconst (SLL <x.Type> x y) (CMPconst [256] y) [0]) 19510 for { 19511 _ = v.Args[1] 19512 x := v.Args[0] 19513 y := v.Args[1] 19514 v.reset(OpARMCMOVWHSconst) 19515 v.AuxInt = 0 19516 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 19517 v0.AddArg(x) 19518 v0.AddArg(y) 19519 v.AddArg(v0) 19520 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 19521 v1.AuxInt = 256 19522 v1.AddArg(y) 19523 v.AddArg(v1) 19524 return true 19525 } 19526 } 19527 func rewriteValueARM_OpLsh16x64_0(v *Value) bool { 19528 // match: (Lsh16x64 x (Const64 [c])) 19529 // cond: uint64(c) < 16 19530 // result: (SLLconst x [c]) 19531 for { 19532 _ = v.Args[1] 19533 x := v.Args[0] 19534 v_1 := v.Args[1] 19535 if v_1.Op != OpConst64 { 19536 break 19537 } 19538 c := v_1.AuxInt 19539 if !(uint64(c) < 16) { 19540 break 19541 } 19542 v.reset(OpARMSLLconst) 19543 v.AuxInt = c 19544 v.AddArg(x) 19545 return true 19546 } 19547 // match: (Lsh16x64 _ (Const64 [c])) 19548 // cond: uint64(c) >= 16 19549 // result: (Const16 [0]) 19550 for { 19551 _ = v.Args[1] 19552 v_1 := v.Args[1] 19553 if v_1.Op != OpConst64 { 19554 break 19555 } 19556 c := v_1.AuxInt 19557 if !(uint64(c) >= 16) { 19558 break 19559 } 19560 v.reset(OpConst16) 19561 v.AuxInt = 0 19562 return true 19563 } 19564 return false 19565 } 19566 func rewriteValueARM_OpLsh16x8_0(v *Value) bool { 19567 b := v.Block 19568 _ = b 19569 typ := &b.Func.Config.Types 19570 _ = typ 19571 // match: (Lsh16x8 x y) 19572 // cond: 19573 // result: (SLL x (ZeroExt8to32 y)) 19574 for { 19575 _ = v.Args[1] 19576 x := v.Args[0] 19577 y := v.Args[1] 19578 v.reset(OpARMSLL) 19579 v.AddArg(x) 19580 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 19581 v0.AddArg(y) 19582 v.AddArg(v0) 19583 return true 19584 } 19585 } 19586 func rewriteValueARM_OpLsh32x16_0(v *Value) bool { 19587 b := v.Block 19588 _ = b 19589 typ := &b.Func.Config.Types 19590 _ = typ 19591 // match: (Lsh32x16 x y) 19592 // cond: 19593 // result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 19594 for { 19595 _ = v.Args[1] 19596 x := v.Args[0] 19597 y := v.Args[1] 19598 v.reset(OpARMCMOVWHSconst) 19599 v.AuxInt = 0 19600 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 19601 v0.AddArg(x) 19602 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19603 v1.AddArg(y) 19604 v0.AddArg(v1) 19605 v.AddArg(v0) 19606 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 19607 v2.AuxInt = 256 19608 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19609 v3.AddArg(y) 19610 v2.AddArg(v3) 19611 v.AddArg(v2) 19612 return true 19613 } 19614 } 19615 func rewriteValueARM_OpLsh32x32_0(v *Value) bool { 19616 b := v.Block 19617 _ = b 19618 // match: (Lsh32x32 x y) 19619 // cond: 19620 // result: (CMOVWHSconst (SLL <x.Type> x y) (CMPconst [256] y) [0]) 19621 for { 19622 _ = v.Args[1] 19623 x := v.Args[0] 19624 y := v.Args[1] 19625 v.reset(OpARMCMOVWHSconst) 19626 v.AuxInt = 0 19627 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 19628 v0.AddArg(x) 19629 v0.AddArg(y) 19630 v.AddArg(v0) 19631 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 19632 v1.AuxInt = 256 19633 v1.AddArg(y) 19634 v.AddArg(v1) 19635 return true 19636 } 19637 } 19638 func rewriteValueARM_OpLsh32x64_0(v *Value) bool { 19639 // match: (Lsh32x64 x (Const64 [c])) 19640 // cond: uint64(c) < 32 19641 // result: (SLLconst x [c]) 19642 for { 19643 _ = v.Args[1] 19644 x := v.Args[0] 19645 v_1 := v.Args[1] 19646 if v_1.Op != OpConst64 { 19647 break 19648 } 19649 c := v_1.AuxInt 19650 if !(uint64(c) < 32) { 19651 break 19652 } 19653 v.reset(OpARMSLLconst) 19654 v.AuxInt = c 19655 v.AddArg(x) 19656 return true 19657 } 19658 // match: (Lsh32x64 _ (Const64 [c])) 19659 // cond: uint64(c) >= 32 19660 // result: (Const32 [0]) 19661 for { 19662 _ = v.Args[1] 19663 v_1 := v.Args[1] 19664 if v_1.Op != OpConst64 { 19665 break 19666 } 19667 c := v_1.AuxInt 19668 if !(uint64(c) >= 32) { 19669 break 19670 } 19671 v.reset(OpConst32) 19672 v.AuxInt = 0 19673 return true 19674 } 19675 return false 19676 } 19677 func rewriteValueARM_OpLsh32x8_0(v *Value) bool { 19678 b := v.Block 19679 _ = b 19680 typ := &b.Func.Config.Types 19681 _ = typ 19682 // match: (Lsh32x8 x y) 19683 // cond: 19684 // result: (SLL x (ZeroExt8to32 y)) 19685 for { 19686 _ = v.Args[1] 19687 x := v.Args[0] 19688 y := v.Args[1] 19689 v.reset(OpARMSLL) 19690 v.AddArg(x) 19691 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 19692 v0.AddArg(y) 19693 v.AddArg(v0) 19694 return true 19695 } 19696 } 19697 func rewriteValueARM_OpLsh8x16_0(v *Value) bool { 19698 b := v.Block 19699 _ = b 19700 typ := &b.Func.Config.Types 19701 _ = typ 19702 // match: (Lsh8x16 x y) 19703 // cond: 19704 // result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 19705 for { 19706 _ = v.Args[1] 19707 x := v.Args[0] 19708 y := v.Args[1] 19709 v.reset(OpARMCMOVWHSconst) 19710 v.AuxInt = 0 19711 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 19712 v0.AddArg(x) 19713 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19714 v1.AddArg(y) 19715 v0.AddArg(v1) 19716 v.AddArg(v0) 19717 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 19718 v2.AuxInt = 256 19719 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19720 v3.AddArg(y) 19721 v2.AddArg(v3) 19722 v.AddArg(v2) 19723 return true 19724 } 19725 } 19726 func rewriteValueARM_OpLsh8x32_0(v *Value) bool { 19727 b := v.Block 19728 _ = b 19729 // match: (Lsh8x32 x y) 19730 // cond: 19731 // result: (CMOVWHSconst (SLL <x.Type> x y) (CMPconst [256] y) [0]) 19732 for { 19733 _ = v.Args[1] 19734 x := v.Args[0] 19735 y := v.Args[1] 19736 v.reset(OpARMCMOVWHSconst) 19737 v.AuxInt = 0 19738 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type) 19739 v0.AddArg(x) 19740 v0.AddArg(y) 19741 v.AddArg(v0) 19742 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 19743 v1.AuxInt = 256 19744 v1.AddArg(y) 19745 v.AddArg(v1) 19746 return true 19747 } 19748 } 19749 func rewriteValueARM_OpLsh8x64_0(v *Value) bool { 19750 // match: (Lsh8x64 x (Const64 [c])) 19751 // cond: uint64(c) < 8 19752 // result: (SLLconst x [c]) 19753 for { 19754 _ = v.Args[1] 19755 x := v.Args[0] 19756 v_1 := v.Args[1] 19757 if v_1.Op != OpConst64 { 19758 break 19759 } 19760 c := v_1.AuxInt 19761 if !(uint64(c) < 8) { 19762 break 19763 } 19764 v.reset(OpARMSLLconst) 19765 v.AuxInt = c 19766 v.AddArg(x) 19767 return true 19768 } 19769 // match: (Lsh8x64 _ (Const64 [c])) 19770 // cond: uint64(c) >= 8 19771 // result: (Const8 [0]) 19772 for { 19773 _ = v.Args[1] 19774 v_1 := v.Args[1] 19775 if v_1.Op != OpConst64 { 19776 break 19777 } 19778 c := v_1.AuxInt 19779 if !(uint64(c) >= 8) { 19780 break 19781 } 19782 v.reset(OpConst8) 19783 v.AuxInt = 0 19784 return true 19785 } 19786 return false 19787 } 19788 func rewriteValueARM_OpLsh8x8_0(v *Value) bool { 19789 b := v.Block 19790 _ = b 19791 typ := &b.Func.Config.Types 19792 _ = typ 19793 // match: (Lsh8x8 x y) 19794 // cond: 19795 // result: (SLL x (ZeroExt8to32 y)) 19796 for { 19797 _ = v.Args[1] 19798 x := v.Args[0] 19799 y := v.Args[1] 19800 v.reset(OpARMSLL) 19801 v.AddArg(x) 19802 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 19803 v0.AddArg(y) 19804 v.AddArg(v0) 19805 return true 19806 } 19807 } 19808 func rewriteValueARM_OpMod16_0(v *Value) bool { 19809 b := v.Block 19810 _ = b 19811 typ := &b.Func.Config.Types 19812 _ = typ 19813 // match: (Mod16 x y) 19814 // cond: 19815 // result: (Mod32 (SignExt16to32 x) (SignExt16to32 y)) 19816 for { 19817 _ = v.Args[1] 19818 x := v.Args[0] 19819 y := v.Args[1] 19820 v.reset(OpMod32) 19821 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 19822 v0.AddArg(x) 19823 v.AddArg(v0) 19824 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 19825 v1.AddArg(y) 19826 v.AddArg(v1) 19827 return true 19828 } 19829 } 19830 func rewriteValueARM_OpMod16u_0(v *Value) bool { 19831 b := v.Block 19832 _ = b 19833 typ := &b.Func.Config.Types 19834 _ = typ 19835 // match: (Mod16u x y) 19836 // cond: 19837 // result: (Mod32u (ZeroExt16to32 x) (ZeroExt16to32 y)) 19838 for { 19839 _ = v.Args[1] 19840 x := v.Args[0] 19841 y := v.Args[1] 19842 v.reset(OpMod32u) 19843 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19844 v0.AddArg(x) 19845 v.AddArg(v0) 19846 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 19847 v1.AddArg(y) 19848 v.AddArg(v1) 19849 return true 19850 } 19851 } 19852 func rewriteValueARM_OpMod32_0(v *Value) bool { 19853 b := v.Block 19854 _ = b 19855 typ := &b.Func.Config.Types 19856 _ = typ 19857 // match: (Mod32 x y) 19858 // cond: 19859 // 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)) 19860 for { 19861 _ = v.Args[1] 19862 x := v.Args[0] 19863 y := v.Args[1] 19864 v.reset(OpARMSUB) 19865 v0 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32) 19866 v1 := b.NewValue0(v.Pos, OpSelect1, typ.UInt32) 19867 v2 := b.NewValue0(v.Pos, OpARMCALLudiv, types.NewTuple(typ.UInt32, typ.UInt32)) 19868 v3 := b.NewValue0(v.Pos, OpARMSUB, typ.UInt32) 19869 v4 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32) 19870 v4.AddArg(x) 19871 v5 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 19872 v5.AddArg(x) 19873 v4.AddArg(v5) 19874 v3.AddArg(v4) 19875 v6 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 19876 v6.AddArg(x) 19877 v3.AddArg(v6) 19878 v2.AddArg(v3) 19879 v7 := b.NewValue0(v.Pos, OpARMSUB, typ.UInt32) 19880 v8 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32) 19881 v8.AddArg(y) 19882 v9 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 19883 v9.AddArg(y) 19884 v8.AddArg(v9) 19885 v7.AddArg(v8) 19886 v10 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 19887 v10.AddArg(y) 19888 v7.AddArg(v10) 19889 v2.AddArg(v7) 19890 v1.AddArg(v2) 19891 v0.AddArg(v1) 19892 v11 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 19893 v11.AddArg(x) 19894 v0.AddArg(v11) 19895 v.AddArg(v0) 19896 v12 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 19897 v12.AddArg(x) 19898 v.AddArg(v12) 19899 return true 19900 } 19901 } 19902 func rewriteValueARM_OpMod32u_0(v *Value) bool { 19903 b := v.Block 19904 _ = b 19905 typ := &b.Func.Config.Types 19906 _ = typ 19907 // match: (Mod32u x y) 19908 // cond: 19909 // result: (Select1 <typ.UInt32> (CALLudiv x y)) 19910 for { 19911 _ = v.Args[1] 19912 x := v.Args[0] 19913 y := v.Args[1] 19914 v.reset(OpSelect1) 19915 v.Type = typ.UInt32 19916 v0 := b.NewValue0(v.Pos, OpARMCALLudiv, types.NewTuple(typ.UInt32, typ.UInt32)) 19917 v0.AddArg(x) 19918 v0.AddArg(y) 19919 v.AddArg(v0) 19920 return true 19921 } 19922 } 19923 func rewriteValueARM_OpMod8_0(v *Value) bool { 19924 b := v.Block 19925 _ = b 19926 typ := &b.Func.Config.Types 19927 _ = typ 19928 // match: (Mod8 x y) 19929 // cond: 19930 // result: (Mod32 (SignExt8to32 x) (SignExt8to32 y)) 19931 for { 19932 _ = v.Args[1] 19933 x := v.Args[0] 19934 y := v.Args[1] 19935 v.reset(OpMod32) 19936 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 19937 v0.AddArg(x) 19938 v.AddArg(v0) 19939 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 19940 v1.AddArg(y) 19941 v.AddArg(v1) 19942 return true 19943 } 19944 } 19945 func rewriteValueARM_OpMod8u_0(v *Value) bool { 19946 b := v.Block 19947 _ = b 19948 typ := &b.Func.Config.Types 19949 _ = typ 19950 // match: (Mod8u x y) 19951 // cond: 19952 // result: (Mod32u (ZeroExt8to32 x) (ZeroExt8to32 y)) 19953 for { 19954 _ = v.Args[1] 19955 x := v.Args[0] 19956 y := v.Args[1] 19957 v.reset(OpMod32u) 19958 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 19959 v0.AddArg(x) 19960 v.AddArg(v0) 19961 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 19962 v1.AddArg(y) 19963 v.AddArg(v1) 19964 return true 19965 } 19966 } 19967 func rewriteValueARM_OpMove_0(v *Value) bool { 19968 b := v.Block 19969 _ = b 19970 config := b.Func.Config 19971 _ = config 19972 typ := &b.Func.Config.Types 19973 _ = typ 19974 // match: (Move [0] _ _ mem) 19975 // cond: 19976 // result: mem 19977 for { 19978 if v.AuxInt != 0 { 19979 break 19980 } 19981 _ = v.Args[2] 19982 mem := v.Args[2] 19983 v.reset(OpCopy) 19984 v.Type = mem.Type 19985 v.AddArg(mem) 19986 return true 19987 } 19988 // match: (Move [1] dst src mem) 19989 // cond: 19990 // result: (MOVBstore dst (MOVBUload src mem) mem) 19991 for { 19992 if v.AuxInt != 1 { 19993 break 19994 } 19995 _ = v.Args[2] 19996 dst := v.Args[0] 19997 src := v.Args[1] 19998 mem := v.Args[2] 19999 v.reset(OpARMMOVBstore) 20000 v.AddArg(dst) 20001 v0 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 20002 v0.AddArg(src) 20003 v0.AddArg(mem) 20004 v.AddArg(v0) 20005 v.AddArg(mem) 20006 return true 20007 } 20008 // match: (Move [2] {t} dst src mem) 20009 // cond: t.(*types.Type).Alignment()%2 == 0 20010 // result: (MOVHstore dst (MOVHUload src mem) mem) 20011 for { 20012 if v.AuxInt != 2 { 20013 break 20014 } 20015 t := v.Aux 20016 _ = v.Args[2] 20017 dst := v.Args[0] 20018 src := v.Args[1] 20019 mem := v.Args[2] 20020 if !(t.(*types.Type).Alignment()%2 == 0) { 20021 break 20022 } 20023 v.reset(OpARMMOVHstore) 20024 v.AddArg(dst) 20025 v0 := b.NewValue0(v.Pos, OpARMMOVHUload, typ.UInt16) 20026 v0.AddArg(src) 20027 v0.AddArg(mem) 20028 v.AddArg(v0) 20029 v.AddArg(mem) 20030 return true 20031 } 20032 // match: (Move [2] dst src mem) 20033 // cond: 20034 // result: (MOVBstore [1] dst (MOVBUload [1] src mem) (MOVBstore dst (MOVBUload src mem) mem)) 20035 for { 20036 if v.AuxInt != 2 { 20037 break 20038 } 20039 _ = v.Args[2] 20040 dst := v.Args[0] 20041 src := v.Args[1] 20042 mem := v.Args[2] 20043 v.reset(OpARMMOVBstore) 20044 v.AuxInt = 1 20045 v.AddArg(dst) 20046 v0 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 20047 v0.AuxInt = 1 20048 v0.AddArg(src) 20049 v0.AddArg(mem) 20050 v.AddArg(v0) 20051 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 20052 v1.AddArg(dst) 20053 v2 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 20054 v2.AddArg(src) 20055 v2.AddArg(mem) 20056 v1.AddArg(v2) 20057 v1.AddArg(mem) 20058 v.AddArg(v1) 20059 return true 20060 } 20061 // match: (Move [4] {t} dst src mem) 20062 // cond: t.(*types.Type).Alignment()%4 == 0 20063 // result: (MOVWstore dst (MOVWload src mem) mem) 20064 for { 20065 if v.AuxInt != 4 { 20066 break 20067 } 20068 t := v.Aux 20069 _ = v.Args[2] 20070 dst := v.Args[0] 20071 src := v.Args[1] 20072 mem := v.Args[2] 20073 if !(t.(*types.Type).Alignment()%4 == 0) { 20074 break 20075 } 20076 v.reset(OpARMMOVWstore) 20077 v.AddArg(dst) 20078 v0 := b.NewValue0(v.Pos, OpARMMOVWload, typ.UInt32) 20079 v0.AddArg(src) 20080 v0.AddArg(mem) 20081 v.AddArg(v0) 20082 v.AddArg(mem) 20083 return true 20084 } 20085 // match: (Move [4] {t} dst src mem) 20086 // cond: t.(*types.Type).Alignment()%2 == 0 20087 // result: (MOVHstore [2] dst (MOVHUload [2] src mem) (MOVHstore dst (MOVHUload src mem) mem)) 20088 for { 20089 if v.AuxInt != 4 { 20090 break 20091 } 20092 t := v.Aux 20093 _ = v.Args[2] 20094 dst := v.Args[0] 20095 src := v.Args[1] 20096 mem := v.Args[2] 20097 if !(t.(*types.Type).Alignment()%2 == 0) { 20098 break 20099 } 20100 v.reset(OpARMMOVHstore) 20101 v.AuxInt = 2 20102 v.AddArg(dst) 20103 v0 := b.NewValue0(v.Pos, OpARMMOVHUload, typ.UInt16) 20104 v0.AuxInt = 2 20105 v0.AddArg(src) 20106 v0.AddArg(mem) 20107 v.AddArg(v0) 20108 v1 := b.NewValue0(v.Pos, OpARMMOVHstore, types.TypeMem) 20109 v1.AddArg(dst) 20110 v2 := b.NewValue0(v.Pos, OpARMMOVHUload, typ.UInt16) 20111 v2.AddArg(src) 20112 v2.AddArg(mem) 20113 v1.AddArg(v2) 20114 v1.AddArg(mem) 20115 v.AddArg(v1) 20116 return true 20117 } 20118 // match: (Move [4] dst src mem) 20119 // cond: 20120 // 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)))) 20121 for { 20122 if v.AuxInt != 4 { 20123 break 20124 } 20125 _ = v.Args[2] 20126 dst := v.Args[0] 20127 src := v.Args[1] 20128 mem := v.Args[2] 20129 v.reset(OpARMMOVBstore) 20130 v.AuxInt = 3 20131 v.AddArg(dst) 20132 v0 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 20133 v0.AuxInt = 3 20134 v0.AddArg(src) 20135 v0.AddArg(mem) 20136 v.AddArg(v0) 20137 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 20138 v1.AuxInt = 2 20139 v1.AddArg(dst) 20140 v2 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 20141 v2.AuxInt = 2 20142 v2.AddArg(src) 20143 v2.AddArg(mem) 20144 v1.AddArg(v2) 20145 v3 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 20146 v3.AuxInt = 1 20147 v3.AddArg(dst) 20148 v4 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 20149 v4.AuxInt = 1 20150 v4.AddArg(src) 20151 v4.AddArg(mem) 20152 v3.AddArg(v4) 20153 v5 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 20154 v5.AddArg(dst) 20155 v6 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 20156 v6.AddArg(src) 20157 v6.AddArg(mem) 20158 v5.AddArg(v6) 20159 v5.AddArg(mem) 20160 v3.AddArg(v5) 20161 v1.AddArg(v3) 20162 v.AddArg(v1) 20163 return true 20164 } 20165 // match: (Move [3] dst src mem) 20166 // cond: 20167 // result: (MOVBstore [2] dst (MOVBUload [2] src mem) (MOVBstore [1] dst (MOVBUload [1] src mem) (MOVBstore dst (MOVBUload src mem) mem))) 20168 for { 20169 if v.AuxInt != 3 { 20170 break 20171 } 20172 _ = v.Args[2] 20173 dst := v.Args[0] 20174 src := v.Args[1] 20175 mem := v.Args[2] 20176 v.reset(OpARMMOVBstore) 20177 v.AuxInt = 2 20178 v.AddArg(dst) 20179 v0 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 20180 v0.AuxInt = 2 20181 v0.AddArg(src) 20182 v0.AddArg(mem) 20183 v.AddArg(v0) 20184 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 20185 v1.AuxInt = 1 20186 v1.AddArg(dst) 20187 v2 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 20188 v2.AuxInt = 1 20189 v2.AddArg(src) 20190 v2.AddArg(mem) 20191 v1.AddArg(v2) 20192 v3 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 20193 v3.AddArg(dst) 20194 v4 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8) 20195 v4.AddArg(src) 20196 v4.AddArg(mem) 20197 v3.AddArg(v4) 20198 v3.AddArg(mem) 20199 v1.AddArg(v3) 20200 v.AddArg(v1) 20201 return true 20202 } 20203 // match: (Move [s] {t} dst src mem) 20204 // cond: s%4 == 0 && s > 4 && s <= 512 && t.(*types.Type).Alignment()%4 == 0 && !config.noDuffDevice 20205 // result: (DUFFCOPY [8 * (128 - s/4)] dst src mem) 20206 for { 20207 s := v.AuxInt 20208 t := v.Aux 20209 _ = v.Args[2] 20210 dst := v.Args[0] 20211 src := v.Args[1] 20212 mem := v.Args[2] 20213 if !(s%4 == 0 && s > 4 && s <= 512 && t.(*types.Type).Alignment()%4 == 0 && !config.noDuffDevice) { 20214 break 20215 } 20216 v.reset(OpARMDUFFCOPY) 20217 v.AuxInt = 8 * (128 - s/4) 20218 v.AddArg(dst) 20219 v.AddArg(src) 20220 v.AddArg(mem) 20221 return true 20222 } 20223 // match: (Move [s] {t} dst src mem) 20224 // cond: (s > 512 || config.noDuffDevice) || t.(*types.Type).Alignment()%4 != 0 20225 // result: (LoweredMove [t.(*types.Type).Alignment()] dst src (ADDconst <src.Type> src [s-moveSize(t.(*types.Type).Alignment(), config)]) mem) 20226 for { 20227 s := v.AuxInt 20228 t := v.Aux 20229 _ = v.Args[2] 20230 dst := v.Args[0] 20231 src := v.Args[1] 20232 mem := v.Args[2] 20233 if !((s > 512 || config.noDuffDevice) || t.(*types.Type).Alignment()%4 != 0) { 20234 break 20235 } 20236 v.reset(OpARMLoweredMove) 20237 v.AuxInt = t.(*types.Type).Alignment() 20238 v.AddArg(dst) 20239 v.AddArg(src) 20240 v0 := b.NewValue0(v.Pos, OpARMADDconst, src.Type) 20241 v0.AuxInt = s - moveSize(t.(*types.Type).Alignment(), config) 20242 v0.AddArg(src) 20243 v.AddArg(v0) 20244 v.AddArg(mem) 20245 return true 20246 } 20247 return false 20248 } 20249 func rewriteValueARM_OpMul16_0(v *Value) bool { 20250 // match: (Mul16 x y) 20251 // cond: 20252 // result: (MUL x y) 20253 for { 20254 _ = v.Args[1] 20255 x := v.Args[0] 20256 y := v.Args[1] 20257 v.reset(OpARMMUL) 20258 v.AddArg(x) 20259 v.AddArg(y) 20260 return true 20261 } 20262 } 20263 func rewriteValueARM_OpMul32_0(v *Value) bool { 20264 // match: (Mul32 x y) 20265 // cond: 20266 // result: (MUL x y) 20267 for { 20268 _ = v.Args[1] 20269 x := v.Args[0] 20270 y := v.Args[1] 20271 v.reset(OpARMMUL) 20272 v.AddArg(x) 20273 v.AddArg(y) 20274 return true 20275 } 20276 } 20277 func rewriteValueARM_OpMul32F_0(v *Value) bool { 20278 // match: (Mul32F x y) 20279 // cond: 20280 // result: (MULF x y) 20281 for { 20282 _ = v.Args[1] 20283 x := v.Args[0] 20284 y := v.Args[1] 20285 v.reset(OpARMMULF) 20286 v.AddArg(x) 20287 v.AddArg(y) 20288 return true 20289 } 20290 } 20291 func rewriteValueARM_OpMul32uhilo_0(v *Value) bool { 20292 // match: (Mul32uhilo x y) 20293 // cond: 20294 // result: (MULLU x y) 20295 for { 20296 _ = v.Args[1] 20297 x := v.Args[0] 20298 y := v.Args[1] 20299 v.reset(OpARMMULLU) 20300 v.AddArg(x) 20301 v.AddArg(y) 20302 return true 20303 } 20304 } 20305 func rewriteValueARM_OpMul64F_0(v *Value) bool { 20306 // match: (Mul64F x y) 20307 // cond: 20308 // result: (MULD x y) 20309 for { 20310 _ = v.Args[1] 20311 x := v.Args[0] 20312 y := v.Args[1] 20313 v.reset(OpARMMULD) 20314 v.AddArg(x) 20315 v.AddArg(y) 20316 return true 20317 } 20318 } 20319 func rewriteValueARM_OpMul8_0(v *Value) bool { 20320 // match: (Mul8 x y) 20321 // cond: 20322 // result: (MUL x y) 20323 for { 20324 _ = v.Args[1] 20325 x := v.Args[0] 20326 y := v.Args[1] 20327 v.reset(OpARMMUL) 20328 v.AddArg(x) 20329 v.AddArg(y) 20330 return true 20331 } 20332 } 20333 func rewriteValueARM_OpNeg16_0(v *Value) bool { 20334 // match: (Neg16 x) 20335 // cond: 20336 // result: (RSBconst [0] x) 20337 for { 20338 x := v.Args[0] 20339 v.reset(OpARMRSBconst) 20340 v.AuxInt = 0 20341 v.AddArg(x) 20342 return true 20343 } 20344 } 20345 func rewriteValueARM_OpNeg32_0(v *Value) bool { 20346 // match: (Neg32 x) 20347 // cond: 20348 // result: (RSBconst [0] x) 20349 for { 20350 x := v.Args[0] 20351 v.reset(OpARMRSBconst) 20352 v.AuxInt = 0 20353 v.AddArg(x) 20354 return true 20355 } 20356 } 20357 func rewriteValueARM_OpNeg32F_0(v *Value) bool { 20358 // match: (Neg32F x) 20359 // cond: 20360 // result: (NEGF x) 20361 for { 20362 x := v.Args[0] 20363 v.reset(OpARMNEGF) 20364 v.AddArg(x) 20365 return true 20366 } 20367 } 20368 func rewriteValueARM_OpNeg64F_0(v *Value) bool { 20369 // match: (Neg64F x) 20370 // cond: 20371 // result: (NEGD x) 20372 for { 20373 x := v.Args[0] 20374 v.reset(OpARMNEGD) 20375 v.AddArg(x) 20376 return true 20377 } 20378 } 20379 func rewriteValueARM_OpNeg8_0(v *Value) bool { 20380 // match: (Neg8 x) 20381 // cond: 20382 // result: (RSBconst [0] x) 20383 for { 20384 x := v.Args[0] 20385 v.reset(OpARMRSBconst) 20386 v.AuxInt = 0 20387 v.AddArg(x) 20388 return true 20389 } 20390 } 20391 func rewriteValueARM_OpNeq16_0(v *Value) bool { 20392 b := v.Block 20393 _ = b 20394 typ := &b.Func.Config.Types 20395 _ = typ 20396 // match: (Neq16 x y) 20397 // cond: 20398 // result: (NotEqual (CMP (ZeroExt16to32 x) (ZeroExt16to32 y))) 20399 for { 20400 _ = v.Args[1] 20401 x := v.Args[0] 20402 y := v.Args[1] 20403 v.reset(OpARMNotEqual) 20404 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 20405 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 20406 v1.AddArg(x) 20407 v0.AddArg(v1) 20408 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 20409 v2.AddArg(y) 20410 v0.AddArg(v2) 20411 v.AddArg(v0) 20412 return true 20413 } 20414 } 20415 func rewriteValueARM_OpNeq32_0(v *Value) bool { 20416 b := v.Block 20417 _ = b 20418 // match: (Neq32 x y) 20419 // cond: 20420 // result: (NotEqual (CMP x y)) 20421 for { 20422 _ = v.Args[1] 20423 x := v.Args[0] 20424 y := v.Args[1] 20425 v.reset(OpARMNotEqual) 20426 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 20427 v0.AddArg(x) 20428 v0.AddArg(y) 20429 v.AddArg(v0) 20430 return true 20431 } 20432 } 20433 func rewriteValueARM_OpNeq32F_0(v *Value) bool { 20434 b := v.Block 20435 _ = b 20436 // match: (Neq32F x y) 20437 // cond: 20438 // result: (NotEqual (CMPF x y)) 20439 for { 20440 _ = v.Args[1] 20441 x := v.Args[0] 20442 y := v.Args[1] 20443 v.reset(OpARMNotEqual) 20444 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags) 20445 v0.AddArg(x) 20446 v0.AddArg(y) 20447 v.AddArg(v0) 20448 return true 20449 } 20450 } 20451 func rewriteValueARM_OpNeq64F_0(v *Value) bool { 20452 b := v.Block 20453 _ = b 20454 // match: (Neq64F x y) 20455 // cond: 20456 // result: (NotEqual (CMPD x y)) 20457 for { 20458 _ = v.Args[1] 20459 x := v.Args[0] 20460 y := v.Args[1] 20461 v.reset(OpARMNotEqual) 20462 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags) 20463 v0.AddArg(x) 20464 v0.AddArg(y) 20465 v.AddArg(v0) 20466 return true 20467 } 20468 } 20469 func rewriteValueARM_OpNeq8_0(v *Value) bool { 20470 b := v.Block 20471 _ = b 20472 typ := &b.Func.Config.Types 20473 _ = typ 20474 // match: (Neq8 x y) 20475 // cond: 20476 // result: (NotEqual (CMP (ZeroExt8to32 x) (ZeroExt8to32 y))) 20477 for { 20478 _ = v.Args[1] 20479 x := v.Args[0] 20480 y := v.Args[1] 20481 v.reset(OpARMNotEqual) 20482 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 20483 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 20484 v1.AddArg(x) 20485 v0.AddArg(v1) 20486 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 20487 v2.AddArg(y) 20488 v0.AddArg(v2) 20489 v.AddArg(v0) 20490 return true 20491 } 20492 } 20493 func rewriteValueARM_OpNeqB_0(v *Value) bool { 20494 // match: (NeqB x y) 20495 // cond: 20496 // result: (XOR x y) 20497 for { 20498 _ = v.Args[1] 20499 x := v.Args[0] 20500 y := v.Args[1] 20501 v.reset(OpARMXOR) 20502 v.AddArg(x) 20503 v.AddArg(y) 20504 return true 20505 } 20506 } 20507 func rewriteValueARM_OpNeqPtr_0(v *Value) bool { 20508 b := v.Block 20509 _ = b 20510 // match: (NeqPtr x y) 20511 // cond: 20512 // result: (NotEqual (CMP x y)) 20513 for { 20514 _ = v.Args[1] 20515 x := v.Args[0] 20516 y := v.Args[1] 20517 v.reset(OpARMNotEqual) 20518 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 20519 v0.AddArg(x) 20520 v0.AddArg(y) 20521 v.AddArg(v0) 20522 return true 20523 } 20524 } 20525 func rewriteValueARM_OpNilCheck_0(v *Value) bool { 20526 // match: (NilCheck ptr mem) 20527 // cond: 20528 // result: (LoweredNilCheck ptr mem) 20529 for { 20530 _ = v.Args[1] 20531 ptr := v.Args[0] 20532 mem := v.Args[1] 20533 v.reset(OpARMLoweredNilCheck) 20534 v.AddArg(ptr) 20535 v.AddArg(mem) 20536 return true 20537 } 20538 } 20539 func rewriteValueARM_OpNot_0(v *Value) bool { 20540 // match: (Not x) 20541 // cond: 20542 // result: (XORconst [1] x) 20543 for { 20544 x := v.Args[0] 20545 v.reset(OpARMXORconst) 20546 v.AuxInt = 1 20547 v.AddArg(x) 20548 return true 20549 } 20550 } 20551 func rewriteValueARM_OpOffPtr_0(v *Value) bool { 20552 // match: (OffPtr [off] ptr:(SP)) 20553 // cond: 20554 // result: (MOVWaddr [off] ptr) 20555 for { 20556 off := v.AuxInt 20557 ptr := v.Args[0] 20558 if ptr.Op != OpSP { 20559 break 20560 } 20561 v.reset(OpARMMOVWaddr) 20562 v.AuxInt = off 20563 v.AddArg(ptr) 20564 return true 20565 } 20566 // match: (OffPtr [off] ptr) 20567 // cond: 20568 // result: (ADDconst [off] ptr) 20569 for { 20570 off := v.AuxInt 20571 ptr := v.Args[0] 20572 v.reset(OpARMADDconst) 20573 v.AuxInt = off 20574 v.AddArg(ptr) 20575 return true 20576 } 20577 } 20578 func rewriteValueARM_OpOr16_0(v *Value) bool { 20579 // match: (Or16 x y) 20580 // cond: 20581 // result: (OR x y) 20582 for { 20583 _ = v.Args[1] 20584 x := v.Args[0] 20585 y := v.Args[1] 20586 v.reset(OpARMOR) 20587 v.AddArg(x) 20588 v.AddArg(y) 20589 return true 20590 } 20591 } 20592 func rewriteValueARM_OpOr32_0(v *Value) bool { 20593 // match: (Or32 x y) 20594 // cond: 20595 // result: (OR x y) 20596 for { 20597 _ = v.Args[1] 20598 x := v.Args[0] 20599 y := v.Args[1] 20600 v.reset(OpARMOR) 20601 v.AddArg(x) 20602 v.AddArg(y) 20603 return true 20604 } 20605 } 20606 func rewriteValueARM_OpOr8_0(v *Value) bool { 20607 // match: (Or8 x y) 20608 // cond: 20609 // result: (OR x y) 20610 for { 20611 _ = v.Args[1] 20612 x := v.Args[0] 20613 y := v.Args[1] 20614 v.reset(OpARMOR) 20615 v.AddArg(x) 20616 v.AddArg(y) 20617 return true 20618 } 20619 } 20620 func rewriteValueARM_OpOrB_0(v *Value) bool { 20621 // match: (OrB x y) 20622 // cond: 20623 // result: (OR x y) 20624 for { 20625 _ = v.Args[1] 20626 x := v.Args[0] 20627 y := v.Args[1] 20628 v.reset(OpARMOR) 20629 v.AddArg(x) 20630 v.AddArg(y) 20631 return true 20632 } 20633 } 20634 func rewriteValueARM_OpRound32F_0(v *Value) bool { 20635 // match: (Round32F x) 20636 // cond: 20637 // result: x 20638 for { 20639 x := v.Args[0] 20640 v.reset(OpCopy) 20641 v.Type = x.Type 20642 v.AddArg(x) 20643 return true 20644 } 20645 } 20646 func rewriteValueARM_OpRound64F_0(v *Value) bool { 20647 // match: (Round64F x) 20648 // cond: 20649 // result: x 20650 for { 20651 x := v.Args[0] 20652 v.reset(OpCopy) 20653 v.Type = x.Type 20654 v.AddArg(x) 20655 return true 20656 } 20657 } 20658 func rewriteValueARM_OpRsh16Ux16_0(v *Value) bool { 20659 b := v.Block 20660 _ = b 20661 typ := &b.Func.Config.Types 20662 _ = typ 20663 // match: (Rsh16Ux16 x y) 20664 // cond: 20665 // result: (CMOVWHSconst (SRL <x.Type> (ZeroExt16to32 x) (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 20666 for { 20667 _ = v.Args[1] 20668 x := v.Args[0] 20669 y := v.Args[1] 20670 v.reset(OpARMCMOVWHSconst) 20671 v.AuxInt = 0 20672 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 20673 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 20674 v1.AddArg(x) 20675 v0.AddArg(v1) 20676 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 20677 v2.AddArg(y) 20678 v0.AddArg(v2) 20679 v.AddArg(v0) 20680 v3 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 20681 v3.AuxInt = 256 20682 v4 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 20683 v4.AddArg(y) 20684 v3.AddArg(v4) 20685 v.AddArg(v3) 20686 return true 20687 } 20688 } 20689 func rewriteValueARM_OpRsh16Ux32_0(v *Value) bool { 20690 b := v.Block 20691 _ = b 20692 typ := &b.Func.Config.Types 20693 _ = typ 20694 // match: (Rsh16Ux32 x y) 20695 // cond: 20696 // result: (CMOVWHSconst (SRL <x.Type> (ZeroExt16to32 x) y) (CMPconst [256] y) [0]) 20697 for { 20698 _ = v.Args[1] 20699 x := v.Args[0] 20700 y := v.Args[1] 20701 v.reset(OpARMCMOVWHSconst) 20702 v.AuxInt = 0 20703 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 20704 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 20705 v1.AddArg(x) 20706 v0.AddArg(v1) 20707 v0.AddArg(y) 20708 v.AddArg(v0) 20709 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 20710 v2.AuxInt = 256 20711 v2.AddArg(y) 20712 v.AddArg(v2) 20713 return true 20714 } 20715 } 20716 func rewriteValueARM_OpRsh16Ux64_0(v *Value) bool { 20717 b := v.Block 20718 _ = b 20719 typ := &b.Func.Config.Types 20720 _ = typ 20721 // match: (Rsh16Ux64 x (Const64 [c])) 20722 // cond: uint64(c) < 16 20723 // result: (SRLconst (SLLconst <typ.UInt32> x [16]) [c+16]) 20724 for { 20725 _ = v.Args[1] 20726 x := v.Args[0] 20727 v_1 := v.Args[1] 20728 if v_1.Op != OpConst64 { 20729 break 20730 } 20731 c := v_1.AuxInt 20732 if !(uint64(c) < 16) { 20733 break 20734 } 20735 v.reset(OpARMSRLconst) 20736 v.AuxInt = c + 16 20737 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32) 20738 v0.AuxInt = 16 20739 v0.AddArg(x) 20740 v.AddArg(v0) 20741 return true 20742 } 20743 // match: (Rsh16Ux64 _ (Const64 [c])) 20744 // cond: uint64(c) >= 16 20745 // result: (Const16 [0]) 20746 for { 20747 _ = v.Args[1] 20748 v_1 := v.Args[1] 20749 if v_1.Op != OpConst64 { 20750 break 20751 } 20752 c := v_1.AuxInt 20753 if !(uint64(c) >= 16) { 20754 break 20755 } 20756 v.reset(OpConst16) 20757 v.AuxInt = 0 20758 return true 20759 } 20760 return false 20761 } 20762 func rewriteValueARM_OpRsh16Ux8_0(v *Value) bool { 20763 b := v.Block 20764 _ = b 20765 typ := &b.Func.Config.Types 20766 _ = typ 20767 // match: (Rsh16Ux8 x y) 20768 // cond: 20769 // result: (SRL (ZeroExt16to32 x) (ZeroExt8to32 y)) 20770 for { 20771 _ = v.Args[1] 20772 x := v.Args[0] 20773 y := v.Args[1] 20774 v.reset(OpARMSRL) 20775 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 20776 v0.AddArg(x) 20777 v.AddArg(v0) 20778 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 20779 v1.AddArg(y) 20780 v.AddArg(v1) 20781 return true 20782 } 20783 } 20784 func rewriteValueARM_OpRsh16x16_0(v *Value) bool { 20785 b := v.Block 20786 _ = b 20787 typ := &b.Func.Config.Types 20788 _ = typ 20789 // match: (Rsh16x16 x y) 20790 // cond: 20791 // result: (SRAcond (SignExt16to32 x) (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y))) 20792 for { 20793 _ = v.Args[1] 20794 x := v.Args[0] 20795 y := v.Args[1] 20796 v.reset(OpARMSRAcond) 20797 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 20798 v0.AddArg(x) 20799 v.AddArg(v0) 20800 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 20801 v1.AddArg(y) 20802 v.AddArg(v1) 20803 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 20804 v2.AuxInt = 256 20805 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 20806 v3.AddArg(y) 20807 v2.AddArg(v3) 20808 v.AddArg(v2) 20809 return true 20810 } 20811 } 20812 func rewriteValueARM_OpRsh16x32_0(v *Value) bool { 20813 b := v.Block 20814 _ = b 20815 typ := &b.Func.Config.Types 20816 _ = typ 20817 // match: (Rsh16x32 x y) 20818 // cond: 20819 // result: (SRAcond (SignExt16to32 x) y (CMPconst [256] y)) 20820 for { 20821 _ = v.Args[1] 20822 x := v.Args[0] 20823 y := v.Args[1] 20824 v.reset(OpARMSRAcond) 20825 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 20826 v0.AddArg(x) 20827 v.AddArg(v0) 20828 v.AddArg(y) 20829 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 20830 v1.AuxInt = 256 20831 v1.AddArg(y) 20832 v.AddArg(v1) 20833 return true 20834 } 20835 } 20836 func rewriteValueARM_OpRsh16x64_0(v *Value) bool { 20837 b := v.Block 20838 _ = b 20839 typ := &b.Func.Config.Types 20840 _ = typ 20841 // match: (Rsh16x64 x (Const64 [c])) 20842 // cond: uint64(c) < 16 20843 // result: (SRAconst (SLLconst <typ.UInt32> x [16]) [c+16]) 20844 for { 20845 _ = v.Args[1] 20846 x := v.Args[0] 20847 v_1 := v.Args[1] 20848 if v_1.Op != OpConst64 { 20849 break 20850 } 20851 c := v_1.AuxInt 20852 if !(uint64(c) < 16) { 20853 break 20854 } 20855 v.reset(OpARMSRAconst) 20856 v.AuxInt = c + 16 20857 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32) 20858 v0.AuxInt = 16 20859 v0.AddArg(x) 20860 v.AddArg(v0) 20861 return true 20862 } 20863 // match: (Rsh16x64 x (Const64 [c])) 20864 // cond: uint64(c) >= 16 20865 // result: (SRAconst (SLLconst <typ.UInt32> x [16]) [31]) 20866 for { 20867 _ = v.Args[1] 20868 x := v.Args[0] 20869 v_1 := v.Args[1] 20870 if v_1.Op != OpConst64 { 20871 break 20872 } 20873 c := v_1.AuxInt 20874 if !(uint64(c) >= 16) { 20875 break 20876 } 20877 v.reset(OpARMSRAconst) 20878 v.AuxInt = 31 20879 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32) 20880 v0.AuxInt = 16 20881 v0.AddArg(x) 20882 v.AddArg(v0) 20883 return true 20884 } 20885 return false 20886 } 20887 func rewriteValueARM_OpRsh16x8_0(v *Value) bool { 20888 b := v.Block 20889 _ = b 20890 typ := &b.Func.Config.Types 20891 _ = typ 20892 // match: (Rsh16x8 x y) 20893 // cond: 20894 // result: (SRA (SignExt16to32 x) (ZeroExt8to32 y)) 20895 for { 20896 _ = v.Args[1] 20897 x := v.Args[0] 20898 y := v.Args[1] 20899 v.reset(OpARMSRA) 20900 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 20901 v0.AddArg(x) 20902 v.AddArg(v0) 20903 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 20904 v1.AddArg(y) 20905 v.AddArg(v1) 20906 return true 20907 } 20908 } 20909 func rewriteValueARM_OpRsh32Ux16_0(v *Value) bool { 20910 b := v.Block 20911 _ = b 20912 typ := &b.Func.Config.Types 20913 _ = typ 20914 // match: (Rsh32Ux16 x y) 20915 // cond: 20916 // result: (CMOVWHSconst (SRL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 20917 for { 20918 _ = v.Args[1] 20919 x := v.Args[0] 20920 y := v.Args[1] 20921 v.reset(OpARMCMOVWHSconst) 20922 v.AuxInt = 0 20923 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 20924 v0.AddArg(x) 20925 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 20926 v1.AddArg(y) 20927 v0.AddArg(v1) 20928 v.AddArg(v0) 20929 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 20930 v2.AuxInt = 256 20931 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 20932 v3.AddArg(y) 20933 v2.AddArg(v3) 20934 v.AddArg(v2) 20935 return true 20936 } 20937 } 20938 func rewriteValueARM_OpRsh32Ux32_0(v *Value) bool { 20939 b := v.Block 20940 _ = b 20941 // match: (Rsh32Ux32 x y) 20942 // cond: 20943 // result: (CMOVWHSconst (SRL <x.Type> x y) (CMPconst [256] y) [0]) 20944 for { 20945 _ = v.Args[1] 20946 x := v.Args[0] 20947 y := v.Args[1] 20948 v.reset(OpARMCMOVWHSconst) 20949 v.AuxInt = 0 20950 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 20951 v0.AddArg(x) 20952 v0.AddArg(y) 20953 v.AddArg(v0) 20954 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 20955 v1.AuxInt = 256 20956 v1.AddArg(y) 20957 v.AddArg(v1) 20958 return true 20959 } 20960 } 20961 func rewriteValueARM_OpRsh32Ux64_0(v *Value) bool { 20962 // match: (Rsh32Ux64 x (Const64 [c])) 20963 // cond: uint64(c) < 32 20964 // result: (SRLconst x [c]) 20965 for { 20966 _ = v.Args[1] 20967 x := v.Args[0] 20968 v_1 := v.Args[1] 20969 if v_1.Op != OpConst64 { 20970 break 20971 } 20972 c := v_1.AuxInt 20973 if !(uint64(c) < 32) { 20974 break 20975 } 20976 v.reset(OpARMSRLconst) 20977 v.AuxInt = c 20978 v.AddArg(x) 20979 return true 20980 } 20981 // match: (Rsh32Ux64 _ (Const64 [c])) 20982 // cond: uint64(c) >= 32 20983 // result: (Const32 [0]) 20984 for { 20985 _ = v.Args[1] 20986 v_1 := v.Args[1] 20987 if v_1.Op != OpConst64 { 20988 break 20989 } 20990 c := v_1.AuxInt 20991 if !(uint64(c) >= 32) { 20992 break 20993 } 20994 v.reset(OpConst32) 20995 v.AuxInt = 0 20996 return true 20997 } 20998 return false 20999 } 21000 func rewriteValueARM_OpRsh32Ux8_0(v *Value) bool { 21001 b := v.Block 21002 _ = b 21003 typ := &b.Func.Config.Types 21004 _ = typ 21005 // match: (Rsh32Ux8 x y) 21006 // cond: 21007 // result: (SRL x (ZeroExt8to32 y)) 21008 for { 21009 _ = v.Args[1] 21010 x := v.Args[0] 21011 y := v.Args[1] 21012 v.reset(OpARMSRL) 21013 v.AddArg(x) 21014 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 21015 v0.AddArg(y) 21016 v.AddArg(v0) 21017 return true 21018 } 21019 } 21020 func rewriteValueARM_OpRsh32x16_0(v *Value) bool { 21021 b := v.Block 21022 _ = b 21023 typ := &b.Func.Config.Types 21024 _ = typ 21025 // match: (Rsh32x16 x y) 21026 // cond: 21027 // result: (SRAcond x (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y))) 21028 for { 21029 _ = v.Args[1] 21030 x := v.Args[0] 21031 y := v.Args[1] 21032 v.reset(OpARMSRAcond) 21033 v.AddArg(x) 21034 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 21035 v0.AddArg(y) 21036 v.AddArg(v0) 21037 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 21038 v1.AuxInt = 256 21039 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 21040 v2.AddArg(y) 21041 v1.AddArg(v2) 21042 v.AddArg(v1) 21043 return true 21044 } 21045 } 21046 func rewriteValueARM_OpRsh32x32_0(v *Value) bool { 21047 b := v.Block 21048 _ = b 21049 // match: (Rsh32x32 x y) 21050 // cond: 21051 // result: (SRAcond x y (CMPconst [256] y)) 21052 for { 21053 _ = v.Args[1] 21054 x := v.Args[0] 21055 y := v.Args[1] 21056 v.reset(OpARMSRAcond) 21057 v.AddArg(x) 21058 v.AddArg(y) 21059 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 21060 v0.AuxInt = 256 21061 v0.AddArg(y) 21062 v.AddArg(v0) 21063 return true 21064 } 21065 } 21066 func rewriteValueARM_OpRsh32x64_0(v *Value) bool { 21067 // match: (Rsh32x64 x (Const64 [c])) 21068 // cond: uint64(c) < 32 21069 // result: (SRAconst x [c]) 21070 for { 21071 _ = v.Args[1] 21072 x := v.Args[0] 21073 v_1 := v.Args[1] 21074 if v_1.Op != OpConst64 { 21075 break 21076 } 21077 c := v_1.AuxInt 21078 if !(uint64(c) < 32) { 21079 break 21080 } 21081 v.reset(OpARMSRAconst) 21082 v.AuxInt = c 21083 v.AddArg(x) 21084 return true 21085 } 21086 // match: (Rsh32x64 x (Const64 [c])) 21087 // cond: uint64(c) >= 32 21088 // result: (SRAconst x [31]) 21089 for { 21090 _ = v.Args[1] 21091 x := v.Args[0] 21092 v_1 := v.Args[1] 21093 if v_1.Op != OpConst64 { 21094 break 21095 } 21096 c := v_1.AuxInt 21097 if !(uint64(c) >= 32) { 21098 break 21099 } 21100 v.reset(OpARMSRAconst) 21101 v.AuxInt = 31 21102 v.AddArg(x) 21103 return true 21104 } 21105 return false 21106 } 21107 func rewriteValueARM_OpRsh32x8_0(v *Value) bool { 21108 b := v.Block 21109 _ = b 21110 typ := &b.Func.Config.Types 21111 _ = typ 21112 // match: (Rsh32x8 x y) 21113 // cond: 21114 // result: (SRA x (ZeroExt8to32 y)) 21115 for { 21116 _ = v.Args[1] 21117 x := v.Args[0] 21118 y := v.Args[1] 21119 v.reset(OpARMSRA) 21120 v.AddArg(x) 21121 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 21122 v0.AddArg(y) 21123 v.AddArg(v0) 21124 return true 21125 } 21126 } 21127 func rewriteValueARM_OpRsh8Ux16_0(v *Value) bool { 21128 b := v.Block 21129 _ = b 21130 typ := &b.Func.Config.Types 21131 _ = typ 21132 // match: (Rsh8Ux16 x y) 21133 // cond: 21134 // result: (CMOVWHSconst (SRL <x.Type> (ZeroExt8to32 x) (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0]) 21135 for { 21136 _ = v.Args[1] 21137 x := v.Args[0] 21138 y := v.Args[1] 21139 v.reset(OpARMCMOVWHSconst) 21140 v.AuxInt = 0 21141 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 21142 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 21143 v1.AddArg(x) 21144 v0.AddArg(v1) 21145 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 21146 v2.AddArg(y) 21147 v0.AddArg(v2) 21148 v.AddArg(v0) 21149 v3 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 21150 v3.AuxInt = 256 21151 v4 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 21152 v4.AddArg(y) 21153 v3.AddArg(v4) 21154 v.AddArg(v3) 21155 return true 21156 } 21157 } 21158 func rewriteValueARM_OpRsh8Ux32_0(v *Value) bool { 21159 b := v.Block 21160 _ = b 21161 typ := &b.Func.Config.Types 21162 _ = typ 21163 // match: (Rsh8Ux32 x y) 21164 // cond: 21165 // result: (CMOVWHSconst (SRL <x.Type> (ZeroExt8to32 x) y) (CMPconst [256] y) [0]) 21166 for { 21167 _ = v.Args[1] 21168 x := v.Args[0] 21169 y := v.Args[1] 21170 v.reset(OpARMCMOVWHSconst) 21171 v.AuxInt = 0 21172 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type) 21173 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 21174 v1.AddArg(x) 21175 v0.AddArg(v1) 21176 v0.AddArg(y) 21177 v.AddArg(v0) 21178 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 21179 v2.AuxInt = 256 21180 v2.AddArg(y) 21181 v.AddArg(v2) 21182 return true 21183 } 21184 } 21185 func rewriteValueARM_OpRsh8Ux64_0(v *Value) bool { 21186 b := v.Block 21187 _ = b 21188 typ := &b.Func.Config.Types 21189 _ = typ 21190 // match: (Rsh8Ux64 x (Const64 [c])) 21191 // cond: uint64(c) < 8 21192 // result: (SRLconst (SLLconst <typ.UInt32> x [24]) [c+24]) 21193 for { 21194 _ = v.Args[1] 21195 x := v.Args[0] 21196 v_1 := v.Args[1] 21197 if v_1.Op != OpConst64 { 21198 break 21199 } 21200 c := v_1.AuxInt 21201 if !(uint64(c) < 8) { 21202 break 21203 } 21204 v.reset(OpARMSRLconst) 21205 v.AuxInt = c + 24 21206 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32) 21207 v0.AuxInt = 24 21208 v0.AddArg(x) 21209 v.AddArg(v0) 21210 return true 21211 } 21212 // match: (Rsh8Ux64 _ (Const64 [c])) 21213 // cond: uint64(c) >= 8 21214 // result: (Const8 [0]) 21215 for { 21216 _ = v.Args[1] 21217 v_1 := v.Args[1] 21218 if v_1.Op != OpConst64 { 21219 break 21220 } 21221 c := v_1.AuxInt 21222 if !(uint64(c) >= 8) { 21223 break 21224 } 21225 v.reset(OpConst8) 21226 v.AuxInt = 0 21227 return true 21228 } 21229 return false 21230 } 21231 func rewriteValueARM_OpRsh8Ux8_0(v *Value) bool { 21232 b := v.Block 21233 _ = b 21234 typ := &b.Func.Config.Types 21235 _ = typ 21236 // match: (Rsh8Ux8 x y) 21237 // cond: 21238 // result: (SRL (ZeroExt8to32 x) (ZeroExt8to32 y)) 21239 for { 21240 _ = v.Args[1] 21241 x := v.Args[0] 21242 y := v.Args[1] 21243 v.reset(OpARMSRL) 21244 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 21245 v0.AddArg(x) 21246 v.AddArg(v0) 21247 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 21248 v1.AddArg(y) 21249 v.AddArg(v1) 21250 return true 21251 } 21252 } 21253 func rewriteValueARM_OpRsh8x16_0(v *Value) bool { 21254 b := v.Block 21255 _ = b 21256 typ := &b.Func.Config.Types 21257 _ = typ 21258 // match: (Rsh8x16 x y) 21259 // cond: 21260 // result: (SRAcond (SignExt8to32 x) (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y))) 21261 for { 21262 _ = v.Args[1] 21263 x := v.Args[0] 21264 y := v.Args[1] 21265 v.reset(OpARMSRAcond) 21266 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 21267 v0.AddArg(x) 21268 v.AddArg(v0) 21269 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 21270 v1.AddArg(y) 21271 v.AddArg(v1) 21272 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 21273 v2.AuxInt = 256 21274 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 21275 v3.AddArg(y) 21276 v2.AddArg(v3) 21277 v.AddArg(v2) 21278 return true 21279 } 21280 } 21281 func rewriteValueARM_OpRsh8x32_0(v *Value) bool { 21282 b := v.Block 21283 _ = b 21284 typ := &b.Func.Config.Types 21285 _ = typ 21286 // match: (Rsh8x32 x y) 21287 // cond: 21288 // result: (SRAcond (SignExt8to32 x) y (CMPconst [256] y)) 21289 for { 21290 _ = v.Args[1] 21291 x := v.Args[0] 21292 y := v.Args[1] 21293 v.reset(OpARMSRAcond) 21294 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 21295 v0.AddArg(x) 21296 v.AddArg(v0) 21297 v.AddArg(y) 21298 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 21299 v1.AuxInt = 256 21300 v1.AddArg(y) 21301 v.AddArg(v1) 21302 return true 21303 } 21304 } 21305 func rewriteValueARM_OpRsh8x64_0(v *Value) bool { 21306 b := v.Block 21307 _ = b 21308 typ := &b.Func.Config.Types 21309 _ = typ 21310 // match: (Rsh8x64 x (Const64 [c])) 21311 // cond: uint64(c) < 8 21312 // result: (SRAconst (SLLconst <typ.UInt32> x [24]) [c+24]) 21313 for { 21314 _ = v.Args[1] 21315 x := v.Args[0] 21316 v_1 := v.Args[1] 21317 if v_1.Op != OpConst64 { 21318 break 21319 } 21320 c := v_1.AuxInt 21321 if !(uint64(c) < 8) { 21322 break 21323 } 21324 v.reset(OpARMSRAconst) 21325 v.AuxInt = c + 24 21326 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32) 21327 v0.AuxInt = 24 21328 v0.AddArg(x) 21329 v.AddArg(v0) 21330 return true 21331 } 21332 // match: (Rsh8x64 x (Const64 [c])) 21333 // cond: uint64(c) >= 8 21334 // result: (SRAconst (SLLconst <typ.UInt32> x [24]) [31]) 21335 for { 21336 _ = v.Args[1] 21337 x := v.Args[0] 21338 v_1 := v.Args[1] 21339 if v_1.Op != OpConst64 { 21340 break 21341 } 21342 c := v_1.AuxInt 21343 if !(uint64(c) >= 8) { 21344 break 21345 } 21346 v.reset(OpARMSRAconst) 21347 v.AuxInt = 31 21348 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32) 21349 v0.AuxInt = 24 21350 v0.AddArg(x) 21351 v.AddArg(v0) 21352 return true 21353 } 21354 return false 21355 } 21356 func rewriteValueARM_OpRsh8x8_0(v *Value) bool { 21357 b := v.Block 21358 _ = b 21359 typ := &b.Func.Config.Types 21360 _ = typ 21361 // match: (Rsh8x8 x y) 21362 // cond: 21363 // result: (SRA (SignExt8to32 x) (ZeroExt8to32 y)) 21364 for { 21365 _ = v.Args[1] 21366 x := v.Args[0] 21367 y := v.Args[1] 21368 v.reset(OpARMSRA) 21369 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 21370 v0.AddArg(x) 21371 v.AddArg(v0) 21372 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 21373 v1.AddArg(y) 21374 v.AddArg(v1) 21375 return true 21376 } 21377 } 21378 func rewriteValueARM_OpSelect0_0(v *Value) bool { 21379 // match: (Select0 (CALLudiv x (MOVWconst [1]))) 21380 // cond: 21381 // result: x 21382 for { 21383 v_0 := v.Args[0] 21384 if v_0.Op != OpARMCALLudiv { 21385 break 21386 } 21387 _ = v_0.Args[1] 21388 x := v_0.Args[0] 21389 v_0_1 := v_0.Args[1] 21390 if v_0_1.Op != OpARMMOVWconst { 21391 break 21392 } 21393 if v_0_1.AuxInt != 1 { 21394 break 21395 } 21396 v.reset(OpCopy) 21397 v.Type = x.Type 21398 v.AddArg(x) 21399 return true 21400 } 21401 // match: (Select0 (CALLudiv x (MOVWconst [c]))) 21402 // cond: isPowerOfTwo(c) 21403 // result: (SRLconst [log2(c)] x) 21404 for { 21405 v_0 := v.Args[0] 21406 if v_0.Op != OpARMCALLudiv { 21407 break 21408 } 21409 _ = v_0.Args[1] 21410 x := v_0.Args[0] 21411 v_0_1 := v_0.Args[1] 21412 if v_0_1.Op != OpARMMOVWconst { 21413 break 21414 } 21415 c := v_0_1.AuxInt 21416 if !(isPowerOfTwo(c)) { 21417 break 21418 } 21419 v.reset(OpARMSRLconst) 21420 v.AuxInt = log2(c) 21421 v.AddArg(x) 21422 return true 21423 } 21424 // match: (Select0 (CALLudiv (MOVWconst [c]) (MOVWconst [d]))) 21425 // cond: 21426 // result: (MOVWconst [int64(int32(uint32(c)/uint32(d)))]) 21427 for { 21428 v_0 := v.Args[0] 21429 if v_0.Op != OpARMCALLudiv { 21430 break 21431 } 21432 _ = v_0.Args[1] 21433 v_0_0 := v_0.Args[0] 21434 if v_0_0.Op != OpARMMOVWconst { 21435 break 21436 } 21437 c := v_0_0.AuxInt 21438 v_0_1 := v_0.Args[1] 21439 if v_0_1.Op != OpARMMOVWconst { 21440 break 21441 } 21442 d := v_0_1.AuxInt 21443 v.reset(OpARMMOVWconst) 21444 v.AuxInt = int64(int32(uint32(c) / uint32(d))) 21445 return true 21446 } 21447 return false 21448 } 21449 func rewriteValueARM_OpSelect1_0(v *Value) bool { 21450 // match: (Select1 (CALLudiv _ (MOVWconst [1]))) 21451 // cond: 21452 // result: (MOVWconst [0]) 21453 for { 21454 v_0 := v.Args[0] 21455 if v_0.Op != OpARMCALLudiv { 21456 break 21457 } 21458 _ = v_0.Args[1] 21459 v_0_1 := v_0.Args[1] 21460 if v_0_1.Op != OpARMMOVWconst { 21461 break 21462 } 21463 if v_0_1.AuxInt != 1 { 21464 break 21465 } 21466 v.reset(OpARMMOVWconst) 21467 v.AuxInt = 0 21468 return true 21469 } 21470 // match: (Select1 (CALLudiv x (MOVWconst [c]))) 21471 // cond: isPowerOfTwo(c) 21472 // result: (ANDconst [c-1] x) 21473 for { 21474 v_0 := v.Args[0] 21475 if v_0.Op != OpARMCALLudiv { 21476 break 21477 } 21478 _ = v_0.Args[1] 21479 x := v_0.Args[0] 21480 v_0_1 := v_0.Args[1] 21481 if v_0_1.Op != OpARMMOVWconst { 21482 break 21483 } 21484 c := v_0_1.AuxInt 21485 if !(isPowerOfTwo(c)) { 21486 break 21487 } 21488 v.reset(OpARMANDconst) 21489 v.AuxInt = c - 1 21490 v.AddArg(x) 21491 return true 21492 } 21493 // match: (Select1 (CALLudiv (MOVWconst [c]) (MOVWconst [d]))) 21494 // cond: 21495 // result: (MOVWconst [int64(int32(uint32(c)%uint32(d)))]) 21496 for { 21497 v_0 := v.Args[0] 21498 if v_0.Op != OpARMCALLudiv { 21499 break 21500 } 21501 _ = v_0.Args[1] 21502 v_0_0 := v_0.Args[0] 21503 if v_0_0.Op != OpARMMOVWconst { 21504 break 21505 } 21506 c := v_0_0.AuxInt 21507 v_0_1 := v_0.Args[1] 21508 if v_0_1.Op != OpARMMOVWconst { 21509 break 21510 } 21511 d := v_0_1.AuxInt 21512 v.reset(OpARMMOVWconst) 21513 v.AuxInt = int64(int32(uint32(c) % uint32(d))) 21514 return true 21515 } 21516 return false 21517 } 21518 func rewriteValueARM_OpSignExt16to32_0(v *Value) bool { 21519 // match: (SignExt16to32 x) 21520 // cond: 21521 // result: (MOVHreg x) 21522 for { 21523 x := v.Args[0] 21524 v.reset(OpARMMOVHreg) 21525 v.AddArg(x) 21526 return true 21527 } 21528 } 21529 func rewriteValueARM_OpSignExt8to16_0(v *Value) bool { 21530 // match: (SignExt8to16 x) 21531 // cond: 21532 // result: (MOVBreg x) 21533 for { 21534 x := v.Args[0] 21535 v.reset(OpARMMOVBreg) 21536 v.AddArg(x) 21537 return true 21538 } 21539 } 21540 func rewriteValueARM_OpSignExt8to32_0(v *Value) bool { 21541 // match: (SignExt8to32 x) 21542 // cond: 21543 // result: (MOVBreg x) 21544 for { 21545 x := v.Args[0] 21546 v.reset(OpARMMOVBreg) 21547 v.AddArg(x) 21548 return true 21549 } 21550 } 21551 func rewriteValueARM_OpSignmask_0(v *Value) bool { 21552 // match: (Signmask x) 21553 // cond: 21554 // result: (SRAconst x [31]) 21555 for { 21556 x := v.Args[0] 21557 v.reset(OpARMSRAconst) 21558 v.AuxInt = 31 21559 v.AddArg(x) 21560 return true 21561 } 21562 } 21563 func rewriteValueARM_OpSlicemask_0(v *Value) bool { 21564 b := v.Block 21565 _ = b 21566 // match: (Slicemask <t> x) 21567 // cond: 21568 // result: (SRAconst (RSBconst <t> [0] x) [31]) 21569 for { 21570 t := v.Type 21571 x := v.Args[0] 21572 v.reset(OpARMSRAconst) 21573 v.AuxInt = 31 21574 v0 := b.NewValue0(v.Pos, OpARMRSBconst, t) 21575 v0.AuxInt = 0 21576 v0.AddArg(x) 21577 v.AddArg(v0) 21578 return true 21579 } 21580 } 21581 func rewriteValueARM_OpSqrt_0(v *Value) bool { 21582 // match: (Sqrt x) 21583 // cond: 21584 // result: (SQRTD x) 21585 for { 21586 x := v.Args[0] 21587 v.reset(OpARMSQRTD) 21588 v.AddArg(x) 21589 return true 21590 } 21591 } 21592 func rewriteValueARM_OpStaticCall_0(v *Value) bool { 21593 // match: (StaticCall [argwid] {target} mem) 21594 // cond: 21595 // result: (CALLstatic [argwid] {target} mem) 21596 for { 21597 argwid := v.AuxInt 21598 target := v.Aux 21599 mem := v.Args[0] 21600 v.reset(OpARMCALLstatic) 21601 v.AuxInt = argwid 21602 v.Aux = target 21603 v.AddArg(mem) 21604 return true 21605 } 21606 } 21607 func rewriteValueARM_OpStore_0(v *Value) bool { 21608 // match: (Store {t} ptr val mem) 21609 // cond: t.(*types.Type).Size() == 1 21610 // result: (MOVBstore ptr val mem) 21611 for { 21612 t := v.Aux 21613 _ = v.Args[2] 21614 ptr := v.Args[0] 21615 val := v.Args[1] 21616 mem := v.Args[2] 21617 if !(t.(*types.Type).Size() == 1) { 21618 break 21619 } 21620 v.reset(OpARMMOVBstore) 21621 v.AddArg(ptr) 21622 v.AddArg(val) 21623 v.AddArg(mem) 21624 return true 21625 } 21626 // match: (Store {t} ptr val mem) 21627 // cond: t.(*types.Type).Size() == 2 21628 // result: (MOVHstore ptr val mem) 21629 for { 21630 t := v.Aux 21631 _ = v.Args[2] 21632 ptr := v.Args[0] 21633 val := v.Args[1] 21634 mem := v.Args[2] 21635 if !(t.(*types.Type).Size() == 2) { 21636 break 21637 } 21638 v.reset(OpARMMOVHstore) 21639 v.AddArg(ptr) 21640 v.AddArg(val) 21641 v.AddArg(mem) 21642 return true 21643 } 21644 // match: (Store {t} ptr val mem) 21645 // cond: t.(*types.Type).Size() == 4 && !is32BitFloat(val.Type) 21646 // result: (MOVWstore ptr val mem) 21647 for { 21648 t := v.Aux 21649 _ = v.Args[2] 21650 ptr := v.Args[0] 21651 val := v.Args[1] 21652 mem := v.Args[2] 21653 if !(t.(*types.Type).Size() == 4 && !is32BitFloat(val.Type)) { 21654 break 21655 } 21656 v.reset(OpARMMOVWstore) 21657 v.AddArg(ptr) 21658 v.AddArg(val) 21659 v.AddArg(mem) 21660 return true 21661 } 21662 // match: (Store {t} ptr val mem) 21663 // cond: t.(*types.Type).Size() == 4 && is32BitFloat(val.Type) 21664 // result: (MOVFstore ptr val mem) 21665 for { 21666 t := v.Aux 21667 _ = v.Args[2] 21668 ptr := v.Args[0] 21669 val := v.Args[1] 21670 mem := v.Args[2] 21671 if !(t.(*types.Type).Size() == 4 && is32BitFloat(val.Type)) { 21672 break 21673 } 21674 v.reset(OpARMMOVFstore) 21675 v.AddArg(ptr) 21676 v.AddArg(val) 21677 v.AddArg(mem) 21678 return true 21679 } 21680 // match: (Store {t} ptr val mem) 21681 // cond: t.(*types.Type).Size() == 8 && is64BitFloat(val.Type) 21682 // result: (MOVDstore ptr val mem) 21683 for { 21684 t := v.Aux 21685 _ = v.Args[2] 21686 ptr := v.Args[0] 21687 val := v.Args[1] 21688 mem := v.Args[2] 21689 if !(t.(*types.Type).Size() == 8 && is64BitFloat(val.Type)) { 21690 break 21691 } 21692 v.reset(OpARMMOVDstore) 21693 v.AddArg(ptr) 21694 v.AddArg(val) 21695 v.AddArg(mem) 21696 return true 21697 } 21698 return false 21699 } 21700 func rewriteValueARM_OpSub16_0(v *Value) bool { 21701 // match: (Sub16 x y) 21702 // cond: 21703 // result: (SUB x y) 21704 for { 21705 _ = v.Args[1] 21706 x := v.Args[0] 21707 y := v.Args[1] 21708 v.reset(OpARMSUB) 21709 v.AddArg(x) 21710 v.AddArg(y) 21711 return true 21712 } 21713 } 21714 func rewriteValueARM_OpSub32_0(v *Value) bool { 21715 // match: (Sub32 x y) 21716 // cond: 21717 // result: (SUB x y) 21718 for { 21719 _ = v.Args[1] 21720 x := v.Args[0] 21721 y := v.Args[1] 21722 v.reset(OpARMSUB) 21723 v.AddArg(x) 21724 v.AddArg(y) 21725 return true 21726 } 21727 } 21728 func rewriteValueARM_OpSub32F_0(v *Value) bool { 21729 // match: (Sub32F x y) 21730 // cond: 21731 // result: (SUBF x y) 21732 for { 21733 _ = v.Args[1] 21734 x := v.Args[0] 21735 y := v.Args[1] 21736 v.reset(OpARMSUBF) 21737 v.AddArg(x) 21738 v.AddArg(y) 21739 return true 21740 } 21741 } 21742 func rewriteValueARM_OpSub32carry_0(v *Value) bool { 21743 // match: (Sub32carry x y) 21744 // cond: 21745 // result: (SUBS x y) 21746 for { 21747 _ = v.Args[1] 21748 x := v.Args[0] 21749 y := v.Args[1] 21750 v.reset(OpARMSUBS) 21751 v.AddArg(x) 21752 v.AddArg(y) 21753 return true 21754 } 21755 } 21756 func rewriteValueARM_OpSub32withcarry_0(v *Value) bool { 21757 // match: (Sub32withcarry x y c) 21758 // cond: 21759 // result: (SBC x y c) 21760 for { 21761 _ = v.Args[2] 21762 x := v.Args[0] 21763 y := v.Args[1] 21764 c := v.Args[2] 21765 v.reset(OpARMSBC) 21766 v.AddArg(x) 21767 v.AddArg(y) 21768 v.AddArg(c) 21769 return true 21770 } 21771 } 21772 func rewriteValueARM_OpSub64F_0(v *Value) bool { 21773 // match: (Sub64F x y) 21774 // cond: 21775 // result: (SUBD x y) 21776 for { 21777 _ = v.Args[1] 21778 x := v.Args[0] 21779 y := v.Args[1] 21780 v.reset(OpARMSUBD) 21781 v.AddArg(x) 21782 v.AddArg(y) 21783 return true 21784 } 21785 } 21786 func rewriteValueARM_OpSub8_0(v *Value) bool { 21787 // match: (Sub8 x y) 21788 // cond: 21789 // result: (SUB x y) 21790 for { 21791 _ = v.Args[1] 21792 x := v.Args[0] 21793 y := v.Args[1] 21794 v.reset(OpARMSUB) 21795 v.AddArg(x) 21796 v.AddArg(y) 21797 return true 21798 } 21799 } 21800 func rewriteValueARM_OpSubPtr_0(v *Value) bool { 21801 // match: (SubPtr x y) 21802 // cond: 21803 // result: (SUB x y) 21804 for { 21805 _ = v.Args[1] 21806 x := v.Args[0] 21807 y := v.Args[1] 21808 v.reset(OpARMSUB) 21809 v.AddArg(x) 21810 v.AddArg(y) 21811 return true 21812 } 21813 } 21814 func rewriteValueARM_OpTrunc16to8_0(v *Value) bool { 21815 // match: (Trunc16to8 x) 21816 // cond: 21817 // result: x 21818 for { 21819 x := v.Args[0] 21820 v.reset(OpCopy) 21821 v.Type = x.Type 21822 v.AddArg(x) 21823 return true 21824 } 21825 } 21826 func rewriteValueARM_OpTrunc32to16_0(v *Value) bool { 21827 // match: (Trunc32to16 x) 21828 // cond: 21829 // result: x 21830 for { 21831 x := v.Args[0] 21832 v.reset(OpCopy) 21833 v.Type = x.Type 21834 v.AddArg(x) 21835 return true 21836 } 21837 } 21838 func rewriteValueARM_OpTrunc32to8_0(v *Value) bool { 21839 // match: (Trunc32to8 x) 21840 // cond: 21841 // result: x 21842 for { 21843 x := v.Args[0] 21844 v.reset(OpCopy) 21845 v.Type = x.Type 21846 v.AddArg(x) 21847 return true 21848 } 21849 } 21850 func rewriteValueARM_OpWB_0(v *Value) bool { 21851 // match: (WB {fn} destptr srcptr mem) 21852 // cond: 21853 // result: (LoweredWB {fn} destptr srcptr mem) 21854 for { 21855 fn := v.Aux 21856 _ = v.Args[2] 21857 destptr := v.Args[0] 21858 srcptr := v.Args[1] 21859 mem := v.Args[2] 21860 v.reset(OpARMLoweredWB) 21861 v.Aux = fn 21862 v.AddArg(destptr) 21863 v.AddArg(srcptr) 21864 v.AddArg(mem) 21865 return true 21866 } 21867 } 21868 func rewriteValueARM_OpXor16_0(v *Value) bool { 21869 // match: (Xor16 x y) 21870 // cond: 21871 // result: (XOR x y) 21872 for { 21873 _ = v.Args[1] 21874 x := v.Args[0] 21875 y := v.Args[1] 21876 v.reset(OpARMXOR) 21877 v.AddArg(x) 21878 v.AddArg(y) 21879 return true 21880 } 21881 } 21882 func rewriteValueARM_OpXor32_0(v *Value) bool { 21883 // match: (Xor32 x y) 21884 // cond: 21885 // result: (XOR x y) 21886 for { 21887 _ = v.Args[1] 21888 x := v.Args[0] 21889 y := v.Args[1] 21890 v.reset(OpARMXOR) 21891 v.AddArg(x) 21892 v.AddArg(y) 21893 return true 21894 } 21895 } 21896 func rewriteValueARM_OpXor8_0(v *Value) bool { 21897 // match: (Xor8 x y) 21898 // cond: 21899 // result: (XOR x y) 21900 for { 21901 _ = v.Args[1] 21902 x := v.Args[0] 21903 y := v.Args[1] 21904 v.reset(OpARMXOR) 21905 v.AddArg(x) 21906 v.AddArg(y) 21907 return true 21908 } 21909 } 21910 func rewriteValueARM_OpZero_0(v *Value) bool { 21911 b := v.Block 21912 _ = b 21913 config := b.Func.Config 21914 _ = config 21915 typ := &b.Func.Config.Types 21916 _ = typ 21917 // match: (Zero [0] _ mem) 21918 // cond: 21919 // result: mem 21920 for { 21921 if v.AuxInt != 0 { 21922 break 21923 } 21924 _ = v.Args[1] 21925 mem := v.Args[1] 21926 v.reset(OpCopy) 21927 v.Type = mem.Type 21928 v.AddArg(mem) 21929 return true 21930 } 21931 // match: (Zero [1] ptr mem) 21932 // cond: 21933 // result: (MOVBstore ptr (MOVWconst [0]) mem) 21934 for { 21935 if v.AuxInt != 1 { 21936 break 21937 } 21938 _ = v.Args[1] 21939 ptr := v.Args[0] 21940 mem := v.Args[1] 21941 v.reset(OpARMMOVBstore) 21942 v.AddArg(ptr) 21943 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 21944 v0.AuxInt = 0 21945 v.AddArg(v0) 21946 v.AddArg(mem) 21947 return true 21948 } 21949 // match: (Zero [2] {t} ptr mem) 21950 // cond: t.(*types.Type).Alignment()%2 == 0 21951 // result: (MOVHstore ptr (MOVWconst [0]) mem) 21952 for { 21953 if v.AuxInt != 2 { 21954 break 21955 } 21956 t := v.Aux 21957 _ = v.Args[1] 21958 ptr := v.Args[0] 21959 mem := v.Args[1] 21960 if !(t.(*types.Type).Alignment()%2 == 0) { 21961 break 21962 } 21963 v.reset(OpARMMOVHstore) 21964 v.AddArg(ptr) 21965 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 21966 v0.AuxInt = 0 21967 v.AddArg(v0) 21968 v.AddArg(mem) 21969 return true 21970 } 21971 // match: (Zero [2] ptr mem) 21972 // cond: 21973 // result: (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem)) 21974 for { 21975 if v.AuxInt != 2 { 21976 break 21977 } 21978 _ = v.Args[1] 21979 ptr := v.Args[0] 21980 mem := v.Args[1] 21981 v.reset(OpARMMOVBstore) 21982 v.AuxInt = 1 21983 v.AddArg(ptr) 21984 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 21985 v0.AuxInt = 0 21986 v.AddArg(v0) 21987 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 21988 v1.AuxInt = 0 21989 v1.AddArg(ptr) 21990 v2 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 21991 v2.AuxInt = 0 21992 v1.AddArg(v2) 21993 v1.AddArg(mem) 21994 v.AddArg(v1) 21995 return true 21996 } 21997 // match: (Zero [4] {t} ptr mem) 21998 // cond: t.(*types.Type).Alignment()%4 == 0 21999 // result: (MOVWstore ptr (MOVWconst [0]) mem) 22000 for { 22001 if v.AuxInt != 4 { 22002 break 22003 } 22004 t := v.Aux 22005 _ = v.Args[1] 22006 ptr := v.Args[0] 22007 mem := v.Args[1] 22008 if !(t.(*types.Type).Alignment()%4 == 0) { 22009 break 22010 } 22011 v.reset(OpARMMOVWstore) 22012 v.AddArg(ptr) 22013 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 22014 v0.AuxInt = 0 22015 v.AddArg(v0) 22016 v.AddArg(mem) 22017 return true 22018 } 22019 // match: (Zero [4] {t} ptr mem) 22020 // cond: t.(*types.Type).Alignment()%2 == 0 22021 // result: (MOVHstore [2] ptr (MOVWconst [0]) (MOVHstore [0] ptr (MOVWconst [0]) mem)) 22022 for { 22023 if v.AuxInt != 4 { 22024 break 22025 } 22026 t := v.Aux 22027 _ = v.Args[1] 22028 ptr := v.Args[0] 22029 mem := v.Args[1] 22030 if !(t.(*types.Type).Alignment()%2 == 0) { 22031 break 22032 } 22033 v.reset(OpARMMOVHstore) 22034 v.AuxInt = 2 22035 v.AddArg(ptr) 22036 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 22037 v0.AuxInt = 0 22038 v.AddArg(v0) 22039 v1 := b.NewValue0(v.Pos, OpARMMOVHstore, types.TypeMem) 22040 v1.AuxInt = 0 22041 v1.AddArg(ptr) 22042 v2 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 22043 v2.AuxInt = 0 22044 v1.AddArg(v2) 22045 v1.AddArg(mem) 22046 v.AddArg(v1) 22047 return true 22048 } 22049 // match: (Zero [4] ptr mem) 22050 // cond: 22051 // result: (MOVBstore [3] ptr (MOVWconst [0]) (MOVBstore [2] ptr (MOVWconst [0]) (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem)))) 22052 for { 22053 if v.AuxInt != 4 { 22054 break 22055 } 22056 _ = v.Args[1] 22057 ptr := v.Args[0] 22058 mem := v.Args[1] 22059 v.reset(OpARMMOVBstore) 22060 v.AuxInt = 3 22061 v.AddArg(ptr) 22062 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 22063 v0.AuxInt = 0 22064 v.AddArg(v0) 22065 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 22066 v1.AuxInt = 2 22067 v1.AddArg(ptr) 22068 v2 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 22069 v2.AuxInt = 0 22070 v1.AddArg(v2) 22071 v3 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 22072 v3.AuxInt = 1 22073 v3.AddArg(ptr) 22074 v4 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 22075 v4.AuxInt = 0 22076 v3.AddArg(v4) 22077 v5 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 22078 v5.AuxInt = 0 22079 v5.AddArg(ptr) 22080 v6 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 22081 v6.AuxInt = 0 22082 v5.AddArg(v6) 22083 v5.AddArg(mem) 22084 v3.AddArg(v5) 22085 v1.AddArg(v3) 22086 v.AddArg(v1) 22087 return true 22088 } 22089 // match: (Zero [3] ptr mem) 22090 // cond: 22091 // result: (MOVBstore [2] ptr (MOVWconst [0]) (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem))) 22092 for { 22093 if v.AuxInt != 3 { 22094 break 22095 } 22096 _ = v.Args[1] 22097 ptr := v.Args[0] 22098 mem := v.Args[1] 22099 v.reset(OpARMMOVBstore) 22100 v.AuxInt = 2 22101 v.AddArg(ptr) 22102 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 22103 v0.AuxInt = 0 22104 v.AddArg(v0) 22105 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 22106 v1.AuxInt = 1 22107 v1.AddArg(ptr) 22108 v2 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 22109 v2.AuxInt = 0 22110 v1.AddArg(v2) 22111 v3 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem) 22112 v3.AuxInt = 0 22113 v3.AddArg(ptr) 22114 v4 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 22115 v4.AuxInt = 0 22116 v3.AddArg(v4) 22117 v3.AddArg(mem) 22118 v1.AddArg(v3) 22119 v.AddArg(v1) 22120 return true 22121 } 22122 // match: (Zero [s] {t} ptr mem) 22123 // cond: s%4 == 0 && s > 4 && s <= 512 && t.(*types.Type).Alignment()%4 == 0 && !config.noDuffDevice 22124 // result: (DUFFZERO [4 * (128 - s/4)] ptr (MOVWconst [0]) mem) 22125 for { 22126 s := v.AuxInt 22127 t := v.Aux 22128 _ = v.Args[1] 22129 ptr := v.Args[0] 22130 mem := v.Args[1] 22131 if !(s%4 == 0 && s > 4 && s <= 512 && t.(*types.Type).Alignment()%4 == 0 && !config.noDuffDevice) { 22132 break 22133 } 22134 v.reset(OpARMDUFFZERO) 22135 v.AuxInt = 4 * (128 - s/4) 22136 v.AddArg(ptr) 22137 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 22138 v0.AuxInt = 0 22139 v.AddArg(v0) 22140 v.AddArg(mem) 22141 return true 22142 } 22143 // match: (Zero [s] {t} ptr mem) 22144 // cond: (s > 512 || config.noDuffDevice) || t.(*types.Type).Alignment()%4 != 0 22145 // result: (LoweredZero [t.(*types.Type).Alignment()] ptr (ADDconst <ptr.Type> ptr [s-moveSize(t.(*types.Type).Alignment(), config)]) (MOVWconst [0]) mem) 22146 for { 22147 s := v.AuxInt 22148 t := v.Aux 22149 _ = v.Args[1] 22150 ptr := v.Args[0] 22151 mem := v.Args[1] 22152 if !((s > 512 || config.noDuffDevice) || t.(*types.Type).Alignment()%4 != 0) { 22153 break 22154 } 22155 v.reset(OpARMLoweredZero) 22156 v.AuxInt = t.(*types.Type).Alignment() 22157 v.AddArg(ptr) 22158 v0 := b.NewValue0(v.Pos, OpARMADDconst, ptr.Type) 22159 v0.AuxInt = s - moveSize(t.(*types.Type).Alignment(), config) 22160 v0.AddArg(ptr) 22161 v.AddArg(v0) 22162 v1 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32) 22163 v1.AuxInt = 0 22164 v.AddArg(v1) 22165 v.AddArg(mem) 22166 return true 22167 } 22168 return false 22169 } 22170 func rewriteValueARM_OpZeroExt16to32_0(v *Value) bool { 22171 // match: (ZeroExt16to32 x) 22172 // cond: 22173 // result: (MOVHUreg x) 22174 for { 22175 x := v.Args[0] 22176 v.reset(OpARMMOVHUreg) 22177 v.AddArg(x) 22178 return true 22179 } 22180 } 22181 func rewriteValueARM_OpZeroExt8to16_0(v *Value) bool { 22182 // match: (ZeroExt8to16 x) 22183 // cond: 22184 // result: (MOVBUreg x) 22185 for { 22186 x := v.Args[0] 22187 v.reset(OpARMMOVBUreg) 22188 v.AddArg(x) 22189 return true 22190 } 22191 } 22192 func rewriteValueARM_OpZeroExt8to32_0(v *Value) bool { 22193 // match: (ZeroExt8to32 x) 22194 // cond: 22195 // result: (MOVBUreg x) 22196 for { 22197 x := v.Args[0] 22198 v.reset(OpARMMOVBUreg) 22199 v.AddArg(x) 22200 return true 22201 } 22202 } 22203 func rewriteValueARM_OpZeromask_0(v *Value) bool { 22204 b := v.Block 22205 _ = b 22206 typ := &b.Func.Config.Types 22207 _ = typ 22208 // match: (Zeromask x) 22209 // cond: 22210 // result: (SRAconst (RSBshiftRL <typ.Int32> x x [1]) [31]) 22211 for { 22212 x := v.Args[0] 22213 v.reset(OpARMSRAconst) 22214 v.AuxInt = 31 22215 v0 := b.NewValue0(v.Pos, OpARMRSBshiftRL, typ.Int32) 22216 v0.AuxInt = 1 22217 v0.AddArg(x) 22218 v0.AddArg(x) 22219 v.AddArg(v0) 22220 return true 22221 } 22222 } 22223 func rewriteBlockARM(b *Block) bool { 22224 config := b.Func.Config 22225 _ = config 22226 fe := b.Func.fe 22227 _ = fe 22228 typ := &config.Types 22229 _ = typ 22230 switch b.Kind { 22231 case BlockARMEQ: 22232 // match: (EQ (FlagEQ) yes no) 22233 // cond: 22234 // result: (First nil yes no) 22235 for { 22236 v := b.Control 22237 if v.Op != OpARMFlagEQ { 22238 break 22239 } 22240 b.Kind = BlockFirst 22241 b.SetControl(nil) 22242 b.Aux = nil 22243 return true 22244 } 22245 // match: (EQ (FlagLT_ULT) yes no) 22246 // cond: 22247 // result: (First nil no yes) 22248 for { 22249 v := b.Control 22250 if v.Op != OpARMFlagLT_ULT { 22251 break 22252 } 22253 b.Kind = BlockFirst 22254 b.SetControl(nil) 22255 b.Aux = nil 22256 b.swapSuccessors() 22257 return true 22258 } 22259 // match: (EQ (FlagLT_UGT) yes no) 22260 // cond: 22261 // result: (First nil no yes) 22262 for { 22263 v := b.Control 22264 if v.Op != OpARMFlagLT_UGT { 22265 break 22266 } 22267 b.Kind = BlockFirst 22268 b.SetControl(nil) 22269 b.Aux = nil 22270 b.swapSuccessors() 22271 return true 22272 } 22273 // match: (EQ (FlagGT_ULT) yes no) 22274 // cond: 22275 // result: (First nil no yes) 22276 for { 22277 v := b.Control 22278 if v.Op != OpARMFlagGT_ULT { 22279 break 22280 } 22281 b.Kind = BlockFirst 22282 b.SetControl(nil) 22283 b.Aux = nil 22284 b.swapSuccessors() 22285 return true 22286 } 22287 // match: (EQ (FlagGT_UGT) yes no) 22288 // cond: 22289 // result: (First nil no yes) 22290 for { 22291 v := b.Control 22292 if v.Op != OpARMFlagGT_UGT { 22293 break 22294 } 22295 b.Kind = BlockFirst 22296 b.SetControl(nil) 22297 b.Aux = nil 22298 b.swapSuccessors() 22299 return true 22300 } 22301 // match: (EQ (InvertFlags cmp) yes no) 22302 // cond: 22303 // result: (EQ cmp yes no) 22304 for { 22305 v := b.Control 22306 if v.Op != OpARMInvertFlags { 22307 break 22308 } 22309 cmp := v.Args[0] 22310 b.Kind = BlockARMEQ 22311 b.SetControl(cmp) 22312 b.Aux = nil 22313 return true 22314 } 22315 // match: (EQ (CMPconst [0] l:(SUB x y)) yes no) 22316 // cond: l.Uses==1 22317 // result: (EQ (CMP x y) yes no) 22318 for { 22319 v := b.Control 22320 if v.Op != OpARMCMPconst { 22321 break 22322 } 22323 if v.AuxInt != 0 { 22324 break 22325 } 22326 l := v.Args[0] 22327 if l.Op != OpARMSUB { 22328 break 22329 } 22330 _ = l.Args[1] 22331 x := l.Args[0] 22332 y := l.Args[1] 22333 if !(l.Uses == 1) { 22334 break 22335 } 22336 b.Kind = BlockARMEQ 22337 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 22338 v0.AddArg(x) 22339 v0.AddArg(y) 22340 b.SetControl(v0) 22341 b.Aux = nil 22342 return true 22343 } 22344 // match: (EQ (CMPconst [0] l:(MULS x y a)) yes no) 22345 // cond: l.Uses==1 22346 // result: (EQ (CMP a (MUL <x.Type> x y)) yes no) 22347 for { 22348 v := b.Control 22349 if v.Op != OpARMCMPconst { 22350 break 22351 } 22352 if v.AuxInt != 0 { 22353 break 22354 } 22355 l := v.Args[0] 22356 if l.Op != OpARMMULS { 22357 break 22358 } 22359 _ = l.Args[2] 22360 x := l.Args[0] 22361 y := l.Args[1] 22362 a := l.Args[2] 22363 if !(l.Uses == 1) { 22364 break 22365 } 22366 b.Kind = BlockARMEQ 22367 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 22368 v0.AddArg(a) 22369 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type) 22370 v1.AddArg(x) 22371 v1.AddArg(y) 22372 v0.AddArg(v1) 22373 b.SetControl(v0) 22374 b.Aux = nil 22375 return true 22376 } 22377 // match: (EQ (CMPconst [0] l:(SUBconst [c] x)) yes no) 22378 // cond: l.Uses==1 22379 // result: (EQ (CMPconst [c] x) yes no) 22380 for { 22381 v := b.Control 22382 if v.Op != OpARMCMPconst { 22383 break 22384 } 22385 if v.AuxInt != 0 { 22386 break 22387 } 22388 l := v.Args[0] 22389 if l.Op != OpARMSUBconst { 22390 break 22391 } 22392 c := l.AuxInt 22393 x := l.Args[0] 22394 if !(l.Uses == 1) { 22395 break 22396 } 22397 b.Kind = BlockARMEQ 22398 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 22399 v0.AuxInt = c 22400 v0.AddArg(x) 22401 b.SetControl(v0) 22402 b.Aux = nil 22403 return true 22404 } 22405 // match: (EQ (CMPconst [0] l:(SUBshiftLL x y [c])) yes no) 22406 // cond: l.Uses==1 22407 // result: (EQ (CMPshiftLL x y [c]) yes no) 22408 for { 22409 v := b.Control 22410 if v.Op != OpARMCMPconst { 22411 break 22412 } 22413 if v.AuxInt != 0 { 22414 break 22415 } 22416 l := v.Args[0] 22417 if l.Op != OpARMSUBshiftLL { 22418 break 22419 } 22420 c := l.AuxInt 22421 _ = l.Args[1] 22422 x := l.Args[0] 22423 y := l.Args[1] 22424 if !(l.Uses == 1) { 22425 break 22426 } 22427 b.Kind = BlockARMEQ 22428 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags) 22429 v0.AuxInt = c 22430 v0.AddArg(x) 22431 v0.AddArg(y) 22432 b.SetControl(v0) 22433 b.Aux = nil 22434 return true 22435 } 22436 // match: (EQ (CMPconst [0] l:(SUBshiftRL x y [c])) yes no) 22437 // cond: l.Uses==1 22438 // result: (EQ (CMPshiftRL x y [c]) yes no) 22439 for { 22440 v := b.Control 22441 if v.Op != OpARMCMPconst { 22442 break 22443 } 22444 if v.AuxInt != 0 { 22445 break 22446 } 22447 l := v.Args[0] 22448 if l.Op != OpARMSUBshiftRL { 22449 break 22450 } 22451 c := l.AuxInt 22452 _ = l.Args[1] 22453 x := l.Args[0] 22454 y := l.Args[1] 22455 if !(l.Uses == 1) { 22456 break 22457 } 22458 b.Kind = BlockARMEQ 22459 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags) 22460 v0.AuxInt = c 22461 v0.AddArg(x) 22462 v0.AddArg(y) 22463 b.SetControl(v0) 22464 b.Aux = nil 22465 return true 22466 } 22467 // match: (EQ (CMPconst [0] l:(SUBshiftRA x y [c])) yes no) 22468 // cond: l.Uses==1 22469 // result: (EQ (CMPshiftRA x y [c]) yes no) 22470 for { 22471 v := b.Control 22472 if v.Op != OpARMCMPconst { 22473 break 22474 } 22475 if v.AuxInt != 0 { 22476 break 22477 } 22478 l := v.Args[0] 22479 if l.Op != OpARMSUBshiftRA { 22480 break 22481 } 22482 c := l.AuxInt 22483 _ = l.Args[1] 22484 x := l.Args[0] 22485 y := l.Args[1] 22486 if !(l.Uses == 1) { 22487 break 22488 } 22489 b.Kind = BlockARMEQ 22490 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags) 22491 v0.AuxInt = c 22492 v0.AddArg(x) 22493 v0.AddArg(y) 22494 b.SetControl(v0) 22495 b.Aux = nil 22496 return true 22497 } 22498 // match: (EQ (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no) 22499 // cond: l.Uses==1 22500 // result: (EQ (CMPshiftLLreg x y z) yes no) 22501 for { 22502 v := b.Control 22503 if v.Op != OpARMCMPconst { 22504 break 22505 } 22506 if v.AuxInt != 0 { 22507 break 22508 } 22509 l := v.Args[0] 22510 if l.Op != OpARMSUBshiftLLreg { 22511 break 22512 } 22513 _ = l.Args[2] 22514 x := l.Args[0] 22515 y := l.Args[1] 22516 z := l.Args[2] 22517 if !(l.Uses == 1) { 22518 break 22519 } 22520 b.Kind = BlockARMEQ 22521 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags) 22522 v0.AddArg(x) 22523 v0.AddArg(y) 22524 v0.AddArg(z) 22525 b.SetControl(v0) 22526 b.Aux = nil 22527 return true 22528 } 22529 // match: (EQ (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no) 22530 // cond: l.Uses==1 22531 // result: (EQ (CMPshiftRLreg x y z) yes no) 22532 for { 22533 v := b.Control 22534 if v.Op != OpARMCMPconst { 22535 break 22536 } 22537 if v.AuxInt != 0 { 22538 break 22539 } 22540 l := v.Args[0] 22541 if l.Op != OpARMSUBshiftRLreg { 22542 break 22543 } 22544 _ = l.Args[2] 22545 x := l.Args[0] 22546 y := l.Args[1] 22547 z := l.Args[2] 22548 if !(l.Uses == 1) { 22549 break 22550 } 22551 b.Kind = BlockARMEQ 22552 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags) 22553 v0.AddArg(x) 22554 v0.AddArg(y) 22555 v0.AddArg(z) 22556 b.SetControl(v0) 22557 b.Aux = nil 22558 return true 22559 } 22560 // match: (EQ (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no) 22561 // cond: l.Uses==1 22562 // result: (EQ (CMPshiftRAreg x y z) yes no) 22563 for { 22564 v := b.Control 22565 if v.Op != OpARMCMPconst { 22566 break 22567 } 22568 if v.AuxInt != 0 { 22569 break 22570 } 22571 l := v.Args[0] 22572 if l.Op != OpARMSUBshiftRAreg { 22573 break 22574 } 22575 _ = l.Args[2] 22576 x := l.Args[0] 22577 y := l.Args[1] 22578 z := l.Args[2] 22579 if !(l.Uses == 1) { 22580 break 22581 } 22582 b.Kind = BlockARMEQ 22583 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags) 22584 v0.AddArg(x) 22585 v0.AddArg(y) 22586 v0.AddArg(z) 22587 b.SetControl(v0) 22588 b.Aux = nil 22589 return true 22590 } 22591 // match: (EQ (CMPconst [0] l:(ADD x y)) yes no) 22592 // cond: l.Uses==1 22593 // result: (EQ (CMN x y) yes no) 22594 for { 22595 v := b.Control 22596 if v.Op != OpARMCMPconst { 22597 break 22598 } 22599 if v.AuxInt != 0 { 22600 break 22601 } 22602 l := v.Args[0] 22603 if l.Op != OpARMADD { 22604 break 22605 } 22606 _ = l.Args[1] 22607 x := l.Args[0] 22608 y := l.Args[1] 22609 if !(l.Uses == 1) { 22610 break 22611 } 22612 b.Kind = BlockARMEQ 22613 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags) 22614 v0.AddArg(x) 22615 v0.AddArg(y) 22616 b.SetControl(v0) 22617 b.Aux = nil 22618 return true 22619 } 22620 // match: (EQ (CMPconst [0] l:(MULA x y a)) yes no) 22621 // cond: l.Uses==1 22622 // result: (EQ (CMN a (MUL <x.Type> x y)) yes no) 22623 for { 22624 v := b.Control 22625 if v.Op != OpARMCMPconst { 22626 break 22627 } 22628 if v.AuxInt != 0 { 22629 break 22630 } 22631 l := v.Args[0] 22632 if l.Op != OpARMMULA { 22633 break 22634 } 22635 _ = l.Args[2] 22636 x := l.Args[0] 22637 y := l.Args[1] 22638 a := l.Args[2] 22639 if !(l.Uses == 1) { 22640 break 22641 } 22642 b.Kind = BlockARMEQ 22643 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags) 22644 v0.AddArg(a) 22645 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type) 22646 v1.AddArg(x) 22647 v1.AddArg(y) 22648 v0.AddArg(v1) 22649 b.SetControl(v0) 22650 b.Aux = nil 22651 return true 22652 } 22653 // match: (EQ (CMPconst [0] l:(ADDconst [c] x)) yes no) 22654 // cond: l.Uses==1 22655 // result: (EQ (CMNconst [c] x) yes no) 22656 for { 22657 v := b.Control 22658 if v.Op != OpARMCMPconst { 22659 break 22660 } 22661 if v.AuxInt != 0 { 22662 break 22663 } 22664 l := v.Args[0] 22665 if l.Op != OpARMADDconst { 22666 break 22667 } 22668 c := l.AuxInt 22669 x := l.Args[0] 22670 if !(l.Uses == 1) { 22671 break 22672 } 22673 b.Kind = BlockARMEQ 22674 v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags) 22675 v0.AuxInt = c 22676 v0.AddArg(x) 22677 b.SetControl(v0) 22678 b.Aux = nil 22679 return true 22680 } 22681 // match: (EQ (CMPconst [0] l:(ADDshiftLL x y [c])) yes no) 22682 // cond: l.Uses==1 22683 // result: (EQ (CMNshiftLL x y [c]) yes no) 22684 for { 22685 v := b.Control 22686 if v.Op != OpARMCMPconst { 22687 break 22688 } 22689 if v.AuxInt != 0 { 22690 break 22691 } 22692 l := v.Args[0] 22693 if l.Op != OpARMADDshiftLL { 22694 break 22695 } 22696 c := l.AuxInt 22697 _ = l.Args[1] 22698 x := l.Args[0] 22699 y := l.Args[1] 22700 if !(l.Uses == 1) { 22701 break 22702 } 22703 b.Kind = BlockARMEQ 22704 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags) 22705 v0.AuxInt = c 22706 v0.AddArg(x) 22707 v0.AddArg(y) 22708 b.SetControl(v0) 22709 b.Aux = nil 22710 return true 22711 } 22712 // match: (EQ (CMPconst [0] l:(ADDshiftRL x y [c])) yes no) 22713 // cond: l.Uses==1 22714 // result: (EQ (CMNshiftRL x y [c]) yes no) 22715 for { 22716 v := b.Control 22717 if v.Op != OpARMCMPconst { 22718 break 22719 } 22720 if v.AuxInt != 0 { 22721 break 22722 } 22723 l := v.Args[0] 22724 if l.Op != OpARMADDshiftRL { 22725 break 22726 } 22727 c := l.AuxInt 22728 _ = l.Args[1] 22729 x := l.Args[0] 22730 y := l.Args[1] 22731 if !(l.Uses == 1) { 22732 break 22733 } 22734 b.Kind = BlockARMEQ 22735 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags) 22736 v0.AuxInt = c 22737 v0.AddArg(x) 22738 v0.AddArg(y) 22739 b.SetControl(v0) 22740 b.Aux = nil 22741 return true 22742 } 22743 // match: (EQ (CMPconst [0] l:(ADDshiftRA x y [c])) yes no) 22744 // cond: l.Uses==1 22745 // result: (EQ (CMNshiftRA x y [c]) yes no) 22746 for { 22747 v := b.Control 22748 if v.Op != OpARMCMPconst { 22749 break 22750 } 22751 if v.AuxInt != 0 { 22752 break 22753 } 22754 l := v.Args[0] 22755 if l.Op != OpARMADDshiftRA { 22756 break 22757 } 22758 c := l.AuxInt 22759 _ = l.Args[1] 22760 x := l.Args[0] 22761 y := l.Args[1] 22762 if !(l.Uses == 1) { 22763 break 22764 } 22765 b.Kind = BlockARMEQ 22766 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags) 22767 v0.AuxInt = c 22768 v0.AddArg(x) 22769 v0.AddArg(y) 22770 b.SetControl(v0) 22771 b.Aux = nil 22772 return true 22773 } 22774 // match: (EQ (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) 22775 // cond: l.Uses==1 22776 // result: (EQ (CMNshiftLLreg x y z) yes no) 22777 for { 22778 v := b.Control 22779 if v.Op != OpARMCMPconst { 22780 break 22781 } 22782 if v.AuxInt != 0 { 22783 break 22784 } 22785 l := v.Args[0] 22786 if l.Op != OpARMADDshiftLLreg { 22787 break 22788 } 22789 _ = l.Args[2] 22790 x := l.Args[0] 22791 y := l.Args[1] 22792 z := l.Args[2] 22793 if !(l.Uses == 1) { 22794 break 22795 } 22796 b.Kind = BlockARMEQ 22797 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags) 22798 v0.AddArg(x) 22799 v0.AddArg(y) 22800 v0.AddArg(z) 22801 b.SetControl(v0) 22802 b.Aux = nil 22803 return true 22804 } 22805 // match: (EQ (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) 22806 // cond: l.Uses==1 22807 // result: (EQ (CMNshiftRLreg x y z) yes no) 22808 for { 22809 v := b.Control 22810 if v.Op != OpARMCMPconst { 22811 break 22812 } 22813 if v.AuxInt != 0 { 22814 break 22815 } 22816 l := v.Args[0] 22817 if l.Op != OpARMADDshiftRLreg { 22818 break 22819 } 22820 _ = l.Args[2] 22821 x := l.Args[0] 22822 y := l.Args[1] 22823 z := l.Args[2] 22824 if !(l.Uses == 1) { 22825 break 22826 } 22827 b.Kind = BlockARMEQ 22828 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags) 22829 v0.AddArg(x) 22830 v0.AddArg(y) 22831 v0.AddArg(z) 22832 b.SetControl(v0) 22833 b.Aux = nil 22834 return true 22835 } 22836 // match: (EQ (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) 22837 // cond: l.Uses==1 22838 // result: (EQ (CMNshiftRAreg x y z) yes no) 22839 for { 22840 v := b.Control 22841 if v.Op != OpARMCMPconst { 22842 break 22843 } 22844 if v.AuxInt != 0 { 22845 break 22846 } 22847 l := v.Args[0] 22848 if l.Op != OpARMADDshiftRAreg { 22849 break 22850 } 22851 _ = l.Args[2] 22852 x := l.Args[0] 22853 y := l.Args[1] 22854 z := l.Args[2] 22855 if !(l.Uses == 1) { 22856 break 22857 } 22858 b.Kind = BlockARMEQ 22859 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags) 22860 v0.AddArg(x) 22861 v0.AddArg(y) 22862 v0.AddArg(z) 22863 b.SetControl(v0) 22864 b.Aux = nil 22865 return true 22866 } 22867 // match: (EQ (CMPconst [0] l:(AND x y)) yes no) 22868 // cond: l.Uses==1 22869 // result: (EQ (TST x y) yes no) 22870 for { 22871 v := b.Control 22872 if v.Op != OpARMCMPconst { 22873 break 22874 } 22875 if v.AuxInt != 0 { 22876 break 22877 } 22878 l := v.Args[0] 22879 if l.Op != OpARMAND { 22880 break 22881 } 22882 _ = l.Args[1] 22883 x := l.Args[0] 22884 y := l.Args[1] 22885 if !(l.Uses == 1) { 22886 break 22887 } 22888 b.Kind = BlockARMEQ 22889 v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags) 22890 v0.AddArg(x) 22891 v0.AddArg(y) 22892 b.SetControl(v0) 22893 b.Aux = nil 22894 return true 22895 } 22896 // match: (EQ (CMPconst [0] l:(ANDconst [c] x)) yes no) 22897 // cond: l.Uses==1 22898 // result: (EQ (TSTconst [c] x) yes no) 22899 for { 22900 v := b.Control 22901 if v.Op != OpARMCMPconst { 22902 break 22903 } 22904 if v.AuxInt != 0 { 22905 break 22906 } 22907 l := v.Args[0] 22908 if l.Op != OpARMANDconst { 22909 break 22910 } 22911 c := l.AuxInt 22912 x := l.Args[0] 22913 if !(l.Uses == 1) { 22914 break 22915 } 22916 b.Kind = BlockARMEQ 22917 v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags) 22918 v0.AuxInt = c 22919 v0.AddArg(x) 22920 b.SetControl(v0) 22921 b.Aux = nil 22922 return true 22923 } 22924 // match: (EQ (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) 22925 // cond: l.Uses==1 22926 // result: (EQ (TSTshiftLL x y [c]) yes no) 22927 for { 22928 v := b.Control 22929 if v.Op != OpARMCMPconst { 22930 break 22931 } 22932 if v.AuxInt != 0 { 22933 break 22934 } 22935 l := v.Args[0] 22936 if l.Op != OpARMANDshiftLL { 22937 break 22938 } 22939 c := l.AuxInt 22940 _ = l.Args[1] 22941 x := l.Args[0] 22942 y := l.Args[1] 22943 if !(l.Uses == 1) { 22944 break 22945 } 22946 b.Kind = BlockARMEQ 22947 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags) 22948 v0.AuxInt = c 22949 v0.AddArg(x) 22950 v0.AddArg(y) 22951 b.SetControl(v0) 22952 b.Aux = nil 22953 return true 22954 } 22955 // match: (EQ (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) 22956 // cond: l.Uses==1 22957 // result: (EQ (TSTshiftRL x y [c]) yes no) 22958 for { 22959 v := b.Control 22960 if v.Op != OpARMCMPconst { 22961 break 22962 } 22963 if v.AuxInt != 0 { 22964 break 22965 } 22966 l := v.Args[0] 22967 if l.Op != OpARMANDshiftRL { 22968 break 22969 } 22970 c := l.AuxInt 22971 _ = l.Args[1] 22972 x := l.Args[0] 22973 y := l.Args[1] 22974 if !(l.Uses == 1) { 22975 break 22976 } 22977 b.Kind = BlockARMEQ 22978 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags) 22979 v0.AuxInt = c 22980 v0.AddArg(x) 22981 v0.AddArg(y) 22982 b.SetControl(v0) 22983 b.Aux = nil 22984 return true 22985 } 22986 // match: (EQ (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) 22987 // cond: l.Uses==1 22988 // result: (EQ (TSTshiftRA x y [c]) yes no) 22989 for { 22990 v := b.Control 22991 if v.Op != OpARMCMPconst { 22992 break 22993 } 22994 if v.AuxInt != 0 { 22995 break 22996 } 22997 l := v.Args[0] 22998 if l.Op != OpARMANDshiftRA { 22999 break 23000 } 23001 c := l.AuxInt 23002 _ = l.Args[1] 23003 x := l.Args[0] 23004 y := l.Args[1] 23005 if !(l.Uses == 1) { 23006 break 23007 } 23008 b.Kind = BlockARMEQ 23009 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags) 23010 v0.AuxInt = c 23011 v0.AddArg(x) 23012 v0.AddArg(y) 23013 b.SetControl(v0) 23014 b.Aux = nil 23015 return true 23016 } 23017 // match: (EQ (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) 23018 // cond: l.Uses==1 23019 // result: (EQ (TSTshiftLLreg x y z) yes no) 23020 for { 23021 v := b.Control 23022 if v.Op != OpARMCMPconst { 23023 break 23024 } 23025 if v.AuxInt != 0 { 23026 break 23027 } 23028 l := v.Args[0] 23029 if l.Op != OpARMANDshiftLLreg { 23030 break 23031 } 23032 _ = l.Args[2] 23033 x := l.Args[0] 23034 y := l.Args[1] 23035 z := l.Args[2] 23036 if !(l.Uses == 1) { 23037 break 23038 } 23039 b.Kind = BlockARMEQ 23040 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags) 23041 v0.AddArg(x) 23042 v0.AddArg(y) 23043 v0.AddArg(z) 23044 b.SetControl(v0) 23045 b.Aux = nil 23046 return true 23047 } 23048 // match: (EQ (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) 23049 // cond: l.Uses==1 23050 // result: (EQ (TSTshiftRLreg x y z) yes no) 23051 for { 23052 v := b.Control 23053 if v.Op != OpARMCMPconst { 23054 break 23055 } 23056 if v.AuxInt != 0 { 23057 break 23058 } 23059 l := v.Args[0] 23060 if l.Op != OpARMANDshiftRLreg { 23061 break 23062 } 23063 _ = l.Args[2] 23064 x := l.Args[0] 23065 y := l.Args[1] 23066 z := l.Args[2] 23067 if !(l.Uses == 1) { 23068 break 23069 } 23070 b.Kind = BlockARMEQ 23071 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags) 23072 v0.AddArg(x) 23073 v0.AddArg(y) 23074 v0.AddArg(z) 23075 b.SetControl(v0) 23076 b.Aux = nil 23077 return true 23078 } 23079 // match: (EQ (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) 23080 // cond: l.Uses==1 23081 // result: (EQ (TSTshiftRAreg x y z) yes no) 23082 for { 23083 v := b.Control 23084 if v.Op != OpARMCMPconst { 23085 break 23086 } 23087 if v.AuxInt != 0 { 23088 break 23089 } 23090 l := v.Args[0] 23091 if l.Op != OpARMANDshiftRAreg { 23092 break 23093 } 23094 _ = l.Args[2] 23095 x := l.Args[0] 23096 y := l.Args[1] 23097 z := l.Args[2] 23098 if !(l.Uses == 1) { 23099 break 23100 } 23101 b.Kind = BlockARMEQ 23102 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags) 23103 v0.AddArg(x) 23104 v0.AddArg(y) 23105 v0.AddArg(z) 23106 b.SetControl(v0) 23107 b.Aux = nil 23108 return true 23109 } 23110 // match: (EQ (CMPconst [0] l:(XOR x y)) yes no) 23111 // cond: l.Uses==1 23112 // result: (EQ (TEQ x y) yes no) 23113 for { 23114 v := b.Control 23115 if v.Op != OpARMCMPconst { 23116 break 23117 } 23118 if v.AuxInt != 0 { 23119 break 23120 } 23121 l := v.Args[0] 23122 if l.Op != OpARMXOR { 23123 break 23124 } 23125 _ = l.Args[1] 23126 x := l.Args[0] 23127 y := l.Args[1] 23128 if !(l.Uses == 1) { 23129 break 23130 } 23131 b.Kind = BlockARMEQ 23132 v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags) 23133 v0.AddArg(x) 23134 v0.AddArg(y) 23135 b.SetControl(v0) 23136 b.Aux = nil 23137 return true 23138 } 23139 // match: (EQ (CMPconst [0] l:(XORconst [c] x)) yes no) 23140 // cond: l.Uses==1 23141 // result: (EQ (TEQconst [c] x) yes no) 23142 for { 23143 v := b.Control 23144 if v.Op != OpARMCMPconst { 23145 break 23146 } 23147 if v.AuxInt != 0 { 23148 break 23149 } 23150 l := v.Args[0] 23151 if l.Op != OpARMXORconst { 23152 break 23153 } 23154 c := l.AuxInt 23155 x := l.Args[0] 23156 if !(l.Uses == 1) { 23157 break 23158 } 23159 b.Kind = BlockARMEQ 23160 v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags) 23161 v0.AuxInt = c 23162 v0.AddArg(x) 23163 b.SetControl(v0) 23164 b.Aux = nil 23165 return true 23166 } 23167 // match: (EQ (CMPconst [0] l:(XORshiftLL x y [c])) yes no) 23168 // cond: l.Uses==1 23169 // result: (EQ (TEQshiftLL x y [c]) yes no) 23170 for { 23171 v := b.Control 23172 if v.Op != OpARMCMPconst { 23173 break 23174 } 23175 if v.AuxInt != 0 { 23176 break 23177 } 23178 l := v.Args[0] 23179 if l.Op != OpARMXORshiftLL { 23180 break 23181 } 23182 c := l.AuxInt 23183 _ = l.Args[1] 23184 x := l.Args[0] 23185 y := l.Args[1] 23186 if !(l.Uses == 1) { 23187 break 23188 } 23189 b.Kind = BlockARMEQ 23190 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags) 23191 v0.AuxInt = c 23192 v0.AddArg(x) 23193 v0.AddArg(y) 23194 b.SetControl(v0) 23195 b.Aux = nil 23196 return true 23197 } 23198 // match: (EQ (CMPconst [0] l:(XORshiftRL x y [c])) yes no) 23199 // cond: l.Uses==1 23200 // result: (EQ (TEQshiftRL x y [c]) yes no) 23201 for { 23202 v := b.Control 23203 if v.Op != OpARMCMPconst { 23204 break 23205 } 23206 if v.AuxInt != 0 { 23207 break 23208 } 23209 l := v.Args[0] 23210 if l.Op != OpARMXORshiftRL { 23211 break 23212 } 23213 c := l.AuxInt 23214 _ = l.Args[1] 23215 x := l.Args[0] 23216 y := l.Args[1] 23217 if !(l.Uses == 1) { 23218 break 23219 } 23220 b.Kind = BlockARMEQ 23221 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags) 23222 v0.AuxInt = c 23223 v0.AddArg(x) 23224 v0.AddArg(y) 23225 b.SetControl(v0) 23226 b.Aux = nil 23227 return true 23228 } 23229 // match: (EQ (CMPconst [0] l:(XORshiftRA x y [c])) yes no) 23230 // cond: l.Uses==1 23231 // result: (EQ (TEQshiftRA x y [c]) yes no) 23232 for { 23233 v := b.Control 23234 if v.Op != OpARMCMPconst { 23235 break 23236 } 23237 if v.AuxInt != 0 { 23238 break 23239 } 23240 l := v.Args[0] 23241 if l.Op != OpARMXORshiftRA { 23242 break 23243 } 23244 c := l.AuxInt 23245 _ = l.Args[1] 23246 x := l.Args[0] 23247 y := l.Args[1] 23248 if !(l.Uses == 1) { 23249 break 23250 } 23251 b.Kind = BlockARMEQ 23252 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags) 23253 v0.AuxInt = c 23254 v0.AddArg(x) 23255 v0.AddArg(y) 23256 b.SetControl(v0) 23257 b.Aux = nil 23258 return true 23259 } 23260 // match: (EQ (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) 23261 // cond: l.Uses==1 23262 // result: (EQ (TEQshiftLLreg x y z) yes no) 23263 for { 23264 v := b.Control 23265 if v.Op != OpARMCMPconst { 23266 break 23267 } 23268 if v.AuxInt != 0 { 23269 break 23270 } 23271 l := v.Args[0] 23272 if l.Op != OpARMXORshiftLLreg { 23273 break 23274 } 23275 _ = l.Args[2] 23276 x := l.Args[0] 23277 y := l.Args[1] 23278 z := l.Args[2] 23279 if !(l.Uses == 1) { 23280 break 23281 } 23282 b.Kind = BlockARMEQ 23283 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags) 23284 v0.AddArg(x) 23285 v0.AddArg(y) 23286 v0.AddArg(z) 23287 b.SetControl(v0) 23288 b.Aux = nil 23289 return true 23290 } 23291 // match: (EQ (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) 23292 // cond: l.Uses==1 23293 // result: (EQ (TEQshiftRLreg x y z) yes no) 23294 for { 23295 v := b.Control 23296 if v.Op != OpARMCMPconst { 23297 break 23298 } 23299 if v.AuxInt != 0 { 23300 break 23301 } 23302 l := v.Args[0] 23303 if l.Op != OpARMXORshiftRLreg { 23304 break 23305 } 23306 _ = l.Args[2] 23307 x := l.Args[0] 23308 y := l.Args[1] 23309 z := l.Args[2] 23310 if !(l.Uses == 1) { 23311 break 23312 } 23313 b.Kind = BlockARMEQ 23314 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags) 23315 v0.AddArg(x) 23316 v0.AddArg(y) 23317 v0.AddArg(z) 23318 b.SetControl(v0) 23319 b.Aux = nil 23320 return true 23321 } 23322 // match: (EQ (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) 23323 // cond: l.Uses==1 23324 // result: (EQ (TEQshiftRAreg x y z) yes no) 23325 for { 23326 v := b.Control 23327 if v.Op != OpARMCMPconst { 23328 break 23329 } 23330 if v.AuxInt != 0 { 23331 break 23332 } 23333 l := v.Args[0] 23334 if l.Op != OpARMXORshiftRAreg { 23335 break 23336 } 23337 _ = l.Args[2] 23338 x := l.Args[0] 23339 y := l.Args[1] 23340 z := l.Args[2] 23341 if !(l.Uses == 1) { 23342 break 23343 } 23344 b.Kind = BlockARMEQ 23345 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags) 23346 v0.AddArg(x) 23347 v0.AddArg(y) 23348 v0.AddArg(z) 23349 b.SetControl(v0) 23350 b.Aux = nil 23351 return true 23352 } 23353 case BlockARMGE: 23354 // match: (GE (FlagEQ) yes no) 23355 // cond: 23356 // result: (First nil yes no) 23357 for { 23358 v := b.Control 23359 if v.Op != OpARMFlagEQ { 23360 break 23361 } 23362 b.Kind = BlockFirst 23363 b.SetControl(nil) 23364 b.Aux = nil 23365 return true 23366 } 23367 // match: (GE (FlagLT_ULT) yes no) 23368 // cond: 23369 // result: (First nil no yes) 23370 for { 23371 v := b.Control 23372 if v.Op != OpARMFlagLT_ULT { 23373 break 23374 } 23375 b.Kind = BlockFirst 23376 b.SetControl(nil) 23377 b.Aux = nil 23378 b.swapSuccessors() 23379 return true 23380 } 23381 // match: (GE (FlagLT_UGT) yes no) 23382 // cond: 23383 // result: (First nil no yes) 23384 for { 23385 v := b.Control 23386 if v.Op != OpARMFlagLT_UGT { 23387 break 23388 } 23389 b.Kind = BlockFirst 23390 b.SetControl(nil) 23391 b.Aux = nil 23392 b.swapSuccessors() 23393 return true 23394 } 23395 // match: (GE (FlagGT_ULT) yes no) 23396 // cond: 23397 // result: (First nil yes no) 23398 for { 23399 v := b.Control 23400 if v.Op != OpARMFlagGT_ULT { 23401 break 23402 } 23403 b.Kind = BlockFirst 23404 b.SetControl(nil) 23405 b.Aux = nil 23406 return true 23407 } 23408 // match: (GE (FlagGT_UGT) yes no) 23409 // cond: 23410 // result: (First nil yes no) 23411 for { 23412 v := b.Control 23413 if v.Op != OpARMFlagGT_UGT { 23414 break 23415 } 23416 b.Kind = BlockFirst 23417 b.SetControl(nil) 23418 b.Aux = nil 23419 return true 23420 } 23421 // match: (GE (InvertFlags cmp) yes no) 23422 // cond: 23423 // result: (LE cmp yes no) 23424 for { 23425 v := b.Control 23426 if v.Op != OpARMInvertFlags { 23427 break 23428 } 23429 cmp := v.Args[0] 23430 b.Kind = BlockARMLE 23431 b.SetControl(cmp) 23432 b.Aux = nil 23433 return true 23434 } 23435 // match: (GE (CMPconst [0] l:(SUB x y)) yes no) 23436 // cond: l.Uses==1 23437 // result: (GE (CMP x y) yes no) 23438 for { 23439 v := b.Control 23440 if v.Op != OpARMCMPconst { 23441 break 23442 } 23443 if v.AuxInt != 0 { 23444 break 23445 } 23446 l := v.Args[0] 23447 if l.Op != OpARMSUB { 23448 break 23449 } 23450 _ = l.Args[1] 23451 x := l.Args[0] 23452 y := l.Args[1] 23453 if !(l.Uses == 1) { 23454 break 23455 } 23456 b.Kind = BlockARMGE 23457 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 23458 v0.AddArg(x) 23459 v0.AddArg(y) 23460 b.SetControl(v0) 23461 b.Aux = nil 23462 return true 23463 } 23464 // match: (GE (CMPconst [0] l:(MULS x y a)) yes no) 23465 // cond: l.Uses==1 23466 // result: (GE (CMP a (MUL <x.Type> x y)) yes no) 23467 for { 23468 v := b.Control 23469 if v.Op != OpARMCMPconst { 23470 break 23471 } 23472 if v.AuxInt != 0 { 23473 break 23474 } 23475 l := v.Args[0] 23476 if l.Op != OpARMMULS { 23477 break 23478 } 23479 _ = l.Args[2] 23480 x := l.Args[0] 23481 y := l.Args[1] 23482 a := l.Args[2] 23483 if !(l.Uses == 1) { 23484 break 23485 } 23486 b.Kind = BlockARMGE 23487 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 23488 v0.AddArg(a) 23489 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type) 23490 v1.AddArg(x) 23491 v1.AddArg(y) 23492 v0.AddArg(v1) 23493 b.SetControl(v0) 23494 b.Aux = nil 23495 return true 23496 } 23497 // match: (GE (CMPconst [0] l:(SUBconst [c] x)) yes no) 23498 // cond: l.Uses==1 23499 // result: (GE (CMPconst [c] x) yes no) 23500 for { 23501 v := b.Control 23502 if v.Op != OpARMCMPconst { 23503 break 23504 } 23505 if v.AuxInt != 0 { 23506 break 23507 } 23508 l := v.Args[0] 23509 if l.Op != OpARMSUBconst { 23510 break 23511 } 23512 c := l.AuxInt 23513 x := l.Args[0] 23514 if !(l.Uses == 1) { 23515 break 23516 } 23517 b.Kind = BlockARMGE 23518 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 23519 v0.AuxInt = c 23520 v0.AddArg(x) 23521 b.SetControl(v0) 23522 b.Aux = nil 23523 return true 23524 } 23525 // match: (GE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no) 23526 // cond: l.Uses==1 23527 // result: (GE (CMPshiftLL x y [c]) yes no) 23528 for { 23529 v := b.Control 23530 if v.Op != OpARMCMPconst { 23531 break 23532 } 23533 if v.AuxInt != 0 { 23534 break 23535 } 23536 l := v.Args[0] 23537 if l.Op != OpARMSUBshiftLL { 23538 break 23539 } 23540 c := l.AuxInt 23541 _ = l.Args[1] 23542 x := l.Args[0] 23543 y := l.Args[1] 23544 if !(l.Uses == 1) { 23545 break 23546 } 23547 b.Kind = BlockARMGE 23548 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags) 23549 v0.AuxInt = c 23550 v0.AddArg(x) 23551 v0.AddArg(y) 23552 b.SetControl(v0) 23553 b.Aux = nil 23554 return true 23555 } 23556 // match: (GE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no) 23557 // cond: l.Uses==1 23558 // result: (GE (CMPshiftRL x y [c]) yes no) 23559 for { 23560 v := b.Control 23561 if v.Op != OpARMCMPconst { 23562 break 23563 } 23564 if v.AuxInt != 0 { 23565 break 23566 } 23567 l := v.Args[0] 23568 if l.Op != OpARMSUBshiftRL { 23569 break 23570 } 23571 c := l.AuxInt 23572 _ = l.Args[1] 23573 x := l.Args[0] 23574 y := l.Args[1] 23575 if !(l.Uses == 1) { 23576 break 23577 } 23578 b.Kind = BlockARMGE 23579 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags) 23580 v0.AuxInt = c 23581 v0.AddArg(x) 23582 v0.AddArg(y) 23583 b.SetControl(v0) 23584 b.Aux = nil 23585 return true 23586 } 23587 // match: (GE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no) 23588 // cond: l.Uses==1 23589 // result: (GE (CMPshiftRA x y [c]) yes no) 23590 for { 23591 v := b.Control 23592 if v.Op != OpARMCMPconst { 23593 break 23594 } 23595 if v.AuxInt != 0 { 23596 break 23597 } 23598 l := v.Args[0] 23599 if l.Op != OpARMSUBshiftRA { 23600 break 23601 } 23602 c := l.AuxInt 23603 _ = l.Args[1] 23604 x := l.Args[0] 23605 y := l.Args[1] 23606 if !(l.Uses == 1) { 23607 break 23608 } 23609 b.Kind = BlockARMGE 23610 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags) 23611 v0.AuxInt = c 23612 v0.AddArg(x) 23613 v0.AddArg(y) 23614 b.SetControl(v0) 23615 b.Aux = nil 23616 return true 23617 } 23618 // match: (GE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no) 23619 // cond: l.Uses==1 23620 // result: (GE (CMPshiftLLreg x y z) yes no) 23621 for { 23622 v := b.Control 23623 if v.Op != OpARMCMPconst { 23624 break 23625 } 23626 if v.AuxInt != 0 { 23627 break 23628 } 23629 l := v.Args[0] 23630 if l.Op != OpARMSUBshiftLLreg { 23631 break 23632 } 23633 _ = l.Args[2] 23634 x := l.Args[0] 23635 y := l.Args[1] 23636 z := l.Args[2] 23637 if !(l.Uses == 1) { 23638 break 23639 } 23640 b.Kind = BlockARMGE 23641 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags) 23642 v0.AddArg(x) 23643 v0.AddArg(y) 23644 v0.AddArg(z) 23645 b.SetControl(v0) 23646 b.Aux = nil 23647 return true 23648 } 23649 // match: (GE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no) 23650 // cond: l.Uses==1 23651 // result: (GE (CMPshiftRLreg x y z) yes no) 23652 for { 23653 v := b.Control 23654 if v.Op != OpARMCMPconst { 23655 break 23656 } 23657 if v.AuxInt != 0 { 23658 break 23659 } 23660 l := v.Args[0] 23661 if l.Op != OpARMSUBshiftRLreg { 23662 break 23663 } 23664 _ = l.Args[2] 23665 x := l.Args[0] 23666 y := l.Args[1] 23667 z := l.Args[2] 23668 if !(l.Uses == 1) { 23669 break 23670 } 23671 b.Kind = BlockARMGE 23672 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags) 23673 v0.AddArg(x) 23674 v0.AddArg(y) 23675 v0.AddArg(z) 23676 b.SetControl(v0) 23677 b.Aux = nil 23678 return true 23679 } 23680 // match: (GE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no) 23681 // cond: l.Uses==1 23682 // result: (GE (CMPshiftRAreg x y z) yes no) 23683 for { 23684 v := b.Control 23685 if v.Op != OpARMCMPconst { 23686 break 23687 } 23688 if v.AuxInt != 0 { 23689 break 23690 } 23691 l := v.Args[0] 23692 if l.Op != OpARMSUBshiftRAreg { 23693 break 23694 } 23695 _ = l.Args[2] 23696 x := l.Args[0] 23697 y := l.Args[1] 23698 z := l.Args[2] 23699 if !(l.Uses == 1) { 23700 break 23701 } 23702 b.Kind = BlockARMGE 23703 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags) 23704 v0.AddArg(x) 23705 v0.AddArg(y) 23706 v0.AddArg(z) 23707 b.SetControl(v0) 23708 b.Aux = nil 23709 return true 23710 } 23711 // match: (GE (CMPconst [0] l:(ADD x y)) yes no) 23712 // cond: l.Uses==1 23713 // result: (GE (CMN x y) yes no) 23714 for { 23715 v := b.Control 23716 if v.Op != OpARMCMPconst { 23717 break 23718 } 23719 if v.AuxInt != 0 { 23720 break 23721 } 23722 l := v.Args[0] 23723 if l.Op != OpARMADD { 23724 break 23725 } 23726 _ = l.Args[1] 23727 x := l.Args[0] 23728 y := l.Args[1] 23729 if !(l.Uses == 1) { 23730 break 23731 } 23732 b.Kind = BlockARMGE 23733 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags) 23734 v0.AddArg(x) 23735 v0.AddArg(y) 23736 b.SetControl(v0) 23737 b.Aux = nil 23738 return true 23739 } 23740 // match: (GE (CMPconst [0] l:(MULA x y a)) yes no) 23741 // cond: l.Uses==1 23742 // result: (GE (CMN a (MUL <x.Type> x y)) yes no) 23743 for { 23744 v := b.Control 23745 if v.Op != OpARMCMPconst { 23746 break 23747 } 23748 if v.AuxInt != 0 { 23749 break 23750 } 23751 l := v.Args[0] 23752 if l.Op != OpARMMULA { 23753 break 23754 } 23755 _ = l.Args[2] 23756 x := l.Args[0] 23757 y := l.Args[1] 23758 a := l.Args[2] 23759 if !(l.Uses == 1) { 23760 break 23761 } 23762 b.Kind = BlockARMGE 23763 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags) 23764 v0.AddArg(a) 23765 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type) 23766 v1.AddArg(x) 23767 v1.AddArg(y) 23768 v0.AddArg(v1) 23769 b.SetControl(v0) 23770 b.Aux = nil 23771 return true 23772 } 23773 // match: (GE (CMPconst [0] l:(ADDconst [c] x)) yes no) 23774 // cond: l.Uses==1 23775 // result: (GE (CMNconst [c] x) yes no) 23776 for { 23777 v := b.Control 23778 if v.Op != OpARMCMPconst { 23779 break 23780 } 23781 if v.AuxInt != 0 { 23782 break 23783 } 23784 l := v.Args[0] 23785 if l.Op != OpARMADDconst { 23786 break 23787 } 23788 c := l.AuxInt 23789 x := l.Args[0] 23790 if !(l.Uses == 1) { 23791 break 23792 } 23793 b.Kind = BlockARMGE 23794 v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags) 23795 v0.AuxInt = c 23796 v0.AddArg(x) 23797 b.SetControl(v0) 23798 b.Aux = nil 23799 return true 23800 } 23801 // match: (GE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no) 23802 // cond: l.Uses==1 23803 // result: (GE (CMNshiftLL x y [c]) yes no) 23804 for { 23805 v := b.Control 23806 if v.Op != OpARMCMPconst { 23807 break 23808 } 23809 if v.AuxInt != 0 { 23810 break 23811 } 23812 l := v.Args[0] 23813 if l.Op != OpARMADDshiftLL { 23814 break 23815 } 23816 c := l.AuxInt 23817 _ = l.Args[1] 23818 x := l.Args[0] 23819 y := l.Args[1] 23820 if !(l.Uses == 1) { 23821 break 23822 } 23823 b.Kind = BlockARMGE 23824 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags) 23825 v0.AuxInt = c 23826 v0.AddArg(x) 23827 v0.AddArg(y) 23828 b.SetControl(v0) 23829 b.Aux = nil 23830 return true 23831 } 23832 // match: (GE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no) 23833 // cond: l.Uses==1 23834 // result: (GE (CMNshiftRL x y [c]) yes no) 23835 for { 23836 v := b.Control 23837 if v.Op != OpARMCMPconst { 23838 break 23839 } 23840 if v.AuxInt != 0 { 23841 break 23842 } 23843 l := v.Args[0] 23844 if l.Op != OpARMADDshiftRL { 23845 break 23846 } 23847 c := l.AuxInt 23848 _ = l.Args[1] 23849 x := l.Args[0] 23850 y := l.Args[1] 23851 if !(l.Uses == 1) { 23852 break 23853 } 23854 b.Kind = BlockARMGE 23855 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags) 23856 v0.AuxInt = c 23857 v0.AddArg(x) 23858 v0.AddArg(y) 23859 b.SetControl(v0) 23860 b.Aux = nil 23861 return true 23862 } 23863 // match: (GE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no) 23864 // cond: l.Uses==1 23865 // result: (GE (CMNshiftRA x y [c]) yes no) 23866 for { 23867 v := b.Control 23868 if v.Op != OpARMCMPconst { 23869 break 23870 } 23871 if v.AuxInt != 0 { 23872 break 23873 } 23874 l := v.Args[0] 23875 if l.Op != OpARMADDshiftRA { 23876 break 23877 } 23878 c := l.AuxInt 23879 _ = l.Args[1] 23880 x := l.Args[0] 23881 y := l.Args[1] 23882 if !(l.Uses == 1) { 23883 break 23884 } 23885 b.Kind = BlockARMGE 23886 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags) 23887 v0.AuxInt = c 23888 v0.AddArg(x) 23889 v0.AddArg(y) 23890 b.SetControl(v0) 23891 b.Aux = nil 23892 return true 23893 } 23894 // match: (GE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) 23895 // cond: l.Uses==1 23896 // result: (GE (CMNshiftLLreg x y z) yes no) 23897 for { 23898 v := b.Control 23899 if v.Op != OpARMCMPconst { 23900 break 23901 } 23902 if v.AuxInt != 0 { 23903 break 23904 } 23905 l := v.Args[0] 23906 if l.Op != OpARMADDshiftLLreg { 23907 break 23908 } 23909 _ = l.Args[2] 23910 x := l.Args[0] 23911 y := l.Args[1] 23912 z := l.Args[2] 23913 if !(l.Uses == 1) { 23914 break 23915 } 23916 b.Kind = BlockARMGE 23917 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags) 23918 v0.AddArg(x) 23919 v0.AddArg(y) 23920 v0.AddArg(z) 23921 b.SetControl(v0) 23922 b.Aux = nil 23923 return true 23924 } 23925 // match: (GE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) 23926 // cond: l.Uses==1 23927 // result: (GE (CMNshiftRLreg x y z) yes no) 23928 for { 23929 v := b.Control 23930 if v.Op != OpARMCMPconst { 23931 break 23932 } 23933 if v.AuxInt != 0 { 23934 break 23935 } 23936 l := v.Args[0] 23937 if l.Op != OpARMADDshiftRLreg { 23938 break 23939 } 23940 _ = l.Args[2] 23941 x := l.Args[0] 23942 y := l.Args[1] 23943 z := l.Args[2] 23944 if !(l.Uses == 1) { 23945 break 23946 } 23947 b.Kind = BlockARMGE 23948 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags) 23949 v0.AddArg(x) 23950 v0.AddArg(y) 23951 v0.AddArg(z) 23952 b.SetControl(v0) 23953 b.Aux = nil 23954 return true 23955 } 23956 // match: (GE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) 23957 // cond: l.Uses==1 23958 // result: (GE (CMNshiftRAreg x y z) yes no) 23959 for { 23960 v := b.Control 23961 if v.Op != OpARMCMPconst { 23962 break 23963 } 23964 if v.AuxInt != 0 { 23965 break 23966 } 23967 l := v.Args[0] 23968 if l.Op != OpARMADDshiftRAreg { 23969 break 23970 } 23971 _ = l.Args[2] 23972 x := l.Args[0] 23973 y := l.Args[1] 23974 z := l.Args[2] 23975 if !(l.Uses == 1) { 23976 break 23977 } 23978 b.Kind = BlockARMGE 23979 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags) 23980 v0.AddArg(x) 23981 v0.AddArg(y) 23982 v0.AddArg(z) 23983 b.SetControl(v0) 23984 b.Aux = nil 23985 return true 23986 } 23987 // match: (GE (CMPconst [0] l:(AND x y)) yes no) 23988 // cond: l.Uses==1 23989 // result: (GE (TST x y) yes no) 23990 for { 23991 v := b.Control 23992 if v.Op != OpARMCMPconst { 23993 break 23994 } 23995 if v.AuxInt != 0 { 23996 break 23997 } 23998 l := v.Args[0] 23999 if l.Op != OpARMAND { 24000 break 24001 } 24002 _ = l.Args[1] 24003 x := l.Args[0] 24004 y := l.Args[1] 24005 if !(l.Uses == 1) { 24006 break 24007 } 24008 b.Kind = BlockARMGE 24009 v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags) 24010 v0.AddArg(x) 24011 v0.AddArg(y) 24012 b.SetControl(v0) 24013 b.Aux = nil 24014 return true 24015 } 24016 // match: (GE (CMPconst [0] l:(ANDconst [c] x)) yes no) 24017 // cond: l.Uses==1 24018 // result: (GE (TSTconst [c] x) yes no) 24019 for { 24020 v := b.Control 24021 if v.Op != OpARMCMPconst { 24022 break 24023 } 24024 if v.AuxInt != 0 { 24025 break 24026 } 24027 l := v.Args[0] 24028 if l.Op != OpARMANDconst { 24029 break 24030 } 24031 c := l.AuxInt 24032 x := l.Args[0] 24033 if !(l.Uses == 1) { 24034 break 24035 } 24036 b.Kind = BlockARMGE 24037 v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags) 24038 v0.AuxInt = c 24039 v0.AddArg(x) 24040 b.SetControl(v0) 24041 b.Aux = nil 24042 return true 24043 } 24044 // match: (GE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) 24045 // cond: l.Uses==1 24046 // result: (GE (TSTshiftLL x y [c]) yes no) 24047 for { 24048 v := b.Control 24049 if v.Op != OpARMCMPconst { 24050 break 24051 } 24052 if v.AuxInt != 0 { 24053 break 24054 } 24055 l := v.Args[0] 24056 if l.Op != OpARMANDshiftLL { 24057 break 24058 } 24059 c := l.AuxInt 24060 _ = l.Args[1] 24061 x := l.Args[0] 24062 y := l.Args[1] 24063 if !(l.Uses == 1) { 24064 break 24065 } 24066 b.Kind = BlockARMGE 24067 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags) 24068 v0.AuxInt = c 24069 v0.AddArg(x) 24070 v0.AddArg(y) 24071 b.SetControl(v0) 24072 b.Aux = nil 24073 return true 24074 } 24075 // match: (GE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) 24076 // cond: l.Uses==1 24077 // result: (GE (TSTshiftRL x y [c]) yes no) 24078 for { 24079 v := b.Control 24080 if v.Op != OpARMCMPconst { 24081 break 24082 } 24083 if v.AuxInt != 0 { 24084 break 24085 } 24086 l := v.Args[0] 24087 if l.Op != OpARMANDshiftRL { 24088 break 24089 } 24090 c := l.AuxInt 24091 _ = l.Args[1] 24092 x := l.Args[0] 24093 y := l.Args[1] 24094 if !(l.Uses == 1) { 24095 break 24096 } 24097 b.Kind = BlockARMGE 24098 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags) 24099 v0.AuxInt = c 24100 v0.AddArg(x) 24101 v0.AddArg(y) 24102 b.SetControl(v0) 24103 b.Aux = nil 24104 return true 24105 } 24106 // match: (GE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) 24107 // cond: l.Uses==1 24108 // result: (GE (TSTshiftRA x y [c]) yes no) 24109 for { 24110 v := b.Control 24111 if v.Op != OpARMCMPconst { 24112 break 24113 } 24114 if v.AuxInt != 0 { 24115 break 24116 } 24117 l := v.Args[0] 24118 if l.Op != OpARMANDshiftRA { 24119 break 24120 } 24121 c := l.AuxInt 24122 _ = l.Args[1] 24123 x := l.Args[0] 24124 y := l.Args[1] 24125 if !(l.Uses == 1) { 24126 break 24127 } 24128 b.Kind = BlockARMGE 24129 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags) 24130 v0.AuxInt = c 24131 v0.AddArg(x) 24132 v0.AddArg(y) 24133 b.SetControl(v0) 24134 b.Aux = nil 24135 return true 24136 } 24137 // match: (GE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) 24138 // cond: l.Uses==1 24139 // result: (GE (TSTshiftLLreg x y z) yes no) 24140 for { 24141 v := b.Control 24142 if v.Op != OpARMCMPconst { 24143 break 24144 } 24145 if v.AuxInt != 0 { 24146 break 24147 } 24148 l := v.Args[0] 24149 if l.Op != OpARMANDshiftLLreg { 24150 break 24151 } 24152 _ = l.Args[2] 24153 x := l.Args[0] 24154 y := l.Args[1] 24155 z := l.Args[2] 24156 if !(l.Uses == 1) { 24157 break 24158 } 24159 b.Kind = BlockARMGE 24160 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags) 24161 v0.AddArg(x) 24162 v0.AddArg(y) 24163 v0.AddArg(z) 24164 b.SetControl(v0) 24165 b.Aux = nil 24166 return true 24167 } 24168 // match: (GE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) 24169 // cond: l.Uses==1 24170 // result: (GE (TSTshiftRLreg x y z) yes no) 24171 for { 24172 v := b.Control 24173 if v.Op != OpARMCMPconst { 24174 break 24175 } 24176 if v.AuxInt != 0 { 24177 break 24178 } 24179 l := v.Args[0] 24180 if l.Op != OpARMANDshiftRLreg { 24181 break 24182 } 24183 _ = l.Args[2] 24184 x := l.Args[0] 24185 y := l.Args[1] 24186 z := l.Args[2] 24187 if !(l.Uses == 1) { 24188 break 24189 } 24190 b.Kind = BlockARMGE 24191 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags) 24192 v0.AddArg(x) 24193 v0.AddArg(y) 24194 v0.AddArg(z) 24195 b.SetControl(v0) 24196 b.Aux = nil 24197 return true 24198 } 24199 // match: (GE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) 24200 // cond: l.Uses==1 24201 // result: (GE (TSTshiftRAreg x y z) yes no) 24202 for { 24203 v := b.Control 24204 if v.Op != OpARMCMPconst { 24205 break 24206 } 24207 if v.AuxInt != 0 { 24208 break 24209 } 24210 l := v.Args[0] 24211 if l.Op != OpARMANDshiftRAreg { 24212 break 24213 } 24214 _ = l.Args[2] 24215 x := l.Args[0] 24216 y := l.Args[1] 24217 z := l.Args[2] 24218 if !(l.Uses == 1) { 24219 break 24220 } 24221 b.Kind = BlockARMGE 24222 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags) 24223 v0.AddArg(x) 24224 v0.AddArg(y) 24225 v0.AddArg(z) 24226 b.SetControl(v0) 24227 b.Aux = nil 24228 return true 24229 } 24230 // match: (GE (CMPconst [0] l:(XOR x y)) yes no) 24231 // cond: l.Uses==1 24232 // result: (GE (TEQ x y) yes no) 24233 for { 24234 v := b.Control 24235 if v.Op != OpARMCMPconst { 24236 break 24237 } 24238 if v.AuxInt != 0 { 24239 break 24240 } 24241 l := v.Args[0] 24242 if l.Op != OpARMXOR { 24243 break 24244 } 24245 _ = l.Args[1] 24246 x := l.Args[0] 24247 y := l.Args[1] 24248 if !(l.Uses == 1) { 24249 break 24250 } 24251 b.Kind = BlockARMGE 24252 v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags) 24253 v0.AddArg(x) 24254 v0.AddArg(y) 24255 b.SetControl(v0) 24256 b.Aux = nil 24257 return true 24258 } 24259 // match: (GE (CMPconst [0] l:(XORconst [c] x)) yes no) 24260 // cond: l.Uses==1 24261 // result: (GE (TEQconst [c] x) yes no) 24262 for { 24263 v := b.Control 24264 if v.Op != OpARMCMPconst { 24265 break 24266 } 24267 if v.AuxInt != 0 { 24268 break 24269 } 24270 l := v.Args[0] 24271 if l.Op != OpARMXORconst { 24272 break 24273 } 24274 c := l.AuxInt 24275 x := l.Args[0] 24276 if !(l.Uses == 1) { 24277 break 24278 } 24279 b.Kind = BlockARMGE 24280 v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags) 24281 v0.AuxInt = c 24282 v0.AddArg(x) 24283 b.SetControl(v0) 24284 b.Aux = nil 24285 return true 24286 } 24287 // match: (GE (CMPconst [0] l:(XORshiftLL x y [c])) yes no) 24288 // cond: l.Uses==1 24289 // result: (GE (TEQshiftLL x y [c]) yes no) 24290 for { 24291 v := b.Control 24292 if v.Op != OpARMCMPconst { 24293 break 24294 } 24295 if v.AuxInt != 0 { 24296 break 24297 } 24298 l := v.Args[0] 24299 if l.Op != OpARMXORshiftLL { 24300 break 24301 } 24302 c := l.AuxInt 24303 _ = l.Args[1] 24304 x := l.Args[0] 24305 y := l.Args[1] 24306 if !(l.Uses == 1) { 24307 break 24308 } 24309 b.Kind = BlockARMGE 24310 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags) 24311 v0.AuxInt = c 24312 v0.AddArg(x) 24313 v0.AddArg(y) 24314 b.SetControl(v0) 24315 b.Aux = nil 24316 return true 24317 } 24318 // match: (GE (CMPconst [0] l:(XORshiftRL x y [c])) yes no) 24319 // cond: l.Uses==1 24320 // result: (GE (TEQshiftRL x y [c]) yes no) 24321 for { 24322 v := b.Control 24323 if v.Op != OpARMCMPconst { 24324 break 24325 } 24326 if v.AuxInt != 0 { 24327 break 24328 } 24329 l := v.Args[0] 24330 if l.Op != OpARMXORshiftRL { 24331 break 24332 } 24333 c := l.AuxInt 24334 _ = l.Args[1] 24335 x := l.Args[0] 24336 y := l.Args[1] 24337 if !(l.Uses == 1) { 24338 break 24339 } 24340 b.Kind = BlockARMGE 24341 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags) 24342 v0.AuxInt = c 24343 v0.AddArg(x) 24344 v0.AddArg(y) 24345 b.SetControl(v0) 24346 b.Aux = nil 24347 return true 24348 } 24349 // match: (GE (CMPconst [0] l:(XORshiftRA x y [c])) yes no) 24350 // cond: l.Uses==1 24351 // result: (GE (TEQshiftRA x y [c]) yes no) 24352 for { 24353 v := b.Control 24354 if v.Op != OpARMCMPconst { 24355 break 24356 } 24357 if v.AuxInt != 0 { 24358 break 24359 } 24360 l := v.Args[0] 24361 if l.Op != OpARMXORshiftRA { 24362 break 24363 } 24364 c := l.AuxInt 24365 _ = l.Args[1] 24366 x := l.Args[0] 24367 y := l.Args[1] 24368 if !(l.Uses == 1) { 24369 break 24370 } 24371 b.Kind = BlockARMGE 24372 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags) 24373 v0.AuxInt = c 24374 v0.AddArg(x) 24375 v0.AddArg(y) 24376 b.SetControl(v0) 24377 b.Aux = nil 24378 return true 24379 } 24380 // match: (GE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) 24381 // cond: l.Uses==1 24382 // result: (GE (TEQshiftLLreg x y z) yes no) 24383 for { 24384 v := b.Control 24385 if v.Op != OpARMCMPconst { 24386 break 24387 } 24388 if v.AuxInt != 0 { 24389 break 24390 } 24391 l := v.Args[0] 24392 if l.Op != OpARMXORshiftLLreg { 24393 break 24394 } 24395 _ = l.Args[2] 24396 x := l.Args[0] 24397 y := l.Args[1] 24398 z := l.Args[2] 24399 if !(l.Uses == 1) { 24400 break 24401 } 24402 b.Kind = BlockARMGE 24403 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags) 24404 v0.AddArg(x) 24405 v0.AddArg(y) 24406 v0.AddArg(z) 24407 b.SetControl(v0) 24408 b.Aux = nil 24409 return true 24410 } 24411 // match: (GE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) 24412 // cond: l.Uses==1 24413 // result: (GE (TEQshiftRLreg x y z) yes no) 24414 for { 24415 v := b.Control 24416 if v.Op != OpARMCMPconst { 24417 break 24418 } 24419 if v.AuxInt != 0 { 24420 break 24421 } 24422 l := v.Args[0] 24423 if l.Op != OpARMXORshiftRLreg { 24424 break 24425 } 24426 _ = l.Args[2] 24427 x := l.Args[0] 24428 y := l.Args[1] 24429 z := l.Args[2] 24430 if !(l.Uses == 1) { 24431 break 24432 } 24433 b.Kind = BlockARMGE 24434 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags) 24435 v0.AddArg(x) 24436 v0.AddArg(y) 24437 v0.AddArg(z) 24438 b.SetControl(v0) 24439 b.Aux = nil 24440 return true 24441 } 24442 // match: (GE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) 24443 // cond: l.Uses==1 24444 // result: (GE (TEQshiftRAreg x y z) yes no) 24445 for { 24446 v := b.Control 24447 if v.Op != OpARMCMPconst { 24448 break 24449 } 24450 if v.AuxInt != 0 { 24451 break 24452 } 24453 l := v.Args[0] 24454 if l.Op != OpARMXORshiftRAreg { 24455 break 24456 } 24457 _ = l.Args[2] 24458 x := l.Args[0] 24459 y := l.Args[1] 24460 z := l.Args[2] 24461 if !(l.Uses == 1) { 24462 break 24463 } 24464 b.Kind = BlockARMGE 24465 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags) 24466 v0.AddArg(x) 24467 v0.AddArg(y) 24468 v0.AddArg(z) 24469 b.SetControl(v0) 24470 b.Aux = nil 24471 return true 24472 } 24473 case BlockARMGT: 24474 // match: (GT (FlagEQ) yes no) 24475 // cond: 24476 // result: (First nil no yes) 24477 for { 24478 v := b.Control 24479 if v.Op != OpARMFlagEQ { 24480 break 24481 } 24482 b.Kind = BlockFirst 24483 b.SetControl(nil) 24484 b.Aux = nil 24485 b.swapSuccessors() 24486 return true 24487 } 24488 // match: (GT (FlagLT_ULT) yes no) 24489 // cond: 24490 // result: (First nil no yes) 24491 for { 24492 v := b.Control 24493 if v.Op != OpARMFlagLT_ULT { 24494 break 24495 } 24496 b.Kind = BlockFirst 24497 b.SetControl(nil) 24498 b.Aux = nil 24499 b.swapSuccessors() 24500 return true 24501 } 24502 // match: (GT (FlagLT_UGT) yes no) 24503 // cond: 24504 // result: (First nil no yes) 24505 for { 24506 v := b.Control 24507 if v.Op != OpARMFlagLT_UGT { 24508 break 24509 } 24510 b.Kind = BlockFirst 24511 b.SetControl(nil) 24512 b.Aux = nil 24513 b.swapSuccessors() 24514 return true 24515 } 24516 // match: (GT (FlagGT_ULT) yes no) 24517 // cond: 24518 // result: (First nil yes no) 24519 for { 24520 v := b.Control 24521 if v.Op != OpARMFlagGT_ULT { 24522 break 24523 } 24524 b.Kind = BlockFirst 24525 b.SetControl(nil) 24526 b.Aux = nil 24527 return true 24528 } 24529 // match: (GT (FlagGT_UGT) yes no) 24530 // cond: 24531 // result: (First nil yes no) 24532 for { 24533 v := b.Control 24534 if v.Op != OpARMFlagGT_UGT { 24535 break 24536 } 24537 b.Kind = BlockFirst 24538 b.SetControl(nil) 24539 b.Aux = nil 24540 return true 24541 } 24542 // match: (GT (InvertFlags cmp) yes no) 24543 // cond: 24544 // result: (LT cmp yes no) 24545 for { 24546 v := b.Control 24547 if v.Op != OpARMInvertFlags { 24548 break 24549 } 24550 cmp := v.Args[0] 24551 b.Kind = BlockARMLT 24552 b.SetControl(cmp) 24553 b.Aux = nil 24554 return true 24555 } 24556 // match: (GT (CMPconst [0] l:(SUB x y)) yes no) 24557 // cond: l.Uses==1 24558 // result: (GT (CMP x y) yes no) 24559 for { 24560 v := b.Control 24561 if v.Op != OpARMCMPconst { 24562 break 24563 } 24564 if v.AuxInt != 0 { 24565 break 24566 } 24567 l := v.Args[0] 24568 if l.Op != OpARMSUB { 24569 break 24570 } 24571 _ = l.Args[1] 24572 x := l.Args[0] 24573 y := l.Args[1] 24574 if !(l.Uses == 1) { 24575 break 24576 } 24577 b.Kind = BlockARMGT 24578 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 24579 v0.AddArg(x) 24580 v0.AddArg(y) 24581 b.SetControl(v0) 24582 b.Aux = nil 24583 return true 24584 } 24585 // match: (GT (CMPconst [0] l:(MULS x y a)) yes no) 24586 // cond: l.Uses==1 24587 // result: (GT (CMP a (MUL <x.Type> x y)) yes no) 24588 for { 24589 v := b.Control 24590 if v.Op != OpARMCMPconst { 24591 break 24592 } 24593 if v.AuxInt != 0 { 24594 break 24595 } 24596 l := v.Args[0] 24597 if l.Op != OpARMMULS { 24598 break 24599 } 24600 _ = l.Args[2] 24601 x := l.Args[0] 24602 y := l.Args[1] 24603 a := l.Args[2] 24604 if !(l.Uses == 1) { 24605 break 24606 } 24607 b.Kind = BlockARMGT 24608 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 24609 v0.AddArg(a) 24610 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type) 24611 v1.AddArg(x) 24612 v1.AddArg(y) 24613 v0.AddArg(v1) 24614 b.SetControl(v0) 24615 b.Aux = nil 24616 return true 24617 } 24618 // match: (GT (CMPconst [0] l:(SUBconst [c] x)) yes no) 24619 // cond: l.Uses==1 24620 // result: (GT (CMPconst [c] x) yes no) 24621 for { 24622 v := b.Control 24623 if v.Op != OpARMCMPconst { 24624 break 24625 } 24626 if v.AuxInt != 0 { 24627 break 24628 } 24629 l := v.Args[0] 24630 if l.Op != OpARMSUBconst { 24631 break 24632 } 24633 c := l.AuxInt 24634 x := l.Args[0] 24635 if !(l.Uses == 1) { 24636 break 24637 } 24638 b.Kind = BlockARMGT 24639 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 24640 v0.AuxInt = c 24641 v0.AddArg(x) 24642 b.SetControl(v0) 24643 b.Aux = nil 24644 return true 24645 } 24646 // match: (GT (CMPconst [0] l:(SUBshiftLL x y [c])) yes no) 24647 // cond: l.Uses==1 24648 // result: (GT (CMPshiftLL x y [c]) yes no) 24649 for { 24650 v := b.Control 24651 if v.Op != OpARMCMPconst { 24652 break 24653 } 24654 if v.AuxInt != 0 { 24655 break 24656 } 24657 l := v.Args[0] 24658 if l.Op != OpARMSUBshiftLL { 24659 break 24660 } 24661 c := l.AuxInt 24662 _ = l.Args[1] 24663 x := l.Args[0] 24664 y := l.Args[1] 24665 if !(l.Uses == 1) { 24666 break 24667 } 24668 b.Kind = BlockARMGT 24669 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags) 24670 v0.AuxInt = c 24671 v0.AddArg(x) 24672 v0.AddArg(y) 24673 b.SetControl(v0) 24674 b.Aux = nil 24675 return true 24676 } 24677 // match: (GT (CMPconst [0] l:(SUBshiftRL x y [c])) yes no) 24678 // cond: l.Uses==1 24679 // result: (GT (CMPshiftRL x y [c]) yes no) 24680 for { 24681 v := b.Control 24682 if v.Op != OpARMCMPconst { 24683 break 24684 } 24685 if v.AuxInt != 0 { 24686 break 24687 } 24688 l := v.Args[0] 24689 if l.Op != OpARMSUBshiftRL { 24690 break 24691 } 24692 c := l.AuxInt 24693 _ = l.Args[1] 24694 x := l.Args[0] 24695 y := l.Args[1] 24696 if !(l.Uses == 1) { 24697 break 24698 } 24699 b.Kind = BlockARMGT 24700 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags) 24701 v0.AuxInt = c 24702 v0.AddArg(x) 24703 v0.AddArg(y) 24704 b.SetControl(v0) 24705 b.Aux = nil 24706 return true 24707 } 24708 // match: (GT (CMPconst [0] l:(SUBshiftRA x y [c])) yes no) 24709 // cond: l.Uses==1 24710 // result: (GT (CMPshiftRA x y [c]) yes no) 24711 for { 24712 v := b.Control 24713 if v.Op != OpARMCMPconst { 24714 break 24715 } 24716 if v.AuxInt != 0 { 24717 break 24718 } 24719 l := v.Args[0] 24720 if l.Op != OpARMSUBshiftRA { 24721 break 24722 } 24723 c := l.AuxInt 24724 _ = l.Args[1] 24725 x := l.Args[0] 24726 y := l.Args[1] 24727 if !(l.Uses == 1) { 24728 break 24729 } 24730 b.Kind = BlockARMGT 24731 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags) 24732 v0.AuxInt = c 24733 v0.AddArg(x) 24734 v0.AddArg(y) 24735 b.SetControl(v0) 24736 b.Aux = nil 24737 return true 24738 } 24739 // match: (GT (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no) 24740 // cond: l.Uses==1 24741 // result: (GT (CMPshiftLLreg x y z) yes no) 24742 for { 24743 v := b.Control 24744 if v.Op != OpARMCMPconst { 24745 break 24746 } 24747 if v.AuxInt != 0 { 24748 break 24749 } 24750 l := v.Args[0] 24751 if l.Op != OpARMSUBshiftLLreg { 24752 break 24753 } 24754 _ = l.Args[2] 24755 x := l.Args[0] 24756 y := l.Args[1] 24757 z := l.Args[2] 24758 if !(l.Uses == 1) { 24759 break 24760 } 24761 b.Kind = BlockARMGT 24762 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags) 24763 v0.AddArg(x) 24764 v0.AddArg(y) 24765 v0.AddArg(z) 24766 b.SetControl(v0) 24767 b.Aux = nil 24768 return true 24769 } 24770 // match: (GT (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no) 24771 // cond: l.Uses==1 24772 // result: (GT (CMPshiftRLreg x y z) yes no) 24773 for { 24774 v := b.Control 24775 if v.Op != OpARMCMPconst { 24776 break 24777 } 24778 if v.AuxInt != 0 { 24779 break 24780 } 24781 l := v.Args[0] 24782 if l.Op != OpARMSUBshiftRLreg { 24783 break 24784 } 24785 _ = l.Args[2] 24786 x := l.Args[0] 24787 y := l.Args[1] 24788 z := l.Args[2] 24789 if !(l.Uses == 1) { 24790 break 24791 } 24792 b.Kind = BlockARMGT 24793 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags) 24794 v0.AddArg(x) 24795 v0.AddArg(y) 24796 v0.AddArg(z) 24797 b.SetControl(v0) 24798 b.Aux = nil 24799 return true 24800 } 24801 // match: (GT (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no) 24802 // cond: l.Uses==1 24803 // result: (GT (CMPshiftRAreg x y z) yes no) 24804 for { 24805 v := b.Control 24806 if v.Op != OpARMCMPconst { 24807 break 24808 } 24809 if v.AuxInt != 0 { 24810 break 24811 } 24812 l := v.Args[0] 24813 if l.Op != OpARMSUBshiftRAreg { 24814 break 24815 } 24816 _ = l.Args[2] 24817 x := l.Args[0] 24818 y := l.Args[1] 24819 z := l.Args[2] 24820 if !(l.Uses == 1) { 24821 break 24822 } 24823 b.Kind = BlockARMGT 24824 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags) 24825 v0.AddArg(x) 24826 v0.AddArg(y) 24827 v0.AddArg(z) 24828 b.SetControl(v0) 24829 b.Aux = nil 24830 return true 24831 } 24832 // match: (GT (CMPconst [0] l:(ADD x y)) yes no) 24833 // cond: l.Uses==1 24834 // result: (GT (CMN x y) yes no) 24835 for { 24836 v := b.Control 24837 if v.Op != OpARMCMPconst { 24838 break 24839 } 24840 if v.AuxInt != 0 { 24841 break 24842 } 24843 l := v.Args[0] 24844 if l.Op != OpARMADD { 24845 break 24846 } 24847 _ = l.Args[1] 24848 x := l.Args[0] 24849 y := l.Args[1] 24850 if !(l.Uses == 1) { 24851 break 24852 } 24853 b.Kind = BlockARMGT 24854 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags) 24855 v0.AddArg(x) 24856 v0.AddArg(y) 24857 b.SetControl(v0) 24858 b.Aux = nil 24859 return true 24860 } 24861 // match: (GT (CMPconst [0] l:(ADDconst [c] x)) yes no) 24862 // cond: l.Uses==1 24863 // result: (GT (CMNconst [c] x) yes no) 24864 for { 24865 v := b.Control 24866 if v.Op != OpARMCMPconst { 24867 break 24868 } 24869 if v.AuxInt != 0 { 24870 break 24871 } 24872 l := v.Args[0] 24873 if l.Op != OpARMADDconst { 24874 break 24875 } 24876 c := l.AuxInt 24877 x := l.Args[0] 24878 if !(l.Uses == 1) { 24879 break 24880 } 24881 b.Kind = BlockARMGT 24882 v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags) 24883 v0.AuxInt = c 24884 v0.AddArg(x) 24885 b.SetControl(v0) 24886 b.Aux = nil 24887 return true 24888 } 24889 // match: (GT (CMPconst [0] l:(ADDshiftLL x y [c])) yes no) 24890 // cond: l.Uses==1 24891 // result: (GT (CMNshiftLL x y [c]) yes no) 24892 for { 24893 v := b.Control 24894 if v.Op != OpARMCMPconst { 24895 break 24896 } 24897 if v.AuxInt != 0 { 24898 break 24899 } 24900 l := v.Args[0] 24901 if l.Op != OpARMADDshiftLL { 24902 break 24903 } 24904 c := l.AuxInt 24905 _ = l.Args[1] 24906 x := l.Args[0] 24907 y := l.Args[1] 24908 if !(l.Uses == 1) { 24909 break 24910 } 24911 b.Kind = BlockARMGT 24912 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags) 24913 v0.AuxInt = c 24914 v0.AddArg(x) 24915 v0.AddArg(y) 24916 b.SetControl(v0) 24917 b.Aux = nil 24918 return true 24919 } 24920 // match: (GT (CMPconst [0] l:(ADDshiftRL x y [c])) yes no) 24921 // cond: l.Uses==1 24922 // result: (GT (CMNshiftRL x y [c]) yes no) 24923 for { 24924 v := b.Control 24925 if v.Op != OpARMCMPconst { 24926 break 24927 } 24928 if v.AuxInt != 0 { 24929 break 24930 } 24931 l := v.Args[0] 24932 if l.Op != OpARMADDshiftRL { 24933 break 24934 } 24935 c := l.AuxInt 24936 _ = l.Args[1] 24937 x := l.Args[0] 24938 y := l.Args[1] 24939 if !(l.Uses == 1) { 24940 break 24941 } 24942 b.Kind = BlockARMGT 24943 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags) 24944 v0.AuxInt = c 24945 v0.AddArg(x) 24946 v0.AddArg(y) 24947 b.SetControl(v0) 24948 b.Aux = nil 24949 return true 24950 } 24951 // match: (GT (CMPconst [0] l:(ADDshiftRA x y [c])) yes no) 24952 // cond: l.Uses==1 24953 // result: (GT (CMNshiftRA x y [c]) yes no) 24954 for { 24955 v := b.Control 24956 if v.Op != OpARMCMPconst { 24957 break 24958 } 24959 if v.AuxInt != 0 { 24960 break 24961 } 24962 l := v.Args[0] 24963 if l.Op != OpARMADDshiftRA { 24964 break 24965 } 24966 c := l.AuxInt 24967 _ = l.Args[1] 24968 x := l.Args[0] 24969 y := l.Args[1] 24970 if !(l.Uses == 1) { 24971 break 24972 } 24973 b.Kind = BlockARMGT 24974 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags) 24975 v0.AuxInt = c 24976 v0.AddArg(x) 24977 v0.AddArg(y) 24978 b.SetControl(v0) 24979 b.Aux = nil 24980 return true 24981 } 24982 // match: (GT (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) 24983 // cond: l.Uses==1 24984 // result: (GT (CMNshiftLLreg x y z) yes no) 24985 for { 24986 v := b.Control 24987 if v.Op != OpARMCMPconst { 24988 break 24989 } 24990 if v.AuxInt != 0 { 24991 break 24992 } 24993 l := v.Args[0] 24994 if l.Op != OpARMADDshiftLLreg { 24995 break 24996 } 24997 _ = l.Args[2] 24998 x := l.Args[0] 24999 y := l.Args[1] 25000 z := l.Args[2] 25001 if !(l.Uses == 1) { 25002 break 25003 } 25004 b.Kind = BlockARMGT 25005 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags) 25006 v0.AddArg(x) 25007 v0.AddArg(y) 25008 v0.AddArg(z) 25009 b.SetControl(v0) 25010 b.Aux = nil 25011 return true 25012 } 25013 // match: (GT (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) 25014 // cond: l.Uses==1 25015 // result: (GT (CMNshiftRLreg x y z) yes no) 25016 for { 25017 v := b.Control 25018 if v.Op != OpARMCMPconst { 25019 break 25020 } 25021 if v.AuxInt != 0 { 25022 break 25023 } 25024 l := v.Args[0] 25025 if l.Op != OpARMADDshiftRLreg { 25026 break 25027 } 25028 _ = l.Args[2] 25029 x := l.Args[0] 25030 y := l.Args[1] 25031 z := l.Args[2] 25032 if !(l.Uses == 1) { 25033 break 25034 } 25035 b.Kind = BlockARMGT 25036 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags) 25037 v0.AddArg(x) 25038 v0.AddArg(y) 25039 v0.AddArg(z) 25040 b.SetControl(v0) 25041 b.Aux = nil 25042 return true 25043 } 25044 // match: (GT (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) 25045 // cond: l.Uses==1 25046 // result: (GT (CMNshiftRAreg x y z) yes no) 25047 for { 25048 v := b.Control 25049 if v.Op != OpARMCMPconst { 25050 break 25051 } 25052 if v.AuxInt != 0 { 25053 break 25054 } 25055 l := v.Args[0] 25056 if l.Op != OpARMADDshiftRAreg { 25057 break 25058 } 25059 _ = l.Args[2] 25060 x := l.Args[0] 25061 y := l.Args[1] 25062 z := l.Args[2] 25063 if !(l.Uses == 1) { 25064 break 25065 } 25066 b.Kind = BlockARMGT 25067 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags) 25068 v0.AddArg(x) 25069 v0.AddArg(y) 25070 v0.AddArg(z) 25071 b.SetControl(v0) 25072 b.Aux = nil 25073 return true 25074 } 25075 // match: (GT (CMPconst [0] l:(AND x y)) yes no) 25076 // cond: l.Uses==1 25077 // result: (GT (TST x y) yes no) 25078 for { 25079 v := b.Control 25080 if v.Op != OpARMCMPconst { 25081 break 25082 } 25083 if v.AuxInt != 0 { 25084 break 25085 } 25086 l := v.Args[0] 25087 if l.Op != OpARMAND { 25088 break 25089 } 25090 _ = l.Args[1] 25091 x := l.Args[0] 25092 y := l.Args[1] 25093 if !(l.Uses == 1) { 25094 break 25095 } 25096 b.Kind = BlockARMGT 25097 v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags) 25098 v0.AddArg(x) 25099 v0.AddArg(y) 25100 b.SetControl(v0) 25101 b.Aux = nil 25102 return true 25103 } 25104 // match: (GT (CMPconst [0] l:(MULA x y a)) yes no) 25105 // cond: l.Uses==1 25106 // result: (GT (CMN a (MUL <x.Type> x y)) yes no) 25107 for { 25108 v := b.Control 25109 if v.Op != OpARMCMPconst { 25110 break 25111 } 25112 if v.AuxInt != 0 { 25113 break 25114 } 25115 l := v.Args[0] 25116 if l.Op != OpARMMULA { 25117 break 25118 } 25119 _ = l.Args[2] 25120 x := l.Args[0] 25121 y := l.Args[1] 25122 a := l.Args[2] 25123 if !(l.Uses == 1) { 25124 break 25125 } 25126 b.Kind = BlockARMGT 25127 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags) 25128 v0.AddArg(a) 25129 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type) 25130 v1.AddArg(x) 25131 v1.AddArg(y) 25132 v0.AddArg(v1) 25133 b.SetControl(v0) 25134 b.Aux = nil 25135 return true 25136 } 25137 // match: (GT (CMPconst [0] l:(ANDconst [c] x)) yes no) 25138 // cond: l.Uses==1 25139 // result: (GT (TSTconst [c] x) yes no) 25140 for { 25141 v := b.Control 25142 if v.Op != OpARMCMPconst { 25143 break 25144 } 25145 if v.AuxInt != 0 { 25146 break 25147 } 25148 l := v.Args[0] 25149 if l.Op != OpARMANDconst { 25150 break 25151 } 25152 c := l.AuxInt 25153 x := l.Args[0] 25154 if !(l.Uses == 1) { 25155 break 25156 } 25157 b.Kind = BlockARMGT 25158 v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags) 25159 v0.AuxInt = c 25160 v0.AddArg(x) 25161 b.SetControl(v0) 25162 b.Aux = nil 25163 return true 25164 } 25165 // match: (GT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) 25166 // cond: l.Uses==1 25167 // result: (GT (TSTshiftLL x y [c]) yes no) 25168 for { 25169 v := b.Control 25170 if v.Op != OpARMCMPconst { 25171 break 25172 } 25173 if v.AuxInt != 0 { 25174 break 25175 } 25176 l := v.Args[0] 25177 if l.Op != OpARMANDshiftLL { 25178 break 25179 } 25180 c := l.AuxInt 25181 _ = l.Args[1] 25182 x := l.Args[0] 25183 y := l.Args[1] 25184 if !(l.Uses == 1) { 25185 break 25186 } 25187 b.Kind = BlockARMGT 25188 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags) 25189 v0.AuxInt = c 25190 v0.AddArg(x) 25191 v0.AddArg(y) 25192 b.SetControl(v0) 25193 b.Aux = nil 25194 return true 25195 } 25196 // match: (GT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) 25197 // cond: l.Uses==1 25198 // result: (GT (TSTshiftRL x y [c]) yes no) 25199 for { 25200 v := b.Control 25201 if v.Op != OpARMCMPconst { 25202 break 25203 } 25204 if v.AuxInt != 0 { 25205 break 25206 } 25207 l := v.Args[0] 25208 if l.Op != OpARMANDshiftRL { 25209 break 25210 } 25211 c := l.AuxInt 25212 _ = l.Args[1] 25213 x := l.Args[0] 25214 y := l.Args[1] 25215 if !(l.Uses == 1) { 25216 break 25217 } 25218 b.Kind = BlockARMGT 25219 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags) 25220 v0.AuxInt = c 25221 v0.AddArg(x) 25222 v0.AddArg(y) 25223 b.SetControl(v0) 25224 b.Aux = nil 25225 return true 25226 } 25227 // match: (GT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) 25228 // cond: l.Uses==1 25229 // result: (GT (TSTshiftRA x y [c]) yes no) 25230 for { 25231 v := b.Control 25232 if v.Op != OpARMCMPconst { 25233 break 25234 } 25235 if v.AuxInt != 0 { 25236 break 25237 } 25238 l := v.Args[0] 25239 if l.Op != OpARMANDshiftRA { 25240 break 25241 } 25242 c := l.AuxInt 25243 _ = l.Args[1] 25244 x := l.Args[0] 25245 y := l.Args[1] 25246 if !(l.Uses == 1) { 25247 break 25248 } 25249 b.Kind = BlockARMGT 25250 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags) 25251 v0.AuxInt = c 25252 v0.AddArg(x) 25253 v0.AddArg(y) 25254 b.SetControl(v0) 25255 b.Aux = nil 25256 return true 25257 } 25258 // match: (GT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) 25259 // cond: l.Uses==1 25260 // result: (GT (TSTshiftLLreg x y z) yes no) 25261 for { 25262 v := b.Control 25263 if v.Op != OpARMCMPconst { 25264 break 25265 } 25266 if v.AuxInt != 0 { 25267 break 25268 } 25269 l := v.Args[0] 25270 if l.Op != OpARMANDshiftLLreg { 25271 break 25272 } 25273 _ = l.Args[2] 25274 x := l.Args[0] 25275 y := l.Args[1] 25276 z := l.Args[2] 25277 if !(l.Uses == 1) { 25278 break 25279 } 25280 b.Kind = BlockARMGT 25281 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags) 25282 v0.AddArg(x) 25283 v0.AddArg(y) 25284 v0.AddArg(z) 25285 b.SetControl(v0) 25286 b.Aux = nil 25287 return true 25288 } 25289 // match: (GT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) 25290 // cond: l.Uses==1 25291 // result: (GT (TSTshiftRLreg x y z) yes no) 25292 for { 25293 v := b.Control 25294 if v.Op != OpARMCMPconst { 25295 break 25296 } 25297 if v.AuxInt != 0 { 25298 break 25299 } 25300 l := v.Args[0] 25301 if l.Op != OpARMANDshiftRLreg { 25302 break 25303 } 25304 _ = l.Args[2] 25305 x := l.Args[0] 25306 y := l.Args[1] 25307 z := l.Args[2] 25308 if !(l.Uses == 1) { 25309 break 25310 } 25311 b.Kind = BlockARMGT 25312 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags) 25313 v0.AddArg(x) 25314 v0.AddArg(y) 25315 v0.AddArg(z) 25316 b.SetControl(v0) 25317 b.Aux = nil 25318 return true 25319 } 25320 // match: (GT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) 25321 // cond: l.Uses==1 25322 // result: (GT (TSTshiftRAreg x y z) yes no) 25323 for { 25324 v := b.Control 25325 if v.Op != OpARMCMPconst { 25326 break 25327 } 25328 if v.AuxInt != 0 { 25329 break 25330 } 25331 l := v.Args[0] 25332 if l.Op != OpARMANDshiftRAreg { 25333 break 25334 } 25335 _ = l.Args[2] 25336 x := l.Args[0] 25337 y := l.Args[1] 25338 z := l.Args[2] 25339 if !(l.Uses == 1) { 25340 break 25341 } 25342 b.Kind = BlockARMGT 25343 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags) 25344 v0.AddArg(x) 25345 v0.AddArg(y) 25346 v0.AddArg(z) 25347 b.SetControl(v0) 25348 b.Aux = nil 25349 return true 25350 } 25351 // match: (GT (CMPconst [0] l:(XOR x y)) yes no) 25352 // cond: l.Uses==1 25353 // result: (GT (TEQ x y) yes no) 25354 for { 25355 v := b.Control 25356 if v.Op != OpARMCMPconst { 25357 break 25358 } 25359 if v.AuxInt != 0 { 25360 break 25361 } 25362 l := v.Args[0] 25363 if l.Op != OpARMXOR { 25364 break 25365 } 25366 _ = l.Args[1] 25367 x := l.Args[0] 25368 y := l.Args[1] 25369 if !(l.Uses == 1) { 25370 break 25371 } 25372 b.Kind = BlockARMGT 25373 v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags) 25374 v0.AddArg(x) 25375 v0.AddArg(y) 25376 b.SetControl(v0) 25377 b.Aux = nil 25378 return true 25379 } 25380 // match: (GT (CMPconst [0] l:(XORconst [c] x)) yes no) 25381 // cond: l.Uses==1 25382 // result: (GT (TEQconst [c] x) yes no) 25383 for { 25384 v := b.Control 25385 if v.Op != OpARMCMPconst { 25386 break 25387 } 25388 if v.AuxInt != 0 { 25389 break 25390 } 25391 l := v.Args[0] 25392 if l.Op != OpARMXORconst { 25393 break 25394 } 25395 c := l.AuxInt 25396 x := l.Args[0] 25397 if !(l.Uses == 1) { 25398 break 25399 } 25400 b.Kind = BlockARMGT 25401 v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags) 25402 v0.AuxInt = c 25403 v0.AddArg(x) 25404 b.SetControl(v0) 25405 b.Aux = nil 25406 return true 25407 } 25408 // match: (GT (CMPconst [0] l:(XORshiftLL x y [c])) yes no) 25409 // cond: l.Uses==1 25410 // result: (GT (TEQshiftLL x y [c]) yes no) 25411 for { 25412 v := b.Control 25413 if v.Op != OpARMCMPconst { 25414 break 25415 } 25416 if v.AuxInt != 0 { 25417 break 25418 } 25419 l := v.Args[0] 25420 if l.Op != OpARMXORshiftLL { 25421 break 25422 } 25423 c := l.AuxInt 25424 _ = l.Args[1] 25425 x := l.Args[0] 25426 y := l.Args[1] 25427 if !(l.Uses == 1) { 25428 break 25429 } 25430 b.Kind = BlockARMGT 25431 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags) 25432 v0.AuxInt = c 25433 v0.AddArg(x) 25434 v0.AddArg(y) 25435 b.SetControl(v0) 25436 b.Aux = nil 25437 return true 25438 } 25439 // match: (GT (CMPconst [0] l:(XORshiftRL x y [c])) yes no) 25440 // cond: l.Uses==1 25441 // result: (GT (TEQshiftRL x y [c]) yes no) 25442 for { 25443 v := b.Control 25444 if v.Op != OpARMCMPconst { 25445 break 25446 } 25447 if v.AuxInt != 0 { 25448 break 25449 } 25450 l := v.Args[0] 25451 if l.Op != OpARMXORshiftRL { 25452 break 25453 } 25454 c := l.AuxInt 25455 _ = l.Args[1] 25456 x := l.Args[0] 25457 y := l.Args[1] 25458 if !(l.Uses == 1) { 25459 break 25460 } 25461 b.Kind = BlockARMGT 25462 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags) 25463 v0.AuxInt = c 25464 v0.AddArg(x) 25465 v0.AddArg(y) 25466 b.SetControl(v0) 25467 b.Aux = nil 25468 return true 25469 } 25470 // match: (GT (CMPconst [0] l:(XORshiftRA x y [c])) yes no) 25471 // cond: l.Uses==1 25472 // result: (GT (TEQshiftRA x y [c]) yes no) 25473 for { 25474 v := b.Control 25475 if v.Op != OpARMCMPconst { 25476 break 25477 } 25478 if v.AuxInt != 0 { 25479 break 25480 } 25481 l := v.Args[0] 25482 if l.Op != OpARMXORshiftRA { 25483 break 25484 } 25485 c := l.AuxInt 25486 _ = l.Args[1] 25487 x := l.Args[0] 25488 y := l.Args[1] 25489 if !(l.Uses == 1) { 25490 break 25491 } 25492 b.Kind = BlockARMGT 25493 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags) 25494 v0.AuxInt = c 25495 v0.AddArg(x) 25496 v0.AddArg(y) 25497 b.SetControl(v0) 25498 b.Aux = nil 25499 return true 25500 } 25501 // match: (GT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) 25502 // cond: l.Uses==1 25503 // result: (GT (TEQshiftLLreg x y z) yes no) 25504 for { 25505 v := b.Control 25506 if v.Op != OpARMCMPconst { 25507 break 25508 } 25509 if v.AuxInt != 0 { 25510 break 25511 } 25512 l := v.Args[0] 25513 if l.Op != OpARMXORshiftLLreg { 25514 break 25515 } 25516 _ = l.Args[2] 25517 x := l.Args[0] 25518 y := l.Args[1] 25519 z := l.Args[2] 25520 if !(l.Uses == 1) { 25521 break 25522 } 25523 b.Kind = BlockARMGT 25524 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags) 25525 v0.AddArg(x) 25526 v0.AddArg(y) 25527 v0.AddArg(z) 25528 b.SetControl(v0) 25529 b.Aux = nil 25530 return true 25531 } 25532 // match: (GT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) 25533 // cond: l.Uses==1 25534 // result: (GT (TEQshiftRLreg x y z) yes no) 25535 for { 25536 v := b.Control 25537 if v.Op != OpARMCMPconst { 25538 break 25539 } 25540 if v.AuxInt != 0 { 25541 break 25542 } 25543 l := v.Args[0] 25544 if l.Op != OpARMXORshiftRLreg { 25545 break 25546 } 25547 _ = l.Args[2] 25548 x := l.Args[0] 25549 y := l.Args[1] 25550 z := l.Args[2] 25551 if !(l.Uses == 1) { 25552 break 25553 } 25554 b.Kind = BlockARMGT 25555 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags) 25556 v0.AddArg(x) 25557 v0.AddArg(y) 25558 v0.AddArg(z) 25559 b.SetControl(v0) 25560 b.Aux = nil 25561 return true 25562 } 25563 // match: (GT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) 25564 // cond: l.Uses==1 25565 // result: (GT (TEQshiftRAreg x y z) yes no) 25566 for { 25567 v := b.Control 25568 if v.Op != OpARMCMPconst { 25569 break 25570 } 25571 if v.AuxInt != 0 { 25572 break 25573 } 25574 l := v.Args[0] 25575 if l.Op != OpARMXORshiftRAreg { 25576 break 25577 } 25578 _ = l.Args[2] 25579 x := l.Args[0] 25580 y := l.Args[1] 25581 z := l.Args[2] 25582 if !(l.Uses == 1) { 25583 break 25584 } 25585 b.Kind = BlockARMGT 25586 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags) 25587 v0.AddArg(x) 25588 v0.AddArg(y) 25589 v0.AddArg(z) 25590 b.SetControl(v0) 25591 b.Aux = nil 25592 return true 25593 } 25594 case BlockIf: 25595 // match: (If (Equal cc) yes no) 25596 // cond: 25597 // result: (EQ cc yes no) 25598 for { 25599 v := b.Control 25600 if v.Op != OpARMEqual { 25601 break 25602 } 25603 cc := v.Args[0] 25604 b.Kind = BlockARMEQ 25605 b.SetControl(cc) 25606 b.Aux = nil 25607 return true 25608 } 25609 // match: (If (NotEqual cc) yes no) 25610 // cond: 25611 // result: (NE cc yes no) 25612 for { 25613 v := b.Control 25614 if v.Op != OpARMNotEqual { 25615 break 25616 } 25617 cc := v.Args[0] 25618 b.Kind = BlockARMNE 25619 b.SetControl(cc) 25620 b.Aux = nil 25621 return true 25622 } 25623 // match: (If (LessThan cc) yes no) 25624 // cond: 25625 // result: (LT cc yes no) 25626 for { 25627 v := b.Control 25628 if v.Op != OpARMLessThan { 25629 break 25630 } 25631 cc := v.Args[0] 25632 b.Kind = BlockARMLT 25633 b.SetControl(cc) 25634 b.Aux = nil 25635 return true 25636 } 25637 // match: (If (LessThanU cc) yes no) 25638 // cond: 25639 // result: (ULT cc yes no) 25640 for { 25641 v := b.Control 25642 if v.Op != OpARMLessThanU { 25643 break 25644 } 25645 cc := v.Args[0] 25646 b.Kind = BlockARMULT 25647 b.SetControl(cc) 25648 b.Aux = nil 25649 return true 25650 } 25651 // match: (If (LessEqual cc) yes no) 25652 // cond: 25653 // result: (LE cc yes no) 25654 for { 25655 v := b.Control 25656 if v.Op != OpARMLessEqual { 25657 break 25658 } 25659 cc := v.Args[0] 25660 b.Kind = BlockARMLE 25661 b.SetControl(cc) 25662 b.Aux = nil 25663 return true 25664 } 25665 // match: (If (LessEqualU cc) yes no) 25666 // cond: 25667 // result: (ULE cc yes no) 25668 for { 25669 v := b.Control 25670 if v.Op != OpARMLessEqualU { 25671 break 25672 } 25673 cc := v.Args[0] 25674 b.Kind = BlockARMULE 25675 b.SetControl(cc) 25676 b.Aux = nil 25677 return true 25678 } 25679 // match: (If (GreaterThan cc) yes no) 25680 // cond: 25681 // result: (GT cc yes no) 25682 for { 25683 v := b.Control 25684 if v.Op != OpARMGreaterThan { 25685 break 25686 } 25687 cc := v.Args[0] 25688 b.Kind = BlockARMGT 25689 b.SetControl(cc) 25690 b.Aux = nil 25691 return true 25692 } 25693 // match: (If (GreaterThanU cc) yes no) 25694 // cond: 25695 // result: (UGT cc yes no) 25696 for { 25697 v := b.Control 25698 if v.Op != OpARMGreaterThanU { 25699 break 25700 } 25701 cc := v.Args[0] 25702 b.Kind = BlockARMUGT 25703 b.SetControl(cc) 25704 b.Aux = nil 25705 return true 25706 } 25707 // match: (If (GreaterEqual cc) yes no) 25708 // cond: 25709 // result: (GE cc yes no) 25710 for { 25711 v := b.Control 25712 if v.Op != OpARMGreaterEqual { 25713 break 25714 } 25715 cc := v.Args[0] 25716 b.Kind = BlockARMGE 25717 b.SetControl(cc) 25718 b.Aux = nil 25719 return true 25720 } 25721 // match: (If (GreaterEqualU cc) yes no) 25722 // cond: 25723 // result: (UGE cc yes no) 25724 for { 25725 v := b.Control 25726 if v.Op != OpARMGreaterEqualU { 25727 break 25728 } 25729 cc := v.Args[0] 25730 b.Kind = BlockARMUGE 25731 b.SetControl(cc) 25732 b.Aux = nil 25733 return true 25734 } 25735 // match: (If cond yes no) 25736 // cond: 25737 // result: (NE (CMPconst [0] cond) yes no) 25738 for { 25739 v := b.Control 25740 _ = v 25741 cond := b.Control 25742 b.Kind = BlockARMNE 25743 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 25744 v0.AuxInt = 0 25745 v0.AddArg(cond) 25746 b.SetControl(v0) 25747 b.Aux = nil 25748 return true 25749 } 25750 case BlockARMLE: 25751 // match: (LE (FlagEQ) yes no) 25752 // cond: 25753 // result: (First nil yes no) 25754 for { 25755 v := b.Control 25756 if v.Op != OpARMFlagEQ { 25757 break 25758 } 25759 b.Kind = BlockFirst 25760 b.SetControl(nil) 25761 b.Aux = nil 25762 return true 25763 } 25764 // match: (LE (FlagLT_ULT) yes no) 25765 // cond: 25766 // result: (First nil yes no) 25767 for { 25768 v := b.Control 25769 if v.Op != OpARMFlagLT_ULT { 25770 break 25771 } 25772 b.Kind = BlockFirst 25773 b.SetControl(nil) 25774 b.Aux = nil 25775 return true 25776 } 25777 // match: (LE (FlagLT_UGT) yes no) 25778 // cond: 25779 // result: (First nil yes no) 25780 for { 25781 v := b.Control 25782 if v.Op != OpARMFlagLT_UGT { 25783 break 25784 } 25785 b.Kind = BlockFirst 25786 b.SetControl(nil) 25787 b.Aux = nil 25788 return true 25789 } 25790 // match: (LE (FlagGT_ULT) yes no) 25791 // cond: 25792 // result: (First nil no yes) 25793 for { 25794 v := b.Control 25795 if v.Op != OpARMFlagGT_ULT { 25796 break 25797 } 25798 b.Kind = BlockFirst 25799 b.SetControl(nil) 25800 b.Aux = nil 25801 b.swapSuccessors() 25802 return true 25803 } 25804 // match: (LE (FlagGT_UGT) yes no) 25805 // cond: 25806 // result: (First nil no yes) 25807 for { 25808 v := b.Control 25809 if v.Op != OpARMFlagGT_UGT { 25810 break 25811 } 25812 b.Kind = BlockFirst 25813 b.SetControl(nil) 25814 b.Aux = nil 25815 b.swapSuccessors() 25816 return true 25817 } 25818 // match: (LE (InvertFlags cmp) yes no) 25819 // cond: 25820 // result: (GE cmp yes no) 25821 for { 25822 v := b.Control 25823 if v.Op != OpARMInvertFlags { 25824 break 25825 } 25826 cmp := v.Args[0] 25827 b.Kind = BlockARMGE 25828 b.SetControl(cmp) 25829 b.Aux = nil 25830 return true 25831 } 25832 // match: (LE (CMPconst [0] l:(SUB x y)) yes no) 25833 // cond: l.Uses==1 25834 // result: (LE (CMP x y) yes no) 25835 for { 25836 v := b.Control 25837 if v.Op != OpARMCMPconst { 25838 break 25839 } 25840 if v.AuxInt != 0 { 25841 break 25842 } 25843 l := v.Args[0] 25844 if l.Op != OpARMSUB { 25845 break 25846 } 25847 _ = l.Args[1] 25848 x := l.Args[0] 25849 y := l.Args[1] 25850 if !(l.Uses == 1) { 25851 break 25852 } 25853 b.Kind = BlockARMLE 25854 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 25855 v0.AddArg(x) 25856 v0.AddArg(y) 25857 b.SetControl(v0) 25858 b.Aux = nil 25859 return true 25860 } 25861 // match: (LE (CMPconst [0] l:(MULS x y a)) yes no) 25862 // cond: l.Uses==1 25863 // result: (LE (CMP a (MUL <x.Type> x y)) yes no) 25864 for { 25865 v := b.Control 25866 if v.Op != OpARMCMPconst { 25867 break 25868 } 25869 if v.AuxInt != 0 { 25870 break 25871 } 25872 l := v.Args[0] 25873 if l.Op != OpARMMULS { 25874 break 25875 } 25876 _ = l.Args[2] 25877 x := l.Args[0] 25878 y := l.Args[1] 25879 a := l.Args[2] 25880 if !(l.Uses == 1) { 25881 break 25882 } 25883 b.Kind = BlockARMLE 25884 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 25885 v0.AddArg(a) 25886 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type) 25887 v1.AddArg(x) 25888 v1.AddArg(y) 25889 v0.AddArg(v1) 25890 b.SetControl(v0) 25891 b.Aux = nil 25892 return true 25893 } 25894 // match: (LE (CMPconst [0] l:(SUBconst [c] x)) yes no) 25895 // cond: l.Uses==1 25896 // result: (LE (CMPconst [c] x) yes no) 25897 for { 25898 v := b.Control 25899 if v.Op != OpARMCMPconst { 25900 break 25901 } 25902 if v.AuxInt != 0 { 25903 break 25904 } 25905 l := v.Args[0] 25906 if l.Op != OpARMSUBconst { 25907 break 25908 } 25909 c := l.AuxInt 25910 x := l.Args[0] 25911 if !(l.Uses == 1) { 25912 break 25913 } 25914 b.Kind = BlockARMLE 25915 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 25916 v0.AuxInt = c 25917 v0.AddArg(x) 25918 b.SetControl(v0) 25919 b.Aux = nil 25920 return true 25921 } 25922 // match: (LE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no) 25923 // cond: l.Uses==1 25924 // result: (LE (CMPshiftLL x y [c]) yes no) 25925 for { 25926 v := b.Control 25927 if v.Op != OpARMCMPconst { 25928 break 25929 } 25930 if v.AuxInt != 0 { 25931 break 25932 } 25933 l := v.Args[0] 25934 if l.Op != OpARMSUBshiftLL { 25935 break 25936 } 25937 c := l.AuxInt 25938 _ = l.Args[1] 25939 x := l.Args[0] 25940 y := l.Args[1] 25941 if !(l.Uses == 1) { 25942 break 25943 } 25944 b.Kind = BlockARMLE 25945 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags) 25946 v0.AuxInt = c 25947 v0.AddArg(x) 25948 v0.AddArg(y) 25949 b.SetControl(v0) 25950 b.Aux = nil 25951 return true 25952 } 25953 // match: (LE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no) 25954 // cond: l.Uses==1 25955 // result: (LE (CMPshiftRL x y [c]) yes no) 25956 for { 25957 v := b.Control 25958 if v.Op != OpARMCMPconst { 25959 break 25960 } 25961 if v.AuxInt != 0 { 25962 break 25963 } 25964 l := v.Args[0] 25965 if l.Op != OpARMSUBshiftRL { 25966 break 25967 } 25968 c := l.AuxInt 25969 _ = l.Args[1] 25970 x := l.Args[0] 25971 y := l.Args[1] 25972 if !(l.Uses == 1) { 25973 break 25974 } 25975 b.Kind = BlockARMLE 25976 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags) 25977 v0.AuxInt = c 25978 v0.AddArg(x) 25979 v0.AddArg(y) 25980 b.SetControl(v0) 25981 b.Aux = nil 25982 return true 25983 } 25984 // match: (LE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no) 25985 // cond: l.Uses==1 25986 // result: (LE (CMPshiftRA x y [c]) yes no) 25987 for { 25988 v := b.Control 25989 if v.Op != OpARMCMPconst { 25990 break 25991 } 25992 if v.AuxInt != 0 { 25993 break 25994 } 25995 l := v.Args[0] 25996 if l.Op != OpARMSUBshiftRA { 25997 break 25998 } 25999 c := l.AuxInt 26000 _ = l.Args[1] 26001 x := l.Args[0] 26002 y := l.Args[1] 26003 if !(l.Uses == 1) { 26004 break 26005 } 26006 b.Kind = BlockARMLE 26007 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags) 26008 v0.AuxInt = c 26009 v0.AddArg(x) 26010 v0.AddArg(y) 26011 b.SetControl(v0) 26012 b.Aux = nil 26013 return true 26014 } 26015 // match: (LE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no) 26016 // cond: l.Uses==1 26017 // result: (LE (CMPshiftLLreg x y z) yes no) 26018 for { 26019 v := b.Control 26020 if v.Op != OpARMCMPconst { 26021 break 26022 } 26023 if v.AuxInt != 0 { 26024 break 26025 } 26026 l := v.Args[0] 26027 if l.Op != OpARMSUBshiftLLreg { 26028 break 26029 } 26030 _ = l.Args[2] 26031 x := l.Args[0] 26032 y := l.Args[1] 26033 z := l.Args[2] 26034 if !(l.Uses == 1) { 26035 break 26036 } 26037 b.Kind = BlockARMLE 26038 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags) 26039 v0.AddArg(x) 26040 v0.AddArg(y) 26041 v0.AddArg(z) 26042 b.SetControl(v0) 26043 b.Aux = nil 26044 return true 26045 } 26046 // match: (LE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no) 26047 // cond: l.Uses==1 26048 // result: (LE (CMPshiftRLreg x y z) yes no) 26049 for { 26050 v := b.Control 26051 if v.Op != OpARMCMPconst { 26052 break 26053 } 26054 if v.AuxInt != 0 { 26055 break 26056 } 26057 l := v.Args[0] 26058 if l.Op != OpARMSUBshiftRLreg { 26059 break 26060 } 26061 _ = l.Args[2] 26062 x := l.Args[0] 26063 y := l.Args[1] 26064 z := l.Args[2] 26065 if !(l.Uses == 1) { 26066 break 26067 } 26068 b.Kind = BlockARMLE 26069 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags) 26070 v0.AddArg(x) 26071 v0.AddArg(y) 26072 v0.AddArg(z) 26073 b.SetControl(v0) 26074 b.Aux = nil 26075 return true 26076 } 26077 // match: (LE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no) 26078 // cond: l.Uses==1 26079 // result: (LE (CMPshiftRAreg x y z) yes no) 26080 for { 26081 v := b.Control 26082 if v.Op != OpARMCMPconst { 26083 break 26084 } 26085 if v.AuxInt != 0 { 26086 break 26087 } 26088 l := v.Args[0] 26089 if l.Op != OpARMSUBshiftRAreg { 26090 break 26091 } 26092 _ = l.Args[2] 26093 x := l.Args[0] 26094 y := l.Args[1] 26095 z := l.Args[2] 26096 if !(l.Uses == 1) { 26097 break 26098 } 26099 b.Kind = BlockARMLE 26100 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags) 26101 v0.AddArg(x) 26102 v0.AddArg(y) 26103 v0.AddArg(z) 26104 b.SetControl(v0) 26105 b.Aux = nil 26106 return true 26107 } 26108 // match: (LE (CMPconst [0] l:(ADD x y)) yes no) 26109 // cond: l.Uses==1 26110 // result: (LE (CMN x y) yes no) 26111 for { 26112 v := b.Control 26113 if v.Op != OpARMCMPconst { 26114 break 26115 } 26116 if v.AuxInt != 0 { 26117 break 26118 } 26119 l := v.Args[0] 26120 if l.Op != OpARMADD { 26121 break 26122 } 26123 _ = l.Args[1] 26124 x := l.Args[0] 26125 y := l.Args[1] 26126 if !(l.Uses == 1) { 26127 break 26128 } 26129 b.Kind = BlockARMLE 26130 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags) 26131 v0.AddArg(x) 26132 v0.AddArg(y) 26133 b.SetControl(v0) 26134 b.Aux = nil 26135 return true 26136 } 26137 // match: (LE (CMPconst [0] l:(MULA x y a)) yes no) 26138 // cond: l.Uses==1 26139 // result: (LE (CMN a (MUL <x.Type> x y)) yes no) 26140 for { 26141 v := b.Control 26142 if v.Op != OpARMCMPconst { 26143 break 26144 } 26145 if v.AuxInt != 0 { 26146 break 26147 } 26148 l := v.Args[0] 26149 if l.Op != OpARMMULA { 26150 break 26151 } 26152 _ = l.Args[2] 26153 x := l.Args[0] 26154 y := l.Args[1] 26155 a := l.Args[2] 26156 if !(l.Uses == 1) { 26157 break 26158 } 26159 b.Kind = BlockARMLE 26160 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags) 26161 v0.AddArg(a) 26162 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type) 26163 v1.AddArg(x) 26164 v1.AddArg(y) 26165 v0.AddArg(v1) 26166 b.SetControl(v0) 26167 b.Aux = nil 26168 return true 26169 } 26170 // match: (LE (CMPconst [0] l:(ADDconst [c] x)) yes no) 26171 // cond: l.Uses==1 26172 // result: (LE (CMNconst [c] x) yes no) 26173 for { 26174 v := b.Control 26175 if v.Op != OpARMCMPconst { 26176 break 26177 } 26178 if v.AuxInt != 0 { 26179 break 26180 } 26181 l := v.Args[0] 26182 if l.Op != OpARMADDconst { 26183 break 26184 } 26185 c := l.AuxInt 26186 x := l.Args[0] 26187 if !(l.Uses == 1) { 26188 break 26189 } 26190 b.Kind = BlockARMLE 26191 v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags) 26192 v0.AuxInt = c 26193 v0.AddArg(x) 26194 b.SetControl(v0) 26195 b.Aux = nil 26196 return true 26197 } 26198 // match: (LE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no) 26199 // cond: l.Uses==1 26200 // result: (LE (CMNshiftLL x y [c]) yes no) 26201 for { 26202 v := b.Control 26203 if v.Op != OpARMCMPconst { 26204 break 26205 } 26206 if v.AuxInt != 0 { 26207 break 26208 } 26209 l := v.Args[0] 26210 if l.Op != OpARMADDshiftLL { 26211 break 26212 } 26213 c := l.AuxInt 26214 _ = l.Args[1] 26215 x := l.Args[0] 26216 y := l.Args[1] 26217 if !(l.Uses == 1) { 26218 break 26219 } 26220 b.Kind = BlockARMLE 26221 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags) 26222 v0.AuxInt = c 26223 v0.AddArg(x) 26224 v0.AddArg(y) 26225 b.SetControl(v0) 26226 b.Aux = nil 26227 return true 26228 } 26229 // match: (LE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no) 26230 // cond: l.Uses==1 26231 // result: (LE (CMNshiftRL x y [c]) yes no) 26232 for { 26233 v := b.Control 26234 if v.Op != OpARMCMPconst { 26235 break 26236 } 26237 if v.AuxInt != 0 { 26238 break 26239 } 26240 l := v.Args[0] 26241 if l.Op != OpARMADDshiftRL { 26242 break 26243 } 26244 c := l.AuxInt 26245 _ = l.Args[1] 26246 x := l.Args[0] 26247 y := l.Args[1] 26248 if !(l.Uses == 1) { 26249 break 26250 } 26251 b.Kind = BlockARMLE 26252 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags) 26253 v0.AuxInt = c 26254 v0.AddArg(x) 26255 v0.AddArg(y) 26256 b.SetControl(v0) 26257 b.Aux = nil 26258 return true 26259 } 26260 // match: (LE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no) 26261 // cond: l.Uses==1 26262 // result: (LE (CMNshiftRA x y [c]) yes no) 26263 for { 26264 v := b.Control 26265 if v.Op != OpARMCMPconst { 26266 break 26267 } 26268 if v.AuxInt != 0 { 26269 break 26270 } 26271 l := v.Args[0] 26272 if l.Op != OpARMADDshiftRA { 26273 break 26274 } 26275 c := l.AuxInt 26276 _ = l.Args[1] 26277 x := l.Args[0] 26278 y := l.Args[1] 26279 if !(l.Uses == 1) { 26280 break 26281 } 26282 b.Kind = BlockARMLE 26283 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags) 26284 v0.AuxInt = c 26285 v0.AddArg(x) 26286 v0.AddArg(y) 26287 b.SetControl(v0) 26288 b.Aux = nil 26289 return true 26290 } 26291 // match: (LE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) 26292 // cond: l.Uses==1 26293 // result: (LE (CMNshiftLLreg x y z) yes no) 26294 for { 26295 v := b.Control 26296 if v.Op != OpARMCMPconst { 26297 break 26298 } 26299 if v.AuxInt != 0 { 26300 break 26301 } 26302 l := v.Args[0] 26303 if l.Op != OpARMADDshiftLLreg { 26304 break 26305 } 26306 _ = l.Args[2] 26307 x := l.Args[0] 26308 y := l.Args[1] 26309 z := l.Args[2] 26310 if !(l.Uses == 1) { 26311 break 26312 } 26313 b.Kind = BlockARMLE 26314 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags) 26315 v0.AddArg(x) 26316 v0.AddArg(y) 26317 v0.AddArg(z) 26318 b.SetControl(v0) 26319 b.Aux = nil 26320 return true 26321 } 26322 // match: (LE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) 26323 // cond: l.Uses==1 26324 // result: (LE (CMNshiftRLreg x y z) yes no) 26325 for { 26326 v := b.Control 26327 if v.Op != OpARMCMPconst { 26328 break 26329 } 26330 if v.AuxInt != 0 { 26331 break 26332 } 26333 l := v.Args[0] 26334 if l.Op != OpARMADDshiftRLreg { 26335 break 26336 } 26337 _ = l.Args[2] 26338 x := l.Args[0] 26339 y := l.Args[1] 26340 z := l.Args[2] 26341 if !(l.Uses == 1) { 26342 break 26343 } 26344 b.Kind = BlockARMLE 26345 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags) 26346 v0.AddArg(x) 26347 v0.AddArg(y) 26348 v0.AddArg(z) 26349 b.SetControl(v0) 26350 b.Aux = nil 26351 return true 26352 } 26353 // match: (LE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) 26354 // cond: l.Uses==1 26355 // result: (LE (CMNshiftRAreg x y z) yes no) 26356 for { 26357 v := b.Control 26358 if v.Op != OpARMCMPconst { 26359 break 26360 } 26361 if v.AuxInt != 0 { 26362 break 26363 } 26364 l := v.Args[0] 26365 if l.Op != OpARMADDshiftRAreg { 26366 break 26367 } 26368 _ = l.Args[2] 26369 x := l.Args[0] 26370 y := l.Args[1] 26371 z := l.Args[2] 26372 if !(l.Uses == 1) { 26373 break 26374 } 26375 b.Kind = BlockARMLE 26376 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags) 26377 v0.AddArg(x) 26378 v0.AddArg(y) 26379 v0.AddArg(z) 26380 b.SetControl(v0) 26381 b.Aux = nil 26382 return true 26383 } 26384 // match: (LE (CMPconst [0] l:(AND x y)) yes no) 26385 // cond: l.Uses==1 26386 // result: (LE (TST x y) yes no) 26387 for { 26388 v := b.Control 26389 if v.Op != OpARMCMPconst { 26390 break 26391 } 26392 if v.AuxInt != 0 { 26393 break 26394 } 26395 l := v.Args[0] 26396 if l.Op != OpARMAND { 26397 break 26398 } 26399 _ = l.Args[1] 26400 x := l.Args[0] 26401 y := l.Args[1] 26402 if !(l.Uses == 1) { 26403 break 26404 } 26405 b.Kind = BlockARMLE 26406 v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags) 26407 v0.AddArg(x) 26408 v0.AddArg(y) 26409 b.SetControl(v0) 26410 b.Aux = nil 26411 return true 26412 } 26413 // match: (LE (CMPconst [0] l:(ANDconst [c] x)) yes no) 26414 // cond: l.Uses==1 26415 // result: (LE (TSTconst [c] x) yes no) 26416 for { 26417 v := b.Control 26418 if v.Op != OpARMCMPconst { 26419 break 26420 } 26421 if v.AuxInt != 0 { 26422 break 26423 } 26424 l := v.Args[0] 26425 if l.Op != OpARMANDconst { 26426 break 26427 } 26428 c := l.AuxInt 26429 x := l.Args[0] 26430 if !(l.Uses == 1) { 26431 break 26432 } 26433 b.Kind = BlockARMLE 26434 v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags) 26435 v0.AuxInt = c 26436 v0.AddArg(x) 26437 b.SetControl(v0) 26438 b.Aux = nil 26439 return true 26440 } 26441 // match: (LE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) 26442 // cond: l.Uses==1 26443 // result: (LE (TSTshiftLL x y [c]) yes no) 26444 for { 26445 v := b.Control 26446 if v.Op != OpARMCMPconst { 26447 break 26448 } 26449 if v.AuxInt != 0 { 26450 break 26451 } 26452 l := v.Args[0] 26453 if l.Op != OpARMANDshiftLL { 26454 break 26455 } 26456 c := l.AuxInt 26457 _ = l.Args[1] 26458 x := l.Args[0] 26459 y := l.Args[1] 26460 if !(l.Uses == 1) { 26461 break 26462 } 26463 b.Kind = BlockARMLE 26464 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags) 26465 v0.AuxInt = c 26466 v0.AddArg(x) 26467 v0.AddArg(y) 26468 b.SetControl(v0) 26469 b.Aux = nil 26470 return true 26471 } 26472 // match: (LE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) 26473 // cond: l.Uses==1 26474 // result: (LE (TSTshiftRL x y [c]) yes no) 26475 for { 26476 v := b.Control 26477 if v.Op != OpARMCMPconst { 26478 break 26479 } 26480 if v.AuxInt != 0 { 26481 break 26482 } 26483 l := v.Args[0] 26484 if l.Op != OpARMANDshiftRL { 26485 break 26486 } 26487 c := l.AuxInt 26488 _ = l.Args[1] 26489 x := l.Args[0] 26490 y := l.Args[1] 26491 if !(l.Uses == 1) { 26492 break 26493 } 26494 b.Kind = BlockARMLE 26495 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags) 26496 v0.AuxInt = c 26497 v0.AddArg(x) 26498 v0.AddArg(y) 26499 b.SetControl(v0) 26500 b.Aux = nil 26501 return true 26502 } 26503 // match: (LE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) 26504 // cond: l.Uses==1 26505 // result: (LE (TSTshiftRA x y [c]) yes no) 26506 for { 26507 v := b.Control 26508 if v.Op != OpARMCMPconst { 26509 break 26510 } 26511 if v.AuxInt != 0 { 26512 break 26513 } 26514 l := v.Args[0] 26515 if l.Op != OpARMANDshiftRA { 26516 break 26517 } 26518 c := l.AuxInt 26519 _ = l.Args[1] 26520 x := l.Args[0] 26521 y := l.Args[1] 26522 if !(l.Uses == 1) { 26523 break 26524 } 26525 b.Kind = BlockARMLE 26526 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags) 26527 v0.AuxInt = c 26528 v0.AddArg(x) 26529 v0.AddArg(y) 26530 b.SetControl(v0) 26531 b.Aux = nil 26532 return true 26533 } 26534 // match: (LE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) 26535 // cond: l.Uses==1 26536 // result: (LE (TSTshiftLLreg x y z) yes no) 26537 for { 26538 v := b.Control 26539 if v.Op != OpARMCMPconst { 26540 break 26541 } 26542 if v.AuxInt != 0 { 26543 break 26544 } 26545 l := v.Args[0] 26546 if l.Op != OpARMANDshiftLLreg { 26547 break 26548 } 26549 _ = l.Args[2] 26550 x := l.Args[0] 26551 y := l.Args[1] 26552 z := l.Args[2] 26553 if !(l.Uses == 1) { 26554 break 26555 } 26556 b.Kind = BlockARMLE 26557 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags) 26558 v0.AddArg(x) 26559 v0.AddArg(y) 26560 v0.AddArg(z) 26561 b.SetControl(v0) 26562 b.Aux = nil 26563 return true 26564 } 26565 // match: (LE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) 26566 // cond: l.Uses==1 26567 // result: (LE (TSTshiftRLreg x y z) yes no) 26568 for { 26569 v := b.Control 26570 if v.Op != OpARMCMPconst { 26571 break 26572 } 26573 if v.AuxInt != 0 { 26574 break 26575 } 26576 l := v.Args[0] 26577 if l.Op != OpARMANDshiftRLreg { 26578 break 26579 } 26580 _ = l.Args[2] 26581 x := l.Args[0] 26582 y := l.Args[1] 26583 z := l.Args[2] 26584 if !(l.Uses == 1) { 26585 break 26586 } 26587 b.Kind = BlockARMLE 26588 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags) 26589 v0.AddArg(x) 26590 v0.AddArg(y) 26591 v0.AddArg(z) 26592 b.SetControl(v0) 26593 b.Aux = nil 26594 return true 26595 } 26596 // match: (LE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) 26597 // cond: l.Uses==1 26598 // result: (LE (TSTshiftRAreg x y z) yes no) 26599 for { 26600 v := b.Control 26601 if v.Op != OpARMCMPconst { 26602 break 26603 } 26604 if v.AuxInt != 0 { 26605 break 26606 } 26607 l := v.Args[0] 26608 if l.Op != OpARMANDshiftRAreg { 26609 break 26610 } 26611 _ = l.Args[2] 26612 x := l.Args[0] 26613 y := l.Args[1] 26614 z := l.Args[2] 26615 if !(l.Uses == 1) { 26616 break 26617 } 26618 b.Kind = BlockARMLE 26619 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags) 26620 v0.AddArg(x) 26621 v0.AddArg(y) 26622 v0.AddArg(z) 26623 b.SetControl(v0) 26624 b.Aux = nil 26625 return true 26626 } 26627 // match: (LE (CMPconst [0] l:(XOR x y)) yes no) 26628 // cond: l.Uses==1 26629 // result: (LE (TEQ x y) yes no) 26630 for { 26631 v := b.Control 26632 if v.Op != OpARMCMPconst { 26633 break 26634 } 26635 if v.AuxInt != 0 { 26636 break 26637 } 26638 l := v.Args[0] 26639 if l.Op != OpARMXOR { 26640 break 26641 } 26642 _ = l.Args[1] 26643 x := l.Args[0] 26644 y := l.Args[1] 26645 if !(l.Uses == 1) { 26646 break 26647 } 26648 b.Kind = BlockARMLE 26649 v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags) 26650 v0.AddArg(x) 26651 v0.AddArg(y) 26652 b.SetControl(v0) 26653 b.Aux = nil 26654 return true 26655 } 26656 // match: (LE (CMPconst [0] l:(XORconst [c] x)) yes no) 26657 // cond: l.Uses==1 26658 // result: (LE (TEQconst [c] x) yes no) 26659 for { 26660 v := b.Control 26661 if v.Op != OpARMCMPconst { 26662 break 26663 } 26664 if v.AuxInt != 0 { 26665 break 26666 } 26667 l := v.Args[0] 26668 if l.Op != OpARMXORconst { 26669 break 26670 } 26671 c := l.AuxInt 26672 x := l.Args[0] 26673 if !(l.Uses == 1) { 26674 break 26675 } 26676 b.Kind = BlockARMLE 26677 v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags) 26678 v0.AuxInt = c 26679 v0.AddArg(x) 26680 b.SetControl(v0) 26681 b.Aux = nil 26682 return true 26683 } 26684 // match: (LE (CMPconst [0] l:(XORshiftLL x y [c])) yes no) 26685 // cond: l.Uses==1 26686 // result: (LE (TEQshiftLL x y [c]) yes no) 26687 for { 26688 v := b.Control 26689 if v.Op != OpARMCMPconst { 26690 break 26691 } 26692 if v.AuxInt != 0 { 26693 break 26694 } 26695 l := v.Args[0] 26696 if l.Op != OpARMXORshiftLL { 26697 break 26698 } 26699 c := l.AuxInt 26700 _ = l.Args[1] 26701 x := l.Args[0] 26702 y := l.Args[1] 26703 if !(l.Uses == 1) { 26704 break 26705 } 26706 b.Kind = BlockARMLE 26707 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags) 26708 v0.AuxInt = c 26709 v0.AddArg(x) 26710 v0.AddArg(y) 26711 b.SetControl(v0) 26712 b.Aux = nil 26713 return true 26714 } 26715 // match: (LE (CMPconst [0] l:(XORshiftRL x y [c])) yes no) 26716 // cond: l.Uses==1 26717 // result: (LE (TEQshiftRL x y [c]) yes no) 26718 for { 26719 v := b.Control 26720 if v.Op != OpARMCMPconst { 26721 break 26722 } 26723 if v.AuxInt != 0 { 26724 break 26725 } 26726 l := v.Args[0] 26727 if l.Op != OpARMXORshiftRL { 26728 break 26729 } 26730 c := l.AuxInt 26731 _ = l.Args[1] 26732 x := l.Args[0] 26733 y := l.Args[1] 26734 if !(l.Uses == 1) { 26735 break 26736 } 26737 b.Kind = BlockARMLE 26738 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags) 26739 v0.AuxInt = c 26740 v0.AddArg(x) 26741 v0.AddArg(y) 26742 b.SetControl(v0) 26743 b.Aux = nil 26744 return true 26745 } 26746 // match: (LE (CMPconst [0] l:(XORshiftRA x y [c])) yes no) 26747 // cond: l.Uses==1 26748 // result: (LE (TEQshiftRA x y [c]) yes no) 26749 for { 26750 v := b.Control 26751 if v.Op != OpARMCMPconst { 26752 break 26753 } 26754 if v.AuxInt != 0 { 26755 break 26756 } 26757 l := v.Args[0] 26758 if l.Op != OpARMXORshiftRA { 26759 break 26760 } 26761 c := l.AuxInt 26762 _ = l.Args[1] 26763 x := l.Args[0] 26764 y := l.Args[1] 26765 if !(l.Uses == 1) { 26766 break 26767 } 26768 b.Kind = BlockARMLE 26769 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags) 26770 v0.AuxInt = c 26771 v0.AddArg(x) 26772 v0.AddArg(y) 26773 b.SetControl(v0) 26774 b.Aux = nil 26775 return true 26776 } 26777 // match: (LE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) 26778 // cond: l.Uses==1 26779 // result: (LE (TEQshiftLLreg x y z) yes no) 26780 for { 26781 v := b.Control 26782 if v.Op != OpARMCMPconst { 26783 break 26784 } 26785 if v.AuxInt != 0 { 26786 break 26787 } 26788 l := v.Args[0] 26789 if l.Op != OpARMXORshiftLLreg { 26790 break 26791 } 26792 _ = l.Args[2] 26793 x := l.Args[0] 26794 y := l.Args[1] 26795 z := l.Args[2] 26796 if !(l.Uses == 1) { 26797 break 26798 } 26799 b.Kind = BlockARMLE 26800 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags) 26801 v0.AddArg(x) 26802 v0.AddArg(y) 26803 v0.AddArg(z) 26804 b.SetControl(v0) 26805 b.Aux = nil 26806 return true 26807 } 26808 // match: (LE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) 26809 // cond: l.Uses==1 26810 // result: (LE (TEQshiftRLreg x y z) yes no) 26811 for { 26812 v := b.Control 26813 if v.Op != OpARMCMPconst { 26814 break 26815 } 26816 if v.AuxInt != 0 { 26817 break 26818 } 26819 l := v.Args[0] 26820 if l.Op != OpARMXORshiftRLreg { 26821 break 26822 } 26823 _ = l.Args[2] 26824 x := l.Args[0] 26825 y := l.Args[1] 26826 z := l.Args[2] 26827 if !(l.Uses == 1) { 26828 break 26829 } 26830 b.Kind = BlockARMLE 26831 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags) 26832 v0.AddArg(x) 26833 v0.AddArg(y) 26834 v0.AddArg(z) 26835 b.SetControl(v0) 26836 b.Aux = nil 26837 return true 26838 } 26839 // match: (LE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) 26840 // cond: l.Uses==1 26841 // result: (LE (TEQshiftRAreg x y z) yes no) 26842 for { 26843 v := b.Control 26844 if v.Op != OpARMCMPconst { 26845 break 26846 } 26847 if v.AuxInt != 0 { 26848 break 26849 } 26850 l := v.Args[0] 26851 if l.Op != OpARMXORshiftRAreg { 26852 break 26853 } 26854 _ = l.Args[2] 26855 x := l.Args[0] 26856 y := l.Args[1] 26857 z := l.Args[2] 26858 if !(l.Uses == 1) { 26859 break 26860 } 26861 b.Kind = BlockARMLE 26862 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags) 26863 v0.AddArg(x) 26864 v0.AddArg(y) 26865 v0.AddArg(z) 26866 b.SetControl(v0) 26867 b.Aux = nil 26868 return true 26869 } 26870 case BlockARMLT: 26871 // match: (LT (FlagEQ) yes no) 26872 // cond: 26873 // result: (First nil no yes) 26874 for { 26875 v := b.Control 26876 if v.Op != OpARMFlagEQ { 26877 break 26878 } 26879 b.Kind = BlockFirst 26880 b.SetControl(nil) 26881 b.Aux = nil 26882 b.swapSuccessors() 26883 return true 26884 } 26885 // match: (LT (FlagLT_ULT) yes no) 26886 // cond: 26887 // result: (First nil yes no) 26888 for { 26889 v := b.Control 26890 if v.Op != OpARMFlagLT_ULT { 26891 break 26892 } 26893 b.Kind = BlockFirst 26894 b.SetControl(nil) 26895 b.Aux = nil 26896 return true 26897 } 26898 // match: (LT (FlagLT_UGT) yes no) 26899 // cond: 26900 // result: (First nil yes no) 26901 for { 26902 v := b.Control 26903 if v.Op != OpARMFlagLT_UGT { 26904 break 26905 } 26906 b.Kind = BlockFirst 26907 b.SetControl(nil) 26908 b.Aux = nil 26909 return true 26910 } 26911 // match: (LT (FlagGT_ULT) yes no) 26912 // cond: 26913 // result: (First nil no yes) 26914 for { 26915 v := b.Control 26916 if v.Op != OpARMFlagGT_ULT { 26917 break 26918 } 26919 b.Kind = BlockFirst 26920 b.SetControl(nil) 26921 b.Aux = nil 26922 b.swapSuccessors() 26923 return true 26924 } 26925 // match: (LT (FlagGT_UGT) yes no) 26926 // cond: 26927 // result: (First nil no yes) 26928 for { 26929 v := b.Control 26930 if v.Op != OpARMFlagGT_UGT { 26931 break 26932 } 26933 b.Kind = BlockFirst 26934 b.SetControl(nil) 26935 b.Aux = nil 26936 b.swapSuccessors() 26937 return true 26938 } 26939 // match: (LT (InvertFlags cmp) yes no) 26940 // cond: 26941 // result: (GT cmp yes no) 26942 for { 26943 v := b.Control 26944 if v.Op != OpARMInvertFlags { 26945 break 26946 } 26947 cmp := v.Args[0] 26948 b.Kind = BlockARMGT 26949 b.SetControl(cmp) 26950 b.Aux = nil 26951 return true 26952 } 26953 // match: (LT (CMPconst [0] l:(SUB x y)) yes no) 26954 // cond: l.Uses==1 26955 // result: (LT (CMP x y) yes no) 26956 for { 26957 v := b.Control 26958 if v.Op != OpARMCMPconst { 26959 break 26960 } 26961 if v.AuxInt != 0 { 26962 break 26963 } 26964 l := v.Args[0] 26965 if l.Op != OpARMSUB { 26966 break 26967 } 26968 _ = l.Args[1] 26969 x := l.Args[0] 26970 y := l.Args[1] 26971 if !(l.Uses == 1) { 26972 break 26973 } 26974 b.Kind = BlockARMLT 26975 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 26976 v0.AddArg(x) 26977 v0.AddArg(y) 26978 b.SetControl(v0) 26979 b.Aux = nil 26980 return true 26981 } 26982 // match: (LT (CMPconst [0] l:(MULS x y a)) yes no) 26983 // cond: l.Uses==1 26984 // result: (LT (CMP a (MUL <x.Type> x y)) yes no) 26985 for { 26986 v := b.Control 26987 if v.Op != OpARMCMPconst { 26988 break 26989 } 26990 if v.AuxInt != 0 { 26991 break 26992 } 26993 l := v.Args[0] 26994 if l.Op != OpARMMULS { 26995 break 26996 } 26997 _ = l.Args[2] 26998 x := l.Args[0] 26999 y := l.Args[1] 27000 a := l.Args[2] 27001 if !(l.Uses == 1) { 27002 break 27003 } 27004 b.Kind = BlockARMLT 27005 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 27006 v0.AddArg(a) 27007 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type) 27008 v1.AddArg(x) 27009 v1.AddArg(y) 27010 v0.AddArg(v1) 27011 b.SetControl(v0) 27012 b.Aux = nil 27013 return true 27014 } 27015 // match: (LT (CMPconst [0] l:(SUBconst [c] x)) yes no) 27016 // cond: l.Uses==1 27017 // result: (LT (CMPconst [c] x) yes no) 27018 for { 27019 v := b.Control 27020 if v.Op != OpARMCMPconst { 27021 break 27022 } 27023 if v.AuxInt != 0 { 27024 break 27025 } 27026 l := v.Args[0] 27027 if l.Op != OpARMSUBconst { 27028 break 27029 } 27030 c := l.AuxInt 27031 x := l.Args[0] 27032 if !(l.Uses == 1) { 27033 break 27034 } 27035 b.Kind = BlockARMLT 27036 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 27037 v0.AuxInt = c 27038 v0.AddArg(x) 27039 b.SetControl(v0) 27040 b.Aux = nil 27041 return true 27042 } 27043 // match: (LT (CMPconst [0] l:(SUBshiftLL x y [c])) yes no) 27044 // cond: l.Uses==1 27045 // result: (LT (CMPshiftLL x y [c]) yes no) 27046 for { 27047 v := b.Control 27048 if v.Op != OpARMCMPconst { 27049 break 27050 } 27051 if v.AuxInt != 0 { 27052 break 27053 } 27054 l := v.Args[0] 27055 if l.Op != OpARMSUBshiftLL { 27056 break 27057 } 27058 c := l.AuxInt 27059 _ = l.Args[1] 27060 x := l.Args[0] 27061 y := l.Args[1] 27062 if !(l.Uses == 1) { 27063 break 27064 } 27065 b.Kind = BlockARMLT 27066 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags) 27067 v0.AuxInt = c 27068 v0.AddArg(x) 27069 v0.AddArg(y) 27070 b.SetControl(v0) 27071 b.Aux = nil 27072 return true 27073 } 27074 // match: (LT (CMPconst [0] l:(SUBshiftRL x y [c])) yes no) 27075 // cond: l.Uses==1 27076 // result: (LT (CMPshiftRL x y [c]) yes no) 27077 for { 27078 v := b.Control 27079 if v.Op != OpARMCMPconst { 27080 break 27081 } 27082 if v.AuxInt != 0 { 27083 break 27084 } 27085 l := v.Args[0] 27086 if l.Op != OpARMSUBshiftRL { 27087 break 27088 } 27089 c := l.AuxInt 27090 _ = l.Args[1] 27091 x := l.Args[0] 27092 y := l.Args[1] 27093 if !(l.Uses == 1) { 27094 break 27095 } 27096 b.Kind = BlockARMLT 27097 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags) 27098 v0.AuxInt = c 27099 v0.AddArg(x) 27100 v0.AddArg(y) 27101 b.SetControl(v0) 27102 b.Aux = nil 27103 return true 27104 } 27105 // match: (LT (CMPconst [0] l:(SUBshiftRA x y [c])) yes no) 27106 // cond: l.Uses==1 27107 // result: (LT (CMPshiftRA x y [c]) yes no) 27108 for { 27109 v := b.Control 27110 if v.Op != OpARMCMPconst { 27111 break 27112 } 27113 if v.AuxInt != 0 { 27114 break 27115 } 27116 l := v.Args[0] 27117 if l.Op != OpARMSUBshiftRA { 27118 break 27119 } 27120 c := l.AuxInt 27121 _ = l.Args[1] 27122 x := l.Args[0] 27123 y := l.Args[1] 27124 if !(l.Uses == 1) { 27125 break 27126 } 27127 b.Kind = BlockARMLT 27128 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags) 27129 v0.AuxInt = c 27130 v0.AddArg(x) 27131 v0.AddArg(y) 27132 b.SetControl(v0) 27133 b.Aux = nil 27134 return true 27135 } 27136 // match: (LT (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no) 27137 // cond: l.Uses==1 27138 // result: (LT (CMPshiftLLreg x y z) yes no) 27139 for { 27140 v := b.Control 27141 if v.Op != OpARMCMPconst { 27142 break 27143 } 27144 if v.AuxInt != 0 { 27145 break 27146 } 27147 l := v.Args[0] 27148 if l.Op != OpARMSUBshiftLLreg { 27149 break 27150 } 27151 _ = l.Args[2] 27152 x := l.Args[0] 27153 y := l.Args[1] 27154 z := l.Args[2] 27155 if !(l.Uses == 1) { 27156 break 27157 } 27158 b.Kind = BlockARMLT 27159 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags) 27160 v0.AddArg(x) 27161 v0.AddArg(y) 27162 v0.AddArg(z) 27163 b.SetControl(v0) 27164 b.Aux = nil 27165 return true 27166 } 27167 // match: (LT (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no) 27168 // cond: l.Uses==1 27169 // result: (LT (CMPshiftRLreg x y z) yes no) 27170 for { 27171 v := b.Control 27172 if v.Op != OpARMCMPconst { 27173 break 27174 } 27175 if v.AuxInt != 0 { 27176 break 27177 } 27178 l := v.Args[0] 27179 if l.Op != OpARMSUBshiftRLreg { 27180 break 27181 } 27182 _ = l.Args[2] 27183 x := l.Args[0] 27184 y := l.Args[1] 27185 z := l.Args[2] 27186 if !(l.Uses == 1) { 27187 break 27188 } 27189 b.Kind = BlockARMLT 27190 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags) 27191 v0.AddArg(x) 27192 v0.AddArg(y) 27193 v0.AddArg(z) 27194 b.SetControl(v0) 27195 b.Aux = nil 27196 return true 27197 } 27198 // match: (LT (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no) 27199 // cond: l.Uses==1 27200 // result: (LT (CMPshiftRAreg x y z) yes no) 27201 for { 27202 v := b.Control 27203 if v.Op != OpARMCMPconst { 27204 break 27205 } 27206 if v.AuxInt != 0 { 27207 break 27208 } 27209 l := v.Args[0] 27210 if l.Op != OpARMSUBshiftRAreg { 27211 break 27212 } 27213 _ = l.Args[2] 27214 x := l.Args[0] 27215 y := l.Args[1] 27216 z := l.Args[2] 27217 if !(l.Uses == 1) { 27218 break 27219 } 27220 b.Kind = BlockARMLT 27221 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags) 27222 v0.AddArg(x) 27223 v0.AddArg(y) 27224 v0.AddArg(z) 27225 b.SetControl(v0) 27226 b.Aux = nil 27227 return true 27228 } 27229 // match: (LT (CMPconst [0] l:(ADD x y)) yes no) 27230 // cond: l.Uses==1 27231 // result: (LT (CMN x y) yes no) 27232 for { 27233 v := b.Control 27234 if v.Op != OpARMCMPconst { 27235 break 27236 } 27237 if v.AuxInt != 0 { 27238 break 27239 } 27240 l := v.Args[0] 27241 if l.Op != OpARMADD { 27242 break 27243 } 27244 _ = l.Args[1] 27245 x := l.Args[0] 27246 y := l.Args[1] 27247 if !(l.Uses == 1) { 27248 break 27249 } 27250 b.Kind = BlockARMLT 27251 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags) 27252 v0.AddArg(x) 27253 v0.AddArg(y) 27254 b.SetControl(v0) 27255 b.Aux = nil 27256 return true 27257 } 27258 // match: (LT (CMPconst [0] l:(MULA x y a)) yes no) 27259 // cond: l.Uses==1 27260 // result: (LT (CMN a (MUL <x.Type> x y)) yes no) 27261 for { 27262 v := b.Control 27263 if v.Op != OpARMCMPconst { 27264 break 27265 } 27266 if v.AuxInt != 0 { 27267 break 27268 } 27269 l := v.Args[0] 27270 if l.Op != OpARMMULA { 27271 break 27272 } 27273 _ = l.Args[2] 27274 x := l.Args[0] 27275 y := l.Args[1] 27276 a := l.Args[2] 27277 if !(l.Uses == 1) { 27278 break 27279 } 27280 b.Kind = BlockARMLT 27281 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags) 27282 v0.AddArg(a) 27283 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type) 27284 v1.AddArg(x) 27285 v1.AddArg(y) 27286 v0.AddArg(v1) 27287 b.SetControl(v0) 27288 b.Aux = nil 27289 return true 27290 } 27291 // match: (LT (CMPconst [0] l:(ADDconst [c] x)) yes no) 27292 // cond: l.Uses==1 27293 // result: (LT (CMNconst [c] x) yes no) 27294 for { 27295 v := b.Control 27296 if v.Op != OpARMCMPconst { 27297 break 27298 } 27299 if v.AuxInt != 0 { 27300 break 27301 } 27302 l := v.Args[0] 27303 if l.Op != OpARMADDconst { 27304 break 27305 } 27306 c := l.AuxInt 27307 x := l.Args[0] 27308 if !(l.Uses == 1) { 27309 break 27310 } 27311 b.Kind = BlockARMLT 27312 v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags) 27313 v0.AuxInt = c 27314 v0.AddArg(x) 27315 b.SetControl(v0) 27316 b.Aux = nil 27317 return true 27318 } 27319 // match: (LT (CMPconst [0] l:(ADDshiftLL x y [c])) yes no) 27320 // cond: l.Uses==1 27321 // result: (LT (CMNshiftLL x y [c]) yes no) 27322 for { 27323 v := b.Control 27324 if v.Op != OpARMCMPconst { 27325 break 27326 } 27327 if v.AuxInt != 0 { 27328 break 27329 } 27330 l := v.Args[0] 27331 if l.Op != OpARMADDshiftLL { 27332 break 27333 } 27334 c := l.AuxInt 27335 _ = l.Args[1] 27336 x := l.Args[0] 27337 y := l.Args[1] 27338 if !(l.Uses == 1) { 27339 break 27340 } 27341 b.Kind = BlockARMLT 27342 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags) 27343 v0.AuxInt = c 27344 v0.AddArg(x) 27345 v0.AddArg(y) 27346 b.SetControl(v0) 27347 b.Aux = nil 27348 return true 27349 } 27350 // match: (LT (CMPconst [0] l:(ADDshiftRL x y [c])) yes no) 27351 // cond: l.Uses==1 27352 // result: (LT (CMNshiftRL x y [c]) yes no) 27353 for { 27354 v := b.Control 27355 if v.Op != OpARMCMPconst { 27356 break 27357 } 27358 if v.AuxInt != 0 { 27359 break 27360 } 27361 l := v.Args[0] 27362 if l.Op != OpARMADDshiftRL { 27363 break 27364 } 27365 c := l.AuxInt 27366 _ = l.Args[1] 27367 x := l.Args[0] 27368 y := l.Args[1] 27369 if !(l.Uses == 1) { 27370 break 27371 } 27372 b.Kind = BlockARMLT 27373 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags) 27374 v0.AuxInt = c 27375 v0.AddArg(x) 27376 v0.AddArg(y) 27377 b.SetControl(v0) 27378 b.Aux = nil 27379 return true 27380 } 27381 // match: (LT (CMPconst [0] l:(ADDshiftRA x y [c])) yes no) 27382 // cond: l.Uses==1 27383 // result: (LT (CMNshiftRA x y [c]) yes no) 27384 for { 27385 v := b.Control 27386 if v.Op != OpARMCMPconst { 27387 break 27388 } 27389 if v.AuxInt != 0 { 27390 break 27391 } 27392 l := v.Args[0] 27393 if l.Op != OpARMADDshiftRA { 27394 break 27395 } 27396 c := l.AuxInt 27397 _ = l.Args[1] 27398 x := l.Args[0] 27399 y := l.Args[1] 27400 if !(l.Uses == 1) { 27401 break 27402 } 27403 b.Kind = BlockARMLT 27404 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags) 27405 v0.AuxInt = c 27406 v0.AddArg(x) 27407 v0.AddArg(y) 27408 b.SetControl(v0) 27409 b.Aux = nil 27410 return true 27411 } 27412 // match: (LT (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) 27413 // cond: l.Uses==1 27414 // result: (LT (CMNshiftLLreg x y z) yes no) 27415 for { 27416 v := b.Control 27417 if v.Op != OpARMCMPconst { 27418 break 27419 } 27420 if v.AuxInt != 0 { 27421 break 27422 } 27423 l := v.Args[0] 27424 if l.Op != OpARMADDshiftLLreg { 27425 break 27426 } 27427 _ = l.Args[2] 27428 x := l.Args[0] 27429 y := l.Args[1] 27430 z := l.Args[2] 27431 if !(l.Uses == 1) { 27432 break 27433 } 27434 b.Kind = BlockARMLT 27435 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags) 27436 v0.AddArg(x) 27437 v0.AddArg(y) 27438 v0.AddArg(z) 27439 b.SetControl(v0) 27440 b.Aux = nil 27441 return true 27442 } 27443 // match: (LT (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) 27444 // cond: l.Uses==1 27445 // result: (LT (CMNshiftRLreg x y z) yes no) 27446 for { 27447 v := b.Control 27448 if v.Op != OpARMCMPconst { 27449 break 27450 } 27451 if v.AuxInt != 0 { 27452 break 27453 } 27454 l := v.Args[0] 27455 if l.Op != OpARMADDshiftRLreg { 27456 break 27457 } 27458 _ = l.Args[2] 27459 x := l.Args[0] 27460 y := l.Args[1] 27461 z := l.Args[2] 27462 if !(l.Uses == 1) { 27463 break 27464 } 27465 b.Kind = BlockARMLT 27466 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags) 27467 v0.AddArg(x) 27468 v0.AddArg(y) 27469 v0.AddArg(z) 27470 b.SetControl(v0) 27471 b.Aux = nil 27472 return true 27473 } 27474 // match: (LT (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) 27475 // cond: l.Uses==1 27476 // result: (LT (CMNshiftRAreg x y z) yes no) 27477 for { 27478 v := b.Control 27479 if v.Op != OpARMCMPconst { 27480 break 27481 } 27482 if v.AuxInt != 0 { 27483 break 27484 } 27485 l := v.Args[0] 27486 if l.Op != OpARMADDshiftRAreg { 27487 break 27488 } 27489 _ = l.Args[2] 27490 x := l.Args[0] 27491 y := l.Args[1] 27492 z := l.Args[2] 27493 if !(l.Uses == 1) { 27494 break 27495 } 27496 b.Kind = BlockARMLT 27497 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags) 27498 v0.AddArg(x) 27499 v0.AddArg(y) 27500 v0.AddArg(z) 27501 b.SetControl(v0) 27502 b.Aux = nil 27503 return true 27504 } 27505 // match: (LT (CMPconst [0] l:(AND x y)) yes no) 27506 // cond: l.Uses==1 27507 // result: (LT (TST x y) yes no) 27508 for { 27509 v := b.Control 27510 if v.Op != OpARMCMPconst { 27511 break 27512 } 27513 if v.AuxInt != 0 { 27514 break 27515 } 27516 l := v.Args[0] 27517 if l.Op != OpARMAND { 27518 break 27519 } 27520 _ = l.Args[1] 27521 x := l.Args[0] 27522 y := l.Args[1] 27523 if !(l.Uses == 1) { 27524 break 27525 } 27526 b.Kind = BlockARMLT 27527 v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags) 27528 v0.AddArg(x) 27529 v0.AddArg(y) 27530 b.SetControl(v0) 27531 b.Aux = nil 27532 return true 27533 } 27534 // match: (LT (CMPconst [0] l:(ANDconst [c] x)) yes no) 27535 // cond: l.Uses==1 27536 // result: (LT (TSTconst [c] x) yes no) 27537 for { 27538 v := b.Control 27539 if v.Op != OpARMCMPconst { 27540 break 27541 } 27542 if v.AuxInt != 0 { 27543 break 27544 } 27545 l := v.Args[0] 27546 if l.Op != OpARMANDconst { 27547 break 27548 } 27549 c := l.AuxInt 27550 x := l.Args[0] 27551 if !(l.Uses == 1) { 27552 break 27553 } 27554 b.Kind = BlockARMLT 27555 v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags) 27556 v0.AuxInt = c 27557 v0.AddArg(x) 27558 b.SetControl(v0) 27559 b.Aux = nil 27560 return true 27561 } 27562 // match: (LT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) 27563 // cond: l.Uses==1 27564 // result: (LT (TSTshiftLL x y [c]) yes no) 27565 for { 27566 v := b.Control 27567 if v.Op != OpARMCMPconst { 27568 break 27569 } 27570 if v.AuxInt != 0 { 27571 break 27572 } 27573 l := v.Args[0] 27574 if l.Op != OpARMANDshiftLL { 27575 break 27576 } 27577 c := l.AuxInt 27578 _ = l.Args[1] 27579 x := l.Args[0] 27580 y := l.Args[1] 27581 if !(l.Uses == 1) { 27582 break 27583 } 27584 b.Kind = BlockARMLT 27585 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags) 27586 v0.AuxInt = c 27587 v0.AddArg(x) 27588 v0.AddArg(y) 27589 b.SetControl(v0) 27590 b.Aux = nil 27591 return true 27592 } 27593 // match: (LT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) 27594 // cond: l.Uses==1 27595 // result: (LT (TSTshiftRL x y [c]) yes no) 27596 for { 27597 v := b.Control 27598 if v.Op != OpARMCMPconst { 27599 break 27600 } 27601 if v.AuxInt != 0 { 27602 break 27603 } 27604 l := v.Args[0] 27605 if l.Op != OpARMANDshiftRL { 27606 break 27607 } 27608 c := l.AuxInt 27609 _ = l.Args[1] 27610 x := l.Args[0] 27611 y := l.Args[1] 27612 if !(l.Uses == 1) { 27613 break 27614 } 27615 b.Kind = BlockARMLT 27616 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags) 27617 v0.AuxInt = c 27618 v0.AddArg(x) 27619 v0.AddArg(y) 27620 b.SetControl(v0) 27621 b.Aux = nil 27622 return true 27623 } 27624 // match: (LT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) 27625 // cond: l.Uses==1 27626 // result: (LT (TSTshiftRA x y [c]) yes no) 27627 for { 27628 v := b.Control 27629 if v.Op != OpARMCMPconst { 27630 break 27631 } 27632 if v.AuxInt != 0 { 27633 break 27634 } 27635 l := v.Args[0] 27636 if l.Op != OpARMANDshiftRA { 27637 break 27638 } 27639 c := l.AuxInt 27640 _ = l.Args[1] 27641 x := l.Args[0] 27642 y := l.Args[1] 27643 if !(l.Uses == 1) { 27644 break 27645 } 27646 b.Kind = BlockARMLT 27647 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags) 27648 v0.AuxInt = c 27649 v0.AddArg(x) 27650 v0.AddArg(y) 27651 b.SetControl(v0) 27652 b.Aux = nil 27653 return true 27654 } 27655 // match: (LT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) 27656 // cond: l.Uses==1 27657 // result: (LT (TSTshiftLLreg x y z) yes no) 27658 for { 27659 v := b.Control 27660 if v.Op != OpARMCMPconst { 27661 break 27662 } 27663 if v.AuxInt != 0 { 27664 break 27665 } 27666 l := v.Args[0] 27667 if l.Op != OpARMANDshiftLLreg { 27668 break 27669 } 27670 _ = l.Args[2] 27671 x := l.Args[0] 27672 y := l.Args[1] 27673 z := l.Args[2] 27674 if !(l.Uses == 1) { 27675 break 27676 } 27677 b.Kind = BlockARMLT 27678 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags) 27679 v0.AddArg(x) 27680 v0.AddArg(y) 27681 v0.AddArg(z) 27682 b.SetControl(v0) 27683 b.Aux = nil 27684 return true 27685 } 27686 // match: (LT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) 27687 // cond: l.Uses==1 27688 // result: (LT (TSTshiftRLreg x y z) yes no) 27689 for { 27690 v := b.Control 27691 if v.Op != OpARMCMPconst { 27692 break 27693 } 27694 if v.AuxInt != 0 { 27695 break 27696 } 27697 l := v.Args[0] 27698 if l.Op != OpARMANDshiftRLreg { 27699 break 27700 } 27701 _ = l.Args[2] 27702 x := l.Args[0] 27703 y := l.Args[1] 27704 z := l.Args[2] 27705 if !(l.Uses == 1) { 27706 break 27707 } 27708 b.Kind = BlockARMLT 27709 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags) 27710 v0.AddArg(x) 27711 v0.AddArg(y) 27712 v0.AddArg(z) 27713 b.SetControl(v0) 27714 b.Aux = nil 27715 return true 27716 } 27717 // match: (LT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) 27718 // cond: l.Uses==1 27719 // result: (LT (TSTshiftRAreg x y z) yes no) 27720 for { 27721 v := b.Control 27722 if v.Op != OpARMCMPconst { 27723 break 27724 } 27725 if v.AuxInt != 0 { 27726 break 27727 } 27728 l := v.Args[0] 27729 if l.Op != OpARMANDshiftRAreg { 27730 break 27731 } 27732 _ = l.Args[2] 27733 x := l.Args[0] 27734 y := l.Args[1] 27735 z := l.Args[2] 27736 if !(l.Uses == 1) { 27737 break 27738 } 27739 b.Kind = BlockARMLT 27740 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags) 27741 v0.AddArg(x) 27742 v0.AddArg(y) 27743 v0.AddArg(z) 27744 b.SetControl(v0) 27745 b.Aux = nil 27746 return true 27747 } 27748 // match: (LT (CMPconst [0] l:(XOR x y)) yes no) 27749 // cond: l.Uses==1 27750 // result: (LT (TEQ x y) yes no) 27751 for { 27752 v := b.Control 27753 if v.Op != OpARMCMPconst { 27754 break 27755 } 27756 if v.AuxInt != 0 { 27757 break 27758 } 27759 l := v.Args[0] 27760 if l.Op != OpARMXOR { 27761 break 27762 } 27763 _ = l.Args[1] 27764 x := l.Args[0] 27765 y := l.Args[1] 27766 if !(l.Uses == 1) { 27767 break 27768 } 27769 b.Kind = BlockARMLT 27770 v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags) 27771 v0.AddArg(x) 27772 v0.AddArg(y) 27773 b.SetControl(v0) 27774 b.Aux = nil 27775 return true 27776 } 27777 // match: (LT (CMPconst [0] l:(XORconst [c] x)) yes no) 27778 // cond: l.Uses==1 27779 // result: (LT (TEQconst [c] x) yes no) 27780 for { 27781 v := b.Control 27782 if v.Op != OpARMCMPconst { 27783 break 27784 } 27785 if v.AuxInt != 0 { 27786 break 27787 } 27788 l := v.Args[0] 27789 if l.Op != OpARMXORconst { 27790 break 27791 } 27792 c := l.AuxInt 27793 x := l.Args[0] 27794 if !(l.Uses == 1) { 27795 break 27796 } 27797 b.Kind = BlockARMLT 27798 v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags) 27799 v0.AuxInt = c 27800 v0.AddArg(x) 27801 b.SetControl(v0) 27802 b.Aux = nil 27803 return true 27804 } 27805 // match: (LT (CMPconst [0] l:(XORshiftLL x y [c])) yes no) 27806 // cond: l.Uses==1 27807 // result: (LT (TEQshiftLL x y [c]) yes no) 27808 for { 27809 v := b.Control 27810 if v.Op != OpARMCMPconst { 27811 break 27812 } 27813 if v.AuxInt != 0 { 27814 break 27815 } 27816 l := v.Args[0] 27817 if l.Op != OpARMXORshiftLL { 27818 break 27819 } 27820 c := l.AuxInt 27821 _ = l.Args[1] 27822 x := l.Args[0] 27823 y := l.Args[1] 27824 if !(l.Uses == 1) { 27825 break 27826 } 27827 b.Kind = BlockARMLT 27828 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags) 27829 v0.AuxInt = c 27830 v0.AddArg(x) 27831 v0.AddArg(y) 27832 b.SetControl(v0) 27833 b.Aux = nil 27834 return true 27835 } 27836 // match: (LT (CMPconst [0] l:(XORshiftRL x y [c])) yes no) 27837 // cond: l.Uses==1 27838 // result: (LT (TEQshiftRL x y [c]) yes no) 27839 for { 27840 v := b.Control 27841 if v.Op != OpARMCMPconst { 27842 break 27843 } 27844 if v.AuxInt != 0 { 27845 break 27846 } 27847 l := v.Args[0] 27848 if l.Op != OpARMXORshiftRL { 27849 break 27850 } 27851 c := l.AuxInt 27852 _ = l.Args[1] 27853 x := l.Args[0] 27854 y := l.Args[1] 27855 if !(l.Uses == 1) { 27856 break 27857 } 27858 b.Kind = BlockARMLT 27859 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags) 27860 v0.AuxInt = c 27861 v0.AddArg(x) 27862 v0.AddArg(y) 27863 b.SetControl(v0) 27864 b.Aux = nil 27865 return true 27866 } 27867 // match: (LT (CMPconst [0] l:(XORshiftRA x y [c])) yes no) 27868 // cond: l.Uses==1 27869 // result: (LT (TEQshiftRA x y [c]) yes no) 27870 for { 27871 v := b.Control 27872 if v.Op != OpARMCMPconst { 27873 break 27874 } 27875 if v.AuxInt != 0 { 27876 break 27877 } 27878 l := v.Args[0] 27879 if l.Op != OpARMXORshiftRA { 27880 break 27881 } 27882 c := l.AuxInt 27883 _ = l.Args[1] 27884 x := l.Args[0] 27885 y := l.Args[1] 27886 if !(l.Uses == 1) { 27887 break 27888 } 27889 b.Kind = BlockARMLT 27890 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags) 27891 v0.AuxInt = c 27892 v0.AddArg(x) 27893 v0.AddArg(y) 27894 b.SetControl(v0) 27895 b.Aux = nil 27896 return true 27897 } 27898 // match: (LT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) 27899 // cond: l.Uses==1 27900 // result: (LT (TEQshiftLLreg x y z) yes no) 27901 for { 27902 v := b.Control 27903 if v.Op != OpARMCMPconst { 27904 break 27905 } 27906 if v.AuxInt != 0 { 27907 break 27908 } 27909 l := v.Args[0] 27910 if l.Op != OpARMXORshiftLLreg { 27911 break 27912 } 27913 _ = l.Args[2] 27914 x := l.Args[0] 27915 y := l.Args[1] 27916 z := l.Args[2] 27917 if !(l.Uses == 1) { 27918 break 27919 } 27920 b.Kind = BlockARMLT 27921 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags) 27922 v0.AddArg(x) 27923 v0.AddArg(y) 27924 v0.AddArg(z) 27925 b.SetControl(v0) 27926 b.Aux = nil 27927 return true 27928 } 27929 // match: (LT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) 27930 // cond: l.Uses==1 27931 // result: (LT (TEQshiftRLreg x y z) yes no) 27932 for { 27933 v := b.Control 27934 if v.Op != OpARMCMPconst { 27935 break 27936 } 27937 if v.AuxInt != 0 { 27938 break 27939 } 27940 l := v.Args[0] 27941 if l.Op != OpARMXORshiftRLreg { 27942 break 27943 } 27944 _ = l.Args[2] 27945 x := l.Args[0] 27946 y := l.Args[1] 27947 z := l.Args[2] 27948 if !(l.Uses == 1) { 27949 break 27950 } 27951 b.Kind = BlockARMLT 27952 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags) 27953 v0.AddArg(x) 27954 v0.AddArg(y) 27955 v0.AddArg(z) 27956 b.SetControl(v0) 27957 b.Aux = nil 27958 return true 27959 } 27960 // match: (LT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) 27961 // cond: l.Uses==1 27962 // result: (LT (TEQshiftRAreg x y z) yes no) 27963 for { 27964 v := b.Control 27965 if v.Op != OpARMCMPconst { 27966 break 27967 } 27968 if v.AuxInt != 0 { 27969 break 27970 } 27971 l := v.Args[0] 27972 if l.Op != OpARMXORshiftRAreg { 27973 break 27974 } 27975 _ = l.Args[2] 27976 x := l.Args[0] 27977 y := l.Args[1] 27978 z := l.Args[2] 27979 if !(l.Uses == 1) { 27980 break 27981 } 27982 b.Kind = BlockARMLT 27983 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags) 27984 v0.AddArg(x) 27985 v0.AddArg(y) 27986 v0.AddArg(z) 27987 b.SetControl(v0) 27988 b.Aux = nil 27989 return true 27990 } 27991 case BlockARMNE: 27992 // match: (NE (CMPconst [0] (Equal cc)) yes no) 27993 // cond: 27994 // result: (EQ cc yes no) 27995 for { 27996 v := b.Control 27997 if v.Op != OpARMCMPconst { 27998 break 27999 } 28000 if v.AuxInt != 0 { 28001 break 28002 } 28003 v_0 := v.Args[0] 28004 if v_0.Op != OpARMEqual { 28005 break 28006 } 28007 cc := v_0.Args[0] 28008 b.Kind = BlockARMEQ 28009 b.SetControl(cc) 28010 b.Aux = nil 28011 return true 28012 } 28013 // match: (NE (CMPconst [0] (NotEqual cc)) yes no) 28014 // cond: 28015 // result: (NE cc yes no) 28016 for { 28017 v := b.Control 28018 if v.Op != OpARMCMPconst { 28019 break 28020 } 28021 if v.AuxInt != 0 { 28022 break 28023 } 28024 v_0 := v.Args[0] 28025 if v_0.Op != OpARMNotEqual { 28026 break 28027 } 28028 cc := v_0.Args[0] 28029 b.Kind = BlockARMNE 28030 b.SetControl(cc) 28031 b.Aux = nil 28032 return true 28033 } 28034 // match: (NE (CMPconst [0] (LessThan cc)) yes no) 28035 // cond: 28036 // result: (LT cc yes no) 28037 for { 28038 v := b.Control 28039 if v.Op != OpARMCMPconst { 28040 break 28041 } 28042 if v.AuxInt != 0 { 28043 break 28044 } 28045 v_0 := v.Args[0] 28046 if v_0.Op != OpARMLessThan { 28047 break 28048 } 28049 cc := v_0.Args[0] 28050 b.Kind = BlockARMLT 28051 b.SetControl(cc) 28052 b.Aux = nil 28053 return true 28054 } 28055 // match: (NE (CMPconst [0] (LessThanU cc)) yes no) 28056 // cond: 28057 // result: (ULT cc yes no) 28058 for { 28059 v := b.Control 28060 if v.Op != OpARMCMPconst { 28061 break 28062 } 28063 if v.AuxInt != 0 { 28064 break 28065 } 28066 v_0 := v.Args[0] 28067 if v_0.Op != OpARMLessThanU { 28068 break 28069 } 28070 cc := v_0.Args[0] 28071 b.Kind = BlockARMULT 28072 b.SetControl(cc) 28073 b.Aux = nil 28074 return true 28075 } 28076 // match: (NE (CMPconst [0] (LessEqual cc)) yes no) 28077 // cond: 28078 // result: (LE cc yes no) 28079 for { 28080 v := b.Control 28081 if v.Op != OpARMCMPconst { 28082 break 28083 } 28084 if v.AuxInt != 0 { 28085 break 28086 } 28087 v_0 := v.Args[0] 28088 if v_0.Op != OpARMLessEqual { 28089 break 28090 } 28091 cc := v_0.Args[0] 28092 b.Kind = BlockARMLE 28093 b.SetControl(cc) 28094 b.Aux = nil 28095 return true 28096 } 28097 // match: (NE (CMPconst [0] (LessEqualU cc)) yes no) 28098 // cond: 28099 // result: (ULE cc yes no) 28100 for { 28101 v := b.Control 28102 if v.Op != OpARMCMPconst { 28103 break 28104 } 28105 if v.AuxInt != 0 { 28106 break 28107 } 28108 v_0 := v.Args[0] 28109 if v_0.Op != OpARMLessEqualU { 28110 break 28111 } 28112 cc := v_0.Args[0] 28113 b.Kind = BlockARMULE 28114 b.SetControl(cc) 28115 b.Aux = nil 28116 return true 28117 } 28118 // match: (NE (CMPconst [0] (GreaterThan cc)) yes no) 28119 // cond: 28120 // result: (GT cc yes no) 28121 for { 28122 v := b.Control 28123 if v.Op != OpARMCMPconst { 28124 break 28125 } 28126 if v.AuxInt != 0 { 28127 break 28128 } 28129 v_0 := v.Args[0] 28130 if v_0.Op != OpARMGreaterThan { 28131 break 28132 } 28133 cc := v_0.Args[0] 28134 b.Kind = BlockARMGT 28135 b.SetControl(cc) 28136 b.Aux = nil 28137 return true 28138 } 28139 // match: (NE (CMPconst [0] (GreaterThanU cc)) yes no) 28140 // cond: 28141 // result: (UGT cc yes no) 28142 for { 28143 v := b.Control 28144 if v.Op != OpARMCMPconst { 28145 break 28146 } 28147 if v.AuxInt != 0 { 28148 break 28149 } 28150 v_0 := v.Args[0] 28151 if v_0.Op != OpARMGreaterThanU { 28152 break 28153 } 28154 cc := v_0.Args[0] 28155 b.Kind = BlockARMUGT 28156 b.SetControl(cc) 28157 b.Aux = nil 28158 return true 28159 } 28160 // match: (NE (CMPconst [0] (GreaterEqual cc)) yes no) 28161 // cond: 28162 // result: (GE cc yes no) 28163 for { 28164 v := b.Control 28165 if v.Op != OpARMCMPconst { 28166 break 28167 } 28168 if v.AuxInt != 0 { 28169 break 28170 } 28171 v_0 := v.Args[0] 28172 if v_0.Op != OpARMGreaterEqual { 28173 break 28174 } 28175 cc := v_0.Args[0] 28176 b.Kind = BlockARMGE 28177 b.SetControl(cc) 28178 b.Aux = nil 28179 return true 28180 } 28181 // match: (NE (CMPconst [0] (GreaterEqualU cc)) yes no) 28182 // cond: 28183 // result: (UGE cc yes no) 28184 for { 28185 v := b.Control 28186 if v.Op != OpARMCMPconst { 28187 break 28188 } 28189 if v.AuxInt != 0 { 28190 break 28191 } 28192 v_0 := v.Args[0] 28193 if v_0.Op != OpARMGreaterEqualU { 28194 break 28195 } 28196 cc := v_0.Args[0] 28197 b.Kind = BlockARMUGE 28198 b.SetControl(cc) 28199 b.Aux = nil 28200 return true 28201 } 28202 // match: (NE (FlagEQ) yes no) 28203 // cond: 28204 // result: (First nil no yes) 28205 for { 28206 v := b.Control 28207 if v.Op != OpARMFlagEQ { 28208 break 28209 } 28210 b.Kind = BlockFirst 28211 b.SetControl(nil) 28212 b.Aux = nil 28213 b.swapSuccessors() 28214 return true 28215 } 28216 // match: (NE (FlagLT_ULT) yes no) 28217 // cond: 28218 // result: (First nil yes no) 28219 for { 28220 v := b.Control 28221 if v.Op != OpARMFlagLT_ULT { 28222 break 28223 } 28224 b.Kind = BlockFirst 28225 b.SetControl(nil) 28226 b.Aux = nil 28227 return true 28228 } 28229 // match: (NE (FlagLT_UGT) yes no) 28230 // cond: 28231 // result: (First nil yes no) 28232 for { 28233 v := b.Control 28234 if v.Op != OpARMFlagLT_UGT { 28235 break 28236 } 28237 b.Kind = BlockFirst 28238 b.SetControl(nil) 28239 b.Aux = nil 28240 return true 28241 } 28242 // match: (NE (FlagGT_ULT) yes no) 28243 // cond: 28244 // result: (First nil yes no) 28245 for { 28246 v := b.Control 28247 if v.Op != OpARMFlagGT_ULT { 28248 break 28249 } 28250 b.Kind = BlockFirst 28251 b.SetControl(nil) 28252 b.Aux = nil 28253 return true 28254 } 28255 // match: (NE (FlagGT_UGT) yes no) 28256 // cond: 28257 // result: (First nil yes no) 28258 for { 28259 v := b.Control 28260 if v.Op != OpARMFlagGT_UGT { 28261 break 28262 } 28263 b.Kind = BlockFirst 28264 b.SetControl(nil) 28265 b.Aux = nil 28266 return true 28267 } 28268 // match: (NE (InvertFlags cmp) yes no) 28269 // cond: 28270 // result: (NE cmp yes no) 28271 for { 28272 v := b.Control 28273 if v.Op != OpARMInvertFlags { 28274 break 28275 } 28276 cmp := v.Args[0] 28277 b.Kind = BlockARMNE 28278 b.SetControl(cmp) 28279 b.Aux = nil 28280 return true 28281 } 28282 // match: (NE (CMPconst [0] l:(SUB x y)) yes no) 28283 // cond: l.Uses==1 28284 // result: (NE (CMP x y) yes no) 28285 for { 28286 v := b.Control 28287 if v.Op != OpARMCMPconst { 28288 break 28289 } 28290 if v.AuxInt != 0 { 28291 break 28292 } 28293 l := v.Args[0] 28294 if l.Op != OpARMSUB { 28295 break 28296 } 28297 _ = l.Args[1] 28298 x := l.Args[0] 28299 y := l.Args[1] 28300 if !(l.Uses == 1) { 28301 break 28302 } 28303 b.Kind = BlockARMNE 28304 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 28305 v0.AddArg(x) 28306 v0.AddArg(y) 28307 b.SetControl(v0) 28308 b.Aux = nil 28309 return true 28310 } 28311 // match: (NE (CMPconst [0] l:(MULS x y a)) yes no) 28312 // cond: l.Uses==1 28313 // result: (NE (CMP a (MUL <x.Type> x y)) yes no) 28314 for { 28315 v := b.Control 28316 if v.Op != OpARMCMPconst { 28317 break 28318 } 28319 if v.AuxInt != 0 { 28320 break 28321 } 28322 l := v.Args[0] 28323 if l.Op != OpARMMULS { 28324 break 28325 } 28326 _ = l.Args[2] 28327 x := l.Args[0] 28328 y := l.Args[1] 28329 a := l.Args[2] 28330 if !(l.Uses == 1) { 28331 break 28332 } 28333 b.Kind = BlockARMNE 28334 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags) 28335 v0.AddArg(a) 28336 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type) 28337 v1.AddArg(x) 28338 v1.AddArg(y) 28339 v0.AddArg(v1) 28340 b.SetControl(v0) 28341 b.Aux = nil 28342 return true 28343 } 28344 // match: (NE (CMPconst [0] l:(SUBconst [c] x)) yes no) 28345 // cond: l.Uses==1 28346 // result: (NE (CMPconst [c] x) yes no) 28347 for { 28348 v := b.Control 28349 if v.Op != OpARMCMPconst { 28350 break 28351 } 28352 if v.AuxInt != 0 { 28353 break 28354 } 28355 l := v.Args[0] 28356 if l.Op != OpARMSUBconst { 28357 break 28358 } 28359 c := l.AuxInt 28360 x := l.Args[0] 28361 if !(l.Uses == 1) { 28362 break 28363 } 28364 b.Kind = BlockARMNE 28365 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags) 28366 v0.AuxInt = c 28367 v0.AddArg(x) 28368 b.SetControl(v0) 28369 b.Aux = nil 28370 return true 28371 } 28372 // match: (NE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no) 28373 // cond: l.Uses==1 28374 // result: (NE (CMPshiftLL x y [c]) yes no) 28375 for { 28376 v := b.Control 28377 if v.Op != OpARMCMPconst { 28378 break 28379 } 28380 if v.AuxInt != 0 { 28381 break 28382 } 28383 l := v.Args[0] 28384 if l.Op != OpARMSUBshiftLL { 28385 break 28386 } 28387 c := l.AuxInt 28388 _ = l.Args[1] 28389 x := l.Args[0] 28390 y := l.Args[1] 28391 if !(l.Uses == 1) { 28392 break 28393 } 28394 b.Kind = BlockARMNE 28395 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags) 28396 v0.AuxInt = c 28397 v0.AddArg(x) 28398 v0.AddArg(y) 28399 b.SetControl(v0) 28400 b.Aux = nil 28401 return true 28402 } 28403 // match: (NE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no) 28404 // cond: l.Uses==1 28405 // result: (NE (CMPshiftRL x y [c]) yes no) 28406 for { 28407 v := b.Control 28408 if v.Op != OpARMCMPconst { 28409 break 28410 } 28411 if v.AuxInt != 0 { 28412 break 28413 } 28414 l := v.Args[0] 28415 if l.Op != OpARMSUBshiftRL { 28416 break 28417 } 28418 c := l.AuxInt 28419 _ = l.Args[1] 28420 x := l.Args[0] 28421 y := l.Args[1] 28422 if !(l.Uses == 1) { 28423 break 28424 } 28425 b.Kind = BlockARMNE 28426 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags) 28427 v0.AuxInt = c 28428 v0.AddArg(x) 28429 v0.AddArg(y) 28430 b.SetControl(v0) 28431 b.Aux = nil 28432 return true 28433 } 28434 // match: (NE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no) 28435 // cond: l.Uses==1 28436 // result: (NE (CMPshiftRA x y [c]) yes no) 28437 for { 28438 v := b.Control 28439 if v.Op != OpARMCMPconst { 28440 break 28441 } 28442 if v.AuxInt != 0 { 28443 break 28444 } 28445 l := v.Args[0] 28446 if l.Op != OpARMSUBshiftRA { 28447 break 28448 } 28449 c := l.AuxInt 28450 _ = l.Args[1] 28451 x := l.Args[0] 28452 y := l.Args[1] 28453 if !(l.Uses == 1) { 28454 break 28455 } 28456 b.Kind = BlockARMNE 28457 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags) 28458 v0.AuxInt = c 28459 v0.AddArg(x) 28460 v0.AddArg(y) 28461 b.SetControl(v0) 28462 b.Aux = nil 28463 return true 28464 } 28465 // match: (NE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no) 28466 // cond: l.Uses==1 28467 // result: (NE (CMPshiftLLreg x y z) yes no) 28468 for { 28469 v := b.Control 28470 if v.Op != OpARMCMPconst { 28471 break 28472 } 28473 if v.AuxInt != 0 { 28474 break 28475 } 28476 l := v.Args[0] 28477 if l.Op != OpARMSUBshiftLLreg { 28478 break 28479 } 28480 _ = l.Args[2] 28481 x := l.Args[0] 28482 y := l.Args[1] 28483 z := l.Args[2] 28484 if !(l.Uses == 1) { 28485 break 28486 } 28487 b.Kind = BlockARMNE 28488 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags) 28489 v0.AddArg(x) 28490 v0.AddArg(y) 28491 v0.AddArg(z) 28492 b.SetControl(v0) 28493 b.Aux = nil 28494 return true 28495 } 28496 // match: (NE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no) 28497 // cond: l.Uses==1 28498 // result: (NE (CMPshiftRLreg x y z) yes no) 28499 for { 28500 v := b.Control 28501 if v.Op != OpARMCMPconst { 28502 break 28503 } 28504 if v.AuxInt != 0 { 28505 break 28506 } 28507 l := v.Args[0] 28508 if l.Op != OpARMSUBshiftRLreg { 28509 break 28510 } 28511 _ = l.Args[2] 28512 x := l.Args[0] 28513 y := l.Args[1] 28514 z := l.Args[2] 28515 if !(l.Uses == 1) { 28516 break 28517 } 28518 b.Kind = BlockARMNE 28519 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags) 28520 v0.AddArg(x) 28521 v0.AddArg(y) 28522 v0.AddArg(z) 28523 b.SetControl(v0) 28524 b.Aux = nil 28525 return true 28526 } 28527 // match: (NE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no) 28528 // cond: l.Uses==1 28529 // result: (NE (CMPshiftRAreg x y z) yes no) 28530 for { 28531 v := b.Control 28532 if v.Op != OpARMCMPconst { 28533 break 28534 } 28535 if v.AuxInt != 0 { 28536 break 28537 } 28538 l := v.Args[0] 28539 if l.Op != OpARMSUBshiftRAreg { 28540 break 28541 } 28542 _ = l.Args[2] 28543 x := l.Args[0] 28544 y := l.Args[1] 28545 z := l.Args[2] 28546 if !(l.Uses == 1) { 28547 break 28548 } 28549 b.Kind = BlockARMNE 28550 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags) 28551 v0.AddArg(x) 28552 v0.AddArg(y) 28553 v0.AddArg(z) 28554 b.SetControl(v0) 28555 b.Aux = nil 28556 return true 28557 } 28558 // match: (NE (CMPconst [0] l:(ADD x y)) yes no) 28559 // cond: l.Uses==1 28560 // result: (NE (CMN x y) yes no) 28561 for { 28562 v := b.Control 28563 if v.Op != OpARMCMPconst { 28564 break 28565 } 28566 if v.AuxInt != 0 { 28567 break 28568 } 28569 l := v.Args[0] 28570 if l.Op != OpARMADD { 28571 break 28572 } 28573 _ = l.Args[1] 28574 x := l.Args[0] 28575 y := l.Args[1] 28576 if !(l.Uses == 1) { 28577 break 28578 } 28579 b.Kind = BlockARMNE 28580 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags) 28581 v0.AddArg(x) 28582 v0.AddArg(y) 28583 b.SetControl(v0) 28584 b.Aux = nil 28585 return true 28586 } 28587 // match: (NE (CMPconst [0] l:(MULA x y a)) yes no) 28588 // cond: l.Uses==1 28589 // result: (NE (CMN a (MUL <x.Type> x y)) yes no) 28590 for { 28591 v := b.Control 28592 if v.Op != OpARMCMPconst { 28593 break 28594 } 28595 if v.AuxInt != 0 { 28596 break 28597 } 28598 l := v.Args[0] 28599 if l.Op != OpARMMULA { 28600 break 28601 } 28602 _ = l.Args[2] 28603 x := l.Args[0] 28604 y := l.Args[1] 28605 a := l.Args[2] 28606 if !(l.Uses == 1) { 28607 break 28608 } 28609 b.Kind = BlockARMNE 28610 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags) 28611 v0.AddArg(a) 28612 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type) 28613 v1.AddArg(x) 28614 v1.AddArg(y) 28615 v0.AddArg(v1) 28616 b.SetControl(v0) 28617 b.Aux = nil 28618 return true 28619 } 28620 // match: (NE (CMPconst [0] l:(ADDconst [c] x)) yes no) 28621 // cond: l.Uses==1 28622 // result: (NE (CMNconst [c] x) yes no) 28623 for { 28624 v := b.Control 28625 if v.Op != OpARMCMPconst { 28626 break 28627 } 28628 if v.AuxInt != 0 { 28629 break 28630 } 28631 l := v.Args[0] 28632 if l.Op != OpARMADDconst { 28633 break 28634 } 28635 c := l.AuxInt 28636 x := l.Args[0] 28637 if !(l.Uses == 1) { 28638 break 28639 } 28640 b.Kind = BlockARMNE 28641 v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags) 28642 v0.AuxInt = c 28643 v0.AddArg(x) 28644 b.SetControl(v0) 28645 b.Aux = nil 28646 return true 28647 } 28648 // match: (NE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no) 28649 // cond: l.Uses==1 28650 // result: (NE (CMNshiftLL x y [c]) yes no) 28651 for { 28652 v := b.Control 28653 if v.Op != OpARMCMPconst { 28654 break 28655 } 28656 if v.AuxInt != 0 { 28657 break 28658 } 28659 l := v.Args[0] 28660 if l.Op != OpARMADDshiftLL { 28661 break 28662 } 28663 c := l.AuxInt 28664 _ = l.Args[1] 28665 x := l.Args[0] 28666 y := l.Args[1] 28667 if !(l.Uses == 1) { 28668 break 28669 } 28670 b.Kind = BlockARMNE 28671 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags) 28672 v0.AuxInt = c 28673 v0.AddArg(x) 28674 v0.AddArg(y) 28675 b.SetControl(v0) 28676 b.Aux = nil 28677 return true 28678 } 28679 // match: (NE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no) 28680 // cond: l.Uses==1 28681 // result: (NE (CMNshiftRL x y [c]) yes no) 28682 for { 28683 v := b.Control 28684 if v.Op != OpARMCMPconst { 28685 break 28686 } 28687 if v.AuxInt != 0 { 28688 break 28689 } 28690 l := v.Args[0] 28691 if l.Op != OpARMADDshiftRL { 28692 break 28693 } 28694 c := l.AuxInt 28695 _ = l.Args[1] 28696 x := l.Args[0] 28697 y := l.Args[1] 28698 if !(l.Uses == 1) { 28699 break 28700 } 28701 b.Kind = BlockARMNE 28702 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags) 28703 v0.AuxInt = c 28704 v0.AddArg(x) 28705 v0.AddArg(y) 28706 b.SetControl(v0) 28707 b.Aux = nil 28708 return true 28709 } 28710 // match: (NE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no) 28711 // cond: l.Uses==1 28712 // result: (NE (CMNshiftRA x y [c]) yes no) 28713 for { 28714 v := b.Control 28715 if v.Op != OpARMCMPconst { 28716 break 28717 } 28718 if v.AuxInt != 0 { 28719 break 28720 } 28721 l := v.Args[0] 28722 if l.Op != OpARMADDshiftRA { 28723 break 28724 } 28725 c := l.AuxInt 28726 _ = l.Args[1] 28727 x := l.Args[0] 28728 y := l.Args[1] 28729 if !(l.Uses == 1) { 28730 break 28731 } 28732 b.Kind = BlockARMNE 28733 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags) 28734 v0.AuxInt = c 28735 v0.AddArg(x) 28736 v0.AddArg(y) 28737 b.SetControl(v0) 28738 b.Aux = nil 28739 return true 28740 } 28741 // match: (NE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) 28742 // cond: l.Uses==1 28743 // result: (NE (CMNshiftLLreg x y z) yes no) 28744 for { 28745 v := b.Control 28746 if v.Op != OpARMCMPconst { 28747 break 28748 } 28749 if v.AuxInt != 0 { 28750 break 28751 } 28752 l := v.Args[0] 28753 if l.Op != OpARMADDshiftLLreg { 28754 break 28755 } 28756 _ = l.Args[2] 28757 x := l.Args[0] 28758 y := l.Args[1] 28759 z := l.Args[2] 28760 if !(l.Uses == 1) { 28761 break 28762 } 28763 b.Kind = BlockARMNE 28764 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags) 28765 v0.AddArg(x) 28766 v0.AddArg(y) 28767 v0.AddArg(z) 28768 b.SetControl(v0) 28769 b.Aux = nil 28770 return true 28771 } 28772 // match: (NE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) 28773 // cond: l.Uses==1 28774 // result: (NE (CMNshiftRLreg x y z) yes no) 28775 for { 28776 v := b.Control 28777 if v.Op != OpARMCMPconst { 28778 break 28779 } 28780 if v.AuxInt != 0 { 28781 break 28782 } 28783 l := v.Args[0] 28784 if l.Op != OpARMADDshiftRLreg { 28785 break 28786 } 28787 _ = l.Args[2] 28788 x := l.Args[0] 28789 y := l.Args[1] 28790 z := l.Args[2] 28791 if !(l.Uses == 1) { 28792 break 28793 } 28794 b.Kind = BlockARMNE 28795 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags) 28796 v0.AddArg(x) 28797 v0.AddArg(y) 28798 v0.AddArg(z) 28799 b.SetControl(v0) 28800 b.Aux = nil 28801 return true 28802 } 28803 // match: (NE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) 28804 // cond: l.Uses==1 28805 // result: (NE (CMNshiftRAreg x y z) yes no) 28806 for { 28807 v := b.Control 28808 if v.Op != OpARMCMPconst { 28809 break 28810 } 28811 if v.AuxInt != 0 { 28812 break 28813 } 28814 l := v.Args[0] 28815 if l.Op != OpARMADDshiftRAreg { 28816 break 28817 } 28818 _ = l.Args[2] 28819 x := l.Args[0] 28820 y := l.Args[1] 28821 z := l.Args[2] 28822 if !(l.Uses == 1) { 28823 break 28824 } 28825 b.Kind = BlockARMNE 28826 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags) 28827 v0.AddArg(x) 28828 v0.AddArg(y) 28829 v0.AddArg(z) 28830 b.SetControl(v0) 28831 b.Aux = nil 28832 return true 28833 } 28834 // match: (NE (CMPconst [0] l:(AND x y)) yes no) 28835 // cond: l.Uses==1 28836 // result: (NE (TST x y) yes no) 28837 for { 28838 v := b.Control 28839 if v.Op != OpARMCMPconst { 28840 break 28841 } 28842 if v.AuxInt != 0 { 28843 break 28844 } 28845 l := v.Args[0] 28846 if l.Op != OpARMAND { 28847 break 28848 } 28849 _ = l.Args[1] 28850 x := l.Args[0] 28851 y := l.Args[1] 28852 if !(l.Uses == 1) { 28853 break 28854 } 28855 b.Kind = BlockARMNE 28856 v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags) 28857 v0.AddArg(x) 28858 v0.AddArg(y) 28859 b.SetControl(v0) 28860 b.Aux = nil 28861 return true 28862 } 28863 // match: (NE (CMPconst [0] l:(ANDconst [c] x)) yes no) 28864 // cond: l.Uses==1 28865 // result: (NE (TSTconst [c] x) yes no) 28866 for { 28867 v := b.Control 28868 if v.Op != OpARMCMPconst { 28869 break 28870 } 28871 if v.AuxInt != 0 { 28872 break 28873 } 28874 l := v.Args[0] 28875 if l.Op != OpARMANDconst { 28876 break 28877 } 28878 c := l.AuxInt 28879 x := l.Args[0] 28880 if !(l.Uses == 1) { 28881 break 28882 } 28883 b.Kind = BlockARMNE 28884 v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags) 28885 v0.AuxInt = c 28886 v0.AddArg(x) 28887 b.SetControl(v0) 28888 b.Aux = nil 28889 return true 28890 } 28891 // match: (NE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) 28892 // cond: l.Uses==1 28893 // result: (NE (TSTshiftLL x y [c]) yes no) 28894 for { 28895 v := b.Control 28896 if v.Op != OpARMCMPconst { 28897 break 28898 } 28899 if v.AuxInt != 0 { 28900 break 28901 } 28902 l := v.Args[0] 28903 if l.Op != OpARMANDshiftLL { 28904 break 28905 } 28906 c := l.AuxInt 28907 _ = l.Args[1] 28908 x := l.Args[0] 28909 y := l.Args[1] 28910 if !(l.Uses == 1) { 28911 break 28912 } 28913 b.Kind = BlockARMNE 28914 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags) 28915 v0.AuxInt = c 28916 v0.AddArg(x) 28917 v0.AddArg(y) 28918 b.SetControl(v0) 28919 b.Aux = nil 28920 return true 28921 } 28922 // match: (NE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) 28923 // cond: l.Uses==1 28924 // result: (NE (TSTshiftRL x y [c]) yes no) 28925 for { 28926 v := b.Control 28927 if v.Op != OpARMCMPconst { 28928 break 28929 } 28930 if v.AuxInt != 0 { 28931 break 28932 } 28933 l := v.Args[0] 28934 if l.Op != OpARMANDshiftRL { 28935 break 28936 } 28937 c := l.AuxInt 28938 _ = l.Args[1] 28939 x := l.Args[0] 28940 y := l.Args[1] 28941 if !(l.Uses == 1) { 28942 break 28943 } 28944 b.Kind = BlockARMNE 28945 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags) 28946 v0.AuxInt = c 28947 v0.AddArg(x) 28948 v0.AddArg(y) 28949 b.SetControl(v0) 28950 b.Aux = nil 28951 return true 28952 } 28953 // match: (NE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) 28954 // cond: l.Uses==1 28955 // result: (NE (TSTshiftRA x y [c]) yes no) 28956 for { 28957 v := b.Control 28958 if v.Op != OpARMCMPconst { 28959 break 28960 } 28961 if v.AuxInt != 0 { 28962 break 28963 } 28964 l := v.Args[0] 28965 if l.Op != OpARMANDshiftRA { 28966 break 28967 } 28968 c := l.AuxInt 28969 _ = l.Args[1] 28970 x := l.Args[0] 28971 y := l.Args[1] 28972 if !(l.Uses == 1) { 28973 break 28974 } 28975 b.Kind = BlockARMNE 28976 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags) 28977 v0.AuxInt = c 28978 v0.AddArg(x) 28979 v0.AddArg(y) 28980 b.SetControl(v0) 28981 b.Aux = nil 28982 return true 28983 } 28984 // match: (NE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) 28985 // cond: l.Uses==1 28986 // result: (NE (TSTshiftLLreg x y z) yes no) 28987 for { 28988 v := b.Control 28989 if v.Op != OpARMCMPconst { 28990 break 28991 } 28992 if v.AuxInt != 0 { 28993 break 28994 } 28995 l := v.Args[0] 28996 if l.Op != OpARMANDshiftLLreg { 28997 break 28998 } 28999 _ = l.Args[2] 29000 x := l.Args[0] 29001 y := l.Args[1] 29002 z := l.Args[2] 29003 if !(l.Uses == 1) { 29004 break 29005 } 29006 b.Kind = BlockARMNE 29007 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags) 29008 v0.AddArg(x) 29009 v0.AddArg(y) 29010 v0.AddArg(z) 29011 b.SetControl(v0) 29012 b.Aux = nil 29013 return true 29014 } 29015 // match: (NE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) 29016 // cond: l.Uses==1 29017 // result: (NE (TSTshiftRLreg x y z) yes no) 29018 for { 29019 v := b.Control 29020 if v.Op != OpARMCMPconst { 29021 break 29022 } 29023 if v.AuxInt != 0 { 29024 break 29025 } 29026 l := v.Args[0] 29027 if l.Op != OpARMANDshiftRLreg { 29028 break 29029 } 29030 _ = l.Args[2] 29031 x := l.Args[0] 29032 y := l.Args[1] 29033 z := l.Args[2] 29034 if !(l.Uses == 1) { 29035 break 29036 } 29037 b.Kind = BlockARMNE 29038 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags) 29039 v0.AddArg(x) 29040 v0.AddArg(y) 29041 v0.AddArg(z) 29042 b.SetControl(v0) 29043 b.Aux = nil 29044 return true 29045 } 29046 // match: (NE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) 29047 // cond: l.Uses==1 29048 // result: (NE (TSTshiftRAreg x y z) yes no) 29049 for { 29050 v := b.Control 29051 if v.Op != OpARMCMPconst { 29052 break 29053 } 29054 if v.AuxInt != 0 { 29055 break 29056 } 29057 l := v.Args[0] 29058 if l.Op != OpARMANDshiftRAreg { 29059 break 29060 } 29061 _ = l.Args[2] 29062 x := l.Args[0] 29063 y := l.Args[1] 29064 z := l.Args[2] 29065 if !(l.Uses == 1) { 29066 break 29067 } 29068 b.Kind = BlockARMNE 29069 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags) 29070 v0.AddArg(x) 29071 v0.AddArg(y) 29072 v0.AddArg(z) 29073 b.SetControl(v0) 29074 b.Aux = nil 29075 return true 29076 } 29077 // match: (NE (CMPconst [0] l:(XOR x y)) yes no) 29078 // cond: l.Uses==1 29079 // result: (NE (TEQ x y) yes no) 29080 for { 29081 v := b.Control 29082 if v.Op != OpARMCMPconst { 29083 break 29084 } 29085 if v.AuxInt != 0 { 29086 break 29087 } 29088 l := v.Args[0] 29089 if l.Op != OpARMXOR { 29090 break 29091 } 29092 _ = l.Args[1] 29093 x := l.Args[0] 29094 y := l.Args[1] 29095 if !(l.Uses == 1) { 29096 break 29097 } 29098 b.Kind = BlockARMNE 29099 v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags) 29100 v0.AddArg(x) 29101 v0.AddArg(y) 29102 b.SetControl(v0) 29103 b.Aux = nil 29104 return true 29105 } 29106 // match: (NE (CMPconst [0] l:(XORconst [c] x)) yes no) 29107 // cond: l.Uses==1 29108 // result: (NE (TEQconst [c] x) yes no) 29109 for { 29110 v := b.Control 29111 if v.Op != OpARMCMPconst { 29112 break 29113 } 29114 if v.AuxInt != 0 { 29115 break 29116 } 29117 l := v.Args[0] 29118 if l.Op != OpARMXORconst { 29119 break 29120 } 29121 c := l.AuxInt 29122 x := l.Args[0] 29123 if !(l.Uses == 1) { 29124 break 29125 } 29126 b.Kind = BlockARMNE 29127 v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags) 29128 v0.AuxInt = c 29129 v0.AddArg(x) 29130 b.SetControl(v0) 29131 b.Aux = nil 29132 return true 29133 } 29134 // match: (NE (CMPconst [0] l:(XORshiftLL x y [c])) yes no) 29135 // cond: l.Uses==1 29136 // result: (NE (TEQshiftLL x y [c]) yes no) 29137 for { 29138 v := b.Control 29139 if v.Op != OpARMCMPconst { 29140 break 29141 } 29142 if v.AuxInt != 0 { 29143 break 29144 } 29145 l := v.Args[0] 29146 if l.Op != OpARMXORshiftLL { 29147 break 29148 } 29149 c := l.AuxInt 29150 _ = l.Args[1] 29151 x := l.Args[0] 29152 y := l.Args[1] 29153 if !(l.Uses == 1) { 29154 break 29155 } 29156 b.Kind = BlockARMNE 29157 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags) 29158 v0.AuxInt = c 29159 v0.AddArg(x) 29160 v0.AddArg(y) 29161 b.SetControl(v0) 29162 b.Aux = nil 29163 return true 29164 } 29165 // match: (NE (CMPconst [0] l:(XORshiftRL x y [c])) yes no) 29166 // cond: l.Uses==1 29167 // result: (NE (TEQshiftRL x y [c]) yes no) 29168 for { 29169 v := b.Control 29170 if v.Op != OpARMCMPconst { 29171 break 29172 } 29173 if v.AuxInt != 0 { 29174 break 29175 } 29176 l := v.Args[0] 29177 if l.Op != OpARMXORshiftRL { 29178 break 29179 } 29180 c := l.AuxInt 29181 _ = l.Args[1] 29182 x := l.Args[0] 29183 y := l.Args[1] 29184 if !(l.Uses == 1) { 29185 break 29186 } 29187 b.Kind = BlockARMNE 29188 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags) 29189 v0.AuxInt = c 29190 v0.AddArg(x) 29191 v0.AddArg(y) 29192 b.SetControl(v0) 29193 b.Aux = nil 29194 return true 29195 } 29196 // match: (NE (CMPconst [0] l:(XORshiftRA x y [c])) yes no) 29197 // cond: l.Uses==1 29198 // result: (NE (TEQshiftRA x y [c]) yes no) 29199 for { 29200 v := b.Control 29201 if v.Op != OpARMCMPconst { 29202 break 29203 } 29204 if v.AuxInt != 0 { 29205 break 29206 } 29207 l := v.Args[0] 29208 if l.Op != OpARMXORshiftRA { 29209 break 29210 } 29211 c := l.AuxInt 29212 _ = l.Args[1] 29213 x := l.Args[0] 29214 y := l.Args[1] 29215 if !(l.Uses == 1) { 29216 break 29217 } 29218 b.Kind = BlockARMNE 29219 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags) 29220 v0.AuxInt = c 29221 v0.AddArg(x) 29222 v0.AddArg(y) 29223 b.SetControl(v0) 29224 b.Aux = nil 29225 return true 29226 } 29227 // match: (NE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) 29228 // cond: l.Uses==1 29229 // result: (NE (TEQshiftLLreg x y z) yes no) 29230 for { 29231 v := b.Control 29232 if v.Op != OpARMCMPconst { 29233 break 29234 } 29235 if v.AuxInt != 0 { 29236 break 29237 } 29238 l := v.Args[0] 29239 if l.Op != OpARMXORshiftLLreg { 29240 break 29241 } 29242 _ = l.Args[2] 29243 x := l.Args[0] 29244 y := l.Args[1] 29245 z := l.Args[2] 29246 if !(l.Uses == 1) { 29247 break 29248 } 29249 b.Kind = BlockARMNE 29250 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags) 29251 v0.AddArg(x) 29252 v0.AddArg(y) 29253 v0.AddArg(z) 29254 b.SetControl(v0) 29255 b.Aux = nil 29256 return true 29257 } 29258 // match: (NE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) 29259 // cond: l.Uses==1 29260 // result: (NE (TEQshiftRLreg x y z) yes no) 29261 for { 29262 v := b.Control 29263 if v.Op != OpARMCMPconst { 29264 break 29265 } 29266 if v.AuxInt != 0 { 29267 break 29268 } 29269 l := v.Args[0] 29270 if l.Op != OpARMXORshiftRLreg { 29271 break 29272 } 29273 _ = l.Args[2] 29274 x := l.Args[0] 29275 y := l.Args[1] 29276 z := l.Args[2] 29277 if !(l.Uses == 1) { 29278 break 29279 } 29280 b.Kind = BlockARMNE 29281 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags) 29282 v0.AddArg(x) 29283 v0.AddArg(y) 29284 v0.AddArg(z) 29285 b.SetControl(v0) 29286 b.Aux = nil 29287 return true 29288 } 29289 // match: (NE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) 29290 // cond: l.Uses==1 29291 // result: (NE (TEQshiftRAreg x y z) yes no) 29292 for { 29293 v := b.Control 29294 if v.Op != OpARMCMPconst { 29295 break 29296 } 29297 if v.AuxInt != 0 { 29298 break 29299 } 29300 l := v.Args[0] 29301 if l.Op != OpARMXORshiftRAreg { 29302 break 29303 } 29304 _ = l.Args[2] 29305 x := l.Args[0] 29306 y := l.Args[1] 29307 z := l.Args[2] 29308 if !(l.Uses == 1) { 29309 break 29310 } 29311 b.Kind = BlockARMNE 29312 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags) 29313 v0.AddArg(x) 29314 v0.AddArg(y) 29315 v0.AddArg(z) 29316 b.SetControl(v0) 29317 b.Aux = nil 29318 return true 29319 } 29320 case BlockARMUGE: 29321 // match: (UGE (FlagEQ) yes no) 29322 // cond: 29323 // result: (First nil yes no) 29324 for { 29325 v := b.Control 29326 if v.Op != OpARMFlagEQ { 29327 break 29328 } 29329 b.Kind = BlockFirst 29330 b.SetControl(nil) 29331 b.Aux = nil 29332 return true 29333 } 29334 // match: (UGE (FlagLT_ULT) yes no) 29335 // cond: 29336 // result: (First nil no yes) 29337 for { 29338 v := b.Control 29339 if v.Op != OpARMFlagLT_ULT { 29340 break 29341 } 29342 b.Kind = BlockFirst 29343 b.SetControl(nil) 29344 b.Aux = nil 29345 b.swapSuccessors() 29346 return true 29347 } 29348 // match: (UGE (FlagLT_UGT) yes no) 29349 // cond: 29350 // result: (First nil yes no) 29351 for { 29352 v := b.Control 29353 if v.Op != OpARMFlagLT_UGT { 29354 break 29355 } 29356 b.Kind = BlockFirst 29357 b.SetControl(nil) 29358 b.Aux = nil 29359 return true 29360 } 29361 // match: (UGE (FlagGT_ULT) yes no) 29362 // cond: 29363 // result: (First nil no yes) 29364 for { 29365 v := b.Control 29366 if v.Op != OpARMFlagGT_ULT { 29367 break 29368 } 29369 b.Kind = BlockFirst 29370 b.SetControl(nil) 29371 b.Aux = nil 29372 b.swapSuccessors() 29373 return true 29374 } 29375 // match: (UGE (FlagGT_UGT) yes no) 29376 // cond: 29377 // result: (First nil yes no) 29378 for { 29379 v := b.Control 29380 if v.Op != OpARMFlagGT_UGT { 29381 break 29382 } 29383 b.Kind = BlockFirst 29384 b.SetControl(nil) 29385 b.Aux = nil 29386 return true 29387 } 29388 // match: (UGE (InvertFlags cmp) yes no) 29389 // cond: 29390 // result: (ULE cmp yes no) 29391 for { 29392 v := b.Control 29393 if v.Op != OpARMInvertFlags { 29394 break 29395 } 29396 cmp := v.Args[0] 29397 b.Kind = BlockARMULE 29398 b.SetControl(cmp) 29399 b.Aux = nil 29400 return true 29401 } 29402 case BlockARMUGT: 29403 // match: (UGT (FlagEQ) yes no) 29404 // cond: 29405 // result: (First nil no yes) 29406 for { 29407 v := b.Control 29408 if v.Op != OpARMFlagEQ { 29409 break 29410 } 29411 b.Kind = BlockFirst 29412 b.SetControl(nil) 29413 b.Aux = nil 29414 b.swapSuccessors() 29415 return true 29416 } 29417 // match: (UGT (FlagLT_ULT) yes no) 29418 // cond: 29419 // result: (First nil no yes) 29420 for { 29421 v := b.Control 29422 if v.Op != OpARMFlagLT_ULT { 29423 break 29424 } 29425 b.Kind = BlockFirst 29426 b.SetControl(nil) 29427 b.Aux = nil 29428 b.swapSuccessors() 29429 return true 29430 } 29431 // match: (UGT (FlagLT_UGT) yes no) 29432 // cond: 29433 // result: (First nil yes no) 29434 for { 29435 v := b.Control 29436 if v.Op != OpARMFlagLT_UGT { 29437 break 29438 } 29439 b.Kind = BlockFirst 29440 b.SetControl(nil) 29441 b.Aux = nil 29442 return true 29443 } 29444 // match: (UGT (FlagGT_ULT) yes no) 29445 // cond: 29446 // result: (First nil no yes) 29447 for { 29448 v := b.Control 29449 if v.Op != OpARMFlagGT_ULT { 29450 break 29451 } 29452 b.Kind = BlockFirst 29453 b.SetControl(nil) 29454 b.Aux = nil 29455 b.swapSuccessors() 29456 return true 29457 } 29458 // match: (UGT (FlagGT_UGT) yes no) 29459 // cond: 29460 // result: (First nil yes no) 29461 for { 29462 v := b.Control 29463 if v.Op != OpARMFlagGT_UGT { 29464 break 29465 } 29466 b.Kind = BlockFirst 29467 b.SetControl(nil) 29468 b.Aux = nil 29469 return true 29470 } 29471 // match: (UGT (InvertFlags cmp) yes no) 29472 // cond: 29473 // result: (ULT cmp yes no) 29474 for { 29475 v := b.Control 29476 if v.Op != OpARMInvertFlags { 29477 break 29478 } 29479 cmp := v.Args[0] 29480 b.Kind = BlockARMULT 29481 b.SetControl(cmp) 29482 b.Aux = nil 29483 return true 29484 } 29485 case BlockARMULE: 29486 // match: (ULE (FlagEQ) yes no) 29487 // cond: 29488 // result: (First nil yes no) 29489 for { 29490 v := b.Control 29491 if v.Op != OpARMFlagEQ { 29492 break 29493 } 29494 b.Kind = BlockFirst 29495 b.SetControl(nil) 29496 b.Aux = nil 29497 return true 29498 } 29499 // match: (ULE (FlagLT_ULT) yes no) 29500 // cond: 29501 // result: (First nil yes no) 29502 for { 29503 v := b.Control 29504 if v.Op != OpARMFlagLT_ULT { 29505 break 29506 } 29507 b.Kind = BlockFirst 29508 b.SetControl(nil) 29509 b.Aux = nil 29510 return true 29511 } 29512 // match: (ULE (FlagLT_UGT) yes no) 29513 // cond: 29514 // result: (First nil no yes) 29515 for { 29516 v := b.Control 29517 if v.Op != OpARMFlagLT_UGT { 29518 break 29519 } 29520 b.Kind = BlockFirst 29521 b.SetControl(nil) 29522 b.Aux = nil 29523 b.swapSuccessors() 29524 return true 29525 } 29526 // match: (ULE (FlagGT_ULT) yes no) 29527 // cond: 29528 // result: (First nil yes no) 29529 for { 29530 v := b.Control 29531 if v.Op != OpARMFlagGT_ULT { 29532 break 29533 } 29534 b.Kind = BlockFirst 29535 b.SetControl(nil) 29536 b.Aux = nil 29537 return true 29538 } 29539 // match: (ULE (FlagGT_UGT) yes no) 29540 // cond: 29541 // result: (First nil no yes) 29542 for { 29543 v := b.Control 29544 if v.Op != OpARMFlagGT_UGT { 29545 break 29546 } 29547 b.Kind = BlockFirst 29548 b.SetControl(nil) 29549 b.Aux = nil 29550 b.swapSuccessors() 29551 return true 29552 } 29553 // match: (ULE (InvertFlags cmp) yes no) 29554 // cond: 29555 // result: (UGE cmp yes no) 29556 for { 29557 v := b.Control 29558 if v.Op != OpARMInvertFlags { 29559 break 29560 } 29561 cmp := v.Args[0] 29562 b.Kind = BlockARMUGE 29563 b.SetControl(cmp) 29564 b.Aux = nil 29565 return true 29566 } 29567 case BlockARMULT: 29568 // match: (ULT (FlagEQ) yes no) 29569 // cond: 29570 // result: (First nil no yes) 29571 for { 29572 v := b.Control 29573 if v.Op != OpARMFlagEQ { 29574 break 29575 } 29576 b.Kind = BlockFirst 29577 b.SetControl(nil) 29578 b.Aux = nil 29579 b.swapSuccessors() 29580 return true 29581 } 29582 // match: (ULT (FlagLT_ULT) yes no) 29583 // cond: 29584 // result: (First nil yes no) 29585 for { 29586 v := b.Control 29587 if v.Op != OpARMFlagLT_ULT { 29588 break 29589 } 29590 b.Kind = BlockFirst 29591 b.SetControl(nil) 29592 b.Aux = nil 29593 return true 29594 } 29595 // match: (ULT (FlagLT_UGT) yes no) 29596 // cond: 29597 // result: (First nil no yes) 29598 for { 29599 v := b.Control 29600 if v.Op != OpARMFlagLT_UGT { 29601 break 29602 } 29603 b.Kind = BlockFirst 29604 b.SetControl(nil) 29605 b.Aux = nil 29606 b.swapSuccessors() 29607 return true 29608 } 29609 // match: (ULT (FlagGT_ULT) yes no) 29610 // cond: 29611 // result: (First nil yes no) 29612 for { 29613 v := b.Control 29614 if v.Op != OpARMFlagGT_ULT { 29615 break 29616 } 29617 b.Kind = BlockFirst 29618 b.SetControl(nil) 29619 b.Aux = nil 29620 return true 29621 } 29622 // match: (ULT (FlagGT_UGT) yes no) 29623 // cond: 29624 // result: (First nil no yes) 29625 for { 29626 v := b.Control 29627 if v.Op != OpARMFlagGT_UGT { 29628 break 29629 } 29630 b.Kind = BlockFirst 29631 b.SetControl(nil) 29632 b.Aux = nil 29633 b.swapSuccessors() 29634 return true 29635 } 29636 // match: (ULT (InvertFlags cmp) yes no) 29637 // cond: 29638 // result: (UGT cmp yes no) 29639 for { 29640 v := b.Control 29641 if v.Op != OpARMInvertFlags { 29642 break 29643 } 29644 cmp := v.Args[0] 29645 b.Kind = BlockARMUGT 29646 b.SetControl(cmp) 29647 b.Aux = nil 29648 return true 29649 } 29650 } 29651 return false 29652 }