1
2
3 package ssa
4
5 import "cmd/compile/internal/types"
6 import "cmd/compile/internal/ssa/block"
7
8 func rewriteValueARM64(v *Value) bool {
9 switch v.Op {
10 case OpARM64ADCSflags:
11 return rewriteValueARM64_OpARM64ADCSflags(v)
12 case OpARM64ADD:
13 return rewriteValueARM64_OpARM64ADD(v)
14 case OpARM64ADDSflags:
15 return rewriteValueARM64_OpARM64ADDSflags(v)
16 case OpARM64ADDconst:
17 return rewriteValueARM64_OpARM64ADDconst(v)
18 case OpARM64ADDshiftLL:
19 return rewriteValueARM64_OpARM64ADDshiftLL(v)
20 case OpARM64ADDshiftRA:
21 return rewriteValueARM64_OpARM64ADDshiftRA(v)
22 case OpARM64ADDshiftRL:
23 return rewriteValueARM64_OpARM64ADDshiftRL(v)
24 case OpARM64AND:
25 return rewriteValueARM64_OpARM64AND(v)
26 case OpARM64ANDconst:
27 return rewriteValueARM64_OpARM64ANDconst(v)
28 case OpARM64ANDshiftLL:
29 return rewriteValueARM64_OpARM64ANDshiftLL(v)
30 case OpARM64ANDshiftRA:
31 return rewriteValueARM64_OpARM64ANDshiftRA(v)
32 case OpARM64ANDshiftRL:
33 return rewriteValueARM64_OpARM64ANDshiftRL(v)
34 case OpARM64ANDshiftRO:
35 return rewriteValueARM64_OpARM64ANDshiftRO(v)
36 case OpARM64BIC:
37 return rewriteValueARM64_OpARM64BIC(v)
38 case OpARM64BICshiftLL:
39 return rewriteValueARM64_OpARM64BICshiftLL(v)
40 case OpARM64BICshiftRA:
41 return rewriteValueARM64_OpARM64BICshiftRA(v)
42 case OpARM64BICshiftRL:
43 return rewriteValueARM64_OpARM64BICshiftRL(v)
44 case OpARM64BICshiftRO:
45 return rewriteValueARM64_OpARM64BICshiftRO(v)
46 case OpARM64CMN:
47 return rewriteValueARM64_OpARM64CMN(v)
48 case OpARM64CMNW:
49 return rewriteValueARM64_OpARM64CMNW(v)
50 case OpARM64CMNWconst:
51 return rewriteValueARM64_OpARM64CMNWconst(v)
52 case OpARM64CMNconst:
53 return rewriteValueARM64_OpARM64CMNconst(v)
54 case OpARM64CMNshiftLL:
55 return rewriteValueARM64_OpARM64CMNshiftLL(v)
56 case OpARM64CMNshiftRA:
57 return rewriteValueARM64_OpARM64CMNshiftRA(v)
58 case OpARM64CMNshiftRL:
59 return rewriteValueARM64_OpARM64CMNshiftRL(v)
60 case OpARM64CMP:
61 return rewriteValueARM64_OpARM64CMP(v)
62 case OpARM64CMPW:
63 return rewriteValueARM64_OpARM64CMPW(v)
64 case OpARM64CMPWconst:
65 return rewriteValueARM64_OpARM64CMPWconst(v)
66 case OpARM64CMPconst:
67 return rewriteValueARM64_OpARM64CMPconst(v)
68 case OpARM64CMPshiftLL:
69 return rewriteValueARM64_OpARM64CMPshiftLL(v)
70 case OpARM64CMPshiftRA:
71 return rewriteValueARM64_OpARM64CMPshiftRA(v)
72 case OpARM64CMPshiftRL:
73 return rewriteValueARM64_OpARM64CMPshiftRL(v)
74 case OpARM64CSEL:
75 return rewriteValueARM64_OpARM64CSEL(v)
76 case OpARM64CSEL0:
77 return rewriteValueARM64_OpARM64CSEL0(v)
78 case OpARM64CSETM:
79 return rewriteValueARM64_OpARM64CSETM(v)
80 case OpARM64CSINC:
81 return rewriteValueARM64_OpARM64CSINC(v)
82 case OpARM64CSINV:
83 return rewriteValueARM64_OpARM64CSINV(v)
84 case OpARM64CSNEG:
85 return rewriteValueARM64_OpARM64CSNEG(v)
86 case OpARM64DIV:
87 return rewriteValueARM64_OpARM64DIV(v)
88 case OpARM64DIVW:
89 return rewriteValueARM64_OpARM64DIVW(v)
90 case OpARM64EON:
91 return rewriteValueARM64_OpARM64EON(v)
92 case OpARM64EONshiftLL:
93 return rewriteValueARM64_OpARM64EONshiftLL(v)
94 case OpARM64EONshiftRA:
95 return rewriteValueARM64_OpARM64EONshiftRA(v)
96 case OpARM64EONshiftRL:
97 return rewriteValueARM64_OpARM64EONshiftRL(v)
98 case OpARM64EONshiftRO:
99 return rewriteValueARM64_OpARM64EONshiftRO(v)
100 case OpARM64Equal:
101 return rewriteValueARM64_OpARM64Equal(v)
102 case OpARM64FADDD:
103 return rewriteValueARM64_OpARM64FADDD(v)
104 case OpARM64FADDS:
105 return rewriteValueARM64_OpARM64FADDS(v)
106 case OpARM64FCMPD:
107 return rewriteValueARM64_OpARM64FCMPD(v)
108 case OpARM64FCMPS:
109 return rewriteValueARM64_OpARM64FCMPS(v)
110 case OpARM64FCSELD:
111 return rewriteValueARM64_OpARM64FCSELD(v)
112 case OpARM64FCSELS:
113 return rewriteValueARM64_OpARM64FCSELS(v)
114 case OpARM64FCVTDS:
115 return rewriteValueARM64_OpARM64FCVTDS(v)
116 case OpARM64FLDPQ:
117 return rewriteValueARM64_OpARM64FLDPQ(v)
118 case OpARM64FMOVDfpgp:
119 return rewriteValueARM64_OpARM64FMOVDfpgp(v)
120 case OpARM64FMOVDgpfp:
121 return rewriteValueARM64_OpARM64FMOVDgpfp(v)
122 case OpARM64FMOVDload:
123 return rewriteValueARM64_OpARM64FMOVDload(v)
124 case OpARM64FMOVDloadidx:
125 return rewriteValueARM64_OpARM64FMOVDloadidx(v)
126 case OpARM64FMOVDloadidx8:
127 return rewriteValueARM64_OpARM64FMOVDloadidx8(v)
128 case OpARM64FMOVDstore:
129 return rewriteValueARM64_OpARM64FMOVDstore(v)
130 case OpARM64FMOVDstoreidx:
131 return rewriteValueARM64_OpARM64FMOVDstoreidx(v)
132 case OpARM64FMOVDstoreidx8:
133 return rewriteValueARM64_OpARM64FMOVDstoreidx8(v)
134 case OpARM64FMOVQload:
135 return rewriteValueARM64_OpARM64FMOVQload(v)
136 case OpARM64FMOVQstore:
137 return rewriteValueARM64_OpARM64FMOVQstore(v)
138 case OpARM64FMOVSload:
139 return rewriteValueARM64_OpARM64FMOVSload(v)
140 case OpARM64FMOVSloadidx:
141 return rewriteValueARM64_OpARM64FMOVSloadidx(v)
142 case OpARM64FMOVSloadidx4:
143 return rewriteValueARM64_OpARM64FMOVSloadidx4(v)
144 case OpARM64FMOVSstore:
145 return rewriteValueARM64_OpARM64FMOVSstore(v)
146 case OpARM64FMOVSstoreidx:
147 return rewriteValueARM64_OpARM64FMOVSstoreidx(v)
148 case OpARM64FMOVSstoreidx4:
149 return rewriteValueARM64_OpARM64FMOVSstoreidx4(v)
150 case OpARM64FMULD:
151 return rewriteValueARM64_OpARM64FMULD(v)
152 case OpARM64FMULS:
153 return rewriteValueARM64_OpARM64FMULS(v)
154 case OpARM64FNEGD:
155 return rewriteValueARM64_OpARM64FNEGD(v)
156 case OpARM64FNEGS:
157 return rewriteValueARM64_OpARM64FNEGS(v)
158 case OpARM64FNMULD:
159 return rewriteValueARM64_OpARM64FNMULD(v)
160 case OpARM64FNMULS:
161 return rewriteValueARM64_OpARM64FNMULS(v)
162 case OpARM64FSTPQ:
163 return rewriteValueARM64_OpARM64FSTPQ(v)
164 case OpARM64FSUBD:
165 return rewriteValueARM64_OpARM64FSUBD(v)
166 case OpARM64FSUBS:
167 return rewriteValueARM64_OpARM64FSUBS(v)
168 case OpARM64GreaterEqual:
169 return rewriteValueARM64_OpARM64GreaterEqual(v)
170 case OpARM64GreaterEqualF:
171 return rewriteValueARM64_OpARM64GreaterEqualF(v)
172 case OpARM64GreaterEqualNoov:
173 return rewriteValueARM64_OpARM64GreaterEqualNoov(v)
174 case OpARM64GreaterEqualU:
175 return rewriteValueARM64_OpARM64GreaterEqualU(v)
176 case OpARM64GreaterThan:
177 return rewriteValueARM64_OpARM64GreaterThan(v)
178 case OpARM64GreaterThanF:
179 return rewriteValueARM64_OpARM64GreaterThanF(v)
180 case OpARM64GreaterThanU:
181 return rewriteValueARM64_OpARM64GreaterThanU(v)
182 case OpARM64LDP:
183 return rewriteValueARM64_OpARM64LDP(v)
184 case OpARM64LessEqual:
185 return rewriteValueARM64_OpARM64LessEqual(v)
186 case OpARM64LessEqualF:
187 return rewriteValueARM64_OpARM64LessEqualF(v)
188 case OpARM64LessEqualU:
189 return rewriteValueARM64_OpARM64LessEqualU(v)
190 case OpARM64LessThan:
191 return rewriteValueARM64_OpARM64LessThan(v)
192 case OpARM64LessThanF:
193 return rewriteValueARM64_OpARM64LessThanF(v)
194 case OpARM64LessThanNoov:
195 return rewriteValueARM64_OpARM64LessThanNoov(v)
196 case OpARM64LessThanU:
197 return rewriteValueARM64_OpARM64LessThanU(v)
198 case OpARM64LoweredPanicBoundsCR:
199 return rewriteValueARM64_OpARM64LoweredPanicBoundsCR(v)
200 case OpARM64LoweredPanicBoundsRC:
201 return rewriteValueARM64_OpARM64LoweredPanicBoundsRC(v)
202 case OpARM64LoweredPanicBoundsRR:
203 return rewriteValueARM64_OpARM64LoweredPanicBoundsRR(v)
204 case OpARM64MADD:
205 return rewriteValueARM64_OpARM64MADD(v)
206 case OpARM64MADDW:
207 return rewriteValueARM64_OpARM64MADDW(v)
208 case OpARM64MNEG:
209 return rewriteValueARM64_OpARM64MNEG(v)
210 case OpARM64MNEGW:
211 return rewriteValueARM64_OpARM64MNEGW(v)
212 case OpARM64MOD:
213 return rewriteValueARM64_OpARM64MOD(v)
214 case OpARM64MODW:
215 return rewriteValueARM64_OpARM64MODW(v)
216 case OpARM64MOVBUload:
217 return rewriteValueARM64_OpARM64MOVBUload(v)
218 case OpARM64MOVBUloadidx:
219 return rewriteValueARM64_OpARM64MOVBUloadidx(v)
220 case OpARM64MOVBUreg:
221 return rewriteValueARM64_OpARM64MOVBUreg(v)
222 case OpARM64MOVBload:
223 return rewriteValueARM64_OpARM64MOVBload(v)
224 case OpARM64MOVBloadidx:
225 return rewriteValueARM64_OpARM64MOVBloadidx(v)
226 case OpARM64MOVBreg:
227 return rewriteValueARM64_OpARM64MOVBreg(v)
228 case OpARM64MOVBstore:
229 return rewriteValueARM64_OpARM64MOVBstore(v)
230 case OpARM64MOVBstoreidx:
231 return rewriteValueARM64_OpARM64MOVBstoreidx(v)
232 case OpARM64MOVDload:
233 return rewriteValueARM64_OpARM64MOVDload(v)
234 case OpARM64MOVDloadidx:
235 return rewriteValueARM64_OpARM64MOVDloadidx(v)
236 case OpARM64MOVDloadidx8:
237 return rewriteValueARM64_OpARM64MOVDloadidx8(v)
238 case OpARM64MOVDnop:
239 return rewriteValueARM64_OpARM64MOVDnop(v)
240 case OpARM64MOVDreg:
241 return rewriteValueARM64_OpARM64MOVDreg(v)
242 case OpARM64MOVDstore:
243 return rewriteValueARM64_OpARM64MOVDstore(v)
244 case OpARM64MOVDstoreidx:
245 return rewriteValueARM64_OpARM64MOVDstoreidx(v)
246 case OpARM64MOVDstoreidx8:
247 return rewriteValueARM64_OpARM64MOVDstoreidx8(v)
248 case OpARM64MOVHUload:
249 return rewriteValueARM64_OpARM64MOVHUload(v)
250 case OpARM64MOVHUloadidx:
251 return rewriteValueARM64_OpARM64MOVHUloadidx(v)
252 case OpARM64MOVHUloadidx2:
253 return rewriteValueARM64_OpARM64MOVHUloadidx2(v)
254 case OpARM64MOVHUreg:
255 return rewriteValueARM64_OpARM64MOVHUreg(v)
256 case OpARM64MOVHload:
257 return rewriteValueARM64_OpARM64MOVHload(v)
258 case OpARM64MOVHloadidx:
259 return rewriteValueARM64_OpARM64MOVHloadidx(v)
260 case OpARM64MOVHloadidx2:
261 return rewriteValueARM64_OpARM64MOVHloadidx2(v)
262 case OpARM64MOVHreg:
263 return rewriteValueARM64_OpARM64MOVHreg(v)
264 case OpARM64MOVHstore:
265 return rewriteValueARM64_OpARM64MOVHstore(v)
266 case OpARM64MOVHstoreidx:
267 return rewriteValueARM64_OpARM64MOVHstoreidx(v)
268 case OpARM64MOVHstoreidx2:
269 return rewriteValueARM64_OpARM64MOVHstoreidx2(v)
270 case OpARM64MOVWUload:
271 return rewriteValueARM64_OpARM64MOVWUload(v)
272 case OpARM64MOVWUloadidx:
273 return rewriteValueARM64_OpARM64MOVWUloadidx(v)
274 case OpARM64MOVWUloadidx4:
275 return rewriteValueARM64_OpARM64MOVWUloadidx4(v)
276 case OpARM64MOVWUreg:
277 return rewriteValueARM64_OpARM64MOVWUreg(v)
278 case OpARM64MOVWload:
279 return rewriteValueARM64_OpARM64MOVWload(v)
280 case OpARM64MOVWloadidx:
281 return rewriteValueARM64_OpARM64MOVWloadidx(v)
282 case OpARM64MOVWloadidx4:
283 return rewriteValueARM64_OpARM64MOVWloadidx4(v)
284 case OpARM64MOVWreg:
285 return rewriteValueARM64_OpARM64MOVWreg(v)
286 case OpARM64MOVWstore:
287 return rewriteValueARM64_OpARM64MOVWstore(v)
288 case OpARM64MOVWstoreidx:
289 return rewriteValueARM64_OpARM64MOVWstoreidx(v)
290 case OpARM64MOVWstoreidx4:
291 return rewriteValueARM64_OpARM64MOVWstoreidx4(v)
292 case OpARM64MSUB:
293 return rewriteValueARM64_OpARM64MSUB(v)
294 case OpARM64MSUBW:
295 return rewriteValueARM64_OpARM64MSUBW(v)
296 case OpARM64MUL:
297 return rewriteValueARM64_OpARM64MUL(v)
298 case OpARM64MULW:
299 return rewriteValueARM64_OpARM64MULW(v)
300 case OpARM64MVN:
301 return rewriteValueARM64_OpARM64MVN(v)
302 case OpARM64MVNshiftLL:
303 return rewriteValueARM64_OpARM64MVNshiftLL(v)
304 case OpARM64MVNshiftRA:
305 return rewriteValueARM64_OpARM64MVNshiftRA(v)
306 case OpARM64MVNshiftRL:
307 return rewriteValueARM64_OpARM64MVNshiftRL(v)
308 case OpARM64MVNshiftRO:
309 return rewriteValueARM64_OpARM64MVNshiftRO(v)
310 case OpARM64NEG:
311 return rewriteValueARM64_OpARM64NEG(v)
312 case OpARM64NEGshiftLL:
313 return rewriteValueARM64_OpARM64NEGshiftLL(v)
314 case OpARM64NEGshiftRA:
315 return rewriteValueARM64_OpARM64NEGshiftRA(v)
316 case OpARM64NEGshiftRL:
317 return rewriteValueARM64_OpARM64NEGshiftRL(v)
318 case OpARM64NotEqual:
319 return rewriteValueARM64_OpARM64NotEqual(v)
320 case OpARM64OR:
321 return rewriteValueARM64_OpARM64OR(v)
322 case OpARM64ORN:
323 return rewriteValueARM64_OpARM64ORN(v)
324 case OpARM64ORNshiftLL:
325 return rewriteValueARM64_OpARM64ORNshiftLL(v)
326 case OpARM64ORNshiftRA:
327 return rewriteValueARM64_OpARM64ORNshiftRA(v)
328 case OpARM64ORNshiftRL:
329 return rewriteValueARM64_OpARM64ORNshiftRL(v)
330 case OpARM64ORNshiftRO:
331 return rewriteValueARM64_OpARM64ORNshiftRO(v)
332 case OpARM64ORconst:
333 return rewriteValueARM64_OpARM64ORconst(v)
334 case OpARM64ORshiftLL:
335 return rewriteValueARM64_OpARM64ORshiftLL(v)
336 case OpARM64ORshiftRA:
337 return rewriteValueARM64_OpARM64ORshiftRA(v)
338 case OpARM64ORshiftRL:
339 return rewriteValueARM64_OpARM64ORshiftRL(v)
340 case OpARM64ORshiftRO:
341 return rewriteValueARM64_OpARM64ORshiftRO(v)
342 case OpARM64REV:
343 return rewriteValueARM64_OpARM64REV(v)
344 case OpARM64REV16:
345 return rewriteValueARM64_OpARM64REV16(v)
346 case OpARM64REVW:
347 return rewriteValueARM64_OpARM64REVW(v)
348 case OpARM64ROR:
349 return rewriteValueARM64_OpARM64ROR(v)
350 case OpARM64RORW:
351 return rewriteValueARM64_OpARM64RORW(v)
352 case OpARM64SBCSflags:
353 return rewriteValueARM64_OpARM64SBCSflags(v)
354 case OpARM64SBFX:
355 return rewriteValueARM64_OpARM64SBFX(v)
356 case OpARM64SLL:
357 return rewriteValueARM64_OpARM64SLL(v)
358 case OpARM64SLLconst:
359 return rewriteValueARM64_OpARM64SLLconst(v)
360 case OpARM64SRA:
361 return rewriteValueARM64_OpARM64SRA(v)
362 case OpARM64SRAconst:
363 return rewriteValueARM64_OpARM64SRAconst(v)
364 case OpARM64SRL:
365 return rewriteValueARM64_OpARM64SRL(v)
366 case OpARM64SRLconst:
367 return rewriteValueARM64_OpARM64SRLconst(v)
368 case OpARM64STP:
369 return rewriteValueARM64_OpARM64STP(v)
370 case OpARM64SUB:
371 return rewriteValueARM64_OpARM64SUB(v)
372 case OpARM64SUBconst:
373 return rewriteValueARM64_OpARM64SUBconst(v)
374 case OpARM64SUBshiftLL:
375 return rewriteValueARM64_OpARM64SUBshiftLL(v)
376 case OpARM64SUBshiftRA:
377 return rewriteValueARM64_OpARM64SUBshiftRA(v)
378 case OpARM64SUBshiftRL:
379 return rewriteValueARM64_OpARM64SUBshiftRL(v)
380 case OpARM64TST:
381 return rewriteValueARM64_OpARM64TST(v)
382 case OpARM64TSTW:
383 return rewriteValueARM64_OpARM64TSTW(v)
384 case OpARM64TSTWconst:
385 return rewriteValueARM64_OpARM64TSTWconst(v)
386 case OpARM64TSTconst:
387 return rewriteValueARM64_OpARM64TSTconst(v)
388 case OpARM64TSTshiftLL:
389 return rewriteValueARM64_OpARM64TSTshiftLL(v)
390 case OpARM64TSTshiftRA:
391 return rewriteValueARM64_OpARM64TSTshiftRA(v)
392 case OpARM64TSTshiftRL:
393 return rewriteValueARM64_OpARM64TSTshiftRL(v)
394 case OpARM64TSTshiftRO:
395 return rewriteValueARM64_OpARM64TSTshiftRO(v)
396 case OpARM64UBFIZ:
397 return rewriteValueARM64_OpARM64UBFIZ(v)
398 case OpARM64UBFX:
399 return rewriteValueARM64_OpARM64UBFX(v)
400 case OpARM64UDIV:
401 return rewriteValueARM64_OpARM64UDIV(v)
402 case OpARM64UDIVW:
403 return rewriteValueARM64_OpARM64UDIVW(v)
404 case OpARM64UMOD:
405 return rewriteValueARM64_OpARM64UMOD(v)
406 case OpARM64UMODW:
407 return rewriteValueARM64_OpARM64UMODW(v)
408 case OpARM64VBIF16B:
409 return rewriteValueARM64_OpARM64VBIF16B(v)
410 case OpARM64VBIT16B:
411 return rewriteValueARM64_OpARM64VBIT16B(v)
412 case OpARM64VDUPBbcast:
413 return rewriteValueARM64_OpARM64VDUPBbcast(v)
414 case OpARM64VFCVTL4S:
415 return rewriteValueARM64_OpARM64VFCVTL4S(v)
416 case OpARM64VMOVDins0:
417 return rewriteValueARM64_OpARM64VMOVDins0(v)
418 case OpARM64VMOVSins0:
419 return rewriteValueARM64_OpARM64VMOVSins0(v)
420 case OpARM64VPMULL2D:
421 return rewriteValueARM64_OpARM64VPMULL2D(v)
422 case OpARM64VSHL16B:
423 return rewriteValueARM64_OpARM64VSHL16B(v)
424 case OpARM64VSHL2D:
425 return rewriteValueARM64_OpARM64VSHL2D(v)
426 case OpARM64VSHL4S:
427 return rewriteValueARM64_OpARM64VSHL4S(v)
428 case OpARM64VSHL8H:
429 return rewriteValueARM64_OpARM64VSHL8H(v)
430 case OpARM64VSHRN2D:
431 return rewriteValueARM64_OpARM64VSHRN2D(v)
432 case OpARM64VSHRN4S:
433 return rewriteValueARM64_OpARM64VSHRN4S(v)
434 case OpARM64VSHRN8H:
435 return rewriteValueARM64_OpARM64VSHRN8H(v)
436 case OpARM64VSMULL16B:
437 return rewriteValueARM64_OpARM64VSMULL16B(v)
438 case OpARM64VSMULL4S:
439 return rewriteValueARM64_OpARM64VSMULL4S(v)
440 case OpARM64VSMULL8H:
441 return rewriteValueARM64_OpARM64VSMULL8H(v)
442 case OpARM64VSQSHL16Bconst:
443 return rewriteValueARM64_OpARM64VSQSHL16Bconst(v)
444 case OpARM64VSQSHL2Dconst:
445 return rewriteValueARM64_OpARM64VSQSHL2Dconst(v)
446 case OpARM64VSQSHL4Sconst:
447 return rewriteValueARM64_OpARM64VSQSHL4Sconst(v)
448 case OpARM64VSQSHL8Hconst:
449 return rewriteValueARM64_OpARM64VSQSHL8Hconst(v)
450 case OpARM64VSSHLL16B:
451 return rewriteValueARM64_OpARM64VSSHLL16B(v)
452 case OpARM64VSSHLL4S:
453 return rewriteValueARM64_OpARM64VSSHLL4S(v)
454 case OpARM64VSSHLL8H:
455 return rewriteValueARM64_OpARM64VSSHLL8H(v)
456 case OpARM64VSSHR16B:
457 return rewriteValueARM64_OpARM64VSSHR16B(v)
458 case OpARM64VSSHR2D:
459 return rewriteValueARM64_OpARM64VSSHR2D(v)
460 case OpARM64VSSHR4S:
461 return rewriteValueARM64_OpARM64VSSHR4S(v)
462 case OpARM64VSSHR8H:
463 return rewriteValueARM64_OpARM64VSSHR8H(v)
464 case OpARM64VSXTL16B:
465 return rewriteValueARM64_OpARM64VSXTL16B(v)
466 case OpARM64VSXTL4S:
467 return rewriteValueARM64_OpARM64VSXTL4S(v)
468 case OpARM64VSXTL8H:
469 return rewriteValueARM64_OpARM64VSXTL8H(v)
470 case OpARM64VUMULL16B:
471 return rewriteValueARM64_OpARM64VUMULL16B(v)
472 case OpARM64VUMULL4S:
473 return rewriteValueARM64_OpARM64VUMULL4S(v)
474 case OpARM64VUMULL8H:
475 return rewriteValueARM64_OpARM64VUMULL8H(v)
476 case OpARM64VUQSHL16Bconst:
477 return rewriteValueARM64_OpARM64VUQSHL16Bconst(v)
478 case OpARM64VUQSHL2Dconst:
479 return rewriteValueARM64_OpARM64VUQSHL2Dconst(v)
480 case OpARM64VUQSHL4Sconst:
481 return rewriteValueARM64_OpARM64VUQSHL4Sconst(v)
482 case OpARM64VUQSHL8Hconst:
483 return rewriteValueARM64_OpARM64VUQSHL8Hconst(v)
484 case OpARM64VUSHLL16B:
485 return rewriteValueARM64_OpARM64VUSHLL16B(v)
486 case OpARM64VUSHLL4S:
487 return rewriteValueARM64_OpARM64VUSHLL4S(v)
488 case OpARM64VUSHLL8H:
489 return rewriteValueARM64_OpARM64VUSHLL8H(v)
490 case OpARM64VUSHR16B:
491 return rewriteValueARM64_OpARM64VUSHR16B(v)
492 case OpARM64VUSHR2D:
493 return rewriteValueARM64_OpARM64VUSHR2D(v)
494 case OpARM64VUSHR4S:
495 return rewriteValueARM64_OpARM64VUSHR4S(v)
496 case OpARM64VUSHR8H:
497 return rewriteValueARM64_OpARM64VUSHR8H(v)
498 case OpARM64VUXTL16B:
499 return rewriteValueARM64_OpARM64VUXTL16B(v)
500 case OpARM64VUXTL4S:
501 return rewriteValueARM64_OpARM64VUXTL4S(v)
502 case OpARM64VUXTL8H:
503 return rewriteValueARM64_OpARM64VUXTL8H(v)
504 case OpARM64XOR:
505 return rewriteValueARM64_OpARM64XOR(v)
506 case OpARM64XORconst:
507 return rewriteValueARM64_OpARM64XORconst(v)
508 case OpARM64XORshiftLL:
509 return rewriteValueARM64_OpARM64XORshiftLL(v)
510 case OpARM64XORshiftRA:
511 return rewriteValueARM64_OpARM64XORshiftRA(v)
512 case OpARM64XORshiftRL:
513 return rewriteValueARM64_OpARM64XORshiftRL(v)
514 case OpARM64XORshiftRO:
515 return rewriteValueARM64_OpARM64XORshiftRO(v)
516 case OpAbs:
517 v.Op = OpARM64FABSD
518 return true
519 case OpAbsFloat32x4:
520 v.Op = OpARM64VFABS4S
521 return true
522 case OpAbsFloat64x2:
523 v.Op = OpARM64VFABS2D
524 return true
525 case OpAbsInt16x8:
526 v.Op = OpARM64VABS8H
527 return true
528 case OpAbsInt32x4:
529 v.Op = OpARM64VABS4S
530 return true
531 case OpAbsInt64x2:
532 v.Op = OpARM64VABS2D
533 return true
534 case OpAbsInt8x16:
535 v.Op = OpARM64VABS16B
536 return true
537 case OpAdd16:
538 v.Op = OpARM64ADD
539 return true
540 case OpAdd32:
541 v.Op = OpARM64ADD
542 return true
543 case OpAdd32F:
544 v.Op = OpARM64FADDS
545 return true
546 case OpAdd64:
547 v.Op = OpARM64ADD
548 return true
549 case OpAdd64F:
550 v.Op = OpARM64FADDD
551 return true
552 case OpAdd8:
553 v.Op = OpARM64ADD
554 return true
555 case OpAddFloat32x4:
556 v.Op = OpARM64VFADD4S
557 return true
558 case OpAddFloat64x2:
559 v.Op = OpARM64VFADD2D
560 return true
561 case OpAddInt16x8:
562 v.Op = OpARM64VADD8H
563 return true
564 case OpAddInt32x4:
565 v.Op = OpARM64VADD4S
566 return true
567 case OpAddInt64x2:
568 v.Op = OpARM64VADD2D
569 return true
570 case OpAddInt8s:
571 return rewriteValueARM64_OpAddInt8s(v)
572 case OpAddInt8x16:
573 v.Op = OpARM64VADD16B
574 return true
575 case OpAddPtr:
576 v.Op = OpARM64ADD
577 return true
578 case OpAddSaturatedInt16x8:
579 v.Op = OpARM64VSQADD8H
580 return true
581 case OpAddSaturatedInt32x4:
582 v.Op = OpARM64VSQADD4S
583 return true
584 case OpAddSaturatedInt64x2:
585 v.Op = OpARM64VSQADD2D
586 return true
587 case OpAddSaturatedInt8x16:
588 v.Op = OpARM64VSQADD16B
589 return true
590 case OpAddSaturatedUint16x8:
591 v.Op = OpARM64VUQADD8H
592 return true
593 case OpAddSaturatedUint32x4:
594 v.Op = OpARM64VUQADD4S
595 return true
596 case OpAddSaturatedUint64x2:
597 v.Op = OpARM64VUQADD2D
598 return true
599 case OpAddSaturatedUint8x16:
600 v.Op = OpARM64VUQADD16B
601 return true
602 case OpAddUint16x8:
603 v.Op = OpARM64VADD8H
604 return true
605 case OpAddUint32x4:
606 v.Op = OpARM64VADD4S
607 return true
608 case OpAddUint64x2:
609 v.Op = OpARM64VADD2D
610 return true
611 case OpAddUint8x16:
612 v.Op = OpARM64VADD16B
613 return true
614 case OpAddr:
615 return rewriteValueARM64_OpAddr(v)
616 case OpAnd16:
617 v.Op = OpARM64AND
618 return true
619 case OpAnd32:
620 v.Op = OpARM64AND
621 return true
622 case OpAnd64:
623 v.Op = OpARM64AND
624 return true
625 case OpAnd8:
626 v.Op = OpARM64AND
627 return true
628 case OpAndB:
629 v.Op = OpARM64AND
630 return true
631 case OpAndInt16x8:
632 v.Op = OpARM64VAND16B
633 return true
634 case OpAndInt32x4:
635 v.Op = OpARM64VAND16B
636 return true
637 case OpAndInt64x2:
638 v.Op = OpARM64VAND16B
639 return true
640 case OpAndInt8x16:
641 v.Op = OpARM64VAND16B
642 return true
643 case OpAndNotInt16x8:
644 v.Op = OpARM64VBIC16B
645 return true
646 case OpAndNotInt32x4:
647 v.Op = OpARM64VBIC16B
648 return true
649 case OpAndNotInt64x2:
650 v.Op = OpARM64VBIC16B
651 return true
652 case OpAndNotInt8x16:
653 v.Op = OpARM64VBIC16B
654 return true
655 case OpAndNotUint16x8:
656 v.Op = OpARM64VBIC16B
657 return true
658 case OpAndNotUint32x4:
659 v.Op = OpARM64VBIC16B
660 return true
661 case OpAndNotUint64x2:
662 v.Op = OpARM64VBIC16B
663 return true
664 case OpAndNotUint8x16:
665 v.Op = OpARM64VBIC16B
666 return true
667 case OpAndUint16x8:
668 v.Op = OpARM64VAND16B
669 return true
670 case OpAndUint32x4:
671 v.Op = OpARM64VAND16B
672 return true
673 case OpAndUint64x2:
674 v.Op = OpARM64VAND16B
675 return true
676 case OpAndUint8x16:
677 v.Op = OpARM64VAND16B
678 return true
679 case OpAtomicAdd32:
680 v.Op = OpARM64LoweredAtomicAdd32
681 return true
682 case OpAtomicAdd32Variant:
683 v.Op = OpARM64LoweredAtomicAdd32Variant
684 return true
685 case OpAtomicAdd64:
686 v.Op = OpARM64LoweredAtomicAdd64
687 return true
688 case OpAtomicAdd64Variant:
689 v.Op = OpARM64LoweredAtomicAdd64Variant
690 return true
691 case OpAtomicAnd32value:
692 v.Op = OpARM64LoweredAtomicAnd32
693 return true
694 case OpAtomicAnd32valueVariant:
695 v.Op = OpARM64LoweredAtomicAnd32Variant
696 return true
697 case OpAtomicAnd64value:
698 v.Op = OpARM64LoweredAtomicAnd64
699 return true
700 case OpAtomicAnd64valueVariant:
701 v.Op = OpARM64LoweredAtomicAnd64Variant
702 return true
703 case OpAtomicAnd8value:
704 v.Op = OpARM64LoweredAtomicAnd8
705 return true
706 case OpAtomicAnd8valueVariant:
707 v.Op = OpARM64LoweredAtomicAnd8Variant
708 return true
709 case OpAtomicCompareAndSwap32:
710 v.Op = OpARM64LoweredAtomicCas32
711 return true
712 case OpAtomicCompareAndSwap32Variant:
713 v.Op = OpARM64LoweredAtomicCas32Variant
714 return true
715 case OpAtomicCompareAndSwap64:
716 v.Op = OpARM64LoweredAtomicCas64
717 return true
718 case OpAtomicCompareAndSwap64Variant:
719 v.Op = OpARM64LoweredAtomicCas64Variant
720 return true
721 case OpAtomicExchange32:
722 v.Op = OpARM64LoweredAtomicExchange32
723 return true
724 case OpAtomicExchange32Variant:
725 v.Op = OpARM64LoweredAtomicExchange32Variant
726 return true
727 case OpAtomicExchange64:
728 v.Op = OpARM64LoweredAtomicExchange64
729 return true
730 case OpAtomicExchange64Variant:
731 v.Op = OpARM64LoweredAtomicExchange64Variant
732 return true
733 case OpAtomicExchange8:
734 v.Op = OpARM64LoweredAtomicExchange8
735 return true
736 case OpAtomicExchange8Variant:
737 v.Op = OpARM64LoweredAtomicExchange8Variant
738 return true
739 case OpAtomicLoad32:
740 v.Op = OpARM64LDARW
741 return true
742 case OpAtomicLoad64:
743 v.Op = OpARM64LDAR
744 return true
745 case OpAtomicLoad8:
746 v.Op = OpARM64LDARB
747 return true
748 case OpAtomicLoadPtr:
749 v.Op = OpARM64LDAR
750 return true
751 case OpAtomicOr32value:
752 v.Op = OpARM64LoweredAtomicOr32
753 return true
754 case OpAtomicOr32valueVariant:
755 v.Op = OpARM64LoweredAtomicOr32Variant
756 return true
757 case OpAtomicOr64value:
758 v.Op = OpARM64LoweredAtomicOr64
759 return true
760 case OpAtomicOr64valueVariant:
761 v.Op = OpARM64LoweredAtomicOr64Variant
762 return true
763 case OpAtomicOr8value:
764 v.Op = OpARM64LoweredAtomicOr8
765 return true
766 case OpAtomicOr8valueVariant:
767 v.Op = OpARM64LoweredAtomicOr8Variant
768 return true
769 case OpAtomicStore32:
770 v.Op = OpARM64STLRW
771 return true
772 case OpAtomicStore64:
773 v.Op = OpARM64STLR
774 return true
775 case OpAtomicStore8:
776 v.Op = OpARM64STLRB
777 return true
778 case OpAtomicStorePtrNoWB:
779 v.Op = OpARM64STLR
780 return true
781 case OpAverageInt16x8:
782 v.Op = OpARM64VSRHADD8H
783 return true
784 case OpAverageInt32x4:
785 v.Op = OpARM64VSRHADD4S
786 return true
787 case OpAverageInt8x16:
788 v.Op = OpARM64VSRHADD16B
789 return true
790 case OpAverageUint16x8:
791 v.Op = OpARM64VURHADD8H
792 return true
793 case OpAverageUint32x4:
794 v.Op = OpARM64VURHADD4S
795 return true
796 case OpAverageUint8x16:
797 v.Op = OpARM64VURHADD16B
798 return true
799 case OpAvg64u:
800 return rewriteValueARM64_OpAvg64u(v)
801 case OpBitLen16:
802 return rewriteValueARM64_OpBitLen16(v)
803 case OpBitLen32:
804 return rewriteValueARM64_OpBitLen32(v)
805 case OpBitLen64:
806 return rewriteValueARM64_OpBitLen64(v)
807 case OpBitLen8:
808 return rewriteValueARM64_OpBitLen8(v)
809 case OpBitRev16:
810 return rewriteValueARM64_OpBitRev16(v)
811 case OpBitRev32:
812 v.Op = OpARM64RBITW
813 return true
814 case OpBitRev64:
815 v.Op = OpARM64RBIT
816 return true
817 case OpBitRev8:
818 return rewriteValueARM64_OpBitRev8(v)
819 case OpBswap16:
820 v.Op = OpARM64REV16W
821 return true
822 case OpBswap32:
823 v.Op = OpARM64REVW
824 return true
825 case OpBswap64:
826 v.Op = OpARM64REV
827 return true
828 case OpCeil:
829 v.Op = OpARM64FRINTPD
830 return true
831 case OpCeilFloat32x4:
832 v.Op = OpARM64VFRINTP4S
833 return true
834 case OpCeilFloat64x2:
835 v.Op = OpARM64VFRINTP2D
836 return true
837 case OpClosureCall:
838 v.Op = OpARM64CALLclosure
839 return true
840 case OpCom16:
841 v.Op = OpARM64MVN
842 return true
843 case OpCom32:
844 v.Op = OpARM64MVN
845 return true
846 case OpCom64:
847 v.Op = OpARM64MVN
848 return true
849 case OpCom8:
850 v.Op = OpARM64MVN
851 return true
852 case OpConcatAddPairsFloat32x4:
853 v.Op = OpARM64VFADDP4S
854 return true
855 case OpConcatAddPairsFloat64x2:
856 v.Op = OpARM64VFADDP2D
857 return true
858 case OpConcatAddPairsInt16x8:
859 v.Op = OpARM64VADDP8H
860 return true
861 case OpConcatAddPairsInt32x4:
862 v.Op = OpARM64VADDP4S
863 return true
864 case OpConcatAddPairsInt64x2:
865 v.Op = OpARM64VADDP2D
866 return true
867 case OpConcatAddPairsUint16x8:
868 v.Op = OpARM64VADDP8H
869 return true
870 case OpConcatAddPairsUint32x4:
871 v.Op = OpARM64VADDP4S
872 return true
873 case OpConcatAddPairsUint64x2:
874 v.Op = OpARM64VADDP2D
875 return true
876 case OpConcatEvenInt16x8:
877 v.Op = OpARM64VUZP18H
878 return true
879 case OpConcatEvenInt32x4:
880 v.Op = OpARM64VUZP14S
881 return true
882 case OpConcatEvenInt64x2:
883 v.Op = OpARM64VUZP12D
884 return true
885 case OpConcatEvenInt8x16:
886 v.Op = OpARM64VUZP116B
887 return true
888 case OpConcatEvenUint16x8:
889 v.Op = OpARM64VUZP18H
890 return true
891 case OpConcatEvenUint32x4:
892 v.Op = OpARM64VUZP14S
893 return true
894 case OpConcatEvenUint64x2:
895 v.Op = OpARM64VUZP12D
896 return true
897 case OpConcatEvenUint8x16:
898 v.Op = OpARM64VUZP116B
899 return true
900 case OpConcatOddInt16x8:
901 v.Op = OpARM64VUZP28H
902 return true
903 case OpConcatOddInt32x4:
904 v.Op = OpARM64VUZP24S
905 return true
906 case OpConcatOddInt64x2:
907 v.Op = OpARM64VUZP22D
908 return true
909 case OpConcatOddInt8x16:
910 v.Op = OpARM64VUZP216B
911 return true
912 case OpConcatOddUint16x8:
913 v.Op = OpARM64VUZP28H
914 return true
915 case OpConcatOddUint32x4:
916 v.Op = OpARM64VUZP24S
917 return true
918 case OpConcatOddUint64x2:
919 v.Op = OpARM64VUZP22D
920 return true
921 case OpConcatOddUint8x16:
922 v.Op = OpARM64VUZP216B
923 return true
924 case OpConcatShiftBytesRightUint8x16:
925 v.Op = OpARM64VEXT16B
926 return true
927 case OpCondSelect:
928 return rewriteValueARM64_OpCondSelect(v)
929 case OpConst16:
930 return rewriteValueARM64_OpConst16(v)
931 case OpConst32:
932 return rewriteValueARM64_OpConst32(v)
933 case OpConst32F:
934 return rewriteValueARM64_OpConst32F(v)
935 case OpConst64:
936 return rewriteValueARM64_OpConst64(v)
937 case OpConst64F:
938 return rewriteValueARM64_OpConst64F(v)
939 case OpConst8:
940 return rewriteValueARM64_OpConst8(v)
941 case OpConstBool:
942 return rewriteValueARM64_OpConstBool(v)
943 case OpConstNil:
944 return rewriteValueARM64_OpConstNil(v)
945 case OpConvertLo2ToFloat64Float32x4:
946 v.Op = OpARM64VFCVTL4S
947 return true
948 case OpConvertToFloat32Float64x2:
949 v.Op = OpARM64VFCVTN2D
950 return true
951 case OpConvertToFloat32Int32x4:
952 v.Op = OpARM64VSCVTF4S
953 return true
954 case OpConvertToFloat32Uint32x4:
955 v.Op = OpARM64VUCVTF4S
956 return true
957 case OpConvertToFloat64Int64x2:
958 v.Op = OpARM64VSCVTF2D
959 return true
960 case OpConvertToFloat64Uint64x2:
961 v.Op = OpARM64VUCVTF2D
962 return true
963 case OpConvertToInt32Float32x4:
964 v.Op = OpARM64VFCVTZS4S
965 return true
966 case OpConvertToInt64Float64x2:
967 v.Op = OpARM64VFCVTZS2D
968 return true
969 case OpConvertToUint32Float32x4:
970 v.Op = OpARM64VFCVTZU4S
971 return true
972 case OpConvertToUint64Float64x2:
973 v.Op = OpARM64VFCVTZU2D
974 return true
975 case OpCount8s:
976 return rewriteValueARM64_OpCount8s(v)
977 case OpCtz16:
978 return rewriteValueARM64_OpCtz16(v)
979 case OpCtz16NonZero:
980 v.Op = OpCtz32
981 return true
982 case OpCtz32:
983 return rewriteValueARM64_OpCtz32(v)
984 case OpCtz32NonZero:
985 v.Op = OpCtz32
986 return true
987 case OpCtz64:
988 return rewriteValueARM64_OpCtz64(v)
989 case OpCtz64NonZero:
990 v.Op = OpCtz64
991 return true
992 case OpCtz8:
993 return rewriteValueARM64_OpCtz8(v)
994 case OpCtz8NonZero:
995 v.Op = OpCtz32
996 return true
997 case OpCvt32Fto32:
998 v.Op = OpARM64FCVTZSSW
999 return true
1000 case OpCvt32Fto32U:
1001 v.Op = OpARM64FCVTZUSW
1002 return true
1003 case OpCvt32Fto64:
1004 v.Op = OpARM64FCVTZSS
1005 return true
1006 case OpCvt32Fto64F:
1007 v.Op = OpARM64FCVTSD
1008 return true
1009 case OpCvt32Fto64U:
1010 v.Op = OpARM64FCVTZUS
1011 return true
1012 case OpCvt32Uto32F:
1013 v.Op = OpARM64UCVTFWS
1014 return true
1015 case OpCvt32Uto64F:
1016 v.Op = OpARM64UCVTFWD
1017 return true
1018 case OpCvt32to32F:
1019 v.Op = OpARM64SCVTFWS
1020 return true
1021 case OpCvt32to64F:
1022 v.Op = OpARM64SCVTFWD
1023 return true
1024 case OpCvt64Fto32:
1025 v.Op = OpARM64FCVTZSDW
1026 return true
1027 case OpCvt64Fto32F:
1028 v.Op = OpARM64FCVTDS
1029 return true
1030 case OpCvt64Fto32U:
1031 v.Op = OpARM64FCVTZUDW
1032 return true
1033 case OpCvt64Fto64:
1034 v.Op = OpARM64FCVTZSD
1035 return true
1036 case OpCvt64Fto64U:
1037 v.Op = OpARM64FCVTZUD
1038 return true
1039 case OpCvt64Uto32F:
1040 v.Op = OpARM64UCVTFS
1041 return true
1042 case OpCvt64Uto64F:
1043 v.Op = OpARM64UCVTFD
1044 return true
1045 case OpCvt64to32F:
1046 v.Op = OpARM64SCVTFS
1047 return true
1048 case OpCvt64to64F:
1049 v.Op = OpARM64SCVTFD
1050 return true
1051 case OpCvtBoolToUint8:
1052 v.Op = OpCopy
1053 return true
1054 case OpDiv16:
1055 return rewriteValueARM64_OpDiv16(v)
1056 case OpDiv16u:
1057 return rewriteValueARM64_OpDiv16u(v)
1058 case OpDiv32:
1059 return rewriteValueARM64_OpDiv32(v)
1060 case OpDiv32F:
1061 v.Op = OpARM64FDIVS
1062 return true
1063 case OpDiv32u:
1064 v.Op = OpARM64UDIVW
1065 return true
1066 case OpDiv64:
1067 return rewriteValueARM64_OpDiv64(v)
1068 case OpDiv64F:
1069 v.Op = OpARM64FDIVD
1070 return true
1071 case OpDiv64u:
1072 v.Op = OpARM64UDIV
1073 return true
1074 case OpDiv8:
1075 return rewriteValueARM64_OpDiv8(v)
1076 case OpDiv8u:
1077 return rewriteValueARM64_OpDiv8u(v)
1078 case OpDivFloat32x4:
1079 v.Op = OpARM64VFDIV4S
1080 return true
1081 case OpDivFloat64x2:
1082 v.Op = OpARM64VFDIV2D
1083 return true
1084 case OpEq16:
1085 return rewriteValueARM64_OpEq16(v)
1086 case OpEq32:
1087 return rewriteValueARM64_OpEq32(v)
1088 case OpEq32F:
1089 return rewriteValueARM64_OpEq32F(v)
1090 case OpEq64:
1091 return rewriteValueARM64_OpEq64(v)
1092 case OpEq64F:
1093 return rewriteValueARM64_OpEq64F(v)
1094 case OpEq8:
1095 return rewriteValueARM64_OpEq8(v)
1096 case OpEqB:
1097 return rewriteValueARM64_OpEqB(v)
1098 case OpEqPtr:
1099 return rewriteValueARM64_OpEqPtr(v)
1100 case OpEqualFloat32x4:
1101 v.Op = OpARM64VFCMEQ4S
1102 return true
1103 case OpEqualFloat64x2:
1104 v.Op = OpARM64VFCMEQ2D
1105 return true
1106 case OpEqualInt16x8:
1107 v.Op = OpARM64VCMEQ8H
1108 return true
1109 case OpEqualInt32x4:
1110 v.Op = OpARM64VCMEQ4S
1111 return true
1112 case OpEqualInt64x2:
1113 v.Op = OpARM64VCMEQ2D
1114 return true
1115 case OpEqualInt8x16:
1116 v.Op = OpARM64VCMEQ16B
1117 return true
1118 case OpEqualUint16x8:
1119 v.Op = OpARM64VCMEQ8H
1120 return true
1121 case OpEqualUint32x4:
1122 v.Op = OpARM64VCMEQ4S
1123 return true
1124 case OpEqualUint64x2:
1125 v.Op = OpARM64VCMEQ2D
1126 return true
1127 case OpEqualUint8x16:
1128 v.Op = OpARM64VCMEQ16B
1129 return true
1130 case OpExtendLo2ToInt64Int32x4:
1131 v.Op = OpARM64VSXTL4S
1132 return true
1133 case OpExtendLo2ToUint64Uint32x4:
1134 v.Op = OpARM64VUXTL4S
1135 return true
1136 case OpExtendLo4ToInt32Int16x8:
1137 v.Op = OpARM64VSXTL8H
1138 return true
1139 case OpExtendLo4ToUint32Uint16x8:
1140 v.Op = OpARM64VUXTL8H
1141 return true
1142 case OpExtendLo8ToInt16Int8x16:
1143 v.Op = OpARM64VSXTL16B
1144 return true
1145 case OpExtendLo8ToUint16Uint8x16:
1146 v.Op = OpARM64VUXTL16B
1147 return true
1148 case OpFMA:
1149 return rewriteValueARM64_OpFMA(v)
1150 case OpFloor:
1151 v.Op = OpARM64FRINTMD
1152 return true
1153 case OpFloorFloat32x4:
1154 v.Op = OpARM64VFRINTM4S
1155 return true
1156 case OpFloorFloat64x2:
1157 v.Op = OpARM64VFRINTM2D
1158 return true
1159 case OpGetCallerPC:
1160 v.Op = OpARM64LoweredGetCallerPC
1161 return true
1162 case OpGetCallerSP:
1163 v.Op = OpARM64LoweredGetCallerSP
1164 return true
1165 case OpGetClosurePtr:
1166 v.Op = OpARM64LoweredGetClosurePtr
1167 return true
1168 case OpGetElemFloat32x4:
1169 v.Op = OpARM64VDUPSextr
1170 return true
1171 case OpGetElemFloat64x2:
1172 v.Op = OpARM64VDUPDextr
1173 return true
1174 case OpGetElemInt16x8:
1175 v.Op = OpARM64VMOVHextr
1176 return true
1177 case OpGetElemInt32x4:
1178 v.Op = OpARM64VMOVSextr
1179 return true
1180 case OpGetElemInt64x2:
1181 v.Op = OpARM64VMOVDextr
1182 return true
1183 case OpGetElemInt8x16:
1184 v.Op = OpARM64VMOVBextr
1185 return true
1186 case OpGetElemUint16x8:
1187 v.Op = OpARM64VMOVHextr
1188 return true
1189 case OpGetElemUint32x4:
1190 v.Op = OpARM64VMOVSextr
1191 return true
1192 case OpGetElemUint64x2:
1193 v.Op = OpARM64VMOVDextr
1194 return true
1195 case OpGetElemUint8x16:
1196 v.Op = OpARM64VMOVBextr
1197 return true
1198 case OpGreaterEqualFloat32x4:
1199 v.Op = OpARM64VFCMGE4S
1200 return true
1201 case OpGreaterEqualFloat64x2:
1202 v.Op = OpARM64VFCMGE2D
1203 return true
1204 case OpGreaterEqualInt16x8:
1205 v.Op = OpARM64VCMGE8H
1206 return true
1207 case OpGreaterEqualInt32x4:
1208 v.Op = OpARM64VCMGE4S
1209 return true
1210 case OpGreaterEqualInt64x2:
1211 v.Op = OpARM64VCMGE2D
1212 return true
1213 case OpGreaterEqualInt8x16:
1214 v.Op = OpARM64VCMGE16B
1215 return true
1216 case OpGreaterEqualUint16x8:
1217 v.Op = OpARM64VCMHS8H
1218 return true
1219 case OpGreaterEqualUint32x4:
1220 v.Op = OpARM64VCMHS4S
1221 return true
1222 case OpGreaterEqualUint64x2:
1223 v.Op = OpARM64VCMHS2D
1224 return true
1225 case OpGreaterEqualUint8x16:
1226 v.Op = OpARM64VCMHS16B
1227 return true
1228 case OpGreaterFloat32x4:
1229 v.Op = OpARM64VFCMGT4S
1230 return true
1231 case OpGreaterFloat64x2:
1232 v.Op = OpARM64VFCMGT2D
1233 return true
1234 case OpGreaterInt16x8:
1235 v.Op = OpARM64VCMGT8H
1236 return true
1237 case OpGreaterInt32x4:
1238 v.Op = OpARM64VCMGT4S
1239 return true
1240 case OpGreaterInt64x2:
1241 v.Op = OpARM64VCMGT2D
1242 return true
1243 case OpGreaterInt8s:
1244 return rewriteValueARM64_OpGreaterInt8s(v)
1245 case OpGreaterInt8x16:
1246 v.Op = OpARM64VCMGT16B
1247 return true
1248 case OpGreaterUint16x8:
1249 v.Op = OpARM64VCMHI8H
1250 return true
1251 case OpGreaterUint32x4:
1252 v.Op = OpARM64VCMHI4S
1253 return true
1254 case OpGreaterUint64x2:
1255 v.Op = OpARM64VCMHI2D
1256 return true
1257 case OpGreaterUint8x16:
1258 v.Op = OpARM64VCMHI16B
1259 return true
1260 case OpHmul32:
1261 return rewriteValueARM64_OpHmul32(v)
1262 case OpHmul32u:
1263 return rewriteValueARM64_OpHmul32u(v)
1264 case OpHmul64:
1265 v.Op = OpARM64MULH
1266 return true
1267 case OpHmul64u:
1268 v.Op = OpARM64UMULH
1269 return true
1270 case OpInterCall:
1271 v.Op = OpARM64CALLinter
1272 return true
1273 case OpInterleaveEvenInt16x8:
1274 v.Op = OpARM64VTRN18H
1275 return true
1276 case OpInterleaveEvenInt32x4:
1277 v.Op = OpARM64VTRN14S
1278 return true
1279 case OpInterleaveEvenInt64x2:
1280 v.Op = OpARM64VTRN12D
1281 return true
1282 case OpInterleaveEvenInt8x16:
1283 v.Op = OpARM64VTRN116B
1284 return true
1285 case OpInterleaveEvenUint16x8:
1286 v.Op = OpARM64VTRN18H
1287 return true
1288 case OpInterleaveEvenUint32x4:
1289 v.Op = OpARM64VTRN14S
1290 return true
1291 case OpInterleaveEvenUint64x2:
1292 v.Op = OpARM64VTRN12D
1293 return true
1294 case OpInterleaveEvenUint8x16:
1295 v.Op = OpARM64VTRN116B
1296 return true
1297 case OpInterleaveHiInt16x8:
1298 v.Op = OpARM64VZIP28H
1299 return true
1300 case OpInterleaveHiInt32x4:
1301 v.Op = OpARM64VZIP24S
1302 return true
1303 case OpInterleaveHiInt64x2:
1304 v.Op = OpARM64VZIP22D
1305 return true
1306 case OpInterleaveHiInt8x16:
1307 v.Op = OpARM64VZIP216B
1308 return true
1309 case OpInterleaveHiUint16x8:
1310 v.Op = OpARM64VZIP28H
1311 return true
1312 case OpInterleaveHiUint32x4:
1313 v.Op = OpARM64VZIP24S
1314 return true
1315 case OpInterleaveHiUint64x2:
1316 v.Op = OpARM64VZIP22D
1317 return true
1318 case OpInterleaveHiUint8x16:
1319 v.Op = OpARM64VZIP216B
1320 return true
1321 case OpInterleaveLoInt16x8:
1322 v.Op = OpARM64VZIP18H
1323 return true
1324 case OpInterleaveLoInt32x4:
1325 v.Op = OpARM64VZIP14S
1326 return true
1327 case OpInterleaveLoInt64x2:
1328 v.Op = OpARM64VZIP12D
1329 return true
1330 case OpInterleaveLoInt8x16:
1331 v.Op = OpARM64VZIP116B
1332 return true
1333 case OpInterleaveLoUint16x8:
1334 v.Op = OpARM64VZIP18H
1335 return true
1336 case OpInterleaveLoUint32x4:
1337 v.Op = OpARM64VZIP14S
1338 return true
1339 case OpInterleaveLoUint64x2:
1340 v.Op = OpARM64VZIP12D
1341 return true
1342 case OpInterleaveLoUint8x16:
1343 v.Op = OpARM64VZIP116B
1344 return true
1345 case OpInterleaveOddInt16x8:
1346 v.Op = OpARM64VTRN28H
1347 return true
1348 case OpInterleaveOddInt32x4:
1349 v.Op = OpARM64VTRN24S
1350 return true
1351 case OpInterleaveOddInt64x2:
1352 v.Op = OpARM64VTRN22D
1353 return true
1354 case OpInterleaveOddInt8x16:
1355 v.Op = OpARM64VTRN216B
1356 return true
1357 case OpInterleaveOddUint16x8:
1358 v.Op = OpARM64VTRN28H
1359 return true
1360 case OpInterleaveOddUint32x4:
1361 v.Op = OpARM64VTRN24S
1362 return true
1363 case OpInterleaveOddUint64x2:
1364 v.Op = OpARM64VTRN22D
1365 return true
1366 case OpInterleaveOddUint8x16:
1367 v.Op = OpARM64VTRN216B
1368 return true
1369 case OpIsInBounds:
1370 return rewriteValueARM64_OpIsInBounds(v)
1371 case OpIsNonNil:
1372 return rewriteValueARM64_OpIsNonNil(v)
1373 case OpIsSliceInBounds:
1374 return rewriteValueARM64_OpIsSliceInBounds(v)
1375 case OpLeadingSignBitsInt16x8:
1376 v.Op = OpARM64VCLS8H
1377 return true
1378 case OpLeadingSignBitsInt32x4:
1379 v.Op = OpARM64VCLS4S
1380 return true
1381 case OpLeadingSignBitsInt8x16:
1382 v.Op = OpARM64VCLS16B
1383 return true
1384 case OpLeadingSignBitsUint16x8:
1385 v.Op = OpARM64VCLS8H
1386 return true
1387 case OpLeadingSignBitsUint32x4:
1388 v.Op = OpARM64VCLS4S
1389 return true
1390 case OpLeadingSignBitsUint8x16:
1391 v.Op = OpARM64VCLS16B
1392 return true
1393 case OpLeadingZerosInt16x8:
1394 v.Op = OpARM64VCLZ8H
1395 return true
1396 case OpLeadingZerosInt32x4:
1397 v.Op = OpARM64VCLZ4S
1398 return true
1399 case OpLeadingZerosInt8x16:
1400 v.Op = OpARM64VCLZ16B
1401 return true
1402 case OpLeadingZerosUint16x8:
1403 v.Op = OpARM64VCLZ8H
1404 return true
1405 case OpLeadingZerosUint32x4:
1406 v.Op = OpARM64VCLZ4S
1407 return true
1408 case OpLeadingZerosUint8x16:
1409 v.Op = OpARM64VCLZ16B
1410 return true
1411 case OpLeq16:
1412 return rewriteValueARM64_OpLeq16(v)
1413 case OpLeq16U:
1414 return rewriteValueARM64_OpLeq16U(v)
1415 case OpLeq32:
1416 return rewriteValueARM64_OpLeq32(v)
1417 case OpLeq32F:
1418 return rewriteValueARM64_OpLeq32F(v)
1419 case OpLeq32U:
1420 return rewriteValueARM64_OpLeq32U(v)
1421 case OpLeq64:
1422 return rewriteValueARM64_OpLeq64(v)
1423 case OpLeq64F:
1424 return rewriteValueARM64_OpLeq64F(v)
1425 case OpLeq64U:
1426 return rewriteValueARM64_OpLeq64U(v)
1427 case OpLeq8:
1428 return rewriteValueARM64_OpLeq8(v)
1429 case OpLeq8U:
1430 return rewriteValueARM64_OpLeq8U(v)
1431 case OpLess16:
1432 return rewriteValueARM64_OpLess16(v)
1433 case OpLess16U:
1434 return rewriteValueARM64_OpLess16U(v)
1435 case OpLess32:
1436 return rewriteValueARM64_OpLess32(v)
1437 case OpLess32F:
1438 return rewriteValueARM64_OpLess32F(v)
1439 case OpLess32U:
1440 return rewriteValueARM64_OpLess32U(v)
1441 case OpLess64:
1442 return rewriteValueARM64_OpLess64(v)
1443 case OpLess64F:
1444 return rewriteValueARM64_OpLess64F(v)
1445 case OpLess64U:
1446 return rewriteValueARM64_OpLess64U(v)
1447 case OpLess8:
1448 return rewriteValueARM64_OpLess8(v)
1449 case OpLess8U:
1450 return rewriteValueARM64_OpLess8U(v)
1451 case OpLoad:
1452 return rewriteValueARM64_OpLoad(v)
1453 case OpLoadMasked8:
1454 return rewriteValueARM64_OpLoadMasked8(v)
1455 case OpLocalAddr:
1456 return rewriteValueARM64_OpLocalAddr(v)
1457 case OpLookupOrZeroInt8x16:
1458 v.Op = OpARM64VTBL16B
1459 return true
1460 case OpLookupOrZeroUint8x16:
1461 v.Op = OpARM64VTBL16B
1462 return true
1463 case OpLsh16x16:
1464 v.Op = OpLsh64x16
1465 return true
1466 case OpLsh16x32:
1467 v.Op = OpLsh64x32
1468 return true
1469 case OpLsh16x64:
1470 v.Op = OpLsh64x64
1471 return true
1472 case OpLsh16x8:
1473 v.Op = OpLsh64x8
1474 return true
1475 case OpLsh32x16:
1476 v.Op = OpLsh64x16
1477 return true
1478 case OpLsh32x32:
1479 v.Op = OpLsh64x32
1480 return true
1481 case OpLsh32x64:
1482 v.Op = OpLsh64x64
1483 return true
1484 case OpLsh32x8:
1485 v.Op = OpLsh64x8
1486 return true
1487 case OpLsh64x16:
1488 return rewriteValueARM64_OpLsh64x16(v)
1489 case OpLsh64x32:
1490 return rewriteValueARM64_OpLsh64x32(v)
1491 case OpLsh64x64:
1492 return rewriteValueARM64_OpLsh64x64(v)
1493 case OpLsh64x8:
1494 return rewriteValueARM64_OpLsh64x8(v)
1495 case OpLsh8x16:
1496 v.Op = OpLsh64x16
1497 return true
1498 case OpLsh8x32:
1499 v.Op = OpLsh64x32
1500 return true
1501 case OpLsh8x64:
1502 v.Op = OpLsh64x64
1503 return true
1504 case OpLsh8x8:
1505 v.Op = OpLsh64x8
1506 return true
1507 case OpMax32F:
1508 v.Op = OpARM64FMAXS
1509 return true
1510 case OpMax32FSel:
1511 return rewriteValueARM64_OpMax32FSel(v)
1512 case OpMax64F:
1513 v.Op = OpARM64FMAXD
1514 return true
1515 case OpMax64FSel:
1516 return rewriteValueARM64_OpMax64FSel(v)
1517 case OpMaxFloat32x4:
1518 v.Op = OpARM64VFMAX4S
1519 return true
1520 case OpMaxFloat64x2:
1521 v.Op = OpARM64VFMAX2D
1522 return true
1523 case OpMaxInt16x8:
1524 v.Op = OpARM64VSMAX8H
1525 return true
1526 case OpMaxInt32x4:
1527 v.Op = OpARM64VSMAX4S
1528 return true
1529 case OpMaxInt8x16:
1530 v.Op = OpARM64VSMAX16B
1531 return true
1532 case OpMaxUint16x8:
1533 v.Op = OpARM64VUMAX8H
1534 return true
1535 case OpMaxUint32x4:
1536 v.Op = OpARM64VUMAX4S
1537 return true
1538 case OpMaxUint8x16:
1539 v.Op = OpARM64VUMAX16B
1540 return true
1541 case OpMemEq:
1542 v.Op = OpARM64LoweredMemEq
1543 return true
1544 case OpMergeInt8s:
1545 v.Op = OpARM64ZSELB
1546 return true
1547 case OpMin32F:
1548 v.Op = OpARM64FMINS
1549 return true
1550 case OpMin32FSel:
1551 return rewriteValueARM64_OpMin32FSel(v)
1552 case OpMin64F:
1553 v.Op = OpARM64FMIND
1554 return true
1555 case OpMin64FSel:
1556 return rewriteValueARM64_OpMin64FSel(v)
1557 case OpMinFloat32x4:
1558 v.Op = OpARM64VFMIN4S
1559 return true
1560 case OpMinFloat64x2:
1561 v.Op = OpARM64VFMIN2D
1562 return true
1563 case OpMinInt16x8:
1564 v.Op = OpARM64VSMIN8H
1565 return true
1566 case OpMinInt32x4:
1567 v.Op = OpARM64VSMIN4S
1568 return true
1569 case OpMinInt8x16:
1570 v.Op = OpARM64VSMIN16B
1571 return true
1572 case OpMinUint16x8:
1573 v.Op = OpARM64VUMIN8H
1574 return true
1575 case OpMinUint32x4:
1576 v.Op = OpARM64VUMIN4S
1577 return true
1578 case OpMinUint8x16:
1579 v.Op = OpARM64VUMIN16B
1580 return true
1581 case OpMod16:
1582 return rewriteValueARM64_OpMod16(v)
1583 case OpMod16u:
1584 return rewriteValueARM64_OpMod16u(v)
1585 case OpMod32:
1586 return rewriteValueARM64_OpMod32(v)
1587 case OpMod32u:
1588 v.Op = OpARM64UMODW
1589 return true
1590 case OpMod64:
1591 return rewriteValueARM64_OpMod64(v)
1592 case OpMod64u:
1593 v.Op = OpARM64UMOD
1594 return true
1595 case OpMod8:
1596 return rewriteValueARM64_OpMod8(v)
1597 case OpMod8u:
1598 return rewriteValueARM64_OpMod8u(v)
1599 case OpMove:
1600 return rewriteValueARM64_OpMove(v)
1601 case OpMul16:
1602 v.Op = OpARM64MULW
1603 return true
1604 case OpMul32:
1605 v.Op = OpARM64MULW
1606 return true
1607 case OpMul32F:
1608 v.Op = OpARM64FMULS
1609 return true
1610 case OpMul64:
1611 v.Op = OpARM64MUL
1612 return true
1613 case OpMul64F:
1614 v.Op = OpARM64FMULD
1615 return true
1616 case OpMul8:
1617 v.Op = OpARM64MULW
1618 return true
1619 case OpMulAddFloat32x4:
1620 return rewriteValueARM64_OpMulAddFloat32x4(v)
1621 case OpMulAddFloat64x2:
1622 return rewriteValueARM64_OpMulAddFloat64x2(v)
1623 case OpMulAddInt16x8:
1624 return rewriteValueARM64_OpMulAddInt16x8(v)
1625 case OpMulAddInt32x4:
1626 return rewriteValueARM64_OpMulAddInt32x4(v)
1627 case OpMulAddInt8x16:
1628 return rewriteValueARM64_OpMulAddInt8x16(v)
1629 case OpMulAddUint16x8:
1630 return rewriteValueARM64_OpMulAddUint16x8(v)
1631 case OpMulAddUint32x4:
1632 return rewriteValueARM64_OpMulAddUint32x4(v)
1633 case OpMulAddUint8x16:
1634 return rewriteValueARM64_OpMulAddUint8x16(v)
1635 case OpMulFloat32x4:
1636 v.Op = OpARM64VFMUL4S
1637 return true
1638 case OpMulFloat64x2:
1639 v.Op = OpARM64VFMUL2D
1640 return true
1641 case OpMulInt16x8:
1642 v.Op = OpARM64VMUL8H
1643 return true
1644 case OpMulInt32x4:
1645 v.Op = OpARM64VMUL4S
1646 return true
1647 case OpMulInt8x16:
1648 v.Op = OpARM64VMUL16B
1649 return true
1650 case OpMulUint16x8:
1651 v.Op = OpARM64VMUL8H
1652 return true
1653 case OpMulUint32x4:
1654 v.Op = OpARM64VMUL4S
1655 return true
1656 case OpMulUint8x16:
1657 v.Op = OpARM64VMUL16B
1658 return true
1659 case OpMulWidenLoInt16x8:
1660 v.Op = OpARM64VSMULL8H
1661 return true
1662 case OpMulWidenLoInt32x4:
1663 v.Op = OpARM64VSMULL4S
1664 return true
1665 case OpMulWidenLoInt8x16:
1666 v.Op = OpARM64VSMULL16B
1667 return true
1668 case OpMulWidenLoUint16x8:
1669 v.Op = OpARM64VUMULL8H
1670 return true
1671 case OpMulWidenLoUint32x4:
1672 v.Op = OpARM64VUMULL4S
1673 return true
1674 case OpMulWidenLoUint8x16:
1675 v.Op = OpARM64VUMULL16B
1676 return true
1677 case OpNeg16:
1678 v.Op = OpARM64NEG
1679 return true
1680 case OpNeg32:
1681 v.Op = OpARM64NEG
1682 return true
1683 case OpNeg32F:
1684 v.Op = OpARM64FNEGS
1685 return true
1686 case OpNeg64:
1687 v.Op = OpARM64NEG
1688 return true
1689 case OpNeg64F:
1690 v.Op = OpARM64FNEGD
1691 return true
1692 case OpNeg8:
1693 v.Op = OpARM64NEG
1694 return true
1695 case OpNegFloat32x4:
1696 v.Op = OpARM64VFNEG4S
1697 return true
1698 case OpNegFloat64x2:
1699 v.Op = OpARM64VFNEG2D
1700 return true
1701 case OpNegInt16x8:
1702 v.Op = OpARM64VNEG8H
1703 return true
1704 case OpNegInt32x4:
1705 v.Op = OpARM64VNEG4S
1706 return true
1707 case OpNegInt64x2:
1708 v.Op = OpARM64VNEG2D
1709 return true
1710 case OpNegInt8x16:
1711 v.Op = OpARM64VNEG16B
1712 return true
1713 case OpNeq16:
1714 return rewriteValueARM64_OpNeq16(v)
1715 case OpNeq32:
1716 return rewriteValueARM64_OpNeq32(v)
1717 case OpNeq32F:
1718 return rewriteValueARM64_OpNeq32F(v)
1719 case OpNeq64:
1720 return rewriteValueARM64_OpNeq64(v)
1721 case OpNeq64F:
1722 return rewriteValueARM64_OpNeq64F(v)
1723 case OpNeq8:
1724 return rewriteValueARM64_OpNeq8(v)
1725 case OpNeqB:
1726 v.Op = OpARM64XOR
1727 return true
1728 case OpNeqPtr:
1729 return rewriteValueARM64_OpNeqPtr(v)
1730 case OpNilCheck:
1731 v.Op = OpARM64LoweredNilCheck
1732 return true
1733 case OpNot:
1734 return rewriteValueARM64_OpNot(v)
1735 case OpNotInt16x8:
1736 v.Op = OpARM64VNOT16B
1737 return true
1738 case OpNotInt32x4:
1739 v.Op = OpARM64VNOT16B
1740 return true
1741 case OpNotInt64x2:
1742 v.Op = OpARM64VNOT16B
1743 return true
1744 case OpNotInt8x16:
1745 v.Op = OpARM64VNOT16B
1746 return true
1747 case OpNotUint16x8:
1748 v.Op = OpARM64VNOT16B
1749 return true
1750 case OpNotUint32x4:
1751 v.Op = OpARM64VNOT16B
1752 return true
1753 case OpNotUint64x2:
1754 v.Op = OpARM64VNOT16B
1755 return true
1756 case OpNotUint8x16:
1757 v.Op = OpARM64VNOT16B
1758 return true
1759 case OpOffPtr:
1760 return rewriteValueARM64_OpOffPtr(v)
1761 case OpOnesCountInt8x16:
1762 v.Op = OpARM64VCNT16B
1763 return true
1764 case OpOnesCountUint8x16:
1765 v.Op = OpARM64VCNT16B
1766 return true
1767 case OpOr16:
1768 v.Op = OpARM64OR
1769 return true
1770 case OpOr32:
1771 v.Op = OpARM64OR
1772 return true
1773 case OpOr64:
1774 v.Op = OpARM64OR
1775 return true
1776 case OpOr8:
1777 v.Op = OpARM64OR
1778 return true
1779 case OpOrB:
1780 v.Op = OpARM64OR
1781 return true
1782 case OpOrInt16x8:
1783 v.Op = OpARM64VORR16B
1784 return true
1785 case OpOrInt32x4:
1786 v.Op = OpARM64VORR16B
1787 return true
1788 case OpOrInt64x2:
1789 v.Op = OpARM64VORR16B
1790 return true
1791 case OpOrInt8x16:
1792 v.Op = OpARM64VORR16B
1793 return true
1794 case OpOrNotInt16x8:
1795 v.Op = OpARM64VORN16B
1796 return true
1797 case OpOrNotInt32x4:
1798 v.Op = OpARM64VORN16B
1799 return true
1800 case OpOrNotInt64x2:
1801 v.Op = OpARM64VORN16B
1802 return true
1803 case OpOrNotInt8x16:
1804 v.Op = OpARM64VORN16B
1805 return true
1806 case OpOrNotUint16x8:
1807 v.Op = OpARM64VORN16B
1808 return true
1809 case OpOrNotUint32x4:
1810 v.Op = OpARM64VORN16B
1811 return true
1812 case OpOrNotUint64x2:
1813 v.Op = OpARM64VORN16B
1814 return true
1815 case OpOrNotUint8x16:
1816 v.Op = OpARM64VORN16B
1817 return true
1818 case OpOrUint16x8:
1819 v.Op = OpARM64VORR16B
1820 return true
1821 case OpOrUint32x4:
1822 v.Op = OpARM64VORR16B
1823 return true
1824 case OpOrUint64x2:
1825 v.Op = OpARM64VORR16B
1826 return true
1827 case OpOrUint8x16:
1828 v.Op = OpARM64VORR16B
1829 return true
1830 case OpPanicBounds:
1831 v.Op = OpARM64LoweredPanicBoundsRR
1832 return true
1833 case OpPopCount16:
1834 return rewriteValueARM64_OpPopCount16(v)
1835 case OpPopCount32:
1836 return rewriteValueARM64_OpPopCount32(v)
1837 case OpPopCount64:
1838 return rewriteValueARM64_OpPopCount64(v)
1839 case OpPrefetchCache:
1840 return rewriteValueARM64_OpPrefetchCache(v)
1841 case OpPrefetchCacheStreamed:
1842 return rewriteValueARM64_OpPrefetchCacheStreamed(v)
1843 case OpPubBarrier:
1844 return rewriteValueARM64_OpPubBarrier(v)
1845 case OpRotateLeft16:
1846 return rewriteValueARM64_OpRotateLeft16(v)
1847 case OpRotateLeft32:
1848 return rewriteValueARM64_OpRotateLeft32(v)
1849 case OpRotateLeft64:
1850 return rewriteValueARM64_OpRotateLeft64(v)
1851 case OpRotateLeft8:
1852 return rewriteValueARM64_OpRotateLeft8(v)
1853 case OpRound:
1854 v.Op = OpARM64FRINTAD
1855 return true
1856 case OpRound32F:
1857 v.Op = OpARM64LoweredRound32F
1858 return true
1859 case OpRound64F:
1860 v.Op = OpARM64LoweredRound64F
1861 return true
1862 case OpRoundFloat32x4:
1863 v.Op = OpARM64VFRINTN4S
1864 return true
1865 case OpRoundFloat64x2:
1866 v.Op = OpARM64VFRINTN2D
1867 return true
1868 case OpRoundToEven:
1869 v.Op = OpARM64FRINTND
1870 return true
1871 case OpRsh16Ux16:
1872 return rewriteValueARM64_OpRsh16Ux16(v)
1873 case OpRsh16Ux32:
1874 return rewriteValueARM64_OpRsh16Ux32(v)
1875 case OpRsh16Ux64:
1876 return rewriteValueARM64_OpRsh16Ux64(v)
1877 case OpRsh16Ux8:
1878 return rewriteValueARM64_OpRsh16Ux8(v)
1879 case OpRsh16x16:
1880 return rewriteValueARM64_OpRsh16x16(v)
1881 case OpRsh16x32:
1882 return rewriteValueARM64_OpRsh16x32(v)
1883 case OpRsh16x64:
1884 return rewriteValueARM64_OpRsh16x64(v)
1885 case OpRsh16x8:
1886 return rewriteValueARM64_OpRsh16x8(v)
1887 case OpRsh32Ux16:
1888 return rewriteValueARM64_OpRsh32Ux16(v)
1889 case OpRsh32Ux32:
1890 return rewriteValueARM64_OpRsh32Ux32(v)
1891 case OpRsh32Ux64:
1892 return rewriteValueARM64_OpRsh32Ux64(v)
1893 case OpRsh32Ux8:
1894 return rewriteValueARM64_OpRsh32Ux8(v)
1895 case OpRsh32x16:
1896 return rewriteValueARM64_OpRsh32x16(v)
1897 case OpRsh32x32:
1898 return rewriteValueARM64_OpRsh32x32(v)
1899 case OpRsh32x64:
1900 return rewriteValueARM64_OpRsh32x64(v)
1901 case OpRsh32x8:
1902 return rewriteValueARM64_OpRsh32x8(v)
1903 case OpRsh64Ux16:
1904 return rewriteValueARM64_OpRsh64Ux16(v)
1905 case OpRsh64Ux32:
1906 return rewriteValueARM64_OpRsh64Ux32(v)
1907 case OpRsh64Ux64:
1908 return rewriteValueARM64_OpRsh64Ux64(v)
1909 case OpRsh64Ux8:
1910 return rewriteValueARM64_OpRsh64Ux8(v)
1911 case OpRsh64x16:
1912 return rewriteValueARM64_OpRsh64x16(v)
1913 case OpRsh64x32:
1914 return rewriteValueARM64_OpRsh64x32(v)
1915 case OpRsh64x64:
1916 return rewriteValueARM64_OpRsh64x64(v)
1917 case OpRsh64x8:
1918 return rewriteValueARM64_OpRsh64x8(v)
1919 case OpRsh8Ux16:
1920 return rewriteValueARM64_OpRsh8Ux16(v)
1921 case OpRsh8Ux32:
1922 return rewriteValueARM64_OpRsh8Ux32(v)
1923 case OpRsh8Ux64:
1924 return rewriteValueARM64_OpRsh8Ux64(v)
1925 case OpRsh8Ux8:
1926 return rewriteValueARM64_OpRsh8Ux8(v)
1927 case OpRsh8x16:
1928 return rewriteValueARM64_OpRsh8x16(v)
1929 case OpRsh8x32:
1930 return rewriteValueARM64_OpRsh8x32(v)
1931 case OpRsh8x64:
1932 return rewriteValueARM64_OpRsh8x64(v)
1933 case OpRsh8x8:
1934 return rewriteValueARM64_OpRsh8x8(v)
1935 case OpSaturateToInt16Int32x4:
1936 v.Op = OpARM64VSQXTN4S
1937 return true
1938 case OpSaturateToInt32Int64x2:
1939 v.Op = OpARM64VSQXTN2D
1940 return true
1941 case OpSaturateToInt8Int16x8:
1942 v.Op = OpARM64VSQXTN8H
1943 return true
1944 case OpSaturateToUint16Int32x4:
1945 v.Op = OpARM64VSQXTUN4S
1946 return true
1947 case OpSaturateToUint16Uint32x4:
1948 v.Op = OpARM64VUQXTN4S
1949 return true
1950 case OpSaturateToUint32Int64x2:
1951 v.Op = OpARM64VSQXTUN2D
1952 return true
1953 case OpSaturateToUint32Uint64x2:
1954 v.Op = OpARM64VUQXTN2D
1955 return true
1956 case OpSaturateToUint8Int16x8:
1957 v.Op = OpARM64VSQXTUN8H
1958 return true
1959 case OpSaturateToUint8Uint16x8:
1960 v.Op = OpARM64VUQXTN8H
1961 return true
1962 case OpScalableVectorLen:
1963 return rewriteValueARM64_OpScalableVectorLen(v)
1964 case OpSelect0:
1965 return rewriteValueARM64_OpSelect0(v)
1966 case OpSelect1:
1967 return rewriteValueARM64_OpSelect1(v)
1968 case OpSelectN:
1969 return rewriteValueARM64_OpSelectN(v)
1970 case OpSetElemFloat32x4:
1971 v.Op = OpARM64VMOVSins0
1972 return true
1973 case OpSetElemFloat64x2:
1974 v.Op = OpARM64VMOVDins0
1975 return true
1976 case OpSetElemInt16x8:
1977 v.Op = OpARM64VMOVHins
1978 return true
1979 case OpSetElemInt32x4:
1980 v.Op = OpARM64VMOVSins
1981 return true
1982 case OpSetElemInt64x2:
1983 v.Op = OpARM64VMOVDins
1984 return true
1985 case OpSetElemInt8x16:
1986 v.Op = OpARM64VMOVBins
1987 return true
1988 case OpSetElemUint16x8:
1989 v.Op = OpARM64VMOVHins
1990 return true
1991 case OpSetElemUint32x4:
1992 v.Op = OpARM64VMOVSins
1993 return true
1994 case OpSetElemUint64x2:
1995 v.Op = OpARM64VMOVDins
1996 return true
1997 case OpSetElemUint8x16:
1998 v.Op = OpARM64VMOVBins
1999 return true
2000 case OpShiftAllLeftInt16x8:
2001 return rewriteValueARM64_OpShiftAllLeftInt16x8(v)
2002 case OpShiftAllLeftInt32x4:
2003 return rewriteValueARM64_OpShiftAllLeftInt32x4(v)
2004 case OpShiftAllLeftInt64x2:
2005 return rewriteValueARM64_OpShiftAllLeftInt64x2(v)
2006 case OpShiftAllLeftInt8x16:
2007 return rewriteValueARM64_OpShiftAllLeftInt8x16(v)
2008 case OpShiftAllLeftUint16x8:
2009 return rewriteValueARM64_OpShiftAllLeftUint16x8(v)
2010 case OpShiftAllLeftUint32x4:
2011 return rewriteValueARM64_OpShiftAllLeftUint32x4(v)
2012 case OpShiftAllLeftUint64x2:
2013 return rewriteValueARM64_OpShiftAllLeftUint64x2(v)
2014 case OpShiftAllLeftUint8x16:
2015 return rewriteValueARM64_OpShiftAllLeftUint8x16(v)
2016 case OpShiftAllRightInt16x8:
2017 return rewriteValueARM64_OpShiftAllRightInt16x8(v)
2018 case OpShiftAllRightInt32x4:
2019 return rewriteValueARM64_OpShiftAllRightInt32x4(v)
2020 case OpShiftAllRightInt64x2:
2021 return rewriteValueARM64_OpShiftAllRightInt64x2(v)
2022 case OpShiftAllRightInt8x16:
2023 return rewriteValueARM64_OpShiftAllRightInt8x16(v)
2024 case OpShiftAllRightUint16x8:
2025 return rewriteValueARM64_OpShiftAllRightUint16x8(v)
2026 case OpShiftAllRightUint32x4:
2027 return rewriteValueARM64_OpShiftAllRightUint32x4(v)
2028 case OpShiftAllRightUint64x2:
2029 return rewriteValueARM64_OpShiftAllRightUint64x2(v)
2030 case OpShiftAllRightUint8x16:
2031 return rewriteValueARM64_OpShiftAllRightUint8x16(v)
2032 case OpShiftInt16x8:
2033 v.Op = OpARM64VSSHL8H
2034 return true
2035 case OpShiftInt32x4:
2036 v.Op = OpARM64VSSHL4S
2037 return true
2038 case OpShiftInt64x2:
2039 v.Op = OpARM64VSSHL2D
2040 return true
2041 case OpShiftInt8x16:
2042 v.Op = OpARM64VSSHL16B
2043 return true
2044 case OpShiftSaturatedInt16x8:
2045 v.Op = OpARM64VSQSHL8H
2046 return true
2047 case OpShiftSaturatedInt32x4:
2048 v.Op = OpARM64VSQSHL4S
2049 return true
2050 case OpShiftSaturatedInt64x2:
2051 v.Op = OpARM64VSQSHL2D
2052 return true
2053 case OpShiftSaturatedInt8x16:
2054 v.Op = OpARM64VSQSHL16B
2055 return true
2056 case OpShiftSaturatedUint16x8:
2057 v.Op = OpARM64VUQSHL8H
2058 return true
2059 case OpShiftSaturatedUint32x4:
2060 v.Op = OpARM64VUQSHL4S
2061 return true
2062 case OpShiftSaturatedUint64x2:
2063 v.Op = OpARM64VUQSHL2D
2064 return true
2065 case OpShiftSaturatedUint8x16:
2066 v.Op = OpARM64VUQSHL16B
2067 return true
2068 case OpShiftUint16x8:
2069 v.Op = OpARM64VUSHL8H
2070 return true
2071 case OpShiftUint32x4:
2072 v.Op = OpARM64VUSHL4S
2073 return true
2074 case OpShiftUint64x2:
2075 v.Op = OpARM64VUSHL2D
2076 return true
2077 case OpShiftUint8x16:
2078 v.Op = OpARM64VUSHL16B
2079 return true
2080 case OpSignExt16to32:
2081 v.Op = OpARM64MOVHreg
2082 return true
2083 case OpSignExt16to64:
2084 v.Op = OpARM64MOVHreg
2085 return true
2086 case OpSignExt32to64:
2087 v.Op = OpARM64MOVWreg
2088 return true
2089 case OpSignExt8to16:
2090 v.Op = OpARM64MOVBreg
2091 return true
2092 case OpSignExt8to32:
2093 v.Op = OpARM64MOVBreg
2094 return true
2095 case OpSignExt8to64:
2096 v.Op = OpARM64MOVBreg
2097 return true
2098 case OpSlicemask:
2099 return rewriteValueARM64_OpSlicemask(v)
2100 case OpSqrt:
2101 v.Op = OpARM64FSQRTD
2102 return true
2103 case OpSqrt32:
2104 v.Op = OpARM64FSQRTS
2105 return true
2106 case OpSqrtFloat32x4:
2107 v.Op = OpARM64VFSQRT4S
2108 return true
2109 case OpSqrtFloat64x2:
2110 v.Op = OpARM64VFSQRT2D
2111 return true
2112 case OpStaticCall:
2113 v.Op = OpARM64CALLstatic
2114 return true
2115 case OpStore:
2116 return rewriteValueARM64_OpStore(v)
2117 case OpStoreMasked8:
2118 return rewriteValueARM64_OpStoreMasked8(v)
2119 case OpSub16:
2120 v.Op = OpARM64SUB
2121 return true
2122 case OpSub32:
2123 v.Op = OpARM64SUB
2124 return true
2125 case OpSub32F:
2126 v.Op = OpARM64FSUBS
2127 return true
2128 case OpSub64:
2129 v.Op = OpARM64SUB
2130 return true
2131 case OpSub64F:
2132 v.Op = OpARM64FSUBD
2133 return true
2134 case OpSub8:
2135 v.Op = OpARM64SUB
2136 return true
2137 case OpSubFloat32x4:
2138 v.Op = OpARM64VFSUB4S
2139 return true
2140 case OpSubFloat64x2:
2141 v.Op = OpARM64VFSUB2D
2142 return true
2143 case OpSubInt16x8:
2144 v.Op = OpARM64VSUB8H
2145 return true
2146 case OpSubInt32x4:
2147 v.Op = OpARM64VSUB4S
2148 return true
2149 case OpSubInt64x2:
2150 v.Op = OpARM64VSUB2D
2151 return true
2152 case OpSubInt8x16:
2153 v.Op = OpARM64VSUB16B
2154 return true
2155 case OpSubPtr:
2156 v.Op = OpARM64SUB
2157 return true
2158 case OpSubSaturatedInt16x8:
2159 v.Op = OpARM64VSQSUB8H
2160 return true
2161 case OpSubSaturatedInt32x4:
2162 v.Op = OpARM64VSQSUB4S
2163 return true
2164 case OpSubSaturatedInt64x2:
2165 v.Op = OpARM64VSQSUB2D
2166 return true
2167 case OpSubSaturatedInt8x16:
2168 v.Op = OpARM64VSQSUB16B
2169 return true
2170 case OpSubSaturatedUint16x8:
2171 v.Op = OpARM64VUQSUB8H
2172 return true
2173 case OpSubSaturatedUint32x4:
2174 v.Op = OpARM64VUQSUB4S
2175 return true
2176 case OpSubSaturatedUint64x2:
2177 v.Op = OpARM64VUQSUB2D
2178 return true
2179 case OpSubSaturatedUint8x16:
2180 v.Op = OpARM64VUQSUB16B
2181 return true
2182 case OpSubUint16x8:
2183 v.Op = OpARM64VSUB8H
2184 return true
2185 case OpSubUint32x4:
2186 v.Op = OpARM64VSUB4S
2187 return true
2188 case OpSubUint64x2:
2189 v.Op = OpARM64VSUB2D
2190 return true
2191 case OpSubUint8x16:
2192 v.Op = OpARM64VSUB16B
2193 return true
2194 case OpTailCall:
2195 v.Op = OpARM64CALLtail
2196 return true
2197 case OpTailCallInter:
2198 v.Op = OpARM64CALLtailinter
2199 return true
2200 case OpTrunc:
2201 v.Op = OpARM64FRINTZD
2202 return true
2203 case OpTrunc16to8:
2204 v.Op = OpCopy
2205 return true
2206 case OpTrunc32to16:
2207 v.Op = OpCopy
2208 return true
2209 case OpTrunc32to8:
2210 v.Op = OpCopy
2211 return true
2212 case OpTrunc64to16:
2213 v.Op = OpCopy
2214 return true
2215 case OpTrunc64to32:
2216 v.Op = OpCopy
2217 return true
2218 case OpTrunc64to8:
2219 v.Op = OpCopy
2220 return true
2221 case OpTruncFloat32x4:
2222 v.Op = OpARM64VFRINTZ4S
2223 return true
2224 case OpTruncFloat64x2:
2225 v.Op = OpARM64VFRINTZ2D
2226 return true
2227 case OpTruncToInt16Int32x4:
2228 v.Op = OpARM64VXTN4S
2229 return true
2230 case OpTruncToInt32Int64x2:
2231 v.Op = OpARM64VXTN2D
2232 return true
2233 case OpTruncToInt8Int16x8:
2234 v.Op = OpARM64VXTN8H
2235 return true
2236 case OpTruncToUint16Uint32x4:
2237 v.Op = OpARM64VXTN4S
2238 return true
2239 case OpTruncToUint32Uint64x2:
2240 v.Op = OpARM64VXTN2D
2241 return true
2242 case OpTruncToUint8Uint16x8:
2243 v.Op = OpARM64VXTN8H
2244 return true
2245 case OpWB:
2246 v.Op = OpARM64LoweredWB
2247 return true
2248 case OpXor16:
2249 v.Op = OpARM64XOR
2250 return true
2251 case OpXor32:
2252 v.Op = OpARM64XOR
2253 return true
2254 case OpXor64:
2255 v.Op = OpARM64XOR
2256 return true
2257 case OpXor8:
2258 v.Op = OpARM64XOR
2259 return true
2260 case OpXorInt16x8:
2261 v.Op = OpARM64VEOR16B
2262 return true
2263 case OpXorInt32x4:
2264 v.Op = OpARM64VEOR16B
2265 return true
2266 case OpXorInt64x2:
2267 v.Op = OpARM64VEOR16B
2268 return true
2269 case OpXorInt8x16:
2270 v.Op = OpARM64VEOR16B
2271 return true
2272 case OpXorUint16x8:
2273 v.Op = OpARM64VEOR16B
2274 return true
2275 case OpXorUint32x4:
2276 v.Op = OpARM64VEOR16B
2277 return true
2278 case OpXorUint64x2:
2279 v.Op = OpARM64VEOR16B
2280 return true
2281 case OpXorUint8x16:
2282 v.Op = OpARM64VEOR16B
2283 return true
2284 case OpZero:
2285 return rewriteValueARM64_OpZero(v)
2286 case OpZeroExt16to32:
2287 v.Op = OpARM64MOVHUreg
2288 return true
2289 case OpZeroExt16to64:
2290 v.Op = OpARM64MOVHUreg
2291 return true
2292 case OpZeroExt32to64:
2293 v.Op = OpARM64MOVWUreg
2294 return true
2295 case OpZeroExt8to16:
2296 v.Op = OpARM64MOVBUreg
2297 return true
2298 case OpZeroExt8to32:
2299 v.Op = OpARM64MOVBUreg
2300 return true
2301 case OpZeroExt8to64:
2302 v.Op = OpARM64MOVBUreg
2303 return true
2304 case OpZeroSIMD:
2305 return rewriteValueARM64_OpZeroSIMD(v)
2306 case OpbitSelectInt8x16:
2307 v.Op = OpARM64VBIF16B
2308 return true
2309 case OpbitSelectNotInt8x16:
2310 v.Op = OpARM64VBIT16B
2311 return true
2312 case Opbroadcast1To16Int8x16:
2313 return rewriteValueARM64_Opbroadcast1To16Int8x16(v)
2314 case Opbroadcast1To16Uint8x16:
2315 return rewriteValueARM64_Opbroadcast1To16Uint8x16(v)
2316 case Opbroadcast1To2Float64x2:
2317 return rewriteValueARM64_Opbroadcast1To2Float64x2(v)
2318 case Opbroadcast1To2Int64x2:
2319 return rewriteValueARM64_Opbroadcast1To2Int64x2(v)
2320 case Opbroadcast1To2Uint64x2:
2321 return rewriteValueARM64_Opbroadcast1To2Uint64x2(v)
2322 case Opbroadcast1To4Float32x4:
2323 return rewriteValueARM64_Opbroadcast1To4Float32x4(v)
2324 case Opbroadcast1To4Int32x4:
2325 return rewriteValueARM64_Opbroadcast1To4Int32x4(v)
2326 case Opbroadcast1To4Uint32x4:
2327 return rewriteValueARM64_Opbroadcast1To4Uint32x4(v)
2328 case Opbroadcast1To8Int16x8:
2329 return rewriteValueARM64_Opbroadcast1To8Int16x8(v)
2330 case Opbroadcast1To8Uint16x8:
2331 return rewriteValueARM64_Opbroadcast1To8Uint16x8(v)
2332 case OpcarrylessMultiplyWidenLoUint64x2:
2333 v.Op = OpARM64VPMULL2D
2334 return true
2335 case OpreduceMaxFloat32x4:
2336 v.Op = OpARM64VFMAXV4S
2337 return true
2338 case OpreduceMaxInt16x8:
2339 v.Op = OpARM64VSMAXV8H
2340 return true
2341 case OpreduceMaxInt32x4:
2342 v.Op = OpARM64VSMAXV4S
2343 return true
2344 case OpreduceMaxInt8x16:
2345 v.Op = OpARM64VSMAXV16B
2346 return true
2347 case OpreduceMaxUint16x8:
2348 v.Op = OpARM64VUMAXV8H
2349 return true
2350 case OpreduceMaxUint32x4:
2351 v.Op = OpARM64VUMAXV4S
2352 return true
2353 case OpreduceMaxUint8x16:
2354 v.Op = OpARM64VUMAXV16B
2355 return true
2356 case OpreduceMinFloat32x4:
2357 v.Op = OpARM64VFMINV4S
2358 return true
2359 case OpreduceMinInt16x8:
2360 v.Op = OpARM64VSMINV8H
2361 return true
2362 case OpreduceMinInt32x4:
2363 v.Op = OpARM64VSMINV4S
2364 return true
2365 case OpreduceMinInt8x16:
2366 v.Op = OpARM64VSMINV16B
2367 return true
2368 case OpreduceMinUint16x8:
2369 v.Op = OpARM64VUMINV8H
2370 return true
2371 case OpreduceMinUint32x4:
2372 v.Op = OpARM64VUMINV4S
2373 return true
2374 case OpreduceMinUint8x16:
2375 v.Op = OpARM64VUMINV16B
2376 return true
2377 case OpreduceSumInt16x8:
2378 v.Op = OpARM64VADDV8H
2379 return true
2380 case OpreduceSumInt32x4:
2381 v.Op = OpARM64VADDV4S
2382 return true
2383 case OpreduceSumInt8x16:
2384 v.Op = OpARM64VADDV16B
2385 return true
2386 case OpreduceSumUint16x8:
2387 v.Op = OpARM64VADDV8H
2388 return true
2389 case OpreduceSumUint32x4:
2390 v.Op = OpARM64VADDV4S
2391 return true
2392 case OpreduceSumUint8x16:
2393 v.Op = OpARM64VADDV16B
2394 return true
2395 }
2396 return false
2397 }
2398 func rewriteValueARM64_OpARM64ADCSflags(v *Value) bool {
2399 v_2 := v.Args[2]
2400 v_1 := v.Args[1]
2401 v_0 := v.Args[0]
2402 b := v.Block
2403 typ := &b.Func.Config.Types
2404
2405
2406 for {
2407 x := v_0
2408 y := v_1
2409 if v_2.Op != OpSelect1 || v_2.Type != types.TypeFlags {
2410 break
2411 }
2412 v_2_0 := v_2.Args[0]
2413 if v_2_0.Op != OpARM64ADDSconstflags || auxIntToInt64(v_2_0.AuxInt) != -1 {
2414 break
2415 }
2416 v_2_0_0 := v_2_0.Args[0]
2417 if v_2_0_0.Op != OpARM64ADCzerocarry || v_2_0_0.Type != typ.UInt64 {
2418 break
2419 }
2420 c := v_2_0_0.Args[0]
2421 v.reset(OpARM64ADCSflags)
2422 v.AddArg3(x, y, c)
2423 return true
2424 }
2425
2426
2427 for {
2428 x := v_0
2429 y := v_1
2430 if v_2.Op != OpSelect1 || v_2.Type != types.TypeFlags {
2431 break
2432 }
2433 v_2_0 := v_2.Args[0]
2434 if v_2_0.Op != OpARM64ADDSconstflags || auxIntToInt64(v_2_0.AuxInt) != -1 {
2435 break
2436 }
2437 v_2_0_0 := v_2_0.Args[0]
2438 if v_2_0_0.Op != OpARM64MOVDconst || auxIntToInt64(v_2_0_0.AuxInt) != 0 {
2439 break
2440 }
2441 v.reset(OpARM64ADDSflags)
2442 v.AddArg2(x, y)
2443 return true
2444 }
2445 return false
2446 }
2447 func rewriteValueARM64_OpARM64ADD(v *Value) bool {
2448 v_1 := v.Args[1]
2449 v_0 := v.Args[0]
2450 b := v.Block
2451
2452
2453
2454 for {
2455 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2456 x := v_0
2457 if v_1.Op != OpARM64MOVDconst {
2458 continue
2459 }
2460 t := v_1.Type
2461 c := auxIntToInt64(v_1.AuxInt)
2462 if !(!t.IsPtr()) {
2463 continue
2464 }
2465 v.reset(OpARM64ADDconst)
2466 v.AuxInt = int64ToAuxInt(c)
2467 v.AddArg(x)
2468 return true
2469 }
2470 break
2471 }
2472
2473
2474
2475 for {
2476 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2477 a := v_0
2478 l := v_1
2479 if l.Op != OpARM64MUL {
2480 continue
2481 }
2482 y := l.Args[1]
2483 x := l.Args[0]
2484 if !(l.Uses == 1 && clobber(l)) {
2485 continue
2486 }
2487 v.reset(OpARM64MADD)
2488 v.AddArg3(a, x, y)
2489 return true
2490 }
2491 break
2492 }
2493
2494
2495
2496 for {
2497 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2498 a := v_0
2499 l := v_1
2500 if l.Op != OpARM64MNEG {
2501 continue
2502 }
2503 y := l.Args[1]
2504 x := l.Args[0]
2505 if !(l.Uses == 1 && clobber(l)) {
2506 continue
2507 }
2508 v.reset(OpARM64MSUB)
2509 v.AddArg3(a, x, y)
2510 return true
2511 }
2512 break
2513 }
2514
2515
2516
2517 for {
2518 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2519 a := v_0
2520 l := v_1
2521 if l.Op != OpARM64MULW {
2522 continue
2523 }
2524 y := l.Args[1]
2525 x := l.Args[0]
2526 if !(v.Type.Size() <= 4 && l.Uses == 1 && clobber(l)) {
2527 continue
2528 }
2529 v.reset(OpARM64MADDW)
2530 v.AddArg3(a, x, y)
2531 return true
2532 }
2533 break
2534 }
2535
2536
2537
2538 for {
2539 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2540 a := v_0
2541 l := v_1
2542 if l.Op != OpARM64MNEGW {
2543 continue
2544 }
2545 y := l.Args[1]
2546 x := l.Args[0]
2547 if !(v.Type.Size() <= 4 && l.Uses == 1 && clobber(l)) {
2548 continue
2549 }
2550 v.reset(OpARM64MSUBW)
2551 v.AddArg3(a, x, y)
2552 return true
2553 }
2554 break
2555 }
2556
2557
2558
2559 for {
2560 t := v.Type
2561 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2562 a := v_0
2563 p := v_1
2564 if p.Op != OpARM64ADDconst {
2565 continue
2566 }
2567 c := auxIntToInt64(p.AuxInt)
2568 m := p.Args[0]
2569 if m.Op != OpARM64MUL || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
2570 continue
2571 }
2572 v.reset(OpARM64ADDconst)
2573 v.AuxInt = int64ToAuxInt(c)
2574 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
2575 v0.AddArg2(a, m)
2576 v.AddArg(v0)
2577 return true
2578 }
2579 break
2580 }
2581
2582
2583
2584 for {
2585 t := v.Type
2586 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2587 a := v_0
2588 p := v_1
2589 if p.Op != OpARM64ADDconst {
2590 continue
2591 }
2592 c := auxIntToInt64(p.AuxInt)
2593 m := p.Args[0]
2594 if m.Op != OpARM64MULW || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
2595 continue
2596 }
2597 v.reset(OpARM64ADDconst)
2598 v.AuxInt = int64ToAuxInt(c)
2599 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
2600 v0.AddArg2(a, m)
2601 v.AddArg(v0)
2602 return true
2603 }
2604 break
2605 }
2606
2607
2608
2609 for {
2610 t := v.Type
2611 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2612 a := v_0
2613 p := v_1
2614 if p.Op != OpARM64ADDconst {
2615 continue
2616 }
2617 c := auxIntToInt64(p.AuxInt)
2618 m := p.Args[0]
2619 if m.Op != OpARM64MNEG || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
2620 continue
2621 }
2622 v.reset(OpARM64ADDconst)
2623 v.AuxInt = int64ToAuxInt(c)
2624 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
2625 v0.AddArg2(a, m)
2626 v.AddArg(v0)
2627 return true
2628 }
2629 break
2630 }
2631
2632
2633
2634 for {
2635 t := v.Type
2636 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2637 a := v_0
2638 p := v_1
2639 if p.Op != OpARM64ADDconst {
2640 continue
2641 }
2642 c := auxIntToInt64(p.AuxInt)
2643 m := p.Args[0]
2644 if m.Op != OpARM64MNEGW || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
2645 continue
2646 }
2647 v.reset(OpARM64ADDconst)
2648 v.AuxInt = int64ToAuxInt(c)
2649 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
2650 v0.AddArg2(a, m)
2651 v.AddArg(v0)
2652 return true
2653 }
2654 break
2655 }
2656
2657
2658
2659 for {
2660 t := v.Type
2661 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2662 a := v_0
2663 p := v_1
2664 if p.Op != OpARM64SUBconst {
2665 continue
2666 }
2667 c := auxIntToInt64(p.AuxInt)
2668 m := p.Args[0]
2669 if m.Op != OpARM64MUL || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
2670 continue
2671 }
2672 v.reset(OpARM64SUBconst)
2673 v.AuxInt = int64ToAuxInt(c)
2674 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
2675 v0.AddArg2(a, m)
2676 v.AddArg(v0)
2677 return true
2678 }
2679 break
2680 }
2681
2682
2683
2684 for {
2685 t := v.Type
2686 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2687 a := v_0
2688 p := v_1
2689 if p.Op != OpARM64SUBconst {
2690 continue
2691 }
2692 c := auxIntToInt64(p.AuxInt)
2693 m := p.Args[0]
2694 if m.Op != OpARM64MULW || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
2695 continue
2696 }
2697 v.reset(OpARM64SUBconst)
2698 v.AuxInt = int64ToAuxInt(c)
2699 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
2700 v0.AddArg2(a, m)
2701 v.AddArg(v0)
2702 return true
2703 }
2704 break
2705 }
2706
2707
2708
2709 for {
2710 t := v.Type
2711 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2712 a := v_0
2713 p := v_1
2714 if p.Op != OpARM64SUBconst {
2715 continue
2716 }
2717 c := auxIntToInt64(p.AuxInt)
2718 m := p.Args[0]
2719 if m.Op != OpARM64MNEG || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
2720 continue
2721 }
2722 v.reset(OpARM64SUBconst)
2723 v.AuxInt = int64ToAuxInt(c)
2724 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
2725 v0.AddArg2(a, m)
2726 v.AddArg(v0)
2727 return true
2728 }
2729 break
2730 }
2731
2732
2733
2734 for {
2735 t := v.Type
2736 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2737 a := v_0
2738 p := v_1
2739 if p.Op != OpARM64SUBconst {
2740 continue
2741 }
2742 c := auxIntToInt64(p.AuxInt)
2743 m := p.Args[0]
2744 if m.Op != OpARM64MNEGW || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
2745 continue
2746 }
2747 v.reset(OpARM64SUBconst)
2748 v.AuxInt = int64ToAuxInt(c)
2749 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
2750 v0.AddArg2(a, m)
2751 v.AddArg(v0)
2752 return true
2753 }
2754 break
2755 }
2756
2757
2758 for {
2759 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2760 x := v_0
2761 if v_1.Op != OpARM64NEG {
2762 continue
2763 }
2764 y := v_1.Args[0]
2765 v.reset(OpARM64SUB)
2766 v.AddArg2(x, y)
2767 return true
2768 }
2769 break
2770 }
2771
2772
2773
2774 for {
2775 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2776 x0 := v_0
2777 x1 := v_1
2778 if x1.Op != OpARM64SLLconst {
2779 continue
2780 }
2781 c := auxIntToInt64(x1.AuxInt)
2782 y := x1.Args[0]
2783 if !(clobberIfDead(x1)) {
2784 continue
2785 }
2786 v.reset(OpARM64ADDshiftLL)
2787 v.AuxInt = int64ToAuxInt(c)
2788 v.AddArg2(x0, y)
2789 return true
2790 }
2791 break
2792 }
2793
2794
2795
2796 for {
2797 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2798 x0 := v_0
2799 x1 := v_1
2800 if x1.Op != OpARM64SRLconst {
2801 continue
2802 }
2803 c := auxIntToInt64(x1.AuxInt)
2804 y := x1.Args[0]
2805 if !(clobberIfDead(x1)) {
2806 continue
2807 }
2808 v.reset(OpARM64ADDshiftRL)
2809 v.AuxInt = int64ToAuxInt(c)
2810 v.AddArg2(x0, y)
2811 return true
2812 }
2813 break
2814 }
2815
2816
2817
2818 for {
2819 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2820 x0 := v_0
2821 x1 := v_1
2822 if x1.Op != OpARM64SRAconst {
2823 continue
2824 }
2825 c := auxIntToInt64(x1.AuxInt)
2826 y := x1.Args[0]
2827 if !(clobberIfDead(x1)) {
2828 continue
2829 }
2830 v.reset(OpARM64ADDshiftRA)
2831 v.AuxInt = int64ToAuxInt(c)
2832 v.AddArg2(x0, y)
2833 return true
2834 }
2835 break
2836 }
2837
2838
2839
2840 for {
2841 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2842 x0 := v_0
2843 x1 := v_1
2844 if x1.Op != OpARM64ANDshiftRA || auxIntToInt64(x1.AuxInt) != 63 {
2845 continue
2846 }
2847 z := x1.Args[1]
2848 x2 := x1.Args[0]
2849 if x2.Op != OpARM64SLLconst {
2850 continue
2851 }
2852 sl := auxIntToInt64(x2.AuxInt)
2853 y := x2.Args[0]
2854 if !(x1.Uses == 1 && x2.Uses == 1) {
2855 continue
2856 }
2857 v.reset(OpARM64ADDshiftLL)
2858 v.AuxInt = int64ToAuxInt(sl)
2859 v0 := b.NewValue0(v.Pos, OpARM64ANDshiftRA, y.Type)
2860 v0.AuxInt = int64ToAuxInt(63)
2861 v0.AddArg2(y, z)
2862 v.AddArg2(x0, v0)
2863 return true
2864 }
2865 break
2866 }
2867
2868
2869
2870 for {
2871 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2872 x0 := v_0
2873 x1 := v_1
2874 if x1.Op != OpARM64ANDshiftLL {
2875 continue
2876 }
2877 sl := auxIntToInt64(x1.AuxInt)
2878 y := x1.Args[1]
2879 x2 := x1.Args[0]
2880 if x2.Op != OpARM64SRAconst || auxIntToInt64(x2.AuxInt) != 63 {
2881 continue
2882 }
2883 z := x2.Args[0]
2884 if !(x1.Uses == 1 && x2.Uses == 1) {
2885 continue
2886 }
2887 v.reset(OpARM64ADDshiftLL)
2888 v.AuxInt = int64ToAuxInt(sl)
2889 v0 := b.NewValue0(v.Pos, OpARM64ANDshiftRA, y.Type)
2890 v0.AuxInt = int64ToAuxInt(63)
2891 v0.AddArg2(y, z)
2892 v.AddArg2(x0, v0)
2893 return true
2894 }
2895 break
2896 }
2897 return false
2898 }
2899 func rewriteValueARM64_OpARM64ADDSflags(v *Value) bool {
2900 v_1 := v.Args[1]
2901 v_0 := v.Args[0]
2902
2903
2904 for {
2905 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2906 x := v_0
2907 if v_1.Op != OpARM64MOVDconst {
2908 continue
2909 }
2910 c := auxIntToInt64(v_1.AuxInt)
2911 v.reset(OpARM64ADDSconstflags)
2912 v.AuxInt = int64ToAuxInt(c)
2913 v.AddArg(x)
2914 return true
2915 }
2916 break
2917 }
2918 return false
2919 }
2920 func rewriteValueARM64_OpARM64ADDconst(v *Value) bool {
2921 v_0 := v.Args[0]
2922
2923
2924
2925 for {
2926 off1 := auxIntToInt64(v.AuxInt)
2927 if v_0.Op != OpARM64MOVDaddr {
2928 break
2929 }
2930 off2 := auxIntToInt32(v_0.AuxInt)
2931 sym := auxToSym(v_0.Aux)
2932 ptr := v_0.Args[0]
2933 if !(is32Bit(off1 + int64(off2))) {
2934 break
2935 }
2936 v.reset(OpARM64MOVDaddr)
2937 v.AuxInt = int32ToAuxInt(int32(off1) + off2)
2938 v.Aux = symToAux(sym)
2939 v.AddArg(ptr)
2940 return true
2941 }
2942
2943
2944
2945 for {
2946 c := auxIntToInt64(v.AuxInt)
2947 y := v_0
2948 if !(c < 0) {
2949 break
2950 }
2951 v.reset(OpARM64SUBconst)
2952 v.AuxInt = int64ToAuxInt(-c)
2953 v.AddArg(y)
2954 return true
2955 }
2956
2957
2958 for {
2959 if auxIntToInt64(v.AuxInt) != 0 {
2960 break
2961 }
2962 x := v_0
2963 v.copyOf(x)
2964 return true
2965 }
2966
2967
2968 for {
2969 c := auxIntToInt64(v.AuxInt)
2970 if v_0.Op != OpARM64MOVDconst {
2971 break
2972 }
2973 d := auxIntToInt64(v_0.AuxInt)
2974 v.reset(OpARM64MOVDconst)
2975 v.AuxInt = int64ToAuxInt(c + d)
2976 return true
2977 }
2978
2979
2980 for {
2981 c := auxIntToInt64(v.AuxInt)
2982 if v_0.Op != OpARM64ADDconst {
2983 break
2984 }
2985 d := auxIntToInt64(v_0.AuxInt)
2986 x := v_0.Args[0]
2987 v.reset(OpARM64ADDconst)
2988 v.AuxInt = int64ToAuxInt(c + d)
2989 v.AddArg(x)
2990 return true
2991 }
2992
2993
2994 for {
2995 c := auxIntToInt64(v.AuxInt)
2996 if v_0.Op != OpARM64SUBconst {
2997 break
2998 }
2999 d := auxIntToInt64(v_0.AuxInt)
3000 x := v_0.Args[0]
3001 v.reset(OpARM64ADDconst)
3002 v.AuxInt = int64ToAuxInt(c - d)
3003 v.AddArg(x)
3004 return true
3005 }
3006 return false
3007 }
3008 func rewriteValueARM64_OpARM64ADDshiftLL(v *Value) bool {
3009 v_1 := v.Args[1]
3010 v_0 := v.Args[0]
3011 b := v.Block
3012 typ := &b.Func.Config.Types
3013
3014
3015 for {
3016 d := auxIntToInt64(v.AuxInt)
3017 if v_0.Op != OpARM64MOVDconst {
3018 break
3019 }
3020 c := auxIntToInt64(v_0.AuxInt)
3021 x := v_1
3022 v.reset(OpARM64ADDconst)
3023 v.AuxInt = int64ToAuxInt(c)
3024 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
3025 v0.AuxInt = int64ToAuxInt(d)
3026 v0.AddArg(x)
3027 v.AddArg(v0)
3028 return true
3029 }
3030
3031
3032 for {
3033 d := auxIntToInt64(v.AuxInt)
3034 x := v_0
3035 if v_1.Op != OpARM64MOVDconst {
3036 break
3037 }
3038 c := auxIntToInt64(v_1.AuxInt)
3039 v.reset(OpARM64ADDconst)
3040 v.AuxInt = int64ToAuxInt(int64(uint64(c) << uint64(d)))
3041 v.AddArg(x)
3042 return true
3043 }
3044
3045
3046 for {
3047 if v.Type != typ.UInt16 || auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64UBFX || v_0.Type != typ.UInt16 || auxIntToArm64BitField(v_0.AuxInt) != armBFAuxInt(8, 8) {
3048 break
3049 }
3050 x := v_0.Args[0]
3051 if x != v_1 {
3052 break
3053 }
3054 v.reset(OpARM64REV16W)
3055 v.AddArg(x)
3056 return true
3057 }
3058
3059
3060
3061 for {
3062 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64UBFX || auxIntToArm64BitField(v_0.AuxInt) != armBFAuxInt(8, 24) {
3063 break
3064 }
3065 v_0_0 := v_0.Args[0]
3066 if v_0_0.Op != OpARM64ANDconst {
3067 break
3068 }
3069 c1 := auxIntToInt64(v_0_0.AuxInt)
3070 x := v_0_0.Args[0]
3071 if v_1.Op != OpARM64ANDconst {
3072 break
3073 }
3074 c2 := auxIntToInt64(v_1.AuxInt)
3075 if x != v_1.Args[0] || !(uint32(c1) == 0xff00ff00 && uint32(c2) == 0x00ff00ff) {
3076 break
3077 }
3078 v.reset(OpARM64REV16W)
3079 v.AddArg(x)
3080 return true
3081 }
3082
3083
3084
3085 for {
3086 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
3087 break
3088 }
3089 v_0_0 := v_0.Args[0]
3090 if v_0_0.Op != OpARM64ANDconst {
3091 break
3092 }
3093 c1 := auxIntToInt64(v_0_0.AuxInt)
3094 x := v_0_0.Args[0]
3095 if v_1.Op != OpARM64ANDconst {
3096 break
3097 }
3098 c2 := auxIntToInt64(v_1.AuxInt)
3099 if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00ff00ff00 && uint64(c2) == 0x00ff00ff00ff00ff) {
3100 break
3101 }
3102 v.reset(OpARM64REV16)
3103 v.AddArg(x)
3104 return true
3105 }
3106
3107
3108
3109 for {
3110 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
3111 break
3112 }
3113 v_0_0 := v_0.Args[0]
3114 if v_0_0.Op != OpARM64ANDconst {
3115 break
3116 }
3117 c1 := auxIntToInt64(v_0_0.AuxInt)
3118 x := v_0_0.Args[0]
3119 if v_1.Op != OpARM64ANDconst {
3120 break
3121 }
3122 c2 := auxIntToInt64(v_1.AuxInt)
3123 if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00 && uint64(c2) == 0x00ff00ff) {
3124 break
3125 }
3126 v.reset(OpARM64REV16)
3127 v0 := b.NewValue0(v.Pos, OpARM64ANDconst, x.Type)
3128 v0.AuxInt = int64ToAuxInt(0xffffffff)
3129 v0.AddArg(x)
3130 v.AddArg(v0)
3131 return true
3132 }
3133
3134
3135 for {
3136 c := auxIntToInt64(v.AuxInt)
3137 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 64-c {
3138 break
3139 }
3140 x := v_0.Args[0]
3141 x2 := v_1
3142 v.reset(OpARM64EXTRconst)
3143 v.AuxInt = int64ToAuxInt(64 - c)
3144 v.AddArg2(x2, x)
3145 return true
3146 }
3147
3148
3149
3150 for {
3151 t := v.Type
3152 c := auxIntToInt64(v.AuxInt)
3153 if v_0.Op != OpARM64UBFX {
3154 break
3155 }
3156 bfc := auxIntToArm64BitField(v_0.AuxInt)
3157 x := v_0.Args[0]
3158 x2 := v_1
3159 if !(c < 32 && t.Size() == 4 && bfc == armBFAuxInt(32-c, c)) {
3160 break
3161 }
3162 v.reset(OpARM64EXTRWconst)
3163 v.AuxInt = int64ToAuxInt(32 - c)
3164 v.AddArg2(x2, x)
3165 return true
3166 }
3167 return false
3168 }
3169 func rewriteValueARM64_OpARM64ADDshiftRA(v *Value) bool {
3170 v_1 := v.Args[1]
3171 v_0 := v.Args[0]
3172 b := v.Block
3173
3174
3175 for {
3176 d := auxIntToInt64(v.AuxInt)
3177 if v_0.Op != OpARM64MOVDconst {
3178 break
3179 }
3180 c := auxIntToInt64(v_0.AuxInt)
3181 x := v_1
3182 v.reset(OpARM64ADDconst)
3183 v.AuxInt = int64ToAuxInt(c)
3184 v0 := b.NewValue0(v.Pos, OpARM64SRAconst, x.Type)
3185 v0.AuxInt = int64ToAuxInt(d)
3186 v0.AddArg(x)
3187 v.AddArg(v0)
3188 return true
3189 }
3190
3191
3192 for {
3193 d := auxIntToInt64(v.AuxInt)
3194 x := v_0
3195 if v_1.Op != OpARM64MOVDconst {
3196 break
3197 }
3198 c := auxIntToInt64(v_1.AuxInt)
3199 v.reset(OpARM64ADDconst)
3200 v.AuxInt = int64ToAuxInt(c >> uint64(d))
3201 v.AddArg(x)
3202 return true
3203 }
3204 return false
3205 }
3206 func rewriteValueARM64_OpARM64ADDshiftRL(v *Value) bool {
3207 v_1 := v.Args[1]
3208 v_0 := v.Args[0]
3209 b := v.Block
3210
3211
3212 for {
3213 d := auxIntToInt64(v.AuxInt)
3214 if v_0.Op != OpARM64MOVDconst {
3215 break
3216 }
3217 c := auxIntToInt64(v_0.AuxInt)
3218 x := v_1
3219 v.reset(OpARM64ADDconst)
3220 v.AuxInt = int64ToAuxInt(c)
3221 v0 := b.NewValue0(v.Pos, OpARM64SRLconst, x.Type)
3222 v0.AuxInt = int64ToAuxInt(d)
3223 v0.AddArg(x)
3224 v.AddArg(v0)
3225 return true
3226 }
3227
3228
3229 for {
3230 d := auxIntToInt64(v.AuxInt)
3231 x := v_0
3232 if v_1.Op != OpARM64MOVDconst {
3233 break
3234 }
3235 c := auxIntToInt64(v_1.AuxInt)
3236 v.reset(OpARM64ADDconst)
3237 v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
3238 v.AddArg(x)
3239 return true
3240 }
3241 return false
3242 }
3243 func rewriteValueARM64_OpARM64AND(v *Value) bool {
3244 v_1 := v.Args[1]
3245 v_0 := v.Args[0]
3246
3247
3248 for {
3249 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3250 x := v_0
3251 if v_1.Op != OpARM64MOVDconst {
3252 continue
3253 }
3254 c := auxIntToInt64(v_1.AuxInt)
3255 v.reset(OpARM64ANDconst)
3256 v.AuxInt = int64ToAuxInt(c)
3257 v.AddArg(x)
3258 return true
3259 }
3260 break
3261 }
3262
3263
3264 for {
3265 x := v_0
3266 if x != v_1 {
3267 break
3268 }
3269 v.copyOf(x)
3270 return true
3271 }
3272
3273
3274 for {
3275 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3276 x := v_0
3277 if v_1.Op != OpARM64MVN {
3278 continue
3279 }
3280 y := v_1.Args[0]
3281 v.reset(OpARM64BIC)
3282 v.AddArg2(x, y)
3283 return true
3284 }
3285 break
3286 }
3287
3288
3289
3290 for {
3291 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3292 x0 := v_0
3293 x1 := v_1
3294 if x1.Op != OpARM64SLLconst {
3295 continue
3296 }
3297 c := auxIntToInt64(x1.AuxInt)
3298 y := x1.Args[0]
3299 if !(clobberIfDead(x1)) {
3300 continue
3301 }
3302 v.reset(OpARM64ANDshiftLL)
3303 v.AuxInt = int64ToAuxInt(c)
3304 v.AddArg2(x0, y)
3305 return true
3306 }
3307 break
3308 }
3309
3310
3311
3312 for {
3313 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3314 x0 := v_0
3315 x1 := v_1
3316 if x1.Op != OpARM64SRLconst {
3317 continue
3318 }
3319 c := auxIntToInt64(x1.AuxInt)
3320 y := x1.Args[0]
3321 if !(clobberIfDead(x1)) {
3322 continue
3323 }
3324 v.reset(OpARM64ANDshiftRL)
3325 v.AuxInt = int64ToAuxInt(c)
3326 v.AddArg2(x0, y)
3327 return true
3328 }
3329 break
3330 }
3331
3332
3333
3334 for {
3335 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3336 x0 := v_0
3337 x1 := v_1
3338 if x1.Op != OpARM64SRAconst {
3339 continue
3340 }
3341 c := auxIntToInt64(x1.AuxInt)
3342 y := x1.Args[0]
3343 if !(clobberIfDead(x1)) {
3344 continue
3345 }
3346 v.reset(OpARM64ANDshiftRA)
3347 v.AuxInt = int64ToAuxInt(c)
3348 v.AddArg2(x0, y)
3349 return true
3350 }
3351 break
3352 }
3353
3354
3355
3356 for {
3357 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3358 x0 := v_0
3359 x1 := v_1
3360 if x1.Op != OpARM64RORconst {
3361 continue
3362 }
3363 c := auxIntToInt64(x1.AuxInt)
3364 y := x1.Args[0]
3365 if !(clobberIfDead(x1)) {
3366 continue
3367 }
3368 v.reset(OpARM64ANDshiftRO)
3369 v.AuxInt = int64ToAuxInt(c)
3370 v.AddArg2(x0, y)
3371 return true
3372 }
3373 break
3374 }
3375 return false
3376 }
3377 func rewriteValueARM64_OpARM64ANDconst(v *Value) bool {
3378 v_0 := v.Args[0]
3379
3380
3381 for {
3382 if auxIntToInt64(v.AuxInt) != 0 {
3383 break
3384 }
3385 v.reset(OpARM64MOVDconst)
3386 v.AuxInt = int64ToAuxInt(0)
3387 return true
3388 }
3389
3390
3391 for {
3392 if auxIntToInt64(v.AuxInt) != -1 {
3393 break
3394 }
3395 x := v_0
3396 v.copyOf(x)
3397 return true
3398 }
3399
3400
3401 for {
3402 c := auxIntToInt64(v.AuxInt)
3403 if v_0.Op != OpARM64MOVDconst {
3404 break
3405 }
3406 d := auxIntToInt64(v_0.AuxInt)
3407 v.reset(OpARM64MOVDconst)
3408 v.AuxInt = int64ToAuxInt(c & d)
3409 return true
3410 }
3411
3412
3413 for {
3414 c := auxIntToInt64(v.AuxInt)
3415 if v_0.Op != OpARM64ANDconst {
3416 break
3417 }
3418 d := auxIntToInt64(v_0.AuxInt)
3419 x := v_0.Args[0]
3420 v.reset(OpARM64ANDconst)
3421 v.AuxInt = int64ToAuxInt(c & d)
3422 v.AddArg(x)
3423 return true
3424 }
3425
3426
3427 for {
3428 c := auxIntToInt64(v.AuxInt)
3429 if v_0.Op != OpARM64MOVWUreg {
3430 break
3431 }
3432 x := v_0.Args[0]
3433 v.reset(OpARM64ANDconst)
3434 v.AuxInt = int64ToAuxInt(c & (1<<32 - 1))
3435 v.AddArg(x)
3436 return true
3437 }
3438
3439
3440 for {
3441 c := auxIntToInt64(v.AuxInt)
3442 if v_0.Op != OpARM64MOVHUreg {
3443 break
3444 }
3445 x := v_0.Args[0]
3446 v.reset(OpARM64ANDconst)
3447 v.AuxInt = int64ToAuxInt(c & (1<<16 - 1))
3448 v.AddArg(x)
3449 return true
3450 }
3451
3452
3453 for {
3454 c := auxIntToInt64(v.AuxInt)
3455 if v_0.Op != OpARM64MOVBUreg {
3456 break
3457 }
3458 x := v_0.Args[0]
3459 v.reset(OpARM64ANDconst)
3460 v.AuxInt = int64ToAuxInt(c & (1<<8 - 1))
3461 v.AddArg(x)
3462 return true
3463 }
3464
3465
3466
3467 for {
3468 ac := auxIntToInt64(v.AuxInt)
3469 if v_0.Op != OpARM64SLLconst {
3470 break
3471 }
3472 sc := auxIntToInt64(v_0.AuxInt)
3473 x := v_0.Args[0]
3474 if !(isARM64BFMask(sc, ac, sc)) {
3475 break
3476 }
3477 v.reset(OpARM64UBFIZ)
3478 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(sc, arm64BFWidth(ac, sc)))
3479 v.AddArg(x)
3480 return true
3481 }
3482
3483
3484
3485 for {
3486 ac := auxIntToInt64(v.AuxInt)
3487 if v_0.Op != OpARM64SRLconst {
3488 break
3489 }
3490 sc := auxIntToInt64(v_0.AuxInt)
3491 x := v_0.Args[0]
3492 if !(isARM64BFMask(sc, ac, 0)) {
3493 break
3494 }
3495 v.reset(OpARM64UBFX)
3496 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(sc, arm64BFWidth(ac, 0)))
3497 v.AddArg(x)
3498 return true
3499 }
3500
3501
3502
3503 for {
3504 c := auxIntToInt64(v.AuxInt)
3505 if v_0.Op != OpARM64UBFX {
3506 break
3507 }
3508 bfc := auxIntToArm64BitField(v_0.AuxInt)
3509 x := v_0.Args[0]
3510 if !(isARM64BFMask(0, c, 0)) {
3511 break
3512 }
3513 v.reset(OpARM64UBFX)
3514 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb(), min(bfc.width(), arm64BFWidth(c, 0))))
3515 v.AddArg(x)
3516 return true
3517 }
3518
3519
3520 for {
3521 if auxIntToInt64(v.AuxInt) != 0xffffffff {
3522 break
3523 }
3524 x := v_0
3525 v.reset(OpARM64MOVWUreg)
3526 v.AddArg(x)
3527 return true
3528 }
3529
3530
3531 for {
3532 if auxIntToInt64(v.AuxInt) != 0xffff {
3533 break
3534 }
3535 x := v_0
3536 v.reset(OpARM64MOVHUreg)
3537 v.AddArg(x)
3538 return true
3539 }
3540
3541
3542 for {
3543 if auxIntToInt64(v.AuxInt) != 0xff {
3544 break
3545 }
3546 x := v_0
3547 v.reset(OpARM64MOVBUreg)
3548 v.AddArg(x)
3549 return true
3550 }
3551 return false
3552 }
3553 func rewriteValueARM64_OpARM64ANDshiftLL(v *Value) bool {
3554 v_1 := v.Args[1]
3555 v_0 := v.Args[0]
3556 b := v.Block
3557
3558
3559 for {
3560 d := auxIntToInt64(v.AuxInt)
3561 if v_0.Op != OpARM64MOVDconst {
3562 break
3563 }
3564 c := auxIntToInt64(v_0.AuxInt)
3565 x := v_1
3566 v.reset(OpARM64ANDconst)
3567 v.AuxInt = int64ToAuxInt(c)
3568 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
3569 v0.AuxInt = int64ToAuxInt(d)
3570 v0.AddArg(x)
3571 v.AddArg(v0)
3572 return true
3573 }
3574
3575
3576 for {
3577 d := auxIntToInt64(v.AuxInt)
3578 x := v_0
3579 if v_1.Op != OpARM64MOVDconst {
3580 break
3581 }
3582 c := auxIntToInt64(v_1.AuxInt)
3583 v.reset(OpARM64ANDconst)
3584 v.AuxInt = int64ToAuxInt(int64(uint64(c) << uint64(d)))
3585 v.AddArg(x)
3586 return true
3587 }
3588
3589
3590 for {
3591 c := auxIntToInt64(v.AuxInt)
3592 y := v_0
3593 if y.Op != OpARM64SLLconst || auxIntToInt64(y.AuxInt) != c {
3594 break
3595 }
3596 x := y.Args[0]
3597 if x != v_1 {
3598 break
3599 }
3600 v.copyOf(y)
3601 return true
3602 }
3603 return false
3604 }
3605 func rewriteValueARM64_OpARM64ANDshiftRA(v *Value) bool {
3606 v_1 := v.Args[1]
3607 v_0 := v.Args[0]
3608 b := v.Block
3609
3610
3611 for {
3612 d := auxIntToInt64(v.AuxInt)
3613 if v_0.Op != OpARM64MOVDconst {
3614 break
3615 }
3616 c := auxIntToInt64(v_0.AuxInt)
3617 x := v_1
3618 v.reset(OpARM64ANDconst)
3619 v.AuxInt = int64ToAuxInt(c)
3620 v0 := b.NewValue0(v.Pos, OpARM64SRAconst, x.Type)
3621 v0.AuxInt = int64ToAuxInt(d)
3622 v0.AddArg(x)
3623 v.AddArg(v0)
3624 return true
3625 }
3626
3627
3628 for {
3629 d := auxIntToInt64(v.AuxInt)
3630 x := v_0
3631 if v_1.Op != OpARM64MOVDconst {
3632 break
3633 }
3634 c := auxIntToInt64(v_1.AuxInt)
3635 v.reset(OpARM64ANDconst)
3636 v.AuxInt = int64ToAuxInt(c >> uint64(d))
3637 v.AddArg(x)
3638 return true
3639 }
3640
3641
3642 for {
3643 c := auxIntToInt64(v.AuxInt)
3644 y := v_0
3645 if y.Op != OpARM64SRAconst || auxIntToInt64(y.AuxInt) != c {
3646 break
3647 }
3648 x := y.Args[0]
3649 if x != v_1 {
3650 break
3651 }
3652 v.copyOf(y)
3653 return true
3654 }
3655 return false
3656 }
3657 func rewriteValueARM64_OpARM64ANDshiftRL(v *Value) bool {
3658 v_1 := v.Args[1]
3659 v_0 := v.Args[0]
3660 b := v.Block
3661
3662
3663 for {
3664 d := auxIntToInt64(v.AuxInt)
3665 if v_0.Op != OpARM64MOVDconst {
3666 break
3667 }
3668 c := auxIntToInt64(v_0.AuxInt)
3669 x := v_1
3670 v.reset(OpARM64ANDconst)
3671 v.AuxInt = int64ToAuxInt(c)
3672 v0 := b.NewValue0(v.Pos, OpARM64SRLconst, x.Type)
3673 v0.AuxInt = int64ToAuxInt(d)
3674 v0.AddArg(x)
3675 v.AddArg(v0)
3676 return true
3677 }
3678
3679
3680 for {
3681 d := auxIntToInt64(v.AuxInt)
3682 x := v_0
3683 if v_1.Op != OpARM64MOVDconst {
3684 break
3685 }
3686 c := auxIntToInt64(v_1.AuxInt)
3687 v.reset(OpARM64ANDconst)
3688 v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
3689 v.AddArg(x)
3690 return true
3691 }
3692
3693
3694 for {
3695 c := auxIntToInt64(v.AuxInt)
3696 y := v_0
3697 if y.Op != OpARM64SRLconst || auxIntToInt64(y.AuxInt) != c {
3698 break
3699 }
3700 x := y.Args[0]
3701 if x != v_1 {
3702 break
3703 }
3704 v.copyOf(y)
3705 return true
3706 }
3707 return false
3708 }
3709 func rewriteValueARM64_OpARM64ANDshiftRO(v *Value) bool {
3710 v_1 := v.Args[1]
3711 v_0 := v.Args[0]
3712 b := v.Block
3713
3714
3715 for {
3716 d := auxIntToInt64(v.AuxInt)
3717 if v_0.Op != OpARM64MOVDconst {
3718 break
3719 }
3720 c := auxIntToInt64(v_0.AuxInt)
3721 x := v_1
3722 v.reset(OpARM64ANDconst)
3723 v.AuxInt = int64ToAuxInt(c)
3724 v0 := b.NewValue0(v.Pos, OpARM64RORconst, x.Type)
3725 v0.AuxInt = int64ToAuxInt(d)
3726 v0.AddArg(x)
3727 v.AddArg(v0)
3728 return true
3729 }
3730
3731
3732 for {
3733 d := auxIntToInt64(v.AuxInt)
3734 x := v_0
3735 if v_1.Op != OpARM64MOVDconst {
3736 break
3737 }
3738 c := auxIntToInt64(v_1.AuxInt)
3739 v.reset(OpARM64ANDconst)
3740 v.AuxInt = int64ToAuxInt(rotateRight64(c, d))
3741 v.AddArg(x)
3742 return true
3743 }
3744
3745
3746 for {
3747 c := auxIntToInt64(v.AuxInt)
3748 y := v_0
3749 if y.Op != OpARM64RORconst || auxIntToInt64(y.AuxInt) != c {
3750 break
3751 }
3752 x := y.Args[0]
3753 if x != v_1 {
3754 break
3755 }
3756 v.copyOf(y)
3757 return true
3758 }
3759 return false
3760 }
3761 func rewriteValueARM64_OpARM64BIC(v *Value) bool {
3762 v_1 := v.Args[1]
3763 v_0 := v.Args[0]
3764
3765
3766 for {
3767 x := v_0
3768 if v_1.Op != OpARM64MOVDconst {
3769 break
3770 }
3771 c := auxIntToInt64(v_1.AuxInt)
3772 v.reset(OpARM64ANDconst)
3773 v.AuxInt = int64ToAuxInt(^c)
3774 v.AddArg(x)
3775 return true
3776 }
3777
3778
3779 for {
3780 x := v_0
3781 if x != v_1 {
3782 break
3783 }
3784 v.reset(OpARM64MOVDconst)
3785 v.AuxInt = int64ToAuxInt(0)
3786 return true
3787 }
3788
3789
3790
3791 for {
3792 x0 := v_0
3793 x1 := v_1
3794 if x1.Op != OpARM64SLLconst {
3795 break
3796 }
3797 c := auxIntToInt64(x1.AuxInt)
3798 y := x1.Args[0]
3799 if !(clobberIfDead(x1)) {
3800 break
3801 }
3802 v.reset(OpARM64BICshiftLL)
3803 v.AuxInt = int64ToAuxInt(c)
3804 v.AddArg2(x0, y)
3805 return true
3806 }
3807
3808
3809
3810 for {
3811 x0 := v_0
3812 x1 := v_1
3813 if x1.Op != OpARM64SRLconst {
3814 break
3815 }
3816 c := auxIntToInt64(x1.AuxInt)
3817 y := x1.Args[0]
3818 if !(clobberIfDead(x1)) {
3819 break
3820 }
3821 v.reset(OpARM64BICshiftRL)
3822 v.AuxInt = int64ToAuxInt(c)
3823 v.AddArg2(x0, y)
3824 return true
3825 }
3826
3827
3828
3829 for {
3830 x0 := v_0
3831 x1 := v_1
3832 if x1.Op != OpARM64SRAconst {
3833 break
3834 }
3835 c := auxIntToInt64(x1.AuxInt)
3836 y := x1.Args[0]
3837 if !(clobberIfDead(x1)) {
3838 break
3839 }
3840 v.reset(OpARM64BICshiftRA)
3841 v.AuxInt = int64ToAuxInt(c)
3842 v.AddArg2(x0, y)
3843 return true
3844 }
3845
3846
3847
3848 for {
3849 x0 := v_0
3850 x1 := v_1
3851 if x1.Op != OpARM64RORconst {
3852 break
3853 }
3854 c := auxIntToInt64(x1.AuxInt)
3855 y := x1.Args[0]
3856 if !(clobberIfDead(x1)) {
3857 break
3858 }
3859 v.reset(OpARM64BICshiftRO)
3860 v.AuxInt = int64ToAuxInt(c)
3861 v.AddArg2(x0, y)
3862 return true
3863 }
3864 return false
3865 }
3866 func rewriteValueARM64_OpARM64BICshiftLL(v *Value) bool {
3867 v_1 := v.Args[1]
3868 v_0 := v.Args[0]
3869
3870
3871 for {
3872 d := auxIntToInt64(v.AuxInt)
3873 x := v_0
3874 if v_1.Op != OpARM64MOVDconst {
3875 break
3876 }
3877 c := auxIntToInt64(v_1.AuxInt)
3878 v.reset(OpARM64ANDconst)
3879 v.AuxInt = int64ToAuxInt(^int64(uint64(c) << uint64(d)))
3880 v.AddArg(x)
3881 return true
3882 }
3883
3884
3885 for {
3886 c := auxIntToInt64(v.AuxInt)
3887 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != c {
3888 break
3889 }
3890 x := v_0.Args[0]
3891 if x != v_1 {
3892 break
3893 }
3894 v.reset(OpARM64MOVDconst)
3895 v.AuxInt = int64ToAuxInt(0)
3896 return true
3897 }
3898 return false
3899 }
3900 func rewriteValueARM64_OpARM64BICshiftRA(v *Value) bool {
3901 v_1 := v.Args[1]
3902 v_0 := v.Args[0]
3903
3904
3905 for {
3906 d := auxIntToInt64(v.AuxInt)
3907 x := v_0
3908 if v_1.Op != OpARM64MOVDconst {
3909 break
3910 }
3911 c := auxIntToInt64(v_1.AuxInt)
3912 v.reset(OpARM64ANDconst)
3913 v.AuxInt = int64ToAuxInt(^(c >> uint64(d)))
3914 v.AddArg(x)
3915 return true
3916 }
3917
3918
3919 for {
3920 c := auxIntToInt64(v.AuxInt)
3921 if v_0.Op != OpARM64SRAconst || auxIntToInt64(v_0.AuxInt) != c {
3922 break
3923 }
3924 x := v_0.Args[0]
3925 if x != v_1 {
3926 break
3927 }
3928 v.reset(OpARM64MOVDconst)
3929 v.AuxInt = int64ToAuxInt(0)
3930 return true
3931 }
3932 return false
3933 }
3934 func rewriteValueARM64_OpARM64BICshiftRL(v *Value) bool {
3935 v_1 := v.Args[1]
3936 v_0 := v.Args[0]
3937
3938
3939 for {
3940 d := auxIntToInt64(v.AuxInt)
3941 x := v_0
3942 if v_1.Op != OpARM64MOVDconst {
3943 break
3944 }
3945 c := auxIntToInt64(v_1.AuxInt)
3946 v.reset(OpARM64ANDconst)
3947 v.AuxInt = int64ToAuxInt(^int64(uint64(c) >> uint64(d)))
3948 v.AddArg(x)
3949 return true
3950 }
3951
3952
3953 for {
3954 c := auxIntToInt64(v.AuxInt)
3955 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != c {
3956 break
3957 }
3958 x := v_0.Args[0]
3959 if x != v_1 {
3960 break
3961 }
3962 v.reset(OpARM64MOVDconst)
3963 v.AuxInt = int64ToAuxInt(0)
3964 return true
3965 }
3966 return false
3967 }
3968 func rewriteValueARM64_OpARM64BICshiftRO(v *Value) bool {
3969 v_1 := v.Args[1]
3970 v_0 := v.Args[0]
3971
3972
3973 for {
3974 d := auxIntToInt64(v.AuxInt)
3975 x := v_0
3976 if v_1.Op != OpARM64MOVDconst {
3977 break
3978 }
3979 c := auxIntToInt64(v_1.AuxInt)
3980 v.reset(OpARM64ANDconst)
3981 v.AuxInt = int64ToAuxInt(^rotateRight64(c, d))
3982 v.AddArg(x)
3983 return true
3984 }
3985
3986
3987 for {
3988 c := auxIntToInt64(v.AuxInt)
3989 if v_0.Op != OpARM64RORconst || auxIntToInt64(v_0.AuxInt) != c {
3990 break
3991 }
3992 x := v_0.Args[0]
3993 if x != v_1 {
3994 break
3995 }
3996 v.reset(OpARM64MOVDconst)
3997 v.AuxInt = int64ToAuxInt(0)
3998 return true
3999 }
4000 return false
4001 }
4002 func rewriteValueARM64_OpARM64CMN(v *Value) bool {
4003 v_1 := v.Args[1]
4004 v_0 := v.Args[0]
4005
4006
4007 for {
4008 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4009 x := v_0
4010 if v_1.Op != OpARM64MOVDconst {
4011 continue
4012 }
4013 c := auxIntToInt64(v_1.AuxInt)
4014 v.reset(OpARM64CMNconst)
4015 v.AuxInt = int64ToAuxInt(c)
4016 v.AddArg(x)
4017 return true
4018 }
4019 break
4020 }
4021
4022
4023
4024 for {
4025 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4026 x0 := v_0
4027 x1 := v_1
4028 if x1.Op != OpARM64SLLconst {
4029 continue
4030 }
4031 c := auxIntToInt64(x1.AuxInt)
4032 y := x1.Args[0]
4033 if !(clobberIfDead(x1)) {
4034 continue
4035 }
4036 v.reset(OpARM64CMNshiftLL)
4037 v.AuxInt = int64ToAuxInt(c)
4038 v.AddArg2(x0, y)
4039 return true
4040 }
4041 break
4042 }
4043
4044
4045
4046 for {
4047 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4048 x0 := v_0
4049 x1 := v_1
4050 if x1.Op != OpARM64SRLconst {
4051 continue
4052 }
4053 c := auxIntToInt64(x1.AuxInt)
4054 y := x1.Args[0]
4055 if !(clobberIfDead(x1)) {
4056 continue
4057 }
4058 v.reset(OpARM64CMNshiftRL)
4059 v.AuxInt = int64ToAuxInt(c)
4060 v.AddArg2(x0, y)
4061 return true
4062 }
4063 break
4064 }
4065
4066
4067
4068 for {
4069 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4070 x0 := v_0
4071 x1 := v_1
4072 if x1.Op != OpARM64SRAconst {
4073 continue
4074 }
4075 c := auxIntToInt64(x1.AuxInt)
4076 y := x1.Args[0]
4077 if !(clobberIfDead(x1)) {
4078 continue
4079 }
4080 v.reset(OpARM64CMNshiftRA)
4081 v.AuxInt = int64ToAuxInt(c)
4082 v.AddArg2(x0, y)
4083 return true
4084 }
4085 break
4086 }
4087 return false
4088 }
4089 func rewriteValueARM64_OpARM64CMNW(v *Value) bool {
4090 v_1 := v.Args[1]
4091 v_0 := v.Args[0]
4092
4093
4094 for {
4095 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4096 x := v_0
4097 if v_1.Op != OpARM64MOVDconst {
4098 continue
4099 }
4100 c := auxIntToInt64(v_1.AuxInt)
4101 v.reset(OpARM64CMNWconst)
4102 v.AuxInt = int32ToAuxInt(int32(c))
4103 v.AddArg(x)
4104 return true
4105 }
4106 break
4107 }
4108 return false
4109 }
4110 func rewriteValueARM64_OpARM64CMNWconst(v *Value) bool {
4111 v_0 := v.Args[0]
4112
4113
4114
4115 for {
4116 c := auxIntToInt32(v.AuxInt)
4117 y := v_0
4118 if !(c < 0 && c != -1<<31) {
4119 break
4120 }
4121 v.reset(OpARM64CMPWconst)
4122 v.AuxInt = int32ToAuxInt(-c)
4123 v.AddArg(y)
4124 return true
4125 }
4126
4127
4128 for {
4129 y := auxIntToInt32(v.AuxInt)
4130 if v_0.Op != OpARM64MOVDconst {
4131 break
4132 }
4133 x := auxIntToInt64(v_0.AuxInt)
4134 v.reset(OpARM64FlagConstant)
4135 v.AuxInt = flagConstantToAuxInt(addFlags32(int32(x), y))
4136 return true
4137 }
4138 return false
4139 }
4140 func rewriteValueARM64_OpARM64CMNconst(v *Value) bool {
4141 v_0 := v.Args[0]
4142
4143
4144
4145 for {
4146 c := auxIntToInt64(v.AuxInt)
4147 y := v_0
4148 if !(c < 0 && c != -1<<63) {
4149 break
4150 }
4151 v.reset(OpARM64CMPconst)
4152 v.AuxInt = int64ToAuxInt(-c)
4153 v.AddArg(y)
4154 return true
4155 }
4156
4157
4158 for {
4159 y := auxIntToInt64(v.AuxInt)
4160 if v_0.Op != OpARM64MOVDconst {
4161 break
4162 }
4163 x := auxIntToInt64(v_0.AuxInt)
4164 v.reset(OpARM64FlagConstant)
4165 v.AuxInt = flagConstantToAuxInt(addFlags64(x, y))
4166 return true
4167 }
4168 return false
4169 }
4170 func rewriteValueARM64_OpARM64CMNshiftLL(v *Value) bool {
4171 v_1 := v.Args[1]
4172 v_0 := v.Args[0]
4173 b := v.Block
4174
4175
4176 for {
4177 d := auxIntToInt64(v.AuxInt)
4178 if v_0.Op != OpARM64MOVDconst {
4179 break
4180 }
4181 c := auxIntToInt64(v_0.AuxInt)
4182 x := v_1
4183 v.reset(OpARM64CMNconst)
4184 v.AuxInt = int64ToAuxInt(c)
4185 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
4186 v0.AuxInt = int64ToAuxInt(d)
4187 v0.AddArg(x)
4188 v.AddArg(v0)
4189 return true
4190 }
4191
4192
4193 for {
4194 d := auxIntToInt64(v.AuxInt)
4195 x := v_0
4196 if v_1.Op != OpARM64MOVDconst {
4197 break
4198 }
4199 c := auxIntToInt64(v_1.AuxInt)
4200 v.reset(OpARM64CMNconst)
4201 v.AuxInt = int64ToAuxInt(int64(uint64(c) << uint64(d)))
4202 v.AddArg(x)
4203 return true
4204 }
4205 return false
4206 }
4207 func rewriteValueARM64_OpARM64CMNshiftRA(v *Value) bool {
4208 v_1 := v.Args[1]
4209 v_0 := v.Args[0]
4210 b := v.Block
4211
4212
4213 for {
4214 d := auxIntToInt64(v.AuxInt)
4215 if v_0.Op != OpARM64MOVDconst {
4216 break
4217 }
4218 c := auxIntToInt64(v_0.AuxInt)
4219 x := v_1
4220 v.reset(OpARM64CMNconst)
4221 v.AuxInt = int64ToAuxInt(c)
4222 v0 := b.NewValue0(v.Pos, OpARM64SRAconst, x.Type)
4223 v0.AuxInt = int64ToAuxInt(d)
4224 v0.AddArg(x)
4225 v.AddArg(v0)
4226 return true
4227 }
4228
4229
4230 for {
4231 d := auxIntToInt64(v.AuxInt)
4232 x := v_0
4233 if v_1.Op != OpARM64MOVDconst {
4234 break
4235 }
4236 c := auxIntToInt64(v_1.AuxInt)
4237 v.reset(OpARM64CMNconst)
4238 v.AuxInt = int64ToAuxInt(c >> uint64(d))
4239 v.AddArg(x)
4240 return true
4241 }
4242 return false
4243 }
4244 func rewriteValueARM64_OpARM64CMNshiftRL(v *Value) bool {
4245 v_1 := v.Args[1]
4246 v_0 := v.Args[0]
4247 b := v.Block
4248
4249
4250 for {
4251 d := auxIntToInt64(v.AuxInt)
4252 if v_0.Op != OpARM64MOVDconst {
4253 break
4254 }
4255 c := auxIntToInt64(v_0.AuxInt)
4256 x := v_1
4257 v.reset(OpARM64CMNconst)
4258 v.AuxInt = int64ToAuxInt(c)
4259 v0 := b.NewValue0(v.Pos, OpARM64SRLconst, x.Type)
4260 v0.AuxInt = int64ToAuxInt(d)
4261 v0.AddArg(x)
4262 v.AddArg(v0)
4263 return true
4264 }
4265
4266
4267 for {
4268 d := auxIntToInt64(v.AuxInt)
4269 x := v_0
4270 if v_1.Op != OpARM64MOVDconst {
4271 break
4272 }
4273 c := auxIntToInt64(v_1.AuxInt)
4274 v.reset(OpARM64CMNconst)
4275 v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
4276 v.AddArg(x)
4277 return true
4278 }
4279 return false
4280 }
4281 func rewriteValueARM64_OpARM64CMP(v *Value) bool {
4282 v_1 := v.Args[1]
4283 v_0 := v.Args[0]
4284 b := v.Block
4285
4286
4287 for {
4288 x := v_0
4289 if v_1.Op != OpARM64MOVDconst {
4290 break
4291 }
4292 c := auxIntToInt64(v_1.AuxInt)
4293 v.reset(OpARM64CMPconst)
4294 v.AuxInt = int64ToAuxInt(c)
4295 v.AddArg(x)
4296 return true
4297 }
4298
4299
4300 for {
4301 if v_0.Op != OpARM64MOVDconst {
4302 break
4303 }
4304 c := auxIntToInt64(v_0.AuxInt)
4305 x := v_1
4306 v.reset(OpARM64InvertFlags)
4307 v0 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
4308 v0.AuxInt = int64ToAuxInt(c)
4309 v0.AddArg(x)
4310 v.AddArg(v0)
4311 return true
4312 }
4313
4314
4315
4316 for {
4317 x := v_0
4318 y := v_1
4319 if !(canonLessThan(x, y)) {
4320 break
4321 }
4322 v.reset(OpARM64InvertFlags)
4323 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
4324 v0.AddArg2(y, x)
4325 v.AddArg(v0)
4326 return true
4327 }
4328
4329
4330
4331 for {
4332 x0 := v_0
4333 x1 := v_1
4334 if x1.Op != OpARM64SLLconst {
4335 break
4336 }
4337 c := auxIntToInt64(x1.AuxInt)
4338 y := x1.Args[0]
4339 if !(clobberIfDead(x1)) {
4340 break
4341 }
4342 v.reset(OpARM64CMPshiftLL)
4343 v.AuxInt = int64ToAuxInt(c)
4344 v.AddArg2(x0, y)
4345 return true
4346 }
4347
4348
4349
4350 for {
4351 x0 := v_0
4352 if x0.Op != OpARM64SLLconst {
4353 break
4354 }
4355 c := auxIntToInt64(x0.AuxInt)
4356 y := x0.Args[0]
4357 x1 := v_1
4358 if !(clobberIfDead(x0)) {
4359 break
4360 }
4361 v.reset(OpARM64InvertFlags)
4362 v0 := b.NewValue0(v.Pos, OpARM64CMPshiftLL, types.TypeFlags)
4363 v0.AuxInt = int64ToAuxInt(c)
4364 v0.AddArg2(x1, y)
4365 v.AddArg(v0)
4366 return true
4367 }
4368
4369
4370
4371 for {
4372 x0 := v_0
4373 x1 := v_1
4374 if x1.Op != OpARM64SRLconst {
4375 break
4376 }
4377 c := auxIntToInt64(x1.AuxInt)
4378 y := x1.Args[0]
4379 if !(clobberIfDead(x1)) {
4380 break
4381 }
4382 v.reset(OpARM64CMPshiftRL)
4383 v.AuxInt = int64ToAuxInt(c)
4384 v.AddArg2(x0, y)
4385 return true
4386 }
4387
4388
4389
4390 for {
4391 x0 := v_0
4392 if x0.Op != OpARM64SRLconst {
4393 break
4394 }
4395 c := auxIntToInt64(x0.AuxInt)
4396 y := x0.Args[0]
4397 x1 := v_1
4398 if !(clobberIfDead(x0)) {
4399 break
4400 }
4401 v.reset(OpARM64InvertFlags)
4402 v0 := b.NewValue0(v.Pos, OpARM64CMPshiftRL, types.TypeFlags)
4403 v0.AuxInt = int64ToAuxInt(c)
4404 v0.AddArg2(x1, y)
4405 v.AddArg(v0)
4406 return true
4407 }
4408
4409
4410
4411 for {
4412 x0 := v_0
4413 x1 := v_1
4414 if x1.Op != OpARM64SRAconst {
4415 break
4416 }
4417 c := auxIntToInt64(x1.AuxInt)
4418 y := x1.Args[0]
4419 if !(clobberIfDead(x1)) {
4420 break
4421 }
4422 v.reset(OpARM64CMPshiftRA)
4423 v.AuxInt = int64ToAuxInt(c)
4424 v.AddArg2(x0, y)
4425 return true
4426 }
4427
4428
4429
4430 for {
4431 x0 := v_0
4432 if x0.Op != OpARM64SRAconst {
4433 break
4434 }
4435 c := auxIntToInt64(x0.AuxInt)
4436 y := x0.Args[0]
4437 x1 := v_1
4438 if !(clobberIfDead(x0)) {
4439 break
4440 }
4441 v.reset(OpARM64InvertFlags)
4442 v0 := b.NewValue0(v.Pos, OpARM64CMPshiftRA, types.TypeFlags)
4443 v0.AuxInt = int64ToAuxInt(c)
4444 v0.AddArg2(x1, y)
4445 v.AddArg(v0)
4446 return true
4447 }
4448 return false
4449 }
4450 func rewriteValueARM64_OpARM64CMPW(v *Value) bool {
4451 v_1 := v.Args[1]
4452 v_0 := v.Args[0]
4453 b := v.Block
4454
4455
4456 for {
4457 x := v_0
4458 if v_1.Op != OpARM64MOVDconst {
4459 break
4460 }
4461 c := auxIntToInt64(v_1.AuxInt)
4462 v.reset(OpARM64CMPWconst)
4463 v.AuxInt = int32ToAuxInt(int32(c))
4464 v.AddArg(x)
4465 return true
4466 }
4467
4468
4469 for {
4470 if v_0.Op != OpARM64MOVDconst {
4471 break
4472 }
4473 c := auxIntToInt64(v_0.AuxInt)
4474 x := v_1
4475 v.reset(OpARM64InvertFlags)
4476 v0 := b.NewValue0(v.Pos, OpARM64CMPWconst, types.TypeFlags)
4477 v0.AuxInt = int32ToAuxInt(int32(c))
4478 v0.AddArg(x)
4479 v.AddArg(v0)
4480 return true
4481 }
4482
4483
4484
4485 for {
4486 x := v_0
4487 y := v_1
4488 if !(canonLessThan(x, y)) {
4489 break
4490 }
4491 v.reset(OpARM64InvertFlags)
4492 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
4493 v0.AddArg2(y, x)
4494 v.AddArg(v0)
4495 return true
4496 }
4497 return false
4498 }
4499 func rewriteValueARM64_OpARM64CMPWconst(v *Value) bool {
4500 v_0 := v.Args[0]
4501
4502
4503
4504 for {
4505 c := auxIntToInt32(v.AuxInt)
4506 y := v_0
4507 if !(c < 0 && c != -1<<31) {
4508 break
4509 }
4510 v.reset(OpARM64CMNWconst)
4511 v.AuxInt = int32ToAuxInt(-c)
4512 v.AddArg(y)
4513 return true
4514 }
4515
4516
4517 for {
4518 y := auxIntToInt32(v.AuxInt)
4519 if v_0.Op != OpARM64MOVDconst {
4520 break
4521 }
4522 x := auxIntToInt64(v_0.AuxInt)
4523 v.reset(OpARM64FlagConstant)
4524 v.AuxInt = flagConstantToAuxInt(subFlags32(int32(x), y))
4525 return true
4526 }
4527
4528
4529
4530 for {
4531 c := auxIntToInt32(v.AuxInt)
4532 if v_0.Op != OpARM64MOVBUreg || !(0xff < c) {
4533 break
4534 }
4535 v.reset(OpARM64FlagConstant)
4536 v.AuxInt = flagConstantToAuxInt(subFlags64(0, 1))
4537 return true
4538 }
4539
4540
4541
4542 for {
4543 c := auxIntToInt32(v.AuxInt)
4544 if v_0.Op != OpARM64MOVHUreg || !(0xffff < c) {
4545 break
4546 }
4547 v.reset(OpARM64FlagConstant)
4548 v.AuxInt = flagConstantToAuxInt(subFlags64(0, 1))
4549 return true
4550 }
4551 return false
4552 }
4553 func rewriteValueARM64_OpARM64CMPconst(v *Value) bool {
4554 v_0 := v.Args[0]
4555
4556
4557
4558 for {
4559 c := auxIntToInt64(v.AuxInt)
4560 y := v_0
4561 if !(c < 0 && c != -1<<63) {
4562 break
4563 }
4564 v.reset(OpARM64CMNconst)
4565 v.AuxInt = int64ToAuxInt(-c)
4566 v.AddArg(y)
4567 return true
4568 }
4569
4570
4571 for {
4572 y := auxIntToInt64(v.AuxInt)
4573 if v_0.Op != OpARM64MOVDconst {
4574 break
4575 }
4576 x := auxIntToInt64(v_0.AuxInt)
4577 v.reset(OpARM64FlagConstant)
4578 v.AuxInt = flagConstantToAuxInt(subFlags64(x, y))
4579 return true
4580 }
4581
4582
4583
4584 for {
4585 c := auxIntToInt64(v.AuxInt)
4586 if v_0.Op != OpARM64MOVBUreg || !(0xff < c) {
4587 break
4588 }
4589 v.reset(OpARM64FlagConstant)
4590 v.AuxInt = flagConstantToAuxInt(subFlags64(0, 1))
4591 return true
4592 }
4593
4594
4595
4596 for {
4597 c := auxIntToInt64(v.AuxInt)
4598 if v_0.Op != OpARM64MOVHUreg || !(0xffff < c) {
4599 break
4600 }
4601 v.reset(OpARM64FlagConstant)
4602 v.AuxInt = flagConstantToAuxInt(subFlags64(0, 1))
4603 return true
4604 }
4605
4606
4607
4608 for {
4609 c := auxIntToInt64(v.AuxInt)
4610 if v_0.Op != OpARM64MOVWUreg || !(0xffffffff < c) {
4611 break
4612 }
4613 v.reset(OpARM64FlagConstant)
4614 v.AuxInt = flagConstantToAuxInt(subFlags64(0, 1))
4615 return true
4616 }
4617
4618
4619
4620 for {
4621 n := auxIntToInt64(v.AuxInt)
4622 if v_0.Op != OpARM64ANDconst {
4623 break
4624 }
4625 m := auxIntToInt64(v_0.AuxInt)
4626 if !(0 <= m && m < n) {
4627 break
4628 }
4629 v.reset(OpARM64FlagConstant)
4630 v.AuxInt = flagConstantToAuxInt(subFlags64(0, 1))
4631 return true
4632 }
4633
4634
4635
4636 for {
4637 n := auxIntToInt64(v.AuxInt)
4638 if v_0.Op != OpARM64SRLconst {
4639 break
4640 }
4641 c := auxIntToInt64(v_0.AuxInt)
4642 if !(0 <= n && 0 < c && c <= 63 && (1<<uint64(64-c)) <= uint64(n)) {
4643 break
4644 }
4645 v.reset(OpARM64FlagConstant)
4646 v.AuxInt = flagConstantToAuxInt(subFlags64(0, 1))
4647 return true
4648 }
4649 return false
4650 }
4651 func rewriteValueARM64_OpARM64CMPshiftLL(v *Value) bool {
4652 v_1 := v.Args[1]
4653 v_0 := v.Args[0]
4654 b := v.Block
4655
4656
4657 for {
4658 d := auxIntToInt64(v.AuxInt)
4659 if v_0.Op != OpARM64MOVDconst {
4660 break
4661 }
4662 c := auxIntToInt64(v_0.AuxInt)
4663 x := v_1
4664 v.reset(OpARM64InvertFlags)
4665 v0 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
4666 v0.AuxInt = int64ToAuxInt(c)
4667 v1 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
4668 v1.AuxInt = int64ToAuxInt(d)
4669 v1.AddArg(x)
4670 v0.AddArg(v1)
4671 v.AddArg(v0)
4672 return true
4673 }
4674
4675
4676 for {
4677 d := auxIntToInt64(v.AuxInt)
4678 x := v_0
4679 if v_1.Op != OpARM64MOVDconst {
4680 break
4681 }
4682 c := auxIntToInt64(v_1.AuxInt)
4683 v.reset(OpARM64CMPconst)
4684 v.AuxInt = int64ToAuxInt(int64(uint64(c) << uint64(d)))
4685 v.AddArg(x)
4686 return true
4687 }
4688 return false
4689 }
4690 func rewriteValueARM64_OpARM64CMPshiftRA(v *Value) bool {
4691 v_1 := v.Args[1]
4692 v_0 := v.Args[0]
4693 b := v.Block
4694
4695
4696 for {
4697 d := auxIntToInt64(v.AuxInt)
4698 if v_0.Op != OpARM64MOVDconst {
4699 break
4700 }
4701 c := auxIntToInt64(v_0.AuxInt)
4702 x := v_1
4703 v.reset(OpARM64InvertFlags)
4704 v0 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
4705 v0.AuxInt = int64ToAuxInt(c)
4706 v1 := b.NewValue0(v.Pos, OpARM64SRAconst, x.Type)
4707 v1.AuxInt = int64ToAuxInt(d)
4708 v1.AddArg(x)
4709 v0.AddArg(v1)
4710 v.AddArg(v0)
4711 return true
4712 }
4713
4714
4715 for {
4716 d := auxIntToInt64(v.AuxInt)
4717 x := v_0
4718 if v_1.Op != OpARM64MOVDconst {
4719 break
4720 }
4721 c := auxIntToInt64(v_1.AuxInt)
4722 v.reset(OpARM64CMPconst)
4723 v.AuxInt = int64ToAuxInt(c >> uint64(d))
4724 v.AddArg(x)
4725 return true
4726 }
4727 return false
4728 }
4729 func rewriteValueARM64_OpARM64CMPshiftRL(v *Value) bool {
4730 v_1 := v.Args[1]
4731 v_0 := v.Args[0]
4732 b := v.Block
4733
4734
4735 for {
4736 d := auxIntToInt64(v.AuxInt)
4737 if v_0.Op != OpARM64MOVDconst {
4738 break
4739 }
4740 c := auxIntToInt64(v_0.AuxInt)
4741 x := v_1
4742 v.reset(OpARM64InvertFlags)
4743 v0 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
4744 v0.AuxInt = int64ToAuxInt(c)
4745 v1 := b.NewValue0(v.Pos, OpARM64SRLconst, x.Type)
4746 v1.AuxInt = int64ToAuxInt(d)
4747 v1.AddArg(x)
4748 v0.AddArg(v1)
4749 v.AddArg(v0)
4750 return true
4751 }
4752
4753
4754 for {
4755 d := auxIntToInt64(v.AuxInt)
4756 x := v_0
4757 if v_1.Op != OpARM64MOVDconst {
4758 break
4759 }
4760 c := auxIntToInt64(v_1.AuxInt)
4761 v.reset(OpARM64CMPconst)
4762 v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
4763 v.AddArg(x)
4764 return true
4765 }
4766 return false
4767 }
4768 func rewriteValueARM64_OpARM64CSEL(v *Value) bool {
4769 v_2 := v.Args[2]
4770 v_1 := v.Args[1]
4771 v_0 := v.Args[0]
4772
4773
4774 for {
4775 cc := auxIntToOp(v.AuxInt)
4776 if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != -1 || v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
4777 break
4778 }
4779 flag := v_2
4780 v.reset(OpARM64CSETM)
4781 v.AuxInt = opToAuxInt(cc)
4782 v.AddArg(flag)
4783 return true
4784 }
4785
4786
4787 for {
4788 cc := auxIntToOp(v.AuxInt)
4789 if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 || v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != -1 {
4790 break
4791 }
4792 flag := v_2
4793 v.reset(OpARM64CSETM)
4794 v.AuxInt = opToAuxInt(arm64Negate(cc))
4795 v.AddArg(flag)
4796 return true
4797 }
4798
4799
4800 for {
4801 cc := auxIntToOp(v.AuxInt)
4802 x := v_0
4803 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
4804 break
4805 }
4806 flag := v_2
4807 v.reset(OpARM64CSEL0)
4808 v.AuxInt = opToAuxInt(cc)
4809 v.AddArg2(x, flag)
4810 return true
4811 }
4812
4813
4814 for {
4815 cc := auxIntToOp(v.AuxInt)
4816 if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
4817 break
4818 }
4819 y := v_1
4820 flag := v_2
4821 v.reset(OpARM64CSEL0)
4822 v.AuxInt = opToAuxInt(arm64Negate(cc))
4823 v.AddArg2(y, flag)
4824 return true
4825 }
4826
4827
4828 for {
4829 cc := auxIntToOp(v.AuxInt)
4830 x := v_0
4831 if v_1.Op != OpARM64ADDconst || auxIntToInt64(v_1.AuxInt) != 1 {
4832 break
4833 }
4834 a := v_1.Args[0]
4835 flag := v_2
4836 v.reset(OpARM64CSINC)
4837 v.AuxInt = opToAuxInt(cc)
4838 v.AddArg3(x, a, flag)
4839 return true
4840 }
4841
4842
4843 for {
4844 cc := auxIntToOp(v.AuxInt)
4845 if v_0.Op != OpARM64ADDconst || auxIntToInt64(v_0.AuxInt) != 1 {
4846 break
4847 }
4848 a := v_0.Args[0]
4849 x := v_1
4850 flag := v_2
4851 v.reset(OpARM64CSINC)
4852 v.AuxInt = opToAuxInt(arm64Negate(cc))
4853 v.AddArg3(x, a, flag)
4854 return true
4855 }
4856
4857
4858 for {
4859 cc := auxIntToOp(v.AuxInt)
4860 x := v_0
4861 if v_1.Op != OpARM64MVN {
4862 break
4863 }
4864 a := v_1.Args[0]
4865 flag := v_2
4866 v.reset(OpARM64CSINV)
4867 v.AuxInt = opToAuxInt(cc)
4868 v.AddArg3(x, a, flag)
4869 return true
4870 }
4871
4872
4873 for {
4874 cc := auxIntToOp(v.AuxInt)
4875 if v_0.Op != OpARM64MVN {
4876 break
4877 }
4878 a := v_0.Args[0]
4879 x := v_1
4880 flag := v_2
4881 v.reset(OpARM64CSINV)
4882 v.AuxInt = opToAuxInt(arm64Negate(cc))
4883 v.AddArg3(x, a, flag)
4884 return true
4885 }
4886
4887
4888 for {
4889 cc := auxIntToOp(v.AuxInt)
4890 x := v_0
4891 if v_1.Op != OpARM64NEG {
4892 break
4893 }
4894 a := v_1.Args[0]
4895 flag := v_2
4896 v.reset(OpARM64CSNEG)
4897 v.AuxInt = opToAuxInt(cc)
4898 v.AddArg3(x, a, flag)
4899 return true
4900 }
4901
4902
4903 for {
4904 cc := auxIntToOp(v.AuxInt)
4905 if v_0.Op != OpARM64NEG {
4906 break
4907 }
4908 a := v_0.Args[0]
4909 x := v_1
4910 flag := v_2
4911 v.reset(OpARM64CSNEG)
4912 v.AuxInt = opToAuxInt(arm64Negate(cc))
4913 v.AddArg3(x, a, flag)
4914 return true
4915 }
4916
4917
4918 for {
4919 cc := auxIntToOp(v.AuxInt)
4920 x := v_0
4921 y := v_1
4922 if v_2.Op != OpARM64InvertFlags {
4923 break
4924 }
4925 cmp := v_2.Args[0]
4926 v.reset(OpARM64CSEL)
4927 v.AuxInt = opToAuxInt(arm64Invert(cc))
4928 v.AddArg3(x, y, cmp)
4929 return true
4930 }
4931
4932
4933
4934 for {
4935 cc := auxIntToOp(v.AuxInt)
4936 x := v_0
4937 flag := v_2
4938 if !(ccARM64Eval(cc, flag) > 0) {
4939 break
4940 }
4941 v.copyOf(x)
4942 return true
4943 }
4944
4945
4946
4947 for {
4948 cc := auxIntToOp(v.AuxInt)
4949 y := v_1
4950 flag := v_2
4951 if !(ccARM64Eval(cc, flag) < 0) {
4952 break
4953 }
4954 v.copyOf(y)
4955 return true
4956 }
4957
4958
4959
4960 for {
4961 cc := auxIntToOp(v.AuxInt)
4962 x := v_0
4963 y := v_1
4964 if v_2.Op != OpARM64CMPWconst || auxIntToInt32(v_2.AuxInt) != 0 {
4965 break
4966 }
4967 boolval := v_2.Args[0]
4968 if !(cc == OpARM64NotEqual && flagArg(boolval) != nil) {
4969 break
4970 }
4971 v.reset(OpARM64CSEL)
4972 v.AuxInt = opToAuxInt(boolval.Op)
4973 v.AddArg3(x, y, flagArg(boolval))
4974 return true
4975 }
4976
4977
4978
4979 for {
4980 cc := auxIntToOp(v.AuxInt)
4981 x := v_0
4982 y := v_1
4983 if v_2.Op != OpARM64CMPWconst || auxIntToInt32(v_2.AuxInt) != 0 {
4984 break
4985 }
4986 boolval := v_2.Args[0]
4987 if !(cc == OpARM64Equal && flagArg(boolval) != nil) {
4988 break
4989 }
4990 v.reset(OpARM64CSEL)
4991 v.AuxInt = opToAuxInt(arm64Negate(boolval.Op))
4992 v.AddArg3(x, y, flagArg(boolval))
4993 return true
4994 }
4995 return false
4996 }
4997 func rewriteValueARM64_OpARM64CSEL0(v *Value) bool {
4998 v_1 := v.Args[1]
4999 v_0 := v.Args[0]
5000
5001
5002 for {
5003 cc := auxIntToOp(v.AuxInt)
5004 x := v_0
5005 if v_1.Op != OpARM64InvertFlags {
5006 break
5007 }
5008 cmp := v_1.Args[0]
5009 v.reset(OpARM64CSEL0)
5010 v.AuxInt = opToAuxInt(arm64Invert(cc))
5011 v.AddArg2(x, cmp)
5012 return true
5013 }
5014
5015
5016
5017 for {
5018 cc := auxIntToOp(v.AuxInt)
5019 x := v_0
5020 flag := v_1
5021 if !(ccARM64Eval(cc, flag) > 0) {
5022 break
5023 }
5024 v.copyOf(x)
5025 return true
5026 }
5027
5028
5029
5030 for {
5031 cc := auxIntToOp(v.AuxInt)
5032 flag := v_1
5033 if !(ccARM64Eval(cc, flag) < 0) {
5034 break
5035 }
5036 v.reset(OpARM64MOVDconst)
5037 v.AuxInt = int64ToAuxInt(0)
5038 return true
5039 }
5040
5041
5042
5043 for {
5044 cc := auxIntToOp(v.AuxInt)
5045 x := v_0
5046 if v_1.Op != OpARM64CMPWconst || auxIntToInt32(v_1.AuxInt) != 0 {
5047 break
5048 }
5049 boolval := v_1.Args[0]
5050 if !(cc == OpARM64NotEqual && flagArg(boolval) != nil) {
5051 break
5052 }
5053 v.reset(OpARM64CSEL0)
5054 v.AuxInt = opToAuxInt(boolval.Op)
5055 v.AddArg2(x, flagArg(boolval))
5056 return true
5057 }
5058
5059
5060
5061 for {
5062 cc := auxIntToOp(v.AuxInt)
5063 x := v_0
5064 if v_1.Op != OpARM64CMPWconst || auxIntToInt32(v_1.AuxInt) != 0 {
5065 break
5066 }
5067 boolval := v_1.Args[0]
5068 if !(cc == OpARM64Equal && flagArg(boolval) != nil) {
5069 break
5070 }
5071 v.reset(OpARM64CSEL0)
5072 v.AuxInt = opToAuxInt(arm64Negate(boolval.Op))
5073 v.AddArg2(x, flagArg(boolval))
5074 return true
5075 }
5076 return false
5077 }
5078 func rewriteValueARM64_OpARM64CSETM(v *Value) bool {
5079 v_0 := v.Args[0]
5080
5081
5082 for {
5083 cc := auxIntToOp(v.AuxInt)
5084 if v_0.Op != OpARM64InvertFlags {
5085 break
5086 }
5087 cmp := v_0.Args[0]
5088 v.reset(OpARM64CSETM)
5089 v.AuxInt = opToAuxInt(arm64Invert(cc))
5090 v.AddArg(cmp)
5091 return true
5092 }
5093
5094
5095
5096 for {
5097 cc := auxIntToOp(v.AuxInt)
5098 flag := v_0
5099 if !(ccARM64Eval(cc, flag) > 0) {
5100 break
5101 }
5102 v.reset(OpARM64MOVDconst)
5103 v.AuxInt = int64ToAuxInt(-1)
5104 return true
5105 }
5106
5107
5108
5109 for {
5110 cc := auxIntToOp(v.AuxInt)
5111 flag := v_0
5112 if !(ccARM64Eval(cc, flag) < 0) {
5113 break
5114 }
5115 v.reset(OpARM64MOVDconst)
5116 v.AuxInt = int64ToAuxInt(0)
5117 return true
5118 }
5119 return false
5120 }
5121 func rewriteValueARM64_OpARM64CSINC(v *Value) bool {
5122 v_2 := v.Args[2]
5123 v_1 := v.Args[1]
5124 v_0 := v.Args[0]
5125
5126
5127 for {
5128 cc := auxIntToOp(v.AuxInt)
5129 x := v_0
5130 y := v_1
5131 if v_2.Op != OpARM64InvertFlags {
5132 break
5133 }
5134 cmp := v_2.Args[0]
5135 v.reset(OpARM64CSINC)
5136 v.AuxInt = opToAuxInt(arm64Invert(cc))
5137 v.AddArg3(x, y, cmp)
5138 return true
5139 }
5140
5141
5142
5143 for {
5144 cc := auxIntToOp(v.AuxInt)
5145 x := v_0
5146 flag := v_2
5147 if !(ccARM64Eval(cc, flag) > 0) {
5148 break
5149 }
5150 v.copyOf(x)
5151 return true
5152 }
5153
5154
5155
5156 for {
5157 cc := auxIntToOp(v.AuxInt)
5158 y := v_1
5159 flag := v_2
5160 if !(ccARM64Eval(cc, flag) < 0) {
5161 break
5162 }
5163 v.reset(OpARM64ADDconst)
5164 v.AuxInt = int64ToAuxInt(1)
5165 v.AddArg(y)
5166 return true
5167 }
5168 return false
5169 }
5170 func rewriteValueARM64_OpARM64CSINV(v *Value) bool {
5171 v_2 := v.Args[2]
5172 v_1 := v.Args[1]
5173 v_0 := v.Args[0]
5174
5175
5176 for {
5177 cc := auxIntToOp(v.AuxInt)
5178 x := v_0
5179 y := v_1
5180 if v_2.Op != OpARM64InvertFlags {
5181 break
5182 }
5183 cmp := v_2.Args[0]
5184 v.reset(OpARM64CSINV)
5185 v.AuxInt = opToAuxInt(arm64Invert(cc))
5186 v.AddArg3(x, y, cmp)
5187 return true
5188 }
5189
5190
5191
5192 for {
5193 cc := auxIntToOp(v.AuxInt)
5194 x := v_0
5195 flag := v_2
5196 if !(ccARM64Eval(cc, flag) > 0) {
5197 break
5198 }
5199 v.copyOf(x)
5200 return true
5201 }
5202
5203
5204
5205 for {
5206 cc := auxIntToOp(v.AuxInt)
5207 y := v_1
5208 flag := v_2
5209 if !(ccARM64Eval(cc, flag) < 0) {
5210 break
5211 }
5212 v.reset(OpNot)
5213 v.AddArg(y)
5214 return true
5215 }
5216 return false
5217 }
5218 func rewriteValueARM64_OpARM64CSNEG(v *Value) bool {
5219 v_2 := v.Args[2]
5220 v_1 := v.Args[1]
5221 v_0 := v.Args[0]
5222
5223
5224 for {
5225 cc := auxIntToOp(v.AuxInt)
5226 x := v_0
5227 y := v_1
5228 if v_2.Op != OpARM64InvertFlags {
5229 break
5230 }
5231 cmp := v_2.Args[0]
5232 v.reset(OpARM64CSNEG)
5233 v.AuxInt = opToAuxInt(arm64Invert(cc))
5234 v.AddArg3(x, y, cmp)
5235 return true
5236 }
5237
5238
5239
5240 for {
5241 cc := auxIntToOp(v.AuxInt)
5242 x := v_0
5243 flag := v_2
5244 if !(ccARM64Eval(cc, flag) > 0) {
5245 break
5246 }
5247 v.copyOf(x)
5248 return true
5249 }
5250
5251
5252
5253 for {
5254 cc := auxIntToOp(v.AuxInt)
5255 y := v_1
5256 flag := v_2
5257 if !(ccARM64Eval(cc, flag) < 0) {
5258 break
5259 }
5260 v.reset(OpARM64NEG)
5261 v.AddArg(y)
5262 return true
5263 }
5264 return false
5265 }
5266 func rewriteValueARM64_OpARM64DIV(v *Value) bool {
5267 v_1 := v.Args[1]
5268 v_0 := v.Args[0]
5269
5270
5271
5272 for {
5273 if v_0.Op != OpARM64MOVDconst {
5274 break
5275 }
5276 c := auxIntToInt64(v_0.AuxInt)
5277 if v_1.Op != OpARM64MOVDconst {
5278 break
5279 }
5280 d := auxIntToInt64(v_1.AuxInt)
5281 if !(d != 0) {
5282 break
5283 }
5284 v.reset(OpARM64MOVDconst)
5285 v.AuxInt = int64ToAuxInt(c / d)
5286 return true
5287 }
5288 return false
5289 }
5290 func rewriteValueARM64_OpARM64DIVW(v *Value) bool {
5291 v_1 := v.Args[1]
5292 v_0 := v.Args[0]
5293
5294
5295
5296 for {
5297 if v_0.Op != OpARM64MOVDconst {
5298 break
5299 }
5300 c := auxIntToInt64(v_0.AuxInt)
5301 if v_1.Op != OpARM64MOVDconst {
5302 break
5303 }
5304 d := auxIntToInt64(v_1.AuxInt)
5305 if !(d != 0) {
5306 break
5307 }
5308 v.reset(OpARM64MOVDconst)
5309 v.AuxInt = int64ToAuxInt(int64(uint32(int32(c) / int32(d))))
5310 return true
5311 }
5312 return false
5313 }
5314 func rewriteValueARM64_OpARM64EON(v *Value) bool {
5315 v_1 := v.Args[1]
5316 v_0 := v.Args[0]
5317
5318
5319 for {
5320 x := v_0
5321 if v_1.Op != OpARM64MOVDconst {
5322 break
5323 }
5324 c := auxIntToInt64(v_1.AuxInt)
5325 v.reset(OpARM64XORconst)
5326 v.AuxInt = int64ToAuxInt(^c)
5327 v.AddArg(x)
5328 return true
5329 }
5330
5331
5332 for {
5333 x := v_0
5334 if x != v_1 {
5335 break
5336 }
5337 v.reset(OpARM64MOVDconst)
5338 v.AuxInt = int64ToAuxInt(-1)
5339 return true
5340 }
5341
5342
5343
5344 for {
5345 x0 := v_0
5346 x1 := v_1
5347 if x1.Op != OpARM64SLLconst {
5348 break
5349 }
5350 c := auxIntToInt64(x1.AuxInt)
5351 y := x1.Args[0]
5352 if !(clobberIfDead(x1)) {
5353 break
5354 }
5355 v.reset(OpARM64EONshiftLL)
5356 v.AuxInt = int64ToAuxInt(c)
5357 v.AddArg2(x0, y)
5358 return true
5359 }
5360
5361
5362
5363 for {
5364 x0 := v_0
5365 x1 := v_1
5366 if x1.Op != OpARM64SRLconst {
5367 break
5368 }
5369 c := auxIntToInt64(x1.AuxInt)
5370 y := x1.Args[0]
5371 if !(clobberIfDead(x1)) {
5372 break
5373 }
5374 v.reset(OpARM64EONshiftRL)
5375 v.AuxInt = int64ToAuxInt(c)
5376 v.AddArg2(x0, y)
5377 return true
5378 }
5379
5380
5381
5382 for {
5383 x0 := v_0
5384 x1 := v_1
5385 if x1.Op != OpARM64SRAconst {
5386 break
5387 }
5388 c := auxIntToInt64(x1.AuxInt)
5389 y := x1.Args[0]
5390 if !(clobberIfDead(x1)) {
5391 break
5392 }
5393 v.reset(OpARM64EONshiftRA)
5394 v.AuxInt = int64ToAuxInt(c)
5395 v.AddArg2(x0, y)
5396 return true
5397 }
5398
5399
5400
5401 for {
5402 x0 := v_0
5403 x1 := v_1
5404 if x1.Op != OpARM64RORconst {
5405 break
5406 }
5407 c := auxIntToInt64(x1.AuxInt)
5408 y := x1.Args[0]
5409 if !(clobberIfDead(x1)) {
5410 break
5411 }
5412 v.reset(OpARM64EONshiftRO)
5413 v.AuxInt = int64ToAuxInt(c)
5414 v.AddArg2(x0, y)
5415 return true
5416 }
5417 return false
5418 }
5419 func rewriteValueARM64_OpARM64EONshiftLL(v *Value) bool {
5420 v_1 := v.Args[1]
5421 v_0 := v.Args[0]
5422
5423
5424 for {
5425 d := auxIntToInt64(v.AuxInt)
5426 x := v_0
5427 if v_1.Op != OpARM64MOVDconst {
5428 break
5429 }
5430 c := auxIntToInt64(v_1.AuxInt)
5431 v.reset(OpARM64XORconst)
5432 v.AuxInt = int64ToAuxInt(^int64(uint64(c) << uint64(d)))
5433 v.AddArg(x)
5434 return true
5435 }
5436
5437
5438 for {
5439 c := auxIntToInt64(v.AuxInt)
5440 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != c {
5441 break
5442 }
5443 x := v_0.Args[0]
5444 if x != v_1 {
5445 break
5446 }
5447 v.reset(OpARM64MOVDconst)
5448 v.AuxInt = int64ToAuxInt(-1)
5449 return true
5450 }
5451 return false
5452 }
5453 func rewriteValueARM64_OpARM64EONshiftRA(v *Value) bool {
5454 v_1 := v.Args[1]
5455 v_0 := v.Args[0]
5456
5457
5458 for {
5459 d := auxIntToInt64(v.AuxInt)
5460 x := v_0
5461 if v_1.Op != OpARM64MOVDconst {
5462 break
5463 }
5464 c := auxIntToInt64(v_1.AuxInt)
5465 v.reset(OpARM64XORconst)
5466 v.AuxInt = int64ToAuxInt(^(c >> uint64(d)))
5467 v.AddArg(x)
5468 return true
5469 }
5470
5471
5472 for {
5473 c := auxIntToInt64(v.AuxInt)
5474 if v_0.Op != OpARM64SRAconst || auxIntToInt64(v_0.AuxInt) != c {
5475 break
5476 }
5477 x := v_0.Args[0]
5478 if x != v_1 {
5479 break
5480 }
5481 v.reset(OpARM64MOVDconst)
5482 v.AuxInt = int64ToAuxInt(-1)
5483 return true
5484 }
5485 return false
5486 }
5487 func rewriteValueARM64_OpARM64EONshiftRL(v *Value) bool {
5488 v_1 := v.Args[1]
5489 v_0 := v.Args[0]
5490
5491
5492 for {
5493 d := auxIntToInt64(v.AuxInt)
5494 x := v_0
5495 if v_1.Op != OpARM64MOVDconst {
5496 break
5497 }
5498 c := auxIntToInt64(v_1.AuxInt)
5499 v.reset(OpARM64XORconst)
5500 v.AuxInt = int64ToAuxInt(^int64(uint64(c) >> uint64(d)))
5501 v.AddArg(x)
5502 return true
5503 }
5504
5505
5506 for {
5507 c := auxIntToInt64(v.AuxInt)
5508 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != c {
5509 break
5510 }
5511 x := v_0.Args[0]
5512 if x != v_1 {
5513 break
5514 }
5515 v.reset(OpARM64MOVDconst)
5516 v.AuxInt = int64ToAuxInt(-1)
5517 return true
5518 }
5519 return false
5520 }
5521 func rewriteValueARM64_OpARM64EONshiftRO(v *Value) bool {
5522 v_1 := v.Args[1]
5523 v_0 := v.Args[0]
5524
5525
5526 for {
5527 d := auxIntToInt64(v.AuxInt)
5528 x := v_0
5529 if v_1.Op != OpARM64MOVDconst {
5530 break
5531 }
5532 c := auxIntToInt64(v_1.AuxInt)
5533 v.reset(OpARM64XORconst)
5534 v.AuxInt = int64ToAuxInt(^rotateRight64(c, d))
5535 v.AddArg(x)
5536 return true
5537 }
5538
5539
5540 for {
5541 c := auxIntToInt64(v.AuxInt)
5542 if v_0.Op != OpARM64RORconst || auxIntToInt64(v_0.AuxInt) != c {
5543 break
5544 }
5545 x := v_0.Args[0]
5546 if x != v_1 {
5547 break
5548 }
5549 v.reset(OpARM64MOVDconst)
5550 v.AuxInt = int64ToAuxInt(-1)
5551 return true
5552 }
5553 return false
5554 }
5555 func rewriteValueARM64_OpARM64Equal(v *Value) bool {
5556 v_0 := v.Args[0]
5557 b := v.Block
5558
5559
5560
5561 for {
5562 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
5563 break
5564 }
5565 z := v_0.Args[0]
5566 if z.Op != OpARM64AND {
5567 break
5568 }
5569 y := z.Args[1]
5570 x := z.Args[0]
5571 if !(z.Uses == 1) {
5572 break
5573 }
5574 v.reset(OpARM64Equal)
5575 v0 := b.NewValue0(v.Pos, OpARM64TST, types.TypeFlags)
5576 v0.AddArg2(x, y)
5577 v.AddArg(v0)
5578 return true
5579 }
5580
5581
5582
5583 for {
5584 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
5585 break
5586 }
5587 x := v_0.Args[0]
5588 if x.Op != OpARM64ANDconst {
5589 break
5590 }
5591 c := auxIntToInt64(x.AuxInt)
5592 y := x.Args[0]
5593 if !(x.Uses == 1) {
5594 break
5595 }
5596 v.reset(OpARM64Equal)
5597 v0 := b.NewValue0(v.Pos, OpARM64TSTWconst, types.TypeFlags)
5598 v0.AuxInt = int32ToAuxInt(int32(c))
5599 v0.AddArg(y)
5600 v.AddArg(v0)
5601 return true
5602 }
5603
5604
5605
5606 for {
5607 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
5608 break
5609 }
5610 z := v_0.Args[0]
5611 if z.Op != OpARM64AND {
5612 break
5613 }
5614 y := z.Args[1]
5615 x := z.Args[0]
5616 if !(z.Uses == 1) {
5617 break
5618 }
5619 v.reset(OpARM64Equal)
5620 v0 := b.NewValue0(v.Pos, OpARM64TSTW, types.TypeFlags)
5621 v0.AddArg2(x, y)
5622 v.AddArg(v0)
5623 return true
5624 }
5625
5626
5627
5628 for {
5629 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
5630 break
5631 }
5632 x := v_0.Args[0]
5633 if x.Op != OpARM64ANDconst {
5634 break
5635 }
5636 c := auxIntToInt64(x.AuxInt)
5637 y := x.Args[0]
5638 if !(x.Uses == 1) {
5639 break
5640 }
5641 v.reset(OpARM64Equal)
5642 v0 := b.NewValue0(v.Pos, OpARM64TSTconst, types.TypeFlags)
5643 v0.AuxInt = int64ToAuxInt(c)
5644 v0.AddArg(y)
5645 v.AddArg(v0)
5646 return true
5647 }
5648
5649
5650
5651 for {
5652 if v_0.Op != OpARM64CMP {
5653 break
5654 }
5655 _ = v_0.Args[1]
5656 x := v_0.Args[0]
5657 z := v_0.Args[1]
5658 if z.Op != OpARM64NEG {
5659 break
5660 }
5661 y := z.Args[0]
5662 if !(z.Uses == 1) {
5663 break
5664 }
5665 v.reset(OpARM64Equal)
5666 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
5667 v0.AddArg2(x, y)
5668 v.AddArg(v0)
5669 return true
5670 }
5671
5672
5673
5674 for {
5675 if v_0.Op != OpARM64CMPW {
5676 break
5677 }
5678 _ = v_0.Args[1]
5679 x := v_0.Args[0]
5680 z := v_0.Args[1]
5681 if z.Op != OpARM64NEG {
5682 break
5683 }
5684 y := z.Args[0]
5685 if !(z.Uses == 1) {
5686 break
5687 }
5688 v.reset(OpARM64Equal)
5689 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
5690 v0.AddArg2(x, y)
5691 v.AddArg(v0)
5692 return true
5693 }
5694
5695
5696
5697 for {
5698 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
5699 break
5700 }
5701 x := v_0.Args[0]
5702 if x.Op != OpARM64ADDconst {
5703 break
5704 }
5705 c := auxIntToInt64(x.AuxInt)
5706 y := x.Args[0]
5707 if !(x.Uses == 1) {
5708 break
5709 }
5710 v.reset(OpARM64Equal)
5711 v0 := b.NewValue0(v.Pos, OpARM64CMNconst, types.TypeFlags)
5712 v0.AuxInt = int64ToAuxInt(c)
5713 v0.AddArg(y)
5714 v.AddArg(v0)
5715 return true
5716 }
5717
5718
5719
5720 for {
5721 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
5722 break
5723 }
5724 x := v_0.Args[0]
5725 if x.Op != OpARM64ADDconst {
5726 break
5727 }
5728 c := auxIntToInt64(x.AuxInt)
5729 y := x.Args[0]
5730 if !(x.Uses == 1) {
5731 break
5732 }
5733 v.reset(OpARM64Equal)
5734 v0 := b.NewValue0(v.Pos, OpARM64CMNWconst, types.TypeFlags)
5735 v0.AuxInt = int32ToAuxInt(int32(c))
5736 v0.AddArg(y)
5737 v.AddArg(v0)
5738 return true
5739 }
5740
5741
5742
5743 for {
5744 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
5745 break
5746 }
5747 z := v_0.Args[0]
5748 if z.Op != OpARM64ADD {
5749 break
5750 }
5751 y := z.Args[1]
5752 x := z.Args[0]
5753 if !(z.Uses == 1) {
5754 break
5755 }
5756 v.reset(OpARM64Equal)
5757 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
5758 v0.AddArg2(x, y)
5759 v.AddArg(v0)
5760 return true
5761 }
5762
5763
5764
5765 for {
5766 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
5767 break
5768 }
5769 z := v_0.Args[0]
5770 if z.Op != OpARM64ADD {
5771 break
5772 }
5773 y := z.Args[1]
5774 x := z.Args[0]
5775 if !(z.Uses == 1) {
5776 break
5777 }
5778 v.reset(OpARM64Equal)
5779 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
5780 v0.AddArg2(x, y)
5781 v.AddArg(v0)
5782 return true
5783 }
5784
5785
5786
5787 for {
5788 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
5789 break
5790 }
5791 z := v_0.Args[0]
5792 if z.Op != OpARM64MADD {
5793 break
5794 }
5795 y := z.Args[2]
5796 a := z.Args[0]
5797 x := z.Args[1]
5798 if !(z.Uses == 1) {
5799 break
5800 }
5801 v.reset(OpARM64Equal)
5802 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
5803 v1 := b.NewValue0(v.Pos, OpARM64MUL, x.Type)
5804 v1.AddArg2(x, y)
5805 v0.AddArg2(a, v1)
5806 v.AddArg(v0)
5807 return true
5808 }
5809
5810
5811
5812 for {
5813 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
5814 break
5815 }
5816 z := v_0.Args[0]
5817 if z.Op != OpARM64MADDW {
5818 break
5819 }
5820 y := z.Args[2]
5821 a := z.Args[0]
5822 x := z.Args[1]
5823 if !(z.Uses == 1) {
5824 break
5825 }
5826 v.reset(OpARM64Equal)
5827 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
5828 v1 := b.NewValue0(v.Pos, OpARM64MULW, x.Type)
5829 v1.AddArg2(x, y)
5830 v0.AddArg2(a, v1)
5831 v.AddArg(v0)
5832 return true
5833 }
5834
5835
5836
5837 for {
5838 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
5839 break
5840 }
5841 z := v_0.Args[0]
5842 if z.Op != OpARM64MSUB {
5843 break
5844 }
5845 y := z.Args[2]
5846 a := z.Args[0]
5847 x := z.Args[1]
5848 if !(z.Uses == 1) {
5849 break
5850 }
5851 v.reset(OpARM64Equal)
5852 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
5853 v1 := b.NewValue0(v.Pos, OpARM64MUL, x.Type)
5854 v1.AddArg2(x, y)
5855 v0.AddArg2(a, v1)
5856 v.AddArg(v0)
5857 return true
5858 }
5859
5860
5861
5862 for {
5863 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
5864 break
5865 }
5866 z := v_0.Args[0]
5867 if z.Op != OpARM64MSUBW {
5868 break
5869 }
5870 y := z.Args[2]
5871 a := z.Args[0]
5872 x := z.Args[1]
5873 if !(z.Uses == 1) {
5874 break
5875 }
5876 v.reset(OpARM64Equal)
5877 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
5878 v1 := b.NewValue0(v.Pos, OpARM64MULW, x.Type)
5879 v1.AddArg2(x, y)
5880 v0.AddArg2(a, v1)
5881 v.AddArg(v0)
5882 return true
5883 }
5884
5885
5886 for {
5887 if v_0.Op != OpARM64FlagConstant {
5888 break
5889 }
5890 fc := auxIntToFlagConstant(v_0.AuxInt)
5891 v.reset(OpARM64MOVDconst)
5892 v.AuxInt = int64ToAuxInt(b2i(fc.eq()))
5893 return true
5894 }
5895
5896
5897 for {
5898 if v_0.Op != OpARM64InvertFlags {
5899 break
5900 }
5901 x := v_0.Args[0]
5902 v.reset(OpARM64Equal)
5903 v.AddArg(x)
5904 return true
5905 }
5906 return false
5907 }
5908 func rewriteValueARM64_OpARM64FADDD(v *Value) bool {
5909 v_1 := v.Args[1]
5910 v_0 := v.Args[0]
5911
5912
5913
5914 for {
5915 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
5916 a := v_0
5917 if v_1.Op != OpARM64FMULD {
5918 continue
5919 }
5920 y := v_1.Args[1]
5921 x := v_1.Args[0]
5922 if !(a.Block.Func.useFMA(v)) {
5923 continue
5924 }
5925 v.reset(OpARM64FMADDD)
5926 v.AddArg3(a, x, y)
5927 return true
5928 }
5929 break
5930 }
5931
5932
5933
5934 for {
5935 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
5936 a := v_0
5937 if v_1.Op != OpARM64FNMULD {
5938 continue
5939 }
5940 y := v_1.Args[1]
5941 x := v_1.Args[0]
5942 if !(a.Block.Func.useFMA(v)) {
5943 continue
5944 }
5945 v.reset(OpARM64FMSUBD)
5946 v.AddArg3(a, x, y)
5947 return true
5948 }
5949 break
5950 }
5951 return false
5952 }
5953 func rewriteValueARM64_OpARM64FADDS(v *Value) bool {
5954 v_1 := v.Args[1]
5955 v_0 := v.Args[0]
5956
5957
5958
5959 for {
5960 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
5961 a := v_0
5962 if v_1.Op != OpARM64FMULS {
5963 continue
5964 }
5965 y := v_1.Args[1]
5966 x := v_1.Args[0]
5967 if !(a.Block.Func.useFMA(v)) {
5968 continue
5969 }
5970 v.reset(OpARM64FMADDS)
5971 v.AddArg3(a, x, y)
5972 return true
5973 }
5974 break
5975 }
5976
5977
5978
5979 for {
5980 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
5981 a := v_0
5982 if v_1.Op != OpARM64FNMULS {
5983 continue
5984 }
5985 y := v_1.Args[1]
5986 x := v_1.Args[0]
5987 if !(a.Block.Func.useFMA(v)) {
5988 continue
5989 }
5990 v.reset(OpARM64FMSUBS)
5991 v.AddArg3(a, x, y)
5992 return true
5993 }
5994 break
5995 }
5996 return false
5997 }
5998 func rewriteValueARM64_OpARM64FCMPD(v *Value) bool {
5999 v_1 := v.Args[1]
6000 v_0 := v.Args[0]
6001 b := v.Block
6002
6003
6004 for {
6005 x := v_0
6006 if v_1.Op != OpARM64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != 0 {
6007 break
6008 }
6009 v.reset(OpARM64FCMPD0)
6010 v.AddArg(x)
6011 return true
6012 }
6013
6014
6015 for {
6016 if v_0.Op != OpARM64FMOVDconst || auxIntToFloat64(v_0.AuxInt) != 0 {
6017 break
6018 }
6019 x := v_1
6020 v.reset(OpARM64InvertFlags)
6021 v0 := b.NewValue0(v.Pos, OpARM64FCMPD0, types.TypeFlags)
6022 v0.AddArg(x)
6023 v.AddArg(v0)
6024 return true
6025 }
6026 return false
6027 }
6028 func rewriteValueARM64_OpARM64FCMPS(v *Value) bool {
6029 v_1 := v.Args[1]
6030 v_0 := v.Args[0]
6031 b := v.Block
6032
6033
6034 for {
6035 x := v_0
6036 if v_1.Op != OpARM64FMOVSconst || auxIntToFloat64(v_1.AuxInt) != 0 {
6037 break
6038 }
6039 v.reset(OpARM64FCMPS0)
6040 v.AddArg(x)
6041 return true
6042 }
6043
6044
6045 for {
6046 if v_0.Op != OpARM64FMOVSconst || auxIntToFloat64(v_0.AuxInt) != 0 {
6047 break
6048 }
6049 x := v_1
6050 v.reset(OpARM64InvertFlags)
6051 v0 := b.NewValue0(v.Pos, OpARM64FCMPS0, types.TypeFlags)
6052 v0.AddArg(x)
6053 v.AddArg(v0)
6054 return true
6055 }
6056 return false
6057 }
6058 func rewriteValueARM64_OpARM64FCSELD(v *Value) bool {
6059 v_2 := v.Args[2]
6060 v_1 := v.Args[1]
6061 v_0 := v.Args[0]
6062
6063
6064 for {
6065 cc := auxIntToOp(v.AuxInt)
6066 x := v_0
6067 y := v_1
6068 if v_2.Op != OpARM64InvertFlags {
6069 break
6070 }
6071 cmp := v_2.Args[0]
6072 v.reset(OpARM64FCSELD)
6073 v.AuxInt = opToAuxInt(arm64Invert(cc))
6074 v.AddArg3(x, y, cmp)
6075 return true
6076 }
6077 return false
6078 }
6079 func rewriteValueARM64_OpARM64FCSELS(v *Value) bool {
6080 v_2 := v.Args[2]
6081 v_1 := v.Args[1]
6082 v_0 := v.Args[0]
6083
6084
6085 for {
6086 cc := auxIntToOp(v.AuxInt)
6087 x := v_0
6088 y := v_1
6089 if v_2.Op != OpARM64InvertFlags {
6090 break
6091 }
6092 cmp := v_2.Args[0]
6093 v.reset(OpARM64FCSELS)
6094 v.AuxInt = opToAuxInt(arm64Invert(cc))
6095 v.AddArg3(x, y, cmp)
6096 return true
6097 }
6098 return false
6099 }
6100 func rewriteValueARM64_OpARM64FCVTDS(v *Value) bool {
6101 v_0 := v.Args[0]
6102
6103
6104 for {
6105 if v_0.Op != OpARM64FABSD {
6106 break
6107 }
6108 v_0_0 := v_0.Args[0]
6109 if v_0_0.Op != OpARM64FCVTSD {
6110 break
6111 }
6112 x := v_0_0.Args[0]
6113 v.reset(OpARM64FABSS)
6114 v.AddArg(x)
6115 return true
6116 }
6117
6118
6119 for {
6120 if v_0.Op != OpARM64FSQRTD {
6121 break
6122 }
6123 v_0_0 := v_0.Args[0]
6124 if v_0_0.Op != OpARM64FCVTSD {
6125 break
6126 }
6127 x := v_0_0.Args[0]
6128 v.reset(OpARM64FSQRTS)
6129 v.AddArg(x)
6130 return true
6131 }
6132
6133
6134 for {
6135 if v_0.Op != OpARM64FRINTPD {
6136 break
6137 }
6138 v_0_0 := v_0.Args[0]
6139 if v_0_0.Op != OpARM64FCVTSD {
6140 break
6141 }
6142 x := v_0_0.Args[0]
6143 v.reset(OpARM64FRINTPS)
6144 v.AddArg(x)
6145 return true
6146 }
6147
6148
6149 for {
6150 if v_0.Op != OpARM64FRINTMD {
6151 break
6152 }
6153 v_0_0 := v_0.Args[0]
6154 if v_0_0.Op != OpARM64FCVTSD {
6155 break
6156 }
6157 x := v_0_0.Args[0]
6158 v.reset(OpARM64FRINTMS)
6159 v.AddArg(x)
6160 return true
6161 }
6162
6163
6164 for {
6165 if v_0.Op != OpARM64FRINTAD {
6166 break
6167 }
6168 v_0_0 := v_0.Args[0]
6169 if v_0_0.Op != OpARM64FCVTSD {
6170 break
6171 }
6172 x := v_0_0.Args[0]
6173 v.reset(OpARM64FRINTAS)
6174 v.AddArg(x)
6175 return true
6176 }
6177
6178
6179 for {
6180 if v_0.Op != OpARM64FRINTND {
6181 break
6182 }
6183 v_0_0 := v_0.Args[0]
6184 if v_0_0.Op != OpARM64FCVTSD {
6185 break
6186 }
6187 x := v_0_0.Args[0]
6188 v.reset(OpARM64FRINTNS)
6189 v.AddArg(x)
6190 return true
6191 }
6192
6193
6194 for {
6195 if v_0.Op != OpARM64FRINTZD {
6196 break
6197 }
6198 v_0_0 := v_0.Args[0]
6199 if v_0_0.Op != OpARM64FCVTSD {
6200 break
6201 }
6202 x := v_0_0.Args[0]
6203 v.reset(OpARM64FRINTZS)
6204 v.AddArg(x)
6205 return true
6206 }
6207 return false
6208 }
6209 func rewriteValueARM64_OpARM64FLDPQ(v *Value) bool {
6210 v_1 := v.Args[1]
6211 v_0 := v.Args[0]
6212 b := v.Block
6213 config := b.Func.Config
6214
6215
6216
6217 for {
6218 off1 := auxIntToInt32(v.AuxInt)
6219 sym := auxToSym(v.Aux)
6220 if v_0.Op != OpARM64ADDconst {
6221 break
6222 }
6223 off2 := auxIntToInt64(v_0.AuxInt)
6224 ptr := v_0.Args[0]
6225 mem := v_1
6226 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6227 break
6228 }
6229 v.reset(OpARM64FLDPQ)
6230 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6231 v.Aux = symToAux(sym)
6232 v.AddArg2(ptr, mem)
6233 return true
6234 }
6235
6236
6237
6238 for {
6239 off1 := auxIntToInt32(v.AuxInt)
6240 sym1 := auxToSym(v.Aux)
6241 if v_0.Op != OpARM64MOVDaddr {
6242 break
6243 }
6244 off2 := auxIntToInt32(v_0.AuxInt)
6245 sym2 := auxToSym(v_0.Aux)
6246 ptr := v_0.Args[0]
6247 mem := v_1
6248 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6249 break
6250 }
6251 v.reset(OpARM64FLDPQ)
6252 v.AuxInt = int32ToAuxInt(off1 + off2)
6253 v.Aux = symToAux(mergeSym(sym1, sym2))
6254 v.AddArg2(ptr, mem)
6255 return true
6256 }
6257 return false
6258 }
6259 func rewriteValueARM64_OpARM64FMOVDfpgp(v *Value) bool {
6260 v_0 := v.Args[0]
6261 b := v.Block
6262
6263
6264 for {
6265 t := v.Type
6266 if v_0.Op != OpArg {
6267 break
6268 }
6269 off := auxIntToInt32(v_0.AuxInt)
6270 sym := auxToSym(v_0.Aux)
6271 b = b.Func.Entry
6272 v0 := b.NewValue0(v.Pos, OpArg, t)
6273 v.copyOf(v0)
6274 v0.AuxInt = int32ToAuxInt(off)
6275 v0.Aux = symToAux(sym)
6276 return true
6277 }
6278 return false
6279 }
6280 func rewriteValueARM64_OpARM64FMOVDgpfp(v *Value) bool {
6281 v_0 := v.Args[0]
6282 b := v.Block
6283
6284
6285 for {
6286 t := v.Type
6287 if v_0.Op != OpArg {
6288 break
6289 }
6290 off := auxIntToInt32(v_0.AuxInt)
6291 sym := auxToSym(v_0.Aux)
6292 b = b.Func.Entry
6293 v0 := b.NewValue0(v.Pos, OpArg, t)
6294 v.copyOf(v0)
6295 v0.AuxInt = int32ToAuxInt(off)
6296 v0.Aux = symToAux(sym)
6297 return true
6298 }
6299 return false
6300 }
6301 func rewriteValueARM64_OpARM64FMOVDload(v *Value) bool {
6302 v_1 := v.Args[1]
6303 v_0 := v.Args[0]
6304 b := v.Block
6305 config := b.Func.Config
6306
6307
6308 for {
6309 off := auxIntToInt32(v.AuxInt)
6310 sym := auxToSym(v.Aux)
6311 ptr := v_0
6312 if v_1.Op != OpARM64MOVDstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
6313 break
6314 }
6315 val := v_1.Args[1]
6316 if ptr != v_1.Args[0] {
6317 break
6318 }
6319 v.reset(OpARM64FMOVDgpfp)
6320 v.AddArg(val)
6321 return true
6322 }
6323
6324
6325
6326 for {
6327 off1 := auxIntToInt32(v.AuxInt)
6328 sym := auxToSym(v.Aux)
6329 if v_0.Op != OpARM64ADDconst {
6330 break
6331 }
6332 off2 := auxIntToInt64(v_0.AuxInt)
6333 ptr := v_0.Args[0]
6334 mem := v_1
6335 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6336 break
6337 }
6338 v.reset(OpARM64FMOVDload)
6339 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6340 v.Aux = symToAux(sym)
6341 v.AddArg2(ptr, mem)
6342 return true
6343 }
6344
6345
6346
6347 for {
6348 off := auxIntToInt32(v.AuxInt)
6349 sym := auxToSym(v.Aux)
6350 if v_0.Op != OpARM64ADD {
6351 break
6352 }
6353 idx := v_0.Args[1]
6354 ptr := v_0.Args[0]
6355 mem := v_1
6356 if !(off == 0 && sym == nil) {
6357 break
6358 }
6359 v.reset(OpARM64FMOVDloadidx)
6360 v.AddArg3(ptr, idx, mem)
6361 return true
6362 }
6363
6364
6365
6366 for {
6367 off := auxIntToInt32(v.AuxInt)
6368 sym := auxToSym(v.Aux)
6369 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 3 {
6370 break
6371 }
6372 idx := v_0.Args[1]
6373 ptr := v_0.Args[0]
6374 mem := v_1
6375 if !(off == 0 && sym == nil) {
6376 break
6377 }
6378 v.reset(OpARM64FMOVDloadidx8)
6379 v.AddArg3(ptr, idx, mem)
6380 return true
6381 }
6382
6383
6384
6385 for {
6386 off1 := auxIntToInt32(v.AuxInt)
6387 sym1 := auxToSym(v.Aux)
6388 if v_0.Op != OpARM64MOVDaddr {
6389 break
6390 }
6391 off2 := auxIntToInt32(v_0.AuxInt)
6392 sym2 := auxToSym(v_0.Aux)
6393 ptr := v_0.Args[0]
6394 mem := v_1
6395 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6396 break
6397 }
6398 v.reset(OpARM64FMOVDload)
6399 v.AuxInt = int32ToAuxInt(off1 + off2)
6400 v.Aux = symToAux(mergeSym(sym1, sym2))
6401 v.AddArg2(ptr, mem)
6402 return true
6403 }
6404 return false
6405 }
6406 func rewriteValueARM64_OpARM64FMOVDloadidx(v *Value) bool {
6407 v_2 := v.Args[2]
6408 v_1 := v.Args[1]
6409 v_0 := v.Args[0]
6410
6411
6412
6413 for {
6414 ptr := v_0
6415 if v_1.Op != OpARM64MOVDconst {
6416 break
6417 }
6418 c := auxIntToInt64(v_1.AuxInt)
6419 mem := v_2
6420 if !(is32Bit(c)) {
6421 break
6422 }
6423 v.reset(OpARM64FMOVDload)
6424 v.AuxInt = int32ToAuxInt(int32(c))
6425 v.AddArg2(ptr, mem)
6426 return true
6427 }
6428
6429
6430
6431 for {
6432 if v_0.Op != OpARM64MOVDconst {
6433 break
6434 }
6435 c := auxIntToInt64(v_0.AuxInt)
6436 ptr := v_1
6437 mem := v_2
6438 if !(is32Bit(c)) {
6439 break
6440 }
6441 v.reset(OpARM64FMOVDload)
6442 v.AuxInt = int32ToAuxInt(int32(c))
6443 v.AddArg2(ptr, mem)
6444 return true
6445 }
6446
6447
6448 for {
6449 ptr := v_0
6450 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 3 {
6451 break
6452 }
6453 idx := v_1.Args[0]
6454 mem := v_2
6455 v.reset(OpARM64FMOVDloadidx8)
6456 v.AddArg3(ptr, idx, mem)
6457 return true
6458 }
6459
6460
6461 for {
6462 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 3 {
6463 break
6464 }
6465 idx := v_0.Args[0]
6466 ptr := v_1
6467 mem := v_2
6468 v.reset(OpARM64FMOVDloadidx8)
6469 v.AddArg3(ptr, idx, mem)
6470 return true
6471 }
6472 return false
6473 }
6474 func rewriteValueARM64_OpARM64FMOVDloadidx8(v *Value) bool {
6475 v_2 := v.Args[2]
6476 v_1 := v.Args[1]
6477 v_0 := v.Args[0]
6478
6479
6480
6481 for {
6482 ptr := v_0
6483 if v_1.Op != OpARM64MOVDconst {
6484 break
6485 }
6486 c := auxIntToInt64(v_1.AuxInt)
6487 mem := v_2
6488 if !(is32Bit(c << 3)) {
6489 break
6490 }
6491 v.reset(OpARM64FMOVDload)
6492 v.AuxInt = int32ToAuxInt(int32(c) << 3)
6493 v.AddArg2(ptr, mem)
6494 return true
6495 }
6496 return false
6497 }
6498 func rewriteValueARM64_OpARM64FMOVDstore(v *Value) bool {
6499 v_2 := v.Args[2]
6500 v_1 := v.Args[1]
6501 v_0 := v.Args[0]
6502 b := v.Block
6503 config := b.Func.Config
6504
6505
6506 for {
6507 off := auxIntToInt32(v.AuxInt)
6508 sym := auxToSym(v.Aux)
6509 ptr := v_0
6510 if v_1.Op != OpARM64FMOVDgpfp {
6511 break
6512 }
6513 val := v_1.Args[0]
6514 mem := v_2
6515 v.reset(OpARM64MOVDstore)
6516 v.AuxInt = int32ToAuxInt(off)
6517 v.Aux = symToAux(sym)
6518 v.AddArg3(ptr, val, mem)
6519 return true
6520 }
6521
6522
6523
6524 for {
6525 off1 := auxIntToInt32(v.AuxInt)
6526 sym := auxToSym(v.Aux)
6527 if v_0.Op != OpARM64ADDconst {
6528 break
6529 }
6530 off2 := auxIntToInt64(v_0.AuxInt)
6531 ptr := v_0.Args[0]
6532 val := v_1
6533 mem := v_2
6534 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6535 break
6536 }
6537 v.reset(OpARM64FMOVDstore)
6538 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6539 v.Aux = symToAux(sym)
6540 v.AddArg3(ptr, val, mem)
6541 return true
6542 }
6543
6544
6545
6546 for {
6547 off := auxIntToInt32(v.AuxInt)
6548 sym := auxToSym(v.Aux)
6549 if v_0.Op != OpARM64ADD {
6550 break
6551 }
6552 idx := v_0.Args[1]
6553 ptr := v_0.Args[0]
6554 val := v_1
6555 mem := v_2
6556 if !(off == 0 && sym == nil) {
6557 break
6558 }
6559 v.reset(OpARM64FMOVDstoreidx)
6560 v.AddArg4(ptr, idx, val, mem)
6561 return true
6562 }
6563
6564
6565
6566 for {
6567 off := auxIntToInt32(v.AuxInt)
6568 sym := auxToSym(v.Aux)
6569 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 3 {
6570 break
6571 }
6572 idx := v_0.Args[1]
6573 ptr := v_0.Args[0]
6574 val := v_1
6575 mem := v_2
6576 if !(off == 0 && sym == nil) {
6577 break
6578 }
6579 v.reset(OpARM64FMOVDstoreidx8)
6580 v.AddArg4(ptr, idx, val, mem)
6581 return true
6582 }
6583
6584
6585
6586 for {
6587 off1 := auxIntToInt32(v.AuxInt)
6588 sym1 := auxToSym(v.Aux)
6589 if v_0.Op != OpARM64MOVDaddr {
6590 break
6591 }
6592 off2 := auxIntToInt32(v_0.AuxInt)
6593 sym2 := auxToSym(v_0.Aux)
6594 ptr := v_0.Args[0]
6595 val := v_1
6596 mem := v_2
6597 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6598 break
6599 }
6600 v.reset(OpARM64FMOVDstore)
6601 v.AuxInt = int32ToAuxInt(off1 + off2)
6602 v.Aux = symToAux(mergeSym(sym1, sym2))
6603 v.AddArg3(ptr, val, mem)
6604 return true
6605 }
6606 return false
6607 }
6608 func rewriteValueARM64_OpARM64FMOVDstoreidx(v *Value) bool {
6609 v_3 := v.Args[3]
6610 v_2 := v.Args[2]
6611 v_1 := v.Args[1]
6612 v_0 := v.Args[0]
6613
6614
6615
6616 for {
6617 ptr := v_0
6618 if v_1.Op != OpARM64MOVDconst {
6619 break
6620 }
6621 c := auxIntToInt64(v_1.AuxInt)
6622 val := v_2
6623 mem := v_3
6624 if !(is32Bit(c)) {
6625 break
6626 }
6627 v.reset(OpARM64FMOVDstore)
6628 v.AuxInt = int32ToAuxInt(int32(c))
6629 v.AddArg3(ptr, val, mem)
6630 return true
6631 }
6632
6633
6634
6635 for {
6636 if v_0.Op != OpARM64MOVDconst {
6637 break
6638 }
6639 c := auxIntToInt64(v_0.AuxInt)
6640 idx := v_1
6641 val := v_2
6642 mem := v_3
6643 if !(is32Bit(c)) {
6644 break
6645 }
6646 v.reset(OpARM64FMOVDstore)
6647 v.AuxInt = int32ToAuxInt(int32(c))
6648 v.AddArg3(idx, val, mem)
6649 return true
6650 }
6651
6652
6653 for {
6654 ptr := v_0
6655 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 3 {
6656 break
6657 }
6658 idx := v_1.Args[0]
6659 val := v_2
6660 mem := v_3
6661 v.reset(OpARM64FMOVDstoreidx8)
6662 v.AddArg4(ptr, idx, val, mem)
6663 return true
6664 }
6665
6666
6667 for {
6668 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 3 {
6669 break
6670 }
6671 idx := v_0.Args[0]
6672 ptr := v_1
6673 val := v_2
6674 mem := v_3
6675 v.reset(OpARM64FMOVDstoreidx8)
6676 v.AddArg4(ptr, idx, val, mem)
6677 return true
6678 }
6679 return false
6680 }
6681 func rewriteValueARM64_OpARM64FMOVDstoreidx8(v *Value) bool {
6682 v_3 := v.Args[3]
6683 v_2 := v.Args[2]
6684 v_1 := v.Args[1]
6685 v_0 := v.Args[0]
6686
6687
6688
6689 for {
6690 ptr := v_0
6691 if v_1.Op != OpARM64MOVDconst {
6692 break
6693 }
6694 c := auxIntToInt64(v_1.AuxInt)
6695 val := v_2
6696 mem := v_3
6697 if !(is32Bit(c << 3)) {
6698 break
6699 }
6700 v.reset(OpARM64FMOVDstore)
6701 v.AuxInt = int32ToAuxInt(int32(c) << 3)
6702 v.AddArg3(ptr, val, mem)
6703 return true
6704 }
6705 return false
6706 }
6707 func rewriteValueARM64_OpARM64FMOVQload(v *Value) bool {
6708 v_1 := v.Args[1]
6709 v_0 := v.Args[0]
6710 b := v.Block
6711 config := b.Func.Config
6712
6713
6714
6715 for {
6716 off1 := auxIntToInt32(v.AuxInt)
6717 sym := auxToSym(v.Aux)
6718 if v_0.Op != OpARM64ADDconst {
6719 break
6720 }
6721 off2 := auxIntToInt64(v_0.AuxInt)
6722 ptr := v_0.Args[0]
6723 mem := v_1
6724 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6725 break
6726 }
6727 v.reset(OpARM64FMOVQload)
6728 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6729 v.Aux = symToAux(sym)
6730 v.AddArg2(ptr, mem)
6731 return true
6732 }
6733
6734
6735
6736 for {
6737 off1 := auxIntToInt32(v.AuxInt)
6738 sym1 := auxToSym(v.Aux)
6739 if v_0.Op != OpARM64MOVDaddr {
6740 break
6741 }
6742 off2 := auxIntToInt32(v_0.AuxInt)
6743 sym2 := auxToSym(v_0.Aux)
6744 ptr := v_0.Args[0]
6745 mem := v_1
6746 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6747 break
6748 }
6749 v.reset(OpARM64FMOVQload)
6750 v.AuxInt = int32ToAuxInt(off1 + off2)
6751 v.Aux = symToAux(mergeSym(sym1, sym2))
6752 v.AddArg2(ptr, mem)
6753 return true
6754 }
6755 return false
6756 }
6757 func rewriteValueARM64_OpARM64FMOVQstore(v *Value) bool {
6758 v_2 := v.Args[2]
6759 v_1 := v.Args[1]
6760 v_0 := v.Args[0]
6761 b := v.Block
6762 config := b.Func.Config
6763
6764
6765
6766 for {
6767 off1 := auxIntToInt32(v.AuxInt)
6768 sym := auxToSym(v.Aux)
6769 if v_0.Op != OpARM64ADDconst {
6770 break
6771 }
6772 off2 := auxIntToInt64(v_0.AuxInt)
6773 ptr := v_0.Args[0]
6774 val := v_1
6775 mem := v_2
6776 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6777 break
6778 }
6779 v.reset(OpARM64FMOVQstore)
6780 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6781 v.Aux = symToAux(sym)
6782 v.AddArg3(ptr, val, mem)
6783 return true
6784 }
6785
6786
6787
6788 for {
6789 off1 := auxIntToInt32(v.AuxInt)
6790 sym1 := auxToSym(v.Aux)
6791 if v_0.Op != OpARM64MOVDaddr {
6792 break
6793 }
6794 off2 := auxIntToInt32(v_0.AuxInt)
6795 sym2 := auxToSym(v_0.Aux)
6796 ptr := v_0.Args[0]
6797 val := v_1
6798 mem := v_2
6799 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6800 break
6801 }
6802 v.reset(OpARM64FMOVQstore)
6803 v.AuxInt = int32ToAuxInt(off1 + off2)
6804 v.Aux = symToAux(mergeSym(sym1, sym2))
6805 v.AddArg3(ptr, val, mem)
6806 return true
6807 }
6808 return false
6809 }
6810 func rewriteValueARM64_OpARM64FMOVSload(v *Value) bool {
6811 v_1 := v.Args[1]
6812 v_0 := v.Args[0]
6813 b := v.Block
6814 config := b.Func.Config
6815
6816
6817 for {
6818 off := auxIntToInt32(v.AuxInt)
6819 sym := auxToSym(v.Aux)
6820 ptr := v_0
6821 if v_1.Op != OpARM64MOVWstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
6822 break
6823 }
6824 val := v_1.Args[1]
6825 if ptr != v_1.Args[0] {
6826 break
6827 }
6828 v.reset(OpARM64FMOVSgpfp)
6829 v.AddArg(val)
6830 return true
6831 }
6832
6833
6834
6835 for {
6836 off1 := auxIntToInt32(v.AuxInt)
6837 sym := auxToSym(v.Aux)
6838 if v_0.Op != OpARM64ADDconst {
6839 break
6840 }
6841 off2 := auxIntToInt64(v_0.AuxInt)
6842 ptr := v_0.Args[0]
6843 mem := v_1
6844 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6845 break
6846 }
6847 v.reset(OpARM64FMOVSload)
6848 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6849 v.Aux = symToAux(sym)
6850 v.AddArg2(ptr, mem)
6851 return true
6852 }
6853
6854
6855
6856 for {
6857 off := auxIntToInt32(v.AuxInt)
6858 sym := auxToSym(v.Aux)
6859 if v_0.Op != OpARM64ADD {
6860 break
6861 }
6862 idx := v_0.Args[1]
6863 ptr := v_0.Args[0]
6864 mem := v_1
6865 if !(off == 0 && sym == nil) {
6866 break
6867 }
6868 v.reset(OpARM64FMOVSloadidx)
6869 v.AddArg3(ptr, idx, mem)
6870 return true
6871 }
6872
6873
6874
6875 for {
6876 off := auxIntToInt32(v.AuxInt)
6877 sym := auxToSym(v.Aux)
6878 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 2 {
6879 break
6880 }
6881 idx := v_0.Args[1]
6882 ptr := v_0.Args[0]
6883 mem := v_1
6884 if !(off == 0 && sym == nil) {
6885 break
6886 }
6887 v.reset(OpARM64FMOVSloadidx4)
6888 v.AddArg3(ptr, idx, mem)
6889 return true
6890 }
6891
6892
6893
6894 for {
6895 off1 := auxIntToInt32(v.AuxInt)
6896 sym1 := auxToSym(v.Aux)
6897 if v_0.Op != OpARM64MOVDaddr {
6898 break
6899 }
6900 off2 := auxIntToInt32(v_0.AuxInt)
6901 sym2 := auxToSym(v_0.Aux)
6902 ptr := v_0.Args[0]
6903 mem := v_1
6904 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6905 break
6906 }
6907 v.reset(OpARM64FMOVSload)
6908 v.AuxInt = int32ToAuxInt(off1 + off2)
6909 v.Aux = symToAux(mergeSym(sym1, sym2))
6910 v.AddArg2(ptr, mem)
6911 return true
6912 }
6913 return false
6914 }
6915 func rewriteValueARM64_OpARM64FMOVSloadidx(v *Value) bool {
6916 v_2 := v.Args[2]
6917 v_1 := v.Args[1]
6918 v_0 := v.Args[0]
6919
6920
6921
6922 for {
6923 ptr := v_0
6924 if v_1.Op != OpARM64MOVDconst {
6925 break
6926 }
6927 c := auxIntToInt64(v_1.AuxInt)
6928 mem := v_2
6929 if !(is32Bit(c)) {
6930 break
6931 }
6932 v.reset(OpARM64FMOVSload)
6933 v.AuxInt = int32ToAuxInt(int32(c))
6934 v.AddArg2(ptr, mem)
6935 return true
6936 }
6937
6938
6939
6940 for {
6941 if v_0.Op != OpARM64MOVDconst {
6942 break
6943 }
6944 c := auxIntToInt64(v_0.AuxInt)
6945 ptr := v_1
6946 mem := v_2
6947 if !(is32Bit(c)) {
6948 break
6949 }
6950 v.reset(OpARM64FMOVSload)
6951 v.AuxInt = int32ToAuxInt(int32(c))
6952 v.AddArg2(ptr, mem)
6953 return true
6954 }
6955
6956
6957 for {
6958 ptr := v_0
6959 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 2 {
6960 break
6961 }
6962 idx := v_1.Args[0]
6963 mem := v_2
6964 v.reset(OpARM64FMOVSloadidx4)
6965 v.AddArg3(ptr, idx, mem)
6966 return true
6967 }
6968
6969
6970 for {
6971 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 2 {
6972 break
6973 }
6974 idx := v_0.Args[0]
6975 ptr := v_1
6976 mem := v_2
6977 v.reset(OpARM64FMOVSloadidx4)
6978 v.AddArg3(ptr, idx, mem)
6979 return true
6980 }
6981 return false
6982 }
6983 func rewriteValueARM64_OpARM64FMOVSloadidx4(v *Value) bool {
6984 v_2 := v.Args[2]
6985 v_1 := v.Args[1]
6986 v_0 := v.Args[0]
6987
6988
6989
6990 for {
6991 ptr := v_0
6992 if v_1.Op != OpARM64MOVDconst {
6993 break
6994 }
6995 c := auxIntToInt64(v_1.AuxInt)
6996 mem := v_2
6997 if !(is32Bit(c << 2)) {
6998 break
6999 }
7000 v.reset(OpARM64FMOVSload)
7001 v.AuxInt = int32ToAuxInt(int32(c) << 2)
7002 v.AddArg2(ptr, mem)
7003 return true
7004 }
7005 return false
7006 }
7007 func rewriteValueARM64_OpARM64FMOVSstore(v *Value) bool {
7008 v_2 := v.Args[2]
7009 v_1 := v.Args[1]
7010 v_0 := v.Args[0]
7011 b := v.Block
7012 config := b.Func.Config
7013
7014
7015 for {
7016 off := auxIntToInt32(v.AuxInt)
7017 sym := auxToSym(v.Aux)
7018 ptr := v_0
7019 if v_1.Op != OpARM64FMOVSgpfp {
7020 break
7021 }
7022 val := v_1.Args[0]
7023 mem := v_2
7024 v.reset(OpARM64MOVWstore)
7025 v.AuxInt = int32ToAuxInt(off)
7026 v.Aux = symToAux(sym)
7027 v.AddArg3(ptr, val, mem)
7028 return true
7029 }
7030
7031
7032
7033 for {
7034 off1 := auxIntToInt32(v.AuxInt)
7035 sym := auxToSym(v.Aux)
7036 if v_0.Op != OpARM64ADDconst {
7037 break
7038 }
7039 off2 := auxIntToInt64(v_0.AuxInt)
7040 ptr := v_0.Args[0]
7041 val := v_1
7042 mem := v_2
7043 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
7044 break
7045 }
7046 v.reset(OpARM64FMOVSstore)
7047 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
7048 v.Aux = symToAux(sym)
7049 v.AddArg3(ptr, val, mem)
7050 return true
7051 }
7052
7053
7054
7055 for {
7056 off := auxIntToInt32(v.AuxInt)
7057 sym := auxToSym(v.Aux)
7058 if v_0.Op != OpARM64ADD {
7059 break
7060 }
7061 idx := v_0.Args[1]
7062 ptr := v_0.Args[0]
7063 val := v_1
7064 mem := v_2
7065 if !(off == 0 && sym == nil) {
7066 break
7067 }
7068 v.reset(OpARM64FMOVSstoreidx)
7069 v.AddArg4(ptr, idx, val, mem)
7070 return true
7071 }
7072
7073
7074
7075 for {
7076 off := auxIntToInt32(v.AuxInt)
7077 sym := auxToSym(v.Aux)
7078 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 2 {
7079 break
7080 }
7081 idx := v_0.Args[1]
7082 ptr := v_0.Args[0]
7083 val := v_1
7084 mem := v_2
7085 if !(off == 0 && sym == nil) {
7086 break
7087 }
7088 v.reset(OpARM64FMOVSstoreidx4)
7089 v.AddArg4(ptr, idx, val, mem)
7090 return true
7091 }
7092
7093
7094
7095 for {
7096 off1 := auxIntToInt32(v.AuxInt)
7097 sym1 := auxToSym(v.Aux)
7098 if v_0.Op != OpARM64MOVDaddr {
7099 break
7100 }
7101 off2 := auxIntToInt32(v_0.AuxInt)
7102 sym2 := auxToSym(v_0.Aux)
7103 ptr := v_0.Args[0]
7104 val := v_1
7105 mem := v_2
7106 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
7107 break
7108 }
7109 v.reset(OpARM64FMOVSstore)
7110 v.AuxInt = int32ToAuxInt(off1 + off2)
7111 v.Aux = symToAux(mergeSym(sym1, sym2))
7112 v.AddArg3(ptr, val, mem)
7113 return true
7114 }
7115 return false
7116 }
7117 func rewriteValueARM64_OpARM64FMOVSstoreidx(v *Value) bool {
7118 v_3 := v.Args[3]
7119 v_2 := v.Args[2]
7120 v_1 := v.Args[1]
7121 v_0 := v.Args[0]
7122
7123
7124
7125 for {
7126 ptr := v_0
7127 if v_1.Op != OpARM64MOVDconst {
7128 break
7129 }
7130 c := auxIntToInt64(v_1.AuxInt)
7131 val := v_2
7132 mem := v_3
7133 if !(is32Bit(c)) {
7134 break
7135 }
7136 v.reset(OpARM64FMOVSstore)
7137 v.AuxInt = int32ToAuxInt(int32(c))
7138 v.AddArg3(ptr, val, mem)
7139 return true
7140 }
7141
7142
7143
7144 for {
7145 if v_0.Op != OpARM64MOVDconst {
7146 break
7147 }
7148 c := auxIntToInt64(v_0.AuxInt)
7149 idx := v_1
7150 val := v_2
7151 mem := v_3
7152 if !(is32Bit(c)) {
7153 break
7154 }
7155 v.reset(OpARM64FMOVSstore)
7156 v.AuxInt = int32ToAuxInt(int32(c))
7157 v.AddArg3(idx, val, mem)
7158 return true
7159 }
7160
7161
7162 for {
7163 ptr := v_0
7164 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 2 {
7165 break
7166 }
7167 idx := v_1.Args[0]
7168 val := v_2
7169 mem := v_3
7170 v.reset(OpARM64FMOVSstoreidx4)
7171 v.AddArg4(ptr, idx, val, mem)
7172 return true
7173 }
7174
7175
7176 for {
7177 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 2 {
7178 break
7179 }
7180 idx := v_0.Args[0]
7181 ptr := v_1
7182 val := v_2
7183 mem := v_3
7184 v.reset(OpARM64FMOVSstoreidx4)
7185 v.AddArg4(ptr, idx, val, mem)
7186 return true
7187 }
7188 return false
7189 }
7190 func rewriteValueARM64_OpARM64FMOVSstoreidx4(v *Value) bool {
7191 v_3 := v.Args[3]
7192 v_2 := v.Args[2]
7193 v_1 := v.Args[1]
7194 v_0 := v.Args[0]
7195
7196
7197
7198 for {
7199 ptr := v_0
7200 if v_1.Op != OpARM64MOVDconst {
7201 break
7202 }
7203 c := auxIntToInt64(v_1.AuxInt)
7204 val := v_2
7205 mem := v_3
7206 if !(is32Bit(c << 2)) {
7207 break
7208 }
7209 v.reset(OpARM64FMOVSstore)
7210 v.AuxInt = int32ToAuxInt(int32(c) << 2)
7211 v.AddArg3(ptr, val, mem)
7212 return true
7213 }
7214 return false
7215 }
7216 func rewriteValueARM64_OpARM64FMULD(v *Value) bool {
7217 v_1 := v.Args[1]
7218 v_0 := v.Args[0]
7219
7220
7221 for {
7222 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7223 if v_0.Op != OpARM64FNEGD {
7224 continue
7225 }
7226 x := v_0.Args[0]
7227 y := v_1
7228 v.reset(OpARM64FNMULD)
7229 v.AddArg2(x, y)
7230 return true
7231 }
7232 break
7233 }
7234 return false
7235 }
7236 func rewriteValueARM64_OpARM64FMULS(v *Value) bool {
7237 v_1 := v.Args[1]
7238 v_0 := v.Args[0]
7239
7240
7241 for {
7242 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7243 if v_0.Op != OpARM64FNEGS {
7244 continue
7245 }
7246 x := v_0.Args[0]
7247 y := v_1
7248 v.reset(OpARM64FNMULS)
7249 v.AddArg2(x, y)
7250 return true
7251 }
7252 break
7253 }
7254 return false
7255 }
7256 func rewriteValueARM64_OpARM64FNEGD(v *Value) bool {
7257 v_0 := v.Args[0]
7258
7259
7260 for {
7261 if v_0.Op != OpARM64FMULD {
7262 break
7263 }
7264 y := v_0.Args[1]
7265 x := v_0.Args[0]
7266 v.reset(OpARM64FNMULD)
7267 v.AddArg2(x, y)
7268 return true
7269 }
7270
7271
7272 for {
7273 if v_0.Op != OpARM64FNMULD {
7274 break
7275 }
7276 y := v_0.Args[1]
7277 x := v_0.Args[0]
7278 v.reset(OpARM64FMULD)
7279 v.AddArg2(x, y)
7280 return true
7281 }
7282 return false
7283 }
7284 func rewriteValueARM64_OpARM64FNEGS(v *Value) bool {
7285 v_0 := v.Args[0]
7286
7287
7288 for {
7289 if v_0.Op != OpARM64FMULS {
7290 break
7291 }
7292 y := v_0.Args[1]
7293 x := v_0.Args[0]
7294 v.reset(OpARM64FNMULS)
7295 v.AddArg2(x, y)
7296 return true
7297 }
7298
7299
7300 for {
7301 if v_0.Op != OpARM64FNMULS {
7302 break
7303 }
7304 y := v_0.Args[1]
7305 x := v_0.Args[0]
7306 v.reset(OpARM64FMULS)
7307 v.AddArg2(x, y)
7308 return true
7309 }
7310 return false
7311 }
7312 func rewriteValueARM64_OpARM64FNMULD(v *Value) bool {
7313 v_1 := v.Args[1]
7314 v_0 := v.Args[0]
7315
7316
7317 for {
7318 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7319 if v_0.Op != OpARM64FNEGD {
7320 continue
7321 }
7322 x := v_0.Args[0]
7323 y := v_1
7324 v.reset(OpARM64FMULD)
7325 v.AddArg2(x, y)
7326 return true
7327 }
7328 break
7329 }
7330 return false
7331 }
7332 func rewriteValueARM64_OpARM64FNMULS(v *Value) bool {
7333 v_1 := v.Args[1]
7334 v_0 := v.Args[0]
7335
7336
7337 for {
7338 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7339 if v_0.Op != OpARM64FNEGS {
7340 continue
7341 }
7342 x := v_0.Args[0]
7343 y := v_1
7344 v.reset(OpARM64FMULS)
7345 v.AddArg2(x, y)
7346 return true
7347 }
7348 break
7349 }
7350 return false
7351 }
7352 func rewriteValueARM64_OpARM64FSTPQ(v *Value) bool {
7353 v_3 := v.Args[3]
7354 v_2 := v.Args[2]
7355 v_1 := v.Args[1]
7356 v_0 := v.Args[0]
7357 b := v.Block
7358 config := b.Func.Config
7359
7360
7361
7362 for {
7363 off1 := auxIntToInt32(v.AuxInt)
7364 sym := auxToSym(v.Aux)
7365 if v_0.Op != OpARM64ADDconst {
7366 break
7367 }
7368 off2 := auxIntToInt64(v_0.AuxInt)
7369 ptr := v_0.Args[0]
7370 val1 := v_1
7371 val2 := v_2
7372 mem := v_3
7373 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
7374 break
7375 }
7376 v.reset(OpARM64FSTPQ)
7377 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
7378 v.Aux = symToAux(sym)
7379 v.AddArg4(ptr, val1, val2, mem)
7380 return true
7381 }
7382
7383
7384
7385 for {
7386 off1 := auxIntToInt32(v.AuxInt)
7387 sym1 := auxToSym(v.Aux)
7388 if v_0.Op != OpARM64MOVDaddr {
7389 break
7390 }
7391 off2 := auxIntToInt32(v_0.AuxInt)
7392 sym2 := auxToSym(v_0.Aux)
7393 ptr := v_0.Args[0]
7394 val1 := v_1
7395 val2 := v_2
7396 mem := v_3
7397 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
7398 break
7399 }
7400 v.reset(OpARM64FSTPQ)
7401 v.AuxInt = int32ToAuxInt(off1 + off2)
7402 v.Aux = symToAux(mergeSym(sym1, sym2))
7403 v.AddArg4(ptr, val1, val2, mem)
7404 return true
7405 }
7406 return false
7407 }
7408 func rewriteValueARM64_OpARM64FSUBD(v *Value) bool {
7409 v_1 := v.Args[1]
7410 v_0 := v.Args[0]
7411
7412
7413
7414 for {
7415 a := v_0
7416 if v_1.Op != OpARM64FMULD {
7417 break
7418 }
7419 y := v_1.Args[1]
7420 x := v_1.Args[0]
7421 if !(a.Block.Func.useFMA(v)) {
7422 break
7423 }
7424 v.reset(OpARM64FMSUBD)
7425 v.AddArg3(a, x, y)
7426 return true
7427 }
7428
7429
7430
7431 for {
7432 if v_0.Op != OpARM64FMULD {
7433 break
7434 }
7435 y := v_0.Args[1]
7436 x := v_0.Args[0]
7437 a := v_1
7438 if !(a.Block.Func.useFMA(v)) {
7439 break
7440 }
7441 v.reset(OpARM64FNMSUBD)
7442 v.AddArg3(a, x, y)
7443 return true
7444 }
7445
7446
7447
7448 for {
7449 a := v_0
7450 if v_1.Op != OpARM64FNMULD {
7451 break
7452 }
7453 y := v_1.Args[1]
7454 x := v_1.Args[0]
7455 if !(a.Block.Func.useFMA(v)) {
7456 break
7457 }
7458 v.reset(OpARM64FMADDD)
7459 v.AddArg3(a, x, y)
7460 return true
7461 }
7462
7463
7464
7465 for {
7466 if v_0.Op != OpARM64FNMULD {
7467 break
7468 }
7469 y := v_0.Args[1]
7470 x := v_0.Args[0]
7471 a := v_1
7472 if !(a.Block.Func.useFMA(v)) {
7473 break
7474 }
7475 v.reset(OpARM64FNMADDD)
7476 v.AddArg3(a, x, y)
7477 return true
7478 }
7479 return false
7480 }
7481 func rewriteValueARM64_OpARM64FSUBS(v *Value) bool {
7482 v_1 := v.Args[1]
7483 v_0 := v.Args[0]
7484
7485
7486
7487 for {
7488 a := v_0
7489 if v_1.Op != OpARM64FMULS {
7490 break
7491 }
7492 y := v_1.Args[1]
7493 x := v_1.Args[0]
7494 if !(a.Block.Func.useFMA(v)) {
7495 break
7496 }
7497 v.reset(OpARM64FMSUBS)
7498 v.AddArg3(a, x, y)
7499 return true
7500 }
7501
7502
7503
7504 for {
7505 if v_0.Op != OpARM64FMULS {
7506 break
7507 }
7508 y := v_0.Args[1]
7509 x := v_0.Args[0]
7510 a := v_1
7511 if !(a.Block.Func.useFMA(v)) {
7512 break
7513 }
7514 v.reset(OpARM64FNMSUBS)
7515 v.AddArg3(a, x, y)
7516 return true
7517 }
7518
7519
7520
7521 for {
7522 a := v_0
7523 if v_1.Op != OpARM64FNMULS {
7524 break
7525 }
7526 y := v_1.Args[1]
7527 x := v_1.Args[0]
7528 if !(a.Block.Func.useFMA(v)) {
7529 break
7530 }
7531 v.reset(OpARM64FMADDS)
7532 v.AddArg3(a, x, y)
7533 return true
7534 }
7535
7536
7537
7538 for {
7539 if v_0.Op != OpARM64FNMULS {
7540 break
7541 }
7542 y := v_0.Args[1]
7543 x := v_0.Args[0]
7544 a := v_1
7545 if !(a.Block.Func.useFMA(v)) {
7546 break
7547 }
7548 v.reset(OpARM64FNMADDS)
7549 v.AddArg3(a, x, y)
7550 return true
7551 }
7552 return false
7553 }
7554 func rewriteValueARM64_OpARM64GreaterEqual(v *Value) bool {
7555 v_0 := v.Args[0]
7556 b := v.Block
7557
7558
7559
7560 for {
7561 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
7562 break
7563 }
7564 z := v_0.Args[0]
7565 if z.Op != OpARM64AND {
7566 break
7567 }
7568 y := z.Args[1]
7569 x := z.Args[0]
7570 if !(z.Uses == 1) {
7571 break
7572 }
7573 v.reset(OpARM64GreaterEqual)
7574 v0 := b.NewValue0(v.Pos, OpARM64TST, types.TypeFlags)
7575 v0.AddArg2(x, y)
7576 v.AddArg(v0)
7577 return true
7578 }
7579
7580
7581
7582 for {
7583 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
7584 break
7585 }
7586 x := v_0.Args[0]
7587 if x.Op != OpARM64ANDconst {
7588 break
7589 }
7590 c := auxIntToInt64(x.AuxInt)
7591 y := x.Args[0]
7592 if !(x.Uses == 1) {
7593 break
7594 }
7595 v.reset(OpARM64GreaterEqual)
7596 v0 := b.NewValue0(v.Pos, OpARM64TSTWconst, types.TypeFlags)
7597 v0.AuxInt = int32ToAuxInt(int32(c))
7598 v0.AddArg(y)
7599 v.AddArg(v0)
7600 return true
7601 }
7602
7603
7604
7605 for {
7606 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
7607 break
7608 }
7609 z := v_0.Args[0]
7610 if z.Op != OpARM64AND {
7611 break
7612 }
7613 y := z.Args[1]
7614 x := z.Args[0]
7615 if !(z.Uses == 1) {
7616 break
7617 }
7618 v.reset(OpARM64GreaterEqual)
7619 v0 := b.NewValue0(v.Pos, OpARM64TSTW, types.TypeFlags)
7620 v0.AddArg2(x, y)
7621 v.AddArg(v0)
7622 return true
7623 }
7624
7625
7626
7627 for {
7628 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
7629 break
7630 }
7631 x := v_0.Args[0]
7632 if x.Op != OpARM64ANDconst {
7633 break
7634 }
7635 c := auxIntToInt64(x.AuxInt)
7636 y := x.Args[0]
7637 if !(x.Uses == 1) {
7638 break
7639 }
7640 v.reset(OpARM64GreaterEqual)
7641 v0 := b.NewValue0(v.Pos, OpARM64TSTconst, types.TypeFlags)
7642 v0.AuxInt = int64ToAuxInt(c)
7643 v0.AddArg(y)
7644 v.AddArg(v0)
7645 return true
7646 }
7647
7648
7649
7650 for {
7651 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
7652 break
7653 }
7654 x := v_0.Args[0]
7655 if x.Op != OpARM64ADDconst {
7656 break
7657 }
7658 c := auxIntToInt64(x.AuxInt)
7659 y := x.Args[0]
7660 if !(x.Uses == 1) {
7661 break
7662 }
7663 v.reset(OpARM64GreaterEqualNoov)
7664 v0 := b.NewValue0(v.Pos, OpARM64CMNconst, types.TypeFlags)
7665 v0.AuxInt = int64ToAuxInt(c)
7666 v0.AddArg(y)
7667 v.AddArg(v0)
7668 return true
7669 }
7670
7671
7672
7673 for {
7674 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
7675 break
7676 }
7677 x := v_0.Args[0]
7678 if x.Op != OpARM64ADDconst {
7679 break
7680 }
7681 c := auxIntToInt64(x.AuxInt)
7682 y := x.Args[0]
7683 if !(x.Uses == 1) {
7684 break
7685 }
7686 v.reset(OpARM64GreaterEqualNoov)
7687 v0 := b.NewValue0(v.Pos, OpARM64CMNWconst, types.TypeFlags)
7688 v0.AuxInt = int32ToAuxInt(int32(c))
7689 v0.AddArg(y)
7690 v.AddArg(v0)
7691 return true
7692 }
7693
7694
7695
7696 for {
7697 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
7698 break
7699 }
7700 z := v_0.Args[0]
7701 if z.Op != OpARM64ADD {
7702 break
7703 }
7704 y := z.Args[1]
7705 x := z.Args[0]
7706 if !(z.Uses == 1) {
7707 break
7708 }
7709 v.reset(OpARM64GreaterEqualNoov)
7710 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
7711 v0.AddArg2(x, y)
7712 v.AddArg(v0)
7713 return true
7714 }
7715
7716
7717
7718 for {
7719 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
7720 break
7721 }
7722 z := v_0.Args[0]
7723 if z.Op != OpARM64ADD {
7724 break
7725 }
7726 y := z.Args[1]
7727 x := z.Args[0]
7728 if !(z.Uses == 1) {
7729 break
7730 }
7731 v.reset(OpARM64GreaterEqualNoov)
7732 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
7733 v0.AddArg2(x, y)
7734 v.AddArg(v0)
7735 return true
7736 }
7737
7738
7739
7740 for {
7741 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
7742 break
7743 }
7744 z := v_0.Args[0]
7745 if z.Op != OpARM64MADD {
7746 break
7747 }
7748 y := z.Args[2]
7749 a := z.Args[0]
7750 x := z.Args[1]
7751 if !(z.Uses == 1) {
7752 break
7753 }
7754 v.reset(OpARM64GreaterEqualNoov)
7755 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
7756 v1 := b.NewValue0(v.Pos, OpARM64MUL, x.Type)
7757 v1.AddArg2(x, y)
7758 v0.AddArg2(a, v1)
7759 v.AddArg(v0)
7760 return true
7761 }
7762
7763
7764
7765 for {
7766 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
7767 break
7768 }
7769 z := v_0.Args[0]
7770 if z.Op != OpARM64MADDW {
7771 break
7772 }
7773 y := z.Args[2]
7774 a := z.Args[0]
7775 x := z.Args[1]
7776 if !(z.Uses == 1) {
7777 break
7778 }
7779 v.reset(OpARM64GreaterEqualNoov)
7780 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
7781 v1 := b.NewValue0(v.Pos, OpARM64MULW, x.Type)
7782 v1.AddArg2(x, y)
7783 v0.AddArg2(a, v1)
7784 v.AddArg(v0)
7785 return true
7786 }
7787
7788
7789 for {
7790 if v_0.Op != OpARM64FlagConstant {
7791 break
7792 }
7793 fc := auxIntToFlagConstant(v_0.AuxInt)
7794 v.reset(OpARM64MOVDconst)
7795 v.AuxInt = int64ToAuxInt(b2i(fc.ge()))
7796 return true
7797 }
7798
7799
7800 for {
7801 if v_0.Op != OpARM64InvertFlags {
7802 break
7803 }
7804 x := v_0.Args[0]
7805 v.reset(OpARM64LessEqual)
7806 v.AddArg(x)
7807 return true
7808 }
7809
7810
7811 for {
7812 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
7813 break
7814 }
7815 x := v_0.Args[0]
7816 v.reset(OpARM64XORconst)
7817 v.AuxInt = int64ToAuxInt(1)
7818 v0 := b.NewValue0(v.Pos, OpARM64SRLconst, v.Type)
7819 v0.AuxInt = int64ToAuxInt(63)
7820 v0.AddArg(x)
7821 v.AddArg(v0)
7822 return true
7823 }
7824
7825
7826 for {
7827 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
7828 break
7829 }
7830 x := v_0.Args[0]
7831 v.reset(OpARM64XORconst)
7832 v.AuxInt = int64ToAuxInt(1)
7833 v0 := b.NewValue0(v.Pos, OpARM64UBFX, v.Type)
7834 v0.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(31, 1))
7835 v0.AddArg(x)
7836 v.AddArg(v0)
7837 return true
7838 }
7839 return false
7840 }
7841 func rewriteValueARM64_OpARM64GreaterEqualF(v *Value) bool {
7842 v_0 := v.Args[0]
7843
7844
7845 for {
7846 if v_0.Op != OpARM64InvertFlags {
7847 break
7848 }
7849 x := v_0.Args[0]
7850 v.reset(OpARM64LessEqualF)
7851 v.AddArg(x)
7852 return true
7853 }
7854 return false
7855 }
7856 func rewriteValueARM64_OpARM64GreaterEqualNoov(v *Value) bool {
7857 v_0 := v.Args[0]
7858
7859
7860 for {
7861 if v_0.Op != OpARM64FlagConstant {
7862 break
7863 }
7864 fc := auxIntToFlagConstant(v_0.AuxInt)
7865 v.reset(OpARM64MOVDconst)
7866 v.AuxInt = int64ToAuxInt(b2i(fc.geNoov()))
7867 return true
7868 }
7869 return false
7870 }
7871 func rewriteValueARM64_OpARM64GreaterEqualU(v *Value) bool {
7872 v_0 := v.Args[0]
7873
7874
7875 for {
7876 if v_0.Op != OpARM64FlagConstant {
7877 break
7878 }
7879 fc := auxIntToFlagConstant(v_0.AuxInt)
7880 v.reset(OpARM64MOVDconst)
7881 v.AuxInt = int64ToAuxInt(b2i(fc.uge()))
7882 return true
7883 }
7884
7885
7886 for {
7887 if v_0.Op != OpARM64InvertFlags {
7888 break
7889 }
7890 x := v_0.Args[0]
7891 v.reset(OpARM64LessEqualU)
7892 v.AddArg(x)
7893 return true
7894 }
7895 return false
7896 }
7897 func rewriteValueARM64_OpARM64GreaterThan(v *Value) bool {
7898 v_0 := v.Args[0]
7899 b := v.Block
7900
7901
7902
7903 for {
7904 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
7905 break
7906 }
7907 z := v_0.Args[0]
7908 if z.Op != OpARM64AND {
7909 break
7910 }
7911 y := z.Args[1]
7912 x := z.Args[0]
7913 if !(z.Uses == 1) {
7914 break
7915 }
7916 v.reset(OpARM64GreaterThan)
7917 v0 := b.NewValue0(v.Pos, OpARM64TST, types.TypeFlags)
7918 v0.AddArg2(x, y)
7919 v.AddArg(v0)
7920 return true
7921 }
7922
7923
7924
7925 for {
7926 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
7927 break
7928 }
7929 x := v_0.Args[0]
7930 if x.Op != OpARM64ANDconst {
7931 break
7932 }
7933 c := auxIntToInt64(x.AuxInt)
7934 y := x.Args[0]
7935 if !(x.Uses == 1) {
7936 break
7937 }
7938 v.reset(OpARM64GreaterThan)
7939 v0 := b.NewValue0(v.Pos, OpARM64TSTWconst, types.TypeFlags)
7940 v0.AuxInt = int32ToAuxInt(int32(c))
7941 v0.AddArg(y)
7942 v.AddArg(v0)
7943 return true
7944 }
7945
7946
7947
7948 for {
7949 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
7950 break
7951 }
7952 z := v_0.Args[0]
7953 if z.Op != OpARM64AND {
7954 break
7955 }
7956 y := z.Args[1]
7957 x := z.Args[0]
7958 if !(z.Uses == 1) {
7959 break
7960 }
7961 v.reset(OpARM64GreaterThan)
7962 v0 := b.NewValue0(v.Pos, OpARM64TSTW, types.TypeFlags)
7963 v0.AddArg2(x, y)
7964 v.AddArg(v0)
7965 return true
7966 }
7967
7968
7969
7970 for {
7971 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
7972 break
7973 }
7974 x := v_0.Args[0]
7975 if x.Op != OpARM64ANDconst {
7976 break
7977 }
7978 c := auxIntToInt64(x.AuxInt)
7979 y := x.Args[0]
7980 if !(x.Uses == 1) {
7981 break
7982 }
7983 v.reset(OpARM64GreaterThan)
7984 v0 := b.NewValue0(v.Pos, OpARM64TSTconst, types.TypeFlags)
7985 v0.AuxInt = int64ToAuxInt(c)
7986 v0.AddArg(y)
7987 v.AddArg(v0)
7988 return true
7989 }
7990
7991
7992 for {
7993 if v_0.Op != OpARM64FlagConstant {
7994 break
7995 }
7996 fc := auxIntToFlagConstant(v_0.AuxInt)
7997 v.reset(OpARM64MOVDconst)
7998 v.AuxInt = int64ToAuxInt(b2i(fc.gt()))
7999 return true
8000 }
8001
8002
8003 for {
8004 if v_0.Op != OpARM64InvertFlags {
8005 break
8006 }
8007 x := v_0.Args[0]
8008 v.reset(OpARM64LessThan)
8009 v.AddArg(x)
8010 return true
8011 }
8012 return false
8013 }
8014 func rewriteValueARM64_OpARM64GreaterThanF(v *Value) bool {
8015 v_0 := v.Args[0]
8016
8017
8018 for {
8019 if v_0.Op != OpARM64InvertFlags {
8020 break
8021 }
8022 x := v_0.Args[0]
8023 v.reset(OpARM64LessThanF)
8024 v.AddArg(x)
8025 return true
8026 }
8027 return false
8028 }
8029 func rewriteValueARM64_OpARM64GreaterThanU(v *Value) bool {
8030 v_0 := v.Args[0]
8031
8032
8033 for {
8034 if v_0.Op != OpARM64FlagConstant {
8035 break
8036 }
8037 fc := auxIntToFlagConstant(v_0.AuxInt)
8038 v.reset(OpARM64MOVDconst)
8039 v.AuxInt = int64ToAuxInt(b2i(fc.ugt()))
8040 return true
8041 }
8042
8043
8044 for {
8045 if v_0.Op != OpARM64InvertFlags {
8046 break
8047 }
8048 x := v_0.Args[0]
8049 v.reset(OpARM64LessThanU)
8050 v.AddArg(x)
8051 return true
8052 }
8053 return false
8054 }
8055 func rewriteValueARM64_OpARM64LDP(v *Value) bool {
8056 v_1 := v.Args[1]
8057 v_0 := v.Args[0]
8058 b := v.Block
8059 config := b.Func.Config
8060
8061
8062
8063 for {
8064 off1 := auxIntToInt32(v.AuxInt)
8065 sym := auxToSym(v.Aux)
8066 if v_0.Op != OpARM64ADDconst {
8067 break
8068 }
8069 off2 := auxIntToInt64(v_0.AuxInt)
8070 ptr := v_0.Args[0]
8071 mem := v_1
8072 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
8073 break
8074 }
8075 v.reset(OpARM64LDP)
8076 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
8077 v.Aux = symToAux(sym)
8078 v.AddArg2(ptr, mem)
8079 return true
8080 }
8081
8082
8083
8084 for {
8085 off1 := auxIntToInt32(v.AuxInt)
8086 sym1 := auxToSym(v.Aux)
8087 if v_0.Op != OpARM64MOVDaddr {
8088 break
8089 }
8090 off2 := auxIntToInt32(v_0.AuxInt)
8091 sym2 := auxToSym(v_0.Aux)
8092 ptr := v_0.Args[0]
8093 mem := v_1
8094 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
8095 break
8096 }
8097 v.reset(OpARM64LDP)
8098 v.AuxInt = int32ToAuxInt(off1 + off2)
8099 v.Aux = symToAux(mergeSym(sym1, sym2))
8100 v.AddArg2(ptr, mem)
8101 return true
8102 }
8103 return false
8104 }
8105 func rewriteValueARM64_OpARM64LessEqual(v *Value) bool {
8106 v_0 := v.Args[0]
8107 b := v.Block
8108
8109
8110
8111 for {
8112 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
8113 break
8114 }
8115 z := v_0.Args[0]
8116 if z.Op != OpARM64AND {
8117 break
8118 }
8119 y := z.Args[1]
8120 x := z.Args[0]
8121 if !(z.Uses == 1) {
8122 break
8123 }
8124 v.reset(OpARM64LessEqual)
8125 v0 := b.NewValue0(v.Pos, OpARM64TST, types.TypeFlags)
8126 v0.AddArg2(x, y)
8127 v.AddArg(v0)
8128 return true
8129 }
8130
8131
8132
8133 for {
8134 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
8135 break
8136 }
8137 x := v_0.Args[0]
8138 if x.Op != OpARM64ANDconst {
8139 break
8140 }
8141 c := auxIntToInt64(x.AuxInt)
8142 y := x.Args[0]
8143 if !(x.Uses == 1) {
8144 break
8145 }
8146 v.reset(OpARM64LessEqual)
8147 v0 := b.NewValue0(v.Pos, OpARM64TSTWconst, types.TypeFlags)
8148 v0.AuxInt = int32ToAuxInt(int32(c))
8149 v0.AddArg(y)
8150 v.AddArg(v0)
8151 return true
8152 }
8153
8154
8155
8156 for {
8157 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
8158 break
8159 }
8160 z := v_0.Args[0]
8161 if z.Op != OpARM64AND {
8162 break
8163 }
8164 y := z.Args[1]
8165 x := z.Args[0]
8166 if !(z.Uses == 1) {
8167 break
8168 }
8169 v.reset(OpARM64LessEqual)
8170 v0 := b.NewValue0(v.Pos, OpARM64TSTW, types.TypeFlags)
8171 v0.AddArg2(x, y)
8172 v.AddArg(v0)
8173 return true
8174 }
8175
8176
8177
8178 for {
8179 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
8180 break
8181 }
8182 x := v_0.Args[0]
8183 if x.Op != OpARM64ANDconst {
8184 break
8185 }
8186 c := auxIntToInt64(x.AuxInt)
8187 y := x.Args[0]
8188 if !(x.Uses == 1) {
8189 break
8190 }
8191 v.reset(OpARM64LessEqual)
8192 v0 := b.NewValue0(v.Pos, OpARM64TSTconst, types.TypeFlags)
8193 v0.AuxInt = int64ToAuxInt(c)
8194 v0.AddArg(y)
8195 v.AddArg(v0)
8196 return true
8197 }
8198
8199
8200 for {
8201 if v_0.Op != OpARM64FlagConstant {
8202 break
8203 }
8204 fc := auxIntToFlagConstant(v_0.AuxInt)
8205 v.reset(OpARM64MOVDconst)
8206 v.AuxInt = int64ToAuxInt(b2i(fc.le()))
8207 return true
8208 }
8209
8210
8211 for {
8212 if v_0.Op != OpARM64InvertFlags {
8213 break
8214 }
8215 x := v_0.Args[0]
8216 v.reset(OpARM64GreaterEqual)
8217 v.AddArg(x)
8218 return true
8219 }
8220 return false
8221 }
8222 func rewriteValueARM64_OpARM64LessEqualF(v *Value) bool {
8223 v_0 := v.Args[0]
8224
8225
8226 for {
8227 if v_0.Op != OpARM64InvertFlags {
8228 break
8229 }
8230 x := v_0.Args[0]
8231 v.reset(OpARM64GreaterEqualF)
8232 v.AddArg(x)
8233 return true
8234 }
8235 return false
8236 }
8237 func rewriteValueARM64_OpARM64LessEqualU(v *Value) bool {
8238 v_0 := v.Args[0]
8239
8240
8241 for {
8242 if v_0.Op != OpARM64FlagConstant {
8243 break
8244 }
8245 fc := auxIntToFlagConstant(v_0.AuxInt)
8246 v.reset(OpARM64MOVDconst)
8247 v.AuxInt = int64ToAuxInt(b2i(fc.ule()))
8248 return true
8249 }
8250
8251
8252 for {
8253 if v_0.Op != OpARM64InvertFlags {
8254 break
8255 }
8256 x := v_0.Args[0]
8257 v.reset(OpARM64GreaterEqualU)
8258 v.AddArg(x)
8259 return true
8260 }
8261 return false
8262 }
8263 func rewriteValueARM64_OpARM64LessThan(v *Value) bool {
8264 v_0 := v.Args[0]
8265 b := v.Block
8266
8267
8268
8269 for {
8270 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
8271 break
8272 }
8273 z := v_0.Args[0]
8274 if z.Op != OpARM64AND {
8275 break
8276 }
8277 y := z.Args[1]
8278 x := z.Args[0]
8279 if !(z.Uses == 1) {
8280 break
8281 }
8282 v.reset(OpARM64LessThan)
8283 v0 := b.NewValue0(v.Pos, OpARM64TST, types.TypeFlags)
8284 v0.AddArg2(x, y)
8285 v.AddArg(v0)
8286 return true
8287 }
8288
8289
8290
8291 for {
8292 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
8293 break
8294 }
8295 x := v_0.Args[0]
8296 if x.Op != OpARM64ANDconst {
8297 break
8298 }
8299 c := auxIntToInt64(x.AuxInt)
8300 y := x.Args[0]
8301 if !(x.Uses == 1) {
8302 break
8303 }
8304 v.reset(OpARM64LessThan)
8305 v0 := b.NewValue0(v.Pos, OpARM64TSTWconst, types.TypeFlags)
8306 v0.AuxInt = int32ToAuxInt(int32(c))
8307 v0.AddArg(y)
8308 v.AddArg(v0)
8309 return true
8310 }
8311
8312
8313
8314 for {
8315 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
8316 break
8317 }
8318 z := v_0.Args[0]
8319 if z.Op != OpARM64AND {
8320 break
8321 }
8322 y := z.Args[1]
8323 x := z.Args[0]
8324 if !(z.Uses == 1) {
8325 break
8326 }
8327 v.reset(OpARM64LessThan)
8328 v0 := b.NewValue0(v.Pos, OpARM64TSTW, types.TypeFlags)
8329 v0.AddArg2(x, y)
8330 v.AddArg(v0)
8331 return true
8332 }
8333
8334
8335
8336 for {
8337 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
8338 break
8339 }
8340 x := v_0.Args[0]
8341 if x.Op != OpARM64ANDconst {
8342 break
8343 }
8344 c := auxIntToInt64(x.AuxInt)
8345 y := x.Args[0]
8346 if !(x.Uses == 1) {
8347 break
8348 }
8349 v.reset(OpARM64LessThan)
8350 v0 := b.NewValue0(v.Pos, OpARM64TSTconst, types.TypeFlags)
8351 v0.AuxInt = int64ToAuxInt(c)
8352 v0.AddArg(y)
8353 v.AddArg(v0)
8354 return true
8355 }
8356
8357
8358
8359 for {
8360 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
8361 break
8362 }
8363 x := v_0.Args[0]
8364 if x.Op != OpARM64ADDconst {
8365 break
8366 }
8367 c := auxIntToInt64(x.AuxInt)
8368 y := x.Args[0]
8369 if !(x.Uses == 1) {
8370 break
8371 }
8372 v.reset(OpARM64LessThanNoov)
8373 v0 := b.NewValue0(v.Pos, OpARM64CMNconst, types.TypeFlags)
8374 v0.AuxInt = int64ToAuxInt(c)
8375 v0.AddArg(y)
8376 v.AddArg(v0)
8377 return true
8378 }
8379
8380
8381
8382 for {
8383 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
8384 break
8385 }
8386 x := v_0.Args[0]
8387 if x.Op != OpARM64ADDconst {
8388 break
8389 }
8390 c := auxIntToInt64(x.AuxInt)
8391 y := x.Args[0]
8392 if !(x.Uses == 1) {
8393 break
8394 }
8395 v.reset(OpARM64LessThanNoov)
8396 v0 := b.NewValue0(v.Pos, OpARM64CMNWconst, types.TypeFlags)
8397 v0.AuxInt = int32ToAuxInt(int32(c))
8398 v0.AddArg(y)
8399 v.AddArg(v0)
8400 return true
8401 }
8402
8403
8404
8405 for {
8406 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
8407 break
8408 }
8409 z := v_0.Args[0]
8410 if z.Op != OpARM64ADD {
8411 break
8412 }
8413 y := z.Args[1]
8414 x := z.Args[0]
8415 if !(z.Uses == 1) {
8416 break
8417 }
8418 v.reset(OpARM64LessThanNoov)
8419 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
8420 v0.AddArg2(x, y)
8421 v.AddArg(v0)
8422 return true
8423 }
8424
8425
8426
8427 for {
8428 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
8429 break
8430 }
8431 z := v_0.Args[0]
8432 if z.Op != OpARM64ADD {
8433 break
8434 }
8435 y := z.Args[1]
8436 x := z.Args[0]
8437 if !(z.Uses == 1) {
8438 break
8439 }
8440 v.reset(OpARM64LessThanNoov)
8441 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
8442 v0.AddArg2(x, y)
8443 v.AddArg(v0)
8444 return true
8445 }
8446
8447
8448
8449 for {
8450 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
8451 break
8452 }
8453 z := v_0.Args[0]
8454 if z.Op != OpARM64MADD {
8455 break
8456 }
8457 y := z.Args[2]
8458 a := z.Args[0]
8459 x := z.Args[1]
8460 if !(z.Uses == 1) {
8461 break
8462 }
8463 v.reset(OpARM64LessThanNoov)
8464 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
8465 v1 := b.NewValue0(v.Pos, OpARM64MUL, x.Type)
8466 v1.AddArg2(x, y)
8467 v0.AddArg2(a, v1)
8468 v.AddArg(v0)
8469 return true
8470 }
8471
8472
8473
8474 for {
8475 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
8476 break
8477 }
8478 z := v_0.Args[0]
8479 if z.Op != OpARM64MADDW {
8480 break
8481 }
8482 y := z.Args[2]
8483 a := z.Args[0]
8484 x := z.Args[1]
8485 if !(z.Uses == 1) {
8486 break
8487 }
8488 v.reset(OpARM64LessThanNoov)
8489 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
8490 v1 := b.NewValue0(v.Pos, OpARM64MULW, x.Type)
8491 v1.AddArg2(x, y)
8492 v0.AddArg2(a, v1)
8493 v.AddArg(v0)
8494 return true
8495 }
8496
8497
8498 for {
8499 if v_0.Op != OpARM64FlagConstant {
8500 break
8501 }
8502 fc := auxIntToFlagConstant(v_0.AuxInt)
8503 v.reset(OpARM64MOVDconst)
8504 v.AuxInt = int64ToAuxInt(b2i(fc.lt()))
8505 return true
8506 }
8507
8508
8509 for {
8510 if v_0.Op != OpARM64InvertFlags {
8511 break
8512 }
8513 x := v_0.Args[0]
8514 v.reset(OpARM64GreaterThan)
8515 v.AddArg(x)
8516 return true
8517 }
8518
8519
8520 for {
8521 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
8522 break
8523 }
8524 x := v_0.Args[0]
8525 v.reset(OpARM64SRLconst)
8526 v.AuxInt = int64ToAuxInt(63)
8527 v.AddArg(x)
8528 return true
8529 }
8530
8531
8532 for {
8533 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
8534 break
8535 }
8536 x := v_0.Args[0]
8537 v.reset(OpARM64UBFX)
8538 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(31, 1))
8539 v.AddArg(x)
8540 return true
8541 }
8542 return false
8543 }
8544 func rewriteValueARM64_OpARM64LessThanF(v *Value) bool {
8545 v_0 := v.Args[0]
8546
8547
8548 for {
8549 if v_0.Op != OpARM64InvertFlags {
8550 break
8551 }
8552 x := v_0.Args[0]
8553 v.reset(OpARM64GreaterThanF)
8554 v.AddArg(x)
8555 return true
8556 }
8557 return false
8558 }
8559 func rewriteValueARM64_OpARM64LessThanNoov(v *Value) bool {
8560 v_0 := v.Args[0]
8561
8562
8563 for {
8564 if v_0.Op != OpARM64FlagConstant {
8565 break
8566 }
8567 fc := auxIntToFlagConstant(v_0.AuxInt)
8568 v.reset(OpARM64MOVDconst)
8569 v.AuxInt = int64ToAuxInt(b2i(fc.ltNoov()))
8570 return true
8571 }
8572 return false
8573 }
8574 func rewriteValueARM64_OpARM64LessThanU(v *Value) bool {
8575 v_0 := v.Args[0]
8576
8577
8578 for {
8579 if v_0.Op != OpARM64FlagConstant {
8580 break
8581 }
8582 fc := auxIntToFlagConstant(v_0.AuxInt)
8583 v.reset(OpARM64MOVDconst)
8584 v.AuxInt = int64ToAuxInt(b2i(fc.ult()))
8585 return true
8586 }
8587
8588
8589 for {
8590 if v_0.Op != OpARM64InvertFlags {
8591 break
8592 }
8593 x := v_0.Args[0]
8594 v.reset(OpARM64GreaterThanU)
8595 v.AddArg(x)
8596 return true
8597 }
8598 return false
8599 }
8600 func rewriteValueARM64_OpARM64LoweredPanicBoundsCR(v *Value) bool {
8601 v_1 := v.Args[1]
8602 v_0 := v.Args[0]
8603
8604
8605 for {
8606 kind := auxIntToInt64(v.AuxInt)
8607 p := auxToPanicBoundsC(v.Aux)
8608 if v_0.Op != OpARM64MOVDconst {
8609 break
8610 }
8611 c := auxIntToInt64(v_0.AuxInt)
8612 mem := v_1
8613 v.reset(OpARM64LoweredPanicBoundsCC)
8614 v.AuxInt = int64ToAuxInt(kind)
8615 v.Aux = panicBoundsCCToAux(PanicBoundsCC{Cx: p.C, Cy: c})
8616 v.AddArg(mem)
8617 return true
8618 }
8619 return false
8620 }
8621 func rewriteValueARM64_OpARM64LoweredPanicBoundsRC(v *Value) bool {
8622 v_1 := v.Args[1]
8623 v_0 := v.Args[0]
8624
8625
8626 for {
8627 kind := auxIntToInt64(v.AuxInt)
8628 p := auxToPanicBoundsC(v.Aux)
8629 if v_0.Op != OpARM64MOVDconst {
8630 break
8631 }
8632 c := auxIntToInt64(v_0.AuxInt)
8633 mem := v_1
8634 v.reset(OpARM64LoweredPanicBoundsCC)
8635 v.AuxInt = int64ToAuxInt(kind)
8636 v.Aux = panicBoundsCCToAux(PanicBoundsCC{Cx: c, Cy: p.C})
8637 v.AddArg(mem)
8638 return true
8639 }
8640 return false
8641 }
8642 func rewriteValueARM64_OpARM64LoweredPanicBoundsRR(v *Value) bool {
8643 v_2 := v.Args[2]
8644 v_1 := v.Args[1]
8645 v_0 := v.Args[0]
8646
8647
8648 for {
8649 kind := auxIntToInt64(v.AuxInt)
8650 x := v_0
8651 if v_1.Op != OpARM64MOVDconst {
8652 break
8653 }
8654 c := auxIntToInt64(v_1.AuxInt)
8655 mem := v_2
8656 v.reset(OpARM64LoweredPanicBoundsRC)
8657 v.AuxInt = int64ToAuxInt(kind)
8658 v.Aux = panicBoundsCToAux(PanicBoundsC{C: c})
8659 v.AddArg2(x, mem)
8660 return true
8661 }
8662
8663
8664 for {
8665 kind := auxIntToInt64(v.AuxInt)
8666 if v_0.Op != OpARM64MOVDconst {
8667 break
8668 }
8669 c := auxIntToInt64(v_0.AuxInt)
8670 y := v_1
8671 mem := v_2
8672 v.reset(OpARM64LoweredPanicBoundsCR)
8673 v.AuxInt = int64ToAuxInt(kind)
8674 v.Aux = panicBoundsCToAux(PanicBoundsC{C: c})
8675 v.AddArg2(y, mem)
8676 return true
8677 }
8678 return false
8679 }
8680 func rewriteValueARM64_OpARM64MADD(v *Value) bool {
8681 v_2 := v.Args[2]
8682 v_1 := v.Args[1]
8683 v_0 := v.Args[0]
8684 b := v.Block
8685
8686
8687 for {
8688 a := v_0
8689 x := v_1
8690 if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != -1 {
8691 break
8692 }
8693 v.reset(OpARM64SUB)
8694 v.AddArg2(a, x)
8695 return true
8696 }
8697
8698
8699 for {
8700 a := v_0
8701 if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != 0 {
8702 break
8703 }
8704 v.copyOf(a)
8705 return true
8706 }
8707
8708
8709 for {
8710 a := v_0
8711 x := v_1
8712 if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != 1 {
8713 break
8714 }
8715 v.reset(OpARM64ADD)
8716 v.AddArg2(a, x)
8717 return true
8718 }
8719
8720
8721
8722 for {
8723 a := v_0
8724 x := v_1
8725 if v_2.Op != OpARM64MOVDconst {
8726 break
8727 }
8728 c := auxIntToInt64(v_2.AuxInt)
8729 if !(isPowerOfTwo(c)) {
8730 break
8731 }
8732 v.reset(OpARM64ADDshiftLL)
8733 v.AuxInt = int64ToAuxInt(log64(c))
8734 v.AddArg2(a, x)
8735 return true
8736 }
8737
8738
8739
8740 for {
8741 a := v_0
8742 x := v_1
8743 if v_2.Op != OpARM64MOVDconst {
8744 break
8745 }
8746 c := auxIntToInt64(v_2.AuxInt)
8747 if !(isPowerOfTwo(c-1) && c >= 3) {
8748 break
8749 }
8750 v.reset(OpARM64ADD)
8751 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
8752 v0.AuxInt = int64ToAuxInt(log64(c - 1))
8753 v0.AddArg2(x, x)
8754 v.AddArg2(a, v0)
8755 return true
8756 }
8757
8758
8759
8760 for {
8761 a := v_0
8762 x := v_1
8763 if v_2.Op != OpARM64MOVDconst {
8764 break
8765 }
8766 c := auxIntToInt64(v_2.AuxInt)
8767 if !(isPowerOfTwo(c+1) && c >= 7) {
8768 break
8769 }
8770 v.reset(OpARM64SUB)
8771 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
8772 v0.AuxInt = int64ToAuxInt(log64(c + 1))
8773 v0.AddArg2(x, x)
8774 v.AddArg2(a, v0)
8775 return true
8776 }
8777
8778
8779
8780 for {
8781 a := v_0
8782 x := v_1
8783 if v_2.Op != OpARM64MOVDconst {
8784 break
8785 }
8786 c := auxIntToInt64(v_2.AuxInt)
8787 if !(c%3 == 0 && isPowerOfTwo(c/3)) {
8788 break
8789 }
8790 v.reset(OpARM64SUBshiftLL)
8791 v.AuxInt = int64ToAuxInt(log64(c / 3))
8792 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
8793 v0.AuxInt = int64ToAuxInt(2)
8794 v0.AddArg2(x, x)
8795 v.AddArg2(a, v0)
8796 return true
8797 }
8798
8799
8800
8801 for {
8802 a := v_0
8803 x := v_1
8804 if v_2.Op != OpARM64MOVDconst {
8805 break
8806 }
8807 c := auxIntToInt64(v_2.AuxInt)
8808 if !(c%5 == 0 && isPowerOfTwo(c/5)) {
8809 break
8810 }
8811 v.reset(OpARM64ADDshiftLL)
8812 v.AuxInt = int64ToAuxInt(log64(c / 5))
8813 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
8814 v0.AuxInt = int64ToAuxInt(2)
8815 v0.AddArg2(x, x)
8816 v.AddArg2(a, v0)
8817 return true
8818 }
8819
8820
8821
8822 for {
8823 a := v_0
8824 x := v_1
8825 if v_2.Op != OpARM64MOVDconst {
8826 break
8827 }
8828 c := auxIntToInt64(v_2.AuxInt)
8829 if !(c%7 == 0 && isPowerOfTwo(c/7)) {
8830 break
8831 }
8832 v.reset(OpARM64SUBshiftLL)
8833 v.AuxInt = int64ToAuxInt(log64(c / 7))
8834 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
8835 v0.AuxInt = int64ToAuxInt(3)
8836 v0.AddArg2(x, x)
8837 v.AddArg2(a, v0)
8838 return true
8839 }
8840
8841
8842
8843 for {
8844 a := v_0
8845 x := v_1
8846 if v_2.Op != OpARM64MOVDconst {
8847 break
8848 }
8849 c := auxIntToInt64(v_2.AuxInt)
8850 if !(c%9 == 0 && isPowerOfTwo(c/9)) {
8851 break
8852 }
8853 v.reset(OpARM64ADDshiftLL)
8854 v.AuxInt = int64ToAuxInt(log64(c / 9))
8855 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
8856 v0.AuxInt = int64ToAuxInt(3)
8857 v0.AddArg2(x, x)
8858 v.AddArg2(a, v0)
8859 return true
8860 }
8861
8862
8863 for {
8864 a := v_0
8865 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != -1 {
8866 break
8867 }
8868 x := v_2
8869 v.reset(OpARM64SUB)
8870 v.AddArg2(a, x)
8871 return true
8872 }
8873
8874
8875 for {
8876 a := v_0
8877 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
8878 break
8879 }
8880 v.copyOf(a)
8881 return true
8882 }
8883
8884
8885 for {
8886 a := v_0
8887 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
8888 break
8889 }
8890 x := v_2
8891 v.reset(OpARM64ADD)
8892 v.AddArg2(a, x)
8893 return true
8894 }
8895
8896
8897
8898 for {
8899 a := v_0
8900 if v_1.Op != OpARM64MOVDconst {
8901 break
8902 }
8903 c := auxIntToInt64(v_1.AuxInt)
8904 x := v_2
8905 if !(isPowerOfTwo(c)) {
8906 break
8907 }
8908 v.reset(OpARM64ADDshiftLL)
8909 v.AuxInt = int64ToAuxInt(log64(c))
8910 v.AddArg2(a, x)
8911 return true
8912 }
8913
8914
8915
8916 for {
8917 a := v_0
8918 if v_1.Op != OpARM64MOVDconst {
8919 break
8920 }
8921 c := auxIntToInt64(v_1.AuxInt)
8922 x := v_2
8923 if !(isPowerOfTwo(c-1) && c >= 3) {
8924 break
8925 }
8926 v.reset(OpARM64ADD)
8927 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
8928 v0.AuxInt = int64ToAuxInt(log64(c - 1))
8929 v0.AddArg2(x, x)
8930 v.AddArg2(a, v0)
8931 return true
8932 }
8933
8934
8935
8936 for {
8937 a := v_0
8938 if v_1.Op != OpARM64MOVDconst {
8939 break
8940 }
8941 c := auxIntToInt64(v_1.AuxInt)
8942 x := v_2
8943 if !(isPowerOfTwo(c+1) && c >= 7) {
8944 break
8945 }
8946 v.reset(OpARM64SUB)
8947 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
8948 v0.AuxInt = int64ToAuxInt(log64(c + 1))
8949 v0.AddArg2(x, x)
8950 v.AddArg2(a, v0)
8951 return true
8952 }
8953
8954
8955
8956 for {
8957 a := v_0
8958 if v_1.Op != OpARM64MOVDconst {
8959 break
8960 }
8961 c := auxIntToInt64(v_1.AuxInt)
8962 x := v_2
8963 if !(c%3 == 0 && isPowerOfTwo(c/3)) {
8964 break
8965 }
8966 v.reset(OpARM64SUBshiftLL)
8967 v.AuxInt = int64ToAuxInt(log64(c / 3))
8968 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
8969 v0.AuxInt = int64ToAuxInt(2)
8970 v0.AddArg2(x, x)
8971 v.AddArg2(a, v0)
8972 return true
8973 }
8974
8975
8976
8977 for {
8978 a := v_0
8979 if v_1.Op != OpARM64MOVDconst {
8980 break
8981 }
8982 c := auxIntToInt64(v_1.AuxInt)
8983 x := v_2
8984 if !(c%5 == 0 && isPowerOfTwo(c/5)) {
8985 break
8986 }
8987 v.reset(OpARM64ADDshiftLL)
8988 v.AuxInt = int64ToAuxInt(log64(c / 5))
8989 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
8990 v0.AuxInt = int64ToAuxInt(2)
8991 v0.AddArg2(x, x)
8992 v.AddArg2(a, v0)
8993 return true
8994 }
8995
8996
8997
8998 for {
8999 a := v_0
9000 if v_1.Op != OpARM64MOVDconst {
9001 break
9002 }
9003 c := auxIntToInt64(v_1.AuxInt)
9004 x := v_2
9005 if !(c%7 == 0 && isPowerOfTwo(c/7)) {
9006 break
9007 }
9008 v.reset(OpARM64SUBshiftLL)
9009 v.AuxInt = int64ToAuxInt(log64(c / 7))
9010 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9011 v0.AuxInt = int64ToAuxInt(3)
9012 v0.AddArg2(x, x)
9013 v.AddArg2(a, v0)
9014 return true
9015 }
9016
9017
9018
9019 for {
9020 a := v_0
9021 if v_1.Op != OpARM64MOVDconst {
9022 break
9023 }
9024 c := auxIntToInt64(v_1.AuxInt)
9025 x := v_2
9026 if !(c%9 == 0 && isPowerOfTwo(c/9)) {
9027 break
9028 }
9029 v.reset(OpARM64ADDshiftLL)
9030 v.AuxInt = int64ToAuxInt(log64(c / 9))
9031 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9032 v0.AuxInt = int64ToAuxInt(3)
9033 v0.AddArg2(x, x)
9034 v.AddArg2(a, v0)
9035 return true
9036 }
9037
9038
9039 for {
9040 if v_0.Op != OpARM64MOVDconst {
9041 break
9042 }
9043 c := auxIntToInt64(v_0.AuxInt)
9044 x := v_1
9045 y := v_2
9046 v.reset(OpARM64ADDconst)
9047 v.AuxInt = int64ToAuxInt(c)
9048 v0 := b.NewValue0(v.Pos, OpARM64MUL, x.Type)
9049 v0.AddArg2(x, y)
9050 v.AddArg(v0)
9051 return true
9052 }
9053
9054
9055 for {
9056 a := v_0
9057 if v_1.Op != OpARM64MOVDconst {
9058 break
9059 }
9060 c := auxIntToInt64(v_1.AuxInt)
9061 if v_2.Op != OpARM64MOVDconst {
9062 break
9063 }
9064 d := auxIntToInt64(v_2.AuxInt)
9065 v.reset(OpARM64ADDconst)
9066 v.AuxInt = int64ToAuxInt(c * d)
9067 v.AddArg(a)
9068 return true
9069 }
9070 return false
9071 }
9072 func rewriteValueARM64_OpARM64MADDW(v *Value) bool {
9073 v_2 := v.Args[2]
9074 v_1 := v.Args[1]
9075 v_0 := v.Args[0]
9076 b := v.Block
9077
9078
9079
9080 for {
9081 a := v_0
9082 x := v_1
9083 if v_2.Op != OpARM64MOVDconst {
9084 break
9085 }
9086 c := auxIntToInt64(v_2.AuxInt)
9087 if !(int32(c) == -1) {
9088 break
9089 }
9090 v.reset(OpARM64MOVWUreg)
9091 v0 := b.NewValue0(v.Pos, OpARM64SUB, a.Type)
9092 v0.AddArg2(a, x)
9093 v.AddArg(v0)
9094 return true
9095 }
9096
9097
9098
9099 for {
9100 a := v_0
9101 if v_2.Op != OpARM64MOVDconst {
9102 break
9103 }
9104 c := auxIntToInt64(v_2.AuxInt)
9105 if !(int32(c) == 0) {
9106 break
9107 }
9108 v.reset(OpARM64MOVWUreg)
9109 v.AddArg(a)
9110 return true
9111 }
9112
9113
9114
9115 for {
9116 a := v_0
9117 x := v_1
9118 if v_2.Op != OpARM64MOVDconst {
9119 break
9120 }
9121 c := auxIntToInt64(v_2.AuxInt)
9122 if !(int32(c) == 1) {
9123 break
9124 }
9125 v.reset(OpARM64MOVWUreg)
9126 v0 := b.NewValue0(v.Pos, OpARM64ADD, a.Type)
9127 v0.AddArg2(a, x)
9128 v.AddArg(v0)
9129 return true
9130 }
9131
9132
9133
9134 for {
9135 a := v_0
9136 x := v_1
9137 if v_2.Op != OpARM64MOVDconst {
9138 break
9139 }
9140 c := auxIntToInt64(v_2.AuxInt)
9141 if !(isPowerOfTwo(c)) {
9142 break
9143 }
9144 v.reset(OpARM64MOVWUreg)
9145 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
9146 v0.AuxInt = int64ToAuxInt(log64(c))
9147 v0.AddArg2(a, x)
9148 v.AddArg(v0)
9149 return true
9150 }
9151
9152
9153
9154 for {
9155 a := v_0
9156 x := v_1
9157 if v_2.Op != OpARM64MOVDconst {
9158 break
9159 }
9160 c := auxIntToInt64(v_2.AuxInt)
9161 if !(isPowerOfTwo(c-1) && int32(c) >= 3) {
9162 break
9163 }
9164 v.reset(OpARM64MOVWUreg)
9165 v0 := b.NewValue0(v.Pos, OpARM64ADD, a.Type)
9166 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9167 v1.AuxInt = int64ToAuxInt(log64(c - 1))
9168 v1.AddArg2(x, x)
9169 v0.AddArg2(a, v1)
9170 v.AddArg(v0)
9171 return true
9172 }
9173
9174
9175
9176 for {
9177 a := v_0
9178 x := v_1
9179 if v_2.Op != OpARM64MOVDconst {
9180 break
9181 }
9182 c := auxIntToInt64(v_2.AuxInt)
9183 if !(isPowerOfTwo(c+1) && int32(c) >= 7) {
9184 break
9185 }
9186 v.reset(OpARM64MOVWUreg)
9187 v0 := b.NewValue0(v.Pos, OpARM64SUB, a.Type)
9188 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9189 v1.AuxInt = int64ToAuxInt(log64(c + 1))
9190 v1.AddArg2(x, x)
9191 v0.AddArg2(a, v1)
9192 v.AddArg(v0)
9193 return true
9194 }
9195
9196
9197
9198 for {
9199 a := v_0
9200 x := v_1
9201 if v_2.Op != OpARM64MOVDconst {
9202 break
9203 }
9204 c := auxIntToInt64(v_2.AuxInt)
9205 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) {
9206 break
9207 }
9208 v.reset(OpARM64MOVWUreg)
9209 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
9210 v0.AuxInt = int64ToAuxInt(log64(c / 3))
9211 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9212 v1.AuxInt = int64ToAuxInt(2)
9213 v1.AddArg2(x, x)
9214 v0.AddArg2(a, v1)
9215 v.AddArg(v0)
9216 return true
9217 }
9218
9219
9220
9221 for {
9222 a := v_0
9223 x := v_1
9224 if v_2.Op != OpARM64MOVDconst {
9225 break
9226 }
9227 c := auxIntToInt64(v_2.AuxInt)
9228 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) {
9229 break
9230 }
9231 v.reset(OpARM64MOVWUreg)
9232 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
9233 v0.AuxInt = int64ToAuxInt(log64(c / 5))
9234 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9235 v1.AuxInt = int64ToAuxInt(2)
9236 v1.AddArg2(x, x)
9237 v0.AddArg2(a, v1)
9238 v.AddArg(v0)
9239 return true
9240 }
9241
9242
9243
9244 for {
9245 a := v_0
9246 x := v_1
9247 if v_2.Op != OpARM64MOVDconst {
9248 break
9249 }
9250 c := auxIntToInt64(v_2.AuxInt)
9251 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) {
9252 break
9253 }
9254 v.reset(OpARM64MOVWUreg)
9255 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
9256 v0.AuxInt = int64ToAuxInt(log64(c / 7))
9257 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9258 v1.AuxInt = int64ToAuxInt(3)
9259 v1.AddArg2(x, x)
9260 v0.AddArg2(a, v1)
9261 v.AddArg(v0)
9262 return true
9263 }
9264
9265
9266
9267 for {
9268 a := v_0
9269 x := v_1
9270 if v_2.Op != OpARM64MOVDconst {
9271 break
9272 }
9273 c := auxIntToInt64(v_2.AuxInt)
9274 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) {
9275 break
9276 }
9277 v.reset(OpARM64MOVWUreg)
9278 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
9279 v0.AuxInt = int64ToAuxInt(log64(c / 9))
9280 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9281 v1.AuxInt = int64ToAuxInt(3)
9282 v1.AddArg2(x, x)
9283 v0.AddArg2(a, v1)
9284 v.AddArg(v0)
9285 return true
9286 }
9287
9288
9289
9290 for {
9291 a := v_0
9292 if v_1.Op != OpARM64MOVDconst {
9293 break
9294 }
9295 c := auxIntToInt64(v_1.AuxInt)
9296 x := v_2
9297 if !(int32(c) == -1) {
9298 break
9299 }
9300 v.reset(OpARM64MOVWUreg)
9301 v0 := b.NewValue0(v.Pos, OpARM64SUB, a.Type)
9302 v0.AddArg2(a, x)
9303 v.AddArg(v0)
9304 return true
9305 }
9306
9307
9308
9309 for {
9310 a := v_0
9311 if v_1.Op != OpARM64MOVDconst {
9312 break
9313 }
9314 c := auxIntToInt64(v_1.AuxInt)
9315 if !(int32(c) == 0) {
9316 break
9317 }
9318 v.reset(OpARM64MOVWUreg)
9319 v.AddArg(a)
9320 return true
9321 }
9322
9323
9324
9325 for {
9326 a := v_0
9327 if v_1.Op != OpARM64MOVDconst {
9328 break
9329 }
9330 c := auxIntToInt64(v_1.AuxInt)
9331 x := v_2
9332 if !(int32(c) == 1) {
9333 break
9334 }
9335 v.reset(OpARM64MOVWUreg)
9336 v0 := b.NewValue0(v.Pos, OpARM64ADD, a.Type)
9337 v0.AddArg2(a, x)
9338 v.AddArg(v0)
9339 return true
9340 }
9341
9342
9343
9344 for {
9345 a := v_0
9346 if v_1.Op != OpARM64MOVDconst {
9347 break
9348 }
9349 c := auxIntToInt64(v_1.AuxInt)
9350 x := v_2
9351 if !(isPowerOfTwo(c)) {
9352 break
9353 }
9354 v.reset(OpARM64MOVWUreg)
9355 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
9356 v0.AuxInt = int64ToAuxInt(log64(c))
9357 v0.AddArg2(a, x)
9358 v.AddArg(v0)
9359 return true
9360 }
9361
9362
9363
9364 for {
9365 a := v_0
9366 if v_1.Op != OpARM64MOVDconst {
9367 break
9368 }
9369 c := auxIntToInt64(v_1.AuxInt)
9370 x := v_2
9371 if !(isPowerOfTwo(c-1) && int32(c) >= 3) {
9372 break
9373 }
9374 v.reset(OpARM64MOVWUreg)
9375 v0 := b.NewValue0(v.Pos, OpARM64ADD, a.Type)
9376 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9377 v1.AuxInt = int64ToAuxInt(log64(c - 1))
9378 v1.AddArg2(x, x)
9379 v0.AddArg2(a, v1)
9380 v.AddArg(v0)
9381 return true
9382 }
9383
9384
9385
9386 for {
9387 a := v_0
9388 if v_1.Op != OpARM64MOVDconst {
9389 break
9390 }
9391 c := auxIntToInt64(v_1.AuxInt)
9392 x := v_2
9393 if !(isPowerOfTwo(c+1) && int32(c) >= 7) {
9394 break
9395 }
9396 v.reset(OpARM64MOVWUreg)
9397 v0 := b.NewValue0(v.Pos, OpARM64SUB, a.Type)
9398 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9399 v1.AuxInt = int64ToAuxInt(log64(c + 1))
9400 v1.AddArg2(x, x)
9401 v0.AddArg2(a, v1)
9402 v.AddArg(v0)
9403 return true
9404 }
9405
9406
9407
9408 for {
9409 a := v_0
9410 if v_1.Op != OpARM64MOVDconst {
9411 break
9412 }
9413 c := auxIntToInt64(v_1.AuxInt)
9414 x := v_2
9415 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) {
9416 break
9417 }
9418 v.reset(OpARM64MOVWUreg)
9419 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
9420 v0.AuxInt = int64ToAuxInt(log64(c / 3))
9421 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9422 v1.AuxInt = int64ToAuxInt(2)
9423 v1.AddArg2(x, x)
9424 v0.AddArg2(a, v1)
9425 v.AddArg(v0)
9426 return true
9427 }
9428
9429
9430
9431 for {
9432 a := v_0
9433 if v_1.Op != OpARM64MOVDconst {
9434 break
9435 }
9436 c := auxIntToInt64(v_1.AuxInt)
9437 x := v_2
9438 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) {
9439 break
9440 }
9441 v.reset(OpARM64MOVWUreg)
9442 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
9443 v0.AuxInt = int64ToAuxInt(log64(c / 5))
9444 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9445 v1.AuxInt = int64ToAuxInt(2)
9446 v1.AddArg2(x, x)
9447 v0.AddArg2(a, v1)
9448 v.AddArg(v0)
9449 return true
9450 }
9451
9452
9453
9454 for {
9455 a := v_0
9456 if v_1.Op != OpARM64MOVDconst {
9457 break
9458 }
9459 c := auxIntToInt64(v_1.AuxInt)
9460 x := v_2
9461 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) {
9462 break
9463 }
9464 v.reset(OpARM64MOVWUreg)
9465 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
9466 v0.AuxInt = int64ToAuxInt(log64(c / 7))
9467 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9468 v1.AuxInt = int64ToAuxInt(3)
9469 v1.AddArg2(x, x)
9470 v0.AddArg2(a, v1)
9471 v.AddArg(v0)
9472 return true
9473 }
9474
9475
9476
9477 for {
9478 a := v_0
9479 if v_1.Op != OpARM64MOVDconst {
9480 break
9481 }
9482 c := auxIntToInt64(v_1.AuxInt)
9483 x := v_2
9484 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) {
9485 break
9486 }
9487 v.reset(OpARM64MOVWUreg)
9488 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
9489 v0.AuxInt = int64ToAuxInt(log64(c / 9))
9490 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9491 v1.AuxInt = int64ToAuxInt(3)
9492 v1.AddArg2(x, x)
9493 v0.AddArg2(a, v1)
9494 v.AddArg(v0)
9495 return true
9496 }
9497
9498
9499 for {
9500 if v_0.Op != OpARM64MOVDconst {
9501 break
9502 }
9503 c := auxIntToInt64(v_0.AuxInt)
9504 x := v_1
9505 y := v_2
9506 v.reset(OpARM64MOVWUreg)
9507 v0 := b.NewValue0(v.Pos, OpARM64ADDconst, x.Type)
9508 v0.AuxInt = int64ToAuxInt(c)
9509 v1 := b.NewValue0(v.Pos, OpARM64MULW, x.Type)
9510 v1.AddArg2(x, y)
9511 v0.AddArg(v1)
9512 v.AddArg(v0)
9513 return true
9514 }
9515
9516
9517 for {
9518 a := v_0
9519 if v_1.Op != OpARM64MOVDconst {
9520 break
9521 }
9522 c := auxIntToInt64(v_1.AuxInt)
9523 if v_2.Op != OpARM64MOVDconst {
9524 break
9525 }
9526 d := auxIntToInt64(v_2.AuxInt)
9527 v.reset(OpARM64MOVWUreg)
9528 v0 := b.NewValue0(v.Pos, OpARM64ADDconst, a.Type)
9529 v0.AuxInt = int64ToAuxInt(c * d)
9530 v0.AddArg(a)
9531 v.AddArg(v0)
9532 return true
9533 }
9534 return false
9535 }
9536 func rewriteValueARM64_OpARM64MNEG(v *Value) bool {
9537 v_1 := v.Args[1]
9538 v_0 := v.Args[0]
9539 b := v.Block
9540
9541
9542 for {
9543 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9544 x := v_0
9545 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != -1 {
9546 continue
9547 }
9548 v.copyOf(x)
9549 return true
9550 }
9551 break
9552 }
9553
9554
9555 for {
9556 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9557 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
9558 continue
9559 }
9560 v.reset(OpARM64MOVDconst)
9561 v.AuxInt = int64ToAuxInt(0)
9562 return true
9563 }
9564 break
9565 }
9566
9567
9568 for {
9569 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9570 x := v_0
9571 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
9572 continue
9573 }
9574 v.reset(OpARM64NEG)
9575 v.AddArg(x)
9576 return true
9577 }
9578 break
9579 }
9580
9581
9582
9583 for {
9584 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9585 x := v_0
9586 if v_1.Op != OpARM64MOVDconst {
9587 continue
9588 }
9589 c := auxIntToInt64(v_1.AuxInt)
9590 if !(isPowerOfTwo(c)) {
9591 continue
9592 }
9593 v.reset(OpARM64NEG)
9594 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
9595 v0.AuxInt = int64ToAuxInt(log64(c))
9596 v0.AddArg(x)
9597 v.AddArg(v0)
9598 return true
9599 }
9600 break
9601 }
9602
9603
9604
9605 for {
9606 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9607 x := v_0
9608 if v_1.Op != OpARM64MOVDconst {
9609 continue
9610 }
9611 c := auxIntToInt64(v_1.AuxInt)
9612 if !(isPowerOfTwo(c-1) && c >= 3) {
9613 continue
9614 }
9615 v.reset(OpARM64NEG)
9616 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9617 v0.AuxInt = int64ToAuxInt(log64(c - 1))
9618 v0.AddArg2(x, x)
9619 v.AddArg(v0)
9620 return true
9621 }
9622 break
9623 }
9624
9625
9626
9627 for {
9628 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9629 x := v_0
9630 if v_1.Op != OpARM64MOVDconst {
9631 continue
9632 }
9633 c := auxIntToInt64(v_1.AuxInt)
9634 if !(isPowerOfTwo(c+1) && c >= 7) {
9635 continue
9636 }
9637 v.reset(OpARM64NEG)
9638 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9639 v0.AuxInt = int64ToAuxInt(log64(c + 1))
9640 v1 := b.NewValue0(v.Pos, OpARM64NEG, x.Type)
9641 v1.AddArg(x)
9642 v0.AddArg2(v1, x)
9643 v.AddArg(v0)
9644 return true
9645 }
9646 break
9647 }
9648
9649
9650
9651 for {
9652 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9653 x := v_0
9654 if v_1.Op != OpARM64MOVDconst {
9655 continue
9656 }
9657 c := auxIntToInt64(v_1.AuxInt)
9658 if !(c%3 == 0 && isPowerOfTwo(c/3)) {
9659 continue
9660 }
9661 v.reset(OpARM64SLLconst)
9662 v.Type = x.Type
9663 v.AuxInt = int64ToAuxInt(log64(c / 3))
9664 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9665 v0.AuxInt = int64ToAuxInt(2)
9666 v0.AddArg2(x, x)
9667 v.AddArg(v0)
9668 return true
9669 }
9670 break
9671 }
9672
9673
9674
9675 for {
9676 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9677 x := v_0
9678 if v_1.Op != OpARM64MOVDconst {
9679 continue
9680 }
9681 c := auxIntToInt64(v_1.AuxInt)
9682 if !(c%5 == 0 && isPowerOfTwo(c/5)) {
9683 continue
9684 }
9685 v.reset(OpARM64NEG)
9686 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
9687 v0.AuxInt = int64ToAuxInt(log64(c / 5))
9688 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9689 v1.AuxInt = int64ToAuxInt(2)
9690 v1.AddArg2(x, x)
9691 v0.AddArg(v1)
9692 v.AddArg(v0)
9693 return true
9694 }
9695 break
9696 }
9697
9698
9699
9700 for {
9701 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9702 x := v_0
9703 if v_1.Op != OpARM64MOVDconst {
9704 continue
9705 }
9706 c := auxIntToInt64(v_1.AuxInt)
9707 if !(c%7 == 0 && isPowerOfTwo(c/7)) {
9708 continue
9709 }
9710 v.reset(OpARM64SLLconst)
9711 v.Type = x.Type
9712 v.AuxInt = int64ToAuxInt(log64(c / 7))
9713 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9714 v0.AuxInt = int64ToAuxInt(3)
9715 v0.AddArg2(x, x)
9716 v.AddArg(v0)
9717 return true
9718 }
9719 break
9720 }
9721
9722
9723
9724 for {
9725 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9726 x := v_0
9727 if v_1.Op != OpARM64MOVDconst {
9728 continue
9729 }
9730 c := auxIntToInt64(v_1.AuxInt)
9731 if !(c%9 == 0 && isPowerOfTwo(c/9)) {
9732 continue
9733 }
9734 v.reset(OpARM64NEG)
9735 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
9736 v0.AuxInt = int64ToAuxInt(log64(c / 9))
9737 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9738 v1.AuxInt = int64ToAuxInt(3)
9739 v1.AddArg2(x, x)
9740 v0.AddArg(v1)
9741 v.AddArg(v0)
9742 return true
9743 }
9744 break
9745 }
9746
9747
9748 for {
9749 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9750 if v_0.Op != OpARM64MOVDconst {
9751 continue
9752 }
9753 c := auxIntToInt64(v_0.AuxInt)
9754 if v_1.Op != OpARM64MOVDconst {
9755 continue
9756 }
9757 d := auxIntToInt64(v_1.AuxInt)
9758 v.reset(OpARM64MOVDconst)
9759 v.AuxInt = int64ToAuxInt(-c * d)
9760 return true
9761 }
9762 break
9763 }
9764 return false
9765 }
9766 func rewriteValueARM64_OpARM64MNEGW(v *Value) bool {
9767 v_1 := v.Args[1]
9768 v_0 := v.Args[0]
9769 b := v.Block
9770
9771
9772
9773 for {
9774 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9775 x := v_0
9776 if v_1.Op != OpARM64MOVDconst {
9777 continue
9778 }
9779 c := auxIntToInt64(v_1.AuxInt)
9780 if !(int32(c) == -1) {
9781 continue
9782 }
9783 v.reset(OpARM64MOVWUreg)
9784 v.AddArg(x)
9785 return true
9786 }
9787 break
9788 }
9789
9790
9791
9792 for {
9793 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9794 if v_1.Op != OpARM64MOVDconst {
9795 continue
9796 }
9797 c := auxIntToInt64(v_1.AuxInt)
9798 if !(int32(c) == 0) {
9799 continue
9800 }
9801 v.reset(OpARM64MOVDconst)
9802 v.AuxInt = int64ToAuxInt(0)
9803 return true
9804 }
9805 break
9806 }
9807
9808
9809
9810 for {
9811 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9812 x := v_0
9813 if v_1.Op != OpARM64MOVDconst {
9814 continue
9815 }
9816 c := auxIntToInt64(v_1.AuxInt)
9817 if !(int32(c) == 1) {
9818 continue
9819 }
9820 v.reset(OpARM64MOVWUreg)
9821 v0 := b.NewValue0(v.Pos, OpARM64NEG, x.Type)
9822 v0.AddArg(x)
9823 v.AddArg(v0)
9824 return true
9825 }
9826 break
9827 }
9828
9829
9830
9831 for {
9832 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9833 x := v_0
9834 if v_1.Op != OpARM64MOVDconst {
9835 continue
9836 }
9837 c := auxIntToInt64(v_1.AuxInt)
9838 if !(isPowerOfTwo(c)) {
9839 continue
9840 }
9841 v.reset(OpARM64NEG)
9842 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
9843 v0.AuxInt = int64ToAuxInt(log64(c))
9844 v0.AddArg(x)
9845 v.AddArg(v0)
9846 return true
9847 }
9848 break
9849 }
9850
9851
9852
9853 for {
9854 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9855 x := v_0
9856 if v_1.Op != OpARM64MOVDconst {
9857 continue
9858 }
9859 c := auxIntToInt64(v_1.AuxInt)
9860 if !(isPowerOfTwo(c-1) && int32(c) >= 3) {
9861 continue
9862 }
9863 v.reset(OpARM64MOVWUreg)
9864 v0 := b.NewValue0(v.Pos, OpARM64NEG, x.Type)
9865 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9866 v1.AuxInt = int64ToAuxInt(log64(c - 1))
9867 v1.AddArg2(x, x)
9868 v0.AddArg(v1)
9869 v.AddArg(v0)
9870 return true
9871 }
9872 break
9873 }
9874
9875
9876
9877 for {
9878 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9879 x := v_0
9880 if v_1.Op != OpARM64MOVDconst {
9881 continue
9882 }
9883 c := auxIntToInt64(v_1.AuxInt)
9884 if !(isPowerOfTwo(c+1) && int32(c) >= 7) {
9885 continue
9886 }
9887 v.reset(OpARM64MOVWUreg)
9888 v0 := b.NewValue0(v.Pos, OpARM64NEG, x.Type)
9889 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9890 v1.AuxInt = int64ToAuxInt(log64(c + 1))
9891 v2 := b.NewValue0(v.Pos, OpARM64NEG, x.Type)
9892 v2.AddArg(x)
9893 v1.AddArg2(v2, x)
9894 v0.AddArg(v1)
9895 v.AddArg(v0)
9896 return true
9897 }
9898 break
9899 }
9900
9901
9902
9903 for {
9904 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9905 x := v_0
9906 if v_1.Op != OpARM64MOVDconst {
9907 continue
9908 }
9909 c := auxIntToInt64(v_1.AuxInt)
9910 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) {
9911 continue
9912 }
9913 v.reset(OpARM64MOVWUreg)
9914 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
9915 v0.AuxInt = int64ToAuxInt(log64(c / 3))
9916 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9917 v1.AuxInt = int64ToAuxInt(2)
9918 v1.AddArg2(x, x)
9919 v0.AddArg(v1)
9920 v.AddArg(v0)
9921 return true
9922 }
9923 break
9924 }
9925
9926
9927
9928 for {
9929 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9930 x := v_0
9931 if v_1.Op != OpARM64MOVDconst {
9932 continue
9933 }
9934 c := auxIntToInt64(v_1.AuxInt)
9935 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) {
9936 continue
9937 }
9938 v.reset(OpARM64MOVWUreg)
9939 v0 := b.NewValue0(v.Pos, OpARM64NEG, x.Type)
9940 v1 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
9941 v1.AuxInt = int64ToAuxInt(log64(c / 5))
9942 v2 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9943 v2.AuxInt = int64ToAuxInt(2)
9944 v2.AddArg2(x, x)
9945 v1.AddArg(v2)
9946 v0.AddArg(v1)
9947 v.AddArg(v0)
9948 return true
9949 }
9950 break
9951 }
9952
9953
9954
9955 for {
9956 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9957 x := v_0
9958 if v_1.Op != OpARM64MOVDconst {
9959 continue
9960 }
9961 c := auxIntToInt64(v_1.AuxInt)
9962 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) {
9963 continue
9964 }
9965 v.reset(OpARM64MOVWUreg)
9966 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
9967 v0.AuxInt = int64ToAuxInt(log64(c / 7))
9968 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9969 v1.AuxInt = int64ToAuxInt(3)
9970 v1.AddArg2(x, x)
9971 v0.AddArg(v1)
9972 v.AddArg(v0)
9973 return true
9974 }
9975 break
9976 }
9977
9978
9979
9980 for {
9981 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9982 x := v_0
9983 if v_1.Op != OpARM64MOVDconst {
9984 continue
9985 }
9986 c := auxIntToInt64(v_1.AuxInt)
9987 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) {
9988 continue
9989 }
9990 v.reset(OpARM64MOVWUreg)
9991 v0 := b.NewValue0(v.Pos, OpARM64NEG, x.Type)
9992 v1 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
9993 v1.AuxInt = int64ToAuxInt(log64(c / 9))
9994 v2 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9995 v2.AuxInt = int64ToAuxInt(3)
9996 v2.AddArg2(x, x)
9997 v1.AddArg(v2)
9998 v0.AddArg(v1)
9999 v.AddArg(v0)
10000 return true
10001 }
10002 break
10003 }
10004
10005
10006 for {
10007 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
10008 if v_0.Op != OpARM64MOVDconst {
10009 continue
10010 }
10011 c := auxIntToInt64(v_0.AuxInt)
10012 if v_1.Op != OpARM64MOVDconst {
10013 continue
10014 }
10015 d := auxIntToInt64(v_1.AuxInt)
10016 v.reset(OpARM64MOVDconst)
10017 v.AuxInt = int64ToAuxInt(int64(uint32(-c * d)))
10018 return true
10019 }
10020 break
10021 }
10022 return false
10023 }
10024 func rewriteValueARM64_OpARM64MOD(v *Value) bool {
10025 v_1 := v.Args[1]
10026 v_0 := v.Args[0]
10027
10028
10029
10030 for {
10031 if v_0.Op != OpARM64MOVDconst {
10032 break
10033 }
10034 c := auxIntToInt64(v_0.AuxInt)
10035 if v_1.Op != OpARM64MOVDconst {
10036 break
10037 }
10038 d := auxIntToInt64(v_1.AuxInt)
10039 if !(d != 0) {
10040 break
10041 }
10042 v.reset(OpARM64MOVDconst)
10043 v.AuxInt = int64ToAuxInt(c % d)
10044 return true
10045 }
10046 return false
10047 }
10048 func rewriteValueARM64_OpARM64MODW(v *Value) bool {
10049 v_1 := v.Args[1]
10050 v_0 := v.Args[0]
10051
10052
10053
10054 for {
10055 if v_0.Op != OpARM64MOVDconst {
10056 break
10057 }
10058 c := auxIntToInt64(v_0.AuxInt)
10059 if v_1.Op != OpARM64MOVDconst {
10060 break
10061 }
10062 d := auxIntToInt64(v_1.AuxInt)
10063 if !(d != 0) {
10064 break
10065 }
10066 v.reset(OpARM64MOVDconst)
10067 v.AuxInt = int64ToAuxInt(int64(uint32(int32(c) % int32(d))))
10068 return true
10069 }
10070 return false
10071 }
10072 func rewriteValueARM64_OpARM64MOVBUload(v *Value) bool {
10073 v_1 := v.Args[1]
10074 v_0 := v.Args[0]
10075 b := v.Block
10076 config := b.Func.Config
10077
10078
10079
10080 for {
10081 off1 := auxIntToInt32(v.AuxInt)
10082 sym := auxToSym(v.Aux)
10083 if v_0.Op != OpARM64ADDconst {
10084 break
10085 }
10086 off2 := auxIntToInt64(v_0.AuxInt)
10087 ptr := v_0.Args[0]
10088 mem := v_1
10089 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
10090 break
10091 }
10092 v.reset(OpARM64MOVBUload)
10093 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
10094 v.Aux = symToAux(sym)
10095 v.AddArg2(ptr, mem)
10096 return true
10097 }
10098
10099
10100
10101 for {
10102 off := auxIntToInt32(v.AuxInt)
10103 sym := auxToSym(v.Aux)
10104 if v_0.Op != OpARM64ADD {
10105 break
10106 }
10107 idx := v_0.Args[1]
10108 ptr := v_0.Args[0]
10109 mem := v_1
10110 if !(off == 0 && sym == nil) {
10111 break
10112 }
10113 v.reset(OpARM64MOVBUloadidx)
10114 v.AddArg3(ptr, idx, mem)
10115 return true
10116 }
10117
10118
10119
10120 for {
10121 off1 := auxIntToInt32(v.AuxInt)
10122 sym1 := auxToSym(v.Aux)
10123 if v_0.Op != OpARM64MOVDaddr {
10124 break
10125 }
10126 off2 := auxIntToInt32(v_0.AuxInt)
10127 sym2 := auxToSym(v_0.Aux)
10128 ptr := v_0.Args[0]
10129 mem := v_1
10130 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
10131 break
10132 }
10133 v.reset(OpARM64MOVBUload)
10134 v.AuxInt = int32ToAuxInt(off1 + off2)
10135 v.Aux = symToAux(mergeSym(sym1, sym2))
10136 v.AddArg2(ptr, mem)
10137 return true
10138 }
10139
10140
10141
10142 for {
10143 off := auxIntToInt32(v.AuxInt)
10144 sym := auxToSym(v.Aux)
10145 if v_0.Op != OpSB || !(symIsRO(sym)) {
10146 break
10147 }
10148 v.reset(OpARM64MOVDconst)
10149 v.AuxInt = int64ToAuxInt(int64(read8(sym, int64(off))))
10150 return true
10151 }
10152 return false
10153 }
10154 func rewriteValueARM64_OpARM64MOVBUloadidx(v *Value) bool {
10155 v_2 := v.Args[2]
10156 v_1 := v.Args[1]
10157 v_0 := v.Args[0]
10158
10159
10160
10161 for {
10162 ptr := v_0
10163 if v_1.Op != OpARM64MOVDconst {
10164 break
10165 }
10166 c := auxIntToInt64(v_1.AuxInt)
10167 mem := v_2
10168 if !(is32Bit(c)) {
10169 break
10170 }
10171 v.reset(OpARM64MOVBUload)
10172 v.AuxInt = int32ToAuxInt(int32(c))
10173 v.AddArg2(ptr, mem)
10174 return true
10175 }
10176
10177
10178
10179 for {
10180 if v_0.Op != OpARM64MOVDconst {
10181 break
10182 }
10183 c := auxIntToInt64(v_0.AuxInt)
10184 ptr := v_1
10185 mem := v_2
10186 if !(is32Bit(c)) {
10187 break
10188 }
10189 v.reset(OpARM64MOVBUload)
10190 v.AuxInt = int32ToAuxInt(int32(c))
10191 v.AddArg2(ptr, mem)
10192 return true
10193 }
10194 return false
10195 }
10196 func rewriteValueARM64_OpARM64MOVBUreg(v *Value) bool {
10197 v_0 := v.Args[0]
10198
10199
10200 for {
10201 if v_0.Op != OpARM64ANDconst {
10202 break
10203 }
10204 c := auxIntToInt64(v_0.AuxInt)
10205 x := v_0.Args[0]
10206 v.reset(OpARM64ANDconst)
10207 v.AuxInt = int64ToAuxInt(c & (1<<8 - 1))
10208 v.AddArg(x)
10209 return true
10210 }
10211
10212
10213 for {
10214 if v_0.Op != OpARM64MOVDconst {
10215 break
10216 }
10217 c := auxIntToInt64(v_0.AuxInt)
10218 v.reset(OpARM64MOVDconst)
10219 v.AuxInt = int64ToAuxInt(int64(uint8(c)))
10220 return true
10221 }
10222
10223
10224
10225 for {
10226 x := v_0
10227 if !(v.Type.Size() <= 1) {
10228 break
10229 }
10230 v.copyOf(x)
10231 return true
10232 }
10233
10234
10235
10236 for {
10237 if v_0.Op != OpARM64SLLconst {
10238 break
10239 }
10240 lc := auxIntToInt64(v_0.AuxInt)
10241 if !(lc >= 8) {
10242 break
10243 }
10244 v.reset(OpARM64MOVDconst)
10245 v.AuxInt = int64ToAuxInt(0)
10246 return true
10247 }
10248
10249
10250
10251 for {
10252 if v_0.Op != OpARM64SLLconst {
10253 break
10254 }
10255 lc := auxIntToInt64(v_0.AuxInt)
10256 x := v_0.Args[0]
10257 if !(lc < 8) {
10258 break
10259 }
10260 v.reset(OpARM64UBFIZ)
10261 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, 8-lc))
10262 v.AddArg(x)
10263 return true
10264 }
10265
10266
10267
10268 for {
10269 if v_0.Op != OpARM64SRLconst {
10270 break
10271 }
10272 rc := auxIntToInt64(v_0.AuxInt)
10273 x := v_0.Args[0]
10274 if !(rc < 8) {
10275 break
10276 }
10277 v.reset(OpARM64UBFX)
10278 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 8))
10279 v.AddArg(x)
10280 return true
10281 }
10282
10283
10284
10285 for {
10286 if v_0.Op != OpARM64UBFX {
10287 break
10288 }
10289 bfc := auxIntToArm64BitField(v_0.AuxInt)
10290 x := v_0.Args[0]
10291 if !(bfc.width() <= 8) {
10292 break
10293 }
10294 v.reset(OpARM64UBFX)
10295 v.AuxInt = arm64BitFieldToAuxInt(bfc)
10296 v.AddArg(x)
10297 return true
10298 }
10299 return false
10300 }
10301 func rewriteValueARM64_OpARM64MOVBload(v *Value) bool {
10302 v_1 := v.Args[1]
10303 v_0 := v.Args[0]
10304 b := v.Block
10305 config := b.Func.Config
10306
10307
10308
10309 for {
10310 off1 := auxIntToInt32(v.AuxInt)
10311 sym := auxToSym(v.Aux)
10312 if v_0.Op != OpARM64ADDconst {
10313 break
10314 }
10315 off2 := auxIntToInt64(v_0.AuxInt)
10316 ptr := v_0.Args[0]
10317 mem := v_1
10318 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
10319 break
10320 }
10321 v.reset(OpARM64MOVBload)
10322 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
10323 v.Aux = symToAux(sym)
10324 v.AddArg2(ptr, mem)
10325 return true
10326 }
10327
10328
10329
10330 for {
10331 off := auxIntToInt32(v.AuxInt)
10332 sym := auxToSym(v.Aux)
10333 if v_0.Op != OpARM64ADD {
10334 break
10335 }
10336 idx := v_0.Args[1]
10337 ptr := v_0.Args[0]
10338 mem := v_1
10339 if !(off == 0 && sym == nil) {
10340 break
10341 }
10342 v.reset(OpARM64MOVBloadidx)
10343 v.AddArg3(ptr, idx, mem)
10344 return true
10345 }
10346
10347
10348
10349 for {
10350 off1 := auxIntToInt32(v.AuxInt)
10351 sym1 := auxToSym(v.Aux)
10352 if v_0.Op != OpARM64MOVDaddr {
10353 break
10354 }
10355 off2 := auxIntToInt32(v_0.AuxInt)
10356 sym2 := auxToSym(v_0.Aux)
10357 ptr := v_0.Args[0]
10358 mem := v_1
10359 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
10360 break
10361 }
10362 v.reset(OpARM64MOVBload)
10363 v.AuxInt = int32ToAuxInt(off1 + off2)
10364 v.Aux = symToAux(mergeSym(sym1, sym2))
10365 v.AddArg2(ptr, mem)
10366 return true
10367 }
10368
10369
10370
10371 for {
10372 off := auxIntToInt32(v.AuxInt)
10373 sym := auxToSym(v.Aux)
10374 if v_0.Op != OpSB || !(symIsRO(sym)) {
10375 break
10376 }
10377 v.reset(OpARM64MOVDconst)
10378 v.AuxInt = int64ToAuxInt(int64(int8(read8(sym, int64(off)))))
10379 return true
10380 }
10381 return false
10382 }
10383 func rewriteValueARM64_OpARM64MOVBloadidx(v *Value) bool {
10384 v_2 := v.Args[2]
10385 v_1 := v.Args[1]
10386 v_0 := v.Args[0]
10387
10388
10389
10390 for {
10391 ptr := v_0
10392 if v_1.Op != OpARM64MOVDconst {
10393 break
10394 }
10395 c := auxIntToInt64(v_1.AuxInt)
10396 mem := v_2
10397 if !(is32Bit(c)) {
10398 break
10399 }
10400 v.reset(OpARM64MOVBload)
10401 v.AuxInt = int32ToAuxInt(int32(c))
10402 v.AddArg2(ptr, mem)
10403 return true
10404 }
10405
10406
10407
10408 for {
10409 if v_0.Op != OpARM64MOVDconst {
10410 break
10411 }
10412 c := auxIntToInt64(v_0.AuxInt)
10413 ptr := v_1
10414 mem := v_2
10415 if !(is32Bit(c)) {
10416 break
10417 }
10418 v.reset(OpARM64MOVBload)
10419 v.AuxInt = int32ToAuxInt(int32(c))
10420 v.AddArg2(ptr, mem)
10421 return true
10422 }
10423 return false
10424 }
10425 func rewriteValueARM64_OpARM64MOVBreg(v *Value) bool {
10426 v_0 := v.Args[0]
10427
10428
10429 for {
10430 if v_0.Op != OpARM64MOVDconst {
10431 break
10432 }
10433 c := auxIntToInt64(v_0.AuxInt)
10434 v.reset(OpARM64MOVDconst)
10435 v.AuxInt = int64ToAuxInt(int64(int8(c)))
10436 return true
10437 }
10438
10439
10440
10441 for {
10442 x := v_0
10443 if !(v.Type.Size() <= 1) {
10444 break
10445 }
10446 v.copyOf(x)
10447 return true
10448 }
10449
10450
10451
10452 for {
10453 t := v.Type
10454 if v_0.Op != OpARM64ANDconst {
10455 break
10456 }
10457 c := auxIntToInt64(v_0.AuxInt)
10458 x := v_0.Args[0]
10459 if !(uint64(c)&uint64(0xffffffffffffff80) == 0) {
10460 break
10461 }
10462 v.reset(OpARM64ANDconst)
10463 v.Type = t
10464 v.AuxInt = int64ToAuxInt(c)
10465 v.AddArg(x)
10466 return true
10467 }
10468
10469
10470
10471 for {
10472 if v_0.Op != OpARM64SLLconst {
10473 break
10474 }
10475 lc := auxIntToInt64(v_0.AuxInt)
10476 x := v_0.Args[0]
10477 if !(lc < 8) {
10478 break
10479 }
10480 v.reset(OpARM64SBFIZ)
10481 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, 8-lc))
10482 v.AddArg(x)
10483 return true
10484 }
10485
10486
10487
10488 for {
10489 if v_0.Op != OpARM64SBFX {
10490 break
10491 }
10492 bfc := auxIntToArm64BitField(v_0.AuxInt)
10493 x := v_0.Args[0]
10494 if !(bfc.width() <= 8) {
10495 break
10496 }
10497 v.reset(OpARM64SBFX)
10498 v.AuxInt = arm64BitFieldToAuxInt(bfc)
10499 v.AddArg(x)
10500 return true
10501 }
10502 return false
10503 }
10504 func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool {
10505 v_2 := v.Args[2]
10506 v_1 := v.Args[1]
10507 v_0 := v.Args[0]
10508 b := v.Block
10509 config := b.Func.Config
10510
10511
10512
10513 for {
10514 off1 := auxIntToInt32(v.AuxInt)
10515 sym := auxToSym(v.Aux)
10516 if v_0.Op != OpARM64ADDconst {
10517 break
10518 }
10519 off2 := auxIntToInt64(v_0.AuxInt)
10520 ptr := v_0.Args[0]
10521 val := v_1
10522 mem := v_2
10523 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
10524 break
10525 }
10526 v.reset(OpARM64MOVBstore)
10527 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
10528 v.Aux = symToAux(sym)
10529 v.AddArg3(ptr, val, mem)
10530 return true
10531 }
10532
10533
10534
10535 for {
10536 off := auxIntToInt32(v.AuxInt)
10537 sym := auxToSym(v.Aux)
10538 if v_0.Op != OpARM64ADD {
10539 break
10540 }
10541 idx := v_0.Args[1]
10542 ptr := v_0.Args[0]
10543 val := v_1
10544 mem := v_2
10545 if !(off == 0 && sym == nil) {
10546 break
10547 }
10548 v.reset(OpARM64MOVBstoreidx)
10549 v.AddArg4(ptr, idx, val, mem)
10550 return true
10551 }
10552
10553
10554
10555 for {
10556 off1 := auxIntToInt32(v.AuxInt)
10557 sym1 := auxToSym(v.Aux)
10558 if v_0.Op != OpARM64MOVDaddr {
10559 break
10560 }
10561 off2 := auxIntToInt32(v_0.AuxInt)
10562 sym2 := auxToSym(v_0.Aux)
10563 ptr := v_0.Args[0]
10564 val := v_1
10565 mem := v_2
10566 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
10567 break
10568 }
10569 v.reset(OpARM64MOVBstore)
10570 v.AuxInt = int32ToAuxInt(off1 + off2)
10571 v.Aux = symToAux(mergeSym(sym1, sym2))
10572 v.AddArg3(ptr, val, mem)
10573 return true
10574 }
10575
10576
10577 for {
10578 off := auxIntToInt32(v.AuxInt)
10579 sym := auxToSym(v.Aux)
10580 ptr := v_0
10581 if v_1.Op != OpARM64MOVBreg {
10582 break
10583 }
10584 x := v_1.Args[0]
10585 mem := v_2
10586 v.reset(OpARM64MOVBstore)
10587 v.AuxInt = int32ToAuxInt(off)
10588 v.Aux = symToAux(sym)
10589 v.AddArg3(ptr, x, mem)
10590 return true
10591 }
10592
10593
10594 for {
10595 off := auxIntToInt32(v.AuxInt)
10596 sym := auxToSym(v.Aux)
10597 ptr := v_0
10598 if v_1.Op != OpARM64MOVBUreg {
10599 break
10600 }
10601 x := v_1.Args[0]
10602 mem := v_2
10603 v.reset(OpARM64MOVBstore)
10604 v.AuxInt = int32ToAuxInt(off)
10605 v.Aux = symToAux(sym)
10606 v.AddArg3(ptr, x, mem)
10607 return true
10608 }
10609
10610
10611 for {
10612 off := auxIntToInt32(v.AuxInt)
10613 sym := auxToSym(v.Aux)
10614 ptr := v_0
10615 if v_1.Op != OpARM64MOVHreg {
10616 break
10617 }
10618 x := v_1.Args[0]
10619 mem := v_2
10620 v.reset(OpARM64MOVBstore)
10621 v.AuxInt = int32ToAuxInt(off)
10622 v.Aux = symToAux(sym)
10623 v.AddArg3(ptr, x, mem)
10624 return true
10625 }
10626
10627
10628 for {
10629 off := auxIntToInt32(v.AuxInt)
10630 sym := auxToSym(v.Aux)
10631 ptr := v_0
10632 if v_1.Op != OpARM64MOVHUreg {
10633 break
10634 }
10635 x := v_1.Args[0]
10636 mem := v_2
10637 v.reset(OpARM64MOVBstore)
10638 v.AuxInt = int32ToAuxInt(off)
10639 v.Aux = symToAux(sym)
10640 v.AddArg3(ptr, x, mem)
10641 return true
10642 }
10643
10644
10645 for {
10646 off := auxIntToInt32(v.AuxInt)
10647 sym := auxToSym(v.Aux)
10648 ptr := v_0
10649 if v_1.Op != OpARM64MOVWreg {
10650 break
10651 }
10652 x := v_1.Args[0]
10653 mem := v_2
10654 v.reset(OpARM64MOVBstore)
10655 v.AuxInt = int32ToAuxInt(off)
10656 v.Aux = symToAux(sym)
10657 v.AddArg3(ptr, x, mem)
10658 return true
10659 }
10660
10661
10662 for {
10663 off := auxIntToInt32(v.AuxInt)
10664 sym := auxToSym(v.Aux)
10665 ptr := v_0
10666 if v_1.Op != OpARM64MOVWUreg {
10667 break
10668 }
10669 x := v_1.Args[0]
10670 mem := v_2
10671 v.reset(OpARM64MOVBstore)
10672 v.AuxInt = int32ToAuxInt(off)
10673 v.Aux = symToAux(sym)
10674 v.AddArg3(ptr, x, mem)
10675 return true
10676 }
10677 return false
10678 }
10679 func rewriteValueARM64_OpARM64MOVBstoreidx(v *Value) bool {
10680 v_3 := v.Args[3]
10681 v_2 := v.Args[2]
10682 v_1 := v.Args[1]
10683 v_0 := v.Args[0]
10684
10685
10686
10687 for {
10688 ptr := v_0
10689 if v_1.Op != OpARM64MOVDconst {
10690 break
10691 }
10692 c := auxIntToInt64(v_1.AuxInt)
10693 val := v_2
10694 mem := v_3
10695 if !(is32Bit(c)) {
10696 break
10697 }
10698 v.reset(OpARM64MOVBstore)
10699 v.AuxInt = int32ToAuxInt(int32(c))
10700 v.AddArg3(ptr, val, mem)
10701 return true
10702 }
10703
10704
10705
10706 for {
10707 if v_0.Op != OpARM64MOVDconst {
10708 break
10709 }
10710 c := auxIntToInt64(v_0.AuxInt)
10711 idx := v_1
10712 val := v_2
10713 mem := v_3
10714 if !(is32Bit(c)) {
10715 break
10716 }
10717 v.reset(OpARM64MOVBstore)
10718 v.AuxInt = int32ToAuxInt(int32(c))
10719 v.AddArg3(idx, val, mem)
10720 return true
10721 }
10722
10723
10724 for {
10725 ptr := v_0
10726 idx := v_1
10727 if v_2.Op != OpARM64MOVBreg {
10728 break
10729 }
10730 x := v_2.Args[0]
10731 mem := v_3
10732 v.reset(OpARM64MOVBstoreidx)
10733 v.AddArg4(ptr, idx, x, mem)
10734 return true
10735 }
10736
10737
10738 for {
10739 ptr := v_0
10740 idx := v_1
10741 if v_2.Op != OpARM64MOVBUreg {
10742 break
10743 }
10744 x := v_2.Args[0]
10745 mem := v_3
10746 v.reset(OpARM64MOVBstoreidx)
10747 v.AddArg4(ptr, idx, x, mem)
10748 return true
10749 }
10750
10751
10752 for {
10753 ptr := v_0
10754 idx := v_1
10755 if v_2.Op != OpARM64MOVHreg {
10756 break
10757 }
10758 x := v_2.Args[0]
10759 mem := v_3
10760 v.reset(OpARM64MOVBstoreidx)
10761 v.AddArg4(ptr, idx, x, mem)
10762 return true
10763 }
10764
10765
10766 for {
10767 ptr := v_0
10768 idx := v_1
10769 if v_2.Op != OpARM64MOVHUreg {
10770 break
10771 }
10772 x := v_2.Args[0]
10773 mem := v_3
10774 v.reset(OpARM64MOVBstoreidx)
10775 v.AddArg4(ptr, idx, x, mem)
10776 return true
10777 }
10778
10779
10780 for {
10781 ptr := v_0
10782 idx := v_1
10783 if v_2.Op != OpARM64MOVWreg {
10784 break
10785 }
10786 x := v_2.Args[0]
10787 mem := v_3
10788 v.reset(OpARM64MOVBstoreidx)
10789 v.AddArg4(ptr, idx, x, mem)
10790 return true
10791 }
10792
10793
10794 for {
10795 ptr := v_0
10796 idx := v_1
10797 if v_2.Op != OpARM64MOVWUreg {
10798 break
10799 }
10800 x := v_2.Args[0]
10801 mem := v_3
10802 v.reset(OpARM64MOVBstoreidx)
10803 v.AddArg4(ptr, idx, x, mem)
10804 return true
10805 }
10806 return false
10807 }
10808 func rewriteValueARM64_OpARM64MOVDload(v *Value) bool {
10809 v_1 := v.Args[1]
10810 v_0 := v.Args[0]
10811 b := v.Block
10812 config := b.Func.Config
10813
10814
10815 for {
10816 off := auxIntToInt32(v.AuxInt)
10817 sym := auxToSym(v.Aux)
10818 ptr := v_0
10819 if v_1.Op != OpARM64FMOVDstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
10820 break
10821 }
10822 val := v_1.Args[1]
10823 if ptr != v_1.Args[0] {
10824 break
10825 }
10826 v.reset(OpARM64FMOVDfpgp)
10827 v.AddArg(val)
10828 return true
10829 }
10830
10831
10832
10833 for {
10834 off1 := auxIntToInt32(v.AuxInt)
10835 sym := auxToSym(v.Aux)
10836 if v_0.Op != OpARM64ADDconst {
10837 break
10838 }
10839 off2 := auxIntToInt64(v_0.AuxInt)
10840 ptr := v_0.Args[0]
10841 mem := v_1
10842 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
10843 break
10844 }
10845 v.reset(OpARM64MOVDload)
10846 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
10847 v.Aux = symToAux(sym)
10848 v.AddArg2(ptr, mem)
10849 return true
10850 }
10851
10852
10853
10854 for {
10855 off := auxIntToInt32(v.AuxInt)
10856 sym := auxToSym(v.Aux)
10857 if v_0.Op != OpARM64ADD {
10858 break
10859 }
10860 idx := v_0.Args[1]
10861 ptr := v_0.Args[0]
10862 mem := v_1
10863 if !(off == 0 && sym == nil) {
10864 break
10865 }
10866 v.reset(OpARM64MOVDloadidx)
10867 v.AddArg3(ptr, idx, mem)
10868 return true
10869 }
10870
10871
10872
10873 for {
10874 off := auxIntToInt32(v.AuxInt)
10875 sym := auxToSym(v.Aux)
10876 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 3 {
10877 break
10878 }
10879 idx := v_0.Args[1]
10880 ptr := v_0.Args[0]
10881 mem := v_1
10882 if !(off == 0 && sym == nil) {
10883 break
10884 }
10885 v.reset(OpARM64MOVDloadidx8)
10886 v.AddArg3(ptr, idx, mem)
10887 return true
10888 }
10889
10890
10891
10892 for {
10893 off1 := auxIntToInt32(v.AuxInt)
10894 sym1 := auxToSym(v.Aux)
10895 if v_0.Op != OpARM64MOVDaddr {
10896 break
10897 }
10898 off2 := auxIntToInt32(v_0.AuxInt)
10899 sym2 := auxToSym(v_0.Aux)
10900 ptr := v_0.Args[0]
10901 mem := v_1
10902 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
10903 break
10904 }
10905 v.reset(OpARM64MOVDload)
10906 v.AuxInt = int32ToAuxInt(off1 + off2)
10907 v.Aux = symToAux(mergeSym(sym1, sym2))
10908 v.AddArg2(ptr, mem)
10909 return true
10910 }
10911
10912
10913
10914 for {
10915 off := auxIntToInt32(v.AuxInt)
10916 sym := auxToSym(v.Aux)
10917 if v_0.Op != OpSB || !(symIsRO(sym)) {
10918 break
10919 }
10920 v.reset(OpARM64MOVDconst)
10921 v.AuxInt = int64ToAuxInt(int64(read64(sym, int64(off), config.ctxt.Arch.ByteOrder)))
10922 return true
10923 }
10924 return false
10925 }
10926 func rewriteValueARM64_OpARM64MOVDloadidx(v *Value) bool {
10927 v_2 := v.Args[2]
10928 v_1 := v.Args[1]
10929 v_0 := v.Args[0]
10930
10931
10932
10933 for {
10934 ptr := v_0
10935 if v_1.Op != OpARM64MOVDconst {
10936 break
10937 }
10938 c := auxIntToInt64(v_1.AuxInt)
10939 mem := v_2
10940 if !(is32Bit(c)) {
10941 break
10942 }
10943 v.reset(OpARM64MOVDload)
10944 v.AuxInt = int32ToAuxInt(int32(c))
10945 v.AddArg2(ptr, mem)
10946 return true
10947 }
10948
10949
10950
10951 for {
10952 if v_0.Op != OpARM64MOVDconst {
10953 break
10954 }
10955 c := auxIntToInt64(v_0.AuxInt)
10956 ptr := v_1
10957 mem := v_2
10958 if !(is32Bit(c)) {
10959 break
10960 }
10961 v.reset(OpARM64MOVDload)
10962 v.AuxInt = int32ToAuxInt(int32(c))
10963 v.AddArg2(ptr, mem)
10964 return true
10965 }
10966
10967
10968 for {
10969 ptr := v_0
10970 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 3 {
10971 break
10972 }
10973 idx := v_1.Args[0]
10974 mem := v_2
10975 v.reset(OpARM64MOVDloadidx8)
10976 v.AddArg3(ptr, idx, mem)
10977 return true
10978 }
10979
10980
10981 for {
10982 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 3 {
10983 break
10984 }
10985 idx := v_0.Args[0]
10986 ptr := v_1
10987 mem := v_2
10988 v.reset(OpARM64MOVDloadidx8)
10989 v.AddArg3(ptr, idx, mem)
10990 return true
10991 }
10992 return false
10993 }
10994 func rewriteValueARM64_OpARM64MOVDloadidx8(v *Value) bool {
10995 v_2 := v.Args[2]
10996 v_1 := v.Args[1]
10997 v_0 := v.Args[0]
10998
10999
11000
11001 for {
11002 ptr := v_0
11003 if v_1.Op != OpARM64MOVDconst {
11004 break
11005 }
11006 c := auxIntToInt64(v_1.AuxInt)
11007 mem := v_2
11008 if !(is32Bit(c << 3)) {
11009 break
11010 }
11011 v.reset(OpARM64MOVDload)
11012 v.AuxInt = int32ToAuxInt(int32(c) << 3)
11013 v.AddArg2(ptr, mem)
11014 return true
11015 }
11016 return false
11017 }
11018 func rewriteValueARM64_OpARM64MOVDnop(v *Value) bool {
11019 v_0 := v.Args[0]
11020
11021
11022 for {
11023 if v_0.Op != OpARM64MOVDconst {
11024 break
11025 }
11026 c := auxIntToInt64(v_0.AuxInt)
11027 v.reset(OpARM64MOVDconst)
11028 v.AuxInt = int64ToAuxInt(c)
11029 return true
11030 }
11031 return false
11032 }
11033 func rewriteValueARM64_OpARM64MOVDreg(v *Value) bool {
11034 v_0 := v.Args[0]
11035
11036
11037
11038 for {
11039 x := v_0
11040 if !(x.Uses == 1) {
11041 break
11042 }
11043 v.reset(OpARM64MOVDnop)
11044 v.AddArg(x)
11045 return true
11046 }
11047
11048
11049 for {
11050 if v_0.Op != OpARM64MOVDconst {
11051 break
11052 }
11053 c := auxIntToInt64(v_0.AuxInt)
11054 v.reset(OpARM64MOVDconst)
11055 v.AuxInt = int64ToAuxInt(c)
11056 return true
11057 }
11058 return false
11059 }
11060 func rewriteValueARM64_OpARM64MOVDstore(v *Value) bool {
11061 v_2 := v.Args[2]
11062 v_1 := v.Args[1]
11063 v_0 := v.Args[0]
11064 b := v.Block
11065 config := b.Func.Config
11066
11067
11068 for {
11069 off := auxIntToInt32(v.AuxInt)
11070 sym := auxToSym(v.Aux)
11071 ptr := v_0
11072 if v_1.Op != OpARM64FMOVDfpgp {
11073 break
11074 }
11075 val := v_1.Args[0]
11076 mem := v_2
11077 v.reset(OpARM64FMOVDstore)
11078 v.AuxInt = int32ToAuxInt(off)
11079 v.Aux = symToAux(sym)
11080 v.AddArg3(ptr, val, mem)
11081 return true
11082 }
11083
11084
11085
11086 for {
11087 off1 := auxIntToInt32(v.AuxInt)
11088 sym := auxToSym(v.Aux)
11089 if v_0.Op != OpARM64ADDconst {
11090 break
11091 }
11092 off2 := auxIntToInt64(v_0.AuxInt)
11093 ptr := v_0.Args[0]
11094 val := v_1
11095 mem := v_2
11096 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
11097 break
11098 }
11099 v.reset(OpARM64MOVDstore)
11100 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
11101 v.Aux = symToAux(sym)
11102 v.AddArg3(ptr, val, mem)
11103 return true
11104 }
11105
11106
11107
11108 for {
11109 off := auxIntToInt32(v.AuxInt)
11110 sym := auxToSym(v.Aux)
11111 if v_0.Op != OpARM64ADD {
11112 break
11113 }
11114 idx := v_0.Args[1]
11115 ptr := v_0.Args[0]
11116 val := v_1
11117 mem := v_2
11118 if !(off == 0 && sym == nil) {
11119 break
11120 }
11121 v.reset(OpARM64MOVDstoreidx)
11122 v.AddArg4(ptr, idx, val, mem)
11123 return true
11124 }
11125
11126
11127
11128 for {
11129 off := auxIntToInt32(v.AuxInt)
11130 sym := auxToSym(v.Aux)
11131 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 3 {
11132 break
11133 }
11134 idx := v_0.Args[1]
11135 ptr := v_0.Args[0]
11136 val := v_1
11137 mem := v_2
11138 if !(off == 0 && sym == nil) {
11139 break
11140 }
11141 v.reset(OpARM64MOVDstoreidx8)
11142 v.AddArg4(ptr, idx, val, mem)
11143 return true
11144 }
11145
11146
11147
11148 for {
11149 off1 := auxIntToInt32(v.AuxInt)
11150 sym1 := auxToSym(v.Aux)
11151 if v_0.Op != OpARM64MOVDaddr {
11152 break
11153 }
11154 off2 := auxIntToInt32(v_0.AuxInt)
11155 sym2 := auxToSym(v_0.Aux)
11156 ptr := v_0.Args[0]
11157 val := v_1
11158 mem := v_2
11159 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
11160 break
11161 }
11162 v.reset(OpARM64MOVDstore)
11163 v.AuxInt = int32ToAuxInt(off1 + off2)
11164 v.Aux = symToAux(mergeSym(sym1, sym2))
11165 v.AddArg3(ptr, val, mem)
11166 return true
11167 }
11168 return false
11169 }
11170 func rewriteValueARM64_OpARM64MOVDstoreidx(v *Value) bool {
11171 v_3 := v.Args[3]
11172 v_2 := v.Args[2]
11173 v_1 := v.Args[1]
11174 v_0 := v.Args[0]
11175
11176
11177
11178 for {
11179 ptr := v_0
11180 if v_1.Op != OpARM64MOVDconst {
11181 break
11182 }
11183 c := auxIntToInt64(v_1.AuxInt)
11184 val := v_2
11185 mem := v_3
11186 if !(is32Bit(c)) {
11187 break
11188 }
11189 v.reset(OpARM64MOVDstore)
11190 v.AuxInt = int32ToAuxInt(int32(c))
11191 v.AddArg3(ptr, val, mem)
11192 return true
11193 }
11194
11195
11196
11197 for {
11198 if v_0.Op != OpARM64MOVDconst {
11199 break
11200 }
11201 c := auxIntToInt64(v_0.AuxInt)
11202 idx := v_1
11203 val := v_2
11204 mem := v_3
11205 if !(is32Bit(c)) {
11206 break
11207 }
11208 v.reset(OpARM64MOVDstore)
11209 v.AuxInt = int32ToAuxInt(int32(c))
11210 v.AddArg3(idx, val, mem)
11211 return true
11212 }
11213
11214
11215 for {
11216 ptr := v_0
11217 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 3 {
11218 break
11219 }
11220 idx := v_1.Args[0]
11221 val := v_2
11222 mem := v_3
11223 v.reset(OpARM64MOVDstoreidx8)
11224 v.AddArg4(ptr, idx, val, mem)
11225 return true
11226 }
11227
11228
11229 for {
11230 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 3 {
11231 break
11232 }
11233 idx := v_0.Args[0]
11234 ptr := v_1
11235 val := v_2
11236 mem := v_3
11237 v.reset(OpARM64MOVDstoreidx8)
11238 v.AddArg4(ptr, idx, val, mem)
11239 return true
11240 }
11241 return false
11242 }
11243 func rewriteValueARM64_OpARM64MOVDstoreidx8(v *Value) bool {
11244 v_3 := v.Args[3]
11245 v_2 := v.Args[2]
11246 v_1 := v.Args[1]
11247 v_0 := v.Args[0]
11248
11249
11250
11251 for {
11252 ptr := v_0
11253 if v_1.Op != OpARM64MOVDconst {
11254 break
11255 }
11256 c := auxIntToInt64(v_1.AuxInt)
11257 val := v_2
11258 mem := v_3
11259 if !(is32Bit(c << 3)) {
11260 break
11261 }
11262 v.reset(OpARM64MOVDstore)
11263 v.AuxInt = int32ToAuxInt(int32(c) << 3)
11264 v.AddArg3(ptr, val, mem)
11265 return true
11266 }
11267 return false
11268 }
11269 func rewriteValueARM64_OpARM64MOVHUload(v *Value) bool {
11270 v_1 := v.Args[1]
11271 v_0 := v.Args[0]
11272 b := v.Block
11273 config := b.Func.Config
11274
11275
11276
11277 for {
11278 off1 := auxIntToInt32(v.AuxInt)
11279 sym := auxToSym(v.Aux)
11280 if v_0.Op != OpARM64ADDconst {
11281 break
11282 }
11283 off2 := auxIntToInt64(v_0.AuxInt)
11284 ptr := v_0.Args[0]
11285 mem := v_1
11286 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
11287 break
11288 }
11289 v.reset(OpARM64MOVHUload)
11290 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
11291 v.Aux = symToAux(sym)
11292 v.AddArg2(ptr, mem)
11293 return true
11294 }
11295
11296
11297
11298 for {
11299 off := auxIntToInt32(v.AuxInt)
11300 sym := auxToSym(v.Aux)
11301 if v_0.Op != OpARM64ADD {
11302 break
11303 }
11304 idx := v_0.Args[1]
11305 ptr := v_0.Args[0]
11306 mem := v_1
11307 if !(off == 0 && sym == nil) {
11308 break
11309 }
11310 v.reset(OpARM64MOVHUloadidx)
11311 v.AddArg3(ptr, idx, mem)
11312 return true
11313 }
11314
11315
11316
11317 for {
11318 off := auxIntToInt32(v.AuxInt)
11319 sym := auxToSym(v.Aux)
11320 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 1 {
11321 break
11322 }
11323 idx := v_0.Args[1]
11324 ptr := v_0.Args[0]
11325 mem := v_1
11326 if !(off == 0 && sym == nil) {
11327 break
11328 }
11329 v.reset(OpARM64MOVHUloadidx2)
11330 v.AddArg3(ptr, idx, mem)
11331 return true
11332 }
11333
11334
11335
11336 for {
11337 off1 := auxIntToInt32(v.AuxInt)
11338 sym1 := auxToSym(v.Aux)
11339 if v_0.Op != OpARM64MOVDaddr {
11340 break
11341 }
11342 off2 := auxIntToInt32(v_0.AuxInt)
11343 sym2 := auxToSym(v_0.Aux)
11344 ptr := v_0.Args[0]
11345 mem := v_1
11346 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
11347 break
11348 }
11349 v.reset(OpARM64MOVHUload)
11350 v.AuxInt = int32ToAuxInt(off1 + off2)
11351 v.Aux = symToAux(mergeSym(sym1, sym2))
11352 v.AddArg2(ptr, mem)
11353 return true
11354 }
11355
11356
11357
11358 for {
11359 off := auxIntToInt32(v.AuxInt)
11360 sym := auxToSym(v.Aux)
11361 if v_0.Op != OpSB || !(symIsRO(sym)) {
11362 break
11363 }
11364 v.reset(OpARM64MOVDconst)
11365 v.AuxInt = int64ToAuxInt(int64(read16(sym, int64(off), config.ctxt.Arch.ByteOrder)))
11366 return true
11367 }
11368 return false
11369 }
11370 func rewriteValueARM64_OpARM64MOVHUloadidx(v *Value) bool {
11371 v_2 := v.Args[2]
11372 v_1 := v.Args[1]
11373 v_0 := v.Args[0]
11374
11375
11376
11377 for {
11378 ptr := v_0
11379 if v_1.Op != OpARM64MOVDconst {
11380 break
11381 }
11382 c := auxIntToInt64(v_1.AuxInt)
11383 mem := v_2
11384 if !(is32Bit(c)) {
11385 break
11386 }
11387 v.reset(OpARM64MOVHUload)
11388 v.AuxInt = int32ToAuxInt(int32(c))
11389 v.AddArg2(ptr, mem)
11390 return true
11391 }
11392
11393
11394
11395 for {
11396 if v_0.Op != OpARM64MOVDconst {
11397 break
11398 }
11399 c := auxIntToInt64(v_0.AuxInt)
11400 ptr := v_1
11401 mem := v_2
11402 if !(is32Bit(c)) {
11403 break
11404 }
11405 v.reset(OpARM64MOVHUload)
11406 v.AuxInt = int32ToAuxInt(int32(c))
11407 v.AddArg2(ptr, mem)
11408 return true
11409 }
11410
11411
11412 for {
11413 ptr := v_0
11414 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 1 {
11415 break
11416 }
11417 idx := v_1.Args[0]
11418 mem := v_2
11419 v.reset(OpARM64MOVHUloadidx2)
11420 v.AddArg3(ptr, idx, mem)
11421 return true
11422 }
11423
11424
11425 for {
11426 ptr := v_0
11427 if v_1.Op != OpARM64ADD {
11428 break
11429 }
11430 idx := v_1.Args[1]
11431 if idx != v_1.Args[0] {
11432 break
11433 }
11434 mem := v_2
11435 v.reset(OpARM64MOVHUloadidx2)
11436 v.AddArg3(ptr, idx, mem)
11437 return true
11438 }
11439
11440
11441 for {
11442 if v_0.Op != OpARM64ADD {
11443 break
11444 }
11445 idx := v_0.Args[1]
11446 if idx != v_0.Args[0] {
11447 break
11448 }
11449 ptr := v_1
11450 mem := v_2
11451 v.reset(OpARM64MOVHUloadidx2)
11452 v.AddArg3(ptr, idx, mem)
11453 return true
11454 }
11455 return false
11456 }
11457 func rewriteValueARM64_OpARM64MOVHUloadidx2(v *Value) bool {
11458 v_2 := v.Args[2]
11459 v_1 := v.Args[1]
11460 v_0 := v.Args[0]
11461
11462
11463
11464 for {
11465 ptr := v_0
11466 if v_1.Op != OpARM64MOVDconst {
11467 break
11468 }
11469 c := auxIntToInt64(v_1.AuxInt)
11470 mem := v_2
11471 if !(is32Bit(c << 1)) {
11472 break
11473 }
11474 v.reset(OpARM64MOVHUload)
11475 v.AuxInt = int32ToAuxInt(int32(c) << 1)
11476 v.AddArg2(ptr, mem)
11477 return true
11478 }
11479 return false
11480 }
11481 func rewriteValueARM64_OpARM64MOVHUreg(v *Value) bool {
11482 v_0 := v.Args[0]
11483
11484
11485 for {
11486 if v_0.Op != OpARM64ANDconst {
11487 break
11488 }
11489 c := auxIntToInt64(v_0.AuxInt)
11490 x := v_0.Args[0]
11491 v.reset(OpARM64ANDconst)
11492 v.AuxInt = int64ToAuxInt(c & (1<<16 - 1))
11493 v.AddArg(x)
11494 return true
11495 }
11496
11497
11498 for {
11499 if v_0.Op != OpARM64MOVDconst {
11500 break
11501 }
11502 c := auxIntToInt64(v_0.AuxInt)
11503 v.reset(OpARM64MOVDconst)
11504 v.AuxInt = int64ToAuxInt(int64(uint16(c)))
11505 return true
11506 }
11507
11508
11509
11510 for {
11511 x := v_0
11512 if !(v.Type.Size() <= 2) {
11513 break
11514 }
11515 v.copyOf(x)
11516 return true
11517 }
11518
11519
11520
11521 for {
11522 if v_0.Op != OpARM64SLLconst {
11523 break
11524 }
11525 lc := auxIntToInt64(v_0.AuxInt)
11526 if !(lc >= 16) {
11527 break
11528 }
11529 v.reset(OpARM64MOVDconst)
11530 v.AuxInt = int64ToAuxInt(0)
11531 return true
11532 }
11533
11534
11535
11536 for {
11537 if v_0.Op != OpARM64SLLconst {
11538 break
11539 }
11540 lc := auxIntToInt64(v_0.AuxInt)
11541 x := v_0.Args[0]
11542 if !(lc < 16) {
11543 break
11544 }
11545 v.reset(OpARM64UBFIZ)
11546 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, 16-lc))
11547 v.AddArg(x)
11548 return true
11549 }
11550
11551
11552
11553 for {
11554 if v_0.Op != OpARM64SRLconst {
11555 break
11556 }
11557 rc := auxIntToInt64(v_0.AuxInt)
11558 x := v_0.Args[0]
11559 if !(rc < 16) {
11560 break
11561 }
11562 v.reset(OpARM64UBFX)
11563 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 16))
11564 v.AddArg(x)
11565 return true
11566 }
11567
11568
11569
11570 for {
11571 if v_0.Op != OpARM64UBFX {
11572 break
11573 }
11574 bfc := auxIntToArm64BitField(v_0.AuxInt)
11575 x := v_0.Args[0]
11576 if !(bfc.width() <= 16) {
11577 break
11578 }
11579 v.reset(OpARM64UBFX)
11580 v.AuxInt = arm64BitFieldToAuxInt(bfc)
11581 v.AddArg(x)
11582 return true
11583 }
11584 return false
11585 }
11586 func rewriteValueARM64_OpARM64MOVHload(v *Value) bool {
11587 v_1 := v.Args[1]
11588 v_0 := v.Args[0]
11589 b := v.Block
11590 config := b.Func.Config
11591
11592
11593
11594 for {
11595 off1 := auxIntToInt32(v.AuxInt)
11596 sym := auxToSym(v.Aux)
11597 if v_0.Op != OpARM64ADDconst {
11598 break
11599 }
11600 off2 := auxIntToInt64(v_0.AuxInt)
11601 ptr := v_0.Args[0]
11602 mem := v_1
11603 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
11604 break
11605 }
11606 v.reset(OpARM64MOVHload)
11607 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
11608 v.Aux = symToAux(sym)
11609 v.AddArg2(ptr, mem)
11610 return true
11611 }
11612
11613
11614
11615 for {
11616 off := auxIntToInt32(v.AuxInt)
11617 sym := auxToSym(v.Aux)
11618 if v_0.Op != OpARM64ADD {
11619 break
11620 }
11621 idx := v_0.Args[1]
11622 ptr := v_0.Args[0]
11623 mem := v_1
11624 if !(off == 0 && sym == nil) {
11625 break
11626 }
11627 v.reset(OpARM64MOVHloadidx)
11628 v.AddArg3(ptr, idx, mem)
11629 return true
11630 }
11631
11632
11633
11634 for {
11635 off := auxIntToInt32(v.AuxInt)
11636 sym := auxToSym(v.Aux)
11637 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 1 {
11638 break
11639 }
11640 idx := v_0.Args[1]
11641 ptr := v_0.Args[0]
11642 mem := v_1
11643 if !(off == 0 && sym == nil) {
11644 break
11645 }
11646 v.reset(OpARM64MOVHloadidx2)
11647 v.AddArg3(ptr, idx, mem)
11648 return true
11649 }
11650
11651
11652
11653 for {
11654 off1 := auxIntToInt32(v.AuxInt)
11655 sym1 := auxToSym(v.Aux)
11656 if v_0.Op != OpARM64MOVDaddr {
11657 break
11658 }
11659 off2 := auxIntToInt32(v_0.AuxInt)
11660 sym2 := auxToSym(v_0.Aux)
11661 ptr := v_0.Args[0]
11662 mem := v_1
11663 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
11664 break
11665 }
11666 v.reset(OpARM64MOVHload)
11667 v.AuxInt = int32ToAuxInt(off1 + off2)
11668 v.Aux = symToAux(mergeSym(sym1, sym2))
11669 v.AddArg2(ptr, mem)
11670 return true
11671 }
11672
11673
11674
11675 for {
11676 off := auxIntToInt32(v.AuxInt)
11677 sym := auxToSym(v.Aux)
11678 if v_0.Op != OpSB || !(symIsRO(sym)) {
11679 break
11680 }
11681 v.reset(OpARM64MOVDconst)
11682 v.AuxInt = int64ToAuxInt(int64(int16(read16(sym, int64(off), config.ctxt.Arch.ByteOrder))))
11683 return true
11684 }
11685 return false
11686 }
11687 func rewriteValueARM64_OpARM64MOVHloadidx(v *Value) bool {
11688 v_2 := v.Args[2]
11689 v_1 := v.Args[1]
11690 v_0 := v.Args[0]
11691
11692
11693
11694 for {
11695 ptr := v_0
11696 if v_1.Op != OpARM64MOVDconst {
11697 break
11698 }
11699 c := auxIntToInt64(v_1.AuxInt)
11700 mem := v_2
11701 if !(is32Bit(c)) {
11702 break
11703 }
11704 v.reset(OpARM64MOVHload)
11705 v.AuxInt = int32ToAuxInt(int32(c))
11706 v.AddArg2(ptr, mem)
11707 return true
11708 }
11709
11710
11711
11712 for {
11713 if v_0.Op != OpARM64MOVDconst {
11714 break
11715 }
11716 c := auxIntToInt64(v_0.AuxInt)
11717 ptr := v_1
11718 mem := v_2
11719 if !(is32Bit(c)) {
11720 break
11721 }
11722 v.reset(OpARM64MOVHload)
11723 v.AuxInt = int32ToAuxInt(int32(c))
11724 v.AddArg2(ptr, mem)
11725 return true
11726 }
11727
11728
11729 for {
11730 ptr := v_0
11731 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 1 {
11732 break
11733 }
11734 idx := v_1.Args[0]
11735 mem := v_2
11736 v.reset(OpARM64MOVHloadidx2)
11737 v.AddArg3(ptr, idx, mem)
11738 return true
11739 }
11740
11741
11742 for {
11743 ptr := v_0
11744 if v_1.Op != OpARM64ADD {
11745 break
11746 }
11747 idx := v_1.Args[1]
11748 if idx != v_1.Args[0] {
11749 break
11750 }
11751 mem := v_2
11752 v.reset(OpARM64MOVHloadidx2)
11753 v.AddArg3(ptr, idx, mem)
11754 return true
11755 }
11756
11757
11758 for {
11759 if v_0.Op != OpARM64ADD {
11760 break
11761 }
11762 idx := v_0.Args[1]
11763 if idx != v_0.Args[0] {
11764 break
11765 }
11766 ptr := v_1
11767 mem := v_2
11768 v.reset(OpARM64MOVHloadidx2)
11769 v.AddArg3(ptr, idx, mem)
11770 return true
11771 }
11772 return false
11773 }
11774 func rewriteValueARM64_OpARM64MOVHloadidx2(v *Value) bool {
11775 v_2 := v.Args[2]
11776 v_1 := v.Args[1]
11777 v_0 := v.Args[0]
11778
11779
11780
11781 for {
11782 ptr := v_0
11783 if v_1.Op != OpARM64MOVDconst {
11784 break
11785 }
11786 c := auxIntToInt64(v_1.AuxInt)
11787 mem := v_2
11788 if !(is32Bit(c << 1)) {
11789 break
11790 }
11791 v.reset(OpARM64MOVHload)
11792 v.AuxInt = int32ToAuxInt(int32(c) << 1)
11793 v.AddArg2(ptr, mem)
11794 return true
11795 }
11796 return false
11797 }
11798 func rewriteValueARM64_OpARM64MOVHreg(v *Value) bool {
11799 v_0 := v.Args[0]
11800
11801
11802 for {
11803 if v_0.Op != OpARM64MOVDconst {
11804 break
11805 }
11806 c := auxIntToInt64(v_0.AuxInt)
11807 v.reset(OpARM64MOVDconst)
11808 v.AuxInt = int64ToAuxInt(int64(int16(c)))
11809 return true
11810 }
11811
11812
11813
11814 for {
11815 x := v_0
11816 if !(v.Type.Size() <= 2) {
11817 break
11818 }
11819 v.copyOf(x)
11820 return true
11821 }
11822
11823
11824
11825 for {
11826 t := v.Type
11827 if v_0.Op != OpARM64ANDconst {
11828 break
11829 }
11830 c := auxIntToInt64(v_0.AuxInt)
11831 x := v_0.Args[0]
11832 if !(uint64(c)&uint64(0xffffffffffff8000) == 0) {
11833 break
11834 }
11835 v.reset(OpARM64ANDconst)
11836 v.Type = t
11837 v.AuxInt = int64ToAuxInt(c)
11838 v.AddArg(x)
11839 return true
11840 }
11841
11842
11843
11844 for {
11845 if v_0.Op != OpARM64SLLconst {
11846 break
11847 }
11848 lc := auxIntToInt64(v_0.AuxInt)
11849 x := v_0.Args[0]
11850 if !(lc < 16) {
11851 break
11852 }
11853 v.reset(OpARM64SBFIZ)
11854 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, 16-lc))
11855 v.AddArg(x)
11856 return true
11857 }
11858
11859
11860
11861 for {
11862 if v_0.Op != OpARM64SBFX {
11863 break
11864 }
11865 bfc := auxIntToArm64BitField(v_0.AuxInt)
11866 x := v_0.Args[0]
11867 if !(bfc.width() <= 16) {
11868 break
11869 }
11870 v.reset(OpARM64SBFX)
11871 v.AuxInt = arm64BitFieldToAuxInt(bfc)
11872 v.AddArg(x)
11873 return true
11874 }
11875 return false
11876 }
11877 func rewriteValueARM64_OpARM64MOVHstore(v *Value) bool {
11878 v_2 := v.Args[2]
11879 v_1 := v.Args[1]
11880 v_0 := v.Args[0]
11881 b := v.Block
11882 config := b.Func.Config
11883
11884
11885
11886 for {
11887 off1 := auxIntToInt32(v.AuxInt)
11888 sym := auxToSym(v.Aux)
11889 if v_0.Op != OpARM64ADDconst {
11890 break
11891 }
11892 off2 := auxIntToInt64(v_0.AuxInt)
11893 ptr := v_0.Args[0]
11894 val := v_1
11895 mem := v_2
11896 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
11897 break
11898 }
11899 v.reset(OpARM64MOVHstore)
11900 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
11901 v.Aux = symToAux(sym)
11902 v.AddArg3(ptr, val, mem)
11903 return true
11904 }
11905
11906
11907
11908 for {
11909 off := auxIntToInt32(v.AuxInt)
11910 sym := auxToSym(v.Aux)
11911 if v_0.Op != OpARM64ADD {
11912 break
11913 }
11914 idx := v_0.Args[1]
11915 ptr := v_0.Args[0]
11916 val := v_1
11917 mem := v_2
11918 if !(off == 0 && sym == nil) {
11919 break
11920 }
11921 v.reset(OpARM64MOVHstoreidx)
11922 v.AddArg4(ptr, idx, val, mem)
11923 return true
11924 }
11925
11926
11927
11928 for {
11929 off := auxIntToInt32(v.AuxInt)
11930 sym := auxToSym(v.Aux)
11931 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 1 {
11932 break
11933 }
11934 idx := v_0.Args[1]
11935 ptr := v_0.Args[0]
11936 val := v_1
11937 mem := v_2
11938 if !(off == 0 && sym == nil) {
11939 break
11940 }
11941 v.reset(OpARM64MOVHstoreidx2)
11942 v.AddArg4(ptr, idx, val, mem)
11943 return true
11944 }
11945
11946
11947
11948 for {
11949 off1 := auxIntToInt32(v.AuxInt)
11950 sym1 := auxToSym(v.Aux)
11951 if v_0.Op != OpARM64MOVDaddr {
11952 break
11953 }
11954 off2 := auxIntToInt32(v_0.AuxInt)
11955 sym2 := auxToSym(v_0.Aux)
11956 ptr := v_0.Args[0]
11957 val := v_1
11958 mem := v_2
11959 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
11960 break
11961 }
11962 v.reset(OpARM64MOVHstore)
11963 v.AuxInt = int32ToAuxInt(off1 + off2)
11964 v.Aux = symToAux(mergeSym(sym1, sym2))
11965 v.AddArg3(ptr, val, mem)
11966 return true
11967 }
11968
11969
11970 for {
11971 off := auxIntToInt32(v.AuxInt)
11972 sym := auxToSym(v.Aux)
11973 ptr := v_0
11974 if v_1.Op != OpARM64MOVHreg {
11975 break
11976 }
11977 x := v_1.Args[0]
11978 mem := v_2
11979 v.reset(OpARM64MOVHstore)
11980 v.AuxInt = int32ToAuxInt(off)
11981 v.Aux = symToAux(sym)
11982 v.AddArg3(ptr, x, mem)
11983 return true
11984 }
11985
11986
11987 for {
11988 off := auxIntToInt32(v.AuxInt)
11989 sym := auxToSym(v.Aux)
11990 ptr := v_0
11991 if v_1.Op != OpARM64MOVHUreg {
11992 break
11993 }
11994 x := v_1.Args[0]
11995 mem := v_2
11996 v.reset(OpARM64MOVHstore)
11997 v.AuxInt = int32ToAuxInt(off)
11998 v.Aux = symToAux(sym)
11999 v.AddArg3(ptr, x, mem)
12000 return true
12001 }
12002
12003
12004 for {
12005 off := auxIntToInt32(v.AuxInt)
12006 sym := auxToSym(v.Aux)
12007 ptr := v_0
12008 if v_1.Op != OpARM64MOVWreg {
12009 break
12010 }
12011 x := v_1.Args[0]
12012 mem := v_2
12013 v.reset(OpARM64MOVHstore)
12014 v.AuxInt = int32ToAuxInt(off)
12015 v.Aux = symToAux(sym)
12016 v.AddArg3(ptr, x, mem)
12017 return true
12018 }
12019
12020
12021 for {
12022 off := auxIntToInt32(v.AuxInt)
12023 sym := auxToSym(v.Aux)
12024 ptr := v_0
12025 if v_1.Op != OpARM64MOVWUreg {
12026 break
12027 }
12028 x := v_1.Args[0]
12029 mem := v_2
12030 v.reset(OpARM64MOVHstore)
12031 v.AuxInt = int32ToAuxInt(off)
12032 v.Aux = symToAux(sym)
12033 v.AddArg3(ptr, x, mem)
12034 return true
12035 }
12036 return false
12037 }
12038 func rewriteValueARM64_OpARM64MOVHstoreidx(v *Value) bool {
12039 v_3 := v.Args[3]
12040 v_2 := v.Args[2]
12041 v_1 := v.Args[1]
12042 v_0 := v.Args[0]
12043
12044
12045
12046 for {
12047 ptr := v_0
12048 if v_1.Op != OpARM64MOVDconst {
12049 break
12050 }
12051 c := auxIntToInt64(v_1.AuxInt)
12052 val := v_2
12053 mem := v_3
12054 if !(is32Bit(c)) {
12055 break
12056 }
12057 v.reset(OpARM64MOVHstore)
12058 v.AuxInt = int32ToAuxInt(int32(c))
12059 v.AddArg3(ptr, val, mem)
12060 return true
12061 }
12062
12063
12064
12065 for {
12066 if v_0.Op != OpARM64MOVDconst {
12067 break
12068 }
12069 c := auxIntToInt64(v_0.AuxInt)
12070 idx := v_1
12071 val := v_2
12072 mem := v_3
12073 if !(is32Bit(c)) {
12074 break
12075 }
12076 v.reset(OpARM64MOVHstore)
12077 v.AuxInt = int32ToAuxInt(int32(c))
12078 v.AddArg3(idx, val, mem)
12079 return true
12080 }
12081
12082
12083 for {
12084 ptr := v_0
12085 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 1 {
12086 break
12087 }
12088 idx := v_1.Args[0]
12089 val := v_2
12090 mem := v_3
12091 v.reset(OpARM64MOVHstoreidx2)
12092 v.AddArg4(ptr, idx, val, mem)
12093 return true
12094 }
12095
12096
12097 for {
12098 ptr := v_0
12099 if v_1.Op != OpARM64ADD {
12100 break
12101 }
12102 idx := v_1.Args[1]
12103 if idx != v_1.Args[0] {
12104 break
12105 }
12106 val := v_2
12107 mem := v_3
12108 v.reset(OpARM64MOVHstoreidx2)
12109 v.AddArg4(ptr, idx, val, mem)
12110 return true
12111 }
12112
12113
12114 for {
12115 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 1 {
12116 break
12117 }
12118 idx := v_0.Args[0]
12119 ptr := v_1
12120 val := v_2
12121 mem := v_3
12122 v.reset(OpARM64MOVHstoreidx2)
12123 v.AddArg4(ptr, idx, val, mem)
12124 return true
12125 }
12126
12127
12128 for {
12129 if v_0.Op != OpARM64ADD {
12130 break
12131 }
12132 idx := v_0.Args[1]
12133 if idx != v_0.Args[0] {
12134 break
12135 }
12136 ptr := v_1
12137 val := v_2
12138 mem := v_3
12139 v.reset(OpARM64MOVHstoreidx2)
12140 v.AddArg4(ptr, idx, val, mem)
12141 return true
12142 }
12143
12144
12145 for {
12146 ptr := v_0
12147 idx := v_1
12148 if v_2.Op != OpARM64MOVHreg {
12149 break
12150 }
12151 x := v_2.Args[0]
12152 mem := v_3
12153 v.reset(OpARM64MOVHstoreidx)
12154 v.AddArg4(ptr, idx, x, mem)
12155 return true
12156 }
12157
12158
12159 for {
12160 ptr := v_0
12161 idx := v_1
12162 if v_2.Op != OpARM64MOVHUreg {
12163 break
12164 }
12165 x := v_2.Args[0]
12166 mem := v_3
12167 v.reset(OpARM64MOVHstoreidx)
12168 v.AddArg4(ptr, idx, x, mem)
12169 return true
12170 }
12171
12172
12173 for {
12174 ptr := v_0
12175 idx := v_1
12176 if v_2.Op != OpARM64MOVWreg {
12177 break
12178 }
12179 x := v_2.Args[0]
12180 mem := v_3
12181 v.reset(OpARM64MOVHstoreidx)
12182 v.AddArg4(ptr, idx, x, mem)
12183 return true
12184 }
12185
12186
12187 for {
12188 ptr := v_0
12189 idx := v_1
12190 if v_2.Op != OpARM64MOVWUreg {
12191 break
12192 }
12193 x := v_2.Args[0]
12194 mem := v_3
12195 v.reset(OpARM64MOVHstoreidx)
12196 v.AddArg4(ptr, idx, x, mem)
12197 return true
12198 }
12199 return false
12200 }
12201 func rewriteValueARM64_OpARM64MOVHstoreidx2(v *Value) bool {
12202 v_3 := v.Args[3]
12203 v_2 := v.Args[2]
12204 v_1 := v.Args[1]
12205 v_0 := v.Args[0]
12206
12207
12208
12209 for {
12210 ptr := v_0
12211 if v_1.Op != OpARM64MOVDconst {
12212 break
12213 }
12214 c := auxIntToInt64(v_1.AuxInt)
12215 val := v_2
12216 mem := v_3
12217 if !(is32Bit(c << 1)) {
12218 break
12219 }
12220 v.reset(OpARM64MOVHstore)
12221 v.AuxInt = int32ToAuxInt(int32(c) << 1)
12222 v.AddArg3(ptr, val, mem)
12223 return true
12224 }
12225
12226
12227 for {
12228 ptr := v_0
12229 idx := v_1
12230 if v_2.Op != OpARM64MOVHreg {
12231 break
12232 }
12233 x := v_2.Args[0]
12234 mem := v_3
12235 v.reset(OpARM64MOVHstoreidx2)
12236 v.AddArg4(ptr, idx, x, mem)
12237 return true
12238 }
12239
12240
12241 for {
12242 ptr := v_0
12243 idx := v_1
12244 if v_2.Op != OpARM64MOVHUreg {
12245 break
12246 }
12247 x := v_2.Args[0]
12248 mem := v_3
12249 v.reset(OpARM64MOVHstoreidx2)
12250 v.AddArg4(ptr, idx, x, mem)
12251 return true
12252 }
12253
12254
12255 for {
12256 ptr := v_0
12257 idx := v_1
12258 if v_2.Op != OpARM64MOVWreg {
12259 break
12260 }
12261 x := v_2.Args[0]
12262 mem := v_3
12263 v.reset(OpARM64MOVHstoreidx2)
12264 v.AddArg4(ptr, idx, x, mem)
12265 return true
12266 }
12267
12268
12269 for {
12270 ptr := v_0
12271 idx := v_1
12272 if v_2.Op != OpARM64MOVWUreg {
12273 break
12274 }
12275 x := v_2.Args[0]
12276 mem := v_3
12277 v.reset(OpARM64MOVHstoreidx2)
12278 v.AddArg4(ptr, idx, x, mem)
12279 return true
12280 }
12281 return false
12282 }
12283 func rewriteValueARM64_OpARM64MOVWUload(v *Value) bool {
12284 v_1 := v.Args[1]
12285 v_0 := v.Args[0]
12286 b := v.Block
12287 config := b.Func.Config
12288
12289
12290 for {
12291 off := auxIntToInt32(v.AuxInt)
12292 sym := auxToSym(v.Aux)
12293 ptr := v_0
12294 if v_1.Op != OpARM64FMOVSstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
12295 break
12296 }
12297 val := v_1.Args[1]
12298 if ptr != v_1.Args[0] {
12299 break
12300 }
12301 v.reset(OpARM64FMOVSfpgp)
12302 v.AddArg(val)
12303 return true
12304 }
12305
12306
12307
12308 for {
12309 off1 := auxIntToInt32(v.AuxInt)
12310 sym := auxToSym(v.Aux)
12311 if v_0.Op != OpARM64ADDconst {
12312 break
12313 }
12314 off2 := auxIntToInt64(v_0.AuxInt)
12315 ptr := v_0.Args[0]
12316 mem := v_1
12317 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
12318 break
12319 }
12320 v.reset(OpARM64MOVWUload)
12321 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
12322 v.Aux = symToAux(sym)
12323 v.AddArg2(ptr, mem)
12324 return true
12325 }
12326
12327
12328
12329 for {
12330 off := auxIntToInt32(v.AuxInt)
12331 sym := auxToSym(v.Aux)
12332 if v_0.Op != OpARM64ADD {
12333 break
12334 }
12335 idx := v_0.Args[1]
12336 ptr := v_0.Args[0]
12337 mem := v_1
12338 if !(off == 0 && sym == nil) {
12339 break
12340 }
12341 v.reset(OpARM64MOVWUloadidx)
12342 v.AddArg3(ptr, idx, mem)
12343 return true
12344 }
12345
12346
12347
12348 for {
12349 off := auxIntToInt32(v.AuxInt)
12350 sym := auxToSym(v.Aux)
12351 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 2 {
12352 break
12353 }
12354 idx := v_0.Args[1]
12355 ptr := v_0.Args[0]
12356 mem := v_1
12357 if !(off == 0 && sym == nil) {
12358 break
12359 }
12360 v.reset(OpARM64MOVWUloadidx4)
12361 v.AddArg3(ptr, idx, mem)
12362 return true
12363 }
12364
12365
12366
12367 for {
12368 off1 := auxIntToInt32(v.AuxInt)
12369 sym1 := auxToSym(v.Aux)
12370 if v_0.Op != OpARM64MOVDaddr {
12371 break
12372 }
12373 off2 := auxIntToInt32(v_0.AuxInt)
12374 sym2 := auxToSym(v_0.Aux)
12375 ptr := v_0.Args[0]
12376 mem := v_1
12377 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
12378 break
12379 }
12380 v.reset(OpARM64MOVWUload)
12381 v.AuxInt = int32ToAuxInt(off1 + off2)
12382 v.Aux = symToAux(mergeSym(sym1, sym2))
12383 v.AddArg2(ptr, mem)
12384 return true
12385 }
12386
12387
12388
12389 for {
12390 off := auxIntToInt32(v.AuxInt)
12391 sym := auxToSym(v.Aux)
12392 if v_0.Op != OpSB || !(symIsRO(sym)) {
12393 break
12394 }
12395 v.reset(OpARM64MOVDconst)
12396 v.AuxInt = int64ToAuxInt(int64(read32(sym, int64(off), config.ctxt.Arch.ByteOrder)))
12397 return true
12398 }
12399 return false
12400 }
12401 func rewriteValueARM64_OpARM64MOVWUloadidx(v *Value) bool {
12402 v_2 := v.Args[2]
12403 v_1 := v.Args[1]
12404 v_0 := v.Args[0]
12405
12406
12407
12408 for {
12409 ptr := v_0
12410 if v_1.Op != OpARM64MOVDconst {
12411 break
12412 }
12413 c := auxIntToInt64(v_1.AuxInt)
12414 mem := v_2
12415 if !(is32Bit(c)) {
12416 break
12417 }
12418 v.reset(OpARM64MOVWUload)
12419 v.AuxInt = int32ToAuxInt(int32(c))
12420 v.AddArg2(ptr, mem)
12421 return true
12422 }
12423
12424
12425
12426 for {
12427 if v_0.Op != OpARM64MOVDconst {
12428 break
12429 }
12430 c := auxIntToInt64(v_0.AuxInt)
12431 ptr := v_1
12432 mem := v_2
12433 if !(is32Bit(c)) {
12434 break
12435 }
12436 v.reset(OpARM64MOVWUload)
12437 v.AuxInt = int32ToAuxInt(int32(c))
12438 v.AddArg2(ptr, mem)
12439 return true
12440 }
12441
12442
12443 for {
12444 ptr := v_0
12445 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 2 {
12446 break
12447 }
12448 idx := v_1.Args[0]
12449 mem := v_2
12450 v.reset(OpARM64MOVWUloadidx4)
12451 v.AddArg3(ptr, idx, mem)
12452 return true
12453 }
12454
12455
12456 for {
12457 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 2 {
12458 break
12459 }
12460 idx := v_0.Args[0]
12461 ptr := v_1
12462 mem := v_2
12463 v.reset(OpARM64MOVWUloadidx4)
12464 v.AddArg3(ptr, idx, mem)
12465 return true
12466 }
12467 return false
12468 }
12469 func rewriteValueARM64_OpARM64MOVWUloadidx4(v *Value) bool {
12470 v_2 := v.Args[2]
12471 v_1 := v.Args[1]
12472 v_0 := v.Args[0]
12473
12474
12475
12476 for {
12477 ptr := v_0
12478 if v_1.Op != OpARM64MOVDconst {
12479 break
12480 }
12481 c := auxIntToInt64(v_1.AuxInt)
12482 mem := v_2
12483 if !(is32Bit(c << 2)) {
12484 break
12485 }
12486 v.reset(OpARM64MOVWUload)
12487 v.AuxInt = int32ToAuxInt(int32(c) << 2)
12488 v.AddArg2(ptr, mem)
12489 return true
12490 }
12491 return false
12492 }
12493 func rewriteValueARM64_OpARM64MOVWUreg(v *Value) bool {
12494 v_0 := v.Args[0]
12495
12496
12497 for {
12498 if v_0.Op != OpARM64ANDconst {
12499 break
12500 }
12501 c := auxIntToInt64(v_0.AuxInt)
12502 x := v_0.Args[0]
12503 v.reset(OpARM64ANDconst)
12504 v.AuxInt = int64ToAuxInt(c & (1<<32 - 1))
12505 v.AddArg(x)
12506 return true
12507 }
12508
12509
12510 for {
12511 if v_0.Op != OpARM64MOVDconst {
12512 break
12513 }
12514 c := auxIntToInt64(v_0.AuxInt)
12515 v.reset(OpARM64MOVDconst)
12516 v.AuxInt = int64ToAuxInt(int64(uint32(c)))
12517 return true
12518 }
12519
12520
12521
12522 for {
12523 x := v_0
12524 if !(v.Type.Size() <= 4) {
12525 break
12526 }
12527 v.copyOf(x)
12528 return true
12529 }
12530
12531
12532
12533 for {
12534 if v_0.Op != OpARM64SLLconst {
12535 break
12536 }
12537 lc := auxIntToInt64(v_0.AuxInt)
12538 if !(lc >= 32) {
12539 break
12540 }
12541 v.reset(OpARM64MOVDconst)
12542 v.AuxInt = int64ToAuxInt(0)
12543 return true
12544 }
12545
12546
12547
12548 for {
12549 if v_0.Op != OpARM64SLLconst {
12550 break
12551 }
12552 lc := auxIntToInt64(v_0.AuxInt)
12553 x := v_0.Args[0]
12554 if !(lc < 32) {
12555 break
12556 }
12557 v.reset(OpARM64UBFIZ)
12558 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, 32-lc))
12559 v.AddArg(x)
12560 return true
12561 }
12562
12563
12564
12565 for {
12566 if v_0.Op != OpARM64SRLconst {
12567 break
12568 }
12569 rc := auxIntToInt64(v_0.AuxInt)
12570 x := v_0.Args[0]
12571 if !(rc < 32) {
12572 break
12573 }
12574 v.reset(OpARM64UBFX)
12575 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 32))
12576 v.AddArg(x)
12577 return true
12578 }
12579
12580
12581
12582 for {
12583 if v_0.Op != OpARM64UBFX {
12584 break
12585 }
12586 bfc := auxIntToArm64BitField(v_0.AuxInt)
12587 x := v_0.Args[0]
12588 if !(bfc.width() <= 32) {
12589 break
12590 }
12591 v.reset(OpARM64UBFX)
12592 v.AuxInt = arm64BitFieldToAuxInt(bfc)
12593 v.AddArg(x)
12594 return true
12595 }
12596 return false
12597 }
12598 func rewriteValueARM64_OpARM64MOVWload(v *Value) bool {
12599 v_1 := v.Args[1]
12600 v_0 := v.Args[0]
12601 b := v.Block
12602 config := b.Func.Config
12603
12604
12605
12606 for {
12607 off1 := auxIntToInt32(v.AuxInt)
12608 sym := auxToSym(v.Aux)
12609 if v_0.Op != OpARM64ADDconst {
12610 break
12611 }
12612 off2 := auxIntToInt64(v_0.AuxInt)
12613 ptr := v_0.Args[0]
12614 mem := v_1
12615 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
12616 break
12617 }
12618 v.reset(OpARM64MOVWload)
12619 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
12620 v.Aux = symToAux(sym)
12621 v.AddArg2(ptr, mem)
12622 return true
12623 }
12624
12625
12626
12627 for {
12628 off := auxIntToInt32(v.AuxInt)
12629 sym := auxToSym(v.Aux)
12630 if v_0.Op != OpARM64ADD {
12631 break
12632 }
12633 idx := v_0.Args[1]
12634 ptr := v_0.Args[0]
12635 mem := v_1
12636 if !(off == 0 && sym == nil) {
12637 break
12638 }
12639 v.reset(OpARM64MOVWloadidx)
12640 v.AddArg3(ptr, idx, mem)
12641 return true
12642 }
12643
12644
12645
12646 for {
12647 off := auxIntToInt32(v.AuxInt)
12648 sym := auxToSym(v.Aux)
12649 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 2 {
12650 break
12651 }
12652 idx := v_0.Args[1]
12653 ptr := v_0.Args[0]
12654 mem := v_1
12655 if !(off == 0 && sym == nil) {
12656 break
12657 }
12658 v.reset(OpARM64MOVWloadidx4)
12659 v.AddArg3(ptr, idx, mem)
12660 return true
12661 }
12662
12663
12664
12665 for {
12666 off1 := auxIntToInt32(v.AuxInt)
12667 sym1 := auxToSym(v.Aux)
12668 if v_0.Op != OpARM64MOVDaddr {
12669 break
12670 }
12671 off2 := auxIntToInt32(v_0.AuxInt)
12672 sym2 := auxToSym(v_0.Aux)
12673 ptr := v_0.Args[0]
12674 mem := v_1
12675 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
12676 break
12677 }
12678 v.reset(OpARM64MOVWload)
12679 v.AuxInt = int32ToAuxInt(off1 + off2)
12680 v.Aux = symToAux(mergeSym(sym1, sym2))
12681 v.AddArg2(ptr, mem)
12682 return true
12683 }
12684
12685
12686
12687 for {
12688 off := auxIntToInt32(v.AuxInt)
12689 sym := auxToSym(v.Aux)
12690 if v_0.Op != OpSB || !(symIsRO(sym)) {
12691 break
12692 }
12693 v.reset(OpARM64MOVDconst)
12694 v.AuxInt = int64ToAuxInt(int64(int32(read32(sym, int64(off), config.ctxt.Arch.ByteOrder))))
12695 return true
12696 }
12697 return false
12698 }
12699 func rewriteValueARM64_OpARM64MOVWloadidx(v *Value) bool {
12700 v_2 := v.Args[2]
12701 v_1 := v.Args[1]
12702 v_0 := v.Args[0]
12703
12704
12705
12706 for {
12707 ptr := v_0
12708 if v_1.Op != OpARM64MOVDconst {
12709 break
12710 }
12711 c := auxIntToInt64(v_1.AuxInt)
12712 mem := v_2
12713 if !(is32Bit(c)) {
12714 break
12715 }
12716 v.reset(OpARM64MOVWload)
12717 v.AuxInt = int32ToAuxInt(int32(c))
12718 v.AddArg2(ptr, mem)
12719 return true
12720 }
12721
12722
12723
12724 for {
12725 if v_0.Op != OpARM64MOVDconst {
12726 break
12727 }
12728 c := auxIntToInt64(v_0.AuxInt)
12729 ptr := v_1
12730 mem := v_2
12731 if !(is32Bit(c)) {
12732 break
12733 }
12734 v.reset(OpARM64MOVWload)
12735 v.AuxInt = int32ToAuxInt(int32(c))
12736 v.AddArg2(ptr, mem)
12737 return true
12738 }
12739
12740
12741 for {
12742 ptr := v_0
12743 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 2 {
12744 break
12745 }
12746 idx := v_1.Args[0]
12747 mem := v_2
12748 v.reset(OpARM64MOVWloadidx4)
12749 v.AddArg3(ptr, idx, mem)
12750 return true
12751 }
12752
12753
12754 for {
12755 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 2 {
12756 break
12757 }
12758 idx := v_0.Args[0]
12759 ptr := v_1
12760 mem := v_2
12761 v.reset(OpARM64MOVWloadidx4)
12762 v.AddArg3(ptr, idx, mem)
12763 return true
12764 }
12765 return false
12766 }
12767 func rewriteValueARM64_OpARM64MOVWloadidx4(v *Value) bool {
12768 v_2 := v.Args[2]
12769 v_1 := v.Args[1]
12770 v_0 := v.Args[0]
12771
12772
12773
12774 for {
12775 ptr := v_0
12776 if v_1.Op != OpARM64MOVDconst {
12777 break
12778 }
12779 c := auxIntToInt64(v_1.AuxInt)
12780 mem := v_2
12781 if !(is32Bit(c << 2)) {
12782 break
12783 }
12784 v.reset(OpARM64MOVWload)
12785 v.AuxInt = int32ToAuxInt(int32(c) << 2)
12786 v.AddArg2(ptr, mem)
12787 return true
12788 }
12789 return false
12790 }
12791 func rewriteValueARM64_OpARM64MOVWreg(v *Value) bool {
12792 v_0 := v.Args[0]
12793
12794
12795 for {
12796 if v_0.Op != OpARM64MOVDconst {
12797 break
12798 }
12799 c := auxIntToInt64(v_0.AuxInt)
12800 v.reset(OpARM64MOVDconst)
12801 v.AuxInt = int64ToAuxInt(int64(int32(c)))
12802 return true
12803 }
12804
12805
12806
12807 for {
12808 x := v_0
12809 if !(v.Type.Size() <= 4) {
12810 break
12811 }
12812 v.copyOf(x)
12813 return true
12814 }
12815
12816
12817
12818 for {
12819 t := v.Type
12820 if v_0.Op != OpARM64ANDconst {
12821 break
12822 }
12823 c := auxIntToInt64(v_0.AuxInt)
12824 x := v_0.Args[0]
12825 if !(uint64(c)&uint64(0xffffffff80000000) == 0) {
12826 break
12827 }
12828 v.reset(OpARM64ANDconst)
12829 v.Type = t
12830 v.AuxInt = int64ToAuxInt(c)
12831 v.AddArg(x)
12832 return true
12833 }
12834
12835
12836
12837 for {
12838 if v_0.Op != OpARM64SLLconst {
12839 break
12840 }
12841 lc := auxIntToInt64(v_0.AuxInt)
12842 x := v_0.Args[0]
12843 if !(lc < 32) {
12844 break
12845 }
12846 v.reset(OpARM64SBFIZ)
12847 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, 32-lc))
12848 v.AddArg(x)
12849 return true
12850 }
12851
12852
12853
12854 for {
12855 if v_0.Op != OpARM64SBFX {
12856 break
12857 }
12858 bfc := auxIntToArm64BitField(v_0.AuxInt)
12859 x := v_0.Args[0]
12860 if !(bfc.width() <= 32) {
12861 break
12862 }
12863 v.reset(OpARM64SBFX)
12864 v.AuxInt = arm64BitFieldToAuxInt(bfc)
12865 v.AddArg(x)
12866 return true
12867 }
12868 return false
12869 }
12870 func rewriteValueARM64_OpARM64MOVWstore(v *Value) bool {
12871 v_2 := v.Args[2]
12872 v_1 := v.Args[1]
12873 v_0 := v.Args[0]
12874 b := v.Block
12875 config := b.Func.Config
12876
12877
12878 for {
12879 off := auxIntToInt32(v.AuxInt)
12880 sym := auxToSym(v.Aux)
12881 ptr := v_0
12882 if v_1.Op != OpARM64FMOVSfpgp {
12883 break
12884 }
12885 val := v_1.Args[0]
12886 mem := v_2
12887 v.reset(OpARM64FMOVSstore)
12888 v.AuxInt = int32ToAuxInt(off)
12889 v.Aux = symToAux(sym)
12890 v.AddArg3(ptr, val, mem)
12891 return true
12892 }
12893
12894
12895
12896 for {
12897 off1 := auxIntToInt32(v.AuxInt)
12898 sym := auxToSym(v.Aux)
12899 if v_0.Op != OpARM64ADDconst {
12900 break
12901 }
12902 off2 := auxIntToInt64(v_0.AuxInt)
12903 ptr := v_0.Args[0]
12904 val := v_1
12905 mem := v_2
12906 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
12907 break
12908 }
12909 v.reset(OpARM64MOVWstore)
12910 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
12911 v.Aux = symToAux(sym)
12912 v.AddArg3(ptr, val, mem)
12913 return true
12914 }
12915
12916
12917
12918 for {
12919 off := auxIntToInt32(v.AuxInt)
12920 sym := auxToSym(v.Aux)
12921 if v_0.Op != OpARM64ADD {
12922 break
12923 }
12924 idx := v_0.Args[1]
12925 ptr := v_0.Args[0]
12926 val := v_1
12927 mem := v_2
12928 if !(off == 0 && sym == nil) {
12929 break
12930 }
12931 v.reset(OpARM64MOVWstoreidx)
12932 v.AddArg4(ptr, idx, val, mem)
12933 return true
12934 }
12935
12936
12937
12938 for {
12939 off := auxIntToInt32(v.AuxInt)
12940 sym := auxToSym(v.Aux)
12941 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 2 {
12942 break
12943 }
12944 idx := v_0.Args[1]
12945 ptr := v_0.Args[0]
12946 val := v_1
12947 mem := v_2
12948 if !(off == 0 && sym == nil) {
12949 break
12950 }
12951 v.reset(OpARM64MOVWstoreidx4)
12952 v.AddArg4(ptr, idx, val, mem)
12953 return true
12954 }
12955
12956
12957
12958 for {
12959 off1 := auxIntToInt32(v.AuxInt)
12960 sym1 := auxToSym(v.Aux)
12961 if v_0.Op != OpARM64MOVDaddr {
12962 break
12963 }
12964 off2 := auxIntToInt32(v_0.AuxInt)
12965 sym2 := auxToSym(v_0.Aux)
12966 ptr := v_0.Args[0]
12967 val := v_1
12968 mem := v_2
12969 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
12970 break
12971 }
12972 v.reset(OpARM64MOVWstore)
12973 v.AuxInt = int32ToAuxInt(off1 + off2)
12974 v.Aux = symToAux(mergeSym(sym1, sym2))
12975 v.AddArg3(ptr, val, mem)
12976 return true
12977 }
12978
12979
12980 for {
12981 off := auxIntToInt32(v.AuxInt)
12982 sym := auxToSym(v.Aux)
12983 ptr := v_0
12984 if v_1.Op != OpARM64MOVWreg {
12985 break
12986 }
12987 x := v_1.Args[0]
12988 mem := v_2
12989 v.reset(OpARM64MOVWstore)
12990 v.AuxInt = int32ToAuxInt(off)
12991 v.Aux = symToAux(sym)
12992 v.AddArg3(ptr, x, mem)
12993 return true
12994 }
12995
12996
12997 for {
12998 off := auxIntToInt32(v.AuxInt)
12999 sym := auxToSym(v.Aux)
13000 ptr := v_0
13001 if v_1.Op != OpARM64MOVWUreg {
13002 break
13003 }
13004 x := v_1.Args[0]
13005 mem := v_2
13006 v.reset(OpARM64MOVWstore)
13007 v.AuxInt = int32ToAuxInt(off)
13008 v.Aux = symToAux(sym)
13009 v.AddArg3(ptr, x, mem)
13010 return true
13011 }
13012 return false
13013 }
13014 func rewriteValueARM64_OpARM64MOVWstoreidx(v *Value) bool {
13015 v_3 := v.Args[3]
13016 v_2 := v.Args[2]
13017 v_1 := v.Args[1]
13018 v_0 := v.Args[0]
13019
13020
13021
13022 for {
13023 ptr := v_0
13024 if v_1.Op != OpARM64MOVDconst {
13025 break
13026 }
13027 c := auxIntToInt64(v_1.AuxInt)
13028 val := v_2
13029 mem := v_3
13030 if !(is32Bit(c)) {
13031 break
13032 }
13033 v.reset(OpARM64MOVWstore)
13034 v.AuxInt = int32ToAuxInt(int32(c))
13035 v.AddArg3(ptr, val, mem)
13036 return true
13037 }
13038
13039
13040
13041 for {
13042 if v_0.Op != OpARM64MOVDconst {
13043 break
13044 }
13045 c := auxIntToInt64(v_0.AuxInt)
13046 idx := v_1
13047 val := v_2
13048 mem := v_3
13049 if !(is32Bit(c)) {
13050 break
13051 }
13052 v.reset(OpARM64MOVWstore)
13053 v.AuxInt = int32ToAuxInt(int32(c))
13054 v.AddArg3(idx, val, mem)
13055 return true
13056 }
13057
13058
13059 for {
13060 ptr := v_0
13061 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 2 {
13062 break
13063 }
13064 idx := v_1.Args[0]
13065 val := v_2
13066 mem := v_3
13067 v.reset(OpARM64MOVWstoreidx4)
13068 v.AddArg4(ptr, idx, val, mem)
13069 return true
13070 }
13071
13072
13073 for {
13074 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 2 {
13075 break
13076 }
13077 idx := v_0.Args[0]
13078 ptr := v_1
13079 val := v_2
13080 mem := v_3
13081 v.reset(OpARM64MOVWstoreidx4)
13082 v.AddArg4(ptr, idx, val, mem)
13083 return true
13084 }
13085
13086
13087 for {
13088 ptr := v_0
13089 idx := v_1
13090 if v_2.Op != OpARM64MOVWreg {
13091 break
13092 }
13093 x := v_2.Args[0]
13094 mem := v_3
13095 v.reset(OpARM64MOVWstoreidx)
13096 v.AddArg4(ptr, idx, x, mem)
13097 return true
13098 }
13099
13100
13101 for {
13102 ptr := v_0
13103 idx := v_1
13104 if v_2.Op != OpARM64MOVWUreg {
13105 break
13106 }
13107 x := v_2.Args[0]
13108 mem := v_3
13109 v.reset(OpARM64MOVWstoreidx)
13110 v.AddArg4(ptr, idx, x, mem)
13111 return true
13112 }
13113 return false
13114 }
13115 func rewriteValueARM64_OpARM64MOVWstoreidx4(v *Value) bool {
13116 v_3 := v.Args[3]
13117 v_2 := v.Args[2]
13118 v_1 := v.Args[1]
13119 v_0 := v.Args[0]
13120
13121
13122
13123 for {
13124 ptr := v_0
13125 if v_1.Op != OpARM64MOVDconst {
13126 break
13127 }
13128 c := auxIntToInt64(v_1.AuxInt)
13129 val := v_2
13130 mem := v_3
13131 if !(is32Bit(c << 2)) {
13132 break
13133 }
13134 v.reset(OpARM64MOVWstore)
13135 v.AuxInt = int32ToAuxInt(int32(c) << 2)
13136 v.AddArg3(ptr, val, mem)
13137 return true
13138 }
13139
13140
13141 for {
13142 ptr := v_0
13143 idx := v_1
13144 if v_2.Op != OpARM64MOVWreg {
13145 break
13146 }
13147 x := v_2.Args[0]
13148 mem := v_3
13149 v.reset(OpARM64MOVWstoreidx4)
13150 v.AddArg4(ptr, idx, x, mem)
13151 return true
13152 }
13153
13154
13155 for {
13156 ptr := v_0
13157 idx := v_1
13158 if v_2.Op != OpARM64MOVWUreg {
13159 break
13160 }
13161 x := v_2.Args[0]
13162 mem := v_3
13163 v.reset(OpARM64MOVWstoreidx4)
13164 v.AddArg4(ptr, idx, x, mem)
13165 return true
13166 }
13167 return false
13168 }
13169 func rewriteValueARM64_OpARM64MSUB(v *Value) bool {
13170 v_2 := v.Args[2]
13171 v_1 := v.Args[1]
13172 v_0 := v.Args[0]
13173 b := v.Block
13174
13175
13176 for {
13177 a := v_0
13178 x := v_1
13179 if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != -1 {
13180 break
13181 }
13182 v.reset(OpARM64ADD)
13183 v.AddArg2(a, x)
13184 return true
13185 }
13186
13187
13188 for {
13189 a := v_0
13190 if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != 0 {
13191 break
13192 }
13193 v.copyOf(a)
13194 return true
13195 }
13196
13197
13198 for {
13199 a := v_0
13200 x := v_1
13201 if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != 1 {
13202 break
13203 }
13204 v.reset(OpARM64SUB)
13205 v.AddArg2(a, x)
13206 return true
13207 }
13208
13209
13210
13211 for {
13212 a := v_0
13213 x := v_1
13214 if v_2.Op != OpARM64MOVDconst {
13215 break
13216 }
13217 c := auxIntToInt64(v_2.AuxInt)
13218 if !(isPowerOfTwo(c)) {
13219 break
13220 }
13221 v.reset(OpARM64SUBshiftLL)
13222 v.AuxInt = int64ToAuxInt(log64(c))
13223 v.AddArg2(a, x)
13224 return true
13225 }
13226
13227
13228
13229 for {
13230 a := v_0
13231 x := v_1
13232 if v_2.Op != OpARM64MOVDconst {
13233 break
13234 }
13235 c := auxIntToInt64(v_2.AuxInt)
13236 if !(isPowerOfTwo(c-1) && c >= 3) {
13237 break
13238 }
13239 v.reset(OpARM64SUB)
13240 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13241 v0.AuxInt = int64ToAuxInt(log64(c - 1))
13242 v0.AddArg2(x, x)
13243 v.AddArg2(a, v0)
13244 return true
13245 }
13246
13247
13248
13249 for {
13250 a := v_0
13251 x := v_1
13252 if v_2.Op != OpARM64MOVDconst {
13253 break
13254 }
13255 c := auxIntToInt64(v_2.AuxInt)
13256 if !(isPowerOfTwo(c+1) && c >= 7) {
13257 break
13258 }
13259 v.reset(OpARM64ADD)
13260 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13261 v0.AuxInt = int64ToAuxInt(log64(c + 1))
13262 v0.AddArg2(x, x)
13263 v.AddArg2(a, v0)
13264 return true
13265 }
13266
13267
13268
13269 for {
13270 a := v_0
13271 x := v_1
13272 if v_2.Op != OpARM64MOVDconst {
13273 break
13274 }
13275 c := auxIntToInt64(v_2.AuxInt)
13276 if !(c%3 == 0 && isPowerOfTwo(c/3)) {
13277 break
13278 }
13279 v.reset(OpARM64ADDshiftLL)
13280 v.AuxInt = int64ToAuxInt(log64(c / 3))
13281 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13282 v0.AuxInt = int64ToAuxInt(2)
13283 v0.AddArg2(x, x)
13284 v.AddArg2(a, v0)
13285 return true
13286 }
13287
13288
13289
13290 for {
13291 a := v_0
13292 x := v_1
13293 if v_2.Op != OpARM64MOVDconst {
13294 break
13295 }
13296 c := auxIntToInt64(v_2.AuxInt)
13297 if !(c%5 == 0 && isPowerOfTwo(c/5)) {
13298 break
13299 }
13300 v.reset(OpARM64SUBshiftLL)
13301 v.AuxInt = int64ToAuxInt(log64(c / 5))
13302 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13303 v0.AuxInt = int64ToAuxInt(2)
13304 v0.AddArg2(x, x)
13305 v.AddArg2(a, v0)
13306 return true
13307 }
13308
13309
13310
13311 for {
13312 a := v_0
13313 x := v_1
13314 if v_2.Op != OpARM64MOVDconst {
13315 break
13316 }
13317 c := auxIntToInt64(v_2.AuxInt)
13318 if !(c%7 == 0 && isPowerOfTwo(c/7)) {
13319 break
13320 }
13321 v.reset(OpARM64ADDshiftLL)
13322 v.AuxInt = int64ToAuxInt(log64(c / 7))
13323 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13324 v0.AuxInt = int64ToAuxInt(3)
13325 v0.AddArg2(x, x)
13326 v.AddArg2(a, v0)
13327 return true
13328 }
13329
13330
13331
13332 for {
13333 a := v_0
13334 x := v_1
13335 if v_2.Op != OpARM64MOVDconst {
13336 break
13337 }
13338 c := auxIntToInt64(v_2.AuxInt)
13339 if !(c%9 == 0 && isPowerOfTwo(c/9)) {
13340 break
13341 }
13342 v.reset(OpARM64SUBshiftLL)
13343 v.AuxInt = int64ToAuxInt(log64(c / 9))
13344 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13345 v0.AuxInt = int64ToAuxInt(3)
13346 v0.AddArg2(x, x)
13347 v.AddArg2(a, v0)
13348 return true
13349 }
13350
13351
13352 for {
13353 a := v_0
13354 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != -1 {
13355 break
13356 }
13357 x := v_2
13358 v.reset(OpARM64ADD)
13359 v.AddArg2(a, x)
13360 return true
13361 }
13362
13363
13364 for {
13365 a := v_0
13366 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
13367 break
13368 }
13369 v.copyOf(a)
13370 return true
13371 }
13372
13373
13374 for {
13375 a := v_0
13376 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
13377 break
13378 }
13379 x := v_2
13380 v.reset(OpARM64SUB)
13381 v.AddArg2(a, x)
13382 return true
13383 }
13384
13385
13386
13387 for {
13388 a := v_0
13389 if v_1.Op != OpARM64MOVDconst {
13390 break
13391 }
13392 c := auxIntToInt64(v_1.AuxInt)
13393 x := v_2
13394 if !(isPowerOfTwo(c)) {
13395 break
13396 }
13397 v.reset(OpARM64SUBshiftLL)
13398 v.AuxInt = int64ToAuxInt(log64(c))
13399 v.AddArg2(a, x)
13400 return true
13401 }
13402
13403
13404
13405 for {
13406 a := v_0
13407 if v_1.Op != OpARM64MOVDconst {
13408 break
13409 }
13410 c := auxIntToInt64(v_1.AuxInt)
13411 x := v_2
13412 if !(isPowerOfTwo(c-1) && c >= 3) {
13413 break
13414 }
13415 v.reset(OpARM64SUB)
13416 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13417 v0.AuxInt = int64ToAuxInt(log64(c - 1))
13418 v0.AddArg2(x, x)
13419 v.AddArg2(a, v0)
13420 return true
13421 }
13422
13423
13424
13425 for {
13426 a := v_0
13427 if v_1.Op != OpARM64MOVDconst {
13428 break
13429 }
13430 c := auxIntToInt64(v_1.AuxInt)
13431 x := v_2
13432 if !(isPowerOfTwo(c+1) && c >= 7) {
13433 break
13434 }
13435 v.reset(OpARM64ADD)
13436 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13437 v0.AuxInt = int64ToAuxInt(log64(c + 1))
13438 v0.AddArg2(x, x)
13439 v.AddArg2(a, v0)
13440 return true
13441 }
13442
13443
13444
13445 for {
13446 a := v_0
13447 if v_1.Op != OpARM64MOVDconst {
13448 break
13449 }
13450 c := auxIntToInt64(v_1.AuxInt)
13451 x := v_2
13452 if !(c%3 == 0 && isPowerOfTwo(c/3)) {
13453 break
13454 }
13455 v.reset(OpARM64ADDshiftLL)
13456 v.AuxInt = int64ToAuxInt(log64(c / 3))
13457 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13458 v0.AuxInt = int64ToAuxInt(2)
13459 v0.AddArg2(x, x)
13460 v.AddArg2(a, v0)
13461 return true
13462 }
13463
13464
13465
13466 for {
13467 a := v_0
13468 if v_1.Op != OpARM64MOVDconst {
13469 break
13470 }
13471 c := auxIntToInt64(v_1.AuxInt)
13472 x := v_2
13473 if !(c%5 == 0 && isPowerOfTwo(c/5)) {
13474 break
13475 }
13476 v.reset(OpARM64SUBshiftLL)
13477 v.AuxInt = int64ToAuxInt(log64(c / 5))
13478 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13479 v0.AuxInt = int64ToAuxInt(2)
13480 v0.AddArg2(x, x)
13481 v.AddArg2(a, v0)
13482 return true
13483 }
13484
13485
13486
13487 for {
13488 a := v_0
13489 if v_1.Op != OpARM64MOVDconst {
13490 break
13491 }
13492 c := auxIntToInt64(v_1.AuxInt)
13493 x := v_2
13494 if !(c%7 == 0 && isPowerOfTwo(c/7)) {
13495 break
13496 }
13497 v.reset(OpARM64ADDshiftLL)
13498 v.AuxInt = int64ToAuxInt(log64(c / 7))
13499 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13500 v0.AuxInt = int64ToAuxInt(3)
13501 v0.AddArg2(x, x)
13502 v.AddArg2(a, v0)
13503 return true
13504 }
13505
13506
13507
13508 for {
13509 a := v_0
13510 if v_1.Op != OpARM64MOVDconst {
13511 break
13512 }
13513 c := auxIntToInt64(v_1.AuxInt)
13514 x := v_2
13515 if !(c%9 == 0 && isPowerOfTwo(c/9)) {
13516 break
13517 }
13518 v.reset(OpARM64SUBshiftLL)
13519 v.AuxInt = int64ToAuxInt(log64(c / 9))
13520 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13521 v0.AuxInt = int64ToAuxInt(3)
13522 v0.AddArg2(x, x)
13523 v.AddArg2(a, v0)
13524 return true
13525 }
13526
13527
13528 for {
13529 if v_0.Op != OpARM64MOVDconst {
13530 break
13531 }
13532 c := auxIntToInt64(v_0.AuxInt)
13533 x := v_1
13534 y := v_2
13535 v.reset(OpARM64ADDconst)
13536 v.AuxInt = int64ToAuxInt(c)
13537 v0 := b.NewValue0(v.Pos, OpARM64MNEG, x.Type)
13538 v0.AddArg2(x, y)
13539 v.AddArg(v0)
13540 return true
13541 }
13542
13543
13544 for {
13545 a := v_0
13546 if v_1.Op != OpARM64MOVDconst {
13547 break
13548 }
13549 c := auxIntToInt64(v_1.AuxInt)
13550 if v_2.Op != OpARM64MOVDconst {
13551 break
13552 }
13553 d := auxIntToInt64(v_2.AuxInt)
13554 v.reset(OpARM64SUBconst)
13555 v.AuxInt = int64ToAuxInt(c * d)
13556 v.AddArg(a)
13557 return true
13558 }
13559 return false
13560 }
13561 func rewriteValueARM64_OpARM64MSUBW(v *Value) bool {
13562 v_2 := v.Args[2]
13563 v_1 := v.Args[1]
13564 v_0 := v.Args[0]
13565 b := v.Block
13566
13567
13568
13569 for {
13570 a := v_0
13571 x := v_1
13572 if v_2.Op != OpARM64MOVDconst {
13573 break
13574 }
13575 c := auxIntToInt64(v_2.AuxInt)
13576 if !(int32(c) == -1) {
13577 break
13578 }
13579 v.reset(OpARM64MOVWUreg)
13580 v0 := b.NewValue0(v.Pos, OpARM64ADD, a.Type)
13581 v0.AddArg2(a, x)
13582 v.AddArg(v0)
13583 return true
13584 }
13585
13586
13587
13588 for {
13589 a := v_0
13590 if v_2.Op != OpARM64MOVDconst {
13591 break
13592 }
13593 c := auxIntToInt64(v_2.AuxInt)
13594 if !(int32(c) == 0) {
13595 break
13596 }
13597 v.reset(OpARM64MOVWUreg)
13598 v.AddArg(a)
13599 return true
13600 }
13601
13602
13603
13604 for {
13605 a := v_0
13606 x := v_1
13607 if v_2.Op != OpARM64MOVDconst {
13608 break
13609 }
13610 c := auxIntToInt64(v_2.AuxInt)
13611 if !(int32(c) == 1) {
13612 break
13613 }
13614 v.reset(OpARM64MOVWUreg)
13615 v0 := b.NewValue0(v.Pos, OpARM64SUB, a.Type)
13616 v0.AddArg2(a, x)
13617 v.AddArg(v0)
13618 return true
13619 }
13620
13621
13622
13623 for {
13624 a := v_0
13625 x := v_1
13626 if v_2.Op != OpARM64MOVDconst {
13627 break
13628 }
13629 c := auxIntToInt64(v_2.AuxInt)
13630 if !(isPowerOfTwo(c)) {
13631 break
13632 }
13633 v.reset(OpARM64MOVWUreg)
13634 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
13635 v0.AuxInt = int64ToAuxInt(log64(c))
13636 v0.AddArg2(a, x)
13637 v.AddArg(v0)
13638 return true
13639 }
13640
13641
13642
13643 for {
13644 a := v_0
13645 x := v_1
13646 if v_2.Op != OpARM64MOVDconst {
13647 break
13648 }
13649 c := auxIntToInt64(v_2.AuxInt)
13650 if !(isPowerOfTwo(c-1) && int32(c) >= 3) {
13651 break
13652 }
13653 v.reset(OpARM64MOVWUreg)
13654 v0 := b.NewValue0(v.Pos, OpARM64SUB, a.Type)
13655 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13656 v1.AuxInt = int64ToAuxInt(log64(c - 1))
13657 v1.AddArg2(x, x)
13658 v0.AddArg2(a, v1)
13659 v.AddArg(v0)
13660 return true
13661 }
13662
13663
13664
13665 for {
13666 a := v_0
13667 x := v_1
13668 if v_2.Op != OpARM64MOVDconst {
13669 break
13670 }
13671 c := auxIntToInt64(v_2.AuxInt)
13672 if !(isPowerOfTwo(c+1) && int32(c) >= 7) {
13673 break
13674 }
13675 v.reset(OpARM64MOVWUreg)
13676 v0 := b.NewValue0(v.Pos, OpARM64ADD, a.Type)
13677 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13678 v1.AuxInt = int64ToAuxInt(log64(c + 1))
13679 v1.AddArg2(x, x)
13680 v0.AddArg2(a, v1)
13681 v.AddArg(v0)
13682 return true
13683 }
13684
13685
13686
13687 for {
13688 a := v_0
13689 x := v_1
13690 if v_2.Op != OpARM64MOVDconst {
13691 break
13692 }
13693 c := auxIntToInt64(v_2.AuxInt)
13694 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) {
13695 break
13696 }
13697 v.reset(OpARM64MOVWUreg)
13698 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
13699 v0.AuxInt = int64ToAuxInt(log64(c / 3))
13700 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13701 v1.AuxInt = int64ToAuxInt(2)
13702 v1.AddArg2(x, x)
13703 v0.AddArg2(a, v1)
13704 v.AddArg(v0)
13705 return true
13706 }
13707
13708
13709
13710 for {
13711 a := v_0
13712 x := v_1
13713 if v_2.Op != OpARM64MOVDconst {
13714 break
13715 }
13716 c := auxIntToInt64(v_2.AuxInt)
13717 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) {
13718 break
13719 }
13720 v.reset(OpARM64MOVWUreg)
13721 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
13722 v0.AuxInt = int64ToAuxInt(log64(c / 5))
13723 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13724 v1.AuxInt = int64ToAuxInt(2)
13725 v1.AddArg2(x, x)
13726 v0.AddArg2(a, v1)
13727 v.AddArg(v0)
13728 return true
13729 }
13730
13731
13732
13733 for {
13734 a := v_0
13735 x := v_1
13736 if v_2.Op != OpARM64MOVDconst {
13737 break
13738 }
13739 c := auxIntToInt64(v_2.AuxInt)
13740 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) {
13741 break
13742 }
13743 v.reset(OpARM64MOVWUreg)
13744 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
13745 v0.AuxInt = int64ToAuxInt(log64(c / 7))
13746 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13747 v1.AuxInt = int64ToAuxInt(3)
13748 v1.AddArg2(x, x)
13749 v0.AddArg2(a, v1)
13750 v.AddArg(v0)
13751 return true
13752 }
13753
13754
13755
13756 for {
13757 a := v_0
13758 x := v_1
13759 if v_2.Op != OpARM64MOVDconst {
13760 break
13761 }
13762 c := auxIntToInt64(v_2.AuxInt)
13763 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) {
13764 break
13765 }
13766 v.reset(OpARM64MOVWUreg)
13767 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
13768 v0.AuxInt = int64ToAuxInt(log64(c / 9))
13769 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13770 v1.AuxInt = int64ToAuxInt(3)
13771 v1.AddArg2(x, x)
13772 v0.AddArg2(a, v1)
13773 v.AddArg(v0)
13774 return true
13775 }
13776
13777
13778
13779 for {
13780 a := v_0
13781 if v_1.Op != OpARM64MOVDconst {
13782 break
13783 }
13784 c := auxIntToInt64(v_1.AuxInt)
13785 x := v_2
13786 if !(int32(c) == -1) {
13787 break
13788 }
13789 v.reset(OpARM64MOVWUreg)
13790 v0 := b.NewValue0(v.Pos, OpARM64ADD, a.Type)
13791 v0.AddArg2(a, x)
13792 v.AddArg(v0)
13793 return true
13794 }
13795
13796
13797
13798 for {
13799 a := v_0
13800 if v_1.Op != OpARM64MOVDconst {
13801 break
13802 }
13803 c := auxIntToInt64(v_1.AuxInt)
13804 if !(int32(c) == 0) {
13805 break
13806 }
13807 v.reset(OpARM64MOVWUreg)
13808 v.AddArg(a)
13809 return true
13810 }
13811
13812
13813
13814 for {
13815 a := v_0
13816 if v_1.Op != OpARM64MOVDconst {
13817 break
13818 }
13819 c := auxIntToInt64(v_1.AuxInt)
13820 x := v_2
13821 if !(int32(c) == 1) {
13822 break
13823 }
13824 v.reset(OpARM64MOVWUreg)
13825 v0 := b.NewValue0(v.Pos, OpARM64SUB, a.Type)
13826 v0.AddArg2(a, x)
13827 v.AddArg(v0)
13828 return true
13829 }
13830
13831
13832
13833 for {
13834 a := v_0
13835 if v_1.Op != OpARM64MOVDconst {
13836 break
13837 }
13838 c := auxIntToInt64(v_1.AuxInt)
13839 x := v_2
13840 if !(isPowerOfTwo(c)) {
13841 break
13842 }
13843 v.reset(OpARM64MOVWUreg)
13844 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
13845 v0.AuxInt = int64ToAuxInt(log64(c))
13846 v0.AddArg2(a, x)
13847 v.AddArg(v0)
13848 return true
13849 }
13850
13851
13852
13853 for {
13854 a := v_0
13855 if v_1.Op != OpARM64MOVDconst {
13856 break
13857 }
13858 c := auxIntToInt64(v_1.AuxInt)
13859 x := v_2
13860 if !(isPowerOfTwo(c-1) && int32(c) >= 3) {
13861 break
13862 }
13863 v.reset(OpARM64MOVWUreg)
13864 v0 := b.NewValue0(v.Pos, OpARM64SUB, a.Type)
13865 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13866 v1.AuxInt = int64ToAuxInt(log64(c - 1))
13867 v1.AddArg2(x, x)
13868 v0.AddArg2(a, v1)
13869 v.AddArg(v0)
13870 return true
13871 }
13872
13873
13874
13875 for {
13876 a := v_0
13877 if v_1.Op != OpARM64MOVDconst {
13878 break
13879 }
13880 c := auxIntToInt64(v_1.AuxInt)
13881 x := v_2
13882 if !(isPowerOfTwo(c+1) && int32(c) >= 7) {
13883 break
13884 }
13885 v.reset(OpARM64MOVWUreg)
13886 v0 := b.NewValue0(v.Pos, OpARM64ADD, a.Type)
13887 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13888 v1.AuxInt = int64ToAuxInt(log64(c + 1))
13889 v1.AddArg2(x, x)
13890 v0.AddArg2(a, v1)
13891 v.AddArg(v0)
13892 return true
13893 }
13894
13895
13896
13897 for {
13898 a := v_0
13899 if v_1.Op != OpARM64MOVDconst {
13900 break
13901 }
13902 c := auxIntToInt64(v_1.AuxInt)
13903 x := v_2
13904 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) {
13905 break
13906 }
13907 v.reset(OpARM64MOVWUreg)
13908 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
13909 v0.AuxInt = int64ToAuxInt(log64(c / 3))
13910 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13911 v1.AuxInt = int64ToAuxInt(2)
13912 v1.AddArg2(x, x)
13913 v0.AddArg2(a, v1)
13914 v.AddArg(v0)
13915 return true
13916 }
13917
13918
13919
13920 for {
13921 a := v_0
13922 if v_1.Op != OpARM64MOVDconst {
13923 break
13924 }
13925 c := auxIntToInt64(v_1.AuxInt)
13926 x := v_2
13927 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) {
13928 break
13929 }
13930 v.reset(OpARM64MOVWUreg)
13931 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
13932 v0.AuxInt = int64ToAuxInt(log64(c / 5))
13933 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13934 v1.AuxInt = int64ToAuxInt(2)
13935 v1.AddArg2(x, x)
13936 v0.AddArg2(a, v1)
13937 v.AddArg(v0)
13938 return true
13939 }
13940
13941
13942
13943 for {
13944 a := v_0
13945 if v_1.Op != OpARM64MOVDconst {
13946 break
13947 }
13948 c := auxIntToInt64(v_1.AuxInt)
13949 x := v_2
13950 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) {
13951 break
13952 }
13953 v.reset(OpARM64MOVWUreg)
13954 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
13955 v0.AuxInt = int64ToAuxInt(log64(c / 7))
13956 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13957 v1.AuxInt = int64ToAuxInt(3)
13958 v1.AddArg2(x, x)
13959 v0.AddArg2(a, v1)
13960 v.AddArg(v0)
13961 return true
13962 }
13963
13964
13965
13966 for {
13967 a := v_0
13968 if v_1.Op != OpARM64MOVDconst {
13969 break
13970 }
13971 c := auxIntToInt64(v_1.AuxInt)
13972 x := v_2
13973 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) {
13974 break
13975 }
13976 v.reset(OpARM64MOVWUreg)
13977 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
13978 v0.AuxInt = int64ToAuxInt(log64(c / 9))
13979 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13980 v1.AuxInt = int64ToAuxInt(3)
13981 v1.AddArg2(x, x)
13982 v0.AddArg2(a, v1)
13983 v.AddArg(v0)
13984 return true
13985 }
13986
13987
13988 for {
13989 if v_0.Op != OpARM64MOVDconst {
13990 break
13991 }
13992 c := auxIntToInt64(v_0.AuxInt)
13993 x := v_1
13994 y := v_2
13995 v.reset(OpARM64MOVWUreg)
13996 v0 := b.NewValue0(v.Pos, OpARM64ADDconst, x.Type)
13997 v0.AuxInt = int64ToAuxInt(c)
13998 v1 := b.NewValue0(v.Pos, OpARM64MNEGW, x.Type)
13999 v1.AddArg2(x, y)
14000 v0.AddArg(v1)
14001 v.AddArg(v0)
14002 return true
14003 }
14004
14005
14006 for {
14007 a := v_0
14008 if v_1.Op != OpARM64MOVDconst {
14009 break
14010 }
14011 c := auxIntToInt64(v_1.AuxInt)
14012 if v_2.Op != OpARM64MOVDconst {
14013 break
14014 }
14015 d := auxIntToInt64(v_2.AuxInt)
14016 v.reset(OpARM64MOVWUreg)
14017 v0 := b.NewValue0(v.Pos, OpARM64SUBconst, a.Type)
14018 v0.AuxInt = int64ToAuxInt(c * d)
14019 v0.AddArg(a)
14020 v.AddArg(v0)
14021 return true
14022 }
14023 return false
14024 }
14025 func rewriteValueARM64_OpARM64MUL(v *Value) bool {
14026 v_1 := v.Args[1]
14027 v_0 := v.Args[0]
14028 b := v.Block
14029 config := b.Func.Config
14030
14031
14032 for {
14033 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14034 if v_0.Op != OpARM64NEG {
14035 continue
14036 }
14037 x := v_0.Args[0]
14038 y := v_1
14039 v.reset(OpARM64MNEG)
14040 v.AddArg2(x, y)
14041 return true
14042 }
14043 break
14044 }
14045
14046
14047 for {
14048 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14049 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
14050 continue
14051 }
14052 v.reset(OpARM64MOVDconst)
14053 v.AuxInt = int64ToAuxInt(0)
14054 return true
14055 }
14056 break
14057 }
14058
14059
14060 for {
14061 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14062 x := v_0
14063 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
14064 continue
14065 }
14066 v.copyOf(x)
14067 return true
14068 }
14069 break
14070 }
14071
14072
14073
14074 for {
14075 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14076 x := v_0
14077 if v_1.Op != OpARM64MOVDconst {
14078 continue
14079 }
14080 c := auxIntToInt64(v_1.AuxInt)
14081 if !(canMulStrengthReduce(config, c)) {
14082 continue
14083 }
14084 v.copyOf(mulStrengthReduce(v, x, c))
14085 return true
14086 }
14087 break
14088 }
14089
14090
14091 for {
14092 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14093 if v_0.Op != OpARM64MOVDconst {
14094 continue
14095 }
14096 c := auxIntToInt64(v_0.AuxInt)
14097 if v_1.Op != OpARM64MOVDconst {
14098 continue
14099 }
14100 d := auxIntToInt64(v_1.AuxInt)
14101 v.reset(OpARM64MOVDconst)
14102 v.AuxInt = int64ToAuxInt(c * d)
14103 return true
14104 }
14105 break
14106 }
14107
14108
14109
14110 for {
14111 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14112 r := v_0
14113 if r.Op != OpARM64MOVWUreg {
14114 continue
14115 }
14116 x := r.Args[0]
14117 s := v_1
14118 if s.Op != OpARM64MOVWUreg {
14119 continue
14120 }
14121 y := s.Args[0]
14122 if !(r.Uses == 1 && s.Uses == 1) {
14123 continue
14124 }
14125 v.reset(OpARM64UMULL)
14126 v.AddArg2(x, y)
14127 return true
14128 }
14129 break
14130 }
14131
14132
14133
14134 for {
14135 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14136 r := v_0
14137 if r.Op != OpARM64MOVWreg {
14138 continue
14139 }
14140 x := r.Args[0]
14141 s := v_1
14142 if s.Op != OpARM64MOVWreg {
14143 continue
14144 }
14145 y := s.Args[0]
14146 if !(r.Uses == 1 && s.Uses == 1) {
14147 continue
14148 }
14149 v.reset(OpARM64MULL)
14150 v.AddArg2(x, y)
14151 return true
14152 }
14153 break
14154 }
14155 return false
14156 }
14157 func rewriteValueARM64_OpARM64MULW(v *Value) bool {
14158 v_1 := v.Args[1]
14159 v_0 := v.Args[0]
14160 b := v.Block
14161 config := b.Func.Config
14162
14163
14164 for {
14165 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14166 if v_0.Op != OpARM64NEG {
14167 continue
14168 }
14169 x := v_0.Args[0]
14170 y := v_1
14171 v.reset(OpARM64MNEGW)
14172 v.AddArg2(x, y)
14173 return true
14174 }
14175 break
14176 }
14177
14178
14179
14180 for {
14181 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14182 if v_1.Op != OpARM64MOVDconst {
14183 continue
14184 }
14185 c := auxIntToInt64(v_1.AuxInt)
14186 if !(int32(c) == 0) {
14187 continue
14188 }
14189 v.reset(OpARM64MOVDconst)
14190 v.AuxInt = int64ToAuxInt(0)
14191 return true
14192 }
14193 break
14194 }
14195
14196
14197
14198 for {
14199 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14200 x := v_0
14201 if v_1.Op != OpARM64MOVDconst {
14202 continue
14203 }
14204 c := auxIntToInt64(v_1.AuxInt)
14205 if !(int32(c) == 1) {
14206 continue
14207 }
14208 v.reset(OpARM64MOVWUreg)
14209 v.AddArg(x)
14210 return true
14211 }
14212 break
14213 }
14214
14215
14216
14217 for {
14218 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14219 x := v_0
14220 if v_1.Op != OpARM64MOVDconst {
14221 continue
14222 }
14223 c := auxIntToInt64(v_1.AuxInt)
14224 if !(v.Type.Size() <= 4 && canMulStrengthReduce32(config, int32(c))) {
14225 continue
14226 }
14227 v.copyOf(mulStrengthReduce32(v, x, int32(c)))
14228 return true
14229 }
14230 break
14231 }
14232
14233
14234 for {
14235 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14236 if v_0.Op != OpARM64MOVDconst {
14237 continue
14238 }
14239 c := auxIntToInt64(v_0.AuxInt)
14240 if v_1.Op != OpARM64MOVDconst {
14241 continue
14242 }
14243 d := auxIntToInt64(v_1.AuxInt)
14244 v.reset(OpARM64MOVDconst)
14245 v.AuxInt = int64ToAuxInt(int64(uint32(c * d)))
14246 return true
14247 }
14248 break
14249 }
14250 return false
14251 }
14252 func rewriteValueARM64_OpARM64MVN(v *Value) bool {
14253 v_0 := v.Args[0]
14254
14255
14256 for {
14257 if v_0.Op != OpARM64XOR {
14258 break
14259 }
14260 y := v_0.Args[1]
14261 x := v_0.Args[0]
14262 v.reset(OpARM64EON)
14263 v.AddArg2(x, y)
14264 return true
14265 }
14266
14267
14268 for {
14269 if v_0.Op != OpARM64MOVDconst {
14270 break
14271 }
14272 c := auxIntToInt64(v_0.AuxInt)
14273 v.reset(OpARM64MOVDconst)
14274 v.AuxInt = int64ToAuxInt(^c)
14275 return true
14276 }
14277
14278
14279
14280 for {
14281 x := v_0
14282 if x.Op != OpARM64SLLconst {
14283 break
14284 }
14285 c := auxIntToInt64(x.AuxInt)
14286 y := x.Args[0]
14287 if !(clobberIfDead(x)) {
14288 break
14289 }
14290 v.reset(OpARM64MVNshiftLL)
14291 v.AuxInt = int64ToAuxInt(c)
14292 v.AddArg(y)
14293 return true
14294 }
14295
14296
14297
14298 for {
14299 x := v_0
14300 if x.Op != OpARM64SRLconst {
14301 break
14302 }
14303 c := auxIntToInt64(x.AuxInt)
14304 y := x.Args[0]
14305 if !(clobberIfDead(x)) {
14306 break
14307 }
14308 v.reset(OpARM64MVNshiftRL)
14309 v.AuxInt = int64ToAuxInt(c)
14310 v.AddArg(y)
14311 return true
14312 }
14313
14314
14315
14316 for {
14317 x := v_0
14318 if x.Op != OpARM64SRAconst {
14319 break
14320 }
14321 c := auxIntToInt64(x.AuxInt)
14322 y := x.Args[0]
14323 if !(clobberIfDead(x)) {
14324 break
14325 }
14326 v.reset(OpARM64MVNshiftRA)
14327 v.AuxInt = int64ToAuxInt(c)
14328 v.AddArg(y)
14329 return true
14330 }
14331
14332
14333
14334 for {
14335 x := v_0
14336 if x.Op != OpARM64RORconst {
14337 break
14338 }
14339 c := auxIntToInt64(x.AuxInt)
14340 y := x.Args[0]
14341 if !(clobberIfDead(x)) {
14342 break
14343 }
14344 v.reset(OpARM64MVNshiftRO)
14345 v.AuxInt = int64ToAuxInt(c)
14346 v.AddArg(y)
14347 return true
14348 }
14349 return false
14350 }
14351 func rewriteValueARM64_OpARM64MVNshiftLL(v *Value) bool {
14352 v_0 := v.Args[0]
14353
14354
14355 for {
14356 d := auxIntToInt64(v.AuxInt)
14357 if v_0.Op != OpARM64MOVDconst {
14358 break
14359 }
14360 c := auxIntToInt64(v_0.AuxInt)
14361 v.reset(OpARM64MOVDconst)
14362 v.AuxInt = int64ToAuxInt(^int64(uint64(c) << uint64(d)))
14363 return true
14364 }
14365 return false
14366 }
14367 func rewriteValueARM64_OpARM64MVNshiftRA(v *Value) bool {
14368 v_0 := v.Args[0]
14369
14370
14371 for {
14372 d := auxIntToInt64(v.AuxInt)
14373 if v_0.Op != OpARM64MOVDconst {
14374 break
14375 }
14376 c := auxIntToInt64(v_0.AuxInt)
14377 v.reset(OpARM64MOVDconst)
14378 v.AuxInt = int64ToAuxInt(^(c >> uint64(d)))
14379 return true
14380 }
14381 return false
14382 }
14383 func rewriteValueARM64_OpARM64MVNshiftRL(v *Value) bool {
14384 v_0 := v.Args[0]
14385
14386
14387 for {
14388 d := auxIntToInt64(v.AuxInt)
14389 if v_0.Op != OpARM64MOVDconst {
14390 break
14391 }
14392 c := auxIntToInt64(v_0.AuxInt)
14393 v.reset(OpARM64MOVDconst)
14394 v.AuxInt = int64ToAuxInt(^int64(uint64(c) >> uint64(d)))
14395 return true
14396 }
14397 return false
14398 }
14399 func rewriteValueARM64_OpARM64MVNshiftRO(v *Value) bool {
14400 v_0 := v.Args[0]
14401
14402
14403 for {
14404 d := auxIntToInt64(v.AuxInt)
14405 if v_0.Op != OpARM64MOVDconst {
14406 break
14407 }
14408 c := auxIntToInt64(v_0.AuxInt)
14409 v.reset(OpARM64MOVDconst)
14410 v.AuxInt = int64ToAuxInt(^rotateRight64(c, d))
14411 return true
14412 }
14413 return false
14414 }
14415 func rewriteValueARM64_OpARM64NEG(v *Value) bool {
14416 v_0 := v.Args[0]
14417
14418
14419 for {
14420 if v_0.Op != OpARM64MUL {
14421 break
14422 }
14423 y := v_0.Args[1]
14424 x := v_0.Args[0]
14425 v.reset(OpARM64MNEG)
14426 v.AddArg2(x, y)
14427 return true
14428 }
14429
14430
14431
14432 for {
14433 if v_0.Op != OpARM64MULW {
14434 break
14435 }
14436 y := v_0.Args[1]
14437 x := v_0.Args[0]
14438 if !(v.Type.Size() <= 4) {
14439 break
14440 }
14441 v.reset(OpARM64MNEGW)
14442 v.AddArg2(x, y)
14443 return true
14444 }
14445
14446
14447 for {
14448 if v_0.Op != OpARM64SUB {
14449 break
14450 }
14451 y := v_0.Args[1]
14452 x := v_0.Args[0]
14453 v.reset(OpARM64SUB)
14454 v.AddArg2(y, x)
14455 return true
14456 }
14457
14458
14459 for {
14460 if v_0.Op != OpARM64NEG {
14461 break
14462 }
14463 x := v_0.Args[0]
14464 v.copyOf(x)
14465 return true
14466 }
14467
14468
14469 for {
14470 if v_0.Op != OpARM64MOVDconst {
14471 break
14472 }
14473 c := auxIntToInt64(v_0.AuxInt)
14474 v.reset(OpARM64MOVDconst)
14475 v.AuxInt = int64ToAuxInt(-c)
14476 return true
14477 }
14478
14479
14480
14481 for {
14482 x := v_0
14483 if x.Op != OpARM64SLLconst {
14484 break
14485 }
14486 c := auxIntToInt64(x.AuxInt)
14487 y := x.Args[0]
14488 if !(clobberIfDead(x)) {
14489 break
14490 }
14491 v.reset(OpARM64NEGshiftLL)
14492 v.AuxInt = int64ToAuxInt(c)
14493 v.AddArg(y)
14494 return true
14495 }
14496
14497
14498
14499 for {
14500 x := v_0
14501 if x.Op != OpARM64SRLconst {
14502 break
14503 }
14504 c := auxIntToInt64(x.AuxInt)
14505 y := x.Args[0]
14506 if !(clobberIfDead(x)) {
14507 break
14508 }
14509 v.reset(OpARM64NEGshiftRL)
14510 v.AuxInt = int64ToAuxInt(c)
14511 v.AddArg(y)
14512 return true
14513 }
14514
14515
14516
14517 for {
14518 x := v_0
14519 if x.Op != OpARM64SRAconst {
14520 break
14521 }
14522 c := auxIntToInt64(x.AuxInt)
14523 y := x.Args[0]
14524 if !(clobberIfDead(x)) {
14525 break
14526 }
14527 v.reset(OpARM64NEGshiftRA)
14528 v.AuxInt = int64ToAuxInt(c)
14529 v.AddArg(y)
14530 return true
14531 }
14532 return false
14533 }
14534 func rewriteValueARM64_OpARM64NEGshiftLL(v *Value) bool {
14535 v_0 := v.Args[0]
14536
14537
14538 for {
14539 d := auxIntToInt64(v.AuxInt)
14540 if v_0.Op != OpARM64MOVDconst {
14541 break
14542 }
14543 c := auxIntToInt64(v_0.AuxInt)
14544 v.reset(OpARM64MOVDconst)
14545 v.AuxInt = int64ToAuxInt(-int64(uint64(c) << uint64(d)))
14546 return true
14547 }
14548 return false
14549 }
14550 func rewriteValueARM64_OpARM64NEGshiftRA(v *Value) bool {
14551 v_0 := v.Args[0]
14552
14553
14554 for {
14555 d := auxIntToInt64(v.AuxInt)
14556 if v_0.Op != OpARM64MOVDconst {
14557 break
14558 }
14559 c := auxIntToInt64(v_0.AuxInt)
14560 v.reset(OpARM64MOVDconst)
14561 v.AuxInt = int64ToAuxInt(-(c >> uint64(d)))
14562 return true
14563 }
14564 return false
14565 }
14566 func rewriteValueARM64_OpARM64NEGshiftRL(v *Value) bool {
14567 v_0 := v.Args[0]
14568
14569
14570 for {
14571 d := auxIntToInt64(v.AuxInt)
14572 if v_0.Op != OpARM64MOVDconst {
14573 break
14574 }
14575 c := auxIntToInt64(v_0.AuxInt)
14576 v.reset(OpARM64MOVDconst)
14577 v.AuxInt = int64ToAuxInt(-int64(uint64(c) >> uint64(d)))
14578 return true
14579 }
14580 return false
14581 }
14582 func rewriteValueARM64_OpARM64NotEqual(v *Value) bool {
14583 v_0 := v.Args[0]
14584 b := v.Block
14585
14586
14587
14588 for {
14589 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
14590 break
14591 }
14592 z := v_0.Args[0]
14593 if z.Op != OpARM64AND {
14594 break
14595 }
14596 y := z.Args[1]
14597 x := z.Args[0]
14598 if !(z.Uses == 1) {
14599 break
14600 }
14601 v.reset(OpARM64NotEqual)
14602 v0 := b.NewValue0(v.Pos, OpARM64TST, types.TypeFlags)
14603 v0.AddArg2(x, y)
14604 v.AddArg(v0)
14605 return true
14606 }
14607
14608
14609
14610 for {
14611 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
14612 break
14613 }
14614 x := v_0.Args[0]
14615 if x.Op != OpARM64ANDconst {
14616 break
14617 }
14618 c := auxIntToInt64(x.AuxInt)
14619 y := x.Args[0]
14620 if !(x.Uses == 1) {
14621 break
14622 }
14623 v.reset(OpARM64NotEqual)
14624 v0 := b.NewValue0(v.Pos, OpARM64TSTWconst, types.TypeFlags)
14625 v0.AuxInt = int32ToAuxInt(int32(c))
14626 v0.AddArg(y)
14627 v.AddArg(v0)
14628 return true
14629 }
14630
14631
14632
14633 for {
14634 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
14635 break
14636 }
14637 z := v_0.Args[0]
14638 if z.Op != OpARM64AND {
14639 break
14640 }
14641 y := z.Args[1]
14642 x := z.Args[0]
14643 if !(z.Uses == 1) {
14644 break
14645 }
14646 v.reset(OpARM64NotEqual)
14647 v0 := b.NewValue0(v.Pos, OpARM64TSTW, types.TypeFlags)
14648 v0.AddArg2(x, y)
14649 v.AddArg(v0)
14650 return true
14651 }
14652
14653
14654
14655 for {
14656 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
14657 break
14658 }
14659 x := v_0.Args[0]
14660 if x.Op != OpARM64ANDconst {
14661 break
14662 }
14663 c := auxIntToInt64(x.AuxInt)
14664 y := x.Args[0]
14665 if !(x.Uses == 1) {
14666 break
14667 }
14668 v.reset(OpARM64NotEqual)
14669 v0 := b.NewValue0(v.Pos, OpARM64TSTconst, types.TypeFlags)
14670 v0.AuxInt = int64ToAuxInt(c)
14671 v0.AddArg(y)
14672 v.AddArg(v0)
14673 return true
14674 }
14675
14676
14677
14678 for {
14679 if v_0.Op != OpARM64CMP {
14680 break
14681 }
14682 _ = v_0.Args[1]
14683 x := v_0.Args[0]
14684 z := v_0.Args[1]
14685 if z.Op != OpARM64NEG {
14686 break
14687 }
14688 y := z.Args[0]
14689 if !(z.Uses == 1) {
14690 break
14691 }
14692 v.reset(OpARM64NotEqual)
14693 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
14694 v0.AddArg2(x, y)
14695 v.AddArg(v0)
14696 return true
14697 }
14698
14699
14700
14701 for {
14702 if v_0.Op != OpARM64CMPW {
14703 break
14704 }
14705 _ = v_0.Args[1]
14706 x := v_0.Args[0]
14707 z := v_0.Args[1]
14708 if z.Op != OpARM64NEG {
14709 break
14710 }
14711 y := z.Args[0]
14712 if !(z.Uses == 1) {
14713 break
14714 }
14715 v.reset(OpARM64NotEqual)
14716 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
14717 v0.AddArg2(x, y)
14718 v.AddArg(v0)
14719 return true
14720 }
14721
14722
14723
14724 for {
14725 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
14726 break
14727 }
14728 x := v_0.Args[0]
14729 if x.Op != OpARM64ADDconst {
14730 break
14731 }
14732 c := auxIntToInt64(x.AuxInt)
14733 y := x.Args[0]
14734 if !(x.Uses == 1) {
14735 break
14736 }
14737 v.reset(OpARM64NotEqual)
14738 v0 := b.NewValue0(v.Pos, OpARM64CMNconst, types.TypeFlags)
14739 v0.AuxInt = int64ToAuxInt(c)
14740 v0.AddArg(y)
14741 v.AddArg(v0)
14742 return true
14743 }
14744
14745
14746
14747 for {
14748 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
14749 break
14750 }
14751 x := v_0.Args[0]
14752 if x.Op != OpARM64ADDconst {
14753 break
14754 }
14755 c := auxIntToInt64(x.AuxInt)
14756 y := x.Args[0]
14757 if !(x.Uses == 1) {
14758 break
14759 }
14760 v.reset(OpARM64NotEqual)
14761 v0 := b.NewValue0(v.Pos, OpARM64CMNWconst, types.TypeFlags)
14762 v0.AuxInt = int32ToAuxInt(int32(c))
14763 v0.AddArg(y)
14764 v.AddArg(v0)
14765 return true
14766 }
14767
14768
14769
14770 for {
14771 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
14772 break
14773 }
14774 z := v_0.Args[0]
14775 if z.Op != OpARM64ADD {
14776 break
14777 }
14778 y := z.Args[1]
14779 x := z.Args[0]
14780 if !(z.Uses == 1) {
14781 break
14782 }
14783 v.reset(OpARM64NotEqual)
14784 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
14785 v0.AddArg2(x, y)
14786 v.AddArg(v0)
14787 return true
14788 }
14789
14790
14791
14792 for {
14793 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
14794 break
14795 }
14796 z := v_0.Args[0]
14797 if z.Op != OpARM64ADD {
14798 break
14799 }
14800 y := z.Args[1]
14801 x := z.Args[0]
14802 if !(z.Uses == 1) {
14803 break
14804 }
14805 v.reset(OpARM64NotEqual)
14806 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
14807 v0.AddArg2(x, y)
14808 v.AddArg(v0)
14809 return true
14810 }
14811
14812
14813
14814 for {
14815 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
14816 break
14817 }
14818 z := v_0.Args[0]
14819 if z.Op != OpARM64MADD {
14820 break
14821 }
14822 y := z.Args[2]
14823 a := z.Args[0]
14824 x := z.Args[1]
14825 if !(z.Uses == 1) {
14826 break
14827 }
14828 v.reset(OpARM64NotEqual)
14829 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
14830 v1 := b.NewValue0(v.Pos, OpARM64MUL, x.Type)
14831 v1.AddArg2(x, y)
14832 v0.AddArg2(a, v1)
14833 v.AddArg(v0)
14834 return true
14835 }
14836
14837
14838
14839 for {
14840 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
14841 break
14842 }
14843 z := v_0.Args[0]
14844 if z.Op != OpARM64MADDW {
14845 break
14846 }
14847 y := z.Args[2]
14848 a := z.Args[0]
14849 x := z.Args[1]
14850 if !(z.Uses == 1) {
14851 break
14852 }
14853 v.reset(OpARM64NotEqual)
14854 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
14855 v1 := b.NewValue0(v.Pos, OpARM64MULW, x.Type)
14856 v1.AddArg2(x, y)
14857 v0.AddArg2(a, v1)
14858 v.AddArg(v0)
14859 return true
14860 }
14861
14862
14863
14864 for {
14865 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
14866 break
14867 }
14868 z := v_0.Args[0]
14869 if z.Op != OpARM64MSUB {
14870 break
14871 }
14872 y := z.Args[2]
14873 a := z.Args[0]
14874 x := z.Args[1]
14875 if !(z.Uses == 1) {
14876 break
14877 }
14878 v.reset(OpARM64NotEqual)
14879 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
14880 v1 := b.NewValue0(v.Pos, OpARM64MUL, x.Type)
14881 v1.AddArg2(x, y)
14882 v0.AddArg2(a, v1)
14883 v.AddArg(v0)
14884 return true
14885 }
14886
14887
14888
14889 for {
14890 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
14891 break
14892 }
14893 z := v_0.Args[0]
14894 if z.Op != OpARM64MSUBW {
14895 break
14896 }
14897 y := z.Args[2]
14898 a := z.Args[0]
14899 x := z.Args[1]
14900 if !(z.Uses == 1) {
14901 break
14902 }
14903 v.reset(OpARM64NotEqual)
14904 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
14905 v1 := b.NewValue0(v.Pos, OpARM64MULW, x.Type)
14906 v1.AddArg2(x, y)
14907 v0.AddArg2(a, v1)
14908 v.AddArg(v0)
14909 return true
14910 }
14911
14912
14913 for {
14914 if v_0.Op != OpARM64FlagConstant {
14915 break
14916 }
14917 fc := auxIntToFlagConstant(v_0.AuxInt)
14918 v.reset(OpARM64MOVDconst)
14919 v.AuxInt = int64ToAuxInt(b2i(fc.ne()))
14920 return true
14921 }
14922
14923
14924 for {
14925 if v_0.Op != OpARM64InvertFlags {
14926 break
14927 }
14928 x := v_0.Args[0]
14929 v.reset(OpARM64NotEqual)
14930 v.AddArg(x)
14931 return true
14932 }
14933 return false
14934 }
14935 func rewriteValueARM64_OpARM64OR(v *Value) bool {
14936 v_1 := v.Args[1]
14937 v_0 := v.Args[0]
14938
14939
14940 for {
14941 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14942 x := v_0
14943 if v_1.Op != OpARM64MOVDconst {
14944 continue
14945 }
14946 c := auxIntToInt64(v_1.AuxInt)
14947 v.reset(OpARM64ORconst)
14948 v.AuxInt = int64ToAuxInt(c)
14949 v.AddArg(x)
14950 return true
14951 }
14952 break
14953 }
14954
14955
14956 for {
14957 x := v_0
14958 if x != v_1 {
14959 break
14960 }
14961 v.copyOf(x)
14962 return true
14963 }
14964
14965
14966 for {
14967 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14968 x := v_0
14969 if v_1.Op != OpARM64MVN {
14970 continue
14971 }
14972 y := v_1.Args[0]
14973 v.reset(OpARM64ORN)
14974 v.AddArg2(x, y)
14975 return true
14976 }
14977 break
14978 }
14979
14980
14981
14982 for {
14983 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14984 x0 := v_0
14985 x1 := v_1
14986 if x1.Op != OpARM64SLLconst {
14987 continue
14988 }
14989 c := auxIntToInt64(x1.AuxInt)
14990 y := x1.Args[0]
14991 if !(clobberIfDead(x1)) {
14992 continue
14993 }
14994 v.reset(OpARM64ORshiftLL)
14995 v.AuxInt = int64ToAuxInt(c)
14996 v.AddArg2(x0, y)
14997 return true
14998 }
14999 break
15000 }
15001
15002
15003
15004 for {
15005 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
15006 x0 := v_0
15007 x1 := v_1
15008 if x1.Op != OpARM64SRLconst {
15009 continue
15010 }
15011 c := auxIntToInt64(x1.AuxInt)
15012 y := x1.Args[0]
15013 if !(clobberIfDead(x1)) {
15014 continue
15015 }
15016 v.reset(OpARM64ORshiftRL)
15017 v.AuxInt = int64ToAuxInt(c)
15018 v.AddArg2(x0, y)
15019 return true
15020 }
15021 break
15022 }
15023
15024
15025
15026 for {
15027 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
15028 x0 := v_0
15029 x1 := v_1
15030 if x1.Op != OpARM64SRAconst {
15031 continue
15032 }
15033 c := auxIntToInt64(x1.AuxInt)
15034 y := x1.Args[0]
15035 if !(clobberIfDead(x1)) {
15036 continue
15037 }
15038 v.reset(OpARM64ORshiftRA)
15039 v.AuxInt = int64ToAuxInt(c)
15040 v.AddArg2(x0, y)
15041 return true
15042 }
15043 break
15044 }
15045
15046
15047
15048 for {
15049 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
15050 x0 := v_0
15051 x1 := v_1
15052 if x1.Op != OpARM64RORconst {
15053 continue
15054 }
15055 c := auxIntToInt64(x1.AuxInt)
15056 y := x1.Args[0]
15057 if !(clobberIfDead(x1)) {
15058 continue
15059 }
15060 v.reset(OpARM64ORshiftRO)
15061 v.AuxInt = int64ToAuxInt(c)
15062 v.AddArg2(x0, y)
15063 return true
15064 }
15065 break
15066 }
15067
15068
15069
15070 for {
15071 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
15072 if v_0.Op != OpARM64UBFIZ {
15073 continue
15074 }
15075 bfc := auxIntToArm64BitField(v_0.AuxInt)
15076 x := v_0.Args[0]
15077 if v_1.Op != OpARM64ANDconst {
15078 continue
15079 }
15080 ac := auxIntToInt64(v_1.AuxInt)
15081 y := v_1.Args[0]
15082 if !(ac == ^((1<<uint(bfc.width()) - 1) << uint(bfc.lsb()))) {
15083 continue
15084 }
15085 v.reset(OpARM64BFI)
15086 v.AuxInt = arm64BitFieldToAuxInt(bfc)
15087 v.AddArg2(y, x)
15088 return true
15089 }
15090 break
15091 }
15092
15093
15094
15095 for {
15096 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
15097 if v_0.Op != OpARM64UBFX {
15098 continue
15099 }
15100 bfc := auxIntToArm64BitField(v_0.AuxInt)
15101 x := v_0.Args[0]
15102 if v_1.Op != OpARM64ANDconst {
15103 continue
15104 }
15105 ac := auxIntToInt64(v_1.AuxInt)
15106 y := v_1.Args[0]
15107 if !(ac == ^(1<<uint(bfc.width()) - 1)) {
15108 continue
15109 }
15110 v.reset(OpARM64BFXIL)
15111 v.AuxInt = arm64BitFieldToAuxInt(bfc)
15112 v.AddArg2(y, x)
15113 return true
15114 }
15115 break
15116 }
15117 return false
15118 }
15119 func rewriteValueARM64_OpARM64ORN(v *Value) bool {
15120 v_1 := v.Args[1]
15121 v_0 := v.Args[0]
15122
15123
15124 for {
15125 x := v_0
15126 if v_1.Op != OpARM64MOVDconst {
15127 break
15128 }
15129 c := auxIntToInt64(v_1.AuxInt)
15130 v.reset(OpARM64ORconst)
15131 v.AuxInt = int64ToAuxInt(^c)
15132 v.AddArg(x)
15133 return true
15134 }
15135
15136
15137 for {
15138 x := v_0
15139 if x != v_1 {
15140 break
15141 }
15142 v.reset(OpARM64MOVDconst)
15143 v.AuxInt = int64ToAuxInt(-1)
15144 return true
15145 }
15146
15147
15148
15149 for {
15150 x0 := v_0
15151 x1 := v_1
15152 if x1.Op != OpARM64SLLconst {
15153 break
15154 }
15155 c := auxIntToInt64(x1.AuxInt)
15156 y := x1.Args[0]
15157 if !(clobberIfDead(x1)) {
15158 break
15159 }
15160 v.reset(OpARM64ORNshiftLL)
15161 v.AuxInt = int64ToAuxInt(c)
15162 v.AddArg2(x0, y)
15163 return true
15164 }
15165
15166
15167
15168 for {
15169 x0 := v_0
15170 x1 := v_1
15171 if x1.Op != OpARM64SRLconst {
15172 break
15173 }
15174 c := auxIntToInt64(x1.AuxInt)
15175 y := x1.Args[0]
15176 if !(clobberIfDead(x1)) {
15177 break
15178 }
15179 v.reset(OpARM64ORNshiftRL)
15180 v.AuxInt = int64ToAuxInt(c)
15181 v.AddArg2(x0, y)
15182 return true
15183 }
15184
15185
15186
15187 for {
15188 x0 := v_0
15189 x1 := v_1
15190 if x1.Op != OpARM64SRAconst {
15191 break
15192 }
15193 c := auxIntToInt64(x1.AuxInt)
15194 y := x1.Args[0]
15195 if !(clobberIfDead(x1)) {
15196 break
15197 }
15198 v.reset(OpARM64ORNshiftRA)
15199 v.AuxInt = int64ToAuxInt(c)
15200 v.AddArg2(x0, y)
15201 return true
15202 }
15203
15204
15205
15206 for {
15207 x0 := v_0
15208 x1 := v_1
15209 if x1.Op != OpARM64RORconst {
15210 break
15211 }
15212 c := auxIntToInt64(x1.AuxInt)
15213 y := x1.Args[0]
15214 if !(clobberIfDead(x1)) {
15215 break
15216 }
15217 v.reset(OpARM64ORNshiftRO)
15218 v.AuxInt = int64ToAuxInt(c)
15219 v.AddArg2(x0, y)
15220 return true
15221 }
15222 return false
15223 }
15224 func rewriteValueARM64_OpARM64ORNshiftLL(v *Value) bool {
15225 v_1 := v.Args[1]
15226 v_0 := v.Args[0]
15227
15228
15229 for {
15230 d := auxIntToInt64(v.AuxInt)
15231 x := v_0
15232 if v_1.Op != OpARM64MOVDconst {
15233 break
15234 }
15235 c := auxIntToInt64(v_1.AuxInt)
15236 v.reset(OpARM64ORconst)
15237 v.AuxInt = int64ToAuxInt(^int64(uint64(c) << uint64(d)))
15238 v.AddArg(x)
15239 return true
15240 }
15241
15242
15243 for {
15244 c := auxIntToInt64(v.AuxInt)
15245 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != c {
15246 break
15247 }
15248 x := v_0.Args[0]
15249 if x != v_1 {
15250 break
15251 }
15252 v.reset(OpARM64MOVDconst)
15253 v.AuxInt = int64ToAuxInt(-1)
15254 return true
15255 }
15256 return false
15257 }
15258 func rewriteValueARM64_OpARM64ORNshiftRA(v *Value) bool {
15259 v_1 := v.Args[1]
15260 v_0 := v.Args[0]
15261
15262
15263 for {
15264 d := auxIntToInt64(v.AuxInt)
15265 x := v_0
15266 if v_1.Op != OpARM64MOVDconst {
15267 break
15268 }
15269 c := auxIntToInt64(v_1.AuxInt)
15270 v.reset(OpARM64ORconst)
15271 v.AuxInt = int64ToAuxInt(^(c >> uint64(d)))
15272 v.AddArg(x)
15273 return true
15274 }
15275
15276
15277 for {
15278 c := auxIntToInt64(v.AuxInt)
15279 if v_0.Op != OpARM64SRAconst || auxIntToInt64(v_0.AuxInt) != c {
15280 break
15281 }
15282 x := v_0.Args[0]
15283 if x != v_1 {
15284 break
15285 }
15286 v.reset(OpARM64MOVDconst)
15287 v.AuxInt = int64ToAuxInt(-1)
15288 return true
15289 }
15290 return false
15291 }
15292 func rewriteValueARM64_OpARM64ORNshiftRL(v *Value) bool {
15293 v_1 := v.Args[1]
15294 v_0 := v.Args[0]
15295
15296
15297 for {
15298 d := auxIntToInt64(v.AuxInt)
15299 x := v_0
15300 if v_1.Op != OpARM64MOVDconst {
15301 break
15302 }
15303 c := auxIntToInt64(v_1.AuxInt)
15304 v.reset(OpARM64ORconst)
15305 v.AuxInt = int64ToAuxInt(^int64(uint64(c) >> uint64(d)))
15306 v.AddArg(x)
15307 return true
15308 }
15309
15310
15311 for {
15312 c := auxIntToInt64(v.AuxInt)
15313 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != c {
15314 break
15315 }
15316 x := v_0.Args[0]
15317 if x != v_1 {
15318 break
15319 }
15320 v.reset(OpARM64MOVDconst)
15321 v.AuxInt = int64ToAuxInt(-1)
15322 return true
15323 }
15324 return false
15325 }
15326 func rewriteValueARM64_OpARM64ORNshiftRO(v *Value) bool {
15327 v_1 := v.Args[1]
15328 v_0 := v.Args[0]
15329
15330
15331 for {
15332 d := auxIntToInt64(v.AuxInt)
15333 x := v_0
15334 if v_1.Op != OpARM64MOVDconst {
15335 break
15336 }
15337 c := auxIntToInt64(v_1.AuxInt)
15338 v.reset(OpARM64ORconst)
15339 v.AuxInt = int64ToAuxInt(^rotateRight64(c, d))
15340 v.AddArg(x)
15341 return true
15342 }
15343
15344
15345 for {
15346 c := auxIntToInt64(v.AuxInt)
15347 if v_0.Op != OpARM64RORconst || auxIntToInt64(v_0.AuxInt) != c {
15348 break
15349 }
15350 x := v_0.Args[0]
15351 if x != v_1 {
15352 break
15353 }
15354 v.reset(OpARM64MOVDconst)
15355 v.AuxInt = int64ToAuxInt(-1)
15356 return true
15357 }
15358 return false
15359 }
15360 func rewriteValueARM64_OpARM64ORconst(v *Value) bool {
15361 v_0 := v.Args[0]
15362
15363
15364 for {
15365 if auxIntToInt64(v.AuxInt) != 0 {
15366 break
15367 }
15368 x := v_0
15369 v.copyOf(x)
15370 return true
15371 }
15372
15373
15374 for {
15375 if auxIntToInt64(v.AuxInt) != -1 {
15376 break
15377 }
15378 v.reset(OpARM64MOVDconst)
15379 v.AuxInt = int64ToAuxInt(-1)
15380 return true
15381 }
15382
15383
15384 for {
15385 c := auxIntToInt64(v.AuxInt)
15386 if v_0.Op != OpARM64MOVDconst {
15387 break
15388 }
15389 d := auxIntToInt64(v_0.AuxInt)
15390 v.reset(OpARM64MOVDconst)
15391 v.AuxInt = int64ToAuxInt(c | d)
15392 return true
15393 }
15394
15395
15396 for {
15397 c := auxIntToInt64(v.AuxInt)
15398 if v_0.Op != OpARM64ORconst {
15399 break
15400 }
15401 d := auxIntToInt64(v_0.AuxInt)
15402 x := v_0.Args[0]
15403 v.reset(OpARM64ORconst)
15404 v.AuxInt = int64ToAuxInt(c | d)
15405 v.AddArg(x)
15406 return true
15407 }
15408
15409
15410
15411 for {
15412 c1 := auxIntToInt64(v.AuxInt)
15413 if v_0.Op != OpARM64ANDconst {
15414 break
15415 }
15416 c2 := auxIntToInt64(v_0.AuxInt)
15417 x := v_0.Args[0]
15418 if !(c2|c1 == ^0) {
15419 break
15420 }
15421 v.reset(OpARM64ORconst)
15422 v.AuxInt = int64ToAuxInt(c1)
15423 v.AddArg(x)
15424 return true
15425 }
15426 return false
15427 }
15428 func rewriteValueARM64_OpARM64ORshiftLL(v *Value) bool {
15429 v_1 := v.Args[1]
15430 v_0 := v.Args[0]
15431 b := v.Block
15432 typ := &b.Func.Config.Types
15433
15434
15435 for {
15436 d := auxIntToInt64(v.AuxInt)
15437 if v_0.Op != OpARM64MOVDconst {
15438 break
15439 }
15440 c := auxIntToInt64(v_0.AuxInt)
15441 x := v_1
15442 v.reset(OpARM64ORconst)
15443 v.AuxInt = int64ToAuxInt(c)
15444 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
15445 v0.AuxInt = int64ToAuxInt(d)
15446 v0.AddArg(x)
15447 v.AddArg(v0)
15448 return true
15449 }
15450
15451
15452 for {
15453 d := auxIntToInt64(v.AuxInt)
15454 x := v_0
15455 if v_1.Op != OpARM64MOVDconst {
15456 break
15457 }
15458 c := auxIntToInt64(v_1.AuxInt)
15459 v.reset(OpARM64ORconst)
15460 v.AuxInt = int64ToAuxInt(int64(uint64(c) << uint64(d)))
15461 v.AddArg(x)
15462 return true
15463 }
15464
15465
15466 for {
15467 c := auxIntToInt64(v.AuxInt)
15468 y := v_0
15469 if y.Op != OpARM64SLLconst || auxIntToInt64(y.AuxInt) != c {
15470 break
15471 }
15472 x := y.Args[0]
15473 if x != v_1 {
15474 break
15475 }
15476 v.copyOf(y)
15477 return true
15478 }
15479
15480
15481 for {
15482 if v.Type != typ.UInt16 || auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64UBFX || v_0.Type != typ.UInt16 || auxIntToArm64BitField(v_0.AuxInt) != armBFAuxInt(8, 8) {
15483 break
15484 }
15485 x := v_0.Args[0]
15486 if x != v_1 {
15487 break
15488 }
15489 v.reset(OpARM64REV16W)
15490 v.AddArg(x)
15491 return true
15492 }
15493
15494
15495
15496 for {
15497 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64UBFX || auxIntToArm64BitField(v_0.AuxInt) != armBFAuxInt(8, 24) {
15498 break
15499 }
15500 v_0_0 := v_0.Args[0]
15501 if v_0_0.Op != OpARM64ANDconst {
15502 break
15503 }
15504 c1 := auxIntToInt64(v_0_0.AuxInt)
15505 x := v_0_0.Args[0]
15506 if v_1.Op != OpARM64ANDconst {
15507 break
15508 }
15509 c2 := auxIntToInt64(v_1.AuxInt)
15510 if x != v_1.Args[0] || !(uint32(c1) == 0xff00ff00 && uint32(c2) == 0x00ff00ff) {
15511 break
15512 }
15513 v.reset(OpARM64REV16W)
15514 v.AddArg(x)
15515 return true
15516 }
15517
15518
15519
15520 for {
15521 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
15522 break
15523 }
15524 v_0_0 := v_0.Args[0]
15525 if v_0_0.Op != OpARM64ANDconst {
15526 break
15527 }
15528 c1 := auxIntToInt64(v_0_0.AuxInt)
15529 x := v_0_0.Args[0]
15530 if v_1.Op != OpARM64ANDconst {
15531 break
15532 }
15533 c2 := auxIntToInt64(v_1.AuxInt)
15534 if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00ff00ff00 && uint64(c2) == 0x00ff00ff00ff00ff) {
15535 break
15536 }
15537 v.reset(OpARM64REV16)
15538 v.AddArg(x)
15539 return true
15540 }
15541
15542
15543
15544 for {
15545 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
15546 break
15547 }
15548 v_0_0 := v_0.Args[0]
15549 if v_0_0.Op != OpARM64ANDconst {
15550 break
15551 }
15552 c1 := auxIntToInt64(v_0_0.AuxInt)
15553 x := v_0_0.Args[0]
15554 if v_1.Op != OpARM64ANDconst {
15555 break
15556 }
15557 c2 := auxIntToInt64(v_1.AuxInt)
15558 if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00 && uint64(c2) == 0x00ff00ff) {
15559 break
15560 }
15561 v.reset(OpARM64REV16)
15562 v0 := b.NewValue0(v.Pos, OpARM64ANDconst, x.Type)
15563 v0.AuxInt = int64ToAuxInt(0xffffffff)
15564 v0.AddArg(x)
15565 v.AddArg(v0)
15566 return true
15567 }
15568
15569
15570 for {
15571 c := auxIntToInt64(v.AuxInt)
15572 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 64-c {
15573 break
15574 }
15575 x := v_0.Args[0]
15576 x2 := v_1
15577 v.reset(OpARM64EXTRconst)
15578 v.AuxInt = int64ToAuxInt(64 - c)
15579 v.AddArg2(x2, x)
15580 return true
15581 }
15582
15583
15584
15585 for {
15586 t := v.Type
15587 c := auxIntToInt64(v.AuxInt)
15588 if v_0.Op != OpARM64UBFX {
15589 break
15590 }
15591 bfc := auxIntToArm64BitField(v_0.AuxInt)
15592 x := v_0.Args[0]
15593 x2 := v_1
15594 if !(c < 32 && t.Size() == 4 && bfc == armBFAuxInt(32-c, c)) {
15595 break
15596 }
15597 v.reset(OpARM64EXTRWconst)
15598 v.AuxInt = int64ToAuxInt(32 - c)
15599 v.AddArg2(x2, x)
15600 return true
15601 }
15602
15603
15604
15605 for {
15606 s := auxIntToInt64(v.AuxInt)
15607 if v_0.Op != OpARM64ANDconst {
15608 break
15609 }
15610 xc := auxIntToInt64(v_0.AuxInt)
15611 x := v_0.Args[0]
15612 if v_1.Op != OpARM64ANDconst {
15613 break
15614 }
15615 yc := auxIntToInt64(v_1.AuxInt)
15616 y := v_1.Args[0]
15617 if !(xc == ^(yc<<s) && yc&(yc+1) == 0 && yc > 0 && s+log64(yc+1) <= 64) {
15618 break
15619 }
15620 v.reset(OpARM64BFI)
15621 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(s, log64(yc+1)))
15622 v.AddArg2(x, y)
15623 return true
15624 }
15625
15626
15627
15628 for {
15629 sc := auxIntToInt64(v.AuxInt)
15630 if v_0.Op != OpARM64UBFX {
15631 break
15632 }
15633 bfc := auxIntToArm64BitField(v_0.AuxInt)
15634 x := v_0.Args[0]
15635 if v_1.Op != OpARM64SRLconst || auxIntToInt64(v_1.AuxInt) != sc {
15636 break
15637 }
15638 y := v_1.Args[0]
15639 if !(sc == bfc.width()) {
15640 break
15641 }
15642 v.reset(OpARM64BFXIL)
15643 v.AuxInt = arm64BitFieldToAuxInt(bfc)
15644 v.AddArg2(y, x)
15645 return true
15646 }
15647 return false
15648 }
15649 func rewriteValueARM64_OpARM64ORshiftRA(v *Value) bool {
15650 v_1 := v.Args[1]
15651 v_0 := v.Args[0]
15652 b := v.Block
15653
15654
15655 for {
15656 d := auxIntToInt64(v.AuxInt)
15657 if v_0.Op != OpARM64MOVDconst {
15658 break
15659 }
15660 c := auxIntToInt64(v_0.AuxInt)
15661 x := v_1
15662 v.reset(OpARM64ORconst)
15663 v.AuxInt = int64ToAuxInt(c)
15664 v0 := b.NewValue0(v.Pos, OpARM64SRAconst, x.Type)
15665 v0.AuxInt = int64ToAuxInt(d)
15666 v0.AddArg(x)
15667 v.AddArg(v0)
15668 return true
15669 }
15670
15671
15672 for {
15673 d := auxIntToInt64(v.AuxInt)
15674 x := v_0
15675 if v_1.Op != OpARM64MOVDconst {
15676 break
15677 }
15678 c := auxIntToInt64(v_1.AuxInt)
15679 v.reset(OpARM64ORconst)
15680 v.AuxInt = int64ToAuxInt(c >> uint64(d))
15681 v.AddArg(x)
15682 return true
15683 }
15684
15685
15686 for {
15687 c := auxIntToInt64(v.AuxInt)
15688 y := v_0
15689 if y.Op != OpARM64SRAconst || auxIntToInt64(y.AuxInt) != c {
15690 break
15691 }
15692 x := y.Args[0]
15693 if x != v_1 {
15694 break
15695 }
15696 v.copyOf(y)
15697 return true
15698 }
15699 return false
15700 }
15701 func rewriteValueARM64_OpARM64ORshiftRL(v *Value) bool {
15702 v_1 := v.Args[1]
15703 v_0 := v.Args[0]
15704 b := v.Block
15705
15706
15707 for {
15708 d := auxIntToInt64(v.AuxInt)
15709 if v_0.Op != OpARM64MOVDconst {
15710 break
15711 }
15712 c := auxIntToInt64(v_0.AuxInt)
15713 x := v_1
15714 v.reset(OpARM64ORconst)
15715 v.AuxInt = int64ToAuxInt(c)
15716 v0 := b.NewValue0(v.Pos, OpARM64SRLconst, x.Type)
15717 v0.AuxInt = int64ToAuxInt(d)
15718 v0.AddArg(x)
15719 v.AddArg(v0)
15720 return true
15721 }
15722
15723
15724 for {
15725 d := auxIntToInt64(v.AuxInt)
15726 x := v_0
15727 if v_1.Op != OpARM64MOVDconst {
15728 break
15729 }
15730 c := auxIntToInt64(v_1.AuxInt)
15731 v.reset(OpARM64ORconst)
15732 v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
15733 v.AddArg(x)
15734 return true
15735 }
15736
15737
15738 for {
15739 c := auxIntToInt64(v.AuxInt)
15740 y := v_0
15741 if y.Op != OpARM64SRLconst || auxIntToInt64(y.AuxInt) != c {
15742 break
15743 }
15744 x := y.Args[0]
15745 if x != v_1 {
15746 break
15747 }
15748 v.copyOf(y)
15749 return true
15750 }
15751
15752
15753
15754 for {
15755 rc := auxIntToInt64(v.AuxInt)
15756 if v_0.Op != OpARM64ANDconst {
15757 break
15758 }
15759 ac := auxIntToInt64(v_0.AuxInt)
15760 x := v_0.Args[0]
15761 if v_1.Op != OpARM64SLLconst {
15762 break
15763 }
15764 lc := auxIntToInt64(v_1.AuxInt)
15765 y := v_1.Args[0]
15766 if !(lc > rc && ac == ^((1<<uint(64-lc)-1)<<uint64(lc-rc))) {
15767 break
15768 }
15769 v.reset(OpARM64BFI)
15770 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc-rc, 64-lc))
15771 v.AddArg2(x, y)
15772 return true
15773 }
15774
15775
15776
15777 for {
15778 rc := auxIntToInt64(v.AuxInt)
15779 if v_0.Op != OpARM64ANDconst {
15780 break
15781 }
15782 ac := auxIntToInt64(v_0.AuxInt)
15783 y := v_0.Args[0]
15784 if v_1.Op != OpARM64SLLconst {
15785 break
15786 }
15787 lc := auxIntToInt64(v_1.AuxInt)
15788 x := v_1.Args[0]
15789 if !(lc < rc && ac == ^(1<<uint(64-rc)-1)) {
15790 break
15791 }
15792 v.reset(OpARM64BFXIL)
15793 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc-lc, 64-rc))
15794 v.AddArg2(y, x)
15795 return true
15796 }
15797 return false
15798 }
15799 func rewriteValueARM64_OpARM64ORshiftRO(v *Value) bool {
15800 v_1 := v.Args[1]
15801 v_0 := v.Args[0]
15802 b := v.Block
15803
15804
15805 for {
15806 d := auxIntToInt64(v.AuxInt)
15807 if v_0.Op != OpARM64MOVDconst {
15808 break
15809 }
15810 c := auxIntToInt64(v_0.AuxInt)
15811 x := v_1
15812 v.reset(OpARM64ORconst)
15813 v.AuxInt = int64ToAuxInt(c)
15814 v0 := b.NewValue0(v.Pos, OpARM64RORconst, x.Type)
15815 v0.AuxInt = int64ToAuxInt(d)
15816 v0.AddArg(x)
15817 v.AddArg(v0)
15818 return true
15819 }
15820
15821
15822 for {
15823 d := auxIntToInt64(v.AuxInt)
15824 x := v_0
15825 if v_1.Op != OpARM64MOVDconst {
15826 break
15827 }
15828 c := auxIntToInt64(v_1.AuxInt)
15829 v.reset(OpARM64ORconst)
15830 v.AuxInt = int64ToAuxInt(rotateRight64(c, d))
15831 v.AddArg(x)
15832 return true
15833 }
15834
15835
15836 for {
15837 c := auxIntToInt64(v.AuxInt)
15838 y := v_0
15839 if y.Op != OpARM64RORconst || auxIntToInt64(y.AuxInt) != c {
15840 break
15841 }
15842 x := y.Args[0]
15843 if x != v_1 {
15844 break
15845 }
15846 v.copyOf(y)
15847 return true
15848 }
15849 return false
15850 }
15851 func rewriteValueARM64_OpARM64REV(v *Value) bool {
15852 v_0 := v.Args[0]
15853
15854
15855 for {
15856 if v_0.Op != OpARM64REV {
15857 break
15858 }
15859 p := v_0.Args[0]
15860 v.copyOf(p)
15861 return true
15862 }
15863 return false
15864 }
15865 func rewriteValueARM64_OpARM64REV16(v *Value) bool {
15866 v_0 := v.Args[0]
15867
15868
15869 for {
15870 if v_0.Op != OpARM64MOVWUreg {
15871 break
15872 }
15873 x := v_0.Args[0]
15874 v.reset(OpARM64REV16W)
15875 v.AddArg(x)
15876 return true
15877 }
15878 return false
15879 }
15880 func rewriteValueARM64_OpARM64REVW(v *Value) bool {
15881 v_0 := v.Args[0]
15882
15883
15884 for {
15885 if v_0.Op != OpARM64REVW {
15886 break
15887 }
15888 p := v_0.Args[0]
15889 v.copyOf(p)
15890 return true
15891 }
15892 return false
15893 }
15894 func rewriteValueARM64_OpARM64ROR(v *Value) bool {
15895 v_1 := v.Args[1]
15896 v_0 := v.Args[0]
15897
15898
15899 for {
15900 x := v_0
15901 if v_1.Op != OpARM64MOVDconst {
15902 break
15903 }
15904 c := auxIntToInt64(v_1.AuxInt)
15905 v.reset(OpARM64RORconst)
15906 v.AuxInt = int64ToAuxInt(c & 63)
15907 v.AddArg(x)
15908 return true
15909 }
15910 return false
15911 }
15912 func rewriteValueARM64_OpARM64RORW(v *Value) bool {
15913 v_1 := v.Args[1]
15914 v_0 := v.Args[0]
15915
15916
15917 for {
15918 x := v_0
15919 if v_1.Op != OpARM64MOVDconst {
15920 break
15921 }
15922 c := auxIntToInt64(v_1.AuxInt)
15923 v.reset(OpARM64RORWconst)
15924 v.AuxInt = int64ToAuxInt(c & 31)
15925 v.AddArg(x)
15926 return true
15927 }
15928 return false
15929 }
15930 func rewriteValueARM64_OpARM64SBCSflags(v *Value) bool {
15931 v_2 := v.Args[2]
15932 v_1 := v.Args[1]
15933 v_0 := v.Args[0]
15934 b := v.Block
15935 typ := &b.Func.Config.Types
15936
15937
15938 for {
15939 x := v_0
15940 y := v_1
15941 if v_2.Op != OpSelect1 || v_2.Type != types.TypeFlags {
15942 break
15943 }
15944 v_2_0 := v_2.Args[0]
15945 if v_2_0.Op != OpARM64NEGSflags {
15946 break
15947 }
15948 v_2_0_0 := v_2_0.Args[0]
15949 if v_2_0_0.Op != OpARM64NEG || v_2_0_0.Type != typ.UInt64 {
15950 break
15951 }
15952 v_2_0_0_0 := v_2_0_0.Args[0]
15953 if v_2_0_0_0.Op != OpARM64NGCzerocarry || v_2_0_0_0.Type != typ.UInt64 {
15954 break
15955 }
15956 bo := v_2_0_0_0.Args[0]
15957 v.reset(OpARM64SBCSflags)
15958 v.AddArg3(x, y, bo)
15959 return true
15960 }
15961
15962
15963 for {
15964 x := v_0
15965 y := v_1
15966 if v_2.Op != OpSelect1 || v_2.Type != types.TypeFlags {
15967 break
15968 }
15969 v_2_0 := v_2.Args[0]
15970 if v_2_0.Op != OpARM64NEGSflags {
15971 break
15972 }
15973 v_2_0_0 := v_2_0.Args[0]
15974 if v_2_0_0.Op != OpARM64MOVDconst || auxIntToInt64(v_2_0_0.AuxInt) != 0 {
15975 break
15976 }
15977 v.reset(OpARM64SUBSflags)
15978 v.AddArg2(x, y)
15979 return true
15980 }
15981 return false
15982 }
15983 func rewriteValueARM64_OpARM64SBFX(v *Value) bool {
15984 v_0 := v.Args[0]
15985
15986
15987
15988 for {
15989 bfc := auxIntToArm64BitField(v.AuxInt)
15990 s := v_0
15991 if s.Op != OpARM64SLLconst {
15992 break
15993 }
15994 sc := auxIntToInt64(s.AuxInt)
15995 x := s.Args[0]
15996 if !(s.Uses == 1 && sc <= bfc.lsb()) {
15997 break
15998 }
15999 v.reset(OpARM64SBFX)
16000 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb()-sc, bfc.width()))
16001 v.AddArg(x)
16002 return true
16003 }
16004
16005
16006
16007 for {
16008 bfc := auxIntToArm64BitField(v.AuxInt)
16009 s := v_0
16010 if s.Op != OpARM64SLLconst {
16011 break
16012 }
16013 sc := auxIntToInt64(s.AuxInt)
16014 x := s.Args[0]
16015 if !(s.Uses == 1 && sc > bfc.lsb() && sc < bfc.lsb()+bfc.width()) {
16016 break
16017 }
16018 v.reset(OpARM64SBFIZ)
16019 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(sc-bfc.lsb(), bfc.width()-(sc-bfc.lsb())))
16020 v.AddArg(x)
16021 return true
16022 }
16023 return false
16024 }
16025 func rewriteValueARM64_OpARM64SLL(v *Value) bool {
16026 v_1 := v.Args[1]
16027 v_0 := v.Args[0]
16028
16029
16030 for {
16031 x := v_0
16032 if v_1.Op != OpARM64MOVDconst {
16033 break
16034 }
16035 c := auxIntToInt64(v_1.AuxInt)
16036 v.reset(OpARM64SLLconst)
16037 v.AuxInt = int64ToAuxInt(c & 63)
16038 v.AddArg(x)
16039 return true
16040 }
16041
16042
16043 for {
16044 x := v_0
16045 if v_1.Op != OpARM64ANDconst || auxIntToInt64(v_1.AuxInt) != 63 {
16046 break
16047 }
16048 y := v_1.Args[0]
16049 v.reset(OpARM64SLL)
16050 v.AddArg2(x, y)
16051 return true
16052 }
16053 return false
16054 }
16055 func rewriteValueARM64_OpARM64SLLconst(v *Value) bool {
16056 v_0 := v.Args[0]
16057
16058
16059 for {
16060 c := auxIntToInt64(v.AuxInt)
16061 if v_0.Op != OpARM64MOVDconst {
16062 break
16063 }
16064 d := auxIntToInt64(v_0.AuxInt)
16065 v.reset(OpARM64MOVDconst)
16066 v.AuxInt = int64ToAuxInt(d << uint64(c))
16067 return true
16068 }
16069
16070
16071
16072 for {
16073 c := auxIntToInt64(v.AuxInt)
16074 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != c {
16075 break
16076 }
16077 x := v_0.Args[0]
16078 if !(0 < c && c < 64) {
16079 break
16080 }
16081 v.reset(OpARM64ANDconst)
16082 v.AuxInt = int64ToAuxInt(^(1<<uint(c) - 1))
16083 v.AddArg(x)
16084 return true
16085 }
16086
16087
16088 for {
16089 lc := auxIntToInt64(v.AuxInt)
16090 if v_0.Op != OpARM64MOVWreg {
16091 break
16092 }
16093 x := v_0.Args[0]
16094 v.reset(OpARM64SBFIZ)
16095 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, min(32, 64-lc)))
16096 v.AddArg(x)
16097 return true
16098 }
16099
16100
16101 for {
16102 lc := auxIntToInt64(v.AuxInt)
16103 if v_0.Op != OpARM64MOVHreg {
16104 break
16105 }
16106 x := v_0.Args[0]
16107 v.reset(OpARM64SBFIZ)
16108 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, min(16, 64-lc)))
16109 v.AddArg(x)
16110 return true
16111 }
16112
16113
16114 for {
16115 lc := auxIntToInt64(v.AuxInt)
16116 if v_0.Op != OpARM64MOVBreg {
16117 break
16118 }
16119 x := v_0.Args[0]
16120 v.reset(OpARM64SBFIZ)
16121 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, min(8, 64-lc)))
16122 v.AddArg(x)
16123 return true
16124 }
16125
16126
16127 for {
16128 lc := auxIntToInt64(v.AuxInt)
16129 if v_0.Op != OpARM64MOVWUreg {
16130 break
16131 }
16132 x := v_0.Args[0]
16133 v.reset(OpARM64UBFIZ)
16134 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, min(32, 64-lc)))
16135 v.AddArg(x)
16136 return true
16137 }
16138
16139
16140 for {
16141 lc := auxIntToInt64(v.AuxInt)
16142 if v_0.Op != OpARM64MOVHUreg {
16143 break
16144 }
16145 x := v_0.Args[0]
16146 v.reset(OpARM64UBFIZ)
16147 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, min(16, 64-lc)))
16148 v.AddArg(x)
16149 return true
16150 }
16151
16152
16153 for {
16154 lc := auxIntToInt64(v.AuxInt)
16155 if v_0.Op != OpARM64MOVBUreg {
16156 break
16157 }
16158 x := v_0.Args[0]
16159 v.reset(OpARM64UBFIZ)
16160 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, min(8, 64-lc)))
16161 v.AddArg(x)
16162 return true
16163 }
16164
16165
16166
16167 for {
16168 sc := auxIntToInt64(v.AuxInt)
16169 if v_0.Op != OpARM64ANDconst {
16170 break
16171 }
16172 ac := auxIntToInt64(v_0.AuxInt)
16173 x := v_0.Args[0]
16174 if !(isARM64BFMask(sc, ac, 0)) {
16175 break
16176 }
16177 v.reset(OpARM64UBFIZ)
16178 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(sc, arm64BFWidth(ac, 0)))
16179 v.AddArg(x)
16180 return true
16181 }
16182
16183
16184
16185 for {
16186 sc := auxIntToInt64(v.AuxInt)
16187 if v_0.Op != OpARM64UBFIZ {
16188 break
16189 }
16190 bfc := auxIntToArm64BitField(v_0.AuxInt)
16191 x := v_0.Args[0]
16192 if !(sc+bfc.width()+bfc.lsb() < 64) {
16193 break
16194 }
16195 v.reset(OpARM64UBFIZ)
16196 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb()+sc, bfc.width()))
16197 v.AddArg(x)
16198 return true
16199 }
16200 return false
16201 }
16202 func rewriteValueARM64_OpARM64SRA(v *Value) bool {
16203 v_1 := v.Args[1]
16204 v_0 := v.Args[0]
16205
16206
16207 for {
16208 x := v_0
16209 if v_1.Op != OpARM64MOVDconst {
16210 break
16211 }
16212 c := auxIntToInt64(v_1.AuxInt)
16213 v.reset(OpARM64SRAconst)
16214 v.AuxInt = int64ToAuxInt(c & 63)
16215 v.AddArg(x)
16216 return true
16217 }
16218
16219
16220 for {
16221 x := v_0
16222 if v_1.Op != OpARM64ANDconst || auxIntToInt64(v_1.AuxInt) != 63 {
16223 break
16224 }
16225 y := v_1.Args[0]
16226 v.reset(OpARM64SRA)
16227 v.AddArg2(x, y)
16228 return true
16229 }
16230 return false
16231 }
16232 func rewriteValueARM64_OpARM64SRAconst(v *Value) bool {
16233 v_0 := v.Args[0]
16234
16235
16236 for {
16237 c := auxIntToInt64(v.AuxInt)
16238 if v_0.Op != OpARM64MOVDconst {
16239 break
16240 }
16241 d := auxIntToInt64(v_0.AuxInt)
16242 v.reset(OpARM64MOVDconst)
16243 v.AuxInt = int64ToAuxInt(d >> uint64(c))
16244 return true
16245 }
16246
16247
16248
16249 for {
16250 rc := auxIntToInt64(v.AuxInt)
16251 if v_0.Op != OpARM64SLLconst {
16252 break
16253 }
16254 lc := auxIntToInt64(v_0.AuxInt)
16255 x := v_0.Args[0]
16256 if !(lc > rc) {
16257 break
16258 }
16259 v.reset(OpARM64SBFIZ)
16260 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc-rc, 64-lc))
16261 v.AddArg(x)
16262 return true
16263 }
16264
16265
16266
16267 for {
16268 rc := auxIntToInt64(v.AuxInt)
16269 if v_0.Op != OpARM64SLLconst {
16270 break
16271 }
16272 lc := auxIntToInt64(v_0.AuxInt)
16273 x := v_0.Args[0]
16274 if !(lc <= rc) {
16275 break
16276 }
16277 v.reset(OpARM64SBFX)
16278 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc-lc, 64-rc))
16279 v.AddArg(x)
16280 return true
16281 }
16282
16283
16284
16285 for {
16286 rc := auxIntToInt64(v.AuxInt)
16287 if v_0.Op != OpARM64MOVWreg {
16288 break
16289 }
16290 x := v_0.Args[0]
16291 if !(rc < 32) {
16292 break
16293 }
16294 v.reset(OpARM64SBFX)
16295 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 32-rc))
16296 v.AddArg(x)
16297 return true
16298 }
16299
16300
16301
16302 for {
16303 rc := auxIntToInt64(v.AuxInt)
16304 if v_0.Op != OpARM64MOVHreg {
16305 break
16306 }
16307 x := v_0.Args[0]
16308 if !(rc < 16) {
16309 break
16310 }
16311 v.reset(OpARM64SBFX)
16312 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 16-rc))
16313 v.AddArg(x)
16314 return true
16315 }
16316
16317
16318
16319 for {
16320 rc := auxIntToInt64(v.AuxInt)
16321 if v_0.Op != OpARM64MOVBreg {
16322 break
16323 }
16324 x := v_0.Args[0]
16325 if !(rc < 8) {
16326 break
16327 }
16328 v.reset(OpARM64SBFX)
16329 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 8-rc))
16330 v.AddArg(x)
16331 return true
16332 }
16333
16334
16335
16336 for {
16337 sc := auxIntToInt64(v.AuxInt)
16338 if v_0.Op != OpARM64SBFIZ {
16339 break
16340 }
16341 bfc := auxIntToArm64BitField(v_0.AuxInt)
16342 x := v_0.Args[0]
16343 if !(sc < bfc.lsb()) {
16344 break
16345 }
16346 v.reset(OpARM64SBFIZ)
16347 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb()-sc, bfc.width()))
16348 v.AddArg(x)
16349 return true
16350 }
16351
16352
16353
16354 for {
16355 sc := auxIntToInt64(v.AuxInt)
16356 if v_0.Op != OpARM64SBFIZ {
16357 break
16358 }
16359 bfc := auxIntToArm64BitField(v_0.AuxInt)
16360 x := v_0.Args[0]
16361 if !(sc >= bfc.lsb() && sc < bfc.lsb()+bfc.width()) {
16362 break
16363 }
16364 v.reset(OpARM64SBFX)
16365 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(sc-bfc.lsb(), bfc.lsb()+bfc.width()-sc))
16366 v.AddArg(x)
16367 return true
16368 }
16369 return false
16370 }
16371 func rewriteValueARM64_OpARM64SRL(v *Value) bool {
16372 v_1 := v.Args[1]
16373 v_0 := v.Args[0]
16374
16375
16376 for {
16377 x := v_0
16378 if v_1.Op != OpARM64MOVDconst {
16379 break
16380 }
16381 c := auxIntToInt64(v_1.AuxInt)
16382 v.reset(OpARM64SRLconst)
16383 v.AuxInt = int64ToAuxInt(c & 63)
16384 v.AddArg(x)
16385 return true
16386 }
16387
16388
16389 for {
16390 x := v_0
16391 if v_1.Op != OpARM64ANDconst || auxIntToInt64(v_1.AuxInt) != 63 {
16392 break
16393 }
16394 y := v_1.Args[0]
16395 v.reset(OpARM64SRL)
16396 v.AddArg2(x, y)
16397 return true
16398 }
16399 return false
16400 }
16401 func rewriteValueARM64_OpARM64SRLconst(v *Value) bool {
16402 v_0 := v.Args[0]
16403
16404
16405 for {
16406 c := auxIntToInt64(v.AuxInt)
16407 if v_0.Op != OpARM64MOVDconst {
16408 break
16409 }
16410 d := auxIntToInt64(v_0.AuxInt)
16411 v.reset(OpARM64MOVDconst)
16412 v.AuxInt = int64ToAuxInt(int64(uint64(d) >> uint64(c)))
16413 return true
16414 }
16415
16416
16417
16418 for {
16419 c := auxIntToInt64(v.AuxInt)
16420 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != c {
16421 break
16422 }
16423 x := v_0.Args[0]
16424 if !(0 < c && c < 64) {
16425 break
16426 }
16427 v.reset(OpARM64ANDconst)
16428 v.AuxInt = int64ToAuxInt(1<<uint(64-c) - 1)
16429 v.AddArg(x)
16430 return true
16431 }
16432
16433
16434
16435 for {
16436 rc := auxIntToInt64(v.AuxInt)
16437 if v_0.Op != OpARM64MOVWUreg {
16438 break
16439 }
16440 if !(rc >= 32) {
16441 break
16442 }
16443 v.reset(OpARM64MOVDconst)
16444 v.AuxInt = int64ToAuxInt(0)
16445 return true
16446 }
16447
16448
16449
16450 for {
16451 rc := auxIntToInt64(v.AuxInt)
16452 if v_0.Op != OpARM64MOVHUreg {
16453 break
16454 }
16455 if !(rc >= 16) {
16456 break
16457 }
16458 v.reset(OpARM64MOVDconst)
16459 v.AuxInt = int64ToAuxInt(0)
16460 return true
16461 }
16462
16463
16464
16465 for {
16466 rc := auxIntToInt64(v.AuxInt)
16467 if v_0.Op != OpARM64MOVBUreg {
16468 break
16469 }
16470 if !(rc >= 8) {
16471 break
16472 }
16473 v.reset(OpARM64MOVDconst)
16474 v.AuxInt = int64ToAuxInt(0)
16475 return true
16476 }
16477
16478
16479
16480 for {
16481 rc := auxIntToInt64(v.AuxInt)
16482 if v_0.Op != OpARM64SLLconst {
16483 break
16484 }
16485 lc := auxIntToInt64(v_0.AuxInt)
16486 x := v_0.Args[0]
16487 if !(lc > rc) {
16488 break
16489 }
16490 v.reset(OpARM64UBFIZ)
16491 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc-rc, 64-lc))
16492 v.AddArg(x)
16493 return true
16494 }
16495
16496
16497
16498 for {
16499 rc := auxIntToInt64(v.AuxInt)
16500 if v_0.Op != OpARM64SLLconst {
16501 break
16502 }
16503 lc := auxIntToInt64(v_0.AuxInt)
16504 x := v_0.Args[0]
16505 if !(lc < rc) {
16506 break
16507 }
16508 v.reset(OpARM64UBFX)
16509 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc-lc, 64-rc))
16510 v.AddArg(x)
16511 return true
16512 }
16513
16514
16515
16516 for {
16517 rc := auxIntToInt64(v.AuxInt)
16518 if v_0.Op != OpARM64MOVWUreg {
16519 break
16520 }
16521 x := v_0.Args[0]
16522 if !(rc < 32) {
16523 break
16524 }
16525 v.reset(OpARM64UBFX)
16526 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 32-rc))
16527 v.AddArg(x)
16528 return true
16529 }
16530
16531
16532
16533 for {
16534 rc := auxIntToInt64(v.AuxInt)
16535 if v_0.Op != OpARM64MOVHUreg {
16536 break
16537 }
16538 x := v_0.Args[0]
16539 if !(rc < 16) {
16540 break
16541 }
16542 v.reset(OpARM64UBFX)
16543 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 16-rc))
16544 v.AddArg(x)
16545 return true
16546 }
16547
16548
16549
16550 for {
16551 rc := auxIntToInt64(v.AuxInt)
16552 if v_0.Op != OpARM64MOVBUreg {
16553 break
16554 }
16555 x := v_0.Args[0]
16556 if !(rc < 8) {
16557 break
16558 }
16559 v.reset(OpARM64UBFX)
16560 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 8-rc))
16561 v.AddArg(x)
16562 return true
16563 }
16564
16565
16566
16567 for {
16568 sc := auxIntToInt64(v.AuxInt)
16569 if v_0.Op != OpARM64ANDconst {
16570 break
16571 }
16572 ac := auxIntToInt64(v_0.AuxInt)
16573 x := v_0.Args[0]
16574 if !(isARM64BFMask(sc, ac, sc)) {
16575 break
16576 }
16577 v.reset(OpARM64UBFX)
16578 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(sc, arm64BFWidth(ac, sc)))
16579 v.AddArg(x)
16580 return true
16581 }
16582
16583
16584
16585 for {
16586 sc := auxIntToInt64(v.AuxInt)
16587 if v_0.Op != OpARM64UBFX {
16588 break
16589 }
16590 bfc := auxIntToArm64BitField(v_0.AuxInt)
16591 x := v_0.Args[0]
16592 if !(sc < bfc.width()) {
16593 break
16594 }
16595 v.reset(OpARM64UBFX)
16596 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb()+sc, bfc.width()-sc))
16597 v.AddArg(x)
16598 return true
16599 }
16600
16601
16602
16603 for {
16604 sc := auxIntToInt64(v.AuxInt)
16605 if v_0.Op != OpARM64UBFIZ {
16606 break
16607 }
16608 bfc := auxIntToArm64BitField(v_0.AuxInt)
16609 x := v_0.Args[0]
16610 if !(sc == bfc.lsb()) {
16611 break
16612 }
16613 v.reset(OpARM64ANDconst)
16614 v.AuxInt = int64ToAuxInt(1<<uint(bfc.width()) - 1)
16615 v.AddArg(x)
16616 return true
16617 }
16618
16619
16620
16621 for {
16622 sc := auxIntToInt64(v.AuxInt)
16623 if v_0.Op != OpARM64UBFIZ {
16624 break
16625 }
16626 bfc := auxIntToArm64BitField(v_0.AuxInt)
16627 x := v_0.Args[0]
16628 if !(sc < bfc.lsb()) {
16629 break
16630 }
16631 v.reset(OpARM64UBFIZ)
16632 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb()-sc, bfc.width()))
16633 v.AddArg(x)
16634 return true
16635 }
16636
16637
16638
16639 for {
16640 sc := auxIntToInt64(v.AuxInt)
16641 if v_0.Op != OpARM64UBFIZ {
16642 break
16643 }
16644 bfc := auxIntToArm64BitField(v_0.AuxInt)
16645 x := v_0.Args[0]
16646 if !(sc > bfc.lsb() && sc < bfc.lsb()+bfc.width()) {
16647 break
16648 }
16649 v.reset(OpARM64UBFX)
16650 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(sc-bfc.lsb(), bfc.lsb()+bfc.width()-sc))
16651 v.AddArg(x)
16652 return true
16653 }
16654 return false
16655 }
16656 func rewriteValueARM64_OpARM64STP(v *Value) bool {
16657 v_3 := v.Args[3]
16658 v_2 := v.Args[2]
16659 v_1 := v.Args[1]
16660 v_0 := v.Args[0]
16661 b := v.Block
16662 config := b.Func.Config
16663
16664
16665
16666 for {
16667 off1 := auxIntToInt32(v.AuxInt)
16668 sym := auxToSym(v.Aux)
16669 if v_0.Op != OpARM64ADDconst {
16670 break
16671 }
16672 off2 := auxIntToInt64(v_0.AuxInt)
16673 ptr := v_0.Args[0]
16674 val1 := v_1
16675 val2 := v_2
16676 mem := v_3
16677 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
16678 break
16679 }
16680 v.reset(OpARM64STP)
16681 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
16682 v.Aux = symToAux(sym)
16683 v.AddArg4(ptr, val1, val2, mem)
16684 return true
16685 }
16686
16687
16688
16689 for {
16690 off1 := auxIntToInt32(v.AuxInt)
16691 sym1 := auxToSym(v.Aux)
16692 if v_0.Op != OpARM64MOVDaddr {
16693 break
16694 }
16695 off2 := auxIntToInt32(v_0.AuxInt)
16696 sym2 := auxToSym(v_0.Aux)
16697 ptr := v_0.Args[0]
16698 val1 := v_1
16699 val2 := v_2
16700 mem := v_3
16701 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
16702 break
16703 }
16704 v.reset(OpARM64STP)
16705 v.AuxInt = int32ToAuxInt(off1 + off2)
16706 v.Aux = symToAux(mergeSym(sym1, sym2))
16707 v.AddArg4(ptr, val1, val2, mem)
16708 return true
16709 }
16710 return false
16711 }
16712 func rewriteValueARM64_OpARM64SUB(v *Value) bool {
16713 v_1 := v.Args[1]
16714 v_0 := v.Args[0]
16715 b := v.Block
16716
16717
16718 for {
16719 x := v_0
16720 if v_1.Op != OpARM64MOVDconst {
16721 break
16722 }
16723 c := auxIntToInt64(v_1.AuxInt)
16724 v.reset(OpARM64SUBconst)
16725 v.AuxInt = int64ToAuxInt(c)
16726 v.AddArg(x)
16727 return true
16728 }
16729
16730
16731
16732 for {
16733 a := v_0
16734 l := v_1
16735 if l.Op != OpARM64MUL {
16736 break
16737 }
16738 y := l.Args[1]
16739 x := l.Args[0]
16740 if !(l.Uses == 1 && clobber(l)) {
16741 break
16742 }
16743 v.reset(OpARM64MSUB)
16744 v.AddArg3(a, x, y)
16745 return true
16746 }
16747
16748
16749
16750 for {
16751 a := v_0
16752 l := v_1
16753 if l.Op != OpARM64MNEG {
16754 break
16755 }
16756 y := l.Args[1]
16757 x := l.Args[0]
16758 if !(l.Uses == 1 && clobber(l)) {
16759 break
16760 }
16761 v.reset(OpARM64MADD)
16762 v.AddArg3(a, x, y)
16763 return true
16764 }
16765
16766
16767
16768 for {
16769 a := v_0
16770 l := v_1
16771 if l.Op != OpARM64MULW {
16772 break
16773 }
16774 y := l.Args[1]
16775 x := l.Args[0]
16776 if !(v.Type.Size() <= 4 && l.Uses == 1 && clobber(l)) {
16777 break
16778 }
16779 v.reset(OpARM64MSUBW)
16780 v.AddArg3(a, x, y)
16781 return true
16782 }
16783
16784
16785
16786 for {
16787 a := v_0
16788 l := v_1
16789 if l.Op != OpARM64MNEGW {
16790 break
16791 }
16792 y := l.Args[1]
16793 x := l.Args[0]
16794 if !(v.Type.Size() <= 4 && l.Uses == 1 && clobber(l)) {
16795 break
16796 }
16797 v.reset(OpARM64MADDW)
16798 v.AddArg3(a, x, y)
16799 return true
16800 }
16801
16802
16803
16804 for {
16805 t := v.Type
16806 a := v_0
16807 p := v_1
16808 if p.Op != OpARM64ADDconst {
16809 break
16810 }
16811 c := auxIntToInt64(p.AuxInt)
16812 m := p.Args[0]
16813 if m.Op != OpARM64MUL || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
16814 break
16815 }
16816 v.reset(OpARM64SUBconst)
16817 v.AuxInt = int64ToAuxInt(c)
16818 v0 := b.NewValue0(v.Pos, OpARM64SUB, v.Type)
16819 v0.AddArg2(a, m)
16820 v.AddArg(v0)
16821 return true
16822 }
16823
16824
16825
16826 for {
16827 t := v.Type
16828 a := v_0
16829 p := v_1
16830 if p.Op != OpARM64ADDconst {
16831 break
16832 }
16833 c := auxIntToInt64(p.AuxInt)
16834 m := p.Args[0]
16835 if m.Op != OpARM64MULW || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
16836 break
16837 }
16838 v.reset(OpARM64SUBconst)
16839 v.AuxInt = int64ToAuxInt(c)
16840 v0 := b.NewValue0(v.Pos, OpARM64SUB, v.Type)
16841 v0.AddArg2(a, m)
16842 v.AddArg(v0)
16843 return true
16844 }
16845
16846
16847
16848 for {
16849 t := v.Type
16850 a := v_0
16851 p := v_1
16852 if p.Op != OpARM64ADDconst {
16853 break
16854 }
16855 c := auxIntToInt64(p.AuxInt)
16856 m := p.Args[0]
16857 if m.Op != OpARM64MNEG || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
16858 break
16859 }
16860 v.reset(OpARM64SUBconst)
16861 v.AuxInt = int64ToAuxInt(c)
16862 v0 := b.NewValue0(v.Pos, OpARM64SUB, v.Type)
16863 v0.AddArg2(a, m)
16864 v.AddArg(v0)
16865 return true
16866 }
16867
16868
16869
16870 for {
16871 t := v.Type
16872 a := v_0
16873 p := v_1
16874 if p.Op != OpARM64ADDconst {
16875 break
16876 }
16877 c := auxIntToInt64(p.AuxInt)
16878 m := p.Args[0]
16879 if m.Op != OpARM64MNEGW || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
16880 break
16881 }
16882 v.reset(OpARM64SUBconst)
16883 v.AuxInt = int64ToAuxInt(c)
16884 v0 := b.NewValue0(v.Pos, OpARM64SUB, v.Type)
16885 v0.AddArg2(a, m)
16886 v.AddArg(v0)
16887 return true
16888 }
16889
16890
16891
16892 for {
16893 t := v.Type
16894 a := v_0
16895 p := v_1
16896 if p.Op != OpARM64SUBconst {
16897 break
16898 }
16899 c := auxIntToInt64(p.AuxInt)
16900 m := p.Args[0]
16901 if m.Op != OpARM64MUL || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
16902 break
16903 }
16904 v.reset(OpARM64ADDconst)
16905 v.AuxInt = int64ToAuxInt(c)
16906 v0 := b.NewValue0(v.Pos, OpARM64SUB, v.Type)
16907 v0.AddArg2(a, m)
16908 v.AddArg(v0)
16909 return true
16910 }
16911
16912
16913
16914 for {
16915 t := v.Type
16916 a := v_0
16917 p := v_1
16918 if p.Op != OpARM64SUBconst {
16919 break
16920 }
16921 c := auxIntToInt64(p.AuxInt)
16922 m := p.Args[0]
16923 if m.Op != OpARM64MULW || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
16924 break
16925 }
16926 v.reset(OpARM64ADDconst)
16927 v.AuxInt = int64ToAuxInt(c)
16928 v0 := b.NewValue0(v.Pos, OpARM64SUB, v.Type)
16929 v0.AddArg2(a, m)
16930 v.AddArg(v0)
16931 return true
16932 }
16933
16934
16935
16936 for {
16937 t := v.Type
16938 a := v_0
16939 p := v_1
16940 if p.Op != OpARM64SUBconst {
16941 break
16942 }
16943 c := auxIntToInt64(p.AuxInt)
16944 m := p.Args[0]
16945 if m.Op != OpARM64MNEG || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
16946 break
16947 }
16948 v.reset(OpARM64ADDconst)
16949 v.AuxInt = int64ToAuxInt(c)
16950 v0 := b.NewValue0(v.Pos, OpARM64SUB, v.Type)
16951 v0.AddArg2(a, m)
16952 v.AddArg(v0)
16953 return true
16954 }
16955
16956
16957
16958 for {
16959 t := v.Type
16960 a := v_0
16961 p := v_1
16962 if p.Op != OpARM64SUBconst {
16963 break
16964 }
16965 c := auxIntToInt64(p.AuxInt)
16966 m := p.Args[0]
16967 if m.Op != OpARM64MNEGW || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
16968 break
16969 }
16970 v.reset(OpARM64ADDconst)
16971 v.AuxInt = int64ToAuxInt(c)
16972 v0 := b.NewValue0(v.Pos, OpARM64SUB, v.Type)
16973 v0.AddArg2(a, m)
16974 v.AddArg(v0)
16975 return true
16976 }
16977
16978
16979 for {
16980 x := v_0
16981 if v_1.Op != OpARM64NEG {
16982 break
16983 }
16984 y := v_1.Args[0]
16985 v.reset(OpARM64ADD)
16986 v.AddArg2(x, y)
16987 return true
16988 }
16989
16990
16991 for {
16992 x := v_0
16993 if x != v_1 {
16994 break
16995 }
16996 v.reset(OpARM64MOVDconst)
16997 v.AuxInt = int64ToAuxInt(0)
16998 return true
16999 }
17000
17001
17002 for {
17003 x := v_0
17004 if v_1.Op != OpARM64SUB {
17005 break
17006 }
17007 z := v_1.Args[1]
17008 y := v_1.Args[0]
17009 v.reset(OpARM64SUB)
17010 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
17011 v0.AddArg2(x, z)
17012 v.AddArg2(v0, y)
17013 return true
17014 }
17015
17016
17017 for {
17018 if v_0.Op != OpARM64SUB {
17019 break
17020 }
17021 y := v_0.Args[1]
17022 x := v_0.Args[0]
17023 z := v_1
17024 v.reset(OpARM64SUB)
17025 v0 := b.NewValue0(v.Pos, OpARM64ADD, y.Type)
17026 v0.AddArg2(y, z)
17027 v.AddArg2(x, v0)
17028 return true
17029 }
17030
17031
17032
17033 for {
17034 x0 := v_0
17035 x1 := v_1
17036 if x1.Op != OpARM64SLLconst {
17037 break
17038 }
17039 c := auxIntToInt64(x1.AuxInt)
17040 y := x1.Args[0]
17041 if !(clobberIfDead(x1)) {
17042 break
17043 }
17044 v.reset(OpARM64SUBshiftLL)
17045 v.AuxInt = int64ToAuxInt(c)
17046 v.AddArg2(x0, y)
17047 return true
17048 }
17049
17050
17051
17052 for {
17053 x0 := v_0
17054 x1 := v_1
17055 if x1.Op != OpARM64SRLconst {
17056 break
17057 }
17058 c := auxIntToInt64(x1.AuxInt)
17059 y := x1.Args[0]
17060 if !(clobberIfDead(x1)) {
17061 break
17062 }
17063 v.reset(OpARM64SUBshiftRL)
17064 v.AuxInt = int64ToAuxInt(c)
17065 v.AddArg2(x0, y)
17066 return true
17067 }
17068
17069
17070
17071 for {
17072 x0 := v_0
17073 x1 := v_1
17074 if x1.Op != OpARM64SRAconst {
17075 break
17076 }
17077 c := auxIntToInt64(x1.AuxInt)
17078 y := x1.Args[0]
17079 if !(clobberIfDead(x1)) {
17080 break
17081 }
17082 v.reset(OpARM64SUBshiftRA)
17083 v.AuxInt = int64ToAuxInt(c)
17084 v.AddArg2(x0, y)
17085 return true
17086 }
17087 return false
17088 }
17089 func rewriteValueARM64_OpARM64SUBconst(v *Value) bool {
17090 v_0 := v.Args[0]
17091
17092
17093 for {
17094 if auxIntToInt64(v.AuxInt) != 0 {
17095 break
17096 }
17097 x := v_0
17098 v.copyOf(x)
17099 return true
17100 }
17101
17102
17103 for {
17104 c := auxIntToInt64(v.AuxInt)
17105 if v_0.Op != OpARM64MOVDconst {
17106 break
17107 }
17108 d := auxIntToInt64(v_0.AuxInt)
17109 v.reset(OpARM64MOVDconst)
17110 v.AuxInt = int64ToAuxInt(d - c)
17111 return true
17112 }
17113
17114
17115 for {
17116 c := auxIntToInt64(v.AuxInt)
17117 if v_0.Op != OpARM64SUBconst {
17118 break
17119 }
17120 d := auxIntToInt64(v_0.AuxInt)
17121 x := v_0.Args[0]
17122 v.reset(OpARM64ADDconst)
17123 v.AuxInt = int64ToAuxInt(-c - d)
17124 v.AddArg(x)
17125 return true
17126 }
17127
17128
17129 for {
17130 c := auxIntToInt64(v.AuxInt)
17131 if v_0.Op != OpARM64ADDconst {
17132 break
17133 }
17134 d := auxIntToInt64(v_0.AuxInt)
17135 x := v_0.Args[0]
17136 v.reset(OpARM64ADDconst)
17137 v.AuxInt = int64ToAuxInt(-c + d)
17138 v.AddArg(x)
17139 return true
17140 }
17141 return false
17142 }
17143 func rewriteValueARM64_OpARM64SUBshiftLL(v *Value) bool {
17144 v_1 := v.Args[1]
17145 v_0 := v.Args[0]
17146
17147
17148 for {
17149 d := auxIntToInt64(v.AuxInt)
17150 x := v_0
17151 if v_1.Op != OpARM64MOVDconst {
17152 break
17153 }
17154 c := auxIntToInt64(v_1.AuxInt)
17155 v.reset(OpARM64SUBconst)
17156 v.AuxInt = int64ToAuxInt(int64(uint64(c) << uint64(d)))
17157 v.AddArg(x)
17158 return true
17159 }
17160
17161
17162 for {
17163 c := auxIntToInt64(v.AuxInt)
17164 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != c {
17165 break
17166 }
17167 x := v_0.Args[0]
17168 if x != v_1 {
17169 break
17170 }
17171 v.reset(OpARM64MOVDconst)
17172 v.AuxInt = int64ToAuxInt(0)
17173 return true
17174 }
17175 return false
17176 }
17177 func rewriteValueARM64_OpARM64SUBshiftRA(v *Value) bool {
17178 v_1 := v.Args[1]
17179 v_0 := v.Args[0]
17180
17181
17182 for {
17183 d := auxIntToInt64(v.AuxInt)
17184 x := v_0
17185 if v_1.Op != OpARM64MOVDconst {
17186 break
17187 }
17188 c := auxIntToInt64(v_1.AuxInt)
17189 v.reset(OpARM64SUBconst)
17190 v.AuxInt = int64ToAuxInt(c >> uint64(d))
17191 v.AddArg(x)
17192 return true
17193 }
17194
17195
17196 for {
17197 c := auxIntToInt64(v.AuxInt)
17198 if v_0.Op != OpARM64SRAconst || auxIntToInt64(v_0.AuxInt) != c {
17199 break
17200 }
17201 x := v_0.Args[0]
17202 if x != v_1 {
17203 break
17204 }
17205 v.reset(OpARM64MOVDconst)
17206 v.AuxInt = int64ToAuxInt(0)
17207 return true
17208 }
17209 return false
17210 }
17211 func rewriteValueARM64_OpARM64SUBshiftRL(v *Value) bool {
17212 v_1 := v.Args[1]
17213 v_0 := v.Args[0]
17214
17215
17216 for {
17217 d := auxIntToInt64(v.AuxInt)
17218 x := v_0
17219 if v_1.Op != OpARM64MOVDconst {
17220 break
17221 }
17222 c := auxIntToInt64(v_1.AuxInt)
17223 v.reset(OpARM64SUBconst)
17224 v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
17225 v.AddArg(x)
17226 return true
17227 }
17228
17229
17230 for {
17231 c := auxIntToInt64(v.AuxInt)
17232 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != c {
17233 break
17234 }
17235 x := v_0.Args[0]
17236 if x != v_1 {
17237 break
17238 }
17239 v.reset(OpARM64MOVDconst)
17240 v.AuxInt = int64ToAuxInt(0)
17241 return true
17242 }
17243 return false
17244 }
17245 func rewriteValueARM64_OpARM64TST(v *Value) bool {
17246 v_1 := v.Args[1]
17247 v_0 := v.Args[0]
17248
17249
17250 for {
17251 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
17252 x := v_0
17253 if v_1.Op != OpARM64MOVDconst {
17254 continue
17255 }
17256 c := auxIntToInt64(v_1.AuxInt)
17257 v.reset(OpARM64TSTconst)
17258 v.AuxInt = int64ToAuxInt(c)
17259 v.AddArg(x)
17260 return true
17261 }
17262 break
17263 }
17264
17265
17266
17267 for {
17268 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
17269 x0 := v_0
17270 x1 := v_1
17271 if x1.Op != OpARM64SLLconst {
17272 continue
17273 }
17274 c := auxIntToInt64(x1.AuxInt)
17275 y := x1.Args[0]
17276 if !(clobberIfDead(x1)) {
17277 continue
17278 }
17279 v.reset(OpARM64TSTshiftLL)
17280 v.AuxInt = int64ToAuxInt(c)
17281 v.AddArg2(x0, y)
17282 return true
17283 }
17284 break
17285 }
17286
17287
17288
17289 for {
17290 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
17291 x0 := v_0
17292 x1 := v_1
17293 if x1.Op != OpARM64SRLconst {
17294 continue
17295 }
17296 c := auxIntToInt64(x1.AuxInt)
17297 y := x1.Args[0]
17298 if !(clobberIfDead(x1)) {
17299 continue
17300 }
17301 v.reset(OpARM64TSTshiftRL)
17302 v.AuxInt = int64ToAuxInt(c)
17303 v.AddArg2(x0, y)
17304 return true
17305 }
17306 break
17307 }
17308
17309
17310
17311 for {
17312 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
17313 x0 := v_0
17314 x1 := v_1
17315 if x1.Op != OpARM64SRAconst {
17316 continue
17317 }
17318 c := auxIntToInt64(x1.AuxInt)
17319 y := x1.Args[0]
17320 if !(clobberIfDead(x1)) {
17321 continue
17322 }
17323 v.reset(OpARM64TSTshiftRA)
17324 v.AuxInt = int64ToAuxInt(c)
17325 v.AddArg2(x0, y)
17326 return true
17327 }
17328 break
17329 }
17330
17331
17332
17333 for {
17334 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
17335 x0 := v_0
17336 x1 := v_1
17337 if x1.Op != OpARM64RORconst {
17338 continue
17339 }
17340 c := auxIntToInt64(x1.AuxInt)
17341 y := x1.Args[0]
17342 if !(clobberIfDead(x1)) {
17343 continue
17344 }
17345 v.reset(OpARM64TSTshiftRO)
17346 v.AuxInt = int64ToAuxInt(c)
17347 v.AddArg2(x0, y)
17348 return true
17349 }
17350 break
17351 }
17352 return false
17353 }
17354 func rewriteValueARM64_OpARM64TSTW(v *Value) bool {
17355 v_1 := v.Args[1]
17356 v_0 := v.Args[0]
17357
17358
17359 for {
17360 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
17361 x := v_0
17362 if v_1.Op != OpARM64MOVDconst {
17363 continue
17364 }
17365 c := auxIntToInt64(v_1.AuxInt)
17366 v.reset(OpARM64TSTWconst)
17367 v.AuxInt = int32ToAuxInt(int32(c))
17368 v.AddArg(x)
17369 return true
17370 }
17371 break
17372 }
17373 return false
17374 }
17375 func rewriteValueARM64_OpARM64TSTWconst(v *Value) bool {
17376 v_0 := v.Args[0]
17377
17378
17379 for {
17380 y := auxIntToInt32(v.AuxInt)
17381 if v_0.Op != OpARM64MOVDconst {
17382 break
17383 }
17384 x := auxIntToInt64(v_0.AuxInt)
17385 v.reset(OpARM64FlagConstant)
17386 v.AuxInt = flagConstantToAuxInt(logicFlags32(int32(x) & y))
17387 return true
17388 }
17389 return false
17390 }
17391 func rewriteValueARM64_OpARM64TSTconst(v *Value) bool {
17392 v_0 := v.Args[0]
17393
17394
17395 for {
17396 y := auxIntToInt64(v.AuxInt)
17397 if v_0.Op != OpARM64MOVDconst {
17398 break
17399 }
17400 x := auxIntToInt64(v_0.AuxInt)
17401 v.reset(OpARM64FlagConstant)
17402 v.AuxInt = flagConstantToAuxInt(logicFlags64(x & y))
17403 return true
17404 }
17405 return false
17406 }
17407 func rewriteValueARM64_OpARM64TSTshiftLL(v *Value) bool {
17408 v_1 := v.Args[1]
17409 v_0 := v.Args[0]
17410 b := v.Block
17411
17412
17413 for {
17414 d := auxIntToInt64(v.AuxInt)
17415 if v_0.Op != OpARM64MOVDconst {
17416 break
17417 }
17418 c := auxIntToInt64(v_0.AuxInt)
17419 x := v_1
17420 v.reset(OpARM64TSTconst)
17421 v.AuxInt = int64ToAuxInt(c)
17422 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
17423 v0.AuxInt = int64ToAuxInt(d)
17424 v0.AddArg(x)
17425 v.AddArg(v0)
17426 return true
17427 }
17428
17429
17430 for {
17431 d := auxIntToInt64(v.AuxInt)
17432 x := v_0
17433 if v_1.Op != OpARM64MOVDconst {
17434 break
17435 }
17436 c := auxIntToInt64(v_1.AuxInt)
17437 v.reset(OpARM64TSTconst)
17438 v.AuxInt = int64ToAuxInt(int64(uint64(c) << uint64(d)))
17439 v.AddArg(x)
17440 return true
17441 }
17442 return false
17443 }
17444 func rewriteValueARM64_OpARM64TSTshiftRA(v *Value) bool {
17445 v_1 := v.Args[1]
17446 v_0 := v.Args[0]
17447 b := v.Block
17448
17449
17450 for {
17451 d := auxIntToInt64(v.AuxInt)
17452 if v_0.Op != OpARM64MOVDconst {
17453 break
17454 }
17455 c := auxIntToInt64(v_0.AuxInt)
17456 x := v_1
17457 v.reset(OpARM64TSTconst)
17458 v.AuxInt = int64ToAuxInt(c)
17459 v0 := b.NewValue0(v.Pos, OpARM64SRAconst, x.Type)
17460 v0.AuxInt = int64ToAuxInt(d)
17461 v0.AddArg(x)
17462 v.AddArg(v0)
17463 return true
17464 }
17465
17466
17467 for {
17468 d := auxIntToInt64(v.AuxInt)
17469 x := v_0
17470 if v_1.Op != OpARM64MOVDconst {
17471 break
17472 }
17473 c := auxIntToInt64(v_1.AuxInt)
17474 v.reset(OpARM64TSTconst)
17475 v.AuxInt = int64ToAuxInt(c >> uint64(d))
17476 v.AddArg(x)
17477 return true
17478 }
17479 return false
17480 }
17481 func rewriteValueARM64_OpARM64TSTshiftRL(v *Value) bool {
17482 v_1 := v.Args[1]
17483 v_0 := v.Args[0]
17484 b := v.Block
17485
17486
17487 for {
17488 d := auxIntToInt64(v.AuxInt)
17489 if v_0.Op != OpARM64MOVDconst {
17490 break
17491 }
17492 c := auxIntToInt64(v_0.AuxInt)
17493 x := v_1
17494 v.reset(OpARM64TSTconst)
17495 v.AuxInt = int64ToAuxInt(c)
17496 v0 := b.NewValue0(v.Pos, OpARM64SRLconst, x.Type)
17497 v0.AuxInt = int64ToAuxInt(d)
17498 v0.AddArg(x)
17499 v.AddArg(v0)
17500 return true
17501 }
17502
17503
17504 for {
17505 d := auxIntToInt64(v.AuxInt)
17506 x := v_0
17507 if v_1.Op != OpARM64MOVDconst {
17508 break
17509 }
17510 c := auxIntToInt64(v_1.AuxInt)
17511 v.reset(OpARM64TSTconst)
17512 v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
17513 v.AddArg(x)
17514 return true
17515 }
17516 return false
17517 }
17518 func rewriteValueARM64_OpARM64TSTshiftRO(v *Value) bool {
17519 v_1 := v.Args[1]
17520 v_0 := v.Args[0]
17521 b := v.Block
17522
17523
17524 for {
17525 d := auxIntToInt64(v.AuxInt)
17526 if v_0.Op != OpARM64MOVDconst {
17527 break
17528 }
17529 c := auxIntToInt64(v_0.AuxInt)
17530 x := v_1
17531 v.reset(OpARM64TSTconst)
17532 v.AuxInt = int64ToAuxInt(c)
17533 v0 := b.NewValue0(v.Pos, OpARM64RORconst, x.Type)
17534 v0.AuxInt = int64ToAuxInt(d)
17535 v0.AddArg(x)
17536 v.AddArg(v0)
17537 return true
17538 }
17539
17540
17541 for {
17542 d := auxIntToInt64(v.AuxInt)
17543 x := v_0
17544 if v_1.Op != OpARM64MOVDconst {
17545 break
17546 }
17547 c := auxIntToInt64(v_1.AuxInt)
17548 v.reset(OpARM64TSTconst)
17549 v.AuxInt = int64ToAuxInt(rotateRight64(c, d))
17550 v.AddArg(x)
17551 return true
17552 }
17553 return false
17554 }
17555 func rewriteValueARM64_OpARM64UBFIZ(v *Value) bool {
17556 v_0 := v.Args[0]
17557
17558
17559
17560 for {
17561 bfc := auxIntToArm64BitField(v.AuxInt)
17562 if v_0.Op != OpARM64SLLconst {
17563 break
17564 }
17565 sc := auxIntToInt64(v_0.AuxInt)
17566 x := v_0.Args[0]
17567 if !(sc < bfc.width()) {
17568 break
17569 }
17570 v.reset(OpARM64UBFIZ)
17571 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb()+sc, bfc.width()-sc))
17572 v.AddArg(x)
17573 return true
17574 }
17575 return false
17576 }
17577 func rewriteValueARM64_OpARM64UBFX(v *Value) bool {
17578 v_0 := v.Args[0]
17579
17580
17581
17582 for {
17583 bfc := auxIntToArm64BitField(v.AuxInt)
17584 if v_0.Op != OpARM64ANDconst {
17585 break
17586 }
17587 c := auxIntToInt64(v_0.AuxInt)
17588 x := v_0.Args[0]
17589 if !(isARM64BFMask(0, c, 0) && bfc.lsb()+bfc.width() <= arm64BFWidth(c, 0)) {
17590 break
17591 }
17592 v.reset(OpARM64UBFX)
17593 v.AuxInt = arm64BitFieldToAuxInt(bfc)
17594 v.AddArg(x)
17595 return true
17596 }
17597
17598
17599
17600 for {
17601 bfc := auxIntToArm64BitField(v.AuxInt)
17602 e := v_0
17603 if e.Op != OpARM64MOVWUreg {
17604 break
17605 }
17606 x := e.Args[0]
17607 if !(e.Uses == 1 && bfc.lsb() < 32) {
17608 break
17609 }
17610 v.reset(OpARM64UBFX)
17611 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb(), min(bfc.width(), 32-bfc.lsb())))
17612 v.AddArg(x)
17613 return true
17614 }
17615
17616
17617
17618 for {
17619 bfc := auxIntToArm64BitField(v.AuxInt)
17620 e := v_0
17621 if e.Op != OpARM64MOVHUreg {
17622 break
17623 }
17624 x := e.Args[0]
17625 if !(e.Uses == 1 && bfc.lsb() < 16) {
17626 break
17627 }
17628 v.reset(OpARM64UBFX)
17629 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb(), min(bfc.width(), 16-bfc.lsb())))
17630 v.AddArg(x)
17631 return true
17632 }
17633
17634
17635
17636 for {
17637 bfc := auxIntToArm64BitField(v.AuxInt)
17638 e := v_0
17639 if e.Op != OpARM64MOVBUreg {
17640 break
17641 }
17642 x := e.Args[0]
17643 if !(e.Uses == 1 && bfc.lsb() < 8) {
17644 break
17645 }
17646 v.reset(OpARM64UBFX)
17647 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb(), min(bfc.width(), 8-bfc.lsb())))
17648 v.AddArg(x)
17649 return true
17650 }
17651
17652
17653
17654 for {
17655 bfc := auxIntToArm64BitField(v.AuxInt)
17656 if v_0.Op != OpARM64SRLconst {
17657 break
17658 }
17659 sc := auxIntToInt64(v_0.AuxInt)
17660 x := v_0.Args[0]
17661 if !(sc+bfc.width()+bfc.lsb() < 64) {
17662 break
17663 }
17664 v.reset(OpARM64UBFX)
17665 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb()+sc, bfc.width()))
17666 v.AddArg(x)
17667 return true
17668 }
17669
17670
17671
17672 for {
17673 bfc := auxIntToArm64BitField(v.AuxInt)
17674 if v_0.Op != OpARM64SLLconst {
17675 break
17676 }
17677 sc := auxIntToInt64(v_0.AuxInt)
17678 x := v_0.Args[0]
17679 if !(sc == bfc.lsb()) {
17680 break
17681 }
17682 v.reset(OpARM64ANDconst)
17683 v.AuxInt = int64ToAuxInt(1<<uint(bfc.width()) - 1)
17684 v.AddArg(x)
17685 return true
17686 }
17687
17688
17689
17690 for {
17691 bfc := auxIntToArm64BitField(v.AuxInt)
17692 if v_0.Op != OpARM64SLLconst {
17693 break
17694 }
17695 sc := auxIntToInt64(v_0.AuxInt)
17696 x := v_0.Args[0]
17697 if !(sc < bfc.lsb()) {
17698 break
17699 }
17700 v.reset(OpARM64UBFX)
17701 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb()-sc, bfc.width()))
17702 v.AddArg(x)
17703 return true
17704 }
17705
17706
17707
17708 for {
17709 bfc := auxIntToArm64BitField(v.AuxInt)
17710 if v_0.Op != OpARM64SLLconst {
17711 break
17712 }
17713 sc := auxIntToInt64(v_0.AuxInt)
17714 x := v_0.Args[0]
17715 if !(sc > bfc.lsb() && sc < bfc.lsb()+bfc.width()) {
17716 break
17717 }
17718 v.reset(OpARM64UBFIZ)
17719 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(sc-bfc.lsb(), bfc.lsb()+bfc.width()-sc))
17720 v.AddArg(x)
17721 return true
17722 }
17723 return false
17724 }
17725 func rewriteValueARM64_OpARM64UDIV(v *Value) bool {
17726 v_1 := v.Args[1]
17727 v_0 := v.Args[0]
17728
17729
17730 for {
17731 x := v_0
17732 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
17733 break
17734 }
17735 v.copyOf(x)
17736 return true
17737 }
17738
17739
17740
17741 for {
17742 x := v_0
17743 if v_1.Op != OpARM64MOVDconst {
17744 break
17745 }
17746 c := auxIntToInt64(v_1.AuxInt)
17747 if !(isPowerOfTwo(c)) {
17748 break
17749 }
17750 v.reset(OpARM64SRLconst)
17751 v.AuxInt = int64ToAuxInt(log64(c))
17752 v.AddArg(x)
17753 return true
17754 }
17755
17756
17757
17758 for {
17759 if v_0.Op != OpARM64MOVDconst {
17760 break
17761 }
17762 c := auxIntToInt64(v_0.AuxInt)
17763 if v_1.Op != OpARM64MOVDconst {
17764 break
17765 }
17766 d := auxIntToInt64(v_1.AuxInt)
17767 if !(d != 0) {
17768 break
17769 }
17770 v.reset(OpARM64MOVDconst)
17771 v.AuxInt = int64ToAuxInt(int64(uint64(c) / uint64(d)))
17772 return true
17773 }
17774 return false
17775 }
17776 func rewriteValueARM64_OpARM64UDIVW(v *Value) bool {
17777 v_1 := v.Args[1]
17778 v_0 := v.Args[0]
17779 b := v.Block
17780
17781
17782
17783 for {
17784 x := v_0
17785 if v_1.Op != OpARM64MOVDconst {
17786 break
17787 }
17788 c := auxIntToInt64(v_1.AuxInt)
17789 if !(uint32(c) == 1) {
17790 break
17791 }
17792 v.reset(OpARM64MOVWUreg)
17793 v.AddArg(x)
17794 return true
17795 }
17796
17797
17798
17799 for {
17800 x := v_0
17801 if v_1.Op != OpARM64MOVDconst {
17802 break
17803 }
17804 c := auxIntToInt64(v_1.AuxInt)
17805 if !(isPowerOfTwo(c) && is32Bit(c)) {
17806 break
17807 }
17808 v.reset(OpARM64SRLconst)
17809 v.AuxInt = int64ToAuxInt(log64(c))
17810 v0 := b.NewValue0(v.Pos, OpARM64MOVWUreg, v.Type)
17811 v0.AddArg(x)
17812 v.AddArg(v0)
17813 return true
17814 }
17815
17816
17817
17818 for {
17819 if v_0.Op != OpARM64MOVDconst {
17820 break
17821 }
17822 c := auxIntToInt64(v_0.AuxInt)
17823 if v_1.Op != OpARM64MOVDconst {
17824 break
17825 }
17826 d := auxIntToInt64(v_1.AuxInt)
17827 if !(d != 0) {
17828 break
17829 }
17830 v.reset(OpARM64MOVDconst)
17831 v.AuxInt = int64ToAuxInt(int64(uint32(c) / uint32(d)))
17832 return true
17833 }
17834 return false
17835 }
17836 func rewriteValueARM64_OpARM64UMOD(v *Value) bool {
17837 v_1 := v.Args[1]
17838 v_0 := v.Args[0]
17839 b := v.Block
17840 typ := &b.Func.Config.Types
17841
17842
17843 for {
17844 if v.Type != typ.UInt64 {
17845 break
17846 }
17847 x := v_0
17848 y := v_1
17849 v.reset(OpARM64MSUB)
17850 v.Type = typ.UInt64
17851 v0 := b.NewValue0(v.Pos, OpARM64UDIV, typ.UInt64)
17852 v0.AddArg2(x, y)
17853 v.AddArg3(x, y, v0)
17854 return true
17855 }
17856
17857
17858 for {
17859 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
17860 break
17861 }
17862 v.reset(OpARM64MOVDconst)
17863 v.AuxInt = int64ToAuxInt(0)
17864 return true
17865 }
17866
17867
17868
17869 for {
17870 x := v_0
17871 if v_1.Op != OpARM64MOVDconst {
17872 break
17873 }
17874 c := auxIntToInt64(v_1.AuxInt)
17875 if !(isPowerOfTwo(c)) {
17876 break
17877 }
17878 v.reset(OpARM64ANDconst)
17879 v.AuxInt = int64ToAuxInt(c - 1)
17880 v.AddArg(x)
17881 return true
17882 }
17883
17884
17885
17886 for {
17887 if v_0.Op != OpARM64MOVDconst {
17888 break
17889 }
17890 c := auxIntToInt64(v_0.AuxInt)
17891 if v_1.Op != OpARM64MOVDconst {
17892 break
17893 }
17894 d := auxIntToInt64(v_1.AuxInt)
17895 if !(d != 0) {
17896 break
17897 }
17898 v.reset(OpARM64MOVDconst)
17899 v.AuxInt = int64ToAuxInt(int64(uint64(c) % uint64(d)))
17900 return true
17901 }
17902 return false
17903 }
17904 func rewriteValueARM64_OpARM64UMODW(v *Value) bool {
17905 v_1 := v.Args[1]
17906 v_0 := v.Args[0]
17907 b := v.Block
17908 typ := &b.Func.Config.Types
17909
17910
17911 for {
17912 if v.Type != typ.UInt32 {
17913 break
17914 }
17915 x := v_0
17916 y := v_1
17917 v.reset(OpARM64MSUBW)
17918 v.Type = typ.UInt32
17919 v0 := b.NewValue0(v.Pos, OpARM64UDIVW, typ.UInt32)
17920 v0.AddArg2(x, y)
17921 v.AddArg3(x, y, v0)
17922 return true
17923 }
17924
17925
17926
17927 for {
17928 if v_1.Op != OpARM64MOVDconst {
17929 break
17930 }
17931 c := auxIntToInt64(v_1.AuxInt)
17932 if !(uint32(c) == 1) {
17933 break
17934 }
17935 v.reset(OpARM64MOVDconst)
17936 v.AuxInt = int64ToAuxInt(0)
17937 return true
17938 }
17939
17940
17941
17942 for {
17943 x := v_0
17944 if v_1.Op != OpARM64MOVDconst {
17945 break
17946 }
17947 c := auxIntToInt64(v_1.AuxInt)
17948 if !(isPowerOfTwo(c) && is32Bit(c)) {
17949 break
17950 }
17951 v.reset(OpARM64ANDconst)
17952 v.AuxInt = int64ToAuxInt(c - 1)
17953 v.AddArg(x)
17954 return true
17955 }
17956
17957
17958
17959 for {
17960 if v_0.Op != OpARM64MOVDconst {
17961 break
17962 }
17963 c := auxIntToInt64(v_0.AuxInt)
17964 if v_1.Op != OpARM64MOVDconst {
17965 break
17966 }
17967 d := auxIntToInt64(v_1.AuxInt)
17968 if !(d != 0) {
17969 break
17970 }
17971 v.reset(OpARM64MOVDconst)
17972 v.AuxInt = int64ToAuxInt(int64(uint32(c) % uint32(d)))
17973 return true
17974 }
17975 return false
17976 }
17977 func rewriteValueARM64_OpARM64VBIF16B(v *Value) bool {
17978 v_2 := v.Args[2]
17979 v_1 := v.Args[1]
17980 v_0 := v.Args[0]
17981
17982
17983 for {
17984 x := v_0
17985 y := v_1
17986 if v_2.Op != OpARM64VNOT16B {
17987 break
17988 }
17989 mask := v_2.Args[0]
17990 v.reset(OpARM64VBIT16B)
17991 v.AddArg3(x, y, mask)
17992 return true
17993 }
17994 return false
17995 }
17996 func rewriteValueARM64_OpARM64VBIT16B(v *Value) bool {
17997 v_2 := v.Args[2]
17998 v_1 := v.Args[1]
17999 v_0 := v.Args[0]
18000
18001
18002 for {
18003 x := v_0
18004 y := v_1
18005 if v_2.Op != OpARM64VNOT16B {
18006 break
18007 }
18008 mask := v_2.Args[0]
18009 v.reset(OpARM64VBIF16B)
18010 v.AddArg3(x, y, mask)
18011 return true
18012 }
18013 return false
18014 }
18015 func rewriteValueARM64_OpARM64VDUPBbcast(v *Value) bool {
18016 v_0 := v.Args[0]
18017
18018
18019
18020 for {
18021 i := auxIntToUint8(v.AuxInt)
18022 if v_0.Op != OpARM64VMOVBins {
18023 break
18024 }
18025 j := auxIntToUint8(v_0.AuxInt)
18026 _ = v_0.Args[1]
18027 v_0_1 := v_0.Args[1]
18028 if v_0_1.Op != OpARM64MOVDconst {
18029 break
18030 }
18031 c := auxIntToInt64(v_0_1.AuxInt)
18032 if !(i == j && c >= -128 && c <= 255) {
18033 break
18034 }
18035 v.reset(OpARM64VMOVI16B)
18036 v.AuxInt = uint8ToAuxInt(uint8(c))
18037 return true
18038 }
18039 return false
18040 }
18041 func rewriteValueARM64_OpARM64VFCVTL4S(v *Value) bool {
18042 v_0 := v.Args[0]
18043
18044
18045 for {
18046 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18047 break
18048 }
18049 x := v_0.Args[0]
18050 v.reset(OpARM64VFCVTL2_4S)
18051 v.AddArg(x)
18052 return true
18053 }
18054 return false
18055 }
18056 func rewriteValueARM64_OpARM64VMOVDins0(v *Value) bool {
18057 v_1 := v.Args[1]
18058 v_0 := v.Args[0]
18059
18060
18061 for {
18062 if auxIntToUint8(v.AuxInt) != 1 {
18063 break
18064 }
18065 dst := v_0
18066 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18067 break
18068 }
18069 v_1_0 := v_1.Args[0]
18070 if v_1_0.Op != OpARM64VFCVTN2D {
18071 break
18072 }
18073 y := v_1_0.Args[0]
18074 v.reset(OpARM64VFCVTN2_2D)
18075 v.AddArg2(dst, y)
18076 return true
18077 }
18078
18079
18080 for {
18081 if auxIntToUint8(v.AuxInt) != 1 {
18082 break
18083 }
18084 dst := v_0
18085 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18086 break
18087 }
18088 v_1_0 := v_1.Args[0]
18089 if v_1_0.Op != OpARM64VSHRN2D {
18090 break
18091 }
18092 c := auxIntToUint8(v_1_0.AuxInt)
18093 y := v_1_0.Args[0]
18094 v.reset(OpARM64VSHRN2_2D)
18095 v.AuxInt = uint8ToAuxInt(c)
18096 v.AddArg2(dst, y)
18097 return true
18098 }
18099
18100
18101 for {
18102 if auxIntToUint8(v.AuxInt) != 1 {
18103 break
18104 }
18105 dst := v_0
18106 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18107 break
18108 }
18109 v_1_0 := v_1.Args[0]
18110 if v_1_0.Op != OpARM64VSHRN4S {
18111 break
18112 }
18113 c := auxIntToUint8(v_1_0.AuxInt)
18114 y := v_1_0.Args[0]
18115 v.reset(OpARM64VSHRN2_4S)
18116 v.AuxInt = uint8ToAuxInt(c)
18117 v.AddArg2(dst, y)
18118 return true
18119 }
18120
18121
18122 for {
18123 if auxIntToUint8(v.AuxInt) != 1 {
18124 break
18125 }
18126 dst := v_0
18127 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18128 break
18129 }
18130 v_1_0 := v_1.Args[0]
18131 if v_1_0.Op != OpARM64VSHRN8H {
18132 break
18133 }
18134 c := auxIntToUint8(v_1_0.AuxInt)
18135 y := v_1_0.Args[0]
18136 v.reset(OpARM64VSHRN2_8H)
18137 v.AuxInt = uint8ToAuxInt(c)
18138 v.AddArg2(dst, y)
18139 return true
18140 }
18141
18142
18143 for {
18144 if auxIntToUint8(v.AuxInt) != 1 {
18145 break
18146 }
18147 dst := v_0
18148 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18149 break
18150 }
18151 v_1_0 := v_1.Args[0]
18152 if v_1_0.Op != OpARM64VSQXTN2D {
18153 break
18154 }
18155 y := v_1_0.Args[0]
18156 v.reset(OpARM64VSQXTN2_2D)
18157 v.AddArg2(dst, y)
18158 return true
18159 }
18160
18161
18162 for {
18163 if auxIntToUint8(v.AuxInt) != 1 {
18164 break
18165 }
18166 dst := v_0
18167 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18168 break
18169 }
18170 v_1_0 := v_1.Args[0]
18171 if v_1_0.Op != OpARM64VSQXTN4S {
18172 break
18173 }
18174 y := v_1_0.Args[0]
18175 v.reset(OpARM64VSQXTN2_4S)
18176 v.AddArg2(dst, y)
18177 return true
18178 }
18179
18180
18181 for {
18182 if auxIntToUint8(v.AuxInt) != 1 {
18183 break
18184 }
18185 dst := v_0
18186 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18187 break
18188 }
18189 v_1_0 := v_1.Args[0]
18190 if v_1_0.Op != OpARM64VSQXTN8H {
18191 break
18192 }
18193 y := v_1_0.Args[0]
18194 v.reset(OpARM64VSQXTN2_8H)
18195 v.AddArg2(dst, y)
18196 return true
18197 }
18198
18199
18200 for {
18201 if auxIntToUint8(v.AuxInt) != 1 {
18202 break
18203 }
18204 dst := v_0
18205 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18206 break
18207 }
18208 v_1_0 := v_1.Args[0]
18209 if v_1_0.Op != OpARM64VSQXTUN2D {
18210 break
18211 }
18212 y := v_1_0.Args[0]
18213 v.reset(OpARM64VSQXTUN2_2D)
18214 v.AddArg2(dst, y)
18215 return true
18216 }
18217
18218
18219 for {
18220 if auxIntToUint8(v.AuxInt) != 1 {
18221 break
18222 }
18223 dst := v_0
18224 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18225 break
18226 }
18227 v_1_0 := v_1.Args[0]
18228 if v_1_0.Op != OpARM64VSQXTUN4S {
18229 break
18230 }
18231 y := v_1_0.Args[0]
18232 v.reset(OpARM64VSQXTUN2_4S)
18233 v.AddArg2(dst, y)
18234 return true
18235 }
18236
18237
18238 for {
18239 if auxIntToUint8(v.AuxInt) != 1 {
18240 break
18241 }
18242 dst := v_0
18243 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18244 break
18245 }
18246 v_1_0 := v_1.Args[0]
18247 if v_1_0.Op != OpARM64VSQXTUN8H {
18248 break
18249 }
18250 y := v_1_0.Args[0]
18251 v.reset(OpARM64VSQXTUN2_8H)
18252 v.AddArg2(dst, y)
18253 return true
18254 }
18255
18256
18257 for {
18258 if auxIntToUint8(v.AuxInt) != 1 {
18259 break
18260 }
18261 dst := v_0
18262 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18263 break
18264 }
18265 v_1_0 := v_1.Args[0]
18266 if v_1_0.Op != OpARM64VUQXTN2D {
18267 break
18268 }
18269 y := v_1_0.Args[0]
18270 v.reset(OpARM64VUQXTN2_2D)
18271 v.AddArg2(dst, y)
18272 return true
18273 }
18274
18275
18276 for {
18277 if auxIntToUint8(v.AuxInt) != 1 {
18278 break
18279 }
18280 dst := v_0
18281 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18282 break
18283 }
18284 v_1_0 := v_1.Args[0]
18285 if v_1_0.Op != OpARM64VUQXTN4S {
18286 break
18287 }
18288 y := v_1_0.Args[0]
18289 v.reset(OpARM64VUQXTN2_4S)
18290 v.AddArg2(dst, y)
18291 return true
18292 }
18293
18294
18295 for {
18296 if auxIntToUint8(v.AuxInt) != 1 {
18297 break
18298 }
18299 dst := v_0
18300 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18301 break
18302 }
18303 v_1_0 := v_1.Args[0]
18304 if v_1_0.Op != OpARM64VUQXTN8H {
18305 break
18306 }
18307 y := v_1_0.Args[0]
18308 v.reset(OpARM64VUQXTN2_8H)
18309 v.AddArg2(dst, y)
18310 return true
18311 }
18312
18313
18314 for {
18315 if auxIntToUint8(v.AuxInt) != 1 {
18316 break
18317 }
18318 dst := v_0
18319 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18320 break
18321 }
18322 v_1_0 := v_1.Args[0]
18323 if v_1_0.Op != OpARM64VXTN2D {
18324 break
18325 }
18326 y := v_1_0.Args[0]
18327 v.reset(OpARM64VXTN2_2D)
18328 v.AddArg2(dst, y)
18329 return true
18330 }
18331
18332
18333 for {
18334 if auxIntToUint8(v.AuxInt) != 1 {
18335 break
18336 }
18337 dst := v_0
18338 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18339 break
18340 }
18341 v_1_0 := v_1.Args[0]
18342 if v_1_0.Op != OpARM64VXTN4S {
18343 break
18344 }
18345 y := v_1_0.Args[0]
18346 v.reset(OpARM64VXTN2_4S)
18347 v.AddArg2(dst, y)
18348 return true
18349 }
18350
18351
18352 for {
18353 if auxIntToUint8(v.AuxInt) != 1 {
18354 break
18355 }
18356 dst := v_0
18357 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18358 break
18359 }
18360 v_1_0 := v_1.Args[0]
18361 if v_1_0.Op != OpARM64VXTN8H {
18362 break
18363 }
18364 y := v_1_0.Args[0]
18365 v.reset(OpARM64VXTN2_8H)
18366 v.AddArg2(dst, y)
18367 return true
18368 }
18369
18370
18371 for {
18372 if auxIntToUint8(v.AuxInt) != 0 || v_0.Op != OpARM64VMOVI16B || auxIntToUint8(v_0.AuxInt) != 0 {
18373 break
18374 }
18375 y := v_1
18376 if y.Op != OpARM64VDUPDextr {
18377 break
18378 }
18379 v.copyOf(y)
18380 return true
18381 }
18382 return false
18383 }
18384 func rewriteValueARM64_OpARM64VMOVSins0(v *Value) bool {
18385 v_1 := v.Args[1]
18386 v_0 := v.Args[0]
18387
18388
18389 for {
18390 if auxIntToUint8(v.AuxInt) != 0 || v_0.Op != OpARM64VMOVI16B || auxIntToUint8(v_0.AuxInt) != 0 {
18391 break
18392 }
18393 y := v_1
18394 if y.Op != OpARM64VDUPSextr {
18395 break
18396 }
18397 v.copyOf(y)
18398 return true
18399 }
18400 return false
18401 }
18402 func rewriteValueARM64_OpARM64VPMULL2D(v *Value) bool {
18403 v_1 := v.Args[1]
18404 v_0 := v.Args[0]
18405
18406
18407 for {
18408 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
18409 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18410 continue
18411 }
18412 x := v_0.Args[0]
18413 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 1 {
18414 continue
18415 }
18416 y := v_1.Args[0]
18417 v.reset(OpARM64VPMULL2_2D)
18418 v.AddArg2(x, y)
18419 return true
18420 }
18421 break
18422 }
18423 return false
18424 }
18425 func rewriteValueARM64_OpARM64VSHL16B(v *Value) bool {
18426 v_0 := v.Args[0]
18427
18428
18429
18430 for {
18431 a := auxIntToUint8(v.AuxInt)
18432 x := v_0
18433 if !(a == 0) {
18434 break
18435 }
18436 v.copyOf(x)
18437 return true
18438 }
18439 return false
18440 }
18441 func rewriteValueARM64_OpARM64VSHL2D(v *Value) bool {
18442 v_0 := v.Args[0]
18443
18444
18445
18446 for {
18447 a := auxIntToUint8(v.AuxInt)
18448 x := v_0
18449 if !(a == 0) {
18450 break
18451 }
18452 v.copyOf(x)
18453 return true
18454 }
18455 return false
18456 }
18457 func rewriteValueARM64_OpARM64VSHL4S(v *Value) bool {
18458 v_0 := v.Args[0]
18459
18460
18461
18462 for {
18463 a := auxIntToUint8(v.AuxInt)
18464 x := v_0
18465 if !(a == 0) {
18466 break
18467 }
18468 v.copyOf(x)
18469 return true
18470 }
18471 return false
18472 }
18473 func rewriteValueARM64_OpARM64VSHL8H(v *Value) bool {
18474 v_0 := v.Args[0]
18475
18476
18477
18478 for {
18479 a := auxIntToUint8(v.AuxInt)
18480 x := v_0
18481 if !(a == 0) {
18482 break
18483 }
18484 v.copyOf(x)
18485 return true
18486 }
18487 return false
18488 }
18489 func rewriteValueARM64_OpARM64VSHRN2D(v *Value) bool {
18490 v_0 := v.Args[0]
18491
18492
18493 for {
18494 if auxIntToUint8(v.AuxInt) != 0 {
18495 break
18496 }
18497 x := v_0
18498 v.reset(OpARM64VXTN2D)
18499 v.AddArg(x)
18500 return true
18501 }
18502 return false
18503 }
18504 func rewriteValueARM64_OpARM64VSHRN4S(v *Value) bool {
18505 v_0 := v.Args[0]
18506
18507
18508 for {
18509 if auxIntToUint8(v.AuxInt) != 0 {
18510 break
18511 }
18512 x := v_0
18513 v.reset(OpARM64VXTN4S)
18514 v.AddArg(x)
18515 return true
18516 }
18517 return false
18518 }
18519 func rewriteValueARM64_OpARM64VSHRN8H(v *Value) bool {
18520 v_0 := v.Args[0]
18521
18522
18523 for {
18524 if auxIntToUint8(v.AuxInt) != 0 {
18525 break
18526 }
18527 x := v_0
18528 v.reset(OpARM64VXTN8H)
18529 v.AddArg(x)
18530 return true
18531 }
18532 return false
18533 }
18534 func rewriteValueARM64_OpARM64VSMULL16B(v *Value) bool {
18535 v_1 := v.Args[1]
18536 v_0 := v.Args[0]
18537
18538
18539 for {
18540 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
18541 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18542 continue
18543 }
18544 x := v_0.Args[0]
18545 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 1 {
18546 continue
18547 }
18548 y := v_1.Args[0]
18549 v.reset(OpARM64VSMULL2_16B)
18550 v.AddArg2(x, y)
18551 return true
18552 }
18553 break
18554 }
18555 return false
18556 }
18557 func rewriteValueARM64_OpARM64VSMULL4S(v *Value) bool {
18558 v_1 := v.Args[1]
18559 v_0 := v.Args[0]
18560
18561
18562 for {
18563 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
18564 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18565 continue
18566 }
18567 x := v_0.Args[0]
18568 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 1 {
18569 continue
18570 }
18571 y := v_1.Args[0]
18572 v.reset(OpARM64VSMULL2_4S)
18573 v.AddArg2(x, y)
18574 return true
18575 }
18576 break
18577 }
18578 return false
18579 }
18580 func rewriteValueARM64_OpARM64VSMULL8H(v *Value) bool {
18581 v_1 := v.Args[1]
18582 v_0 := v.Args[0]
18583
18584
18585 for {
18586 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
18587 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18588 continue
18589 }
18590 x := v_0.Args[0]
18591 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 1 {
18592 continue
18593 }
18594 y := v_1.Args[0]
18595 v.reset(OpARM64VSMULL2_8H)
18596 v.AddArg2(x, y)
18597 return true
18598 }
18599 break
18600 }
18601 return false
18602 }
18603 func rewriteValueARM64_OpARM64VSQSHL16Bconst(v *Value) bool {
18604 v_0 := v.Args[0]
18605
18606
18607
18608 for {
18609 a := auxIntToUint8(v.AuxInt)
18610 x := v_0
18611 if !(a == 0) {
18612 break
18613 }
18614 v.copyOf(x)
18615 return true
18616 }
18617 return false
18618 }
18619 func rewriteValueARM64_OpARM64VSQSHL2Dconst(v *Value) bool {
18620 v_0 := v.Args[0]
18621
18622
18623
18624 for {
18625 a := auxIntToUint8(v.AuxInt)
18626 x := v_0
18627 if !(a == 0) {
18628 break
18629 }
18630 v.copyOf(x)
18631 return true
18632 }
18633 return false
18634 }
18635 func rewriteValueARM64_OpARM64VSQSHL4Sconst(v *Value) bool {
18636 v_0 := v.Args[0]
18637
18638
18639
18640 for {
18641 a := auxIntToUint8(v.AuxInt)
18642 x := v_0
18643 if !(a == 0) {
18644 break
18645 }
18646 v.copyOf(x)
18647 return true
18648 }
18649 return false
18650 }
18651 func rewriteValueARM64_OpARM64VSQSHL8Hconst(v *Value) bool {
18652 v_0 := v.Args[0]
18653
18654
18655
18656 for {
18657 a := auxIntToUint8(v.AuxInt)
18658 x := v_0
18659 if !(a == 0) {
18660 break
18661 }
18662 v.copyOf(x)
18663 return true
18664 }
18665 return false
18666 }
18667 func rewriteValueARM64_OpARM64VSSHLL16B(v *Value) bool {
18668 v_0 := v.Args[0]
18669
18670
18671 for {
18672 a := auxIntToUint8(v.AuxInt)
18673 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18674 break
18675 }
18676 x := v_0.Args[0]
18677 v.reset(OpARM64VSSHLL2_16B)
18678 v.AuxInt = uint8ToAuxInt(a)
18679 v.AddArg(x)
18680 return true
18681 }
18682 return false
18683 }
18684 func rewriteValueARM64_OpARM64VSSHLL4S(v *Value) bool {
18685 v_0 := v.Args[0]
18686
18687
18688 for {
18689 a := auxIntToUint8(v.AuxInt)
18690 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18691 break
18692 }
18693 x := v_0.Args[0]
18694 v.reset(OpARM64VSSHLL2_4S)
18695 v.AuxInt = uint8ToAuxInt(a)
18696 v.AddArg(x)
18697 return true
18698 }
18699 return false
18700 }
18701 func rewriteValueARM64_OpARM64VSSHLL8H(v *Value) bool {
18702 v_0 := v.Args[0]
18703
18704
18705 for {
18706 a := auxIntToUint8(v.AuxInt)
18707 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18708 break
18709 }
18710 x := v_0.Args[0]
18711 v.reset(OpARM64VSSHLL2_8H)
18712 v.AuxInt = uint8ToAuxInt(a)
18713 v.AddArg(x)
18714 return true
18715 }
18716 return false
18717 }
18718 func rewriteValueARM64_OpARM64VSSHR16B(v *Value) bool {
18719 v_0 := v.Args[0]
18720
18721
18722
18723 for {
18724 a := auxIntToUint8(v.AuxInt)
18725 x := v_0
18726 if !(a == 0) {
18727 break
18728 }
18729 v.copyOf(x)
18730 return true
18731 }
18732 return false
18733 }
18734 func rewriteValueARM64_OpARM64VSSHR2D(v *Value) bool {
18735 v_0 := v.Args[0]
18736
18737
18738
18739 for {
18740 a := auxIntToUint8(v.AuxInt)
18741 x := v_0
18742 if !(a == 0) {
18743 break
18744 }
18745 v.copyOf(x)
18746 return true
18747 }
18748 return false
18749 }
18750 func rewriteValueARM64_OpARM64VSSHR4S(v *Value) bool {
18751 v_0 := v.Args[0]
18752
18753
18754
18755 for {
18756 a := auxIntToUint8(v.AuxInt)
18757 x := v_0
18758 if !(a == 0) {
18759 break
18760 }
18761 v.copyOf(x)
18762 return true
18763 }
18764 return false
18765 }
18766 func rewriteValueARM64_OpARM64VSSHR8H(v *Value) bool {
18767 v_0 := v.Args[0]
18768
18769
18770
18771 for {
18772 a := auxIntToUint8(v.AuxInt)
18773 x := v_0
18774 if !(a == 0) {
18775 break
18776 }
18777 v.copyOf(x)
18778 return true
18779 }
18780 return false
18781 }
18782 func rewriteValueARM64_OpARM64VSXTL16B(v *Value) bool {
18783 v_0 := v.Args[0]
18784
18785
18786 for {
18787 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18788 break
18789 }
18790 x := v_0.Args[0]
18791 v.reset(OpARM64VSXTL2_16B)
18792 v.AddArg(x)
18793 return true
18794 }
18795 return false
18796 }
18797 func rewriteValueARM64_OpARM64VSXTL4S(v *Value) bool {
18798 v_0 := v.Args[0]
18799
18800
18801 for {
18802 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18803 break
18804 }
18805 x := v_0.Args[0]
18806 v.reset(OpARM64VSXTL2_4S)
18807 v.AddArg(x)
18808 return true
18809 }
18810 return false
18811 }
18812 func rewriteValueARM64_OpARM64VSXTL8H(v *Value) bool {
18813 v_0 := v.Args[0]
18814
18815
18816 for {
18817 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18818 break
18819 }
18820 x := v_0.Args[0]
18821 v.reset(OpARM64VSXTL2_8H)
18822 v.AddArg(x)
18823 return true
18824 }
18825 return false
18826 }
18827 func rewriteValueARM64_OpARM64VUMULL16B(v *Value) bool {
18828 v_1 := v.Args[1]
18829 v_0 := v.Args[0]
18830
18831
18832 for {
18833 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
18834 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18835 continue
18836 }
18837 x := v_0.Args[0]
18838 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 1 {
18839 continue
18840 }
18841 y := v_1.Args[0]
18842 v.reset(OpARM64VUMULL2_16B)
18843 v.AddArg2(x, y)
18844 return true
18845 }
18846 break
18847 }
18848 return false
18849 }
18850 func rewriteValueARM64_OpARM64VUMULL4S(v *Value) bool {
18851 v_1 := v.Args[1]
18852 v_0 := v.Args[0]
18853
18854
18855 for {
18856 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
18857 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18858 continue
18859 }
18860 x := v_0.Args[0]
18861 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 1 {
18862 continue
18863 }
18864 y := v_1.Args[0]
18865 v.reset(OpARM64VUMULL2_4S)
18866 v.AddArg2(x, y)
18867 return true
18868 }
18869 break
18870 }
18871 return false
18872 }
18873 func rewriteValueARM64_OpARM64VUMULL8H(v *Value) bool {
18874 v_1 := v.Args[1]
18875 v_0 := v.Args[0]
18876
18877
18878 for {
18879 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
18880 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18881 continue
18882 }
18883 x := v_0.Args[0]
18884 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 1 {
18885 continue
18886 }
18887 y := v_1.Args[0]
18888 v.reset(OpARM64VUMULL2_8H)
18889 v.AddArg2(x, y)
18890 return true
18891 }
18892 break
18893 }
18894 return false
18895 }
18896 func rewriteValueARM64_OpARM64VUQSHL16Bconst(v *Value) bool {
18897 v_0 := v.Args[0]
18898
18899
18900
18901 for {
18902 a := auxIntToUint8(v.AuxInt)
18903 x := v_0
18904 if !(a == 0) {
18905 break
18906 }
18907 v.copyOf(x)
18908 return true
18909 }
18910 return false
18911 }
18912 func rewriteValueARM64_OpARM64VUQSHL2Dconst(v *Value) bool {
18913 v_0 := v.Args[0]
18914
18915
18916
18917 for {
18918 a := auxIntToUint8(v.AuxInt)
18919 x := v_0
18920 if !(a == 0) {
18921 break
18922 }
18923 v.copyOf(x)
18924 return true
18925 }
18926 return false
18927 }
18928 func rewriteValueARM64_OpARM64VUQSHL4Sconst(v *Value) bool {
18929 v_0 := v.Args[0]
18930
18931
18932
18933 for {
18934 a := auxIntToUint8(v.AuxInt)
18935 x := v_0
18936 if !(a == 0) {
18937 break
18938 }
18939 v.copyOf(x)
18940 return true
18941 }
18942 return false
18943 }
18944 func rewriteValueARM64_OpARM64VUQSHL8Hconst(v *Value) bool {
18945 v_0 := v.Args[0]
18946
18947
18948
18949 for {
18950 a := auxIntToUint8(v.AuxInt)
18951 x := v_0
18952 if !(a == 0) {
18953 break
18954 }
18955 v.copyOf(x)
18956 return true
18957 }
18958 return false
18959 }
18960 func rewriteValueARM64_OpARM64VUSHLL16B(v *Value) bool {
18961 v_0 := v.Args[0]
18962
18963
18964 for {
18965 a := auxIntToUint8(v.AuxInt)
18966 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18967 break
18968 }
18969 x := v_0.Args[0]
18970 v.reset(OpARM64VUSHLL2_16B)
18971 v.AuxInt = uint8ToAuxInt(a)
18972 v.AddArg(x)
18973 return true
18974 }
18975 return false
18976 }
18977 func rewriteValueARM64_OpARM64VUSHLL4S(v *Value) bool {
18978 v_0 := v.Args[0]
18979
18980
18981 for {
18982 a := auxIntToUint8(v.AuxInt)
18983 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18984 break
18985 }
18986 x := v_0.Args[0]
18987 v.reset(OpARM64VUSHLL2_4S)
18988 v.AuxInt = uint8ToAuxInt(a)
18989 v.AddArg(x)
18990 return true
18991 }
18992 return false
18993 }
18994 func rewriteValueARM64_OpARM64VUSHLL8H(v *Value) bool {
18995 v_0 := v.Args[0]
18996
18997
18998 for {
18999 a := auxIntToUint8(v.AuxInt)
19000 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
19001 break
19002 }
19003 x := v_0.Args[0]
19004 v.reset(OpARM64VUSHLL2_8H)
19005 v.AuxInt = uint8ToAuxInt(a)
19006 v.AddArg(x)
19007 return true
19008 }
19009 return false
19010 }
19011 func rewriteValueARM64_OpARM64VUSHR16B(v *Value) bool {
19012 v_0 := v.Args[0]
19013
19014
19015
19016 for {
19017 a := auxIntToUint8(v.AuxInt)
19018 x := v_0
19019 if !(a == 0) {
19020 break
19021 }
19022 v.copyOf(x)
19023 return true
19024 }
19025 return false
19026 }
19027 func rewriteValueARM64_OpARM64VUSHR2D(v *Value) bool {
19028 v_0 := v.Args[0]
19029
19030
19031
19032 for {
19033 a := auxIntToUint8(v.AuxInt)
19034 x := v_0
19035 if !(a == 0) {
19036 break
19037 }
19038 v.copyOf(x)
19039 return true
19040 }
19041 return false
19042 }
19043 func rewriteValueARM64_OpARM64VUSHR4S(v *Value) bool {
19044 v_0 := v.Args[0]
19045
19046
19047
19048 for {
19049 a := auxIntToUint8(v.AuxInt)
19050 x := v_0
19051 if !(a == 0) {
19052 break
19053 }
19054 v.copyOf(x)
19055 return true
19056 }
19057 return false
19058 }
19059 func rewriteValueARM64_OpARM64VUSHR8H(v *Value) bool {
19060 v_0 := v.Args[0]
19061
19062
19063
19064 for {
19065 a := auxIntToUint8(v.AuxInt)
19066 x := v_0
19067 if !(a == 0) {
19068 break
19069 }
19070 v.copyOf(x)
19071 return true
19072 }
19073 return false
19074 }
19075 func rewriteValueARM64_OpARM64VUXTL16B(v *Value) bool {
19076 v_0 := v.Args[0]
19077
19078
19079 for {
19080 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
19081 break
19082 }
19083 x := v_0.Args[0]
19084 v.reset(OpARM64VUXTL2_16B)
19085 v.AddArg(x)
19086 return true
19087 }
19088 return false
19089 }
19090 func rewriteValueARM64_OpARM64VUXTL4S(v *Value) bool {
19091 v_0 := v.Args[0]
19092
19093
19094 for {
19095 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
19096 break
19097 }
19098 x := v_0.Args[0]
19099 v.reset(OpARM64VUXTL2_4S)
19100 v.AddArg(x)
19101 return true
19102 }
19103 return false
19104 }
19105 func rewriteValueARM64_OpARM64VUXTL8H(v *Value) bool {
19106 v_0 := v.Args[0]
19107
19108
19109 for {
19110 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
19111 break
19112 }
19113 x := v_0.Args[0]
19114 v.reset(OpARM64VUXTL2_8H)
19115 v.AddArg(x)
19116 return true
19117 }
19118 return false
19119 }
19120 func rewriteValueARM64_OpARM64XOR(v *Value) bool {
19121 v_1 := v.Args[1]
19122 v_0 := v.Args[0]
19123
19124
19125 for {
19126 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
19127 x := v_0
19128 if v_1.Op != OpARM64MOVDconst {
19129 continue
19130 }
19131 c := auxIntToInt64(v_1.AuxInt)
19132 v.reset(OpARM64XORconst)
19133 v.AuxInt = int64ToAuxInt(c)
19134 v.AddArg(x)
19135 return true
19136 }
19137 break
19138 }
19139
19140
19141 for {
19142 x := v_0
19143 if x != v_1 {
19144 break
19145 }
19146 v.reset(OpARM64MOVDconst)
19147 v.AuxInt = int64ToAuxInt(0)
19148 return true
19149 }
19150
19151
19152 for {
19153 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
19154 x := v_0
19155 if v_1.Op != OpARM64MVN {
19156 continue
19157 }
19158 y := v_1.Args[0]
19159 v.reset(OpARM64EON)
19160 v.AddArg2(x, y)
19161 return true
19162 }
19163 break
19164 }
19165
19166
19167
19168 for {
19169 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
19170 x0 := v_0
19171 x1 := v_1
19172 if x1.Op != OpARM64SLLconst {
19173 continue
19174 }
19175 c := auxIntToInt64(x1.AuxInt)
19176 y := x1.Args[0]
19177 if !(clobberIfDead(x1)) {
19178 continue
19179 }
19180 v.reset(OpARM64XORshiftLL)
19181 v.AuxInt = int64ToAuxInt(c)
19182 v.AddArg2(x0, y)
19183 return true
19184 }
19185 break
19186 }
19187
19188
19189
19190 for {
19191 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
19192 x0 := v_0
19193 x1 := v_1
19194 if x1.Op != OpARM64SRLconst {
19195 continue
19196 }
19197 c := auxIntToInt64(x1.AuxInt)
19198 y := x1.Args[0]
19199 if !(clobberIfDead(x1)) {
19200 continue
19201 }
19202 v.reset(OpARM64XORshiftRL)
19203 v.AuxInt = int64ToAuxInt(c)
19204 v.AddArg2(x0, y)
19205 return true
19206 }
19207 break
19208 }
19209
19210
19211
19212 for {
19213 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
19214 x0 := v_0
19215 x1 := v_1
19216 if x1.Op != OpARM64SRAconst {
19217 continue
19218 }
19219 c := auxIntToInt64(x1.AuxInt)
19220 y := x1.Args[0]
19221 if !(clobberIfDead(x1)) {
19222 continue
19223 }
19224 v.reset(OpARM64XORshiftRA)
19225 v.AuxInt = int64ToAuxInt(c)
19226 v.AddArg2(x0, y)
19227 return true
19228 }
19229 break
19230 }
19231
19232
19233
19234 for {
19235 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
19236 x0 := v_0
19237 x1 := v_1
19238 if x1.Op != OpARM64RORconst {
19239 continue
19240 }
19241 c := auxIntToInt64(x1.AuxInt)
19242 y := x1.Args[0]
19243 if !(clobberIfDead(x1)) {
19244 continue
19245 }
19246 v.reset(OpARM64XORshiftRO)
19247 v.AuxInt = int64ToAuxInt(c)
19248 v.AddArg2(x0, y)
19249 return true
19250 }
19251 break
19252 }
19253 return false
19254 }
19255 func rewriteValueARM64_OpARM64XORconst(v *Value) bool {
19256 v_0 := v.Args[0]
19257
19258
19259 for {
19260 if auxIntToInt64(v.AuxInt) != 0 {
19261 break
19262 }
19263 x := v_0
19264 v.copyOf(x)
19265 return true
19266 }
19267
19268
19269 for {
19270 if auxIntToInt64(v.AuxInt) != -1 {
19271 break
19272 }
19273 x := v_0
19274 v.reset(OpARM64MVN)
19275 v.AddArg(x)
19276 return true
19277 }
19278
19279
19280 for {
19281 c := auxIntToInt64(v.AuxInt)
19282 if v_0.Op != OpARM64MOVDconst {
19283 break
19284 }
19285 d := auxIntToInt64(v_0.AuxInt)
19286 v.reset(OpARM64MOVDconst)
19287 v.AuxInt = int64ToAuxInt(c ^ d)
19288 return true
19289 }
19290
19291
19292 for {
19293 c := auxIntToInt64(v.AuxInt)
19294 if v_0.Op != OpARM64XORconst {
19295 break
19296 }
19297 d := auxIntToInt64(v_0.AuxInt)
19298 x := v_0.Args[0]
19299 v.reset(OpARM64XORconst)
19300 v.AuxInt = int64ToAuxInt(c ^ d)
19301 v.AddArg(x)
19302 return true
19303 }
19304 return false
19305 }
19306 func rewriteValueARM64_OpARM64XORshiftLL(v *Value) bool {
19307 v_1 := v.Args[1]
19308 v_0 := v.Args[0]
19309 b := v.Block
19310 typ := &b.Func.Config.Types
19311
19312
19313 for {
19314 d := auxIntToInt64(v.AuxInt)
19315 if v_0.Op != OpARM64MOVDconst {
19316 break
19317 }
19318 c := auxIntToInt64(v_0.AuxInt)
19319 x := v_1
19320 v.reset(OpARM64XORconst)
19321 v.AuxInt = int64ToAuxInt(c)
19322 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
19323 v0.AuxInt = int64ToAuxInt(d)
19324 v0.AddArg(x)
19325 v.AddArg(v0)
19326 return true
19327 }
19328
19329
19330 for {
19331 d := auxIntToInt64(v.AuxInt)
19332 x := v_0
19333 if v_1.Op != OpARM64MOVDconst {
19334 break
19335 }
19336 c := auxIntToInt64(v_1.AuxInt)
19337 v.reset(OpARM64XORconst)
19338 v.AuxInt = int64ToAuxInt(int64(uint64(c) << uint64(d)))
19339 v.AddArg(x)
19340 return true
19341 }
19342
19343
19344 for {
19345 c := auxIntToInt64(v.AuxInt)
19346 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != c {
19347 break
19348 }
19349 x := v_0.Args[0]
19350 if x != v_1 {
19351 break
19352 }
19353 v.reset(OpARM64MOVDconst)
19354 v.AuxInt = int64ToAuxInt(0)
19355 return true
19356 }
19357
19358
19359 for {
19360 if v.Type != typ.UInt16 || auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64UBFX || v_0.Type != typ.UInt16 || auxIntToArm64BitField(v_0.AuxInt) != armBFAuxInt(8, 8) {
19361 break
19362 }
19363 x := v_0.Args[0]
19364 if x != v_1 {
19365 break
19366 }
19367 v.reset(OpARM64REV16W)
19368 v.AddArg(x)
19369 return true
19370 }
19371
19372
19373
19374 for {
19375 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64UBFX || auxIntToArm64BitField(v_0.AuxInt) != armBFAuxInt(8, 24) {
19376 break
19377 }
19378 v_0_0 := v_0.Args[0]
19379 if v_0_0.Op != OpARM64ANDconst {
19380 break
19381 }
19382 c1 := auxIntToInt64(v_0_0.AuxInt)
19383 x := v_0_0.Args[0]
19384 if v_1.Op != OpARM64ANDconst {
19385 break
19386 }
19387 c2 := auxIntToInt64(v_1.AuxInt)
19388 if x != v_1.Args[0] || !(uint32(c1) == 0xff00ff00 && uint32(c2) == 0x00ff00ff) {
19389 break
19390 }
19391 v.reset(OpARM64REV16W)
19392 v.AddArg(x)
19393 return true
19394 }
19395
19396
19397
19398 for {
19399 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
19400 break
19401 }
19402 v_0_0 := v_0.Args[0]
19403 if v_0_0.Op != OpARM64ANDconst {
19404 break
19405 }
19406 c1 := auxIntToInt64(v_0_0.AuxInt)
19407 x := v_0_0.Args[0]
19408 if v_1.Op != OpARM64ANDconst {
19409 break
19410 }
19411 c2 := auxIntToInt64(v_1.AuxInt)
19412 if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00ff00ff00 && uint64(c2) == 0x00ff00ff00ff00ff) {
19413 break
19414 }
19415 v.reset(OpARM64REV16)
19416 v.AddArg(x)
19417 return true
19418 }
19419
19420
19421
19422 for {
19423 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
19424 break
19425 }
19426 v_0_0 := v_0.Args[0]
19427 if v_0_0.Op != OpARM64ANDconst {
19428 break
19429 }
19430 c1 := auxIntToInt64(v_0_0.AuxInt)
19431 x := v_0_0.Args[0]
19432 if v_1.Op != OpARM64ANDconst {
19433 break
19434 }
19435 c2 := auxIntToInt64(v_1.AuxInt)
19436 if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00 && uint64(c2) == 0x00ff00ff) {
19437 break
19438 }
19439 v.reset(OpARM64REV16)
19440 v0 := b.NewValue0(v.Pos, OpARM64ANDconst, x.Type)
19441 v0.AuxInt = int64ToAuxInt(0xffffffff)
19442 v0.AddArg(x)
19443 v.AddArg(v0)
19444 return true
19445 }
19446
19447
19448 for {
19449 c := auxIntToInt64(v.AuxInt)
19450 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 64-c {
19451 break
19452 }
19453 x := v_0.Args[0]
19454 x2 := v_1
19455 v.reset(OpARM64EXTRconst)
19456 v.AuxInt = int64ToAuxInt(64 - c)
19457 v.AddArg2(x2, x)
19458 return true
19459 }
19460
19461
19462
19463 for {
19464 t := v.Type
19465 c := auxIntToInt64(v.AuxInt)
19466 if v_0.Op != OpARM64UBFX {
19467 break
19468 }
19469 bfc := auxIntToArm64BitField(v_0.AuxInt)
19470 x := v_0.Args[0]
19471 x2 := v_1
19472 if !(c < 32 && t.Size() == 4 && bfc == armBFAuxInt(32-c, c)) {
19473 break
19474 }
19475 v.reset(OpARM64EXTRWconst)
19476 v.AuxInt = int64ToAuxInt(32 - c)
19477 v.AddArg2(x2, x)
19478 return true
19479 }
19480 return false
19481 }
19482 func rewriteValueARM64_OpARM64XORshiftRA(v *Value) bool {
19483 v_1 := v.Args[1]
19484 v_0 := v.Args[0]
19485 b := v.Block
19486
19487
19488 for {
19489 d := auxIntToInt64(v.AuxInt)
19490 if v_0.Op != OpARM64MOVDconst {
19491 break
19492 }
19493 c := auxIntToInt64(v_0.AuxInt)
19494 x := v_1
19495 v.reset(OpARM64XORconst)
19496 v.AuxInt = int64ToAuxInt(c)
19497 v0 := b.NewValue0(v.Pos, OpARM64SRAconst, x.Type)
19498 v0.AuxInt = int64ToAuxInt(d)
19499 v0.AddArg(x)
19500 v.AddArg(v0)
19501 return true
19502 }
19503
19504
19505 for {
19506 d := auxIntToInt64(v.AuxInt)
19507 x := v_0
19508 if v_1.Op != OpARM64MOVDconst {
19509 break
19510 }
19511 c := auxIntToInt64(v_1.AuxInt)
19512 v.reset(OpARM64XORconst)
19513 v.AuxInt = int64ToAuxInt(c >> uint64(d))
19514 v.AddArg(x)
19515 return true
19516 }
19517
19518
19519 for {
19520 c := auxIntToInt64(v.AuxInt)
19521 if v_0.Op != OpARM64SRAconst || auxIntToInt64(v_0.AuxInt) != c {
19522 break
19523 }
19524 x := v_0.Args[0]
19525 if x != v_1 {
19526 break
19527 }
19528 v.reset(OpARM64MOVDconst)
19529 v.AuxInt = int64ToAuxInt(0)
19530 return true
19531 }
19532 return false
19533 }
19534 func rewriteValueARM64_OpARM64XORshiftRL(v *Value) bool {
19535 v_1 := v.Args[1]
19536 v_0 := v.Args[0]
19537 b := v.Block
19538
19539
19540 for {
19541 d := auxIntToInt64(v.AuxInt)
19542 if v_0.Op != OpARM64MOVDconst {
19543 break
19544 }
19545 c := auxIntToInt64(v_0.AuxInt)
19546 x := v_1
19547 v.reset(OpARM64XORconst)
19548 v.AuxInt = int64ToAuxInt(c)
19549 v0 := b.NewValue0(v.Pos, OpARM64SRLconst, x.Type)
19550 v0.AuxInt = int64ToAuxInt(d)
19551 v0.AddArg(x)
19552 v.AddArg(v0)
19553 return true
19554 }
19555
19556
19557 for {
19558 d := auxIntToInt64(v.AuxInt)
19559 x := v_0
19560 if v_1.Op != OpARM64MOVDconst {
19561 break
19562 }
19563 c := auxIntToInt64(v_1.AuxInt)
19564 v.reset(OpARM64XORconst)
19565 v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
19566 v.AddArg(x)
19567 return true
19568 }
19569
19570
19571 for {
19572 c := auxIntToInt64(v.AuxInt)
19573 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != c {
19574 break
19575 }
19576 x := v_0.Args[0]
19577 if x != v_1 {
19578 break
19579 }
19580 v.reset(OpARM64MOVDconst)
19581 v.AuxInt = int64ToAuxInt(0)
19582 return true
19583 }
19584 return false
19585 }
19586 func rewriteValueARM64_OpARM64XORshiftRO(v *Value) bool {
19587 v_1 := v.Args[1]
19588 v_0 := v.Args[0]
19589 b := v.Block
19590
19591
19592 for {
19593 d := auxIntToInt64(v.AuxInt)
19594 if v_0.Op != OpARM64MOVDconst {
19595 break
19596 }
19597 c := auxIntToInt64(v_0.AuxInt)
19598 x := v_1
19599 v.reset(OpARM64XORconst)
19600 v.AuxInt = int64ToAuxInt(c)
19601 v0 := b.NewValue0(v.Pos, OpARM64RORconst, x.Type)
19602 v0.AuxInt = int64ToAuxInt(d)
19603 v0.AddArg(x)
19604 v.AddArg(v0)
19605 return true
19606 }
19607
19608
19609 for {
19610 d := auxIntToInt64(v.AuxInt)
19611 x := v_0
19612 if v_1.Op != OpARM64MOVDconst {
19613 break
19614 }
19615 c := auxIntToInt64(v_1.AuxInt)
19616 v.reset(OpARM64XORconst)
19617 v.AuxInt = int64ToAuxInt(rotateRight64(c, d))
19618 v.AddArg(x)
19619 return true
19620 }
19621
19622
19623 for {
19624 c := auxIntToInt64(v.AuxInt)
19625 if v_0.Op != OpARM64RORconst || auxIntToInt64(v_0.AuxInt) != c {
19626 break
19627 }
19628 x := v_0.Args[0]
19629 if x != v_1 {
19630 break
19631 }
19632 v.reset(OpARM64MOVDconst)
19633 v.AuxInt = int64ToAuxInt(0)
19634 return true
19635 }
19636 return false
19637 }
19638 func rewriteValueARM64_OpAddInt8s(v *Value) bool {
19639 v_1 := v.Args[1]
19640 v_0 := v.Args[0]
19641 b := v.Block
19642 typ := &b.Func.Config.Types
19643
19644
19645 for {
19646 x := v_0
19647 y := v_1
19648 v.reset(OpARM64ZADDBPred)
19649 v0 := b.NewValue0(v.Pos, OpSelect0, types.TypeMask)
19650 v1 := b.NewValue0(v.Pos, OpARM64PWHILELTB, types.NewTuple(typ.Mask, types.TypeFlags))
19651 v2 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
19652 v2.AuxInt = int64ToAuxInt(0)
19653 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
19654 v3.AuxInt = int64ToAuxInt(32)
19655 v1.AddArg2(v2, v3)
19656 v0.AddArg(v1)
19657 v.AddArg3(x, y, v0)
19658 return true
19659 }
19660 }
19661 func rewriteValueARM64_OpAddr(v *Value) bool {
19662 v_0 := v.Args[0]
19663
19664
19665 for {
19666 sym := auxToSym(v.Aux)
19667 base := v_0
19668 v.reset(OpARM64MOVDaddr)
19669 v.Aux = symToAux(sym)
19670 v.AddArg(base)
19671 return true
19672 }
19673 }
19674 func rewriteValueARM64_OpAvg64u(v *Value) bool {
19675 v_1 := v.Args[1]
19676 v_0 := v.Args[0]
19677 b := v.Block
19678
19679
19680 for {
19681 t := v.Type
19682 x := v_0
19683 y := v_1
19684 v.reset(OpARM64ADD)
19685 v0 := b.NewValue0(v.Pos, OpARM64SRLconst, t)
19686 v0.AuxInt = int64ToAuxInt(1)
19687 v1 := b.NewValue0(v.Pos, OpARM64SUB, t)
19688 v1.AddArg2(x, y)
19689 v0.AddArg(v1)
19690 v.AddArg2(v0, y)
19691 return true
19692 }
19693 }
19694 func rewriteValueARM64_OpBitLen16(v *Value) bool {
19695 v_0 := v.Args[0]
19696 b := v.Block
19697 typ := &b.Func.Config.Types
19698
19699
19700 for {
19701 x := v_0
19702 v.reset(OpBitLen64)
19703 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
19704 v0.AddArg(x)
19705 v.AddArg(v0)
19706 return true
19707 }
19708 }
19709 func rewriteValueARM64_OpBitLen32(v *Value) bool {
19710 v_0 := v.Args[0]
19711 b := v.Block
19712 typ := &b.Func.Config.Types
19713
19714
19715 for {
19716 x := v_0
19717 v.reset(OpARM64SUB)
19718 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
19719 v0.AuxInt = int64ToAuxInt(32)
19720 v1 := b.NewValue0(v.Pos, OpARM64CLZW, typ.Int)
19721 v1.AddArg(x)
19722 v.AddArg2(v0, v1)
19723 return true
19724 }
19725 }
19726 func rewriteValueARM64_OpBitLen64(v *Value) bool {
19727 v_0 := v.Args[0]
19728 b := v.Block
19729 typ := &b.Func.Config.Types
19730
19731
19732 for {
19733 x := v_0
19734 v.reset(OpARM64SUB)
19735 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
19736 v0.AuxInt = int64ToAuxInt(64)
19737 v1 := b.NewValue0(v.Pos, OpARM64CLZ, typ.Int)
19738 v1.AddArg(x)
19739 v.AddArg2(v0, v1)
19740 return true
19741 }
19742 }
19743 func rewriteValueARM64_OpBitLen8(v *Value) bool {
19744 v_0 := v.Args[0]
19745 b := v.Block
19746 typ := &b.Func.Config.Types
19747
19748
19749 for {
19750 x := v_0
19751 v.reset(OpBitLen64)
19752 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
19753 v0.AddArg(x)
19754 v.AddArg(v0)
19755 return true
19756 }
19757 }
19758 func rewriteValueARM64_OpBitRev16(v *Value) bool {
19759 v_0 := v.Args[0]
19760 b := v.Block
19761 typ := &b.Func.Config.Types
19762
19763
19764 for {
19765 x := v_0
19766 v.reset(OpARM64SRLconst)
19767 v.AuxInt = int64ToAuxInt(48)
19768 v0 := b.NewValue0(v.Pos, OpARM64RBIT, typ.UInt64)
19769 v0.AddArg(x)
19770 v.AddArg(v0)
19771 return true
19772 }
19773 }
19774 func rewriteValueARM64_OpBitRev8(v *Value) bool {
19775 v_0 := v.Args[0]
19776 b := v.Block
19777 typ := &b.Func.Config.Types
19778
19779
19780 for {
19781 x := v_0
19782 v.reset(OpARM64SRLconst)
19783 v.AuxInt = int64ToAuxInt(56)
19784 v0 := b.NewValue0(v.Pos, OpARM64RBIT, typ.UInt64)
19785 v0.AddArg(x)
19786 v.AddArg(v0)
19787 return true
19788 }
19789 }
19790 func rewriteValueARM64_OpCondSelect(v *Value) bool {
19791 v_2 := v.Args[2]
19792 v_1 := v.Args[1]
19793 v_0 := v.Args[0]
19794 b := v.Block
19795
19796
19797
19798 for {
19799 x := v_0
19800 y := v_1
19801 boolval := v_2
19802 if !(flagArg(boolval) != nil) {
19803 break
19804 }
19805 v.reset(OpARM64CSEL)
19806 v.AuxInt = opToAuxInt(boolval.Op)
19807 v.AddArg3(x, y, flagArg(boolval))
19808 return true
19809 }
19810
19811
19812
19813 for {
19814 x := v_0
19815 y := v_1
19816 boolval := v_2
19817 if !(flagArg(boolval) == nil) {
19818 break
19819 }
19820 v.reset(OpARM64CSEL)
19821 v.AuxInt = opToAuxInt(OpARM64NotEqual)
19822 v0 := b.NewValue0(v.Pos, OpARM64TSTWconst, types.TypeFlags)
19823 v0.AuxInt = int32ToAuxInt(1)
19824 v0.AddArg(boolval)
19825 v.AddArg3(x, y, v0)
19826 return true
19827 }
19828 return false
19829 }
19830 func rewriteValueARM64_OpConst16(v *Value) bool {
19831
19832
19833 for {
19834 val := auxIntToInt16(v.AuxInt)
19835 v.reset(OpARM64MOVDconst)
19836 v.AuxInt = int64ToAuxInt(int64(val))
19837 return true
19838 }
19839 }
19840 func rewriteValueARM64_OpConst32(v *Value) bool {
19841
19842
19843 for {
19844 val := auxIntToInt32(v.AuxInt)
19845 v.reset(OpARM64MOVDconst)
19846 v.AuxInt = int64ToAuxInt(int64(val))
19847 return true
19848 }
19849 }
19850 func rewriteValueARM64_OpConst32F(v *Value) bool {
19851
19852
19853 for {
19854 val := auxIntToFloat32(v.AuxInt)
19855 v.reset(OpARM64FMOVSconst)
19856 v.AuxInt = float64ToAuxInt(float64(val))
19857 return true
19858 }
19859 }
19860 func rewriteValueARM64_OpConst64(v *Value) bool {
19861
19862
19863 for {
19864 val := auxIntToInt64(v.AuxInt)
19865 v.reset(OpARM64MOVDconst)
19866 v.AuxInt = int64ToAuxInt(int64(val))
19867 return true
19868 }
19869 }
19870 func rewriteValueARM64_OpConst64F(v *Value) bool {
19871
19872
19873 for {
19874 val := auxIntToFloat64(v.AuxInt)
19875 v.reset(OpARM64FMOVDconst)
19876 v.AuxInt = float64ToAuxInt(float64(val))
19877 return true
19878 }
19879 }
19880 func rewriteValueARM64_OpConst8(v *Value) bool {
19881
19882
19883 for {
19884 val := auxIntToInt8(v.AuxInt)
19885 v.reset(OpARM64MOVDconst)
19886 v.AuxInt = int64ToAuxInt(int64(val))
19887 return true
19888 }
19889 }
19890 func rewriteValueARM64_OpConstBool(v *Value) bool {
19891
19892
19893 for {
19894 t := auxIntToBool(v.AuxInt)
19895 v.reset(OpARM64MOVDconst)
19896 v.AuxInt = int64ToAuxInt(b2i(t))
19897 return true
19898 }
19899 }
19900 func rewriteValueARM64_OpConstNil(v *Value) bool {
19901
19902
19903 for {
19904 v.reset(OpARM64MOVDconst)
19905 v.AuxInt = int64ToAuxInt(0)
19906 return true
19907 }
19908 }
19909 func rewriteValueARM64_OpCount8s(v *Value) bool {
19910 v_0 := v.Args[0]
19911 b := v.Block
19912 typ := &b.Func.Config.Types
19913
19914
19915 for {
19916 r := v_0
19917 v.reset(OpSelect0)
19918 v.Type = types.TypeMask
19919 v0 := b.NewValue0(v.Pos, OpARM64PWHILELTB, types.NewTuple(typ.Mask, types.TypeFlags))
19920 v1 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
19921 v1.AuxInt = int64ToAuxInt(0)
19922 v0.AddArg2(v1, r)
19923 v.AddArg(v0)
19924 return true
19925 }
19926 }
19927 func rewriteValueARM64_OpCtz16(v *Value) bool {
19928 v_0 := v.Args[0]
19929 b := v.Block
19930 typ := &b.Func.Config.Types
19931
19932
19933 for {
19934 t := v.Type
19935 x := v_0
19936 v.reset(OpARM64CLZW)
19937 v.Type = t
19938 v0 := b.NewValue0(v.Pos, OpARM64RBITW, typ.UInt32)
19939 v1 := b.NewValue0(v.Pos, OpARM64ORconst, typ.UInt32)
19940 v1.AuxInt = int64ToAuxInt(0x10000)
19941 v1.AddArg(x)
19942 v0.AddArg(v1)
19943 v.AddArg(v0)
19944 return true
19945 }
19946 }
19947 func rewriteValueARM64_OpCtz32(v *Value) bool {
19948 v_0 := v.Args[0]
19949 b := v.Block
19950
19951
19952 for {
19953 t := v.Type
19954 x := v_0
19955 v.reset(OpARM64CLZW)
19956 v0 := b.NewValue0(v.Pos, OpARM64RBITW, t)
19957 v0.AddArg(x)
19958 v.AddArg(v0)
19959 return true
19960 }
19961 }
19962 func rewriteValueARM64_OpCtz64(v *Value) bool {
19963 v_0 := v.Args[0]
19964 b := v.Block
19965
19966
19967 for {
19968 t := v.Type
19969 x := v_0
19970 v.reset(OpARM64CLZ)
19971 v0 := b.NewValue0(v.Pos, OpARM64RBIT, t)
19972 v0.AddArg(x)
19973 v.AddArg(v0)
19974 return true
19975 }
19976 }
19977 func rewriteValueARM64_OpCtz8(v *Value) bool {
19978 v_0 := v.Args[0]
19979 b := v.Block
19980 typ := &b.Func.Config.Types
19981
19982
19983 for {
19984 t := v.Type
19985 x := v_0
19986 v.reset(OpARM64CLZW)
19987 v.Type = t
19988 v0 := b.NewValue0(v.Pos, OpARM64RBITW, typ.UInt32)
19989 v1 := b.NewValue0(v.Pos, OpARM64ORconst, typ.UInt32)
19990 v1.AuxInt = int64ToAuxInt(0x100)
19991 v1.AddArg(x)
19992 v0.AddArg(v1)
19993 v.AddArg(v0)
19994 return true
19995 }
19996 }
19997 func rewriteValueARM64_OpDiv16(v *Value) bool {
19998 v_1 := v.Args[1]
19999 v_0 := v.Args[0]
20000 b := v.Block
20001 typ := &b.Func.Config.Types
20002
20003
20004 for {
20005 if auxIntToBool(v.AuxInt) != false {
20006 break
20007 }
20008 x := v_0
20009 y := v_1
20010 v.reset(OpARM64DIVW)
20011 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
20012 v0.AddArg(x)
20013 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
20014 v1.AddArg(y)
20015 v.AddArg2(v0, v1)
20016 return true
20017 }
20018 return false
20019 }
20020 func rewriteValueARM64_OpDiv16u(v *Value) bool {
20021 v_1 := v.Args[1]
20022 v_0 := v.Args[0]
20023 b := v.Block
20024 typ := &b.Func.Config.Types
20025
20026
20027 for {
20028 x := v_0
20029 y := v_1
20030 v.reset(OpARM64UDIVW)
20031 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20032 v0.AddArg(x)
20033 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20034 v1.AddArg(y)
20035 v.AddArg2(v0, v1)
20036 return true
20037 }
20038 }
20039 func rewriteValueARM64_OpDiv32(v *Value) bool {
20040 v_1 := v.Args[1]
20041 v_0 := v.Args[0]
20042
20043
20044 for {
20045 if auxIntToBool(v.AuxInt) != false {
20046 break
20047 }
20048 x := v_0
20049 y := v_1
20050 v.reset(OpARM64DIVW)
20051 v.AddArg2(x, y)
20052 return true
20053 }
20054 return false
20055 }
20056 func rewriteValueARM64_OpDiv64(v *Value) bool {
20057 v_1 := v.Args[1]
20058 v_0 := v.Args[0]
20059
20060
20061 for {
20062 if auxIntToBool(v.AuxInt) != false {
20063 break
20064 }
20065 x := v_0
20066 y := v_1
20067 v.reset(OpARM64DIV)
20068 v.AddArg2(x, y)
20069 return true
20070 }
20071 return false
20072 }
20073 func rewriteValueARM64_OpDiv8(v *Value) bool {
20074 v_1 := v.Args[1]
20075 v_0 := v.Args[0]
20076 b := v.Block
20077 typ := &b.Func.Config.Types
20078
20079
20080 for {
20081 x := v_0
20082 y := v_1
20083 v.reset(OpARM64DIVW)
20084 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
20085 v0.AddArg(x)
20086 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
20087 v1.AddArg(y)
20088 v.AddArg2(v0, v1)
20089 return true
20090 }
20091 }
20092 func rewriteValueARM64_OpDiv8u(v *Value) bool {
20093 v_1 := v.Args[1]
20094 v_0 := v.Args[0]
20095 b := v.Block
20096 typ := &b.Func.Config.Types
20097
20098
20099 for {
20100 x := v_0
20101 y := v_1
20102 v.reset(OpARM64UDIVW)
20103 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20104 v0.AddArg(x)
20105 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20106 v1.AddArg(y)
20107 v.AddArg2(v0, v1)
20108 return true
20109 }
20110 }
20111 func rewriteValueARM64_OpEq16(v *Value) bool {
20112 v_1 := v.Args[1]
20113 v_0 := v.Args[0]
20114 b := v.Block
20115 typ := &b.Func.Config.Types
20116
20117
20118 for {
20119 x := v_0
20120 y := v_1
20121 v.reset(OpARM64Equal)
20122 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20123 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20124 v1.AddArg(x)
20125 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20126 v2.AddArg(y)
20127 v0.AddArg2(v1, v2)
20128 v.AddArg(v0)
20129 return true
20130 }
20131 }
20132 func rewriteValueARM64_OpEq32(v *Value) bool {
20133 v_1 := v.Args[1]
20134 v_0 := v.Args[0]
20135 b := v.Block
20136
20137
20138 for {
20139 x := v_0
20140 y := v_1
20141 v.reset(OpARM64Equal)
20142 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20143 v0.AddArg2(x, y)
20144 v.AddArg(v0)
20145 return true
20146 }
20147 }
20148 func rewriteValueARM64_OpEq32F(v *Value) bool {
20149 v_1 := v.Args[1]
20150 v_0 := v.Args[0]
20151 b := v.Block
20152
20153
20154 for {
20155 x := v_0
20156 y := v_1
20157 v.reset(OpARM64Equal)
20158 v0 := b.NewValue0(v.Pos, OpARM64FCMPS, types.TypeFlags)
20159 v0.AddArg2(x, y)
20160 v.AddArg(v0)
20161 return true
20162 }
20163 }
20164 func rewriteValueARM64_OpEq64(v *Value) bool {
20165 v_1 := v.Args[1]
20166 v_0 := v.Args[0]
20167 b := v.Block
20168
20169
20170 for {
20171 x := v_0
20172 y := v_1
20173 v.reset(OpARM64Equal)
20174 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
20175 v0.AddArg2(x, y)
20176 v.AddArg(v0)
20177 return true
20178 }
20179 }
20180 func rewriteValueARM64_OpEq64F(v *Value) bool {
20181 v_1 := v.Args[1]
20182 v_0 := v.Args[0]
20183 b := v.Block
20184
20185
20186 for {
20187 x := v_0
20188 y := v_1
20189 v.reset(OpARM64Equal)
20190 v0 := b.NewValue0(v.Pos, OpARM64FCMPD, types.TypeFlags)
20191 v0.AddArg2(x, y)
20192 v.AddArg(v0)
20193 return true
20194 }
20195 }
20196 func rewriteValueARM64_OpEq8(v *Value) bool {
20197 v_1 := v.Args[1]
20198 v_0 := v.Args[0]
20199 b := v.Block
20200 typ := &b.Func.Config.Types
20201
20202
20203 for {
20204 x := v_0
20205 y := v_1
20206 v.reset(OpARM64Equal)
20207 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20208 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20209 v1.AddArg(x)
20210 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20211 v2.AddArg(y)
20212 v0.AddArg2(v1, v2)
20213 v.AddArg(v0)
20214 return true
20215 }
20216 }
20217 func rewriteValueARM64_OpEqB(v *Value) bool {
20218 v_1 := v.Args[1]
20219 v_0 := v.Args[0]
20220 b := v.Block
20221 typ := &b.Func.Config.Types
20222
20223
20224 for {
20225 x := v_0
20226 y := v_1
20227 v.reset(OpARM64XOR)
20228 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20229 v0.AuxInt = int64ToAuxInt(1)
20230 v1 := b.NewValue0(v.Pos, OpARM64XOR, typ.Bool)
20231 v1.AddArg2(x, y)
20232 v.AddArg2(v0, v1)
20233 return true
20234 }
20235 }
20236 func rewriteValueARM64_OpEqPtr(v *Value) bool {
20237 v_1 := v.Args[1]
20238 v_0 := v.Args[0]
20239 b := v.Block
20240
20241
20242 for {
20243 x := v_0
20244 y := v_1
20245 v.reset(OpARM64Equal)
20246 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
20247 v0.AddArg2(x, y)
20248 v.AddArg(v0)
20249 return true
20250 }
20251 }
20252 func rewriteValueARM64_OpFMA(v *Value) bool {
20253 v_2 := v.Args[2]
20254 v_1 := v.Args[1]
20255 v_0 := v.Args[0]
20256
20257
20258 for {
20259 x := v_0
20260 y := v_1
20261 z := v_2
20262 v.reset(OpARM64FMADDD)
20263 v.AddArg3(z, x, y)
20264 return true
20265 }
20266 }
20267 func rewriteValueARM64_OpGreaterInt8s(v *Value) bool {
20268 v_1 := v.Args[1]
20269 v_0 := v.Args[0]
20270 b := v.Block
20271 typ := &b.Func.Config.Types
20272
20273
20274 for {
20275 x := v_0
20276 y := v_1
20277 v.reset(OpSelect0)
20278 v.Type = types.TypeMask
20279 v0 := b.NewValue0(v.Pos, OpARM64ZCMPGTB, types.NewTuple(typ.Mask, types.TypeFlags))
20280 v1 := b.NewValue0(v.Pos, OpSelect0, types.TypeMask)
20281 v2 := b.NewValue0(v.Pos, OpARM64PWHILELTB, types.NewTuple(typ.Mask, types.TypeFlags))
20282 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20283 v3.AuxInt = int64ToAuxInt(0)
20284 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20285 v4.AuxInt = int64ToAuxInt(32)
20286 v2.AddArg2(v3, v4)
20287 v1.AddArg(v2)
20288 v0.AddArg3(x, y, v1)
20289 v.AddArg(v0)
20290 return true
20291 }
20292 }
20293 func rewriteValueARM64_OpHmul32(v *Value) bool {
20294 v_1 := v.Args[1]
20295 v_0 := v.Args[0]
20296 b := v.Block
20297 typ := &b.Func.Config.Types
20298
20299
20300 for {
20301 x := v_0
20302 y := v_1
20303 v.reset(OpARM64SRAconst)
20304 v.AuxInt = int64ToAuxInt(32)
20305 v0 := b.NewValue0(v.Pos, OpARM64MULL, typ.Int64)
20306 v0.AddArg2(x, y)
20307 v.AddArg(v0)
20308 return true
20309 }
20310 }
20311 func rewriteValueARM64_OpHmul32u(v *Value) bool {
20312 v_1 := v.Args[1]
20313 v_0 := v.Args[0]
20314 b := v.Block
20315 typ := &b.Func.Config.Types
20316
20317
20318 for {
20319 x := v_0
20320 y := v_1
20321 v.reset(OpARM64SRAconst)
20322 v.AuxInt = int64ToAuxInt(32)
20323 v0 := b.NewValue0(v.Pos, OpARM64UMULL, typ.UInt64)
20324 v0.AddArg2(x, y)
20325 v.AddArg(v0)
20326 return true
20327 }
20328 }
20329 func rewriteValueARM64_OpIsInBounds(v *Value) bool {
20330 v_1 := v.Args[1]
20331 v_0 := v.Args[0]
20332 b := v.Block
20333
20334
20335 for {
20336 idx := v_0
20337 len := v_1
20338 v.reset(OpARM64LessThanU)
20339 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
20340 v0.AddArg2(idx, len)
20341 v.AddArg(v0)
20342 return true
20343 }
20344 }
20345 func rewriteValueARM64_OpIsNonNil(v *Value) bool {
20346 v_0 := v.Args[0]
20347 b := v.Block
20348
20349
20350 for {
20351 ptr := v_0
20352 v.reset(OpARM64NotEqual)
20353 v0 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
20354 v0.AuxInt = int64ToAuxInt(0)
20355 v0.AddArg(ptr)
20356 v.AddArg(v0)
20357 return true
20358 }
20359 }
20360 func rewriteValueARM64_OpIsSliceInBounds(v *Value) bool {
20361 v_1 := v.Args[1]
20362 v_0 := v.Args[0]
20363 b := v.Block
20364
20365
20366 for {
20367 idx := v_0
20368 len := v_1
20369 v.reset(OpARM64LessEqualU)
20370 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
20371 v0.AddArg2(idx, len)
20372 v.AddArg(v0)
20373 return true
20374 }
20375 }
20376 func rewriteValueARM64_OpLeq16(v *Value) bool {
20377 v_1 := v.Args[1]
20378 v_0 := v.Args[0]
20379 b := v.Block
20380 typ := &b.Func.Config.Types
20381
20382
20383 for {
20384 x := v_0
20385 y := v_1
20386 v.reset(OpARM64LessEqual)
20387 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20388 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
20389 v1.AddArg(x)
20390 v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
20391 v2.AddArg(y)
20392 v0.AddArg2(v1, v2)
20393 v.AddArg(v0)
20394 return true
20395 }
20396 }
20397 func rewriteValueARM64_OpLeq16U(v *Value) bool {
20398 v_1 := v.Args[1]
20399 v_0 := v.Args[0]
20400 b := v.Block
20401 typ := &b.Func.Config.Types
20402
20403
20404 for {
20405 x := v_0
20406 zero := v_1
20407 if zero.Op != OpARM64MOVDconst || auxIntToInt64(zero.AuxInt) != 0 {
20408 break
20409 }
20410 v.reset(OpEq16)
20411 v.AddArg2(x, zero)
20412 return true
20413 }
20414
20415
20416 for {
20417 if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != 1 {
20418 break
20419 }
20420 x := v_1
20421 v.reset(OpNeq16)
20422 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20423 v0.AuxInt = int64ToAuxInt(0)
20424 v.AddArg2(v0, x)
20425 return true
20426 }
20427
20428
20429 for {
20430 x := v_0
20431 y := v_1
20432 v.reset(OpARM64LessEqualU)
20433 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20434 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20435 v1.AddArg(x)
20436 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20437 v2.AddArg(y)
20438 v0.AddArg2(v1, v2)
20439 v.AddArg(v0)
20440 return true
20441 }
20442 }
20443 func rewriteValueARM64_OpLeq32(v *Value) bool {
20444 v_1 := v.Args[1]
20445 v_0 := v.Args[0]
20446 b := v.Block
20447
20448
20449 for {
20450 x := v_0
20451 y := v_1
20452 v.reset(OpARM64LessEqual)
20453 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20454 v0.AddArg2(x, y)
20455 v.AddArg(v0)
20456 return true
20457 }
20458 }
20459 func rewriteValueARM64_OpLeq32F(v *Value) bool {
20460 v_1 := v.Args[1]
20461 v_0 := v.Args[0]
20462 b := v.Block
20463
20464
20465 for {
20466 x := v_0
20467 y := v_1
20468 v.reset(OpARM64LessEqualF)
20469 v0 := b.NewValue0(v.Pos, OpARM64FCMPS, types.TypeFlags)
20470 v0.AddArg2(x, y)
20471 v.AddArg(v0)
20472 return true
20473 }
20474 }
20475 func rewriteValueARM64_OpLeq32U(v *Value) bool {
20476 v_1 := v.Args[1]
20477 v_0 := v.Args[0]
20478 b := v.Block
20479 typ := &b.Func.Config.Types
20480
20481
20482 for {
20483 x := v_0
20484 zero := v_1
20485 if zero.Op != OpARM64MOVDconst || auxIntToInt64(zero.AuxInt) != 0 {
20486 break
20487 }
20488 v.reset(OpEq32)
20489 v.AddArg2(x, zero)
20490 return true
20491 }
20492
20493
20494 for {
20495 if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != 1 {
20496 break
20497 }
20498 x := v_1
20499 v.reset(OpNeq32)
20500 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20501 v0.AuxInt = int64ToAuxInt(0)
20502 v.AddArg2(v0, x)
20503 return true
20504 }
20505
20506
20507 for {
20508 x := v_0
20509 y := v_1
20510 v.reset(OpARM64LessEqualU)
20511 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20512 v0.AddArg2(x, y)
20513 v.AddArg(v0)
20514 return true
20515 }
20516 }
20517 func rewriteValueARM64_OpLeq64(v *Value) bool {
20518 v_1 := v.Args[1]
20519 v_0 := v.Args[0]
20520 b := v.Block
20521
20522
20523 for {
20524 x := v_0
20525 y := v_1
20526 v.reset(OpARM64LessEqual)
20527 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
20528 v0.AddArg2(x, y)
20529 v.AddArg(v0)
20530 return true
20531 }
20532 }
20533 func rewriteValueARM64_OpLeq64F(v *Value) bool {
20534 v_1 := v.Args[1]
20535 v_0 := v.Args[0]
20536 b := v.Block
20537
20538
20539 for {
20540 x := v_0
20541 y := v_1
20542 v.reset(OpARM64LessEqualF)
20543 v0 := b.NewValue0(v.Pos, OpARM64FCMPD, types.TypeFlags)
20544 v0.AddArg2(x, y)
20545 v.AddArg(v0)
20546 return true
20547 }
20548 }
20549 func rewriteValueARM64_OpLeq64U(v *Value) bool {
20550 v_1 := v.Args[1]
20551 v_0 := v.Args[0]
20552 b := v.Block
20553 typ := &b.Func.Config.Types
20554
20555
20556 for {
20557 x := v_0
20558 zero := v_1
20559 if zero.Op != OpARM64MOVDconst || auxIntToInt64(zero.AuxInt) != 0 {
20560 break
20561 }
20562 v.reset(OpEq64)
20563 v.AddArg2(x, zero)
20564 return true
20565 }
20566
20567
20568 for {
20569 if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != 1 {
20570 break
20571 }
20572 x := v_1
20573 v.reset(OpNeq64)
20574 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20575 v0.AuxInt = int64ToAuxInt(0)
20576 v.AddArg2(v0, x)
20577 return true
20578 }
20579
20580
20581 for {
20582 x := v_0
20583 y := v_1
20584 v.reset(OpARM64LessEqualU)
20585 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
20586 v0.AddArg2(x, y)
20587 v.AddArg(v0)
20588 return true
20589 }
20590 }
20591 func rewriteValueARM64_OpLeq8(v *Value) bool {
20592 v_1 := v.Args[1]
20593 v_0 := v.Args[0]
20594 b := v.Block
20595 typ := &b.Func.Config.Types
20596
20597
20598 for {
20599 x := v_0
20600 y := v_1
20601 v.reset(OpARM64LessEqual)
20602 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20603 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
20604 v1.AddArg(x)
20605 v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
20606 v2.AddArg(y)
20607 v0.AddArg2(v1, v2)
20608 v.AddArg(v0)
20609 return true
20610 }
20611 }
20612 func rewriteValueARM64_OpLeq8U(v *Value) bool {
20613 v_1 := v.Args[1]
20614 v_0 := v.Args[0]
20615 b := v.Block
20616 typ := &b.Func.Config.Types
20617
20618
20619 for {
20620 x := v_0
20621 zero := v_1
20622 if zero.Op != OpARM64MOVDconst || auxIntToInt64(zero.AuxInt) != 0 {
20623 break
20624 }
20625 v.reset(OpEq8)
20626 v.AddArg2(x, zero)
20627 return true
20628 }
20629
20630
20631 for {
20632 if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != 1 {
20633 break
20634 }
20635 x := v_1
20636 v.reset(OpNeq8)
20637 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20638 v0.AuxInt = int64ToAuxInt(0)
20639 v.AddArg2(v0, x)
20640 return true
20641 }
20642
20643
20644 for {
20645 x := v_0
20646 y := v_1
20647 v.reset(OpARM64LessEqualU)
20648 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20649 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20650 v1.AddArg(x)
20651 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20652 v2.AddArg(y)
20653 v0.AddArg2(v1, v2)
20654 v.AddArg(v0)
20655 return true
20656 }
20657 }
20658 func rewriteValueARM64_OpLess16(v *Value) bool {
20659 v_1 := v.Args[1]
20660 v_0 := v.Args[0]
20661 b := v.Block
20662 typ := &b.Func.Config.Types
20663
20664
20665 for {
20666 x := v_0
20667 y := v_1
20668 v.reset(OpARM64LessThan)
20669 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20670 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
20671 v1.AddArg(x)
20672 v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
20673 v2.AddArg(y)
20674 v0.AddArg2(v1, v2)
20675 v.AddArg(v0)
20676 return true
20677 }
20678 }
20679 func rewriteValueARM64_OpLess16U(v *Value) bool {
20680 v_1 := v.Args[1]
20681 v_0 := v.Args[0]
20682 b := v.Block
20683 typ := &b.Func.Config.Types
20684
20685
20686 for {
20687 zero := v_0
20688 if zero.Op != OpARM64MOVDconst || auxIntToInt64(zero.AuxInt) != 0 {
20689 break
20690 }
20691 x := v_1
20692 v.reset(OpNeq16)
20693 v.AddArg2(zero, x)
20694 return true
20695 }
20696
20697
20698 for {
20699 x := v_0
20700 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
20701 break
20702 }
20703 v.reset(OpEq16)
20704 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20705 v0.AuxInt = int64ToAuxInt(0)
20706 v.AddArg2(x, v0)
20707 return true
20708 }
20709
20710
20711 for {
20712 x := v_0
20713 y := v_1
20714 v.reset(OpARM64LessThanU)
20715 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20716 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20717 v1.AddArg(x)
20718 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20719 v2.AddArg(y)
20720 v0.AddArg2(v1, v2)
20721 v.AddArg(v0)
20722 return true
20723 }
20724 }
20725 func rewriteValueARM64_OpLess32(v *Value) bool {
20726 v_1 := v.Args[1]
20727 v_0 := v.Args[0]
20728 b := v.Block
20729
20730
20731 for {
20732 x := v_0
20733 y := v_1
20734 v.reset(OpARM64LessThan)
20735 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20736 v0.AddArg2(x, y)
20737 v.AddArg(v0)
20738 return true
20739 }
20740 }
20741 func rewriteValueARM64_OpLess32F(v *Value) bool {
20742 v_1 := v.Args[1]
20743 v_0 := v.Args[0]
20744 b := v.Block
20745
20746
20747 for {
20748 x := v_0
20749 y := v_1
20750 v.reset(OpARM64LessThanF)
20751 v0 := b.NewValue0(v.Pos, OpARM64FCMPS, types.TypeFlags)
20752 v0.AddArg2(x, y)
20753 v.AddArg(v0)
20754 return true
20755 }
20756 }
20757 func rewriteValueARM64_OpLess32U(v *Value) bool {
20758 v_1 := v.Args[1]
20759 v_0 := v.Args[0]
20760 b := v.Block
20761 typ := &b.Func.Config.Types
20762
20763
20764 for {
20765 zero := v_0
20766 if zero.Op != OpARM64MOVDconst || auxIntToInt64(zero.AuxInt) != 0 {
20767 break
20768 }
20769 x := v_1
20770 v.reset(OpNeq32)
20771 v.AddArg2(zero, x)
20772 return true
20773 }
20774
20775
20776 for {
20777 x := v_0
20778 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
20779 break
20780 }
20781 v.reset(OpEq32)
20782 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20783 v0.AuxInt = int64ToAuxInt(0)
20784 v.AddArg2(x, v0)
20785 return true
20786 }
20787
20788
20789 for {
20790 x := v_0
20791 y := v_1
20792 v.reset(OpARM64LessThanU)
20793 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20794 v0.AddArg2(x, y)
20795 v.AddArg(v0)
20796 return true
20797 }
20798 }
20799 func rewriteValueARM64_OpLess64(v *Value) bool {
20800 v_1 := v.Args[1]
20801 v_0 := v.Args[0]
20802 b := v.Block
20803
20804
20805 for {
20806 x := v_0
20807 y := v_1
20808 v.reset(OpARM64LessThan)
20809 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
20810 v0.AddArg2(x, y)
20811 v.AddArg(v0)
20812 return true
20813 }
20814 }
20815 func rewriteValueARM64_OpLess64F(v *Value) bool {
20816 v_1 := v.Args[1]
20817 v_0 := v.Args[0]
20818 b := v.Block
20819
20820
20821 for {
20822 x := v_0
20823 y := v_1
20824 v.reset(OpARM64LessThanF)
20825 v0 := b.NewValue0(v.Pos, OpARM64FCMPD, types.TypeFlags)
20826 v0.AddArg2(x, y)
20827 v.AddArg(v0)
20828 return true
20829 }
20830 }
20831 func rewriteValueARM64_OpLess64U(v *Value) bool {
20832 v_1 := v.Args[1]
20833 v_0 := v.Args[0]
20834 b := v.Block
20835 typ := &b.Func.Config.Types
20836
20837
20838 for {
20839 zero := v_0
20840 if zero.Op != OpARM64MOVDconst || auxIntToInt64(zero.AuxInt) != 0 {
20841 break
20842 }
20843 x := v_1
20844 v.reset(OpNeq64)
20845 v.AddArg2(zero, x)
20846 return true
20847 }
20848
20849
20850 for {
20851 x := v_0
20852 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
20853 break
20854 }
20855 v.reset(OpEq64)
20856 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20857 v0.AuxInt = int64ToAuxInt(0)
20858 v.AddArg2(x, v0)
20859 return true
20860 }
20861
20862
20863 for {
20864 x := v_0
20865 y := v_1
20866 v.reset(OpARM64LessThanU)
20867 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
20868 v0.AddArg2(x, y)
20869 v.AddArg(v0)
20870 return true
20871 }
20872 }
20873 func rewriteValueARM64_OpLess8(v *Value) bool {
20874 v_1 := v.Args[1]
20875 v_0 := v.Args[0]
20876 b := v.Block
20877 typ := &b.Func.Config.Types
20878
20879
20880 for {
20881 x := v_0
20882 y := v_1
20883 v.reset(OpARM64LessThan)
20884 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20885 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
20886 v1.AddArg(x)
20887 v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
20888 v2.AddArg(y)
20889 v0.AddArg2(v1, v2)
20890 v.AddArg(v0)
20891 return true
20892 }
20893 }
20894 func rewriteValueARM64_OpLess8U(v *Value) bool {
20895 v_1 := v.Args[1]
20896 v_0 := v.Args[0]
20897 b := v.Block
20898 typ := &b.Func.Config.Types
20899
20900
20901 for {
20902 zero := v_0
20903 if zero.Op != OpARM64MOVDconst || auxIntToInt64(zero.AuxInt) != 0 {
20904 break
20905 }
20906 x := v_1
20907 v.reset(OpNeq8)
20908 v.AddArg2(zero, x)
20909 return true
20910 }
20911
20912
20913 for {
20914 x := v_0
20915 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
20916 break
20917 }
20918 v.reset(OpEq8)
20919 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20920 v0.AuxInt = int64ToAuxInt(0)
20921 v.AddArg2(x, v0)
20922 return true
20923 }
20924
20925
20926 for {
20927 x := v_0
20928 y := v_1
20929 v.reset(OpARM64LessThanU)
20930 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20931 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20932 v1.AddArg(x)
20933 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20934 v2.AddArg(y)
20935 v0.AddArg2(v1, v2)
20936 v.AddArg(v0)
20937 return true
20938 }
20939 }
20940 func rewriteValueARM64_OpLoad(v *Value) bool {
20941 v_1 := v.Args[1]
20942 v_0 := v.Args[0]
20943
20944
20945
20946 for {
20947 t := v.Type
20948 ptr := v_0
20949 mem := v_1
20950 if !(t.IsBoolean()) {
20951 break
20952 }
20953 v.reset(OpARM64MOVBUload)
20954 v.AddArg2(ptr, mem)
20955 return true
20956 }
20957
20958
20959
20960 for {
20961 t := v.Type
20962 ptr := v_0
20963 mem := v_1
20964 if !(is8BitInt(t) && t.IsSigned()) {
20965 break
20966 }
20967 v.reset(OpARM64MOVBload)
20968 v.AddArg2(ptr, mem)
20969 return true
20970 }
20971
20972
20973
20974 for {
20975 t := v.Type
20976 ptr := v_0
20977 mem := v_1
20978 if !(is8BitInt(t) && !t.IsSigned()) {
20979 break
20980 }
20981 v.reset(OpARM64MOVBUload)
20982 v.AddArg2(ptr, mem)
20983 return true
20984 }
20985
20986
20987
20988 for {
20989 t := v.Type
20990 ptr := v_0
20991 mem := v_1
20992 if !(is16BitInt(t) && t.IsSigned()) {
20993 break
20994 }
20995 v.reset(OpARM64MOVHload)
20996 v.AddArg2(ptr, mem)
20997 return true
20998 }
20999
21000
21001
21002 for {
21003 t := v.Type
21004 ptr := v_0
21005 mem := v_1
21006 if !(is16BitInt(t) && !t.IsSigned()) {
21007 break
21008 }
21009 v.reset(OpARM64MOVHUload)
21010 v.AddArg2(ptr, mem)
21011 return true
21012 }
21013
21014
21015
21016 for {
21017 t := v.Type
21018 ptr := v_0
21019 mem := v_1
21020 if !(is32BitInt(t) && t.IsSigned()) {
21021 break
21022 }
21023 v.reset(OpARM64MOVWload)
21024 v.AddArg2(ptr, mem)
21025 return true
21026 }
21027
21028
21029
21030 for {
21031 t := v.Type
21032 ptr := v_0
21033 mem := v_1
21034 if !(is32BitInt(t) && !t.IsSigned()) {
21035 break
21036 }
21037 v.reset(OpARM64MOVWUload)
21038 v.AddArg2(ptr, mem)
21039 return true
21040 }
21041
21042
21043
21044 for {
21045 t := v.Type
21046 ptr := v_0
21047 mem := v_1
21048 if !(is64BitInt(t) || isPtr(t)) {
21049 break
21050 }
21051 v.reset(OpARM64MOVDload)
21052 v.AddArg2(ptr, mem)
21053 return true
21054 }
21055
21056
21057
21058 for {
21059 t := v.Type
21060 ptr := v_0
21061 mem := v_1
21062 if !(is32BitFloat(t)) {
21063 break
21064 }
21065 v.reset(OpARM64FMOVSload)
21066 v.AddArg2(ptr, mem)
21067 return true
21068 }
21069
21070
21071
21072 for {
21073 t := v.Type
21074 ptr := v_0
21075 mem := v_1
21076 if !(is64BitFloat(t)) {
21077 break
21078 }
21079 v.reset(OpARM64FMOVDload)
21080 v.AddArg2(ptr, mem)
21081 return true
21082 }
21083
21084
21085
21086 for {
21087 t := v.Type
21088 ptr := v_0
21089 mem := v_1
21090 if !(t.Size() == 16) {
21091 break
21092 }
21093 v.reset(OpARM64FMOVQload)
21094 v.AddArg2(ptr, mem)
21095 return true
21096 }
21097
21098
21099
21100 for {
21101 t := v.Type
21102 ptr := v_0
21103 mem := v_1
21104 if !(t.Size() == 32 && t.IsSIMD()) {
21105 break
21106 }
21107 v.reset(OpARM64ZLDRload)
21108 v.AddArg2(ptr, mem)
21109 return true
21110 }
21111
21112
21113
21114 for {
21115 t := v.Type
21116 ptr := v_0
21117 mem := v_1
21118 if !(t.Size() == 8 && t.IsSIMD()) {
21119 break
21120 }
21121 v.reset(OpARM64PLDRload)
21122 v.AddArg2(ptr, mem)
21123 return true
21124 }
21125 return false
21126 }
21127 func rewriteValueARM64_OpLoadMasked8(v *Value) bool {
21128 v_2 := v.Args[2]
21129 v_1 := v.Args[1]
21130 v_0 := v.Args[0]
21131
21132
21133
21134 for {
21135 t := v.Type
21136 ptr := v_0
21137 mask := v_1
21138 mem := v_2
21139 if !(t.Size() == 32) {
21140 break
21141 }
21142 v.reset(OpARM64ZLD1BPredload)
21143 v.AddArg3(ptr, mask, mem)
21144 return true
21145 }
21146 return false
21147 }
21148 func rewriteValueARM64_OpLocalAddr(v *Value) bool {
21149 v_1 := v.Args[1]
21150 v_0 := v.Args[0]
21151 b := v.Block
21152 typ := &b.Func.Config.Types
21153
21154
21155
21156 for {
21157 t := v.Type
21158 sym := auxToSym(v.Aux)
21159 base := v_0
21160 mem := v_1
21161 if !(t.Elem().HasPointers()) {
21162 break
21163 }
21164 v.reset(OpARM64MOVDaddr)
21165 v.Aux = symToAux(sym)
21166 v0 := b.NewValue0(v.Pos, OpSPanchored, typ.Uintptr)
21167 v0.AddArg2(base, mem)
21168 v.AddArg(v0)
21169 return true
21170 }
21171
21172
21173
21174 for {
21175 t := v.Type
21176 sym := auxToSym(v.Aux)
21177 base := v_0
21178 if !(!t.Elem().HasPointers()) {
21179 break
21180 }
21181 v.reset(OpARM64MOVDaddr)
21182 v.Aux = symToAux(sym)
21183 v.AddArg(base)
21184 return true
21185 }
21186 return false
21187 }
21188 func rewriteValueARM64_OpLsh64x16(v *Value) bool {
21189 v_1 := v.Args[1]
21190 v_0 := v.Args[0]
21191 b := v.Block
21192 typ := &b.Func.Config.Types
21193
21194
21195
21196 for {
21197 t := v.Type
21198 x := v_0
21199 y := v_1
21200 if !(shiftIsBounded(v)) {
21201 break
21202 }
21203 v.reset(OpARM64SLL)
21204 v.Type = t
21205 v.AddArg2(x, y)
21206 return true
21207 }
21208
21209
21210
21211 for {
21212 t := v.Type
21213 bounded := auxIntToBool(v.AuxInt)
21214 x := v_0
21215 y := v_1
21216 if !(!shiftIsBounded(v)) {
21217 break
21218 }
21219 v.reset(OpLsh64x32)
21220 v.Type = t
21221 v.AuxInt = boolToAuxInt(bounded)
21222 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
21223 v0.AddArg(y)
21224 v.AddArg2(x, v0)
21225 return true
21226 }
21227 return false
21228 }
21229 func rewriteValueARM64_OpLsh64x32(v *Value) bool {
21230 v_1 := v.Args[1]
21231 v_0 := v.Args[0]
21232 b := v.Block
21233
21234
21235
21236 for {
21237 t := v.Type
21238 x := v_0
21239 y := v_1
21240 if !(shiftIsBounded(v)) {
21241 break
21242 }
21243 v.reset(OpARM64SLL)
21244 v.Type = t
21245 v.AddArg2(x, y)
21246 return true
21247 }
21248
21249
21250
21251 for {
21252 t := v.Type
21253 x := v_0
21254 y := v_1
21255 if !(!shiftIsBounded(v)) {
21256 break
21257 }
21258 v.reset(OpARM64CSEL)
21259 v.AuxInt = opToAuxInt(OpARM64LessThanU)
21260 v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
21261 v0.AddArg2(x, y)
21262 v1 := b.NewValue0(v.Pos, OpConst64, t)
21263 v1.AuxInt = int64ToAuxInt(0)
21264 v2 := b.NewValue0(v.Pos, OpARM64CMPWconst, types.TypeFlags)
21265 v2.AuxInt = int32ToAuxInt(64)
21266 v2.AddArg(y)
21267 v.AddArg3(v0, v1, v2)
21268 return true
21269 }
21270 return false
21271 }
21272 func rewriteValueARM64_OpLsh64x64(v *Value) bool {
21273 v_1 := v.Args[1]
21274 v_0 := v.Args[0]
21275 b := v.Block
21276
21277
21278
21279 for {
21280 t := v.Type
21281 x := v_0
21282 y := v_1
21283 if !(shiftIsBounded(v)) {
21284 break
21285 }
21286 v.reset(OpARM64SLL)
21287 v.Type = t
21288 v.AddArg2(x, y)
21289 return true
21290 }
21291
21292
21293
21294 for {
21295 t := v.Type
21296 x := v_0
21297 y := v_1
21298 if !(!shiftIsBounded(v)) {
21299 break
21300 }
21301 v.reset(OpARM64CSEL)
21302 v.AuxInt = opToAuxInt(OpARM64LessThanU)
21303 v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
21304 v0.AddArg2(x, y)
21305 v1 := b.NewValue0(v.Pos, OpConst64, t)
21306 v1.AuxInt = int64ToAuxInt(0)
21307 v2 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
21308 v2.AuxInt = int64ToAuxInt(64)
21309 v2.AddArg(y)
21310 v.AddArg3(v0, v1, v2)
21311 return true
21312 }
21313 return false
21314 }
21315 func rewriteValueARM64_OpLsh64x8(v *Value) bool {
21316 v_1 := v.Args[1]
21317 v_0 := v.Args[0]
21318 b := v.Block
21319 typ := &b.Func.Config.Types
21320
21321
21322
21323 for {
21324 t := v.Type
21325 x := v_0
21326 y := v_1
21327 if !(shiftIsBounded(v)) {
21328 break
21329 }
21330 v.reset(OpARM64SLL)
21331 v.Type = t
21332 v.AddArg2(x, y)
21333 return true
21334 }
21335
21336
21337
21338 for {
21339 t := v.Type
21340 bounded := auxIntToBool(v.AuxInt)
21341 x := v_0
21342 y := v_1
21343 if !(!shiftIsBounded(v)) {
21344 break
21345 }
21346 v.reset(OpLsh64x32)
21347 v.Type = t
21348 v.AuxInt = boolToAuxInt(bounded)
21349 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
21350 v0.AddArg(y)
21351 v.AddArg2(x, v0)
21352 return true
21353 }
21354 return false
21355 }
21356 func rewriteValueARM64_OpMax32FSel(v *Value) bool {
21357 v_1 := v.Args[1]
21358 v_0 := v.Args[0]
21359 b := v.Block
21360
21361
21362 for {
21363 x := v_0
21364 y := v_1
21365 v.reset(OpARM64FCSELS)
21366 v.AuxInt = opToAuxInt(OpARM64GreaterThanF)
21367 v0 := b.NewValue0(v.Pos, OpARM64FCMPS, types.TypeFlags)
21368 v0.AddArg2(x, y)
21369 v.AddArg3(x, y, v0)
21370 return true
21371 }
21372 }
21373 func rewriteValueARM64_OpMax64FSel(v *Value) bool {
21374 v_1 := v.Args[1]
21375 v_0 := v.Args[0]
21376 b := v.Block
21377
21378
21379 for {
21380 x := v_0
21381 y := v_1
21382 v.reset(OpARM64FCSELD)
21383 v.AuxInt = opToAuxInt(OpARM64GreaterThanF)
21384 v0 := b.NewValue0(v.Pos, OpARM64FCMPD, types.TypeFlags)
21385 v0.AddArg2(x, y)
21386 v.AddArg3(x, y, v0)
21387 return true
21388 }
21389 }
21390 func rewriteValueARM64_OpMin32FSel(v *Value) bool {
21391 v_1 := v.Args[1]
21392 v_0 := v.Args[0]
21393 b := v.Block
21394
21395
21396 for {
21397 x := v_0
21398 y := v_1
21399 v.reset(OpARM64FCSELS)
21400 v.AuxInt = opToAuxInt(OpARM64LessThanF)
21401 v0 := b.NewValue0(v.Pos, OpARM64FCMPS, types.TypeFlags)
21402 v0.AddArg2(x, y)
21403 v.AddArg3(x, y, v0)
21404 return true
21405 }
21406 }
21407 func rewriteValueARM64_OpMin64FSel(v *Value) bool {
21408 v_1 := v.Args[1]
21409 v_0 := v.Args[0]
21410 b := v.Block
21411
21412
21413 for {
21414 x := v_0
21415 y := v_1
21416 v.reset(OpARM64FCSELD)
21417 v.AuxInt = opToAuxInt(OpARM64LessThanF)
21418 v0 := b.NewValue0(v.Pos, OpARM64FCMPD, types.TypeFlags)
21419 v0.AddArg2(x, y)
21420 v.AddArg3(x, y, v0)
21421 return true
21422 }
21423 }
21424 func rewriteValueARM64_OpMod16(v *Value) bool {
21425 v_1 := v.Args[1]
21426 v_0 := v.Args[0]
21427 b := v.Block
21428 typ := &b.Func.Config.Types
21429
21430
21431 for {
21432 x := v_0
21433 y := v_1
21434 v.reset(OpARM64MODW)
21435 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
21436 v0.AddArg(x)
21437 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
21438 v1.AddArg(y)
21439 v.AddArg2(v0, v1)
21440 return true
21441 }
21442 }
21443 func rewriteValueARM64_OpMod16u(v *Value) bool {
21444 v_1 := v.Args[1]
21445 v_0 := v.Args[0]
21446 b := v.Block
21447 typ := &b.Func.Config.Types
21448
21449
21450 for {
21451 x := v_0
21452 y := v_1
21453 v.reset(OpARM64UMODW)
21454 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
21455 v0.AddArg(x)
21456 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
21457 v1.AddArg(y)
21458 v.AddArg2(v0, v1)
21459 return true
21460 }
21461 }
21462 func rewriteValueARM64_OpMod32(v *Value) bool {
21463 v_1 := v.Args[1]
21464 v_0 := v.Args[0]
21465
21466
21467 for {
21468 x := v_0
21469 y := v_1
21470 v.reset(OpARM64MODW)
21471 v.AddArg2(x, y)
21472 return true
21473 }
21474 }
21475 func rewriteValueARM64_OpMod64(v *Value) bool {
21476 v_1 := v.Args[1]
21477 v_0 := v.Args[0]
21478
21479
21480 for {
21481 x := v_0
21482 y := v_1
21483 v.reset(OpARM64MOD)
21484 v.AddArg2(x, y)
21485 return true
21486 }
21487 }
21488 func rewriteValueARM64_OpMod8(v *Value) bool {
21489 v_1 := v.Args[1]
21490 v_0 := v.Args[0]
21491 b := v.Block
21492 typ := &b.Func.Config.Types
21493
21494
21495 for {
21496 x := v_0
21497 y := v_1
21498 v.reset(OpARM64MODW)
21499 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
21500 v0.AddArg(x)
21501 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
21502 v1.AddArg(y)
21503 v.AddArg2(v0, v1)
21504 return true
21505 }
21506 }
21507 func rewriteValueARM64_OpMod8u(v *Value) bool {
21508 v_1 := v.Args[1]
21509 v_0 := v.Args[0]
21510 b := v.Block
21511 typ := &b.Func.Config.Types
21512
21513
21514 for {
21515 x := v_0
21516 y := v_1
21517 v.reset(OpARM64UMODW)
21518 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
21519 v0.AddArg(x)
21520 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
21521 v1.AddArg(y)
21522 v.AddArg2(v0, v1)
21523 return true
21524 }
21525 }
21526 func rewriteValueARM64_OpMove(v *Value) bool {
21527 v_2 := v.Args[2]
21528 v_1 := v.Args[1]
21529 v_0 := v.Args[0]
21530 b := v.Block
21531 typ := &b.Func.Config.Types
21532
21533
21534 for {
21535 if auxIntToInt64(v.AuxInt) != 0 {
21536 break
21537 }
21538 mem := v_2
21539 v.copyOf(mem)
21540 return true
21541 }
21542
21543
21544 for {
21545 if auxIntToInt64(v.AuxInt) != 1 {
21546 break
21547 }
21548 dst := v_0
21549 src := v_1
21550 mem := v_2
21551 v.reset(OpARM64MOVBstore)
21552 v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, typ.UInt8)
21553 v0.AddArg2(src, mem)
21554 v.AddArg3(dst, v0, mem)
21555 return true
21556 }
21557
21558
21559 for {
21560 if auxIntToInt64(v.AuxInt) != 2 {
21561 break
21562 }
21563 dst := v_0
21564 src := v_1
21565 mem := v_2
21566 v.reset(OpARM64MOVHstore)
21567 v0 := b.NewValue0(v.Pos, OpARM64MOVHUload, typ.UInt16)
21568 v0.AddArg2(src, mem)
21569 v.AddArg3(dst, v0, mem)
21570 return true
21571 }
21572
21573
21574 for {
21575 if auxIntToInt64(v.AuxInt) != 3 {
21576 break
21577 }
21578 dst := v_0
21579 src := v_1
21580 mem := v_2
21581 v.reset(OpARM64MOVBstore)
21582 v.AuxInt = int32ToAuxInt(2)
21583 v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, typ.UInt8)
21584 v0.AuxInt = int32ToAuxInt(2)
21585 v0.AddArg2(src, mem)
21586 v1 := b.NewValue0(v.Pos, OpARM64MOVHstore, types.TypeMem)
21587 v2 := b.NewValue0(v.Pos, OpARM64MOVHUload, typ.UInt16)
21588 v2.AddArg2(src, mem)
21589 v1.AddArg3(dst, v2, mem)
21590 v.AddArg3(dst, v0, v1)
21591 return true
21592 }
21593
21594
21595 for {
21596 if auxIntToInt64(v.AuxInt) != 4 {
21597 break
21598 }
21599 dst := v_0
21600 src := v_1
21601 mem := v_2
21602 v.reset(OpARM64MOVWstore)
21603 v0 := b.NewValue0(v.Pos, OpARM64MOVWUload, typ.UInt32)
21604 v0.AddArg2(src, mem)
21605 v.AddArg3(dst, v0, mem)
21606 return true
21607 }
21608
21609
21610 for {
21611 if auxIntToInt64(v.AuxInt) != 5 {
21612 break
21613 }
21614 dst := v_0
21615 src := v_1
21616 mem := v_2
21617 v.reset(OpARM64MOVBstore)
21618 v.AuxInt = int32ToAuxInt(4)
21619 v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, typ.UInt8)
21620 v0.AuxInt = int32ToAuxInt(4)
21621 v0.AddArg2(src, mem)
21622 v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, types.TypeMem)
21623 v2 := b.NewValue0(v.Pos, OpARM64MOVWUload, typ.UInt32)
21624 v2.AddArg2(src, mem)
21625 v1.AddArg3(dst, v2, mem)
21626 v.AddArg3(dst, v0, v1)
21627 return true
21628 }
21629
21630
21631 for {
21632 if auxIntToInt64(v.AuxInt) != 6 {
21633 break
21634 }
21635 dst := v_0
21636 src := v_1
21637 mem := v_2
21638 v.reset(OpARM64MOVHstore)
21639 v.AuxInt = int32ToAuxInt(4)
21640 v0 := b.NewValue0(v.Pos, OpARM64MOVHUload, typ.UInt16)
21641 v0.AuxInt = int32ToAuxInt(4)
21642 v0.AddArg2(src, mem)
21643 v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, types.TypeMem)
21644 v2 := b.NewValue0(v.Pos, OpARM64MOVWUload, typ.UInt32)
21645 v2.AddArg2(src, mem)
21646 v1.AddArg3(dst, v2, mem)
21647 v.AddArg3(dst, v0, v1)
21648 return true
21649 }
21650
21651
21652 for {
21653 if auxIntToInt64(v.AuxInt) != 7 {
21654 break
21655 }
21656 dst := v_0
21657 src := v_1
21658 mem := v_2
21659 v.reset(OpARM64MOVWstore)
21660 v.AuxInt = int32ToAuxInt(3)
21661 v0 := b.NewValue0(v.Pos, OpARM64MOVWUload, typ.UInt32)
21662 v0.AuxInt = int32ToAuxInt(3)
21663 v0.AddArg2(src, mem)
21664 v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, types.TypeMem)
21665 v2 := b.NewValue0(v.Pos, OpARM64MOVWUload, typ.UInt32)
21666 v2.AddArg2(src, mem)
21667 v1.AddArg3(dst, v2, mem)
21668 v.AddArg3(dst, v0, v1)
21669 return true
21670 }
21671
21672
21673 for {
21674 if auxIntToInt64(v.AuxInt) != 8 {
21675 break
21676 }
21677 dst := v_0
21678 src := v_1
21679 mem := v_2
21680 v.reset(OpARM64MOVDstore)
21681 v0 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21682 v0.AddArg2(src, mem)
21683 v.AddArg3(dst, v0, mem)
21684 return true
21685 }
21686
21687
21688 for {
21689 if auxIntToInt64(v.AuxInt) != 9 {
21690 break
21691 }
21692 dst := v_0
21693 src := v_1
21694 mem := v_2
21695 v.reset(OpARM64MOVBstore)
21696 v.AuxInt = int32ToAuxInt(8)
21697 v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, typ.UInt8)
21698 v0.AuxInt = int32ToAuxInt(8)
21699 v0.AddArg2(src, mem)
21700 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
21701 v2 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21702 v2.AddArg2(src, mem)
21703 v1.AddArg3(dst, v2, mem)
21704 v.AddArg3(dst, v0, v1)
21705 return true
21706 }
21707
21708
21709 for {
21710 if auxIntToInt64(v.AuxInt) != 10 {
21711 break
21712 }
21713 dst := v_0
21714 src := v_1
21715 mem := v_2
21716 v.reset(OpARM64MOVHstore)
21717 v.AuxInt = int32ToAuxInt(8)
21718 v0 := b.NewValue0(v.Pos, OpARM64MOVHUload, typ.UInt16)
21719 v0.AuxInt = int32ToAuxInt(8)
21720 v0.AddArg2(src, mem)
21721 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
21722 v2 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21723 v2.AddArg2(src, mem)
21724 v1.AddArg3(dst, v2, mem)
21725 v.AddArg3(dst, v0, v1)
21726 return true
21727 }
21728
21729
21730 for {
21731 if auxIntToInt64(v.AuxInt) != 11 {
21732 break
21733 }
21734 dst := v_0
21735 src := v_1
21736 mem := v_2
21737 v.reset(OpARM64MOVDstore)
21738 v.AuxInt = int32ToAuxInt(3)
21739 v0 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21740 v0.AuxInt = int32ToAuxInt(3)
21741 v0.AddArg2(src, mem)
21742 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
21743 v2 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21744 v2.AddArg2(src, mem)
21745 v1.AddArg3(dst, v2, mem)
21746 v.AddArg3(dst, v0, v1)
21747 return true
21748 }
21749
21750
21751 for {
21752 if auxIntToInt64(v.AuxInt) != 12 {
21753 break
21754 }
21755 dst := v_0
21756 src := v_1
21757 mem := v_2
21758 v.reset(OpARM64MOVWstore)
21759 v.AuxInt = int32ToAuxInt(8)
21760 v0 := b.NewValue0(v.Pos, OpARM64MOVWUload, typ.UInt32)
21761 v0.AuxInt = int32ToAuxInt(8)
21762 v0.AddArg2(src, mem)
21763 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
21764 v2 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21765 v2.AddArg2(src, mem)
21766 v1.AddArg3(dst, v2, mem)
21767 v.AddArg3(dst, v0, v1)
21768 return true
21769 }
21770
21771
21772 for {
21773 if auxIntToInt64(v.AuxInt) != 13 {
21774 break
21775 }
21776 dst := v_0
21777 src := v_1
21778 mem := v_2
21779 v.reset(OpARM64MOVDstore)
21780 v.AuxInt = int32ToAuxInt(5)
21781 v0 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21782 v0.AuxInt = int32ToAuxInt(5)
21783 v0.AddArg2(src, mem)
21784 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
21785 v2 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21786 v2.AddArg2(src, mem)
21787 v1.AddArg3(dst, v2, mem)
21788 v.AddArg3(dst, v0, v1)
21789 return true
21790 }
21791
21792
21793 for {
21794 if auxIntToInt64(v.AuxInt) != 14 {
21795 break
21796 }
21797 dst := v_0
21798 src := v_1
21799 mem := v_2
21800 v.reset(OpARM64MOVDstore)
21801 v.AuxInt = int32ToAuxInt(6)
21802 v0 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21803 v0.AuxInt = int32ToAuxInt(6)
21804 v0.AddArg2(src, mem)
21805 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
21806 v2 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21807 v2.AddArg2(src, mem)
21808 v1.AddArg3(dst, v2, mem)
21809 v.AddArg3(dst, v0, v1)
21810 return true
21811 }
21812
21813
21814 for {
21815 if auxIntToInt64(v.AuxInt) != 15 {
21816 break
21817 }
21818 dst := v_0
21819 src := v_1
21820 mem := v_2
21821 v.reset(OpARM64MOVDstore)
21822 v.AuxInt = int32ToAuxInt(7)
21823 v0 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21824 v0.AuxInt = int32ToAuxInt(7)
21825 v0.AddArg2(src, mem)
21826 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
21827 v2 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21828 v2.AddArg2(src, mem)
21829 v1.AddArg3(dst, v2, mem)
21830 v.AddArg3(dst, v0, v1)
21831 return true
21832 }
21833
21834
21835 for {
21836 if auxIntToInt64(v.AuxInt) != 16 {
21837 break
21838 }
21839 dst := v_0
21840 src := v_1
21841 mem := v_2
21842 v.reset(OpARM64FMOVQstore)
21843 v0 := b.NewValue0(v.Pos, OpARM64FMOVQload, typ.Vec128)
21844 v0.AddArg2(src, mem)
21845 v.AddArg3(dst, v0, mem)
21846 return true
21847 }
21848
21849
21850
21851 for {
21852 s := auxIntToInt64(v.AuxInt)
21853 dst := v_0
21854 src := v_1
21855 mem := v_2
21856 if !(s > 16 && s <= 24) {
21857 break
21858 }
21859 v.reset(OpARM64MOVDstore)
21860 v.AuxInt = int32ToAuxInt(int32(s - 8))
21861 v0 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21862 v0.AuxInt = int32ToAuxInt(int32(s - 8))
21863 v0.AddArg2(src, mem)
21864 v1 := b.NewValue0(v.Pos, OpARM64FMOVQstore, types.TypeMem)
21865 v2 := b.NewValue0(v.Pos, OpARM64FMOVQload, typ.Vec128)
21866 v2.AddArg2(src, mem)
21867 v1.AddArg3(dst, v2, mem)
21868 v.AddArg3(dst, v0, v1)
21869 return true
21870 }
21871
21872
21873
21874 for {
21875 s := auxIntToInt64(v.AuxInt)
21876 dst := v_0
21877 src := v_1
21878 mem := v_2
21879 if !(s > 24 && s < 32) {
21880 break
21881 }
21882 v.reset(OpARM64FMOVQstore)
21883 v.AuxInt = int32ToAuxInt(int32(s - 16))
21884 v0 := b.NewValue0(v.Pos, OpARM64FMOVQload, typ.Vec128)
21885 v0.AuxInt = int32ToAuxInt(int32(s - 16))
21886 v0.AddArg2(src, mem)
21887 v1 := b.NewValue0(v.Pos, OpARM64FMOVQstore, types.TypeMem)
21888 v2 := b.NewValue0(v.Pos, OpARM64FMOVQload, typ.Vec128)
21889 v2.AddArg2(src, mem)
21890 v1.AddArg3(dst, v2, mem)
21891 v.AddArg3(dst, v0, v1)
21892 return true
21893 }
21894
21895
21896 for {
21897 if auxIntToInt64(v.AuxInt) != 32 {
21898 break
21899 }
21900 dst := v_0
21901 src := v_1
21902 mem := v_2
21903 v.reset(OpARM64FSTPQ)
21904 v0 := b.NewValue0(v.Pos, OpSelect0, typ.Vec128)
21905 v1 := b.NewValue0(v.Pos, OpARM64FLDPQ, types.NewTuple(typ.Vec128, typ.Vec128))
21906 v1.AddArg2(src, mem)
21907 v0.AddArg(v1)
21908 v2 := b.NewValue0(v.Pos, OpSelect1, typ.Vec128)
21909 v2.AddArg(v1)
21910 v.AddArg4(dst, v0, v2, mem)
21911 return true
21912 }
21913
21914
21915
21916 for {
21917 s := auxIntToInt64(v.AuxInt)
21918 dst := v_0
21919 src := v_1
21920 mem := v_2
21921 if !(s > 32 && s <= 40) {
21922 break
21923 }
21924 v.reset(OpARM64MOVDstore)
21925 v.AuxInt = int32ToAuxInt(int32(s - 8))
21926 v0 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21927 v0.AuxInt = int32ToAuxInt(int32(s - 8))
21928 v0.AddArg2(src, mem)
21929 v1 := b.NewValue0(v.Pos, OpARM64FSTPQ, types.TypeMem)
21930 v2 := b.NewValue0(v.Pos, OpSelect0, typ.Vec128)
21931 v3 := b.NewValue0(v.Pos, OpARM64FLDPQ, types.NewTuple(typ.Vec128, typ.Vec128))
21932 v3.AddArg2(src, mem)
21933 v2.AddArg(v3)
21934 v4 := b.NewValue0(v.Pos, OpSelect1, typ.Vec128)
21935 v4.AddArg(v3)
21936 v1.AddArg4(dst, v2, v4, mem)
21937 v.AddArg3(dst, v0, v1)
21938 return true
21939 }
21940
21941
21942
21943 for {
21944 s := auxIntToInt64(v.AuxInt)
21945 dst := v_0
21946 src := v_1
21947 mem := v_2
21948 if !(s > 40 && s <= 48) {
21949 break
21950 }
21951 v.reset(OpARM64FMOVQstore)
21952 v.AuxInt = int32ToAuxInt(int32(s - 16))
21953 v0 := b.NewValue0(v.Pos, OpARM64FMOVQload, typ.Vec128)
21954 v0.AuxInt = int32ToAuxInt(int32(s - 16))
21955 v0.AddArg2(src, mem)
21956 v1 := b.NewValue0(v.Pos, OpARM64FSTPQ, types.TypeMem)
21957 v2 := b.NewValue0(v.Pos, OpSelect0, typ.Vec128)
21958 v3 := b.NewValue0(v.Pos, OpARM64FLDPQ, types.NewTuple(typ.Vec128, typ.Vec128))
21959 v3.AddArg2(src, mem)
21960 v2.AddArg(v3)
21961 v4 := b.NewValue0(v.Pos, OpSelect1, typ.Vec128)
21962 v4.AddArg(v3)
21963 v1.AddArg4(dst, v2, v4, mem)
21964 v.AddArg3(dst, v0, v1)
21965 return true
21966 }
21967
21968
21969
21970 for {
21971 s := auxIntToInt64(v.AuxInt)
21972 dst := v_0
21973 src := v_1
21974 mem := v_2
21975 if !(s > 48 && s <= 64) {
21976 break
21977 }
21978 v.reset(OpARM64FSTPQ)
21979 v.AuxInt = int32ToAuxInt(int32(s - 32))
21980 v0 := b.NewValue0(v.Pos, OpSelect0, typ.Vec128)
21981 v1 := b.NewValue0(v.Pos, OpARM64FLDPQ, types.NewTuple(typ.Vec128, typ.Vec128))
21982 v1.AuxInt = int32ToAuxInt(int32(s - 32))
21983 v1.AddArg2(src, mem)
21984 v0.AddArg(v1)
21985 v2 := b.NewValue0(v.Pos, OpSelect1, typ.Vec128)
21986 v2.AddArg(v1)
21987 v3 := b.NewValue0(v.Pos, OpARM64FSTPQ, types.TypeMem)
21988 v4 := b.NewValue0(v.Pos, OpSelect0, typ.Vec128)
21989 v5 := b.NewValue0(v.Pos, OpARM64FLDPQ, types.NewTuple(typ.Vec128, typ.Vec128))
21990 v5.AddArg2(src, mem)
21991 v4.AddArg(v5)
21992 v6 := b.NewValue0(v.Pos, OpSelect1, typ.Vec128)
21993 v6.AddArg(v5)
21994 v3.AddArg4(dst, v4, v6, mem)
21995 v.AddArg4(dst, v0, v2, v3)
21996 return true
21997 }
21998
21999
22000
22001 for {
22002 s := auxIntToInt64(v.AuxInt)
22003 dst := v_0
22004 src := v_1
22005 mem := v_2
22006 if !(s > 64 && s < 192 && logLargeCopy(v, s)) {
22007 break
22008 }
22009 v.reset(OpARM64LoweredMove)
22010 v.AuxInt = int64ToAuxInt(s)
22011 v.AddArg3(dst, src, mem)
22012 return true
22013 }
22014
22015
22016
22017 for {
22018 s := auxIntToInt64(v.AuxInt)
22019 dst := v_0
22020 src := v_1
22021 mem := v_2
22022 if !(s >= 192 && logLargeCopy(v, s)) {
22023 break
22024 }
22025 v.reset(OpARM64LoweredMoveLoop)
22026 v.AuxInt = int64ToAuxInt(s)
22027 v.AddArg3(dst, src, mem)
22028 return true
22029 }
22030 return false
22031 }
22032 func rewriteValueARM64_OpMulAddFloat32x4(v *Value) bool {
22033 v_2 := v.Args[2]
22034 v_1 := v.Args[1]
22035 v_0 := v.Args[0]
22036
22037
22038 for {
22039 x := v_0
22040 y := v_1
22041 z := v_2
22042 v.reset(OpARM64VFMLA4S)
22043 v.AddArg3(z, x, y)
22044 return true
22045 }
22046 }
22047 func rewriteValueARM64_OpMulAddFloat64x2(v *Value) bool {
22048 v_2 := v.Args[2]
22049 v_1 := v.Args[1]
22050 v_0 := v.Args[0]
22051
22052
22053 for {
22054 x := v_0
22055 y := v_1
22056 z := v_2
22057 v.reset(OpARM64VFMLA2D)
22058 v.AddArg3(z, x, y)
22059 return true
22060 }
22061 }
22062 func rewriteValueARM64_OpMulAddInt16x8(v *Value) bool {
22063 v_2 := v.Args[2]
22064 v_1 := v.Args[1]
22065 v_0 := v.Args[0]
22066
22067
22068 for {
22069 x := v_0
22070 y := v_1
22071 z := v_2
22072 v.reset(OpARM64VMLA8H)
22073 v.AddArg3(z, x, y)
22074 return true
22075 }
22076 }
22077 func rewriteValueARM64_OpMulAddInt32x4(v *Value) bool {
22078 v_2 := v.Args[2]
22079 v_1 := v.Args[1]
22080 v_0 := v.Args[0]
22081
22082
22083 for {
22084 x := v_0
22085 y := v_1
22086 z := v_2
22087 v.reset(OpARM64VMLA4S)
22088 v.AddArg3(z, x, y)
22089 return true
22090 }
22091 }
22092 func rewriteValueARM64_OpMulAddInt8x16(v *Value) bool {
22093 v_2 := v.Args[2]
22094 v_1 := v.Args[1]
22095 v_0 := v.Args[0]
22096
22097
22098 for {
22099 x := v_0
22100 y := v_1
22101 z := v_2
22102 v.reset(OpARM64VMLA16B)
22103 v.AddArg3(z, x, y)
22104 return true
22105 }
22106 }
22107 func rewriteValueARM64_OpMulAddUint16x8(v *Value) bool {
22108 v_2 := v.Args[2]
22109 v_1 := v.Args[1]
22110 v_0 := v.Args[0]
22111
22112
22113 for {
22114 x := v_0
22115 y := v_1
22116 z := v_2
22117 v.reset(OpARM64VMLA8H)
22118 v.AddArg3(z, x, y)
22119 return true
22120 }
22121 }
22122 func rewriteValueARM64_OpMulAddUint32x4(v *Value) bool {
22123 v_2 := v.Args[2]
22124 v_1 := v.Args[1]
22125 v_0 := v.Args[0]
22126
22127
22128 for {
22129 x := v_0
22130 y := v_1
22131 z := v_2
22132 v.reset(OpARM64VMLA4S)
22133 v.AddArg3(z, x, y)
22134 return true
22135 }
22136 }
22137 func rewriteValueARM64_OpMulAddUint8x16(v *Value) bool {
22138 v_2 := v.Args[2]
22139 v_1 := v.Args[1]
22140 v_0 := v.Args[0]
22141
22142
22143 for {
22144 x := v_0
22145 y := v_1
22146 z := v_2
22147 v.reset(OpARM64VMLA16B)
22148 v.AddArg3(z, x, y)
22149 return true
22150 }
22151 }
22152 func rewriteValueARM64_OpNeq16(v *Value) bool {
22153 v_1 := v.Args[1]
22154 v_0 := v.Args[0]
22155 b := v.Block
22156 typ := &b.Func.Config.Types
22157
22158
22159 for {
22160 x := v_0
22161 y := v_1
22162 v.reset(OpARM64NotEqual)
22163 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
22164 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
22165 v1.AddArg(x)
22166 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
22167 v2.AddArg(y)
22168 v0.AddArg2(v1, v2)
22169 v.AddArg(v0)
22170 return true
22171 }
22172 }
22173 func rewriteValueARM64_OpNeq32(v *Value) bool {
22174 v_1 := v.Args[1]
22175 v_0 := v.Args[0]
22176 b := v.Block
22177
22178
22179 for {
22180 x := v_0
22181 y := v_1
22182 v.reset(OpARM64NotEqual)
22183 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
22184 v0.AddArg2(x, y)
22185 v.AddArg(v0)
22186 return true
22187 }
22188 }
22189 func rewriteValueARM64_OpNeq32F(v *Value) bool {
22190 v_1 := v.Args[1]
22191 v_0 := v.Args[0]
22192 b := v.Block
22193
22194
22195 for {
22196 x := v_0
22197 y := v_1
22198 v.reset(OpARM64NotEqual)
22199 v0 := b.NewValue0(v.Pos, OpARM64FCMPS, types.TypeFlags)
22200 v0.AddArg2(x, y)
22201 v.AddArg(v0)
22202 return true
22203 }
22204 }
22205 func rewriteValueARM64_OpNeq64(v *Value) bool {
22206 v_1 := v.Args[1]
22207 v_0 := v.Args[0]
22208 b := v.Block
22209
22210
22211 for {
22212 x := v_0
22213 y := v_1
22214 v.reset(OpARM64NotEqual)
22215 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
22216 v0.AddArg2(x, y)
22217 v.AddArg(v0)
22218 return true
22219 }
22220 }
22221 func rewriteValueARM64_OpNeq64F(v *Value) bool {
22222 v_1 := v.Args[1]
22223 v_0 := v.Args[0]
22224 b := v.Block
22225
22226
22227 for {
22228 x := v_0
22229 y := v_1
22230 v.reset(OpARM64NotEqual)
22231 v0 := b.NewValue0(v.Pos, OpARM64FCMPD, types.TypeFlags)
22232 v0.AddArg2(x, y)
22233 v.AddArg(v0)
22234 return true
22235 }
22236 }
22237 func rewriteValueARM64_OpNeq8(v *Value) bool {
22238 v_1 := v.Args[1]
22239 v_0 := v.Args[0]
22240 b := v.Block
22241 typ := &b.Func.Config.Types
22242
22243
22244 for {
22245 x := v_0
22246 y := v_1
22247 v.reset(OpARM64NotEqual)
22248 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
22249 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
22250 v1.AddArg(x)
22251 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
22252 v2.AddArg(y)
22253 v0.AddArg2(v1, v2)
22254 v.AddArg(v0)
22255 return true
22256 }
22257 }
22258 func rewriteValueARM64_OpNeqPtr(v *Value) bool {
22259 v_1 := v.Args[1]
22260 v_0 := v.Args[0]
22261 b := v.Block
22262
22263
22264 for {
22265 x := v_0
22266 y := v_1
22267 v.reset(OpARM64NotEqual)
22268 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
22269 v0.AddArg2(x, y)
22270 v.AddArg(v0)
22271 return true
22272 }
22273 }
22274 func rewriteValueARM64_OpNot(v *Value) bool {
22275 v_0 := v.Args[0]
22276 b := v.Block
22277 typ := &b.Func.Config.Types
22278
22279
22280 for {
22281 x := v_0
22282 v.reset(OpARM64XOR)
22283 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
22284 v0.AuxInt = int64ToAuxInt(1)
22285 v.AddArg2(v0, x)
22286 return true
22287 }
22288 }
22289 func rewriteValueARM64_OpOffPtr(v *Value) bool {
22290 v_0 := v.Args[0]
22291
22292
22293
22294 for {
22295 off := auxIntToInt64(v.AuxInt)
22296 ptr := v_0
22297 if ptr.Op != OpSP || !(is32Bit(off)) {
22298 break
22299 }
22300 v.reset(OpARM64MOVDaddr)
22301 v.AuxInt = int32ToAuxInt(int32(off))
22302 v.AddArg(ptr)
22303 return true
22304 }
22305
22306
22307 for {
22308 off := auxIntToInt64(v.AuxInt)
22309 ptr := v_0
22310 v.reset(OpARM64ADDconst)
22311 v.AuxInt = int64ToAuxInt(off)
22312 v.AddArg(ptr)
22313 return true
22314 }
22315 }
22316 func rewriteValueARM64_OpPopCount16(v *Value) bool {
22317 v_0 := v.Args[0]
22318 b := v.Block
22319 typ := &b.Func.Config.Types
22320
22321
22322 for {
22323 t := v.Type
22324 x := v_0
22325 v.reset(OpARM64FMOVDfpgp)
22326 v.Type = t
22327 v0 := b.NewValue0(v.Pos, OpARM64VUADDLV, typ.Float64)
22328 v1 := b.NewValue0(v.Pos, OpARM64VCNT, typ.Float64)
22329 v2 := b.NewValue0(v.Pos, OpARM64FMOVDgpfp, typ.Float64)
22330 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
22331 v3.AddArg(x)
22332 v2.AddArg(v3)
22333 v1.AddArg(v2)
22334 v0.AddArg(v1)
22335 v.AddArg(v0)
22336 return true
22337 }
22338 }
22339 func rewriteValueARM64_OpPopCount32(v *Value) bool {
22340 v_0 := v.Args[0]
22341 b := v.Block
22342 typ := &b.Func.Config.Types
22343
22344
22345 for {
22346 t := v.Type
22347 x := v_0
22348 v.reset(OpARM64FMOVDfpgp)
22349 v.Type = t
22350 v0 := b.NewValue0(v.Pos, OpARM64VUADDLV, typ.Float64)
22351 v1 := b.NewValue0(v.Pos, OpARM64VCNT, typ.Float64)
22352 v2 := b.NewValue0(v.Pos, OpARM64FMOVDgpfp, typ.Float64)
22353 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
22354 v3.AddArg(x)
22355 v2.AddArg(v3)
22356 v1.AddArg(v2)
22357 v0.AddArg(v1)
22358 v.AddArg(v0)
22359 return true
22360 }
22361 }
22362 func rewriteValueARM64_OpPopCount64(v *Value) bool {
22363 v_0 := v.Args[0]
22364 b := v.Block
22365 typ := &b.Func.Config.Types
22366
22367
22368 for {
22369 t := v.Type
22370 x := v_0
22371 v.reset(OpARM64FMOVDfpgp)
22372 v.Type = t
22373 v0 := b.NewValue0(v.Pos, OpARM64VUADDLV, typ.Float64)
22374 v1 := b.NewValue0(v.Pos, OpARM64VCNT, typ.Float64)
22375 v2 := b.NewValue0(v.Pos, OpARM64FMOVDgpfp, typ.Float64)
22376 v2.AddArg(x)
22377 v1.AddArg(v2)
22378 v0.AddArg(v1)
22379 v.AddArg(v0)
22380 return true
22381 }
22382 }
22383 func rewriteValueARM64_OpPrefetchCache(v *Value) bool {
22384 v_1 := v.Args[1]
22385 v_0 := v.Args[0]
22386
22387
22388 for {
22389 addr := v_0
22390 mem := v_1
22391 v.reset(OpARM64PRFM)
22392 v.AuxInt = int64ToAuxInt(0)
22393 v.AddArg2(addr, mem)
22394 return true
22395 }
22396 }
22397 func rewriteValueARM64_OpPrefetchCacheStreamed(v *Value) bool {
22398 v_1 := v.Args[1]
22399 v_0 := v.Args[0]
22400
22401
22402 for {
22403 addr := v_0
22404 mem := v_1
22405 v.reset(OpARM64PRFM)
22406 v.AuxInt = int64ToAuxInt(1)
22407 v.AddArg2(addr, mem)
22408 return true
22409 }
22410 }
22411 func rewriteValueARM64_OpPubBarrier(v *Value) bool {
22412 v_0 := v.Args[0]
22413
22414
22415 for {
22416 mem := v_0
22417 v.reset(OpARM64DMB)
22418 v.AuxInt = int64ToAuxInt(0xe)
22419 v.AddArg(mem)
22420 return true
22421 }
22422 }
22423 func rewriteValueARM64_OpRotateLeft16(v *Value) bool {
22424 v_1 := v.Args[1]
22425 v_0 := v.Args[0]
22426 b := v.Block
22427 typ := &b.Func.Config.Types
22428
22429
22430 for {
22431 t := v.Type
22432 x := v_0
22433 if v_1.Op != OpARM64MOVDconst {
22434 break
22435 }
22436 c := auxIntToInt64(v_1.AuxInt)
22437 v.reset(OpOr16)
22438 v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
22439 v1 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
22440 v1.AuxInt = int64ToAuxInt(c & 15)
22441 v0.AddArg2(x, v1)
22442 v2 := b.NewValue0(v.Pos, OpRsh16Ux64, t)
22443 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
22444 v3.AuxInt = int64ToAuxInt(-c & 15)
22445 v2.AddArg2(x, v3)
22446 v.AddArg2(v0, v2)
22447 return true
22448 }
22449
22450
22451 for {
22452 t := v.Type
22453 x := v_0
22454 y := v_1
22455 v.reset(OpARM64RORW)
22456 v.Type = t
22457 v0 := b.NewValue0(v.Pos, OpARM64ORshiftLL, typ.UInt32)
22458 v0.AuxInt = int64ToAuxInt(16)
22459 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
22460 v1.AddArg(x)
22461 v0.AddArg2(v1, v1)
22462 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
22463 v2.AddArg(y)
22464 v.AddArg2(v0, v2)
22465 return true
22466 }
22467 }
22468 func rewriteValueARM64_OpRotateLeft32(v *Value) bool {
22469 v_1 := v.Args[1]
22470 v_0 := v.Args[0]
22471 b := v.Block
22472
22473
22474 for {
22475 x := v_0
22476 y := v_1
22477 v.reset(OpARM64RORW)
22478 v0 := b.NewValue0(v.Pos, OpARM64NEG, y.Type)
22479 v0.AddArg(y)
22480 v.AddArg2(x, v0)
22481 return true
22482 }
22483 }
22484 func rewriteValueARM64_OpRotateLeft64(v *Value) bool {
22485 v_1 := v.Args[1]
22486 v_0 := v.Args[0]
22487 b := v.Block
22488
22489
22490 for {
22491 x := v_0
22492 y := v_1
22493 v.reset(OpARM64ROR)
22494 v0 := b.NewValue0(v.Pos, OpARM64NEG, y.Type)
22495 v0.AddArg(y)
22496 v.AddArg2(x, v0)
22497 return true
22498 }
22499 }
22500 func rewriteValueARM64_OpRotateLeft8(v *Value) bool {
22501 v_1 := v.Args[1]
22502 v_0 := v.Args[0]
22503 b := v.Block
22504 typ := &b.Func.Config.Types
22505
22506
22507 for {
22508 t := v.Type
22509 x := v_0
22510 if v_1.Op != OpARM64MOVDconst {
22511 break
22512 }
22513 c := auxIntToInt64(v_1.AuxInt)
22514 v.reset(OpOr8)
22515 v0 := b.NewValue0(v.Pos, OpLsh8x64, t)
22516 v1 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
22517 v1.AuxInt = int64ToAuxInt(c & 7)
22518 v0.AddArg2(x, v1)
22519 v2 := b.NewValue0(v.Pos, OpRsh8Ux64, t)
22520 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
22521 v3.AuxInt = int64ToAuxInt(-c & 7)
22522 v2.AddArg2(x, v3)
22523 v.AddArg2(v0, v2)
22524 return true
22525 }
22526
22527
22528 for {
22529 t := v.Type
22530 x := v_0
22531 y := v_1
22532 v.reset(OpARM64OR)
22533 v.Type = t
22534 v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
22535 v1 := b.NewValue0(v.Pos, OpARM64ANDconst, typ.Int64)
22536 v1.AuxInt = int64ToAuxInt(7)
22537 v1.AddArg(y)
22538 v0.AddArg2(x, v1)
22539 v2 := b.NewValue0(v.Pos, OpARM64SRL, t)
22540 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
22541 v3.AddArg(x)
22542 v4 := b.NewValue0(v.Pos, OpARM64ANDconst, typ.Int64)
22543 v4.AuxInt = int64ToAuxInt(7)
22544 v5 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
22545 v5.AddArg(y)
22546 v4.AddArg(v5)
22547 v2.AddArg2(v3, v4)
22548 v.AddArg2(v0, v2)
22549 return true
22550 }
22551 }
22552 func rewriteValueARM64_OpRsh16Ux16(v *Value) bool {
22553 v_1 := v.Args[1]
22554 v_0 := v.Args[0]
22555 b := v.Block
22556 typ := &b.Func.Config.Types
22557
22558
22559 for {
22560 t := v.Type
22561 bounded := auxIntToBool(v.AuxInt)
22562 x := v_0
22563 y := v_1
22564 v.reset(OpRsh64Ux16)
22565 v.Type = t
22566 v.AuxInt = boolToAuxInt(bounded)
22567 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
22568 v0.AddArg(x)
22569 v.AddArg2(v0, y)
22570 return true
22571 }
22572 }
22573 func rewriteValueARM64_OpRsh16Ux32(v *Value) bool {
22574 v_1 := v.Args[1]
22575 v_0 := v.Args[0]
22576 b := v.Block
22577 typ := &b.Func.Config.Types
22578
22579
22580 for {
22581 t := v.Type
22582 bounded := auxIntToBool(v.AuxInt)
22583 x := v_0
22584 y := v_1
22585 v.reset(OpRsh64Ux32)
22586 v.Type = t
22587 v.AuxInt = boolToAuxInt(bounded)
22588 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
22589 v0.AddArg(x)
22590 v.AddArg2(v0, y)
22591 return true
22592 }
22593 }
22594 func rewriteValueARM64_OpRsh16Ux64(v *Value) bool {
22595 v_1 := v.Args[1]
22596 v_0 := v.Args[0]
22597 b := v.Block
22598 typ := &b.Func.Config.Types
22599
22600
22601 for {
22602 t := v.Type
22603 bounded := auxIntToBool(v.AuxInt)
22604 x := v_0
22605 y := v_1
22606 v.reset(OpRsh64Ux64)
22607 v.Type = t
22608 v.AuxInt = boolToAuxInt(bounded)
22609 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
22610 v0.AddArg(x)
22611 v.AddArg2(v0, y)
22612 return true
22613 }
22614 }
22615 func rewriteValueARM64_OpRsh16Ux8(v *Value) bool {
22616 v_1 := v.Args[1]
22617 v_0 := v.Args[0]
22618 b := v.Block
22619 typ := &b.Func.Config.Types
22620
22621
22622 for {
22623 t := v.Type
22624 bounded := auxIntToBool(v.AuxInt)
22625 x := v_0
22626 y := v_1
22627 v.reset(OpRsh64Ux8)
22628 v.Type = t
22629 v.AuxInt = boolToAuxInt(bounded)
22630 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
22631 v0.AddArg(x)
22632 v.AddArg2(v0, y)
22633 return true
22634 }
22635 }
22636 func rewriteValueARM64_OpRsh16x16(v *Value) bool {
22637 v_1 := v.Args[1]
22638 v_0 := v.Args[0]
22639 b := v.Block
22640 typ := &b.Func.Config.Types
22641
22642
22643 for {
22644 t := v.Type
22645 bounded := auxIntToBool(v.AuxInt)
22646 x := v_0
22647 y := v_1
22648 v.reset(OpRsh64x16)
22649 v.Type = t
22650 v.AuxInt = boolToAuxInt(bounded)
22651 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
22652 v0.AddArg(x)
22653 v.AddArg2(v0, y)
22654 return true
22655 }
22656 }
22657 func rewriteValueARM64_OpRsh16x32(v *Value) bool {
22658 v_1 := v.Args[1]
22659 v_0 := v.Args[0]
22660 b := v.Block
22661 typ := &b.Func.Config.Types
22662
22663
22664 for {
22665 t := v.Type
22666 bounded := auxIntToBool(v.AuxInt)
22667 x := v_0
22668 y := v_1
22669 v.reset(OpRsh64x32)
22670 v.Type = t
22671 v.AuxInt = boolToAuxInt(bounded)
22672 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
22673 v0.AddArg(x)
22674 v.AddArg2(v0, y)
22675 return true
22676 }
22677 }
22678 func rewriteValueARM64_OpRsh16x64(v *Value) bool {
22679 v_1 := v.Args[1]
22680 v_0 := v.Args[0]
22681 b := v.Block
22682 typ := &b.Func.Config.Types
22683
22684
22685 for {
22686 t := v.Type
22687 bounded := auxIntToBool(v.AuxInt)
22688 x := v_0
22689 y := v_1
22690 v.reset(OpRsh64x64)
22691 v.Type = t
22692 v.AuxInt = boolToAuxInt(bounded)
22693 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
22694 v0.AddArg(x)
22695 v.AddArg2(v0, y)
22696 return true
22697 }
22698 }
22699 func rewriteValueARM64_OpRsh16x8(v *Value) bool {
22700 v_1 := v.Args[1]
22701 v_0 := v.Args[0]
22702 b := v.Block
22703 typ := &b.Func.Config.Types
22704
22705
22706 for {
22707 t := v.Type
22708 bounded := auxIntToBool(v.AuxInt)
22709 x := v_0
22710 y := v_1
22711 v.reset(OpRsh64x8)
22712 v.Type = t
22713 v.AuxInt = boolToAuxInt(bounded)
22714 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
22715 v0.AddArg(x)
22716 v.AddArg2(v0, y)
22717 return true
22718 }
22719 }
22720 func rewriteValueARM64_OpRsh32Ux16(v *Value) bool {
22721 v_1 := v.Args[1]
22722 v_0 := v.Args[0]
22723 b := v.Block
22724 typ := &b.Func.Config.Types
22725
22726
22727 for {
22728 t := v.Type
22729 bounded := auxIntToBool(v.AuxInt)
22730 x := v_0
22731 y := v_1
22732 v.reset(OpRsh64Ux16)
22733 v.Type = t
22734 v.AuxInt = boolToAuxInt(bounded)
22735 v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
22736 v0.AddArg(x)
22737 v.AddArg2(v0, y)
22738 return true
22739 }
22740 }
22741 func rewriteValueARM64_OpRsh32Ux32(v *Value) bool {
22742 v_1 := v.Args[1]
22743 v_0 := v.Args[0]
22744 b := v.Block
22745 typ := &b.Func.Config.Types
22746
22747
22748 for {
22749 t := v.Type
22750 bounded := auxIntToBool(v.AuxInt)
22751 x := v_0
22752 y := v_1
22753 v.reset(OpRsh64Ux32)
22754 v.Type = t
22755 v.AuxInt = boolToAuxInt(bounded)
22756 v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
22757 v0.AddArg(x)
22758 v.AddArg2(v0, y)
22759 return true
22760 }
22761 }
22762 func rewriteValueARM64_OpRsh32Ux64(v *Value) bool {
22763 v_1 := v.Args[1]
22764 v_0 := v.Args[0]
22765 b := v.Block
22766 typ := &b.Func.Config.Types
22767
22768
22769 for {
22770 t := v.Type
22771 bounded := auxIntToBool(v.AuxInt)
22772 x := v_0
22773 y := v_1
22774 v.reset(OpRsh64Ux64)
22775 v.Type = t
22776 v.AuxInt = boolToAuxInt(bounded)
22777 v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
22778 v0.AddArg(x)
22779 v.AddArg2(v0, y)
22780 return true
22781 }
22782 }
22783 func rewriteValueARM64_OpRsh32Ux8(v *Value) bool {
22784 v_1 := v.Args[1]
22785 v_0 := v.Args[0]
22786 b := v.Block
22787 typ := &b.Func.Config.Types
22788
22789
22790 for {
22791 t := v.Type
22792 bounded := auxIntToBool(v.AuxInt)
22793 x := v_0
22794 y := v_1
22795 v.reset(OpRsh64Ux8)
22796 v.Type = t
22797 v.AuxInt = boolToAuxInt(bounded)
22798 v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
22799 v0.AddArg(x)
22800 v.AddArg2(v0, y)
22801 return true
22802 }
22803 }
22804 func rewriteValueARM64_OpRsh32x16(v *Value) bool {
22805 v_1 := v.Args[1]
22806 v_0 := v.Args[0]
22807 b := v.Block
22808 typ := &b.Func.Config.Types
22809
22810
22811 for {
22812 t := v.Type
22813 bounded := auxIntToBool(v.AuxInt)
22814 x := v_0
22815 y := v_1
22816 v.reset(OpRsh64x16)
22817 v.Type = t
22818 v.AuxInt = boolToAuxInt(bounded)
22819 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
22820 v0.AddArg(x)
22821 v.AddArg2(v0, y)
22822 return true
22823 }
22824 }
22825 func rewriteValueARM64_OpRsh32x32(v *Value) bool {
22826 v_1 := v.Args[1]
22827 v_0 := v.Args[0]
22828 b := v.Block
22829 typ := &b.Func.Config.Types
22830
22831
22832 for {
22833 t := v.Type
22834 bounded := auxIntToBool(v.AuxInt)
22835 x := v_0
22836 y := v_1
22837 v.reset(OpRsh64x32)
22838 v.Type = t
22839 v.AuxInt = boolToAuxInt(bounded)
22840 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
22841 v0.AddArg(x)
22842 v.AddArg2(v0, y)
22843 return true
22844 }
22845 }
22846 func rewriteValueARM64_OpRsh32x64(v *Value) bool {
22847 v_1 := v.Args[1]
22848 v_0 := v.Args[0]
22849 b := v.Block
22850 typ := &b.Func.Config.Types
22851
22852
22853 for {
22854 t := v.Type
22855 bounded := auxIntToBool(v.AuxInt)
22856 x := v_0
22857 y := v_1
22858 v.reset(OpRsh64x64)
22859 v.Type = t
22860 v.AuxInt = boolToAuxInt(bounded)
22861 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
22862 v0.AddArg(x)
22863 v.AddArg2(v0, y)
22864 return true
22865 }
22866 }
22867 func rewriteValueARM64_OpRsh32x8(v *Value) bool {
22868 v_1 := v.Args[1]
22869 v_0 := v.Args[0]
22870 b := v.Block
22871 typ := &b.Func.Config.Types
22872
22873
22874 for {
22875 t := v.Type
22876 bounded := auxIntToBool(v.AuxInt)
22877 x := v_0
22878 y := v_1
22879 v.reset(OpRsh64x8)
22880 v.Type = t
22881 v.AuxInt = boolToAuxInt(bounded)
22882 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
22883 v0.AddArg(x)
22884 v.AddArg2(v0, y)
22885 return true
22886 }
22887 }
22888 func rewriteValueARM64_OpRsh64Ux16(v *Value) bool {
22889 v_1 := v.Args[1]
22890 v_0 := v.Args[0]
22891 b := v.Block
22892 typ := &b.Func.Config.Types
22893
22894
22895
22896 for {
22897 t := v.Type
22898 x := v_0
22899 y := v_1
22900 if !(shiftIsBounded(v)) {
22901 break
22902 }
22903 v.reset(OpARM64SRL)
22904 v.Type = t
22905 v.AddArg2(x, y)
22906 return true
22907 }
22908
22909
22910
22911 for {
22912 t := v.Type
22913 bounded := auxIntToBool(v.AuxInt)
22914 x := v_0
22915 y := v_1
22916 if !(!shiftIsBounded(v)) {
22917 break
22918 }
22919 v.reset(OpRsh64Ux32)
22920 v.Type = t
22921 v.AuxInt = boolToAuxInt(bounded)
22922 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
22923 v0.AddArg(y)
22924 v.AddArg2(x, v0)
22925 return true
22926 }
22927 return false
22928 }
22929 func rewriteValueARM64_OpRsh64Ux32(v *Value) bool {
22930 v_1 := v.Args[1]
22931 v_0 := v.Args[0]
22932 b := v.Block
22933
22934
22935
22936 for {
22937 t := v.Type
22938 x := v_0
22939 y := v_1
22940 if !(shiftIsBounded(v)) {
22941 break
22942 }
22943 v.reset(OpARM64SRL)
22944 v.Type = t
22945 v.AddArg2(x, y)
22946 return true
22947 }
22948
22949
22950
22951 for {
22952 t := v.Type
22953 x := v_0
22954 y := v_1
22955 if !(!shiftIsBounded(v)) {
22956 break
22957 }
22958 v.reset(OpARM64CSEL)
22959 v.AuxInt = opToAuxInt(OpARM64LessThanU)
22960 v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
22961 v0.AddArg2(x, y)
22962 v1 := b.NewValue0(v.Pos, OpConst64, t)
22963 v1.AuxInt = int64ToAuxInt(0)
22964 v2 := b.NewValue0(v.Pos, OpARM64CMPWconst, types.TypeFlags)
22965 v2.AuxInt = int32ToAuxInt(64)
22966 v2.AddArg(y)
22967 v.AddArg3(v0, v1, v2)
22968 return true
22969 }
22970 return false
22971 }
22972 func rewriteValueARM64_OpRsh64Ux64(v *Value) bool {
22973 v_1 := v.Args[1]
22974 v_0 := v.Args[0]
22975 b := v.Block
22976
22977
22978
22979 for {
22980 t := v.Type
22981 x := v_0
22982 y := v_1
22983 if !(shiftIsBounded(v)) {
22984 break
22985 }
22986 v.reset(OpARM64SRL)
22987 v.Type = t
22988 v.AddArg2(x, y)
22989 return true
22990 }
22991
22992
22993
22994 for {
22995 t := v.Type
22996 x := v_0
22997 y := v_1
22998 if !(!shiftIsBounded(v)) {
22999 break
23000 }
23001 v.reset(OpARM64CSEL)
23002 v.AuxInt = opToAuxInt(OpARM64LessThanU)
23003 v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
23004 v0.AddArg2(x, y)
23005 v1 := b.NewValue0(v.Pos, OpConst64, t)
23006 v1.AuxInt = int64ToAuxInt(0)
23007 v2 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23008 v2.AuxInt = int64ToAuxInt(64)
23009 v2.AddArg(y)
23010 v.AddArg3(v0, v1, v2)
23011 return true
23012 }
23013 return false
23014 }
23015 func rewriteValueARM64_OpRsh64Ux8(v *Value) bool {
23016 v_1 := v.Args[1]
23017 v_0 := v.Args[0]
23018 b := v.Block
23019 typ := &b.Func.Config.Types
23020
23021
23022
23023 for {
23024 t := v.Type
23025 x := v_0
23026 y := v_1
23027 if !(shiftIsBounded(v)) {
23028 break
23029 }
23030 v.reset(OpARM64SRL)
23031 v.Type = t
23032 v.AddArg2(x, y)
23033 return true
23034 }
23035
23036
23037
23038 for {
23039 t := v.Type
23040 bounded := auxIntToBool(v.AuxInt)
23041 x := v_0
23042 y := v_1
23043 if !(!shiftIsBounded(v)) {
23044 break
23045 }
23046 v.reset(OpRsh64Ux32)
23047 v.Type = t
23048 v.AuxInt = boolToAuxInt(bounded)
23049 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
23050 v0.AddArg(y)
23051 v.AddArg2(x, v0)
23052 return true
23053 }
23054 return false
23055 }
23056 func rewriteValueARM64_OpRsh64x16(v *Value) bool {
23057 v_1 := v.Args[1]
23058 v_0 := v.Args[0]
23059 b := v.Block
23060 typ := &b.Func.Config.Types
23061
23062
23063
23064 for {
23065 t := v.Type
23066 x := v_0
23067 y := v_1
23068 if !(shiftIsBounded(v)) {
23069 break
23070 }
23071 v.reset(OpARM64SRA)
23072 v.Type = t
23073 v.AddArg2(x, y)
23074 return true
23075 }
23076
23077
23078
23079 for {
23080 t := v.Type
23081 bounded := auxIntToBool(v.AuxInt)
23082 x := v_0
23083 y := v_1
23084 if !(!shiftIsBounded(v)) {
23085 break
23086 }
23087 v.reset(OpRsh64x32)
23088 v.Type = t
23089 v.AuxInt = boolToAuxInt(bounded)
23090 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
23091 v0.AddArg(y)
23092 v.AddArg2(x, v0)
23093 return true
23094 }
23095 return false
23096 }
23097 func rewriteValueARM64_OpRsh64x32(v *Value) bool {
23098 v_1 := v.Args[1]
23099 v_0 := v.Args[0]
23100 b := v.Block
23101
23102
23103
23104 for {
23105 t := v.Type
23106 x := v_0
23107 y := v_1
23108 if !(shiftIsBounded(v)) {
23109 break
23110 }
23111 v.reset(OpARM64SRA)
23112 v.Type = t
23113 v.AddArg2(x, y)
23114 return true
23115 }
23116
23117
23118
23119 for {
23120 x := v_0
23121 y := v_1
23122 if !(!shiftIsBounded(v)) {
23123 break
23124 }
23125 v.reset(OpARM64SRA)
23126 v0 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
23127 v0.AuxInt = opToAuxInt(OpARM64LessThanU)
23128 v1 := b.NewValue0(v.Pos, OpConst64, y.Type)
23129 v1.AuxInt = int64ToAuxInt(63)
23130 v2 := b.NewValue0(v.Pos, OpARM64CMPWconst, types.TypeFlags)
23131 v2.AuxInt = int32ToAuxInt(64)
23132 v2.AddArg(y)
23133 v0.AddArg3(y, v1, v2)
23134 v.AddArg2(x, v0)
23135 return true
23136 }
23137 return false
23138 }
23139 func rewriteValueARM64_OpRsh64x64(v *Value) bool {
23140 v_1 := v.Args[1]
23141 v_0 := v.Args[0]
23142 b := v.Block
23143
23144
23145
23146 for {
23147 t := v.Type
23148 x := v_0
23149 y := v_1
23150 if !(shiftIsBounded(v)) {
23151 break
23152 }
23153 v.reset(OpARM64SRA)
23154 v.Type = t
23155 v.AddArg2(x, y)
23156 return true
23157 }
23158
23159
23160
23161 for {
23162 x := v_0
23163 y := v_1
23164 if !(!shiftIsBounded(v)) {
23165 break
23166 }
23167 v.reset(OpARM64SRA)
23168 v0 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
23169 v0.AuxInt = opToAuxInt(OpARM64LessThanU)
23170 v1 := b.NewValue0(v.Pos, OpConst64, y.Type)
23171 v1.AuxInt = int64ToAuxInt(63)
23172 v2 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23173 v2.AuxInt = int64ToAuxInt(64)
23174 v2.AddArg(y)
23175 v0.AddArg3(y, v1, v2)
23176 v.AddArg2(x, v0)
23177 return true
23178 }
23179 return false
23180 }
23181 func rewriteValueARM64_OpRsh64x8(v *Value) bool {
23182 v_1 := v.Args[1]
23183 v_0 := v.Args[0]
23184 b := v.Block
23185 typ := &b.Func.Config.Types
23186
23187
23188
23189 for {
23190 t := v.Type
23191 x := v_0
23192 y := v_1
23193 if !(shiftIsBounded(v)) {
23194 break
23195 }
23196 v.reset(OpARM64SRA)
23197 v.Type = t
23198 v.AddArg2(x, y)
23199 return true
23200 }
23201
23202
23203
23204 for {
23205 t := v.Type
23206 bounded := auxIntToBool(v.AuxInt)
23207 x := v_0
23208 y := v_1
23209 if !(!shiftIsBounded(v)) {
23210 break
23211 }
23212 v.reset(OpRsh64x32)
23213 v.Type = t
23214 v.AuxInt = boolToAuxInt(bounded)
23215 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
23216 v0.AddArg(y)
23217 v.AddArg2(x, v0)
23218 return true
23219 }
23220 return false
23221 }
23222 func rewriteValueARM64_OpRsh8Ux16(v *Value) bool {
23223 v_1 := v.Args[1]
23224 v_0 := v.Args[0]
23225 b := v.Block
23226 typ := &b.Func.Config.Types
23227
23228
23229 for {
23230 t := v.Type
23231 bounded := auxIntToBool(v.AuxInt)
23232 x := v_0
23233 y := v_1
23234 v.reset(OpRsh64Ux16)
23235 v.Type = t
23236 v.AuxInt = boolToAuxInt(bounded)
23237 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
23238 v0.AddArg(x)
23239 v.AddArg2(v0, y)
23240 return true
23241 }
23242 }
23243 func rewriteValueARM64_OpRsh8Ux32(v *Value) bool {
23244 v_1 := v.Args[1]
23245 v_0 := v.Args[0]
23246 b := v.Block
23247 typ := &b.Func.Config.Types
23248
23249
23250 for {
23251 t := v.Type
23252 bounded := auxIntToBool(v.AuxInt)
23253 x := v_0
23254 y := v_1
23255 v.reset(OpRsh64Ux32)
23256 v.Type = t
23257 v.AuxInt = boolToAuxInt(bounded)
23258 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
23259 v0.AddArg(x)
23260 v.AddArg2(v0, y)
23261 return true
23262 }
23263 }
23264 func rewriteValueARM64_OpRsh8Ux64(v *Value) bool {
23265 v_1 := v.Args[1]
23266 v_0 := v.Args[0]
23267 b := v.Block
23268 typ := &b.Func.Config.Types
23269
23270
23271 for {
23272 t := v.Type
23273 bounded := auxIntToBool(v.AuxInt)
23274 x := v_0
23275 y := v_1
23276 v.reset(OpRsh64Ux64)
23277 v.Type = t
23278 v.AuxInt = boolToAuxInt(bounded)
23279 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
23280 v0.AddArg(x)
23281 v.AddArg2(v0, y)
23282 return true
23283 }
23284 }
23285 func rewriteValueARM64_OpRsh8Ux8(v *Value) bool {
23286 v_1 := v.Args[1]
23287 v_0 := v.Args[0]
23288 b := v.Block
23289 typ := &b.Func.Config.Types
23290
23291
23292 for {
23293 t := v.Type
23294 bounded := auxIntToBool(v.AuxInt)
23295 x := v_0
23296 y := v_1
23297 v.reset(OpRsh64Ux8)
23298 v.Type = t
23299 v.AuxInt = boolToAuxInt(bounded)
23300 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
23301 v0.AddArg(x)
23302 v.AddArg2(v0, y)
23303 return true
23304 }
23305 }
23306 func rewriteValueARM64_OpRsh8x16(v *Value) bool {
23307 v_1 := v.Args[1]
23308 v_0 := v.Args[0]
23309 b := v.Block
23310 typ := &b.Func.Config.Types
23311
23312
23313 for {
23314 t := v.Type
23315 bounded := auxIntToBool(v.AuxInt)
23316 x := v_0
23317 y := v_1
23318 v.reset(OpRsh64x16)
23319 v.Type = t
23320 v.AuxInt = boolToAuxInt(bounded)
23321 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
23322 v0.AddArg(x)
23323 v.AddArg2(v0, y)
23324 return true
23325 }
23326 }
23327 func rewriteValueARM64_OpRsh8x32(v *Value) bool {
23328 v_1 := v.Args[1]
23329 v_0 := v.Args[0]
23330 b := v.Block
23331 typ := &b.Func.Config.Types
23332
23333
23334 for {
23335 t := v.Type
23336 bounded := auxIntToBool(v.AuxInt)
23337 x := v_0
23338 y := v_1
23339 v.reset(OpRsh64x32)
23340 v.Type = t
23341 v.AuxInt = boolToAuxInt(bounded)
23342 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
23343 v0.AddArg(x)
23344 v.AddArg2(v0, y)
23345 return true
23346 }
23347 }
23348 func rewriteValueARM64_OpRsh8x64(v *Value) bool {
23349 v_1 := v.Args[1]
23350 v_0 := v.Args[0]
23351 b := v.Block
23352 typ := &b.Func.Config.Types
23353
23354
23355 for {
23356 t := v.Type
23357 bounded := auxIntToBool(v.AuxInt)
23358 x := v_0
23359 y := v_1
23360 v.reset(OpRsh64x64)
23361 v.Type = t
23362 v.AuxInt = boolToAuxInt(bounded)
23363 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
23364 v0.AddArg(x)
23365 v.AddArg2(v0, y)
23366 return true
23367 }
23368 }
23369 func rewriteValueARM64_OpRsh8x8(v *Value) bool {
23370 v_1 := v.Args[1]
23371 v_0 := v.Args[0]
23372 b := v.Block
23373 typ := &b.Func.Config.Types
23374
23375
23376 for {
23377 t := v.Type
23378 bounded := auxIntToBool(v.AuxInt)
23379 x := v_0
23380 y := v_1
23381 v.reset(OpRsh64x8)
23382 v.Type = t
23383 v.AuxInt = boolToAuxInt(bounded)
23384 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
23385 v0.AddArg(x)
23386 v.AddArg2(v0, y)
23387 return true
23388 }
23389 }
23390 func rewriteValueARM64_OpScalableVectorLen(v *Value) bool {
23391
23392
23393 for {
23394 v.reset(OpARM64RDVL)
23395 v.AuxInt = int64ToAuxInt(1)
23396 return true
23397 }
23398 }
23399 func rewriteValueARM64_OpSelect0(v *Value) bool {
23400 v_0 := v.Args[0]
23401 b := v.Block
23402 typ := &b.Func.Config.Types
23403
23404
23405 for {
23406 if v_0.Op != OpMul64uhilo {
23407 break
23408 }
23409 y := v_0.Args[1]
23410 x := v_0.Args[0]
23411 v.reset(OpARM64UMULH)
23412 v.AddArg2(x, y)
23413 return true
23414 }
23415
23416
23417 for {
23418 if v_0.Op != OpAdd64carry {
23419 break
23420 }
23421 c := v_0.Args[2]
23422 x := v_0.Args[0]
23423 y := v_0.Args[1]
23424 v.reset(OpSelect0)
23425 v.Type = typ.UInt64
23426 v0 := b.NewValue0(v.Pos, OpARM64ADCSflags, types.NewTuple(typ.UInt64, types.TypeFlags))
23427 v1 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
23428 v2 := b.NewValue0(v.Pos, OpARM64ADDSconstflags, types.NewTuple(typ.UInt64, types.TypeFlags))
23429 v2.AuxInt = int64ToAuxInt(-1)
23430 v2.AddArg(c)
23431 v1.AddArg(v2)
23432 v0.AddArg3(x, y, v1)
23433 v.AddArg(v0)
23434 return true
23435 }
23436
23437
23438 for {
23439 if v_0.Op != OpSub64borrow {
23440 break
23441 }
23442 bo := v_0.Args[2]
23443 x := v_0.Args[0]
23444 y := v_0.Args[1]
23445 v.reset(OpSelect0)
23446 v.Type = typ.UInt64
23447 v0 := b.NewValue0(v.Pos, OpARM64SBCSflags, types.NewTuple(typ.UInt64, types.TypeFlags))
23448 v1 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
23449 v2 := b.NewValue0(v.Pos, OpARM64NEGSflags, types.NewTuple(typ.UInt64, types.TypeFlags))
23450 v2.AddArg(bo)
23451 v1.AddArg(v2)
23452 v0.AddArg3(x, y, v1)
23453 v.AddArg(v0)
23454 return true
23455 }
23456
23457
23458 for {
23459 if v_0.Op != OpMul64uover {
23460 break
23461 }
23462 y := v_0.Args[1]
23463 x := v_0.Args[0]
23464 v.reset(OpARM64MUL)
23465 v.AddArg2(x, y)
23466 return true
23467 }
23468 return false
23469 }
23470 func rewriteValueARM64_OpSelect1(v *Value) bool {
23471 v_0 := v.Args[0]
23472 b := v.Block
23473 typ := &b.Func.Config.Types
23474
23475
23476 for {
23477 if v_0.Op != OpMul64uhilo {
23478 break
23479 }
23480 y := v_0.Args[1]
23481 x := v_0.Args[0]
23482 v.reset(OpARM64MUL)
23483 v.AddArg2(x, y)
23484 return true
23485 }
23486
23487
23488 for {
23489 if v_0.Op != OpAdd64carry {
23490 break
23491 }
23492 c := v_0.Args[2]
23493 x := v_0.Args[0]
23494 y := v_0.Args[1]
23495 v.reset(OpARM64ADCzerocarry)
23496 v.Type = typ.UInt64
23497 v0 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
23498 v1 := b.NewValue0(v.Pos, OpARM64ADCSflags, types.NewTuple(typ.UInt64, types.TypeFlags))
23499 v2 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
23500 v3 := b.NewValue0(v.Pos, OpARM64ADDSconstflags, types.NewTuple(typ.UInt64, types.TypeFlags))
23501 v3.AuxInt = int64ToAuxInt(-1)
23502 v3.AddArg(c)
23503 v2.AddArg(v3)
23504 v1.AddArg3(x, y, v2)
23505 v0.AddArg(v1)
23506 v.AddArg(v0)
23507 return true
23508 }
23509
23510
23511 for {
23512 if v_0.Op != OpSub64borrow {
23513 break
23514 }
23515 bo := v_0.Args[2]
23516 x := v_0.Args[0]
23517 y := v_0.Args[1]
23518 v.reset(OpARM64NEG)
23519 v.Type = typ.UInt64
23520 v0 := b.NewValue0(v.Pos, OpARM64NGCzerocarry, typ.UInt64)
23521 v1 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
23522 v2 := b.NewValue0(v.Pos, OpARM64SBCSflags, types.NewTuple(typ.UInt64, types.TypeFlags))
23523 v3 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
23524 v4 := b.NewValue0(v.Pos, OpARM64NEGSflags, types.NewTuple(typ.UInt64, types.TypeFlags))
23525 v4.AddArg(bo)
23526 v3.AddArg(v4)
23527 v2.AddArg3(x, y, v3)
23528 v1.AddArg(v2)
23529 v0.AddArg(v1)
23530 v.AddArg(v0)
23531 return true
23532 }
23533
23534
23535 for {
23536 if v_0.Op != OpMul64uover {
23537 break
23538 }
23539 y := v_0.Args[1]
23540 x := v_0.Args[0]
23541 v.reset(OpARM64NotEqual)
23542 v0 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23543 v0.AuxInt = int64ToAuxInt(0)
23544 v1 := b.NewValue0(v.Pos, OpARM64UMULH, typ.UInt64)
23545 v1.AddArg2(x, y)
23546 v0.AddArg(v1)
23547 v.AddArg(v0)
23548 return true
23549 }
23550 return false
23551 }
23552 func rewriteValueARM64_OpSelectN(v *Value) bool {
23553 v_0 := v.Args[0]
23554 b := v.Block
23555 config := b.Func.Config
23556
23557
23558
23559 for {
23560 if auxIntToInt64(v.AuxInt) != 0 {
23561 break
23562 }
23563 call := v_0
23564 if call.Op != OpARM64CALLstatic || len(call.Args) != 1 {
23565 break
23566 }
23567 sym := auxToCall(call.Aux)
23568 s1 := call.Args[0]
23569 if s1.Op != OpARM64MOVDstore {
23570 break
23571 }
23572 _ = s1.Args[2]
23573 s1_1 := s1.Args[1]
23574 if s1_1.Op != OpARM64MOVDconst {
23575 break
23576 }
23577 sz := auxIntToInt64(s1_1.AuxInt)
23578 s2 := s1.Args[2]
23579 if s2.Op != OpARM64MOVDstore {
23580 break
23581 }
23582 _ = s2.Args[2]
23583 src := s2.Args[1]
23584 s3 := s2.Args[2]
23585 if s3.Op != OpARM64MOVDstore {
23586 break
23587 }
23588 mem := s3.Args[2]
23589 dst := s3.Args[1]
23590 if !(sz >= 0 && isSameCall(sym, "runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, sz, config) && clobber(s1, s2, s3, call)) {
23591 break
23592 }
23593 v.reset(OpMove)
23594 v.AuxInt = int64ToAuxInt(sz)
23595 v.AddArg3(dst, src, mem)
23596 return true
23597 }
23598
23599
23600
23601 for {
23602 if auxIntToInt64(v.AuxInt) != 0 {
23603 break
23604 }
23605 call := v_0
23606 if call.Op != OpARM64CALLstatic || len(call.Args) != 4 {
23607 break
23608 }
23609 sym := auxToCall(call.Aux)
23610 mem := call.Args[3]
23611 dst := call.Args[0]
23612 src := call.Args[1]
23613 call_2 := call.Args[2]
23614 if call_2.Op != OpARM64MOVDconst {
23615 break
23616 }
23617 sz := auxIntToInt64(call_2.AuxInt)
23618 if !(sz >= 0 && isSameCall(sym, "runtime.memmove") && call.Uses == 1 && isInlinableMemmove(dst, src, sz, config) && clobber(call)) {
23619 break
23620 }
23621 v.reset(OpMove)
23622 v.AuxInt = int64ToAuxInt(sz)
23623 v.AddArg3(dst, src, mem)
23624 return true
23625 }
23626 return false
23627 }
23628 func rewriteValueARM64_OpShiftAllLeftInt16x8(v *Value) bool {
23629 v_1 := v.Args[1]
23630 v_0 := v.Args[0]
23631 b := v.Block
23632 typ := &b.Func.Config.Types
23633
23634
23635 for {
23636 x := v_0
23637 y := v_1
23638 v.reset(OpARM64VSSHL8H)
23639 v0 := b.NewValue0(v.Pos, OpARM64VDUPHbcast, typ.Vec128)
23640 v0.AuxInt = uint8ToAuxInt(0)
23641 v1 := b.NewValue0(v.Pos, OpARM64VMOVHins, typ.Vec128)
23642 v1.AuxInt = uint8ToAuxInt(0)
23643 v2 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23644 v2.AuxInt = opToAuxInt(OpARM64LessThanU)
23645 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23646 v3.AuxInt = int64ToAuxInt(127)
23647 v4 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23648 v4.AuxInt = int64ToAuxInt(127)
23649 v4.AddArg(y)
23650 v2.AddArg3(y, v3, v4)
23651 v1.AddArg2(x, v2)
23652 v0.AddArg(v1)
23653 v.AddArg2(x, v0)
23654 return true
23655 }
23656 }
23657 func rewriteValueARM64_OpShiftAllLeftInt32x4(v *Value) bool {
23658 v_1 := v.Args[1]
23659 v_0 := v.Args[0]
23660 b := v.Block
23661 typ := &b.Func.Config.Types
23662
23663
23664 for {
23665 x := v_0
23666 y := v_1
23667 v.reset(OpARM64VSSHL4S)
23668 v0 := b.NewValue0(v.Pos, OpARM64VDUPSbcast, typ.Vec128)
23669 v0.AuxInt = uint8ToAuxInt(0)
23670 v1 := b.NewValue0(v.Pos, OpARM64VMOVSins, typ.Vec128)
23671 v1.AuxInt = uint8ToAuxInt(0)
23672 v2 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23673 v2.AuxInt = opToAuxInt(OpARM64LessThanU)
23674 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23675 v3.AuxInt = int64ToAuxInt(127)
23676 v4 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23677 v4.AuxInt = int64ToAuxInt(127)
23678 v4.AddArg(y)
23679 v2.AddArg3(y, v3, v4)
23680 v1.AddArg2(x, v2)
23681 v0.AddArg(v1)
23682 v.AddArg2(x, v0)
23683 return true
23684 }
23685 }
23686 func rewriteValueARM64_OpShiftAllLeftInt64x2(v *Value) bool {
23687 v_1 := v.Args[1]
23688 v_0 := v.Args[0]
23689 b := v.Block
23690 typ := &b.Func.Config.Types
23691
23692
23693 for {
23694 x := v_0
23695 y := v_1
23696 v.reset(OpARM64VSSHL2D)
23697 v0 := b.NewValue0(v.Pos, OpARM64VDUPDbcast, typ.Vec128)
23698 v0.AuxInt = uint8ToAuxInt(0)
23699 v1 := b.NewValue0(v.Pos, OpARM64VMOVDins, typ.Vec128)
23700 v1.AuxInt = uint8ToAuxInt(0)
23701 v2 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23702 v2.AuxInt = opToAuxInt(OpARM64LessThanU)
23703 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23704 v3.AuxInt = int64ToAuxInt(127)
23705 v4 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23706 v4.AuxInt = int64ToAuxInt(127)
23707 v4.AddArg(y)
23708 v2.AddArg3(y, v3, v4)
23709 v1.AddArg2(x, v2)
23710 v0.AddArg(v1)
23711 v.AddArg2(x, v0)
23712 return true
23713 }
23714 }
23715 func rewriteValueARM64_OpShiftAllLeftInt8x16(v *Value) bool {
23716 v_1 := v.Args[1]
23717 v_0 := v.Args[0]
23718 b := v.Block
23719 typ := &b.Func.Config.Types
23720
23721
23722 for {
23723 x := v_0
23724 y := v_1
23725 v.reset(OpARM64VSSHL16B)
23726 v0 := b.NewValue0(v.Pos, OpARM64VDUPBbcast, typ.Vec128)
23727 v0.AuxInt = uint8ToAuxInt(0)
23728 v1 := b.NewValue0(v.Pos, OpARM64VMOVBins, typ.Vec128)
23729 v1.AuxInt = uint8ToAuxInt(0)
23730 v2 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23731 v2.AuxInt = opToAuxInt(OpARM64LessThanU)
23732 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23733 v3.AuxInt = int64ToAuxInt(127)
23734 v4 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23735 v4.AuxInt = int64ToAuxInt(127)
23736 v4.AddArg(y)
23737 v2.AddArg3(y, v3, v4)
23738 v1.AddArg2(x, v2)
23739 v0.AddArg(v1)
23740 v.AddArg2(x, v0)
23741 return true
23742 }
23743 }
23744 func rewriteValueARM64_OpShiftAllLeftUint16x8(v *Value) bool {
23745 v_1 := v.Args[1]
23746 v_0 := v.Args[0]
23747 b := v.Block
23748 typ := &b.Func.Config.Types
23749
23750
23751 for {
23752 x := v_0
23753 y := v_1
23754 v.reset(OpARM64VUSHL8H)
23755 v0 := b.NewValue0(v.Pos, OpARM64VDUPHbcast, typ.Vec128)
23756 v0.AuxInt = uint8ToAuxInt(0)
23757 v1 := b.NewValue0(v.Pos, OpARM64VMOVHins, typ.Vec128)
23758 v1.AuxInt = uint8ToAuxInt(0)
23759 v2 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23760 v2.AuxInt = opToAuxInt(OpARM64LessThanU)
23761 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23762 v3.AuxInt = int64ToAuxInt(127)
23763 v4 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23764 v4.AuxInt = int64ToAuxInt(127)
23765 v4.AddArg(y)
23766 v2.AddArg3(y, v3, v4)
23767 v1.AddArg2(x, v2)
23768 v0.AddArg(v1)
23769 v.AddArg2(x, v0)
23770 return true
23771 }
23772 }
23773 func rewriteValueARM64_OpShiftAllLeftUint32x4(v *Value) bool {
23774 v_1 := v.Args[1]
23775 v_0 := v.Args[0]
23776 b := v.Block
23777 typ := &b.Func.Config.Types
23778
23779
23780 for {
23781 x := v_0
23782 y := v_1
23783 v.reset(OpARM64VUSHL4S)
23784 v0 := b.NewValue0(v.Pos, OpARM64VDUPSbcast, typ.Vec128)
23785 v0.AuxInt = uint8ToAuxInt(0)
23786 v1 := b.NewValue0(v.Pos, OpARM64VMOVSins, typ.Vec128)
23787 v1.AuxInt = uint8ToAuxInt(0)
23788 v2 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23789 v2.AuxInt = opToAuxInt(OpARM64LessThanU)
23790 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23791 v3.AuxInt = int64ToAuxInt(127)
23792 v4 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23793 v4.AuxInt = int64ToAuxInt(127)
23794 v4.AddArg(y)
23795 v2.AddArg3(y, v3, v4)
23796 v1.AddArg2(x, v2)
23797 v0.AddArg(v1)
23798 v.AddArg2(x, v0)
23799 return true
23800 }
23801 }
23802 func rewriteValueARM64_OpShiftAllLeftUint64x2(v *Value) bool {
23803 v_1 := v.Args[1]
23804 v_0 := v.Args[0]
23805 b := v.Block
23806 typ := &b.Func.Config.Types
23807
23808
23809 for {
23810 x := v_0
23811 y := v_1
23812 v.reset(OpARM64VUSHL2D)
23813 v0 := b.NewValue0(v.Pos, OpARM64VDUPDbcast, typ.Vec128)
23814 v0.AuxInt = uint8ToAuxInt(0)
23815 v1 := b.NewValue0(v.Pos, OpARM64VMOVDins, typ.Vec128)
23816 v1.AuxInt = uint8ToAuxInt(0)
23817 v2 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23818 v2.AuxInt = opToAuxInt(OpARM64LessThanU)
23819 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23820 v3.AuxInt = int64ToAuxInt(127)
23821 v4 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23822 v4.AuxInt = int64ToAuxInt(127)
23823 v4.AddArg(y)
23824 v2.AddArg3(y, v3, v4)
23825 v1.AddArg2(x, v2)
23826 v0.AddArg(v1)
23827 v.AddArg2(x, v0)
23828 return true
23829 }
23830 }
23831 func rewriteValueARM64_OpShiftAllLeftUint8x16(v *Value) bool {
23832 v_1 := v.Args[1]
23833 v_0 := v.Args[0]
23834 b := v.Block
23835 typ := &b.Func.Config.Types
23836
23837
23838 for {
23839 x := v_0
23840 y := v_1
23841 v.reset(OpARM64VUSHL16B)
23842 v0 := b.NewValue0(v.Pos, OpARM64VDUPBbcast, typ.Vec128)
23843 v0.AuxInt = uint8ToAuxInt(0)
23844 v1 := b.NewValue0(v.Pos, OpARM64VMOVBins, typ.Vec128)
23845 v1.AuxInt = uint8ToAuxInt(0)
23846 v2 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23847 v2.AuxInt = opToAuxInt(OpARM64LessThanU)
23848 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23849 v3.AuxInt = int64ToAuxInt(127)
23850 v4 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23851 v4.AuxInt = int64ToAuxInt(127)
23852 v4.AddArg(y)
23853 v2.AddArg3(y, v3, v4)
23854 v1.AddArg2(x, v2)
23855 v0.AddArg(v1)
23856 v.AddArg2(x, v0)
23857 return true
23858 }
23859 }
23860 func rewriteValueARM64_OpShiftAllRightInt16x8(v *Value) bool {
23861 v_1 := v.Args[1]
23862 v_0 := v.Args[0]
23863 b := v.Block
23864 typ := &b.Func.Config.Types
23865
23866
23867 for {
23868 x := v_0
23869 y := v_1
23870 v.reset(OpARM64VSSHL8H)
23871 v0 := b.NewValue0(v.Pos, OpARM64VDUPHbcast, typ.Vec128)
23872 v0.AuxInt = uint8ToAuxInt(0)
23873 v1 := b.NewValue0(v.Pos, OpARM64VMOVHins, typ.Vec128)
23874 v1.AuxInt = uint8ToAuxInt(0)
23875 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
23876 v3 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23877 v3.AuxInt = opToAuxInt(OpARM64LessThanU)
23878 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23879 v4.AuxInt = int64ToAuxInt(127)
23880 v5 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23881 v5.AuxInt = int64ToAuxInt(127)
23882 v5.AddArg(y)
23883 v3.AddArg3(y, v4, v5)
23884 v2.AddArg(v3)
23885 v1.AddArg2(x, v2)
23886 v0.AddArg(v1)
23887 v.AddArg2(x, v0)
23888 return true
23889 }
23890 }
23891 func rewriteValueARM64_OpShiftAllRightInt32x4(v *Value) bool {
23892 v_1 := v.Args[1]
23893 v_0 := v.Args[0]
23894 b := v.Block
23895 typ := &b.Func.Config.Types
23896
23897
23898 for {
23899 x := v_0
23900 y := v_1
23901 v.reset(OpARM64VSSHL4S)
23902 v0 := b.NewValue0(v.Pos, OpARM64VDUPSbcast, typ.Vec128)
23903 v0.AuxInt = uint8ToAuxInt(0)
23904 v1 := b.NewValue0(v.Pos, OpARM64VMOVSins, typ.Vec128)
23905 v1.AuxInt = uint8ToAuxInt(0)
23906 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
23907 v3 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23908 v3.AuxInt = opToAuxInt(OpARM64LessThanU)
23909 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23910 v4.AuxInt = int64ToAuxInt(127)
23911 v5 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23912 v5.AuxInt = int64ToAuxInt(127)
23913 v5.AddArg(y)
23914 v3.AddArg3(y, v4, v5)
23915 v2.AddArg(v3)
23916 v1.AddArg2(x, v2)
23917 v0.AddArg(v1)
23918 v.AddArg2(x, v0)
23919 return true
23920 }
23921 }
23922 func rewriteValueARM64_OpShiftAllRightInt64x2(v *Value) bool {
23923 v_1 := v.Args[1]
23924 v_0 := v.Args[0]
23925 b := v.Block
23926 typ := &b.Func.Config.Types
23927
23928
23929 for {
23930 x := v_0
23931 y := v_1
23932 v.reset(OpARM64VSSHL2D)
23933 v0 := b.NewValue0(v.Pos, OpARM64VDUPDbcast, typ.Vec128)
23934 v0.AuxInt = uint8ToAuxInt(0)
23935 v1 := b.NewValue0(v.Pos, OpARM64VMOVDins, typ.Vec128)
23936 v1.AuxInt = uint8ToAuxInt(0)
23937 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
23938 v3 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23939 v3.AuxInt = opToAuxInt(OpARM64LessThanU)
23940 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23941 v4.AuxInt = int64ToAuxInt(127)
23942 v5 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23943 v5.AuxInt = int64ToAuxInt(127)
23944 v5.AddArg(y)
23945 v3.AddArg3(y, v4, v5)
23946 v2.AddArg(v3)
23947 v1.AddArg2(x, v2)
23948 v0.AddArg(v1)
23949 v.AddArg2(x, v0)
23950 return true
23951 }
23952 }
23953 func rewriteValueARM64_OpShiftAllRightInt8x16(v *Value) bool {
23954 v_1 := v.Args[1]
23955 v_0 := v.Args[0]
23956 b := v.Block
23957 typ := &b.Func.Config.Types
23958
23959
23960 for {
23961 x := v_0
23962 y := v_1
23963 v.reset(OpARM64VSSHL16B)
23964 v0 := b.NewValue0(v.Pos, OpARM64VDUPBbcast, typ.Vec128)
23965 v0.AuxInt = uint8ToAuxInt(0)
23966 v1 := b.NewValue0(v.Pos, OpARM64VMOVBins, typ.Vec128)
23967 v1.AuxInt = uint8ToAuxInt(0)
23968 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
23969 v3 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23970 v3.AuxInt = opToAuxInt(OpARM64LessThanU)
23971 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23972 v4.AuxInt = int64ToAuxInt(127)
23973 v5 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23974 v5.AuxInt = int64ToAuxInt(127)
23975 v5.AddArg(y)
23976 v3.AddArg3(y, v4, v5)
23977 v2.AddArg(v3)
23978 v1.AddArg2(x, v2)
23979 v0.AddArg(v1)
23980 v.AddArg2(x, v0)
23981 return true
23982 }
23983 }
23984 func rewriteValueARM64_OpShiftAllRightUint16x8(v *Value) bool {
23985 v_1 := v.Args[1]
23986 v_0 := v.Args[0]
23987 b := v.Block
23988 typ := &b.Func.Config.Types
23989
23990
23991 for {
23992 x := v_0
23993 y := v_1
23994 v.reset(OpARM64VUSHL8H)
23995 v0 := b.NewValue0(v.Pos, OpARM64VDUPHbcast, typ.Vec128)
23996 v0.AuxInt = uint8ToAuxInt(0)
23997 v1 := b.NewValue0(v.Pos, OpARM64VMOVHins, typ.Vec128)
23998 v1.AuxInt = uint8ToAuxInt(0)
23999 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
24000 v3 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
24001 v3.AuxInt = opToAuxInt(OpARM64LessThanU)
24002 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24003 v4.AuxInt = int64ToAuxInt(127)
24004 v5 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
24005 v5.AuxInt = int64ToAuxInt(127)
24006 v5.AddArg(y)
24007 v3.AddArg3(y, v4, v5)
24008 v2.AddArg(v3)
24009 v1.AddArg2(x, v2)
24010 v0.AddArg(v1)
24011 v.AddArg2(x, v0)
24012 return true
24013 }
24014 }
24015 func rewriteValueARM64_OpShiftAllRightUint32x4(v *Value) bool {
24016 v_1 := v.Args[1]
24017 v_0 := v.Args[0]
24018 b := v.Block
24019 typ := &b.Func.Config.Types
24020
24021
24022 for {
24023 x := v_0
24024 y := v_1
24025 v.reset(OpARM64VUSHL4S)
24026 v0 := b.NewValue0(v.Pos, OpARM64VDUPSbcast, typ.Vec128)
24027 v0.AuxInt = uint8ToAuxInt(0)
24028 v1 := b.NewValue0(v.Pos, OpARM64VMOVSins, typ.Vec128)
24029 v1.AuxInt = uint8ToAuxInt(0)
24030 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
24031 v3 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
24032 v3.AuxInt = opToAuxInt(OpARM64LessThanU)
24033 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24034 v4.AuxInt = int64ToAuxInt(127)
24035 v5 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
24036 v5.AuxInt = int64ToAuxInt(127)
24037 v5.AddArg(y)
24038 v3.AddArg3(y, v4, v5)
24039 v2.AddArg(v3)
24040 v1.AddArg2(x, v2)
24041 v0.AddArg(v1)
24042 v.AddArg2(x, v0)
24043 return true
24044 }
24045 }
24046 func rewriteValueARM64_OpShiftAllRightUint64x2(v *Value) bool {
24047 v_1 := v.Args[1]
24048 v_0 := v.Args[0]
24049 b := v.Block
24050 typ := &b.Func.Config.Types
24051
24052
24053 for {
24054 x := v_0
24055 y := v_1
24056 v.reset(OpARM64VUSHL2D)
24057 v0 := b.NewValue0(v.Pos, OpARM64VDUPDbcast, typ.Vec128)
24058 v0.AuxInt = uint8ToAuxInt(0)
24059 v1 := b.NewValue0(v.Pos, OpARM64VMOVDins, typ.Vec128)
24060 v1.AuxInt = uint8ToAuxInt(0)
24061 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
24062 v3 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
24063 v3.AuxInt = opToAuxInt(OpARM64LessThanU)
24064 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24065 v4.AuxInt = int64ToAuxInt(127)
24066 v5 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
24067 v5.AuxInt = int64ToAuxInt(127)
24068 v5.AddArg(y)
24069 v3.AddArg3(y, v4, v5)
24070 v2.AddArg(v3)
24071 v1.AddArg2(x, v2)
24072 v0.AddArg(v1)
24073 v.AddArg2(x, v0)
24074 return true
24075 }
24076 }
24077 func rewriteValueARM64_OpShiftAllRightUint8x16(v *Value) bool {
24078 v_1 := v.Args[1]
24079 v_0 := v.Args[0]
24080 b := v.Block
24081 typ := &b.Func.Config.Types
24082
24083
24084 for {
24085 x := v_0
24086 y := v_1
24087 v.reset(OpARM64VUSHL16B)
24088 v0 := b.NewValue0(v.Pos, OpARM64VDUPBbcast, typ.Vec128)
24089 v0.AuxInt = uint8ToAuxInt(0)
24090 v1 := b.NewValue0(v.Pos, OpARM64VMOVBins, typ.Vec128)
24091 v1.AuxInt = uint8ToAuxInt(0)
24092 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
24093 v3 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
24094 v3.AuxInt = opToAuxInt(OpARM64LessThanU)
24095 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24096 v4.AuxInt = int64ToAuxInt(127)
24097 v5 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
24098 v5.AuxInt = int64ToAuxInt(127)
24099 v5.AddArg(y)
24100 v3.AddArg3(y, v4, v5)
24101 v2.AddArg(v3)
24102 v1.AddArg2(x, v2)
24103 v0.AddArg(v1)
24104 v.AddArg2(x, v0)
24105 return true
24106 }
24107 }
24108 func rewriteValueARM64_OpSlicemask(v *Value) bool {
24109 v_0 := v.Args[0]
24110 b := v.Block
24111
24112
24113 for {
24114 t := v.Type
24115 x := v_0
24116 v.reset(OpARM64SRAconst)
24117 v.AuxInt = int64ToAuxInt(63)
24118 v0 := b.NewValue0(v.Pos, OpARM64NEG, t)
24119 v0.AddArg(x)
24120 v.AddArg(v0)
24121 return true
24122 }
24123 }
24124 func rewriteValueARM64_OpStore(v *Value) bool {
24125 v_2 := v.Args[2]
24126 v_1 := v.Args[1]
24127 v_0 := v.Args[0]
24128
24129
24130
24131 for {
24132 t := auxToType(v.Aux)
24133 ptr := v_0
24134 val := v_1
24135 mem := v_2
24136 if !(t.Size() == 1) {
24137 break
24138 }
24139 v.reset(OpARM64MOVBstore)
24140 v.AddArg3(ptr, val, mem)
24141 return true
24142 }
24143
24144
24145
24146 for {
24147 t := auxToType(v.Aux)
24148 ptr := v_0
24149 val := v_1
24150 mem := v_2
24151 if !(t.Size() == 2) {
24152 break
24153 }
24154 v.reset(OpARM64MOVHstore)
24155 v.AddArg3(ptr, val, mem)
24156 return true
24157 }
24158
24159
24160
24161 for {
24162 t := auxToType(v.Aux)
24163 ptr := v_0
24164 val := v_1
24165 mem := v_2
24166 if !(t.Size() == 4 && !t.IsFloat()) {
24167 break
24168 }
24169 v.reset(OpARM64MOVWstore)
24170 v.AddArg3(ptr, val, mem)
24171 return true
24172 }
24173
24174
24175
24176 for {
24177 t := auxToType(v.Aux)
24178 ptr := v_0
24179 val := v_1
24180 mem := v_2
24181 if !(t.Size() == 8 && !t.IsFloat() && !t.IsSIMD()) {
24182 break
24183 }
24184 v.reset(OpARM64MOVDstore)
24185 v.AddArg3(ptr, val, mem)
24186 return true
24187 }
24188
24189
24190
24191 for {
24192 t := auxToType(v.Aux)
24193 ptr := v_0
24194 val := v_1
24195 mem := v_2
24196 if !(t.Size() == 4 && t.IsFloat()) {
24197 break
24198 }
24199 v.reset(OpARM64FMOVSstore)
24200 v.AddArg3(ptr, val, mem)
24201 return true
24202 }
24203
24204
24205
24206 for {
24207 t := auxToType(v.Aux)
24208 ptr := v_0
24209 val := v_1
24210 mem := v_2
24211 if !(t.Size() == 8 && t.IsFloat()) {
24212 break
24213 }
24214 v.reset(OpARM64FMOVDstore)
24215 v.AddArg3(ptr, val, mem)
24216 return true
24217 }
24218
24219
24220
24221 for {
24222 t := auxToType(v.Aux)
24223 ptr := v_0
24224 val := v_1
24225 mem := v_2
24226 if !(t.Size() == 16) {
24227 break
24228 }
24229 v.reset(OpARM64FMOVQstore)
24230 v.AddArg3(ptr, val, mem)
24231 return true
24232 }
24233
24234
24235
24236 for {
24237 t := auxToType(v.Aux)
24238 ptr := v_0
24239 val := v_1
24240 mem := v_2
24241 if !(t.Size() == 32 && t.IsSIMD()) {
24242 break
24243 }
24244 v.reset(OpARM64ZSTRstore)
24245 v.AddArg3(ptr, val, mem)
24246 return true
24247 }
24248
24249
24250
24251 for {
24252 t := auxToType(v.Aux)
24253 ptr := v_0
24254 val := v_1
24255 mem := v_2
24256 if !(t.Size() == 8 && t.IsSIMD()) {
24257 break
24258 }
24259 v.reset(OpARM64PSTRstore)
24260 v.AddArg3(ptr, val, mem)
24261 return true
24262 }
24263 return false
24264 }
24265 func rewriteValueARM64_OpStoreMasked8(v *Value) bool {
24266 v_3 := v.Args[3]
24267 v_2 := v.Args[2]
24268 v_1 := v.Args[1]
24269 v_0 := v.Args[0]
24270
24271
24272
24273 for {
24274 t := auxToType(v.Aux)
24275 ptr := v_0
24276 mask := v_1
24277 val := v_2
24278 mem := v_3
24279 if !(t.Size() == 32) {
24280 break
24281 }
24282 v.reset(OpARM64ZST1BPredstore)
24283 v.AddArg4(ptr, val, mask, mem)
24284 return true
24285 }
24286 return false
24287 }
24288 func rewriteValueARM64_OpZero(v *Value) bool {
24289 v_1 := v.Args[1]
24290 v_0 := v.Args[0]
24291 b := v.Block
24292 typ := &b.Func.Config.Types
24293
24294
24295 for {
24296 if auxIntToInt64(v.AuxInt) != 0 {
24297 break
24298 }
24299 mem := v_1
24300 v.copyOf(mem)
24301 return true
24302 }
24303
24304
24305 for {
24306 if auxIntToInt64(v.AuxInt) != 1 {
24307 break
24308 }
24309 ptr := v_0
24310 mem := v_1
24311 v.reset(OpARM64MOVBstore)
24312 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24313 v0.AuxInt = int64ToAuxInt(0)
24314 v.AddArg3(ptr, v0, mem)
24315 return true
24316 }
24317
24318
24319 for {
24320 if auxIntToInt64(v.AuxInt) != 2 {
24321 break
24322 }
24323 ptr := v_0
24324 mem := v_1
24325 v.reset(OpARM64MOVHstore)
24326 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24327 v0.AuxInt = int64ToAuxInt(0)
24328 v.AddArg3(ptr, v0, mem)
24329 return true
24330 }
24331
24332
24333 for {
24334 if auxIntToInt64(v.AuxInt) != 4 {
24335 break
24336 }
24337 ptr := v_0
24338 mem := v_1
24339 v.reset(OpARM64MOVWstore)
24340 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24341 v0.AuxInt = int64ToAuxInt(0)
24342 v.AddArg3(ptr, v0, mem)
24343 return true
24344 }
24345
24346
24347 for {
24348 if auxIntToInt64(v.AuxInt) != 3 {
24349 break
24350 }
24351 ptr := v_0
24352 mem := v_1
24353 v.reset(OpARM64MOVBstore)
24354 v.AuxInt = int32ToAuxInt(2)
24355 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24356 v0.AuxInt = int64ToAuxInt(0)
24357 v1 := b.NewValue0(v.Pos, OpARM64MOVHstore, types.TypeMem)
24358 v1.AddArg3(ptr, v0, mem)
24359 v.AddArg3(ptr, v0, v1)
24360 return true
24361 }
24362
24363
24364 for {
24365 if auxIntToInt64(v.AuxInt) != 5 {
24366 break
24367 }
24368 ptr := v_0
24369 mem := v_1
24370 v.reset(OpARM64MOVBstore)
24371 v.AuxInt = int32ToAuxInt(4)
24372 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24373 v0.AuxInt = int64ToAuxInt(0)
24374 v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, types.TypeMem)
24375 v1.AddArg3(ptr, v0, mem)
24376 v.AddArg3(ptr, v0, v1)
24377 return true
24378 }
24379
24380
24381 for {
24382 if auxIntToInt64(v.AuxInt) != 6 {
24383 break
24384 }
24385 ptr := v_0
24386 mem := v_1
24387 v.reset(OpARM64MOVHstore)
24388 v.AuxInt = int32ToAuxInt(4)
24389 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24390 v0.AuxInt = int64ToAuxInt(0)
24391 v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, types.TypeMem)
24392 v1.AddArg3(ptr, v0, mem)
24393 v.AddArg3(ptr, v0, v1)
24394 return true
24395 }
24396
24397
24398 for {
24399 if auxIntToInt64(v.AuxInt) != 7 {
24400 break
24401 }
24402 ptr := v_0
24403 mem := v_1
24404 v.reset(OpARM64MOVWstore)
24405 v.AuxInt = int32ToAuxInt(3)
24406 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24407 v0.AuxInt = int64ToAuxInt(0)
24408 v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, types.TypeMem)
24409 v1.AddArg3(ptr, v0, mem)
24410 v.AddArg3(ptr, v0, v1)
24411 return true
24412 }
24413
24414
24415 for {
24416 if auxIntToInt64(v.AuxInt) != 8 {
24417 break
24418 }
24419 ptr := v_0
24420 mem := v_1
24421 v.reset(OpARM64MOVDstore)
24422 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24423 v0.AuxInt = int64ToAuxInt(0)
24424 v.AddArg3(ptr, v0, mem)
24425 return true
24426 }
24427
24428
24429 for {
24430 if auxIntToInt64(v.AuxInt) != 9 {
24431 break
24432 }
24433 ptr := v_0
24434 mem := v_1
24435 v.reset(OpARM64MOVBstore)
24436 v.AuxInt = int32ToAuxInt(8)
24437 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24438 v0.AuxInt = int64ToAuxInt(0)
24439 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
24440 v1.AddArg3(ptr, v0, mem)
24441 v.AddArg3(ptr, v0, v1)
24442 return true
24443 }
24444
24445
24446 for {
24447 if auxIntToInt64(v.AuxInt) != 10 {
24448 break
24449 }
24450 ptr := v_0
24451 mem := v_1
24452 v.reset(OpARM64MOVHstore)
24453 v.AuxInt = int32ToAuxInt(8)
24454 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24455 v0.AuxInt = int64ToAuxInt(0)
24456 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
24457 v1.AddArg3(ptr, v0, mem)
24458 v.AddArg3(ptr, v0, v1)
24459 return true
24460 }
24461
24462
24463 for {
24464 if auxIntToInt64(v.AuxInt) != 11 {
24465 break
24466 }
24467 ptr := v_0
24468 mem := v_1
24469 v.reset(OpARM64MOVDstore)
24470 v.AuxInt = int32ToAuxInt(3)
24471 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24472 v0.AuxInt = int64ToAuxInt(0)
24473 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
24474 v1.AddArg3(ptr, v0, mem)
24475 v.AddArg3(ptr, v0, v1)
24476 return true
24477 }
24478
24479
24480 for {
24481 if auxIntToInt64(v.AuxInt) != 12 {
24482 break
24483 }
24484 ptr := v_0
24485 mem := v_1
24486 v.reset(OpARM64MOVWstore)
24487 v.AuxInt = int32ToAuxInt(8)
24488 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24489 v0.AuxInt = int64ToAuxInt(0)
24490 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
24491 v1.AddArg3(ptr, v0, mem)
24492 v.AddArg3(ptr, v0, v1)
24493 return true
24494 }
24495
24496
24497 for {
24498 if auxIntToInt64(v.AuxInt) != 13 {
24499 break
24500 }
24501 ptr := v_0
24502 mem := v_1
24503 v.reset(OpARM64MOVDstore)
24504 v.AuxInt = int32ToAuxInt(5)
24505 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24506 v0.AuxInt = int64ToAuxInt(0)
24507 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
24508 v1.AddArg3(ptr, v0, mem)
24509 v.AddArg3(ptr, v0, v1)
24510 return true
24511 }
24512
24513
24514 for {
24515 if auxIntToInt64(v.AuxInt) != 14 {
24516 break
24517 }
24518 ptr := v_0
24519 mem := v_1
24520 v.reset(OpARM64MOVDstore)
24521 v.AuxInt = int32ToAuxInt(6)
24522 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24523 v0.AuxInt = int64ToAuxInt(0)
24524 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
24525 v1.AddArg3(ptr, v0, mem)
24526 v.AddArg3(ptr, v0, v1)
24527 return true
24528 }
24529
24530
24531 for {
24532 if auxIntToInt64(v.AuxInt) != 15 {
24533 break
24534 }
24535 ptr := v_0
24536 mem := v_1
24537 v.reset(OpARM64MOVDstore)
24538 v.AuxInt = int32ToAuxInt(7)
24539 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24540 v0.AuxInt = int64ToAuxInt(0)
24541 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
24542 v1.AddArg3(ptr, v0, mem)
24543 v.AddArg3(ptr, v0, v1)
24544 return true
24545 }
24546
24547
24548 for {
24549 if auxIntToInt64(v.AuxInt) != 16 {
24550 break
24551 }
24552 ptr := v_0
24553 mem := v_1
24554 v.reset(OpARM64STP)
24555 v.AuxInt = int32ToAuxInt(0)
24556 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24557 v0.AuxInt = int64ToAuxInt(0)
24558 v.AddArg4(ptr, v0, v0, mem)
24559 return true
24560 }
24561
24562
24563
24564 for {
24565 s := auxIntToInt64(v.AuxInt)
24566 ptr := v_0
24567 mem := v_1
24568 if !(s > 16 && s < 192) {
24569 break
24570 }
24571 v.reset(OpARM64LoweredZero)
24572 v.AuxInt = int64ToAuxInt(s)
24573 v.AddArg2(ptr, mem)
24574 return true
24575 }
24576
24577
24578
24579 for {
24580 s := auxIntToInt64(v.AuxInt)
24581 ptr := v_0
24582 mem := v_1
24583 if !(s >= 192) {
24584 break
24585 }
24586 v.reset(OpARM64LoweredZeroLoop)
24587 v.AuxInt = int64ToAuxInt(s)
24588 v.AddArg2(ptr, mem)
24589 return true
24590 }
24591 return false
24592 }
24593 func rewriteValueARM64_OpZeroSIMD(v *Value) bool {
24594
24595
24596
24597 for {
24598 t := v.Type
24599 if !(t.Size() == 16) {
24600 break
24601 }
24602 v.reset(OpARM64VMOVI16B)
24603 v.Type = t
24604 v.AuxInt = uint8ToAuxInt(0)
24605 return true
24606 }
24607
24608
24609
24610 for {
24611 t := v.Type
24612 if !(t.Size() == 8 && t.IsSIMD()) {
24613 break
24614 }
24615 v.reset(OpARM64PPFALSE)
24616 return true
24617 }
24618
24619
24620
24621 for {
24622 t := v.Type
24623 if !(t.Size() == 32 && t.IsSIMD()) {
24624 break
24625 }
24626 v.reset(OpARM64ZDUPBconst)
24627 v.AuxInt = int8ToAuxInt(0)
24628 return true
24629 }
24630 return false
24631 }
24632 func rewriteValueARM64_Opbroadcast1To16Int8x16(v *Value) bool {
24633 v_0 := v.Args[0]
24634
24635
24636 for {
24637 x := v_0
24638 v.reset(OpARM64VDUPBbcast)
24639 v.AuxInt = uint8ToAuxInt(0)
24640 v.AddArg(x)
24641 return true
24642 }
24643 }
24644 func rewriteValueARM64_Opbroadcast1To16Uint8x16(v *Value) bool {
24645 v_0 := v.Args[0]
24646
24647
24648 for {
24649 x := v_0
24650 v.reset(OpARM64VDUPBbcast)
24651 v.AuxInt = uint8ToAuxInt(0)
24652 v.AddArg(x)
24653 return true
24654 }
24655 }
24656 func rewriteValueARM64_Opbroadcast1To2Float64x2(v *Value) bool {
24657 v_0 := v.Args[0]
24658
24659
24660 for {
24661 x := v_0
24662 v.reset(OpARM64VDUPDbcast)
24663 v.AuxInt = uint8ToAuxInt(0)
24664 v.AddArg(x)
24665 return true
24666 }
24667 }
24668 func rewriteValueARM64_Opbroadcast1To2Int64x2(v *Value) bool {
24669 v_0 := v.Args[0]
24670
24671
24672 for {
24673 x := v_0
24674 v.reset(OpARM64VDUPDbcast)
24675 v.AuxInt = uint8ToAuxInt(0)
24676 v.AddArg(x)
24677 return true
24678 }
24679 }
24680 func rewriteValueARM64_Opbroadcast1To2Uint64x2(v *Value) bool {
24681 v_0 := v.Args[0]
24682
24683
24684 for {
24685 x := v_0
24686 v.reset(OpARM64VDUPDbcast)
24687 v.AuxInt = uint8ToAuxInt(0)
24688 v.AddArg(x)
24689 return true
24690 }
24691 }
24692 func rewriteValueARM64_Opbroadcast1To4Float32x4(v *Value) bool {
24693 v_0 := v.Args[0]
24694
24695
24696 for {
24697 x := v_0
24698 v.reset(OpARM64VDUPSbcast)
24699 v.AuxInt = uint8ToAuxInt(0)
24700 v.AddArg(x)
24701 return true
24702 }
24703 }
24704 func rewriteValueARM64_Opbroadcast1To4Int32x4(v *Value) bool {
24705 v_0 := v.Args[0]
24706
24707
24708 for {
24709 x := v_0
24710 v.reset(OpARM64VDUPSbcast)
24711 v.AuxInt = uint8ToAuxInt(0)
24712 v.AddArg(x)
24713 return true
24714 }
24715 }
24716 func rewriteValueARM64_Opbroadcast1To4Uint32x4(v *Value) bool {
24717 v_0 := v.Args[0]
24718
24719
24720 for {
24721 x := v_0
24722 v.reset(OpARM64VDUPSbcast)
24723 v.AuxInt = uint8ToAuxInt(0)
24724 v.AddArg(x)
24725 return true
24726 }
24727 }
24728 func rewriteValueARM64_Opbroadcast1To8Int16x8(v *Value) bool {
24729 v_0 := v.Args[0]
24730
24731
24732 for {
24733 x := v_0
24734 v.reset(OpARM64VDUPHbcast)
24735 v.AuxInt = uint8ToAuxInt(0)
24736 v.AddArg(x)
24737 return true
24738 }
24739 }
24740 func rewriteValueARM64_Opbroadcast1To8Uint16x8(v *Value) bool {
24741 v_0 := v.Args[0]
24742
24743
24744 for {
24745 x := v_0
24746 v.reset(OpARM64VDUPHbcast)
24747 v.AuxInt = uint8ToAuxInt(0)
24748 v.AddArg(x)
24749 return true
24750 }
24751 }
24752 func rewriteBlockARM64(b *Block) bool {
24753 typ := &b.Func.Config.Types
24754 switch b.Kind {
24755 case block.BlockARM64EQ:
24756
24757
24758
24759 for b.Controls[0].Op == OpARM64CMPconst {
24760 v_0 := b.Controls[0]
24761 if auxIntToInt64(v_0.AuxInt) != 0 {
24762 break
24763 }
24764 z := v_0.Args[0]
24765 if z.Op != OpARM64AND {
24766 break
24767 }
24768 _ = z.Args[1]
24769 z_0 := z.Args[0]
24770 z_1 := z.Args[1]
24771 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
24772 x := z_0
24773 y := z_1
24774 if !(z.Uses == 1) {
24775 continue
24776 }
24777 v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
24778 v0.AddArg2(x, y)
24779 b.resetWithControl(block.BlockARM64EQ, v0)
24780 return true
24781 }
24782 break
24783 }
24784
24785
24786
24787 for b.Controls[0].Op == OpARM64CMPconst {
24788 v_0 := b.Controls[0]
24789 if auxIntToInt64(v_0.AuxInt) != 0 {
24790 break
24791 }
24792 x := v_0.Args[0]
24793 if x.Op != OpARM64ANDconst {
24794 break
24795 }
24796 c := auxIntToInt64(x.AuxInt)
24797 y := x.Args[0]
24798 if !(x.Uses == 1) {
24799 break
24800 }
24801 v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
24802 v0.AuxInt = int64ToAuxInt(c)
24803 v0.AddArg(y)
24804 b.resetWithControl(block.BlockARM64EQ, v0)
24805 return true
24806 }
24807
24808
24809
24810 for b.Controls[0].Op == OpARM64CMPWconst {
24811 v_0 := b.Controls[0]
24812 if auxIntToInt32(v_0.AuxInt) != 0 {
24813 break
24814 }
24815 z := v_0.Args[0]
24816 if z.Op != OpARM64AND {
24817 break
24818 }
24819 _ = z.Args[1]
24820 z_0 := z.Args[0]
24821 z_1 := z.Args[1]
24822 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
24823 x := z_0
24824 y := z_1
24825 if !(z.Uses == 1) {
24826 continue
24827 }
24828 v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
24829 v0.AddArg2(x, y)
24830 b.resetWithControl(block.BlockARM64EQ, v0)
24831 return true
24832 }
24833 break
24834 }
24835
24836
24837
24838 for b.Controls[0].Op == OpARM64CMPWconst {
24839 v_0 := b.Controls[0]
24840 if auxIntToInt32(v_0.AuxInt) != 0 {
24841 break
24842 }
24843 x := v_0.Args[0]
24844 if x.Op != OpARM64ANDconst {
24845 break
24846 }
24847 c := auxIntToInt64(x.AuxInt)
24848 y := x.Args[0]
24849 if !(x.Uses == 1) {
24850 break
24851 }
24852 v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
24853 v0.AuxInt = int32ToAuxInt(int32(c))
24854 v0.AddArg(y)
24855 b.resetWithControl(block.BlockARM64EQ, v0)
24856 return true
24857 }
24858
24859
24860
24861 for b.Controls[0].Op == OpARM64CMPconst {
24862 v_0 := b.Controls[0]
24863 if auxIntToInt64(v_0.AuxInt) != 0 {
24864 break
24865 }
24866 x := v_0.Args[0]
24867 if x.Op != OpARM64ADDconst {
24868 break
24869 }
24870 c := auxIntToInt64(x.AuxInt)
24871 y := x.Args[0]
24872 if !(x.Uses == 1) {
24873 break
24874 }
24875 v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
24876 v0.AuxInt = int64ToAuxInt(c)
24877 v0.AddArg(y)
24878 b.resetWithControl(block.BlockARM64EQ, v0)
24879 return true
24880 }
24881
24882
24883
24884 for b.Controls[0].Op == OpARM64CMPWconst {
24885 v_0 := b.Controls[0]
24886 if auxIntToInt32(v_0.AuxInt) != 0 {
24887 break
24888 }
24889 x := v_0.Args[0]
24890 if x.Op != OpARM64ADDconst {
24891 break
24892 }
24893 c := auxIntToInt64(x.AuxInt)
24894 y := x.Args[0]
24895 if !(x.Uses == 1) {
24896 break
24897 }
24898 v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
24899 v0.AuxInt = int32ToAuxInt(int32(c))
24900 v0.AddArg(y)
24901 b.resetWithControl(block.BlockARM64EQ, v0)
24902 return true
24903 }
24904
24905
24906
24907 for b.Controls[0].Op == OpARM64CMPconst {
24908 v_0 := b.Controls[0]
24909 if auxIntToInt64(v_0.AuxInt) != 0 {
24910 break
24911 }
24912 z := v_0.Args[0]
24913 if z.Op != OpARM64ADD {
24914 break
24915 }
24916 _ = z.Args[1]
24917 z_0 := z.Args[0]
24918 z_1 := z.Args[1]
24919 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
24920 x := z_0
24921 y := z_1
24922 if !(z.Uses == 1) {
24923 continue
24924 }
24925 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
24926 v0.AddArg2(x, y)
24927 b.resetWithControl(block.BlockARM64EQ, v0)
24928 return true
24929 }
24930 break
24931 }
24932
24933
24934
24935 for b.Controls[0].Op == OpARM64CMPWconst {
24936 v_0 := b.Controls[0]
24937 if auxIntToInt32(v_0.AuxInt) != 0 {
24938 break
24939 }
24940 z := v_0.Args[0]
24941 if z.Op != OpARM64ADD {
24942 break
24943 }
24944 _ = z.Args[1]
24945 z_0 := z.Args[0]
24946 z_1 := z.Args[1]
24947 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
24948 x := z_0
24949 y := z_1
24950 if !(z.Uses == 1) {
24951 continue
24952 }
24953 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
24954 v0.AddArg2(x, y)
24955 b.resetWithControl(block.BlockARM64EQ, v0)
24956 return true
24957 }
24958 break
24959 }
24960
24961
24962
24963 for b.Controls[0].Op == OpARM64CMP {
24964 v_0 := b.Controls[0]
24965 _ = v_0.Args[1]
24966 x := v_0.Args[0]
24967 z := v_0.Args[1]
24968 if z.Op != OpARM64NEG {
24969 break
24970 }
24971 y := z.Args[0]
24972 if !(z.Uses == 1) {
24973 break
24974 }
24975 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
24976 v0.AddArg2(x, y)
24977 b.resetWithControl(block.BlockARM64EQ, v0)
24978 return true
24979 }
24980
24981
24982
24983 for b.Controls[0].Op == OpARM64CMPW {
24984 v_0 := b.Controls[0]
24985 _ = v_0.Args[1]
24986 x := v_0.Args[0]
24987 z := v_0.Args[1]
24988 if z.Op != OpARM64NEG {
24989 break
24990 }
24991 y := z.Args[0]
24992 if !(z.Uses == 1) {
24993 break
24994 }
24995 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
24996 v0.AddArg2(x, y)
24997 b.resetWithControl(block.BlockARM64EQ, v0)
24998 return true
24999 }
25000
25001
25002 for b.Controls[0].Op == OpARM64CMPconst {
25003 v_0 := b.Controls[0]
25004 if auxIntToInt64(v_0.AuxInt) != 0 {
25005 break
25006 }
25007 x := v_0.Args[0]
25008 b.resetWithControl(block.BlockARM64Z, x)
25009 return true
25010 }
25011
25012
25013 for b.Controls[0].Op == OpARM64CMPWconst {
25014 v_0 := b.Controls[0]
25015 if auxIntToInt32(v_0.AuxInt) != 0 {
25016 break
25017 }
25018 x := v_0.Args[0]
25019 b.resetWithControl(block.BlockARM64ZW, x)
25020 return true
25021 }
25022
25023
25024
25025 for b.Controls[0].Op == OpARM64CMPconst {
25026 v_0 := b.Controls[0]
25027 if auxIntToInt64(v_0.AuxInt) != 0 {
25028 break
25029 }
25030 z := v_0.Args[0]
25031 if z.Op != OpARM64MADD {
25032 break
25033 }
25034 y := z.Args[2]
25035 a := z.Args[0]
25036 x := z.Args[1]
25037 if !(z.Uses == 1) {
25038 break
25039 }
25040 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
25041 v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
25042 v1.AddArg2(x, y)
25043 v0.AddArg2(a, v1)
25044 b.resetWithControl(block.BlockARM64EQ, v0)
25045 return true
25046 }
25047
25048
25049
25050 for b.Controls[0].Op == OpARM64CMPWconst {
25051 v_0 := b.Controls[0]
25052 if auxIntToInt32(v_0.AuxInt) != 0 {
25053 break
25054 }
25055 z := v_0.Args[0]
25056 if z.Op != OpARM64MADDW {
25057 break
25058 }
25059 y := z.Args[2]
25060 a := z.Args[0]
25061 x := z.Args[1]
25062 if !(z.Uses == 1) {
25063 break
25064 }
25065 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
25066 v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
25067 v1.AddArg2(x, y)
25068 v0.AddArg2(a, v1)
25069 b.resetWithControl(block.BlockARM64EQ, v0)
25070 return true
25071 }
25072
25073
25074
25075 for b.Controls[0].Op == OpARM64CMPconst {
25076 v_0 := b.Controls[0]
25077 if auxIntToInt64(v_0.AuxInt) != 0 {
25078 break
25079 }
25080 z := v_0.Args[0]
25081 if z.Op != OpARM64MSUB {
25082 break
25083 }
25084 y := z.Args[2]
25085 a := z.Args[0]
25086 x := z.Args[1]
25087 if !(z.Uses == 1) {
25088 break
25089 }
25090 v0 := b.NewValue0(v_0.Pos, OpARM64CMP, types.TypeFlags)
25091 v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
25092 v1.AddArg2(x, y)
25093 v0.AddArg2(a, v1)
25094 b.resetWithControl(block.BlockARM64EQ, v0)
25095 return true
25096 }
25097
25098
25099
25100 for b.Controls[0].Op == OpARM64CMPWconst {
25101 v_0 := b.Controls[0]
25102 if auxIntToInt32(v_0.AuxInt) != 0 {
25103 break
25104 }
25105 z := v_0.Args[0]
25106 if z.Op != OpARM64MSUBW {
25107 break
25108 }
25109 y := z.Args[2]
25110 a := z.Args[0]
25111 x := z.Args[1]
25112 if !(z.Uses == 1) {
25113 break
25114 }
25115 v0 := b.NewValue0(v_0.Pos, OpARM64CMPW, types.TypeFlags)
25116 v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
25117 v1.AddArg2(x, y)
25118 v0.AddArg2(a, v1)
25119 b.resetWithControl(block.BlockARM64EQ, v0)
25120 return true
25121 }
25122
25123
25124
25125 for b.Controls[0].Op == OpARM64TSTconst {
25126 v_0 := b.Controls[0]
25127 c := auxIntToInt64(v_0.AuxInt)
25128 x := v_0.Args[0]
25129 if !(oneBit(c)) {
25130 break
25131 }
25132 b.resetWithControl(block.BlockARM64TBZ, x)
25133 b.AuxInt = int64ToAuxInt(int64(ntz64(c)))
25134 return true
25135 }
25136
25137
25138
25139 for b.Controls[0].Op == OpARM64TSTWconst {
25140 v_0 := b.Controls[0]
25141 c := auxIntToInt32(v_0.AuxInt)
25142 x := v_0.Args[0]
25143 if !(oneBit(int64(uint32(c)))) {
25144 break
25145 }
25146 b.resetWithControl(block.BlockARM64TBZ, x)
25147 b.AuxInt = int64ToAuxInt(int64(ntz64(int64(uint32(c)))))
25148 return true
25149 }
25150
25151
25152
25153 for b.Controls[0].Op == OpARM64FlagConstant {
25154 v_0 := b.Controls[0]
25155 fc := auxIntToFlagConstant(v_0.AuxInt)
25156 if !(fc.eq()) {
25157 break
25158 }
25159 b.Reset(block.BlockFirst)
25160 return true
25161 }
25162
25163
25164
25165 for b.Controls[0].Op == OpARM64FlagConstant {
25166 v_0 := b.Controls[0]
25167 fc := auxIntToFlagConstant(v_0.AuxInt)
25168 if !(!fc.eq()) {
25169 break
25170 }
25171 b.Reset(block.BlockFirst)
25172 b.swapSuccessors()
25173 return true
25174 }
25175
25176
25177 for b.Controls[0].Op == OpARM64InvertFlags {
25178 v_0 := b.Controls[0]
25179 cmp := v_0.Args[0]
25180 b.resetWithControl(block.BlockARM64EQ, cmp)
25181 return true
25182 }
25183 case block.BlockARM64FGE:
25184
25185
25186 for b.Controls[0].Op == OpARM64InvertFlags {
25187 v_0 := b.Controls[0]
25188 cmp := v_0.Args[0]
25189 b.resetWithControl(block.BlockARM64FLE, cmp)
25190 return true
25191 }
25192 case block.BlockARM64FGT:
25193
25194
25195 for b.Controls[0].Op == OpARM64InvertFlags {
25196 v_0 := b.Controls[0]
25197 cmp := v_0.Args[0]
25198 b.resetWithControl(block.BlockARM64FLT, cmp)
25199 return true
25200 }
25201 case block.BlockARM64FLE:
25202
25203
25204 for b.Controls[0].Op == OpARM64InvertFlags {
25205 v_0 := b.Controls[0]
25206 cmp := v_0.Args[0]
25207 b.resetWithControl(block.BlockARM64FGE, cmp)
25208 return true
25209 }
25210 case block.BlockARM64FLT:
25211
25212
25213 for b.Controls[0].Op == OpARM64InvertFlags {
25214 v_0 := b.Controls[0]
25215 cmp := v_0.Args[0]
25216 b.resetWithControl(block.BlockARM64FGT, cmp)
25217 return true
25218 }
25219 case block.BlockARM64GE:
25220
25221
25222
25223 for b.Controls[0].Op == OpARM64CMPconst {
25224 v_0 := b.Controls[0]
25225 if auxIntToInt64(v_0.AuxInt) != 0 {
25226 break
25227 }
25228 z := v_0.Args[0]
25229 if z.Op != OpARM64AND {
25230 break
25231 }
25232 _ = z.Args[1]
25233 z_0 := z.Args[0]
25234 z_1 := z.Args[1]
25235 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25236 x := z_0
25237 y := z_1
25238 if !(z.Uses == 1) {
25239 continue
25240 }
25241 v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
25242 v0.AddArg2(x, y)
25243 b.resetWithControl(block.BlockARM64GE, v0)
25244 return true
25245 }
25246 break
25247 }
25248
25249
25250
25251 for b.Controls[0].Op == OpARM64CMPconst {
25252 v_0 := b.Controls[0]
25253 if auxIntToInt64(v_0.AuxInt) != 0 {
25254 break
25255 }
25256 x := v_0.Args[0]
25257 if x.Op != OpARM64ANDconst {
25258 break
25259 }
25260 c := auxIntToInt64(x.AuxInt)
25261 y := x.Args[0]
25262 if !(x.Uses == 1) {
25263 break
25264 }
25265 v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
25266 v0.AuxInt = int64ToAuxInt(c)
25267 v0.AddArg(y)
25268 b.resetWithControl(block.BlockARM64GE, v0)
25269 return true
25270 }
25271
25272
25273
25274 for b.Controls[0].Op == OpARM64CMPWconst {
25275 v_0 := b.Controls[0]
25276 if auxIntToInt32(v_0.AuxInt) != 0 {
25277 break
25278 }
25279 z := v_0.Args[0]
25280 if z.Op != OpARM64AND {
25281 break
25282 }
25283 _ = z.Args[1]
25284 z_0 := z.Args[0]
25285 z_1 := z.Args[1]
25286 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25287 x := z_0
25288 y := z_1
25289 if !(z.Uses == 1) {
25290 continue
25291 }
25292 v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
25293 v0.AddArg2(x, y)
25294 b.resetWithControl(block.BlockARM64GE, v0)
25295 return true
25296 }
25297 break
25298 }
25299
25300
25301
25302 for b.Controls[0].Op == OpARM64CMPWconst {
25303 v_0 := b.Controls[0]
25304 if auxIntToInt32(v_0.AuxInt) != 0 {
25305 break
25306 }
25307 x := v_0.Args[0]
25308 if x.Op != OpARM64ANDconst {
25309 break
25310 }
25311 c := auxIntToInt64(x.AuxInt)
25312 y := x.Args[0]
25313 if !(x.Uses == 1) {
25314 break
25315 }
25316 v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
25317 v0.AuxInt = int32ToAuxInt(int32(c))
25318 v0.AddArg(y)
25319 b.resetWithControl(block.BlockARM64GE, v0)
25320 return true
25321 }
25322
25323
25324
25325 for b.Controls[0].Op == OpARM64CMPconst {
25326 v_0 := b.Controls[0]
25327 if auxIntToInt64(v_0.AuxInt) != 0 {
25328 break
25329 }
25330 x := v_0.Args[0]
25331 if x.Op != OpARM64ADDconst {
25332 break
25333 }
25334 c := auxIntToInt64(x.AuxInt)
25335 y := x.Args[0]
25336 if !(x.Uses == 1) {
25337 break
25338 }
25339 v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
25340 v0.AuxInt = int64ToAuxInt(c)
25341 v0.AddArg(y)
25342 b.resetWithControl(block.BlockARM64GEnoov, v0)
25343 return true
25344 }
25345
25346
25347
25348 for b.Controls[0].Op == OpARM64CMPWconst {
25349 v_0 := b.Controls[0]
25350 if auxIntToInt32(v_0.AuxInt) != 0 {
25351 break
25352 }
25353 x := v_0.Args[0]
25354 if x.Op != OpARM64ADDconst {
25355 break
25356 }
25357 c := auxIntToInt64(x.AuxInt)
25358 y := x.Args[0]
25359 if !(x.Uses == 1) {
25360 break
25361 }
25362 v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
25363 v0.AuxInt = int32ToAuxInt(int32(c))
25364 v0.AddArg(y)
25365 b.resetWithControl(block.BlockARM64GEnoov, v0)
25366 return true
25367 }
25368
25369
25370
25371 for b.Controls[0].Op == OpARM64CMPconst {
25372 v_0 := b.Controls[0]
25373 if auxIntToInt64(v_0.AuxInt) != 0 {
25374 break
25375 }
25376 z := v_0.Args[0]
25377 if z.Op != OpARM64ADD {
25378 break
25379 }
25380 _ = z.Args[1]
25381 z_0 := z.Args[0]
25382 z_1 := z.Args[1]
25383 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25384 x := z_0
25385 y := z_1
25386 if !(z.Uses == 1) {
25387 continue
25388 }
25389 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
25390 v0.AddArg2(x, y)
25391 b.resetWithControl(block.BlockARM64GEnoov, v0)
25392 return true
25393 }
25394 break
25395 }
25396
25397
25398
25399 for b.Controls[0].Op == OpARM64CMPWconst {
25400 v_0 := b.Controls[0]
25401 if auxIntToInt32(v_0.AuxInt) != 0 {
25402 break
25403 }
25404 z := v_0.Args[0]
25405 if z.Op != OpARM64ADD {
25406 break
25407 }
25408 _ = z.Args[1]
25409 z_0 := z.Args[0]
25410 z_1 := z.Args[1]
25411 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25412 x := z_0
25413 y := z_1
25414 if !(z.Uses == 1) {
25415 continue
25416 }
25417 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
25418 v0.AddArg2(x, y)
25419 b.resetWithControl(block.BlockARM64GEnoov, v0)
25420 return true
25421 }
25422 break
25423 }
25424
25425
25426
25427 for b.Controls[0].Op == OpARM64CMPconst {
25428 v_0 := b.Controls[0]
25429 if auxIntToInt64(v_0.AuxInt) != 0 {
25430 break
25431 }
25432 z := v_0.Args[0]
25433 if z.Op != OpARM64MADD {
25434 break
25435 }
25436 y := z.Args[2]
25437 a := z.Args[0]
25438 x := z.Args[1]
25439 if !(z.Uses == 1) {
25440 break
25441 }
25442 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
25443 v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
25444 v1.AddArg2(x, y)
25445 v0.AddArg2(a, v1)
25446 b.resetWithControl(block.BlockARM64GEnoov, v0)
25447 return true
25448 }
25449
25450
25451
25452 for b.Controls[0].Op == OpARM64CMPWconst {
25453 v_0 := b.Controls[0]
25454 if auxIntToInt32(v_0.AuxInt) != 0 {
25455 break
25456 }
25457 z := v_0.Args[0]
25458 if z.Op != OpARM64MADDW {
25459 break
25460 }
25461 y := z.Args[2]
25462 a := z.Args[0]
25463 x := z.Args[1]
25464 if !(z.Uses == 1) {
25465 break
25466 }
25467 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
25468 v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
25469 v1.AddArg2(x, y)
25470 v0.AddArg2(a, v1)
25471 b.resetWithControl(block.BlockARM64GEnoov, v0)
25472 return true
25473 }
25474
25475
25476 for b.Controls[0].Op == OpARM64CMPWconst {
25477 v_0 := b.Controls[0]
25478 if auxIntToInt32(v_0.AuxInt) != 0 {
25479 break
25480 }
25481 x := v_0.Args[0]
25482 b.resetWithControl(block.BlockARM64TBZ, x)
25483 b.AuxInt = int64ToAuxInt(31)
25484 return true
25485 }
25486
25487
25488 for b.Controls[0].Op == OpARM64CMPconst {
25489 v_0 := b.Controls[0]
25490 if auxIntToInt64(v_0.AuxInt) != 0 {
25491 break
25492 }
25493 x := v_0.Args[0]
25494 b.resetWithControl(block.BlockARM64TBZ, x)
25495 b.AuxInt = int64ToAuxInt(63)
25496 return true
25497 }
25498
25499
25500
25501 for b.Controls[0].Op == OpARM64CMPWconst {
25502 v_0 := b.Controls[0]
25503 if auxIntToInt32(v_0.AuxInt) != 128 {
25504 break
25505 }
25506 x := v_0.Args[0]
25507 if !(ZeroUpper56Bits(x)) {
25508 break
25509 }
25510 b.resetWithControl(block.BlockARM64TBNZ, x)
25511 b.AuxInt = int64ToAuxInt(7)
25512 return true
25513 }
25514
25515
25516
25517 for b.Controls[0].Op == OpARM64CMPconst {
25518 v_0 := b.Controls[0]
25519 if auxIntToInt64(v_0.AuxInt) != 128 {
25520 break
25521 }
25522 x := v_0.Args[0]
25523 if !(ZeroUpper56Bits(x)) {
25524 break
25525 }
25526 b.resetWithControl(block.BlockARM64TBNZ, x)
25527 b.AuxInt = int64ToAuxInt(7)
25528 return true
25529 }
25530
25531
25532
25533 for b.Controls[0].Op == OpARM64FlagConstant {
25534 v_0 := b.Controls[0]
25535 fc := auxIntToFlagConstant(v_0.AuxInt)
25536 if !(fc.ge()) {
25537 break
25538 }
25539 b.Reset(block.BlockFirst)
25540 return true
25541 }
25542
25543
25544
25545 for b.Controls[0].Op == OpARM64FlagConstant {
25546 v_0 := b.Controls[0]
25547 fc := auxIntToFlagConstant(v_0.AuxInt)
25548 if !(!fc.ge()) {
25549 break
25550 }
25551 b.Reset(block.BlockFirst)
25552 b.swapSuccessors()
25553 return true
25554 }
25555
25556
25557 for b.Controls[0].Op == OpARM64InvertFlags {
25558 v_0 := b.Controls[0]
25559 cmp := v_0.Args[0]
25560 b.resetWithControl(block.BlockARM64LE, cmp)
25561 return true
25562 }
25563 case block.BlockARM64GEnoov:
25564
25565
25566
25567 for b.Controls[0].Op == OpARM64FlagConstant {
25568 v_0 := b.Controls[0]
25569 fc := auxIntToFlagConstant(v_0.AuxInt)
25570 if !(fc.geNoov()) {
25571 break
25572 }
25573 b.Reset(block.BlockFirst)
25574 return true
25575 }
25576
25577
25578
25579 for b.Controls[0].Op == OpARM64FlagConstant {
25580 v_0 := b.Controls[0]
25581 fc := auxIntToFlagConstant(v_0.AuxInt)
25582 if !(!fc.geNoov()) {
25583 break
25584 }
25585 b.Reset(block.BlockFirst)
25586 b.swapSuccessors()
25587 return true
25588 }
25589 case block.BlockARM64GT:
25590
25591
25592
25593 for b.Controls[0].Op == OpARM64CMPconst {
25594 v_0 := b.Controls[0]
25595 if auxIntToInt64(v_0.AuxInt) != 0 {
25596 break
25597 }
25598 z := v_0.Args[0]
25599 if z.Op != OpARM64AND {
25600 break
25601 }
25602 _ = z.Args[1]
25603 z_0 := z.Args[0]
25604 z_1 := z.Args[1]
25605 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25606 x := z_0
25607 y := z_1
25608 if !(z.Uses == 1) {
25609 continue
25610 }
25611 v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
25612 v0.AddArg2(x, y)
25613 b.resetWithControl(block.BlockARM64GT, v0)
25614 return true
25615 }
25616 break
25617 }
25618
25619
25620
25621 for b.Controls[0].Op == OpARM64CMPconst {
25622 v_0 := b.Controls[0]
25623 if auxIntToInt64(v_0.AuxInt) != 0 {
25624 break
25625 }
25626 x := v_0.Args[0]
25627 if x.Op != OpARM64ANDconst {
25628 break
25629 }
25630 c := auxIntToInt64(x.AuxInt)
25631 y := x.Args[0]
25632 if !(x.Uses == 1) {
25633 break
25634 }
25635 v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
25636 v0.AuxInt = int64ToAuxInt(c)
25637 v0.AddArg(y)
25638 b.resetWithControl(block.BlockARM64GT, v0)
25639 return true
25640 }
25641
25642
25643
25644 for b.Controls[0].Op == OpARM64CMPWconst {
25645 v_0 := b.Controls[0]
25646 if auxIntToInt32(v_0.AuxInt) != 0 {
25647 break
25648 }
25649 z := v_0.Args[0]
25650 if z.Op != OpARM64AND {
25651 break
25652 }
25653 _ = z.Args[1]
25654 z_0 := z.Args[0]
25655 z_1 := z.Args[1]
25656 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25657 x := z_0
25658 y := z_1
25659 if !(z.Uses == 1) {
25660 continue
25661 }
25662 v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
25663 v0.AddArg2(x, y)
25664 b.resetWithControl(block.BlockARM64GT, v0)
25665 return true
25666 }
25667 break
25668 }
25669
25670
25671
25672 for b.Controls[0].Op == OpARM64CMPWconst {
25673 v_0 := b.Controls[0]
25674 if auxIntToInt32(v_0.AuxInt) != 0 {
25675 break
25676 }
25677 x := v_0.Args[0]
25678 if x.Op != OpARM64ANDconst {
25679 break
25680 }
25681 c := auxIntToInt64(x.AuxInt)
25682 y := x.Args[0]
25683 if !(x.Uses == 1) {
25684 break
25685 }
25686 v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
25687 v0.AuxInt = int32ToAuxInt(int32(c))
25688 v0.AddArg(y)
25689 b.resetWithControl(block.BlockARM64GT, v0)
25690 return true
25691 }
25692
25693
25694
25695 for b.Controls[0].Op == OpARM64CMPconst {
25696 v_0 := b.Controls[0]
25697 if auxIntToInt64(v_0.AuxInt) != 0 {
25698 break
25699 }
25700 x := v_0.Args[0]
25701 if x.Op != OpARM64ADDconst {
25702 break
25703 }
25704 c := auxIntToInt64(x.AuxInt)
25705 y := x.Args[0]
25706 if !(x.Uses == 1) {
25707 break
25708 }
25709 v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
25710 v0.AuxInt = int64ToAuxInt(c)
25711 v0.AddArg(y)
25712 b.resetWithControl(block.BlockARM64GTnoov, v0)
25713 return true
25714 }
25715
25716
25717
25718 for b.Controls[0].Op == OpARM64CMPWconst {
25719 v_0 := b.Controls[0]
25720 if auxIntToInt32(v_0.AuxInt) != 0 {
25721 break
25722 }
25723 x := v_0.Args[0]
25724 if x.Op != OpARM64ADDconst {
25725 break
25726 }
25727 c := auxIntToInt64(x.AuxInt)
25728 y := x.Args[0]
25729 if !(x.Uses == 1) {
25730 break
25731 }
25732 v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
25733 v0.AuxInt = int32ToAuxInt(int32(c))
25734 v0.AddArg(y)
25735 b.resetWithControl(block.BlockARM64GTnoov, v0)
25736 return true
25737 }
25738
25739
25740
25741 for b.Controls[0].Op == OpARM64CMPconst {
25742 v_0 := b.Controls[0]
25743 if auxIntToInt64(v_0.AuxInt) != 0 {
25744 break
25745 }
25746 z := v_0.Args[0]
25747 if z.Op != OpARM64ADD {
25748 break
25749 }
25750 _ = z.Args[1]
25751 z_0 := z.Args[0]
25752 z_1 := z.Args[1]
25753 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25754 x := z_0
25755 y := z_1
25756 if !(z.Uses == 1) {
25757 continue
25758 }
25759 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
25760 v0.AddArg2(x, y)
25761 b.resetWithControl(block.BlockARM64GTnoov, v0)
25762 return true
25763 }
25764 break
25765 }
25766
25767
25768
25769 for b.Controls[0].Op == OpARM64CMPWconst {
25770 v_0 := b.Controls[0]
25771 if auxIntToInt32(v_0.AuxInt) != 0 {
25772 break
25773 }
25774 z := v_0.Args[0]
25775 if z.Op != OpARM64ADD {
25776 break
25777 }
25778 _ = z.Args[1]
25779 z_0 := z.Args[0]
25780 z_1 := z.Args[1]
25781 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25782 x := z_0
25783 y := z_1
25784 if !(z.Uses == 1) {
25785 continue
25786 }
25787 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
25788 v0.AddArg2(x, y)
25789 b.resetWithControl(block.BlockARM64GTnoov, v0)
25790 return true
25791 }
25792 break
25793 }
25794
25795
25796
25797 for b.Controls[0].Op == OpARM64CMPconst {
25798 v_0 := b.Controls[0]
25799 if auxIntToInt64(v_0.AuxInt) != 0 {
25800 break
25801 }
25802 z := v_0.Args[0]
25803 if z.Op != OpARM64MADD {
25804 break
25805 }
25806 y := z.Args[2]
25807 a := z.Args[0]
25808 x := z.Args[1]
25809 if !(z.Uses == 1) {
25810 break
25811 }
25812 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
25813 v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
25814 v1.AddArg2(x, y)
25815 v0.AddArg2(a, v1)
25816 b.resetWithControl(block.BlockARM64GTnoov, v0)
25817 return true
25818 }
25819
25820
25821
25822 for b.Controls[0].Op == OpARM64CMPWconst {
25823 v_0 := b.Controls[0]
25824 if auxIntToInt32(v_0.AuxInt) != 0 {
25825 break
25826 }
25827 z := v_0.Args[0]
25828 if z.Op != OpARM64MADDW {
25829 break
25830 }
25831 y := z.Args[2]
25832 a := z.Args[0]
25833 x := z.Args[1]
25834 if !(z.Uses == 1) {
25835 break
25836 }
25837 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
25838 v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
25839 v1.AddArg2(x, y)
25840 v0.AddArg2(a, v1)
25841 b.resetWithControl(block.BlockARM64GTnoov, v0)
25842 return true
25843 }
25844
25845
25846
25847 for b.Controls[0].Op == OpARM64FlagConstant {
25848 v_0 := b.Controls[0]
25849 fc := auxIntToFlagConstant(v_0.AuxInt)
25850 if !(fc.gt()) {
25851 break
25852 }
25853 b.Reset(block.BlockFirst)
25854 return true
25855 }
25856
25857
25858
25859 for b.Controls[0].Op == OpARM64FlagConstant {
25860 v_0 := b.Controls[0]
25861 fc := auxIntToFlagConstant(v_0.AuxInt)
25862 if !(!fc.gt()) {
25863 break
25864 }
25865 b.Reset(block.BlockFirst)
25866 b.swapSuccessors()
25867 return true
25868 }
25869
25870
25871 for b.Controls[0].Op == OpARM64InvertFlags {
25872 v_0 := b.Controls[0]
25873 cmp := v_0.Args[0]
25874 b.resetWithControl(block.BlockARM64LT, cmp)
25875 return true
25876 }
25877 case block.BlockARM64GTnoov:
25878
25879
25880
25881 for b.Controls[0].Op == OpARM64FlagConstant {
25882 v_0 := b.Controls[0]
25883 fc := auxIntToFlagConstant(v_0.AuxInt)
25884 if !(fc.gtNoov()) {
25885 break
25886 }
25887 b.Reset(block.BlockFirst)
25888 return true
25889 }
25890
25891
25892
25893 for b.Controls[0].Op == OpARM64FlagConstant {
25894 v_0 := b.Controls[0]
25895 fc := auxIntToFlagConstant(v_0.AuxInt)
25896 if !(!fc.gtNoov()) {
25897 break
25898 }
25899 b.Reset(block.BlockFirst)
25900 b.swapSuccessors()
25901 return true
25902 }
25903 case block.BlockIf:
25904
25905
25906 for b.Controls[0].Op == OpARM64Equal {
25907 v_0 := b.Controls[0]
25908 cc := v_0.Args[0]
25909 b.resetWithControl(block.BlockARM64EQ, cc)
25910 return true
25911 }
25912
25913
25914 for b.Controls[0].Op == OpARM64NotEqual {
25915 v_0 := b.Controls[0]
25916 cc := v_0.Args[0]
25917 b.resetWithControl(block.BlockARM64NE, cc)
25918 return true
25919 }
25920
25921
25922 for b.Controls[0].Op == OpARM64LessThan {
25923 v_0 := b.Controls[0]
25924 cc := v_0.Args[0]
25925 b.resetWithControl(block.BlockARM64LT, cc)
25926 return true
25927 }
25928
25929
25930 for b.Controls[0].Op == OpARM64LessThanU {
25931 v_0 := b.Controls[0]
25932 cc := v_0.Args[0]
25933 b.resetWithControl(block.BlockARM64ULT, cc)
25934 return true
25935 }
25936
25937
25938 for b.Controls[0].Op == OpARM64LessEqual {
25939 v_0 := b.Controls[0]
25940 cc := v_0.Args[0]
25941 b.resetWithControl(block.BlockARM64LE, cc)
25942 return true
25943 }
25944
25945
25946 for b.Controls[0].Op == OpARM64LessEqualU {
25947 v_0 := b.Controls[0]
25948 cc := v_0.Args[0]
25949 b.resetWithControl(block.BlockARM64ULE, cc)
25950 return true
25951 }
25952
25953
25954 for b.Controls[0].Op == OpARM64GreaterThan {
25955 v_0 := b.Controls[0]
25956 cc := v_0.Args[0]
25957 b.resetWithControl(block.BlockARM64GT, cc)
25958 return true
25959 }
25960
25961
25962 for b.Controls[0].Op == OpARM64GreaterThanU {
25963 v_0 := b.Controls[0]
25964 cc := v_0.Args[0]
25965 b.resetWithControl(block.BlockARM64UGT, cc)
25966 return true
25967 }
25968
25969
25970 for b.Controls[0].Op == OpARM64GreaterEqual {
25971 v_0 := b.Controls[0]
25972 cc := v_0.Args[0]
25973 b.resetWithControl(block.BlockARM64GE, cc)
25974 return true
25975 }
25976
25977
25978 for b.Controls[0].Op == OpARM64GreaterEqualU {
25979 v_0 := b.Controls[0]
25980 cc := v_0.Args[0]
25981 b.resetWithControl(block.BlockARM64UGE, cc)
25982 return true
25983 }
25984
25985
25986 for b.Controls[0].Op == OpARM64LessThanF {
25987 v_0 := b.Controls[0]
25988 cc := v_0.Args[0]
25989 b.resetWithControl(block.BlockARM64FLT, cc)
25990 return true
25991 }
25992
25993
25994 for b.Controls[0].Op == OpARM64LessEqualF {
25995 v_0 := b.Controls[0]
25996 cc := v_0.Args[0]
25997 b.resetWithControl(block.BlockARM64FLE, cc)
25998 return true
25999 }
26000
26001
26002 for b.Controls[0].Op == OpARM64GreaterThanF {
26003 v_0 := b.Controls[0]
26004 cc := v_0.Args[0]
26005 b.resetWithControl(block.BlockARM64FGT, cc)
26006 return true
26007 }
26008
26009
26010 for b.Controls[0].Op == OpARM64GreaterEqualF {
26011 v_0 := b.Controls[0]
26012 cc := v_0.Args[0]
26013 b.resetWithControl(block.BlockARM64FGE, cc)
26014 return true
26015 }
26016
26017
26018 for {
26019 cond := b.Controls[0]
26020 b.resetWithControl(block.BlockARM64TBNZ, cond)
26021 b.AuxInt = int64ToAuxInt(0)
26022 return true
26023 }
26024 case block.BlockJumpTable:
26025
26026
26027 for {
26028 idx := b.Controls[0]
26029 v0 := b.NewValue0(b.Pos, OpARM64MOVDaddr, typ.Uintptr)
26030 v0.Aux = symToAux(makeJumpTableSym(b))
26031 v1 := b.NewValue0(b.Pos, OpSB, typ.Uintptr)
26032 v0.AddArg(v1)
26033 b.resetWithControl2(block.BlockARM64JUMPTABLE, idx, v0)
26034 b.Aux = symToAux(makeJumpTableSym(b))
26035 return true
26036 }
26037 case block.BlockARM64LE:
26038
26039
26040
26041 for b.Controls[0].Op == OpARM64CMPconst {
26042 v_0 := b.Controls[0]
26043 if auxIntToInt64(v_0.AuxInt) != 0 {
26044 break
26045 }
26046 z := v_0.Args[0]
26047 if z.Op != OpARM64AND {
26048 break
26049 }
26050 _ = z.Args[1]
26051 z_0 := z.Args[0]
26052 z_1 := z.Args[1]
26053 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26054 x := z_0
26055 y := z_1
26056 if !(z.Uses == 1) {
26057 continue
26058 }
26059 v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
26060 v0.AddArg2(x, y)
26061 b.resetWithControl(block.BlockARM64LE, v0)
26062 return true
26063 }
26064 break
26065 }
26066
26067
26068
26069 for b.Controls[0].Op == OpARM64CMPconst {
26070 v_0 := b.Controls[0]
26071 if auxIntToInt64(v_0.AuxInt) != 0 {
26072 break
26073 }
26074 x := v_0.Args[0]
26075 if x.Op != OpARM64ANDconst {
26076 break
26077 }
26078 c := auxIntToInt64(x.AuxInt)
26079 y := x.Args[0]
26080 if !(x.Uses == 1) {
26081 break
26082 }
26083 v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
26084 v0.AuxInt = int64ToAuxInt(c)
26085 v0.AddArg(y)
26086 b.resetWithControl(block.BlockARM64LE, v0)
26087 return true
26088 }
26089
26090
26091
26092 for b.Controls[0].Op == OpARM64CMPWconst {
26093 v_0 := b.Controls[0]
26094 if auxIntToInt32(v_0.AuxInt) != 0 {
26095 break
26096 }
26097 z := v_0.Args[0]
26098 if z.Op != OpARM64AND {
26099 break
26100 }
26101 _ = z.Args[1]
26102 z_0 := z.Args[0]
26103 z_1 := z.Args[1]
26104 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26105 x := z_0
26106 y := z_1
26107 if !(z.Uses == 1) {
26108 continue
26109 }
26110 v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
26111 v0.AddArg2(x, y)
26112 b.resetWithControl(block.BlockARM64LE, v0)
26113 return true
26114 }
26115 break
26116 }
26117
26118
26119
26120 for b.Controls[0].Op == OpARM64CMPWconst {
26121 v_0 := b.Controls[0]
26122 if auxIntToInt32(v_0.AuxInt) != 0 {
26123 break
26124 }
26125 x := v_0.Args[0]
26126 if x.Op != OpARM64ANDconst {
26127 break
26128 }
26129 c := auxIntToInt64(x.AuxInt)
26130 y := x.Args[0]
26131 if !(x.Uses == 1) {
26132 break
26133 }
26134 v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
26135 v0.AuxInt = int32ToAuxInt(int32(c))
26136 v0.AddArg(y)
26137 b.resetWithControl(block.BlockARM64LE, v0)
26138 return true
26139 }
26140
26141
26142
26143 for b.Controls[0].Op == OpARM64CMPconst {
26144 v_0 := b.Controls[0]
26145 if auxIntToInt64(v_0.AuxInt) != 0 {
26146 break
26147 }
26148 x := v_0.Args[0]
26149 if x.Op != OpARM64ADDconst {
26150 break
26151 }
26152 c := auxIntToInt64(x.AuxInt)
26153 y := x.Args[0]
26154 if !(x.Uses == 1) {
26155 break
26156 }
26157 v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
26158 v0.AuxInt = int64ToAuxInt(c)
26159 v0.AddArg(y)
26160 b.resetWithControl(block.BlockARM64LEnoov, v0)
26161 return true
26162 }
26163
26164
26165
26166 for b.Controls[0].Op == OpARM64CMPWconst {
26167 v_0 := b.Controls[0]
26168 if auxIntToInt32(v_0.AuxInt) != 0 {
26169 break
26170 }
26171 x := v_0.Args[0]
26172 if x.Op != OpARM64ADDconst {
26173 break
26174 }
26175 c := auxIntToInt64(x.AuxInt)
26176 y := x.Args[0]
26177 if !(x.Uses == 1) {
26178 break
26179 }
26180 v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
26181 v0.AuxInt = int32ToAuxInt(int32(c))
26182 v0.AddArg(y)
26183 b.resetWithControl(block.BlockARM64LEnoov, v0)
26184 return true
26185 }
26186
26187
26188
26189 for b.Controls[0].Op == OpARM64CMPconst {
26190 v_0 := b.Controls[0]
26191 if auxIntToInt64(v_0.AuxInt) != 0 {
26192 break
26193 }
26194 z := v_0.Args[0]
26195 if z.Op != OpARM64ADD {
26196 break
26197 }
26198 _ = z.Args[1]
26199 z_0 := z.Args[0]
26200 z_1 := z.Args[1]
26201 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26202 x := z_0
26203 y := z_1
26204 if !(z.Uses == 1) {
26205 continue
26206 }
26207 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
26208 v0.AddArg2(x, y)
26209 b.resetWithControl(block.BlockARM64LEnoov, v0)
26210 return true
26211 }
26212 break
26213 }
26214
26215
26216
26217 for b.Controls[0].Op == OpARM64CMPWconst {
26218 v_0 := b.Controls[0]
26219 if auxIntToInt32(v_0.AuxInt) != 0 {
26220 break
26221 }
26222 z := v_0.Args[0]
26223 if z.Op != OpARM64ADD {
26224 break
26225 }
26226 _ = z.Args[1]
26227 z_0 := z.Args[0]
26228 z_1 := z.Args[1]
26229 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26230 x := z_0
26231 y := z_1
26232 if !(z.Uses == 1) {
26233 continue
26234 }
26235 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
26236 v0.AddArg2(x, y)
26237 b.resetWithControl(block.BlockARM64LEnoov, v0)
26238 return true
26239 }
26240 break
26241 }
26242
26243
26244
26245 for b.Controls[0].Op == OpARM64CMPconst {
26246 v_0 := b.Controls[0]
26247 if auxIntToInt64(v_0.AuxInt) != 0 {
26248 break
26249 }
26250 z := v_0.Args[0]
26251 if z.Op != OpARM64MADD {
26252 break
26253 }
26254 y := z.Args[2]
26255 a := z.Args[0]
26256 x := z.Args[1]
26257 if !(z.Uses == 1) {
26258 break
26259 }
26260 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
26261 v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
26262 v1.AddArg2(x, y)
26263 v0.AddArg2(a, v1)
26264 b.resetWithControl(block.BlockARM64LEnoov, v0)
26265 return true
26266 }
26267
26268
26269
26270 for b.Controls[0].Op == OpARM64CMPWconst {
26271 v_0 := b.Controls[0]
26272 if auxIntToInt32(v_0.AuxInt) != 0 {
26273 break
26274 }
26275 z := v_0.Args[0]
26276 if z.Op != OpARM64MADDW {
26277 break
26278 }
26279 y := z.Args[2]
26280 a := z.Args[0]
26281 x := z.Args[1]
26282 if !(z.Uses == 1) {
26283 break
26284 }
26285 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
26286 v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
26287 v1.AddArg2(x, y)
26288 v0.AddArg2(a, v1)
26289 b.resetWithControl(block.BlockARM64LEnoov, v0)
26290 return true
26291 }
26292
26293
26294
26295 for b.Controls[0].Op == OpARM64FlagConstant {
26296 v_0 := b.Controls[0]
26297 fc := auxIntToFlagConstant(v_0.AuxInt)
26298 if !(fc.le()) {
26299 break
26300 }
26301 b.Reset(block.BlockFirst)
26302 return true
26303 }
26304
26305
26306
26307 for b.Controls[0].Op == OpARM64FlagConstant {
26308 v_0 := b.Controls[0]
26309 fc := auxIntToFlagConstant(v_0.AuxInt)
26310 if !(!fc.le()) {
26311 break
26312 }
26313 b.Reset(block.BlockFirst)
26314 b.swapSuccessors()
26315 return true
26316 }
26317
26318
26319 for b.Controls[0].Op == OpARM64InvertFlags {
26320 v_0 := b.Controls[0]
26321 cmp := v_0.Args[0]
26322 b.resetWithControl(block.BlockARM64GE, cmp)
26323 return true
26324 }
26325 case block.BlockARM64LEnoov:
26326
26327
26328
26329 for b.Controls[0].Op == OpARM64FlagConstant {
26330 v_0 := b.Controls[0]
26331 fc := auxIntToFlagConstant(v_0.AuxInt)
26332 if !(fc.leNoov()) {
26333 break
26334 }
26335 b.Reset(block.BlockFirst)
26336 return true
26337 }
26338
26339
26340
26341 for b.Controls[0].Op == OpARM64FlagConstant {
26342 v_0 := b.Controls[0]
26343 fc := auxIntToFlagConstant(v_0.AuxInt)
26344 if !(!fc.leNoov()) {
26345 break
26346 }
26347 b.Reset(block.BlockFirst)
26348 b.swapSuccessors()
26349 return true
26350 }
26351 case block.BlockARM64LT:
26352
26353
26354
26355 for b.Controls[0].Op == OpARM64CMPconst {
26356 v_0 := b.Controls[0]
26357 if auxIntToInt64(v_0.AuxInt) != 0 {
26358 break
26359 }
26360 z := v_0.Args[0]
26361 if z.Op != OpARM64AND {
26362 break
26363 }
26364 _ = z.Args[1]
26365 z_0 := z.Args[0]
26366 z_1 := z.Args[1]
26367 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26368 x := z_0
26369 y := z_1
26370 if !(z.Uses == 1) {
26371 continue
26372 }
26373 v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
26374 v0.AddArg2(x, y)
26375 b.resetWithControl(block.BlockARM64LT, v0)
26376 return true
26377 }
26378 break
26379 }
26380
26381
26382
26383 for b.Controls[0].Op == OpARM64CMPconst {
26384 v_0 := b.Controls[0]
26385 if auxIntToInt64(v_0.AuxInt) != 0 {
26386 break
26387 }
26388 x := v_0.Args[0]
26389 if x.Op != OpARM64ANDconst {
26390 break
26391 }
26392 c := auxIntToInt64(x.AuxInt)
26393 y := x.Args[0]
26394 if !(x.Uses == 1) {
26395 break
26396 }
26397 v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
26398 v0.AuxInt = int64ToAuxInt(c)
26399 v0.AddArg(y)
26400 b.resetWithControl(block.BlockARM64LT, v0)
26401 return true
26402 }
26403
26404
26405
26406 for b.Controls[0].Op == OpARM64CMPWconst {
26407 v_0 := b.Controls[0]
26408 if auxIntToInt32(v_0.AuxInt) != 0 {
26409 break
26410 }
26411 z := v_0.Args[0]
26412 if z.Op != OpARM64AND {
26413 break
26414 }
26415 _ = z.Args[1]
26416 z_0 := z.Args[0]
26417 z_1 := z.Args[1]
26418 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26419 x := z_0
26420 y := z_1
26421 if !(z.Uses == 1) {
26422 continue
26423 }
26424 v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
26425 v0.AddArg2(x, y)
26426 b.resetWithControl(block.BlockARM64LT, v0)
26427 return true
26428 }
26429 break
26430 }
26431
26432
26433
26434 for b.Controls[0].Op == OpARM64CMPWconst {
26435 v_0 := b.Controls[0]
26436 if auxIntToInt32(v_0.AuxInt) != 0 {
26437 break
26438 }
26439 x := v_0.Args[0]
26440 if x.Op != OpARM64ANDconst {
26441 break
26442 }
26443 c := auxIntToInt64(x.AuxInt)
26444 y := x.Args[0]
26445 if !(x.Uses == 1) {
26446 break
26447 }
26448 v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
26449 v0.AuxInt = int32ToAuxInt(int32(c))
26450 v0.AddArg(y)
26451 b.resetWithControl(block.BlockARM64LT, v0)
26452 return true
26453 }
26454
26455
26456
26457 for b.Controls[0].Op == OpARM64CMPconst {
26458 v_0 := b.Controls[0]
26459 if auxIntToInt64(v_0.AuxInt) != 0 {
26460 break
26461 }
26462 x := v_0.Args[0]
26463 if x.Op != OpARM64ADDconst {
26464 break
26465 }
26466 c := auxIntToInt64(x.AuxInt)
26467 y := x.Args[0]
26468 if !(x.Uses == 1) {
26469 break
26470 }
26471 v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
26472 v0.AuxInt = int64ToAuxInt(c)
26473 v0.AddArg(y)
26474 b.resetWithControl(block.BlockARM64LTnoov, v0)
26475 return true
26476 }
26477
26478
26479
26480 for b.Controls[0].Op == OpARM64CMPWconst {
26481 v_0 := b.Controls[0]
26482 if auxIntToInt32(v_0.AuxInt) != 0 {
26483 break
26484 }
26485 x := v_0.Args[0]
26486 if x.Op != OpARM64ADDconst {
26487 break
26488 }
26489 c := auxIntToInt64(x.AuxInt)
26490 y := x.Args[0]
26491 if !(x.Uses == 1) {
26492 break
26493 }
26494 v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
26495 v0.AuxInt = int32ToAuxInt(int32(c))
26496 v0.AddArg(y)
26497 b.resetWithControl(block.BlockARM64LTnoov, v0)
26498 return true
26499 }
26500
26501
26502
26503 for b.Controls[0].Op == OpARM64CMPconst {
26504 v_0 := b.Controls[0]
26505 if auxIntToInt64(v_0.AuxInt) != 0 {
26506 break
26507 }
26508 z := v_0.Args[0]
26509 if z.Op != OpARM64ADD {
26510 break
26511 }
26512 _ = z.Args[1]
26513 z_0 := z.Args[0]
26514 z_1 := z.Args[1]
26515 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26516 x := z_0
26517 y := z_1
26518 if !(z.Uses == 1) {
26519 continue
26520 }
26521 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
26522 v0.AddArg2(x, y)
26523 b.resetWithControl(block.BlockARM64LTnoov, v0)
26524 return true
26525 }
26526 break
26527 }
26528
26529
26530
26531 for b.Controls[0].Op == OpARM64CMPWconst {
26532 v_0 := b.Controls[0]
26533 if auxIntToInt32(v_0.AuxInt) != 0 {
26534 break
26535 }
26536 z := v_0.Args[0]
26537 if z.Op != OpARM64ADD {
26538 break
26539 }
26540 _ = z.Args[1]
26541 z_0 := z.Args[0]
26542 z_1 := z.Args[1]
26543 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26544 x := z_0
26545 y := z_1
26546 if !(z.Uses == 1) {
26547 continue
26548 }
26549 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
26550 v0.AddArg2(x, y)
26551 b.resetWithControl(block.BlockARM64LTnoov, v0)
26552 return true
26553 }
26554 break
26555 }
26556
26557
26558
26559 for b.Controls[0].Op == OpARM64CMPconst {
26560 v_0 := b.Controls[0]
26561 if auxIntToInt64(v_0.AuxInt) != 0 {
26562 break
26563 }
26564 z := v_0.Args[0]
26565 if z.Op != OpARM64MADD {
26566 break
26567 }
26568 y := z.Args[2]
26569 a := z.Args[0]
26570 x := z.Args[1]
26571 if !(z.Uses == 1) {
26572 break
26573 }
26574 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
26575 v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
26576 v1.AddArg2(x, y)
26577 v0.AddArg2(a, v1)
26578 b.resetWithControl(block.BlockARM64LTnoov, v0)
26579 return true
26580 }
26581
26582
26583
26584 for b.Controls[0].Op == OpARM64CMPWconst {
26585 v_0 := b.Controls[0]
26586 if auxIntToInt32(v_0.AuxInt) != 0 {
26587 break
26588 }
26589 z := v_0.Args[0]
26590 if z.Op != OpARM64MADDW {
26591 break
26592 }
26593 y := z.Args[2]
26594 a := z.Args[0]
26595 x := z.Args[1]
26596 if !(z.Uses == 1) {
26597 break
26598 }
26599 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
26600 v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
26601 v1.AddArg2(x, y)
26602 v0.AddArg2(a, v1)
26603 b.resetWithControl(block.BlockARM64LTnoov, v0)
26604 return true
26605 }
26606
26607
26608 for b.Controls[0].Op == OpARM64CMPWconst {
26609 v_0 := b.Controls[0]
26610 if auxIntToInt32(v_0.AuxInt) != 0 {
26611 break
26612 }
26613 x := v_0.Args[0]
26614 b.resetWithControl(block.BlockARM64TBNZ, x)
26615 b.AuxInt = int64ToAuxInt(31)
26616 return true
26617 }
26618
26619
26620 for b.Controls[0].Op == OpARM64CMPconst {
26621 v_0 := b.Controls[0]
26622 if auxIntToInt64(v_0.AuxInt) != 0 {
26623 break
26624 }
26625 x := v_0.Args[0]
26626 b.resetWithControl(block.BlockARM64TBNZ, x)
26627 b.AuxInt = int64ToAuxInt(63)
26628 return true
26629 }
26630
26631
26632
26633 for b.Controls[0].Op == OpARM64CMPWconst {
26634 v_0 := b.Controls[0]
26635 if auxIntToInt32(v_0.AuxInt) != 128 {
26636 break
26637 }
26638 x := v_0.Args[0]
26639 if !(ZeroUpper56Bits(x)) {
26640 break
26641 }
26642 b.resetWithControl(block.BlockARM64TBZ, x)
26643 b.AuxInt = int64ToAuxInt(7)
26644 return true
26645 }
26646
26647
26648
26649 for b.Controls[0].Op == OpARM64CMPconst {
26650 v_0 := b.Controls[0]
26651 if auxIntToInt64(v_0.AuxInt) != 128 {
26652 break
26653 }
26654 x := v_0.Args[0]
26655 if !(ZeroUpper56Bits(x)) {
26656 break
26657 }
26658 b.resetWithControl(block.BlockARM64TBZ, x)
26659 b.AuxInt = int64ToAuxInt(7)
26660 return true
26661 }
26662
26663
26664
26665 for b.Controls[0].Op == OpARM64FlagConstant {
26666 v_0 := b.Controls[0]
26667 fc := auxIntToFlagConstant(v_0.AuxInt)
26668 if !(fc.lt()) {
26669 break
26670 }
26671 b.Reset(block.BlockFirst)
26672 return true
26673 }
26674
26675
26676
26677 for b.Controls[0].Op == OpARM64FlagConstant {
26678 v_0 := b.Controls[0]
26679 fc := auxIntToFlagConstant(v_0.AuxInt)
26680 if !(!fc.lt()) {
26681 break
26682 }
26683 b.Reset(block.BlockFirst)
26684 b.swapSuccessors()
26685 return true
26686 }
26687
26688
26689 for b.Controls[0].Op == OpARM64InvertFlags {
26690 v_0 := b.Controls[0]
26691 cmp := v_0.Args[0]
26692 b.resetWithControl(block.BlockARM64GT, cmp)
26693 return true
26694 }
26695 case block.BlockARM64LTnoov:
26696
26697
26698
26699 for b.Controls[0].Op == OpARM64FlagConstant {
26700 v_0 := b.Controls[0]
26701 fc := auxIntToFlagConstant(v_0.AuxInt)
26702 if !(fc.ltNoov()) {
26703 break
26704 }
26705 b.Reset(block.BlockFirst)
26706 return true
26707 }
26708
26709
26710
26711 for b.Controls[0].Op == OpARM64FlagConstant {
26712 v_0 := b.Controls[0]
26713 fc := auxIntToFlagConstant(v_0.AuxInt)
26714 if !(!fc.ltNoov()) {
26715 break
26716 }
26717 b.Reset(block.BlockFirst)
26718 b.swapSuccessors()
26719 return true
26720 }
26721 case block.BlockARM64NE:
26722
26723
26724
26725 for b.Controls[0].Op == OpARM64CMPconst {
26726 v_0 := b.Controls[0]
26727 if auxIntToInt64(v_0.AuxInt) != 0 {
26728 break
26729 }
26730 z := v_0.Args[0]
26731 if z.Op != OpARM64AND {
26732 break
26733 }
26734 _ = z.Args[1]
26735 z_0 := z.Args[0]
26736 z_1 := z.Args[1]
26737 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26738 x := z_0
26739 y := z_1
26740 if !(z.Uses == 1) {
26741 continue
26742 }
26743 v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
26744 v0.AddArg2(x, y)
26745 b.resetWithControl(block.BlockARM64NE, v0)
26746 return true
26747 }
26748 break
26749 }
26750
26751
26752
26753 for b.Controls[0].Op == OpARM64CMPconst {
26754 v_0 := b.Controls[0]
26755 if auxIntToInt64(v_0.AuxInt) != 0 {
26756 break
26757 }
26758 x := v_0.Args[0]
26759 if x.Op != OpARM64ANDconst {
26760 break
26761 }
26762 c := auxIntToInt64(x.AuxInt)
26763 y := x.Args[0]
26764 if !(x.Uses == 1) {
26765 break
26766 }
26767 v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
26768 v0.AuxInt = int64ToAuxInt(c)
26769 v0.AddArg(y)
26770 b.resetWithControl(block.BlockARM64NE, v0)
26771 return true
26772 }
26773
26774
26775
26776 for b.Controls[0].Op == OpARM64CMPWconst {
26777 v_0 := b.Controls[0]
26778 if auxIntToInt32(v_0.AuxInt) != 0 {
26779 break
26780 }
26781 z := v_0.Args[0]
26782 if z.Op != OpARM64AND {
26783 break
26784 }
26785 _ = z.Args[1]
26786 z_0 := z.Args[0]
26787 z_1 := z.Args[1]
26788 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26789 x := z_0
26790 y := z_1
26791 if !(z.Uses == 1) {
26792 continue
26793 }
26794 v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
26795 v0.AddArg2(x, y)
26796 b.resetWithControl(block.BlockARM64NE, v0)
26797 return true
26798 }
26799 break
26800 }
26801
26802
26803
26804 for b.Controls[0].Op == OpARM64CMPWconst {
26805 v_0 := b.Controls[0]
26806 if auxIntToInt32(v_0.AuxInt) != 0 {
26807 break
26808 }
26809 x := v_0.Args[0]
26810 if x.Op != OpARM64ANDconst {
26811 break
26812 }
26813 c := auxIntToInt64(x.AuxInt)
26814 y := x.Args[0]
26815 if !(x.Uses == 1) {
26816 break
26817 }
26818 v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
26819 v0.AuxInt = int32ToAuxInt(int32(c))
26820 v0.AddArg(y)
26821 b.resetWithControl(block.BlockARM64NE, v0)
26822 return true
26823 }
26824
26825
26826
26827 for b.Controls[0].Op == OpARM64CMPconst {
26828 v_0 := b.Controls[0]
26829 if auxIntToInt64(v_0.AuxInt) != 0 {
26830 break
26831 }
26832 x := v_0.Args[0]
26833 if x.Op != OpARM64ADDconst {
26834 break
26835 }
26836 c := auxIntToInt64(x.AuxInt)
26837 y := x.Args[0]
26838 if !(x.Uses == 1) {
26839 break
26840 }
26841 v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
26842 v0.AuxInt = int64ToAuxInt(c)
26843 v0.AddArg(y)
26844 b.resetWithControl(block.BlockARM64NE, v0)
26845 return true
26846 }
26847
26848
26849
26850 for b.Controls[0].Op == OpARM64CMPWconst {
26851 v_0 := b.Controls[0]
26852 if auxIntToInt32(v_0.AuxInt) != 0 {
26853 break
26854 }
26855 x := v_0.Args[0]
26856 if x.Op != OpARM64ADDconst {
26857 break
26858 }
26859 c := auxIntToInt64(x.AuxInt)
26860 y := x.Args[0]
26861 if !(x.Uses == 1) {
26862 break
26863 }
26864 v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
26865 v0.AuxInt = int32ToAuxInt(int32(c))
26866 v0.AddArg(y)
26867 b.resetWithControl(block.BlockARM64NE, v0)
26868 return true
26869 }
26870
26871
26872
26873 for b.Controls[0].Op == OpARM64CMPconst {
26874 v_0 := b.Controls[0]
26875 if auxIntToInt64(v_0.AuxInt) != 0 {
26876 break
26877 }
26878 z := v_0.Args[0]
26879 if z.Op != OpARM64ADD {
26880 break
26881 }
26882 _ = z.Args[1]
26883 z_0 := z.Args[0]
26884 z_1 := z.Args[1]
26885 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26886 x := z_0
26887 y := z_1
26888 if !(z.Uses == 1) {
26889 continue
26890 }
26891 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
26892 v0.AddArg2(x, y)
26893 b.resetWithControl(block.BlockARM64NE, v0)
26894 return true
26895 }
26896 break
26897 }
26898
26899
26900
26901 for b.Controls[0].Op == OpARM64CMPWconst {
26902 v_0 := b.Controls[0]
26903 if auxIntToInt32(v_0.AuxInt) != 0 {
26904 break
26905 }
26906 z := v_0.Args[0]
26907 if z.Op != OpARM64ADD {
26908 break
26909 }
26910 _ = z.Args[1]
26911 z_0 := z.Args[0]
26912 z_1 := z.Args[1]
26913 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26914 x := z_0
26915 y := z_1
26916 if !(z.Uses == 1) {
26917 continue
26918 }
26919 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
26920 v0.AddArg2(x, y)
26921 b.resetWithControl(block.BlockARM64NE, v0)
26922 return true
26923 }
26924 break
26925 }
26926
26927
26928
26929 for b.Controls[0].Op == OpARM64CMP {
26930 v_0 := b.Controls[0]
26931 _ = v_0.Args[1]
26932 x := v_0.Args[0]
26933 z := v_0.Args[1]
26934 if z.Op != OpARM64NEG {
26935 break
26936 }
26937 y := z.Args[0]
26938 if !(z.Uses == 1) {
26939 break
26940 }
26941 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
26942 v0.AddArg2(x, y)
26943 b.resetWithControl(block.BlockARM64NE, v0)
26944 return true
26945 }
26946
26947
26948
26949 for b.Controls[0].Op == OpARM64CMPW {
26950 v_0 := b.Controls[0]
26951 _ = v_0.Args[1]
26952 x := v_0.Args[0]
26953 z := v_0.Args[1]
26954 if z.Op != OpARM64NEG {
26955 break
26956 }
26957 y := z.Args[0]
26958 if !(z.Uses == 1) {
26959 break
26960 }
26961 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
26962 v0.AddArg2(x, y)
26963 b.resetWithControl(block.BlockARM64NE, v0)
26964 return true
26965 }
26966
26967
26968 for b.Controls[0].Op == OpARM64CMPconst {
26969 v_0 := b.Controls[0]
26970 if auxIntToInt64(v_0.AuxInt) != 0 {
26971 break
26972 }
26973 x := v_0.Args[0]
26974 b.resetWithControl(block.BlockARM64NZ, x)
26975 return true
26976 }
26977
26978
26979 for b.Controls[0].Op == OpARM64CMPWconst {
26980 v_0 := b.Controls[0]
26981 if auxIntToInt32(v_0.AuxInt) != 0 {
26982 break
26983 }
26984 x := v_0.Args[0]
26985 b.resetWithControl(block.BlockARM64NZW, x)
26986 return true
26987 }
26988
26989
26990
26991 for b.Controls[0].Op == OpARM64CMPconst {
26992 v_0 := b.Controls[0]
26993 if auxIntToInt64(v_0.AuxInt) != 0 {
26994 break
26995 }
26996 z := v_0.Args[0]
26997 if z.Op != OpARM64MADD {
26998 break
26999 }
27000 y := z.Args[2]
27001 a := z.Args[0]
27002 x := z.Args[1]
27003 if !(z.Uses == 1) {
27004 break
27005 }
27006 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
27007 v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
27008 v1.AddArg2(x, y)
27009 v0.AddArg2(a, v1)
27010 b.resetWithControl(block.BlockARM64NE, v0)
27011 return true
27012 }
27013
27014
27015
27016 for b.Controls[0].Op == OpARM64CMPWconst {
27017 v_0 := b.Controls[0]
27018 if auxIntToInt32(v_0.AuxInt) != 0 {
27019 break
27020 }
27021 z := v_0.Args[0]
27022 if z.Op != OpARM64MADDW {
27023 break
27024 }
27025 y := z.Args[2]
27026 a := z.Args[0]
27027 x := z.Args[1]
27028 if !(z.Uses == 1) {
27029 break
27030 }
27031 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
27032 v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
27033 v1.AddArg2(x, y)
27034 v0.AddArg2(a, v1)
27035 b.resetWithControl(block.BlockARM64NE, v0)
27036 return true
27037 }
27038
27039
27040
27041 for b.Controls[0].Op == OpARM64CMPconst {
27042 v_0 := b.Controls[0]
27043 if auxIntToInt64(v_0.AuxInt) != 0 {
27044 break
27045 }
27046 z := v_0.Args[0]
27047 if z.Op != OpARM64MSUB {
27048 break
27049 }
27050 y := z.Args[2]
27051 a := z.Args[0]
27052 x := z.Args[1]
27053 if !(z.Uses == 1) {
27054 break
27055 }
27056 v0 := b.NewValue0(v_0.Pos, OpARM64CMP, types.TypeFlags)
27057 v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
27058 v1.AddArg2(x, y)
27059 v0.AddArg2(a, v1)
27060 b.resetWithControl(block.BlockARM64NE, v0)
27061 return true
27062 }
27063
27064
27065
27066 for b.Controls[0].Op == OpARM64CMPWconst {
27067 v_0 := b.Controls[0]
27068 if auxIntToInt32(v_0.AuxInt) != 0 {
27069 break
27070 }
27071 z := v_0.Args[0]
27072 if z.Op != OpARM64MSUBW {
27073 break
27074 }
27075 y := z.Args[2]
27076 a := z.Args[0]
27077 x := z.Args[1]
27078 if !(z.Uses == 1) {
27079 break
27080 }
27081 v0 := b.NewValue0(v_0.Pos, OpARM64CMPW, types.TypeFlags)
27082 v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
27083 v1.AddArg2(x, y)
27084 v0.AddArg2(a, v1)
27085 b.resetWithControl(block.BlockARM64NE, v0)
27086 return true
27087 }
27088
27089
27090
27091 for b.Controls[0].Op == OpARM64TSTconst {
27092 v_0 := b.Controls[0]
27093 c := auxIntToInt64(v_0.AuxInt)
27094 x := v_0.Args[0]
27095 if !(oneBit(c)) {
27096 break
27097 }
27098 b.resetWithControl(block.BlockARM64TBNZ, x)
27099 b.AuxInt = int64ToAuxInt(int64(ntz64(c)))
27100 return true
27101 }
27102
27103
27104
27105 for b.Controls[0].Op == OpARM64TSTWconst {
27106 v_0 := b.Controls[0]
27107 c := auxIntToInt32(v_0.AuxInt)
27108 x := v_0.Args[0]
27109 if !(oneBit(int64(uint32(c)))) {
27110 break
27111 }
27112 b.resetWithControl(block.BlockARM64TBNZ, x)
27113 b.AuxInt = int64ToAuxInt(int64(ntz64(int64(uint32(c)))))
27114 return true
27115 }
27116
27117
27118
27119 for b.Controls[0].Op == OpARM64FlagConstant {
27120 v_0 := b.Controls[0]
27121 fc := auxIntToFlagConstant(v_0.AuxInt)
27122 if !(fc.ne()) {
27123 break
27124 }
27125 b.Reset(block.BlockFirst)
27126 return true
27127 }
27128
27129
27130
27131 for b.Controls[0].Op == OpARM64FlagConstant {
27132 v_0 := b.Controls[0]
27133 fc := auxIntToFlagConstant(v_0.AuxInt)
27134 if !(!fc.ne()) {
27135 break
27136 }
27137 b.Reset(block.BlockFirst)
27138 b.swapSuccessors()
27139 return true
27140 }
27141
27142
27143 for b.Controls[0].Op == OpARM64InvertFlags {
27144 v_0 := b.Controls[0]
27145 cmp := v_0.Args[0]
27146 b.resetWithControl(block.BlockARM64NE, cmp)
27147 return true
27148 }
27149 case block.BlockARM64NZ:
27150
27151
27152 for b.Controls[0].Op == OpARM64Equal {
27153 v_0 := b.Controls[0]
27154 cc := v_0.Args[0]
27155 b.resetWithControl(block.BlockARM64EQ, cc)
27156 return true
27157 }
27158
27159
27160 for b.Controls[0].Op == OpARM64NotEqual {
27161 v_0 := b.Controls[0]
27162 cc := v_0.Args[0]
27163 b.resetWithControl(block.BlockARM64NE, cc)
27164 return true
27165 }
27166
27167
27168 for b.Controls[0].Op == OpARM64LessThan {
27169 v_0 := b.Controls[0]
27170 cc := v_0.Args[0]
27171 b.resetWithControl(block.BlockARM64LT, cc)
27172 return true
27173 }
27174
27175
27176 for b.Controls[0].Op == OpARM64LessThanU {
27177 v_0 := b.Controls[0]
27178 cc := v_0.Args[0]
27179 b.resetWithControl(block.BlockARM64ULT, cc)
27180 return true
27181 }
27182
27183
27184 for b.Controls[0].Op == OpARM64LessEqual {
27185 v_0 := b.Controls[0]
27186 cc := v_0.Args[0]
27187 b.resetWithControl(block.BlockARM64LE, cc)
27188 return true
27189 }
27190
27191
27192 for b.Controls[0].Op == OpARM64LessEqualU {
27193 v_0 := b.Controls[0]
27194 cc := v_0.Args[0]
27195 b.resetWithControl(block.BlockARM64ULE, cc)
27196 return true
27197 }
27198
27199
27200 for b.Controls[0].Op == OpARM64GreaterThan {
27201 v_0 := b.Controls[0]
27202 cc := v_0.Args[0]
27203 b.resetWithControl(block.BlockARM64GT, cc)
27204 return true
27205 }
27206
27207
27208 for b.Controls[0].Op == OpARM64GreaterThanU {
27209 v_0 := b.Controls[0]
27210 cc := v_0.Args[0]
27211 b.resetWithControl(block.BlockARM64UGT, cc)
27212 return true
27213 }
27214
27215
27216 for b.Controls[0].Op == OpARM64GreaterEqual {
27217 v_0 := b.Controls[0]
27218 cc := v_0.Args[0]
27219 b.resetWithControl(block.BlockARM64GE, cc)
27220 return true
27221 }
27222
27223
27224 for b.Controls[0].Op == OpARM64GreaterEqualU {
27225 v_0 := b.Controls[0]
27226 cc := v_0.Args[0]
27227 b.resetWithControl(block.BlockARM64UGE, cc)
27228 return true
27229 }
27230
27231
27232 for b.Controls[0].Op == OpARM64LessThanF {
27233 v_0 := b.Controls[0]
27234 cc := v_0.Args[0]
27235 b.resetWithControl(block.BlockARM64FLT, cc)
27236 return true
27237 }
27238
27239
27240 for b.Controls[0].Op == OpARM64LessEqualF {
27241 v_0 := b.Controls[0]
27242 cc := v_0.Args[0]
27243 b.resetWithControl(block.BlockARM64FLE, cc)
27244 return true
27245 }
27246
27247
27248 for b.Controls[0].Op == OpARM64GreaterThanF {
27249 v_0 := b.Controls[0]
27250 cc := v_0.Args[0]
27251 b.resetWithControl(block.BlockARM64FGT, cc)
27252 return true
27253 }
27254
27255
27256 for b.Controls[0].Op == OpARM64GreaterEqualF {
27257 v_0 := b.Controls[0]
27258 cc := v_0.Args[0]
27259 b.resetWithControl(block.BlockARM64FGE, cc)
27260 return true
27261 }
27262
27263
27264
27265 for b.Controls[0].Op == OpARM64SUB {
27266 sub := b.Controls[0]
27267 y := sub.Args[1]
27268 x := sub.Args[0]
27269 if !(sub.Uses == 1) {
27270 break
27271 }
27272 v0 := b.NewValue0(sub.Pos, OpARM64CMP, types.TypeFlags)
27273 v0.AddArg2(x, y)
27274 b.resetWithControl(block.BlockARM64NE, v0)
27275 return true
27276 }
27277
27278
27279
27280 for b.Controls[0].Op == OpARM64SUBconst {
27281 sub := b.Controls[0]
27282 c := auxIntToInt64(sub.AuxInt)
27283 y := sub.Args[0]
27284 if !(sub.Uses == 1) {
27285 break
27286 }
27287 v0 := b.NewValue0(sub.Pos, OpARM64CMPconst, types.TypeFlags)
27288 v0.AuxInt = int64ToAuxInt(c)
27289 v0.AddArg(y)
27290 b.resetWithControl(block.BlockARM64NE, v0)
27291 return true
27292 }
27293
27294
27295
27296 for b.Controls[0].Op == OpARM64ANDconst {
27297 v_0 := b.Controls[0]
27298 c := auxIntToInt64(v_0.AuxInt)
27299 x := v_0.Args[0]
27300 if !(oneBit(c)) {
27301 break
27302 }
27303 b.resetWithControl(block.BlockARM64TBNZ, x)
27304 b.AuxInt = int64ToAuxInt(int64(ntz64(c)))
27305 return true
27306 }
27307
27308
27309
27310 for b.Controls[0].Op == OpARM64SRLconst {
27311 s := b.Controls[0]
27312 if auxIntToInt64(s.AuxInt) != 63 {
27313 break
27314 }
27315 x := s.Args[0]
27316 if !(s.Uses == 1) {
27317 break
27318 }
27319 b.resetWithControl(block.BlockARM64TBNZ, x)
27320 b.AuxInt = int64ToAuxInt(63)
27321 return true
27322 }
27323
27324
27325
27326 for b.Controls[0].Op == OpARM64SRAconst {
27327 s := b.Controls[0]
27328 if auxIntToInt64(s.AuxInt) != 63 {
27329 break
27330 }
27331 x := s.Args[0]
27332 if !(s.Uses == 1) {
27333 break
27334 }
27335 b.resetWithControl(block.BlockARM64TBNZ, x)
27336 b.AuxInt = int64ToAuxInt(63)
27337 return true
27338 }
27339
27340
27341 for b.Controls[0].Op == OpARM64MOVDconst {
27342 v_0 := b.Controls[0]
27343 if auxIntToInt64(v_0.AuxInt) != 0 {
27344 break
27345 }
27346 b.Reset(block.BlockFirst)
27347 b.swapSuccessors()
27348 return true
27349 }
27350
27351
27352
27353 for b.Controls[0].Op == OpARM64MOVDconst {
27354 v_0 := b.Controls[0]
27355 c := auxIntToInt64(v_0.AuxInt)
27356 if !(c != 0) {
27357 break
27358 }
27359 b.Reset(block.BlockFirst)
27360 return true
27361 }
27362 case block.BlockARM64NZW:
27363
27364
27365
27366 for b.Controls[0].Op == OpARM64SUB {
27367 sub := b.Controls[0]
27368 y := sub.Args[1]
27369 x := sub.Args[0]
27370 if !(sub.Uses == 1) {
27371 break
27372 }
27373 v0 := b.NewValue0(sub.Pos, OpARM64CMPW, types.TypeFlags)
27374 v0.AddArg2(x, y)
27375 b.resetWithControl(block.BlockARM64NE, v0)
27376 return true
27377 }
27378
27379
27380
27381 for b.Controls[0].Op == OpARM64SUBconst {
27382 sub := b.Controls[0]
27383 c := auxIntToInt64(sub.AuxInt)
27384 y := sub.Args[0]
27385 if !(sub.Uses == 1) {
27386 break
27387 }
27388 v0 := b.NewValue0(sub.Pos, OpARM64CMPWconst, types.TypeFlags)
27389 v0.AuxInt = int32ToAuxInt(int32(c))
27390 v0.AddArg(y)
27391 b.resetWithControl(block.BlockARM64NE, v0)
27392 return true
27393 }
27394
27395
27396
27397 for b.Controls[0].Op == OpARM64ANDconst {
27398 v_0 := b.Controls[0]
27399 c := auxIntToInt64(v_0.AuxInt)
27400 x := v_0.Args[0]
27401 if !(oneBit(int64(uint32(c)))) {
27402 break
27403 }
27404 b.resetWithControl(block.BlockARM64TBNZ, x)
27405 b.AuxInt = int64ToAuxInt(int64(ntz64(int64(uint32(c)))))
27406 return true
27407 }
27408
27409
27410
27411 for b.Controls[0].Op == OpARM64MOVDconst {
27412 v_0 := b.Controls[0]
27413 c := auxIntToInt64(v_0.AuxInt)
27414 if !(int32(c) == 0) {
27415 break
27416 }
27417 b.Reset(block.BlockFirst)
27418 b.swapSuccessors()
27419 return true
27420 }
27421
27422
27423
27424 for b.Controls[0].Op == OpARM64MOVDconst {
27425 v_0 := b.Controls[0]
27426 c := auxIntToInt64(v_0.AuxInt)
27427 if !(int32(c) != 0) {
27428 break
27429 }
27430 b.Reset(block.BlockFirst)
27431 return true
27432 }
27433 case block.BlockARM64TBNZ:
27434
27435
27436 for b.Controls[0].Op == OpARM64Equal {
27437 v_0 := b.Controls[0]
27438 cc := v_0.Args[0]
27439 if auxIntToInt64(b.AuxInt) != 0 {
27440 break
27441 }
27442 b.resetWithControl(block.BlockARM64EQ, cc)
27443 return true
27444 }
27445
27446
27447 for b.Controls[0].Op == OpARM64NotEqual {
27448 v_0 := b.Controls[0]
27449 cc := v_0.Args[0]
27450 if auxIntToInt64(b.AuxInt) != 0 {
27451 break
27452 }
27453 b.resetWithControl(block.BlockARM64NE, cc)
27454 return true
27455 }
27456
27457
27458 for b.Controls[0].Op == OpARM64LessThan {
27459 v_0 := b.Controls[0]
27460 cc := v_0.Args[0]
27461 if auxIntToInt64(b.AuxInt) != 0 {
27462 break
27463 }
27464 b.resetWithControl(block.BlockARM64LT, cc)
27465 return true
27466 }
27467
27468
27469 for b.Controls[0].Op == OpARM64LessThanU {
27470 v_0 := b.Controls[0]
27471 cc := v_0.Args[0]
27472 if auxIntToInt64(b.AuxInt) != 0 {
27473 break
27474 }
27475 b.resetWithControl(block.BlockARM64ULT, cc)
27476 return true
27477 }
27478
27479
27480 for b.Controls[0].Op == OpARM64LessEqual {
27481 v_0 := b.Controls[0]
27482 cc := v_0.Args[0]
27483 if auxIntToInt64(b.AuxInt) != 0 {
27484 break
27485 }
27486 b.resetWithControl(block.BlockARM64LE, cc)
27487 return true
27488 }
27489
27490
27491 for b.Controls[0].Op == OpARM64LessEqualU {
27492 v_0 := b.Controls[0]
27493 cc := v_0.Args[0]
27494 if auxIntToInt64(b.AuxInt) != 0 {
27495 break
27496 }
27497 b.resetWithControl(block.BlockARM64ULE, cc)
27498 return true
27499 }
27500
27501
27502 for b.Controls[0].Op == OpARM64GreaterThan {
27503 v_0 := b.Controls[0]
27504 cc := v_0.Args[0]
27505 if auxIntToInt64(b.AuxInt) != 0 {
27506 break
27507 }
27508 b.resetWithControl(block.BlockARM64GT, cc)
27509 return true
27510 }
27511
27512
27513 for b.Controls[0].Op == OpARM64GreaterThanU {
27514 v_0 := b.Controls[0]
27515 cc := v_0.Args[0]
27516 if auxIntToInt64(b.AuxInt) != 0 {
27517 break
27518 }
27519 b.resetWithControl(block.BlockARM64UGT, cc)
27520 return true
27521 }
27522
27523
27524 for b.Controls[0].Op == OpARM64GreaterEqual {
27525 v_0 := b.Controls[0]
27526 cc := v_0.Args[0]
27527 if auxIntToInt64(b.AuxInt) != 0 {
27528 break
27529 }
27530 b.resetWithControl(block.BlockARM64GE, cc)
27531 return true
27532 }
27533
27534
27535 for b.Controls[0].Op == OpARM64GreaterEqualU {
27536 v_0 := b.Controls[0]
27537 cc := v_0.Args[0]
27538 if auxIntToInt64(b.AuxInt) != 0 {
27539 break
27540 }
27541 b.resetWithControl(block.BlockARM64UGE, cc)
27542 return true
27543 }
27544
27545
27546 for b.Controls[0].Op == OpARM64LessThanF {
27547 v_0 := b.Controls[0]
27548 cc := v_0.Args[0]
27549 if auxIntToInt64(b.AuxInt) != 0 {
27550 break
27551 }
27552 b.resetWithControl(block.BlockARM64FLT, cc)
27553 return true
27554 }
27555
27556
27557 for b.Controls[0].Op == OpARM64LessEqualF {
27558 v_0 := b.Controls[0]
27559 cc := v_0.Args[0]
27560 if auxIntToInt64(b.AuxInt) != 0 {
27561 break
27562 }
27563 b.resetWithControl(block.BlockARM64FLE, cc)
27564 return true
27565 }
27566
27567
27568 for b.Controls[0].Op == OpARM64GreaterThanF {
27569 v_0 := b.Controls[0]
27570 cc := v_0.Args[0]
27571 if auxIntToInt64(b.AuxInt) != 0 {
27572 break
27573 }
27574 b.resetWithControl(block.BlockARM64FGT, cc)
27575 return true
27576 }
27577
27578
27579 for b.Controls[0].Op == OpARM64GreaterEqualF {
27580 v_0 := b.Controls[0]
27581 cc := v_0.Args[0]
27582 if auxIntToInt64(b.AuxInt) != 0 {
27583 break
27584 }
27585 b.resetWithControl(block.BlockARM64FGE, cc)
27586 return true
27587 }
27588
27589
27590 for b.Controls[0].Op == OpARM64XORconst {
27591 v_0 := b.Controls[0]
27592 if auxIntToInt64(v_0.AuxInt) != 1 {
27593 break
27594 }
27595 x := v_0.Args[0]
27596 if auxIntToInt64(b.AuxInt) != 0 {
27597 break
27598 }
27599 b.resetWithControl(block.BlockARM64TBZ, x)
27600 b.AuxInt = int64ToAuxInt(0)
27601 return true
27602 }
27603
27604
27605
27606 for b.Controls[0].Op == OpARM64SRLconst {
27607 sv := b.Controls[0]
27608 s := auxIntToInt64(sv.AuxInt)
27609 x := sv.Args[0]
27610 t := auxIntToInt64(b.AuxInt)
27611 if !(t+s < 64 && sv.Uses == 1) {
27612 break
27613 }
27614 b.resetWithControl(block.BlockARM64TBNZ, x)
27615 b.AuxInt = int64ToAuxInt(t + s)
27616 return true
27617 }
27618
27619
27620
27621 for b.Controls[0].Op == OpARM64SRLconst {
27622 v_0 := b.Controls[0]
27623 s := auxIntToInt64(v_0.AuxInt)
27624 t := auxIntToInt64(b.AuxInt)
27625 if !(t+s >= 64) {
27626 break
27627 }
27628 b.Reset(block.BlockFirst)
27629 b.swapSuccessors()
27630 return true
27631 }
27632
27633
27634
27635 for b.Controls[0].Op == OpARM64SLLconst {
27636 sv := b.Controls[0]
27637 s := auxIntToInt64(sv.AuxInt)
27638 x := sv.Args[0]
27639 t := auxIntToInt64(b.AuxInt)
27640 if !(t-s >= 0 && sv.Uses == 1) {
27641 break
27642 }
27643 b.resetWithControl(block.BlockARM64TBNZ, x)
27644 b.AuxInt = int64ToAuxInt(t - s)
27645 return true
27646 }
27647
27648
27649
27650 for b.Controls[0].Op == OpARM64SLLconst {
27651 v_0 := b.Controls[0]
27652 s := auxIntToInt64(v_0.AuxInt)
27653 t := auxIntToInt64(b.AuxInt)
27654 if !(t-s < 0) {
27655 break
27656 }
27657 b.Reset(block.BlockFirst)
27658 b.swapSuccessors()
27659 return true
27660 }
27661
27662
27663
27664 for b.Controls[0].Op == OpARM64RORconst {
27665 rv := b.Controls[0]
27666 r := auxIntToInt64(rv.AuxInt)
27667 x := rv.Args[0]
27668 t := auxIntToInt64(b.AuxInt)
27669 if !(rv.Uses == 1) {
27670 break
27671 }
27672 b.resetWithControl(block.BlockARM64TBNZ, x)
27673 b.AuxInt = int64ToAuxInt(int64(uint64(t+r) % 64))
27674 return true
27675 }
27676
27677
27678
27679 for b.Controls[0].Op == OpARM64SRAconst {
27680 sv := b.Controls[0]
27681 s := auxIntToInt64(sv.AuxInt)
27682 x := sv.Args[0]
27683 t := auxIntToInt64(b.AuxInt)
27684 if !(t+s < 64 && sv.Uses == 1) {
27685 break
27686 }
27687 b.resetWithControl(block.BlockARM64TBNZ, x)
27688 b.AuxInt = int64ToAuxInt(t + s)
27689 return true
27690 }
27691
27692
27693
27694 for b.Controls[0].Op == OpARM64SRAconst {
27695 sv := b.Controls[0]
27696 s := auxIntToInt64(sv.AuxInt)
27697 x := sv.Args[0]
27698 t := auxIntToInt64(b.AuxInt)
27699 if !(t+s >= 64 && sv.Uses == 1) {
27700 break
27701 }
27702 b.resetWithControl(block.BlockARM64TBNZ, x)
27703 b.AuxInt = int64ToAuxInt(63)
27704 return true
27705 }
27706 case block.BlockARM64TBZ:
27707
27708
27709 for b.Controls[0].Op == OpARM64XORconst {
27710 v_0 := b.Controls[0]
27711 if auxIntToInt64(v_0.AuxInt) != 1 {
27712 break
27713 }
27714 x := v_0.Args[0]
27715 if auxIntToInt64(b.AuxInt) != 0 {
27716 break
27717 }
27718 b.resetWithControl(block.BlockARM64TBNZ, x)
27719 b.AuxInt = int64ToAuxInt(0)
27720 return true
27721 }
27722
27723
27724
27725 for b.Controls[0].Op == OpARM64SRLconst {
27726 sv := b.Controls[0]
27727 s := auxIntToInt64(sv.AuxInt)
27728 x := sv.Args[0]
27729 t := auxIntToInt64(b.AuxInt)
27730 if !(t+s < 64 && sv.Uses == 1) {
27731 break
27732 }
27733 b.resetWithControl(block.BlockARM64TBZ, x)
27734 b.AuxInt = int64ToAuxInt(t + s)
27735 return true
27736 }
27737
27738
27739
27740 for b.Controls[0].Op == OpARM64SRLconst {
27741 v_0 := b.Controls[0]
27742 s := auxIntToInt64(v_0.AuxInt)
27743 t := auxIntToInt64(b.AuxInt)
27744 if !(t+s >= 64) {
27745 break
27746 }
27747 b.Reset(block.BlockFirst)
27748 return true
27749 }
27750
27751
27752
27753 for b.Controls[0].Op == OpARM64SLLconst {
27754 sv := b.Controls[0]
27755 s := auxIntToInt64(sv.AuxInt)
27756 x := sv.Args[0]
27757 t := auxIntToInt64(b.AuxInt)
27758 if !(t-s >= 0 && sv.Uses == 1) {
27759 break
27760 }
27761 b.resetWithControl(block.BlockARM64TBZ, x)
27762 b.AuxInt = int64ToAuxInt(t - s)
27763 return true
27764 }
27765
27766
27767
27768 for b.Controls[0].Op == OpARM64SLLconst {
27769 v_0 := b.Controls[0]
27770 s := auxIntToInt64(v_0.AuxInt)
27771 t := auxIntToInt64(b.AuxInt)
27772 if !(t-s < 0) {
27773 break
27774 }
27775 b.Reset(block.BlockFirst)
27776 return true
27777 }
27778
27779
27780
27781 for b.Controls[0].Op == OpARM64RORconst {
27782 rv := b.Controls[0]
27783 r := auxIntToInt64(rv.AuxInt)
27784 x := rv.Args[0]
27785 t := auxIntToInt64(b.AuxInt)
27786 if !(rv.Uses == 1) {
27787 break
27788 }
27789 b.resetWithControl(block.BlockARM64TBZ, x)
27790 b.AuxInt = int64ToAuxInt(int64(uint64(t+r) % 64))
27791 return true
27792 }
27793
27794
27795
27796 for b.Controls[0].Op == OpARM64SRAconst {
27797 sv := b.Controls[0]
27798 s := auxIntToInt64(sv.AuxInt)
27799 x := sv.Args[0]
27800 t := auxIntToInt64(b.AuxInt)
27801 if !(t+s < 64 && sv.Uses == 1) {
27802 break
27803 }
27804 b.resetWithControl(block.BlockARM64TBZ, x)
27805 b.AuxInt = int64ToAuxInt(t + s)
27806 return true
27807 }
27808
27809
27810
27811 for b.Controls[0].Op == OpARM64SRAconst {
27812 sv := b.Controls[0]
27813 s := auxIntToInt64(sv.AuxInt)
27814 x := sv.Args[0]
27815 t := auxIntToInt64(b.AuxInt)
27816 if !(t+s >= 64 && sv.Uses == 1) {
27817 break
27818 }
27819 b.resetWithControl(block.BlockARM64TBZ, x)
27820 b.AuxInt = int64ToAuxInt(63)
27821 return true
27822 }
27823 case block.BlockARM64UGE:
27824
27825
27826
27827 for b.Controls[0].Op == OpARM64CMPWconst {
27828 v_0 := b.Controls[0]
27829 if auxIntToInt32(v_0.AuxInt) != 128 {
27830 break
27831 }
27832 x := v_0.Args[0]
27833 if !(ZeroUpper56Bits(x)) {
27834 break
27835 }
27836 b.resetWithControl(block.BlockARM64TBNZ, x)
27837 b.AuxInt = int64ToAuxInt(7)
27838 return true
27839 }
27840
27841
27842
27843 for b.Controls[0].Op == OpARM64CMPconst {
27844 v_0 := b.Controls[0]
27845 if auxIntToInt64(v_0.AuxInt) != 128 {
27846 break
27847 }
27848 x := v_0.Args[0]
27849 if !(ZeroUpper56Bits(x)) {
27850 break
27851 }
27852 b.resetWithControl(block.BlockARM64TBNZ, x)
27853 b.AuxInt = int64ToAuxInt(7)
27854 return true
27855 }
27856
27857
27858
27859 for b.Controls[0].Op == OpARM64FlagConstant {
27860 v_0 := b.Controls[0]
27861 fc := auxIntToFlagConstant(v_0.AuxInt)
27862 if !(fc.uge()) {
27863 break
27864 }
27865 b.Reset(block.BlockFirst)
27866 return true
27867 }
27868
27869
27870
27871 for b.Controls[0].Op == OpARM64FlagConstant {
27872 v_0 := b.Controls[0]
27873 fc := auxIntToFlagConstant(v_0.AuxInt)
27874 if !(!fc.uge()) {
27875 break
27876 }
27877 b.Reset(block.BlockFirst)
27878 b.swapSuccessors()
27879 return true
27880 }
27881
27882
27883 for b.Controls[0].Op == OpARM64InvertFlags {
27884 v_0 := b.Controls[0]
27885 cmp := v_0.Args[0]
27886 b.resetWithControl(block.BlockARM64ULE, cmp)
27887 return true
27888 }
27889 case block.BlockARM64UGT:
27890
27891
27892 for b.Controls[0].Op == OpARM64CMPconst {
27893 v_0 := b.Controls[0]
27894 if auxIntToInt64(v_0.AuxInt) != 0 {
27895 break
27896 }
27897 x := v_0.Args[0]
27898 v0 := b.NewValue0(v_0.Pos, OpARM64CMPconst, types.TypeFlags)
27899 v0.AuxInt = int64ToAuxInt(0)
27900 v0.AddArg(x)
27901 b.resetWithControl(block.BlockARM64NE, v0)
27902 return true
27903 }
27904
27905
27906 for b.Controls[0].Op == OpARM64CMPWconst {
27907 v_0 := b.Controls[0]
27908 if auxIntToInt32(v_0.AuxInt) != 0 {
27909 break
27910 }
27911 x := v_0.Args[0]
27912 v0 := b.NewValue0(v_0.Pos, OpARM64CMPWconst, types.TypeFlags)
27913 v0.AuxInt = int32ToAuxInt(0)
27914 v0.AddArg(x)
27915 b.resetWithControl(block.BlockARM64NE, v0)
27916 return true
27917 }
27918
27919
27920
27921 for b.Controls[0].Op == OpARM64FlagConstant {
27922 v_0 := b.Controls[0]
27923 fc := auxIntToFlagConstant(v_0.AuxInt)
27924 if !(fc.ugt()) {
27925 break
27926 }
27927 b.Reset(block.BlockFirst)
27928 return true
27929 }
27930
27931
27932
27933 for b.Controls[0].Op == OpARM64FlagConstant {
27934 v_0 := b.Controls[0]
27935 fc := auxIntToFlagConstant(v_0.AuxInt)
27936 if !(!fc.ugt()) {
27937 break
27938 }
27939 b.Reset(block.BlockFirst)
27940 b.swapSuccessors()
27941 return true
27942 }
27943
27944
27945 for b.Controls[0].Op == OpARM64InvertFlags {
27946 v_0 := b.Controls[0]
27947 cmp := v_0.Args[0]
27948 b.resetWithControl(block.BlockARM64ULT, cmp)
27949 return true
27950 }
27951 case block.BlockARM64ULE:
27952
27953
27954 for b.Controls[0].Op == OpARM64CMPconst {
27955 v_0 := b.Controls[0]
27956 if auxIntToInt64(v_0.AuxInt) != 0 {
27957 break
27958 }
27959 x := v_0.Args[0]
27960 v0 := b.NewValue0(v_0.Pos, OpARM64CMPconst, types.TypeFlags)
27961 v0.AuxInt = int64ToAuxInt(0)
27962 v0.AddArg(x)
27963 b.resetWithControl(block.BlockARM64EQ, v0)
27964 return true
27965 }
27966
27967
27968 for b.Controls[0].Op == OpARM64CMPWconst {
27969 v_0 := b.Controls[0]
27970 if auxIntToInt32(v_0.AuxInt) != 0 {
27971 break
27972 }
27973 x := v_0.Args[0]
27974 v0 := b.NewValue0(v_0.Pos, OpARM64CMPWconst, types.TypeFlags)
27975 v0.AuxInt = int32ToAuxInt(0)
27976 v0.AddArg(x)
27977 b.resetWithControl(block.BlockARM64EQ, v0)
27978 return true
27979 }
27980
27981
27982
27983 for b.Controls[0].Op == OpARM64FlagConstant {
27984 v_0 := b.Controls[0]
27985 fc := auxIntToFlagConstant(v_0.AuxInt)
27986 if !(fc.ule()) {
27987 break
27988 }
27989 b.Reset(block.BlockFirst)
27990 return true
27991 }
27992
27993
27994
27995 for b.Controls[0].Op == OpARM64FlagConstant {
27996 v_0 := b.Controls[0]
27997 fc := auxIntToFlagConstant(v_0.AuxInt)
27998 if !(!fc.ule()) {
27999 break
28000 }
28001 b.Reset(block.BlockFirst)
28002 b.swapSuccessors()
28003 return true
28004 }
28005
28006
28007 for b.Controls[0].Op == OpARM64InvertFlags {
28008 v_0 := b.Controls[0]
28009 cmp := v_0.Args[0]
28010 b.resetWithControl(block.BlockARM64UGE, cmp)
28011 return true
28012 }
28013 case block.BlockARM64ULT:
28014
28015
28016
28017 for b.Controls[0].Op == OpARM64CMPWconst {
28018 v_0 := b.Controls[0]
28019 if auxIntToInt32(v_0.AuxInt) != 128 {
28020 break
28021 }
28022 x := v_0.Args[0]
28023 if !(ZeroUpper56Bits(x)) {
28024 break
28025 }
28026 b.resetWithControl(block.BlockARM64TBZ, x)
28027 b.AuxInt = int64ToAuxInt(7)
28028 return true
28029 }
28030
28031
28032
28033 for b.Controls[0].Op == OpARM64CMPconst {
28034 v_0 := b.Controls[0]
28035 if auxIntToInt64(v_0.AuxInt) != 128 {
28036 break
28037 }
28038 x := v_0.Args[0]
28039 if !(ZeroUpper56Bits(x)) {
28040 break
28041 }
28042 b.resetWithControl(block.BlockARM64TBZ, x)
28043 b.AuxInt = int64ToAuxInt(7)
28044 return true
28045 }
28046
28047
28048
28049 for b.Controls[0].Op == OpARM64FlagConstant {
28050 v_0 := b.Controls[0]
28051 fc := auxIntToFlagConstant(v_0.AuxInt)
28052 if !(fc.ult()) {
28053 break
28054 }
28055 b.Reset(block.BlockFirst)
28056 return true
28057 }
28058
28059
28060
28061 for b.Controls[0].Op == OpARM64FlagConstant {
28062 v_0 := b.Controls[0]
28063 fc := auxIntToFlagConstant(v_0.AuxInt)
28064 if !(!fc.ult()) {
28065 break
28066 }
28067 b.Reset(block.BlockFirst)
28068 b.swapSuccessors()
28069 return true
28070 }
28071
28072
28073 for b.Controls[0].Op == OpARM64InvertFlags {
28074 v_0 := b.Controls[0]
28075 cmp := v_0.Args[0]
28076 b.resetWithControl(block.BlockARM64UGT, cmp)
28077 return true
28078 }
28079 case block.BlockARM64Z:
28080
28081
28082
28083 for b.Controls[0].Op == OpARM64SUB {
28084 sub := b.Controls[0]
28085 y := sub.Args[1]
28086 x := sub.Args[0]
28087 if !(sub.Uses == 1) {
28088 break
28089 }
28090 v0 := b.NewValue0(sub.Pos, OpARM64CMP, types.TypeFlags)
28091 v0.AddArg2(x, y)
28092 b.resetWithControl(block.BlockARM64EQ, v0)
28093 return true
28094 }
28095
28096
28097
28098 for b.Controls[0].Op == OpARM64SUBconst {
28099 sub := b.Controls[0]
28100 c := auxIntToInt64(sub.AuxInt)
28101 y := sub.Args[0]
28102 if !(sub.Uses == 1) {
28103 break
28104 }
28105 v0 := b.NewValue0(sub.Pos, OpARM64CMPconst, types.TypeFlags)
28106 v0.AuxInt = int64ToAuxInt(c)
28107 v0.AddArg(y)
28108 b.resetWithControl(block.BlockARM64EQ, v0)
28109 return true
28110 }
28111
28112
28113
28114 for b.Controls[0].Op == OpARM64ANDconst {
28115 v_0 := b.Controls[0]
28116 c := auxIntToInt64(v_0.AuxInt)
28117 x := v_0.Args[0]
28118 if !(oneBit(c)) {
28119 break
28120 }
28121 b.resetWithControl(block.BlockARM64TBZ, x)
28122 b.AuxInt = int64ToAuxInt(int64(ntz64(c)))
28123 return true
28124 }
28125
28126
28127
28128 for b.Controls[0].Op == OpARM64SRLconst {
28129 s := b.Controls[0]
28130 if auxIntToInt64(s.AuxInt) != 63 {
28131 break
28132 }
28133 x := s.Args[0]
28134 if !(s.Uses == 1) {
28135 break
28136 }
28137 b.resetWithControl(block.BlockARM64TBZ, x)
28138 b.AuxInt = int64ToAuxInt(63)
28139 return true
28140 }
28141
28142
28143
28144 for b.Controls[0].Op == OpARM64SRAconst {
28145 s := b.Controls[0]
28146 if auxIntToInt64(s.AuxInt) != 63 {
28147 break
28148 }
28149 x := s.Args[0]
28150 if !(s.Uses == 1) {
28151 break
28152 }
28153 b.resetWithControl(block.BlockARM64TBZ, x)
28154 b.AuxInt = int64ToAuxInt(63)
28155 return true
28156 }
28157
28158
28159 for b.Controls[0].Op == OpARM64MOVDconst {
28160 v_0 := b.Controls[0]
28161 if auxIntToInt64(v_0.AuxInt) != 0 {
28162 break
28163 }
28164 b.Reset(block.BlockFirst)
28165 return true
28166 }
28167
28168
28169
28170 for b.Controls[0].Op == OpARM64MOVDconst {
28171 v_0 := b.Controls[0]
28172 c := auxIntToInt64(v_0.AuxInt)
28173 if !(c != 0) {
28174 break
28175 }
28176 b.Reset(block.BlockFirst)
28177 b.swapSuccessors()
28178 return true
28179 }
28180 case block.BlockARM64ZW:
28181
28182
28183
28184 for b.Controls[0].Op == OpARM64SUB {
28185 sub := b.Controls[0]
28186 y := sub.Args[1]
28187 x := sub.Args[0]
28188 if !(sub.Uses == 1) {
28189 break
28190 }
28191 v0 := b.NewValue0(sub.Pos, OpARM64CMPW, types.TypeFlags)
28192 v0.AddArg2(x, y)
28193 b.resetWithControl(block.BlockARM64EQ, v0)
28194 return true
28195 }
28196
28197
28198
28199 for b.Controls[0].Op == OpARM64SUBconst {
28200 sub := b.Controls[0]
28201 c := auxIntToInt64(sub.AuxInt)
28202 y := sub.Args[0]
28203 if !(sub.Uses == 1) {
28204 break
28205 }
28206 v0 := b.NewValue0(sub.Pos, OpARM64CMPWconst, types.TypeFlags)
28207 v0.AuxInt = int32ToAuxInt(int32(c))
28208 v0.AddArg(y)
28209 b.resetWithControl(block.BlockARM64EQ, v0)
28210 return true
28211 }
28212
28213
28214
28215 for b.Controls[0].Op == OpARM64ANDconst {
28216 v_0 := b.Controls[0]
28217 c := auxIntToInt64(v_0.AuxInt)
28218 x := v_0.Args[0]
28219 if !(oneBit(int64(uint32(c)))) {
28220 break
28221 }
28222 b.resetWithControl(block.BlockARM64TBZ, x)
28223 b.AuxInt = int64ToAuxInt(int64(ntz64(int64(uint32(c)))))
28224 return true
28225 }
28226
28227
28228
28229 for b.Controls[0].Op == OpARM64MOVDconst {
28230 v_0 := b.Controls[0]
28231 c := auxIntToInt64(v_0.AuxInt)
28232 if !(int32(c) == 0) {
28233 break
28234 }
28235 b.Reset(block.BlockFirst)
28236 return true
28237 }
28238
28239
28240
28241 for b.Controls[0].Op == OpARM64MOVDconst {
28242 v_0 := b.Controls[0]
28243 c := auxIntToInt64(v_0.AuxInt)
28244 if !(int32(c) != 0) {
28245 break
28246 }
28247 b.Reset(block.BlockFirst)
28248 b.swapSuccessors()
28249 return true
28250 }
28251 }
28252 return false
28253 }
28254
View as plain text