Source file src/pkg/cmd/compile/internal/ssa/rewriteARM.go
1
2
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
13 var _ = math.MinInt8
14 var _ = obj.ANOP
15 var _ = objabi.GOROOT
16 var _ = types.TypeMem
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 OpCtz16:
487 return rewriteValueARM_OpCtz16_0(v)
488 case OpCtz16NonZero:
489 return rewriteValueARM_OpCtz16NonZero_0(v)
490 case OpCtz32:
491 return rewriteValueARM_OpCtz32_0(v)
492 case OpCtz32NonZero:
493 return rewriteValueARM_OpCtz32NonZero_0(v)
494 case OpCtz8:
495 return rewriteValueARM_OpCtz8_0(v)
496 case OpCtz8NonZero:
497 return rewriteValueARM_OpCtz8NonZero_0(v)
498 case OpCvt32Fto32:
499 return rewriteValueARM_OpCvt32Fto32_0(v)
500 case OpCvt32Fto32U:
501 return rewriteValueARM_OpCvt32Fto32U_0(v)
502 case OpCvt32Fto64F:
503 return rewriteValueARM_OpCvt32Fto64F_0(v)
504 case OpCvt32Uto32F:
505 return rewriteValueARM_OpCvt32Uto32F_0(v)
506 case OpCvt32Uto64F:
507 return rewriteValueARM_OpCvt32Uto64F_0(v)
508 case OpCvt32to32F:
509 return rewriteValueARM_OpCvt32to32F_0(v)
510 case OpCvt32to64F:
511 return rewriteValueARM_OpCvt32to64F_0(v)
512 case OpCvt64Fto32:
513 return rewriteValueARM_OpCvt64Fto32_0(v)
514 case OpCvt64Fto32F:
515 return rewriteValueARM_OpCvt64Fto32F_0(v)
516 case OpCvt64Fto32U:
517 return rewriteValueARM_OpCvt64Fto32U_0(v)
518 case OpDiv16:
519 return rewriteValueARM_OpDiv16_0(v)
520 case OpDiv16u:
521 return rewriteValueARM_OpDiv16u_0(v)
522 case OpDiv32:
523 return rewriteValueARM_OpDiv32_0(v)
524 case OpDiv32F:
525 return rewriteValueARM_OpDiv32F_0(v)
526 case OpDiv32u:
527 return rewriteValueARM_OpDiv32u_0(v)
528 case OpDiv64F:
529 return rewriteValueARM_OpDiv64F_0(v)
530 case OpDiv8:
531 return rewriteValueARM_OpDiv8_0(v)
532 case OpDiv8u:
533 return rewriteValueARM_OpDiv8u_0(v)
534 case OpEq16:
535 return rewriteValueARM_OpEq16_0(v)
536 case OpEq32:
537 return rewriteValueARM_OpEq32_0(v)
538 case OpEq32F:
539 return rewriteValueARM_OpEq32F_0(v)
540 case OpEq64F:
541 return rewriteValueARM_OpEq64F_0(v)
542 case OpEq8:
543 return rewriteValueARM_OpEq8_0(v)
544 case OpEqB:
545 return rewriteValueARM_OpEqB_0(v)
546 case OpEqPtr:
547 return rewriteValueARM_OpEqPtr_0(v)
548 case OpGeq16:
549 return rewriteValueARM_OpGeq16_0(v)
550 case OpGeq16U:
551 return rewriteValueARM_OpGeq16U_0(v)
552 case OpGeq32:
553 return rewriteValueARM_OpGeq32_0(v)
554 case OpGeq32F:
555 return rewriteValueARM_OpGeq32F_0(v)
556 case OpGeq32U:
557 return rewriteValueARM_OpGeq32U_0(v)
558 case OpGeq64F:
559 return rewriteValueARM_OpGeq64F_0(v)
560 case OpGeq8:
561 return rewriteValueARM_OpGeq8_0(v)
562 case OpGeq8U:
563 return rewriteValueARM_OpGeq8U_0(v)
564 case OpGetCallerPC:
565 return rewriteValueARM_OpGetCallerPC_0(v)
566 case OpGetCallerSP:
567 return rewriteValueARM_OpGetCallerSP_0(v)
568 case OpGetClosurePtr:
569 return rewriteValueARM_OpGetClosurePtr_0(v)
570 case OpGreater16:
571 return rewriteValueARM_OpGreater16_0(v)
572 case OpGreater16U:
573 return rewriteValueARM_OpGreater16U_0(v)
574 case OpGreater32:
575 return rewriteValueARM_OpGreater32_0(v)
576 case OpGreater32F:
577 return rewriteValueARM_OpGreater32F_0(v)
578 case OpGreater32U:
579 return rewriteValueARM_OpGreater32U_0(v)
580 case OpGreater64F:
581 return rewriteValueARM_OpGreater64F_0(v)
582 case OpGreater8:
583 return rewriteValueARM_OpGreater8_0(v)
584 case OpGreater8U:
585 return rewriteValueARM_OpGreater8U_0(v)
586 case OpHmul32:
587 return rewriteValueARM_OpHmul32_0(v)
588 case OpHmul32u:
589 return rewriteValueARM_OpHmul32u_0(v)
590 case OpInterCall:
591 return rewriteValueARM_OpInterCall_0(v)
592 case OpIsInBounds:
593 return rewriteValueARM_OpIsInBounds_0(v)
594 case OpIsNonNil:
595 return rewriteValueARM_OpIsNonNil_0(v)
596 case OpIsSliceInBounds:
597 return rewriteValueARM_OpIsSliceInBounds_0(v)
598 case OpLeq16:
599 return rewriteValueARM_OpLeq16_0(v)
600 case OpLeq16U:
601 return rewriteValueARM_OpLeq16U_0(v)
602 case OpLeq32:
603 return rewriteValueARM_OpLeq32_0(v)
604 case OpLeq32F:
605 return rewriteValueARM_OpLeq32F_0(v)
606 case OpLeq32U:
607 return rewriteValueARM_OpLeq32U_0(v)
608 case OpLeq64F:
609 return rewriteValueARM_OpLeq64F_0(v)
610 case OpLeq8:
611 return rewriteValueARM_OpLeq8_0(v)
612 case OpLeq8U:
613 return rewriteValueARM_OpLeq8U_0(v)
614 case OpLess16:
615 return rewriteValueARM_OpLess16_0(v)
616 case OpLess16U:
617 return rewriteValueARM_OpLess16U_0(v)
618 case OpLess32:
619 return rewriteValueARM_OpLess32_0(v)
620 case OpLess32F:
621 return rewriteValueARM_OpLess32F_0(v)
622 case OpLess32U:
623 return rewriteValueARM_OpLess32U_0(v)
624 case OpLess64F:
625 return rewriteValueARM_OpLess64F_0(v)
626 case OpLess8:
627 return rewriteValueARM_OpLess8_0(v)
628 case OpLess8U:
629 return rewriteValueARM_OpLess8U_0(v)
630 case OpLoad:
631 return rewriteValueARM_OpLoad_0(v)
632 case OpLocalAddr:
633 return rewriteValueARM_OpLocalAddr_0(v)
634 case OpLsh16x16:
635 return rewriteValueARM_OpLsh16x16_0(v)
636 case OpLsh16x32:
637 return rewriteValueARM_OpLsh16x32_0(v)
638 case OpLsh16x64:
639 return rewriteValueARM_OpLsh16x64_0(v)
640 case OpLsh16x8:
641 return rewriteValueARM_OpLsh16x8_0(v)
642 case OpLsh32x16:
643 return rewriteValueARM_OpLsh32x16_0(v)
644 case OpLsh32x32:
645 return rewriteValueARM_OpLsh32x32_0(v)
646 case OpLsh32x64:
647 return rewriteValueARM_OpLsh32x64_0(v)
648 case OpLsh32x8:
649 return rewriteValueARM_OpLsh32x8_0(v)
650 case OpLsh8x16:
651 return rewriteValueARM_OpLsh8x16_0(v)
652 case OpLsh8x32:
653 return rewriteValueARM_OpLsh8x32_0(v)
654 case OpLsh8x64:
655 return rewriteValueARM_OpLsh8x64_0(v)
656 case OpLsh8x8:
657 return rewriteValueARM_OpLsh8x8_0(v)
658 case OpMod16:
659 return rewriteValueARM_OpMod16_0(v)
660 case OpMod16u:
661 return rewriteValueARM_OpMod16u_0(v)
662 case OpMod32:
663 return rewriteValueARM_OpMod32_0(v)
664 case OpMod32u:
665 return rewriteValueARM_OpMod32u_0(v)
666 case OpMod8:
667 return rewriteValueARM_OpMod8_0(v)
668 case OpMod8u:
669 return rewriteValueARM_OpMod8u_0(v)
670 case OpMove:
671 return rewriteValueARM_OpMove_0(v)
672 case OpMul16:
673 return rewriteValueARM_OpMul16_0(v)
674 case OpMul32:
675 return rewriteValueARM_OpMul32_0(v)
676 case OpMul32F:
677 return rewriteValueARM_OpMul32F_0(v)
678 case OpMul32uhilo:
679 return rewriteValueARM_OpMul32uhilo_0(v)
680 case OpMul64F:
681 return rewriteValueARM_OpMul64F_0(v)
682 case OpMul8:
683 return rewriteValueARM_OpMul8_0(v)
684 case OpNeg16:
685 return rewriteValueARM_OpNeg16_0(v)
686 case OpNeg32:
687 return rewriteValueARM_OpNeg32_0(v)
688 case OpNeg32F:
689 return rewriteValueARM_OpNeg32F_0(v)
690 case OpNeg64F:
691 return rewriteValueARM_OpNeg64F_0(v)
692 case OpNeg8:
693 return rewriteValueARM_OpNeg8_0(v)
694 case OpNeq16:
695 return rewriteValueARM_OpNeq16_0(v)
696 case OpNeq32:
697 return rewriteValueARM_OpNeq32_0(v)
698 case OpNeq32F:
699 return rewriteValueARM_OpNeq32F_0(v)
700 case OpNeq64F:
701 return rewriteValueARM_OpNeq64F_0(v)
702 case OpNeq8:
703 return rewriteValueARM_OpNeq8_0(v)
704 case OpNeqB:
705 return rewriteValueARM_OpNeqB_0(v)
706 case OpNeqPtr:
707 return rewriteValueARM_OpNeqPtr_0(v)
708 case OpNilCheck:
709 return rewriteValueARM_OpNilCheck_0(v)
710 case OpNot:
711 return rewriteValueARM_OpNot_0(v)
712 case OpOffPtr:
713 return rewriteValueARM_OpOffPtr_0(v)
714 case OpOr16:
715 return rewriteValueARM_OpOr16_0(v)
716 case OpOr32:
717 return rewriteValueARM_OpOr32_0(v)
718 case OpOr8:
719 return rewriteValueARM_OpOr8_0(v)
720 case OpOrB:
721 return rewriteValueARM_OpOrB_0(v)
722 case OpPanicBounds:
723 return rewriteValueARM_OpPanicBounds_0(v)
724 case OpPanicExtend:
725 return rewriteValueARM_OpPanicExtend_0(v)
726 case OpRotateLeft16:
727 return rewriteValueARM_OpRotateLeft16_0(v)
728 case OpRotateLeft32:
729 return rewriteValueARM_OpRotateLeft32_0(v)
730 case OpRotateLeft8:
731 return rewriteValueARM_OpRotateLeft8_0(v)
732 case OpRound32F:
733 return rewriteValueARM_OpRound32F_0(v)
734 case OpRound64F:
735 return rewriteValueARM_OpRound64F_0(v)
736 case OpRsh16Ux16:
737 return rewriteValueARM_OpRsh16Ux16_0(v)
738 case OpRsh16Ux32:
739 return rewriteValueARM_OpRsh16Ux32_0(v)
740 case OpRsh16Ux64:
741 return rewriteValueARM_OpRsh16Ux64_0(v)
742 case OpRsh16Ux8:
743 return rewriteValueARM_OpRsh16Ux8_0(v)
744 case OpRsh16x16:
745 return rewriteValueARM_OpRsh16x16_0(v)
746 case OpRsh16x32:
747 return rewriteValueARM_OpRsh16x32_0(v)
748 case OpRsh16x64:
749 return rewriteValueARM_OpRsh16x64_0(v)
750 case OpRsh16x8:
751 return rewriteValueARM_OpRsh16x8_0(v)
752 case OpRsh32Ux16:
753 return rewriteValueARM_OpRsh32Ux16_0(v)
754 case OpRsh32Ux32:
755 return rewriteValueARM_OpRsh32Ux32_0(v)
756 case OpRsh32Ux64:
757 return rewriteValueARM_OpRsh32Ux64_0(v)
758 case OpRsh32Ux8:
759 return rewriteValueARM_OpRsh32Ux8_0(v)
760 case OpRsh32x16:
761 return rewriteValueARM_OpRsh32x16_0(v)
762 case OpRsh32x32:
763 return rewriteValueARM_OpRsh32x32_0(v)
764 case OpRsh32x64:
765 return rewriteValueARM_OpRsh32x64_0(v)
766 case OpRsh32x8:
767 return rewriteValueARM_OpRsh32x8_0(v)
768 case OpRsh8Ux16:
769 return rewriteValueARM_OpRsh8Ux16_0(v)
770 case OpRsh8Ux32:
771 return rewriteValueARM_OpRsh8Ux32_0(v)
772 case OpRsh8Ux64:
773 return rewriteValueARM_OpRsh8Ux64_0(v)
774 case OpRsh8Ux8:
775 return rewriteValueARM_OpRsh8Ux8_0(v)
776 case OpRsh8x16:
777 return rewriteValueARM_OpRsh8x16_0(v)
778 case OpRsh8x32:
779 return rewriteValueARM_OpRsh8x32_0(v)
780 case OpRsh8x64:
781 return rewriteValueARM_OpRsh8x64_0(v)
782 case OpRsh8x8:
783 return rewriteValueARM_OpRsh8x8_0(v)
784 case OpSelect0:
785 return rewriteValueARM_OpSelect0_0(v)
786 case OpSelect1:
787 return rewriteValueARM_OpSelect1_0(v)
788 case OpSignExt16to32:
789 return rewriteValueARM_OpSignExt16to32_0(v)
790 case OpSignExt8to16:
791 return rewriteValueARM_OpSignExt8to16_0(v)
792 case OpSignExt8to32:
793 return rewriteValueARM_OpSignExt8to32_0(v)
794 case OpSignmask:
795 return rewriteValueARM_OpSignmask_0(v)
796 case OpSlicemask:
797 return rewriteValueARM_OpSlicemask_0(v)
798 case OpSqrt:
799 return rewriteValueARM_OpSqrt_0(v)
800 case OpStaticCall:
801 return rewriteValueARM_OpStaticCall_0(v)
802 case OpStore:
803 return rewriteValueARM_OpStore_0(v)
804 case OpSub16:
805 return rewriteValueARM_OpSub16_0(v)
806 case OpSub32:
807 return rewriteValueARM_OpSub32_0(v)
808 case OpSub32F:
809 return rewriteValueARM_OpSub32F_0(v)
810 case OpSub32carry:
811 return rewriteValueARM_OpSub32carry_0(v)
812 case OpSub32withcarry:
813 return rewriteValueARM_OpSub32withcarry_0(v)
814 case OpSub64F:
815 return rewriteValueARM_OpSub64F_0(v)
816 case OpSub8:
817 return rewriteValueARM_OpSub8_0(v)
818 case OpSubPtr:
819 return rewriteValueARM_OpSubPtr_0(v)
820 case OpTrunc16to8:
821 return rewriteValueARM_OpTrunc16to8_0(v)
822 case OpTrunc32to16:
823 return rewriteValueARM_OpTrunc32to16_0(v)
824 case OpTrunc32to8:
825 return rewriteValueARM_OpTrunc32to8_0(v)
826 case OpWB:
827 return rewriteValueARM_OpWB_0(v)
828 case OpXor16:
829 return rewriteValueARM_OpXor16_0(v)
830 case OpXor32:
831 return rewriteValueARM_OpXor32_0(v)
832 case OpXor8:
833 return rewriteValueARM_OpXor8_0(v)
834 case OpZero:
835 return rewriteValueARM_OpZero_0(v)
836 case OpZeroExt16to32:
837 return rewriteValueARM_OpZeroExt16to32_0(v)
838 case OpZeroExt8to16:
839 return rewriteValueARM_OpZeroExt8to16_0(v)
840 case OpZeroExt8to32:
841 return rewriteValueARM_OpZeroExt8to32_0(v)
842 case OpZeromask:
843 return rewriteValueARM_OpZeromask_0(v)
844 }
845 return false
846 }
847 func rewriteValueARM_OpARMADC_0(v *Value) bool {
848
849
850
851 for {
852 flags := v.Args[2]
853 v_0 := v.Args[0]
854 if v_0.Op != OpARMMOVWconst {
855 break
856 }
857 c := v_0.AuxInt
858 x := v.Args[1]
859 v.reset(OpARMADCconst)
860 v.AuxInt = c
861 v.AddArg(x)
862 v.AddArg(flags)
863 return true
864 }
865
866
867
868 for {
869 flags := v.Args[2]
870 x := v.Args[0]
871 v_1 := v.Args[1]
872 if v_1.Op != OpARMMOVWconst {
873 break
874 }
875 c := v_1.AuxInt
876 v.reset(OpARMADCconst)
877 v.AuxInt = c
878 v.AddArg(x)
879 v.AddArg(flags)
880 return true
881 }
882
883
884
885 for {
886 flags := v.Args[2]
887 x := v.Args[0]
888 v_1 := v.Args[1]
889 if v_1.Op != OpARMMOVWconst {
890 break
891 }
892 c := v_1.AuxInt
893 v.reset(OpARMADCconst)
894 v.AuxInt = c
895 v.AddArg(x)
896 v.AddArg(flags)
897 return true
898 }
899
900
901
902 for {
903 flags := v.Args[2]
904 v_0 := v.Args[0]
905 if v_0.Op != OpARMMOVWconst {
906 break
907 }
908 c := v_0.AuxInt
909 x := v.Args[1]
910 v.reset(OpARMADCconst)
911 v.AuxInt = c
912 v.AddArg(x)
913 v.AddArg(flags)
914 return true
915 }
916
917
918
919 for {
920 flags := v.Args[2]
921 x := v.Args[0]
922 v_1 := v.Args[1]
923 if v_1.Op != OpARMSLLconst {
924 break
925 }
926 c := v_1.AuxInt
927 y := v_1.Args[0]
928 v.reset(OpARMADCshiftLL)
929 v.AuxInt = c
930 v.AddArg(x)
931 v.AddArg(y)
932 v.AddArg(flags)
933 return true
934 }
935
936
937
938 for {
939 flags := v.Args[2]
940 v_0 := v.Args[0]
941 if v_0.Op != OpARMSLLconst {
942 break
943 }
944 c := v_0.AuxInt
945 y := v_0.Args[0]
946 x := v.Args[1]
947 v.reset(OpARMADCshiftLL)
948 v.AuxInt = c
949 v.AddArg(x)
950 v.AddArg(y)
951 v.AddArg(flags)
952 return true
953 }
954
955
956
957 for {
958 flags := v.Args[2]
959 v_0 := v.Args[0]
960 if v_0.Op != OpARMSLLconst {
961 break
962 }
963 c := v_0.AuxInt
964 y := v_0.Args[0]
965 x := v.Args[1]
966 v.reset(OpARMADCshiftLL)
967 v.AuxInt = c
968 v.AddArg(x)
969 v.AddArg(y)
970 v.AddArg(flags)
971 return true
972 }
973
974
975
976 for {
977 flags := v.Args[2]
978 x := v.Args[0]
979 v_1 := v.Args[1]
980 if v_1.Op != OpARMSLLconst {
981 break
982 }
983 c := v_1.AuxInt
984 y := v_1.Args[0]
985 v.reset(OpARMADCshiftLL)
986 v.AuxInt = c
987 v.AddArg(x)
988 v.AddArg(y)
989 v.AddArg(flags)
990 return true
991 }
992
993
994
995 for {
996 flags := v.Args[2]
997 x := v.Args[0]
998 v_1 := v.Args[1]
999 if v_1.Op != OpARMSRLconst {
1000 break
1001 }
1002 c := v_1.AuxInt
1003 y := v_1.Args[0]
1004 v.reset(OpARMADCshiftRL)
1005 v.AuxInt = c
1006 v.AddArg(x)
1007 v.AddArg(y)
1008 v.AddArg(flags)
1009 return true
1010 }
1011
1012
1013
1014 for {
1015 flags := v.Args[2]
1016 v_0 := v.Args[0]
1017 if v_0.Op != OpARMSRLconst {
1018 break
1019 }
1020 c := v_0.AuxInt
1021 y := v_0.Args[0]
1022 x := v.Args[1]
1023 v.reset(OpARMADCshiftRL)
1024 v.AuxInt = c
1025 v.AddArg(x)
1026 v.AddArg(y)
1027 v.AddArg(flags)
1028 return true
1029 }
1030 return false
1031 }
1032 func rewriteValueARM_OpARMADC_10(v *Value) bool {
1033
1034
1035
1036 for {
1037 flags := v.Args[2]
1038 v_0 := v.Args[0]
1039 if v_0.Op != OpARMSRLconst {
1040 break
1041 }
1042 c := v_0.AuxInt
1043 y := v_0.Args[0]
1044 x := v.Args[1]
1045 v.reset(OpARMADCshiftRL)
1046 v.AuxInt = c
1047 v.AddArg(x)
1048 v.AddArg(y)
1049 v.AddArg(flags)
1050 return true
1051 }
1052
1053
1054
1055 for {
1056 flags := v.Args[2]
1057 x := v.Args[0]
1058 v_1 := v.Args[1]
1059 if v_1.Op != OpARMSRLconst {
1060 break
1061 }
1062 c := v_1.AuxInt
1063 y := v_1.Args[0]
1064 v.reset(OpARMADCshiftRL)
1065 v.AuxInt = c
1066 v.AddArg(x)
1067 v.AddArg(y)
1068 v.AddArg(flags)
1069 return true
1070 }
1071
1072
1073
1074 for {
1075 flags := v.Args[2]
1076 x := v.Args[0]
1077 v_1 := v.Args[1]
1078 if v_1.Op != OpARMSRAconst {
1079 break
1080 }
1081 c := v_1.AuxInt
1082 y := v_1.Args[0]
1083 v.reset(OpARMADCshiftRA)
1084 v.AuxInt = c
1085 v.AddArg(x)
1086 v.AddArg(y)
1087 v.AddArg(flags)
1088 return true
1089 }
1090
1091
1092
1093 for {
1094 flags := v.Args[2]
1095 v_0 := v.Args[0]
1096 if v_0.Op != OpARMSRAconst {
1097 break
1098 }
1099 c := v_0.AuxInt
1100 y := v_0.Args[0]
1101 x := v.Args[1]
1102 v.reset(OpARMADCshiftRA)
1103 v.AuxInt = c
1104 v.AddArg(x)
1105 v.AddArg(y)
1106 v.AddArg(flags)
1107 return true
1108 }
1109
1110
1111
1112 for {
1113 flags := v.Args[2]
1114 v_0 := v.Args[0]
1115 if v_0.Op != OpARMSRAconst {
1116 break
1117 }
1118 c := v_0.AuxInt
1119 y := v_0.Args[0]
1120 x := v.Args[1]
1121 v.reset(OpARMADCshiftRA)
1122 v.AuxInt = c
1123 v.AddArg(x)
1124 v.AddArg(y)
1125 v.AddArg(flags)
1126 return true
1127 }
1128
1129
1130
1131 for {
1132 flags := v.Args[2]
1133 x := v.Args[0]
1134 v_1 := v.Args[1]
1135 if v_1.Op != OpARMSRAconst {
1136 break
1137 }
1138 c := v_1.AuxInt
1139 y := v_1.Args[0]
1140 v.reset(OpARMADCshiftRA)
1141 v.AuxInt = c
1142 v.AddArg(x)
1143 v.AddArg(y)
1144 v.AddArg(flags)
1145 return true
1146 }
1147
1148
1149
1150 for {
1151 flags := v.Args[2]
1152 x := v.Args[0]
1153 v_1 := v.Args[1]
1154 if v_1.Op != OpARMSLL {
1155 break
1156 }
1157 z := v_1.Args[1]
1158 y := v_1.Args[0]
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
1167
1168
1169 for {
1170 flags := v.Args[2]
1171 v_0 := v.Args[0]
1172 if v_0.Op != OpARMSLL {
1173 break
1174 }
1175 z := v_0.Args[1]
1176 y := v_0.Args[0]
1177 x := v.Args[1]
1178 v.reset(OpARMADCshiftLLreg)
1179 v.AddArg(x)
1180 v.AddArg(y)
1181 v.AddArg(z)
1182 v.AddArg(flags)
1183 return true
1184 }
1185
1186
1187
1188 for {
1189 flags := v.Args[2]
1190 v_0 := v.Args[0]
1191 if v_0.Op != OpARMSLL {
1192 break
1193 }
1194 z := v_0.Args[1]
1195 y := v_0.Args[0]
1196 x := v.Args[1]
1197 v.reset(OpARMADCshiftLLreg)
1198 v.AddArg(x)
1199 v.AddArg(y)
1200 v.AddArg(z)
1201 v.AddArg(flags)
1202 return true
1203 }
1204
1205
1206
1207 for {
1208 flags := v.Args[2]
1209 x := v.Args[0]
1210 v_1 := v.Args[1]
1211 if v_1.Op != OpARMSLL {
1212 break
1213 }
1214 z := v_1.Args[1]
1215 y := v_1.Args[0]
1216 v.reset(OpARMADCshiftLLreg)
1217 v.AddArg(x)
1218 v.AddArg(y)
1219 v.AddArg(z)
1220 v.AddArg(flags)
1221 return true
1222 }
1223 return false
1224 }
1225 func rewriteValueARM_OpARMADC_20(v *Value) bool {
1226
1227
1228
1229 for {
1230 flags := v.Args[2]
1231 x := v.Args[0]
1232 v_1 := v.Args[1]
1233 if v_1.Op != OpARMSRL {
1234 break
1235 }
1236 z := v_1.Args[1]
1237 y := v_1.Args[0]
1238 v.reset(OpARMADCshiftRLreg)
1239 v.AddArg(x)
1240 v.AddArg(y)
1241 v.AddArg(z)
1242 v.AddArg(flags)
1243 return true
1244 }
1245
1246
1247
1248 for {
1249 flags := v.Args[2]
1250 v_0 := v.Args[0]
1251 if v_0.Op != OpARMSRL {
1252 break
1253 }
1254 z := v_0.Args[1]
1255 y := v_0.Args[0]
1256 x := v.Args[1]
1257 v.reset(OpARMADCshiftRLreg)
1258 v.AddArg(x)
1259 v.AddArg(y)
1260 v.AddArg(z)
1261 v.AddArg(flags)
1262 return true
1263 }
1264
1265
1266
1267 for {
1268 flags := v.Args[2]
1269 v_0 := v.Args[0]
1270 if v_0.Op != OpARMSRL {
1271 break
1272 }
1273 z := v_0.Args[1]
1274 y := v_0.Args[0]
1275 x := v.Args[1]
1276 v.reset(OpARMADCshiftRLreg)
1277 v.AddArg(x)
1278 v.AddArg(y)
1279 v.AddArg(z)
1280 v.AddArg(flags)
1281 return true
1282 }
1283
1284
1285
1286 for {
1287 flags := v.Args[2]
1288 x := v.Args[0]
1289 v_1 := v.Args[1]
1290 if v_1.Op != OpARMSRL {
1291 break
1292 }
1293 z := v_1.Args[1]
1294 y := v_1.Args[0]
1295 v.reset(OpARMADCshiftRLreg)
1296 v.AddArg(x)
1297 v.AddArg(y)
1298 v.AddArg(z)
1299 v.AddArg(flags)
1300 return true
1301 }
1302
1303
1304
1305 for {
1306 flags := v.Args[2]
1307 x := v.Args[0]
1308 v_1 := v.Args[1]
1309 if v_1.Op != OpARMSRA {
1310 break
1311 }
1312 z := v_1.Args[1]
1313 y := v_1.Args[0]
1314 v.reset(OpARMADCshiftRAreg)
1315 v.AddArg(x)
1316 v.AddArg(y)
1317 v.AddArg(z)
1318 v.AddArg(flags)
1319 return true
1320 }
1321
1322
1323
1324 for {
1325 flags := v.Args[2]
1326 v_0 := v.Args[0]
1327 if v_0.Op != OpARMSRA {
1328 break
1329 }
1330 z := v_0.Args[1]
1331 y := v_0.Args[0]
1332 x := v.Args[1]
1333 v.reset(OpARMADCshiftRAreg)
1334 v.AddArg(x)
1335 v.AddArg(y)
1336 v.AddArg(z)
1337 v.AddArg(flags)
1338 return true
1339 }
1340
1341
1342
1343 for {
1344 flags := v.Args[2]
1345 v_0 := v.Args[0]
1346 if v_0.Op != OpARMSRA {
1347 break
1348 }
1349 z := v_0.Args[1]
1350 y := v_0.Args[0]
1351 x := v.Args[1]
1352 v.reset(OpARMADCshiftRAreg)
1353 v.AddArg(x)
1354 v.AddArg(y)
1355 v.AddArg(z)
1356 v.AddArg(flags)
1357 return true
1358 }
1359
1360
1361
1362 for {
1363 flags := v.Args[2]
1364 x := v.Args[0]
1365 v_1 := v.Args[1]
1366 if v_1.Op != OpARMSRA {
1367 break
1368 }
1369 z := v_1.Args[1]
1370 y := v_1.Args[0]
1371 v.reset(OpARMADCshiftRAreg)
1372 v.AddArg(x)
1373 v.AddArg(y)
1374 v.AddArg(z)
1375 v.AddArg(flags)
1376 return true
1377 }
1378 return false
1379 }
1380 func rewriteValueARM_OpARMADCconst_0(v *Value) bool {
1381
1382
1383
1384 for {
1385 c := v.AuxInt
1386 flags := v.Args[1]
1387 v_0 := v.Args[0]
1388 if v_0.Op != OpARMADDconst {
1389 break
1390 }
1391 d := v_0.AuxInt
1392 x := v_0.Args[0]
1393 v.reset(OpARMADCconst)
1394 v.AuxInt = int64(int32(c + d))
1395 v.AddArg(x)
1396 v.AddArg(flags)
1397 return true
1398 }
1399
1400
1401
1402 for {
1403 c := v.AuxInt
1404 flags := v.Args[1]
1405 v_0 := v.Args[0]
1406 if v_0.Op != OpARMSUBconst {
1407 break
1408 }
1409 d := v_0.AuxInt
1410 x := v_0.Args[0]
1411 v.reset(OpARMADCconst)
1412 v.AuxInt = int64(int32(c - d))
1413 v.AddArg(x)
1414 v.AddArg(flags)
1415 return true
1416 }
1417 return false
1418 }
1419 func rewriteValueARM_OpARMADCshiftLL_0(v *Value) bool {
1420 b := v.Block
1421
1422
1423
1424 for {
1425 d := v.AuxInt
1426 flags := v.Args[2]
1427 v_0 := v.Args[0]
1428 if v_0.Op != OpARMMOVWconst {
1429 break
1430 }
1431 c := v_0.AuxInt
1432 x := v.Args[1]
1433 v.reset(OpARMADCconst)
1434 v.AuxInt = c
1435 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
1436 v0.AuxInt = d
1437 v0.AddArg(x)
1438 v.AddArg(v0)
1439 v.AddArg(flags)
1440 return true
1441 }
1442
1443
1444
1445 for {
1446 d := v.AuxInt
1447 flags := v.Args[2]
1448 x := v.Args[0]
1449 v_1 := v.Args[1]
1450 if v_1.Op != OpARMMOVWconst {
1451 break
1452 }
1453 c := v_1.AuxInt
1454 v.reset(OpARMADCconst)
1455 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
1456 v.AddArg(x)
1457 v.AddArg(flags)
1458 return true
1459 }
1460 return false
1461 }
1462 func rewriteValueARM_OpARMADCshiftLLreg_0(v *Value) bool {
1463 b := v.Block
1464
1465
1466
1467 for {
1468 flags := v.Args[3]
1469 v_0 := v.Args[0]
1470 if v_0.Op != OpARMMOVWconst {
1471 break
1472 }
1473 c := v_0.AuxInt
1474 x := v.Args[1]
1475 y := v.Args[2]
1476 v.reset(OpARMADCconst)
1477 v.AuxInt = c
1478 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
1479 v0.AddArg(x)
1480 v0.AddArg(y)
1481 v.AddArg(v0)
1482 v.AddArg(flags)
1483 return true
1484 }
1485
1486
1487
1488 for {
1489 flags := v.Args[3]
1490 x := v.Args[0]
1491 y := v.Args[1]
1492 v_2 := v.Args[2]
1493 if v_2.Op != OpARMMOVWconst {
1494 break
1495 }
1496 c := v_2.AuxInt
1497 v.reset(OpARMADCshiftLL)
1498 v.AuxInt = c
1499 v.AddArg(x)
1500 v.AddArg(y)
1501 v.AddArg(flags)
1502 return true
1503 }
1504 return false
1505 }
1506 func rewriteValueARM_OpARMADCshiftRA_0(v *Value) bool {
1507 b := v.Block
1508
1509
1510
1511 for {
1512 d := v.AuxInt
1513 flags := v.Args[2]
1514 v_0 := v.Args[0]
1515 if v_0.Op != OpARMMOVWconst {
1516 break
1517 }
1518 c := v_0.AuxInt
1519 x := v.Args[1]
1520 v.reset(OpARMADCconst)
1521 v.AuxInt = c
1522 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
1523 v0.AuxInt = d
1524 v0.AddArg(x)
1525 v.AddArg(v0)
1526 v.AddArg(flags)
1527 return true
1528 }
1529
1530
1531
1532 for {
1533 d := v.AuxInt
1534 flags := v.Args[2]
1535 x := v.Args[0]
1536 v_1 := v.Args[1]
1537 if v_1.Op != OpARMMOVWconst {
1538 break
1539 }
1540 c := v_1.AuxInt
1541 v.reset(OpARMADCconst)
1542 v.AuxInt = int64(int32(c) >> uint64(d))
1543 v.AddArg(x)
1544 v.AddArg(flags)
1545 return true
1546 }
1547 return false
1548 }
1549 func rewriteValueARM_OpARMADCshiftRAreg_0(v *Value) bool {
1550 b := v.Block
1551
1552
1553
1554 for {
1555 flags := v.Args[3]
1556 v_0 := v.Args[0]
1557 if v_0.Op != OpARMMOVWconst {
1558 break
1559 }
1560 c := v_0.AuxInt
1561 x := v.Args[1]
1562 y := v.Args[2]
1563 v.reset(OpARMADCconst)
1564 v.AuxInt = c
1565 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
1566 v0.AddArg(x)
1567 v0.AddArg(y)
1568 v.AddArg(v0)
1569 v.AddArg(flags)
1570 return true
1571 }
1572
1573
1574
1575 for {
1576 flags := v.Args[3]
1577 x := v.Args[0]
1578 y := v.Args[1]
1579 v_2 := v.Args[2]
1580 if v_2.Op != OpARMMOVWconst {
1581 break
1582 }
1583 c := v_2.AuxInt
1584 v.reset(OpARMADCshiftRA)
1585 v.AuxInt = c
1586 v.AddArg(x)
1587 v.AddArg(y)
1588 v.AddArg(flags)
1589 return true
1590 }
1591 return false
1592 }
1593 func rewriteValueARM_OpARMADCshiftRL_0(v *Value) bool {
1594 b := v.Block
1595
1596
1597
1598 for {
1599 d := v.AuxInt
1600 flags := v.Args[2]
1601 v_0 := v.Args[0]
1602 if v_0.Op != OpARMMOVWconst {
1603 break
1604 }
1605 c := v_0.AuxInt
1606 x := v.Args[1]
1607 v.reset(OpARMADCconst)
1608 v.AuxInt = c
1609 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
1610 v0.AuxInt = d
1611 v0.AddArg(x)
1612 v.AddArg(v0)
1613 v.AddArg(flags)
1614 return true
1615 }
1616
1617
1618
1619 for {
1620 d := v.AuxInt
1621 flags := v.Args[2]
1622 x := v.Args[0]
1623 v_1 := v.Args[1]
1624 if v_1.Op != OpARMMOVWconst {
1625 break
1626 }
1627 c := v_1.AuxInt
1628 v.reset(OpARMADCconst)
1629 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
1630 v.AddArg(x)
1631 v.AddArg(flags)
1632 return true
1633 }
1634 return false
1635 }
1636 func rewriteValueARM_OpARMADCshiftRLreg_0(v *Value) bool {
1637 b := v.Block
1638
1639
1640
1641 for {
1642 flags := v.Args[3]
1643 v_0 := v.Args[0]
1644 if v_0.Op != OpARMMOVWconst {
1645 break
1646 }
1647 c := v_0.AuxInt
1648 x := v.Args[1]
1649 y := v.Args[2]
1650 v.reset(OpARMADCconst)
1651 v.AuxInt = c
1652 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
1653 v0.AddArg(x)
1654 v0.AddArg(y)
1655 v.AddArg(v0)
1656 v.AddArg(flags)
1657 return true
1658 }
1659
1660
1661
1662 for {
1663 flags := v.Args[3]
1664 x := v.Args[0]
1665 y := v.Args[1]
1666 v_2 := v.Args[2]
1667 if v_2.Op != OpARMMOVWconst {
1668 break
1669 }
1670 c := v_2.AuxInt
1671 v.reset(OpARMADCshiftRL)
1672 v.AuxInt = c
1673 v.AddArg(x)
1674 v.AddArg(y)
1675 v.AddArg(flags)
1676 return true
1677 }
1678 return false
1679 }
1680 func rewriteValueARM_OpARMADD_0(v *Value) bool {
1681
1682
1683
1684 for {
1685 _ = v.Args[1]
1686 x := v.Args[0]
1687 v_1 := v.Args[1]
1688 if v_1.Op != OpARMMOVWconst {
1689 break
1690 }
1691 c := v_1.AuxInt
1692 v.reset(OpARMADDconst)
1693 v.AuxInt = c
1694 v.AddArg(x)
1695 return true
1696 }
1697
1698
1699
1700 for {
1701 x := v.Args[1]
1702 v_0 := v.Args[0]
1703 if v_0.Op != OpARMMOVWconst {
1704 break
1705 }
1706 c := v_0.AuxInt
1707 v.reset(OpARMADDconst)
1708 v.AuxInt = c
1709 v.AddArg(x)
1710 return true
1711 }
1712
1713
1714
1715 for {
1716 _ = v.Args[1]
1717 x := v.Args[0]
1718 v_1 := v.Args[1]
1719 if v_1.Op != OpARMSLLconst {
1720 break
1721 }
1722 c := v_1.AuxInt
1723 y := v_1.Args[0]
1724 v.reset(OpARMADDshiftLL)
1725 v.AuxInt = c
1726 v.AddArg(x)
1727 v.AddArg(y)
1728 return true
1729 }
1730
1731
1732
1733 for {
1734 x := v.Args[1]
1735 v_0 := v.Args[0]
1736 if v_0.Op != OpARMSLLconst {
1737 break
1738 }
1739 c := v_0.AuxInt
1740 y := v_0.Args[0]
1741 v.reset(OpARMADDshiftLL)
1742 v.AuxInt = c
1743 v.AddArg(x)
1744 v.AddArg(y)
1745 return true
1746 }
1747
1748
1749
1750 for {
1751 _ = v.Args[1]
1752 x := v.Args[0]
1753 v_1 := v.Args[1]
1754 if v_1.Op != OpARMSRLconst {
1755 break
1756 }
1757 c := v_1.AuxInt
1758 y := v_1.Args[0]
1759 v.reset(OpARMADDshiftRL)
1760 v.AuxInt = c
1761 v.AddArg(x)
1762 v.AddArg(y)
1763 return true
1764 }
1765
1766
1767
1768 for {
1769 x := v.Args[1]
1770 v_0 := v.Args[0]
1771 if v_0.Op != OpARMSRLconst {
1772 break
1773 }
1774 c := v_0.AuxInt
1775 y := v_0.Args[0]
1776 v.reset(OpARMADDshiftRL)
1777 v.AuxInt = c
1778 v.AddArg(x)
1779 v.AddArg(y)
1780 return true
1781 }
1782
1783
1784
1785 for {
1786 _ = v.Args[1]
1787 x := v.Args[0]
1788 v_1 := v.Args[1]
1789 if v_1.Op != OpARMSRAconst {
1790 break
1791 }
1792 c := v_1.AuxInt
1793 y := v_1.Args[0]
1794 v.reset(OpARMADDshiftRA)
1795 v.AuxInt = c
1796 v.AddArg(x)
1797 v.AddArg(y)
1798 return true
1799 }
1800
1801
1802
1803 for {
1804 x := v.Args[1]
1805 v_0 := v.Args[0]
1806 if v_0.Op != OpARMSRAconst {
1807 break
1808 }
1809 c := v_0.AuxInt
1810 y := v_0.Args[0]
1811 v.reset(OpARMADDshiftRA)
1812 v.AuxInt = c
1813 v.AddArg(x)
1814 v.AddArg(y)
1815 return true
1816 }
1817
1818
1819
1820 for {
1821 _ = v.Args[1]
1822 x := v.Args[0]
1823 v_1 := v.Args[1]
1824 if v_1.Op != OpARMSLL {
1825 break
1826 }
1827 z := v_1.Args[1]
1828 y := v_1.Args[0]
1829 v.reset(OpARMADDshiftLLreg)
1830 v.AddArg(x)
1831 v.AddArg(y)
1832 v.AddArg(z)
1833 return true
1834 }
1835
1836
1837
1838 for {
1839 x := v.Args[1]
1840 v_0 := v.Args[0]
1841 if v_0.Op != OpARMSLL {
1842 break
1843 }
1844 z := v_0.Args[1]
1845 y := v_0.Args[0]
1846 v.reset(OpARMADDshiftLLreg)
1847 v.AddArg(x)
1848 v.AddArg(y)
1849 v.AddArg(z)
1850 return true
1851 }
1852 return false
1853 }
1854 func rewriteValueARM_OpARMADD_10(v *Value) bool {
1855 b := v.Block
1856
1857
1858
1859 for {
1860 _ = v.Args[1]
1861 x := v.Args[0]
1862 v_1 := v.Args[1]
1863 if v_1.Op != OpARMSRL {
1864 break
1865 }
1866 z := v_1.Args[1]
1867 y := v_1.Args[0]
1868 v.reset(OpARMADDshiftRLreg)
1869 v.AddArg(x)
1870 v.AddArg(y)
1871 v.AddArg(z)
1872 return true
1873 }
1874
1875
1876
1877 for {
1878 x := v.Args[1]
1879 v_0 := v.Args[0]
1880 if v_0.Op != OpARMSRL {
1881 break
1882 }
1883 z := v_0.Args[1]
1884 y := v_0.Args[0]
1885 v.reset(OpARMADDshiftRLreg)
1886 v.AddArg(x)
1887 v.AddArg(y)
1888 v.AddArg(z)
1889 return true
1890 }
1891
1892
1893
1894 for {
1895 _ = v.Args[1]
1896 x := v.Args[0]
1897 v_1 := v.Args[1]
1898 if v_1.Op != OpARMSRA {
1899 break
1900 }
1901 z := v_1.Args[1]
1902 y := v_1.Args[0]
1903 v.reset(OpARMADDshiftRAreg)
1904 v.AddArg(x)
1905 v.AddArg(y)
1906 v.AddArg(z)
1907 return true
1908 }
1909
1910
1911
1912 for {
1913 x := v.Args[1]
1914 v_0 := v.Args[0]
1915 if v_0.Op != OpARMSRA {
1916 break
1917 }
1918 z := v_0.Args[1]
1919 y := v_0.Args[0]
1920 v.reset(OpARMADDshiftRAreg)
1921 v.AddArg(x)
1922 v.AddArg(y)
1923 v.AddArg(z)
1924 return true
1925 }
1926
1927
1928
1929 for {
1930 _ = v.Args[1]
1931 x := v.Args[0]
1932 v_1 := v.Args[1]
1933 if v_1.Op != OpARMRSBconst {
1934 break
1935 }
1936 if v_1.AuxInt != 0 {
1937 break
1938 }
1939 y := v_1.Args[0]
1940 v.reset(OpARMSUB)
1941 v.AddArg(x)
1942 v.AddArg(y)
1943 return true
1944 }
1945
1946
1947
1948 for {
1949 x := v.Args[1]
1950 v_0 := v.Args[0]
1951 if v_0.Op != OpARMRSBconst {
1952 break
1953 }
1954 if v_0.AuxInt != 0 {
1955 break
1956 }
1957 y := v_0.Args[0]
1958 v.reset(OpARMSUB)
1959 v.AddArg(x)
1960 v.AddArg(y)
1961 return true
1962 }
1963
1964
1965
1966 for {
1967 t := v.Type
1968 _ = v.Args[1]
1969 v_0 := v.Args[0]
1970 if v_0.Op != OpARMRSBconst {
1971 break
1972 }
1973 c := v_0.AuxInt
1974 x := v_0.Args[0]
1975 v_1 := v.Args[1]
1976 if v_1.Op != OpARMRSBconst {
1977 break
1978 }
1979 d := v_1.AuxInt
1980 y := v_1.Args[0]
1981 v.reset(OpARMRSBconst)
1982 v.AuxInt = c + d
1983 v0 := b.NewValue0(v.Pos, OpARMADD, t)
1984 v0.AddArg(x)
1985 v0.AddArg(y)
1986 v.AddArg(v0)
1987 return true
1988 }
1989
1990
1991
1992 for {
1993 t := v.Type
1994 _ = v.Args[1]
1995 v_0 := v.Args[0]
1996 if v_0.Op != OpARMRSBconst {
1997 break
1998 }
1999 d := v_0.AuxInt
2000 y := v_0.Args[0]
2001 v_1 := v.Args[1]
2002 if v_1.Op != OpARMRSBconst {
2003 break
2004 }
2005 c := v_1.AuxInt
2006 x := v_1.Args[0]
2007 v.reset(OpARMRSBconst)
2008 v.AuxInt = c + d
2009 v0 := b.NewValue0(v.Pos, OpARMADD, t)
2010 v0.AddArg(x)
2011 v0.AddArg(y)
2012 v.AddArg(v0)
2013 return true
2014 }
2015
2016
2017
2018 for {
2019 a := v.Args[1]
2020 v_0 := v.Args[0]
2021 if v_0.Op != OpARMMUL {
2022 break
2023 }
2024 y := v_0.Args[1]
2025 x := v_0.Args[0]
2026 v.reset(OpARMMULA)
2027 v.AddArg(x)
2028 v.AddArg(y)
2029 v.AddArg(a)
2030 return true
2031 }
2032
2033
2034
2035 for {
2036 _ = v.Args[1]
2037 a := v.Args[0]
2038 v_1 := v.Args[1]
2039 if v_1.Op != OpARMMUL {
2040 break
2041 }
2042 y := v_1.Args[1]
2043 x := v_1.Args[0]
2044 v.reset(OpARMMULA)
2045 v.AddArg(x)
2046 v.AddArg(y)
2047 v.AddArg(a)
2048 return true
2049 }
2050 return false
2051 }
2052 func rewriteValueARM_OpARMADDD_0(v *Value) bool {
2053
2054
2055
2056 for {
2057 _ = v.Args[1]
2058 a := v.Args[0]
2059 v_1 := v.Args[1]
2060 if v_1.Op != OpARMMULD {
2061 break
2062 }
2063 y := v_1.Args[1]
2064 x := v_1.Args[0]
2065 if !(a.Uses == 1 && objabi.GOARM >= 6) {
2066 break
2067 }
2068 v.reset(OpARMMULAD)
2069 v.AddArg(a)
2070 v.AddArg(x)
2071 v.AddArg(y)
2072 return true
2073 }
2074
2075
2076
2077 for {
2078 a := v.Args[1]
2079 v_0 := v.Args[0]
2080 if v_0.Op != OpARMMULD {
2081 break
2082 }
2083 y := v_0.Args[1]
2084 x := v_0.Args[0]
2085 if !(a.Uses == 1 && objabi.GOARM >= 6) {
2086 break
2087 }
2088 v.reset(OpARMMULAD)
2089 v.AddArg(a)
2090 v.AddArg(x)
2091 v.AddArg(y)
2092 return true
2093 }
2094
2095
2096
2097 for {
2098 _ = v.Args[1]
2099 a := v.Args[0]
2100 v_1 := v.Args[1]
2101 if v_1.Op != OpARMNMULD {
2102 break
2103 }
2104 y := v_1.Args[1]
2105 x := v_1.Args[0]
2106 if !(a.Uses == 1 && objabi.GOARM >= 6) {
2107 break
2108 }
2109 v.reset(OpARMMULSD)
2110 v.AddArg(a)
2111 v.AddArg(x)
2112 v.AddArg(y)
2113 return true
2114 }
2115
2116
2117
2118 for {
2119 a := v.Args[1]
2120 v_0 := v.Args[0]
2121 if v_0.Op != OpARMNMULD {
2122 break
2123 }
2124 y := v_0.Args[1]
2125 x := v_0.Args[0]
2126 if !(a.Uses == 1 && objabi.GOARM >= 6) {
2127 break
2128 }
2129 v.reset(OpARMMULSD)
2130 v.AddArg(a)
2131 v.AddArg(x)
2132 v.AddArg(y)
2133 return true
2134 }
2135 return false
2136 }
2137 func rewriteValueARM_OpARMADDF_0(v *Value) bool {
2138
2139
2140
2141 for {
2142 _ = v.Args[1]
2143 a := v.Args[0]
2144 v_1 := v.Args[1]
2145 if v_1.Op != OpARMMULF {
2146 break
2147 }
2148 y := v_1.Args[1]
2149 x := v_1.Args[0]
2150 if !(a.Uses == 1 && objabi.GOARM >= 6) {
2151 break
2152 }
2153 v.reset(OpARMMULAF)
2154 v.AddArg(a)
2155 v.AddArg(x)
2156 v.AddArg(y)
2157 return true
2158 }
2159
2160
2161
2162 for {
2163 a := v.Args[1]
2164 v_0 := v.Args[0]
2165 if v_0.Op != OpARMMULF {
2166 break
2167 }
2168 y := v_0.Args[1]
2169 x := v_0.Args[0]
2170 if !(a.Uses == 1 && objabi.GOARM >= 6) {
2171 break
2172 }
2173 v.reset(OpARMMULAF)
2174 v.AddArg(a)
2175 v.AddArg(x)
2176 v.AddArg(y)
2177 return true
2178 }
2179
2180
2181
2182 for {
2183 _ = v.Args[1]
2184 a := v.Args[0]
2185 v_1 := v.Args[1]
2186 if v_1.Op != OpARMNMULF {
2187 break
2188 }
2189 y := v_1.Args[1]
2190 x := v_1.Args[0]
2191 if !(a.Uses == 1 && objabi.GOARM >= 6) {
2192 break
2193 }
2194 v.reset(OpARMMULSF)
2195 v.AddArg(a)
2196 v.AddArg(x)
2197 v.AddArg(y)
2198 return true
2199 }
2200
2201
2202
2203 for {
2204 a := v.Args[1]
2205 v_0 := v.Args[0]
2206 if v_0.Op != OpARMNMULF {
2207 break
2208 }
2209 y := v_0.Args[1]
2210 x := v_0.Args[0]
2211 if !(a.Uses == 1 && objabi.GOARM >= 6) {
2212 break
2213 }
2214 v.reset(OpARMMULSF)
2215 v.AddArg(a)
2216 v.AddArg(x)
2217 v.AddArg(y)
2218 return true
2219 }
2220 return false
2221 }
2222 func rewriteValueARM_OpARMADDS_0(v *Value) bool {
2223
2224
2225
2226 for {
2227 _ = v.Args[1]
2228 x := v.Args[0]
2229 v_1 := v.Args[1]
2230 if v_1.Op != OpARMMOVWconst {
2231 break
2232 }
2233 c := v_1.AuxInt
2234 v.reset(OpARMADDSconst)
2235 v.AuxInt = c
2236 v.AddArg(x)
2237 return true
2238 }
2239
2240
2241
2242 for {
2243 x := v.Args[1]
2244 v_0 := v.Args[0]
2245 if v_0.Op != OpARMMOVWconst {
2246 break
2247 }
2248 c := v_0.AuxInt
2249 v.reset(OpARMADDSconst)
2250 v.AuxInt = c
2251 v.AddArg(x)
2252 return true
2253 }
2254
2255
2256
2257 for {
2258 _ = v.Args[1]
2259 x := v.Args[0]
2260 v_1 := v.Args[1]
2261 if v_1.Op != OpARMSLLconst {
2262 break
2263 }
2264 c := v_1.AuxInt
2265 y := v_1.Args[0]
2266 v.reset(OpARMADDSshiftLL)
2267 v.AuxInt = c
2268 v.AddArg(x)
2269 v.AddArg(y)
2270 return true
2271 }
2272
2273
2274
2275 for {
2276 x := v.Args[1]
2277 v_0 := v.Args[0]
2278 if v_0.Op != OpARMSLLconst {
2279 break
2280 }
2281 c := v_0.AuxInt
2282 y := v_0.Args[0]
2283 v.reset(OpARMADDSshiftLL)
2284 v.AuxInt = c
2285 v.AddArg(x)
2286 v.AddArg(y)
2287 return true
2288 }
2289
2290
2291
2292 for {
2293 _ = v.Args[1]
2294 x := v.Args[0]
2295 v_1 := v.Args[1]
2296 if v_1.Op != OpARMSRLconst {
2297 break
2298 }
2299 c := v_1.AuxInt
2300 y := v_1.Args[0]
2301 v.reset(OpARMADDSshiftRL)
2302 v.AuxInt = c
2303 v.AddArg(x)
2304 v.AddArg(y)
2305 return true
2306 }
2307
2308
2309
2310 for {
2311 x := v.Args[1]
2312 v_0 := v.Args[0]
2313 if v_0.Op != OpARMSRLconst {
2314 break
2315 }
2316 c := v_0.AuxInt
2317 y := v_0.Args[0]
2318 v.reset(OpARMADDSshiftRL)
2319 v.AuxInt = c
2320 v.AddArg(x)
2321 v.AddArg(y)
2322 return true
2323 }
2324
2325
2326
2327 for {
2328 _ = v.Args[1]
2329 x := v.Args[0]
2330 v_1 := v.Args[1]
2331 if v_1.Op != OpARMSRAconst {
2332 break
2333 }
2334 c := v_1.AuxInt
2335 y := v_1.Args[0]
2336 v.reset(OpARMADDSshiftRA)
2337 v.AuxInt = c
2338 v.AddArg(x)
2339 v.AddArg(y)
2340 return true
2341 }
2342
2343
2344
2345 for {
2346 x := v.Args[1]
2347 v_0 := v.Args[0]
2348 if v_0.Op != OpARMSRAconst {
2349 break
2350 }
2351 c := v_0.AuxInt
2352 y := v_0.Args[0]
2353 v.reset(OpARMADDSshiftRA)
2354 v.AuxInt = c
2355 v.AddArg(x)
2356 v.AddArg(y)
2357 return true
2358 }
2359
2360
2361
2362 for {
2363 _ = v.Args[1]
2364 x := v.Args[0]
2365 v_1 := v.Args[1]
2366 if v_1.Op != OpARMSLL {
2367 break
2368 }
2369 z := v_1.Args[1]
2370 y := v_1.Args[0]
2371 v.reset(OpARMADDSshiftLLreg)
2372 v.AddArg(x)
2373 v.AddArg(y)
2374 v.AddArg(z)
2375 return true
2376 }
2377
2378
2379
2380 for {
2381 x := v.Args[1]
2382 v_0 := v.Args[0]
2383 if v_0.Op != OpARMSLL {
2384 break
2385 }
2386 z := v_0.Args[1]
2387 y := v_0.Args[0]
2388 v.reset(OpARMADDSshiftLLreg)
2389 v.AddArg(x)
2390 v.AddArg(y)
2391 v.AddArg(z)
2392 return true
2393 }
2394 return false
2395 }
2396 func rewriteValueARM_OpARMADDS_10(v *Value) bool {
2397
2398
2399
2400 for {
2401 _ = v.Args[1]
2402 x := v.Args[0]
2403 v_1 := v.Args[1]
2404 if v_1.Op != OpARMSRL {
2405 break
2406 }
2407 z := v_1.Args[1]
2408 y := v_1.Args[0]
2409 v.reset(OpARMADDSshiftRLreg)
2410 v.AddArg(x)
2411 v.AddArg(y)
2412 v.AddArg(z)
2413 return true
2414 }
2415
2416
2417
2418 for {
2419 x := v.Args[1]
2420 v_0 := v.Args[0]
2421 if v_0.Op != OpARMSRL {
2422 break
2423 }
2424 z := v_0.Args[1]
2425 y := v_0.Args[0]
2426 v.reset(OpARMADDSshiftRLreg)
2427 v.AddArg(x)
2428 v.AddArg(y)
2429 v.AddArg(z)
2430 return true
2431 }
2432
2433
2434
2435 for {
2436 _ = v.Args[1]
2437 x := v.Args[0]
2438 v_1 := v.Args[1]
2439 if v_1.Op != OpARMSRA {
2440 break
2441 }
2442 z := v_1.Args[1]
2443 y := v_1.Args[0]
2444 v.reset(OpARMADDSshiftRAreg)
2445 v.AddArg(x)
2446 v.AddArg(y)
2447 v.AddArg(z)
2448 return true
2449 }
2450
2451
2452
2453 for {
2454 x := v.Args[1]
2455 v_0 := v.Args[0]
2456 if v_0.Op != OpARMSRA {
2457 break
2458 }
2459 z := v_0.Args[1]
2460 y := v_0.Args[0]
2461 v.reset(OpARMADDSshiftRAreg)
2462 v.AddArg(x)
2463 v.AddArg(y)
2464 v.AddArg(z)
2465 return true
2466 }
2467 return false
2468 }
2469 func rewriteValueARM_OpARMADDSshiftLL_0(v *Value) bool {
2470 b := v.Block
2471
2472
2473
2474 for {
2475 d := v.AuxInt
2476 x := v.Args[1]
2477 v_0 := v.Args[0]
2478 if v_0.Op != OpARMMOVWconst {
2479 break
2480 }
2481 c := v_0.AuxInt
2482 v.reset(OpARMADDSconst)
2483 v.AuxInt = c
2484 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
2485 v0.AuxInt = d
2486 v0.AddArg(x)
2487 v.AddArg(v0)
2488 return true
2489 }
2490
2491
2492
2493 for {
2494 d := v.AuxInt
2495 _ = v.Args[1]
2496 x := v.Args[0]
2497 v_1 := v.Args[1]
2498 if v_1.Op != OpARMMOVWconst {
2499 break
2500 }
2501 c := v_1.AuxInt
2502 v.reset(OpARMADDSconst)
2503 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
2504 v.AddArg(x)
2505 return true
2506 }
2507 return false
2508 }
2509 func rewriteValueARM_OpARMADDSshiftLLreg_0(v *Value) bool {
2510 b := v.Block
2511
2512
2513
2514 for {
2515 y := v.Args[2]
2516 v_0 := v.Args[0]
2517 if v_0.Op != OpARMMOVWconst {
2518 break
2519 }
2520 c := v_0.AuxInt
2521 x := v.Args[1]
2522 v.reset(OpARMADDSconst)
2523 v.AuxInt = c
2524 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
2525 v0.AddArg(x)
2526 v0.AddArg(y)
2527 v.AddArg(v0)
2528 return true
2529 }
2530
2531
2532
2533 for {
2534 _ = v.Args[2]
2535 x := v.Args[0]
2536 y := v.Args[1]
2537 v_2 := v.Args[2]
2538 if v_2.Op != OpARMMOVWconst {
2539 break
2540 }
2541 c := v_2.AuxInt
2542 v.reset(OpARMADDSshiftLL)
2543 v.AuxInt = c
2544 v.AddArg(x)
2545 v.AddArg(y)
2546 return true
2547 }
2548 return false
2549 }
2550 func rewriteValueARM_OpARMADDSshiftRA_0(v *Value) bool {
2551 b := v.Block
2552
2553
2554
2555 for {
2556 d := v.AuxInt
2557 x := v.Args[1]
2558 v_0 := v.Args[0]
2559 if v_0.Op != OpARMMOVWconst {
2560 break
2561 }
2562 c := v_0.AuxInt
2563 v.reset(OpARMADDSconst)
2564 v.AuxInt = c
2565 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
2566 v0.AuxInt = d
2567 v0.AddArg(x)
2568 v.AddArg(v0)
2569 return true
2570 }
2571
2572
2573
2574 for {
2575 d := v.AuxInt
2576 _ = v.Args[1]
2577 x := v.Args[0]
2578 v_1 := v.Args[1]
2579 if v_1.Op != OpARMMOVWconst {
2580 break
2581 }
2582 c := v_1.AuxInt
2583 v.reset(OpARMADDSconst)
2584 v.AuxInt = int64(int32(c) >> uint64(d))
2585 v.AddArg(x)
2586 return true
2587 }
2588 return false
2589 }
2590 func rewriteValueARM_OpARMADDSshiftRAreg_0(v *Value) bool {
2591 b := v.Block
2592
2593
2594
2595 for {
2596 y := v.Args[2]
2597 v_0 := v.Args[0]
2598 if v_0.Op != OpARMMOVWconst {
2599 break
2600 }
2601 c := v_0.AuxInt
2602 x := v.Args[1]
2603 v.reset(OpARMADDSconst)
2604 v.AuxInt = c
2605 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
2606 v0.AddArg(x)
2607 v0.AddArg(y)
2608 v.AddArg(v0)
2609 return true
2610 }
2611
2612
2613
2614 for {
2615 _ = v.Args[2]
2616 x := v.Args[0]
2617 y := v.Args[1]
2618 v_2 := v.Args[2]
2619 if v_2.Op != OpARMMOVWconst {
2620 break
2621 }
2622 c := v_2.AuxInt
2623 v.reset(OpARMADDSshiftRA)
2624 v.AuxInt = c
2625 v.AddArg(x)
2626 v.AddArg(y)
2627 return true
2628 }
2629 return false
2630 }
2631 func rewriteValueARM_OpARMADDSshiftRL_0(v *Value) bool {
2632 b := v.Block
2633
2634
2635
2636 for {
2637 d := v.AuxInt
2638 x := v.Args[1]
2639 v_0 := v.Args[0]
2640 if v_0.Op != OpARMMOVWconst {
2641 break
2642 }
2643 c := v_0.AuxInt
2644 v.reset(OpARMADDSconst)
2645 v.AuxInt = c
2646 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
2647 v0.AuxInt = d
2648 v0.AddArg(x)
2649 v.AddArg(v0)
2650 return true
2651 }
2652
2653
2654
2655 for {
2656 d := v.AuxInt
2657 _ = v.Args[1]
2658 x := v.Args[0]
2659 v_1 := v.Args[1]
2660 if v_1.Op != OpARMMOVWconst {
2661 break
2662 }
2663 c := v_1.AuxInt
2664 v.reset(OpARMADDSconst)
2665 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
2666 v.AddArg(x)
2667 return true
2668 }
2669 return false
2670 }
2671 func rewriteValueARM_OpARMADDSshiftRLreg_0(v *Value) bool {
2672 b := v.Block
2673
2674
2675
2676 for {
2677 y := v.Args[2]
2678 v_0 := v.Args[0]
2679 if v_0.Op != OpARMMOVWconst {
2680 break
2681 }
2682 c := v_0.AuxInt
2683 x := v.Args[1]
2684 v.reset(OpARMADDSconst)
2685 v.AuxInt = c
2686 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
2687 v0.AddArg(x)
2688 v0.AddArg(y)
2689 v.AddArg(v0)
2690 return true
2691 }
2692
2693
2694
2695 for {
2696 _ = v.Args[2]
2697 x := v.Args[0]
2698 y := v.Args[1]
2699 v_2 := v.Args[2]
2700 if v_2.Op != OpARMMOVWconst {
2701 break
2702 }
2703 c := v_2.AuxInt
2704 v.reset(OpARMADDSshiftRL)
2705 v.AuxInt = c
2706 v.AddArg(x)
2707 v.AddArg(y)
2708 return true
2709 }
2710 return false
2711 }
2712 func rewriteValueARM_OpARMADDconst_0(v *Value) bool {
2713
2714
2715
2716 for {
2717 off1 := v.AuxInt
2718 v_0 := v.Args[0]
2719 if v_0.Op != OpARMMOVWaddr {
2720 break
2721 }
2722 off2 := v_0.AuxInt
2723 sym := v_0.Aux
2724 ptr := v_0.Args[0]
2725 v.reset(OpARMMOVWaddr)
2726 v.AuxInt = off1 + off2
2727 v.Aux = sym
2728 v.AddArg(ptr)
2729 return true
2730 }
2731
2732
2733
2734 for {
2735 if v.AuxInt != 0 {
2736 break
2737 }
2738 x := v.Args[0]
2739 v.reset(OpCopy)
2740 v.Type = x.Type
2741 v.AddArg(x)
2742 return true
2743 }
2744
2745
2746
2747 for {
2748 c := v.AuxInt
2749 x := v.Args[0]
2750 if !(!isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c))) {
2751 break
2752 }
2753 v.reset(OpARMSUBconst)
2754 v.AuxInt = int64(int32(-c))
2755 v.AddArg(x)
2756 return true
2757 }
2758
2759
2760
2761 for {
2762 c := v.AuxInt
2763 x := v.Args[0]
2764 if !(objabi.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && uint32(-c) <= 0xffff) {
2765 break
2766 }
2767 v.reset(OpARMSUBconst)
2768 v.AuxInt = int64(int32(-c))
2769 v.AddArg(x)
2770 return true
2771 }
2772
2773
2774
2775 for {
2776 c := v.AuxInt
2777 v_0 := v.Args[0]
2778 if v_0.Op != OpARMMOVWconst {
2779 break
2780 }
2781 d := v_0.AuxInt
2782 v.reset(OpARMMOVWconst)
2783 v.AuxInt = int64(int32(c + d))
2784 return true
2785 }
2786
2787
2788
2789 for {
2790 c := v.AuxInt
2791 v_0 := v.Args[0]
2792 if v_0.Op != OpARMADDconst {
2793 break
2794 }
2795 d := v_0.AuxInt
2796 x := v_0.Args[0]
2797 v.reset(OpARMADDconst)
2798 v.AuxInt = int64(int32(c + d))
2799 v.AddArg(x)
2800 return true
2801 }
2802
2803
2804
2805 for {
2806 c := v.AuxInt
2807 v_0 := v.Args[0]
2808 if v_0.Op != OpARMSUBconst {
2809 break
2810 }
2811 d := v_0.AuxInt
2812 x := v_0.Args[0]
2813 v.reset(OpARMADDconst)
2814 v.AuxInt = int64(int32(c - d))
2815 v.AddArg(x)
2816 return true
2817 }
2818
2819
2820
2821 for {
2822 c := v.AuxInt
2823 v_0 := v.Args[0]
2824 if v_0.Op != OpARMRSBconst {
2825 break
2826 }
2827 d := v_0.AuxInt
2828 x := v_0.Args[0]
2829 v.reset(OpARMRSBconst)
2830 v.AuxInt = int64(int32(c + d))
2831 v.AddArg(x)
2832 return true
2833 }
2834 return false
2835 }
2836 func rewriteValueARM_OpARMADDshiftLL_0(v *Value) bool {
2837 b := v.Block
2838 typ := &b.Func.Config.Types
2839
2840
2841
2842 for {
2843 d := v.AuxInt
2844 x := v.Args[1]
2845 v_0 := v.Args[0]
2846 if v_0.Op != OpARMMOVWconst {
2847 break
2848 }
2849 c := v_0.AuxInt
2850 v.reset(OpARMADDconst)
2851 v.AuxInt = c
2852 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
2853 v0.AuxInt = d
2854 v0.AddArg(x)
2855 v.AddArg(v0)
2856 return true
2857 }
2858
2859
2860
2861 for {
2862 d := v.AuxInt
2863 _ = v.Args[1]
2864 x := v.Args[0]
2865 v_1 := v.Args[1]
2866 if v_1.Op != OpARMMOVWconst {
2867 break
2868 }
2869 c := v_1.AuxInt
2870 v.reset(OpARMADDconst)
2871 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
2872 v.AddArg(x)
2873 return true
2874 }
2875
2876
2877
2878 for {
2879 c := v.AuxInt
2880 x := v.Args[1]
2881 v_0 := v.Args[0]
2882 if v_0.Op != OpARMSRLconst {
2883 break
2884 }
2885 if v_0.AuxInt != 32-c {
2886 break
2887 }
2888 if x != v_0.Args[0] {
2889 break
2890 }
2891 v.reset(OpARMSRRconst)
2892 v.AuxInt = 32 - c
2893 v.AddArg(x)
2894 return true
2895 }
2896
2897
2898
2899 for {
2900 if v.Type != typ.UInt16 {
2901 break
2902 }
2903 if v.AuxInt != 8 {
2904 break
2905 }
2906 x := v.Args[1]
2907 v_0 := v.Args[0]
2908 if v_0.Op != OpARMBFXU {
2909 break
2910 }
2911 if v_0.Type != typ.UInt16 {
2912 break
2913 }
2914 if v_0.AuxInt != armBFAuxInt(8, 8) {
2915 break
2916 }
2917 if x != v_0.Args[0] {
2918 break
2919 }
2920 v.reset(OpARMREV16)
2921 v.AddArg(x)
2922 return true
2923 }
2924
2925
2926
2927 for {
2928 if v.Type != typ.UInt16 {
2929 break
2930 }
2931 if v.AuxInt != 8 {
2932 break
2933 }
2934 x := v.Args[1]
2935 v_0 := v.Args[0]
2936 if v_0.Op != OpARMSRLconst {
2937 break
2938 }
2939 if v_0.Type != typ.UInt16 {
2940 break
2941 }
2942 if v_0.AuxInt != 24 {
2943 break
2944 }
2945 v_0_0 := v_0.Args[0]
2946 if v_0_0.Op != OpARMSLLconst {
2947 break
2948 }
2949 if v_0_0.AuxInt != 16 {
2950 break
2951 }
2952 if x != v_0_0.Args[0] {
2953 break
2954 }
2955 if !(objabi.GOARM >= 6) {
2956 break
2957 }
2958 v.reset(OpARMREV16)
2959 v.AddArg(x)
2960 return true
2961 }
2962 return false
2963 }
2964 func rewriteValueARM_OpARMADDshiftLLreg_0(v *Value) bool {
2965 b := v.Block
2966
2967
2968
2969 for {
2970 y := v.Args[2]
2971 v_0 := v.Args[0]
2972 if v_0.Op != OpARMMOVWconst {
2973 break
2974 }
2975 c := v_0.AuxInt
2976 x := v.Args[1]
2977 v.reset(OpARMADDconst)
2978 v.AuxInt = c
2979 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
2980 v0.AddArg(x)
2981 v0.AddArg(y)
2982 v.AddArg(v0)
2983 return true
2984 }
2985
2986
2987
2988 for {
2989 _ = v.Args[2]
2990 x := v.Args[0]
2991 y := v.Args[1]
2992 v_2 := v.Args[2]
2993 if v_2.Op != OpARMMOVWconst {
2994 break
2995 }
2996 c := v_2.AuxInt
2997 v.reset(OpARMADDshiftLL)
2998 v.AuxInt = c
2999 v.AddArg(x)
3000 v.AddArg(y)
3001 return true
3002 }
3003 return false
3004 }
3005 func rewriteValueARM_OpARMADDshiftRA_0(v *Value) bool {
3006 b := v.Block
3007
3008
3009
3010 for {
3011 d := v.AuxInt
3012 x := v.Args[1]
3013 v_0 := v.Args[0]
3014 if v_0.Op != OpARMMOVWconst {
3015 break
3016 }
3017 c := v_0.AuxInt
3018 v.reset(OpARMADDconst)
3019 v.AuxInt = c
3020 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
3021 v0.AuxInt = d
3022 v0.AddArg(x)
3023 v.AddArg(v0)
3024 return true
3025 }
3026
3027
3028
3029 for {
3030 d := v.AuxInt
3031 _ = v.Args[1]
3032 x := v.Args[0]
3033 v_1 := v.Args[1]
3034 if v_1.Op != OpARMMOVWconst {
3035 break
3036 }
3037 c := v_1.AuxInt
3038 v.reset(OpARMADDconst)
3039 v.AuxInt = int64(int32(c) >> uint64(d))
3040 v.AddArg(x)
3041 return true
3042 }
3043 return false
3044 }
3045 func rewriteValueARM_OpARMADDshiftRAreg_0(v *Value) bool {
3046 b := v.Block
3047
3048
3049
3050 for {
3051 y := v.Args[2]
3052 v_0 := v.Args[0]
3053 if v_0.Op != OpARMMOVWconst {
3054 break
3055 }
3056 c := v_0.AuxInt
3057 x := v.Args[1]
3058 v.reset(OpARMADDconst)
3059 v.AuxInt = c
3060 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
3061 v0.AddArg(x)
3062 v0.AddArg(y)
3063 v.AddArg(v0)
3064 return true
3065 }
3066
3067
3068
3069 for {
3070 _ = v.Args[2]
3071 x := v.Args[0]
3072 y := v.Args[1]
3073 v_2 := v.Args[2]
3074 if v_2.Op != OpARMMOVWconst {
3075 break
3076 }
3077 c := v_2.AuxInt
3078 v.reset(OpARMADDshiftRA)
3079 v.AuxInt = c
3080 v.AddArg(x)
3081 v.AddArg(y)
3082 return true
3083 }
3084 return false
3085 }
3086 func rewriteValueARM_OpARMADDshiftRL_0(v *Value) bool {
3087 b := v.Block
3088
3089
3090
3091 for {
3092 d := v.AuxInt
3093 x := v.Args[1]
3094 v_0 := v.Args[0]
3095 if v_0.Op != OpARMMOVWconst {
3096 break
3097 }
3098 c := v_0.AuxInt
3099 v.reset(OpARMADDconst)
3100 v.AuxInt = c
3101 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
3102 v0.AuxInt = d
3103 v0.AddArg(x)
3104 v.AddArg(v0)
3105 return true
3106 }
3107
3108
3109
3110 for {
3111 d := v.AuxInt
3112 _ = v.Args[1]
3113 x := v.Args[0]
3114 v_1 := v.Args[1]
3115 if v_1.Op != OpARMMOVWconst {
3116 break
3117 }
3118 c := v_1.AuxInt
3119 v.reset(OpARMADDconst)
3120 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
3121 v.AddArg(x)
3122 return true
3123 }
3124
3125
3126
3127 for {
3128 c := v.AuxInt
3129 x := v.Args[1]
3130 v_0 := v.Args[0]
3131 if v_0.Op != OpARMSLLconst {
3132 break
3133 }
3134 if v_0.AuxInt != 32-c {
3135 break
3136 }
3137 if x != v_0.Args[0] {
3138 break
3139 }
3140 v.reset(OpARMSRRconst)
3141 v.AuxInt = c
3142 v.AddArg(x)
3143 return true
3144 }
3145 return false
3146 }
3147 func rewriteValueARM_OpARMADDshiftRLreg_0(v *Value) bool {
3148 b := v.Block
3149
3150
3151
3152 for {
3153 y := v.Args[2]
3154 v_0 := v.Args[0]
3155 if v_0.Op != OpARMMOVWconst {
3156 break
3157 }
3158 c := v_0.AuxInt
3159 x := v.Args[1]
3160 v.reset(OpARMADDconst)
3161 v.AuxInt = c
3162 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
3163 v0.AddArg(x)
3164 v0.AddArg(y)
3165 v.AddArg(v0)
3166 return true
3167 }
3168
3169
3170
3171 for {
3172 _ = v.Args[2]
3173 x := v.Args[0]
3174 y := v.Args[1]
3175 v_2 := v.Args[2]
3176 if v_2.Op != OpARMMOVWconst {
3177 break
3178 }
3179 c := v_2.AuxInt
3180 v.reset(OpARMADDshiftRL)
3181 v.AuxInt = c
3182 v.AddArg(x)
3183 v.AddArg(y)
3184 return true
3185 }
3186 return false
3187 }
3188 func rewriteValueARM_OpARMAND_0(v *Value) bool {
3189
3190
3191
3192 for {
3193 _ = v.Args[1]
3194 x := v.Args[0]
3195 v_1 := v.Args[1]
3196 if v_1.Op != OpARMMOVWconst {
3197 break
3198 }
3199 c := v_1.AuxInt
3200 v.reset(OpARMANDconst)
3201 v.AuxInt = c
3202 v.AddArg(x)
3203 return true
3204 }
3205
3206
3207
3208 for {
3209 x := v.Args[1]
3210 v_0 := v.Args[0]
3211 if v_0.Op != OpARMMOVWconst {
3212 break
3213 }
3214 c := v_0.AuxInt
3215 v.reset(OpARMANDconst)
3216 v.AuxInt = c
3217 v.AddArg(x)
3218 return true
3219 }
3220
3221
3222
3223 for {
3224 _ = v.Args[1]
3225 x := v.Args[0]
3226 v_1 := v.Args[1]
3227 if v_1.Op != OpARMSLLconst {
3228 break
3229 }
3230 c := v_1.AuxInt
3231 y := v_1.Args[0]
3232 v.reset(OpARMANDshiftLL)
3233 v.AuxInt = c
3234 v.AddArg(x)
3235 v.AddArg(y)
3236 return true
3237 }
3238
3239
3240
3241 for {
3242 x := v.Args[1]
3243 v_0 := v.Args[0]
3244 if v_0.Op != OpARMSLLconst {
3245 break
3246 }
3247 c := v_0.AuxInt
3248 y := v_0.Args[0]
3249 v.reset(OpARMANDshiftLL)
3250 v.AuxInt = c
3251 v.AddArg(x)
3252 v.AddArg(y)
3253 return true
3254 }
3255
3256
3257
3258 for {
3259 _ = v.Args[1]
3260 x := v.Args[0]
3261 v_1 := v.Args[1]
3262 if v_1.Op != OpARMSRLconst {
3263 break
3264 }
3265 c := v_1.AuxInt
3266 y := v_1.Args[0]
3267 v.reset(OpARMANDshiftRL)
3268 v.AuxInt = c
3269 v.AddArg(x)
3270 v.AddArg(y)
3271 return true
3272 }
3273
3274
3275
3276 for {
3277 x := v.Args[1]
3278 v_0 := v.Args[0]
3279 if v_0.Op != OpARMSRLconst {
3280 break
3281 }
3282 c := v_0.AuxInt
3283 y := v_0.Args[0]
3284 v.reset(OpARMANDshiftRL)
3285 v.AuxInt = c
3286 v.AddArg(x)
3287 v.AddArg(y)
3288 return true
3289 }
3290
3291
3292
3293 for {
3294 _ = v.Args[1]
3295 x := v.Args[0]
3296 v_1 := v.Args[1]
3297 if v_1.Op != OpARMSRAconst {
3298 break
3299 }
3300 c := v_1.AuxInt
3301 y := v_1.Args[0]
3302 v.reset(OpARMANDshiftRA)
3303 v.AuxInt = c
3304 v.AddArg(x)
3305 v.AddArg(y)
3306 return true
3307 }
3308
3309
3310
3311 for {
3312 x := v.Args[1]
3313 v_0 := v.Args[0]
3314 if v_0.Op != OpARMSRAconst {
3315 break
3316 }
3317 c := v_0.AuxInt
3318 y := v_0.Args[0]
3319 v.reset(OpARMANDshiftRA)
3320 v.AuxInt = c
3321 v.AddArg(x)
3322 v.AddArg(y)
3323 return true
3324 }
3325
3326
3327
3328 for {
3329 _ = v.Args[1]
3330 x := v.Args[0]
3331 v_1 := v.Args[1]
3332 if v_1.Op != OpARMSLL {
3333 break
3334 }
3335 z := v_1.Args[1]
3336 y := v_1.Args[0]
3337 v.reset(OpARMANDshiftLLreg)
3338 v.AddArg(x)
3339 v.AddArg(y)
3340 v.AddArg(z)
3341 return true
3342 }
3343
3344
3345
3346 for {
3347 x := v.Args[1]
3348 v_0 := v.Args[0]
3349 if v_0.Op != OpARMSLL {
3350 break
3351 }
3352 z := v_0.Args[1]
3353 y := v_0.Args[0]
3354 v.reset(OpARMANDshiftLLreg)
3355 v.AddArg(x)
3356 v.AddArg(y)
3357 v.AddArg(z)
3358 return true
3359 }
3360 return false
3361 }
3362 func rewriteValueARM_OpARMAND_10(v *Value) bool {
3363
3364
3365
3366 for {
3367 _ = v.Args[1]
3368 x := v.Args[0]
3369 v_1 := v.Args[1]
3370 if v_1.Op != OpARMSRL {
3371 break
3372 }
3373 z := v_1.Args[1]
3374 y := v_1.Args[0]
3375 v.reset(OpARMANDshiftRLreg)
3376 v.AddArg(x)
3377 v.AddArg(y)
3378 v.AddArg(z)
3379 return true
3380 }
3381
3382
3383
3384 for {
3385 x := v.Args[1]
3386 v_0 := v.Args[0]
3387 if v_0.Op != OpARMSRL {
3388 break
3389 }
3390 z := v_0.Args[1]
3391 y := v_0.Args[0]
3392 v.reset(OpARMANDshiftRLreg)
3393 v.AddArg(x)
3394 v.AddArg(y)
3395 v.AddArg(z)
3396 return true
3397 }
3398
3399
3400
3401 for {
3402 _ = v.Args[1]
3403 x := v.Args[0]
3404 v_1 := v.Args[1]
3405 if v_1.Op != OpARMSRA {
3406 break
3407 }
3408 z := v_1.Args[1]
3409 y := v_1.Args[0]
3410 v.reset(OpARMANDshiftRAreg)
3411 v.AddArg(x)
3412 v.AddArg(y)
3413 v.AddArg(z)
3414 return true
3415 }
3416
3417
3418
3419 for {
3420 x := v.Args[1]
3421 v_0 := v.Args[0]
3422 if v_0.Op != OpARMSRA {
3423 break
3424 }
3425 z := v_0.Args[1]
3426 y := v_0.Args[0]
3427 v.reset(OpARMANDshiftRAreg)
3428 v.AddArg(x)
3429 v.AddArg(y)
3430 v.AddArg(z)
3431 return true
3432 }
3433
3434
3435
3436 for {
3437 x := v.Args[1]
3438 if x != v.Args[0] {
3439 break
3440 }
3441 v.reset(OpCopy)
3442 v.Type = x.Type
3443 v.AddArg(x)
3444 return true
3445 }
3446
3447
3448
3449 for {
3450 _ = v.Args[1]
3451 x := v.Args[0]
3452 v_1 := v.Args[1]
3453 if v_1.Op != OpARMMVN {
3454 break
3455 }
3456 y := v_1.Args[0]
3457 v.reset(OpARMBIC)
3458 v.AddArg(x)
3459 v.AddArg(y)
3460 return true
3461 }
3462
3463
3464
3465 for {
3466 x := v.Args[1]
3467 v_0 := v.Args[0]
3468 if v_0.Op != OpARMMVN {
3469 break
3470 }
3471 y := v_0.Args[0]
3472 v.reset(OpARMBIC)
3473 v.AddArg(x)
3474 v.AddArg(y)
3475 return true
3476 }
3477
3478
3479
3480 for {
3481 _ = v.Args[1]
3482 x := v.Args[0]
3483 v_1 := v.Args[1]
3484 if v_1.Op != OpARMMVNshiftLL {
3485 break
3486 }
3487 c := v_1.AuxInt
3488 y := v_1.Args[0]
3489 v.reset(OpARMBICshiftLL)
3490 v.AuxInt = c
3491 v.AddArg(x)
3492 v.AddArg(y)
3493 return true
3494 }
3495
3496
3497
3498 for {
3499 x := v.Args[1]
3500 v_0 := v.Args[0]
3501 if v_0.Op != OpARMMVNshiftLL {
3502 break
3503 }
3504 c := v_0.AuxInt
3505 y := v_0.Args[0]
3506 v.reset(OpARMBICshiftLL)
3507 v.AuxInt = c
3508 v.AddArg(x)
3509 v.AddArg(y)
3510 return true
3511 }
3512
3513
3514
3515 for {
3516 _ = v.Args[1]
3517 x := v.Args[0]
3518 v_1 := v.Args[1]
3519 if v_1.Op != OpARMMVNshiftRL {
3520 break
3521 }
3522 c := v_1.AuxInt
3523 y := v_1.Args[0]
3524 v.reset(OpARMBICshiftRL)
3525 v.AuxInt = c
3526 v.AddArg(x)
3527 v.AddArg(y)
3528 return true
3529 }
3530 return false
3531 }
3532 func rewriteValueARM_OpARMAND_20(v *Value) bool {
3533
3534
3535
3536 for {
3537 x := v.Args[1]
3538 v_0 := v.Args[0]
3539 if v_0.Op != OpARMMVNshiftRL {
3540 break
3541 }
3542 c := v_0.AuxInt
3543 y := v_0.Args[0]
3544 v.reset(OpARMBICshiftRL)
3545 v.AuxInt = c
3546 v.AddArg(x)
3547 v.AddArg(y)
3548 return true
3549 }
3550
3551
3552
3553 for {
3554 _ = v.Args[1]
3555 x := v.Args[0]
3556 v_1 := v.Args[1]
3557 if v_1.Op != OpARMMVNshiftRA {
3558 break
3559 }
3560 c := v_1.AuxInt
3561 y := v_1.Args[0]
3562 v.reset(OpARMBICshiftRA)
3563 v.AuxInt = c
3564 v.AddArg(x)
3565 v.AddArg(y)
3566 return true
3567 }
3568
3569
3570
3571 for {
3572 x := v.Args[1]
3573 v_0 := v.Args[0]
3574 if v_0.Op != OpARMMVNshiftRA {
3575 break
3576 }
3577 c := v_0.AuxInt
3578 y := v_0.Args[0]
3579 v.reset(OpARMBICshiftRA)
3580 v.AuxInt = c
3581 v.AddArg(x)
3582 v.AddArg(y)
3583 return true
3584 }
3585 return false
3586 }
3587 func rewriteValueARM_OpARMANDconst_0(v *Value) bool {
3588
3589
3590
3591 for {
3592 if v.AuxInt != 0 {
3593 break
3594 }
3595 v.reset(OpARMMOVWconst)
3596 v.AuxInt = 0
3597 return true
3598 }
3599
3600
3601
3602 for {
3603 c := v.AuxInt
3604 x := v.Args[0]
3605 if !(int32(c) == -1) {
3606 break
3607 }
3608 v.reset(OpCopy)
3609 v.Type = x.Type
3610 v.AddArg(x)
3611 return true
3612 }
3613
3614
3615
3616 for {
3617 c := v.AuxInt
3618 x := v.Args[0]
3619 if !(!isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c))) {
3620 break
3621 }
3622 v.reset(OpARMBICconst)
3623 v.AuxInt = int64(int32(^uint32(c)))
3624 v.AddArg(x)
3625 return true
3626 }
3627
3628
3629
3630 for {
3631 c := v.AuxInt
3632 x := v.Args[0]
3633 if !(objabi.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && ^uint32(c) <= 0xffff) {
3634 break
3635 }
3636 v.reset(OpARMBICconst)
3637 v.AuxInt = int64(int32(^uint32(c)))
3638 v.AddArg(x)
3639 return true
3640 }
3641
3642
3643
3644 for {
3645 c := v.AuxInt
3646 v_0 := v.Args[0]
3647 if v_0.Op != OpARMMOVWconst {
3648 break
3649 }
3650 d := v_0.AuxInt
3651 v.reset(OpARMMOVWconst)
3652 v.AuxInt = c & d
3653 return true
3654 }
3655
3656
3657
3658 for {
3659 c := v.AuxInt
3660 v_0 := v.Args[0]
3661 if v_0.Op != OpARMANDconst {
3662 break
3663 }
3664 d := v_0.AuxInt
3665 x := v_0.Args[0]
3666 v.reset(OpARMANDconst)
3667 v.AuxInt = c & d
3668 v.AddArg(x)
3669 return true
3670 }
3671 return false
3672 }
3673 func rewriteValueARM_OpARMANDshiftLL_0(v *Value) bool {
3674 b := v.Block
3675
3676
3677
3678 for {
3679 d := v.AuxInt
3680 x := v.Args[1]
3681 v_0 := v.Args[0]
3682 if v_0.Op != OpARMMOVWconst {
3683 break
3684 }
3685 c := v_0.AuxInt
3686 v.reset(OpARMANDconst)
3687 v.AuxInt = c
3688 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
3689 v0.AuxInt = d
3690 v0.AddArg(x)
3691 v.AddArg(v0)
3692 return true
3693 }
3694
3695
3696
3697 for {
3698 d := v.AuxInt
3699 _ = v.Args[1]
3700 x := v.Args[0]
3701 v_1 := v.Args[1]
3702 if v_1.Op != OpARMMOVWconst {
3703 break
3704 }
3705 c := v_1.AuxInt
3706 v.reset(OpARMANDconst)
3707 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
3708 v.AddArg(x)
3709 return true
3710 }
3711
3712
3713
3714 for {
3715 d := v.AuxInt
3716 _ = v.Args[1]
3717 x := v.Args[0]
3718 y := v.Args[1]
3719 if y.Op != OpARMSLLconst {
3720 break
3721 }
3722 c := y.AuxInt
3723 if x != y.Args[0] {
3724 break
3725 }
3726 if !(c == d) {
3727 break
3728 }
3729 v.reset(OpCopy)
3730 v.Type = y.Type
3731 v.AddArg(y)
3732 return true
3733 }
3734 return false
3735 }
3736 func rewriteValueARM_OpARMANDshiftLLreg_0(v *Value) bool {
3737 b := v.Block
3738
3739
3740
3741 for {
3742 y := v.Args[2]
3743 v_0 := v.Args[0]
3744 if v_0.Op != OpARMMOVWconst {
3745 break
3746 }
3747 c := v_0.AuxInt
3748 x := v.Args[1]
3749 v.reset(OpARMANDconst)
3750 v.AuxInt = c
3751 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
3752 v0.AddArg(x)
3753 v0.AddArg(y)
3754 v.AddArg(v0)
3755 return true
3756 }
3757
3758
3759
3760 for {
3761 _ = v.Args[2]
3762 x := v.Args[0]
3763 y := v.Args[1]
3764 v_2 := v.Args[2]
3765 if v_2.Op != OpARMMOVWconst {
3766 break
3767 }
3768 c := v_2.AuxInt
3769 v.reset(OpARMANDshiftLL)
3770 v.AuxInt = c
3771 v.AddArg(x)
3772 v.AddArg(y)
3773 return true
3774 }
3775 return false
3776 }
3777 func rewriteValueARM_OpARMANDshiftRA_0(v *Value) bool {
3778 b := v.Block
3779
3780
3781
3782 for {
3783 d := v.AuxInt
3784 x := v.Args[1]
3785 v_0 := v.Args[0]
3786 if v_0.Op != OpARMMOVWconst {
3787 break
3788 }
3789 c := v_0.AuxInt
3790 v.reset(OpARMANDconst)
3791 v.AuxInt = c
3792 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
3793 v0.AuxInt = d
3794 v0.AddArg(x)
3795 v.AddArg(v0)
3796 return true
3797 }
3798
3799
3800
3801 for {
3802 d := v.AuxInt
3803 _ = v.Args[1]
3804 x := v.Args[0]
3805 v_1 := v.Args[1]
3806 if v_1.Op != OpARMMOVWconst {
3807 break
3808 }
3809 c := v_1.AuxInt
3810 v.reset(OpARMANDconst)
3811 v.AuxInt = int64(int32(c) >> uint64(d))
3812 v.AddArg(x)
3813 return true
3814 }
3815
3816
3817
3818 for {
3819 d := v.AuxInt
3820 _ = v.Args[1]
3821 x := v.Args[0]
3822 y := v.Args[1]
3823 if y.Op != OpARMSRAconst {
3824 break
3825 }
3826 c := y.AuxInt
3827 if x != y.Args[0] {
3828 break
3829 }
3830 if !(c == d) {
3831 break
3832 }
3833 v.reset(OpCopy)
3834 v.Type = y.Type
3835 v.AddArg(y)
3836 return true
3837 }
3838 return false
3839 }
3840 func rewriteValueARM_OpARMANDshiftRAreg_0(v *Value) bool {
3841 b := v.Block
3842
3843
3844
3845 for {
3846 y := v.Args[2]
3847 v_0 := v.Args[0]
3848 if v_0.Op != OpARMMOVWconst {
3849 break
3850 }
3851 c := v_0.AuxInt
3852 x := v.Args[1]
3853 v.reset(OpARMANDconst)
3854 v.AuxInt = c
3855 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
3856 v0.AddArg(x)
3857 v0.AddArg(y)
3858 v.AddArg(v0)
3859 return true
3860 }
3861
3862
3863
3864 for {
3865 _ = v.Args[2]
3866 x := v.Args[0]
3867 y := v.Args[1]
3868 v_2 := v.Args[2]
3869 if v_2.Op != OpARMMOVWconst {
3870 break
3871 }
3872 c := v_2.AuxInt
3873 v.reset(OpARMANDshiftRA)
3874 v.AuxInt = c
3875 v.AddArg(x)
3876 v.AddArg(y)
3877 return true
3878 }
3879 return false
3880 }
3881 func rewriteValueARM_OpARMANDshiftRL_0(v *Value) bool {
3882 b := v.Block
3883
3884
3885
3886 for {
3887 d := v.AuxInt
3888 x := v.Args[1]
3889 v_0 := v.Args[0]
3890 if v_0.Op != OpARMMOVWconst {
3891 break
3892 }
3893 c := v_0.AuxInt
3894 v.reset(OpARMANDconst)
3895 v.AuxInt = c
3896 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
3897 v0.AuxInt = d
3898 v0.AddArg(x)
3899 v.AddArg(v0)
3900 return true
3901 }
3902
3903
3904
3905 for {
3906 d := v.AuxInt
3907 _ = v.Args[1]
3908 x := v.Args[0]
3909 v_1 := v.Args[1]
3910 if v_1.Op != OpARMMOVWconst {
3911 break
3912 }
3913 c := v_1.AuxInt
3914 v.reset(OpARMANDconst)
3915 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
3916 v.AddArg(x)
3917 return true
3918 }
3919
3920
3921
3922 for {
3923 d := v.AuxInt
3924 _ = v.Args[1]
3925 x := v.Args[0]
3926 y := v.Args[1]
3927 if y.Op != OpARMSRLconst {
3928 break
3929 }
3930 c := y.AuxInt
3931 if x != y.Args[0] {
3932 break
3933 }
3934 if !(c == d) {
3935 break
3936 }
3937 v.reset(OpCopy)
3938 v.Type = y.Type
3939 v.AddArg(y)
3940 return true
3941 }
3942 return false
3943 }
3944 func rewriteValueARM_OpARMANDshiftRLreg_0(v *Value) bool {
3945 b := v.Block
3946
3947
3948
3949 for {
3950 y := v.Args[2]
3951 v_0 := v.Args[0]
3952 if v_0.Op != OpARMMOVWconst {
3953 break
3954 }
3955 c := v_0.AuxInt
3956 x := v.Args[1]
3957 v.reset(OpARMANDconst)
3958 v.AuxInt = c
3959 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
3960 v0.AddArg(x)
3961 v0.AddArg(y)
3962 v.AddArg(v0)
3963 return true
3964 }
3965
3966
3967
3968 for {
3969 _ = v.Args[2]
3970 x := v.Args[0]
3971 y := v.Args[1]
3972 v_2 := v.Args[2]
3973 if v_2.Op != OpARMMOVWconst {
3974 break
3975 }
3976 c := v_2.AuxInt
3977 v.reset(OpARMANDshiftRL)
3978 v.AuxInt = c
3979 v.AddArg(x)
3980 v.AddArg(y)
3981 return true
3982 }
3983 return false
3984 }
3985 func rewriteValueARM_OpARMBFX_0(v *Value) bool {
3986
3987
3988
3989 for {
3990 c := v.AuxInt
3991 v_0 := v.Args[0]
3992 if v_0.Op != OpARMMOVWconst {
3993 break
3994 }
3995 d := v_0.AuxInt
3996 v.reset(OpARMMOVWconst)
3997 v.AuxInt = int64(int32(d) << (32 - uint32(c&0xff) - uint32(c>>8)) >> (32 - uint32(c>>8)))
3998 return true
3999 }
4000 return false
4001 }
4002 func rewriteValueARM_OpARMBFXU_0(v *Value) bool {
4003
4004
4005
4006 for {
4007 c := v.AuxInt
4008 v_0 := v.Args[0]
4009 if v_0.Op != OpARMMOVWconst {
4010 break
4011 }
4012 d := v_0.AuxInt
4013 v.reset(OpARMMOVWconst)
4014 v.AuxInt = int64(int32(uint32(d) << (32 - uint32(c&0xff) - uint32(c>>8)) >> (32 - uint32(c>>8))))
4015 return true
4016 }
4017 return false
4018 }
4019 func rewriteValueARM_OpARMBIC_0(v *Value) bool {
4020
4021
4022
4023 for {
4024 _ = v.Args[1]
4025 x := v.Args[0]
4026 v_1 := v.Args[1]
4027 if v_1.Op != OpARMMOVWconst {
4028 break
4029 }
4030 c := v_1.AuxInt
4031 v.reset(OpARMBICconst)
4032 v.AuxInt = c
4033 v.AddArg(x)
4034 return true
4035 }
4036
4037
4038
4039 for {
4040 _ = v.Args[1]
4041 x := v.Args[0]
4042 v_1 := v.Args[1]
4043 if v_1.Op != OpARMSLLconst {
4044 break
4045 }
4046 c := v_1.AuxInt
4047 y := v_1.Args[0]
4048 v.reset(OpARMBICshiftLL)
4049 v.AuxInt = c
4050 v.AddArg(x)
4051 v.AddArg(y)
4052 return true
4053 }
4054
4055
4056
4057 for {
4058 _ = v.Args[1]
4059 x := v.Args[0]
4060 v_1 := v.Args[1]
4061 if v_1.Op != OpARMSRLconst {
4062 break
4063 }
4064 c := v_1.AuxInt
4065 y := v_1.Args[0]
4066 v.reset(OpARMBICshiftRL)
4067 v.AuxInt = c
4068 v.AddArg(x)
4069 v.AddArg(y)
4070 return true
4071 }
4072
4073
4074
4075 for {
4076 _ = v.Args[1]
4077 x := v.Args[0]
4078 v_1 := v.Args[1]
4079 if v_1.Op != OpARMSRAconst {
4080 break
4081 }
4082 c := v_1.AuxInt
4083 y := v_1.Args[0]
4084 v.reset(OpARMBICshiftRA)
4085 v.AuxInt = c
4086 v.AddArg(x)
4087 v.AddArg(y)
4088 return true
4089 }
4090
4091
4092
4093 for {
4094 _ = v.Args[1]
4095 x := v.Args[0]
4096 v_1 := v.Args[1]
4097 if v_1.Op != OpARMSLL {
4098 break
4099 }
4100 z := v_1.Args[1]
4101 y := v_1.Args[0]
4102 v.reset(OpARMBICshiftLLreg)
4103 v.AddArg(x)
4104 v.AddArg(y)
4105 v.AddArg(z)
4106 return true
4107 }
4108
4109
4110
4111 for {
4112 _ = v.Args[1]
4113 x := v.Args[0]
4114 v_1 := v.Args[1]
4115 if v_1.Op != OpARMSRL {
4116 break
4117 }
4118 z := v_1.Args[1]
4119 y := v_1.Args[0]
4120 v.reset(OpARMBICshiftRLreg)
4121 v.AddArg(x)
4122 v.AddArg(y)
4123 v.AddArg(z)
4124 return true
4125 }
4126
4127
4128
4129 for {
4130 _ = v.Args[1]
4131 x := v.Args[0]
4132 v_1 := v.Args[1]
4133 if v_1.Op != OpARMSRA {
4134 break
4135 }
4136 z := v_1.Args[1]
4137 y := v_1.Args[0]
4138 v.reset(OpARMBICshiftRAreg)
4139 v.AddArg(x)
4140 v.AddArg(y)
4141 v.AddArg(z)
4142 return true
4143 }
4144
4145
4146
4147 for {
4148 x := v.Args[1]
4149 if x != v.Args[0] {
4150 break
4151 }
4152 v.reset(OpARMMOVWconst)
4153 v.AuxInt = 0
4154 return true
4155 }
4156 return false
4157 }
4158 func rewriteValueARM_OpARMBICconst_0(v *Value) bool {
4159
4160
4161
4162 for {
4163 if v.AuxInt != 0 {
4164 break
4165 }
4166 x := v.Args[0]
4167 v.reset(OpCopy)
4168 v.Type = x.Type
4169 v.AddArg(x)
4170 return true
4171 }
4172
4173
4174
4175 for {
4176 c := v.AuxInt
4177 if !(int32(c) == -1) {
4178 break
4179 }
4180 v.reset(OpARMMOVWconst)
4181 v.AuxInt = 0
4182 return true
4183 }
4184
4185
4186
4187 for {
4188 c := v.AuxInt
4189 x := v.Args[0]
4190 if !(!isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c))) {
4191 break
4192 }
4193 v.reset(OpARMANDconst)
4194 v.AuxInt = int64(int32(^uint32(c)))
4195 v.AddArg(x)
4196 return true
4197 }
4198
4199
4200
4201 for {
4202 c := v.AuxInt
4203 x := v.Args[0]
4204 if !(objabi.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && ^uint32(c) <= 0xffff) {
4205 break
4206 }
4207 v.reset(OpARMANDconst)
4208 v.AuxInt = int64(int32(^uint32(c)))
4209 v.AddArg(x)
4210 return true
4211 }
4212
4213
4214
4215 for {
4216 c := v.AuxInt
4217 v_0 := v.Args[0]
4218 if v_0.Op != OpARMMOVWconst {
4219 break
4220 }
4221 d := v_0.AuxInt
4222 v.reset(OpARMMOVWconst)
4223 v.AuxInt = d &^ c
4224 return true
4225 }
4226
4227
4228
4229 for {
4230 c := v.AuxInt
4231 v_0 := v.Args[0]
4232 if v_0.Op != OpARMBICconst {
4233 break
4234 }
4235 d := v_0.AuxInt
4236 x := v_0.Args[0]
4237 v.reset(OpARMBICconst)
4238 v.AuxInt = int64(int32(c | d))
4239 v.AddArg(x)
4240 return true
4241 }
4242 return false
4243 }
4244 func rewriteValueARM_OpARMBICshiftLL_0(v *Value) bool {
4245
4246
4247
4248 for {
4249 d := v.AuxInt
4250 _ = v.Args[1]
4251 x := v.Args[0]
4252 v_1 := v.Args[1]
4253 if v_1.Op != OpARMMOVWconst {
4254 break
4255 }
4256 c := v_1.AuxInt
4257 v.reset(OpARMBICconst)
4258 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
4259 v.AddArg(x)
4260 return true
4261 }
4262
4263
4264
4265 for {
4266 d := v.AuxInt
4267 _ = v.Args[1]
4268 x := v.Args[0]
4269 v_1 := v.Args[1]
4270 if v_1.Op != OpARMSLLconst {
4271 break
4272 }
4273 c := v_1.AuxInt
4274 if x != v_1.Args[0] {
4275 break
4276 }
4277 if !(c == d) {
4278 break
4279 }
4280 v.reset(OpARMMOVWconst)
4281 v.AuxInt = 0
4282 return true
4283 }
4284 return false
4285 }
4286 func rewriteValueARM_OpARMBICshiftLLreg_0(v *Value) bool {
4287
4288
4289
4290 for {
4291 _ = v.Args[2]
4292 x := v.Args[0]
4293 y := v.Args[1]
4294 v_2 := v.Args[2]
4295 if v_2.Op != OpARMMOVWconst {
4296 break
4297 }
4298 c := v_2.AuxInt
4299 v.reset(OpARMBICshiftLL)
4300 v.AuxInt = c
4301 v.AddArg(x)
4302 v.AddArg(y)
4303 return true
4304 }
4305 return false
4306 }
4307 func rewriteValueARM_OpARMBICshiftRA_0(v *Value) bool {
4308
4309
4310
4311 for {
4312 d := v.AuxInt
4313 _ = v.Args[1]
4314 x := v.Args[0]
4315 v_1 := v.Args[1]
4316 if v_1.Op != OpARMMOVWconst {
4317 break
4318 }
4319 c := v_1.AuxInt
4320 v.reset(OpARMBICconst)
4321 v.AuxInt = int64(int32(c) >> uint64(d))
4322 v.AddArg(x)
4323 return true
4324 }
4325
4326
4327
4328 for {
4329 d := v.AuxInt
4330 _ = v.Args[1]
4331 x := v.Args[0]
4332 v_1 := v.Args[1]
4333 if v_1.Op != OpARMSRAconst {
4334 break
4335 }
4336 c := v_1.AuxInt
4337 if x != v_1.Args[0] {
4338 break
4339 }
4340 if !(c == d) {
4341 break
4342 }
4343 v.reset(OpARMMOVWconst)
4344 v.AuxInt = 0
4345 return true
4346 }
4347 return false
4348 }
4349 func rewriteValueARM_OpARMBICshiftRAreg_0(v *Value) bool {
4350
4351
4352
4353 for {
4354 _ = v.Args[2]
4355 x := v.Args[0]
4356 y := v.Args[1]
4357 v_2 := v.Args[2]
4358 if v_2.Op != OpARMMOVWconst {
4359 break
4360 }
4361 c := v_2.AuxInt
4362 v.reset(OpARMBICshiftRA)
4363 v.AuxInt = c
4364 v.AddArg(x)
4365 v.AddArg(y)
4366 return true
4367 }
4368 return false
4369 }
4370 func rewriteValueARM_OpARMBICshiftRL_0(v *Value) bool {
4371
4372
4373
4374 for {
4375 d := v.AuxInt
4376 _ = v.Args[1]
4377 x := v.Args[0]
4378 v_1 := v.Args[1]
4379 if v_1.Op != OpARMMOVWconst {
4380 break
4381 }
4382 c := v_1.AuxInt
4383 v.reset(OpARMBICconst)
4384 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
4385 v.AddArg(x)
4386 return true
4387 }
4388
4389
4390
4391 for {
4392 d := v.AuxInt
4393 _ = v.Args[1]
4394 x := v.Args[0]
4395 v_1 := v.Args[1]
4396 if v_1.Op != OpARMSRLconst {
4397 break
4398 }
4399 c := v_1.AuxInt
4400 if x != v_1.Args[0] {
4401 break
4402 }
4403 if !(c == d) {
4404 break
4405 }
4406 v.reset(OpARMMOVWconst)
4407 v.AuxInt = 0
4408 return true
4409 }
4410 return false
4411 }
4412 func rewriteValueARM_OpARMBICshiftRLreg_0(v *Value) bool {
4413
4414
4415
4416 for {
4417 _ = v.Args[2]
4418 x := v.Args[0]
4419 y := v.Args[1]
4420 v_2 := v.Args[2]
4421 if v_2.Op != OpARMMOVWconst {
4422 break
4423 }
4424 c := v_2.AuxInt
4425 v.reset(OpARMBICshiftRL)
4426 v.AuxInt = c
4427 v.AddArg(x)
4428 v.AddArg(y)
4429 return true
4430 }
4431 return false
4432 }
4433 func rewriteValueARM_OpARMCMN_0(v *Value) bool {
4434
4435
4436
4437 for {
4438 _ = v.Args[1]
4439 x := v.Args[0]
4440 v_1 := v.Args[1]
4441 if v_1.Op != OpARMMOVWconst {
4442 break
4443 }
4444 c := v_1.AuxInt
4445 v.reset(OpARMCMNconst)
4446 v.AuxInt = c
4447 v.AddArg(x)
4448 return true
4449 }
4450
4451
4452
4453 for {
4454 x := v.Args[1]
4455 v_0 := v.Args[0]
4456 if v_0.Op != OpARMMOVWconst {
4457 break
4458 }
4459 c := v_0.AuxInt
4460 v.reset(OpARMCMNconst)
4461 v.AuxInt = c
4462 v.AddArg(x)
4463 return true
4464 }
4465
4466
4467
4468 for {
4469 _ = v.Args[1]
4470 x := v.Args[0]
4471 v_1 := v.Args[1]
4472 if v_1.Op != OpARMSLLconst {
4473 break
4474 }
4475 c := v_1.AuxInt
4476 y := v_1.Args[0]
4477 v.reset(OpARMCMNshiftLL)
4478 v.AuxInt = c
4479 v.AddArg(x)
4480 v.AddArg(y)
4481 return true
4482 }
4483
4484
4485
4486 for {
4487 x := v.Args[1]
4488 v_0 := v.Args[0]
4489 if v_0.Op != OpARMSLLconst {
4490 break
4491 }
4492 c := v_0.AuxInt
4493 y := v_0.Args[0]
4494 v.reset(OpARMCMNshiftLL)
4495 v.AuxInt = c
4496 v.AddArg(x)
4497 v.AddArg(y)
4498 return true
4499 }
4500
4501
4502
4503 for {
4504 _ = v.Args[1]
4505 x := v.Args[0]
4506 v_1 := v.Args[1]
4507 if v_1.Op != OpARMSRLconst {
4508 break
4509 }
4510 c := v_1.AuxInt
4511 y := v_1.Args[0]
4512 v.reset(OpARMCMNshiftRL)
4513 v.AuxInt = c
4514 v.AddArg(x)
4515 v.AddArg(y)
4516 return true
4517 }
4518
4519
4520
4521 for {
4522 x := v.Args[1]
4523 v_0 := v.Args[0]
4524 if v_0.Op != OpARMSRLconst {
4525 break
4526 }
4527 c := v_0.AuxInt
4528 y := v_0.Args[0]
4529 v.reset(OpARMCMNshiftRL)
4530 v.AuxInt = c
4531 v.AddArg(x)
4532 v.AddArg(y)
4533 return true
4534 }
4535
4536
4537
4538 for {
4539 _ = v.Args[1]
4540 x := v.Args[0]
4541 v_1 := v.Args[1]
4542 if v_1.Op != OpARMSRAconst {
4543 break
4544 }
4545 c := v_1.AuxInt
4546 y := v_1.Args[0]
4547 v.reset(OpARMCMNshiftRA)
4548 v.AuxInt = c
4549 v.AddArg(x)
4550 v.AddArg(y)
4551 return true
4552 }
4553
4554
4555
4556 for {
4557 x := v.Args[1]
4558 v_0 := v.Args[0]
4559 if v_0.Op != OpARMSRAconst {
4560 break
4561 }
4562 c := v_0.AuxInt
4563 y := v_0.Args[0]
4564 v.reset(OpARMCMNshiftRA)
4565 v.AuxInt = c
4566 v.AddArg(x)
4567 v.AddArg(y)
4568 return true
4569 }
4570
4571
4572
4573 for {
4574 _ = v.Args[1]
4575 x := v.Args[0]
4576 v_1 := v.Args[1]
4577 if v_1.Op != OpARMSLL {
4578 break
4579 }
4580 z := v_1.Args[1]
4581 y := v_1.Args[0]
4582 v.reset(OpARMCMNshiftLLreg)
4583 v.AddArg(x)
4584 v.AddArg(y)
4585 v.AddArg(z)
4586 return true
4587 }
4588
4589
4590
4591 for {
4592 x := v.Args[1]
4593 v_0 := v.Args[0]
4594 if v_0.Op != OpARMSLL {
4595 break
4596 }
4597 z := v_0.Args[1]
4598 y := v_0.Args[0]
4599 v.reset(OpARMCMNshiftLLreg)
4600 v.AddArg(x)
4601 v.AddArg(y)
4602 v.AddArg(z)
4603 return true
4604 }
4605 return false
4606 }
4607 func rewriteValueARM_OpARMCMN_10(v *Value) bool {
4608
4609
4610
4611 for {
4612 _ = v.Args[1]
4613 x := v.Args[0]
4614 v_1 := v.Args[1]
4615 if v_1.Op != OpARMSRL {
4616 break
4617 }
4618 z := v_1.Args[1]
4619 y := v_1.Args[0]
4620 v.reset(OpARMCMNshiftRLreg)
4621 v.AddArg(x)
4622 v.AddArg(y)
4623 v.AddArg(z)
4624 return true
4625 }
4626
4627
4628
4629 for {
4630 x := v.Args[1]
4631 v_0 := v.Args[0]
4632 if v_0.Op != OpARMSRL {
4633 break
4634 }
4635 z := v_0.Args[1]
4636 y := v_0.Args[0]
4637 v.reset(OpARMCMNshiftRLreg)
4638 v.AddArg(x)
4639 v.AddArg(y)
4640 v.AddArg(z)
4641 return true
4642 }
4643
4644
4645
4646 for {
4647 _ = v.Args[1]
4648 x := v.Args[0]
4649 v_1 := v.Args[1]
4650 if v_1.Op != OpARMSRA {
4651 break
4652 }
4653 z := v_1.Args[1]
4654 y := v_1.Args[0]
4655 v.reset(OpARMCMNshiftRAreg)
4656 v.AddArg(x)
4657 v.AddArg(y)
4658 v.AddArg(z)
4659 return true
4660 }
4661
4662
4663
4664 for {
4665 x := v.Args[1]
4666 v_0 := v.Args[0]
4667 if v_0.Op != OpARMSRA {
4668 break
4669 }
4670 z := v_0.Args[1]
4671 y := v_0.Args[0]
4672 v.reset(OpARMCMNshiftRAreg)
4673 v.AddArg(x)
4674 v.AddArg(y)
4675 v.AddArg(z)
4676 return true
4677 }
4678
4679
4680
4681 for {
4682 _ = v.Args[1]
4683 x := v.Args[0]
4684 v_1 := v.Args[1]
4685 if v_1.Op != OpARMRSBconst {
4686 break
4687 }
4688 if v_1.AuxInt != 0 {
4689 break
4690 }
4691 y := v_1.Args[0]
4692 v.reset(OpARMCMP)
4693 v.AddArg(x)
4694 v.AddArg(y)
4695 return true
4696 }
4697
4698
4699
4700 for {
4701 x := v.Args[1]
4702 v_0 := v.Args[0]
4703 if v_0.Op != OpARMRSBconst {
4704 break
4705 }
4706 if v_0.AuxInt != 0 {
4707 break
4708 }
4709 y := v_0.Args[0]
4710 v.reset(OpARMCMP)
4711 v.AddArg(x)
4712 v.AddArg(y)
4713 return true
4714 }
4715 return false
4716 }
4717 func rewriteValueARM_OpARMCMNconst_0(v *Value) bool {
4718
4719
4720
4721 for {
4722 y := v.AuxInt
4723 v_0 := v.Args[0]
4724 if v_0.Op != OpARMMOVWconst {
4725 break
4726 }
4727 x := v_0.AuxInt
4728 if !(int32(x) == int32(-y)) {
4729 break
4730 }
4731 v.reset(OpARMFlagEQ)
4732 return true
4733 }
4734
4735
4736
4737 for {
4738 y := v.AuxInt
4739 v_0 := v.Args[0]
4740 if v_0.Op != OpARMMOVWconst {
4741 break
4742 }
4743 x := v_0.AuxInt
4744 if !(int32(x) < int32(-y) && uint32(x) < uint32(-y)) {
4745 break
4746 }
4747 v.reset(OpARMFlagLT_ULT)
4748 return true
4749 }
4750
4751
4752
4753 for {
4754 y := v.AuxInt
4755 v_0 := v.Args[0]
4756 if v_0.Op != OpARMMOVWconst {
4757 break
4758 }
4759 x := v_0.AuxInt
4760 if !(int32(x) < int32(-y) && uint32(x) > uint32(-y)) {
4761 break
4762 }
4763 v.reset(OpARMFlagLT_UGT)
4764 return true
4765 }
4766
4767
4768
4769 for {
4770 y := v.AuxInt
4771 v_0 := v.Args[0]
4772 if v_0.Op != OpARMMOVWconst {
4773 break
4774 }
4775 x := v_0.AuxInt
4776 if !(int32(x) > int32(-y) && uint32(x) < uint32(-y)) {
4777 break
4778 }
4779 v.reset(OpARMFlagGT_ULT)
4780 return true
4781 }
4782
4783
4784
4785 for {
4786 y := v.AuxInt
4787 v_0 := v.Args[0]
4788 if v_0.Op != OpARMMOVWconst {
4789 break
4790 }
4791 x := v_0.AuxInt
4792 if !(int32(x) > int32(-y) && uint32(x) > uint32(-y)) {
4793 break
4794 }
4795 v.reset(OpARMFlagGT_UGT)
4796 return true
4797 }
4798 return false
4799 }
4800 func rewriteValueARM_OpARMCMNshiftLL_0(v *Value) bool {
4801 b := v.Block
4802
4803
4804
4805 for {
4806 d := v.AuxInt
4807 x := v.Args[1]
4808 v_0 := v.Args[0]
4809 if v_0.Op != OpARMMOVWconst {
4810 break
4811 }
4812 c := v_0.AuxInt
4813 v.reset(OpARMCMNconst)
4814 v.AuxInt = c
4815 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
4816 v0.AuxInt = d
4817 v0.AddArg(x)
4818 v.AddArg(v0)
4819 return true
4820 }
4821
4822
4823
4824 for {
4825 d := v.AuxInt
4826 _ = v.Args[1]
4827 x := v.Args[0]
4828 v_1 := v.Args[1]
4829 if v_1.Op != OpARMMOVWconst {
4830 break
4831 }
4832 c := v_1.AuxInt
4833 v.reset(OpARMCMNconst)
4834 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
4835 v.AddArg(x)
4836 return true
4837 }
4838 return false
4839 }
4840 func rewriteValueARM_OpARMCMNshiftLLreg_0(v *Value) bool {
4841 b := v.Block
4842
4843
4844
4845 for {
4846 y := v.Args[2]
4847 v_0 := v.Args[0]
4848 if v_0.Op != OpARMMOVWconst {
4849 break
4850 }
4851 c := v_0.AuxInt
4852 x := v.Args[1]
4853 v.reset(OpARMCMNconst)
4854 v.AuxInt = c
4855 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
4856 v0.AddArg(x)
4857 v0.AddArg(y)
4858 v.AddArg(v0)
4859 return true
4860 }
4861
4862
4863
4864 for {
4865 _ = v.Args[2]
4866 x := v.Args[0]
4867 y := v.Args[1]
4868 v_2 := v.Args[2]
4869 if v_2.Op != OpARMMOVWconst {
4870 break
4871 }
4872 c := v_2.AuxInt
4873 v.reset(OpARMCMNshiftLL)
4874 v.AuxInt = c
4875 v.AddArg(x)
4876 v.AddArg(y)
4877 return true
4878 }
4879 return false
4880 }
4881 func rewriteValueARM_OpARMCMNshiftRA_0(v *Value) bool {
4882 b := v.Block
4883
4884
4885
4886 for {
4887 d := v.AuxInt
4888 x := v.Args[1]
4889 v_0 := v.Args[0]
4890 if v_0.Op != OpARMMOVWconst {
4891 break
4892 }
4893 c := v_0.AuxInt
4894 v.reset(OpARMCMNconst)
4895 v.AuxInt = c
4896 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
4897 v0.AuxInt = d
4898 v0.AddArg(x)
4899 v.AddArg(v0)
4900 return true
4901 }
4902
4903
4904
4905 for {
4906 d := v.AuxInt
4907 _ = v.Args[1]
4908 x := v.Args[0]
4909 v_1 := v.Args[1]
4910 if v_1.Op != OpARMMOVWconst {
4911 break
4912 }
4913 c := v_1.AuxInt
4914 v.reset(OpARMCMNconst)
4915 v.AuxInt = int64(int32(c) >> uint64(d))
4916 v.AddArg(x)
4917 return true
4918 }
4919 return false
4920 }
4921 func rewriteValueARM_OpARMCMNshiftRAreg_0(v *Value) bool {
4922 b := v.Block
4923
4924
4925
4926 for {
4927 y := v.Args[2]
4928 v_0 := v.Args[0]
4929 if v_0.Op != OpARMMOVWconst {
4930 break
4931 }
4932 c := v_0.AuxInt
4933 x := v.Args[1]
4934 v.reset(OpARMCMNconst)
4935 v.AuxInt = c
4936 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
4937 v0.AddArg(x)
4938 v0.AddArg(y)
4939 v.AddArg(v0)
4940 return true
4941 }
4942
4943
4944
4945 for {
4946 _ = v.Args[2]
4947 x := v.Args[0]
4948 y := v.Args[1]
4949 v_2 := v.Args[2]
4950 if v_2.Op != OpARMMOVWconst {
4951 break
4952 }
4953 c := v_2.AuxInt
4954 v.reset(OpARMCMNshiftRA)
4955 v.AuxInt = c
4956 v.AddArg(x)
4957 v.AddArg(y)
4958 return true
4959 }
4960 return false
4961 }
4962 func rewriteValueARM_OpARMCMNshiftRL_0(v *Value) bool {
4963 b := v.Block
4964
4965
4966
4967 for {
4968 d := v.AuxInt
4969 x := v.Args[1]
4970 v_0 := v.Args[0]
4971 if v_0.Op != OpARMMOVWconst {
4972 break
4973 }
4974 c := v_0.AuxInt
4975 v.reset(OpARMCMNconst)
4976 v.AuxInt = c
4977 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
4978 v0.AuxInt = d
4979 v0.AddArg(x)
4980 v.AddArg(v0)
4981 return true
4982 }
4983
4984
4985
4986 for {
4987 d := v.AuxInt
4988 _ = v.Args[1]
4989 x := v.Args[0]
4990 v_1 := v.Args[1]
4991 if v_1.Op != OpARMMOVWconst {
4992 break
4993 }
4994 c := v_1.AuxInt
4995 v.reset(OpARMCMNconst)
4996 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
4997 v.AddArg(x)
4998 return true
4999 }
5000 return false
5001 }
5002 func rewriteValueARM_OpARMCMNshiftRLreg_0(v *Value) bool {
5003 b := v.Block
5004
5005
5006
5007 for {
5008 y := v.Args[2]
5009 v_0 := v.Args[0]
5010 if v_0.Op != OpARMMOVWconst {
5011 break
5012 }
5013 c := v_0.AuxInt
5014 x := v.Args[1]
5015 v.reset(OpARMCMNconst)
5016 v.AuxInt = c
5017 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
5018 v0.AddArg(x)
5019 v0.AddArg(y)
5020 v.AddArg(v0)
5021 return true
5022 }
5023
5024
5025
5026 for {
5027 _ = v.Args[2]
5028 x := v.Args[0]
5029 y := v.Args[1]
5030 v_2 := v.Args[2]
5031 if v_2.Op != OpARMMOVWconst {
5032 break
5033 }
5034 c := v_2.AuxInt
5035 v.reset(OpARMCMNshiftRL)
5036 v.AuxInt = c
5037 v.AddArg(x)
5038 v.AddArg(y)
5039 return true
5040 }
5041 return false
5042 }
5043 func rewriteValueARM_OpARMCMOVWHSconst_0(v *Value) bool {
5044
5045
5046
5047 for {
5048 c := v.AuxInt
5049 _ = v.Args[1]
5050 v_1 := v.Args[1]
5051 if v_1.Op != OpARMFlagEQ {
5052 break
5053 }
5054 v.reset(OpARMMOVWconst)
5055 v.AuxInt = c
5056 return true
5057 }
5058
5059
5060
5061 for {
5062 _ = v.Args[1]
5063 x := v.Args[0]
5064 v_1 := v.Args[1]
5065 if v_1.Op != OpARMFlagLT_ULT {
5066 break
5067 }
5068 v.reset(OpCopy)
5069 v.Type = x.Type
5070 v.AddArg(x)
5071 return true
5072 }
5073
5074
5075
5076 for {
5077 c := v.AuxInt
5078 _ = v.Args[1]
5079 v_1 := v.Args[1]
5080 if v_1.Op != OpARMFlagLT_UGT {
5081 break
5082 }
5083 v.reset(OpARMMOVWconst)
5084 v.AuxInt = c
5085 return true
5086 }
5087
5088
5089
5090 for {
5091 _ = v.Args[1]
5092 x := v.Args[0]
5093 v_1 := v.Args[1]
5094 if v_1.Op != OpARMFlagGT_ULT {
5095 break
5096 }
5097 v.reset(OpCopy)
5098 v.Type = x.Type
5099 v.AddArg(x)
5100 return true
5101 }
5102
5103
5104
5105 for {
5106 c := v.AuxInt
5107 _ = v.Args[1]
5108 v_1 := v.Args[1]
5109 if v_1.Op != OpARMFlagGT_UGT {
5110 break
5111 }
5112 v.reset(OpARMMOVWconst)
5113 v.AuxInt = c
5114 return true
5115 }
5116
5117
5118
5119 for {
5120 c := v.AuxInt
5121 _ = v.Args[1]
5122 x := v.Args[0]
5123 v_1 := v.Args[1]
5124 if v_1.Op != OpARMInvertFlags {
5125 break
5126 }
5127 flags := v_1.Args[0]
5128 v.reset(OpARMCMOVWLSconst)
5129 v.AuxInt = c
5130 v.AddArg(x)
5131 v.AddArg(flags)
5132 return true
5133 }
5134 return false
5135 }
5136 func rewriteValueARM_OpARMCMOVWLSconst_0(v *Value) bool {
5137
5138
5139
5140 for {
5141 c := v.AuxInt
5142 _ = v.Args[1]
5143 v_1 := v.Args[1]
5144 if v_1.Op != OpARMFlagEQ {
5145 break
5146 }
5147 v.reset(OpARMMOVWconst)
5148 v.AuxInt = c
5149 return true
5150 }
5151
5152
5153
5154 for {
5155 c := v.AuxInt
5156 _ = v.Args[1]
5157 v_1 := v.Args[1]
5158 if v_1.Op != OpARMFlagLT_ULT {
5159 break
5160 }
5161 v.reset(OpARMMOVWconst)
5162 v.AuxInt = c
5163 return true
5164 }
5165
5166
5167
5168 for {
5169 _ = v.Args[1]
5170 x := v.Args[0]
5171 v_1 := v.Args[1]
5172 if v_1.Op != OpARMFlagLT_UGT {
5173 break
5174 }
5175 v.reset(OpCopy)
5176 v.Type = x.Type
5177 v.AddArg(x)
5178 return true
5179 }
5180
5181
5182
5183 for {
5184 c := v.AuxInt
5185 _ = v.Args[1]
5186 v_1 := v.Args[1]
5187 if v_1.Op != OpARMFlagGT_ULT {
5188 break
5189 }
5190 v.reset(OpARMMOVWconst)
5191 v.AuxInt = c
5192 return true
5193 }
5194
5195
5196
5197 for {
5198 _ = v.Args[1]
5199 x := v.Args[0]
5200 v_1 := v.Args[1]
5201 if v_1.Op != OpARMFlagGT_UGT {
5202 break
5203 }
5204 v.reset(OpCopy)
5205 v.Type = x.Type
5206 v.AddArg(x)
5207 return true
5208 }
5209
5210
5211
5212 for {
5213 c := v.AuxInt
5214 _ = v.Args[1]
5215 x := v.Args[0]
5216 v_1 := v.Args[1]
5217 if v_1.Op != OpARMInvertFlags {
5218 break
5219 }
5220 flags := v_1.Args[0]
5221 v.reset(OpARMCMOVWHSconst)
5222 v.AuxInt = c
5223 v.AddArg(x)
5224 v.AddArg(flags)
5225 return true
5226 }
5227 return false
5228 }
5229 func rewriteValueARM_OpARMCMP_0(v *Value) bool {
5230 b := v.Block
5231
5232
5233
5234 for {
5235 _ = v.Args[1]
5236 x := v.Args[0]
5237 v_1 := v.Args[1]
5238 if v_1.Op != OpARMMOVWconst {
5239 break
5240 }
5241 c := v_1.AuxInt
5242 v.reset(OpARMCMPconst)
5243 v.AuxInt = c
5244 v.AddArg(x)
5245 return true
5246 }
5247
5248
5249
5250 for {
5251 x := v.Args[1]
5252 v_0 := v.Args[0]
5253 if v_0.Op != OpARMMOVWconst {
5254 break
5255 }
5256 c := v_0.AuxInt
5257 v.reset(OpARMInvertFlags)
5258 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
5259 v0.AuxInt = c
5260 v0.AddArg(x)
5261 v.AddArg(v0)
5262 return true
5263 }
5264
5265
5266
5267 for {
5268 _ = v.Args[1]
5269 x := v.Args[0]
5270 v_1 := v.Args[1]
5271 if v_1.Op != OpARMSLLconst {
5272 break
5273 }
5274 c := v_1.AuxInt
5275 y := v_1.Args[0]
5276 v.reset(OpARMCMPshiftLL)
5277 v.AuxInt = c
5278 v.AddArg(x)
5279 v.AddArg(y)
5280 return true
5281 }
5282
5283
5284
5285 for {
5286 x := v.Args[1]
5287 v_0 := v.Args[0]
5288 if v_0.Op != OpARMSLLconst {
5289 break
5290 }
5291 c := v_0.AuxInt
5292 y := v_0.Args[0]
5293 v.reset(OpARMInvertFlags)
5294 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags)
5295 v0.AuxInt = c
5296 v0.AddArg(x)
5297 v0.AddArg(y)
5298 v.AddArg(v0)
5299 return true
5300 }
5301
5302
5303
5304 for {
5305 _ = v.Args[1]
5306 x := v.Args[0]
5307 v_1 := v.Args[1]
5308 if v_1.Op != OpARMSRLconst {
5309 break
5310 }
5311 c := v_1.AuxInt
5312 y := v_1.Args[0]
5313 v.reset(OpARMCMPshiftRL)
5314 v.AuxInt = c
5315 v.AddArg(x)
5316 v.AddArg(y)
5317 return true
5318 }
5319
5320
5321
5322 for {
5323 x := v.Args[1]
5324 v_0 := v.Args[0]
5325 if v_0.Op != OpARMSRLconst {
5326 break
5327 }
5328 c := v_0.AuxInt
5329 y := v_0.Args[0]
5330 v.reset(OpARMInvertFlags)
5331 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags)
5332 v0.AuxInt = c
5333 v0.AddArg(x)
5334 v0.AddArg(y)
5335 v.AddArg(v0)
5336 return true
5337 }
5338
5339
5340
5341 for {
5342 _ = v.Args[1]
5343 x := v.Args[0]
5344 v_1 := v.Args[1]
5345 if v_1.Op != OpARMSRAconst {
5346 break
5347 }
5348 c := v_1.AuxInt
5349 y := v_1.Args[0]
5350 v.reset(OpARMCMPshiftRA)
5351 v.AuxInt = c
5352 v.AddArg(x)
5353 v.AddArg(y)
5354 return true
5355 }
5356
5357
5358
5359 for {
5360 x := v.Args[1]
5361 v_0 := v.Args[0]
5362 if v_0.Op != OpARMSRAconst {
5363 break
5364 }
5365 c := v_0.AuxInt
5366 y := v_0.Args[0]
5367 v.reset(OpARMInvertFlags)
5368 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags)
5369 v0.AuxInt = c
5370 v0.AddArg(x)
5371 v0.AddArg(y)
5372 v.AddArg(v0)
5373 return true
5374 }
5375
5376
5377
5378 for {
5379 _ = v.Args[1]
5380 x := v.Args[0]
5381 v_1 := v.Args[1]
5382 if v_1.Op != OpARMSLL {
5383 break
5384 }
5385 z := v_1.Args[1]
5386 y := v_1.Args[0]
5387 v.reset(OpARMCMPshiftLLreg)
5388 v.AddArg(x)
5389 v.AddArg(y)
5390 v.AddArg(z)
5391 return true
5392 }
5393
5394
5395
5396 for {
5397 x := v.Args[1]
5398 v_0 := v.Args[0]
5399 if v_0.Op != OpARMSLL {
5400 break
5401 }
5402 z := v_0.Args[1]
5403 y := v_0.Args[0]
5404 v.reset(OpARMInvertFlags)
5405 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
5406 v0.AddArg(x)
5407 v0.AddArg(y)
5408 v0.AddArg(z)
5409 v.AddArg(v0)
5410 return true
5411 }
5412 return false
5413 }
5414 func rewriteValueARM_OpARMCMP_10(v *Value) bool {
5415 b := v.Block
5416
5417
5418
5419 for {
5420 _ = v.Args[1]
5421 x := v.Args[0]
5422 v_1 := v.Args[1]
5423 if v_1.Op != OpARMSRL {
5424 break
5425 }
5426 z := v_1.Args[1]
5427 y := v_1.Args[0]
5428 v.reset(OpARMCMPshiftRLreg)
5429 v.AddArg(x)
5430 v.AddArg(y)
5431 v.AddArg(z)
5432 return true
5433 }
5434
5435
5436
5437 for {
5438 x := v.Args[1]
5439 v_0 := v.Args[0]
5440 if v_0.Op != OpARMSRL {
5441 break
5442 }
5443 z := v_0.Args[1]
5444 y := v_0.Args[0]
5445 v.reset(OpARMInvertFlags)
5446 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
5447 v0.AddArg(x)
5448 v0.AddArg(y)
5449 v0.AddArg(z)
5450 v.AddArg(v0)
5451 return true
5452 }
5453
5454
5455
5456 for {
5457 _ = v.Args[1]
5458 x := v.Args[0]
5459 v_1 := v.Args[1]
5460 if v_1.Op != OpARMSRA {
5461 break
5462 }
5463 z := v_1.Args[1]
5464 y := v_1.Args[0]
5465 v.reset(OpARMCMPshiftRAreg)
5466 v.AddArg(x)
5467 v.AddArg(y)
5468 v.AddArg(z)
5469 return true
5470 }
5471
5472
5473
5474 for {
5475 x := v.Args[1]
5476 v_0 := v.Args[0]
5477 if v_0.Op != OpARMSRA {
5478 break
5479 }
5480 z := v_0.Args[1]
5481 y := v_0.Args[0]
5482 v.reset(OpARMInvertFlags)
5483 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
5484 v0.AddArg(x)
5485 v0.AddArg(y)
5486 v0.AddArg(z)
5487 v.AddArg(v0)
5488 return true
5489 }
5490
5491
5492
5493 for {
5494 _ = v.Args[1]
5495 x := v.Args[0]
5496 v_1 := v.Args[1]
5497 if v_1.Op != OpARMRSBconst {
5498 break
5499 }
5500 if v_1.AuxInt != 0 {
5501 break
5502 }
5503 y := v_1.Args[0]
5504 v.reset(OpARMCMN)
5505 v.AddArg(x)
5506 v.AddArg(y)
5507 return true
5508 }
5509 return false
5510 }
5511 func rewriteValueARM_OpARMCMPD_0(v *Value) bool {
5512
5513
5514
5515 for {
5516 _ = v.Args[1]
5517 x := v.Args[0]
5518 v_1 := v.Args[1]
5519 if v_1.Op != OpARMMOVDconst {
5520 break
5521 }
5522 if v_1.AuxInt != 0 {
5523 break
5524 }
5525 v.reset(OpARMCMPD0)
5526 v.AddArg(x)
5527 return true
5528 }
5529 return false
5530 }
5531 func rewriteValueARM_OpARMCMPF_0(v *Value) bool {
5532
5533
5534
5535 for {
5536 _ = v.Args[1]
5537 x := v.Args[0]
5538 v_1 := v.Args[1]
5539 if v_1.Op != OpARMMOVFconst {
5540 break
5541 }
5542 if v_1.AuxInt != 0 {
5543 break
5544 }
5545 v.reset(OpARMCMPF0)
5546 v.AddArg(x)
5547 return true
5548 }
5549 return false
5550 }
5551 func rewriteValueARM_OpARMCMPconst_0(v *Value) bool {
5552
5553
5554
5555 for {
5556 y := v.AuxInt
5557 v_0 := v.Args[0]
5558 if v_0.Op != OpARMMOVWconst {
5559 break
5560 }
5561 x := v_0.AuxInt
5562 if !(int32(x) == int32(y)) {
5563 break
5564 }
5565 v.reset(OpARMFlagEQ)
5566 return true
5567 }
5568
5569
5570
5571 for {
5572 y := v.AuxInt
5573 v_0 := v.Args[0]
5574 if v_0.Op != OpARMMOVWconst {
5575 break
5576 }
5577 x := v_0.AuxInt
5578 if !(int32(x) < int32(y) && uint32(x) < uint32(y)) {
5579 break
5580 }
5581 v.reset(OpARMFlagLT_ULT)
5582 return true
5583 }
5584
5585
5586
5587 for {
5588 y := v.AuxInt
5589 v_0 := v.Args[0]
5590 if v_0.Op != OpARMMOVWconst {
5591 break
5592 }
5593 x := v_0.AuxInt
5594 if !(int32(x) < int32(y) && uint32(x) > uint32(y)) {
5595 break
5596 }
5597 v.reset(OpARMFlagLT_UGT)
5598 return true
5599 }
5600
5601
5602
5603 for {
5604 y := v.AuxInt
5605 v_0 := v.Args[0]
5606 if v_0.Op != OpARMMOVWconst {
5607 break
5608 }
5609 x := v_0.AuxInt
5610 if !(int32(x) > int32(y) && uint32(x) < uint32(y)) {
5611 break
5612 }
5613 v.reset(OpARMFlagGT_ULT)
5614 return true
5615 }
5616
5617
5618
5619 for {
5620 y := v.AuxInt
5621 v_0 := v.Args[0]
5622 if v_0.Op != OpARMMOVWconst {
5623 break
5624 }
5625 x := v_0.AuxInt
5626 if !(int32(x) > int32(y) && uint32(x) > uint32(y)) {
5627 break
5628 }
5629 v.reset(OpARMFlagGT_UGT)
5630 return true
5631 }
5632
5633
5634
5635 for {
5636 c := v.AuxInt
5637 v_0 := v.Args[0]
5638 if v_0.Op != OpARMMOVBUreg {
5639 break
5640 }
5641 if !(0xff < c) {
5642 break
5643 }
5644 v.reset(OpARMFlagLT_ULT)
5645 return true
5646 }
5647
5648
5649
5650 for {
5651 c := v.AuxInt
5652 v_0 := v.Args[0]
5653 if v_0.Op != OpARMMOVHUreg {
5654 break
5655 }
5656 if !(0xffff < c) {
5657 break
5658 }
5659 v.reset(OpARMFlagLT_ULT)
5660 return true
5661 }
5662
5663
5664
5665 for {
5666 n := v.AuxInt
5667 v_0 := v.Args[0]
5668 if v_0.Op != OpARMANDconst {
5669 break
5670 }
5671 m := v_0.AuxInt
5672 if !(0 <= int32(m) && int32(m) < int32(n)) {
5673 break
5674 }
5675 v.reset(OpARMFlagLT_ULT)
5676 return true
5677 }
5678
5679
5680
5681 for {
5682 n := v.AuxInt
5683 v_0 := v.Args[0]
5684 if v_0.Op != OpARMSRLconst {
5685 break
5686 }
5687 c := v_0.AuxInt
5688 if !(0 <= n && 0 < c && c <= 32 && (1<<uint32(32-c)) <= uint32(n)) {
5689 break
5690 }
5691 v.reset(OpARMFlagLT_ULT)
5692 return true
5693 }
5694 return false
5695 }
5696 func rewriteValueARM_OpARMCMPshiftLL_0(v *Value) bool {
5697 b := v.Block
5698
5699
5700
5701 for {
5702 d := v.AuxInt
5703 x := v.Args[1]
5704 v_0 := v.Args[0]
5705 if v_0.Op != OpARMMOVWconst {
5706 break
5707 }
5708 c := v_0.AuxInt
5709 v.reset(OpARMInvertFlags)
5710 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
5711 v0.AuxInt = c
5712 v1 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
5713 v1.AuxInt = d
5714 v1.AddArg(x)
5715 v0.AddArg(v1)
5716 v.AddArg(v0)
5717 return true
5718 }
5719
5720
5721
5722 for {
5723 d := v.AuxInt
5724 _ = v.Args[1]
5725 x := v.Args[0]
5726 v_1 := v.Args[1]
5727 if v_1.Op != OpARMMOVWconst {
5728 break
5729 }
5730 c := v_1.AuxInt
5731 v.reset(OpARMCMPconst)
5732 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
5733 v.AddArg(x)
5734 return true
5735 }
5736 return false
5737 }
5738 func rewriteValueARM_OpARMCMPshiftLLreg_0(v *Value) bool {
5739 b := v.Block
5740
5741
5742
5743 for {
5744 y := v.Args[2]
5745 v_0 := v.Args[0]
5746 if v_0.Op != OpARMMOVWconst {
5747 break
5748 }
5749 c := v_0.AuxInt
5750 x := v.Args[1]
5751 v.reset(OpARMInvertFlags)
5752 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
5753 v0.AuxInt = c
5754 v1 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
5755 v1.AddArg(x)
5756 v1.AddArg(y)
5757 v0.AddArg(v1)
5758 v.AddArg(v0)
5759 return true
5760 }
5761
5762
5763
5764 for {
5765 _ = v.Args[2]
5766 x := v.Args[0]
5767 y := v.Args[1]
5768 v_2 := v.Args[2]
5769 if v_2.Op != OpARMMOVWconst {
5770 break
5771 }
5772 c := v_2.AuxInt
5773 v.reset(OpARMCMPshiftLL)
5774 v.AuxInt = c
5775 v.AddArg(x)
5776 v.AddArg(y)
5777 return true
5778 }
5779 return false
5780 }
5781 func rewriteValueARM_OpARMCMPshiftRA_0(v *Value) bool {
5782 b := v.Block
5783
5784
5785
5786 for {
5787 d := v.AuxInt
5788 x := v.Args[1]
5789 v_0 := v.Args[0]
5790 if v_0.Op != OpARMMOVWconst {
5791 break
5792 }
5793 c := v_0.AuxInt
5794 v.reset(OpARMInvertFlags)
5795 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
5796 v0.AuxInt = c
5797 v1 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
5798 v1.AuxInt = d
5799 v1.AddArg(x)
5800 v0.AddArg(v1)
5801 v.AddArg(v0)
5802 return true
5803 }
5804
5805
5806
5807 for {
5808 d := v.AuxInt
5809 _ = v.Args[1]
5810 x := v.Args[0]
5811 v_1 := v.Args[1]
5812 if v_1.Op != OpARMMOVWconst {
5813 break
5814 }
5815 c := v_1.AuxInt
5816 v.reset(OpARMCMPconst)
5817 v.AuxInt = int64(int32(c) >> uint64(d))
5818 v.AddArg(x)
5819 return true
5820 }
5821 return false
5822 }
5823 func rewriteValueARM_OpARMCMPshiftRAreg_0(v *Value) bool {
5824 b := v.Block
5825
5826
5827
5828 for {
5829 y := v.Args[2]
5830 v_0 := v.Args[0]
5831 if v_0.Op != OpARMMOVWconst {
5832 break
5833 }
5834 c := v_0.AuxInt
5835 x := v.Args[1]
5836 v.reset(OpARMInvertFlags)
5837 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
5838 v0.AuxInt = c
5839 v1 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
5840 v1.AddArg(x)
5841 v1.AddArg(y)
5842 v0.AddArg(v1)
5843 v.AddArg(v0)
5844 return true
5845 }
5846
5847
5848
5849 for {
5850 _ = v.Args[2]
5851 x := v.Args[0]
5852 y := v.Args[1]
5853 v_2 := v.Args[2]
5854 if v_2.Op != OpARMMOVWconst {
5855 break
5856 }
5857 c := v_2.AuxInt
5858 v.reset(OpARMCMPshiftRA)
5859 v.AuxInt = c
5860 v.AddArg(x)
5861 v.AddArg(y)
5862 return true
5863 }
5864 return false
5865 }
5866 func rewriteValueARM_OpARMCMPshiftRL_0(v *Value) bool {
5867 b := v.Block
5868
5869
5870
5871 for {
5872 d := v.AuxInt
5873 x := v.Args[1]
5874 v_0 := v.Args[0]
5875 if v_0.Op != OpARMMOVWconst {
5876 break
5877 }
5878 c := v_0.AuxInt
5879 v.reset(OpARMInvertFlags)
5880 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
5881 v0.AuxInt = c
5882 v1 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
5883 v1.AuxInt = d
5884 v1.AddArg(x)
5885 v0.AddArg(v1)
5886 v.AddArg(v0)
5887 return true
5888 }
5889
5890
5891
5892 for {
5893 d := v.AuxInt
5894 _ = v.Args[1]
5895 x := v.Args[0]
5896 v_1 := v.Args[1]
5897 if v_1.Op != OpARMMOVWconst {
5898 break
5899 }
5900 c := v_1.AuxInt
5901 v.reset(OpARMCMPconst)
5902 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
5903 v.AddArg(x)
5904 return true
5905 }
5906 return false
5907 }
5908 func rewriteValueARM_OpARMCMPshiftRLreg_0(v *Value) bool {
5909 b := v.Block
5910
5911
5912
5913 for {
5914 y := v.Args[2]
5915 v_0 := v.Args[0]
5916 if v_0.Op != OpARMMOVWconst {
5917 break
5918 }
5919 c := v_0.AuxInt
5920 x := v.Args[1]
5921 v.reset(OpARMInvertFlags)
5922 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
5923 v0.AuxInt = c
5924 v1 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
5925 v1.AddArg(x)
5926 v1.AddArg(y)
5927 v0.AddArg(v1)
5928 v.AddArg(v0)
5929 return true
5930 }
5931
5932
5933
5934 for {
5935 _ = v.Args[2]
5936 x := v.Args[0]
5937 y := v.Args[1]
5938 v_2 := v.Args[2]
5939 if v_2.Op != OpARMMOVWconst {
5940 break
5941 }
5942 c := v_2.AuxInt
5943 v.reset(OpARMCMPshiftRL)
5944 v.AuxInt = c
5945 v.AddArg(x)
5946 v.AddArg(y)
5947 return true
5948 }
5949 return false
5950 }
5951 func rewriteValueARM_OpARMEqual_0(v *Value) bool {
5952
5953
5954
5955 for {
5956 v_0 := v.Args[0]
5957 if v_0.Op != OpARMFlagEQ {
5958 break
5959 }
5960 v.reset(OpARMMOVWconst)
5961 v.AuxInt = 1
5962 return true
5963 }
5964
5965
5966
5967 for {
5968 v_0 := v.Args[0]
5969 if v_0.Op != OpARMFlagLT_ULT {
5970 break
5971 }
5972 v.reset(OpARMMOVWconst)
5973 v.AuxInt = 0
5974 return true
5975 }
5976
5977
5978
5979 for {
5980 v_0 := v.Args[0]
5981 if v_0.Op != OpARMFlagLT_UGT {
5982 break
5983 }
5984 v.reset(OpARMMOVWconst)
5985 v.AuxInt = 0
5986 return true
5987 }
5988
5989
5990
5991 for {
5992 v_0 := v.Args[0]
5993 if v_0.Op != OpARMFlagGT_ULT {
5994 break
5995 }
5996 v.reset(OpARMMOVWconst)
5997 v.AuxInt = 0
5998 return true
5999 }
6000
6001
6002
6003 for {
6004 v_0 := v.Args[0]
6005 if v_0.Op != OpARMFlagGT_UGT {
6006 break
6007 }
6008 v.reset(OpARMMOVWconst)
6009 v.AuxInt = 0
6010 return true
6011 }
6012
6013
6014
6015 for {
6016 v_0 := v.Args[0]
6017 if v_0.Op != OpARMInvertFlags {
6018 break
6019 }
6020 x := v_0.Args[0]
6021 v.reset(OpARMEqual)
6022 v.AddArg(x)
6023 return true
6024 }
6025 return false
6026 }
6027 func rewriteValueARM_OpARMGreaterEqual_0(v *Value) bool {
6028
6029
6030
6031 for {
6032 v_0 := v.Args[0]
6033 if v_0.Op != OpARMFlagEQ {
6034 break
6035 }
6036 v.reset(OpARMMOVWconst)
6037 v.AuxInt = 1
6038 return true
6039 }
6040
6041
6042
6043 for {
6044 v_0 := v.Args[0]
6045 if v_0.Op != OpARMFlagLT_ULT {
6046 break
6047 }
6048 v.reset(OpARMMOVWconst)
6049 v.AuxInt = 0
6050 return true
6051 }
6052
6053
6054
6055 for {
6056 v_0 := v.Args[0]
6057 if v_0.Op != OpARMFlagLT_UGT {
6058 break
6059 }
6060 v.reset(OpARMMOVWconst)
6061 v.AuxInt = 0
6062 return true
6063 }
6064
6065
6066
6067 for {
6068 v_0 := v.Args[0]
6069 if v_0.Op != OpARMFlagGT_ULT {
6070 break
6071 }
6072 v.reset(OpARMMOVWconst)
6073 v.AuxInt = 1
6074 return true
6075 }
6076
6077
6078
6079 for {
6080 v_0 := v.Args[0]
6081 if v_0.Op != OpARMFlagGT_UGT {
6082 break
6083 }
6084 v.reset(OpARMMOVWconst)
6085 v.AuxInt = 1
6086 return true
6087 }
6088
6089
6090
6091 for {
6092 v_0 := v.Args[0]
6093 if v_0.Op != OpARMInvertFlags {
6094 break
6095 }
6096 x := v_0.Args[0]
6097 v.reset(OpARMLessEqual)
6098 v.AddArg(x)
6099 return true
6100 }
6101 return false
6102 }
6103 func rewriteValueARM_OpARMGreaterEqualU_0(v *Value) bool {
6104
6105
6106
6107 for {
6108 v_0 := v.Args[0]
6109 if v_0.Op != OpARMFlagEQ {
6110 break
6111 }
6112 v.reset(OpARMMOVWconst)
6113 v.AuxInt = 1
6114 return true
6115 }
6116
6117
6118
6119 for {
6120 v_0 := v.Args[0]
6121 if v_0.Op != OpARMFlagLT_ULT {
6122 break
6123 }
6124 v.reset(OpARMMOVWconst)
6125 v.AuxInt = 0
6126 return true
6127 }
6128
6129
6130
6131 for {
6132 v_0 := v.Args[0]
6133 if v_0.Op != OpARMFlagLT_UGT {
6134 break
6135 }
6136 v.reset(OpARMMOVWconst)
6137 v.AuxInt = 1
6138 return true
6139 }
6140
6141
6142
6143 for {
6144 v_0 := v.Args[0]
6145 if v_0.Op != OpARMFlagGT_ULT {
6146 break
6147 }
6148 v.reset(OpARMMOVWconst)
6149 v.AuxInt = 0
6150 return true
6151 }
6152
6153
6154
6155 for {
6156 v_0 := v.Args[0]
6157 if v_0.Op != OpARMFlagGT_UGT {
6158 break
6159 }
6160 v.reset(OpARMMOVWconst)
6161 v.AuxInt = 1
6162 return true
6163 }
6164
6165
6166
6167 for {
6168 v_0 := v.Args[0]
6169 if v_0.Op != OpARMInvertFlags {
6170 break
6171 }
6172 x := v_0.Args[0]
6173 v.reset(OpARMLessEqualU)
6174 v.AddArg(x)
6175 return true
6176 }
6177 return false
6178 }
6179 func rewriteValueARM_OpARMGreaterThan_0(v *Value) bool {
6180
6181
6182
6183 for {
6184 v_0 := v.Args[0]
6185 if v_0.Op != OpARMFlagEQ {
6186 break
6187 }
6188 v.reset(OpARMMOVWconst)
6189 v.AuxInt = 0
6190 return true
6191 }
6192
6193
6194
6195 for {
6196 v_0 := v.Args[0]
6197 if v_0.Op != OpARMFlagLT_ULT {
6198 break
6199 }
6200 v.reset(OpARMMOVWconst)
6201 v.AuxInt = 0
6202 return true
6203 }
6204
6205
6206
6207 for {
6208 v_0 := v.Args[0]
6209 if v_0.Op != OpARMFlagLT_UGT {
6210 break
6211 }
6212 v.reset(OpARMMOVWconst)
6213 v.AuxInt = 0
6214 return true
6215 }
6216
6217
6218
6219 for {
6220 v_0 := v.Args[0]
6221 if v_0.Op != OpARMFlagGT_ULT {
6222 break
6223 }
6224 v.reset(OpARMMOVWconst)
6225 v.AuxInt = 1
6226 return true
6227 }
6228
6229
6230
6231 for {
6232 v_0 := v.Args[0]
6233 if v_0.Op != OpARMFlagGT_UGT {
6234 break
6235 }
6236 v.reset(OpARMMOVWconst)
6237 v.AuxInt = 1
6238 return true
6239 }
6240
6241
6242
6243 for {
6244 v_0 := v.Args[0]
6245 if v_0.Op != OpARMInvertFlags {
6246 break
6247 }
6248 x := v_0.Args[0]
6249 v.reset(OpARMLessThan)
6250 v.AddArg(x)
6251 return true
6252 }
6253 return false
6254 }
6255 func rewriteValueARM_OpARMGreaterThanU_0(v *Value) bool {
6256
6257
6258
6259 for {
6260 v_0 := v.Args[0]
6261 if v_0.Op != OpARMFlagEQ {
6262 break
6263 }
6264 v.reset(OpARMMOVWconst)
6265 v.AuxInt = 0
6266 return true
6267 }
6268
6269
6270
6271 for {
6272 v_0 := v.Args[0]
6273 if v_0.Op != OpARMFlagLT_ULT {
6274 break
6275 }
6276 v.reset(OpARMMOVWconst)
6277 v.AuxInt = 0
6278 return true
6279 }
6280
6281
6282
6283 for {
6284 v_0 := v.Args[0]
6285 if v_0.Op != OpARMFlagLT_UGT {
6286 break
6287 }
6288 v.reset(OpARMMOVWconst)
6289 v.AuxInt = 1
6290 return true
6291 }
6292
6293
6294
6295 for {
6296 v_0 := v.Args[0]
6297 if v_0.Op != OpARMFlagGT_ULT {
6298 break
6299 }
6300 v.reset(OpARMMOVWconst)
6301 v.AuxInt = 0
6302 return true
6303 }
6304
6305
6306
6307 for {
6308 v_0 := v.Args[0]
6309 if v_0.Op != OpARMFlagGT_UGT {
6310 break
6311 }
6312 v.reset(OpARMMOVWconst)
6313 v.AuxInt = 1
6314 return true
6315 }
6316
6317
6318
6319 for {
6320 v_0 := v.Args[0]
6321 if v_0.Op != OpARMInvertFlags {
6322 break
6323 }
6324 x := v_0.Args[0]
6325 v.reset(OpARMLessThanU)
6326 v.AddArg(x)
6327 return true
6328 }
6329 return false
6330 }
6331 func rewriteValueARM_OpARMLessEqual_0(v *Value) bool {
6332
6333
6334
6335 for {
6336 v_0 := v.Args[0]
6337 if v_0.Op != OpARMFlagEQ {
6338 break
6339 }
6340 v.reset(OpARMMOVWconst)
6341 v.AuxInt = 1
6342 return true
6343 }
6344
6345
6346
6347 for {
6348 v_0 := v.Args[0]
6349 if v_0.Op != OpARMFlagLT_ULT {
6350 break
6351 }
6352 v.reset(OpARMMOVWconst)
6353 v.AuxInt = 1
6354 return true
6355 }
6356
6357
6358
6359 for {
6360 v_0 := v.Args[0]
6361 if v_0.Op != OpARMFlagLT_UGT {
6362 break
6363 }
6364 v.reset(OpARMMOVWconst)
6365 v.AuxInt = 1
6366 return true
6367 }
6368
6369
6370
6371 for {
6372 v_0 := v.Args[0]
6373 if v_0.Op != OpARMFlagGT_ULT {
6374 break
6375 }
6376 v.reset(OpARMMOVWconst)
6377 v.AuxInt = 0
6378 return true
6379 }
6380
6381
6382
6383 for {
6384 v_0 := v.Args[0]
6385 if v_0.Op != OpARMFlagGT_UGT {
6386 break
6387 }
6388 v.reset(OpARMMOVWconst)
6389 v.AuxInt = 0
6390 return true
6391 }
6392
6393
6394
6395 for {
6396 v_0 := v.Args[0]
6397 if v_0.Op != OpARMInvertFlags {
6398 break
6399 }
6400 x := v_0.Args[0]
6401 v.reset(OpARMGreaterEqual)
6402 v.AddArg(x)
6403 return true
6404 }
6405 return false
6406 }
6407 func rewriteValueARM_OpARMLessEqualU_0(v *Value) bool {
6408
6409
6410
6411 for {
6412 v_0 := v.Args[0]
6413 if v_0.Op != OpARMFlagEQ {
6414 break
6415 }
6416 v.reset(OpARMMOVWconst)
6417 v.AuxInt = 1
6418 return true
6419 }
6420
6421
6422
6423 for {
6424 v_0 := v.Args[0]
6425 if v_0.Op != OpARMFlagLT_ULT {
6426 break
6427 }
6428 v.reset(OpARMMOVWconst)
6429 v.AuxInt = 1
6430 return true
6431 }
6432
6433
6434
6435 for {
6436 v_0 := v.Args[0]
6437 if v_0.Op != OpARMFlagLT_UGT {
6438 break
6439 }
6440 v.reset(OpARMMOVWconst)
6441 v.AuxInt = 0
6442 return true
6443 }
6444
6445
6446
6447 for {
6448 v_0 := v.Args[0]
6449 if v_0.Op != OpARMFlagGT_ULT {
6450 break
6451 }
6452 v.reset(OpARMMOVWconst)
6453 v.AuxInt = 1
6454 return true
6455 }
6456
6457
6458
6459 for {
6460 v_0 := v.Args[0]
6461 if v_0.Op != OpARMFlagGT_UGT {
6462 break
6463 }
6464 v.reset(OpARMMOVWconst)
6465 v.AuxInt = 0
6466 return true
6467 }
6468
6469
6470
6471 for {
6472 v_0 := v.Args[0]
6473 if v_0.Op != OpARMInvertFlags {
6474 break
6475 }
6476 x := v_0.Args[0]
6477 v.reset(OpARMGreaterEqualU)
6478 v.AddArg(x)
6479 return true
6480 }
6481 return false
6482 }
6483 func rewriteValueARM_OpARMLessThan_0(v *Value) bool {
6484
6485
6486
6487 for {
6488 v_0 := v.Args[0]
6489 if v_0.Op != OpARMFlagEQ {
6490 break
6491 }
6492 v.reset(OpARMMOVWconst)
6493 v.AuxInt = 0
6494 return true
6495 }
6496
6497
6498
6499 for {
6500 v_0 := v.Args[0]
6501 if v_0.Op != OpARMFlagLT_ULT {
6502 break
6503 }
6504 v.reset(OpARMMOVWconst)
6505 v.AuxInt = 1
6506 return true
6507 }
6508
6509
6510
6511 for {
6512 v_0 := v.Args[0]
6513 if v_0.Op != OpARMFlagLT_UGT {
6514 break
6515 }
6516 v.reset(OpARMMOVWconst)
6517 v.AuxInt = 1
6518 return true
6519 }
6520
6521
6522
6523 for {
6524 v_0 := v.Args[0]
6525 if v_0.Op != OpARMFlagGT_ULT {
6526 break
6527 }
6528 v.reset(OpARMMOVWconst)
6529 v.AuxInt = 0
6530 return true
6531 }
6532
6533
6534
6535 for {
6536 v_0 := v.Args[0]
6537 if v_0.Op != OpARMFlagGT_UGT {
6538 break
6539 }
6540 v.reset(OpARMMOVWconst)
6541 v.AuxInt = 0
6542 return true
6543 }
6544
6545
6546
6547 for {
6548 v_0 := v.Args[0]
6549 if v_0.Op != OpARMInvertFlags {
6550 break
6551 }
6552 x := v_0.Args[0]
6553 v.reset(OpARMGreaterThan)
6554 v.AddArg(x)
6555 return true
6556 }
6557 return false
6558 }
6559 func rewriteValueARM_OpARMLessThanU_0(v *Value) bool {
6560
6561
6562
6563 for {
6564 v_0 := v.Args[0]
6565 if v_0.Op != OpARMFlagEQ {
6566 break
6567 }
6568 v.reset(OpARMMOVWconst)
6569 v.AuxInt = 0
6570 return true
6571 }
6572
6573
6574
6575 for {
6576 v_0 := v.Args[0]
6577 if v_0.Op != OpARMFlagLT_ULT {
6578 break
6579 }
6580 v.reset(OpARMMOVWconst)
6581 v.AuxInt = 1
6582 return true
6583 }
6584
6585
6586
6587 for {
6588 v_0 := v.Args[0]
6589 if v_0.Op != OpARMFlagLT_UGT {
6590 break
6591 }
6592 v.reset(OpARMMOVWconst)
6593 v.AuxInt = 0
6594 return true
6595 }
6596
6597
6598
6599 for {
6600 v_0 := v.Args[0]
6601 if v_0.Op != OpARMFlagGT_ULT {
6602 break
6603 }
6604 v.reset(OpARMMOVWconst)
6605 v.AuxInt = 1
6606 return true
6607 }
6608
6609
6610
6611 for {
6612 v_0 := v.Args[0]
6613 if v_0.Op != OpARMFlagGT_UGT {
6614 break
6615 }
6616 v.reset(OpARMMOVWconst)
6617 v.AuxInt = 0
6618 return true
6619 }
6620
6621
6622
6623 for {
6624 v_0 := v.Args[0]
6625 if v_0.Op != OpARMInvertFlags {
6626 break
6627 }
6628 x := v_0.Args[0]
6629 v.reset(OpARMGreaterThanU)
6630 v.AddArg(x)
6631 return true
6632 }
6633 return false
6634 }
6635 func rewriteValueARM_OpARMMOVBUload_0(v *Value) bool {
6636 b := v.Block
6637 config := b.Func.Config
6638
6639
6640
6641 for {
6642 off1 := v.AuxInt
6643 sym := v.Aux
6644 mem := v.Args[1]
6645 v_0 := v.Args[0]
6646 if v_0.Op != OpARMADDconst {
6647 break
6648 }
6649 off2 := v_0.AuxInt
6650 ptr := v_0.Args[0]
6651 v.reset(OpARMMOVBUload)
6652 v.AuxInt = off1 + off2
6653 v.Aux = sym
6654 v.AddArg(ptr)
6655 v.AddArg(mem)
6656 return true
6657 }
6658
6659
6660
6661 for {
6662 off1 := v.AuxInt
6663 sym := v.Aux
6664 mem := v.Args[1]
6665 v_0 := v.Args[0]
6666 if v_0.Op != OpARMSUBconst {
6667 break
6668 }
6669 off2 := v_0.AuxInt
6670 ptr := v_0.Args[0]
6671 v.reset(OpARMMOVBUload)
6672 v.AuxInt = off1 - off2
6673 v.Aux = sym
6674 v.AddArg(ptr)
6675 v.AddArg(mem)
6676 return true
6677 }
6678
6679
6680
6681 for {
6682 off1 := v.AuxInt
6683 sym1 := v.Aux
6684 mem := v.Args[1]
6685 v_0 := v.Args[0]
6686 if v_0.Op != OpARMMOVWaddr {
6687 break
6688 }
6689 off2 := v_0.AuxInt
6690 sym2 := v_0.Aux
6691 ptr := v_0.Args[0]
6692 if !(canMergeSym(sym1, sym2)) {
6693 break
6694 }
6695 v.reset(OpARMMOVBUload)
6696 v.AuxInt = off1 + off2
6697 v.Aux = mergeSym(sym1, sym2)
6698 v.AddArg(ptr)
6699 v.AddArg(mem)
6700 return true
6701 }
6702
6703
6704
6705 for {
6706 off := v.AuxInt
6707 sym := v.Aux
6708 _ = v.Args[1]
6709 ptr := v.Args[0]
6710 v_1 := v.Args[1]
6711 if v_1.Op != OpARMMOVBstore {
6712 break
6713 }
6714 off2 := v_1.AuxInt
6715 sym2 := v_1.Aux
6716 _ = v_1.Args[2]
6717 ptr2 := v_1.Args[0]
6718 x := v_1.Args[1]
6719 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
6720 break
6721 }
6722 v.reset(OpARMMOVBUreg)
6723 v.AddArg(x)
6724 return true
6725 }
6726
6727
6728
6729 for {
6730 if v.AuxInt != 0 {
6731 break
6732 }
6733 sym := v.Aux
6734 mem := v.Args[1]
6735 v_0 := v.Args[0]
6736 if v_0.Op != OpARMADD {
6737 break
6738 }
6739 idx := v_0.Args[1]
6740 ptr := v_0.Args[0]
6741 if !(sym == nil && !config.nacl) {
6742 break
6743 }
6744 v.reset(OpARMMOVBUloadidx)
6745 v.AddArg(ptr)
6746 v.AddArg(idx)
6747 v.AddArg(mem)
6748 return true
6749 }
6750
6751
6752
6753 for {
6754 off := v.AuxInt
6755 sym := v.Aux
6756 _ = v.Args[1]
6757 v_0 := v.Args[0]
6758 if v_0.Op != OpSB {
6759 break
6760 }
6761 if !(symIsRO(sym)) {
6762 break
6763 }
6764 v.reset(OpARMMOVWconst)
6765 v.AuxInt = int64(read8(sym, off))
6766 return true
6767 }
6768 return false
6769 }
6770 func rewriteValueARM_OpARMMOVBUloadidx_0(v *Value) bool {
6771
6772
6773
6774 for {
6775 _ = v.Args[2]
6776 ptr := v.Args[0]
6777 idx := v.Args[1]
6778 v_2 := v.Args[2]
6779 if v_2.Op != OpARMMOVBstoreidx {
6780 break
6781 }
6782 _ = v_2.Args[3]
6783 ptr2 := v_2.Args[0]
6784 if idx != v_2.Args[1] {
6785 break
6786 }
6787 x := v_2.Args[2]
6788 if !(isSamePtr(ptr, ptr2)) {
6789 break
6790 }
6791 v.reset(OpARMMOVBUreg)
6792 v.AddArg(x)
6793 return true
6794 }
6795
6796
6797
6798 for {
6799 mem := v.Args[2]
6800 ptr := v.Args[0]
6801 v_1 := v.Args[1]
6802 if v_1.Op != OpARMMOVWconst {
6803 break
6804 }
6805 c := v_1.AuxInt
6806 v.reset(OpARMMOVBUload)
6807 v.AuxInt = c
6808 v.AddArg(ptr)
6809 v.AddArg(mem)
6810 return true
6811 }
6812
6813
6814
6815 for {
6816 mem := v.Args[2]
6817 v_0 := v.Args[0]
6818 if v_0.Op != OpARMMOVWconst {
6819 break
6820 }
6821 c := v_0.AuxInt
6822 ptr := v.Args[1]
6823 v.reset(OpARMMOVBUload)
6824 v.AuxInt = c
6825 v.AddArg(ptr)
6826 v.AddArg(mem)
6827 return true
6828 }
6829 return false
6830 }
6831 func rewriteValueARM_OpARMMOVBUreg_0(v *Value) bool {
6832
6833
6834
6835 for {
6836 x := v.Args[0]
6837 if x.Op != OpARMMOVBUload {
6838 break
6839 }
6840 _ = x.Args[1]
6841 v.reset(OpARMMOVWreg)
6842 v.AddArg(x)
6843 return true
6844 }
6845
6846
6847
6848 for {
6849 v_0 := v.Args[0]
6850 if v_0.Op != OpARMANDconst {
6851 break
6852 }
6853 c := v_0.AuxInt
6854 x := v_0.Args[0]
6855 v.reset(OpARMANDconst)
6856 v.AuxInt = c & 0xff
6857 v.AddArg(x)
6858 return true
6859 }
6860
6861
6862
6863 for {
6864 x := v.Args[0]
6865 if x.Op != OpARMMOVBUreg {
6866 break
6867 }
6868 v.reset(OpARMMOVWreg)
6869 v.AddArg(x)
6870 return true
6871 }
6872
6873
6874
6875 for {
6876 v_0 := v.Args[0]
6877 if v_0.Op != OpARMMOVWconst {
6878 break
6879 }
6880 c := v_0.AuxInt
6881 v.reset(OpARMMOVWconst)
6882 v.AuxInt = int64(uint8(c))
6883 return true
6884 }
6885 return false
6886 }
6887 func rewriteValueARM_OpARMMOVBload_0(v *Value) bool {
6888 b := v.Block
6889 config := b.Func.Config
6890
6891
6892
6893 for {
6894 off1 := v.AuxInt
6895 sym := v.Aux
6896 mem := v.Args[1]
6897 v_0 := v.Args[0]
6898 if v_0.Op != OpARMADDconst {
6899 break
6900 }
6901 off2 := v_0.AuxInt
6902 ptr := v_0.Args[0]
6903 v.reset(OpARMMOVBload)
6904 v.AuxInt = off1 + off2
6905 v.Aux = sym
6906 v.AddArg(ptr)
6907 v.AddArg(mem)
6908 return true
6909 }
6910
6911
6912
6913 for {
6914 off1 := v.AuxInt
6915 sym := v.Aux
6916 mem := v.Args[1]
6917 v_0 := v.Args[0]
6918 if v_0.Op != OpARMSUBconst {
6919 break
6920 }
6921 off2 := v_0.AuxInt
6922 ptr := v_0.Args[0]
6923 v.reset(OpARMMOVBload)
6924 v.AuxInt = off1 - off2
6925 v.Aux = sym
6926 v.AddArg(ptr)
6927 v.AddArg(mem)
6928 return true
6929 }
6930
6931
6932
6933 for {
6934 off1 := v.AuxInt
6935 sym1 := v.Aux
6936 mem := v.Args[1]
6937 v_0 := v.Args[0]
6938 if v_0.Op != OpARMMOVWaddr {
6939 break
6940 }
6941 off2 := v_0.AuxInt
6942 sym2 := v_0.Aux
6943 ptr := v_0.Args[0]
6944 if !(canMergeSym(sym1, sym2)) {
6945 break
6946 }
6947 v.reset(OpARMMOVBload)
6948 v.AuxInt = off1 + off2
6949 v.Aux = mergeSym(sym1, sym2)
6950 v.AddArg(ptr)
6951 v.AddArg(mem)
6952 return true
6953 }
6954
6955
6956
6957 for {
6958 off := v.AuxInt
6959 sym := v.Aux
6960 _ = v.Args[1]
6961 ptr := v.Args[0]
6962 v_1 := v.Args[1]
6963 if v_1.Op != OpARMMOVBstore {
6964 break
6965 }
6966 off2 := v_1.AuxInt
6967 sym2 := v_1.Aux
6968 _ = v_1.Args[2]
6969 ptr2 := v_1.Args[0]
6970 x := v_1.Args[1]
6971 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
6972 break
6973 }
6974 v.reset(OpARMMOVBreg)
6975 v.AddArg(x)
6976 return true
6977 }
6978
6979
6980
6981 for {
6982 if v.AuxInt != 0 {
6983 break
6984 }
6985 sym := v.Aux
6986 mem := v.Args[1]
6987 v_0 := v.Args[0]
6988 if v_0.Op != OpARMADD {
6989 break
6990 }
6991 idx := v_0.Args[1]
6992 ptr := v_0.Args[0]
6993 if !(sym == nil && !config.nacl) {
6994 break
6995 }
6996 v.reset(OpARMMOVBloadidx)
6997 v.AddArg(ptr)
6998 v.AddArg(idx)
6999 v.AddArg(mem)
7000 return true
7001 }
7002 return false
7003 }
7004 func rewriteValueARM_OpARMMOVBloadidx_0(v *Value) bool {
7005
7006
7007
7008 for {
7009 _ = v.Args[2]
7010 ptr := v.Args[0]
7011 idx := v.Args[1]
7012 v_2 := v.Args[2]
7013 if v_2.Op != OpARMMOVBstoreidx {
7014 break
7015 }
7016 _ = v_2.Args[3]
7017 ptr2 := v_2.Args[0]
7018 if idx != v_2.Args[1] {
7019 break
7020 }
7021 x := v_2.Args[2]
7022 if !(isSamePtr(ptr, ptr2)) {
7023 break
7024 }
7025 v.reset(OpARMMOVBreg)
7026 v.AddArg(x)
7027 return true
7028 }
7029
7030
7031
7032 for {
7033 mem := v.Args[2]
7034 ptr := v.Args[0]
7035 v_1 := v.Args[1]
7036 if v_1.Op != OpARMMOVWconst {
7037 break
7038 }
7039 c := v_1.AuxInt
7040 v.reset(OpARMMOVBload)
7041 v.AuxInt = c
7042 v.AddArg(ptr)
7043 v.AddArg(mem)
7044 return true
7045 }
7046
7047
7048
7049 for {
7050 mem := v.Args[2]
7051 v_0 := v.Args[0]
7052 if v_0.Op != OpARMMOVWconst {
7053 break
7054 }
7055 c := v_0.AuxInt
7056 ptr := v.Args[1]
7057 v.reset(OpARMMOVBload)
7058 v.AuxInt = c
7059 v.AddArg(ptr)
7060 v.AddArg(mem)
7061 return true
7062 }
7063 return false
7064 }
7065 func rewriteValueARM_OpARMMOVBreg_0(v *Value) bool {
7066
7067
7068
7069 for {
7070 x := v.Args[0]
7071 if x.Op != OpARMMOVBload {
7072 break
7073 }
7074 _ = x.Args[1]
7075 v.reset(OpARMMOVWreg)
7076 v.AddArg(x)
7077 return true
7078 }
7079
7080
7081
7082 for {
7083 v_0 := v.Args[0]
7084 if v_0.Op != OpARMANDconst {
7085 break
7086 }
7087 c := v_0.AuxInt
7088 x := v_0.Args[0]
7089 if !(c&0x80 == 0) {
7090 break
7091 }
7092 v.reset(OpARMANDconst)
7093 v.AuxInt = c & 0x7f
7094 v.AddArg(x)
7095 return true
7096 }
7097
7098
7099
7100 for {
7101 x := v.Args[0]
7102 if x.Op != OpARMMOVBreg {
7103 break
7104 }
7105 v.reset(OpARMMOVWreg)
7106 v.AddArg(x)
7107 return true
7108 }
7109
7110
7111
7112 for {
7113 v_0 := v.Args[0]
7114 if v_0.Op != OpARMMOVWconst {
7115 break
7116 }
7117 c := v_0.AuxInt
7118 v.reset(OpARMMOVWconst)
7119 v.AuxInt = int64(int8(c))
7120 return true
7121 }
7122 return false
7123 }
7124 func rewriteValueARM_OpARMMOVBstore_0(v *Value) bool {
7125 b := v.Block
7126 config := b.Func.Config
7127
7128
7129
7130 for {
7131 off1 := v.AuxInt
7132 sym := v.Aux
7133 mem := v.Args[2]
7134 v_0 := v.Args[0]
7135 if v_0.Op != OpARMADDconst {
7136 break
7137 }
7138 off2 := v_0.AuxInt
7139 ptr := v_0.Args[0]
7140 val := v.Args[1]
7141 v.reset(OpARMMOVBstore)
7142 v.AuxInt = off1 + off2
7143 v.Aux = sym
7144 v.AddArg(ptr)
7145 v.AddArg(val)
7146 v.AddArg(mem)
7147 return true
7148 }
7149
7150
7151
7152 for {
7153 off1 := v.AuxInt
7154 sym := v.Aux
7155 mem := v.Args[2]
7156 v_0 := v.Args[0]
7157 if v_0.Op != OpARMSUBconst {
7158 break
7159 }
7160 off2 := v_0.AuxInt
7161 ptr := v_0.Args[0]
7162 val := v.Args[1]
7163 v.reset(OpARMMOVBstore)
7164 v.AuxInt = off1 - off2
7165 v.Aux = sym
7166 v.AddArg(ptr)
7167 v.AddArg(val)
7168 v.AddArg(mem)
7169 return true
7170 }
7171
7172
7173
7174 for {
7175 off1 := v.AuxInt
7176 sym1 := v.Aux
7177 mem := v.Args[2]
7178 v_0 := v.Args[0]
7179 if v_0.Op != OpARMMOVWaddr {
7180 break
7181 }
7182 off2 := v_0.AuxInt
7183 sym2 := v_0.Aux
7184 ptr := v_0.Args[0]
7185 val := v.Args[1]
7186 if !(canMergeSym(sym1, sym2)) {
7187 break
7188 }
7189 v.reset(OpARMMOVBstore)
7190 v.AuxInt = off1 + off2
7191 v.Aux = mergeSym(sym1, sym2)
7192 v.AddArg(ptr)
7193 v.AddArg(val)
7194 v.AddArg(mem)
7195 return true
7196 }
7197
7198
7199
7200 for {
7201 off := v.AuxInt
7202 sym := v.Aux
7203 mem := v.Args[2]
7204 ptr := v.Args[0]
7205 v_1 := v.Args[1]
7206 if v_1.Op != OpARMMOVBreg {
7207 break
7208 }
7209 x := v_1.Args[0]
7210 v.reset(OpARMMOVBstore)
7211 v.AuxInt = off
7212 v.Aux = sym
7213 v.AddArg(ptr)
7214 v.AddArg(x)
7215 v.AddArg(mem)
7216 return true
7217 }
7218
7219
7220
7221 for {
7222 off := v.AuxInt
7223 sym := v.Aux
7224 mem := v.Args[2]
7225 ptr := v.Args[0]
7226 v_1 := v.Args[1]
7227 if v_1.Op != OpARMMOVBUreg {
7228 break
7229 }
7230 x := v_1.Args[0]
7231 v.reset(OpARMMOVBstore)
7232 v.AuxInt = off
7233 v.Aux = sym
7234 v.AddArg(ptr)
7235 v.AddArg(x)
7236 v.AddArg(mem)
7237 return true
7238 }
7239
7240
7241
7242 for {
7243 off := v.AuxInt
7244 sym := v.Aux
7245 mem := v.Args[2]
7246 ptr := v.Args[0]
7247 v_1 := v.Args[1]
7248 if v_1.Op != OpARMMOVHreg {
7249 break
7250 }
7251 x := v_1.Args[0]
7252 v.reset(OpARMMOVBstore)
7253 v.AuxInt = off
7254 v.Aux = sym
7255 v.AddArg(ptr)
7256 v.AddArg(x)
7257 v.AddArg(mem)
7258 return true
7259 }
7260
7261
7262
7263 for {
7264 off := v.AuxInt
7265 sym := v.Aux
7266 mem := v.Args[2]
7267 ptr := v.Args[0]
7268 v_1 := v.Args[1]
7269 if v_1.Op != OpARMMOVHUreg {
7270 break
7271 }
7272 x := v_1.Args[0]
7273 v.reset(OpARMMOVBstore)
7274 v.AuxInt = off
7275 v.Aux = sym
7276 v.AddArg(ptr)
7277 v.AddArg(x)
7278 v.AddArg(mem)
7279 return true
7280 }
7281
7282
7283
7284 for {
7285 if v.AuxInt != 0 {
7286 break
7287 }
7288 sym := v.Aux
7289 mem := v.Args[2]
7290 v_0 := v.Args[0]
7291 if v_0.Op != OpARMADD {
7292 break
7293 }
7294 idx := v_0.Args[1]
7295 ptr := v_0.Args[0]
7296 val := v.Args[1]
7297 if !(sym == nil && !config.nacl) {
7298 break
7299 }
7300 v.reset(OpARMMOVBstoreidx)
7301 v.AddArg(ptr)
7302 v.AddArg(idx)
7303 v.AddArg(val)
7304 v.AddArg(mem)
7305 return true
7306 }
7307 return false
7308 }
7309 func rewriteValueARM_OpARMMOVBstoreidx_0(v *Value) bool {
7310
7311
7312
7313 for {
7314 mem := v.Args[3]
7315 ptr := v.Args[0]
7316 v_1 := v.Args[1]
7317 if v_1.Op != OpARMMOVWconst {
7318 break
7319 }
7320 c := v_1.AuxInt
7321 val := v.Args[2]
7322 v.reset(OpARMMOVBstore)
7323 v.AuxInt = c
7324 v.AddArg(ptr)
7325 v.AddArg(val)
7326 v.AddArg(mem)
7327 return true
7328 }
7329
7330
7331
7332 for {
7333 mem := v.Args[3]
7334 v_0 := v.Args[0]
7335 if v_0.Op != OpARMMOVWconst {
7336 break
7337 }
7338 c := v_0.AuxInt
7339 ptr := v.Args[1]
7340 val := v.Args[2]
7341 v.reset(OpARMMOVBstore)
7342 v.AuxInt = c
7343 v.AddArg(ptr)
7344 v.AddArg(val)
7345 v.AddArg(mem)
7346 return true
7347 }
7348 return false
7349 }
7350 func rewriteValueARM_OpARMMOVDload_0(v *Value) bool {
7351
7352
7353
7354 for {
7355 off1 := v.AuxInt
7356 sym := v.Aux
7357 mem := v.Args[1]
7358 v_0 := v.Args[0]
7359 if v_0.Op != OpARMADDconst {
7360 break
7361 }
7362 off2 := v_0.AuxInt
7363 ptr := v_0.Args[0]
7364 v.reset(OpARMMOVDload)
7365 v.AuxInt = off1 + off2
7366 v.Aux = sym
7367 v.AddArg(ptr)
7368 v.AddArg(mem)
7369 return true
7370 }
7371
7372
7373
7374 for {
7375 off1 := v.AuxInt
7376 sym := v.Aux
7377 mem := v.Args[1]
7378 v_0 := v.Args[0]
7379 if v_0.Op != OpARMSUBconst {
7380 break
7381 }
7382 off2 := v_0.AuxInt
7383 ptr := v_0.Args[0]
7384 v.reset(OpARMMOVDload)
7385 v.AuxInt = off1 - off2
7386 v.Aux = sym
7387 v.AddArg(ptr)
7388 v.AddArg(mem)
7389 return true
7390 }
7391
7392
7393
7394 for {
7395 off1 := v.AuxInt
7396 sym1 := v.Aux
7397 mem := v.Args[1]
7398 v_0 := v.Args[0]
7399 if v_0.Op != OpARMMOVWaddr {
7400 break
7401 }
7402 off2 := v_0.AuxInt
7403 sym2 := v_0.Aux
7404 ptr := v_0.Args[0]
7405 if !(canMergeSym(sym1, sym2)) {
7406 break
7407 }
7408 v.reset(OpARMMOVDload)
7409 v.AuxInt = off1 + off2
7410 v.Aux = mergeSym(sym1, sym2)
7411 v.AddArg(ptr)
7412 v.AddArg(mem)
7413 return true
7414 }
7415
7416
7417
7418 for {
7419 off := v.AuxInt
7420 sym := v.Aux
7421 _ = v.Args[1]
7422 ptr := v.Args[0]
7423 v_1 := v.Args[1]
7424 if v_1.Op != OpARMMOVDstore {
7425 break
7426 }
7427 off2 := v_1.AuxInt
7428 sym2 := v_1.Aux
7429 _ = v_1.Args[2]
7430 ptr2 := v_1.Args[0]
7431 x := v_1.Args[1]
7432 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
7433 break
7434 }
7435 v.reset(OpCopy)
7436 v.Type = x.Type
7437 v.AddArg(x)
7438 return true
7439 }
7440 return false
7441 }
7442 func rewriteValueARM_OpARMMOVDstore_0(v *Value) bool {
7443
7444
7445
7446 for {
7447 off1 := v.AuxInt
7448 sym := v.Aux
7449 mem := v.Args[2]
7450 v_0 := v.Args[0]
7451 if v_0.Op != OpARMADDconst {
7452 break
7453 }
7454 off2 := v_0.AuxInt
7455 ptr := v_0.Args[0]
7456 val := v.Args[1]
7457 v.reset(OpARMMOVDstore)
7458 v.AuxInt = off1 + off2
7459 v.Aux = sym
7460 v.AddArg(ptr)
7461 v.AddArg(val)
7462 v.AddArg(mem)
7463 return true
7464 }
7465
7466
7467
7468 for {
7469 off1 := v.AuxInt
7470 sym := v.Aux
7471 mem := v.Args[2]
7472 v_0 := v.Args[0]
7473 if v_0.Op != OpARMSUBconst {
7474 break
7475 }
7476 off2 := v_0.AuxInt
7477 ptr := v_0.Args[0]
7478 val := v.Args[1]
7479 v.reset(OpARMMOVDstore)
7480 v.AuxInt = off1 - off2
7481 v.Aux = sym
7482 v.AddArg(ptr)
7483 v.AddArg(val)
7484 v.AddArg(mem)
7485 return true
7486 }
7487
7488
7489
7490 for {
7491 off1 := v.AuxInt
7492 sym1 := v.Aux
7493 mem := v.Args[2]
7494 v_0 := v.Args[0]
7495 if v_0.Op != OpARMMOVWaddr {
7496 break
7497 }
7498 off2 := v_0.AuxInt
7499 sym2 := v_0.Aux
7500 ptr := v_0.Args[0]
7501 val := v.Args[1]
7502 if !(canMergeSym(sym1, sym2)) {
7503 break
7504 }
7505 v.reset(OpARMMOVDstore)
7506 v.AuxInt = off1 + off2
7507 v.Aux = mergeSym(sym1, sym2)
7508 v.AddArg(ptr)
7509 v.AddArg(val)
7510 v.AddArg(mem)
7511 return true
7512 }
7513 return false
7514 }
7515 func rewriteValueARM_OpARMMOVFload_0(v *Value) bool {
7516
7517
7518
7519 for {
7520 off1 := v.AuxInt
7521 sym := v.Aux
7522 mem := v.Args[1]
7523 v_0 := v.Args[0]
7524 if v_0.Op != OpARMADDconst {
7525 break
7526 }
7527 off2 := v_0.AuxInt
7528 ptr := v_0.Args[0]
7529 v.reset(OpARMMOVFload)
7530 v.AuxInt = off1 + off2
7531 v.Aux = sym
7532 v.AddArg(ptr)
7533 v.AddArg(mem)
7534 return true
7535 }
7536
7537
7538
7539 for {
7540 off1 := v.AuxInt
7541 sym := v.Aux
7542 mem := v.Args[1]
7543 v_0 := v.Args[0]
7544 if v_0.Op != OpARMSUBconst {
7545 break
7546 }
7547 off2 := v_0.AuxInt
7548 ptr := v_0.Args[0]
7549 v.reset(OpARMMOVFload)
7550 v.AuxInt = off1 - off2
7551 v.Aux = sym
7552 v.AddArg(ptr)
7553 v.AddArg(mem)
7554 return true
7555 }
7556
7557
7558
7559 for {
7560 off1 := v.AuxInt
7561 sym1 := v.Aux
7562 mem := v.Args[1]
7563 v_0 := v.Args[0]
7564 if v_0.Op != OpARMMOVWaddr {
7565 break
7566 }
7567 off2 := v_0.AuxInt
7568 sym2 := v_0.Aux
7569 ptr := v_0.Args[0]
7570 if !(canMergeSym(sym1, sym2)) {
7571 break
7572 }
7573 v.reset(OpARMMOVFload)
7574 v.AuxInt = off1 + off2
7575 v.Aux = mergeSym(sym1, sym2)
7576 v.AddArg(ptr)
7577 v.AddArg(mem)
7578 return true
7579 }
7580
7581
7582
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 != OpARMMOVFstore {
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_OpARMMOVFstore_0(v *Value) bool {
7608
7609
7610
7611 for {
7612 off1 := v.AuxInt
7613 sym := v.Aux
7614 mem := 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 v.reset(OpARMMOVFstore)
7623 v.AuxInt = off1 + off2
7624 v.Aux = sym
7625 v.AddArg(ptr)
7626 v.AddArg(val)
7627 v.AddArg(mem)
7628 return true
7629 }
7630
7631
7632
7633 for {
7634 off1 := v.AuxInt
7635 sym := v.Aux
7636 mem := v.Args[2]
7637 v_0 := v.Args[0]
7638 if v_0.Op != OpARMSUBconst {
7639 break
7640 }
7641 off2 := v_0.AuxInt
7642 ptr := v_0.Args[0]
7643 val := v.Args[1]
7644 v.reset(OpARMMOVFstore)
7645 v.AuxInt = off1 - off2
7646 v.Aux = sym
7647 v.AddArg(ptr)
7648 v.AddArg(val)
7649 v.AddArg(mem)
7650 return true
7651 }
7652
7653
7654
7655 for {
7656 off1 := v.AuxInt
7657 sym1 := v.Aux
7658 mem := v.Args[2]
7659 v_0 := v.Args[0]
7660 if v_0.Op != OpARMMOVWaddr {
7661 break
7662 }
7663 off2 := v_0.AuxInt
7664 sym2 := v_0.Aux
7665 ptr := v_0.Args[0]
7666 val := v.Args[1]
7667 if !(canMergeSym(sym1, sym2)) {
7668 break
7669 }
7670 v.reset(OpARMMOVFstore)
7671 v.AuxInt = off1 + off2
7672 v.Aux = mergeSym(sym1, sym2)
7673 v.AddArg(ptr)
7674 v.AddArg(val)
7675 v.AddArg(mem)
7676 return true
7677 }
7678 return false
7679 }
7680 func rewriteValueARM_OpARMMOVHUload_0(v *Value) bool {
7681 b := v.Block
7682 config := b.Func.Config
7683
7684
7685
7686 for {
7687 off1 := v.AuxInt
7688 sym := v.Aux
7689 mem := v.Args[1]
7690 v_0 := v.Args[0]
7691 if v_0.Op != OpARMADDconst {
7692 break
7693 }
7694 off2 := v_0.AuxInt
7695 ptr := v_0.Args[0]
7696 v.reset(OpARMMOVHUload)
7697 v.AuxInt = off1 + off2
7698 v.Aux = sym
7699 v.AddArg(ptr)
7700 v.AddArg(mem)
7701 return true
7702 }
7703
7704
7705
7706 for {
7707 off1 := v.AuxInt
7708 sym := v.Aux
7709 mem := v.Args[1]
7710 v_0 := v.Args[0]
7711 if v_0.Op != OpARMSUBconst {
7712 break
7713 }
7714 off2 := v_0.AuxInt
7715 ptr := v_0.Args[0]
7716 v.reset(OpARMMOVHUload)
7717 v.AuxInt = off1 - off2
7718 v.Aux = sym
7719 v.AddArg(ptr)
7720 v.AddArg(mem)
7721 return true
7722 }
7723
7724
7725
7726 for {
7727 off1 := v.AuxInt
7728 sym1 := v.Aux
7729 mem := v.Args[1]
7730 v_0 := v.Args[0]
7731 if v_0.Op != OpARMMOVWaddr {
7732 break
7733 }
7734 off2 := v_0.AuxInt
7735 sym2 := v_0.Aux
7736 ptr := v_0.Args[0]
7737 if !(canMergeSym(sym1, sym2)) {
7738 break
7739 }
7740 v.reset(OpARMMOVHUload)
7741 v.AuxInt = off1 + off2
7742 v.Aux = mergeSym(sym1, sym2)
7743 v.AddArg(ptr)
7744 v.AddArg(mem)
7745 return true
7746 }
7747
7748
7749
7750 for {
7751 off := v.AuxInt
7752 sym := v.Aux
7753 _ = v.Args[1]
7754 ptr := v.Args[0]
7755 v_1 := v.Args[1]
7756 if v_1.Op != OpARMMOVHstore {
7757 break
7758 }
7759 off2 := v_1.AuxInt
7760 sym2 := v_1.Aux
7761 _ = v_1.Args[2]
7762 ptr2 := v_1.Args[0]
7763 x := v_1.Args[1]
7764 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
7765 break
7766 }
7767 v.reset(OpARMMOVHUreg)
7768 v.AddArg(x)
7769 return true
7770 }
7771
7772
7773
7774 for {
7775 if v.AuxInt != 0 {
7776 break
7777 }
7778 sym := v.Aux
7779 mem := v.Args[1]
7780 v_0 := v.Args[0]
7781 if v_0.Op != OpARMADD {
7782 break
7783 }
7784 idx := v_0.Args[1]
7785 ptr := v_0.Args[0]
7786 if !(sym == nil && !config.nacl) {
7787 break
7788 }
7789 v.reset(OpARMMOVHUloadidx)
7790 v.AddArg(ptr)
7791 v.AddArg(idx)
7792 v.AddArg(mem)
7793 return true
7794 }
7795
7796
7797
7798 for {
7799 off := v.AuxInt
7800 sym := v.Aux
7801 _ = v.Args[1]
7802 v_0 := v.Args[0]
7803 if v_0.Op != OpSB {
7804 break
7805 }
7806 if !(symIsRO(sym)) {
7807 break
7808 }
7809 v.reset(OpARMMOVWconst)
7810 v.AuxInt = int64(read16(sym, off, config.BigEndian))
7811 return true
7812 }
7813 return false
7814 }
7815 func rewriteValueARM_OpARMMOVHUloadidx_0(v *Value) bool {
7816
7817
7818
7819 for {
7820 _ = v.Args[2]
7821 ptr := v.Args[0]
7822 idx := v.Args[1]
7823 v_2 := v.Args[2]
7824 if v_2.Op != OpARMMOVHstoreidx {
7825 break
7826 }
7827 _ = v_2.Args[3]
7828 ptr2 := v_2.Args[0]
7829 if idx != v_2.Args[1] {
7830 break
7831 }
7832 x := v_2.Args[2]
7833 if !(isSamePtr(ptr, ptr2)) {
7834 break
7835 }
7836 v.reset(OpARMMOVHUreg)
7837 v.AddArg(x)
7838 return true
7839 }
7840
7841
7842
7843 for {
7844 mem := v.Args[2]
7845 ptr := v.Args[0]
7846 v_1 := v.Args[1]
7847 if v_1.Op != OpARMMOVWconst {
7848 break
7849 }
7850 c := v_1.AuxInt
7851 v.reset(OpARMMOVHUload)
7852 v.AuxInt = c
7853 v.AddArg(ptr)
7854 v.AddArg(mem)
7855 return true
7856 }
7857
7858
7859
7860 for {
7861 mem := v.Args[2]
7862 v_0 := v.Args[0]
7863 if v_0.Op != OpARMMOVWconst {
7864 break
7865 }
7866 c := v_0.AuxInt
7867 ptr := v.Args[1]
7868 v.reset(OpARMMOVHUload)
7869 v.AuxInt = c
7870 v.AddArg(ptr)
7871 v.AddArg(mem)
7872 return true
7873 }
7874 return false
7875 }
7876 func rewriteValueARM_OpARMMOVHUreg_0(v *Value) bool {
7877
7878
7879
7880 for {
7881 x := v.Args[0]
7882 if x.Op != OpARMMOVBUload {
7883 break
7884 }
7885 _ = x.Args[1]
7886 v.reset(OpARMMOVWreg)
7887 v.AddArg(x)
7888 return true
7889 }
7890
7891
7892
7893 for {
7894 x := v.Args[0]
7895 if x.Op != OpARMMOVHUload {
7896 break
7897 }
7898 _ = x.Args[1]
7899 v.reset(OpARMMOVWreg)
7900 v.AddArg(x)
7901 return true
7902 }
7903
7904
7905
7906 for {
7907 v_0 := v.Args[0]
7908 if v_0.Op != OpARMANDconst {
7909 break
7910 }
7911 c := v_0.AuxInt
7912 x := v_0.Args[0]
7913 v.reset(OpARMANDconst)
7914 v.AuxInt = c & 0xffff
7915 v.AddArg(x)
7916 return true
7917 }
7918
7919
7920
7921 for {
7922 x := v.Args[0]
7923 if x.Op != OpARMMOVBUreg {
7924 break
7925 }
7926 v.reset(OpARMMOVWreg)
7927 v.AddArg(x)
7928 return true
7929 }
7930
7931
7932
7933 for {
7934 x := v.Args[0]
7935 if x.Op != OpARMMOVHUreg {
7936 break
7937 }
7938 v.reset(OpARMMOVWreg)
7939 v.AddArg(x)
7940 return true
7941 }
7942
7943
7944
7945 for {
7946 v_0 := v.Args[0]
7947 if v_0.Op != OpARMMOVWconst {
7948 break
7949 }
7950 c := v_0.AuxInt
7951 v.reset(OpARMMOVWconst)
7952 v.AuxInt = int64(uint16(c))
7953 return true
7954 }
7955 return false
7956 }
7957 func rewriteValueARM_OpARMMOVHload_0(v *Value) bool {
7958 b := v.Block
7959 config := b.Func.Config
7960
7961
7962
7963 for {
7964 off1 := v.AuxInt
7965 sym := v.Aux
7966 mem := v.Args[1]
7967 v_0 := v.Args[0]
7968 if v_0.Op != OpARMADDconst {
7969 break
7970 }
7971 off2 := v_0.AuxInt
7972 ptr := v_0.Args[0]
7973 v.reset(OpARMMOVHload)
7974 v.AuxInt = off1 + off2
7975 v.Aux = sym
7976 v.AddArg(ptr)
7977 v.AddArg(mem)
7978 return true
7979 }
7980
7981
7982
7983 for {
7984 off1 := v.AuxInt
7985 sym := v.Aux
7986 mem := v.Args[1]
7987 v_0 := v.Args[0]
7988 if v_0.Op != OpARMSUBconst {
7989 break
7990 }
7991 off2 := v_0.AuxInt
7992 ptr := v_0.Args[0]
7993 v.reset(OpARMMOVHload)
7994 v.AuxInt = off1 - off2
7995 v.Aux = sym
7996 v.AddArg(ptr)
7997 v.AddArg(mem)
7998 return true
7999 }
8000
8001
8002
8003 for {
8004 off1 := v.AuxInt
8005 sym1 := v.Aux
8006 mem := v.Args[1]
8007 v_0 := v.Args[0]
8008 if v_0.Op != OpARMMOVWaddr {
8009 break
8010 }
8011 off2 := v_0.AuxInt
8012 sym2 := v_0.Aux
8013 ptr := v_0.Args[0]
8014 if !(canMergeSym(sym1, sym2)) {
8015 break
8016 }
8017 v.reset(OpARMMOVHload)
8018 v.AuxInt = off1 + off2
8019 v.Aux = mergeSym(sym1, sym2)
8020 v.AddArg(ptr)
8021 v.AddArg(mem)
8022 return true
8023 }
8024
8025
8026
8027 for {
8028 off := v.AuxInt
8029 sym := v.Aux
8030 _ = v.Args[1]
8031 ptr := v.Args[0]
8032 v_1 := v.Args[1]
8033 if v_1.Op != OpARMMOVHstore {
8034 break
8035 }
8036 off2 := v_1.AuxInt
8037 sym2 := v_1.Aux
8038 _ = v_1.Args[2]
8039 ptr2 := v_1.Args[0]
8040 x := v_1.Args[1]
8041 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
8042 break
8043 }
8044 v.reset(OpARMMOVHreg)
8045 v.AddArg(x)
8046 return true
8047 }
8048
8049
8050
8051 for {
8052 if v.AuxInt != 0 {
8053 break
8054 }
8055 sym := v.Aux
8056 mem := v.Args[1]
8057 v_0 := v.Args[0]
8058 if v_0.Op != OpARMADD {
8059 break
8060 }
8061 idx := v_0.Args[1]
8062 ptr := v_0.Args[0]
8063 if !(sym == nil && !config.nacl) {
8064 break
8065 }
8066 v.reset(OpARMMOVHloadidx)
8067 v.AddArg(ptr)
8068 v.AddArg(idx)
8069 v.AddArg(mem)
8070 return true
8071 }
8072 return false
8073 }
8074 func rewriteValueARM_OpARMMOVHloadidx_0(v *Value) bool {
8075
8076
8077
8078 for {
8079 _ = v.Args[2]
8080 ptr := v.Args[0]
8081 idx := v.Args[1]
8082 v_2 := v.Args[2]
8083 if v_2.Op != OpARMMOVHstoreidx {
8084 break
8085 }
8086 _ = v_2.Args[3]
8087 ptr2 := v_2.Args[0]
8088 if idx != v_2.Args[1] {
8089 break
8090 }
8091 x := v_2.Args[2]
8092 if !(isSamePtr(ptr, ptr2)) {
8093 break
8094 }
8095 v.reset(OpARMMOVHreg)
8096 v.AddArg(x)
8097 return true
8098 }
8099
8100
8101
8102 for {
8103 mem := v.Args[2]
8104 ptr := v.Args[0]
8105 v_1 := v.Args[1]
8106 if v_1.Op != OpARMMOVWconst {
8107 break
8108 }
8109 c := v_1.AuxInt
8110 v.reset(OpARMMOVHload)
8111 v.AuxInt = c
8112 v.AddArg(ptr)
8113 v.AddArg(mem)
8114 return true
8115 }
8116
8117
8118
8119 for {
8120 mem := v.Args[2]
8121 v_0 := v.Args[0]
8122 if v_0.Op != OpARMMOVWconst {
8123 break
8124 }
8125 c := v_0.AuxInt
8126 ptr := v.Args[1]
8127 v.reset(OpARMMOVHload)
8128 v.AuxInt = c
8129 v.AddArg(ptr)
8130 v.AddArg(mem)
8131 return true
8132 }
8133 return false
8134 }
8135 func rewriteValueARM_OpARMMOVHreg_0(v *Value) bool {
8136
8137
8138
8139 for {
8140 x := v.Args[0]
8141 if x.Op != OpARMMOVBload {
8142 break
8143 }
8144 _ = x.Args[1]
8145 v.reset(OpARMMOVWreg)
8146 v.AddArg(x)
8147 return true
8148 }
8149
8150
8151
8152 for {
8153 x := v.Args[0]
8154 if x.Op != OpARMMOVBUload {
8155 break
8156 }
8157 _ = x.Args[1]
8158 v.reset(OpARMMOVWreg)
8159 v.AddArg(x)
8160 return true
8161 }
8162
8163
8164
8165 for {
8166 x := v.Args[0]
8167 if x.Op != OpARMMOVHload {
8168 break
8169 }
8170 _ = x.Args[1]
8171 v.reset(OpARMMOVWreg)
8172 v.AddArg(x)
8173 return true
8174 }
8175
8176
8177
8178 for {
8179 v_0 := v.Args[0]
8180 if v_0.Op != OpARMANDconst {
8181 break
8182 }
8183 c := v_0.AuxInt
8184 x := v_0.Args[0]
8185 if !(c&0x8000 == 0) {
8186 break
8187 }
8188 v.reset(OpARMANDconst)
8189 v.AuxInt = c & 0x7fff
8190 v.AddArg(x)
8191 return true
8192 }
8193
8194
8195
8196 for {
8197 x := v.Args[0]
8198 if x.Op != OpARMMOVBreg {
8199 break
8200 }
8201 v.reset(OpARMMOVWreg)
8202 v.AddArg(x)
8203 return true
8204 }
8205
8206
8207
8208 for {
8209 x := v.Args[0]
8210 if x.Op != OpARMMOVBUreg {
8211 break
8212 }
8213 v.reset(OpARMMOVWreg)
8214 v.AddArg(x)
8215 return true
8216 }
8217
8218
8219
8220 for {
8221 x := v.Args[0]
8222 if x.Op != OpARMMOVHreg {
8223 break
8224 }
8225 v.reset(OpARMMOVWreg)
8226 v.AddArg(x)
8227 return true
8228 }
8229
8230
8231
8232 for {
8233 v_0 := v.Args[0]
8234 if v_0.Op != OpARMMOVWconst {
8235 break
8236 }
8237 c := v_0.AuxInt
8238 v.reset(OpARMMOVWconst)
8239 v.AuxInt = int64(int16(c))
8240 return true
8241 }
8242 return false
8243 }
8244 func rewriteValueARM_OpARMMOVHstore_0(v *Value) bool {
8245 b := v.Block
8246 config := b.Func.Config
8247
8248
8249
8250 for {
8251 off1 := v.AuxInt
8252 sym := v.Aux
8253 mem := v.Args[2]
8254 v_0 := v.Args[0]
8255 if v_0.Op != OpARMADDconst {
8256 break
8257 }
8258 off2 := v_0.AuxInt
8259 ptr := v_0.Args[0]
8260 val := v.Args[1]
8261 v.reset(OpARMMOVHstore)
8262 v.AuxInt = off1 + off2
8263 v.Aux = sym
8264 v.AddArg(ptr)
8265 v.AddArg(val)
8266 v.AddArg(mem)
8267 return true
8268 }
8269
8270
8271
8272 for {
8273 off1 := v.AuxInt
8274 sym := v.Aux
8275 mem := v.Args[2]
8276 v_0 := v.Args[0]
8277 if v_0.Op != OpARMSUBconst {
8278 break
8279 }
8280 off2 := v_0.AuxInt
8281 ptr := v_0.Args[0]
8282 val := v.Args[1]
8283 v.reset(OpARMMOVHstore)
8284 v.AuxInt = off1 - off2
8285 v.Aux = sym
8286 v.AddArg(ptr)
8287 v.AddArg(val)
8288 v.AddArg(mem)
8289 return true
8290 }
8291
8292
8293
8294 for {
8295 off1 := v.AuxInt
8296 sym1 := v.Aux
8297 mem := v.Args[2]
8298 v_0 := v.Args[0]
8299 if v_0.Op != OpARMMOVWaddr {
8300 break
8301 }
8302 off2 := v_0.AuxInt
8303 sym2 := v_0.Aux
8304 ptr := v_0.Args[0]
8305 val := v.Args[1]
8306 if !(canMergeSym(sym1, sym2)) {
8307 break
8308 }
8309 v.reset(OpARMMOVHstore)
8310 v.AuxInt = off1 + off2
8311 v.Aux = mergeSym(sym1, sym2)
8312 v.AddArg(ptr)
8313 v.AddArg(val)
8314 v.AddArg(mem)
8315 return true
8316 }
8317
8318
8319
8320 for {
8321 off := v.AuxInt
8322 sym := v.Aux
8323 mem := v.Args[2]
8324 ptr := v.Args[0]
8325 v_1 := v.Args[1]
8326 if v_1.Op != OpARMMOVHreg {
8327 break
8328 }
8329 x := v_1.Args[0]
8330 v.reset(OpARMMOVHstore)
8331 v.AuxInt = off
8332 v.Aux = sym
8333 v.AddArg(ptr)
8334 v.AddArg(x)
8335 v.AddArg(mem)
8336 return true
8337 }
8338
8339
8340
8341 for {
8342 off := v.AuxInt
8343 sym := v.Aux
8344 mem := v.Args[2]
8345 ptr := v.Args[0]
8346 v_1 := v.Args[1]
8347 if v_1.Op != OpARMMOVHUreg {
8348 break
8349 }
8350 x := v_1.Args[0]
8351 v.reset(OpARMMOVHstore)
8352 v.AuxInt = off
8353 v.Aux = sym
8354 v.AddArg(ptr)
8355 v.AddArg(x)
8356 v.AddArg(mem)
8357 return true
8358 }
8359
8360
8361
8362 for {
8363 if v.AuxInt != 0 {
8364 break
8365 }
8366 sym := v.Aux
8367 mem := v.Args[2]
8368 v_0 := v.Args[0]
8369 if v_0.Op != OpARMADD {
8370 break
8371 }
8372 idx := v_0.Args[1]
8373 ptr := v_0.Args[0]
8374 val := v.Args[1]
8375 if !(sym == nil && !config.nacl) {
8376 break
8377 }
8378 v.reset(OpARMMOVHstoreidx)
8379 v.AddArg(ptr)
8380 v.AddArg(idx)
8381 v.AddArg(val)
8382 v.AddArg(mem)
8383 return true
8384 }
8385 return false
8386 }
8387 func rewriteValueARM_OpARMMOVHstoreidx_0(v *Value) bool {
8388
8389
8390
8391 for {
8392 mem := v.Args[3]
8393 ptr := v.Args[0]
8394 v_1 := v.Args[1]
8395 if v_1.Op != OpARMMOVWconst {
8396 break
8397 }
8398 c := v_1.AuxInt
8399 val := v.Args[2]
8400 v.reset(OpARMMOVHstore)
8401 v.AuxInt = c
8402 v.AddArg(ptr)
8403 v.AddArg(val)
8404 v.AddArg(mem)
8405 return true
8406 }
8407
8408
8409
8410 for {
8411 mem := v.Args[3]
8412 v_0 := v.Args[0]
8413 if v_0.Op != OpARMMOVWconst {
8414 break
8415 }
8416 c := v_0.AuxInt
8417 ptr := v.Args[1]
8418 val := v.Args[2]
8419 v.reset(OpARMMOVHstore)
8420 v.AuxInt = c
8421 v.AddArg(ptr)
8422 v.AddArg(val)
8423 v.AddArg(mem)
8424 return true
8425 }
8426 return false
8427 }
8428 func rewriteValueARM_OpARMMOVWload_0(v *Value) bool {
8429 b := v.Block
8430 config := b.Func.Config
8431
8432
8433
8434 for {
8435 off1 := v.AuxInt
8436 sym := v.Aux
8437 mem := v.Args[1]
8438 v_0 := v.Args[0]
8439 if v_0.Op != OpARMADDconst {
8440 break
8441 }
8442 off2 := v_0.AuxInt
8443 ptr := v_0.Args[0]
8444 v.reset(OpARMMOVWload)
8445 v.AuxInt = off1 + off2
8446 v.Aux = sym
8447 v.AddArg(ptr)
8448 v.AddArg(mem)
8449 return true
8450 }
8451
8452
8453
8454 for {
8455 off1 := v.AuxInt
8456 sym := v.Aux
8457 mem := v.Args[1]
8458 v_0 := v.Args[0]
8459 if v_0.Op != OpARMSUBconst {
8460 break
8461 }
8462 off2 := v_0.AuxInt
8463 ptr := v_0.Args[0]
8464 v.reset(OpARMMOVWload)
8465 v.AuxInt = off1 - off2
8466 v.Aux = sym
8467 v.AddArg(ptr)
8468 v.AddArg(mem)
8469 return true
8470 }
8471
8472
8473
8474 for {
8475 off1 := v.AuxInt
8476 sym1 := v.Aux
8477 mem := v.Args[1]
8478 v_0 := v.Args[0]
8479 if v_0.Op != OpARMMOVWaddr {
8480 break
8481 }
8482 off2 := v_0.AuxInt
8483 sym2 := v_0.Aux
8484 ptr := v_0.Args[0]
8485 if !(canMergeSym(sym1, sym2)) {
8486 break
8487 }
8488 v.reset(OpARMMOVWload)
8489 v.AuxInt = off1 + off2
8490 v.Aux = mergeSym(sym1, sym2)
8491 v.AddArg(ptr)
8492 v.AddArg(mem)
8493 return true
8494 }
8495
8496
8497
8498 for {
8499 off := v.AuxInt
8500 sym := v.Aux
8501 _ = v.Args[1]
8502 ptr := v.Args[0]
8503 v_1 := v.Args[1]
8504 if v_1.Op != OpARMMOVWstore {
8505 break
8506 }
8507 off2 := v_1.AuxInt
8508 sym2 := v_1.Aux
8509 _ = v_1.Args[2]
8510 ptr2 := v_1.Args[0]
8511 x := v_1.Args[1]
8512 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
8513 break
8514 }
8515 v.reset(OpCopy)
8516 v.Type = x.Type
8517 v.AddArg(x)
8518 return true
8519 }
8520
8521
8522
8523 for {
8524 if v.AuxInt != 0 {
8525 break
8526 }
8527 sym := v.Aux
8528 mem := v.Args[1]
8529 v_0 := v.Args[0]
8530 if v_0.Op != OpARMADD {
8531 break
8532 }
8533 idx := v_0.Args[1]
8534 ptr := v_0.Args[0]
8535 if !(sym == nil && !config.nacl) {
8536 break
8537 }
8538 v.reset(OpARMMOVWloadidx)
8539 v.AddArg(ptr)
8540 v.AddArg(idx)
8541 v.AddArg(mem)
8542 return true
8543 }
8544
8545
8546
8547 for {
8548 if v.AuxInt != 0 {
8549 break
8550 }
8551 sym := v.Aux
8552 mem := v.Args[1]
8553 v_0 := v.Args[0]
8554 if v_0.Op != OpARMADDshiftLL {
8555 break
8556 }
8557 c := v_0.AuxInt
8558 idx := v_0.Args[1]
8559 ptr := v_0.Args[0]
8560 if !(sym == nil && !config.nacl) {
8561 break
8562 }
8563 v.reset(OpARMMOVWloadshiftLL)
8564 v.AuxInt = c
8565 v.AddArg(ptr)
8566 v.AddArg(idx)
8567 v.AddArg(mem)
8568 return true
8569 }
8570
8571
8572
8573 for {
8574 if v.AuxInt != 0 {
8575 break
8576 }
8577 sym := v.Aux
8578 mem := v.Args[1]
8579 v_0 := v.Args[0]
8580 if v_0.Op != OpARMADDshiftRL {
8581 break
8582 }
8583 c := v_0.AuxInt
8584 idx := v_0.Args[1]
8585 ptr := v_0.Args[0]
8586 if !(sym == nil && !config.nacl) {
8587 break
8588 }
8589 v.reset(OpARMMOVWloadshiftRL)
8590 v.AuxInt = c
8591 v.AddArg(ptr)
8592 v.AddArg(idx)
8593 v.AddArg(mem)
8594 return true
8595 }
8596
8597
8598
8599 for {
8600 if v.AuxInt != 0 {
8601 break
8602 }
8603 sym := v.Aux
8604 mem := v.Args[1]
8605 v_0 := v.Args[0]
8606 if v_0.Op != OpARMADDshiftRA {
8607 break
8608 }
8609 c := v_0.AuxInt
8610 idx := v_0.Args[1]
8611 ptr := v_0.Args[0]
8612 if !(sym == nil && !config.nacl) {
8613 break
8614 }
8615 v.reset(OpARMMOVWloadshiftRA)
8616 v.AuxInt = c
8617 v.AddArg(ptr)
8618 v.AddArg(idx)
8619 v.AddArg(mem)
8620 return true
8621 }
8622
8623
8624
8625 for {
8626 off := v.AuxInt
8627 sym := v.Aux
8628 _ = v.Args[1]
8629 v_0 := v.Args[0]
8630 if v_0.Op != OpSB {
8631 break
8632 }
8633 if !(symIsRO(sym)) {
8634 break
8635 }
8636 v.reset(OpARMMOVWconst)
8637 v.AuxInt = int64(int32(read32(sym, off, config.BigEndian)))
8638 return true
8639 }
8640 return false
8641 }
8642 func rewriteValueARM_OpARMMOVWloadidx_0(v *Value) bool {
8643
8644
8645
8646 for {
8647 _ = v.Args[2]
8648 ptr := v.Args[0]
8649 idx := v.Args[1]
8650 v_2 := v.Args[2]
8651 if v_2.Op != OpARMMOVWstoreidx {
8652 break
8653 }
8654 _ = v_2.Args[3]
8655 ptr2 := v_2.Args[0]
8656 if idx != v_2.Args[1] {
8657 break
8658 }
8659 x := v_2.Args[2]
8660 if !(isSamePtr(ptr, ptr2)) {
8661 break
8662 }
8663 v.reset(OpCopy)
8664 v.Type = x.Type
8665 v.AddArg(x)
8666 return true
8667 }
8668
8669
8670
8671 for {
8672 mem := v.Args[2]
8673 ptr := v.Args[0]
8674 v_1 := v.Args[1]
8675 if v_1.Op != OpARMMOVWconst {
8676 break
8677 }
8678 c := v_1.AuxInt
8679 v.reset(OpARMMOVWload)
8680 v.AuxInt = c
8681 v.AddArg(ptr)
8682 v.AddArg(mem)
8683 return true
8684 }
8685
8686
8687
8688 for {
8689 mem := v.Args[2]
8690 v_0 := v.Args[0]
8691 if v_0.Op != OpARMMOVWconst {
8692 break
8693 }
8694 c := v_0.AuxInt
8695 ptr := v.Args[1]
8696 v.reset(OpARMMOVWload)
8697 v.AuxInt = c
8698 v.AddArg(ptr)
8699 v.AddArg(mem)
8700 return true
8701 }
8702
8703
8704
8705 for {
8706 mem := v.Args[2]
8707 ptr := v.Args[0]
8708 v_1 := v.Args[1]
8709 if v_1.Op != OpARMSLLconst {
8710 break
8711 }
8712 c := v_1.AuxInt
8713 idx := v_1.Args[0]
8714 v.reset(OpARMMOVWloadshiftLL)
8715 v.AuxInt = c
8716 v.AddArg(ptr)
8717 v.AddArg(idx)
8718 v.AddArg(mem)
8719 return true
8720 }
8721
8722
8723
8724 for {
8725 mem := v.Args[2]
8726 v_0 := v.Args[0]
8727 if v_0.Op != OpARMSLLconst {
8728 break
8729 }
8730 c := v_0.AuxInt
8731 idx := v_0.Args[0]
8732 ptr := v.Args[1]
8733 v.reset(OpARMMOVWloadshiftLL)
8734 v.AuxInt = c
8735 v.AddArg(ptr)
8736 v.AddArg(idx)
8737 v.AddArg(mem)
8738 return true
8739 }
8740
8741
8742
8743 for {
8744 mem := v.Args[2]
8745 ptr := v.Args[0]
8746 v_1 := v.Args[1]
8747 if v_1.Op != OpARMSRLconst {
8748 break
8749 }
8750 c := v_1.AuxInt
8751 idx := v_1.Args[0]
8752 v.reset(OpARMMOVWloadshiftRL)
8753 v.AuxInt = c
8754 v.AddArg(ptr)
8755 v.AddArg(idx)
8756 v.AddArg(mem)
8757 return true
8758 }
8759
8760
8761
8762 for {
8763 mem := v.Args[2]
8764 v_0 := v.Args[0]
8765 if v_0.Op != OpARMSRLconst {
8766 break
8767 }
8768 c := v_0.AuxInt
8769 idx := v_0.Args[0]
8770 ptr := v.Args[1]
8771 v.reset(OpARMMOVWloadshiftRL)
8772 v.AuxInt = c
8773 v.AddArg(ptr)
8774 v.AddArg(idx)
8775 v.AddArg(mem)
8776 return true
8777 }
8778
8779
8780
8781 for {
8782 mem := v.Args[2]
8783 ptr := v.Args[0]
8784 v_1 := v.Args[1]
8785 if v_1.Op != OpARMSRAconst {
8786 break
8787 }
8788 c := v_1.AuxInt
8789 idx := v_1.Args[0]
8790 v.reset(OpARMMOVWloadshiftRA)
8791 v.AuxInt = c
8792 v.AddArg(ptr)
8793 v.AddArg(idx)
8794 v.AddArg(mem)
8795 return true
8796 }
8797
8798
8799
8800 for {
8801 mem := v.Args[2]
8802 v_0 := v.Args[0]
8803 if v_0.Op != OpARMSRAconst {
8804 break
8805 }
8806 c := v_0.AuxInt
8807 idx := v_0.Args[0]
8808 ptr := v.Args[1]
8809 v.reset(OpARMMOVWloadshiftRA)
8810 v.AuxInt = c
8811 v.AddArg(ptr)
8812 v.AddArg(idx)
8813 v.AddArg(mem)
8814 return true
8815 }
8816 return false
8817 }
8818 func rewriteValueARM_OpARMMOVWloadshiftLL_0(v *Value) bool {
8819
8820
8821
8822 for {
8823 c := v.AuxInt
8824 _ = v.Args[2]
8825 ptr := v.Args[0]
8826 idx := v.Args[1]
8827 v_2 := v.Args[2]
8828 if v_2.Op != OpARMMOVWstoreshiftLL {
8829 break
8830 }
8831 d := v_2.AuxInt
8832 _ = v_2.Args[3]
8833 ptr2 := v_2.Args[0]
8834 if idx != v_2.Args[1] {
8835 break
8836 }
8837 x := v_2.Args[2]
8838 if !(c == d && isSamePtr(ptr, ptr2)) {
8839 break
8840 }
8841 v.reset(OpCopy)
8842 v.Type = x.Type
8843 v.AddArg(x)
8844 return true
8845 }
8846
8847
8848
8849 for {
8850 d := v.AuxInt
8851 mem := v.Args[2]
8852 ptr := v.Args[0]
8853 v_1 := v.Args[1]
8854 if v_1.Op != OpARMMOVWconst {
8855 break
8856 }
8857 c := v_1.AuxInt
8858 v.reset(OpARMMOVWload)
8859 v.AuxInt = int64(uint32(c) << uint64(d))
8860 v.AddArg(ptr)
8861 v.AddArg(mem)
8862 return true
8863 }
8864 return false
8865 }
8866 func rewriteValueARM_OpARMMOVWloadshiftRA_0(v *Value) bool {
8867
8868
8869
8870 for {
8871 c := v.AuxInt
8872 _ = v.Args[2]
8873 ptr := v.Args[0]
8874 idx := v.Args[1]
8875 v_2 := v.Args[2]
8876 if v_2.Op != OpARMMOVWstoreshiftRA {
8877 break
8878 }
8879 d := v_2.AuxInt
8880 _ = v_2.Args[3]
8881 ptr2 := v_2.Args[0]
8882 if idx != v_2.Args[1] {
8883 break
8884 }
8885 x := v_2.Args[2]
8886 if !(c == d && isSamePtr(ptr, ptr2)) {
8887 break
8888 }
8889 v.reset(OpCopy)
8890 v.Type = x.Type
8891 v.AddArg(x)
8892 return true
8893 }
8894
8895
8896
8897 for {
8898 d := v.AuxInt
8899 mem := v.Args[2]
8900 ptr := v.Args[0]
8901 v_1 := v.Args[1]
8902 if v_1.Op != OpARMMOVWconst {
8903 break
8904 }
8905 c := v_1.AuxInt
8906 v.reset(OpARMMOVWload)
8907 v.AuxInt = int64(int32(c) >> uint64(d))
8908 v.AddArg(ptr)
8909 v.AddArg(mem)
8910 return true
8911 }
8912 return false
8913 }
8914 func rewriteValueARM_OpARMMOVWloadshiftRL_0(v *Value) bool {
8915
8916
8917
8918 for {
8919 c := v.AuxInt
8920 _ = v.Args[2]
8921 ptr := v.Args[0]
8922 idx := v.Args[1]
8923 v_2 := v.Args[2]
8924 if v_2.Op != OpARMMOVWstoreshiftRL {
8925 break
8926 }
8927 d := v_2.AuxInt
8928 _ = v_2.Args[3]
8929 ptr2 := v_2.Args[0]
8930 if idx != v_2.Args[1] {
8931 break
8932 }
8933 x := v_2.Args[2]
8934 if !(c == d && isSamePtr(ptr, ptr2)) {
8935 break
8936 }
8937 v.reset(OpCopy)
8938 v.Type = x.Type
8939 v.AddArg(x)
8940 return true
8941 }
8942
8943
8944
8945 for {
8946 d := v.AuxInt
8947 mem := v.Args[2]
8948 ptr := v.Args[0]
8949 v_1 := v.Args[1]
8950 if v_1.Op != OpARMMOVWconst {
8951 break
8952 }
8953 c := v_1.AuxInt
8954 v.reset(OpARMMOVWload)
8955 v.AuxInt = int64(uint32(c) >> uint64(d))
8956 v.AddArg(ptr)
8957 v.AddArg(mem)
8958 return true
8959 }
8960 return false
8961 }
8962 func rewriteValueARM_OpARMMOVWreg_0(v *Value) bool {
8963
8964
8965
8966 for {
8967 x := v.Args[0]
8968 if !(x.Uses == 1) {
8969 break
8970 }
8971 v.reset(OpARMMOVWnop)
8972 v.AddArg(x)
8973 return true
8974 }
8975
8976
8977
8978 for {
8979 v_0 := v.Args[0]
8980 if v_0.Op != OpARMMOVWconst {
8981 break
8982 }
8983 c := v_0.AuxInt
8984 v.reset(OpARMMOVWconst)
8985 v.AuxInt = c
8986 return true
8987 }
8988 return false
8989 }
8990 func rewriteValueARM_OpARMMOVWstore_0(v *Value) bool {
8991 b := v.Block
8992 config := b.Func.Config
8993
8994
8995
8996 for {
8997 off1 := v.AuxInt
8998 sym := v.Aux
8999 mem := v.Args[2]
9000 v_0 := v.Args[0]
9001 if v_0.Op != OpARMADDconst {
9002 break
9003 }
9004 off2 := v_0.AuxInt
9005 ptr := v_0.Args[0]
9006 val := v.Args[1]
9007 v.reset(OpARMMOVWstore)
9008 v.AuxInt = off1 + off2
9009 v.Aux = sym
9010 v.AddArg(ptr)
9011 v.AddArg(val)
9012 v.AddArg(mem)
9013 return true
9014 }
9015
9016
9017
9018 for {
9019 off1 := v.AuxInt
9020 sym := v.Aux
9021 mem := v.Args[2]
9022 v_0 := v.Args[0]
9023 if v_0.Op != OpARMSUBconst {
9024 break
9025 }
9026 off2 := v_0.AuxInt
9027 ptr := v_0.Args[0]
9028 val := v.Args[1]
9029 v.reset(OpARMMOVWstore)
9030 v.AuxInt = off1 - off2
9031 v.Aux = sym
9032 v.AddArg(ptr)
9033 v.AddArg(val)
9034 v.AddArg(mem)
9035 return true
9036 }
9037
9038
9039
9040 for {
9041 off1 := v.AuxInt
9042 sym1 := v.Aux
9043 mem := v.Args[2]
9044 v_0 := v.Args[0]
9045 if v_0.Op != OpARMMOVWaddr {
9046 break
9047 }
9048 off2 := v_0.AuxInt
9049 sym2 := v_0.Aux
9050 ptr := v_0.Args[0]
9051 val := v.Args[1]
9052 if !(canMergeSym(sym1, sym2)) {
9053 break
9054 }
9055 v.reset(OpARMMOVWstore)
9056 v.AuxInt = off1 + off2
9057 v.Aux = mergeSym(sym1, sym2)
9058 v.AddArg(ptr)
9059 v.AddArg(val)
9060 v.AddArg(mem)
9061 return true
9062 }
9063
9064
9065
9066 for {
9067 if v.AuxInt != 0 {
9068 break
9069 }
9070 sym := v.Aux
9071 mem := v.Args[2]
9072 v_0 := v.Args[0]
9073 if v_0.Op != OpARMADD {
9074 break
9075 }
9076 idx := v_0.Args[1]
9077 ptr := v_0.Args[0]
9078 val := v.Args[1]
9079 if !(sym == nil && !config.nacl) {
9080 break
9081 }
9082 v.reset(OpARMMOVWstoreidx)
9083 v.AddArg(ptr)
9084 v.AddArg(idx)
9085 v.AddArg(val)
9086 v.AddArg(mem)
9087 return true
9088 }
9089
9090
9091
9092 for {
9093 if v.AuxInt != 0 {
9094 break
9095 }
9096 sym := v.Aux
9097 mem := v.Args[2]
9098 v_0 := v.Args[0]
9099 if v_0.Op != OpARMADDshiftLL {
9100 break
9101 }
9102 c := v_0.AuxInt
9103 idx := v_0.Args[1]
9104 ptr := v_0.Args[0]
9105 val := v.Args[1]
9106 if !(sym == nil && !config.nacl) {
9107 break
9108 }
9109 v.reset(OpARMMOVWstoreshiftLL)
9110 v.AuxInt = c
9111 v.AddArg(ptr)
9112 v.AddArg(idx)
9113 v.AddArg(val)
9114 v.AddArg(mem)
9115 return true
9116 }
9117
9118
9119
9120 for {
9121 if v.AuxInt != 0 {
9122 break
9123 }
9124 sym := v.Aux
9125 mem := v.Args[2]
9126 v_0 := v.Args[0]
9127 if v_0.Op != OpARMADDshiftRL {
9128 break
9129 }
9130 c := v_0.AuxInt
9131 idx := v_0.Args[1]
9132 ptr := v_0.Args[0]
9133 val := v.Args[1]
9134 if !(sym == nil && !config.nacl) {
9135 break
9136 }
9137 v.reset(OpARMMOVWstoreshiftRL)
9138 v.AuxInt = c
9139 v.AddArg(ptr)
9140 v.AddArg(idx)
9141 v.AddArg(val)
9142 v.AddArg(mem)
9143 return true
9144 }
9145
9146
9147
9148 for {
9149 if v.AuxInt != 0 {
9150 break
9151 }
9152 sym := v.Aux
9153 mem := v.Args[2]
9154 v_0 := v.Args[0]
9155 if v_0.Op != OpARMADDshiftRA {
9156 break
9157 }
9158 c := v_0.AuxInt
9159 idx := v_0.Args[1]
9160 ptr := v_0.Args[0]
9161 val := v.Args[1]
9162 if !(sym == nil && !config.nacl) {
9163 break
9164 }
9165 v.reset(OpARMMOVWstoreshiftRA)
9166 v.AuxInt = c
9167 v.AddArg(ptr)
9168 v.AddArg(idx)
9169 v.AddArg(val)
9170 v.AddArg(mem)
9171 return true
9172 }
9173 return false
9174 }
9175 func rewriteValueARM_OpARMMOVWstoreidx_0(v *Value) bool {
9176
9177
9178
9179 for {
9180 mem := v.Args[3]
9181 ptr := v.Args[0]
9182 v_1 := v.Args[1]
9183 if v_1.Op != OpARMMOVWconst {
9184 break
9185 }
9186 c := v_1.AuxInt
9187 val := v.Args[2]
9188 v.reset(OpARMMOVWstore)
9189 v.AuxInt = c
9190 v.AddArg(ptr)
9191 v.AddArg(val)
9192 v.AddArg(mem)
9193 return true
9194 }
9195
9196
9197
9198 for {
9199 mem := v.Args[3]
9200 v_0 := v.Args[0]
9201 if v_0.Op != OpARMMOVWconst {
9202 break
9203 }
9204 c := v_0.AuxInt
9205 ptr := v.Args[1]
9206 val := v.Args[2]
9207 v.reset(OpARMMOVWstore)
9208 v.AuxInt = c
9209 v.AddArg(ptr)
9210 v.AddArg(val)
9211 v.AddArg(mem)
9212 return true
9213 }
9214
9215
9216
9217 for {
9218 mem := v.Args[3]
9219 ptr := v.Args[0]
9220 v_1 := v.Args[1]
9221 if v_1.Op != OpARMSLLconst {
9222 break
9223 }
9224 c := v_1.AuxInt
9225 idx := v_1.Args[0]
9226 val := v.Args[2]
9227 v.reset(OpARMMOVWstoreshiftLL)
9228 v.AuxInt = c
9229 v.AddArg(ptr)
9230 v.AddArg(idx)
9231 v.AddArg(val)
9232 v.AddArg(mem)
9233 return true
9234 }
9235
9236
9237
9238 for {
9239 mem := v.Args[3]
9240 v_0 := v.Args[0]
9241 if v_0.Op != OpARMSLLconst {
9242 break
9243 }
9244 c := v_0.AuxInt
9245 idx := v_0.Args[0]
9246 ptr := v.Args[1]
9247 val := v.Args[2]
9248 v.reset(OpARMMOVWstoreshiftLL)
9249 v.AuxInt = c
9250 v.AddArg(ptr)
9251 v.AddArg(idx)
9252 v.AddArg(val)
9253 v.AddArg(mem)
9254 return true
9255 }
9256
9257
9258
9259 for {
9260 mem := v.Args[3]
9261 ptr := v.Args[0]
9262 v_1 := v.Args[1]
9263 if v_1.Op != OpARMSRLconst {
9264 break
9265 }
9266 c := v_1.AuxInt
9267 idx := v_1.Args[0]
9268 val := v.Args[2]
9269 v.reset(OpARMMOVWstoreshiftRL)
9270 v.AuxInt = c
9271 v.AddArg(ptr)
9272 v.AddArg(idx)
9273 v.AddArg(val)
9274 v.AddArg(mem)
9275 return true
9276 }
9277
9278
9279
9280 for {
9281 mem := v.Args[3]
9282 v_0 := v.Args[0]
9283 if v_0.Op != OpARMSRLconst {
9284 break
9285 }
9286 c := v_0.AuxInt
9287 idx := v_0.Args[0]
9288 ptr := v.Args[1]
9289 val := v.Args[2]
9290 v.reset(OpARMMOVWstoreshiftRL)
9291 v.AuxInt = c
9292 v.AddArg(ptr)
9293 v.AddArg(idx)
9294 v.AddArg(val)
9295 v.AddArg(mem)
9296 return true
9297 }
9298
9299
9300
9301 for {
9302 mem := v.Args[3]
9303 ptr := v.Args[0]
9304 v_1 := v.Args[1]
9305 if v_1.Op != OpARMSRAconst {
9306 break
9307 }
9308 c := v_1.AuxInt
9309 idx := v_1.Args[0]
9310 val := v.Args[2]
9311 v.reset(OpARMMOVWstoreshiftRA)
9312 v.AuxInt = c
9313 v.AddArg(ptr)
9314 v.AddArg(idx)
9315 v.AddArg(val)
9316 v.AddArg(mem)
9317 return true
9318 }
9319
9320
9321
9322 for {
9323 mem := v.Args[3]
9324 v_0 := v.Args[0]
9325 if v_0.Op != OpARMSRAconst {
9326 break
9327 }
9328 c := v_0.AuxInt
9329 idx := v_0.Args[0]
9330 ptr := v.Args[1]
9331 val := v.Args[2]
9332 v.reset(OpARMMOVWstoreshiftRA)
9333 v.AuxInt = c
9334 v.AddArg(ptr)
9335 v.AddArg(idx)
9336 v.AddArg(val)
9337 v.AddArg(mem)
9338 return true
9339 }
9340 return false
9341 }
9342 func rewriteValueARM_OpARMMOVWstoreshiftLL_0(v *Value) bool {
9343
9344
9345
9346 for {
9347 d := v.AuxInt
9348 mem := v.Args[3]
9349 ptr := v.Args[0]
9350 v_1 := v.Args[1]
9351 if v_1.Op != OpARMMOVWconst {
9352 break
9353 }
9354 c := v_1.AuxInt
9355 val := v.Args[2]
9356 v.reset(OpARMMOVWstore)
9357 v.AuxInt = int64(uint32(c) << uint64(d))
9358 v.AddArg(ptr)
9359 v.AddArg(val)
9360 v.AddArg(mem)
9361 return true
9362 }
9363 return false
9364 }
9365 func rewriteValueARM_OpARMMOVWstoreshiftRA_0(v *Value) bool {
9366
9367
9368
9369 for {
9370 d := v.AuxInt
9371 mem := v.Args[3]
9372 ptr := v.Args[0]
9373 v_1 := v.Args[1]
9374 if v_1.Op != OpARMMOVWconst {
9375 break
9376 }
9377 c := v_1.AuxInt
9378 val := v.Args[2]
9379 v.reset(OpARMMOVWstore)
9380 v.AuxInt = int64(int32(c) >> uint64(d))
9381 v.AddArg(ptr)
9382 v.AddArg(val)
9383 v.AddArg(mem)
9384 return true
9385 }
9386 return false
9387 }
9388 func rewriteValueARM_OpARMMOVWstoreshiftRL_0(v *Value) bool {
9389
9390
9391
9392 for {
9393 d := v.AuxInt
9394 mem := v.Args[3]
9395 ptr := v.Args[0]
9396 v_1 := v.Args[1]
9397 if v_1.Op != OpARMMOVWconst {
9398 break
9399 }
9400 c := v_1.AuxInt
9401 val := v.Args[2]
9402 v.reset(OpARMMOVWstore)
9403 v.AuxInt = int64(uint32(c) >> uint64(d))
9404 v.AddArg(ptr)
9405 v.AddArg(val)
9406 v.AddArg(mem)
9407 return true
9408 }
9409 return false
9410 }
9411 func rewriteValueARM_OpARMMUL_0(v *Value) bool {
9412
9413
9414
9415 for {
9416 _ = v.Args[1]
9417 x := v.Args[0]
9418 v_1 := v.Args[1]
9419 if v_1.Op != OpARMMOVWconst {
9420 break
9421 }
9422 c := v_1.AuxInt
9423 if !(int32(c) == -1) {
9424 break
9425 }
9426 v.reset(OpARMRSBconst)
9427 v.AuxInt = 0
9428 v.AddArg(x)
9429 return true
9430 }
9431
9432
9433
9434 for {
9435 x := v.Args[1]
9436 v_0 := v.Args[0]
9437 if v_0.Op != OpARMMOVWconst {
9438 break
9439 }
9440 c := v_0.AuxInt
9441 if !(int32(c) == -1) {
9442 break
9443 }
9444 v.reset(OpARMRSBconst)
9445 v.AuxInt = 0
9446 v.AddArg(x)
9447 return true
9448 }
9449
9450
9451
9452 for {
9453 _ = v.Args[1]
9454 v_1 := v.Args[1]
9455 if v_1.Op != OpARMMOVWconst {
9456 break
9457 }
9458 if v_1.AuxInt != 0 {
9459 break
9460 }
9461 v.reset(OpARMMOVWconst)
9462 v.AuxInt = 0
9463 return true
9464 }
9465
9466
9467
9468 for {
9469 _ = v.Args[1]
9470 v_0 := v.Args[0]
9471 if v_0.Op != OpARMMOVWconst {
9472 break
9473 }
9474 if v_0.AuxInt != 0 {
9475 break
9476 }
9477 v.reset(OpARMMOVWconst)
9478 v.AuxInt = 0
9479 return true
9480 }
9481
9482
9483
9484 for {
9485 _ = v.Args[1]
9486 x := v.Args[0]
9487 v_1 := v.Args[1]
9488 if v_1.Op != OpARMMOVWconst {
9489 break
9490 }
9491 if v_1.AuxInt != 1 {
9492 break
9493 }
9494 v.reset(OpCopy)
9495 v.Type = x.Type
9496 v.AddArg(x)
9497 return true
9498 }
9499
9500
9501
9502 for {
9503 x := v.Args[1]
9504 v_0 := v.Args[0]
9505 if v_0.Op != OpARMMOVWconst {
9506 break
9507 }
9508 if v_0.AuxInt != 1 {
9509 break
9510 }
9511 v.reset(OpCopy)
9512 v.Type = x.Type
9513 v.AddArg(x)
9514 return true
9515 }
9516
9517
9518
9519 for {
9520 _ = v.Args[1]
9521 x := v.Args[0]
9522 v_1 := v.Args[1]
9523 if v_1.Op != OpARMMOVWconst {
9524 break
9525 }
9526 c := v_1.AuxInt
9527 if !(isPowerOfTwo(c)) {
9528 break
9529 }
9530 v.reset(OpARMSLLconst)
9531 v.AuxInt = log2(c)
9532 v.AddArg(x)
9533 return true
9534 }
9535
9536
9537
9538 for {
9539 x := v.Args[1]
9540 v_0 := v.Args[0]
9541 if v_0.Op != OpARMMOVWconst {
9542 break
9543 }
9544 c := v_0.AuxInt
9545 if !(isPowerOfTwo(c)) {
9546 break
9547 }
9548 v.reset(OpARMSLLconst)
9549 v.AuxInt = log2(c)
9550 v.AddArg(x)
9551 return true
9552 }
9553
9554
9555
9556 for {
9557 _ = v.Args[1]
9558 x := v.Args[0]
9559 v_1 := v.Args[1]
9560 if v_1.Op != OpARMMOVWconst {
9561 break
9562 }
9563 c := v_1.AuxInt
9564 if !(isPowerOfTwo(c-1) && int32(c) >= 3) {
9565 break
9566 }
9567 v.reset(OpARMADDshiftLL)
9568 v.AuxInt = log2(c - 1)
9569 v.AddArg(x)
9570 v.AddArg(x)
9571 return true
9572 }
9573
9574
9575
9576 for {
9577 x := v.Args[1]
9578 v_0 := v.Args[0]
9579 if v_0.Op != OpARMMOVWconst {
9580 break
9581 }
9582 c := v_0.AuxInt
9583 if !(isPowerOfTwo(c-1) && int32(c) >= 3) {
9584 break
9585 }
9586 v.reset(OpARMADDshiftLL)
9587 v.AuxInt = log2(c - 1)
9588 v.AddArg(x)
9589 v.AddArg(x)
9590 return true
9591 }
9592 return false
9593 }
9594 func rewriteValueARM_OpARMMUL_10(v *Value) bool {
9595 b := v.Block
9596
9597
9598
9599 for {
9600 _ = v.Args[1]
9601 x := v.Args[0]
9602 v_1 := v.Args[1]
9603 if v_1.Op != OpARMMOVWconst {
9604 break
9605 }
9606 c := v_1.AuxInt
9607 if !(isPowerOfTwo(c+1) && int32(c) >= 7) {
9608 break
9609 }
9610 v.reset(OpARMRSBshiftLL)
9611 v.AuxInt = log2(c + 1)
9612 v.AddArg(x)
9613 v.AddArg(x)
9614 return true
9615 }
9616
9617
9618
9619 for {
9620 x := v.Args[1]
9621 v_0 := v.Args[0]
9622 if v_0.Op != OpARMMOVWconst {
9623 break
9624 }
9625 c := v_0.AuxInt
9626 if !(isPowerOfTwo(c+1) && int32(c) >= 7) {
9627 break
9628 }
9629 v.reset(OpARMRSBshiftLL)
9630 v.AuxInt = log2(c + 1)
9631 v.AddArg(x)
9632 v.AddArg(x)
9633 return true
9634 }
9635
9636
9637
9638 for {
9639 _ = v.Args[1]
9640 x := v.Args[0]
9641 v_1 := v.Args[1]
9642 if v_1.Op != OpARMMOVWconst {
9643 break
9644 }
9645 c := v_1.AuxInt
9646 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) {
9647 break
9648 }
9649 v.reset(OpARMSLLconst)
9650 v.AuxInt = log2(c / 3)
9651 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
9652 v0.AuxInt = 1
9653 v0.AddArg(x)
9654 v0.AddArg(x)
9655 v.AddArg(v0)
9656 return true
9657 }
9658
9659
9660
9661 for {
9662 x := v.Args[1]
9663 v_0 := v.Args[0]
9664 if v_0.Op != OpARMMOVWconst {
9665 break
9666 }
9667 c := v_0.AuxInt
9668 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) {
9669 break
9670 }
9671 v.reset(OpARMSLLconst)
9672 v.AuxInt = log2(c / 3)
9673 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
9674 v0.AuxInt = 1
9675 v0.AddArg(x)
9676 v0.AddArg(x)
9677 v.AddArg(v0)
9678 return true
9679 }
9680
9681
9682
9683 for {
9684 _ = v.Args[1]
9685 x := v.Args[0]
9686 v_1 := v.Args[1]
9687 if v_1.Op != OpARMMOVWconst {
9688 break
9689 }
9690 c := v_1.AuxInt
9691 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) {
9692 break
9693 }
9694 v.reset(OpARMSLLconst)
9695 v.AuxInt = log2(c / 5)
9696 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
9697 v0.AuxInt = 2
9698 v0.AddArg(x)
9699 v0.AddArg(x)
9700 v.AddArg(v0)
9701 return true
9702 }
9703
9704
9705
9706 for {
9707 x := v.Args[1]
9708 v_0 := v.Args[0]
9709 if v_0.Op != OpARMMOVWconst {
9710 break
9711 }
9712 c := v_0.AuxInt
9713 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) {
9714 break
9715 }
9716 v.reset(OpARMSLLconst)
9717 v.AuxInt = log2(c / 5)
9718 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
9719 v0.AuxInt = 2
9720 v0.AddArg(x)
9721 v0.AddArg(x)
9722 v.AddArg(v0)
9723 return true
9724 }
9725
9726
9727
9728 for {
9729 _ = v.Args[1]
9730 x := v.Args[0]
9731 v_1 := v.Args[1]
9732 if v_1.Op != OpARMMOVWconst {
9733 break
9734 }
9735 c := v_1.AuxInt
9736 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) {
9737 break
9738 }
9739 v.reset(OpARMSLLconst)
9740 v.AuxInt = log2(c / 7)
9741 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
9742 v0.AuxInt = 3
9743 v0.AddArg(x)
9744 v0.AddArg(x)
9745 v.AddArg(v0)
9746 return true
9747 }
9748
9749
9750
9751 for {
9752 x := v.Args[1]
9753 v_0 := v.Args[0]
9754 if v_0.Op != OpARMMOVWconst {
9755 break
9756 }
9757 c := v_0.AuxInt
9758 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) {
9759 break
9760 }
9761 v.reset(OpARMSLLconst)
9762 v.AuxInt = log2(c / 7)
9763 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
9764 v0.AuxInt = 3
9765 v0.AddArg(x)
9766 v0.AddArg(x)
9767 v.AddArg(v0)
9768 return true
9769 }
9770
9771
9772
9773 for {
9774 _ = v.Args[1]
9775 x := v.Args[0]
9776 v_1 := v.Args[1]
9777 if v_1.Op != OpARMMOVWconst {
9778 break
9779 }
9780 c := v_1.AuxInt
9781 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) {
9782 break
9783 }
9784 v.reset(OpARMSLLconst)
9785 v.AuxInt = log2(c / 9)
9786 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
9787 v0.AuxInt = 3
9788 v0.AddArg(x)
9789 v0.AddArg(x)
9790 v.AddArg(v0)
9791 return true
9792 }
9793
9794
9795
9796 for {
9797 x := v.Args[1]
9798 v_0 := v.Args[0]
9799 if v_0.Op != OpARMMOVWconst {
9800 break
9801 }
9802 c := v_0.AuxInt
9803 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) {
9804 break
9805 }
9806 v.reset(OpARMSLLconst)
9807 v.AuxInt = log2(c / 9)
9808 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
9809 v0.AuxInt = 3
9810 v0.AddArg(x)
9811 v0.AddArg(x)
9812 v.AddArg(v0)
9813 return true
9814 }
9815 return false
9816 }
9817 func rewriteValueARM_OpARMMUL_20(v *Value) bool {
9818
9819
9820
9821 for {
9822 _ = v.Args[1]
9823 v_0 := v.Args[0]
9824 if v_0.Op != OpARMMOVWconst {
9825 break
9826 }
9827 c := v_0.AuxInt
9828 v_1 := v.Args[1]
9829 if v_1.Op != OpARMMOVWconst {
9830 break
9831 }
9832 d := v_1.AuxInt
9833 v.reset(OpARMMOVWconst)
9834 v.AuxInt = int64(int32(c * d))
9835 return true
9836 }
9837
9838
9839
9840 for {
9841 _ = v.Args[1]
9842 v_0 := v.Args[0]
9843 if v_0.Op != OpARMMOVWconst {
9844 break
9845 }
9846 d := v_0.AuxInt
9847 v_1 := v.Args[1]
9848 if v_1.Op != OpARMMOVWconst {
9849 break
9850 }
9851 c := v_1.AuxInt
9852 v.reset(OpARMMOVWconst)
9853 v.AuxInt = int64(int32(c * d))
9854 return true
9855 }
9856 return false
9857 }
9858 func rewriteValueARM_OpARMMULA_0(v *Value) bool {
9859 b := v.Block
9860
9861
9862
9863 for {
9864 a := v.Args[2]
9865 x := v.Args[0]
9866 v_1 := v.Args[1]
9867 if v_1.Op != OpARMMOVWconst {
9868 break
9869 }
9870 c := v_1.AuxInt
9871 if !(int32(c) == -1) {
9872 break
9873 }
9874 v.reset(OpARMSUB)
9875 v.AddArg(a)
9876 v.AddArg(x)
9877 return true
9878 }
9879
9880
9881
9882 for {
9883 a := v.Args[2]
9884 v_1 := v.Args[1]
9885 if v_1.Op != OpARMMOVWconst {
9886 break
9887 }
9888 if v_1.AuxInt != 0 {
9889 break
9890 }
9891 v.reset(OpCopy)
9892 v.Type = a.Type
9893 v.AddArg(a)
9894 return true
9895 }
9896
9897
9898
9899 for {
9900 a := v.Args[2]
9901 x := v.Args[0]
9902 v_1 := v.Args[1]
9903 if v_1.Op != OpARMMOVWconst {
9904 break
9905 }
9906 if v_1.AuxInt != 1 {
9907 break
9908 }
9909 v.reset(OpARMADD)
9910 v.AddArg(x)
9911 v.AddArg(a)
9912 return true
9913 }
9914
9915
9916
9917 for {
9918 a := v.Args[2]
9919 x := v.Args[0]
9920 v_1 := v.Args[1]
9921 if v_1.Op != OpARMMOVWconst {
9922 break
9923 }
9924 c := v_1.AuxInt
9925 if !(isPowerOfTwo(c)) {
9926 break
9927 }
9928 v.reset(OpARMADD)
9929 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
9930 v0.AuxInt = log2(c)
9931 v0.AddArg(x)
9932 v.AddArg(v0)
9933 v.AddArg(a)
9934 return true
9935 }
9936
9937
9938
9939 for {
9940 a := v.Args[2]
9941 x := v.Args[0]
9942 v_1 := v.Args[1]
9943 if v_1.Op != OpARMMOVWconst {
9944 break
9945 }
9946 c := v_1.AuxInt
9947 if !(isPowerOfTwo(c-1) && int32(c) >= 3) {
9948 break
9949 }
9950 v.reset(OpARMADD)
9951 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
9952 v0.AuxInt = log2(c - 1)
9953 v0.AddArg(x)
9954 v0.AddArg(x)
9955 v.AddArg(v0)
9956 v.AddArg(a)
9957 return true
9958 }
9959
9960
9961
9962 for {
9963 a := v.Args[2]
9964 x := v.Args[0]
9965 v_1 := v.Args[1]
9966 if v_1.Op != OpARMMOVWconst {
9967 break
9968 }
9969 c := v_1.AuxInt
9970 if !(isPowerOfTwo(c+1) && int32(c) >= 7) {
9971 break
9972 }
9973 v.reset(OpARMADD)
9974 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
9975 v0.AuxInt = log2(c + 1)
9976 v0.AddArg(x)
9977 v0.AddArg(x)
9978 v.AddArg(v0)
9979 v.AddArg(a)
9980 return true
9981 }
9982
9983
9984
9985 for {
9986 a := v.Args[2]
9987 x := v.Args[0]
9988 v_1 := v.Args[1]
9989 if v_1.Op != OpARMMOVWconst {
9990 break
9991 }
9992 c := v_1.AuxInt
9993 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) {
9994 break
9995 }
9996 v.reset(OpARMADD)
9997 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
9998 v0.AuxInt = log2(c / 3)
9999 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
10000 v1.AuxInt = 1
10001 v1.AddArg(x)
10002 v1.AddArg(x)
10003 v0.AddArg(v1)
10004 v.AddArg(v0)
10005 v.AddArg(a)
10006 return true
10007 }
10008
10009
10010
10011 for {
10012 a := v.Args[2]
10013 x := v.Args[0]
10014 v_1 := v.Args[1]
10015 if v_1.Op != OpARMMOVWconst {
10016 break
10017 }
10018 c := v_1.AuxInt
10019 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) {
10020 break
10021 }
10022 v.reset(OpARMADD)
10023 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10024 v0.AuxInt = log2(c / 5)
10025 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
10026 v1.AuxInt = 2
10027 v1.AddArg(x)
10028 v1.AddArg(x)
10029 v0.AddArg(v1)
10030 v.AddArg(v0)
10031 v.AddArg(a)
10032 return true
10033 }
10034
10035
10036
10037 for {
10038 a := v.Args[2]
10039 x := v.Args[0]
10040 v_1 := v.Args[1]
10041 if v_1.Op != OpARMMOVWconst {
10042 break
10043 }
10044 c := v_1.AuxInt
10045 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) {
10046 break
10047 }
10048 v.reset(OpARMADD)
10049 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10050 v0.AuxInt = log2(c / 7)
10051 v1 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
10052 v1.AuxInt = 3
10053 v1.AddArg(x)
10054 v1.AddArg(x)
10055 v0.AddArg(v1)
10056 v.AddArg(v0)
10057 v.AddArg(a)
10058 return true
10059 }
10060
10061
10062
10063 for {
10064 a := v.Args[2]
10065 x := v.Args[0]
10066 v_1 := v.Args[1]
10067 if v_1.Op != OpARMMOVWconst {
10068 break
10069 }
10070 c := v_1.AuxInt
10071 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) {
10072 break
10073 }
10074 v.reset(OpARMADD)
10075 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10076 v0.AuxInt = log2(c / 9)
10077 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
10078 v1.AuxInt = 3
10079 v1.AddArg(x)
10080 v1.AddArg(x)
10081 v0.AddArg(v1)
10082 v.AddArg(v0)
10083 v.AddArg(a)
10084 return true
10085 }
10086 return false
10087 }
10088 func rewriteValueARM_OpARMMULA_10(v *Value) bool {
10089 b := v.Block
10090
10091
10092
10093 for {
10094 a := v.Args[2]
10095 v_0 := v.Args[0]
10096 if v_0.Op != OpARMMOVWconst {
10097 break
10098 }
10099 c := v_0.AuxInt
10100 x := v.Args[1]
10101 if !(int32(c) == -1) {
10102 break
10103 }
10104 v.reset(OpARMSUB)
10105 v.AddArg(a)
10106 v.AddArg(x)
10107 return true
10108 }
10109
10110
10111
10112 for {
10113 a := v.Args[2]
10114 v_0 := v.Args[0]
10115 if v_0.Op != OpARMMOVWconst {
10116 break
10117 }
10118 if v_0.AuxInt != 0 {
10119 break
10120 }
10121 v.reset(OpCopy)
10122 v.Type = a.Type
10123 v.AddArg(a)
10124 return true
10125 }
10126
10127
10128
10129 for {
10130 a := v.Args[2]
10131 v_0 := v.Args[0]
10132 if v_0.Op != OpARMMOVWconst {
10133 break
10134 }
10135 if v_0.AuxInt != 1 {
10136 break
10137 }
10138 x := v.Args[1]
10139 v.reset(OpARMADD)
10140 v.AddArg(x)
10141 v.AddArg(a)
10142 return true
10143 }
10144
10145
10146
10147 for {
10148 a := v.Args[2]
10149 v_0 := v.Args[0]
10150 if v_0.Op != OpARMMOVWconst {
10151 break
10152 }
10153 c := v_0.AuxInt
10154 x := v.Args[1]
10155 if !(isPowerOfTwo(c)) {
10156 break
10157 }
10158 v.reset(OpARMADD)
10159 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10160 v0.AuxInt = log2(c)
10161 v0.AddArg(x)
10162 v.AddArg(v0)
10163 v.AddArg(a)
10164 return true
10165 }
10166
10167
10168
10169 for {
10170 a := v.Args[2]
10171 v_0 := v.Args[0]
10172 if v_0.Op != OpARMMOVWconst {
10173 break
10174 }
10175 c := v_0.AuxInt
10176 x := v.Args[1]
10177 if !(isPowerOfTwo(c-1) && int32(c) >= 3) {
10178 break
10179 }
10180 v.reset(OpARMADD)
10181 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
10182 v0.AuxInt = log2(c - 1)
10183 v0.AddArg(x)
10184 v0.AddArg(x)
10185 v.AddArg(v0)
10186 v.AddArg(a)
10187 return true
10188 }
10189
10190
10191
10192 for {
10193 a := v.Args[2]
10194 v_0 := v.Args[0]
10195 if v_0.Op != OpARMMOVWconst {
10196 break
10197 }
10198 c := v_0.AuxInt
10199 x := v.Args[1]
10200 if !(isPowerOfTwo(c+1) && int32(c) >= 7) {
10201 break
10202 }
10203 v.reset(OpARMADD)
10204 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
10205 v0.AuxInt = log2(c + 1)
10206 v0.AddArg(x)
10207 v0.AddArg(x)
10208 v.AddArg(v0)
10209 v.AddArg(a)
10210 return true
10211 }
10212
10213
10214
10215 for {
10216 a := v.Args[2]
10217 v_0 := v.Args[0]
10218 if v_0.Op != OpARMMOVWconst {
10219 break
10220 }
10221 c := v_0.AuxInt
10222 x := v.Args[1]
10223 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) {
10224 break
10225 }
10226 v.reset(OpARMADD)
10227 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10228 v0.AuxInt = log2(c / 3)
10229 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
10230 v1.AuxInt = 1
10231 v1.AddArg(x)
10232 v1.AddArg(x)
10233 v0.AddArg(v1)
10234 v.AddArg(v0)
10235 v.AddArg(a)
10236 return true
10237 }
10238
10239
10240
10241 for {
10242 a := v.Args[2]
10243 v_0 := v.Args[0]
10244 if v_0.Op != OpARMMOVWconst {
10245 break
10246 }
10247 c := v_0.AuxInt
10248 x := v.Args[1]
10249 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) {
10250 break
10251 }
10252 v.reset(OpARMADD)
10253 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10254 v0.AuxInt = log2(c / 5)
10255 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
10256 v1.AuxInt = 2
10257 v1.AddArg(x)
10258 v1.AddArg(x)
10259 v0.AddArg(v1)
10260 v.AddArg(v0)
10261 v.AddArg(a)
10262 return true
10263 }
10264
10265
10266
10267 for {
10268 a := v.Args[2]
10269 v_0 := v.Args[0]
10270 if v_0.Op != OpARMMOVWconst {
10271 break
10272 }
10273 c := v_0.AuxInt
10274 x := v.Args[1]
10275 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) {
10276 break
10277 }
10278 v.reset(OpARMADD)
10279 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10280 v0.AuxInt = log2(c / 7)
10281 v1 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
10282 v1.AuxInt = 3
10283 v1.AddArg(x)
10284 v1.AddArg(x)
10285 v0.AddArg(v1)
10286 v.AddArg(v0)
10287 v.AddArg(a)
10288 return true
10289 }
10290
10291
10292
10293 for {
10294 a := v.Args[2]
10295 v_0 := v.Args[0]
10296 if v_0.Op != OpARMMOVWconst {
10297 break
10298 }
10299 c := v_0.AuxInt
10300 x := v.Args[1]
10301 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) {
10302 break
10303 }
10304 v.reset(OpARMADD)
10305 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10306 v0.AuxInt = log2(c / 9)
10307 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
10308 v1.AuxInt = 3
10309 v1.AddArg(x)
10310 v1.AddArg(x)
10311 v0.AddArg(v1)
10312 v.AddArg(v0)
10313 v.AddArg(a)
10314 return true
10315 }
10316 return false
10317 }
10318 func rewriteValueARM_OpARMMULA_20(v *Value) bool {
10319
10320
10321
10322 for {
10323 a := v.Args[2]
10324 v_0 := v.Args[0]
10325 if v_0.Op != OpARMMOVWconst {
10326 break
10327 }
10328 c := v_0.AuxInt
10329 v_1 := v.Args[1]
10330 if v_1.Op != OpARMMOVWconst {
10331 break
10332 }
10333 d := v_1.AuxInt
10334 v.reset(OpARMADDconst)
10335 v.AuxInt = int64(int32(c * d))
10336 v.AddArg(a)
10337 return true
10338 }
10339 return false
10340 }
10341 func rewriteValueARM_OpARMMULD_0(v *Value) bool {
10342
10343
10344
10345 for {
10346 y := v.Args[1]
10347 v_0 := v.Args[0]
10348 if v_0.Op != OpARMNEGD {
10349 break
10350 }
10351 x := v_0.Args[0]
10352 if !(objabi.GOARM >= 6) {
10353 break
10354 }
10355 v.reset(OpARMNMULD)
10356 v.AddArg(x)
10357 v.AddArg(y)
10358 return true
10359 }
10360
10361
10362
10363 for {
10364 _ = v.Args[1]
10365 y := v.Args[0]
10366 v_1 := v.Args[1]
10367 if v_1.Op != OpARMNEGD {
10368 break
10369 }
10370 x := v_1.Args[0]
10371 if !(objabi.GOARM >= 6) {
10372 break
10373 }
10374 v.reset(OpARMNMULD)
10375 v.AddArg(x)
10376 v.AddArg(y)
10377 return true
10378 }
10379 return false
10380 }
10381 func rewriteValueARM_OpARMMULF_0(v *Value) bool {
10382
10383
10384
10385 for {
10386 y := v.Args[1]
10387 v_0 := v.Args[0]
10388 if v_0.Op != OpARMNEGF {
10389 break
10390 }
10391 x := v_0.Args[0]
10392 if !(objabi.GOARM >= 6) {
10393 break
10394 }
10395 v.reset(OpARMNMULF)
10396 v.AddArg(x)
10397 v.AddArg(y)
10398 return true
10399 }
10400
10401
10402
10403 for {
10404 _ = v.Args[1]
10405 y := v.Args[0]
10406 v_1 := v.Args[1]
10407 if v_1.Op != OpARMNEGF {
10408 break
10409 }
10410 x := v_1.Args[0]
10411 if !(objabi.GOARM >= 6) {
10412 break
10413 }
10414 v.reset(OpARMNMULF)
10415 v.AddArg(x)
10416 v.AddArg(y)
10417 return true
10418 }
10419 return false
10420 }
10421 func rewriteValueARM_OpARMMULS_0(v *Value) bool {
10422 b := v.Block
10423
10424
10425
10426 for {
10427 a := v.Args[2]
10428 x := v.Args[0]
10429 v_1 := v.Args[1]
10430 if v_1.Op != OpARMMOVWconst {
10431 break
10432 }
10433 c := v_1.AuxInt
10434 if !(int32(c) == -1) {
10435 break
10436 }
10437 v.reset(OpARMADD)
10438 v.AddArg(a)
10439 v.AddArg(x)
10440 return true
10441 }
10442
10443
10444
10445 for {
10446 a := v.Args[2]
10447 v_1 := v.Args[1]
10448 if v_1.Op != OpARMMOVWconst {
10449 break
10450 }
10451 if v_1.AuxInt != 0 {
10452 break
10453 }
10454 v.reset(OpCopy)
10455 v.Type = a.Type
10456 v.AddArg(a)
10457 return true
10458 }
10459
10460
10461
10462 for {
10463 a := v.Args[2]
10464 x := v.Args[0]
10465 v_1 := v.Args[1]
10466 if v_1.Op != OpARMMOVWconst {
10467 break
10468 }
10469 if v_1.AuxInt != 1 {
10470 break
10471 }
10472 v.reset(OpARMRSB)
10473 v.AddArg(x)
10474 v.AddArg(a)
10475 return true
10476 }
10477
10478
10479
10480 for {
10481 a := v.Args[2]
10482 x := v.Args[0]
10483 v_1 := v.Args[1]
10484 if v_1.Op != OpARMMOVWconst {
10485 break
10486 }
10487 c := v_1.AuxInt
10488 if !(isPowerOfTwo(c)) {
10489 break
10490 }
10491 v.reset(OpARMRSB)
10492 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10493 v0.AuxInt = log2(c)
10494 v0.AddArg(x)
10495 v.AddArg(v0)
10496 v.AddArg(a)
10497 return true
10498 }
10499
10500
10501
10502 for {
10503 a := v.Args[2]
10504 x := v.Args[0]
10505 v_1 := v.Args[1]
10506 if v_1.Op != OpARMMOVWconst {
10507 break
10508 }
10509 c := v_1.AuxInt
10510 if !(isPowerOfTwo(c-1) && int32(c) >= 3) {
10511 break
10512 }
10513 v.reset(OpARMRSB)
10514 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
10515 v0.AuxInt = log2(c - 1)
10516 v0.AddArg(x)
10517 v0.AddArg(x)
10518 v.AddArg(v0)
10519 v.AddArg(a)
10520 return true
10521 }
10522
10523
10524
10525 for {
10526 a := v.Args[2]
10527 x := v.Args[0]
10528 v_1 := v.Args[1]
10529 if v_1.Op != OpARMMOVWconst {
10530 break
10531 }
10532 c := v_1.AuxInt
10533 if !(isPowerOfTwo(c+1) && int32(c) >= 7) {
10534 break
10535 }
10536 v.reset(OpARMRSB)
10537 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
10538 v0.AuxInt = log2(c + 1)
10539 v0.AddArg(x)
10540 v0.AddArg(x)
10541 v.AddArg(v0)
10542 v.AddArg(a)
10543 return true
10544 }
10545
10546
10547
10548 for {
10549 a := v.Args[2]
10550 x := v.Args[0]
10551 v_1 := v.Args[1]
10552 if v_1.Op != OpARMMOVWconst {
10553 break
10554 }
10555 c := v_1.AuxInt
10556 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) {
10557 break
10558 }
10559 v.reset(OpARMRSB)
10560 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10561 v0.AuxInt = log2(c / 3)
10562 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
10563 v1.AuxInt = 1
10564 v1.AddArg(x)
10565 v1.AddArg(x)
10566 v0.AddArg(v1)
10567 v.AddArg(v0)
10568 v.AddArg(a)
10569 return true
10570 }
10571
10572
10573
10574 for {
10575 a := v.Args[2]
10576 x := v.Args[0]
10577 v_1 := v.Args[1]
10578 if v_1.Op != OpARMMOVWconst {
10579 break
10580 }
10581 c := v_1.AuxInt
10582 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) {
10583 break
10584 }
10585 v.reset(OpARMRSB)
10586 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10587 v0.AuxInt = log2(c / 5)
10588 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
10589 v1.AuxInt = 2
10590 v1.AddArg(x)
10591 v1.AddArg(x)
10592 v0.AddArg(v1)
10593 v.AddArg(v0)
10594 v.AddArg(a)
10595 return true
10596 }
10597
10598
10599
10600 for {
10601 a := v.Args[2]
10602 x := v.Args[0]
10603 v_1 := v.Args[1]
10604 if v_1.Op != OpARMMOVWconst {
10605 break
10606 }
10607 c := v_1.AuxInt
10608 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) {
10609 break
10610 }
10611 v.reset(OpARMRSB)
10612 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10613 v0.AuxInt = log2(c / 7)
10614 v1 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
10615 v1.AuxInt = 3
10616 v1.AddArg(x)
10617 v1.AddArg(x)
10618 v0.AddArg(v1)
10619 v.AddArg(v0)
10620 v.AddArg(a)
10621 return true
10622 }
10623
10624
10625
10626 for {
10627 a := v.Args[2]
10628 x := v.Args[0]
10629 v_1 := v.Args[1]
10630 if v_1.Op != OpARMMOVWconst {
10631 break
10632 }
10633 c := v_1.AuxInt
10634 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) {
10635 break
10636 }
10637 v.reset(OpARMRSB)
10638 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10639 v0.AuxInt = log2(c / 9)
10640 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
10641 v1.AuxInt = 3
10642 v1.AddArg(x)
10643 v1.AddArg(x)
10644 v0.AddArg(v1)
10645 v.AddArg(v0)
10646 v.AddArg(a)
10647 return true
10648 }
10649 return false
10650 }
10651 func rewriteValueARM_OpARMMULS_10(v *Value) bool {
10652 b := v.Block
10653
10654
10655
10656 for {
10657 a := v.Args[2]
10658 v_0 := v.Args[0]
10659 if v_0.Op != OpARMMOVWconst {
10660 break
10661 }
10662 c := v_0.AuxInt
10663 x := v.Args[1]
10664 if !(int32(c) == -1) {
10665 break
10666 }
10667 v.reset(OpARMADD)
10668 v.AddArg(a)
10669 v.AddArg(x)
10670 return true
10671 }
10672
10673
10674
10675 for {
10676 a := v.Args[2]
10677 v_0 := v.Args[0]
10678 if v_0.Op != OpARMMOVWconst {
10679 break
10680 }
10681 if v_0.AuxInt != 0 {
10682 break
10683 }
10684 v.reset(OpCopy)
10685 v.Type = a.Type
10686 v.AddArg(a)
10687 return true
10688 }
10689
10690
10691
10692 for {
10693 a := v.Args[2]
10694 v_0 := v.Args[0]
10695 if v_0.Op != OpARMMOVWconst {
10696 break
10697 }
10698 if v_0.AuxInt != 1 {
10699 break
10700 }
10701 x := v.Args[1]
10702 v.reset(OpARMRSB)
10703 v.AddArg(x)
10704 v.AddArg(a)
10705 return true
10706 }
10707
10708
10709
10710 for {
10711 a := v.Args[2]
10712 v_0 := v.Args[0]
10713 if v_0.Op != OpARMMOVWconst {
10714 break
10715 }
10716 c := v_0.AuxInt
10717 x := v.Args[1]
10718 if !(isPowerOfTwo(c)) {
10719 break
10720 }
10721 v.reset(OpARMRSB)
10722 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10723 v0.AuxInt = log2(c)
10724 v0.AddArg(x)
10725 v.AddArg(v0)
10726 v.AddArg(a)
10727 return true
10728 }
10729
10730
10731
10732 for {
10733 a := v.Args[2]
10734 v_0 := v.Args[0]
10735 if v_0.Op != OpARMMOVWconst {
10736 break
10737 }
10738 c := v_0.AuxInt
10739 x := v.Args[1]
10740 if !(isPowerOfTwo(c-1) && int32(c) >= 3) {
10741 break
10742 }
10743 v.reset(OpARMRSB)
10744 v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
10745 v0.AuxInt = log2(c - 1)
10746 v0.AddArg(x)
10747 v0.AddArg(x)
10748 v.AddArg(v0)
10749 v.AddArg(a)
10750 return true
10751 }
10752
10753
10754
10755 for {
10756 a := v.Args[2]
10757 v_0 := v.Args[0]
10758 if v_0.Op != OpARMMOVWconst {
10759 break
10760 }
10761 c := v_0.AuxInt
10762 x := v.Args[1]
10763 if !(isPowerOfTwo(c+1) && int32(c) >= 7) {
10764 break
10765 }
10766 v.reset(OpARMRSB)
10767 v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
10768 v0.AuxInt = log2(c + 1)
10769 v0.AddArg(x)
10770 v0.AddArg(x)
10771 v.AddArg(v0)
10772 v.AddArg(a)
10773 return true
10774 }
10775
10776
10777
10778 for {
10779 a := v.Args[2]
10780 v_0 := v.Args[0]
10781 if v_0.Op != OpARMMOVWconst {
10782 break
10783 }
10784 c := v_0.AuxInt
10785 x := v.Args[1]
10786 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) {
10787 break
10788 }
10789 v.reset(OpARMRSB)
10790 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10791 v0.AuxInt = log2(c / 3)
10792 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
10793 v1.AuxInt = 1
10794 v1.AddArg(x)
10795 v1.AddArg(x)
10796 v0.AddArg(v1)
10797 v.AddArg(v0)
10798 v.AddArg(a)
10799 return true
10800 }
10801
10802
10803
10804 for {
10805 a := v.Args[2]
10806 v_0 := v.Args[0]
10807 if v_0.Op != OpARMMOVWconst {
10808 break
10809 }
10810 c := v_0.AuxInt
10811 x := v.Args[1]
10812 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) {
10813 break
10814 }
10815 v.reset(OpARMRSB)
10816 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10817 v0.AuxInt = log2(c / 5)
10818 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
10819 v1.AuxInt = 2
10820 v1.AddArg(x)
10821 v1.AddArg(x)
10822 v0.AddArg(v1)
10823 v.AddArg(v0)
10824 v.AddArg(a)
10825 return true
10826 }
10827
10828
10829
10830 for {
10831 a := v.Args[2]
10832 v_0 := v.Args[0]
10833 if v_0.Op != OpARMMOVWconst {
10834 break
10835 }
10836 c := v_0.AuxInt
10837 x := v.Args[1]
10838 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) {
10839 break
10840 }
10841 v.reset(OpARMRSB)
10842 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10843 v0.AuxInt = log2(c / 7)
10844 v1 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
10845 v1.AuxInt = 3
10846 v1.AddArg(x)
10847 v1.AddArg(x)
10848 v0.AddArg(v1)
10849 v.AddArg(v0)
10850 v.AddArg(a)
10851 return true
10852 }
10853
10854
10855
10856 for {
10857 a := v.Args[2]
10858 v_0 := v.Args[0]
10859 if v_0.Op != OpARMMOVWconst {
10860 break
10861 }
10862 c := v_0.AuxInt
10863 x := v.Args[1]
10864 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) {
10865 break
10866 }
10867 v.reset(OpARMRSB)
10868 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
10869 v0.AuxInt = log2(c / 9)
10870 v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
10871 v1.AuxInt = 3
10872 v1.AddArg(x)
10873 v1.AddArg(x)
10874 v0.AddArg(v1)
10875 v.AddArg(v0)
10876 v.AddArg(a)
10877 return true
10878 }
10879 return false
10880 }
10881 func rewriteValueARM_OpARMMULS_20(v *Value) bool {
10882
10883
10884
10885 for {
10886 a := v.Args[2]
10887 v_0 := v.Args[0]
10888 if v_0.Op != OpARMMOVWconst {
10889 break
10890 }
10891 c := v_0.AuxInt
10892 v_1 := v.Args[1]
10893 if v_1.Op != OpARMMOVWconst {
10894 break
10895 }
10896 d := v_1.AuxInt
10897 v.reset(OpARMSUBconst)
10898 v.AuxInt = int64(int32(c * d))
10899 v.AddArg(a)
10900 return true
10901 }
10902 return false
10903 }
10904 func rewriteValueARM_OpARMMVN_0(v *Value) bool {
10905
10906
10907
10908 for {
10909 v_0 := v.Args[0]
10910 if v_0.Op != OpARMMOVWconst {
10911 break
10912 }
10913 c := v_0.AuxInt
10914 v.reset(OpARMMOVWconst)
10915 v.AuxInt = ^c
10916 return true
10917 }
10918
10919
10920
10921 for {
10922 v_0 := v.Args[0]
10923 if v_0.Op != OpARMSLLconst {
10924 break
10925 }
10926 c := v_0.AuxInt
10927 x := v_0.Args[0]
10928 v.reset(OpARMMVNshiftLL)
10929 v.AuxInt = c
10930 v.AddArg(x)
10931 return true
10932 }
10933
10934
10935
10936 for {
10937 v_0 := v.Args[0]
10938 if v_0.Op != OpARMSRLconst {
10939 break
10940 }
10941 c := v_0.AuxInt
10942 x := v_0.Args[0]
10943 v.reset(OpARMMVNshiftRL)
10944 v.AuxInt = c
10945 v.AddArg(x)
10946 return true
10947 }
10948
10949
10950
10951 for {
10952 v_0 := v.Args[0]
10953 if v_0.Op != OpARMSRAconst {
10954 break
10955 }
10956 c := v_0.AuxInt
10957 x := v_0.Args[0]
10958 v.reset(OpARMMVNshiftRA)
10959 v.AuxInt = c
10960 v.AddArg(x)
10961 return true
10962 }
10963
10964
10965
10966 for {
10967 v_0 := v.Args[0]
10968 if v_0.Op != OpARMSLL {
10969 break
10970 }
10971 y := v_0.Args[1]
10972 x := v_0.Args[0]
10973 v.reset(OpARMMVNshiftLLreg)
10974 v.AddArg(x)
10975 v.AddArg(y)
10976 return true
10977 }
10978
10979
10980
10981 for {
10982 v_0 := v.Args[0]
10983 if v_0.Op != OpARMSRL {
10984 break
10985 }
10986 y := v_0.Args[1]
10987 x := v_0.Args[0]
10988 v.reset(OpARMMVNshiftRLreg)
10989 v.AddArg(x)
10990 v.AddArg(y)
10991 return true
10992 }
10993
10994
10995
10996 for {
10997 v_0 := v.Args[0]
10998 if v_0.Op != OpARMSRA {
10999 break
11000 }
11001 y := v_0.Args[1]
11002 x := v_0.Args[0]
11003 v.reset(OpARMMVNshiftRAreg)
11004 v.AddArg(x)
11005 v.AddArg(y)
11006 return true
11007 }
11008 return false
11009 }
11010 func rewriteValueARM_OpARMMVNshiftLL_0(v *Value) bool {
11011
11012
11013
11014 for {
11015 d := v.AuxInt
11016 v_0 := v.Args[0]
11017 if v_0.Op != OpARMMOVWconst {
11018 break
11019 }
11020 c := v_0.AuxInt
11021 v.reset(OpARMMOVWconst)
11022 v.AuxInt = ^int64(uint32(c) << uint64(d))
11023 return true
11024 }
11025 return false
11026 }
11027 func rewriteValueARM_OpARMMVNshiftLLreg_0(v *Value) bool {
11028
11029
11030
11031 for {
11032 _ = v.Args[1]
11033 x := v.Args[0]
11034 v_1 := v.Args[1]
11035 if v_1.Op != OpARMMOVWconst {
11036 break
11037 }
11038 c := v_1.AuxInt
11039 v.reset(OpARMMVNshiftLL)
11040 v.AuxInt = c
11041 v.AddArg(x)
11042 return true
11043 }
11044 return false
11045 }
11046 func rewriteValueARM_OpARMMVNshiftRA_0(v *Value) bool {
11047
11048
11049
11050 for {
11051 d := v.AuxInt
11052 v_0 := v.Args[0]
11053 if v_0.Op != OpARMMOVWconst {
11054 break
11055 }
11056 c := v_0.AuxInt
11057 v.reset(OpARMMOVWconst)
11058 v.AuxInt = ^int64(int32(c) >> uint64(d))
11059 return true
11060 }
11061 return false
11062 }
11063 func rewriteValueARM_OpARMMVNshiftRAreg_0(v *Value) bool {
11064
11065
11066
11067 for {
11068 _ = v.Args[1]
11069 x := v.Args[0]
11070 v_1 := v.Args[1]
11071 if v_1.Op != OpARMMOVWconst {
11072 break
11073 }
11074 c := v_1.AuxInt
11075 v.reset(OpARMMVNshiftRA)
11076 v.AuxInt = c
11077 v.AddArg(x)
11078 return true
11079 }
11080 return false
11081 }
11082 func rewriteValueARM_OpARMMVNshiftRL_0(v *Value) bool {
11083
11084
11085
11086 for {
11087 d := v.AuxInt
11088 v_0 := v.Args[0]
11089 if v_0.Op != OpARMMOVWconst {
11090 break
11091 }
11092 c := v_0.AuxInt
11093 v.reset(OpARMMOVWconst)
11094 v.AuxInt = ^int64(uint32(c) >> uint64(d))
11095 return true
11096 }
11097 return false
11098 }
11099 func rewriteValueARM_OpARMMVNshiftRLreg_0(v *Value) bool {
11100
11101
11102
11103 for {
11104 _ = v.Args[1]
11105 x := v.Args[0]
11106 v_1 := v.Args[1]
11107 if v_1.Op != OpARMMOVWconst {
11108 break
11109 }
11110 c := v_1.AuxInt
11111 v.reset(OpARMMVNshiftRL)
11112 v.AuxInt = c
11113 v.AddArg(x)
11114 return true
11115 }
11116 return false
11117 }
11118 func rewriteValueARM_OpARMNEGD_0(v *Value) bool {
11119
11120
11121
11122 for {
11123 v_0 := v.Args[0]
11124 if v_0.Op != OpARMMULD {
11125 break
11126 }
11127 y := v_0.Args[1]
11128 x := v_0.Args[0]
11129 if !(objabi.GOARM >= 6) {
11130 break
11131 }
11132 v.reset(OpARMNMULD)
11133 v.AddArg(x)
11134 v.AddArg(y)
11135 return true
11136 }
11137 return false
11138 }
11139 func rewriteValueARM_OpARMNEGF_0(v *Value) bool {
11140
11141
11142
11143 for {
11144 v_0 := v.Args[0]
11145 if v_0.Op != OpARMMULF {
11146 break
11147 }
11148 y := v_0.Args[1]
11149 x := v_0.Args[0]
11150 if !(objabi.GOARM >= 6) {
11151 break
11152 }
11153 v.reset(OpARMNMULF)
11154 v.AddArg(x)
11155 v.AddArg(y)
11156 return true
11157 }
11158 return false
11159 }
11160 func rewriteValueARM_OpARMNMULD_0(v *Value) bool {
11161
11162
11163
11164 for {
11165 y := v.Args[1]
11166 v_0 := v.Args[0]
11167 if v_0.Op != OpARMNEGD {
11168 break
11169 }
11170 x := v_0.Args[0]
11171 v.reset(OpARMMULD)
11172 v.AddArg(x)
11173 v.AddArg(y)
11174 return true
11175 }
11176
11177
11178
11179 for {
11180 _ = v.Args[1]
11181 y := v.Args[0]
11182 v_1 := v.Args[1]
11183 if v_1.Op != OpARMNEGD {
11184 break
11185 }
11186 x := v_1.Args[0]
11187 v.reset(OpARMMULD)
11188 v.AddArg(x)
11189 v.AddArg(y)
11190 return true
11191 }
11192 return false
11193 }
11194 func rewriteValueARM_OpARMNMULF_0(v *Value) bool {
11195
11196
11197
11198 for {
11199 y := v.Args[1]
11200 v_0 := v.Args[0]
11201 if v_0.Op != OpARMNEGF {
11202 break
11203 }
11204 x := v_0.Args[0]
11205 v.reset(OpARMMULF)
11206 v.AddArg(x)
11207 v.AddArg(y)
11208 return true
11209 }
11210
11211
11212
11213 for {
11214 _ = v.Args[1]
11215 y := v.Args[0]
11216 v_1 := v.Args[1]
11217 if v_1.Op != OpARMNEGF {
11218 break
11219 }
11220 x := v_1.Args[0]
11221 v.reset(OpARMMULF)
11222 v.AddArg(x)
11223 v.AddArg(y)
11224 return true
11225 }
11226 return false
11227 }
11228 func rewriteValueARM_OpARMNotEqual_0(v *Value) bool {
11229
11230
11231
11232 for {
11233 v_0 := v.Args[0]
11234 if v_0.Op != OpARMFlagEQ {
11235 break
11236 }
11237 v.reset(OpARMMOVWconst)
11238 v.AuxInt = 0
11239 return true
11240 }
11241
11242
11243
11244 for {
11245 v_0 := v.Args[0]
11246 if v_0.Op != OpARMFlagLT_ULT {
11247 break
11248 }
11249 v.reset(OpARMMOVWconst)
11250 v.AuxInt = 1
11251 return true
11252 }
11253
11254
11255
11256 for {
11257 v_0 := v.Args[0]
11258 if v_0.Op != OpARMFlagLT_UGT {
11259 break
11260 }
11261 v.reset(OpARMMOVWconst)
11262 v.AuxInt = 1
11263 return true
11264 }
11265
11266
11267
11268 for {
11269 v_0 := v.Args[0]
11270 if v_0.Op != OpARMFlagGT_ULT {
11271 break
11272 }
11273 v.reset(OpARMMOVWconst)
11274 v.AuxInt = 1
11275 return true
11276 }
11277
11278
11279
11280 for {
11281 v_0 := v.Args[0]
11282 if v_0.Op != OpARMFlagGT_UGT {
11283 break
11284 }
11285 v.reset(OpARMMOVWconst)
11286 v.AuxInt = 1
11287 return true
11288 }
11289
11290
11291
11292 for {
11293 v_0 := v.Args[0]
11294 if v_0.Op != OpARMInvertFlags {
11295 break
11296 }
11297 x := v_0.Args[0]
11298 v.reset(OpARMNotEqual)
11299 v.AddArg(x)
11300 return true
11301 }
11302 return false
11303 }
11304 func rewriteValueARM_OpARMOR_0(v *Value) bool {
11305
11306
11307
11308 for {
11309 _ = v.Args[1]
11310 x := v.Args[0]
11311 v_1 := v.Args[1]
11312 if v_1.Op != OpARMMOVWconst {
11313 break
11314 }
11315 c := v_1.AuxInt
11316 v.reset(OpARMORconst)
11317 v.AuxInt = c
11318 v.AddArg(x)
11319 return true
11320 }
11321
11322
11323
11324 for {
11325 x := v.Args[1]
11326 v_0 := v.Args[0]
11327 if v_0.Op != OpARMMOVWconst {
11328 break
11329 }
11330 c := v_0.AuxInt
11331 v.reset(OpARMORconst)
11332 v.AuxInt = c
11333 v.AddArg(x)
11334 return true
11335 }
11336
11337
11338
11339 for {
11340 _ = v.Args[1]
11341 x := v.Args[0]
11342 v_1 := v.Args[1]
11343 if v_1.Op != OpARMSLLconst {
11344 break
11345 }
11346 c := v_1.AuxInt
11347 y := v_1.Args[0]
11348 v.reset(OpARMORshiftLL)
11349 v.AuxInt = c
11350 v.AddArg(x)
11351 v.AddArg(y)
11352 return true
11353 }
11354
11355
11356
11357 for {
11358 x := v.Args[1]
11359 v_0 := v.Args[0]
11360 if v_0.Op != OpARMSLLconst {
11361 break
11362 }
11363 c := v_0.AuxInt
11364 y := v_0.Args[0]
11365 v.reset(OpARMORshiftLL)
11366 v.AuxInt = c
11367 v.AddArg(x)
11368 v.AddArg(y)
11369 return true
11370 }
11371
11372
11373
11374 for {
11375 _ = v.Args[1]
11376 x := v.Args[0]
11377 v_1 := v.Args[1]
11378 if v_1.Op != OpARMSRLconst {
11379 break
11380 }
11381 c := v_1.AuxInt
11382 y := v_1.Args[0]
11383 v.reset(OpARMORshiftRL)
11384 v.AuxInt = c
11385 v.AddArg(x)
11386 v.AddArg(y)
11387 return true
11388 }
11389
11390
11391
11392 for {
11393 x := v.Args[1]
11394 v_0 := v.Args[0]
11395 if v_0.Op != OpARMSRLconst {
11396 break
11397 }
11398 c := v_0.AuxInt
11399 y := v_0.Args[0]
11400 v.reset(OpARMORshiftRL)
11401 v.AuxInt = c
11402 v.AddArg(x)
11403 v.AddArg(y)
11404 return true
11405 }
11406
11407
11408
11409 for {
11410 _ = v.Args[1]
11411 x := v.Args[0]
11412 v_1 := v.Args[1]
11413 if v_1.Op != OpARMSRAconst {
11414 break
11415 }
11416 c := v_1.AuxInt
11417 y := v_1.Args[0]
11418 v.reset(OpARMORshiftRA)
11419 v.AuxInt = c
11420 v.AddArg(x)
11421 v.AddArg(y)
11422 return true
11423 }
11424
11425
11426
11427 for {
11428 x := v.Args[1]
11429 v_0 := v.Args[0]
11430 if v_0.Op != OpARMSRAconst {
11431 break
11432 }
11433 c := v_0.AuxInt
11434 y := v_0.Args[0]
11435 v.reset(OpARMORshiftRA)
11436 v.AuxInt = c
11437 v.AddArg(x)
11438 v.AddArg(y)
11439 return true
11440 }
11441
11442
11443
11444 for {
11445 _ = v.Args[1]
11446 x := v.Args[0]
11447 v_1 := v.Args[1]
11448 if v_1.Op != OpARMSLL {
11449 break
11450 }
11451 z := v_1.Args[1]
11452 y := v_1.Args[0]
11453 v.reset(OpARMORshiftLLreg)
11454 v.AddArg(x)
11455 v.AddArg(y)
11456 v.AddArg(z)
11457 return true
11458 }
11459
11460
11461
11462 for {
11463 x := v.Args[1]
11464 v_0 := v.Args[0]
11465 if v_0.Op != OpARMSLL {
11466 break
11467 }
11468 z := v_0.Args[1]
11469 y := v_0.Args[0]
11470 v.reset(OpARMORshiftLLreg)
11471 v.AddArg(x)
11472 v.AddArg(y)
11473 v.AddArg(z)
11474 return true
11475 }
11476 return false
11477 }
11478 func rewriteValueARM_OpARMOR_10(v *Value) bool {
11479
11480
11481
11482 for {
11483 _ = v.Args[1]
11484 x := v.Args[0]
11485 v_1 := v.Args[1]
11486 if v_1.Op != OpARMSRL {
11487 break
11488 }
11489 z := v_1.Args[1]
11490 y := v_1.Args[0]
11491 v.reset(OpARMORshiftRLreg)
11492 v.AddArg(x)
11493 v.AddArg(y)
11494 v.AddArg(z)
11495 return true
11496 }
11497
11498
11499
11500 for {
11501 x := v.Args[1]
11502 v_0 := v.Args[0]
11503 if v_0.Op != OpARMSRL {
11504 break
11505 }
11506 z := v_0.Args[1]
11507 y := v_0.Args[0]
11508 v.reset(OpARMORshiftRLreg)
11509 v.AddArg(x)
11510 v.AddArg(y)
11511 v.AddArg(z)
11512 return true
11513 }
11514
11515
11516
11517 for {
11518 _ = v.Args[1]
11519 x := v.Args[0]
11520 v_1 := v.Args[1]
11521 if v_1.Op != OpARMSRA {
11522 break
11523 }
11524 z := v_1.Args[1]
11525 y := v_1.Args[0]
11526 v.reset(OpARMORshiftRAreg)
11527 v.AddArg(x)
11528 v.AddArg(y)
11529 v.AddArg(z)
11530 return true
11531 }
11532
11533
11534
11535 for {
11536 x := v.Args[1]
11537 v_0 := v.Args[0]
11538 if v_0.Op != OpARMSRA {
11539 break
11540 }
11541 z := v_0.Args[1]
11542 y := v_0.Args[0]
11543 v.reset(OpARMORshiftRAreg)
11544 v.AddArg(x)
11545 v.AddArg(y)
11546 v.AddArg(z)
11547 return true
11548 }
11549
11550
11551
11552 for {
11553 x := v.Args[1]
11554 if x != v.Args[0] {
11555 break
11556 }
11557 v.reset(OpCopy)
11558 v.Type = x.Type
11559 v.AddArg(x)
11560 return true
11561 }
11562 return false
11563 }
11564 func rewriteValueARM_OpARMORconst_0(v *Value) bool {
11565
11566
11567
11568 for {
11569 if v.AuxInt != 0 {
11570 break
11571 }
11572 x := v.Args[0]
11573 v.reset(OpCopy)
11574 v.Type = x.Type
11575 v.AddArg(x)
11576 return true
11577 }
11578
11579
11580
11581 for {
11582 c := v.AuxInt
11583 if !(int32(c) == -1) {
11584 break
11585 }
11586 v.reset(OpARMMOVWconst)
11587 v.AuxInt = -1
11588 return true
11589 }
11590
11591
11592
11593 for {
11594 c := v.AuxInt
11595 v_0 := v.Args[0]
11596 if v_0.Op != OpARMMOVWconst {
11597 break
11598 }
11599 d := v_0.AuxInt
11600 v.reset(OpARMMOVWconst)
11601 v.AuxInt = c | d
11602 return true
11603 }
11604
11605
11606
11607 for {
11608 c := v.AuxInt
11609 v_0 := v.Args[0]
11610 if v_0.Op != OpARMORconst {
11611 break
11612 }
11613 d := v_0.AuxInt
11614 x := v_0.Args[0]
11615 v.reset(OpARMORconst)
11616 v.AuxInt = c | d
11617 v.AddArg(x)
11618 return true
11619 }
11620 return false
11621 }
11622 func rewriteValueARM_OpARMORshiftLL_0(v *Value) bool {
11623 b := v.Block
11624 typ := &b.Func.Config.Types
11625
11626
11627
11628 for {
11629 d := v.AuxInt
11630 x := v.Args[1]
11631 v_0 := v.Args[0]
11632 if v_0.Op != OpARMMOVWconst {
11633 break
11634 }
11635 c := v_0.AuxInt
11636 v.reset(OpARMORconst)
11637 v.AuxInt = c
11638 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
11639 v0.AuxInt = d
11640 v0.AddArg(x)
11641 v.AddArg(v0)
11642 return true
11643 }
11644
11645
11646
11647 for {
11648 d := v.AuxInt
11649 _ = v.Args[1]
11650 x := v.Args[0]
11651 v_1 := v.Args[1]
11652 if v_1.Op != OpARMMOVWconst {
11653 break
11654 }
11655 c := v_1.AuxInt
11656 v.reset(OpARMORconst)
11657 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
11658 v.AddArg(x)
11659 return true
11660 }
11661
11662
11663
11664 for {
11665 c := v.AuxInt
11666 x := v.Args[1]
11667 v_0 := v.Args[0]
11668 if v_0.Op != OpARMSRLconst {
11669 break
11670 }
11671 if v_0.AuxInt != 32-c {
11672 break
11673 }
11674 if x != v_0.Args[0] {
11675 break
11676 }
11677 v.reset(OpARMSRRconst)
11678 v.AuxInt = 32 - c
11679 v.AddArg(x)
11680 return true
11681 }
11682
11683
11684
11685 for {
11686 if v.Type != typ.UInt16 {
11687 break
11688 }
11689 if v.AuxInt != 8 {
11690 break
11691 }
11692 x := v.Args[1]
11693 v_0 := v.Args[0]
11694 if v_0.Op != OpARMBFXU {
11695 break
11696 }
11697 if v_0.Type != typ.UInt16 {
11698 break
11699 }
11700 if v_0.AuxInt != armBFAuxInt(8, 8) {
11701 break
11702 }
11703 if x != v_0.Args[0] {
11704 break
11705 }
11706 v.reset(OpARMREV16)
11707 v.AddArg(x)
11708 return true
11709 }
11710
11711
11712
11713 for {
11714 if v.Type != typ.UInt16 {
11715 break
11716 }
11717 if v.AuxInt != 8 {
11718 break
11719 }
11720 x := v.Args[1]
11721 v_0 := v.Args[0]
11722 if v_0.Op != OpARMSRLconst {
11723 break
11724 }
11725 if v_0.Type != typ.UInt16 {
11726 break
11727 }
11728 if v_0.AuxInt != 24 {
11729 break
11730 }
11731 v_0_0 := v_0.Args[0]
11732 if v_0_0.Op != OpARMSLLconst {
11733 break
11734 }
11735 if v_0_0.AuxInt != 16 {
11736 break
11737 }
11738 if x != v_0_0.Args[0] {
11739 break
11740 }
11741 if !(objabi.GOARM >= 6) {
11742 break
11743 }
11744 v.reset(OpARMREV16)
11745 v.AddArg(x)
11746 return true
11747 }
11748
11749
11750
11751 for {
11752 d := v.AuxInt
11753 _ = v.Args[1]
11754 x := v.Args[0]
11755 y := v.Args[1]
11756 if y.Op != OpARMSLLconst {
11757 break
11758 }
11759 c := y.AuxInt
11760 if x != y.Args[0] {
11761 break
11762 }
11763 if !(c == d) {
11764 break
11765 }
11766 v.reset(OpCopy)
11767 v.Type = y.Type
11768 v.AddArg(y)
11769 return true
11770 }
11771 return false
11772 }
11773 func rewriteValueARM_OpARMORshiftLLreg_0(v *Value) bool {
11774 b := v.Block
11775
11776
11777
11778 for {
11779 y := v.Args[2]
11780 v_0 := v.Args[0]
11781 if v_0.Op != OpARMMOVWconst {
11782 break
11783 }
11784 c := v_0.AuxInt
11785 x := v.Args[1]
11786 v.reset(OpARMORconst)
11787 v.AuxInt = c
11788 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
11789 v0.AddArg(x)
11790 v0.AddArg(y)
11791 v.AddArg(v0)
11792 return true
11793 }
11794
11795
11796
11797 for {
11798 _ = v.Args[2]
11799 x := v.Args[0]
11800 y := v.Args[1]
11801 v_2 := v.Args[2]
11802 if v_2.Op != OpARMMOVWconst {
11803 break
11804 }
11805 c := v_2.AuxInt
11806 v.reset(OpARMORshiftLL)
11807 v.AuxInt = c
11808 v.AddArg(x)
11809 v.AddArg(y)
11810 return true
11811 }
11812 return false
11813 }
11814 func rewriteValueARM_OpARMORshiftRA_0(v *Value) bool {
11815 b := v.Block
11816
11817
11818
11819 for {
11820 d := v.AuxInt
11821 x := v.Args[1]
11822 v_0 := v.Args[0]
11823 if v_0.Op != OpARMMOVWconst {
11824 break
11825 }
11826 c := v_0.AuxInt
11827 v.reset(OpARMORconst)
11828 v.AuxInt = c
11829 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
11830 v0.AuxInt = d
11831 v0.AddArg(x)
11832 v.AddArg(v0)
11833 return true
11834 }
11835
11836
11837
11838 for {
11839 d := v.AuxInt
11840 _ = v.Args[1]
11841 x := v.Args[0]
11842 v_1 := v.Args[1]
11843 if v_1.Op != OpARMMOVWconst {
11844 break
11845 }
11846 c := v_1.AuxInt
11847 v.reset(OpARMORconst)
11848 v.AuxInt = int64(int32(c) >> uint64(d))
11849 v.AddArg(x)
11850 return true
11851 }
11852
11853
11854
11855 for {
11856 d := v.AuxInt
11857 _ = v.Args[1]
11858 x := v.Args[0]
11859 y := v.Args[1]
11860 if y.Op != OpARMSRAconst {
11861 break
11862 }
11863 c := y.AuxInt
11864 if x != y.Args[0] {
11865 break
11866 }
11867 if !(c == d) {
11868 break
11869 }
11870 v.reset(OpCopy)
11871 v.Type = y.Type
11872 v.AddArg(y)
11873 return true
11874 }
11875 return false
11876 }
11877 func rewriteValueARM_OpARMORshiftRAreg_0(v *Value) bool {
11878 b := v.Block
11879
11880
11881
11882 for {
11883 y := v.Args[2]
11884 v_0 := v.Args[0]
11885 if v_0.Op != OpARMMOVWconst {
11886 break
11887 }
11888 c := v_0.AuxInt
11889 x := v.Args[1]
11890 v.reset(OpARMORconst)
11891 v.AuxInt = c
11892 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
11893 v0.AddArg(x)
11894 v0.AddArg(y)
11895 v.AddArg(v0)
11896 return true
11897 }
11898
11899
11900
11901 for {
11902 _ = v.Args[2]
11903 x := v.Args[0]
11904 y := v.Args[1]
11905 v_2 := v.Args[2]
11906 if v_2.Op != OpARMMOVWconst {
11907 break
11908 }
11909 c := v_2.AuxInt
11910 v.reset(OpARMORshiftRA)
11911 v.AuxInt = c
11912 v.AddArg(x)
11913 v.AddArg(y)
11914 return true
11915 }
11916 return false
11917 }
11918 func rewriteValueARM_OpARMORshiftRL_0(v *Value) bool {
11919 b := v.Block
11920
11921
11922
11923 for {
11924 d := v.AuxInt
11925 x := v.Args[1]
11926 v_0 := v.Args[0]
11927 if v_0.Op != OpARMMOVWconst {
11928 break
11929 }
11930 c := v_0.AuxInt
11931 v.reset(OpARMORconst)
11932 v.AuxInt = c
11933 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
11934 v0.AuxInt = d
11935 v0.AddArg(x)
11936 v.AddArg(v0)
11937 return true
11938 }
11939
11940
11941
11942 for {
11943 d := v.AuxInt
11944 _ = v.Args[1]
11945 x := v.Args[0]
11946 v_1 := v.Args[1]
11947 if v_1.Op != OpARMMOVWconst {
11948 break
11949 }
11950 c := v_1.AuxInt
11951 v.reset(OpARMORconst)
11952 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
11953 v.AddArg(x)
11954 return true
11955 }
11956
11957
11958
11959 for {
11960 c := v.AuxInt
11961 x := v.Args[1]
11962 v_0 := v.Args[0]
11963 if v_0.Op != OpARMSLLconst {
11964 break
11965 }
11966 if v_0.AuxInt != 32-c {
11967 break
11968 }
11969 if x != v_0.Args[0] {
11970 break
11971 }
11972 v.reset(OpARMSRRconst)
11973 v.AuxInt = c
11974 v.AddArg(x)
11975 return true
11976 }
11977
11978
11979
11980 for {
11981 d := v.AuxInt
11982 _ = v.Args[1]
11983 x := v.Args[0]
11984 y := v.Args[1]
11985 if y.Op != OpARMSRLconst {
11986 break
11987 }
11988 c := y.AuxInt
11989 if x != y.Args[0] {
11990 break
11991 }
11992 if !(c == d) {
11993 break
11994 }
11995 v.reset(OpCopy)
11996 v.Type = y.Type
11997 v.AddArg(y)
11998 return true
11999 }
12000 return false
12001 }
12002 func rewriteValueARM_OpARMORshiftRLreg_0(v *Value) bool {
12003 b := v.Block
12004
12005
12006
12007 for {
12008 y := v.Args[2]
12009 v_0 := v.Args[0]
12010 if v_0.Op != OpARMMOVWconst {
12011 break
12012 }
12013 c := v_0.AuxInt
12014 x := v.Args[1]
12015 v.reset(OpARMORconst)
12016 v.AuxInt = c
12017 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
12018 v0.AddArg(x)
12019 v0.AddArg(y)
12020 v.AddArg(v0)
12021 return true
12022 }
12023
12024
12025
12026 for {
12027 _ = v.Args[2]
12028 x := v.Args[0]
12029 y := v.Args[1]
12030 v_2 := v.Args[2]
12031 if v_2.Op != OpARMMOVWconst {
12032 break
12033 }
12034 c := v_2.AuxInt
12035 v.reset(OpARMORshiftRL)
12036 v.AuxInt = c
12037 v.AddArg(x)
12038 v.AddArg(y)
12039 return true
12040 }
12041 return false
12042 }
12043 func rewriteValueARM_OpARMRSB_0(v *Value) bool {
12044
12045
12046
12047 for {
12048 x := v.Args[1]
12049 v_0 := v.Args[0]
12050 if v_0.Op != OpARMMOVWconst {
12051 break
12052 }
12053 c := v_0.AuxInt
12054 v.reset(OpARMSUBconst)
12055 v.AuxInt = c
12056 v.AddArg(x)
12057 return true
12058 }
12059
12060
12061
12062 for {
12063 _ = v.Args[1]
12064 x := v.Args[0]
12065 v_1 := v.Args[1]
12066 if v_1.Op != OpARMMOVWconst {
12067 break
12068 }
12069 c := v_1.AuxInt
12070 v.reset(OpARMRSBconst)
12071 v.AuxInt = c
12072 v.AddArg(x)
12073 return true
12074 }
12075
12076
12077
12078 for {
12079 _ = v.Args[1]
12080 x := v.Args[0]
12081 v_1 := v.Args[1]
12082 if v_1.Op != OpARMSLLconst {
12083 break
12084 }
12085 c := v_1.AuxInt
12086 y := v_1.Args[0]
12087 v.reset(OpARMRSBshiftLL)
12088 v.AuxInt = c
12089 v.AddArg(x)
12090 v.AddArg(y)
12091 return true
12092 }
12093
12094
12095
12096 for {
12097 x := v.Args[1]
12098 v_0 := v.Args[0]
12099 if v_0.Op != OpARMSLLconst {
12100 break
12101 }
12102 c := v_0.AuxInt
12103 y := v_0.Args[0]
12104 v.reset(OpARMSUBshiftLL)
12105 v.AuxInt = c
12106 v.AddArg(x)
12107 v.AddArg(y)
12108 return true
12109 }
12110
12111
12112
12113 for {
12114 _ = v.Args[1]
12115 x := v.Args[0]
12116 v_1 := v.Args[1]
12117 if v_1.Op != OpARMSRLconst {
12118 break
12119 }
12120 c := v_1.AuxInt
12121 y := v_1.Args[0]
12122 v.reset(OpARMRSBshiftRL)
12123 v.AuxInt = c
12124 v.AddArg(x)
12125 v.AddArg(y)
12126 return true
12127 }
12128
12129
12130
12131 for {
12132 x := v.Args[1]
12133 v_0 := v.Args[0]
12134 if v_0.Op != OpARMSRLconst {
12135 break
12136 }
12137 c := v_0.AuxInt
12138 y := v_0.Args[0]
12139 v.reset(OpARMSUBshiftRL)
12140 v.AuxInt = c
12141 v.AddArg(x)
12142 v.AddArg(y)
12143 return true
12144 }
12145
12146
12147
12148 for {
12149 _ = v.Args[1]
12150 x := v.Args[0]
12151 v_1 := v.Args[1]
12152 if v_1.Op != OpARMSRAconst {
12153 break
12154 }
12155 c := v_1.AuxInt
12156 y := v_1.Args[0]
12157 v.reset(OpARMRSBshiftRA)
12158 v.AuxInt = c
12159 v.AddArg(x)
12160 v.AddArg(y)
12161 return true
12162 }
12163
12164
12165
12166 for {
12167 x := v.Args[1]
12168 v_0 := v.Args[0]
12169 if v_0.Op != OpARMSRAconst {
12170 break
12171 }
12172 c := v_0.AuxInt
12173 y := v_0.Args[0]
12174 v.reset(OpARMSUBshiftRA)
12175 v.AuxInt = c
12176 v.AddArg(x)
12177 v.AddArg(y)
12178 return true
12179 }
12180
12181
12182
12183 for {
12184 _ = v.Args[1]
12185 x := v.Args[0]
12186 v_1 := v.Args[1]
12187 if v_1.Op != OpARMSLL {
12188 break
12189 }
12190 z := v_1.Args[1]
12191 y := v_1.Args[0]
12192 v.reset(OpARMRSBshiftLLreg)
12193 v.AddArg(x)
12194 v.AddArg(y)
12195 v.AddArg(z)
12196 return true
12197 }
12198
12199
12200
12201 for {
12202 x := v.Args[1]
12203 v_0 := v.Args[0]
12204 if v_0.Op != OpARMSLL {
12205 break
12206 }
12207 z := v_0.Args[1]
12208 y := v_0.Args[0]
12209 v.reset(OpARMSUBshiftLLreg)
12210 v.AddArg(x)
12211 v.AddArg(y)
12212 v.AddArg(z)
12213 return true
12214 }
12215 return false
12216 }
12217 func rewriteValueARM_OpARMRSB_10(v *Value) bool {
12218
12219
12220
12221 for {
12222 _ = v.Args[1]
12223 x := v.Args[0]
12224 v_1 := v.Args[1]
12225 if v_1.Op != OpARMSRL {
12226 break
12227 }
12228 z := v_1.Args[1]
12229 y := v_1.Args[0]
12230 v.reset(OpARMRSBshiftRLreg)
12231 v.AddArg(x)
12232 v.AddArg(y)
12233 v.AddArg(z)
12234 return true
12235 }
12236
12237
12238
12239 for {
12240 x := v.Args[1]
12241 v_0 := v.Args[0]
12242 if v_0.Op != OpARMSRL {
12243 break
12244 }
12245 z := v_0.Args[1]
12246 y := v_0.Args[0]
12247 v.reset(OpARMSUBshiftRLreg)
12248 v.AddArg(x)
12249 v.AddArg(y)
12250 v.AddArg(z)
12251 return true
12252 }
12253
12254
12255
12256 for {
12257 _ = v.Args[1]
12258 x := v.Args[0]
12259 v_1 := v.Args[1]
12260 if v_1.Op != OpARMSRA {
12261 break
12262 }
12263 z := v_1.Args[1]
12264 y := v_1.Args[0]
12265 v.reset(OpARMRSBshiftRAreg)
12266 v.AddArg(x)
12267 v.AddArg(y)
12268 v.AddArg(z)
12269 return true
12270 }
12271
12272
12273
12274 for {
12275 x := v.Args[1]
12276 v_0 := v.Args[0]
12277 if v_0.Op != OpARMSRA {
12278 break
12279 }
12280 z := v_0.Args[1]
12281 y := v_0.Args[0]
12282 v.reset(OpARMSUBshiftRAreg)
12283 v.AddArg(x)
12284 v.AddArg(y)
12285 v.AddArg(z)
12286 return true
12287 }
12288
12289
12290
12291 for {
12292 x := v.Args[1]
12293 if x != v.Args[0] {
12294 break
12295 }
12296 v.reset(OpARMMOVWconst)
12297 v.AuxInt = 0
12298 return true
12299 }
12300
12301
12302
12303 for {
12304 a := v.Args[1]
12305 v_0 := v.Args[0]
12306 if v_0.Op != OpARMMUL {
12307 break
12308 }
12309 y := v_0.Args[1]
12310 x := v_0.Args[0]
12311 if !(objabi.GOARM == 7) {
12312 break
12313 }
12314 v.reset(OpARMMULS)
12315 v.AddArg(x)
12316 v.AddArg(y)
12317 v.AddArg(a)
12318 return true
12319 }
12320 return false
12321 }
12322 func rewriteValueARM_OpARMRSBSshiftLL_0(v *Value) bool {
12323 b := v.Block
12324
12325
12326
12327 for {
12328 d := v.AuxInt
12329 x := v.Args[1]
12330 v_0 := v.Args[0]
12331 if v_0.Op != OpARMMOVWconst {
12332 break
12333 }
12334 c := v_0.AuxInt
12335 v.reset(OpARMSUBSconst)
12336 v.AuxInt = c
12337 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
12338 v0.AuxInt = d
12339 v0.AddArg(x)
12340 v.AddArg(v0)
12341 return true
12342 }
12343
12344
12345
12346 for {
12347 d := v.AuxInt
12348 _ = v.Args[1]
12349 x := v.Args[0]
12350 v_1 := v.Args[1]
12351 if v_1.Op != OpARMMOVWconst {
12352 break
12353 }
12354 c := v_1.AuxInt
12355 v.reset(OpARMRSBSconst)
12356 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
12357 v.AddArg(x)
12358 return true
12359 }
12360 return false
12361 }
12362 func rewriteValueARM_OpARMRSBSshiftLLreg_0(v *Value) bool {
12363 b := v.Block
12364
12365
12366
12367 for {
12368 y := v.Args[2]
12369 v_0 := v.Args[0]
12370 if v_0.Op != OpARMMOVWconst {
12371 break
12372 }
12373 c := v_0.AuxInt
12374 x := v.Args[1]
12375 v.reset(OpARMSUBSconst)
12376 v.AuxInt = c
12377 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
12378 v0.AddArg(x)
12379 v0.AddArg(y)
12380 v.AddArg(v0)
12381 return true
12382 }
12383
12384
12385
12386 for {
12387 _ = v.Args[2]
12388 x := v.Args[0]
12389 y := v.Args[1]
12390 v_2 := v.Args[2]
12391 if v_2.Op != OpARMMOVWconst {
12392 break
12393 }
12394 c := v_2.AuxInt
12395 v.reset(OpARMRSBSshiftLL)
12396 v.AuxInt = c
12397 v.AddArg(x)
12398 v.AddArg(y)
12399 return true
12400 }
12401 return false
12402 }
12403 func rewriteValueARM_OpARMRSBSshiftRA_0(v *Value) bool {
12404 b := v.Block
12405
12406
12407
12408 for {
12409 d := v.AuxInt
12410 x := v.Args[1]
12411 v_0 := v.Args[0]
12412 if v_0.Op != OpARMMOVWconst {
12413 break
12414 }
12415 c := v_0.AuxInt
12416 v.reset(OpARMSUBSconst)
12417 v.AuxInt = c
12418 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
12419 v0.AuxInt = d
12420 v0.AddArg(x)
12421 v.AddArg(v0)
12422 return true
12423 }
12424
12425
12426
12427 for {
12428 d := v.AuxInt
12429 _ = v.Args[1]
12430 x := v.Args[0]
12431 v_1 := v.Args[1]
12432 if v_1.Op != OpARMMOVWconst {
12433 break
12434 }
12435 c := v_1.AuxInt
12436 v.reset(OpARMRSBSconst)
12437 v.AuxInt = int64(int32(c) >> uint64(d))
12438 v.AddArg(x)
12439 return true
12440 }
12441 return false
12442 }
12443 func rewriteValueARM_OpARMRSBSshiftRAreg_0(v *Value) bool {
12444 b := v.Block
12445
12446
12447
12448 for {
12449 y := v.Args[2]
12450 v_0 := v.Args[0]
12451 if v_0.Op != OpARMMOVWconst {
12452 break
12453 }
12454 c := v_0.AuxInt
12455 x := v.Args[1]
12456 v.reset(OpARMSUBSconst)
12457 v.AuxInt = c
12458 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
12459 v0.AddArg(x)
12460 v0.AddArg(y)
12461 v.AddArg(v0)
12462 return true
12463 }
12464
12465
12466
12467 for {
12468 _ = v.Args[2]
12469 x := v.Args[0]
12470 y := v.Args[1]
12471 v_2 := v.Args[2]
12472 if v_2.Op != OpARMMOVWconst {
12473 break
12474 }
12475 c := v_2.AuxInt
12476 v.reset(OpARMRSBSshiftRA)
12477 v.AuxInt = c
12478 v.AddArg(x)
12479 v.AddArg(y)
12480 return true
12481 }
12482 return false
12483 }
12484 func rewriteValueARM_OpARMRSBSshiftRL_0(v *Value) bool {
12485 b := v.Block
12486
12487
12488
12489 for {
12490 d := v.AuxInt
12491 x := v.Args[1]
12492 v_0 := v.Args[0]
12493 if v_0.Op != OpARMMOVWconst {
12494 break
12495 }
12496 c := v_0.AuxInt
12497 v.reset(OpARMSUBSconst)
12498 v.AuxInt = c
12499 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
12500 v0.AuxInt = d
12501 v0.AddArg(x)
12502 v.AddArg(v0)
12503 return true
12504 }
12505
12506
12507
12508 for {
12509 d := v.AuxInt
12510 _ = v.Args[1]
12511 x := v.Args[0]
12512 v_1 := v.Args[1]
12513 if v_1.Op != OpARMMOVWconst {
12514 break
12515 }
12516 c := v_1.AuxInt
12517 v.reset(OpARMRSBSconst)
12518 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
12519 v.AddArg(x)
12520 return true
12521 }
12522 return false
12523 }
12524 func rewriteValueARM_OpARMRSBSshiftRLreg_0(v *Value) bool {
12525 b := v.Block
12526
12527
12528
12529 for {
12530 y := v.Args[2]
12531 v_0 := v.Args[0]
12532 if v_0.Op != OpARMMOVWconst {
12533 break
12534 }
12535 c := v_0.AuxInt
12536 x := v.Args[1]
12537 v.reset(OpARMSUBSconst)
12538 v.AuxInt = c
12539 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
12540 v0.AddArg(x)
12541 v0.AddArg(y)
12542 v.AddArg(v0)
12543 return true
12544 }
12545
12546
12547
12548 for {
12549 _ = v.Args[2]
12550 x := v.Args[0]
12551 y := v.Args[1]
12552 v_2 := v.Args[2]
12553 if v_2.Op != OpARMMOVWconst {
12554 break
12555 }
12556 c := v_2.AuxInt
12557 v.reset(OpARMRSBSshiftRL)
12558 v.AuxInt = c
12559 v.AddArg(x)
12560 v.AddArg(y)
12561 return true
12562 }
12563 return false
12564 }
12565 func rewriteValueARM_OpARMRSBconst_0(v *Value) bool {
12566
12567
12568
12569 for {
12570 c := v.AuxInt
12571 v_0 := v.Args[0]
12572 if v_0.Op != OpARMMOVWconst {
12573 break
12574 }
12575 d := v_0.AuxInt
12576 v.reset(OpARMMOVWconst)
12577 v.AuxInt = int64(int32(c - d))
12578 return true
12579 }
12580
12581
12582
12583 for {
12584 c := v.AuxInt
12585 v_0 := v.Args[0]
12586 if v_0.Op != OpARMRSBconst {
12587 break
12588 }
12589 d := v_0.AuxInt
12590 x := v_0.Args[0]
12591 v.reset(OpARMADDconst)
12592 v.AuxInt = int64(int32(c - d))
12593 v.AddArg(x)
12594 return true
12595 }
12596
12597
12598
12599 for {
12600 c := v.AuxInt
12601 v_0 := v.Args[0]
12602 if v_0.Op != OpARMADDconst {
12603 break
12604 }
12605 d := v_0.AuxInt
12606 x := v_0.Args[0]
12607 v.reset(OpARMRSBconst)
12608 v.AuxInt = int64(int32(c - d))
12609 v.AddArg(x)
12610 return true
12611 }
12612
12613
12614
12615 for {
12616 c := v.AuxInt
12617 v_0 := v.Args[0]
12618 if v_0.Op != OpARMSUBconst {
12619 break
12620 }
12621 d := v_0.AuxInt
12622 x := v_0.Args[0]
12623 v.reset(OpARMRSBconst)
12624 v.AuxInt = int64(int32(c + d))
12625 v.AddArg(x)
12626 return true
12627 }
12628 return false
12629 }
12630 func rewriteValueARM_OpARMRSBshiftLL_0(v *Value) bool {
12631 b := v.Block
12632
12633
12634
12635 for {
12636 d := v.AuxInt
12637 x := v.Args[1]
12638 v_0 := v.Args[0]
12639 if v_0.Op != OpARMMOVWconst {
12640 break
12641 }
12642 c := v_0.AuxInt
12643 v.reset(OpARMSUBconst)
12644 v.AuxInt = c
12645 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
12646 v0.AuxInt = d
12647 v0.AddArg(x)
12648 v.AddArg(v0)
12649 return true
12650 }
12651
12652
12653
12654 for {
12655 d := v.AuxInt
12656 _ = v.Args[1]
12657 x := v.Args[0]
12658 v_1 := v.Args[1]
12659 if v_1.Op != OpARMMOVWconst {
12660 break
12661 }
12662 c := v_1.AuxInt
12663 v.reset(OpARMRSBconst)
12664 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
12665 v.AddArg(x)
12666 return true
12667 }
12668
12669
12670
12671 for {
12672 d := v.AuxInt
12673 _ = v.Args[1]
12674 x := v.Args[0]
12675 v_1 := v.Args[1]
12676 if v_1.Op != OpARMSLLconst {
12677 break
12678 }
12679 c := v_1.AuxInt
12680 if x != v_1.Args[0] {
12681 break
12682 }
12683 if !(c == d) {
12684 break
12685 }
12686 v.reset(OpARMMOVWconst)
12687 v.AuxInt = 0
12688 return true
12689 }
12690 return false
12691 }
12692 func rewriteValueARM_OpARMRSBshiftLLreg_0(v *Value) bool {
12693 b := v.Block
12694
12695
12696
12697 for {
12698 y := v.Args[2]
12699 v_0 := v.Args[0]
12700 if v_0.Op != OpARMMOVWconst {
12701 break
12702 }
12703 c := v_0.AuxInt
12704 x := v.Args[1]
12705 v.reset(OpARMSUBconst)
12706 v.AuxInt = c
12707 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
12708 v0.AddArg(x)
12709 v0.AddArg(y)
12710 v.AddArg(v0)
12711 return true
12712 }
12713
12714
12715
12716 for {
12717 _ = v.Args[2]
12718 x := v.Args[0]
12719 y := v.Args[1]
12720 v_2 := v.Args[2]
12721 if v_2.Op != OpARMMOVWconst {
12722 break
12723 }
12724 c := v_2.AuxInt
12725 v.reset(OpARMRSBshiftLL)
12726 v.AuxInt = c
12727 v.AddArg(x)
12728 v.AddArg(y)
12729 return true
12730 }
12731 return false
12732 }
12733 func rewriteValueARM_OpARMRSBshiftRA_0(v *Value) bool {
12734 b := v.Block
12735
12736
12737
12738 for {
12739 d := v.AuxInt
12740 x := v.Args[1]
12741 v_0 := v.Args[0]
12742 if v_0.Op != OpARMMOVWconst {
12743 break
12744 }
12745 c := v_0.AuxInt
12746 v.reset(OpARMSUBconst)
12747 v.AuxInt = c
12748 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
12749 v0.AuxInt = d
12750 v0.AddArg(x)
12751 v.AddArg(v0)
12752 return true
12753 }
12754
12755
12756
12757 for {
12758 d := v.AuxInt
12759 _ = v.Args[1]
12760 x := v.Args[0]
12761 v_1 := v.Args[1]
12762 if v_1.Op != OpARMMOVWconst {
12763 break
12764 }
12765 c := v_1.AuxInt
12766 v.reset(OpARMRSBconst)
12767 v.AuxInt = int64(int32(c) >> uint64(d))
12768 v.AddArg(x)
12769 return true
12770 }
12771
12772
12773
12774 for {
12775 d := v.AuxInt
12776 _ = v.Args[1]
12777 x := v.Args[0]
12778 v_1 := v.Args[1]
12779 if v_1.Op != OpARMSRAconst {
12780 break
12781 }
12782 c := v_1.AuxInt
12783 if x != v_1.Args[0] {
12784 break
12785 }
12786 if !(c == d) {
12787 break
12788 }
12789 v.reset(OpARMMOVWconst)
12790 v.AuxInt = 0
12791 return true
12792 }
12793 return false
12794 }
12795 func rewriteValueARM_OpARMRSBshiftRAreg_0(v *Value) bool {
12796 b := v.Block
12797
12798
12799
12800 for {
12801 y := v.Args[2]
12802 v_0 := v.Args[0]
12803 if v_0.Op != OpARMMOVWconst {
12804 break
12805 }
12806 c := v_0.AuxInt
12807 x := v.Args[1]
12808 v.reset(OpARMSUBconst)
12809 v.AuxInt = c
12810 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
12811 v0.AddArg(x)
12812 v0.AddArg(y)
12813 v.AddArg(v0)
12814 return true
12815 }
12816
12817
12818
12819 for {
12820 _ = v.Args[2]
12821 x := v.Args[0]
12822 y := v.Args[1]
12823 v_2 := v.Args[2]
12824 if v_2.Op != OpARMMOVWconst {
12825 break
12826 }
12827 c := v_2.AuxInt
12828 v.reset(OpARMRSBshiftRA)
12829 v.AuxInt = c
12830 v.AddArg(x)
12831 v.AddArg(y)
12832 return true
12833 }
12834 return false
12835 }
12836 func rewriteValueARM_OpARMRSBshiftRL_0(v *Value) bool {
12837 b := v.Block
12838
12839
12840
12841 for {
12842 d := v.AuxInt
12843 x := v.Args[1]
12844 v_0 := v.Args[0]
12845 if v_0.Op != OpARMMOVWconst {
12846 break
12847 }
12848 c := v_0.AuxInt
12849 v.reset(OpARMSUBconst)
12850 v.AuxInt = c
12851 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
12852 v0.AuxInt = d
12853 v0.AddArg(x)
12854 v.AddArg(v0)
12855 return true
12856 }
12857
12858
12859
12860 for {
12861 d := v.AuxInt
12862 _ = v.Args[1]
12863 x := v.Args[0]
12864 v_1 := v.Args[1]
12865 if v_1.Op != OpARMMOVWconst {
12866 break
12867 }
12868 c := v_1.AuxInt
12869 v.reset(OpARMRSBconst)
12870 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
12871 v.AddArg(x)
12872 return true
12873 }
12874
12875
12876
12877 for {
12878 d := v.AuxInt
12879 _ = v.Args[1]
12880 x := v.Args[0]
12881 v_1 := v.Args[1]
12882 if v_1.Op != OpARMSRLconst {
12883 break
12884 }
12885 c := v_1.AuxInt
12886 if x != v_1.Args[0] {
12887 break
12888 }
12889 if !(c == d) {
12890 break
12891 }
12892 v.reset(OpARMMOVWconst)
12893 v.AuxInt = 0
12894 return true
12895 }
12896 return false
12897 }
12898 func rewriteValueARM_OpARMRSBshiftRLreg_0(v *Value) bool {
12899 b := v.Block
12900
12901
12902
12903 for {
12904 y := v.Args[2]
12905 v_0 := v.Args[0]
12906 if v_0.Op != OpARMMOVWconst {
12907 break
12908 }
12909 c := v_0.AuxInt
12910 x := v.Args[1]
12911 v.reset(OpARMSUBconst)
12912 v.AuxInt = c
12913 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
12914 v0.AddArg(x)
12915 v0.AddArg(y)
12916 v.AddArg(v0)
12917 return true
12918 }
12919
12920
12921
12922 for {
12923 _ = v.Args[2]
12924 x := v.Args[0]
12925 y := v.Args[1]
12926 v_2 := v.Args[2]
12927 if v_2.Op != OpARMMOVWconst {
12928 break
12929 }
12930 c := v_2.AuxInt
12931 v.reset(OpARMRSBshiftRL)
12932 v.AuxInt = c
12933 v.AddArg(x)
12934 v.AddArg(y)
12935 return true
12936 }
12937 return false
12938 }
12939 func rewriteValueARM_OpARMRSCconst_0(v *Value) bool {
12940
12941
12942
12943 for {
12944 c := v.AuxInt
12945 flags := v.Args[1]
12946 v_0 := v.Args[0]
12947 if v_0.Op != OpARMADDconst {
12948 break
12949 }
12950 d := v_0.AuxInt
12951 x := v_0.Args[0]
12952 v.reset(OpARMRSCconst)
12953 v.AuxInt = int64(int32(c - d))
12954 v.AddArg(x)
12955 v.AddArg(flags)
12956 return true
12957 }
12958
12959
12960
12961 for {
12962 c := v.AuxInt
12963 flags := v.Args[1]
12964 v_0 := v.Args[0]
12965 if v_0.Op != OpARMSUBconst {
12966 break
12967 }
12968 d := v_0.AuxInt
12969 x := v_0.Args[0]
12970 v.reset(OpARMRSCconst)
12971 v.AuxInt = int64(int32(c + d))
12972 v.AddArg(x)
12973 v.AddArg(flags)
12974 return true
12975 }
12976 return false
12977 }
12978 func rewriteValueARM_OpARMRSCshiftLL_0(v *Value) bool {
12979 b := v.Block
12980
12981
12982
12983 for {
12984 d := v.AuxInt
12985 flags := v.Args[2]
12986 v_0 := v.Args[0]
12987 if v_0.Op != OpARMMOVWconst {
12988 break
12989 }
12990 c := v_0.AuxInt
12991 x := v.Args[1]
12992 v.reset(OpARMSBCconst)
12993 v.AuxInt = c
12994 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
12995 v0.AuxInt = d
12996 v0.AddArg(x)
12997 v.AddArg(v0)
12998 v.AddArg(flags)
12999 return true
13000 }
13001
13002
13003
13004 for {
13005 d := v.AuxInt
13006 flags := v.Args[2]
13007 x := v.Args[0]
13008 v_1 := v.Args[1]
13009 if v_1.Op != OpARMMOVWconst {
13010 break
13011 }
13012 c := v_1.AuxInt
13013 v.reset(OpARMRSCconst)
13014 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
13015 v.AddArg(x)
13016 v.AddArg(flags)
13017 return true
13018 }
13019 return false
13020 }
13021 func rewriteValueARM_OpARMRSCshiftLLreg_0(v *Value) bool {
13022 b := v.Block
13023
13024
13025
13026 for {
13027 flags := v.Args[3]
13028 v_0 := v.Args[0]
13029 if v_0.Op != OpARMMOVWconst {
13030 break
13031 }
13032 c := v_0.AuxInt
13033 x := v.Args[1]
13034 y := v.Args[2]
13035 v.reset(OpARMSBCconst)
13036 v.AuxInt = c
13037 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
13038 v0.AddArg(x)
13039 v0.AddArg(y)
13040 v.AddArg(v0)
13041 v.AddArg(flags)
13042 return true
13043 }
13044
13045
13046
13047 for {
13048 flags := v.Args[3]
13049 x := v.Args[0]
13050 y := v.Args[1]
13051 v_2 := v.Args[2]
13052 if v_2.Op != OpARMMOVWconst {
13053 break
13054 }
13055 c := v_2.AuxInt
13056 v.reset(OpARMRSCshiftLL)
13057 v.AuxInt = c
13058 v.AddArg(x)
13059 v.AddArg(y)
13060 v.AddArg(flags)
13061 return true
13062 }
13063 return false
13064 }
13065 func rewriteValueARM_OpARMRSCshiftRA_0(v *Value) bool {
13066 b := v.Block
13067
13068
13069
13070 for {
13071 d := v.AuxInt
13072 flags := v.Args[2]
13073 v_0 := v.Args[0]
13074 if v_0.Op != OpARMMOVWconst {
13075 break
13076 }
13077 c := v_0.AuxInt
13078 x := v.Args[1]
13079 v.reset(OpARMSBCconst)
13080 v.AuxInt = c
13081 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
13082 v0.AuxInt = d
13083 v0.AddArg(x)
13084 v.AddArg(v0)
13085 v.AddArg(flags)
13086 return true
13087 }
13088
13089
13090
13091 for {
13092 d := v.AuxInt
13093 flags := v.Args[2]
13094 x := v.Args[0]
13095 v_1 := v.Args[1]
13096 if v_1.Op != OpARMMOVWconst {
13097 break
13098 }
13099 c := v_1.AuxInt
13100 v.reset(OpARMRSCconst)
13101 v.AuxInt = int64(int32(c) >> uint64(d))
13102 v.AddArg(x)
13103 v.AddArg(flags)
13104 return true
13105 }
13106 return false
13107 }
13108 func rewriteValueARM_OpARMRSCshiftRAreg_0(v *Value) bool {
13109 b := v.Block
13110
13111
13112
13113 for {
13114 flags := v.Args[3]
13115 v_0 := v.Args[0]
13116 if v_0.Op != OpARMMOVWconst {
13117 break
13118 }
13119 c := v_0.AuxInt
13120 x := v.Args[1]
13121 y := v.Args[2]
13122 v.reset(OpARMSBCconst)
13123 v.AuxInt = c
13124 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
13125 v0.AddArg(x)
13126 v0.AddArg(y)
13127 v.AddArg(v0)
13128 v.AddArg(flags)
13129 return true
13130 }
13131
13132
13133
13134 for {
13135 flags := v.Args[3]
13136 x := v.Args[0]
13137 y := v.Args[1]
13138 v_2 := v.Args[2]
13139 if v_2.Op != OpARMMOVWconst {
13140 break
13141 }
13142 c := v_2.AuxInt
13143 v.reset(OpARMRSCshiftRA)
13144 v.AuxInt = c
13145 v.AddArg(x)
13146 v.AddArg(y)
13147 v.AddArg(flags)
13148 return true
13149 }
13150 return false
13151 }
13152 func rewriteValueARM_OpARMRSCshiftRL_0(v *Value) bool {
13153 b := v.Block
13154
13155
13156
13157 for {
13158 d := v.AuxInt
13159 flags := v.Args[2]
13160 v_0 := v.Args[0]
13161 if v_0.Op != OpARMMOVWconst {
13162 break
13163 }
13164 c := v_0.AuxInt
13165 x := v.Args[1]
13166 v.reset(OpARMSBCconst)
13167 v.AuxInt = c
13168 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
13169 v0.AuxInt = d
13170 v0.AddArg(x)
13171 v.AddArg(v0)
13172 v.AddArg(flags)
13173 return true
13174 }
13175
13176
13177
13178 for {
13179 d := v.AuxInt
13180 flags := v.Args[2]
13181 x := v.Args[0]
13182 v_1 := v.Args[1]
13183 if v_1.Op != OpARMMOVWconst {
13184 break
13185 }
13186 c := v_1.AuxInt
13187 v.reset(OpARMRSCconst)
13188 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
13189 v.AddArg(x)
13190 v.AddArg(flags)
13191 return true
13192 }
13193 return false
13194 }
13195 func rewriteValueARM_OpARMRSCshiftRLreg_0(v *Value) bool {
13196 b := v.Block
13197
13198
13199
13200 for {
13201 flags := v.Args[3]
13202 v_0 := v.Args[0]
13203 if v_0.Op != OpARMMOVWconst {
13204 break
13205 }
13206 c := v_0.AuxInt
13207 x := v.Args[1]
13208 y := v.Args[2]
13209 v.reset(OpARMSBCconst)
13210 v.AuxInt = c
13211 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
13212 v0.AddArg(x)
13213 v0.AddArg(y)
13214 v.AddArg(v0)
13215 v.AddArg(flags)
13216 return true
13217 }
13218
13219
13220
13221 for {
13222 flags := v.Args[3]
13223 x := v.Args[0]
13224 y := v.Args[1]
13225 v_2 := v.Args[2]
13226 if v_2.Op != OpARMMOVWconst {
13227 break
13228 }
13229 c := v_2.AuxInt
13230 v.reset(OpARMRSCshiftRL)
13231 v.AuxInt = c
13232 v.AddArg(x)
13233 v.AddArg(y)
13234 v.AddArg(flags)
13235 return true
13236 }
13237 return false
13238 }
13239 func rewriteValueARM_OpARMSBC_0(v *Value) bool {
13240
13241
13242
13243 for {
13244 flags := v.Args[2]
13245 v_0 := v.Args[0]
13246 if v_0.Op != OpARMMOVWconst {
13247 break
13248 }
13249 c := v_0.AuxInt
13250 x := v.Args[1]
13251 v.reset(OpARMRSCconst)
13252 v.AuxInt = c
13253 v.AddArg(x)
13254 v.AddArg(flags)
13255 return true
13256 }
13257
13258
13259
13260 for {
13261 flags := v.Args[2]
13262 x := v.Args[0]
13263 v_1 := v.Args[1]
13264 if v_1.Op != OpARMMOVWconst {
13265 break
13266 }
13267 c := v_1.AuxInt
13268 v.reset(OpARMSBCconst)
13269 v.AuxInt = c
13270 v.AddArg(x)
13271 v.AddArg(flags)
13272 return true
13273 }
13274
13275
13276
13277 for {
13278 flags := v.Args[2]
13279 x := v.Args[0]
13280 v_1 := v.Args[1]
13281 if v_1.Op != OpARMSLLconst {
13282 break
13283 }
13284 c := v_1.AuxInt
13285 y := v_1.Args[0]
13286 v.reset(OpARMSBCshiftLL)
13287 v.AuxInt = c
13288 v.AddArg(x)
13289 v.AddArg(y)
13290 v.AddArg(flags)
13291 return true
13292 }
13293
13294
13295
13296 for {
13297 flags := v.Args[2]
13298 v_0 := v.Args[0]
13299 if v_0.Op != OpARMSLLconst {
13300 break
13301 }
13302 c := v_0.AuxInt
13303 y := v_0.Args[0]
13304 x := v.Args[1]
13305 v.reset(OpARMRSCshiftLL)
13306 v.AuxInt = c
13307 v.AddArg(x)
13308 v.AddArg(y)
13309 v.AddArg(flags)
13310 return true
13311 }
13312
13313
13314
13315 for {
13316 flags := v.Args[2]
13317 x := v.Args[0]
13318 v_1 := v.Args[1]
13319 if v_1.Op != OpARMSRLconst {
13320 break
13321 }
13322 c := v_1.AuxInt
13323 y := v_1.Args[0]
13324 v.reset(OpARMSBCshiftRL)
13325 v.AuxInt = c
13326 v.AddArg(x)
13327 v.AddArg(y)
13328 v.AddArg(flags)
13329 return true
13330 }
13331
13332
13333
13334 for {
13335 flags := v.Args[2]
13336 v_0 := v.Args[0]
13337 if v_0.Op != OpARMSRLconst {
13338 break
13339 }
13340 c := v_0.AuxInt
13341 y := v_0.Args[0]
13342 x := v.Args[1]
13343 v.reset(OpARMRSCshiftRL)
13344 v.AuxInt = c
13345 v.AddArg(x)
13346 v.AddArg(y)
13347 v.AddArg(flags)
13348 return true
13349 }
13350
13351
13352
13353 for {
13354 flags := v.Args[2]
13355 x := v.Args[0]
13356 v_1 := v.Args[1]
13357 if v_1.Op != OpARMSRAconst {
13358 break
13359 }
13360 c := v_1.AuxInt
13361 y := v_1.Args[0]
13362 v.reset(OpARMSBCshiftRA)
13363 v.AuxInt = c
13364 v.AddArg(x)
13365 v.AddArg(y)
13366 v.AddArg(flags)
13367 return true
13368 }
13369
13370
13371
13372 for {
13373 flags := v.Args[2]
13374 v_0 := v.Args[0]
13375 if v_0.Op != OpARMSRAconst {
13376 break
13377 }
13378 c := v_0.AuxInt
13379 y := v_0.Args[0]
13380 x := v.Args[1]
13381 v.reset(OpARMRSCshiftRA)
13382 v.AuxInt = c
13383 v.AddArg(x)
13384 v.AddArg(y)
13385 v.AddArg(flags)
13386 return true
13387 }
13388
13389
13390
13391 for {
13392 flags := v.Args[2]
13393 x := v.Args[0]
13394 v_1 := v.Args[1]
13395 if v_1.Op != OpARMSLL {
13396 break
13397 }
13398 z := v_1.Args[1]
13399 y := v_1.Args[0]
13400 v.reset(OpARMSBCshiftLLreg)
13401 v.AddArg(x)
13402 v.AddArg(y)
13403 v.AddArg(z)
13404 v.AddArg(flags)
13405 return true
13406 }
13407
13408
13409
13410 for {
13411 flags := v.Args[2]
13412 v_0 := v.Args[0]
13413 if v_0.Op != OpARMSLL {
13414 break
13415 }
13416 z := v_0.Args[1]
13417 y := v_0.Args[0]
13418 x := v.Args[1]
13419 v.reset(OpARMRSCshiftLLreg)
13420 v.AddArg(x)
13421 v.AddArg(y)
13422 v.AddArg(z)
13423 v.AddArg(flags)
13424 return true
13425 }
13426 return false
13427 }
13428 func rewriteValueARM_OpARMSBC_10(v *Value) bool {
13429
13430
13431
13432 for {
13433 flags := v.Args[2]
13434 x := v.Args[0]
13435 v_1 := v.Args[1]
13436 if v_1.Op != OpARMSRL {
13437 break
13438 }
13439 z := v_1.Args[1]
13440 y := v_1.Args[0]
13441 v.reset(OpARMSBCshiftRLreg)
13442 v.AddArg(x)
13443 v.AddArg(y)
13444 v.AddArg(z)
13445 v.AddArg(flags)
13446 return true
13447 }
13448
13449
13450
13451 for {
13452 flags := v.Args[2]
13453 v_0 := v.Args[0]
13454 if v_0.Op != OpARMSRL {
13455 break
13456 }
13457 z := v_0.Args[1]
13458 y := v_0.Args[0]
13459 x := v.Args[1]
13460 v.reset(OpARMRSCshiftRLreg)
13461 v.AddArg(x)
13462 v.AddArg(y)
13463 v.AddArg(z)
13464 v.AddArg(flags)
13465 return true
13466 }
13467
13468
13469
13470 for {
13471 flags := v.Args[2]
13472 x := v.Args[0]
13473 v_1 := v.Args[1]
13474 if v_1.Op != OpARMSRA {
13475 break
13476 }
13477 z := v_1.Args[1]
13478 y := v_1.Args[0]
13479 v.reset(OpARMSBCshiftRAreg)
13480 v.AddArg(x)
13481 v.AddArg(y)
13482 v.AddArg(z)
13483 v.AddArg(flags)
13484 return true
13485 }
13486
13487
13488
13489 for {
13490 flags := v.Args[2]
13491 v_0 := v.Args[0]
13492 if v_0.Op != OpARMSRA {
13493 break
13494 }
13495 z := v_0.Args[1]
13496 y := v_0.Args[0]
13497 x := v.Args[1]
13498 v.reset(OpARMRSCshiftRAreg)
13499 v.AddArg(x)
13500 v.AddArg(y)
13501 v.AddArg(z)
13502 v.AddArg(flags)
13503 return true
13504 }
13505 return false
13506 }
13507 func rewriteValueARM_OpARMSBCconst_0(v *Value) bool {
13508
13509
13510
13511 for {
13512 c := v.AuxInt
13513 flags := v.Args[1]
13514 v_0 := v.Args[0]
13515 if v_0.Op != OpARMADDconst {
13516 break
13517 }
13518 d := v_0.AuxInt
13519 x := v_0.Args[0]
13520 v.reset(OpARMSBCconst)
13521 v.AuxInt = int64(int32(c - d))
13522 v.AddArg(x)
13523 v.AddArg(flags)
13524 return true
13525 }
13526
13527
13528
13529 for {
13530 c := v.AuxInt
13531 flags := v.Args[1]
13532 v_0 := v.Args[0]
13533 if v_0.Op != OpARMSUBconst {
13534 break
13535 }
13536 d := v_0.AuxInt
13537 x := v_0.Args[0]
13538 v.reset(OpARMSBCconst)
13539 v.AuxInt = int64(int32(c + d))
13540 v.AddArg(x)
13541 v.AddArg(flags)
13542 return true
13543 }
13544 return false
13545 }
13546 func rewriteValueARM_OpARMSBCshiftLL_0(v *Value) bool {
13547 b := v.Block
13548
13549
13550
13551 for {
13552 d := v.AuxInt
13553 flags := v.Args[2]
13554 v_0 := v.Args[0]
13555 if v_0.Op != OpARMMOVWconst {
13556 break
13557 }
13558 c := v_0.AuxInt
13559 x := v.Args[1]
13560 v.reset(OpARMRSCconst)
13561 v.AuxInt = c
13562 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
13563 v0.AuxInt = d
13564 v0.AddArg(x)
13565 v.AddArg(v0)
13566 v.AddArg(flags)
13567 return true
13568 }
13569
13570
13571
13572 for {
13573 d := v.AuxInt
13574 flags := v.Args[2]
13575 x := v.Args[0]
13576 v_1 := v.Args[1]
13577 if v_1.Op != OpARMMOVWconst {
13578 break
13579 }
13580 c := v_1.AuxInt
13581 v.reset(OpARMSBCconst)
13582 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
13583 v.AddArg(x)
13584 v.AddArg(flags)
13585 return true
13586 }
13587 return false
13588 }
13589 func rewriteValueARM_OpARMSBCshiftLLreg_0(v *Value) bool {
13590 b := v.Block
13591
13592
13593
13594 for {
13595 flags := v.Args[3]
13596 v_0 := v.Args[0]
13597 if v_0.Op != OpARMMOVWconst {
13598 break
13599 }
13600 c := v_0.AuxInt
13601 x := v.Args[1]
13602 y := v.Args[2]
13603 v.reset(OpARMRSCconst)
13604 v.AuxInt = c
13605 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
13606 v0.AddArg(x)
13607 v0.AddArg(y)
13608 v.AddArg(v0)
13609 v.AddArg(flags)
13610 return true
13611 }
13612
13613
13614
13615 for {
13616 flags := v.Args[3]
13617 x := v.Args[0]
13618 y := v.Args[1]
13619 v_2 := v.Args[2]
13620 if v_2.Op != OpARMMOVWconst {
13621 break
13622 }
13623 c := v_2.AuxInt
13624 v.reset(OpARMSBCshiftLL)
13625 v.AuxInt = c
13626 v.AddArg(x)
13627 v.AddArg(y)
13628 v.AddArg(flags)
13629 return true
13630 }
13631 return false
13632 }
13633 func rewriteValueARM_OpARMSBCshiftRA_0(v *Value) bool {
13634 b := v.Block
13635
13636
13637
13638 for {
13639 d := v.AuxInt
13640 flags := v.Args[2]
13641 v_0 := v.Args[0]
13642 if v_0.Op != OpARMMOVWconst {
13643 break
13644 }
13645 c := v_0.AuxInt
13646 x := v.Args[1]
13647 v.reset(OpARMRSCconst)
13648 v.AuxInt = c
13649 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
13650 v0.AuxInt = d
13651 v0.AddArg(x)
13652 v.AddArg(v0)
13653 v.AddArg(flags)
13654 return true
13655 }
13656
13657
13658
13659 for {
13660 d := v.AuxInt
13661 flags := v.Args[2]
13662 x := v.Args[0]
13663 v_1 := v.Args[1]
13664 if v_1.Op != OpARMMOVWconst {
13665 break
13666 }
13667 c := v_1.AuxInt
13668 v.reset(OpARMSBCconst)
13669 v.AuxInt = int64(int32(c) >> uint64(d))
13670 v.AddArg(x)
13671 v.AddArg(flags)
13672 return true
13673 }
13674 return false
13675 }
13676 func rewriteValueARM_OpARMSBCshiftRAreg_0(v *Value) bool {
13677 b := v.Block
13678
13679
13680
13681 for {
13682 flags := v.Args[3]
13683 v_0 := v.Args[0]
13684 if v_0.Op != OpARMMOVWconst {
13685 break
13686 }
13687 c := v_0.AuxInt
13688 x := v.Args[1]
13689 y := v.Args[2]
13690 v.reset(OpARMRSCconst)
13691 v.AuxInt = c
13692 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
13693 v0.AddArg(x)
13694 v0.AddArg(y)
13695 v.AddArg(v0)
13696 v.AddArg(flags)
13697 return true
13698 }
13699
13700
13701
13702 for {
13703 flags := v.Args[3]
13704 x := v.Args[0]
13705 y := v.Args[1]
13706 v_2 := v.Args[2]
13707 if v_2.Op != OpARMMOVWconst {
13708 break
13709 }
13710 c := v_2.AuxInt
13711 v.reset(OpARMSBCshiftRA)
13712 v.AuxInt = c
13713 v.AddArg(x)
13714 v.AddArg(y)
13715 v.AddArg(flags)
13716 return true
13717 }
13718 return false
13719 }
13720 func rewriteValueARM_OpARMSBCshiftRL_0(v *Value) bool {
13721 b := v.Block
13722
13723
13724
13725 for {
13726 d := v.AuxInt
13727 flags := v.Args[2]
13728 v_0 := v.Args[0]
13729 if v_0.Op != OpARMMOVWconst {
13730 break
13731 }
13732 c := v_0.AuxInt
13733 x := v.Args[1]
13734 v.reset(OpARMRSCconst)
13735 v.AuxInt = c
13736 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
13737 v0.AuxInt = d
13738 v0.AddArg(x)
13739 v.AddArg(v0)
13740 v.AddArg(flags)
13741 return true
13742 }
13743
13744
13745
13746 for {
13747 d := v.AuxInt
13748 flags := v.Args[2]
13749 x := v.Args[0]
13750 v_1 := v.Args[1]
13751 if v_1.Op != OpARMMOVWconst {
13752 break
13753 }
13754 c := v_1.AuxInt
13755 v.reset(OpARMSBCconst)
13756 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
13757 v.AddArg(x)
13758 v.AddArg(flags)
13759 return true
13760 }
13761 return false
13762 }
13763 func rewriteValueARM_OpARMSBCshiftRLreg_0(v *Value) bool {
13764 b := v.Block
13765
13766
13767
13768 for {
13769 flags := v.Args[3]
13770 v_0 := v.Args[0]
13771 if v_0.Op != OpARMMOVWconst {
13772 break
13773 }
13774 c := v_0.AuxInt
13775 x := v.Args[1]
13776 y := v.Args[2]
13777 v.reset(OpARMRSCconst)
13778 v.AuxInt = c
13779 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
13780 v0.AddArg(x)
13781 v0.AddArg(y)
13782 v.AddArg(v0)
13783 v.AddArg(flags)
13784 return true
13785 }
13786
13787
13788
13789 for {
13790 flags := v.Args[3]
13791 x := v.Args[0]
13792 y := v.Args[1]
13793 v_2 := v.Args[2]
13794 if v_2.Op != OpARMMOVWconst {
13795 break
13796 }
13797 c := v_2.AuxInt
13798 v.reset(OpARMSBCshiftRL)
13799 v.AuxInt = c
13800 v.AddArg(x)
13801 v.AddArg(y)
13802 v.AddArg(flags)
13803 return true
13804 }
13805 return false
13806 }
13807 func rewriteValueARM_OpARMSLL_0(v *Value) bool {
13808
13809
13810
13811 for {
13812 _ = v.Args[1]
13813 x := v.Args[0]
13814 v_1 := v.Args[1]
13815 if v_1.Op != OpARMMOVWconst {
13816 break
13817 }
13818 c := v_1.AuxInt
13819 v.reset(OpARMSLLconst)
13820 v.AuxInt = c & 31
13821 v.AddArg(x)
13822 return true
13823 }
13824 return false
13825 }
13826 func rewriteValueARM_OpARMSLLconst_0(v *Value) bool {
13827
13828
13829
13830 for {
13831 c := v.AuxInt
13832 v_0 := v.Args[0]
13833 if v_0.Op != OpARMMOVWconst {
13834 break
13835 }
13836 d := v_0.AuxInt
13837 v.reset(OpARMMOVWconst)
13838 v.AuxInt = int64(int32(uint32(d) << uint64(c)))
13839 return true
13840 }
13841 return false
13842 }
13843 func rewriteValueARM_OpARMSRA_0(v *Value) bool {
13844
13845
13846
13847 for {
13848 _ = v.Args[1]
13849 x := v.Args[0]
13850 v_1 := v.Args[1]
13851 if v_1.Op != OpARMMOVWconst {
13852 break
13853 }
13854 c := v_1.AuxInt
13855 v.reset(OpARMSRAconst)
13856 v.AuxInt = c & 31
13857 v.AddArg(x)
13858 return true
13859 }
13860 return false
13861 }
13862 func rewriteValueARM_OpARMSRAcond_0(v *Value) bool {
13863
13864
13865
13866 for {
13867 _ = v.Args[2]
13868 x := v.Args[0]
13869 v_2 := v.Args[2]
13870 if v_2.Op != OpARMFlagEQ {
13871 break
13872 }
13873 v.reset(OpARMSRAconst)
13874 v.AuxInt = 31
13875 v.AddArg(x)
13876 return true
13877 }
13878
13879
13880
13881 for {
13882 _ = v.Args[2]
13883 x := v.Args[0]
13884 y := v.Args[1]
13885 v_2 := v.Args[2]
13886 if v_2.Op != OpARMFlagLT_ULT {
13887 break
13888 }
13889 v.reset(OpARMSRA)
13890 v.AddArg(x)
13891 v.AddArg(y)
13892 return true
13893 }
13894
13895
13896
13897 for {
13898 _ = v.Args[2]
13899 x := v.Args[0]
13900 v_2 := v.Args[2]
13901 if v_2.Op != OpARMFlagLT_UGT {
13902 break
13903 }
13904 v.reset(OpARMSRAconst)
13905 v.AuxInt = 31
13906 v.AddArg(x)
13907 return true
13908 }
13909
13910
13911
13912 for {
13913 _ = v.Args[2]
13914 x := v.Args[0]
13915 y := v.Args[1]
13916 v_2 := v.Args[2]
13917 if v_2.Op != OpARMFlagGT_ULT {
13918 break
13919 }
13920 v.reset(OpARMSRA)
13921 v.AddArg(x)
13922 v.AddArg(y)
13923 return true
13924 }
13925
13926
13927
13928 for {
13929 _ = v.Args[2]
13930 x := v.Args[0]
13931 v_2 := v.Args[2]
13932 if v_2.Op != OpARMFlagGT_UGT {
13933 break
13934 }
13935 v.reset(OpARMSRAconst)
13936 v.AuxInt = 31
13937 v.AddArg(x)
13938 return true
13939 }
13940 return false
13941 }
13942 func rewriteValueARM_OpARMSRAconst_0(v *Value) bool {
13943
13944
13945
13946 for {
13947 c := v.AuxInt
13948 v_0 := v.Args[0]
13949 if v_0.Op != OpARMMOVWconst {
13950 break
13951 }
13952 d := v_0.AuxInt
13953 v.reset(OpARMMOVWconst)
13954 v.AuxInt = int64(int32(d) >> uint64(c))
13955 return true
13956 }
13957
13958
13959
13960 for {
13961 d := v.AuxInt
13962 v_0 := v.Args[0]
13963 if v_0.Op != OpARMSLLconst {
13964 break
13965 }
13966 c := v_0.AuxInt
13967 x := v_0.Args[0]
13968 if !(objabi.GOARM == 7 && uint64(d) >= uint64(c) && uint64(d) <= 31) {
13969 break
13970 }
13971 v.reset(OpARMBFX)
13972 v.AuxInt = (d - c) | (32-d)<<8
13973 v.AddArg(x)
13974 return true
13975 }
13976 return false
13977 }
13978 func rewriteValueARM_OpARMSRL_0(v *Value) bool {
13979
13980
13981
13982 for {
13983 _ = v.Args[1]
13984 x := v.Args[0]
13985 v_1 := v.Args[1]
13986 if v_1.Op != OpARMMOVWconst {
13987 break
13988 }
13989 c := v_1.AuxInt
13990 v.reset(OpARMSRLconst)
13991 v.AuxInt = c & 31
13992 v.AddArg(x)
13993 return true
13994 }
13995 return false
13996 }
13997 func rewriteValueARM_OpARMSRLconst_0(v *Value) bool {
13998
13999
14000
14001 for {
14002 c := v.AuxInt
14003 v_0 := v.Args[0]
14004 if v_0.Op != OpARMMOVWconst {
14005 break
14006 }
14007 d := v_0.AuxInt
14008 v.reset(OpARMMOVWconst)
14009 v.AuxInt = int64(int32(uint32(d) >> uint64(c)))
14010 return true
14011 }
14012
14013
14014
14015 for {
14016 d := v.AuxInt
14017 v_0 := v.Args[0]
14018 if v_0.Op != OpARMSLLconst {
14019 break
14020 }
14021 c := v_0.AuxInt
14022 x := v_0.Args[0]
14023 if !(objabi.GOARM == 7 && uint64(d) >= uint64(c) && uint64(d) <= 31) {
14024 break
14025 }
14026 v.reset(OpARMBFXU)
14027 v.AuxInt = (d - c) | (32-d)<<8
14028 v.AddArg(x)
14029 return true
14030 }
14031 return false
14032 }
14033 func rewriteValueARM_OpARMSUB_0(v *Value) bool {
14034
14035
14036
14037 for {
14038 x := v.Args[1]
14039 v_0 := v.Args[0]
14040 if v_0.Op != OpARMMOVWconst {
14041 break
14042 }
14043 c := v_0.AuxInt
14044 v.reset(OpARMRSBconst)
14045 v.AuxInt = c
14046 v.AddArg(x)
14047 return true
14048 }
14049
14050
14051
14052 for {
14053 _ = v.Args[1]
14054 x := v.Args[0]
14055 v_1 := v.Args[1]
14056 if v_1.Op != OpARMMOVWconst {
14057 break
14058 }
14059 c := v_1.AuxInt
14060 v.reset(OpARMSUBconst)
14061 v.AuxInt = c
14062 v.AddArg(x)
14063 return true
14064 }
14065
14066
14067
14068 for {
14069 _ = v.Args[1]
14070 x := v.Args[0]
14071 v_1 := v.Args[1]
14072 if v_1.Op != OpARMSLLconst {
14073 break
14074 }
14075 c := v_1.AuxInt
14076 y := v_1.Args[0]
14077 v.reset(OpARMSUBshiftLL)
14078 v.AuxInt = c
14079 v.AddArg(x)
14080 v.AddArg(y)
14081 return true
14082 }
14083
14084
14085
14086 for {
14087 x := v.Args[1]
14088 v_0 := v.Args[0]
14089 if v_0.Op != OpARMSLLconst {
14090 break
14091 }
14092 c := v_0.AuxInt
14093 y := v_0.Args[0]
14094 v.reset(OpARMRSBshiftLL)
14095 v.AuxInt = c
14096 v.AddArg(x)
14097 v.AddArg(y)
14098 return true
14099 }
14100
14101
14102
14103 for {
14104 _ = v.Args[1]
14105 x := v.Args[0]
14106 v_1 := v.Args[1]
14107 if v_1.Op != OpARMSRLconst {
14108 break
14109 }
14110 c := v_1.AuxInt
14111 y := v_1.Args[0]
14112 v.reset(OpARMSUBshiftRL)
14113 v.AuxInt = c
14114 v.AddArg(x)
14115 v.AddArg(y)
14116 return true
14117 }
14118
14119
14120
14121 for {
14122 x := v.Args[1]
14123 v_0 := v.Args[0]
14124 if v_0.Op != OpARMSRLconst {
14125 break
14126 }
14127 c := v_0.AuxInt
14128 y := v_0.Args[0]
14129 v.reset(OpARMRSBshiftRL)
14130 v.AuxInt = c
14131 v.AddArg(x)
14132 v.AddArg(y)
14133 return true
14134 }
14135
14136
14137
14138 for {
14139 _ = v.Args[1]
14140 x := v.Args[0]
14141 v_1 := v.Args[1]
14142 if v_1.Op != OpARMSRAconst {
14143 break
14144 }
14145 c := v_1.AuxInt
14146 y := v_1.Args[0]
14147 v.reset(OpARMSUBshiftRA)
14148 v.AuxInt = c
14149 v.AddArg(x)
14150 v.AddArg(y)
14151 return true
14152 }
14153
14154
14155
14156 for {
14157 x := v.Args[1]
14158 v_0 := v.Args[0]
14159 if v_0.Op != OpARMSRAconst {
14160 break
14161 }
14162 c := v_0.AuxInt
14163 y := v_0.Args[0]
14164 v.reset(OpARMRSBshiftRA)
14165 v.AuxInt = c
14166 v.AddArg(x)
14167 v.AddArg(y)
14168 return true
14169 }
14170
14171
14172
14173 for {
14174 _ = v.Args[1]
14175 x := v.Args[0]
14176 v_1 := v.Args[1]
14177 if v_1.Op != OpARMSLL {
14178 break
14179 }
14180 z := v_1.Args[1]
14181 y := v_1.Args[0]
14182 v.reset(OpARMSUBshiftLLreg)
14183 v.AddArg(x)
14184 v.AddArg(y)
14185 v.AddArg(z)
14186 return true
14187 }
14188
14189
14190
14191 for {
14192 x := v.Args[1]
14193 v_0 := v.Args[0]
14194 if v_0.Op != OpARMSLL {
14195 break
14196 }
14197 z := v_0.Args[1]
14198 y := v_0.Args[0]
14199 v.reset(OpARMRSBshiftLLreg)
14200 v.AddArg(x)
14201 v.AddArg(y)
14202 v.AddArg(z)
14203 return true
14204 }
14205 return false
14206 }
14207 func rewriteValueARM_OpARMSUB_10(v *Value) bool {
14208
14209
14210
14211 for {
14212 _ = v.Args[1]
14213 x := v.Args[0]
14214 v_1 := v.Args[1]
14215 if v_1.Op != OpARMSRL {
14216 break
14217 }
14218 z := v_1.Args[1]
14219 y := v_1.Args[0]
14220 v.reset(OpARMSUBshiftRLreg)
14221 v.AddArg(x)
14222 v.AddArg(y)
14223 v.AddArg(z)
14224 return true
14225 }
14226
14227
14228
14229 for {
14230 x := v.Args[1]
14231 v_0 := v.Args[0]
14232 if v_0.Op != OpARMSRL {
14233 break
14234 }
14235 z := v_0.Args[1]
14236 y := v_0.Args[0]
14237 v.reset(OpARMRSBshiftRLreg)
14238 v.AddArg(x)
14239 v.AddArg(y)
14240 v.AddArg(z)
14241 return true
14242 }
14243
14244
14245
14246 for {
14247 _ = v.Args[1]
14248 x := v.Args[0]
14249 v_1 := v.Args[1]
14250 if v_1.Op != OpARMSRA {
14251 break
14252 }
14253 z := v_1.Args[1]
14254 y := v_1.Args[0]
14255 v.reset(OpARMSUBshiftRAreg)
14256 v.AddArg(x)
14257 v.AddArg(y)
14258 v.AddArg(z)
14259 return true
14260 }
14261
14262
14263
14264 for {
14265 x := v.Args[1]
14266 v_0 := v.Args[0]
14267 if v_0.Op != OpARMSRA {
14268 break
14269 }
14270 z := v_0.Args[1]
14271 y := v_0.Args[0]
14272 v.reset(OpARMRSBshiftRAreg)
14273 v.AddArg(x)
14274 v.AddArg(y)
14275 v.AddArg(z)
14276 return true
14277 }
14278
14279
14280
14281 for {
14282 x := v.Args[1]
14283 if x != v.Args[0] {
14284 break
14285 }
14286 v.reset(OpARMMOVWconst)
14287 v.AuxInt = 0
14288 return true
14289 }
14290
14291
14292
14293 for {
14294 _ = v.Args[1]
14295 a := v.Args[0]
14296 v_1 := v.Args[1]
14297 if v_1.Op != OpARMMUL {
14298 break
14299 }
14300 y := v_1.Args[1]
14301 x := v_1.Args[0]
14302 if !(objabi.GOARM == 7) {
14303 break
14304 }
14305 v.reset(OpARMMULS)
14306 v.AddArg(x)
14307 v.AddArg(y)
14308 v.AddArg(a)
14309 return true
14310 }
14311 return false
14312 }
14313 func rewriteValueARM_OpARMSUBD_0(v *Value) bool {
14314
14315
14316
14317 for {
14318 _ = v.Args[1]
14319 a := v.Args[0]
14320 v_1 := v.Args[1]
14321 if v_1.Op != OpARMMULD {
14322 break
14323 }
14324 y := v_1.Args[1]
14325 x := v_1.Args[0]
14326 if !(a.Uses == 1 && objabi.GOARM >= 6) {
14327 break
14328 }
14329 v.reset(OpARMMULSD)
14330 v.AddArg(a)
14331 v.AddArg(x)
14332 v.AddArg(y)
14333 return true
14334 }
14335
14336
14337
14338 for {
14339 _ = v.Args[1]
14340 a := v.Args[0]
14341 v_1 := v.Args[1]
14342 if v_1.Op != OpARMNMULD {
14343 break
14344 }
14345 y := v_1.Args[1]
14346 x := v_1.Args[0]
14347 if !(a.Uses == 1 && objabi.GOARM >= 6) {
14348 break
14349 }
14350 v.reset(OpARMMULAD)
14351 v.AddArg(a)
14352 v.AddArg(x)
14353 v.AddArg(y)
14354 return true
14355 }
14356 return false
14357 }
14358 func rewriteValueARM_OpARMSUBF_0(v *Value) bool {
14359
14360
14361
14362 for {
14363 _ = v.Args[1]
14364 a := v.Args[0]
14365 v_1 := v.Args[1]
14366 if v_1.Op != OpARMMULF {
14367 break
14368 }
14369 y := v_1.Args[1]
14370 x := v_1.Args[0]
14371 if !(a.Uses == 1 && objabi.GOARM >= 6) {
14372 break
14373 }
14374 v.reset(OpARMMULSF)
14375 v.AddArg(a)
14376 v.AddArg(x)
14377 v.AddArg(y)
14378 return true
14379 }
14380
14381
14382
14383 for {
14384 _ = v.Args[1]
14385 a := v.Args[0]
14386 v_1 := v.Args[1]
14387 if v_1.Op != OpARMNMULF {
14388 break
14389 }
14390 y := v_1.Args[1]
14391 x := v_1.Args[0]
14392 if !(a.Uses == 1 && objabi.GOARM >= 6) {
14393 break
14394 }
14395 v.reset(OpARMMULAF)
14396 v.AddArg(a)
14397 v.AddArg(x)
14398 v.AddArg(y)
14399 return true
14400 }
14401 return false
14402 }
14403 func rewriteValueARM_OpARMSUBS_0(v *Value) bool {
14404
14405
14406
14407 for {
14408 _ = v.Args[1]
14409 x := v.Args[0]
14410 v_1 := v.Args[1]
14411 if v_1.Op != OpARMMOVWconst {
14412 break
14413 }
14414 c := v_1.AuxInt
14415 v.reset(OpARMSUBSconst)
14416 v.AuxInt = c
14417 v.AddArg(x)
14418 return true
14419 }
14420
14421
14422
14423 for {
14424 _ = v.Args[1]
14425 x := v.Args[0]
14426 v_1 := v.Args[1]
14427 if v_1.Op != OpARMSLLconst {
14428 break
14429 }
14430 c := v_1.AuxInt
14431 y := v_1.Args[0]
14432 v.reset(OpARMSUBSshiftLL)
14433 v.AuxInt = c
14434 v.AddArg(x)
14435 v.AddArg(y)
14436 return true
14437 }
14438
14439
14440
14441 for {
14442 x := v.Args[1]
14443 v_0 := v.Args[0]
14444 if v_0.Op != OpARMSLLconst {
14445 break
14446 }
14447 c := v_0.AuxInt
14448 y := v_0.Args[0]
14449 v.reset(OpARMRSBSshiftLL)
14450 v.AuxInt = c
14451 v.AddArg(x)
14452 v.AddArg(y)
14453 return true
14454 }
14455
14456
14457
14458 for {
14459 _ = v.Args[1]
14460 x := v.Args[0]
14461 v_1 := v.Args[1]
14462 if v_1.Op != OpARMSRLconst {
14463 break
14464 }
14465 c := v_1.AuxInt
14466 y := v_1.Args[0]
14467 v.reset(OpARMSUBSshiftRL)
14468 v.AuxInt = c
14469 v.AddArg(x)
14470 v.AddArg(y)
14471 return true
14472 }
14473
14474
14475
14476 for {
14477 x := v.Args[1]
14478 v_0 := v.Args[0]
14479 if v_0.Op != OpARMSRLconst {
14480 break
14481 }
14482 c := v_0.AuxInt
14483 y := v_0.Args[0]
14484 v.reset(OpARMRSBSshiftRL)
14485 v.AuxInt = c
14486 v.AddArg(x)
14487 v.AddArg(y)
14488 return true
14489 }
14490
14491
14492
14493 for {
14494 _ = v.Args[1]
14495 x := v.Args[0]
14496 v_1 := v.Args[1]
14497 if v_1.Op != OpARMSRAconst {
14498 break
14499 }
14500 c := v_1.AuxInt
14501 y := v_1.Args[0]
14502 v.reset(OpARMSUBSshiftRA)
14503 v.AuxInt = c
14504 v.AddArg(x)
14505 v.AddArg(y)
14506 return true
14507 }
14508
14509
14510
14511 for {
14512 x := v.Args[1]
14513 v_0 := v.Args[0]
14514 if v_0.Op != OpARMSRAconst {
14515 break
14516 }
14517 c := v_0.AuxInt
14518 y := v_0.Args[0]
14519 v.reset(OpARMRSBSshiftRA)
14520 v.AuxInt = c
14521 v.AddArg(x)
14522 v.AddArg(y)
14523 return true
14524 }
14525
14526
14527
14528 for {
14529 _ = v.Args[1]
14530 x := v.Args[0]
14531 v_1 := v.Args[1]
14532 if v_1.Op != OpARMSLL {
14533 break
14534 }
14535 z := v_1.Args[1]
14536 y := v_1.Args[0]
14537 v.reset(OpARMSUBSshiftLLreg)
14538 v.AddArg(x)
14539 v.AddArg(y)
14540 v.AddArg(z)
14541 return true
14542 }
14543
14544
14545
14546 for {
14547 x := v.Args[1]
14548 v_0 := v.Args[0]
14549 if v_0.Op != OpARMSLL {
14550 break
14551 }
14552 z := v_0.Args[1]
14553 y := v_0.Args[0]
14554 v.reset(OpARMRSBSshiftLLreg)
14555 v.AddArg(x)
14556 v.AddArg(y)
14557 v.AddArg(z)
14558 return true
14559 }
14560
14561
14562
14563 for {
14564 _ = v.Args[1]
14565 x := v.Args[0]
14566 v_1 := v.Args[1]
14567 if v_1.Op != OpARMSRL {
14568 break
14569 }
14570 z := v_1.Args[1]
14571 y := v_1.Args[0]
14572 v.reset(OpARMSUBSshiftRLreg)
14573 v.AddArg(x)
14574 v.AddArg(y)
14575 v.AddArg(z)
14576 return true
14577 }
14578 return false
14579 }
14580 func rewriteValueARM_OpARMSUBS_10(v *Value) bool {
14581
14582
14583
14584 for {
14585 x := v.Args[1]
14586 v_0 := v.Args[0]
14587 if v_0.Op != OpARMSRL {
14588 break
14589 }
14590 z := v_0.Args[1]
14591 y := v_0.Args[0]
14592 v.reset(OpARMRSBSshiftRLreg)
14593 v.AddArg(x)
14594 v.AddArg(y)
14595 v.AddArg(z)
14596 return true
14597 }
14598
14599
14600
14601 for {
14602 _ = v.Args[1]
14603 x := v.Args[0]
14604 v_1 := v.Args[1]
14605 if v_1.Op != OpARMSRA {
14606 break
14607 }
14608 z := v_1.Args[1]
14609 y := v_1.Args[0]
14610 v.reset(OpARMSUBSshiftRAreg)
14611 v.AddArg(x)
14612 v.AddArg(y)
14613 v.AddArg(z)
14614 return true
14615 }
14616
14617
14618
14619 for {
14620 x := v.Args[1]
14621 v_0 := v.Args[0]
14622 if v_0.Op != OpARMSRA {
14623 break
14624 }
14625 z := v_0.Args[1]
14626 y := v_0.Args[0]
14627 v.reset(OpARMRSBSshiftRAreg)
14628 v.AddArg(x)
14629 v.AddArg(y)
14630 v.AddArg(z)
14631 return true
14632 }
14633 return false
14634 }
14635 func rewriteValueARM_OpARMSUBSshiftLL_0(v *Value) bool {
14636 b := v.Block
14637
14638
14639
14640 for {
14641 d := v.AuxInt
14642 x := v.Args[1]
14643 v_0 := v.Args[0]
14644 if v_0.Op != OpARMMOVWconst {
14645 break
14646 }
14647 c := v_0.AuxInt
14648 v.reset(OpARMRSBSconst)
14649 v.AuxInt = c
14650 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
14651 v0.AuxInt = d
14652 v0.AddArg(x)
14653 v.AddArg(v0)
14654 return true
14655 }
14656
14657
14658
14659 for {
14660 d := v.AuxInt
14661 _ = v.Args[1]
14662 x := v.Args[0]
14663 v_1 := v.Args[1]
14664 if v_1.Op != OpARMMOVWconst {
14665 break
14666 }
14667 c := v_1.AuxInt
14668 v.reset(OpARMSUBSconst)
14669 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
14670 v.AddArg(x)
14671 return true
14672 }
14673 return false
14674 }
14675 func rewriteValueARM_OpARMSUBSshiftLLreg_0(v *Value) bool {
14676 b := v.Block
14677
14678
14679
14680 for {
14681 y := v.Args[2]
14682 v_0 := v.Args[0]
14683 if v_0.Op != OpARMMOVWconst {
14684 break
14685 }
14686 c := v_0.AuxInt
14687 x := v.Args[1]
14688 v.reset(OpARMRSBSconst)
14689 v.AuxInt = c
14690 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
14691 v0.AddArg(x)
14692 v0.AddArg(y)
14693 v.AddArg(v0)
14694 return true
14695 }
14696
14697
14698
14699 for {
14700 _ = v.Args[2]
14701 x := v.Args[0]
14702 y := v.Args[1]
14703 v_2 := v.Args[2]
14704 if v_2.Op != OpARMMOVWconst {
14705 break
14706 }
14707 c := v_2.AuxInt
14708 v.reset(OpARMSUBSshiftLL)
14709 v.AuxInt = c
14710 v.AddArg(x)
14711 v.AddArg(y)
14712 return true
14713 }
14714 return false
14715 }
14716 func rewriteValueARM_OpARMSUBSshiftRA_0(v *Value) bool {
14717 b := v.Block
14718
14719
14720
14721 for {
14722 d := v.AuxInt
14723 x := v.Args[1]
14724 v_0 := v.Args[0]
14725 if v_0.Op != OpARMMOVWconst {
14726 break
14727 }
14728 c := v_0.AuxInt
14729 v.reset(OpARMRSBSconst)
14730 v.AuxInt = c
14731 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
14732 v0.AuxInt = d
14733 v0.AddArg(x)
14734 v.AddArg(v0)
14735 return true
14736 }
14737
14738
14739
14740 for {
14741 d := v.AuxInt
14742 _ = v.Args[1]
14743 x := v.Args[0]
14744 v_1 := v.Args[1]
14745 if v_1.Op != OpARMMOVWconst {
14746 break
14747 }
14748 c := v_1.AuxInt
14749 v.reset(OpARMSUBSconst)
14750 v.AuxInt = int64(int32(c) >> uint64(d))
14751 v.AddArg(x)
14752 return true
14753 }
14754 return false
14755 }
14756 func rewriteValueARM_OpARMSUBSshiftRAreg_0(v *Value) bool {
14757 b := v.Block
14758
14759
14760
14761 for {
14762 y := v.Args[2]
14763 v_0 := v.Args[0]
14764 if v_0.Op != OpARMMOVWconst {
14765 break
14766 }
14767 c := v_0.AuxInt
14768 x := v.Args[1]
14769 v.reset(OpARMRSBSconst)
14770 v.AuxInt = c
14771 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
14772 v0.AddArg(x)
14773 v0.AddArg(y)
14774 v.AddArg(v0)
14775 return true
14776 }
14777
14778
14779
14780 for {
14781 _ = v.Args[2]
14782 x := v.Args[0]
14783 y := v.Args[1]
14784 v_2 := v.Args[2]
14785 if v_2.Op != OpARMMOVWconst {
14786 break
14787 }
14788 c := v_2.AuxInt
14789 v.reset(OpARMSUBSshiftRA)
14790 v.AuxInt = c
14791 v.AddArg(x)
14792 v.AddArg(y)
14793 return true
14794 }
14795 return false
14796 }
14797 func rewriteValueARM_OpARMSUBSshiftRL_0(v *Value) bool {
14798 b := v.Block
14799
14800
14801
14802 for {
14803 d := v.AuxInt
14804 x := v.Args[1]
14805 v_0 := v.Args[0]
14806 if v_0.Op != OpARMMOVWconst {
14807 break
14808 }
14809 c := v_0.AuxInt
14810 v.reset(OpARMRSBSconst)
14811 v.AuxInt = c
14812 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
14813 v0.AuxInt = d
14814 v0.AddArg(x)
14815 v.AddArg(v0)
14816 return true
14817 }
14818
14819
14820
14821 for {
14822 d := v.AuxInt
14823 _ = v.Args[1]
14824 x := v.Args[0]
14825 v_1 := v.Args[1]
14826 if v_1.Op != OpARMMOVWconst {
14827 break
14828 }
14829 c := v_1.AuxInt
14830 v.reset(OpARMSUBSconst)
14831 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
14832 v.AddArg(x)
14833 return true
14834 }
14835 return false
14836 }
14837 func rewriteValueARM_OpARMSUBSshiftRLreg_0(v *Value) bool {
14838 b := v.Block
14839
14840
14841
14842 for {
14843 y := v.Args[2]
14844 v_0 := v.Args[0]
14845 if v_0.Op != OpARMMOVWconst {
14846 break
14847 }
14848 c := v_0.AuxInt
14849 x := v.Args[1]
14850 v.reset(OpARMRSBSconst)
14851 v.AuxInt = c
14852 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
14853 v0.AddArg(x)
14854 v0.AddArg(y)
14855 v.AddArg(v0)
14856 return true
14857 }
14858
14859
14860
14861 for {
14862 _ = v.Args[2]
14863 x := v.Args[0]
14864 y := v.Args[1]
14865 v_2 := v.Args[2]
14866 if v_2.Op != OpARMMOVWconst {
14867 break
14868 }
14869 c := v_2.AuxInt
14870 v.reset(OpARMSUBSshiftRL)
14871 v.AuxInt = c
14872 v.AddArg(x)
14873 v.AddArg(y)
14874 return true
14875 }
14876 return false
14877 }
14878 func rewriteValueARM_OpARMSUBconst_0(v *Value) bool {
14879
14880
14881
14882 for {
14883 off1 := v.AuxInt
14884 v_0 := v.Args[0]
14885 if v_0.Op != OpARMMOVWaddr {
14886 break
14887 }
14888 off2 := v_0.AuxInt
14889 sym := v_0.Aux
14890 ptr := v_0.Args[0]
14891 v.reset(OpARMMOVWaddr)
14892 v.AuxInt = off2 - off1
14893 v.Aux = sym
14894 v.AddArg(ptr)
14895 return true
14896 }
14897
14898
14899
14900 for {
14901 if v.AuxInt != 0 {
14902 break
14903 }
14904 x := v.Args[0]
14905 v.reset(OpCopy)
14906 v.Type = x.Type
14907 v.AddArg(x)
14908 return true
14909 }
14910
14911
14912
14913 for {
14914 c := v.AuxInt
14915 x := v.Args[0]
14916 if !(!isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c))) {
14917 break
14918 }
14919 v.reset(OpARMADDconst)
14920 v.AuxInt = int64(int32(-c))
14921 v.AddArg(x)
14922 return true
14923 }
14924
14925
14926
14927 for {
14928 c := v.AuxInt
14929 x := v.Args[0]
14930 if !(objabi.GOARM == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && uint32(-c) <= 0xffff) {
14931 break
14932 }
14933 v.reset(OpARMANDconst)
14934 v.AuxInt = int64(int32(-c))
14935 v.AddArg(x)
14936 return true
14937 }
14938
14939
14940
14941 for {
14942 c := v.AuxInt
14943 v_0 := v.Args[0]
14944 if v_0.Op != OpARMMOVWconst {
14945 break
14946 }
14947 d := v_0.AuxInt
14948 v.reset(OpARMMOVWconst)
14949 v.AuxInt = int64(int32(d - c))
14950 return true
14951 }
14952
14953
14954
14955 for {
14956 c := v.AuxInt
14957 v_0 := v.Args[0]
14958 if v_0.Op != OpARMSUBconst {
14959 break
14960 }
14961 d := v_0.AuxInt
14962 x := v_0.Args[0]
14963 v.reset(OpARMADDconst)
14964 v.AuxInt = int64(int32(-c - d))
14965 v.AddArg(x)
14966 return true
14967 }
14968
14969
14970
14971 for {
14972 c := v.AuxInt
14973 v_0 := v.Args[0]
14974 if v_0.Op != OpARMADDconst {
14975 break
14976 }
14977 d := v_0.AuxInt
14978 x := v_0.Args[0]
14979 v.reset(OpARMADDconst)
14980 v.AuxInt = int64(int32(-c + d))
14981 v.AddArg(x)
14982 return true
14983 }
14984
14985
14986
14987 for {
14988 c := v.AuxInt
14989 v_0 := v.Args[0]
14990 if v_0.Op != OpARMRSBconst {
14991 break
14992 }
14993 d := v_0.AuxInt
14994 x := v_0.Args[0]
14995 v.reset(OpARMRSBconst)
14996 v.AuxInt = int64(int32(-c + d))
14997 v.AddArg(x)
14998 return true
14999 }
15000 return false
15001 }
15002 func rewriteValueARM_OpARMSUBshiftLL_0(v *Value) bool {
15003 b := v.Block
15004
15005
15006
15007 for {
15008 d := v.AuxInt
15009 x := v.Args[1]
15010 v_0 := v.Args[0]
15011 if v_0.Op != OpARMMOVWconst {
15012 break
15013 }
15014 c := v_0.AuxInt
15015 v.reset(OpARMRSBconst)
15016 v.AuxInt = c
15017 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
15018 v0.AuxInt = d
15019 v0.AddArg(x)
15020 v.AddArg(v0)
15021 return true
15022 }
15023
15024
15025
15026 for {
15027 d := v.AuxInt
15028 _ = v.Args[1]
15029 x := v.Args[0]
15030 v_1 := v.Args[1]
15031 if v_1.Op != OpARMMOVWconst {
15032 break
15033 }
15034 c := v_1.AuxInt
15035 v.reset(OpARMSUBconst)
15036 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
15037 v.AddArg(x)
15038 return true
15039 }
15040
15041
15042
15043 for {
15044 d := v.AuxInt
15045 _ = v.Args[1]
15046 x := v.Args[0]
15047 v_1 := v.Args[1]
15048 if v_1.Op != OpARMSLLconst {
15049 break
15050 }
15051 c := v_1.AuxInt
15052 if x != v_1.Args[0] {
15053 break
15054 }
15055 if !(c == d) {
15056 break
15057 }
15058 v.reset(OpARMMOVWconst)
15059 v.AuxInt = 0
15060 return true
15061 }
15062 return false
15063 }
15064 func rewriteValueARM_OpARMSUBshiftLLreg_0(v *Value) bool {
15065 b := v.Block
15066
15067
15068
15069 for {
15070 y := v.Args[2]
15071 v_0 := v.Args[0]
15072 if v_0.Op != OpARMMOVWconst {
15073 break
15074 }
15075 c := v_0.AuxInt
15076 x := v.Args[1]
15077 v.reset(OpARMRSBconst)
15078 v.AuxInt = c
15079 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
15080 v0.AddArg(x)
15081 v0.AddArg(y)
15082 v.AddArg(v0)
15083 return true
15084 }
15085
15086
15087
15088 for {
15089 _ = v.Args[2]
15090 x := v.Args[0]
15091 y := v.Args[1]
15092 v_2 := v.Args[2]
15093 if v_2.Op != OpARMMOVWconst {
15094 break
15095 }
15096 c := v_2.AuxInt
15097 v.reset(OpARMSUBshiftLL)
15098 v.AuxInt = c
15099 v.AddArg(x)
15100 v.AddArg(y)
15101 return true
15102 }
15103 return false
15104 }
15105 func rewriteValueARM_OpARMSUBshiftRA_0(v *Value) bool {
15106 b := v.Block
15107
15108
15109
15110 for {
15111 d := v.AuxInt
15112 x := v.Args[1]
15113 v_0 := v.Args[0]
15114 if v_0.Op != OpARMMOVWconst {
15115 break
15116 }
15117 c := v_0.AuxInt
15118 v.reset(OpARMRSBconst)
15119 v.AuxInt = c
15120 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
15121 v0.AuxInt = d
15122 v0.AddArg(x)
15123 v.AddArg(v0)
15124 return true
15125 }
15126
15127
15128
15129 for {
15130 d := v.AuxInt
15131 _ = v.Args[1]
15132 x := v.Args[0]
15133 v_1 := v.Args[1]
15134 if v_1.Op != OpARMMOVWconst {
15135 break
15136 }
15137 c := v_1.AuxInt
15138 v.reset(OpARMSUBconst)
15139 v.AuxInt = int64(int32(c) >> uint64(d))
15140 v.AddArg(x)
15141 return true
15142 }
15143
15144
15145
15146 for {
15147 d := v.AuxInt
15148 _ = v.Args[1]
15149 x := v.Args[0]
15150 v_1 := v.Args[1]
15151 if v_1.Op != OpARMSRAconst {
15152 break
15153 }
15154 c := v_1.AuxInt
15155 if x != v_1.Args[0] {
15156 break
15157 }
15158 if !(c == d) {
15159 break
15160 }
15161 v.reset(OpARMMOVWconst)
15162 v.AuxInt = 0
15163 return true
15164 }
15165 return false
15166 }
15167 func rewriteValueARM_OpARMSUBshiftRAreg_0(v *Value) bool {
15168 b := v.Block
15169
15170
15171
15172 for {
15173 y := v.Args[2]
15174 v_0 := v.Args[0]
15175 if v_0.Op != OpARMMOVWconst {
15176 break
15177 }
15178 c := v_0.AuxInt
15179 x := v.Args[1]
15180 v.reset(OpARMRSBconst)
15181 v.AuxInt = c
15182 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
15183 v0.AddArg(x)
15184 v0.AddArg(y)
15185 v.AddArg(v0)
15186 return true
15187 }
15188
15189
15190
15191 for {
15192 _ = v.Args[2]
15193 x := v.Args[0]
15194 y := v.Args[1]
15195 v_2 := v.Args[2]
15196 if v_2.Op != OpARMMOVWconst {
15197 break
15198 }
15199 c := v_2.AuxInt
15200 v.reset(OpARMSUBshiftRA)
15201 v.AuxInt = c
15202 v.AddArg(x)
15203 v.AddArg(y)
15204 return true
15205 }
15206 return false
15207 }
15208 func rewriteValueARM_OpARMSUBshiftRL_0(v *Value) bool {
15209 b := v.Block
15210
15211
15212
15213 for {
15214 d := v.AuxInt
15215 x := v.Args[1]
15216 v_0 := v.Args[0]
15217 if v_0.Op != OpARMMOVWconst {
15218 break
15219 }
15220 c := v_0.AuxInt
15221 v.reset(OpARMRSBconst)
15222 v.AuxInt = c
15223 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
15224 v0.AuxInt = d
15225 v0.AddArg(x)
15226 v.AddArg(v0)
15227 return true
15228 }
15229
15230
15231
15232 for {
15233 d := v.AuxInt
15234 _ = v.Args[1]
15235 x := v.Args[0]
15236 v_1 := v.Args[1]
15237 if v_1.Op != OpARMMOVWconst {
15238 break
15239 }
15240 c := v_1.AuxInt
15241 v.reset(OpARMSUBconst)
15242 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
15243 v.AddArg(x)
15244 return true
15245 }
15246
15247
15248
15249 for {
15250 d := v.AuxInt
15251 _ = v.Args[1]
15252 x := v.Args[0]
15253 v_1 := v.Args[1]
15254 if v_1.Op != OpARMSRLconst {
15255 break
15256 }
15257 c := v_1.AuxInt
15258 if x != v_1.Args[0] {
15259 break
15260 }
15261 if !(c == d) {
15262 break
15263 }
15264 v.reset(OpARMMOVWconst)
15265 v.AuxInt = 0
15266 return true
15267 }
15268 return false
15269 }
15270 func rewriteValueARM_OpARMSUBshiftRLreg_0(v *Value) bool {
15271 b := v.Block
15272
15273
15274
15275 for {
15276 y := v.Args[2]
15277 v_0 := v.Args[0]
15278 if v_0.Op != OpARMMOVWconst {
15279 break
15280 }
15281 c := v_0.AuxInt
15282 x := v.Args[1]
15283 v.reset(OpARMRSBconst)
15284 v.AuxInt = c
15285 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
15286 v0.AddArg(x)
15287 v0.AddArg(y)
15288 v.AddArg(v0)
15289 return true
15290 }
15291
15292
15293
15294 for {
15295 _ = v.Args[2]
15296 x := v.Args[0]
15297 y := v.Args[1]
15298 v_2 := v.Args[2]
15299 if v_2.Op != OpARMMOVWconst {
15300 break
15301 }
15302 c := v_2.AuxInt
15303 v.reset(OpARMSUBshiftRL)
15304 v.AuxInt = c
15305 v.AddArg(x)
15306 v.AddArg(y)
15307 return true
15308 }
15309 return false
15310 }
15311 func rewriteValueARM_OpARMTEQ_0(v *Value) bool {
15312
15313
15314
15315 for {
15316 _ = v.Args[1]
15317 x := v.Args[0]
15318 v_1 := v.Args[1]
15319 if v_1.Op != OpARMMOVWconst {
15320 break
15321 }
15322 c := v_1.AuxInt
15323 v.reset(OpARMTEQconst)
15324 v.AuxInt = c
15325 v.AddArg(x)
15326 return true
15327 }
15328
15329
15330
15331 for {
15332 x := v.Args[1]
15333 v_0 := v.Args[0]
15334 if v_0.Op != OpARMMOVWconst {
15335 break
15336 }
15337 c := v_0.AuxInt
15338 v.reset(OpARMTEQconst)
15339 v.AuxInt = c
15340 v.AddArg(x)
15341 return true
15342 }
15343
15344
15345
15346 for {
15347 _ = v.Args[1]
15348 x := v.Args[0]
15349 v_1 := v.Args[1]
15350 if v_1.Op != OpARMSLLconst {
15351 break
15352 }
15353 c := v_1.AuxInt
15354 y := v_1.Args[0]
15355 v.reset(OpARMTEQshiftLL)
15356 v.AuxInt = c
15357 v.AddArg(x)
15358 v.AddArg(y)
15359 return true
15360 }
15361
15362
15363
15364 for {
15365 x := v.Args[1]
15366 v_0 := v.Args[0]
15367 if v_0.Op != OpARMSLLconst {
15368 break
15369 }
15370 c := v_0.AuxInt
15371 y := v_0.Args[0]
15372 v.reset(OpARMTEQshiftLL)
15373 v.AuxInt = c
15374 v.AddArg(x)
15375 v.AddArg(y)
15376 return true
15377 }
15378
15379
15380
15381 for {
15382 _ = v.Args[1]
15383 x := v.Args[0]
15384 v_1 := v.Args[1]
15385 if v_1.Op != OpARMSRLconst {
15386 break
15387 }
15388 c := v_1.AuxInt
15389 y := v_1.Args[0]
15390 v.reset(OpARMTEQshiftRL)
15391 v.AuxInt = c
15392 v.AddArg(x)
15393 v.AddArg(y)
15394 return true
15395 }
15396
15397
15398
15399 for {
15400 x := v.Args[1]
15401 v_0 := v.Args[0]
15402 if v_0.Op != OpARMSRLconst {
15403 break
15404 }
15405 c := v_0.AuxInt
15406 y := v_0.Args[0]
15407 v.reset(OpARMTEQshiftRL)
15408 v.AuxInt = c
15409 v.AddArg(x)
15410 v.AddArg(y)
15411 return true
15412 }
15413
15414
15415
15416 for {
15417 _ = v.Args[1]
15418 x := v.Args[0]
15419 v_1 := v.Args[1]
15420 if v_1.Op != OpARMSRAconst {
15421 break
15422 }
15423 c := v_1.AuxInt
15424 y := v_1.Args[0]
15425 v.reset(OpARMTEQshiftRA)
15426 v.AuxInt = c
15427 v.AddArg(x)
15428 v.AddArg(y)
15429 return true
15430 }
15431
15432
15433
15434 for {
15435 x := v.Args[1]
15436 v_0 := v.Args[0]
15437 if v_0.Op != OpARMSRAconst {
15438 break
15439 }
15440 c := v_0.AuxInt
15441 y := v_0.Args[0]
15442 v.reset(OpARMTEQshiftRA)
15443 v.AuxInt = c
15444 v.AddArg(x)
15445 v.AddArg(y)
15446 return true
15447 }
15448
15449
15450
15451 for {
15452 _ = v.Args[1]
15453 x := v.Args[0]
15454 v_1 := v.Args[1]
15455 if v_1.Op != OpARMSLL {
15456 break
15457 }
15458 z := v_1.Args[1]
15459 y := v_1.Args[0]
15460 v.reset(OpARMTEQshiftLLreg)
15461 v.AddArg(x)
15462 v.AddArg(y)
15463 v.AddArg(z)
15464 return true
15465 }
15466
15467
15468
15469 for {
15470 x := v.Args[1]
15471 v_0 := v.Args[0]
15472 if v_0.Op != OpARMSLL {
15473 break
15474 }
15475 z := v_0.Args[1]
15476 y := v_0.Args[0]
15477 v.reset(OpARMTEQshiftLLreg)
15478 v.AddArg(x)
15479 v.AddArg(y)
15480 v.AddArg(z)
15481 return true
15482 }
15483 return false
15484 }
15485 func rewriteValueARM_OpARMTEQ_10(v *Value) bool {
15486
15487
15488
15489 for {
15490 _ = v.Args[1]
15491 x := v.Args[0]
15492 v_1 := v.Args[1]
15493 if v_1.Op != OpARMSRL {
15494 break
15495 }
15496 z := v_1.Args[1]
15497 y := v_1.Args[0]
15498 v.reset(OpARMTEQshiftRLreg)
15499 v.AddArg(x)
15500 v.AddArg(y)
15501 v.AddArg(z)
15502 return true
15503 }
15504
15505
15506
15507 for {
15508 x := v.Args[1]
15509 v_0 := v.Args[0]
15510 if v_0.Op != OpARMSRL {
15511 break
15512 }
15513 z := v_0.Args[1]
15514 y := v_0.Args[0]
15515 v.reset(OpARMTEQshiftRLreg)
15516 v.AddArg(x)
15517 v.AddArg(y)
15518 v.AddArg(z)
15519 return true
15520 }
15521
15522
15523
15524 for {
15525 _ = v.Args[1]
15526 x := v.Args[0]
15527 v_1 := v.Args[1]
15528 if v_1.Op != OpARMSRA {
15529 break
15530 }
15531 z := v_1.Args[1]
15532 y := v_1.Args[0]
15533 v.reset(OpARMTEQshiftRAreg)
15534 v.AddArg(x)
15535 v.AddArg(y)
15536 v.AddArg(z)
15537 return true
15538 }
15539
15540
15541
15542 for {
15543 x := v.Args[1]
15544 v_0 := v.Args[0]
15545 if v_0.Op != OpARMSRA {
15546 break
15547 }
15548 z := v_0.Args[1]
15549 y := v_0.Args[0]
15550 v.reset(OpARMTEQshiftRAreg)
15551 v.AddArg(x)
15552 v.AddArg(y)
15553 v.AddArg(z)
15554 return true
15555 }
15556 return false
15557 }
15558 func rewriteValueARM_OpARMTEQconst_0(v *Value) bool {
15559
15560
15561
15562 for {
15563 y := v.AuxInt
15564 v_0 := v.Args[0]
15565 if v_0.Op != OpARMMOVWconst {
15566 break
15567 }
15568 x := v_0.AuxInt
15569 if !(int32(x^y) == 0) {
15570 break
15571 }
15572 v.reset(OpARMFlagEQ)
15573 return true
15574 }
15575
15576
15577
15578 for {
15579 y := v.AuxInt
15580 v_0 := v.Args[0]
15581 if v_0.Op != OpARMMOVWconst {
15582 break
15583 }
15584 x := v_0.AuxInt
15585 if !(int32(x^y) < 0) {
15586 break
15587 }
15588 v.reset(OpARMFlagLT_UGT)
15589 return true
15590 }
15591
15592
15593
15594 for {
15595 y := v.AuxInt
15596 v_0 := v.Args[0]
15597 if v_0.Op != OpARMMOVWconst {
15598 break
15599 }
15600 x := v_0.AuxInt
15601 if !(int32(x^y) > 0) {
15602 break
15603 }
15604 v.reset(OpARMFlagGT_UGT)
15605 return true
15606 }
15607 return false
15608 }
15609 func rewriteValueARM_OpARMTEQshiftLL_0(v *Value) bool {
15610 b := v.Block
15611
15612
15613
15614 for {
15615 d := v.AuxInt
15616 x := v.Args[1]
15617 v_0 := v.Args[0]
15618 if v_0.Op != OpARMMOVWconst {
15619 break
15620 }
15621 c := v_0.AuxInt
15622 v.reset(OpARMTEQconst)
15623 v.AuxInt = c
15624 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
15625 v0.AuxInt = d
15626 v0.AddArg(x)
15627 v.AddArg(v0)
15628 return true
15629 }
15630
15631
15632
15633 for {
15634 d := v.AuxInt
15635 _ = v.Args[1]
15636 x := v.Args[0]
15637 v_1 := v.Args[1]
15638 if v_1.Op != OpARMMOVWconst {
15639 break
15640 }
15641 c := v_1.AuxInt
15642 v.reset(OpARMTEQconst)
15643 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
15644 v.AddArg(x)
15645 return true
15646 }
15647 return false
15648 }
15649 func rewriteValueARM_OpARMTEQshiftLLreg_0(v *Value) bool {
15650 b := v.Block
15651
15652
15653
15654 for {
15655 y := v.Args[2]
15656 v_0 := v.Args[0]
15657 if v_0.Op != OpARMMOVWconst {
15658 break
15659 }
15660 c := v_0.AuxInt
15661 x := v.Args[1]
15662 v.reset(OpARMTEQconst)
15663 v.AuxInt = c
15664 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
15665 v0.AddArg(x)
15666 v0.AddArg(y)
15667 v.AddArg(v0)
15668 return true
15669 }
15670
15671
15672
15673 for {
15674 _ = v.Args[2]
15675 x := v.Args[0]
15676 y := v.Args[1]
15677 v_2 := v.Args[2]
15678 if v_2.Op != OpARMMOVWconst {
15679 break
15680 }
15681 c := v_2.AuxInt
15682 v.reset(OpARMTEQshiftLL)
15683 v.AuxInt = c
15684 v.AddArg(x)
15685 v.AddArg(y)
15686 return true
15687 }
15688 return false
15689 }
15690 func rewriteValueARM_OpARMTEQshiftRA_0(v *Value) bool {
15691 b := v.Block
15692
15693
15694
15695 for {
15696 d := v.AuxInt
15697 x := v.Args[1]
15698 v_0 := v.Args[0]
15699 if v_0.Op != OpARMMOVWconst {
15700 break
15701 }
15702 c := v_0.AuxInt
15703 v.reset(OpARMTEQconst)
15704 v.AuxInt = c
15705 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
15706 v0.AuxInt = d
15707 v0.AddArg(x)
15708 v.AddArg(v0)
15709 return true
15710 }
15711
15712
15713
15714 for {
15715 d := v.AuxInt
15716 _ = v.Args[1]
15717 x := v.Args[0]
15718 v_1 := v.Args[1]
15719 if v_1.Op != OpARMMOVWconst {
15720 break
15721 }
15722 c := v_1.AuxInt
15723 v.reset(OpARMTEQconst)
15724 v.AuxInt = int64(int32(c) >> uint64(d))
15725 v.AddArg(x)
15726 return true
15727 }
15728 return false
15729 }
15730 func rewriteValueARM_OpARMTEQshiftRAreg_0(v *Value) bool {
15731 b := v.Block
15732
15733
15734
15735 for {
15736 y := v.Args[2]
15737 v_0 := v.Args[0]
15738 if v_0.Op != OpARMMOVWconst {
15739 break
15740 }
15741 c := v_0.AuxInt
15742 x := v.Args[1]
15743 v.reset(OpARMTEQconst)
15744 v.AuxInt = c
15745 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
15746 v0.AddArg(x)
15747 v0.AddArg(y)
15748 v.AddArg(v0)
15749 return true
15750 }
15751
15752
15753
15754 for {
15755 _ = v.Args[2]
15756 x := v.Args[0]
15757 y := v.Args[1]
15758 v_2 := v.Args[2]
15759 if v_2.Op != OpARMMOVWconst {
15760 break
15761 }
15762 c := v_2.AuxInt
15763 v.reset(OpARMTEQshiftRA)
15764 v.AuxInt = c
15765 v.AddArg(x)
15766 v.AddArg(y)
15767 return true
15768 }
15769 return false
15770 }
15771 func rewriteValueARM_OpARMTEQshiftRL_0(v *Value) bool {
15772 b := v.Block
15773
15774
15775
15776 for {
15777 d := v.AuxInt
15778 x := v.Args[1]
15779 v_0 := v.Args[0]
15780 if v_0.Op != OpARMMOVWconst {
15781 break
15782 }
15783 c := v_0.AuxInt
15784 v.reset(OpARMTEQconst)
15785 v.AuxInt = c
15786 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
15787 v0.AuxInt = d
15788 v0.AddArg(x)
15789 v.AddArg(v0)
15790 return true
15791 }
15792
15793
15794
15795 for {
15796 d := v.AuxInt
15797 _ = v.Args[1]
15798 x := v.Args[0]
15799 v_1 := v.Args[1]
15800 if v_1.Op != OpARMMOVWconst {
15801 break
15802 }
15803 c := v_1.AuxInt
15804 v.reset(OpARMTEQconst)
15805 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
15806 v.AddArg(x)
15807 return true
15808 }
15809 return false
15810 }
15811 func rewriteValueARM_OpARMTEQshiftRLreg_0(v *Value) bool {
15812 b := v.Block
15813
15814
15815
15816 for {
15817 y := v.Args[2]
15818 v_0 := v.Args[0]
15819 if v_0.Op != OpARMMOVWconst {
15820 break
15821 }
15822 c := v_0.AuxInt
15823 x := v.Args[1]
15824 v.reset(OpARMTEQconst)
15825 v.AuxInt = c
15826 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
15827 v0.AddArg(x)
15828 v0.AddArg(y)
15829 v.AddArg(v0)
15830 return true
15831 }
15832
15833
15834
15835 for {
15836 _ = v.Args[2]
15837 x := v.Args[0]
15838 y := v.Args[1]
15839 v_2 := v.Args[2]
15840 if v_2.Op != OpARMMOVWconst {
15841 break
15842 }
15843 c := v_2.AuxInt
15844 v.reset(OpARMTEQshiftRL)
15845 v.AuxInt = c
15846 v.AddArg(x)
15847 v.AddArg(y)
15848 return true
15849 }
15850 return false
15851 }
15852 func rewriteValueARM_OpARMTST_0(v *Value) bool {
15853
15854
15855
15856 for {
15857 _ = v.Args[1]
15858 x := v.Args[0]
15859 v_1 := v.Args[1]
15860 if v_1.Op != OpARMMOVWconst {
15861 break
15862 }
15863 c := v_1.AuxInt
15864 v.reset(OpARMTSTconst)
15865 v.AuxInt = c
15866 v.AddArg(x)
15867 return true
15868 }
15869
15870
15871
15872 for {
15873 x := v.Args[1]
15874 v_0 := v.Args[0]
15875 if v_0.Op != OpARMMOVWconst {
15876 break
15877 }
15878 c := v_0.AuxInt
15879 v.reset(OpARMTSTconst)
15880 v.AuxInt = c
15881 v.AddArg(x)
15882 return true
15883 }
15884
15885
15886
15887 for {
15888 _ = v.Args[1]
15889 x := v.Args[0]
15890 v_1 := v.Args[1]
15891 if v_1.Op != OpARMSLLconst {
15892 break
15893 }
15894 c := v_1.AuxInt
15895 y := v_1.Args[0]
15896 v.reset(OpARMTSTshiftLL)
15897 v.AuxInt = c
15898 v.AddArg(x)
15899 v.AddArg(y)
15900 return true
15901 }
15902
15903
15904
15905 for {
15906 x := v.Args[1]
15907 v_0 := v.Args[0]
15908 if v_0.Op != OpARMSLLconst {
15909 break
15910 }
15911 c := v_0.AuxInt
15912 y := v_0.Args[0]
15913 v.reset(OpARMTSTshiftLL)
15914 v.AuxInt = c
15915 v.AddArg(x)
15916 v.AddArg(y)
15917 return true
15918 }
15919
15920
15921
15922 for {
15923 _ = v.Args[1]
15924 x := v.Args[0]
15925 v_1 := v.Args[1]
15926 if v_1.Op != OpARMSRLconst {
15927 break
15928 }
15929 c := v_1.AuxInt
15930 y := v_1.Args[0]
15931 v.reset(OpARMTSTshiftRL)
15932 v.AuxInt = c
15933 v.AddArg(x)
15934 v.AddArg(y)
15935 return true
15936 }
15937
15938
15939
15940 for {
15941 x := v.Args[1]
15942 v_0 := v.Args[0]
15943 if v_0.Op != OpARMSRLconst {
15944 break
15945 }
15946 c := v_0.AuxInt
15947 y := v_0.Args[0]
15948 v.reset(OpARMTSTshiftRL)
15949 v.AuxInt = c
15950 v.AddArg(x)
15951 v.AddArg(y)
15952 return true
15953 }
15954
15955
15956
15957 for {
15958 _ = v.Args[1]
15959 x := v.Args[0]
15960 v_1 := v.Args[1]
15961 if v_1.Op != OpARMSRAconst {
15962 break
15963 }
15964 c := v_1.AuxInt
15965 y := v_1.Args[0]
15966 v.reset(OpARMTSTshiftRA)
15967 v.AuxInt = c
15968 v.AddArg(x)
15969 v.AddArg(y)
15970 return true
15971 }
15972
15973
15974
15975 for {
15976 x := v.Args[1]
15977 v_0 := v.Args[0]
15978 if v_0.Op != OpARMSRAconst {
15979 break
15980 }
15981 c := v_0.AuxInt
15982 y := v_0.Args[0]
15983 v.reset(OpARMTSTshiftRA)
15984 v.AuxInt = c
15985 v.AddArg(x)
15986 v.AddArg(y)
15987 return true
15988 }
15989
15990
15991
15992 for {
15993 _ = v.Args[1]
15994 x := v.Args[0]
15995 v_1 := v.Args[1]
15996 if v_1.Op != OpARMSLL {
15997 break
15998 }
15999 z := v_1.Args[1]
16000 y := v_1.Args[0]
16001 v.reset(OpARMTSTshiftLLreg)
16002 v.AddArg(x)
16003 v.AddArg(y)
16004 v.AddArg(z)
16005 return true
16006 }
16007
16008
16009
16010 for {
16011 x := v.Args[1]
16012 v_0 := v.Args[0]
16013 if v_0.Op != OpARMSLL {
16014 break
16015 }
16016 z := v_0.Args[1]
16017 y := v_0.Args[0]
16018 v.reset(OpARMTSTshiftLLreg)
16019 v.AddArg(x)
16020 v.AddArg(y)
16021 v.AddArg(z)
16022 return true
16023 }
16024 return false
16025 }
16026 func rewriteValueARM_OpARMTST_10(v *Value) bool {
16027
16028
16029
16030 for {
16031 _ = v.Args[1]
16032 x := v.Args[0]
16033 v_1 := v.Args[1]
16034 if v_1.Op != OpARMSRL {
16035 break
16036 }
16037 z := v_1.Args[1]
16038 y := v_1.Args[0]
16039 v.reset(OpARMTSTshiftRLreg)
16040 v.AddArg(x)
16041 v.AddArg(y)
16042 v.AddArg(z)
16043 return true
16044 }
16045
16046
16047
16048 for {
16049 x := v.Args[1]
16050 v_0 := v.Args[0]
16051 if v_0.Op != OpARMSRL {
16052 break
16053 }
16054 z := v_0.Args[1]
16055 y := v_0.Args[0]
16056 v.reset(OpARMTSTshiftRLreg)
16057 v.AddArg(x)
16058 v.AddArg(y)
16059 v.AddArg(z)
16060 return true
16061 }
16062
16063
16064
16065 for {
16066 _ = v.Args[1]
16067 x := v.Args[0]
16068 v_1 := v.Args[1]
16069 if v_1.Op != OpARMSRA {
16070 break
16071 }
16072 z := v_1.Args[1]
16073 y := v_1.Args[0]
16074 v.reset(OpARMTSTshiftRAreg)
16075 v.AddArg(x)
16076 v.AddArg(y)
16077 v.AddArg(z)
16078 return true
16079 }
16080
16081
16082
16083 for {
16084 x := v.Args[1]
16085 v_0 := v.Args[0]
16086 if v_0.Op != OpARMSRA {
16087 break
16088 }
16089 z := v_0.Args[1]
16090 y := v_0.Args[0]
16091 v.reset(OpARMTSTshiftRAreg)
16092 v.AddArg(x)
16093 v.AddArg(y)
16094 v.AddArg(z)
16095 return true
16096 }
16097 return false
16098 }
16099 func rewriteValueARM_OpARMTSTconst_0(v *Value) bool {
16100
16101
16102
16103 for {
16104 y := v.AuxInt
16105 v_0 := v.Args[0]
16106 if v_0.Op != OpARMMOVWconst {
16107 break
16108 }
16109 x := v_0.AuxInt
16110 if !(int32(x&y) == 0) {
16111 break
16112 }
16113 v.reset(OpARMFlagEQ)
16114 return true
16115 }
16116
16117
16118
16119 for {
16120 y := v.AuxInt
16121 v_0 := v.Args[0]
16122 if v_0.Op != OpARMMOVWconst {
16123 break
16124 }
16125 x := v_0.AuxInt
16126 if !(int32(x&y) < 0) {
16127 break
16128 }
16129 v.reset(OpARMFlagLT_UGT)
16130 return true
16131 }
16132
16133
16134
16135 for {
16136 y := v.AuxInt
16137 v_0 := v.Args[0]
16138 if v_0.Op != OpARMMOVWconst {
16139 break
16140 }
16141 x := v_0.AuxInt
16142 if !(int32(x&y) > 0) {
16143 break
16144 }
16145 v.reset(OpARMFlagGT_UGT)
16146 return true
16147 }
16148 return false
16149 }
16150 func rewriteValueARM_OpARMTSTshiftLL_0(v *Value) bool {
16151 b := v.Block
16152
16153
16154
16155 for {
16156 d := v.AuxInt
16157 x := v.Args[1]
16158 v_0 := v.Args[0]
16159 if v_0.Op != OpARMMOVWconst {
16160 break
16161 }
16162 c := v_0.AuxInt
16163 v.reset(OpARMTSTconst)
16164 v.AuxInt = c
16165 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
16166 v0.AuxInt = d
16167 v0.AddArg(x)
16168 v.AddArg(v0)
16169 return true
16170 }
16171
16172
16173
16174 for {
16175 d := v.AuxInt
16176 _ = v.Args[1]
16177 x := v.Args[0]
16178 v_1 := v.Args[1]
16179 if v_1.Op != OpARMMOVWconst {
16180 break
16181 }
16182 c := v_1.AuxInt
16183 v.reset(OpARMTSTconst)
16184 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
16185 v.AddArg(x)
16186 return true
16187 }
16188 return false
16189 }
16190 func rewriteValueARM_OpARMTSTshiftLLreg_0(v *Value) bool {
16191 b := v.Block
16192
16193
16194
16195 for {
16196 y := v.Args[2]
16197 v_0 := v.Args[0]
16198 if v_0.Op != OpARMMOVWconst {
16199 break
16200 }
16201 c := v_0.AuxInt
16202 x := v.Args[1]
16203 v.reset(OpARMTSTconst)
16204 v.AuxInt = c
16205 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
16206 v0.AddArg(x)
16207 v0.AddArg(y)
16208 v.AddArg(v0)
16209 return true
16210 }
16211
16212
16213
16214 for {
16215 _ = v.Args[2]
16216 x := v.Args[0]
16217 y := v.Args[1]
16218 v_2 := v.Args[2]
16219 if v_2.Op != OpARMMOVWconst {
16220 break
16221 }
16222 c := v_2.AuxInt
16223 v.reset(OpARMTSTshiftLL)
16224 v.AuxInt = c
16225 v.AddArg(x)
16226 v.AddArg(y)
16227 return true
16228 }
16229 return false
16230 }
16231 func rewriteValueARM_OpARMTSTshiftRA_0(v *Value) bool {
16232 b := v.Block
16233
16234
16235
16236 for {
16237 d := v.AuxInt
16238 x := v.Args[1]
16239 v_0 := v.Args[0]
16240 if v_0.Op != OpARMMOVWconst {
16241 break
16242 }
16243 c := v_0.AuxInt
16244 v.reset(OpARMTSTconst)
16245 v.AuxInt = c
16246 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
16247 v0.AuxInt = d
16248 v0.AddArg(x)
16249 v.AddArg(v0)
16250 return true
16251 }
16252
16253
16254
16255 for {
16256 d := v.AuxInt
16257 _ = v.Args[1]
16258 x := v.Args[0]
16259 v_1 := v.Args[1]
16260 if v_1.Op != OpARMMOVWconst {
16261 break
16262 }
16263 c := v_1.AuxInt
16264 v.reset(OpARMTSTconst)
16265 v.AuxInt = int64(int32(c) >> uint64(d))
16266 v.AddArg(x)
16267 return true
16268 }
16269 return false
16270 }
16271 func rewriteValueARM_OpARMTSTshiftRAreg_0(v *Value) bool {
16272 b := v.Block
16273
16274
16275
16276 for {
16277 y := v.Args[2]
16278 v_0 := v.Args[0]
16279 if v_0.Op != OpARMMOVWconst {
16280 break
16281 }
16282 c := v_0.AuxInt
16283 x := v.Args[1]
16284 v.reset(OpARMTSTconst)
16285 v.AuxInt = c
16286 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
16287 v0.AddArg(x)
16288 v0.AddArg(y)
16289 v.AddArg(v0)
16290 return true
16291 }
16292
16293
16294
16295 for {
16296 _ = v.Args[2]
16297 x := v.Args[0]
16298 y := v.Args[1]
16299 v_2 := v.Args[2]
16300 if v_2.Op != OpARMMOVWconst {
16301 break
16302 }
16303 c := v_2.AuxInt
16304 v.reset(OpARMTSTshiftRA)
16305 v.AuxInt = c
16306 v.AddArg(x)
16307 v.AddArg(y)
16308 return true
16309 }
16310 return false
16311 }
16312 func rewriteValueARM_OpARMTSTshiftRL_0(v *Value) bool {
16313 b := v.Block
16314
16315
16316
16317 for {
16318 d := v.AuxInt
16319 x := v.Args[1]
16320 v_0 := v.Args[0]
16321 if v_0.Op != OpARMMOVWconst {
16322 break
16323 }
16324 c := v_0.AuxInt
16325 v.reset(OpARMTSTconst)
16326 v.AuxInt = c
16327 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
16328 v0.AuxInt = d
16329 v0.AddArg(x)
16330 v.AddArg(v0)
16331 return true
16332 }
16333
16334
16335
16336 for {
16337 d := v.AuxInt
16338 _ = v.Args[1]
16339 x := v.Args[0]
16340 v_1 := v.Args[1]
16341 if v_1.Op != OpARMMOVWconst {
16342 break
16343 }
16344 c := v_1.AuxInt
16345 v.reset(OpARMTSTconst)
16346 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
16347 v.AddArg(x)
16348 return true
16349 }
16350 return false
16351 }
16352 func rewriteValueARM_OpARMTSTshiftRLreg_0(v *Value) bool {
16353 b := v.Block
16354
16355
16356
16357 for {
16358 y := v.Args[2]
16359 v_0 := v.Args[0]
16360 if v_0.Op != OpARMMOVWconst {
16361 break
16362 }
16363 c := v_0.AuxInt
16364 x := v.Args[1]
16365 v.reset(OpARMTSTconst)
16366 v.AuxInt = c
16367 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
16368 v0.AddArg(x)
16369 v0.AddArg(y)
16370 v.AddArg(v0)
16371 return true
16372 }
16373
16374
16375
16376 for {
16377 _ = v.Args[2]
16378 x := v.Args[0]
16379 y := v.Args[1]
16380 v_2 := v.Args[2]
16381 if v_2.Op != OpARMMOVWconst {
16382 break
16383 }
16384 c := v_2.AuxInt
16385 v.reset(OpARMTSTshiftRL)
16386 v.AuxInt = c
16387 v.AddArg(x)
16388 v.AddArg(y)
16389 return true
16390 }
16391 return false
16392 }
16393 func rewriteValueARM_OpARMXOR_0(v *Value) bool {
16394
16395
16396
16397 for {
16398 _ = v.Args[1]
16399 x := v.Args[0]
16400 v_1 := v.Args[1]
16401 if v_1.Op != OpARMMOVWconst {
16402 break
16403 }
16404 c := v_1.AuxInt
16405 v.reset(OpARMXORconst)
16406 v.AuxInt = c
16407 v.AddArg(x)
16408 return true
16409 }
16410
16411
16412
16413 for {
16414 x := v.Args[1]
16415 v_0 := v.Args[0]
16416 if v_0.Op != OpARMMOVWconst {
16417 break
16418 }
16419 c := v_0.AuxInt
16420 v.reset(OpARMXORconst)
16421 v.AuxInt = c
16422 v.AddArg(x)
16423 return true
16424 }
16425
16426
16427
16428 for {
16429 _ = v.Args[1]
16430 x := v.Args[0]
16431 v_1 := v.Args[1]
16432 if v_1.Op != OpARMSLLconst {
16433 break
16434 }
16435 c := v_1.AuxInt
16436 y := v_1.Args[0]
16437 v.reset(OpARMXORshiftLL)
16438 v.AuxInt = c
16439 v.AddArg(x)
16440 v.AddArg(y)
16441 return true
16442 }
16443
16444
16445
16446 for {
16447 x := v.Args[1]
16448 v_0 := v.Args[0]
16449 if v_0.Op != OpARMSLLconst {
16450 break
16451 }
16452 c := v_0.AuxInt
16453 y := v_0.Args[0]
16454 v.reset(OpARMXORshiftLL)
16455 v.AuxInt = c
16456 v.AddArg(x)
16457 v.AddArg(y)
16458 return true
16459 }
16460
16461
16462
16463 for {
16464 _ = v.Args[1]
16465 x := v.Args[0]
16466 v_1 := v.Args[1]
16467 if v_1.Op != OpARMSRLconst {
16468 break
16469 }
16470 c := v_1.AuxInt
16471 y := v_1.Args[0]
16472 v.reset(OpARMXORshiftRL)
16473 v.AuxInt = c
16474 v.AddArg(x)
16475 v.AddArg(y)
16476 return true
16477 }
16478
16479
16480
16481 for {
16482 x := v.Args[1]
16483 v_0 := v.Args[0]
16484 if v_0.Op != OpARMSRLconst {
16485 break
16486 }
16487 c := v_0.AuxInt
16488 y := v_0.Args[0]
16489 v.reset(OpARMXORshiftRL)
16490 v.AuxInt = c
16491 v.AddArg(x)
16492 v.AddArg(y)
16493 return true
16494 }
16495
16496
16497
16498 for {
16499 _ = v.Args[1]
16500 x := v.Args[0]
16501 v_1 := v.Args[1]
16502 if v_1.Op != OpARMSRAconst {
16503 break
16504 }
16505 c := v_1.AuxInt
16506 y := v_1.Args[0]
16507 v.reset(OpARMXORshiftRA)
16508 v.AuxInt = c
16509 v.AddArg(x)
16510 v.AddArg(y)
16511 return true
16512 }
16513
16514
16515
16516 for {
16517 x := v.Args[1]
16518 v_0 := v.Args[0]
16519 if v_0.Op != OpARMSRAconst {
16520 break
16521 }
16522 c := v_0.AuxInt
16523 y := v_0.Args[0]
16524 v.reset(OpARMXORshiftRA)
16525 v.AuxInt = c
16526 v.AddArg(x)
16527 v.AddArg(y)
16528 return true
16529 }
16530
16531
16532
16533 for {
16534 _ = v.Args[1]
16535 x := v.Args[0]
16536 v_1 := v.Args[1]
16537 if v_1.Op != OpARMSRRconst {
16538 break
16539 }
16540 c := v_1.AuxInt
16541 y := v_1.Args[0]
16542 v.reset(OpARMXORshiftRR)
16543 v.AuxInt = c
16544 v.AddArg(x)
16545 v.AddArg(y)
16546 return true
16547 }
16548
16549
16550
16551 for {
16552 x := v.Args[1]
16553 v_0 := v.Args[0]
16554 if v_0.Op != OpARMSRRconst {
16555 break
16556 }
16557 c := v_0.AuxInt
16558 y := v_0.Args[0]
16559 v.reset(OpARMXORshiftRR)
16560 v.AuxInt = c
16561 v.AddArg(x)
16562 v.AddArg(y)
16563 return true
16564 }
16565 return false
16566 }
16567 func rewriteValueARM_OpARMXOR_10(v *Value) bool {
16568
16569
16570
16571 for {
16572 _ = v.Args[1]
16573 x := v.Args[0]
16574 v_1 := v.Args[1]
16575 if v_1.Op != OpARMSLL {
16576 break
16577 }
16578 z := v_1.Args[1]
16579 y := v_1.Args[0]
16580 v.reset(OpARMXORshiftLLreg)
16581 v.AddArg(x)
16582 v.AddArg(y)
16583 v.AddArg(z)
16584 return true
16585 }
16586
16587
16588
16589 for {
16590 x := v.Args[1]
16591 v_0 := v.Args[0]
16592 if v_0.Op != OpARMSLL {
16593 break
16594 }
16595 z := v_0.Args[1]
16596 y := v_0.Args[0]
16597 v.reset(OpARMXORshiftLLreg)
16598 v.AddArg(x)
16599 v.AddArg(y)
16600 v.AddArg(z)
16601 return true
16602 }
16603
16604
16605
16606 for {
16607 _ = v.Args[1]
16608 x := v.Args[0]
16609 v_1 := v.Args[1]
16610 if v_1.Op != OpARMSRL {
16611 break
16612 }
16613 z := v_1.Args[1]
16614 y := v_1.Args[0]
16615 v.reset(OpARMXORshiftRLreg)
16616 v.AddArg(x)
16617 v.AddArg(y)
16618 v.AddArg(z)
16619 return true
16620 }
16621
16622
16623
16624 for {
16625 x := v.Args[1]
16626 v_0 := v.Args[0]
16627 if v_0.Op != OpARMSRL {
16628 break
16629 }
16630 z := v_0.Args[1]
16631 y := v_0.Args[0]
16632 v.reset(OpARMXORshiftRLreg)
16633 v.AddArg(x)
16634 v.AddArg(y)
16635 v.AddArg(z)
16636 return true
16637 }
16638
16639
16640
16641 for {
16642 _ = v.Args[1]
16643 x := v.Args[0]
16644 v_1 := v.Args[1]
16645 if v_1.Op != OpARMSRA {
16646 break
16647 }
16648 z := v_1.Args[1]
16649 y := v_1.Args[0]
16650 v.reset(OpARMXORshiftRAreg)
16651 v.AddArg(x)
16652 v.AddArg(y)
16653 v.AddArg(z)
16654 return true
16655 }
16656
16657
16658
16659 for {
16660 x := v.Args[1]
16661 v_0 := v.Args[0]
16662 if v_0.Op != OpARMSRA {
16663 break
16664 }
16665 z := v_0.Args[1]
16666 y := v_0.Args[0]
16667 v.reset(OpARMXORshiftRAreg)
16668 v.AddArg(x)
16669 v.AddArg(y)
16670 v.AddArg(z)
16671 return true
16672 }
16673
16674
16675
16676 for {
16677 x := v.Args[1]
16678 if x != v.Args[0] {
16679 break
16680 }
16681 v.reset(OpARMMOVWconst)
16682 v.AuxInt = 0
16683 return true
16684 }
16685 return false
16686 }
16687 func rewriteValueARM_OpARMXORconst_0(v *Value) bool {
16688
16689
16690
16691 for {
16692 if v.AuxInt != 0 {
16693 break
16694 }
16695 x := v.Args[0]
16696 v.reset(OpCopy)
16697 v.Type = x.Type
16698 v.AddArg(x)
16699 return true
16700 }
16701
16702
16703
16704 for {
16705 c := v.AuxInt
16706 v_0 := v.Args[0]
16707 if v_0.Op != OpARMMOVWconst {
16708 break
16709 }
16710 d := v_0.AuxInt
16711 v.reset(OpARMMOVWconst)
16712 v.AuxInt = c ^ d
16713 return true
16714 }
16715
16716
16717
16718 for {
16719 c := v.AuxInt
16720 v_0 := v.Args[0]
16721 if v_0.Op != OpARMXORconst {
16722 break
16723 }
16724 d := v_0.AuxInt
16725 x := v_0.Args[0]
16726 v.reset(OpARMXORconst)
16727 v.AuxInt = c ^ d
16728 v.AddArg(x)
16729 return true
16730 }
16731 return false
16732 }
16733 func rewriteValueARM_OpARMXORshiftLL_0(v *Value) bool {
16734 b := v.Block
16735 typ := &b.Func.Config.Types
16736
16737
16738
16739 for {
16740 d := v.AuxInt
16741 x := v.Args[1]
16742 v_0 := v.Args[0]
16743 if v_0.Op != OpARMMOVWconst {
16744 break
16745 }
16746 c := v_0.AuxInt
16747 v.reset(OpARMXORconst)
16748 v.AuxInt = c
16749 v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
16750 v0.AuxInt = d
16751 v0.AddArg(x)
16752 v.AddArg(v0)
16753 return true
16754 }
16755
16756
16757
16758 for {
16759 d := v.AuxInt
16760 _ = v.Args[1]
16761 x := v.Args[0]
16762 v_1 := v.Args[1]
16763 if v_1.Op != OpARMMOVWconst {
16764 break
16765 }
16766 c := v_1.AuxInt
16767 v.reset(OpARMXORconst)
16768 v.AuxInt = int64(int32(uint32(c) << uint64(d)))
16769 v.AddArg(x)
16770 return true
16771 }
16772
16773
16774
16775 for {
16776 c := v.AuxInt
16777 x := v.Args[1]
16778 v_0 := v.Args[0]
16779 if v_0.Op != OpARMSRLconst {
16780 break
16781 }
16782 if v_0.AuxInt != 32-c {
16783 break
16784 }
16785 if x != v_0.Args[0] {
16786 break
16787 }
16788 v.reset(OpARMSRRconst)
16789 v.AuxInt = 32 - c
16790 v.AddArg(x)
16791 return true
16792 }
16793
16794
16795
16796 for {
16797 if v.Type != typ.UInt16 {
16798 break
16799 }
16800 if v.AuxInt != 8 {
16801 break
16802 }
16803 x := v.Args[1]
16804 v_0 := v.Args[0]
16805 if v_0.Op != OpARMBFXU {
16806 break
16807 }
16808 if v_0.Type != typ.UInt16 {
16809 break
16810 }
16811 if v_0.AuxInt != armBFAuxInt(8, 8) {
16812 break
16813 }
16814 if x != v_0.Args[0] {
16815 break
16816 }
16817 v.reset(OpARMREV16)
16818 v.AddArg(x)
16819 return true
16820 }
16821
16822
16823
16824 for {
16825 if v.Type != typ.UInt16 {
16826 break
16827 }
16828 if v.AuxInt != 8 {
16829 break
16830 }
16831 x := v.Args[1]
16832 v_0 := v.Args[0]
16833 if v_0.Op != OpARMSRLconst {
16834 break
16835 }
16836 if v_0.Type != typ.UInt16 {
16837 break
16838 }
16839 if v_0.AuxInt != 24 {
16840 break
16841 }
16842 v_0_0 := v_0.Args[0]
16843 if v_0_0.Op != OpARMSLLconst {
16844 break
16845 }
16846 if v_0_0.AuxInt != 16 {
16847 break
16848 }
16849 if x != v_0_0.Args[0] {
16850 break
16851 }
16852 if !(objabi.GOARM >= 6) {
16853 break
16854 }
16855 v.reset(OpARMREV16)
16856 v.AddArg(x)
16857 return true
16858 }
16859
16860
16861
16862 for {
16863 d := v.AuxInt
16864 _ = v.Args[1]
16865 x := v.Args[0]
16866 v_1 := v.Args[1]
16867 if v_1.Op != OpARMSLLconst {
16868 break
16869 }
16870 c := v_1.AuxInt
16871 if x != v_1.Args[0] {
16872 break
16873 }
16874 if !(c == d) {
16875 break
16876 }
16877 v.reset(OpARMMOVWconst)
16878 v.AuxInt = 0
16879 return true
16880 }
16881 return false
16882 }
16883 func rewriteValueARM_OpARMXORshiftLLreg_0(v *Value) bool {
16884 b := v.Block
16885
16886
16887
16888 for {
16889 y := v.Args[2]
16890 v_0 := v.Args[0]
16891 if v_0.Op != OpARMMOVWconst {
16892 break
16893 }
16894 c := v_0.AuxInt
16895 x := v.Args[1]
16896 v.reset(OpARMXORconst)
16897 v.AuxInt = c
16898 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
16899 v0.AddArg(x)
16900 v0.AddArg(y)
16901 v.AddArg(v0)
16902 return true
16903 }
16904
16905
16906
16907 for {
16908 _ = v.Args[2]
16909 x := v.Args[0]
16910 y := v.Args[1]
16911 v_2 := v.Args[2]
16912 if v_2.Op != OpARMMOVWconst {
16913 break
16914 }
16915 c := v_2.AuxInt
16916 v.reset(OpARMXORshiftLL)
16917 v.AuxInt = c
16918 v.AddArg(x)
16919 v.AddArg(y)
16920 return true
16921 }
16922 return false
16923 }
16924 func rewriteValueARM_OpARMXORshiftRA_0(v *Value) bool {
16925 b := v.Block
16926
16927
16928
16929 for {
16930 d := v.AuxInt
16931 x := v.Args[1]
16932 v_0 := v.Args[0]
16933 if v_0.Op != OpARMMOVWconst {
16934 break
16935 }
16936 c := v_0.AuxInt
16937 v.reset(OpARMXORconst)
16938 v.AuxInt = c
16939 v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
16940 v0.AuxInt = d
16941 v0.AddArg(x)
16942 v.AddArg(v0)
16943 return true
16944 }
16945
16946
16947
16948 for {
16949 d := v.AuxInt
16950 _ = v.Args[1]
16951 x := v.Args[0]
16952 v_1 := v.Args[1]
16953 if v_1.Op != OpARMMOVWconst {
16954 break
16955 }
16956 c := v_1.AuxInt
16957 v.reset(OpARMXORconst)
16958 v.AuxInt = int64(int32(c) >> uint64(d))
16959 v.AddArg(x)
16960 return true
16961 }
16962
16963
16964
16965 for {
16966 d := v.AuxInt
16967 _ = v.Args[1]
16968 x := v.Args[0]
16969 v_1 := v.Args[1]
16970 if v_1.Op != OpARMSRAconst {
16971 break
16972 }
16973 c := v_1.AuxInt
16974 if x != v_1.Args[0] {
16975 break
16976 }
16977 if !(c == d) {
16978 break
16979 }
16980 v.reset(OpARMMOVWconst)
16981 v.AuxInt = 0
16982 return true
16983 }
16984 return false
16985 }
16986 func rewriteValueARM_OpARMXORshiftRAreg_0(v *Value) bool {
16987 b := v.Block
16988
16989
16990
16991 for {
16992 y := v.Args[2]
16993 v_0 := v.Args[0]
16994 if v_0.Op != OpARMMOVWconst {
16995 break
16996 }
16997 c := v_0.AuxInt
16998 x := v.Args[1]
16999 v.reset(OpARMXORconst)
17000 v.AuxInt = c
17001 v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
17002 v0.AddArg(x)
17003 v0.AddArg(y)
17004 v.AddArg(v0)
17005 return true
17006 }
17007
17008
17009
17010 for {
17011 _ = v.Args[2]
17012 x := v.Args[0]
17013 y := v.Args[1]
17014 v_2 := v.Args[2]
17015 if v_2.Op != OpARMMOVWconst {
17016 break
17017 }
17018 c := v_2.AuxInt
17019 v.reset(OpARMXORshiftRA)
17020 v.AuxInt = c
17021 v.AddArg(x)
17022 v.AddArg(y)
17023 return true
17024 }
17025 return false
17026 }
17027 func rewriteValueARM_OpARMXORshiftRL_0(v *Value) bool {
17028 b := v.Block
17029
17030
17031
17032 for {
17033 d := v.AuxInt
17034 x := v.Args[1]
17035 v_0 := v.Args[0]
17036 if v_0.Op != OpARMMOVWconst {
17037 break
17038 }
17039 c := v_0.AuxInt
17040 v.reset(OpARMXORconst)
17041 v.AuxInt = c
17042 v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
17043 v0.AuxInt = d
17044 v0.AddArg(x)
17045 v.AddArg(v0)
17046 return true
17047 }
17048
17049
17050
17051 for {
17052 d := v.AuxInt
17053 _ = v.Args[1]
17054 x := v.Args[0]
17055 v_1 := v.Args[1]
17056 if v_1.Op != OpARMMOVWconst {
17057 break
17058 }
17059 c := v_1.AuxInt
17060 v.reset(OpARMXORconst)
17061 v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
17062 v.AddArg(x)
17063 return true
17064 }
17065
17066
17067
17068 for {
17069 c := v.AuxInt
17070 x := v.Args[1]
17071 v_0 := v.Args[0]
17072 if v_0.Op != OpARMSLLconst {
17073 break
17074 }
17075 if v_0.AuxInt != 32-c {
17076 break
17077 }
17078 if x != v_0.Args[0] {
17079 break
17080 }
17081 v.reset(OpARMSRRconst)
17082 v.AuxInt = c
17083 v.AddArg(x)
17084 return true
17085 }
17086
17087
17088
17089 for {
17090 d := v.AuxInt
17091 _ = v.Args[1]
17092 x := v.Args[0]
17093 v_1 := v.Args[1]
17094 if v_1.Op != OpARMSRLconst {
17095 break
17096 }
17097 c := v_1.AuxInt
17098 if x != v_1.Args[0] {
17099 break
17100 }
17101 if !(c == d) {
17102 break
17103 }
17104 v.reset(OpARMMOVWconst)
17105 v.AuxInt = 0
17106 return true
17107 }
17108 return false
17109 }
17110 func rewriteValueARM_OpARMXORshiftRLreg_0(v *Value) bool {
17111 b := v.Block
17112
17113
17114
17115 for {
17116 y := v.Args[2]
17117 v_0 := v.Args[0]
17118 if v_0.Op != OpARMMOVWconst {
17119 break
17120 }
17121 c := v_0.AuxInt
17122 x := v.Args[1]
17123 v.reset(OpARMXORconst)
17124 v.AuxInt = c
17125 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
17126 v0.AddArg(x)
17127 v0.AddArg(y)
17128 v.AddArg(v0)
17129 return true
17130 }
17131
17132
17133
17134 for {
17135 _ = v.Args[2]
17136 x := v.Args[0]
17137 y := v.Args[1]
17138 v_2 := v.Args[2]
17139 if v_2.Op != OpARMMOVWconst {
17140 break
17141 }
17142 c := v_2.AuxInt
17143 v.reset(OpARMXORshiftRL)
17144 v.AuxInt = c
17145 v.AddArg(x)
17146 v.AddArg(y)
17147 return true
17148 }
17149 return false
17150 }
17151 func rewriteValueARM_OpARMXORshiftRR_0(v *Value) bool {
17152 b := v.Block
17153
17154
17155
17156 for {
17157 d := v.AuxInt
17158 x := v.Args[1]
17159 v_0 := v.Args[0]
17160 if v_0.Op != OpARMMOVWconst {
17161 break
17162 }
17163 c := v_0.AuxInt
17164 v.reset(OpARMXORconst)
17165 v.AuxInt = c
17166 v0 := b.NewValue0(v.Pos, OpARMSRRconst, x.Type)
17167 v0.AuxInt = d
17168 v0.AddArg(x)
17169 v.AddArg(v0)
17170 return true
17171 }
17172
17173
17174
17175 for {
17176 d := v.AuxInt
17177 _ = v.Args[1]
17178 x := v.Args[0]
17179 v_1 := v.Args[1]
17180 if v_1.Op != OpARMMOVWconst {
17181 break
17182 }
17183 c := v_1.AuxInt
17184 v.reset(OpARMXORconst)
17185 v.AuxInt = int64(int32(uint32(c)>>uint64(d) | uint32(c)<<uint64(32-d)))
17186 v.AddArg(x)
17187 return true
17188 }
17189 return false
17190 }
17191 func rewriteValueARM_OpAdd16_0(v *Value) bool {
17192
17193
17194
17195 for {
17196 y := v.Args[1]
17197 x := v.Args[0]
17198 v.reset(OpARMADD)
17199 v.AddArg(x)
17200 v.AddArg(y)
17201 return true
17202 }
17203 }
17204 func rewriteValueARM_OpAdd32_0(v *Value) bool {
17205
17206
17207
17208 for {
17209 y := v.Args[1]
17210 x := v.Args[0]
17211 v.reset(OpARMADD)
17212 v.AddArg(x)
17213 v.AddArg(y)
17214 return true
17215 }
17216 }
17217 func rewriteValueARM_OpAdd32F_0(v *Value) bool {
17218
17219
17220
17221 for {
17222 y := v.Args[1]
17223 x := v.Args[0]
17224 v.reset(OpARMADDF)
17225 v.AddArg(x)
17226 v.AddArg(y)
17227 return true
17228 }
17229 }
17230 func rewriteValueARM_OpAdd32carry_0(v *Value) bool {
17231
17232
17233
17234 for {
17235 y := v.Args[1]
17236 x := v.Args[0]
17237 v.reset(OpARMADDS)
17238 v.AddArg(x)
17239 v.AddArg(y)
17240 return true
17241 }
17242 }
17243 func rewriteValueARM_OpAdd32withcarry_0(v *Value) bool {
17244
17245
17246
17247 for {
17248 c := v.Args[2]
17249 x := v.Args[0]
17250 y := v.Args[1]
17251 v.reset(OpARMADC)
17252 v.AddArg(x)
17253 v.AddArg(y)
17254 v.AddArg(c)
17255 return true
17256 }
17257 }
17258 func rewriteValueARM_OpAdd64F_0(v *Value) bool {
17259
17260
17261
17262 for {
17263 y := v.Args[1]
17264 x := v.Args[0]
17265 v.reset(OpARMADDD)
17266 v.AddArg(x)
17267 v.AddArg(y)
17268 return true
17269 }
17270 }
17271 func rewriteValueARM_OpAdd8_0(v *Value) bool {
17272
17273
17274
17275 for {
17276 y := v.Args[1]
17277 x := v.Args[0]
17278 v.reset(OpARMADD)
17279 v.AddArg(x)
17280 v.AddArg(y)
17281 return true
17282 }
17283 }
17284 func rewriteValueARM_OpAddPtr_0(v *Value) bool {
17285
17286
17287
17288 for {
17289 y := v.Args[1]
17290 x := v.Args[0]
17291 v.reset(OpARMADD)
17292 v.AddArg(x)
17293 v.AddArg(y)
17294 return true
17295 }
17296 }
17297 func rewriteValueARM_OpAddr_0(v *Value) bool {
17298
17299
17300
17301 for {
17302 sym := v.Aux
17303 base := v.Args[0]
17304 v.reset(OpARMMOVWaddr)
17305 v.Aux = sym
17306 v.AddArg(base)
17307 return true
17308 }
17309 }
17310 func rewriteValueARM_OpAnd16_0(v *Value) bool {
17311
17312
17313
17314 for {
17315 y := v.Args[1]
17316 x := v.Args[0]
17317 v.reset(OpARMAND)
17318 v.AddArg(x)
17319 v.AddArg(y)
17320 return true
17321 }
17322 }
17323 func rewriteValueARM_OpAnd32_0(v *Value) bool {
17324
17325
17326
17327 for {
17328 y := v.Args[1]
17329 x := v.Args[0]
17330 v.reset(OpARMAND)
17331 v.AddArg(x)
17332 v.AddArg(y)
17333 return true
17334 }
17335 }
17336 func rewriteValueARM_OpAnd8_0(v *Value) bool {
17337
17338
17339
17340 for {
17341 y := v.Args[1]
17342 x := v.Args[0]
17343 v.reset(OpARMAND)
17344 v.AddArg(x)
17345 v.AddArg(y)
17346 return true
17347 }
17348 }
17349 func rewriteValueARM_OpAndB_0(v *Value) bool {
17350
17351
17352
17353 for {
17354 y := v.Args[1]
17355 x := v.Args[0]
17356 v.reset(OpARMAND)
17357 v.AddArg(x)
17358 v.AddArg(y)
17359 return true
17360 }
17361 }
17362 func rewriteValueARM_OpAvg32u_0(v *Value) bool {
17363 b := v.Block
17364
17365
17366
17367 for {
17368 t := v.Type
17369 y := v.Args[1]
17370 x := v.Args[0]
17371 v.reset(OpARMADD)
17372 v0 := b.NewValue0(v.Pos, OpARMSRLconst, t)
17373 v0.AuxInt = 1
17374 v1 := b.NewValue0(v.Pos, OpARMSUB, t)
17375 v1.AddArg(x)
17376 v1.AddArg(y)
17377 v0.AddArg(v1)
17378 v.AddArg(v0)
17379 v.AddArg(y)
17380 return true
17381 }
17382 }
17383 func rewriteValueARM_OpBitLen32_0(v *Value) bool {
17384 b := v.Block
17385
17386
17387
17388 for {
17389 t := v.Type
17390 x := v.Args[0]
17391 v.reset(OpARMRSBconst)
17392 v.AuxInt = 32
17393 v0 := b.NewValue0(v.Pos, OpARMCLZ, t)
17394 v0.AddArg(x)
17395 v.AddArg(v0)
17396 return true
17397 }
17398 }
17399 func rewriteValueARM_OpBswap32_0(v *Value) bool {
17400 b := v.Block
17401
17402
17403
17404 for {
17405 t := v.Type
17406 x := v.Args[0]
17407 if !(objabi.GOARM == 5) {
17408 break
17409 }
17410 v.reset(OpARMXOR)
17411 v.Type = t
17412 v0 := b.NewValue0(v.Pos, OpARMSRLconst, t)
17413 v0.AuxInt = 8
17414 v1 := b.NewValue0(v.Pos, OpARMBICconst, t)
17415 v1.AuxInt = 0xff0000
17416 v2 := b.NewValue0(v.Pos, OpARMXOR, t)
17417 v2.AddArg(x)
17418 v3 := b.NewValue0(v.Pos, OpARMSRRconst, t)
17419 v3.AuxInt = 16
17420 v3.AddArg(x)
17421 v2.AddArg(v3)
17422 v1.AddArg(v2)
17423 v0.AddArg(v1)
17424 v.AddArg(v0)
17425 v4 := b.NewValue0(v.Pos, OpARMSRRconst, t)
17426 v4.AuxInt = 8
17427 v4.AddArg(x)
17428 v.AddArg(v4)
17429 return true
17430 }
17431
17432
17433
17434 for {
17435 x := v.Args[0]
17436 if !(objabi.GOARM >= 6) {
17437 break
17438 }
17439 v.reset(OpARMREV)
17440 v.AddArg(x)
17441 return true
17442 }
17443 return false
17444 }
17445 func rewriteValueARM_OpClosureCall_0(v *Value) bool {
17446
17447
17448
17449 for {
17450 argwid := v.AuxInt
17451 mem := v.Args[2]
17452 entry := v.Args[0]
17453 closure := v.Args[1]
17454 v.reset(OpARMCALLclosure)
17455 v.AuxInt = argwid
17456 v.AddArg(entry)
17457 v.AddArg(closure)
17458 v.AddArg(mem)
17459 return true
17460 }
17461 }
17462 func rewriteValueARM_OpCom16_0(v *Value) bool {
17463
17464
17465
17466 for {
17467 x := v.Args[0]
17468 v.reset(OpARMMVN)
17469 v.AddArg(x)
17470 return true
17471 }
17472 }
17473 func rewriteValueARM_OpCom32_0(v *Value) bool {
17474
17475
17476
17477 for {
17478 x := v.Args[0]
17479 v.reset(OpARMMVN)
17480 v.AddArg(x)
17481 return true
17482 }
17483 }
17484 func rewriteValueARM_OpCom8_0(v *Value) bool {
17485
17486
17487
17488 for {
17489 x := v.Args[0]
17490 v.reset(OpARMMVN)
17491 v.AddArg(x)
17492 return true
17493 }
17494 }
17495 func rewriteValueARM_OpConst16_0(v *Value) bool {
17496
17497
17498
17499 for {
17500 val := v.AuxInt
17501 v.reset(OpARMMOVWconst)
17502 v.AuxInt = val
17503 return true
17504 }
17505 }
17506 func rewriteValueARM_OpConst32_0(v *Value) bool {
17507
17508
17509
17510 for {
17511 val := v.AuxInt
17512 v.reset(OpARMMOVWconst)
17513 v.AuxInt = val
17514 return true
17515 }
17516 }
17517 func rewriteValueARM_OpConst32F_0(v *Value) bool {
17518
17519
17520
17521 for {
17522 val := v.AuxInt
17523 v.reset(OpARMMOVFconst)
17524 v.AuxInt = val
17525 return true
17526 }
17527 }
17528 func rewriteValueARM_OpConst64F_0(v *Value) bool {
17529
17530
17531
17532 for {
17533 val := v.AuxInt
17534 v.reset(OpARMMOVDconst)
17535 v.AuxInt = val
17536 return true
17537 }
17538 }
17539 func rewriteValueARM_OpConst8_0(v *Value) bool {
17540
17541
17542
17543 for {
17544 val := v.AuxInt
17545 v.reset(OpARMMOVWconst)
17546 v.AuxInt = val
17547 return true
17548 }
17549 }
17550 func rewriteValueARM_OpConstBool_0(v *Value) bool {
17551
17552
17553
17554 for {
17555 b := v.AuxInt
17556 v.reset(OpARMMOVWconst)
17557 v.AuxInt = b
17558 return true
17559 }
17560 }
17561 func rewriteValueARM_OpConstNil_0(v *Value) bool {
17562
17563
17564
17565 for {
17566 v.reset(OpARMMOVWconst)
17567 v.AuxInt = 0
17568 return true
17569 }
17570 }
17571 func rewriteValueARM_OpCtz16_0(v *Value) bool {
17572 b := v.Block
17573 typ := &b.Func.Config.Types
17574
17575
17576
17577 for {
17578 t := v.Type
17579 x := v.Args[0]
17580 if !(objabi.GOARM <= 6) {
17581 break
17582 }
17583 v.reset(OpARMRSBconst)
17584 v.AuxInt = 32
17585 v0 := b.NewValue0(v.Pos, OpARMCLZ, t)
17586 v1 := b.NewValue0(v.Pos, OpARMSUBconst, typ.UInt32)
17587 v1.AuxInt = 1
17588 v2 := b.NewValue0(v.Pos, OpARMAND, typ.UInt32)
17589 v3 := b.NewValue0(v.Pos, OpARMORconst, typ.UInt32)
17590 v3.AuxInt = 0x10000
17591 v3.AddArg(x)
17592 v2.AddArg(v3)
17593 v4 := b.NewValue0(v.Pos, OpARMRSBconst, typ.UInt32)
17594 v4.AuxInt = 0
17595 v5 := b.NewValue0(v.Pos, OpARMORconst, typ.UInt32)
17596 v5.AuxInt = 0x10000
17597 v5.AddArg(x)
17598 v4.AddArg(v5)
17599 v2.AddArg(v4)
17600 v1.AddArg(v2)
17601 v0.AddArg(v1)
17602 v.AddArg(v0)
17603 return true
17604 }
17605
17606
17607
17608 for {
17609 t := v.Type
17610 x := v.Args[0]
17611 if !(objabi.GOARM == 7) {
17612 break
17613 }
17614 v.reset(OpARMCLZ)
17615 v.Type = t
17616 v0 := b.NewValue0(v.Pos, OpARMRBIT, typ.UInt32)
17617 v1 := b.NewValue0(v.Pos, OpARMORconst, typ.UInt32)
17618 v1.AuxInt = 0x10000
17619 v1.AddArg(x)
17620 v0.AddArg(v1)
17621 v.AddArg(v0)
17622 return true
17623 }
17624 return false
17625 }
17626 func rewriteValueARM_OpCtz16NonZero_0(v *Value) bool {
17627
17628
17629
17630 for {
17631 x := v.Args[0]
17632 v.reset(OpCtz32)
17633 v.AddArg(x)
17634 return true
17635 }
17636 }
17637 func rewriteValueARM_OpCtz32_0(v *Value) bool {
17638 b := v.Block
17639
17640
17641
17642 for {
17643 t := v.Type
17644 x := v.Args[0]
17645 if !(objabi.GOARM <= 6) {
17646 break
17647 }
17648 v.reset(OpARMRSBconst)
17649 v.AuxInt = 32
17650 v0 := b.NewValue0(v.Pos, OpARMCLZ, t)
17651 v1 := b.NewValue0(v.Pos, OpARMSUBconst, t)
17652 v1.AuxInt = 1
17653 v2 := b.NewValue0(v.Pos, OpARMAND, t)
17654 v2.AddArg(x)
17655 v3 := b.NewValue0(v.Pos, OpARMRSBconst, t)
17656 v3.AuxInt = 0
17657 v3.AddArg(x)
17658 v2.AddArg(v3)
17659 v1.AddArg(v2)
17660 v0.AddArg(v1)
17661 v.AddArg(v0)
17662 return true
17663 }
17664
17665
17666
17667 for {
17668 t := v.Type
17669 x := v.Args[0]
17670 if !(objabi.GOARM == 7) {
17671 break
17672 }
17673 v.reset(OpARMCLZ)
17674 v.Type = t
17675 v0 := b.NewValue0(v.Pos, OpARMRBIT, t)
17676 v0.AddArg(x)
17677 v.AddArg(v0)
17678 return true
17679 }
17680 return false
17681 }
17682 func rewriteValueARM_OpCtz32NonZero_0(v *Value) bool {
17683
17684
17685
17686 for {
17687 x := v.Args[0]
17688 v.reset(OpCtz32)
17689 v.AddArg(x)
17690 return true
17691 }
17692 }
17693 func rewriteValueARM_OpCtz8_0(v *Value) bool {
17694 b := v.Block
17695 typ := &b.Func.Config.Types
17696
17697
17698
17699 for {
17700 t := v.Type
17701 x := v.Args[0]
17702 if !(objabi.GOARM <= 6) {
17703 break
17704 }
17705 v.reset(OpARMRSBconst)
17706 v.AuxInt = 32
17707 v0 := b.NewValue0(v.Pos, OpARMCLZ, t)
17708 v1 := b.NewValue0(v.Pos, OpARMSUBconst, typ.UInt32)
17709 v1.AuxInt = 1
17710 v2 := b.NewValue0(v.Pos, OpARMAND, typ.UInt32)
17711 v3 := b.NewValue0(v.Pos, OpARMORconst, typ.UInt32)
17712 v3.AuxInt = 0x100
17713 v3.AddArg(x)
17714 v2.AddArg(v3)
17715 v4 := b.NewValue0(v.Pos, OpARMRSBconst, typ.UInt32)
17716 v4.AuxInt = 0
17717 v5 := b.NewValue0(v.Pos, OpARMORconst, typ.UInt32)
17718 v5.AuxInt = 0x100
17719 v5.AddArg(x)
17720 v4.AddArg(v5)
17721 v2.AddArg(v4)
17722 v1.AddArg(v2)
17723 v0.AddArg(v1)
17724 v.AddArg(v0)
17725 return true
17726 }
17727
17728
17729
17730 for {
17731 t := v.Type
17732 x := v.Args[0]
17733 if !(objabi.GOARM == 7) {
17734 break
17735 }
17736 v.reset(OpARMCLZ)
17737 v.Type = t
17738 v0 := b.NewValue0(v.Pos, OpARMRBIT, typ.UInt32)
17739 v1 := b.NewValue0(v.Pos, OpARMORconst, typ.UInt32)
17740 v1.AuxInt = 0x100
17741 v1.AddArg(x)
17742 v0.AddArg(v1)
17743 v.AddArg(v0)
17744 return true
17745 }
17746 return false
17747 }
17748 func rewriteValueARM_OpCtz8NonZero_0(v *Value) bool {
17749
17750
17751
17752 for {
17753 x := v.Args[0]
17754 v.reset(OpCtz32)
17755 v.AddArg(x)
17756 return true
17757 }
17758 }
17759 func rewriteValueARM_OpCvt32Fto32_0(v *Value) bool {
17760
17761
17762
17763 for {
17764 x := v.Args[0]
17765 v.reset(OpARMMOVFW)
17766 v.AddArg(x)
17767 return true
17768 }
17769 }
17770 func rewriteValueARM_OpCvt32Fto32U_0(v *Value) bool {
17771
17772
17773
17774 for {
17775 x := v.Args[0]
17776 v.reset(OpARMMOVFWU)
17777 v.AddArg(x)
17778 return true
17779 }
17780 }
17781 func rewriteValueARM_OpCvt32Fto64F_0(v *Value) bool {
17782
17783
17784
17785 for {
17786 x := v.Args[0]
17787 v.reset(OpARMMOVFD)
17788 v.AddArg(x)
17789 return true
17790 }
17791 }
17792 func rewriteValueARM_OpCvt32Uto32F_0(v *Value) bool {
17793
17794
17795
17796 for {
17797 x := v.Args[0]
17798 v.reset(OpARMMOVWUF)
17799 v.AddArg(x)
17800 return true
17801 }
17802 }
17803 func rewriteValueARM_OpCvt32Uto64F_0(v *Value) bool {
17804
17805
17806
17807 for {
17808 x := v.Args[0]
17809 v.reset(OpARMMOVWUD)
17810 v.AddArg(x)
17811 return true
17812 }
17813 }
17814 func rewriteValueARM_OpCvt32to32F_0(v *Value) bool {
17815
17816
17817
17818 for {
17819 x := v.Args[0]
17820 v.reset(OpARMMOVWF)
17821 v.AddArg(x)
17822 return true
17823 }
17824 }
17825 func rewriteValueARM_OpCvt32to64F_0(v *Value) bool {
17826
17827
17828
17829 for {
17830 x := v.Args[0]
17831 v.reset(OpARMMOVWD)
17832 v.AddArg(x)
17833 return true
17834 }
17835 }
17836 func rewriteValueARM_OpCvt64Fto32_0(v *Value) bool {
17837
17838
17839
17840 for {
17841 x := v.Args[0]
17842 v.reset(OpARMMOVDW)
17843 v.AddArg(x)
17844 return true
17845 }
17846 }
17847 func rewriteValueARM_OpCvt64Fto32F_0(v *Value) bool {
17848
17849
17850
17851 for {
17852 x := v.Args[0]
17853 v.reset(OpARMMOVDF)
17854 v.AddArg(x)
17855 return true
17856 }
17857 }
17858 func rewriteValueARM_OpCvt64Fto32U_0(v *Value) bool {
17859
17860
17861
17862 for {
17863 x := v.Args[0]
17864 v.reset(OpARMMOVDWU)
17865 v.AddArg(x)
17866 return true
17867 }
17868 }
17869 func rewriteValueARM_OpDiv16_0(v *Value) bool {
17870 b := v.Block
17871 typ := &b.Func.Config.Types
17872
17873
17874
17875 for {
17876 y := v.Args[1]
17877 x := v.Args[0]
17878 v.reset(OpDiv32)
17879 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
17880 v0.AddArg(x)
17881 v.AddArg(v0)
17882 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
17883 v1.AddArg(y)
17884 v.AddArg(v1)
17885 return true
17886 }
17887 }
17888 func rewriteValueARM_OpDiv16u_0(v *Value) bool {
17889 b := v.Block
17890 typ := &b.Func.Config.Types
17891
17892
17893
17894 for {
17895 y := v.Args[1]
17896 x := v.Args[0]
17897 v.reset(OpDiv32u)
17898 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
17899 v0.AddArg(x)
17900 v.AddArg(v0)
17901 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
17902 v1.AddArg(y)
17903 v.AddArg(v1)
17904 return true
17905 }
17906 }
17907 func rewriteValueARM_OpDiv32_0(v *Value) bool {
17908 b := v.Block
17909 typ := &b.Func.Config.Types
17910
17911
17912
17913 for {
17914 y := v.Args[1]
17915 x := v.Args[0]
17916 v.reset(OpARMSUB)
17917 v0 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32)
17918 v1 := b.NewValue0(v.Pos, OpSelect0, typ.UInt32)
17919 v2 := b.NewValue0(v.Pos, OpARMCALLudiv, types.NewTuple(typ.UInt32, typ.UInt32))
17920 v3 := b.NewValue0(v.Pos, OpARMSUB, typ.UInt32)
17921 v4 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32)
17922 v4.AddArg(x)
17923 v5 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
17924 v5.AddArg(x)
17925 v4.AddArg(v5)
17926 v3.AddArg(v4)
17927 v6 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
17928 v6.AddArg(x)
17929 v3.AddArg(v6)
17930 v2.AddArg(v3)
17931 v7 := b.NewValue0(v.Pos, OpARMSUB, typ.UInt32)
17932 v8 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32)
17933 v8.AddArg(y)
17934 v9 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
17935 v9.AddArg(y)
17936 v8.AddArg(v9)
17937 v7.AddArg(v8)
17938 v10 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
17939 v10.AddArg(y)
17940 v7.AddArg(v10)
17941 v2.AddArg(v7)
17942 v1.AddArg(v2)
17943 v0.AddArg(v1)
17944 v11 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
17945 v12 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32)
17946 v12.AddArg(x)
17947 v12.AddArg(y)
17948 v11.AddArg(v12)
17949 v0.AddArg(v11)
17950 v.AddArg(v0)
17951 v13 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
17952 v14 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32)
17953 v14.AddArg(x)
17954 v14.AddArg(y)
17955 v13.AddArg(v14)
17956 v.AddArg(v13)
17957 return true
17958 }
17959 }
17960 func rewriteValueARM_OpDiv32F_0(v *Value) bool {
17961
17962
17963
17964 for {
17965 y := v.Args[1]
17966 x := v.Args[0]
17967 v.reset(OpARMDIVF)
17968 v.AddArg(x)
17969 v.AddArg(y)
17970 return true
17971 }
17972 }
17973 func rewriteValueARM_OpDiv32u_0(v *Value) bool {
17974 b := v.Block
17975 typ := &b.Func.Config.Types
17976
17977
17978
17979 for {
17980 y := v.Args[1]
17981 x := v.Args[0]
17982 v.reset(OpSelect0)
17983 v.Type = typ.UInt32
17984 v0 := b.NewValue0(v.Pos, OpARMCALLudiv, types.NewTuple(typ.UInt32, typ.UInt32))
17985 v0.AddArg(x)
17986 v0.AddArg(y)
17987 v.AddArg(v0)
17988 return true
17989 }
17990 }
17991 func rewriteValueARM_OpDiv64F_0(v *Value) bool {
17992
17993
17994
17995 for {
17996 y := v.Args[1]
17997 x := v.Args[0]
17998 v.reset(OpARMDIVD)
17999 v.AddArg(x)
18000 v.AddArg(y)
18001 return true
18002 }
18003 }
18004 func rewriteValueARM_OpDiv8_0(v *Value) bool {
18005 b := v.Block
18006 typ := &b.Func.Config.Types
18007
18008
18009
18010 for {
18011 y := v.Args[1]
18012 x := v.Args[0]
18013 v.reset(OpDiv32)
18014 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
18015 v0.AddArg(x)
18016 v.AddArg(v0)
18017 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
18018 v1.AddArg(y)
18019 v.AddArg(v1)
18020 return true
18021 }
18022 }
18023 func rewriteValueARM_OpDiv8u_0(v *Value) bool {
18024 b := v.Block
18025 typ := &b.Func.Config.Types
18026
18027
18028
18029 for {
18030 y := v.Args[1]
18031 x := v.Args[0]
18032 v.reset(OpDiv32u)
18033 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
18034 v0.AddArg(x)
18035 v.AddArg(v0)
18036 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
18037 v1.AddArg(y)
18038 v.AddArg(v1)
18039 return true
18040 }
18041 }
18042 func rewriteValueARM_OpEq16_0(v *Value) bool {
18043 b := v.Block
18044 typ := &b.Func.Config.Types
18045
18046
18047
18048 for {
18049 y := v.Args[1]
18050 x := v.Args[0]
18051 v.reset(OpARMEqual)
18052 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18053 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
18054 v1.AddArg(x)
18055 v0.AddArg(v1)
18056 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
18057 v2.AddArg(y)
18058 v0.AddArg(v2)
18059 v.AddArg(v0)
18060 return true
18061 }
18062 }
18063 func rewriteValueARM_OpEq32_0(v *Value) bool {
18064 b := v.Block
18065
18066
18067
18068 for {
18069 y := v.Args[1]
18070 x := v.Args[0]
18071 v.reset(OpARMEqual)
18072 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18073 v0.AddArg(x)
18074 v0.AddArg(y)
18075 v.AddArg(v0)
18076 return true
18077 }
18078 }
18079 func rewriteValueARM_OpEq32F_0(v *Value) bool {
18080 b := v.Block
18081
18082
18083
18084 for {
18085 y := v.Args[1]
18086 x := v.Args[0]
18087 v.reset(OpARMEqual)
18088 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags)
18089 v0.AddArg(x)
18090 v0.AddArg(y)
18091 v.AddArg(v0)
18092 return true
18093 }
18094 }
18095 func rewriteValueARM_OpEq64F_0(v *Value) bool {
18096 b := v.Block
18097
18098
18099
18100 for {
18101 y := v.Args[1]
18102 x := v.Args[0]
18103 v.reset(OpARMEqual)
18104 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags)
18105 v0.AddArg(x)
18106 v0.AddArg(y)
18107 v.AddArg(v0)
18108 return true
18109 }
18110 }
18111 func rewriteValueARM_OpEq8_0(v *Value) bool {
18112 b := v.Block
18113 typ := &b.Func.Config.Types
18114
18115
18116
18117 for {
18118 y := v.Args[1]
18119 x := v.Args[0]
18120 v.reset(OpARMEqual)
18121 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18122 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
18123 v1.AddArg(x)
18124 v0.AddArg(v1)
18125 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
18126 v2.AddArg(y)
18127 v0.AddArg(v2)
18128 v.AddArg(v0)
18129 return true
18130 }
18131 }
18132 func rewriteValueARM_OpEqB_0(v *Value) bool {
18133 b := v.Block
18134 typ := &b.Func.Config.Types
18135
18136
18137
18138 for {
18139 y := v.Args[1]
18140 x := v.Args[0]
18141 v.reset(OpARMXORconst)
18142 v.AuxInt = 1
18143 v0 := b.NewValue0(v.Pos, OpARMXOR, typ.Bool)
18144 v0.AddArg(x)
18145 v0.AddArg(y)
18146 v.AddArg(v0)
18147 return true
18148 }
18149 }
18150 func rewriteValueARM_OpEqPtr_0(v *Value) bool {
18151 b := v.Block
18152
18153
18154
18155 for {
18156 y := v.Args[1]
18157 x := v.Args[0]
18158 v.reset(OpARMEqual)
18159 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18160 v0.AddArg(x)
18161 v0.AddArg(y)
18162 v.AddArg(v0)
18163 return true
18164 }
18165 }
18166 func rewriteValueARM_OpGeq16_0(v *Value) bool {
18167 b := v.Block
18168 typ := &b.Func.Config.Types
18169
18170
18171
18172 for {
18173 y := v.Args[1]
18174 x := v.Args[0]
18175 v.reset(OpARMGreaterEqual)
18176 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18177 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
18178 v1.AddArg(x)
18179 v0.AddArg(v1)
18180 v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
18181 v2.AddArg(y)
18182 v0.AddArg(v2)
18183 v.AddArg(v0)
18184 return true
18185 }
18186 }
18187 func rewriteValueARM_OpGeq16U_0(v *Value) bool {
18188 b := v.Block
18189 typ := &b.Func.Config.Types
18190
18191
18192
18193 for {
18194 y := v.Args[1]
18195 x := v.Args[0]
18196 v.reset(OpARMGreaterEqualU)
18197 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18198 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
18199 v1.AddArg(x)
18200 v0.AddArg(v1)
18201 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
18202 v2.AddArg(y)
18203 v0.AddArg(v2)
18204 v.AddArg(v0)
18205 return true
18206 }
18207 }
18208 func rewriteValueARM_OpGeq32_0(v *Value) bool {
18209 b := v.Block
18210
18211
18212
18213 for {
18214 y := v.Args[1]
18215 x := v.Args[0]
18216 v.reset(OpARMGreaterEqual)
18217 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18218 v0.AddArg(x)
18219 v0.AddArg(y)
18220 v.AddArg(v0)
18221 return true
18222 }
18223 }
18224 func rewriteValueARM_OpGeq32F_0(v *Value) bool {
18225 b := v.Block
18226
18227
18228
18229 for {
18230 y := v.Args[1]
18231 x := v.Args[0]
18232 v.reset(OpARMGreaterEqual)
18233 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags)
18234 v0.AddArg(x)
18235 v0.AddArg(y)
18236 v.AddArg(v0)
18237 return true
18238 }
18239 }
18240 func rewriteValueARM_OpGeq32U_0(v *Value) bool {
18241 b := v.Block
18242
18243
18244
18245 for {
18246 y := v.Args[1]
18247 x := v.Args[0]
18248 v.reset(OpARMGreaterEqualU)
18249 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18250 v0.AddArg(x)
18251 v0.AddArg(y)
18252 v.AddArg(v0)
18253 return true
18254 }
18255 }
18256 func rewriteValueARM_OpGeq64F_0(v *Value) bool {
18257 b := v.Block
18258
18259
18260
18261 for {
18262 y := v.Args[1]
18263 x := v.Args[0]
18264 v.reset(OpARMGreaterEqual)
18265 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags)
18266 v0.AddArg(x)
18267 v0.AddArg(y)
18268 v.AddArg(v0)
18269 return true
18270 }
18271 }
18272 func rewriteValueARM_OpGeq8_0(v *Value) bool {
18273 b := v.Block
18274 typ := &b.Func.Config.Types
18275
18276
18277
18278 for {
18279 y := v.Args[1]
18280 x := v.Args[0]
18281 v.reset(OpARMGreaterEqual)
18282 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18283 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
18284 v1.AddArg(x)
18285 v0.AddArg(v1)
18286 v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
18287 v2.AddArg(y)
18288 v0.AddArg(v2)
18289 v.AddArg(v0)
18290 return true
18291 }
18292 }
18293 func rewriteValueARM_OpGeq8U_0(v *Value) bool {
18294 b := v.Block
18295 typ := &b.Func.Config.Types
18296
18297
18298
18299 for {
18300 y := v.Args[1]
18301 x := v.Args[0]
18302 v.reset(OpARMGreaterEqualU)
18303 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18304 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
18305 v1.AddArg(x)
18306 v0.AddArg(v1)
18307 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
18308 v2.AddArg(y)
18309 v0.AddArg(v2)
18310 v.AddArg(v0)
18311 return true
18312 }
18313 }
18314 func rewriteValueARM_OpGetCallerPC_0(v *Value) bool {
18315
18316
18317
18318 for {
18319 v.reset(OpARMLoweredGetCallerPC)
18320 return true
18321 }
18322 }
18323 func rewriteValueARM_OpGetCallerSP_0(v *Value) bool {
18324
18325
18326
18327 for {
18328 v.reset(OpARMLoweredGetCallerSP)
18329 return true
18330 }
18331 }
18332 func rewriteValueARM_OpGetClosurePtr_0(v *Value) bool {
18333
18334
18335
18336 for {
18337 v.reset(OpARMLoweredGetClosurePtr)
18338 return true
18339 }
18340 }
18341 func rewriteValueARM_OpGreater16_0(v *Value) bool {
18342 b := v.Block
18343 typ := &b.Func.Config.Types
18344
18345
18346
18347 for {
18348 y := v.Args[1]
18349 x := v.Args[0]
18350 v.reset(OpARMGreaterThan)
18351 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18352 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
18353 v1.AddArg(x)
18354 v0.AddArg(v1)
18355 v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
18356 v2.AddArg(y)
18357 v0.AddArg(v2)
18358 v.AddArg(v0)
18359 return true
18360 }
18361 }
18362 func rewriteValueARM_OpGreater16U_0(v *Value) bool {
18363 b := v.Block
18364 typ := &b.Func.Config.Types
18365
18366
18367
18368 for {
18369 y := v.Args[1]
18370 x := v.Args[0]
18371 v.reset(OpARMGreaterThanU)
18372 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18373 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
18374 v1.AddArg(x)
18375 v0.AddArg(v1)
18376 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
18377 v2.AddArg(y)
18378 v0.AddArg(v2)
18379 v.AddArg(v0)
18380 return true
18381 }
18382 }
18383 func rewriteValueARM_OpGreater32_0(v *Value) bool {
18384 b := v.Block
18385
18386
18387
18388 for {
18389 y := v.Args[1]
18390 x := v.Args[0]
18391 v.reset(OpARMGreaterThan)
18392 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18393 v0.AddArg(x)
18394 v0.AddArg(y)
18395 v.AddArg(v0)
18396 return true
18397 }
18398 }
18399 func rewriteValueARM_OpGreater32F_0(v *Value) bool {
18400 b := v.Block
18401
18402
18403
18404 for {
18405 y := v.Args[1]
18406 x := v.Args[0]
18407 v.reset(OpARMGreaterThan)
18408 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags)
18409 v0.AddArg(x)
18410 v0.AddArg(y)
18411 v.AddArg(v0)
18412 return true
18413 }
18414 }
18415 func rewriteValueARM_OpGreater32U_0(v *Value) bool {
18416 b := v.Block
18417
18418
18419
18420 for {
18421 y := v.Args[1]
18422 x := v.Args[0]
18423 v.reset(OpARMGreaterThanU)
18424 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18425 v0.AddArg(x)
18426 v0.AddArg(y)
18427 v.AddArg(v0)
18428 return true
18429 }
18430 }
18431 func rewriteValueARM_OpGreater64F_0(v *Value) bool {
18432 b := v.Block
18433
18434
18435
18436 for {
18437 y := v.Args[1]
18438 x := v.Args[0]
18439 v.reset(OpARMGreaterThan)
18440 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags)
18441 v0.AddArg(x)
18442 v0.AddArg(y)
18443 v.AddArg(v0)
18444 return true
18445 }
18446 }
18447 func rewriteValueARM_OpGreater8_0(v *Value) bool {
18448 b := v.Block
18449 typ := &b.Func.Config.Types
18450
18451
18452
18453 for {
18454 y := v.Args[1]
18455 x := v.Args[0]
18456 v.reset(OpARMGreaterThan)
18457 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18458 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
18459 v1.AddArg(x)
18460 v0.AddArg(v1)
18461 v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
18462 v2.AddArg(y)
18463 v0.AddArg(v2)
18464 v.AddArg(v0)
18465 return true
18466 }
18467 }
18468 func rewriteValueARM_OpGreater8U_0(v *Value) bool {
18469 b := v.Block
18470 typ := &b.Func.Config.Types
18471
18472
18473
18474 for {
18475 y := v.Args[1]
18476 x := v.Args[0]
18477 v.reset(OpARMGreaterThanU)
18478 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18479 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
18480 v1.AddArg(x)
18481 v0.AddArg(v1)
18482 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
18483 v2.AddArg(y)
18484 v0.AddArg(v2)
18485 v.AddArg(v0)
18486 return true
18487 }
18488 }
18489 func rewriteValueARM_OpHmul32_0(v *Value) bool {
18490
18491
18492
18493 for {
18494 y := v.Args[1]
18495 x := v.Args[0]
18496 v.reset(OpARMHMUL)
18497 v.AddArg(x)
18498 v.AddArg(y)
18499 return true
18500 }
18501 }
18502 func rewriteValueARM_OpHmul32u_0(v *Value) bool {
18503
18504
18505
18506 for {
18507 y := v.Args[1]
18508 x := v.Args[0]
18509 v.reset(OpARMHMULU)
18510 v.AddArg(x)
18511 v.AddArg(y)
18512 return true
18513 }
18514 }
18515 func rewriteValueARM_OpInterCall_0(v *Value) bool {
18516
18517
18518
18519 for {
18520 argwid := v.AuxInt
18521 mem := v.Args[1]
18522 entry := v.Args[0]
18523 v.reset(OpARMCALLinter)
18524 v.AuxInt = argwid
18525 v.AddArg(entry)
18526 v.AddArg(mem)
18527 return true
18528 }
18529 }
18530 func rewriteValueARM_OpIsInBounds_0(v *Value) bool {
18531 b := v.Block
18532
18533
18534
18535 for {
18536 len := v.Args[1]
18537 idx := v.Args[0]
18538 v.reset(OpARMLessThanU)
18539 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18540 v0.AddArg(idx)
18541 v0.AddArg(len)
18542 v.AddArg(v0)
18543 return true
18544 }
18545 }
18546 func rewriteValueARM_OpIsNonNil_0(v *Value) bool {
18547 b := v.Block
18548
18549
18550
18551 for {
18552 ptr := v.Args[0]
18553 v.reset(OpARMNotEqual)
18554 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
18555 v0.AuxInt = 0
18556 v0.AddArg(ptr)
18557 v.AddArg(v0)
18558 return true
18559 }
18560 }
18561 func rewriteValueARM_OpIsSliceInBounds_0(v *Value) bool {
18562 b := v.Block
18563
18564
18565
18566 for {
18567 len := v.Args[1]
18568 idx := v.Args[0]
18569 v.reset(OpARMLessEqualU)
18570 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18571 v0.AddArg(idx)
18572 v0.AddArg(len)
18573 v.AddArg(v0)
18574 return true
18575 }
18576 }
18577 func rewriteValueARM_OpLeq16_0(v *Value) bool {
18578 b := v.Block
18579 typ := &b.Func.Config.Types
18580
18581
18582
18583 for {
18584 y := v.Args[1]
18585 x := v.Args[0]
18586 v.reset(OpARMLessEqual)
18587 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18588 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
18589 v1.AddArg(x)
18590 v0.AddArg(v1)
18591 v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
18592 v2.AddArg(y)
18593 v0.AddArg(v2)
18594 v.AddArg(v0)
18595 return true
18596 }
18597 }
18598 func rewriteValueARM_OpLeq16U_0(v *Value) bool {
18599 b := v.Block
18600 typ := &b.Func.Config.Types
18601
18602
18603
18604 for {
18605 y := v.Args[1]
18606 x := v.Args[0]
18607 v.reset(OpARMLessEqualU)
18608 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18609 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
18610 v1.AddArg(x)
18611 v0.AddArg(v1)
18612 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
18613 v2.AddArg(y)
18614 v0.AddArg(v2)
18615 v.AddArg(v0)
18616 return true
18617 }
18618 }
18619 func rewriteValueARM_OpLeq32_0(v *Value) bool {
18620 b := v.Block
18621
18622
18623
18624 for {
18625 y := v.Args[1]
18626 x := v.Args[0]
18627 v.reset(OpARMLessEqual)
18628 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18629 v0.AddArg(x)
18630 v0.AddArg(y)
18631 v.AddArg(v0)
18632 return true
18633 }
18634 }
18635 func rewriteValueARM_OpLeq32F_0(v *Value) bool {
18636 b := v.Block
18637
18638
18639
18640 for {
18641 y := v.Args[1]
18642 x := v.Args[0]
18643 v.reset(OpARMGreaterEqual)
18644 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags)
18645 v0.AddArg(y)
18646 v0.AddArg(x)
18647 v.AddArg(v0)
18648 return true
18649 }
18650 }
18651 func rewriteValueARM_OpLeq32U_0(v *Value) bool {
18652 b := v.Block
18653
18654
18655
18656 for {
18657 y := v.Args[1]
18658 x := v.Args[0]
18659 v.reset(OpARMLessEqualU)
18660 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18661 v0.AddArg(x)
18662 v0.AddArg(y)
18663 v.AddArg(v0)
18664 return true
18665 }
18666 }
18667 func rewriteValueARM_OpLeq64F_0(v *Value) bool {
18668 b := v.Block
18669
18670
18671
18672 for {
18673 y := v.Args[1]
18674 x := v.Args[0]
18675 v.reset(OpARMGreaterEqual)
18676 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags)
18677 v0.AddArg(y)
18678 v0.AddArg(x)
18679 v.AddArg(v0)
18680 return true
18681 }
18682 }
18683 func rewriteValueARM_OpLeq8_0(v *Value) bool {
18684 b := v.Block
18685 typ := &b.Func.Config.Types
18686
18687
18688
18689 for {
18690 y := v.Args[1]
18691 x := v.Args[0]
18692 v.reset(OpARMLessEqual)
18693 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18694 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
18695 v1.AddArg(x)
18696 v0.AddArg(v1)
18697 v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
18698 v2.AddArg(y)
18699 v0.AddArg(v2)
18700 v.AddArg(v0)
18701 return true
18702 }
18703 }
18704 func rewriteValueARM_OpLeq8U_0(v *Value) bool {
18705 b := v.Block
18706 typ := &b.Func.Config.Types
18707
18708
18709
18710 for {
18711 y := v.Args[1]
18712 x := v.Args[0]
18713 v.reset(OpARMLessEqualU)
18714 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18715 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
18716 v1.AddArg(x)
18717 v0.AddArg(v1)
18718 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
18719 v2.AddArg(y)
18720 v0.AddArg(v2)
18721 v.AddArg(v0)
18722 return true
18723 }
18724 }
18725 func rewriteValueARM_OpLess16_0(v *Value) bool {
18726 b := v.Block
18727 typ := &b.Func.Config.Types
18728
18729
18730
18731 for {
18732 y := v.Args[1]
18733 x := v.Args[0]
18734 v.reset(OpARMLessThan)
18735 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18736 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
18737 v1.AddArg(x)
18738 v0.AddArg(v1)
18739 v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
18740 v2.AddArg(y)
18741 v0.AddArg(v2)
18742 v.AddArg(v0)
18743 return true
18744 }
18745 }
18746 func rewriteValueARM_OpLess16U_0(v *Value) bool {
18747 b := v.Block
18748 typ := &b.Func.Config.Types
18749
18750
18751
18752 for {
18753 y := v.Args[1]
18754 x := v.Args[0]
18755 v.reset(OpARMLessThanU)
18756 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18757 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
18758 v1.AddArg(x)
18759 v0.AddArg(v1)
18760 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
18761 v2.AddArg(y)
18762 v0.AddArg(v2)
18763 v.AddArg(v0)
18764 return true
18765 }
18766 }
18767 func rewriteValueARM_OpLess32_0(v *Value) bool {
18768 b := v.Block
18769
18770
18771
18772 for {
18773 y := v.Args[1]
18774 x := v.Args[0]
18775 v.reset(OpARMLessThan)
18776 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18777 v0.AddArg(x)
18778 v0.AddArg(y)
18779 v.AddArg(v0)
18780 return true
18781 }
18782 }
18783 func rewriteValueARM_OpLess32F_0(v *Value) bool {
18784 b := v.Block
18785
18786
18787
18788 for {
18789 y := v.Args[1]
18790 x := v.Args[0]
18791 v.reset(OpARMGreaterThan)
18792 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags)
18793 v0.AddArg(y)
18794 v0.AddArg(x)
18795 v.AddArg(v0)
18796 return true
18797 }
18798 }
18799 func rewriteValueARM_OpLess32U_0(v *Value) bool {
18800 b := v.Block
18801
18802
18803
18804 for {
18805 y := v.Args[1]
18806 x := v.Args[0]
18807 v.reset(OpARMLessThanU)
18808 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18809 v0.AddArg(x)
18810 v0.AddArg(y)
18811 v.AddArg(v0)
18812 return true
18813 }
18814 }
18815 func rewriteValueARM_OpLess64F_0(v *Value) bool {
18816 b := v.Block
18817
18818
18819
18820 for {
18821 y := v.Args[1]
18822 x := v.Args[0]
18823 v.reset(OpARMGreaterThan)
18824 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags)
18825 v0.AddArg(y)
18826 v0.AddArg(x)
18827 v.AddArg(v0)
18828 return true
18829 }
18830 }
18831 func rewriteValueARM_OpLess8_0(v *Value) bool {
18832 b := v.Block
18833 typ := &b.Func.Config.Types
18834
18835
18836
18837 for {
18838 y := v.Args[1]
18839 x := v.Args[0]
18840 v.reset(OpARMLessThan)
18841 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18842 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
18843 v1.AddArg(x)
18844 v0.AddArg(v1)
18845 v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
18846 v2.AddArg(y)
18847 v0.AddArg(v2)
18848 v.AddArg(v0)
18849 return true
18850 }
18851 }
18852 func rewriteValueARM_OpLess8U_0(v *Value) bool {
18853 b := v.Block
18854 typ := &b.Func.Config.Types
18855
18856
18857
18858 for {
18859 y := v.Args[1]
18860 x := v.Args[0]
18861 v.reset(OpARMLessThanU)
18862 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
18863 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
18864 v1.AddArg(x)
18865 v0.AddArg(v1)
18866 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
18867 v2.AddArg(y)
18868 v0.AddArg(v2)
18869 v.AddArg(v0)
18870 return true
18871 }
18872 }
18873 func rewriteValueARM_OpLoad_0(v *Value) bool {
18874
18875
18876
18877 for {
18878 t := v.Type
18879 mem := v.Args[1]
18880 ptr := v.Args[0]
18881 if !(t.IsBoolean()) {
18882 break
18883 }
18884 v.reset(OpARMMOVBUload)
18885 v.AddArg(ptr)
18886 v.AddArg(mem)
18887 return true
18888 }
18889
18890
18891
18892 for {
18893 t := v.Type
18894 mem := v.Args[1]
18895 ptr := v.Args[0]
18896 if !(is8BitInt(t) && isSigned(t)) {
18897 break
18898 }
18899 v.reset(OpARMMOVBload)
18900 v.AddArg(ptr)
18901 v.AddArg(mem)
18902 return true
18903 }
18904
18905
18906
18907 for {
18908 t := v.Type
18909 mem := v.Args[1]
18910 ptr := v.Args[0]
18911 if !(is8BitInt(t) && !isSigned(t)) {
18912 break
18913 }
18914 v.reset(OpARMMOVBUload)
18915 v.AddArg(ptr)
18916 v.AddArg(mem)
18917 return true
18918 }
18919
18920
18921
18922 for {
18923 t := v.Type
18924 mem := v.Args[1]
18925 ptr := v.Args[0]
18926 if !(is16BitInt(t) && isSigned(t)) {
18927 break
18928 }
18929 v.reset(OpARMMOVHload)
18930 v.AddArg(ptr)
18931 v.AddArg(mem)
18932 return true
18933 }
18934
18935
18936
18937 for {
18938 t := v.Type
18939 mem := v.Args[1]
18940 ptr := v.Args[0]
18941 if !(is16BitInt(t) && !isSigned(t)) {
18942 break
18943 }
18944 v.reset(OpARMMOVHUload)
18945 v.AddArg(ptr)
18946 v.AddArg(mem)
18947 return true
18948 }
18949
18950
18951
18952 for {
18953 t := v.Type
18954 mem := v.Args[1]
18955 ptr := v.Args[0]
18956 if !(is32BitInt(t) || isPtr(t)) {
18957 break
18958 }
18959 v.reset(OpARMMOVWload)
18960 v.AddArg(ptr)
18961 v.AddArg(mem)
18962 return true
18963 }
18964
18965
18966
18967 for {
18968 t := v.Type
18969 mem := v.Args[1]
18970 ptr := v.Args[0]
18971 if !(is32BitFloat(t)) {
18972 break
18973 }
18974 v.reset(OpARMMOVFload)
18975 v.AddArg(ptr)
18976 v.AddArg(mem)
18977 return true
18978 }
18979
18980
18981
18982 for {
18983 t := v.Type
18984 mem := v.Args[1]
18985 ptr := v.Args[0]
18986 if !(is64BitFloat(t)) {
18987 break
18988 }
18989 v.reset(OpARMMOVDload)
18990 v.AddArg(ptr)
18991 v.AddArg(mem)
18992 return true
18993 }
18994 return false
18995 }
18996 func rewriteValueARM_OpLocalAddr_0(v *Value) bool {
18997
18998
18999
19000 for {
19001 sym := v.Aux
19002 _ = v.Args[1]
19003 base := v.Args[0]
19004 v.reset(OpARMMOVWaddr)
19005 v.Aux = sym
19006 v.AddArg(base)
19007 return true
19008 }
19009 }
19010 func rewriteValueARM_OpLsh16x16_0(v *Value) bool {
19011 b := v.Block
19012 typ := &b.Func.Config.Types
19013
19014
19015
19016 for {
19017 y := v.Args[1]
19018 x := v.Args[0]
19019 v.reset(OpARMCMOVWHSconst)
19020 v.AuxInt = 0
19021 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
19022 v0.AddArg(x)
19023 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
19024 v1.AddArg(y)
19025 v0.AddArg(v1)
19026 v.AddArg(v0)
19027 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
19028 v2.AuxInt = 256
19029 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
19030 v3.AddArg(y)
19031 v2.AddArg(v3)
19032 v.AddArg(v2)
19033 return true
19034 }
19035 }
19036 func rewriteValueARM_OpLsh16x32_0(v *Value) bool {
19037 b := v.Block
19038
19039
19040
19041 for {
19042 y := v.Args[1]
19043 x := v.Args[0]
19044 v.reset(OpARMCMOVWHSconst)
19045 v.AuxInt = 0
19046 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
19047 v0.AddArg(x)
19048 v0.AddArg(y)
19049 v.AddArg(v0)
19050 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
19051 v1.AuxInt = 256
19052 v1.AddArg(y)
19053 v.AddArg(v1)
19054 return true
19055 }
19056 }
19057 func rewriteValueARM_OpLsh16x64_0(v *Value) bool {
19058
19059
19060
19061 for {
19062 _ = v.Args[1]
19063 x := v.Args[0]
19064 v_1 := v.Args[1]
19065 if v_1.Op != OpConst64 {
19066 break
19067 }
19068 c := v_1.AuxInt
19069 if !(uint64(c) < 16) {
19070 break
19071 }
19072 v.reset(OpARMSLLconst)
19073 v.AuxInt = c
19074 v.AddArg(x)
19075 return true
19076 }
19077
19078
19079
19080 for {
19081 _ = v.Args[1]
19082 v_1 := v.Args[1]
19083 if v_1.Op != OpConst64 {
19084 break
19085 }
19086 c := v_1.AuxInt
19087 if !(uint64(c) >= 16) {
19088 break
19089 }
19090 v.reset(OpConst16)
19091 v.AuxInt = 0
19092 return true
19093 }
19094 return false
19095 }
19096 func rewriteValueARM_OpLsh16x8_0(v *Value) bool {
19097 b := v.Block
19098 typ := &b.Func.Config.Types
19099
19100
19101
19102 for {
19103 y := v.Args[1]
19104 x := v.Args[0]
19105 v.reset(OpARMSLL)
19106 v.AddArg(x)
19107 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
19108 v0.AddArg(y)
19109 v.AddArg(v0)
19110 return true
19111 }
19112 }
19113 func rewriteValueARM_OpLsh32x16_0(v *Value) bool {
19114 b := v.Block
19115 typ := &b.Func.Config.Types
19116
19117
19118
19119 for {
19120 y := v.Args[1]
19121 x := v.Args[0]
19122 v.reset(OpARMCMOVWHSconst)
19123 v.AuxInt = 0
19124 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
19125 v0.AddArg(x)
19126 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
19127 v1.AddArg(y)
19128 v0.AddArg(v1)
19129 v.AddArg(v0)
19130 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
19131 v2.AuxInt = 256
19132 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
19133 v3.AddArg(y)
19134 v2.AddArg(v3)
19135 v.AddArg(v2)
19136 return true
19137 }
19138 }
19139 func rewriteValueARM_OpLsh32x32_0(v *Value) bool {
19140 b := v.Block
19141
19142
19143
19144 for {
19145 y := v.Args[1]
19146 x := v.Args[0]
19147 v.reset(OpARMCMOVWHSconst)
19148 v.AuxInt = 0
19149 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
19150 v0.AddArg(x)
19151 v0.AddArg(y)
19152 v.AddArg(v0)
19153 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
19154 v1.AuxInt = 256
19155 v1.AddArg(y)
19156 v.AddArg(v1)
19157 return true
19158 }
19159 }
19160 func rewriteValueARM_OpLsh32x64_0(v *Value) bool {
19161
19162
19163
19164 for {
19165 _ = v.Args[1]
19166 x := v.Args[0]
19167 v_1 := v.Args[1]
19168 if v_1.Op != OpConst64 {
19169 break
19170 }
19171 c := v_1.AuxInt
19172 if !(uint64(c) < 32) {
19173 break
19174 }
19175 v.reset(OpARMSLLconst)
19176 v.AuxInt = c
19177 v.AddArg(x)
19178 return true
19179 }
19180
19181
19182
19183 for {
19184 _ = v.Args[1]
19185 v_1 := v.Args[1]
19186 if v_1.Op != OpConst64 {
19187 break
19188 }
19189 c := v_1.AuxInt
19190 if !(uint64(c) >= 32) {
19191 break
19192 }
19193 v.reset(OpConst32)
19194 v.AuxInt = 0
19195 return true
19196 }
19197 return false
19198 }
19199 func rewriteValueARM_OpLsh32x8_0(v *Value) bool {
19200 b := v.Block
19201 typ := &b.Func.Config.Types
19202
19203
19204
19205 for {
19206 y := v.Args[1]
19207 x := v.Args[0]
19208 v.reset(OpARMSLL)
19209 v.AddArg(x)
19210 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
19211 v0.AddArg(y)
19212 v.AddArg(v0)
19213 return true
19214 }
19215 }
19216 func rewriteValueARM_OpLsh8x16_0(v *Value) bool {
19217 b := v.Block
19218 typ := &b.Func.Config.Types
19219
19220
19221
19222 for {
19223 y := v.Args[1]
19224 x := v.Args[0]
19225 v.reset(OpARMCMOVWHSconst)
19226 v.AuxInt = 0
19227 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
19228 v0.AddArg(x)
19229 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
19230 v1.AddArg(y)
19231 v0.AddArg(v1)
19232 v.AddArg(v0)
19233 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
19234 v2.AuxInt = 256
19235 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
19236 v3.AddArg(y)
19237 v2.AddArg(v3)
19238 v.AddArg(v2)
19239 return true
19240 }
19241 }
19242 func rewriteValueARM_OpLsh8x32_0(v *Value) bool {
19243 b := v.Block
19244
19245
19246
19247 for {
19248 y := v.Args[1]
19249 x := v.Args[0]
19250 v.reset(OpARMCMOVWHSconst)
19251 v.AuxInt = 0
19252 v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
19253 v0.AddArg(x)
19254 v0.AddArg(y)
19255 v.AddArg(v0)
19256 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
19257 v1.AuxInt = 256
19258 v1.AddArg(y)
19259 v.AddArg(v1)
19260 return true
19261 }
19262 }
19263 func rewriteValueARM_OpLsh8x64_0(v *Value) bool {
19264
19265
19266
19267 for {
19268 _ = v.Args[1]
19269 x := v.Args[0]
19270 v_1 := v.Args[1]
19271 if v_1.Op != OpConst64 {
19272 break
19273 }
19274 c := v_1.AuxInt
19275 if !(uint64(c) < 8) {
19276 break
19277 }
19278 v.reset(OpARMSLLconst)
19279 v.AuxInt = c
19280 v.AddArg(x)
19281 return true
19282 }
19283
19284
19285
19286 for {
19287 _ = v.Args[1]
19288 v_1 := v.Args[1]
19289 if v_1.Op != OpConst64 {
19290 break
19291 }
19292 c := v_1.AuxInt
19293 if !(uint64(c) >= 8) {
19294 break
19295 }
19296 v.reset(OpConst8)
19297 v.AuxInt = 0
19298 return true
19299 }
19300 return false
19301 }
19302 func rewriteValueARM_OpLsh8x8_0(v *Value) bool {
19303 b := v.Block
19304 typ := &b.Func.Config.Types
19305
19306
19307
19308 for {
19309 y := v.Args[1]
19310 x := v.Args[0]
19311 v.reset(OpARMSLL)
19312 v.AddArg(x)
19313 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
19314 v0.AddArg(y)
19315 v.AddArg(v0)
19316 return true
19317 }
19318 }
19319 func rewriteValueARM_OpMod16_0(v *Value) bool {
19320 b := v.Block
19321 typ := &b.Func.Config.Types
19322
19323
19324
19325 for {
19326 y := v.Args[1]
19327 x := v.Args[0]
19328 v.reset(OpMod32)
19329 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
19330 v0.AddArg(x)
19331 v.AddArg(v0)
19332 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
19333 v1.AddArg(y)
19334 v.AddArg(v1)
19335 return true
19336 }
19337 }
19338 func rewriteValueARM_OpMod16u_0(v *Value) bool {
19339 b := v.Block
19340 typ := &b.Func.Config.Types
19341
19342
19343
19344 for {
19345 y := v.Args[1]
19346 x := v.Args[0]
19347 v.reset(OpMod32u)
19348 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
19349 v0.AddArg(x)
19350 v.AddArg(v0)
19351 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
19352 v1.AddArg(y)
19353 v.AddArg(v1)
19354 return true
19355 }
19356 }
19357 func rewriteValueARM_OpMod32_0(v *Value) bool {
19358 b := v.Block
19359 typ := &b.Func.Config.Types
19360
19361
19362
19363 for {
19364 y := v.Args[1]
19365 x := v.Args[0]
19366 v.reset(OpARMSUB)
19367 v0 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32)
19368 v1 := b.NewValue0(v.Pos, OpSelect1, typ.UInt32)
19369 v2 := b.NewValue0(v.Pos, OpARMCALLudiv, types.NewTuple(typ.UInt32, typ.UInt32))
19370 v3 := b.NewValue0(v.Pos, OpARMSUB, typ.UInt32)
19371 v4 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32)
19372 v4.AddArg(x)
19373 v5 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
19374 v5.AddArg(x)
19375 v4.AddArg(v5)
19376 v3.AddArg(v4)
19377 v6 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
19378 v6.AddArg(x)
19379 v3.AddArg(v6)
19380 v2.AddArg(v3)
19381 v7 := b.NewValue0(v.Pos, OpARMSUB, typ.UInt32)
19382 v8 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32)
19383 v8.AddArg(y)
19384 v9 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
19385 v9.AddArg(y)
19386 v8.AddArg(v9)
19387 v7.AddArg(v8)
19388 v10 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
19389 v10.AddArg(y)
19390 v7.AddArg(v10)
19391 v2.AddArg(v7)
19392 v1.AddArg(v2)
19393 v0.AddArg(v1)
19394 v11 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
19395 v11.AddArg(x)
19396 v0.AddArg(v11)
19397 v.AddArg(v0)
19398 v12 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
19399 v12.AddArg(x)
19400 v.AddArg(v12)
19401 return true
19402 }
19403 }
19404 func rewriteValueARM_OpMod32u_0(v *Value) bool {
19405 b := v.Block
19406 typ := &b.Func.Config.Types
19407
19408
19409
19410 for {
19411 y := v.Args[1]
19412 x := v.Args[0]
19413 v.reset(OpSelect1)
19414 v.Type = typ.UInt32
19415 v0 := b.NewValue0(v.Pos, OpARMCALLudiv, types.NewTuple(typ.UInt32, typ.UInt32))
19416 v0.AddArg(x)
19417 v0.AddArg(y)
19418 v.AddArg(v0)
19419 return true
19420 }
19421 }
19422 func rewriteValueARM_OpMod8_0(v *Value) bool {
19423 b := v.Block
19424 typ := &b.Func.Config.Types
19425
19426
19427
19428 for {
19429 y := v.Args[1]
19430 x := v.Args[0]
19431 v.reset(OpMod32)
19432 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
19433 v0.AddArg(x)
19434 v.AddArg(v0)
19435 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
19436 v1.AddArg(y)
19437 v.AddArg(v1)
19438 return true
19439 }
19440 }
19441 func rewriteValueARM_OpMod8u_0(v *Value) bool {
19442 b := v.Block
19443 typ := &b.Func.Config.Types
19444
19445
19446
19447 for {
19448 y := v.Args[1]
19449 x := v.Args[0]
19450 v.reset(OpMod32u)
19451 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
19452 v0.AddArg(x)
19453 v.AddArg(v0)
19454 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
19455 v1.AddArg(y)
19456 v.AddArg(v1)
19457 return true
19458 }
19459 }
19460 func rewriteValueARM_OpMove_0(v *Value) bool {
19461 b := v.Block
19462 config := b.Func.Config
19463 typ := &b.Func.Config.Types
19464
19465
19466
19467 for {
19468 if v.AuxInt != 0 {
19469 break
19470 }
19471 mem := v.Args[2]
19472 v.reset(OpCopy)
19473 v.Type = mem.Type
19474 v.AddArg(mem)
19475 return true
19476 }
19477
19478
19479
19480 for {
19481 if v.AuxInt != 1 {
19482 break
19483 }
19484 mem := v.Args[2]
19485 dst := v.Args[0]
19486 src := v.Args[1]
19487 v.reset(OpARMMOVBstore)
19488 v.AddArg(dst)
19489 v0 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
19490 v0.AddArg(src)
19491 v0.AddArg(mem)
19492 v.AddArg(v0)
19493 v.AddArg(mem)
19494 return true
19495 }
19496
19497
19498
19499 for {
19500 if v.AuxInt != 2 {
19501 break
19502 }
19503 t := v.Aux
19504 mem := v.Args[2]
19505 dst := v.Args[0]
19506 src := v.Args[1]
19507 if !(t.(*types.Type).Alignment()%2 == 0) {
19508 break
19509 }
19510 v.reset(OpARMMOVHstore)
19511 v.AddArg(dst)
19512 v0 := b.NewValue0(v.Pos, OpARMMOVHUload, typ.UInt16)
19513 v0.AddArg(src)
19514 v0.AddArg(mem)
19515 v.AddArg(v0)
19516 v.AddArg(mem)
19517 return true
19518 }
19519
19520
19521
19522 for {
19523 if v.AuxInt != 2 {
19524 break
19525 }
19526 mem := v.Args[2]
19527 dst := v.Args[0]
19528 src := v.Args[1]
19529 v.reset(OpARMMOVBstore)
19530 v.AuxInt = 1
19531 v.AddArg(dst)
19532 v0 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
19533 v0.AuxInt = 1
19534 v0.AddArg(src)
19535 v0.AddArg(mem)
19536 v.AddArg(v0)
19537 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
19538 v1.AddArg(dst)
19539 v2 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
19540 v2.AddArg(src)
19541 v2.AddArg(mem)
19542 v1.AddArg(v2)
19543 v1.AddArg(mem)
19544 v.AddArg(v1)
19545 return true
19546 }
19547
19548
19549
19550 for {
19551 if v.AuxInt != 4 {
19552 break
19553 }
19554 t := v.Aux
19555 mem := v.Args[2]
19556 dst := v.Args[0]
19557 src := v.Args[1]
19558 if !(t.(*types.Type).Alignment()%4 == 0) {
19559 break
19560 }
19561 v.reset(OpARMMOVWstore)
19562 v.AddArg(dst)
19563 v0 := b.NewValue0(v.Pos, OpARMMOVWload, typ.UInt32)
19564 v0.AddArg(src)
19565 v0.AddArg(mem)
19566 v.AddArg(v0)
19567 v.AddArg(mem)
19568 return true
19569 }
19570
19571
19572
19573 for {
19574 if v.AuxInt != 4 {
19575 break
19576 }
19577 t := v.Aux
19578 mem := v.Args[2]
19579 dst := v.Args[0]
19580 src := v.Args[1]
19581 if !(t.(*types.Type).Alignment()%2 == 0) {
19582 break
19583 }
19584 v.reset(OpARMMOVHstore)
19585 v.AuxInt = 2
19586 v.AddArg(dst)
19587 v0 := b.NewValue0(v.Pos, OpARMMOVHUload, typ.UInt16)
19588 v0.AuxInt = 2
19589 v0.AddArg(src)
19590 v0.AddArg(mem)
19591 v.AddArg(v0)
19592 v1 := b.NewValue0(v.Pos, OpARMMOVHstore, types.TypeMem)
19593 v1.AddArg(dst)
19594 v2 := b.NewValue0(v.Pos, OpARMMOVHUload, typ.UInt16)
19595 v2.AddArg(src)
19596 v2.AddArg(mem)
19597 v1.AddArg(v2)
19598 v1.AddArg(mem)
19599 v.AddArg(v1)
19600 return true
19601 }
19602
19603
19604
19605 for {
19606 if v.AuxInt != 4 {
19607 break
19608 }
19609 mem := v.Args[2]
19610 dst := v.Args[0]
19611 src := v.Args[1]
19612 v.reset(OpARMMOVBstore)
19613 v.AuxInt = 3
19614 v.AddArg(dst)
19615 v0 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
19616 v0.AuxInt = 3
19617 v0.AddArg(src)
19618 v0.AddArg(mem)
19619 v.AddArg(v0)
19620 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
19621 v1.AuxInt = 2
19622 v1.AddArg(dst)
19623 v2 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
19624 v2.AuxInt = 2
19625 v2.AddArg(src)
19626 v2.AddArg(mem)
19627 v1.AddArg(v2)
19628 v3 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
19629 v3.AuxInt = 1
19630 v3.AddArg(dst)
19631 v4 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
19632 v4.AuxInt = 1
19633 v4.AddArg(src)
19634 v4.AddArg(mem)
19635 v3.AddArg(v4)
19636 v5 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
19637 v5.AddArg(dst)
19638 v6 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
19639 v6.AddArg(src)
19640 v6.AddArg(mem)
19641 v5.AddArg(v6)
19642 v5.AddArg(mem)
19643 v3.AddArg(v5)
19644 v1.AddArg(v3)
19645 v.AddArg(v1)
19646 return true
19647 }
19648
19649
19650
19651 for {
19652 if v.AuxInt != 3 {
19653 break
19654 }
19655 mem := v.Args[2]
19656 dst := v.Args[0]
19657 src := v.Args[1]
19658 v.reset(OpARMMOVBstore)
19659 v.AuxInt = 2
19660 v.AddArg(dst)
19661 v0 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
19662 v0.AuxInt = 2
19663 v0.AddArg(src)
19664 v0.AddArg(mem)
19665 v.AddArg(v0)
19666 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
19667 v1.AuxInt = 1
19668 v1.AddArg(dst)
19669 v2 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
19670 v2.AuxInt = 1
19671 v2.AddArg(src)
19672 v2.AddArg(mem)
19673 v1.AddArg(v2)
19674 v3 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
19675 v3.AddArg(dst)
19676 v4 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
19677 v4.AddArg(src)
19678 v4.AddArg(mem)
19679 v3.AddArg(v4)
19680 v3.AddArg(mem)
19681 v1.AddArg(v3)
19682 v.AddArg(v1)
19683 return true
19684 }
19685
19686
19687
19688 for {
19689 s := v.AuxInt
19690 t := v.Aux
19691 mem := v.Args[2]
19692 dst := v.Args[0]
19693 src := v.Args[1]
19694 if !(s%4 == 0 && s > 4 && s <= 512 && t.(*types.Type).Alignment()%4 == 0 && !config.noDuffDevice) {
19695 break
19696 }
19697 v.reset(OpARMDUFFCOPY)
19698 v.AuxInt = 8 * (128 - s/4)
19699 v.AddArg(dst)
19700 v.AddArg(src)
19701 v.AddArg(mem)
19702 return true
19703 }
19704
19705
19706
19707 for {
19708 s := v.AuxInt
19709 t := v.Aux
19710 mem := v.Args[2]
19711 dst := v.Args[0]
19712 src := v.Args[1]
19713 if !((s > 512 || config.noDuffDevice) || t.(*types.Type).Alignment()%4 != 0) {
19714 break
19715 }
19716 v.reset(OpARMLoweredMove)
19717 v.AuxInt = t.(*types.Type).Alignment()
19718 v.AddArg(dst)
19719 v.AddArg(src)
19720 v0 := b.NewValue0(v.Pos, OpARMADDconst, src.Type)
19721 v0.AuxInt = s - moveSize(t.(*types.Type).Alignment(), config)
19722 v0.AddArg(src)
19723 v.AddArg(v0)
19724 v.AddArg(mem)
19725 return true
19726 }
19727 return false
19728 }
19729 func rewriteValueARM_OpMul16_0(v *Value) bool {
19730
19731
19732
19733 for {
19734 y := v.Args[1]
19735 x := v.Args[0]
19736 v.reset(OpARMMUL)
19737 v.AddArg(x)
19738 v.AddArg(y)
19739 return true
19740 }
19741 }
19742 func rewriteValueARM_OpMul32_0(v *Value) bool {
19743
19744
19745
19746 for {
19747 y := v.Args[1]
19748 x := v.Args[0]
19749 v.reset(OpARMMUL)
19750 v.AddArg(x)
19751 v.AddArg(y)
19752 return true
19753 }
19754 }
19755 func rewriteValueARM_OpMul32F_0(v *Value) bool {
19756
19757
19758
19759 for {
19760 y := v.Args[1]
19761 x := v.Args[0]
19762 v.reset(OpARMMULF)
19763 v.AddArg(x)
19764 v.AddArg(y)
19765 return true
19766 }
19767 }
19768 func rewriteValueARM_OpMul32uhilo_0(v *Value) bool {
19769
19770
19771
19772 for {
19773 y := v.Args[1]
19774 x := v.Args[0]
19775 v.reset(OpARMMULLU)
19776 v.AddArg(x)
19777 v.AddArg(y)
19778 return true
19779 }
19780 }
19781 func rewriteValueARM_OpMul64F_0(v *Value) bool {
19782
19783
19784
19785 for {
19786 y := v.Args[1]
19787 x := v.Args[0]
19788 v.reset(OpARMMULD)
19789 v.AddArg(x)
19790 v.AddArg(y)
19791 return true
19792 }
19793 }
19794 func rewriteValueARM_OpMul8_0(v *Value) bool {
19795
19796
19797
19798 for {
19799 y := v.Args[1]
19800 x := v.Args[0]
19801 v.reset(OpARMMUL)
19802 v.AddArg(x)
19803 v.AddArg(y)
19804 return true
19805 }
19806 }
19807 func rewriteValueARM_OpNeg16_0(v *Value) bool {
19808
19809
19810
19811 for {
19812 x := v.Args[0]
19813 v.reset(OpARMRSBconst)
19814 v.AuxInt = 0
19815 v.AddArg(x)
19816 return true
19817 }
19818 }
19819 func rewriteValueARM_OpNeg32_0(v *Value) bool {
19820
19821
19822
19823 for {
19824 x := v.Args[0]
19825 v.reset(OpARMRSBconst)
19826 v.AuxInt = 0
19827 v.AddArg(x)
19828 return true
19829 }
19830 }
19831 func rewriteValueARM_OpNeg32F_0(v *Value) bool {
19832
19833
19834
19835 for {
19836 x := v.Args[0]
19837 v.reset(OpARMNEGF)
19838 v.AddArg(x)
19839 return true
19840 }
19841 }
19842 func rewriteValueARM_OpNeg64F_0(v *Value) bool {
19843
19844
19845
19846 for {
19847 x := v.Args[0]
19848 v.reset(OpARMNEGD)
19849 v.AddArg(x)
19850 return true
19851 }
19852 }
19853 func rewriteValueARM_OpNeg8_0(v *Value) bool {
19854
19855
19856
19857 for {
19858 x := v.Args[0]
19859 v.reset(OpARMRSBconst)
19860 v.AuxInt = 0
19861 v.AddArg(x)
19862 return true
19863 }
19864 }
19865 func rewriteValueARM_OpNeq16_0(v *Value) bool {
19866 b := v.Block
19867 typ := &b.Func.Config.Types
19868
19869
19870
19871 for {
19872 y := v.Args[1]
19873 x := v.Args[0]
19874 v.reset(OpARMNotEqual)
19875 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
19876 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
19877 v1.AddArg(x)
19878 v0.AddArg(v1)
19879 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
19880 v2.AddArg(y)
19881 v0.AddArg(v2)
19882 v.AddArg(v0)
19883 return true
19884 }
19885 }
19886 func rewriteValueARM_OpNeq32_0(v *Value) bool {
19887 b := v.Block
19888
19889
19890
19891 for {
19892 y := v.Args[1]
19893 x := v.Args[0]
19894 v.reset(OpARMNotEqual)
19895 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
19896 v0.AddArg(x)
19897 v0.AddArg(y)
19898 v.AddArg(v0)
19899 return true
19900 }
19901 }
19902 func rewriteValueARM_OpNeq32F_0(v *Value) bool {
19903 b := v.Block
19904
19905
19906
19907 for {
19908 y := v.Args[1]
19909 x := v.Args[0]
19910 v.reset(OpARMNotEqual)
19911 v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags)
19912 v0.AddArg(x)
19913 v0.AddArg(y)
19914 v.AddArg(v0)
19915 return true
19916 }
19917 }
19918 func rewriteValueARM_OpNeq64F_0(v *Value) bool {
19919 b := v.Block
19920
19921
19922
19923 for {
19924 y := v.Args[1]
19925 x := v.Args[0]
19926 v.reset(OpARMNotEqual)
19927 v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags)
19928 v0.AddArg(x)
19929 v0.AddArg(y)
19930 v.AddArg(v0)
19931 return true
19932 }
19933 }
19934 func rewriteValueARM_OpNeq8_0(v *Value) bool {
19935 b := v.Block
19936 typ := &b.Func.Config.Types
19937
19938
19939
19940 for {
19941 y := v.Args[1]
19942 x := v.Args[0]
19943 v.reset(OpARMNotEqual)
19944 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
19945 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
19946 v1.AddArg(x)
19947 v0.AddArg(v1)
19948 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
19949 v2.AddArg(y)
19950 v0.AddArg(v2)
19951 v.AddArg(v0)
19952 return true
19953 }
19954 }
19955 func rewriteValueARM_OpNeqB_0(v *Value) bool {
19956
19957
19958
19959 for {
19960 y := v.Args[1]
19961 x := v.Args[0]
19962 v.reset(OpARMXOR)
19963 v.AddArg(x)
19964 v.AddArg(y)
19965 return true
19966 }
19967 }
19968 func rewriteValueARM_OpNeqPtr_0(v *Value) bool {
19969 b := v.Block
19970
19971
19972
19973 for {
19974 y := v.Args[1]
19975 x := v.Args[0]
19976 v.reset(OpARMNotEqual)
19977 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
19978 v0.AddArg(x)
19979 v0.AddArg(y)
19980 v.AddArg(v0)
19981 return true
19982 }
19983 }
19984 func rewriteValueARM_OpNilCheck_0(v *Value) bool {
19985
19986
19987
19988 for {
19989 mem := v.Args[1]
19990 ptr := v.Args[0]
19991 v.reset(OpARMLoweredNilCheck)
19992 v.AddArg(ptr)
19993 v.AddArg(mem)
19994 return true
19995 }
19996 }
19997 func rewriteValueARM_OpNot_0(v *Value) bool {
19998
19999
20000
20001 for {
20002 x := v.Args[0]
20003 v.reset(OpARMXORconst)
20004 v.AuxInt = 1
20005 v.AddArg(x)
20006 return true
20007 }
20008 }
20009 func rewriteValueARM_OpOffPtr_0(v *Value) bool {
20010
20011
20012
20013 for {
20014 off := v.AuxInt
20015 ptr := v.Args[0]
20016 if ptr.Op != OpSP {
20017 break
20018 }
20019 v.reset(OpARMMOVWaddr)
20020 v.AuxInt = off
20021 v.AddArg(ptr)
20022 return true
20023 }
20024
20025
20026
20027 for {
20028 off := v.AuxInt
20029 ptr := v.Args[0]
20030 v.reset(OpARMADDconst)
20031 v.AuxInt = off
20032 v.AddArg(ptr)
20033 return true
20034 }
20035 }
20036 func rewriteValueARM_OpOr16_0(v *Value) bool {
20037
20038
20039
20040 for {
20041 y := v.Args[1]
20042 x := v.Args[0]
20043 v.reset(OpARMOR)
20044 v.AddArg(x)
20045 v.AddArg(y)
20046 return true
20047 }
20048 }
20049 func rewriteValueARM_OpOr32_0(v *Value) bool {
20050
20051
20052
20053 for {
20054 y := v.Args[1]
20055 x := v.Args[0]
20056 v.reset(OpARMOR)
20057 v.AddArg(x)
20058 v.AddArg(y)
20059 return true
20060 }
20061 }
20062 func rewriteValueARM_OpOr8_0(v *Value) bool {
20063
20064
20065
20066 for {
20067 y := v.Args[1]
20068 x := v.Args[0]
20069 v.reset(OpARMOR)
20070 v.AddArg(x)
20071 v.AddArg(y)
20072 return true
20073 }
20074 }
20075 func rewriteValueARM_OpOrB_0(v *Value) bool {
20076
20077
20078
20079 for {
20080 y := v.Args[1]
20081 x := v.Args[0]
20082 v.reset(OpARMOR)
20083 v.AddArg(x)
20084 v.AddArg(y)
20085 return true
20086 }
20087 }
20088 func rewriteValueARM_OpPanicBounds_0(v *Value) bool {
20089
20090
20091
20092 for {
20093 kind := v.AuxInt
20094 mem := v.Args[2]
20095 x := v.Args[0]
20096 y := v.Args[1]
20097 if !(boundsABI(kind) == 0) {
20098 break
20099 }
20100 v.reset(OpARMLoweredPanicBoundsA)
20101 v.AuxInt = kind
20102 v.AddArg(x)
20103 v.AddArg(y)
20104 v.AddArg(mem)
20105 return true
20106 }
20107
20108
20109
20110 for {
20111 kind := v.AuxInt
20112 mem := v.Args[2]
20113 x := v.Args[0]
20114 y := v.Args[1]
20115 if !(boundsABI(kind) == 1) {
20116 break
20117 }
20118 v.reset(OpARMLoweredPanicBoundsB)
20119 v.AuxInt = kind
20120 v.AddArg(x)
20121 v.AddArg(y)
20122 v.AddArg(mem)
20123 return true
20124 }
20125
20126
20127
20128 for {
20129 kind := v.AuxInt
20130 mem := v.Args[2]
20131 x := v.Args[0]
20132 y := v.Args[1]
20133 if !(boundsABI(kind) == 2) {
20134 break
20135 }
20136 v.reset(OpARMLoweredPanicBoundsC)
20137 v.AuxInt = kind
20138 v.AddArg(x)
20139 v.AddArg(y)
20140 v.AddArg(mem)
20141 return true
20142 }
20143 return false
20144 }
20145 func rewriteValueARM_OpPanicExtend_0(v *Value) bool {
20146
20147
20148
20149 for {
20150 kind := v.AuxInt
20151 mem := v.Args[3]
20152 hi := v.Args[0]
20153 lo := v.Args[1]
20154 y := v.Args[2]
20155 if !(boundsABI(kind) == 0) {
20156 break
20157 }
20158 v.reset(OpARMLoweredPanicExtendA)
20159 v.AuxInt = kind
20160 v.AddArg(hi)
20161 v.AddArg(lo)
20162 v.AddArg(y)
20163 v.AddArg(mem)
20164 return true
20165 }
20166
20167
20168
20169 for {
20170 kind := v.AuxInt
20171 mem := v.Args[3]
20172 hi := v.Args[0]
20173 lo := v.Args[1]
20174 y := v.Args[2]
20175 if !(boundsABI(kind) == 1) {
20176 break
20177 }
20178 v.reset(OpARMLoweredPanicExtendB)
20179 v.AuxInt = kind
20180 v.AddArg(hi)
20181 v.AddArg(lo)
20182 v.AddArg(y)
20183 v.AddArg(mem)
20184 return true
20185 }
20186
20187
20188
20189 for {
20190 kind := v.AuxInt
20191 mem := v.Args[3]
20192 hi := v.Args[0]
20193 lo := v.Args[1]
20194 y := v.Args[2]
20195 if !(boundsABI(kind) == 2) {
20196 break
20197 }
20198 v.reset(OpARMLoweredPanicExtendC)
20199 v.AuxInt = kind
20200 v.AddArg(hi)
20201 v.AddArg(lo)
20202 v.AddArg(y)
20203 v.AddArg(mem)
20204 return true
20205 }
20206 return false
20207 }
20208 func rewriteValueARM_OpRotateLeft16_0(v *Value) bool {
20209 b := v.Block
20210 typ := &b.Func.Config.Types
20211
20212
20213
20214 for {
20215 t := v.Type
20216 _ = v.Args[1]
20217 x := v.Args[0]
20218 v_1 := v.Args[1]
20219 if v_1.Op != OpARMMOVWconst {
20220 break
20221 }
20222 c := v_1.AuxInt
20223 v.reset(OpOr16)
20224 v0 := b.NewValue0(v.Pos, OpLsh16x32, t)
20225 v0.AddArg(x)
20226 v1 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
20227 v1.AuxInt = c & 15
20228 v0.AddArg(v1)
20229 v.AddArg(v0)
20230 v2 := b.NewValue0(v.Pos, OpRsh16Ux32, t)
20231 v2.AddArg(x)
20232 v3 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
20233 v3.AuxInt = -c & 15
20234 v2.AddArg(v3)
20235 v.AddArg(v2)
20236 return true
20237 }
20238 return false
20239 }
20240 func rewriteValueARM_OpRotateLeft32_0(v *Value) bool {
20241
20242
20243
20244 for {
20245 _ = v.Args[1]
20246 x := v.Args[0]
20247 v_1 := v.Args[1]
20248 if v_1.Op != OpARMMOVWconst {
20249 break
20250 }
20251 c := v_1.AuxInt
20252 v.reset(OpARMSRRconst)
20253 v.AuxInt = -c & 31
20254 v.AddArg(x)
20255 return true
20256 }
20257 return false
20258 }
20259 func rewriteValueARM_OpRotateLeft8_0(v *Value) bool {
20260 b := v.Block
20261 typ := &b.Func.Config.Types
20262
20263
20264
20265 for {
20266 t := v.Type
20267 _ = v.Args[1]
20268 x := v.Args[0]
20269 v_1 := v.Args[1]
20270 if v_1.Op != OpARMMOVWconst {
20271 break
20272 }
20273 c := v_1.AuxInt
20274 v.reset(OpOr8)
20275 v0 := b.NewValue0(v.Pos, OpLsh8x32, t)
20276 v0.AddArg(x)
20277 v1 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
20278 v1.AuxInt = c & 7
20279 v0.AddArg(v1)
20280 v.AddArg(v0)
20281 v2 := b.NewValue0(v.Pos, OpRsh8Ux32, t)
20282 v2.AddArg(x)
20283 v3 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
20284 v3.AuxInt = -c & 7
20285 v2.AddArg(v3)
20286 v.AddArg(v2)
20287 return true
20288 }
20289 return false
20290 }
20291 func rewriteValueARM_OpRound32F_0(v *Value) bool {
20292
20293
20294
20295 for {
20296 x := v.Args[0]
20297 v.reset(OpCopy)
20298 v.Type = x.Type
20299 v.AddArg(x)
20300 return true
20301 }
20302 }
20303 func rewriteValueARM_OpRound64F_0(v *Value) bool {
20304
20305
20306
20307 for {
20308 x := v.Args[0]
20309 v.reset(OpCopy)
20310 v.Type = x.Type
20311 v.AddArg(x)
20312 return true
20313 }
20314 }
20315 func rewriteValueARM_OpRsh16Ux16_0(v *Value) bool {
20316 b := v.Block
20317 typ := &b.Func.Config.Types
20318
20319
20320
20321 for {
20322 y := v.Args[1]
20323 x := v.Args[0]
20324 v.reset(OpARMCMOVWHSconst)
20325 v.AuxInt = 0
20326 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
20327 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20328 v1.AddArg(x)
20329 v0.AddArg(v1)
20330 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20331 v2.AddArg(y)
20332 v0.AddArg(v2)
20333 v.AddArg(v0)
20334 v3 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
20335 v3.AuxInt = 256
20336 v4 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20337 v4.AddArg(y)
20338 v3.AddArg(v4)
20339 v.AddArg(v3)
20340 return true
20341 }
20342 }
20343 func rewriteValueARM_OpRsh16Ux32_0(v *Value) bool {
20344 b := v.Block
20345 typ := &b.Func.Config.Types
20346
20347
20348
20349 for {
20350 y := v.Args[1]
20351 x := v.Args[0]
20352 v.reset(OpARMCMOVWHSconst)
20353 v.AuxInt = 0
20354 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
20355 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20356 v1.AddArg(x)
20357 v0.AddArg(v1)
20358 v0.AddArg(y)
20359 v.AddArg(v0)
20360 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
20361 v2.AuxInt = 256
20362 v2.AddArg(y)
20363 v.AddArg(v2)
20364 return true
20365 }
20366 }
20367 func rewriteValueARM_OpRsh16Ux64_0(v *Value) bool {
20368 b := v.Block
20369 typ := &b.Func.Config.Types
20370
20371
20372
20373 for {
20374 _ = v.Args[1]
20375 x := v.Args[0]
20376 v_1 := v.Args[1]
20377 if v_1.Op != OpConst64 {
20378 break
20379 }
20380 c := v_1.AuxInt
20381 if !(uint64(c) < 16) {
20382 break
20383 }
20384 v.reset(OpARMSRLconst)
20385 v.AuxInt = c + 16
20386 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32)
20387 v0.AuxInt = 16
20388 v0.AddArg(x)
20389 v.AddArg(v0)
20390 return true
20391 }
20392
20393
20394
20395 for {
20396 _ = v.Args[1]
20397 v_1 := v.Args[1]
20398 if v_1.Op != OpConst64 {
20399 break
20400 }
20401 c := v_1.AuxInt
20402 if !(uint64(c) >= 16) {
20403 break
20404 }
20405 v.reset(OpConst16)
20406 v.AuxInt = 0
20407 return true
20408 }
20409 return false
20410 }
20411 func rewriteValueARM_OpRsh16Ux8_0(v *Value) bool {
20412 b := v.Block
20413 typ := &b.Func.Config.Types
20414
20415
20416
20417 for {
20418 y := v.Args[1]
20419 x := v.Args[0]
20420 v.reset(OpARMSRL)
20421 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20422 v0.AddArg(x)
20423 v.AddArg(v0)
20424 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20425 v1.AddArg(y)
20426 v.AddArg(v1)
20427 return true
20428 }
20429 }
20430 func rewriteValueARM_OpRsh16x16_0(v *Value) bool {
20431 b := v.Block
20432 typ := &b.Func.Config.Types
20433
20434
20435
20436 for {
20437 y := v.Args[1]
20438 x := v.Args[0]
20439 v.reset(OpARMSRAcond)
20440 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
20441 v0.AddArg(x)
20442 v.AddArg(v0)
20443 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20444 v1.AddArg(y)
20445 v.AddArg(v1)
20446 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
20447 v2.AuxInt = 256
20448 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20449 v3.AddArg(y)
20450 v2.AddArg(v3)
20451 v.AddArg(v2)
20452 return true
20453 }
20454 }
20455 func rewriteValueARM_OpRsh16x32_0(v *Value) bool {
20456 b := v.Block
20457 typ := &b.Func.Config.Types
20458
20459
20460
20461 for {
20462 y := v.Args[1]
20463 x := v.Args[0]
20464 v.reset(OpARMSRAcond)
20465 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
20466 v0.AddArg(x)
20467 v.AddArg(v0)
20468 v.AddArg(y)
20469 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
20470 v1.AuxInt = 256
20471 v1.AddArg(y)
20472 v.AddArg(v1)
20473 return true
20474 }
20475 }
20476 func rewriteValueARM_OpRsh16x64_0(v *Value) bool {
20477 b := v.Block
20478 typ := &b.Func.Config.Types
20479
20480
20481
20482 for {
20483 _ = v.Args[1]
20484 x := v.Args[0]
20485 v_1 := v.Args[1]
20486 if v_1.Op != OpConst64 {
20487 break
20488 }
20489 c := v_1.AuxInt
20490 if !(uint64(c) < 16) {
20491 break
20492 }
20493 v.reset(OpARMSRAconst)
20494 v.AuxInt = c + 16
20495 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32)
20496 v0.AuxInt = 16
20497 v0.AddArg(x)
20498 v.AddArg(v0)
20499 return true
20500 }
20501
20502
20503
20504 for {
20505 _ = v.Args[1]
20506 x := v.Args[0]
20507 v_1 := v.Args[1]
20508 if v_1.Op != OpConst64 {
20509 break
20510 }
20511 c := v_1.AuxInt
20512 if !(uint64(c) >= 16) {
20513 break
20514 }
20515 v.reset(OpARMSRAconst)
20516 v.AuxInt = 31
20517 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32)
20518 v0.AuxInt = 16
20519 v0.AddArg(x)
20520 v.AddArg(v0)
20521 return true
20522 }
20523 return false
20524 }
20525 func rewriteValueARM_OpRsh16x8_0(v *Value) bool {
20526 b := v.Block
20527 typ := &b.Func.Config.Types
20528
20529
20530
20531 for {
20532 y := v.Args[1]
20533 x := v.Args[0]
20534 v.reset(OpARMSRA)
20535 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
20536 v0.AddArg(x)
20537 v.AddArg(v0)
20538 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20539 v1.AddArg(y)
20540 v.AddArg(v1)
20541 return true
20542 }
20543 }
20544 func rewriteValueARM_OpRsh32Ux16_0(v *Value) bool {
20545 b := v.Block
20546 typ := &b.Func.Config.Types
20547
20548
20549
20550 for {
20551 y := v.Args[1]
20552 x := v.Args[0]
20553 v.reset(OpARMCMOVWHSconst)
20554 v.AuxInt = 0
20555 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
20556 v0.AddArg(x)
20557 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20558 v1.AddArg(y)
20559 v0.AddArg(v1)
20560 v.AddArg(v0)
20561 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
20562 v2.AuxInt = 256
20563 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20564 v3.AddArg(y)
20565 v2.AddArg(v3)
20566 v.AddArg(v2)
20567 return true
20568 }
20569 }
20570 func rewriteValueARM_OpRsh32Ux32_0(v *Value) bool {
20571 b := v.Block
20572
20573
20574
20575 for {
20576 y := v.Args[1]
20577 x := v.Args[0]
20578 v.reset(OpARMCMOVWHSconst)
20579 v.AuxInt = 0
20580 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
20581 v0.AddArg(x)
20582 v0.AddArg(y)
20583 v.AddArg(v0)
20584 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
20585 v1.AuxInt = 256
20586 v1.AddArg(y)
20587 v.AddArg(v1)
20588 return true
20589 }
20590 }
20591 func rewriteValueARM_OpRsh32Ux64_0(v *Value) bool {
20592
20593
20594
20595 for {
20596 _ = v.Args[1]
20597 x := v.Args[0]
20598 v_1 := v.Args[1]
20599 if v_1.Op != OpConst64 {
20600 break
20601 }
20602 c := v_1.AuxInt
20603 if !(uint64(c) < 32) {
20604 break
20605 }
20606 v.reset(OpARMSRLconst)
20607 v.AuxInt = c
20608 v.AddArg(x)
20609 return true
20610 }
20611
20612
20613
20614 for {
20615 _ = v.Args[1]
20616 v_1 := v.Args[1]
20617 if v_1.Op != OpConst64 {
20618 break
20619 }
20620 c := v_1.AuxInt
20621 if !(uint64(c) >= 32) {
20622 break
20623 }
20624 v.reset(OpConst32)
20625 v.AuxInt = 0
20626 return true
20627 }
20628 return false
20629 }
20630 func rewriteValueARM_OpRsh32Ux8_0(v *Value) bool {
20631 b := v.Block
20632 typ := &b.Func.Config.Types
20633
20634
20635
20636 for {
20637 y := v.Args[1]
20638 x := v.Args[0]
20639 v.reset(OpARMSRL)
20640 v.AddArg(x)
20641 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20642 v0.AddArg(y)
20643 v.AddArg(v0)
20644 return true
20645 }
20646 }
20647 func rewriteValueARM_OpRsh32x16_0(v *Value) bool {
20648 b := v.Block
20649 typ := &b.Func.Config.Types
20650
20651
20652
20653 for {
20654 y := v.Args[1]
20655 x := v.Args[0]
20656 v.reset(OpARMSRAcond)
20657 v.AddArg(x)
20658 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20659 v0.AddArg(y)
20660 v.AddArg(v0)
20661 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
20662 v1.AuxInt = 256
20663 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20664 v2.AddArg(y)
20665 v1.AddArg(v2)
20666 v.AddArg(v1)
20667 return true
20668 }
20669 }
20670 func rewriteValueARM_OpRsh32x32_0(v *Value) bool {
20671 b := v.Block
20672
20673
20674
20675 for {
20676 y := v.Args[1]
20677 x := v.Args[0]
20678 v.reset(OpARMSRAcond)
20679 v.AddArg(x)
20680 v.AddArg(y)
20681 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
20682 v0.AuxInt = 256
20683 v0.AddArg(y)
20684 v.AddArg(v0)
20685 return true
20686 }
20687 }
20688 func rewriteValueARM_OpRsh32x64_0(v *Value) bool {
20689
20690
20691
20692 for {
20693 _ = v.Args[1]
20694 x := v.Args[0]
20695 v_1 := v.Args[1]
20696 if v_1.Op != OpConst64 {
20697 break
20698 }
20699 c := v_1.AuxInt
20700 if !(uint64(c) < 32) {
20701 break
20702 }
20703 v.reset(OpARMSRAconst)
20704 v.AuxInt = c
20705 v.AddArg(x)
20706 return true
20707 }
20708
20709
20710
20711 for {
20712 _ = v.Args[1]
20713 x := v.Args[0]
20714 v_1 := v.Args[1]
20715 if v_1.Op != OpConst64 {
20716 break
20717 }
20718 c := v_1.AuxInt
20719 if !(uint64(c) >= 32) {
20720 break
20721 }
20722 v.reset(OpARMSRAconst)
20723 v.AuxInt = 31
20724 v.AddArg(x)
20725 return true
20726 }
20727 return false
20728 }
20729 func rewriteValueARM_OpRsh32x8_0(v *Value) bool {
20730 b := v.Block
20731 typ := &b.Func.Config.Types
20732
20733
20734
20735 for {
20736 y := v.Args[1]
20737 x := v.Args[0]
20738 v.reset(OpARMSRA)
20739 v.AddArg(x)
20740 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20741 v0.AddArg(y)
20742 v.AddArg(v0)
20743 return true
20744 }
20745 }
20746 func rewriteValueARM_OpRsh8Ux16_0(v *Value) bool {
20747 b := v.Block
20748 typ := &b.Func.Config.Types
20749
20750
20751
20752 for {
20753 y := v.Args[1]
20754 x := v.Args[0]
20755 v.reset(OpARMCMOVWHSconst)
20756 v.AuxInt = 0
20757 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
20758 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20759 v1.AddArg(x)
20760 v0.AddArg(v1)
20761 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20762 v2.AddArg(y)
20763 v0.AddArg(v2)
20764 v.AddArg(v0)
20765 v3 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
20766 v3.AuxInt = 256
20767 v4 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20768 v4.AddArg(y)
20769 v3.AddArg(v4)
20770 v.AddArg(v3)
20771 return true
20772 }
20773 }
20774 func rewriteValueARM_OpRsh8Ux32_0(v *Value) bool {
20775 b := v.Block
20776 typ := &b.Func.Config.Types
20777
20778
20779
20780 for {
20781 y := v.Args[1]
20782 x := v.Args[0]
20783 v.reset(OpARMCMOVWHSconst)
20784 v.AuxInt = 0
20785 v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
20786 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20787 v1.AddArg(x)
20788 v0.AddArg(v1)
20789 v0.AddArg(y)
20790 v.AddArg(v0)
20791 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
20792 v2.AuxInt = 256
20793 v2.AddArg(y)
20794 v.AddArg(v2)
20795 return true
20796 }
20797 }
20798 func rewriteValueARM_OpRsh8Ux64_0(v *Value) bool {
20799 b := v.Block
20800 typ := &b.Func.Config.Types
20801
20802
20803
20804 for {
20805 _ = v.Args[1]
20806 x := v.Args[0]
20807 v_1 := v.Args[1]
20808 if v_1.Op != OpConst64 {
20809 break
20810 }
20811 c := v_1.AuxInt
20812 if !(uint64(c) < 8) {
20813 break
20814 }
20815 v.reset(OpARMSRLconst)
20816 v.AuxInt = c + 24
20817 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32)
20818 v0.AuxInt = 24
20819 v0.AddArg(x)
20820 v.AddArg(v0)
20821 return true
20822 }
20823
20824
20825
20826 for {
20827 _ = v.Args[1]
20828 v_1 := v.Args[1]
20829 if v_1.Op != OpConst64 {
20830 break
20831 }
20832 c := v_1.AuxInt
20833 if !(uint64(c) >= 8) {
20834 break
20835 }
20836 v.reset(OpConst8)
20837 v.AuxInt = 0
20838 return true
20839 }
20840 return false
20841 }
20842 func rewriteValueARM_OpRsh8Ux8_0(v *Value) bool {
20843 b := v.Block
20844 typ := &b.Func.Config.Types
20845
20846
20847
20848 for {
20849 y := v.Args[1]
20850 x := v.Args[0]
20851 v.reset(OpARMSRL)
20852 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20853 v0.AddArg(x)
20854 v.AddArg(v0)
20855 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20856 v1.AddArg(y)
20857 v.AddArg(v1)
20858 return true
20859 }
20860 }
20861 func rewriteValueARM_OpRsh8x16_0(v *Value) bool {
20862 b := v.Block
20863 typ := &b.Func.Config.Types
20864
20865
20866
20867 for {
20868 y := v.Args[1]
20869 x := v.Args[0]
20870 v.reset(OpARMSRAcond)
20871 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
20872 v0.AddArg(x)
20873 v.AddArg(v0)
20874 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20875 v1.AddArg(y)
20876 v.AddArg(v1)
20877 v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
20878 v2.AuxInt = 256
20879 v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20880 v3.AddArg(y)
20881 v2.AddArg(v3)
20882 v.AddArg(v2)
20883 return true
20884 }
20885 }
20886 func rewriteValueARM_OpRsh8x32_0(v *Value) bool {
20887 b := v.Block
20888 typ := &b.Func.Config.Types
20889
20890
20891
20892 for {
20893 y := v.Args[1]
20894 x := v.Args[0]
20895 v.reset(OpARMSRAcond)
20896 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
20897 v0.AddArg(x)
20898 v.AddArg(v0)
20899 v.AddArg(y)
20900 v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
20901 v1.AuxInt = 256
20902 v1.AddArg(y)
20903 v.AddArg(v1)
20904 return true
20905 }
20906 }
20907 func rewriteValueARM_OpRsh8x64_0(v *Value) bool {
20908 b := v.Block
20909 typ := &b.Func.Config.Types
20910
20911
20912
20913 for {
20914 _ = v.Args[1]
20915 x := v.Args[0]
20916 v_1 := v.Args[1]
20917 if v_1.Op != OpConst64 {
20918 break
20919 }
20920 c := v_1.AuxInt
20921 if !(uint64(c) < 8) {
20922 break
20923 }
20924 v.reset(OpARMSRAconst)
20925 v.AuxInt = c + 24
20926 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32)
20927 v0.AuxInt = 24
20928 v0.AddArg(x)
20929 v.AddArg(v0)
20930 return true
20931 }
20932
20933
20934
20935 for {
20936 _ = v.Args[1]
20937 x := v.Args[0]
20938 v_1 := v.Args[1]
20939 if v_1.Op != OpConst64 {
20940 break
20941 }
20942 c := v_1.AuxInt
20943 if !(uint64(c) >= 8) {
20944 break
20945 }
20946 v.reset(OpARMSRAconst)
20947 v.AuxInt = 31
20948 v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32)
20949 v0.AuxInt = 24
20950 v0.AddArg(x)
20951 v.AddArg(v0)
20952 return true
20953 }
20954 return false
20955 }
20956 func rewriteValueARM_OpRsh8x8_0(v *Value) bool {
20957 b := v.Block
20958 typ := &b.Func.Config.Types
20959
20960
20961
20962 for {
20963 y := v.Args[1]
20964 x := v.Args[0]
20965 v.reset(OpARMSRA)
20966 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
20967 v0.AddArg(x)
20968 v.AddArg(v0)
20969 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20970 v1.AddArg(y)
20971 v.AddArg(v1)
20972 return true
20973 }
20974 }
20975 func rewriteValueARM_OpSelect0_0(v *Value) bool {
20976
20977
20978
20979 for {
20980 v_0 := v.Args[0]
20981 if v_0.Op != OpARMCALLudiv {
20982 break
20983 }
20984 _ = v_0.Args[1]
20985 x := v_0.Args[0]
20986 v_0_1 := v_0.Args[1]
20987 if v_0_1.Op != OpARMMOVWconst {
20988 break
20989 }
20990 if v_0_1.AuxInt != 1 {
20991 break
20992 }
20993 v.reset(OpCopy)
20994 v.Type = x.Type
20995 v.AddArg(x)
20996 return true
20997 }
20998
20999
21000
21001 for {
21002 v_0 := v.Args[0]
21003 if v_0.Op != OpARMCALLudiv {
21004 break
21005 }
21006 _ = v_0.Args[1]
21007 x := v_0.Args[0]
21008 v_0_1 := v_0.Args[1]
21009 if v_0_1.Op != OpARMMOVWconst {
21010 break
21011 }
21012 c := v_0_1.AuxInt
21013 if !(isPowerOfTwo(c)) {
21014 break
21015 }
21016 v.reset(OpARMSRLconst)
21017 v.AuxInt = log2(c)
21018 v.AddArg(x)
21019 return true
21020 }
21021
21022
21023
21024 for {
21025 v_0 := v.Args[0]
21026 if v_0.Op != OpARMCALLudiv {
21027 break
21028 }
21029 _ = v_0.Args[1]
21030 v_0_0 := v_0.Args[0]
21031 if v_0_0.Op != OpARMMOVWconst {
21032 break
21033 }
21034 c := v_0_0.AuxInt
21035 v_0_1 := v_0.Args[1]
21036 if v_0_1.Op != OpARMMOVWconst {
21037 break
21038 }
21039 d := v_0_1.AuxInt
21040 v.reset(OpARMMOVWconst)
21041 v.AuxInt = int64(int32(uint32(c) / uint32(d)))
21042 return true
21043 }
21044 return false
21045 }
21046 func rewriteValueARM_OpSelect1_0(v *Value) bool {
21047
21048
21049
21050 for {
21051 v_0 := v.Args[0]
21052 if v_0.Op != OpARMCALLudiv {
21053 break
21054 }
21055 _ = v_0.Args[1]
21056 v_0_1 := v_0.Args[1]
21057 if v_0_1.Op != OpARMMOVWconst {
21058 break
21059 }
21060 if v_0_1.AuxInt != 1 {
21061 break
21062 }
21063 v.reset(OpARMMOVWconst)
21064 v.AuxInt = 0
21065 return true
21066 }
21067
21068
21069
21070 for {
21071 v_0 := v.Args[0]
21072 if v_0.Op != OpARMCALLudiv {
21073 break
21074 }
21075 _ = v_0.Args[1]
21076 x := v_0.Args[0]
21077 v_0_1 := v_0.Args[1]
21078 if v_0_1.Op != OpARMMOVWconst {
21079 break
21080 }
21081 c := v_0_1.AuxInt
21082 if !(isPowerOfTwo(c)) {
21083 break
21084 }
21085 v.reset(OpARMANDconst)
21086 v.AuxInt = c - 1
21087 v.AddArg(x)
21088 return true
21089 }
21090
21091
21092
21093 for {
21094 v_0 := v.Args[0]
21095 if v_0.Op != OpARMCALLudiv {
21096 break
21097 }
21098 _ = v_0.Args[1]
21099 v_0_0 := v_0.Args[0]
21100 if v_0_0.Op != OpARMMOVWconst {
21101 break
21102 }
21103 c := v_0_0.AuxInt
21104 v_0_1 := v_0.Args[1]
21105 if v_0_1.Op != OpARMMOVWconst {
21106 break
21107 }
21108 d := v_0_1.AuxInt
21109 v.reset(OpARMMOVWconst)
21110 v.AuxInt = int64(int32(uint32(c) % uint32(d)))
21111 return true
21112 }
21113 return false
21114 }
21115 func rewriteValueARM_OpSignExt16to32_0(v *Value) bool {
21116
21117
21118
21119 for {
21120 x := v.Args[0]
21121 v.reset(OpARMMOVHreg)
21122 v.AddArg(x)
21123 return true
21124 }
21125 }
21126 func rewriteValueARM_OpSignExt8to16_0(v *Value) bool {
21127
21128
21129
21130 for {
21131 x := v.Args[0]
21132 v.reset(OpARMMOVBreg)
21133 v.AddArg(x)
21134 return true
21135 }
21136 }
21137 func rewriteValueARM_OpSignExt8to32_0(v *Value) bool {
21138
21139
21140
21141 for {
21142 x := v.Args[0]
21143 v.reset(OpARMMOVBreg)
21144 v.AddArg(x)
21145 return true
21146 }
21147 }
21148 func rewriteValueARM_OpSignmask_0(v *Value) bool {
21149
21150
21151
21152 for {
21153 x := v.Args[0]
21154 v.reset(OpARMSRAconst)
21155 v.AuxInt = 31
21156 v.AddArg(x)
21157 return true
21158 }
21159 }
21160 func rewriteValueARM_OpSlicemask_0(v *Value) bool {
21161 b := v.Block
21162
21163
21164
21165 for {
21166 t := v.Type
21167 x := v.Args[0]
21168 v.reset(OpARMSRAconst)
21169 v.AuxInt = 31
21170 v0 := b.NewValue0(v.Pos, OpARMRSBconst, t)
21171 v0.AuxInt = 0
21172 v0.AddArg(x)
21173 v.AddArg(v0)
21174 return true
21175 }
21176 }
21177 func rewriteValueARM_OpSqrt_0(v *Value) bool {
21178
21179
21180
21181 for {
21182 x := v.Args[0]
21183 v.reset(OpARMSQRTD)
21184 v.AddArg(x)
21185 return true
21186 }
21187 }
21188 func rewriteValueARM_OpStaticCall_0(v *Value) bool {
21189
21190
21191
21192 for {
21193 argwid := v.AuxInt
21194 target := v.Aux
21195 mem := v.Args[0]
21196 v.reset(OpARMCALLstatic)
21197 v.AuxInt = argwid
21198 v.Aux = target
21199 v.AddArg(mem)
21200 return true
21201 }
21202 }
21203 func rewriteValueARM_OpStore_0(v *Value) bool {
21204
21205
21206
21207 for {
21208 t := v.Aux
21209 mem := v.Args[2]
21210 ptr := v.Args[0]
21211 val := v.Args[1]
21212 if !(t.(*types.Type).Size() == 1) {
21213 break
21214 }
21215 v.reset(OpARMMOVBstore)
21216 v.AddArg(ptr)
21217 v.AddArg(val)
21218 v.AddArg(mem)
21219 return true
21220 }
21221
21222
21223
21224 for {
21225 t := v.Aux
21226 mem := v.Args[2]
21227 ptr := v.Args[0]
21228 val := v.Args[1]
21229 if !(t.(*types.Type).Size() == 2) {
21230 break
21231 }
21232 v.reset(OpARMMOVHstore)
21233 v.AddArg(ptr)
21234 v.AddArg(val)
21235 v.AddArg(mem)
21236 return true
21237 }
21238
21239
21240
21241 for {
21242 t := v.Aux
21243 mem := v.Args[2]
21244 ptr := v.Args[0]
21245 val := v.Args[1]
21246 if !(t.(*types.Type).Size() == 4 && !is32BitFloat(val.Type)) {
21247 break
21248 }
21249 v.reset(OpARMMOVWstore)
21250 v.AddArg(ptr)
21251 v.AddArg(val)
21252 v.AddArg(mem)
21253 return true
21254 }
21255
21256
21257
21258 for {
21259 t := v.Aux
21260 mem := v.Args[2]
21261 ptr := v.Args[0]
21262 val := v.Args[1]
21263 if !(t.(*types.Type).Size() == 4 && is32BitFloat(val.Type)) {
21264 break
21265 }
21266 v.reset(OpARMMOVFstore)
21267 v.AddArg(ptr)
21268 v.AddArg(val)
21269 v.AddArg(mem)
21270 return true
21271 }
21272
21273
21274
21275 for {
21276 t := v.Aux
21277 mem := v.Args[2]
21278 ptr := v.Args[0]
21279 val := v.Args[1]
21280 if !(t.(*types.Type).Size() == 8 && is64BitFloat(val.Type)) {
21281 break
21282 }
21283 v.reset(OpARMMOVDstore)
21284 v.AddArg(ptr)
21285 v.AddArg(val)
21286 v.AddArg(mem)
21287 return true
21288 }
21289 return false
21290 }
21291 func rewriteValueARM_OpSub16_0(v *Value) bool {
21292
21293
21294
21295 for {
21296 y := v.Args[1]
21297 x := v.Args[0]
21298 v.reset(OpARMSUB)
21299 v.AddArg(x)
21300 v.AddArg(y)
21301 return true
21302 }
21303 }
21304 func rewriteValueARM_OpSub32_0(v *Value) bool {
21305
21306
21307
21308 for {
21309 y := v.Args[1]
21310 x := v.Args[0]
21311 v.reset(OpARMSUB)
21312 v.AddArg(x)
21313 v.AddArg(y)
21314 return true
21315 }
21316 }
21317 func rewriteValueARM_OpSub32F_0(v *Value) bool {
21318
21319
21320
21321 for {
21322 y := v.Args[1]
21323 x := v.Args[0]
21324 v.reset(OpARMSUBF)
21325 v.AddArg(x)
21326 v.AddArg(y)
21327 return true
21328 }
21329 }
21330 func rewriteValueARM_OpSub32carry_0(v *Value) bool {
21331
21332
21333
21334 for {
21335 y := v.Args[1]
21336 x := v.Args[0]
21337 v.reset(OpARMSUBS)
21338 v.AddArg(x)
21339 v.AddArg(y)
21340 return true
21341 }
21342 }
21343 func rewriteValueARM_OpSub32withcarry_0(v *Value) bool {
21344
21345
21346
21347 for {
21348 c := v.Args[2]
21349 x := v.Args[0]
21350 y := v.Args[1]
21351 v.reset(OpARMSBC)
21352 v.AddArg(x)
21353 v.AddArg(y)
21354 v.AddArg(c)
21355 return true
21356 }
21357 }
21358 func rewriteValueARM_OpSub64F_0(v *Value) bool {
21359
21360
21361
21362 for {
21363 y := v.Args[1]
21364 x := v.Args[0]
21365 v.reset(OpARMSUBD)
21366 v.AddArg(x)
21367 v.AddArg(y)
21368 return true
21369 }
21370 }
21371 func rewriteValueARM_OpSub8_0(v *Value) bool {
21372
21373
21374
21375 for {
21376 y := v.Args[1]
21377 x := v.Args[0]
21378 v.reset(OpARMSUB)
21379 v.AddArg(x)
21380 v.AddArg(y)
21381 return true
21382 }
21383 }
21384 func rewriteValueARM_OpSubPtr_0(v *Value) bool {
21385
21386
21387
21388 for {
21389 y := v.Args[1]
21390 x := v.Args[0]
21391 v.reset(OpARMSUB)
21392 v.AddArg(x)
21393 v.AddArg(y)
21394 return true
21395 }
21396 }
21397 func rewriteValueARM_OpTrunc16to8_0(v *Value) bool {
21398
21399
21400
21401 for {
21402 x := v.Args[0]
21403 v.reset(OpCopy)
21404 v.Type = x.Type
21405 v.AddArg(x)
21406 return true
21407 }
21408 }
21409 func rewriteValueARM_OpTrunc32to16_0(v *Value) bool {
21410
21411
21412
21413 for {
21414 x := v.Args[0]
21415 v.reset(OpCopy)
21416 v.Type = x.Type
21417 v.AddArg(x)
21418 return true
21419 }
21420 }
21421 func rewriteValueARM_OpTrunc32to8_0(v *Value) bool {
21422
21423
21424
21425 for {
21426 x := v.Args[0]
21427 v.reset(OpCopy)
21428 v.Type = x.Type
21429 v.AddArg(x)
21430 return true
21431 }
21432 }
21433 func rewriteValueARM_OpWB_0(v *Value) bool {
21434
21435
21436
21437 for {
21438 fn := v.Aux
21439 mem := v.Args[2]
21440 destptr := v.Args[0]
21441 srcptr := v.Args[1]
21442 v.reset(OpARMLoweredWB)
21443 v.Aux = fn
21444 v.AddArg(destptr)
21445 v.AddArg(srcptr)
21446 v.AddArg(mem)
21447 return true
21448 }
21449 }
21450 func rewriteValueARM_OpXor16_0(v *Value) bool {
21451
21452
21453
21454 for {
21455 y := v.Args[1]
21456 x := v.Args[0]
21457 v.reset(OpARMXOR)
21458 v.AddArg(x)
21459 v.AddArg(y)
21460 return true
21461 }
21462 }
21463 func rewriteValueARM_OpXor32_0(v *Value) bool {
21464
21465
21466
21467 for {
21468 y := v.Args[1]
21469 x := v.Args[0]
21470 v.reset(OpARMXOR)
21471 v.AddArg(x)
21472 v.AddArg(y)
21473 return true
21474 }
21475 }
21476 func rewriteValueARM_OpXor8_0(v *Value) bool {
21477
21478
21479
21480 for {
21481 y := v.Args[1]
21482 x := v.Args[0]
21483 v.reset(OpARMXOR)
21484 v.AddArg(x)
21485 v.AddArg(y)
21486 return true
21487 }
21488 }
21489 func rewriteValueARM_OpZero_0(v *Value) bool {
21490 b := v.Block
21491 config := b.Func.Config
21492 typ := &b.Func.Config.Types
21493
21494
21495
21496 for {
21497 if v.AuxInt != 0 {
21498 break
21499 }
21500 mem := v.Args[1]
21501 v.reset(OpCopy)
21502 v.Type = mem.Type
21503 v.AddArg(mem)
21504 return true
21505 }
21506
21507
21508
21509 for {
21510 if v.AuxInt != 1 {
21511 break
21512 }
21513 mem := v.Args[1]
21514 ptr := v.Args[0]
21515 v.reset(OpARMMOVBstore)
21516 v.AddArg(ptr)
21517 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
21518 v0.AuxInt = 0
21519 v.AddArg(v0)
21520 v.AddArg(mem)
21521 return true
21522 }
21523
21524
21525
21526 for {
21527 if v.AuxInt != 2 {
21528 break
21529 }
21530 t := v.Aux
21531 mem := v.Args[1]
21532 ptr := v.Args[0]
21533 if !(t.(*types.Type).Alignment()%2 == 0) {
21534 break
21535 }
21536 v.reset(OpARMMOVHstore)
21537 v.AddArg(ptr)
21538 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
21539 v0.AuxInt = 0
21540 v.AddArg(v0)
21541 v.AddArg(mem)
21542 return true
21543 }
21544
21545
21546
21547 for {
21548 if v.AuxInt != 2 {
21549 break
21550 }
21551 mem := v.Args[1]
21552 ptr := v.Args[0]
21553 v.reset(OpARMMOVBstore)
21554 v.AuxInt = 1
21555 v.AddArg(ptr)
21556 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
21557 v0.AuxInt = 0
21558 v.AddArg(v0)
21559 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
21560 v1.AuxInt = 0
21561 v1.AddArg(ptr)
21562 v2 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
21563 v2.AuxInt = 0
21564 v1.AddArg(v2)
21565 v1.AddArg(mem)
21566 v.AddArg(v1)
21567 return true
21568 }
21569
21570
21571
21572 for {
21573 if v.AuxInt != 4 {
21574 break
21575 }
21576 t := v.Aux
21577 mem := v.Args[1]
21578 ptr := v.Args[0]
21579 if !(t.(*types.Type).Alignment()%4 == 0) {
21580 break
21581 }
21582 v.reset(OpARMMOVWstore)
21583 v.AddArg(ptr)
21584 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
21585 v0.AuxInt = 0
21586 v.AddArg(v0)
21587 v.AddArg(mem)
21588 return true
21589 }
21590
21591
21592
21593 for {
21594 if v.AuxInt != 4 {
21595 break
21596 }
21597 t := v.Aux
21598 mem := v.Args[1]
21599 ptr := v.Args[0]
21600 if !(t.(*types.Type).Alignment()%2 == 0) {
21601 break
21602 }
21603 v.reset(OpARMMOVHstore)
21604 v.AuxInt = 2
21605 v.AddArg(ptr)
21606 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
21607 v0.AuxInt = 0
21608 v.AddArg(v0)
21609 v1 := b.NewValue0(v.Pos, OpARMMOVHstore, types.TypeMem)
21610 v1.AuxInt = 0
21611 v1.AddArg(ptr)
21612 v2 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
21613 v2.AuxInt = 0
21614 v1.AddArg(v2)
21615 v1.AddArg(mem)
21616 v.AddArg(v1)
21617 return true
21618 }
21619
21620
21621
21622 for {
21623 if v.AuxInt != 4 {
21624 break
21625 }
21626 mem := v.Args[1]
21627 ptr := v.Args[0]
21628 v.reset(OpARMMOVBstore)
21629 v.AuxInt = 3
21630 v.AddArg(ptr)
21631 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
21632 v0.AuxInt = 0
21633 v.AddArg(v0)
21634 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
21635 v1.AuxInt = 2
21636 v1.AddArg(ptr)
21637 v2 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
21638 v2.AuxInt = 0
21639 v1.AddArg(v2)
21640 v3 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
21641 v3.AuxInt = 1
21642 v3.AddArg(ptr)
21643 v4 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
21644 v4.AuxInt = 0
21645 v3.AddArg(v4)
21646 v5 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
21647 v5.AuxInt = 0
21648 v5.AddArg(ptr)
21649 v6 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
21650 v6.AuxInt = 0
21651 v5.AddArg(v6)
21652 v5.AddArg(mem)
21653 v3.AddArg(v5)
21654 v1.AddArg(v3)
21655 v.AddArg(v1)
21656 return true
21657 }
21658
21659
21660
21661 for {
21662 if v.AuxInt != 3 {
21663 break
21664 }
21665 mem := v.Args[1]
21666 ptr := v.Args[0]
21667 v.reset(OpARMMOVBstore)
21668 v.AuxInt = 2
21669 v.AddArg(ptr)
21670 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
21671 v0.AuxInt = 0
21672 v.AddArg(v0)
21673 v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
21674 v1.AuxInt = 1
21675 v1.AddArg(ptr)
21676 v2 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
21677 v2.AuxInt = 0
21678 v1.AddArg(v2)
21679 v3 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
21680 v3.AuxInt = 0
21681 v3.AddArg(ptr)
21682 v4 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
21683 v4.AuxInt = 0
21684 v3.AddArg(v4)
21685 v3.AddArg(mem)
21686 v1.AddArg(v3)
21687 v.AddArg(v1)
21688 return true
21689 }
21690
21691
21692
21693 for {
21694 s := v.AuxInt
21695 t := v.Aux
21696 mem := v.Args[1]
21697 ptr := v.Args[0]
21698 if !(s%4 == 0 && s > 4 && s <= 512 && t.(*types.Type).Alignment()%4 == 0 && !config.noDuffDevice) {
21699 break
21700 }
21701 v.reset(OpARMDUFFZERO)
21702 v.AuxInt = 4 * (128 - s/4)
21703 v.AddArg(ptr)
21704 v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
21705 v0.AuxInt = 0
21706 v.AddArg(v0)
21707 v.AddArg(mem)
21708 return true
21709 }
21710
21711
21712
21713 for {
21714 s := v.AuxInt
21715 t := v.Aux
21716 mem := v.Args[1]
21717 ptr := v.Args[0]
21718 if !((s > 512 || config.noDuffDevice) || t.(*types.Type).Alignment()%4 != 0) {
21719 break
21720 }
21721 v.reset(OpARMLoweredZero)
21722 v.AuxInt = t.(*types.Type).Alignment()
21723 v.AddArg(ptr)
21724 v0 := b.NewValue0(v.Pos, OpARMADDconst, ptr.Type)
21725 v0.AuxInt = s - moveSize(t.(*types.Type).Alignment(), config)
21726 v0.AddArg(ptr)
21727 v.AddArg(v0)
21728 v1 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
21729 v1.AuxInt = 0
21730 v.AddArg(v1)
21731 v.AddArg(mem)
21732 return true
21733 }
21734 return false
21735 }
21736 func rewriteValueARM_OpZeroExt16to32_0(v *Value) bool {
21737
21738
21739
21740 for {
21741 x := v.Args[0]
21742 v.reset(OpARMMOVHUreg)
21743 v.AddArg(x)
21744 return true
21745 }
21746 }
21747 func rewriteValueARM_OpZeroExt8to16_0(v *Value) bool {
21748
21749
21750
21751 for {
21752 x := v.Args[0]
21753 v.reset(OpARMMOVBUreg)
21754 v.AddArg(x)
21755 return true
21756 }
21757 }
21758 func rewriteValueARM_OpZeroExt8to32_0(v *Value) bool {
21759
21760
21761
21762 for {
21763 x := v.Args[0]
21764 v.reset(OpARMMOVBUreg)
21765 v.AddArg(x)
21766 return true
21767 }
21768 }
21769 func rewriteValueARM_OpZeromask_0(v *Value) bool {
21770 b := v.Block
21771 typ := &b.Func.Config.Types
21772
21773
21774
21775 for {
21776 x := v.Args[0]
21777 v.reset(OpARMSRAconst)
21778 v.AuxInt = 31
21779 v0 := b.NewValue0(v.Pos, OpARMRSBshiftRL, typ.Int32)
21780 v0.AuxInt = 1
21781 v0.AddArg(x)
21782 v0.AddArg(x)
21783 v.AddArg(v0)
21784 return true
21785 }
21786 }
21787 func rewriteBlockARM(b *Block) bool {
21788 config := b.Func.Config
21789 typ := &config.Types
21790 _ = typ
21791 v := b.Control
21792 _ = v
21793 switch b.Kind {
21794 case BlockARMEQ:
21795
21796
21797
21798 for v.Op == OpARMFlagEQ {
21799 b.Kind = BlockFirst
21800 b.SetControl(nil)
21801 b.Aux = nil
21802 return true
21803 }
21804
21805
21806
21807 for v.Op == OpARMFlagLT_ULT {
21808 b.Kind = BlockFirst
21809 b.SetControl(nil)
21810 b.Aux = nil
21811 b.swapSuccessors()
21812 return true
21813 }
21814
21815
21816
21817 for v.Op == OpARMFlagLT_UGT {
21818 b.Kind = BlockFirst
21819 b.SetControl(nil)
21820 b.Aux = nil
21821 b.swapSuccessors()
21822 return true
21823 }
21824
21825
21826
21827 for v.Op == OpARMFlagGT_ULT {
21828 b.Kind = BlockFirst
21829 b.SetControl(nil)
21830 b.Aux = nil
21831 b.swapSuccessors()
21832 return true
21833 }
21834
21835
21836
21837 for v.Op == OpARMFlagGT_UGT {
21838 b.Kind = BlockFirst
21839 b.SetControl(nil)
21840 b.Aux = nil
21841 b.swapSuccessors()
21842 return true
21843 }
21844
21845
21846
21847 for v.Op == OpARMInvertFlags {
21848 cmp := v.Args[0]
21849 b.Kind = BlockARMEQ
21850 b.SetControl(cmp)
21851 b.Aux = nil
21852 return true
21853 }
21854
21855
21856
21857 for v.Op == OpARMCMPconst {
21858 if v.AuxInt != 0 {
21859 break
21860 }
21861 l := v.Args[0]
21862 if l.Op != OpARMSUB {
21863 break
21864 }
21865 y := l.Args[1]
21866 x := l.Args[0]
21867 if !(l.Uses == 1) {
21868 break
21869 }
21870 b.Kind = BlockARMEQ
21871 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
21872 v0.AddArg(x)
21873 v0.AddArg(y)
21874 b.SetControl(v0)
21875 b.Aux = nil
21876 return true
21877 }
21878
21879
21880
21881 for v.Op == OpARMCMPconst {
21882 if v.AuxInt != 0 {
21883 break
21884 }
21885 l := v.Args[0]
21886 if l.Op != OpARMMULS {
21887 break
21888 }
21889 a := l.Args[2]
21890 x := l.Args[0]
21891 y := l.Args[1]
21892 if !(l.Uses == 1) {
21893 break
21894 }
21895 b.Kind = BlockARMEQ
21896 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
21897 v0.AddArg(a)
21898 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type)
21899 v1.AddArg(x)
21900 v1.AddArg(y)
21901 v0.AddArg(v1)
21902 b.SetControl(v0)
21903 b.Aux = nil
21904 return true
21905 }
21906
21907
21908
21909 for v.Op == OpARMCMPconst {
21910 if v.AuxInt != 0 {
21911 break
21912 }
21913 l := v.Args[0]
21914 if l.Op != OpARMSUBconst {
21915 break
21916 }
21917 c := l.AuxInt
21918 x := l.Args[0]
21919 if !(l.Uses == 1) {
21920 break
21921 }
21922 b.Kind = BlockARMEQ
21923 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
21924 v0.AuxInt = c
21925 v0.AddArg(x)
21926 b.SetControl(v0)
21927 b.Aux = nil
21928 return true
21929 }
21930
21931
21932
21933 for v.Op == OpARMCMPconst {
21934 if v.AuxInt != 0 {
21935 break
21936 }
21937 l := v.Args[0]
21938 if l.Op != OpARMSUBshiftLL {
21939 break
21940 }
21941 c := l.AuxInt
21942 y := l.Args[1]
21943 x := l.Args[0]
21944 if !(l.Uses == 1) {
21945 break
21946 }
21947 b.Kind = BlockARMEQ
21948 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags)
21949 v0.AuxInt = c
21950 v0.AddArg(x)
21951 v0.AddArg(y)
21952 b.SetControl(v0)
21953 b.Aux = nil
21954 return true
21955 }
21956
21957
21958
21959 for v.Op == OpARMCMPconst {
21960 if v.AuxInt != 0 {
21961 break
21962 }
21963 l := v.Args[0]
21964 if l.Op != OpARMSUBshiftRL {
21965 break
21966 }
21967 c := l.AuxInt
21968 y := l.Args[1]
21969 x := l.Args[0]
21970 if !(l.Uses == 1) {
21971 break
21972 }
21973 b.Kind = BlockARMEQ
21974 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags)
21975 v0.AuxInt = c
21976 v0.AddArg(x)
21977 v0.AddArg(y)
21978 b.SetControl(v0)
21979 b.Aux = nil
21980 return true
21981 }
21982
21983
21984
21985 for v.Op == OpARMCMPconst {
21986 if v.AuxInt != 0 {
21987 break
21988 }
21989 l := v.Args[0]
21990 if l.Op != OpARMSUBshiftRA {
21991 break
21992 }
21993 c := l.AuxInt
21994 y := l.Args[1]
21995 x := l.Args[0]
21996 if !(l.Uses == 1) {
21997 break
21998 }
21999 b.Kind = BlockARMEQ
22000 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags)
22001 v0.AuxInt = c
22002 v0.AddArg(x)
22003 v0.AddArg(y)
22004 b.SetControl(v0)
22005 b.Aux = nil
22006 return true
22007 }
22008
22009
22010
22011 for v.Op == OpARMCMPconst {
22012 if v.AuxInt != 0 {
22013 break
22014 }
22015 l := v.Args[0]
22016 if l.Op != OpARMSUBshiftLLreg {
22017 break
22018 }
22019 z := l.Args[2]
22020 x := l.Args[0]
22021 y := l.Args[1]
22022 if !(l.Uses == 1) {
22023 break
22024 }
22025 b.Kind = BlockARMEQ
22026 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
22027 v0.AddArg(x)
22028 v0.AddArg(y)
22029 v0.AddArg(z)
22030 b.SetControl(v0)
22031 b.Aux = nil
22032 return true
22033 }
22034
22035
22036
22037 for v.Op == OpARMCMPconst {
22038 if v.AuxInt != 0 {
22039 break
22040 }
22041 l := v.Args[0]
22042 if l.Op != OpARMSUBshiftRLreg {
22043 break
22044 }
22045 z := l.Args[2]
22046 x := l.Args[0]
22047 y := l.Args[1]
22048 if !(l.Uses == 1) {
22049 break
22050 }
22051 b.Kind = BlockARMEQ
22052 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
22053 v0.AddArg(x)
22054 v0.AddArg(y)
22055 v0.AddArg(z)
22056 b.SetControl(v0)
22057 b.Aux = nil
22058 return true
22059 }
22060
22061
22062
22063 for v.Op == OpARMCMPconst {
22064 if v.AuxInt != 0 {
22065 break
22066 }
22067 l := v.Args[0]
22068 if l.Op != OpARMSUBshiftRAreg {
22069 break
22070 }
22071 z := l.Args[2]
22072 x := l.Args[0]
22073 y := l.Args[1]
22074 if !(l.Uses == 1) {
22075 break
22076 }
22077 b.Kind = BlockARMEQ
22078 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
22079 v0.AddArg(x)
22080 v0.AddArg(y)
22081 v0.AddArg(z)
22082 b.SetControl(v0)
22083 b.Aux = nil
22084 return true
22085 }
22086
22087
22088
22089 for v.Op == OpARMCMPconst {
22090 if v.AuxInt != 0 {
22091 break
22092 }
22093 l := v.Args[0]
22094 if l.Op != OpARMADD {
22095 break
22096 }
22097 y := l.Args[1]
22098 x := l.Args[0]
22099 if !(l.Uses == 1) {
22100 break
22101 }
22102 b.Kind = BlockARMEQ
22103 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
22104 v0.AddArg(x)
22105 v0.AddArg(y)
22106 b.SetControl(v0)
22107 b.Aux = nil
22108 return true
22109 }
22110
22111
22112
22113 for v.Op == OpARMCMPconst {
22114 if v.AuxInt != 0 {
22115 break
22116 }
22117 l := v.Args[0]
22118 if l.Op != OpARMMULA {
22119 break
22120 }
22121 a := l.Args[2]
22122 x := l.Args[0]
22123 y := l.Args[1]
22124 if !(l.Uses == 1) {
22125 break
22126 }
22127 b.Kind = BlockARMEQ
22128 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
22129 v0.AddArg(a)
22130 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type)
22131 v1.AddArg(x)
22132 v1.AddArg(y)
22133 v0.AddArg(v1)
22134 b.SetControl(v0)
22135 b.Aux = nil
22136 return true
22137 }
22138
22139
22140
22141 for v.Op == OpARMCMPconst {
22142 if v.AuxInt != 0 {
22143 break
22144 }
22145 l := v.Args[0]
22146 if l.Op != OpARMADDconst {
22147 break
22148 }
22149 c := l.AuxInt
22150 x := l.Args[0]
22151 if !(l.Uses == 1) {
22152 break
22153 }
22154 b.Kind = BlockARMEQ
22155 v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags)
22156 v0.AuxInt = c
22157 v0.AddArg(x)
22158 b.SetControl(v0)
22159 b.Aux = nil
22160 return true
22161 }
22162
22163
22164
22165 for v.Op == OpARMCMPconst {
22166 if v.AuxInt != 0 {
22167 break
22168 }
22169 l := v.Args[0]
22170 if l.Op != OpARMADDshiftLL {
22171 break
22172 }
22173 c := l.AuxInt
22174 y := l.Args[1]
22175 x := l.Args[0]
22176 if !(l.Uses == 1) {
22177 break
22178 }
22179 b.Kind = BlockARMEQ
22180 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags)
22181 v0.AuxInt = c
22182 v0.AddArg(x)
22183 v0.AddArg(y)
22184 b.SetControl(v0)
22185 b.Aux = nil
22186 return true
22187 }
22188
22189
22190
22191 for v.Op == OpARMCMPconst {
22192 if v.AuxInt != 0 {
22193 break
22194 }
22195 l := v.Args[0]
22196 if l.Op != OpARMADDshiftRL {
22197 break
22198 }
22199 c := l.AuxInt
22200 y := l.Args[1]
22201 x := l.Args[0]
22202 if !(l.Uses == 1) {
22203 break
22204 }
22205 b.Kind = BlockARMEQ
22206 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags)
22207 v0.AuxInt = c
22208 v0.AddArg(x)
22209 v0.AddArg(y)
22210 b.SetControl(v0)
22211 b.Aux = nil
22212 return true
22213 }
22214
22215
22216
22217 for v.Op == OpARMCMPconst {
22218 if v.AuxInt != 0 {
22219 break
22220 }
22221 l := v.Args[0]
22222 if l.Op != OpARMADDshiftRA {
22223 break
22224 }
22225 c := l.AuxInt
22226 y := l.Args[1]
22227 x := l.Args[0]
22228 if !(l.Uses == 1) {
22229 break
22230 }
22231 b.Kind = BlockARMEQ
22232 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags)
22233 v0.AuxInt = c
22234 v0.AddArg(x)
22235 v0.AddArg(y)
22236 b.SetControl(v0)
22237 b.Aux = nil
22238 return true
22239 }
22240
22241
22242
22243 for v.Op == OpARMCMPconst {
22244 if v.AuxInt != 0 {
22245 break
22246 }
22247 l := v.Args[0]
22248 if l.Op != OpARMADDshiftLLreg {
22249 break
22250 }
22251 z := l.Args[2]
22252 x := l.Args[0]
22253 y := l.Args[1]
22254 if !(l.Uses == 1) {
22255 break
22256 }
22257 b.Kind = BlockARMEQ
22258 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
22259 v0.AddArg(x)
22260 v0.AddArg(y)
22261 v0.AddArg(z)
22262 b.SetControl(v0)
22263 b.Aux = nil
22264 return true
22265 }
22266
22267
22268
22269 for v.Op == OpARMCMPconst {
22270 if v.AuxInt != 0 {
22271 break
22272 }
22273 l := v.Args[0]
22274 if l.Op != OpARMADDshiftRLreg {
22275 break
22276 }
22277 z := l.Args[2]
22278 x := l.Args[0]
22279 y := l.Args[1]
22280 if !(l.Uses == 1) {
22281 break
22282 }
22283 b.Kind = BlockARMEQ
22284 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
22285 v0.AddArg(x)
22286 v0.AddArg(y)
22287 v0.AddArg(z)
22288 b.SetControl(v0)
22289 b.Aux = nil
22290 return true
22291 }
22292
22293
22294
22295 for v.Op == OpARMCMPconst {
22296 if v.AuxInt != 0 {
22297 break
22298 }
22299 l := v.Args[0]
22300 if l.Op != OpARMADDshiftRAreg {
22301 break
22302 }
22303 z := l.Args[2]
22304 x := l.Args[0]
22305 y := l.Args[1]
22306 if !(l.Uses == 1) {
22307 break
22308 }
22309 b.Kind = BlockARMEQ
22310 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
22311 v0.AddArg(x)
22312 v0.AddArg(y)
22313 v0.AddArg(z)
22314 b.SetControl(v0)
22315 b.Aux = nil
22316 return true
22317 }
22318
22319
22320
22321 for v.Op == OpARMCMPconst {
22322 if v.AuxInt != 0 {
22323 break
22324 }
22325 l := v.Args[0]
22326 if l.Op != OpARMAND {
22327 break
22328 }
22329 y := l.Args[1]
22330 x := l.Args[0]
22331 if !(l.Uses == 1) {
22332 break
22333 }
22334 b.Kind = BlockARMEQ
22335 v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags)
22336 v0.AddArg(x)
22337 v0.AddArg(y)
22338 b.SetControl(v0)
22339 b.Aux = nil
22340 return true
22341 }
22342
22343
22344
22345 for v.Op == OpARMCMPconst {
22346 if v.AuxInt != 0 {
22347 break
22348 }
22349 l := v.Args[0]
22350 if l.Op != OpARMANDconst {
22351 break
22352 }
22353 c := l.AuxInt
22354 x := l.Args[0]
22355 if !(l.Uses == 1) {
22356 break
22357 }
22358 b.Kind = BlockARMEQ
22359 v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags)
22360 v0.AuxInt = c
22361 v0.AddArg(x)
22362 b.SetControl(v0)
22363 b.Aux = nil
22364 return true
22365 }
22366
22367
22368
22369 for v.Op == OpARMCMPconst {
22370 if v.AuxInt != 0 {
22371 break
22372 }
22373 l := v.Args[0]
22374 if l.Op != OpARMANDshiftLL {
22375 break
22376 }
22377 c := l.AuxInt
22378 y := l.Args[1]
22379 x := l.Args[0]
22380 if !(l.Uses == 1) {
22381 break
22382 }
22383 b.Kind = BlockARMEQ
22384 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags)
22385 v0.AuxInt = c
22386 v0.AddArg(x)
22387 v0.AddArg(y)
22388 b.SetControl(v0)
22389 b.Aux = nil
22390 return true
22391 }
22392
22393
22394
22395 for v.Op == OpARMCMPconst {
22396 if v.AuxInt != 0 {
22397 break
22398 }
22399 l := v.Args[0]
22400 if l.Op != OpARMANDshiftRL {
22401 break
22402 }
22403 c := l.AuxInt
22404 y := l.Args[1]
22405 x := l.Args[0]
22406 if !(l.Uses == 1) {
22407 break
22408 }
22409 b.Kind = BlockARMEQ
22410 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags)
22411 v0.AuxInt = c
22412 v0.AddArg(x)
22413 v0.AddArg(y)
22414 b.SetControl(v0)
22415 b.Aux = nil
22416 return true
22417 }
22418
22419
22420
22421 for v.Op == OpARMCMPconst {
22422 if v.AuxInt != 0 {
22423 break
22424 }
22425 l := v.Args[0]
22426 if l.Op != OpARMANDshiftRA {
22427 break
22428 }
22429 c := l.AuxInt
22430 y := l.Args[1]
22431 x := l.Args[0]
22432 if !(l.Uses == 1) {
22433 break
22434 }
22435 b.Kind = BlockARMEQ
22436 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags)
22437 v0.AuxInt = c
22438 v0.AddArg(x)
22439 v0.AddArg(y)
22440 b.SetControl(v0)
22441 b.Aux = nil
22442 return true
22443 }
22444
22445
22446
22447 for v.Op == OpARMCMPconst {
22448 if v.AuxInt != 0 {
22449 break
22450 }
22451 l := v.Args[0]
22452 if l.Op != OpARMANDshiftLLreg {
22453 break
22454 }
22455 z := l.Args[2]
22456 x := l.Args[0]
22457 y := l.Args[1]
22458 if !(l.Uses == 1) {
22459 break
22460 }
22461 b.Kind = BlockARMEQ
22462 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
22463 v0.AddArg(x)
22464 v0.AddArg(y)
22465 v0.AddArg(z)
22466 b.SetControl(v0)
22467 b.Aux = nil
22468 return true
22469 }
22470
22471
22472
22473 for v.Op == OpARMCMPconst {
22474 if v.AuxInt != 0 {
22475 break
22476 }
22477 l := v.Args[0]
22478 if l.Op != OpARMANDshiftRLreg {
22479 break
22480 }
22481 z := l.Args[2]
22482 x := l.Args[0]
22483 y := l.Args[1]
22484 if !(l.Uses == 1) {
22485 break
22486 }
22487 b.Kind = BlockARMEQ
22488 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
22489 v0.AddArg(x)
22490 v0.AddArg(y)
22491 v0.AddArg(z)
22492 b.SetControl(v0)
22493 b.Aux = nil
22494 return true
22495 }
22496
22497
22498
22499 for v.Op == OpARMCMPconst {
22500 if v.AuxInt != 0 {
22501 break
22502 }
22503 l := v.Args[0]
22504 if l.Op != OpARMANDshiftRAreg {
22505 break
22506 }
22507 z := l.Args[2]
22508 x := l.Args[0]
22509 y := l.Args[1]
22510 if !(l.Uses == 1) {
22511 break
22512 }
22513 b.Kind = BlockARMEQ
22514 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
22515 v0.AddArg(x)
22516 v0.AddArg(y)
22517 v0.AddArg(z)
22518 b.SetControl(v0)
22519 b.Aux = nil
22520 return true
22521 }
22522
22523
22524
22525 for v.Op == OpARMCMPconst {
22526 if v.AuxInt != 0 {
22527 break
22528 }
22529 l := v.Args[0]
22530 if l.Op != OpARMXOR {
22531 break
22532 }
22533 y := l.Args[1]
22534 x := l.Args[0]
22535 if !(l.Uses == 1) {
22536 break
22537 }
22538 b.Kind = BlockARMEQ
22539 v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags)
22540 v0.AddArg(x)
22541 v0.AddArg(y)
22542 b.SetControl(v0)
22543 b.Aux = nil
22544 return true
22545 }
22546
22547
22548
22549 for v.Op == OpARMCMPconst {
22550 if v.AuxInt != 0 {
22551 break
22552 }
22553 l := v.Args[0]
22554 if l.Op != OpARMXORconst {
22555 break
22556 }
22557 c := l.AuxInt
22558 x := l.Args[0]
22559 if !(l.Uses == 1) {
22560 break
22561 }
22562 b.Kind = BlockARMEQ
22563 v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags)
22564 v0.AuxInt = c
22565 v0.AddArg(x)
22566 b.SetControl(v0)
22567 b.Aux = nil
22568 return true
22569 }
22570
22571
22572
22573 for v.Op == OpARMCMPconst {
22574 if v.AuxInt != 0 {
22575 break
22576 }
22577 l := v.Args[0]
22578 if l.Op != OpARMXORshiftLL {
22579 break
22580 }
22581 c := l.AuxInt
22582 y := l.Args[1]
22583 x := l.Args[0]
22584 if !(l.Uses == 1) {
22585 break
22586 }
22587 b.Kind = BlockARMEQ
22588 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags)
22589 v0.AuxInt = c
22590 v0.AddArg(x)
22591 v0.AddArg(y)
22592 b.SetControl(v0)
22593 b.Aux = nil
22594 return true
22595 }
22596
22597
22598
22599 for v.Op == OpARMCMPconst {
22600 if v.AuxInt != 0 {
22601 break
22602 }
22603 l := v.Args[0]
22604 if l.Op != OpARMXORshiftRL {
22605 break
22606 }
22607 c := l.AuxInt
22608 y := l.Args[1]
22609 x := l.Args[0]
22610 if !(l.Uses == 1) {
22611 break
22612 }
22613 b.Kind = BlockARMEQ
22614 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags)
22615 v0.AuxInt = c
22616 v0.AddArg(x)
22617 v0.AddArg(y)
22618 b.SetControl(v0)
22619 b.Aux = nil
22620 return true
22621 }
22622
22623
22624
22625 for v.Op == OpARMCMPconst {
22626 if v.AuxInt != 0 {
22627 break
22628 }
22629 l := v.Args[0]
22630 if l.Op != OpARMXORshiftRA {
22631 break
22632 }
22633 c := l.AuxInt
22634 y := l.Args[1]
22635 x := l.Args[0]
22636 if !(l.Uses == 1) {
22637 break
22638 }
22639 b.Kind = BlockARMEQ
22640 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags)
22641 v0.AuxInt = c
22642 v0.AddArg(x)
22643 v0.AddArg(y)
22644 b.SetControl(v0)
22645 b.Aux = nil
22646 return true
22647 }
22648
22649
22650
22651 for v.Op == OpARMCMPconst {
22652 if v.AuxInt != 0 {
22653 break
22654 }
22655 l := v.Args[0]
22656 if l.Op != OpARMXORshiftLLreg {
22657 break
22658 }
22659 z := l.Args[2]
22660 x := l.Args[0]
22661 y := l.Args[1]
22662 if !(l.Uses == 1) {
22663 break
22664 }
22665 b.Kind = BlockARMEQ
22666 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
22667 v0.AddArg(x)
22668 v0.AddArg(y)
22669 v0.AddArg(z)
22670 b.SetControl(v0)
22671 b.Aux = nil
22672 return true
22673 }
22674
22675
22676
22677 for v.Op == OpARMCMPconst {
22678 if v.AuxInt != 0 {
22679 break
22680 }
22681 l := v.Args[0]
22682 if l.Op != OpARMXORshiftRLreg {
22683 break
22684 }
22685 z := l.Args[2]
22686 x := l.Args[0]
22687 y := l.Args[1]
22688 if !(l.Uses == 1) {
22689 break
22690 }
22691 b.Kind = BlockARMEQ
22692 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
22693 v0.AddArg(x)
22694 v0.AddArg(y)
22695 v0.AddArg(z)
22696 b.SetControl(v0)
22697 b.Aux = nil
22698 return true
22699 }
22700
22701
22702
22703 for v.Op == OpARMCMPconst {
22704 if v.AuxInt != 0 {
22705 break
22706 }
22707 l := v.Args[0]
22708 if l.Op != OpARMXORshiftRAreg {
22709 break
22710 }
22711 z := l.Args[2]
22712 x := l.Args[0]
22713 y := l.Args[1]
22714 if !(l.Uses == 1) {
22715 break
22716 }
22717 b.Kind = BlockARMEQ
22718 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
22719 v0.AddArg(x)
22720 v0.AddArg(y)
22721 v0.AddArg(z)
22722 b.SetControl(v0)
22723 b.Aux = nil
22724 return true
22725 }
22726 case BlockARMGE:
22727
22728
22729
22730 for v.Op == OpARMFlagEQ {
22731 b.Kind = BlockFirst
22732 b.SetControl(nil)
22733 b.Aux = nil
22734 return true
22735 }
22736
22737
22738
22739 for v.Op == OpARMFlagLT_ULT {
22740 b.Kind = BlockFirst
22741 b.SetControl(nil)
22742 b.Aux = nil
22743 b.swapSuccessors()
22744 return true
22745 }
22746
22747
22748
22749 for v.Op == OpARMFlagLT_UGT {
22750 b.Kind = BlockFirst
22751 b.SetControl(nil)
22752 b.Aux = nil
22753 b.swapSuccessors()
22754 return true
22755 }
22756
22757
22758
22759 for v.Op == OpARMFlagGT_ULT {
22760 b.Kind = BlockFirst
22761 b.SetControl(nil)
22762 b.Aux = nil
22763 return true
22764 }
22765
22766
22767
22768 for v.Op == OpARMFlagGT_UGT {
22769 b.Kind = BlockFirst
22770 b.SetControl(nil)
22771 b.Aux = nil
22772 return true
22773 }
22774
22775
22776
22777 for v.Op == OpARMInvertFlags {
22778 cmp := v.Args[0]
22779 b.Kind = BlockARMLE
22780 b.SetControl(cmp)
22781 b.Aux = nil
22782 return true
22783 }
22784
22785
22786
22787 for v.Op == OpARMCMPconst {
22788 if v.AuxInt != 0 {
22789 break
22790 }
22791 l := v.Args[0]
22792 if l.Op != OpARMSUB {
22793 break
22794 }
22795 y := l.Args[1]
22796 x := l.Args[0]
22797 if !(l.Uses == 1) {
22798 break
22799 }
22800 b.Kind = BlockARMGE
22801 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
22802 v0.AddArg(x)
22803 v0.AddArg(y)
22804 b.SetControl(v0)
22805 b.Aux = nil
22806 return true
22807 }
22808
22809
22810
22811 for v.Op == OpARMCMPconst {
22812 if v.AuxInt != 0 {
22813 break
22814 }
22815 l := v.Args[0]
22816 if l.Op != OpARMMULS {
22817 break
22818 }
22819 a := l.Args[2]
22820 x := l.Args[0]
22821 y := l.Args[1]
22822 if !(l.Uses == 1) {
22823 break
22824 }
22825 b.Kind = BlockARMGE
22826 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
22827 v0.AddArg(a)
22828 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type)
22829 v1.AddArg(x)
22830 v1.AddArg(y)
22831 v0.AddArg(v1)
22832 b.SetControl(v0)
22833 b.Aux = nil
22834 return true
22835 }
22836
22837
22838
22839 for v.Op == OpARMCMPconst {
22840 if v.AuxInt != 0 {
22841 break
22842 }
22843 l := v.Args[0]
22844 if l.Op != OpARMSUBconst {
22845 break
22846 }
22847 c := l.AuxInt
22848 x := l.Args[0]
22849 if !(l.Uses == 1) {
22850 break
22851 }
22852 b.Kind = BlockARMGE
22853 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
22854 v0.AuxInt = c
22855 v0.AddArg(x)
22856 b.SetControl(v0)
22857 b.Aux = nil
22858 return true
22859 }
22860
22861
22862
22863 for v.Op == OpARMCMPconst {
22864 if v.AuxInt != 0 {
22865 break
22866 }
22867 l := v.Args[0]
22868 if l.Op != OpARMSUBshiftLL {
22869 break
22870 }
22871 c := l.AuxInt
22872 y := l.Args[1]
22873 x := l.Args[0]
22874 if !(l.Uses == 1) {
22875 break
22876 }
22877 b.Kind = BlockARMGE
22878 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags)
22879 v0.AuxInt = c
22880 v0.AddArg(x)
22881 v0.AddArg(y)
22882 b.SetControl(v0)
22883 b.Aux = nil
22884 return true
22885 }
22886
22887
22888
22889 for v.Op == OpARMCMPconst {
22890 if v.AuxInt != 0 {
22891 break
22892 }
22893 l := v.Args[0]
22894 if l.Op != OpARMSUBshiftRL {
22895 break
22896 }
22897 c := l.AuxInt
22898 y := l.Args[1]
22899 x := l.Args[0]
22900 if !(l.Uses == 1) {
22901 break
22902 }
22903 b.Kind = BlockARMGE
22904 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags)
22905 v0.AuxInt = c
22906 v0.AddArg(x)
22907 v0.AddArg(y)
22908 b.SetControl(v0)
22909 b.Aux = nil
22910 return true
22911 }
22912
22913
22914
22915 for v.Op == OpARMCMPconst {
22916 if v.AuxInt != 0 {
22917 break
22918 }
22919 l := v.Args[0]
22920 if l.Op != OpARMSUBshiftRA {
22921 break
22922 }
22923 c := l.AuxInt
22924 y := l.Args[1]
22925 x := l.Args[0]
22926 if !(l.Uses == 1) {
22927 break
22928 }
22929 b.Kind = BlockARMGE
22930 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags)
22931 v0.AuxInt = c
22932 v0.AddArg(x)
22933 v0.AddArg(y)
22934 b.SetControl(v0)
22935 b.Aux = nil
22936 return true
22937 }
22938
22939
22940
22941 for v.Op == OpARMCMPconst {
22942 if v.AuxInt != 0 {
22943 break
22944 }
22945 l := v.Args[0]
22946 if l.Op != OpARMSUBshiftLLreg {
22947 break
22948 }
22949 z := l.Args[2]
22950 x := l.Args[0]
22951 y := l.Args[1]
22952 if !(l.Uses == 1) {
22953 break
22954 }
22955 b.Kind = BlockARMGE
22956 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
22957 v0.AddArg(x)
22958 v0.AddArg(y)
22959 v0.AddArg(z)
22960 b.SetControl(v0)
22961 b.Aux = nil
22962 return true
22963 }
22964
22965
22966
22967 for v.Op == OpARMCMPconst {
22968 if v.AuxInt != 0 {
22969 break
22970 }
22971 l := v.Args[0]
22972 if l.Op != OpARMSUBshiftRLreg {
22973 break
22974 }
22975 z := l.Args[2]
22976 x := l.Args[0]
22977 y := l.Args[1]
22978 if !(l.Uses == 1) {
22979 break
22980 }
22981 b.Kind = BlockARMGE
22982 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
22983 v0.AddArg(x)
22984 v0.AddArg(y)
22985 v0.AddArg(z)
22986 b.SetControl(v0)
22987 b.Aux = nil
22988 return true
22989 }
22990
22991
22992
22993 for v.Op == OpARMCMPconst {
22994 if v.AuxInt != 0 {
22995 break
22996 }
22997 l := v.Args[0]
22998 if l.Op != OpARMSUBshiftRAreg {
22999 break
23000 }
23001 z := l.Args[2]
23002 x := l.Args[0]
23003 y := l.Args[1]
23004 if !(l.Uses == 1) {
23005 break
23006 }
23007 b.Kind = BlockARMGE
23008 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
23009 v0.AddArg(x)
23010 v0.AddArg(y)
23011 v0.AddArg(z)
23012 b.SetControl(v0)
23013 b.Aux = nil
23014 return true
23015 }
23016
23017
23018
23019 for v.Op == OpARMCMPconst {
23020 if v.AuxInt != 0 {
23021 break
23022 }
23023 l := v.Args[0]
23024 if l.Op != OpARMADD {
23025 break
23026 }
23027 y := l.Args[1]
23028 x := l.Args[0]
23029 if !(l.Uses == 1) {
23030 break
23031 }
23032 b.Kind = BlockARMGE
23033 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
23034 v0.AddArg(x)
23035 v0.AddArg(y)
23036 b.SetControl(v0)
23037 b.Aux = nil
23038 return true
23039 }
23040
23041
23042
23043 for v.Op == OpARMCMPconst {
23044 if v.AuxInt != 0 {
23045 break
23046 }
23047 l := v.Args[0]
23048 if l.Op != OpARMMULA {
23049 break
23050 }
23051 a := l.Args[2]
23052 x := l.Args[0]
23053 y := l.Args[1]
23054 if !(l.Uses == 1) {
23055 break
23056 }
23057 b.Kind = BlockARMGE
23058 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
23059 v0.AddArg(a)
23060 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type)
23061 v1.AddArg(x)
23062 v1.AddArg(y)
23063 v0.AddArg(v1)
23064 b.SetControl(v0)
23065 b.Aux = nil
23066 return true
23067 }
23068
23069
23070
23071 for v.Op == OpARMCMPconst {
23072 if v.AuxInt != 0 {
23073 break
23074 }
23075 l := v.Args[0]
23076 if l.Op != OpARMADDconst {
23077 break
23078 }
23079 c := l.AuxInt
23080 x := l.Args[0]
23081 if !(l.Uses == 1) {
23082 break
23083 }
23084 b.Kind = BlockARMGE
23085 v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags)
23086 v0.AuxInt = c
23087 v0.AddArg(x)
23088 b.SetControl(v0)
23089 b.Aux = nil
23090 return true
23091 }
23092
23093
23094
23095 for v.Op == OpARMCMPconst {
23096 if v.AuxInt != 0 {
23097 break
23098 }
23099 l := v.Args[0]
23100 if l.Op != OpARMADDshiftLL {
23101 break
23102 }
23103 c := l.AuxInt
23104 y := l.Args[1]
23105 x := l.Args[0]
23106 if !(l.Uses == 1) {
23107 break
23108 }
23109 b.Kind = BlockARMGE
23110 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags)
23111 v0.AuxInt = c
23112 v0.AddArg(x)
23113 v0.AddArg(y)
23114 b.SetControl(v0)
23115 b.Aux = nil
23116 return true
23117 }
23118
23119
23120
23121 for v.Op == OpARMCMPconst {
23122 if v.AuxInt != 0 {
23123 break
23124 }
23125 l := v.Args[0]
23126 if l.Op != OpARMADDshiftRL {
23127 break
23128 }
23129 c := l.AuxInt
23130 y := l.Args[1]
23131 x := l.Args[0]
23132 if !(l.Uses == 1) {
23133 break
23134 }
23135 b.Kind = BlockARMGE
23136 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags)
23137 v0.AuxInt = c
23138 v0.AddArg(x)
23139 v0.AddArg(y)
23140 b.SetControl(v0)
23141 b.Aux = nil
23142 return true
23143 }
23144
23145
23146
23147 for v.Op == OpARMCMPconst {
23148 if v.AuxInt != 0 {
23149 break
23150 }
23151 l := v.Args[0]
23152 if l.Op != OpARMADDshiftRA {
23153 break
23154 }
23155 c := l.AuxInt
23156 y := l.Args[1]
23157 x := l.Args[0]
23158 if !(l.Uses == 1) {
23159 break
23160 }
23161 b.Kind = BlockARMGE
23162 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags)
23163 v0.AuxInt = c
23164 v0.AddArg(x)
23165 v0.AddArg(y)
23166 b.SetControl(v0)
23167 b.Aux = nil
23168 return true
23169 }
23170
23171
23172
23173 for v.Op == OpARMCMPconst {
23174 if v.AuxInt != 0 {
23175 break
23176 }
23177 l := v.Args[0]
23178 if l.Op != OpARMADDshiftLLreg {
23179 break
23180 }
23181 z := l.Args[2]
23182 x := l.Args[0]
23183 y := l.Args[1]
23184 if !(l.Uses == 1) {
23185 break
23186 }
23187 b.Kind = BlockARMGE
23188 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
23189 v0.AddArg(x)
23190 v0.AddArg(y)
23191 v0.AddArg(z)
23192 b.SetControl(v0)
23193 b.Aux = nil
23194 return true
23195 }
23196
23197
23198
23199 for v.Op == OpARMCMPconst {
23200 if v.AuxInt != 0 {
23201 break
23202 }
23203 l := v.Args[0]
23204 if l.Op != OpARMADDshiftRLreg {
23205 break
23206 }
23207 z := l.Args[2]
23208 x := l.Args[0]
23209 y := l.Args[1]
23210 if !(l.Uses == 1) {
23211 break
23212 }
23213 b.Kind = BlockARMGE
23214 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
23215 v0.AddArg(x)
23216 v0.AddArg(y)
23217 v0.AddArg(z)
23218 b.SetControl(v0)
23219 b.Aux = nil
23220 return true
23221 }
23222
23223
23224
23225 for v.Op == OpARMCMPconst {
23226 if v.AuxInt != 0 {
23227 break
23228 }
23229 l := v.Args[0]
23230 if l.Op != OpARMADDshiftRAreg {
23231 break
23232 }
23233 z := l.Args[2]
23234 x := l.Args[0]
23235 y := l.Args[1]
23236 if !(l.Uses == 1) {
23237 break
23238 }
23239 b.Kind = BlockARMGE
23240 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
23241 v0.AddArg(x)
23242 v0.AddArg(y)
23243 v0.AddArg(z)
23244 b.SetControl(v0)
23245 b.Aux = nil
23246 return true
23247 }
23248
23249
23250
23251 for v.Op == OpARMCMPconst {
23252 if v.AuxInt != 0 {
23253 break
23254 }
23255 l := v.Args[0]
23256 if l.Op != OpARMAND {
23257 break
23258 }
23259 y := l.Args[1]
23260 x := l.Args[0]
23261 if !(l.Uses == 1) {
23262 break
23263 }
23264 b.Kind = BlockARMGE
23265 v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags)
23266 v0.AddArg(x)
23267 v0.AddArg(y)
23268 b.SetControl(v0)
23269 b.Aux = nil
23270 return true
23271 }
23272
23273
23274
23275 for v.Op == OpARMCMPconst {
23276 if v.AuxInt != 0 {
23277 break
23278 }
23279 l := v.Args[0]
23280 if l.Op != OpARMANDconst {
23281 break
23282 }
23283 c := l.AuxInt
23284 x := l.Args[0]
23285 if !(l.Uses == 1) {
23286 break
23287 }
23288 b.Kind = BlockARMGE
23289 v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags)
23290 v0.AuxInt = c
23291 v0.AddArg(x)
23292 b.SetControl(v0)
23293 b.Aux = nil
23294 return true
23295 }
23296
23297
23298
23299 for v.Op == OpARMCMPconst {
23300 if v.AuxInt != 0 {
23301 break
23302 }
23303 l := v.Args[0]
23304 if l.Op != OpARMANDshiftLL {
23305 break
23306 }
23307 c := l.AuxInt
23308 y := l.Args[1]
23309 x := l.Args[0]
23310 if !(l.Uses == 1) {
23311 break
23312 }
23313 b.Kind = BlockARMGE
23314 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags)
23315 v0.AuxInt = c
23316 v0.AddArg(x)
23317 v0.AddArg(y)
23318 b.SetControl(v0)
23319 b.Aux = nil
23320 return true
23321 }
23322
23323
23324
23325 for v.Op == OpARMCMPconst {
23326 if v.AuxInt != 0 {
23327 break
23328 }
23329 l := v.Args[0]
23330 if l.Op != OpARMANDshiftRL {
23331 break
23332 }
23333 c := l.AuxInt
23334 y := l.Args[1]
23335 x := l.Args[0]
23336 if !(l.Uses == 1) {
23337 break
23338 }
23339 b.Kind = BlockARMGE
23340 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags)
23341 v0.AuxInt = c
23342 v0.AddArg(x)
23343 v0.AddArg(y)
23344 b.SetControl(v0)
23345 b.Aux = nil
23346 return true
23347 }
23348
23349
23350
23351 for v.Op == OpARMCMPconst {
23352 if v.AuxInt != 0 {
23353 break
23354 }
23355 l := v.Args[0]
23356 if l.Op != OpARMANDshiftRA {
23357 break
23358 }
23359 c := l.AuxInt
23360 y := l.Args[1]
23361 x := l.Args[0]
23362 if !(l.Uses == 1) {
23363 break
23364 }
23365 b.Kind = BlockARMGE
23366 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags)
23367 v0.AuxInt = c
23368 v0.AddArg(x)
23369 v0.AddArg(y)
23370 b.SetControl(v0)
23371 b.Aux = nil
23372 return true
23373 }
23374
23375
23376
23377 for v.Op == OpARMCMPconst {
23378 if v.AuxInt != 0 {
23379 break
23380 }
23381 l := v.Args[0]
23382 if l.Op != OpARMANDshiftLLreg {
23383 break
23384 }
23385 z := l.Args[2]
23386 x := l.Args[0]
23387 y := l.Args[1]
23388 if !(l.Uses == 1) {
23389 break
23390 }
23391 b.Kind = BlockARMGE
23392 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
23393 v0.AddArg(x)
23394 v0.AddArg(y)
23395 v0.AddArg(z)
23396 b.SetControl(v0)
23397 b.Aux = nil
23398 return true
23399 }
23400
23401
23402
23403 for v.Op == OpARMCMPconst {
23404 if v.AuxInt != 0 {
23405 break
23406 }
23407 l := v.Args[0]
23408 if l.Op != OpARMANDshiftRLreg {
23409 break
23410 }
23411 z := l.Args[2]
23412 x := l.Args[0]
23413 y := l.Args[1]
23414 if !(l.Uses == 1) {
23415 break
23416 }
23417 b.Kind = BlockARMGE
23418 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
23419 v0.AddArg(x)
23420 v0.AddArg(y)
23421 v0.AddArg(z)
23422 b.SetControl(v0)
23423 b.Aux = nil
23424 return true
23425 }
23426
23427
23428
23429 for v.Op == OpARMCMPconst {
23430 if v.AuxInt != 0 {
23431 break
23432 }
23433 l := v.Args[0]
23434 if l.Op != OpARMANDshiftRAreg {
23435 break
23436 }
23437 z := l.Args[2]
23438 x := l.Args[0]
23439 y := l.Args[1]
23440 if !(l.Uses == 1) {
23441 break
23442 }
23443 b.Kind = BlockARMGE
23444 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
23445 v0.AddArg(x)
23446 v0.AddArg(y)
23447 v0.AddArg(z)
23448 b.SetControl(v0)
23449 b.Aux = nil
23450 return true
23451 }
23452
23453
23454
23455 for v.Op == OpARMCMPconst {
23456 if v.AuxInt != 0 {
23457 break
23458 }
23459 l := v.Args[0]
23460 if l.Op != OpARMXOR {
23461 break
23462 }
23463 y := l.Args[1]
23464 x := l.Args[0]
23465 if !(l.Uses == 1) {
23466 break
23467 }
23468 b.Kind = BlockARMGE
23469 v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags)
23470 v0.AddArg(x)
23471 v0.AddArg(y)
23472 b.SetControl(v0)
23473 b.Aux = nil
23474 return true
23475 }
23476
23477
23478
23479 for v.Op == OpARMCMPconst {
23480 if v.AuxInt != 0 {
23481 break
23482 }
23483 l := v.Args[0]
23484 if l.Op != OpARMXORconst {
23485 break
23486 }
23487 c := l.AuxInt
23488 x := l.Args[0]
23489 if !(l.Uses == 1) {
23490 break
23491 }
23492 b.Kind = BlockARMGE
23493 v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags)
23494 v0.AuxInt = c
23495 v0.AddArg(x)
23496 b.SetControl(v0)
23497 b.Aux = nil
23498 return true
23499 }
23500
23501
23502
23503 for v.Op == OpARMCMPconst {
23504 if v.AuxInt != 0 {
23505 break
23506 }
23507 l := v.Args[0]
23508 if l.Op != OpARMXORshiftLL {
23509 break
23510 }
23511 c := l.AuxInt
23512 y := l.Args[1]
23513 x := l.Args[0]
23514 if !(l.Uses == 1) {
23515 break
23516 }
23517 b.Kind = BlockARMGE
23518 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags)
23519 v0.AuxInt = c
23520 v0.AddArg(x)
23521 v0.AddArg(y)
23522 b.SetControl(v0)
23523 b.Aux = nil
23524 return true
23525 }
23526
23527
23528
23529 for v.Op == OpARMCMPconst {
23530 if v.AuxInt != 0 {
23531 break
23532 }
23533 l := v.Args[0]
23534 if l.Op != OpARMXORshiftRL {
23535 break
23536 }
23537 c := l.AuxInt
23538 y := l.Args[1]
23539 x := l.Args[0]
23540 if !(l.Uses == 1) {
23541 break
23542 }
23543 b.Kind = BlockARMGE
23544 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags)
23545 v0.AuxInt = c
23546 v0.AddArg(x)
23547 v0.AddArg(y)
23548 b.SetControl(v0)
23549 b.Aux = nil
23550 return true
23551 }
23552
23553
23554
23555 for v.Op == OpARMCMPconst {
23556 if v.AuxInt != 0 {
23557 break
23558 }
23559 l := v.Args[0]
23560 if l.Op != OpARMXORshiftRA {
23561 break
23562 }
23563 c := l.AuxInt
23564 y := l.Args[1]
23565 x := l.Args[0]
23566 if !(l.Uses == 1) {
23567 break
23568 }
23569 b.Kind = BlockARMGE
23570 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags)
23571 v0.AuxInt = c
23572 v0.AddArg(x)
23573 v0.AddArg(y)
23574 b.SetControl(v0)
23575 b.Aux = nil
23576 return true
23577 }
23578
23579
23580
23581 for v.Op == OpARMCMPconst {
23582 if v.AuxInt != 0 {
23583 break
23584 }
23585 l := v.Args[0]
23586 if l.Op != OpARMXORshiftLLreg {
23587 break
23588 }
23589 z := l.Args[2]
23590 x := l.Args[0]
23591 y := l.Args[1]
23592 if !(l.Uses == 1) {
23593 break
23594 }
23595 b.Kind = BlockARMGE
23596 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
23597 v0.AddArg(x)
23598 v0.AddArg(y)
23599 v0.AddArg(z)
23600 b.SetControl(v0)
23601 b.Aux = nil
23602 return true
23603 }
23604
23605
23606
23607 for v.Op == OpARMCMPconst {
23608 if v.AuxInt != 0 {
23609 break
23610 }
23611 l := v.Args[0]
23612 if l.Op != OpARMXORshiftRLreg {
23613 break
23614 }
23615 z := l.Args[2]
23616 x := l.Args[0]
23617 y := l.Args[1]
23618 if !(l.Uses == 1) {
23619 break
23620 }
23621 b.Kind = BlockARMGE
23622 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
23623 v0.AddArg(x)
23624 v0.AddArg(y)
23625 v0.AddArg(z)
23626 b.SetControl(v0)
23627 b.Aux = nil
23628 return true
23629 }
23630
23631
23632
23633 for v.Op == OpARMCMPconst {
23634 if v.AuxInt != 0 {
23635 break
23636 }
23637 l := v.Args[0]
23638 if l.Op != OpARMXORshiftRAreg {
23639 break
23640 }
23641 z := l.Args[2]
23642 x := l.Args[0]
23643 y := l.Args[1]
23644 if !(l.Uses == 1) {
23645 break
23646 }
23647 b.Kind = BlockARMGE
23648 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
23649 v0.AddArg(x)
23650 v0.AddArg(y)
23651 v0.AddArg(z)
23652 b.SetControl(v0)
23653 b.Aux = nil
23654 return true
23655 }
23656 case BlockARMGT:
23657
23658
23659
23660 for v.Op == OpARMFlagEQ {
23661 b.Kind = BlockFirst
23662 b.SetControl(nil)
23663 b.Aux = nil
23664 b.swapSuccessors()
23665 return true
23666 }
23667
23668
23669
23670 for v.Op == OpARMFlagLT_ULT {
23671 b.Kind = BlockFirst
23672 b.SetControl(nil)
23673 b.Aux = nil
23674 b.swapSuccessors()
23675 return true
23676 }
23677
23678
23679
23680 for v.Op == OpARMFlagLT_UGT {
23681 b.Kind = BlockFirst
23682 b.SetControl(nil)
23683 b.Aux = nil
23684 b.swapSuccessors()
23685 return true
23686 }
23687
23688
23689
23690 for v.Op == OpARMFlagGT_ULT {
23691 b.Kind = BlockFirst
23692 b.SetControl(nil)
23693 b.Aux = nil
23694 return true
23695 }
23696
23697
23698
23699 for v.Op == OpARMFlagGT_UGT {
23700 b.Kind = BlockFirst
23701 b.SetControl(nil)
23702 b.Aux = nil
23703 return true
23704 }
23705
23706
23707
23708 for v.Op == OpARMInvertFlags {
23709 cmp := v.Args[0]
23710 b.Kind = BlockARMLT
23711 b.SetControl(cmp)
23712 b.Aux = nil
23713 return true
23714 }
23715
23716
23717
23718 for v.Op == OpARMCMPconst {
23719 if v.AuxInt != 0 {
23720 break
23721 }
23722 l := v.Args[0]
23723 if l.Op != OpARMSUB {
23724 break
23725 }
23726 y := l.Args[1]
23727 x := l.Args[0]
23728 if !(l.Uses == 1) {
23729 break
23730 }
23731 b.Kind = BlockARMGT
23732 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
23733 v0.AddArg(x)
23734 v0.AddArg(y)
23735 b.SetControl(v0)
23736 b.Aux = nil
23737 return true
23738 }
23739
23740
23741
23742 for v.Op == OpARMCMPconst {
23743 if v.AuxInt != 0 {
23744 break
23745 }
23746 l := v.Args[0]
23747 if l.Op != OpARMMULS {
23748 break
23749 }
23750 a := l.Args[2]
23751 x := l.Args[0]
23752 y := l.Args[1]
23753 if !(l.Uses == 1) {
23754 break
23755 }
23756 b.Kind = BlockARMGT
23757 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
23758 v0.AddArg(a)
23759 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type)
23760 v1.AddArg(x)
23761 v1.AddArg(y)
23762 v0.AddArg(v1)
23763 b.SetControl(v0)
23764 b.Aux = nil
23765 return true
23766 }
23767
23768
23769
23770 for v.Op == OpARMCMPconst {
23771 if v.AuxInt != 0 {
23772 break
23773 }
23774 l := v.Args[0]
23775 if l.Op != OpARMSUBconst {
23776 break
23777 }
23778 c := l.AuxInt
23779 x := l.Args[0]
23780 if !(l.Uses == 1) {
23781 break
23782 }
23783 b.Kind = BlockARMGT
23784 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
23785 v0.AuxInt = c
23786 v0.AddArg(x)
23787 b.SetControl(v0)
23788 b.Aux = nil
23789 return true
23790 }
23791
23792
23793
23794 for v.Op == OpARMCMPconst {
23795 if v.AuxInt != 0 {
23796 break
23797 }
23798 l := v.Args[0]
23799 if l.Op != OpARMSUBshiftLL {
23800 break
23801 }
23802 c := l.AuxInt
23803 y := l.Args[1]
23804 x := l.Args[0]
23805 if !(l.Uses == 1) {
23806 break
23807 }
23808 b.Kind = BlockARMGT
23809 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags)
23810 v0.AuxInt = c
23811 v0.AddArg(x)
23812 v0.AddArg(y)
23813 b.SetControl(v0)
23814 b.Aux = nil
23815 return true
23816 }
23817
23818
23819
23820 for v.Op == OpARMCMPconst {
23821 if v.AuxInt != 0 {
23822 break
23823 }
23824 l := v.Args[0]
23825 if l.Op != OpARMSUBshiftRL {
23826 break
23827 }
23828 c := l.AuxInt
23829 y := l.Args[1]
23830 x := l.Args[0]
23831 if !(l.Uses == 1) {
23832 break
23833 }
23834 b.Kind = BlockARMGT
23835 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags)
23836 v0.AuxInt = c
23837 v0.AddArg(x)
23838 v0.AddArg(y)
23839 b.SetControl(v0)
23840 b.Aux = nil
23841 return true
23842 }
23843
23844
23845
23846 for v.Op == OpARMCMPconst {
23847 if v.AuxInt != 0 {
23848 break
23849 }
23850 l := v.Args[0]
23851 if l.Op != OpARMSUBshiftRA {
23852 break
23853 }
23854 c := l.AuxInt
23855 y := l.Args[1]
23856 x := l.Args[0]
23857 if !(l.Uses == 1) {
23858 break
23859 }
23860 b.Kind = BlockARMGT
23861 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags)
23862 v0.AuxInt = c
23863 v0.AddArg(x)
23864 v0.AddArg(y)
23865 b.SetControl(v0)
23866 b.Aux = nil
23867 return true
23868 }
23869
23870
23871
23872 for v.Op == OpARMCMPconst {
23873 if v.AuxInt != 0 {
23874 break
23875 }
23876 l := v.Args[0]
23877 if l.Op != OpARMSUBshiftLLreg {
23878 break
23879 }
23880 z := l.Args[2]
23881 x := l.Args[0]
23882 y := l.Args[1]
23883 if !(l.Uses == 1) {
23884 break
23885 }
23886 b.Kind = BlockARMGT
23887 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
23888 v0.AddArg(x)
23889 v0.AddArg(y)
23890 v0.AddArg(z)
23891 b.SetControl(v0)
23892 b.Aux = nil
23893 return true
23894 }
23895
23896
23897
23898 for v.Op == OpARMCMPconst {
23899 if v.AuxInt != 0 {
23900 break
23901 }
23902 l := v.Args[0]
23903 if l.Op != OpARMSUBshiftRLreg {
23904 break
23905 }
23906 z := l.Args[2]
23907 x := l.Args[0]
23908 y := l.Args[1]
23909 if !(l.Uses == 1) {
23910 break
23911 }
23912 b.Kind = BlockARMGT
23913 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
23914 v0.AddArg(x)
23915 v0.AddArg(y)
23916 v0.AddArg(z)
23917 b.SetControl(v0)
23918 b.Aux = nil
23919 return true
23920 }
23921
23922
23923
23924 for v.Op == OpARMCMPconst {
23925 if v.AuxInt != 0 {
23926 break
23927 }
23928 l := v.Args[0]
23929 if l.Op != OpARMSUBshiftRAreg {
23930 break
23931 }
23932 z := l.Args[2]
23933 x := l.Args[0]
23934 y := l.Args[1]
23935 if !(l.Uses == 1) {
23936 break
23937 }
23938 b.Kind = BlockARMGT
23939 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
23940 v0.AddArg(x)
23941 v0.AddArg(y)
23942 v0.AddArg(z)
23943 b.SetControl(v0)
23944 b.Aux = nil
23945 return true
23946 }
23947
23948
23949
23950 for v.Op == OpARMCMPconst {
23951 if v.AuxInt != 0 {
23952 break
23953 }
23954 l := v.Args[0]
23955 if l.Op != OpARMADD {
23956 break
23957 }
23958 y := l.Args[1]
23959 x := l.Args[0]
23960 if !(l.Uses == 1) {
23961 break
23962 }
23963 b.Kind = BlockARMGT
23964 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
23965 v0.AddArg(x)
23966 v0.AddArg(y)
23967 b.SetControl(v0)
23968 b.Aux = nil
23969 return true
23970 }
23971
23972
23973
23974 for v.Op == OpARMCMPconst {
23975 if v.AuxInt != 0 {
23976 break
23977 }
23978 l := v.Args[0]
23979 if l.Op != OpARMADDconst {
23980 break
23981 }
23982 c := l.AuxInt
23983 x := l.Args[0]
23984 if !(l.Uses == 1) {
23985 break
23986 }
23987 b.Kind = BlockARMGT
23988 v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags)
23989 v0.AuxInt = c
23990 v0.AddArg(x)
23991 b.SetControl(v0)
23992 b.Aux = nil
23993 return true
23994 }
23995
23996
23997
23998 for v.Op == OpARMCMPconst {
23999 if v.AuxInt != 0 {
24000 break
24001 }
24002 l := v.Args[0]
24003 if l.Op != OpARMADDshiftLL {
24004 break
24005 }
24006 c := l.AuxInt
24007 y := l.Args[1]
24008 x := l.Args[0]
24009 if !(l.Uses == 1) {
24010 break
24011 }
24012 b.Kind = BlockARMGT
24013 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags)
24014 v0.AuxInt = c
24015 v0.AddArg(x)
24016 v0.AddArg(y)
24017 b.SetControl(v0)
24018 b.Aux = nil
24019 return true
24020 }
24021
24022
24023
24024 for v.Op == OpARMCMPconst {
24025 if v.AuxInt != 0 {
24026 break
24027 }
24028 l := v.Args[0]
24029 if l.Op != OpARMADDshiftRL {
24030 break
24031 }
24032 c := l.AuxInt
24033 y := l.Args[1]
24034 x := l.Args[0]
24035 if !(l.Uses == 1) {
24036 break
24037 }
24038 b.Kind = BlockARMGT
24039 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags)
24040 v0.AuxInt = c
24041 v0.AddArg(x)
24042 v0.AddArg(y)
24043 b.SetControl(v0)
24044 b.Aux = nil
24045 return true
24046 }
24047
24048
24049
24050 for v.Op == OpARMCMPconst {
24051 if v.AuxInt != 0 {
24052 break
24053 }
24054 l := v.Args[0]
24055 if l.Op != OpARMADDshiftRA {
24056 break
24057 }
24058 c := l.AuxInt
24059 y := l.Args[1]
24060 x := l.Args[0]
24061 if !(l.Uses == 1) {
24062 break
24063 }
24064 b.Kind = BlockARMGT
24065 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags)
24066 v0.AuxInt = c
24067 v0.AddArg(x)
24068 v0.AddArg(y)
24069 b.SetControl(v0)
24070 b.Aux = nil
24071 return true
24072 }
24073
24074
24075
24076 for v.Op == OpARMCMPconst {
24077 if v.AuxInt != 0 {
24078 break
24079 }
24080 l := v.Args[0]
24081 if l.Op != OpARMADDshiftLLreg {
24082 break
24083 }
24084 z := l.Args[2]
24085 x := l.Args[0]
24086 y := l.Args[1]
24087 if !(l.Uses == 1) {
24088 break
24089 }
24090 b.Kind = BlockARMGT
24091 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
24092 v0.AddArg(x)
24093 v0.AddArg(y)
24094 v0.AddArg(z)
24095 b.SetControl(v0)
24096 b.Aux = nil
24097 return true
24098 }
24099
24100
24101
24102 for v.Op == OpARMCMPconst {
24103 if v.AuxInt != 0 {
24104 break
24105 }
24106 l := v.Args[0]
24107 if l.Op != OpARMADDshiftRLreg {
24108 break
24109 }
24110 z := l.Args[2]
24111 x := l.Args[0]
24112 y := l.Args[1]
24113 if !(l.Uses == 1) {
24114 break
24115 }
24116 b.Kind = BlockARMGT
24117 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
24118 v0.AddArg(x)
24119 v0.AddArg(y)
24120 v0.AddArg(z)
24121 b.SetControl(v0)
24122 b.Aux = nil
24123 return true
24124 }
24125
24126
24127
24128 for v.Op == OpARMCMPconst {
24129 if v.AuxInt != 0 {
24130 break
24131 }
24132 l := v.Args[0]
24133 if l.Op != OpARMADDshiftRAreg {
24134 break
24135 }
24136 z := l.Args[2]
24137 x := l.Args[0]
24138 y := l.Args[1]
24139 if !(l.Uses == 1) {
24140 break
24141 }
24142 b.Kind = BlockARMGT
24143 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
24144 v0.AddArg(x)
24145 v0.AddArg(y)
24146 v0.AddArg(z)
24147 b.SetControl(v0)
24148 b.Aux = nil
24149 return true
24150 }
24151
24152
24153
24154 for v.Op == OpARMCMPconst {
24155 if v.AuxInt != 0 {
24156 break
24157 }
24158 l := v.Args[0]
24159 if l.Op != OpARMAND {
24160 break
24161 }
24162 y := l.Args[1]
24163 x := l.Args[0]
24164 if !(l.Uses == 1) {
24165 break
24166 }
24167 b.Kind = BlockARMGT
24168 v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags)
24169 v0.AddArg(x)
24170 v0.AddArg(y)
24171 b.SetControl(v0)
24172 b.Aux = nil
24173 return true
24174 }
24175
24176
24177
24178 for v.Op == OpARMCMPconst {
24179 if v.AuxInt != 0 {
24180 break
24181 }
24182 l := v.Args[0]
24183 if l.Op != OpARMMULA {
24184 break
24185 }
24186 a := l.Args[2]
24187 x := l.Args[0]
24188 y := l.Args[1]
24189 if !(l.Uses == 1) {
24190 break
24191 }
24192 b.Kind = BlockARMGT
24193 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
24194 v0.AddArg(a)
24195 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type)
24196 v1.AddArg(x)
24197 v1.AddArg(y)
24198 v0.AddArg(v1)
24199 b.SetControl(v0)
24200 b.Aux = nil
24201 return true
24202 }
24203
24204
24205
24206 for v.Op == OpARMCMPconst {
24207 if v.AuxInt != 0 {
24208 break
24209 }
24210 l := v.Args[0]
24211 if l.Op != OpARMANDconst {
24212 break
24213 }
24214 c := l.AuxInt
24215 x := l.Args[0]
24216 if !(l.Uses == 1) {
24217 break
24218 }
24219 b.Kind = BlockARMGT
24220 v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags)
24221 v0.AuxInt = c
24222 v0.AddArg(x)
24223 b.SetControl(v0)
24224 b.Aux = nil
24225 return true
24226 }
24227
24228
24229
24230 for v.Op == OpARMCMPconst {
24231 if v.AuxInt != 0 {
24232 break
24233 }
24234 l := v.Args[0]
24235 if l.Op != OpARMANDshiftLL {
24236 break
24237 }
24238 c := l.AuxInt
24239 y := l.Args[1]
24240 x := l.Args[0]
24241 if !(l.Uses == 1) {
24242 break
24243 }
24244 b.Kind = BlockARMGT
24245 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags)
24246 v0.AuxInt = c
24247 v0.AddArg(x)
24248 v0.AddArg(y)
24249 b.SetControl(v0)
24250 b.Aux = nil
24251 return true
24252 }
24253
24254
24255
24256 for v.Op == OpARMCMPconst {
24257 if v.AuxInt != 0 {
24258 break
24259 }
24260 l := v.Args[0]
24261 if l.Op != OpARMANDshiftRL {
24262 break
24263 }
24264 c := l.AuxInt
24265 y := l.Args[1]
24266 x := l.Args[0]
24267 if !(l.Uses == 1) {
24268 break
24269 }
24270 b.Kind = BlockARMGT
24271 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags)
24272 v0.AuxInt = c
24273 v0.AddArg(x)
24274 v0.AddArg(y)
24275 b.SetControl(v0)
24276 b.Aux = nil
24277 return true
24278 }
24279
24280
24281
24282 for v.Op == OpARMCMPconst {
24283 if v.AuxInt != 0 {
24284 break
24285 }
24286 l := v.Args[0]
24287 if l.Op != OpARMANDshiftRA {
24288 break
24289 }
24290 c := l.AuxInt
24291 y := l.Args[1]
24292 x := l.Args[0]
24293 if !(l.Uses == 1) {
24294 break
24295 }
24296 b.Kind = BlockARMGT
24297 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags)
24298 v0.AuxInt = c
24299 v0.AddArg(x)
24300 v0.AddArg(y)
24301 b.SetControl(v0)
24302 b.Aux = nil
24303 return true
24304 }
24305
24306
24307
24308 for v.Op == OpARMCMPconst {
24309 if v.AuxInt != 0 {
24310 break
24311 }
24312 l := v.Args[0]
24313 if l.Op != OpARMANDshiftLLreg {
24314 break
24315 }
24316 z := l.Args[2]
24317 x := l.Args[0]
24318 y := l.Args[1]
24319 if !(l.Uses == 1) {
24320 break
24321 }
24322 b.Kind = BlockARMGT
24323 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
24324 v0.AddArg(x)
24325 v0.AddArg(y)
24326 v0.AddArg(z)
24327 b.SetControl(v0)
24328 b.Aux = nil
24329 return true
24330 }
24331
24332
24333
24334 for v.Op == OpARMCMPconst {
24335 if v.AuxInt != 0 {
24336 break
24337 }
24338 l := v.Args[0]
24339 if l.Op != OpARMANDshiftRLreg {
24340 break
24341 }
24342 z := l.Args[2]
24343 x := l.Args[0]
24344 y := l.Args[1]
24345 if !(l.Uses == 1) {
24346 break
24347 }
24348 b.Kind = BlockARMGT
24349 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
24350 v0.AddArg(x)
24351 v0.AddArg(y)
24352 v0.AddArg(z)
24353 b.SetControl(v0)
24354 b.Aux = nil
24355 return true
24356 }
24357
24358
24359
24360 for v.Op == OpARMCMPconst {
24361 if v.AuxInt != 0 {
24362 break
24363 }
24364 l := v.Args[0]
24365 if l.Op != OpARMANDshiftRAreg {
24366 break
24367 }
24368 z := l.Args[2]
24369 x := l.Args[0]
24370 y := l.Args[1]
24371 if !(l.Uses == 1) {
24372 break
24373 }
24374 b.Kind = BlockARMGT
24375 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
24376 v0.AddArg(x)
24377 v0.AddArg(y)
24378 v0.AddArg(z)
24379 b.SetControl(v0)
24380 b.Aux = nil
24381 return true
24382 }
24383
24384
24385
24386 for v.Op == OpARMCMPconst {
24387 if v.AuxInt != 0 {
24388 break
24389 }
24390 l := v.Args[0]
24391 if l.Op != OpARMXOR {
24392 break
24393 }
24394 y := l.Args[1]
24395 x := l.Args[0]
24396 if !(l.Uses == 1) {
24397 break
24398 }
24399 b.Kind = BlockARMGT
24400 v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags)
24401 v0.AddArg(x)
24402 v0.AddArg(y)
24403 b.SetControl(v0)
24404 b.Aux = nil
24405 return true
24406 }
24407
24408
24409
24410 for v.Op == OpARMCMPconst {
24411 if v.AuxInt != 0 {
24412 break
24413 }
24414 l := v.Args[0]
24415 if l.Op != OpARMXORconst {
24416 break
24417 }
24418 c := l.AuxInt
24419 x := l.Args[0]
24420 if !(l.Uses == 1) {
24421 break
24422 }
24423 b.Kind = BlockARMGT
24424 v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags)
24425 v0.AuxInt = c
24426 v0.AddArg(x)
24427 b.SetControl(v0)
24428 b.Aux = nil
24429 return true
24430 }
24431
24432
24433
24434 for v.Op == OpARMCMPconst {
24435 if v.AuxInt != 0 {
24436 break
24437 }
24438 l := v.Args[0]
24439 if l.Op != OpARMXORshiftLL {
24440 break
24441 }
24442 c := l.AuxInt
24443 y := l.Args[1]
24444 x := l.Args[0]
24445 if !(l.Uses == 1) {
24446 break
24447 }
24448 b.Kind = BlockARMGT
24449 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags)
24450 v0.AuxInt = c
24451 v0.AddArg(x)
24452 v0.AddArg(y)
24453 b.SetControl(v0)
24454 b.Aux = nil
24455 return true
24456 }
24457
24458
24459
24460 for v.Op == OpARMCMPconst {
24461 if v.AuxInt != 0 {
24462 break
24463 }
24464 l := v.Args[0]
24465 if l.Op != OpARMXORshiftRL {
24466 break
24467 }
24468 c := l.AuxInt
24469 y := l.Args[1]
24470 x := l.Args[0]
24471 if !(l.Uses == 1) {
24472 break
24473 }
24474 b.Kind = BlockARMGT
24475 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags)
24476 v0.AuxInt = c
24477 v0.AddArg(x)
24478 v0.AddArg(y)
24479 b.SetControl(v0)
24480 b.Aux = nil
24481 return true
24482 }
24483
24484
24485
24486 for v.Op == OpARMCMPconst {
24487 if v.AuxInt != 0 {
24488 break
24489 }
24490 l := v.Args[0]
24491 if l.Op != OpARMXORshiftRA {
24492 break
24493 }
24494 c := l.AuxInt
24495 y := l.Args[1]
24496 x := l.Args[0]
24497 if !(l.Uses == 1) {
24498 break
24499 }
24500 b.Kind = BlockARMGT
24501 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags)
24502 v0.AuxInt = c
24503 v0.AddArg(x)
24504 v0.AddArg(y)
24505 b.SetControl(v0)
24506 b.Aux = nil
24507 return true
24508 }
24509
24510
24511
24512 for v.Op == OpARMCMPconst {
24513 if v.AuxInt != 0 {
24514 break
24515 }
24516 l := v.Args[0]
24517 if l.Op != OpARMXORshiftLLreg {
24518 break
24519 }
24520 z := l.Args[2]
24521 x := l.Args[0]
24522 y := l.Args[1]
24523 if !(l.Uses == 1) {
24524 break
24525 }
24526 b.Kind = BlockARMGT
24527 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
24528 v0.AddArg(x)
24529 v0.AddArg(y)
24530 v0.AddArg(z)
24531 b.SetControl(v0)
24532 b.Aux = nil
24533 return true
24534 }
24535
24536
24537
24538 for v.Op == OpARMCMPconst {
24539 if v.AuxInt != 0 {
24540 break
24541 }
24542 l := v.Args[0]
24543 if l.Op != OpARMXORshiftRLreg {
24544 break
24545 }
24546 z := l.Args[2]
24547 x := l.Args[0]
24548 y := l.Args[1]
24549 if !(l.Uses == 1) {
24550 break
24551 }
24552 b.Kind = BlockARMGT
24553 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
24554 v0.AddArg(x)
24555 v0.AddArg(y)
24556 v0.AddArg(z)
24557 b.SetControl(v0)
24558 b.Aux = nil
24559 return true
24560 }
24561
24562
24563
24564 for v.Op == OpARMCMPconst {
24565 if v.AuxInt != 0 {
24566 break
24567 }
24568 l := v.Args[0]
24569 if l.Op != OpARMXORshiftRAreg {
24570 break
24571 }
24572 z := l.Args[2]
24573 x := l.Args[0]
24574 y := l.Args[1]
24575 if !(l.Uses == 1) {
24576 break
24577 }
24578 b.Kind = BlockARMGT
24579 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
24580 v0.AddArg(x)
24581 v0.AddArg(y)
24582 v0.AddArg(z)
24583 b.SetControl(v0)
24584 b.Aux = nil
24585 return true
24586 }
24587 case BlockIf:
24588
24589
24590
24591 for v.Op == OpARMEqual {
24592 cc := v.Args[0]
24593 b.Kind = BlockARMEQ
24594 b.SetControl(cc)
24595 b.Aux = nil
24596 return true
24597 }
24598
24599
24600
24601 for v.Op == OpARMNotEqual {
24602 cc := v.Args[0]
24603 b.Kind = BlockARMNE
24604 b.SetControl(cc)
24605 b.Aux = nil
24606 return true
24607 }
24608
24609
24610
24611 for v.Op == OpARMLessThan {
24612 cc := v.Args[0]
24613 b.Kind = BlockARMLT
24614 b.SetControl(cc)
24615 b.Aux = nil
24616 return true
24617 }
24618
24619
24620
24621 for v.Op == OpARMLessThanU {
24622 cc := v.Args[0]
24623 b.Kind = BlockARMULT
24624 b.SetControl(cc)
24625 b.Aux = nil
24626 return true
24627 }
24628
24629
24630
24631 for v.Op == OpARMLessEqual {
24632 cc := v.Args[0]
24633 b.Kind = BlockARMLE
24634 b.SetControl(cc)
24635 b.Aux = nil
24636 return true
24637 }
24638
24639
24640
24641 for v.Op == OpARMLessEqualU {
24642 cc := v.Args[0]
24643 b.Kind = BlockARMULE
24644 b.SetControl(cc)
24645 b.Aux = nil
24646 return true
24647 }
24648
24649
24650
24651 for v.Op == OpARMGreaterThan {
24652 cc := v.Args[0]
24653 b.Kind = BlockARMGT
24654 b.SetControl(cc)
24655 b.Aux = nil
24656 return true
24657 }
24658
24659
24660
24661 for v.Op == OpARMGreaterThanU {
24662 cc := v.Args[0]
24663 b.Kind = BlockARMUGT
24664 b.SetControl(cc)
24665 b.Aux = nil
24666 return true
24667 }
24668
24669
24670
24671 for v.Op == OpARMGreaterEqual {
24672 cc := v.Args[0]
24673 b.Kind = BlockARMGE
24674 b.SetControl(cc)
24675 b.Aux = nil
24676 return true
24677 }
24678
24679
24680
24681 for v.Op == OpARMGreaterEqualU {
24682 cc := v.Args[0]
24683 b.Kind = BlockARMUGE
24684 b.SetControl(cc)
24685 b.Aux = nil
24686 return true
24687 }
24688
24689
24690
24691 for {
24692 cond := b.Control
24693 b.Kind = BlockARMNE
24694 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
24695 v0.AuxInt = 0
24696 v0.AddArg(cond)
24697 b.SetControl(v0)
24698 b.Aux = nil
24699 return true
24700 }
24701 case BlockARMLE:
24702
24703
24704
24705 for v.Op == OpARMFlagEQ {
24706 b.Kind = BlockFirst
24707 b.SetControl(nil)
24708 b.Aux = nil
24709 return true
24710 }
24711
24712
24713
24714 for v.Op == OpARMFlagLT_ULT {
24715 b.Kind = BlockFirst
24716 b.SetControl(nil)
24717 b.Aux = nil
24718 return true
24719 }
24720
24721
24722
24723 for v.Op == OpARMFlagLT_UGT {
24724 b.Kind = BlockFirst
24725 b.SetControl(nil)
24726 b.Aux = nil
24727 return true
24728 }
24729
24730
24731
24732 for v.Op == OpARMFlagGT_ULT {
24733 b.Kind = BlockFirst
24734 b.SetControl(nil)
24735 b.Aux = nil
24736 b.swapSuccessors()
24737 return true
24738 }
24739
24740
24741
24742 for v.Op == OpARMFlagGT_UGT {
24743 b.Kind = BlockFirst
24744 b.SetControl(nil)
24745 b.Aux = nil
24746 b.swapSuccessors()
24747 return true
24748 }
24749
24750
24751
24752 for v.Op == OpARMInvertFlags {
24753 cmp := v.Args[0]
24754 b.Kind = BlockARMGE
24755 b.SetControl(cmp)
24756 b.Aux = nil
24757 return true
24758 }
24759
24760
24761
24762 for v.Op == OpARMCMPconst {
24763 if v.AuxInt != 0 {
24764 break
24765 }
24766 l := v.Args[0]
24767 if l.Op != OpARMSUB {
24768 break
24769 }
24770 y := l.Args[1]
24771 x := l.Args[0]
24772 if !(l.Uses == 1) {
24773 break
24774 }
24775 b.Kind = BlockARMLE
24776 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
24777 v0.AddArg(x)
24778 v0.AddArg(y)
24779 b.SetControl(v0)
24780 b.Aux = nil
24781 return true
24782 }
24783
24784
24785
24786 for v.Op == OpARMCMPconst {
24787 if v.AuxInt != 0 {
24788 break
24789 }
24790 l := v.Args[0]
24791 if l.Op != OpARMMULS {
24792 break
24793 }
24794 a := l.Args[2]
24795 x := l.Args[0]
24796 y := l.Args[1]
24797 if !(l.Uses == 1) {
24798 break
24799 }
24800 b.Kind = BlockARMLE
24801 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
24802 v0.AddArg(a)
24803 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type)
24804 v1.AddArg(x)
24805 v1.AddArg(y)
24806 v0.AddArg(v1)
24807 b.SetControl(v0)
24808 b.Aux = nil
24809 return true
24810 }
24811
24812
24813
24814 for v.Op == OpARMCMPconst {
24815 if v.AuxInt != 0 {
24816 break
24817 }
24818 l := v.Args[0]
24819 if l.Op != OpARMSUBconst {
24820 break
24821 }
24822 c := l.AuxInt
24823 x := l.Args[0]
24824 if !(l.Uses == 1) {
24825 break
24826 }
24827 b.Kind = BlockARMLE
24828 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
24829 v0.AuxInt = c
24830 v0.AddArg(x)
24831 b.SetControl(v0)
24832 b.Aux = nil
24833 return true
24834 }
24835
24836
24837
24838 for v.Op == OpARMCMPconst {
24839 if v.AuxInt != 0 {
24840 break
24841 }
24842 l := v.Args[0]
24843 if l.Op != OpARMSUBshiftLL {
24844 break
24845 }
24846 c := l.AuxInt
24847 y := l.Args[1]
24848 x := l.Args[0]
24849 if !(l.Uses == 1) {
24850 break
24851 }
24852 b.Kind = BlockARMLE
24853 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags)
24854 v0.AuxInt = c
24855 v0.AddArg(x)
24856 v0.AddArg(y)
24857 b.SetControl(v0)
24858 b.Aux = nil
24859 return true
24860 }
24861
24862
24863
24864 for v.Op == OpARMCMPconst {
24865 if v.AuxInt != 0 {
24866 break
24867 }
24868 l := v.Args[0]
24869 if l.Op != OpARMSUBshiftRL {
24870 break
24871 }
24872 c := l.AuxInt
24873 y := l.Args[1]
24874 x := l.Args[0]
24875 if !(l.Uses == 1) {
24876 break
24877 }
24878 b.Kind = BlockARMLE
24879 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags)
24880 v0.AuxInt = c
24881 v0.AddArg(x)
24882 v0.AddArg(y)
24883 b.SetControl(v0)
24884 b.Aux = nil
24885 return true
24886 }
24887
24888
24889
24890 for v.Op == OpARMCMPconst {
24891 if v.AuxInt != 0 {
24892 break
24893 }
24894 l := v.Args[0]
24895 if l.Op != OpARMSUBshiftRA {
24896 break
24897 }
24898 c := l.AuxInt
24899 y := l.Args[1]
24900 x := l.Args[0]
24901 if !(l.Uses == 1) {
24902 break
24903 }
24904 b.Kind = BlockARMLE
24905 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags)
24906 v0.AuxInt = c
24907 v0.AddArg(x)
24908 v0.AddArg(y)
24909 b.SetControl(v0)
24910 b.Aux = nil
24911 return true
24912 }
24913
24914
24915
24916 for v.Op == OpARMCMPconst {
24917 if v.AuxInt != 0 {
24918 break
24919 }
24920 l := v.Args[0]
24921 if l.Op != OpARMSUBshiftLLreg {
24922 break
24923 }
24924 z := l.Args[2]
24925 x := l.Args[0]
24926 y := l.Args[1]
24927 if !(l.Uses == 1) {
24928 break
24929 }
24930 b.Kind = BlockARMLE
24931 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
24932 v0.AddArg(x)
24933 v0.AddArg(y)
24934 v0.AddArg(z)
24935 b.SetControl(v0)
24936 b.Aux = nil
24937 return true
24938 }
24939
24940
24941
24942 for v.Op == OpARMCMPconst {
24943 if v.AuxInt != 0 {
24944 break
24945 }
24946 l := v.Args[0]
24947 if l.Op != OpARMSUBshiftRLreg {
24948 break
24949 }
24950 z := l.Args[2]
24951 x := l.Args[0]
24952 y := l.Args[1]
24953 if !(l.Uses == 1) {
24954 break
24955 }
24956 b.Kind = BlockARMLE
24957 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
24958 v0.AddArg(x)
24959 v0.AddArg(y)
24960 v0.AddArg(z)
24961 b.SetControl(v0)
24962 b.Aux = nil
24963 return true
24964 }
24965
24966
24967
24968 for v.Op == OpARMCMPconst {
24969 if v.AuxInt != 0 {
24970 break
24971 }
24972 l := v.Args[0]
24973 if l.Op != OpARMSUBshiftRAreg {
24974 break
24975 }
24976 z := l.Args[2]
24977 x := l.Args[0]
24978 y := l.Args[1]
24979 if !(l.Uses == 1) {
24980 break
24981 }
24982 b.Kind = BlockARMLE
24983 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
24984 v0.AddArg(x)
24985 v0.AddArg(y)
24986 v0.AddArg(z)
24987 b.SetControl(v0)
24988 b.Aux = nil
24989 return true
24990 }
24991
24992
24993
24994 for v.Op == OpARMCMPconst {
24995 if v.AuxInt != 0 {
24996 break
24997 }
24998 l := v.Args[0]
24999 if l.Op != OpARMADD {
25000 break
25001 }
25002 y := l.Args[1]
25003 x := l.Args[0]
25004 if !(l.Uses == 1) {
25005 break
25006 }
25007 b.Kind = BlockARMLE
25008 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
25009 v0.AddArg(x)
25010 v0.AddArg(y)
25011 b.SetControl(v0)
25012 b.Aux = nil
25013 return true
25014 }
25015
25016
25017
25018 for v.Op == OpARMCMPconst {
25019 if v.AuxInt != 0 {
25020 break
25021 }
25022 l := v.Args[0]
25023 if l.Op != OpARMMULA {
25024 break
25025 }
25026 a := l.Args[2]
25027 x := l.Args[0]
25028 y := l.Args[1]
25029 if !(l.Uses == 1) {
25030 break
25031 }
25032 b.Kind = BlockARMLE
25033 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
25034 v0.AddArg(a)
25035 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type)
25036 v1.AddArg(x)
25037 v1.AddArg(y)
25038 v0.AddArg(v1)
25039 b.SetControl(v0)
25040 b.Aux = nil
25041 return true
25042 }
25043
25044
25045
25046 for v.Op == OpARMCMPconst {
25047 if v.AuxInt != 0 {
25048 break
25049 }
25050 l := v.Args[0]
25051 if l.Op != OpARMADDconst {
25052 break
25053 }
25054 c := l.AuxInt
25055 x := l.Args[0]
25056 if !(l.Uses == 1) {
25057 break
25058 }
25059 b.Kind = BlockARMLE
25060 v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags)
25061 v0.AuxInt = c
25062 v0.AddArg(x)
25063 b.SetControl(v0)
25064 b.Aux = nil
25065 return true
25066 }
25067
25068
25069
25070 for v.Op == OpARMCMPconst {
25071 if v.AuxInt != 0 {
25072 break
25073 }
25074 l := v.Args[0]
25075 if l.Op != OpARMADDshiftLL {
25076 break
25077 }
25078 c := l.AuxInt
25079 y := l.Args[1]
25080 x := l.Args[0]
25081 if !(l.Uses == 1) {
25082 break
25083 }
25084 b.Kind = BlockARMLE
25085 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags)
25086 v0.AuxInt = c
25087 v0.AddArg(x)
25088 v0.AddArg(y)
25089 b.SetControl(v0)
25090 b.Aux = nil
25091 return true
25092 }
25093
25094
25095
25096 for v.Op == OpARMCMPconst {
25097 if v.AuxInt != 0 {
25098 break
25099 }
25100 l := v.Args[0]
25101 if l.Op != OpARMADDshiftRL {
25102 break
25103 }
25104 c := l.AuxInt
25105 y := l.Args[1]
25106 x := l.Args[0]
25107 if !(l.Uses == 1) {
25108 break
25109 }
25110 b.Kind = BlockARMLE
25111 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags)
25112 v0.AuxInt = c
25113 v0.AddArg(x)
25114 v0.AddArg(y)
25115 b.SetControl(v0)
25116 b.Aux = nil
25117 return true
25118 }
25119
25120
25121
25122 for v.Op == OpARMCMPconst {
25123 if v.AuxInt != 0 {
25124 break
25125 }
25126 l := v.Args[0]
25127 if l.Op != OpARMADDshiftRA {
25128 break
25129 }
25130 c := l.AuxInt
25131 y := l.Args[1]
25132 x := l.Args[0]
25133 if !(l.Uses == 1) {
25134 break
25135 }
25136 b.Kind = BlockARMLE
25137 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags)
25138 v0.AuxInt = c
25139 v0.AddArg(x)
25140 v0.AddArg(y)
25141 b.SetControl(v0)
25142 b.Aux = nil
25143 return true
25144 }
25145
25146
25147
25148 for v.Op == OpARMCMPconst {
25149 if v.AuxInt != 0 {
25150 break
25151 }
25152 l := v.Args[0]
25153 if l.Op != OpARMADDshiftLLreg {
25154 break
25155 }
25156 z := l.Args[2]
25157 x := l.Args[0]
25158 y := l.Args[1]
25159 if !(l.Uses == 1) {
25160 break
25161 }
25162 b.Kind = BlockARMLE
25163 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
25164 v0.AddArg(x)
25165 v0.AddArg(y)
25166 v0.AddArg(z)
25167 b.SetControl(v0)
25168 b.Aux = nil
25169 return true
25170 }
25171
25172
25173
25174 for v.Op == OpARMCMPconst {
25175 if v.AuxInt != 0 {
25176 break
25177 }
25178 l := v.Args[0]
25179 if l.Op != OpARMADDshiftRLreg {
25180 break
25181 }
25182 z := l.Args[2]
25183 x := l.Args[0]
25184 y := l.Args[1]
25185 if !(l.Uses == 1) {
25186 break
25187 }
25188 b.Kind = BlockARMLE
25189 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
25190 v0.AddArg(x)
25191 v0.AddArg(y)
25192 v0.AddArg(z)
25193 b.SetControl(v0)
25194 b.Aux = nil
25195 return true
25196 }
25197
25198
25199
25200 for v.Op == OpARMCMPconst {
25201 if v.AuxInt != 0 {
25202 break
25203 }
25204 l := v.Args[0]
25205 if l.Op != OpARMADDshiftRAreg {
25206 break
25207 }
25208 z := l.Args[2]
25209 x := l.Args[0]
25210 y := l.Args[1]
25211 if !(l.Uses == 1) {
25212 break
25213 }
25214 b.Kind = BlockARMLE
25215 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
25216 v0.AddArg(x)
25217 v0.AddArg(y)
25218 v0.AddArg(z)
25219 b.SetControl(v0)
25220 b.Aux = nil
25221 return true
25222 }
25223
25224
25225
25226 for v.Op == OpARMCMPconst {
25227 if v.AuxInt != 0 {
25228 break
25229 }
25230 l := v.Args[0]
25231 if l.Op != OpARMAND {
25232 break
25233 }
25234 y := l.Args[1]
25235 x := l.Args[0]
25236 if !(l.Uses == 1) {
25237 break
25238 }
25239 b.Kind = BlockARMLE
25240 v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags)
25241 v0.AddArg(x)
25242 v0.AddArg(y)
25243 b.SetControl(v0)
25244 b.Aux = nil
25245 return true
25246 }
25247
25248
25249
25250 for v.Op == OpARMCMPconst {
25251 if v.AuxInt != 0 {
25252 break
25253 }
25254 l := v.Args[0]
25255 if l.Op != OpARMANDconst {
25256 break
25257 }
25258 c := l.AuxInt
25259 x := l.Args[0]
25260 if !(l.Uses == 1) {
25261 break
25262 }
25263 b.Kind = BlockARMLE
25264 v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags)
25265 v0.AuxInt = c
25266 v0.AddArg(x)
25267 b.SetControl(v0)
25268 b.Aux = nil
25269 return true
25270 }
25271
25272
25273
25274 for v.Op == OpARMCMPconst {
25275 if v.AuxInt != 0 {
25276 break
25277 }
25278 l := v.Args[0]
25279 if l.Op != OpARMANDshiftLL {
25280 break
25281 }
25282 c := l.AuxInt
25283 y := l.Args[1]
25284 x := l.Args[0]
25285 if !(l.Uses == 1) {
25286 break
25287 }
25288 b.Kind = BlockARMLE
25289 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags)
25290 v0.AuxInt = c
25291 v0.AddArg(x)
25292 v0.AddArg(y)
25293 b.SetControl(v0)
25294 b.Aux = nil
25295 return true
25296 }
25297
25298
25299
25300 for v.Op == OpARMCMPconst {
25301 if v.AuxInt != 0 {
25302 break
25303 }
25304 l := v.Args[0]
25305 if l.Op != OpARMANDshiftRL {
25306 break
25307 }
25308 c := l.AuxInt
25309 y := l.Args[1]
25310 x := l.Args[0]
25311 if !(l.Uses == 1) {
25312 break
25313 }
25314 b.Kind = BlockARMLE
25315 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags)
25316 v0.AuxInt = c
25317 v0.AddArg(x)
25318 v0.AddArg(y)
25319 b.SetControl(v0)
25320 b.Aux = nil
25321 return true
25322 }
25323
25324
25325
25326 for v.Op == OpARMCMPconst {
25327 if v.AuxInt != 0 {
25328 break
25329 }
25330 l := v.Args[0]
25331 if l.Op != OpARMANDshiftRA {
25332 break
25333 }
25334 c := l.AuxInt
25335 y := l.Args[1]
25336 x := l.Args[0]
25337 if !(l.Uses == 1) {
25338 break
25339 }
25340 b.Kind = BlockARMLE
25341 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags)
25342 v0.AuxInt = c
25343 v0.AddArg(x)
25344 v0.AddArg(y)
25345 b.SetControl(v0)
25346 b.Aux = nil
25347 return true
25348 }
25349
25350
25351
25352 for v.Op == OpARMCMPconst {
25353 if v.AuxInt != 0 {
25354 break
25355 }
25356 l := v.Args[0]
25357 if l.Op != OpARMANDshiftLLreg {
25358 break
25359 }
25360 z := l.Args[2]
25361 x := l.Args[0]
25362 y := l.Args[1]
25363 if !(l.Uses == 1) {
25364 break
25365 }
25366 b.Kind = BlockARMLE
25367 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
25368 v0.AddArg(x)
25369 v0.AddArg(y)
25370 v0.AddArg(z)
25371 b.SetControl(v0)
25372 b.Aux = nil
25373 return true
25374 }
25375
25376
25377
25378 for v.Op == OpARMCMPconst {
25379 if v.AuxInt != 0 {
25380 break
25381 }
25382 l := v.Args[0]
25383 if l.Op != OpARMANDshiftRLreg {
25384 break
25385 }
25386 z := l.Args[2]
25387 x := l.Args[0]
25388 y := l.Args[1]
25389 if !(l.Uses == 1) {
25390 break
25391 }
25392 b.Kind = BlockARMLE
25393 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
25394 v0.AddArg(x)
25395 v0.AddArg(y)
25396 v0.AddArg(z)
25397 b.SetControl(v0)
25398 b.Aux = nil
25399 return true
25400 }
25401
25402
25403
25404 for v.Op == OpARMCMPconst {
25405 if v.AuxInt != 0 {
25406 break
25407 }
25408 l := v.Args[0]
25409 if l.Op != OpARMANDshiftRAreg {
25410 break
25411 }
25412 z := l.Args[2]
25413 x := l.Args[0]
25414 y := l.Args[1]
25415 if !(l.Uses == 1) {
25416 break
25417 }
25418 b.Kind = BlockARMLE
25419 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
25420 v0.AddArg(x)
25421 v0.AddArg(y)
25422 v0.AddArg(z)
25423 b.SetControl(v0)
25424 b.Aux = nil
25425 return true
25426 }
25427
25428
25429
25430 for v.Op == OpARMCMPconst {
25431 if v.AuxInt != 0 {
25432 break
25433 }
25434 l := v.Args[0]
25435 if l.Op != OpARMXOR {
25436 break
25437 }
25438 y := l.Args[1]
25439 x := l.Args[0]
25440 if !(l.Uses == 1) {
25441 break
25442 }
25443 b.Kind = BlockARMLE
25444 v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags)
25445 v0.AddArg(x)
25446 v0.AddArg(y)
25447 b.SetControl(v0)
25448 b.Aux = nil
25449 return true
25450 }
25451
25452
25453
25454 for v.Op == OpARMCMPconst {
25455 if v.AuxInt != 0 {
25456 break
25457 }
25458 l := v.Args[0]
25459 if l.Op != OpARMXORconst {
25460 break
25461 }
25462 c := l.AuxInt
25463 x := l.Args[0]
25464 if !(l.Uses == 1) {
25465 break
25466 }
25467 b.Kind = BlockARMLE
25468 v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags)
25469 v0.AuxInt = c
25470 v0.AddArg(x)
25471 b.SetControl(v0)
25472 b.Aux = nil
25473 return true
25474 }
25475
25476
25477
25478 for v.Op == OpARMCMPconst {
25479 if v.AuxInt != 0 {
25480 break
25481 }
25482 l := v.Args[0]
25483 if l.Op != OpARMXORshiftLL {
25484 break
25485 }
25486 c := l.AuxInt
25487 y := l.Args[1]
25488 x := l.Args[0]
25489 if !(l.Uses == 1) {
25490 break
25491 }
25492 b.Kind = BlockARMLE
25493 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, 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
25502
25503
25504 for v.Op == OpARMCMPconst {
25505 if v.AuxInt != 0 {
25506 break
25507 }
25508 l := v.Args[0]
25509 if l.Op != OpARMXORshiftRL {
25510 break
25511 }
25512 c := l.AuxInt
25513 y := l.Args[1]
25514 x := l.Args[0]
25515 if !(l.Uses == 1) {
25516 break
25517 }
25518 b.Kind = BlockARMLE
25519 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags)
25520 v0.AuxInt = c
25521 v0.AddArg(x)
25522 v0.AddArg(y)
25523 b.SetControl(v0)
25524 b.Aux = nil
25525 return true
25526 }
25527
25528
25529
25530 for v.Op == OpARMCMPconst {
25531 if v.AuxInt != 0 {
25532 break
25533 }
25534 l := v.Args[0]
25535 if l.Op != OpARMXORshiftRA {
25536 break
25537 }
25538 c := l.AuxInt
25539 y := l.Args[1]
25540 x := l.Args[0]
25541 if !(l.Uses == 1) {
25542 break
25543 }
25544 b.Kind = BlockARMLE
25545 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags)
25546 v0.AuxInt = c
25547 v0.AddArg(x)
25548 v0.AddArg(y)
25549 b.SetControl(v0)
25550 b.Aux = nil
25551 return true
25552 }
25553
25554
25555
25556 for v.Op == OpARMCMPconst {
25557 if v.AuxInt != 0 {
25558 break
25559 }
25560 l := v.Args[0]
25561 if l.Op != OpARMXORshiftLLreg {
25562 break
25563 }
25564 z := l.Args[2]
25565 x := l.Args[0]
25566 y := l.Args[1]
25567 if !(l.Uses == 1) {
25568 break
25569 }
25570 b.Kind = BlockARMLE
25571 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
25572 v0.AddArg(x)
25573 v0.AddArg(y)
25574 v0.AddArg(z)
25575 b.SetControl(v0)
25576 b.Aux = nil
25577 return true
25578 }
25579
25580
25581
25582 for v.Op == OpARMCMPconst {
25583 if v.AuxInt != 0 {
25584 break
25585 }
25586 l := v.Args[0]
25587 if l.Op != OpARMXORshiftRLreg {
25588 break
25589 }
25590 z := l.Args[2]
25591 x := l.Args[0]
25592 y := l.Args[1]
25593 if !(l.Uses == 1) {
25594 break
25595 }
25596 b.Kind = BlockARMLE
25597 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
25598 v0.AddArg(x)
25599 v0.AddArg(y)
25600 v0.AddArg(z)
25601 b.SetControl(v0)
25602 b.Aux = nil
25603 return true
25604 }
25605
25606
25607
25608 for v.Op == OpARMCMPconst {
25609 if v.AuxInt != 0 {
25610 break
25611 }
25612 l := v.Args[0]
25613 if l.Op != OpARMXORshiftRAreg {
25614 break
25615 }
25616 z := l.Args[2]
25617 x := l.Args[0]
25618 y := l.Args[1]
25619 if !(l.Uses == 1) {
25620 break
25621 }
25622 b.Kind = BlockARMLE
25623 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
25624 v0.AddArg(x)
25625 v0.AddArg(y)
25626 v0.AddArg(z)
25627 b.SetControl(v0)
25628 b.Aux = nil
25629 return true
25630 }
25631 case BlockARMLT:
25632
25633
25634
25635 for v.Op == OpARMFlagEQ {
25636 b.Kind = BlockFirst
25637 b.SetControl(nil)
25638 b.Aux = nil
25639 b.swapSuccessors()
25640 return true
25641 }
25642
25643
25644
25645 for v.Op == OpARMFlagLT_ULT {
25646 b.Kind = BlockFirst
25647 b.SetControl(nil)
25648 b.Aux = nil
25649 return true
25650 }
25651
25652
25653
25654 for v.Op == OpARMFlagLT_UGT {
25655 b.Kind = BlockFirst
25656 b.SetControl(nil)
25657 b.Aux = nil
25658 return true
25659 }
25660
25661
25662
25663 for v.Op == OpARMFlagGT_ULT {
25664 b.Kind = BlockFirst
25665 b.SetControl(nil)
25666 b.Aux = nil
25667 b.swapSuccessors()
25668 return true
25669 }
25670
25671
25672
25673 for v.Op == OpARMFlagGT_UGT {
25674 b.Kind = BlockFirst
25675 b.SetControl(nil)
25676 b.Aux = nil
25677 b.swapSuccessors()
25678 return true
25679 }
25680
25681
25682
25683 for v.Op == OpARMInvertFlags {
25684 cmp := v.Args[0]
25685 b.Kind = BlockARMGT
25686 b.SetControl(cmp)
25687 b.Aux = nil
25688 return true
25689 }
25690
25691
25692
25693 for v.Op == OpARMCMPconst {
25694 if v.AuxInt != 0 {
25695 break
25696 }
25697 l := v.Args[0]
25698 if l.Op != OpARMSUB {
25699 break
25700 }
25701 y := l.Args[1]
25702 x := l.Args[0]
25703 if !(l.Uses == 1) {
25704 break
25705 }
25706 b.Kind = BlockARMLT
25707 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
25708 v0.AddArg(x)
25709 v0.AddArg(y)
25710 b.SetControl(v0)
25711 b.Aux = nil
25712 return true
25713 }
25714
25715
25716
25717 for v.Op == OpARMCMPconst {
25718 if v.AuxInt != 0 {
25719 break
25720 }
25721 l := v.Args[0]
25722 if l.Op != OpARMMULS {
25723 break
25724 }
25725 a := l.Args[2]
25726 x := l.Args[0]
25727 y := l.Args[1]
25728 if !(l.Uses == 1) {
25729 break
25730 }
25731 b.Kind = BlockARMLT
25732 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
25733 v0.AddArg(a)
25734 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type)
25735 v1.AddArg(x)
25736 v1.AddArg(y)
25737 v0.AddArg(v1)
25738 b.SetControl(v0)
25739 b.Aux = nil
25740 return true
25741 }
25742
25743
25744
25745 for v.Op == OpARMCMPconst {
25746 if v.AuxInt != 0 {
25747 break
25748 }
25749 l := v.Args[0]
25750 if l.Op != OpARMSUBconst {
25751 break
25752 }
25753 c := l.AuxInt
25754 x := l.Args[0]
25755 if !(l.Uses == 1) {
25756 break
25757 }
25758 b.Kind = BlockARMLT
25759 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
25760 v0.AuxInt = c
25761 v0.AddArg(x)
25762 b.SetControl(v0)
25763 b.Aux = nil
25764 return true
25765 }
25766
25767
25768
25769 for v.Op == OpARMCMPconst {
25770 if v.AuxInt != 0 {
25771 break
25772 }
25773 l := v.Args[0]
25774 if l.Op != OpARMSUBshiftLL {
25775 break
25776 }
25777 c := l.AuxInt
25778 y := l.Args[1]
25779 x := l.Args[0]
25780 if !(l.Uses == 1) {
25781 break
25782 }
25783 b.Kind = BlockARMLT
25784 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags)
25785 v0.AuxInt = c
25786 v0.AddArg(x)
25787 v0.AddArg(y)
25788 b.SetControl(v0)
25789 b.Aux = nil
25790 return true
25791 }
25792
25793
25794
25795 for v.Op == OpARMCMPconst {
25796 if v.AuxInt != 0 {
25797 break
25798 }
25799 l := v.Args[0]
25800 if l.Op != OpARMSUBshiftRL {
25801 break
25802 }
25803 c := l.AuxInt
25804 y := l.Args[1]
25805 x := l.Args[0]
25806 if !(l.Uses == 1) {
25807 break
25808 }
25809 b.Kind = BlockARMLT
25810 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags)
25811 v0.AuxInt = c
25812 v0.AddArg(x)
25813 v0.AddArg(y)
25814 b.SetControl(v0)
25815 b.Aux = nil
25816 return true
25817 }
25818
25819
25820
25821 for v.Op == OpARMCMPconst {
25822 if v.AuxInt != 0 {
25823 break
25824 }
25825 l := v.Args[0]
25826 if l.Op != OpARMSUBshiftRA {
25827 break
25828 }
25829 c := l.AuxInt
25830 y := l.Args[1]
25831 x := l.Args[0]
25832 if !(l.Uses == 1) {
25833 break
25834 }
25835 b.Kind = BlockARMLT
25836 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags)
25837 v0.AuxInt = c
25838 v0.AddArg(x)
25839 v0.AddArg(y)
25840 b.SetControl(v0)
25841 b.Aux = nil
25842 return true
25843 }
25844
25845
25846
25847 for v.Op == OpARMCMPconst {
25848 if v.AuxInt != 0 {
25849 break
25850 }
25851 l := v.Args[0]
25852 if l.Op != OpARMSUBshiftLLreg {
25853 break
25854 }
25855 z := l.Args[2]
25856 x := l.Args[0]
25857 y := l.Args[1]
25858 if !(l.Uses == 1) {
25859 break
25860 }
25861 b.Kind = BlockARMLT
25862 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
25863 v0.AddArg(x)
25864 v0.AddArg(y)
25865 v0.AddArg(z)
25866 b.SetControl(v0)
25867 b.Aux = nil
25868 return true
25869 }
25870
25871
25872
25873 for v.Op == OpARMCMPconst {
25874 if v.AuxInt != 0 {
25875 break
25876 }
25877 l := v.Args[0]
25878 if l.Op != OpARMSUBshiftRLreg {
25879 break
25880 }
25881 z := l.Args[2]
25882 x := l.Args[0]
25883 y := l.Args[1]
25884 if !(l.Uses == 1) {
25885 break
25886 }
25887 b.Kind = BlockARMLT
25888 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
25889 v0.AddArg(x)
25890 v0.AddArg(y)
25891 v0.AddArg(z)
25892 b.SetControl(v0)
25893 b.Aux = nil
25894 return true
25895 }
25896
25897
25898
25899 for v.Op == OpARMCMPconst {
25900 if v.AuxInt != 0 {
25901 break
25902 }
25903 l := v.Args[0]
25904 if l.Op != OpARMSUBshiftRAreg {
25905 break
25906 }
25907 z := l.Args[2]
25908 x := l.Args[0]
25909 y := l.Args[1]
25910 if !(l.Uses == 1) {
25911 break
25912 }
25913 b.Kind = BlockARMLT
25914 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
25915 v0.AddArg(x)
25916 v0.AddArg(y)
25917 v0.AddArg(z)
25918 b.SetControl(v0)
25919 b.Aux = nil
25920 return true
25921 }
25922
25923
25924
25925 for v.Op == OpARMCMPconst {
25926 if v.AuxInt != 0 {
25927 break
25928 }
25929 l := v.Args[0]
25930 if l.Op != OpARMADD {
25931 break
25932 }
25933 y := l.Args[1]
25934 x := l.Args[0]
25935 if !(l.Uses == 1) {
25936 break
25937 }
25938 b.Kind = BlockARMLT
25939 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
25940 v0.AddArg(x)
25941 v0.AddArg(y)
25942 b.SetControl(v0)
25943 b.Aux = nil
25944 return true
25945 }
25946
25947
25948
25949 for v.Op == OpARMCMPconst {
25950 if v.AuxInt != 0 {
25951 break
25952 }
25953 l := v.Args[0]
25954 if l.Op != OpARMMULA {
25955 break
25956 }
25957 a := l.Args[2]
25958 x := l.Args[0]
25959 y := l.Args[1]
25960 if !(l.Uses == 1) {
25961 break
25962 }
25963 b.Kind = BlockARMLT
25964 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
25965 v0.AddArg(a)
25966 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type)
25967 v1.AddArg(x)
25968 v1.AddArg(y)
25969 v0.AddArg(v1)
25970 b.SetControl(v0)
25971 b.Aux = nil
25972 return true
25973 }
25974
25975
25976
25977 for v.Op == OpARMCMPconst {
25978 if v.AuxInt != 0 {
25979 break
25980 }
25981 l := v.Args[0]
25982 if l.Op != OpARMADDconst {
25983 break
25984 }
25985 c := l.AuxInt
25986 x := l.Args[0]
25987 if !(l.Uses == 1) {
25988 break
25989 }
25990 b.Kind = BlockARMLT
25991 v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags)
25992 v0.AuxInt = c
25993 v0.AddArg(x)
25994 b.SetControl(v0)
25995 b.Aux = nil
25996 return true
25997 }
25998
25999
26000
26001 for v.Op == OpARMCMPconst {
26002 if v.AuxInt != 0 {
26003 break
26004 }
26005 l := v.Args[0]
26006 if l.Op != OpARMADDshiftLL {
26007 break
26008 }
26009 c := l.AuxInt
26010 y := l.Args[1]
26011 x := l.Args[0]
26012 if !(l.Uses == 1) {
26013 break
26014 }
26015 b.Kind = BlockARMLT
26016 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags)
26017 v0.AuxInt = c
26018 v0.AddArg(x)
26019 v0.AddArg(y)
26020 b.SetControl(v0)
26021 b.Aux = nil
26022 return true
26023 }
26024
26025
26026
26027 for v.Op == OpARMCMPconst {
26028 if v.AuxInt != 0 {
26029 break
26030 }
26031 l := v.Args[0]
26032 if l.Op != OpARMADDshiftRL {
26033 break
26034 }
26035 c := l.AuxInt
26036 y := l.Args[1]
26037 x := l.Args[0]
26038 if !(l.Uses == 1) {
26039 break
26040 }
26041 b.Kind = BlockARMLT
26042 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags)
26043 v0.AuxInt = c
26044 v0.AddArg(x)
26045 v0.AddArg(y)
26046 b.SetControl(v0)
26047 b.Aux = nil
26048 return true
26049 }
26050
26051
26052
26053 for v.Op == OpARMCMPconst {
26054 if v.AuxInt != 0 {
26055 break
26056 }
26057 l := v.Args[0]
26058 if l.Op != OpARMADDshiftRA {
26059 break
26060 }
26061 c := l.AuxInt
26062 y := l.Args[1]
26063 x := l.Args[0]
26064 if !(l.Uses == 1) {
26065 break
26066 }
26067 b.Kind = BlockARMLT
26068 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags)
26069 v0.AuxInt = c
26070 v0.AddArg(x)
26071 v0.AddArg(y)
26072 b.SetControl(v0)
26073 b.Aux = nil
26074 return true
26075 }
26076
26077
26078
26079 for v.Op == OpARMCMPconst {
26080 if v.AuxInt != 0 {
26081 break
26082 }
26083 l := v.Args[0]
26084 if l.Op != OpARMADDshiftLLreg {
26085 break
26086 }
26087 z := l.Args[2]
26088 x := l.Args[0]
26089 y := l.Args[1]
26090 if !(l.Uses == 1) {
26091 break
26092 }
26093 b.Kind = BlockARMLT
26094 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
26095 v0.AddArg(x)
26096 v0.AddArg(y)
26097 v0.AddArg(z)
26098 b.SetControl(v0)
26099 b.Aux = nil
26100 return true
26101 }
26102
26103
26104
26105 for v.Op == OpARMCMPconst {
26106 if v.AuxInt != 0 {
26107 break
26108 }
26109 l := v.Args[0]
26110 if l.Op != OpARMADDshiftRLreg {
26111 break
26112 }
26113 z := l.Args[2]
26114 x := l.Args[0]
26115 y := l.Args[1]
26116 if !(l.Uses == 1) {
26117 break
26118 }
26119 b.Kind = BlockARMLT
26120 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
26121 v0.AddArg(x)
26122 v0.AddArg(y)
26123 v0.AddArg(z)
26124 b.SetControl(v0)
26125 b.Aux = nil
26126 return true
26127 }
26128
26129
26130
26131 for v.Op == OpARMCMPconst {
26132 if v.AuxInt != 0 {
26133 break
26134 }
26135 l := v.Args[0]
26136 if l.Op != OpARMADDshiftRAreg {
26137 break
26138 }
26139 z := l.Args[2]
26140 x := l.Args[0]
26141 y := l.Args[1]
26142 if !(l.Uses == 1) {
26143 break
26144 }
26145 b.Kind = BlockARMLT
26146 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
26147 v0.AddArg(x)
26148 v0.AddArg(y)
26149 v0.AddArg(z)
26150 b.SetControl(v0)
26151 b.Aux = nil
26152 return true
26153 }
26154
26155
26156
26157 for v.Op == OpARMCMPconst {
26158 if v.AuxInt != 0 {
26159 break
26160 }
26161 l := v.Args[0]
26162 if l.Op != OpARMAND {
26163 break
26164 }
26165 y := l.Args[1]
26166 x := l.Args[0]
26167 if !(l.Uses == 1) {
26168 break
26169 }
26170 b.Kind = BlockARMLT
26171 v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags)
26172 v0.AddArg(x)
26173 v0.AddArg(y)
26174 b.SetControl(v0)
26175 b.Aux = nil
26176 return true
26177 }
26178
26179
26180
26181 for v.Op == OpARMCMPconst {
26182 if v.AuxInt != 0 {
26183 break
26184 }
26185 l := v.Args[0]
26186 if l.Op != OpARMANDconst {
26187 break
26188 }
26189 c := l.AuxInt
26190 x := l.Args[0]
26191 if !(l.Uses == 1) {
26192 break
26193 }
26194 b.Kind = BlockARMLT
26195 v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags)
26196 v0.AuxInt = c
26197 v0.AddArg(x)
26198 b.SetControl(v0)
26199 b.Aux = nil
26200 return true
26201 }
26202
26203
26204
26205 for v.Op == OpARMCMPconst {
26206 if v.AuxInt != 0 {
26207 break
26208 }
26209 l := v.Args[0]
26210 if l.Op != OpARMANDshiftLL {
26211 break
26212 }
26213 c := l.AuxInt
26214 y := l.Args[1]
26215 x := l.Args[0]
26216 if !(l.Uses == 1) {
26217 break
26218 }
26219 b.Kind = BlockARMLT
26220 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags)
26221 v0.AuxInt = c
26222 v0.AddArg(x)
26223 v0.AddArg(y)
26224 b.SetControl(v0)
26225 b.Aux = nil
26226 return true
26227 }
26228
26229
26230
26231 for v.Op == OpARMCMPconst {
26232 if v.AuxInt != 0 {
26233 break
26234 }
26235 l := v.Args[0]
26236 if l.Op != OpARMANDshiftRL {
26237 break
26238 }
26239 c := l.AuxInt
26240 y := l.Args[1]
26241 x := l.Args[0]
26242 if !(l.Uses == 1) {
26243 break
26244 }
26245 b.Kind = BlockARMLT
26246 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags)
26247 v0.AuxInt = c
26248 v0.AddArg(x)
26249 v0.AddArg(y)
26250 b.SetControl(v0)
26251 b.Aux = nil
26252 return true
26253 }
26254
26255
26256
26257 for v.Op == OpARMCMPconst {
26258 if v.AuxInt != 0 {
26259 break
26260 }
26261 l := v.Args[0]
26262 if l.Op != OpARMANDshiftRA {
26263 break
26264 }
26265 c := l.AuxInt
26266 y := l.Args[1]
26267 x := l.Args[0]
26268 if !(l.Uses == 1) {
26269 break
26270 }
26271 b.Kind = BlockARMLT
26272 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags)
26273 v0.AuxInt = c
26274 v0.AddArg(x)
26275 v0.AddArg(y)
26276 b.SetControl(v0)
26277 b.Aux = nil
26278 return true
26279 }
26280
26281
26282
26283 for v.Op == OpARMCMPconst {
26284 if v.AuxInt != 0 {
26285 break
26286 }
26287 l := v.Args[0]
26288 if l.Op != OpARMANDshiftLLreg {
26289 break
26290 }
26291 z := l.Args[2]
26292 x := l.Args[0]
26293 y := l.Args[1]
26294 if !(l.Uses == 1) {
26295 break
26296 }
26297 b.Kind = BlockARMLT
26298 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
26299 v0.AddArg(x)
26300 v0.AddArg(y)
26301 v0.AddArg(z)
26302 b.SetControl(v0)
26303 b.Aux = nil
26304 return true
26305 }
26306
26307
26308
26309 for v.Op == OpARMCMPconst {
26310 if v.AuxInt != 0 {
26311 break
26312 }
26313 l := v.Args[0]
26314 if l.Op != OpARMANDshiftRLreg {
26315 break
26316 }
26317 z := l.Args[2]
26318 x := l.Args[0]
26319 y := l.Args[1]
26320 if !(l.Uses == 1) {
26321 break
26322 }
26323 b.Kind = BlockARMLT
26324 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
26325 v0.AddArg(x)
26326 v0.AddArg(y)
26327 v0.AddArg(z)
26328 b.SetControl(v0)
26329 b.Aux = nil
26330 return true
26331 }
26332
26333
26334
26335 for v.Op == OpARMCMPconst {
26336 if v.AuxInt != 0 {
26337 break
26338 }
26339 l := v.Args[0]
26340 if l.Op != OpARMANDshiftRAreg {
26341 break
26342 }
26343 z := l.Args[2]
26344 x := l.Args[0]
26345 y := l.Args[1]
26346 if !(l.Uses == 1) {
26347 break
26348 }
26349 b.Kind = BlockARMLT
26350 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
26351 v0.AddArg(x)
26352 v0.AddArg(y)
26353 v0.AddArg(z)
26354 b.SetControl(v0)
26355 b.Aux = nil
26356 return true
26357 }
26358
26359
26360
26361 for v.Op == OpARMCMPconst {
26362 if v.AuxInt != 0 {
26363 break
26364 }
26365 l := v.Args[0]
26366 if l.Op != OpARMXOR {
26367 break
26368 }
26369 y := l.Args[1]
26370 x := l.Args[0]
26371 if !(l.Uses == 1) {
26372 break
26373 }
26374 b.Kind = BlockARMLT
26375 v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags)
26376 v0.AddArg(x)
26377 v0.AddArg(y)
26378 b.SetControl(v0)
26379 b.Aux = nil
26380 return true
26381 }
26382
26383
26384
26385 for v.Op == OpARMCMPconst {
26386 if v.AuxInt != 0 {
26387 break
26388 }
26389 l := v.Args[0]
26390 if l.Op != OpARMXORconst {
26391 break
26392 }
26393 c := l.AuxInt
26394 x := l.Args[0]
26395 if !(l.Uses == 1) {
26396 break
26397 }
26398 b.Kind = BlockARMLT
26399 v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags)
26400 v0.AuxInt = c
26401 v0.AddArg(x)
26402 b.SetControl(v0)
26403 b.Aux = nil
26404 return true
26405 }
26406
26407
26408
26409 for v.Op == OpARMCMPconst {
26410 if v.AuxInt != 0 {
26411 break
26412 }
26413 l := v.Args[0]
26414 if l.Op != OpARMXORshiftLL {
26415 break
26416 }
26417 c := l.AuxInt
26418 y := l.Args[1]
26419 x := l.Args[0]
26420 if !(l.Uses == 1) {
26421 break
26422 }
26423 b.Kind = BlockARMLT
26424 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags)
26425 v0.AuxInt = c
26426 v0.AddArg(x)
26427 v0.AddArg(y)
26428 b.SetControl(v0)
26429 b.Aux = nil
26430 return true
26431 }
26432
26433
26434
26435 for v.Op == OpARMCMPconst {
26436 if v.AuxInt != 0 {
26437 break
26438 }
26439 l := v.Args[0]
26440 if l.Op != OpARMXORshiftRL {
26441 break
26442 }
26443 c := l.AuxInt
26444 y := l.Args[1]
26445 x := l.Args[0]
26446 if !(l.Uses == 1) {
26447 break
26448 }
26449 b.Kind = BlockARMLT
26450 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags)
26451 v0.AuxInt = c
26452 v0.AddArg(x)
26453 v0.AddArg(y)
26454 b.SetControl(v0)
26455 b.Aux = nil
26456 return true
26457 }
26458
26459
26460
26461 for v.Op == OpARMCMPconst {
26462 if v.AuxInt != 0 {
26463 break
26464 }
26465 l := v.Args[0]
26466 if l.Op != OpARMXORshiftRA {
26467 break
26468 }
26469 c := l.AuxInt
26470 y := l.Args[1]
26471 x := l.Args[0]
26472 if !(l.Uses == 1) {
26473 break
26474 }
26475 b.Kind = BlockARMLT
26476 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags)
26477 v0.AuxInt = c
26478 v0.AddArg(x)
26479 v0.AddArg(y)
26480 b.SetControl(v0)
26481 b.Aux = nil
26482 return true
26483 }
26484
26485
26486
26487 for v.Op == OpARMCMPconst {
26488 if v.AuxInt != 0 {
26489 break
26490 }
26491 l := v.Args[0]
26492 if l.Op != OpARMXORshiftLLreg {
26493 break
26494 }
26495 z := l.Args[2]
26496 x := l.Args[0]
26497 y := l.Args[1]
26498 if !(l.Uses == 1) {
26499 break
26500 }
26501 b.Kind = BlockARMLT
26502 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
26503 v0.AddArg(x)
26504 v0.AddArg(y)
26505 v0.AddArg(z)
26506 b.SetControl(v0)
26507 b.Aux = nil
26508 return true
26509 }
26510
26511
26512
26513 for v.Op == OpARMCMPconst {
26514 if v.AuxInt != 0 {
26515 break
26516 }
26517 l := v.Args[0]
26518 if l.Op != OpARMXORshiftRLreg {
26519 break
26520 }
26521 z := l.Args[2]
26522 x := l.Args[0]
26523 y := l.Args[1]
26524 if !(l.Uses == 1) {
26525 break
26526 }
26527 b.Kind = BlockARMLT
26528 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
26529 v0.AddArg(x)
26530 v0.AddArg(y)
26531 v0.AddArg(z)
26532 b.SetControl(v0)
26533 b.Aux = nil
26534 return true
26535 }
26536
26537
26538
26539 for v.Op == OpARMCMPconst {
26540 if v.AuxInt != 0 {
26541 break
26542 }
26543 l := v.Args[0]
26544 if l.Op != OpARMXORshiftRAreg {
26545 break
26546 }
26547 z := l.Args[2]
26548 x := l.Args[0]
26549 y := l.Args[1]
26550 if !(l.Uses == 1) {
26551 break
26552 }
26553 b.Kind = BlockARMLT
26554 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
26555 v0.AddArg(x)
26556 v0.AddArg(y)
26557 v0.AddArg(z)
26558 b.SetControl(v0)
26559 b.Aux = nil
26560 return true
26561 }
26562 case BlockARMNE:
26563
26564
26565
26566 for v.Op == OpARMCMPconst {
26567 if v.AuxInt != 0 {
26568 break
26569 }
26570 v_0 := v.Args[0]
26571 if v_0.Op != OpARMEqual {
26572 break
26573 }
26574 cc := v_0.Args[0]
26575 b.Kind = BlockARMEQ
26576 b.SetControl(cc)
26577 b.Aux = nil
26578 return true
26579 }
26580
26581
26582
26583 for v.Op == OpARMCMPconst {
26584 if v.AuxInt != 0 {
26585 break
26586 }
26587 v_0 := v.Args[0]
26588 if v_0.Op != OpARMNotEqual {
26589 break
26590 }
26591 cc := v_0.Args[0]
26592 b.Kind = BlockARMNE
26593 b.SetControl(cc)
26594 b.Aux = nil
26595 return true
26596 }
26597
26598
26599
26600 for v.Op == OpARMCMPconst {
26601 if v.AuxInt != 0 {
26602 break
26603 }
26604 v_0 := v.Args[0]
26605 if v_0.Op != OpARMLessThan {
26606 break
26607 }
26608 cc := v_0.Args[0]
26609 b.Kind = BlockARMLT
26610 b.SetControl(cc)
26611 b.Aux = nil
26612 return true
26613 }
26614
26615
26616
26617 for v.Op == OpARMCMPconst {
26618 if v.AuxInt != 0 {
26619 break
26620 }
26621 v_0 := v.Args[0]
26622 if v_0.Op != OpARMLessThanU {
26623 break
26624 }
26625 cc := v_0.Args[0]
26626 b.Kind = BlockARMULT
26627 b.SetControl(cc)
26628 b.Aux = nil
26629 return true
26630 }
26631
26632
26633
26634 for v.Op == OpARMCMPconst {
26635 if v.AuxInt != 0 {
26636 break
26637 }
26638 v_0 := v.Args[0]
26639 if v_0.Op != OpARMLessEqual {
26640 break
26641 }
26642 cc := v_0.Args[0]
26643 b.Kind = BlockARMLE
26644 b.SetControl(cc)
26645 b.Aux = nil
26646 return true
26647 }
26648
26649
26650
26651 for v.Op == OpARMCMPconst {
26652 if v.AuxInt != 0 {
26653 break
26654 }
26655 v_0 := v.Args[0]
26656 if v_0.Op != OpARMLessEqualU {
26657 break
26658 }
26659 cc := v_0.Args[0]
26660 b.Kind = BlockARMULE
26661 b.SetControl(cc)
26662 b.Aux = nil
26663 return true
26664 }
26665
26666
26667
26668 for v.Op == OpARMCMPconst {
26669 if v.AuxInt != 0 {
26670 break
26671 }
26672 v_0 := v.Args[0]
26673 if v_0.Op != OpARMGreaterThan {
26674 break
26675 }
26676 cc := v_0.Args[0]
26677 b.Kind = BlockARMGT
26678 b.SetControl(cc)
26679 b.Aux = nil
26680 return true
26681 }
26682
26683
26684
26685 for v.Op == OpARMCMPconst {
26686 if v.AuxInt != 0 {
26687 break
26688 }
26689 v_0 := v.Args[0]
26690 if v_0.Op != OpARMGreaterThanU {
26691 break
26692 }
26693 cc := v_0.Args[0]
26694 b.Kind = BlockARMUGT
26695 b.SetControl(cc)
26696 b.Aux = nil
26697 return true
26698 }
26699
26700
26701
26702 for v.Op == OpARMCMPconst {
26703 if v.AuxInt != 0 {
26704 break
26705 }
26706 v_0 := v.Args[0]
26707 if v_0.Op != OpARMGreaterEqual {
26708 break
26709 }
26710 cc := v_0.Args[0]
26711 b.Kind = BlockARMGE
26712 b.SetControl(cc)
26713 b.Aux = nil
26714 return true
26715 }
26716
26717
26718
26719 for v.Op == OpARMCMPconst {
26720 if v.AuxInt != 0 {
26721 break
26722 }
26723 v_0 := v.Args[0]
26724 if v_0.Op != OpARMGreaterEqualU {
26725 break
26726 }
26727 cc := v_0.Args[0]
26728 b.Kind = BlockARMUGE
26729 b.SetControl(cc)
26730 b.Aux = nil
26731 return true
26732 }
26733
26734
26735
26736 for v.Op == OpARMFlagEQ {
26737 b.Kind = BlockFirst
26738 b.SetControl(nil)
26739 b.Aux = nil
26740 b.swapSuccessors()
26741 return true
26742 }
26743
26744
26745
26746 for v.Op == OpARMFlagLT_ULT {
26747 b.Kind = BlockFirst
26748 b.SetControl(nil)
26749 b.Aux = nil
26750 return true
26751 }
26752
26753
26754
26755 for v.Op == OpARMFlagLT_UGT {
26756 b.Kind = BlockFirst
26757 b.SetControl(nil)
26758 b.Aux = nil
26759 return true
26760 }
26761
26762
26763
26764 for v.Op == OpARMFlagGT_ULT {
26765 b.Kind = BlockFirst
26766 b.SetControl(nil)
26767 b.Aux = nil
26768 return true
26769 }
26770
26771
26772
26773 for v.Op == OpARMFlagGT_UGT {
26774 b.Kind = BlockFirst
26775 b.SetControl(nil)
26776 b.Aux = nil
26777 return true
26778 }
26779
26780
26781
26782 for v.Op == OpARMInvertFlags {
26783 cmp := v.Args[0]
26784 b.Kind = BlockARMNE
26785 b.SetControl(cmp)
26786 b.Aux = nil
26787 return true
26788 }
26789
26790
26791
26792 for v.Op == OpARMCMPconst {
26793 if v.AuxInt != 0 {
26794 break
26795 }
26796 l := v.Args[0]
26797 if l.Op != OpARMSUB {
26798 break
26799 }
26800 y := l.Args[1]
26801 x := l.Args[0]
26802 if !(l.Uses == 1) {
26803 break
26804 }
26805 b.Kind = BlockARMNE
26806 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
26807 v0.AddArg(x)
26808 v0.AddArg(y)
26809 b.SetControl(v0)
26810 b.Aux = nil
26811 return true
26812 }
26813
26814
26815
26816 for v.Op == OpARMCMPconst {
26817 if v.AuxInt != 0 {
26818 break
26819 }
26820 l := v.Args[0]
26821 if l.Op != OpARMMULS {
26822 break
26823 }
26824 a := l.Args[2]
26825 x := l.Args[0]
26826 y := l.Args[1]
26827 if !(l.Uses == 1) {
26828 break
26829 }
26830 b.Kind = BlockARMNE
26831 v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
26832 v0.AddArg(a)
26833 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type)
26834 v1.AddArg(x)
26835 v1.AddArg(y)
26836 v0.AddArg(v1)
26837 b.SetControl(v0)
26838 b.Aux = nil
26839 return true
26840 }
26841
26842
26843
26844 for v.Op == OpARMCMPconst {
26845 if v.AuxInt != 0 {
26846 break
26847 }
26848 l := v.Args[0]
26849 if l.Op != OpARMSUBconst {
26850 break
26851 }
26852 c := l.AuxInt
26853 x := l.Args[0]
26854 if !(l.Uses == 1) {
26855 break
26856 }
26857 b.Kind = BlockARMNE
26858 v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
26859 v0.AuxInt = c
26860 v0.AddArg(x)
26861 b.SetControl(v0)
26862 b.Aux = nil
26863 return true
26864 }
26865
26866
26867
26868 for v.Op == OpARMCMPconst {
26869 if v.AuxInt != 0 {
26870 break
26871 }
26872 l := v.Args[0]
26873 if l.Op != OpARMSUBshiftLL {
26874 break
26875 }
26876 c := l.AuxInt
26877 y := l.Args[1]
26878 x := l.Args[0]
26879 if !(l.Uses == 1) {
26880 break
26881 }
26882 b.Kind = BlockARMNE
26883 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags)
26884 v0.AuxInt = c
26885 v0.AddArg(x)
26886 v0.AddArg(y)
26887 b.SetControl(v0)
26888 b.Aux = nil
26889 return true
26890 }
26891
26892
26893
26894 for v.Op == OpARMCMPconst {
26895 if v.AuxInt != 0 {
26896 break
26897 }
26898 l := v.Args[0]
26899 if l.Op != OpARMSUBshiftRL {
26900 break
26901 }
26902 c := l.AuxInt
26903 y := l.Args[1]
26904 x := l.Args[0]
26905 if !(l.Uses == 1) {
26906 break
26907 }
26908 b.Kind = BlockARMNE
26909 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags)
26910 v0.AuxInt = c
26911 v0.AddArg(x)
26912 v0.AddArg(y)
26913 b.SetControl(v0)
26914 b.Aux = nil
26915 return true
26916 }
26917
26918
26919
26920 for v.Op == OpARMCMPconst {
26921 if v.AuxInt != 0 {
26922 break
26923 }
26924 l := v.Args[0]
26925 if l.Op != OpARMSUBshiftRA {
26926 break
26927 }
26928 c := l.AuxInt
26929 y := l.Args[1]
26930 x := l.Args[0]
26931 if !(l.Uses == 1) {
26932 break
26933 }
26934 b.Kind = BlockARMNE
26935 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags)
26936 v0.AuxInt = c
26937 v0.AddArg(x)
26938 v0.AddArg(y)
26939 b.SetControl(v0)
26940 b.Aux = nil
26941 return true
26942 }
26943
26944
26945
26946 for v.Op == OpARMCMPconst {
26947 if v.AuxInt != 0 {
26948 break
26949 }
26950 l := v.Args[0]
26951 if l.Op != OpARMSUBshiftLLreg {
26952 break
26953 }
26954 z := l.Args[2]
26955 x := l.Args[0]
26956 y := l.Args[1]
26957 if !(l.Uses == 1) {
26958 break
26959 }
26960 b.Kind = BlockARMNE
26961 v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
26962 v0.AddArg(x)
26963 v0.AddArg(y)
26964 v0.AddArg(z)
26965 b.SetControl(v0)
26966 b.Aux = nil
26967 return true
26968 }
26969
26970
26971
26972 for v.Op == OpARMCMPconst {
26973 if v.AuxInt != 0 {
26974 break
26975 }
26976 l := v.Args[0]
26977 if l.Op != OpARMSUBshiftRLreg {
26978 break
26979 }
26980 z := l.Args[2]
26981 x := l.Args[0]
26982 y := l.Args[1]
26983 if !(l.Uses == 1) {
26984 break
26985 }
26986 b.Kind = BlockARMNE
26987 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
26988 v0.AddArg(x)
26989 v0.AddArg(y)
26990 v0.AddArg(z)
26991 b.SetControl(v0)
26992 b.Aux = nil
26993 return true
26994 }
26995
26996
26997
26998 for v.Op == OpARMCMPconst {
26999 if v.AuxInt != 0 {
27000 break
27001 }
27002 l := v.Args[0]
27003 if l.Op != OpARMSUBshiftRAreg {
27004 break
27005 }
27006 z := l.Args[2]
27007 x := l.Args[0]
27008 y := l.Args[1]
27009 if !(l.Uses == 1) {
27010 break
27011 }
27012 b.Kind = BlockARMNE
27013 v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
27014 v0.AddArg(x)
27015 v0.AddArg(y)
27016 v0.AddArg(z)
27017 b.SetControl(v0)
27018 b.Aux = nil
27019 return true
27020 }
27021
27022
27023
27024 for v.Op == OpARMCMPconst {
27025 if v.AuxInt != 0 {
27026 break
27027 }
27028 l := v.Args[0]
27029 if l.Op != OpARMADD {
27030 break
27031 }
27032 y := l.Args[1]
27033 x := l.Args[0]
27034 if !(l.Uses == 1) {
27035 break
27036 }
27037 b.Kind = BlockARMNE
27038 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
27039 v0.AddArg(x)
27040 v0.AddArg(y)
27041 b.SetControl(v0)
27042 b.Aux = nil
27043 return true
27044 }
27045
27046
27047
27048 for v.Op == OpARMCMPconst {
27049 if v.AuxInt != 0 {
27050 break
27051 }
27052 l := v.Args[0]
27053 if l.Op != OpARMMULA {
27054 break
27055 }
27056 a := l.Args[2]
27057 x := l.Args[0]
27058 y := l.Args[1]
27059 if !(l.Uses == 1) {
27060 break
27061 }
27062 b.Kind = BlockARMNE
27063 v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
27064 v0.AddArg(a)
27065 v1 := b.NewValue0(v.Pos, OpARMMUL, x.Type)
27066 v1.AddArg(x)
27067 v1.AddArg(y)
27068 v0.AddArg(v1)
27069 b.SetControl(v0)
27070 b.Aux = nil
27071 return true
27072 }
27073
27074
27075
27076 for v.Op == OpARMCMPconst {
27077 if v.AuxInt != 0 {
27078 break
27079 }
27080 l := v.Args[0]
27081 if l.Op != OpARMADDconst {
27082 break
27083 }
27084 c := l.AuxInt
27085 x := l.Args[0]
27086 if !(l.Uses == 1) {
27087 break
27088 }
27089 b.Kind = BlockARMNE
27090 v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags)
27091 v0.AuxInt = c
27092 v0.AddArg(x)
27093 b.SetControl(v0)
27094 b.Aux = nil
27095 return true
27096 }
27097
27098
27099
27100 for v.Op == OpARMCMPconst {
27101 if v.AuxInt != 0 {
27102 break
27103 }
27104 l := v.Args[0]
27105 if l.Op != OpARMADDshiftLL {
27106 break
27107 }
27108 c := l.AuxInt
27109 y := l.Args[1]
27110 x := l.Args[0]
27111 if !(l.Uses == 1) {
27112 break
27113 }
27114 b.Kind = BlockARMNE
27115 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags)
27116 v0.AuxInt = c
27117 v0.AddArg(x)
27118 v0.AddArg(y)
27119 b.SetControl(v0)
27120 b.Aux = nil
27121 return true
27122 }
27123
27124
27125
27126 for v.Op == OpARMCMPconst {
27127 if v.AuxInt != 0 {
27128 break
27129 }
27130 l := v.Args[0]
27131 if l.Op != OpARMADDshiftRL {
27132 break
27133 }
27134 c := l.AuxInt
27135 y := l.Args[1]
27136 x := l.Args[0]
27137 if !(l.Uses == 1) {
27138 break
27139 }
27140 b.Kind = BlockARMNE
27141 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags)
27142 v0.AuxInt = c
27143 v0.AddArg(x)
27144 v0.AddArg(y)
27145 b.SetControl(v0)
27146 b.Aux = nil
27147 return true
27148 }
27149
27150
27151
27152 for v.Op == OpARMCMPconst {
27153 if v.AuxInt != 0 {
27154 break
27155 }
27156 l := v.Args[0]
27157 if l.Op != OpARMADDshiftRA {
27158 break
27159 }
27160 c := l.AuxInt
27161 y := l.Args[1]
27162 x := l.Args[0]
27163 if !(l.Uses == 1) {
27164 break
27165 }
27166 b.Kind = BlockARMNE
27167 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags)
27168 v0.AuxInt = c
27169 v0.AddArg(x)
27170 v0.AddArg(y)
27171 b.SetControl(v0)
27172 b.Aux = nil
27173 return true
27174 }
27175
27176
27177
27178 for v.Op == OpARMCMPconst {
27179 if v.AuxInt != 0 {
27180 break
27181 }
27182 l := v.Args[0]
27183 if l.Op != OpARMADDshiftLLreg {
27184 break
27185 }
27186 z := l.Args[2]
27187 x := l.Args[0]
27188 y := l.Args[1]
27189 if !(l.Uses == 1) {
27190 break
27191 }
27192 b.Kind = BlockARMNE
27193 v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
27194 v0.AddArg(x)
27195 v0.AddArg(y)
27196 v0.AddArg(z)
27197 b.SetControl(v0)
27198 b.Aux = nil
27199 return true
27200 }
27201
27202
27203
27204 for v.Op == OpARMCMPconst {
27205 if v.AuxInt != 0 {
27206 break
27207 }
27208 l := v.Args[0]
27209 if l.Op != OpARMADDshiftRLreg {
27210 break
27211 }
27212 z := l.Args[2]
27213 x := l.Args[0]
27214 y := l.Args[1]
27215 if !(l.Uses == 1) {
27216 break
27217 }
27218 b.Kind = BlockARMNE
27219 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
27220 v0.AddArg(x)
27221 v0.AddArg(y)
27222 v0.AddArg(z)
27223 b.SetControl(v0)
27224 b.Aux = nil
27225 return true
27226 }
27227
27228
27229
27230 for v.Op == OpARMCMPconst {
27231 if v.AuxInt != 0 {
27232 break
27233 }
27234 l := v.Args[0]
27235 if l.Op != OpARMADDshiftRAreg {
27236 break
27237 }
27238 z := l.Args[2]
27239 x := l.Args[0]
27240 y := l.Args[1]
27241 if !(l.Uses == 1) {
27242 break
27243 }
27244 b.Kind = BlockARMNE
27245 v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
27246 v0.AddArg(x)
27247 v0.AddArg(y)
27248 v0.AddArg(z)
27249 b.SetControl(v0)
27250 b.Aux = nil
27251 return true
27252 }
27253
27254
27255
27256 for v.Op == OpARMCMPconst {
27257 if v.AuxInt != 0 {
27258 break
27259 }
27260 l := v.Args[0]
27261 if l.Op != OpARMAND {
27262 break
27263 }
27264 y := l.Args[1]
27265 x := l.Args[0]
27266 if !(l.Uses == 1) {
27267 break
27268 }
27269 b.Kind = BlockARMNE
27270 v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags)
27271 v0.AddArg(x)
27272 v0.AddArg(y)
27273 b.SetControl(v0)
27274 b.Aux = nil
27275 return true
27276 }
27277
27278
27279
27280 for v.Op == OpARMCMPconst {
27281 if v.AuxInt != 0 {
27282 break
27283 }
27284 l := v.Args[0]
27285 if l.Op != OpARMANDconst {
27286 break
27287 }
27288 c := l.AuxInt
27289 x := l.Args[0]
27290 if !(l.Uses == 1) {
27291 break
27292 }
27293 b.Kind = BlockARMNE
27294 v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags)
27295 v0.AuxInt = c
27296 v0.AddArg(x)
27297 b.SetControl(v0)
27298 b.Aux = nil
27299 return true
27300 }
27301
27302
27303
27304 for v.Op == OpARMCMPconst {
27305 if v.AuxInt != 0 {
27306 break
27307 }
27308 l := v.Args[0]
27309 if l.Op != OpARMANDshiftLL {
27310 break
27311 }
27312 c := l.AuxInt
27313 y := l.Args[1]
27314 x := l.Args[0]
27315 if !(l.Uses == 1) {
27316 break
27317 }
27318 b.Kind = BlockARMNE
27319 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags)
27320 v0.AuxInt = c
27321 v0.AddArg(x)
27322 v0.AddArg(y)
27323 b.SetControl(v0)
27324 b.Aux = nil
27325 return true
27326 }
27327
27328
27329
27330 for v.Op == OpARMCMPconst {
27331 if v.AuxInt != 0 {
27332 break
27333 }
27334 l := v.Args[0]
27335 if l.Op != OpARMANDshiftRL {
27336 break
27337 }
27338 c := l.AuxInt
27339 y := l.Args[1]
27340 x := l.Args[0]
27341 if !(l.Uses == 1) {
27342 break
27343 }
27344 b.Kind = BlockARMNE
27345 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags)
27346 v0.AuxInt = c
27347 v0.AddArg(x)
27348 v0.AddArg(y)
27349 b.SetControl(v0)
27350 b.Aux = nil
27351 return true
27352 }
27353
27354
27355
27356 for v.Op == OpARMCMPconst {
27357 if v.AuxInt != 0 {
27358 break
27359 }
27360 l := v.Args[0]
27361 if l.Op != OpARMANDshiftRA {
27362 break
27363 }
27364 c := l.AuxInt
27365 y := l.Args[1]
27366 x := l.Args[0]
27367 if !(l.Uses == 1) {
27368 break
27369 }
27370 b.Kind = BlockARMNE
27371 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags)
27372 v0.AuxInt = c
27373 v0.AddArg(x)
27374 v0.AddArg(y)
27375 b.SetControl(v0)
27376 b.Aux = nil
27377 return true
27378 }
27379
27380
27381
27382 for v.Op == OpARMCMPconst {
27383 if v.AuxInt != 0 {
27384 break
27385 }
27386 l := v.Args[0]
27387 if l.Op != OpARMANDshiftLLreg {
27388 break
27389 }
27390 z := l.Args[2]
27391 x := l.Args[0]
27392 y := l.Args[1]
27393 if !(l.Uses == 1) {
27394 break
27395 }
27396 b.Kind = BlockARMNE
27397 v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
27398 v0.AddArg(x)
27399 v0.AddArg(y)
27400 v0.AddArg(z)
27401 b.SetControl(v0)
27402 b.Aux = nil
27403 return true
27404 }
27405
27406
27407
27408 for v.Op == OpARMCMPconst {
27409 if v.AuxInt != 0 {
27410 break
27411 }
27412 l := v.Args[0]
27413 if l.Op != OpARMANDshiftRLreg {
27414 break
27415 }
27416 z := l.Args[2]
27417 x := l.Args[0]
27418 y := l.Args[1]
27419 if !(l.Uses == 1) {
27420 break
27421 }
27422 b.Kind = BlockARMNE
27423 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
27424 v0.AddArg(x)
27425 v0.AddArg(y)
27426 v0.AddArg(z)
27427 b.SetControl(v0)
27428 b.Aux = nil
27429 return true
27430 }
27431
27432
27433
27434 for v.Op == OpARMCMPconst {
27435 if v.AuxInt != 0 {
27436 break
27437 }
27438 l := v.Args[0]
27439 if l.Op != OpARMANDshiftRAreg {
27440 break
27441 }
27442 z := l.Args[2]
27443 x := l.Args[0]
27444 y := l.Args[1]
27445 if !(l.Uses == 1) {
27446 break
27447 }
27448 b.Kind = BlockARMNE
27449 v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
27450 v0.AddArg(x)
27451 v0.AddArg(y)
27452 v0.AddArg(z)
27453 b.SetControl(v0)
27454 b.Aux = nil
27455 return true
27456 }
27457
27458
27459
27460 for v.Op == OpARMCMPconst {
27461 if v.AuxInt != 0 {
27462 break
27463 }
27464 l := v.Args[0]
27465 if l.Op != OpARMXOR {
27466 break
27467 }
27468 y := l.Args[1]
27469 x := l.Args[0]
27470 if !(l.Uses == 1) {
27471 break
27472 }
27473 b.Kind = BlockARMNE
27474 v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags)
27475 v0.AddArg(x)
27476 v0.AddArg(y)
27477 b.SetControl(v0)
27478 b.Aux = nil
27479 return true
27480 }
27481
27482
27483
27484 for v.Op == OpARMCMPconst {
27485 if v.AuxInt != 0 {
27486 break
27487 }
27488 l := v.Args[0]
27489 if l.Op != OpARMXORconst {
27490 break
27491 }
27492 c := l.AuxInt
27493 x := l.Args[0]
27494 if !(l.Uses == 1) {
27495 break
27496 }
27497 b.Kind = BlockARMNE
27498 v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags)
27499 v0.AuxInt = c
27500 v0.AddArg(x)
27501 b.SetControl(v0)
27502 b.Aux = nil
27503 return true
27504 }
27505
27506
27507
27508 for v.Op == OpARMCMPconst {
27509 if v.AuxInt != 0 {
27510 break
27511 }
27512 l := v.Args[0]
27513 if l.Op != OpARMXORshiftLL {
27514 break
27515 }
27516 c := l.AuxInt
27517 y := l.Args[1]
27518 x := l.Args[0]
27519 if !(l.Uses == 1) {
27520 break
27521 }
27522 b.Kind = BlockARMNE
27523 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags)
27524 v0.AuxInt = c
27525 v0.AddArg(x)
27526 v0.AddArg(y)
27527 b.SetControl(v0)
27528 b.Aux = nil
27529 return true
27530 }
27531
27532
27533
27534 for v.Op == OpARMCMPconst {
27535 if v.AuxInt != 0 {
27536 break
27537 }
27538 l := v.Args[0]
27539 if l.Op != OpARMXORshiftRL {
27540 break
27541 }
27542 c := l.AuxInt
27543 y := l.Args[1]
27544 x := l.Args[0]
27545 if !(l.Uses == 1) {
27546 break
27547 }
27548 b.Kind = BlockARMNE
27549 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags)
27550 v0.AuxInt = c
27551 v0.AddArg(x)
27552 v0.AddArg(y)
27553 b.SetControl(v0)
27554 b.Aux = nil
27555 return true
27556 }
27557
27558
27559
27560 for v.Op == OpARMCMPconst {
27561 if v.AuxInt != 0 {
27562 break
27563 }
27564 l := v.Args[0]
27565 if l.Op != OpARMXORshiftRA {
27566 break
27567 }
27568 c := l.AuxInt
27569 y := l.Args[1]
27570 x := l.Args[0]
27571 if !(l.Uses == 1) {
27572 break
27573 }
27574 b.Kind = BlockARMNE
27575 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags)
27576 v0.AuxInt = c
27577 v0.AddArg(x)
27578 v0.AddArg(y)
27579 b.SetControl(v0)
27580 b.Aux = nil
27581 return true
27582 }
27583
27584
27585
27586 for v.Op == OpARMCMPconst {
27587 if v.AuxInt != 0 {
27588 break
27589 }
27590 l := v.Args[0]
27591 if l.Op != OpARMXORshiftLLreg {
27592 break
27593 }
27594 z := l.Args[2]
27595 x := l.Args[0]
27596 y := l.Args[1]
27597 if !(l.Uses == 1) {
27598 break
27599 }
27600 b.Kind = BlockARMNE
27601 v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
27602 v0.AddArg(x)
27603 v0.AddArg(y)
27604 v0.AddArg(z)
27605 b.SetControl(v0)
27606 b.Aux = nil
27607 return true
27608 }
27609
27610
27611
27612 for v.Op == OpARMCMPconst {
27613 if v.AuxInt != 0 {
27614 break
27615 }
27616 l := v.Args[0]
27617 if l.Op != OpARMXORshiftRLreg {
27618 break
27619 }
27620 z := l.Args[2]
27621 x := l.Args[0]
27622 y := l.Args[1]
27623 if !(l.Uses == 1) {
27624 break
27625 }
27626 b.Kind = BlockARMNE
27627 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
27628 v0.AddArg(x)
27629 v0.AddArg(y)
27630 v0.AddArg(z)
27631 b.SetControl(v0)
27632 b.Aux = nil
27633 return true
27634 }
27635
27636
27637
27638 for v.Op == OpARMCMPconst {
27639 if v.AuxInt != 0 {
27640 break
27641 }
27642 l := v.Args[0]
27643 if l.Op != OpARMXORshiftRAreg {
27644 break
27645 }
27646 z := l.Args[2]
27647 x := l.Args[0]
27648 y := l.Args[1]
27649 if !(l.Uses == 1) {
27650 break
27651 }
27652 b.Kind = BlockARMNE
27653 v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
27654 v0.AddArg(x)
27655 v0.AddArg(y)
27656 v0.AddArg(z)
27657 b.SetControl(v0)
27658 b.Aux = nil
27659 return true
27660 }
27661 case BlockARMUGE:
27662
27663
27664
27665 for v.Op == OpARMFlagEQ {
27666 b.Kind = BlockFirst
27667 b.SetControl(nil)
27668 b.Aux = nil
27669 return true
27670 }
27671
27672
27673
27674 for v.Op == OpARMFlagLT_ULT {
27675 b.Kind = BlockFirst
27676 b.SetControl(nil)
27677 b.Aux = nil
27678 b.swapSuccessors()
27679 return true
27680 }
27681
27682
27683
27684 for v.Op == OpARMFlagLT_UGT {
27685 b.Kind = BlockFirst
27686 b.SetControl(nil)
27687 b.Aux = nil
27688 return true
27689 }
27690
27691
27692
27693 for v.Op == OpARMFlagGT_ULT {
27694 b.Kind = BlockFirst
27695 b.SetControl(nil)
27696 b.Aux = nil
27697 b.swapSuccessors()
27698 return true
27699 }
27700
27701
27702
27703 for v.Op == OpARMFlagGT_UGT {
27704 b.Kind = BlockFirst
27705 b.SetControl(nil)
27706 b.Aux = nil
27707 return true
27708 }
27709
27710
27711
27712 for v.Op == OpARMInvertFlags {
27713 cmp := v.Args[0]
27714 b.Kind = BlockARMULE
27715 b.SetControl(cmp)
27716 b.Aux = nil
27717 return true
27718 }
27719 case BlockARMUGT:
27720
27721
27722
27723 for v.Op == OpARMFlagEQ {
27724 b.Kind = BlockFirst
27725 b.SetControl(nil)
27726 b.Aux = nil
27727 b.swapSuccessors()
27728 return true
27729 }
27730
27731
27732
27733 for v.Op == OpARMFlagLT_ULT {
27734 b.Kind = BlockFirst
27735 b.SetControl(nil)
27736 b.Aux = nil
27737 b.swapSuccessors()
27738 return true
27739 }
27740
27741
27742
27743 for v.Op == OpARMFlagLT_UGT {
27744 b.Kind = BlockFirst
27745 b.SetControl(nil)
27746 b.Aux = nil
27747 return true
27748 }
27749
27750
27751
27752 for v.Op == OpARMFlagGT_ULT {
27753 b.Kind = BlockFirst
27754 b.SetControl(nil)
27755 b.Aux = nil
27756 b.swapSuccessors()
27757 return true
27758 }
27759
27760
27761
27762 for v.Op == OpARMFlagGT_UGT {
27763 b.Kind = BlockFirst
27764 b.SetControl(nil)
27765 b.Aux = nil
27766 return true
27767 }
27768
27769
27770
27771 for v.Op == OpARMInvertFlags {
27772 cmp := v.Args[0]
27773 b.Kind = BlockARMULT
27774 b.SetControl(cmp)
27775 b.Aux = nil
27776 return true
27777 }
27778 case BlockARMULE:
27779
27780
27781
27782 for v.Op == OpARMFlagEQ {
27783 b.Kind = BlockFirst
27784 b.SetControl(nil)
27785 b.Aux = nil
27786 return true
27787 }
27788
27789
27790
27791 for v.Op == OpARMFlagLT_ULT {
27792 b.Kind = BlockFirst
27793 b.SetControl(nil)
27794 b.Aux = nil
27795 return true
27796 }
27797
27798
27799
27800 for v.Op == OpARMFlagLT_UGT {
27801 b.Kind = BlockFirst
27802 b.SetControl(nil)
27803 b.Aux = nil
27804 b.swapSuccessors()
27805 return true
27806 }
27807
27808
27809
27810 for v.Op == OpARMFlagGT_ULT {
27811 b.Kind = BlockFirst
27812 b.SetControl(nil)
27813 b.Aux = nil
27814 return true
27815 }
27816
27817
27818
27819 for v.Op == OpARMFlagGT_UGT {
27820 b.Kind = BlockFirst
27821 b.SetControl(nil)
27822 b.Aux = nil
27823 b.swapSuccessors()
27824 return true
27825 }
27826
27827
27828
27829 for v.Op == OpARMInvertFlags {
27830 cmp := v.Args[0]
27831 b.Kind = BlockARMUGE
27832 b.SetControl(cmp)
27833 b.Aux = nil
27834 return true
27835 }
27836 case BlockARMULT:
27837
27838
27839
27840 for v.Op == OpARMFlagEQ {
27841 b.Kind = BlockFirst
27842 b.SetControl(nil)
27843 b.Aux = nil
27844 b.swapSuccessors()
27845 return true
27846 }
27847
27848
27849
27850 for v.Op == OpARMFlagLT_ULT {
27851 b.Kind = BlockFirst
27852 b.SetControl(nil)
27853 b.Aux = nil
27854 return true
27855 }
27856
27857
27858
27859 for v.Op == OpARMFlagLT_UGT {
27860 b.Kind = BlockFirst
27861 b.SetControl(nil)
27862 b.Aux = nil
27863 b.swapSuccessors()
27864 return true
27865 }
27866
27867
27868
27869 for v.Op == OpARMFlagGT_ULT {
27870 b.Kind = BlockFirst
27871 b.SetControl(nil)
27872 b.Aux = nil
27873 return true
27874 }
27875
27876
27877
27878 for v.Op == OpARMFlagGT_UGT {
27879 b.Kind = BlockFirst
27880 b.SetControl(nil)
27881 b.Aux = nil
27882 b.swapSuccessors()
27883 return true
27884 }
27885
27886
27887
27888 for v.Op == OpARMInvertFlags {
27889 cmp := v.Args[0]
27890 b.Kind = BlockARMUGT
27891 b.SetControl(cmp)
27892 b.Aux = nil
27893 return true
27894 }
27895 }
27896 return false
27897 }
27898
View as plain text