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 OpAddInt8x16:
571 v.Op = OpARM64VADD16B
572 return true
573 case OpAddPtr:
574 v.Op = OpARM64ADD
575 return true
576 case OpAddSaturatedInt16x8:
577 v.Op = OpARM64VSQADD8H
578 return true
579 case OpAddSaturatedInt32x4:
580 v.Op = OpARM64VSQADD4S
581 return true
582 case OpAddSaturatedInt64x2:
583 v.Op = OpARM64VSQADD2D
584 return true
585 case OpAddSaturatedInt8x16:
586 v.Op = OpARM64VSQADD16B
587 return true
588 case OpAddSaturatedUint16x8:
589 v.Op = OpARM64VUQADD8H
590 return true
591 case OpAddSaturatedUint32x4:
592 v.Op = OpARM64VUQADD4S
593 return true
594 case OpAddSaturatedUint64x2:
595 v.Op = OpARM64VUQADD2D
596 return true
597 case OpAddSaturatedUint8x16:
598 v.Op = OpARM64VUQADD16B
599 return true
600 case OpAddUint16x8:
601 v.Op = OpARM64VADD8H
602 return true
603 case OpAddUint32x4:
604 v.Op = OpARM64VADD4S
605 return true
606 case OpAddUint64x2:
607 v.Op = OpARM64VADD2D
608 return true
609 case OpAddUint8x16:
610 v.Op = OpARM64VADD16B
611 return true
612 case OpAddr:
613 return rewriteValueARM64_OpAddr(v)
614 case OpAnd16:
615 v.Op = OpARM64AND
616 return true
617 case OpAnd32:
618 v.Op = OpARM64AND
619 return true
620 case OpAnd64:
621 v.Op = OpARM64AND
622 return true
623 case OpAnd8:
624 v.Op = OpARM64AND
625 return true
626 case OpAndB:
627 v.Op = OpARM64AND
628 return true
629 case OpAndInt16x8:
630 v.Op = OpARM64VAND16B
631 return true
632 case OpAndInt32x4:
633 v.Op = OpARM64VAND16B
634 return true
635 case OpAndInt64x2:
636 v.Op = OpARM64VAND16B
637 return true
638 case OpAndInt8x16:
639 v.Op = OpARM64VAND16B
640 return true
641 case OpAndNotInt16x8:
642 v.Op = OpARM64VBIC16B
643 return true
644 case OpAndNotInt32x4:
645 v.Op = OpARM64VBIC16B
646 return true
647 case OpAndNotInt64x2:
648 v.Op = OpARM64VBIC16B
649 return true
650 case OpAndNotInt8x16:
651 v.Op = OpARM64VBIC16B
652 return true
653 case OpAndNotUint16x8:
654 v.Op = OpARM64VBIC16B
655 return true
656 case OpAndNotUint32x4:
657 v.Op = OpARM64VBIC16B
658 return true
659 case OpAndNotUint64x2:
660 v.Op = OpARM64VBIC16B
661 return true
662 case OpAndNotUint8x16:
663 v.Op = OpARM64VBIC16B
664 return true
665 case OpAndUint16x8:
666 v.Op = OpARM64VAND16B
667 return true
668 case OpAndUint32x4:
669 v.Op = OpARM64VAND16B
670 return true
671 case OpAndUint64x2:
672 v.Op = OpARM64VAND16B
673 return true
674 case OpAndUint8x16:
675 v.Op = OpARM64VAND16B
676 return true
677 case OpAtomicAdd32:
678 v.Op = OpARM64LoweredAtomicAdd32
679 return true
680 case OpAtomicAdd32Variant:
681 v.Op = OpARM64LoweredAtomicAdd32Variant
682 return true
683 case OpAtomicAdd64:
684 v.Op = OpARM64LoweredAtomicAdd64
685 return true
686 case OpAtomicAdd64Variant:
687 v.Op = OpARM64LoweredAtomicAdd64Variant
688 return true
689 case OpAtomicAnd32value:
690 v.Op = OpARM64LoweredAtomicAnd32
691 return true
692 case OpAtomicAnd32valueVariant:
693 v.Op = OpARM64LoweredAtomicAnd32Variant
694 return true
695 case OpAtomicAnd64value:
696 v.Op = OpARM64LoweredAtomicAnd64
697 return true
698 case OpAtomicAnd64valueVariant:
699 v.Op = OpARM64LoweredAtomicAnd64Variant
700 return true
701 case OpAtomicAnd8value:
702 v.Op = OpARM64LoweredAtomicAnd8
703 return true
704 case OpAtomicAnd8valueVariant:
705 v.Op = OpARM64LoweredAtomicAnd8Variant
706 return true
707 case OpAtomicCompareAndSwap32:
708 v.Op = OpARM64LoweredAtomicCas32
709 return true
710 case OpAtomicCompareAndSwap32Variant:
711 v.Op = OpARM64LoweredAtomicCas32Variant
712 return true
713 case OpAtomicCompareAndSwap64:
714 v.Op = OpARM64LoweredAtomicCas64
715 return true
716 case OpAtomicCompareAndSwap64Variant:
717 v.Op = OpARM64LoweredAtomicCas64Variant
718 return true
719 case OpAtomicExchange32:
720 v.Op = OpARM64LoweredAtomicExchange32
721 return true
722 case OpAtomicExchange32Variant:
723 v.Op = OpARM64LoweredAtomicExchange32Variant
724 return true
725 case OpAtomicExchange64:
726 v.Op = OpARM64LoweredAtomicExchange64
727 return true
728 case OpAtomicExchange64Variant:
729 v.Op = OpARM64LoweredAtomicExchange64Variant
730 return true
731 case OpAtomicExchange8:
732 v.Op = OpARM64LoweredAtomicExchange8
733 return true
734 case OpAtomicExchange8Variant:
735 v.Op = OpARM64LoweredAtomicExchange8Variant
736 return true
737 case OpAtomicLoad32:
738 v.Op = OpARM64LDARW
739 return true
740 case OpAtomicLoad64:
741 v.Op = OpARM64LDAR
742 return true
743 case OpAtomicLoad8:
744 v.Op = OpARM64LDARB
745 return true
746 case OpAtomicLoadPtr:
747 v.Op = OpARM64LDAR
748 return true
749 case OpAtomicOr32value:
750 v.Op = OpARM64LoweredAtomicOr32
751 return true
752 case OpAtomicOr32valueVariant:
753 v.Op = OpARM64LoweredAtomicOr32Variant
754 return true
755 case OpAtomicOr64value:
756 v.Op = OpARM64LoweredAtomicOr64
757 return true
758 case OpAtomicOr64valueVariant:
759 v.Op = OpARM64LoweredAtomicOr64Variant
760 return true
761 case OpAtomicOr8value:
762 v.Op = OpARM64LoweredAtomicOr8
763 return true
764 case OpAtomicOr8valueVariant:
765 v.Op = OpARM64LoweredAtomicOr8Variant
766 return true
767 case OpAtomicStore32:
768 v.Op = OpARM64STLRW
769 return true
770 case OpAtomicStore64:
771 v.Op = OpARM64STLR
772 return true
773 case OpAtomicStore8:
774 v.Op = OpARM64STLRB
775 return true
776 case OpAtomicStorePtrNoWB:
777 v.Op = OpARM64STLR
778 return true
779 case OpAverageInt16x8:
780 v.Op = OpARM64VSRHADD8H
781 return true
782 case OpAverageInt32x4:
783 v.Op = OpARM64VSRHADD4S
784 return true
785 case OpAverageInt8x16:
786 v.Op = OpARM64VSRHADD16B
787 return true
788 case OpAverageUint16x8:
789 v.Op = OpARM64VURHADD8H
790 return true
791 case OpAverageUint32x4:
792 v.Op = OpARM64VURHADD4S
793 return true
794 case OpAverageUint8x16:
795 v.Op = OpARM64VURHADD16B
796 return true
797 case OpAvg64u:
798 return rewriteValueARM64_OpAvg64u(v)
799 case OpBitLen16:
800 return rewriteValueARM64_OpBitLen16(v)
801 case OpBitLen32:
802 return rewriteValueARM64_OpBitLen32(v)
803 case OpBitLen64:
804 return rewriteValueARM64_OpBitLen64(v)
805 case OpBitLen8:
806 return rewriteValueARM64_OpBitLen8(v)
807 case OpBitRev16:
808 return rewriteValueARM64_OpBitRev16(v)
809 case OpBitRev32:
810 v.Op = OpARM64RBITW
811 return true
812 case OpBitRev64:
813 v.Op = OpARM64RBIT
814 return true
815 case OpBitRev8:
816 return rewriteValueARM64_OpBitRev8(v)
817 case OpBswap16:
818 v.Op = OpARM64REV16W
819 return true
820 case OpBswap32:
821 v.Op = OpARM64REVW
822 return true
823 case OpBswap64:
824 v.Op = OpARM64REV
825 return true
826 case OpCeil:
827 v.Op = OpARM64FRINTPD
828 return true
829 case OpCeilFloat32x4:
830 v.Op = OpARM64VFRINTP4S
831 return true
832 case OpCeilFloat64x2:
833 v.Op = OpARM64VFRINTP2D
834 return true
835 case OpClosureCall:
836 v.Op = OpARM64CALLclosure
837 return true
838 case OpCom16:
839 v.Op = OpARM64MVN
840 return true
841 case OpCom32:
842 v.Op = OpARM64MVN
843 return true
844 case OpCom64:
845 v.Op = OpARM64MVN
846 return true
847 case OpCom8:
848 v.Op = OpARM64MVN
849 return true
850 case OpConcatAddPairsFloat32x4:
851 v.Op = OpARM64VFADDP4S
852 return true
853 case OpConcatAddPairsFloat64x2:
854 v.Op = OpARM64VFADDP2D
855 return true
856 case OpConcatAddPairsInt16x8:
857 v.Op = OpARM64VADDP8H
858 return true
859 case OpConcatAddPairsInt32x4:
860 v.Op = OpARM64VADDP4S
861 return true
862 case OpConcatAddPairsInt64x2:
863 v.Op = OpARM64VADDP2D
864 return true
865 case OpConcatAddPairsUint16x8:
866 v.Op = OpARM64VADDP8H
867 return true
868 case OpConcatAddPairsUint32x4:
869 v.Op = OpARM64VADDP4S
870 return true
871 case OpConcatAddPairsUint64x2:
872 v.Op = OpARM64VADDP2D
873 return true
874 case OpConcatEvenInt16x8:
875 v.Op = OpARM64VUZP18H
876 return true
877 case OpConcatEvenInt32x4:
878 v.Op = OpARM64VUZP14S
879 return true
880 case OpConcatEvenInt64x2:
881 v.Op = OpARM64VUZP12D
882 return true
883 case OpConcatEvenInt8x16:
884 v.Op = OpARM64VUZP116B
885 return true
886 case OpConcatEvenUint16x8:
887 v.Op = OpARM64VUZP18H
888 return true
889 case OpConcatEvenUint32x4:
890 v.Op = OpARM64VUZP14S
891 return true
892 case OpConcatEvenUint64x2:
893 v.Op = OpARM64VUZP12D
894 return true
895 case OpConcatEvenUint8x16:
896 v.Op = OpARM64VUZP116B
897 return true
898 case OpConcatOddInt16x8:
899 v.Op = OpARM64VUZP28H
900 return true
901 case OpConcatOddInt32x4:
902 v.Op = OpARM64VUZP24S
903 return true
904 case OpConcatOddInt64x2:
905 v.Op = OpARM64VUZP22D
906 return true
907 case OpConcatOddInt8x16:
908 v.Op = OpARM64VUZP216B
909 return true
910 case OpConcatOddUint16x8:
911 v.Op = OpARM64VUZP28H
912 return true
913 case OpConcatOddUint32x4:
914 v.Op = OpARM64VUZP24S
915 return true
916 case OpConcatOddUint64x2:
917 v.Op = OpARM64VUZP22D
918 return true
919 case OpConcatOddUint8x16:
920 v.Op = OpARM64VUZP216B
921 return true
922 case OpConcatShiftBytesRightUint8x16:
923 v.Op = OpARM64VEXT16B
924 return true
925 case OpCondSelect:
926 return rewriteValueARM64_OpCondSelect(v)
927 case OpConst16:
928 return rewriteValueARM64_OpConst16(v)
929 case OpConst32:
930 return rewriteValueARM64_OpConst32(v)
931 case OpConst32F:
932 return rewriteValueARM64_OpConst32F(v)
933 case OpConst64:
934 return rewriteValueARM64_OpConst64(v)
935 case OpConst64F:
936 return rewriteValueARM64_OpConst64F(v)
937 case OpConst8:
938 return rewriteValueARM64_OpConst8(v)
939 case OpConstBool:
940 return rewriteValueARM64_OpConstBool(v)
941 case OpConstNil:
942 return rewriteValueARM64_OpConstNil(v)
943 case OpConvertLo2ToFloat64Float32x4:
944 v.Op = OpARM64VFCVTL4S
945 return true
946 case OpConvertToFloat32Float64x2:
947 v.Op = OpARM64VFCVTN2D
948 return true
949 case OpConvertToFloat32Int32x4:
950 v.Op = OpARM64VSCVTF4S
951 return true
952 case OpConvertToFloat32Uint32x4:
953 v.Op = OpARM64VUCVTF4S
954 return true
955 case OpConvertToFloat64Int64x2:
956 v.Op = OpARM64VSCVTF2D
957 return true
958 case OpConvertToFloat64Uint64x2:
959 v.Op = OpARM64VUCVTF2D
960 return true
961 case OpConvertToInt32Float32x4:
962 v.Op = OpARM64VFCVTZS4S
963 return true
964 case OpConvertToInt64Float64x2:
965 v.Op = OpARM64VFCVTZS2D
966 return true
967 case OpConvertToUint32Float32x4:
968 v.Op = OpARM64VFCVTZU4S
969 return true
970 case OpConvertToUint64Float64x2:
971 v.Op = OpARM64VFCVTZU2D
972 return true
973 case OpCtz16:
974 return rewriteValueARM64_OpCtz16(v)
975 case OpCtz16NonZero:
976 v.Op = OpCtz32
977 return true
978 case OpCtz32:
979 return rewriteValueARM64_OpCtz32(v)
980 case OpCtz32NonZero:
981 v.Op = OpCtz32
982 return true
983 case OpCtz64:
984 return rewriteValueARM64_OpCtz64(v)
985 case OpCtz64NonZero:
986 v.Op = OpCtz64
987 return true
988 case OpCtz8:
989 return rewriteValueARM64_OpCtz8(v)
990 case OpCtz8NonZero:
991 v.Op = OpCtz32
992 return true
993 case OpCvt32Fto32:
994 v.Op = OpARM64FCVTZSSW
995 return true
996 case OpCvt32Fto32U:
997 v.Op = OpARM64FCVTZUSW
998 return true
999 case OpCvt32Fto64:
1000 v.Op = OpARM64FCVTZSS
1001 return true
1002 case OpCvt32Fto64F:
1003 v.Op = OpARM64FCVTSD
1004 return true
1005 case OpCvt32Fto64U:
1006 v.Op = OpARM64FCVTZUS
1007 return true
1008 case OpCvt32Uto32F:
1009 v.Op = OpARM64UCVTFWS
1010 return true
1011 case OpCvt32Uto64F:
1012 v.Op = OpARM64UCVTFWD
1013 return true
1014 case OpCvt32to32F:
1015 v.Op = OpARM64SCVTFWS
1016 return true
1017 case OpCvt32to64F:
1018 v.Op = OpARM64SCVTFWD
1019 return true
1020 case OpCvt64Fto32:
1021 v.Op = OpARM64FCVTZSDW
1022 return true
1023 case OpCvt64Fto32F:
1024 v.Op = OpARM64FCVTDS
1025 return true
1026 case OpCvt64Fto32U:
1027 v.Op = OpARM64FCVTZUDW
1028 return true
1029 case OpCvt64Fto64:
1030 v.Op = OpARM64FCVTZSD
1031 return true
1032 case OpCvt64Fto64U:
1033 v.Op = OpARM64FCVTZUD
1034 return true
1035 case OpCvt64Uto32F:
1036 v.Op = OpARM64UCVTFS
1037 return true
1038 case OpCvt64Uto64F:
1039 v.Op = OpARM64UCVTFD
1040 return true
1041 case OpCvt64to32F:
1042 v.Op = OpARM64SCVTFS
1043 return true
1044 case OpCvt64to64F:
1045 v.Op = OpARM64SCVTFD
1046 return true
1047 case OpCvtBoolToUint8:
1048 v.Op = OpCopy
1049 return true
1050 case OpDiv16:
1051 return rewriteValueARM64_OpDiv16(v)
1052 case OpDiv16u:
1053 return rewriteValueARM64_OpDiv16u(v)
1054 case OpDiv32:
1055 return rewriteValueARM64_OpDiv32(v)
1056 case OpDiv32F:
1057 v.Op = OpARM64FDIVS
1058 return true
1059 case OpDiv32u:
1060 v.Op = OpARM64UDIVW
1061 return true
1062 case OpDiv64:
1063 return rewriteValueARM64_OpDiv64(v)
1064 case OpDiv64F:
1065 v.Op = OpARM64FDIVD
1066 return true
1067 case OpDiv64u:
1068 v.Op = OpARM64UDIV
1069 return true
1070 case OpDiv8:
1071 return rewriteValueARM64_OpDiv8(v)
1072 case OpDiv8u:
1073 return rewriteValueARM64_OpDiv8u(v)
1074 case OpDivFloat32x4:
1075 v.Op = OpARM64VFDIV4S
1076 return true
1077 case OpDivFloat64x2:
1078 v.Op = OpARM64VFDIV2D
1079 return true
1080 case OpEq16:
1081 return rewriteValueARM64_OpEq16(v)
1082 case OpEq32:
1083 return rewriteValueARM64_OpEq32(v)
1084 case OpEq32F:
1085 return rewriteValueARM64_OpEq32F(v)
1086 case OpEq64:
1087 return rewriteValueARM64_OpEq64(v)
1088 case OpEq64F:
1089 return rewriteValueARM64_OpEq64F(v)
1090 case OpEq8:
1091 return rewriteValueARM64_OpEq8(v)
1092 case OpEqB:
1093 return rewriteValueARM64_OpEqB(v)
1094 case OpEqPtr:
1095 return rewriteValueARM64_OpEqPtr(v)
1096 case OpEqualFloat32x4:
1097 v.Op = OpARM64VFCMEQ4S
1098 return true
1099 case OpEqualFloat64x2:
1100 v.Op = OpARM64VFCMEQ2D
1101 return true
1102 case OpEqualInt16x8:
1103 v.Op = OpARM64VCMEQ8H
1104 return true
1105 case OpEqualInt32x4:
1106 v.Op = OpARM64VCMEQ4S
1107 return true
1108 case OpEqualInt64x2:
1109 v.Op = OpARM64VCMEQ2D
1110 return true
1111 case OpEqualInt8x16:
1112 v.Op = OpARM64VCMEQ16B
1113 return true
1114 case OpEqualUint16x8:
1115 v.Op = OpARM64VCMEQ8H
1116 return true
1117 case OpEqualUint32x4:
1118 v.Op = OpARM64VCMEQ4S
1119 return true
1120 case OpEqualUint64x2:
1121 v.Op = OpARM64VCMEQ2D
1122 return true
1123 case OpEqualUint8x16:
1124 v.Op = OpARM64VCMEQ16B
1125 return true
1126 case OpExtendLo2ToInt64Int32x4:
1127 v.Op = OpARM64VSXTL4S
1128 return true
1129 case OpExtendLo2ToUint64Uint32x4:
1130 v.Op = OpARM64VUXTL4S
1131 return true
1132 case OpExtendLo4ToInt32Int16x8:
1133 v.Op = OpARM64VSXTL8H
1134 return true
1135 case OpExtendLo4ToUint32Uint16x8:
1136 v.Op = OpARM64VUXTL8H
1137 return true
1138 case OpExtendLo8ToInt16Int8x16:
1139 v.Op = OpARM64VSXTL16B
1140 return true
1141 case OpExtendLo8ToUint16Uint8x16:
1142 v.Op = OpARM64VUXTL16B
1143 return true
1144 case OpFMA:
1145 return rewriteValueARM64_OpFMA(v)
1146 case OpFloor:
1147 v.Op = OpARM64FRINTMD
1148 return true
1149 case OpFloorFloat32x4:
1150 v.Op = OpARM64VFRINTM4S
1151 return true
1152 case OpFloorFloat64x2:
1153 v.Op = OpARM64VFRINTM2D
1154 return true
1155 case OpGetCallerPC:
1156 v.Op = OpARM64LoweredGetCallerPC
1157 return true
1158 case OpGetCallerSP:
1159 v.Op = OpARM64LoweredGetCallerSP
1160 return true
1161 case OpGetClosurePtr:
1162 v.Op = OpARM64LoweredGetClosurePtr
1163 return true
1164 case OpGetElemFloat32x4:
1165 v.Op = OpARM64VDUPSextr
1166 return true
1167 case OpGetElemFloat64x2:
1168 v.Op = OpARM64VDUPDextr
1169 return true
1170 case OpGetElemInt16x8:
1171 v.Op = OpARM64VMOVHextr
1172 return true
1173 case OpGetElemInt32x4:
1174 v.Op = OpARM64VMOVSextr
1175 return true
1176 case OpGetElemInt64x2:
1177 v.Op = OpARM64VMOVDextr
1178 return true
1179 case OpGetElemInt8x16:
1180 v.Op = OpARM64VMOVBextr
1181 return true
1182 case OpGetElemUint16x8:
1183 v.Op = OpARM64VMOVHextr
1184 return true
1185 case OpGetElemUint32x4:
1186 v.Op = OpARM64VMOVSextr
1187 return true
1188 case OpGetElemUint64x2:
1189 v.Op = OpARM64VMOVDextr
1190 return true
1191 case OpGetElemUint8x16:
1192 v.Op = OpARM64VMOVBextr
1193 return true
1194 case OpGreaterEqualFloat32x4:
1195 v.Op = OpARM64VFCMGE4S
1196 return true
1197 case OpGreaterEqualFloat64x2:
1198 v.Op = OpARM64VFCMGE2D
1199 return true
1200 case OpGreaterEqualInt16x8:
1201 v.Op = OpARM64VCMGE8H
1202 return true
1203 case OpGreaterEqualInt32x4:
1204 v.Op = OpARM64VCMGE4S
1205 return true
1206 case OpGreaterEqualInt64x2:
1207 v.Op = OpARM64VCMGE2D
1208 return true
1209 case OpGreaterEqualInt8x16:
1210 v.Op = OpARM64VCMGE16B
1211 return true
1212 case OpGreaterEqualUint16x8:
1213 v.Op = OpARM64VCMHS8H
1214 return true
1215 case OpGreaterEqualUint32x4:
1216 v.Op = OpARM64VCMHS4S
1217 return true
1218 case OpGreaterEqualUint64x2:
1219 v.Op = OpARM64VCMHS2D
1220 return true
1221 case OpGreaterEqualUint8x16:
1222 v.Op = OpARM64VCMHS16B
1223 return true
1224 case OpGreaterFloat32x4:
1225 v.Op = OpARM64VFCMGT4S
1226 return true
1227 case OpGreaterFloat64x2:
1228 v.Op = OpARM64VFCMGT2D
1229 return true
1230 case OpGreaterInt16x8:
1231 v.Op = OpARM64VCMGT8H
1232 return true
1233 case OpGreaterInt32x4:
1234 v.Op = OpARM64VCMGT4S
1235 return true
1236 case OpGreaterInt64x2:
1237 v.Op = OpARM64VCMGT2D
1238 return true
1239 case OpGreaterInt8x16:
1240 v.Op = OpARM64VCMGT16B
1241 return true
1242 case OpGreaterUint16x8:
1243 v.Op = OpARM64VCMHI8H
1244 return true
1245 case OpGreaterUint32x4:
1246 v.Op = OpARM64VCMHI4S
1247 return true
1248 case OpGreaterUint64x2:
1249 v.Op = OpARM64VCMHI2D
1250 return true
1251 case OpGreaterUint8x16:
1252 v.Op = OpARM64VCMHI16B
1253 return true
1254 case OpHmul32:
1255 return rewriteValueARM64_OpHmul32(v)
1256 case OpHmul32u:
1257 return rewriteValueARM64_OpHmul32u(v)
1258 case OpHmul64:
1259 v.Op = OpARM64MULH
1260 return true
1261 case OpHmul64u:
1262 v.Op = OpARM64UMULH
1263 return true
1264 case OpInterCall:
1265 v.Op = OpARM64CALLinter
1266 return true
1267 case OpInterleaveEvenInt16x8:
1268 v.Op = OpARM64VTRN18H
1269 return true
1270 case OpInterleaveEvenInt32x4:
1271 v.Op = OpARM64VTRN14S
1272 return true
1273 case OpInterleaveEvenInt64x2:
1274 v.Op = OpARM64VTRN12D
1275 return true
1276 case OpInterleaveEvenInt8x16:
1277 v.Op = OpARM64VTRN116B
1278 return true
1279 case OpInterleaveEvenUint16x8:
1280 v.Op = OpARM64VTRN18H
1281 return true
1282 case OpInterleaveEvenUint32x4:
1283 v.Op = OpARM64VTRN14S
1284 return true
1285 case OpInterleaveEvenUint64x2:
1286 v.Op = OpARM64VTRN12D
1287 return true
1288 case OpInterleaveEvenUint8x16:
1289 v.Op = OpARM64VTRN116B
1290 return true
1291 case OpInterleaveHiInt16x8:
1292 v.Op = OpARM64VZIP28H
1293 return true
1294 case OpInterleaveHiInt32x4:
1295 v.Op = OpARM64VZIP24S
1296 return true
1297 case OpInterleaveHiInt64x2:
1298 v.Op = OpARM64VZIP22D
1299 return true
1300 case OpInterleaveHiInt8x16:
1301 v.Op = OpARM64VZIP216B
1302 return true
1303 case OpInterleaveHiUint16x8:
1304 v.Op = OpARM64VZIP28H
1305 return true
1306 case OpInterleaveHiUint32x4:
1307 v.Op = OpARM64VZIP24S
1308 return true
1309 case OpInterleaveHiUint64x2:
1310 v.Op = OpARM64VZIP22D
1311 return true
1312 case OpInterleaveHiUint8x16:
1313 v.Op = OpARM64VZIP216B
1314 return true
1315 case OpInterleaveLoInt16x8:
1316 v.Op = OpARM64VZIP18H
1317 return true
1318 case OpInterleaveLoInt32x4:
1319 v.Op = OpARM64VZIP14S
1320 return true
1321 case OpInterleaveLoInt64x2:
1322 v.Op = OpARM64VZIP12D
1323 return true
1324 case OpInterleaveLoInt8x16:
1325 v.Op = OpARM64VZIP116B
1326 return true
1327 case OpInterleaveLoUint16x8:
1328 v.Op = OpARM64VZIP18H
1329 return true
1330 case OpInterleaveLoUint32x4:
1331 v.Op = OpARM64VZIP14S
1332 return true
1333 case OpInterleaveLoUint64x2:
1334 v.Op = OpARM64VZIP12D
1335 return true
1336 case OpInterleaveLoUint8x16:
1337 v.Op = OpARM64VZIP116B
1338 return true
1339 case OpInterleaveOddInt16x8:
1340 v.Op = OpARM64VTRN28H
1341 return true
1342 case OpInterleaveOddInt32x4:
1343 v.Op = OpARM64VTRN24S
1344 return true
1345 case OpInterleaveOddInt64x2:
1346 v.Op = OpARM64VTRN22D
1347 return true
1348 case OpInterleaveOddInt8x16:
1349 v.Op = OpARM64VTRN216B
1350 return true
1351 case OpInterleaveOddUint16x8:
1352 v.Op = OpARM64VTRN28H
1353 return true
1354 case OpInterleaveOddUint32x4:
1355 v.Op = OpARM64VTRN24S
1356 return true
1357 case OpInterleaveOddUint64x2:
1358 v.Op = OpARM64VTRN22D
1359 return true
1360 case OpInterleaveOddUint8x16:
1361 v.Op = OpARM64VTRN216B
1362 return true
1363 case OpIsInBounds:
1364 return rewriteValueARM64_OpIsInBounds(v)
1365 case OpIsNonNil:
1366 return rewriteValueARM64_OpIsNonNil(v)
1367 case OpIsSliceInBounds:
1368 return rewriteValueARM64_OpIsSliceInBounds(v)
1369 case OpLeadingSignBitsInt16x8:
1370 v.Op = OpARM64VCLS8H
1371 return true
1372 case OpLeadingSignBitsInt32x4:
1373 v.Op = OpARM64VCLS4S
1374 return true
1375 case OpLeadingSignBitsInt8x16:
1376 v.Op = OpARM64VCLS16B
1377 return true
1378 case OpLeadingSignBitsUint16x8:
1379 v.Op = OpARM64VCLS8H
1380 return true
1381 case OpLeadingSignBitsUint32x4:
1382 v.Op = OpARM64VCLS4S
1383 return true
1384 case OpLeadingSignBitsUint8x16:
1385 v.Op = OpARM64VCLS16B
1386 return true
1387 case OpLeadingZerosInt16x8:
1388 v.Op = OpARM64VCLZ8H
1389 return true
1390 case OpLeadingZerosInt32x4:
1391 v.Op = OpARM64VCLZ4S
1392 return true
1393 case OpLeadingZerosInt8x16:
1394 v.Op = OpARM64VCLZ16B
1395 return true
1396 case OpLeadingZerosUint16x8:
1397 v.Op = OpARM64VCLZ8H
1398 return true
1399 case OpLeadingZerosUint32x4:
1400 v.Op = OpARM64VCLZ4S
1401 return true
1402 case OpLeadingZerosUint8x16:
1403 v.Op = OpARM64VCLZ16B
1404 return true
1405 case OpLeq16:
1406 return rewriteValueARM64_OpLeq16(v)
1407 case OpLeq16U:
1408 return rewriteValueARM64_OpLeq16U(v)
1409 case OpLeq32:
1410 return rewriteValueARM64_OpLeq32(v)
1411 case OpLeq32F:
1412 return rewriteValueARM64_OpLeq32F(v)
1413 case OpLeq32U:
1414 return rewriteValueARM64_OpLeq32U(v)
1415 case OpLeq64:
1416 return rewriteValueARM64_OpLeq64(v)
1417 case OpLeq64F:
1418 return rewriteValueARM64_OpLeq64F(v)
1419 case OpLeq64U:
1420 return rewriteValueARM64_OpLeq64U(v)
1421 case OpLeq8:
1422 return rewriteValueARM64_OpLeq8(v)
1423 case OpLeq8U:
1424 return rewriteValueARM64_OpLeq8U(v)
1425 case OpLess16:
1426 return rewriteValueARM64_OpLess16(v)
1427 case OpLess16U:
1428 return rewriteValueARM64_OpLess16U(v)
1429 case OpLess32:
1430 return rewriteValueARM64_OpLess32(v)
1431 case OpLess32F:
1432 return rewriteValueARM64_OpLess32F(v)
1433 case OpLess32U:
1434 return rewriteValueARM64_OpLess32U(v)
1435 case OpLess64:
1436 return rewriteValueARM64_OpLess64(v)
1437 case OpLess64F:
1438 return rewriteValueARM64_OpLess64F(v)
1439 case OpLess64U:
1440 return rewriteValueARM64_OpLess64U(v)
1441 case OpLess8:
1442 return rewriteValueARM64_OpLess8(v)
1443 case OpLess8U:
1444 return rewriteValueARM64_OpLess8U(v)
1445 case OpLoad:
1446 return rewriteValueARM64_OpLoad(v)
1447 case OpLocalAddr:
1448 return rewriteValueARM64_OpLocalAddr(v)
1449 case OpLookupOrZeroInt8x16:
1450 v.Op = OpARM64VTBL16B
1451 return true
1452 case OpLookupOrZeroUint8x16:
1453 v.Op = OpARM64VTBL16B
1454 return true
1455 case OpLsh16x16:
1456 v.Op = OpLsh64x16
1457 return true
1458 case OpLsh16x32:
1459 v.Op = OpLsh64x32
1460 return true
1461 case OpLsh16x64:
1462 v.Op = OpLsh64x64
1463 return true
1464 case OpLsh16x8:
1465 v.Op = OpLsh64x8
1466 return true
1467 case OpLsh32x16:
1468 v.Op = OpLsh64x16
1469 return true
1470 case OpLsh32x32:
1471 v.Op = OpLsh64x32
1472 return true
1473 case OpLsh32x64:
1474 v.Op = OpLsh64x64
1475 return true
1476 case OpLsh32x8:
1477 v.Op = OpLsh64x8
1478 return true
1479 case OpLsh64x16:
1480 return rewriteValueARM64_OpLsh64x16(v)
1481 case OpLsh64x32:
1482 return rewriteValueARM64_OpLsh64x32(v)
1483 case OpLsh64x64:
1484 return rewriteValueARM64_OpLsh64x64(v)
1485 case OpLsh64x8:
1486 return rewriteValueARM64_OpLsh64x8(v)
1487 case OpLsh8x16:
1488 v.Op = OpLsh64x16
1489 return true
1490 case OpLsh8x32:
1491 v.Op = OpLsh64x32
1492 return true
1493 case OpLsh8x64:
1494 v.Op = OpLsh64x64
1495 return true
1496 case OpLsh8x8:
1497 v.Op = OpLsh64x8
1498 return true
1499 case OpMax32F:
1500 v.Op = OpARM64FMAXS
1501 return true
1502 case OpMax32FSel:
1503 return rewriteValueARM64_OpMax32FSel(v)
1504 case OpMax64F:
1505 v.Op = OpARM64FMAXD
1506 return true
1507 case OpMax64FSel:
1508 return rewriteValueARM64_OpMax64FSel(v)
1509 case OpMaxFloat32x4:
1510 v.Op = OpARM64VFMAX4S
1511 return true
1512 case OpMaxFloat64x2:
1513 v.Op = OpARM64VFMAX2D
1514 return true
1515 case OpMaxInt16x8:
1516 v.Op = OpARM64VSMAX8H
1517 return true
1518 case OpMaxInt32x4:
1519 v.Op = OpARM64VSMAX4S
1520 return true
1521 case OpMaxInt8x16:
1522 v.Op = OpARM64VSMAX16B
1523 return true
1524 case OpMaxUint16x8:
1525 v.Op = OpARM64VUMAX8H
1526 return true
1527 case OpMaxUint32x4:
1528 v.Op = OpARM64VUMAX4S
1529 return true
1530 case OpMaxUint8x16:
1531 v.Op = OpARM64VUMAX16B
1532 return true
1533 case OpMemEq:
1534 v.Op = OpARM64LoweredMemEq
1535 return true
1536 case OpMin32F:
1537 v.Op = OpARM64FMINS
1538 return true
1539 case OpMin32FSel:
1540 return rewriteValueARM64_OpMin32FSel(v)
1541 case OpMin64F:
1542 v.Op = OpARM64FMIND
1543 return true
1544 case OpMin64FSel:
1545 return rewriteValueARM64_OpMin64FSel(v)
1546 case OpMinFloat32x4:
1547 v.Op = OpARM64VFMIN4S
1548 return true
1549 case OpMinFloat64x2:
1550 v.Op = OpARM64VFMIN2D
1551 return true
1552 case OpMinInt16x8:
1553 v.Op = OpARM64VSMIN8H
1554 return true
1555 case OpMinInt32x4:
1556 v.Op = OpARM64VSMIN4S
1557 return true
1558 case OpMinInt8x16:
1559 v.Op = OpARM64VSMIN16B
1560 return true
1561 case OpMinUint16x8:
1562 v.Op = OpARM64VUMIN8H
1563 return true
1564 case OpMinUint32x4:
1565 v.Op = OpARM64VUMIN4S
1566 return true
1567 case OpMinUint8x16:
1568 v.Op = OpARM64VUMIN16B
1569 return true
1570 case OpMod16:
1571 return rewriteValueARM64_OpMod16(v)
1572 case OpMod16u:
1573 return rewriteValueARM64_OpMod16u(v)
1574 case OpMod32:
1575 return rewriteValueARM64_OpMod32(v)
1576 case OpMod32u:
1577 v.Op = OpARM64UMODW
1578 return true
1579 case OpMod64:
1580 return rewriteValueARM64_OpMod64(v)
1581 case OpMod64u:
1582 v.Op = OpARM64UMOD
1583 return true
1584 case OpMod8:
1585 return rewriteValueARM64_OpMod8(v)
1586 case OpMod8u:
1587 return rewriteValueARM64_OpMod8u(v)
1588 case OpMove:
1589 return rewriteValueARM64_OpMove(v)
1590 case OpMul16:
1591 v.Op = OpARM64MULW
1592 return true
1593 case OpMul32:
1594 v.Op = OpARM64MULW
1595 return true
1596 case OpMul32F:
1597 v.Op = OpARM64FMULS
1598 return true
1599 case OpMul64:
1600 v.Op = OpARM64MUL
1601 return true
1602 case OpMul64F:
1603 v.Op = OpARM64FMULD
1604 return true
1605 case OpMul8:
1606 v.Op = OpARM64MULW
1607 return true
1608 case OpMulAddFloat32x4:
1609 return rewriteValueARM64_OpMulAddFloat32x4(v)
1610 case OpMulAddFloat64x2:
1611 return rewriteValueARM64_OpMulAddFloat64x2(v)
1612 case OpMulAddInt16x8:
1613 return rewriteValueARM64_OpMulAddInt16x8(v)
1614 case OpMulAddInt32x4:
1615 return rewriteValueARM64_OpMulAddInt32x4(v)
1616 case OpMulAddInt8x16:
1617 return rewriteValueARM64_OpMulAddInt8x16(v)
1618 case OpMulAddUint16x8:
1619 return rewriteValueARM64_OpMulAddUint16x8(v)
1620 case OpMulAddUint32x4:
1621 return rewriteValueARM64_OpMulAddUint32x4(v)
1622 case OpMulAddUint8x16:
1623 return rewriteValueARM64_OpMulAddUint8x16(v)
1624 case OpMulFloat32x4:
1625 v.Op = OpARM64VFMUL4S
1626 return true
1627 case OpMulFloat64x2:
1628 v.Op = OpARM64VFMUL2D
1629 return true
1630 case OpMulInt16x8:
1631 v.Op = OpARM64VMUL8H
1632 return true
1633 case OpMulInt32x4:
1634 v.Op = OpARM64VMUL4S
1635 return true
1636 case OpMulInt8x16:
1637 v.Op = OpARM64VMUL16B
1638 return true
1639 case OpMulUint16x8:
1640 v.Op = OpARM64VMUL8H
1641 return true
1642 case OpMulUint32x4:
1643 v.Op = OpARM64VMUL4S
1644 return true
1645 case OpMulUint8x16:
1646 v.Op = OpARM64VMUL16B
1647 return true
1648 case OpMulWidenLoInt16x8:
1649 v.Op = OpARM64VSMULL8H
1650 return true
1651 case OpMulWidenLoInt32x4:
1652 v.Op = OpARM64VSMULL4S
1653 return true
1654 case OpMulWidenLoInt8x16:
1655 v.Op = OpARM64VSMULL16B
1656 return true
1657 case OpMulWidenLoUint16x8:
1658 v.Op = OpARM64VUMULL8H
1659 return true
1660 case OpMulWidenLoUint32x4:
1661 v.Op = OpARM64VUMULL4S
1662 return true
1663 case OpMulWidenLoUint8x16:
1664 v.Op = OpARM64VUMULL16B
1665 return true
1666 case OpNeg16:
1667 v.Op = OpARM64NEG
1668 return true
1669 case OpNeg32:
1670 v.Op = OpARM64NEG
1671 return true
1672 case OpNeg32F:
1673 v.Op = OpARM64FNEGS
1674 return true
1675 case OpNeg64:
1676 v.Op = OpARM64NEG
1677 return true
1678 case OpNeg64F:
1679 v.Op = OpARM64FNEGD
1680 return true
1681 case OpNeg8:
1682 v.Op = OpARM64NEG
1683 return true
1684 case OpNegFloat32x4:
1685 v.Op = OpARM64VFNEG4S
1686 return true
1687 case OpNegFloat64x2:
1688 v.Op = OpARM64VFNEG2D
1689 return true
1690 case OpNegInt16x8:
1691 v.Op = OpARM64VNEG8H
1692 return true
1693 case OpNegInt32x4:
1694 v.Op = OpARM64VNEG4S
1695 return true
1696 case OpNegInt64x2:
1697 v.Op = OpARM64VNEG2D
1698 return true
1699 case OpNegInt8x16:
1700 v.Op = OpARM64VNEG16B
1701 return true
1702 case OpNeq16:
1703 return rewriteValueARM64_OpNeq16(v)
1704 case OpNeq32:
1705 return rewriteValueARM64_OpNeq32(v)
1706 case OpNeq32F:
1707 return rewriteValueARM64_OpNeq32F(v)
1708 case OpNeq64:
1709 return rewriteValueARM64_OpNeq64(v)
1710 case OpNeq64F:
1711 return rewriteValueARM64_OpNeq64F(v)
1712 case OpNeq8:
1713 return rewriteValueARM64_OpNeq8(v)
1714 case OpNeqB:
1715 v.Op = OpARM64XOR
1716 return true
1717 case OpNeqPtr:
1718 return rewriteValueARM64_OpNeqPtr(v)
1719 case OpNilCheck:
1720 v.Op = OpARM64LoweredNilCheck
1721 return true
1722 case OpNot:
1723 return rewriteValueARM64_OpNot(v)
1724 case OpNotInt16x8:
1725 v.Op = OpARM64VNOT16B
1726 return true
1727 case OpNotInt32x4:
1728 v.Op = OpARM64VNOT16B
1729 return true
1730 case OpNotInt64x2:
1731 v.Op = OpARM64VNOT16B
1732 return true
1733 case OpNotInt8x16:
1734 v.Op = OpARM64VNOT16B
1735 return true
1736 case OpNotUint16x8:
1737 v.Op = OpARM64VNOT16B
1738 return true
1739 case OpNotUint32x4:
1740 v.Op = OpARM64VNOT16B
1741 return true
1742 case OpNotUint64x2:
1743 v.Op = OpARM64VNOT16B
1744 return true
1745 case OpNotUint8x16:
1746 v.Op = OpARM64VNOT16B
1747 return true
1748 case OpOffPtr:
1749 return rewriteValueARM64_OpOffPtr(v)
1750 case OpOnesCountInt8x16:
1751 v.Op = OpARM64VCNT16B
1752 return true
1753 case OpOnesCountUint8x16:
1754 v.Op = OpARM64VCNT16B
1755 return true
1756 case OpOr16:
1757 v.Op = OpARM64OR
1758 return true
1759 case OpOr32:
1760 v.Op = OpARM64OR
1761 return true
1762 case OpOr64:
1763 v.Op = OpARM64OR
1764 return true
1765 case OpOr8:
1766 v.Op = OpARM64OR
1767 return true
1768 case OpOrB:
1769 v.Op = OpARM64OR
1770 return true
1771 case OpOrInt16x8:
1772 v.Op = OpARM64VORR16B
1773 return true
1774 case OpOrInt32x4:
1775 v.Op = OpARM64VORR16B
1776 return true
1777 case OpOrInt64x2:
1778 v.Op = OpARM64VORR16B
1779 return true
1780 case OpOrInt8x16:
1781 v.Op = OpARM64VORR16B
1782 return true
1783 case OpOrNotInt16x8:
1784 v.Op = OpARM64VORN16B
1785 return true
1786 case OpOrNotInt32x4:
1787 v.Op = OpARM64VORN16B
1788 return true
1789 case OpOrNotInt64x2:
1790 v.Op = OpARM64VORN16B
1791 return true
1792 case OpOrNotInt8x16:
1793 v.Op = OpARM64VORN16B
1794 return true
1795 case OpOrNotUint16x8:
1796 v.Op = OpARM64VORN16B
1797 return true
1798 case OpOrNotUint32x4:
1799 v.Op = OpARM64VORN16B
1800 return true
1801 case OpOrNotUint64x2:
1802 v.Op = OpARM64VORN16B
1803 return true
1804 case OpOrNotUint8x16:
1805 v.Op = OpARM64VORN16B
1806 return true
1807 case OpOrUint16x8:
1808 v.Op = OpARM64VORR16B
1809 return true
1810 case OpOrUint32x4:
1811 v.Op = OpARM64VORR16B
1812 return true
1813 case OpOrUint64x2:
1814 v.Op = OpARM64VORR16B
1815 return true
1816 case OpOrUint8x16:
1817 v.Op = OpARM64VORR16B
1818 return true
1819 case OpPanicBounds:
1820 v.Op = OpARM64LoweredPanicBoundsRR
1821 return true
1822 case OpPopCount16:
1823 return rewriteValueARM64_OpPopCount16(v)
1824 case OpPopCount32:
1825 return rewriteValueARM64_OpPopCount32(v)
1826 case OpPopCount64:
1827 return rewriteValueARM64_OpPopCount64(v)
1828 case OpPrefetchCache:
1829 return rewriteValueARM64_OpPrefetchCache(v)
1830 case OpPrefetchCacheStreamed:
1831 return rewriteValueARM64_OpPrefetchCacheStreamed(v)
1832 case OpPubBarrier:
1833 return rewriteValueARM64_OpPubBarrier(v)
1834 case OpRotateLeft16:
1835 return rewriteValueARM64_OpRotateLeft16(v)
1836 case OpRotateLeft32:
1837 return rewriteValueARM64_OpRotateLeft32(v)
1838 case OpRotateLeft64:
1839 return rewriteValueARM64_OpRotateLeft64(v)
1840 case OpRotateLeft8:
1841 return rewriteValueARM64_OpRotateLeft8(v)
1842 case OpRound:
1843 v.Op = OpARM64FRINTAD
1844 return true
1845 case OpRound32F:
1846 v.Op = OpARM64LoweredRound32F
1847 return true
1848 case OpRound64F:
1849 v.Op = OpARM64LoweredRound64F
1850 return true
1851 case OpRoundFloat32x4:
1852 v.Op = OpARM64VFRINTN4S
1853 return true
1854 case OpRoundFloat64x2:
1855 v.Op = OpARM64VFRINTN2D
1856 return true
1857 case OpRoundToEven:
1858 v.Op = OpARM64FRINTND
1859 return true
1860 case OpRsh16Ux16:
1861 return rewriteValueARM64_OpRsh16Ux16(v)
1862 case OpRsh16Ux32:
1863 return rewriteValueARM64_OpRsh16Ux32(v)
1864 case OpRsh16Ux64:
1865 return rewriteValueARM64_OpRsh16Ux64(v)
1866 case OpRsh16Ux8:
1867 return rewriteValueARM64_OpRsh16Ux8(v)
1868 case OpRsh16x16:
1869 return rewriteValueARM64_OpRsh16x16(v)
1870 case OpRsh16x32:
1871 return rewriteValueARM64_OpRsh16x32(v)
1872 case OpRsh16x64:
1873 return rewriteValueARM64_OpRsh16x64(v)
1874 case OpRsh16x8:
1875 return rewriteValueARM64_OpRsh16x8(v)
1876 case OpRsh32Ux16:
1877 return rewriteValueARM64_OpRsh32Ux16(v)
1878 case OpRsh32Ux32:
1879 return rewriteValueARM64_OpRsh32Ux32(v)
1880 case OpRsh32Ux64:
1881 return rewriteValueARM64_OpRsh32Ux64(v)
1882 case OpRsh32Ux8:
1883 return rewriteValueARM64_OpRsh32Ux8(v)
1884 case OpRsh32x16:
1885 return rewriteValueARM64_OpRsh32x16(v)
1886 case OpRsh32x32:
1887 return rewriteValueARM64_OpRsh32x32(v)
1888 case OpRsh32x64:
1889 return rewriteValueARM64_OpRsh32x64(v)
1890 case OpRsh32x8:
1891 return rewriteValueARM64_OpRsh32x8(v)
1892 case OpRsh64Ux16:
1893 return rewriteValueARM64_OpRsh64Ux16(v)
1894 case OpRsh64Ux32:
1895 return rewriteValueARM64_OpRsh64Ux32(v)
1896 case OpRsh64Ux64:
1897 return rewriteValueARM64_OpRsh64Ux64(v)
1898 case OpRsh64Ux8:
1899 return rewriteValueARM64_OpRsh64Ux8(v)
1900 case OpRsh64x16:
1901 return rewriteValueARM64_OpRsh64x16(v)
1902 case OpRsh64x32:
1903 return rewriteValueARM64_OpRsh64x32(v)
1904 case OpRsh64x64:
1905 return rewriteValueARM64_OpRsh64x64(v)
1906 case OpRsh64x8:
1907 return rewriteValueARM64_OpRsh64x8(v)
1908 case OpRsh8Ux16:
1909 return rewriteValueARM64_OpRsh8Ux16(v)
1910 case OpRsh8Ux32:
1911 return rewriteValueARM64_OpRsh8Ux32(v)
1912 case OpRsh8Ux64:
1913 return rewriteValueARM64_OpRsh8Ux64(v)
1914 case OpRsh8Ux8:
1915 return rewriteValueARM64_OpRsh8Ux8(v)
1916 case OpRsh8x16:
1917 return rewriteValueARM64_OpRsh8x16(v)
1918 case OpRsh8x32:
1919 return rewriteValueARM64_OpRsh8x32(v)
1920 case OpRsh8x64:
1921 return rewriteValueARM64_OpRsh8x64(v)
1922 case OpRsh8x8:
1923 return rewriteValueARM64_OpRsh8x8(v)
1924 case OpSaturateToInt16Int32x4:
1925 v.Op = OpARM64VSQXTN4S
1926 return true
1927 case OpSaturateToInt32Int64x2:
1928 v.Op = OpARM64VSQXTN2D
1929 return true
1930 case OpSaturateToInt8Int16x8:
1931 v.Op = OpARM64VSQXTN8H
1932 return true
1933 case OpSaturateToUint16Int32x4:
1934 v.Op = OpARM64VSQXTUN4S
1935 return true
1936 case OpSaturateToUint16Uint32x4:
1937 v.Op = OpARM64VUQXTN4S
1938 return true
1939 case OpSaturateToUint32Int64x2:
1940 v.Op = OpARM64VSQXTUN2D
1941 return true
1942 case OpSaturateToUint32Uint64x2:
1943 v.Op = OpARM64VUQXTN2D
1944 return true
1945 case OpSaturateToUint8Int16x8:
1946 v.Op = OpARM64VSQXTUN8H
1947 return true
1948 case OpSaturateToUint8Uint16x8:
1949 v.Op = OpARM64VUQXTN8H
1950 return true
1951 case OpSelect0:
1952 return rewriteValueARM64_OpSelect0(v)
1953 case OpSelect1:
1954 return rewriteValueARM64_OpSelect1(v)
1955 case OpSelectN:
1956 return rewriteValueARM64_OpSelectN(v)
1957 case OpSetElemFloat32x4:
1958 v.Op = OpARM64VMOVSins0
1959 return true
1960 case OpSetElemFloat64x2:
1961 v.Op = OpARM64VMOVDins0
1962 return true
1963 case OpSetElemInt16x8:
1964 v.Op = OpARM64VMOVHins
1965 return true
1966 case OpSetElemInt32x4:
1967 v.Op = OpARM64VMOVSins
1968 return true
1969 case OpSetElemInt64x2:
1970 v.Op = OpARM64VMOVDins
1971 return true
1972 case OpSetElemInt8x16:
1973 v.Op = OpARM64VMOVBins
1974 return true
1975 case OpSetElemUint16x8:
1976 v.Op = OpARM64VMOVHins
1977 return true
1978 case OpSetElemUint32x4:
1979 v.Op = OpARM64VMOVSins
1980 return true
1981 case OpSetElemUint64x2:
1982 v.Op = OpARM64VMOVDins
1983 return true
1984 case OpSetElemUint8x16:
1985 v.Op = OpARM64VMOVBins
1986 return true
1987 case OpShiftAllLeftInt16x8:
1988 return rewriteValueARM64_OpShiftAllLeftInt16x8(v)
1989 case OpShiftAllLeftInt32x4:
1990 return rewriteValueARM64_OpShiftAllLeftInt32x4(v)
1991 case OpShiftAllLeftInt64x2:
1992 return rewriteValueARM64_OpShiftAllLeftInt64x2(v)
1993 case OpShiftAllLeftInt8x16:
1994 return rewriteValueARM64_OpShiftAllLeftInt8x16(v)
1995 case OpShiftAllLeftUint16x8:
1996 return rewriteValueARM64_OpShiftAllLeftUint16x8(v)
1997 case OpShiftAllLeftUint32x4:
1998 return rewriteValueARM64_OpShiftAllLeftUint32x4(v)
1999 case OpShiftAllLeftUint64x2:
2000 return rewriteValueARM64_OpShiftAllLeftUint64x2(v)
2001 case OpShiftAllLeftUint8x16:
2002 return rewriteValueARM64_OpShiftAllLeftUint8x16(v)
2003 case OpShiftAllRightInt16x8:
2004 return rewriteValueARM64_OpShiftAllRightInt16x8(v)
2005 case OpShiftAllRightInt32x4:
2006 return rewriteValueARM64_OpShiftAllRightInt32x4(v)
2007 case OpShiftAllRightInt64x2:
2008 return rewriteValueARM64_OpShiftAllRightInt64x2(v)
2009 case OpShiftAllRightInt8x16:
2010 return rewriteValueARM64_OpShiftAllRightInt8x16(v)
2011 case OpShiftAllRightUint16x8:
2012 return rewriteValueARM64_OpShiftAllRightUint16x8(v)
2013 case OpShiftAllRightUint32x4:
2014 return rewriteValueARM64_OpShiftAllRightUint32x4(v)
2015 case OpShiftAllRightUint64x2:
2016 return rewriteValueARM64_OpShiftAllRightUint64x2(v)
2017 case OpShiftAllRightUint8x16:
2018 return rewriteValueARM64_OpShiftAllRightUint8x16(v)
2019 case OpShiftInt16x8:
2020 v.Op = OpARM64VSSHL8H
2021 return true
2022 case OpShiftInt32x4:
2023 v.Op = OpARM64VSSHL4S
2024 return true
2025 case OpShiftInt64x2:
2026 v.Op = OpARM64VSSHL2D
2027 return true
2028 case OpShiftInt8x16:
2029 v.Op = OpARM64VSSHL16B
2030 return true
2031 case OpShiftSaturatedInt16x8:
2032 v.Op = OpARM64VSQSHL8H
2033 return true
2034 case OpShiftSaturatedInt32x4:
2035 v.Op = OpARM64VSQSHL4S
2036 return true
2037 case OpShiftSaturatedInt64x2:
2038 v.Op = OpARM64VSQSHL2D
2039 return true
2040 case OpShiftSaturatedInt8x16:
2041 v.Op = OpARM64VSQSHL16B
2042 return true
2043 case OpShiftSaturatedUint16x8:
2044 v.Op = OpARM64VUQSHL8H
2045 return true
2046 case OpShiftSaturatedUint32x4:
2047 v.Op = OpARM64VUQSHL4S
2048 return true
2049 case OpShiftSaturatedUint64x2:
2050 v.Op = OpARM64VUQSHL2D
2051 return true
2052 case OpShiftSaturatedUint8x16:
2053 v.Op = OpARM64VUQSHL16B
2054 return true
2055 case OpShiftUint16x8:
2056 v.Op = OpARM64VUSHL8H
2057 return true
2058 case OpShiftUint32x4:
2059 v.Op = OpARM64VUSHL4S
2060 return true
2061 case OpShiftUint64x2:
2062 v.Op = OpARM64VUSHL2D
2063 return true
2064 case OpShiftUint8x16:
2065 v.Op = OpARM64VUSHL16B
2066 return true
2067 case OpSignExt16to32:
2068 v.Op = OpARM64MOVHreg
2069 return true
2070 case OpSignExt16to64:
2071 v.Op = OpARM64MOVHreg
2072 return true
2073 case OpSignExt32to64:
2074 v.Op = OpARM64MOVWreg
2075 return true
2076 case OpSignExt8to16:
2077 v.Op = OpARM64MOVBreg
2078 return true
2079 case OpSignExt8to32:
2080 v.Op = OpARM64MOVBreg
2081 return true
2082 case OpSignExt8to64:
2083 v.Op = OpARM64MOVBreg
2084 return true
2085 case OpSlicemask:
2086 return rewriteValueARM64_OpSlicemask(v)
2087 case OpSqrt:
2088 v.Op = OpARM64FSQRTD
2089 return true
2090 case OpSqrt32:
2091 v.Op = OpARM64FSQRTS
2092 return true
2093 case OpSqrtFloat32x4:
2094 v.Op = OpARM64VFSQRT4S
2095 return true
2096 case OpSqrtFloat64x2:
2097 v.Op = OpARM64VFSQRT2D
2098 return true
2099 case OpStaticCall:
2100 v.Op = OpARM64CALLstatic
2101 return true
2102 case OpStore:
2103 return rewriteValueARM64_OpStore(v)
2104 case OpSub16:
2105 v.Op = OpARM64SUB
2106 return true
2107 case OpSub32:
2108 v.Op = OpARM64SUB
2109 return true
2110 case OpSub32F:
2111 v.Op = OpARM64FSUBS
2112 return true
2113 case OpSub64:
2114 v.Op = OpARM64SUB
2115 return true
2116 case OpSub64F:
2117 v.Op = OpARM64FSUBD
2118 return true
2119 case OpSub8:
2120 v.Op = OpARM64SUB
2121 return true
2122 case OpSubFloat32x4:
2123 v.Op = OpARM64VFSUB4S
2124 return true
2125 case OpSubFloat64x2:
2126 v.Op = OpARM64VFSUB2D
2127 return true
2128 case OpSubInt16x8:
2129 v.Op = OpARM64VSUB8H
2130 return true
2131 case OpSubInt32x4:
2132 v.Op = OpARM64VSUB4S
2133 return true
2134 case OpSubInt64x2:
2135 v.Op = OpARM64VSUB2D
2136 return true
2137 case OpSubInt8x16:
2138 v.Op = OpARM64VSUB16B
2139 return true
2140 case OpSubPtr:
2141 v.Op = OpARM64SUB
2142 return true
2143 case OpSubSaturatedInt16x8:
2144 v.Op = OpARM64VSQSUB8H
2145 return true
2146 case OpSubSaturatedInt32x4:
2147 v.Op = OpARM64VSQSUB4S
2148 return true
2149 case OpSubSaturatedInt64x2:
2150 v.Op = OpARM64VSQSUB2D
2151 return true
2152 case OpSubSaturatedInt8x16:
2153 v.Op = OpARM64VSQSUB16B
2154 return true
2155 case OpSubSaturatedUint16x8:
2156 v.Op = OpARM64VUQSUB8H
2157 return true
2158 case OpSubSaturatedUint32x4:
2159 v.Op = OpARM64VUQSUB4S
2160 return true
2161 case OpSubSaturatedUint64x2:
2162 v.Op = OpARM64VUQSUB2D
2163 return true
2164 case OpSubSaturatedUint8x16:
2165 v.Op = OpARM64VUQSUB16B
2166 return true
2167 case OpSubUint16x8:
2168 v.Op = OpARM64VSUB8H
2169 return true
2170 case OpSubUint32x4:
2171 v.Op = OpARM64VSUB4S
2172 return true
2173 case OpSubUint64x2:
2174 v.Op = OpARM64VSUB2D
2175 return true
2176 case OpSubUint8x16:
2177 v.Op = OpARM64VSUB16B
2178 return true
2179 case OpTailCall:
2180 v.Op = OpARM64CALLtail
2181 return true
2182 case OpTailCallInter:
2183 v.Op = OpARM64CALLtailinter
2184 return true
2185 case OpTrunc:
2186 v.Op = OpARM64FRINTZD
2187 return true
2188 case OpTrunc16to8:
2189 v.Op = OpCopy
2190 return true
2191 case OpTrunc32to16:
2192 v.Op = OpCopy
2193 return true
2194 case OpTrunc32to8:
2195 v.Op = OpCopy
2196 return true
2197 case OpTrunc64to16:
2198 v.Op = OpCopy
2199 return true
2200 case OpTrunc64to32:
2201 v.Op = OpCopy
2202 return true
2203 case OpTrunc64to8:
2204 v.Op = OpCopy
2205 return true
2206 case OpTruncFloat32x4:
2207 v.Op = OpARM64VFRINTZ4S
2208 return true
2209 case OpTruncFloat64x2:
2210 v.Op = OpARM64VFRINTZ2D
2211 return true
2212 case OpTruncToInt16Int32x4:
2213 v.Op = OpARM64VXTN4S
2214 return true
2215 case OpTruncToInt32Int64x2:
2216 v.Op = OpARM64VXTN2D
2217 return true
2218 case OpTruncToInt8Int16x8:
2219 v.Op = OpARM64VXTN8H
2220 return true
2221 case OpTruncToUint16Uint32x4:
2222 v.Op = OpARM64VXTN4S
2223 return true
2224 case OpTruncToUint32Uint64x2:
2225 v.Op = OpARM64VXTN2D
2226 return true
2227 case OpTruncToUint8Uint16x8:
2228 v.Op = OpARM64VXTN8H
2229 return true
2230 case OpWB:
2231 v.Op = OpARM64LoweredWB
2232 return true
2233 case OpXor16:
2234 v.Op = OpARM64XOR
2235 return true
2236 case OpXor32:
2237 v.Op = OpARM64XOR
2238 return true
2239 case OpXor64:
2240 v.Op = OpARM64XOR
2241 return true
2242 case OpXor8:
2243 v.Op = OpARM64XOR
2244 return true
2245 case OpXorInt16x8:
2246 v.Op = OpARM64VEOR16B
2247 return true
2248 case OpXorInt32x4:
2249 v.Op = OpARM64VEOR16B
2250 return true
2251 case OpXorInt64x2:
2252 v.Op = OpARM64VEOR16B
2253 return true
2254 case OpXorInt8x16:
2255 v.Op = OpARM64VEOR16B
2256 return true
2257 case OpXorUint16x8:
2258 v.Op = OpARM64VEOR16B
2259 return true
2260 case OpXorUint32x4:
2261 v.Op = OpARM64VEOR16B
2262 return true
2263 case OpXorUint64x2:
2264 v.Op = OpARM64VEOR16B
2265 return true
2266 case OpXorUint8x16:
2267 v.Op = OpARM64VEOR16B
2268 return true
2269 case OpZero:
2270 return rewriteValueARM64_OpZero(v)
2271 case OpZeroExt16to32:
2272 v.Op = OpARM64MOVHUreg
2273 return true
2274 case OpZeroExt16to64:
2275 v.Op = OpARM64MOVHUreg
2276 return true
2277 case OpZeroExt32to64:
2278 v.Op = OpARM64MOVWUreg
2279 return true
2280 case OpZeroExt8to16:
2281 v.Op = OpARM64MOVBUreg
2282 return true
2283 case OpZeroExt8to32:
2284 v.Op = OpARM64MOVBUreg
2285 return true
2286 case OpZeroExt8to64:
2287 v.Op = OpARM64MOVBUreg
2288 return true
2289 case OpZeroSIMD:
2290 return rewriteValueARM64_OpZeroSIMD(v)
2291 case OpbitSelectInt8x16:
2292 v.Op = OpARM64VBIF16B
2293 return true
2294 case OpbitSelectNotInt8x16:
2295 v.Op = OpARM64VBIT16B
2296 return true
2297 case Opbroadcast1To16Int8x16:
2298 return rewriteValueARM64_Opbroadcast1To16Int8x16(v)
2299 case Opbroadcast1To16Uint8x16:
2300 return rewriteValueARM64_Opbroadcast1To16Uint8x16(v)
2301 case Opbroadcast1To2Float64x2:
2302 return rewriteValueARM64_Opbroadcast1To2Float64x2(v)
2303 case Opbroadcast1To2Int64x2:
2304 return rewriteValueARM64_Opbroadcast1To2Int64x2(v)
2305 case Opbroadcast1To2Uint64x2:
2306 return rewriteValueARM64_Opbroadcast1To2Uint64x2(v)
2307 case Opbroadcast1To4Float32x4:
2308 return rewriteValueARM64_Opbroadcast1To4Float32x4(v)
2309 case Opbroadcast1To4Int32x4:
2310 return rewriteValueARM64_Opbroadcast1To4Int32x4(v)
2311 case Opbroadcast1To4Uint32x4:
2312 return rewriteValueARM64_Opbroadcast1To4Uint32x4(v)
2313 case Opbroadcast1To8Int16x8:
2314 return rewriteValueARM64_Opbroadcast1To8Int16x8(v)
2315 case Opbroadcast1To8Uint16x8:
2316 return rewriteValueARM64_Opbroadcast1To8Uint16x8(v)
2317 case OpcarrylessMultiplyWidenLoUint64x2:
2318 v.Op = OpARM64VPMULL2D
2319 return true
2320 case OpreduceMaxFloat32x4:
2321 v.Op = OpARM64VFMAXV4S
2322 return true
2323 case OpreduceMaxInt16x8:
2324 v.Op = OpARM64VSMAXV8H
2325 return true
2326 case OpreduceMaxInt32x4:
2327 v.Op = OpARM64VSMAXV4S
2328 return true
2329 case OpreduceMaxInt8x16:
2330 v.Op = OpARM64VSMAXV16B
2331 return true
2332 case OpreduceMaxUint16x8:
2333 v.Op = OpARM64VUMAXV8H
2334 return true
2335 case OpreduceMaxUint32x4:
2336 v.Op = OpARM64VUMAXV4S
2337 return true
2338 case OpreduceMaxUint8x16:
2339 v.Op = OpARM64VUMAXV16B
2340 return true
2341 case OpreduceMinFloat32x4:
2342 v.Op = OpARM64VFMINV4S
2343 return true
2344 case OpreduceMinInt16x8:
2345 v.Op = OpARM64VSMINV8H
2346 return true
2347 case OpreduceMinInt32x4:
2348 v.Op = OpARM64VSMINV4S
2349 return true
2350 case OpreduceMinInt8x16:
2351 v.Op = OpARM64VSMINV16B
2352 return true
2353 case OpreduceMinUint16x8:
2354 v.Op = OpARM64VUMINV8H
2355 return true
2356 case OpreduceMinUint32x4:
2357 v.Op = OpARM64VUMINV4S
2358 return true
2359 case OpreduceMinUint8x16:
2360 v.Op = OpARM64VUMINV16B
2361 return true
2362 case OpreduceSumInt16x8:
2363 v.Op = OpARM64VADDV8H
2364 return true
2365 case OpreduceSumInt32x4:
2366 v.Op = OpARM64VADDV4S
2367 return true
2368 case OpreduceSumInt8x16:
2369 v.Op = OpARM64VADDV16B
2370 return true
2371 case OpreduceSumUint16x8:
2372 v.Op = OpARM64VADDV8H
2373 return true
2374 case OpreduceSumUint32x4:
2375 v.Op = OpARM64VADDV4S
2376 return true
2377 case OpreduceSumUint8x16:
2378 v.Op = OpARM64VADDV16B
2379 return true
2380 }
2381 return false
2382 }
2383 func rewriteValueARM64_OpARM64ADCSflags(v *Value) bool {
2384 v_2 := v.Args[2]
2385 v_1 := v.Args[1]
2386 v_0 := v.Args[0]
2387 b := v.Block
2388 typ := &b.Func.Config.Types
2389
2390
2391 for {
2392 x := v_0
2393 y := v_1
2394 if v_2.Op != OpSelect1 || v_2.Type != types.TypeFlags {
2395 break
2396 }
2397 v_2_0 := v_2.Args[0]
2398 if v_2_0.Op != OpARM64ADDSconstflags || auxIntToInt64(v_2_0.AuxInt) != -1 {
2399 break
2400 }
2401 v_2_0_0 := v_2_0.Args[0]
2402 if v_2_0_0.Op != OpARM64ADCzerocarry || v_2_0_0.Type != typ.UInt64 {
2403 break
2404 }
2405 c := v_2_0_0.Args[0]
2406 v.reset(OpARM64ADCSflags)
2407 v.AddArg3(x, y, c)
2408 return true
2409 }
2410
2411
2412 for {
2413 x := v_0
2414 y := v_1
2415 if v_2.Op != OpSelect1 || v_2.Type != types.TypeFlags {
2416 break
2417 }
2418 v_2_0 := v_2.Args[0]
2419 if v_2_0.Op != OpARM64ADDSconstflags || auxIntToInt64(v_2_0.AuxInt) != -1 {
2420 break
2421 }
2422 v_2_0_0 := v_2_0.Args[0]
2423 if v_2_0_0.Op != OpARM64MOVDconst || auxIntToInt64(v_2_0_0.AuxInt) != 0 {
2424 break
2425 }
2426 v.reset(OpARM64ADDSflags)
2427 v.AddArg2(x, y)
2428 return true
2429 }
2430 return false
2431 }
2432 func rewriteValueARM64_OpARM64ADD(v *Value) bool {
2433 v_1 := v.Args[1]
2434 v_0 := v.Args[0]
2435 b := v.Block
2436
2437
2438
2439 for {
2440 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2441 x := v_0
2442 if v_1.Op != OpARM64MOVDconst {
2443 continue
2444 }
2445 t := v_1.Type
2446 c := auxIntToInt64(v_1.AuxInt)
2447 if !(!t.IsPtr()) {
2448 continue
2449 }
2450 v.reset(OpARM64ADDconst)
2451 v.AuxInt = int64ToAuxInt(c)
2452 v.AddArg(x)
2453 return true
2454 }
2455 break
2456 }
2457
2458
2459
2460 for {
2461 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2462 a := v_0
2463 l := v_1
2464 if l.Op != OpARM64MUL {
2465 continue
2466 }
2467 y := l.Args[1]
2468 x := l.Args[0]
2469 if !(l.Uses == 1 && clobber(l)) {
2470 continue
2471 }
2472 v.reset(OpARM64MADD)
2473 v.AddArg3(a, x, y)
2474 return true
2475 }
2476 break
2477 }
2478
2479
2480
2481 for {
2482 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2483 a := v_0
2484 l := v_1
2485 if l.Op != OpARM64MNEG {
2486 continue
2487 }
2488 y := l.Args[1]
2489 x := l.Args[0]
2490 if !(l.Uses == 1 && clobber(l)) {
2491 continue
2492 }
2493 v.reset(OpARM64MSUB)
2494 v.AddArg3(a, x, y)
2495 return true
2496 }
2497 break
2498 }
2499
2500
2501
2502 for {
2503 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2504 a := v_0
2505 l := v_1
2506 if l.Op != OpARM64MULW {
2507 continue
2508 }
2509 y := l.Args[1]
2510 x := l.Args[0]
2511 if !(v.Type.Size() <= 4 && l.Uses == 1 && clobber(l)) {
2512 continue
2513 }
2514 v.reset(OpARM64MADDW)
2515 v.AddArg3(a, x, y)
2516 return true
2517 }
2518 break
2519 }
2520
2521
2522
2523 for {
2524 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2525 a := v_0
2526 l := v_1
2527 if l.Op != OpARM64MNEGW {
2528 continue
2529 }
2530 y := l.Args[1]
2531 x := l.Args[0]
2532 if !(v.Type.Size() <= 4 && l.Uses == 1 && clobber(l)) {
2533 continue
2534 }
2535 v.reset(OpARM64MSUBW)
2536 v.AddArg3(a, x, y)
2537 return true
2538 }
2539 break
2540 }
2541
2542
2543
2544 for {
2545 t := v.Type
2546 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2547 a := v_0
2548 p := v_1
2549 if p.Op != OpARM64ADDconst {
2550 continue
2551 }
2552 c := auxIntToInt64(p.AuxInt)
2553 m := p.Args[0]
2554 if m.Op != OpARM64MUL || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
2555 continue
2556 }
2557 v.reset(OpARM64ADDconst)
2558 v.AuxInt = int64ToAuxInt(c)
2559 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
2560 v0.AddArg2(a, m)
2561 v.AddArg(v0)
2562 return true
2563 }
2564 break
2565 }
2566
2567
2568
2569 for {
2570 t := v.Type
2571 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2572 a := v_0
2573 p := v_1
2574 if p.Op != OpARM64ADDconst {
2575 continue
2576 }
2577 c := auxIntToInt64(p.AuxInt)
2578 m := p.Args[0]
2579 if m.Op != OpARM64MULW || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
2580 continue
2581 }
2582 v.reset(OpARM64ADDconst)
2583 v.AuxInt = int64ToAuxInt(c)
2584 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
2585 v0.AddArg2(a, m)
2586 v.AddArg(v0)
2587 return true
2588 }
2589 break
2590 }
2591
2592
2593
2594 for {
2595 t := v.Type
2596 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2597 a := v_0
2598 p := v_1
2599 if p.Op != OpARM64ADDconst {
2600 continue
2601 }
2602 c := auxIntToInt64(p.AuxInt)
2603 m := p.Args[0]
2604 if m.Op != OpARM64MNEG || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
2605 continue
2606 }
2607 v.reset(OpARM64ADDconst)
2608 v.AuxInt = int64ToAuxInt(c)
2609 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
2610 v0.AddArg2(a, m)
2611 v.AddArg(v0)
2612 return true
2613 }
2614 break
2615 }
2616
2617
2618
2619 for {
2620 t := v.Type
2621 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2622 a := v_0
2623 p := v_1
2624 if p.Op != OpARM64ADDconst {
2625 continue
2626 }
2627 c := auxIntToInt64(p.AuxInt)
2628 m := p.Args[0]
2629 if m.Op != OpARM64MNEGW || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
2630 continue
2631 }
2632 v.reset(OpARM64ADDconst)
2633 v.AuxInt = int64ToAuxInt(c)
2634 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
2635 v0.AddArg2(a, m)
2636 v.AddArg(v0)
2637 return true
2638 }
2639 break
2640 }
2641
2642
2643
2644 for {
2645 t := v.Type
2646 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2647 a := v_0
2648 p := v_1
2649 if p.Op != OpARM64SUBconst {
2650 continue
2651 }
2652 c := auxIntToInt64(p.AuxInt)
2653 m := p.Args[0]
2654 if m.Op != OpARM64MUL || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
2655 continue
2656 }
2657 v.reset(OpARM64SUBconst)
2658 v.AuxInt = int64ToAuxInt(c)
2659 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
2660 v0.AddArg2(a, m)
2661 v.AddArg(v0)
2662 return true
2663 }
2664 break
2665 }
2666
2667
2668
2669 for {
2670 t := v.Type
2671 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2672 a := v_0
2673 p := v_1
2674 if p.Op != OpARM64SUBconst {
2675 continue
2676 }
2677 c := auxIntToInt64(p.AuxInt)
2678 m := p.Args[0]
2679 if m.Op != OpARM64MULW || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
2680 continue
2681 }
2682 v.reset(OpARM64SUBconst)
2683 v.AuxInt = int64ToAuxInt(c)
2684 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
2685 v0.AddArg2(a, m)
2686 v.AddArg(v0)
2687 return true
2688 }
2689 break
2690 }
2691
2692
2693
2694 for {
2695 t := v.Type
2696 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2697 a := v_0
2698 p := v_1
2699 if p.Op != OpARM64SUBconst {
2700 continue
2701 }
2702 c := auxIntToInt64(p.AuxInt)
2703 m := p.Args[0]
2704 if m.Op != OpARM64MNEG || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
2705 continue
2706 }
2707 v.reset(OpARM64SUBconst)
2708 v.AuxInt = int64ToAuxInt(c)
2709 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
2710 v0.AddArg2(a, m)
2711 v.AddArg(v0)
2712 return true
2713 }
2714 break
2715 }
2716
2717
2718
2719 for {
2720 t := v.Type
2721 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2722 a := v_0
2723 p := v_1
2724 if p.Op != OpARM64SUBconst {
2725 continue
2726 }
2727 c := auxIntToInt64(p.AuxInt)
2728 m := p.Args[0]
2729 if m.Op != OpARM64MNEGW || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
2730 continue
2731 }
2732 v.reset(OpARM64SUBconst)
2733 v.AuxInt = int64ToAuxInt(c)
2734 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
2735 v0.AddArg2(a, m)
2736 v.AddArg(v0)
2737 return true
2738 }
2739 break
2740 }
2741
2742
2743 for {
2744 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2745 x := v_0
2746 if v_1.Op != OpARM64NEG {
2747 continue
2748 }
2749 y := v_1.Args[0]
2750 v.reset(OpARM64SUB)
2751 v.AddArg2(x, y)
2752 return true
2753 }
2754 break
2755 }
2756
2757
2758
2759 for {
2760 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2761 x0 := v_0
2762 x1 := v_1
2763 if x1.Op != OpARM64SLLconst {
2764 continue
2765 }
2766 c := auxIntToInt64(x1.AuxInt)
2767 y := x1.Args[0]
2768 if !(clobberIfDead(x1)) {
2769 continue
2770 }
2771 v.reset(OpARM64ADDshiftLL)
2772 v.AuxInt = int64ToAuxInt(c)
2773 v.AddArg2(x0, y)
2774 return true
2775 }
2776 break
2777 }
2778
2779
2780
2781 for {
2782 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2783 x0 := v_0
2784 x1 := v_1
2785 if x1.Op != OpARM64SRLconst {
2786 continue
2787 }
2788 c := auxIntToInt64(x1.AuxInt)
2789 y := x1.Args[0]
2790 if !(clobberIfDead(x1)) {
2791 continue
2792 }
2793 v.reset(OpARM64ADDshiftRL)
2794 v.AuxInt = int64ToAuxInt(c)
2795 v.AddArg2(x0, y)
2796 return true
2797 }
2798 break
2799 }
2800
2801
2802
2803 for {
2804 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2805 x0 := v_0
2806 x1 := v_1
2807 if x1.Op != OpARM64SRAconst {
2808 continue
2809 }
2810 c := auxIntToInt64(x1.AuxInt)
2811 y := x1.Args[0]
2812 if !(clobberIfDead(x1)) {
2813 continue
2814 }
2815 v.reset(OpARM64ADDshiftRA)
2816 v.AuxInt = int64ToAuxInt(c)
2817 v.AddArg2(x0, y)
2818 return true
2819 }
2820 break
2821 }
2822
2823
2824
2825 for {
2826 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2827 x0 := v_0
2828 x1 := v_1
2829 if x1.Op != OpARM64ANDshiftRA || auxIntToInt64(x1.AuxInt) != 63 {
2830 continue
2831 }
2832 z := x1.Args[1]
2833 x2 := x1.Args[0]
2834 if x2.Op != OpARM64SLLconst {
2835 continue
2836 }
2837 sl := auxIntToInt64(x2.AuxInt)
2838 y := x2.Args[0]
2839 if !(x1.Uses == 1 && x2.Uses == 1) {
2840 continue
2841 }
2842 v.reset(OpARM64ADDshiftLL)
2843 v.AuxInt = int64ToAuxInt(sl)
2844 v0 := b.NewValue0(v.Pos, OpARM64ANDshiftRA, y.Type)
2845 v0.AuxInt = int64ToAuxInt(63)
2846 v0.AddArg2(y, z)
2847 v.AddArg2(x0, v0)
2848 return true
2849 }
2850 break
2851 }
2852
2853
2854
2855 for {
2856 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2857 x0 := v_0
2858 x1 := v_1
2859 if x1.Op != OpARM64ANDshiftLL {
2860 continue
2861 }
2862 sl := auxIntToInt64(x1.AuxInt)
2863 y := x1.Args[1]
2864 x2 := x1.Args[0]
2865 if x2.Op != OpARM64SRAconst || auxIntToInt64(x2.AuxInt) != 63 {
2866 continue
2867 }
2868 z := x2.Args[0]
2869 if !(x1.Uses == 1 && x2.Uses == 1) {
2870 continue
2871 }
2872 v.reset(OpARM64ADDshiftLL)
2873 v.AuxInt = int64ToAuxInt(sl)
2874 v0 := b.NewValue0(v.Pos, OpARM64ANDshiftRA, y.Type)
2875 v0.AuxInt = int64ToAuxInt(63)
2876 v0.AddArg2(y, z)
2877 v.AddArg2(x0, v0)
2878 return true
2879 }
2880 break
2881 }
2882 return false
2883 }
2884 func rewriteValueARM64_OpARM64ADDSflags(v *Value) bool {
2885 v_1 := v.Args[1]
2886 v_0 := v.Args[0]
2887
2888
2889 for {
2890 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2891 x := v_0
2892 if v_1.Op != OpARM64MOVDconst {
2893 continue
2894 }
2895 c := auxIntToInt64(v_1.AuxInt)
2896 v.reset(OpARM64ADDSconstflags)
2897 v.AuxInt = int64ToAuxInt(c)
2898 v.AddArg(x)
2899 return true
2900 }
2901 break
2902 }
2903 return false
2904 }
2905 func rewriteValueARM64_OpARM64ADDconst(v *Value) bool {
2906 v_0 := v.Args[0]
2907
2908
2909
2910 for {
2911 off1 := auxIntToInt64(v.AuxInt)
2912 if v_0.Op != OpARM64MOVDaddr {
2913 break
2914 }
2915 off2 := auxIntToInt32(v_0.AuxInt)
2916 sym := auxToSym(v_0.Aux)
2917 ptr := v_0.Args[0]
2918 if !(is32Bit(off1 + int64(off2))) {
2919 break
2920 }
2921 v.reset(OpARM64MOVDaddr)
2922 v.AuxInt = int32ToAuxInt(int32(off1) + off2)
2923 v.Aux = symToAux(sym)
2924 v.AddArg(ptr)
2925 return true
2926 }
2927
2928
2929
2930 for {
2931 c := auxIntToInt64(v.AuxInt)
2932 y := v_0
2933 if !(c < 0) {
2934 break
2935 }
2936 v.reset(OpARM64SUBconst)
2937 v.AuxInt = int64ToAuxInt(-c)
2938 v.AddArg(y)
2939 return true
2940 }
2941
2942
2943 for {
2944 if auxIntToInt64(v.AuxInt) != 0 {
2945 break
2946 }
2947 x := v_0
2948 v.copyOf(x)
2949 return true
2950 }
2951
2952
2953 for {
2954 c := auxIntToInt64(v.AuxInt)
2955 if v_0.Op != OpARM64MOVDconst {
2956 break
2957 }
2958 d := auxIntToInt64(v_0.AuxInt)
2959 v.reset(OpARM64MOVDconst)
2960 v.AuxInt = int64ToAuxInt(c + d)
2961 return true
2962 }
2963
2964
2965 for {
2966 c := auxIntToInt64(v.AuxInt)
2967 if v_0.Op != OpARM64ADDconst {
2968 break
2969 }
2970 d := auxIntToInt64(v_0.AuxInt)
2971 x := v_0.Args[0]
2972 v.reset(OpARM64ADDconst)
2973 v.AuxInt = int64ToAuxInt(c + d)
2974 v.AddArg(x)
2975 return true
2976 }
2977
2978
2979 for {
2980 c := auxIntToInt64(v.AuxInt)
2981 if v_0.Op != OpARM64SUBconst {
2982 break
2983 }
2984 d := auxIntToInt64(v_0.AuxInt)
2985 x := v_0.Args[0]
2986 v.reset(OpARM64ADDconst)
2987 v.AuxInt = int64ToAuxInt(c - d)
2988 v.AddArg(x)
2989 return true
2990 }
2991 return false
2992 }
2993 func rewriteValueARM64_OpARM64ADDshiftLL(v *Value) bool {
2994 v_1 := v.Args[1]
2995 v_0 := v.Args[0]
2996 b := v.Block
2997 typ := &b.Func.Config.Types
2998
2999
3000 for {
3001 d := auxIntToInt64(v.AuxInt)
3002 if v_0.Op != OpARM64MOVDconst {
3003 break
3004 }
3005 c := auxIntToInt64(v_0.AuxInt)
3006 x := v_1
3007 v.reset(OpARM64ADDconst)
3008 v.AuxInt = int64ToAuxInt(c)
3009 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
3010 v0.AuxInt = int64ToAuxInt(d)
3011 v0.AddArg(x)
3012 v.AddArg(v0)
3013 return true
3014 }
3015
3016
3017 for {
3018 d := auxIntToInt64(v.AuxInt)
3019 x := v_0
3020 if v_1.Op != OpARM64MOVDconst {
3021 break
3022 }
3023 c := auxIntToInt64(v_1.AuxInt)
3024 v.reset(OpARM64ADDconst)
3025 v.AuxInt = int64ToAuxInt(int64(uint64(c) << uint64(d)))
3026 v.AddArg(x)
3027 return true
3028 }
3029
3030
3031 for {
3032 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) {
3033 break
3034 }
3035 x := v_0.Args[0]
3036 if x != v_1 {
3037 break
3038 }
3039 v.reset(OpARM64REV16W)
3040 v.AddArg(x)
3041 return true
3042 }
3043
3044
3045
3046 for {
3047 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64UBFX || auxIntToArm64BitField(v_0.AuxInt) != armBFAuxInt(8, 24) {
3048 break
3049 }
3050 v_0_0 := v_0.Args[0]
3051 if v_0_0.Op != OpARM64ANDconst {
3052 break
3053 }
3054 c1 := auxIntToInt64(v_0_0.AuxInt)
3055 x := v_0_0.Args[0]
3056 if v_1.Op != OpARM64ANDconst {
3057 break
3058 }
3059 c2 := auxIntToInt64(v_1.AuxInt)
3060 if x != v_1.Args[0] || !(uint32(c1) == 0xff00ff00 && uint32(c2) == 0x00ff00ff) {
3061 break
3062 }
3063 v.reset(OpARM64REV16W)
3064 v.AddArg(x)
3065 return true
3066 }
3067
3068
3069
3070 for {
3071 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
3072 break
3073 }
3074 v_0_0 := v_0.Args[0]
3075 if v_0_0.Op != OpARM64ANDconst {
3076 break
3077 }
3078 c1 := auxIntToInt64(v_0_0.AuxInt)
3079 x := v_0_0.Args[0]
3080 if v_1.Op != OpARM64ANDconst {
3081 break
3082 }
3083 c2 := auxIntToInt64(v_1.AuxInt)
3084 if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00ff00ff00 && uint64(c2) == 0x00ff00ff00ff00ff) {
3085 break
3086 }
3087 v.reset(OpARM64REV16)
3088 v.AddArg(x)
3089 return true
3090 }
3091
3092
3093
3094 for {
3095 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
3096 break
3097 }
3098 v_0_0 := v_0.Args[0]
3099 if v_0_0.Op != OpARM64ANDconst {
3100 break
3101 }
3102 c1 := auxIntToInt64(v_0_0.AuxInt)
3103 x := v_0_0.Args[0]
3104 if v_1.Op != OpARM64ANDconst {
3105 break
3106 }
3107 c2 := auxIntToInt64(v_1.AuxInt)
3108 if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00 && uint64(c2) == 0x00ff00ff) {
3109 break
3110 }
3111 v.reset(OpARM64REV16)
3112 v0 := b.NewValue0(v.Pos, OpARM64ANDconst, x.Type)
3113 v0.AuxInt = int64ToAuxInt(0xffffffff)
3114 v0.AddArg(x)
3115 v.AddArg(v0)
3116 return true
3117 }
3118
3119
3120 for {
3121 c := auxIntToInt64(v.AuxInt)
3122 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 64-c {
3123 break
3124 }
3125 x := v_0.Args[0]
3126 x2 := v_1
3127 v.reset(OpARM64EXTRconst)
3128 v.AuxInt = int64ToAuxInt(64 - c)
3129 v.AddArg2(x2, x)
3130 return true
3131 }
3132
3133
3134
3135 for {
3136 t := v.Type
3137 c := auxIntToInt64(v.AuxInt)
3138 if v_0.Op != OpARM64UBFX {
3139 break
3140 }
3141 bfc := auxIntToArm64BitField(v_0.AuxInt)
3142 x := v_0.Args[0]
3143 x2 := v_1
3144 if !(c < 32 && t.Size() == 4 && bfc == armBFAuxInt(32-c, c)) {
3145 break
3146 }
3147 v.reset(OpARM64EXTRWconst)
3148 v.AuxInt = int64ToAuxInt(32 - c)
3149 v.AddArg2(x2, x)
3150 return true
3151 }
3152 return false
3153 }
3154 func rewriteValueARM64_OpARM64ADDshiftRA(v *Value) bool {
3155 v_1 := v.Args[1]
3156 v_0 := v.Args[0]
3157 b := v.Block
3158
3159
3160 for {
3161 d := auxIntToInt64(v.AuxInt)
3162 if v_0.Op != OpARM64MOVDconst {
3163 break
3164 }
3165 c := auxIntToInt64(v_0.AuxInt)
3166 x := v_1
3167 v.reset(OpARM64ADDconst)
3168 v.AuxInt = int64ToAuxInt(c)
3169 v0 := b.NewValue0(v.Pos, OpARM64SRAconst, x.Type)
3170 v0.AuxInt = int64ToAuxInt(d)
3171 v0.AddArg(x)
3172 v.AddArg(v0)
3173 return true
3174 }
3175
3176
3177 for {
3178 d := auxIntToInt64(v.AuxInt)
3179 x := v_0
3180 if v_1.Op != OpARM64MOVDconst {
3181 break
3182 }
3183 c := auxIntToInt64(v_1.AuxInt)
3184 v.reset(OpARM64ADDconst)
3185 v.AuxInt = int64ToAuxInt(c >> uint64(d))
3186 v.AddArg(x)
3187 return true
3188 }
3189 return false
3190 }
3191 func rewriteValueARM64_OpARM64ADDshiftRL(v *Value) bool {
3192 v_1 := v.Args[1]
3193 v_0 := v.Args[0]
3194 b := v.Block
3195
3196
3197 for {
3198 d := auxIntToInt64(v.AuxInt)
3199 if v_0.Op != OpARM64MOVDconst {
3200 break
3201 }
3202 c := auxIntToInt64(v_0.AuxInt)
3203 x := v_1
3204 v.reset(OpARM64ADDconst)
3205 v.AuxInt = int64ToAuxInt(c)
3206 v0 := b.NewValue0(v.Pos, OpARM64SRLconst, x.Type)
3207 v0.AuxInt = int64ToAuxInt(d)
3208 v0.AddArg(x)
3209 v.AddArg(v0)
3210 return true
3211 }
3212
3213
3214 for {
3215 d := auxIntToInt64(v.AuxInt)
3216 x := v_0
3217 if v_1.Op != OpARM64MOVDconst {
3218 break
3219 }
3220 c := auxIntToInt64(v_1.AuxInt)
3221 v.reset(OpARM64ADDconst)
3222 v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
3223 v.AddArg(x)
3224 return true
3225 }
3226 return false
3227 }
3228 func rewriteValueARM64_OpARM64AND(v *Value) bool {
3229 v_1 := v.Args[1]
3230 v_0 := v.Args[0]
3231
3232
3233 for {
3234 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3235 x := v_0
3236 if v_1.Op != OpARM64MOVDconst {
3237 continue
3238 }
3239 c := auxIntToInt64(v_1.AuxInt)
3240 v.reset(OpARM64ANDconst)
3241 v.AuxInt = int64ToAuxInt(c)
3242 v.AddArg(x)
3243 return true
3244 }
3245 break
3246 }
3247
3248
3249 for {
3250 x := v_0
3251 if x != v_1 {
3252 break
3253 }
3254 v.copyOf(x)
3255 return true
3256 }
3257
3258
3259 for {
3260 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3261 x := v_0
3262 if v_1.Op != OpARM64MVN {
3263 continue
3264 }
3265 y := v_1.Args[0]
3266 v.reset(OpARM64BIC)
3267 v.AddArg2(x, y)
3268 return true
3269 }
3270 break
3271 }
3272
3273
3274
3275 for {
3276 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3277 x0 := v_0
3278 x1 := v_1
3279 if x1.Op != OpARM64SLLconst {
3280 continue
3281 }
3282 c := auxIntToInt64(x1.AuxInt)
3283 y := x1.Args[0]
3284 if !(clobberIfDead(x1)) {
3285 continue
3286 }
3287 v.reset(OpARM64ANDshiftLL)
3288 v.AuxInt = int64ToAuxInt(c)
3289 v.AddArg2(x0, y)
3290 return true
3291 }
3292 break
3293 }
3294
3295
3296
3297 for {
3298 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3299 x0 := v_0
3300 x1 := v_1
3301 if x1.Op != OpARM64SRLconst {
3302 continue
3303 }
3304 c := auxIntToInt64(x1.AuxInt)
3305 y := x1.Args[0]
3306 if !(clobberIfDead(x1)) {
3307 continue
3308 }
3309 v.reset(OpARM64ANDshiftRL)
3310 v.AuxInt = int64ToAuxInt(c)
3311 v.AddArg2(x0, y)
3312 return true
3313 }
3314 break
3315 }
3316
3317
3318
3319 for {
3320 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3321 x0 := v_0
3322 x1 := v_1
3323 if x1.Op != OpARM64SRAconst {
3324 continue
3325 }
3326 c := auxIntToInt64(x1.AuxInt)
3327 y := x1.Args[0]
3328 if !(clobberIfDead(x1)) {
3329 continue
3330 }
3331 v.reset(OpARM64ANDshiftRA)
3332 v.AuxInt = int64ToAuxInt(c)
3333 v.AddArg2(x0, y)
3334 return true
3335 }
3336 break
3337 }
3338
3339
3340
3341 for {
3342 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3343 x0 := v_0
3344 x1 := v_1
3345 if x1.Op != OpARM64RORconst {
3346 continue
3347 }
3348 c := auxIntToInt64(x1.AuxInt)
3349 y := x1.Args[0]
3350 if !(clobberIfDead(x1)) {
3351 continue
3352 }
3353 v.reset(OpARM64ANDshiftRO)
3354 v.AuxInt = int64ToAuxInt(c)
3355 v.AddArg2(x0, y)
3356 return true
3357 }
3358 break
3359 }
3360 return false
3361 }
3362 func rewriteValueARM64_OpARM64ANDconst(v *Value) bool {
3363 v_0 := v.Args[0]
3364
3365
3366 for {
3367 if auxIntToInt64(v.AuxInt) != 0 {
3368 break
3369 }
3370 v.reset(OpARM64MOVDconst)
3371 v.AuxInt = int64ToAuxInt(0)
3372 return true
3373 }
3374
3375
3376 for {
3377 if auxIntToInt64(v.AuxInt) != -1 {
3378 break
3379 }
3380 x := v_0
3381 v.copyOf(x)
3382 return true
3383 }
3384
3385
3386 for {
3387 c := auxIntToInt64(v.AuxInt)
3388 if v_0.Op != OpARM64MOVDconst {
3389 break
3390 }
3391 d := auxIntToInt64(v_0.AuxInt)
3392 v.reset(OpARM64MOVDconst)
3393 v.AuxInt = int64ToAuxInt(c & d)
3394 return true
3395 }
3396
3397
3398 for {
3399 c := auxIntToInt64(v.AuxInt)
3400 if v_0.Op != OpARM64ANDconst {
3401 break
3402 }
3403 d := auxIntToInt64(v_0.AuxInt)
3404 x := v_0.Args[0]
3405 v.reset(OpARM64ANDconst)
3406 v.AuxInt = int64ToAuxInt(c & d)
3407 v.AddArg(x)
3408 return true
3409 }
3410
3411
3412 for {
3413 c := auxIntToInt64(v.AuxInt)
3414 if v_0.Op != OpARM64MOVWUreg {
3415 break
3416 }
3417 x := v_0.Args[0]
3418 v.reset(OpARM64ANDconst)
3419 v.AuxInt = int64ToAuxInt(c & (1<<32 - 1))
3420 v.AddArg(x)
3421 return true
3422 }
3423
3424
3425 for {
3426 c := auxIntToInt64(v.AuxInt)
3427 if v_0.Op != OpARM64MOVHUreg {
3428 break
3429 }
3430 x := v_0.Args[0]
3431 v.reset(OpARM64ANDconst)
3432 v.AuxInt = int64ToAuxInt(c & (1<<16 - 1))
3433 v.AddArg(x)
3434 return true
3435 }
3436
3437
3438 for {
3439 c := auxIntToInt64(v.AuxInt)
3440 if v_0.Op != OpARM64MOVBUreg {
3441 break
3442 }
3443 x := v_0.Args[0]
3444 v.reset(OpARM64ANDconst)
3445 v.AuxInt = int64ToAuxInt(c & (1<<8 - 1))
3446 v.AddArg(x)
3447 return true
3448 }
3449
3450
3451
3452 for {
3453 ac := auxIntToInt64(v.AuxInt)
3454 if v_0.Op != OpARM64SLLconst {
3455 break
3456 }
3457 sc := auxIntToInt64(v_0.AuxInt)
3458 x := v_0.Args[0]
3459 if !(isARM64BFMask(sc, ac, sc)) {
3460 break
3461 }
3462 v.reset(OpARM64UBFIZ)
3463 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(sc, arm64BFWidth(ac, sc)))
3464 v.AddArg(x)
3465 return true
3466 }
3467
3468
3469
3470 for {
3471 ac := auxIntToInt64(v.AuxInt)
3472 if v_0.Op != OpARM64SRLconst {
3473 break
3474 }
3475 sc := auxIntToInt64(v_0.AuxInt)
3476 x := v_0.Args[0]
3477 if !(isARM64BFMask(sc, ac, 0)) {
3478 break
3479 }
3480 v.reset(OpARM64UBFX)
3481 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(sc, arm64BFWidth(ac, 0)))
3482 v.AddArg(x)
3483 return true
3484 }
3485
3486
3487
3488 for {
3489 c := auxIntToInt64(v.AuxInt)
3490 if v_0.Op != OpARM64UBFX {
3491 break
3492 }
3493 bfc := auxIntToArm64BitField(v_0.AuxInt)
3494 x := v_0.Args[0]
3495 if !(isARM64BFMask(0, c, 0)) {
3496 break
3497 }
3498 v.reset(OpARM64UBFX)
3499 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb(), min(bfc.width(), arm64BFWidth(c, 0))))
3500 v.AddArg(x)
3501 return true
3502 }
3503
3504
3505 for {
3506 if auxIntToInt64(v.AuxInt) != 0xffffffff {
3507 break
3508 }
3509 x := v_0
3510 v.reset(OpARM64MOVWUreg)
3511 v.AddArg(x)
3512 return true
3513 }
3514
3515
3516 for {
3517 if auxIntToInt64(v.AuxInt) != 0xffff {
3518 break
3519 }
3520 x := v_0
3521 v.reset(OpARM64MOVHUreg)
3522 v.AddArg(x)
3523 return true
3524 }
3525
3526
3527 for {
3528 if auxIntToInt64(v.AuxInt) != 0xff {
3529 break
3530 }
3531 x := v_0
3532 v.reset(OpARM64MOVBUreg)
3533 v.AddArg(x)
3534 return true
3535 }
3536 return false
3537 }
3538 func rewriteValueARM64_OpARM64ANDshiftLL(v *Value) bool {
3539 v_1 := v.Args[1]
3540 v_0 := v.Args[0]
3541 b := v.Block
3542
3543
3544 for {
3545 d := auxIntToInt64(v.AuxInt)
3546 if v_0.Op != OpARM64MOVDconst {
3547 break
3548 }
3549 c := auxIntToInt64(v_0.AuxInt)
3550 x := v_1
3551 v.reset(OpARM64ANDconst)
3552 v.AuxInt = int64ToAuxInt(c)
3553 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
3554 v0.AuxInt = int64ToAuxInt(d)
3555 v0.AddArg(x)
3556 v.AddArg(v0)
3557 return true
3558 }
3559
3560
3561 for {
3562 d := auxIntToInt64(v.AuxInt)
3563 x := v_0
3564 if v_1.Op != OpARM64MOVDconst {
3565 break
3566 }
3567 c := auxIntToInt64(v_1.AuxInt)
3568 v.reset(OpARM64ANDconst)
3569 v.AuxInt = int64ToAuxInt(int64(uint64(c) << uint64(d)))
3570 v.AddArg(x)
3571 return true
3572 }
3573
3574
3575 for {
3576 c := auxIntToInt64(v.AuxInt)
3577 y := v_0
3578 if y.Op != OpARM64SLLconst || auxIntToInt64(y.AuxInt) != c {
3579 break
3580 }
3581 x := y.Args[0]
3582 if x != v_1 {
3583 break
3584 }
3585 v.copyOf(y)
3586 return true
3587 }
3588 return false
3589 }
3590 func rewriteValueARM64_OpARM64ANDshiftRA(v *Value) bool {
3591 v_1 := v.Args[1]
3592 v_0 := v.Args[0]
3593 b := v.Block
3594
3595
3596 for {
3597 d := auxIntToInt64(v.AuxInt)
3598 if v_0.Op != OpARM64MOVDconst {
3599 break
3600 }
3601 c := auxIntToInt64(v_0.AuxInt)
3602 x := v_1
3603 v.reset(OpARM64ANDconst)
3604 v.AuxInt = int64ToAuxInt(c)
3605 v0 := b.NewValue0(v.Pos, OpARM64SRAconst, x.Type)
3606 v0.AuxInt = int64ToAuxInt(d)
3607 v0.AddArg(x)
3608 v.AddArg(v0)
3609 return true
3610 }
3611
3612
3613 for {
3614 d := auxIntToInt64(v.AuxInt)
3615 x := v_0
3616 if v_1.Op != OpARM64MOVDconst {
3617 break
3618 }
3619 c := auxIntToInt64(v_1.AuxInt)
3620 v.reset(OpARM64ANDconst)
3621 v.AuxInt = int64ToAuxInt(c >> uint64(d))
3622 v.AddArg(x)
3623 return true
3624 }
3625
3626
3627 for {
3628 c := auxIntToInt64(v.AuxInt)
3629 y := v_0
3630 if y.Op != OpARM64SRAconst || auxIntToInt64(y.AuxInt) != c {
3631 break
3632 }
3633 x := y.Args[0]
3634 if x != v_1 {
3635 break
3636 }
3637 v.copyOf(y)
3638 return true
3639 }
3640 return false
3641 }
3642 func rewriteValueARM64_OpARM64ANDshiftRL(v *Value) bool {
3643 v_1 := v.Args[1]
3644 v_0 := v.Args[0]
3645 b := v.Block
3646
3647
3648 for {
3649 d := auxIntToInt64(v.AuxInt)
3650 if v_0.Op != OpARM64MOVDconst {
3651 break
3652 }
3653 c := auxIntToInt64(v_0.AuxInt)
3654 x := v_1
3655 v.reset(OpARM64ANDconst)
3656 v.AuxInt = int64ToAuxInt(c)
3657 v0 := b.NewValue0(v.Pos, OpARM64SRLconst, x.Type)
3658 v0.AuxInt = int64ToAuxInt(d)
3659 v0.AddArg(x)
3660 v.AddArg(v0)
3661 return true
3662 }
3663
3664
3665 for {
3666 d := auxIntToInt64(v.AuxInt)
3667 x := v_0
3668 if v_1.Op != OpARM64MOVDconst {
3669 break
3670 }
3671 c := auxIntToInt64(v_1.AuxInt)
3672 v.reset(OpARM64ANDconst)
3673 v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
3674 v.AddArg(x)
3675 return true
3676 }
3677
3678
3679 for {
3680 c := auxIntToInt64(v.AuxInt)
3681 y := v_0
3682 if y.Op != OpARM64SRLconst || auxIntToInt64(y.AuxInt) != c {
3683 break
3684 }
3685 x := y.Args[0]
3686 if x != v_1 {
3687 break
3688 }
3689 v.copyOf(y)
3690 return true
3691 }
3692 return false
3693 }
3694 func rewriteValueARM64_OpARM64ANDshiftRO(v *Value) bool {
3695 v_1 := v.Args[1]
3696 v_0 := v.Args[0]
3697 b := v.Block
3698
3699
3700 for {
3701 d := auxIntToInt64(v.AuxInt)
3702 if v_0.Op != OpARM64MOVDconst {
3703 break
3704 }
3705 c := auxIntToInt64(v_0.AuxInt)
3706 x := v_1
3707 v.reset(OpARM64ANDconst)
3708 v.AuxInt = int64ToAuxInt(c)
3709 v0 := b.NewValue0(v.Pos, OpARM64RORconst, x.Type)
3710 v0.AuxInt = int64ToAuxInt(d)
3711 v0.AddArg(x)
3712 v.AddArg(v0)
3713 return true
3714 }
3715
3716
3717 for {
3718 d := auxIntToInt64(v.AuxInt)
3719 x := v_0
3720 if v_1.Op != OpARM64MOVDconst {
3721 break
3722 }
3723 c := auxIntToInt64(v_1.AuxInt)
3724 v.reset(OpARM64ANDconst)
3725 v.AuxInt = int64ToAuxInt(rotateRight64(c, d))
3726 v.AddArg(x)
3727 return true
3728 }
3729
3730
3731 for {
3732 c := auxIntToInt64(v.AuxInt)
3733 y := v_0
3734 if y.Op != OpARM64RORconst || auxIntToInt64(y.AuxInt) != c {
3735 break
3736 }
3737 x := y.Args[0]
3738 if x != v_1 {
3739 break
3740 }
3741 v.copyOf(y)
3742 return true
3743 }
3744 return false
3745 }
3746 func rewriteValueARM64_OpARM64BIC(v *Value) bool {
3747 v_1 := v.Args[1]
3748 v_0 := v.Args[0]
3749
3750
3751 for {
3752 x := v_0
3753 if v_1.Op != OpARM64MOVDconst {
3754 break
3755 }
3756 c := auxIntToInt64(v_1.AuxInt)
3757 v.reset(OpARM64ANDconst)
3758 v.AuxInt = int64ToAuxInt(^c)
3759 v.AddArg(x)
3760 return true
3761 }
3762
3763
3764 for {
3765 x := v_0
3766 if x != v_1 {
3767 break
3768 }
3769 v.reset(OpARM64MOVDconst)
3770 v.AuxInt = int64ToAuxInt(0)
3771 return true
3772 }
3773
3774
3775
3776 for {
3777 x0 := v_0
3778 x1 := v_1
3779 if x1.Op != OpARM64SLLconst {
3780 break
3781 }
3782 c := auxIntToInt64(x1.AuxInt)
3783 y := x1.Args[0]
3784 if !(clobberIfDead(x1)) {
3785 break
3786 }
3787 v.reset(OpARM64BICshiftLL)
3788 v.AuxInt = int64ToAuxInt(c)
3789 v.AddArg2(x0, y)
3790 return true
3791 }
3792
3793
3794
3795 for {
3796 x0 := v_0
3797 x1 := v_1
3798 if x1.Op != OpARM64SRLconst {
3799 break
3800 }
3801 c := auxIntToInt64(x1.AuxInt)
3802 y := x1.Args[0]
3803 if !(clobberIfDead(x1)) {
3804 break
3805 }
3806 v.reset(OpARM64BICshiftRL)
3807 v.AuxInt = int64ToAuxInt(c)
3808 v.AddArg2(x0, y)
3809 return true
3810 }
3811
3812
3813
3814 for {
3815 x0 := v_0
3816 x1 := v_1
3817 if x1.Op != OpARM64SRAconst {
3818 break
3819 }
3820 c := auxIntToInt64(x1.AuxInt)
3821 y := x1.Args[0]
3822 if !(clobberIfDead(x1)) {
3823 break
3824 }
3825 v.reset(OpARM64BICshiftRA)
3826 v.AuxInt = int64ToAuxInt(c)
3827 v.AddArg2(x0, y)
3828 return true
3829 }
3830
3831
3832
3833 for {
3834 x0 := v_0
3835 x1 := v_1
3836 if x1.Op != OpARM64RORconst {
3837 break
3838 }
3839 c := auxIntToInt64(x1.AuxInt)
3840 y := x1.Args[0]
3841 if !(clobberIfDead(x1)) {
3842 break
3843 }
3844 v.reset(OpARM64BICshiftRO)
3845 v.AuxInt = int64ToAuxInt(c)
3846 v.AddArg2(x0, y)
3847 return true
3848 }
3849 return false
3850 }
3851 func rewriteValueARM64_OpARM64BICshiftLL(v *Value) bool {
3852 v_1 := v.Args[1]
3853 v_0 := v.Args[0]
3854
3855
3856 for {
3857 d := auxIntToInt64(v.AuxInt)
3858 x := v_0
3859 if v_1.Op != OpARM64MOVDconst {
3860 break
3861 }
3862 c := auxIntToInt64(v_1.AuxInt)
3863 v.reset(OpARM64ANDconst)
3864 v.AuxInt = int64ToAuxInt(^int64(uint64(c) << uint64(d)))
3865 v.AddArg(x)
3866 return true
3867 }
3868
3869
3870 for {
3871 c := auxIntToInt64(v.AuxInt)
3872 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != c {
3873 break
3874 }
3875 x := v_0.Args[0]
3876 if x != v_1 {
3877 break
3878 }
3879 v.reset(OpARM64MOVDconst)
3880 v.AuxInt = int64ToAuxInt(0)
3881 return true
3882 }
3883 return false
3884 }
3885 func rewriteValueARM64_OpARM64BICshiftRA(v *Value) bool {
3886 v_1 := v.Args[1]
3887 v_0 := v.Args[0]
3888
3889
3890 for {
3891 d := auxIntToInt64(v.AuxInt)
3892 x := v_0
3893 if v_1.Op != OpARM64MOVDconst {
3894 break
3895 }
3896 c := auxIntToInt64(v_1.AuxInt)
3897 v.reset(OpARM64ANDconst)
3898 v.AuxInt = int64ToAuxInt(^(c >> uint64(d)))
3899 v.AddArg(x)
3900 return true
3901 }
3902
3903
3904 for {
3905 c := auxIntToInt64(v.AuxInt)
3906 if v_0.Op != OpARM64SRAconst || auxIntToInt64(v_0.AuxInt) != c {
3907 break
3908 }
3909 x := v_0.Args[0]
3910 if x != v_1 {
3911 break
3912 }
3913 v.reset(OpARM64MOVDconst)
3914 v.AuxInt = int64ToAuxInt(0)
3915 return true
3916 }
3917 return false
3918 }
3919 func rewriteValueARM64_OpARM64BICshiftRL(v *Value) bool {
3920 v_1 := v.Args[1]
3921 v_0 := v.Args[0]
3922
3923
3924 for {
3925 d := auxIntToInt64(v.AuxInt)
3926 x := v_0
3927 if v_1.Op != OpARM64MOVDconst {
3928 break
3929 }
3930 c := auxIntToInt64(v_1.AuxInt)
3931 v.reset(OpARM64ANDconst)
3932 v.AuxInt = int64ToAuxInt(^int64(uint64(c) >> uint64(d)))
3933 v.AddArg(x)
3934 return true
3935 }
3936
3937
3938 for {
3939 c := auxIntToInt64(v.AuxInt)
3940 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != c {
3941 break
3942 }
3943 x := v_0.Args[0]
3944 if x != v_1 {
3945 break
3946 }
3947 v.reset(OpARM64MOVDconst)
3948 v.AuxInt = int64ToAuxInt(0)
3949 return true
3950 }
3951 return false
3952 }
3953 func rewriteValueARM64_OpARM64BICshiftRO(v *Value) bool {
3954 v_1 := v.Args[1]
3955 v_0 := v.Args[0]
3956
3957
3958 for {
3959 d := auxIntToInt64(v.AuxInt)
3960 x := v_0
3961 if v_1.Op != OpARM64MOVDconst {
3962 break
3963 }
3964 c := auxIntToInt64(v_1.AuxInt)
3965 v.reset(OpARM64ANDconst)
3966 v.AuxInt = int64ToAuxInt(^rotateRight64(c, d))
3967 v.AddArg(x)
3968 return true
3969 }
3970
3971
3972 for {
3973 c := auxIntToInt64(v.AuxInt)
3974 if v_0.Op != OpARM64RORconst || auxIntToInt64(v_0.AuxInt) != c {
3975 break
3976 }
3977 x := v_0.Args[0]
3978 if x != v_1 {
3979 break
3980 }
3981 v.reset(OpARM64MOVDconst)
3982 v.AuxInt = int64ToAuxInt(0)
3983 return true
3984 }
3985 return false
3986 }
3987 func rewriteValueARM64_OpARM64CMN(v *Value) bool {
3988 v_1 := v.Args[1]
3989 v_0 := v.Args[0]
3990
3991
3992 for {
3993 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3994 x := v_0
3995 if v_1.Op != OpARM64MOVDconst {
3996 continue
3997 }
3998 c := auxIntToInt64(v_1.AuxInt)
3999 v.reset(OpARM64CMNconst)
4000 v.AuxInt = int64ToAuxInt(c)
4001 v.AddArg(x)
4002 return true
4003 }
4004 break
4005 }
4006
4007
4008
4009 for {
4010 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4011 x0 := v_0
4012 x1 := v_1
4013 if x1.Op != OpARM64SLLconst {
4014 continue
4015 }
4016 c := auxIntToInt64(x1.AuxInt)
4017 y := x1.Args[0]
4018 if !(clobberIfDead(x1)) {
4019 continue
4020 }
4021 v.reset(OpARM64CMNshiftLL)
4022 v.AuxInt = int64ToAuxInt(c)
4023 v.AddArg2(x0, y)
4024 return true
4025 }
4026 break
4027 }
4028
4029
4030
4031 for {
4032 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4033 x0 := v_0
4034 x1 := v_1
4035 if x1.Op != OpARM64SRLconst {
4036 continue
4037 }
4038 c := auxIntToInt64(x1.AuxInt)
4039 y := x1.Args[0]
4040 if !(clobberIfDead(x1)) {
4041 continue
4042 }
4043 v.reset(OpARM64CMNshiftRL)
4044 v.AuxInt = int64ToAuxInt(c)
4045 v.AddArg2(x0, y)
4046 return true
4047 }
4048 break
4049 }
4050
4051
4052
4053 for {
4054 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4055 x0 := v_0
4056 x1 := v_1
4057 if x1.Op != OpARM64SRAconst {
4058 continue
4059 }
4060 c := auxIntToInt64(x1.AuxInt)
4061 y := x1.Args[0]
4062 if !(clobberIfDead(x1)) {
4063 continue
4064 }
4065 v.reset(OpARM64CMNshiftRA)
4066 v.AuxInt = int64ToAuxInt(c)
4067 v.AddArg2(x0, y)
4068 return true
4069 }
4070 break
4071 }
4072 return false
4073 }
4074 func rewriteValueARM64_OpARM64CMNW(v *Value) bool {
4075 v_1 := v.Args[1]
4076 v_0 := v.Args[0]
4077
4078
4079 for {
4080 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4081 x := v_0
4082 if v_1.Op != OpARM64MOVDconst {
4083 continue
4084 }
4085 c := auxIntToInt64(v_1.AuxInt)
4086 v.reset(OpARM64CMNWconst)
4087 v.AuxInt = int32ToAuxInt(int32(c))
4088 v.AddArg(x)
4089 return true
4090 }
4091 break
4092 }
4093 return false
4094 }
4095 func rewriteValueARM64_OpARM64CMNWconst(v *Value) bool {
4096 v_0 := v.Args[0]
4097
4098
4099
4100 for {
4101 c := auxIntToInt32(v.AuxInt)
4102 y := v_0
4103 if !(c < 0 && c != -1<<31) {
4104 break
4105 }
4106 v.reset(OpARM64CMPWconst)
4107 v.AuxInt = int32ToAuxInt(-c)
4108 v.AddArg(y)
4109 return true
4110 }
4111
4112
4113 for {
4114 y := auxIntToInt32(v.AuxInt)
4115 if v_0.Op != OpARM64MOVDconst {
4116 break
4117 }
4118 x := auxIntToInt64(v_0.AuxInt)
4119 v.reset(OpARM64FlagConstant)
4120 v.AuxInt = flagConstantToAuxInt(addFlags32(int32(x), y))
4121 return true
4122 }
4123 return false
4124 }
4125 func rewriteValueARM64_OpARM64CMNconst(v *Value) bool {
4126 v_0 := v.Args[0]
4127
4128
4129
4130 for {
4131 c := auxIntToInt64(v.AuxInt)
4132 y := v_0
4133 if !(c < 0 && c != -1<<63) {
4134 break
4135 }
4136 v.reset(OpARM64CMPconst)
4137 v.AuxInt = int64ToAuxInt(-c)
4138 v.AddArg(y)
4139 return true
4140 }
4141
4142
4143 for {
4144 y := auxIntToInt64(v.AuxInt)
4145 if v_0.Op != OpARM64MOVDconst {
4146 break
4147 }
4148 x := auxIntToInt64(v_0.AuxInt)
4149 v.reset(OpARM64FlagConstant)
4150 v.AuxInt = flagConstantToAuxInt(addFlags64(x, y))
4151 return true
4152 }
4153 return false
4154 }
4155 func rewriteValueARM64_OpARM64CMNshiftLL(v *Value) bool {
4156 v_1 := v.Args[1]
4157 v_0 := v.Args[0]
4158 b := v.Block
4159
4160
4161 for {
4162 d := auxIntToInt64(v.AuxInt)
4163 if v_0.Op != OpARM64MOVDconst {
4164 break
4165 }
4166 c := auxIntToInt64(v_0.AuxInt)
4167 x := v_1
4168 v.reset(OpARM64CMNconst)
4169 v.AuxInt = int64ToAuxInt(c)
4170 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
4171 v0.AuxInt = int64ToAuxInt(d)
4172 v0.AddArg(x)
4173 v.AddArg(v0)
4174 return true
4175 }
4176
4177
4178 for {
4179 d := auxIntToInt64(v.AuxInt)
4180 x := v_0
4181 if v_1.Op != OpARM64MOVDconst {
4182 break
4183 }
4184 c := auxIntToInt64(v_1.AuxInt)
4185 v.reset(OpARM64CMNconst)
4186 v.AuxInt = int64ToAuxInt(int64(uint64(c) << uint64(d)))
4187 v.AddArg(x)
4188 return true
4189 }
4190 return false
4191 }
4192 func rewriteValueARM64_OpARM64CMNshiftRA(v *Value) bool {
4193 v_1 := v.Args[1]
4194 v_0 := v.Args[0]
4195 b := v.Block
4196
4197
4198 for {
4199 d := auxIntToInt64(v.AuxInt)
4200 if v_0.Op != OpARM64MOVDconst {
4201 break
4202 }
4203 c := auxIntToInt64(v_0.AuxInt)
4204 x := v_1
4205 v.reset(OpARM64CMNconst)
4206 v.AuxInt = int64ToAuxInt(c)
4207 v0 := b.NewValue0(v.Pos, OpARM64SRAconst, x.Type)
4208 v0.AuxInt = int64ToAuxInt(d)
4209 v0.AddArg(x)
4210 v.AddArg(v0)
4211 return true
4212 }
4213
4214
4215 for {
4216 d := auxIntToInt64(v.AuxInt)
4217 x := v_0
4218 if v_1.Op != OpARM64MOVDconst {
4219 break
4220 }
4221 c := auxIntToInt64(v_1.AuxInt)
4222 v.reset(OpARM64CMNconst)
4223 v.AuxInt = int64ToAuxInt(c >> uint64(d))
4224 v.AddArg(x)
4225 return true
4226 }
4227 return false
4228 }
4229 func rewriteValueARM64_OpARM64CMNshiftRL(v *Value) bool {
4230 v_1 := v.Args[1]
4231 v_0 := v.Args[0]
4232 b := v.Block
4233
4234
4235 for {
4236 d := auxIntToInt64(v.AuxInt)
4237 if v_0.Op != OpARM64MOVDconst {
4238 break
4239 }
4240 c := auxIntToInt64(v_0.AuxInt)
4241 x := v_1
4242 v.reset(OpARM64CMNconst)
4243 v.AuxInt = int64ToAuxInt(c)
4244 v0 := b.NewValue0(v.Pos, OpARM64SRLconst, x.Type)
4245 v0.AuxInt = int64ToAuxInt(d)
4246 v0.AddArg(x)
4247 v.AddArg(v0)
4248 return true
4249 }
4250
4251
4252 for {
4253 d := auxIntToInt64(v.AuxInt)
4254 x := v_0
4255 if v_1.Op != OpARM64MOVDconst {
4256 break
4257 }
4258 c := auxIntToInt64(v_1.AuxInt)
4259 v.reset(OpARM64CMNconst)
4260 v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
4261 v.AddArg(x)
4262 return true
4263 }
4264 return false
4265 }
4266 func rewriteValueARM64_OpARM64CMP(v *Value) bool {
4267 v_1 := v.Args[1]
4268 v_0 := v.Args[0]
4269 b := v.Block
4270
4271
4272 for {
4273 x := v_0
4274 if v_1.Op != OpARM64MOVDconst {
4275 break
4276 }
4277 c := auxIntToInt64(v_1.AuxInt)
4278 v.reset(OpARM64CMPconst)
4279 v.AuxInt = int64ToAuxInt(c)
4280 v.AddArg(x)
4281 return true
4282 }
4283
4284
4285 for {
4286 if v_0.Op != OpARM64MOVDconst {
4287 break
4288 }
4289 c := auxIntToInt64(v_0.AuxInt)
4290 x := v_1
4291 v.reset(OpARM64InvertFlags)
4292 v0 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
4293 v0.AuxInt = int64ToAuxInt(c)
4294 v0.AddArg(x)
4295 v.AddArg(v0)
4296 return true
4297 }
4298
4299
4300
4301 for {
4302 x := v_0
4303 y := v_1
4304 if !(canonLessThan(x, y)) {
4305 break
4306 }
4307 v.reset(OpARM64InvertFlags)
4308 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
4309 v0.AddArg2(y, x)
4310 v.AddArg(v0)
4311 return true
4312 }
4313
4314
4315
4316 for {
4317 x0 := v_0
4318 x1 := v_1
4319 if x1.Op != OpARM64SLLconst {
4320 break
4321 }
4322 c := auxIntToInt64(x1.AuxInt)
4323 y := x1.Args[0]
4324 if !(clobberIfDead(x1)) {
4325 break
4326 }
4327 v.reset(OpARM64CMPshiftLL)
4328 v.AuxInt = int64ToAuxInt(c)
4329 v.AddArg2(x0, y)
4330 return true
4331 }
4332
4333
4334
4335 for {
4336 x0 := v_0
4337 if x0.Op != OpARM64SLLconst {
4338 break
4339 }
4340 c := auxIntToInt64(x0.AuxInt)
4341 y := x0.Args[0]
4342 x1 := v_1
4343 if !(clobberIfDead(x0)) {
4344 break
4345 }
4346 v.reset(OpARM64InvertFlags)
4347 v0 := b.NewValue0(v.Pos, OpARM64CMPshiftLL, types.TypeFlags)
4348 v0.AuxInt = int64ToAuxInt(c)
4349 v0.AddArg2(x1, y)
4350 v.AddArg(v0)
4351 return true
4352 }
4353
4354
4355
4356 for {
4357 x0 := v_0
4358 x1 := v_1
4359 if x1.Op != OpARM64SRLconst {
4360 break
4361 }
4362 c := auxIntToInt64(x1.AuxInt)
4363 y := x1.Args[0]
4364 if !(clobberIfDead(x1)) {
4365 break
4366 }
4367 v.reset(OpARM64CMPshiftRL)
4368 v.AuxInt = int64ToAuxInt(c)
4369 v.AddArg2(x0, y)
4370 return true
4371 }
4372
4373
4374
4375 for {
4376 x0 := v_0
4377 if x0.Op != OpARM64SRLconst {
4378 break
4379 }
4380 c := auxIntToInt64(x0.AuxInt)
4381 y := x0.Args[0]
4382 x1 := v_1
4383 if !(clobberIfDead(x0)) {
4384 break
4385 }
4386 v.reset(OpARM64InvertFlags)
4387 v0 := b.NewValue0(v.Pos, OpARM64CMPshiftRL, types.TypeFlags)
4388 v0.AuxInt = int64ToAuxInt(c)
4389 v0.AddArg2(x1, y)
4390 v.AddArg(v0)
4391 return true
4392 }
4393
4394
4395
4396 for {
4397 x0 := v_0
4398 x1 := v_1
4399 if x1.Op != OpARM64SRAconst {
4400 break
4401 }
4402 c := auxIntToInt64(x1.AuxInt)
4403 y := x1.Args[0]
4404 if !(clobberIfDead(x1)) {
4405 break
4406 }
4407 v.reset(OpARM64CMPshiftRA)
4408 v.AuxInt = int64ToAuxInt(c)
4409 v.AddArg2(x0, y)
4410 return true
4411 }
4412
4413
4414
4415 for {
4416 x0 := v_0
4417 if x0.Op != OpARM64SRAconst {
4418 break
4419 }
4420 c := auxIntToInt64(x0.AuxInt)
4421 y := x0.Args[0]
4422 x1 := v_1
4423 if !(clobberIfDead(x0)) {
4424 break
4425 }
4426 v.reset(OpARM64InvertFlags)
4427 v0 := b.NewValue0(v.Pos, OpARM64CMPshiftRA, types.TypeFlags)
4428 v0.AuxInt = int64ToAuxInt(c)
4429 v0.AddArg2(x1, y)
4430 v.AddArg(v0)
4431 return true
4432 }
4433 return false
4434 }
4435 func rewriteValueARM64_OpARM64CMPW(v *Value) bool {
4436 v_1 := v.Args[1]
4437 v_0 := v.Args[0]
4438 b := v.Block
4439
4440
4441 for {
4442 x := v_0
4443 if v_1.Op != OpARM64MOVDconst {
4444 break
4445 }
4446 c := auxIntToInt64(v_1.AuxInt)
4447 v.reset(OpARM64CMPWconst)
4448 v.AuxInt = int32ToAuxInt(int32(c))
4449 v.AddArg(x)
4450 return true
4451 }
4452
4453
4454 for {
4455 if v_0.Op != OpARM64MOVDconst {
4456 break
4457 }
4458 c := auxIntToInt64(v_0.AuxInt)
4459 x := v_1
4460 v.reset(OpARM64InvertFlags)
4461 v0 := b.NewValue0(v.Pos, OpARM64CMPWconst, types.TypeFlags)
4462 v0.AuxInt = int32ToAuxInt(int32(c))
4463 v0.AddArg(x)
4464 v.AddArg(v0)
4465 return true
4466 }
4467
4468
4469
4470 for {
4471 x := v_0
4472 y := v_1
4473 if !(canonLessThan(x, y)) {
4474 break
4475 }
4476 v.reset(OpARM64InvertFlags)
4477 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
4478 v0.AddArg2(y, x)
4479 v.AddArg(v0)
4480 return true
4481 }
4482 return false
4483 }
4484 func rewriteValueARM64_OpARM64CMPWconst(v *Value) bool {
4485 v_0 := v.Args[0]
4486
4487
4488
4489 for {
4490 c := auxIntToInt32(v.AuxInt)
4491 y := v_0
4492 if !(c < 0 && c != -1<<31) {
4493 break
4494 }
4495 v.reset(OpARM64CMNWconst)
4496 v.AuxInt = int32ToAuxInt(-c)
4497 v.AddArg(y)
4498 return true
4499 }
4500
4501
4502 for {
4503 y := auxIntToInt32(v.AuxInt)
4504 if v_0.Op != OpARM64MOVDconst {
4505 break
4506 }
4507 x := auxIntToInt64(v_0.AuxInt)
4508 v.reset(OpARM64FlagConstant)
4509 v.AuxInt = flagConstantToAuxInt(subFlags32(int32(x), y))
4510 return true
4511 }
4512
4513
4514
4515 for {
4516 c := auxIntToInt32(v.AuxInt)
4517 if v_0.Op != OpARM64MOVBUreg || !(0xff < c) {
4518 break
4519 }
4520 v.reset(OpARM64FlagConstant)
4521 v.AuxInt = flagConstantToAuxInt(subFlags64(0, 1))
4522 return true
4523 }
4524
4525
4526
4527 for {
4528 c := auxIntToInt32(v.AuxInt)
4529 if v_0.Op != OpARM64MOVHUreg || !(0xffff < c) {
4530 break
4531 }
4532 v.reset(OpARM64FlagConstant)
4533 v.AuxInt = flagConstantToAuxInt(subFlags64(0, 1))
4534 return true
4535 }
4536 return false
4537 }
4538 func rewriteValueARM64_OpARM64CMPconst(v *Value) bool {
4539 v_0 := v.Args[0]
4540
4541
4542
4543 for {
4544 c := auxIntToInt64(v.AuxInt)
4545 y := v_0
4546 if !(c < 0 && c != -1<<63) {
4547 break
4548 }
4549 v.reset(OpARM64CMNconst)
4550 v.AuxInt = int64ToAuxInt(-c)
4551 v.AddArg(y)
4552 return true
4553 }
4554
4555
4556 for {
4557 y := auxIntToInt64(v.AuxInt)
4558 if v_0.Op != OpARM64MOVDconst {
4559 break
4560 }
4561 x := auxIntToInt64(v_0.AuxInt)
4562 v.reset(OpARM64FlagConstant)
4563 v.AuxInt = flagConstantToAuxInt(subFlags64(x, y))
4564 return true
4565 }
4566
4567
4568
4569 for {
4570 c := auxIntToInt64(v.AuxInt)
4571 if v_0.Op != OpARM64MOVBUreg || !(0xff < c) {
4572 break
4573 }
4574 v.reset(OpARM64FlagConstant)
4575 v.AuxInt = flagConstantToAuxInt(subFlags64(0, 1))
4576 return true
4577 }
4578
4579
4580
4581 for {
4582 c := auxIntToInt64(v.AuxInt)
4583 if v_0.Op != OpARM64MOVHUreg || !(0xffff < c) {
4584 break
4585 }
4586 v.reset(OpARM64FlagConstant)
4587 v.AuxInt = flagConstantToAuxInt(subFlags64(0, 1))
4588 return true
4589 }
4590
4591
4592
4593 for {
4594 c := auxIntToInt64(v.AuxInt)
4595 if v_0.Op != OpARM64MOVWUreg || !(0xffffffff < c) {
4596 break
4597 }
4598 v.reset(OpARM64FlagConstant)
4599 v.AuxInt = flagConstantToAuxInt(subFlags64(0, 1))
4600 return true
4601 }
4602
4603
4604
4605 for {
4606 n := auxIntToInt64(v.AuxInt)
4607 if v_0.Op != OpARM64ANDconst {
4608 break
4609 }
4610 m := auxIntToInt64(v_0.AuxInt)
4611 if !(0 <= m && m < n) {
4612 break
4613 }
4614 v.reset(OpARM64FlagConstant)
4615 v.AuxInt = flagConstantToAuxInt(subFlags64(0, 1))
4616 return true
4617 }
4618
4619
4620
4621 for {
4622 n := auxIntToInt64(v.AuxInt)
4623 if v_0.Op != OpARM64SRLconst {
4624 break
4625 }
4626 c := auxIntToInt64(v_0.AuxInt)
4627 if !(0 <= n && 0 < c && c <= 63 && (1<<uint64(64-c)) <= uint64(n)) {
4628 break
4629 }
4630 v.reset(OpARM64FlagConstant)
4631 v.AuxInt = flagConstantToAuxInt(subFlags64(0, 1))
4632 return true
4633 }
4634 return false
4635 }
4636 func rewriteValueARM64_OpARM64CMPshiftLL(v *Value) bool {
4637 v_1 := v.Args[1]
4638 v_0 := v.Args[0]
4639 b := v.Block
4640
4641
4642 for {
4643 d := auxIntToInt64(v.AuxInt)
4644 if v_0.Op != OpARM64MOVDconst {
4645 break
4646 }
4647 c := auxIntToInt64(v_0.AuxInt)
4648 x := v_1
4649 v.reset(OpARM64InvertFlags)
4650 v0 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
4651 v0.AuxInt = int64ToAuxInt(c)
4652 v1 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
4653 v1.AuxInt = int64ToAuxInt(d)
4654 v1.AddArg(x)
4655 v0.AddArg(v1)
4656 v.AddArg(v0)
4657 return true
4658 }
4659
4660
4661 for {
4662 d := auxIntToInt64(v.AuxInt)
4663 x := v_0
4664 if v_1.Op != OpARM64MOVDconst {
4665 break
4666 }
4667 c := auxIntToInt64(v_1.AuxInt)
4668 v.reset(OpARM64CMPconst)
4669 v.AuxInt = int64ToAuxInt(int64(uint64(c) << uint64(d)))
4670 v.AddArg(x)
4671 return true
4672 }
4673 return false
4674 }
4675 func rewriteValueARM64_OpARM64CMPshiftRA(v *Value) bool {
4676 v_1 := v.Args[1]
4677 v_0 := v.Args[0]
4678 b := v.Block
4679
4680
4681 for {
4682 d := auxIntToInt64(v.AuxInt)
4683 if v_0.Op != OpARM64MOVDconst {
4684 break
4685 }
4686 c := auxIntToInt64(v_0.AuxInt)
4687 x := v_1
4688 v.reset(OpARM64InvertFlags)
4689 v0 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
4690 v0.AuxInt = int64ToAuxInt(c)
4691 v1 := b.NewValue0(v.Pos, OpARM64SRAconst, x.Type)
4692 v1.AuxInt = int64ToAuxInt(d)
4693 v1.AddArg(x)
4694 v0.AddArg(v1)
4695 v.AddArg(v0)
4696 return true
4697 }
4698
4699
4700 for {
4701 d := auxIntToInt64(v.AuxInt)
4702 x := v_0
4703 if v_1.Op != OpARM64MOVDconst {
4704 break
4705 }
4706 c := auxIntToInt64(v_1.AuxInt)
4707 v.reset(OpARM64CMPconst)
4708 v.AuxInt = int64ToAuxInt(c >> uint64(d))
4709 v.AddArg(x)
4710 return true
4711 }
4712 return false
4713 }
4714 func rewriteValueARM64_OpARM64CMPshiftRL(v *Value) bool {
4715 v_1 := v.Args[1]
4716 v_0 := v.Args[0]
4717 b := v.Block
4718
4719
4720 for {
4721 d := auxIntToInt64(v.AuxInt)
4722 if v_0.Op != OpARM64MOVDconst {
4723 break
4724 }
4725 c := auxIntToInt64(v_0.AuxInt)
4726 x := v_1
4727 v.reset(OpARM64InvertFlags)
4728 v0 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
4729 v0.AuxInt = int64ToAuxInt(c)
4730 v1 := b.NewValue0(v.Pos, OpARM64SRLconst, x.Type)
4731 v1.AuxInt = int64ToAuxInt(d)
4732 v1.AddArg(x)
4733 v0.AddArg(v1)
4734 v.AddArg(v0)
4735 return true
4736 }
4737
4738
4739 for {
4740 d := auxIntToInt64(v.AuxInt)
4741 x := v_0
4742 if v_1.Op != OpARM64MOVDconst {
4743 break
4744 }
4745 c := auxIntToInt64(v_1.AuxInt)
4746 v.reset(OpARM64CMPconst)
4747 v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
4748 v.AddArg(x)
4749 return true
4750 }
4751 return false
4752 }
4753 func rewriteValueARM64_OpARM64CSEL(v *Value) bool {
4754 v_2 := v.Args[2]
4755 v_1 := v.Args[1]
4756 v_0 := v.Args[0]
4757
4758
4759 for {
4760 cc := auxIntToOp(v.AuxInt)
4761 if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != -1 || v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
4762 break
4763 }
4764 flag := v_2
4765 v.reset(OpARM64CSETM)
4766 v.AuxInt = opToAuxInt(cc)
4767 v.AddArg(flag)
4768 return true
4769 }
4770
4771
4772 for {
4773 cc := auxIntToOp(v.AuxInt)
4774 if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 || v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != -1 {
4775 break
4776 }
4777 flag := v_2
4778 v.reset(OpARM64CSETM)
4779 v.AuxInt = opToAuxInt(arm64Negate(cc))
4780 v.AddArg(flag)
4781 return true
4782 }
4783
4784
4785 for {
4786 cc := auxIntToOp(v.AuxInt)
4787 x := v_0
4788 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
4789 break
4790 }
4791 flag := v_2
4792 v.reset(OpARM64CSEL0)
4793 v.AuxInt = opToAuxInt(cc)
4794 v.AddArg2(x, flag)
4795 return true
4796 }
4797
4798
4799 for {
4800 cc := auxIntToOp(v.AuxInt)
4801 if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
4802 break
4803 }
4804 y := v_1
4805 flag := v_2
4806 v.reset(OpARM64CSEL0)
4807 v.AuxInt = opToAuxInt(arm64Negate(cc))
4808 v.AddArg2(y, flag)
4809 return true
4810 }
4811
4812
4813 for {
4814 cc := auxIntToOp(v.AuxInt)
4815 x := v_0
4816 if v_1.Op != OpARM64ADDconst || auxIntToInt64(v_1.AuxInt) != 1 {
4817 break
4818 }
4819 a := v_1.Args[0]
4820 flag := v_2
4821 v.reset(OpARM64CSINC)
4822 v.AuxInt = opToAuxInt(cc)
4823 v.AddArg3(x, a, flag)
4824 return true
4825 }
4826
4827
4828 for {
4829 cc := auxIntToOp(v.AuxInt)
4830 if v_0.Op != OpARM64ADDconst || auxIntToInt64(v_0.AuxInt) != 1 {
4831 break
4832 }
4833 a := v_0.Args[0]
4834 x := v_1
4835 flag := v_2
4836 v.reset(OpARM64CSINC)
4837 v.AuxInt = opToAuxInt(arm64Negate(cc))
4838 v.AddArg3(x, a, flag)
4839 return true
4840 }
4841
4842
4843 for {
4844 cc := auxIntToOp(v.AuxInt)
4845 x := v_0
4846 if v_1.Op != OpARM64MVN {
4847 break
4848 }
4849 a := v_1.Args[0]
4850 flag := v_2
4851 v.reset(OpARM64CSINV)
4852 v.AuxInt = opToAuxInt(cc)
4853 v.AddArg3(x, a, flag)
4854 return true
4855 }
4856
4857
4858 for {
4859 cc := auxIntToOp(v.AuxInt)
4860 if v_0.Op != OpARM64MVN {
4861 break
4862 }
4863 a := v_0.Args[0]
4864 x := v_1
4865 flag := v_2
4866 v.reset(OpARM64CSINV)
4867 v.AuxInt = opToAuxInt(arm64Negate(cc))
4868 v.AddArg3(x, a, flag)
4869 return true
4870 }
4871
4872
4873 for {
4874 cc := auxIntToOp(v.AuxInt)
4875 x := v_0
4876 if v_1.Op != OpARM64NEG {
4877 break
4878 }
4879 a := v_1.Args[0]
4880 flag := v_2
4881 v.reset(OpARM64CSNEG)
4882 v.AuxInt = opToAuxInt(cc)
4883 v.AddArg3(x, a, flag)
4884 return true
4885 }
4886
4887
4888 for {
4889 cc := auxIntToOp(v.AuxInt)
4890 if v_0.Op != OpARM64NEG {
4891 break
4892 }
4893 a := v_0.Args[0]
4894 x := v_1
4895 flag := v_2
4896 v.reset(OpARM64CSNEG)
4897 v.AuxInt = opToAuxInt(arm64Negate(cc))
4898 v.AddArg3(x, a, flag)
4899 return true
4900 }
4901
4902
4903 for {
4904 cc := auxIntToOp(v.AuxInt)
4905 x := v_0
4906 y := v_1
4907 if v_2.Op != OpARM64InvertFlags {
4908 break
4909 }
4910 cmp := v_2.Args[0]
4911 v.reset(OpARM64CSEL)
4912 v.AuxInt = opToAuxInt(arm64Invert(cc))
4913 v.AddArg3(x, y, cmp)
4914 return true
4915 }
4916
4917
4918
4919 for {
4920 cc := auxIntToOp(v.AuxInt)
4921 x := v_0
4922 flag := v_2
4923 if !(ccARM64Eval(cc, flag) > 0) {
4924 break
4925 }
4926 v.copyOf(x)
4927 return true
4928 }
4929
4930
4931
4932 for {
4933 cc := auxIntToOp(v.AuxInt)
4934 y := v_1
4935 flag := v_2
4936 if !(ccARM64Eval(cc, flag) < 0) {
4937 break
4938 }
4939 v.copyOf(y)
4940 return true
4941 }
4942
4943
4944
4945 for {
4946 cc := auxIntToOp(v.AuxInt)
4947 x := v_0
4948 y := v_1
4949 if v_2.Op != OpARM64CMPWconst || auxIntToInt32(v_2.AuxInt) != 0 {
4950 break
4951 }
4952 boolval := v_2.Args[0]
4953 if !(cc == OpARM64NotEqual && flagArg(boolval) != nil) {
4954 break
4955 }
4956 v.reset(OpARM64CSEL)
4957 v.AuxInt = opToAuxInt(boolval.Op)
4958 v.AddArg3(x, y, flagArg(boolval))
4959 return true
4960 }
4961
4962
4963
4964 for {
4965 cc := auxIntToOp(v.AuxInt)
4966 x := v_0
4967 y := v_1
4968 if v_2.Op != OpARM64CMPWconst || auxIntToInt32(v_2.AuxInt) != 0 {
4969 break
4970 }
4971 boolval := v_2.Args[0]
4972 if !(cc == OpARM64Equal && flagArg(boolval) != nil) {
4973 break
4974 }
4975 v.reset(OpARM64CSEL)
4976 v.AuxInt = opToAuxInt(arm64Negate(boolval.Op))
4977 v.AddArg3(x, y, flagArg(boolval))
4978 return true
4979 }
4980 return false
4981 }
4982 func rewriteValueARM64_OpARM64CSEL0(v *Value) bool {
4983 v_1 := v.Args[1]
4984 v_0 := v.Args[0]
4985
4986
4987 for {
4988 cc := auxIntToOp(v.AuxInt)
4989 x := v_0
4990 if v_1.Op != OpARM64InvertFlags {
4991 break
4992 }
4993 cmp := v_1.Args[0]
4994 v.reset(OpARM64CSEL0)
4995 v.AuxInt = opToAuxInt(arm64Invert(cc))
4996 v.AddArg2(x, cmp)
4997 return true
4998 }
4999
5000
5001
5002 for {
5003 cc := auxIntToOp(v.AuxInt)
5004 x := v_0
5005 flag := v_1
5006 if !(ccARM64Eval(cc, flag) > 0) {
5007 break
5008 }
5009 v.copyOf(x)
5010 return true
5011 }
5012
5013
5014
5015 for {
5016 cc := auxIntToOp(v.AuxInt)
5017 flag := v_1
5018 if !(ccARM64Eval(cc, flag) < 0) {
5019 break
5020 }
5021 v.reset(OpARM64MOVDconst)
5022 v.AuxInt = int64ToAuxInt(0)
5023 return true
5024 }
5025
5026
5027
5028 for {
5029 cc := auxIntToOp(v.AuxInt)
5030 x := v_0
5031 if v_1.Op != OpARM64CMPWconst || auxIntToInt32(v_1.AuxInt) != 0 {
5032 break
5033 }
5034 boolval := v_1.Args[0]
5035 if !(cc == OpARM64NotEqual && flagArg(boolval) != nil) {
5036 break
5037 }
5038 v.reset(OpARM64CSEL0)
5039 v.AuxInt = opToAuxInt(boolval.Op)
5040 v.AddArg2(x, flagArg(boolval))
5041 return true
5042 }
5043
5044
5045
5046 for {
5047 cc := auxIntToOp(v.AuxInt)
5048 x := v_0
5049 if v_1.Op != OpARM64CMPWconst || auxIntToInt32(v_1.AuxInt) != 0 {
5050 break
5051 }
5052 boolval := v_1.Args[0]
5053 if !(cc == OpARM64Equal && flagArg(boolval) != nil) {
5054 break
5055 }
5056 v.reset(OpARM64CSEL0)
5057 v.AuxInt = opToAuxInt(arm64Negate(boolval.Op))
5058 v.AddArg2(x, flagArg(boolval))
5059 return true
5060 }
5061 return false
5062 }
5063 func rewriteValueARM64_OpARM64CSETM(v *Value) bool {
5064 v_0 := v.Args[0]
5065
5066
5067 for {
5068 cc := auxIntToOp(v.AuxInt)
5069 if v_0.Op != OpARM64InvertFlags {
5070 break
5071 }
5072 cmp := v_0.Args[0]
5073 v.reset(OpARM64CSETM)
5074 v.AuxInt = opToAuxInt(arm64Invert(cc))
5075 v.AddArg(cmp)
5076 return true
5077 }
5078
5079
5080
5081 for {
5082 cc := auxIntToOp(v.AuxInt)
5083 flag := v_0
5084 if !(ccARM64Eval(cc, flag) > 0) {
5085 break
5086 }
5087 v.reset(OpARM64MOVDconst)
5088 v.AuxInt = int64ToAuxInt(-1)
5089 return true
5090 }
5091
5092
5093
5094 for {
5095 cc := auxIntToOp(v.AuxInt)
5096 flag := v_0
5097 if !(ccARM64Eval(cc, flag) < 0) {
5098 break
5099 }
5100 v.reset(OpARM64MOVDconst)
5101 v.AuxInt = int64ToAuxInt(0)
5102 return true
5103 }
5104 return false
5105 }
5106 func rewriteValueARM64_OpARM64CSINC(v *Value) bool {
5107 v_2 := v.Args[2]
5108 v_1 := v.Args[1]
5109 v_0 := v.Args[0]
5110
5111
5112 for {
5113 cc := auxIntToOp(v.AuxInt)
5114 x := v_0
5115 y := v_1
5116 if v_2.Op != OpARM64InvertFlags {
5117 break
5118 }
5119 cmp := v_2.Args[0]
5120 v.reset(OpARM64CSINC)
5121 v.AuxInt = opToAuxInt(arm64Invert(cc))
5122 v.AddArg3(x, y, cmp)
5123 return true
5124 }
5125
5126
5127
5128 for {
5129 cc := auxIntToOp(v.AuxInt)
5130 x := v_0
5131 flag := v_2
5132 if !(ccARM64Eval(cc, flag) > 0) {
5133 break
5134 }
5135 v.copyOf(x)
5136 return true
5137 }
5138
5139
5140
5141 for {
5142 cc := auxIntToOp(v.AuxInt)
5143 y := v_1
5144 flag := v_2
5145 if !(ccARM64Eval(cc, flag) < 0) {
5146 break
5147 }
5148 v.reset(OpARM64ADDconst)
5149 v.AuxInt = int64ToAuxInt(1)
5150 v.AddArg(y)
5151 return true
5152 }
5153 return false
5154 }
5155 func rewriteValueARM64_OpARM64CSINV(v *Value) bool {
5156 v_2 := v.Args[2]
5157 v_1 := v.Args[1]
5158 v_0 := v.Args[0]
5159
5160
5161 for {
5162 cc := auxIntToOp(v.AuxInt)
5163 x := v_0
5164 y := v_1
5165 if v_2.Op != OpARM64InvertFlags {
5166 break
5167 }
5168 cmp := v_2.Args[0]
5169 v.reset(OpARM64CSINV)
5170 v.AuxInt = opToAuxInt(arm64Invert(cc))
5171 v.AddArg3(x, y, cmp)
5172 return true
5173 }
5174
5175
5176
5177 for {
5178 cc := auxIntToOp(v.AuxInt)
5179 x := v_0
5180 flag := v_2
5181 if !(ccARM64Eval(cc, flag) > 0) {
5182 break
5183 }
5184 v.copyOf(x)
5185 return true
5186 }
5187
5188
5189
5190 for {
5191 cc := auxIntToOp(v.AuxInt)
5192 y := v_1
5193 flag := v_2
5194 if !(ccARM64Eval(cc, flag) < 0) {
5195 break
5196 }
5197 v.reset(OpNot)
5198 v.AddArg(y)
5199 return true
5200 }
5201 return false
5202 }
5203 func rewriteValueARM64_OpARM64CSNEG(v *Value) bool {
5204 v_2 := v.Args[2]
5205 v_1 := v.Args[1]
5206 v_0 := v.Args[0]
5207
5208
5209 for {
5210 cc := auxIntToOp(v.AuxInt)
5211 x := v_0
5212 y := v_1
5213 if v_2.Op != OpARM64InvertFlags {
5214 break
5215 }
5216 cmp := v_2.Args[0]
5217 v.reset(OpARM64CSNEG)
5218 v.AuxInt = opToAuxInt(arm64Invert(cc))
5219 v.AddArg3(x, y, cmp)
5220 return true
5221 }
5222
5223
5224
5225 for {
5226 cc := auxIntToOp(v.AuxInt)
5227 x := v_0
5228 flag := v_2
5229 if !(ccARM64Eval(cc, flag) > 0) {
5230 break
5231 }
5232 v.copyOf(x)
5233 return true
5234 }
5235
5236
5237
5238 for {
5239 cc := auxIntToOp(v.AuxInt)
5240 y := v_1
5241 flag := v_2
5242 if !(ccARM64Eval(cc, flag) < 0) {
5243 break
5244 }
5245 v.reset(OpARM64NEG)
5246 v.AddArg(y)
5247 return true
5248 }
5249 return false
5250 }
5251 func rewriteValueARM64_OpARM64DIV(v *Value) bool {
5252 v_1 := v.Args[1]
5253 v_0 := v.Args[0]
5254
5255
5256
5257 for {
5258 if v_0.Op != OpARM64MOVDconst {
5259 break
5260 }
5261 c := auxIntToInt64(v_0.AuxInt)
5262 if v_1.Op != OpARM64MOVDconst {
5263 break
5264 }
5265 d := auxIntToInt64(v_1.AuxInt)
5266 if !(d != 0) {
5267 break
5268 }
5269 v.reset(OpARM64MOVDconst)
5270 v.AuxInt = int64ToAuxInt(c / d)
5271 return true
5272 }
5273 return false
5274 }
5275 func rewriteValueARM64_OpARM64DIVW(v *Value) bool {
5276 v_1 := v.Args[1]
5277 v_0 := v.Args[0]
5278
5279
5280
5281 for {
5282 if v_0.Op != OpARM64MOVDconst {
5283 break
5284 }
5285 c := auxIntToInt64(v_0.AuxInt)
5286 if v_1.Op != OpARM64MOVDconst {
5287 break
5288 }
5289 d := auxIntToInt64(v_1.AuxInt)
5290 if !(d != 0) {
5291 break
5292 }
5293 v.reset(OpARM64MOVDconst)
5294 v.AuxInt = int64ToAuxInt(int64(uint32(int32(c) / int32(d))))
5295 return true
5296 }
5297 return false
5298 }
5299 func rewriteValueARM64_OpARM64EON(v *Value) bool {
5300 v_1 := v.Args[1]
5301 v_0 := v.Args[0]
5302
5303
5304 for {
5305 x := v_0
5306 if v_1.Op != OpARM64MOVDconst {
5307 break
5308 }
5309 c := auxIntToInt64(v_1.AuxInt)
5310 v.reset(OpARM64XORconst)
5311 v.AuxInt = int64ToAuxInt(^c)
5312 v.AddArg(x)
5313 return true
5314 }
5315
5316
5317 for {
5318 x := v_0
5319 if x != v_1 {
5320 break
5321 }
5322 v.reset(OpARM64MOVDconst)
5323 v.AuxInt = int64ToAuxInt(-1)
5324 return true
5325 }
5326
5327
5328
5329 for {
5330 x0 := v_0
5331 x1 := v_1
5332 if x1.Op != OpARM64SLLconst {
5333 break
5334 }
5335 c := auxIntToInt64(x1.AuxInt)
5336 y := x1.Args[0]
5337 if !(clobberIfDead(x1)) {
5338 break
5339 }
5340 v.reset(OpARM64EONshiftLL)
5341 v.AuxInt = int64ToAuxInt(c)
5342 v.AddArg2(x0, y)
5343 return true
5344 }
5345
5346
5347
5348 for {
5349 x0 := v_0
5350 x1 := v_1
5351 if x1.Op != OpARM64SRLconst {
5352 break
5353 }
5354 c := auxIntToInt64(x1.AuxInt)
5355 y := x1.Args[0]
5356 if !(clobberIfDead(x1)) {
5357 break
5358 }
5359 v.reset(OpARM64EONshiftRL)
5360 v.AuxInt = int64ToAuxInt(c)
5361 v.AddArg2(x0, y)
5362 return true
5363 }
5364
5365
5366
5367 for {
5368 x0 := v_0
5369 x1 := v_1
5370 if x1.Op != OpARM64SRAconst {
5371 break
5372 }
5373 c := auxIntToInt64(x1.AuxInt)
5374 y := x1.Args[0]
5375 if !(clobberIfDead(x1)) {
5376 break
5377 }
5378 v.reset(OpARM64EONshiftRA)
5379 v.AuxInt = int64ToAuxInt(c)
5380 v.AddArg2(x0, y)
5381 return true
5382 }
5383
5384
5385
5386 for {
5387 x0 := v_0
5388 x1 := v_1
5389 if x1.Op != OpARM64RORconst {
5390 break
5391 }
5392 c := auxIntToInt64(x1.AuxInt)
5393 y := x1.Args[0]
5394 if !(clobberIfDead(x1)) {
5395 break
5396 }
5397 v.reset(OpARM64EONshiftRO)
5398 v.AuxInt = int64ToAuxInt(c)
5399 v.AddArg2(x0, y)
5400 return true
5401 }
5402 return false
5403 }
5404 func rewriteValueARM64_OpARM64EONshiftLL(v *Value) bool {
5405 v_1 := v.Args[1]
5406 v_0 := v.Args[0]
5407
5408
5409 for {
5410 d := auxIntToInt64(v.AuxInt)
5411 x := v_0
5412 if v_1.Op != OpARM64MOVDconst {
5413 break
5414 }
5415 c := auxIntToInt64(v_1.AuxInt)
5416 v.reset(OpARM64XORconst)
5417 v.AuxInt = int64ToAuxInt(^int64(uint64(c) << uint64(d)))
5418 v.AddArg(x)
5419 return true
5420 }
5421
5422
5423 for {
5424 c := auxIntToInt64(v.AuxInt)
5425 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != c {
5426 break
5427 }
5428 x := v_0.Args[0]
5429 if x != v_1 {
5430 break
5431 }
5432 v.reset(OpARM64MOVDconst)
5433 v.AuxInt = int64ToAuxInt(-1)
5434 return true
5435 }
5436 return false
5437 }
5438 func rewriteValueARM64_OpARM64EONshiftRA(v *Value) bool {
5439 v_1 := v.Args[1]
5440 v_0 := v.Args[0]
5441
5442
5443 for {
5444 d := auxIntToInt64(v.AuxInt)
5445 x := v_0
5446 if v_1.Op != OpARM64MOVDconst {
5447 break
5448 }
5449 c := auxIntToInt64(v_1.AuxInt)
5450 v.reset(OpARM64XORconst)
5451 v.AuxInt = int64ToAuxInt(^(c >> uint64(d)))
5452 v.AddArg(x)
5453 return true
5454 }
5455
5456
5457 for {
5458 c := auxIntToInt64(v.AuxInt)
5459 if v_0.Op != OpARM64SRAconst || auxIntToInt64(v_0.AuxInt) != c {
5460 break
5461 }
5462 x := v_0.Args[0]
5463 if x != v_1 {
5464 break
5465 }
5466 v.reset(OpARM64MOVDconst)
5467 v.AuxInt = int64ToAuxInt(-1)
5468 return true
5469 }
5470 return false
5471 }
5472 func rewriteValueARM64_OpARM64EONshiftRL(v *Value) bool {
5473 v_1 := v.Args[1]
5474 v_0 := v.Args[0]
5475
5476
5477 for {
5478 d := auxIntToInt64(v.AuxInt)
5479 x := v_0
5480 if v_1.Op != OpARM64MOVDconst {
5481 break
5482 }
5483 c := auxIntToInt64(v_1.AuxInt)
5484 v.reset(OpARM64XORconst)
5485 v.AuxInt = int64ToAuxInt(^int64(uint64(c) >> uint64(d)))
5486 v.AddArg(x)
5487 return true
5488 }
5489
5490
5491 for {
5492 c := auxIntToInt64(v.AuxInt)
5493 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != c {
5494 break
5495 }
5496 x := v_0.Args[0]
5497 if x != v_1 {
5498 break
5499 }
5500 v.reset(OpARM64MOVDconst)
5501 v.AuxInt = int64ToAuxInt(-1)
5502 return true
5503 }
5504 return false
5505 }
5506 func rewriteValueARM64_OpARM64EONshiftRO(v *Value) bool {
5507 v_1 := v.Args[1]
5508 v_0 := v.Args[0]
5509
5510
5511 for {
5512 d := auxIntToInt64(v.AuxInt)
5513 x := v_0
5514 if v_1.Op != OpARM64MOVDconst {
5515 break
5516 }
5517 c := auxIntToInt64(v_1.AuxInt)
5518 v.reset(OpARM64XORconst)
5519 v.AuxInt = int64ToAuxInt(^rotateRight64(c, d))
5520 v.AddArg(x)
5521 return true
5522 }
5523
5524
5525 for {
5526 c := auxIntToInt64(v.AuxInt)
5527 if v_0.Op != OpARM64RORconst || auxIntToInt64(v_0.AuxInt) != c {
5528 break
5529 }
5530 x := v_0.Args[0]
5531 if x != v_1 {
5532 break
5533 }
5534 v.reset(OpARM64MOVDconst)
5535 v.AuxInt = int64ToAuxInt(-1)
5536 return true
5537 }
5538 return false
5539 }
5540 func rewriteValueARM64_OpARM64Equal(v *Value) bool {
5541 v_0 := v.Args[0]
5542 b := v.Block
5543
5544
5545
5546 for {
5547 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
5548 break
5549 }
5550 z := v_0.Args[0]
5551 if z.Op != OpARM64AND {
5552 break
5553 }
5554 y := z.Args[1]
5555 x := z.Args[0]
5556 if !(z.Uses == 1) {
5557 break
5558 }
5559 v.reset(OpARM64Equal)
5560 v0 := b.NewValue0(v.Pos, OpARM64TST, types.TypeFlags)
5561 v0.AddArg2(x, y)
5562 v.AddArg(v0)
5563 return true
5564 }
5565
5566
5567
5568 for {
5569 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
5570 break
5571 }
5572 x := v_0.Args[0]
5573 if x.Op != OpARM64ANDconst {
5574 break
5575 }
5576 c := auxIntToInt64(x.AuxInt)
5577 y := x.Args[0]
5578 if !(x.Uses == 1) {
5579 break
5580 }
5581 v.reset(OpARM64Equal)
5582 v0 := b.NewValue0(v.Pos, OpARM64TSTWconst, types.TypeFlags)
5583 v0.AuxInt = int32ToAuxInt(int32(c))
5584 v0.AddArg(y)
5585 v.AddArg(v0)
5586 return true
5587 }
5588
5589
5590
5591 for {
5592 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
5593 break
5594 }
5595 z := v_0.Args[0]
5596 if z.Op != OpARM64AND {
5597 break
5598 }
5599 y := z.Args[1]
5600 x := z.Args[0]
5601 if !(z.Uses == 1) {
5602 break
5603 }
5604 v.reset(OpARM64Equal)
5605 v0 := b.NewValue0(v.Pos, OpARM64TSTW, types.TypeFlags)
5606 v0.AddArg2(x, y)
5607 v.AddArg(v0)
5608 return true
5609 }
5610
5611
5612
5613 for {
5614 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
5615 break
5616 }
5617 x := v_0.Args[0]
5618 if x.Op != OpARM64ANDconst {
5619 break
5620 }
5621 c := auxIntToInt64(x.AuxInt)
5622 y := x.Args[0]
5623 if !(x.Uses == 1) {
5624 break
5625 }
5626 v.reset(OpARM64Equal)
5627 v0 := b.NewValue0(v.Pos, OpARM64TSTconst, types.TypeFlags)
5628 v0.AuxInt = int64ToAuxInt(c)
5629 v0.AddArg(y)
5630 v.AddArg(v0)
5631 return true
5632 }
5633
5634
5635
5636 for {
5637 if v_0.Op != OpARM64CMP {
5638 break
5639 }
5640 _ = v_0.Args[1]
5641 x := v_0.Args[0]
5642 z := v_0.Args[1]
5643 if z.Op != OpARM64NEG {
5644 break
5645 }
5646 y := z.Args[0]
5647 if !(z.Uses == 1) {
5648 break
5649 }
5650 v.reset(OpARM64Equal)
5651 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
5652 v0.AddArg2(x, y)
5653 v.AddArg(v0)
5654 return true
5655 }
5656
5657
5658
5659 for {
5660 if v_0.Op != OpARM64CMPW {
5661 break
5662 }
5663 _ = v_0.Args[1]
5664 x := v_0.Args[0]
5665 z := v_0.Args[1]
5666 if z.Op != OpARM64NEG {
5667 break
5668 }
5669 y := z.Args[0]
5670 if !(z.Uses == 1) {
5671 break
5672 }
5673 v.reset(OpARM64Equal)
5674 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
5675 v0.AddArg2(x, y)
5676 v.AddArg(v0)
5677 return true
5678 }
5679
5680
5681
5682 for {
5683 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
5684 break
5685 }
5686 x := v_0.Args[0]
5687 if x.Op != OpARM64ADDconst {
5688 break
5689 }
5690 c := auxIntToInt64(x.AuxInt)
5691 y := x.Args[0]
5692 if !(x.Uses == 1) {
5693 break
5694 }
5695 v.reset(OpARM64Equal)
5696 v0 := b.NewValue0(v.Pos, OpARM64CMNconst, types.TypeFlags)
5697 v0.AuxInt = int64ToAuxInt(c)
5698 v0.AddArg(y)
5699 v.AddArg(v0)
5700 return true
5701 }
5702
5703
5704
5705 for {
5706 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
5707 break
5708 }
5709 x := v_0.Args[0]
5710 if x.Op != OpARM64ADDconst {
5711 break
5712 }
5713 c := auxIntToInt64(x.AuxInt)
5714 y := x.Args[0]
5715 if !(x.Uses == 1) {
5716 break
5717 }
5718 v.reset(OpARM64Equal)
5719 v0 := b.NewValue0(v.Pos, OpARM64CMNWconst, types.TypeFlags)
5720 v0.AuxInt = int32ToAuxInt(int32(c))
5721 v0.AddArg(y)
5722 v.AddArg(v0)
5723 return true
5724 }
5725
5726
5727
5728 for {
5729 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
5730 break
5731 }
5732 z := v_0.Args[0]
5733 if z.Op != OpARM64ADD {
5734 break
5735 }
5736 y := z.Args[1]
5737 x := z.Args[0]
5738 if !(z.Uses == 1) {
5739 break
5740 }
5741 v.reset(OpARM64Equal)
5742 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
5743 v0.AddArg2(x, y)
5744 v.AddArg(v0)
5745 return true
5746 }
5747
5748
5749
5750 for {
5751 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
5752 break
5753 }
5754 z := v_0.Args[0]
5755 if z.Op != OpARM64ADD {
5756 break
5757 }
5758 y := z.Args[1]
5759 x := z.Args[0]
5760 if !(z.Uses == 1) {
5761 break
5762 }
5763 v.reset(OpARM64Equal)
5764 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
5765 v0.AddArg2(x, y)
5766 v.AddArg(v0)
5767 return true
5768 }
5769
5770
5771
5772 for {
5773 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
5774 break
5775 }
5776 z := v_0.Args[0]
5777 if z.Op != OpARM64MADD {
5778 break
5779 }
5780 y := z.Args[2]
5781 a := z.Args[0]
5782 x := z.Args[1]
5783 if !(z.Uses == 1) {
5784 break
5785 }
5786 v.reset(OpARM64Equal)
5787 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
5788 v1 := b.NewValue0(v.Pos, OpARM64MUL, x.Type)
5789 v1.AddArg2(x, y)
5790 v0.AddArg2(a, v1)
5791 v.AddArg(v0)
5792 return true
5793 }
5794
5795
5796
5797 for {
5798 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
5799 break
5800 }
5801 z := v_0.Args[0]
5802 if z.Op != OpARM64MADDW {
5803 break
5804 }
5805 y := z.Args[2]
5806 a := z.Args[0]
5807 x := z.Args[1]
5808 if !(z.Uses == 1) {
5809 break
5810 }
5811 v.reset(OpARM64Equal)
5812 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
5813 v1 := b.NewValue0(v.Pos, OpARM64MULW, x.Type)
5814 v1.AddArg2(x, y)
5815 v0.AddArg2(a, v1)
5816 v.AddArg(v0)
5817 return true
5818 }
5819
5820
5821
5822 for {
5823 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
5824 break
5825 }
5826 z := v_0.Args[0]
5827 if z.Op != OpARM64MSUB {
5828 break
5829 }
5830 y := z.Args[2]
5831 a := z.Args[0]
5832 x := z.Args[1]
5833 if !(z.Uses == 1) {
5834 break
5835 }
5836 v.reset(OpARM64Equal)
5837 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
5838 v1 := b.NewValue0(v.Pos, OpARM64MUL, x.Type)
5839 v1.AddArg2(x, y)
5840 v0.AddArg2(a, v1)
5841 v.AddArg(v0)
5842 return true
5843 }
5844
5845
5846
5847 for {
5848 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
5849 break
5850 }
5851 z := v_0.Args[0]
5852 if z.Op != OpARM64MSUBW {
5853 break
5854 }
5855 y := z.Args[2]
5856 a := z.Args[0]
5857 x := z.Args[1]
5858 if !(z.Uses == 1) {
5859 break
5860 }
5861 v.reset(OpARM64Equal)
5862 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
5863 v1 := b.NewValue0(v.Pos, OpARM64MULW, x.Type)
5864 v1.AddArg2(x, y)
5865 v0.AddArg2(a, v1)
5866 v.AddArg(v0)
5867 return true
5868 }
5869
5870
5871 for {
5872 if v_0.Op != OpARM64FlagConstant {
5873 break
5874 }
5875 fc := auxIntToFlagConstant(v_0.AuxInt)
5876 v.reset(OpARM64MOVDconst)
5877 v.AuxInt = int64ToAuxInt(b2i(fc.eq()))
5878 return true
5879 }
5880
5881
5882 for {
5883 if v_0.Op != OpARM64InvertFlags {
5884 break
5885 }
5886 x := v_0.Args[0]
5887 v.reset(OpARM64Equal)
5888 v.AddArg(x)
5889 return true
5890 }
5891 return false
5892 }
5893 func rewriteValueARM64_OpARM64FADDD(v *Value) bool {
5894 v_1 := v.Args[1]
5895 v_0 := v.Args[0]
5896
5897
5898
5899 for {
5900 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
5901 a := v_0
5902 if v_1.Op != OpARM64FMULD {
5903 continue
5904 }
5905 y := v_1.Args[1]
5906 x := v_1.Args[0]
5907 if !(a.Block.Func.useFMA(v)) {
5908 continue
5909 }
5910 v.reset(OpARM64FMADDD)
5911 v.AddArg3(a, x, y)
5912 return true
5913 }
5914 break
5915 }
5916
5917
5918
5919 for {
5920 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
5921 a := v_0
5922 if v_1.Op != OpARM64FNMULD {
5923 continue
5924 }
5925 y := v_1.Args[1]
5926 x := v_1.Args[0]
5927 if !(a.Block.Func.useFMA(v)) {
5928 continue
5929 }
5930 v.reset(OpARM64FMSUBD)
5931 v.AddArg3(a, x, y)
5932 return true
5933 }
5934 break
5935 }
5936 return false
5937 }
5938 func rewriteValueARM64_OpARM64FADDS(v *Value) bool {
5939 v_1 := v.Args[1]
5940 v_0 := v.Args[0]
5941
5942
5943
5944 for {
5945 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
5946 a := v_0
5947 if v_1.Op != OpARM64FMULS {
5948 continue
5949 }
5950 y := v_1.Args[1]
5951 x := v_1.Args[0]
5952 if !(a.Block.Func.useFMA(v)) {
5953 continue
5954 }
5955 v.reset(OpARM64FMADDS)
5956 v.AddArg3(a, x, y)
5957 return true
5958 }
5959 break
5960 }
5961
5962
5963
5964 for {
5965 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
5966 a := v_0
5967 if v_1.Op != OpARM64FNMULS {
5968 continue
5969 }
5970 y := v_1.Args[1]
5971 x := v_1.Args[0]
5972 if !(a.Block.Func.useFMA(v)) {
5973 continue
5974 }
5975 v.reset(OpARM64FMSUBS)
5976 v.AddArg3(a, x, y)
5977 return true
5978 }
5979 break
5980 }
5981 return false
5982 }
5983 func rewriteValueARM64_OpARM64FCMPD(v *Value) bool {
5984 v_1 := v.Args[1]
5985 v_0 := v.Args[0]
5986 b := v.Block
5987
5988
5989 for {
5990 x := v_0
5991 if v_1.Op != OpARM64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != 0 {
5992 break
5993 }
5994 v.reset(OpARM64FCMPD0)
5995 v.AddArg(x)
5996 return true
5997 }
5998
5999
6000 for {
6001 if v_0.Op != OpARM64FMOVDconst || auxIntToFloat64(v_0.AuxInt) != 0 {
6002 break
6003 }
6004 x := v_1
6005 v.reset(OpARM64InvertFlags)
6006 v0 := b.NewValue0(v.Pos, OpARM64FCMPD0, types.TypeFlags)
6007 v0.AddArg(x)
6008 v.AddArg(v0)
6009 return true
6010 }
6011 return false
6012 }
6013 func rewriteValueARM64_OpARM64FCMPS(v *Value) bool {
6014 v_1 := v.Args[1]
6015 v_0 := v.Args[0]
6016 b := v.Block
6017
6018
6019 for {
6020 x := v_0
6021 if v_1.Op != OpARM64FMOVSconst || auxIntToFloat64(v_1.AuxInt) != 0 {
6022 break
6023 }
6024 v.reset(OpARM64FCMPS0)
6025 v.AddArg(x)
6026 return true
6027 }
6028
6029
6030 for {
6031 if v_0.Op != OpARM64FMOVSconst || auxIntToFloat64(v_0.AuxInt) != 0 {
6032 break
6033 }
6034 x := v_1
6035 v.reset(OpARM64InvertFlags)
6036 v0 := b.NewValue0(v.Pos, OpARM64FCMPS0, types.TypeFlags)
6037 v0.AddArg(x)
6038 v.AddArg(v0)
6039 return true
6040 }
6041 return false
6042 }
6043 func rewriteValueARM64_OpARM64FCSELD(v *Value) bool {
6044 v_2 := v.Args[2]
6045 v_1 := v.Args[1]
6046 v_0 := v.Args[0]
6047
6048
6049 for {
6050 cc := auxIntToOp(v.AuxInt)
6051 x := v_0
6052 y := v_1
6053 if v_2.Op != OpARM64InvertFlags {
6054 break
6055 }
6056 cmp := v_2.Args[0]
6057 v.reset(OpARM64FCSELD)
6058 v.AuxInt = opToAuxInt(arm64Invert(cc))
6059 v.AddArg3(x, y, cmp)
6060 return true
6061 }
6062 return false
6063 }
6064 func rewriteValueARM64_OpARM64FCSELS(v *Value) bool {
6065 v_2 := v.Args[2]
6066 v_1 := v.Args[1]
6067 v_0 := v.Args[0]
6068
6069
6070 for {
6071 cc := auxIntToOp(v.AuxInt)
6072 x := v_0
6073 y := v_1
6074 if v_2.Op != OpARM64InvertFlags {
6075 break
6076 }
6077 cmp := v_2.Args[0]
6078 v.reset(OpARM64FCSELS)
6079 v.AuxInt = opToAuxInt(arm64Invert(cc))
6080 v.AddArg3(x, y, cmp)
6081 return true
6082 }
6083 return false
6084 }
6085 func rewriteValueARM64_OpARM64FCVTDS(v *Value) bool {
6086 v_0 := v.Args[0]
6087
6088
6089 for {
6090 if v_0.Op != OpARM64FABSD {
6091 break
6092 }
6093 v_0_0 := v_0.Args[0]
6094 if v_0_0.Op != OpARM64FCVTSD {
6095 break
6096 }
6097 x := v_0_0.Args[0]
6098 v.reset(OpARM64FABSS)
6099 v.AddArg(x)
6100 return true
6101 }
6102
6103
6104 for {
6105 if v_0.Op != OpARM64FSQRTD {
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(OpARM64FSQRTS)
6114 v.AddArg(x)
6115 return true
6116 }
6117
6118
6119 for {
6120 if v_0.Op != OpARM64FRINTPD {
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(OpARM64FRINTPS)
6129 v.AddArg(x)
6130 return true
6131 }
6132
6133
6134 for {
6135 if v_0.Op != OpARM64FRINTMD {
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(OpARM64FRINTMS)
6144 v.AddArg(x)
6145 return true
6146 }
6147
6148
6149 for {
6150 if v_0.Op != OpARM64FRINTAD {
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(OpARM64FRINTAS)
6159 v.AddArg(x)
6160 return true
6161 }
6162
6163
6164 for {
6165 if v_0.Op != OpARM64FRINTND {
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(OpARM64FRINTNS)
6174 v.AddArg(x)
6175 return true
6176 }
6177
6178
6179 for {
6180 if v_0.Op != OpARM64FRINTZD {
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(OpARM64FRINTZS)
6189 v.AddArg(x)
6190 return true
6191 }
6192 return false
6193 }
6194 func rewriteValueARM64_OpARM64FLDPQ(v *Value) bool {
6195 v_1 := v.Args[1]
6196 v_0 := v.Args[0]
6197 b := v.Block
6198 config := b.Func.Config
6199
6200
6201
6202 for {
6203 off1 := auxIntToInt32(v.AuxInt)
6204 sym := auxToSym(v.Aux)
6205 if v_0.Op != OpARM64ADDconst {
6206 break
6207 }
6208 off2 := auxIntToInt64(v_0.AuxInt)
6209 ptr := v_0.Args[0]
6210 mem := v_1
6211 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6212 break
6213 }
6214 v.reset(OpARM64FLDPQ)
6215 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6216 v.Aux = symToAux(sym)
6217 v.AddArg2(ptr, mem)
6218 return true
6219 }
6220
6221
6222
6223 for {
6224 off1 := auxIntToInt32(v.AuxInt)
6225 sym1 := auxToSym(v.Aux)
6226 if v_0.Op != OpARM64MOVDaddr {
6227 break
6228 }
6229 off2 := auxIntToInt32(v_0.AuxInt)
6230 sym2 := auxToSym(v_0.Aux)
6231 ptr := v_0.Args[0]
6232 mem := v_1
6233 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6234 break
6235 }
6236 v.reset(OpARM64FLDPQ)
6237 v.AuxInt = int32ToAuxInt(off1 + off2)
6238 v.Aux = symToAux(mergeSym(sym1, sym2))
6239 v.AddArg2(ptr, mem)
6240 return true
6241 }
6242 return false
6243 }
6244 func rewriteValueARM64_OpARM64FMOVDfpgp(v *Value) bool {
6245 v_0 := v.Args[0]
6246 b := v.Block
6247
6248
6249 for {
6250 t := v.Type
6251 if v_0.Op != OpArg {
6252 break
6253 }
6254 off := auxIntToInt32(v_0.AuxInt)
6255 sym := auxToSym(v_0.Aux)
6256 b = b.Func.Entry
6257 v0 := b.NewValue0(v.Pos, OpArg, t)
6258 v.copyOf(v0)
6259 v0.AuxInt = int32ToAuxInt(off)
6260 v0.Aux = symToAux(sym)
6261 return true
6262 }
6263 return false
6264 }
6265 func rewriteValueARM64_OpARM64FMOVDgpfp(v *Value) bool {
6266 v_0 := v.Args[0]
6267 b := v.Block
6268
6269
6270 for {
6271 t := v.Type
6272 if v_0.Op != OpArg {
6273 break
6274 }
6275 off := auxIntToInt32(v_0.AuxInt)
6276 sym := auxToSym(v_0.Aux)
6277 b = b.Func.Entry
6278 v0 := b.NewValue0(v.Pos, OpArg, t)
6279 v.copyOf(v0)
6280 v0.AuxInt = int32ToAuxInt(off)
6281 v0.Aux = symToAux(sym)
6282 return true
6283 }
6284 return false
6285 }
6286 func rewriteValueARM64_OpARM64FMOVDload(v *Value) bool {
6287 v_1 := v.Args[1]
6288 v_0 := v.Args[0]
6289 b := v.Block
6290 config := b.Func.Config
6291
6292
6293 for {
6294 off := auxIntToInt32(v.AuxInt)
6295 sym := auxToSym(v.Aux)
6296 ptr := v_0
6297 if v_1.Op != OpARM64MOVDstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
6298 break
6299 }
6300 val := v_1.Args[1]
6301 if ptr != v_1.Args[0] {
6302 break
6303 }
6304 v.reset(OpARM64FMOVDgpfp)
6305 v.AddArg(val)
6306 return true
6307 }
6308
6309
6310
6311 for {
6312 off1 := auxIntToInt32(v.AuxInt)
6313 sym := auxToSym(v.Aux)
6314 if v_0.Op != OpARM64ADDconst {
6315 break
6316 }
6317 off2 := auxIntToInt64(v_0.AuxInt)
6318 ptr := v_0.Args[0]
6319 mem := v_1
6320 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6321 break
6322 }
6323 v.reset(OpARM64FMOVDload)
6324 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6325 v.Aux = symToAux(sym)
6326 v.AddArg2(ptr, mem)
6327 return true
6328 }
6329
6330
6331
6332 for {
6333 off := auxIntToInt32(v.AuxInt)
6334 sym := auxToSym(v.Aux)
6335 if v_0.Op != OpARM64ADD {
6336 break
6337 }
6338 idx := v_0.Args[1]
6339 ptr := v_0.Args[0]
6340 mem := v_1
6341 if !(off == 0 && sym == nil) {
6342 break
6343 }
6344 v.reset(OpARM64FMOVDloadidx)
6345 v.AddArg3(ptr, idx, mem)
6346 return true
6347 }
6348
6349
6350
6351 for {
6352 off := auxIntToInt32(v.AuxInt)
6353 sym := auxToSym(v.Aux)
6354 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 3 {
6355 break
6356 }
6357 idx := v_0.Args[1]
6358 ptr := v_0.Args[0]
6359 mem := v_1
6360 if !(off == 0 && sym == nil) {
6361 break
6362 }
6363 v.reset(OpARM64FMOVDloadidx8)
6364 v.AddArg3(ptr, idx, mem)
6365 return true
6366 }
6367
6368
6369
6370 for {
6371 off1 := auxIntToInt32(v.AuxInt)
6372 sym1 := auxToSym(v.Aux)
6373 if v_0.Op != OpARM64MOVDaddr {
6374 break
6375 }
6376 off2 := auxIntToInt32(v_0.AuxInt)
6377 sym2 := auxToSym(v_0.Aux)
6378 ptr := v_0.Args[0]
6379 mem := v_1
6380 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6381 break
6382 }
6383 v.reset(OpARM64FMOVDload)
6384 v.AuxInt = int32ToAuxInt(off1 + off2)
6385 v.Aux = symToAux(mergeSym(sym1, sym2))
6386 v.AddArg2(ptr, mem)
6387 return true
6388 }
6389 return false
6390 }
6391 func rewriteValueARM64_OpARM64FMOVDloadidx(v *Value) bool {
6392 v_2 := v.Args[2]
6393 v_1 := v.Args[1]
6394 v_0 := v.Args[0]
6395
6396
6397
6398 for {
6399 ptr := v_0
6400 if v_1.Op != OpARM64MOVDconst {
6401 break
6402 }
6403 c := auxIntToInt64(v_1.AuxInt)
6404 mem := v_2
6405 if !(is32Bit(c)) {
6406 break
6407 }
6408 v.reset(OpARM64FMOVDload)
6409 v.AuxInt = int32ToAuxInt(int32(c))
6410 v.AddArg2(ptr, mem)
6411 return true
6412 }
6413
6414
6415
6416 for {
6417 if v_0.Op != OpARM64MOVDconst {
6418 break
6419 }
6420 c := auxIntToInt64(v_0.AuxInt)
6421 ptr := v_1
6422 mem := v_2
6423 if !(is32Bit(c)) {
6424 break
6425 }
6426 v.reset(OpARM64FMOVDload)
6427 v.AuxInt = int32ToAuxInt(int32(c))
6428 v.AddArg2(ptr, mem)
6429 return true
6430 }
6431
6432
6433 for {
6434 ptr := v_0
6435 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 3 {
6436 break
6437 }
6438 idx := v_1.Args[0]
6439 mem := v_2
6440 v.reset(OpARM64FMOVDloadidx8)
6441 v.AddArg3(ptr, idx, mem)
6442 return true
6443 }
6444
6445
6446 for {
6447 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 3 {
6448 break
6449 }
6450 idx := v_0.Args[0]
6451 ptr := v_1
6452 mem := v_2
6453 v.reset(OpARM64FMOVDloadidx8)
6454 v.AddArg3(ptr, idx, mem)
6455 return true
6456 }
6457 return false
6458 }
6459 func rewriteValueARM64_OpARM64FMOVDloadidx8(v *Value) bool {
6460 v_2 := v.Args[2]
6461 v_1 := v.Args[1]
6462 v_0 := v.Args[0]
6463
6464
6465
6466 for {
6467 ptr := v_0
6468 if v_1.Op != OpARM64MOVDconst {
6469 break
6470 }
6471 c := auxIntToInt64(v_1.AuxInt)
6472 mem := v_2
6473 if !(is32Bit(c << 3)) {
6474 break
6475 }
6476 v.reset(OpARM64FMOVDload)
6477 v.AuxInt = int32ToAuxInt(int32(c) << 3)
6478 v.AddArg2(ptr, mem)
6479 return true
6480 }
6481 return false
6482 }
6483 func rewriteValueARM64_OpARM64FMOVDstore(v *Value) bool {
6484 v_2 := v.Args[2]
6485 v_1 := v.Args[1]
6486 v_0 := v.Args[0]
6487 b := v.Block
6488 config := b.Func.Config
6489
6490
6491 for {
6492 off := auxIntToInt32(v.AuxInt)
6493 sym := auxToSym(v.Aux)
6494 ptr := v_0
6495 if v_1.Op != OpARM64FMOVDgpfp {
6496 break
6497 }
6498 val := v_1.Args[0]
6499 mem := v_2
6500 v.reset(OpARM64MOVDstore)
6501 v.AuxInt = int32ToAuxInt(off)
6502 v.Aux = symToAux(sym)
6503 v.AddArg3(ptr, val, mem)
6504 return true
6505 }
6506
6507
6508
6509 for {
6510 off1 := auxIntToInt32(v.AuxInt)
6511 sym := auxToSym(v.Aux)
6512 if v_0.Op != OpARM64ADDconst {
6513 break
6514 }
6515 off2 := auxIntToInt64(v_0.AuxInt)
6516 ptr := v_0.Args[0]
6517 val := v_1
6518 mem := v_2
6519 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6520 break
6521 }
6522 v.reset(OpARM64FMOVDstore)
6523 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6524 v.Aux = symToAux(sym)
6525 v.AddArg3(ptr, val, mem)
6526 return true
6527 }
6528
6529
6530
6531 for {
6532 off := auxIntToInt32(v.AuxInt)
6533 sym := auxToSym(v.Aux)
6534 if v_0.Op != OpARM64ADD {
6535 break
6536 }
6537 idx := v_0.Args[1]
6538 ptr := v_0.Args[0]
6539 val := v_1
6540 mem := v_2
6541 if !(off == 0 && sym == nil) {
6542 break
6543 }
6544 v.reset(OpARM64FMOVDstoreidx)
6545 v.AddArg4(ptr, idx, val, mem)
6546 return true
6547 }
6548
6549
6550
6551 for {
6552 off := auxIntToInt32(v.AuxInt)
6553 sym := auxToSym(v.Aux)
6554 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 3 {
6555 break
6556 }
6557 idx := v_0.Args[1]
6558 ptr := v_0.Args[0]
6559 val := v_1
6560 mem := v_2
6561 if !(off == 0 && sym == nil) {
6562 break
6563 }
6564 v.reset(OpARM64FMOVDstoreidx8)
6565 v.AddArg4(ptr, idx, val, mem)
6566 return true
6567 }
6568
6569
6570
6571 for {
6572 off1 := auxIntToInt32(v.AuxInt)
6573 sym1 := auxToSym(v.Aux)
6574 if v_0.Op != OpARM64MOVDaddr {
6575 break
6576 }
6577 off2 := auxIntToInt32(v_0.AuxInt)
6578 sym2 := auxToSym(v_0.Aux)
6579 ptr := v_0.Args[0]
6580 val := v_1
6581 mem := v_2
6582 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6583 break
6584 }
6585 v.reset(OpARM64FMOVDstore)
6586 v.AuxInt = int32ToAuxInt(off1 + off2)
6587 v.Aux = symToAux(mergeSym(sym1, sym2))
6588 v.AddArg3(ptr, val, mem)
6589 return true
6590 }
6591 return false
6592 }
6593 func rewriteValueARM64_OpARM64FMOVDstoreidx(v *Value) bool {
6594 v_3 := v.Args[3]
6595 v_2 := v.Args[2]
6596 v_1 := v.Args[1]
6597 v_0 := v.Args[0]
6598
6599
6600
6601 for {
6602 ptr := v_0
6603 if v_1.Op != OpARM64MOVDconst {
6604 break
6605 }
6606 c := auxIntToInt64(v_1.AuxInt)
6607 val := v_2
6608 mem := v_3
6609 if !(is32Bit(c)) {
6610 break
6611 }
6612 v.reset(OpARM64FMOVDstore)
6613 v.AuxInt = int32ToAuxInt(int32(c))
6614 v.AddArg3(ptr, val, mem)
6615 return true
6616 }
6617
6618
6619
6620 for {
6621 if v_0.Op != OpARM64MOVDconst {
6622 break
6623 }
6624 c := auxIntToInt64(v_0.AuxInt)
6625 idx := v_1
6626 val := v_2
6627 mem := v_3
6628 if !(is32Bit(c)) {
6629 break
6630 }
6631 v.reset(OpARM64FMOVDstore)
6632 v.AuxInt = int32ToAuxInt(int32(c))
6633 v.AddArg3(idx, val, mem)
6634 return true
6635 }
6636
6637
6638 for {
6639 ptr := v_0
6640 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 3 {
6641 break
6642 }
6643 idx := v_1.Args[0]
6644 val := v_2
6645 mem := v_3
6646 v.reset(OpARM64FMOVDstoreidx8)
6647 v.AddArg4(ptr, idx, val, mem)
6648 return true
6649 }
6650
6651
6652 for {
6653 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 3 {
6654 break
6655 }
6656 idx := v_0.Args[0]
6657 ptr := v_1
6658 val := v_2
6659 mem := v_3
6660 v.reset(OpARM64FMOVDstoreidx8)
6661 v.AddArg4(ptr, idx, val, mem)
6662 return true
6663 }
6664 return false
6665 }
6666 func rewriteValueARM64_OpARM64FMOVDstoreidx8(v *Value) bool {
6667 v_3 := v.Args[3]
6668 v_2 := v.Args[2]
6669 v_1 := v.Args[1]
6670 v_0 := v.Args[0]
6671
6672
6673
6674 for {
6675 ptr := v_0
6676 if v_1.Op != OpARM64MOVDconst {
6677 break
6678 }
6679 c := auxIntToInt64(v_1.AuxInt)
6680 val := v_2
6681 mem := v_3
6682 if !(is32Bit(c << 3)) {
6683 break
6684 }
6685 v.reset(OpARM64FMOVDstore)
6686 v.AuxInt = int32ToAuxInt(int32(c) << 3)
6687 v.AddArg3(ptr, val, mem)
6688 return true
6689 }
6690 return false
6691 }
6692 func rewriteValueARM64_OpARM64FMOVQload(v *Value) bool {
6693 v_1 := v.Args[1]
6694 v_0 := v.Args[0]
6695 b := v.Block
6696 config := b.Func.Config
6697
6698
6699
6700 for {
6701 off1 := auxIntToInt32(v.AuxInt)
6702 sym := auxToSym(v.Aux)
6703 if v_0.Op != OpARM64ADDconst {
6704 break
6705 }
6706 off2 := auxIntToInt64(v_0.AuxInt)
6707 ptr := v_0.Args[0]
6708 mem := v_1
6709 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6710 break
6711 }
6712 v.reset(OpARM64FMOVQload)
6713 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6714 v.Aux = symToAux(sym)
6715 v.AddArg2(ptr, mem)
6716 return true
6717 }
6718
6719
6720
6721 for {
6722 off1 := auxIntToInt32(v.AuxInt)
6723 sym1 := auxToSym(v.Aux)
6724 if v_0.Op != OpARM64MOVDaddr {
6725 break
6726 }
6727 off2 := auxIntToInt32(v_0.AuxInt)
6728 sym2 := auxToSym(v_0.Aux)
6729 ptr := v_0.Args[0]
6730 mem := v_1
6731 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6732 break
6733 }
6734 v.reset(OpARM64FMOVQload)
6735 v.AuxInt = int32ToAuxInt(off1 + off2)
6736 v.Aux = symToAux(mergeSym(sym1, sym2))
6737 v.AddArg2(ptr, mem)
6738 return true
6739 }
6740 return false
6741 }
6742 func rewriteValueARM64_OpARM64FMOVQstore(v *Value) bool {
6743 v_2 := v.Args[2]
6744 v_1 := v.Args[1]
6745 v_0 := v.Args[0]
6746 b := v.Block
6747 config := b.Func.Config
6748
6749
6750
6751 for {
6752 off1 := auxIntToInt32(v.AuxInt)
6753 sym := auxToSym(v.Aux)
6754 if v_0.Op != OpARM64ADDconst {
6755 break
6756 }
6757 off2 := auxIntToInt64(v_0.AuxInt)
6758 ptr := v_0.Args[0]
6759 val := v_1
6760 mem := v_2
6761 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6762 break
6763 }
6764 v.reset(OpARM64FMOVQstore)
6765 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6766 v.Aux = symToAux(sym)
6767 v.AddArg3(ptr, val, mem)
6768 return true
6769 }
6770
6771
6772
6773 for {
6774 off1 := auxIntToInt32(v.AuxInt)
6775 sym1 := auxToSym(v.Aux)
6776 if v_0.Op != OpARM64MOVDaddr {
6777 break
6778 }
6779 off2 := auxIntToInt32(v_0.AuxInt)
6780 sym2 := auxToSym(v_0.Aux)
6781 ptr := v_0.Args[0]
6782 val := v_1
6783 mem := v_2
6784 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6785 break
6786 }
6787 v.reset(OpARM64FMOVQstore)
6788 v.AuxInt = int32ToAuxInt(off1 + off2)
6789 v.Aux = symToAux(mergeSym(sym1, sym2))
6790 v.AddArg3(ptr, val, mem)
6791 return true
6792 }
6793 return false
6794 }
6795 func rewriteValueARM64_OpARM64FMOVSload(v *Value) bool {
6796 v_1 := v.Args[1]
6797 v_0 := v.Args[0]
6798 b := v.Block
6799 config := b.Func.Config
6800
6801
6802 for {
6803 off := auxIntToInt32(v.AuxInt)
6804 sym := auxToSym(v.Aux)
6805 ptr := v_0
6806 if v_1.Op != OpARM64MOVWstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
6807 break
6808 }
6809 val := v_1.Args[1]
6810 if ptr != v_1.Args[0] {
6811 break
6812 }
6813 v.reset(OpARM64FMOVSgpfp)
6814 v.AddArg(val)
6815 return true
6816 }
6817
6818
6819
6820 for {
6821 off1 := auxIntToInt32(v.AuxInt)
6822 sym := auxToSym(v.Aux)
6823 if v_0.Op != OpARM64ADDconst {
6824 break
6825 }
6826 off2 := auxIntToInt64(v_0.AuxInt)
6827 ptr := v_0.Args[0]
6828 mem := v_1
6829 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6830 break
6831 }
6832 v.reset(OpARM64FMOVSload)
6833 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6834 v.Aux = symToAux(sym)
6835 v.AddArg2(ptr, mem)
6836 return true
6837 }
6838
6839
6840
6841 for {
6842 off := auxIntToInt32(v.AuxInt)
6843 sym := auxToSym(v.Aux)
6844 if v_0.Op != OpARM64ADD {
6845 break
6846 }
6847 idx := v_0.Args[1]
6848 ptr := v_0.Args[0]
6849 mem := v_1
6850 if !(off == 0 && sym == nil) {
6851 break
6852 }
6853 v.reset(OpARM64FMOVSloadidx)
6854 v.AddArg3(ptr, idx, mem)
6855 return true
6856 }
6857
6858
6859
6860 for {
6861 off := auxIntToInt32(v.AuxInt)
6862 sym := auxToSym(v.Aux)
6863 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 2 {
6864 break
6865 }
6866 idx := v_0.Args[1]
6867 ptr := v_0.Args[0]
6868 mem := v_1
6869 if !(off == 0 && sym == nil) {
6870 break
6871 }
6872 v.reset(OpARM64FMOVSloadidx4)
6873 v.AddArg3(ptr, idx, mem)
6874 return true
6875 }
6876
6877
6878
6879 for {
6880 off1 := auxIntToInt32(v.AuxInt)
6881 sym1 := auxToSym(v.Aux)
6882 if v_0.Op != OpARM64MOVDaddr {
6883 break
6884 }
6885 off2 := auxIntToInt32(v_0.AuxInt)
6886 sym2 := auxToSym(v_0.Aux)
6887 ptr := v_0.Args[0]
6888 mem := v_1
6889 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6890 break
6891 }
6892 v.reset(OpARM64FMOVSload)
6893 v.AuxInt = int32ToAuxInt(off1 + off2)
6894 v.Aux = symToAux(mergeSym(sym1, sym2))
6895 v.AddArg2(ptr, mem)
6896 return true
6897 }
6898 return false
6899 }
6900 func rewriteValueARM64_OpARM64FMOVSloadidx(v *Value) bool {
6901 v_2 := v.Args[2]
6902 v_1 := v.Args[1]
6903 v_0 := v.Args[0]
6904
6905
6906
6907 for {
6908 ptr := v_0
6909 if v_1.Op != OpARM64MOVDconst {
6910 break
6911 }
6912 c := auxIntToInt64(v_1.AuxInt)
6913 mem := v_2
6914 if !(is32Bit(c)) {
6915 break
6916 }
6917 v.reset(OpARM64FMOVSload)
6918 v.AuxInt = int32ToAuxInt(int32(c))
6919 v.AddArg2(ptr, mem)
6920 return true
6921 }
6922
6923
6924
6925 for {
6926 if v_0.Op != OpARM64MOVDconst {
6927 break
6928 }
6929 c := auxIntToInt64(v_0.AuxInt)
6930 ptr := v_1
6931 mem := v_2
6932 if !(is32Bit(c)) {
6933 break
6934 }
6935 v.reset(OpARM64FMOVSload)
6936 v.AuxInt = int32ToAuxInt(int32(c))
6937 v.AddArg2(ptr, mem)
6938 return true
6939 }
6940
6941
6942 for {
6943 ptr := v_0
6944 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 2 {
6945 break
6946 }
6947 idx := v_1.Args[0]
6948 mem := v_2
6949 v.reset(OpARM64FMOVSloadidx4)
6950 v.AddArg3(ptr, idx, mem)
6951 return true
6952 }
6953
6954
6955 for {
6956 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 2 {
6957 break
6958 }
6959 idx := v_0.Args[0]
6960 ptr := v_1
6961 mem := v_2
6962 v.reset(OpARM64FMOVSloadidx4)
6963 v.AddArg3(ptr, idx, mem)
6964 return true
6965 }
6966 return false
6967 }
6968 func rewriteValueARM64_OpARM64FMOVSloadidx4(v *Value) bool {
6969 v_2 := v.Args[2]
6970 v_1 := v.Args[1]
6971 v_0 := v.Args[0]
6972
6973
6974
6975 for {
6976 ptr := v_0
6977 if v_1.Op != OpARM64MOVDconst {
6978 break
6979 }
6980 c := auxIntToInt64(v_1.AuxInt)
6981 mem := v_2
6982 if !(is32Bit(c << 2)) {
6983 break
6984 }
6985 v.reset(OpARM64FMOVSload)
6986 v.AuxInt = int32ToAuxInt(int32(c) << 2)
6987 v.AddArg2(ptr, mem)
6988 return true
6989 }
6990 return false
6991 }
6992 func rewriteValueARM64_OpARM64FMOVSstore(v *Value) bool {
6993 v_2 := v.Args[2]
6994 v_1 := v.Args[1]
6995 v_0 := v.Args[0]
6996 b := v.Block
6997 config := b.Func.Config
6998
6999
7000 for {
7001 off := auxIntToInt32(v.AuxInt)
7002 sym := auxToSym(v.Aux)
7003 ptr := v_0
7004 if v_1.Op != OpARM64FMOVSgpfp {
7005 break
7006 }
7007 val := v_1.Args[0]
7008 mem := v_2
7009 v.reset(OpARM64MOVWstore)
7010 v.AuxInt = int32ToAuxInt(off)
7011 v.Aux = symToAux(sym)
7012 v.AddArg3(ptr, val, mem)
7013 return true
7014 }
7015
7016
7017
7018 for {
7019 off1 := auxIntToInt32(v.AuxInt)
7020 sym := auxToSym(v.Aux)
7021 if v_0.Op != OpARM64ADDconst {
7022 break
7023 }
7024 off2 := auxIntToInt64(v_0.AuxInt)
7025 ptr := v_0.Args[0]
7026 val := v_1
7027 mem := v_2
7028 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
7029 break
7030 }
7031 v.reset(OpARM64FMOVSstore)
7032 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
7033 v.Aux = symToAux(sym)
7034 v.AddArg3(ptr, val, mem)
7035 return true
7036 }
7037
7038
7039
7040 for {
7041 off := auxIntToInt32(v.AuxInt)
7042 sym := auxToSym(v.Aux)
7043 if v_0.Op != OpARM64ADD {
7044 break
7045 }
7046 idx := v_0.Args[1]
7047 ptr := v_0.Args[0]
7048 val := v_1
7049 mem := v_2
7050 if !(off == 0 && sym == nil) {
7051 break
7052 }
7053 v.reset(OpARM64FMOVSstoreidx)
7054 v.AddArg4(ptr, idx, val, mem)
7055 return true
7056 }
7057
7058
7059
7060 for {
7061 off := auxIntToInt32(v.AuxInt)
7062 sym := auxToSym(v.Aux)
7063 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 2 {
7064 break
7065 }
7066 idx := v_0.Args[1]
7067 ptr := v_0.Args[0]
7068 val := v_1
7069 mem := v_2
7070 if !(off == 0 && sym == nil) {
7071 break
7072 }
7073 v.reset(OpARM64FMOVSstoreidx4)
7074 v.AddArg4(ptr, idx, val, mem)
7075 return true
7076 }
7077
7078
7079
7080 for {
7081 off1 := auxIntToInt32(v.AuxInt)
7082 sym1 := auxToSym(v.Aux)
7083 if v_0.Op != OpARM64MOVDaddr {
7084 break
7085 }
7086 off2 := auxIntToInt32(v_0.AuxInt)
7087 sym2 := auxToSym(v_0.Aux)
7088 ptr := v_0.Args[0]
7089 val := v_1
7090 mem := v_2
7091 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
7092 break
7093 }
7094 v.reset(OpARM64FMOVSstore)
7095 v.AuxInt = int32ToAuxInt(off1 + off2)
7096 v.Aux = symToAux(mergeSym(sym1, sym2))
7097 v.AddArg3(ptr, val, mem)
7098 return true
7099 }
7100 return false
7101 }
7102 func rewriteValueARM64_OpARM64FMOVSstoreidx(v *Value) bool {
7103 v_3 := v.Args[3]
7104 v_2 := v.Args[2]
7105 v_1 := v.Args[1]
7106 v_0 := v.Args[0]
7107
7108
7109
7110 for {
7111 ptr := v_0
7112 if v_1.Op != OpARM64MOVDconst {
7113 break
7114 }
7115 c := auxIntToInt64(v_1.AuxInt)
7116 val := v_2
7117 mem := v_3
7118 if !(is32Bit(c)) {
7119 break
7120 }
7121 v.reset(OpARM64FMOVSstore)
7122 v.AuxInt = int32ToAuxInt(int32(c))
7123 v.AddArg3(ptr, val, mem)
7124 return true
7125 }
7126
7127
7128
7129 for {
7130 if v_0.Op != OpARM64MOVDconst {
7131 break
7132 }
7133 c := auxIntToInt64(v_0.AuxInt)
7134 idx := v_1
7135 val := v_2
7136 mem := v_3
7137 if !(is32Bit(c)) {
7138 break
7139 }
7140 v.reset(OpARM64FMOVSstore)
7141 v.AuxInt = int32ToAuxInt(int32(c))
7142 v.AddArg3(idx, val, mem)
7143 return true
7144 }
7145
7146
7147 for {
7148 ptr := v_0
7149 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 2 {
7150 break
7151 }
7152 idx := v_1.Args[0]
7153 val := v_2
7154 mem := v_3
7155 v.reset(OpARM64FMOVSstoreidx4)
7156 v.AddArg4(ptr, idx, val, mem)
7157 return true
7158 }
7159
7160
7161 for {
7162 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 2 {
7163 break
7164 }
7165 idx := v_0.Args[0]
7166 ptr := v_1
7167 val := v_2
7168 mem := v_3
7169 v.reset(OpARM64FMOVSstoreidx4)
7170 v.AddArg4(ptr, idx, val, mem)
7171 return true
7172 }
7173 return false
7174 }
7175 func rewriteValueARM64_OpARM64FMOVSstoreidx4(v *Value) bool {
7176 v_3 := v.Args[3]
7177 v_2 := v.Args[2]
7178 v_1 := v.Args[1]
7179 v_0 := v.Args[0]
7180
7181
7182
7183 for {
7184 ptr := v_0
7185 if v_1.Op != OpARM64MOVDconst {
7186 break
7187 }
7188 c := auxIntToInt64(v_1.AuxInt)
7189 val := v_2
7190 mem := v_3
7191 if !(is32Bit(c << 2)) {
7192 break
7193 }
7194 v.reset(OpARM64FMOVSstore)
7195 v.AuxInt = int32ToAuxInt(int32(c) << 2)
7196 v.AddArg3(ptr, val, mem)
7197 return true
7198 }
7199 return false
7200 }
7201 func rewriteValueARM64_OpARM64FMULD(v *Value) bool {
7202 v_1 := v.Args[1]
7203 v_0 := v.Args[0]
7204
7205
7206 for {
7207 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7208 if v_0.Op != OpARM64FNEGD {
7209 continue
7210 }
7211 x := v_0.Args[0]
7212 y := v_1
7213 v.reset(OpARM64FNMULD)
7214 v.AddArg2(x, y)
7215 return true
7216 }
7217 break
7218 }
7219 return false
7220 }
7221 func rewriteValueARM64_OpARM64FMULS(v *Value) bool {
7222 v_1 := v.Args[1]
7223 v_0 := v.Args[0]
7224
7225
7226 for {
7227 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7228 if v_0.Op != OpARM64FNEGS {
7229 continue
7230 }
7231 x := v_0.Args[0]
7232 y := v_1
7233 v.reset(OpARM64FNMULS)
7234 v.AddArg2(x, y)
7235 return true
7236 }
7237 break
7238 }
7239 return false
7240 }
7241 func rewriteValueARM64_OpARM64FNEGD(v *Value) bool {
7242 v_0 := v.Args[0]
7243
7244
7245 for {
7246 if v_0.Op != OpARM64FMULD {
7247 break
7248 }
7249 y := v_0.Args[1]
7250 x := v_0.Args[0]
7251 v.reset(OpARM64FNMULD)
7252 v.AddArg2(x, y)
7253 return true
7254 }
7255
7256
7257 for {
7258 if v_0.Op != OpARM64FNMULD {
7259 break
7260 }
7261 y := v_0.Args[1]
7262 x := v_0.Args[0]
7263 v.reset(OpARM64FMULD)
7264 v.AddArg2(x, y)
7265 return true
7266 }
7267 return false
7268 }
7269 func rewriteValueARM64_OpARM64FNEGS(v *Value) bool {
7270 v_0 := v.Args[0]
7271
7272
7273 for {
7274 if v_0.Op != OpARM64FMULS {
7275 break
7276 }
7277 y := v_0.Args[1]
7278 x := v_0.Args[0]
7279 v.reset(OpARM64FNMULS)
7280 v.AddArg2(x, y)
7281 return true
7282 }
7283
7284
7285 for {
7286 if v_0.Op != OpARM64FNMULS {
7287 break
7288 }
7289 y := v_0.Args[1]
7290 x := v_0.Args[0]
7291 v.reset(OpARM64FMULS)
7292 v.AddArg2(x, y)
7293 return true
7294 }
7295 return false
7296 }
7297 func rewriteValueARM64_OpARM64FNMULD(v *Value) bool {
7298 v_1 := v.Args[1]
7299 v_0 := v.Args[0]
7300
7301
7302 for {
7303 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7304 if v_0.Op != OpARM64FNEGD {
7305 continue
7306 }
7307 x := v_0.Args[0]
7308 y := v_1
7309 v.reset(OpARM64FMULD)
7310 v.AddArg2(x, y)
7311 return true
7312 }
7313 break
7314 }
7315 return false
7316 }
7317 func rewriteValueARM64_OpARM64FNMULS(v *Value) bool {
7318 v_1 := v.Args[1]
7319 v_0 := v.Args[0]
7320
7321
7322 for {
7323 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7324 if v_0.Op != OpARM64FNEGS {
7325 continue
7326 }
7327 x := v_0.Args[0]
7328 y := v_1
7329 v.reset(OpARM64FMULS)
7330 v.AddArg2(x, y)
7331 return true
7332 }
7333 break
7334 }
7335 return false
7336 }
7337 func rewriteValueARM64_OpARM64FSTPQ(v *Value) bool {
7338 v_3 := v.Args[3]
7339 v_2 := v.Args[2]
7340 v_1 := v.Args[1]
7341 v_0 := v.Args[0]
7342 b := v.Block
7343 config := b.Func.Config
7344
7345
7346
7347 for {
7348 off1 := auxIntToInt32(v.AuxInt)
7349 sym := auxToSym(v.Aux)
7350 if v_0.Op != OpARM64ADDconst {
7351 break
7352 }
7353 off2 := auxIntToInt64(v_0.AuxInt)
7354 ptr := v_0.Args[0]
7355 val1 := v_1
7356 val2 := v_2
7357 mem := v_3
7358 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
7359 break
7360 }
7361 v.reset(OpARM64FSTPQ)
7362 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
7363 v.Aux = symToAux(sym)
7364 v.AddArg4(ptr, val1, val2, mem)
7365 return true
7366 }
7367
7368
7369
7370 for {
7371 off1 := auxIntToInt32(v.AuxInt)
7372 sym1 := auxToSym(v.Aux)
7373 if v_0.Op != OpARM64MOVDaddr {
7374 break
7375 }
7376 off2 := auxIntToInt32(v_0.AuxInt)
7377 sym2 := auxToSym(v_0.Aux)
7378 ptr := v_0.Args[0]
7379 val1 := v_1
7380 val2 := v_2
7381 mem := v_3
7382 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
7383 break
7384 }
7385 v.reset(OpARM64FSTPQ)
7386 v.AuxInt = int32ToAuxInt(off1 + off2)
7387 v.Aux = symToAux(mergeSym(sym1, sym2))
7388 v.AddArg4(ptr, val1, val2, mem)
7389 return true
7390 }
7391 return false
7392 }
7393 func rewriteValueARM64_OpARM64FSUBD(v *Value) bool {
7394 v_1 := v.Args[1]
7395 v_0 := v.Args[0]
7396
7397
7398
7399 for {
7400 a := v_0
7401 if v_1.Op != OpARM64FMULD {
7402 break
7403 }
7404 y := v_1.Args[1]
7405 x := v_1.Args[0]
7406 if !(a.Block.Func.useFMA(v)) {
7407 break
7408 }
7409 v.reset(OpARM64FMSUBD)
7410 v.AddArg3(a, x, y)
7411 return true
7412 }
7413
7414
7415
7416 for {
7417 if v_0.Op != OpARM64FMULD {
7418 break
7419 }
7420 y := v_0.Args[1]
7421 x := v_0.Args[0]
7422 a := v_1
7423 if !(a.Block.Func.useFMA(v)) {
7424 break
7425 }
7426 v.reset(OpARM64FNMSUBD)
7427 v.AddArg3(a, x, y)
7428 return true
7429 }
7430
7431
7432
7433 for {
7434 a := v_0
7435 if v_1.Op != OpARM64FNMULD {
7436 break
7437 }
7438 y := v_1.Args[1]
7439 x := v_1.Args[0]
7440 if !(a.Block.Func.useFMA(v)) {
7441 break
7442 }
7443 v.reset(OpARM64FMADDD)
7444 v.AddArg3(a, x, y)
7445 return true
7446 }
7447
7448
7449
7450 for {
7451 if v_0.Op != OpARM64FNMULD {
7452 break
7453 }
7454 y := v_0.Args[1]
7455 x := v_0.Args[0]
7456 a := v_1
7457 if !(a.Block.Func.useFMA(v)) {
7458 break
7459 }
7460 v.reset(OpARM64FNMADDD)
7461 v.AddArg3(a, x, y)
7462 return true
7463 }
7464 return false
7465 }
7466 func rewriteValueARM64_OpARM64FSUBS(v *Value) bool {
7467 v_1 := v.Args[1]
7468 v_0 := v.Args[0]
7469
7470
7471
7472 for {
7473 a := v_0
7474 if v_1.Op != OpARM64FMULS {
7475 break
7476 }
7477 y := v_1.Args[1]
7478 x := v_1.Args[0]
7479 if !(a.Block.Func.useFMA(v)) {
7480 break
7481 }
7482 v.reset(OpARM64FMSUBS)
7483 v.AddArg3(a, x, y)
7484 return true
7485 }
7486
7487
7488
7489 for {
7490 if v_0.Op != OpARM64FMULS {
7491 break
7492 }
7493 y := v_0.Args[1]
7494 x := v_0.Args[0]
7495 a := v_1
7496 if !(a.Block.Func.useFMA(v)) {
7497 break
7498 }
7499 v.reset(OpARM64FNMSUBS)
7500 v.AddArg3(a, x, y)
7501 return true
7502 }
7503
7504
7505
7506 for {
7507 a := v_0
7508 if v_1.Op != OpARM64FNMULS {
7509 break
7510 }
7511 y := v_1.Args[1]
7512 x := v_1.Args[0]
7513 if !(a.Block.Func.useFMA(v)) {
7514 break
7515 }
7516 v.reset(OpARM64FMADDS)
7517 v.AddArg3(a, x, y)
7518 return true
7519 }
7520
7521
7522
7523 for {
7524 if v_0.Op != OpARM64FNMULS {
7525 break
7526 }
7527 y := v_0.Args[1]
7528 x := v_0.Args[0]
7529 a := v_1
7530 if !(a.Block.Func.useFMA(v)) {
7531 break
7532 }
7533 v.reset(OpARM64FNMADDS)
7534 v.AddArg3(a, x, y)
7535 return true
7536 }
7537 return false
7538 }
7539 func rewriteValueARM64_OpARM64GreaterEqual(v *Value) bool {
7540 v_0 := v.Args[0]
7541 b := v.Block
7542
7543
7544
7545 for {
7546 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
7547 break
7548 }
7549 z := v_0.Args[0]
7550 if z.Op != OpARM64AND {
7551 break
7552 }
7553 y := z.Args[1]
7554 x := z.Args[0]
7555 if !(z.Uses == 1) {
7556 break
7557 }
7558 v.reset(OpARM64GreaterEqual)
7559 v0 := b.NewValue0(v.Pos, OpARM64TST, types.TypeFlags)
7560 v0.AddArg2(x, y)
7561 v.AddArg(v0)
7562 return true
7563 }
7564
7565
7566
7567 for {
7568 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
7569 break
7570 }
7571 x := v_0.Args[0]
7572 if x.Op != OpARM64ANDconst {
7573 break
7574 }
7575 c := auxIntToInt64(x.AuxInt)
7576 y := x.Args[0]
7577 if !(x.Uses == 1) {
7578 break
7579 }
7580 v.reset(OpARM64GreaterEqual)
7581 v0 := b.NewValue0(v.Pos, OpARM64TSTWconst, types.TypeFlags)
7582 v0.AuxInt = int32ToAuxInt(int32(c))
7583 v0.AddArg(y)
7584 v.AddArg(v0)
7585 return true
7586 }
7587
7588
7589
7590 for {
7591 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
7592 break
7593 }
7594 z := v_0.Args[0]
7595 if z.Op != OpARM64AND {
7596 break
7597 }
7598 y := z.Args[1]
7599 x := z.Args[0]
7600 if !(z.Uses == 1) {
7601 break
7602 }
7603 v.reset(OpARM64GreaterEqual)
7604 v0 := b.NewValue0(v.Pos, OpARM64TSTW, types.TypeFlags)
7605 v0.AddArg2(x, y)
7606 v.AddArg(v0)
7607 return true
7608 }
7609
7610
7611
7612 for {
7613 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
7614 break
7615 }
7616 x := v_0.Args[0]
7617 if x.Op != OpARM64ANDconst {
7618 break
7619 }
7620 c := auxIntToInt64(x.AuxInt)
7621 y := x.Args[0]
7622 if !(x.Uses == 1) {
7623 break
7624 }
7625 v.reset(OpARM64GreaterEqual)
7626 v0 := b.NewValue0(v.Pos, OpARM64TSTconst, types.TypeFlags)
7627 v0.AuxInt = int64ToAuxInt(c)
7628 v0.AddArg(y)
7629 v.AddArg(v0)
7630 return true
7631 }
7632
7633
7634
7635 for {
7636 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
7637 break
7638 }
7639 x := v_0.Args[0]
7640 if x.Op != OpARM64ADDconst {
7641 break
7642 }
7643 c := auxIntToInt64(x.AuxInt)
7644 y := x.Args[0]
7645 if !(x.Uses == 1) {
7646 break
7647 }
7648 v.reset(OpARM64GreaterEqualNoov)
7649 v0 := b.NewValue0(v.Pos, OpARM64CMNconst, types.TypeFlags)
7650 v0.AuxInt = int64ToAuxInt(c)
7651 v0.AddArg(y)
7652 v.AddArg(v0)
7653 return true
7654 }
7655
7656
7657
7658 for {
7659 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
7660 break
7661 }
7662 x := v_0.Args[0]
7663 if x.Op != OpARM64ADDconst {
7664 break
7665 }
7666 c := auxIntToInt64(x.AuxInt)
7667 y := x.Args[0]
7668 if !(x.Uses == 1) {
7669 break
7670 }
7671 v.reset(OpARM64GreaterEqualNoov)
7672 v0 := b.NewValue0(v.Pos, OpARM64CMNWconst, types.TypeFlags)
7673 v0.AuxInt = int32ToAuxInt(int32(c))
7674 v0.AddArg(y)
7675 v.AddArg(v0)
7676 return true
7677 }
7678
7679
7680
7681 for {
7682 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
7683 break
7684 }
7685 z := v_0.Args[0]
7686 if z.Op != OpARM64ADD {
7687 break
7688 }
7689 y := z.Args[1]
7690 x := z.Args[0]
7691 if !(z.Uses == 1) {
7692 break
7693 }
7694 v.reset(OpARM64GreaterEqualNoov)
7695 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
7696 v0.AddArg2(x, y)
7697 v.AddArg(v0)
7698 return true
7699 }
7700
7701
7702
7703 for {
7704 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
7705 break
7706 }
7707 z := v_0.Args[0]
7708 if z.Op != OpARM64ADD {
7709 break
7710 }
7711 y := z.Args[1]
7712 x := z.Args[0]
7713 if !(z.Uses == 1) {
7714 break
7715 }
7716 v.reset(OpARM64GreaterEqualNoov)
7717 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
7718 v0.AddArg2(x, y)
7719 v.AddArg(v0)
7720 return true
7721 }
7722
7723
7724
7725 for {
7726 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
7727 break
7728 }
7729 z := v_0.Args[0]
7730 if z.Op != OpARM64MADD {
7731 break
7732 }
7733 y := z.Args[2]
7734 a := z.Args[0]
7735 x := z.Args[1]
7736 if !(z.Uses == 1) {
7737 break
7738 }
7739 v.reset(OpARM64GreaterEqualNoov)
7740 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
7741 v1 := b.NewValue0(v.Pos, OpARM64MUL, x.Type)
7742 v1.AddArg2(x, y)
7743 v0.AddArg2(a, v1)
7744 v.AddArg(v0)
7745 return true
7746 }
7747
7748
7749
7750 for {
7751 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
7752 break
7753 }
7754 z := v_0.Args[0]
7755 if z.Op != OpARM64MADDW {
7756 break
7757 }
7758 y := z.Args[2]
7759 a := z.Args[0]
7760 x := z.Args[1]
7761 if !(z.Uses == 1) {
7762 break
7763 }
7764 v.reset(OpARM64GreaterEqualNoov)
7765 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
7766 v1 := b.NewValue0(v.Pos, OpARM64MULW, x.Type)
7767 v1.AddArg2(x, y)
7768 v0.AddArg2(a, v1)
7769 v.AddArg(v0)
7770 return true
7771 }
7772
7773
7774 for {
7775 if v_0.Op != OpARM64FlagConstant {
7776 break
7777 }
7778 fc := auxIntToFlagConstant(v_0.AuxInt)
7779 v.reset(OpARM64MOVDconst)
7780 v.AuxInt = int64ToAuxInt(b2i(fc.ge()))
7781 return true
7782 }
7783
7784
7785 for {
7786 if v_0.Op != OpARM64InvertFlags {
7787 break
7788 }
7789 x := v_0.Args[0]
7790 v.reset(OpARM64LessEqual)
7791 v.AddArg(x)
7792 return true
7793 }
7794
7795
7796 for {
7797 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
7798 break
7799 }
7800 x := v_0.Args[0]
7801 v.reset(OpARM64XORconst)
7802 v.AuxInt = int64ToAuxInt(1)
7803 v0 := b.NewValue0(v.Pos, OpARM64SRLconst, v.Type)
7804 v0.AuxInt = int64ToAuxInt(63)
7805 v0.AddArg(x)
7806 v.AddArg(v0)
7807 return true
7808 }
7809
7810
7811 for {
7812 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(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, OpARM64UBFX, v.Type)
7819 v0.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(31, 1))
7820 v0.AddArg(x)
7821 v.AddArg(v0)
7822 return true
7823 }
7824 return false
7825 }
7826 func rewriteValueARM64_OpARM64GreaterEqualF(v *Value) bool {
7827 v_0 := v.Args[0]
7828
7829
7830 for {
7831 if v_0.Op != OpARM64InvertFlags {
7832 break
7833 }
7834 x := v_0.Args[0]
7835 v.reset(OpARM64LessEqualF)
7836 v.AddArg(x)
7837 return true
7838 }
7839 return false
7840 }
7841 func rewriteValueARM64_OpARM64GreaterEqualNoov(v *Value) bool {
7842 v_0 := v.Args[0]
7843
7844
7845 for {
7846 if v_0.Op != OpARM64FlagConstant {
7847 break
7848 }
7849 fc := auxIntToFlagConstant(v_0.AuxInt)
7850 v.reset(OpARM64MOVDconst)
7851 v.AuxInt = int64ToAuxInt(b2i(fc.geNoov()))
7852 return true
7853 }
7854 return false
7855 }
7856 func rewriteValueARM64_OpARM64GreaterEqualU(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.uge()))
7867 return true
7868 }
7869
7870
7871 for {
7872 if v_0.Op != OpARM64InvertFlags {
7873 break
7874 }
7875 x := v_0.Args[0]
7876 v.reset(OpARM64LessEqualU)
7877 v.AddArg(x)
7878 return true
7879 }
7880 return false
7881 }
7882 func rewriteValueARM64_OpARM64GreaterThan(v *Value) bool {
7883 v_0 := v.Args[0]
7884 b := v.Block
7885
7886
7887
7888 for {
7889 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
7890 break
7891 }
7892 z := v_0.Args[0]
7893 if z.Op != OpARM64AND {
7894 break
7895 }
7896 y := z.Args[1]
7897 x := z.Args[0]
7898 if !(z.Uses == 1) {
7899 break
7900 }
7901 v.reset(OpARM64GreaterThan)
7902 v0 := b.NewValue0(v.Pos, OpARM64TST, types.TypeFlags)
7903 v0.AddArg2(x, y)
7904 v.AddArg(v0)
7905 return true
7906 }
7907
7908
7909
7910 for {
7911 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
7912 break
7913 }
7914 x := v_0.Args[0]
7915 if x.Op != OpARM64ANDconst {
7916 break
7917 }
7918 c := auxIntToInt64(x.AuxInt)
7919 y := x.Args[0]
7920 if !(x.Uses == 1) {
7921 break
7922 }
7923 v.reset(OpARM64GreaterThan)
7924 v0 := b.NewValue0(v.Pos, OpARM64TSTWconst, types.TypeFlags)
7925 v0.AuxInt = int32ToAuxInt(int32(c))
7926 v0.AddArg(y)
7927 v.AddArg(v0)
7928 return true
7929 }
7930
7931
7932
7933 for {
7934 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
7935 break
7936 }
7937 z := v_0.Args[0]
7938 if z.Op != OpARM64AND {
7939 break
7940 }
7941 y := z.Args[1]
7942 x := z.Args[0]
7943 if !(z.Uses == 1) {
7944 break
7945 }
7946 v.reset(OpARM64GreaterThan)
7947 v0 := b.NewValue0(v.Pos, OpARM64TSTW, types.TypeFlags)
7948 v0.AddArg2(x, y)
7949 v.AddArg(v0)
7950 return true
7951 }
7952
7953
7954
7955 for {
7956 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
7957 break
7958 }
7959 x := v_0.Args[0]
7960 if x.Op != OpARM64ANDconst {
7961 break
7962 }
7963 c := auxIntToInt64(x.AuxInt)
7964 y := x.Args[0]
7965 if !(x.Uses == 1) {
7966 break
7967 }
7968 v.reset(OpARM64GreaterThan)
7969 v0 := b.NewValue0(v.Pos, OpARM64TSTconst, types.TypeFlags)
7970 v0.AuxInt = int64ToAuxInt(c)
7971 v0.AddArg(y)
7972 v.AddArg(v0)
7973 return true
7974 }
7975
7976
7977 for {
7978 if v_0.Op != OpARM64FlagConstant {
7979 break
7980 }
7981 fc := auxIntToFlagConstant(v_0.AuxInt)
7982 v.reset(OpARM64MOVDconst)
7983 v.AuxInt = int64ToAuxInt(b2i(fc.gt()))
7984 return true
7985 }
7986
7987
7988 for {
7989 if v_0.Op != OpARM64InvertFlags {
7990 break
7991 }
7992 x := v_0.Args[0]
7993 v.reset(OpARM64LessThan)
7994 v.AddArg(x)
7995 return true
7996 }
7997 return false
7998 }
7999 func rewriteValueARM64_OpARM64GreaterThanF(v *Value) bool {
8000 v_0 := v.Args[0]
8001
8002
8003 for {
8004 if v_0.Op != OpARM64InvertFlags {
8005 break
8006 }
8007 x := v_0.Args[0]
8008 v.reset(OpARM64LessThanF)
8009 v.AddArg(x)
8010 return true
8011 }
8012 return false
8013 }
8014 func rewriteValueARM64_OpARM64GreaterThanU(v *Value) bool {
8015 v_0 := v.Args[0]
8016
8017
8018 for {
8019 if v_0.Op != OpARM64FlagConstant {
8020 break
8021 }
8022 fc := auxIntToFlagConstant(v_0.AuxInt)
8023 v.reset(OpARM64MOVDconst)
8024 v.AuxInt = int64ToAuxInt(b2i(fc.ugt()))
8025 return true
8026 }
8027
8028
8029 for {
8030 if v_0.Op != OpARM64InvertFlags {
8031 break
8032 }
8033 x := v_0.Args[0]
8034 v.reset(OpARM64LessThanU)
8035 v.AddArg(x)
8036 return true
8037 }
8038 return false
8039 }
8040 func rewriteValueARM64_OpARM64LDP(v *Value) bool {
8041 v_1 := v.Args[1]
8042 v_0 := v.Args[0]
8043 b := v.Block
8044 config := b.Func.Config
8045
8046
8047
8048 for {
8049 off1 := auxIntToInt32(v.AuxInt)
8050 sym := auxToSym(v.Aux)
8051 if v_0.Op != OpARM64ADDconst {
8052 break
8053 }
8054 off2 := auxIntToInt64(v_0.AuxInt)
8055 ptr := v_0.Args[0]
8056 mem := v_1
8057 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
8058 break
8059 }
8060 v.reset(OpARM64LDP)
8061 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
8062 v.Aux = symToAux(sym)
8063 v.AddArg2(ptr, mem)
8064 return true
8065 }
8066
8067
8068
8069 for {
8070 off1 := auxIntToInt32(v.AuxInt)
8071 sym1 := auxToSym(v.Aux)
8072 if v_0.Op != OpARM64MOVDaddr {
8073 break
8074 }
8075 off2 := auxIntToInt32(v_0.AuxInt)
8076 sym2 := auxToSym(v_0.Aux)
8077 ptr := v_0.Args[0]
8078 mem := v_1
8079 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
8080 break
8081 }
8082 v.reset(OpARM64LDP)
8083 v.AuxInt = int32ToAuxInt(off1 + off2)
8084 v.Aux = symToAux(mergeSym(sym1, sym2))
8085 v.AddArg2(ptr, mem)
8086 return true
8087 }
8088 return false
8089 }
8090 func rewriteValueARM64_OpARM64LessEqual(v *Value) bool {
8091 v_0 := v.Args[0]
8092 b := v.Block
8093
8094
8095
8096 for {
8097 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
8098 break
8099 }
8100 z := v_0.Args[0]
8101 if z.Op != OpARM64AND {
8102 break
8103 }
8104 y := z.Args[1]
8105 x := z.Args[0]
8106 if !(z.Uses == 1) {
8107 break
8108 }
8109 v.reset(OpARM64LessEqual)
8110 v0 := b.NewValue0(v.Pos, OpARM64TST, types.TypeFlags)
8111 v0.AddArg2(x, y)
8112 v.AddArg(v0)
8113 return true
8114 }
8115
8116
8117
8118 for {
8119 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
8120 break
8121 }
8122 x := v_0.Args[0]
8123 if x.Op != OpARM64ANDconst {
8124 break
8125 }
8126 c := auxIntToInt64(x.AuxInt)
8127 y := x.Args[0]
8128 if !(x.Uses == 1) {
8129 break
8130 }
8131 v.reset(OpARM64LessEqual)
8132 v0 := b.NewValue0(v.Pos, OpARM64TSTWconst, types.TypeFlags)
8133 v0.AuxInt = int32ToAuxInt(int32(c))
8134 v0.AddArg(y)
8135 v.AddArg(v0)
8136 return true
8137 }
8138
8139
8140
8141 for {
8142 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
8143 break
8144 }
8145 z := v_0.Args[0]
8146 if z.Op != OpARM64AND {
8147 break
8148 }
8149 y := z.Args[1]
8150 x := z.Args[0]
8151 if !(z.Uses == 1) {
8152 break
8153 }
8154 v.reset(OpARM64LessEqual)
8155 v0 := b.NewValue0(v.Pos, OpARM64TSTW, types.TypeFlags)
8156 v0.AddArg2(x, y)
8157 v.AddArg(v0)
8158 return true
8159 }
8160
8161
8162
8163 for {
8164 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
8165 break
8166 }
8167 x := v_0.Args[0]
8168 if x.Op != OpARM64ANDconst {
8169 break
8170 }
8171 c := auxIntToInt64(x.AuxInt)
8172 y := x.Args[0]
8173 if !(x.Uses == 1) {
8174 break
8175 }
8176 v.reset(OpARM64LessEqual)
8177 v0 := b.NewValue0(v.Pos, OpARM64TSTconst, types.TypeFlags)
8178 v0.AuxInt = int64ToAuxInt(c)
8179 v0.AddArg(y)
8180 v.AddArg(v0)
8181 return true
8182 }
8183
8184
8185 for {
8186 if v_0.Op != OpARM64FlagConstant {
8187 break
8188 }
8189 fc := auxIntToFlagConstant(v_0.AuxInt)
8190 v.reset(OpARM64MOVDconst)
8191 v.AuxInt = int64ToAuxInt(b2i(fc.le()))
8192 return true
8193 }
8194
8195
8196 for {
8197 if v_0.Op != OpARM64InvertFlags {
8198 break
8199 }
8200 x := v_0.Args[0]
8201 v.reset(OpARM64GreaterEqual)
8202 v.AddArg(x)
8203 return true
8204 }
8205 return false
8206 }
8207 func rewriteValueARM64_OpARM64LessEqualF(v *Value) bool {
8208 v_0 := v.Args[0]
8209
8210
8211 for {
8212 if v_0.Op != OpARM64InvertFlags {
8213 break
8214 }
8215 x := v_0.Args[0]
8216 v.reset(OpARM64GreaterEqualF)
8217 v.AddArg(x)
8218 return true
8219 }
8220 return false
8221 }
8222 func rewriteValueARM64_OpARM64LessEqualU(v *Value) bool {
8223 v_0 := v.Args[0]
8224
8225
8226 for {
8227 if v_0.Op != OpARM64FlagConstant {
8228 break
8229 }
8230 fc := auxIntToFlagConstant(v_0.AuxInt)
8231 v.reset(OpARM64MOVDconst)
8232 v.AuxInt = int64ToAuxInt(b2i(fc.ule()))
8233 return true
8234 }
8235
8236
8237 for {
8238 if v_0.Op != OpARM64InvertFlags {
8239 break
8240 }
8241 x := v_0.Args[0]
8242 v.reset(OpARM64GreaterEqualU)
8243 v.AddArg(x)
8244 return true
8245 }
8246 return false
8247 }
8248 func rewriteValueARM64_OpARM64LessThan(v *Value) bool {
8249 v_0 := v.Args[0]
8250 b := v.Block
8251
8252
8253
8254 for {
8255 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
8256 break
8257 }
8258 z := v_0.Args[0]
8259 if z.Op != OpARM64AND {
8260 break
8261 }
8262 y := z.Args[1]
8263 x := z.Args[0]
8264 if !(z.Uses == 1) {
8265 break
8266 }
8267 v.reset(OpARM64LessThan)
8268 v0 := b.NewValue0(v.Pos, OpARM64TST, types.TypeFlags)
8269 v0.AddArg2(x, y)
8270 v.AddArg(v0)
8271 return true
8272 }
8273
8274
8275
8276 for {
8277 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
8278 break
8279 }
8280 x := v_0.Args[0]
8281 if x.Op != OpARM64ANDconst {
8282 break
8283 }
8284 c := auxIntToInt64(x.AuxInt)
8285 y := x.Args[0]
8286 if !(x.Uses == 1) {
8287 break
8288 }
8289 v.reset(OpARM64LessThan)
8290 v0 := b.NewValue0(v.Pos, OpARM64TSTWconst, types.TypeFlags)
8291 v0.AuxInt = int32ToAuxInt(int32(c))
8292 v0.AddArg(y)
8293 v.AddArg(v0)
8294 return true
8295 }
8296
8297
8298
8299 for {
8300 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
8301 break
8302 }
8303 z := v_0.Args[0]
8304 if z.Op != OpARM64AND {
8305 break
8306 }
8307 y := z.Args[1]
8308 x := z.Args[0]
8309 if !(z.Uses == 1) {
8310 break
8311 }
8312 v.reset(OpARM64LessThan)
8313 v0 := b.NewValue0(v.Pos, OpARM64TSTW, types.TypeFlags)
8314 v0.AddArg2(x, y)
8315 v.AddArg(v0)
8316 return true
8317 }
8318
8319
8320
8321 for {
8322 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
8323 break
8324 }
8325 x := v_0.Args[0]
8326 if x.Op != OpARM64ANDconst {
8327 break
8328 }
8329 c := auxIntToInt64(x.AuxInt)
8330 y := x.Args[0]
8331 if !(x.Uses == 1) {
8332 break
8333 }
8334 v.reset(OpARM64LessThan)
8335 v0 := b.NewValue0(v.Pos, OpARM64TSTconst, types.TypeFlags)
8336 v0.AuxInt = int64ToAuxInt(c)
8337 v0.AddArg(y)
8338 v.AddArg(v0)
8339 return true
8340 }
8341
8342
8343
8344 for {
8345 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
8346 break
8347 }
8348 x := v_0.Args[0]
8349 if x.Op != OpARM64ADDconst {
8350 break
8351 }
8352 c := auxIntToInt64(x.AuxInt)
8353 y := x.Args[0]
8354 if !(x.Uses == 1) {
8355 break
8356 }
8357 v.reset(OpARM64LessThanNoov)
8358 v0 := b.NewValue0(v.Pos, OpARM64CMNconst, types.TypeFlags)
8359 v0.AuxInt = int64ToAuxInt(c)
8360 v0.AddArg(y)
8361 v.AddArg(v0)
8362 return true
8363 }
8364
8365
8366
8367 for {
8368 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
8369 break
8370 }
8371 x := v_0.Args[0]
8372 if x.Op != OpARM64ADDconst {
8373 break
8374 }
8375 c := auxIntToInt64(x.AuxInt)
8376 y := x.Args[0]
8377 if !(x.Uses == 1) {
8378 break
8379 }
8380 v.reset(OpARM64LessThanNoov)
8381 v0 := b.NewValue0(v.Pos, OpARM64CMNWconst, types.TypeFlags)
8382 v0.AuxInt = int32ToAuxInt(int32(c))
8383 v0.AddArg(y)
8384 v.AddArg(v0)
8385 return true
8386 }
8387
8388
8389
8390 for {
8391 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
8392 break
8393 }
8394 z := v_0.Args[0]
8395 if z.Op != OpARM64ADD {
8396 break
8397 }
8398 y := z.Args[1]
8399 x := z.Args[0]
8400 if !(z.Uses == 1) {
8401 break
8402 }
8403 v.reset(OpARM64LessThanNoov)
8404 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
8405 v0.AddArg2(x, y)
8406 v.AddArg(v0)
8407 return true
8408 }
8409
8410
8411
8412 for {
8413 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
8414 break
8415 }
8416 z := v_0.Args[0]
8417 if z.Op != OpARM64ADD {
8418 break
8419 }
8420 y := z.Args[1]
8421 x := z.Args[0]
8422 if !(z.Uses == 1) {
8423 break
8424 }
8425 v.reset(OpARM64LessThanNoov)
8426 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
8427 v0.AddArg2(x, y)
8428 v.AddArg(v0)
8429 return true
8430 }
8431
8432
8433
8434 for {
8435 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
8436 break
8437 }
8438 z := v_0.Args[0]
8439 if z.Op != OpARM64MADD {
8440 break
8441 }
8442 y := z.Args[2]
8443 a := z.Args[0]
8444 x := z.Args[1]
8445 if !(z.Uses == 1) {
8446 break
8447 }
8448 v.reset(OpARM64LessThanNoov)
8449 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
8450 v1 := b.NewValue0(v.Pos, OpARM64MUL, x.Type)
8451 v1.AddArg2(x, y)
8452 v0.AddArg2(a, v1)
8453 v.AddArg(v0)
8454 return true
8455 }
8456
8457
8458
8459 for {
8460 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
8461 break
8462 }
8463 z := v_0.Args[0]
8464 if z.Op != OpARM64MADDW {
8465 break
8466 }
8467 y := z.Args[2]
8468 a := z.Args[0]
8469 x := z.Args[1]
8470 if !(z.Uses == 1) {
8471 break
8472 }
8473 v.reset(OpARM64LessThanNoov)
8474 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
8475 v1 := b.NewValue0(v.Pos, OpARM64MULW, x.Type)
8476 v1.AddArg2(x, y)
8477 v0.AddArg2(a, v1)
8478 v.AddArg(v0)
8479 return true
8480 }
8481
8482
8483 for {
8484 if v_0.Op != OpARM64FlagConstant {
8485 break
8486 }
8487 fc := auxIntToFlagConstant(v_0.AuxInt)
8488 v.reset(OpARM64MOVDconst)
8489 v.AuxInt = int64ToAuxInt(b2i(fc.lt()))
8490 return true
8491 }
8492
8493
8494 for {
8495 if v_0.Op != OpARM64InvertFlags {
8496 break
8497 }
8498 x := v_0.Args[0]
8499 v.reset(OpARM64GreaterThan)
8500 v.AddArg(x)
8501 return true
8502 }
8503
8504
8505 for {
8506 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
8507 break
8508 }
8509 x := v_0.Args[0]
8510 v.reset(OpARM64SRLconst)
8511 v.AuxInt = int64ToAuxInt(63)
8512 v.AddArg(x)
8513 return true
8514 }
8515
8516
8517 for {
8518 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
8519 break
8520 }
8521 x := v_0.Args[0]
8522 v.reset(OpARM64UBFX)
8523 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(31, 1))
8524 v.AddArg(x)
8525 return true
8526 }
8527 return false
8528 }
8529 func rewriteValueARM64_OpARM64LessThanF(v *Value) bool {
8530 v_0 := v.Args[0]
8531
8532
8533 for {
8534 if v_0.Op != OpARM64InvertFlags {
8535 break
8536 }
8537 x := v_0.Args[0]
8538 v.reset(OpARM64GreaterThanF)
8539 v.AddArg(x)
8540 return true
8541 }
8542 return false
8543 }
8544 func rewriteValueARM64_OpARM64LessThanNoov(v *Value) bool {
8545 v_0 := v.Args[0]
8546
8547
8548 for {
8549 if v_0.Op != OpARM64FlagConstant {
8550 break
8551 }
8552 fc := auxIntToFlagConstant(v_0.AuxInt)
8553 v.reset(OpARM64MOVDconst)
8554 v.AuxInt = int64ToAuxInt(b2i(fc.ltNoov()))
8555 return true
8556 }
8557 return false
8558 }
8559 func rewriteValueARM64_OpARM64LessThanU(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.ult()))
8570 return true
8571 }
8572
8573
8574 for {
8575 if v_0.Op != OpARM64InvertFlags {
8576 break
8577 }
8578 x := v_0.Args[0]
8579 v.reset(OpARM64GreaterThanU)
8580 v.AddArg(x)
8581 return true
8582 }
8583 return false
8584 }
8585 func rewriteValueARM64_OpARM64LoweredPanicBoundsCR(v *Value) bool {
8586 v_1 := v.Args[1]
8587 v_0 := v.Args[0]
8588
8589
8590 for {
8591 kind := auxIntToInt64(v.AuxInt)
8592 p := auxToPanicBoundsC(v.Aux)
8593 if v_0.Op != OpARM64MOVDconst {
8594 break
8595 }
8596 c := auxIntToInt64(v_0.AuxInt)
8597 mem := v_1
8598 v.reset(OpARM64LoweredPanicBoundsCC)
8599 v.AuxInt = int64ToAuxInt(kind)
8600 v.Aux = panicBoundsCCToAux(PanicBoundsCC{Cx: p.C, Cy: c})
8601 v.AddArg(mem)
8602 return true
8603 }
8604 return false
8605 }
8606 func rewriteValueARM64_OpARM64LoweredPanicBoundsRC(v *Value) bool {
8607 v_1 := v.Args[1]
8608 v_0 := v.Args[0]
8609
8610
8611 for {
8612 kind := auxIntToInt64(v.AuxInt)
8613 p := auxToPanicBoundsC(v.Aux)
8614 if v_0.Op != OpARM64MOVDconst {
8615 break
8616 }
8617 c := auxIntToInt64(v_0.AuxInt)
8618 mem := v_1
8619 v.reset(OpARM64LoweredPanicBoundsCC)
8620 v.AuxInt = int64ToAuxInt(kind)
8621 v.Aux = panicBoundsCCToAux(PanicBoundsCC{Cx: c, Cy: p.C})
8622 v.AddArg(mem)
8623 return true
8624 }
8625 return false
8626 }
8627 func rewriteValueARM64_OpARM64LoweredPanicBoundsRR(v *Value) bool {
8628 v_2 := v.Args[2]
8629 v_1 := v.Args[1]
8630 v_0 := v.Args[0]
8631
8632
8633 for {
8634 kind := auxIntToInt64(v.AuxInt)
8635 x := v_0
8636 if v_1.Op != OpARM64MOVDconst {
8637 break
8638 }
8639 c := auxIntToInt64(v_1.AuxInt)
8640 mem := v_2
8641 v.reset(OpARM64LoweredPanicBoundsRC)
8642 v.AuxInt = int64ToAuxInt(kind)
8643 v.Aux = panicBoundsCToAux(PanicBoundsC{C: c})
8644 v.AddArg2(x, mem)
8645 return true
8646 }
8647
8648
8649 for {
8650 kind := auxIntToInt64(v.AuxInt)
8651 if v_0.Op != OpARM64MOVDconst {
8652 break
8653 }
8654 c := auxIntToInt64(v_0.AuxInt)
8655 y := v_1
8656 mem := v_2
8657 v.reset(OpARM64LoweredPanicBoundsCR)
8658 v.AuxInt = int64ToAuxInt(kind)
8659 v.Aux = panicBoundsCToAux(PanicBoundsC{C: c})
8660 v.AddArg2(y, mem)
8661 return true
8662 }
8663 return false
8664 }
8665 func rewriteValueARM64_OpARM64MADD(v *Value) bool {
8666 v_2 := v.Args[2]
8667 v_1 := v.Args[1]
8668 v_0 := v.Args[0]
8669 b := v.Block
8670
8671
8672 for {
8673 a := v_0
8674 x := v_1
8675 if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != -1 {
8676 break
8677 }
8678 v.reset(OpARM64SUB)
8679 v.AddArg2(a, x)
8680 return true
8681 }
8682
8683
8684 for {
8685 a := v_0
8686 if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != 0 {
8687 break
8688 }
8689 v.copyOf(a)
8690 return true
8691 }
8692
8693
8694 for {
8695 a := v_0
8696 x := v_1
8697 if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != 1 {
8698 break
8699 }
8700 v.reset(OpARM64ADD)
8701 v.AddArg2(a, x)
8702 return true
8703 }
8704
8705
8706
8707 for {
8708 a := v_0
8709 x := v_1
8710 if v_2.Op != OpARM64MOVDconst {
8711 break
8712 }
8713 c := auxIntToInt64(v_2.AuxInt)
8714 if !(isPowerOfTwo(c)) {
8715 break
8716 }
8717 v.reset(OpARM64ADDshiftLL)
8718 v.AuxInt = int64ToAuxInt(log64(c))
8719 v.AddArg2(a, x)
8720 return true
8721 }
8722
8723
8724
8725 for {
8726 a := v_0
8727 x := v_1
8728 if v_2.Op != OpARM64MOVDconst {
8729 break
8730 }
8731 c := auxIntToInt64(v_2.AuxInt)
8732 if !(isPowerOfTwo(c-1) && c >= 3) {
8733 break
8734 }
8735 v.reset(OpARM64ADD)
8736 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
8737 v0.AuxInt = int64ToAuxInt(log64(c - 1))
8738 v0.AddArg2(x, x)
8739 v.AddArg2(a, v0)
8740 return true
8741 }
8742
8743
8744
8745 for {
8746 a := v_0
8747 x := v_1
8748 if v_2.Op != OpARM64MOVDconst {
8749 break
8750 }
8751 c := auxIntToInt64(v_2.AuxInt)
8752 if !(isPowerOfTwo(c+1) && c >= 7) {
8753 break
8754 }
8755 v.reset(OpARM64SUB)
8756 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
8757 v0.AuxInt = int64ToAuxInt(log64(c + 1))
8758 v0.AddArg2(x, x)
8759 v.AddArg2(a, v0)
8760 return true
8761 }
8762
8763
8764
8765 for {
8766 a := v_0
8767 x := v_1
8768 if v_2.Op != OpARM64MOVDconst {
8769 break
8770 }
8771 c := auxIntToInt64(v_2.AuxInt)
8772 if !(c%3 == 0 && isPowerOfTwo(c/3)) {
8773 break
8774 }
8775 v.reset(OpARM64SUBshiftLL)
8776 v.AuxInt = int64ToAuxInt(log64(c / 3))
8777 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
8778 v0.AuxInt = int64ToAuxInt(2)
8779 v0.AddArg2(x, x)
8780 v.AddArg2(a, v0)
8781 return true
8782 }
8783
8784
8785
8786 for {
8787 a := v_0
8788 x := v_1
8789 if v_2.Op != OpARM64MOVDconst {
8790 break
8791 }
8792 c := auxIntToInt64(v_2.AuxInt)
8793 if !(c%5 == 0 && isPowerOfTwo(c/5)) {
8794 break
8795 }
8796 v.reset(OpARM64ADDshiftLL)
8797 v.AuxInt = int64ToAuxInt(log64(c / 5))
8798 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
8799 v0.AuxInt = int64ToAuxInt(2)
8800 v0.AddArg2(x, x)
8801 v.AddArg2(a, v0)
8802 return true
8803 }
8804
8805
8806
8807 for {
8808 a := v_0
8809 x := v_1
8810 if v_2.Op != OpARM64MOVDconst {
8811 break
8812 }
8813 c := auxIntToInt64(v_2.AuxInt)
8814 if !(c%7 == 0 && isPowerOfTwo(c/7)) {
8815 break
8816 }
8817 v.reset(OpARM64SUBshiftLL)
8818 v.AuxInt = int64ToAuxInt(log64(c / 7))
8819 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
8820 v0.AuxInt = int64ToAuxInt(3)
8821 v0.AddArg2(x, x)
8822 v.AddArg2(a, v0)
8823 return true
8824 }
8825
8826
8827
8828 for {
8829 a := v_0
8830 x := v_1
8831 if v_2.Op != OpARM64MOVDconst {
8832 break
8833 }
8834 c := auxIntToInt64(v_2.AuxInt)
8835 if !(c%9 == 0 && isPowerOfTwo(c/9)) {
8836 break
8837 }
8838 v.reset(OpARM64ADDshiftLL)
8839 v.AuxInt = int64ToAuxInt(log64(c / 9))
8840 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
8841 v0.AuxInt = int64ToAuxInt(3)
8842 v0.AddArg2(x, x)
8843 v.AddArg2(a, v0)
8844 return true
8845 }
8846
8847
8848 for {
8849 a := v_0
8850 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != -1 {
8851 break
8852 }
8853 x := v_2
8854 v.reset(OpARM64SUB)
8855 v.AddArg2(a, x)
8856 return true
8857 }
8858
8859
8860 for {
8861 a := v_0
8862 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
8863 break
8864 }
8865 v.copyOf(a)
8866 return true
8867 }
8868
8869
8870 for {
8871 a := v_0
8872 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
8873 break
8874 }
8875 x := v_2
8876 v.reset(OpARM64ADD)
8877 v.AddArg2(a, x)
8878 return true
8879 }
8880
8881
8882
8883 for {
8884 a := v_0
8885 if v_1.Op != OpARM64MOVDconst {
8886 break
8887 }
8888 c := auxIntToInt64(v_1.AuxInt)
8889 x := v_2
8890 if !(isPowerOfTwo(c)) {
8891 break
8892 }
8893 v.reset(OpARM64ADDshiftLL)
8894 v.AuxInt = int64ToAuxInt(log64(c))
8895 v.AddArg2(a, x)
8896 return true
8897 }
8898
8899
8900
8901 for {
8902 a := v_0
8903 if v_1.Op != OpARM64MOVDconst {
8904 break
8905 }
8906 c := auxIntToInt64(v_1.AuxInt)
8907 x := v_2
8908 if !(isPowerOfTwo(c-1) && c >= 3) {
8909 break
8910 }
8911 v.reset(OpARM64ADD)
8912 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
8913 v0.AuxInt = int64ToAuxInt(log64(c - 1))
8914 v0.AddArg2(x, x)
8915 v.AddArg2(a, v0)
8916 return true
8917 }
8918
8919
8920
8921 for {
8922 a := v_0
8923 if v_1.Op != OpARM64MOVDconst {
8924 break
8925 }
8926 c := auxIntToInt64(v_1.AuxInt)
8927 x := v_2
8928 if !(isPowerOfTwo(c+1) && c >= 7) {
8929 break
8930 }
8931 v.reset(OpARM64SUB)
8932 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
8933 v0.AuxInt = int64ToAuxInt(log64(c + 1))
8934 v0.AddArg2(x, x)
8935 v.AddArg2(a, v0)
8936 return true
8937 }
8938
8939
8940
8941 for {
8942 a := v_0
8943 if v_1.Op != OpARM64MOVDconst {
8944 break
8945 }
8946 c := auxIntToInt64(v_1.AuxInt)
8947 x := v_2
8948 if !(c%3 == 0 && isPowerOfTwo(c/3)) {
8949 break
8950 }
8951 v.reset(OpARM64SUBshiftLL)
8952 v.AuxInt = int64ToAuxInt(log64(c / 3))
8953 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
8954 v0.AuxInt = int64ToAuxInt(2)
8955 v0.AddArg2(x, x)
8956 v.AddArg2(a, v0)
8957 return true
8958 }
8959
8960
8961
8962 for {
8963 a := v_0
8964 if v_1.Op != OpARM64MOVDconst {
8965 break
8966 }
8967 c := auxIntToInt64(v_1.AuxInt)
8968 x := v_2
8969 if !(c%5 == 0 && isPowerOfTwo(c/5)) {
8970 break
8971 }
8972 v.reset(OpARM64ADDshiftLL)
8973 v.AuxInt = int64ToAuxInt(log64(c / 5))
8974 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
8975 v0.AuxInt = int64ToAuxInt(2)
8976 v0.AddArg2(x, x)
8977 v.AddArg2(a, v0)
8978 return true
8979 }
8980
8981
8982
8983 for {
8984 a := v_0
8985 if v_1.Op != OpARM64MOVDconst {
8986 break
8987 }
8988 c := auxIntToInt64(v_1.AuxInt)
8989 x := v_2
8990 if !(c%7 == 0 && isPowerOfTwo(c/7)) {
8991 break
8992 }
8993 v.reset(OpARM64SUBshiftLL)
8994 v.AuxInt = int64ToAuxInt(log64(c / 7))
8995 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
8996 v0.AuxInt = int64ToAuxInt(3)
8997 v0.AddArg2(x, x)
8998 v.AddArg2(a, v0)
8999 return true
9000 }
9001
9002
9003
9004 for {
9005 a := v_0
9006 if v_1.Op != OpARM64MOVDconst {
9007 break
9008 }
9009 c := auxIntToInt64(v_1.AuxInt)
9010 x := v_2
9011 if !(c%9 == 0 && isPowerOfTwo(c/9)) {
9012 break
9013 }
9014 v.reset(OpARM64ADDshiftLL)
9015 v.AuxInt = int64ToAuxInt(log64(c / 9))
9016 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9017 v0.AuxInt = int64ToAuxInt(3)
9018 v0.AddArg2(x, x)
9019 v.AddArg2(a, v0)
9020 return true
9021 }
9022
9023
9024 for {
9025 if v_0.Op != OpARM64MOVDconst {
9026 break
9027 }
9028 c := auxIntToInt64(v_0.AuxInt)
9029 x := v_1
9030 y := v_2
9031 v.reset(OpARM64ADDconst)
9032 v.AuxInt = int64ToAuxInt(c)
9033 v0 := b.NewValue0(v.Pos, OpARM64MUL, x.Type)
9034 v0.AddArg2(x, y)
9035 v.AddArg(v0)
9036 return true
9037 }
9038
9039
9040 for {
9041 a := v_0
9042 if v_1.Op != OpARM64MOVDconst {
9043 break
9044 }
9045 c := auxIntToInt64(v_1.AuxInt)
9046 if v_2.Op != OpARM64MOVDconst {
9047 break
9048 }
9049 d := auxIntToInt64(v_2.AuxInt)
9050 v.reset(OpARM64ADDconst)
9051 v.AuxInt = int64ToAuxInt(c * d)
9052 v.AddArg(a)
9053 return true
9054 }
9055 return false
9056 }
9057 func rewriteValueARM64_OpARM64MADDW(v *Value) bool {
9058 v_2 := v.Args[2]
9059 v_1 := v.Args[1]
9060 v_0 := v.Args[0]
9061 b := v.Block
9062
9063
9064
9065 for {
9066 a := v_0
9067 x := v_1
9068 if v_2.Op != OpARM64MOVDconst {
9069 break
9070 }
9071 c := auxIntToInt64(v_2.AuxInt)
9072 if !(int32(c) == -1) {
9073 break
9074 }
9075 v.reset(OpARM64MOVWUreg)
9076 v0 := b.NewValue0(v.Pos, OpARM64SUB, a.Type)
9077 v0.AddArg2(a, x)
9078 v.AddArg(v0)
9079 return true
9080 }
9081
9082
9083
9084 for {
9085 a := v_0
9086 if v_2.Op != OpARM64MOVDconst {
9087 break
9088 }
9089 c := auxIntToInt64(v_2.AuxInt)
9090 if !(int32(c) == 0) {
9091 break
9092 }
9093 v.reset(OpARM64MOVWUreg)
9094 v.AddArg(a)
9095 return true
9096 }
9097
9098
9099
9100 for {
9101 a := v_0
9102 x := v_1
9103 if v_2.Op != OpARM64MOVDconst {
9104 break
9105 }
9106 c := auxIntToInt64(v_2.AuxInt)
9107 if !(int32(c) == 1) {
9108 break
9109 }
9110 v.reset(OpARM64MOVWUreg)
9111 v0 := b.NewValue0(v.Pos, OpARM64ADD, a.Type)
9112 v0.AddArg2(a, x)
9113 v.AddArg(v0)
9114 return true
9115 }
9116
9117
9118
9119 for {
9120 a := v_0
9121 x := v_1
9122 if v_2.Op != OpARM64MOVDconst {
9123 break
9124 }
9125 c := auxIntToInt64(v_2.AuxInt)
9126 if !(isPowerOfTwo(c)) {
9127 break
9128 }
9129 v.reset(OpARM64MOVWUreg)
9130 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
9131 v0.AuxInt = int64ToAuxInt(log64(c))
9132 v0.AddArg2(a, x)
9133 v.AddArg(v0)
9134 return true
9135 }
9136
9137
9138
9139 for {
9140 a := v_0
9141 x := v_1
9142 if v_2.Op != OpARM64MOVDconst {
9143 break
9144 }
9145 c := auxIntToInt64(v_2.AuxInt)
9146 if !(isPowerOfTwo(c-1) && int32(c) >= 3) {
9147 break
9148 }
9149 v.reset(OpARM64MOVWUreg)
9150 v0 := b.NewValue0(v.Pos, OpARM64ADD, a.Type)
9151 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9152 v1.AuxInt = int64ToAuxInt(log64(c - 1))
9153 v1.AddArg2(x, x)
9154 v0.AddArg2(a, v1)
9155 v.AddArg(v0)
9156 return true
9157 }
9158
9159
9160
9161 for {
9162 a := v_0
9163 x := v_1
9164 if v_2.Op != OpARM64MOVDconst {
9165 break
9166 }
9167 c := auxIntToInt64(v_2.AuxInt)
9168 if !(isPowerOfTwo(c+1) && int32(c) >= 7) {
9169 break
9170 }
9171 v.reset(OpARM64MOVWUreg)
9172 v0 := b.NewValue0(v.Pos, OpARM64SUB, a.Type)
9173 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9174 v1.AuxInt = int64ToAuxInt(log64(c + 1))
9175 v1.AddArg2(x, x)
9176 v0.AddArg2(a, v1)
9177 v.AddArg(v0)
9178 return true
9179 }
9180
9181
9182
9183 for {
9184 a := v_0
9185 x := v_1
9186 if v_2.Op != OpARM64MOVDconst {
9187 break
9188 }
9189 c := auxIntToInt64(v_2.AuxInt)
9190 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) {
9191 break
9192 }
9193 v.reset(OpARM64MOVWUreg)
9194 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
9195 v0.AuxInt = int64ToAuxInt(log64(c / 3))
9196 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9197 v1.AuxInt = int64ToAuxInt(2)
9198 v1.AddArg2(x, x)
9199 v0.AddArg2(a, v1)
9200 v.AddArg(v0)
9201 return true
9202 }
9203
9204
9205
9206 for {
9207 a := v_0
9208 x := v_1
9209 if v_2.Op != OpARM64MOVDconst {
9210 break
9211 }
9212 c := auxIntToInt64(v_2.AuxInt)
9213 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) {
9214 break
9215 }
9216 v.reset(OpARM64MOVWUreg)
9217 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
9218 v0.AuxInt = int64ToAuxInt(log64(c / 5))
9219 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9220 v1.AuxInt = int64ToAuxInt(2)
9221 v1.AddArg2(x, x)
9222 v0.AddArg2(a, v1)
9223 v.AddArg(v0)
9224 return true
9225 }
9226
9227
9228
9229 for {
9230 a := v_0
9231 x := v_1
9232 if v_2.Op != OpARM64MOVDconst {
9233 break
9234 }
9235 c := auxIntToInt64(v_2.AuxInt)
9236 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) {
9237 break
9238 }
9239 v.reset(OpARM64MOVWUreg)
9240 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
9241 v0.AuxInt = int64ToAuxInt(log64(c / 7))
9242 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9243 v1.AuxInt = int64ToAuxInt(3)
9244 v1.AddArg2(x, x)
9245 v0.AddArg2(a, v1)
9246 v.AddArg(v0)
9247 return true
9248 }
9249
9250
9251
9252 for {
9253 a := v_0
9254 x := v_1
9255 if v_2.Op != OpARM64MOVDconst {
9256 break
9257 }
9258 c := auxIntToInt64(v_2.AuxInt)
9259 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) {
9260 break
9261 }
9262 v.reset(OpARM64MOVWUreg)
9263 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
9264 v0.AuxInt = int64ToAuxInt(log64(c / 9))
9265 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9266 v1.AuxInt = int64ToAuxInt(3)
9267 v1.AddArg2(x, x)
9268 v0.AddArg2(a, v1)
9269 v.AddArg(v0)
9270 return true
9271 }
9272
9273
9274
9275 for {
9276 a := v_0
9277 if v_1.Op != OpARM64MOVDconst {
9278 break
9279 }
9280 c := auxIntToInt64(v_1.AuxInt)
9281 x := v_2
9282 if !(int32(c) == -1) {
9283 break
9284 }
9285 v.reset(OpARM64MOVWUreg)
9286 v0 := b.NewValue0(v.Pos, OpARM64SUB, a.Type)
9287 v0.AddArg2(a, x)
9288 v.AddArg(v0)
9289 return true
9290 }
9291
9292
9293
9294 for {
9295 a := v_0
9296 if v_1.Op != OpARM64MOVDconst {
9297 break
9298 }
9299 c := auxIntToInt64(v_1.AuxInt)
9300 if !(int32(c) == 0) {
9301 break
9302 }
9303 v.reset(OpARM64MOVWUreg)
9304 v.AddArg(a)
9305 return true
9306 }
9307
9308
9309
9310 for {
9311 a := v_0
9312 if v_1.Op != OpARM64MOVDconst {
9313 break
9314 }
9315 c := auxIntToInt64(v_1.AuxInt)
9316 x := v_2
9317 if !(int32(c) == 1) {
9318 break
9319 }
9320 v.reset(OpARM64MOVWUreg)
9321 v0 := b.NewValue0(v.Pos, OpARM64ADD, a.Type)
9322 v0.AddArg2(a, x)
9323 v.AddArg(v0)
9324 return true
9325 }
9326
9327
9328
9329 for {
9330 a := v_0
9331 if v_1.Op != OpARM64MOVDconst {
9332 break
9333 }
9334 c := auxIntToInt64(v_1.AuxInt)
9335 x := v_2
9336 if !(isPowerOfTwo(c)) {
9337 break
9338 }
9339 v.reset(OpARM64MOVWUreg)
9340 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
9341 v0.AuxInt = int64ToAuxInt(log64(c))
9342 v0.AddArg2(a, x)
9343 v.AddArg(v0)
9344 return true
9345 }
9346
9347
9348
9349 for {
9350 a := v_0
9351 if v_1.Op != OpARM64MOVDconst {
9352 break
9353 }
9354 c := auxIntToInt64(v_1.AuxInt)
9355 x := v_2
9356 if !(isPowerOfTwo(c-1) && int32(c) >= 3) {
9357 break
9358 }
9359 v.reset(OpARM64MOVWUreg)
9360 v0 := b.NewValue0(v.Pos, OpARM64ADD, a.Type)
9361 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9362 v1.AuxInt = int64ToAuxInt(log64(c - 1))
9363 v1.AddArg2(x, x)
9364 v0.AddArg2(a, v1)
9365 v.AddArg(v0)
9366 return true
9367 }
9368
9369
9370
9371 for {
9372 a := v_0
9373 if v_1.Op != OpARM64MOVDconst {
9374 break
9375 }
9376 c := auxIntToInt64(v_1.AuxInt)
9377 x := v_2
9378 if !(isPowerOfTwo(c+1) && int32(c) >= 7) {
9379 break
9380 }
9381 v.reset(OpARM64MOVWUreg)
9382 v0 := b.NewValue0(v.Pos, OpARM64SUB, a.Type)
9383 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9384 v1.AuxInt = int64ToAuxInt(log64(c + 1))
9385 v1.AddArg2(x, x)
9386 v0.AddArg2(a, v1)
9387 v.AddArg(v0)
9388 return true
9389 }
9390
9391
9392
9393 for {
9394 a := v_0
9395 if v_1.Op != OpARM64MOVDconst {
9396 break
9397 }
9398 c := auxIntToInt64(v_1.AuxInt)
9399 x := v_2
9400 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) {
9401 break
9402 }
9403 v.reset(OpARM64MOVWUreg)
9404 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
9405 v0.AuxInt = int64ToAuxInt(log64(c / 3))
9406 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9407 v1.AuxInt = int64ToAuxInt(2)
9408 v1.AddArg2(x, x)
9409 v0.AddArg2(a, v1)
9410 v.AddArg(v0)
9411 return true
9412 }
9413
9414
9415
9416 for {
9417 a := v_0
9418 if v_1.Op != OpARM64MOVDconst {
9419 break
9420 }
9421 c := auxIntToInt64(v_1.AuxInt)
9422 x := v_2
9423 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) {
9424 break
9425 }
9426 v.reset(OpARM64MOVWUreg)
9427 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
9428 v0.AuxInt = int64ToAuxInt(log64(c / 5))
9429 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9430 v1.AuxInt = int64ToAuxInt(2)
9431 v1.AddArg2(x, x)
9432 v0.AddArg2(a, v1)
9433 v.AddArg(v0)
9434 return true
9435 }
9436
9437
9438
9439 for {
9440 a := v_0
9441 if v_1.Op != OpARM64MOVDconst {
9442 break
9443 }
9444 c := auxIntToInt64(v_1.AuxInt)
9445 x := v_2
9446 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) {
9447 break
9448 }
9449 v.reset(OpARM64MOVWUreg)
9450 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
9451 v0.AuxInt = int64ToAuxInt(log64(c / 7))
9452 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9453 v1.AuxInt = int64ToAuxInt(3)
9454 v1.AddArg2(x, x)
9455 v0.AddArg2(a, v1)
9456 v.AddArg(v0)
9457 return true
9458 }
9459
9460
9461
9462 for {
9463 a := v_0
9464 if v_1.Op != OpARM64MOVDconst {
9465 break
9466 }
9467 c := auxIntToInt64(v_1.AuxInt)
9468 x := v_2
9469 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) {
9470 break
9471 }
9472 v.reset(OpARM64MOVWUreg)
9473 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
9474 v0.AuxInt = int64ToAuxInt(log64(c / 9))
9475 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9476 v1.AuxInt = int64ToAuxInt(3)
9477 v1.AddArg2(x, x)
9478 v0.AddArg2(a, v1)
9479 v.AddArg(v0)
9480 return true
9481 }
9482
9483
9484 for {
9485 if v_0.Op != OpARM64MOVDconst {
9486 break
9487 }
9488 c := auxIntToInt64(v_0.AuxInt)
9489 x := v_1
9490 y := v_2
9491 v.reset(OpARM64MOVWUreg)
9492 v0 := b.NewValue0(v.Pos, OpARM64ADDconst, x.Type)
9493 v0.AuxInt = int64ToAuxInt(c)
9494 v1 := b.NewValue0(v.Pos, OpARM64MULW, x.Type)
9495 v1.AddArg2(x, y)
9496 v0.AddArg(v1)
9497 v.AddArg(v0)
9498 return true
9499 }
9500
9501
9502 for {
9503 a := v_0
9504 if v_1.Op != OpARM64MOVDconst {
9505 break
9506 }
9507 c := auxIntToInt64(v_1.AuxInt)
9508 if v_2.Op != OpARM64MOVDconst {
9509 break
9510 }
9511 d := auxIntToInt64(v_2.AuxInt)
9512 v.reset(OpARM64MOVWUreg)
9513 v0 := b.NewValue0(v.Pos, OpARM64ADDconst, a.Type)
9514 v0.AuxInt = int64ToAuxInt(c * d)
9515 v0.AddArg(a)
9516 v.AddArg(v0)
9517 return true
9518 }
9519 return false
9520 }
9521 func rewriteValueARM64_OpARM64MNEG(v *Value) bool {
9522 v_1 := v.Args[1]
9523 v_0 := v.Args[0]
9524 b := v.Block
9525
9526
9527 for {
9528 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9529 x := v_0
9530 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != -1 {
9531 continue
9532 }
9533 v.copyOf(x)
9534 return true
9535 }
9536 break
9537 }
9538
9539
9540 for {
9541 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9542 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
9543 continue
9544 }
9545 v.reset(OpARM64MOVDconst)
9546 v.AuxInt = int64ToAuxInt(0)
9547 return true
9548 }
9549 break
9550 }
9551
9552
9553 for {
9554 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9555 x := v_0
9556 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
9557 continue
9558 }
9559 v.reset(OpARM64NEG)
9560 v.AddArg(x)
9561 return true
9562 }
9563 break
9564 }
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 {
9572 continue
9573 }
9574 c := auxIntToInt64(v_1.AuxInt)
9575 if !(isPowerOfTwo(c)) {
9576 continue
9577 }
9578 v.reset(OpARM64NEG)
9579 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
9580 v0.AuxInt = int64ToAuxInt(log64(c))
9581 v0.AddArg(x)
9582 v.AddArg(v0)
9583 return true
9584 }
9585 break
9586 }
9587
9588
9589
9590 for {
9591 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9592 x := v_0
9593 if v_1.Op != OpARM64MOVDconst {
9594 continue
9595 }
9596 c := auxIntToInt64(v_1.AuxInt)
9597 if !(isPowerOfTwo(c-1) && c >= 3) {
9598 continue
9599 }
9600 v.reset(OpARM64NEG)
9601 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9602 v0.AuxInt = int64ToAuxInt(log64(c - 1))
9603 v0.AddArg2(x, x)
9604 v.AddArg(v0)
9605 return true
9606 }
9607 break
9608 }
9609
9610
9611
9612 for {
9613 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9614 x := v_0
9615 if v_1.Op != OpARM64MOVDconst {
9616 continue
9617 }
9618 c := auxIntToInt64(v_1.AuxInt)
9619 if !(isPowerOfTwo(c+1) && c >= 7) {
9620 continue
9621 }
9622 v.reset(OpARM64NEG)
9623 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9624 v0.AuxInt = int64ToAuxInt(log64(c + 1))
9625 v1 := b.NewValue0(v.Pos, OpARM64NEG, x.Type)
9626 v1.AddArg(x)
9627 v0.AddArg2(v1, x)
9628 v.AddArg(v0)
9629 return true
9630 }
9631 break
9632 }
9633
9634
9635
9636 for {
9637 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9638 x := v_0
9639 if v_1.Op != OpARM64MOVDconst {
9640 continue
9641 }
9642 c := auxIntToInt64(v_1.AuxInt)
9643 if !(c%3 == 0 && isPowerOfTwo(c/3)) {
9644 continue
9645 }
9646 v.reset(OpARM64SLLconst)
9647 v.Type = x.Type
9648 v.AuxInt = int64ToAuxInt(log64(c / 3))
9649 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9650 v0.AuxInt = int64ToAuxInt(2)
9651 v0.AddArg2(x, x)
9652 v.AddArg(v0)
9653 return true
9654 }
9655 break
9656 }
9657
9658
9659
9660 for {
9661 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9662 x := v_0
9663 if v_1.Op != OpARM64MOVDconst {
9664 continue
9665 }
9666 c := auxIntToInt64(v_1.AuxInt)
9667 if !(c%5 == 0 && isPowerOfTwo(c/5)) {
9668 continue
9669 }
9670 v.reset(OpARM64NEG)
9671 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
9672 v0.AuxInt = int64ToAuxInt(log64(c / 5))
9673 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9674 v1.AuxInt = int64ToAuxInt(2)
9675 v1.AddArg2(x, x)
9676 v0.AddArg(v1)
9677 v.AddArg(v0)
9678 return true
9679 }
9680 break
9681 }
9682
9683
9684
9685 for {
9686 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9687 x := v_0
9688 if v_1.Op != OpARM64MOVDconst {
9689 continue
9690 }
9691 c := auxIntToInt64(v_1.AuxInt)
9692 if !(c%7 == 0 && isPowerOfTwo(c/7)) {
9693 continue
9694 }
9695 v.reset(OpARM64SLLconst)
9696 v.Type = x.Type
9697 v.AuxInt = int64ToAuxInt(log64(c / 7))
9698 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9699 v0.AuxInt = int64ToAuxInt(3)
9700 v0.AddArg2(x, x)
9701 v.AddArg(v0)
9702 return true
9703 }
9704 break
9705 }
9706
9707
9708
9709 for {
9710 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9711 x := v_0
9712 if v_1.Op != OpARM64MOVDconst {
9713 continue
9714 }
9715 c := auxIntToInt64(v_1.AuxInt)
9716 if !(c%9 == 0 && isPowerOfTwo(c/9)) {
9717 continue
9718 }
9719 v.reset(OpARM64NEG)
9720 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
9721 v0.AuxInt = int64ToAuxInt(log64(c / 9))
9722 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9723 v1.AuxInt = int64ToAuxInt(3)
9724 v1.AddArg2(x, x)
9725 v0.AddArg(v1)
9726 v.AddArg(v0)
9727 return true
9728 }
9729 break
9730 }
9731
9732
9733 for {
9734 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9735 if v_0.Op != OpARM64MOVDconst {
9736 continue
9737 }
9738 c := auxIntToInt64(v_0.AuxInt)
9739 if v_1.Op != OpARM64MOVDconst {
9740 continue
9741 }
9742 d := auxIntToInt64(v_1.AuxInt)
9743 v.reset(OpARM64MOVDconst)
9744 v.AuxInt = int64ToAuxInt(-c * d)
9745 return true
9746 }
9747 break
9748 }
9749 return false
9750 }
9751 func rewriteValueARM64_OpARM64MNEGW(v *Value) bool {
9752 v_1 := v.Args[1]
9753 v_0 := v.Args[0]
9754 b := v.Block
9755
9756
9757
9758 for {
9759 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9760 x := v_0
9761 if v_1.Op != OpARM64MOVDconst {
9762 continue
9763 }
9764 c := auxIntToInt64(v_1.AuxInt)
9765 if !(int32(c) == -1) {
9766 continue
9767 }
9768 v.reset(OpARM64MOVWUreg)
9769 v.AddArg(x)
9770 return true
9771 }
9772 break
9773 }
9774
9775
9776
9777 for {
9778 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9779 if v_1.Op != OpARM64MOVDconst {
9780 continue
9781 }
9782 c := auxIntToInt64(v_1.AuxInt)
9783 if !(int32(c) == 0) {
9784 continue
9785 }
9786 v.reset(OpARM64MOVDconst)
9787 v.AuxInt = int64ToAuxInt(0)
9788 return true
9789 }
9790 break
9791 }
9792
9793
9794
9795 for {
9796 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9797 x := v_0
9798 if v_1.Op != OpARM64MOVDconst {
9799 continue
9800 }
9801 c := auxIntToInt64(v_1.AuxInt)
9802 if !(int32(c) == 1) {
9803 continue
9804 }
9805 v.reset(OpARM64MOVWUreg)
9806 v0 := b.NewValue0(v.Pos, OpARM64NEG, x.Type)
9807 v0.AddArg(x)
9808 v.AddArg(v0)
9809 return true
9810 }
9811 break
9812 }
9813
9814
9815
9816 for {
9817 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9818 x := v_0
9819 if v_1.Op != OpARM64MOVDconst {
9820 continue
9821 }
9822 c := auxIntToInt64(v_1.AuxInt)
9823 if !(isPowerOfTwo(c)) {
9824 continue
9825 }
9826 v.reset(OpARM64NEG)
9827 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
9828 v0.AuxInt = int64ToAuxInt(log64(c))
9829 v0.AddArg(x)
9830 v.AddArg(v0)
9831 return true
9832 }
9833 break
9834 }
9835
9836
9837
9838 for {
9839 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9840 x := v_0
9841 if v_1.Op != OpARM64MOVDconst {
9842 continue
9843 }
9844 c := auxIntToInt64(v_1.AuxInt)
9845 if !(isPowerOfTwo(c-1) && int32(c) >= 3) {
9846 continue
9847 }
9848 v.reset(OpARM64MOVWUreg)
9849 v0 := b.NewValue0(v.Pos, OpARM64NEG, x.Type)
9850 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9851 v1.AuxInt = int64ToAuxInt(log64(c - 1))
9852 v1.AddArg2(x, x)
9853 v0.AddArg(v1)
9854 v.AddArg(v0)
9855 return true
9856 }
9857 break
9858 }
9859
9860
9861
9862 for {
9863 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9864 x := v_0
9865 if v_1.Op != OpARM64MOVDconst {
9866 continue
9867 }
9868 c := auxIntToInt64(v_1.AuxInt)
9869 if !(isPowerOfTwo(c+1) && int32(c) >= 7) {
9870 continue
9871 }
9872 v.reset(OpARM64MOVWUreg)
9873 v0 := b.NewValue0(v.Pos, OpARM64NEG, x.Type)
9874 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9875 v1.AuxInt = int64ToAuxInt(log64(c + 1))
9876 v2 := b.NewValue0(v.Pos, OpARM64NEG, x.Type)
9877 v2.AddArg(x)
9878 v1.AddArg2(v2, x)
9879 v0.AddArg(v1)
9880 v.AddArg(v0)
9881 return true
9882 }
9883 break
9884 }
9885
9886
9887
9888 for {
9889 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9890 x := v_0
9891 if v_1.Op != OpARM64MOVDconst {
9892 continue
9893 }
9894 c := auxIntToInt64(v_1.AuxInt)
9895 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) {
9896 continue
9897 }
9898 v.reset(OpARM64MOVWUreg)
9899 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
9900 v0.AuxInt = int64ToAuxInt(log64(c / 3))
9901 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9902 v1.AuxInt = int64ToAuxInt(2)
9903 v1.AddArg2(x, x)
9904 v0.AddArg(v1)
9905 v.AddArg(v0)
9906 return true
9907 }
9908 break
9909 }
9910
9911
9912
9913 for {
9914 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9915 x := v_0
9916 if v_1.Op != OpARM64MOVDconst {
9917 continue
9918 }
9919 c := auxIntToInt64(v_1.AuxInt)
9920 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) {
9921 continue
9922 }
9923 v.reset(OpARM64MOVWUreg)
9924 v0 := b.NewValue0(v.Pos, OpARM64NEG, x.Type)
9925 v1 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
9926 v1.AuxInt = int64ToAuxInt(log64(c / 5))
9927 v2 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9928 v2.AuxInt = int64ToAuxInt(2)
9929 v2.AddArg2(x, x)
9930 v1.AddArg(v2)
9931 v0.AddArg(v1)
9932 v.AddArg(v0)
9933 return true
9934 }
9935 break
9936 }
9937
9938
9939
9940 for {
9941 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9942 x := v_0
9943 if v_1.Op != OpARM64MOVDconst {
9944 continue
9945 }
9946 c := auxIntToInt64(v_1.AuxInt)
9947 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) {
9948 continue
9949 }
9950 v.reset(OpARM64MOVWUreg)
9951 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
9952 v0.AuxInt = int64ToAuxInt(log64(c / 7))
9953 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
9954 v1.AuxInt = int64ToAuxInt(3)
9955 v1.AddArg2(x, x)
9956 v0.AddArg(v1)
9957 v.AddArg(v0)
9958 return true
9959 }
9960 break
9961 }
9962
9963
9964
9965 for {
9966 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9967 x := v_0
9968 if v_1.Op != OpARM64MOVDconst {
9969 continue
9970 }
9971 c := auxIntToInt64(v_1.AuxInt)
9972 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) {
9973 continue
9974 }
9975 v.reset(OpARM64MOVWUreg)
9976 v0 := b.NewValue0(v.Pos, OpARM64NEG, x.Type)
9977 v1 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
9978 v1.AuxInt = int64ToAuxInt(log64(c / 9))
9979 v2 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
9980 v2.AuxInt = int64ToAuxInt(3)
9981 v2.AddArg2(x, x)
9982 v1.AddArg(v2)
9983 v0.AddArg(v1)
9984 v.AddArg(v0)
9985 return true
9986 }
9987 break
9988 }
9989
9990
9991 for {
9992 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
9993 if v_0.Op != OpARM64MOVDconst {
9994 continue
9995 }
9996 c := auxIntToInt64(v_0.AuxInt)
9997 if v_1.Op != OpARM64MOVDconst {
9998 continue
9999 }
10000 d := auxIntToInt64(v_1.AuxInt)
10001 v.reset(OpARM64MOVDconst)
10002 v.AuxInt = int64ToAuxInt(int64(uint32(-c * d)))
10003 return true
10004 }
10005 break
10006 }
10007 return false
10008 }
10009 func rewriteValueARM64_OpARM64MOD(v *Value) bool {
10010 v_1 := v.Args[1]
10011 v_0 := v.Args[0]
10012
10013
10014
10015 for {
10016 if v_0.Op != OpARM64MOVDconst {
10017 break
10018 }
10019 c := auxIntToInt64(v_0.AuxInt)
10020 if v_1.Op != OpARM64MOVDconst {
10021 break
10022 }
10023 d := auxIntToInt64(v_1.AuxInt)
10024 if !(d != 0) {
10025 break
10026 }
10027 v.reset(OpARM64MOVDconst)
10028 v.AuxInt = int64ToAuxInt(c % d)
10029 return true
10030 }
10031 return false
10032 }
10033 func rewriteValueARM64_OpARM64MODW(v *Value) bool {
10034 v_1 := v.Args[1]
10035 v_0 := v.Args[0]
10036
10037
10038
10039 for {
10040 if v_0.Op != OpARM64MOVDconst {
10041 break
10042 }
10043 c := auxIntToInt64(v_0.AuxInt)
10044 if v_1.Op != OpARM64MOVDconst {
10045 break
10046 }
10047 d := auxIntToInt64(v_1.AuxInt)
10048 if !(d != 0) {
10049 break
10050 }
10051 v.reset(OpARM64MOVDconst)
10052 v.AuxInt = int64ToAuxInt(int64(uint32(int32(c) % int32(d))))
10053 return true
10054 }
10055 return false
10056 }
10057 func rewriteValueARM64_OpARM64MOVBUload(v *Value) bool {
10058 v_1 := v.Args[1]
10059 v_0 := v.Args[0]
10060 b := v.Block
10061 config := b.Func.Config
10062
10063
10064
10065 for {
10066 off1 := auxIntToInt32(v.AuxInt)
10067 sym := auxToSym(v.Aux)
10068 if v_0.Op != OpARM64ADDconst {
10069 break
10070 }
10071 off2 := auxIntToInt64(v_0.AuxInt)
10072 ptr := v_0.Args[0]
10073 mem := v_1
10074 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
10075 break
10076 }
10077 v.reset(OpARM64MOVBUload)
10078 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
10079 v.Aux = symToAux(sym)
10080 v.AddArg2(ptr, mem)
10081 return true
10082 }
10083
10084
10085
10086 for {
10087 off := auxIntToInt32(v.AuxInt)
10088 sym := auxToSym(v.Aux)
10089 if v_0.Op != OpARM64ADD {
10090 break
10091 }
10092 idx := v_0.Args[1]
10093 ptr := v_0.Args[0]
10094 mem := v_1
10095 if !(off == 0 && sym == nil) {
10096 break
10097 }
10098 v.reset(OpARM64MOVBUloadidx)
10099 v.AddArg3(ptr, idx, mem)
10100 return true
10101 }
10102
10103
10104
10105 for {
10106 off1 := auxIntToInt32(v.AuxInt)
10107 sym1 := auxToSym(v.Aux)
10108 if v_0.Op != OpARM64MOVDaddr {
10109 break
10110 }
10111 off2 := auxIntToInt32(v_0.AuxInt)
10112 sym2 := auxToSym(v_0.Aux)
10113 ptr := v_0.Args[0]
10114 mem := v_1
10115 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
10116 break
10117 }
10118 v.reset(OpARM64MOVBUload)
10119 v.AuxInt = int32ToAuxInt(off1 + off2)
10120 v.Aux = symToAux(mergeSym(sym1, sym2))
10121 v.AddArg2(ptr, mem)
10122 return true
10123 }
10124
10125
10126
10127 for {
10128 off := auxIntToInt32(v.AuxInt)
10129 sym := auxToSym(v.Aux)
10130 if v_0.Op != OpSB || !(symIsRO(sym)) {
10131 break
10132 }
10133 v.reset(OpARM64MOVDconst)
10134 v.AuxInt = int64ToAuxInt(int64(read8(sym, int64(off))))
10135 return true
10136 }
10137 return false
10138 }
10139 func rewriteValueARM64_OpARM64MOVBUloadidx(v *Value) bool {
10140 v_2 := v.Args[2]
10141 v_1 := v.Args[1]
10142 v_0 := v.Args[0]
10143
10144
10145
10146 for {
10147 ptr := v_0
10148 if v_1.Op != OpARM64MOVDconst {
10149 break
10150 }
10151 c := auxIntToInt64(v_1.AuxInt)
10152 mem := v_2
10153 if !(is32Bit(c)) {
10154 break
10155 }
10156 v.reset(OpARM64MOVBUload)
10157 v.AuxInt = int32ToAuxInt(int32(c))
10158 v.AddArg2(ptr, mem)
10159 return true
10160 }
10161
10162
10163
10164 for {
10165 if v_0.Op != OpARM64MOVDconst {
10166 break
10167 }
10168 c := auxIntToInt64(v_0.AuxInt)
10169 ptr := v_1
10170 mem := v_2
10171 if !(is32Bit(c)) {
10172 break
10173 }
10174 v.reset(OpARM64MOVBUload)
10175 v.AuxInt = int32ToAuxInt(int32(c))
10176 v.AddArg2(ptr, mem)
10177 return true
10178 }
10179 return false
10180 }
10181 func rewriteValueARM64_OpARM64MOVBUreg(v *Value) bool {
10182 v_0 := v.Args[0]
10183
10184
10185 for {
10186 if v_0.Op != OpARM64ANDconst {
10187 break
10188 }
10189 c := auxIntToInt64(v_0.AuxInt)
10190 x := v_0.Args[0]
10191 v.reset(OpARM64ANDconst)
10192 v.AuxInt = int64ToAuxInt(c & (1<<8 - 1))
10193 v.AddArg(x)
10194 return true
10195 }
10196
10197
10198 for {
10199 if v_0.Op != OpARM64MOVDconst {
10200 break
10201 }
10202 c := auxIntToInt64(v_0.AuxInt)
10203 v.reset(OpARM64MOVDconst)
10204 v.AuxInt = int64ToAuxInt(int64(uint8(c)))
10205 return true
10206 }
10207
10208
10209
10210 for {
10211 x := v_0
10212 if !(v.Type.Size() <= 1) {
10213 break
10214 }
10215 v.copyOf(x)
10216 return true
10217 }
10218
10219
10220
10221 for {
10222 if v_0.Op != OpARM64SLLconst {
10223 break
10224 }
10225 lc := auxIntToInt64(v_0.AuxInt)
10226 if !(lc >= 8) {
10227 break
10228 }
10229 v.reset(OpARM64MOVDconst)
10230 v.AuxInt = int64ToAuxInt(0)
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 x := v_0.Args[0]
10242 if !(lc < 8) {
10243 break
10244 }
10245 v.reset(OpARM64UBFIZ)
10246 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, 8-lc))
10247 v.AddArg(x)
10248 return true
10249 }
10250
10251
10252
10253 for {
10254 if v_0.Op != OpARM64SRLconst {
10255 break
10256 }
10257 rc := auxIntToInt64(v_0.AuxInt)
10258 x := v_0.Args[0]
10259 if !(rc < 8) {
10260 break
10261 }
10262 v.reset(OpARM64UBFX)
10263 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 8))
10264 v.AddArg(x)
10265 return true
10266 }
10267
10268
10269
10270 for {
10271 if v_0.Op != OpARM64UBFX {
10272 break
10273 }
10274 bfc := auxIntToArm64BitField(v_0.AuxInt)
10275 x := v_0.Args[0]
10276 if !(bfc.width() <= 8) {
10277 break
10278 }
10279 v.reset(OpARM64UBFX)
10280 v.AuxInt = arm64BitFieldToAuxInt(bfc)
10281 v.AddArg(x)
10282 return true
10283 }
10284 return false
10285 }
10286 func rewriteValueARM64_OpARM64MOVBload(v *Value) bool {
10287 v_1 := v.Args[1]
10288 v_0 := v.Args[0]
10289 b := v.Block
10290 config := b.Func.Config
10291
10292
10293
10294 for {
10295 off1 := auxIntToInt32(v.AuxInt)
10296 sym := auxToSym(v.Aux)
10297 if v_0.Op != OpARM64ADDconst {
10298 break
10299 }
10300 off2 := auxIntToInt64(v_0.AuxInt)
10301 ptr := v_0.Args[0]
10302 mem := v_1
10303 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
10304 break
10305 }
10306 v.reset(OpARM64MOVBload)
10307 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
10308 v.Aux = symToAux(sym)
10309 v.AddArg2(ptr, mem)
10310 return true
10311 }
10312
10313
10314
10315 for {
10316 off := auxIntToInt32(v.AuxInt)
10317 sym := auxToSym(v.Aux)
10318 if v_0.Op != OpARM64ADD {
10319 break
10320 }
10321 idx := v_0.Args[1]
10322 ptr := v_0.Args[0]
10323 mem := v_1
10324 if !(off == 0 && sym == nil) {
10325 break
10326 }
10327 v.reset(OpARM64MOVBloadidx)
10328 v.AddArg3(ptr, idx, mem)
10329 return true
10330 }
10331
10332
10333
10334 for {
10335 off1 := auxIntToInt32(v.AuxInt)
10336 sym1 := auxToSym(v.Aux)
10337 if v_0.Op != OpARM64MOVDaddr {
10338 break
10339 }
10340 off2 := auxIntToInt32(v_0.AuxInt)
10341 sym2 := auxToSym(v_0.Aux)
10342 ptr := v_0.Args[0]
10343 mem := v_1
10344 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
10345 break
10346 }
10347 v.reset(OpARM64MOVBload)
10348 v.AuxInt = int32ToAuxInt(off1 + off2)
10349 v.Aux = symToAux(mergeSym(sym1, sym2))
10350 v.AddArg2(ptr, mem)
10351 return true
10352 }
10353
10354
10355
10356 for {
10357 off := auxIntToInt32(v.AuxInt)
10358 sym := auxToSym(v.Aux)
10359 if v_0.Op != OpSB || !(symIsRO(sym)) {
10360 break
10361 }
10362 v.reset(OpARM64MOVDconst)
10363 v.AuxInt = int64ToAuxInt(int64(int8(read8(sym, int64(off)))))
10364 return true
10365 }
10366 return false
10367 }
10368 func rewriteValueARM64_OpARM64MOVBloadidx(v *Value) bool {
10369 v_2 := v.Args[2]
10370 v_1 := v.Args[1]
10371 v_0 := v.Args[0]
10372
10373
10374
10375 for {
10376 ptr := v_0
10377 if v_1.Op != OpARM64MOVDconst {
10378 break
10379 }
10380 c := auxIntToInt64(v_1.AuxInt)
10381 mem := v_2
10382 if !(is32Bit(c)) {
10383 break
10384 }
10385 v.reset(OpARM64MOVBload)
10386 v.AuxInt = int32ToAuxInt(int32(c))
10387 v.AddArg2(ptr, mem)
10388 return true
10389 }
10390
10391
10392
10393 for {
10394 if v_0.Op != OpARM64MOVDconst {
10395 break
10396 }
10397 c := auxIntToInt64(v_0.AuxInt)
10398 ptr := v_1
10399 mem := v_2
10400 if !(is32Bit(c)) {
10401 break
10402 }
10403 v.reset(OpARM64MOVBload)
10404 v.AuxInt = int32ToAuxInt(int32(c))
10405 v.AddArg2(ptr, mem)
10406 return true
10407 }
10408 return false
10409 }
10410 func rewriteValueARM64_OpARM64MOVBreg(v *Value) bool {
10411 v_0 := v.Args[0]
10412
10413
10414 for {
10415 if v_0.Op != OpARM64MOVDconst {
10416 break
10417 }
10418 c := auxIntToInt64(v_0.AuxInt)
10419 v.reset(OpARM64MOVDconst)
10420 v.AuxInt = int64ToAuxInt(int64(int8(c)))
10421 return true
10422 }
10423
10424
10425
10426 for {
10427 x := v_0
10428 if !(v.Type.Size() <= 1) {
10429 break
10430 }
10431 v.copyOf(x)
10432 return true
10433 }
10434
10435
10436
10437 for {
10438 t := v.Type
10439 if v_0.Op != OpARM64ANDconst {
10440 break
10441 }
10442 c := auxIntToInt64(v_0.AuxInt)
10443 x := v_0.Args[0]
10444 if !(uint64(c)&uint64(0xffffffffffffff80) == 0) {
10445 break
10446 }
10447 v.reset(OpARM64ANDconst)
10448 v.Type = t
10449 v.AuxInt = int64ToAuxInt(c)
10450 v.AddArg(x)
10451 return true
10452 }
10453
10454
10455
10456 for {
10457 if v_0.Op != OpARM64SLLconst {
10458 break
10459 }
10460 lc := auxIntToInt64(v_0.AuxInt)
10461 x := v_0.Args[0]
10462 if !(lc < 8) {
10463 break
10464 }
10465 v.reset(OpARM64SBFIZ)
10466 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, 8-lc))
10467 v.AddArg(x)
10468 return true
10469 }
10470
10471
10472
10473 for {
10474 if v_0.Op != OpARM64SBFX {
10475 break
10476 }
10477 bfc := auxIntToArm64BitField(v_0.AuxInt)
10478 x := v_0.Args[0]
10479 if !(bfc.width() <= 8) {
10480 break
10481 }
10482 v.reset(OpARM64SBFX)
10483 v.AuxInt = arm64BitFieldToAuxInt(bfc)
10484 v.AddArg(x)
10485 return true
10486 }
10487 return false
10488 }
10489 func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool {
10490 v_2 := v.Args[2]
10491 v_1 := v.Args[1]
10492 v_0 := v.Args[0]
10493 b := v.Block
10494 config := b.Func.Config
10495
10496
10497
10498 for {
10499 off1 := auxIntToInt32(v.AuxInt)
10500 sym := auxToSym(v.Aux)
10501 if v_0.Op != OpARM64ADDconst {
10502 break
10503 }
10504 off2 := auxIntToInt64(v_0.AuxInt)
10505 ptr := v_0.Args[0]
10506 val := v_1
10507 mem := v_2
10508 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
10509 break
10510 }
10511 v.reset(OpARM64MOVBstore)
10512 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
10513 v.Aux = symToAux(sym)
10514 v.AddArg3(ptr, val, mem)
10515 return true
10516 }
10517
10518
10519
10520 for {
10521 off := auxIntToInt32(v.AuxInt)
10522 sym := auxToSym(v.Aux)
10523 if v_0.Op != OpARM64ADD {
10524 break
10525 }
10526 idx := v_0.Args[1]
10527 ptr := v_0.Args[0]
10528 val := v_1
10529 mem := v_2
10530 if !(off == 0 && sym == nil) {
10531 break
10532 }
10533 v.reset(OpARM64MOVBstoreidx)
10534 v.AddArg4(ptr, idx, val, mem)
10535 return true
10536 }
10537
10538
10539
10540 for {
10541 off1 := auxIntToInt32(v.AuxInt)
10542 sym1 := auxToSym(v.Aux)
10543 if v_0.Op != OpARM64MOVDaddr {
10544 break
10545 }
10546 off2 := auxIntToInt32(v_0.AuxInt)
10547 sym2 := auxToSym(v_0.Aux)
10548 ptr := v_0.Args[0]
10549 val := v_1
10550 mem := v_2
10551 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
10552 break
10553 }
10554 v.reset(OpARM64MOVBstore)
10555 v.AuxInt = int32ToAuxInt(off1 + off2)
10556 v.Aux = symToAux(mergeSym(sym1, sym2))
10557 v.AddArg3(ptr, val, mem)
10558 return true
10559 }
10560
10561
10562 for {
10563 off := auxIntToInt32(v.AuxInt)
10564 sym := auxToSym(v.Aux)
10565 ptr := v_0
10566 if v_1.Op != OpARM64MOVBreg {
10567 break
10568 }
10569 x := v_1.Args[0]
10570 mem := v_2
10571 v.reset(OpARM64MOVBstore)
10572 v.AuxInt = int32ToAuxInt(off)
10573 v.Aux = symToAux(sym)
10574 v.AddArg3(ptr, x, mem)
10575 return true
10576 }
10577
10578
10579 for {
10580 off := auxIntToInt32(v.AuxInt)
10581 sym := auxToSym(v.Aux)
10582 ptr := v_0
10583 if v_1.Op != OpARM64MOVBUreg {
10584 break
10585 }
10586 x := v_1.Args[0]
10587 mem := v_2
10588 v.reset(OpARM64MOVBstore)
10589 v.AuxInt = int32ToAuxInt(off)
10590 v.Aux = symToAux(sym)
10591 v.AddArg3(ptr, x, mem)
10592 return true
10593 }
10594
10595
10596 for {
10597 off := auxIntToInt32(v.AuxInt)
10598 sym := auxToSym(v.Aux)
10599 ptr := v_0
10600 if v_1.Op != OpARM64MOVHreg {
10601 break
10602 }
10603 x := v_1.Args[0]
10604 mem := v_2
10605 v.reset(OpARM64MOVBstore)
10606 v.AuxInt = int32ToAuxInt(off)
10607 v.Aux = symToAux(sym)
10608 v.AddArg3(ptr, x, mem)
10609 return true
10610 }
10611
10612
10613 for {
10614 off := auxIntToInt32(v.AuxInt)
10615 sym := auxToSym(v.Aux)
10616 ptr := v_0
10617 if v_1.Op != OpARM64MOVHUreg {
10618 break
10619 }
10620 x := v_1.Args[0]
10621 mem := v_2
10622 v.reset(OpARM64MOVBstore)
10623 v.AuxInt = int32ToAuxInt(off)
10624 v.Aux = symToAux(sym)
10625 v.AddArg3(ptr, x, mem)
10626 return true
10627 }
10628
10629
10630 for {
10631 off := auxIntToInt32(v.AuxInt)
10632 sym := auxToSym(v.Aux)
10633 ptr := v_0
10634 if v_1.Op != OpARM64MOVWreg {
10635 break
10636 }
10637 x := v_1.Args[0]
10638 mem := v_2
10639 v.reset(OpARM64MOVBstore)
10640 v.AuxInt = int32ToAuxInt(off)
10641 v.Aux = symToAux(sym)
10642 v.AddArg3(ptr, x, mem)
10643 return true
10644 }
10645
10646
10647 for {
10648 off := auxIntToInt32(v.AuxInt)
10649 sym := auxToSym(v.Aux)
10650 ptr := v_0
10651 if v_1.Op != OpARM64MOVWUreg {
10652 break
10653 }
10654 x := v_1.Args[0]
10655 mem := v_2
10656 v.reset(OpARM64MOVBstore)
10657 v.AuxInt = int32ToAuxInt(off)
10658 v.Aux = symToAux(sym)
10659 v.AddArg3(ptr, x, mem)
10660 return true
10661 }
10662 return false
10663 }
10664 func rewriteValueARM64_OpARM64MOVBstoreidx(v *Value) bool {
10665 v_3 := v.Args[3]
10666 v_2 := v.Args[2]
10667 v_1 := v.Args[1]
10668 v_0 := v.Args[0]
10669
10670
10671
10672 for {
10673 ptr := v_0
10674 if v_1.Op != OpARM64MOVDconst {
10675 break
10676 }
10677 c := auxIntToInt64(v_1.AuxInt)
10678 val := v_2
10679 mem := v_3
10680 if !(is32Bit(c)) {
10681 break
10682 }
10683 v.reset(OpARM64MOVBstore)
10684 v.AuxInt = int32ToAuxInt(int32(c))
10685 v.AddArg3(ptr, val, mem)
10686 return true
10687 }
10688
10689
10690
10691 for {
10692 if v_0.Op != OpARM64MOVDconst {
10693 break
10694 }
10695 c := auxIntToInt64(v_0.AuxInt)
10696 idx := v_1
10697 val := v_2
10698 mem := v_3
10699 if !(is32Bit(c)) {
10700 break
10701 }
10702 v.reset(OpARM64MOVBstore)
10703 v.AuxInt = int32ToAuxInt(int32(c))
10704 v.AddArg3(idx, val, mem)
10705 return true
10706 }
10707
10708
10709 for {
10710 ptr := v_0
10711 idx := v_1
10712 if v_2.Op != OpARM64MOVBreg {
10713 break
10714 }
10715 x := v_2.Args[0]
10716 mem := v_3
10717 v.reset(OpARM64MOVBstoreidx)
10718 v.AddArg4(ptr, idx, x, mem)
10719 return true
10720 }
10721
10722
10723 for {
10724 ptr := v_0
10725 idx := v_1
10726 if v_2.Op != OpARM64MOVBUreg {
10727 break
10728 }
10729 x := v_2.Args[0]
10730 mem := v_3
10731 v.reset(OpARM64MOVBstoreidx)
10732 v.AddArg4(ptr, idx, x, mem)
10733 return true
10734 }
10735
10736
10737 for {
10738 ptr := v_0
10739 idx := v_1
10740 if v_2.Op != OpARM64MOVHreg {
10741 break
10742 }
10743 x := v_2.Args[0]
10744 mem := v_3
10745 v.reset(OpARM64MOVBstoreidx)
10746 v.AddArg4(ptr, idx, x, mem)
10747 return true
10748 }
10749
10750
10751 for {
10752 ptr := v_0
10753 idx := v_1
10754 if v_2.Op != OpARM64MOVHUreg {
10755 break
10756 }
10757 x := v_2.Args[0]
10758 mem := v_3
10759 v.reset(OpARM64MOVBstoreidx)
10760 v.AddArg4(ptr, idx, x, mem)
10761 return true
10762 }
10763
10764
10765 for {
10766 ptr := v_0
10767 idx := v_1
10768 if v_2.Op != OpARM64MOVWreg {
10769 break
10770 }
10771 x := v_2.Args[0]
10772 mem := v_3
10773 v.reset(OpARM64MOVBstoreidx)
10774 v.AddArg4(ptr, idx, x, mem)
10775 return true
10776 }
10777
10778
10779 for {
10780 ptr := v_0
10781 idx := v_1
10782 if v_2.Op != OpARM64MOVWUreg {
10783 break
10784 }
10785 x := v_2.Args[0]
10786 mem := v_3
10787 v.reset(OpARM64MOVBstoreidx)
10788 v.AddArg4(ptr, idx, x, mem)
10789 return true
10790 }
10791 return false
10792 }
10793 func rewriteValueARM64_OpARM64MOVDload(v *Value) bool {
10794 v_1 := v.Args[1]
10795 v_0 := v.Args[0]
10796 b := v.Block
10797 config := b.Func.Config
10798
10799
10800 for {
10801 off := auxIntToInt32(v.AuxInt)
10802 sym := auxToSym(v.Aux)
10803 ptr := v_0
10804 if v_1.Op != OpARM64FMOVDstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
10805 break
10806 }
10807 val := v_1.Args[1]
10808 if ptr != v_1.Args[0] {
10809 break
10810 }
10811 v.reset(OpARM64FMOVDfpgp)
10812 v.AddArg(val)
10813 return true
10814 }
10815
10816
10817
10818 for {
10819 off1 := auxIntToInt32(v.AuxInt)
10820 sym := auxToSym(v.Aux)
10821 if v_0.Op != OpARM64ADDconst {
10822 break
10823 }
10824 off2 := auxIntToInt64(v_0.AuxInt)
10825 ptr := v_0.Args[0]
10826 mem := v_1
10827 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
10828 break
10829 }
10830 v.reset(OpARM64MOVDload)
10831 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
10832 v.Aux = symToAux(sym)
10833 v.AddArg2(ptr, mem)
10834 return true
10835 }
10836
10837
10838
10839 for {
10840 off := auxIntToInt32(v.AuxInt)
10841 sym := auxToSym(v.Aux)
10842 if v_0.Op != OpARM64ADD {
10843 break
10844 }
10845 idx := v_0.Args[1]
10846 ptr := v_0.Args[0]
10847 mem := v_1
10848 if !(off == 0 && sym == nil) {
10849 break
10850 }
10851 v.reset(OpARM64MOVDloadidx)
10852 v.AddArg3(ptr, idx, mem)
10853 return true
10854 }
10855
10856
10857
10858 for {
10859 off := auxIntToInt32(v.AuxInt)
10860 sym := auxToSym(v.Aux)
10861 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 3 {
10862 break
10863 }
10864 idx := v_0.Args[1]
10865 ptr := v_0.Args[0]
10866 mem := v_1
10867 if !(off == 0 && sym == nil) {
10868 break
10869 }
10870 v.reset(OpARM64MOVDloadidx8)
10871 v.AddArg3(ptr, idx, mem)
10872 return true
10873 }
10874
10875
10876
10877 for {
10878 off1 := auxIntToInt32(v.AuxInt)
10879 sym1 := auxToSym(v.Aux)
10880 if v_0.Op != OpARM64MOVDaddr {
10881 break
10882 }
10883 off2 := auxIntToInt32(v_0.AuxInt)
10884 sym2 := auxToSym(v_0.Aux)
10885 ptr := v_0.Args[0]
10886 mem := v_1
10887 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
10888 break
10889 }
10890 v.reset(OpARM64MOVDload)
10891 v.AuxInt = int32ToAuxInt(off1 + off2)
10892 v.Aux = symToAux(mergeSym(sym1, sym2))
10893 v.AddArg2(ptr, mem)
10894 return true
10895 }
10896
10897
10898
10899 for {
10900 off := auxIntToInt32(v.AuxInt)
10901 sym := auxToSym(v.Aux)
10902 if v_0.Op != OpSB || !(symIsRO(sym)) {
10903 break
10904 }
10905 v.reset(OpARM64MOVDconst)
10906 v.AuxInt = int64ToAuxInt(int64(read64(sym, int64(off), config.ctxt.Arch.ByteOrder)))
10907 return true
10908 }
10909 return false
10910 }
10911 func rewriteValueARM64_OpARM64MOVDloadidx(v *Value) bool {
10912 v_2 := v.Args[2]
10913 v_1 := v.Args[1]
10914 v_0 := v.Args[0]
10915
10916
10917
10918 for {
10919 ptr := v_0
10920 if v_1.Op != OpARM64MOVDconst {
10921 break
10922 }
10923 c := auxIntToInt64(v_1.AuxInt)
10924 mem := v_2
10925 if !(is32Bit(c)) {
10926 break
10927 }
10928 v.reset(OpARM64MOVDload)
10929 v.AuxInt = int32ToAuxInt(int32(c))
10930 v.AddArg2(ptr, mem)
10931 return true
10932 }
10933
10934
10935
10936 for {
10937 if v_0.Op != OpARM64MOVDconst {
10938 break
10939 }
10940 c := auxIntToInt64(v_0.AuxInt)
10941 ptr := v_1
10942 mem := v_2
10943 if !(is32Bit(c)) {
10944 break
10945 }
10946 v.reset(OpARM64MOVDload)
10947 v.AuxInt = int32ToAuxInt(int32(c))
10948 v.AddArg2(ptr, mem)
10949 return true
10950 }
10951
10952
10953 for {
10954 ptr := v_0
10955 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 3 {
10956 break
10957 }
10958 idx := v_1.Args[0]
10959 mem := v_2
10960 v.reset(OpARM64MOVDloadidx8)
10961 v.AddArg3(ptr, idx, mem)
10962 return true
10963 }
10964
10965
10966 for {
10967 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 3 {
10968 break
10969 }
10970 idx := v_0.Args[0]
10971 ptr := v_1
10972 mem := v_2
10973 v.reset(OpARM64MOVDloadidx8)
10974 v.AddArg3(ptr, idx, mem)
10975 return true
10976 }
10977 return false
10978 }
10979 func rewriteValueARM64_OpARM64MOVDloadidx8(v *Value) bool {
10980 v_2 := v.Args[2]
10981 v_1 := v.Args[1]
10982 v_0 := v.Args[0]
10983
10984
10985
10986 for {
10987 ptr := v_0
10988 if v_1.Op != OpARM64MOVDconst {
10989 break
10990 }
10991 c := auxIntToInt64(v_1.AuxInt)
10992 mem := v_2
10993 if !(is32Bit(c << 3)) {
10994 break
10995 }
10996 v.reset(OpARM64MOVDload)
10997 v.AuxInt = int32ToAuxInt(int32(c) << 3)
10998 v.AddArg2(ptr, mem)
10999 return true
11000 }
11001 return false
11002 }
11003 func rewriteValueARM64_OpARM64MOVDnop(v *Value) bool {
11004 v_0 := v.Args[0]
11005
11006
11007 for {
11008 if v_0.Op != OpARM64MOVDconst {
11009 break
11010 }
11011 c := auxIntToInt64(v_0.AuxInt)
11012 v.reset(OpARM64MOVDconst)
11013 v.AuxInt = int64ToAuxInt(c)
11014 return true
11015 }
11016 return false
11017 }
11018 func rewriteValueARM64_OpARM64MOVDreg(v *Value) bool {
11019 v_0 := v.Args[0]
11020
11021
11022
11023 for {
11024 x := v_0
11025 if !(x.Uses == 1) {
11026 break
11027 }
11028 v.reset(OpARM64MOVDnop)
11029 v.AddArg(x)
11030 return true
11031 }
11032
11033
11034 for {
11035 if v_0.Op != OpARM64MOVDconst {
11036 break
11037 }
11038 c := auxIntToInt64(v_0.AuxInt)
11039 v.reset(OpARM64MOVDconst)
11040 v.AuxInt = int64ToAuxInt(c)
11041 return true
11042 }
11043 return false
11044 }
11045 func rewriteValueARM64_OpARM64MOVDstore(v *Value) bool {
11046 v_2 := v.Args[2]
11047 v_1 := v.Args[1]
11048 v_0 := v.Args[0]
11049 b := v.Block
11050 config := b.Func.Config
11051
11052
11053 for {
11054 off := auxIntToInt32(v.AuxInt)
11055 sym := auxToSym(v.Aux)
11056 ptr := v_0
11057 if v_1.Op != OpARM64FMOVDfpgp {
11058 break
11059 }
11060 val := v_1.Args[0]
11061 mem := v_2
11062 v.reset(OpARM64FMOVDstore)
11063 v.AuxInt = int32ToAuxInt(off)
11064 v.Aux = symToAux(sym)
11065 v.AddArg3(ptr, val, mem)
11066 return true
11067 }
11068
11069
11070
11071 for {
11072 off1 := auxIntToInt32(v.AuxInt)
11073 sym := auxToSym(v.Aux)
11074 if v_0.Op != OpARM64ADDconst {
11075 break
11076 }
11077 off2 := auxIntToInt64(v_0.AuxInt)
11078 ptr := v_0.Args[0]
11079 val := v_1
11080 mem := v_2
11081 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
11082 break
11083 }
11084 v.reset(OpARM64MOVDstore)
11085 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
11086 v.Aux = symToAux(sym)
11087 v.AddArg3(ptr, val, mem)
11088 return true
11089 }
11090
11091
11092
11093 for {
11094 off := auxIntToInt32(v.AuxInt)
11095 sym := auxToSym(v.Aux)
11096 if v_0.Op != OpARM64ADD {
11097 break
11098 }
11099 idx := v_0.Args[1]
11100 ptr := v_0.Args[0]
11101 val := v_1
11102 mem := v_2
11103 if !(off == 0 && sym == nil) {
11104 break
11105 }
11106 v.reset(OpARM64MOVDstoreidx)
11107 v.AddArg4(ptr, idx, val, mem)
11108 return true
11109 }
11110
11111
11112
11113 for {
11114 off := auxIntToInt32(v.AuxInt)
11115 sym := auxToSym(v.Aux)
11116 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 3 {
11117 break
11118 }
11119 idx := v_0.Args[1]
11120 ptr := v_0.Args[0]
11121 val := v_1
11122 mem := v_2
11123 if !(off == 0 && sym == nil) {
11124 break
11125 }
11126 v.reset(OpARM64MOVDstoreidx8)
11127 v.AddArg4(ptr, idx, val, mem)
11128 return true
11129 }
11130
11131
11132
11133 for {
11134 off1 := auxIntToInt32(v.AuxInt)
11135 sym1 := auxToSym(v.Aux)
11136 if v_0.Op != OpARM64MOVDaddr {
11137 break
11138 }
11139 off2 := auxIntToInt32(v_0.AuxInt)
11140 sym2 := auxToSym(v_0.Aux)
11141 ptr := v_0.Args[0]
11142 val := v_1
11143 mem := v_2
11144 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
11145 break
11146 }
11147 v.reset(OpARM64MOVDstore)
11148 v.AuxInt = int32ToAuxInt(off1 + off2)
11149 v.Aux = symToAux(mergeSym(sym1, sym2))
11150 v.AddArg3(ptr, val, mem)
11151 return true
11152 }
11153 return false
11154 }
11155 func rewriteValueARM64_OpARM64MOVDstoreidx(v *Value) bool {
11156 v_3 := v.Args[3]
11157 v_2 := v.Args[2]
11158 v_1 := v.Args[1]
11159 v_0 := v.Args[0]
11160
11161
11162
11163 for {
11164 ptr := v_0
11165 if v_1.Op != OpARM64MOVDconst {
11166 break
11167 }
11168 c := auxIntToInt64(v_1.AuxInt)
11169 val := v_2
11170 mem := v_3
11171 if !(is32Bit(c)) {
11172 break
11173 }
11174 v.reset(OpARM64MOVDstore)
11175 v.AuxInt = int32ToAuxInt(int32(c))
11176 v.AddArg3(ptr, val, mem)
11177 return true
11178 }
11179
11180
11181
11182 for {
11183 if v_0.Op != OpARM64MOVDconst {
11184 break
11185 }
11186 c := auxIntToInt64(v_0.AuxInt)
11187 idx := v_1
11188 val := v_2
11189 mem := v_3
11190 if !(is32Bit(c)) {
11191 break
11192 }
11193 v.reset(OpARM64MOVDstore)
11194 v.AuxInt = int32ToAuxInt(int32(c))
11195 v.AddArg3(idx, val, mem)
11196 return true
11197 }
11198
11199
11200 for {
11201 ptr := v_0
11202 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 3 {
11203 break
11204 }
11205 idx := v_1.Args[0]
11206 val := v_2
11207 mem := v_3
11208 v.reset(OpARM64MOVDstoreidx8)
11209 v.AddArg4(ptr, idx, val, mem)
11210 return true
11211 }
11212
11213
11214 for {
11215 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 3 {
11216 break
11217 }
11218 idx := v_0.Args[0]
11219 ptr := v_1
11220 val := v_2
11221 mem := v_3
11222 v.reset(OpARM64MOVDstoreidx8)
11223 v.AddArg4(ptr, idx, val, mem)
11224 return true
11225 }
11226 return false
11227 }
11228 func rewriteValueARM64_OpARM64MOVDstoreidx8(v *Value) bool {
11229 v_3 := v.Args[3]
11230 v_2 := v.Args[2]
11231 v_1 := v.Args[1]
11232 v_0 := v.Args[0]
11233
11234
11235
11236 for {
11237 ptr := v_0
11238 if v_1.Op != OpARM64MOVDconst {
11239 break
11240 }
11241 c := auxIntToInt64(v_1.AuxInt)
11242 val := v_2
11243 mem := v_3
11244 if !(is32Bit(c << 3)) {
11245 break
11246 }
11247 v.reset(OpARM64MOVDstore)
11248 v.AuxInt = int32ToAuxInt(int32(c) << 3)
11249 v.AddArg3(ptr, val, mem)
11250 return true
11251 }
11252 return false
11253 }
11254 func rewriteValueARM64_OpARM64MOVHUload(v *Value) bool {
11255 v_1 := v.Args[1]
11256 v_0 := v.Args[0]
11257 b := v.Block
11258 config := b.Func.Config
11259
11260
11261
11262 for {
11263 off1 := auxIntToInt32(v.AuxInt)
11264 sym := auxToSym(v.Aux)
11265 if v_0.Op != OpARM64ADDconst {
11266 break
11267 }
11268 off2 := auxIntToInt64(v_0.AuxInt)
11269 ptr := v_0.Args[0]
11270 mem := v_1
11271 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
11272 break
11273 }
11274 v.reset(OpARM64MOVHUload)
11275 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
11276 v.Aux = symToAux(sym)
11277 v.AddArg2(ptr, mem)
11278 return true
11279 }
11280
11281
11282
11283 for {
11284 off := auxIntToInt32(v.AuxInt)
11285 sym := auxToSym(v.Aux)
11286 if v_0.Op != OpARM64ADD {
11287 break
11288 }
11289 idx := v_0.Args[1]
11290 ptr := v_0.Args[0]
11291 mem := v_1
11292 if !(off == 0 && sym == nil) {
11293 break
11294 }
11295 v.reset(OpARM64MOVHUloadidx)
11296 v.AddArg3(ptr, idx, mem)
11297 return true
11298 }
11299
11300
11301
11302 for {
11303 off := auxIntToInt32(v.AuxInt)
11304 sym := auxToSym(v.Aux)
11305 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 1 {
11306 break
11307 }
11308 idx := v_0.Args[1]
11309 ptr := v_0.Args[0]
11310 mem := v_1
11311 if !(off == 0 && sym == nil) {
11312 break
11313 }
11314 v.reset(OpARM64MOVHUloadidx2)
11315 v.AddArg3(ptr, idx, mem)
11316 return true
11317 }
11318
11319
11320
11321 for {
11322 off1 := auxIntToInt32(v.AuxInt)
11323 sym1 := auxToSym(v.Aux)
11324 if v_0.Op != OpARM64MOVDaddr {
11325 break
11326 }
11327 off2 := auxIntToInt32(v_0.AuxInt)
11328 sym2 := auxToSym(v_0.Aux)
11329 ptr := v_0.Args[0]
11330 mem := v_1
11331 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
11332 break
11333 }
11334 v.reset(OpARM64MOVHUload)
11335 v.AuxInt = int32ToAuxInt(off1 + off2)
11336 v.Aux = symToAux(mergeSym(sym1, sym2))
11337 v.AddArg2(ptr, mem)
11338 return true
11339 }
11340
11341
11342
11343 for {
11344 off := auxIntToInt32(v.AuxInt)
11345 sym := auxToSym(v.Aux)
11346 if v_0.Op != OpSB || !(symIsRO(sym)) {
11347 break
11348 }
11349 v.reset(OpARM64MOVDconst)
11350 v.AuxInt = int64ToAuxInt(int64(read16(sym, int64(off), config.ctxt.Arch.ByteOrder)))
11351 return true
11352 }
11353 return false
11354 }
11355 func rewriteValueARM64_OpARM64MOVHUloadidx(v *Value) bool {
11356 v_2 := v.Args[2]
11357 v_1 := v.Args[1]
11358 v_0 := v.Args[0]
11359
11360
11361
11362 for {
11363 ptr := v_0
11364 if v_1.Op != OpARM64MOVDconst {
11365 break
11366 }
11367 c := auxIntToInt64(v_1.AuxInt)
11368 mem := v_2
11369 if !(is32Bit(c)) {
11370 break
11371 }
11372 v.reset(OpARM64MOVHUload)
11373 v.AuxInt = int32ToAuxInt(int32(c))
11374 v.AddArg2(ptr, mem)
11375 return true
11376 }
11377
11378
11379
11380 for {
11381 if v_0.Op != OpARM64MOVDconst {
11382 break
11383 }
11384 c := auxIntToInt64(v_0.AuxInt)
11385 ptr := v_1
11386 mem := v_2
11387 if !(is32Bit(c)) {
11388 break
11389 }
11390 v.reset(OpARM64MOVHUload)
11391 v.AuxInt = int32ToAuxInt(int32(c))
11392 v.AddArg2(ptr, mem)
11393 return true
11394 }
11395
11396
11397 for {
11398 ptr := v_0
11399 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 1 {
11400 break
11401 }
11402 idx := v_1.Args[0]
11403 mem := v_2
11404 v.reset(OpARM64MOVHUloadidx2)
11405 v.AddArg3(ptr, idx, mem)
11406 return true
11407 }
11408
11409
11410 for {
11411 ptr := v_0
11412 if v_1.Op != OpARM64ADD {
11413 break
11414 }
11415 idx := v_1.Args[1]
11416 if idx != v_1.Args[0] {
11417 break
11418 }
11419 mem := v_2
11420 v.reset(OpARM64MOVHUloadidx2)
11421 v.AddArg3(ptr, idx, mem)
11422 return true
11423 }
11424
11425
11426 for {
11427 if v_0.Op != OpARM64ADD {
11428 break
11429 }
11430 idx := v_0.Args[1]
11431 if idx != v_0.Args[0] {
11432 break
11433 }
11434 ptr := v_1
11435 mem := v_2
11436 v.reset(OpARM64MOVHUloadidx2)
11437 v.AddArg3(ptr, idx, mem)
11438 return true
11439 }
11440 return false
11441 }
11442 func rewriteValueARM64_OpARM64MOVHUloadidx2(v *Value) bool {
11443 v_2 := v.Args[2]
11444 v_1 := v.Args[1]
11445 v_0 := v.Args[0]
11446
11447
11448
11449 for {
11450 ptr := v_0
11451 if v_1.Op != OpARM64MOVDconst {
11452 break
11453 }
11454 c := auxIntToInt64(v_1.AuxInt)
11455 mem := v_2
11456 if !(is32Bit(c << 1)) {
11457 break
11458 }
11459 v.reset(OpARM64MOVHUload)
11460 v.AuxInt = int32ToAuxInt(int32(c) << 1)
11461 v.AddArg2(ptr, mem)
11462 return true
11463 }
11464 return false
11465 }
11466 func rewriteValueARM64_OpARM64MOVHUreg(v *Value) bool {
11467 v_0 := v.Args[0]
11468
11469
11470 for {
11471 if v_0.Op != OpARM64ANDconst {
11472 break
11473 }
11474 c := auxIntToInt64(v_0.AuxInt)
11475 x := v_0.Args[0]
11476 v.reset(OpARM64ANDconst)
11477 v.AuxInt = int64ToAuxInt(c & (1<<16 - 1))
11478 v.AddArg(x)
11479 return true
11480 }
11481
11482
11483 for {
11484 if v_0.Op != OpARM64MOVDconst {
11485 break
11486 }
11487 c := auxIntToInt64(v_0.AuxInt)
11488 v.reset(OpARM64MOVDconst)
11489 v.AuxInt = int64ToAuxInt(int64(uint16(c)))
11490 return true
11491 }
11492
11493
11494
11495 for {
11496 x := v_0
11497 if !(v.Type.Size() <= 2) {
11498 break
11499 }
11500 v.copyOf(x)
11501 return true
11502 }
11503
11504
11505
11506 for {
11507 if v_0.Op != OpARM64SLLconst {
11508 break
11509 }
11510 lc := auxIntToInt64(v_0.AuxInt)
11511 if !(lc >= 16) {
11512 break
11513 }
11514 v.reset(OpARM64MOVDconst)
11515 v.AuxInt = int64ToAuxInt(0)
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 x := v_0.Args[0]
11527 if !(lc < 16) {
11528 break
11529 }
11530 v.reset(OpARM64UBFIZ)
11531 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, 16-lc))
11532 v.AddArg(x)
11533 return true
11534 }
11535
11536
11537
11538 for {
11539 if v_0.Op != OpARM64SRLconst {
11540 break
11541 }
11542 rc := auxIntToInt64(v_0.AuxInt)
11543 x := v_0.Args[0]
11544 if !(rc < 16) {
11545 break
11546 }
11547 v.reset(OpARM64UBFX)
11548 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 16))
11549 v.AddArg(x)
11550 return true
11551 }
11552
11553
11554
11555 for {
11556 if v_0.Op != OpARM64UBFX {
11557 break
11558 }
11559 bfc := auxIntToArm64BitField(v_0.AuxInt)
11560 x := v_0.Args[0]
11561 if !(bfc.width() <= 16) {
11562 break
11563 }
11564 v.reset(OpARM64UBFX)
11565 v.AuxInt = arm64BitFieldToAuxInt(bfc)
11566 v.AddArg(x)
11567 return true
11568 }
11569 return false
11570 }
11571 func rewriteValueARM64_OpARM64MOVHload(v *Value) bool {
11572 v_1 := v.Args[1]
11573 v_0 := v.Args[0]
11574 b := v.Block
11575 config := b.Func.Config
11576
11577
11578
11579 for {
11580 off1 := auxIntToInt32(v.AuxInt)
11581 sym := auxToSym(v.Aux)
11582 if v_0.Op != OpARM64ADDconst {
11583 break
11584 }
11585 off2 := auxIntToInt64(v_0.AuxInt)
11586 ptr := v_0.Args[0]
11587 mem := v_1
11588 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
11589 break
11590 }
11591 v.reset(OpARM64MOVHload)
11592 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
11593 v.Aux = symToAux(sym)
11594 v.AddArg2(ptr, mem)
11595 return true
11596 }
11597
11598
11599
11600 for {
11601 off := auxIntToInt32(v.AuxInt)
11602 sym := auxToSym(v.Aux)
11603 if v_0.Op != OpARM64ADD {
11604 break
11605 }
11606 idx := v_0.Args[1]
11607 ptr := v_0.Args[0]
11608 mem := v_1
11609 if !(off == 0 && sym == nil) {
11610 break
11611 }
11612 v.reset(OpARM64MOVHloadidx)
11613 v.AddArg3(ptr, idx, mem)
11614 return true
11615 }
11616
11617
11618
11619 for {
11620 off := auxIntToInt32(v.AuxInt)
11621 sym := auxToSym(v.Aux)
11622 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 1 {
11623 break
11624 }
11625 idx := v_0.Args[1]
11626 ptr := v_0.Args[0]
11627 mem := v_1
11628 if !(off == 0 && sym == nil) {
11629 break
11630 }
11631 v.reset(OpARM64MOVHloadidx2)
11632 v.AddArg3(ptr, idx, mem)
11633 return true
11634 }
11635
11636
11637
11638 for {
11639 off1 := auxIntToInt32(v.AuxInt)
11640 sym1 := auxToSym(v.Aux)
11641 if v_0.Op != OpARM64MOVDaddr {
11642 break
11643 }
11644 off2 := auxIntToInt32(v_0.AuxInt)
11645 sym2 := auxToSym(v_0.Aux)
11646 ptr := v_0.Args[0]
11647 mem := v_1
11648 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
11649 break
11650 }
11651 v.reset(OpARM64MOVHload)
11652 v.AuxInt = int32ToAuxInt(off1 + off2)
11653 v.Aux = symToAux(mergeSym(sym1, sym2))
11654 v.AddArg2(ptr, mem)
11655 return true
11656 }
11657
11658
11659
11660 for {
11661 off := auxIntToInt32(v.AuxInt)
11662 sym := auxToSym(v.Aux)
11663 if v_0.Op != OpSB || !(symIsRO(sym)) {
11664 break
11665 }
11666 v.reset(OpARM64MOVDconst)
11667 v.AuxInt = int64ToAuxInt(int64(int16(read16(sym, int64(off), config.ctxt.Arch.ByteOrder))))
11668 return true
11669 }
11670 return false
11671 }
11672 func rewriteValueARM64_OpARM64MOVHloadidx(v *Value) bool {
11673 v_2 := v.Args[2]
11674 v_1 := v.Args[1]
11675 v_0 := v.Args[0]
11676
11677
11678
11679 for {
11680 ptr := v_0
11681 if v_1.Op != OpARM64MOVDconst {
11682 break
11683 }
11684 c := auxIntToInt64(v_1.AuxInt)
11685 mem := v_2
11686 if !(is32Bit(c)) {
11687 break
11688 }
11689 v.reset(OpARM64MOVHload)
11690 v.AuxInt = int32ToAuxInt(int32(c))
11691 v.AddArg2(ptr, mem)
11692 return true
11693 }
11694
11695
11696
11697 for {
11698 if v_0.Op != OpARM64MOVDconst {
11699 break
11700 }
11701 c := auxIntToInt64(v_0.AuxInt)
11702 ptr := v_1
11703 mem := v_2
11704 if !(is32Bit(c)) {
11705 break
11706 }
11707 v.reset(OpARM64MOVHload)
11708 v.AuxInt = int32ToAuxInt(int32(c))
11709 v.AddArg2(ptr, mem)
11710 return true
11711 }
11712
11713
11714 for {
11715 ptr := v_0
11716 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 1 {
11717 break
11718 }
11719 idx := v_1.Args[0]
11720 mem := v_2
11721 v.reset(OpARM64MOVHloadidx2)
11722 v.AddArg3(ptr, idx, mem)
11723 return true
11724 }
11725
11726
11727 for {
11728 ptr := v_0
11729 if v_1.Op != OpARM64ADD {
11730 break
11731 }
11732 idx := v_1.Args[1]
11733 if idx != v_1.Args[0] {
11734 break
11735 }
11736 mem := v_2
11737 v.reset(OpARM64MOVHloadidx2)
11738 v.AddArg3(ptr, idx, mem)
11739 return true
11740 }
11741
11742
11743 for {
11744 if v_0.Op != OpARM64ADD {
11745 break
11746 }
11747 idx := v_0.Args[1]
11748 if idx != v_0.Args[0] {
11749 break
11750 }
11751 ptr := v_1
11752 mem := v_2
11753 v.reset(OpARM64MOVHloadidx2)
11754 v.AddArg3(ptr, idx, mem)
11755 return true
11756 }
11757 return false
11758 }
11759 func rewriteValueARM64_OpARM64MOVHloadidx2(v *Value) bool {
11760 v_2 := v.Args[2]
11761 v_1 := v.Args[1]
11762 v_0 := v.Args[0]
11763
11764
11765
11766 for {
11767 ptr := v_0
11768 if v_1.Op != OpARM64MOVDconst {
11769 break
11770 }
11771 c := auxIntToInt64(v_1.AuxInt)
11772 mem := v_2
11773 if !(is32Bit(c << 1)) {
11774 break
11775 }
11776 v.reset(OpARM64MOVHload)
11777 v.AuxInt = int32ToAuxInt(int32(c) << 1)
11778 v.AddArg2(ptr, mem)
11779 return true
11780 }
11781 return false
11782 }
11783 func rewriteValueARM64_OpARM64MOVHreg(v *Value) bool {
11784 v_0 := v.Args[0]
11785
11786
11787 for {
11788 if v_0.Op != OpARM64MOVDconst {
11789 break
11790 }
11791 c := auxIntToInt64(v_0.AuxInt)
11792 v.reset(OpARM64MOVDconst)
11793 v.AuxInt = int64ToAuxInt(int64(int16(c)))
11794 return true
11795 }
11796
11797
11798
11799 for {
11800 x := v_0
11801 if !(v.Type.Size() <= 2) {
11802 break
11803 }
11804 v.copyOf(x)
11805 return true
11806 }
11807
11808
11809
11810 for {
11811 t := v.Type
11812 if v_0.Op != OpARM64ANDconst {
11813 break
11814 }
11815 c := auxIntToInt64(v_0.AuxInt)
11816 x := v_0.Args[0]
11817 if !(uint64(c)&uint64(0xffffffffffff8000) == 0) {
11818 break
11819 }
11820 v.reset(OpARM64ANDconst)
11821 v.Type = t
11822 v.AuxInt = int64ToAuxInt(c)
11823 v.AddArg(x)
11824 return true
11825 }
11826
11827
11828
11829 for {
11830 if v_0.Op != OpARM64SLLconst {
11831 break
11832 }
11833 lc := auxIntToInt64(v_0.AuxInt)
11834 x := v_0.Args[0]
11835 if !(lc < 16) {
11836 break
11837 }
11838 v.reset(OpARM64SBFIZ)
11839 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, 16-lc))
11840 v.AddArg(x)
11841 return true
11842 }
11843
11844
11845
11846 for {
11847 if v_0.Op != OpARM64SBFX {
11848 break
11849 }
11850 bfc := auxIntToArm64BitField(v_0.AuxInt)
11851 x := v_0.Args[0]
11852 if !(bfc.width() <= 16) {
11853 break
11854 }
11855 v.reset(OpARM64SBFX)
11856 v.AuxInt = arm64BitFieldToAuxInt(bfc)
11857 v.AddArg(x)
11858 return true
11859 }
11860 return false
11861 }
11862 func rewriteValueARM64_OpARM64MOVHstore(v *Value) bool {
11863 v_2 := v.Args[2]
11864 v_1 := v.Args[1]
11865 v_0 := v.Args[0]
11866 b := v.Block
11867 config := b.Func.Config
11868
11869
11870
11871 for {
11872 off1 := auxIntToInt32(v.AuxInt)
11873 sym := auxToSym(v.Aux)
11874 if v_0.Op != OpARM64ADDconst {
11875 break
11876 }
11877 off2 := auxIntToInt64(v_0.AuxInt)
11878 ptr := v_0.Args[0]
11879 val := v_1
11880 mem := v_2
11881 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
11882 break
11883 }
11884 v.reset(OpARM64MOVHstore)
11885 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
11886 v.Aux = symToAux(sym)
11887 v.AddArg3(ptr, val, mem)
11888 return true
11889 }
11890
11891
11892
11893 for {
11894 off := auxIntToInt32(v.AuxInt)
11895 sym := auxToSym(v.Aux)
11896 if v_0.Op != OpARM64ADD {
11897 break
11898 }
11899 idx := v_0.Args[1]
11900 ptr := v_0.Args[0]
11901 val := v_1
11902 mem := v_2
11903 if !(off == 0 && sym == nil) {
11904 break
11905 }
11906 v.reset(OpARM64MOVHstoreidx)
11907 v.AddArg4(ptr, idx, val, mem)
11908 return true
11909 }
11910
11911
11912
11913 for {
11914 off := auxIntToInt32(v.AuxInt)
11915 sym := auxToSym(v.Aux)
11916 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 1 {
11917 break
11918 }
11919 idx := v_0.Args[1]
11920 ptr := v_0.Args[0]
11921 val := v_1
11922 mem := v_2
11923 if !(off == 0 && sym == nil) {
11924 break
11925 }
11926 v.reset(OpARM64MOVHstoreidx2)
11927 v.AddArg4(ptr, idx, val, mem)
11928 return true
11929 }
11930
11931
11932
11933 for {
11934 off1 := auxIntToInt32(v.AuxInt)
11935 sym1 := auxToSym(v.Aux)
11936 if v_0.Op != OpARM64MOVDaddr {
11937 break
11938 }
11939 off2 := auxIntToInt32(v_0.AuxInt)
11940 sym2 := auxToSym(v_0.Aux)
11941 ptr := v_0.Args[0]
11942 val := v_1
11943 mem := v_2
11944 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
11945 break
11946 }
11947 v.reset(OpARM64MOVHstore)
11948 v.AuxInt = int32ToAuxInt(off1 + off2)
11949 v.Aux = symToAux(mergeSym(sym1, sym2))
11950 v.AddArg3(ptr, val, mem)
11951 return true
11952 }
11953
11954
11955 for {
11956 off := auxIntToInt32(v.AuxInt)
11957 sym := auxToSym(v.Aux)
11958 ptr := v_0
11959 if v_1.Op != OpARM64MOVHreg {
11960 break
11961 }
11962 x := v_1.Args[0]
11963 mem := v_2
11964 v.reset(OpARM64MOVHstore)
11965 v.AuxInt = int32ToAuxInt(off)
11966 v.Aux = symToAux(sym)
11967 v.AddArg3(ptr, x, mem)
11968 return true
11969 }
11970
11971
11972 for {
11973 off := auxIntToInt32(v.AuxInt)
11974 sym := auxToSym(v.Aux)
11975 ptr := v_0
11976 if v_1.Op != OpARM64MOVHUreg {
11977 break
11978 }
11979 x := v_1.Args[0]
11980 mem := v_2
11981 v.reset(OpARM64MOVHstore)
11982 v.AuxInt = int32ToAuxInt(off)
11983 v.Aux = symToAux(sym)
11984 v.AddArg3(ptr, x, mem)
11985 return true
11986 }
11987
11988
11989 for {
11990 off := auxIntToInt32(v.AuxInt)
11991 sym := auxToSym(v.Aux)
11992 ptr := v_0
11993 if v_1.Op != OpARM64MOVWreg {
11994 break
11995 }
11996 x := v_1.Args[0]
11997 mem := v_2
11998 v.reset(OpARM64MOVHstore)
11999 v.AuxInt = int32ToAuxInt(off)
12000 v.Aux = symToAux(sym)
12001 v.AddArg3(ptr, x, mem)
12002 return true
12003 }
12004
12005
12006 for {
12007 off := auxIntToInt32(v.AuxInt)
12008 sym := auxToSym(v.Aux)
12009 ptr := v_0
12010 if v_1.Op != OpARM64MOVWUreg {
12011 break
12012 }
12013 x := v_1.Args[0]
12014 mem := v_2
12015 v.reset(OpARM64MOVHstore)
12016 v.AuxInt = int32ToAuxInt(off)
12017 v.Aux = symToAux(sym)
12018 v.AddArg3(ptr, x, mem)
12019 return true
12020 }
12021 return false
12022 }
12023 func rewriteValueARM64_OpARM64MOVHstoreidx(v *Value) bool {
12024 v_3 := v.Args[3]
12025 v_2 := v.Args[2]
12026 v_1 := v.Args[1]
12027 v_0 := v.Args[0]
12028
12029
12030
12031 for {
12032 ptr := v_0
12033 if v_1.Op != OpARM64MOVDconst {
12034 break
12035 }
12036 c := auxIntToInt64(v_1.AuxInt)
12037 val := v_2
12038 mem := v_3
12039 if !(is32Bit(c)) {
12040 break
12041 }
12042 v.reset(OpARM64MOVHstore)
12043 v.AuxInt = int32ToAuxInt(int32(c))
12044 v.AddArg3(ptr, val, mem)
12045 return true
12046 }
12047
12048
12049
12050 for {
12051 if v_0.Op != OpARM64MOVDconst {
12052 break
12053 }
12054 c := auxIntToInt64(v_0.AuxInt)
12055 idx := v_1
12056 val := v_2
12057 mem := v_3
12058 if !(is32Bit(c)) {
12059 break
12060 }
12061 v.reset(OpARM64MOVHstore)
12062 v.AuxInt = int32ToAuxInt(int32(c))
12063 v.AddArg3(idx, val, mem)
12064 return true
12065 }
12066
12067
12068 for {
12069 ptr := v_0
12070 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 1 {
12071 break
12072 }
12073 idx := v_1.Args[0]
12074 val := v_2
12075 mem := v_3
12076 v.reset(OpARM64MOVHstoreidx2)
12077 v.AddArg4(ptr, idx, val, mem)
12078 return true
12079 }
12080
12081
12082 for {
12083 ptr := v_0
12084 if v_1.Op != OpARM64ADD {
12085 break
12086 }
12087 idx := v_1.Args[1]
12088 if idx != v_1.Args[0] {
12089 break
12090 }
12091 val := v_2
12092 mem := v_3
12093 v.reset(OpARM64MOVHstoreidx2)
12094 v.AddArg4(ptr, idx, val, mem)
12095 return true
12096 }
12097
12098
12099 for {
12100 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 1 {
12101 break
12102 }
12103 idx := v_0.Args[0]
12104 ptr := v_1
12105 val := v_2
12106 mem := v_3
12107 v.reset(OpARM64MOVHstoreidx2)
12108 v.AddArg4(ptr, idx, val, mem)
12109 return true
12110 }
12111
12112
12113 for {
12114 if v_0.Op != OpARM64ADD {
12115 break
12116 }
12117 idx := v_0.Args[1]
12118 if idx != v_0.Args[0] {
12119 break
12120 }
12121 ptr := v_1
12122 val := v_2
12123 mem := v_3
12124 v.reset(OpARM64MOVHstoreidx2)
12125 v.AddArg4(ptr, idx, val, mem)
12126 return true
12127 }
12128
12129
12130 for {
12131 ptr := v_0
12132 idx := v_1
12133 if v_2.Op != OpARM64MOVHreg {
12134 break
12135 }
12136 x := v_2.Args[0]
12137 mem := v_3
12138 v.reset(OpARM64MOVHstoreidx)
12139 v.AddArg4(ptr, idx, x, mem)
12140 return true
12141 }
12142
12143
12144 for {
12145 ptr := v_0
12146 idx := v_1
12147 if v_2.Op != OpARM64MOVHUreg {
12148 break
12149 }
12150 x := v_2.Args[0]
12151 mem := v_3
12152 v.reset(OpARM64MOVHstoreidx)
12153 v.AddArg4(ptr, idx, x, mem)
12154 return true
12155 }
12156
12157
12158 for {
12159 ptr := v_0
12160 idx := v_1
12161 if v_2.Op != OpARM64MOVWreg {
12162 break
12163 }
12164 x := v_2.Args[0]
12165 mem := v_3
12166 v.reset(OpARM64MOVHstoreidx)
12167 v.AddArg4(ptr, idx, x, mem)
12168 return true
12169 }
12170
12171
12172 for {
12173 ptr := v_0
12174 idx := v_1
12175 if v_2.Op != OpARM64MOVWUreg {
12176 break
12177 }
12178 x := v_2.Args[0]
12179 mem := v_3
12180 v.reset(OpARM64MOVHstoreidx)
12181 v.AddArg4(ptr, idx, x, mem)
12182 return true
12183 }
12184 return false
12185 }
12186 func rewriteValueARM64_OpARM64MOVHstoreidx2(v *Value) bool {
12187 v_3 := v.Args[3]
12188 v_2 := v.Args[2]
12189 v_1 := v.Args[1]
12190 v_0 := v.Args[0]
12191
12192
12193
12194 for {
12195 ptr := v_0
12196 if v_1.Op != OpARM64MOVDconst {
12197 break
12198 }
12199 c := auxIntToInt64(v_1.AuxInt)
12200 val := v_2
12201 mem := v_3
12202 if !(is32Bit(c << 1)) {
12203 break
12204 }
12205 v.reset(OpARM64MOVHstore)
12206 v.AuxInt = int32ToAuxInt(int32(c) << 1)
12207 v.AddArg3(ptr, val, mem)
12208 return true
12209 }
12210
12211
12212 for {
12213 ptr := v_0
12214 idx := v_1
12215 if v_2.Op != OpARM64MOVHreg {
12216 break
12217 }
12218 x := v_2.Args[0]
12219 mem := v_3
12220 v.reset(OpARM64MOVHstoreidx2)
12221 v.AddArg4(ptr, idx, x, mem)
12222 return true
12223 }
12224
12225
12226 for {
12227 ptr := v_0
12228 idx := v_1
12229 if v_2.Op != OpARM64MOVHUreg {
12230 break
12231 }
12232 x := v_2.Args[0]
12233 mem := v_3
12234 v.reset(OpARM64MOVHstoreidx2)
12235 v.AddArg4(ptr, idx, x, mem)
12236 return true
12237 }
12238
12239
12240 for {
12241 ptr := v_0
12242 idx := v_1
12243 if v_2.Op != OpARM64MOVWreg {
12244 break
12245 }
12246 x := v_2.Args[0]
12247 mem := v_3
12248 v.reset(OpARM64MOVHstoreidx2)
12249 v.AddArg4(ptr, idx, x, mem)
12250 return true
12251 }
12252
12253
12254 for {
12255 ptr := v_0
12256 idx := v_1
12257 if v_2.Op != OpARM64MOVWUreg {
12258 break
12259 }
12260 x := v_2.Args[0]
12261 mem := v_3
12262 v.reset(OpARM64MOVHstoreidx2)
12263 v.AddArg4(ptr, idx, x, mem)
12264 return true
12265 }
12266 return false
12267 }
12268 func rewriteValueARM64_OpARM64MOVWUload(v *Value) bool {
12269 v_1 := v.Args[1]
12270 v_0 := v.Args[0]
12271 b := v.Block
12272 config := b.Func.Config
12273
12274
12275 for {
12276 off := auxIntToInt32(v.AuxInt)
12277 sym := auxToSym(v.Aux)
12278 ptr := v_0
12279 if v_1.Op != OpARM64FMOVSstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
12280 break
12281 }
12282 val := v_1.Args[1]
12283 if ptr != v_1.Args[0] {
12284 break
12285 }
12286 v.reset(OpARM64FMOVSfpgp)
12287 v.AddArg(val)
12288 return true
12289 }
12290
12291
12292
12293 for {
12294 off1 := auxIntToInt32(v.AuxInt)
12295 sym := auxToSym(v.Aux)
12296 if v_0.Op != OpARM64ADDconst {
12297 break
12298 }
12299 off2 := auxIntToInt64(v_0.AuxInt)
12300 ptr := v_0.Args[0]
12301 mem := v_1
12302 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
12303 break
12304 }
12305 v.reset(OpARM64MOVWUload)
12306 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
12307 v.Aux = symToAux(sym)
12308 v.AddArg2(ptr, mem)
12309 return true
12310 }
12311
12312
12313
12314 for {
12315 off := auxIntToInt32(v.AuxInt)
12316 sym := auxToSym(v.Aux)
12317 if v_0.Op != OpARM64ADD {
12318 break
12319 }
12320 idx := v_0.Args[1]
12321 ptr := v_0.Args[0]
12322 mem := v_1
12323 if !(off == 0 && sym == nil) {
12324 break
12325 }
12326 v.reset(OpARM64MOVWUloadidx)
12327 v.AddArg3(ptr, idx, mem)
12328 return true
12329 }
12330
12331
12332
12333 for {
12334 off := auxIntToInt32(v.AuxInt)
12335 sym := auxToSym(v.Aux)
12336 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 2 {
12337 break
12338 }
12339 idx := v_0.Args[1]
12340 ptr := v_0.Args[0]
12341 mem := v_1
12342 if !(off == 0 && sym == nil) {
12343 break
12344 }
12345 v.reset(OpARM64MOVWUloadidx4)
12346 v.AddArg3(ptr, idx, mem)
12347 return true
12348 }
12349
12350
12351
12352 for {
12353 off1 := auxIntToInt32(v.AuxInt)
12354 sym1 := auxToSym(v.Aux)
12355 if v_0.Op != OpARM64MOVDaddr {
12356 break
12357 }
12358 off2 := auxIntToInt32(v_0.AuxInt)
12359 sym2 := auxToSym(v_0.Aux)
12360 ptr := v_0.Args[0]
12361 mem := v_1
12362 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
12363 break
12364 }
12365 v.reset(OpARM64MOVWUload)
12366 v.AuxInt = int32ToAuxInt(off1 + off2)
12367 v.Aux = symToAux(mergeSym(sym1, sym2))
12368 v.AddArg2(ptr, mem)
12369 return true
12370 }
12371
12372
12373
12374 for {
12375 off := auxIntToInt32(v.AuxInt)
12376 sym := auxToSym(v.Aux)
12377 if v_0.Op != OpSB || !(symIsRO(sym)) {
12378 break
12379 }
12380 v.reset(OpARM64MOVDconst)
12381 v.AuxInt = int64ToAuxInt(int64(read32(sym, int64(off), config.ctxt.Arch.ByteOrder)))
12382 return true
12383 }
12384 return false
12385 }
12386 func rewriteValueARM64_OpARM64MOVWUloadidx(v *Value) bool {
12387 v_2 := v.Args[2]
12388 v_1 := v.Args[1]
12389 v_0 := v.Args[0]
12390
12391
12392
12393 for {
12394 ptr := v_0
12395 if v_1.Op != OpARM64MOVDconst {
12396 break
12397 }
12398 c := auxIntToInt64(v_1.AuxInt)
12399 mem := v_2
12400 if !(is32Bit(c)) {
12401 break
12402 }
12403 v.reset(OpARM64MOVWUload)
12404 v.AuxInt = int32ToAuxInt(int32(c))
12405 v.AddArg2(ptr, mem)
12406 return true
12407 }
12408
12409
12410
12411 for {
12412 if v_0.Op != OpARM64MOVDconst {
12413 break
12414 }
12415 c := auxIntToInt64(v_0.AuxInt)
12416 ptr := v_1
12417 mem := v_2
12418 if !(is32Bit(c)) {
12419 break
12420 }
12421 v.reset(OpARM64MOVWUload)
12422 v.AuxInt = int32ToAuxInt(int32(c))
12423 v.AddArg2(ptr, mem)
12424 return true
12425 }
12426
12427
12428 for {
12429 ptr := v_0
12430 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 2 {
12431 break
12432 }
12433 idx := v_1.Args[0]
12434 mem := v_2
12435 v.reset(OpARM64MOVWUloadidx4)
12436 v.AddArg3(ptr, idx, mem)
12437 return true
12438 }
12439
12440
12441 for {
12442 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 2 {
12443 break
12444 }
12445 idx := v_0.Args[0]
12446 ptr := v_1
12447 mem := v_2
12448 v.reset(OpARM64MOVWUloadidx4)
12449 v.AddArg3(ptr, idx, mem)
12450 return true
12451 }
12452 return false
12453 }
12454 func rewriteValueARM64_OpARM64MOVWUloadidx4(v *Value) bool {
12455 v_2 := v.Args[2]
12456 v_1 := v.Args[1]
12457 v_0 := v.Args[0]
12458
12459
12460
12461 for {
12462 ptr := v_0
12463 if v_1.Op != OpARM64MOVDconst {
12464 break
12465 }
12466 c := auxIntToInt64(v_1.AuxInt)
12467 mem := v_2
12468 if !(is32Bit(c << 2)) {
12469 break
12470 }
12471 v.reset(OpARM64MOVWUload)
12472 v.AuxInt = int32ToAuxInt(int32(c) << 2)
12473 v.AddArg2(ptr, mem)
12474 return true
12475 }
12476 return false
12477 }
12478 func rewriteValueARM64_OpARM64MOVWUreg(v *Value) bool {
12479 v_0 := v.Args[0]
12480
12481
12482 for {
12483 if v_0.Op != OpARM64ANDconst {
12484 break
12485 }
12486 c := auxIntToInt64(v_0.AuxInt)
12487 x := v_0.Args[0]
12488 v.reset(OpARM64ANDconst)
12489 v.AuxInt = int64ToAuxInt(c & (1<<32 - 1))
12490 v.AddArg(x)
12491 return true
12492 }
12493
12494
12495 for {
12496 if v_0.Op != OpARM64MOVDconst {
12497 break
12498 }
12499 c := auxIntToInt64(v_0.AuxInt)
12500 v.reset(OpARM64MOVDconst)
12501 v.AuxInt = int64ToAuxInt(int64(uint32(c)))
12502 return true
12503 }
12504
12505
12506
12507 for {
12508 x := v_0
12509 if !(v.Type.Size() <= 4) {
12510 break
12511 }
12512 v.copyOf(x)
12513 return true
12514 }
12515
12516
12517
12518 for {
12519 if v_0.Op != OpARM64SLLconst {
12520 break
12521 }
12522 lc := auxIntToInt64(v_0.AuxInt)
12523 if !(lc >= 32) {
12524 break
12525 }
12526 v.reset(OpARM64MOVDconst)
12527 v.AuxInt = int64ToAuxInt(0)
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 x := v_0.Args[0]
12539 if !(lc < 32) {
12540 break
12541 }
12542 v.reset(OpARM64UBFIZ)
12543 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, 32-lc))
12544 v.AddArg(x)
12545 return true
12546 }
12547
12548
12549
12550 for {
12551 if v_0.Op != OpARM64SRLconst {
12552 break
12553 }
12554 rc := auxIntToInt64(v_0.AuxInt)
12555 x := v_0.Args[0]
12556 if !(rc < 32) {
12557 break
12558 }
12559 v.reset(OpARM64UBFX)
12560 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 32))
12561 v.AddArg(x)
12562 return true
12563 }
12564
12565
12566
12567 for {
12568 if v_0.Op != OpARM64UBFX {
12569 break
12570 }
12571 bfc := auxIntToArm64BitField(v_0.AuxInt)
12572 x := v_0.Args[0]
12573 if !(bfc.width() <= 32) {
12574 break
12575 }
12576 v.reset(OpARM64UBFX)
12577 v.AuxInt = arm64BitFieldToAuxInt(bfc)
12578 v.AddArg(x)
12579 return true
12580 }
12581 return false
12582 }
12583 func rewriteValueARM64_OpARM64MOVWload(v *Value) bool {
12584 v_1 := v.Args[1]
12585 v_0 := v.Args[0]
12586 b := v.Block
12587 config := b.Func.Config
12588
12589
12590
12591 for {
12592 off1 := auxIntToInt32(v.AuxInt)
12593 sym := auxToSym(v.Aux)
12594 if v_0.Op != OpARM64ADDconst {
12595 break
12596 }
12597 off2 := auxIntToInt64(v_0.AuxInt)
12598 ptr := v_0.Args[0]
12599 mem := v_1
12600 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
12601 break
12602 }
12603 v.reset(OpARM64MOVWload)
12604 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
12605 v.Aux = symToAux(sym)
12606 v.AddArg2(ptr, mem)
12607 return true
12608 }
12609
12610
12611
12612 for {
12613 off := auxIntToInt32(v.AuxInt)
12614 sym := auxToSym(v.Aux)
12615 if v_0.Op != OpARM64ADD {
12616 break
12617 }
12618 idx := v_0.Args[1]
12619 ptr := v_0.Args[0]
12620 mem := v_1
12621 if !(off == 0 && sym == nil) {
12622 break
12623 }
12624 v.reset(OpARM64MOVWloadidx)
12625 v.AddArg3(ptr, idx, mem)
12626 return true
12627 }
12628
12629
12630
12631 for {
12632 off := auxIntToInt32(v.AuxInt)
12633 sym := auxToSym(v.Aux)
12634 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 2 {
12635 break
12636 }
12637 idx := v_0.Args[1]
12638 ptr := v_0.Args[0]
12639 mem := v_1
12640 if !(off == 0 && sym == nil) {
12641 break
12642 }
12643 v.reset(OpARM64MOVWloadidx4)
12644 v.AddArg3(ptr, idx, mem)
12645 return true
12646 }
12647
12648
12649
12650 for {
12651 off1 := auxIntToInt32(v.AuxInt)
12652 sym1 := auxToSym(v.Aux)
12653 if v_0.Op != OpARM64MOVDaddr {
12654 break
12655 }
12656 off2 := auxIntToInt32(v_0.AuxInt)
12657 sym2 := auxToSym(v_0.Aux)
12658 ptr := v_0.Args[0]
12659 mem := v_1
12660 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
12661 break
12662 }
12663 v.reset(OpARM64MOVWload)
12664 v.AuxInt = int32ToAuxInt(off1 + off2)
12665 v.Aux = symToAux(mergeSym(sym1, sym2))
12666 v.AddArg2(ptr, mem)
12667 return true
12668 }
12669
12670
12671
12672 for {
12673 off := auxIntToInt32(v.AuxInt)
12674 sym := auxToSym(v.Aux)
12675 if v_0.Op != OpSB || !(symIsRO(sym)) {
12676 break
12677 }
12678 v.reset(OpARM64MOVDconst)
12679 v.AuxInt = int64ToAuxInt(int64(int32(read32(sym, int64(off), config.ctxt.Arch.ByteOrder))))
12680 return true
12681 }
12682 return false
12683 }
12684 func rewriteValueARM64_OpARM64MOVWloadidx(v *Value) bool {
12685 v_2 := v.Args[2]
12686 v_1 := v.Args[1]
12687 v_0 := v.Args[0]
12688
12689
12690
12691 for {
12692 ptr := v_0
12693 if v_1.Op != OpARM64MOVDconst {
12694 break
12695 }
12696 c := auxIntToInt64(v_1.AuxInt)
12697 mem := v_2
12698 if !(is32Bit(c)) {
12699 break
12700 }
12701 v.reset(OpARM64MOVWload)
12702 v.AuxInt = int32ToAuxInt(int32(c))
12703 v.AddArg2(ptr, mem)
12704 return true
12705 }
12706
12707
12708
12709 for {
12710 if v_0.Op != OpARM64MOVDconst {
12711 break
12712 }
12713 c := auxIntToInt64(v_0.AuxInt)
12714 ptr := v_1
12715 mem := v_2
12716 if !(is32Bit(c)) {
12717 break
12718 }
12719 v.reset(OpARM64MOVWload)
12720 v.AuxInt = int32ToAuxInt(int32(c))
12721 v.AddArg2(ptr, mem)
12722 return true
12723 }
12724
12725
12726 for {
12727 ptr := v_0
12728 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 2 {
12729 break
12730 }
12731 idx := v_1.Args[0]
12732 mem := v_2
12733 v.reset(OpARM64MOVWloadidx4)
12734 v.AddArg3(ptr, idx, mem)
12735 return true
12736 }
12737
12738
12739 for {
12740 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 2 {
12741 break
12742 }
12743 idx := v_0.Args[0]
12744 ptr := v_1
12745 mem := v_2
12746 v.reset(OpARM64MOVWloadidx4)
12747 v.AddArg3(ptr, idx, mem)
12748 return true
12749 }
12750 return false
12751 }
12752 func rewriteValueARM64_OpARM64MOVWloadidx4(v *Value) bool {
12753 v_2 := v.Args[2]
12754 v_1 := v.Args[1]
12755 v_0 := v.Args[0]
12756
12757
12758
12759 for {
12760 ptr := v_0
12761 if v_1.Op != OpARM64MOVDconst {
12762 break
12763 }
12764 c := auxIntToInt64(v_1.AuxInt)
12765 mem := v_2
12766 if !(is32Bit(c << 2)) {
12767 break
12768 }
12769 v.reset(OpARM64MOVWload)
12770 v.AuxInt = int32ToAuxInt(int32(c) << 2)
12771 v.AddArg2(ptr, mem)
12772 return true
12773 }
12774 return false
12775 }
12776 func rewriteValueARM64_OpARM64MOVWreg(v *Value) bool {
12777 v_0 := v.Args[0]
12778
12779
12780 for {
12781 if v_0.Op != OpARM64MOVDconst {
12782 break
12783 }
12784 c := auxIntToInt64(v_0.AuxInt)
12785 v.reset(OpARM64MOVDconst)
12786 v.AuxInt = int64ToAuxInt(int64(int32(c)))
12787 return true
12788 }
12789
12790
12791
12792 for {
12793 x := v_0
12794 if !(v.Type.Size() <= 4) {
12795 break
12796 }
12797 v.copyOf(x)
12798 return true
12799 }
12800
12801
12802
12803 for {
12804 t := v.Type
12805 if v_0.Op != OpARM64ANDconst {
12806 break
12807 }
12808 c := auxIntToInt64(v_0.AuxInt)
12809 x := v_0.Args[0]
12810 if !(uint64(c)&uint64(0xffffffff80000000) == 0) {
12811 break
12812 }
12813 v.reset(OpARM64ANDconst)
12814 v.Type = t
12815 v.AuxInt = int64ToAuxInt(c)
12816 v.AddArg(x)
12817 return true
12818 }
12819
12820
12821
12822 for {
12823 if v_0.Op != OpARM64SLLconst {
12824 break
12825 }
12826 lc := auxIntToInt64(v_0.AuxInt)
12827 x := v_0.Args[0]
12828 if !(lc < 32) {
12829 break
12830 }
12831 v.reset(OpARM64SBFIZ)
12832 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, 32-lc))
12833 v.AddArg(x)
12834 return true
12835 }
12836
12837
12838
12839 for {
12840 if v_0.Op != OpARM64SBFX {
12841 break
12842 }
12843 bfc := auxIntToArm64BitField(v_0.AuxInt)
12844 x := v_0.Args[0]
12845 if !(bfc.width() <= 32) {
12846 break
12847 }
12848 v.reset(OpARM64SBFX)
12849 v.AuxInt = arm64BitFieldToAuxInt(bfc)
12850 v.AddArg(x)
12851 return true
12852 }
12853 return false
12854 }
12855 func rewriteValueARM64_OpARM64MOVWstore(v *Value) bool {
12856 v_2 := v.Args[2]
12857 v_1 := v.Args[1]
12858 v_0 := v.Args[0]
12859 b := v.Block
12860 config := b.Func.Config
12861
12862
12863 for {
12864 off := auxIntToInt32(v.AuxInt)
12865 sym := auxToSym(v.Aux)
12866 ptr := v_0
12867 if v_1.Op != OpARM64FMOVSfpgp {
12868 break
12869 }
12870 val := v_1.Args[0]
12871 mem := v_2
12872 v.reset(OpARM64FMOVSstore)
12873 v.AuxInt = int32ToAuxInt(off)
12874 v.Aux = symToAux(sym)
12875 v.AddArg3(ptr, val, mem)
12876 return true
12877 }
12878
12879
12880
12881 for {
12882 off1 := auxIntToInt32(v.AuxInt)
12883 sym := auxToSym(v.Aux)
12884 if v_0.Op != OpARM64ADDconst {
12885 break
12886 }
12887 off2 := auxIntToInt64(v_0.AuxInt)
12888 ptr := v_0.Args[0]
12889 val := v_1
12890 mem := v_2
12891 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
12892 break
12893 }
12894 v.reset(OpARM64MOVWstore)
12895 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
12896 v.Aux = symToAux(sym)
12897 v.AddArg3(ptr, val, mem)
12898 return true
12899 }
12900
12901
12902
12903 for {
12904 off := auxIntToInt32(v.AuxInt)
12905 sym := auxToSym(v.Aux)
12906 if v_0.Op != OpARM64ADD {
12907 break
12908 }
12909 idx := v_0.Args[1]
12910 ptr := v_0.Args[0]
12911 val := v_1
12912 mem := v_2
12913 if !(off == 0 && sym == nil) {
12914 break
12915 }
12916 v.reset(OpARM64MOVWstoreidx)
12917 v.AddArg4(ptr, idx, val, mem)
12918 return true
12919 }
12920
12921
12922
12923 for {
12924 off := auxIntToInt32(v.AuxInt)
12925 sym := auxToSym(v.Aux)
12926 if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 2 {
12927 break
12928 }
12929 idx := v_0.Args[1]
12930 ptr := v_0.Args[0]
12931 val := v_1
12932 mem := v_2
12933 if !(off == 0 && sym == nil) {
12934 break
12935 }
12936 v.reset(OpARM64MOVWstoreidx4)
12937 v.AddArg4(ptr, idx, val, mem)
12938 return true
12939 }
12940
12941
12942
12943 for {
12944 off1 := auxIntToInt32(v.AuxInt)
12945 sym1 := auxToSym(v.Aux)
12946 if v_0.Op != OpARM64MOVDaddr {
12947 break
12948 }
12949 off2 := auxIntToInt32(v_0.AuxInt)
12950 sym2 := auxToSym(v_0.Aux)
12951 ptr := v_0.Args[0]
12952 val := v_1
12953 mem := v_2
12954 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
12955 break
12956 }
12957 v.reset(OpARM64MOVWstore)
12958 v.AuxInt = int32ToAuxInt(off1 + off2)
12959 v.Aux = symToAux(mergeSym(sym1, sym2))
12960 v.AddArg3(ptr, val, mem)
12961 return true
12962 }
12963
12964
12965 for {
12966 off := auxIntToInt32(v.AuxInt)
12967 sym := auxToSym(v.Aux)
12968 ptr := v_0
12969 if v_1.Op != OpARM64MOVWreg {
12970 break
12971 }
12972 x := v_1.Args[0]
12973 mem := v_2
12974 v.reset(OpARM64MOVWstore)
12975 v.AuxInt = int32ToAuxInt(off)
12976 v.Aux = symToAux(sym)
12977 v.AddArg3(ptr, x, mem)
12978 return true
12979 }
12980
12981
12982 for {
12983 off := auxIntToInt32(v.AuxInt)
12984 sym := auxToSym(v.Aux)
12985 ptr := v_0
12986 if v_1.Op != OpARM64MOVWUreg {
12987 break
12988 }
12989 x := v_1.Args[0]
12990 mem := v_2
12991 v.reset(OpARM64MOVWstore)
12992 v.AuxInt = int32ToAuxInt(off)
12993 v.Aux = symToAux(sym)
12994 v.AddArg3(ptr, x, mem)
12995 return true
12996 }
12997 return false
12998 }
12999 func rewriteValueARM64_OpARM64MOVWstoreidx(v *Value) bool {
13000 v_3 := v.Args[3]
13001 v_2 := v.Args[2]
13002 v_1 := v.Args[1]
13003 v_0 := v.Args[0]
13004
13005
13006
13007 for {
13008 ptr := v_0
13009 if v_1.Op != OpARM64MOVDconst {
13010 break
13011 }
13012 c := auxIntToInt64(v_1.AuxInt)
13013 val := v_2
13014 mem := v_3
13015 if !(is32Bit(c)) {
13016 break
13017 }
13018 v.reset(OpARM64MOVWstore)
13019 v.AuxInt = int32ToAuxInt(int32(c))
13020 v.AddArg3(ptr, val, mem)
13021 return true
13022 }
13023
13024
13025
13026 for {
13027 if v_0.Op != OpARM64MOVDconst {
13028 break
13029 }
13030 c := auxIntToInt64(v_0.AuxInt)
13031 idx := v_1
13032 val := v_2
13033 mem := v_3
13034 if !(is32Bit(c)) {
13035 break
13036 }
13037 v.reset(OpARM64MOVWstore)
13038 v.AuxInt = int32ToAuxInt(int32(c))
13039 v.AddArg3(idx, val, mem)
13040 return true
13041 }
13042
13043
13044 for {
13045 ptr := v_0
13046 if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 2 {
13047 break
13048 }
13049 idx := v_1.Args[0]
13050 val := v_2
13051 mem := v_3
13052 v.reset(OpARM64MOVWstoreidx4)
13053 v.AddArg4(ptr, idx, val, mem)
13054 return true
13055 }
13056
13057
13058 for {
13059 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 2 {
13060 break
13061 }
13062 idx := v_0.Args[0]
13063 ptr := v_1
13064 val := v_2
13065 mem := v_3
13066 v.reset(OpARM64MOVWstoreidx4)
13067 v.AddArg4(ptr, idx, val, mem)
13068 return true
13069 }
13070
13071
13072 for {
13073 ptr := v_0
13074 idx := v_1
13075 if v_2.Op != OpARM64MOVWreg {
13076 break
13077 }
13078 x := v_2.Args[0]
13079 mem := v_3
13080 v.reset(OpARM64MOVWstoreidx)
13081 v.AddArg4(ptr, idx, x, mem)
13082 return true
13083 }
13084
13085
13086 for {
13087 ptr := v_0
13088 idx := v_1
13089 if v_2.Op != OpARM64MOVWUreg {
13090 break
13091 }
13092 x := v_2.Args[0]
13093 mem := v_3
13094 v.reset(OpARM64MOVWstoreidx)
13095 v.AddArg4(ptr, idx, x, mem)
13096 return true
13097 }
13098 return false
13099 }
13100 func rewriteValueARM64_OpARM64MOVWstoreidx4(v *Value) bool {
13101 v_3 := v.Args[3]
13102 v_2 := v.Args[2]
13103 v_1 := v.Args[1]
13104 v_0 := v.Args[0]
13105
13106
13107
13108 for {
13109 ptr := v_0
13110 if v_1.Op != OpARM64MOVDconst {
13111 break
13112 }
13113 c := auxIntToInt64(v_1.AuxInt)
13114 val := v_2
13115 mem := v_3
13116 if !(is32Bit(c << 2)) {
13117 break
13118 }
13119 v.reset(OpARM64MOVWstore)
13120 v.AuxInt = int32ToAuxInt(int32(c) << 2)
13121 v.AddArg3(ptr, val, mem)
13122 return true
13123 }
13124
13125
13126 for {
13127 ptr := v_0
13128 idx := v_1
13129 if v_2.Op != OpARM64MOVWreg {
13130 break
13131 }
13132 x := v_2.Args[0]
13133 mem := v_3
13134 v.reset(OpARM64MOVWstoreidx4)
13135 v.AddArg4(ptr, idx, x, mem)
13136 return true
13137 }
13138
13139
13140 for {
13141 ptr := v_0
13142 idx := v_1
13143 if v_2.Op != OpARM64MOVWUreg {
13144 break
13145 }
13146 x := v_2.Args[0]
13147 mem := v_3
13148 v.reset(OpARM64MOVWstoreidx4)
13149 v.AddArg4(ptr, idx, x, mem)
13150 return true
13151 }
13152 return false
13153 }
13154 func rewriteValueARM64_OpARM64MSUB(v *Value) bool {
13155 v_2 := v.Args[2]
13156 v_1 := v.Args[1]
13157 v_0 := v.Args[0]
13158 b := v.Block
13159
13160
13161 for {
13162 a := v_0
13163 x := v_1
13164 if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != -1 {
13165 break
13166 }
13167 v.reset(OpARM64ADD)
13168 v.AddArg2(a, x)
13169 return true
13170 }
13171
13172
13173 for {
13174 a := v_0
13175 if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != 0 {
13176 break
13177 }
13178 v.copyOf(a)
13179 return true
13180 }
13181
13182
13183 for {
13184 a := v_0
13185 x := v_1
13186 if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != 1 {
13187 break
13188 }
13189 v.reset(OpARM64SUB)
13190 v.AddArg2(a, x)
13191 return true
13192 }
13193
13194
13195
13196 for {
13197 a := v_0
13198 x := v_1
13199 if v_2.Op != OpARM64MOVDconst {
13200 break
13201 }
13202 c := auxIntToInt64(v_2.AuxInt)
13203 if !(isPowerOfTwo(c)) {
13204 break
13205 }
13206 v.reset(OpARM64SUBshiftLL)
13207 v.AuxInt = int64ToAuxInt(log64(c))
13208 v.AddArg2(a, x)
13209 return true
13210 }
13211
13212
13213
13214 for {
13215 a := v_0
13216 x := v_1
13217 if v_2.Op != OpARM64MOVDconst {
13218 break
13219 }
13220 c := auxIntToInt64(v_2.AuxInt)
13221 if !(isPowerOfTwo(c-1) && c >= 3) {
13222 break
13223 }
13224 v.reset(OpARM64SUB)
13225 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13226 v0.AuxInt = int64ToAuxInt(log64(c - 1))
13227 v0.AddArg2(x, x)
13228 v.AddArg2(a, v0)
13229 return true
13230 }
13231
13232
13233
13234 for {
13235 a := v_0
13236 x := v_1
13237 if v_2.Op != OpARM64MOVDconst {
13238 break
13239 }
13240 c := auxIntToInt64(v_2.AuxInt)
13241 if !(isPowerOfTwo(c+1) && c >= 7) {
13242 break
13243 }
13244 v.reset(OpARM64ADD)
13245 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13246 v0.AuxInt = int64ToAuxInt(log64(c + 1))
13247 v0.AddArg2(x, x)
13248 v.AddArg2(a, v0)
13249 return true
13250 }
13251
13252
13253
13254 for {
13255 a := v_0
13256 x := v_1
13257 if v_2.Op != OpARM64MOVDconst {
13258 break
13259 }
13260 c := auxIntToInt64(v_2.AuxInt)
13261 if !(c%3 == 0 && isPowerOfTwo(c/3)) {
13262 break
13263 }
13264 v.reset(OpARM64ADDshiftLL)
13265 v.AuxInt = int64ToAuxInt(log64(c / 3))
13266 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13267 v0.AuxInt = int64ToAuxInt(2)
13268 v0.AddArg2(x, x)
13269 v.AddArg2(a, v0)
13270 return true
13271 }
13272
13273
13274
13275 for {
13276 a := v_0
13277 x := v_1
13278 if v_2.Op != OpARM64MOVDconst {
13279 break
13280 }
13281 c := auxIntToInt64(v_2.AuxInt)
13282 if !(c%5 == 0 && isPowerOfTwo(c/5)) {
13283 break
13284 }
13285 v.reset(OpARM64SUBshiftLL)
13286 v.AuxInt = int64ToAuxInt(log64(c / 5))
13287 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13288 v0.AuxInt = int64ToAuxInt(2)
13289 v0.AddArg2(x, x)
13290 v.AddArg2(a, v0)
13291 return true
13292 }
13293
13294
13295
13296 for {
13297 a := v_0
13298 x := v_1
13299 if v_2.Op != OpARM64MOVDconst {
13300 break
13301 }
13302 c := auxIntToInt64(v_2.AuxInt)
13303 if !(c%7 == 0 && isPowerOfTwo(c/7)) {
13304 break
13305 }
13306 v.reset(OpARM64ADDshiftLL)
13307 v.AuxInt = int64ToAuxInt(log64(c / 7))
13308 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13309 v0.AuxInt = int64ToAuxInt(3)
13310 v0.AddArg2(x, x)
13311 v.AddArg2(a, v0)
13312 return true
13313 }
13314
13315
13316
13317 for {
13318 a := v_0
13319 x := v_1
13320 if v_2.Op != OpARM64MOVDconst {
13321 break
13322 }
13323 c := auxIntToInt64(v_2.AuxInt)
13324 if !(c%9 == 0 && isPowerOfTwo(c/9)) {
13325 break
13326 }
13327 v.reset(OpARM64SUBshiftLL)
13328 v.AuxInt = int64ToAuxInt(log64(c / 9))
13329 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13330 v0.AuxInt = int64ToAuxInt(3)
13331 v0.AddArg2(x, x)
13332 v.AddArg2(a, v0)
13333 return true
13334 }
13335
13336
13337 for {
13338 a := v_0
13339 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != -1 {
13340 break
13341 }
13342 x := v_2
13343 v.reset(OpARM64ADD)
13344 v.AddArg2(a, x)
13345 return true
13346 }
13347
13348
13349 for {
13350 a := v_0
13351 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
13352 break
13353 }
13354 v.copyOf(a)
13355 return true
13356 }
13357
13358
13359 for {
13360 a := v_0
13361 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
13362 break
13363 }
13364 x := v_2
13365 v.reset(OpARM64SUB)
13366 v.AddArg2(a, x)
13367 return true
13368 }
13369
13370
13371
13372 for {
13373 a := v_0
13374 if v_1.Op != OpARM64MOVDconst {
13375 break
13376 }
13377 c := auxIntToInt64(v_1.AuxInt)
13378 x := v_2
13379 if !(isPowerOfTwo(c)) {
13380 break
13381 }
13382 v.reset(OpARM64SUBshiftLL)
13383 v.AuxInt = int64ToAuxInt(log64(c))
13384 v.AddArg2(a, x)
13385 return true
13386 }
13387
13388
13389
13390 for {
13391 a := v_0
13392 if v_1.Op != OpARM64MOVDconst {
13393 break
13394 }
13395 c := auxIntToInt64(v_1.AuxInt)
13396 x := v_2
13397 if !(isPowerOfTwo(c-1) && c >= 3) {
13398 break
13399 }
13400 v.reset(OpARM64SUB)
13401 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13402 v0.AuxInt = int64ToAuxInt(log64(c - 1))
13403 v0.AddArg2(x, x)
13404 v.AddArg2(a, v0)
13405 return true
13406 }
13407
13408
13409
13410 for {
13411 a := v_0
13412 if v_1.Op != OpARM64MOVDconst {
13413 break
13414 }
13415 c := auxIntToInt64(v_1.AuxInt)
13416 x := v_2
13417 if !(isPowerOfTwo(c+1) && c >= 7) {
13418 break
13419 }
13420 v.reset(OpARM64ADD)
13421 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13422 v0.AuxInt = int64ToAuxInt(log64(c + 1))
13423 v0.AddArg2(x, x)
13424 v.AddArg2(a, v0)
13425 return true
13426 }
13427
13428
13429
13430 for {
13431 a := v_0
13432 if v_1.Op != OpARM64MOVDconst {
13433 break
13434 }
13435 c := auxIntToInt64(v_1.AuxInt)
13436 x := v_2
13437 if !(c%3 == 0 && isPowerOfTwo(c/3)) {
13438 break
13439 }
13440 v.reset(OpARM64ADDshiftLL)
13441 v.AuxInt = int64ToAuxInt(log64(c / 3))
13442 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13443 v0.AuxInt = int64ToAuxInt(2)
13444 v0.AddArg2(x, x)
13445 v.AddArg2(a, v0)
13446 return true
13447 }
13448
13449
13450
13451 for {
13452 a := v_0
13453 if v_1.Op != OpARM64MOVDconst {
13454 break
13455 }
13456 c := auxIntToInt64(v_1.AuxInt)
13457 x := v_2
13458 if !(c%5 == 0 && isPowerOfTwo(c/5)) {
13459 break
13460 }
13461 v.reset(OpARM64SUBshiftLL)
13462 v.AuxInt = int64ToAuxInt(log64(c / 5))
13463 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13464 v0.AuxInt = int64ToAuxInt(2)
13465 v0.AddArg2(x, x)
13466 v.AddArg2(a, v0)
13467 return true
13468 }
13469
13470
13471
13472 for {
13473 a := v_0
13474 if v_1.Op != OpARM64MOVDconst {
13475 break
13476 }
13477 c := auxIntToInt64(v_1.AuxInt)
13478 x := v_2
13479 if !(c%7 == 0 && isPowerOfTwo(c/7)) {
13480 break
13481 }
13482 v.reset(OpARM64ADDshiftLL)
13483 v.AuxInt = int64ToAuxInt(log64(c / 7))
13484 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13485 v0.AuxInt = int64ToAuxInt(3)
13486 v0.AddArg2(x, x)
13487 v.AddArg2(a, v0)
13488 return true
13489 }
13490
13491
13492
13493 for {
13494 a := v_0
13495 if v_1.Op != OpARM64MOVDconst {
13496 break
13497 }
13498 c := auxIntToInt64(v_1.AuxInt)
13499 x := v_2
13500 if !(c%9 == 0 && isPowerOfTwo(c/9)) {
13501 break
13502 }
13503 v.reset(OpARM64SUBshiftLL)
13504 v.AuxInt = int64ToAuxInt(log64(c / 9))
13505 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13506 v0.AuxInt = int64ToAuxInt(3)
13507 v0.AddArg2(x, x)
13508 v.AddArg2(a, v0)
13509 return true
13510 }
13511
13512
13513 for {
13514 if v_0.Op != OpARM64MOVDconst {
13515 break
13516 }
13517 c := auxIntToInt64(v_0.AuxInt)
13518 x := v_1
13519 y := v_2
13520 v.reset(OpARM64ADDconst)
13521 v.AuxInt = int64ToAuxInt(c)
13522 v0 := b.NewValue0(v.Pos, OpARM64MNEG, x.Type)
13523 v0.AddArg2(x, y)
13524 v.AddArg(v0)
13525 return true
13526 }
13527
13528
13529 for {
13530 a := v_0
13531 if v_1.Op != OpARM64MOVDconst {
13532 break
13533 }
13534 c := auxIntToInt64(v_1.AuxInt)
13535 if v_2.Op != OpARM64MOVDconst {
13536 break
13537 }
13538 d := auxIntToInt64(v_2.AuxInt)
13539 v.reset(OpARM64SUBconst)
13540 v.AuxInt = int64ToAuxInt(c * d)
13541 v.AddArg(a)
13542 return true
13543 }
13544 return false
13545 }
13546 func rewriteValueARM64_OpARM64MSUBW(v *Value) bool {
13547 v_2 := v.Args[2]
13548 v_1 := v.Args[1]
13549 v_0 := v.Args[0]
13550 b := v.Block
13551
13552
13553
13554 for {
13555 a := v_0
13556 x := v_1
13557 if v_2.Op != OpARM64MOVDconst {
13558 break
13559 }
13560 c := auxIntToInt64(v_2.AuxInt)
13561 if !(int32(c) == -1) {
13562 break
13563 }
13564 v.reset(OpARM64MOVWUreg)
13565 v0 := b.NewValue0(v.Pos, OpARM64ADD, a.Type)
13566 v0.AddArg2(a, x)
13567 v.AddArg(v0)
13568 return true
13569 }
13570
13571
13572
13573 for {
13574 a := v_0
13575 if v_2.Op != OpARM64MOVDconst {
13576 break
13577 }
13578 c := auxIntToInt64(v_2.AuxInt)
13579 if !(int32(c) == 0) {
13580 break
13581 }
13582 v.reset(OpARM64MOVWUreg)
13583 v.AddArg(a)
13584 return true
13585 }
13586
13587
13588
13589 for {
13590 a := v_0
13591 x := v_1
13592 if v_2.Op != OpARM64MOVDconst {
13593 break
13594 }
13595 c := auxIntToInt64(v_2.AuxInt)
13596 if !(int32(c) == 1) {
13597 break
13598 }
13599 v.reset(OpARM64MOVWUreg)
13600 v0 := b.NewValue0(v.Pos, OpARM64SUB, a.Type)
13601 v0.AddArg2(a, x)
13602 v.AddArg(v0)
13603 return true
13604 }
13605
13606
13607
13608 for {
13609 a := v_0
13610 x := v_1
13611 if v_2.Op != OpARM64MOVDconst {
13612 break
13613 }
13614 c := auxIntToInt64(v_2.AuxInt)
13615 if !(isPowerOfTwo(c)) {
13616 break
13617 }
13618 v.reset(OpARM64MOVWUreg)
13619 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
13620 v0.AuxInt = int64ToAuxInt(log64(c))
13621 v0.AddArg2(a, x)
13622 v.AddArg(v0)
13623 return true
13624 }
13625
13626
13627
13628 for {
13629 a := v_0
13630 x := v_1
13631 if v_2.Op != OpARM64MOVDconst {
13632 break
13633 }
13634 c := auxIntToInt64(v_2.AuxInt)
13635 if !(isPowerOfTwo(c-1) && int32(c) >= 3) {
13636 break
13637 }
13638 v.reset(OpARM64MOVWUreg)
13639 v0 := b.NewValue0(v.Pos, OpARM64SUB, a.Type)
13640 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13641 v1.AuxInt = int64ToAuxInt(log64(c - 1))
13642 v1.AddArg2(x, x)
13643 v0.AddArg2(a, v1)
13644 v.AddArg(v0)
13645 return true
13646 }
13647
13648
13649
13650 for {
13651 a := v_0
13652 x := v_1
13653 if v_2.Op != OpARM64MOVDconst {
13654 break
13655 }
13656 c := auxIntToInt64(v_2.AuxInt)
13657 if !(isPowerOfTwo(c+1) && int32(c) >= 7) {
13658 break
13659 }
13660 v.reset(OpARM64MOVWUreg)
13661 v0 := b.NewValue0(v.Pos, OpARM64ADD, a.Type)
13662 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13663 v1.AuxInt = int64ToAuxInt(log64(c + 1))
13664 v1.AddArg2(x, x)
13665 v0.AddArg2(a, v1)
13666 v.AddArg(v0)
13667 return true
13668 }
13669
13670
13671
13672 for {
13673 a := v_0
13674 x := v_1
13675 if v_2.Op != OpARM64MOVDconst {
13676 break
13677 }
13678 c := auxIntToInt64(v_2.AuxInt)
13679 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) {
13680 break
13681 }
13682 v.reset(OpARM64MOVWUreg)
13683 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
13684 v0.AuxInt = int64ToAuxInt(log64(c / 3))
13685 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13686 v1.AuxInt = int64ToAuxInt(2)
13687 v1.AddArg2(x, x)
13688 v0.AddArg2(a, v1)
13689 v.AddArg(v0)
13690 return true
13691 }
13692
13693
13694
13695 for {
13696 a := v_0
13697 x := v_1
13698 if v_2.Op != OpARM64MOVDconst {
13699 break
13700 }
13701 c := auxIntToInt64(v_2.AuxInt)
13702 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) {
13703 break
13704 }
13705 v.reset(OpARM64MOVWUreg)
13706 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
13707 v0.AuxInt = int64ToAuxInt(log64(c / 5))
13708 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13709 v1.AuxInt = int64ToAuxInt(2)
13710 v1.AddArg2(x, x)
13711 v0.AddArg2(a, v1)
13712 v.AddArg(v0)
13713 return true
13714 }
13715
13716
13717
13718 for {
13719 a := v_0
13720 x := v_1
13721 if v_2.Op != OpARM64MOVDconst {
13722 break
13723 }
13724 c := auxIntToInt64(v_2.AuxInt)
13725 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) {
13726 break
13727 }
13728 v.reset(OpARM64MOVWUreg)
13729 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
13730 v0.AuxInt = int64ToAuxInt(log64(c / 7))
13731 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13732 v1.AuxInt = int64ToAuxInt(3)
13733 v1.AddArg2(x, x)
13734 v0.AddArg2(a, v1)
13735 v.AddArg(v0)
13736 return true
13737 }
13738
13739
13740
13741 for {
13742 a := v_0
13743 x := v_1
13744 if v_2.Op != OpARM64MOVDconst {
13745 break
13746 }
13747 c := auxIntToInt64(v_2.AuxInt)
13748 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) {
13749 break
13750 }
13751 v.reset(OpARM64MOVWUreg)
13752 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
13753 v0.AuxInt = int64ToAuxInt(log64(c / 9))
13754 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13755 v1.AuxInt = int64ToAuxInt(3)
13756 v1.AddArg2(x, x)
13757 v0.AddArg2(a, v1)
13758 v.AddArg(v0)
13759 return true
13760 }
13761
13762
13763
13764 for {
13765 a := v_0
13766 if v_1.Op != OpARM64MOVDconst {
13767 break
13768 }
13769 c := auxIntToInt64(v_1.AuxInt)
13770 x := v_2
13771 if !(int32(c) == -1) {
13772 break
13773 }
13774 v.reset(OpARM64MOVWUreg)
13775 v0 := b.NewValue0(v.Pos, OpARM64ADD, a.Type)
13776 v0.AddArg2(a, x)
13777 v.AddArg(v0)
13778 return true
13779 }
13780
13781
13782
13783 for {
13784 a := v_0
13785 if v_1.Op != OpARM64MOVDconst {
13786 break
13787 }
13788 c := auxIntToInt64(v_1.AuxInt)
13789 if !(int32(c) == 0) {
13790 break
13791 }
13792 v.reset(OpARM64MOVWUreg)
13793 v.AddArg(a)
13794 return true
13795 }
13796
13797
13798
13799 for {
13800 a := v_0
13801 if v_1.Op != OpARM64MOVDconst {
13802 break
13803 }
13804 c := auxIntToInt64(v_1.AuxInt)
13805 x := v_2
13806 if !(int32(c) == 1) {
13807 break
13808 }
13809 v.reset(OpARM64MOVWUreg)
13810 v0 := b.NewValue0(v.Pos, OpARM64SUB, a.Type)
13811 v0.AddArg2(a, x)
13812 v.AddArg(v0)
13813 return true
13814 }
13815
13816
13817
13818 for {
13819 a := v_0
13820 if v_1.Op != OpARM64MOVDconst {
13821 break
13822 }
13823 c := auxIntToInt64(v_1.AuxInt)
13824 x := v_2
13825 if !(isPowerOfTwo(c)) {
13826 break
13827 }
13828 v.reset(OpARM64MOVWUreg)
13829 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
13830 v0.AuxInt = int64ToAuxInt(log64(c))
13831 v0.AddArg2(a, x)
13832 v.AddArg(v0)
13833 return true
13834 }
13835
13836
13837
13838 for {
13839 a := v_0
13840 if v_1.Op != OpARM64MOVDconst {
13841 break
13842 }
13843 c := auxIntToInt64(v_1.AuxInt)
13844 x := v_2
13845 if !(isPowerOfTwo(c-1) && int32(c) >= 3) {
13846 break
13847 }
13848 v.reset(OpARM64MOVWUreg)
13849 v0 := b.NewValue0(v.Pos, OpARM64SUB, a.Type)
13850 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13851 v1.AuxInt = int64ToAuxInt(log64(c - 1))
13852 v1.AddArg2(x, x)
13853 v0.AddArg2(a, v1)
13854 v.AddArg(v0)
13855 return true
13856 }
13857
13858
13859
13860 for {
13861 a := v_0
13862 if v_1.Op != OpARM64MOVDconst {
13863 break
13864 }
13865 c := auxIntToInt64(v_1.AuxInt)
13866 x := v_2
13867 if !(isPowerOfTwo(c+1) && int32(c) >= 7) {
13868 break
13869 }
13870 v.reset(OpARM64MOVWUreg)
13871 v0 := b.NewValue0(v.Pos, OpARM64ADD, a.Type)
13872 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13873 v1.AuxInt = int64ToAuxInt(log64(c + 1))
13874 v1.AddArg2(x, x)
13875 v0.AddArg2(a, v1)
13876 v.AddArg(v0)
13877 return true
13878 }
13879
13880
13881
13882 for {
13883 a := v_0
13884 if v_1.Op != OpARM64MOVDconst {
13885 break
13886 }
13887 c := auxIntToInt64(v_1.AuxInt)
13888 x := v_2
13889 if !(c%3 == 0 && isPowerOfTwo(c/3) && is32Bit(c)) {
13890 break
13891 }
13892 v.reset(OpARM64MOVWUreg)
13893 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
13894 v0.AuxInt = int64ToAuxInt(log64(c / 3))
13895 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13896 v1.AuxInt = int64ToAuxInt(2)
13897 v1.AddArg2(x, x)
13898 v0.AddArg2(a, v1)
13899 v.AddArg(v0)
13900 return true
13901 }
13902
13903
13904
13905 for {
13906 a := v_0
13907 if v_1.Op != OpARM64MOVDconst {
13908 break
13909 }
13910 c := auxIntToInt64(v_1.AuxInt)
13911 x := v_2
13912 if !(c%5 == 0 && isPowerOfTwo(c/5) && is32Bit(c)) {
13913 break
13914 }
13915 v.reset(OpARM64MOVWUreg)
13916 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
13917 v0.AuxInt = int64ToAuxInt(log64(c / 5))
13918 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13919 v1.AuxInt = int64ToAuxInt(2)
13920 v1.AddArg2(x, x)
13921 v0.AddArg2(a, v1)
13922 v.AddArg(v0)
13923 return true
13924 }
13925
13926
13927
13928 for {
13929 a := v_0
13930 if v_1.Op != OpARM64MOVDconst {
13931 break
13932 }
13933 c := auxIntToInt64(v_1.AuxInt)
13934 x := v_2
13935 if !(c%7 == 0 && isPowerOfTwo(c/7) && is32Bit(c)) {
13936 break
13937 }
13938 v.reset(OpARM64MOVWUreg)
13939 v0 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, a.Type)
13940 v0.AuxInt = int64ToAuxInt(log64(c / 7))
13941 v1 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, x.Type)
13942 v1.AuxInt = int64ToAuxInt(3)
13943 v1.AddArg2(x, x)
13944 v0.AddArg2(a, v1)
13945 v.AddArg(v0)
13946 return true
13947 }
13948
13949
13950
13951 for {
13952 a := v_0
13953 if v_1.Op != OpARM64MOVDconst {
13954 break
13955 }
13956 c := auxIntToInt64(v_1.AuxInt)
13957 x := v_2
13958 if !(c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)) {
13959 break
13960 }
13961 v.reset(OpARM64MOVWUreg)
13962 v0 := b.NewValue0(v.Pos, OpARM64SUBshiftLL, a.Type)
13963 v0.AuxInt = int64ToAuxInt(log64(c / 9))
13964 v1 := b.NewValue0(v.Pos, OpARM64ADDshiftLL, x.Type)
13965 v1.AuxInt = int64ToAuxInt(3)
13966 v1.AddArg2(x, x)
13967 v0.AddArg2(a, v1)
13968 v.AddArg(v0)
13969 return true
13970 }
13971
13972
13973 for {
13974 if v_0.Op != OpARM64MOVDconst {
13975 break
13976 }
13977 c := auxIntToInt64(v_0.AuxInt)
13978 x := v_1
13979 y := v_2
13980 v.reset(OpARM64MOVWUreg)
13981 v0 := b.NewValue0(v.Pos, OpARM64ADDconst, x.Type)
13982 v0.AuxInt = int64ToAuxInt(c)
13983 v1 := b.NewValue0(v.Pos, OpARM64MNEGW, x.Type)
13984 v1.AddArg2(x, y)
13985 v0.AddArg(v1)
13986 v.AddArg(v0)
13987 return true
13988 }
13989
13990
13991 for {
13992 a := v_0
13993 if v_1.Op != OpARM64MOVDconst {
13994 break
13995 }
13996 c := auxIntToInt64(v_1.AuxInt)
13997 if v_2.Op != OpARM64MOVDconst {
13998 break
13999 }
14000 d := auxIntToInt64(v_2.AuxInt)
14001 v.reset(OpARM64MOVWUreg)
14002 v0 := b.NewValue0(v.Pos, OpARM64SUBconst, a.Type)
14003 v0.AuxInt = int64ToAuxInt(c * d)
14004 v0.AddArg(a)
14005 v.AddArg(v0)
14006 return true
14007 }
14008 return false
14009 }
14010 func rewriteValueARM64_OpARM64MUL(v *Value) bool {
14011 v_1 := v.Args[1]
14012 v_0 := v.Args[0]
14013 b := v.Block
14014 config := b.Func.Config
14015
14016
14017 for {
14018 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14019 if v_0.Op != OpARM64NEG {
14020 continue
14021 }
14022 x := v_0.Args[0]
14023 y := v_1
14024 v.reset(OpARM64MNEG)
14025 v.AddArg2(x, y)
14026 return true
14027 }
14028 break
14029 }
14030
14031
14032 for {
14033 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14034 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
14035 continue
14036 }
14037 v.reset(OpARM64MOVDconst)
14038 v.AuxInt = int64ToAuxInt(0)
14039 return true
14040 }
14041 break
14042 }
14043
14044
14045 for {
14046 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14047 x := v_0
14048 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
14049 continue
14050 }
14051 v.copyOf(x)
14052 return true
14053 }
14054 break
14055 }
14056
14057
14058
14059 for {
14060 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14061 x := v_0
14062 if v_1.Op != OpARM64MOVDconst {
14063 continue
14064 }
14065 c := auxIntToInt64(v_1.AuxInt)
14066 if !(canMulStrengthReduce(config, c)) {
14067 continue
14068 }
14069 v.copyOf(mulStrengthReduce(v, x, c))
14070 return true
14071 }
14072 break
14073 }
14074
14075
14076 for {
14077 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14078 if v_0.Op != OpARM64MOVDconst {
14079 continue
14080 }
14081 c := auxIntToInt64(v_0.AuxInt)
14082 if v_1.Op != OpARM64MOVDconst {
14083 continue
14084 }
14085 d := auxIntToInt64(v_1.AuxInt)
14086 v.reset(OpARM64MOVDconst)
14087 v.AuxInt = int64ToAuxInt(c * d)
14088 return true
14089 }
14090 break
14091 }
14092
14093
14094
14095 for {
14096 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14097 r := v_0
14098 if r.Op != OpARM64MOVWUreg {
14099 continue
14100 }
14101 x := r.Args[0]
14102 s := v_1
14103 if s.Op != OpARM64MOVWUreg {
14104 continue
14105 }
14106 y := s.Args[0]
14107 if !(r.Uses == 1 && s.Uses == 1) {
14108 continue
14109 }
14110 v.reset(OpARM64UMULL)
14111 v.AddArg2(x, y)
14112 return true
14113 }
14114 break
14115 }
14116
14117
14118
14119 for {
14120 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14121 r := v_0
14122 if r.Op != OpARM64MOVWreg {
14123 continue
14124 }
14125 x := r.Args[0]
14126 s := v_1
14127 if s.Op != OpARM64MOVWreg {
14128 continue
14129 }
14130 y := s.Args[0]
14131 if !(r.Uses == 1 && s.Uses == 1) {
14132 continue
14133 }
14134 v.reset(OpARM64MULL)
14135 v.AddArg2(x, y)
14136 return true
14137 }
14138 break
14139 }
14140 return false
14141 }
14142 func rewriteValueARM64_OpARM64MULW(v *Value) bool {
14143 v_1 := v.Args[1]
14144 v_0 := v.Args[0]
14145 b := v.Block
14146 config := b.Func.Config
14147
14148
14149 for {
14150 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14151 if v_0.Op != OpARM64NEG {
14152 continue
14153 }
14154 x := v_0.Args[0]
14155 y := v_1
14156 v.reset(OpARM64MNEGW)
14157 v.AddArg2(x, y)
14158 return true
14159 }
14160 break
14161 }
14162
14163
14164
14165 for {
14166 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14167 if v_1.Op != OpARM64MOVDconst {
14168 continue
14169 }
14170 c := auxIntToInt64(v_1.AuxInt)
14171 if !(int32(c) == 0) {
14172 continue
14173 }
14174 v.reset(OpARM64MOVDconst)
14175 v.AuxInt = int64ToAuxInt(0)
14176 return true
14177 }
14178 break
14179 }
14180
14181
14182
14183 for {
14184 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14185 x := v_0
14186 if v_1.Op != OpARM64MOVDconst {
14187 continue
14188 }
14189 c := auxIntToInt64(v_1.AuxInt)
14190 if !(int32(c) == 1) {
14191 continue
14192 }
14193 v.reset(OpARM64MOVWUreg)
14194 v.AddArg(x)
14195 return true
14196 }
14197 break
14198 }
14199
14200
14201
14202 for {
14203 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14204 x := v_0
14205 if v_1.Op != OpARM64MOVDconst {
14206 continue
14207 }
14208 c := auxIntToInt64(v_1.AuxInt)
14209 if !(v.Type.Size() <= 4 && canMulStrengthReduce32(config, int32(c))) {
14210 continue
14211 }
14212 v.copyOf(mulStrengthReduce32(v, x, int32(c)))
14213 return true
14214 }
14215 break
14216 }
14217
14218
14219 for {
14220 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14221 if v_0.Op != OpARM64MOVDconst {
14222 continue
14223 }
14224 c := auxIntToInt64(v_0.AuxInt)
14225 if v_1.Op != OpARM64MOVDconst {
14226 continue
14227 }
14228 d := auxIntToInt64(v_1.AuxInt)
14229 v.reset(OpARM64MOVDconst)
14230 v.AuxInt = int64ToAuxInt(int64(uint32(c * d)))
14231 return true
14232 }
14233 break
14234 }
14235 return false
14236 }
14237 func rewriteValueARM64_OpARM64MVN(v *Value) bool {
14238 v_0 := v.Args[0]
14239
14240
14241 for {
14242 if v_0.Op != OpARM64XOR {
14243 break
14244 }
14245 y := v_0.Args[1]
14246 x := v_0.Args[0]
14247 v.reset(OpARM64EON)
14248 v.AddArg2(x, y)
14249 return true
14250 }
14251
14252
14253 for {
14254 if v_0.Op != OpARM64MOVDconst {
14255 break
14256 }
14257 c := auxIntToInt64(v_0.AuxInt)
14258 v.reset(OpARM64MOVDconst)
14259 v.AuxInt = int64ToAuxInt(^c)
14260 return true
14261 }
14262
14263
14264
14265 for {
14266 x := v_0
14267 if x.Op != OpARM64SLLconst {
14268 break
14269 }
14270 c := auxIntToInt64(x.AuxInt)
14271 y := x.Args[0]
14272 if !(clobberIfDead(x)) {
14273 break
14274 }
14275 v.reset(OpARM64MVNshiftLL)
14276 v.AuxInt = int64ToAuxInt(c)
14277 v.AddArg(y)
14278 return true
14279 }
14280
14281
14282
14283 for {
14284 x := v_0
14285 if x.Op != OpARM64SRLconst {
14286 break
14287 }
14288 c := auxIntToInt64(x.AuxInt)
14289 y := x.Args[0]
14290 if !(clobberIfDead(x)) {
14291 break
14292 }
14293 v.reset(OpARM64MVNshiftRL)
14294 v.AuxInt = int64ToAuxInt(c)
14295 v.AddArg(y)
14296 return true
14297 }
14298
14299
14300
14301 for {
14302 x := v_0
14303 if x.Op != OpARM64SRAconst {
14304 break
14305 }
14306 c := auxIntToInt64(x.AuxInt)
14307 y := x.Args[0]
14308 if !(clobberIfDead(x)) {
14309 break
14310 }
14311 v.reset(OpARM64MVNshiftRA)
14312 v.AuxInt = int64ToAuxInt(c)
14313 v.AddArg(y)
14314 return true
14315 }
14316
14317
14318
14319 for {
14320 x := v_0
14321 if x.Op != OpARM64RORconst {
14322 break
14323 }
14324 c := auxIntToInt64(x.AuxInt)
14325 y := x.Args[0]
14326 if !(clobberIfDead(x)) {
14327 break
14328 }
14329 v.reset(OpARM64MVNshiftRO)
14330 v.AuxInt = int64ToAuxInt(c)
14331 v.AddArg(y)
14332 return true
14333 }
14334 return false
14335 }
14336 func rewriteValueARM64_OpARM64MVNshiftLL(v *Value) bool {
14337 v_0 := v.Args[0]
14338
14339
14340 for {
14341 d := auxIntToInt64(v.AuxInt)
14342 if v_0.Op != OpARM64MOVDconst {
14343 break
14344 }
14345 c := auxIntToInt64(v_0.AuxInt)
14346 v.reset(OpARM64MOVDconst)
14347 v.AuxInt = int64ToAuxInt(^int64(uint64(c) << uint64(d)))
14348 return true
14349 }
14350 return false
14351 }
14352 func rewriteValueARM64_OpARM64MVNshiftRA(v *Value) bool {
14353 v_0 := v.Args[0]
14354
14355
14356 for {
14357 d := auxIntToInt64(v.AuxInt)
14358 if v_0.Op != OpARM64MOVDconst {
14359 break
14360 }
14361 c := auxIntToInt64(v_0.AuxInt)
14362 v.reset(OpARM64MOVDconst)
14363 v.AuxInt = int64ToAuxInt(^(c >> uint64(d)))
14364 return true
14365 }
14366 return false
14367 }
14368 func rewriteValueARM64_OpARM64MVNshiftRL(v *Value) bool {
14369 v_0 := v.Args[0]
14370
14371
14372 for {
14373 d := auxIntToInt64(v.AuxInt)
14374 if v_0.Op != OpARM64MOVDconst {
14375 break
14376 }
14377 c := auxIntToInt64(v_0.AuxInt)
14378 v.reset(OpARM64MOVDconst)
14379 v.AuxInt = int64ToAuxInt(^int64(uint64(c) >> uint64(d)))
14380 return true
14381 }
14382 return false
14383 }
14384 func rewriteValueARM64_OpARM64MVNshiftRO(v *Value) bool {
14385 v_0 := v.Args[0]
14386
14387
14388 for {
14389 d := auxIntToInt64(v.AuxInt)
14390 if v_0.Op != OpARM64MOVDconst {
14391 break
14392 }
14393 c := auxIntToInt64(v_0.AuxInt)
14394 v.reset(OpARM64MOVDconst)
14395 v.AuxInt = int64ToAuxInt(^rotateRight64(c, d))
14396 return true
14397 }
14398 return false
14399 }
14400 func rewriteValueARM64_OpARM64NEG(v *Value) bool {
14401 v_0 := v.Args[0]
14402
14403
14404 for {
14405 if v_0.Op != OpARM64MUL {
14406 break
14407 }
14408 y := v_0.Args[1]
14409 x := v_0.Args[0]
14410 v.reset(OpARM64MNEG)
14411 v.AddArg2(x, y)
14412 return true
14413 }
14414
14415
14416
14417 for {
14418 if v_0.Op != OpARM64MULW {
14419 break
14420 }
14421 y := v_0.Args[1]
14422 x := v_0.Args[0]
14423 if !(v.Type.Size() <= 4) {
14424 break
14425 }
14426 v.reset(OpARM64MNEGW)
14427 v.AddArg2(x, y)
14428 return true
14429 }
14430
14431
14432 for {
14433 if v_0.Op != OpARM64SUB {
14434 break
14435 }
14436 y := v_0.Args[1]
14437 x := v_0.Args[0]
14438 v.reset(OpARM64SUB)
14439 v.AddArg2(y, x)
14440 return true
14441 }
14442
14443
14444 for {
14445 if v_0.Op != OpARM64NEG {
14446 break
14447 }
14448 x := v_0.Args[0]
14449 v.copyOf(x)
14450 return true
14451 }
14452
14453
14454 for {
14455 if v_0.Op != OpARM64MOVDconst {
14456 break
14457 }
14458 c := auxIntToInt64(v_0.AuxInt)
14459 v.reset(OpARM64MOVDconst)
14460 v.AuxInt = int64ToAuxInt(-c)
14461 return true
14462 }
14463
14464
14465
14466 for {
14467 x := v_0
14468 if x.Op != OpARM64SLLconst {
14469 break
14470 }
14471 c := auxIntToInt64(x.AuxInt)
14472 y := x.Args[0]
14473 if !(clobberIfDead(x)) {
14474 break
14475 }
14476 v.reset(OpARM64NEGshiftLL)
14477 v.AuxInt = int64ToAuxInt(c)
14478 v.AddArg(y)
14479 return true
14480 }
14481
14482
14483
14484 for {
14485 x := v_0
14486 if x.Op != OpARM64SRLconst {
14487 break
14488 }
14489 c := auxIntToInt64(x.AuxInt)
14490 y := x.Args[0]
14491 if !(clobberIfDead(x)) {
14492 break
14493 }
14494 v.reset(OpARM64NEGshiftRL)
14495 v.AuxInt = int64ToAuxInt(c)
14496 v.AddArg(y)
14497 return true
14498 }
14499
14500
14501
14502 for {
14503 x := v_0
14504 if x.Op != OpARM64SRAconst {
14505 break
14506 }
14507 c := auxIntToInt64(x.AuxInt)
14508 y := x.Args[0]
14509 if !(clobberIfDead(x)) {
14510 break
14511 }
14512 v.reset(OpARM64NEGshiftRA)
14513 v.AuxInt = int64ToAuxInt(c)
14514 v.AddArg(y)
14515 return true
14516 }
14517 return false
14518 }
14519 func rewriteValueARM64_OpARM64NEGshiftLL(v *Value) bool {
14520 v_0 := v.Args[0]
14521
14522
14523 for {
14524 d := auxIntToInt64(v.AuxInt)
14525 if v_0.Op != OpARM64MOVDconst {
14526 break
14527 }
14528 c := auxIntToInt64(v_0.AuxInt)
14529 v.reset(OpARM64MOVDconst)
14530 v.AuxInt = int64ToAuxInt(-int64(uint64(c) << uint64(d)))
14531 return true
14532 }
14533 return false
14534 }
14535 func rewriteValueARM64_OpARM64NEGshiftRA(v *Value) bool {
14536 v_0 := v.Args[0]
14537
14538
14539 for {
14540 d := auxIntToInt64(v.AuxInt)
14541 if v_0.Op != OpARM64MOVDconst {
14542 break
14543 }
14544 c := auxIntToInt64(v_0.AuxInt)
14545 v.reset(OpARM64MOVDconst)
14546 v.AuxInt = int64ToAuxInt(-(c >> uint64(d)))
14547 return true
14548 }
14549 return false
14550 }
14551 func rewriteValueARM64_OpARM64NEGshiftRL(v *Value) bool {
14552 v_0 := v.Args[0]
14553
14554
14555 for {
14556 d := auxIntToInt64(v.AuxInt)
14557 if v_0.Op != OpARM64MOVDconst {
14558 break
14559 }
14560 c := auxIntToInt64(v_0.AuxInt)
14561 v.reset(OpARM64MOVDconst)
14562 v.AuxInt = int64ToAuxInt(-int64(uint64(c) >> uint64(d)))
14563 return true
14564 }
14565 return false
14566 }
14567 func rewriteValueARM64_OpARM64NotEqual(v *Value) bool {
14568 v_0 := v.Args[0]
14569 b := v.Block
14570
14571
14572
14573 for {
14574 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
14575 break
14576 }
14577 z := v_0.Args[0]
14578 if z.Op != OpARM64AND {
14579 break
14580 }
14581 y := z.Args[1]
14582 x := z.Args[0]
14583 if !(z.Uses == 1) {
14584 break
14585 }
14586 v.reset(OpARM64NotEqual)
14587 v0 := b.NewValue0(v.Pos, OpARM64TST, types.TypeFlags)
14588 v0.AddArg2(x, y)
14589 v.AddArg(v0)
14590 return true
14591 }
14592
14593
14594
14595 for {
14596 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
14597 break
14598 }
14599 x := v_0.Args[0]
14600 if x.Op != OpARM64ANDconst {
14601 break
14602 }
14603 c := auxIntToInt64(x.AuxInt)
14604 y := x.Args[0]
14605 if !(x.Uses == 1) {
14606 break
14607 }
14608 v.reset(OpARM64NotEqual)
14609 v0 := b.NewValue0(v.Pos, OpARM64TSTWconst, types.TypeFlags)
14610 v0.AuxInt = int32ToAuxInt(int32(c))
14611 v0.AddArg(y)
14612 v.AddArg(v0)
14613 return true
14614 }
14615
14616
14617
14618 for {
14619 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
14620 break
14621 }
14622 z := v_0.Args[0]
14623 if z.Op != OpARM64AND {
14624 break
14625 }
14626 y := z.Args[1]
14627 x := z.Args[0]
14628 if !(z.Uses == 1) {
14629 break
14630 }
14631 v.reset(OpARM64NotEqual)
14632 v0 := b.NewValue0(v.Pos, OpARM64TSTW, types.TypeFlags)
14633 v0.AddArg2(x, y)
14634 v.AddArg(v0)
14635 return true
14636 }
14637
14638
14639
14640 for {
14641 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
14642 break
14643 }
14644 x := v_0.Args[0]
14645 if x.Op != OpARM64ANDconst {
14646 break
14647 }
14648 c := auxIntToInt64(x.AuxInt)
14649 y := x.Args[0]
14650 if !(x.Uses == 1) {
14651 break
14652 }
14653 v.reset(OpARM64NotEqual)
14654 v0 := b.NewValue0(v.Pos, OpARM64TSTconst, types.TypeFlags)
14655 v0.AuxInt = int64ToAuxInt(c)
14656 v0.AddArg(y)
14657 v.AddArg(v0)
14658 return true
14659 }
14660
14661
14662
14663 for {
14664 if v_0.Op != OpARM64CMP {
14665 break
14666 }
14667 _ = v_0.Args[1]
14668 x := v_0.Args[0]
14669 z := v_0.Args[1]
14670 if z.Op != OpARM64NEG {
14671 break
14672 }
14673 y := z.Args[0]
14674 if !(z.Uses == 1) {
14675 break
14676 }
14677 v.reset(OpARM64NotEqual)
14678 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
14679 v0.AddArg2(x, y)
14680 v.AddArg(v0)
14681 return true
14682 }
14683
14684
14685
14686 for {
14687 if v_0.Op != OpARM64CMPW {
14688 break
14689 }
14690 _ = v_0.Args[1]
14691 x := v_0.Args[0]
14692 z := v_0.Args[1]
14693 if z.Op != OpARM64NEG {
14694 break
14695 }
14696 y := z.Args[0]
14697 if !(z.Uses == 1) {
14698 break
14699 }
14700 v.reset(OpARM64NotEqual)
14701 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
14702 v0.AddArg2(x, y)
14703 v.AddArg(v0)
14704 return true
14705 }
14706
14707
14708
14709 for {
14710 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
14711 break
14712 }
14713 x := v_0.Args[0]
14714 if x.Op != OpARM64ADDconst {
14715 break
14716 }
14717 c := auxIntToInt64(x.AuxInt)
14718 y := x.Args[0]
14719 if !(x.Uses == 1) {
14720 break
14721 }
14722 v.reset(OpARM64NotEqual)
14723 v0 := b.NewValue0(v.Pos, OpARM64CMNconst, types.TypeFlags)
14724 v0.AuxInt = int64ToAuxInt(c)
14725 v0.AddArg(y)
14726 v.AddArg(v0)
14727 return true
14728 }
14729
14730
14731
14732 for {
14733 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
14734 break
14735 }
14736 x := v_0.Args[0]
14737 if x.Op != OpARM64ADDconst {
14738 break
14739 }
14740 c := auxIntToInt64(x.AuxInt)
14741 y := x.Args[0]
14742 if !(x.Uses == 1) {
14743 break
14744 }
14745 v.reset(OpARM64NotEqual)
14746 v0 := b.NewValue0(v.Pos, OpARM64CMNWconst, types.TypeFlags)
14747 v0.AuxInt = int32ToAuxInt(int32(c))
14748 v0.AddArg(y)
14749 v.AddArg(v0)
14750 return true
14751 }
14752
14753
14754
14755 for {
14756 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
14757 break
14758 }
14759 z := v_0.Args[0]
14760 if z.Op != OpARM64ADD {
14761 break
14762 }
14763 y := z.Args[1]
14764 x := z.Args[0]
14765 if !(z.Uses == 1) {
14766 break
14767 }
14768 v.reset(OpARM64NotEqual)
14769 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
14770 v0.AddArg2(x, y)
14771 v.AddArg(v0)
14772 return true
14773 }
14774
14775
14776
14777 for {
14778 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
14779 break
14780 }
14781 z := v_0.Args[0]
14782 if z.Op != OpARM64ADD {
14783 break
14784 }
14785 y := z.Args[1]
14786 x := z.Args[0]
14787 if !(z.Uses == 1) {
14788 break
14789 }
14790 v.reset(OpARM64NotEqual)
14791 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
14792 v0.AddArg2(x, y)
14793 v.AddArg(v0)
14794 return true
14795 }
14796
14797
14798
14799 for {
14800 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
14801 break
14802 }
14803 z := v_0.Args[0]
14804 if z.Op != OpARM64MADD {
14805 break
14806 }
14807 y := z.Args[2]
14808 a := z.Args[0]
14809 x := z.Args[1]
14810 if !(z.Uses == 1) {
14811 break
14812 }
14813 v.reset(OpARM64NotEqual)
14814 v0 := b.NewValue0(v.Pos, OpARM64CMN, types.TypeFlags)
14815 v1 := b.NewValue0(v.Pos, OpARM64MUL, x.Type)
14816 v1.AddArg2(x, y)
14817 v0.AddArg2(a, v1)
14818 v.AddArg(v0)
14819 return true
14820 }
14821
14822
14823
14824 for {
14825 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
14826 break
14827 }
14828 z := v_0.Args[0]
14829 if z.Op != OpARM64MADDW {
14830 break
14831 }
14832 y := z.Args[2]
14833 a := z.Args[0]
14834 x := z.Args[1]
14835 if !(z.Uses == 1) {
14836 break
14837 }
14838 v.reset(OpARM64NotEqual)
14839 v0 := b.NewValue0(v.Pos, OpARM64CMNW, types.TypeFlags)
14840 v1 := b.NewValue0(v.Pos, OpARM64MULW, x.Type)
14841 v1.AddArg2(x, y)
14842 v0.AddArg2(a, v1)
14843 v.AddArg(v0)
14844 return true
14845 }
14846
14847
14848
14849 for {
14850 if v_0.Op != OpARM64CMPconst || auxIntToInt64(v_0.AuxInt) != 0 {
14851 break
14852 }
14853 z := v_0.Args[0]
14854 if z.Op != OpARM64MSUB {
14855 break
14856 }
14857 y := z.Args[2]
14858 a := z.Args[0]
14859 x := z.Args[1]
14860 if !(z.Uses == 1) {
14861 break
14862 }
14863 v.reset(OpARM64NotEqual)
14864 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
14865 v1 := b.NewValue0(v.Pos, OpARM64MUL, x.Type)
14866 v1.AddArg2(x, y)
14867 v0.AddArg2(a, v1)
14868 v.AddArg(v0)
14869 return true
14870 }
14871
14872
14873
14874 for {
14875 if v_0.Op != OpARM64CMPWconst || auxIntToInt32(v_0.AuxInt) != 0 {
14876 break
14877 }
14878 z := v_0.Args[0]
14879 if z.Op != OpARM64MSUBW {
14880 break
14881 }
14882 y := z.Args[2]
14883 a := z.Args[0]
14884 x := z.Args[1]
14885 if !(z.Uses == 1) {
14886 break
14887 }
14888 v.reset(OpARM64NotEqual)
14889 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
14890 v1 := b.NewValue0(v.Pos, OpARM64MULW, x.Type)
14891 v1.AddArg2(x, y)
14892 v0.AddArg2(a, v1)
14893 v.AddArg(v0)
14894 return true
14895 }
14896
14897
14898 for {
14899 if v_0.Op != OpARM64FlagConstant {
14900 break
14901 }
14902 fc := auxIntToFlagConstant(v_0.AuxInt)
14903 v.reset(OpARM64MOVDconst)
14904 v.AuxInt = int64ToAuxInt(b2i(fc.ne()))
14905 return true
14906 }
14907
14908
14909 for {
14910 if v_0.Op != OpARM64InvertFlags {
14911 break
14912 }
14913 x := v_0.Args[0]
14914 v.reset(OpARM64NotEqual)
14915 v.AddArg(x)
14916 return true
14917 }
14918 return false
14919 }
14920 func rewriteValueARM64_OpARM64OR(v *Value) bool {
14921 v_1 := v.Args[1]
14922 v_0 := v.Args[0]
14923
14924
14925 for {
14926 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14927 x := v_0
14928 if v_1.Op != OpARM64MOVDconst {
14929 continue
14930 }
14931 c := auxIntToInt64(v_1.AuxInt)
14932 v.reset(OpARM64ORconst)
14933 v.AuxInt = int64ToAuxInt(c)
14934 v.AddArg(x)
14935 return true
14936 }
14937 break
14938 }
14939
14940
14941 for {
14942 x := v_0
14943 if x != v_1 {
14944 break
14945 }
14946 v.copyOf(x)
14947 return true
14948 }
14949
14950
14951 for {
14952 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14953 x := v_0
14954 if v_1.Op != OpARM64MVN {
14955 continue
14956 }
14957 y := v_1.Args[0]
14958 v.reset(OpARM64ORN)
14959 v.AddArg2(x, y)
14960 return true
14961 }
14962 break
14963 }
14964
14965
14966
14967 for {
14968 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14969 x0 := v_0
14970 x1 := v_1
14971 if x1.Op != OpARM64SLLconst {
14972 continue
14973 }
14974 c := auxIntToInt64(x1.AuxInt)
14975 y := x1.Args[0]
14976 if !(clobberIfDead(x1)) {
14977 continue
14978 }
14979 v.reset(OpARM64ORshiftLL)
14980 v.AuxInt = int64ToAuxInt(c)
14981 v.AddArg2(x0, y)
14982 return true
14983 }
14984 break
14985 }
14986
14987
14988
14989 for {
14990 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
14991 x0 := v_0
14992 x1 := v_1
14993 if x1.Op != OpARM64SRLconst {
14994 continue
14995 }
14996 c := auxIntToInt64(x1.AuxInt)
14997 y := x1.Args[0]
14998 if !(clobberIfDead(x1)) {
14999 continue
15000 }
15001 v.reset(OpARM64ORshiftRL)
15002 v.AuxInt = int64ToAuxInt(c)
15003 v.AddArg2(x0, y)
15004 return true
15005 }
15006 break
15007 }
15008
15009
15010
15011 for {
15012 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
15013 x0 := v_0
15014 x1 := v_1
15015 if x1.Op != OpARM64SRAconst {
15016 continue
15017 }
15018 c := auxIntToInt64(x1.AuxInt)
15019 y := x1.Args[0]
15020 if !(clobberIfDead(x1)) {
15021 continue
15022 }
15023 v.reset(OpARM64ORshiftRA)
15024 v.AuxInt = int64ToAuxInt(c)
15025 v.AddArg2(x0, y)
15026 return true
15027 }
15028 break
15029 }
15030
15031
15032
15033 for {
15034 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
15035 x0 := v_0
15036 x1 := v_1
15037 if x1.Op != OpARM64RORconst {
15038 continue
15039 }
15040 c := auxIntToInt64(x1.AuxInt)
15041 y := x1.Args[0]
15042 if !(clobberIfDead(x1)) {
15043 continue
15044 }
15045 v.reset(OpARM64ORshiftRO)
15046 v.AuxInt = int64ToAuxInt(c)
15047 v.AddArg2(x0, y)
15048 return true
15049 }
15050 break
15051 }
15052
15053
15054
15055 for {
15056 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
15057 if v_0.Op != OpARM64UBFIZ {
15058 continue
15059 }
15060 bfc := auxIntToArm64BitField(v_0.AuxInt)
15061 x := v_0.Args[0]
15062 if v_1.Op != OpARM64ANDconst {
15063 continue
15064 }
15065 ac := auxIntToInt64(v_1.AuxInt)
15066 y := v_1.Args[0]
15067 if !(ac == ^((1<<uint(bfc.width()) - 1) << uint(bfc.lsb()))) {
15068 continue
15069 }
15070 v.reset(OpARM64BFI)
15071 v.AuxInt = arm64BitFieldToAuxInt(bfc)
15072 v.AddArg2(y, x)
15073 return true
15074 }
15075 break
15076 }
15077
15078
15079
15080 for {
15081 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
15082 if v_0.Op != OpARM64UBFX {
15083 continue
15084 }
15085 bfc := auxIntToArm64BitField(v_0.AuxInt)
15086 x := v_0.Args[0]
15087 if v_1.Op != OpARM64ANDconst {
15088 continue
15089 }
15090 ac := auxIntToInt64(v_1.AuxInt)
15091 y := v_1.Args[0]
15092 if !(ac == ^(1<<uint(bfc.width()) - 1)) {
15093 continue
15094 }
15095 v.reset(OpARM64BFXIL)
15096 v.AuxInt = arm64BitFieldToAuxInt(bfc)
15097 v.AddArg2(y, x)
15098 return true
15099 }
15100 break
15101 }
15102 return false
15103 }
15104 func rewriteValueARM64_OpARM64ORN(v *Value) bool {
15105 v_1 := v.Args[1]
15106 v_0 := v.Args[0]
15107
15108
15109 for {
15110 x := v_0
15111 if v_1.Op != OpARM64MOVDconst {
15112 break
15113 }
15114 c := auxIntToInt64(v_1.AuxInt)
15115 v.reset(OpARM64ORconst)
15116 v.AuxInt = int64ToAuxInt(^c)
15117 v.AddArg(x)
15118 return true
15119 }
15120
15121
15122 for {
15123 x := v_0
15124 if x != v_1 {
15125 break
15126 }
15127 v.reset(OpARM64MOVDconst)
15128 v.AuxInt = int64ToAuxInt(-1)
15129 return true
15130 }
15131
15132
15133
15134 for {
15135 x0 := v_0
15136 x1 := v_1
15137 if x1.Op != OpARM64SLLconst {
15138 break
15139 }
15140 c := auxIntToInt64(x1.AuxInt)
15141 y := x1.Args[0]
15142 if !(clobberIfDead(x1)) {
15143 break
15144 }
15145 v.reset(OpARM64ORNshiftLL)
15146 v.AuxInt = int64ToAuxInt(c)
15147 v.AddArg2(x0, y)
15148 return true
15149 }
15150
15151
15152
15153 for {
15154 x0 := v_0
15155 x1 := v_1
15156 if x1.Op != OpARM64SRLconst {
15157 break
15158 }
15159 c := auxIntToInt64(x1.AuxInt)
15160 y := x1.Args[0]
15161 if !(clobberIfDead(x1)) {
15162 break
15163 }
15164 v.reset(OpARM64ORNshiftRL)
15165 v.AuxInt = int64ToAuxInt(c)
15166 v.AddArg2(x0, y)
15167 return true
15168 }
15169
15170
15171
15172 for {
15173 x0 := v_0
15174 x1 := v_1
15175 if x1.Op != OpARM64SRAconst {
15176 break
15177 }
15178 c := auxIntToInt64(x1.AuxInt)
15179 y := x1.Args[0]
15180 if !(clobberIfDead(x1)) {
15181 break
15182 }
15183 v.reset(OpARM64ORNshiftRA)
15184 v.AuxInt = int64ToAuxInt(c)
15185 v.AddArg2(x0, y)
15186 return true
15187 }
15188
15189
15190
15191 for {
15192 x0 := v_0
15193 x1 := v_1
15194 if x1.Op != OpARM64RORconst {
15195 break
15196 }
15197 c := auxIntToInt64(x1.AuxInt)
15198 y := x1.Args[0]
15199 if !(clobberIfDead(x1)) {
15200 break
15201 }
15202 v.reset(OpARM64ORNshiftRO)
15203 v.AuxInt = int64ToAuxInt(c)
15204 v.AddArg2(x0, y)
15205 return true
15206 }
15207 return false
15208 }
15209 func rewriteValueARM64_OpARM64ORNshiftLL(v *Value) bool {
15210 v_1 := v.Args[1]
15211 v_0 := v.Args[0]
15212
15213
15214 for {
15215 d := auxIntToInt64(v.AuxInt)
15216 x := v_0
15217 if v_1.Op != OpARM64MOVDconst {
15218 break
15219 }
15220 c := auxIntToInt64(v_1.AuxInt)
15221 v.reset(OpARM64ORconst)
15222 v.AuxInt = int64ToAuxInt(^int64(uint64(c) << uint64(d)))
15223 v.AddArg(x)
15224 return true
15225 }
15226
15227
15228 for {
15229 c := auxIntToInt64(v.AuxInt)
15230 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != c {
15231 break
15232 }
15233 x := v_0.Args[0]
15234 if x != v_1 {
15235 break
15236 }
15237 v.reset(OpARM64MOVDconst)
15238 v.AuxInt = int64ToAuxInt(-1)
15239 return true
15240 }
15241 return false
15242 }
15243 func rewriteValueARM64_OpARM64ORNshiftRA(v *Value) bool {
15244 v_1 := v.Args[1]
15245 v_0 := v.Args[0]
15246
15247
15248 for {
15249 d := auxIntToInt64(v.AuxInt)
15250 x := v_0
15251 if v_1.Op != OpARM64MOVDconst {
15252 break
15253 }
15254 c := auxIntToInt64(v_1.AuxInt)
15255 v.reset(OpARM64ORconst)
15256 v.AuxInt = int64ToAuxInt(^(c >> uint64(d)))
15257 v.AddArg(x)
15258 return true
15259 }
15260
15261
15262 for {
15263 c := auxIntToInt64(v.AuxInt)
15264 if v_0.Op != OpARM64SRAconst || auxIntToInt64(v_0.AuxInt) != c {
15265 break
15266 }
15267 x := v_0.Args[0]
15268 if x != v_1 {
15269 break
15270 }
15271 v.reset(OpARM64MOVDconst)
15272 v.AuxInt = int64ToAuxInt(-1)
15273 return true
15274 }
15275 return false
15276 }
15277 func rewriteValueARM64_OpARM64ORNshiftRL(v *Value) bool {
15278 v_1 := v.Args[1]
15279 v_0 := v.Args[0]
15280
15281
15282 for {
15283 d := auxIntToInt64(v.AuxInt)
15284 x := v_0
15285 if v_1.Op != OpARM64MOVDconst {
15286 break
15287 }
15288 c := auxIntToInt64(v_1.AuxInt)
15289 v.reset(OpARM64ORconst)
15290 v.AuxInt = int64ToAuxInt(^int64(uint64(c) >> uint64(d)))
15291 v.AddArg(x)
15292 return true
15293 }
15294
15295
15296 for {
15297 c := auxIntToInt64(v.AuxInt)
15298 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != c {
15299 break
15300 }
15301 x := v_0.Args[0]
15302 if x != v_1 {
15303 break
15304 }
15305 v.reset(OpARM64MOVDconst)
15306 v.AuxInt = int64ToAuxInt(-1)
15307 return true
15308 }
15309 return false
15310 }
15311 func rewriteValueARM64_OpARM64ORNshiftRO(v *Value) bool {
15312 v_1 := v.Args[1]
15313 v_0 := v.Args[0]
15314
15315
15316 for {
15317 d := auxIntToInt64(v.AuxInt)
15318 x := v_0
15319 if v_1.Op != OpARM64MOVDconst {
15320 break
15321 }
15322 c := auxIntToInt64(v_1.AuxInt)
15323 v.reset(OpARM64ORconst)
15324 v.AuxInt = int64ToAuxInt(^rotateRight64(c, d))
15325 v.AddArg(x)
15326 return true
15327 }
15328
15329
15330 for {
15331 c := auxIntToInt64(v.AuxInt)
15332 if v_0.Op != OpARM64RORconst || auxIntToInt64(v_0.AuxInt) != c {
15333 break
15334 }
15335 x := v_0.Args[0]
15336 if x != v_1 {
15337 break
15338 }
15339 v.reset(OpARM64MOVDconst)
15340 v.AuxInt = int64ToAuxInt(-1)
15341 return true
15342 }
15343 return false
15344 }
15345 func rewriteValueARM64_OpARM64ORconst(v *Value) bool {
15346 v_0 := v.Args[0]
15347
15348
15349 for {
15350 if auxIntToInt64(v.AuxInt) != 0 {
15351 break
15352 }
15353 x := v_0
15354 v.copyOf(x)
15355 return true
15356 }
15357
15358
15359 for {
15360 if auxIntToInt64(v.AuxInt) != -1 {
15361 break
15362 }
15363 v.reset(OpARM64MOVDconst)
15364 v.AuxInt = int64ToAuxInt(-1)
15365 return true
15366 }
15367
15368
15369 for {
15370 c := auxIntToInt64(v.AuxInt)
15371 if v_0.Op != OpARM64MOVDconst {
15372 break
15373 }
15374 d := auxIntToInt64(v_0.AuxInt)
15375 v.reset(OpARM64MOVDconst)
15376 v.AuxInt = int64ToAuxInt(c | d)
15377 return true
15378 }
15379
15380
15381 for {
15382 c := auxIntToInt64(v.AuxInt)
15383 if v_0.Op != OpARM64ORconst {
15384 break
15385 }
15386 d := auxIntToInt64(v_0.AuxInt)
15387 x := v_0.Args[0]
15388 v.reset(OpARM64ORconst)
15389 v.AuxInt = int64ToAuxInt(c | d)
15390 v.AddArg(x)
15391 return true
15392 }
15393
15394
15395
15396 for {
15397 c1 := auxIntToInt64(v.AuxInt)
15398 if v_0.Op != OpARM64ANDconst {
15399 break
15400 }
15401 c2 := auxIntToInt64(v_0.AuxInt)
15402 x := v_0.Args[0]
15403 if !(c2|c1 == ^0) {
15404 break
15405 }
15406 v.reset(OpARM64ORconst)
15407 v.AuxInt = int64ToAuxInt(c1)
15408 v.AddArg(x)
15409 return true
15410 }
15411 return false
15412 }
15413 func rewriteValueARM64_OpARM64ORshiftLL(v *Value) bool {
15414 v_1 := v.Args[1]
15415 v_0 := v.Args[0]
15416 b := v.Block
15417 typ := &b.Func.Config.Types
15418
15419
15420 for {
15421 d := auxIntToInt64(v.AuxInt)
15422 if v_0.Op != OpARM64MOVDconst {
15423 break
15424 }
15425 c := auxIntToInt64(v_0.AuxInt)
15426 x := v_1
15427 v.reset(OpARM64ORconst)
15428 v.AuxInt = int64ToAuxInt(c)
15429 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
15430 v0.AuxInt = int64ToAuxInt(d)
15431 v0.AddArg(x)
15432 v.AddArg(v0)
15433 return true
15434 }
15435
15436
15437 for {
15438 d := auxIntToInt64(v.AuxInt)
15439 x := v_0
15440 if v_1.Op != OpARM64MOVDconst {
15441 break
15442 }
15443 c := auxIntToInt64(v_1.AuxInt)
15444 v.reset(OpARM64ORconst)
15445 v.AuxInt = int64ToAuxInt(int64(uint64(c) << uint64(d)))
15446 v.AddArg(x)
15447 return true
15448 }
15449
15450
15451 for {
15452 c := auxIntToInt64(v.AuxInt)
15453 y := v_0
15454 if y.Op != OpARM64SLLconst || auxIntToInt64(y.AuxInt) != c {
15455 break
15456 }
15457 x := y.Args[0]
15458 if x != v_1 {
15459 break
15460 }
15461 v.copyOf(y)
15462 return true
15463 }
15464
15465
15466 for {
15467 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) {
15468 break
15469 }
15470 x := v_0.Args[0]
15471 if x != v_1 {
15472 break
15473 }
15474 v.reset(OpARM64REV16W)
15475 v.AddArg(x)
15476 return true
15477 }
15478
15479
15480
15481 for {
15482 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64UBFX || auxIntToArm64BitField(v_0.AuxInt) != armBFAuxInt(8, 24) {
15483 break
15484 }
15485 v_0_0 := v_0.Args[0]
15486 if v_0_0.Op != OpARM64ANDconst {
15487 break
15488 }
15489 c1 := auxIntToInt64(v_0_0.AuxInt)
15490 x := v_0_0.Args[0]
15491 if v_1.Op != OpARM64ANDconst {
15492 break
15493 }
15494 c2 := auxIntToInt64(v_1.AuxInt)
15495 if x != v_1.Args[0] || !(uint32(c1) == 0xff00ff00 && uint32(c2) == 0x00ff00ff) {
15496 break
15497 }
15498 v.reset(OpARM64REV16W)
15499 v.AddArg(x)
15500 return true
15501 }
15502
15503
15504
15505 for {
15506 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
15507 break
15508 }
15509 v_0_0 := v_0.Args[0]
15510 if v_0_0.Op != OpARM64ANDconst {
15511 break
15512 }
15513 c1 := auxIntToInt64(v_0_0.AuxInt)
15514 x := v_0_0.Args[0]
15515 if v_1.Op != OpARM64ANDconst {
15516 break
15517 }
15518 c2 := auxIntToInt64(v_1.AuxInt)
15519 if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00ff00ff00 && uint64(c2) == 0x00ff00ff00ff00ff) {
15520 break
15521 }
15522 v.reset(OpARM64REV16)
15523 v.AddArg(x)
15524 return true
15525 }
15526
15527
15528
15529 for {
15530 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
15531 break
15532 }
15533 v_0_0 := v_0.Args[0]
15534 if v_0_0.Op != OpARM64ANDconst {
15535 break
15536 }
15537 c1 := auxIntToInt64(v_0_0.AuxInt)
15538 x := v_0_0.Args[0]
15539 if v_1.Op != OpARM64ANDconst {
15540 break
15541 }
15542 c2 := auxIntToInt64(v_1.AuxInt)
15543 if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00 && uint64(c2) == 0x00ff00ff) {
15544 break
15545 }
15546 v.reset(OpARM64REV16)
15547 v0 := b.NewValue0(v.Pos, OpARM64ANDconst, x.Type)
15548 v0.AuxInt = int64ToAuxInt(0xffffffff)
15549 v0.AddArg(x)
15550 v.AddArg(v0)
15551 return true
15552 }
15553
15554
15555 for {
15556 c := auxIntToInt64(v.AuxInt)
15557 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 64-c {
15558 break
15559 }
15560 x := v_0.Args[0]
15561 x2 := v_1
15562 v.reset(OpARM64EXTRconst)
15563 v.AuxInt = int64ToAuxInt(64 - c)
15564 v.AddArg2(x2, x)
15565 return true
15566 }
15567
15568
15569
15570 for {
15571 t := v.Type
15572 c := auxIntToInt64(v.AuxInt)
15573 if v_0.Op != OpARM64UBFX {
15574 break
15575 }
15576 bfc := auxIntToArm64BitField(v_0.AuxInt)
15577 x := v_0.Args[0]
15578 x2 := v_1
15579 if !(c < 32 && t.Size() == 4 && bfc == armBFAuxInt(32-c, c)) {
15580 break
15581 }
15582 v.reset(OpARM64EXTRWconst)
15583 v.AuxInt = int64ToAuxInt(32 - c)
15584 v.AddArg2(x2, x)
15585 return true
15586 }
15587
15588
15589
15590 for {
15591 s := auxIntToInt64(v.AuxInt)
15592 if v_0.Op != OpARM64ANDconst {
15593 break
15594 }
15595 xc := auxIntToInt64(v_0.AuxInt)
15596 x := v_0.Args[0]
15597 if v_1.Op != OpARM64ANDconst {
15598 break
15599 }
15600 yc := auxIntToInt64(v_1.AuxInt)
15601 y := v_1.Args[0]
15602 if !(xc == ^(yc<<s) && yc&(yc+1) == 0 && yc > 0 && s+log64(yc+1) <= 64) {
15603 break
15604 }
15605 v.reset(OpARM64BFI)
15606 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(s, log64(yc+1)))
15607 v.AddArg2(x, y)
15608 return true
15609 }
15610
15611
15612
15613 for {
15614 sc := auxIntToInt64(v.AuxInt)
15615 if v_0.Op != OpARM64UBFX {
15616 break
15617 }
15618 bfc := auxIntToArm64BitField(v_0.AuxInt)
15619 x := v_0.Args[0]
15620 if v_1.Op != OpARM64SRLconst || auxIntToInt64(v_1.AuxInt) != sc {
15621 break
15622 }
15623 y := v_1.Args[0]
15624 if !(sc == bfc.width()) {
15625 break
15626 }
15627 v.reset(OpARM64BFXIL)
15628 v.AuxInt = arm64BitFieldToAuxInt(bfc)
15629 v.AddArg2(y, x)
15630 return true
15631 }
15632 return false
15633 }
15634 func rewriteValueARM64_OpARM64ORshiftRA(v *Value) bool {
15635 v_1 := v.Args[1]
15636 v_0 := v.Args[0]
15637 b := v.Block
15638
15639
15640 for {
15641 d := auxIntToInt64(v.AuxInt)
15642 if v_0.Op != OpARM64MOVDconst {
15643 break
15644 }
15645 c := auxIntToInt64(v_0.AuxInt)
15646 x := v_1
15647 v.reset(OpARM64ORconst)
15648 v.AuxInt = int64ToAuxInt(c)
15649 v0 := b.NewValue0(v.Pos, OpARM64SRAconst, x.Type)
15650 v0.AuxInt = int64ToAuxInt(d)
15651 v0.AddArg(x)
15652 v.AddArg(v0)
15653 return true
15654 }
15655
15656
15657 for {
15658 d := auxIntToInt64(v.AuxInt)
15659 x := v_0
15660 if v_1.Op != OpARM64MOVDconst {
15661 break
15662 }
15663 c := auxIntToInt64(v_1.AuxInt)
15664 v.reset(OpARM64ORconst)
15665 v.AuxInt = int64ToAuxInt(c >> uint64(d))
15666 v.AddArg(x)
15667 return true
15668 }
15669
15670
15671 for {
15672 c := auxIntToInt64(v.AuxInt)
15673 y := v_0
15674 if y.Op != OpARM64SRAconst || auxIntToInt64(y.AuxInt) != c {
15675 break
15676 }
15677 x := y.Args[0]
15678 if x != v_1 {
15679 break
15680 }
15681 v.copyOf(y)
15682 return true
15683 }
15684 return false
15685 }
15686 func rewriteValueARM64_OpARM64ORshiftRL(v *Value) bool {
15687 v_1 := v.Args[1]
15688 v_0 := v.Args[0]
15689 b := v.Block
15690
15691
15692 for {
15693 d := auxIntToInt64(v.AuxInt)
15694 if v_0.Op != OpARM64MOVDconst {
15695 break
15696 }
15697 c := auxIntToInt64(v_0.AuxInt)
15698 x := v_1
15699 v.reset(OpARM64ORconst)
15700 v.AuxInt = int64ToAuxInt(c)
15701 v0 := b.NewValue0(v.Pos, OpARM64SRLconst, x.Type)
15702 v0.AuxInt = int64ToAuxInt(d)
15703 v0.AddArg(x)
15704 v.AddArg(v0)
15705 return true
15706 }
15707
15708
15709 for {
15710 d := auxIntToInt64(v.AuxInt)
15711 x := v_0
15712 if v_1.Op != OpARM64MOVDconst {
15713 break
15714 }
15715 c := auxIntToInt64(v_1.AuxInt)
15716 v.reset(OpARM64ORconst)
15717 v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
15718 v.AddArg(x)
15719 return true
15720 }
15721
15722
15723 for {
15724 c := auxIntToInt64(v.AuxInt)
15725 y := v_0
15726 if y.Op != OpARM64SRLconst || auxIntToInt64(y.AuxInt) != c {
15727 break
15728 }
15729 x := y.Args[0]
15730 if x != v_1 {
15731 break
15732 }
15733 v.copyOf(y)
15734 return true
15735 }
15736
15737
15738
15739 for {
15740 rc := auxIntToInt64(v.AuxInt)
15741 if v_0.Op != OpARM64ANDconst {
15742 break
15743 }
15744 ac := auxIntToInt64(v_0.AuxInt)
15745 x := v_0.Args[0]
15746 if v_1.Op != OpARM64SLLconst {
15747 break
15748 }
15749 lc := auxIntToInt64(v_1.AuxInt)
15750 y := v_1.Args[0]
15751 if !(lc > rc && ac == ^((1<<uint(64-lc)-1)<<uint64(lc-rc))) {
15752 break
15753 }
15754 v.reset(OpARM64BFI)
15755 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc-rc, 64-lc))
15756 v.AddArg2(x, y)
15757 return true
15758 }
15759
15760
15761
15762 for {
15763 rc := auxIntToInt64(v.AuxInt)
15764 if v_0.Op != OpARM64ANDconst {
15765 break
15766 }
15767 ac := auxIntToInt64(v_0.AuxInt)
15768 y := v_0.Args[0]
15769 if v_1.Op != OpARM64SLLconst {
15770 break
15771 }
15772 lc := auxIntToInt64(v_1.AuxInt)
15773 x := v_1.Args[0]
15774 if !(lc < rc && ac == ^(1<<uint(64-rc)-1)) {
15775 break
15776 }
15777 v.reset(OpARM64BFXIL)
15778 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc-lc, 64-rc))
15779 v.AddArg2(y, x)
15780 return true
15781 }
15782 return false
15783 }
15784 func rewriteValueARM64_OpARM64ORshiftRO(v *Value) bool {
15785 v_1 := v.Args[1]
15786 v_0 := v.Args[0]
15787 b := v.Block
15788
15789
15790 for {
15791 d := auxIntToInt64(v.AuxInt)
15792 if v_0.Op != OpARM64MOVDconst {
15793 break
15794 }
15795 c := auxIntToInt64(v_0.AuxInt)
15796 x := v_1
15797 v.reset(OpARM64ORconst)
15798 v.AuxInt = int64ToAuxInt(c)
15799 v0 := b.NewValue0(v.Pos, OpARM64RORconst, x.Type)
15800 v0.AuxInt = int64ToAuxInt(d)
15801 v0.AddArg(x)
15802 v.AddArg(v0)
15803 return true
15804 }
15805
15806
15807 for {
15808 d := auxIntToInt64(v.AuxInt)
15809 x := v_0
15810 if v_1.Op != OpARM64MOVDconst {
15811 break
15812 }
15813 c := auxIntToInt64(v_1.AuxInt)
15814 v.reset(OpARM64ORconst)
15815 v.AuxInt = int64ToAuxInt(rotateRight64(c, d))
15816 v.AddArg(x)
15817 return true
15818 }
15819
15820
15821 for {
15822 c := auxIntToInt64(v.AuxInt)
15823 y := v_0
15824 if y.Op != OpARM64RORconst || auxIntToInt64(y.AuxInt) != c {
15825 break
15826 }
15827 x := y.Args[0]
15828 if x != v_1 {
15829 break
15830 }
15831 v.copyOf(y)
15832 return true
15833 }
15834 return false
15835 }
15836 func rewriteValueARM64_OpARM64REV(v *Value) bool {
15837 v_0 := v.Args[0]
15838
15839
15840 for {
15841 if v_0.Op != OpARM64REV {
15842 break
15843 }
15844 p := v_0.Args[0]
15845 v.copyOf(p)
15846 return true
15847 }
15848 return false
15849 }
15850 func rewriteValueARM64_OpARM64REV16(v *Value) bool {
15851 v_0 := v.Args[0]
15852
15853
15854 for {
15855 if v_0.Op != OpARM64MOVWUreg {
15856 break
15857 }
15858 x := v_0.Args[0]
15859 v.reset(OpARM64REV16W)
15860 v.AddArg(x)
15861 return true
15862 }
15863 return false
15864 }
15865 func rewriteValueARM64_OpARM64REVW(v *Value) bool {
15866 v_0 := v.Args[0]
15867
15868
15869 for {
15870 if v_0.Op != OpARM64REVW {
15871 break
15872 }
15873 p := v_0.Args[0]
15874 v.copyOf(p)
15875 return true
15876 }
15877 return false
15878 }
15879 func rewriteValueARM64_OpARM64ROR(v *Value) bool {
15880 v_1 := v.Args[1]
15881 v_0 := v.Args[0]
15882
15883
15884 for {
15885 x := v_0
15886 if v_1.Op != OpARM64MOVDconst {
15887 break
15888 }
15889 c := auxIntToInt64(v_1.AuxInt)
15890 v.reset(OpARM64RORconst)
15891 v.AuxInt = int64ToAuxInt(c & 63)
15892 v.AddArg(x)
15893 return true
15894 }
15895 return false
15896 }
15897 func rewriteValueARM64_OpARM64RORW(v *Value) bool {
15898 v_1 := v.Args[1]
15899 v_0 := v.Args[0]
15900
15901
15902 for {
15903 x := v_0
15904 if v_1.Op != OpARM64MOVDconst {
15905 break
15906 }
15907 c := auxIntToInt64(v_1.AuxInt)
15908 v.reset(OpARM64RORWconst)
15909 v.AuxInt = int64ToAuxInt(c & 31)
15910 v.AddArg(x)
15911 return true
15912 }
15913 return false
15914 }
15915 func rewriteValueARM64_OpARM64SBCSflags(v *Value) bool {
15916 v_2 := v.Args[2]
15917 v_1 := v.Args[1]
15918 v_0 := v.Args[0]
15919 b := v.Block
15920 typ := &b.Func.Config.Types
15921
15922
15923 for {
15924 x := v_0
15925 y := v_1
15926 if v_2.Op != OpSelect1 || v_2.Type != types.TypeFlags {
15927 break
15928 }
15929 v_2_0 := v_2.Args[0]
15930 if v_2_0.Op != OpARM64NEGSflags {
15931 break
15932 }
15933 v_2_0_0 := v_2_0.Args[0]
15934 if v_2_0_0.Op != OpARM64NEG || v_2_0_0.Type != typ.UInt64 {
15935 break
15936 }
15937 v_2_0_0_0 := v_2_0_0.Args[0]
15938 if v_2_0_0_0.Op != OpARM64NGCzerocarry || v_2_0_0_0.Type != typ.UInt64 {
15939 break
15940 }
15941 bo := v_2_0_0_0.Args[0]
15942 v.reset(OpARM64SBCSflags)
15943 v.AddArg3(x, y, bo)
15944 return true
15945 }
15946
15947
15948 for {
15949 x := v_0
15950 y := v_1
15951 if v_2.Op != OpSelect1 || v_2.Type != types.TypeFlags {
15952 break
15953 }
15954 v_2_0 := v_2.Args[0]
15955 if v_2_0.Op != OpARM64NEGSflags {
15956 break
15957 }
15958 v_2_0_0 := v_2_0.Args[0]
15959 if v_2_0_0.Op != OpARM64MOVDconst || auxIntToInt64(v_2_0_0.AuxInt) != 0 {
15960 break
15961 }
15962 v.reset(OpARM64SUBSflags)
15963 v.AddArg2(x, y)
15964 return true
15965 }
15966 return false
15967 }
15968 func rewriteValueARM64_OpARM64SBFX(v *Value) bool {
15969 v_0 := v.Args[0]
15970
15971
15972
15973 for {
15974 bfc := auxIntToArm64BitField(v.AuxInt)
15975 s := v_0
15976 if s.Op != OpARM64SLLconst {
15977 break
15978 }
15979 sc := auxIntToInt64(s.AuxInt)
15980 x := s.Args[0]
15981 if !(s.Uses == 1 && sc <= bfc.lsb()) {
15982 break
15983 }
15984 v.reset(OpARM64SBFX)
15985 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb()-sc, bfc.width()))
15986 v.AddArg(x)
15987 return true
15988 }
15989
15990
15991
15992 for {
15993 bfc := auxIntToArm64BitField(v.AuxInt)
15994 s := v_0
15995 if s.Op != OpARM64SLLconst {
15996 break
15997 }
15998 sc := auxIntToInt64(s.AuxInt)
15999 x := s.Args[0]
16000 if !(s.Uses == 1 && sc > bfc.lsb() && sc < bfc.lsb()+bfc.width()) {
16001 break
16002 }
16003 v.reset(OpARM64SBFIZ)
16004 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(sc-bfc.lsb(), bfc.width()-(sc-bfc.lsb())))
16005 v.AddArg(x)
16006 return true
16007 }
16008 return false
16009 }
16010 func rewriteValueARM64_OpARM64SLL(v *Value) bool {
16011 v_1 := v.Args[1]
16012 v_0 := v.Args[0]
16013
16014
16015 for {
16016 x := v_0
16017 if v_1.Op != OpARM64MOVDconst {
16018 break
16019 }
16020 c := auxIntToInt64(v_1.AuxInt)
16021 v.reset(OpARM64SLLconst)
16022 v.AuxInt = int64ToAuxInt(c & 63)
16023 v.AddArg(x)
16024 return true
16025 }
16026
16027
16028 for {
16029 x := v_0
16030 if v_1.Op != OpARM64ANDconst || auxIntToInt64(v_1.AuxInt) != 63 {
16031 break
16032 }
16033 y := v_1.Args[0]
16034 v.reset(OpARM64SLL)
16035 v.AddArg2(x, y)
16036 return true
16037 }
16038 return false
16039 }
16040 func rewriteValueARM64_OpARM64SLLconst(v *Value) bool {
16041 v_0 := v.Args[0]
16042
16043
16044 for {
16045 c := auxIntToInt64(v.AuxInt)
16046 if v_0.Op != OpARM64MOVDconst {
16047 break
16048 }
16049 d := auxIntToInt64(v_0.AuxInt)
16050 v.reset(OpARM64MOVDconst)
16051 v.AuxInt = int64ToAuxInt(d << uint64(c))
16052 return true
16053 }
16054
16055
16056
16057 for {
16058 c := auxIntToInt64(v.AuxInt)
16059 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != c {
16060 break
16061 }
16062 x := v_0.Args[0]
16063 if !(0 < c && c < 64) {
16064 break
16065 }
16066 v.reset(OpARM64ANDconst)
16067 v.AuxInt = int64ToAuxInt(^(1<<uint(c) - 1))
16068 v.AddArg(x)
16069 return true
16070 }
16071
16072
16073 for {
16074 lc := auxIntToInt64(v.AuxInt)
16075 if v_0.Op != OpARM64MOVWreg {
16076 break
16077 }
16078 x := v_0.Args[0]
16079 v.reset(OpARM64SBFIZ)
16080 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, min(32, 64-lc)))
16081 v.AddArg(x)
16082 return true
16083 }
16084
16085
16086 for {
16087 lc := auxIntToInt64(v.AuxInt)
16088 if v_0.Op != OpARM64MOVHreg {
16089 break
16090 }
16091 x := v_0.Args[0]
16092 v.reset(OpARM64SBFIZ)
16093 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, min(16, 64-lc)))
16094 v.AddArg(x)
16095 return true
16096 }
16097
16098
16099 for {
16100 lc := auxIntToInt64(v.AuxInt)
16101 if v_0.Op != OpARM64MOVBreg {
16102 break
16103 }
16104 x := v_0.Args[0]
16105 v.reset(OpARM64SBFIZ)
16106 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, min(8, 64-lc)))
16107 v.AddArg(x)
16108 return true
16109 }
16110
16111
16112 for {
16113 lc := auxIntToInt64(v.AuxInt)
16114 if v_0.Op != OpARM64MOVWUreg {
16115 break
16116 }
16117 x := v_0.Args[0]
16118 v.reset(OpARM64UBFIZ)
16119 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, min(32, 64-lc)))
16120 v.AddArg(x)
16121 return true
16122 }
16123
16124
16125 for {
16126 lc := auxIntToInt64(v.AuxInt)
16127 if v_0.Op != OpARM64MOVHUreg {
16128 break
16129 }
16130 x := v_0.Args[0]
16131 v.reset(OpARM64UBFIZ)
16132 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, min(16, 64-lc)))
16133 v.AddArg(x)
16134 return true
16135 }
16136
16137
16138 for {
16139 lc := auxIntToInt64(v.AuxInt)
16140 if v_0.Op != OpARM64MOVBUreg {
16141 break
16142 }
16143 x := v_0.Args[0]
16144 v.reset(OpARM64UBFIZ)
16145 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc, min(8, 64-lc)))
16146 v.AddArg(x)
16147 return true
16148 }
16149
16150
16151
16152 for {
16153 sc := auxIntToInt64(v.AuxInt)
16154 if v_0.Op != OpARM64ANDconst {
16155 break
16156 }
16157 ac := auxIntToInt64(v_0.AuxInt)
16158 x := v_0.Args[0]
16159 if !(isARM64BFMask(sc, ac, 0)) {
16160 break
16161 }
16162 v.reset(OpARM64UBFIZ)
16163 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(sc, arm64BFWidth(ac, 0)))
16164 v.AddArg(x)
16165 return true
16166 }
16167
16168
16169
16170 for {
16171 sc := auxIntToInt64(v.AuxInt)
16172 if v_0.Op != OpARM64UBFIZ {
16173 break
16174 }
16175 bfc := auxIntToArm64BitField(v_0.AuxInt)
16176 x := v_0.Args[0]
16177 if !(sc+bfc.width()+bfc.lsb() < 64) {
16178 break
16179 }
16180 v.reset(OpARM64UBFIZ)
16181 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb()+sc, bfc.width()))
16182 v.AddArg(x)
16183 return true
16184 }
16185 return false
16186 }
16187 func rewriteValueARM64_OpARM64SRA(v *Value) bool {
16188 v_1 := v.Args[1]
16189 v_0 := v.Args[0]
16190
16191
16192 for {
16193 x := v_0
16194 if v_1.Op != OpARM64MOVDconst {
16195 break
16196 }
16197 c := auxIntToInt64(v_1.AuxInt)
16198 v.reset(OpARM64SRAconst)
16199 v.AuxInt = int64ToAuxInt(c & 63)
16200 v.AddArg(x)
16201 return true
16202 }
16203
16204
16205 for {
16206 x := v_0
16207 if v_1.Op != OpARM64ANDconst || auxIntToInt64(v_1.AuxInt) != 63 {
16208 break
16209 }
16210 y := v_1.Args[0]
16211 v.reset(OpARM64SRA)
16212 v.AddArg2(x, y)
16213 return true
16214 }
16215 return false
16216 }
16217 func rewriteValueARM64_OpARM64SRAconst(v *Value) bool {
16218 v_0 := v.Args[0]
16219
16220
16221 for {
16222 c := auxIntToInt64(v.AuxInt)
16223 if v_0.Op != OpARM64MOVDconst {
16224 break
16225 }
16226 d := auxIntToInt64(v_0.AuxInt)
16227 v.reset(OpARM64MOVDconst)
16228 v.AuxInt = int64ToAuxInt(d >> uint64(c))
16229 return true
16230 }
16231
16232
16233
16234 for {
16235 rc := auxIntToInt64(v.AuxInt)
16236 if v_0.Op != OpARM64SLLconst {
16237 break
16238 }
16239 lc := auxIntToInt64(v_0.AuxInt)
16240 x := v_0.Args[0]
16241 if !(lc > rc) {
16242 break
16243 }
16244 v.reset(OpARM64SBFIZ)
16245 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc-rc, 64-lc))
16246 v.AddArg(x)
16247 return true
16248 }
16249
16250
16251
16252 for {
16253 rc := auxIntToInt64(v.AuxInt)
16254 if v_0.Op != OpARM64SLLconst {
16255 break
16256 }
16257 lc := auxIntToInt64(v_0.AuxInt)
16258 x := v_0.Args[0]
16259 if !(lc <= rc) {
16260 break
16261 }
16262 v.reset(OpARM64SBFX)
16263 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc-lc, 64-rc))
16264 v.AddArg(x)
16265 return true
16266 }
16267
16268
16269
16270 for {
16271 rc := auxIntToInt64(v.AuxInt)
16272 if v_0.Op != OpARM64MOVWreg {
16273 break
16274 }
16275 x := v_0.Args[0]
16276 if !(rc < 32) {
16277 break
16278 }
16279 v.reset(OpARM64SBFX)
16280 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 32-rc))
16281 v.AddArg(x)
16282 return true
16283 }
16284
16285
16286
16287 for {
16288 rc := auxIntToInt64(v.AuxInt)
16289 if v_0.Op != OpARM64MOVHreg {
16290 break
16291 }
16292 x := v_0.Args[0]
16293 if !(rc < 16) {
16294 break
16295 }
16296 v.reset(OpARM64SBFX)
16297 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 16-rc))
16298 v.AddArg(x)
16299 return true
16300 }
16301
16302
16303
16304 for {
16305 rc := auxIntToInt64(v.AuxInt)
16306 if v_0.Op != OpARM64MOVBreg {
16307 break
16308 }
16309 x := v_0.Args[0]
16310 if !(rc < 8) {
16311 break
16312 }
16313 v.reset(OpARM64SBFX)
16314 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 8-rc))
16315 v.AddArg(x)
16316 return true
16317 }
16318
16319
16320
16321 for {
16322 sc := auxIntToInt64(v.AuxInt)
16323 if v_0.Op != OpARM64SBFIZ {
16324 break
16325 }
16326 bfc := auxIntToArm64BitField(v_0.AuxInt)
16327 x := v_0.Args[0]
16328 if !(sc < bfc.lsb()) {
16329 break
16330 }
16331 v.reset(OpARM64SBFIZ)
16332 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb()-sc, bfc.width()))
16333 v.AddArg(x)
16334 return true
16335 }
16336
16337
16338
16339 for {
16340 sc := auxIntToInt64(v.AuxInt)
16341 if v_0.Op != OpARM64SBFIZ {
16342 break
16343 }
16344 bfc := auxIntToArm64BitField(v_0.AuxInt)
16345 x := v_0.Args[0]
16346 if !(sc >= bfc.lsb() && sc < bfc.lsb()+bfc.width()) {
16347 break
16348 }
16349 v.reset(OpARM64SBFX)
16350 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(sc-bfc.lsb(), bfc.lsb()+bfc.width()-sc))
16351 v.AddArg(x)
16352 return true
16353 }
16354 return false
16355 }
16356 func rewriteValueARM64_OpARM64SRL(v *Value) bool {
16357 v_1 := v.Args[1]
16358 v_0 := v.Args[0]
16359
16360
16361 for {
16362 x := v_0
16363 if v_1.Op != OpARM64MOVDconst {
16364 break
16365 }
16366 c := auxIntToInt64(v_1.AuxInt)
16367 v.reset(OpARM64SRLconst)
16368 v.AuxInt = int64ToAuxInt(c & 63)
16369 v.AddArg(x)
16370 return true
16371 }
16372
16373
16374 for {
16375 x := v_0
16376 if v_1.Op != OpARM64ANDconst || auxIntToInt64(v_1.AuxInt) != 63 {
16377 break
16378 }
16379 y := v_1.Args[0]
16380 v.reset(OpARM64SRL)
16381 v.AddArg2(x, y)
16382 return true
16383 }
16384 return false
16385 }
16386 func rewriteValueARM64_OpARM64SRLconst(v *Value) bool {
16387 v_0 := v.Args[0]
16388
16389
16390 for {
16391 c := auxIntToInt64(v.AuxInt)
16392 if v_0.Op != OpARM64MOVDconst {
16393 break
16394 }
16395 d := auxIntToInt64(v_0.AuxInt)
16396 v.reset(OpARM64MOVDconst)
16397 v.AuxInt = int64ToAuxInt(int64(uint64(d) >> uint64(c)))
16398 return true
16399 }
16400
16401
16402
16403 for {
16404 c := auxIntToInt64(v.AuxInt)
16405 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != c {
16406 break
16407 }
16408 x := v_0.Args[0]
16409 if !(0 < c && c < 64) {
16410 break
16411 }
16412 v.reset(OpARM64ANDconst)
16413 v.AuxInt = int64ToAuxInt(1<<uint(64-c) - 1)
16414 v.AddArg(x)
16415 return true
16416 }
16417
16418
16419
16420 for {
16421 rc := auxIntToInt64(v.AuxInt)
16422 if v_0.Op != OpARM64MOVWUreg {
16423 break
16424 }
16425 if !(rc >= 32) {
16426 break
16427 }
16428 v.reset(OpARM64MOVDconst)
16429 v.AuxInt = int64ToAuxInt(0)
16430 return true
16431 }
16432
16433
16434
16435 for {
16436 rc := auxIntToInt64(v.AuxInt)
16437 if v_0.Op != OpARM64MOVHUreg {
16438 break
16439 }
16440 if !(rc >= 16) {
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 != OpARM64MOVBUreg {
16453 break
16454 }
16455 if !(rc >= 8) {
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 != OpARM64SLLconst {
16468 break
16469 }
16470 lc := auxIntToInt64(v_0.AuxInt)
16471 x := v_0.Args[0]
16472 if !(lc > rc) {
16473 break
16474 }
16475 v.reset(OpARM64UBFIZ)
16476 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(lc-rc, 64-lc))
16477 v.AddArg(x)
16478 return true
16479 }
16480
16481
16482
16483 for {
16484 rc := auxIntToInt64(v.AuxInt)
16485 if v_0.Op != OpARM64SLLconst {
16486 break
16487 }
16488 lc := auxIntToInt64(v_0.AuxInt)
16489 x := v_0.Args[0]
16490 if !(lc < rc) {
16491 break
16492 }
16493 v.reset(OpARM64UBFX)
16494 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc-lc, 64-rc))
16495 v.AddArg(x)
16496 return true
16497 }
16498
16499
16500
16501 for {
16502 rc := auxIntToInt64(v.AuxInt)
16503 if v_0.Op != OpARM64MOVWUreg {
16504 break
16505 }
16506 x := v_0.Args[0]
16507 if !(rc < 32) {
16508 break
16509 }
16510 v.reset(OpARM64UBFX)
16511 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 32-rc))
16512 v.AddArg(x)
16513 return true
16514 }
16515
16516
16517
16518 for {
16519 rc := auxIntToInt64(v.AuxInt)
16520 if v_0.Op != OpARM64MOVHUreg {
16521 break
16522 }
16523 x := v_0.Args[0]
16524 if !(rc < 16) {
16525 break
16526 }
16527 v.reset(OpARM64UBFX)
16528 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 16-rc))
16529 v.AddArg(x)
16530 return true
16531 }
16532
16533
16534
16535 for {
16536 rc := auxIntToInt64(v.AuxInt)
16537 if v_0.Op != OpARM64MOVBUreg {
16538 break
16539 }
16540 x := v_0.Args[0]
16541 if !(rc < 8) {
16542 break
16543 }
16544 v.reset(OpARM64UBFX)
16545 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(rc, 8-rc))
16546 v.AddArg(x)
16547 return true
16548 }
16549
16550
16551
16552 for {
16553 sc := auxIntToInt64(v.AuxInt)
16554 if v_0.Op != OpARM64ANDconst {
16555 break
16556 }
16557 ac := auxIntToInt64(v_0.AuxInt)
16558 x := v_0.Args[0]
16559 if !(isARM64BFMask(sc, ac, sc)) {
16560 break
16561 }
16562 v.reset(OpARM64UBFX)
16563 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(sc, arm64BFWidth(ac, sc)))
16564 v.AddArg(x)
16565 return true
16566 }
16567
16568
16569
16570 for {
16571 sc := auxIntToInt64(v.AuxInt)
16572 if v_0.Op != OpARM64UBFX {
16573 break
16574 }
16575 bfc := auxIntToArm64BitField(v_0.AuxInt)
16576 x := v_0.Args[0]
16577 if !(sc < bfc.width()) {
16578 break
16579 }
16580 v.reset(OpARM64UBFX)
16581 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb()+sc, bfc.width()-sc))
16582 v.AddArg(x)
16583 return true
16584 }
16585
16586
16587
16588 for {
16589 sc := auxIntToInt64(v.AuxInt)
16590 if v_0.Op != OpARM64UBFIZ {
16591 break
16592 }
16593 bfc := auxIntToArm64BitField(v_0.AuxInt)
16594 x := v_0.Args[0]
16595 if !(sc == bfc.lsb()) {
16596 break
16597 }
16598 v.reset(OpARM64ANDconst)
16599 v.AuxInt = int64ToAuxInt(1<<uint(bfc.width()) - 1)
16600 v.AddArg(x)
16601 return true
16602 }
16603
16604
16605
16606 for {
16607 sc := auxIntToInt64(v.AuxInt)
16608 if v_0.Op != OpARM64UBFIZ {
16609 break
16610 }
16611 bfc := auxIntToArm64BitField(v_0.AuxInt)
16612 x := v_0.Args[0]
16613 if !(sc < bfc.lsb()) {
16614 break
16615 }
16616 v.reset(OpARM64UBFIZ)
16617 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb()-sc, bfc.width()))
16618 v.AddArg(x)
16619 return true
16620 }
16621
16622
16623
16624 for {
16625 sc := auxIntToInt64(v.AuxInt)
16626 if v_0.Op != OpARM64UBFIZ {
16627 break
16628 }
16629 bfc := auxIntToArm64BitField(v_0.AuxInt)
16630 x := v_0.Args[0]
16631 if !(sc > bfc.lsb() && sc < bfc.lsb()+bfc.width()) {
16632 break
16633 }
16634 v.reset(OpARM64UBFX)
16635 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(sc-bfc.lsb(), bfc.lsb()+bfc.width()-sc))
16636 v.AddArg(x)
16637 return true
16638 }
16639 return false
16640 }
16641 func rewriteValueARM64_OpARM64STP(v *Value) bool {
16642 v_3 := v.Args[3]
16643 v_2 := v.Args[2]
16644 v_1 := v.Args[1]
16645 v_0 := v.Args[0]
16646 b := v.Block
16647 config := b.Func.Config
16648
16649
16650
16651 for {
16652 off1 := auxIntToInt32(v.AuxInt)
16653 sym := auxToSym(v.Aux)
16654 if v_0.Op != OpARM64ADDconst {
16655 break
16656 }
16657 off2 := auxIntToInt64(v_0.AuxInt)
16658 ptr := v_0.Args[0]
16659 val1 := v_1
16660 val2 := v_2
16661 mem := v_3
16662 if !(is32Bit(int64(off1)+off2) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
16663 break
16664 }
16665 v.reset(OpARM64STP)
16666 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
16667 v.Aux = symToAux(sym)
16668 v.AddArg4(ptr, val1, val2, mem)
16669 return true
16670 }
16671
16672
16673
16674 for {
16675 off1 := auxIntToInt32(v.AuxInt)
16676 sym1 := auxToSym(v.Aux)
16677 if v_0.Op != OpARM64MOVDaddr {
16678 break
16679 }
16680 off2 := auxIntToInt32(v_0.AuxInt)
16681 sym2 := auxToSym(v_0.Aux)
16682 ptr := v_0.Args[0]
16683 val1 := v_1
16684 val2 := v_2
16685 mem := v_3
16686 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (ptr.Op != OpSB || !config.ctxt.Flag_dynlink)) {
16687 break
16688 }
16689 v.reset(OpARM64STP)
16690 v.AuxInt = int32ToAuxInt(off1 + off2)
16691 v.Aux = symToAux(mergeSym(sym1, sym2))
16692 v.AddArg4(ptr, val1, val2, mem)
16693 return true
16694 }
16695 return false
16696 }
16697 func rewriteValueARM64_OpARM64SUB(v *Value) bool {
16698 v_1 := v.Args[1]
16699 v_0 := v.Args[0]
16700 b := v.Block
16701
16702
16703 for {
16704 x := v_0
16705 if v_1.Op != OpARM64MOVDconst {
16706 break
16707 }
16708 c := auxIntToInt64(v_1.AuxInt)
16709 v.reset(OpARM64SUBconst)
16710 v.AuxInt = int64ToAuxInt(c)
16711 v.AddArg(x)
16712 return true
16713 }
16714
16715
16716
16717 for {
16718 a := v_0
16719 l := v_1
16720 if l.Op != OpARM64MUL {
16721 break
16722 }
16723 y := l.Args[1]
16724 x := l.Args[0]
16725 if !(l.Uses == 1 && clobber(l)) {
16726 break
16727 }
16728 v.reset(OpARM64MSUB)
16729 v.AddArg3(a, x, y)
16730 return true
16731 }
16732
16733
16734
16735 for {
16736 a := v_0
16737 l := v_1
16738 if l.Op != OpARM64MNEG {
16739 break
16740 }
16741 y := l.Args[1]
16742 x := l.Args[0]
16743 if !(l.Uses == 1 && clobber(l)) {
16744 break
16745 }
16746 v.reset(OpARM64MADD)
16747 v.AddArg3(a, x, y)
16748 return true
16749 }
16750
16751
16752
16753 for {
16754 a := v_0
16755 l := v_1
16756 if l.Op != OpARM64MULW {
16757 break
16758 }
16759 y := l.Args[1]
16760 x := l.Args[0]
16761 if !(v.Type.Size() <= 4 && l.Uses == 1 && clobber(l)) {
16762 break
16763 }
16764 v.reset(OpARM64MSUBW)
16765 v.AddArg3(a, x, y)
16766 return true
16767 }
16768
16769
16770
16771 for {
16772 a := v_0
16773 l := v_1
16774 if l.Op != OpARM64MNEGW {
16775 break
16776 }
16777 y := l.Args[1]
16778 x := l.Args[0]
16779 if !(v.Type.Size() <= 4 && l.Uses == 1 && clobber(l)) {
16780 break
16781 }
16782 v.reset(OpARM64MADDW)
16783 v.AddArg3(a, x, y)
16784 return true
16785 }
16786
16787
16788
16789 for {
16790 t := v.Type
16791 a := v_0
16792 p := v_1
16793 if p.Op != OpARM64ADDconst {
16794 break
16795 }
16796 c := auxIntToInt64(p.AuxInt)
16797 m := p.Args[0]
16798 if m.Op != OpARM64MUL || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
16799 break
16800 }
16801 v.reset(OpARM64SUBconst)
16802 v.AuxInt = int64ToAuxInt(c)
16803 v0 := b.NewValue0(v.Pos, OpARM64SUB, v.Type)
16804 v0.AddArg2(a, m)
16805 v.AddArg(v0)
16806 return true
16807 }
16808
16809
16810
16811 for {
16812 t := v.Type
16813 a := v_0
16814 p := v_1
16815 if p.Op != OpARM64ADDconst {
16816 break
16817 }
16818 c := auxIntToInt64(p.AuxInt)
16819 m := p.Args[0]
16820 if m.Op != OpARM64MULW || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
16821 break
16822 }
16823 v.reset(OpARM64SUBconst)
16824 v.AuxInt = int64ToAuxInt(c)
16825 v0 := b.NewValue0(v.Pos, OpARM64SUB, v.Type)
16826 v0.AddArg2(a, m)
16827 v.AddArg(v0)
16828 return true
16829 }
16830
16831
16832
16833 for {
16834 t := v.Type
16835 a := v_0
16836 p := v_1
16837 if p.Op != OpARM64ADDconst {
16838 break
16839 }
16840 c := auxIntToInt64(p.AuxInt)
16841 m := p.Args[0]
16842 if m.Op != OpARM64MNEG || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
16843 break
16844 }
16845 v.reset(OpARM64SUBconst)
16846 v.AuxInt = int64ToAuxInt(c)
16847 v0 := b.NewValue0(v.Pos, OpARM64SUB, v.Type)
16848 v0.AddArg2(a, m)
16849 v.AddArg(v0)
16850 return true
16851 }
16852
16853
16854
16855 for {
16856 t := v.Type
16857 a := v_0
16858 p := v_1
16859 if p.Op != OpARM64ADDconst {
16860 break
16861 }
16862 c := auxIntToInt64(p.AuxInt)
16863 m := p.Args[0]
16864 if m.Op != OpARM64MNEGW || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
16865 break
16866 }
16867 v.reset(OpARM64SUBconst)
16868 v.AuxInt = int64ToAuxInt(c)
16869 v0 := b.NewValue0(v.Pos, OpARM64SUB, v.Type)
16870 v0.AddArg2(a, m)
16871 v.AddArg(v0)
16872 return true
16873 }
16874
16875
16876
16877 for {
16878 t := v.Type
16879 a := v_0
16880 p := v_1
16881 if p.Op != OpARM64SUBconst {
16882 break
16883 }
16884 c := auxIntToInt64(p.AuxInt)
16885 m := p.Args[0]
16886 if m.Op != OpARM64MUL || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
16887 break
16888 }
16889 v.reset(OpARM64ADDconst)
16890 v.AuxInt = int64ToAuxInt(c)
16891 v0 := b.NewValue0(v.Pos, OpARM64SUB, v.Type)
16892 v0.AddArg2(a, m)
16893 v.AddArg(v0)
16894 return true
16895 }
16896
16897
16898
16899 for {
16900 t := v.Type
16901 a := v_0
16902 p := v_1
16903 if p.Op != OpARM64SUBconst {
16904 break
16905 }
16906 c := auxIntToInt64(p.AuxInt)
16907 m := p.Args[0]
16908 if m.Op != OpARM64MULW || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
16909 break
16910 }
16911 v.reset(OpARM64ADDconst)
16912 v.AuxInt = int64ToAuxInt(c)
16913 v0 := b.NewValue0(v.Pos, OpARM64SUB, v.Type)
16914 v0.AddArg2(a, m)
16915 v.AddArg(v0)
16916 return true
16917 }
16918
16919
16920
16921 for {
16922 t := v.Type
16923 a := v_0
16924 p := v_1
16925 if p.Op != OpARM64SUBconst {
16926 break
16927 }
16928 c := auxIntToInt64(p.AuxInt)
16929 m := p.Args[0]
16930 if m.Op != OpARM64MNEG || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
16931 break
16932 }
16933 v.reset(OpARM64ADDconst)
16934 v.AuxInt = int64ToAuxInt(c)
16935 v0 := b.NewValue0(v.Pos, OpARM64SUB, v.Type)
16936 v0.AddArg2(a, m)
16937 v.AddArg(v0)
16938 return true
16939 }
16940
16941
16942
16943 for {
16944 t := v.Type
16945 a := v_0
16946 p := v_1
16947 if p.Op != OpARM64SUBconst {
16948 break
16949 }
16950 c := auxIntToInt64(p.AuxInt)
16951 m := p.Args[0]
16952 if m.Op != OpARM64MNEGW || !(p.Uses == 1 && m.Uses == 1 && !t.IsPtrShaped()) {
16953 break
16954 }
16955 v.reset(OpARM64ADDconst)
16956 v.AuxInt = int64ToAuxInt(c)
16957 v0 := b.NewValue0(v.Pos, OpARM64SUB, v.Type)
16958 v0.AddArg2(a, m)
16959 v.AddArg(v0)
16960 return true
16961 }
16962
16963
16964 for {
16965 x := v_0
16966 if v_1.Op != OpARM64NEG {
16967 break
16968 }
16969 y := v_1.Args[0]
16970 v.reset(OpARM64ADD)
16971 v.AddArg2(x, y)
16972 return true
16973 }
16974
16975
16976 for {
16977 x := v_0
16978 if x != v_1 {
16979 break
16980 }
16981 v.reset(OpARM64MOVDconst)
16982 v.AuxInt = int64ToAuxInt(0)
16983 return true
16984 }
16985
16986
16987 for {
16988 x := v_0
16989 if v_1.Op != OpARM64SUB {
16990 break
16991 }
16992 z := v_1.Args[1]
16993 y := v_1.Args[0]
16994 v.reset(OpARM64SUB)
16995 v0 := b.NewValue0(v.Pos, OpARM64ADD, v.Type)
16996 v0.AddArg2(x, z)
16997 v.AddArg2(v0, y)
16998 return true
16999 }
17000
17001
17002 for {
17003 if v_0.Op != OpARM64SUB {
17004 break
17005 }
17006 y := v_0.Args[1]
17007 x := v_0.Args[0]
17008 z := v_1
17009 v.reset(OpARM64SUB)
17010 v0 := b.NewValue0(v.Pos, OpARM64ADD, y.Type)
17011 v0.AddArg2(y, z)
17012 v.AddArg2(x, v0)
17013 return true
17014 }
17015
17016
17017
17018 for {
17019 x0 := v_0
17020 x1 := v_1
17021 if x1.Op != OpARM64SLLconst {
17022 break
17023 }
17024 c := auxIntToInt64(x1.AuxInt)
17025 y := x1.Args[0]
17026 if !(clobberIfDead(x1)) {
17027 break
17028 }
17029 v.reset(OpARM64SUBshiftLL)
17030 v.AuxInt = int64ToAuxInt(c)
17031 v.AddArg2(x0, y)
17032 return true
17033 }
17034
17035
17036
17037 for {
17038 x0 := v_0
17039 x1 := v_1
17040 if x1.Op != OpARM64SRLconst {
17041 break
17042 }
17043 c := auxIntToInt64(x1.AuxInt)
17044 y := x1.Args[0]
17045 if !(clobberIfDead(x1)) {
17046 break
17047 }
17048 v.reset(OpARM64SUBshiftRL)
17049 v.AuxInt = int64ToAuxInt(c)
17050 v.AddArg2(x0, y)
17051 return true
17052 }
17053
17054
17055
17056 for {
17057 x0 := v_0
17058 x1 := v_1
17059 if x1.Op != OpARM64SRAconst {
17060 break
17061 }
17062 c := auxIntToInt64(x1.AuxInt)
17063 y := x1.Args[0]
17064 if !(clobberIfDead(x1)) {
17065 break
17066 }
17067 v.reset(OpARM64SUBshiftRA)
17068 v.AuxInt = int64ToAuxInt(c)
17069 v.AddArg2(x0, y)
17070 return true
17071 }
17072 return false
17073 }
17074 func rewriteValueARM64_OpARM64SUBconst(v *Value) bool {
17075 v_0 := v.Args[0]
17076
17077
17078 for {
17079 if auxIntToInt64(v.AuxInt) != 0 {
17080 break
17081 }
17082 x := v_0
17083 v.copyOf(x)
17084 return true
17085 }
17086
17087
17088 for {
17089 c := auxIntToInt64(v.AuxInt)
17090 if v_0.Op != OpARM64MOVDconst {
17091 break
17092 }
17093 d := auxIntToInt64(v_0.AuxInt)
17094 v.reset(OpARM64MOVDconst)
17095 v.AuxInt = int64ToAuxInt(d - c)
17096 return true
17097 }
17098
17099
17100 for {
17101 c := auxIntToInt64(v.AuxInt)
17102 if v_0.Op != OpARM64SUBconst {
17103 break
17104 }
17105 d := auxIntToInt64(v_0.AuxInt)
17106 x := v_0.Args[0]
17107 v.reset(OpARM64ADDconst)
17108 v.AuxInt = int64ToAuxInt(-c - d)
17109 v.AddArg(x)
17110 return true
17111 }
17112
17113
17114 for {
17115 c := auxIntToInt64(v.AuxInt)
17116 if v_0.Op != OpARM64ADDconst {
17117 break
17118 }
17119 d := auxIntToInt64(v_0.AuxInt)
17120 x := v_0.Args[0]
17121 v.reset(OpARM64ADDconst)
17122 v.AuxInt = int64ToAuxInt(-c + d)
17123 v.AddArg(x)
17124 return true
17125 }
17126 return false
17127 }
17128 func rewriteValueARM64_OpARM64SUBshiftLL(v *Value) bool {
17129 v_1 := v.Args[1]
17130 v_0 := v.Args[0]
17131
17132
17133 for {
17134 d := auxIntToInt64(v.AuxInt)
17135 x := v_0
17136 if v_1.Op != OpARM64MOVDconst {
17137 break
17138 }
17139 c := auxIntToInt64(v_1.AuxInt)
17140 v.reset(OpARM64SUBconst)
17141 v.AuxInt = int64ToAuxInt(int64(uint64(c) << uint64(d)))
17142 v.AddArg(x)
17143 return true
17144 }
17145
17146
17147 for {
17148 c := auxIntToInt64(v.AuxInt)
17149 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != c {
17150 break
17151 }
17152 x := v_0.Args[0]
17153 if x != v_1 {
17154 break
17155 }
17156 v.reset(OpARM64MOVDconst)
17157 v.AuxInt = int64ToAuxInt(0)
17158 return true
17159 }
17160 return false
17161 }
17162 func rewriteValueARM64_OpARM64SUBshiftRA(v *Value) bool {
17163 v_1 := v.Args[1]
17164 v_0 := v.Args[0]
17165
17166
17167 for {
17168 d := auxIntToInt64(v.AuxInt)
17169 x := v_0
17170 if v_1.Op != OpARM64MOVDconst {
17171 break
17172 }
17173 c := auxIntToInt64(v_1.AuxInt)
17174 v.reset(OpARM64SUBconst)
17175 v.AuxInt = int64ToAuxInt(c >> uint64(d))
17176 v.AddArg(x)
17177 return true
17178 }
17179
17180
17181 for {
17182 c := auxIntToInt64(v.AuxInt)
17183 if v_0.Op != OpARM64SRAconst || auxIntToInt64(v_0.AuxInt) != c {
17184 break
17185 }
17186 x := v_0.Args[0]
17187 if x != v_1 {
17188 break
17189 }
17190 v.reset(OpARM64MOVDconst)
17191 v.AuxInt = int64ToAuxInt(0)
17192 return true
17193 }
17194 return false
17195 }
17196 func rewriteValueARM64_OpARM64SUBshiftRL(v *Value) bool {
17197 v_1 := v.Args[1]
17198 v_0 := v.Args[0]
17199
17200
17201 for {
17202 d := auxIntToInt64(v.AuxInt)
17203 x := v_0
17204 if v_1.Op != OpARM64MOVDconst {
17205 break
17206 }
17207 c := auxIntToInt64(v_1.AuxInt)
17208 v.reset(OpARM64SUBconst)
17209 v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
17210 v.AddArg(x)
17211 return true
17212 }
17213
17214
17215 for {
17216 c := auxIntToInt64(v.AuxInt)
17217 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != c {
17218 break
17219 }
17220 x := v_0.Args[0]
17221 if x != v_1 {
17222 break
17223 }
17224 v.reset(OpARM64MOVDconst)
17225 v.AuxInt = int64ToAuxInt(0)
17226 return true
17227 }
17228 return false
17229 }
17230 func rewriteValueARM64_OpARM64TST(v *Value) bool {
17231 v_1 := v.Args[1]
17232 v_0 := v.Args[0]
17233
17234
17235 for {
17236 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
17237 x := v_0
17238 if v_1.Op != OpARM64MOVDconst {
17239 continue
17240 }
17241 c := auxIntToInt64(v_1.AuxInt)
17242 v.reset(OpARM64TSTconst)
17243 v.AuxInt = int64ToAuxInt(c)
17244 v.AddArg(x)
17245 return true
17246 }
17247 break
17248 }
17249
17250
17251
17252 for {
17253 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
17254 x0 := v_0
17255 x1 := v_1
17256 if x1.Op != OpARM64SLLconst {
17257 continue
17258 }
17259 c := auxIntToInt64(x1.AuxInt)
17260 y := x1.Args[0]
17261 if !(clobberIfDead(x1)) {
17262 continue
17263 }
17264 v.reset(OpARM64TSTshiftLL)
17265 v.AuxInt = int64ToAuxInt(c)
17266 v.AddArg2(x0, y)
17267 return true
17268 }
17269 break
17270 }
17271
17272
17273
17274 for {
17275 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
17276 x0 := v_0
17277 x1 := v_1
17278 if x1.Op != OpARM64SRLconst {
17279 continue
17280 }
17281 c := auxIntToInt64(x1.AuxInt)
17282 y := x1.Args[0]
17283 if !(clobberIfDead(x1)) {
17284 continue
17285 }
17286 v.reset(OpARM64TSTshiftRL)
17287 v.AuxInt = int64ToAuxInt(c)
17288 v.AddArg2(x0, y)
17289 return true
17290 }
17291 break
17292 }
17293
17294
17295
17296 for {
17297 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
17298 x0 := v_0
17299 x1 := v_1
17300 if x1.Op != OpARM64SRAconst {
17301 continue
17302 }
17303 c := auxIntToInt64(x1.AuxInt)
17304 y := x1.Args[0]
17305 if !(clobberIfDead(x1)) {
17306 continue
17307 }
17308 v.reset(OpARM64TSTshiftRA)
17309 v.AuxInt = int64ToAuxInt(c)
17310 v.AddArg2(x0, y)
17311 return true
17312 }
17313 break
17314 }
17315
17316
17317
17318 for {
17319 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
17320 x0 := v_0
17321 x1 := v_1
17322 if x1.Op != OpARM64RORconst {
17323 continue
17324 }
17325 c := auxIntToInt64(x1.AuxInt)
17326 y := x1.Args[0]
17327 if !(clobberIfDead(x1)) {
17328 continue
17329 }
17330 v.reset(OpARM64TSTshiftRO)
17331 v.AuxInt = int64ToAuxInt(c)
17332 v.AddArg2(x0, y)
17333 return true
17334 }
17335 break
17336 }
17337 return false
17338 }
17339 func rewriteValueARM64_OpARM64TSTW(v *Value) bool {
17340 v_1 := v.Args[1]
17341 v_0 := v.Args[0]
17342
17343
17344 for {
17345 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
17346 x := v_0
17347 if v_1.Op != OpARM64MOVDconst {
17348 continue
17349 }
17350 c := auxIntToInt64(v_1.AuxInt)
17351 v.reset(OpARM64TSTWconst)
17352 v.AuxInt = int32ToAuxInt(int32(c))
17353 v.AddArg(x)
17354 return true
17355 }
17356 break
17357 }
17358 return false
17359 }
17360 func rewriteValueARM64_OpARM64TSTWconst(v *Value) bool {
17361 v_0 := v.Args[0]
17362
17363
17364 for {
17365 y := auxIntToInt32(v.AuxInt)
17366 if v_0.Op != OpARM64MOVDconst {
17367 break
17368 }
17369 x := auxIntToInt64(v_0.AuxInt)
17370 v.reset(OpARM64FlagConstant)
17371 v.AuxInt = flagConstantToAuxInt(logicFlags32(int32(x) & y))
17372 return true
17373 }
17374 return false
17375 }
17376 func rewriteValueARM64_OpARM64TSTconst(v *Value) bool {
17377 v_0 := v.Args[0]
17378
17379
17380 for {
17381 y := auxIntToInt64(v.AuxInt)
17382 if v_0.Op != OpARM64MOVDconst {
17383 break
17384 }
17385 x := auxIntToInt64(v_0.AuxInt)
17386 v.reset(OpARM64FlagConstant)
17387 v.AuxInt = flagConstantToAuxInt(logicFlags64(x & y))
17388 return true
17389 }
17390 return false
17391 }
17392 func rewriteValueARM64_OpARM64TSTshiftLL(v *Value) bool {
17393 v_1 := v.Args[1]
17394 v_0 := v.Args[0]
17395 b := v.Block
17396
17397
17398 for {
17399 d := auxIntToInt64(v.AuxInt)
17400 if v_0.Op != OpARM64MOVDconst {
17401 break
17402 }
17403 c := auxIntToInt64(v_0.AuxInt)
17404 x := v_1
17405 v.reset(OpARM64TSTconst)
17406 v.AuxInt = int64ToAuxInt(c)
17407 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
17408 v0.AuxInt = int64ToAuxInt(d)
17409 v0.AddArg(x)
17410 v.AddArg(v0)
17411 return true
17412 }
17413
17414
17415 for {
17416 d := auxIntToInt64(v.AuxInt)
17417 x := v_0
17418 if v_1.Op != OpARM64MOVDconst {
17419 break
17420 }
17421 c := auxIntToInt64(v_1.AuxInt)
17422 v.reset(OpARM64TSTconst)
17423 v.AuxInt = int64ToAuxInt(int64(uint64(c) << uint64(d)))
17424 v.AddArg(x)
17425 return true
17426 }
17427 return false
17428 }
17429 func rewriteValueARM64_OpARM64TSTshiftRA(v *Value) bool {
17430 v_1 := v.Args[1]
17431 v_0 := v.Args[0]
17432 b := v.Block
17433
17434
17435 for {
17436 d := auxIntToInt64(v.AuxInt)
17437 if v_0.Op != OpARM64MOVDconst {
17438 break
17439 }
17440 c := auxIntToInt64(v_0.AuxInt)
17441 x := v_1
17442 v.reset(OpARM64TSTconst)
17443 v.AuxInt = int64ToAuxInt(c)
17444 v0 := b.NewValue0(v.Pos, OpARM64SRAconst, x.Type)
17445 v0.AuxInt = int64ToAuxInt(d)
17446 v0.AddArg(x)
17447 v.AddArg(v0)
17448 return true
17449 }
17450
17451
17452 for {
17453 d := auxIntToInt64(v.AuxInt)
17454 x := v_0
17455 if v_1.Op != OpARM64MOVDconst {
17456 break
17457 }
17458 c := auxIntToInt64(v_1.AuxInt)
17459 v.reset(OpARM64TSTconst)
17460 v.AuxInt = int64ToAuxInt(c >> uint64(d))
17461 v.AddArg(x)
17462 return true
17463 }
17464 return false
17465 }
17466 func rewriteValueARM64_OpARM64TSTshiftRL(v *Value) bool {
17467 v_1 := v.Args[1]
17468 v_0 := v.Args[0]
17469 b := v.Block
17470
17471
17472 for {
17473 d := auxIntToInt64(v.AuxInt)
17474 if v_0.Op != OpARM64MOVDconst {
17475 break
17476 }
17477 c := auxIntToInt64(v_0.AuxInt)
17478 x := v_1
17479 v.reset(OpARM64TSTconst)
17480 v.AuxInt = int64ToAuxInt(c)
17481 v0 := b.NewValue0(v.Pos, OpARM64SRLconst, x.Type)
17482 v0.AuxInt = int64ToAuxInt(d)
17483 v0.AddArg(x)
17484 v.AddArg(v0)
17485 return true
17486 }
17487
17488
17489 for {
17490 d := auxIntToInt64(v.AuxInt)
17491 x := v_0
17492 if v_1.Op != OpARM64MOVDconst {
17493 break
17494 }
17495 c := auxIntToInt64(v_1.AuxInt)
17496 v.reset(OpARM64TSTconst)
17497 v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
17498 v.AddArg(x)
17499 return true
17500 }
17501 return false
17502 }
17503 func rewriteValueARM64_OpARM64TSTshiftRO(v *Value) bool {
17504 v_1 := v.Args[1]
17505 v_0 := v.Args[0]
17506 b := v.Block
17507
17508
17509 for {
17510 d := auxIntToInt64(v.AuxInt)
17511 if v_0.Op != OpARM64MOVDconst {
17512 break
17513 }
17514 c := auxIntToInt64(v_0.AuxInt)
17515 x := v_1
17516 v.reset(OpARM64TSTconst)
17517 v.AuxInt = int64ToAuxInt(c)
17518 v0 := b.NewValue0(v.Pos, OpARM64RORconst, x.Type)
17519 v0.AuxInt = int64ToAuxInt(d)
17520 v0.AddArg(x)
17521 v.AddArg(v0)
17522 return true
17523 }
17524
17525
17526 for {
17527 d := auxIntToInt64(v.AuxInt)
17528 x := v_0
17529 if v_1.Op != OpARM64MOVDconst {
17530 break
17531 }
17532 c := auxIntToInt64(v_1.AuxInt)
17533 v.reset(OpARM64TSTconst)
17534 v.AuxInt = int64ToAuxInt(rotateRight64(c, d))
17535 v.AddArg(x)
17536 return true
17537 }
17538 return false
17539 }
17540 func rewriteValueARM64_OpARM64UBFIZ(v *Value) bool {
17541 v_0 := v.Args[0]
17542
17543
17544
17545 for {
17546 bfc := auxIntToArm64BitField(v.AuxInt)
17547 if v_0.Op != OpARM64SLLconst {
17548 break
17549 }
17550 sc := auxIntToInt64(v_0.AuxInt)
17551 x := v_0.Args[0]
17552 if !(sc < bfc.width()) {
17553 break
17554 }
17555 v.reset(OpARM64UBFIZ)
17556 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb()+sc, bfc.width()-sc))
17557 v.AddArg(x)
17558 return true
17559 }
17560 return false
17561 }
17562 func rewriteValueARM64_OpARM64UBFX(v *Value) bool {
17563 v_0 := v.Args[0]
17564
17565
17566
17567 for {
17568 bfc := auxIntToArm64BitField(v.AuxInt)
17569 if v_0.Op != OpARM64ANDconst {
17570 break
17571 }
17572 c := auxIntToInt64(v_0.AuxInt)
17573 x := v_0.Args[0]
17574 if !(isARM64BFMask(0, c, 0) && bfc.lsb()+bfc.width() <= arm64BFWidth(c, 0)) {
17575 break
17576 }
17577 v.reset(OpARM64UBFX)
17578 v.AuxInt = arm64BitFieldToAuxInt(bfc)
17579 v.AddArg(x)
17580 return true
17581 }
17582
17583
17584
17585 for {
17586 bfc := auxIntToArm64BitField(v.AuxInt)
17587 e := v_0
17588 if e.Op != OpARM64MOVWUreg {
17589 break
17590 }
17591 x := e.Args[0]
17592 if !(e.Uses == 1 && bfc.lsb() < 32) {
17593 break
17594 }
17595 v.reset(OpARM64UBFX)
17596 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb(), min(bfc.width(), 32-bfc.lsb())))
17597 v.AddArg(x)
17598 return true
17599 }
17600
17601
17602
17603 for {
17604 bfc := auxIntToArm64BitField(v.AuxInt)
17605 e := v_0
17606 if e.Op != OpARM64MOVHUreg {
17607 break
17608 }
17609 x := e.Args[0]
17610 if !(e.Uses == 1 && bfc.lsb() < 16) {
17611 break
17612 }
17613 v.reset(OpARM64UBFX)
17614 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb(), min(bfc.width(), 16-bfc.lsb())))
17615 v.AddArg(x)
17616 return true
17617 }
17618
17619
17620
17621 for {
17622 bfc := auxIntToArm64BitField(v.AuxInt)
17623 e := v_0
17624 if e.Op != OpARM64MOVBUreg {
17625 break
17626 }
17627 x := e.Args[0]
17628 if !(e.Uses == 1 && bfc.lsb() < 8) {
17629 break
17630 }
17631 v.reset(OpARM64UBFX)
17632 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb(), min(bfc.width(), 8-bfc.lsb())))
17633 v.AddArg(x)
17634 return true
17635 }
17636
17637
17638
17639 for {
17640 bfc := auxIntToArm64BitField(v.AuxInt)
17641 if v_0.Op != OpARM64SRLconst {
17642 break
17643 }
17644 sc := auxIntToInt64(v_0.AuxInt)
17645 x := v_0.Args[0]
17646 if !(sc+bfc.width()+bfc.lsb() < 64) {
17647 break
17648 }
17649 v.reset(OpARM64UBFX)
17650 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb()+sc, bfc.width()))
17651 v.AddArg(x)
17652 return true
17653 }
17654
17655
17656
17657 for {
17658 bfc := auxIntToArm64BitField(v.AuxInt)
17659 if v_0.Op != OpARM64SLLconst {
17660 break
17661 }
17662 sc := auxIntToInt64(v_0.AuxInt)
17663 x := v_0.Args[0]
17664 if !(sc == bfc.lsb()) {
17665 break
17666 }
17667 v.reset(OpARM64ANDconst)
17668 v.AuxInt = int64ToAuxInt(1<<uint(bfc.width()) - 1)
17669 v.AddArg(x)
17670 return true
17671 }
17672
17673
17674
17675 for {
17676 bfc := auxIntToArm64BitField(v.AuxInt)
17677 if v_0.Op != OpARM64SLLconst {
17678 break
17679 }
17680 sc := auxIntToInt64(v_0.AuxInt)
17681 x := v_0.Args[0]
17682 if !(sc < bfc.lsb()) {
17683 break
17684 }
17685 v.reset(OpARM64UBFX)
17686 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(bfc.lsb()-sc, bfc.width()))
17687 v.AddArg(x)
17688 return true
17689 }
17690
17691
17692
17693 for {
17694 bfc := auxIntToArm64BitField(v.AuxInt)
17695 if v_0.Op != OpARM64SLLconst {
17696 break
17697 }
17698 sc := auxIntToInt64(v_0.AuxInt)
17699 x := v_0.Args[0]
17700 if !(sc > bfc.lsb() && sc < bfc.lsb()+bfc.width()) {
17701 break
17702 }
17703 v.reset(OpARM64UBFIZ)
17704 v.AuxInt = arm64BitFieldToAuxInt(armBFAuxInt(sc-bfc.lsb(), bfc.lsb()+bfc.width()-sc))
17705 v.AddArg(x)
17706 return true
17707 }
17708 return false
17709 }
17710 func rewriteValueARM64_OpARM64UDIV(v *Value) bool {
17711 v_1 := v.Args[1]
17712 v_0 := v.Args[0]
17713
17714
17715 for {
17716 x := v_0
17717 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
17718 break
17719 }
17720 v.copyOf(x)
17721 return true
17722 }
17723
17724
17725
17726 for {
17727 x := v_0
17728 if v_1.Op != OpARM64MOVDconst {
17729 break
17730 }
17731 c := auxIntToInt64(v_1.AuxInt)
17732 if !(isPowerOfTwo(c)) {
17733 break
17734 }
17735 v.reset(OpARM64SRLconst)
17736 v.AuxInt = int64ToAuxInt(log64(c))
17737 v.AddArg(x)
17738 return true
17739 }
17740
17741
17742
17743 for {
17744 if v_0.Op != OpARM64MOVDconst {
17745 break
17746 }
17747 c := auxIntToInt64(v_0.AuxInt)
17748 if v_1.Op != OpARM64MOVDconst {
17749 break
17750 }
17751 d := auxIntToInt64(v_1.AuxInt)
17752 if !(d != 0) {
17753 break
17754 }
17755 v.reset(OpARM64MOVDconst)
17756 v.AuxInt = int64ToAuxInt(int64(uint64(c) / uint64(d)))
17757 return true
17758 }
17759 return false
17760 }
17761 func rewriteValueARM64_OpARM64UDIVW(v *Value) bool {
17762 v_1 := v.Args[1]
17763 v_0 := v.Args[0]
17764 b := v.Block
17765
17766
17767
17768 for {
17769 x := v_0
17770 if v_1.Op != OpARM64MOVDconst {
17771 break
17772 }
17773 c := auxIntToInt64(v_1.AuxInt)
17774 if !(uint32(c) == 1) {
17775 break
17776 }
17777 v.reset(OpARM64MOVWUreg)
17778 v.AddArg(x)
17779 return true
17780 }
17781
17782
17783
17784 for {
17785 x := v_0
17786 if v_1.Op != OpARM64MOVDconst {
17787 break
17788 }
17789 c := auxIntToInt64(v_1.AuxInt)
17790 if !(isPowerOfTwo(c) && is32Bit(c)) {
17791 break
17792 }
17793 v.reset(OpARM64SRLconst)
17794 v.AuxInt = int64ToAuxInt(log64(c))
17795 v0 := b.NewValue0(v.Pos, OpARM64MOVWUreg, v.Type)
17796 v0.AddArg(x)
17797 v.AddArg(v0)
17798 return true
17799 }
17800
17801
17802
17803 for {
17804 if v_0.Op != OpARM64MOVDconst {
17805 break
17806 }
17807 c := auxIntToInt64(v_0.AuxInt)
17808 if v_1.Op != OpARM64MOVDconst {
17809 break
17810 }
17811 d := auxIntToInt64(v_1.AuxInt)
17812 if !(d != 0) {
17813 break
17814 }
17815 v.reset(OpARM64MOVDconst)
17816 v.AuxInt = int64ToAuxInt(int64(uint32(c) / uint32(d)))
17817 return true
17818 }
17819 return false
17820 }
17821 func rewriteValueARM64_OpARM64UMOD(v *Value) bool {
17822 v_1 := v.Args[1]
17823 v_0 := v.Args[0]
17824 b := v.Block
17825 typ := &b.Func.Config.Types
17826
17827
17828 for {
17829 if v.Type != typ.UInt64 {
17830 break
17831 }
17832 x := v_0
17833 y := v_1
17834 v.reset(OpARM64MSUB)
17835 v.Type = typ.UInt64
17836 v0 := b.NewValue0(v.Pos, OpARM64UDIV, typ.UInt64)
17837 v0.AddArg2(x, y)
17838 v.AddArg3(x, y, v0)
17839 return true
17840 }
17841
17842
17843 for {
17844 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
17845 break
17846 }
17847 v.reset(OpARM64MOVDconst)
17848 v.AuxInt = int64ToAuxInt(0)
17849 return true
17850 }
17851
17852
17853
17854 for {
17855 x := v_0
17856 if v_1.Op != OpARM64MOVDconst {
17857 break
17858 }
17859 c := auxIntToInt64(v_1.AuxInt)
17860 if !(isPowerOfTwo(c)) {
17861 break
17862 }
17863 v.reset(OpARM64ANDconst)
17864 v.AuxInt = int64ToAuxInt(c - 1)
17865 v.AddArg(x)
17866 return true
17867 }
17868
17869
17870
17871 for {
17872 if v_0.Op != OpARM64MOVDconst {
17873 break
17874 }
17875 c := auxIntToInt64(v_0.AuxInt)
17876 if v_1.Op != OpARM64MOVDconst {
17877 break
17878 }
17879 d := auxIntToInt64(v_1.AuxInt)
17880 if !(d != 0) {
17881 break
17882 }
17883 v.reset(OpARM64MOVDconst)
17884 v.AuxInt = int64ToAuxInt(int64(uint64(c) % uint64(d)))
17885 return true
17886 }
17887 return false
17888 }
17889 func rewriteValueARM64_OpARM64UMODW(v *Value) bool {
17890 v_1 := v.Args[1]
17891 v_0 := v.Args[0]
17892 b := v.Block
17893 typ := &b.Func.Config.Types
17894
17895
17896 for {
17897 if v.Type != typ.UInt32 {
17898 break
17899 }
17900 x := v_0
17901 y := v_1
17902 v.reset(OpARM64MSUBW)
17903 v.Type = typ.UInt32
17904 v0 := b.NewValue0(v.Pos, OpARM64UDIVW, typ.UInt32)
17905 v0.AddArg2(x, y)
17906 v.AddArg3(x, y, v0)
17907 return true
17908 }
17909
17910
17911
17912 for {
17913 if v_1.Op != OpARM64MOVDconst {
17914 break
17915 }
17916 c := auxIntToInt64(v_1.AuxInt)
17917 if !(uint32(c) == 1) {
17918 break
17919 }
17920 v.reset(OpARM64MOVDconst)
17921 v.AuxInt = int64ToAuxInt(0)
17922 return true
17923 }
17924
17925
17926
17927 for {
17928 x := v_0
17929 if v_1.Op != OpARM64MOVDconst {
17930 break
17931 }
17932 c := auxIntToInt64(v_1.AuxInt)
17933 if !(isPowerOfTwo(c) && is32Bit(c)) {
17934 break
17935 }
17936 v.reset(OpARM64ANDconst)
17937 v.AuxInt = int64ToAuxInt(c - 1)
17938 v.AddArg(x)
17939 return true
17940 }
17941
17942
17943
17944 for {
17945 if v_0.Op != OpARM64MOVDconst {
17946 break
17947 }
17948 c := auxIntToInt64(v_0.AuxInt)
17949 if v_1.Op != OpARM64MOVDconst {
17950 break
17951 }
17952 d := auxIntToInt64(v_1.AuxInt)
17953 if !(d != 0) {
17954 break
17955 }
17956 v.reset(OpARM64MOVDconst)
17957 v.AuxInt = int64ToAuxInt(int64(uint32(c) % uint32(d)))
17958 return true
17959 }
17960 return false
17961 }
17962 func rewriteValueARM64_OpARM64VBIF16B(v *Value) bool {
17963 v_2 := v.Args[2]
17964 v_1 := v.Args[1]
17965 v_0 := v.Args[0]
17966
17967
17968 for {
17969 x := v_0
17970 y := v_1
17971 if v_2.Op != OpARM64VNOT16B {
17972 break
17973 }
17974 mask := v_2.Args[0]
17975 v.reset(OpARM64VBIT16B)
17976 v.AddArg3(x, y, mask)
17977 return true
17978 }
17979 return false
17980 }
17981 func rewriteValueARM64_OpARM64VBIT16B(v *Value) bool {
17982 v_2 := v.Args[2]
17983 v_1 := v.Args[1]
17984 v_0 := v.Args[0]
17985
17986
17987 for {
17988 x := v_0
17989 y := v_1
17990 if v_2.Op != OpARM64VNOT16B {
17991 break
17992 }
17993 mask := v_2.Args[0]
17994 v.reset(OpARM64VBIF16B)
17995 v.AddArg3(x, y, mask)
17996 return true
17997 }
17998 return false
17999 }
18000 func rewriteValueARM64_OpARM64VDUPBbcast(v *Value) bool {
18001 v_0 := v.Args[0]
18002
18003
18004
18005 for {
18006 i := auxIntToUint8(v.AuxInt)
18007 if v_0.Op != OpARM64VMOVBins {
18008 break
18009 }
18010 j := auxIntToUint8(v_0.AuxInt)
18011 _ = v_0.Args[1]
18012 v_0_1 := v_0.Args[1]
18013 if v_0_1.Op != OpARM64MOVDconst {
18014 break
18015 }
18016 c := auxIntToInt64(v_0_1.AuxInt)
18017 if !(i == j && c >= -128 && c <= 255) {
18018 break
18019 }
18020 v.reset(OpARM64VMOVI16B)
18021 v.AuxInt = uint8ToAuxInt(uint8(c))
18022 return true
18023 }
18024 return false
18025 }
18026 func rewriteValueARM64_OpARM64VFCVTL4S(v *Value) bool {
18027 v_0 := v.Args[0]
18028
18029
18030 for {
18031 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18032 break
18033 }
18034 x := v_0.Args[0]
18035 v.reset(OpARM64VFCVTL2_4S)
18036 v.AddArg(x)
18037 return true
18038 }
18039 return false
18040 }
18041 func rewriteValueARM64_OpARM64VMOVDins0(v *Value) bool {
18042 v_1 := v.Args[1]
18043 v_0 := v.Args[0]
18044
18045
18046 for {
18047 if auxIntToUint8(v.AuxInt) != 1 {
18048 break
18049 }
18050 dst := v_0
18051 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18052 break
18053 }
18054 v_1_0 := v_1.Args[0]
18055 if v_1_0.Op != OpARM64VFCVTN2D {
18056 break
18057 }
18058 y := v_1_0.Args[0]
18059 v.reset(OpARM64VFCVTN2_2D)
18060 v.AddArg2(dst, y)
18061 return true
18062 }
18063
18064
18065 for {
18066 if auxIntToUint8(v.AuxInt) != 1 {
18067 break
18068 }
18069 dst := v_0
18070 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18071 break
18072 }
18073 v_1_0 := v_1.Args[0]
18074 if v_1_0.Op != OpARM64VSHRN2D {
18075 break
18076 }
18077 c := auxIntToUint8(v_1_0.AuxInt)
18078 y := v_1_0.Args[0]
18079 v.reset(OpARM64VSHRN2_2D)
18080 v.AuxInt = uint8ToAuxInt(c)
18081 v.AddArg2(dst, y)
18082 return true
18083 }
18084
18085
18086 for {
18087 if auxIntToUint8(v.AuxInt) != 1 {
18088 break
18089 }
18090 dst := v_0
18091 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18092 break
18093 }
18094 v_1_0 := v_1.Args[0]
18095 if v_1_0.Op != OpARM64VSHRN4S {
18096 break
18097 }
18098 c := auxIntToUint8(v_1_0.AuxInt)
18099 y := v_1_0.Args[0]
18100 v.reset(OpARM64VSHRN2_4S)
18101 v.AuxInt = uint8ToAuxInt(c)
18102 v.AddArg2(dst, y)
18103 return true
18104 }
18105
18106
18107 for {
18108 if auxIntToUint8(v.AuxInt) != 1 {
18109 break
18110 }
18111 dst := v_0
18112 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18113 break
18114 }
18115 v_1_0 := v_1.Args[0]
18116 if v_1_0.Op != OpARM64VSHRN8H {
18117 break
18118 }
18119 c := auxIntToUint8(v_1_0.AuxInt)
18120 y := v_1_0.Args[0]
18121 v.reset(OpARM64VSHRN2_8H)
18122 v.AuxInt = uint8ToAuxInt(c)
18123 v.AddArg2(dst, y)
18124 return true
18125 }
18126
18127
18128 for {
18129 if auxIntToUint8(v.AuxInt) != 1 {
18130 break
18131 }
18132 dst := v_0
18133 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18134 break
18135 }
18136 v_1_0 := v_1.Args[0]
18137 if v_1_0.Op != OpARM64VSQXTN2D {
18138 break
18139 }
18140 y := v_1_0.Args[0]
18141 v.reset(OpARM64VSQXTN2_2D)
18142 v.AddArg2(dst, y)
18143 return true
18144 }
18145
18146
18147 for {
18148 if auxIntToUint8(v.AuxInt) != 1 {
18149 break
18150 }
18151 dst := v_0
18152 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18153 break
18154 }
18155 v_1_0 := v_1.Args[0]
18156 if v_1_0.Op != OpARM64VSQXTN4S {
18157 break
18158 }
18159 y := v_1_0.Args[0]
18160 v.reset(OpARM64VSQXTN2_4S)
18161 v.AddArg2(dst, y)
18162 return true
18163 }
18164
18165
18166 for {
18167 if auxIntToUint8(v.AuxInt) != 1 {
18168 break
18169 }
18170 dst := v_0
18171 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18172 break
18173 }
18174 v_1_0 := v_1.Args[0]
18175 if v_1_0.Op != OpARM64VSQXTN8H {
18176 break
18177 }
18178 y := v_1_0.Args[0]
18179 v.reset(OpARM64VSQXTN2_8H)
18180 v.AddArg2(dst, y)
18181 return true
18182 }
18183
18184
18185 for {
18186 if auxIntToUint8(v.AuxInt) != 1 {
18187 break
18188 }
18189 dst := v_0
18190 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18191 break
18192 }
18193 v_1_0 := v_1.Args[0]
18194 if v_1_0.Op != OpARM64VSQXTUN2D {
18195 break
18196 }
18197 y := v_1_0.Args[0]
18198 v.reset(OpARM64VSQXTUN2_2D)
18199 v.AddArg2(dst, y)
18200 return true
18201 }
18202
18203
18204 for {
18205 if auxIntToUint8(v.AuxInt) != 1 {
18206 break
18207 }
18208 dst := v_0
18209 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18210 break
18211 }
18212 v_1_0 := v_1.Args[0]
18213 if v_1_0.Op != OpARM64VSQXTUN4S {
18214 break
18215 }
18216 y := v_1_0.Args[0]
18217 v.reset(OpARM64VSQXTUN2_4S)
18218 v.AddArg2(dst, y)
18219 return true
18220 }
18221
18222
18223 for {
18224 if auxIntToUint8(v.AuxInt) != 1 {
18225 break
18226 }
18227 dst := v_0
18228 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18229 break
18230 }
18231 v_1_0 := v_1.Args[0]
18232 if v_1_0.Op != OpARM64VSQXTUN8H {
18233 break
18234 }
18235 y := v_1_0.Args[0]
18236 v.reset(OpARM64VSQXTUN2_8H)
18237 v.AddArg2(dst, y)
18238 return true
18239 }
18240
18241
18242 for {
18243 if auxIntToUint8(v.AuxInt) != 1 {
18244 break
18245 }
18246 dst := v_0
18247 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18248 break
18249 }
18250 v_1_0 := v_1.Args[0]
18251 if v_1_0.Op != OpARM64VUQXTN2D {
18252 break
18253 }
18254 y := v_1_0.Args[0]
18255 v.reset(OpARM64VUQXTN2_2D)
18256 v.AddArg2(dst, y)
18257 return true
18258 }
18259
18260
18261 for {
18262 if auxIntToUint8(v.AuxInt) != 1 {
18263 break
18264 }
18265 dst := v_0
18266 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18267 break
18268 }
18269 v_1_0 := v_1.Args[0]
18270 if v_1_0.Op != OpARM64VUQXTN4S {
18271 break
18272 }
18273 y := v_1_0.Args[0]
18274 v.reset(OpARM64VUQXTN2_4S)
18275 v.AddArg2(dst, y)
18276 return true
18277 }
18278
18279
18280 for {
18281 if auxIntToUint8(v.AuxInt) != 1 {
18282 break
18283 }
18284 dst := v_0
18285 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18286 break
18287 }
18288 v_1_0 := v_1.Args[0]
18289 if v_1_0.Op != OpARM64VUQXTN8H {
18290 break
18291 }
18292 y := v_1_0.Args[0]
18293 v.reset(OpARM64VUQXTN2_8H)
18294 v.AddArg2(dst, y)
18295 return true
18296 }
18297
18298
18299 for {
18300 if auxIntToUint8(v.AuxInt) != 1 {
18301 break
18302 }
18303 dst := v_0
18304 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18305 break
18306 }
18307 v_1_0 := v_1.Args[0]
18308 if v_1_0.Op != OpARM64VXTN2D {
18309 break
18310 }
18311 y := v_1_0.Args[0]
18312 v.reset(OpARM64VXTN2_2D)
18313 v.AddArg2(dst, y)
18314 return true
18315 }
18316
18317
18318 for {
18319 if auxIntToUint8(v.AuxInt) != 1 {
18320 break
18321 }
18322 dst := v_0
18323 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18324 break
18325 }
18326 v_1_0 := v_1.Args[0]
18327 if v_1_0.Op != OpARM64VXTN4S {
18328 break
18329 }
18330 y := v_1_0.Args[0]
18331 v.reset(OpARM64VXTN2_4S)
18332 v.AddArg2(dst, y)
18333 return true
18334 }
18335
18336
18337 for {
18338 if auxIntToUint8(v.AuxInt) != 1 {
18339 break
18340 }
18341 dst := v_0
18342 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 0 {
18343 break
18344 }
18345 v_1_0 := v_1.Args[0]
18346 if v_1_0.Op != OpARM64VXTN8H {
18347 break
18348 }
18349 y := v_1_0.Args[0]
18350 v.reset(OpARM64VXTN2_8H)
18351 v.AddArg2(dst, y)
18352 return true
18353 }
18354
18355
18356 for {
18357 if auxIntToUint8(v.AuxInt) != 0 || v_0.Op != OpARM64VMOVI16B || auxIntToUint8(v_0.AuxInt) != 0 {
18358 break
18359 }
18360 y := v_1
18361 if y.Op != OpARM64VDUPDextr {
18362 break
18363 }
18364 v.copyOf(y)
18365 return true
18366 }
18367 return false
18368 }
18369 func rewriteValueARM64_OpARM64VMOVSins0(v *Value) bool {
18370 v_1 := v.Args[1]
18371 v_0 := v.Args[0]
18372
18373
18374 for {
18375 if auxIntToUint8(v.AuxInt) != 0 || v_0.Op != OpARM64VMOVI16B || auxIntToUint8(v_0.AuxInt) != 0 {
18376 break
18377 }
18378 y := v_1
18379 if y.Op != OpARM64VDUPSextr {
18380 break
18381 }
18382 v.copyOf(y)
18383 return true
18384 }
18385 return false
18386 }
18387 func rewriteValueARM64_OpARM64VPMULL2D(v *Value) bool {
18388 v_1 := v.Args[1]
18389 v_0 := v.Args[0]
18390
18391
18392 for {
18393 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
18394 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18395 continue
18396 }
18397 x := v_0.Args[0]
18398 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 1 {
18399 continue
18400 }
18401 y := v_1.Args[0]
18402 v.reset(OpARM64VPMULL2_2D)
18403 v.AddArg2(x, y)
18404 return true
18405 }
18406 break
18407 }
18408 return false
18409 }
18410 func rewriteValueARM64_OpARM64VSHL16B(v *Value) bool {
18411 v_0 := v.Args[0]
18412
18413
18414
18415 for {
18416 a := auxIntToUint8(v.AuxInt)
18417 x := v_0
18418 if !(a == 0) {
18419 break
18420 }
18421 v.copyOf(x)
18422 return true
18423 }
18424 return false
18425 }
18426 func rewriteValueARM64_OpARM64VSHL2D(v *Value) bool {
18427 v_0 := v.Args[0]
18428
18429
18430
18431 for {
18432 a := auxIntToUint8(v.AuxInt)
18433 x := v_0
18434 if !(a == 0) {
18435 break
18436 }
18437 v.copyOf(x)
18438 return true
18439 }
18440 return false
18441 }
18442 func rewriteValueARM64_OpARM64VSHL4S(v *Value) bool {
18443 v_0 := v.Args[0]
18444
18445
18446
18447 for {
18448 a := auxIntToUint8(v.AuxInt)
18449 x := v_0
18450 if !(a == 0) {
18451 break
18452 }
18453 v.copyOf(x)
18454 return true
18455 }
18456 return false
18457 }
18458 func rewriteValueARM64_OpARM64VSHL8H(v *Value) bool {
18459 v_0 := v.Args[0]
18460
18461
18462
18463 for {
18464 a := auxIntToUint8(v.AuxInt)
18465 x := v_0
18466 if !(a == 0) {
18467 break
18468 }
18469 v.copyOf(x)
18470 return true
18471 }
18472 return false
18473 }
18474 func rewriteValueARM64_OpARM64VSHRN2D(v *Value) bool {
18475 v_0 := v.Args[0]
18476
18477
18478 for {
18479 if auxIntToUint8(v.AuxInt) != 0 {
18480 break
18481 }
18482 x := v_0
18483 v.reset(OpARM64VXTN2D)
18484 v.AddArg(x)
18485 return true
18486 }
18487 return false
18488 }
18489 func rewriteValueARM64_OpARM64VSHRN4S(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(OpARM64VXTN4S)
18499 v.AddArg(x)
18500 return true
18501 }
18502 return false
18503 }
18504 func rewriteValueARM64_OpARM64VSHRN8H(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(OpARM64VXTN8H)
18514 v.AddArg(x)
18515 return true
18516 }
18517 return false
18518 }
18519 func rewriteValueARM64_OpARM64VSMULL16B(v *Value) bool {
18520 v_1 := v.Args[1]
18521 v_0 := v.Args[0]
18522
18523
18524 for {
18525 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
18526 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18527 continue
18528 }
18529 x := v_0.Args[0]
18530 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 1 {
18531 continue
18532 }
18533 y := v_1.Args[0]
18534 v.reset(OpARM64VSMULL2_16B)
18535 v.AddArg2(x, y)
18536 return true
18537 }
18538 break
18539 }
18540 return false
18541 }
18542 func rewriteValueARM64_OpARM64VSMULL4S(v *Value) bool {
18543 v_1 := v.Args[1]
18544 v_0 := v.Args[0]
18545
18546
18547 for {
18548 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
18549 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18550 continue
18551 }
18552 x := v_0.Args[0]
18553 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 1 {
18554 continue
18555 }
18556 y := v_1.Args[0]
18557 v.reset(OpARM64VSMULL2_4S)
18558 v.AddArg2(x, y)
18559 return true
18560 }
18561 break
18562 }
18563 return false
18564 }
18565 func rewriteValueARM64_OpARM64VSMULL8H(v *Value) bool {
18566 v_1 := v.Args[1]
18567 v_0 := v.Args[0]
18568
18569
18570 for {
18571 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
18572 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18573 continue
18574 }
18575 x := v_0.Args[0]
18576 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 1 {
18577 continue
18578 }
18579 y := v_1.Args[0]
18580 v.reset(OpARM64VSMULL2_8H)
18581 v.AddArg2(x, y)
18582 return true
18583 }
18584 break
18585 }
18586 return false
18587 }
18588 func rewriteValueARM64_OpARM64VSQSHL16Bconst(v *Value) bool {
18589 v_0 := v.Args[0]
18590
18591
18592
18593 for {
18594 a := auxIntToUint8(v.AuxInt)
18595 x := v_0
18596 if !(a == 0) {
18597 break
18598 }
18599 v.copyOf(x)
18600 return true
18601 }
18602 return false
18603 }
18604 func rewriteValueARM64_OpARM64VSQSHL2Dconst(v *Value) bool {
18605 v_0 := v.Args[0]
18606
18607
18608
18609 for {
18610 a := auxIntToUint8(v.AuxInt)
18611 x := v_0
18612 if !(a == 0) {
18613 break
18614 }
18615 v.copyOf(x)
18616 return true
18617 }
18618 return false
18619 }
18620 func rewriteValueARM64_OpARM64VSQSHL4Sconst(v *Value) bool {
18621 v_0 := v.Args[0]
18622
18623
18624
18625 for {
18626 a := auxIntToUint8(v.AuxInt)
18627 x := v_0
18628 if !(a == 0) {
18629 break
18630 }
18631 v.copyOf(x)
18632 return true
18633 }
18634 return false
18635 }
18636 func rewriteValueARM64_OpARM64VSQSHL8Hconst(v *Value) bool {
18637 v_0 := v.Args[0]
18638
18639
18640
18641 for {
18642 a := auxIntToUint8(v.AuxInt)
18643 x := v_0
18644 if !(a == 0) {
18645 break
18646 }
18647 v.copyOf(x)
18648 return true
18649 }
18650 return false
18651 }
18652 func rewriteValueARM64_OpARM64VSSHLL16B(v *Value) bool {
18653 v_0 := v.Args[0]
18654
18655
18656 for {
18657 a := auxIntToUint8(v.AuxInt)
18658 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18659 break
18660 }
18661 x := v_0.Args[0]
18662 v.reset(OpARM64VSSHLL2_16B)
18663 v.AuxInt = uint8ToAuxInt(a)
18664 v.AddArg(x)
18665 return true
18666 }
18667 return false
18668 }
18669 func rewriteValueARM64_OpARM64VSSHLL4S(v *Value) bool {
18670 v_0 := v.Args[0]
18671
18672
18673 for {
18674 a := auxIntToUint8(v.AuxInt)
18675 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18676 break
18677 }
18678 x := v_0.Args[0]
18679 v.reset(OpARM64VSSHLL2_4S)
18680 v.AuxInt = uint8ToAuxInt(a)
18681 v.AddArg(x)
18682 return true
18683 }
18684 return false
18685 }
18686 func rewriteValueARM64_OpARM64VSSHLL8H(v *Value) bool {
18687 v_0 := v.Args[0]
18688
18689
18690 for {
18691 a := auxIntToUint8(v.AuxInt)
18692 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18693 break
18694 }
18695 x := v_0.Args[0]
18696 v.reset(OpARM64VSSHLL2_8H)
18697 v.AuxInt = uint8ToAuxInt(a)
18698 v.AddArg(x)
18699 return true
18700 }
18701 return false
18702 }
18703 func rewriteValueARM64_OpARM64VSSHR16B(v *Value) bool {
18704 v_0 := v.Args[0]
18705
18706
18707
18708 for {
18709 a := auxIntToUint8(v.AuxInt)
18710 x := v_0
18711 if !(a == 0) {
18712 break
18713 }
18714 v.copyOf(x)
18715 return true
18716 }
18717 return false
18718 }
18719 func rewriteValueARM64_OpARM64VSSHR2D(v *Value) bool {
18720 v_0 := v.Args[0]
18721
18722
18723
18724 for {
18725 a := auxIntToUint8(v.AuxInt)
18726 x := v_0
18727 if !(a == 0) {
18728 break
18729 }
18730 v.copyOf(x)
18731 return true
18732 }
18733 return false
18734 }
18735 func rewriteValueARM64_OpARM64VSSHR4S(v *Value) bool {
18736 v_0 := v.Args[0]
18737
18738
18739
18740 for {
18741 a := auxIntToUint8(v.AuxInt)
18742 x := v_0
18743 if !(a == 0) {
18744 break
18745 }
18746 v.copyOf(x)
18747 return true
18748 }
18749 return false
18750 }
18751 func rewriteValueARM64_OpARM64VSSHR8H(v *Value) bool {
18752 v_0 := v.Args[0]
18753
18754
18755
18756 for {
18757 a := auxIntToUint8(v.AuxInt)
18758 x := v_0
18759 if !(a == 0) {
18760 break
18761 }
18762 v.copyOf(x)
18763 return true
18764 }
18765 return false
18766 }
18767 func rewriteValueARM64_OpARM64VSXTL16B(v *Value) bool {
18768 v_0 := v.Args[0]
18769
18770
18771 for {
18772 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18773 break
18774 }
18775 x := v_0.Args[0]
18776 v.reset(OpARM64VSXTL2_16B)
18777 v.AddArg(x)
18778 return true
18779 }
18780 return false
18781 }
18782 func rewriteValueARM64_OpARM64VSXTL4S(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_4S)
18792 v.AddArg(x)
18793 return true
18794 }
18795 return false
18796 }
18797 func rewriteValueARM64_OpARM64VSXTL8H(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_8H)
18807 v.AddArg(x)
18808 return true
18809 }
18810 return false
18811 }
18812 func rewriteValueARM64_OpARM64VUMULL16B(v *Value) bool {
18813 v_1 := v.Args[1]
18814 v_0 := v.Args[0]
18815
18816
18817 for {
18818 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
18819 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18820 continue
18821 }
18822 x := v_0.Args[0]
18823 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 1 {
18824 continue
18825 }
18826 y := v_1.Args[0]
18827 v.reset(OpARM64VUMULL2_16B)
18828 v.AddArg2(x, y)
18829 return true
18830 }
18831 break
18832 }
18833 return false
18834 }
18835 func rewriteValueARM64_OpARM64VUMULL4S(v *Value) bool {
18836 v_1 := v.Args[1]
18837 v_0 := v.Args[0]
18838
18839
18840 for {
18841 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
18842 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18843 continue
18844 }
18845 x := v_0.Args[0]
18846 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 1 {
18847 continue
18848 }
18849 y := v_1.Args[0]
18850 v.reset(OpARM64VUMULL2_4S)
18851 v.AddArg2(x, y)
18852 return true
18853 }
18854 break
18855 }
18856 return false
18857 }
18858 func rewriteValueARM64_OpARM64VUMULL8H(v *Value) bool {
18859 v_1 := v.Args[1]
18860 v_0 := v.Args[0]
18861
18862
18863 for {
18864 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
18865 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18866 continue
18867 }
18868 x := v_0.Args[0]
18869 if v_1.Op != OpARM64VDUPDextr || auxIntToUint8(v_1.AuxInt) != 1 {
18870 continue
18871 }
18872 y := v_1.Args[0]
18873 v.reset(OpARM64VUMULL2_8H)
18874 v.AddArg2(x, y)
18875 return true
18876 }
18877 break
18878 }
18879 return false
18880 }
18881 func rewriteValueARM64_OpARM64VUQSHL16Bconst(v *Value) bool {
18882 v_0 := v.Args[0]
18883
18884
18885
18886 for {
18887 a := auxIntToUint8(v.AuxInt)
18888 x := v_0
18889 if !(a == 0) {
18890 break
18891 }
18892 v.copyOf(x)
18893 return true
18894 }
18895 return false
18896 }
18897 func rewriteValueARM64_OpARM64VUQSHL2Dconst(v *Value) bool {
18898 v_0 := v.Args[0]
18899
18900
18901
18902 for {
18903 a := auxIntToUint8(v.AuxInt)
18904 x := v_0
18905 if !(a == 0) {
18906 break
18907 }
18908 v.copyOf(x)
18909 return true
18910 }
18911 return false
18912 }
18913 func rewriteValueARM64_OpARM64VUQSHL4Sconst(v *Value) bool {
18914 v_0 := v.Args[0]
18915
18916
18917
18918 for {
18919 a := auxIntToUint8(v.AuxInt)
18920 x := v_0
18921 if !(a == 0) {
18922 break
18923 }
18924 v.copyOf(x)
18925 return true
18926 }
18927 return false
18928 }
18929 func rewriteValueARM64_OpARM64VUQSHL8Hconst(v *Value) bool {
18930 v_0 := v.Args[0]
18931
18932
18933
18934 for {
18935 a := auxIntToUint8(v.AuxInt)
18936 x := v_0
18937 if !(a == 0) {
18938 break
18939 }
18940 v.copyOf(x)
18941 return true
18942 }
18943 return false
18944 }
18945 func rewriteValueARM64_OpARM64VUSHLL16B(v *Value) bool {
18946 v_0 := v.Args[0]
18947
18948
18949 for {
18950 a := auxIntToUint8(v.AuxInt)
18951 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18952 break
18953 }
18954 x := v_0.Args[0]
18955 v.reset(OpARM64VUSHLL2_16B)
18956 v.AuxInt = uint8ToAuxInt(a)
18957 v.AddArg(x)
18958 return true
18959 }
18960 return false
18961 }
18962 func rewriteValueARM64_OpARM64VUSHLL4S(v *Value) bool {
18963 v_0 := v.Args[0]
18964
18965
18966 for {
18967 a := auxIntToUint8(v.AuxInt)
18968 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18969 break
18970 }
18971 x := v_0.Args[0]
18972 v.reset(OpARM64VUSHLL2_4S)
18973 v.AuxInt = uint8ToAuxInt(a)
18974 v.AddArg(x)
18975 return true
18976 }
18977 return false
18978 }
18979 func rewriteValueARM64_OpARM64VUSHLL8H(v *Value) bool {
18980 v_0 := v.Args[0]
18981
18982
18983 for {
18984 a := auxIntToUint8(v.AuxInt)
18985 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
18986 break
18987 }
18988 x := v_0.Args[0]
18989 v.reset(OpARM64VUSHLL2_8H)
18990 v.AuxInt = uint8ToAuxInt(a)
18991 v.AddArg(x)
18992 return true
18993 }
18994 return false
18995 }
18996 func rewriteValueARM64_OpARM64VUSHR16B(v *Value) bool {
18997 v_0 := v.Args[0]
18998
18999
19000
19001 for {
19002 a := auxIntToUint8(v.AuxInt)
19003 x := v_0
19004 if !(a == 0) {
19005 break
19006 }
19007 v.copyOf(x)
19008 return true
19009 }
19010 return false
19011 }
19012 func rewriteValueARM64_OpARM64VUSHR2D(v *Value) bool {
19013 v_0 := v.Args[0]
19014
19015
19016
19017 for {
19018 a := auxIntToUint8(v.AuxInt)
19019 x := v_0
19020 if !(a == 0) {
19021 break
19022 }
19023 v.copyOf(x)
19024 return true
19025 }
19026 return false
19027 }
19028 func rewriteValueARM64_OpARM64VUSHR4S(v *Value) bool {
19029 v_0 := v.Args[0]
19030
19031
19032
19033 for {
19034 a := auxIntToUint8(v.AuxInt)
19035 x := v_0
19036 if !(a == 0) {
19037 break
19038 }
19039 v.copyOf(x)
19040 return true
19041 }
19042 return false
19043 }
19044 func rewriteValueARM64_OpARM64VUSHR8H(v *Value) bool {
19045 v_0 := v.Args[0]
19046
19047
19048
19049 for {
19050 a := auxIntToUint8(v.AuxInt)
19051 x := v_0
19052 if !(a == 0) {
19053 break
19054 }
19055 v.copyOf(x)
19056 return true
19057 }
19058 return false
19059 }
19060 func rewriteValueARM64_OpARM64VUXTL16B(v *Value) bool {
19061 v_0 := v.Args[0]
19062
19063
19064 for {
19065 if v_0.Op != OpARM64VDUPDextr || auxIntToUint8(v_0.AuxInt) != 1 {
19066 break
19067 }
19068 x := v_0.Args[0]
19069 v.reset(OpARM64VUXTL2_16B)
19070 v.AddArg(x)
19071 return true
19072 }
19073 return false
19074 }
19075 func rewriteValueARM64_OpARM64VUXTL4S(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_4S)
19085 v.AddArg(x)
19086 return true
19087 }
19088 return false
19089 }
19090 func rewriteValueARM64_OpARM64VUXTL8H(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_8H)
19100 v.AddArg(x)
19101 return true
19102 }
19103 return false
19104 }
19105 func rewriteValueARM64_OpARM64XOR(v *Value) bool {
19106 v_1 := v.Args[1]
19107 v_0 := v.Args[0]
19108
19109
19110 for {
19111 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
19112 x := v_0
19113 if v_1.Op != OpARM64MOVDconst {
19114 continue
19115 }
19116 c := auxIntToInt64(v_1.AuxInt)
19117 v.reset(OpARM64XORconst)
19118 v.AuxInt = int64ToAuxInt(c)
19119 v.AddArg(x)
19120 return true
19121 }
19122 break
19123 }
19124
19125
19126 for {
19127 x := v_0
19128 if x != v_1 {
19129 break
19130 }
19131 v.reset(OpARM64MOVDconst)
19132 v.AuxInt = int64ToAuxInt(0)
19133 return true
19134 }
19135
19136
19137 for {
19138 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
19139 x := v_0
19140 if v_1.Op != OpARM64MVN {
19141 continue
19142 }
19143 y := v_1.Args[0]
19144 v.reset(OpARM64EON)
19145 v.AddArg2(x, y)
19146 return true
19147 }
19148 break
19149 }
19150
19151
19152
19153 for {
19154 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
19155 x0 := v_0
19156 x1 := v_1
19157 if x1.Op != OpARM64SLLconst {
19158 continue
19159 }
19160 c := auxIntToInt64(x1.AuxInt)
19161 y := x1.Args[0]
19162 if !(clobberIfDead(x1)) {
19163 continue
19164 }
19165 v.reset(OpARM64XORshiftLL)
19166 v.AuxInt = int64ToAuxInt(c)
19167 v.AddArg2(x0, y)
19168 return true
19169 }
19170 break
19171 }
19172
19173
19174
19175 for {
19176 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
19177 x0 := v_0
19178 x1 := v_1
19179 if x1.Op != OpARM64SRLconst {
19180 continue
19181 }
19182 c := auxIntToInt64(x1.AuxInt)
19183 y := x1.Args[0]
19184 if !(clobberIfDead(x1)) {
19185 continue
19186 }
19187 v.reset(OpARM64XORshiftRL)
19188 v.AuxInt = int64ToAuxInt(c)
19189 v.AddArg2(x0, y)
19190 return true
19191 }
19192 break
19193 }
19194
19195
19196
19197 for {
19198 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
19199 x0 := v_0
19200 x1 := v_1
19201 if x1.Op != OpARM64SRAconst {
19202 continue
19203 }
19204 c := auxIntToInt64(x1.AuxInt)
19205 y := x1.Args[0]
19206 if !(clobberIfDead(x1)) {
19207 continue
19208 }
19209 v.reset(OpARM64XORshiftRA)
19210 v.AuxInt = int64ToAuxInt(c)
19211 v.AddArg2(x0, y)
19212 return true
19213 }
19214 break
19215 }
19216
19217
19218
19219 for {
19220 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
19221 x0 := v_0
19222 x1 := v_1
19223 if x1.Op != OpARM64RORconst {
19224 continue
19225 }
19226 c := auxIntToInt64(x1.AuxInt)
19227 y := x1.Args[0]
19228 if !(clobberIfDead(x1)) {
19229 continue
19230 }
19231 v.reset(OpARM64XORshiftRO)
19232 v.AuxInt = int64ToAuxInt(c)
19233 v.AddArg2(x0, y)
19234 return true
19235 }
19236 break
19237 }
19238 return false
19239 }
19240 func rewriteValueARM64_OpARM64XORconst(v *Value) bool {
19241 v_0 := v.Args[0]
19242
19243
19244 for {
19245 if auxIntToInt64(v.AuxInt) != 0 {
19246 break
19247 }
19248 x := v_0
19249 v.copyOf(x)
19250 return true
19251 }
19252
19253
19254 for {
19255 if auxIntToInt64(v.AuxInt) != -1 {
19256 break
19257 }
19258 x := v_0
19259 v.reset(OpARM64MVN)
19260 v.AddArg(x)
19261 return true
19262 }
19263
19264
19265 for {
19266 c := auxIntToInt64(v.AuxInt)
19267 if v_0.Op != OpARM64MOVDconst {
19268 break
19269 }
19270 d := auxIntToInt64(v_0.AuxInt)
19271 v.reset(OpARM64MOVDconst)
19272 v.AuxInt = int64ToAuxInt(c ^ d)
19273 return true
19274 }
19275
19276
19277 for {
19278 c := auxIntToInt64(v.AuxInt)
19279 if v_0.Op != OpARM64XORconst {
19280 break
19281 }
19282 d := auxIntToInt64(v_0.AuxInt)
19283 x := v_0.Args[0]
19284 v.reset(OpARM64XORconst)
19285 v.AuxInt = int64ToAuxInt(c ^ d)
19286 v.AddArg(x)
19287 return true
19288 }
19289 return false
19290 }
19291 func rewriteValueARM64_OpARM64XORshiftLL(v *Value) bool {
19292 v_1 := v.Args[1]
19293 v_0 := v.Args[0]
19294 b := v.Block
19295 typ := &b.Func.Config.Types
19296
19297
19298 for {
19299 d := auxIntToInt64(v.AuxInt)
19300 if v_0.Op != OpARM64MOVDconst {
19301 break
19302 }
19303 c := auxIntToInt64(v_0.AuxInt)
19304 x := v_1
19305 v.reset(OpARM64XORconst)
19306 v.AuxInt = int64ToAuxInt(c)
19307 v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type)
19308 v0.AuxInt = int64ToAuxInt(d)
19309 v0.AddArg(x)
19310 v.AddArg(v0)
19311 return true
19312 }
19313
19314
19315 for {
19316 d := auxIntToInt64(v.AuxInt)
19317 x := v_0
19318 if v_1.Op != OpARM64MOVDconst {
19319 break
19320 }
19321 c := auxIntToInt64(v_1.AuxInt)
19322 v.reset(OpARM64XORconst)
19323 v.AuxInt = int64ToAuxInt(int64(uint64(c) << uint64(d)))
19324 v.AddArg(x)
19325 return true
19326 }
19327
19328
19329 for {
19330 c := auxIntToInt64(v.AuxInt)
19331 if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != c {
19332 break
19333 }
19334 x := v_0.Args[0]
19335 if x != v_1 {
19336 break
19337 }
19338 v.reset(OpARM64MOVDconst)
19339 v.AuxInt = int64ToAuxInt(0)
19340 return true
19341 }
19342
19343
19344 for {
19345 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) {
19346 break
19347 }
19348 x := v_0.Args[0]
19349 if x != v_1 {
19350 break
19351 }
19352 v.reset(OpARM64REV16W)
19353 v.AddArg(x)
19354 return true
19355 }
19356
19357
19358
19359 for {
19360 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64UBFX || auxIntToArm64BitField(v_0.AuxInt) != armBFAuxInt(8, 24) {
19361 break
19362 }
19363 v_0_0 := v_0.Args[0]
19364 if v_0_0.Op != OpARM64ANDconst {
19365 break
19366 }
19367 c1 := auxIntToInt64(v_0_0.AuxInt)
19368 x := v_0_0.Args[0]
19369 if v_1.Op != OpARM64ANDconst {
19370 break
19371 }
19372 c2 := auxIntToInt64(v_1.AuxInt)
19373 if x != v_1.Args[0] || !(uint32(c1) == 0xff00ff00 && uint32(c2) == 0x00ff00ff) {
19374 break
19375 }
19376 v.reset(OpARM64REV16W)
19377 v.AddArg(x)
19378 return true
19379 }
19380
19381
19382
19383 for {
19384 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
19385 break
19386 }
19387 v_0_0 := v_0.Args[0]
19388 if v_0_0.Op != OpARM64ANDconst {
19389 break
19390 }
19391 c1 := auxIntToInt64(v_0_0.AuxInt)
19392 x := v_0_0.Args[0]
19393 if v_1.Op != OpARM64ANDconst {
19394 break
19395 }
19396 c2 := auxIntToInt64(v_1.AuxInt)
19397 if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00ff00ff00 && uint64(c2) == 0x00ff00ff00ff00ff) {
19398 break
19399 }
19400 v.reset(OpARM64REV16)
19401 v.AddArg(x)
19402 return true
19403 }
19404
19405
19406
19407 for {
19408 if auxIntToInt64(v.AuxInt) != 8 || v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 8 {
19409 break
19410 }
19411 v_0_0 := v_0.Args[0]
19412 if v_0_0.Op != OpARM64ANDconst {
19413 break
19414 }
19415 c1 := auxIntToInt64(v_0_0.AuxInt)
19416 x := v_0_0.Args[0]
19417 if v_1.Op != OpARM64ANDconst {
19418 break
19419 }
19420 c2 := auxIntToInt64(v_1.AuxInt)
19421 if x != v_1.Args[0] || !(uint64(c1) == 0xff00ff00 && uint64(c2) == 0x00ff00ff) {
19422 break
19423 }
19424 v.reset(OpARM64REV16)
19425 v0 := b.NewValue0(v.Pos, OpARM64ANDconst, x.Type)
19426 v0.AuxInt = int64ToAuxInt(0xffffffff)
19427 v0.AddArg(x)
19428 v.AddArg(v0)
19429 return true
19430 }
19431
19432
19433 for {
19434 c := auxIntToInt64(v.AuxInt)
19435 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != 64-c {
19436 break
19437 }
19438 x := v_0.Args[0]
19439 x2 := v_1
19440 v.reset(OpARM64EXTRconst)
19441 v.AuxInt = int64ToAuxInt(64 - c)
19442 v.AddArg2(x2, x)
19443 return true
19444 }
19445
19446
19447
19448 for {
19449 t := v.Type
19450 c := auxIntToInt64(v.AuxInt)
19451 if v_0.Op != OpARM64UBFX {
19452 break
19453 }
19454 bfc := auxIntToArm64BitField(v_0.AuxInt)
19455 x := v_0.Args[0]
19456 x2 := v_1
19457 if !(c < 32 && t.Size() == 4 && bfc == armBFAuxInt(32-c, c)) {
19458 break
19459 }
19460 v.reset(OpARM64EXTRWconst)
19461 v.AuxInt = int64ToAuxInt(32 - c)
19462 v.AddArg2(x2, x)
19463 return true
19464 }
19465 return false
19466 }
19467 func rewriteValueARM64_OpARM64XORshiftRA(v *Value) bool {
19468 v_1 := v.Args[1]
19469 v_0 := v.Args[0]
19470 b := v.Block
19471
19472
19473 for {
19474 d := auxIntToInt64(v.AuxInt)
19475 if v_0.Op != OpARM64MOVDconst {
19476 break
19477 }
19478 c := auxIntToInt64(v_0.AuxInt)
19479 x := v_1
19480 v.reset(OpARM64XORconst)
19481 v.AuxInt = int64ToAuxInt(c)
19482 v0 := b.NewValue0(v.Pos, OpARM64SRAconst, x.Type)
19483 v0.AuxInt = int64ToAuxInt(d)
19484 v0.AddArg(x)
19485 v.AddArg(v0)
19486 return true
19487 }
19488
19489
19490 for {
19491 d := auxIntToInt64(v.AuxInt)
19492 x := v_0
19493 if v_1.Op != OpARM64MOVDconst {
19494 break
19495 }
19496 c := auxIntToInt64(v_1.AuxInt)
19497 v.reset(OpARM64XORconst)
19498 v.AuxInt = int64ToAuxInt(c >> uint64(d))
19499 v.AddArg(x)
19500 return true
19501 }
19502
19503
19504 for {
19505 c := auxIntToInt64(v.AuxInt)
19506 if v_0.Op != OpARM64SRAconst || auxIntToInt64(v_0.AuxInt) != c {
19507 break
19508 }
19509 x := v_0.Args[0]
19510 if x != v_1 {
19511 break
19512 }
19513 v.reset(OpARM64MOVDconst)
19514 v.AuxInt = int64ToAuxInt(0)
19515 return true
19516 }
19517 return false
19518 }
19519 func rewriteValueARM64_OpARM64XORshiftRL(v *Value) bool {
19520 v_1 := v.Args[1]
19521 v_0 := v.Args[0]
19522 b := v.Block
19523
19524
19525 for {
19526 d := auxIntToInt64(v.AuxInt)
19527 if v_0.Op != OpARM64MOVDconst {
19528 break
19529 }
19530 c := auxIntToInt64(v_0.AuxInt)
19531 x := v_1
19532 v.reset(OpARM64XORconst)
19533 v.AuxInt = int64ToAuxInt(c)
19534 v0 := b.NewValue0(v.Pos, OpARM64SRLconst, x.Type)
19535 v0.AuxInt = int64ToAuxInt(d)
19536 v0.AddArg(x)
19537 v.AddArg(v0)
19538 return true
19539 }
19540
19541
19542 for {
19543 d := auxIntToInt64(v.AuxInt)
19544 x := v_0
19545 if v_1.Op != OpARM64MOVDconst {
19546 break
19547 }
19548 c := auxIntToInt64(v_1.AuxInt)
19549 v.reset(OpARM64XORconst)
19550 v.AuxInt = int64ToAuxInt(int64(uint64(c) >> uint64(d)))
19551 v.AddArg(x)
19552 return true
19553 }
19554
19555
19556 for {
19557 c := auxIntToInt64(v.AuxInt)
19558 if v_0.Op != OpARM64SRLconst || auxIntToInt64(v_0.AuxInt) != c {
19559 break
19560 }
19561 x := v_0.Args[0]
19562 if x != v_1 {
19563 break
19564 }
19565 v.reset(OpARM64MOVDconst)
19566 v.AuxInt = int64ToAuxInt(0)
19567 return true
19568 }
19569 return false
19570 }
19571 func rewriteValueARM64_OpARM64XORshiftRO(v *Value) bool {
19572 v_1 := v.Args[1]
19573 v_0 := v.Args[0]
19574 b := v.Block
19575
19576
19577 for {
19578 d := auxIntToInt64(v.AuxInt)
19579 if v_0.Op != OpARM64MOVDconst {
19580 break
19581 }
19582 c := auxIntToInt64(v_0.AuxInt)
19583 x := v_1
19584 v.reset(OpARM64XORconst)
19585 v.AuxInt = int64ToAuxInt(c)
19586 v0 := b.NewValue0(v.Pos, OpARM64RORconst, x.Type)
19587 v0.AuxInt = int64ToAuxInt(d)
19588 v0.AddArg(x)
19589 v.AddArg(v0)
19590 return true
19591 }
19592
19593
19594 for {
19595 d := auxIntToInt64(v.AuxInt)
19596 x := v_0
19597 if v_1.Op != OpARM64MOVDconst {
19598 break
19599 }
19600 c := auxIntToInt64(v_1.AuxInt)
19601 v.reset(OpARM64XORconst)
19602 v.AuxInt = int64ToAuxInt(rotateRight64(c, d))
19603 v.AddArg(x)
19604 return true
19605 }
19606
19607
19608 for {
19609 c := auxIntToInt64(v.AuxInt)
19610 if v_0.Op != OpARM64RORconst || auxIntToInt64(v_0.AuxInt) != c {
19611 break
19612 }
19613 x := v_0.Args[0]
19614 if x != v_1 {
19615 break
19616 }
19617 v.reset(OpARM64MOVDconst)
19618 v.AuxInt = int64ToAuxInt(0)
19619 return true
19620 }
19621 return false
19622 }
19623 func rewriteValueARM64_OpAddr(v *Value) bool {
19624 v_0 := v.Args[0]
19625
19626
19627 for {
19628 sym := auxToSym(v.Aux)
19629 base := v_0
19630 v.reset(OpARM64MOVDaddr)
19631 v.Aux = symToAux(sym)
19632 v.AddArg(base)
19633 return true
19634 }
19635 }
19636 func rewriteValueARM64_OpAvg64u(v *Value) bool {
19637 v_1 := v.Args[1]
19638 v_0 := v.Args[0]
19639 b := v.Block
19640
19641
19642 for {
19643 t := v.Type
19644 x := v_0
19645 y := v_1
19646 v.reset(OpARM64ADD)
19647 v0 := b.NewValue0(v.Pos, OpARM64SRLconst, t)
19648 v0.AuxInt = int64ToAuxInt(1)
19649 v1 := b.NewValue0(v.Pos, OpARM64SUB, t)
19650 v1.AddArg2(x, y)
19651 v0.AddArg(v1)
19652 v.AddArg2(v0, y)
19653 return true
19654 }
19655 }
19656 func rewriteValueARM64_OpBitLen16(v *Value) bool {
19657 v_0 := v.Args[0]
19658 b := v.Block
19659 typ := &b.Func.Config.Types
19660
19661
19662 for {
19663 x := v_0
19664 v.reset(OpBitLen64)
19665 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
19666 v0.AddArg(x)
19667 v.AddArg(v0)
19668 return true
19669 }
19670 }
19671 func rewriteValueARM64_OpBitLen32(v *Value) bool {
19672 v_0 := v.Args[0]
19673 b := v.Block
19674 typ := &b.Func.Config.Types
19675
19676
19677 for {
19678 x := v_0
19679 v.reset(OpARM64SUB)
19680 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
19681 v0.AuxInt = int64ToAuxInt(32)
19682 v1 := b.NewValue0(v.Pos, OpARM64CLZW, typ.Int)
19683 v1.AddArg(x)
19684 v.AddArg2(v0, v1)
19685 return true
19686 }
19687 }
19688 func rewriteValueARM64_OpBitLen64(v *Value) bool {
19689 v_0 := v.Args[0]
19690 b := v.Block
19691 typ := &b.Func.Config.Types
19692
19693
19694 for {
19695 x := v_0
19696 v.reset(OpARM64SUB)
19697 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
19698 v0.AuxInt = int64ToAuxInt(64)
19699 v1 := b.NewValue0(v.Pos, OpARM64CLZ, typ.Int)
19700 v1.AddArg(x)
19701 v.AddArg2(v0, v1)
19702 return true
19703 }
19704 }
19705 func rewriteValueARM64_OpBitLen8(v *Value) bool {
19706 v_0 := v.Args[0]
19707 b := v.Block
19708 typ := &b.Func.Config.Types
19709
19710
19711 for {
19712 x := v_0
19713 v.reset(OpBitLen64)
19714 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
19715 v0.AddArg(x)
19716 v.AddArg(v0)
19717 return true
19718 }
19719 }
19720 func rewriteValueARM64_OpBitRev16(v *Value) bool {
19721 v_0 := v.Args[0]
19722 b := v.Block
19723 typ := &b.Func.Config.Types
19724
19725
19726 for {
19727 x := v_0
19728 v.reset(OpARM64SRLconst)
19729 v.AuxInt = int64ToAuxInt(48)
19730 v0 := b.NewValue0(v.Pos, OpARM64RBIT, typ.UInt64)
19731 v0.AddArg(x)
19732 v.AddArg(v0)
19733 return true
19734 }
19735 }
19736 func rewriteValueARM64_OpBitRev8(v *Value) bool {
19737 v_0 := v.Args[0]
19738 b := v.Block
19739 typ := &b.Func.Config.Types
19740
19741
19742 for {
19743 x := v_0
19744 v.reset(OpARM64SRLconst)
19745 v.AuxInt = int64ToAuxInt(56)
19746 v0 := b.NewValue0(v.Pos, OpARM64RBIT, typ.UInt64)
19747 v0.AddArg(x)
19748 v.AddArg(v0)
19749 return true
19750 }
19751 }
19752 func rewriteValueARM64_OpCondSelect(v *Value) bool {
19753 v_2 := v.Args[2]
19754 v_1 := v.Args[1]
19755 v_0 := v.Args[0]
19756 b := v.Block
19757
19758
19759
19760 for {
19761 x := v_0
19762 y := v_1
19763 boolval := v_2
19764 if !(flagArg(boolval) != nil) {
19765 break
19766 }
19767 v.reset(OpARM64CSEL)
19768 v.AuxInt = opToAuxInt(boolval.Op)
19769 v.AddArg3(x, y, flagArg(boolval))
19770 return true
19771 }
19772
19773
19774
19775 for {
19776 x := v_0
19777 y := v_1
19778 boolval := v_2
19779 if !(flagArg(boolval) == nil) {
19780 break
19781 }
19782 v.reset(OpARM64CSEL)
19783 v.AuxInt = opToAuxInt(OpARM64NotEqual)
19784 v0 := b.NewValue0(v.Pos, OpARM64TSTWconst, types.TypeFlags)
19785 v0.AuxInt = int32ToAuxInt(1)
19786 v0.AddArg(boolval)
19787 v.AddArg3(x, y, v0)
19788 return true
19789 }
19790 return false
19791 }
19792 func rewriteValueARM64_OpConst16(v *Value) bool {
19793
19794
19795 for {
19796 val := auxIntToInt16(v.AuxInt)
19797 v.reset(OpARM64MOVDconst)
19798 v.AuxInt = int64ToAuxInt(int64(val))
19799 return true
19800 }
19801 }
19802 func rewriteValueARM64_OpConst32(v *Value) bool {
19803
19804
19805 for {
19806 val := auxIntToInt32(v.AuxInt)
19807 v.reset(OpARM64MOVDconst)
19808 v.AuxInt = int64ToAuxInt(int64(val))
19809 return true
19810 }
19811 }
19812 func rewriteValueARM64_OpConst32F(v *Value) bool {
19813
19814
19815 for {
19816 val := auxIntToFloat32(v.AuxInt)
19817 v.reset(OpARM64FMOVSconst)
19818 v.AuxInt = float64ToAuxInt(float64(val))
19819 return true
19820 }
19821 }
19822 func rewriteValueARM64_OpConst64(v *Value) bool {
19823
19824
19825 for {
19826 val := auxIntToInt64(v.AuxInt)
19827 v.reset(OpARM64MOVDconst)
19828 v.AuxInt = int64ToAuxInt(int64(val))
19829 return true
19830 }
19831 }
19832 func rewriteValueARM64_OpConst64F(v *Value) bool {
19833
19834
19835 for {
19836 val := auxIntToFloat64(v.AuxInt)
19837 v.reset(OpARM64FMOVDconst)
19838 v.AuxInt = float64ToAuxInt(float64(val))
19839 return true
19840 }
19841 }
19842 func rewriteValueARM64_OpConst8(v *Value) bool {
19843
19844
19845 for {
19846 val := auxIntToInt8(v.AuxInt)
19847 v.reset(OpARM64MOVDconst)
19848 v.AuxInt = int64ToAuxInt(int64(val))
19849 return true
19850 }
19851 }
19852 func rewriteValueARM64_OpConstBool(v *Value) bool {
19853
19854
19855 for {
19856 t := auxIntToBool(v.AuxInt)
19857 v.reset(OpARM64MOVDconst)
19858 v.AuxInt = int64ToAuxInt(b2i(t))
19859 return true
19860 }
19861 }
19862 func rewriteValueARM64_OpConstNil(v *Value) bool {
19863
19864
19865 for {
19866 v.reset(OpARM64MOVDconst)
19867 v.AuxInt = int64ToAuxInt(0)
19868 return true
19869 }
19870 }
19871 func rewriteValueARM64_OpCtz16(v *Value) bool {
19872 v_0 := v.Args[0]
19873 b := v.Block
19874 typ := &b.Func.Config.Types
19875
19876
19877 for {
19878 t := v.Type
19879 x := v_0
19880 v.reset(OpARM64CLZW)
19881 v.Type = t
19882 v0 := b.NewValue0(v.Pos, OpARM64RBITW, typ.UInt32)
19883 v1 := b.NewValue0(v.Pos, OpARM64ORconst, typ.UInt32)
19884 v1.AuxInt = int64ToAuxInt(0x10000)
19885 v1.AddArg(x)
19886 v0.AddArg(v1)
19887 v.AddArg(v0)
19888 return true
19889 }
19890 }
19891 func rewriteValueARM64_OpCtz32(v *Value) bool {
19892 v_0 := v.Args[0]
19893 b := v.Block
19894
19895
19896 for {
19897 t := v.Type
19898 x := v_0
19899 v.reset(OpARM64CLZW)
19900 v0 := b.NewValue0(v.Pos, OpARM64RBITW, t)
19901 v0.AddArg(x)
19902 v.AddArg(v0)
19903 return true
19904 }
19905 }
19906 func rewriteValueARM64_OpCtz64(v *Value) bool {
19907 v_0 := v.Args[0]
19908 b := v.Block
19909
19910
19911 for {
19912 t := v.Type
19913 x := v_0
19914 v.reset(OpARM64CLZ)
19915 v0 := b.NewValue0(v.Pos, OpARM64RBIT, t)
19916 v0.AddArg(x)
19917 v.AddArg(v0)
19918 return true
19919 }
19920 }
19921 func rewriteValueARM64_OpCtz8(v *Value) bool {
19922 v_0 := v.Args[0]
19923 b := v.Block
19924 typ := &b.Func.Config.Types
19925
19926
19927 for {
19928 t := v.Type
19929 x := v_0
19930 v.reset(OpARM64CLZW)
19931 v.Type = t
19932 v0 := b.NewValue0(v.Pos, OpARM64RBITW, typ.UInt32)
19933 v1 := b.NewValue0(v.Pos, OpARM64ORconst, typ.UInt32)
19934 v1.AuxInt = int64ToAuxInt(0x100)
19935 v1.AddArg(x)
19936 v0.AddArg(v1)
19937 v.AddArg(v0)
19938 return true
19939 }
19940 }
19941 func rewriteValueARM64_OpDiv16(v *Value) bool {
19942 v_1 := v.Args[1]
19943 v_0 := v.Args[0]
19944 b := v.Block
19945 typ := &b.Func.Config.Types
19946
19947
19948 for {
19949 if auxIntToBool(v.AuxInt) != false {
19950 break
19951 }
19952 x := v_0
19953 y := v_1
19954 v.reset(OpARM64DIVW)
19955 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
19956 v0.AddArg(x)
19957 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
19958 v1.AddArg(y)
19959 v.AddArg2(v0, v1)
19960 return true
19961 }
19962 return false
19963 }
19964 func rewriteValueARM64_OpDiv16u(v *Value) bool {
19965 v_1 := v.Args[1]
19966 v_0 := v.Args[0]
19967 b := v.Block
19968 typ := &b.Func.Config.Types
19969
19970
19971 for {
19972 x := v_0
19973 y := v_1
19974 v.reset(OpARM64UDIVW)
19975 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
19976 v0.AddArg(x)
19977 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
19978 v1.AddArg(y)
19979 v.AddArg2(v0, v1)
19980 return true
19981 }
19982 }
19983 func rewriteValueARM64_OpDiv32(v *Value) bool {
19984 v_1 := v.Args[1]
19985 v_0 := v.Args[0]
19986
19987
19988 for {
19989 if auxIntToBool(v.AuxInt) != false {
19990 break
19991 }
19992 x := v_0
19993 y := v_1
19994 v.reset(OpARM64DIVW)
19995 v.AddArg2(x, y)
19996 return true
19997 }
19998 return false
19999 }
20000 func rewriteValueARM64_OpDiv64(v *Value) bool {
20001 v_1 := v.Args[1]
20002 v_0 := v.Args[0]
20003
20004
20005 for {
20006 if auxIntToBool(v.AuxInt) != false {
20007 break
20008 }
20009 x := v_0
20010 y := v_1
20011 v.reset(OpARM64DIV)
20012 v.AddArg2(x, y)
20013 return true
20014 }
20015 return false
20016 }
20017 func rewriteValueARM64_OpDiv8(v *Value) bool {
20018 v_1 := v.Args[1]
20019 v_0 := v.Args[0]
20020 b := v.Block
20021 typ := &b.Func.Config.Types
20022
20023
20024 for {
20025 x := v_0
20026 y := v_1
20027 v.reset(OpARM64DIVW)
20028 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
20029 v0.AddArg(x)
20030 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
20031 v1.AddArg(y)
20032 v.AddArg2(v0, v1)
20033 return true
20034 }
20035 }
20036 func rewriteValueARM64_OpDiv8u(v *Value) bool {
20037 v_1 := v.Args[1]
20038 v_0 := v.Args[0]
20039 b := v.Block
20040 typ := &b.Func.Config.Types
20041
20042
20043 for {
20044 x := v_0
20045 y := v_1
20046 v.reset(OpARM64UDIVW)
20047 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20048 v0.AddArg(x)
20049 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20050 v1.AddArg(y)
20051 v.AddArg2(v0, v1)
20052 return true
20053 }
20054 }
20055 func rewriteValueARM64_OpEq16(v *Value) bool {
20056 v_1 := v.Args[1]
20057 v_0 := v.Args[0]
20058 b := v.Block
20059 typ := &b.Func.Config.Types
20060
20061
20062 for {
20063 x := v_0
20064 y := v_1
20065 v.reset(OpARM64Equal)
20066 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20067 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20068 v1.AddArg(x)
20069 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20070 v2.AddArg(y)
20071 v0.AddArg2(v1, v2)
20072 v.AddArg(v0)
20073 return true
20074 }
20075 }
20076 func rewriteValueARM64_OpEq32(v *Value) bool {
20077 v_1 := v.Args[1]
20078 v_0 := v.Args[0]
20079 b := v.Block
20080
20081
20082 for {
20083 x := v_0
20084 y := v_1
20085 v.reset(OpARM64Equal)
20086 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20087 v0.AddArg2(x, y)
20088 v.AddArg(v0)
20089 return true
20090 }
20091 }
20092 func rewriteValueARM64_OpEq32F(v *Value) bool {
20093 v_1 := v.Args[1]
20094 v_0 := v.Args[0]
20095 b := v.Block
20096
20097
20098 for {
20099 x := v_0
20100 y := v_1
20101 v.reset(OpARM64Equal)
20102 v0 := b.NewValue0(v.Pos, OpARM64FCMPS, types.TypeFlags)
20103 v0.AddArg2(x, y)
20104 v.AddArg(v0)
20105 return true
20106 }
20107 }
20108 func rewriteValueARM64_OpEq64(v *Value) bool {
20109 v_1 := v.Args[1]
20110 v_0 := v.Args[0]
20111 b := v.Block
20112
20113
20114 for {
20115 x := v_0
20116 y := v_1
20117 v.reset(OpARM64Equal)
20118 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
20119 v0.AddArg2(x, y)
20120 v.AddArg(v0)
20121 return true
20122 }
20123 }
20124 func rewriteValueARM64_OpEq64F(v *Value) bool {
20125 v_1 := v.Args[1]
20126 v_0 := v.Args[0]
20127 b := v.Block
20128
20129
20130 for {
20131 x := v_0
20132 y := v_1
20133 v.reset(OpARM64Equal)
20134 v0 := b.NewValue0(v.Pos, OpARM64FCMPD, types.TypeFlags)
20135 v0.AddArg2(x, y)
20136 v.AddArg(v0)
20137 return true
20138 }
20139 }
20140 func rewriteValueARM64_OpEq8(v *Value) bool {
20141 v_1 := v.Args[1]
20142 v_0 := v.Args[0]
20143 b := v.Block
20144 typ := &b.Func.Config.Types
20145
20146
20147 for {
20148 x := v_0
20149 y := v_1
20150 v.reset(OpARM64Equal)
20151 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20152 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20153 v1.AddArg(x)
20154 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20155 v2.AddArg(y)
20156 v0.AddArg2(v1, v2)
20157 v.AddArg(v0)
20158 return true
20159 }
20160 }
20161 func rewriteValueARM64_OpEqB(v *Value) bool {
20162 v_1 := v.Args[1]
20163 v_0 := v.Args[0]
20164 b := v.Block
20165 typ := &b.Func.Config.Types
20166
20167
20168 for {
20169 x := v_0
20170 y := v_1
20171 v.reset(OpARM64XOR)
20172 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20173 v0.AuxInt = int64ToAuxInt(1)
20174 v1 := b.NewValue0(v.Pos, OpARM64XOR, typ.Bool)
20175 v1.AddArg2(x, y)
20176 v.AddArg2(v0, v1)
20177 return true
20178 }
20179 }
20180 func rewriteValueARM64_OpEqPtr(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, OpARM64CMP, types.TypeFlags)
20191 v0.AddArg2(x, y)
20192 v.AddArg(v0)
20193 return true
20194 }
20195 }
20196 func rewriteValueARM64_OpFMA(v *Value) bool {
20197 v_2 := v.Args[2]
20198 v_1 := v.Args[1]
20199 v_0 := v.Args[0]
20200
20201
20202 for {
20203 x := v_0
20204 y := v_1
20205 z := v_2
20206 v.reset(OpARM64FMADDD)
20207 v.AddArg3(z, x, y)
20208 return true
20209 }
20210 }
20211 func rewriteValueARM64_OpHmul32(v *Value) bool {
20212 v_1 := v.Args[1]
20213 v_0 := v.Args[0]
20214 b := v.Block
20215 typ := &b.Func.Config.Types
20216
20217
20218 for {
20219 x := v_0
20220 y := v_1
20221 v.reset(OpARM64SRAconst)
20222 v.AuxInt = int64ToAuxInt(32)
20223 v0 := b.NewValue0(v.Pos, OpARM64MULL, typ.Int64)
20224 v0.AddArg2(x, y)
20225 v.AddArg(v0)
20226 return true
20227 }
20228 }
20229 func rewriteValueARM64_OpHmul32u(v *Value) bool {
20230 v_1 := v.Args[1]
20231 v_0 := v.Args[0]
20232 b := v.Block
20233 typ := &b.Func.Config.Types
20234
20235
20236 for {
20237 x := v_0
20238 y := v_1
20239 v.reset(OpARM64SRAconst)
20240 v.AuxInt = int64ToAuxInt(32)
20241 v0 := b.NewValue0(v.Pos, OpARM64UMULL, typ.UInt64)
20242 v0.AddArg2(x, y)
20243 v.AddArg(v0)
20244 return true
20245 }
20246 }
20247 func rewriteValueARM64_OpIsInBounds(v *Value) bool {
20248 v_1 := v.Args[1]
20249 v_0 := v.Args[0]
20250 b := v.Block
20251
20252
20253 for {
20254 idx := v_0
20255 len := v_1
20256 v.reset(OpARM64LessThanU)
20257 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
20258 v0.AddArg2(idx, len)
20259 v.AddArg(v0)
20260 return true
20261 }
20262 }
20263 func rewriteValueARM64_OpIsNonNil(v *Value) bool {
20264 v_0 := v.Args[0]
20265 b := v.Block
20266
20267
20268 for {
20269 ptr := v_0
20270 v.reset(OpARM64NotEqual)
20271 v0 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
20272 v0.AuxInt = int64ToAuxInt(0)
20273 v0.AddArg(ptr)
20274 v.AddArg(v0)
20275 return true
20276 }
20277 }
20278 func rewriteValueARM64_OpIsSliceInBounds(v *Value) bool {
20279 v_1 := v.Args[1]
20280 v_0 := v.Args[0]
20281 b := v.Block
20282
20283
20284 for {
20285 idx := v_0
20286 len := v_1
20287 v.reset(OpARM64LessEqualU)
20288 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
20289 v0.AddArg2(idx, len)
20290 v.AddArg(v0)
20291 return true
20292 }
20293 }
20294 func rewriteValueARM64_OpLeq16(v *Value) bool {
20295 v_1 := v.Args[1]
20296 v_0 := v.Args[0]
20297 b := v.Block
20298 typ := &b.Func.Config.Types
20299
20300
20301 for {
20302 x := v_0
20303 y := v_1
20304 v.reset(OpARM64LessEqual)
20305 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20306 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
20307 v1.AddArg(x)
20308 v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
20309 v2.AddArg(y)
20310 v0.AddArg2(v1, v2)
20311 v.AddArg(v0)
20312 return true
20313 }
20314 }
20315 func rewriteValueARM64_OpLeq16U(v *Value) bool {
20316 v_1 := v.Args[1]
20317 v_0 := v.Args[0]
20318 b := v.Block
20319 typ := &b.Func.Config.Types
20320
20321
20322 for {
20323 x := v_0
20324 zero := v_1
20325 if zero.Op != OpARM64MOVDconst || auxIntToInt64(zero.AuxInt) != 0 {
20326 break
20327 }
20328 v.reset(OpEq16)
20329 v.AddArg2(x, zero)
20330 return true
20331 }
20332
20333
20334 for {
20335 if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != 1 {
20336 break
20337 }
20338 x := v_1
20339 v.reset(OpNeq16)
20340 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20341 v0.AuxInt = int64ToAuxInt(0)
20342 v.AddArg2(v0, x)
20343 return true
20344 }
20345
20346
20347 for {
20348 x := v_0
20349 y := v_1
20350 v.reset(OpARM64LessEqualU)
20351 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20352 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20353 v1.AddArg(x)
20354 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20355 v2.AddArg(y)
20356 v0.AddArg2(v1, v2)
20357 v.AddArg(v0)
20358 return true
20359 }
20360 }
20361 func rewriteValueARM64_OpLeq32(v *Value) bool {
20362 v_1 := v.Args[1]
20363 v_0 := v.Args[0]
20364 b := v.Block
20365
20366
20367 for {
20368 x := v_0
20369 y := v_1
20370 v.reset(OpARM64LessEqual)
20371 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20372 v0.AddArg2(x, y)
20373 v.AddArg(v0)
20374 return true
20375 }
20376 }
20377 func rewriteValueARM64_OpLeq32F(v *Value) bool {
20378 v_1 := v.Args[1]
20379 v_0 := v.Args[0]
20380 b := v.Block
20381
20382
20383 for {
20384 x := v_0
20385 y := v_1
20386 v.reset(OpARM64LessEqualF)
20387 v0 := b.NewValue0(v.Pos, OpARM64FCMPS, types.TypeFlags)
20388 v0.AddArg2(x, y)
20389 v.AddArg(v0)
20390 return true
20391 }
20392 }
20393 func rewriteValueARM64_OpLeq32U(v *Value) bool {
20394 v_1 := v.Args[1]
20395 v_0 := v.Args[0]
20396 b := v.Block
20397 typ := &b.Func.Config.Types
20398
20399
20400 for {
20401 x := v_0
20402 zero := v_1
20403 if zero.Op != OpARM64MOVDconst || auxIntToInt64(zero.AuxInt) != 0 {
20404 break
20405 }
20406 v.reset(OpEq32)
20407 v.AddArg2(x, zero)
20408 return true
20409 }
20410
20411
20412 for {
20413 if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != 1 {
20414 break
20415 }
20416 x := v_1
20417 v.reset(OpNeq32)
20418 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20419 v0.AuxInt = int64ToAuxInt(0)
20420 v.AddArg2(v0, x)
20421 return true
20422 }
20423
20424
20425 for {
20426 x := v_0
20427 y := v_1
20428 v.reset(OpARM64LessEqualU)
20429 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20430 v0.AddArg2(x, y)
20431 v.AddArg(v0)
20432 return true
20433 }
20434 }
20435 func rewriteValueARM64_OpLeq64(v *Value) bool {
20436 v_1 := v.Args[1]
20437 v_0 := v.Args[0]
20438 b := v.Block
20439
20440
20441 for {
20442 x := v_0
20443 y := v_1
20444 v.reset(OpARM64LessEqual)
20445 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
20446 v0.AddArg2(x, y)
20447 v.AddArg(v0)
20448 return true
20449 }
20450 }
20451 func rewriteValueARM64_OpLeq64F(v *Value) bool {
20452 v_1 := v.Args[1]
20453 v_0 := v.Args[0]
20454 b := v.Block
20455
20456
20457 for {
20458 x := v_0
20459 y := v_1
20460 v.reset(OpARM64LessEqualF)
20461 v0 := b.NewValue0(v.Pos, OpARM64FCMPD, types.TypeFlags)
20462 v0.AddArg2(x, y)
20463 v.AddArg(v0)
20464 return true
20465 }
20466 }
20467 func rewriteValueARM64_OpLeq64U(v *Value) bool {
20468 v_1 := v.Args[1]
20469 v_0 := v.Args[0]
20470 b := v.Block
20471 typ := &b.Func.Config.Types
20472
20473
20474 for {
20475 x := v_0
20476 zero := v_1
20477 if zero.Op != OpARM64MOVDconst || auxIntToInt64(zero.AuxInt) != 0 {
20478 break
20479 }
20480 v.reset(OpEq64)
20481 v.AddArg2(x, zero)
20482 return true
20483 }
20484
20485
20486 for {
20487 if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != 1 {
20488 break
20489 }
20490 x := v_1
20491 v.reset(OpNeq64)
20492 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20493 v0.AuxInt = int64ToAuxInt(0)
20494 v.AddArg2(v0, x)
20495 return true
20496 }
20497
20498
20499 for {
20500 x := v_0
20501 y := v_1
20502 v.reset(OpARM64LessEqualU)
20503 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
20504 v0.AddArg2(x, y)
20505 v.AddArg(v0)
20506 return true
20507 }
20508 }
20509 func rewriteValueARM64_OpLeq8(v *Value) bool {
20510 v_1 := v.Args[1]
20511 v_0 := v.Args[0]
20512 b := v.Block
20513 typ := &b.Func.Config.Types
20514
20515
20516 for {
20517 x := v_0
20518 y := v_1
20519 v.reset(OpARM64LessEqual)
20520 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20521 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
20522 v1.AddArg(x)
20523 v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
20524 v2.AddArg(y)
20525 v0.AddArg2(v1, v2)
20526 v.AddArg(v0)
20527 return true
20528 }
20529 }
20530 func rewriteValueARM64_OpLeq8U(v *Value) bool {
20531 v_1 := v.Args[1]
20532 v_0 := v.Args[0]
20533 b := v.Block
20534 typ := &b.Func.Config.Types
20535
20536
20537 for {
20538 x := v_0
20539 zero := v_1
20540 if zero.Op != OpARM64MOVDconst || auxIntToInt64(zero.AuxInt) != 0 {
20541 break
20542 }
20543 v.reset(OpEq8)
20544 v.AddArg2(x, zero)
20545 return true
20546 }
20547
20548
20549 for {
20550 if v_0.Op != OpARM64MOVDconst || auxIntToInt64(v_0.AuxInt) != 1 {
20551 break
20552 }
20553 x := v_1
20554 v.reset(OpNeq8)
20555 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20556 v0.AuxInt = int64ToAuxInt(0)
20557 v.AddArg2(v0, x)
20558 return true
20559 }
20560
20561
20562 for {
20563 x := v_0
20564 y := v_1
20565 v.reset(OpARM64LessEqualU)
20566 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20567 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20568 v1.AddArg(x)
20569 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20570 v2.AddArg(y)
20571 v0.AddArg2(v1, v2)
20572 v.AddArg(v0)
20573 return true
20574 }
20575 }
20576 func rewriteValueARM64_OpLess16(v *Value) bool {
20577 v_1 := v.Args[1]
20578 v_0 := v.Args[0]
20579 b := v.Block
20580 typ := &b.Func.Config.Types
20581
20582
20583 for {
20584 x := v_0
20585 y := v_1
20586 v.reset(OpARM64LessThan)
20587 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20588 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
20589 v1.AddArg(x)
20590 v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
20591 v2.AddArg(y)
20592 v0.AddArg2(v1, v2)
20593 v.AddArg(v0)
20594 return true
20595 }
20596 }
20597 func rewriteValueARM64_OpLess16U(v *Value) bool {
20598 v_1 := v.Args[1]
20599 v_0 := v.Args[0]
20600 b := v.Block
20601 typ := &b.Func.Config.Types
20602
20603
20604 for {
20605 zero := v_0
20606 if zero.Op != OpARM64MOVDconst || auxIntToInt64(zero.AuxInt) != 0 {
20607 break
20608 }
20609 x := v_1
20610 v.reset(OpNeq16)
20611 v.AddArg2(zero, x)
20612 return true
20613 }
20614
20615
20616 for {
20617 x := v_0
20618 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
20619 break
20620 }
20621 v.reset(OpEq16)
20622 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20623 v0.AuxInt = int64ToAuxInt(0)
20624 v.AddArg2(x, v0)
20625 return true
20626 }
20627
20628
20629 for {
20630 x := v_0
20631 y := v_1
20632 v.reset(OpARM64LessThanU)
20633 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20634 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20635 v1.AddArg(x)
20636 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
20637 v2.AddArg(y)
20638 v0.AddArg2(v1, v2)
20639 v.AddArg(v0)
20640 return true
20641 }
20642 }
20643 func rewriteValueARM64_OpLess32(v *Value) bool {
20644 v_1 := v.Args[1]
20645 v_0 := v.Args[0]
20646 b := v.Block
20647
20648
20649 for {
20650 x := v_0
20651 y := v_1
20652 v.reset(OpARM64LessThan)
20653 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20654 v0.AddArg2(x, y)
20655 v.AddArg(v0)
20656 return true
20657 }
20658 }
20659 func rewriteValueARM64_OpLess32F(v *Value) bool {
20660 v_1 := v.Args[1]
20661 v_0 := v.Args[0]
20662 b := v.Block
20663
20664
20665 for {
20666 x := v_0
20667 y := v_1
20668 v.reset(OpARM64LessThanF)
20669 v0 := b.NewValue0(v.Pos, OpARM64FCMPS, types.TypeFlags)
20670 v0.AddArg2(x, y)
20671 v.AddArg(v0)
20672 return true
20673 }
20674 }
20675 func rewriteValueARM64_OpLess32U(v *Value) bool {
20676 v_1 := v.Args[1]
20677 v_0 := v.Args[0]
20678 b := v.Block
20679 typ := &b.Func.Config.Types
20680
20681
20682 for {
20683 zero := v_0
20684 if zero.Op != OpARM64MOVDconst || auxIntToInt64(zero.AuxInt) != 0 {
20685 break
20686 }
20687 x := v_1
20688 v.reset(OpNeq32)
20689 v.AddArg2(zero, x)
20690 return true
20691 }
20692
20693
20694 for {
20695 x := v_0
20696 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
20697 break
20698 }
20699 v.reset(OpEq32)
20700 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20701 v0.AuxInt = int64ToAuxInt(0)
20702 v.AddArg2(x, v0)
20703 return true
20704 }
20705
20706
20707 for {
20708 x := v_0
20709 y := v_1
20710 v.reset(OpARM64LessThanU)
20711 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20712 v0.AddArg2(x, y)
20713 v.AddArg(v0)
20714 return true
20715 }
20716 }
20717 func rewriteValueARM64_OpLess64(v *Value) bool {
20718 v_1 := v.Args[1]
20719 v_0 := v.Args[0]
20720 b := v.Block
20721
20722
20723 for {
20724 x := v_0
20725 y := v_1
20726 v.reset(OpARM64LessThan)
20727 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
20728 v0.AddArg2(x, y)
20729 v.AddArg(v0)
20730 return true
20731 }
20732 }
20733 func rewriteValueARM64_OpLess64F(v *Value) bool {
20734 v_1 := v.Args[1]
20735 v_0 := v.Args[0]
20736 b := v.Block
20737
20738
20739 for {
20740 x := v_0
20741 y := v_1
20742 v.reset(OpARM64LessThanF)
20743 v0 := b.NewValue0(v.Pos, OpARM64FCMPD, types.TypeFlags)
20744 v0.AddArg2(x, y)
20745 v.AddArg(v0)
20746 return true
20747 }
20748 }
20749 func rewriteValueARM64_OpLess64U(v *Value) bool {
20750 v_1 := v.Args[1]
20751 v_0 := v.Args[0]
20752 b := v.Block
20753 typ := &b.Func.Config.Types
20754
20755
20756 for {
20757 zero := v_0
20758 if zero.Op != OpARM64MOVDconst || auxIntToInt64(zero.AuxInt) != 0 {
20759 break
20760 }
20761 x := v_1
20762 v.reset(OpNeq64)
20763 v.AddArg2(zero, x)
20764 return true
20765 }
20766
20767
20768 for {
20769 x := v_0
20770 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
20771 break
20772 }
20773 v.reset(OpEq64)
20774 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20775 v0.AuxInt = int64ToAuxInt(0)
20776 v.AddArg2(x, v0)
20777 return true
20778 }
20779
20780
20781 for {
20782 x := v_0
20783 y := v_1
20784 v.reset(OpARM64LessThanU)
20785 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
20786 v0.AddArg2(x, y)
20787 v.AddArg(v0)
20788 return true
20789 }
20790 }
20791 func rewriteValueARM64_OpLess8(v *Value) bool {
20792 v_1 := v.Args[1]
20793 v_0 := v.Args[0]
20794 b := v.Block
20795 typ := &b.Func.Config.Types
20796
20797
20798 for {
20799 x := v_0
20800 y := v_1
20801 v.reset(OpARM64LessThan)
20802 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20803 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
20804 v1.AddArg(x)
20805 v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
20806 v2.AddArg(y)
20807 v0.AddArg2(v1, v2)
20808 v.AddArg(v0)
20809 return true
20810 }
20811 }
20812 func rewriteValueARM64_OpLess8U(v *Value) bool {
20813 v_1 := v.Args[1]
20814 v_0 := v.Args[0]
20815 b := v.Block
20816 typ := &b.Func.Config.Types
20817
20818
20819 for {
20820 zero := v_0
20821 if zero.Op != OpARM64MOVDconst || auxIntToInt64(zero.AuxInt) != 0 {
20822 break
20823 }
20824 x := v_1
20825 v.reset(OpNeq8)
20826 v.AddArg2(zero, x)
20827 return true
20828 }
20829
20830
20831 for {
20832 x := v_0
20833 if v_1.Op != OpARM64MOVDconst || auxIntToInt64(v_1.AuxInt) != 1 {
20834 break
20835 }
20836 v.reset(OpEq8)
20837 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
20838 v0.AuxInt = int64ToAuxInt(0)
20839 v.AddArg2(x, v0)
20840 return true
20841 }
20842
20843
20844 for {
20845 x := v_0
20846 y := v_1
20847 v.reset(OpARM64LessThanU)
20848 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
20849 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20850 v1.AddArg(x)
20851 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
20852 v2.AddArg(y)
20853 v0.AddArg2(v1, v2)
20854 v.AddArg(v0)
20855 return true
20856 }
20857 }
20858 func rewriteValueARM64_OpLoad(v *Value) bool {
20859 v_1 := v.Args[1]
20860 v_0 := v.Args[0]
20861
20862
20863
20864 for {
20865 t := v.Type
20866 ptr := v_0
20867 mem := v_1
20868 if !(t.IsBoolean()) {
20869 break
20870 }
20871 v.reset(OpARM64MOVBUload)
20872 v.AddArg2(ptr, mem)
20873 return true
20874 }
20875
20876
20877
20878 for {
20879 t := v.Type
20880 ptr := v_0
20881 mem := v_1
20882 if !(is8BitInt(t) && t.IsSigned()) {
20883 break
20884 }
20885 v.reset(OpARM64MOVBload)
20886 v.AddArg2(ptr, mem)
20887 return true
20888 }
20889
20890
20891
20892 for {
20893 t := v.Type
20894 ptr := v_0
20895 mem := v_1
20896 if !(is8BitInt(t) && !t.IsSigned()) {
20897 break
20898 }
20899 v.reset(OpARM64MOVBUload)
20900 v.AddArg2(ptr, mem)
20901 return true
20902 }
20903
20904
20905
20906 for {
20907 t := v.Type
20908 ptr := v_0
20909 mem := v_1
20910 if !(is16BitInt(t) && t.IsSigned()) {
20911 break
20912 }
20913 v.reset(OpARM64MOVHload)
20914 v.AddArg2(ptr, mem)
20915 return true
20916 }
20917
20918
20919
20920 for {
20921 t := v.Type
20922 ptr := v_0
20923 mem := v_1
20924 if !(is16BitInt(t) && !t.IsSigned()) {
20925 break
20926 }
20927 v.reset(OpARM64MOVHUload)
20928 v.AddArg2(ptr, mem)
20929 return true
20930 }
20931
20932
20933
20934 for {
20935 t := v.Type
20936 ptr := v_0
20937 mem := v_1
20938 if !(is32BitInt(t) && t.IsSigned()) {
20939 break
20940 }
20941 v.reset(OpARM64MOVWload)
20942 v.AddArg2(ptr, mem)
20943 return true
20944 }
20945
20946
20947
20948 for {
20949 t := v.Type
20950 ptr := v_0
20951 mem := v_1
20952 if !(is32BitInt(t) && !t.IsSigned()) {
20953 break
20954 }
20955 v.reset(OpARM64MOVWUload)
20956 v.AddArg2(ptr, mem)
20957 return true
20958 }
20959
20960
20961
20962 for {
20963 t := v.Type
20964 ptr := v_0
20965 mem := v_1
20966 if !(is64BitInt(t) || isPtr(t)) {
20967 break
20968 }
20969 v.reset(OpARM64MOVDload)
20970 v.AddArg2(ptr, mem)
20971 return true
20972 }
20973
20974
20975
20976 for {
20977 t := v.Type
20978 ptr := v_0
20979 mem := v_1
20980 if !(is32BitFloat(t)) {
20981 break
20982 }
20983 v.reset(OpARM64FMOVSload)
20984 v.AddArg2(ptr, mem)
20985 return true
20986 }
20987
20988
20989
20990 for {
20991 t := v.Type
20992 ptr := v_0
20993 mem := v_1
20994 if !(is64BitFloat(t)) {
20995 break
20996 }
20997 v.reset(OpARM64FMOVDload)
20998 v.AddArg2(ptr, mem)
20999 return true
21000 }
21001
21002
21003
21004 for {
21005 t := v.Type
21006 ptr := v_0
21007 mem := v_1
21008 if !(t.Size() == 16) {
21009 break
21010 }
21011 v.reset(OpARM64FMOVQload)
21012 v.AddArg2(ptr, mem)
21013 return true
21014 }
21015 return false
21016 }
21017 func rewriteValueARM64_OpLocalAddr(v *Value) bool {
21018 v_1 := v.Args[1]
21019 v_0 := v.Args[0]
21020 b := v.Block
21021 typ := &b.Func.Config.Types
21022
21023
21024
21025 for {
21026 t := v.Type
21027 sym := auxToSym(v.Aux)
21028 base := v_0
21029 mem := v_1
21030 if !(t.Elem().HasPointers()) {
21031 break
21032 }
21033 v.reset(OpARM64MOVDaddr)
21034 v.Aux = symToAux(sym)
21035 v0 := b.NewValue0(v.Pos, OpSPanchored, typ.Uintptr)
21036 v0.AddArg2(base, mem)
21037 v.AddArg(v0)
21038 return true
21039 }
21040
21041
21042
21043 for {
21044 t := v.Type
21045 sym := auxToSym(v.Aux)
21046 base := v_0
21047 if !(!t.Elem().HasPointers()) {
21048 break
21049 }
21050 v.reset(OpARM64MOVDaddr)
21051 v.Aux = symToAux(sym)
21052 v.AddArg(base)
21053 return true
21054 }
21055 return false
21056 }
21057 func rewriteValueARM64_OpLsh64x16(v *Value) bool {
21058 v_1 := v.Args[1]
21059 v_0 := v.Args[0]
21060 b := v.Block
21061 typ := &b.Func.Config.Types
21062
21063
21064
21065 for {
21066 t := v.Type
21067 x := v_0
21068 y := v_1
21069 if !(shiftIsBounded(v)) {
21070 break
21071 }
21072 v.reset(OpARM64SLL)
21073 v.Type = t
21074 v.AddArg2(x, y)
21075 return true
21076 }
21077
21078
21079
21080 for {
21081 t := v.Type
21082 bounded := auxIntToBool(v.AuxInt)
21083 x := v_0
21084 y := v_1
21085 if !(!shiftIsBounded(v)) {
21086 break
21087 }
21088 v.reset(OpLsh64x32)
21089 v.Type = t
21090 v.AuxInt = boolToAuxInt(bounded)
21091 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
21092 v0.AddArg(y)
21093 v.AddArg2(x, v0)
21094 return true
21095 }
21096 return false
21097 }
21098 func rewriteValueARM64_OpLsh64x32(v *Value) bool {
21099 v_1 := v.Args[1]
21100 v_0 := v.Args[0]
21101 b := v.Block
21102
21103
21104
21105 for {
21106 t := v.Type
21107 x := v_0
21108 y := v_1
21109 if !(shiftIsBounded(v)) {
21110 break
21111 }
21112 v.reset(OpARM64SLL)
21113 v.Type = t
21114 v.AddArg2(x, y)
21115 return true
21116 }
21117
21118
21119
21120 for {
21121 t := v.Type
21122 x := v_0
21123 y := v_1
21124 if !(!shiftIsBounded(v)) {
21125 break
21126 }
21127 v.reset(OpARM64CSEL)
21128 v.AuxInt = opToAuxInt(OpARM64LessThanU)
21129 v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
21130 v0.AddArg2(x, y)
21131 v1 := b.NewValue0(v.Pos, OpConst64, t)
21132 v1.AuxInt = int64ToAuxInt(0)
21133 v2 := b.NewValue0(v.Pos, OpARM64CMPWconst, types.TypeFlags)
21134 v2.AuxInt = int32ToAuxInt(64)
21135 v2.AddArg(y)
21136 v.AddArg3(v0, v1, v2)
21137 return true
21138 }
21139 return false
21140 }
21141 func rewriteValueARM64_OpLsh64x64(v *Value) bool {
21142 v_1 := v.Args[1]
21143 v_0 := v.Args[0]
21144 b := v.Block
21145
21146
21147
21148 for {
21149 t := v.Type
21150 x := v_0
21151 y := v_1
21152 if !(shiftIsBounded(v)) {
21153 break
21154 }
21155 v.reset(OpARM64SLL)
21156 v.Type = t
21157 v.AddArg2(x, y)
21158 return true
21159 }
21160
21161
21162
21163 for {
21164 t := v.Type
21165 x := v_0
21166 y := v_1
21167 if !(!shiftIsBounded(v)) {
21168 break
21169 }
21170 v.reset(OpARM64CSEL)
21171 v.AuxInt = opToAuxInt(OpARM64LessThanU)
21172 v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
21173 v0.AddArg2(x, y)
21174 v1 := b.NewValue0(v.Pos, OpConst64, t)
21175 v1.AuxInt = int64ToAuxInt(0)
21176 v2 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
21177 v2.AuxInt = int64ToAuxInt(64)
21178 v2.AddArg(y)
21179 v.AddArg3(v0, v1, v2)
21180 return true
21181 }
21182 return false
21183 }
21184 func rewriteValueARM64_OpLsh64x8(v *Value) bool {
21185 v_1 := v.Args[1]
21186 v_0 := v.Args[0]
21187 b := v.Block
21188 typ := &b.Func.Config.Types
21189
21190
21191
21192 for {
21193 t := v.Type
21194 x := v_0
21195 y := v_1
21196 if !(shiftIsBounded(v)) {
21197 break
21198 }
21199 v.reset(OpARM64SLL)
21200 v.Type = t
21201 v.AddArg2(x, y)
21202 return true
21203 }
21204
21205
21206
21207 for {
21208 t := v.Type
21209 bounded := auxIntToBool(v.AuxInt)
21210 x := v_0
21211 y := v_1
21212 if !(!shiftIsBounded(v)) {
21213 break
21214 }
21215 v.reset(OpLsh64x32)
21216 v.Type = t
21217 v.AuxInt = boolToAuxInt(bounded)
21218 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
21219 v0.AddArg(y)
21220 v.AddArg2(x, v0)
21221 return true
21222 }
21223 return false
21224 }
21225 func rewriteValueARM64_OpMax32FSel(v *Value) bool {
21226 v_1 := v.Args[1]
21227 v_0 := v.Args[0]
21228 b := v.Block
21229
21230
21231 for {
21232 x := v_0
21233 y := v_1
21234 v.reset(OpARM64FCSELS)
21235 v.AuxInt = opToAuxInt(OpARM64GreaterThanF)
21236 v0 := b.NewValue0(v.Pos, OpARM64FCMPS, types.TypeFlags)
21237 v0.AddArg2(x, y)
21238 v.AddArg3(x, y, v0)
21239 return true
21240 }
21241 }
21242 func rewriteValueARM64_OpMax64FSel(v *Value) bool {
21243 v_1 := v.Args[1]
21244 v_0 := v.Args[0]
21245 b := v.Block
21246
21247
21248 for {
21249 x := v_0
21250 y := v_1
21251 v.reset(OpARM64FCSELD)
21252 v.AuxInt = opToAuxInt(OpARM64GreaterThanF)
21253 v0 := b.NewValue0(v.Pos, OpARM64FCMPD, types.TypeFlags)
21254 v0.AddArg2(x, y)
21255 v.AddArg3(x, y, v0)
21256 return true
21257 }
21258 }
21259 func rewriteValueARM64_OpMin32FSel(v *Value) bool {
21260 v_1 := v.Args[1]
21261 v_0 := v.Args[0]
21262 b := v.Block
21263
21264
21265 for {
21266 x := v_0
21267 y := v_1
21268 v.reset(OpARM64FCSELS)
21269 v.AuxInt = opToAuxInt(OpARM64LessThanF)
21270 v0 := b.NewValue0(v.Pos, OpARM64FCMPS, types.TypeFlags)
21271 v0.AddArg2(x, y)
21272 v.AddArg3(x, y, v0)
21273 return true
21274 }
21275 }
21276 func rewriteValueARM64_OpMin64FSel(v *Value) bool {
21277 v_1 := v.Args[1]
21278 v_0 := v.Args[0]
21279 b := v.Block
21280
21281
21282 for {
21283 x := v_0
21284 y := v_1
21285 v.reset(OpARM64FCSELD)
21286 v.AuxInt = opToAuxInt(OpARM64LessThanF)
21287 v0 := b.NewValue0(v.Pos, OpARM64FCMPD, types.TypeFlags)
21288 v0.AddArg2(x, y)
21289 v.AddArg3(x, y, v0)
21290 return true
21291 }
21292 }
21293 func rewriteValueARM64_OpMod16(v *Value) bool {
21294 v_1 := v.Args[1]
21295 v_0 := v.Args[0]
21296 b := v.Block
21297 typ := &b.Func.Config.Types
21298
21299
21300 for {
21301 x := v_0
21302 y := v_1
21303 v.reset(OpARM64MODW)
21304 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
21305 v0.AddArg(x)
21306 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
21307 v1.AddArg(y)
21308 v.AddArg2(v0, v1)
21309 return true
21310 }
21311 }
21312 func rewriteValueARM64_OpMod16u(v *Value) bool {
21313 v_1 := v.Args[1]
21314 v_0 := v.Args[0]
21315 b := v.Block
21316 typ := &b.Func.Config.Types
21317
21318
21319 for {
21320 x := v_0
21321 y := v_1
21322 v.reset(OpARM64UMODW)
21323 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
21324 v0.AddArg(x)
21325 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
21326 v1.AddArg(y)
21327 v.AddArg2(v0, v1)
21328 return true
21329 }
21330 }
21331 func rewriteValueARM64_OpMod32(v *Value) bool {
21332 v_1 := v.Args[1]
21333 v_0 := v.Args[0]
21334
21335
21336 for {
21337 x := v_0
21338 y := v_1
21339 v.reset(OpARM64MODW)
21340 v.AddArg2(x, y)
21341 return true
21342 }
21343 }
21344 func rewriteValueARM64_OpMod64(v *Value) bool {
21345 v_1 := v.Args[1]
21346 v_0 := v.Args[0]
21347
21348
21349 for {
21350 x := v_0
21351 y := v_1
21352 v.reset(OpARM64MOD)
21353 v.AddArg2(x, y)
21354 return true
21355 }
21356 }
21357 func rewriteValueARM64_OpMod8(v *Value) bool {
21358 v_1 := v.Args[1]
21359 v_0 := v.Args[0]
21360 b := v.Block
21361 typ := &b.Func.Config.Types
21362
21363
21364 for {
21365 x := v_0
21366 y := v_1
21367 v.reset(OpARM64MODW)
21368 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
21369 v0.AddArg(x)
21370 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
21371 v1.AddArg(y)
21372 v.AddArg2(v0, v1)
21373 return true
21374 }
21375 }
21376 func rewriteValueARM64_OpMod8u(v *Value) bool {
21377 v_1 := v.Args[1]
21378 v_0 := v.Args[0]
21379 b := v.Block
21380 typ := &b.Func.Config.Types
21381
21382
21383 for {
21384 x := v_0
21385 y := v_1
21386 v.reset(OpARM64UMODW)
21387 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
21388 v0.AddArg(x)
21389 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
21390 v1.AddArg(y)
21391 v.AddArg2(v0, v1)
21392 return true
21393 }
21394 }
21395 func rewriteValueARM64_OpMove(v *Value) bool {
21396 v_2 := v.Args[2]
21397 v_1 := v.Args[1]
21398 v_0 := v.Args[0]
21399 b := v.Block
21400 typ := &b.Func.Config.Types
21401
21402
21403 for {
21404 if auxIntToInt64(v.AuxInt) != 0 {
21405 break
21406 }
21407 mem := v_2
21408 v.copyOf(mem)
21409 return true
21410 }
21411
21412
21413 for {
21414 if auxIntToInt64(v.AuxInt) != 1 {
21415 break
21416 }
21417 dst := v_0
21418 src := v_1
21419 mem := v_2
21420 v.reset(OpARM64MOVBstore)
21421 v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, typ.UInt8)
21422 v0.AddArg2(src, mem)
21423 v.AddArg3(dst, v0, mem)
21424 return true
21425 }
21426
21427
21428 for {
21429 if auxIntToInt64(v.AuxInt) != 2 {
21430 break
21431 }
21432 dst := v_0
21433 src := v_1
21434 mem := v_2
21435 v.reset(OpARM64MOVHstore)
21436 v0 := b.NewValue0(v.Pos, OpARM64MOVHUload, typ.UInt16)
21437 v0.AddArg2(src, mem)
21438 v.AddArg3(dst, v0, mem)
21439 return true
21440 }
21441
21442
21443 for {
21444 if auxIntToInt64(v.AuxInt) != 3 {
21445 break
21446 }
21447 dst := v_0
21448 src := v_1
21449 mem := v_2
21450 v.reset(OpARM64MOVBstore)
21451 v.AuxInt = int32ToAuxInt(2)
21452 v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, typ.UInt8)
21453 v0.AuxInt = int32ToAuxInt(2)
21454 v0.AddArg2(src, mem)
21455 v1 := b.NewValue0(v.Pos, OpARM64MOVHstore, types.TypeMem)
21456 v2 := b.NewValue0(v.Pos, OpARM64MOVHUload, typ.UInt16)
21457 v2.AddArg2(src, mem)
21458 v1.AddArg3(dst, v2, mem)
21459 v.AddArg3(dst, v0, v1)
21460 return true
21461 }
21462
21463
21464 for {
21465 if auxIntToInt64(v.AuxInt) != 4 {
21466 break
21467 }
21468 dst := v_0
21469 src := v_1
21470 mem := v_2
21471 v.reset(OpARM64MOVWstore)
21472 v0 := b.NewValue0(v.Pos, OpARM64MOVWUload, typ.UInt32)
21473 v0.AddArg2(src, mem)
21474 v.AddArg3(dst, v0, mem)
21475 return true
21476 }
21477
21478
21479 for {
21480 if auxIntToInt64(v.AuxInt) != 5 {
21481 break
21482 }
21483 dst := v_0
21484 src := v_1
21485 mem := v_2
21486 v.reset(OpARM64MOVBstore)
21487 v.AuxInt = int32ToAuxInt(4)
21488 v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, typ.UInt8)
21489 v0.AuxInt = int32ToAuxInt(4)
21490 v0.AddArg2(src, mem)
21491 v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, types.TypeMem)
21492 v2 := b.NewValue0(v.Pos, OpARM64MOVWUload, typ.UInt32)
21493 v2.AddArg2(src, mem)
21494 v1.AddArg3(dst, v2, mem)
21495 v.AddArg3(dst, v0, v1)
21496 return true
21497 }
21498
21499
21500 for {
21501 if auxIntToInt64(v.AuxInt) != 6 {
21502 break
21503 }
21504 dst := v_0
21505 src := v_1
21506 mem := v_2
21507 v.reset(OpARM64MOVHstore)
21508 v.AuxInt = int32ToAuxInt(4)
21509 v0 := b.NewValue0(v.Pos, OpARM64MOVHUload, typ.UInt16)
21510 v0.AuxInt = int32ToAuxInt(4)
21511 v0.AddArg2(src, mem)
21512 v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, types.TypeMem)
21513 v2 := b.NewValue0(v.Pos, OpARM64MOVWUload, typ.UInt32)
21514 v2.AddArg2(src, mem)
21515 v1.AddArg3(dst, v2, mem)
21516 v.AddArg3(dst, v0, v1)
21517 return true
21518 }
21519
21520
21521 for {
21522 if auxIntToInt64(v.AuxInt) != 7 {
21523 break
21524 }
21525 dst := v_0
21526 src := v_1
21527 mem := v_2
21528 v.reset(OpARM64MOVWstore)
21529 v.AuxInt = int32ToAuxInt(3)
21530 v0 := b.NewValue0(v.Pos, OpARM64MOVWUload, typ.UInt32)
21531 v0.AuxInt = int32ToAuxInt(3)
21532 v0.AddArg2(src, mem)
21533 v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, types.TypeMem)
21534 v2 := b.NewValue0(v.Pos, OpARM64MOVWUload, typ.UInt32)
21535 v2.AddArg2(src, mem)
21536 v1.AddArg3(dst, v2, mem)
21537 v.AddArg3(dst, v0, v1)
21538 return true
21539 }
21540
21541
21542 for {
21543 if auxIntToInt64(v.AuxInt) != 8 {
21544 break
21545 }
21546 dst := v_0
21547 src := v_1
21548 mem := v_2
21549 v.reset(OpARM64MOVDstore)
21550 v0 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21551 v0.AddArg2(src, mem)
21552 v.AddArg3(dst, v0, mem)
21553 return true
21554 }
21555
21556
21557 for {
21558 if auxIntToInt64(v.AuxInt) != 9 {
21559 break
21560 }
21561 dst := v_0
21562 src := v_1
21563 mem := v_2
21564 v.reset(OpARM64MOVBstore)
21565 v.AuxInt = int32ToAuxInt(8)
21566 v0 := b.NewValue0(v.Pos, OpARM64MOVBUload, typ.UInt8)
21567 v0.AuxInt = int32ToAuxInt(8)
21568 v0.AddArg2(src, mem)
21569 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
21570 v2 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21571 v2.AddArg2(src, mem)
21572 v1.AddArg3(dst, v2, mem)
21573 v.AddArg3(dst, v0, v1)
21574 return true
21575 }
21576
21577
21578 for {
21579 if auxIntToInt64(v.AuxInt) != 10 {
21580 break
21581 }
21582 dst := v_0
21583 src := v_1
21584 mem := v_2
21585 v.reset(OpARM64MOVHstore)
21586 v.AuxInt = int32ToAuxInt(8)
21587 v0 := b.NewValue0(v.Pos, OpARM64MOVHUload, typ.UInt16)
21588 v0.AuxInt = int32ToAuxInt(8)
21589 v0.AddArg2(src, mem)
21590 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
21591 v2 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21592 v2.AddArg2(src, mem)
21593 v1.AddArg3(dst, v2, mem)
21594 v.AddArg3(dst, v0, v1)
21595 return true
21596 }
21597
21598
21599 for {
21600 if auxIntToInt64(v.AuxInt) != 11 {
21601 break
21602 }
21603 dst := v_0
21604 src := v_1
21605 mem := v_2
21606 v.reset(OpARM64MOVDstore)
21607 v.AuxInt = int32ToAuxInt(3)
21608 v0 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21609 v0.AuxInt = int32ToAuxInt(3)
21610 v0.AddArg2(src, mem)
21611 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
21612 v2 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21613 v2.AddArg2(src, mem)
21614 v1.AddArg3(dst, v2, mem)
21615 v.AddArg3(dst, v0, v1)
21616 return true
21617 }
21618
21619
21620 for {
21621 if auxIntToInt64(v.AuxInt) != 12 {
21622 break
21623 }
21624 dst := v_0
21625 src := v_1
21626 mem := v_2
21627 v.reset(OpARM64MOVWstore)
21628 v.AuxInt = int32ToAuxInt(8)
21629 v0 := b.NewValue0(v.Pos, OpARM64MOVWUload, typ.UInt32)
21630 v0.AuxInt = int32ToAuxInt(8)
21631 v0.AddArg2(src, mem)
21632 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
21633 v2 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21634 v2.AddArg2(src, mem)
21635 v1.AddArg3(dst, v2, mem)
21636 v.AddArg3(dst, v0, v1)
21637 return true
21638 }
21639
21640
21641 for {
21642 if auxIntToInt64(v.AuxInt) != 13 {
21643 break
21644 }
21645 dst := v_0
21646 src := v_1
21647 mem := v_2
21648 v.reset(OpARM64MOVDstore)
21649 v.AuxInt = int32ToAuxInt(5)
21650 v0 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21651 v0.AuxInt = int32ToAuxInt(5)
21652 v0.AddArg2(src, mem)
21653 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
21654 v2 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21655 v2.AddArg2(src, mem)
21656 v1.AddArg3(dst, v2, mem)
21657 v.AddArg3(dst, v0, v1)
21658 return true
21659 }
21660
21661
21662 for {
21663 if auxIntToInt64(v.AuxInt) != 14 {
21664 break
21665 }
21666 dst := v_0
21667 src := v_1
21668 mem := v_2
21669 v.reset(OpARM64MOVDstore)
21670 v.AuxInt = int32ToAuxInt(6)
21671 v0 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21672 v0.AuxInt = int32ToAuxInt(6)
21673 v0.AddArg2(src, mem)
21674 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
21675 v2 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21676 v2.AddArg2(src, mem)
21677 v1.AddArg3(dst, v2, mem)
21678 v.AddArg3(dst, v0, v1)
21679 return true
21680 }
21681
21682
21683 for {
21684 if auxIntToInt64(v.AuxInt) != 15 {
21685 break
21686 }
21687 dst := v_0
21688 src := v_1
21689 mem := v_2
21690 v.reset(OpARM64MOVDstore)
21691 v.AuxInt = int32ToAuxInt(7)
21692 v0 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21693 v0.AuxInt = int32ToAuxInt(7)
21694 v0.AddArg2(src, mem)
21695 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
21696 v2 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21697 v2.AddArg2(src, mem)
21698 v1.AddArg3(dst, v2, mem)
21699 v.AddArg3(dst, v0, v1)
21700 return true
21701 }
21702
21703
21704 for {
21705 if auxIntToInt64(v.AuxInt) != 16 {
21706 break
21707 }
21708 dst := v_0
21709 src := v_1
21710 mem := v_2
21711 v.reset(OpARM64FMOVQstore)
21712 v0 := b.NewValue0(v.Pos, OpARM64FMOVQload, typ.Vec128)
21713 v0.AddArg2(src, mem)
21714 v.AddArg3(dst, v0, mem)
21715 return true
21716 }
21717
21718
21719
21720 for {
21721 s := auxIntToInt64(v.AuxInt)
21722 dst := v_0
21723 src := v_1
21724 mem := v_2
21725 if !(s > 16 && s <= 24) {
21726 break
21727 }
21728 v.reset(OpARM64MOVDstore)
21729 v.AuxInt = int32ToAuxInt(int32(s - 8))
21730 v0 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21731 v0.AuxInt = int32ToAuxInt(int32(s - 8))
21732 v0.AddArg2(src, mem)
21733 v1 := b.NewValue0(v.Pos, OpARM64FMOVQstore, types.TypeMem)
21734 v2 := b.NewValue0(v.Pos, OpARM64FMOVQload, typ.Vec128)
21735 v2.AddArg2(src, mem)
21736 v1.AddArg3(dst, v2, mem)
21737 v.AddArg3(dst, v0, v1)
21738 return true
21739 }
21740
21741
21742
21743 for {
21744 s := auxIntToInt64(v.AuxInt)
21745 dst := v_0
21746 src := v_1
21747 mem := v_2
21748 if !(s > 24 && s < 32) {
21749 break
21750 }
21751 v.reset(OpARM64FMOVQstore)
21752 v.AuxInt = int32ToAuxInt(int32(s - 16))
21753 v0 := b.NewValue0(v.Pos, OpARM64FMOVQload, typ.Vec128)
21754 v0.AuxInt = int32ToAuxInt(int32(s - 16))
21755 v0.AddArg2(src, mem)
21756 v1 := b.NewValue0(v.Pos, OpARM64FMOVQstore, types.TypeMem)
21757 v2 := b.NewValue0(v.Pos, OpARM64FMOVQload, typ.Vec128)
21758 v2.AddArg2(src, mem)
21759 v1.AddArg3(dst, v2, mem)
21760 v.AddArg3(dst, v0, v1)
21761 return true
21762 }
21763
21764
21765 for {
21766 if auxIntToInt64(v.AuxInt) != 32 {
21767 break
21768 }
21769 dst := v_0
21770 src := v_1
21771 mem := v_2
21772 v.reset(OpARM64FSTPQ)
21773 v0 := b.NewValue0(v.Pos, OpSelect0, typ.Vec128)
21774 v1 := b.NewValue0(v.Pos, OpARM64FLDPQ, types.NewTuple(typ.Vec128, typ.Vec128))
21775 v1.AddArg2(src, mem)
21776 v0.AddArg(v1)
21777 v2 := b.NewValue0(v.Pos, OpSelect1, typ.Vec128)
21778 v2.AddArg(v1)
21779 v.AddArg4(dst, v0, v2, mem)
21780 return true
21781 }
21782
21783
21784
21785 for {
21786 s := auxIntToInt64(v.AuxInt)
21787 dst := v_0
21788 src := v_1
21789 mem := v_2
21790 if !(s > 32 && s <= 40) {
21791 break
21792 }
21793 v.reset(OpARM64MOVDstore)
21794 v.AuxInt = int32ToAuxInt(int32(s - 8))
21795 v0 := b.NewValue0(v.Pos, OpARM64MOVDload, typ.UInt64)
21796 v0.AuxInt = int32ToAuxInt(int32(s - 8))
21797 v0.AddArg2(src, mem)
21798 v1 := b.NewValue0(v.Pos, OpARM64FSTPQ, types.TypeMem)
21799 v2 := b.NewValue0(v.Pos, OpSelect0, typ.Vec128)
21800 v3 := b.NewValue0(v.Pos, OpARM64FLDPQ, types.NewTuple(typ.Vec128, typ.Vec128))
21801 v3.AddArg2(src, mem)
21802 v2.AddArg(v3)
21803 v4 := b.NewValue0(v.Pos, OpSelect1, typ.Vec128)
21804 v4.AddArg(v3)
21805 v1.AddArg4(dst, v2, v4, mem)
21806 v.AddArg3(dst, v0, v1)
21807 return true
21808 }
21809
21810
21811
21812 for {
21813 s := auxIntToInt64(v.AuxInt)
21814 dst := v_0
21815 src := v_1
21816 mem := v_2
21817 if !(s > 40 && s <= 48) {
21818 break
21819 }
21820 v.reset(OpARM64FMOVQstore)
21821 v.AuxInt = int32ToAuxInt(int32(s - 16))
21822 v0 := b.NewValue0(v.Pos, OpARM64FMOVQload, typ.Vec128)
21823 v0.AuxInt = int32ToAuxInt(int32(s - 16))
21824 v0.AddArg2(src, mem)
21825 v1 := b.NewValue0(v.Pos, OpARM64FSTPQ, types.TypeMem)
21826 v2 := b.NewValue0(v.Pos, OpSelect0, typ.Vec128)
21827 v3 := b.NewValue0(v.Pos, OpARM64FLDPQ, types.NewTuple(typ.Vec128, typ.Vec128))
21828 v3.AddArg2(src, mem)
21829 v2.AddArg(v3)
21830 v4 := b.NewValue0(v.Pos, OpSelect1, typ.Vec128)
21831 v4.AddArg(v3)
21832 v1.AddArg4(dst, v2, v4, mem)
21833 v.AddArg3(dst, v0, v1)
21834 return true
21835 }
21836
21837
21838
21839 for {
21840 s := auxIntToInt64(v.AuxInt)
21841 dst := v_0
21842 src := v_1
21843 mem := v_2
21844 if !(s > 48 && s <= 64) {
21845 break
21846 }
21847 v.reset(OpARM64FSTPQ)
21848 v.AuxInt = int32ToAuxInt(int32(s - 32))
21849 v0 := b.NewValue0(v.Pos, OpSelect0, typ.Vec128)
21850 v1 := b.NewValue0(v.Pos, OpARM64FLDPQ, types.NewTuple(typ.Vec128, typ.Vec128))
21851 v1.AuxInt = int32ToAuxInt(int32(s - 32))
21852 v1.AddArg2(src, mem)
21853 v0.AddArg(v1)
21854 v2 := b.NewValue0(v.Pos, OpSelect1, typ.Vec128)
21855 v2.AddArg(v1)
21856 v3 := b.NewValue0(v.Pos, OpARM64FSTPQ, types.TypeMem)
21857 v4 := b.NewValue0(v.Pos, OpSelect0, typ.Vec128)
21858 v5 := b.NewValue0(v.Pos, OpARM64FLDPQ, types.NewTuple(typ.Vec128, typ.Vec128))
21859 v5.AddArg2(src, mem)
21860 v4.AddArg(v5)
21861 v6 := b.NewValue0(v.Pos, OpSelect1, typ.Vec128)
21862 v6.AddArg(v5)
21863 v3.AddArg4(dst, v4, v6, mem)
21864 v.AddArg4(dst, v0, v2, v3)
21865 return true
21866 }
21867
21868
21869
21870 for {
21871 s := auxIntToInt64(v.AuxInt)
21872 dst := v_0
21873 src := v_1
21874 mem := v_2
21875 if !(s > 64 && s < 192 && logLargeCopy(v, s)) {
21876 break
21877 }
21878 v.reset(OpARM64LoweredMove)
21879 v.AuxInt = int64ToAuxInt(s)
21880 v.AddArg3(dst, src, mem)
21881 return true
21882 }
21883
21884
21885
21886 for {
21887 s := auxIntToInt64(v.AuxInt)
21888 dst := v_0
21889 src := v_1
21890 mem := v_2
21891 if !(s >= 192 && logLargeCopy(v, s)) {
21892 break
21893 }
21894 v.reset(OpARM64LoweredMoveLoop)
21895 v.AuxInt = int64ToAuxInt(s)
21896 v.AddArg3(dst, src, mem)
21897 return true
21898 }
21899 return false
21900 }
21901 func rewriteValueARM64_OpMulAddFloat32x4(v *Value) bool {
21902 v_2 := v.Args[2]
21903 v_1 := v.Args[1]
21904 v_0 := v.Args[0]
21905
21906
21907 for {
21908 x := v_0
21909 y := v_1
21910 z := v_2
21911 v.reset(OpARM64VFMLA4S)
21912 v.AddArg3(z, x, y)
21913 return true
21914 }
21915 }
21916 func rewriteValueARM64_OpMulAddFloat64x2(v *Value) bool {
21917 v_2 := v.Args[2]
21918 v_1 := v.Args[1]
21919 v_0 := v.Args[0]
21920
21921
21922 for {
21923 x := v_0
21924 y := v_1
21925 z := v_2
21926 v.reset(OpARM64VFMLA2D)
21927 v.AddArg3(z, x, y)
21928 return true
21929 }
21930 }
21931 func rewriteValueARM64_OpMulAddInt16x8(v *Value) bool {
21932 v_2 := v.Args[2]
21933 v_1 := v.Args[1]
21934 v_0 := v.Args[0]
21935
21936
21937 for {
21938 x := v_0
21939 y := v_1
21940 z := v_2
21941 v.reset(OpARM64VMLA8H)
21942 v.AddArg3(z, x, y)
21943 return true
21944 }
21945 }
21946 func rewriteValueARM64_OpMulAddInt32x4(v *Value) bool {
21947 v_2 := v.Args[2]
21948 v_1 := v.Args[1]
21949 v_0 := v.Args[0]
21950
21951
21952 for {
21953 x := v_0
21954 y := v_1
21955 z := v_2
21956 v.reset(OpARM64VMLA4S)
21957 v.AddArg3(z, x, y)
21958 return true
21959 }
21960 }
21961 func rewriteValueARM64_OpMulAddInt8x16(v *Value) bool {
21962 v_2 := v.Args[2]
21963 v_1 := v.Args[1]
21964 v_0 := v.Args[0]
21965
21966
21967 for {
21968 x := v_0
21969 y := v_1
21970 z := v_2
21971 v.reset(OpARM64VMLA16B)
21972 v.AddArg3(z, x, y)
21973 return true
21974 }
21975 }
21976 func rewriteValueARM64_OpMulAddUint16x8(v *Value) bool {
21977 v_2 := v.Args[2]
21978 v_1 := v.Args[1]
21979 v_0 := v.Args[0]
21980
21981
21982 for {
21983 x := v_0
21984 y := v_1
21985 z := v_2
21986 v.reset(OpARM64VMLA8H)
21987 v.AddArg3(z, x, y)
21988 return true
21989 }
21990 }
21991 func rewriteValueARM64_OpMulAddUint32x4(v *Value) bool {
21992 v_2 := v.Args[2]
21993 v_1 := v.Args[1]
21994 v_0 := v.Args[0]
21995
21996
21997 for {
21998 x := v_0
21999 y := v_1
22000 z := v_2
22001 v.reset(OpARM64VMLA4S)
22002 v.AddArg3(z, x, y)
22003 return true
22004 }
22005 }
22006 func rewriteValueARM64_OpMulAddUint8x16(v *Value) bool {
22007 v_2 := v.Args[2]
22008 v_1 := v.Args[1]
22009 v_0 := v.Args[0]
22010
22011
22012 for {
22013 x := v_0
22014 y := v_1
22015 z := v_2
22016 v.reset(OpARM64VMLA16B)
22017 v.AddArg3(z, x, y)
22018 return true
22019 }
22020 }
22021 func rewriteValueARM64_OpNeq16(v *Value) bool {
22022 v_1 := v.Args[1]
22023 v_0 := v.Args[0]
22024 b := v.Block
22025 typ := &b.Func.Config.Types
22026
22027
22028 for {
22029 x := v_0
22030 y := v_1
22031 v.reset(OpARM64NotEqual)
22032 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
22033 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
22034 v1.AddArg(x)
22035 v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
22036 v2.AddArg(y)
22037 v0.AddArg2(v1, v2)
22038 v.AddArg(v0)
22039 return true
22040 }
22041 }
22042 func rewriteValueARM64_OpNeq32(v *Value) bool {
22043 v_1 := v.Args[1]
22044 v_0 := v.Args[0]
22045 b := v.Block
22046
22047
22048 for {
22049 x := v_0
22050 y := v_1
22051 v.reset(OpARM64NotEqual)
22052 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
22053 v0.AddArg2(x, y)
22054 v.AddArg(v0)
22055 return true
22056 }
22057 }
22058 func rewriteValueARM64_OpNeq32F(v *Value) bool {
22059 v_1 := v.Args[1]
22060 v_0 := v.Args[0]
22061 b := v.Block
22062
22063
22064 for {
22065 x := v_0
22066 y := v_1
22067 v.reset(OpARM64NotEqual)
22068 v0 := b.NewValue0(v.Pos, OpARM64FCMPS, types.TypeFlags)
22069 v0.AddArg2(x, y)
22070 v.AddArg(v0)
22071 return true
22072 }
22073 }
22074 func rewriteValueARM64_OpNeq64(v *Value) bool {
22075 v_1 := v.Args[1]
22076 v_0 := v.Args[0]
22077 b := v.Block
22078
22079
22080 for {
22081 x := v_0
22082 y := v_1
22083 v.reset(OpARM64NotEqual)
22084 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
22085 v0.AddArg2(x, y)
22086 v.AddArg(v0)
22087 return true
22088 }
22089 }
22090 func rewriteValueARM64_OpNeq64F(v *Value) bool {
22091 v_1 := v.Args[1]
22092 v_0 := v.Args[0]
22093 b := v.Block
22094
22095
22096 for {
22097 x := v_0
22098 y := v_1
22099 v.reset(OpARM64NotEqual)
22100 v0 := b.NewValue0(v.Pos, OpARM64FCMPD, types.TypeFlags)
22101 v0.AddArg2(x, y)
22102 v.AddArg(v0)
22103 return true
22104 }
22105 }
22106 func rewriteValueARM64_OpNeq8(v *Value) bool {
22107 v_1 := v.Args[1]
22108 v_0 := v.Args[0]
22109 b := v.Block
22110 typ := &b.Func.Config.Types
22111
22112
22113 for {
22114 x := v_0
22115 y := v_1
22116 v.reset(OpARM64NotEqual)
22117 v0 := b.NewValue0(v.Pos, OpARM64CMPW, types.TypeFlags)
22118 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
22119 v1.AddArg(x)
22120 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
22121 v2.AddArg(y)
22122 v0.AddArg2(v1, v2)
22123 v.AddArg(v0)
22124 return true
22125 }
22126 }
22127 func rewriteValueARM64_OpNeqPtr(v *Value) bool {
22128 v_1 := v.Args[1]
22129 v_0 := v.Args[0]
22130 b := v.Block
22131
22132
22133 for {
22134 x := v_0
22135 y := v_1
22136 v.reset(OpARM64NotEqual)
22137 v0 := b.NewValue0(v.Pos, OpARM64CMP, types.TypeFlags)
22138 v0.AddArg2(x, y)
22139 v.AddArg(v0)
22140 return true
22141 }
22142 }
22143 func rewriteValueARM64_OpNot(v *Value) bool {
22144 v_0 := v.Args[0]
22145 b := v.Block
22146 typ := &b.Func.Config.Types
22147
22148
22149 for {
22150 x := v_0
22151 v.reset(OpARM64XOR)
22152 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
22153 v0.AuxInt = int64ToAuxInt(1)
22154 v.AddArg2(v0, x)
22155 return true
22156 }
22157 }
22158 func rewriteValueARM64_OpOffPtr(v *Value) bool {
22159 v_0 := v.Args[0]
22160
22161
22162
22163 for {
22164 off := auxIntToInt64(v.AuxInt)
22165 ptr := v_0
22166 if ptr.Op != OpSP || !(is32Bit(off)) {
22167 break
22168 }
22169 v.reset(OpARM64MOVDaddr)
22170 v.AuxInt = int32ToAuxInt(int32(off))
22171 v.AddArg(ptr)
22172 return true
22173 }
22174
22175
22176 for {
22177 off := auxIntToInt64(v.AuxInt)
22178 ptr := v_0
22179 v.reset(OpARM64ADDconst)
22180 v.AuxInt = int64ToAuxInt(off)
22181 v.AddArg(ptr)
22182 return true
22183 }
22184 }
22185 func rewriteValueARM64_OpPopCount16(v *Value) bool {
22186 v_0 := v.Args[0]
22187 b := v.Block
22188 typ := &b.Func.Config.Types
22189
22190
22191 for {
22192 t := v.Type
22193 x := v_0
22194 v.reset(OpARM64FMOVDfpgp)
22195 v.Type = t
22196 v0 := b.NewValue0(v.Pos, OpARM64VUADDLV, typ.Float64)
22197 v1 := b.NewValue0(v.Pos, OpARM64VCNT, typ.Float64)
22198 v2 := b.NewValue0(v.Pos, OpARM64FMOVDgpfp, typ.Float64)
22199 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
22200 v3.AddArg(x)
22201 v2.AddArg(v3)
22202 v1.AddArg(v2)
22203 v0.AddArg(v1)
22204 v.AddArg(v0)
22205 return true
22206 }
22207 }
22208 func rewriteValueARM64_OpPopCount32(v *Value) bool {
22209 v_0 := v.Args[0]
22210 b := v.Block
22211 typ := &b.Func.Config.Types
22212
22213
22214 for {
22215 t := v.Type
22216 x := v_0
22217 v.reset(OpARM64FMOVDfpgp)
22218 v.Type = t
22219 v0 := b.NewValue0(v.Pos, OpARM64VUADDLV, typ.Float64)
22220 v1 := b.NewValue0(v.Pos, OpARM64VCNT, typ.Float64)
22221 v2 := b.NewValue0(v.Pos, OpARM64FMOVDgpfp, typ.Float64)
22222 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
22223 v3.AddArg(x)
22224 v2.AddArg(v3)
22225 v1.AddArg(v2)
22226 v0.AddArg(v1)
22227 v.AddArg(v0)
22228 return true
22229 }
22230 }
22231 func rewriteValueARM64_OpPopCount64(v *Value) bool {
22232 v_0 := v.Args[0]
22233 b := v.Block
22234 typ := &b.Func.Config.Types
22235
22236
22237 for {
22238 t := v.Type
22239 x := v_0
22240 v.reset(OpARM64FMOVDfpgp)
22241 v.Type = t
22242 v0 := b.NewValue0(v.Pos, OpARM64VUADDLV, typ.Float64)
22243 v1 := b.NewValue0(v.Pos, OpARM64VCNT, typ.Float64)
22244 v2 := b.NewValue0(v.Pos, OpARM64FMOVDgpfp, typ.Float64)
22245 v2.AddArg(x)
22246 v1.AddArg(v2)
22247 v0.AddArg(v1)
22248 v.AddArg(v0)
22249 return true
22250 }
22251 }
22252 func rewriteValueARM64_OpPrefetchCache(v *Value) bool {
22253 v_1 := v.Args[1]
22254 v_0 := v.Args[0]
22255
22256
22257 for {
22258 addr := v_0
22259 mem := v_1
22260 v.reset(OpARM64PRFM)
22261 v.AuxInt = int64ToAuxInt(0)
22262 v.AddArg2(addr, mem)
22263 return true
22264 }
22265 }
22266 func rewriteValueARM64_OpPrefetchCacheStreamed(v *Value) bool {
22267 v_1 := v.Args[1]
22268 v_0 := v.Args[0]
22269
22270
22271 for {
22272 addr := v_0
22273 mem := v_1
22274 v.reset(OpARM64PRFM)
22275 v.AuxInt = int64ToAuxInt(1)
22276 v.AddArg2(addr, mem)
22277 return true
22278 }
22279 }
22280 func rewriteValueARM64_OpPubBarrier(v *Value) bool {
22281 v_0 := v.Args[0]
22282
22283
22284 for {
22285 mem := v_0
22286 v.reset(OpARM64DMB)
22287 v.AuxInt = int64ToAuxInt(0xe)
22288 v.AddArg(mem)
22289 return true
22290 }
22291 }
22292 func rewriteValueARM64_OpRotateLeft16(v *Value) bool {
22293 v_1 := v.Args[1]
22294 v_0 := v.Args[0]
22295 b := v.Block
22296 typ := &b.Func.Config.Types
22297
22298
22299 for {
22300 t := v.Type
22301 x := v_0
22302 if v_1.Op != OpARM64MOVDconst {
22303 break
22304 }
22305 c := auxIntToInt64(v_1.AuxInt)
22306 v.reset(OpOr16)
22307 v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
22308 v1 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
22309 v1.AuxInt = int64ToAuxInt(c & 15)
22310 v0.AddArg2(x, v1)
22311 v2 := b.NewValue0(v.Pos, OpRsh16Ux64, t)
22312 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
22313 v3.AuxInt = int64ToAuxInt(-c & 15)
22314 v2.AddArg2(x, v3)
22315 v.AddArg2(v0, v2)
22316 return true
22317 }
22318
22319
22320 for {
22321 t := v.Type
22322 x := v_0
22323 y := v_1
22324 v.reset(OpARM64RORW)
22325 v.Type = t
22326 v0 := b.NewValue0(v.Pos, OpARM64ORshiftLL, typ.UInt32)
22327 v0.AuxInt = int64ToAuxInt(16)
22328 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
22329 v1.AddArg(x)
22330 v0.AddArg2(v1, v1)
22331 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
22332 v2.AddArg(y)
22333 v.AddArg2(v0, v2)
22334 return true
22335 }
22336 }
22337 func rewriteValueARM64_OpRotateLeft32(v *Value) bool {
22338 v_1 := v.Args[1]
22339 v_0 := v.Args[0]
22340 b := v.Block
22341
22342
22343 for {
22344 x := v_0
22345 y := v_1
22346 v.reset(OpARM64RORW)
22347 v0 := b.NewValue0(v.Pos, OpARM64NEG, y.Type)
22348 v0.AddArg(y)
22349 v.AddArg2(x, v0)
22350 return true
22351 }
22352 }
22353 func rewriteValueARM64_OpRotateLeft64(v *Value) bool {
22354 v_1 := v.Args[1]
22355 v_0 := v.Args[0]
22356 b := v.Block
22357
22358
22359 for {
22360 x := v_0
22361 y := v_1
22362 v.reset(OpARM64ROR)
22363 v0 := b.NewValue0(v.Pos, OpARM64NEG, y.Type)
22364 v0.AddArg(y)
22365 v.AddArg2(x, v0)
22366 return true
22367 }
22368 }
22369 func rewriteValueARM64_OpRotateLeft8(v *Value) bool {
22370 v_1 := v.Args[1]
22371 v_0 := v.Args[0]
22372 b := v.Block
22373 typ := &b.Func.Config.Types
22374
22375
22376 for {
22377 t := v.Type
22378 x := v_0
22379 if v_1.Op != OpARM64MOVDconst {
22380 break
22381 }
22382 c := auxIntToInt64(v_1.AuxInt)
22383 v.reset(OpOr8)
22384 v0 := b.NewValue0(v.Pos, OpLsh8x64, t)
22385 v1 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
22386 v1.AuxInt = int64ToAuxInt(c & 7)
22387 v0.AddArg2(x, v1)
22388 v2 := b.NewValue0(v.Pos, OpRsh8Ux64, t)
22389 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
22390 v3.AuxInt = int64ToAuxInt(-c & 7)
22391 v2.AddArg2(x, v3)
22392 v.AddArg2(v0, v2)
22393 return true
22394 }
22395
22396
22397 for {
22398 t := v.Type
22399 x := v_0
22400 y := v_1
22401 v.reset(OpARM64OR)
22402 v.Type = t
22403 v0 := b.NewValue0(v.Pos, OpARM64SLL, t)
22404 v1 := b.NewValue0(v.Pos, OpARM64ANDconst, typ.Int64)
22405 v1.AuxInt = int64ToAuxInt(7)
22406 v1.AddArg(y)
22407 v0.AddArg2(x, v1)
22408 v2 := b.NewValue0(v.Pos, OpARM64SRL, t)
22409 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
22410 v3.AddArg(x)
22411 v4 := b.NewValue0(v.Pos, OpARM64ANDconst, typ.Int64)
22412 v4.AuxInt = int64ToAuxInt(7)
22413 v5 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
22414 v5.AddArg(y)
22415 v4.AddArg(v5)
22416 v2.AddArg2(v3, v4)
22417 v.AddArg2(v0, v2)
22418 return true
22419 }
22420 }
22421 func rewriteValueARM64_OpRsh16Ux16(v *Value) bool {
22422 v_1 := v.Args[1]
22423 v_0 := v.Args[0]
22424 b := v.Block
22425 typ := &b.Func.Config.Types
22426
22427
22428 for {
22429 t := v.Type
22430 bounded := auxIntToBool(v.AuxInt)
22431 x := v_0
22432 y := v_1
22433 v.reset(OpRsh64Ux16)
22434 v.Type = t
22435 v.AuxInt = boolToAuxInt(bounded)
22436 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
22437 v0.AddArg(x)
22438 v.AddArg2(v0, y)
22439 return true
22440 }
22441 }
22442 func rewriteValueARM64_OpRsh16Ux32(v *Value) bool {
22443 v_1 := v.Args[1]
22444 v_0 := v.Args[0]
22445 b := v.Block
22446 typ := &b.Func.Config.Types
22447
22448
22449 for {
22450 t := v.Type
22451 bounded := auxIntToBool(v.AuxInt)
22452 x := v_0
22453 y := v_1
22454 v.reset(OpRsh64Ux32)
22455 v.Type = t
22456 v.AuxInt = boolToAuxInt(bounded)
22457 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
22458 v0.AddArg(x)
22459 v.AddArg2(v0, y)
22460 return true
22461 }
22462 }
22463 func rewriteValueARM64_OpRsh16Ux64(v *Value) bool {
22464 v_1 := v.Args[1]
22465 v_0 := v.Args[0]
22466 b := v.Block
22467 typ := &b.Func.Config.Types
22468
22469
22470 for {
22471 t := v.Type
22472 bounded := auxIntToBool(v.AuxInt)
22473 x := v_0
22474 y := v_1
22475 v.reset(OpRsh64Ux64)
22476 v.Type = t
22477 v.AuxInt = boolToAuxInt(bounded)
22478 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
22479 v0.AddArg(x)
22480 v.AddArg2(v0, y)
22481 return true
22482 }
22483 }
22484 func rewriteValueARM64_OpRsh16Ux8(v *Value) bool {
22485 v_1 := v.Args[1]
22486 v_0 := v.Args[0]
22487 b := v.Block
22488 typ := &b.Func.Config.Types
22489
22490
22491 for {
22492 t := v.Type
22493 bounded := auxIntToBool(v.AuxInt)
22494 x := v_0
22495 y := v_1
22496 v.reset(OpRsh64Ux8)
22497 v.Type = t
22498 v.AuxInt = boolToAuxInt(bounded)
22499 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
22500 v0.AddArg(x)
22501 v.AddArg2(v0, y)
22502 return true
22503 }
22504 }
22505 func rewriteValueARM64_OpRsh16x16(v *Value) bool {
22506 v_1 := v.Args[1]
22507 v_0 := v.Args[0]
22508 b := v.Block
22509 typ := &b.Func.Config.Types
22510
22511
22512 for {
22513 t := v.Type
22514 bounded := auxIntToBool(v.AuxInt)
22515 x := v_0
22516 y := v_1
22517 v.reset(OpRsh64x16)
22518 v.Type = t
22519 v.AuxInt = boolToAuxInt(bounded)
22520 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
22521 v0.AddArg(x)
22522 v.AddArg2(v0, y)
22523 return true
22524 }
22525 }
22526 func rewriteValueARM64_OpRsh16x32(v *Value) bool {
22527 v_1 := v.Args[1]
22528 v_0 := v.Args[0]
22529 b := v.Block
22530 typ := &b.Func.Config.Types
22531
22532
22533 for {
22534 t := v.Type
22535 bounded := auxIntToBool(v.AuxInt)
22536 x := v_0
22537 y := v_1
22538 v.reset(OpRsh64x32)
22539 v.Type = t
22540 v.AuxInt = boolToAuxInt(bounded)
22541 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
22542 v0.AddArg(x)
22543 v.AddArg2(v0, y)
22544 return true
22545 }
22546 }
22547 func rewriteValueARM64_OpRsh16x64(v *Value) bool {
22548 v_1 := v.Args[1]
22549 v_0 := v.Args[0]
22550 b := v.Block
22551 typ := &b.Func.Config.Types
22552
22553
22554 for {
22555 t := v.Type
22556 bounded := auxIntToBool(v.AuxInt)
22557 x := v_0
22558 y := v_1
22559 v.reset(OpRsh64x64)
22560 v.Type = t
22561 v.AuxInt = boolToAuxInt(bounded)
22562 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
22563 v0.AddArg(x)
22564 v.AddArg2(v0, y)
22565 return true
22566 }
22567 }
22568 func rewriteValueARM64_OpRsh16x8(v *Value) bool {
22569 v_1 := v.Args[1]
22570 v_0 := v.Args[0]
22571 b := v.Block
22572 typ := &b.Func.Config.Types
22573
22574
22575 for {
22576 t := v.Type
22577 bounded := auxIntToBool(v.AuxInt)
22578 x := v_0
22579 y := v_1
22580 v.reset(OpRsh64x8)
22581 v.Type = t
22582 v.AuxInt = boolToAuxInt(bounded)
22583 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
22584 v0.AddArg(x)
22585 v.AddArg2(v0, y)
22586 return true
22587 }
22588 }
22589 func rewriteValueARM64_OpRsh32Ux16(v *Value) bool {
22590 v_1 := v.Args[1]
22591 v_0 := v.Args[0]
22592 b := v.Block
22593 typ := &b.Func.Config.Types
22594
22595
22596 for {
22597 t := v.Type
22598 bounded := auxIntToBool(v.AuxInt)
22599 x := v_0
22600 y := v_1
22601 v.reset(OpRsh64Ux16)
22602 v.Type = t
22603 v.AuxInt = boolToAuxInt(bounded)
22604 v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
22605 v0.AddArg(x)
22606 v.AddArg2(v0, y)
22607 return true
22608 }
22609 }
22610 func rewriteValueARM64_OpRsh32Ux32(v *Value) bool {
22611 v_1 := v.Args[1]
22612 v_0 := v.Args[0]
22613 b := v.Block
22614 typ := &b.Func.Config.Types
22615
22616
22617 for {
22618 t := v.Type
22619 bounded := auxIntToBool(v.AuxInt)
22620 x := v_0
22621 y := v_1
22622 v.reset(OpRsh64Ux32)
22623 v.Type = t
22624 v.AuxInt = boolToAuxInt(bounded)
22625 v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
22626 v0.AddArg(x)
22627 v.AddArg2(v0, y)
22628 return true
22629 }
22630 }
22631 func rewriteValueARM64_OpRsh32Ux64(v *Value) bool {
22632 v_1 := v.Args[1]
22633 v_0 := v.Args[0]
22634 b := v.Block
22635 typ := &b.Func.Config.Types
22636
22637
22638 for {
22639 t := v.Type
22640 bounded := auxIntToBool(v.AuxInt)
22641 x := v_0
22642 y := v_1
22643 v.reset(OpRsh64Ux64)
22644 v.Type = t
22645 v.AuxInt = boolToAuxInt(bounded)
22646 v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
22647 v0.AddArg(x)
22648 v.AddArg2(v0, y)
22649 return true
22650 }
22651 }
22652 func rewriteValueARM64_OpRsh32Ux8(v *Value) bool {
22653 v_1 := v.Args[1]
22654 v_0 := v.Args[0]
22655 b := v.Block
22656 typ := &b.Func.Config.Types
22657
22658
22659 for {
22660 t := v.Type
22661 bounded := auxIntToBool(v.AuxInt)
22662 x := v_0
22663 y := v_1
22664 v.reset(OpRsh64Ux8)
22665 v.Type = t
22666 v.AuxInt = boolToAuxInt(bounded)
22667 v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
22668 v0.AddArg(x)
22669 v.AddArg2(v0, y)
22670 return true
22671 }
22672 }
22673 func rewriteValueARM64_OpRsh32x16(v *Value) bool {
22674 v_1 := v.Args[1]
22675 v_0 := v.Args[0]
22676 b := v.Block
22677 typ := &b.Func.Config.Types
22678
22679
22680 for {
22681 t := v.Type
22682 bounded := auxIntToBool(v.AuxInt)
22683 x := v_0
22684 y := v_1
22685 v.reset(OpRsh64x16)
22686 v.Type = t
22687 v.AuxInt = boolToAuxInt(bounded)
22688 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
22689 v0.AddArg(x)
22690 v.AddArg2(v0, y)
22691 return true
22692 }
22693 }
22694 func rewriteValueARM64_OpRsh32x32(v *Value) bool {
22695 v_1 := v.Args[1]
22696 v_0 := v.Args[0]
22697 b := v.Block
22698 typ := &b.Func.Config.Types
22699
22700
22701 for {
22702 t := v.Type
22703 bounded := auxIntToBool(v.AuxInt)
22704 x := v_0
22705 y := v_1
22706 v.reset(OpRsh64x32)
22707 v.Type = t
22708 v.AuxInt = boolToAuxInt(bounded)
22709 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
22710 v0.AddArg(x)
22711 v.AddArg2(v0, y)
22712 return true
22713 }
22714 }
22715 func rewriteValueARM64_OpRsh32x64(v *Value) bool {
22716 v_1 := v.Args[1]
22717 v_0 := v.Args[0]
22718 b := v.Block
22719 typ := &b.Func.Config.Types
22720
22721
22722 for {
22723 t := v.Type
22724 bounded := auxIntToBool(v.AuxInt)
22725 x := v_0
22726 y := v_1
22727 v.reset(OpRsh64x64)
22728 v.Type = t
22729 v.AuxInt = boolToAuxInt(bounded)
22730 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
22731 v0.AddArg(x)
22732 v.AddArg2(v0, y)
22733 return true
22734 }
22735 }
22736 func rewriteValueARM64_OpRsh32x8(v *Value) bool {
22737 v_1 := v.Args[1]
22738 v_0 := v.Args[0]
22739 b := v.Block
22740 typ := &b.Func.Config.Types
22741
22742
22743 for {
22744 t := v.Type
22745 bounded := auxIntToBool(v.AuxInt)
22746 x := v_0
22747 y := v_1
22748 v.reset(OpRsh64x8)
22749 v.Type = t
22750 v.AuxInt = boolToAuxInt(bounded)
22751 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
22752 v0.AddArg(x)
22753 v.AddArg2(v0, y)
22754 return true
22755 }
22756 }
22757 func rewriteValueARM64_OpRsh64Ux16(v *Value) bool {
22758 v_1 := v.Args[1]
22759 v_0 := v.Args[0]
22760 b := v.Block
22761 typ := &b.Func.Config.Types
22762
22763
22764
22765 for {
22766 t := v.Type
22767 x := v_0
22768 y := v_1
22769 if !(shiftIsBounded(v)) {
22770 break
22771 }
22772 v.reset(OpARM64SRL)
22773 v.Type = t
22774 v.AddArg2(x, y)
22775 return true
22776 }
22777
22778
22779
22780 for {
22781 t := v.Type
22782 bounded := auxIntToBool(v.AuxInt)
22783 x := v_0
22784 y := v_1
22785 if !(!shiftIsBounded(v)) {
22786 break
22787 }
22788 v.reset(OpRsh64Ux32)
22789 v.Type = t
22790 v.AuxInt = boolToAuxInt(bounded)
22791 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
22792 v0.AddArg(y)
22793 v.AddArg2(x, v0)
22794 return true
22795 }
22796 return false
22797 }
22798 func rewriteValueARM64_OpRsh64Ux32(v *Value) bool {
22799 v_1 := v.Args[1]
22800 v_0 := v.Args[0]
22801 b := v.Block
22802
22803
22804
22805 for {
22806 t := v.Type
22807 x := v_0
22808 y := v_1
22809 if !(shiftIsBounded(v)) {
22810 break
22811 }
22812 v.reset(OpARM64SRL)
22813 v.Type = t
22814 v.AddArg2(x, y)
22815 return true
22816 }
22817
22818
22819
22820 for {
22821 t := v.Type
22822 x := v_0
22823 y := v_1
22824 if !(!shiftIsBounded(v)) {
22825 break
22826 }
22827 v.reset(OpARM64CSEL)
22828 v.AuxInt = opToAuxInt(OpARM64LessThanU)
22829 v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
22830 v0.AddArg2(x, y)
22831 v1 := b.NewValue0(v.Pos, OpConst64, t)
22832 v1.AuxInt = int64ToAuxInt(0)
22833 v2 := b.NewValue0(v.Pos, OpARM64CMPWconst, types.TypeFlags)
22834 v2.AuxInt = int32ToAuxInt(64)
22835 v2.AddArg(y)
22836 v.AddArg3(v0, v1, v2)
22837 return true
22838 }
22839 return false
22840 }
22841 func rewriteValueARM64_OpRsh64Ux64(v *Value) bool {
22842 v_1 := v.Args[1]
22843 v_0 := v.Args[0]
22844 b := v.Block
22845
22846
22847
22848 for {
22849 t := v.Type
22850 x := v_0
22851 y := v_1
22852 if !(shiftIsBounded(v)) {
22853 break
22854 }
22855 v.reset(OpARM64SRL)
22856 v.Type = t
22857 v.AddArg2(x, y)
22858 return true
22859 }
22860
22861
22862
22863 for {
22864 t := v.Type
22865 x := v_0
22866 y := v_1
22867 if !(!shiftIsBounded(v)) {
22868 break
22869 }
22870 v.reset(OpARM64CSEL)
22871 v.AuxInt = opToAuxInt(OpARM64LessThanU)
22872 v0 := b.NewValue0(v.Pos, OpARM64SRL, t)
22873 v0.AddArg2(x, y)
22874 v1 := b.NewValue0(v.Pos, OpConst64, t)
22875 v1.AuxInt = int64ToAuxInt(0)
22876 v2 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
22877 v2.AuxInt = int64ToAuxInt(64)
22878 v2.AddArg(y)
22879 v.AddArg3(v0, v1, v2)
22880 return true
22881 }
22882 return false
22883 }
22884 func rewriteValueARM64_OpRsh64Ux8(v *Value) bool {
22885 v_1 := v.Args[1]
22886 v_0 := v.Args[0]
22887 b := v.Block
22888 typ := &b.Func.Config.Types
22889
22890
22891
22892 for {
22893 t := v.Type
22894 x := v_0
22895 y := v_1
22896 if !(shiftIsBounded(v)) {
22897 break
22898 }
22899 v.reset(OpARM64SRL)
22900 v.Type = t
22901 v.AddArg2(x, y)
22902 return true
22903 }
22904
22905
22906
22907 for {
22908 t := v.Type
22909 bounded := auxIntToBool(v.AuxInt)
22910 x := v_0
22911 y := v_1
22912 if !(!shiftIsBounded(v)) {
22913 break
22914 }
22915 v.reset(OpRsh64Ux32)
22916 v.Type = t
22917 v.AuxInt = boolToAuxInt(bounded)
22918 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
22919 v0.AddArg(y)
22920 v.AddArg2(x, v0)
22921 return true
22922 }
22923 return false
22924 }
22925 func rewriteValueARM64_OpRsh64x16(v *Value) bool {
22926 v_1 := v.Args[1]
22927 v_0 := v.Args[0]
22928 b := v.Block
22929 typ := &b.Func.Config.Types
22930
22931
22932
22933 for {
22934 t := v.Type
22935 x := v_0
22936 y := v_1
22937 if !(shiftIsBounded(v)) {
22938 break
22939 }
22940 v.reset(OpARM64SRA)
22941 v.Type = t
22942 v.AddArg2(x, y)
22943 return true
22944 }
22945
22946
22947
22948 for {
22949 t := v.Type
22950 bounded := auxIntToBool(v.AuxInt)
22951 x := v_0
22952 y := v_1
22953 if !(!shiftIsBounded(v)) {
22954 break
22955 }
22956 v.reset(OpRsh64x32)
22957 v.Type = t
22958 v.AuxInt = boolToAuxInt(bounded)
22959 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
22960 v0.AddArg(y)
22961 v.AddArg2(x, v0)
22962 return true
22963 }
22964 return false
22965 }
22966 func rewriteValueARM64_OpRsh64x32(v *Value) bool {
22967 v_1 := v.Args[1]
22968 v_0 := v.Args[0]
22969 b := v.Block
22970
22971
22972
22973 for {
22974 t := v.Type
22975 x := v_0
22976 y := v_1
22977 if !(shiftIsBounded(v)) {
22978 break
22979 }
22980 v.reset(OpARM64SRA)
22981 v.Type = t
22982 v.AddArg2(x, y)
22983 return true
22984 }
22985
22986
22987
22988 for {
22989 x := v_0
22990 y := v_1
22991 if !(!shiftIsBounded(v)) {
22992 break
22993 }
22994 v.reset(OpARM64SRA)
22995 v0 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
22996 v0.AuxInt = opToAuxInt(OpARM64LessThanU)
22997 v1 := b.NewValue0(v.Pos, OpConst64, y.Type)
22998 v1.AuxInt = int64ToAuxInt(63)
22999 v2 := b.NewValue0(v.Pos, OpARM64CMPWconst, types.TypeFlags)
23000 v2.AuxInt = int32ToAuxInt(64)
23001 v2.AddArg(y)
23002 v0.AddArg3(y, v1, v2)
23003 v.AddArg2(x, v0)
23004 return true
23005 }
23006 return false
23007 }
23008 func rewriteValueARM64_OpRsh64x64(v *Value) bool {
23009 v_1 := v.Args[1]
23010 v_0 := v.Args[0]
23011 b := v.Block
23012
23013
23014
23015 for {
23016 t := v.Type
23017 x := v_0
23018 y := v_1
23019 if !(shiftIsBounded(v)) {
23020 break
23021 }
23022 v.reset(OpARM64SRA)
23023 v.Type = t
23024 v.AddArg2(x, y)
23025 return true
23026 }
23027
23028
23029
23030 for {
23031 x := v_0
23032 y := v_1
23033 if !(!shiftIsBounded(v)) {
23034 break
23035 }
23036 v.reset(OpARM64SRA)
23037 v0 := b.NewValue0(v.Pos, OpARM64CSEL, y.Type)
23038 v0.AuxInt = opToAuxInt(OpARM64LessThanU)
23039 v1 := b.NewValue0(v.Pos, OpConst64, y.Type)
23040 v1.AuxInt = int64ToAuxInt(63)
23041 v2 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23042 v2.AuxInt = int64ToAuxInt(64)
23043 v2.AddArg(y)
23044 v0.AddArg3(y, v1, v2)
23045 v.AddArg2(x, v0)
23046 return true
23047 }
23048 return false
23049 }
23050 func rewriteValueARM64_OpRsh64x8(v *Value) bool {
23051 v_1 := v.Args[1]
23052 v_0 := v.Args[0]
23053 b := v.Block
23054 typ := &b.Func.Config.Types
23055
23056
23057
23058 for {
23059 t := v.Type
23060 x := v_0
23061 y := v_1
23062 if !(shiftIsBounded(v)) {
23063 break
23064 }
23065 v.reset(OpARM64SRA)
23066 v.Type = t
23067 v.AddArg2(x, y)
23068 return true
23069 }
23070
23071
23072
23073 for {
23074 t := v.Type
23075 bounded := auxIntToBool(v.AuxInt)
23076 x := v_0
23077 y := v_1
23078 if !(!shiftIsBounded(v)) {
23079 break
23080 }
23081 v.reset(OpRsh64x32)
23082 v.Type = t
23083 v.AuxInt = boolToAuxInt(bounded)
23084 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
23085 v0.AddArg(y)
23086 v.AddArg2(x, v0)
23087 return true
23088 }
23089 return false
23090 }
23091 func rewriteValueARM64_OpRsh8Ux16(v *Value) bool {
23092 v_1 := v.Args[1]
23093 v_0 := v.Args[0]
23094 b := v.Block
23095 typ := &b.Func.Config.Types
23096
23097
23098 for {
23099 t := v.Type
23100 bounded := auxIntToBool(v.AuxInt)
23101 x := v_0
23102 y := v_1
23103 v.reset(OpRsh64Ux16)
23104 v.Type = t
23105 v.AuxInt = boolToAuxInt(bounded)
23106 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
23107 v0.AddArg(x)
23108 v.AddArg2(v0, y)
23109 return true
23110 }
23111 }
23112 func rewriteValueARM64_OpRsh8Ux32(v *Value) bool {
23113 v_1 := v.Args[1]
23114 v_0 := v.Args[0]
23115 b := v.Block
23116 typ := &b.Func.Config.Types
23117
23118
23119 for {
23120 t := v.Type
23121 bounded := auxIntToBool(v.AuxInt)
23122 x := v_0
23123 y := v_1
23124 v.reset(OpRsh64Ux32)
23125 v.Type = t
23126 v.AuxInt = boolToAuxInt(bounded)
23127 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
23128 v0.AddArg(x)
23129 v.AddArg2(v0, y)
23130 return true
23131 }
23132 }
23133 func rewriteValueARM64_OpRsh8Ux64(v *Value) bool {
23134 v_1 := v.Args[1]
23135 v_0 := v.Args[0]
23136 b := v.Block
23137 typ := &b.Func.Config.Types
23138
23139
23140 for {
23141 t := v.Type
23142 bounded := auxIntToBool(v.AuxInt)
23143 x := v_0
23144 y := v_1
23145 v.reset(OpRsh64Ux64)
23146 v.Type = t
23147 v.AuxInt = boolToAuxInt(bounded)
23148 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
23149 v0.AddArg(x)
23150 v.AddArg2(v0, y)
23151 return true
23152 }
23153 }
23154 func rewriteValueARM64_OpRsh8Ux8(v *Value) bool {
23155 v_1 := v.Args[1]
23156 v_0 := v.Args[0]
23157 b := v.Block
23158 typ := &b.Func.Config.Types
23159
23160
23161 for {
23162 t := v.Type
23163 bounded := auxIntToBool(v.AuxInt)
23164 x := v_0
23165 y := v_1
23166 v.reset(OpRsh64Ux8)
23167 v.Type = t
23168 v.AuxInt = boolToAuxInt(bounded)
23169 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
23170 v0.AddArg(x)
23171 v.AddArg2(v0, y)
23172 return true
23173 }
23174 }
23175 func rewriteValueARM64_OpRsh8x16(v *Value) bool {
23176 v_1 := v.Args[1]
23177 v_0 := v.Args[0]
23178 b := v.Block
23179 typ := &b.Func.Config.Types
23180
23181
23182 for {
23183 t := v.Type
23184 bounded := auxIntToBool(v.AuxInt)
23185 x := v_0
23186 y := v_1
23187 v.reset(OpRsh64x16)
23188 v.Type = t
23189 v.AuxInt = boolToAuxInt(bounded)
23190 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
23191 v0.AddArg(x)
23192 v.AddArg2(v0, y)
23193 return true
23194 }
23195 }
23196 func rewriteValueARM64_OpRsh8x32(v *Value) bool {
23197 v_1 := v.Args[1]
23198 v_0 := v.Args[0]
23199 b := v.Block
23200 typ := &b.Func.Config.Types
23201
23202
23203 for {
23204 t := v.Type
23205 bounded := auxIntToBool(v.AuxInt)
23206 x := v_0
23207 y := v_1
23208 v.reset(OpRsh64x32)
23209 v.Type = t
23210 v.AuxInt = boolToAuxInt(bounded)
23211 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
23212 v0.AddArg(x)
23213 v.AddArg2(v0, y)
23214 return true
23215 }
23216 }
23217 func rewriteValueARM64_OpRsh8x64(v *Value) bool {
23218 v_1 := v.Args[1]
23219 v_0 := v.Args[0]
23220 b := v.Block
23221 typ := &b.Func.Config.Types
23222
23223
23224 for {
23225 t := v.Type
23226 bounded := auxIntToBool(v.AuxInt)
23227 x := v_0
23228 y := v_1
23229 v.reset(OpRsh64x64)
23230 v.Type = t
23231 v.AuxInt = boolToAuxInt(bounded)
23232 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
23233 v0.AddArg(x)
23234 v.AddArg2(v0, y)
23235 return true
23236 }
23237 }
23238 func rewriteValueARM64_OpRsh8x8(v *Value) bool {
23239 v_1 := v.Args[1]
23240 v_0 := v.Args[0]
23241 b := v.Block
23242 typ := &b.Func.Config.Types
23243
23244
23245 for {
23246 t := v.Type
23247 bounded := auxIntToBool(v.AuxInt)
23248 x := v_0
23249 y := v_1
23250 v.reset(OpRsh64x8)
23251 v.Type = t
23252 v.AuxInt = boolToAuxInt(bounded)
23253 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
23254 v0.AddArg(x)
23255 v.AddArg2(v0, y)
23256 return true
23257 }
23258 }
23259 func rewriteValueARM64_OpSelect0(v *Value) bool {
23260 v_0 := v.Args[0]
23261 b := v.Block
23262 typ := &b.Func.Config.Types
23263
23264
23265 for {
23266 if v_0.Op != OpMul64uhilo {
23267 break
23268 }
23269 y := v_0.Args[1]
23270 x := v_0.Args[0]
23271 v.reset(OpARM64UMULH)
23272 v.AddArg2(x, y)
23273 return true
23274 }
23275
23276
23277 for {
23278 if v_0.Op != OpAdd64carry {
23279 break
23280 }
23281 c := v_0.Args[2]
23282 x := v_0.Args[0]
23283 y := v_0.Args[1]
23284 v.reset(OpSelect0)
23285 v.Type = typ.UInt64
23286 v0 := b.NewValue0(v.Pos, OpARM64ADCSflags, types.NewTuple(typ.UInt64, types.TypeFlags))
23287 v1 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
23288 v2 := b.NewValue0(v.Pos, OpARM64ADDSconstflags, types.NewTuple(typ.UInt64, types.TypeFlags))
23289 v2.AuxInt = int64ToAuxInt(-1)
23290 v2.AddArg(c)
23291 v1.AddArg(v2)
23292 v0.AddArg3(x, y, v1)
23293 v.AddArg(v0)
23294 return true
23295 }
23296
23297
23298 for {
23299 if v_0.Op != OpSub64borrow {
23300 break
23301 }
23302 bo := v_0.Args[2]
23303 x := v_0.Args[0]
23304 y := v_0.Args[1]
23305 v.reset(OpSelect0)
23306 v.Type = typ.UInt64
23307 v0 := b.NewValue0(v.Pos, OpARM64SBCSflags, types.NewTuple(typ.UInt64, types.TypeFlags))
23308 v1 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
23309 v2 := b.NewValue0(v.Pos, OpARM64NEGSflags, types.NewTuple(typ.UInt64, types.TypeFlags))
23310 v2.AddArg(bo)
23311 v1.AddArg(v2)
23312 v0.AddArg3(x, y, v1)
23313 v.AddArg(v0)
23314 return true
23315 }
23316
23317
23318 for {
23319 if v_0.Op != OpMul64uover {
23320 break
23321 }
23322 y := v_0.Args[1]
23323 x := v_0.Args[0]
23324 v.reset(OpARM64MUL)
23325 v.AddArg2(x, y)
23326 return true
23327 }
23328 return false
23329 }
23330 func rewriteValueARM64_OpSelect1(v *Value) bool {
23331 v_0 := v.Args[0]
23332 b := v.Block
23333 typ := &b.Func.Config.Types
23334
23335
23336 for {
23337 if v_0.Op != OpMul64uhilo {
23338 break
23339 }
23340 y := v_0.Args[1]
23341 x := v_0.Args[0]
23342 v.reset(OpARM64MUL)
23343 v.AddArg2(x, y)
23344 return true
23345 }
23346
23347
23348 for {
23349 if v_0.Op != OpAdd64carry {
23350 break
23351 }
23352 c := v_0.Args[2]
23353 x := v_0.Args[0]
23354 y := v_0.Args[1]
23355 v.reset(OpARM64ADCzerocarry)
23356 v.Type = typ.UInt64
23357 v0 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
23358 v1 := b.NewValue0(v.Pos, OpARM64ADCSflags, types.NewTuple(typ.UInt64, types.TypeFlags))
23359 v2 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
23360 v3 := b.NewValue0(v.Pos, OpARM64ADDSconstflags, types.NewTuple(typ.UInt64, types.TypeFlags))
23361 v3.AuxInt = int64ToAuxInt(-1)
23362 v3.AddArg(c)
23363 v2.AddArg(v3)
23364 v1.AddArg3(x, y, v2)
23365 v0.AddArg(v1)
23366 v.AddArg(v0)
23367 return true
23368 }
23369
23370
23371 for {
23372 if v_0.Op != OpSub64borrow {
23373 break
23374 }
23375 bo := v_0.Args[2]
23376 x := v_0.Args[0]
23377 y := v_0.Args[1]
23378 v.reset(OpARM64NEG)
23379 v.Type = typ.UInt64
23380 v0 := b.NewValue0(v.Pos, OpARM64NGCzerocarry, typ.UInt64)
23381 v1 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
23382 v2 := b.NewValue0(v.Pos, OpARM64SBCSflags, types.NewTuple(typ.UInt64, types.TypeFlags))
23383 v3 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
23384 v4 := b.NewValue0(v.Pos, OpARM64NEGSflags, types.NewTuple(typ.UInt64, types.TypeFlags))
23385 v4.AddArg(bo)
23386 v3.AddArg(v4)
23387 v2.AddArg3(x, y, v3)
23388 v1.AddArg(v2)
23389 v0.AddArg(v1)
23390 v.AddArg(v0)
23391 return true
23392 }
23393
23394
23395 for {
23396 if v_0.Op != OpMul64uover {
23397 break
23398 }
23399 y := v_0.Args[1]
23400 x := v_0.Args[0]
23401 v.reset(OpARM64NotEqual)
23402 v0 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23403 v0.AuxInt = int64ToAuxInt(0)
23404 v1 := b.NewValue0(v.Pos, OpARM64UMULH, typ.UInt64)
23405 v1.AddArg2(x, y)
23406 v0.AddArg(v1)
23407 v.AddArg(v0)
23408 return true
23409 }
23410 return false
23411 }
23412 func rewriteValueARM64_OpSelectN(v *Value) bool {
23413 v_0 := v.Args[0]
23414 b := v.Block
23415 config := b.Func.Config
23416
23417
23418
23419 for {
23420 if auxIntToInt64(v.AuxInt) != 0 {
23421 break
23422 }
23423 call := v_0
23424 if call.Op != OpARM64CALLstatic || len(call.Args) != 1 {
23425 break
23426 }
23427 sym := auxToCall(call.Aux)
23428 s1 := call.Args[0]
23429 if s1.Op != OpARM64MOVDstore {
23430 break
23431 }
23432 _ = s1.Args[2]
23433 s1_1 := s1.Args[1]
23434 if s1_1.Op != OpARM64MOVDconst {
23435 break
23436 }
23437 sz := auxIntToInt64(s1_1.AuxInt)
23438 s2 := s1.Args[2]
23439 if s2.Op != OpARM64MOVDstore {
23440 break
23441 }
23442 _ = s2.Args[2]
23443 src := s2.Args[1]
23444 s3 := s2.Args[2]
23445 if s3.Op != OpARM64MOVDstore {
23446 break
23447 }
23448 mem := s3.Args[2]
23449 dst := s3.Args[1]
23450 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)) {
23451 break
23452 }
23453 v.reset(OpMove)
23454 v.AuxInt = int64ToAuxInt(sz)
23455 v.AddArg3(dst, src, mem)
23456 return true
23457 }
23458
23459
23460
23461 for {
23462 if auxIntToInt64(v.AuxInt) != 0 {
23463 break
23464 }
23465 call := v_0
23466 if call.Op != OpARM64CALLstatic || len(call.Args) != 4 {
23467 break
23468 }
23469 sym := auxToCall(call.Aux)
23470 mem := call.Args[3]
23471 dst := call.Args[0]
23472 src := call.Args[1]
23473 call_2 := call.Args[2]
23474 if call_2.Op != OpARM64MOVDconst {
23475 break
23476 }
23477 sz := auxIntToInt64(call_2.AuxInt)
23478 if !(sz >= 0 && isSameCall(sym, "runtime.memmove") && call.Uses == 1 && isInlinableMemmove(dst, src, sz, config) && clobber(call)) {
23479 break
23480 }
23481 v.reset(OpMove)
23482 v.AuxInt = int64ToAuxInt(sz)
23483 v.AddArg3(dst, src, mem)
23484 return true
23485 }
23486 return false
23487 }
23488 func rewriteValueARM64_OpShiftAllLeftInt16x8(v *Value) bool {
23489 v_1 := v.Args[1]
23490 v_0 := v.Args[0]
23491 b := v.Block
23492 typ := &b.Func.Config.Types
23493
23494
23495 for {
23496 x := v_0
23497 y := v_1
23498 v.reset(OpARM64VSSHL8H)
23499 v0 := b.NewValue0(v.Pos, OpARM64VDUPHbcast, typ.Vec128)
23500 v0.AuxInt = uint8ToAuxInt(0)
23501 v1 := b.NewValue0(v.Pos, OpARM64VMOVHins, typ.Vec128)
23502 v1.AuxInt = uint8ToAuxInt(0)
23503 v2 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23504 v2.AuxInt = opToAuxInt(OpARM64LessThanU)
23505 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23506 v3.AuxInt = int64ToAuxInt(127)
23507 v4 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23508 v4.AuxInt = int64ToAuxInt(127)
23509 v4.AddArg(y)
23510 v2.AddArg3(y, v3, v4)
23511 v1.AddArg2(x, v2)
23512 v0.AddArg(v1)
23513 v.AddArg2(x, v0)
23514 return true
23515 }
23516 }
23517 func rewriteValueARM64_OpShiftAllLeftInt32x4(v *Value) bool {
23518 v_1 := v.Args[1]
23519 v_0 := v.Args[0]
23520 b := v.Block
23521 typ := &b.Func.Config.Types
23522
23523
23524 for {
23525 x := v_0
23526 y := v_1
23527 v.reset(OpARM64VSSHL4S)
23528 v0 := b.NewValue0(v.Pos, OpARM64VDUPSbcast, typ.Vec128)
23529 v0.AuxInt = uint8ToAuxInt(0)
23530 v1 := b.NewValue0(v.Pos, OpARM64VMOVSins, typ.Vec128)
23531 v1.AuxInt = uint8ToAuxInt(0)
23532 v2 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23533 v2.AuxInt = opToAuxInt(OpARM64LessThanU)
23534 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23535 v3.AuxInt = int64ToAuxInt(127)
23536 v4 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23537 v4.AuxInt = int64ToAuxInt(127)
23538 v4.AddArg(y)
23539 v2.AddArg3(y, v3, v4)
23540 v1.AddArg2(x, v2)
23541 v0.AddArg(v1)
23542 v.AddArg2(x, v0)
23543 return true
23544 }
23545 }
23546 func rewriteValueARM64_OpShiftAllLeftInt64x2(v *Value) bool {
23547 v_1 := v.Args[1]
23548 v_0 := v.Args[0]
23549 b := v.Block
23550 typ := &b.Func.Config.Types
23551
23552
23553 for {
23554 x := v_0
23555 y := v_1
23556 v.reset(OpARM64VSSHL2D)
23557 v0 := b.NewValue0(v.Pos, OpARM64VDUPDbcast, typ.Vec128)
23558 v0.AuxInt = uint8ToAuxInt(0)
23559 v1 := b.NewValue0(v.Pos, OpARM64VMOVDins, typ.Vec128)
23560 v1.AuxInt = uint8ToAuxInt(0)
23561 v2 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23562 v2.AuxInt = opToAuxInt(OpARM64LessThanU)
23563 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23564 v3.AuxInt = int64ToAuxInt(127)
23565 v4 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23566 v4.AuxInt = int64ToAuxInt(127)
23567 v4.AddArg(y)
23568 v2.AddArg3(y, v3, v4)
23569 v1.AddArg2(x, v2)
23570 v0.AddArg(v1)
23571 v.AddArg2(x, v0)
23572 return true
23573 }
23574 }
23575 func rewriteValueARM64_OpShiftAllLeftInt8x16(v *Value) bool {
23576 v_1 := v.Args[1]
23577 v_0 := v.Args[0]
23578 b := v.Block
23579 typ := &b.Func.Config.Types
23580
23581
23582 for {
23583 x := v_0
23584 y := v_1
23585 v.reset(OpARM64VSSHL16B)
23586 v0 := b.NewValue0(v.Pos, OpARM64VDUPBbcast, typ.Vec128)
23587 v0.AuxInt = uint8ToAuxInt(0)
23588 v1 := b.NewValue0(v.Pos, OpARM64VMOVBins, typ.Vec128)
23589 v1.AuxInt = uint8ToAuxInt(0)
23590 v2 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23591 v2.AuxInt = opToAuxInt(OpARM64LessThanU)
23592 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23593 v3.AuxInt = int64ToAuxInt(127)
23594 v4 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23595 v4.AuxInt = int64ToAuxInt(127)
23596 v4.AddArg(y)
23597 v2.AddArg3(y, v3, v4)
23598 v1.AddArg2(x, v2)
23599 v0.AddArg(v1)
23600 v.AddArg2(x, v0)
23601 return true
23602 }
23603 }
23604 func rewriteValueARM64_OpShiftAllLeftUint16x8(v *Value) bool {
23605 v_1 := v.Args[1]
23606 v_0 := v.Args[0]
23607 b := v.Block
23608 typ := &b.Func.Config.Types
23609
23610
23611 for {
23612 x := v_0
23613 y := v_1
23614 v.reset(OpARM64VUSHL8H)
23615 v0 := b.NewValue0(v.Pos, OpARM64VDUPHbcast, typ.Vec128)
23616 v0.AuxInt = uint8ToAuxInt(0)
23617 v1 := b.NewValue0(v.Pos, OpARM64VMOVHins, typ.Vec128)
23618 v1.AuxInt = uint8ToAuxInt(0)
23619 v2 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23620 v2.AuxInt = opToAuxInt(OpARM64LessThanU)
23621 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23622 v3.AuxInt = int64ToAuxInt(127)
23623 v4 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23624 v4.AuxInt = int64ToAuxInt(127)
23625 v4.AddArg(y)
23626 v2.AddArg3(y, v3, v4)
23627 v1.AddArg2(x, v2)
23628 v0.AddArg(v1)
23629 v.AddArg2(x, v0)
23630 return true
23631 }
23632 }
23633 func rewriteValueARM64_OpShiftAllLeftUint32x4(v *Value) bool {
23634 v_1 := v.Args[1]
23635 v_0 := v.Args[0]
23636 b := v.Block
23637 typ := &b.Func.Config.Types
23638
23639
23640 for {
23641 x := v_0
23642 y := v_1
23643 v.reset(OpARM64VUSHL4S)
23644 v0 := b.NewValue0(v.Pos, OpARM64VDUPSbcast, typ.Vec128)
23645 v0.AuxInt = uint8ToAuxInt(0)
23646 v1 := b.NewValue0(v.Pos, OpARM64VMOVSins, typ.Vec128)
23647 v1.AuxInt = uint8ToAuxInt(0)
23648 v2 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23649 v2.AuxInt = opToAuxInt(OpARM64LessThanU)
23650 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23651 v3.AuxInt = int64ToAuxInt(127)
23652 v4 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23653 v4.AuxInt = int64ToAuxInt(127)
23654 v4.AddArg(y)
23655 v2.AddArg3(y, v3, v4)
23656 v1.AddArg2(x, v2)
23657 v0.AddArg(v1)
23658 v.AddArg2(x, v0)
23659 return true
23660 }
23661 }
23662 func rewriteValueARM64_OpShiftAllLeftUint64x2(v *Value) bool {
23663 v_1 := v.Args[1]
23664 v_0 := v.Args[0]
23665 b := v.Block
23666 typ := &b.Func.Config.Types
23667
23668
23669 for {
23670 x := v_0
23671 y := v_1
23672 v.reset(OpARM64VUSHL2D)
23673 v0 := b.NewValue0(v.Pos, OpARM64VDUPDbcast, typ.Vec128)
23674 v0.AuxInt = uint8ToAuxInt(0)
23675 v1 := b.NewValue0(v.Pos, OpARM64VMOVDins, typ.Vec128)
23676 v1.AuxInt = uint8ToAuxInt(0)
23677 v2 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23678 v2.AuxInt = opToAuxInt(OpARM64LessThanU)
23679 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23680 v3.AuxInt = int64ToAuxInt(127)
23681 v4 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23682 v4.AuxInt = int64ToAuxInt(127)
23683 v4.AddArg(y)
23684 v2.AddArg3(y, v3, v4)
23685 v1.AddArg2(x, v2)
23686 v0.AddArg(v1)
23687 v.AddArg2(x, v0)
23688 return true
23689 }
23690 }
23691 func rewriteValueARM64_OpShiftAllLeftUint8x16(v *Value) bool {
23692 v_1 := v.Args[1]
23693 v_0 := v.Args[0]
23694 b := v.Block
23695 typ := &b.Func.Config.Types
23696
23697
23698 for {
23699 x := v_0
23700 y := v_1
23701 v.reset(OpARM64VUSHL16B)
23702 v0 := b.NewValue0(v.Pos, OpARM64VDUPBbcast, typ.Vec128)
23703 v0.AuxInt = uint8ToAuxInt(0)
23704 v1 := b.NewValue0(v.Pos, OpARM64VMOVBins, typ.Vec128)
23705 v1.AuxInt = uint8ToAuxInt(0)
23706 v2 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23707 v2.AuxInt = opToAuxInt(OpARM64LessThanU)
23708 v3 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23709 v3.AuxInt = int64ToAuxInt(127)
23710 v4 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23711 v4.AuxInt = int64ToAuxInt(127)
23712 v4.AddArg(y)
23713 v2.AddArg3(y, v3, v4)
23714 v1.AddArg2(x, v2)
23715 v0.AddArg(v1)
23716 v.AddArg2(x, v0)
23717 return true
23718 }
23719 }
23720 func rewriteValueARM64_OpShiftAllRightInt16x8(v *Value) bool {
23721 v_1 := v.Args[1]
23722 v_0 := v.Args[0]
23723 b := v.Block
23724 typ := &b.Func.Config.Types
23725
23726
23727 for {
23728 x := v_0
23729 y := v_1
23730 v.reset(OpARM64VSSHL8H)
23731 v0 := b.NewValue0(v.Pos, OpARM64VDUPHbcast, typ.Vec128)
23732 v0.AuxInt = uint8ToAuxInt(0)
23733 v1 := b.NewValue0(v.Pos, OpARM64VMOVHins, typ.Vec128)
23734 v1.AuxInt = uint8ToAuxInt(0)
23735 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
23736 v3 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23737 v3.AuxInt = opToAuxInt(OpARM64LessThanU)
23738 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23739 v4.AuxInt = int64ToAuxInt(127)
23740 v5 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23741 v5.AuxInt = int64ToAuxInt(127)
23742 v5.AddArg(y)
23743 v3.AddArg3(y, v4, v5)
23744 v2.AddArg(v3)
23745 v1.AddArg2(x, v2)
23746 v0.AddArg(v1)
23747 v.AddArg2(x, v0)
23748 return true
23749 }
23750 }
23751 func rewriteValueARM64_OpShiftAllRightInt32x4(v *Value) bool {
23752 v_1 := v.Args[1]
23753 v_0 := v.Args[0]
23754 b := v.Block
23755 typ := &b.Func.Config.Types
23756
23757
23758 for {
23759 x := v_0
23760 y := v_1
23761 v.reset(OpARM64VSSHL4S)
23762 v0 := b.NewValue0(v.Pos, OpARM64VDUPSbcast, typ.Vec128)
23763 v0.AuxInt = uint8ToAuxInt(0)
23764 v1 := b.NewValue0(v.Pos, OpARM64VMOVSins, typ.Vec128)
23765 v1.AuxInt = uint8ToAuxInt(0)
23766 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
23767 v3 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23768 v3.AuxInt = opToAuxInt(OpARM64LessThanU)
23769 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23770 v4.AuxInt = int64ToAuxInt(127)
23771 v5 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23772 v5.AuxInt = int64ToAuxInt(127)
23773 v5.AddArg(y)
23774 v3.AddArg3(y, v4, v5)
23775 v2.AddArg(v3)
23776 v1.AddArg2(x, v2)
23777 v0.AddArg(v1)
23778 v.AddArg2(x, v0)
23779 return true
23780 }
23781 }
23782 func rewriteValueARM64_OpShiftAllRightInt64x2(v *Value) bool {
23783 v_1 := v.Args[1]
23784 v_0 := v.Args[0]
23785 b := v.Block
23786 typ := &b.Func.Config.Types
23787
23788
23789 for {
23790 x := v_0
23791 y := v_1
23792 v.reset(OpARM64VSSHL2D)
23793 v0 := b.NewValue0(v.Pos, OpARM64VDUPDbcast, typ.Vec128)
23794 v0.AuxInt = uint8ToAuxInt(0)
23795 v1 := b.NewValue0(v.Pos, OpARM64VMOVDins, typ.Vec128)
23796 v1.AuxInt = uint8ToAuxInt(0)
23797 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
23798 v3 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23799 v3.AuxInt = opToAuxInt(OpARM64LessThanU)
23800 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23801 v4.AuxInt = int64ToAuxInt(127)
23802 v5 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23803 v5.AuxInt = int64ToAuxInt(127)
23804 v5.AddArg(y)
23805 v3.AddArg3(y, v4, v5)
23806 v2.AddArg(v3)
23807 v1.AddArg2(x, v2)
23808 v0.AddArg(v1)
23809 v.AddArg2(x, v0)
23810 return true
23811 }
23812 }
23813 func rewriteValueARM64_OpShiftAllRightInt8x16(v *Value) bool {
23814 v_1 := v.Args[1]
23815 v_0 := v.Args[0]
23816 b := v.Block
23817 typ := &b.Func.Config.Types
23818
23819
23820 for {
23821 x := v_0
23822 y := v_1
23823 v.reset(OpARM64VSSHL16B)
23824 v0 := b.NewValue0(v.Pos, OpARM64VDUPBbcast, typ.Vec128)
23825 v0.AuxInt = uint8ToAuxInt(0)
23826 v1 := b.NewValue0(v.Pos, OpARM64VMOVBins, typ.Vec128)
23827 v1.AuxInt = uint8ToAuxInt(0)
23828 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
23829 v3 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23830 v3.AuxInt = opToAuxInt(OpARM64LessThanU)
23831 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23832 v4.AuxInt = int64ToAuxInt(127)
23833 v5 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23834 v5.AuxInt = int64ToAuxInt(127)
23835 v5.AddArg(y)
23836 v3.AddArg3(y, v4, v5)
23837 v2.AddArg(v3)
23838 v1.AddArg2(x, v2)
23839 v0.AddArg(v1)
23840 v.AddArg2(x, v0)
23841 return true
23842 }
23843 }
23844 func rewriteValueARM64_OpShiftAllRightUint16x8(v *Value) bool {
23845 v_1 := v.Args[1]
23846 v_0 := v.Args[0]
23847 b := v.Block
23848 typ := &b.Func.Config.Types
23849
23850
23851 for {
23852 x := v_0
23853 y := v_1
23854 v.reset(OpARM64VUSHL8H)
23855 v0 := b.NewValue0(v.Pos, OpARM64VDUPHbcast, typ.Vec128)
23856 v0.AuxInt = uint8ToAuxInt(0)
23857 v1 := b.NewValue0(v.Pos, OpARM64VMOVHins, typ.Vec128)
23858 v1.AuxInt = uint8ToAuxInt(0)
23859 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
23860 v3 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23861 v3.AuxInt = opToAuxInt(OpARM64LessThanU)
23862 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23863 v4.AuxInt = int64ToAuxInt(127)
23864 v5 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23865 v5.AuxInt = int64ToAuxInt(127)
23866 v5.AddArg(y)
23867 v3.AddArg3(y, v4, v5)
23868 v2.AddArg(v3)
23869 v1.AddArg2(x, v2)
23870 v0.AddArg(v1)
23871 v.AddArg2(x, v0)
23872 return true
23873 }
23874 }
23875 func rewriteValueARM64_OpShiftAllRightUint32x4(v *Value) bool {
23876 v_1 := v.Args[1]
23877 v_0 := v.Args[0]
23878 b := v.Block
23879 typ := &b.Func.Config.Types
23880
23881
23882 for {
23883 x := v_0
23884 y := v_1
23885 v.reset(OpARM64VUSHL4S)
23886 v0 := b.NewValue0(v.Pos, OpARM64VDUPSbcast, typ.Vec128)
23887 v0.AuxInt = uint8ToAuxInt(0)
23888 v1 := b.NewValue0(v.Pos, OpARM64VMOVSins, typ.Vec128)
23889 v1.AuxInt = uint8ToAuxInt(0)
23890 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
23891 v3 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23892 v3.AuxInt = opToAuxInt(OpARM64LessThanU)
23893 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23894 v4.AuxInt = int64ToAuxInt(127)
23895 v5 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23896 v5.AuxInt = int64ToAuxInt(127)
23897 v5.AddArg(y)
23898 v3.AddArg3(y, v4, v5)
23899 v2.AddArg(v3)
23900 v1.AddArg2(x, v2)
23901 v0.AddArg(v1)
23902 v.AddArg2(x, v0)
23903 return true
23904 }
23905 }
23906 func rewriteValueARM64_OpShiftAllRightUint64x2(v *Value) bool {
23907 v_1 := v.Args[1]
23908 v_0 := v.Args[0]
23909 b := v.Block
23910 typ := &b.Func.Config.Types
23911
23912
23913 for {
23914 x := v_0
23915 y := v_1
23916 v.reset(OpARM64VUSHL2D)
23917 v0 := b.NewValue0(v.Pos, OpARM64VDUPDbcast, typ.Vec128)
23918 v0.AuxInt = uint8ToAuxInt(0)
23919 v1 := b.NewValue0(v.Pos, OpARM64VMOVDins, typ.Vec128)
23920 v1.AuxInt = uint8ToAuxInt(0)
23921 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
23922 v3 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23923 v3.AuxInt = opToAuxInt(OpARM64LessThanU)
23924 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23925 v4.AuxInt = int64ToAuxInt(127)
23926 v5 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23927 v5.AuxInt = int64ToAuxInt(127)
23928 v5.AddArg(y)
23929 v3.AddArg3(y, v4, v5)
23930 v2.AddArg(v3)
23931 v1.AddArg2(x, v2)
23932 v0.AddArg(v1)
23933 v.AddArg2(x, v0)
23934 return true
23935 }
23936 }
23937 func rewriteValueARM64_OpShiftAllRightUint8x16(v *Value) bool {
23938 v_1 := v.Args[1]
23939 v_0 := v.Args[0]
23940 b := v.Block
23941 typ := &b.Func.Config.Types
23942
23943
23944 for {
23945 x := v_0
23946 y := v_1
23947 v.reset(OpARM64VUSHL16B)
23948 v0 := b.NewValue0(v.Pos, OpARM64VDUPBbcast, typ.Vec128)
23949 v0.AuxInt = uint8ToAuxInt(0)
23950 v1 := b.NewValue0(v.Pos, OpARM64VMOVBins, typ.Vec128)
23951 v1.AuxInt = uint8ToAuxInt(0)
23952 v2 := b.NewValue0(v.Pos, OpARM64NEG, typ.Int64)
23953 v3 := b.NewValue0(v.Pos, OpARM64CSEL, typ.UInt64)
23954 v3.AuxInt = opToAuxInt(OpARM64LessThanU)
23955 v4 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
23956 v4.AuxInt = int64ToAuxInt(127)
23957 v5 := b.NewValue0(v.Pos, OpARM64CMPconst, types.TypeFlags)
23958 v5.AuxInt = int64ToAuxInt(127)
23959 v5.AddArg(y)
23960 v3.AddArg3(y, v4, v5)
23961 v2.AddArg(v3)
23962 v1.AddArg2(x, v2)
23963 v0.AddArg(v1)
23964 v.AddArg2(x, v0)
23965 return true
23966 }
23967 }
23968 func rewriteValueARM64_OpSlicemask(v *Value) bool {
23969 v_0 := v.Args[0]
23970 b := v.Block
23971
23972
23973 for {
23974 t := v.Type
23975 x := v_0
23976 v.reset(OpARM64SRAconst)
23977 v.AuxInt = int64ToAuxInt(63)
23978 v0 := b.NewValue0(v.Pos, OpARM64NEG, t)
23979 v0.AddArg(x)
23980 v.AddArg(v0)
23981 return true
23982 }
23983 }
23984 func rewriteValueARM64_OpStore(v *Value) bool {
23985 v_2 := v.Args[2]
23986 v_1 := v.Args[1]
23987 v_0 := v.Args[0]
23988
23989
23990
23991 for {
23992 t := auxToType(v.Aux)
23993 ptr := v_0
23994 val := v_1
23995 mem := v_2
23996 if !(t.Size() == 1) {
23997 break
23998 }
23999 v.reset(OpARM64MOVBstore)
24000 v.AddArg3(ptr, val, mem)
24001 return true
24002 }
24003
24004
24005
24006 for {
24007 t := auxToType(v.Aux)
24008 ptr := v_0
24009 val := v_1
24010 mem := v_2
24011 if !(t.Size() == 2) {
24012 break
24013 }
24014 v.reset(OpARM64MOVHstore)
24015 v.AddArg3(ptr, val, mem)
24016 return true
24017 }
24018
24019
24020
24021 for {
24022 t := auxToType(v.Aux)
24023 ptr := v_0
24024 val := v_1
24025 mem := v_2
24026 if !(t.Size() == 4 && !t.IsFloat()) {
24027 break
24028 }
24029 v.reset(OpARM64MOVWstore)
24030 v.AddArg3(ptr, val, mem)
24031 return true
24032 }
24033
24034
24035
24036 for {
24037 t := auxToType(v.Aux)
24038 ptr := v_0
24039 val := v_1
24040 mem := v_2
24041 if !(t.Size() == 8 && !t.IsFloat()) {
24042 break
24043 }
24044 v.reset(OpARM64MOVDstore)
24045 v.AddArg3(ptr, val, mem)
24046 return true
24047 }
24048
24049
24050
24051 for {
24052 t := auxToType(v.Aux)
24053 ptr := v_0
24054 val := v_1
24055 mem := v_2
24056 if !(t.Size() == 4 && t.IsFloat()) {
24057 break
24058 }
24059 v.reset(OpARM64FMOVSstore)
24060 v.AddArg3(ptr, val, mem)
24061 return true
24062 }
24063
24064
24065
24066 for {
24067 t := auxToType(v.Aux)
24068 ptr := v_0
24069 val := v_1
24070 mem := v_2
24071 if !(t.Size() == 8 && t.IsFloat()) {
24072 break
24073 }
24074 v.reset(OpARM64FMOVDstore)
24075 v.AddArg3(ptr, val, mem)
24076 return true
24077 }
24078
24079
24080
24081 for {
24082 t := auxToType(v.Aux)
24083 ptr := v_0
24084 val := v_1
24085 mem := v_2
24086 if !(t.Size() == 16) {
24087 break
24088 }
24089 v.reset(OpARM64FMOVQstore)
24090 v.AddArg3(ptr, val, mem)
24091 return true
24092 }
24093 return false
24094 }
24095 func rewriteValueARM64_OpZero(v *Value) bool {
24096 v_1 := v.Args[1]
24097 v_0 := v.Args[0]
24098 b := v.Block
24099 typ := &b.Func.Config.Types
24100
24101
24102 for {
24103 if auxIntToInt64(v.AuxInt) != 0 {
24104 break
24105 }
24106 mem := v_1
24107 v.copyOf(mem)
24108 return true
24109 }
24110
24111
24112 for {
24113 if auxIntToInt64(v.AuxInt) != 1 {
24114 break
24115 }
24116 ptr := v_0
24117 mem := v_1
24118 v.reset(OpARM64MOVBstore)
24119 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24120 v0.AuxInt = int64ToAuxInt(0)
24121 v.AddArg3(ptr, v0, mem)
24122 return true
24123 }
24124
24125
24126 for {
24127 if auxIntToInt64(v.AuxInt) != 2 {
24128 break
24129 }
24130 ptr := v_0
24131 mem := v_1
24132 v.reset(OpARM64MOVHstore)
24133 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24134 v0.AuxInt = int64ToAuxInt(0)
24135 v.AddArg3(ptr, v0, mem)
24136 return true
24137 }
24138
24139
24140 for {
24141 if auxIntToInt64(v.AuxInt) != 4 {
24142 break
24143 }
24144 ptr := v_0
24145 mem := v_1
24146 v.reset(OpARM64MOVWstore)
24147 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24148 v0.AuxInt = int64ToAuxInt(0)
24149 v.AddArg3(ptr, v0, mem)
24150 return true
24151 }
24152
24153
24154 for {
24155 if auxIntToInt64(v.AuxInt) != 3 {
24156 break
24157 }
24158 ptr := v_0
24159 mem := v_1
24160 v.reset(OpARM64MOVBstore)
24161 v.AuxInt = int32ToAuxInt(2)
24162 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24163 v0.AuxInt = int64ToAuxInt(0)
24164 v1 := b.NewValue0(v.Pos, OpARM64MOVHstore, types.TypeMem)
24165 v1.AddArg3(ptr, v0, mem)
24166 v.AddArg3(ptr, v0, v1)
24167 return true
24168 }
24169
24170
24171 for {
24172 if auxIntToInt64(v.AuxInt) != 5 {
24173 break
24174 }
24175 ptr := v_0
24176 mem := v_1
24177 v.reset(OpARM64MOVBstore)
24178 v.AuxInt = int32ToAuxInt(4)
24179 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24180 v0.AuxInt = int64ToAuxInt(0)
24181 v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, types.TypeMem)
24182 v1.AddArg3(ptr, v0, mem)
24183 v.AddArg3(ptr, v0, v1)
24184 return true
24185 }
24186
24187
24188 for {
24189 if auxIntToInt64(v.AuxInt) != 6 {
24190 break
24191 }
24192 ptr := v_0
24193 mem := v_1
24194 v.reset(OpARM64MOVHstore)
24195 v.AuxInt = int32ToAuxInt(4)
24196 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24197 v0.AuxInt = int64ToAuxInt(0)
24198 v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, types.TypeMem)
24199 v1.AddArg3(ptr, v0, mem)
24200 v.AddArg3(ptr, v0, v1)
24201 return true
24202 }
24203
24204
24205 for {
24206 if auxIntToInt64(v.AuxInt) != 7 {
24207 break
24208 }
24209 ptr := v_0
24210 mem := v_1
24211 v.reset(OpARM64MOVWstore)
24212 v.AuxInt = int32ToAuxInt(3)
24213 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24214 v0.AuxInt = int64ToAuxInt(0)
24215 v1 := b.NewValue0(v.Pos, OpARM64MOVWstore, types.TypeMem)
24216 v1.AddArg3(ptr, v0, mem)
24217 v.AddArg3(ptr, v0, v1)
24218 return true
24219 }
24220
24221
24222 for {
24223 if auxIntToInt64(v.AuxInt) != 8 {
24224 break
24225 }
24226 ptr := v_0
24227 mem := v_1
24228 v.reset(OpARM64MOVDstore)
24229 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24230 v0.AuxInt = int64ToAuxInt(0)
24231 v.AddArg3(ptr, v0, mem)
24232 return true
24233 }
24234
24235
24236 for {
24237 if auxIntToInt64(v.AuxInt) != 9 {
24238 break
24239 }
24240 ptr := v_0
24241 mem := v_1
24242 v.reset(OpARM64MOVBstore)
24243 v.AuxInt = int32ToAuxInt(8)
24244 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24245 v0.AuxInt = int64ToAuxInt(0)
24246 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
24247 v1.AddArg3(ptr, v0, mem)
24248 v.AddArg3(ptr, v0, v1)
24249 return true
24250 }
24251
24252
24253 for {
24254 if auxIntToInt64(v.AuxInt) != 10 {
24255 break
24256 }
24257 ptr := v_0
24258 mem := v_1
24259 v.reset(OpARM64MOVHstore)
24260 v.AuxInt = int32ToAuxInt(8)
24261 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24262 v0.AuxInt = int64ToAuxInt(0)
24263 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
24264 v1.AddArg3(ptr, v0, mem)
24265 v.AddArg3(ptr, v0, v1)
24266 return true
24267 }
24268
24269
24270 for {
24271 if auxIntToInt64(v.AuxInt) != 11 {
24272 break
24273 }
24274 ptr := v_0
24275 mem := v_1
24276 v.reset(OpARM64MOVDstore)
24277 v.AuxInt = int32ToAuxInt(3)
24278 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24279 v0.AuxInt = int64ToAuxInt(0)
24280 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
24281 v1.AddArg3(ptr, v0, mem)
24282 v.AddArg3(ptr, v0, v1)
24283 return true
24284 }
24285
24286
24287 for {
24288 if auxIntToInt64(v.AuxInt) != 12 {
24289 break
24290 }
24291 ptr := v_0
24292 mem := v_1
24293 v.reset(OpARM64MOVWstore)
24294 v.AuxInt = int32ToAuxInt(8)
24295 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24296 v0.AuxInt = int64ToAuxInt(0)
24297 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
24298 v1.AddArg3(ptr, v0, mem)
24299 v.AddArg3(ptr, v0, v1)
24300 return true
24301 }
24302
24303
24304 for {
24305 if auxIntToInt64(v.AuxInt) != 13 {
24306 break
24307 }
24308 ptr := v_0
24309 mem := v_1
24310 v.reset(OpARM64MOVDstore)
24311 v.AuxInt = int32ToAuxInt(5)
24312 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24313 v0.AuxInt = int64ToAuxInt(0)
24314 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
24315 v1.AddArg3(ptr, v0, mem)
24316 v.AddArg3(ptr, v0, v1)
24317 return true
24318 }
24319
24320
24321 for {
24322 if auxIntToInt64(v.AuxInt) != 14 {
24323 break
24324 }
24325 ptr := v_0
24326 mem := v_1
24327 v.reset(OpARM64MOVDstore)
24328 v.AuxInt = int32ToAuxInt(6)
24329 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24330 v0.AuxInt = int64ToAuxInt(0)
24331 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
24332 v1.AddArg3(ptr, v0, mem)
24333 v.AddArg3(ptr, v0, v1)
24334 return true
24335 }
24336
24337
24338 for {
24339 if auxIntToInt64(v.AuxInt) != 15 {
24340 break
24341 }
24342 ptr := v_0
24343 mem := v_1
24344 v.reset(OpARM64MOVDstore)
24345 v.AuxInt = int32ToAuxInt(7)
24346 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24347 v0.AuxInt = int64ToAuxInt(0)
24348 v1 := b.NewValue0(v.Pos, OpARM64MOVDstore, types.TypeMem)
24349 v1.AddArg3(ptr, v0, mem)
24350 v.AddArg3(ptr, v0, v1)
24351 return true
24352 }
24353
24354
24355 for {
24356 if auxIntToInt64(v.AuxInt) != 16 {
24357 break
24358 }
24359 ptr := v_0
24360 mem := v_1
24361 v.reset(OpARM64STP)
24362 v.AuxInt = int32ToAuxInt(0)
24363 v0 := b.NewValue0(v.Pos, OpARM64MOVDconst, typ.UInt64)
24364 v0.AuxInt = int64ToAuxInt(0)
24365 v.AddArg4(ptr, v0, v0, mem)
24366 return true
24367 }
24368
24369
24370
24371 for {
24372 s := auxIntToInt64(v.AuxInt)
24373 ptr := v_0
24374 mem := v_1
24375 if !(s > 16 && s < 192) {
24376 break
24377 }
24378 v.reset(OpARM64LoweredZero)
24379 v.AuxInt = int64ToAuxInt(s)
24380 v.AddArg2(ptr, mem)
24381 return true
24382 }
24383
24384
24385
24386 for {
24387 s := auxIntToInt64(v.AuxInt)
24388 ptr := v_0
24389 mem := v_1
24390 if !(s >= 192) {
24391 break
24392 }
24393 v.reset(OpARM64LoweredZeroLoop)
24394 v.AuxInt = int64ToAuxInt(s)
24395 v.AddArg2(ptr, mem)
24396 return true
24397 }
24398 return false
24399 }
24400 func rewriteValueARM64_OpZeroSIMD(v *Value) bool {
24401
24402
24403
24404 for {
24405 t := v.Type
24406 if !(t.Size() == 16) {
24407 break
24408 }
24409 v.reset(OpARM64VMOVI16B)
24410 v.Type = t
24411 v.AuxInt = uint8ToAuxInt(0)
24412 return true
24413 }
24414 return false
24415 }
24416 func rewriteValueARM64_Opbroadcast1To16Int8x16(v *Value) bool {
24417 v_0 := v.Args[0]
24418
24419
24420 for {
24421 x := v_0
24422 v.reset(OpARM64VDUPBbcast)
24423 v.AuxInt = uint8ToAuxInt(0)
24424 v.AddArg(x)
24425 return true
24426 }
24427 }
24428 func rewriteValueARM64_Opbroadcast1To16Uint8x16(v *Value) bool {
24429 v_0 := v.Args[0]
24430
24431
24432 for {
24433 x := v_0
24434 v.reset(OpARM64VDUPBbcast)
24435 v.AuxInt = uint8ToAuxInt(0)
24436 v.AddArg(x)
24437 return true
24438 }
24439 }
24440 func rewriteValueARM64_Opbroadcast1To2Float64x2(v *Value) bool {
24441 v_0 := v.Args[0]
24442
24443
24444 for {
24445 x := v_0
24446 v.reset(OpARM64VDUPDbcast)
24447 v.AuxInt = uint8ToAuxInt(0)
24448 v.AddArg(x)
24449 return true
24450 }
24451 }
24452 func rewriteValueARM64_Opbroadcast1To2Int64x2(v *Value) bool {
24453 v_0 := v.Args[0]
24454
24455
24456 for {
24457 x := v_0
24458 v.reset(OpARM64VDUPDbcast)
24459 v.AuxInt = uint8ToAuxInt(0)
24460 v.AddArg(x)
24461 return true
24462 }
24463 }
24464 func rewriteValueARM64_Opbroadcast1To2Uint64x2(v *Value) bool {
24465 v_0 := v.Args[0]
24466
24467
24468 for {
24469 x := v_0
24470 v.reset(OpARM64VDUPDbcast)
24471 v.AuxInt = uint8ToAuxInt(0)
24472 v.AddArg(x)
24473 return true
24474 }
24475 }
24476 func rewriteValueARM64_Opbroadcast1To4Float32x4(v *Value) bool {
24477 v_0 := v.Args[0]
24478
24479
24480 for {
24481 x := v_0
24482 v.reset(OpARM64VDUPSbcast)
24483 v.AuxInt = uint8ToAuxInt(0)
24484 v.AddArg(x)
24485 return true
24486 }
24487 }
24488 func rewriteValueARM64_Opbroadcast1To4Int32x4(v *Value) bool {
24489 v_0 := v.Args[0]
24490
24491
24492 for {
24493 x := v_0
24494 v.reset(OpARM64VDUPSbcast)
24495 v.AuxInt = uint8ToAuxInt(0)
24496 v.AddArg(x)
24497 return true
24498 }
24499 }
24500 func rewriteValueARM64_Opbroadcast1To4Uint32x4(v *Value) bool {
24501 v_0 := v.Args[0]
24502
24503
24504 for {
24505 x := v_0
24506 v.reset(OpARM64VDUPSbcast)
24507 v.AuxInt = uint8ToAuxInt(0)
24508 v.AddArg(x)
24509 return true
24510 }
24511 }
24512 func rewriteValueARM64_Opbroadcast1To8Int16x8(v *Value) bool {
24513 v_0 := v.Args[0]
24514
24515
24516 for {
24517 x := v_0
24518 v.reset(OpARM64VDUPHbcast)
24519 v.AuxInt = uint8ToAuxInt(0)
24520 v.AddArg(x)
24521 return true
24522 }
24523 }
24524 func rewriteValueARM64_Opbroadcast1To8Uint16x8(v *Value) bool {
24525 v_0 := v.Args[0]
24526
24527
24528 for {
24529 x := v_0
24530 v.reset(OpARM64VDUPHbcast)
24531 v.AuxInt = uint8ToAuxInt(0)
24532 v.AddArg(x)
24533 return true
24534 }
24535 }
24536 func rewriteBlockARM64(b *Block) bool {
24537 typ := &b.Func.Config.Types
24538 switch b.Kind {
24539 case block.BlockARM64EQ:
24540
24541
24542
24543 for b.Controls[0].Op == OpARM64CMPconst {
24544 v_0 := b.Controls[0]
24545 if auxIntToInt64(v_0.AuxInt) != 0 {
24546 break
24547 }
24548 z := v_0.Args[0]
24549 if z.Op != OpARM64AND {
24550 break
24551 }
24552 _ = z.Args[1]
24553 z_0 := z.Args[0]
24554 z_1 := z.Args[1]
24555 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
24556 x := z_0
24557 y := z_1
24558 if !(z.Uses == 1) {
24559 continue
24560 }
24561 v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
24562 v0.AddArg2(x, y)
24563 b.resetWithControl(block.BlockARM64EQ, v0)
24564 return true
24565 }
24566 break
24567 }
24568
24569
24570
24571 for b.Controls[0].Op == OpARM64CMPconst {
24572 v_0 := b.Controls[0]
24573 if auxIntToInt64(v_0.AuxInt) != 0 {
24574 break
24575 }
24576 x := v_0.Args[0]
24577 if x.Op != OpARM64ANDconst {
24578 break
24579 }
24580 c := auxIntToInt64(x.AuxInt)
24581 y := x.Args[0]
24582 if !(x.Uses == 1) {
24583 break
24584 }
24585 v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
24586 v0.AuxInt = int64ToAuxInt(c)
24587 v0.AddArg(y)
24588 b.resetWithControl(block.BlockARM64EQ, v0)
24589 return true
24590 }
24591
24592
24593
24594 for b.Controls[0].Op == OpARM64CMPWconst {
24595 v_0 := b.Controls[0]
24596 if auxIntToInt32(v_0.AuxInt) != 0 {
24597 break
24598 }
24599 z := v_0.Args[0]
24600 if z.Op != OpARM64AND {
24601 break
24602 }
24603 _ = z.Args[1]
24604 z_0 := z.Args[0]
24605 z_1 := z.Args[1]
24606 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
24607 x := z_0
24608 y := z_1
24609 if !(z.Uses == 1) {
24610 continue
24611 }
24612 v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
24613 v0.AddArg2(x, y)
24614 b.resetWithControl(block.BlockARM64EQ, v0)
24615 return true
24616 }
24617 break
24618 }
24619
24620
24621
24622 for b.Controls[0].Op == OpARM64CMPWconst {
24623 v_0 := b.Controls[0]
24624 if auxIntToInt32(v_0.AuxInt) != 0 {
24625 break
24626 }
24627 x := v_0.Args[0]
24628 if x.Op != OpARM64ANDconst {
24629 break
24630 }
24631 c := auxIntToInt64(x.AuxInt)
24632 y := x.Args[0]
24633 if !(x.Uses == 1) {
24634 break
24635 }
24636 v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
24637 v0.AuxInt = int32ToAuxInt(int32(c))
24638 v0.AddArg(y)
24639 b.resetWithControl(block.BlockARM64EQ, v0)
24640 return true
24641 }
24642
24643
24644
24645 for b.Controls[0].Op == OpARM64CMPconst {
24646 v_0 := b.Controls[0]
24647 if auxIntToInt64(v_0.AuxInt) != 0 {
24648 break
24649 }
24650 x := v_0.Args[0]
24651 if x.Op != OpARM64ADDconst {
24652 break
24653 }
24654 c := auxIntToInt64(x.AuxInt)
24655 y := x.Args[0]
24656 if !(x.Uses == 1) {
24657 break
24658 }
24659 v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
24660 v0.AuxInt = int64ToAuxInt(c)
24661 v0.AddArg(y)
24662 b.resetWithControl(block.BlockARM64EQ, v0)
24663 return true
24664 }
24665
24666
24667
24668 for b.Controls[0].Op == OpARM64CMPWconst {
24669 v_0 := b.Controls[0]
24670 if auxIntToInt32(v_0.AuxInt) != 0 {
24671 break
24672 }
24673 x := v_0.Args[0]
24674 if x.Op != OpARM64ADDconst {
24675 break
24676 }
24677 c := auxIntToInt64(x.AuxInt)
24678 y := x.Args[0]
24679 if !(x.Uses == 1) {
24680 break
24681 }
24682 v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
24683 v0.AuxInt = int32ToAuxInt(int32(c))
24684 v0.AddArg(y)
24685 b.resetWithControl(block.BlockARM64EQ, v0)
24686 return true
24687 }
24688
24689
24690
24691 for b.Controls[0].Op == OpARM64CMPconst {
24692 v_0 := b.Controls[0]
24693 if auxIntToInt64(v_0.AuxInt) != 0 {
24694 break
24695 }
24696 z := v_0.Args[0]
24697 if z.Op != OpARM64ADD {
24698 break
24699 }
24700 _ = z.Args[1]
24701 z_0 := z.Args[0]
24702 z_1 := z.Args[1]
24703 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
24704 x := z_0
24705 y := z_1
24706 if !(z.Uses == 1) {
24707 continue
24708 }
24709 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
24710 v0.AddArg2(x, y)
24711 b.resetWithControl(block.BlockARM64EQ, v0)
24712 return true
24713 }
24714 break
24715 }
24716
24717
24718
24719 for b.Controls[0].Op == OpARM64CMPWconst {
24720 v_0 := b.Controls[0]
24721 if auxIntToInt32(v_0.AuxInt) != 0 {
24722 break
24723 }
24724 z := v_0.Args[0]
24725 if z.Op != OpARM64ADD {
24726 break
24727 }
24728 _ = z.Args[1]
24729 z_0 := z.Args[0]
24730 z_1 := z.Args[1]
24731 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
24732 x := z_0
24733 y := z_1
24734 if !(z.Uses == 1) {
24735 continue
24736 }
24737 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
24738 v0.AddArg2(x, y)
24739 b.resetWithControl(block.BlockARM64EQ, v0)
24740 return true
24741 }
24742 break
24743 }
24744
24745
24746
24747 for b.Controls[0].Op == OpARM64CMP {
24748 v_0 := b.Controls[0]
24749 _ = v_0.Args[1]
24750 x := v_0.Args[0]
24751 z := v_0.Args[1]
24752 if z.Op != OpARM64NEG {
24753 break
24754 }
24755 y := z.Args[0]
24756 if !(z.Uses == 1) {
24757 break
24758 }
24759 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
24760 v0.AddArg2(x, y)
24761 b.resetWithControl(block.BlockARM64EQ, v0)
24762 return true
24763 }
24764
24765
24766
24767 for b.Controls[0].Op == OpARM64CMPW {
24768 v_0 := b.Controls[0]
24769 _ = v_0.Args[1]
24770 x := v_0.Args[0]
24771 z := v_0.Args[1]
24772 if z.Op != OpARM64NEG {
24773 break
24774 }
24775 y := z.Args[0]
24776 if !(z.Uses == 1) {
24777 break
24778 }
24779 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
24780 v0.AddArg2(x, y)
24781 b.resetWithControl(block.BlockARM64EQ, v0)
24782 return true
24783 }
24784
24785
24786 for b.Controls[0].Op == OpARM64CMPconst {
24787 v_0 := b.Controls[0]
24788 if auxIntToInt64(v_0.AuxInt) != 0 {
24789 break
24790 }
24791 x := v_0.Args[0]
24792 b.resetWithControl(block.BlockARM64Z, x)
24793 return true
24794 }
24795
24796
24797 for b.Controls[0].Op == OpARM64CMPWconst {
24798 v_0 := b.Controls[0]
24799 if auxIntToInt32(v_0.AuxInt) != 0 {
24800 break
24801 }
24802 x := v_0.Args[0]
24803 b.resetWithControl(block.BlockARM64ZW, x)
24804 return true
24805 }
24806
24807
24808
24809 for b.Controls[0].Op == OpARM64CMPconst {
24810 v_0 := b.Controls[0]
24811 if auxIntToInt64(v_0.AuxInt) != 0 {
24812 break
24813 }
24814 z := v_0.Args[0]
24815 if z.Op != OpARM64MADD {
24816 break
24817 }
24818 y := z.Args[2]
24819 a := z.Args[0]
24820 x := z.Args[1]
24821 if !(z.Uses == 1) {
24822 break
24823 }
24824 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
24825 v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
24826 v1.AddArg2(x, y)
24827 v0.AddArg2(a, v1)
24828 b.resetWithControl(block.BlockARM64EQ, v0)
24829 return true
24830 }
24831
24832
24833
24834 for b.Controls[0].Op == OpARM64CMPWconst {
24835 v_0 := b.Controls[0]
24836 if auxIntToInt32(v_0.AuxInt) != 0 {
24837 break
24838 }
24839 z := v_0.Args[0]
24840 if z.Op != OpARM64MADDW {
24841 break
24842 }
24843 y := z.Args[2]
24844 a := z.Args[0]
24845 x := z.Args[1]
24846 if !(z.Uses == 1) {
24847 break
24848 }
24849 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
24850 v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
24851 v1.AddArg2(x, y)
24852 v0.AddArg2(a, v1)
24853 b.resetWithControl(block.BlockARM64EQ, v0)
24854 return true
24855 }
24856
24857
24858
24859 for b.Controls[0].Op == OpARM64CMPconst {
24860 v_0 := b.Controls[0]
24861 if auxIntToInt64(v_0.AuxInt) != 0 {
24862 break
24863 }
24864 z := v_0.Args[0]
24865 if z.Op != OpARM64MSUB {
24866 break
24867 }
24868 y := z.Args[2]
24869 a := z.Args[0]
24870 x := z.Args[1]
24871 if !(z.Uses == 1) {
24872 break
24873 }
24874 v0 := b.NewValue0(v_0.Pos, OpARM64CMP, types.TypeFlags)
24875 v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
24876 v1.AddArg2(x, y)
24877 v0.AddArg2(a, v1)
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 z := v_0.Args[0]
24890 if z.Op != OpARM64MSUBW {
24891 break
24892 }
24893 y := z.Args[2]
24894 a := z.Args[0]
24895 x := z.Args[1]
24896 if !(z.Uses == 1) {
24897 break
24898 }
24899 v0 := b.NewValue0(v_0.Pos, OpARM64CMPW, types.TypeFlags)
24900 v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
24901 v1.AddArg2(x, y)
24902 v0.AddArg2(a, v1)
24903 b.resetWithControl(block.BlockARM64EQ, v0)
24904 return true
24905 }
24906
24907
24908
24909 for b.Controls[0].Op == OpARM64TSTconst {
24910 v_0 := b.Controls[0]
24911 c := auxIntToInt64(v_0.AuxInt)
24912 x := v_0.Args[0]
24913 if !(oneBit(c)) {
24914 break
24915 }
24916 b.resetWithControl(block.BlockARM64TBZ, x)
24917 b.AuxInt = int64ToAuxInt(int64(ntz64(c)))
24918 return true
24919 }
24920
24921
24922
24923 for b.Controls[0].Op == OpARM64TSTWconst {
24924 v_0 := b.Controls[0]
24925 c := auxIntToInt32(v_0.AuxInt)
24926 x := v_0.Args[0]
24927 if !(oneBit(int64(uint32(c)))) {
24928 break
24929 }
24930 b.resetWithControl(block.BlockARM64TBZ, x)
24931 b.AuxInt = int64ToAuxInt(int64(ntz64(int64(uint32(c)))))
24932 return true
24933 }
24934
24935
24936
24937 for b.Controls[0].Op == OpARM64FlagConstant {
24938 v_0 := b.Controls[0]
24939 fc := auxIntToFlagConstant(v_0.AuxInt)
24940 if !(fc.eq()) {
24941 break
24942 }
24943 b.Reset(block.BlockFirst)
24944 return true
24945 }
24946
24947
24948
24949 for b.Controls[0].Op == OpARM64FlagConstant {
24950 v_0 := b.Controls[0]
24951 fc := auxIntToFlagConstant(v_0.AuxInt)
24952 if !(!fc.eq()) {
24953 break
24954 }
24955 b.Reset(block.BlockFirst)
24956 b.swapSuccessors()
24957 return true
24958 }
24959
24960
24961 for b.Controls[0].Op == OpARM64InvertFlags {
24962 v_0 := b.Controls[0]
24963 cmp := v_0.Args[0]
24964 b.resetWithControl(block.BlockARM64EQ, cmp)
24965 return true
24966 }
24967 case block.BlockARM64FGE:
24968
24969
24970 for b.Controls[0].Op == OpARM64InvertFlags {
24971 v_0 := b.Controls[0]
24972 cmp := v_0.Args[0]
24973 b.resetWithControl(block.BlockARM64FLE, cmp)
24974 return true
24975 }
24976 case block.BlockARM64FGT:
24977
24978
24979 for b.Controls[0].Op == OpARM64InvertFlags {
24980 v_0 := b.Controls[0]
24981 cmp := v_0.Args[0]
24982 b.resetWithControl(block.BlockARM64FLT, cmp)
24983 return true
24984 }
24985 case block.BlockARM64FLE:
24986
24987
24988 for b.Controls[0].Op == OpARM64InvertFlags {
24989 v_0 := b.Controls[0]
24990 cmp := v_0.Args[0]
24991 b.resetWithControl(block.BlockARM64FGE, cmp)
24992 return true
24993 }
24994 case block.BlockARM64FLT:
24995
24996
24997 for b.Controls[0].Op == OpARM64InvertFlags {
24998 v_0 := b.Controls[0]
24999 cmp := v_0.Args[0]
25000 b.resetWithControl(block.BlockARM64FGT, cmp)
25001 return true
25002 }
25003 case block.BlockARM64GE:
25004
25005
25006
25007 for b.Controls[0].Op == OpARM64CMPconst {
25008 v_0 := b.Controls[0]
25009 if auxIntToInt64(v_0.AuxInt) != 0 {
25010 break
25011 }
25012 z := v_0.Args[0]
25013 if z.Op != OpARM64AND {
25014 break
25015 }
25016 _ = z.Args[1]
25017 z_0 := z.Args[0]
25018 z_1 := z.Args[1]
25019 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25020 x := z_0
25021 y := z_1
25022 if !(z.Uses == 1) {
25023 continue
25024 }
25025 v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
25026 v0.AddArg2(x, y)
25027 b.resetWithControl(block.BlockARM64GE, v0)
25028 return true
25029 }
25030 break
25031 }
25032
25033
25034
25035 for b.Controls[0].Op == OpARM64CMPconst {
25036 v_0 := b.Controls[0]
25037 if auxIntToInt64(v_0.AuxInt) != 0 {
25038 break
25039 }
25040 x := v_0.Args[0]
25041 if x.Op != OpARM64ANDconst {
25042 break
25043 }
25044 c := auxIntToInt64(x.AuxInt)
25045 y := x.Args[0]
25046 if !(x.Uses == 1) {
25047 break
25048 }
25049 v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
25050 v0.AuxInt = int64ToAuxInt(c)
25051 v0.AddArg(y)
25052 b.resetWithControl(block.BlockARM64GE, v0)
25053 return true
25054 }
25055
25056
25057
25058 for b.Controls[0].Op == OpARM64CMPWconst {
25059 v_0 := b.Controls[0]
25060 if auxIntToInt32(v_0.AuxInt) != 0 {
25061 break
25062 }
25063 z := v_0.Args[0]
25064 if z.Op != OpARM64AND {
25065 break
25066 }
25067 _ = z.Args[1]
25068 z_0 := z.Args[0]
25069 z_1 := z.Args[1]
25070 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25071 x := z_0
25072 y := z_1
25073 if !(z.Uses == 1) {
25074 continue
25075 }
25076 v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
25077 v0.AddArg2(x, y)
25078 b.resetWithControl(block.BlockARM64GE, v0)
25079 return true
25080 }
25081 break
25082 }
25083
25084
25085
25086 for b.Controls[0].Op == OpARM64CMPWconst {
25087 v_0 := b.Controls[0]
25088 if auxIntToInt32(v_0.AuxInt) != 0 {
25089 break
25090 }
25091 x := v_0.Args[0]
25092 if x.Op != OpARM64ANDconst {
25093 break
25094 }
25095 c := auxIntToInt64(x.AuxInt)
25096 y := x.Args[0]
25097 if !(x.Uses == 1) {
25098 break
25099 }
25100 v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
25101 v0.AuxInt = int32ToAuxInt(int32(c))
25102 v0.AddArg(y)
25103 b.resetWithControl(block.BlockARM64GE, v0)
25104 return true
25105 }
25106
25107
25108
25109 for b.Controls[0].Op == OpARM64CMPconst {
25110 v_0 := b.Controls[0]
25111 if auxIntToInt64(v_0.AuxInt) != 0 {
25112 break
25113 }
25114 x := v_0.Args[0]
25115 if x.Op != OpARM64ADDconst {
25116 break
25117 }
25118 c := auxIntToInt64(x.AuxInt)
25119 y := x.Args[0]
25120 if !(x.Uses == 1) {
25121 break
25122 }
25123 v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
25124 v0.AuxInt = int64ToAuxInt(c)
25125 v0.AddArg(y)
25126 b.resetWithControl(block.BlockARM64GEnoov, v0)
25127 return true
25128 }
25129
25130
25131
25132 for b.Controls[0].Op == OpARM64CMPWconst {
25133 v_0 := b.Controls[0]
25134 if auxIntToInt32(v_0.AuxInt) != 0 {
25135 break
25136 }
25137 x := v_0.Args[0]
25138 if x.Op != OpARM64ADDconst {
25139 break
25140 }
25141 c := auxIntToInt64(x.AuxInt)
25142 y := x.Args[0]
25143 if !(x.Uses == 1) {
25144 break
25145 }
25146 v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
25147 v0.AuxInt = int32ToAuxInt(int32(c))
25148 v0.AddArg(y)
25149 b.resetWithControl(block.BlockARM64GEnoov, v0)
25150 return true
25151 }
25152
25153
25154
25155 for b.Controls[0].Op == OpARM64CMPconst {
25156 v_0 := b.Controls[0]
25157 if auxIntToInt64(v_0.AuxInt) != 0 {
25158 break
25159 }
25160 z := v_0.Args[0]
25161 if z.Op != OpARM64ADD {
25162 break
25163 }
25164 _ = z.Args[1]
25165 z_0 := z.Args[0]
25166 z_1 := z.Args[1]
25167 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25168 x := z_0
25169 y := z_1
25170 if !(z.Uses == 1) {
25171 continue
25172 }
25173 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
25174 v0.AddArg2(x, y)
25175 b.resetWithControl(block.BlockARM64GEnoov, v0)
25176 return true
25177 }
25178 break
25179 }
25180
25181
25182
25183 for b.Controls[0].Op == OpARM64CMPWconst {
25184 v_0 := b.Controls[0]
25185 if auxIntToInt32(v_0.AuxInt) != 0 {
25186 break
25187 }
25188 z := v_0.Args[0]
25189 if z.Op != OpARM64ADD {
25190 break
25191 }
25192 _ = z.Args[1]
25193 z_0 := z.Args[0]
25194 z_1 := z.Args[1]
25195 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25196 x := z_0
25197 y := z_1
25198 if !(z.Uses == 1) {
25199 continue
25200 }
25201 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
25202 v0.AddArg2(x, y)
25203 b.resetWithControl(block.BlockARM64GEnoov, v0)
25204 return true
25205 }
25206 break
25207 }
25208
25209
25210
25211 for b.Controls[0].Op == OpARM64CMPconst {
25212 v_0 := b.Controls[0]
25213 if auxIntToInt64(v_0.AuxInt) != 0 {
25214 break
25215 }
25216 z := v_0.Args[0]
25217 if z.Op != OpARM64MADD {
25218 break
25219 }
25220 y := z.Args[2]
25221 a := z.Args[0]
25222 x := z.Args[1]
25223 if !(z.Uses == 1) {
25224 break
25225 }
25226 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
25227 v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
25228 v1.AddArg2(x, y)
25229 v0.AddArg2(a, v1)
25230 b.resetWithControl(block.BlockARM64GEnoov, v0)
25231 return true
25232 }
25233
25234
25235
25236 for b.Controls[0].Op == OpARM64CMPWconst {
25237 v_0 := b.Controls[0]
25238 if auxIntToInt32(v_0.AuxInt) != 0 {
25239 break
25240 }
25241 z := v_0.Args[0]
25242 if z.Op != OpARM64MADDW {
25243 break
25244 }
25245 y := z.Args[2]
25246 a := z.Args[0]
25247 x := z.Args[1]
25248 if !(z.Uses == 1) {
25249 break
25250 }
25251 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
25252 v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
25253 v1.AddArg2(x, y)
25254 v0.AddArg2(a, v1)
25255 b.resetWithControl(block.BlockARM64GEnoov, v0)
25256 return true
25257 }
25258
25259
25260 for b.Controls[0].Op == OpARM64CMPWconst {
25261 v_0 := b.Controls[0]
25262 if auxIntToInt32(v_0.AuxInt) != 0 {
25263 break
25264 }
25265 x := v_0.Args[0]
25266 b.resetWithControl(block.BlockARM64TBZ, x)
25267 b.AuxInt = int64ToAuxInt(31)
25268 return true
25269 }
25270
25271
25272 for b.Controls[0].Op == OpARM64CMPconst {
25273 v_0 := b.Controls[0]
25274 if auxIntToInt64(v_0.AuxInt) != 0 {
25275 break
25276 }
25277 x := v_0.Args[0]
25278 b.resetWithControl(block.BlockARM64TBZ, x)
25279 b.AuxInt = int64ToAuxInt(63)
25280 return true
25281 }
25282
25283
25284
25285 for b.Controls[0].Op == OpARM64CMPWconst {
25286 v_0 := b.Controls[0]
25287 if auxIntToInt32(v_0.AuxInt) != 128 {
25288 break
25289 }
25290 x := v_0.Args[0]
25291 if !(ZeroUpper56Bits(x)) {
25292 break
25293 }
25294 b.resetWithControl(block.BlockARM64TBNZ, x)
25295 b.AuxInt = int64ToAuxInt(7)
25296 return true
25297 }
25298
25299
25300
25301 for b.Controls[0].Op == OpARM64CMPconst {
25302 v_0 := b.Controls[0]
25303 if auxIntToInt64(v_0.AuxInt) != 128 {
25304 break
25305 }
25306 x := v_0.Args[0]
25307 if !(ZeroUpper56Bits(x)) {
25308 break
25309 }
25310 b.resetWithControl(block.BlockARM64TBNZ, x)
25311 b.AuxInt = int64ToAuxInt(7)
25312 return true
25313 }
25314
25315
25316
25317 for b.Controls[0].Op == OpARM64FlagConstant {
25318 v_0 := b.Controls[0]
25319 fc := auxIntToFlagConstant(v_0.AuxInt)
25320 if !(fc.ge()) {
25321 break
25322 }
25323 b.Reset(block.BlockFirst)
25324 return true
25325 }
25326
25327
25328
25329 for b.Controls[0].Op == OpARM64FlagConstant {
25330 v_0 := b.Controls[0]
25331 fc := auxIntToFlagConstant(v_0.AuxInt)
25332 if !(!fc.ge()) {
25333 break
25334 }
25335 b.Reset(block.BlockFirst)
25336 b.swapSuccessors()
25337 return true
25338 }
25339
25340
25341 for b.Controls[0].Op == OpARM64InvertFlags {
25342 v_0 := b.Controls[0]
25343 cmp := v_0.Args[0]
25344 b.resetWithControl(block.BlockARM64LE, cmp)
25345 return true
25346 }
25347 case block.BlockARM64GEnoov:
25348
25349
25350
25351 for b.Controls[0].Op == OpARM64FlagConstant {
25352 v_0 := b.Controls[0]
25353 fc := auxIntToFlagConstant(v_0.AuxInt)
25354 if !(fc.geNoov()) {
25355 break
25356 }
25357 b.Reset(block.BlockFirst)
25358 return true
25359 }
25360
25361
25362
25363 for b.Controls[0].Op == OpARM64FlagConstant {
25364 v_0 := b.Controls[0]
25365 fc := auxIntToFlagConstant(v_0.AuxInt)
25366 if !(!fc.geNoov()) {
25367 break
25368 }
25369 b.Reset(block.BlockFirst)
25370 b.swapSuccessors()
25371 return true
25372 }
25373 case block.BlockARM64GT:
25374
25375
25376
25377 for b.Controls[0].Op == OpARM64CMPconst {
25378 v_0 := b.Controls[0]
25379 if auxIntToInt64(v_0.AuxInt) != 0 {
25380 break
25381 }
25382 z := v_0.Args[0]
25383 if z.Op != OpARM64AND {
25384 break
25385 }
25386 _ = z.Args[1]
25387 z_0 := z.Args[0]
25388 z_1 := z.Args[1]
25389 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25390 x := z_0
25391 y := z_1
25392 if !(z.Uses == 1) {
25393 continue
25394 }
25395 v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
25396 v0.AddArg2(x, y)
25397 b.resetWithControl(block.BlockARM64GT, v0)
25398 return true
25399 }
25400 break
25401 }
25402
25403
25404
25405 for b.Controls[0].Op == OpARM64CMPconst {
25406 v_0 := b.Controls[0]
25407 if auxIntToInt64(v_0.AuxInt) != 0 {
25408 break
25409 }
25410 x := v_0.Args[0]
25411 if x.Op != OpARM64ANDconst {
25412 break
25413 }
25414 c := auxIntToInt64(x.AuxInt)
25415 y := x.Args[0]
25416 if !(x.Uses == 1) {
25417 break
25418 }
25419 v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
25420 v0.AuxInt = int64ToAuxInt(c)
25421 v0.AddArg(y)
25422 b.resetWithControl(block.BlockARM64GT, v0)
25423 return true
25424 }
25425
25426
25427
25428 for b.Controls[0].Op == OpARM64CMPWconst {
25429 v_0 := b.Controls[0]
25430 if auxIntToInt32(v_0.AuxInt) != 0 {
25431 break
25432 }
25433 z := v_0.Args[0]
25434 if z.Op != OpARM64AND {
25435 break
25436 }
25437 _ = z.Args[1]
25438 z_0 := z.Args[0]
25439 z_1 := z.Args[1]
25440 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25441 x := z_0
25442 y := z_1
25443 if !(z.Uses == 1) {
25444 continue
25445 }
25446 v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
25447 v0.AddArg2(x, y)
25448 b.resetWithControl(block.BlockARM64GT, v0)
25449 return true
25450 }
25451 break
25452 }
25453
25454
25455
25456 for b.Controls[0].Op == OpARM64CMPWconst {
25457 v_0 := b.Controls[0]
25458 if auxIntToInt32(v_0.AuxInt) != 0 {
25459 break
25460 }
25461 x := v_0.Args[0]
25462 if x.Op != OpARM64ANDconst {
25463 break
25464 }
25465 c := auxIntToInt64(x.AuxInt)
25466 y := x.Args[0]
25467 if !(x.Uses == 1) {
25468 break
25469 }
25470 v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
25471 v0.AuxInt = int32ToAuxInt(int32(c))
25472 v0.AddArg(y)
25473 b.resetWithControl(block.BlockARM64GT, v0)
25474 return true
25475 }
25476
25477
25478
25479 for b.Controls[0].Op == OpARM64CMPconst {
25480 v_0 := b.Controls[0]
25481 if auxIntToInt64(v_0.AuxInt) != 0 {
25482 break
25483 }
25484 x := v_0.Args[0]
25485 if x.Op != OpARM64ADDconst {
25486 break
25487 }
25488 c := auxIntToInt64(x.AuxInt)
25489 y := x.Args[0]
25490 if !(x.Uses == 1) {
25491 break
25492 }
25493 v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
25494 v0.AuxInt = int64ToAuxInt(c)
25495 v0.AddArg(y)
25496 b.resetWithControl(block.BlockARM64GTnoov, v0)
25497 return true
25498 }
25499
25500
25501
25502 for b.Controls[0].Op == OpARM64CMPWconst {
25503 v_0 := b.Controls[0]
25504 if auxIntToInt32(v_0.AuxInt) != 0 {
25505 break
25506 }
25507 x := v_0.Args[0]
25508 if x.Op != OpARM64ADDconst {
25509 break
25510 }
25511 c := auxIntToInt64(x.AuxInt)
25512 y := x.Args[0]
25513 if !(x.Uses == 1) {
25514 break
25515 }
25516 v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
25517 v0.AuxInt = int32ToAuxInt(int32(c))
25518 v0.AddArg(y)
25519 b.resetWithControl(block.BlockARM64GTnoov, v0)
25520 return true
25521 }
25522
25523
25524
25525 for b.Controls[0].Op == OpARM64CMPconst {
25526 v_0 := b.Controls[0]
25527 if auxIntToInt64(v_0.AuxInt) != 0 {
25528 break
25529 }
25530 z := v_0.Args[0]
25531 if z.Op != OpARM64ADD {
25532 break
25533 }
25534 _ = z.Args[1]
25535 z_0 := z.Args[0]
25536 z_1 := z.Args[1]
25537 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25538 x := z_0
25539 y := z_1
25540 if !(z.Uses == 1) {
25541 continue
25542 }
25543 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
25544 v0.AddArg2(x, y)
25545 b.resetWithControl(block.BlockARM64GTnoov, v0)
25546 return true
25547 }
25548 break
25549 }
25550
25551
25552
25553 for b.Controls[0].Op == OpARM64CMPWconst {
25554 v_0 := b.Controls[0]
25555 if auxIntToInt32(v_0.AuxInt) != 0 {
25556 break
25557 }
25558 z := v_0.Args[0]
25559 if z.Op != OpARM64ADD {
25560 break
25561 }
25562 _ = z.Args[1]
25563 z_0 := z.Args[0]
25564 z_1 := z.Args[1]
25565 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25566 x := z_0
25567 y := z_1
25568 if !(z.Uses == 1) {
25569 continue
25570 }
25571 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
25572 v0.AddArg2(x, y)
25573 b.resetWithControl(block.BlockARM64GTnoov, v0)
25574 return true
25575 }
25576 break
25577 }
25578
25579
25580
25581 for b.Controls[0].Op == OpARM64CMPconst {
25582 v_0 := b.Controls[0]
25583 if auxIntToInt64(v_0.AuxInt) != 0 {
25584 break
25585 }
25586 z := v_0.Args[0]
25587 if z.Op != OpARM64MADD {
25588 break
25589 }
25590 y := z.Args[2]
25591 a := z.Args[0]
25592 x := z.Args[1]
25593 if !(z.Uses == 1) {
25594 break
25595 }
25596 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
25597 v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
25598 v1.AddArg2(x, y)
25599 v0.AddArg2(a, v1)
25600 b.resetWithControl(block.BlockARM64GTnoov, v0)
25601 return true
25602 }
25603
25604
25605
25606 for b.Controls[0].Op == OpARM64CMPWconst {
25607 v_0 := b.Controls[0]
25608 if auxIntToInt32(v_0.AuxInt) != 0 {
25609 break
25610 }
25611 z := v_0.Args[0]
25612 if z.Op != OpARM64MADDW {
25613 break
25614 }
25615 y := z.Args[2]
25616 a := z.Args[0]
25617 x := z.Args[1]
25618 if !(z.Uses == 1) {
25619 break
25620 }
25621 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
25622 v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
25623 v1.AddArg2(x, y)
25624 v0.AddArg2(a, v1)
25625 b.resetWithControl(block.BlockARM64GTnoov, v0)
25626 return true
25627 }
25628
25629
25630
25631 for b.Controls[0].Op == OpARM64FlagConstant {
25632 v_0 := b.Controls[0]
25633 fc := auxIntToFlagConstant(v_0.AuxInt)
25634 if !(fc.gt()) {
25635 break
25636 }
25637 b.Reset(block.BlockFirst)
25638 return true
25639 }
25640
25641
25642
25643 for b.Controls[0].Op == OpARM64FlagConstant {
25644 v_0 := b.Controls[0]
25645 fc := auxIntToFlagConstant(v_0.AuxInt)
25646 if !(!fc.gt()) {
25647 break
25648 }
25649 b.Reset(block.BlockFirst)
25650 b.swapSuccessors()
25651 return true
25652 }
25653
25654
25655 for b.Controls[0].Op == OpARM64InvertFlags {
25656 v_0 := b.Controls[0]
25657 cmp := v_0.Args[0]
25658 b.resetWithControl(block.BlockARM64LT, cmp)
25659 return true
25660 }
25661 case block.BlockARM64GTnoov:
25662
25663
25664
25665 for b.Controls[0].Op == OpARM64FlagConstant {
25666 v_0 := b.Controls[0]
25667 fc := auxIntToFlagConstant(v_0.AuxInt)
25668 if !(fc.gtNoov()) {
25669 break
25670 }
25671 b.Reset(block.BlockFirst)
25672 return true
25673 }
25674
25675
25676
25677 for b.Controls[0].Op == OpARM64FlagConstant {
25678 v_0 := b.Controls[0]
25679 fc := auxIntToFlagConstant(v_0.AuxInt)
25680 if !(!fc.gtNoov()) {
25681 break
25682 }
25683 b.Reset(block.BlockFirst)
25684 b.swapSuccessors()
25685 return true
25686 }
25687 case block.BlockIf:
25688
25689
25690 for b.Controls[0].Op == OpARM64Equal {
25691 v_0 := b.Controls[0]
25692 cc := v_0.Args[0]
25693 b.resetWithControl(block.BlockARM64EQ, cc)
25694 return true
25695 }
25696
25697
25698 for b.Controls[0].Op == OpARM64NotEqual {
25699 v_0 := b.Controls[0]
25700 cc := v_0.Args[0]
25701 b.resetWithControl(block.BlockARM64NE, cc)
25702 return true
25703 }
25704
25705
25706 for b.Controls[0].Op == OpARM64LessThan {
25707 v_0 := b.Controls[0]
25708 cc := v_0.Args[0]
25709 b.resetWithControl(block.BlockARM64LT, cc)
25710 return true
25711 }
25712
25713
25714 for b.Controls[0].Op == OpARM64LessThanU {
25715 v_0 := b.Controls[0]
25716 cc := v_0.Args[0]
25717 b.resetWithControl(block.BlockARM64ULT, cc)
25718 return true
25719 }
25720
25721
25722 for b.Controls[0].Op == OpARM64LessEqual {
25723 v_0 := b.Controls[0]
25724 cc := v_0.Args[0]
25725 b.resetWithControl(block.BlockARM64LE, cc)
25726 return true
25727 }
25728
25729
25730 for b.Controls[0].Op == OpARM64LessEqualU {
25731 v_0 := b.Controls[0]
25732 cc := v_0.Args[0]
25733 b.resetWithControl(block.BlockARM64ULE, cc)
25734 return true
25735 }
25736
25737
25738 for b.Controls[0].Op == OpARM64GreaterThan {
25739 v_0 := b.Controls[0]
25740 cc := v_0.Args[0]
25741 b.resetWithControl(block.BlockARM64GT, cc)
25742 return true
25743 }
25744
25745
25746 for b.Controls[0].Op == OpARM64GreaterThanU {
25747 v_0 := b.Controls[0]
25748 cc := v_0.Args[0]
25749 b.resetWithControl(block.BlockARM64UGT, cc)
25750 return true
25751 }
25752
25753
25754 for b.Controls[0].Op == OpARM64GreaterEqual {
25755 v_0 := b.Controls[0]
25756 cc := v_0.Args[0]
25757 b.resetWithControl(block.BlockARM64GE, cc)
25758 return true
25759 }
25760
25761
25762 for b.Controls[0].Op == OpARM64GreaterEqualU {
25763 v_0 := b.Controls[0]
25764 cc := v_0.Args[0]
25765 b.resetWithControl(block.BlockARM64UGE, cc)
25766 return true
25767 }
25768
25769
25770 for b.Controls[0].Op == OpARM64LessThanF {
25771 v_0 := b.Controls[0]
25772 cc := v_0.Args[0]
25773 b.resetWithControl(block.BlockARM64FLT, cc)
25774 return true
25775 }
25776
25777
25778 for b.Controls[0].Op == OpARM64LessEqualF {
25779 v_0 := b.Controls[0]
25780 cc := v_0.Args[0]
25781 b.resetWithControl(block.BlockARM64FLE, cc)
25782 return true
25783 }
25784
25785
25786 for b.Controls[0].Op == OpARM64GreaterThanF {
25787 v_0 := b.Controls[0]
25788 cc := v_0.Args[0]
25789 b.resetWithControl(block.BlockARM64FGT, cc)
25790 return true
25791 }
25792
25793
25794 for b.Controls[0].Op == OpARM64GreaterEqualF {
25795 v_0 := b.Controls[0]
25796 cc := v_0.Args[0]
25797 b.resetWithControl(block.BlockARM64FGE, cc)
25798 return true
25799 }
25800
25801
25802 for {
25803 cond := b.Controls[0]
25804 b.resetWithControl(block.BlockARM64TBNZ, cond)
25805 b.AuxInt = int64ToAuxInt(0)
25806 return true
25807 }
25808 case block.BlockJumpTable:
25809
25810
25811 for {
25812 idx := b.Controls[0]
25813 v0 := b.NewValue0(b.Pos, OpARM64MOVDaddr, typ.Uintptr)
25814 v0.Aux = symToAux(makeJumpTableSym(b))
25815 v1 := b.NewValue0(b.Pos, OpSB, typ.Uintptr)
25816 v0.AddArg(v1)
25817 b.resetWithControl2(block.BlockARM64JUMPTABLE, idx, v0)
25818 b.Aux = symToAux(makeJumpTableSym(b))
25819 return true
25820 }
25821 case block.BlockARM64LE:
25822
25823
25824
25825 for b.Controls[0].Op == OpARM64CMPconst {
25826 v_0 := b.Controls[0]
25827 if auxIntToInt64(v_0.AuxInt) != 0 {
25828 break
25829 }
25830 z := v_0.Args[0]
25831 if z.Op != OpARM64AND {
25832 break
25833 }
25834 _ = z.Args[1]
25835 z_0 := z.Args[0]
25836 z_1 := z.Args[1]
25837 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25838 x := z_0
25839 y := z_1
25840 if !(z.Uses == 1) {
25841 continue
25842 }
25843 v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
25844 v0.AddArg2(x, y)
25845 b.resetWithControl(block.BlockARM64LE, v0)
25846 return true
25847 }
25848 break
25849 }
25850
25851
25852
25853 for b.Controls[0].Op == OpARM64CMPconst {
25854 v_0 := b.Controls[0]
25855 if auxIntToInt64(v_0.AuxInt) != 0 {
25856 break
25857 }
25858 x := v_0.Args[0]
25859 if x.Op != OpARM64ANDconst {
25860 break
25861 }
25862 c := auxIntToInt64(x.AuxInt)
25863 y := x.Args[0]
25864 if !(x.Uses == 1) {
25865 break
25866 }
25867 v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
25868 v0.AuxInt = int64ToAuxInt(c)
25869 v0.AddArg(y)
25870 b.resetWithControl(block.BlockARM64LE, v0)
25871 return true
25872 }
25873
25874
25875
25876 for b.Controls[0].Op == OpARM64CMPWconst {
25877 v_0 := b.Controls[0]
25878 if auxIntToInt32(v_0.AuxInt) != 0 {
25879 break
25880 }
25881 z := v_0.Args[0]
25882 if z.Op != OpARM64AND {
25883 break
25884 }
25885 _ = z.Args[1]
25886 z_0 := z.Args[0]
25887 z_1 := z.Args[1]
25888 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25889 x := z_0
25890 y := z_1
25891 if !(z.Uses == 1) {
25892 continue
25893 }
25894 v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
25895 v0.AddArg2(x, y)
25896 b.resetWithControl(block.BlockARM64LE, v0)
25897 return true
25898 }
25899 break
25900 }
25901
25902
25903
25904 for b.Controls[0].Op == OpARM64CMPWconst {
25905 v_0 := b.Controls[0]
25906 if auxIntToInt32(v_0.AuxInt) != 0 {
25907 break
25908 }
25909 x := v_0.Args[0]
25910 if x.Op != OpARM64ANDconst {
25911 break
25912 }
25913 c := auxIntToInt64(x.AuxInt)
25914 y := x.Args[0]
25915 if !(x.Uses == 1) {
25916 break
25917 }
25918 v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
25919 v0.AuxInt = int32ToAuxInt(int32(c))
25920 v0.AddArg(y)
25921 b.resetWithControl(block.BlockARM64LE, v0)
25922 return true
25923 }
25924
25925
25926
25927 for b.Controls[0].Op == OpARM64CMPconst {
25928 v_0 := b.Controls[0]
25929 if auxIntToInt64(v_0.AuxInt) != 0 {
25930 break
25931 }
25932 x := v_0.Args[0]
25933 if x.Op != OpARM64ADDconst {
25934 break
25935 }
25936 c := auxIntToInt64(x.AuxInt)
25937 y := x.Args[0]
25938 if !(x.Uses == 1) {
25939 break
25940 }
25941 v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
25942 v0.AuxInt = int64ToAuxInt(c)
25943 v0.AddArg(y)
25944 b.resetWithControl(block.BlockARM64LEnoov, v0)
25945 return true
25946 }
25947
25948
25949
25950 for b.Controls[0].Op == OpARM64CMPWconst {
25951 v_0 := b.Controls[0]
25952 if auxIntToInt32(v_0.AuxInt) != 0 {
25953 break
25954 }
25955 x := v_0.Args[0]
25956 if x.Op != OpARM64ADDconst {
25957 break
25958 }
25959 c := auxIntToInt64(x.AuxInt)
25960 y := x.Args[0]
25961 if !(x.Uses == 1) {
25962 break
25963 }
25964 v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
25965 v0.AuxInt = int32ToAuxInt(int32(c))
25966 v0.AddArg(y)
25967 b.resetWithControl(block.BlockARM64LEnoov, v0)
25968 return true
25969 }
25970
25971
25972
25973 for b.Controls[0].Op == OpARM64CMPconst {
25974 v_0 := b.Controls[0]
25975 if auxIntToInt64(v_0.AuxInt) != 0 {
25976 break
25977 }
25978 z := v_0.Args[0]
25979 if z.Op != OpARM64ADD {
25980 break
25981 }
25982 _ = z.Args[1]
25983 z_0 := z.Args[0]
25984 z_1 := z.Args[1]
25985 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
25986 x := z_0
25987 y := z_1
25988 if !(z.Uses == 1) {
25989 continue
25990 }
25991 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
25992 v0.AddArg2(x, y)
25993 b.resetWithControl(block.BlockARM64LEnoov, v0)
25994 return true
25995 }
25996 break
25997 }
25998
25999
26000
26001 for b.Controls[0].Op == OpARM64CMPWconst {
26002 v_0 := b.Controls[0]
26003 if auxIntToInt32(v_0.AuxInt) != 0 {
26004 break
26005 }
26006 z := v_0.Args[0]
26007 if z.Op != OpARM64ADD {
26008 break
26009 }
26010 _ = z.Args[1]
26011 z_0 := z.Args[0]
26012 z_1 := z.Args[1]
26013 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26014 x := z_0
26015 y := z_1
26016 if !(z.Uses == 1) {
26017 continue
26018 }
26019 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
26020 v0.AddArg2(x, y)
26021 b.resetWithControl(block.BlockARM64LEnoov, v0)
26022 return true
26023 }
26024 break
26025 }
26026
26027
26028
26029 for b.Controls[0].Op == OpARM64CMPconst {
26030 v_0 := b.Controls[0]
26031 if auxIntToInt64(v_0.AuxInt) != 0 {
26032 break
26033 }
26034 z := v_0.Args[0]
26035 if z.Op != OpARM64MADD {
26036 break
26037 }
26038 y := z.Args[2]
26039 a := z.Args[0]
26040 x := z.Args[1]
26041 if !(z.Uses == 1) {
26042 break
26043 }
26044 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
26045 v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
26046 v1.AddArg2(x, y)
26047 v0.AddArg2(a, v1)
26048 b.resetWithControl(block.BlockARM64LEnoov, v0)
26049 return true
26050 }
26051
26052
26053
26054 for b.Controls[0].Op == OpARM64CMPWconst {
26055 v_0 := b.Controls[0]
26056 if auxIntToInt32(v_0.AuxInt) != 0 {
26057 break
26058 }
26059 z := v_0.Args[0]
26060 if z.Op != OpARM64MADDW {
26061 break
26062 }
26063 y := z.Args[2]
26064 a := z.Args[0]
26065 x := z.Args[1]
26066 if !(z.Uses == 1) {
26067 break
26068 }
26069 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
26070 v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
26071 v1.AddArg2(x, y)
26072 v0.AddArg2(a, v1)
26073 b.resetWithControl(block.BlockARM64LEnoov, v0)
26074 return true
26075 }
26076
26077
26078
26079 for b.Controls[0].Op == OpARM64FlagConstant {
26080 v_0 := b.Controls[0]
26081 fc := auxIntToFlagConstant(v_0.AuxInt)
26082 if !(fc.le()) {
26083 break
26084 }
26085 b.Reset(block.BlockFirst)
26086 return true
26087 }
26088
26089
26090
26091 for b.Controls[0].Op == OpARM64FlagConstant {
26092 v_0 := b.Controls[0]
26093 fc := auxIntToFlagConstant(v_0.AuxInt)
26094 if !(!fc.le()) {
26095 break
26096 }
26097 b.Reset(block.BlockFirst)
26098 b.swapSuccessors()
26099 return true
26100 }
26101
26102
26103 for b.Controls[0].Op == OpARM64InvertFlags {
26104 v_0 := b.Controls[0]
26105 cmp := v_0.Args[0]
26106 b.resetWithControl(block.BlockARM64GE, cmp)
26107 return true
26108 }
26109 case block.BlockARM64LEnoov:
26110
26111
26112
26113 for b.Controls[0].Op == OpARM64FlagConstant {
26114 v_0 := b.Controls[0]
26115 fc := auxIntToFlagConstant(v_0.AuxInt)
26116 if !(fc.leNoov()) {
26117 break
26118 }
26119 b.Reset(block.BlockFirst)
26120 return true
26121 }
26122
26123
26124
26125 for b.Controls[0].Op == OpARM64FlagConstant {
26126 v_0 := b.Controls[0]
26127 fc := auxIntToFlagConstant(v_0.AuxInt)
26128 if !(!fc.leNoov()) {
26129 break
26130 }
26131 b.Reset(block.BlockFirst)
26132 b.swapSuccessors()
26133 return true
26134 }
26135 case block.BlockARM64LT:
26136
26137
26138
26139 for b.Controls[0].Op == OpARM64CMPconst {
26140 v_0 := b.Controls[0]
26141 if auxIntToInt64(v_0.AuxInt) != 0 {
26142 break
26143 }
26144 z := v_0.Args[0]
26145 if z.Op != OpARM64AND {
26146 break
26147 }
26148 _ = z.Args[1]
26149 z_0 := z.Args[0]
26150 z_1 := z.Args[1]
26151 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26152 x := z_0
26153 y := z_1
26154 if !(z.Uses == 1) {
26155 continue
26156 }
26157 v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
26158 v0.AddArg2(x, y)
26159 b.resetWithControl(block.BlockARM64LT, v0)
26160 return true
26161 }
26162 break
26163 }
26164
26165
26166
26167 for b.Controls[0].Op == OpARM64CMPconst {
26168 v_0 := b.Controls[0]
26169 if auxIntToInt64(v_0.AuxInt) != 0 {
26170 break
26171 }
26172 x := v_0.Args[0]
26173 if x.Op != OpARM64ANDconst {
26174 break
26175 }
26176 c := auxIntToInt64(x.AuxInt)
26177 y := x.Args[0]
26178 if !(x.Uses == 1) {
26179 break
26180 }
26181 v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
26182 v0.AuxInt = int64ToAuxInt(c)
26183 v0.AddArg(y)
26184 b.resetWithControl(block.BlockARM64LT, v0)
26185 return true
26186 }
26187
26188
26189
26190 for b.Controls[0].Op == OpARM64CMPWconst {
26191 v_0 := b.Controls[0]
26192 if auxIntToInt32(v_0.AuxInt) != 0 {
26193 break
26194 }
26195 z := v_0.Args[0]
26196 if z.Op != OpARM64AND {
26197 break
26198 }
26199 _ = z.Args[1]
26200 z_0 := z.Args[0]
26201 z_1 := z.Args[1]
26202 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26203 x := z_0
26204 y := z_1
26205 if !(z.Uses == 1) {
26206 continue
26207 }
26208 v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
26209 v0.AddArg2(x, y)
26210 b.resetWithControl(block.BlockARM64LT, v0)
26211 return true
26212 }
26213 break
26214 }
26215
26216
26217
26218 for b.Controls[0].Op == OpARM64CMPWconst {
26219 v_0 := b.Controls[0]
26220 if auxIntToInt32(v_0.AuxInt) != 0 {
26221 break
26222 }
26223 x := v_0.Args[0]
26224 if x.Op != OpARM64ANDconst {
26225 break
26226 }
26227 c := auxIntToInt64(x.AuxInt)
26228 y := x.Args[0]
26229 if !(x.Uses == 1) {
26230 break
26231 }
26232 v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
26233 v0.AuxInt = int32ToAuxInt(int32(c))
26234 v0.AddArg(y)
26235 b.resetWithControl(block.BlockARM64LT, v0)
26236 return true
26237 }
26238
26239
26240
26241 for b.Controls[0].Op == OpARM64CMPconst {
26242 v_0 := b.Controls[0]
26243 if auxIntToInt64(v_0.AuxInt) != 0 {
26244 break
26245 }
26246 x := v_0.Args[0]
26247 if x.Op != OpARM64ADDconst {
26248 break
26249 }
26250 c := auxIntToInt64(x.AuxInt)
26251 y := x.Args[0]
26252 if !(x.Uses == 1) {
26253 break
26254 }
26255 v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
26256 v0.AuxInt = int64ToAuxInt(c)
26257 v0.AddArg(y)
26258 b.resetWithControl(block.BlockARM64LTnoov, v0)
26259 return true
26260 }
26261
26262
26263
26264 for b.Controls[0].Op == OpARM64CMPWconst {
26265 v_0 := b.Controls[0]
26266 if auxIntToInt32(v_0.AuxInt) != 0 {
26267 break
26268 }
26269 x := v_0.Args[0]
26270 if x.Op != OpARM64ADDconst {
26271 break
26272 }
26273 c := auxIntToInt64(x.AuxInt)
26274 y := x.Args[0]
26275 if !(x.Uses == 1) {
26276 break
26277 }
26278 v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
26279 v0.AuxInt = int32ToAuxInt(int32(c))
26280 v0.AddArg(y)
26281 b.resetWithControl(block.BlockARM64LTnoov, v0)
26282 return true
26283 }
26284
26285
26286
26287 for b.Controls[0].Op == OpARM64CMPconst {
26288 v_0 := b.Controls[0]
26289 if auxIntToInt64(v_0.AuxInt) != 0 {
26290 break
26291 }
26292 z := v_0.Args[0]
26293 if z.Op != OpARM64ADD {
26294 break
26295 }
26296 _ = z.Args[1]
26297 z_0 := z.Args[0]
26298 z_1 := z.Args[1]
26299 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26300 x := z_0
26301 y := z_1
26302 if !(z.Uses == 1) {
26303 continue
26304 }
26305 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
26306 v0.AddArg2(x, y)
26307 b.resetWithControl(block.BlockARM64LTnoov, v0)
26308 return true
26309 }
26310 break
26311 }
26312
26313
26314
26315 for b.Controls[0].Op == OpARM64CMPWconst {
26316 v_0 := b.Controls[0]
26317 if auxIntToInt32(v_0.AuxInt) != 0 {
26318 break
26319 }
26320 z := v_0.Args[0]
26321 if z.Op != OpARM64ADD {
26322 break
26323 }
26324 _ = z.Args[1]
26325 z_0 := z.Args[0]
26326 z_1 := z.Args[1]
26327 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26328 x := z_0
26329 y := z_1
26330 if !(z.Uses == 1) {
26331 continue
26332 }
26333 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
26334 v0.AddArg2(x, y)
26335 b.resetWithControl(block.BlockARM64LTnoov, v0)
26336 return true
26337 }
26338 break
26339 }
26340
26341
26342
26343 for b.Controls[0].Op == OpARM64CMPconst {
26344 v_0 := b.Controls[0]
26345 if auxIntToInt64(v_0.AuxInt) != 0 {
26346 break
26347 }
26348 z := v_0.Args[0]
26349 if z.Op != OpARM64MADD {
26350 break
26351 }
26352 y := z.Args[2]
26353 a := z.Args[0]
26354 x := z.Args[1]
26355 if !(z.Uses == 1) {
26356 break
26357 }
26358 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
26359 v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
26360 v1.AddArg2(x, y)
26361 v0.AddArg2(a, v1)
26362 b.resetWithControl(block.BlockARM64LTnoov, v0)
26363 return true
26364 }
26365
26366
26367
26368 for b.Controls[0].Op == OpARM64CMPWconst {
26369 v_0 := b.Controls[0]
26370 if auxIntToInt32(v_0.AuxInt) != 0 {
26371 break
26372 }
26373 z := v_0.Args[0]
26374 if z.Op != OpARM64MADDW {
26375 break
26376 }
26377 y := z.Args[2]
26378 a := z.Args[0]
26379 x := z.Args[1]
26380 if !(z.Uses == 1) {
26381 break
26382 }
26383 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
26384 v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
26385 v1.AddArg2(x, y)
26386 v0.AddArg2(a, v1)
26387 b.resetWithControl(block.BlockARM64LTnoov, v0)
26388 return true
26389 }
26390
26391
26392 for b.Controls[0].Op == OpARM64CMPWconst {
26393 v_0 := b.Controls[0]
26394 if auxIntToInt32(v_0.AuxInt) != 0 {
26395 break
26396 }
26397 x := v_0.Args[0]
26398 b.resetWithControl(block.BlockARM64TBNZ, x)
26399 b.AuxInt = int64ToAuxInt(31)
26400 return true
26401 }
26402
26403
26404 for b.Controls[0].Op == OpARM64CMPconst {
26405 v_0 := b.Controls[0]
26406 if auxIntToInt64(v_0.AuxInt) != 0 {
26407 break
26408 }
26409 x := v_0.Args[0]
26410 b.resetWithControl(block.BlockARM64TBNZ, x)
26411 b.AuxInt = int64ToAuxInt(63)
26412 return true
26413 }
26414
26415
26416
26417 for b.Controls[0].Op == OpARM64CMPWconst {
26418 v_0 := b.Controls[0]
26419 if auxIntToInt32(v_0.AuxInt) != 128 {
26420 break
26421 }
26422 x := v_0.Args[0]
26423 if !(ZeroUpper56Bits(x)) {
26424 break
26425 }
26426 b.resetWithControl(block.BlockARM64TBZ, x)
26427 b.AuxInt = int64ToAuxInt(7)
26428 return true
26429 }
26430
26431
26432
26433 for b.Controls[0].Op == OpARM64CMPconst {
26434 v_0 := b.Controls[0]
26435 if auxIntToInt64(v_0.AuxInt) != 128 {
26436 break
26437 }
26438 x := v_0.Args[0]
26439 if !(ZeroUpper56Bits(x)) {
26440 break
26441 }
26442 b.resetWithControl(block.BlockARM64TBZ, x)
26443 b.AuxInt = int64ToAuxInt(7)
26444 return true
26445 }
26446
26447
26448
26449 for b.Controls[0].Op == OpARM64FlagConstant {
26450 v_0 := b.Controls[0]
26451 fc := auxIntToFlagConstant(v_0.AuxInt)
26452 if !(fc.lt()) {
26453 break
26454 }
26455 b.Reset(block.BlockFirst)
26456 return true
26457 }
26458
26459
26460
26461 for b.Controls[0].Op == OpARM64FlagConstant {
26462 v_0 := b.Controls[0]
26463 fc := auxIntToFlagConstant(v_0.AuxInt)
26464 if !(!fc.lt()) {
26465 break
26466 }
26467 b.Reset(block.BlockFirst)
26468 b.swapSuccessors()
26469 return true
26470 }
26471
26472
26473 for b.Controls[0].Op == OpARM64InvertFlags {
26474 v_0 := b.Controls[0]
26475 cmp := v_0.Args[0]
26476 b.resetWithControl(block.BlockARM64GT, cmp)
26477 return true
26478 }
26479 case block.BlockARM64LTnoov:
26480
26481
26482
26483 for b.Controls[0].Op == OpARM64FlagConstant {
26484 v_0 := b.Controls[0]
26485 fc := auxIntToFlagConstant(v_0.AuxInt)
26486 if !(fc.ltNoov()) {
26487 break
26488 }
26489 b.Reset(block.BlockFirst)
26490 return true
26491 }
26492
26493
26494
26495 for b.Controls[0].Op == OpARM64FlagConstant {
26496 v_0 := b.Controls[0]
26497 fc := auxIntToFlagConstant(v_0.AuxInt)
26498 if !(!fc.ltNoov()) {
26499 break
26500 }
26501 b.Reset(block.BlockFirst)
26502 b.swapSuccessors()
26503 return true
26504 }
26505 case block.BlockARM64NE:
26506
26507
26508
26509 for b.Controls[0].Op == OpARM64CMPconst {
26510 v_0 := b.Controls[0]
26511 if auxIntToInt64(v_0.AuxInt) != 0 {
26512 break
26513 }
26514 z := v_0.Args[0]
26515 if z.Op != OpARM64AND {
26516 break
26517 }
26518 _ = z.Args[1]
26519 z_0 := z.Args[0]
26520 z_1 := z.Args[1]
26521 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26522 x := z_0
26523 y := z_1
26524 if !(z.Uses == 1) {
26525 continue
26526 }
26527 v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
26528 v0.AddArg2(x, y)
26529 b.resetWithControl(block.BlockARM64NE, v0)
26530 return true
26531 }
26532 break
26533 }
26534
26535
26536
26537 for b.Controls[0].Op == OpARM64CMPconst {
26538 v_0 := b.Controls[0]
26539 if auxIntToInt64(v_0.AuxInt) != 0 {
26540 break
26541 }
26542 x := v_0.Args[0]
26543 if x.Op != OpARM64ANDconst {
26544 break
26545 }
26546 c := auxIntToInt64(x.AuxInt)
26547 y := x.Args[0]
26548 if !(x.Uses == 1) {
26549 break
26550 }
26551 v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
26552 v0.AuxInt = int64ToAuxInt(c)
26553 v0.AddArg(y)
26554 b.resetWithControl(block.BlockARM64NE, v0)
26555 return true
26556 }
26557
26558
26559
26560 for b.Controls[0].Op == OpARM64CMPWconst {
26561 v_0 := b.Controls[0]
26562 if auxIntToInt32(v_0.AuxInt) != 0 {
26563 break
26564 }
26565 z := v_0.Args[0]
26566 if z.Op != OpARM64AND {
26567 break
26568 }
26569 _ = z.Args[1]
26570 z_0 := z.Args[0]
26571 z_1 := z.Args[1]
26572 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26573 x := z_0
26574 y := z_1
26575 if !(z.Uses == 1) {
26576 continue
26577 }
26578 v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
26579 v0.AddArg2(x, y)
26580 b.resetWithControl(block.BlockARM64NE, v0)
26581 return true
26582 }
26583 break
26584 }
26585
26586
26587
26588 for b.Controls[0].Op == OpARM64CMPWconst {
26589 v_0 := b.Controls[0]
26590 if auxIntToInt32(v_0.AuxInt) != 0 {
26591 break
26592 }
26593 x := v_0.Args[0]
26594 if x.Op != OpARM64ANDconst {
26595 break
26596 }
26597 c := auxIntToInt64(x.AuxInt)
26598 y := x.Args[0]
26599 if !(x.Uses == 1) {
26600 break
26601 }
26602 v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
26603 v0.AuxInt = int32ToAuxInt(int32(c))
26604 v0.AddArg(y)
26605 b.resetWithControl(block.BlockARM64NE, v0)
26606 return true
26607 }
26608
26609
26610
26611 for b.Controls[0].Op == OpARM64CMPconst {
26612 v_0 := b.Controls[0]
26613 if auxIntToInt64(v_0.AuxInt) != 0 {
26614 break
26615 }
26616 x := v_0.Args[0]
26617 if x.Op != OpARM64ADDconst {
26618 break
26619 }
26620 c := auxIntToInt64(x.AuxInt)
26621 y := x.Args[0]
26622 if !(x.Uses == 1) {
26623 break
26624 }
26625 v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
26626 v0.AuxInt = int64ToAuxInt(c)
26627 v0.AddArg(y)
26628 b.resetWithControl(block.BlockARM64NE, v0)
26629 return true
26630 }
26631
26632
26633
26634 for b.Controls[0].Op == OpARM64CMPWconst {
26635 v_0 := b.Controls[0]
26636 if auxIntToInt32(v_0.AuxInt) != 0 {
26637 break
26638 }
26639 x := v_0.Args[0]
26640 if x.Op != OpARM64ADDconst {
26641 break
26642 }
26643 c := auxIntToInt64(x.AuxInt)
26644 y := x.Args[0]
26645 if !(x.Uses == 1) {
26646 break
26647 }
26648 v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
26649 v0.AuxInt = int32ToAuxInt(int32(c))
26650 v0.AddArg(y)
26651 b.resetWithControl(block.BlockARM64NE, v0)
26652 return true
26653 }
26654
26655
26656
26657 for b.Controls[0].Op == OpARM64CMPconst {
26658 v_0 := b.Controls[0]
26659 if auxIntToInt64(v_0.AuxInt) != 0 {
26660 break
26661 }
26662 z := v_0.Args[0]
26663 if z.Op != OpARM64ADD {
26664 break
26665 }
26666 _ = z.Args[1]
26667 z_0 := z.Args[0]
26668 z_1 := z.Args[1]
26669 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26670 x := z_0
26671 y := z_1
26672 if !(z.Uses == 1) {
26673 continue
26674 }
26675 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
26676 v0.AddArg2(x, y)
26677 b.resetWithControl(block.BlockARM64NE, v0)
26678 return true
26679 }
26680 break
26681 }
26682
26683
26684
26685 for b.Controls[0].Op == OpARM64CMPWconst {
26686 v_0 := b.Controls[0]
26687 if auxIntToInt32(v_0.AuxInt) != 0 {
26688 break
26689 }
26690 z := v_0.Args[0]
26691 if z.Op != OpARM64ADD {
26692 break
26693 }
26694 _ = z.Args[1]
26695 z_0 := z.Args[0]
26696 z_1 := z.Args[1]
26697 for _i0 := 0; _i0 <= 1; _i0, z_0, z_1 = _i0+1, z_1, z_0 {
26698 x := z_0
26699 y := z_1
26700 if !(z.Uses == 1) {
26701 continue
26702 }
26703 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
26704 v0.AddArg2(x, y)
26705 b.resetWithControl(block.BlockARM64NE, v0)
26706 return true
26707 }
26708 break
26709 }
26710
26711
26712
26713 for b.Controls[0].Op == OpARM64CMP {
26714 v_0 := b.Controls[0]
26715 _ = v_0.Args[1]
26716 x := v_0.Args[0]
26717 z := v_0.Args[1]
26718 if z.Op != OpARM64NEG {
26719 break
26720 }
26721 y := z.Args[0]
26722 if !(z.Uses == 1) {
26723 break
26724 }
26725 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
26726 v0.AddArg2(x, y)
26727 b.resetWithControl(block.BlockARM64NE, v0)
26728 return true
26729 }
26730
26731
26732
26733 for b.Controls[0].Op == OpARM64CMPW {
26734 v_0 := b.Controls[0]
26735 _ = v_0.Args[1]
26736 x := v_0.Args[0]
26737 z := v_0.Args[1]
26738 if z.Op != OpARM64NEG {
26739 break
26740 }
26741 y := z.Args[0]
26742 if !(z.Uses == 1) {
26743 break
26744 }
26745 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
26746 v0.AddArg2(x, y)
26747 b.resetWithControl(block.BlockARM64NE, v0)
26748 return true
26749 }
26750
26751
26752 for b.Controls[0].Op == OpARM64CMPconst {
26753 v_0 := b.Controls[0]
26754 if auxIntToInt64(v_0.AuxInt) != 0 {
26755 break
26756 }
26757 x := v_0.Args[0]
26758 b.resetWithControl(block.BlockARM64NZ, x)
26759 return true
26760 }
26761
26762
26763 for b.Controls[0].Op == OpARM64CMPWconst {
26764 v_0 := b.Controls[0]
26765 if auxIntToInt32(v_0.AuxInt) != 0 {
26766 break
26767 }
26768 x := v_0.Args[0]
26769 b.resetWithControl(block.BlockARM64NZW, x)
26770 return true
26771 }
26772
26773
26774
26775 for b.Controls[0].Op == OpARM64CMPconst {
26776 v_0 := b.Controls[0]
26777 if auxIntToInt64(v_0.AuxInt) != 0 {
26778 break
26779 }
26780 z := v_0.Args[0]
26781 if z.Op != OpARM64MADD {
26782 break
26783 }
26784 y := z.Args[2]
26785 a := z.Args[0]
26786 x := z.Args[1]
26787 if !(z.Uses == 1) {
26788 break
26789 }
26790 v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
26791 v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
26792 v1.AddArg2(x, y)
26793 v0.AddArg2(a, v1)
26794 b.resetWithControl(block.BlockARM64NE, v0)
26795 return true
26796 }
26797
26798
26799
26800 for b.Controls[0].Op == OpARM64CMPWconst {
26801 v_0 := b.Controls[0]
26802 if auxIntToInt32(v_0.AuxInt) != 0 {
26803 break
26804 }
26805 z := v_0.Args[0]
26806 if z.Op != OpARM64MADDW {
26807 break
26808 }
26809 y := z.Args[2]
26810 a := z.Args[0]
26811 x := z.Args[1]
26812 if !(z.Uses == 1) {
26813 break
26814 }
26815 v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
26816 v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
26817 v1.AddArg2(x, y)
26818 v0.AddArg2(a, v1)
26819 b.resetWithControl(block.BlockARM64NE, v0)
26820 return true
26821 }
26822
26823
26824
26825 for b.Controls[0].Op == OpARM64CMPconst {
26826 v_0 := b.Controls[0]
26827 if auxIntToInt64(v_0.AuxInt) != 0 {
26828 break
26829 }
26830 z := v_0.Args[0]
26831 if z.Op != OpARM64MSUB {
26832 break
26833 }
26834 y := z.Args[2]
26835 a := z.Args[0]
26836 x := z.Args[1]
26837 if !(z.Uses == 1) {
26838 break
26839 }
26840 v0 := b.NewValue0(v_0.Pos, OpARM64CMP, types.TypeFlags)
26841 v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
26842 v1.AddArg2(x, y)
26843 v0.AddArg2(a, v1)
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 z := v_0.Args[0]
26856 if z.Op != OpARM64MSUBW {
26857 break
26858 }
26859 y := z.Args[2]
26860 a := z.Args[0]
26861 x := z.Args[1]
26862 if !(z.Uses == 1) {
26863 break
26864 }
26865 v0 := b.NewValue0(v_0.Pos, OpARM64CMPW, types.TypeFlags)
26866 v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
26867 v1.AddArg2(x, y)
26868 v0.AddArg2(a, v1)
26869 b.resetWithControl(block.BlockARM64NE, v0)
26870 return true
26871 }
26872
26873
26874
26875 for b.Controls[0].Op == OpARM64TSTconst {
26876 v_0 := b.Controls[0]
26877 c := auxIntToInt64(v_0.AuxInt)
26878 x := v_0.Args[0]
26879 if !(oneBit(c)) {
26880 break
26881 }
26882 b.resetWithControl(block.BlockARM64TBNZ, x)
26883 b.AuxInt = int64ToAuxInt(int64(ntz64(c)))
26884 return true
26885 }
26886
26887
26888
26889 for b.Controls[0].Op == OpARM64TSTWconst {
26890 v_0 := b.Controls[0]
26891 c := auxIntToInt32(v_0.AuxInt)
26892 x := v_0.Args[0]
26893 if !(oneBit(int64(uint32(c)))) {
26894 break
26895 }
26896 b.resetWithControl(block.BlockARM64TBNZ, x)
26897 b.AuxInt = int64ToAuxInt(int64(ntz64(int64(uint32(c)))))
26898 return true
26899 }
26900
26901
26902
26903 for b.Controls[0].Op == OpARM64FlagConstant {
26904 v_0 := b.Controls[0]
26905 fc := auxIntToFlagConstant(v_0.AuxInt)
26906 if !(fc.ne()) {
26907 break
26908 }
26909 b.Reset(block.BlockFirst)
26910 return true
26911 }
26912
26913
26914
26915 for b.Controls[0].Op == OpARM64FlagConstant {
26916 v_0 := b.Controls[0]
26917 fc := auxIntToFlagConstant(v_0.AuxInt)
26918 if !(!fc.ne()) {
26919 break
26920 }
26921 b.Reset(block.BlockFirst)
26922 b.swapSuccessors()
26923 return true
26924 }
26925
26926
26927 for b.Controls[0].Op == OpARM64InvertFlags {
26928 v_0 := b.Controls[0]
26929 cmp := v_0.Args[0]
26930 b.resetWithControl(block.BlockARM64NE, cmp)
26931 return true
26932 }
26933 case block.BlockARM64NZ:
26934
26935
26936 for b.Controls[0].Op == OpARM64Equal {
26937 v_0 := b.Controls[0]
26938 cc := v_0.Args[0]
26939 b.resetWithControl(block.BlockARM64EQ, cc)
26940 return true
26941 }
26942
26943
26944 for b.Controls[0].Op == OpARM64NotEqual {
26945 v_0 := b.Controls[0]
26946 cc := v_0.Args[0]
26947 b.resetWithControl(block.BlockARM64NE, cc)
26948 return true
26949 }
26950
26951
26952 for b.Controls[0].Op == OpARM64LessThan {
26953 v_0 := b.Controls[0]
26954 cc := v_0.Args[0]
26955 b.resetWithControl(block.BlockARM64LT, cc)
26956 return true
26957 }
26958
26959
26960 for b.Controls[0].Op == OpARM64LessThanU {
26961 v_0 := b.Controls[0]
26962 cc := v_0.Args[0]
26963 b.resetWithControl(block.BlockARM64ULT, cc)
26964 return true
26965 }
26966
26967
26968 for b.Controls[0].Op == OpARM64LessEqual {
26969 v_0 := b.Controls[0]
26970 cc := v_0.Args[0]
26971 b.resetWithControl(block.BlockARM64LE, cc)
26972 return true
26973 }
26974
26975
26976 for b.Controls[0].Op == OpARM64LessEqualU {
26977 v_0 := b.Controls[0]
26978 cc := v_0.Args[0]
26979 b.resetWithControl(block.BlockARM64ULE, cc)
26980 return true
26981 }
26982
26983
26984 for b.Controls[0].Op == OpARM64GreaterThan {
26985 v_0 := b.Controls[0]
26986 cc := v_0.Args[0]
26987 b.resetWithControl(block.BlockARM64GT, cc)
26988 return true
26989 }
26990
26991
26992 for b.Controls[0].Op == OpARM64GreaterThanU {
26993 v_0 := b.Controls[0]
26994 cc := v_0.Args[0]
26995 b.resetWithControl(block.BlockARM64UGT, cc)
26996 return true
26997 }
26998
26999
27000 for b.Controls[0].Op == OpARM64GreaterEqual {
27001 v_0 := b.Controls[0]
27002 cc := v_0.Args[0]
27003 b.resetWithControl(block.BlockARM64GE, cc)
27004 return true
27005 }
27006
27007
27008 for b.Controls[0].Op == OpARM64GreaterEqualU {
27009 v_0 := b.Controls[0]
27010 cc := v_0.Args[0]
27011 b.resetWithControl(block.BlockARM64UGE, cc)
27012 return true
27013 }
27014
27015
27016 for b.Controls[0].Op == OpARM64LessThanF {
27017 v_0 := b.Controls[0]
27018 cc := v_0.Args[0]
27019 b.resetWithControl(block.BlockARM64FLT, cc)
27020 return true
27021 }
27022
27023
27024 for b.Controls[0].Op == OpARM64LessEqualF {
27025 v_0 := b.Controls[0]
27026 cc := v_0.Args[0]
27027 b.resetWithControl(block.BlockARM64FLE, cc)
27028 return true
27029 }
27030
27031
27032 for b.Controls[0].Op == OpARM64GreaterThanF {
27033 v_0 := b.Controls[0]
27034 cc := v_0.Args[0]
27035 b.resetWithControl(block.BlockARM64FGT, cc)
27036 return true
27037 }
27038
27039
27040 for b.Controls[0].Op == OpARM64GreaterEqualF {
27041 v_0 := b.Controls[0]
27042 cc := v_0.Args[0]
27043 b.resetWithControl(block.BlockARM64FGE, cc)
27044 return true
27045 }
27046
27047
27048
27049 for b.Controls[0].Op == OpARM64SUB {
27050 sub := b.Controls[0]
27051 y := sub.Args[1]
27052 x := sub.Args[0]
27053 if !(sub.Uses == 1) {
27054 break
27055 }
27056 v0 := b.NewValue0(sub.Pos, OpARM64CMP, types.TypeFlags)
27057 v0.AddArg2(x, y)
27058 b.resetWithControl(block.BlockARM64NE, v0)
27059 return true
27060 }
27061
27062
27063
27064 for b.Controls[0].Op == OpARM64SUBconst {
27065 sub := b.Controls[0]
27066 c := auxIntToInt64(sub.AuxInt)
27067 y := sub.Args[0]
27068 if !(sub.Uses == 1) {
27069 break
27070 }
27071 v0 := b.NewValue0(sub.Pos, OpARM64CMPconst, types.TypeFlags)
27072 v0.AuxInt = int64ToAuxInt(c)
27073 v0.AddArg(y)
27074 b.resetWithControl(block.BlockARM64NE, v0)
27075 return true
27076 }
27077
27078
27079
27080 for b.Controls[0].Op == OpARM64ANDconst {
27081 v_0 := b.Controls[0]
27082 c := auxIntToInt64(v_0.AuxInt)
27083 x := v_0.Args[0]
27084 if !(oneBit(c)) {
27085 break
27086 }
27087 b.resetWithControl(block.BlockARM64TBNZ, x)
27088 b.AuxInt = int64ToAuxInt(int64(ntz64(c)))
27089 return true
27090 }
27091
27092
27093
27094 for b.Controls[0].Op == OpARM64SRLconst {
27095 s := b.Controls[0]
27096 if auxIntToInt64(s.AuxInt) != 63 {
27097 break
27098 }
27099 x := s.Args[0]
27100 if !(s.Uses == 1) {
27101 break
27102 }
27103 b.resetWithControl(block.BlockARM64TBNZ, x)
27104 b.AuxInt = int64ToAuxInt(63)
27105 return true
27106 }
27107
27108
27109
27110 for b.Controls[0].Op == OpARM64SRAconst {
27111 s := b.Controls[0]
27112 if auxIntToInt64(s.AuxInt) != 63 {
27113 break
27114 }
27115 x := s.Args[0]
27116 if !(s.Uses == 1) {
27117 break
27118 }
27119 b.resetWithControl(block.BlockARM64TBNZ, x)
27120 b.AuxInt = int64ToAuxInt(63)
27121 return true
27122 }
27123
27124
27125 for b.Controls[0].Op == OpARM64MOVDconst {
27126 v_0 := b.Controls[0]
27127 if auxIntToInt64(v_0.AuxInt) != 0 {
27128 break
27129 }
27130 b.Reset(block.BlockFirst)
27131 b.swapSuccessors()
27132 return true
27133 }
27134
27135
27136
27137 for b.Controls[0].Op == OpARM64MOVDconst {
27138 v_0 := b.Controls[0]
27139 c := auxIntToInt64(v_0.AuxInt)
27140 if !(c != 0) {
27141 break
27142 }
27143 b.Reset(block.BlockFirst)
27144 return true
27145 }
27146 case block.BlockARM64NZW:
27147
27148
27149
27150 for b.Controls[0].Op == OpARM64SUB {
27151 sub := b.Controls[0]
27152 y := sub.Args[1]
27153 x := sub.Args[0]
27154 if !(sub.Uses == 1) {
27155 break
27156 }
27157 v0 := b.NewValue0(sub.Pos, OpARM64CMPW, types.TypeFlags)
27158 v0.AddArg2(x, y)
27159 b.resetWithControl(block.BlockARM64NE, v0)
27160 return true
27161 }
27162
27163
27164
27165 for b.Controls[0].Op == OpARM64SUBconst {
27166 sub := b.Controls[0]
27167 c := auxIntToInt64(sub.AuxInt)
27168 y := sub.Args[0]
27169 if !(sub.Uses == 1) {
27170 break
27171 }
27172 v0 := b.NewValue0(sub.Pos, OpARM64CMPWconst, types.TypeFlags)
27173 v0.AuxInt = int32ToAuxInt(int32(c))
27174 v0.AddArg(y)
27175 b.resetWithControl(block.BlockARM64NE, v0)
27176 return true
27177 }
27178
27179
27180
27181 for b.Controls[0].Op == OpARM64ANDconst {
27182 v_0 := b.Controls[0]
27183 c := auxIntToInt64(v_0.AuxInt)
27184 x := v_0.Args[0]
27185 if !(oneBit(int64(uint32(c)))) {
27186 break
27187 }
27188 b.resetWithControl(block.BlockARM64TBNZ, x)
27189 b.AuxInt = int64ToAuxInt(int64(ntz64(int64(uint32(c)))))
27190 return true
27191 }
27192
27193
27194
27195 for b.Controls[0].Op == OpARM64MOVDconst {
27196 v_0 := b.Controls[0]
27197 c := auxIntToInt64(v_0.AuxInt)
27198 if !(int32(c) == 0) {
27199 break
27200 }
27201 b.Reset(block.BlockFirst)
27202 b.swapSuccessors()
27203 return true
27204 }
27205
27206
27207
27208 for b.Controls[0].Op == OpARM64MOVDconst {
27209 v_0 := b.Controls[0]
27210 c := auxIntToInt64(v_0.AuxInt)
27211 if !(int32(c) != 0) {
27212 break
27213 }
27214 b.Reset(block.BlockFirst)
27215 return true
27216 }
27217 case block.BlockARM64TBNZ:
27218
27219
27220 for b.Controls[0].Op == OpARM64Equal {
27221 v_0 := b.Controls[0]
27222 cc := v_0.Args[0]
27223 if auxIntToInt64(b.AuxInt) != 0 {
27224 break
27225 }
27226 b.resetWithControl(block.BlockARM64EQ, cc)
27227 return true
27228 }
27229
27230
27231 for b.Controls[0].Op == OpARM64NotEqual {
27232 v_0 := b.Controls[0]
27233 cc := v_0.Args[0]
27234 if auxIntToInt64(b.AuxInt) != 0 {
27235 break
27236 }
27237 b.resetWithControl(block.BlockARM64NE, cc)
27238 return true
27239 }
27240
27241
27242 for b.Controls[0].Op == OpARM64LessThan {
27243 v_0 := b.Controls[0]
27244 cc := v_0.Args[0]
27245 if auxIntToInt64(b.AuxInt) != 0 {
27246 break
27247 }
27248 b.resetWithControl(block.BlockARM64LT, cc)
27249 return true
27250 }
27251
27252
27253 for b.Controls[0].Op == OpARM64LessThanU {
27254 v_0 := b.Controls[0]
27255 cc := v_0.Args[0]
27256 if auxIntToInt64(b.AuxInt) != 0 {
27257 break
27258 }
27259 b.resetWithControl(block.BlockARM64ULT, cc)
27260 return true
27261 }
27262
27263
27264 for b.Controls[0].Op == OpARM64LessEqual {
27265 v_0 := b.Controls[0]
27266 cc := v_0.Args[0]
27267 if auxIntToInt64(b.AuxInt) != 0 {
27268 break
27269 }
27270 b.resetWithControl(block.BlockARM64LE, cc)
27271 return true
27272 }
27273
27274
27275 for b.Controls[0].Op == OpARM64LessEqualU {
27276 v_0 := b.Controls[0]
27277 cc := v_0.Args[0]
27278 if auxIntToInt64(b.AuxInt) != 0 {
27279 break
27280 }
27281 b.resetWithControl(block.BlockARM64ULE, cc)
27282 return true
27283 }
27284
27285
27286 for b.Controls[0].Op == OpARM64GreaterThan {
27287 v_0 := b.Controls[0]
27288 cc := v_0.Args[0]
27289 if auxIntToInt64(b.AuxInt) != 0 {
27290 break
27291 }
27292 b.resetWithControl(block.BlockARM64GT, cc)
27293 return true
27294 }
27295
27296
27297 for b.Controls[0].Op == OpARM64GreaterThanU {
27298 v_0 := b.Controls[0]
27299 cc := v_0.Args[0]
27300 if auxIntToInt64(b.AuxInt) != 0 {
27301 break
27302 }
27303 b.resetWithControl(block.BlockARM64UGT, cc)
27304 return true
27305 }
27306
27307
27308 for b.Controls[0].Op == OpARM64GreaterEqual {
27309 v_0 := b.Controls[0]
27310 cc := v_0.Args[0]
27311 if auxIntToInt64(b.AuxInt) != 0 {
27312 break
27313 }
27314 b.resetWithControl(block.BlockARM64GE, cc)
27315 return true
27316 }
27317
27318
27319 for b.Controls[0].Op == OpARM64GreaterEqualU {
27320 v_0 := b.Controls[0]
27321 cc := v_0.Args[0]
27322 if auxIntToInt64(b.AuxInt) != 0 {
27323 break
27324 }
27325 b.resetWithControl(block.BlockARM64UGE, cc)
27326 return true
27327 }
27328
27329
27330 for b.Controls[0].Op == OpARM64LessThanF {
27331 v_0 := b.Controls[0]
27332 cc := v_0.Args[0]
27333 if auxIntToInt64(b.AuxInt) != 0 {
27334 break
27335 }
27336 b.resetWithControl(block.BlockARM64FLT, cc)
27337 return true
27338 }
27339
27340
27341 for b.Controls[0].Op == OpARM64LessEqualF {
27342 v_0 := b.Controls[0]
27343 cc := v_0.Args[0]
27344 if auxIntToInt64(b.AuxInt) != 0 {
27345 break
27346 }
27347 b.resetWithControl(block.BlockARM64FLE, cc)
27348 return true
27349 }
27350
27351
27352 for b.Controls[0].Op == OpARM64GreaterThanF {
27353 v_0 := b.Controls[0]
27354 cc := v_0.Args[0]
27355 if auxIntToInt64(b.AuxInt) != 0 {
27356 break
27357 }
27358 b.resetWithControl(block.BlockARM64FGT, cc)
27359 return true
27360 }
27361
27362
27363 for b.Controls[0].Op == OpARM64GreaterEqualF {
27364 v_0 := b.Controls[0]
27365 cc := v_0.Args[0]
27366 if auxIntToInt64(b.AuxInt) != 0 {
27367 break
27368 }
27369 b.resetWithControl(block.BlockARM64FGE, cc)
27370 return true
27371 }
27372
27373
27374 for b.Controls[0].Op == OpARM64XORconst {
27375 v_0 := b.Controls[0]
27376 if auxIntToInt64(v_0.AuxInt) != 1 {
27377 break
27378 }
27379 x := v_0.Args[0]
27380 if auxIntToInt64(b.AuxInt) != 0 {
27381 break
27382 }
27383 b.resetWithControl(block.BlockARM64TBZ, x)
27384 b.AuxInt = int64ToAuxInt(0)
27385 return true
27386 }
27387
27388
27389
27390 for b.Controls[0].Op == OpARM64SRLconst {
27391 sv := b.Controls[0]
27392 s := auxIntToInt64(sv.AuxInt)
27393 x := sv.Args[0]
27394 t := auxIntToInt64(b.AuxInt)
27395 if !(t+s < 64 && sv.Uses == 1) {
27396 break
27397 }
27398 b.resetWithControl(block.BlockARM64TBNZ, x)
27399 b.AuxInt = int64ToAuxInt(t + s)
27400 return true
27401 }
27402
27403
27404
27405 for b.Controls[0].Op == OpARM64SRLconst {
27406 v_0 := b.Controls[0]
27407 s := auxIntToInt64(v_0.AuxInt)
27408 t := auxIntToInt64(b.AuxInt)
27409 if !(t+s >= 64) {
27410 break
27411 }
27412 b.Reset(block.BlockFirst)
27413 b.swapSuccessors()
27414 return true
27415 }
27416
27417
27418
27419 for b.Controls[0].Op == OpARM64SLLconst {
27420 sv := b.Controls[0]
27421 s := auxIntToInt64(sv.AuxInt)
27422 x := sv.Args[0]
27423 t := auxIntToInt64(b.AuxInt)
27424 if !(t-s >= 0 && sv.Uses == 1) {
27425 break
27426 }
27427 b.resetWithControl(block.BlockARM64TBNZ, x)
27428 b.AuxInt = int64ToAuxInt(t - s)
27429 return true
27430 }
27431
27432
27433
27434 for b.Controls[0].Op == OpARM64SLLconst {
27435 v_0 := b.Controls[0]
27436 s := auxIntToInt64(v_0.AuxInt)
27437 t := auxIntToInt64(b.AuxInt)
27438 if !(t-s < 0) {
27439 break
27440 }
27441 b.Reset(block.BlockFirst)
27442 b.swapSuccessors()
27443 return true
27444 }
27445
27446
27447
27448 for b.Controls[0].Op == OpARM64RORconst {
27449 rv := b.Controls[0]
27450 r := auxIntToInt64(rv.AuxInt)
27451 x := rv.Args[0]
27452 t := auxIntToInt64(b.AuxInt)
27453 if !(rv.Uses == 1) {
27454 break
27455 }
27456 b.resetWithControl(block.BlockARM64TBNZ, x)
27457 b.AuxInt = int64ToAuxInt(int64(uint64(t+r) % 64))
27458 return true
27459 }
27460
27461
27462
27463 for b.Controls[0].Op == OpARM64SRAconst {
27464 sv := b.Controls[0]
27465 s := auxIntToInt64(sv.AuxInt)
27466 x := sv.Args[0]
27467 t := auxIntToInt64(b.AuxInt)
27468 if !(t+s < 64 && sv.Uses == 1) {
27469 break
27470 }
27471 b.resetWithControl(block.BlockARM64TBNZ, x)
27472 b.AuxInt = int64ToAuxInt(t + s)
27473 return true
27474 }
27475
27476
27477
27478 for b.Controls[0].Op == OpARM64SRAconst {
27479 sv := b.Controls[0]
27480 s := auxIntToInt64(sv.AuxInt)
27481 x := sv.Args[0]
27482 t := auxIntToInt64(b.AuxInt)
27483 if !(t+s >= 64 && sv.Uses == 1) {
27484 break
27485 }
27486 b.resetWithControl(block.BlockARM64TBNZ, x)
27487 b.AuxInt = int64ToAuxInt(63)
27488 return true
27489 }
27490 case block.BlockARM64TBZ:
27491
27492
27493 for b.Controls[0].Op == OpARM64XORconst {
27494 v_0 := b.Controls[0]
27495 if auxIntToInt64(v_0.AuxInt) != 1 {
27496 break
27497 }
27498 x := v_0.Args[0]
27499 if auxIntToInt64(b.AuxInt) != 0 {
27500 break
27501 }
27502 b.resetWithControl(block.BlockARM64TBNZ, x)
27503 b.AuxInt = int64ToAuxInt(0)
27504 return true
27505 }
27506
27507
27508
27509 for b.Controls[0].Op == OpARM64SRLconst {
27510 sv := b.Controls[0]
27511 s := auxIntToInt64(sv.AuxInt)
27512 x := sv.Args[0]
27513 t := auxIntToInt64(b.AuxInt)
27514 if !(t+s < 64 && sv.Uses == 1) {
27515 break
27516 }
27517 b.resetWithControl(block.BlockARM64TBZ, x)
27518 b.AuxInt = int64ToAuxInt(t + s)
27519 return true
27520 }
27521
27522
27523
27524 for b.Controls[0].Op == OpARM64SRLconst {
27525 v_0 := b.Controls[0]
27526 s := auxIntToInt64(v_0.AuxInt)
27527 t := auxIntToInt64(b.AuxInt)
27528 if !(t+s >= 64) {
27529 break
27530 }
27531 b.Reset(block.BlockFirst)
27532 return true
27533 }
27534
27535
27536
27537 for b.Controls[0].Op == OpARM64SLLconst {
27538 sv := b.Controls[0]
27539 s := auxIntToInt64(sv.AuxInt)
27540 x := sv.Args[0]
27541 t := auxIntToInt64(b.AuxInt)
27542 if !(t-s >= 0 && sv.Uses == 1) {
27543 break
27544 }
27545 b.resetWithControl(block.BlockARM64TBZ, x)
27546 b.AuxInt = int64ToAuxInt(t - s)
27547 return true
27548 }
27549
27550
27551
27552 for b.Controls[0].Op == OpARM64SLLconst {
27553 v_0 := b.Controls[0]
27554 s := auxIntToInt64(v_0.AuxInt)
27555 t := auxIntToInt64(b.AuxInt)
27556 if !(t-s < 0) {
27557 break
27558 }
27559 b.Reset(block.BlockFirst)
27560 return true
27561 }
27562
27563
27564
27565 for b.Controls[0].Op == OpARM64RORconst {
27566 rv := b.Controls[0]
27567 r := auxIntToInt64(rv.AuxInt)
27568 x := rv.Args[0]
27569 t := auxIntToInt64(b.AuxInt)
27570 if !(rv.Uses == 1) {
27571 break
27572 }
27573 b.resetWithControl(block.BlockARM64TBZ, x)
27574 b.AuxInt = int64ToAuxInt(int64(uint64(t+r) % 64))
27575 return true
27576 }
27577
27578
27579
27580 for b.Controls[0].Op == OpARM64SRAconst {
27581 sv := b.Controls[0]
27582 s := auxIntToInt64(sv.AuxInt)
27583 x := sv.Args[0]
27584 t := auxIntToInt64(b.AuxInt)
27585 if !(t+s < 64 && sv.Uses == 1) {
27586 break
27587 }
27588 b.resetWithControl(block.BlockARM64TBZ, x)
27589 b.AuxInt = int64ToAuxInt(t + s)
27590 return true
27591 }
27592
27593
27594
27595 for b.Controls[0].Op == OpARM64SRAconst {
27596 sv := b.Controls[0]
27597 s := auxIntToInt64(sv.AuxInt)
27598 x := sv.Args[0]
27599 t := auxIntToInt64(b.AuxInt)
27600 if !(t+s >= 64 && sv.Uses == 1) {
27601 break
27602 }
27603 b.resetWithControl(block.BlockARM64TBZ, x)
27604 b.AuxInt = int64ToAuxInt(63)
27605 return true
27606 }
27607 case block.BlockARM64UGE:
27608
27609
27610
27611 for b.Controls[0].Op == OpARM64CMPWconst {
27612 v_0 := b.Controls[0]
27613 if auxIntToInt32(v_0.AuxInt) != 128 {
27614 break
27615 }
27616 x := v_0.Args[0]
27617 if !(ZeroUpper56Bits(x)) {
27618 break
27619 }
27620 b.resetWithControl(block.BlockARM64TBNZ, x)
27621 b.AuxInt = int64ToAuxInt(7)
27622 return true
27623 }
27624
27625
27626
27627 for b.Controls[0].Op == OpARM64CMPconst {
27628 v_0 := b.Controls[0]
27629 if auxIntToInt64(v_0.AuxInt) != 128 {
27630 break
27631 }
27632 x := v_0.Args[0]
27633 if !(ZeroUpper56Bits(x)) {
27634 break
27635 }
27636 b.resetWithControl(block.BlockARM64TBNZ, x)
27637 b.AuxInt = int64ToAuxInt(7)
27638 return true
27639 }
27640
27641
27642
27643 for b.Controls[0].Op == OpARM64FlagConstant {
27644 v_0 := b.Controls[0]
27645 fc := auxIntToFlagConstant(v_0.AuxInt)
27646 if !(fc.uge()) {
27647 break
27648 }
27649 b.Reset(block.BlockFirst)
27650 return true
27651 }
27652
27653
27654
27655 for b.Controls[0].Op == OpARM64FlagConstant {
27656 v_0 := b.Controls[0]
27657 fc := auxIntToFlagConstant(v_0.AuxInt)
27658 if !(!fc.uge()) {
27659 break
27660 }
27661 b.Reset(block.BlockFirst)
27662 b.swapSuccessors()
27663 return true
27664 }
27665
27666
27667 for b.Controls[0].Op == OpARM64InvertFlags {
27668 v_0 := b.Controls[0]
27669 cmp := v_0.Args[0]
27670 b.resetWithControl(block.BlockARM64ULE, cmp)
27671 return true
27672 }
27673 case block.BlockARM64UGT:
27674
27675
27676 for b.Controls[0].Op == OpARM64CMPconst {
27677 v_0 := b.Controls[0]
27678 if auxIntToInt64(v_0.AuxInt) != 0 {
27679 break
27680 }
27681 x := v_0.Args[0]
27682 v0 := b.NewValue0(v_0.Pos, OpARM64CMPconst, types.TypeFlags)
27683 v0.AuxInt = int64ToAuxInt(0)
27684 v0.AddArg(x)
27685 b.resetWithControl(block.BlockARM64NE, v0)
27686 return true
27687 }
27688
27689
27690 for b.Controls[0].Op == OpARM64CMPWconst {
27691 v_0 := b.Controls[0]
27692 if auxIntToInt32(v_0.AuxInt) != 0 {
27693 break
27694 }
27695 x := v_0.Args[0]
27696 v0 := b.NewValue0(v_0.Pos, OpARM64CMPWconst, types.TypeFlags)
27697 v0.AuxInt = int32ToAuxInt(0)
27698 v0.AddArg(x)
27699 b.resetWithControl(block.BlockARM64NE, v0)
27700 return true
27701 }
27702
27703
27704
27705 for b.Controls[0].Op == OpARM64FlagConstant {
27706 v_0 := b.Controls[0]
27707 fc := auxIntToFlagConstant(v_0.AuxInt)
27708 if !(fc.ugt()) {
27709 break
27710 }
27711 b.Reset(block.BlockFirst)
27712 return true
27713 }
27714
27715
27716
27717 for b.Controls[0].Op == OpARM64FlagConstant {
27718 v_0 := b.Controls[0]
27719 fc := auxIntToFlagConstant(v_0.AuxInt)
27720 if !(!fc.ugt()) {
27721 break
27722 }
27723 b.Reset(block.BlockFirst)
27724 b.swapSuccessors()
27725 return true
27726 }
27727
27728
27729 for b.Controls[0].Op == OpARM64InvertFlags {
27730 v_0 := b.Controls[0]
27731 cmp := v_0.Args[0]
27732 b.resetWithControl(block.BlockARM64ULT, cmp)
27733 return true
27734 }
27735 case block.BlockARM64ULE:
27736
27737
27738 for b.Controls[0].Op == OpARM64CMPconst {
27739 v_0 := b.Controls[0]
27740 if auxIntToInt64(v_0.AuxInt) != 0 {
27741 break
27742 }
27743 x := v_0.Args[0]
27744 v0 := b.NewValue0(v_0.Pos, OpARM64CMPconst, types.TypeFlags)
27745 v0.AuxInt = int64ToAuxInt(0)
27746 v0.AddArg(x)
27747 b.resetWithControl(block.BlockARM64EQ, v0)
27748 return true
27749 }
27750
27751
27752 for b.Controls[0].Op == OpARM64CMPWconst {
27753 v_0 := b.Controls[0]
27754 if auxIntToInt32(v_0.AuxInt) != 0 {
27755 break
27756 }
27757 x := v_0.Args[0]
27758 v0 := b.NewValue0(v_0.Pos, OpARM64CMPWconst, types.TypeFlags)
27759 v0.AuxInt = int32ToAuxInt(0)
27760 v0.AddArg(x)
27761 b.resetWithControl(block.BlockARM64EQ, v0)
27762 return true
27763 }
27764
27765
27766
27767 for b.Controls[0].Op == OpARM64FlagConstant {
27768 v_0 := b.Controls[0]
27769 fc := auxIntToFlagConstant(v_0.AuxInt)
27770 if !(fc.ule()) {
27771 break
27772 }
27773 b.Reset(block.BlockFirst)
27774 return true
27775 }
27776
27777
27778
27779 for b.Controls[0].Op == OpARM64FlagConstant {
27780 v_0 := b.Controls[0]
27781 fc := auxIntToFlagConstant(v_0.AuxInt)
27782 if !(!fc.ule()) {
27783 break
27784 }
27785 b.Reset(block.BlockFirst)
27786 b.swapSuccessors()
27787 return true
27788 }
27789
27790
27791 for b.Controls[0].Op == OpARM64InvertFlags {
27792 v_0 := b.Controls[0]
27793 cmp := v_0.Args[0]
27794 b.resetWithControl(block.BlockARM64UGE, cmp)
27795 return true
27796 }
27797 case block.BlockARM64ULT:
27798
27799
27800
27801 for b.Controls[0].Op == OpARM64CMPWconst {
27802 v_0 := b.Controls[0]
27803 if auxIntToInt32(v_0.AuxInt) != 128 {
27804 break
27805 }
27806 x := v_0.Args[0]
27807 if !(ZeroUpper56Bits(x)) {
27808 break
27809 }
27810 b.resetWithControl(block.BlockARM64TBZ, x)
27811 b.AuxInt = int64ToAuxInt(7)
27812 return true
27813 }
27814
27815
27816
27817 for b.Controls[0].Op == OpARM64CMPconst {
27818 v_0 := b.Controls[0]
27819 if auxIntToInt64(v_0.AuxInt) != 128 {
27820 break
27821 }
27822 x := v_0.Args[0]
27823 if !(ZeroUpper56Bits(x)) {
27824 break
27825 }
27826 b.resetWithControl(block.BlockARM64TBZ, x)
27827 b.AuxInt = int64ToAuxInt(7)
27828 return true
27829 }
27830
27831
27832
27833 for b.Controls[0].Op == OpARM64FlagConstant {
27834 v_0 := b.Controls[0]
27835 fc := auxIntToFlagConstant(v_0.AuxInt)
27836 if !(fc.ult()) {
27837 break
27838 }
27839 b.Reset(block.BlockFirst)
27840 return true
27841 }
27842
27843
27844
27845 for b.Controls[0].Op == OpARM64FlagConstant {
27846 v_0 := b.Controls[0]
27847 fc := auxIntToFlagConstant(v_0.AuxInt)
27848 if !(!fc.ult()) {
27849 break
27850 }
27851 b.Reset(block.BlockFirst)
27852 b.swapSuccessors()
27853 return true
27854 }
27855
27856
27857 for b.Controls[0].Op == OpARM64InvertFlags {
27858 v_0 := b.Controls[0]
27859 cmp := v_0.Args[0]
27860 b.resetWithControl(block.BlockARM64UGT, cmp)
27861 return true
27862 }
27863 case block.BlockARM64Z:
27864
27865
27866
27867 for b.Controls[0].Op == OpARM64SUB {
27868 sub := b.Controls[0]
27869 y := sub.Args[1]
27870 x := sub.Args[0]
27871 if !(sub.Uses == 1) {
27872 break
27873 }
27874 v0 := b.NewValue0(sub.Pos, OpARM64CMP, types.TypeFlags)
27875 v0.AddArg2(x, y)
27876 b.resetWithControl(block.BlockARM64EQ, v0)
27877 return true
27878 }
27879
27880
27881
27882 for b.Controls[0].Op == OpARM64SUBconst {
27883 sub := b.Controls[0]
27884 c := auxIntToInt64(sub.AuxInt)
27885 y := sub.Args[0]
27886 if !(sub.Uses == 1) {
27887 break
27888 }
27889 v0 := b.NewValue0(sub.Pos, OpARM64CMPconst, types.TypeFlags)
27890 v0.AuxInt = int64ToAuxInt(c)
27891 v0.AddArg(y)
27892 b.resetWithControl(block.BlockARM64EQ, v0)
27893 return true
27894 }
27895
27896
27897
27898 for b.Controls[0].Op == OpARM64ANDconst {
27899 v_0 := b.Controls[0]
27900 c := auxIntToInt64(v_0.AuxInt)
27901 x := v_0.Args[0]
27902 if !(oneBit(c)) {
27903 break
27904 }
27905 b.resetWithControl(block.BlockARM64TBZ, x)
27906 b.AuxInt = int64ToAuxInt(int64(ntz64(c)))
27907 return true
27908 }
27909
27910
27911
27912 for b.Controls[0].Op == OpARM64SRLconst {
27913 s := b.Controls[0]
27914 if auxIntToInt64(s.AuxInt) != 63 {
27915 break
27916 }
27917 x := s.Args[0]
27918 if !(s.Uses == 1) {
27919 break
27920 }
27921 b.resetWithControl(block.BlockARM64TBZ, x)
27922 b.AuxInt = int64ToAuxInt(63)
27923 return true
27924 }
27925
27926
27927
27928 for b.Controls[0].Op == OpARM64SRAconst {
27929 s := b.Controls[0]
27930 if auxIntToInt64(s.AuxInt) != 63 {
27931 break
27932 }
27933 x := s.Args[0]
27934 if !(s.Uses == 1) {
27935 break
27936 }
27937 b.resetWithControl(block.BlockARM64TBZ, x)
27938 b.AuxInt = int64ToAuxInt(63)
27939 return true
27940 }
27941
27942
27943 for b.Controls[0].Op == OpARM64MOVDconst {
27944 v_0 := b.Controls[0]
27945 if auxIntToInt64(v_0.AuxInt) != 0 {
27946 break
27947 }
27948 b.Reset(block.BlockFirst)
27949 return true
27950 }
27951
27952
27953
27954 for b.Controls[0].Op == OpARM64MOVDconst {
27955 v_0 := b.Controls[0]
27956 c := auxIntToInt64(v_0.AuxInt)
27957 if !(c != 0) {
27958 break
27959 }
27960 b.Reset(block.BlockFirst)
27961 b.swapSuccessors()
27962 return true
27963 }
27964 case block.BlockARM64ZW:
27965
27966
27967
27968 for b.Controls[0].Op == OpARM64SUB {
27969 sub := b.Controls[0]
27970 y := sub.Args[1]
27971 x := sub.Args[0]
27972 if !(sub.Uses == 1) {
27973 break
27974 }
27975 v0 := b.NewValue0(sub.Pos, OpARM64CMPW, types.TypeFlags)
27976 v0.AddArg2(x, y)
27977 b.resetWithControl(block.BlockARM64EQ, v0)
27978 return true
27979 }
27980
27981
27982
27983 for b.Controls[0].Op == OpARM64SUBconst {
27984 sub := b.Controls[0]
27985 c := auxIntToInt64(sub.AuxInt)
27986 y := sub.Args[0]
27987 if !(sub.Uses == 1) {
27988 break
27989 }
27990 v0 := b.NewValue0(sub.Pos, OpARM64CMPWconst, types.TypeFlags)
27991 v0.AuxInt = int32ToAuxInt(int32(c))
27992 v0.AddArg(y)
27993 b.resetWithControl(block.BlockARM64EQ, v0)
27994 return true
27995 }
27996
27997
27998
27999 for b.Controls[0].Op == OpARM64ANDconst {
28000 v_0 := b.Controls[0]
28001 c := auxIntToInt64(v_0.AuxInt)
28002 x := v_0.Args[0]
28003 if !(oneBit(int64(uint32(c)))) {
28004 break
28005 }
28006 b.resetWithControl(block.BlockARM64TBZ, x)
28007 b.AuxInt = int64ToAuxInt(int64(ntz64(int64(uint32(c)))))
28008 return true
28009 }
28010
28011
28012
28013 for b.Controls[0].Op == OpARM64MOVDconst {
28014 v_0 := b.Controls[0]
28015 c := auxIntToInt64(v_0.AuxInt)
28016 if !(int32(c) == 0) {
28017 break
28018 }
28019 b.Reset(block.BlockFirst)
28020 return true
28021 }
28022
28023
28024
28025 for b.Controls[0].Op == OpARM64MOVDconst {
28026 v_0 := b.Controls[0]
28027 c := auxIntToInt64(v_0.AuxInt)
28028 if !(int32(c) != 0) {
28029 break
28030 }
28031 b.Reset(block.BlockFirst)
28032 b.swapSuccessors()
28033 return true
28034 }
28035 }
28036 return false
28037 }
28038
View as plain text